Java OCR Не читает четко очевидные числа

Question

изображение обработанного изображения + оригинал

Я работаю над проектом, в котором беру вывод игры Sma sh Bros., делаю скриншот, обрабатываю его по порядку чтобы определить проценты, в которых сидят персонажи.

Программа, которую я написал, определяет 57 как 55 и 11 (который я позволю себе установить в нормальное положение) как 51. И пока игровой процесс работает, числа будут прыгать вокруг.

Программа, которую я написал, использует Tess4J, и я все настроил правильно. Я обучил Tesseract своим собственным шрифтом, который я сделал, используя процентные значения игр. Я пробовал несколько разных шрифтов. Что сделает это более точным !? Я думал о том, чтобы вместо вычисления процентов просто определить, когда они повреждены, но я также выясняю это.

Этот код я использую для обработки изображений:

    public static Mat blur(Mat input, int numberOfTimes){
        Mat sourceImage = new Mat();
        Mat destImage = input.clone();
        for(int i=0;i<numberOfTimes;i++){
            sourceImage = destImage.clone();
            Imgproc.blur(sourceImage, destImage, new Size(3.0, 3.0));
        }
        return destImage;
    }

    public static BufferedImage purify(BufferedImage image) {
        BufferedImage image2 = ImageHelper.convertImageToGrayscale(image);
        Mat mat = BufferedImage2Mat(image2, -1);
        Mat resizedMat = new Mat();
        double width = mat.cols();
        double height = mat.rows();
        double aspect = width / height;
        Size sz = new Size(width * aspect * 1.4, height * aspect * 1.4);
        Imgproc.resize(mat, resizedMat, sz);
        double thresh = Imgproc.threshold(resizedMat, resizedMat, 23, 255, Imgproc.THRESH_BINARY_INV);
        Mat kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(3, 3));
        Imgproc.dilate(resizedMat, resizedMat, kernel, new Point(0, 0), 9);
        return toBufferedImage(HighGui.toBufferedImage(blur(resizedMat, 0)));
    }

    public static BufferedImage toBufferedImage(Image img)
    {
        if (img instanceof BufferedImage)
        {
            return (BufferedImage) img;
        }

        BufferedImage bimage = new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_ARGB);

        Graphics2D bGr = bimage.createGraphics();
        bGr.drawImage(img, 0, 0, null);
        bGr.dispose();

        return bimage;
    }

    public static Image denoise(BufferedImage img) {
        Mat image = BufferedImage2Mat(img, 0);
        Mat out = new Mat();
        Mat tmp = new Mat();
        Mat kernel = new Mat(new Size(3, 3), CvType.CV_8UC1, new Scalar(255));
        Imgproc.morphologyEx(image, tmp, Imgproc.MORPH_OPEN, kernel);
        Imgproc.morphologyEx(tmp, out, Imgproc.MORPH_CLOSE, kernel);
        return HighGui.toBufferedImage(out);
    }

    public static Mat BufferedImage2Mat(BufferedImage image, int filter) {
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ImageIO.write(image, "jpg", byteArrayOutputStream);
            byteArrayOutputStream.flush();
            return Imgcodecs.imdecode(new MatOfByte(byteArrayOutputStream.toByteArray()), filter);
        } catch (IOException e) {
            return null;
        }
    }

    public static Image clean(BufferedImage image) {
        Mat og = BufferedImage2Mat(image, Imgcodecs.IMREAD_UNCHANGED);
        Mat im = BufferedImage2Mat(image, 0);
        Mat bw = new Mat(im.size(), CvType.CV_8U);
        Imgproc.threshold(im, bw, 0, 255, Imgproc.THRESH_BINARY_INV | Imgproc.THRESH_OTSU);
        Mat dist = new Mat(im.size(), CvType.CV_32F);
        Imgproc.distanceTransform(bw, dist, Imgproc.CV_DIST_L2, Imgproc.CV_DIST_MASK_PRECISE);
        Mat dibw32f = new Mat(im.size(), CvType.CV_32F);
        final double SWTHRESH = 8.0;    // stroke width threshold
        Imgproc.threshold(dist, dibw32f, SWTHRESH/2.0, 255, Imgproc.THRESH_BINARY);
        Mat dibw8u = new Mat(im.size(), CvType.CV_8U);
        dibw32f.convertTo(dibw8u, CvType.CV_8U);

        Mat kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(3, 3));
        Mat cont = new Mat(im.size(), CvType.CV_8U);
        Imgproc.morphologyEx(dibw8u, cont, Imgproc.MORPH_OPEN, kernel);
        final double HTHRESH = im.rows() * 0.5;
        List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
        List<Point> digits = new ArrayList<Point>();
        Mat hierchy = new Mat();
        Imgproc.findContours(cont, contours, hierchy, Imgproc.RETR_CCOMP, Imgproc.CHAIN_APPROX_SIMPLE, new Point(0, 0));
        List<Mat>cleanedMatList = new ArrayList<Mat>();
        int c = 0;

        for (int i = 0; i >= hierchy.cols(); i++) {
            Rect rect = Imgproc.boundingRect(contours.get(i));
            if (rect.height > HTHRESH) {
                Mat binary = new Mat();
                Imgproc.rectangle(binary, new Point(rect.x, rect.y), new Point(rect.x + rect.width - 1, rect.y + rect.height - 1), new Scalar(0, 0, 255), 3);
                cleanedMatList.add(c, binary);
                c++;
            }
        }

        List<MatOfInt> digitsHull = new ArrayList<MatOfInt>();
        for(int i=0; i < contours.size(); i++){
            digitsHull.add(new MatOfInt());
        }
        for(int i=0; i < contours.size(); i++){
            Imgproc.convexHull(contours.get(i), digitsHull.get(i));
        }

        List<MatOfPoint> digitRegions = new ArrayList<MatOfPoint>();

        for (int i = 0; i< digitRegions.size(); i++) {
            MatOfPoint dr = digitRegions.get(i);
            dr.push_back(digitsHull.get(i));
        }

        Mat digitsMask = new Mat(og.rows(),og.cols(), CvType.CV_8U);
        Imgproc.drawContours(digitsMask, digitRegions, 0, new Scalar(255, 255, 255), -1);
        Imgproc.morphologyEx(digitsMask, digitsMask, Imgproc.MORPH_DILATE, kernel);

        Mat cleaned = new Mat(og.rows(), og.cols(), CvType.CV_8U);
        dibw8u.copyTo(cleaned, digitsMask);
        return HighGui.toBufferedImage(dibw8u);
    }