डेल्टा संपीड़न नेटवर्क पर भेजे गए डेटा की मात्रा को कैसे कम करता है?

26

भेजे गए डेटा लोड को कम करने के लिए कई गेम डेल्टा संपीड़न की तकनीक का उपयोग करते हैं। मैं यह समझने में विफल हूं कि यह तकनीक वास्तव में डेटा लोड को कैसे कम करती है?

उदाहरण के लिए, मान लीजिए कि मैं एक पद भेजना चाहता हूँ। डेल्टा संपीड़न के बिना मैं vector3उदाहरण के लिए, इकाई की सटीक स्थिति के साथ भेजता हूं (30, 2, 19)। डेल्टा संपीड़न के साथ मैं vector3छोटी संख्या के साथ भेजता हूं (0.2, 0.1, 0.04)।

मुझे समझ में नहीं आता है कि यदि दोनों संदेश हैं vector3- यह डेटा लोड को कम कैसे करता है - प्रत्येक फ्लोट के लिए 32 बिट - 32 * 3 = 96 बिट्स!

मुझे पता है कि आप प्रत्येक फ्लोट को बाइट में बदल सकते हैं और फिर इसे बाइट से फ्लोट में बदल सकते हैं लेकिन यह सटीक त्रुटियों का कारण बनता है जो दिखाई देते हैं।

networking compression

— user101051
स्रोत

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

— लुआण

2

@ Luaan या आप हर बार एक आंशिक पूर्ण स्थिति जोड़ सकते हैं, उदाहरण के लिए आप हर बार अक्सर कुछ संस्थाओं का चयन कर सकते हैं और पूर्ण स्थिति को पास कर सकते हैं, खिलाड़ी के करीब संस्थाओं का चयन करना पसंद कर सकते हैं।

— शाफ़्ट

किसी तरह, मैं rsync के कुछ रिश्तेदार के बारे में इस सवाल की उम्मीद कर रहा था ...

— सैमबी

हफमैन कोडिंग।

— बेन वोइगट

बस मिडल आउट मैन का उपयोग करें

— जॉन डेमेट्रियौ

41

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

डेल्टास के साथ, आप कभी भी उन इकाइयों की स्थिति नहीं भेजेंगे जो बिल्कुल भी स्थानांतरित नहीं हुई थीं । यही इसकी आत्मा है।

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

आपके दिए गए मामले में, यह (आपके कोडबेस के आधार पर) डेल्टास को एन्कोड करने के लिए बिट्स की कम संख्या का उपयोग करना संभव हो सकता है, क्योंकि पूर्ण राज्य भेजने के लिए आवश्यक बड़ी बिट-रेंजों के विपरीत। कहें कि दुनिया कई किलोमीटर के पार है, आपको एक स्थिति में एक सेंटीमीटर, कहने के लिए पदों को सही ढंग से एनकोड करने के लिए 32-बिट फ्लोट की आवश्यकता हो सकती है। हालांकि, संस्थाओं के लिए लागू अधिकतम वेग, जो केवल प्रति टिक के कुछ मीटर हो सकते हैं, यह केवल 8 बिट्स में संभव हो सकता है (2 ^ 8 = 256 इतना अधिकतम 200 सेमी स्टोर करने के लिए पर्याप्त)। निश्चित रूप से, यह फ्लोटिंग पॉइंट उपयोग के बजाय नियत है ... या ओपनग्लस की तरह किसी तरह का आधा / चौथाई फ्लोट, यदि आप निश्चित पॉइंट झंझट नहीं चाहते हैं।

— इंजीनियर
स्रोत

7

आपका उत्तर मेरे लिए स्पष्ट नहीं है। मुझे ऐसा लगता है कि नहीं चलती हुई वस्तु की जानकारी नहीं भेजना, डेल्टा एन्कोडिंग का केवल एक साइड इफेक्ट है न कि "इस की भावना"। डेल्टा एन्कोडिंग का उपयोग करने का असली कारण शाफ़्ट के फ्रीक के उत्तर में बेहतर बताया गया है।

— एट्सेटपब निओलिव

14

@EtsitpabNioliv "आत्मा" बस "जो आपके पास नहीं है उसे न भेजें"। इसे बिट स्तर तक ले जाया जा सकता है - "केवल उतनी ही बैंडविड्थ का उपयोग करें जितना आपको तार पर आवश्यक संदेश प्राप्त करने की आवश्यकता है"। यह उत्तर स्पष्ट रूप से हर किसी के लिए पर्याप्त स्पष्ट लगता है। धन्यवाद।

— इंजीनियर

4

@EtsitpabNioliv एवर ने इस बात की जानकारी दी कि SVN फाइलों को सर्वर साइड कैसे स्टोर करता है? यह पूरी फाइल को प्रत्येक कमिट में स्टोर नहीं करता है। यह डेल्टास को संग्रहीत करता है , प्रत्येक प्रतिबद्ध में परिवर्तन होते हैं। "डेल्टा" शब्द का प्रयोग अक्सर गणित और प्रोग्रामिंग में दो मूल्यों के बीच अंतर को संदर्भित करने के लिए किया जाता है । मैं गेम प्रोग्रामर नहीं हूं, लेकिन मुझे आश्चर्य होगा कि उपयोग गेमिंग में बहुत अलग है। विचार तब समझ में आता है: आप डेटा की मात्रा को "कंप्रेस" करते हैं, जिसे आपको हर चीज के बजाय केवल अंतर भेजकर भेजना चाहिए। (यदि इसका कोई भी हिस्सा मुझे भ्रमित कर रहा है, तो यह शब्द है "संपीड़ित।")

— jpmc26

1

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

— liggiorgio

22

आपके पास गलत डेल्टा है। आप व्यक्तिगत तत्वों के डेल्टा को देख रहे हैं। आपको पूरे दृश्य के डेल्टा के बारे में सोचना होगा।

मान लीजिए कि आपके दृश्य में 100 तत्व हैं, लेकिन उनमें से केवल 1 ही स्थानांतरित हुआ। यदि आप 100 तत्व वैक्टर भेजते हैं, तो उनमें से 99 बर्बाद हो जाते हैं। आपको वास्तव में केवल 1 भेजने की आवश्यकता है।

अब, मान लें कि आपके पास एक JSON ऑब्जेक्ट है जो आपके सभी तत्व वैक्टर को संग्रहीत करता है। यह ऑब्जेक्ट आपके सर्वर और क्लाइंट के बीच सिंक किया गया है। निर्णय लेने के बजाय "ऐसा किया और इतना आगे बढ़ गया?" आप सिर्फ एक JSON ऑब्जेक्ट में अपना अगला गेम टिक उत्पन्न कर सकते हैं, एक बना सकते हैं diff tick100.json tick101.jsonऔर उस अंतर को भेज सकते हैं। क्लाइंट की तरफ, आप अपने वर्तमान टिक के वेक्टर में अंतर लागू करते हैं और आप सभी सेट होते हैं।

ऐसा करने से आप पाठ (या बाइनरी!) में अंतर का पता लगाने में विशेषज्ञता के दशकों का लाभ उठाते हैं और अपने आप को कुछ भी याद करने के बारे में चिंता करने की ज़रूरत नहीं है। अब आदर्श रूप से आप एक पुस्तकालय का भी उपयोग करते हैं जो आपके लिए पर्दे के पीछे ऐसा करता है कि आप इसे डेवलपर के रूप में भी आसान बना सकें।

— corsiKa
स्रोत

2

diffएक अक्षम हैक की तरह ध्वनियों का उपयोग करना । JSON स्ट्रिंग को प्राप्त करने वाले छोर पर रखते हुए, हर एक बार इसे पैचिंग और डिसेररलाइज़ करना अनावश्यक है। दो कुंजी-मूल्य शब्दकोशों के अंतर की गणना करना कोई जटिल काम नहीं है, मूल रूप से आप सभी कुंजियों पर लूप करते हैं और जांचते हैं कि क्या मान समान हैं। यदि नहीं, तो आप उन्हें परिणामी कुंजी-मान के साथ जोड़ते हैं और अंत में आप JSON को अनुक्रमित अनुक्रमित भेजते हैं। सरल, विशेषज्ञता के वर्षों की आवश्यकता नहीं है। भिन्न के विपरीत, यह विधि: 1) पुराने (प्रतिस्थापित) डेटा को शामिल नहीं करेगी; 2) यूडीपी के साथ अधिक अच्छी तरह से खेलता है; 3) न्यूलाइन्स पर भरोसा नहीं करता है

— ग्रोनोस्तज

8

@gronostaj यह बिंदु को पार करने के लिए एक उदाहरण था। मैं वास्तव में JSON के लिए भिन्न का उपयोग करने की वकालत नहीं करता - इसीलिए कहते हैं कि "मान लीजिए।"

— corsiKa

2

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

— सेलाली एडोबोर

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

— corsiKa

9

बहुत बार एक अन्य संपीड़न तंत्र उदाहरण के अंकगणितीय संपीड़न के लिए डेल्टा एन्कोडिंग के साथ संयोजन में होगा।

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

— शाफ़्ट सनकी
स्रोत

1

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

— लुआण

मैं सहमत हूँ। जवाब में संपीड़न प्रासंगिक है।

— लियोपोल्डो सैंसिएक

8

आप मोटे तौर पर सही हैं, लेकिन एक महत्वपूर्ण बिंदु गायब है।

एक खेल में संस्थाओं को कई विशेषताओं द्वारा वर्णित किया जाता है, जिनमें से स्थिति केवल एक है ।

किस तरह के गुण? बहुत कठिन सोचने के बिना, नेटवर्क गेम में ये शामिल हो सकते हैं:

स्थान।
अभिविन्यास।
वर्तमान फ्रेम नंबर।
रंग / प्रकाश जानकारी।
पारदर्शिता।
मॉडल का उपयोग करने के लिए।
उपयोग करने के लिए बनावट।
विशेष प्रभाव।
आदि।

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

हालाँकि, ये सभी विशेषताएँ समान दर पर नहीं बदलती हैं ।

मॉडल नहीं बदलता है? डेल्टा संपीड़न के बिना, यह वैसे भी पीछे हटना चाहिए। डेल्टा खाद के साथ इसकी आवश्यकता नहीं है।

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

— मैक्सिमस मिनिमस
स्रोत

8

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

हालांकि, दो तरीके हैं जो डेल्टा पर आधारित एक अच्छी तरह से डिज़ाइन की गई प्रणाली ट्रैफ़िक को बचा सकती है।

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

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

— पीटर ग्रीन
स्रोत

6

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

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

उदाहरण के लिए, यदि आप वेक्टर को एनकोड करना चाहते हैं {68923, 69012, 69013, 69015}तो आप डेल्टा-एनकोड कर सकते हैं {68923, 89, 1, 2}। एक तुच्छ वैरिएबल-बाइट एन्कोडिंग का उपयोग करते हुए, जहाँ आप प्रति बाइट 7 बिट डेटा संग्रहीत करते हैं और एक बिट का उपयोग करके यह इंगित करते हैं कि एक और बाइट आ रही है, सरणी में अलग-अलग तत्वों में से प्रत्येक को इसे प्रसारित करने के लिए 3 बाइट्स की आवश्यकता होगी, लेकिन डेल्टा-एन्कोडिंग संस्करण पहले तत्व के लिए केवल 3 बाइट्स और शेष तत्वों के लिए 1 बाइट की आवश्यकता होगी; आपके द्वारा क्रमबद्ध किए जा रहे डेटा के आधार पर यह कुछ बहुत प्रभावशाली बचत हो सकती है।

हालाँकि, यह एक क्रमिक अनुकूलन का अधिक है और आमतौर पर इसका मतलब यह नहीं है जब हम "डेल्टा एन्कोडिंग" के बारे में बात करते हैं, जब यह खेल राज्य (या वीडियो या इस तरह) के हिस्से के रूप में मनमाने ढंग से डेटा स्ट्रीमिंग करने की बात आती है; अन्य उत्तर पहले से ही समझाने का पर्याप्त काम करते हैं।

— शराबी
स्रोत

4

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

यहाँ पायथन में एक उदाहरण दिया गया है:

import numpy as np
import zlib
import json
import array


state1 = np.random.random(int(1e6))

diff12 = np.r_[np.random.random(int(0.1e6)), np.zeros(int(0.9e6))]
np.random.shuffle(diff12) # shuffle so we don't cheat by having all 0s one after another
state2 = state1 + diff12

state3 = state2 + np.random.random(int(1e6)) * 1e-6
diff23 = state3 - state2

def compressed_size(nrs):
    serialized = zlib.compress(array.array("d", nrs).tostring())
    return len(serialized)/(1024**2)


print("Only 10% of elements change for state2")
print("Compressed size of diff12: {:.2f}MB".format(compressed_size(diff12)))
print("Compressed size of state2: {:.2f}MB".format(compressed_size(state2)))

print("All elements change by a small value for state3")
print("Compressed size of diff23: {:.2f}MB".format(compressed_size(diff23)))
print("Compressed size of state3: {:.2f}MB".format(compressed_size(state3)))

जो मुझे देता है:

Only 10% of elements change for state2
Compressed size of diff12: 0.90MB
Compressed size of state2: 7.20MB
All elements change by a small value for state3
Compressed size of diff23: 5.28MB
Compressed size of state3: 7.20MB

— csiz
स्रोत

अच्छा उदाहरण है। संपीड़न यहाँ एक भूमिका निभाता है।

— लियोपोल्डो सैंसिएक

0

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

वर्तमान स्थिति: 23009.0, 1.0, 2342.0 (3 फ्लोट)
नई स्थिति: 23010.0, 1.0, 2341.0 (3 फ्लोट)
डेल्टा: 1, 0, -1 (3 बाइट)

हर बार सटीक स्थिति भेजने के बजाय, हम डेल्टा भेजते हैं।

— the_lotus
स्रोत

0

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

मान लीजिए कि आपकी 2D में 100 इकाइयाँ हैं। एक बड़ी ग्रिड पर, 512 x 512। उदाहरण के लिए केवल पूर्णांकों को ध्यान में रखते हुए। यह दो पूर्णांक संख्या प्रति इकाई या 200 संख्या है।

दो अपडेट के बीच, हमारे सभी पद 0, 1, -1, 2 या -2 से बदलते हैं। 0 के 100 उदाहरण, 1 और -1 के 33 उदाहरण और 2 और -2 के केवल 17 उदाहरण हैं। यह बहुत आम है। हम संपीड़न के लिए हफ़मैन कोडिंग चुनते हैं।

इस के लिए हफमैन पेड़ होगा:

आपके सभी 0 को एक बिट के रूप में एन्कोड किया जाएगा। वह केवल 100 बिट्स है। 66 मान 3 बिट्स के रूप में एन्कोड किए जाएंगे और केवल 34 मान 4 बिट्स के रूप में। वह 434 बिट्स या 55 बाइट्स है। साथ ही कुछ छोटे ओवरहेड हमारे मैपिंग ट्री को बचाने के लिए, क्योंकि पेड़ छोटा है। ध्यान दें कि 5 संख्याओं को एनकोड करने के लिए, आपको 3 बिट्स की आवश्यकता होगी। हमने यहां '-2' के लिए 4 बिट्स का उपयोग करने की आवश्यकता के लिए '0' के लिए 1 बिट का उपयोग करने की क्षमता का कारोबार किया है।

अब इसकी तुलना 200 मनमानी संख्या भेजने के लिए करें। यदि आपकी इकाइयाँ एक ही टाइल पर नहीं हो सकती हैं, तो आपको लगभग गारंटी है कि आपको एक खराब सांख्यिकीय वितरण मिलता है। सबसे अच्छा मामला 100 यूनिक नंबर होगा (सभी अलग-अलग Y के साथ एक ही X पर)। यह कम से कम 7 बिट प्रति संख्या (175 बाइट्स) है और किसी भी संपीड़न एल्गोरिदम के लिए बहुत कठिन है।

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

ध्यान दें कि डेल्टा एन्कोडिंग और संपीड़न का उपयोग अन्य स्थितियों में अन्य परिवर्तनों के साथ भी किया जाता है।

एमपीईजी छोटे वर्गों में चित्र को विभाजित करता है और अगर चित्र का हिस्सा चलता है, तो केवल आंदोलन और एक परिवर्तन चमक बचता है। 25fps की फिल्म में, फ्रेम के बीच बहुत सारे बदलाव बहुत छोटे होते हैं। पुन: डेल्टा एन्कोडिंग + संपीड़न। स्थिर दृश्यों के लिए सबसे अच्छा काम करता है।

— MartinTeeVarga
स्रोत