从图像中删除背景噪音，使文本更清晰，便于 OCR 使用

我的答案是基于以下假设。在您的案例中，它们可能都不成立。

• 您可以为分段区域中的框高度设置边界阈值。然后，您应该能够过滤掉其他组件。
• 您知道数字的平均笔画宽度。使用此信息可最大程度地减少数字连接到其他区域的可能性。为此，您可以使用距离变换和形态学操作。

这是我提取数字的过程：

• 将 Otsu 阈值应用于映像
• 进行距离变换

• 使用描边宽度 （ = 8） 约束阈值转换图像的距离

• 应用形态学操作以断开连接

• 过滤边界框高度并猜测数字的位置

行程宽度 = 8 行程宽度 = 10

编辑

• 使用找到的手指轮廓的凸铰链准备蒙版

• 使用掩码将数字区域复制到干净的图像

行程宽度 = 8

行程宽度 = 10

我的Tesseract知识有点生锈。我记得你可以得到角色的置信度。如果您仍然碰巧将噪声区域检测为字符边界框，则可以使用此信息过滤掉噪声。

C++代码

Mat im = imread("aRh8C.png", 0);
// apply Otsu threshold
Mat bw;
threshold(im, bw, 0, 255, CV_THRESH_BINARY_INV | CV_THRESH_OTSU);
// take the distance transform
Mat dist;
distanceTransform(bw, dist, CV_DIST_L2, CV_DIST_MASK_PRECISE);
Mat dibw;
// threshold the distance transformed image
double SWTHRESH = 8;    // stroke width threshold
threshold(dist, dibw, SWTHRESH/2, 255, CV_THRESH_BINARY);
Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3));
// perform opening, in case digits are still connected
Mat morph;
morphologyEx(dibw, morph, CV_MOP_OPEN, kernel);
dibw.convertTo(dibw, CV_8U);
// find contours and filter
Mat cont;
morph.convertTo(cont, CV_8U);

Mat binary;
cvtColor(dibw, binary, CV_GRAY2BGR);

const double HTHRESH = im.rows * .5;    // height threshold
vector<vector<Point>> contours;
vector<Vec4i> hierarchy;
vector<Point> digits; // points corresponding to digit contours

findContours(cont, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));
for(int idx = 0; idx >= 0; idx = hierarchy[idx][0])
{
    Rect rect = boundingRect(contours[idx]);
    if (rect.height > HTHRESH)
    {
        // append the points of this contour to digit points
        digits.insert(digits.end(), contours[idx].begin(), contours[idx].end());

        rectangle(binary, 
            Point(rect.x, rect.y), Point(rect.x + rect.width - 1, rect.y + rect.height - 1),
            Scalar(0, 0, 255), 1);
    }
}

// take the convexhull of the digit contours
vector<Point> digitsHull;
convexHull(digits, digitsHull);
// prepare a mask
vector<vector<Point>> digitsRegion;
digitsRegion.push_back(digitsHull);
Mat digitsMask = Mat::zeros(im.rows, im.cols, CV_8U);
drawContours(digitsMask, digitsRegion, 0, Scalar(255, 255, 255), -1);
// expand the mask to include any information we lost in earlier morphological opening
morphologyEx(digitsMask, digitsMask, CV_MOP_DILATE, kernel);
// copy the region to get a cleaned image
Mat cleaned = Mat::zeros(im.rows, im.cols, CV_8U);
dibw.copyTo(cleaned, digitsMask);

编辑

Java Code

Mat im = Highgui.imread("aRh8C.png", 0);
// apply Otsu threshold
Mat bw = new Mat(im.size(), CvType.CV_8U);
Imgproc.threshold(im, bw, 0, 255, Imgproc.THRESH_BINARY_INV | Imgproc.THRESH_OTSU);
// take the distance transform
Mat dist = new Mat(im.size(), CvType.CV_32F);
Imgproc.distanceTransform(bw, dist, Imgproc.CV_DIST_L2, Imgproc.CV_DIST_MASK_PRECISE);
// threshold the distance transform
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));
// open to remove connections to stray elements
Mat cont = new Mat(im.size(), CvType.CV_8U);
Imgproc.morphologyEx(dibw8u, cont, Imgproc.MORPH_OPEN, kernel);
// find contours and filter based on bounding-box height
final double HTHRESH = im.rows() * 0.5; // bounding-box height threshold
List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
List<Point> digits = new ArrayList<Point>();    // contours of the possible digits
Imgproc.findContours(cont, contours, new Mat(), Imgproc.RETR_CCOMP, Imgproc.CHAIN_APPROX_SIMPLE);
for (int i = 0; i < contours.size(); i++)
{
    if (Imgproc.boundingRect(contours.get(i)).height > HTHRESH)
    {
        // this contour passed the bounding-box height threshold. add it to digits
        digits.addAll(contours.get(i).toList());
    }   
}
// find the convexhull of the digit contours
MatOfInt digitsHullIdx = new MatOfInt();
MatOfPoint hullPoints = new MatOfPoint();
hullPoints.fromList(digits);
Imgproc.convexHull(hullPoints, digitsHullIdx);
// convert hull index to hull points
List<Point> digitsHullPointsList = new ArrayList<Point>();
List<Point> points = hullPoints.toList();
for (Integer i: digitsHullIdx.toList())
{
    digitsHullPointsList.add(points.get(i));
}
MatOfPoint digitsHullPoints = new MatOfPoint();
digitsHullPoints.fromList(digitsHullPointsList);
// create the mask for digits
List<MatOfPoint> digitRegions = new ArrayList<MatOfPoint>();
digitRegions.add(digitsHullPoints);
Mat digitsMask = Mat.zeros(im.size(), CvType.CV_8U);
Imgproc.drawContours(digitsMask, digitRegions, 0, new Scalar(255, 255, 255), -1);
// dilate the mask to capture any info we lost in earlier opening
Imgproc.morphologyEx(digitsMask, digitsMask, Imgproc.MORPH_DILATE, kernel);
// cleaned image ready for OCR
Mat cleaned = Mat.zeros(im.size(), CvType.CV_8U);
dibw8u.copyTo(cleaned, digitsMask);
// feed cleaned to Tesseract

我认为您需要在预处理部分做更多的工作，以便在调用镶嵌之前准备图像尽可能清晰。

我的想法如下：

1-从图像中提取轮廓并在图像中找到轮廓（检查此）和此

2-每个轮廓都有宽度，高度和面积，因此您可以根据宽度，高度及其面积过滤轮廓（检查这个和这个），另外您可以使用此处轮廓分析代码的某些部分来过滤轮廓，并且更多，您可以使用模板轮廓匹配删除与“字母或数字”轮廓不相似的轮廓。

3-过滤轮廓后，您可以检查此图像中的字母和数字的位置，因此您可能需要使用一些文本检测方法，如下所示

4-如果要从图像中删除非文本区域以及不太好的轮廓，您现在需要的所有内容

5-现在，您可以创建二次化方法，也可以使用tesseract方法对图像进行二次分析，然后在图像上调用OCR。

当然，这些是执行此操作的最佳步骤，您可以使用其中一些步骤，并且对您来说可能就足够了。

其他想法：

• 您可以使用不同的方法来执行此操作，最好的主意是找到一种方法来检测数字和字符位置，使用不同的方法（如模板匹配）或基于特征的方法（如HOG）。

• 您可以首先对图像进行二值化并获取二进制图像，然后您需要使用水平和垂直的线条结构进行开度，这将帮助您检测之后的边缘，然后在图像上进行分割，然后进行OCR。

• 检测图像中的所有轮廓后，您还可以使用检测任何类型的线和定义的曲线，例如，通过这种方式，您可以检测有线条的字符，以便您可以分割图像并在之后进行OCR。Hough transformation

更简单的方法：

1- 执行二进制化

2-一些形态学操作来分离轮廓：

3-反转图像中的颜色（这可能是在步骤2之前）

4-查找图像中的所有轮廓

5-删除宽度大于其高度的所有轮廓，删除非常小的轮廓，非常大的轮廓和不矩形的轮廓

注意：您可以使用文本检测方法（或使用HOG或边缘检测）而不是步骤4和5

6-查找包含图像中所有剩余轮廓的大矩形

7-您可以进行一些额外的预处理以增强镶嵌的输入，然后您可以立即调用OCR。（我建议您裁剪图像并将其作为OCR的输入[我的意思是裁剪黄色矩形，不要将整个图像作为输入，而只是黄色矩形，这也将增强结果]）