1
00:00:00,000 --> 00:00:00,996

2
00:00:00,996 --> 00:00:12,470
>> [მუსიკის დაკვრა]

3
00:00:12,470 --> 00:00:13,210
>> რობ Bowden: Hi.

4
00:00:13,210 --> 00:00:16,870
მე Rob და მოდით ზომა
ეს პრობლემა.

5
00:00:16,870 --> 00:00:20,990
ამიტომ, ჩვენ ვაპირებთ დავიწყოთ copy.c როგორც
თარგი, მაგრამ ჩვენ ვაპირებთ, რომ იყოს

6
00:00:20,990 --> 00:00:23,340
რაც საკმაოდ ცვლილებები.

7
00:00:23,340 --> 00:00:27,570
>> ახლა ჩვენ ვხედავთ, რომ ჩვენ დაუყოვნებლივ მიღების
შეცვლა სადაც ჩვენ აღარ შემოწმების

8
00:00:27,570 --> 00:00:31,560
ჩვენი rxc არ გაუტოლდება 3, მაგრამ ახლა
ჩვენ შემოწმების rc არ გაუტოლდება 4.

9
00:00:31,560 --> 00:00:34,670
მას შემდეგ, რაც ჩვენ ასევე გვინდა მოიცავს,
გარდა ფაილის და გარეთ ფაილები

10
00:00:34,670 --> 00:00:39,550
არგუმენტები, f, რომელიც იქნება ამ
ფაქტორი, რომლითაც ჩვენ სკალირების.

11
00:00:39,550 --> 00:00:45,430
>> ასე რომ ერთხელ ჩვენ დარწმუნებული, რომ ჩვენ გვინდა
გამოყენება ნანახია სკანირების ვ კონვერტირება სიმებიანი

12
00:00:45,430 --> 00:00:49,030
argv1 to float.

13
00:00:49,030 --> 00:00:51,330
და ჩვენ ვაპირებთ შესანახად
რომ ფაქტორი.

14
00:00:51,330 --> 00:00:55,180
ეს დამატებითი ხასიათი მიღების დარწმუნებული ვარ,
რომ ჩვენ რეალურად არ შევდივართ

15
00:00:55,180 --> 00:00:59,200
რაღაც 1.4 ABC
ბრძანებათა ზოლს.

16
00:00:59,200 --> 00:01:02,960
>> ახლა ჩვენ ვაპირებთ შევქმნათ მაგალითი
მას შემდეგ, რაც RV2 და RV3 არ არის

17
00:01:02,960 --> 00:01:04,310
ძალიან გამოსადეგი სახელები.

18
00:01:04,310 --> 00:01:07,660
ჩვენ, ნაცვლად, ვაპირებ მოვუწოდო
მათ ფაილი და out ფაილი.

19
00:01:07,660 --> 00:01:11,580
ახლა ჩვენ ვაპირებთ, რომ დავრწმუნდეთ, რომ
ჩვენი ფაქტორი იყო რეალურად მოქმედებს.

20
00:01:11,580 --> 00:01:16,330
ასე რომ, თუ ფაქტორი ნაკლებია ან ტოლი
ნულოვანი ან აღემატება 100, შემდეგ პოსტი

21
00:01:16,330 --> 00:01:19,660
სპეც, ჩვენ უარი უნდა თქვას
რომ ფაქტორი.

22
00:01:19,660 --> 00:01:23,890
>> როდესაც ჩვენ დარწმუნებული კარგია, ახლა ჩვენ შეგვიძლია
გახსნა n ფაილი, და ჩვენ უნდა გააკეთოთ

23
00:01:23,890 --> 00:01:25,950
დარწმუნებული ვარ, რომ ის წარმატებით გაიხსნა.

24
00:01:25,950 --> 00:01:28,630
თუ ეს არ, რომ დაბრუნდება null.

25
00:01:28,630 --> 00:01:30,390
ჩვენ ვაპირებთ გახსნა out ფაილი.

26
00:01:30,390 --> 00:01:33,420
და ისევ, ჩვენ გვინდა შევამოწმოთ, რათა
დარწმუნებული ვარ, რომ ის წარმატებით გაიხსნა.

27
00:01:33,420 --> 00:01:37,270
და თუ ეს არ წარმატებით გახსნა, შემდეგ
ჩვენ ასევე უნდა იყოს დარწმუნებული დახურვა

28
00:01:37,270 --> 00:01:40,870
n ფაილი, რომელიც თავდაპირველად წარმატებით
გახსნა, ანდა ჩვენ

29
00:01:40,870 --> 00:01:42,600
მეხსიერების გაჟონვის.

30
00:01:42,600 --> 00:01:46,350
>> ასე რომ, ახლა ჩვენ ვაპირებთ, რომ წაიკითხონ bitmap
ფაილის header და bitmap ინფორმაცია

31
00:01:46,350 --> 00:01:48,890
თავი n ფაილი.

32
00:01:48,890 --> 00:01:52,360
ჩვენ ვაპირებთ, რომ დავრწმუნდეთ, რომ
n ფაილი იყო სწორი bitmap.

33
00:01:52,360 --> 00:01:52,640
OK.

34
00:01:52,640 --> 00:01:55,100
>> ახლა ჩვენ ვაპირებთ დავიწყოთ
მიღების გარკვეული ცვლილებები.

35
00:01:55,100 --> 00:01:58,840
ასე რომ, რადგან ჩვენ ვაპირებთ იცვლება
რამ, პირველ რიგში უნდა გვახსოვდეს

36
00:01:58,840 --> 00:02:01,510
ძველი სიგანე n ფაილი.

37
00:02:01,510 --> 00:02:05,160
ჩვენ გვინდა, რომ მახსოვს ძველი padding of
n ფაილი იმავე გაანგარიშება

38
00:02:05,160 --> 00:02:06,990
ეხლა copy.c.

39
00:02:06,990 --> 00:02:09,840
>> და ახლა ჩვენ ვაპირებთ, რომ შეიცვალოს
bitmap ინფორმაცია header.

40
00:02:09,840 --> 00:02:13,630
და ამიტომ ჩვენ გამრავლებით ორივე სიგანე
და სიმაღლე ფაქტორი, რადგან

41
00:02:13,630 --> 00:02:15,750
ის, რაც ჩვენ სკალირების მიერ.

42
00:02:15,750 --> 00:02:18,420
ჩვენ ვაპირებთ, რათა დადგინდეს
ახალი padding ფაილი მიერ

43
00:02:18,420 --> 00:02:21,140
გამოყენებით ახალი სიგანე.

44
00:02:21,140 --> 00:02:27,330
და ჩვენ ვაპირებთ, რათა დადგინდეს new
ზომის გამოსახულების გამოყენებით ნომერი

45
00:02:27,330 --> 00:02:31,610
ბაიტი ერთ row რომელიც აპირებს
იყოს ნომერი pixels რომ row

46
00:02:31,610 --> 00:02:35,960
ჯერ ზომა pixel პლუს
ნომერი ბაიტი padding დასასრულს

47
00:02:35,960 --> 00:02:40,310
რომ ზედიზედ, და გამრავლებით ყველა რომ
რაოდენობის რიგები, რომ ჩვენ გვაქვს.

48
00:02:40,310 --> 00:02:43,800
ასე რომ ბაიტების რაოდენობას
ჩვენ ჩვენი იმიჯი მონაცემები.

49
00:02:43,800 --> 00:02:48,190
>> Bf.Bfsize ახლა იქნება ნომერი
ბაიტების ჩვენი იმიჯი beta პლუს

50
00:02:48,190 --> 00:02:49,350
ზომა ჩვენი headers.

51
00:02:49,350 --> 00:02:53,910
ასე რომ, პლუს ზომა Bitmap ფაილი header
და ზომის bitmap ინფორმაცია header.

52
00:02:53,910 --> 00:02:54,510
OK.

53
00:02:54,510 --> 00:02:56,440
ასე რომ, ეს ჩვენი headers.

54
00:02:56,440 --> 00:02:59,030
ჩვენ შეგვიძლია დავწეროთ ფაილის ხელმძღვანელი და
ინფორმაცია header ჩვენი out

55
00:02:59,030 --> 00:03:01,590
შეიტანოს, და ჩვენ კარგი.

56
00:03:01,590 --> 00:03:03,800
>> ახლა დროა დაიწყოს რეალურად
წერა pixel

57
00:03:03,800 --> 00:03:05,120
მონაცემები out ფაილი.

58
00:03:05,120 --> 00:03:10,460
ჩვენ ვაპირებთ, რომ განაცხადოს ბუფერის ზომა
ძველი სიგანე RGB საწოლიანი, და ჩვენ

59
00:03:10,460 --> 00:03:13,790
აპირებს განაცხადოს ცვლადში
row numb, რომელიც ჩვენ ვაპირებთ

60
00:03:13,790 --> 00:03:15,640
თავდაპირველად მითითებული ტოლი 1.

61
00:03:15,640 --> 00:03:19,090
ჩვენ დავინახავთ, რომ ჩვენ ვაპირებთ იყოს გამოყენებით
რომ იმისათვის, რომ ტრეკზე რა

62
00:03:19,090 --> 00:03:22,640
row ჩვენ გაკეთებული აქვს დატვირთული
ამ ბუფერული.

63
00:03:22,640 --> 00:03:23,290
OK.

64
00:03:23,290 --> 00:03:28,750
>> ახლა, განსხვავებით სტანდარტული გამოცემა,
ნაცვლად iterating ზე in

65
00:03:28,750 --> 00:03:32,900
ფაილი, ჩვენ ვაპირებთ iterate მეტი თითოეული
ზედიზედ out ფაილი და გაერკვნენ

66
00:03:32,900 --> 00:03:38,130
რომელიც ზედიზედ ფაილი ჩვენ გვინდა
განათავსეთ ამ ზედიზედ out ფაილი.

67
00:03:38,130 --> 00:03:44,930
ასე რომ iterating მეტი ყველა რიგები გარეთ
ფაილის გამოყენებით ახალი სიმაღლე, ჩვენ პირველი

68
00:03:44,930 --> 00:03:48,890
აპირებს, რათა დადგინდეს ზედიზედ წლის
ფაილი ჩვენ ვაპირებთ გამოვიყენოთ, რომლებიც ჩვენ

69
00:03:48,890 --> 00:03:53,560
გაკეთებას აპირებს აღების მიმდინარე
row იყოფა ფაქტორია.

70
00:03:53,560 --> 00:03:58,000
ისე, რომ აპირებს მოგვცეს row
ძველი ფაილი, რომელიც ჩვენ გვინდა.

71
00:03:58,000 --> 00:04:03,310
>> ახლა თუ row numb არ თანაბარი ძველი y,
ჩვენ ვაპირებთ, რომ უნდა წაიკითხოთ row

72
00:04:03,310 --> 00:04:05,940
რომ ჩვენ გვინდა, ჩვენს მიმდ. ზედიზედ ბუფერული.

73
00:04:05,940 --> 00:04:07,700
ასე რომ, თუ ჩვენ ვაპირებთ, რომ გავაკეთოთ?

74
00:04:07,700 --> 00:04:11,650
პირველი, ჩვენ ვაპირებთ გაერკვნენ
პოზიცია, რომ იწყება, რომ ზედიზედ

75
00:04:11,650 --> 00:04:13,100
ორიგინალურ ზომაში.

76
00:04:13,100 --> 00:04:18,630
ასე რომ, პოზიცია იქნება
წარსულში ყველა ჩვენი ზედა და

77
00:04:18,630 --> 00:04:21,589
ახლა გასული წლის y რიგები.

78
00:04:21,589 --> 00:04:23,880
>> და ასე რამდენი ბაიტი
არის ერთ ზედიზედ?

79
00:04:23,880 --> 00:04:28,740
ერთხელ, ზომა RGB triple ჯერ ძველი
სიგანე plus წლის padding, ასე რომ

80
00:04:28,740 --> 00:04:30,640
ბაიტების რაოდენობას ერთ row.

81
00:04:30,640 --> 00:04:33,680
და ჩვენ გვინდა გამოტოვოთ წარსულში ძველი y რიგები.

82
00:04:33,680 --> 00:04:37,580
ამიტომ, ჩვენ ვაპირებთ, რომ f შეეცდება და ჩვენ
გამოყენებით შეეცდება კომპლექტი იწყება

83
00:04:37,580 --> 00:04:39,100
დასაწყისში ფაილი.

84
00:04:39,100 --> 00:04:42,740
ჩვენ ვაპირებთ f ცდილობენ ამ თანამდებობაზე
ფაილი, აყენებს ჩვენს

85
00:04:42,740 --> 00:04:46,500
დასაწყისში ზედიზედ გვინდა
წაკითხვის ჩვენს ბუფერული.

86
00:04:46,500 --> 00:04:48,510
>> ჩვენ ვაპირებთ, რომ მითითებული row
numb ტოლია ძველი y.

87
00:04:48,510 --> 00:04:53,080
ახლა თუ ჩვენ loop უკან და ჩვენ გვინდა, რომ
გამოიყენოს ეს იგივე row ჩვენს out ფაილი,

88
00:04:53,080 --> 00:04:55,970
მაშინ ჩვენ არ ვაპირებთ წაკითხვის
ეს კიდევ ერთხელ ზედმეტად.

89
00:04:55,970 --> 00:04:59,310
ასე რომ, რეალურად, row numb არის
უბრალოდ ოპტიმიზაცია.

90
00:04:59,310 --> 00:05:05,500
>> და ბოლოს, ჩვენ ვაპირებთ წაიკითხა შევიდა
მიმდინარე row ძველი სიგანე RGB საწოლიანი

91
00:05:05,500 --> 00:05:08,040
რომ ჩვენ გვინდა ორიგინალური ფაილი.

92
00:05:08,040 --> 00:05:12,270
ახლა მიმდ. row შეიცავს pixels დან
ორიგინალური ფაილის, რომ ჩვენ გვინდა

93
00:05:12,270 --> 00:05:14,200
წერენ შევიდა out ფაილი.

94
00:05:14,200 --> 00:05:18,960
ახლა, ისევე, როგორც ზემოთ აღვნიშნეთ, ნაცვლად
iterating მეტი ძველი ფაილი, ჩვენ გვჭირდება

95
00:05:18,960 --> 00:05:22,560
მას iterate მეტი ახალი ფაილი რიგები.

96
00:05:22,560 --> 00:05:27,450
ისე აქ, ნაცვლად iterating ყველა
ძველი pixels რომ მიმდ. row,

97
00:05:27,450 --> 00:05:31,210
ჩვენ გვინდა iterate მეტი ყველა
pixels ჩვენი ახალი ფაილი ამ

98
00:05:31,210 --> 00:05:32,480
კერძოდ row.

99
00:05:32,480 --> 00:05:34,140
>> რატომ გვინდა ამის გაკეთება?

100
00:05:34,140 --> 00:05:38,960
რადგან ჩვენ ვხედავთ, რომ ჩვენ არა ვართ
რეალურად აუცილებლად გამოყენებით ყველა

101
00:05:38,960 --> 00:05:41,020
pixels ორიგინალური ფაილი.

102
00:05:41,020 --> 00:05:46,630
რადგან თუ ჩვენ მცირდება, ჩვენ შეგვიძლია
ნამდვილად გინდათ გამოტოვოთ pixels.

103
00:05:46,630 --> 00:05:48,090
და ჩვენ ვხედავთ, რომ ამ -

104
00:05:48,090 --> 00:05:49,690
x იყოფა ფაქტორი -

105
00:05:49,690 --> 00:05:55,620
მჭიდროდ სარკეები აქ, სადაც ჩვენ ვამბობთ y
იყოფა ფაქტორი უნდა გაერკვნენ, რომ

106
00:05:55,620 --> 00:06:02,480
ძველი y-th row შეესაბამება
y-th row ამ ახალ ფაილს.

107
00:06:02,480 --> 00:06:05,880
>> ახლა ჩვენ ვაპირებთ დავწეროთ ყველა
ამ pixels ძველი row

108
00:06:05,880 --> 00:06:07,440
ჩვენი ახალი row.

109
00:06:07,440 --> 00:06:10,890
მას შემდეგ, რაც ჩვენ გავაკეთეთ, რომ, ჩვენ გვჭირდება მხოლოდ
დააყენა padding დასასრულს ჩვენი row

110
00:06:10,890 --> 00:06:15,540
და ჩვენ loop უკან და გაგრძელდება
ყველა რიგები ჩვენი ახალი ფაილი.

111
00:06:15,540 --> 00:06:19,390
ბოლოს, ჩვენ უნდა დახუროს ჩვენი ძველი
წარადგინოს, დახუროს ჩვენი ახალი ფაილი, და სანაცვლოდ

112
00:06:19,390 --> 00:06:21,540
ნულოვანი რადგან ყველაფერი წავიდა ჯარიმა.

113
00:06:21,540 --> 00:06:24,220
>> ჩემი სახელი არის რობ და ეს იყო Recess.

114
00:06:24,220 --> 00:06:29,184
>> [მუსიკის დაკვრა]