Reconnaissance OCR à simple chiffre en OpenCV-Python

Eh bien, j'ai décidé de m'entraîner sur ma question pour résoudre le problème ci-dessus. Ce que je voulais, c'est mettre en place un OCR simple en utilisant les fonctionnalités KNearest ou SVM dans OpenCV. Et voici ce que j'ai fait et comment. ( c'est juste pour apprendre à utiliser KNearest pour des buts OCR simples).

1) ma première question portait sur la reconnaissance des lettres.fichier de données fourni avec les échantillons OpenCV. Je voulais savoir ce qu'il y avait dans ce dossier.

It contient une lettre, avec 16 caractéristiques de cette lettre.

et this SOF m'ont aidé à le trouver. Ces 16 caractéristiques sont expliquées dans le document Letter Recognition Using Holland-Style Adaptive Classifiers . ( Bien que je n'ai pas compris certaines des fonctionnalités à la fin)

2) puisque je savais, sans comprendre toutes ces caractéristiques, il est difficile de faire cette méthode. J'ai essayé quelques autres papiers, mais tous ont été un peu difficile pour un débutant.

So I just decided to take all the pixel values as my features. (Je ne m'inquiétais pas de l'exactitude ou de la performance, je voulais juste que cela fonctionne, au moins avec la moindre précision)

j'ai pris ci-dessous l'image pour mes données de formation:

( je sais la quantité de données d'apprentissage est moins. Mais comme toutes les lettres ont la même police et la même taille, j'ai décidé d'essayer ceci).

pour préparer les données pour la formation, j'ai fait un petit code dans OpenCV. Il fait les choses suivantes:

A) il charge l'image.

b) choisit les chiffres ( évidemment en trouvant le contour et en appliquant des contraintes sur la surface et la hauteur des lettres pour éviter les fausses détections).

C) dessine le rectangle limitatif autour d'une lettre et attend key press manually . Cette fois nous appuyez sur la touche de chiffre nous correspondant à la lettre dans la boîte.

D) une fois que la touche de chiffre correspondante est pressée, il redimensionne cette case à 10x10 et sauve 100 valeurs de pixel dans un tableau (ici, samples) et le chiffre correspondant entré manuellement dans un autre tableau(ici, réponses).

E) puis enregistrer les deux tableaux dans des fichiers TXT séparés.

à la fin de la classification manuelle des chiffres, tous les chiffres des données relatives au train( train.png) sont étiqueté manuellement par nous-mêmes, l'image ressemblera à ci-dessous:

ci-dessous est le code que j'ai utilisé à la fin ci-dessus (bien sûr, pas si propre):

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)

---

maintenant, nous entrons dans la partie de formation et de test.

pour tester la partie I utilisée ci-dessous image, qui a le même type de lettres que j'ai utilisé pour former.

Pour la formation, nous faisons comme suit :

a) charger les fichiers txt que nous avons déjà enregistrés plus tôt

B) créer une instance de classifier que nous utilisons ( ici, C'est KNearest)

C) puis nous utilisons KNearest.fonction train pour former les données

à des fins d'essai, nous faisons comme suit:

A) Nous charger l'image utilisée pour l'essai

B) traiter l'image comme une image antérieure et extraire chaque chiffre à l'aide des méthodes de contour

C) Tirage au sort de la boîte englobante, puis redimensionner à 10x10, et de stocker les valeurs des pixels dans un tableau comme fait précédemment.

D) nous utilisons alors KNearest.find_nearest () fonction pour trouver l'article le plus proche de celui que nous avons donné. ( Si la chance, il reconnaît le bon chiffre.)

j'ai inclus les deux dernières étapes ( formation et tests) en un seul code ci-dessous:

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)

et il a fonctionné, ci - dessous est le résultat que j'ai obtenu:

---

" ici, il a fonctionné avec une précision de 100%. Je suppose que c'est parce que tous les chiffres sont de même type et de même taille.

Mais de toute façon, c'est un bon début pour aller pour les débutants ( je l'espère).