Beispiel #1
0
        private static void SaveOCRResult(ocrItem cell, Tuple <string, int> resV2, Tuple <string, string, string> resV3, Bitmap bSprite)
        {
            return;

            var prefixName = $"{cell.x:00}-{cell.y:00}";

            bSprite.Save($"{ocrResultsPath}/{prefixName}.png", System.Drawing.Imaging.ImageFormat.Png);

            using (var file = new StreamWriter($"{ocrResultsPath}/{ocrReportName}", true))
            {
                file.WriteLine($"{cell.x:00};{cell.y:00};{resV2.Item1};{resV2.Item2};{resV3.Item1};{""};{(resV3.Item3 != null ? "excepted" : "")}");
            }
        }
Beispiel #2
0
        static public List <List <ocrItem> > OCR(List <MarkedLineInfo> markedLinesX, List <MarkedLineInfo> markedLinesY, Func <int, int, Color> getPixel)
        {
            int descrXwidth, descrYheight;

            SearchDataBounds(markedLinesX, markedLinesY, out descrXwidth, out descrYheight);

            var res = new List <List <ocrItem> >();
            var fullWidthResultSprite  = 0;
            var maxHeightResultSprite  = 0;
            var maxWidthResultSprite   = 0;
            var fullHeightResultSprite = 0;

            for (int iy = 0; iy < markedLinesY.Count - 1; iy++)
            {
                var resX = new List <ocrItem>();
                for (int ix = 0; ix < markedLinesX.Count - 1; ix++)
                {
                    var newDescriptor = new ocrItem {
                        x = ix, y = iy
                    };
                    if ((ix < descrXwidth && iy >= descrYheight) || (iy < descrYheight && ix >= descrXwidth))
                    {
                        newDescriptor.isDescriptor = true;

                        var widthX = markedLinesX[ix + 1].start - markedLinesX[ix].after;
                        var widthY = markedLinesY[iy + 1].start - markedLinesY[iy].after;

                        newDescriptor.bitmapX = markedLinesX[ix].after;
                        newDescriptor.bitmapY = markedLinesY[iy].after;

                        newDescriptor.width  = widthX;
                        newDescriptor.height = widthY;

                        fullWidthResultSprite += widthX;
                        maxHeightResultSprite  = widthY > maxHeightResultSprite ? widthY : maxHeightResultSprite;

                        fullHeightResultSprite += widthY;
                        maxWidthResultSprite    = widthX > maxWidthResultSprite ? widthX : maxWidthResultSprite;

                        long fullnessI = 0;

                        for (int y = 0; y < widthY; y++)
                        {
                            for (int x = 0; x < widthX; x++)
                            {
                                var pixColor = getPixel(x + markedLinesX[ix].after, y + markedLinesY[iy].after);

                                fullnessI += 255 - pixColor.R;
                            }
                        }

                        var fullness = fullnessI / widthY / widthX;
                        if (fullness > 10)
                        {
                            newDescriptor.hasNumber = true;
                        }
                    }
                    resX.Add(newDescriptor);
                }
                res.Add(resX);
            }

            var fullBmpH = new Bitmap(fullWidthResultSprite, maxHeightResultSprite);
            var fullBmpV = new Bitmap(maxWidthResultSprite, fullHeightResultSprite);
            var grH      = Graphics.FromImage(fullBmpH);
            var grV      = Graphics.FromImage(fullBmpV);

            var currentX = 0;
            var currentY = 0;

            foreach (var line in res)
            {
                foreach (var cell in line)
                {
                    if (cell.isDescriptor && cell.hasNumber)
                    {
                        var  bSprite   = new Bitmap(cell.width, cell.height);
                        long fullnessI = 0;

                        for (int y = 0; y < cell.height; y++)
                        {
                            for (int x = 0; x < cell.width; x++)
                            {
                                var pixColor = getPixel(x + cell.bitmapX, y + cell.bitmapY);

                                if (x == 0 || y == 0 || y == cell.height - 1 || x == cell.width - 1)
                                {
                                    pixColor = Color.White;
                                }

                                if (pixColor.R > 192)
                                {
                                    pixColor = Color.White;
                                }
                                else
                                {
                                    pixColor = Color.Black;
                                }

                                fullnessI += 255 - pixColor.R;
                                bSprite.SetPixel(x, y, pixColor);
                            }
                        }

                        var fullness = fullnessI / cell.height / cell.width;
                        if (fullness < 10)
                        {
                            continue;
                        }

                        var resV2 = OCRBitmapV2(bSprite);
                        var resV3 = OCRBitmapV3(bSprite);

                        var value = 0;
                        if (resV2.Item1 == "~")
                        {
                            value = 8;
                            //value = string.IsNullOrWhiteSpace(resV3.Item1) ? resV2.Item2 : Int32.Parse(resV3.Item1);
                        }
                        else
                        {
                            value = resV2.Item2;
                            var val2 = string.IsNullOrWhiteSpace(resV3.Item1) ? value : Int32.Parse(resV3.Item1);
                            if (value != val2)
                            {
                            }
                        }

                        cell.value = value;

                        SaveOCRResult(cell, resV2, resV3, bSprite);

                        grH.DrawImage(bSprite, currentX, 0);
                        currentX += cell.width;

                        grV.DrawImage(bSprite, 0, currentY);
                        currentY += cell.height;
                    }
                }
            }

            return(res);
        }