फिंगर वेवलेट संपीड़न: अभ्यास

पिछली पोस्ट में, हमने असतत तरंग परिवर्तन का उपयोग करके छवि संपीड़न की सैद्धांतिक नींव की जांच की। और यद्यपि कई महत्वपूर्ण मुद्दे नहीं उठाए गए थे, प्राप्त परिणाम व्यवहार में कुछ करने की कोशिश करने के लिए पर्याप्त हैं।

के लिए शब्द क्या हैं? चलो एक प्रोग्राम लिखते हैं जो छवियों को संपीड़ित करता है! (कट के नीचे बहुत सारी तस्वीरें हैं!)

उपकरण

हम पायथन प्रोग्रामिंग भाषा में लिखेंगे। हां, मुझे पता है कि बहुत से लोग मुझे अपनी पसंदीदा प्रोग्रामिंग भाषा में कोड के साथ प्रस्तुति को चित्रित करना चाहेंगे। लेकिन पायथन मुझे अपनी चरम सादगी के कारण सबसे अच्छा विकल्प लगता है (यह वास्तव में, एक व्याख्यायित छद्मकोड है)।

हमें एक दुभाषिया और एक पीआईएल लाइब्रेरी (पायथन इमेजिंग लाइब्रेरी) की आवश्यकता है। नेटवर्क के पास उन्हें स्थापित करने के लिए पर्याप्त निर्देश हैं, इसलिए मैं वहां नहीं रुकूंगा।

केवल एक चीज जो मैं अनुशंसा करना चाहता हूं वह है विकास के लिए ipython नोटबुक का उपयोग करना। एक अद्भुत बात, एक वेब इंटरफ़ेस प्रदान करना जो मैथमैटिक पैकेज से मिलता जुलता है, लेकिन पायथन में प्रोग्रामेबल है।

पिछली श्रृंखला का सारांश

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

पहला परिवर्तन माना जाता है - हार परिवर्तन - चमक मूल्यों के जोड़े के साथ काम करता है। परिवर्तन एक मैट्रिक्स द्वारा गुणा है


दूसरा परिवर्तन - Daubechies D4 बदल - पहले से ही दो मूल्यों द्वारा एक दूसरे से स्थानांतरित चार मूल्यों का उपयोग करता है। इसलिए, मैट्रिक्स पहले से ही बड़ा होगा (भारी गुणांक c _i द्वारा निरूपित किया जाता है):


हमने नॉनलाइनियर समीकरणों की एक प्रणाली को हल करके रूपांतरण गुणांक पाया। दूसरी पंक्ति बस बारी-बारी से वर्णों के साथ रिवर्स ऑर्डर में लिखे गए गुणांक हैं।

इस मैट्रिक्स को 4 चमक मानों के कॉलम वेक्टर से गुणा करते हुए, हमें केवल दो मान (कम-आवृत्ति और उच्च-आवृत्ति गुणांक) मिलते हैं। यह इस अन्याय के कारण ठीक है कि चार को एक पंक्ति में नहीं, बल्कि "ओवरलैप", 2 की वृद्धि में लिया जाना चाहिए।

उदाहरण के लिए, यदि हमारे पास मान [1, 2, 3, 4] है, तो हमें दो चार लेने की आवश्यकता है: [1, 2, 3, 4] (आश्चर्य, आश्चर्य!) और [3, 4, 1, 2]। इस तथ्य के कारण उत्तरार्द्ध में इस तरह की एक अजीब उपस्थिति है कि हमारे पास दाईं ओर पर्याप्त मान नहीं थे और शुरुआत में एक सर्कल में लौटना पड़ा था।

वैसे, इस मामले में पूरे परिवर्तन के मैट्रिक्स का रूप होगा:


इसी तरह, एक उच्च क्रम के परिवर्तनों के मैट्रिक्स लिख सकता है: डी 6, डी 8, और इसी तरह। (संख्या हमेशा भी होती है। इस बारे में सोचें कि क्यों।)

चलो शुरू हो जाओ!

मान लीजिए कि हमने प्रोग्रामिंग के लिए डी 4 तरंगिका परिवर्तन को चुना। प्रत्येक बार गणना न करने के लिए, हम सूची में गुणांक डालते हैं।

from math import sqrt CL = [(1 + sqrt(3)) / (4 * sqrt(2)), (3 + sqrt(3)) / (4 * sqrt(2)), (3 - sqrt(3)) / (4 * sqrt(2)), (1 - sqrt(3)) / (4 * sqrt(2))] 

L अक्षर का अर्थ है कि ये निम्न (L, निम्न) फ़िल्टर से संबंधित पहली पंक्ति के गुणांक हैं।

यह काफी सार्वभौमिक दृष्टिकोण है। यदि हम एक और परिवर्तन लागू करना चाहते हैं, तो बस सूची को बदलें।

उच्च-पास फ़िल्टर (HPF, उच्च-पास फ़िल्टर) के गुणांक एक अलग फ़ंक्शन का उपयोग करते हुए पाए जाएंगे जो सूची को रिवर्स ऑर्डर में रिकॉर्ड करता है और संकेतों को वैकल्पिक करता है।

 def hpf_coeffs(CL): N = len(CL) #   CH = [(-1)**k * CL[N - k - 1] #        for k in xrange(N)] return CH 

कोष्ठक में अभिव्यक्ति, यदि कोई नहीं जानता है, तो एक सूची जनरेटर है। बहुत सुविधाजनक बात है।

प्रत्यक्ष एक आयामी परिवर्तन

अब हमारे पास गुणांक हैं, हम रूपांतरण स्वयं कर सकते हैं। इसका परिणाम सूची सीएल और सीएच से बदले में गुणांक के साथ भारित रकम वाला एक सूची होगा।

भारित रकम (जोड़ीदार उत्पादों की राशि) कॉलम वेक्टर द्वारा मैट्रिक्स की पंक्तियों के उत्पाद हैं। मैट्रिक्स की पंक्तियाँ भी एक कम-पास फ़िल्टर हैं, और विषम पंक्तियाँ एक उच्च-पास फ़िल्टर हैं। यहीं से बारी आती है।

गणित में एक और सूची "गणना" के साथ गणना की गई भारित रकमों की सूची। फूरियर रूपांतरण के आधार पर इन संकल्पों की गणना के लिए प्रभावी एल्गोरिदम हैं। (अचानक, क्या यह है? फूरियर रूपांतरण साइन और कोजाइन है, और अचानक इसका उपयोग कैसे किया जाता है?) लेकिन हम सादगी के समर्थक हैं और हम समयपूर्व अनुकूलन के साथ सौदा नहीं करेंगे। माथे पर भरोसा करें, यह अधिक स्पष्ट है। और हम एक अभ्यास के रूप में पाठक के लिए अनुकूलन और सुंदर हैक छोड़ देते हैं।

हम फ़ंक्शन को pconv कहते हैं। पी - शब्द जोड़ी (जोड़ी), और कनव - कनवल्शन (दृढ़ संकल्प) से।

 def pconv(data, CL, CH, delta = 0): assert(len(CL) == len(CH)) #       N = len(CL) M = len(data) out = [] #   ,   for k in xrange(0, M, 2): #   0, 2, 4… sL = 0 #   sH = 0 #   for i in xrange(N): #     sL += data[(k + i - delta) % M] * CL[i] sH += data[(k + i - delta) % M] * CH[i] out.append(sL) #     out.append(sH) return out 

यह स्पष्ट नहीं हो सकता है कि डेल्टा मान क्या है, जो डिफ़ॉल्ट रूप से शून्य के बराबर है। यह हमें पहले तत्व से नहीं, बल्कि एक मनमाने ढंग से कनविक्शन शुरू करने की अनुमति देता है। यह बाद में काम आएगा।

भारित मात्राओं की गणना करते समय शेष (अभिव्यक्ति "% M") की गणना आवश्यक है ताकि सूची की सीमाओं से परे न जाएं। यदि M = 4, और सूचकांक अचानक 5 हो गया, तो हम 1 तत्व पर फिर से लौटेंगे, क्योंकि 5% 4 परिणाम के रूप में 1 देता है।

चलिए हमारे कार्य को अप्राकृतिक हर परिवर्तन (जो आधा-आधा और आधा-अंतर है) पर परखें।

 >>>C = [0.5, 0.5] >>>pconv([1, 2, 3, 4], C, hpf_coeffs(C)) [1.5, -0.5, 3.5, -0.5] 

यह काम करता है!

और वापस?

जैसा कि पाठक याद करते हैं, हमने विशेष रूप से अपने मेट्रिसेस को डिज़ाइन किया है ताकि उलटा रूपांतर यथासंभव सरल हो। मेट्रिसेस एच और डी 4 की ऑर्थोगोनलिटी के कारण, उनके लिए उलटा मैट्रिस सरल ट्रांसपोजिशन द्वारा पाया जा सकता है।

एक बार फिर परिवर्तन मैट्रिक्स डी 4 पर विचार करें, लेकिन मनमानी लंबाई के एक स्तंभ वेक्टर के लिए:


पिक्सेल चमक मूल्यों के साथ एक कॉलम वेक्टर द्वारा इस तरह के मैट्रिक्स को गुणा करने से हमें सजावटी मूल्य मिलते हैं। सच है, मैट्रिक्स बहुत बड़ा है, इसलिए स्पष्ट गुणा के बजाय, हमने एक दृढ़ संकल्प का उपयोग किया।

व्युत्क्रम मैट्रिक्स को ट्रांसपोज़ करके प्राप्त किया जा सकता है:


मूल मैट्रिक्स के समान, लेकिन निचले बाएं कोने में कोई चौकोर टुकड़ा नहीं है। यद्यपि यदि आप अंतिम दो कॉलमों को "कट" करते हैं और शुरुआत में इसे "गोंद" करते हैं, तो आपको एक ही आकार का एक मैट्रिक्स मिलेगा (यद्यपि विभिन्न गुणांक के साथ) और हम तैयार-किए गए pconv फ़ंक्शन का उपयोग कर सकते हैं। इसे रोको! लेकिन हमारे पास डेल्टा पैरामीटर है, जो स्रोत डेटा में ऑफसेट सेट करता है। लेकिन यह बहुत काटने और gluing है। डेल्टा पैरामीटर का रहस्य पता चला है!

D4 के लिए, आपको D6, चार, आदि के लिए अंतिम 2 कॉलम "कट" करने की आवश्यकता है।

छोटी बात उल्टे मैट्रिक्स की पंक्तियों में गुणांक के क्रम को निर्धारित करना है। डी 4 के लिए, आदेश स्पष्ट है:


लेकिन डी 6, डी 8 और अन्य के बारे में क्या? आइए परिवर्तन मैट्रिक्स D4 को देखें। हम ट्रांसपोज्ड मैट्रिक्स की पंक्तियों में रुचि रखते हैं, अर्थात, मूल के कॉलम।

हमारे वैक्टर तीसरे और चौथे स्तंभ हैं। रूपांतरण आदेश के बावजूद, लाइन शिफ्ट हमेशा दो तत्वों द्वारा होती है, इसलिए पैटर्न यह है।

पहला वेक्टर:
[पहली पंक्ति का पहला तत्व, दूसरी का पहला तत्व, पहली पंक्ति का पहला तत्व (यह तीसरी के साथ मेल खाता है), दूसरी का पहला तत्व]।

दूसरा वेक्टर:
[पहली पंक्ति का अंतिम तत्व, दूसरी का अंतिम तत्व, पहली पंक्ति का दूसरा तत्व (यह तीसरी के साथ मेल खाता है), दूसरी का दूसरा तत्व]।

यही है, गुणांकों को वैकल्पिक रूप से सीएल और सीएच के चरण 2 में चुना जाता है, जो उल्टे मैट्रिक्स की पहली पंक्ति या दूसरी पंक्ति के लिए अंतिम एक से शुरू होता है।

यह नियम D4 के लिए और D6 के लिए सही होगा, और यहां तक ​​कि Haar परिवर्तन के लिए (जो वास्तव में D2 के समान ही है)।

पाइथन में, तंतु तत्व को इंडेक्स -2 और आखिरी में इंडेक्स -1 में एक्सेस किया जा सकता है। हमने pconv में इस उपयोगी सुविधा का उपयोग किया है।

हम व्युत्क्रम मैट्रिक्स के गुणांक की एक सूची प्राप्त करने के लिए एक फ़ंक्शन लिखते हैं, जो वर्णित एल्गोरिदम के अनुसार काम करता है।

 def icoeffs(CL, CH): assert(len(CL) == len(CH)) #       iCL = [] #    iCH = [] #    for k in xrange(0, len(CL), 2): iCL.extend([CL[k-2], CH[k-2]]) iCH.extend([CL[k-1], CH[k-1]]) return (iCL, iCH) 

चलो उसके काम की जाँच करें:

 >>>C = [0, 1, 2, 3] >>>icoeffs(C, hpf_coeffs(C)) ([2, 1, 0, 3], [3, 0, 1, -2]) 

बाधाओं को सही ढंग से पुनः व्यवस्थित किया जा रहा है।

आप कुछ सूची को परिवर्तित करके कार्यों के संचालन का परीक्षण कर सकते हैं (जैसे, [0, 1, 2, 3]), और फिर अदृश्य परिवर्तन कर रहे हैं।

 >>>CL = [(1 + sqrt(3)) / (4 * sqrt(2)), >>> (3 + sqrt(3)) / (4 * sqrt(2)), >>> (3 - sqrt(3)) / (4 * sqrt(2)), >>> (1 - sqrt(3)) / (4 * sqrt(2))] >>>X = [0, 1, 2, 3] >>>CH = hpf_coeffs(CL) >>>iCL, iCH = icoeffs(CL, CH) >>>Y = pconv(X, CL, CH) >>>X2 = pconv(Y, iCL, iCH, len(CL) - 2) [2.5077929123346285e-16, 1.0, 1.9999999999999991, 2.9999999999999991] 

क्या बकवास है! यह फिर से निकला होना चाहिए [0, 1, 2, 3]! बंद करो, झूठा अलार्म। पहला नंबर बस है , यानी लगभग शून्य। शेष संख्याएं भी मूल के करीब हैं। तथ्य यह है कि हम अपरिमेय संख्याओं के साथ काम कर रहे हैं, और ऐसे मामलों में गोलाई त्रुटियां अपरिहार्य हैं।

दो आयामी परिवर्तन

इसलिए, हमने परिवर्तनों का कार्यक्रम किया। लेकिन ये परिवर्तन एक आयामी हैं! और जिन चित्रों को हम संक्षिप्त करने की योजना बनाते हैं, वे बहुत द्वि-आयामी हैं। लेकिन यह आसानी से हल है। दो-आयामी तरंगिका रूपांतरण सभी लाइनों पर एक आयामी के रूप में किया जाता है, और फिर सभी स्तंभों पर (या इसके विपरीत, स्वाद के लिए)।

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

यदि हमारी छवि के पिक्सेल का चमक मान चर छवि में संग्रहीत किया जाता है, तो आप निम्न के रूप में 4 के चमक की सूची प्राप्त कर सकते हैं, उदाहरण के लिए, रेखा, इस प्रकार है:

 image[4, :] 

और 3 कॉलम में चमक की सूची इस प्रकार है:

 image[:, 3] 

आइए प्रयोगों के लिए एक छवि लें। यह महत्वपूर्ण है कि इसके आयाम दो की शक्तियां हैं! (सामान्य तौर पर, यह महत्वपूर्ण है कि वे भी हैं, लेकिन फिर हम बार-बार परिवर्तन करेंगे।)

उदाहरण के लिए, आप इसे ले सकते हैं (चूंकि लीना सभी से तंग आ चुकी है):


इसमें 512 × 512 के आयाम हैं, इसलिए यह हमें सूट करता है।

इसे मेमोरी में लोड करें (एक ही समय में काले और सफेद रूप में परिवर्तित होने और चमक का मैट्रिक्स बनाने के लिए):

 import PIL.Image as Image image = Image.open('/tmp/boat.png').convert('L') image = array(image) / 255.0 #   — [0, 1] imshow(image, cmap=cm.gray) #    

स्क्रीन पर कुछ इस तरह दिखना चाहिए:


तो, छवि चर चमक का एक सरणी है।

हम एक द्वि-आयामी तरंगिका परिवर्तन के लिए एक फ़ंक्शन लिखते हैं। बारी-बारी से कम और उच्च आवृत्ति वाले गुणांक बदसूरत दिखते हैं, उन्हें फिर से व्यवस्थित करें। कम आवृत्ति - बाईं और ऊपर, उच्च आवृत्ति - दाईं ओर और नीचे।

चूंकि रूपांतरण पंक्ति-वार और कॉलम-वार दोनों किए जाते हैं, कम आवृत्ति वाले गुणांक जो मूल छवि की एक छोटी प्रतिलिपि बनाते हैं, ऊपरी बाएं कोने में समूहीकृत होते हैं।

 def dwt2(image, CL): CH = hpf_coeffs(CL) #    w, h = image.shape #   imageT = image.copy() #      for i in xrange(h): #   imageT[i, :] = pconv(imageT[i, :], CL, CH) for i in xrange(w): #   imageT[:, i] = pconv(imageT[:, i], CL, CH) #     data = imageT.copy() data[0:h/2, 0:w/2] = imageT[0:h:2, 0:w:2] data[h/2:h, 0:w/2] = imageT[1:h:2, 0:w:2] data[0:h/2, w/2:w] = imageT[0:h:2, 1:w:2] data[h/2:h, w/2:w] = imageT[1:h:2, 1:w:2] return data 

आइए परिवर्तन डी 4 पर हमारे फ़ंक्शन के संचालन की जांच करें, जिसके गुणांक हम सीएल और सीएच में रखते हैं।

 data2 = dwt2(image, CL) imshow(data2, cmap=cm.gray) 

मैं आपको तुरंत चेतावनी देता हूं! चूंकि हमने कुछ भी अनुकूलित नहीं किया है, यह धीरे-धीरे काम करेगा। मेरी विनम्र नेटबुक पर, गणना में आधा दर्जन सेकंड लगे।

परिणाम ऐसी तस्वीर होना चाहिए।


सब कुछ, जैसा कि हमें उम्मीद थी! कोने में एक छोटी सी छवि और छोटे moduli (के रूप में काला इंगित करता है) बाकी में गुणांक।

और यहां परिवर्तित छवि की 50 वीं पंक्ति के साथ मूल्यों का एक ग्राफ है।


यह देखा जा सकता है कि पहली छमाही में, इसी कम की गई प्रतिलिपि, भिन्नता की सीमा अधिक है, जबकि उच्च आवृत्ति वाले गुणांक शून्य के करीब हैं।

आप हार तरंग के साथ कोशिश कर सकते हैं:

 C = [1/sqrt(2), 1/sqrt(2)] data3 = dwt2(image, C) imshow(data3, cmap=cm.gray) 

यदि आपके पास अच्छी दृष्टि और एक मॉनिटर है, तो आप देखेंगे कि उच्च आवृत्ति वाले हिस्से में अधिक विवरण दिखाई देते हैं। यह समझ में आता है - आखिरकार, केवल रैखिक घटक को यहां फ़िल्टर किया गया था, और डी 4 में - द्विघात घटक भी।

या विकिपीडिया से D6 के लिए गुणांक भी लेते हैं (उन्हें विभाजित करने के लिए मत भूलना वे वहां दो पर सामान्यीकृत होते हैं)। और सबसे साहसी आमतौर पर गुणांक को विश्लेषणात्मक रूप से प्राप्त कर सकते हैं।

उच्चतर रूपांतरण क्रम, उच्च-आवृत्ति गुणांक वाले क्षेत्रों को गहरा करता है।

उलटा दो आयामी परिवर्तन

तथ्य यह है कि हम दो आयामी परिवर्तन कर सकते हैं महान है, लेकिन यह कौशल उलटा परिवर्तन के बिना बेकार है।

यह करना आसान है हम सीधे रूपांतरण के साथ ही कदम उठाते हैं, लेकिन रिवर्स ऑर्डर में। और pconv में अन्य गुणांक और गैर-शून्य डेल्टा मूल्य के बारे में मत भूलना।

 def idwt2(data, CL): w, h = data.shape #   #      imageT = data.copy() imageT[0:h:2, 0:w:2] = data[0:h/2, 0:w/2] imageT[1:h:2, 0:w:2] = data[h/2:h, 0:w/2] imageT[0:h:2, 1:w:2] = data[0:h/2, w/2:w] imageT[1:h:2, 1:w:2] = data[h/2:h, w/2:w] CH = hpf_coeffs(CL) iCL, iCH = icoeffs(CL, CH) image = imageT.copy() #      for i in xrange(w): #   image[:, i] = pconv(image[:, i], iCL, iCH, delta=len(iCL)-2) for i in xrange(h): #   image[i, :] = pconv(image[i, :], iCL, iCH, delta=len(iCL)-2) return image 

जाँच करने के लिए, हम पहले से प्राप्त इमेज इमेज 2 का उलटा रूपांतरण करते हैं।

 >>>image_rec = idwt2(image2, CL) >>>imshow(image_rec, cmap=cm.gray) 

हमें मूल छवि मिली (अच्छी तरह से या बहुत, बहुत समान), इसलिए हमारे लिए सब कुछ काम करता है!

वहां रुकना मत!

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

तरंगिका डी 4 के लिए, "कोने" का अधिकतम आकार 4 × 4 है, क्योंकि छोटी छवि को परिवर्तित करना संभव नहीं होगा - 4 मैट्रिक्स गुणांक द्वारा गुणा करने के लिए पर्याप्त मान नहीं होंगे।

उदाहरण के लिए, D4 परिवर्तन के लिए, एक समान पुनरावर्ती परिवर्तन को निम्नानुसार क्रमादेशित किया जा सकता है:

 data = image.copy() w, h = data.shape while w >= len(CL) && h >= len(CL): data[0:w, 0:h] = dwt2(data[0:w, 0:h], CL) w /= 2 h /= 2 imshow(data, cmap=cm.gray) 

तस्वीर बहुत दिलचस्प नहीं है।


आइए देखें कि मान किस श्रेणी में बदलते हैं। यहाँ शून्य रेखा से मानों का एक ग्राफ है।


पहले कुछ मूल्य वास्तव में ऑफ स्केल हैं। लेकिन बाकी सब छोटे हैं।

अनावश्यक हटा दें

और अब हम वह करते हैं जिसके बारे में हम सभी सोचते थे - हमें बहुत सारे शून्य मिलते हैं!

यह कई तरीकों से किया जा सकता है। उदाहरण के लिए, आप महत्वपूर्ण अंकों की आवश्यक संख्या (परिमाणीकरण का एक विशेष मामला) के लिए मानों को गोल कर सकते हैं। लेकिन हम इसे आसान करेंगे - हम गुणांक को बदल देंगे, जो शून्य से कुछ मूल्य के पूर्ण मूल्य में छोटे हैं।

ऐसी सीमा मूल्य के रूप में, हम 0.05 लेते हैं। अधिक, अधिक शून्य, लेकिन यह भी अधिक से अधिक नुकसान!

 from numpy import abs threshold = 0.05 data[abs(data)<threshold] = 0 

उसके बाद, ग्राफ स्पष्ट रूप से चिकना हो जाएगा।


शून्य की संख्या की गणना करें:

 >>>sum(data == 0) 224000 

बुरा नहीं है! यह देखते हुए कि छवि में केवल 512 × 512 = 262144 पिक्सेल हैं, यह पता चलता है कि हमने अभी उपलब्ध गुणांक का 85.4% गिरा दिया है !!!

क्या इससे वास्तव में छवि को चोट पहुंची?

उलटा रूपांतरण करें। (कैसे बिल्कुल - पाठक के लिए एक व्यायाम!)

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



अंतर किसने देखा - अच्छा किया! मैंने इसे कठिनाई से पाया है।

और यदि आप 0.1 (92.9% गुणांक रीसेट कर रहे हैं) लेते हैं?

अच्छा भी!

अब दहलीज को 0.2 (छोड़े गए गुणांक के 96.9%) के बराबर लें।

गंभीर विकृतियां पहले से ही ध्यान देने योग्य हैं।

और अंत में, चलो सब कुछ छोड़ने की कोशिश करते हैं जो 0.5 से कम पूर्ण मूल्य में है (99.2% गिरा दिया जाता है)।

खौफनाक साबुन! लेकिन वर्गों के रूप में चुटकी JPEGs के विपरीत नहीं हैं। हमने D4 का उपयोग किया है, इसलिए साबुन "द्विघात" है, जिसमें अंदर की ओर आसानी से प्रवेश होता है।

तुलना के लिए, आइए उसी थ्रेशोल्ड (अर्थात, 0.5) के साथ छवि को संपीड़ित करने का प्रयास करें, लेकिन Haar ट्रांसफॉर्मेशन का उपयोग करके।


खौफ का साया! इसके अलावा रैखिक विरूपण। और केवल 99.2% गुणांक को त्याग दिया गया था। D4 से भी बदतर।

निष्कर्ष

So.

1. D4 के रूपांतरण के बाद, हम 90% गुणांक को सरल शून्यकरण द्वारा सुरक्षित रूप से त्याग सकते हैं और गुणवत्ता में नहीं खोते हैं। और यदि आप उन्नत परिमाणीकरण तकनीकों को लागू करते हैं, तो परिणाम अभी भी सुधारा जा सकता है।

2. D4 D2 (हैर ट्रांसफॉर्मेशन) से बेहतर है। D6, D4 आदि से बेहतर होगा। लेकिन एक समस्या है। उच्च आदेश, जितनी जल्दी हमें ऊपरी बाएं कोने के पुनरावर्ती परिवर्तन की प्रक्रिया को रोकना होगा। तो हर चीज में आपको उपाय जानना जरूरी है।

आगे क्या है?

वास्तव में, हम अभी तक नहीं किए गए हैं। हां, हमने 90% बाधाओं को छोड़ दिया। लेकिन ये वास्तविक गुणांक हैं, 8 बाइट्स पर कब्जा कर रहे हैं! तो संपीड़न बहुत, बहुत छोटा होगा। इसलिए, जब किसी फ़ाइल को सहेजते हैं, तो गुणांक गोल होते हैं और सीमित संख्या में बिट्स का उपयोग भंडारण के लिए किया जाता है। इसके अलावा, बेहतर पैकेजिंग के लिए, गुणांक को एक विशेष तरीके से फिर से व्यवस्थित किया जा सकता है। आप इस बारे में एक से अधिक लेख लिख सकते हैं।

लेकिन यहां तक ​​कि अगर आप सिर्फ आधे-सटीक फ़्लोटिंग-पॉइंट नंबरों (फ्लोट 16) के रूप में गुणांक के साथ सरणी को बचाते हैं, तो xz अभिलेखागार द्वारा संपीड़न के बाद, आपको आकार में 43604 बाइट्स की एक फ़ाइल मिलती है।

इस तरह से बचत की जा सकती है।

 from numpy import save save("boat", data.astype(float16)) 

रूपांतरण के कारण सटीकता का एक महत्वपूर्ण नुकसान होने के बावजूद, फ्लोट 16 → फ्लोट 16 और माथे संपीड़न बिना किसी विशेष एल्गोरिदम के, हमें एक बहुत अच्छा परिणाम मिलता है:


एक ही समय में, (512 × 512) / 43604 1. 6 या 1.33 बिट / पिक्सेल का एक संपीड़न कारक प्राप्त किया गया था। यह अच्छी खबर नहीं है, लेकिन हमने वास्तव में इसे निचोड़ने की कोशिश नहीं की है। उचित परिमाणीकरण और एक अच्छा संपीड़न एल्गोरिथ्म इस परिणाम में बहुत सुधार कर सकता है! तो बढ़ने के लिए जगह है! लेकिन यह पहले से ही "शाम के लिए हमारी परियोजना" के दायरे से परे है। शायद कुछ और समय। ;)

घर का पाठ

1. दिए गए टुकड़ों को एक स्क्रिप्ट में संयोजित करने का प्रयास करें। इसे पैरामीटर के रूप में ग्राफिक फ़ाइल, थ्रेशोल्ड मान और रूपांतरण के प्रकार के रूप में लेने दें, निर्दिष्ट छवि को संपीड़ित करें, और परिणाम को फ़ाइल में सहेजें। ऑपरेशन के दो तरीके प्रदान करें: संपीड़न और विघटन।
2. विभिन्न छवियों को एन्कोडिंग और डिकोडिंग के साथ प्रयोग।
3. अन्य परिवर्तनों का प्रयास करें।
4. विचार करें कि गुणांक को अधिक आर्थिक रूप से कैसे संपीड़ित किया जाए।
5. कार्यक्रम को गति देने का प्रयास करें।
6. रंग छवियों को संपीड़ित करें।
7. आकार प्रतिबंध को हटा दें (अभी के लिए, उन्हें दो की शक्तियां होनी चाहिए)।
8. ???
9. लाभ !!!

एक और जेपीईजी हत्यारा तैयार है! ;)

आप सभी को धन्यवाद! उम्मीद है कि यह दिलचस्प था!