पायथन का उपयोग करके दस्तावेज़ स्कैनर कैसे बनाएं

हो सकता है कि आप भौतिक स्थान बचाने या बैकअप बचाने के लिए किसी दस्तावेज़ को डिजिटाइज़ करना चाहें। किसी भी तरह से, एक प्रोग्राम लिखना जो आपकी कागजी फाइलों की तस्वीरों को एक मानक प्रारूप में परिवर्तित कर सकता है, वह एक ऐसा कार्य है जिसमें पायथन उत्कृष्टता प्राप्त करता है।

उपयुक्त पुस्तकालयों के संयोजन का उपयोग करके, आप दस्तावेज़ों को डिजिटाइज़ करने के लिए एक छोटा ऐप बना सकते हैं। आपका प्रोग्राम इनपुट के रूप में एक भौतिक दस्तावेज़ की एक छवि लेगा, इसमें कई छवि-प्रसंस्करण तकनीकों को लागू करेगा, और इनपुट के स्कैन किए गए संस्करण को आउटपुट करेगा।

अपना पर्यावरण तैयार करना

इस लेख का अनुसरण करने के लिए आपको इससे परिचित होना चाहिए पायथन की मूल बातें. आपको समझने की भी आवश्यकता है NumPy Python लाइब्रेरी के साथ कैसे काम करें.

कोई भी Python IDE खोलें, और दो Python फ़ाइलें बनाएँ। एक का नाम main.py और दूसरे का नाम Transform.py है। फिर आवश्यक पुस्तकालयों को स्थापित करने के लिए टर्मिनल पर निम्न कमांड चलाएँ।

पाइप स्थापित करें OpenCV-Python imutils scikit-image NumPy

आप इमेज इनपुट लेने और कुछ इमेज प्रोसेसिंग करने के लिए OpenCV-Python का उपयोग करेंगे। Imutils इनपुट और आउटपुट छवियों का आकार बदलने के लिए। छवि पर दहलीज लागू करने के लिए scikit-image। NumPy आपको सरणियों के साथ काम करने में मदद करेगा।

स्थापना समाप्त होने तक प्रतीक्षा करें और IDE के लिए प्रोजेक्ट कंकाल को अद्यतन करने के लिए प्रतीक्षा करें। स्केलेटन अपडेट पूरा होने के बाद, आप कोडिंग शुरू करने के लिए तैयार हैं। पूर्ण स्रोत कोड a में उपलब्ध है गिटहब रिपॉजिटरी.

स्थापित पुस्तकालयों का आयात करना

main.py फ़ाइल खोलें, और आपके द्वारा पर्यावरण पर स्थापित पुस्तकालयों को आयात करें। यह आपको जहां आवश्यक हो वहां कॉल करने और उनके कार्यों का उपयोग करने में सक्षम करेगा।

आयात cv2
आयात imutils
से स्किमेज फिल्टर आयात दहलीज_स्थानीय
से परिवर्तन आयात view_transform

Perspective_transform पर फेंकी गई त्रुटि को अनदेखा करें। जब आप Transform.py फ़ाइल पर काम करना समाप्त कर लेंगे तो यह गायब हो जाएगा।

इनपुट लेना और उसका आकार बदलना

आप जिस दस्तावेज़ को स्कैन करना चाहते हैं, उसकी एक स्पष्ट छवि लें। सुनिश्चित करें कि दस्तावेज़ के चारों कोने और उसकी सामग्री दिखाई दे रही है। छवि को उसी फ़ोल्डर में कॉपी करें जिसे आप प्रोग्राम फ़ाइलों को संग्रहीत कर रहे हैं।

इनपुट छवि पथ को OpenCV में पास करें। मूल छवि की प्रतिलिपि बनाएँ क्योंकि परिप्रेक्ष्य परिवर्तन के दौरान आपको इसकी आवश्यकता होगी। मूल छवि की ऊँचाई को उस ऊँचाई से विभाजित करें जिसका आप आकार बदलना चाहते हैं। यह पहलू अनुपात बनाए रखेगा। अंत में, आकार बदलने वाली छवि को आउटपुट करें।

# इमेज पाथ पास करना
मूल_आईएमजी = cv2.imread ('sample.jpg')
कॉपी = ओरिजिनल_आईएमजी.कॉपी ()
# आकार बदलने की ऊंचाई सैकड़ों में
अनुपात = मूल_आईएमजी.आकार [0] / 500.0
img_resize = imutils.resize (मूल_आईएमजी, ऊंचाई =500)
# आउटपुट प्रदर्शित करना
cv2.imshow ('बदली गई छवि', img_resize)
# उपयोगकर्ता द्वारा किसी भी कुंजी को दबाने की प्रतीक्षा की जा रही है
cv2.waitKey (0)

उपरोक्त कोड का आउटपुट इस प्रकार है:

अब आपने मूल छवि की ऊंचाई का आकार बदलकर 500 पिक्सेल कर दिया है।

आकार बदलने वाली छवि को ग्रेस्केल में बदलना

आकार बदलने वाली आरजीबी छवि को ग्रेस्केल में बदलें। अधिकांश छवि-प्रसंस्करण पुस्तकालय केवल ग्रेस्केल छवियों के साथ काम करते हैं क्योंकि उन्हें संसाधित करना आसान होता है।

ग्रे_इमेज = cv2.cvtColor (img_resize, cv2.COLOR_BGR2GRAY)
cv2.imshow ('धूसर छवि', ग्रे_इमेज)
cv2.waitKey (0)

मूल छवि और धूसर वाली छवि के बीच अंतर पर ध्यान दें।

रंगीन तालिका काली और सफेद हो गई है।

एज डिटेक्टर लगाना

शोर को दूर करने के लिए धूसर छवि पर गॉसियन ब्लर फ़िल्टर लागू करें। फिर छवि में मौजूद किनारों का पता लगाने के लिए OpenCV कैनी फ़ंक्शन को कॉल करें।

धुंधला_इमेज = cv2.गाऊसी ब्लर (ग्रे_इमेज, (5, 5), 0)
edged_img = cv2.कैनी (धुंधली_छवि, 75, 200)
cv2.imshow ('छवि किनारों', किनारा_आईएमजी)
cv2.waitKey (0)

आउटपुट पर किनारे दिखाई दे रहे हैं।

आप जिन किनारों के साथ काम करेंगे, वे दस्तावेज़ के किनारे हैं।

सबसे बड़ा समोच्च ढूँढना

धारित छवि में मौजूद आकृति का पता लगाएं। उन्हें केवल पाँच सबसे बड़े समोच्चों को रखते हुए अवरोही क्रम में क्रमबद्ध करें। क्रमबद्ध समोच्चों के माध्यम से लूप करके चार भुजाओं के साथ सबसे बड़े समोच्च का अनुमान लगाएं।

cnts, _ = cv2.findContours (edged_img, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
cnts = सॉर्ट किया गया (cnts, key=cv2.contourArea, रिवर्स=सत्य)[:5]
के लिए सी में सीएनटी:
 पेरी = cv2.arcLength (सी, सत्य)
 लगभग = cv2.approxPolyDP (सी, 0.02 * पेरी, सत्य)
अगर लेन (लगभग) == 4:
 डॉक्टर = लगभग
तोड़ना

चार भुजाओं वाले समोच्च में दस्तावेज़ होने की संभावना है।

डॉक्यूमेंट कंटूर के चारों कोनों पर चक्कर लगाना

पता लगाए गए दस्तावेज़ समोच्च के कोनों पर गोला बनाएं। इससे आपको यह निर्धारित करने में मदद मिलेगी कि आपका प्रोग्राम छवि में दस्तावेज़ का पता लगाने में सक्षम था या नहीं।

पी = []
के लिए डी में डॉक्टर:
 tuple_point = tuple (घ[0])
 cv2.circle (img_resize, tuple_point, 3, (0, 0, 255), 4)
 p.परिशिष्ट (tuple_point)
cv2.imshow ('सर्किल कॉर्नर पॉइंट्स', img_resize)
cv2.waitKey (0)

आकार बदलने वाली आरजीबी छवि पर चक्कर लगाना लागू करें।

दस्तावेज़ का पता लगाने के बाद, अब आपको दस्तावेज़ को छवि से निकालने की आवश्यकता है।

वांछित छवि प्राप्त करने के लिए ताना परिप्रेक्ष्य का उपयोग करना

विकृतियों को ठीक करने के लिए एक छवि को बदलने के लिए ताना परिप्रेक्ष्य एक कंप्यूटर दृष्टि तकनीक है। यह एक छवि को एक अलग विमान में बदल देता है जिससे आप छवि को एक अलग कोण से देख सकते हैं।

Warped_image = Perspective_transform (प्रतिलिपि, doc.reshape(4, 2) * अनुपात)
warped_image = cv2.cvtColor (warped_image, cv2.COLOR_BGR2GRAY)
cv2.imshow ("विकृत छवि", imutils.resize (warped_image, ऊंचाई=650))
cv2.waitKey (0)

एक विकृत छवि प्राप्त करने के लिए, आपको चाहिए एक साधारण मॉड्यूल बनाएँ जो परिप्रेक्ष्य परिवर्तन करेगा।

परिवर्तन मॉड्यूल

मॉड्यूल दस्तावेज़ कोनों के बिंदुओं का क्रम देगा। यह दस्तावेज़ छवि को एक अलग विमान में भी बदल देगा और कैमरा कोण को ओवरहेड शॉट में बदल देगा।

आपके द्वारा पहले बनाई गई Transform.py फ़ाइल खोलें। OpenCV और NumPy लाइब्रेरी आयात करें।

आयात Numpy जैसा एनपी
आयात cv2

इस मॉड्यूल में दो कार्य होंगे। एक ऐसा फंक्शन बनाएं जो दस्तावेज़ कोने के बिंदुओं के निर्देशांक को क्रमबद्ध करेगा। पहला निर्देशांक ऊपरी बाएँ कोने का होगा, दूसरा वह शीर्ष दाएँ कोने का होगा, तीसरा निचले दाएं कोने का होगा, और चौथा समन्वय नीचे बाएं कोने का होगा कोना।

डीईएफ़order_points(अंक):
# ऑर्डर किए जाने वाले निर्देशांक की सूची को इनिशियलाइज़ करना
 आयत = np.शून्य ((4, 2), डीटाइप = "फ्लोट 32")
 s = pts.sum (अक्ष = 1)
# शीर्ष-बाएँ बिंदु का योग सबसे छोटा होगा
 आयत [0] = अंक [np.argmin (रों)]
# नीचे-दाएं बिंदु का योग सबसे बड़ा होगा
 आयत [2] = अंक [np.argmax (s)]
बिंदुओं के बीच अंतर की गणना करना
 शीर्ष-दाएं बिंदु में सबसे छोटा अंतर होगा,
 जबकि नीचे-बाएँ सबसे बड़ा अंतर होगा
 अंतर = np.diff (अंक, अक्ष = 1)
 आयत [1] = अंक [np.argmin (diff)]
 आयत [3] = अंक [np.argmax (diff)]
# दिए गए निर्देशांक लौटाता है
वापस करना रेक्ट

दूसरा फ़ंक्शन बनाएं जो नई छवि के कोने निर्देशांक की गणना करेगा और ओवरहेड शॉट प्राप्त करेगा। यह तब परिप्रेक्ष्य परिवर्तन मैट्रिक्स की गणना करेगा और विकृत छवि को वापस करेगा।

डीईएफ़view_transform(छवि, अंक):
# ऑर्डर किए गए निर्देशांक को अलग-अलग अनपैक करें
 रेक्ट = ऑर्डर_पॉइंट्स (अंक)
 (टीएल, टीआर, बीआर, बीएल) = आयत
नई छवि की चौड़ाई की गणना करें, जो होगी
 नीचे-दाएं के बीच अधिकतम दूरी और तली छोड़ें
 एक्स-निर्देशांक या शीर्ष-दाहिना और शीर्ष-बाएँ x-निर्देशांक
 चौड़ाई ए = np.sqrt (((बीआर [0] - बीएल [0]) ** 2) + ((बीआर [1] - बीएल [1]) ** 2))
 चौड़ाई बी = np.sqrt (((टीआर [0] - टीएल [0]) ** 2) + ((टीआर [1] - टीएल [1]) ** 2))
 maxWidth = max (int (चौड़ाईA), int (चौड़ाईB))
नई छवि की ऊंचाई की गणना करें, जो होगी
 शीर्ष-बाएँ के बीच अधिकतम दूरी और नीचे-बाएँ y-निर्देशांक
 ऊँचाईए = np.sqrt((((tr[0] - ब्र [0]) ** 2) + ((टीआर [1] - ब्र [1]) ** 2))
 ऊँचाईबी = np.sqrt (((टीएल [0] - बीएल [0]) ** 2) + ((टीएल [1] - बीएल [1]) ** 2))
 मैक्सहाइट = मैक्स (इंट (ऊंचाईए), इंट (ऊंचाईबी))
ओवरहेड शॉट प्राप्त करने के लिए गंतव्य बिंदुओं के सेट का निर्माण करें
 डीएसटी = एनपी.सरणी ([
 [0, 0],
 [अधिकतम चौड़ाई - 1, 0],
 [अधिकतम चौड़ाई - 1, अधिकतम ऊँचाई - 1],
 [0, अधिकतम ऊँचाई - 1]], डीटाइप = "फ्लोट 32")
# परिप्रेक्ष्य परिवर्तन मैट्रिक्स की गणना करें
 transform_matrix = cv2.getPerspectiveTransform (रेक्ट, डीएसटी)
# ट्रांसफ़ॉर्म मैट्रिक्स लागू करें
 विकृत = cv2.warpPerspective (इमेज, ट्रांसफ़ॉर्म_मैट्रिक्स, (मैक्सविड्थ, मैक्सहाइट))
# विकृत छवि वापस करें
वापस करना विकृत

आपने अब ट्रांसफॉर्म मॉड्यूल बनाया है। Perspective_transform आयात पर त्रुटि अब गायब हो जाएगी।

ध्यान दें कि प्रदर्शित छवि में ओवरहेड शॉट है।

अनुकूली सीमा लागू करना और स्कैन किए गए आउटपुट को सहेजना

Main.py फ़ाइल में, गॉसियन थ्रेशोल्ड को विकृत छवि पर लागू करें। यह विकृत छवि को स्कैन किया हुआ रूप देगा। स्कैन की गई छवि आउटपुट को प्रोग्राम फ़ाइलों वाले फ़ोल्डर में सहेजें।

टी = दहलीज_लोकल (विकृत_छवि, 11, ऑफसेट =10, विधि ="गॉसियन")
विकृत = (विकृत_छवि> टी)। astype ("uint8") * 255
cv2.imwrite ('./'+'स्कैन'+'पीएनजी'विकृत)

स्कैन को PNG फॉर्मेट में सेव करने से डॉक्यूमेंट की क्वालिटी बनी रहती है।

आउटपुट प्रदर्शित करना

स्कैन किए गए दस्तावेज़ की छवि आउटपुट करें:

cv2.imshow ("अंतिम स्कैन की गई छवि", imutils.resize (विकृत, ऊंचाई =650))
cv2.waitKey (0)
cv2.destroyAllWindows ()

निम्न छवि प्रोग्राम का आउटपुट, स्कैन किए गए दस्तावेज़ का ओवरहेड शॉट दिखाती है।

कंप्यूटर विजन में कैसे आगे बढ़ें

दस्तावेज़ स्कैनर बनाना कंप्यूटर विज़न के कुछ मुख्य क्षेत्रों को कवर करता है, जो एक विस्तृत और जटिल क्षेत्र है। कंप्यूटर दृष्टि में आगे बढ़ने के लिए आपको दिलचस्प लेकिन चुनौतीपूर्ण परियोजनाओं पर काम करना चाहिए।

आपको इस बारे में भी अधिक पढ़ना चाहिए कि आप वर्तमान तकनीकों के साथ कंप्यूटर विज़न का उपयोग कैसे कर सकते हैं। यह आपको सूचित रखेगा और आपको परियोजनाओं पर काम करने के लिए नए विचार देगा।