🐡 🙆 ⬜️ एसएसपी - मूल दोषरहित छवि संपीड़न एल्गोरिदम ⚖️ 👍🏿 🤾🏻

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

एल्गोरिथ्म में दो संपीड़न मोड हैं:

दोषरहित - जिसमें, विघटन के बाद की छवियों को निकटतम बिट पर बहाल किया जाएगा;
नुकसान के साथ - जो चित्र की गुणवत्ता को कम नहीं करता है, बस संपीड़न से ठीक पहले, छवि को Ycbrrette में अनुवादित किया गया है
केवल पैलेट को बदलकर हम संपीड़न में काफी सुधार कर सकते हैं। मैं निम्नलिखित कारकों का उपयोग करता हूं:
cY = 0.30078125 * R + 0.5859375 * G + 0.11328125 * B cCb = -0.171875 * R - 0.33984375 * G + 0.51171875 * B + 128 cCr = 0.51171875 * R - 0.4296875 * G - 0.08203125 * B + 128

यदि आप परीक्षण चित्र को संक्षिप्त करने का प्रयास करते हैं -

हमें निम्न परिणाम मिलते हैं:
183 960 - मूल PNG फ़ाइल का आकार
155 932 - एसएसपी (संपीड़न में 0.2 सेकंड लगते हैं)
122 593 - एसएसपी (नुकसान के साथ, नुकसान)

अगली छवि को संपीड़ित करके बहुत दिलचस्प परिणाम प्राप्त किए जाते हैं।
www.libpng.org/pub/png/img_png/16million-pschmidt.png
59852 - पीएनजी
1428 - एसएसपी

एल्गोरिथ्म में निम्नलिखित चरण हैं:

छवि को आरजीबी सरणी में डिकोड किया गया है;
यदि हानिपूर्ण मोड का चयन किया जाता है, तो YcbCr पैलेट में ट्रांसकोडिंग किया जाता है;
छवि को पैथ फ़िल्टर (एक साधारण रैखिक फ़ंक्शन द्वारा मूल्य भविष्यवाणी) द्वारा फ़िल्टर किया जाता है;
किसी गैर-जटिल तरीके से डुप्लिकेट पिक्सेल को हटाना:
I = 4 से यूबाउंड ( बाइटअरे ) चरण 4 
आर = बाइटअरे ( i + 0 ) 
g = बाइटअरे ( i + 1 ) 
b = बाइटअरे ( i + 2 ) 
यदि नहीं ( lR = R और Lg = g और lB = b ) या ( Cnt> = MAX_ITERATE ) तब 
यदि Cnt = MAX_ITERATE तो Cnt = 0 
बाइटअरे ( पॉस + 0 ) = एलआर 
बाइटअरे ( पॉज़ + 1 ) = एलजी 
बाइटअरे ( पॉस 2 ) = एलबी 
बाइटअरे ( पॉस 3 ) = Cnt 
lR = R 
Lg = g 
lB = b 
pos = pos + 4 
Cnt = 1 
एल्स 
Cnt = Cnt + 1 
अंत अगर 
अगला
बीडब्ल्यूटी कोडिंग (बरोज़-व्हीलर परिवर्तन), अर्थात् - दुनिया में सबसे अच्छा कार्यान्वयन - आर्कन, लेखक - दिमित्री मालिशेव;
अगला मेरा कार्य आता है, पिछले चरण में प्राप्त बाइट को हटाकर सबसे अधिक बार उपयोग की जाने वाली बाइट और उन पदों के एक बिटमैप का निर्माण जहां से यह बाइट हटा दी गई थी। यह चरण 3 बार चलाया जाता है (प्रयोगात्मक रूप से चयनित मूल्य);

डिम मैं जब तक
डिम iCnt लॉन्ग
डिम साइज़स्ट्रीम ( ) बाइट के रूप में
डिम न्यूस्ट्रीम ( ) बाइट के रूप में
लंबे समय के रूप में मंद आकार
डिम SizeLengthReal लंबे समय तक
लंबे समय के रूप में मंदता
लंबे समय के रूप में नई NewLengthReal
डिम बिटपोस लॉन्ग
लंबे समय तक आकार
डिम फ्रीक ( 255 ) अस लॉन्ग
बाइट के रूप में डिम फ्रीकर
लंबे समय के रूप में डिम फ्रीकाउंट
जब तक मंद दही
जब तक नई गिनती मंद
लंबे समय तक डिम एडचर
डिम पिछले चार जब तक
डिम बिटऑर ( 7 ) बाइट के रूप में

आकार = UBound ( bts ) + 1

SizeLengthReal = 1024
ReDim SizeStream ( SizeLengthReal )

NewLengthReal = 1024
ReDim NewStream ( NewLengthReal )

I = 0 से 7 के लिए
BitOr ( i ) = ( 2 ^ i )
अगला

I = 0 से आकार के लिए - 1
करचर = बीटीएस ( आई )
फ़्रीक ( करछार ) = फ़्रीक ( कर्कर ) + १
अगला

I = 0 से 255 के लिए
अगर फ्रीक ( i ) > फ्रीकाउंट तब
FreqCount = फ़्रीक ( i )
फ्रीचक्र = आई
यदि समाप्त हो
अगला

I = 0 से आकार के लिए - 1

करचर = बीटीएस ( आई )

अगर ( करचहर <> फ्रीचार्ज ) तब
AddChar = AddChar या BitOr ( BitPos )
यदि समाप्त हो

बिटपोस = बिटपोस + १
अगर बिटपोस = 8 तो
SizeStream ( SizeLength ) = AddChar
यदि SizeLength + 10 > SizeLengthReal तब
SizeLengthReal = SizeLengthReal * 2
ReDim परिरक्षण SizeStream ( SizeLengthReal )
यदि समाप्त हो
SizeLength = SizeLength + 1
बिटपोस = ०
AddChar = 0
यदि समाप्त हो

अगर ( करचहर <> फ्रीचार्ज ) तब
NewStream ( NewLength ) = करचर
यदि NewLength + 10 > NewLengthReal तब
NewLengthReal = NewLengthReal * 2
ReDim संरक्षित NewStream ( NewLengthReal )
यदि समाप्त हो
NewLength = NewLength + 1
यदि समाप्त हो
अंतिम कचर = करछर

अगला

'***
'अगर AddChar <> 0 तो
SizeStream ( SizeLength ) = AddChar
SizeLength = SizeLength + 1
'एंड इफ

ReDim संरक्षित बीटीएस ( ( SizeLength + NewLength + 4 + 1 + 4 ) )

कॉल कॉपीमेरी ( bts ( 0 ) , FreqChar, 1 )
CallMemory ( bts ( 1 ) , आकार, 4 ) को कॉल करें
CallMemory ( bts ( 5 ) , SizeLength, 4 ) को कॉल करें
CallMemory ( bts ( 9 ) , SizeStream ( 0 ) , SizeLength ) को कॉल करें
कॉल कॉपीमेरी ( bts ( 9 + SizeLength ) , NewStream ( 0 ) , NewLength )

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

आप यहां खेलने के लिए कंप्रेसर डाउनलोड कर सकते हैं - http://www.sendspace.com/file/nv2suu

इस एल्गोरिथ्म के अलावा, डिब्बे में Jpeg को अपने तरीके से लागू किया जाता है, साथ ही Jpeg2000 जैसे नुकसान के साथ छवियों के तरंग संपीड़न के लिए एक एल्गोरिथ्म भी होता है।

एसएसपी - मूल दोषरहित छवि संपीड़न एल्गोरिदम

More articles: