绿色上网，从小孩抓起。
没有长篇大论，也不讲茴香豆的茴有多少种写法。
PaddleOCR 是百度开源的OCR（光学文本识别）计算机视觉AI模型，在中文识别领域可以说是”遥遥领先于同行“的存在，感谢百度开源，Respect !

这些优秀的AI模型都有一个共同点，好像没有C#的示例。
没有关系，我们dotnet er还是会把它造出来。

该系列总共有三个模型，onnx转换在paddle文档里有。

• det.onnx Detection 文本检测模型。
• cls.onnx Classification 文本方向分类模型。
• rec.onnx Recognition 文本识别模型。

这篇文章给大家汇报的是第一个模型：det.onnx Detection 文本检测模型，的推理过程和代码实现，不喜欢撸代码的小伙伴请看前半段。

先看结果，稳定军心

模型的输入输出

平均值和标准差在训练的配置文件中可以找到

• 平均值（mean）： [0.485f, 0.456f, 0.406f]

• 标准差（stddev）: [0.229f, 0.224f, 0.225f]

  
  

Inputs float[p2o.DynamicDimension.0,3,p2o.DynamicDimension.1,p2o.DynamicDimension.2]

• p2o.DynamicDimension.0 批次大小，动态
• 3 通道数 (排列方式BGR)
• p2o.DynamicDimension.1 图像宽度，动态
• p2o.DynamicDimension.2 图像高度，动态

组合起来是一个四维数组，结合均值和标准差举个例子

[
  [
    [
      [ (B / 255f - mean) / stddev, (G / 255f - mean) / stddev, (R / 255f - mean) / stddev ]
    ]
  ]
]

Ouputs float[p2o.DynamicDimension.3,1,p2o.DynamicDimension.4,p2o.DynamicDimension.5]

• p2o.DynamicDimension.3 批次大小，动态
• 1 通道数
• p2o.DynamicDimension.4 图像宽度，动态
• p2o.DynamicDimension.5 图像高度，动态

组合起来是一个四维数组，举个例子

[
  [
    [
      [ 0f, 0.2f, 0.3f ]
    ]
  ]
]

• 0f 图像坐标 [0,0] 处是文本的概率
• 0.2f 图像坐标 [0,1] 处是文本的概率
• 0.3f 图像坐标 [0,2] 处是文本的概率

----------华丽的分割线 ---------

理论结束了，代码稍微难一点，C#依旧稳定发挥

请先准备两个包：

• SixLabors.ImageSharp 处理图像
• Onnxruntime 模型推理

图像预处理

private static Tensor<float> ImageToTensor(Image<Rgb24> image)
{
    float[] mean = [0.485f, 0.456f, 0.406f];
    float[] stddev = [0.229f, 0.224f, 0.225f];

    Tensor<float> result = new DenseTensor<float>([1, 3, image.Height, image.Width]);

    for (int w = 0; w < image.Width; w++)
    {
        for (int h = 0; h < image.Height; h++)
        {
            var pixel = image[w, h];
            result[0, 0, h, w] = (pixel.R / 255f - mean[0]) / stddev[0];
            result[0, 1, h, w] = (pixel.G / 255f - mean[1]) / stddev[1];
            result[0, 2, h, w] = (pixel.B / 255f - mean[2]) / stddev[2];
        }
    }

    return result;
}

Points to Rectangles ，广度优先搜索

 private static List<RectangleF> GetBoundingBoxes(bool[,] binaryMap)
 {
     var boxes = new List<RectangleF>();
     int height = binaryMap.GetLength(0);
     int width = binaryMap.GetLength(1);
     bool[,] visited = new bool[height, width];

     for (int h = 0; h < height; h++)
     {
         for (int w = 0; w < width; w++)
         {
             if (binaryMap[h, w] && !visited[h, w])
             {
                 RectangleF box = ExpandBoundingBox(binaryMap, visited, h, w);
                 boxes.Add(box);
             }
         }
     }

     return boxes;
 }

 private static RectangleF ExpandBoundingBox(bool[,] binaryMap, bool[,] visited, int startH, int startW)
 {
     int minH = startH, maxH = startH;
     int minW = startW, maxW = startW;

     Stack<(int h, int w)> stack = new();
     stack.Push((startH, startW));

     while (stack.Count > 0)
     {
         (int h, int w) = stack.Pop();

         if (h < 0 || h >= binaryMap.GetLength(0) || w < 0 || w >= binaryMap.GetLength(1))
         {
             continue;
         }

         if (visited[h, w] || !binaryMap[h, w])
         {
             continue;
         }

         visited[h, w] = true;

         minH = Math.Min(minH, h);
         maxH = Math.Max(maxH, h);
         minW = Math.Min(minW, w);
         maxW = Math.Max(maxW, w);

         stack.Push((h - 1, w));
         stack.Push((h + 1, w));
         stack.Push((h, w - 1));
         stack.Push((h, w + 1));
     }

     float x = minW - (maxH - minH);
     float y = minH - (maxH - minH);
     float width = maxW - minW + (maxH - minH) * 2;
     float height = (maxH - minH) * 3;

     return new RectangleF(x, y, width, height);
 }

模型推理、结果二值化处理

public IEnumerable<RectangleF> Detection(Image<Rgb24> image, float threshold = 0.95f)
{
    using var inputImage = image.Clone(x => x.Resize(new ResizeOptions
    {
        Size = new Size(IM_WIDTH, IM_HEIGHT),
        Mode = ResizeMode.Pad
    }));

    var input = ImageToTensor(inputImage);

    List<NamedOnnxValue> inputs = [NamedOnnxValue.CreateFromTensor(INPUT_NAME, input)];

    using IDisposableReadOnlyCollection<DisposableNamedOnnxValue> results = _detSession.Run(inputs);

    Tensor<float> output = results[0].AsTensor<float>();

    bool[,] binaryMap = new bool[IM_HEIGHT, IM_WIDTH];

    for (int h = 0; h < IM_HEIGHT; h++)
    {
        for (int w = 0; w < IM_WIDTH; w++)
        {
            float score = output[0, 0, h, w];
            binaryMap[h, w] = score > threshold;
        }
    }

    (float neww, float newh, float rate) = CalculateTransform(image.Width, image.Height, inputImage.Width, inputImage.Height);

    float offsetX = (inputImage.Width - neww) / 2f / rate;
    float offsetY = (inputImage.Height - newh) / 2f / rate;

    List<RectangleF> rectangles = GetBoundingBoxes(binaryMap);

    foreach (var item in rectangles)
    {
        var rectangle = new RectangleF
        {
            X = item.X / rate - offsetX,
            Y = item.Y / rate - offsetY,
            Width = item.Width / rate,
            Height = item.Height / rate
        };

        yield return rectangle;
    }
}