使用 cv2 / pytesseract 进行数字识别的局部对比度增强

Question

I want to use pytesseract to read digits from images. The images look as follows:

The digits are dotted and in order to be able to use pytesseract, I need black connected digits on a white background . To do so, I thought about using erode and dilate as preprocessing techniques. As you can see, the images are similar, yet quite different in certain aspects. For example, the dots in the first image are darker than the background, while the dots in the second are whiter. That means, in the first image I can use erode to get black connected lines and in the second image I can use dilate to get white connected lines and then inverse the colors. This leads to the following results:

Using an appropriate threshold, the first image can easily be read with pytesseract. The second image, whoever, is more tricky. The problem is, that for example parts of the "4" are darker than the background around the three. So a simple threshold is not going to work. I need something like local threshold or local contrast enhancement. Does anybody have an idea here?

Edit:

OTSU, mean threshold and gaussian threshold lead to the following results:

Answer 1

Your images are pretty low res, but you can try a method called gain division . The idea is that you try to build a model of the background and then weight each input pixel by that model. The output gain should be relatively constant during most of the image.

After gain division is performed, you can try to improve the image by applying an area filter and morphology . I only tried your first image, because it is the "least worst".

These are the steps to get the gain-divided image:

1. Apply a soft median blur filter to get rid of high frequency noise.
2. Get the model of the background via local maximum . Apply a very strong close operation, with a big structuring element (I'm using a rectangular kernel of size 15 ).
3. Perform gain adjustment by dividing 255 between each local maximum pixel. Weight this value with each input image pixel.
4. You should get a nice image where the background illumination is pretty much normalized , threshold this image to get a binary mask of the characters.

Now, you can improve the quality of the image with the following, additional steps:

1. Threshold via Otsu , but add a little bit of bias . (This, unfortunately, is a manual step depending on the input).

2. Apply an area filter to filter out the smaller blobs of noise.

Let's see the code:

import numpy as np
import cv2

# image path
path = "C:/opencvImages/"
fileName = "iA904.png"

# Reading an image in default mode:
inputImage = cv2.imread(path+fileName)

# Remove small noise via median:
filterSize = 5
imageMedian = cv2.medianBlur(inputImage, filterSize)

# Get local maximum:
kernelSize = 15
maxKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (kernelSize, kernelSize))
localMax = cv2.morphologyEx(imageMedian, cv2.MORPH_CLOSE, maxKernel, None, None, 1, cv2.BORDER_REFLECT101)

# Perform gain division
gainDivision = np.where(localMax == 0, 0, (inputImage/localMax))

# Clip the values to [0,255]
gainDivision = np.clip((255 * gainDivision), 0, 255)

# Convert the mat type from float to uint8:
gainDivision = gainDivision.astype("uint8") 

# Convert RGB to grayscale:
grayscaleImage = cv2.cvtColor(gainDivision, cv2.COLOR_BGR2GRAY)

This is what gain division gets you:

Note that the lighting is more balanced. Now, let's apply a little bit of contrast enhancement:

# Contrast Enhancement:
grayscaleImage = np.uint8(cv2.normalize(grayscaleImage, grayscaleImage, 0, 255, cv2.NORM_MINMAX))

You get this, which creates a little bit more contrast between the foreground and the background:

Now, let's try to threshold this image to get a nice, binary mask. As I suggested, try Otsu's thresholding but add (or subtract) a little bit of bias to the result. This step, as mentioned, is dependent on the quality of your input:

# Threshold via Otsu + bias adjustment:
threshValue, binaryImage = cv2.threshold(grayscaleImage, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)

threshValue = 0.9 * threshValue
_, binaryImage = cv2.threshold(grayscaleImage, threshValue, 255, cv2.THRESH_BINARY)

You end up with this binary mask:

Invert this and filter out the small blobs. I set an area threshold value of 10 pixels:

# Invert image:
binaryImage = 255 - binaryImage

# Perform an area filter on the binary blobs:
componentsNumber, labeledImage, componentStats, componentCentroids = \
cv2.connectedComponentsWithStats(binaryImage, connectivity=4)

# Set the minimum pixels for the area filter:
minArea = 10

# Get the indices/labels of the remaining components based on the area stat
# (skip the background component at index 0)
remainingComponentLabels = [i for i in range(1, componentsNumber) if componentStats[i][4] >= minArea]

# Filter the labeled pixels based on the remaining labels,
# assign pixel intensity to 255 (uint8) for the remaining pixels
filteredImage = np.where(np.isin(labeledImage, remainingComponentLabels) == True, 255, 0).astype("uint8")

And this is the final binary mask:

If you plan on sending this image to an OCR , you might want to apply some morphology first. Maybe a closing to try and join the dots that make up the characters. Also be sure to train your OCR classifier with a font that is close to what you are actually trying to recognize. This is the (inverted) mask after a size 3 rectangular closing operation with 3 iterations:

Edit:

To get the last image, process the filtered output as follows:

# Set kernel (structuring element) size:
kernelSize = 3

# Set operation iterations:
opIterations = 3

# Get the structuring element:
maxKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (kernelSize, kernelSize))

# Perform closing:
closingImage = cv2.morphologyEx(filteredImage, cv2.MORPH_CLOSE, maxKernel, None, None, opIterations, cv2.BORDER_REFLECT101)

# Invert image to obtain black numbers on white background:
closingImage = 255 - closingImage