Merge pull request #136 from aboccag/single-character-ocr

Add per-character confidence results in OCR output

Author: sdcb

src/Sdcb.PaddleOCR/OcrRecognizerResultSingleChar.cs

@@ -0,0 +1,35 @@
+namespace Sdcb.PaddleOCR;
+
+/// <summary>
+///  A record struct representing a single character recognition result from an OCR operation.
+/// </summary>
+public record struct OcrRecognizerResultSingleChar
+{
+    /// <summary>
+    /// A single character recognized from the image.
+    /// </summary>
+    public string Character { get; init; }
+
+    /// <summary>
+    /// The confidence score of the text recognition.
+    /// </summary>
+    public float Score { get; init; }
+
+    /// <summary>
+    /// The index position of this character within the recognized text.
+    /// </summary>
+    public int Index { get; init; }
+
+    /// <summary>
+    ///  Initializes a new instance of the <see cref="OcrRecognizerResultSingleChar"/> record.
+    /// </summary>
+    /// <param name="character">The recognized character.</param>
+    /// <param name="score">The confidence score of the character recognition.</param>
+    /// <param name="index">The index position of this character within the recognized text.</param>
+    public OcrRecognizerResultSingleChar(string character, float score, int index)
+    {
+        Character = character;
+        Score = score;
+        Index = index;
+    }
+}

src/Sdcb.PaddleOCR/PaddleOcrAll.cs

@@ -146,7 +146,7 @@ public PaddleOcrResult Run(Mat src, int recognizeBatchSize = 0)
         try
         {
             return new PaddleOcrResult(Recognizer.Run(mats, recognizeBatchSize)
-                .Select((result, i) => new PaddleOcrResultRegion(rects[i], result.Text, result.Score))
+                .Select((result, i) => new PaddleOcrResultRegion(rects[i], result.Text, result.Score, result.SingleChars))
                 .ToArray());
         }
         finally

src/Sdcb.PaddleOCR/PaddleOcrRecognizer.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Collections.Generic;
 
 namespace Sdcb.PaddleOCR;
 
@@ -174,6 +175,8 @@ private PaddleOcrRecognizerResult[] RunMulti(Mat[] srcs)
                             StringBuilder sb = new();
                             int lastIndex = 0;
                             float score = 0;
+                            List<OcrRecognizerResultSingleChar> singleChars = new();
+                            int charIndex = 0;
                             for (int n = 0; n < charCount; ++n)
                             {
                                 using Mat mat = Mat.FromPixelData(1, labelCount, MatType.CV_32FC1, dataPtr + (n + i * charCount) * labelCount * sizeof(float));
@@ -183,12 +186,20 @@ private PaddleOcrRecognizerResult[] RunMulti(Mat[] srcs)
                                 if (maxIdx[1] > 0 && (!(n > 0 && maxIdx[1] == lastIndex)))
                                 {
                                     score += (float)maxVal;
-                                    sb.Append(Model.GetLabelByIndex(maxIdx[1]));
+                                    string character = Model.GetLabelByIndex(maxIdx[1]);
+                                    sb.Append(character);
+                                    
+                                    singleChars.Add(new OcrRecognizerResultSingleChar(
+                                        character,
+                                        (float)maxVal,
+                                        charIndex
+                                    ));
+                                    charIndex++;
                                 }
                                 lastIndex = maxIdx[1];
                             }
 
-                            return new PaddleOcrRecognizerResult(sb.ToString(), score / sb.Length);
+                            return new PaddleOcrRecognizerResult(sb.ToString(), score / sb.Length, singleChars);
                         })
                         .ToArray();
                 }

src/Sdcb.PaddleOCR/PaddleOcrRecognizerResult.cs

@@ -1,4 +1,6 @@
-namespace Sdcb.PaddleOCR;
+using System.Collections.Generic;
+
+namespace Sdcb.PaddleOCR;
 
 /// <summary>
 /// A struct representing the result of an image recognition operation using Paddle OCR.
@@ -14,15 +16,22 @@ public readonly record struct PaddleOcrRecognizerResult
     /// The confidence score of the text recognition.
     /// </summary>
     public float Score { get; init; }
+    
+    /// <summary>
+    /// A read-only list of single character recognition results.
+    /// </summary>
+    public IReadOnlyList<OcrRecognizerResultSingleChar> SingleChars { get; init; }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PaddleOcrRecognizerResult"/> struct.
     /// </summary>
     /// <param name="text">The recognized text from the image.</param>
     /// <param name="score">The confidence score of the text recognition.</param>
-    public PaddleOcrRecognizerResult(string text, float score)
+    /// <param name="singleChars">A list of single character recognition results.</param>
+    public PaddleOcrRecognizerResult(string text, float score, IReadOnlyList<OcrRecognizerResultSingleChar> singleChars)
     {
         Text = text;
         Score = score;
+        SingleChars = singleChars ?? new List<OcrRecognizerResultSingleChar>();
     }
-}
+}

src/Sdcb.PaddleOCR/PaddleOcrResultRegion.cs

@@ -1,8 +1,9 @@
 using OpenCvSharp;
+using System.Collections.Generic;
 
 namespace Sdcb.PaddleOCR;
 
 /// <summary>
 /// Represents a region detected in an OCR result using Paddle OCR.
 /// </summary>
-public record struct PaddleOcrResultRegion(RotatedRect Rect, string Text, float Score);
+public record struct PaddleOcrResultRegion(RotatedRect Rect, string Text, float Score, List<OcrRecognizerResultSingleChar> OcrRecognizerResultSingleChars);

tests/Sdcb.PaddleOCR.Tests/SingleCharTest.cs

@@ -0,0 +1,58 @@
+using OpenCvSharp;
+using Sdcb.PaddleOCR.Models;
+using Sdcb.PaddleOCR.Models.Local;
+using System.Runtime.InteropServices;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Sdcb.PaddleOCR.Tests;
+
+public class SingleCharTest(ITestOutputHelper testOutputHelper)
+{
+    [Fact]
+    public void SingleCharRecognitionTest()
+    {
+        testOutputHelper.WriteLine(
+            $"Running SingleChar test on {RuntimeInformation.OSDescription} ({RuntimeInformation.OSArchitecture})");
+
+        FullOcrModel model = LocalFullModels.ChineseV5;
+        byte[] sampleImageData = File.ReadAllBytes(@"./samples/vsext.png");
+
+        using PaddleOcrAll all = new(model)
+        {
+            AllowRotateDetection = true,
+            Enable180Classification = false,
+        };
+
+        using Mat src = Cv2.ImDecode(sampleImageData, ImreadModes.Color);
+        PaddleOcrResult result = all.Run(src);
+        testOutputHelper.WriteLine("Detected all texts: \n" + result.Text);
+
+        Assert.NotEmpty(result.Regions);
+
+        foreach (PaddleOcrResultRegion region in result.Regions)
+        {
+            testOutputHelper.WriteLine($"Text: {region.Text}, Score: {region.Score}");
+            testOutputHelper.WriteLine($"SingleChars count: {region.SingleChars.Count}");
+
+            // Verify single characters exist
+            Assert.NotEmpty(region.SingleChars);
+
+            // Verify indices are properly set and sequential
+            for (int i = 0; i < region.SingleChars.Count; i++)
+            {
+                OcrRecognizerResultSingleChar singleChar = region.SingleChars[i];
+                Assert.Equal(i, singleChar.Index);
+                Assert.NotNull(singleChar.Character);
+                Assert.True(singleChar.Score > 0, $"Character '{singleChar.Character}' should have a positive score");
+
+                testOutputHelper.WriteLine(
+                    $"  Char[{singleChar.Index}]: '{singleChar.Character}', Score: {singleChar.Score:F3}");
+            }
+
+            // Verify the concatenated single characters match the full text
+            string reconstructedText = string.Join("", region.SingleChars.Select(c => c.Character));
+            Assert.Equal(region.Text, reconstructedText);
+        }
+    }
+}