Apa algoritma terbaik untuk pengubahan citra dokumen dalam contoh ini?

Saya mencoba menerapkan berbagai algoritma binarisasi ke gambar yang ditampilkan:

Ini kodenya:

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

% Sekarang kita mengubah ukuran gambar sehingga pekerjaan komputasi menjadi lebih mudah nantinya bagi kita.

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);

% sekarang kita menemukan rata-rata dan standar deviasi yang diperlukan untuk algoritma niblack dan% sauvola

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

% menerapkan algoritma ambang batas niblack:

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');

% menerapkan algoritma ambang sauvola:

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

akhir

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

Hasil yang saya peroleh adalah seperti yang ditunjukkan:

Seperti yang Anda lihat, gambar yang dihasilkan terdegradasi di tempat yang lebih gelap. Bisakah seseorang menyarankan cara mengoptimalkan hasil saya ??

Gambar Anda tidak memiliki kecerahan seragam, jadi Anda seharusnya tidak bekerja dengan ambang batas yang seragam. Anda membutuhkan ambang adaptif. Ini dapat diimplementasikan dengan preprocessing gambar untuk membuat kecerahan lebih seragam di seluruh gambar (kode yang ditulis dalam Mathematica, Anda harus mengimplementasikan versi Matlab sendiri):

Cara sederhana untuk membuat kecerahan seragam adalah dengan menghapus teks sebenarnya dari gambar menggunakan filter penutup:

white = Closing[src, DiskMatrix[5]]

Ukuran filter harus dipilih lebih besar dari lebar langkah font dan lebih kecil dari ukuran noda yang ingin Anda hapus.

EDIT: Saya diminta di komentar untuk menjelaskan apa operasi penutupan tidak. Ini adalah pelebaran morfologis yang diikuti oleh erosi morfologis . Pelebaran pada dasarnya menggerakkan elemen penataan di setiap posisi dalam gambar, dan memilih piksel paling terang di bawah topeng, dengan demikian:

• menghilangkan struktur gelap lebih kecil dari elemen penataan
• menyusut struktur gelap yang lebih besar dengan ukuran elemen penataan
• memperbesar struktur yang terang

Operasi erosi melakukan sebaliknya (mengambil piksel paling gelap di bawah di dalam elemen penataan), jadi jika Anda menerapkannya pada gambar melebar:

• struktur gelap yang dihapus karena mereka lebih kecil dari elemen penataan masih hilang
• struktur yang lebih gelap yang menyusut diperbesar lagi ke ukuran aslinya (meskipun bentuknya akan lebih halus)
• struktur cerah dikurangi ke ukuran aslinya

Jadi operasi penutupan menghilangkan benda gelap kecil dengan hanya perubahan kecil ke benda gelap lebih besar dan benda terang.

Berikut ini contoh dengan berbagai ukuran elemen penataan:

Ketika ukuran elemen penataan meningkat, semakin banyak karakter yang dihapus. Pada radius = 5, semua karakter dihapus. Jika jari-jarinya bertambah lebih jauh, noda yang lebih kecil juga akan dihapus:

Sekarang Anda hanya membagi gambar asli dengan "gambar putih" ini untuk mendapatkan gambar kecerahan (hampir) seragam:

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

Gambar ini sekarang dapat di binerisasi dengan ambang batas konstan:

Binarize[whiteAdjusted , 0.6]

Jawaban Nikie kelihatannya terbaik dan juga tampaknya bekerja dan membuahkan hasil. Jadi ini adalah pemenang yang jelas.

Namun, hanya untuk dokumentasi saya menambahkan satu referensi lagi, itu bisa sangat cepat.

Teknik ini disebut Adaptive thresholding yang tidak perlu mempelajari latar belakang secara eksplisit.

Pada dasarnya, alih-alih menemukan ambang global yang paling cocok - kita dapat mempartisi gambar di jendela lokal (katakan tentang 7x7 atau yang sesuai) dan temukan ambang batas yang berubah saat jendela dilintasi.

Referensi di bawah ini merinci metode yang tepat. http://homepages.inf.ed.ac.uk/rbf/HIPR2/adpthrsh.htm

Metode ini akan relatif lebih cepat secara komputasi.

Cara lain menggunakan filter bandpass (dalam MATLAB). Bermain-main dengan perbedaan parameter Gaussian dapat memberikan hasil yang lebih baik. Proses ini pada dasarnya adalah bandpass menyaring gambar untuk menghapus gumpalan latar frekuensi rendah, dinormalisasi ke [0,1] diperlukan untuk perintah 'graythresh', gambar ambang.

Muat gambar dan konversi ke skala abu-abu:

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

Filter menggunakan perbedaan kernel Gaussian dan menormalkan:

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

Hitung ambang batas dan buat 010101:

T = J > graythresh(J);

Ini adalah kode Matlab yang baik untuk ambang batas adaptif: http://www.mathworks.com/matlabcentral/fileexchange/8647-local-adaptive-thresholding

Saya Akan mencoba coding ini. Tapi saya tidak punya jawaban yang benar ...

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');