Incorrect character detection in OCR project - c++

Question

I have done a DNI text recognition project using Visual Studio, the OpenCV library and the KNN recognition method.
To simplify the project I cut the fields whose information I want to extract and I did the whole process to each of them, obtaining good results.
But I have noticed that the program confuses an M with N and also classifies O as 0.
How could I fix it?
I will show you the field where detection incorrect occurs.
CODE:
#include <iostream>
#include <vector>
#include <opencv2\opencv.hpp>
#include <opencv2\highgui/highgui.hpp>
#include <opencv2\core\core.hpp>
#include <opencv2\ml\ml.hpp>
#include "Preproceso.h"
// VARIABLES GLOBALES
/////////////////////////////////////////////////////
const int AREA_MINIMA_DE_CONTORNO = 70;
const int ANCHO_IMAGEN_REDIM = 20;
const int ALTURA_IMAGEN_REDIM = 30;
class ContornoConDatos {
public:
// variables miembro
///////////////////////////////////////////////////////////////////////////
std::vector<cv::Point> ptContorno;
cv::Rect rectanguloDelimitador;
float fltAreaDelContorno;
////////////////////////////////////////////////////////////////////////////
bool comprobarSiContornoValido() {
if (fltAreaDelContorno < AREA_MINIMA_DE_CONTORNO) return false;
return true;
}
////////////////////////////////////////////////////////////////////////////
static bool ordenarPosicionXRectDelim(const ContornoConDatos& ccdIzquierda, const ContornoConDatos& ccdDerecha) {
return(ccdIzquierda.rectanguloDelimitador.x < ccdDerecha.rectanguloDelimitador.x);
}
};
//////////////////////////////////////////////////////////////////
void preprocess(cv::Mat &imagenOriginal, cv::Mat &imagenEscalaDeGrises, cv::Mat &imagenUmbralizada) {
imagenEscalaDeGrises = extraerValor(imagenOriginal);
cv::Mat imagenMaxContrasteEscalaDeGrises = maximizarContraste(imagenEscalaDeGrises);
cv::Mat imagenSuavizada;
cv::GaussianBlur(imagenMaxContrasteEscalaDeGrises, imagenSuavizada, TAMAÑO_FILTRO_SUAVE_GAUSSIANO, 0);
cv::adaptiveThreshold(imagenSuavizada, imagenUmbralizada, 255.0, CV_ADAPTIVE_THRESH_GAUSSIAN_C, CV_THRESH_BINARY_INV, TAMAÑO_BLOQUE_UMBRAL, ANCHO_UMBRAL);
}
///////////////////////////////////////////////////////////////////
cv::Mat extraerValor(cv::Mat &imagenOriginal) {
cv::Mat imagenHSV;
std::vector<cv::Mat> vectorDeImagenesHSV(2);
cv::Mat imagenValor;
cv::cvtColor(imagenOriginal, imagenHSV, CV_BGR2HSV);
cv::split(imagenHSV, vectorDeImagenesHSV);
imagenValor = vectorDeImagenesHSV[2];
return(imagenValor);
}
//////////////////////////////////////////////////////////////
cv::Mat maximizarContraste(cv::Mat &imagenEscalaDeGrises) {
cv::Mat imagenTopHat;
cv::Mat imagenBlackHat;
cv::Mat imagenEscalaDeGrisesMasTopHat;
cv::Mat imagenEscalaDeGrisesMasTopHatMenosBlackHat;
cv::Mat structuringElement = cv::getStructuringElement(CV_SHAPE_RECT, cv::Size(3, 3));
cv::morphologyEx(imagenEscalaDeGrises, imagenTopHat, CV_MOP_TOPHAT, structuringElement);
cv::morphologyEx(imagenEscalaDeGrises, imagenBlackHat, CV_MOP_BLACKHAT, structuringElement);
imagenEscalaDeGrisesMasTopHat = imagenEscalaDeGrises + imagenTopHat;
imagenEscalaDeGrisesMasTopHatMenosBlackHat = imagenEscalaDeGrisesMasTopHat - imagenBlackHat;
return(imagenEscalaDeGrisesMasTopHatMenosBlackHat);
}
//////////////////////////////////////////////////////
int main()
{
cv::Ptr<cv::ml::KNearest> kNearest(cv::ml::KNearest::create());
// read in training classifications ///////////////////////////////////////////////////
cv::Mat matrizClasificacionCaracteres;
cv::FileStorage archivoClasificacion("classifications.xml", cv::FileStorage::READ);
if (archivoClasificacion.isOpened() == false) {
std::cout << "error, unable to open training classifications file, exiting program\n\n";
return(0);
}
archivoClasificacion["classifications"] >> matrizClasificacionCaracteres;
archivoClasificacion.release();
// read in training images ////////////////////////////////////////////////////////////
cv::Mat matrizPixelesImagenReferencia;
cv::FileStorage archivoImagenes("images.xml", cv::FileStorage::READ);
if (archivoImagenes.isOpened() == false) {
std::cout << "error, unable to open training images file, exiting program\n\n";
return(0);
}
archivoImagenes["images"] >> matrizPixelesImagenReferencia;
archivoImagenes.release();
////////////////////////////////////////////////////////////////
//entrenamiento
//cv::Ptr<cv::ml::KNearest> kNearest(cv::ml::KNearest::create());
kNearest->setDefaultK(1);
kNearest->train(matrizPixelesImagenReferencia, cv::ml::ROW_SAMPLE, matrizClasificacionCaracteres);
//Leer la imagen base, de la cual obtengo solamente las dimensiones para asignarselas a mi verdadera imagen, con la que voy a trabajar
cv::Mat imagenBase = cv::imread("ImagenBase.png");
if (imagenBase.empty()) {
std::cout << "No se puede leer la imagen del archivo \n\n";
return (0);
}
////////////////////////////////////////////////////////////////
//Leer la imagen con la que voy a trabajar, a la cual le realizo el cambio de dimension
cv::Mat imagenOriginal = cv::imread("DNI-Jessica.jpg");
//cv::Mat imagenOriginal = cv::imread("DNI.png");
if (imagenOriginal.empty()) {
std::cout << "No se puede leer la imagen del archivo \n\n";
return (0);
}
// Redimensionar imagenOriginal al tamaño de imagenBase para que todas las imagenes de entrada tengan las mismas dimensiones
cv::resize(imagenOriginal, imagenOriginal, imagenBase.size());
cv::imshow("ImagenOriginal", imagenOriginal);
//Sección de interés 2: SEGUNDO APELLIDO///////////////////////////////
cv::Rect dimensionesROI2(255, 128, 300, 30);
//cv::Rect dimensionesROI2(250, 125, 300, 30);
//Recortar la imagen original para obtener ROI2
cv::Mat ROI2 = imagenOriginal(dimensionesROI2);
//PRE-PROCESADO DE LA IMAGEN/////////////////////////////////////////////
cv::Mat imagenEscalaDeGrises2;
cv::Mat imagenSuavizada2;
cv::Mat imagenUmbralizada2;
preprocess(ROI2, imagenSuavizada2, imagenUmbralizada2);
cv::threshold(imagenUmbralizada2, imagenUmbralizada2, 0.0, 255.0, CV_THRESH_BINARY | CV_THRESH_OTSU);
cv::Mat imagenDeTrabajo2 = imagenUmbralizada2.clone();
cv::imshow("Imagen pre-procesada 2", imagenUmbralizada2);
////////////////////////////////////////////////////////
std::vector<ContornoConDatos> todosLosContornos2;
std::vector<ContornoConDatos> contornosValidos2;
std::vector<std::vector<cv::Point> > ptContornos2;
std::vector<cv::Vec4i> v4iJerarquia2;
cv::findContours(imagenDeTrabajo2, ptContornos2, v4iJerarquia2, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
for (int i = 0; i < ptContornos2.size(); i++)
{
ContornoConDatos contornoConDatos2;
contornoConDatos2.ptContorno = ptContornos2[i];
contornoConDatos2.rectanguloDelimitador = cv::boundingRect(contornoConDatos2.ptContorno);
contornoConDatos2.fltAreaDelContorno = cv::contourArea(contornoConDatos2.ptContorno);
todosLosContornos2.push_back(contornoConDatos2);
}
for (int i = 0; i < todosLosContornos2.size(); i++)
{
if (todosLosContornos2[i].comprobarSiContornoValido())
{
contornosValidos2.push_back(todosLosContornos2[i]);
}
}
std::sort(contornosValidos2.begin(), contornosValidos2.end(), ContornoConDatos::ordenarPosicionXRectDelim);
std::string strCadenaFinal2;
for (int i = 0; i < contornosValidos2.size(); i++)
{
cv::rectangle(ROI2, contornosValidos2[i].rectanguloDelimitador, cv::Scalar(0, 255, 0), 2);
cv::Mat imagenROI2 = imagenUmbralizada2(contornosValidos2[i].rectanguloDelimitador);
cv::Mat imagenROIRedimensionada2;
cv::resize(imagenROI2, imagenROIRedimensionada2, cv::Size(ANCHO_IMAGEN_REDIM, ALTURA_IMAGEN_REDIM));
cv::Mat matrizROIDatosTipoReal2;
imagenROIRedimensionada2.convertTo(matrizROIDatosTipoReal2, CV_32FC1);
cv::Mat matrizROIConRealesSimples2 = matrizROIDatosTipoReal2.reshape(1, 1);
cv::Mat vectorCaracterActual2(0, 0, CV_32F);
kNearest->findNearest(matrizROIConRealesSimples2, 1, vectorCaracterActual2);
float fltCaracterActual2 = (float)vectorCaracterActual2.at<float>(0, 0);
strCadenaFinal2 = strCadenaFinal2 + char(int(fltCaracterActual2));
}
std::cout << "\n" << "SEGUNDO APELLIDO = " << strCadenaFinal2 << "\n";
cv::imshow("SEGUNDO APELLIDO", ROI2);
Preproceso.h CODE:
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
// global variables
//////////////////////////////////////////////
const cv::Size TAMAÑO_FILTRO_SUAVE_GAUSSIANO = cv::Size(5, 5);
const int TAMAÑO_BLOQUE_UMBRAL = 19;
const int ANCHO_UMBRAL = 9;
// function prototypes
////////////////////////////////////////////////////////////////////////////
void preprocess(cv::Mat &imagenOriginal, cv::Mat &imagenEscalaDeGrises,
cv::Mat &imagenUmbralizada);
cv::Mat extraerValor(cv::Mat &imagenOriginal);
cv::Mat maximizarContraste(cv::Mat &imagenEscalaDeGrises);
This is the DNI image
And this, the base image
And to finish, here are the xml files that I use as a database in the program:
https://github.com/MicrocontrollersAndMore/OpenCV_3_KNN_Character_Recognition_Cpp/blob/master/classifications.xml
https://github.com/MicrocontrollersAndMore/OpenCV_3_KNN_Character_Recognition_Cpp/blob/master/images.xml