1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Walkthrough - समस्या सेट 4]

2
00:00:02,700 --> 00:00:05,000
[Zamyla चान - हार्वर्ड विश्वविद्यालय]

3
00:00:05,000 --> 00:00:07,340
[यह CS50 है. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
सही सभी. सबको नमस्ते, और 4 Walkthrough के लिए आपका स्वागत है.

5
00:00:11,670 --> 00:00:14,270
>> आज हमारे pset Forensics है.

6
00:00:14,270 --> 00:00:18,080
Forensics एक सच में मज़ा pset है कि बिटमैप फाइलों के साथ काम करना शामिल है

7
00:00:18,080 --> 00:00:21,550
पता चलता है जो एक अपराध है.

8
00:00:21,550 --> 00:00:24,200
तो फिर हम कुछ बिटमैप फाइलों का आकार करने के लिए जा रहे हैं,

9
00:00:24,200 --> 00:00:27,780
तो हम भी एक सच में मज़ा पुनर्प्राप्त बुलाया भाग के साथ सौदा करने के लिए जा रहे हैं,

10
00:00:27,780 --> 00:00:31,160
जिसमें हम मूल रूप से एक स्मृति कार्ड हाथ कर रहे हैं

11
00:00:31,160 --> 00:00:34,350
जिसमें किसी को गलती से उनके फ़ाइलों के सभी नष्ट कर दिया गया है,

12
00:00:34,350 --> 00:00:38,860
और हम उन फ़ाइलों को ठीक करने के लिए कहा हो.

13
00:00:38,860 --> 00:00:42,910
>> लेकिन पहले, पहले हम pset में मिलता है, मैं वास्तव में हर किसी को बधाई देता हूं करना चाहते हैं.

14
00:00:42,910 --> 00:00:45,230
हम इस पाठ्यक्रम के मध्य में कर रहे हैं के बारे में.

15
00:00:45,230 --> 00:00:50,070
प्रश्नोत्तरी 0 हमारे पीछे है, और हम pset4 में कर रहे हैं, इसलिए अनिवार्य रूप से, हम आधे रास्ते से कर रहे हैं.

16
00:00:50,070 --> 00:00:55,490
हम एक लंबा रास्ता तय किया है कि अगर आप अपने psets, pset0 और pset1 वापस देखो,

17
00:00:55,490 --> 00:00:57,300
तो अपने आप को उस के बारे में बधाई,

18
00:00:57,300 --> 00:01:00,760
और हम कुछ सच में मज़ा सामान में मिल जा रहे हैं.

19
00:01:00,760 --> 00:01:07,070
>> तो इस pset लिए हमारे toolbox, फिर से, बजाय sudo अद्यतन yum-y चलाने की,

20
00:01:07,070 --> 00:01:13,890
हम सिर्फ update50 चलाने के लिए सक्षम हो अगर आप 17.3 संस्करण और उपकरण के ऊपर हो.

21
00:01:13,890 --> 00:01:17,380
तो लिए update50 चलाने के लिए सुनिश्चित हो - यह एक बहुत आसान है, कुछ कम वर्ण -

22
00:01:17,380 --> 00:01:20,640
को यकीन है कि आप उपकरण के नवीनतम संस्करण में हैं.

23
00:01:20,640 --> 00:01:25,410
विशेष रूप से यह update50 के लिए महत्वपूर्ण है जब हम CS50 जाँचें का उपयोग शुरू.

24
00:01:25,410 --> 00:01:28,700
तो यकीन है कि आपको लगता है कि.

25
00:01:28,700 --> 00:01:30,760
>> इस pset के लिए सभी वर्गों के लिए,

26
00:01:30,760 --> 00:01:34,350
फ़ाइल हम फ़ाइल निविष्टियाँ और outputs के साथ काम करने जा रहे हैं, मैं / ओ

27
00:01:34,350 --> 00:01:38,140
हम प्रोग्राम है कि arrays के साथ सौदा की एक बहुत ऊपर जा रहा हो जा रहे हैं

28
00:01:38,140 --> 00:01:40,350
फ़ाइलें और इस तरह बातें की ओर इशारा करते हैं,

29
00:01:40,350 --> 00:01:43,050
इसलिए हम यकीन है कि हम वास्तव में परिचित और आराम कर रहे हैं बनाना चाहते हैं

30
00:01:43,050 --> 00:01:47,990
कैसे और फ़ाइलों में इनपुट, आउटपुट के साथ काम कर रहे हैं.

31
00:01:47,990 --> 00:01:52,080
>> इस pset लिए वितरण कोड एक copy.c नामक एक फाइल है,

32
00:01:52,080 --> 00:01:55,280
और है कि हम को खोजने के लिए जा रहे हैं कि क्या वास्तव में हमारे लिए उपयोगी होने जा रहा है

33
00:01:55,280 --> 00:02:00,340
क्योंकि हम को समाप्त करने के लिए जा रहे हैं वास्तव में copy.c फाइल कॉपी

34
00:02:00,340 --> 00:02:05,350
और सिर्फ यह फेरबदल थोड़ा समस्या सेट के पहले 2 भागों को प्राप्त करने में सक्षम हो.

35
00:02:05,350 --> 00:02:09,030
>> और इतना तो जैसा कि मैंने पहले उल्लेख किया है, हम के रूप में के रूप में अच्छी तरह से bitmaps JPEGs के साथ काम कर रहे हैं.

36
00:02:09,030 --> 00:02:13,170
तो सच में कैसे उन फ़ाइलों का आयोजन कर रहे हैं की संरचना को समझने,

37
00:02:13,170 --> 00:02:16,170
हम वास्तव में कैसे 0s और structs में 1s अनुवाद कर सकते हैं

38
00:02:16,170 --> 00:02:19,040
और बातें है कि हम वास्तव में समझ और व्याख्या कर सकते हैं और संपादित करें,

39
00:02:19,040 --> 00:02:21,000
कि वास्तव में महत्वपूर्ण होगा,

40
00:02:21,000 --> 00:02:25,970
तो JPEG और बिटमैप फ़ाइलों में जा रहा है और उन की संरचना को समझने.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, हमेशा की तरह सवालों के एक खंड के साथ शुरू होता है.

42
00:02:30,780 --> 00:02:36,600
उन मैं / हे फ़ाइल के साथ निपटने के लिए और आपको लगता है कि के आदी हो जाएगा.

43
00:02:36,600 --> 00:02:42,520
फिर 1 भाग whodunit है, जिसमें आप एक बिटमैप फ़ाइल दिया हो

44
00:02:42,520 --> 00:02:45,630
कि लाल डॉट्स की तरह तरह की सब से अधिक लग रहा है.

45
00:02:45,630 --> 00:02:52,180
और फिर मूल रूप से हम क्या करने जा रहे है इस फ़ाइल ले और बस यह थोड़ा संपादित

46
00:02:52,180 --> 00:02:54,010
में एक संस्करण है कि हम पढ़ सकते हैं.

47
00:02:54,010 --> 00:02:56,000
मूलतः, एक बार हम खत्म, हम एक ही फाइल करना होगा,

48
00:02:56,000 --> 00:03:02,630
को छोड़कर हम छिपा उन सभी लाल डॉट्स द्वारा छिपा संदेश को देखने में सक्षम हो जाएगा.

49
00:03:02,630 --> 00:03:07,310
फिर आकार बदला जा सकने वाला एक प्रोग्राम है कि एक फ़ाइल दिया है

50
00:03:07,310 --> 00:03:11,490
और फिर फ़ाइल outputs है कि यह नाम दिया और फिर एक संख्या के रूप में अच्छी तरह से दिया है,

51
00:03:11,490 --> 00:03:16,850
वास्तव में है कि पूर्णांक मान द्वारा कि बिटमैप आकार जाएगा.

52
00:03:16,850 --> 00:03:19,240
तो अंत में, हम ठीक pset है.

53
00:03:19,240 --> 00:03:24,160
हम एक स्मृति कार्ड दिया जाता है और फिर तस्वीरों के सभी ठीक

54
00:03:24,160 --> 00:03:25,920
कि गलती से हटा दिया गया है,

55
00:03:25,920 --> 00:03:31,420
लेकिन, जैसा कि हम सीख जाओगे नष्ट कर दिया है, और नहीं वास्तव में फाइल से हटा दिया;

56
00:03:31,420 --> 00:03:38,470
जहां वे फ़ाइल में थे हम बस की तरह खो दिया है, लेकिन हम चाहते हैं कि ठीक जा रहे हैं.

57
00:03:38,470 --> 00:03:44,950
>> बढ़िया है. तो फ़ाइल में जा रहा मैं / हे विशेष रूप से, इन कार्यों की एक पूरी सूची है कि आप का उपयोग किया जाएगा.

58
00:03:44,950 --> 00:03:49,840
आप पहले से ही एक छोटा सा fopen की मूल बातें, fread और fwrite देखा है,

59
00:03:49,840 --> 00:03:54,350
लेकिन हम कुछ फ़ाइल में आगे देखने के लिए जा रहे हैं मैं / हे fputc के रूप में कार्य,

60
00:03:54,350 --> 00:03:56,930
जिसमें आप एक बार में सिर्फ एक चरित्र लिखने,

61
00:03:56,930 --> 00:04:02,000
fseek, जहाँ आप फ़ाइल की स्थिति सूचक आगे और पीछे की ओर ले जाने की तरह,

62
00:04:02,000 --> 00:04:05,770
और फिर कुछ दूसरों. लेकिन हम उस में pset दौरान थोड़ा बाद में जाना होगा.

63
00:04:08,050 --> 00:04:13,100
>> तो पहले, बस फाइल में पाने के लिए मैं / हे पहले हम pset में जाना,

64
00:04:13,100 --> 00:04:19,860
एक फ़ाइल खोलने के लिए, उदाहरण के लिए, तुम्हें क्या करना है क्या वास्तव में उस फाइल करने के लिए एक सूचक सेट कर दिया जाता है.

65
00:04:19,860 --> 00:04:22,710
तो हम एक फ़ाइल * सूचक है.

66
00:04:22,710 --> 00:04:27,140
इस मामले में, मैं इसे एक सूचक में बुला रहा हूँ क्योंकि मेरे infile होने जा रहा है.

67
00:04:27,140 --> 00:04:33,340
और इसलिए मैं समारोह और फिर फ़ाइल का नाम fopen का उपयोग करने के लिए जा रहा हूँ

68
00:04:33,340 --> 00:04:36,360
और फिर मोड में जो मैं जा रहा हूँ फ़ाइल के साथ काम करने के लिए.

69
00:04:36,360 --> 00:04:42,080
तो वहाँ पढ़ने के लिए इस मामले में, "r" "w" लिखने के लिए, और फिर appending के लिए "एक" है.

70
00:04:42,080 --> 00:04:44,270
उदाहरण के लिए, आप एक infile के साथ जब काम कर रहे हैं

71
00:04:44,270 --> 00:04:47,310
और आप सब करना चाहते हैं बिट्स और बाइट्स में संग्रहीत पढ़ा है,

72
00:04:47,310 --> 00:04:50,420
तो आप शायद करने के लिए उपयोग करना चाहते हैं अपनी विधा के रूप में "r" के लिए जा रहे हैं.

73
00:04:50,420 --> 00:04:54,520
जब आप वास्तव में लिखने के लिए चाहते हैं, इस तरह की एक नई फ़ाइल बनाने,

74
00:04:54,520 --> 00:04:57,220
तो हम क्या करने जा रहे हैं कि क्या हम नई फ़ाइल खोलने के लिए जा रहे हैं

75
00:04:57,220 --> 00:05:02,410
और लिखने के लिए "w" मोड का उपयोग करें.

76
00:05:02,410 --> 00:05:07,540
>> तो जब आप वास्तव में फ़ाइलों में पढ़ रहे हैं, संरचना इस प्रकार है.

77
00:05:07,540 --> 00:05:14,930
पहले आप struct कि बाइट्स है कि आप पढ़ रहे हैं शामिल होंगे सूचक शामिल हैं.

78
00:05:14,930 --> 00:05:19,830
तो यह है कि बाइट्स है कि आप पढ़ रहे हैं के अंत स्थान होने जा रहा है.

79
00:05:19,830 --> 00:05:23,360
फिर आप को आकार का संकेत करने के लिए जा रहे हैं, मूल रूप से कितने बाइट्स

80
00:05:23,360 --> 00:05:30,100
अपने कार्यक्रम के लिए फाइल करने के लिए पढ़ा है, आकार मूल रूप से एक तत्व है,

81
00:05:30,100 --> 00:05:32,620
और फिर आप यह निर्दिष्ट करने के लिए आप पढ़ना चाहते हैं कि कितने तत्वों के लिए जा रहे हैं.

82
00:05:32,620 --> 00:05:34,980
और फिर अंत में, आप जानते हैं कि तुम कहाँ से पढ़ रहे हैं,

83
00:05:34,980 --> 00:05:37,580
इतना है कि अपने में सूचक होने जा रहा है.

84
00:05:37,580 --> 00:05:41,780
मैं इन रंग कोडित क्योंकि fread भी बहुत fwrite करने के लिए इसी तरह की है,

85
00:05:41,780 --> 00:05:47,050
आप यह सुनिश्चित करें कि आप सही क्रम का उपयोग बनाना चाहते हैं, को छोड़कर

86
00:05:47,050 --> 00:05:51,960
सुनिश्चित करें कि आप वास्तव में लिख रहे हैं या सही फ़ाइल से पढ़ने.

87
00:05:54,910 --> 00:05:58,610
>> तो जैसा कि पहले, अगर हम तत्व के आकार के रूप में के रूप में अच्छी तरह से तत्वों की संख्या है,

88
00:05:58,610 --> 00:06:00,600
तो हम यहाँ के आसपास एक छोटा सा खेल सकते हैं.

89
00:06:00,600 --> 00:06:06,810
कहते हैं कि मैं एक कुत्ता struct है और यदि ऐसा है तो फिर मैं एक समय में दो कुत्तों को पढ़ने के लिए चाहते हैं.

90
00:06:06,810 --> 00:06:12,450
मैं क्या कर सकता है एक तत्व के आकार का कहना है कि एक कुत्ते के आकार का होने जा रहा है

91
00:06:12,450 --> 00:06:14,770
और मैं वास्तव में उनमें से दो को पढ़ने के लिए जा रहा हूँ.

92
00:06:14,770 --> 00:06:18,290
वैकल्पिक रूप से, मैं क्या कर सकता है का कहना है कि मैं सिर्फ एक तत्व को पढ़ने के लिए जा रहा हूँ

93
00:06:18,290 --> 00:06:21,340
और कि एक तत्व के लिए दो कुत्तों के आकार का होने जा रहा है.

94
00:06:21,340 --> 00:06:24,320
तो यह है कि अनुरूप है आप कर सकते हैं कैसे आकार और संख्या के साथ खेलने के आसपास तरह

95
00:06:24,320 --> 00:06:28,250
क्या आप के लिए सहज है पर निर्भर करता है.

96
00:06:28,250 --> 00:06:30,810
>> सही सभी. तो अब हम लेखन फाइल करने के लिए मिलता है.

97
00:06:30,810 --> 00:06:36,880
जब आप एक फ़ाइल लिखना चाहते हैं, पहले तर्क वास्तव में तुम कहाँ से पढ़ रहे हैं.

98
00:06:36,880 --> 00:06:42,050
तो यह है कि मूल रूप से डेटा है कि आप फ़ाइल में लिखने के लिए जा रहे हैं,

99
00:06:42,050 --> 00:06:44,490
जो अंत में बाहर सूचक है.

100
00:06:44,490 --> 00:06:47,670
तो जब आप pset के साथ काम कर रहे हैं, तो सुनिश्चित करें कि आप उलझन में नहीं मिलता.

101
00:06:47,670 --> 00:06:50,480
शायद पक्ष द्वारा परिभाषा की ओर है.

102
00:06:50,480 --> 00:06:58,090
आप परिभाषाओं के मैनुअल में खींच आदमी को टाइप करके और फिर fwrite उदाहरण के लिए,

103
00:06:58,090 --> 00:06:59,950
टर्मिनल में, या आप इस स्लाइड पर वापस उल्लेख कर सकते हैं

104
00:06:59,950 --> 00:07:03,570
और सुनिश्चित करें कि आप सही एक का उपयोग कर रहे हैं.

105
00:07:03,570 --> 00:07:08,700
तो फिर, fwrite के लिए, जब आप एक फ़ाइल है कि आप में लिखना चाहते हैं,

106
00:07:08,700 --> 00:07:14,290
कि अंतिम बहस होने जा रहा है और कहा कि कि फाइल करने के लिए एक सूचक होने जा रहा है.

107
00:07:14,290 --> 00:07:18,670
तो है कि कैसे हम शायद एक समय में कई बाइट्स लिखने के साथ सौदा,

108
00:07:18,670 --> 00:07:21,820
लेकिन कहते हैं कि आप सिर्फ एक ही चरित्र में लिखने के लिए चाहते हैं.

109
00:07:21,820 --> 00:07:25,940
जैसा कि हम बाद में इस उदाहरण में देखेंगे, बिटमैप में हम का उपयोग करना होगा.

110
00:07:25,940 --> 00:07:32,180
यही कारण है कि जब हम fputc का उपयोग कर सकते हैं, अनिवार्य रूप से सिर्फ एक समय में एक चरित्र डाल, chr,

111
00:07:32,180 --> 00:07:37,050
कि फ़ाइल सूचक में, और हमारे बाहर वहाँ सूचक.

112
00:07:38,700 --> 00:07:41,560
तो जब भी हम चाहते हैं या एक फ़ाइल में लिखने के लिए,

113
00:07:41,560 --> 00:07:44,690
फ़ाइल जहाँ हम कर रहे हैं की नज़र रखे हुए है.

114
00:07:44,690 --> 00:07:47,810
तो यह कर्सर, फ़ाइल स्थिति सूचक का एक प्रकार है.

115
00:07:47,810 --> 00:07:54,330
और इसलिए जब भी हम लिखने या एक फ़ाइल में फिर से पढ़ा,

116
00:07:54,330 --> 00:07:56,760
फ़ाइल वास्तव में याद है जहां यह है,

117
00:07:56,760 --> 00:07:59,270
और इसलिए यह जहां कर्सर है से जारी है.

118
00:07:59,270 --> 00:08:03,970
यह फायदेमंद हो सकता है जब आप चाहते हैं कर सकते हैं, कहते हैं, एक निश्चित मात्रा में पढ़ने के लिए कुछ करना

119
00:08:03,970 --> 00:08:06,160
और उसके बाद निम्न राशि में पढ़ा,

120
00:08:06,160 --> 00:08:10,700
लेकिन कभी कभी हम एक निश्चित संदर्भ मूल्य से शुरू करने के लिए वापस आ गया है या वास्तव में जाना चाहते हो सकता है.

121
00:08:10,700 --> 00:08:16,870
तो fseek समारोह, यह क्या करता है हमें एक निश्चित फ़ाइल में कर्सर को स्थानांतरित करने की अनुमति देता है

122
00:08:16,870 --> 00:08:19,680
बाइट्स की एक निश्चित संख्या है.

123
00:08:19,680 --> 00:08:24,260
और फिर हमें क्या करना है क्या निर्दिष्ट जहां संदर्भ मूल्य है.

124
00:08:24,260 --> 00:08:31,520
तो या तो यह जहां कर्सर वर्तमान में है से आगे या पीछे की ओर ले जाता है,

125
00:08:31,520 --> 00:08:35,750
या हम निर्दिष्ट कर सकते हैं कि यह सिर्फ फ़ाइल की शुरुआत से में बढ़ना चाहिए

126
00:08:35,750 --> 00:08:37,090
या फ़ाइल के अंत से.

127
00:08:37,090 --> 00:08:41,230
और इसलिए आप नकारात्मक या सकारात्मक मूल्यों में राशि को पारित कर सकते हैं,

128
00:08:41,230 --> 00:08:44,960
और उस तरह के कर्सर या तो आगे या पीछे की ओर कदम होगा.

129
00:08:46,170 --> 00:08:51,920
>> इससे पहले कि हम अन्य psets में मिलता है, फाइल पर किसी भी सवाल मैं / हे?

130
00:08:53,860 --> 00:08:59,990
ठीक है. जैसा कि हम और अधिक उदाहरण में मिलता है, मुझे प्रश्नों के लिए रोकने के लिए स्वतंत्र महसूस हो रहा है.

131
00:08:59,990 --> 00:09:06,930
>> तो whodunit में, आप एक बिटमैप स्लाइड पर इस लाल एक समान फ़ाइल हाथ कर रहे हैं,

132
00:09:06,930 --> 00:09:14,510
और यह इस तरह लग रहा है - लाल डॉट्स का एक गुच्छा और आप वास्तव में क्या लिखा है पता नहीं है.

133
00:09:14,510 --> 00:09:23,310
अगर आप भेंगा, आप बीच के अंदर एक मामूली नीले रंग देखने के लिए सक्षम हो सकता है.

134
00:09:23,310 --> 00:09:26,270
मूलतः, कि जहां पाठ संग्रहीत किया जाता है.

135
00:09:26,270 --> 00:09:30,270
एक हत्या है कि क्या हुआ था, और हम पता लगाने के लिए जो यह किया है की जरूरत है.

136
00:09:30,270 --> 00:09:36,760
आदेश में कहा कि, हम एक पठनीय प्रारूप में इस छवि को बदलने की तरह करने की जरूरत है.

137
00:09:36,760 --> 00:09:42,740
अगर आप लोग कभी भी इस का सामना करना पड़ा है, कभी कभी थोड़ा किट होगा

138
00:09:42,740 --> 00:09:48,510
जहां आप एक लाल फिल्म के साथ एक आवर्धक कांच करना होगा. कोई है? हाँ.

139
00:09:48,510 --> 00:09:52,770
तो तुम इस तरह हाथ कुछ होगा, तुम एक आवर्धक कांच

140
00:09:52,770 --> 00:09:58,130
पर लाल फिल्म के साथ, आप यह छवि पर रखा जाएगा,

141
00:09:58,130 --> 00:10:03,410
और आप को देखने के संदेश उसमें छिपा करने में सक्षम होगा.

142
00:10:03,410 --> 00:10:07,080
हम लाल फिल्म के साथ एक आवर्धक कांच की जरूरत नहीं है, तो बजाय हम तरह हमारे अपने बनाने के लिए जा रहे हैं

143
00:10:07,080 --> 00:10:09,060
इस pset में.

144
00:10:09,060 --> 00:10:15,760
और तो उपयोगकर्ता इनपुट whodunit, तो सुराग के लिए जा रहा है, BMP,

145
00:10:15,760 --> 00:10:18,800
इतना है कि infile, कि लाल बिंदी संदेश है,

146
00:10:18,800 --> 00:10:23,550
और फिर वे कह रहे हैं verdict.bmp हमारे outfile होने जा रहा है.

147
00:10:23,550 --> 00:10:27,900
तो यह एक नया बिटमैप एक सुराग के लिए इसी तरह की छवि बनाने के लिए जा रहा है

148
00:10:27,900 --> 00:10:32,600
एक पठनीय प्रारूप में छोड़कर जहाँ हम छिपा संदेश देख सकते हैं.

149
00:10:32,600 --> 00:10:37,550
>> चूंकि हम कुछ प्रकार के bitmaps संपादन और छेड़खानी के साथ काम कर जा रहे हैं,

150
00:10:37,550 --> 00:10:42,400
हम इन बिटमैप फ़ाइलों की संरचना में गोता की तरह करने के लिए जा रहे हैं.

151
00:10:42,400 --> 00:10:48,130
हम व्याख्यान में ये एक छोटा सा पर चला गया है, लेकिन हम उन्हें कुछ और अधिक लग रही है.

152
00:10:48,130 --> 00:10:51,740
बिटमैप्स अनिवार्य रूप से सिर्फ बाइट्स की व्यवस्था कर रहे हैं

153
00:10:51,740 --> 00:10:55,790
बाइट्स जहां हम निर्दिष्ट किया है जो क्या मतलब है.

154
00:10:55,790 --> 00:11:00,540
तो यहाँ बिटमैप छवि का एक नक्शा की तरह की तरह है

155
00:11:00,540 --> 00:11:08,550
कह रही है कि यह कुछ हेडर फाइल के साथ शुरू होता है, वहाँ में कुछ जानकारी के साथ शुरू होता है.

156
00:11:08,550 --> 00:11:16,540
आप देखते हैं कि आकार के बारे में बाइट 14 नंबर पर बिटमैप छवि का संकेत दिया है,

157
00:11:16,540 --> 00:11:18,520
और यह जारी है.

158
00:11:18,520 --> 00:11:23,810
लेकिन तब क्या हम वास्तव में यहाँ में रुचि रखते हैं बाइट संख्या 54 के आसपास शुरू होता है.

159
00:11:23,810 --> 00:11:26,060
हम इन आरजीबी triples है.

160
00:11:26,060 --> 00:11:30,760
क्या करने जा रहा है वास्तविक पिक्सल, रंग मूल्यों होते है.

161
00:11:30,760 --> 00:11:35,950
शीर्ष लेख में है कि ऊपर सब कुछ जानकारी है

162
00:11:35,950 --> 00:11:41,240
छवि, छवि की चौड़ाई और ऊंचाई के आकार के अनुरूप.

163
00:11:41,240 --> 00:11:44,930
जब हम padding में जाने पर बाद में, हम देखेंगे क्यों छवि का आकार

164
00:11:44,930 --> 00:11:48,670
चौड़ाई या ऊंचाई से अलग हो सकता है.

165
00:11:48,670 --> 00:11:54,240
तो फिर इन का प्रतिनिधित्व करने के लिए इन बिटमैप छवियों बाइट्स के दृश्यों हैं -

166
00:11:54,240 --> 00:11:59,370
हम क्या कर सकता है ठीक कहना है, मैं याद करने के लिए जा रहा है कि सूचकांक में 14,

167
00:11:59,370 --> 00:12:03,380
कि जहां आकार उदाहरण के लिए है, है, लेकिन इसके बजाय हम क्या करने के लिए यह आसान बनाने के लिए करने जा रहे हैं

168
00:12:03,380 --> 00:12:06,020
यह एक struct में encapsulate.

169
00:12:06,020 --> 00:12:08,880
और इसलिए हम दो हमारे लिए बनाया structs, एक BITMAPFILEHEADER है

170
00:12:08,880 --> 00:12:10,440
और एक BITMAPINFOHEADER,

171
00:12:10,440 --> 00:12:14,840
और इसलिए जब भी हम उस फ़ाइल में पढ़ा है, डिफ़ॉल्ट रूप से यह करने के क्रम में जा रहा है,

172
00:12:14,840 --> 00:12:22,360
और तो क्रम में यह भी ऐसे biWidth और biSize के रूप में चर में में भरने जा रहा है.

173
00:12:25,270 --> 00:12:31,230
और फिर अंत में, हर पिक्सेल तीन बाइट्स द्वारा प्रतिनिधित्व किया है.

174
00:12:31,230 --> 00:12:35,500
1 एक पिक्सेल में नीले रंग की राशि है, 2 हरे रंग की राशि है,

175
00:12:35,500 --> 00:12:41,120
और अंत में, लाल, जहां 0 अनिवार्य रूप से कोई नीली या कोई हरा है की राशि या कोई लाल

176
00:12:41,120 --> 00:12:43,720
और फिर एफएफ अधिकतम मूल्य है.

177
00:12:43,720 --> 00:12:46,800
हेक्साडेसिमल मान रहे हैं.

178
00:12:46,800 --> 00:12:53,870
तो अगर हम FF0000 है, तो यह है कि नीले रंग की अधिकतम राशि से मेल खाती है

179
00:12:53,870 --> 00:12:58,890
और फिर हरे और कोई लाल, कोई ऐसा है तो है कि हमें एक नीले पिक्सेल देना होगा.

180
00:12:58,890 --> 00:13:04,190
तो अगर हम बोर्ड भर एफएफ सब है, तो इसका मतलब है कि हम एक सफेद पिक्सेल है.

181
00:13:04,190 --> 00:13:11,370
यह आम तौर पर करने के लिए विपरीत की तरह है जब हम आरजीबी का कहना है. यह वास्तव में बीजीआर जा रहा है.

182
00:13:12,750 --> 00:13:18,990
>> इसलिए यदि हम वास्तव में एक बिटमैप छवि का एक उदाहरण में देखो - मुझे एक यहाँ खींच कर.

183
00:13:31,560 --> 00:13:33,830
यह एक छोटे से छोटा है.

184
00:13:39,890 --> 00:13:47,840
मैं में zooming रहा हूँ, और हम देख सकते हैं कि यह pixelated है. यह रंग के ब्लॉक की तरह लग रहा है.

185
00:13:47,840 --> 00:13:50,110
आप सफेद ब्लॉकों के लिए और फिर लाल ब्लॉक है.

186
00:13:50,110 --> 00:13:53,700
यदि आप माइक्रोसॉफ्ट पेंट में खेलते हैं, उदाहरण के लिए, आप ऐसा कुछ कर सकता है

187
00:13:53,700 --> 00:13:58,960
द्वारा मूल रूप से सिर्फ एक विशिष्ट क्रम में कुछ वर्गों चित्र.

188
00:13:58,960 --> 00:14:08,060
तो फिर इस अनुवाद बिटमैप में क्या है इस प्रकार है.

189
00:14:08,060 --> 00:14:15,710
यहाँ हम पहले सफेद पिक्सल है, कि सभी 6 च कर रहे हैं, और फिर हम लाल पिक्सल है,

190
00:14:15,710 --> 00:14:19,910
0000ff द्वारा संकेत दिया.

191
00:14:19,910 --> 00:14:27,940
और इसलिए है कि हम बाइट्स की अनुक्रम से संकेत मिलता है कि बिटमैप छवि को देखने के लिए जा रहा है.

192
00:14:27,940 --> 00:14:32,230
तो क्या मैं यहाँ किया है सिर्फ उन सभी बाइट्स लिखा है और फिर लाल रंग में रंग

193
00:14:32,230 --> 00:14:37,550
इतना है कि आप की तरह देख सकते हैं, यदि आप एक छोटा सा भेंगापन, कैसे उस तरह एक Smiley चेहरा इंगित करता है.

194
00:14:40,180 --> 00:14:46,390
>> तरीका है कि बिटमैप छवियों काम मैं यह मूल रूप से एक ग्रिड के रूप में कल्पना.

195
00:14:46,390 --> 00:14:54,940
और डिफ़ॉल्ट रूप से ऐसा ग्रिड की हर पंक्ति 4 बाइट्स की एक बहु है.

196
00:15:00,520 --> 00:15:07,060
अगर हम एक बिटमैप छवि को देखो, आप हर मूल्य में भर रहे हैं.

197
00:15:07,060 --> 00:15:17,370
उदाहरण के लिए, आप एक लाल यहाँ है, हो सकता है यहाँ एक हरे रंग की, यहाँ एक नीले,

198
00:15:17,370 --> 00:15:24,950
लेकिन आप यकीन है कि छवि में चार बाइट्स की एक बहु के साथ भरा है.

199
00:15:24,950 --> 00:15:32,200
तो अगर मैं अपने तीन ब्लॉकों चौड़ा छवि चाहते हैं, तो मैं एक खाली मूल्य डाल करना होगा

200
00:15:32,200 --> 00:15:35,640
यह पिछले एक में चार की एक बहु बनाने के लिए.

201
00:15:35,640 --> 00:15:39,530
तो फिर मैं कुछ है जो हम padding बुला रहे हैं में जोड़ना होगा.

202
00:15:39,530 --> 00:15:43,750
मैं सिर्फ एक एक्स के साथ संकेत मिलता है कि वहाँ के लिए जा रहा हूँ.

203
00:15:44,920 --> 00:15:54,160
अब कहते हैं कि हम एक छवि है कि 7 पिक्सल लंबा है, उदाहरण के लिए करना चाहते हैं.

204
00:15:54,160 --> 00:15:59,550
हम 1, 2, 3, 4, 5, 6, 7,

205
00:16:04,750 --> 00:16:07,000
और वह सब में रंग से भरा है.

206
00:16:07,000 --> 00:16:10,620
तरीका है कि बिटमैप छवियों काम यह है कि हम एक 8 की जरूरत है.

207
00:16:10,620 --> 00:16:12,460
अभी हम 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
हम बिटमैप छवि के लिए सही ढंग से पढ़ा 8 रिक्त स्थान की जरूरत है.

209
00:16:19,360 --> 00:16:25,600
तो फिर हम क्या करना है सिर्फ padding के एक बिट में जोड़ रहा है

210
00:16:25,600 --> 00:16:29,430
सुनिश्चित करें कि सभी widths के समान हैं

211
00:16:29,430 --> 00:16:34,260
और है कि चौड़ाई के सभी 4 की एक बहु.

212
00:16:42,110 --> 00:16:47,310
और इसलिए मैं पहले संकेत दिया है, एक एक्स या एक squiggly लाइन के रूप में पैडिंग,

213
00:16:47,310 --> 00:16:53,880
लेकिन वास्तविक बिटमैप छवियों में padding एक hexadecimal 0 से संकेत दिया है.

214
00:16:53,880 --> 00:16:57,340
तो यह है कि एक ही चरित्र, 0 होगा.

215
00:16:58,980 --> 00:17:06,329
काम में आ सकता क्या xxd कमांड है.

216
00:17:06,329 --> 00:17:11,220
यह क्या करता है वास्तव में आप से पता चलता है, मैं क्या स्माइली के साथ पहले किया था इसी तरह की तरह

217
00:17:11,220 --> 00:17:15,630
जब मैं वास्तव में बाहर मुद्रित प्रत्येक रंग पिक्सेल के लिए क्या होगा

218
00:17:15,630 --> 00:17:21,800
और फिर यह रंग कोडित, जब आप चलाने के निम्न कमांड के साथ xxd

219
00:17:21,800 --> 00:17:28,670
तो यह वास्तव में बाहर प्रिंट क्या रंग उन पिक्सल के लिए कर रहे हैं.

220
00:17:28,670 --> 00:17:33,810
तुम्हें क्या करना है क्या यहाँ पर संकेत मिलता है मैं 54-जैसे,

221
00:17:33,810 --> 00:17:36,530
का कहना है कि मैं 54 बाइट पर शुरू करने के लिए जा रहा हूँ

222
00:17:36,530 --> 00:17:40,820
कि क्योंकि इससे पहले, याद है अगर हम bitmaps के नक्शे के लिए वापस देखो,

223
00:17:40,820 --> 00:17:42,690
कि सभी शीर्ष लेख और उस तरह की जानकारी चीजें है.

224
00:17:42,690 --> 00:17:46,280
लेकिन क्या हम वास्तव में के बारे में परवाह वास्तविक पिक्सल है कि रंग से संकेत मिलता है.

225
00:17:46,280 --> 00:17:52,700
तो उस ध्वज में जोड़ने 54,, तो हम रंग मूल्यों को देखने में सक्षम हो.

226
00:17:52,700 --> 00:17:56,020
और जटिल और झंडे की तरह है कि चीजों के बारे में चिंता मत करो.

227
00:17:56,020 --> 00:18:05,020
समस्या सेट कल्पना में, आप कैसे xxd पिक्सेल प्रदर्शन का उपयोग करने के लिए निर्देश दिया है.

228
00:18:07,070 --> 00:18:15,590
तो अगर आप यहाँ देख कर, यह एक तरह से एक हरे रंग बॉक्स, इस छोटी सी बात की तरह लग रहा है.

229
00:18:15,590 --> 00:18:23,610
मैं मूल रूप से कोई नीले, हरे रंग का एक बहुत कुछ है, और कोई लाल के रूप में कह 00ff00 रंग कोडित.

230
00:18:23,610 --> 00:18:26,370
तो यह है कि हरे रंग से मेल खाती है.

231
00:18:26,370 --> 00:18:31,920
जैसा कि आप यहाँ देख, हम एक हरे रंग की आयत देख.

232
00:18:31,920 --> 00:18:36,660
यह हरे आयत केवल 3 पिक्सल चौड़ा है, तो फिर हम क्या करना है

233
00:18:36,660 --> 00:18:44,350
लगता है कि छवि 4 विस्तृत की एक बहु है अतिरिक्त padding में जोड़ें.

234
00:18:44,350 --> 00:18:49,460
और इतना तो है कि कैसे आप इन 0s यहाँ देखें.

235
00:18:49,460 --> 00:18:54,510
यह वास्तव में अपने आकार बदला जा सकने pset का परिणाम होगा,

236
00:18:54,510 --> 00:19:01,350
अनिवार्य रूप से छोटे बिटमैप ले रही है और फिर यह 4 से विस्तार.

237
00:19:01,350 --> 00:19:09,380
और इसलिए हम देखते हैं क्या होता है कि वास्तव में इस छवि 12 पिक्सल चौड़ा है, लेकिन 12 4 की एक बहु है,

238
00:19:09,380 --> 00:19:12,940
और इसलिए हम वास्तव में अंत में किसी भी 0s नहीं देख क्योंकि हम किसी भी जोड़ने की जरूरत नहीं है

239
00:19:12,940 --> 00:19:19,070
क्योंकि यह पूरी तरह से गद्देदार है. यह किसी भी अधिक कमरा नहीं है.

240
00:19:20,720 --> 00:19:23,470
>> ठीक है. Padding के बारे में कोई सवाल है?

241
00:19:25,150 --> 00:19:27,460
ठीक है. कूल.

242
00:19:27,460 --> 00:19:32,520
>> जैसा कि मैंने पहले उल्लेख किया है, bitmaps सिर्फ बाइट्स के एक दृश्य हैं.

243
00:19:32,520 --> 00:19:39,170
और इसलिए हम क्या बिल्कुल बाइट की संख्या जो का ट्रैक रखने की जरूरत के बजाय

244
00:19:39,170 --> 00:19:47,050
किसी विशिष्ट तत्व से मेल खाती है, हम वास्तव में एक struct बनाया है कि प्रतिनिधित्व.

245
00:19:47,050 --> 00:19:50,930
तो हम क्या एक RGBTRIPLE struct है.

246
00:19:50,930 --> 00:19:54,590
, जब भी आप एक आरजीबी ट्रिपल का एक उदाहरण है

247
00:19:54,590 --> 00:20:00,970
क्योंकि यह है कि एक प्रकार struct को परिभाषित करने के लिए, तो आप rgbtBlue चर का उपयोग कर सकते हैं,

248
00:20:00,970 --> 00:20:09,520
इसी तरह हरे और लाल चर, जो संकेत जाएगा कितना नीले, हरे, और लाल,

249
00:20:09,520 --> 00:20:11,580
क्रमशः, आप.

250
00:20:11,580 --> 00:20:16,800
>> तो अगर हम 0 से, एफएफ के लिए हरी सेट, नीले चर सेट है

251
00:20:16,800 --> 00:20:22,060
जो अधिकतम मूल्य है आप कर सकते हैं, और फिर लाल चर 0 पर सेट,

252
00:20:22,060 --> 00:20:27,870
तो क्या रंग इस विशेष आरजीबी ट्रिपल प्रतिनिधित्व चाहते हैं? >> [छात्र] ग्रीन.

253
00:20:27,870 --> 00:20:29,150
ग्रीन. बिल्कुल सही.

254
00:20:29,150 --> 00:20:34,480
यह पता करने के लिए उपयोगी हो सकता है जा रहा है कि जब भी आप एक आरजीबी ट्रिपल का एक उदाहरण है

255
00:20:34,480 --> 00:20:41,340
नीले, हरे और लाल - अलग आप वास्तव में रंग की राशि का उपयोग कर सकते हैं.

256
00:20:43,350 --> 00:20:54,900
>> अब है कि हम उस की संरचना के बारे में बात की है, चलो BMP फ़ाइल पर एक नज़र रखना.

257
00:20:54,900 --> 00:20:57,870
आप के लिए बनाया structs हैं.

258
00:20:57,870 --> 00:21:01,820
यहाँ हम एक BITMAPFILEHEADER struct है.

259
00:21:01,820 --> 00:21:07,610
ब्याज के आकार है.

260
00:21:07,610 --> 00:21:12,660
बाद में, हम जानकारी हैडर है, जो हमें कुछ और बातें है कि दिलचस्प हैं,

261
00:21:12,660 --> 00:21:15,480
अर्थात् आकार, चौड़ाई और ऊंचाई.

262
00:21:15,480 --> 00:21:19,170
जैसा कि हम बाद में जाना होगा, जब आप फ़ाइल को पढ़ने के लिए

263
00:21:19,170 --> 00:21:25,500
यह स्वतः ही है क्योंकि हम क्रम निर्धारित किया है के लिए ही होना पढ़ता है.

264
00:21:25,500 --> 00:21:31,990
तो biSize सही बाइट्स कि छवि के वास्तविक आकार के अनुरूप हो जाएगा.

265
00:21:34,700 --> 00:21:40,500
और फिर यहाँ, अंत में, जैसा कि हम के बारे में बात की है, हम RGBTRIPLE typedef struct है.

266
00:21:40,500 --> 00:21:46,840
हम एक rgbtBlue, ग्रीन, और लाल इसके साथ जुड़े है.

267
00:21:48,210 --> 00:21:49,340
>> बढ़िया है. ठीक है.

268
00:21:49,340 --> 00:21:56,360
अब है कि हम बिटमैप थोड़ा समझ, समझते हैं कि हम एक फ़ाइल शीर्षक है

269
00:21:56,360 --> 00:22:00,790
और जानकारी के साथ यह और फिर उस के बाद जुड़े हैडर, हम दिलचस्प सामान

270
00:22:00,790 --> 00:22:05,110
रंग की, और उन रंग RGBTRIPLE structs द्वारा प्रतिनिधित्व कर रहे हैं,

271
00:22:05,110 --> 00:22:12,710
और उन लोगों के लिए, बदले में, तीन नीले, हरे, लाल और जुड़े मूल्यों है.

272
00:22:12,710 --> 00:22:17,270
>> तो अब, हम लगता है के बारे में एक बिट पुनर्प्राप्त की तरह कर सकते हैं.

273
00:22:17,270 --> 00:22:20,130
माफ़ कीजिए. Whodunit के बारे में सोचो.

274
00:22:20,130 --> 00:22:25,750
जब हम अपने सुराग फ़ाइल है, तो हम क्या करना चाहते हैं यह करने के लिए में पिक्सेल द्वारा पिक्सेल पढ़ा है

275
00:22:25,750 --> 00:22:33,860
और फिर किसी भी तरह उन पिक्सल बदलने इतना है कि हम यह एक पठनीय प्रारूप में उत्पादन कर सकते हैं.

276
00:22:33,860 --> 00:22:41,020
और ऐसा करने के लिए यह उत्पादन, हम verdict.bmp फ़ाइल में पिक्सेल द्वारा पिक्सेल लिखने जा रहे हैं.

277
00:22:41,020 --> 00:22:45,120
यह करने के लिए एक बहुत की तरह है. हम पता है कि.

278
00:22:45,120 --> 00:22:49,860
तो हम क्या किया है यह है कि हम वास्तव में आपके द्वारा प्रदान की copy.c.

279
00:22:49,860 --> 00:22:57,610
Copy.c क्या करता है बस एक दिया बिटमैप फ़ाइल का एक सटीक प्रतिलिपि बनाता है और फिर यह outputs.

280
00:22:57,610 --> 00:23:01,900
तो यह पहले से ही आप के लिए फ़ाइल को खोलता है, पिक्सेल द्वारा पिक्सेल में पढ़ता है,

281
00:23:01,900 --> 00:23:04,510
और फिर इसे एक आउटपुट फाइल में लिखते हैं.

282
00:23:04,510 --> 00:23:07,080
>> चलो उस पर एक नज़र रखना.

283
00:23:13,390 --> 00:23:18,290
यह उचित उपयोग सुनिश्चित करना है,

284
00:23:18,290 --> 00:23:22,640
filenames यहाँ हो रही है.

285
00:23:22,640 --> 00:23:29,940
यह क्या करता है यह इनपुट फ़ाइल सेट करने के लिए क्या हम में infile में पारित कर दिया है यहाँ,

286
00:23:29,940 --> 00:23:34,750
जो हमारी दूसरी कमांड लाइन तर्क है.

287
00:23:34,750 --> 00:23:37,640
यकीन है कि हम फ़ाइल को खोल सकते हैं बनाना जाँचता है.

288
00:23:38,960 --> 00:23:44,860
यकीन है कि हम एक नए outfile यहाँ कर सकते हैं बनाने जाँचता है.

289
00:23:45,630 --> 00:23:53,270
तो यह क्या यहाँ है, यह सिर्फ मूल रूप से बिटमैप फ़ाइल में शुरू से ही पढ़ने शुरू होता है.

290
00:23:53,270 --> 00:23:56,700
शुरुआत है, जैसा कि हम जानते हैं, BITMAPFILEHEADER होता है,

291
00:23:56,700 --> 00:24:03,200
और इसलिए बिट्स के उन दृश्यों सीधे BITMAPFILEHEADER में भरना होगा.

292
00:24:03,200 --> 00:24:07,940
तो क्या हम यहाँ है कि BITMAPFILEHEADER bf कह रहा है -

293
00:24:07,940 --> 00:24:13,150
कि हमारे प्रकार BITMAPFILEHEADER के नए चर है -

294
00:24:13,150 --> 00:24:22,560
हम bf के अंदर डाल हम क्या सूचक में से पढ़ने के लिए जा रहे हैं, जो हमारे infile है.

295
00:24:22,560 --> 00:24:23,970
हम कितना पढ़ा है?

296
00:24:23,970 --> 00:24:32,160
हम कितने बाइट्स हम पूरी BITMAPFILEHEADER होते हैं की जरूरत में पढ़ा.

297
00:24:32,160 --> 00:24:34,660
इसी तरह, कि जानकारी हेडर के लिए हमें क्या करना है.

298
00:24:34,660 --> 00:24:39,010
तो हम हमारे फाइल के साथ infile में जारी कर रहे हैं,

299
00:24:39,010 --> 00:24:44,360
और हम उन बिट्स और बाइट्स पढ़ रहे हैं, और हम उन्हें plugging रहे हैं में सीधे

300
00:24:44,360 --> 00:24:47,880
चर है कि हम कर रहे हैं की इन उदाहरणों में.

301
00:24:49,370 --> 00:24:53,800
यहाँ हम सिर्फ यह सुनिश्चित करें कि बिटमैप एक बिटमैप है कर रहे हैं.

302
00:24:57,670 --> 00:25:01,030
>> अब हम एक outfile, है ना?

303
00:25:01,030 --> 00:25:04,420
तो के रूप में यह खड़ा है जब हम इसे बनाने के लिए है, यह अनिवार्य रूप से खाली है.

304
00:25:04,420 --> 00:25:07,710
तो हम मूल रूप से खरोंच से एक नया बिटमैप बनाने के लिए किया है.

305
00:25:07,710 --> 00:25:12,280
हमें क्या करना है हम यकीन है कि हम फ़ाइल शीर्षक में कॉपी बनाना है

306
00:25:12,280 --> 00:25:16,850
और infile तरह सिर्फ जानकारी शीर्षक है.

307
00:25:16,850 --> 00:25:22,850
हमें क्या करना है हम लिखने और याद कि bf चर है

308
00:25:22,850 --> 00:25:29,300
प्रकार BITMAPFILEHEADER की तो, हम क्या है हम सिर्फ कि सामग्री का उपयोग करें

309
00:25:29,300 --> 00:25:34,980
outfile में लिखने के लिए.

310
00:25:36,550 --> 00:25:38,510
याद है, हम padding के बारे में बात की थी,

311
00:25:38,510 --> 00:25:47,820
कैसे लगता है कि पिक्सल है कि हम की राशि 4 की एक बहु है बनाने के लिए यह महत्वपूर्ण है.

312
00:25:47,820 --> 00:25:52,790
यह एक बहुत उपयोगी सूत्र की गणना के लिए आप कितना padding है

313
00:25:52,790 --> 00:25:57,670
अपनी फ़ाइल की चौड़ाई को देखते हुए.

314
00:25:57,670 --> 00:26:04,120
मैं तुम लोगों को याद करने के लिए कि copy.c में हम padding की गणना के लिए एक फार्मूला है.

315
00:26:04,120 --> 00:26:07,970
ठीक है? तो हर कोई याद है कि. बढ़िया है.

316
00:26:07,970 --> 00:26:14,050
तो फिर copy.c क्या करता बगल में है, यह खत्म scanlines के सभी दोहराता है.

317
00:26:14,050 --> 00:26:23,730
यह पंक्तियों के माध्यम से पहली बार चला जाता है और फिर हर ट्रिपल कि यह पढ़ता भंडार

318
00:26:23,730 --> 00:26:26,920
और फिर यह outfile में लिखता है.

319
00:26:26,920 --> 00:26:33,120
तो फिर यहाँ हम एक समय में केवल एक आरजीबी ट्रिपल पढ़ रहे हैं

320
00:26:33,120 --> 00:26:39,860
और फिर outfile में है कि एक ही ट्रिपल डाल.

321
00:26:41,120 --> 00:26:48,340
मुश्किल हिस्सा है कि padding एक आरजीबी ट्रिपल नहीं है,

322
00:26:48,340 --> 00:26:55,200
और इसलिए हम सिर्फ आरजीबी triples कि padding राशि नहीं पढ़ सकते हैं.

323
00:26:55,200 --> 00:27:01,460
हमें क्या करना है क्या वास्तव में सिर्फ हमारे फ़ाइल स्थिति सूचक ले जाने के लिए, हमारे कर्सर को स्थानांतरित करने के लिए,

324
00:27:01,460 --> 00:27:06,840
सभी padding पर छोड़ इतना है कि हम अगली पंक्ति में हैं की तरह.

325
00:27:06,840 --> 00:27:12,990
और फिर यह क्या करता है प्रतिलिपि दिखाता है कि आप padding जोड़ने के लिए चाहते हो सकता है.

326
00:27:12,990 --> 00:27:14,990
तो हम गणना है कितना padding हम की जरूरत है,

327
00:27:14,990 --> 00:27:18,220
तो इसका मतलब है कि हम 0s के पैडिंग संख्या की जरूरत है.

328
00:27:18,220 --> 00:27:24,510
यह क्या करता है पाश है कि हमारे outfile में 0s के पैडिंग संख्या डालता है के लिए एक है.

329
00:27:24,510 --> 00:27:31,170
और फिर अंत में, आप दोनों फ़ाइलों बंद. आप के रूप में के रूप में अच्छी तरह से outfile infile करीब है.

330
00:27:31,170 --> 00:27:34,870
>> तो है कि copy.c कैसे काम करता है,

331
00:27:34,870 --> 00:27:37,430
और कहा कि बहुत उपयोगी होने जा रहा है.

332
00:27:39,720 --> 00:27:43,750
के बजाय सिर्फ वास्तव में सीधे कॉपी और चिपकाने

333
00:27:43,750 --> 00:27:46,800
या सिर्फ यह देख रहे हैं और जो आप चाहते हैं टाइप,

334
00:27:46,800 --> 00:27:49,440
आप बस टर्मिनल में इस आदेश पर अमल करना चाहते हो सकता है,

335
00:27:49,440 --> 00:27:54,520
सी.पी. copy.c whodunit.c, जो एक नई फ़ाइल बनाने whodunit.c,

336
00:27:54,520 --> 00:27:58,330
कि सटीक एक ही सामग्री के रूप में प्रतिलिपि करता है शामिल हैं.

337
00:27:58,330 --> 00:28:03,880
तो फिर हम क्या कर सकते है कि जिस पर एक ढांचे के रूप में बनाने के लिए और संपादित करने के लिए

338
00:28:03,880 --> 00:28:06,900
हमारे whodunit फ़ाइल के लिए.

339
00:28:08,500 --> 00:28:14,670
>> ये हमारे लिए डॉस whodunit के लिए करने के लिए कर रहे हैं, लेकिन क्या copy.c करता है

340
00:28:14,670 --> 00:28:16,730
है वास्तव में हमारे लिए उनमें से अधिकांश का ख्याल रखता है.

341
00:28:16,730 --> 00:28:21,900
तो हम सब आगे क्या जरूरत है पिक्सल बदलने के रूप में जरूरत

342
00:28:21,900 --> 00:28:25,920
वास्तव में फ़ाइल पठनीय बनाने.

343
00:28:25,920 --> 00:28:32,960
एक दिया ट्रिपल पिक्सेल के लिए याद रखें कि, प्रकार RGBTRIPLE की एक भी चर के लिए तो,

344
00:28:32,960 --> 00:28:35,990
आप नीले, हरे और लाल मूल्यों का उपयोग कर सकते हैं.

345
00:28:35,990 --> 00:28:38,670
कि आने के लिए काम में लिए जा रहा है क्योंकि अगर आप उन तक पहुँच सकते हैं,

346
00:28:38,670 --> 00:28:41,770
इसका मतलब है कि आप भी उन्हें जांच कर सकते हैं,

347
00:28:41,770 --> 00:28:45,430
और इसका मतलब है कि आप उसे बदल सकते हैं.

348
00:28:45,430 --> 00:28:49,430
>> इसलिए, जब हम हमारे लाल आवर्धक कांच उदाहरण के लिए वापस चला गया

349
00:28:49,430 --> 00:28:53,390
मूलतः, कि हमारे लिए फिल्टर का एक प्रकार के रूप में काम कर रहा था.

350
00:28:53,390 --> 00:28:58,160
तो हम क्या करना चाहते है हम ट्रिपल कि अंदर आ रहे हैं के सभी फ़िल्टर करना चाहते हैं

351
00:28:58,160 --> 00:29:01,240
वहाँ कई अलग अलग तरीके से ऐसा कर रहे हैं.

352
00:29:01,240 --> 00:29:07,100
असल में, आप कर सकते हैं फ़िल्टर के प्रकार जो आप चाहते हैं.

353
00:29:07,100 --> 00:29:09,890
हो सकता है कि आप सभी लाल पिक्सल बदलना चाहते हैं

354
00:29:09,890 --> 00:29:13,570
या शायद आप एक अलग रंग के लिए एक अलग रंग पिक्सेल बदलना चाहते हैं.

355
00:29:13,570 --> 00:29:15,400
यह आप पर निर्भर है.

356
00:29:15,400 --> 00:29:19,580
याद रखें कि आप देख सकते हैं कि क्या रंग है पिक्सेल

357
00:29:19,580 --> 00:29:23,000
और फिर आप भी इसे बदलने के रूप में आप के माध्यम से जा रहे हैं कर सकते हैं.

358
00:29:24,410 --> 00:29:26,420
>> ठीक है. तो यह है कि whodunit है.

359
00:29:26,420 --> 00:29:32,760
एक बार जब आप whodunit चलाते हैं, तो आपको पता चल जाएगा कि अपराध का दोषी कौन था.

360
00:29:32,760 --> 00:29:35,540
>> अब हम का आकार बदलना करने के लिए जाने के लिए जा रहे हैं.

361
00:29:35,540 --> 00:29:37,990
हम अभी भी बिटमैप के साथ काम किया जा रहे हैं.

362
00:29:37,990 --> 00:29:40,750
हम क्या करते हैं तो हम एक इनपुट बिटमैप करने के लिए जा रहे हैं

363
00:29:40,750 --> 00:29:45,890
और फिर हम एक संख्या में पारित करने के लिए और फिर एक outfile बिटमैप मिलता जा रहे हैं

364
00:29:45,890 --> 00:29:51,380
कहाँ है कि मूल रूप से हमारे n द्वारा पहुंचा infile.

365
00:29:54,670 --> 00:30:01,450
कहते हैं कि मेरी फाइल सिर्फ एक पिक्सेल बड़ी थी.

366
00:30:01,450 --> 00:30:09,100
फिर अगर मेरे n 3 से 3, स्केलिंग था, तो मुझे लगता है कि n बार की पिक्सेल संख्या दोहराना होगा,

367
00:30:09,100 --> 00:30:14,410
तो 3 बार, और फिर भी यह नीचे पैमाने पर 3 बार के रूप में अच्छी तरह से.

368
00:30:14,410 --> 00:30:17,840
तो आप देखते हैं, मैं इसे स्केलिंग हूँ के रूप में अच्छी तरह के रूप में खड़ी क्षैतिज.

369
00:30:17,840 --> 00:30:19,680
>> और फिर यहाँ एक उदाहरण है.

370
00:30:19,680 --> 00:30:27,590
यदि आप n = 2 है, तो आप देखते हैं कि पहली नीली पिक्सेल दो बार दोहराया

371
00:30:27,590 --> 00:30:30,930
क्षैतिज रूप में खड़ी दो बार के रूप में अच्छी तरह से.

372
00:30:30,930 --> 00:30:38,040
और फिर उस पर जारी है, और इसलिए तुम दोनों के द्वारा अपनी मूल छवि के प्रत्यक्ष स्केलिंग है.

373
00:30:40,920 --> 00:30:47,600
>> यदि ऐसा है तो हम इस बात के लिए pseudocode विस्तार करने के लिए थे, हम फ़ाइल खोलना चाहते हैं.

374
00:30:47,600 --> 00:30:49,880
और फिर यह जानकर कि अगर हम यहाँ वापस जाओ,

375
00:30:49,880 --> 00:30:54,540
हम देखते हैं कि outfile लिए चौड़ाई infile के लिए चौड़ाई से अलग होने जा रहा है.

376
00:30:54,540 --> 00:30:56,130
इसका क्या मतलब है?

377
00:30:56,130 --> 00:31:01,230
इसका मतलब है कि हमारे हेडर सूचना को बदलने जा रहा है.

378
00:31:01,230 --> 00:31:03,790
और इसलिए क्या हम करना चाहते है हैडर जानकारी अपडेट,

379
00:31:03,790 --> 00:31:11,820
जानते हुए भी कि जब हम फाइलों में पढ़ा अगर आप copy.c रूपरेखा पर काम कर रहे हैं,

380
00:31:11,820 --> 00:31:17,570
हम पहले से ही एक चर कि इंगित करता है आकार क्या है और इस तरह बातें है.

381
00:31:17,570 --> 00:31:24,060
तो एक बार आप हैं कि, क्या तुम करना चाहते हो सकता है विशेष रूप से उन चर बदलने के लिए है.

382
00:31:24,060 --> 00:31:29,380
याद रखें, यदि आप एक struct है, कैसे है कि आप के भीतर चर का उपयोग कर रहे हैं.

383
00:31:29,380 --> 00:31:32,080
आप डॉट ऑपरेटर का उपयोग करते हैं, सही?

384
00:31:32,080 --> 00:31:36,420
तो उस का उपयोग कर, आप जानते हैं कि आप हेडर जानकारी बदलने की आवश्यकता होगी.

385
00:31:36,480 --> 00:31:41,030
तो यहाँ सिर्फ वास्तविक तत्व है कि अपनी फ़ाइल में बदलती होने जा रहे हैं की एक सूची है.

386
00:31:41,030 --> 00:31:45,180
फ़ाइल का आकार बदलने, छवि, चौड़ाई और ऊंचाई के रूप में के रूप में अच्छी तरह से जा रहा है.

387
00:31:45,180 --> 00:31:50,080
तो bitmaps के नक्शे के लिए वापस जा रहा,

388
00:31:50,080 --> 00:31:57,730
देखने के लिए कि क्या यह फ़ाइल शीर्षक या जानकारी शीर्षक है कि उस जानकारी शामिल है

389
00:31:57,730 --> 00:32:00,920
और तो बदल के रूप में की जरूरत है.

390
00:32:05,010 --> 00:32:12,470
फिर, सी.पी. copy.c resize.c कहते हैं.

391
00:32:12,470 --> 00:32:19,270
इसका मतलब है कि resize.c अब सब कुछ है कि प्रतिलिपि अंदर निहित है

392
00:32:19,270 --> 00:32:24,490
क्योंकि हमें प्रतिलिपि पिक्सेल द्वारा प्रत्येक scanline पिक्सेल में पढ़ने का एक तरीका प्रदान करता है.

393
00:32:24,490 --> 00:32:29,860
को छोड़कर अब, बजाय सिर्फ मूल्यों को बदलने की तरह हम whodunit में किया था,

394
00:32:29,860 --> 00:32:37,980
हम क्या करना चाहते है हम कई पिक्सल में लिखने के लिए चाहते हैं

395
00:32:37,980 --> 00:32:43,580
के रूप में लंबे समय के रूप के रूप में हमारे n 1 से अधिक है.

396
00:32:43,580 --> 00:32:47,110
>> तो फिर हम क्या करना चाहते है हम इसे n द्वारा क्षैतिज खिंचाव चाहते हैं,

397
00:32:47,110 --> 00:32:50,490
और साथ ही यह खड़ी खिंचाव n द्वारा.

398
00:32:50,490 --> 00:32:52,710
हम यह कैसे कर सकता है?

399
00:32:52,710 --> 00:32:56,890
कहो अपने 2 n है और आप इस दी infile है.

400
00:32:56,890 --> 00:32:58,730
आपका कर्सर पहले एक पर शुरू करने के लिए जा रहा है,

401
00:32:58,730 --> 00:33:03,530
और आप क्या करना चाहते हैं अगर 2 n है, तो आप उन लोगों में से 2 में मुद्रित करना चाहते हैं.

402
00:33:03,530 --> 00:33:05,490
तो आप उन लोगों में से 2 में मुद्रित.

403
00:33:05,490 --> 00:33:10,830
फिर अपने कर्सर अगले पिक्सेल है, जो लाल एक को स्थानांतरित करने के लिए जा रहा है,

404
00:33:10,830 --> 00:33:18,400
और यह करने के लिए बाहर 2 उन लाल वालों के प्रिंट, यह क्या यह पहले किया है पर appending जा रहा है.

405
00:33:18,400 --> 00:33:26,280
तब कर्सर अगले पिक्सेल के लिए ले जाने के लिए और उन में से 2 में आकर्षित करेगा.

406
00:33:26,280 --> 00:33:37,180
यदि आप copy.c रूपरेखा, यह क्या करता है के लिए वापस सही यहाँ देखो

407
00:33:37,180 --> 00:33:42,830
है यह एक आरजीबी, ट्रिपल, एक नए ट्रिपल चर बुलाया की एक नई मिसाल पैदा करता है.

408
00:33:42,830 --> 00:33:50,500
और यहाँ जब यह में पढ़ता है, यह infile RGBTRIPLE 1 से पढ़ता

409
00:33:50,500 --> 00:33:53,470
और यह दुकानों के अंदर कि ट्रिपल चर के.

410
00:33:53,470 --> 00:33:57,590
तो फिर आप वास्तव में एक है कि विशेष रूप से पिक्सेल का प्रतिनिधित्व चर.

411
00:33:57,590 --> 00:34:05,290
तो जब आप लिखते हैं, तुम क्या करना चाहते हो सकता fwrite बयान पाश के लिए एक डिब्बे में बंद है

412
00:34:05,290 --> 00:34:11,080
है कि कई बार के रूप में की जरूरत के रूप में अपने outfile में लिखते हैं.

413
00:34:17,449 --> 00:34:20,100
यह काफी सरल है.

414
00:34:20,200 --> 00:34:27,590
बस मूल रूप से लेखन की प्रक्रिया n बार की संख्या यह क्षैतिज पैमाने दोहराएँ.

415
00:34:27,590 --> 00:34:32,969
>> लेकिन तब हमें याद है कि हमारे padding बदलने जा रहा है.

416
00:34:47,350 --> 00:34:53,020
पहले कहते हैं, हम 3 लंबाई के बारे में कुछ था.

417
00:34:53,020 --> 00:35:00,130
तो हम बस कितना padding में जोड़ना होगा? यह सिर्फ एक और 4 की एक बहु बनाने के लिए.

418
00:35:00,130 --> 00:35:10,480
लेकिन कहते हैं कि हम n = 2 इस विशेष छवि स्केलिंग कर रहे हैं.

419
00:35:10,480 --> 00:35:16,300
तो फिर कैसे कई नीले पिक्सल हम अंत में करना चाहते हैं? हम 6 करना होगा.

420
00:35:16,300 --> 00:35:21,470
1, 2, 3, 4, 5, 6. सही सभी.

421
00:35:21,470 --> 00:35:26,580
6 4 की एक बहु नहीं है. 4 के निकटतम गुणज क्या है? कि 8 होने जा रहा है.

422
00:35:26,580 --> 00:35:33,200
तो हम वास्तव में padding के 2 वर्ण वहाँ जा रहे हैं.

423
00:35:33,200 --> 00:35:38,720
>> क्या किसी को याद है अगर हम को padding की गणना के लिए एक फार्मूला है

424
00:35:38,720 --> 00:35:41,350
और कहा कि जहां हो सकता है?

425
00:35:41,350 --> 00:35:45,160
[अश्राव्य छात्र प्रतिक्रिया] >> copy.c. हाँ, सही है.

426
00:35:45,160 --> 00:35:49,800
Copy.c में एक सूत्र की गणना के लिए आप कितना padding

427
00:35:49,800 --> 00:35:53,810
बिटमैप छवि की एक विशेष चौड़ाई दिया.

428
00:35:53,810 --> 00:36:02,950
तो जा रहा है कि करने के लिए उपयोगी हो सकता है जब आप padding की एक निश्चित मात्रा में जोड़ने की जरूरत है

429
00:36:02,950 --> 00:36:06,160
वास्तव में बाहर आंकड़ा कितना padding आप जोड़ने की जरूरत है.

430
00:36:10,820 --> 00:36:15,850
लेकिन एक नोट, हालांकि यह है कि आप सुनिश्चित करें कि आप सही आकार का उपयोग कर रहे हैं बनाना चाहते हैं.

431
00:36:15,850 --> 00:36:21,410
बस सावधान रहना चाहिए क्योंकि आप मूल रूप से दो बिटमैप छवियों के साथ काम करने जा रहे हैं.

432
00:36:21,410 --> 00:36:23,410
आप सुनिश्चित करें कि आप सही एक का उपयोग कर रहे हैं बनाना चाहते हैं.

433
00:36:23,410 --> 00:36:26,820
जब आप outfile के लिए padding गणना कर रहे हैं, आप outfile की चौड़ाई का उपयोग करना चाहते हैं

434
00:36:26,820 --> 00:36:29,860
और पिछले एक की चौड़ाई नहीं.

435
00:36:29,860 --> 00:36:37,240
>> बढ़िया है. उस तरह एक पूरे बिटमैप छवि क्षैतिज खींच का ख्याल रखता है.

436
00:36:37,240 --> 00:36:41,290
लेकिन वास्तव में हम क्या करना चाहते हैं यह खड़ी है के रूप में अच्छी तरह से खिंचाव.

437
00:36:41,290 --> 00:36:48,760
यह थोड़ा पेचीदा मामला हो सकता है क्योंकि जब हम एक पंक्ति नकल खत्म कर दिया है जा रहा है

438
00:36:48,760 --> 00:36:51,580
और कि पंक्ति लेखन, हमारे कर्सर के अंत में होने जा रहा है.

439
00:36:51,580 --> 00:36:56,210
तो अगर हम फिर से पढ़ा, तो यह सिर्फ अगली पंक्ति में पढ़ा जा रहा है.

440
00:36:56,210 --> 00:37:03,660
तो हम क्या करना चाहते तरह की उन पंक्तियों को फिर से नकल का कोई रास्ता खोजने

441
00:37:03,660 --> 00:37:12,500
या सिर्फ उस पंक्ति ले और फिर इसे फिर से नए सिरे से लिखना की तरह.

442
00:37:14,380 --> 00:37:17,940
जैसा कि मैं एक तरह से करने के लिए alluded, वहाँ कई अलग तरीके से ऐसा कर रहे हैं.

443
00:37:17,940 --> 00:37:23,040
आप क्या कर सकता है के रूप में आप के माध्यम से जा रहे हैं और विशेष scanline के माध्यम से पढ़ने

444
00:37:23,040 --> 00:37:28,560
और यह आवश्यक के रूप में बदल रहा है, तो दुकान की तरह एक सरणी में उन पिक्सल के सभी.

445
00:37:28,560 --> 00:37:36,350
तो फिर तुम पर बाद में पता है कि तुम बाहर है कि सरणी फिर प्रिंट की आवश्यकता होगी,

446
00:37:36,350 --> 00:37:39,830
और इसलिए आप सिर्फ इतना है कि सरणी का उपयोग कर सकते हैं.

447
00:37:39,830 --> 00:37:44,500
एक और तरीका यह करना है आप नीचे एक पंक्ति की नकल कर सकता है,

448
00:37:44,500 --> 00:37:47,950
समझते हैं कि आप है कि फिर से कॉपी करने की जरूरत है, तो वास्तव में आपके कर्सर चाल,

449
00:37:47,950 --> 00:37:50,950
और कहा कि विधि fseek का उपयोग किया जा रहा है.

450
00:37:50,950 --> 00:37:56,410
आप अपने कर्सर सभी तरह वापस स्थानांतरित कर सकता है और फिर नकल की प्रक्रिया को फिर से दोहराने की.

451
00:37:56,410 --> 00:38:03,960
>> तो अगर हमारे स्केलिंग संख्या n है, तो कितनी बार हम वापस जाने के लिए करना होगा

452
00:38:03,960 --> 00:38:10,500
और एक लाइन को फिर से लिखना है? >> [छात्र] n - 1. >> हाँ, सही. n - 1.

453
00:38:10,500 --> 00:38:14,390
हम एक बार पहले से ही यह किया है, तो फिर हम वापस जा रही इस प्रक्रिया को दोहराने के लिए चाहता हूँ

454
00:38:14,390 --> 00:38:17,460
समय की राशि 1 - एन.

455
00:38:22,730 --> 00:38:25,860
ठीक है. तो क्या तुम वहाँ अपने आकार समारोह है.

456
00:38:25,860 --> 00:38:34,360
>> अब हम एक बहुत मजेदार हिस्सा है, मेरी पसंदीदा pset है, जो ठीक है प्राप्त कर सकते हैं.

457
00:38:34,360 --> 00:38:39,580
Bitmaps की बजाय, इस समय हम JPEGs के साथ काम कर रहे हैं.

458
00:38:39,580 --> 00:38:43,370
हम वास्तव में JPEGs का सिर्फ एक फ़ाइल दिया नहीं कर रहे हैं,

459
00:38:43,370 --> 00:38:46,600
हम मूल रूप से एक कच्चे मेमोरी कार्ड प्रारूप दिया हो.

460
00:38:46,600 --> 00:38:51,790
और इसलिए इस जानकारी और कचरा मूल्यों की शुरुआत में एक सा होता है,

461
00:38:51,790 --> 00:38:57,240
और तो यह शुरू होता है और यह JPEG फ़ाइलों का एक गुच्छा है.

462
00:38:57,240 --> 00:39:03,430
हालांकि, हम एक कार्ड हाथ रहे हैं, जहां हम फोटो नष्ट कर दिया है;

463
00:39:03,430 --> 00:39:08,300
अनिवार्य रूप से, हम भूल गए हैं जहाँ फोटो कार्ड के भीतर स्थित हैं.

464
00:39:08,300 --> 00:39:12,770
तो फिर पुनर्प्राप्त में हमारे काम के लिए इस कार्ड प्रारूप के माध्यम से जाना है

465
00:39:12,770 --> 00:39:16,500
और उन चित्रों को फिर से लगता है.

466
00:39:16,500 --> 00:39:23,990
>> सौभाग्य से, JPEG फ़ाइलों और कार्ड फ़ाइल की संरचना एक बिट मददगार है.

467
00:39:23,990 --> 00:39:28,850
यह निश्चित रूप से एक सा trickier हो सकता था अगर यह इस विशेष स्वरूप में नहीं थे.

468
00:39:28,850 --> 00:39:40,160
हर JPEG फ़ाइल वास्तव में दो संभव दृश्यों, ऊपर सूचीबद्ध के साथ शुरू होता है.

469
00:39:40,160 --> 00:39:42,970
असल में, जब भी आप एक नया JPEG फ़ाइल है,

470
00:39:42,970 --> 00:39:52,720
यह या तो ffe0 ffd8 या अन्य एक, ffe1 ffd8 अनुक्रम के साथ शुरू होता है.

471
00:39:52,720 --> 00:39:59,530
एक और उपयोगी बात को पता है कि JPEGs contiguously संग्रहीत कर रहे हैं.

472
00:39:59,530 --> 00:40:03,380
तो जब भी एक JPEG फ़ाइल समाप्त होता है, एक दूसरे को शुरू होता है.

473
00:40:03,380 --> 00:40:07,070
तो वहाँ वहाँ मूल्यों के बीच किसी भी तरह का नहीं है.

474
00:40:07,070 --> 00:40:15,510
एक बार जब आप एक JPEG के शुरू मारा, अगर आप पहले से ही एक JPEG पढ़ कर दिया गया है,

475
00:40:15,510 --> 00:40:21,800
आप जानते हैं कि आप पिछले एक और अगले एक की शुरुआत के अंत मारा है.

476
00:40:21,800 --> 00:40:25,890
>> इस कल्पना की तरह, मैं एक योजनाबद्ध बनाया.

477
00:40:25,890 --> 00:40:36,910
JPEGs के बारे में एक और बात यह है कि हम एक समय में 512 बाइट्स के दृश्यों में उन्हें पढ़ सकते हैं,

478
00:40:36,910 --> 00:40:39,380
इसी तरह के कार्ड की शुरुआत के साथ.

479
00:40:39,380 --> 00:40:43,370
हम हर एक बाइट की जाँच हो सकता है क्योंकि कि चूसना होगा की जरूरत नहीं है.

480
00:40:43,370 --> 00:40:48,200
तो बजाय, हम क्या कर सकते हैं वास्तव में सिर्फ एक बार में 512 बाइट में पढ़ा

481
00:40:48,200 --> 00:40:54,700
और फिर, उन छोटे छोटे स्लाइस में उन लोगों के बीच में जाँच के बजाय,

482
00:40:54,700 --> 00:40:58,640
हम सिर्फ 512 बाइट्स की शुरुआत की जांच कर सकते हैं.

483
00:40:58,640 --> 00:41:02,570
मूलतः, इस चित्र में, क्या तुमने देखा कार्ड की शुरुआत में है,

484
00:41:02,570 --> 00:41:08,700
आप मूल्यों है कि वास्तव में वास्तविक खुद JPEGs के लिए प्रासंगिक नहीं हैं.

485
00:41:08,700 --> 00:41:15,830
लेकिन फिर मैं क्या एक सितारा एक JPEG के लिए दो दृश्यों के शुरू से संकेत मिलता है.

486
00:41:15,830 --> 00:41:19,910
तो जब भी आप एक स्टार को देखने के लिए, आप जानते हैं कि आप एक JPEG फ़ाइल है.

487
00:41:19,910 --> 00:41:25,030
और फिर हर JPEG फ़ाइल 512 बाइट्स के कुछ एकाधिक होने जा रहा है

488
00:41:25,030 --> 00:41:27,880
जरूरी नहीं बल्कि एक ही कई.

489
00:41:27,880 --> 00:41:32,050
तरीका है कि आप जानते हैं कि आप एक और जेपीईजी मारा है अगर आप एक और सितारा मारा,

490
00:41:32,050 --> 00:41:39,090
बाइट्स की एक प्रारंभिक अनुक्रम.

491
00:41:39,090 --> 00:41:43,330
तो तुम यहाँ है क्या है आप लाल JPEG सतत फ़ाइल है जब तक आप एक स्टार मारा,

492
00:41:43,330 --> 00:41:45,150
जो एक नया रंग ने संकेत दिया है.

493
00:41:45,150 --> 00:41:48,510
आप जारी रखने के लिए और फिर आप एक और सितारा मारा, आप एक और जेपीईजी मारा,

494
00:41:48,510 --> 00:41:50,590
आप अंत तक सभी तरह जारी है.

495
00:41:50,590 --> 00:41:53,180
आप पिछली तस्वीर पर यहाँ हो, गुलाबी एक.

496
00:41:53,180 --> 00:41:58,220
आप को समाप्त करने के लिए जाना है जब तक आप फ़ाइल चरित्र के अंत मारा.

497
00:41:58,220 --> 00:42:00,820
यह वास्तव में उपयोगी होने जा रहा है.

498
00:42:00,820 --> 00:42:03,170
>> कुछ यहाँ मुख्य takeaways:

499
00:42:03,170 --> 00:42:06,670
कार्ड फ़ाइल एक JPEG के साथ शुरू नहीं करता है,

500
00:42:06,670 --> 00:42:13,350
लेकिन एक बार एक JPEG शुरू होता है, JPEGs के सभी पक्ष की ओर से एक दूसरे के लिए संग्रहित कर रहे हैं.

501
00:42:17,520 --> 00:42:20,420
>> पुनर्प्राप्त के लिए कुछ pseudocode.

502
00:42:20,420 --> 00:42:22,570
सबसे पहले, हम हमारे कार्ड फ़ाइल खोलने जा रहे हैं,

503
00:42:22,570 --> 00:42:27,500
और कहा कि हमारे फ़ाइल मैं / हे कार्यों का उपयोग किया जा रहा है.

504
00:42:27,500 --> 00:42:32,430
हम निम्नलिखित प्रक्रिया को दोहराने जा रहे हैं जब तक हम फ़ाइल के अंत तक पहुँच है.

505
00:42:32,430 --> 00:42:36,450
हम एक समय में 512 बाइट्स पढ़ने के लिए जा रहे हैं.

506
00:42:36,450 --> 00:42:39,180
और क्या मैं यहाँ कहा है कि हम यह एक बफर में स्टोर करने के लिए जा रहे हैं,

507
00:42:39,180 --> 00:42:46,230
तो बुनियादी तौर पर उन 512 बाइट्स के लिए पर पकड़ जब तक हम जानते हैं कि क्या वास्तव में उनके साथ क्या करना है.

508
00:42:46,230 --> 00:42:50,300
तो फिर हम क्या करना चाहते है हम चाहते हैं कि क्या हम एक सितारा या नहीं मारा है.

509
00:42:50,300 --> 00:42:57,960
यदि हम एक सितारा मारा है, अगर हम शुरू दृश्यों में से एक मारा है,

510
00:42:57,960 --> 00:42:59,980
तो हम जानते हैं कि हम एक नए JPEG फ़ाइल मारा है.

511
00:42:59,980 --> 00:43:08,860
हम क्या करना चाहते है हम करने के लिए हमारे pset4 निर्देशिका में एक नई फ़ाइल बनाने के लिए चाहते करने जा रहे हैं

512
00:43:08,860 --> 00:43:14,480
उस फ़ाइल को बनाने के लिए जारी है.

513
00:43:14,480 --> 00:43:18,220
लेकिन यह भी, अगर हम पहले से ही पहले एक JPEG,

514
00:43:18,220 --> 00:43:25,620
तो हम कि फ़ाइल के अंत और यह pset4 फ़ोल्डर में धक्का चाहते हैं,

515
00:43:25,620 --> 00:43:29,780
हम कहाँ है कि फ़ाइल संग्रहीत क्योंकि अगर हम निर्दिष्ट नहीं करते कि हम उस JPEG फ़ाइल समाप्त हो गया है,

516
00:43:29,780 --> 00:43:37,290
तो हम मूल रूप से एक अनिश्चित राशि होगा. JPEGs कभी खत्म नहीं होगा.

517
00:43:37,290 --> 00:43:40,840
इसलिए हम यह सुनिश्चित करें कि जब हम एक JPEG फ़ाइल में पढ़ रहे हैं और कि लेखन बनाना चाहते हैं,

518
00:43:40,840 --> 00:43:46,590
हम विशेष रूप से है कि बंद के क्रम में करने के लिए अगले एक खोलने के लिए चाहते हैं.

519
00:43:46,590 --> 00:43:48,430
हम कई चीजों की जाँच करने के लिए चाहता हूँ.

520
00:43:48,430 --> 00:43:52,880
हम जाँच करें कि क्या हम अपने बफर के साथ एक नया JPEG के शुरू में हो

521
00:43:52,880 --> 00:43:56,780
और भी अगर हम पहले से ही एक JPEG पाया है पहले

522
00:43:56,780 --> 00:44:03,930
कारण है कि आपकी प्रक्रिया थोड़ा बदल जाएगा.

523
00:44:03,930 --> 00:44:07,880
तो फिर उसके बाद आप सभी तरह के माध्यम से जाने के लिए और आप फ़ाइल के अंत मारा,

524
00:44:07,880 --> 00:44:11,570
तो आप करना चाहती हूँ क्या है आप के लिए सभी फ़ाइलों कि वर्तमान में खुले हैं बंद करने के लिए चाहता हूँ.

525
00:44:11,570 --> 00:44:14,100
यह शायद आखिरी JPEG फ़ाइल है कि आप हो जाएगा,

526
00:44:14,100 --> 00:44:18,930
के रूप में कार्ड फ़ाइल के रूप में अच्छी तरह से है कि आप के साथ काम कर रहा है.

527
00:44:21,940 --> 00:44:28,670
>> अंतिम बाधा है कि हम से निपटने की जरूरत है कि कैसे वास्तव में एक JPEG फ़ाइल बनाने के लिए

528
00:44:28,670 --> 00:44:31,950
और कैसे वास्तव में फ़ोल्डर में इसे धक्का.

529
00:44:33,650 --> 00:44:39,850
pset की आवश्यकता है कि हर JPEG कि आप पाते हैं निम्नलिखित प्रारूप में होना,

530
00:44:39,850 --> 00:44:43,990
आप जहां संख्या है jpg.

531
00:44:43,990 --> 00:44:50,750
संख्या है, यहां तक ​​कि अगर यह 0 है, हम इसे 000.jpg कहते हैं.

532
00:44:50,750 --> 00:44:55,730
जब भी आप अपने प्रोग्राम में खोजने के लिए एक JPEG,

533
00:44:55,730 --> 00:44:58,040
आप जा रहे हैं कि यह पाया गया है क्रम में करने के लिए यह नाम देना चाहते हैं.

534
00:44:58,040 --> 00:44:59,700
इसका क्या मतलब है?

535
00:44:59,700 --> 00:45:03,530
हम कितने हमने पाया है का ट्रैक रखने की तरह करने की जरूरत है

536
00:45:03,530 --> 00:45:08,680
और प्रत्येक JPEG की संख्या क्या होना चाहिए.

537
00:45:08,680 --> 00:45:13,800
यहाँ हम sprintf समारोह का लाभ लेने के लिए जा रहे हैं.

538
00:45:13,800 --> 00:45:17,480
के लिए भी इसी तरह printf, प्रिंट की तरह बस टर्मिनल में एक मूल्य है, जो

539
00:45:17,480 --> 00:45:23,910
sprintf फ़ोल्डर में फ़ाइल बाहर प्रिंट.

540
00:45:23,910 --> 00:45:30,870
और इसलिए यह क्या अगर मैं sprintf शीर्षक था, है, और होता तो वहाँ स्ट्रिंग,

541
00:45:30,870 --> 00:45:36,660
यह बाहर 2.jpg प्रिंट होगा.

542
00:45:36,660 --> 00:45:41,020
यह मानते हुए कि मैं अपनी फ़ाइलों को सही ढंग से बंद कर दिया है,

543
00:45:41,020 --> 00:45:47,210
कि फ़ाइल है कि मैं लिख रहा था शामिल होगा.

544
00:45:47,210 --> 00:45:50,320
लेकिन एक बात है कि कोड है कि मैं यहाँ है

545
00:45:50,320 --> 00:45:53,360
करता है पूरा pset क्या आवश्यकता काफी नहीं है.

546
00:45:53,360 --> 00:46:02,410
pset की आवश्यकता है कि 2 JPEG फ़ाइल 2 के बजाय सिर्फ 002 नाम दिया जाना चाहिए.

547
00:46:02,410 --> 00:46:09,160
तो जब आप बाहर नाम मुद्रित, तो शायद आप प्लेसहोल्डर थोड़ा बदल करना चाहते हो सकता है.

548
00:46:09,160 --> 00:46:18,140
>> क्या किसी को याद है कि हम अतिरिक्त रिक्त स्थान के लिए अनुमति देते हैं जब हम कुछ प्रिंट?

549
00:46:18,140 --> 00:46:22,530
हाँ. >> [छात्र] प्रतिशत चिह्न और 2 के बीच एक 3 डाल दिया. >> हाँ, सही.

550
00:46:22,530 --> 00:46:25,610
आप इस मामले में एक 3 रखा है क्योंकि हम 3 के लिए अंतरिक्ष चाहते.

551
00:46:25,610 --> 00:46:32,590
% 3d शायद आप के बजाय 002.jpg 2 देना होगा.

552
00:46:32,590 --> 00:46:40,120
sprintf समारोह में पहला तर्क वास्तव में एक चार सरणी है,

553
00:46:40,120 --> 00:46:42,520
जो हम पहले तार के रूप में जानता था.

554
00:46:42,520 --> 00:46:50,700
उन होगा, एक अस्थायी भंडारण की तरह अधिक की तरह, सिर्फ परिणामी स्ट्रिंग की दुकान.

555
00:46:50,700 --> 00:46:54,950
तुम सच में इस के साथ काम नहीं कर जाएगा, लेकिन आप इसे शामिल करने की जरूरत है.

556
00:46:54,950 --> 00:47:00,710
>> यह जानते हुए भी कि हर फ़ाइल नाम संख्या है, जो तीन अक्षर लेता है,

557
00:47:00,710 --> 00:47:06,770
और फिर jpg, कितनी देर तक इस सरणी होना चाहिए?

558
00:47:09,070 --> 00:47:14,310
बाहर संख्या फेंको. शीर्षक में कितने नाम में, वर्ण?

559
00:47:18,090 --> 00:47:26,320
तो वहाँ 3 hashtags, अवधि, jpg है. >> [छात्र] 7. 7. >> काफी नहीं है.

560
00:47:26,320 --> 00:47:32,000
हम 8 चाहते करने जा रहे हैं क्योंकि हम के रूप में अच्छी तरह से अशक्त टर्मिनेटर के लिए अनुमति देना चाहते हैं.

561
00:47:45,340 --> 00:47:49,730
>> अंत में, बस प्रक्रिया है कि आप ठीक करने के लिए कर रही हो जाएगा आकर्षित करने,

562
00:47:49,730 --> 00:47:55,420
तुम कुछ शुरुआत जानकारी है.

563
00:47:55,420 --> 00:48:02,460
आप जारी रख सकते हैं जब तक आप एक JPEG फ़ाइल की शुरुआत पाते हैं,

564
00:48:02,460 --> 00:48:07,900
और कहा कि या तो दो शुरूआती दृश्यों के एक हो सकता है.

565
00:48:07,900 --> 00:48:12,510
आप पढ़ने पर रखने के लिए. हर यहाँ स्लेश 512 बाइट्स का प्रतिनिधित्व करता है.

566
00:48:12,510 --> 00:48:22,630
आप पढ़ने पर रहते हैं, जब तक आप एक प्रारंभिक अनुक्रम मुठभेड़ पढ़ने पर रहते हैं.

567
00:48:22,630 --> 00:48:29,790
एक बार जब आपको लगता है कि आप वर्तमान JPEG अंत - इस मामले में, यह एक लाल,

568
00:48:29,790 --> 00:48:31,030
तो आपको लगता है कि खत्म करना चाहते हो.

569
00:48:31,030 --> 00:48:35,540
आप sprintf अपने pset4 फ़ोल्डर में उस के नाम करने के लिए करना चाहते हैं,

570
00:48:35,540 --> 00:48:41,580
तो आप के लिए एक नया JPEG खोलने और फिर पढ़ने पर रखना चाहते हैं

571
00:48:41,580 --> 00:48:46,370
जब तक आप अगले मुठभेड़.

572
00:48:46,370 --> 00:48:49,040
पढ़ने पर रखें, पढ़ने पर रहते हैं,

573
00:48:49,040 --> 00:48:56,290
और फिर अंत में, अंततः, आप फ़ाइल के अंत तक पहुँचने के लिए जा रहे हैं,

574
00:48:56,290 --> 00:49:00,360
और इसलिए आप पिछले JPEG बंद करना चाहते हैं कि आप के साथ काम कर रहे थे,

575
00:49:00,360 --> 00:49:08,380
sprintf कि अपने pset4 फ़ोल्डर में, और फिर सभी चित्रों का है कि तुम मिल गया है पर देखो.

576
00:49:08,380 --> 00:49:12,050
उन चित्रों को वास्तव में कर रहे हैं CS50 कर्मचारियों की तस्वीरें,

577
00:49:12,050 --> 00:49:16,430
और तो यह है जहां pset के बोनस मज़ा हिस्से में आता है

578
00:49:16,430 --> 00:49:26,310
यह है कि आप अपने वर्गों में प्रतिस्पर्धा कर रहे हैं चित्रों में TFS

579
00:49:26,310 --> 00:49:34,610
और उनके साथ तस्वीरें लेने के लिए साबित करने के लिए है कि आप pset किया है

580
00:49:34,610 --> 00:49:37,030
और इसलिए आप देख सकते हैं जो स्टाफ के सदस्यों तस्वीरों में हैं.

581
00:49:37,030 --> 00:49:41,510
तो फिर तुम कर्मचारियों के साथ तस्वीरें ले लो. कभी कभी आप उन्हें नीचे का पीछा करना होगा.

582
00:49:41,510 --> 00:49:44,680
शायद उनमें से कुछ के लिए आप से दूर चलाने के लिए कोशिश करेंगे.

583
00:49:44,680 --> 00:49:47,320
आप उन लोगों के साथ तस्वीरें ले लो.

584
00:49:47,320 --> 00:49:51,190
यह चल रही है. यह कारण जब pset कारण है नहीं है.

585
00:49:51,190 --> 00:49:53,340
समय सीमा तय की कल्पना में घोषणा की जाएगी.

586
00:49:53,340 --> 00:49:58,060
अपने अनुभाग के साथ एक साथ फिर, अनुभाग जो भी सबसे अधिक तस्वीरें लेता है

587
00:49:58,060 --> 00:50:04,430
सबसे स्टाफ के सदस्यों के साथ एक बहुत भयानक पुरस्कार जीत जाएगा.

588
00:50:04,430 --> 00:50:08,890
यह प्रोत्साहन की तरह अपने pset4 यथासंभव जल्दी समाप्त

589
00:50:08,890 --> 00:50:10,820
क्योंकि तब आप नीचे कारोबार करने के लिए मिल सकता है

590
00:50:10,820 --> 00:50:14,570
सब अलग अलग CS50 स्टाफ के सदस्यों के नीचे शिकार.

591
00:50:14,570 --> 00:50:17,500
यह अनिवार्य नहीं है, हालांकि, तो एक बार आप चित्र प्राप्त करने,

592
00:50:17,500 --> 00:50:20,310
तो आप pset4 के साथ खत्म हो रहे हैं.

593
00:50:20,310 --> 00:50:23,970
>> और मैं 4 Walkthrough के साथ समाप्त कर रहा हूँ, तो आप आने के लिए सभी को धन्यवाद.

594
00:50:23,970 --> 00:50:29,330
Forensics के साथ गुड लक. [वाहवाही]

595
00:50:29,330 --> 00:50:31,000
[CS50.TV]