Proste rozpoznawanie cyfr OCR w OpenCV-Python

[6]}cóż, postanowiłem poćwiczyć się na moim pytaniu, aby rozwiązać powyższy problem. Chciałem zaimplementować simpl OCR przy użyciu funkcji KNearest lub SVM w OpenCV. A poniżej jest to, co zrobiłem i jak. ( służy tylko do nauki używania KNearest do prostych celów OCR).

1) moje pierwsze pytanie dotyczyło letter_recognition.plik danych dostarczany z samplami OpenCV. Chciałem wiedzieć, co jest w tych aktach.

Zawiera literę, wraz z 16 cechami tego list.

Oraz this SOF pomógł mi go znaleźć. Te 16 cech wyjaśniono w artykuleLetter Recognition Using Holland-Style Adaptive Classifiers. ( Chociaż nie rozumiem niektórych funkcji na końcu)

2) ponieważ wiedziałem, bez zrozumienia wszystkich tych funkcji, trudno jest zrobić tę metodę. Próbowałem innych prac, ale wszystkie były trochę trudne dla początkujących.

So I just decided to take all the pixel values as my features. (nie martwiłem się dokładnością ani wydajnością, chciałem tylko, aby działało, przynajmniej z najmniejsza dokładność)

Zrobiłem poniższy obrazek dla moich danych treningowych:

( wiem, że ilość danych treningowych jest mniejsza. Ale ponieważ wszystkie litery są tej samej czcionki i rozmiaru, postanowiłem spróbować na tym).

Aby przygotować dane do treningu, zrobiłem mały kod w OpenCV. Robi następujące rzeczy:

A) ładuje obraz.

B) wybiera cyfry (oczywiście poprzez znajdowanie konturu i stosowanie ograniczeń obszaru i wysokości liter, aby uniknąć fałszywe wykrywanie).

C) rysuje obwiedniowy prostokąt wokół jednej litery i czeka na key press manually. Tym razem sami wciskamy klawisz cyfry odpowiadający literze w pudełku.

D) Po naciśnięciu odpowiedniego klawisza cyfry, zmienia rozmiar tego pola do 10x10 i zapisuje wartości 100 pikseli w tablicy(tutaj, próbki) i odpowiadające ręcznie wprowadzone cyfry w innej tablicy (tutaj, odpowiedzi).

E) następnie zapisz obie tablice w oddzielnych plikach txt.

Na końcu ręczna klasyfikacja cyfr, wszystkie cyfry w danych pociągu (pociąg.png) są oznaczane ręcznie przez nas, obraz będzie wyglądał jak poniżej:

Poniżej znajduje się kod, którego użyłem do powyższego celu (oczywiście nie tak czysty):

import sys

import numpy as np
import cv2

im = cv2.imread('pitrain.png')
im3 = im.copy()

gray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray,(5,5),0)
thresh = cv2.adaptiveThreshold(blur,255,1,1,11,2)

#################      Now finding Contours         ###################

contours,hierarchy = cv2.findContours(thresh,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)

samples =  np.empty((0,100))
responses = []
keys = [i for i in range(48,58)]

for cnt in contours:
    if cv2.contourArea(cnt)>50:
        [x,y,w,h] = cv2.boundingRect(cnt)

        if  h>28:
            cv2.rectangle(im,(x,y),(x+w,y+h),(0,0,255),2)
            roi = thresh[y:y+h,x:x+w]
            roismall = cv2.resize(roi,(10,10))
            cv2.imshow('norm',im)
            key = cv2.waitKey(0)

            if key == 27:  # (escape to quit)
                sys.exit()
            elif key in keys:
                responses.append(int(chr(key)))
                sample = roismall.reshape((1,100))
                samples = np.append(samples,sample,0)

responses = np.array(responses,np.float32)
responses = responses.reshape((responses.size,1))
print "training complete"

np.savetxt('generalsamples.data',samples)
np.savetxt('generalresponses.data',responses)

Teraz wchodzimy do części szkoleniowej i testowej.

Do części testowej użyłem poniższego obrazka, który ma ten sam typ liter, których używałem do treningu.

Na szkolenia wykonujemy jako follows :

A) załaduj pliki txt zapisane wcześniej

B) Utwórz instancję klasyfikatora, której używamy (tutaj jest to KNearest)

C) następnie używamy KNearest.funkcja train do trenowania danych

Do celów testowych wykonujemy następujące czynności:

A) wczytujemy obraz używany do testowania

B) przetwarza obraz jak wcześniej i wyodrębnia każdą cyfrę za pomocą metod konturu

C) narysuj dla niego obwiednię, a następnie zmień jej rozmiar na 10x10 i zachowaj jej wartości pikseli w tablicy, jak zrobiono wcześniej.

D) następnie używamy KNearest.funkcja find_nearest (), aby znaleźć najbliższy element do tego, który podaliśmy. (Jeśli ma szczęście, rozpoznaje poprawną cyfrę.)

Dodałem dwa ostatnie kroki ( trening i testy) w jednym kodzie poniżej:

import cv2
import numpy as np

#######   training part    ############### 
samples = np.loadtxt('generalsamples.data',np.float32)
responses = np.loadtxt('generalresponses.data',np.float32)
responses = responses.reshape((responses.size,1))

model = cv2.KNearest()
model.train(samples,responses)

############################# testing part  #########################

im = cv2.imread('pi.png')
out = np.zeros(im.shape,np.uint8)
gray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
thresh = cv2.adaptiveThreshold(gray,255,1,1,11,2)

contours,hierarchy = cv2.findContours(thresh,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)

for cnt in contours:
    if cv2.contourArea(cnt)>50:
        [x,y,w,h] = cv2.boundingRect(cnt)
        if  h>28:
            cv2.rectangle(im,(x,y),(x+w,y+h),(0,255,0),2)
            roi = thresh[y:y+h,x:x+w]
            roismall = cv2.resize(roi,(10,10))
            roismall = roismall.reshape((1,100))
            roismall = np.float32(roismall)
            retval, results, neigh_resp, dists = model.find_nearest(roismall, k = 1)
            string = str(int((results[0][0])))
            cv2.putText(out,string,(x,y+h),0,1,(0,255,0))

cv2.imshow('im',im)
cv2.imshow('out',out)
cv2.waitKey(0)

I zadziałało, poniżej wynik jaki otrzymałem:

Ale każdy sposób, to jest dobry początek, aby przejść dla początkujących (mam nadzieję, że tak).