इस उदाहरण में दस्तावेज़ छवि थ्रेसहोल्डिंग के लिए सबसे अच्छा एल्गोरिदम क्या हैं?

Question

मैं चित्र में दिखाए गए विभिन्न बाइनरीकरण एल्गोरिदम को लागू करने की कोशिश कर रहा हूं:

यहाँ कोड है:

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

अब हम छवियों का आकार बदल देते हैं ताकि कम्प्यूटेशनल काम हमारे लिए बाद में आसान हो जाए।

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=-.4;
value=m+ k*s;
temp=v;

% लागू करने के 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');

% लागू सवोला थ्रेशोल्ड एल्गोरिथ्म:

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

समाप्त

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

मेरे द्वारा प्राप्त किए गए परिणाम निम्नानुसार हैं:

जैसा कि आप देख सकते हैं कि परिणामी छवियां गहरे धब्बों पर नीची हैं। क्या कोई सुझाव देता है कि मेरा परिणाम कैसे अनुकूलित करें ??

Comments

क्या आप केवल चमक के बजाय पृष्ठभूमि को फेंकने के लिए रंग जानकारी का उपयोग कर सकते हैं?

— एंडोलिथ

आदरणीय सर / मैडम। मैं इमेज प्रोसेसिंग पर प्रोजेक्ट कर रहा हूं। मैं दिलचस्प बिनाराइजेशन कॉन्सेप्ट हूं..प्लीज चेक करें और कोडिंग को सही करें ... मैं कोडिंग लेता हूं और प्रोग्राम चलाता हूं। लेकिन कुछ कोडिंग में यह त्रुटि होती है ... अनफाइन्ड फंक्शन या वेरिएबल 'जी'। और एक और त्रुटि है msp (लाइन 31) k = kittlerMet (g) में; .. इसे कैसे हल करें ... कृपया कोडिंग को ठीक करें ...

— muthu

Answer 1

आपकी छवि में समान चमक नहीं है, इसलिए आपको एक समान सीमा के साथ काम नहीं करना चाहिए। आपको एक अनुकूली दहलीज चाहिए। यह छवि को चमक को और अधिक समान बनाने के लिए छवि को प्रीप्रोसेस करके लागू किया जा सकता है (मैथमेटिका में लिखा कोड, आपको अपने लिए मैटलैब संस्करण लागू करना होगा):

चमक को एक समान बनाने का एक सरल तरीका यह है कि आप क्लोजिंग फिल्टर का उपयोग करके इमेज से वास्तविक टेक्स्ट को हटा दें:

white = Closing[src, DiskMatrix[5]]

फ़िल्टर का आकार फ़ॉन्ट स्ट्रोक की चौड़ाई से बड़ा और उस दाग के आकार से छोटा होना चाहिए जिसे आप निकालने का प्रयास कर रहे हैं।

EDIT: मुझे टिप्पणियों में यह बताने के लिए कहा गया था कि एक समापन ऑपरेशन क्या करता है। यह एक रूपात्मक फैलाव है जिसके बाद एक रूपात्मक कटाव होता है । फैलाव अनिवार्य रूप से छवि में हर स्थिति पर संरचना तत्व को स्थानांतरित करता है, और इस प्रकार, मास्क के तहत सबसे तेज पिक्सेल उठाता है:

• संरचनात्मक तत्व की तुलना में छोटे संरचनाओं को हटाना
• संरचना तत्व के आकार से बड़े अंधेरे संरचनाओं को सिकोड़ना
• उज्ज्वल संरचनाओं को बढ़ाना

कटाव संचालन विपरीत करता है (यह संरचना तत्व के अंदर सबसे गहरा पिक्सेल चुनता है), इसलिए यदि आप इसे पतला छवि पर लागू करते हैं:

• डार्क स्ट्रक्चर जो हटा दिए गए थे क्योंकि वे स्ट्रक्चुरिंग एलिमेंट से छोटे हैं अभी भी गए हैं
• गहरे रंग के ढांचे जो सिकुड़ गए थे, वे फिर से अपने मूल आकार में बढ़ गए हैं (हालांकि उनका आकार चिकना होगा)
• उज्ज्वल संरचनाएं अपने मूल आकार में कम हो जाती हैं

इसलिए क्लोजिंग ऑपरेशन छोटी डार्क ऑब्जेक्ट्स को हटा देता है जिसमें बड़ी डार्क ऑब्जेक्ट्स और ब्राइट ऑब्जेक्ट्स में केवल मामूली बदलाव होते हैं।

यहाँ विभिन्न संरचना तत्व आकारों के साथ एक उदाहरण दिया गया है:

जैसे-जैसे संरचना तत्व का आकार बढ़ता है, अधिक से अधिक वर्ण हटा दिए जाते हैं। त्रिज्या = 5 पर, सभी वर्ण हटा दिए जाते हैं। यदि त्रिज्या को और बढ़ाया जाता है, तो छोटे दाग हटा दिए जाते हैं:

अब आप मूल छवि को इस "सफेद छवि" द्वारा विभाजित करते हैं ताकि (लगभग) एक समान चमक प्राप्त कर सकें:

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

यह छवि अब एक निरंतर सीमा के साथ दूरबीन की जा सकती है:

Binarize[whiteAdjusted , 0.6]

Comments

वाह! यह वास्ताव में अच्छा है! विशाल +1!

— फोनॉन

@ मिनी +1 बहुत अच्छा - फिल्टर बंद करने से आपका क्या मतलब है "फ़ॉन्ट स्ट्रोक से बड़ा चुना जाना चाहिए"? किसी अक्षर की चौड़ाई या लंबाई? इसके अलावा, एक बंद फिल्टर 'वास्तव में' क्या कर रहा है? धन्यवाद!

— स्पेसी

@ मोहम्मद: मैंने अपने उत्तर में थोड़ा स्पष्टीकरण जोड़ा है। और हां, ये गैर-रेखीय ऑपरेशन हैं। सामान्य शीर्षक रूपात्मक छवि प्रसंस्करण है।

— निकी एस्टनर

@ मिनी कभी नहीं, सफेद अधिकतम है, काला नहीं। :-)

— स्पेसी

@gdelfino: मैं आमतौर पर एक बड़े पर्याप्त मास्क का उपयोग करके इससे बचने की कोशिश करता हूं, और Clip[ImageData[white],{eps,Infinity}]जहां सुरक्षित होने के लिए एप्स एक छोटी संख्या है, वहां उपयोग करें ।

— निकी एस्टनर

Answer 2

निकी का जवाब सबसे अच्छा लगता है और यह भी काम करता है और परिणाम पैदा करता है। तो यह एक स्पष्ट विजेता है।

हालाँकि, मैं सिर्फ एक और संदर्भ जोड़कर दस्तावेज़ीकरण कर रहा हूँ, जो अभी बहुत तेज़ हो सकता है।

इस तकनीक को एडेप्टिव थ्रेसहोल्डिंग कहा जाता है जिसके लिए पृष्ठभूमि को स्पष्ट रूप से सीखने की आवश्यकता नहीं होती है ।

अनिवार्य रूप से, सबसे उपयुक्त वैश्विक सीमा खोजने के बजाय - हम छवि को एक स्थानीय विंडो (7x7 या उपयुक्त के बारे में कह सकते हैं) में विभाजित कर सकते हैं और उन थ्रेसहोल्ड को खोज सकते हैं जो विंडो ट्रैवर्स के रूप में बदल जाते हैं।

नीचे दिया गया संदर्भ सटीक विधि का विवरण देता है। http://homepages.inf.ed.ac.uk/rbf/HIPR2/adpthrsh.htm

यह विधि अपेक्षाकृत कम्प्यूटेशनल रूप से तेज होगी।

Comments

क्या वे दो चीजें अनिवार्य रूप से एक जैसी नहीं हैं? थ्रेसहोल्ड से पहले सिग्नल के स्थानीय माध्य का अनुमान लगाना?

— मॉरिट्स

@ मौरिट्स ऐसा लगता है कि मुख्य अंतर ऑर्डर करने और उपयोग किए गए आंकड़े हैं। उदाहरण के लिए, उद्घाटन / समापन ऑपरेटरों में, (जो फैलाव और क्षरण से बना होता है लेकिन एक अलग क्रम में), एक खिड़की पर रेखापुंज स्कैन किया जाता है और अधिकतम लिया जाता है। (अन्य बातों के अलावा)। हालांकि अनुकूली दहलीज में अधिकतम के बजाय माध्य / माध्य लिया जा सकता है।

— स्पेसी

ओपी ने इसे एसओ पर भी पूछा , जिसका मैंने जवाब दिया। लेकिन सिद्धांत रूप में, मुझे नहीं लगता कि उत्तरों के बीच कोई अंतर है, एक हमेशा स्थानीय आंकड़ों का अनुमान लगा रहा है। यदि आप सहायक थ्रेसहोल्ड करते हैं, तो आप प्रक्रिया में पृष्ठभूमि भी सीखते हैं।

— मॉरिट्स 7

Answer 3

बैंडपास फ़िल्टर (MATLAB में) का उपयोग करने का दूसरा तरीका। गाऊसी मापदंडों के अंतर के साथ खेलना बेहतर परिणाम दे सकता है। यह प्रक्रिया मूल रूप से कम आवृत्ति वाली पृष्ठभूमि को हटाने के लिए इमेज को फ़िल्टर करती है, 'ग्रेथ्रेश' कमांड, थ्रेशोल्ड इमेज के लिए आवश्यक [0,1] को सामान्य करती है।

छवि लोड करें और ग्रेस्केल डबल में बदलें:

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

गॉसियन कर्नेल के अंतर का उपयोग करके फ़िल्टर करें और सामान्य करें:

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

दहलीज की गणना करें और 010101 करें:

T = J > graythresh(J);

Answer 4

यह अनुकूली थ्रेसहोल्डिंग के लिए एक अच्छा मैटलैब कोड है: http://www.mathworks.com/matlabcentral/fileexchange/8647-local-adaptive-thresholding

Comments

अरे! हालांकि इमेज प्रोसेसिंग टूलबॉक्स की आवश्यकता होती है। : - /

— स्पेसी 23

वास्तव में। क्षमा करें यदि आपके पास नहीं है। लेकिन DIPImage Matlab के लिए एक मुफ्त छवि टोलबॉक्स है। Diplib.org/documentation इसमें थ्रेशोल्डिंग (सेगमेंटेशन सेक्शन) के लिए कुछ तरीके हैं और आप समापन के बाद सभी रूपात्मक ऑपरेशन भी कर सकते हैं। डेवलपर का एक ब्लॉग भी है cb.uu.se/~cris/blog/index.php/archives/tag/matlab

— MyCarta

Answer 5

मैं इस कोडिंग की कोशिश करूँगा। लेकिन मेरे पास एक सही उत्तर नहीं है ...

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

Comments

यदि यह प्रश्न का उत्तर देने के लिए है, तो कृपया बताएं कि आप क्या कर रहे हैं और क्यों कर रहे हैं।

— मैट एल।