Préparer une image complexe pour la ROC

la façon dont je m'occuperais du problème est de séparer les cartes en différentes sections. Il n'y a pas beaucoup de cartes de crédit pour commencer la liste est à vous), donc vous pouvez faire comme une goutte vers le bas pour spécifier quelle carte de crédit il s'agit. De cette façon, vous pouvez éliminer et spécifier la zone du pixel:

Exemple:

seulement travailler avec la zone 20 pixels à partir du bas, 30 pixels à partir du gauche aux 10 pixels de droite à 30 pixels à partir du bas (création d'un rectangle) - ceci couvrirait toutes les MasterCards

quand j'ai travaillé avec des programmes de traitement d'image (fun project) j'ai trouvé le contraste de l'image, l'ai convertie en échelle de gris, pris la moyenne de chaque valeur RVB individuelle de 1 pixel, et l'ai comparée à l'ensemble autour des pixels:

Exemple:

PixAvg[i,j] = (Pix.R + Pix.G + Pix.B)/3
if ((PixAvg[i,j] - PixAvg[i,j+1])>30)
    boolEdge == true;

30 serait à quel point vous voulez que votre image soit distincte. Plus la différence, la baisse va être la tolérance.

dans mon projet, pour voir la détection de bord, j'ai fait un tableau séparé de booléens, qui contenait des valeurs de boolEdge, et un tableau de pixels. La gamme de pixels a été rempli avec seulement des points noirs et blancs. Il a obtenu les valeurs du tableau booléen, où boolEdge = true est un point blanc, et boolEdge = false est un point noir. Ainsi, à la fin, vous vous retrouvez avec un tableau de pixels (image complète) qui ne contient que des points blancs et noirs.

à Partir de là, il est beaucoup plus facile de détecter un nombre commence et où un certain nombre de finitions.

dans mon application j'ai essayé d'utiliser le code ici:http://rnd.azoft.com/algorithm-identifying-barely-legible-embossed-text-image/ les résultats sont meilleurs, mais pas assez... j'ai du mal à trouver les bons paramètres de texture cartes.

(void)processingByStrokesMethod:(cv::Mat)src dst:(cv::Mat*)dst { 
cv::Mat tmp;  
cv::GaussianBlur(src, tmp, cv::Size(3,3), 2.0);                    // gaussian blur  
tmp = cv::abs(src - tmp);                                          // matrix of differences between source image and blur iamge  

//Binarization:  
cv::threshold(tmp, tmp, 0, 255, CV_THRESH_BINARY | CV_THRESH_OTSU);  

//Using method of strokes:  
int Wout = 12;  
int Win = Wout/2;  
int startXY = Win;  
int endY = src.rows - Win;  
int endX = src.cols - Win;  

for (int j = startXY; j < endY; j++) {  
    for (int i = startXY; i < endX; i++) {  
        //Only edge pixels:  
        if (tmp.at<unsigned char="">(j,i) == 255)  
        {  
            //Calculating maxP and minP within Win-region:  
            unsigned char minP = src.at<unsigned char="">(j,i);  
            unsigned char maxP = src.at<unsigned char="">(j,i);  
            int offsetInWin = Win/2;  

            for (int m = - offsetInWin; m < offsetInWin; m++) {  
                for (int n = - offsetInWin; n < offsetInWin; n++) {  
                    if (src.at<unsigned char="">(j+m,i+n) < minP) {  
                        minP = src.at<unsigned char="">(j+m,i+n);  
                    }else if (src.at<unsigned char="">(j+m,i+n) > maxP) {  
                        maxP = src.at<unsigned char="">(j+m,i+n);  
                    }  
                }  
            }  

            //Voiting:  
            unsigned char meanP = lroundf((minP+maxP)/2.0);  

            for (int l = -Win; l < Win; l++) {  
                for (int k = -Win; k < Win; k++) {  
                    if (src.at<unsigned char="">(j+l,i+k) >= meanP) {  
                        dst->at<unsigned char="">(j+l,i+k)++;  
                    }  
                }  
            }  
        }  
    }  
}  

///// Normalization of imageOut:  
unsigned char maxValue = dst->at<unsigned char="">(0,0);  

for (int j = 0; j < dst->rows; j++) {              //finding max value of imageOut  
    for (int i = 0; i < dst->cols; i++) {  
        if (dst->at<unsigned char="">(j,i) > maxValue)  
            maxValue = dst->at<unsigned char="">(j,i);  
    }  
}  
float knorm = 255.0 / maxValue;  

for (int j = 0; j < dst->rows; j++) {             //normalization of imageOut  
    for (int i = 0; i < dst->cols; i++) {  
        dst->at<unsigned char="">(j,i) = lroundf(dst->at<unsigned char="">(j,i)*knorm);  
    }  
}