Python-Bildverarbeitung auf Captcha zum Entfernen von Rauschen

Ich bin so neu in der Bildverarbeitung und versuche, das Rauschen von Captchas zu beseitigen.

Für Captchas habe ich verschiedene Arten von ihnen:

Zum ersten habe ich Folgendes getan:

Erstens habe ich jedes Pixel, das nicht schwarz ist, in Schwarz konvertiert. Dann habe ich ein Muster gefunden, das ein Bildrauschen ist, und es gelöscht. Für das erste Captcha war es leicht zu löschen und ich fand den Text mit Tesseract.

Aber ich suche nach einer Lösung für die zweite und die dritte.

Wie muss das gehen? Ich meine, was sind die möglichen Methoden, um es zu löschen?

So lösche ich Muster:

def delete(searcher,h2,w2):
    h = h2
    w = w2
    search = searcher
    search = search.convert("RGBA")
    herear = np.asarray(search)
    bigar  = np.asarray(imgCropped)

    hereary, herearx = herear.shape[:2]
    bigary,  bigarx  = bigar.shape[:2]

    stopx = bigarx - herearx + 1
    stopy = bigary - hereary + 1

    pix = imgCropped.load()

    for x in range(0, stopx):
        for y in range(0, stopy):
            x2 = x + herearx
            y2 = y + hereary
            pic = bigar[y:y2, x:x2]
            test = (pic == herear)
            if test.all():
                for q in range(h):
                    for k in range(w):
                        pix[x+k,y+q] = (255,255,255,255) 

Entschuldigung für die Variablennamen, ich habe gerade die Funktion getestet.

Vielen Dank..

Dies ist so weit ich kann:

Sie kennen wahrscheinlich die medianBlurFunktion, die den Medianwert in jedem Kernel findet und diesen Wert durch das Kernelzentrum ersetzt. Wir können etwas Ähnliches tun, aber anstelle des Medians den Maximalwert und dann den Minimalwert verwenden. Mit einem mittleren Bluring habe ich auch einige Ergebnisse erzielt. Ich weiß, dass sie nicht perfekt sind, aber ich hoffe, es gibt Ihnen einige Ideen (Sie können mit den Größen des Eingabebildes und der Kernel spielen, es kann die Ergebnisse ein wenig verbessern).

Ich habe Python momentan nicht installiert, daher teile ich den genauen C ++ - Code, den ich verwendet habe:

Mat im1 = imread("E:/1/3.jpg", 0);
Mat im2, im3;

im2 = Mat::zeros(im1.size(), CV_8U);
for (size_t i = 1; i < im1.rows-1; i++)
{
    for (size_t j = 1; j < im1.cols-1; j++)
    {
        double minVal, maxVal = 0;
        minMaxIdx(im1(Rect(j - 1, i - 1, 3, 3)), &minVal, &maxVal);
        im2.at<uchar>(i, j) = maxVal;
    }
}

imshow("(1) max bluring", im2);

medianBlur(im2, im2, 3);

imshow("(2) median bluring", im2);

im2.copyTo(im1);

im2 = Mat::zeros(im1.size(), CV_8U);
for (size_t i = 1; i < im1.rows - 1; i++)
{
    for (size_t j = 1; j < im1.cols - 1; j++)
    {
        double minVal, maxVal = 0;
        minMaxIdx(im1(Rect(j - 1, i - 1, 3, 3)), &minVal, &maxVal);
        im2.at<uchar>(i, j) = minVal;
    }
}

imshow("(3) min bluring", im2);

Mat tmp;
double st = threshold(im2, tmp, 10, 255, THRESH_OTSU);
threshold(im2, im2, st + 14, 255, THRESH_BINARY_INV);
//dilate(im2, im2, Mat::ones(3, 3, CV_8U));

imshow("(4) final", im2);

waitKey(0);

In solchen Fällen sind Deep-Learning-Methoden wie YOLO und RCNN übrigens die besten Methoden. Probieren Sie sie auch aus.

Hier ist meine Lösung,

Zuerst habe ich das Hintergrundmuster bekommen (von Hand auf Farbe bearbeitet). Von:

Danach habe ich ein leeres Bild erstellt, um es mit Unterschieden zwischen Muster und Bild zu füllen.

img = Image.open("x.png").convert("RGBA")
pattern = Image.open("y.png").convert("RGBA")

pixels = img.load()
pixelsPattern = pattern.load()

new = Image.new("RGBA", (150, 50))
pixelNew = new.load()

for i in range(img.size[0]):
    for j in range(img.size[1]):
         if(pixels[i,j] != pixelsPattern[i,j]):
             pixelNew[i,j] = pixels[i,j]

new.save("differences.png")

Hier sind die Unterschiede ..

und schließlich fügte ich Unschärfe hinzu und löschte die nicht schwarzen Stellen.

Ergebnis:

Mit pytesseract Ergebnis ist 2041, es ist falsch für dieses Bild, aber die allgemeine Rate liegt bei% 60.

Sie können die opencv-Bibliothek für die Bildverarbeitung verwenden. Sehr nützlich könnte diese opencv-Dokumentationsseite sein . Versuchen Sie dann, Ihre Nummer mit der findCountour-Methode wie folgt zu extrahieren:

import cv2 
import numpy as np 

image = cv2.imread('C:\\E0snN.png')
cv2.waitKey(0) 

# Grayscale 
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) 
gray = cv2.bitwise_not(gray)

# Threshold
ret,thresh = cv2.threshold(gray,150,255,1)
# Get countours
contours,h = cv2.findContours(thresh,1,2)
# Draw
cv2.drawContours(image, contours, -1, (0, 255, 0), 3) 
cv2.imshow('Contours', image) 
cv2.waitKey(0)

cv2.destroyAllWindows() 

Danach gibt es folgendes Ergebnis:

Es ist alles andere als perfekt, aber wenn Sie es mit unterschiedlichen Schwellenwerten versuchen, z.

ret,thresh = cv2.threshold(gray,127,255,1)

Sie können bessere Ergebnisse erzielen.