[Powered by Google Translate] [Walkthrough - समस्या सेट 4]
[Zamyla चान - हार्वर्ड विश्वविद्यालय]
[यह CS50 है. - CS50.TV]
सही सभी. सबको नमस्ते, और 4 Walkthrough के लिए आपका स्वागत है.
>> आज हमारे pset Forensics है.
Forensics एक सच में मज़ा pset है कि बिटमैप फाइलों के साथ काम करना शामिल है
पता चलता है जो एक अपराध है.
तो फिर हम कुछ बिटमैप फाइलों का आकार करने के लिए जा रहे हैं,
तो हम भी एक सच में मज़ा पुनर्प्राप्त बुलाया भाग के साथ सौदा करने के लिए जा रहे हैं,
जिसमें हम मूल रूप से एक स्मृति कार्ड हाथ कर रहे हैं
जिसमें किसी को गलती से उनके फ़ाइलों के सभी नष्ट कर दिया गया है,
और हम उन फ़ाइलों को ठीक करने के लिए कहा हो.
>> लेकिन पहले, पहले हम pset में मिलता है, मैं वास्तव में हर किसी को बधाई देता हूं करना चाहते हैं.
हम इस पाठ्यक्रम के मध्य में कर रहे हैं के बारे में.
प्रश्नोत्तरी 0 हमारे पीछे है, और हम pset4 में कर रहे हैं, इसलिए अनिवार्य रूप से, हम आधे रास्ते से कर रहे हैं.
हम एक लंबा रास्ता तय किया है कि अगर आप अपने psets, pset0 और pset1 वापस देखो,
तो अपने आप को उस के बारे में बधाई,
और हम कुछ सच में मज़ा सामान में मिल जा रहे हैं.
>> तो इस pset लिए हमारे toolbox, फिर से, बजाय sudo अद्यतन yum-y चलाने की,
हम सिर्फ update50 चलाने के लिए सक्षम हो अगर आप 17.3 संस्करण और उपकरण के ऊपर हो.
तो लिए update50 चलाने के लिए सुनिश्चित हो - यह एक बहुत आसान है, कुछ कम वर्ण -
को यकीन है कि आप उपकरण के नवीनतम संस्करण में हैं.
विशेष रूप से यह update50 के लिए महत्वपूर्ण है जब हम CS50 जाँचें का उपयोग शुरू.
तो यकीन है कि आपको लगता है कि.
>> इस pset के लिए सभी वर्गों के लिए,
फ़ाइल हम फ़ाइल निविष्टियाँ और outputs के साथ काम करने जा रहे हैं, मैं / ओ
हम प्रोग्राम है कि arrays के साथ सौदा की एक बहुत ऊपर जा रहा हो जा रहे हैं
फ़ाइलें और इस तरह बातें की ओर इशारा करते हैं,
इसलिए हम यकीन है कि हम वास्तव में परिचित और आराम कर रहे हैं बनाना चाहते हैं
कैसे और फ़ाइलों में इनपुट, आउटपुट के साथ काम कर रहे हैं.
>> इस pset लिए वितरण कोड एक copy.c नामक एक फाइल है,
और है कि हम को खोजने के लिए जा रहे हैं कि क्या वास्तव में हमारे लिए उपयोगी होने जा रहा है
क्योंकि हम को समाप्त करने के लिए जा रहे हैं वास्तव में copy.c फाइल कॉपी
और सिर्फ यह फेरबदल थोड़ा समस्या सेट के पहले 2 भागों को प्राप्त करने में सक्षम हो.
>> और इतना तो जैसा कि मैंने पहले उल्लेख किया है, हम के रूप में के रूप में अच्छी तरह से bitmaps JPEGs के साथ काम कर रहे हैं.
तो सच में कैसे उन फ़ाइलों का आयोजन कर रहे हैं की संरचना को समझने,
हम वास्तव में कैसे 0s और structs में 1s अनुवाद कर सकते हैं
और बातें है कि हम वास्तव में समझ और व्याख्या कर सकते हैं और संपादित करें,
कि वास्तव में महत्वपूर्ण होगा,
तो JPEG और बिटमैप फ़ाइलों में जा रहा है और उन की संरचना को समझने.
>> Pset4, हमेशा की तरह सवालों के एक खंड के साथ शुरू होता है.
उन मैं / हे फ़ाइल के साथ निपटने के लिए और आपको लगता है कि के आदी हो जाएगा.
फिर 1 भाग whodunit है, जिसमें आप एक बिटमैप फ़ाइल दिया हो
कि लाल डॉट्स की तरह तरह की सब से अधिक लग रहा है.
और फिर मूल रूप से हम क्या करने जा रहे है इस फ़ाइल ले और बस यह थोड़ा संपादित
में एक संस्करण है कि हम पढ़ सकते हैं.
मूलतः, एक बार हम खत्म, हम एक ही फाइल करना होगा,
को छोड़कर हम छिपा उन सभी लाल डॉट्स द्वारा छिपा संदेश को देखने में सक्षम हो जाएगा.
फिर आकार बदला जा सकने वाला एक प्रोग्राम है कि एक फ़ाइल दिया है
और फिर फ़ाइल outputs है कि यह नाम दिया और फिर एक संख्या के रूप में अच्छी तरह से दिया है,
वास्तव में है कि पूर्णांक मान द्वारा कि बिटमैप आकार जाएगा.
तो अंत में, हम ठीक pset है.
हम एक स्मृति कार्ड दिया जाता है और फिर तस्वीरों के सभी ठीक
कि गलती से हटा दिया गया है,
लेकिन, जैसा कि हम सीख जाओगे नष्ट कर दिया है, और नहीं वास्तव में फाइल से हटा दिया;
जहां वे फ़ाइल में थे हम बस की तरह खो दिया है, लेकिन हम चाहते हैं कि ठीक जा रहे हैं.
>> बढ़िया है. तो फ़ाइल में जा रहा मैं / हे विशेष रूप से, इन कार्यों की एक पूरी सूची है कि आप का उपयोग किया जाएगा.
आप पहले से ही एक छोटा सा fopen की मूल बातें, fread और fwrite देखा है,
लेकिन हम कुछ फ़ाइल में आगे देखने के लिए जा रहे हैं मैं / हे fputc के रूप में कार्य,
जिसमें आप एक बार में सिर्फ एक चरित्र लिखने,
fseek, जहाँ आप फ़ाइल की स्थिति सूचक आगे और पीछे की ओर ले जाने की तरह,
और फिर कुछ दूसरों. लेकिन हम उस में pset दौरान थोड़ा बाद में जाना होगा.
>> तो पहले, बस फाइल में पाने के लिए मैं / हे पहले हम pset में जाना,
एक फ़ाइल खोलने के लिए, उदाहरण के लिए, तुम्हें क्या करना है क्या वास्तव में उस फाइल करने के लिए एक सूचक सेट कर दिया जाता है.
तो हम एक फ़ाइल * सूचक है.
इस मामले में, मैं इसे एक सूचक में बुला रहा हूँ क्योंकि मेरे infile होने जा रहा है.
और इसलिए मैं समारोह और फिर फ़ाइल का नाम fopen का उपयोग करने के लिए जा रहा हूँ
और फिर मोड में जो मैं जा रहा हूँ फ़ाइल के साथ काम करने के लिए.
तो वहाँ पढ़ने के लिए इस मामले में, "r" "w" लिखने के लिए, और फिर appending के लिए "एक" है.
उदाहरण के लिए, आप एक infile के साथ जब काम कर रहे हैं
और आप सब करना चाहते हैं बिट्स और बाइट्स में संग्रहीत पढ़ा है,
तो आप शायद करने के लिए उपयोग करना चाहते हैं अपनी विधा के रूप में "r" के लिए जा रहे हैं.
जब आप वास्तव में लिखने के लिए चाहते हैं, इस तरह की एक नई फ़ाइल बनाने,
तो हम क्या करने जा रहे हैं कि क्या हम नई फ़ाइल खोलने के लिए जा रहे हैं
और लिखने के लिए "w" मोड का उपयोग करें.
>> तो जब आप वास्तव में फ़ाइलों में पढ़ रहे हैं, संरचना इस प्रकार है.
पहले आप struct कि बाइट्स है कि आप पढ़ रहे हैं शामिल होंगे सूचक शामिल हैं.
तो यह है कि बाइट्स है कि आप पढ़ रहे हैं के अंत स्थान होने जा रहा है.
फिर आप को आकार का संकेत करने के लिए जा रहे हैं, मूल रूप से कितने बाइट्स
अपने कार्यक्रम के लिए फाइल करने के लिए पढ़ा है, आकार मूल रूप से एक तत्व है,
और फिर आप यह निर्दिष्ट करने के लिए आप पढ़ना चाहते हैं कि कितने तत्वों के लिए जा रहे हैं.
और फिर अंत में, आप जानते हैं कि तुम कहाँ से पढ़ रहे हैं,
इतना है कि अपने में सूचक होने जा रहा है.
मैं इन रंग कोडित क्योंकि fread भी बहुत fwrite करने के लिए इसी तरह की है,
आप यह सुनिश्चित करें कि आप सही क्रम का उपयोग बनाना चाहते हैं, को छोड़कर
सुनिश्चित करें कि आप वास्तव में लिख रहे हैं या सही फ़ाइल से पढ़ने.
>> तो जैसा कि पहले, अगर हम तत्व के आकार के रूप में के रूप में अच्छी तरह से तत्वों की संख्या है,
तो हम यहाँ के आसपास एक छोटा सा खेल सकते हैं.
कहते हैं कि मैं एक कुत्ता struct है और यदि ऐसा है तो फिर मैं एक समय में दो कुत्तों को पढ़ने के लिए चाहते हैं.
मैं क्या कर सकता है एक तत्व के आकार का कहना है कि एक कुत्ते के आकार का होने जा रहा है
और मैं वास्तव में उनमें से दो को पढ़ने के लिए जा रहा हूँ.
वैकल्पिक रूप से, मैं क्या कर सकता है का कहना है कि मैं सिर्फ एक तत्व को पढ़ने के लिए जा रहा हूँ
और कि एक तत्व के लिए दो कुत्तों के आकार का होने जा रहा है.
तो यह है कि अनुरूप है आप कर सकते हैं कैसे आकार और संख्या के साथ खेलने के आसपास तरह
क्या आप के लिए सहज है पर निर्भर करता है.
>> सही सभी. तो अब हम लेखन फाइल करने के लिए मिलता है.
जब आप एक फ़ाइल लिखना चाहते हैं, पहले तर्क वास्तव में तुम कहाँ से पढ़ रहे हैं.
तो यह है कि मूल रूप से डेटा है कि आप फ़ाइल में लिखने के लिए जा रहे हैं,
जो अंत में बाहर सूचक है.
तो जब आप pset के साथ काम कर रहे हैं, तो सुनिश्चित करें कि आप उलझन में नहीं मिलता.
शायद पक्ष द्वारा परिभाषा की ओर है.
आप परिभाषाओं के मैनुअल में खींच आदमी को टाइप करके और फिर fwrite उदाहरण के लिए,
टर्मिनल में, या आप इस स्लाइड पर वापस उल्लेख कर सकते हैं
और सुनिश्चित करें कि आप सही एक का उपयोग कर रहे हैं.
तो फिर, fwrite के लिए, जब आप एक फ़ाइल है कि आप में लिखना चाहते हैं,
कि अंतिम बहस होने जा रहा है और कहा कि कि फाइल करने के लिए एक सूचक होने जा रहा है.
तो है कि कैसे हम शायद एक समय में कई बाइट्स लिखने के साथ सौदा,
लेकिन कहते हैं कि आप सिर्फ एक ही चरित्र में लिखने के लिए चाहते हैं.
जैसा कि हम बाद में इस उदाहरण में देखेंगे, बिटमैप में हम का उपयोग करना होगा.
यही कारण है कि जब हम fputc का उपयोग कर सकते हैं, अनिवार्य रूप से सिर्फ एक समय में एक चरित्र डाल, chr,
कि फ़ाइल सूचक में, और हमारे बाहर वहाँ सूचक.
तो जब भी हम चाहते हैं या एक फ़ाइल में लिखने के लिए,
फ़ाइल जहाँ हम कर रहे हैं की नज़र रखे हुए है.
तो यह कर्सर, फ़ाइल स्थिति सूचक का एक प्रकार है.
और इसलिए जब भी हम लिखने या एक फ़ाइल में फिर से पढ़ा,
फ़ाइल वास्तव में याद है जहां यह है,
और इसलिए यह जहां कर्सर है से जारी है.
यह फायदेमंद हो सकता है जब आप चाहते हैं कर सकते हैं, कहते हैं, एक निश्चित मात्रा में पढ़ने के लिए कुछ करना
और उसके बाद निम्न राशि में पढ़ा,
लेकिन कभी कभी हम एक निश्चित संदर्भ मूल्य से शुरू करने के लिए वापस आ गया है या वास्तव में जाना चाहते हो सकता है.
तो fseek समारोह, यह क्या करता है हमें एक निश्चित फ़ाइल में कर्सर को स्थानांतरित करने की अनुमति देता है
बाइट्स की एक निश्चित संख्या है.
और फिर हमें क्या करना है क्या निर्दिष्ट जहां संदर्भ मूल्य है.
तो या तो यह जहां कर्सर वर्तमान में है से आगे या पीछे की ओर ले जाता है,
या हम निर्दिष्ट कर सकते हैं कि यह सिर्फ फ़ाइल की शुरुआत से में बढ़ना चाहिए
या फ़ाइल के अंत से.
और इसलिए आप नकारात्मक या सकारात्मक मूल्यों में राशि को पारित कर सकते हैं,
और उस तरह के कर्सर या तो आगे या पीछे की ओर कदम होगा.
>> इससे पहले कि हम अन्य psets में मिलता है, फाइल पर किसी भी सवाल मैं / हे?
ठीक है. जैसा कि हम और अधिक उदाहरण में मिलता है, मुझे प्रश्नों के लिए रोकने के लिए स्वतंत्र महसूस हो रहा है.
>> तो whodunit में, आप एक बिटमैप स्लाइड पर इस लाल एक समान फ़ाइल हाथ कर रहे हैं,
और यह इस तरह लग रहा है - लाल डॉट्स का एक गुच्छा और आप वास्तव में क्या लिखा है पता नहीं है.
अगर आप भेंगा, आप बीच के अंदर एक मामूली नीले रंग देखने के लिए सक्षम हो सकता है.
मूलतः, कि जहां पाठ संग्रहीत किया जाता है.
एक हत्या है कि क्या हुआ था, और हम पता लगाने के लिए जो यह किया है की जरूरत है.
आदेश में कहा कि, हम एक पठनीय प्रारूप में इस छवि को बदलने की तरह करने की जरूरत है.
अगर आप लोग कभी भी इस का सामना करना पड़ा है, कभी कभी थोड़ा किट होगा
जहां आप एक लाल फिल्म के साथ एक आवर्धक कांच करना होगा. कोई है? हाँ.
तो तुम इस तरह हाथ कुछ होगा, तुम एक आवर्धक कांच
पर लाल फिल्म के साथ, आप यह छवि पर रखा जाएगा,
और आप को देखने के संदेश उसमें छिपा करने में सक्षम होगा.
हम लाल फिल्म के साथ एक आवर्धक कांच की जरूरत नहीं है, तो बजाय हम तरह हमारे अपने बनाने के लिए जा रहे हैं
इस pset में.
और तो उपयोगकर्ता इनपुट whodunit, तो सुराग के लिए जा रहा है, BMP,
इतना है कि infile, कि लाल बिंदी संदेश है,
और फिर वे कह रहे हैं verdict.bmp हमारे outfile होने जा रहा है.
तो यह एक नया बिटमैप एक सुराग के लिए इसी तरह की छवि बनाने के लिए जा रहा है
एक पठनीय प्रारूप में छोड़कर जहाँ हम छिपा संदेश देख सकते हैं.
>> चूंकि हम कुछ प्रकार के bitmaps संपादन और छेड़खानी के साथ काम कर जा रहे हैं,
हम इन बिटमैप फ़ाइलों की संरचना में गोता की तरह करने के लिए जा रहे हैं.
हम व्याख्यान में ये एक छोटा सा पर चला गया है, लेकिन हम उन्हें कुछ और अधिक लग रही है.
बिटमैप्स अनिवार्य रूप से सिर्फ बाइट्स की व्यवस्था कर रहे हैं
बाइट्स जहां हम निर्दिष्ट किया है जो क्या मतलब है.
तो यहाँ बिटमैप छवि का एक नक्शा की तरह की तरह है
कह रही है कि यह कुछ हेडर फाइल के साथ शुरू होता है, वहाँ में कुछ जानकारी के साथ शुरू होता है.
आप देखते हैं कि आकार के बारे में बाइट 14 नंबर पर बिटमैप छवि का संकेत दिया है,
और यह जारी है.
लेकिन तब क्या हम वास्तव में यहाँ में रुचि रखते हैं बाइट संख्या 54 के आसपास शुरू होता है.
हम इन आरजीबी triples है.
क्या करने जा रहा है वास्तविक पिक्सल, रंग मूल्यों होते है.
शीर्ष लेख में है कि ऊपर सब कुछ जानकारी है
छवि, छवि की चौड़ाई और ऊंचाई के आकार के अनुरूप.
जब हम padding में जाने पर बाद में, हम देखेंगे क्यों छवि का आकार
चौड़ाई या ऊंचाई से अलग हो सकता है.
तो फिर इन का प्रतिनिधित्व करने के लिए इन बिटमैप छवियों बाइट्स के दृश्यों हैं -
हम क्या कर सकता है ठीक कहना है, मैं याद करने के लिए जा रहा है कि सूचकांक में 14,
कि जहां आकार उदाहरण के लिए है, है, लेकिन इसके बजाय हम क्या करने के लिए यह आसान बनाने के लिए करने जा रहे हैं
यह एक struct में encapsulate.
और इसलिए हम दो हमारे लिए बनाया structs, एक BITMAPFILEHEADER है
और एक BITMAPINFOHEADER,
और इसलिए जब भी हम उस फ़ाइल में पढ़ा है, डिफ़ॉल्ट रूप से यह करने के क्रम में जा रहा है,
और तो क्रम में यह भी ऐसे biWidth और biSize के रूप में चर में में भरने जा रहा है.
और फिर अंत में, हर पिक्सेल तीन बाइट्स द्वारा प्रतिनिधित्व किया है.
1 एक पिक्सेल में नीले रंग की राशि है, 2 हरे रंग की राशि है,
और अंत में, लाल, जहां 0 अनिवार्य रूप से कोई नीली या कोई हरा है की राशि या कोई लाल
और फिर एफएफ अधिकतम मूल्य है.
हेक्साडेसिमल मान रहे हैं.
तो अगर हम FF0000 है, तो यह है कि नीले रंग की अधिकतम राशि से मेल खाती है
और फिर हरे और कोई लाल, कोई ऐसा है तो है कि हमें एक नीले पिक्सेल देना होगा.
तो अगर हम बोर्ड भर एफएफ सब है, तो इसका मतलब है कि हम एक सफेद पिक्सेल है.
यह आम तौर पर करने के लिए विपरीत की तरह है जब हम आरजीबी का कहना है. यह वास्तव में बीजीआर जा रहा है.
>> इसलिए यदि हम वास्तव में एक बिटमैप छवि का एक उदाहरण में देखो - मुझे एक यहाँ खींच कर.
यह एक छोटे से छोटा है.
मैं में zooming रहा हूँ, और हम देख सकते हैं कि यह pixelated है. यह रंग के ब्लॉक की तरह लग रहा है.
आप सफेद ब्लॉकों के लिए और फिर लाल ब्लॉक है.
यदि आप माइक्रोसॉफ्ट पेंट में खेलते हैं, उदाहरण के लिए, आप ऐसा कुछ कर सकता है
द्वारा मूल रूप से सिर्फ एक विशिष्ट क्रम में कुछ वर्गों चित्र.
तो फिर इस अनुवाद बिटमैप में क्या है इस प्रकार है.
यहाँ हम पहले सफेद पिक्सल है, कि सभी 6 च कर रहे हैं, और फिर हम लाल पिक्सल है,
0000ff द्वारा संकेत दिया.
और इसलिए है कि हम बाइट्स की अनुक्रम से संकेत मिलता है कि बिटमैप छवि को देखने के लिए जा रहा है.
तो क्या मैं यहाँ किया है सिर्फ उन सभी बाइट्स लिखा है और फिर लाल रंग में रंग
इतना है कि आप की तरह देख सकते हैं, यदि आप एक छोटा सा भेंगापन, कैसे उस तरह एक Smiley चेहरा इंगित करता है.
>> तरीका है कि बिटमैप छवियों काम मैं यह मूल रूप से एक ग्रिड के रूप में कल्पना.
और डिफ़ॉल्ट रूप से ऐसा ग्रिड की हर पंक्ति 4 बाइट्स की एक बहु है.
अगर हम एक बिटमैप छवि को देखो, आप हर मूल्य में भर रहे हैं.
उदाहरण के लिए, आप एक लाल यहाँ है, हो सकता है यहाँ एक हरे रंग की, यहाँ एक नीले,
लेकिन आप यकीन है कि छवि में चार बाइट्स की एक बहु के साथ भरा है.
तो अगर मैं अपने तीन ब्लॉकों चौड़ा छवि चाहते हैं, तो मैं एक खाली मूल्य डाल करना होगा
यह पिछले एक में चार की एक बहु बनाने के लिए.
तो फिर मैं कुछ है जो हम padding बुला रहे हैं में जोड़ना होगा.
मैं सिर्फ एक एक्स के साथ संकेत मिलता है कि वहाँ के लिए जा रहा हूँ.
अब कहते हैं कि हम एक छवि है कि 7 पिक्सल लंबा है, उदाहरण के लिए करना चाहते हैं.
हम 1, 2, 3, 4, 5, 6, 7,
और वह सब में रंग से भरा है.
तरीका है कि बिटमैप छवियों काम यह है कि हम एक 8 की जरूरत है.
अभी हम 1, 2, 3, 4, 5, 6, 7.
हम बिटमैप छवि के लिए सही ढंग से पढ़ा 8 रिक्त स्थान की जरूरत है.
तो फिर हम क्या करना है सिर्फ padding के एक बिट में जोड़ रहा है
सुनिश्चित करें कि सभी widths के समान हैं
और है कि चौड़ाई के सभी 4 की एक बहु.
और इसलिए मैं पहले संकेत दिया है, एक एक्स या एक squiggly लाइन के रूप में पैडिंग,
लेकिन वास्तविक बिटमैप छवियों में padding एक hexadecimal 0 से संकेत दिया है.
तो यह है कि एक ही चरित्र, 0 होगा.
काम में आ सकता क्या xxd कमांड है.
यह क्या करता है वास्तव में आप से पता चलता है, मैं क्या स्माइली के साथ पहले किया था इसी तरह की तरह
जब मैं वास्तव में बाहर मुद्रित प्रत्येक रंग पिक्सेल के लिए क्या होगा
और फिर यह रंग कोडित, जब आप चलाने के निम्न कमांड के साथ xxd
तो यह वास्तव में बाहर प्रिंट क्या रंग उन पिक्सल के लिए कर रहे हैं.
तुम्हें क्या करना है क्या यहाँ पर संकेत मिलता है मैं 54-जैसे,
का कहना है कि मैं 54 बाइट पर शुरू करने के लिए जा रहा हूँ
कि क्योंकि इससे पहले, याद है अगर हम bitmaps के नक्शे के लिए वापस देखो,
कि सभी शीर्ष लेख और उस तरह की जानकारी चीजें है.
लेकिन क्या हम वास्तव में के बारे में परवाह वास्तविक पिक्सल है कि रंग से संकेत मिलता है.
तो उस ध्वज में जोड़ने 54,, तो हम रंग मूल्यों को देखने में सक्षम हो.
और जटिल और झंडे की तरह है कि चीजों के बारे में चिंता मत करो.
समस्या सेट कल्पना में, आप कैसे xxd पिक्सेल प्रदर्शन का उपयोग करने के लिए निर्देश दिया है.
तो अगर आप यहाँ देख कर, यह एक तरह से एक हरे रंग बॉक्स, इस छोटी सी बात की तरह लग रहा है.
मैं मूल रूप से कोई नीले, हरे रंग का एक बहुत कुछ है, और कोई लाल के रूप में कह 00ff00 रंग कोडित.
तो यह है कि हरे रंग से मेल खाती है.
जैसा कि आप यहाँ देख, हम एक हरे रंग की आयत देख.
यह हरे आयत केवल 3 पिक्सल चौड़ा है, तो फिर हम क्या करना है
लगता है कि छवि 4 विस्तृत की एक बहु है अतिरिक्त padding में जोड़ें.
और इतना तो है कि कैसे आप इन 0s यहाँ देखें.
यह वास्तव में अपने आकार बदला जा सकने pset का परिणाम होगा,
अनिवार्य रूप से छोटे बिटमैप ले रही है और फिर यह 4 से विस्तार.
और इसलिए हम देखते हैं क्या होता है कि वास्तव में इस छवि 12 पिक्सल चौड़ा है, लेकिन 12 4 की एक बहु है,
और इसलिए हम वास्तव में अंत में किसी भी 0s नहीं देख क्योंकि हम किसी भी जोड़ने की जरूरत नहीं है
क्योंकि यह पूरी तरह से गद्देदार है. यह किसी भी अधिक कमरा नहीं है.
>> ठीक है. Padding के बारे में कोई सवाल है?
ठीक है. कूल.
>> जैसा कि मैंने पहले उल्लेख किया है, bitmaps सिर्फ बाइट्स के एक दृश्य हैं.
और इसलिए हम क्या बिल्कुल बाइट की संख्या जो का ट्रैक रखने की जरूरत के बजाय
किसी विशिष्ट तत्व से मेल खाती है, हम वास्तव में एक struct बनाया है कि प्रतिनिधित्व.
तो हम क्या एक RGBTRIPLE struct है.
, जब भी आप एक आरजीबी ट्रिपल का एक उदाहरण है
क्योंकि यह है कि एक प्रकार struct को परिभाषित करने के लिए, तो आप rgbtBlue चर का उपयोग कर सकते हैं,
इसी तरह हरे और लाल चर, जो संकेत जाएगा कितना नीले, हरे, और लाल,
क्रमशः, आप.
>> तो अगर हम 0 से, एफएफ के लिए हरी सेट, नीले चर सेट है
जो अधिकतम मूल्य है आप कर सकते हैं, और फिर लाल चर 0 पर सेट,
तो क्या रंग इस विशेष आरजीबी ट्रिपल प्रतिनिधित्व चाहते हैं? >> [छात्र] ग्रीन.
ग्रीन. बिल्कुल सही.
यह पता करने के लिए उपयोगी हो सकता है जा रहा है कि जब भी आप एक आरजीबी ट्रिपल का एक उदाहरण है
नीले, हरे और लाल - अलग आप वास्तव में रंग की राशि का उपयोग कर सकते हैं.
>> अब है कि हम उस की संरचना के बारे में बात की है, चलो BMP फ़ाइल पर एक नज़र रखना.
आप के लिए बनाया structs हैं.
यहाँ हम एक BITMAPFILEHEADER struct है.
ब्याज के आकार है.
बाद में, हम जानकारी हैडर है, जो हमें कुछ और बातें है कि दिलचस्प हैं,
अर्थात् आकार, चौड़ाई और ऊंचाई.
जैसा कि हम बाद में जाना होगा, जब आप फ़ाइल को पढ़ने के लिए
यह स्वतः ही है क्योंकि हम क्रम निर्धारित किया है के लिए ही होना पढ़ता है.
तो biSize सही बाइट्स कि छवि के वास्तविक आकार के अनुरूप हो जाएगा.
और फिर यहाँ, अंत में, जैसा कि हम के बारे में बात की है, हम RGBTRIPLE typedef struct है.
हम एक rgbtBlue, ग्रीन, और लाल इसके साथ जुड़े है.
>> बढ़िया है. ठीक है.
अब है कि हम बिटमैप थोड़ा समझ, समझते हैं कि हम एक फ़ाइल शीर्षक है
और जानकारी के साथ यह और फिर उस के बाद जुड़े हैडर, हम दिलचस्प सामान
रंग की, और उन रंग RGBTRIPLE structs द्वारा प्रतिनिधित्व कर रहे हैं,
और उन लोगों के लिए, बदले में, तीन नीले, हरे, लाल और जुड़े मूल्यों है.
>> तो अब, हम लगता है के बारे में एक बिट पुनर्प्राप्त की तरह कर सकते हैं.
माफ़ कीजिए. Whodunit के बारे में सोचो.
जब हम अपने सुराग फ़ाइल है, तो हम क्या करना चाहते हैं यह करने के लिए में पिक्सेल द्वारा पिक्सेल पढ़ा है
और फिर किसी भी तरह उन पिक्सल बदलने इतना है कि हम यह एक पठनीय प्रारूप में उत्पादन कर सकते हैं.
और ऐसा करने के लिए यह उत्पादन, हम verdict.bmp फ़ाइल में पिक्सेल द्वारा पिक्सेल लिखने जा रहे हैं.
यह करने के लिए एक बहुत की तरह है. हम पता है कि.
तो हम क्या किया है यह है कि हम वास्तव में आपके द्वारा प्रदान की copy.c.
Copy.c क्या करता है बस एक दिया बिटमैप फ़ाइल का एक सटीक प्रतिलिपि बनाता है और फिर यह outputs.
तो यह पहले से ही आप के लिए फ़ाइल को खोलता है, पिक्सेल द्वारा पिक्सेल में पढ़ता है,
और फिर इसे एक आउटपुट फाइल में लिखते हैं.
>> चलो उस पर एक नज़र रखना.
यह उचित उपयोग सुनिश्चित करना है,
filenames यहाँ हो रही है.
यह क्या करता है यह इनपुट फ़ाइल सेट करने के लिए क्या हम में infile में पारित कर दिया है यहाँ,
जो हमारी दूसरी कमांड लाइन तर्क है.
यकीन है कि हम फ़ाइल को खोल सकते हैं बनाना जाँचता है.
यकीन है कि हम एक नए outfile यहाँ कर सकते हैं बनाने जाँचता है.
तो यह क्या यहाँ है, यह सिर्फ मूल रूप से बिटमैप फ़ाइल में शुरू से ही पढ़ने शुरू होता है.
शुरुआत है, जैसा कि हम जानते हैं, BITMAPFILEHEADER होता है,
और इसलिए बिट्स के उन दृश्यों सीधे BITMAPFILEHEADER में भरना होगा.
तो क्या हम यहाँ है कि BITMAPFILEHEADER bf कह रहा है -
कि हमारे प्रकार BITMAPFILEHEADER के नए चर है -
हम bf के अंदर डाल हम क्या सूचक में से पढ़ने के लिए जा रहे हैं, जो हमारे infile है.
हम कितना पढ़ा है?
हम कितने बाइट्स हम पूरी BITMAPFILEHEADER होते हैं की जरूरत में पढ़ा.
इसी तरह, कि जानकारी हेडर के लिए हमें क्या करना है.
तो हम हमारे फाइल के साथ infile में जारी कर रहे हैं,
और हम उन बिट्स और बाइट्स पढ़ रहे हैं, और हम उन्हें plugging रहे हैं में सीधे
चर है कि हम कर रहे हैं की इन उदाहरणों में.
यहाँ हम सिर्फ यह सुनिश्चित करें कि बिटमैप एक बिटमैप है कर रहे हैं.
>> अब हम एक outfile, है ना?
तो के रूप में यह खड़ा है जब हम इसे बनाने के लिए है, यह अनिवार्य रूप से खाली है.
तो हम मूल रूप से खरोंच से एक नया बिटमैप बनाने के लिए किया है.
हमें क्या करना है हम यकीन है कि हम फ़ाइल शीर्षक में कॉपी बनाना है
और infile तरह सिर्फ जानकारी शीर्षक है.
हमें क्या करना है हम लिखने और याद कि bf चर है
प्रकार BITMAPFILEHEADER की तो, हम क्या है हम सिर्फ कि सामग्री का उपयोग करें
outfile में लिखने के लिए.
याद है, हम padding के बारे में बात की थी,
कैसे लगता है कि पिक्सल है कि हम की राशि 4 की एक बहु है बनाने के लिए यह महत्वपूर्ण है.
यह एक बहुत उपयोगी सूत्र की गणना के लिए आप कितना padding है
अपनी फ़ाइल की चौड़ाई को देखते हुए.
मैं तुम लोगों को याद करने के लिए कि copy.c में हम padding की गणना के लिए एक फार्मूला है.
ठीक है? तो हर कोई याद है कि. बढ़िया है.
तो फिर copy.c क्या करता बगल में है, यह खत्म scanlines के सभी दोहराता है.
यह पंक्तियों के माध्यम से पहली बार चला जाता है और फिर हर ट्रिपल कि यह पढ़ता भंडार
और फिर यह outfile में लिखता है.
तो फिर यहाँ हम एक समय में केवल एक आरजीबी ट्रिपल पढ़ रहे हैं
और फिर outfile में है कि एक ही ट्रिपल डाल.
मुश्किल हिस्सा है कि padding एक आरजीबी ट्रिपल नहीं है,
और इसलिए हम सिर्फ आरजीबी triples कि padding राशि नहीं पढ़ सकते हैं.
हमें क्या करना है क्या वास्तव में सिर्फ हमारे फ़ाइल स्थिति सूचक ले जाने के लिए, हमारे कर्सर को स्थानांतरित करने के लिए,
सभी padding पर छोड़ इतना है कि हम अगली पंक्ति में हैं की तरह.
और फिर यह क्या करता है प्रतिलिपि दिखाता है कि आप padding जोड़ने के लिए चाहते हो सकता है.
तो हम गणना है कितना padding हम की जरूरत है,
तो इसका मतलब है कि हम 0s के पैडिंग संख्या की जरूरत है.
यह क्या करता है पाश है कि हमारे outfile में 0s के पैडिंग संख्या डालता है के लिए एक है.
और फिर अंत में, आप दोनों फ़ाइलों बंद. आप के रूप में के रूप में अच्छी तरह से outfile infile करीब है.
>> तो है कि copy.c कैसे काम करता है,
और कहा कि बहुत उपयोगी होने जा रहा है.
के बजाय सिर्फ वास्तव में सीधे कॉपी और चिपकाने
या सिर्फ यह देख रहे हैं और जो आप चाहते हैं टाइप,
आप बस टर्मिनल में इस आदेश पर अमल करना चाहते हो सकता है,
सी.पी. copy.c whodunit.c, जो एक नई फ़ाइल बनाने whodunit.c,
कि सटीक एक ही सामग्री के रूप में प्रतिलिपि करता है शामिल हैं.
तो फिर हम क्या कर सकते है कि जिस पर एक ढांचे के रूप में बनाने के लिए और संपादित करने के लिए
हमारे whodunit फ़ाइल के लिए.
>> ये हमारे लिए डॉस whodunit के लिए करने के लिए कर रहे हैं, लेकिन क्या copy.c करता है
है वास्तव में हमारे लिए उनमें से अधिकांश का ख्याल रखता है.
तो हम सब आगे क्या जरूरत है पिक्सल बदलने के रूप में जरूरत
वास्तव में फ़ाइल पठनीय बनाने.
एक दिया ट्रिपल पिक्सेल के लिए याद रखें कि, प्रकार RGBTRIPLE की एक भी चर के लिए तो,
आप नीले, हरे और लाल मूल्यों का उपयोग कर सकते हैं.
कि आने के लिए काम में लिए जा रहा है क्योंकि अगर आप उन तक पहुँच सकते हैं,
इसका मतलब है कि आप भी उन्हें जांच कर सकते हैं,
और इसका मतलब है कि आप उसे बदल सकते हैं.
>> इसलिए, जब हम हमारे लाल आवर्धक कांच उदाहरण के लिए वापस चला गया
मूलतः, कि हमारे लिए फिल्टर का एक प्रकार के रूप में काम कर रहा था.
तो हम क्या करना चाहते है हम ट्रिपल कि अंदर आ रहे हैं के सभी फ़िल्टर करना चाहते हैं
वहाँ कई अलग अलग तरीके से ऐसा कर रहे हैं.
असल में, आप कर सकते हैं फ़िल्टर के प्रकार जो आप चाहते हैं.
हो सकता है कि आप सभी लाल पिक्सल बदलना चाहते हैं
या शायद आप एक अलग रंग के लिए एक अलग रंग पिक्सेल बदलना चाहते हैं.
यह आप पर निर्भर है.
याद रखें कि आप देख सकते हैं कि क्या रंग है पिक्सेल
और फिर आप भी इसे बदलने के रूप में आप के माध्यम से जा रहे हैं कर सकते हैं.
>> ठीक है. तो यह है कि whodunit है.
एक बार जब आप whodunit चलाते हैं, तो आपको पता चल जाएगा कि अपराध का दोषी कौन था.
>> अब हम का आकार बदलना करने के लिए जाने के लिए जा रहे हैं.
हम अभी भी बिटमैप के साथ काम किया जा रहे हैं.
हम क्या करते हैं तो हम एक इनपुट बिटमैप करने के लिए जा रहे हैं
और फिर हम एक संख्या में पारित करने के लिए और फिर एक outfile बिटमैप मिलता जा रहे हैं
कहाँ है कि मूल रूप से हमारे n द्वारा पहुंचा infile.
कहते हैं कि मेरी फाइल सिर्फ एक पिक्सेल बड़ी थी.
फिर अगर मेरे n 3 से 3, स्केलिंग था, तो मुझे लगता है कि n बार की पिक्सेल संख्या दोहराना होगा,
तो 3 बार, और फिर भी यह नीचे पैमाने पर 3 बार के रूप में अच्छी तरह से.
तो आप देखते हैं, मैं इसे स्केलिंग हूँ के रूप में अच्छी तरह के रूप में खड़ी क्षैतिज.
>> और फिर यहाँ एक उदाहरण है.
यदि आप n = 2 है, तो आप देखते हैं कि पहली नीली पिक्सेल दो बार दोहराया
क्षैतिज रूप में खड़ी दो बार के रूप में अच्छी तरह से.
और फिर उस पर जारी है, और इसलिए तुम दोनों के द्वारा अपनी मूल छवि के प्रत्यक्ष स्केलिंग है.
>> यदि ऐसा है तो हम इस बात के लिए pseudocode विस्तार करने के लिए थे, हम फ़ाइल खोलना चाहते हैं.
और फिर यह जानकर कि अगर हम यहाँ वापस जाओ,
हम देखते हैं कि outfile लिए चौड़ाई infile के लिए चौड़ाई से अलग होने जा रहा है.
इसका क्या मतलब है?
इसका मतलब है कि हमारे हेडर सूचना को बदलने जा रहा है.
और इसलिए क्या हम करना चाहते है हैडर जानकारी अपडेट,
जानते हुए भी कि जब हम फाइलों में पढ़ा अगर आप copy.c रूपरेखा पर काम कर रहे हैं,
हम पहले से ही एक चर कि इंगित करता है आकार क्या है और इस तरह बातें है.
तो एक बार आप हैं कि, क्या तुम करना चाहते हो सकता है विशेष रूप से उन चर बदलने के लिए है.
याद रखें, यदि आप एक struct है, कैसे है कि आप के भीतर चर का उपयोग कर रहे हैं.
आप डॉट ऑपरेटर का उपयोग करते हैं, सही?
तो उस का उपयोग कर, आप जानते हैं कि आप हेडर जानकारी बदलने की आवश्यकता होगी.
तो यहाँ सिर्फ वास्तविक तत्व है कि अपनी फ़ाइल में बदलती होने जा रहे हैं की एक सूची है.
फ़ाइल का आकार बदलने, छवि, चौड़ाई और ऊंचाई के रूप में के रूप में अच्छी तरह से जा रहा है.
तो bitmaps के नक्शे के लिए वापस जा रहा,
देखने के लिए कि क्या यह फ़ाइल शीर्षक या जानकारी शीर्षक है कि उस जानकारी शामिल है
और तो बदल के रूप में की जरूरत है.
फिर, सी.पी. copy.c resize.c कहते हैं.
इसका मतलब है कि resize.c अब सब कुछ है कि प्रतिलिपि अंदर निहित है
क्योंकि हमें प्रतिलिपि पिक्सेल द्वारा प्रत्येक scanline पिक्सेल में पढ़ने का एक तरीका प्रदान करता है.
को छोड़कर अब, बजाय सिर्फ मूल्यों को बदलने की तरह हम whodunit में किया था,
हम क्या करना चाहते है हम कई पिक्सल में लिखने के लिए चाहते हैं
के रूप में लंबे समय के रूप के रूप में हमारे n 1 से अधिक है.
>> तो फिर हम क्या करना चाहते है हम इसे n द्वारा क्षैतिज खिंचाव चाहते हैं,
और साथ ही यह खड़ी खिंचाव n द्वारा.
हम यह कैसे कर सकता है?
कहो अपने 2 n है और आप इस दी infile है.
आपका कर्सर पहले एक पर शुरू करने के लिए जा रहा है,
और आप क्या करना चाहते हैं अगर 2 n है, तो आप उन लोगों में से 2 में मुद्रित करना चाहते हैं.
तो आप उन लोगों में से 2 में मुद्रित.
फिर अपने कर्सर अगले पिक्सेल है, जो लाल एक को स्थानांतरित करने के लिए जा रहा है,
और यह करने के लिए बाहर 2 उन लाल वालों के प्रिंट, यह क्या यह पहले किया है पर appending जा रहा है.
तब कर्सर अगले पिक्सेल के लिए ले जाने के लिए और उन में से 2 में आकर्षित करेगा.
यदि आप copy.c रूपरेखा, यह क्या करता है के लिए वापस सही यहाँ देखो
है यह एक आरजीबी, ट्रिपल, एक नए ट्रिपल चर बुलाया की एक नई मिसाल पैदा करता है.
और यहाँ जब यह में पढ़ता है, यह infile RGBTRIPLE 1 से पढ़ता
और यह दुकानों के अंदर कि ट्रिपल चर के.
तो फिर आप वास्तव में एक है कि विशेष रूप से पिक्सेल का प्रतिनिधित्व चर.
तो जब आप लिखते हैं, तुम क्या करना चाहते हो सकता fwrite बयान पाश के लिए एक डिब्बे में बंद है
है कि कई बार के रूप में की जरूरत के रूप में अपने outfile में लिखते हैं.
यह काफी सरल है.
बस मूल रूप से लेखन की प्रक्रिया n बार की संख्या यह क्षैतिज पैमाने दोहराएँ.
>> लेकिन तब हमें याद है कि हमारे padding बदलने जा रहा है.
पहले कहते हैं, हम 3 लंबाई के बारे में कुछ था.
तो हम बस कितना padding में जोड़ना होगा? यह सिर्फ एक और 4 की एक बहु बनाने के लिए.
लेकिन कहते हैं कि हम n = 2 इस विशेष छवि स्केलिंग कर रहे हैं.
तो फिर कैसे कई नीले पिक्सल हम अंत में करना चाहते हैं? हम 6 करना होगा.
1, 2, 3, 4, 5, 6. सही सभी.
6 4 की एक बहु नहीं है. 4 के निकटतम गुणज क्या है? कि 8 होने जा रहा है.
तो हम वास्तव में padding के 2 वर्ण वहाँ जा रहे हैं.
>> क्या किसी को याद है अगर हम को padding की गणना के लिए एक फार्मूला है
और कहा कि जहां हो सकता है?
[अश्राव्य छात्र प्रतिक्रिया] >> copy.c. हाँ, सही है.
Copy.c में एक सूत्र की गणना के लिए आप कितना padding
बिटमैप छवि की एक विशेष चौड़ाई दिया.
तो जा रहा है कि करने के लिए उपयोगी हो सकता है जब आप padding की एक निश्चित मात्रा में जोड़ने की जरूरत है
वास्तव में बाहर आंकड़ा कितना padding आप जोड़ने की जरूरत है.
लेकिन एक नोट, हालांकि यह है कि आप सुनिश्चित करें कि आप सही आकार का उपयोग कर रहे हैं बनाना चाहते हैं.
बस सावधान रहना चाहिए क्योंकि आप मूल रूप से दो बिटमैप छवियों के साथ काम करने जा रहे हैं.
आप सुनिश्चित करें कि आप सही एक का उपयोग कर रहे हैं बनाना चाहते हैं.
जब आप outfile के लिए padding गणना कर रहे हैं, आप outfile की चौड़ाई का उपयोग करना चाहते हैं
और पिछले एक की चौड़ाई नहीं.
>> बढ़िया है. उस तरह एक पूरे बिटमैप छवि क्षैतिज खींच का ख्याल रखता है.
लेकिन वास्तव में हम क्या करना चाहते हैं यह खड़ी है के रूप में अच्छी तरह से खिंचाव.
यह थोड़ा पेचीदा मामला हो सकता है क्योंकि जब हम एक पंक्ति नकल खत्म कर दिया है जा रहा है
और कि पंक्ति लेखन, हमारे कर्सर के अंत में होने जा रहा है.
तो अगर हम फिर से पढ़ा, तो यह सिर्फ अगली पंक्ति में पढ़ा जा रहा है.
तो हम क्या करना चाहते तरह की उन पंक्तियों को फिर से नकल का कोई रास्ता खोजने
या सिर्फ उस पंक्ति ले और फिर इसे फिर से नए सिरे से लिखना की तरह.
जैसा कि मैं एक तरह से करने के लिए alluded, वहाँ कई अलग तरीके से ऐसा कर रहे हैं.
आप क्या कर सकता है के रूप में आप के माध्यम से जा रहे हैं और विशेष scanline के माध्यम से पढ़ने
और यह आवश्यक के रूप में बदल रहा है, तो दुकान की तरह एक सरणी में उन पिक्सल के सभी.
तो फिर तुम पर बाद में पता है कि तुम बाहर है कि सरणी फिर प्रिंट की आवश्यकता होगी,
और इसलिए आप सिर्फ इतना है कि सरणी का उपयोग कर सकते हैं.
एक और तरीका यह करना है आप नीचे एक पंक्ति की नकल कर सकता है,
समझते हैं कि आप है कि फिर से कॉपी करने की जरूरत है, तो वास्तव में आपके कर्सर चाल,
और कहा कि विधि fseek का उपयोग किया जा रहा है.
आप अपने कर्सर सभी तरह वापस स्थानांतरित कर सकता है और फिर नकल की प्रक्रिया को फिर से दोहराने की.
>> तो अगर हमारे स्केलिंग संख्या n है, तो कितनी बार हम वापस जाने के लिए करना होगा
और एक लाइन को फिर से लिखना है? >> [छात्र] n - 1. >> हाँ, सही. n - 1.
हम एक बार पहले से ही यह किया है, तो फिर हम वापस जा रही इस प्रक्रिया को दोहराने के लिए चाहता हूँ
समय की राशि 1 - एन.
ठीक है. तो क्या तुम वहाँ अपने आकार समारोह है.
>> अब हम एक बहुत मजेदार हिस्सा है, मेरी पसंदीदा pset है, जो ठीक है प्राप्त कर सकते हैं.
Bitmaps की बजाय, इस समय हम JPEGs के साथ काम कर रहे हैं.
हम वास्तव में JPEGs का सिर्फ एक फ़ाइल दिया नहीं कर रहे हैं,
हम मूल रूप से एक कच्चे मेमोरी कार्ड प्रारूप दिया हो.
और इसलिए इस जानकारी और कचरा मूल्यों की शुरुआत में एक सा होता है,
और तो यह शुरू होता है और यह JPEG फ़ाइलों का एक गुच्छा है.
हालांकि, हम एक कार्ड हाथ रहे हैं, जहां हम फोटो नष्ट कर दिया है;
अनिवार्य रूप से, हम भूल गए हैं जहाँ फोटो कार्ड के भीतर स्थित हैं.
तो फिर पुनर्प्राप्त में हमारे काम के लिए इस कार्ड प्रारूप के माध्यम से जाना है
और उन चित्रों को फिर से लगता है.
>> सौभाग्य से, JPEG फ़ाइलों और कार्ड फ़ाइल की संरचना एक बिट मददगार है.
यह निश्चित रूप से एक सा trickier हो सकता था अगर यह इस विशेष स्वरूप में नहीं थे.
हर JPEG फ़ाइल वास्तव में दो संभव दृश्यों, ऊपर सूचीबद्ध के साथ शुरू होता है.
असल में, जब भी आप एक नया JPEG फ़ाइल है,
यह या तो ffe0 ffd8 या अन्य एक, ffe1 ffd8 अनुक्रम के साथ शुरू होता है.
एक और उपयोगी बात को पता है कि JPEGs contiguously संग्रहीत कर रहे हैं.
तो जब भी एक JPEG फ़ाइल समाप्त होता है, एक दूसरे को शुरू होता है.
तो वहाँ वहाँ मूल्यों के बीच किसी भी तरह का नहीं है.
एक बार जब आप एक JPEG के शुरू मारा, अगर आप पहले से ही एक JPEG पढ़ कर दिया गया है,
आप जानते हैं कि आप पिछले एक और अगले एक की शुरुआत के अंत मारा है.
>> इस कल्पना की तरह, मैं एक योजनाबद्ध बनाया.
JPEGs के बारे में एक और बात यह है कि हम एक समय में 512 बाइट्स के दृश्यों में उन्हें पढ़ सकते हैं,
इसी तरह के कार्ड की शुरुआत के साथ.
हम हर एक बाइट की जाँच हो सकता है क्योंकि कि चूसना होगा की जरूरत नहीं है.
तो बजाय, हम क्या कर सकते हैं वास्तव में सिर्फ एक बार में 512 बाइट में पढ़ा
और फिर, उन छोटे छोटे स्लाइस में उन लोगों के बीच में जाँच के बजाय,
हम सिर्फ 512 बाइट्स की शुरुआत की जांच कर सकते हैं.
मूलतः, इस चित्र में, क्या तुमने देखा कार्ड की शुरुआत में है,
आप मूल्यों है कि वास्तव में वास्तविक खुद JPEGs के लिए प्रासंगिक नहीं हैं.
लेकिन फिर मैं क्या एक सितारा एक JPEG के लिए दो दृश्यों के शुरू से संकेत मिलता है.
तो जब भी आप एक स्टार को देखने के लिए, आप जानते हैं कि आप एक JPEG फ़ाइल है.
और फिर हर JPEG फ़ाइल 512 बाइट्स के कुछ एकाधिक होने जा रहा है
जरूरी नहीं बल्कि एक ही कई.
तरीका है कि आप जानते हैं कि आप एक और जेपीईजी मारा है अगर आप एक और सितारा मारा,
बाइट्स की एक प्रारंभिक अनुक्रम.
तो तुम यहाँ है क्या है आप लाल JPEG सतत फ़ाइल है जब तक आप एक स्टार मारा,
जो एक नया रंग ने संकेत दिया है.
आप जारी रखने के लिए और फिर आप एक और सितारा मारा, आप एक और जेपीईजी मारा,
आप अंत तक सभी तरह जारी है.
आप पिछली तस्वीर पर यहाँ हो, गुलाबी एक.
आप को समाप्त करने के लिए जाना है जब तक आप फ़ाइल चरित्र के अंत मारा.
यह वास्तव में उपयोगी होने जा रहा है.
>> कुछ यहाँ मुख्य takeaways:
कार्ड फ़ाइल एक JPEG के साथ शुरू नहीं करता है,
लेकिन एक बार एक JPEG शुरू होता है, JPEGs के सभी पक्ष की ओर से एक दूसरे के लिए संग्रहित कर रहे हैं.
>> पुनर्प्राप्त के लिए कुछ pseudocode.
सबसे पहले, हम हमारे कार्ड फ़ाइल खोलने जा रहे हैं,
और कहा कि हमारे फ़ाइल मैं / हे कार्यों का उपयोग किया जा रहा है.
हम निम्नलिखित प्रक्रिया को दोहराने जा रहे हैं जब तक हम फ़ाइल के अंत तक पहुँच है.
हम एक समय में 512 बाइट्स पढ़ने के लिए जा रहे हैं.
और क्या मैं यहाँ कहा है कि हम यह एक बफर में स्टोर करने के लिए जा रहे हैं,
तो बुनियादी तौर पर उन 512 बाइट्स के लिए पर पकड़ जब तक हम जानते हैं कि क्या वास्तव में उनके साथ क्या करना है.
तो फिर हम क्या करना चाहते है हम चाहते हैं कि क्या हम एक सितारा या नहीं मारा है.
यदि हम एक सितारा मारा है, अगर हम शुरू दृश्यों में से एक मारा है,
तो हम जानते हैं कि हम एक नए JPEG फ़ाइल मारा है.
हम क्या करना चाहते है हम करने के लिए हमारे pset4 निर्देशिका में एक नई फ़ाइल बनाने के लिए चाहते करने जा रहे हैं
उस फ़ाइल को बनाने के लिए जारी है.
लेकिन यह भी, अगर हम पहले से ही पहले एक JPEG,
तो हम कि फ़ाइल के अंत और यह pset4 फ़ोल्डर में धक्का चाहते हैं,
हम कहाँ है कि फ़ाइल संग्रहीत क्योंकि अगर हम निर्दिष्ट नहीं करते कि हम उस JPEG फ़ाइल समाप्त हो गया है,
तो हम मूल रूप से एक अनिश्चित राशि होगा. JPEGs कभी खत्म नहीं होगा.
इसलिए हम यह सुनिश्चित करें कि जब हम एक JPEG फ़ाइल में पढ़ रहे हैं और कि लेखन बनाना चाहते हैं,
हम विशेष रूप से है कि बंद के क्रम में करने के लिए अगले एक खोलने के लिए चाहते हैं.
हम कई चीजों की जाँच करने के लिए चाहता हूँ.
हम जाँच करें कि क्या हम अपने बफर के साथ एक नया JPEG के शुरू में हो
और भी अगर हम पहले से ही एक JPEG पाया है पहले
कारण है कि आपकी प्रक्रिया थोड़ा बदल जाएगा.
तो फिर उसके बाद आप सभी तरह के माध्यम से जाने के लिए और आप फ़ाइल के अंत मारा,
तो आप करना चाहती हूँ क्या है आप के लिए सभी फ़ाइलों कि वर्तमान में खुले हैं बंद करने के लिए चाहता हूँ.
यह शायद आखिरी JPEG फ़ाइल है कि आप हो जाएगा,
के रूप में कार्ड फ़ाइल के रूप में अच्छी तरह से है कि आप के साथ काम कर रहा है.
>> अंतिम बाधा है कि हम से निपटने की जरूरत है कि कैसे वास्तव में एक JPEG फ़ाइल बनाने के लिए
और कैसे वास्तव में फ़ोल्डर में इसे धक्का.
pset की आवश्यकता है कि हर JPEG कि आप पाते हैं निम्नलिखित प्रारूप में होना,
आप जहां संख्या है jpg.
संख्या है, यहां तक ​​कि अगर यह 0 है, हम इसे 000.jpg कहते हैं.
जब भी आप अपने प्रोग्राम में खोजने के लिए एक JPEG,
आप जा रहे हैं कि यह पाया गया है क्रम में करने के लिए यह नाम देना चाहते हैं.
इसका क्या मतलब है?
हम कितने हमने पाया है का ट्रैक रखने की तरह करने की जरूरत है
और प्रत्येक JPEG की संख्या क्या होना चाहिए.
यहाँ हम sprintf समारोह का लाभ लेने के लिए जा रहे हैं.
के लिए भी इसी तरह printf, प्रिंट की तरह बस टर्मिनल में एक मूल्य है, जो
sprintf फ़ोल्डर में फ़ाइल बाहर प्रिंट.
और इसलिए यह क्या अगर मैं sprintf शीर्षक था, है, और होता तो वहाँ स्ट्रिंग,
यह बाहर 2.jpg प्रिंट होगा.
यह मानते हुए कि मैं अपनी फ़ाइलों को सही ढंग से बंद कर दिया है,
कि फ़ाइल है कि मैं लिख रहा था शामिल होगा.
लेकिन एक बात है कि कोड है कि मैं यहाँ है
करता है पूरा pset क्या आवश्यकता काफी नहीं है.
pset की आवश्यकता है कि 2 JPEG फ़ाइल 2 के बजाय सिर्फ 002 नाम दिया जाना चाहिए.
तो जब आप बाहर नाम मुद्रित, तो शायद आप प्लेसहोल्डर थोड़ा बदल करना चाहते हो सकता है.
>> क्या किसी को याद है कि हम अतिरिक्त रिक्त स्थान के लिए अनुमति देते हैं जब हम कुछ प्रिंट?
हाँ. >> [छात्र] प्रतिशत चिह्न और 2 के बीच एक 3 डाल दिया. >> हाँ, सही.
आप इस मामले में एक 3 रखा है क्योंकि हम 3 के लिए अंतरिक्ष चाहते.
% 3d शायद आप के बजाय 002.jpg 2 देना होगा.
sprintf समारोह में पहला तर्क वास्तव में एक चार सरणी है,
जो हम पहले तार के रूप में जानता था.
उन होगा, एक अस्थायी भंडारण की तरह अधिक की तरह, सिर्फ परिणामी स्ट्रिंग की दुकान.
तुम सच में इस के साथ काम नहीं कर जाएगा, लेकिन आप इसे शामिल करने की जरूरत है.
>> यह जानते हुए भी कि हर फ़ाइल नाम संख्या है, जो तीन अक्षर लेता है,
और फिर jpg, कितनी देर तक इस सरणी होना चाहिए?
बाहर संख्या फेंको. शीर्षक में कितने नाम में, वर्ण?
तो वहाँ 3 hashtags, अवधि, jpg है. >> [छात्र] 7. 7. >> काफी नहीं है.
हम 8 चाहते करने जा रहे हैं क्योंकि हम के रूप में अच्छी तरह से अशक्त टर्मिनेटर के लिए अनुमति देना चाहते हैं.
>> अंत में, बस प्रक्रिया है कि आप ठीक करने के लिए कर रही हो जाएगा आकर्षित करने,
तुम कुछ शुरुआत जानकारी है.
आप जारी रख सकते हैं जब तक आप एक JPEG फ़ाइल की शुरुआत पाते हैं,
और कहा कि या तो दो शुरूआती दृश्यों के एक हो सकता है.
आप पढ़ने पर रखने के लिए. हर यहाँ स्लेश 512 बाइट्स का प्रतिनिधित्व करता है.
आप पढ़ने पर रहते हैं, जब तक आप एक प्रारंभिक अनुक्रम मुठभेड़ पढ़ने पर रहते हैं.
एक बार जब आपको लगता है कि आप वर्तमान JPEG अंत - इस मामले में, यह एक लाल,
तो आपको लगता है कि खत्म करना चाहते हो.
आप sprintf अपने pset4 फ़ोल्डर में उस के नाम करने के लिए करना चाहते हैं,
तो आप के लिए एक नया JPEG खोलने और फिर पढ़ने पर रखना चाहते हैं
जब तक आप अगले मुठभेड़.
पढ़ने पर रखें, पढ़ने पर रहते हैं,
और फिर अंत में, अंततः, आप फ़ाइल के अंत तक पहुँचने के लिए जा रहे हैं,
और इसलिए आप पिछले JPEG बंद करना चाहते हैं कि आप के साथ काम कर रहे थे,
sprintf कि अपने pset4 फ़ोल्डर में, और फिर सभी चित्रों का है कि तुम मिल गया है पर देखो.
उन चित्रों को वास्तव में कर रहे हैं CS50 कर्मचारियों की तस्वीरें,
और तो यह है जहां pset के बोनस मज़ा हिस्से में आता है
यह है कि आप अपने वर्गों में प्रतिस्पर्धा कर रहे हैं चित्रों में TFS
और उनके साथ तस्वीरें लेने के लिए साबित करने के लिए है कि आप pset किया है
और इसलिए आप देख सकते हैं जो स्टाफ के सदस्यों तस्वीरों में हैं.
तो फिर तुम कर्मचारियों के साथ तस्वीरें ले लो. कभी कभी आप उन्हें नीचे का पीछा करना होगा.
शायद उनमें से कुछ के लिए आप से दूर चलाने के लिए कोशिश करेंगे.
आप उन लोगों के साथ तस्वीरें ले लो.
यह चल रही है. यह कारण जब pset कारण है नहीं है.
समय सीमा तय की कल्पना में घोषणा की जाएगी.
अपने अनुभाग के साथ एक साथ फिर, अनुभाग जो भी सबसे अधिक तस्वीरें लेता है
सबसे स्टाफ के सदस्यों के साथ एक बहुत भयानक पुरस्कार जीत जाएगा.
यह प्रोत्साहन की तरह अपने pset4 यथासंभव जल्दी समाप्त
क्योंकि तब आप नीचे कारोबार करने के लिए मिल सकता है
सब अलग अलग CS50 स्टाफ के सदस्यों के नीचे शिकार.
यह अनिवार्य नहीं है, हालांकि, तो एक बार आप चित्र प्राप्त करने,
तो आप pset4 के साथ खत्म हो रहे हैं.
>> और मैं 4 Walkthrough के साथ समाप्त कर रहा हूँ, तो आप आने के लिए सभी को धन्यवाद.
Forensics के साथ गुड लक. [वाहवाही]
[CS50.TV]