使用Open CV屏蔽水平和垂直线

Question

I'm trying to remove horizontal and vertical lines in this image in order to have more distinct text areas.

I'm using the below code, which follows this guide

image = cv2.imread('image.jpg')
gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
thresh = cv2.adaptiveThreshold(
                    blurred, 255,
                    cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV,
                    25,
                    15
                )
# Create the images that will use to extract the horizontal and vertical lines
horizontal = np.copy(thresh)
vertical = np.copy(thresh)

# Specify size on horizontal axis
cols = horizontal.shape[1]
horizontal_size = math.ceil(cols / 20)

# Create structure element for extracting horizontal lines through morphology operations
horizontalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontal_size, 1))

# Apply morphology operations
horizontal = cv2.erode(horizontal, horizontalStructure)
horizontal = cv2.dilate(horizontal, horizontalStructure)

# Show extracted horizontal lines
cv2.imwrite("horizontal.jpg", horizontal)

# Specify size on vertical axis
rows = vertical.shape[0]
verticalsize = math.ceil(rows / 20)

# Create structure element for extracting vertical lines through morphology operations
verticalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (1, verticalsize))

# Apply morphology operations
vertical = cv2.erode(vertical, verticalStructure)
vertical = cv2.dilate(vertical, verticalStructure)

After this, I know I would need to isolate the lines and mask the original image with the white lines, however I'm not really sure on how to proceed.

Does anyone have any suggestion?

Answer 1

Jeru's answer already gives you what you want. But I wanted to add an alternative that is maybe a bit more general than what you have so far.

You are converting the color image to gray-value, then apply adaptive threshold in an attempt to find lines. You filter this to get only the long horizontal and vertical lines, then use that mask to paint the original image white at those locations.

Here we look for all lines, and remove them from the image making painting them with whatever the surrounding color is. This process does not involve thresholding at all, all morphological operations are applied to the channels of the color image.

Ideally we'd use color morphology, but implementations of that are rare. Mathematical morphology is based on maximum and minimum operations, and the maximum or minimum of a color triplet (ie a vector) is not well defined.

So instead we apply the following procedure to each of the three color channels independently. This should produce results that are good enough for this application:

1. Extract the red channel: take the input RGB image, and extract the first channel. This is a gray-value image. We'll call this image channel .

2. Apply a top-hat filter to detect the thin structures: the difference between a closing with a small structuring element (SE) applied to channel , and channel (a closing is a dilation followed by an erosion with the same SE, you're using this to find lines as well). We'll call this output thin . thin = closing(channel)-channel . This step is similar to your local thresholding, but no actual threshold is applied. The resulting intensities indicate how dark the lines are wrt to background. If you add thin to channel , you'll fill in these thin structures. The size of the SE here determines what is considered "thin".

3. Filter out the short lines, to keep only the long ones: apply an opening with a long horizontal SE to thin , and an opening with a long vertical SE to thin , and take the maximum of the two result. We'll call this lines . Note that this is the same process you used to generate horizontal and vertical . Instead of adding them together as Jeru suggested, we take the maximum. This makes it so that output intensities still match the contrast in channel . (In Mathematical Morphology parlance, the supremum of openings is an opening). The length of the SEs here determines what is long enough to be a line.

4. Fill in the lines in the original image channel: now simply add lines to channel . Write the result to the first channel of the output image.

5. Repeat the same process with the other two channels.

Using PyDIP this is quite a simple script:

import PyDIP as dip

input = dip.ImageReadTIFF('/home/cris/tmp/T4tbM.tif')
output = input.Copy()

for ii in range(0,3):
   channel = output.TensorElement(ii)
   thin = dip.Closing(channel, dip.SE(5, 'rectangular')) - channel
   vertical = dip.Opening(thin, dip.SE([100,1], 'rectangular'))
   horizontal = dip.Opening(thin, dip.SE([1,100], 'rectangular'))
   lines = dip.Supremum(vertical,horizontal)
   channel += lines # overwrites output image

Edit:

When increasing the size of the first SE, above set to 5, to be large enough to remove also the thicker gray bar in the middle of the example image, causes part of the block containing the inverted text "POWERLIFTING" to be left in thin .

To filter out those parts as well, we can change the definition of thin as follows:

notthin = dip.Closing(channel, dip.SE(11, 'rectangular'), ["add max"]))
notthin = dip.MorphologicalReconstruction(notthin, channel, 1, "erosion")
thin = notthin - channel

That is, instead of thin=closing(channel)-channel , we do thin=reconstruct(closing(channel))-channel . The reconstruction simply expands selected (not thin) structures so that where part of a structure was selected, now the full structure is selected. The only thing that is now in thin are lines that are not connected to thicker structures.

I've also added "add max" as a boundary condition -- this causes the closing to expand the area outside the image with white, and therefore see lines at the edges of the image as lines.

Answer 2

To elaborate more here is what to do:

• First, add the resulting images of vertical and horizontal . This will give you an image containing both the horizontal and vertical lines. Since both the images are of type uint8 (unsigned 8-bit integer) adding them won't be a problem:

res = vertical + horizontal

• Finally, mask the resulting image obtained above with the original 3-channel image. This can be accomplished using cv2.bitwise_and :

fin = cv2.bitwise_and(image, image, mask = cv2.bitwise_not(res))

Answer 3

Do you want something like this?

image = cv2.imread('image.jpg', cv2.IMREAD_UNCHANGED);

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

ret,binary = cv2.threshold(gray, 170, 255, cv2.THRESH_BINARY)#|cv2.THRESH_OTSU)

V = cv2.Sobel(binary, cv2.CV_8U, dx=1, dy=0)
H = cv2.Sobel(binary, cv2.CV_8U, dx=0, dy=1)

kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3,3))
V = cv2.morphologyEx(V, cv2.MORPH_DILATE, kernel, iterations = 2)
H = cv2.morphologyEx(H, cv2.MORPH_DILATE, kernel, iterations = 2)

rows,cols = image.shape[:2]

mask = np.zeros(image.shape[:2], dtype=np.uint8)

contours = cv2.findContours(V, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[1]
for cnt in contours:
    (x,y,w,h) = cv2.boundingRect(cnt)
    # manipulate these values to change accuracy
    if h > rows/2 and w < 10:
        cv2.drawContours(mask, [cnt], -1, 255,-1)

contours = cv2.findContours(H, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[1]
for cnt in contours:
    (x,y,w,h) = cv2.boundingRect(cnt)
    # manipulate these values to change accuracy
    if w > cols/2 and h < 10:
        cv2.drawContours(mask, [cnt], -1, 255,-1)

mask = cv2.morphologyEx(mask, cv2.MORPH_DILATE, kernel, iterations = 2)
image[mask == 255] = (255,255,255)

Answer 4

So I have found a solution by using part of Juke's suggestion. Eventually I would need to continue to process the image using a binary mode so figured I might keep it that way.

First, add the resulting images of vertical and horizontal . This will give you an image containing both the horizontal and vertical lines. Since both the images are of type uint8 (unsigned 8-bit integer) adding them won't be a problem:

res = vertical + horizontal

Then, subtract res from the original input image tresh , which was used to find the lines. This will remove the white lines and can than be used to apply some other morphology transformations.

fin = thresh - res

Answer 5

A sample for removing horizontal lines.

Sample image:

import cv2
import numpy as np

img = cv2.imread("Image path", 0)

if len(img.shape) != 2:
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
else:
    gray = img

gray = cv2.bitwise_not(gray)
bw = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, 
cv2.THRESH_BINARY, 15, -2)

horizontal = np.copy(bw)

cols = horizontal.shape[1]
horizontal_size = cols // 30

horizontalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontal_size, 1))

horizontal = cv2.erode(horizontal, horizontalStructure)
horizontal = cv2.dilate(horizontal, horizontalStructure)

cv2.imwrite("horizontal_lines_extracted.png", horizontal)

horizontal_inv = cv2.bitwise_not(horizontal)
cv2.imwrite("inverse_extracted.png", horizontal_inv)

masked_img = cv2.bitwise_and(gray, gray, mask=horizontal_inv)
masked_img_inv = cv2.bitwise_not(masked_img)

cv2.imwrite("masked_img.jpg", masked_img_inv)

=> horizontal_lines_extracted.png:

=> inverse_extracted.png

=> masked_img.png(resultant image after masking)