devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C# PaddleInference OCR识别 学习研究Demo_paddle ocr c#

作者：从前慢现在也慢 | 2024-06-09 05:27:09

赞

踩

paddle ocr c#

目录

说明

效果

项目

代码

下载 

说明

基于开源项目 https://github.com/sdcb/PaddleSharp

VS2022+.net4.8+ OpenCvSharp4+Sdcb.PaddleInference

效果

项目

代码

using Sdcb.PaddleInference.Native;
using Sdcb.PaddleInference;
using System;
using System.Collections.Generic;
using OpenCvSharp.Extensions;
using OpenCvSharp;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Globalization;
using System.IO;

namespace PaddleInference_OCR识别
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        Bitmap bmp;
        string fileFilter = "*.*|*.bmp;*.jpg;*.jpeg;*.tiff;*.tiff;*.png";
        string img = "";
        string startupPath = "";

        int MaxSize = 1536;
        float? BoxThreshold = 0.3f;
        float? BoxScoreThreahold = 0.7f;
        int? DilatedSize = 2;
        int MinSize = 3;
        float UnclipRatio = 2.0f;

        Mat src;
        PaddlePredictor det_predictor;

        RotatedRect[] rects;

        bool Enable180Classification { get; set; } = true;
        bool AllowRotateDetection { get; set; } = true;
        double RotateThreshold { get; } = 0.75;
        Mat[] mats;
        PaddlePredictor cls_predictor;

        OcrShape recShape = new OcrShape(3, 320, 48);
        PaddlePredictor rec_predictor;

        public IReadOnlyList<string> Labels;

        DateTime dt1 = DateTime.Now;
        DateTime dt2 = DateTime.Now;

        private unsafe void Form1_Load(object sender, EventArgs e)
        {

            string startupPath = Application.StartupPath;

            IntPtr det_ptr = PaddleNative.PD_ConfigCreate();

            Encoding PaddleEncoding = Environment.OSVersion.Platform == PlatformID.Win32NT ? Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.ANSICodePage) : Encoding.UTF8;

            //检测模型路径
            String det_programPath = startupPath + "\\ch_PP-OCRv3_det\\inference.pdmodel";
            String det_paramsPath = startupPath + "\\ch_PP-OCRv3_det\\inference.pdiparams";

            //方式一
            //byte[] programBytes = PaddleEncoding.GetBytes(det_programPath);
            //byte[] paramsBytes = PaddleEncoding.GetBytes(det_paramsPath);
            //fixed (byte* programPtr = programBytes)
            //fixed (byte* paramsPtr = paramsBytes)
            //{
            //    PaddleNative.PD_ConfigSetModel(det_ptr, (IntPtr)programPtr, (IntPtr)paramsPtr);
            //}

            //方式二  读自己加密后的模型文件,解密后写入byte[]
            Stream Steam = new FileStream(det_programPath, FileMode.Open, FileAccess.Read, FileShare.Read);
            byte[] programBuffer = new byte[Steam.Length];
            Steam.Read(programBuffer, 0, programBuffer.Length);

            Steam = new FileStream(det_paramsPath, FileMode.Open, FileAccess.Read, FileShare.Read);
            byte[] paramsBuffer = new byte[Steam.Length];
            Steam.Read(paramsBuffer, 0, paramsBuffer.Length);

            fixed (byte* pprogram = programBuffer)
            fixed (byte* pparams = paramsBuffer)
            {
                PaddleNative.PD_ConfigSetModelBuffer(det_ptr,
                    (IntPtr)pprogram, programBuffer.Length,
                    (IntPtr)pparams, paramsBuffer.Length);
            }

            det_predictor = new PaddlePredictor(PaddleNative.PD_PredictorCreate(det_ptr));

            //方向分类模型
            IntPtr cls_ptr = PaddleNative.PD_ConfigCreate();

            String cls_programPath = startupPath + "\\ch_ppocr_mobile_v2.0_cls\\inference.pdmodel";
            String cls_paramsPath = startupPath + "\\ch_ppocr_mobile_v2.0_cls\\inference.pdiparams";

            byte[] programBytes = PaddleEncoding.GetBytes(cls_programPath);
            byte[] paramsBytes = PaddleEncoding.GetBytes(cls_paramsPath);
            fixed (byte* programPtr = programBytes)
            fixed (byte* paramsPtr = paramsBytes)
            {
                PaddleNative.PD_ConfigSetModel(cls_ptr, (IntPtr)programPtr, (IntPtr)paramsPtr);
            }

            cls_predictor = new PaddlePredictor(PaddleNative.PD_PredictorCreate(cls_ptr));

            //识别模型
            IntPtr rec_ptr = PaddleNative.PD_ConfigCreate();

            String rec_programPath = startupPath + "\\ch_PP-OCRv3_rec\\inference.pdmodel";
            String rec_paramsPath = startupPath + "\\ch_PP-OCRv3_rec\\inference.pdiparams";

            byte[] rec_programBytes = PaddleEncoding.GetBytes(rec_programPath);
            byte[] rec_paramsBytes = PaddleEncoding.GetBytes(rec_paramsPath);
            fixed (byte* rec_programPtr = rec_programBytes)
            fixed (byte* rec_paramsPtr = rec_paramsBytes)
            {
                PaddleNative.PD_ConfigSetModel(rec_ptr, (IntPtr)rec_programPtr, (IntPtr)rec_paramsPtr);
            }

            rec_predictor = new PaddlePredictor(PaddleNative.PD_PredictorCreate(rec_ptr));

            //Labels
            String labelsPath = startupPath + "\\ppocr_keys.txt";
            Steam = new FileStream(labelsPath, FileMode.Open, FileAccess.Read, FileShare.Read);
            StreamReader reader = new StreamReader(Steam);
            List<string> tempList = new List<string>();
            while (!reader.EndOfStream)
            {
                tempList.Add(reader.ReadLine());
            }
            reader.Dispose();
            Steam.Dispose();
            Labels = tempList;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.Filter = fileFilter;
            if (ofd.ShowDialog() != DialogResult.OK) return;

            pictureBox1.Image = null;

            img = ofd.FileName;
            bmp = new Bitmap(img);
            pictureBox1.Image = new Bitmap(img);
            textBox1.Text = "";
        }

        private void button2_Click(object sender, EventArgs e)
        {
            textBox1.Text = "";
            Application.DoEvents();
            if (img == "")
            {
                return;
            }
            dt1 = DateTime.Now;
            src = Cv2.ImRead(img);

            Mat resized = MatResize(src, MaxSize);
            //Cv2.ImShow("resized", resized);
            Mat padded = MatPadding32(resized);
            //Cv2.ImShow("padded", padded);
            Mat normalized = Normalize(padded);
            Cv2.ImShow("normalized", normalized);
            OpenCvSharp.Size resizedSize = resized.Size();
            using (PaddleTensor input = det_predictor.GetInputTensor(det_predictor.InputNames[0]))
            {
                input.Shape = new[] { 1, 3, normalized.Rows, normalized.Cols };
                float[] setData = ExtractMat(normalized);
                input.SetData(setData);
            }

            if (!det_predictor.Run())
            {
                throw new Exception("PaddlePredictor(Detector) run failed.");
            }

            using (PaddleTensor output = det_predictor.GetOutputTensor(det_predictor.OutputNames[0]))
            {
                float[] data = output.GetData<float>();
                int[] shape = output.Shape;

                Mat pred = new Mat(shape[2], shape[3], MatType.CV_32FC1, data);
                Cv2.ImShow("pred", pred);
                Mat cbuf = new Mat();

                Mat roi = pred[0, resizedSize.Height, 0, resizedSize.Width];
                roi.ConvertTo(cbuf, MatType.CV_8UC1, 255);
                //Cv2.ImShow("roi", roi);
                Mat dilated = new Mat();
                Mat binary = BoxThreshold != null ?
                   cbuf.Threshold((int)(BoxThreshold * 255), 255, ThresholdTypes.Binary) :
                   cbuf;
                //Cv2.ImShow("binary", binary);
                if (DilatedSize != null)
                {
                    Mat ones = Cv2.GetStructuringElement(MorphShapes.Rect, new OpenCvSharp.Size(DilatedSize.Value, DilatedSize.Value));
                    Cv2.Dilate(binary, dilated, ones);
                    ones.Dispose();
                }
                else
                {
                    Cv2.CopyTo(binary, dilated);
                }
                //Cv2.ImShow("dilated", dilated);
                OpenCvSharp.Point[][] contours = dilated.FindContoursAsArray(RetrievalModes.List, ContourApproximationModes.ApproxSimple);

                OpenCvSharp.Size size = src.Size();
                double scaleRate = 1.0 * src.Width / resizedSize.Width;

                rects = contours
                    .Where(x => BoxScoreThreahold == null || GetScore(x, pred) > BoxScoreThreahold)
                    .Select(x => Cv2.MinAreaRect(x))
                    .Where(x => x.Size.Width > MinSize && x.Size.Height > MinSize)
                    .Select(rect =>
                    {
                        float minEdge = Math.Min(rect.Size.Width, rect.Size.Height);
                        Size2f newSize = new Size2f(
                            (rect.Size.Width + UnclipRatio * minEdge) * scaleRate,
                            (rect.Size.Height + UnclipRatio * minEdge) * scaleRate);
                        RotatedRect largerRect = new RotatedRect(rect.Center * scaleRate, newSize, rect.Angle);
                        return largerRect;
                    })
                    .OrderBy(v => v.Center.Y)
                    .ThenBy(v => v.Center.X)
                    .ToArray();

                binary.Dispose();
                roi.Dispose();
                cbuf.Dispose();
                pred.Dispose();
                dilated.Dispose();


                dt2 = DateTime.Now;
                StringBuilder sb = new StringBuilder();
                sb.AppendLine("-----------------------------------\n");
                sb.AppendLine("耗时:" + (dt2 - dt1).TotalMilliseconds + "ms\n");

                textBox1.Text = sb.ToString();

                //绘图
                Mat src2 = Cv2.ImRead(img);
                for (int i = 0; i < rects.Length; i++)
                {
                    Scalar scalar = Scalar.RandomColor();
                    List<OpenCvSharp.Point> temp = new List<OpenCvSharp.Point>();
                    foreach (var item2 in rects[i].Points())
                    {
                        temp.Add(new OpenCvSharp.Point(item2.X, item2.Y));
                    }
                    List<List<OpenCvSharp.Point>> lltemp = new List<List<OpenCvSharp.Point>>();
                    lltemp.Add(temp);
                    Cv2.Polylines(src2, lltemp, true, scalar);
                }

                if (pictureBox1.Image != null)
                {
                    pictureBox1.Image.Dispose();
                }

                pictureBox1.Image = BitmapConverter.ToBitmap(src2);
                src2.Dispose();

            }
        }

        private float GetScore(OpenCvSharp.Point[] contour, Mat pred)
        {
            int width = pred.Width;
            int height = pred.Height;
            int[] boxX = contour.Select(v => v.X).ToArray();
            int[] boxY = contour.Select(v => v.Y).ToArray();

            int xmin = Clamp(boxX.Min(), 0, width - 1);
            int xmax = Clamp(boxX.Max(), 0, width - 1);
            int ymin = Clamp(boxY.Min(), 0, height - 1);
            int ymax = Clamp(boxY.Max(), 0, height - 1);

            OpenCvSharp.Point[] rootPoints = contour
                .Select(v => new OpenCvSharp.Point(v.X - xmin, v.Y - ymin))
                .ToArray();
            Mat mask = new Mat(ymax - ymin + 1, xmax - xmin + 1, MatType.CV_8UC1, Scalar.Black);
            mask.FillPoly(new[] { rootPoints }, new Scalar(1));

            Mat croppedMat = pred[ymin, ymax + 1, xmin, xmax + 1];
            float score = (float)croppedMat.Mean(mask).Val0;
            return score;
        }

        public int Clamp(int val, int min, int max)
        {
            if (val < min)
            {
                return min;
            }
            else if (val > max)
            {
                return max;
            }
            return val;
        }

        float[] ExtractMat(Mat src)
        {
            int rows = src.Rows;
            int cols = src.Cols;
            float[] array = new float[rows * cols * 3];
            GCHandle gCHandle = default(GCHandle);
            try
            {
                gCHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
                IntPtr intPtr = gCHandle.AddrOfPinnedObject();
                for (int i = 0; i < src.Channels(); i++)
                {
                    Mat dest = new Mat(rows, cols, MatType.CV_32FC1, intPtr + i * rows * cols * 4, 0L);
                    Cv2.ExtractChannel(src, dest, i);
                    dest.Dispose();
                }
                return array;
            }
            finally
            {
                gCHandle.Free();
            }
        }

        private Mat MatResize(Mat src, int? maxSize)
        {
            if (maxSize == null) return src.Clone();

            OpenCvSharp.Size size = src.Size();
            int longEdge = Math.Max(size.Width, size.Height);
            double scaleRate = 1.0 * maxSize.Value / longEdge;

            return scaleRate < 1.0 ?
                src.Resize(OpenCvSharp.Size.Zero, scaleRate, scaleRate) :
                src.Clone();
        }

        private Mat MatPadding32(Mat src)
        {
            OpenCvSharp.Size size = src.Size();
            OpenCvSharp.Size newSize = new OpenCvSharp.Size(
                32 * Math.Ceiling(1.0 * size.Width / 32),
                32 * Math.Ceiling(1.0 * size.Height / 32));

            return src.CopyMakeBorder(0, newSize.Height - size.Height, 0, newSize.Width - size.Width, BorderTypes.Constant, Scalar.Black);
        }

        private Mat Normalize(Mat src)
        {
            Mat normalized = new Mat();
            src.ConvertTo(normalized, MatType.CV_32FC3, 1.0 / 255);
            Mat[] bgr = normalized.Split();
            float[] scales = new[] { 1 / 0.229f, 1 / 0.224f, 1 / 0.225f };
            float[] means = new[] { 0.485f, 0.456f, 0.406f };
            for (int i = 0; i < bgr.Length; ++i)
            {
                bgr[i].ConvertTo(bgr[i], MatType.CV_32FC1, 1.0 * scales[i], (0.0 - means[i]) * scales[i]);
            }
            normalized.Dispose();
            Mat dest = new Mat();
            Cv2.Merge(bgr, dest);
            foreach (Mat channel in bgr)
            {
                channel.Dispose();
            }
            return dest;
        }

        private Mat GetRotateCropImage(Mat src, RotatedRect rect)
        {
            bool wider = rect.Size.Width > rect.Size.Height;
            float angle = rect.Angle;
            OpenCvSharp.Size srcSize = src.Size();
            Rect boundingRect = rect.BoundingRect();

            int expTop = Math.Max(0, 0 - boundingRect.Top);
            int expBottom = Math.Max(0, boundingRect.Bottom - srcSize.Height);
            int expLeft = Math.Max(0, 0 - boundingRect.Left);
            int expRight = Math.Max(0, boundingRect.Right - srcSize.Width);

            Rect rectToExp = boundingRect + new OpenCvSharp.Point(expTop, expLeft);
            Rect roiRect = Rect.FromLTRB(
                boundingRect.Left + expLeft,
                boundingRect.Top + expTop,
                boundingRect.Right - expRight,
                boundingRect.Bottom - expBottom);
            Mat boundingMat = src[roiRect];
            Mat expanded = boundingMat.CopyMakeBorder(expTop, expBottom, expLeft, expRight, BorderTypes.Replicate);
            Point2f[] rp = rect.Points()
                .Select(v => new Point2f(v.X - rectToExp.X, v.Y - rectToExp.Y))
                .ToArray();

            Point2f[] srcPoints = new[] { rp[0], rp[3], rp[2], rp[1] };

            if (wider == true && angle >= 0 && angle < 45)
            {
                srcPoints = new[] { rp[1], rp[2], rp[3], rp[0] };
            }

            var ptsDst0 = new Point2f(0, 0);
            var ptsDst1 = new Point2f(rect.Size.Width, 0);
            var ptsDst2 = new Point2f(rect.Size.Width, rect.Size.Height);
            var ptsDst3 = new Point2f(0, rect.Size.Height);

            Mat matrix = Cv2.GetPerspectiveTransform(srcPoints, new[] { ptsDst0, ptsDst1, ptsDst2, ptsDst3 });

            Mat dest = expanded.WarpPerspective(matrix, new OpenCvSharp.Size(rect.Size.Width, rect.Size.Height), InterpolationFlags.Nearest, BorderTypes.Replicate);

            if (!wider)
            {
                Cv2.Transpose(dest, dest);
            }
            else if (angle > 45)
            {
                Cv2.Flip(dest, dest, FlipMode.X);
            }

            boundingMat.Dispose();
            expanded.Dispose();
            matrix.Dispose();

            return dest;
        }

        private Rect GetCropedRect(Rect rect, OpenCvSharp.Size size)
        {
            return Rect.FromLTRB(
                Clamp(rect.Left, 0, size.Width),
                Clamp(rect.Top, 0, size.Height),
                Clamp(rect.Right, 0, size.Width),
                Clamp(rect.Bottom, 0, size.Height));
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            det_predictor.Dispose();
            rec_predictor.Dispose();
        }

        /// <summary>
        /// 方向检测
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button4_Click(object sender, EventArgs e)
        {
            textBox1.Text = "";
            Application.DoEvents();
            if (rects == null)
            {
                return;
            }
            if (rects == null)
            {
                return;
            }
            dt1 = DateTime.Now;
            mats =
               rects.Select(rect =>
               {
                   Mat roi = AllowRotateDetection ? GetRotateCropImage(src, rect) : src[GetCropedRect(rect.BoundingRect(), src.Size())];
                   return Enable180Classification ? CLSPredictorRun(roi) : roi;
               })
               .ToArray();

            dt2 = DateTime.Now;
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("-----------------------------------\n");
            sb.AppendLine("耗时:" + (dt2 - dt1).TotalMilliseconds + "ms\n");

            textBox1.Text = sb.ToString();
        }

        private void button3_Click(object sender, EventArgs e)
        {
            textBox1.Text = "";
            Application.DoEvents();
            if (rects == null || mats == null)
            {
                return;
            }
            dt1 = DateTime.Now;
            try
            {
                int recognizeBatchSize = 0;
                //Cv2.ImShow("mats", mats[0]);
                PaddleOcrRecognizerResult[] porr = RecognizerRun(mats, recognizeBatchSize);
                dt2 = DateTime.Now;
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < porr.Length; i++)
                {
                    sb.AppendLine("("+ porr[i].Score+")"+ porr[i].Text );
                }
                sb.AppendLine("-----------------------------------\n");
                sb.AppendLine("耗时:" + (dt2 - dt1).TotalMilliseconds + "ms\n");
                textBox1.Text = sb.ToString();
            }
            finally
            {
                foreach (Mat mat in mats)
                {
                    mat.Dispose();
                }
            }
        }

        public PaddleOcrRecognizerResult[] RecognizerRun(Mat[] srcs, int batchSize = 0)
        {
            if (srcs.Length == 0)
            {
                return new PaddleOcrRecognizerResult[0];
            }

            int chooseBatchSize = batchSize != 0 ? batchSize : Math.Min(8, Environment.ProcessorCount);
            PaddleOcrRecognizerResult[] allResult = new PaddleOcrRecognizerResult[srcs.Length];

            return srcs
                .Select((x, i) => (mat: x, i))
                .OrderBy(x => x.mat.Width)
                .Chunk(chooseBatchSize)
                .Select(x => (result: RunMulti(x.Select(x2 => x2.mat).ToArray()), ids: x.Select(x2 => x2.i).ToArray()))
                .SelectMany(x => x.result.Zip(x.ids, (result, i) => (result, i)))
                .OrderBy(x => x.i)
                .Select(x => x.result)
                .ToArray();
        }

        private Mat ResizePadding(Mat src, int height, int targetWidth)
        {
            OpenCvSharp.Size size = src.Size();
            float whRatio = 1.0f * size.Width / size.Height;
            int width = (int)Math.Ceiling(height * whRatio);

            if (width == targetWidth)
            {
                return src.Resize(new OpenCvSharp.Size(width, height));
            }
            else
            {
                //using Mat resized = src.Resize(new OpenCvSharp.Size(width, height));
                Mat resized = src.Resize(new OpenCvSharp.Size(width, height));
                return resized.CopyMakeBorder(0, 0, 0, targetWidth - width, BorderTypes.Constant, Scalar.Gray);
            }
        }

        private PaddleOcrRecognizerResult Run(Mat src) => RunMulti(new[] { src }).Single();

        private PaddleOcrRecognizerResult[] RunMulti(Mat[] srcs)
        {
            if (srcs.Length == 0)
            {
                return new PaddleOcrRecognizerResult[0];
            }

            for (int i = 0; i < srcs.Length; ++i)
            {
                Mat src = srcs[i];
                if (src.Empty())
                {
                    throw new ArgumentException($"src[{i}] size should not be 0, wrong input picture provided?");
                }
            }

            int modelHeight = recShape.Height;
            int maxWidth = (int)Math.Ceiling(srcs.Max(src =>
            {
                OpenCvSharp.Size size = src.Size();
                return 1.0 * size.Width / size.Height * modelHeight;
            }));

            int index = 0;

            Mat[] normalizeds = srcs
                .Select(src =>
                {
                   
                    Mat channel3 = new Mat();
                    if (src.Channels() == 4)
                    {
                        channel3 = src.CvtColor(ColorConversionCodes.RGBA2BGR);
                    }
                    else if (src.Channels() == 3)
                    {
                        channel3 = src.Clone();
                    }
                    else if (src.Channels() == 1)
                    {
                        channel3 = src.CvtColor(ColorConversionCodes.GRAY2RGB);
                    }
                    else
                    {
                        throw new Exception("Unexpect src channel: {" + src.Channels() + "}, allow: (1/3/4)");
                    }

                    Mat resized = ResizePadding(channel3, modelHeight, maxWidth);
                    Cv2.ImShow("resized"+index.ToString(), resized);
                    index++;
                    channel3.Dispose();
                    return Normalize(resized);
                })
                .ToArray();

            using (PaddleTensor input = rec_predictor.GetInputTensor(rec_predictor.InputNames[0]))
            {
                int channel = normalizeds[0].Channels();
                input.Shape = new[] { normalizeds.Length, channel, modelHeight, maxWidth };
                float[] data = ExtractMat(normalizeds, channel, modelHeight, maxWidth);
                input.SetData(data);
            }
            if (!rec_predictor.Run())
            {
                throw new Exception($"PaddlePredictor(Recognizer) run failed.");
            }

            using (PaddleTensor output = rec_predictor.GetOutputTensor(rec_predictor.OutputNames[0]))
            {
                float[] data = output.GetData<float>();
                int[] shape = output.Shape;

                GCHandle dataHandle = default;
                try
                {
                    dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
                    IntPtr dataPtr = dataHandle.AddrOfPinnedObject();
                    int labelCount = shape[2];
                    int charCount = shape[1];

                    return Enumerable.Range(0, shape[0])
                        .Select(i =>
                        {
                            StringBuilder sb = new StringBuilder();
                            int lastIndex = 0;
                            float score = 0;
                            for (int n = 0; n < charCount; ++n)
                            {
                                Mat mat = new Mat(1, labelCount, MatType.CV_32FC1, dataPtr + (n + i * charCount) * labelCount * sizeof(float));
                                int[] maxIdx = new int[2];
                                mat.MinMaxIdx(out double _, out double maxVal, new int[0], maxIdx);

                                if (maxIdx[1] > 0 && (!(n > 0 && maxIdx[1] == lastIndex)))
                                {
                                    score += (float)maxVal;
                                    sb.Append(GetLabelByIndex(maxIdx[1]));
                                }
                                lastIndex = maxIdx[1];
                                mat.Dispose();
                            }
                            return new PaddleOcrRecognizerResult(sb.ToString(), score / sb.Length);
                        })
                        .ToArray();
                }
                finally
                {
                    dataHandle.Free();
                }
            }
        }

        private float[] ExtractMat(Mat[] srcs, int channel, int height, int width)
        {
            float[] result = new float[srcs.Length * channel * width * height];
            GCHandle resultHandle = GCHandle.Alloc(result, GCHandleType.Pinned);
            IntPtr resultPtr = resultHandle.AddrOfPinnedObject();
            try
            {
                for (int i = 0; i < srcs.Length; ++i)
                {
                    Mat src = srcs[i];
                    if (src.Channels() != channel)
                    {
                        throw new Exception($"src[{i}] channel={src.Channels()}, expected {channel}");
                    }
                    for (int c = 0; c < channel; ++c)
                    {
                        //using Mat dest = new Mat(height, width, MatType.CV_32FC1, resultPtr + (c + i * channel) * height * width * sizeof(float));
                        Mat dest = new Mat(height, width, MatType.CV_32FC1, resultPtr + (c + i * channel) * height * width * sizeof(float));
                        Cv2.ExtractChannel(src, dest, c);
                        //dest.Dispose();
                    }
                }
                return result;
            }
            finally
            {
                resultHandle.Free();
            }
        }

        string GetLabelByIndex(int x)
        {
            if (x > 0 && x <= Labels.Count)
            {
                return Labels[x - 1];
            }
            else if (x == Labels.Count + 1)
            {
                return "";
            }
            else
            {
                throw new Exception("Unable to GetLabelByIndex: index {" + x + "} out of range {" + Labels.Count + "}, OCR model or labels not matched?");
            }
        }

        private Mat ResizePadding(Mat src, OcrShape shape)
        {
            OpenCvSharp.Size srcSize = src.Size();
            Mat roi = srcSize.Width / srcSize.Height > shape.Width / shape.Height ?
                src[0, srcSize.Height, 0, (int)Math.Floor(1.0 * srcSize.Height * shape.Width / shape.Height)] :
                src.Clone();
            double scaleRate = 1.0 * shape.Height / srcSize.Height;
            Mat resized = roi.Resize(new OpenCvSharp.Size(Math.Floor(roi.Width * scaleRate), shape.Height));
            if (resized.Width < shape.Width)
            {
                Cv2.CopyMakeBorder(resized, resized, 0, 0, 0, shape.Width - resized.Width, BorderTypes.Constant, Scalar.Black);
            }
            roi.Dispose();
            return resized;
        }

        public Mat CLSPredictorRun(Mat src)
        {
            if (src.Empty())
            {
                throw new ArgumentException("src size should not be 0, wrong input picture provided?");
            }

            if (!(src.Channels() == 3 || src.Channels() == 1))
            {
                throw new NotSupportedException($"{nameof(src)} channel must be 3 or 1, provided {src.Channels()}.");
            }

            if (ShouldRotate180(src))
            {
                Cv2.Rotate(src, src, RotateFlags.Rotate180);
                Console.WriteLine("ShouldRotate180:True");
                return src;
            }
            else
            {
                Console.WriteLine("ShouldRotate180:Flase");
                return src;
            }
        }

        public bool ShouldRotate180(Mat src)
        {
            if (src.Empty())
            {
                throw new ArgumentException("src size should not be 0, wrong input picture provided?");
            }

            if (!(src.Channels() == 3 || src.Channels() == 1))
            {
                throw new NotSupportedException($"{nameof(src)} channel must be 3 or 1, provided {src.Channels()}.");
            }

            //The default OcrShape used in the classification model
            OcrShape shape = new OcrShape(3, 192, 48);
            Mat resized = ResizePadding(src, shape);
            Mat normalized = Normalize(resized);

            using (PaddleTensor input = cls_predictor.GetInputTensor(cls_predictor.InputNames[0]))
            {
                input.Shape = new[] { 1, 3, normalized.Rows, normalized.Cols };
                float[] data = ExtractMat(normalized);
                input.SetData(data);
            }
            if (!cls_predictor.Run())
            {
                throw new Exception("PaddlePredictor(Classifier) run failed.");
            }

            using (PaddleTensor output = cls_predictor.GetOutputTensor(cls_predictor.OutputNames[0]))
            {
                float[] softmax = output.GetData<float>();
                float score = 0;
                int label = 0;
                for (int i = 0; i < softmax.Length; ++i)
                {
                    if (softmax[i] > score)
                    {
                        score = softmax[i];
                        label = i;
                    }
                }

                resized.Dispose();
                normalized.Dispose();

                return label % 2 == 1 && score > RotateThreshold;
            }
        }

    }
}

  1. using Sdcb.PaddleInference.Native;
  2. using Sdcb.PaddleInference;
  3. using System;
  4. using System.Collections.Generic;
  5. using OpenCvSharp.Extensions;
  6. using OpenCvSharp;
  7. using System.Data;
  8. using System.Drawing;
  9. using System.Linq;
  10. using System.Text;
  11. using System.Windows.Forms;
  12. using System.Runtime.InteropServices;
  13. using System.Globalization;
  14. using System.IO;
  15.  
  16. namespace PaddleInference_OCR识别
  17. {
  18.     public partial class Form1 : Form
  19.     {
  20.         public Form1()
  21.         {
  22.             InitializeComponent();
  23.         }
  24.  
  25.         Bitmap bmp;
  26.         string fileFilter = "*.*|*.bmp;*.jpg;*.jpeg;*.tiff;*.tiff;*.png";
  27.         string img = "";
  28.         string startupPath = "";
  29.  
  30.         int MaxSize = 1536;
  31.         float? BoxThreshold = 0.3f;
  32.         float? BoxScoreThreahold = 0.7f;
  33.         int? DilatedSize = 2;
  34.         int MinSize = 3;
  35.         float UnclipRatio = 2.0f;
  36.  
  37.         Mat src;
  38.         PaddlePredictor det_predictor;
  39.  
  40.         RotatedRect[] rects;
  41.  
  42.         bool Enable180Classification { get; set; } = true;
  43.         bool AllowRotateDetection { get; set; } = true;
  44.         double RotateThreshold { get; } = 0.75;
  45.         Mat[] mats;
  46.         PaddlePredictor cls_predictor;
  47.  
  48.         OcrShape recShape = new OcrShape(3, 320, 48);
  49.         PaddlePredictor rec_predictor;
  50.  
  51.         public IReadOnlyList<string> Labels;
  52.  
  53.         DateTime dt1 = DateTime.Now;
  54.         DateTime dt2 = DateTime.Now;
  55.  
  56.         private unsafe void Form1_Load(object sender, EventArgs e)
  57.         {
  58.  
  59.             string startupPath = Application.StartupPath;
  60.  
  61.             IntPtr det_ptr = PaddleNative.PD_ConfigCreate();
  62.  
  63.             Encoding PaddleEncoding = Environment.OSVersion.Platform == PlatformID.Win32NT ? Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.ANSICodePage) : Encoding.UTF8;
  64.  
  65.             //检测模型路径
  66.             String det_programPath = startupPath + "\\ch_PP-OCRv3_det\\inference.pdmodel";
  67.             String det_paramsPath = startupPath + "\\ch_PP-OCRv3_det\\inference.pdiparams";
  68.  
  69.             //方式一
  70.             //byte[] programBytes = PaddleEncoding.GetBytes(det_programPath);
  71.             //byte[] paramsBytes = PaddleEncoding.GetBytes(det_paramsPath);
  72.             //fixed (byte* programPtr = programBytes)
  73.             //fixed (byte* paramsPtr = paramsBytes)
  74.             //{
  75.             //    PaddleNative.PD_ConfigSetModel(det_ptr, (IntPtr)programPtr, (IntPtr)paramsPtr);
  76.             //}
  77.  
  78.             //方式二  读自己加密后的模型文件,解密后写入byte[]
  79.             Stream Steam = new FileStream(det_programPath, FileMode.Open, FileAccess.Read, FileShare.Read);
  80.             byte[] programBuffer = new byte[Steam.Length];
  81.             Steam.Read(programBuffer, 0, programBuffer.Length);
  82.  
  83.             Steam = new FileStream(det_paramsPath, FileMode.Open, FileAccess.Read, FileShare.Read);
  84.             byte[] paramsBuffer = new byte[Steam.Length];
  85.             Steam.Read(paramsBuffer, 0, paramsBuffer.Length);
  86.  
  87.             fixed (byte* pprogram = programBuffer)
  88.             fixed (byte* pparams = paramsBuffer)
  89.             {
  90.                 PaddleNative.PD_ConfigSetModelBuffer(det_ptr,
  91.                     (IntPtr)pprogram, programBuffer.Length,
  92.                     (IntPtr)pparams, paramsBuffer.Length);
  93.             }
  94.  
  95.             det_predictor = new PaddlePredictor(PaddleNative.PD_PredictorCreate(det_ptr));
  96.  
  97.             //方向分类模型
  98.             IntPtr cls_ptr = PaddleNative.PD_ConfigCreate();
  99.  
  100.             String cls_programPath = startupPath + "\\ch_ppocr_mobile_v2.0_cls\\inference.pdmodel";
  101.             String cls_paramsPath = startupPath + "\\ch_ppocr_mobile_v2.0_cls\\inference.pdiparams";
  102.  
  103.             byte[] programBytes = PaddleEncoding.GetBytes(cls_programPath);
  104.             byte[] paramsBytes = PaddleEncoding.GetBytes(cls_paramsPath);
  105.             fixed (byte* programPtr = programBytes)
  106.             fixed (byte* paramsPtr = paramsBytes)
  107.             {
  108.                 PaddleNative.PD_ConfigSetModel(cls_ptr, (IntPtr)programPtr, (IntPtr)paramsPtr);
  109.             }
  110.  
  111.             cls_predictor = new PaddlePredictor(PaddleNative.PD_PredictorCreate(cls_ptr));
  112.  
  113.             //识别模型
  114.             IntPtr rec_ptr = PaddleNative.PD_ConfigCreate();
  115.  
  116.             String rec_programPath = startupPath + "\\ch_PP-OCRv3_rec\\inference.pdmodel";
  117.             String rec_paramsPath = startupPath + "\\ch_PP-OCRv3_rec\\inference.pdiparams";
  118.  
  119.             byte[] rec_programBytes = PaddleEncoding.GetBytes(rec_programPath);
  120.             byte[] rec_paramsBytes = PaddleEncoding.GetBytes(rec_paramsPath);
  121.             fixed (byte* rec_programPtr = rec_programBytes)
  122.             fixed (byte* rec_paramsPtr = rec_paramsBytes)
  123.             {
  124.                 PaddleNative.PD_ConfigSetModel(rec_ptr, (IntPtr)rec_programPtr, (IntPtr)rec_paramsPtr);
  125.             }
  126.  
  127.             rec_predictor = new PaddlePredictor(PaddleNative.PD_PredictorCreate(rec_ptr));
  128.  
  129.             //Labels
  130.             String labelsPath = startupPath + "\\ppocr_keys.txt";
  131.             Steam = new FileStream(labelsPath, FileMode.Open, FileAccess.Read, FileShare.Read);
  132.             StreamReader reader = new StreamReader(Steam);
  133.             List<string> tempList = new List<string>();
  134.             while (!reader.EndOfStream)
  135.             {
  136.                 tempList.Add(reader.ReadLine());
  137.             }
  138.             reader.Dispose();
  139.             Steam.Dispose();
  140.             Labels = tempList;
  141.         }
  142.  
  143.         private void button1_Click(object sender, EventArgs e)
  144.         {
  145.             OpenFileDialog ofd = new OpenFileDialog();
  146.             ofd.Filter = fileFilter;
  147.             if (ofd.ShowDialog() != DialogResult.OK) return;
  148.  
  149.             pictureBox1.Image = null;
  150.  
  151.             img = ofd.FileName;
  152.             bmp = new Bitmap(img);
  153.             pictureBox1.Image = new Bitmap(img);
  154.             textBox1.Text = "";
  155.         }
  156.  
  157.         private void button2_Click(object sender, EventArgs e)
  158.         {
  159.             textBox1.Text = "";
  160.             Application.DoEvents();
  161.             if (img == "")
  162.             {
  163.                 return;
  164.             }
  165.             dt1 = DateTime.Now;
  166.             src = Cv2.ImRead(img);
  167.  
  168.             Mat resized = MatResize(src, MaxSize);
  169.             //Cv2.ImShow("resized", resized);
  170.             Mat padded = MatPadding32(resized);
  171.             //Cv2.ImShow("padded", padded);
  172.             Mat normalized = Normalize(padded);
  173.             Cv2.ImShow("normalized", normalized);
  174.             OpenCvSharp.Size resizedSize = resized.Size();
  175.             using (PaddleTensor input = det_predictor.GetInputTensor(det_predictor.InputNames[0]))
  176.             {
  177.                 input.Shape = new[] { 1, 3, normalized.Rows, normalized.Cols };
  178.                 float[] setData = ExtractMat(normalized);
  179.                 input.SetData(setData);
  180.             }
  181.  
  182.             if (!det_predictor.Run())
  183.             {
  184.                 throw new Exception("PaddlePredictor(Detector) run failed.");
  185.             }
  186.  
  187.             using (PaddleTensor output = det_predictor.GetOutputTensor(det_predictor.OutputNames[0]))
  188.             {
  189.                 float[] data = output.GetData<float>();
  190.                 int[] shape = output.Shape;
  191.  
  192.                 Mat pred = new Mat(shape[2], shape[3], MatType.CV_32FC1, data);
  193.                 Cv2.ImShow("pred", pred);
  194.                 Mat cbuf = new Mat();
  195.  
  196.                 Mat roi = pred[0, resizedSize.Height, 0, resizedSize.Width];
  197.                 roi.ConvertTo(cbuf, MatType.CV_8UC1, 255);
  198.                 //Cv2.ImShow("roi", roi);
  199.                 Mat dilated = new Mat();
  200.                 Mat binary = BoxThreshold != null ?
  201.                    cbuf.Threshold((int)(BoxThreshold * 255), 255, ThresholdTypes.Binary) :
  202.                    cbuf;
  203.                 //Cv2.ImShow("binary", binary);
  204.                 if (DilatedSize != null)
  205.                 {
  206.                     Mat ones = Cv2.GetStructuringElement(MorphShapes.Rect, new OpenCvSharp.Size(DilatedSize.Value, DilatedSize.Value));
  207.                     Cv2.Dilate(binary, dilated, ones);
  208.                     ones.Dispose();
  209.                 }
  210.                 else
  211.                 {
  212.                     Cv2.CopyTo(binary, dilated);
  213.                 }
  214.                 //Cv2.ImShow("dilated", dilated);
  215.                 OpenCvSharp.Point[][] contours = dilated.FindContoursAsArray(RetrievalModes.List, ContourApproximationModes.ApproxSimple);
  216.  
  217.                 OpenCvSharp.Size size = src.Size();
  218.                 double scaleRate = 1.0 * src.Width / resizedSize.Width;
  219.  
  220.                 rects = contours
  221.                     .Where(x => BoxScoreThreahold == null || GetScore(x, pred) > BoxScoreThreahold)
  222.                     .Select(x => Cv2.MinAreaRect(x))
  223.                     .Where(x => x.Size.Width > MinSize && x.Size.Height > MinSize)
  224.                     .Select(rect =>
  225.                     {
  226.                         float minEdge = Math.Min(rect.Size.Width, rect.Size.Height);
  227.                         Size2f newSize = new Size2f(
  228.                             (rect.Size.Width + UnclipRatio * minEdge) * scaleRate,
  229.                             (rect.Size.Height + UnclipRatio * minEdge) * scaleRate);
  230.                         RotatedRect largerRect = new RotatedRect(rect.Center * scaleRate, newSize, rect.Angle);
  231.                         return largerRect;
  232.                     })
  233.                     .OrderBy(v => v.Center.Y)
  234.                     .ThenBy(v => v.Center.X)
  235.                     .ToArray();
  236.  
  237.                 binary.Dispose();
  238.                 roi.Dispose();
  239.                 cbuf.Dispose();
  240.                 pred.Dispose();
  241.                 dilated.Dispose();
  242.  
  243.  
  244.                 dt2 = DateTime.Now;
  245.                 StringBuilder sb = new StringBuilder();
  246.                 sb.AppendLine("-----------------------------------\n");
  247.                 sb.AppendLine("耗时:" + (dt2 - dt1).TotalMilliseconds + "ms\n");
  248.  
  249.                 textBox1.Text = sb.ToString();
  250.  
  251.                 //绘图
  252.                 Mat src2 = Cv2.ImRead(img);
  253.                 for (int i = 0; i < rects.Length; i++)
  254.                 {
  255.                     Scalar scalar = Scalar.RandomColor();
  256.                     List<OpenCvSharp.Point> temp = new List<OpenCvSharp.Point>();
  257.                     foreach (var item2 in rects[i].Points())
  258.                     {
  259.                         temp.Add(new OpenCvSharp.Point(item2.X, item2.Y));
  260.                     }
  261.                     List<List<OpenCvSharp.Point>> lltemp = new List<List<OpenCvSharp.Point>>();
  262.                     lltemp.Add(temp);
  263.                     Cv2.Polylines(src2, lltemp, true, scalar);
  264.                 }
  265.  
  266.                 if (pictureBox1.Image != null)
  267.                 {
  268.                     pictureBox1.Image.Dispose();
  269.                 }
  270.  
  271.                 pictureBox1.Image = BitmapConverter.ToBitmap(src2);
  272.                 src2.Dispose();
  273.  
  274.             }
  275.         }
  276.  
  277.         private float GetScore(OpenCvSharp.Point[] contour, Mat pred)
  278.         {
  279.             int width = pred.Width;
  280.             int height = pred.Height;
  281.             int[] boxX = contour.Select(v => v.X).ToArray();
  282.             int[] boxY = contour.Select(v => v.Y).ToArray();
  283.  
  284.             int xmin = Clamp(boxX.Min(), 0, width - 1);
  285.             int xmax = Clamp(boxX.Max(), 0, width - 1);
  286.             int ymin = Clamp(boxY.Min(), 0, height - 1);
  287.             int ymax = Clamp(boxY.Max(), 0, height - 1);
  288.  
  289.             OpenCvSharp.Point[] rootPoints = contour
  290.                 .Select(v => new OpenCvSharp.Point(v.X - xmin, v.Y - ymin))
  291.                 .ToArray();
  292.             Mat mask = new Mat(ymax - ymin + 1, xmax - xmin + 1, MatType.CV_8UC1, Scalar.Black);
  293.             mask.FillPoly(new[] { rootPoints }, new Scalar(1));
  294.  
  295.             Mat croppedMat = pred[ymin, ymax + 1, xmin, xmax + 1];
  296.             float score = (float)croppedMat.Mean(mask).Val0;
  297.             return score;
  298.         }
  299.  
  300.         public int Clamp(int val, int min, int max)
  301.         {
  302.             if (val < min)
  303.             {
  304.                 return min;
  305.             }
  306.             else if (val > max)
  307.             {
  308.                 return max;
  309.             }
  310.             return val;
  311.         }
  312.  
  313.         float[] ExtractMat(Mat src)
  314.         {
  315.             int rows = src.Rows;
  316.             int cols = src.Cols;
  317.             float[] array = new float[rows * cols * 3];
  318.             GCHandle gCHandle = default(GCHandle);
  319.             try
  320.             {
  321.                 gCHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
  322.                 IntPtr intPtr = gCHandle.AddrOfPinnedObject();
  323.                 for (int i = 0; i < src.Channels(); i++)
  324.                 {
  325.                     Mat dest = new Mat(rows, cols, MatType.CV_32FC1, intPtr + i * rows * cols * 4, 0L);
  326.                     Cv2.ExtractChannel(src, dest, i);
  327.                     dest.Dispose();
  328.                 }
  329.                 return array;
  330.             }
  331.             finally
  332.             {
  333.                 gCHandle.Free();
  334.             }
  335.         }
  336.  
  337.         private Mat MatResize(Mat src, int? maxSize)
  338.         {
  339.             if (maxSize == null) return src.Clone();
  340.  
  341.             OpenCvSharp.Size size = src.Size();
  342.             int longEdge = Math.Max(size.Width, size.Height);
  343.             double scaleRate = 1.0 * maxSize.Value / longEdge;
  344.  
  345.             return scaleRate < 1.0 ?
  346.                 src.Resize(OpenCvSharp.Size.Zero, scaleRate, scaleRate) :
  347.                 src.Clone();
  348.         }
  349.  
  350.         private Mat MatPadding32(Mat src)
  351.         {
  352.             OpenCvSharp.Size size = src.Size();
  353.             OpenCvSharp.Size newSize = new OpenCvSharp.Size(
  354.                 32 * Math.Ceiling(1.0 * size.Width / 32),
  355.                 32 * Math.Ceiling(1.0 * size.Height / 32));
  356.  
  357.             return src.CopyMakeBorder(0, newSize.Height - size.Height, 0, newSize.Width - size.Width, BorderTypes.Constant, Scalar.Black);
  358.         }
  359.  
  360.         private Mat Normalize(Mat src)
  361.         {
  362.             Mat normalized = new Mat();
  363.             src.ConvertTo(normalized, MatType.CV_32FC3, 1.0 / 255);
  364.             Mat[] bgr = normalized.Split();
  365.             float[] scales = new[] { 1 / 0.229f, 1 / 0.224f, 1 / 0.225f };
  366.             float[] means = new[] { 0.485f, 0.456f, 0.406f };
  367.             for (int i = 0; i < bgr.Length; ++i)
  368.             {
  369.                 bgr[i].ConvertTo(bgr[i], MatType.CV_32FC1, 1.0 * scales[i], (0.0 - means[i]) * scales[i]);
  370.             }
  371.             normalized.Dispose();
  372.             Mat dest = new Mat();
  373.             Cv2.Merge(bgr, dest);
  374.             foreach (Mat channel in bgr)
  375.             {
  376.                 channel.Dispose();
  377.             }
  378.             return dest;
  379.         }
  380.  
  381.         private Mat GetRotateCropImage(Mat src, RotatedRect rect)
  382.         {
  383.             bool wider = rect.Size.Width > rect.Size.Height;
  384.             float angle = rect.Angle;
  385.             OpenCvSharp.Size srcSize = src.Size();
  386.             Rect boundingRect = rect.BoundingRect();
  387.  
  388.             int expTop = Math.Max(0, 0 - boundingRect.Top);
  389.             int expBottom = Math.Max(0, boundingRect.Bottom - srcSize.Height);
  390.             int expLeft = Math.Max(0, 0 - boundingRect.Left);
  391.             int expRight = Math.Max(0, boundingRect.Right - srcSize.Width);
  392.  
  393.             Rect rectToExp = boundingRect + new OpenCvSharp.Point(expTop, expLeft);
  394.             Rect roiRect = Rect.FromLTRB(
  395.                 boundingRect.Left + expLeft,
  396.                 boundingRect.Top + expTop,
  397.                 boundingRect.Right - expRight,
  398.                 boundingRect.Bottom - expBottom);
  399.             Mat boundingMat = src[roiRect];
  400.             Mat expanded = boundingMat.CopyMakeBorder(expTop, expBottom, expLeft, expRight, BorderTypes.Replicate);
  401.             Point2f[] rp = rect.Points()
  402.                 .Select(v => new Point2f(v.X - rectToExp.X, v.Y - rectToExp.Y))
  403.                 .ToArray();
  404.  
  405.             Point2f[] srcPoints = new[] { rp[0], rp[3], rp[2], rp[1] };
  406.  
  407.             if (wider == true && angle >= 0 && angle < 45)
  408.             {
  409.                 srcPoints = new[] { rp[1], rp[2], rp[3], rp[0] };
  410.             }
  411.  
  412.             var ptsDst0 = new Point2f(0, 0);
  413.             var ptsDst1 = new Point2f(rect.Size.Width, 0);
  414.             var ptsDst2 = new Point2f(rect.Size.Width, rect.Size.Height);
  415.             var ptsDst3 = new Point2f(0, rect.Size.Height);
  416.  
  417.             Mat matrix = Cv2.GetPerspectiveTransform(srcPoints, new[] { ptsDst0, ptsDst1, ptsDst2, ptsDst3 });
  418.  
  419.             Mat dest = expanded.WarpPerspective(matrix, new OpenCvSharp.Size(rect.Size.Width, rect.Size.Height), InterpolationFlags.Nearest, BorderTypes.Replicate);
  420.  
  421.             if (!wider)
  422.             {
  423.                 Cv2.Transpose(dest, dest);
  424.             }
  425.             else if (angle > 45)
  426.             {
  427.                 Cv2.Flip(dest, dest, FlipMode.X);
  428.             }
  429.  
  430.             boundingMat.Dispose();
  431.             expanded.Dispose();
  432.             matrix.Dispose();
  433.  
  434.             return dest;
  435.         }
  436.  
  437.         private Rect GetCropedRect(Rect rect, OpenCvSharp.Size size)
  438.         {
  439.             return Rect.FromLTRB(
  440.                 Clamp(rect.Left, 0, size.Width),
  441.                 Clamp(rect.Top, 0, size.Height),
  442.                 Clamp(rect.Right, 0, size.Width),
  443.                 Clamp(rect.Bottom, 0, size.Height));
  444.         }
  445.  
  446.         private void Form1_FormClosing(object sender, FormClosingEventArgs e)
  447.         {
  448.             det_predictor.Dispose();
  449.             rec_predictor.Dispose();
  450.         }
  451.  
  452.         /// <summary>
  453.         /// 方向检测
  454.         /// </summary>
  455.         /// <param name="sender"></param>
  456.         /// <param name="e"></param>
  457.         private void button4_Click(object sender, EventArgs e)
  458.         {
  459.             textBox1.Text = "";
  460.             Application.DoEvents();
  461.             if (rects == null)
  462.             {
  463.                 return;
  464.             }
  465.             if (rects == null)
  466.             {
  467.                 return;
  468.             }
  469.             dt1 = DateTime.Now;
  470.             mats =
  471.                rects.Select(rect =>
  472.                {
  473.                    Mat roi = AllowRotateDetection ? GetRotateCropImage(src, rect) : src[GetCropedRect(rect.BoundingRect(), src.Size())];
  474.                    return Enable180Classification ? CLSPredictorRun(roi) : roi;
  475.                })
  476.                .ToArray();
  477.  
  478.             dt2 = DateTime.Now;
  479.             StringBuilder sb = new StringBuilder();
  480.             sb.AppendLine("-----------------------------------\n");
  481.             sb.AppendLine("耗时:" + (dt2 - dt1).TotalMilliseconds + "ms\n");
  482.  
  483.             textBox1.Text = sb.ToString();
  484.         }
  485.  
  486.         private void button3_Click(object sender, EventArgs e)
  487.         {
  488.             textBox1.Text = "";
  489.             Application.DoEvents();
  490.             if (rects == null || mats == null)
  491.             {
  492.                 return;
  493.             }
  494.             dt1 = DateTime.Now;
  495.             try
  496.             {
  497.                 int recognizeBatchSize = 0;
  498.                 //Cv2.ImShow("mats", mats[0]);
  499.                 PaddleOcrRecognizerResult[] porr = RecognizerRun(mats, recognizeBatchSize);
  500.                 dt2 = DateTime.Now;
  501.                 StringBuilder sb = new StringBuilder();
  502.                 for (int i = 0; i < porr.Length; i++)
  503.                 {
  504.                     sb.AppendLine("("+ porr[i].Score+")"+ porr[i].Text );
  505.                 }
  506.                 sb.AppendLine("-----------------------------------\n");
  507.                 sb.AppendLine("耗时:" + (dt2 - dt1).TotalMilliseconds + "ms\n");
  508.                 textBox1.Text = sb.ToString();
  509.             }
  510.             finally
  511.             {
  512.                 foreach (Mat mat in mats)
  513.                 {
  514.                     mat.Dispose();
  515.                 }
  516.             }
  517.         }
  518.  
  519.         public PaddleOcrRecognizerResult[] RecognizerRun(Mat[] srcs, int batchSize = 0)
  520.         {
  521.             if (srcs.Length == 0)
  522.             {
  523.                 return new PaddleOcrRecognizerResult[0];
  524.             }
  525.  
  526.             int chooseBatchSize = batchSize != 0 ? batchSize : Math.Min(8, Environment.ProcessorCount);
  527.             PaddleOcrRecognizerResult[] allResult = new PaddleOcrRecognizerResult[srcs.Length];
  528.  
  529.             return srcs
  530.                 .Select((x, i) => (mat: x, i))
  531.                 .OrderBy(x => x.mat.Width)
  532.                 .Chunk(chooseBatchSize)
  533.                 .Select(x => (result: RunMulti(x.Select(x2 => x2.mat).ToArray()), ids: x.Select(x2 => x2.i).ToArray()))
  534.                 .SelectMany(x => x.result.Zip(x.ids, (result, i) => (result, i)))
  535.                 .OrderBy(x => x.i)
  536.                 .Select(x => x.result)
  537.                 .ToArray();
  538.         }
  539.  
  540.         private Mat ResizePadding(Mat src, int height, int targetWidth)
  541.         {
  542.             OpenCvSharp.Size size = src.Size();
  543.             float whRatio = 1.0f * size.Width / size.Height;
  544.             int width = (int)Math.Ceiling(height * whRatio);
  545.  
  546.             if (width == targetWidth)
  547.             {
  548.                 return src.Resize(new OpenCvSharp.Size(width, height));
  549.             }
  550.             else
  551.             {
  552.                 //using Mat resized = src.Resize(new OpenCvSharp.Size(width, height));
  553.                 Mat resized = src.Resize(new OpenCvSharp.Size(width, height));
  554.                 return resized.CopyMakeBorder(0, 0, 0, targetWidth - width, BorderTypes.Constant, Scalar.Gray);
  555.             }
  556.         }
  557.  
  558.         private PaddleOcrRecognizerResult Run(Mat src) => RunMulti(new[] { src }).Single();
  559.  
  560.         private PaddleOcrRecognizerResult[] RunMulti(Mat[] srcs)
  561.         {
  562.             if (srcs.Length == 0)
  563.             {
  564.                 return new PaddleOcrRecognizerResult[0];
  565.             }
  566.  
  567.             for (int i = 0; i < srcs.Length; ++i)
  568.             {
  569.                 Mat src = srcs[i];
  570.                 if (src.Empty())
  571.                 {
  572.                     throw new ArgumentException($"src[{i}] size should not be 0, wrong input picture provided?");
  573.                 }
  574.             }
  575.  
  576.             int modelHeight = recShape.Height;
  577.             int maxWidth = (int)Math.Ceiling(srcs.Max(src =>
  578.             {
  579.                 OpenCvSharp.Size size = src.Size();
  580.                 return 1.0 * size.Width / size.Height * modelHeight;
  581.             }));
  582.  
  583.             int index = 0;
  584.  
  585.             Mat[] normalizeds = srcs
  586.                 .Select(src =>
  587.                 {
  588.                    
  589.                     Mat channel3 = new Mat();
  590.                     if (src.Channels() == 4)
  591.                     {
  592.                         channel3 = src.CvtColor(ColorConversionCodes.RGBA2BGR);
  593.                     }
  594.                     else if (src.Channels() == 3)
  595.                     {
  596.                         channel3 = src.Clone();
  597.                     }
  598.                     else if (src.Channels() == 1)
  599.                     {
  600.                         channel3 = src.CvtColor(ColorConversionCodes.GRAY2RGB);
  601.                     }
  602.                     else
  603.                     {
  604.                         throw new Exception("Unexpect src channel: {" + src.Channels() + "}, allow: (1/3/4)");
  605.                     }
  606.  
  607.                     Mat resized = ResizePadding(channel3, modelHeight, maxWidth);
  608.                     Cv2.ImShow("resized"+index.ToString(), resized);
  609.                     index++;
  610.                     channel3.Dispose();
  611.                     return Normalize(resized);
  612.                 })
  613.                 .ToArray();
  614.  
  615.             using (PaddleTensor input = rec_predictor.GetInputTensor(rec_predictor.InputNames[0]))
  616.             {
  617.                 int channel = normalizeds[0].Channels();
  618.                 input.Shape = new[] { normalizeds.Length, channel, modelHeight, maxWidth };
  619.                 float[] data = ExtractMat(normalizeds, channel, modelHeight, maxWidth);
  620.                 input.SetData(data);
  621.             }
  622.             if (!rec_predictor.Run())
  623.             {
  624.                 throw new Exception($"PaddlePredictor(Recognizer) run failed.");
  625.             }
  626.  
  627.             using (PaddleTensor output = rec_predictor.GetOutputTensor(rec_predictor.OutputNames[0]))
  628.             {
  629.                 float[] data = output.GetData<float>();
  630.                 int[] shape = output.Shape;
  631.  
  632.                 GCHandle dataHandle = default;
  633.                 try
  634.                 {
  635.                     dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
  636.                     IntPtr dataPtr = dataHandle.AddrOfPinnedObject();
  637.                     int labelCount = shape[2];
  638.                     int charCount = shape[1];
  639.  
  640.                     return Enumerable.Range(0, shape[0])
  641.                         .Select(i =>
  642.                         {
  643.                             StringBuilder sb = new StringBuilder();
  644.                             int lastIndex = 0;
  645.                             float score = 0;
  646.                             for (int n = 0; n < charCount; ++n)
  647.                             {
  648.                                 Mat mat = new Mat(1, labelCount, MatType.CV_32FC1, dataPtr + (n + i * charCount) * labelCount * sizeof(float));
  649.                                 int[] maxIdx = new int[2];
  650.                                 mat.MinMaxIdx(out double _, out double maxVal, new int[0], maxIdx);
  651.  
  652.                                 if (maxIdx[1] > 0 && (!(n > 0 && maxIdx[1] == lastIndex)))
  653.                                 {
  654.                                     score += (float)maxVal;
  655.                                     sb.Append(GetLabelByIndex(maxIdx[1]));
  656.                                 }
  657.                                 lastIndex = maxIdx[1];
  658.                                 mat.Dispose();
  659.                             }
  660.                             return new PaddleOcrRecognizerResult(sb.ToString(), score / sb.Length);
  661.                         })
  662.                         .ToArray();
  663.                 }
  664.                 finally
  665.                 {
  666.                     dataHandle.Free();
  667.                 }
  668.             }
  669.         }
  670.  
  671.         private float[] ExtractMat(Mat[] srcs, int channel, int height, int width)
  672.         {
  673.             float[] result = new float[srcs.Length * channel * width * height];
  674.             GCHandle resultHandle = GCHandle.Alloc(result, GCHandleType.Pinned);
  675.             IntPtr resultPtr = resultHandle.AddrOfPinnedObject();
  676.             try
  677.             {
  678.                 for (int i = 0; i < srcs.Length; ++i)
  679.                 {
  680.                     Mat src = srcs[i];
  681.                     if (src.Channels() != channel)
  682.                     {
  683.                         throw new Exception($"src[{i}] channel={src.Channels()}, expected {channel}");
  684.                     }
  685.                     for (int c = 0; c < channel; ++c)
  686.                     {
  687.                         //using Mat dest = new Mat(height, width, MatType.CV_32FC1, resultPtr + (c + i * channel) * height * width * sizeof(float));
  688.                         Mat dest = new Mat(height, width, MatType.CV_32FC1, resultPtr + (c + i * channel) * height * width * sizeof(float));
  689.                         Cv2.ExtractChannel(src, dest, c);
  690.                         //dest.Dispose();
  691.                     }
  692.                 }
  693.                 return result;
  694.             }
  695.             finally
  696.             {
  697.                 resultHandle.Free();
  698.             }
  699.         }
  700.  
  701.         string GetLabelByIndex(int x)
  702.         {
  703.             if (x > 0 && x <= Labels.Count)
  704.             {
  705.                 return Labels[x - 1];
  706.             }
  707.             else if (x == Labels.Count + 1)
  708.             {
  709.                 return "";
  710.             }
  711.             else
  712.             {
  713.                 throw new Exception("Unable to GetLabelByIndex: index {" + x + "} out of range {" + Labels.Count + "}, OCR model or labels not matched?");
  714.             }
  715.         }
  716.  
  717.         private Mat ResizePadding(Mat src, OcrShape shape)
  718.         {
  719.             OpenCvSharp.Size srcSize = src.Size();
  720.             Mat roi = srcSize.Width / srcSize.Height > shape.Width / shape.Height ?
  721.                 src[0, srcSize.Height, 0, (int)Math.Floor(1.0 * srcSize.Height * shape.Width / shape.Height)] :
  722.                 src.Clone();
  723.             double scaleRate = 1.0 * shape.Height / srcSize.Height;
  724.             Mat resized = roi.Resize(new OpenCvSharp.Size(Math.Floor(roi.Width * scaleRate), shape.Height));
  725.             if (resized.Width < shape.Width)
  726.             {
  727.                 Cv2.CopyMakeBorder(resized, resized, 0, 0, 0, shape.Width - resized.Width, BorderTypes.Constant, Scalar.Black);
  728.             }
  729.             roi.Dispose();
  730.             return resized;
  731.         }
  732.  
  733.         public Mat CLSPredictorRun(Mat src)
  734.         {
  735.             if (src.Empty())
  736.             {
  737.                 throw new ArgumentException("src size should not be 0, wrong input picture provided?");
  738.             }
  739.  
  740.             if (!(src.Channels() == 3 || src.Channels() == 1))
  741.             {
  742.                 throw new NotSupportedException($"{nameof(src)} channel must be 3 or 1, provided {src.Channels()}.");
  743.             }
  744.  
  745.             if (ShouldRotate180(src))
  746.             {
  747.                 Cv2.Rotate(src, src, RotateFlags.Rotate180);
  748.                 Console.WriteLine("ShouldRotate180:True");
  749.                 return src;
  750.             }
  751.             else
  752.             {
  753.                 Console.WriteLine("ShouldRotate180:Flase");
  754.                 return src;
  755.             }
  756.         }
  757.  
  758.         public bool ShouldRotate180(Mat src)
  759.         {
  760.             if (src.Empty())
  761.             {
  762.                 throw new ArgumentException("src size should not be 0, wrong input picture provided?");
  763.             }
  764.  
  765.             if (!(src.Channels() == 3 || src.Channels() == 1))
  766.             {
  767.                 throw new NotSupportedException($"{nameof(src)} channel must be 3 or 1, provided {src.Channels()}.");
  768.             }
  769.  
  770.             //The default OcrShape used in the classification model
  771.             OcrShape shape = new OcrShape(3, 192, 48);
  772.             Mat resized = ResizePadding(src, shape);
  773.             Mat normalized = Normalize(resized);
  774.  
  775.             using (PaddleTensor input = cls_predictor.GetInputTensor(cls_predictor.InputNames[0]))
  776.             {
  777.                 input.Shape = new[] { 1, 3, normalized.Rows, normalized.Cols };
  778.                 float[] data = ExtractMat(normalized);
  779.                 input.SetData(data);
  780.             }
  781.             if (!cls_predictor.Run())
  782.             {
  783.                 throw new Exception("PaddlePredictor(Classifier) run failed.");
  784.             }
  785.  
  786.             using (PaddleTensor output = cls_predictor.GetOutputTensor(cls_predictor.OutputNames[0]))
  787.             {
  788.                 float[] softmax = output.GetData<float>();
  789.                 float score = 0;
  790.                 int label = 0;
  791.                 for (int i = 0; i < softmax.Length; ++i)
  792.                 {
  793.                     if (softmax[i] > score)
  794.                     {
  795.                         score = softmax[i];
  796.                         label = i;
  797.                     }
  798.                 }
  799.  
  800.                 resized.Dispose();
  801.                 normalized.Dispose();
  802.  
  803.                 return label % 2 == 1 && score > RotateThreshold;
  804.             }
  805.         }
  806.  
  807.     }
  808. }

下载 

Demo下载

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/692803
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号