Java OCR无法读取明显的数字

我正在做一个项目，我正在拍摄《粉碎兄弟》的游戏输出，拍摄一个屏幕截图，处理它，以便检测角色所处的百分比

我编写的程序将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);
    }

公共静态Mat模糊（Mat输入，整数次）{
Mat sourceImage=新Mat（）；
Mat destImage=input.clone（）；
for（int i=0；i=hierarchy.cols（）；i++）{
Rect Rect=Imgproc.boundingRect（contours.get（i））；
如果（矩形高度>HTHRESH）{
Mat二进制=新Mat（）；
Imgproc.矩形（二进制，新点（rect.x，rect.y），新点（rect.x+rect.width-1，rect.y+rect.height-1），新标量（0,0255），3）；
添加（c，二进制）；
C++；
}
}
List digitsHull=new ArrayList（）；
对于（int i=0；i