I'll just write the part where the pre-processing could be improved. Again, the colour of the text is very easy to select and threshold on it with cv2.inRange:

im = cv2.imread("text.png") # read image
lower = (60, 60, 0) # define lower limit
upper = (100, 100, 40) # and upper limit
mask = cv2.inRange(im, lower, upper) # use cv2.inRange
maskClosed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((3,3), dtype = np.uint8)) # use morph close to fill the holes in the mask
plt.imshow(maskClosed) # show mask

The result:

You can use this instead of your current pre-processing part. The letters should be very easily separated from each other.

The idea you presented for text line segmentation is correct. But the approach needs some tweaking.

Note:

Whenever you want to mask a portion of the image, make sure the masked region is in white. Because when finding contours the algorithm looks for white regions. Since you were looking for contours that were in black the algorithm missed it.

The following is modified with the above idea.

Solution:

img = cv2.imread(image_file)
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh2 = cv2.threshold(img_gray, 150, 255, cv2.THRESH_BINARY_INV)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (150,2))
mask = cv2.morphologyEx(thresh2, cv2.MORPH_DILATE, kernel)

Below is the mask image:

bboxes = []
bboxes_img = img.copy()
contours = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours = contours[0] if len(contours) == 2 else contours[1]
for cntr in contours:
    x,y,w,h = cv2.boundingRect(cntr)
    cv2.rectangle(bboxes_img, (x, y), (x+w, y+h), (0,0,255), 1)
    bboxes.append((x,y,w,h))

The following is the final result with bounding boxes:

You can now add your portion of the code to save each region as a separate image file. You can try modifying the kernel parameters and exploring different morphological operations to get a better mask region.

Hope this puts you on the right track!

A great tutorial on the first step you described is available at pyimagesearch (and they have great tutorials in general)

In short, as described by Ella, you would have to use cv2.CHAIN_APPROX_SIMPLE. A slightly more robust method would be to use cv2.RETR_LIST instead of cv2.RETR_EXTERNAL and then sort the areas, as it should decently work even in white backgrounds/if the page inscribes a bigger shape in the background, etc.

Coming to the second part of your question, a good way to segment the characters would be to use the Maximally stable extremal region extractor available in OpenCV. A complete implementation in CPP is available here in a project I was helping out in recently. The Python implementation would go along the lines of (Code below works for OpenCV 3.0+. For the OpenCV 2.x syntax, check it up online)

import cv2

img = cv2.imread('test.jpg')
mser = cv2.MSER_create()

#Resize the image so that MSER can work better
img = cv2.resize(img, (img.shape[1]*2, img.shape[0]*2))

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
vis = img.copy()

regions = mser.detectRegions(gray)
hulls = [cv2.convexHull(p.reshape(-1, 1, 2)) for p in regions[0]]
cv2.polylines(vis, hulls, 1, (0,255,0)) 

cv2.namedWindow('img', 0)
cv2.imshow('img', vis)
while(cv2.waitKey()!=ord('q')):
    continue
cv2.destroyAllWindows()

This gives the output as

Now, to eliminate the false positives, you can simply cycle through the points in hulls, and calculate the perimeter (sum of distance between all adjacent points in hulls[i], where hulls[i] is a list of all points in one convexHull). If the perimeter is too large, classify it as not a character.

The diagnol lines across the image are coming because the border of the image is black. that can simply be removed by adding the following line as soon as the image is read (below line 7)

img = img[5:-5,5:-5,:]

which gives the output

hope this helps.

To find each line:

• Threshold the image with
• Close the image with custom kernel that only connects vertical blobs (xAxisKernel() is the custom function i wrote to create the kernel that has 1 in its center and neighbouring rows, 0 elswhere )
• Find external contours which will be the contours of each line

This is the thresholded image:

This is the closed image with 17 kernel size, now all lines are connected as one big blob:

This is the bounding boxes for each contour which are all detected lines:

Now repeating the same procedure for detecting each word in one line:

• Cut the line portion of image
• Threshold the cut portion (or just cut the thresholded verison)
• Close the image with custom kernel that only connects vertical blobs
• Find external contours which will be the contours of each word

This the thresholded line image:

This is the closed image with 7 kernel size, smaller kernel because we just want to connect the letters of a word instead of connecting each word together:

This is the bounding boxes for each contour which are all detected lines:

This is the final result of word detection:

From this point you can use your own code that detects each letter of a word for every detected word.

This is the complete code:

import cv2
import numpy

#Funciton to create custom kernel
def xAxisKernel(size):
    size = size if size%2 else size+1
    xkernel = numpy.zeros((size,size),dtype=numpy.uint8)
    center = size//2
    for j in range(size):
        xkernel[center][j] = 1
        xkernel[center-1][j] = 1
        xkernel[center+1][j] = 1
    return xkernel

#Give filtered image, get bounding boxes for the lines
def findLines(full_image):

    #Threshold the image, close with custom kernel to connect only vertical blobs which are letters
    gray = cv2.cvtColor(full_image,cv2.COLOR_BGR2GRAY)
    _,thresh = cv2.threshold(gray,200,255,cv2.THRESH_BINARY_INV)
    closed = cv2.morphologyEx(thresh,cv2.MORPH_CLOSE,xAxisKernel(17)) #Connecting every word of a line together
    
    #Find line contours in the closed image
    contours,hierarchy = cv2.findContours(closed,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
    lines = []
    for cnt in contours:
        if cv2.contourArea(cnt)>100: #to eliminate the dots
            x,y,w,h = cv2.boundingRect(cnt)
            lines.append([x,y,w,h])
    return lines


#Give the cropped image of a line, get bounding boxes for the words 
def findWords(line_image):

    #Add white border around the line for better filtering
    line_image = cv2.copyMakeBorder(line_image,top=10,bottom=10,left=10,right=10,borderType=cv2.BORDER_CONSTANT,value=[255, 255, 255])

    #Threshold the image, close with custom kernel to connect only vertical blobs which are letters
    gray = cv2.cvtColor(line_image,cv2.COLOR_BGR2GRAY)
    _,thresh = cv2.threshold(gray,200,255,cv2.THRESH_BINARY_INV)
    closed = cv2.morphologyEx(thresh,cv2.MORPH_CLOSE,xAxisKernel(7)) #Connecting the letters of a word

    #Find word contours in the closed image
    contours,hierarchy = cv2.findContours(closed,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
    words = []
    for cnt in contours:
        if cv2.contourArea(cnt)>100:#to eliminate the dots
            x,y,w,h = cv2.boundingRect(cnt)
            words.append([x-10,y-10,w,h]) #subtracting the added border size for correction
            cv2.rectangle(line_image,(x,y),(x+w,y+h),(0,0,255),2)

    return words


#Read the image
image = cv2.imread('ph1.png')
height,width,channel = image.shape

# Find all lines in the image
al_lines = findLines(image)

# Iterate on each line and find all words
for line in al_lines:
    lineX,lineY,lineW,lineH = line #Line bounding box coordinates
    words = findWords(image[lineY:lineY+lineH,lineX:lineX+lineW])
    
    for word in words:
        x,y,w,h = word #Word bounding box coordinates
        
        # Add line start position as offset to word start position for correction
        x = x+lineX
        y = y+lineY
        #Draw bounding box around each word
        cv2.rectangle(image,(x,y),(x+w,y+h),(0,0,255),2)

cv2.imshow('Original',image)
cv2.waitKey(0)

I think your image has a multiline text. In that case, first you have to do is to detect these lines.

For that, first binarize the image using Otsu's method or adaptive thresholding.

Then,you can use something what is called as "Horizontal histogram". It is like a histogram itself, but shows where there are lines and where there are blank spaces. So devide the images at blank lines, and you get each line. Below is the image of a horizontal histogram.

Now for each line, find horizontal histogram. Before that, try to do some dilatation and erosion, so that all letters are grouped together. Then you can find connected components on each line to get each word. Then draw boundaries.

Below image shows both horizontal and vertical histograms:

This SOF might help : How to convert an image into character segments?

I think you should follow this where show that Sorting Contours using Python and OpenCV.

The basic steps that I follow are:

1. Blur the image and if necessary convert to gray scale first.
2. Apply the Canny edge detection algorithm to find the outline of every character.
3. Pass the edge detected image to the Adaptive Algorithm which works better considering the neighbouring points.
4. Perform dilation which performs better on line segmentation.
5. Perform the line segmentation on the copy of dilated image which produces the segments randomly.
6. Finally sort the segment in a order "Top to bottom".

I got the required segmentation by making a change to the above code on the line:

kernel = np.ones((5,5), np.uint8)

I changed it to :

kernel = np.ones((5,100), np.uint8)

Now i get the outputs as following This also works with handwritten text images with lines that are not perfectly horizontal:

EDIT : For getting individual characters out of a word, do the following :

1. Resize the contour containing the word using the code as follows.

   im = cv2.resize(image,None,fx=4, fy=4, interpolation = cv2.INTER_CUBIC)
   

2. Apply same contour detection process as in line segmentation, but with a kernel of size (5,5), i.e :

   kernel = np.ones((5,5), np.uint8)
   img_dilation = cv2.dilate(im_th, kernel, iterations=1)