lilian
/
OCR_paper_form
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
66KB
Tree: ed1e645236
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ed1e645236'
${ noResults }
OCR_paper_form/bin/signal_processing.py

234 lines
8.2KB
Raw Blame History 

  1. import os

  2. import numpy as np

  3. import matplotlib.pyplot as plt

  4. import scipy as scp

  5. 

  6. 

  7. 

  8. def levenshteinDistance(s1, s2):

  9.     if len(s1) > len(s2):

  10.         s1, s2 = s2, s1

  11. 

  12.     distances = range(len(s1) + 1)

  13.     for i2, c2 in enumerate(s2):

  14.         distances_ = [i2+1]

  15.         for i1, c1 in enumerate(s1):

  16.             if c1 == c2:

  17.                 distances_.append(distances[i1])

  18.             else:

  19.                 distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))

  20.         distances = distances_

  21.     return distances[-1]

  22. 

  23. def unit_gaussian_filter(sigma):

  24.     """Create and returns a 2D square gaussian filter"""

  25.     x_grid = np.linspace(-3*int(sigma+1),3*int(sigma+1), 6*int(sigma+1)+1)

  26.     X,Y = np.meshgrid(x_grid, x_grid)

  27.     R = X*0

  28.     for i in range(0,R.shape[0]):

  29.         for j in range(0,R.shape[1]):

  30.             R[i,j] = 1 / (2*np.pi*sigma*sigma) * np.exp(-(X[i,j]*X[i,j] + Y[i,j]*Y[i,j]) / (2*sigma*sigma))

  31.     return R

  32. 

  33. def calculate_img_correlation(img1, img2):

  34.     """Calculation of the correlation between the two images.

  35.     Produces a 2D map, and returns the maximum of it."""

  36.     if(img2.size > img1.size):

  37.         img2, img1 = img1, img2

  38. 

  39.     #img_template = scp.signal.correlate2d(img1, img1, "same")

  40.     img_corr = scp.signal.correlate2d(img1, img2, "same")

  41. 

  42.     # sum_template = np.sum(img_template)

  43.     # sum_test = np.sum(img_test)

  44.     # ratio = sum_template/sum_test

  45.     # img_test = img_test*ratio

  46. 

  47.     # max_template = np.amax(img_template)

  48.     max_corr = np.amax(img_corr)

  49.     index = np.where(img_corr == max_corr)

  50.     # ratio_max = max_template/max_test

  51. 

  52.     return max_corr, index

  53. 

  54. def otsu_algo(img):

  55.     """Calculates the threshold between upper and lower values in an image.

  56.     Uses the Otsu algorithm and returns the lower threshold value."""

  57.     histo, edges = np.histogram(img, bins=255, range=(0,255))

  58.     sum_tot = np.sum(histo)

  59.     w = np.zeros(len(histo))

  60.     mu = np.zeros(len(histo))

  61.     w[0] = histo[0]

  62.     mu[0] = 1*histo[0]

  63.     for i in range(1,len(histo)):

  64.         w[i] = w[i-1] + histo[i]

  65.         mu[i] = mu[i-1] + (i+1)*histo[i]

  66. 

  67.     w = w/sum_tot

  68.     mu = mu/sum_tot

  69.     muN = mu[len(histo)-1]

  70. 

  71.     crit = np.zeros(len(histo))

  72.     for i in range(0,len(histo)):

  73.         crit[i] = w[i]*(muN-mu[i])*(muN-mu[i]) + (1-w[i])*mu[i]*mu[i]

  74. 

  75.     max_crit = np.amax(crit)

  76.     place = np.where(crit == max_crit)

  77.     if(type(place) != int):

  78.         place = place[0]

  79.     thresh = int(np.floor(place[0]/len(histo)*np.amax(img)))

  80.     thresh = edges[thresh]

  81.     return thresh

  82. 

  83. def img_cells_zero(img_origin, img_gauss, threshold):

  84.     """Switches off all the values of ing_gauss lower than the threshold in img_origin."""

  85.     for i in range(0,img_origin.shape[0]):

  86.         for j in range(0,img_origin.shape[1]):

  87.             if(img_gauss[i,j]<=threshold):

  88.                 img_origin[i,j]=0

  89. 

  90. def img_one_border_remove(img, start="begin", axis=0):

  91.     """Find the limit of a black border in an image.

  92.     Use "begin" or "end" through the selected axis (0 or 1) to

  93.     find the limit from the upper/left or lower/right borders of the image.

  94.     Returns the index limit."""

  95.     if(start=="begin"):

  96.         add = 1

  97.         i = 0

  98.     else:

  99.         add = -1

  100.         i = img.shape[axis-1]-1

  101.     axis_sum = np.sum(img, axis=axis)

  102.     while(axis_sum[i] == 0):

  103.         i = i+add

  104.     return i

  105. 

  106. def img_black_borders_remove(img):

  107.     """Find the borders of an image and removes them."""

  108.     y_beg = img_one_border_remove(img)

  109.     x_beg = img_one_border_remove(img, axis=1)

  110.     y_end = img_one_border_remove(img, start="end")

  111.     x_end = img_one_border_remove(img, start="end", axis=1)

  112.     return img[x_beg:x_end, y_beg:y_end]

  113. 

  114. def resize(img, shape):

  115.     """Resizes an image to a different shape with the bilinear method."""

  116.     img_final = np.zeros(shape)

  117.     y_vect = np.linspace(0, img.shape[0]-1, shape[0])

  118.     x_vect = np.linspace(0, img.shape[1]-1, shape[1])

  119.     for j in range(0,shape[0]):

  120.         for i in range(0,shape[1]):

  121.             y0 = int(np.floor(y_vect[j]))

  122.             y1 = int(np.ceil(y_vect[j]))

  123.             x0 = int(np.floor(x_vect[i]))

  124.             x1 = int(np.ceil(x_vect[i]))

  125.             x_coma = x_vect[i]-np.floor(x_vect[i])

  126.             y_coma = y_vect[j]-np.floor(y_vect[j])

  127. 

  128.             img_final[j,i] = (1-x_coma)*(1-y_coma)*img[y0,x0] + (x_coma)*(1-y_coma)*img[y0,x1] + (1-x_coma)*(y_coma)*img[y1,x0] + (x_coma)*(y_coma)*img[y1,x1]

  129.     return img_final

  130. 

  131. def signal_processing_process(img_template, img_scanned):

  132.     img_gauss = scp.signal.correlate2d(img_scanned, unit_gaussian_filter(1.5), "same")

  133.     thresh = otsu_algo(img_gauss)

  134.     img_cells_zero(img_scanned, img_gauss, thresh)

  135.     im_trunc = img_black_borders_remove(img_scanned)

  136.     ratio = (img_template.shape[0]/im_trunc.shape[0], img_template.shape[1]/im_trunc.shape[1])

  137. 

  138.     shape1 = (int(img_template.shape[0]/ratio[0]), int(img_template.shape[1]/ratio[0]))

  139.     shape2 = (int(img_template.shape[0]/ratio[1]), int(img_template.shape[1]/ratio[1]))

  140. 

  141.     if(shape1[0] != shape2[0] or shape1[1] != shape2[1]):

  142.         img_final_1 = resize(img_template, shape1)

  143.         img_final_2 = resize(img_template, shape2)

  144.         max1, location1 = calculate_img_correlation(img_final_1, im_trunc)

  145.         max2, location2 = calculate_img_correlation(img_final_2, im_trunc)

  146.         if(max1 > max2):

  147.             img_final = img_final_1

  148.             ratio = ratio[0]

  149.             location = location1

  150.         else:

  151.             img_final = img_final_2

  152.             ratio = ratio[1]

  153.             location = location2

  154.     offset = (img_final.shape[0]//2-location[0], img_final.shape[1]//2-location[1])

  155.     return img_final, im_trunc, ratio, offset

  156. 

  157. 

  158. # to be tried:

  159. # - delete black borders (gauss to highlight written content, blacken and delete what is not the paper)

  160. # - resize with root method

  161. # no rotation !

  162. 

  163. if __name__ == "__main__":

  164.     #used for tests

  165.     im1 = plt.imread("/home/inc0nnu-rol/Documents/La Gemme/OCR_paper_form/test.png")

  166.     im2 = plt.imread("/home/inc0nnu-rol/Documents/La Gemme/OCR_paper_form/test2.png")

  167.     im3 = plt.imread("/home/inc0nnu-rol/Documents/La Gemme/OCR_paper_form/test3.png")

  168.     im1 = (im1[:,:,0]+im1[:,:,1]+im1[:,:,2])*255//3

  169.     im2 = (im2[:,:,0]+im2[:,:,1]+im2[:,:,2])*255//3

  170.     im3 = (im3[:,:,0]+im3[:,:,1]+im3[:,:,2])*255//3

  171. 

  172.     img_fin, ratios, offset = signal_processing_process(im1, im3)

  173.     # img_gauss = scp.signal.correlate2d(im3, unit_gaussian_filter(1.5), "same")

  174.     #

  175.     # thresh = otsu_algo(img_gauss)

  176.     # img_cells_zero(im3, img_gauss, thresh)

  177.     # im_trunc = img_black_borders_remove(im3)

  178.     #

  179.     # plt.imshow(im_trunc)

  180.     # plt.show()

  181.     #

  182.     # ratio = (im1.shape[0]/im_trunc.shape[0], im1.shape[1]/im_trunc.shape[1])

  183.     #

  184.     # shape1 = (int(im1.shape[0]/ratio[0]), int(im1.shape[1]/ratio[0]))

  185.     # shape2 = (int(im1.shape[0]/ratio[1]), int(im1.shape[1]/ratio[1]))

  186.     #

  187.     # if(shape1[0] != shape2[0] or shape1[1] != shape2[1]):

  188.     #     img_final_1 = resize(im1, shape1)

  189.     #     img_final_2 = resize(im1, shape2)

  190.     #     max1 = calculate_img_correlation(img_final_1, im_trunc)

  191.     #     max2 = calculate_img_correlation(img_final_2, im_trunc)

  192.     #     if(max1 > max2):

  193.     #         img_final = img_final_1

  194.     #     else:

  195.     #         img_final = img_final_2

  196. 

  197.     print(ratios, offset)

  198.     plt.imshow(img_fin)

  199.     plt.show()

  200. 

  201. 

  202. 

  203.     # Gauss = unit_gaussian_filter(1.5)

  204.     # im_template = scp.signal.correlate2d(im1, im1, "same")

  205.     # im_filt = scp.signal.correlate2d(im2, im_trunc, "same")

  206.     #

  207.     # plt.imshow(im_test)

  208.     # plt.show()

  209.     #

  210.     # sum_template = np.sum(im_template)

  211.     # sum3 = np.sum(im_test)

  212.     # ratio = sum_template/sum3

  213.     # im_test = im_test*ratio

  214.     #

  215.     # max_template = np.amax(im_template)

  216.     # min_template = np.amin(im_template)

  217.     # max_im_test = np.amax(im_test)

  218.     # min_im_test = np.amin(im_test)

  219.     #

  220.     # ratio_max = max_template/max_im_test

  221.     # ratio_min = min_template/min_im_test

  222.     #

  223.     # index_max_template = np.where(im_template == np.amax(im_template))

  224.     # index_min_template = np.where(im_template == np.amin(im_template))

  225.     # index_max_im_test = np.where(im_test == np.amax(im_test))

  226.     # index_min_im_test = np.where(im_test == np.amin(im_test))

  227. 

  228.     # Gauss = unit_gaussian_filter(5)

  229.     # plt.imshow(Gauss)

  230.     # plt.show()

  231.     # print(np.sum(Gauss))

  232. 

  233.     #max_index = (bla[0][0], bla[1][0])