Was sind die besten Algorithmen für das Dokument-Image-Thresholding in diesem Beispiel?

Ich versuche, verschiedene Binarisierungsalgorithmen für das gezeigte Bild zu implementieren:

Hier ist der Code:

clc;
clear;
x=imread('n2.jpg');     %load original image

% Jetzt ändern wir die Größe der Bilder, damit wir später leichter rechnen können.

size(x);
x=imresize(x,[500 800]);
figure;
imshow(x);
title('original image');

z=rgb2hsv(x);       %extract the value part of hsv plane
v=z(:,:,3);
v=imadjust(v);

% Jetzt finden wir den Mittelwert und die Standardabweichung, die für Niblack- und% Sauvola-Algorithmen erforderlich sind

m = mean(v(:))
s=std(v(:))
k=-.4;
value=m+ k*s;
temp=v;

% implementierender Niblack-Schwellenwertalgorithmus:

for p=1:1:500
    for q=1:1:800
        pixel=temp(p,q);
        if(pixel>value)
            temp(p,q)=1;
        else
            temp(p,q)=0;
        end
    end
end
figure;
imshow(temp);
title('result by niblack');
k=kittlerMet(g);
figure;
imshow(k);
title('result by kittlerMet');

% implementiert Sauvola-Schwellenwertalgorithmus:

val2=m*(1+.1*((s/128)-1));
t2=v;
for p=1:1:500
for q=1:1:800
    pixel=t2(p,q);
    if(pixel>value)
        t2(p,q)=1;
    else
        t2(p,q)=0;
    end
end

Ende

figure;
imshow(t2);
title('result by sauvola');

Die Ergebnisse, die ich erhalten habe, sind wie folgt:

Wie Sie sehen können, sind die resultierenden Bilder an den dunkleren Stellen abgebaut. Könnte jemand bitte vorschlagen, wie ich mein Ergebnis optimieren kann?

Ihr Bild hat keine einheitliche Helligkeit, daher sollten Sie nicht mit einer einheitlichen Schwelle arbeiten. Sie benötigen eine adaptive Schwelle. Dies kann implementiert werden, indem das Bild vorverarbeitet wird, um die Helligkeit im gesamten Bild gleichmäßiger zu machen (Code, der in Mathematica geschrieben wurde, muss die Matlab-Version selbst implementiert werden):

Eine einfache Möglichkeit, die Helligkeit zu vereinheitlichen, besteht darin, den eigentlichen Text mithilfe eines Abschlussfilters aus dem Bild zu entfernen:

white = Closing[src, DiskMatrix[5]]

Die Filtergröße sollte größer als die Schriftbreite und kleiner als die Größe der Flecken gewählt werden, die Sie entfernen möchten.

EDIT: Ich wurde in den Kommentaren gebeten zu erklären, was eine Abschlussoperation macht. Es ist eine morphologische Erweiterung, gefolgt von einer morphologischen Erosion . Die Dilatation bewegt das Strukturierungselement im Wesentlichen an jeder Position im Bild und wählt das hellste Pixel unter der Maske aus.

• Entfernen dunkler Strukturen, die kleiner als das Strukturierungselement sind
• Schrumpfen größerer dunkler Strukturen um die Größe des Strukturierungselements
• Vergrößerung heller Strukturen

Die Erosionsoperation bewirkt das Gegenteil (sie wählt das dunkelste Pixel innerhalb des Strukturierungselements aus). Wenn Sie es also auf das erweiterte Bild anwenden, geschieht Folgendes:

• Die dunklen Strukturen, die entfernt wurden, weil sie kleiner als das strukturierende Element sind, sind immer noch verschwunden
• die dunkleren Strukturen, die geschrumpft wurden, werden wieder auf ihre ursprüngliche Größe vergrößert (obwohl ihre Form glatter sein wird)
• Die hellen Strukturen werden auf ihre ursprüngliche Größe reduziert

Der Schließvorgang entfernt also kleine dunkle Objekte mit nur geringfügigen Änderungen an größeren dunklen Objekten und hellen Objekten.

Hier ein Beispiel mit verschiedenen Strukturelementgrößen:

Mit zunehmender Größe des Strukturierungselements werden immer mehr Zeichen entfernt. Bei einem Radius von 5 werden alle Zeichen entfernt. Wenn der Radius weiter vergrößert wird, werden auch die kleineren Flecken entfernt:

Teilen Sie nun das Originalbild durch dieses "weiße Bild", um ein Bild mit (nahezu) gleichmäßiger Helligkeit zu erhalten:

whiteAdjusted = Image[ImageData[src]/ImageData[white]*0.85]

Dieses Bild kann jetzt mit einem konstanten Schwellenwert digitalisiert werden:

Binarize[whiteAdjusted , 0.6]

Nikies Antwort scheint die beste zu sein und scheint auch zu funktionieren und Ergebnisse zu erzielen. Es ist also ein klarer Gewinner.

Aber nur zur Dokumentation, ich füge noch eine Referenz hinzu, das könnte sehr schnell gehen.

Diese Technik wird als adaptives Schwellenwertverfahren bezeichnet, bei dem der Hintergrund nicht explizit erlernt werden muss.

Anstatt den am besten geeigneten globalen Schwellenwert zu finden , können wir das Bild in ein lokales Fenster unterteilen (etwa 7x7 oder entsprechend) und Schwellenwerte finden, die sich ändern, wenn das Fenster überquert wird.

Die folgende Referenz beschreibt die genaue Methode. http://homepages.inf.ed.ac.uk/rbf/HIPR2/adpthrsh.htm

Diese Methode wäre relativ rechnerisch schneller.

Ein anderer Weg mit einem Bandpassfilter (in MATLAB). Das Herumspielen mit den Unterschieden der Gaußschen Parameter kann zu besseren Ergebnissen führen. Das Verfahren besteht im Wesentlichen darin, das Bild mit einem Bandpassfilter zu filtern, um die Hintergrundflecken mit niedriger Frequenz zu entfernen und auf [0,1] zu normalisieren, die für den Befehl "Grauwert" (Schwellenwertbild) erforderlich sind.

Bild laden und in Graustufen-Doppel umwandeln:

I = imread('hw.jpg');
I = rgb2gray(I);
I = double(I);

Filtern Sie mit der Differenz des Gaußschen Kernels und normalisieren Sie:

J = imgaussian(I,1.5) - imgaussian(I,0.5);
J = J - min(J(:));
J = J / max(J(:));

Berechne die Schwelle und mache 010101:

T = J > graythresh(J);

Dies ist ein guter Matlab-Code für adaptives Thresholding: http://www.mathworks.com/matlabcentral/fileexchange/8647-local-adaptive-thresholding

Ich werde diese Codierung versuchen. Aber ich habe keine richtige Antwort ...

clc;
clear;
x=imread('base2.jpg');
size(x);
x=imresize(x,[500 800]);
figure;
imshow(x);
title('original image');
z=rgb2hsv(x);       %extract the value part of hsv plane
v=z(:,:,3);
v=imadjust(v);
m = mean(v(:))
s=std(v(:))
k=-2;
value=m+ k*s;
temp=v;
for p=1:1:500
    for q=1:1:800
        pixel=temp(p,q);
        if(pixel>value)
            temp(p,q)=1;
        else
            temp(p,q)=0;
        end
    end
end
figure;
imshow(temp);
title('result by niblack');
% k=kittlerMet(g);
% figure;
% imshow(k);
% title('result by kittlerMet');

val2=m*(1+.1*((s/128)-1));
t2=v;
for p=1:1:500
for q=1:1:800
    pixel=t2(p,q);
    if(pixel>value)
        t2(p,q)=1;
    else
        t2(p,q)=0;
    end
end

end
figure;
imshow(t2);
title('result by sauvola');