1
00:00:00,000 --> 00:00:12,240
>> [संगीत खेल]

2
00:00:12,240 --> 00:00:15,870
>> आरओबी BOWDEN: हाय, मैं रोब हूँ, चलो
आकार के लिए पर इस कोशिश.

3
00:00:15,870 --> 00:00:21,100
तो, हम फिर से शुरू करने जा रहे हैं
मूल रूप से एक copy.c की प्रतिलिपि, और

4
00:00:21,100 --> 00:00:22,860
कुछ परिवर्तन करें.

5
00:00:22,860 --> 00:00:26,280
तुरंत हम एक बदलाव को देखने के नोट जहां
बजाय देखने के लिए जाँच की अगर

6
00:00:26,280 --> 00:00:30,440
argc, हम जांच करने के लिए 3 बराबर नहीं चाहता है
argc के बाद से, 4 बराबर नहीं है अगर

7
00:00:30,440 --> 00:00:34,350
अब हम सिर्फ एक infile में नहीं ले रहे हैं
और outfile, लेकिन हम भी में ले जा रहे हैं

8
00:00:34,350 --> 00:00:38,980
हम कर रहे हैं कि राशि है जो एन,
मूल छवि से स्केलिंग.

9
00:00:38,980 --> 00:00:44,340
हम इस बात का यकीन हो जाने के बाद, हम कर सकते हैं बस
atoi का उपयोग कर एक पूर्णांक n करने के लिए परिवर्तित.

10
00:00:44,340 --> 00:00:48,760
>> तो, अब हम कुछ बनाने के लिए जा रहे हैं
फर्जी नाम, सिर्फ 2 infile argv कहते हैं, और

11
00:00:48,760 --> 00:00:54,240
argv 3 outfile, argv 2 और क्योंकि
argv 3 बहुत उपयोगी नाम नहीं हैं.

12
00:00:54,240 --> 00:00:58,510
अब हमें यकीन है कि n है बनाने के लिए जाँच करना चाहते हैं
सीमा के भीतर हम उम्मीद करते हैं, तो

13
00:00:58,510 --> 00:01:02,910
कल्पना यह बताता है कि यह कम से कम या अगर
, शून्य के बराबर, या 100 से अधिक

14
00:01:02,910 --> 00:01:08,580
तो है कि एक अवैध आकार परिवर्तन कारक है,
और हम उस के उपयोगकर्ता को सचेत करना चाहिए.

15
00:01:08,580 --> 00:01:13,090
>> हम सब उस पार जाते हैं, तो हम कर सकते हैं
अंत में हमारे infile खोलने, और हम की जरूरत

16
00:01:13,090 --> 00:01:16,270
यकीन है कि जांच त्रुटि को
उद्घाटन किसी कारण के लिए असफल नहीं किया.

17
00:01:16,270 --> 00:01:19,860
हम भी अपने outfile खोलने की जरूरत है, और
फिर से सुनिश्चित करने के लिए जांच त्रुटि

18
00:01:19,860 --> 00:01:21,250
किसी कारण के लिए असफल नहीं किया.

19
00:01:21,250 --> 00:01:26,270
लेकिन यकीन है कि अगर का उद्घाटन
outfile हम बंद करने की आवश्यकता है कि विफल रही

20
00:01:26,270 --> 00:01:29,040
पहले से ही खोला गया था जो infile,.

21
00:01:29,040 --> 00:01:33,690
>> तो, फिर, कि असफल नहीं किया संभालने
we're - बस के रूप में copy.c -

22
00:01:33,690 --> 00:01:36,140
हैडर में पढ़ने के लिए जा रहा
infile से.

23
00:01:36,140 --> 00:01:40,130
हमें यकीन है कि यह एक वैध बनाने के लिए जा रहे हैं
बिटमैप, लेकिन अब हम कुछ ऐसा करने जा रहे हैं

24
00:01:40,130 --> 00:01:41,620
थोड़ा अलग बातें.

25
00:01:41,620 --> 00:01:44,870
तो सबसे पहले, हम चाहते करने जा रहे हैं
मूल चौड़ाई और ऊंचाई याद

26
00:01:44,870 --> 00:01:48,290
infile की, क्योंकि हम करने जा रहे हैं
outfile के लिए इसे बदलने जा.

27
00:01:48,290 --> 00:01:53,890
तो अब अजीब कारणों के लिए याद है कि
bi.biheight, नकारात्मक है, और

28
00:01:53,890 --> 00:01:58,670
इतने में वास्तविक ऊंचाई, सकारात्मक, हम
निरपेक्ष मान लेना चाहते हैं.

29
00:01:58,670 --> 00:02:02,580
>> अब, गद्दी ही होने जा रहा है
यह copy.c में था गणना के रूप में,

30
00:02:02,580 --> 00:02:06,060
पुराने चौड़ाई का उपयोग कर, और अब हम कर रहे हैं
वास्तव में बदलने जा रहा

31
00:02:06,060 --> 00:02:07,320
हमारे शीर्ष में क्या है.

32
00:02:07,320 --> 00:02:11,200
तो हम से हमारे चौड़ाई गुणा करने के लिए जा रहे हैं
एन, हम द्वारा चौड़ाई स्केलिंग रहे हैं

33
00:02:11,200 --> 00:02:15,100
हम कर रहे हैं के बाद से n, n द्वारा ऊंचाई गुणा
n द्वारा स्केलिंग, और अब हमारे पास

34
00:02:15,100 --> 00:02:19,250
एक नई गद्दी के लिए गणना
नई चौड़ाई के आधार पर.

35
00:02:19,250 --> 00:02:21,840
>> तो अब हम कुछ बदलने की जरूरत
हमारे शीर्ष लेख में अन्य क्षेत्रों.

36
00:02:21,840 --> 00:02:26,890
Bi.biSizeImage माना जाता है
पिक्सल में सभी बाइट्स का आकार

37
00:02:26,890 --> 00:02:28,520
और छवि की गद्दी.

38
00:02:28,520 --> 00:02:34,190
और इसलिए हमारे की एक ही पंक्ति का आकार
छवि आरजीबी का आकार ट्रिपल, आकार है

39
00:02:34,190 --> 00:02:39,430
एक एकल पिक्सेल का, बार संख्या की
एक पंक्ति में पिक्सल, प्लस गद्दी पर

40
00:02:39,430 --> 00:02:40,910
पंक्ति के अंत.

41
00:02:40,910 --> 00:02:45,200
और फिर हम से है कि गुणा करने के लिए जा रहे हैं
पाने के लिए हमारे ऊंचाई के निरपेक्ष मूल्य

42
00:02:45,200 --> 00:02:48,350
बाइट्स की कुल संख्या
छवि डेटा में.

43
00:02:48,350 --> 00:02:53,050
bf.bfSize अभी कुल संख्या है
के बारे में हमारी छवि डेटा में बाइट्स, तो

44
00:02:53,050 --> 00:02:56,530
bi.biSizeImage, प्लस
हमारे हेडर के आकार.

45
00:02:56,530 --> 00:02:59,850
तो, बिटमैप फ़ाइल के आकार पर जोड़ने
बिटमैप जानकारी का शीर्षक है, और आकार

46
00:02:59,850 --> 00:03:00,800
ठीक है, हैडर.

47
00:03:00,800 --> 00:03:03,170
तो यह है कि हम सब करने की ज़रूरत है
हमारे हेडर में बदल जाते हैं.

48
00:03:03,170 --> 00:03:07,020
अब हम बिटमैप फ़ाइल शीर्ष लेख लिख देंगे
हमारे outfile, और हमारे बिटमैप की जानकारी के लिए

49
00:03:07,020 --> 00:03:09,880
अब हमारे outfile को हैडर, और
हम जा रहा शुरू करने के लिए तैयार हैं

50
00:03:09,880 --> 00:03:11,990
वास्तविक पिक्सल से अधिक.

51
00:03:11,990 --> 00:03:15,720
>> इसलिए हम अधिक पुनरावृति करना चाहते हैं
infile की लाइनों स्कैन.

52
00:03:15,720 --> 00:03:17,730
इसलिए हम oldheight अधिक पुनरावृति करना चाहते हैं.

53
00:03:17,730 --> 00:03:20,830
हम याद करने की जरूरत है यही कारण है कि
हम इसे बदलने से पहले मूल ऊंचाई,

54
00:03:20,830 --> 00:03:23,040
और एन द्वारा इसे बढ़ाया.

55
00:03:23,040 --> 00:03:27,810
अब हम एक भी पढ़ने के लिए जा रहे हैं
एक में infile की पंक्ति

56
00:03:27,810 --> 00:03:30,630
आकार oldwidth के बफर.

57
00:03:30,630 --> 00:03:36,190
आरजीबी की तो यहाँ, हम freading रहे हैं आकार
ट्रिपल, एक पिक्सेल, और के पुराने चौड़ाई

58
00:03:36,190 --> 00:03:39,760
हमारे बफर में infile से उन्हें.

59
00:03:39,760 --> 00:03:43,480
और कहा कि एक पूरा होने जा रहा है
इस सरणी में पंक्ति.

60
00:03:43,480 --> 00:03:50,390
तो अब, हम करने के लिए एन बार पुनरावृति करना चाहते हैं
हमारे outfile एन बार करने के लिए इस पंक्ति मुद्रित.

61
00:03:50,390 --> 00:03:52,510
और इतना है कि इस पाश कर रहा है.

62
00:03:52,510 --> 00:03:57,910
यह भीतरी लूप पर iterating है
सरणी, मुद्रण पर, खुद पंक्ति

63
00:03:57,910 --> 00:04:00,710
सरणी एन बार में प्रत्येक पिक्सेल.

64
00:04:00,710 --> 00:04:04,510
तो zeroth तत्व मुद्रित किया जा रहा है
n बार, पहला तत्व जा रहा है

65
00:04:04,510 --> 00:04:05,660
एन बार छपी.

66
00:04:05,660 --> 00:04:10,820
और उस तरह का है कि कैसे हम करने जा रहे है
क्षैतिज outfile में पैमाने पर, और

67
00:04:10,820 --> 00:04:13,390
इस लूप, हम n पाशन रहे हैं
कई बार, हम करने जा रहे हैं कि कैसे है

68
00:04:13,390 --> 00:04:15,580
खड़ी पैमाने.

69
00:04:15,580 --> 00:04:19,850
>> यहाँ नीचे, हम हम जोड़ने की जरूरत है कि देखना
प्रत्येक पंक्ति के अंत में पैडिंग.

70
00:04:19,850 --> 00:04:25,050
इस के लिए लूप के अंदर है यही कारण है कि
कि बस के एन पंक्तियों बाहर मुद्रण है

71
00:04:25,050 --> 00:04:28,400
infile से इस एक पंक्ति.

72
00:04:28,400 --> 00:04:32,150
तो फिर यहाँ नीचे, मैं पर छोड़ जा रहा हूँ
infile में गद्दी, एक बार के बाद से

73
00:04:32,150 --> 00:04:34,560
हम में से एक पंक्ति के साथ कर रहे हैं
infile, हम के बारे में परवाह नहीं है

74
00:04:34,560 --> 00:04:35,290
क्या गद्दी था.

75
00:04:35,290 --> 00:04:37,110
हम सिर्फ दूसरी पंक्ति को प्राप्त करना चाहते हैं.

76
00:04:37,110 --> 00:04:40,870
और फिर हम वापस पाश हूँ और सब करते हैं
इस बार फिर दूसरी पंक्ति के लिए.

77
00:04:40,870 --> 00:04:44,406
>> अंत में, एक बार हम सब के साथ कर रहे हैं,
हम करीब, infile बंद कर सकते हैं

78
00:04:44,406 --> 00:04:47,430
outfile, और वापसी
0 हम कर रहे हैं क्योंकि.

79
00:04:47,430 --> 00:04:50,330
>> मेरा नाम रोब है, और यह आकार परिवर्तन था.

80
00:04:50,330 --> 00:04:54,934
>> [संगीत खेल]