1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Walkthrough - პრობლემა Set 4]

2
00:00:02,700 --> 00:00:05,000
[Zamyla Chan - ჰარვარდის უნივერსიტეტი]

3
00:00:05,000 --> 00:00:07,340
[ეს არის CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
ყველა უფლება. Hello, ყველას, და მივესალმები რომ Walkthrough 4.

5
00:00:11,670 --> 00:00:14,270
>> დღეს ჩვენი pset არის სასამართლო ექსპერტიზის.

6
00:00:14,270 --> 00:00:18,080
სასამართლო ექსპერტიზის მართლაც fun pset რომელიც მოიცავს საქმე Bitmap ფაილი

7
00:00:18,080 --> 00:00:21,550
აღმოჩენა, რომლებმაც ჩაიდინეს დანაშაული.

8
00:00:21,550 --> 00:00:24,200
მაშინ ჩვენ ვაპირებთ შემცირება გარკვეული Bitmap ფაილი

9
00:00:24,200 --> 00:00:27,780
მაშინ ჩვენ ასევე ვაპირებთ გაუმკლავდეთ მართლაც fun ნაწილი მოუწოდა აღდგენა,

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
Quiz 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
და ჩვენ ვაპირებთ შეღწევას ზოგიერთი მართლაც fun stuff.

19
00:01:00,760 --> 00:01:07,070
>> ასე რომ ჩვენი ყუთისთვის ამ pset, კიდევ ერთხელ, ნაცვლად გაშვებული 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
ჩვენ ვაპირებთ იყოს საქმე ფაილის საშუალებებით და შედეგები, ფაილის I / O.

27
00:01:34,350 --> 00:01:38,140
ჩვენ ვაპირებთ იყოს აპირებს მეტი ბევრი პროგრამების, რომ გაუმკლავდეთ კოლექტორები

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
>> In განაწილების კოდი ამ 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 და 1s შევიდა structs

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 და bitmap ფაილი და გაგება სტრუქტურა იმ.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, როგორც ყოველთვის, იწყება მონაკვეთზე კითხვები.

42
00:02:30,780 --> 00:02:36,600
იმ იმუშავებს ფაილის I / O და მისაღებად თქვენ მიჩვეული რომ.

43
00:02:36,600 --> 00:02:42,520
შემდეგ ნაწილი 1 არის Whodunit, რომელშიც თქვენ მოცემული Bitmap ფაილი

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
მაშინ Resize არის პროგრამა, რომელიც, მოცემულ ფაილი

50
00:03:07,310 --> 00:03:11,490
და შემდეგ სახელს ფაილი, რომ ეს მასალები და შემდეგ მიცემული ხმების ისევე,

51
00:03:11,490 --> 00:03:16,850
რეალურად შეცვლის, რომ bitmap მიერ, რომ მთელი მნიშვნელობა.

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
>> დიდი. ასე მიდის ფაილის I / O კონკრეტულად, ეს არის მთელი სია ფუნქციები რომ თქვენ გამოიყენებთ.

58
00:03:44,950 --> 00:03:49,840
თქვენ უკვე ჩანს ცოტა საფუძვლები fopen, fread და fwrite,

59
00:03:49,840 --> 00:03:54,350
მაგრამ ჩვენ ვაპირებთ შევხედოთ შემდგომი შევიდა ზოგიერთი ფაილის I / O ფუნქციები, როგორიცაა fputc,

60
00:03:54,350 --> 00:03:56,930
რომელშიც თქვენ უბრალოდ დაწერეთ ერთი ხასიათი დროს,

61
00:03:56,930 --> 00:04:02,000
to fseek, სადაც სახის გადაადგილება ფაილი თანამდებობა მაჩვენებელი ფორვარდები და უკან,

62
00:04:02,000 --> 00:04:05,770
და შემდეგ რამდენიმე სხვა. მაგრამ ჩვენ წასვლას რომ მოგვიანებით დროს pset.

63
00:04:08,050 --> 00:04:13,100
>> ასე რომ, პირველი, მხოლოდ შეღწევას ფაილის I / O სანამ წასვლას 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
ასე რომ არსებობს "რ" ამ შემთხვევაში წასაკითხად, "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
მაშინ თქვენ ალბათ აპირებს გინდათ გამოიყენოთ "რ", როგორც თქვენი რეჟიმში.

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
თქვათ, რომ DOG struct და ასე შემდეგ მინდა წაიკითხონ ორი ძაღლები დროს.

90
00:06:06,810 --> 00:06:12,450
რა შეიძლება არ არის ამბობენ ზომის ერთ ელემენტს იქნება ზომა ერთი DOG

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
წელს ტერმინალი, ან შეგიძლიათ ეხება უკან ამ slide

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
როგორც ვნახავთ, მოგვიანებით ამ მაგალითად, bitmaps ჩვენ უნდა გამოვიყენოთ, რომ.

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, ნებისმიერი შეკითხვა ფაილის I / O?

130
00:08:53,860 --> 00:08:59,990
Okay. როგორც მივიღებთ უფრო მაგალითები, მოგერიდებათ შემაჩერებს შეკითხვებზე.

131
00:08:59,990 --> 00:09:06,930
>> ასე რომ Whodunit, თქვენ გადასცა Bitmap ფაილი მსგავსი ამ წითელი ერთი slide,

132
00:09:06,930 --> 00:09:14,510
და ეს ასე გამოიყურება - bunch წითელი წერტილები - და თქვენ ნამდვილად არ ვიცი რა წერია.

133
00:09:14,510 --> 00:09:23,310
თუ თქვენ squint, თქვენ შეიძლება ნახოს უმნიშვნელო bluish ფერი შიგნით ახლო.

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
სადაც თქვენ ექნება magnifying მინის ერთად წითელი ფილმი. ვინმე? Yeah.

139
00:09:48,510 --> 00:09:52,770
ასე რომ თქვენ გადაეცემა მსგავსი რამ, თქვენ ექნება magnifying მინის

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
ჩვენ არ გვაქვს magnifying მინის წითელი ფილმი, ასე რომ ნაცვლად ჩვენ ვაპირებთ სახის შევქმნათ ჩვენი

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, რომ წითელი dot გაგზავნა,

146
00:10:18,800 --> 00:10:23,550
და მაშინ ისინი ამბობენ verdict.bmp იქნება ჩვენი outfile.

147
00:10:23,550 --> 00:10:27,900
ამიტომ აპირებს შექმნას ახალი bitmap გამოსახულება მსგავსი ნახავ ერთი

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
ჩვენ ვაპირებთ სახის Dive in შევიდა სტრუქტურის ამ Bitmap ფაილი.

151
00:10:42,400 --> 00:10:48,130
წავედით ამ ცოტა ლექციების, მაგრამ მოდით წავიკითხოთ შევიდა მათ კიდევ რამდენიმე.

152
00:10:48,130 --> 00:10:51,740
Bitmaps ძირითადად მხოლოდ მოწყობის ბაიტი

153
00:10:51,740 --> 00:10:55,790
აქ ჩვენ მითითებული რომელიც bytes ნიშნავს რა.

154
00:10:55,790 --> 00:11:00,540
ასე რომ აქ არის სახის მოსწონს რუკაზე bitmap გამოსახულება

155
00:11:00,540 --> 00:11:08,550
რომ ეს იწყება რამდენიმე header ფაილი იწყება გარკვეული ინფორმაცია იქ.

156
00:11:08,550 --> 00:11:16,540
თქვენ ხედავთ, რომ დაახლოებით ერთი ბაიტი ნომერი 14 ზომა მითითებულია of bitmap გამოსახულება,

157
00:11:16,540 --> 00:11:18,520
და ეს გრძელდება.

158
00:11:18,520 --> 00:11:23,810
მაგრამ მაშინ რა ჩვენ ნამდვილად დაინტერესებულია აქ იწყება გარშემო byte ნომერი 54.

159
00:11:23,810 --> 00:11:26,060
ჩვენ გვყავს ამ RGB საწოლიანი.

160
00:11:26,060 --> 00:11:30,760
რა, რომ აპირებს გააკეთოთ შეიცავდეს ფაქტობრივი პიქსელი, ფერი ღირებულებებს.

161
00:11:30,760 --> 00:11:35,950
ყველაფერი ზემოთ რომ header არის გარკვეული ინფორმაცია

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
ასე შემდეგ წარმოადგენენ ამ - ამ bitmap გამოსახულებები sequences ბაიტების -

166
00:11:54,240 --> 00:11:59,370
რაც ჩვენ შეიძლება არ არის ამბობენ okay, მე ვაპირებ გვახსოვდეს, რომ ინდექსი 14,

167
00:11:59,370 --> 00:12:03,380
რომ სადაც ზომა არის, მაგალითად, არამედ ის, რასაც ჩვენ ვაპირებთ გავაკეთოთ იმისთვის, რომ ეს ადვილია

168
00:12:03,380 --> 00:12:06,020
არის encapsulate ის struct.

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
და მაშინ საბოლოოდ, ყველა pixel წარმოდგენილია სამი ბაიტი.

174
00:12:31,230 --> 00:12:35,500
პირველი ის არის, თანხის ლურჯი in pixel, მეორე არის თანხის მწვანე,

175
00:12:35,500 --> 00:12:41,120
და ბოლოს, თანხის წითელი, სადაც 0 არის არსებითად არ ლურჯი ან არა მწვანე ან არა წითელი

176
00:12:41,120 --> 00:12:43,720
და მაშინ FF არის მაქსიმალური მნიშვნელობა.

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
და მაშინ არ მწვანე და არ წითელი, ასე შემდეგ, რომ მოგვცეს ლურჯი pixel.

180
00:12:58,890 --> 00:13:04,190
თუ ჩვენ გვაქვს ff ს მთელს ფორუმში, მაშინ ეს იმას ნიშნავს, რომ ჩვენ გვაქვს თეთრი pixel.

181
00:13:04,190 --> 00:13:11,370
ეს არის სახის საპირისპიროდ, როგორც წესი, როდესაც ჩვენ ვამბობთ, RGB. სინამდვილეში აპირებს BGR.

182
00:13:12,750 --> 00:13:18,990
>> ასე რომ, თუ ჩვენ რეალურად შესასწავლად მაგალითი bitmap გამოსახულება - ნება მომეცით გაიყვანოს ერთი აქ.

183
00:13:31,560 --> 00:13:33,830
ეს პატარა პატარა.

184
00:13:39,890 --> 00:13:47,840
მე zooming in, და ვხედავთ მას pixelated. როგორც ჩანს ბლოკები ფერი.

185
00:13:47,840 --> 00:13:50,110
თქვენ გაქვთ თეთრი ბლოკები და შემდეგ წითელი ბლოკები.

186
00:13:50,110 --> 00:13:53,700
თუ თქვენ ითამაშოს Microsoft Paint, მაგალითად, თქვენ შესაძლოა რაღაც მსგავსი

187
00:13:53,700 --> 00:13:58,960
მიერ ძირითადად მხოლოდ ხატვის გარკვეული სკვერების კონკრეტული მიზნით.

188
00:13:58,960 --> 00:14:08,060
ასეა, მაშინ რა ამ ითარგმნება ამ bitmap ასეთია.

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
და ა.შ. თანმიმდევრობა bytes რომ ჩვენ გვაქვს მიუთითებს როგორ bitmap გამოსახულება აპირებს გამოიყურებოდეს.

192
00:14:27,940 --> 00:14:32,230
მერე რა მე ვაკეთებ აქ არის მხოლოდ წერილობითი ყველა იმ bytes და შემდეგ ფერადი წითელ

193
00:14:32,230 --> 00:14:37,550
ასე რომ თქვენ შეგიძლიათ სახის ვხედავთ, თუ squint ცოტა, როგორ ასეთი სახის მიუთითებს smiley face.

194
00:14:40,180 --> 00:14:46,390
>> ისე, რომ Bitmap images მუშაობა მე გვჯერა ეს ძირითადად, როგორც ბადე.

195
00:14:46,390 --> 00:14:54,940
და ასე იყოს, ყოველ გრაფაში ქსელის უნდა იყოს ჯერადი 4 ბაიტი.

196
00:15:00,520 --> 00:15:07,060
თუ დავაკვირდებით bitmap გამოსახულება, თქვენ შევსების ყველა ღირებულება.

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
მე უბრალოდ აპირებს მიუთითებს, რომ იქ x.

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
ისე, რომ Bitmap images მუშაობა არის ის, რომ ჩვენ გვჭირდება მე -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 ფართების bitmap გამოსახულება იკითხება სწორად.

209
00:16:19,360 --> 00:16:25,600
ასე შემდეგ, რაც ჩვენ უნდა გავაკეთოთ არის ის რომ დაამატოთ რაღაც ცოტა padding

210
00:16:25,600 --> 00:16:29,430
დავრწმუნდეთ, რომ ყველა widths are უნიფორმა

211
00:16:29,430 --> 00:16:34,260
და რომ ყველა widths are ჯერადი 4.

212
00:16:42,110 --> 00:16:47,310
და მე ადრე მითითებული, დასატენი როგორც x ან squiggly ხაზი,

213
00:16:47,310 --> 00:16:53,880
მაგრამ ფაქტობრივი Bitmap images padding მითითებულია მიერ თექვსმეტობითი 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
რა ეს იმას ფაქტიურად გიჩვენებთ, ისევე როგორც მსგავსი რა მე ადრე ერთად smiley

217
00:17:11,220 --> 00:17:15,630
როცა რეალურად დაბეჭდილი რა თითოეული ფერი იქნებოდა ამისთვის pixel

218
00:17:15,630 --> 00:17:21,800
და შემდეგ ფერი კოდირებული, როდესაც თქვენ აწარმოებს xxd შემდეგი ბრძანებები,

219
00:17:21,800 --> 00:17:28,670
მაშინ რეალურად ბეჭდვა რა ფერის არის მათთვის, pixels.

220
00:17:28,670 --> 00:17:33,810
რა უნდა გააკეთოთ მეტი აქ მიუთითებს, როგორიც-s 54

221
00:17:33,810 --> 00:17:36,530
ამბობს, რომ მე ვაპირებ დაიწყება 54TH byte

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
ამიტომ დანამატის ამ დროშას,-s 54, მაშინ ჩვენ ნახოს ფერი ღირებულებებს.

226
00:17:52,700 --> 00:17:56,020
და არ ინერვიულოთ რთული დროშებით და რამ, როგორიცაა, რომ.

227
00:17:56,020 --> 00:18:05,020
პრობლემის კომპლექტი Spec, თქვენ მიმართულებების შესახებ თუ როგორ გამოიყენოთ xxd ცარიელია pixels.

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
ეს რეალურად იყოს შედეგად თქვენი Resize pset,

236
00:18:54,510 --> 00:19:01,350
არსებითად აღების მცირე bitmap და შემდეგ გაფართოების იგი 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
რადგანაც ეს მთლიანად padded. ეს არ აქვს მეტი ოთახი.

240
00:19:20,720 --> 00:19:23,470
>> Okay. რაიმე კითხვა padding?

241
00:19:25,150 --> 00:19:27,460
Okay. ზემოთ.

242
00:19:27,460 --> 00:19:32,520
>> როგორც აღვნიშნე ადრე, bitmaps მხოლოდ თანმიმდევრობა bytes.

243
00:19:32,520 --> 00:19:39,170
და ა.შ. რაც გვაქვს არის ნაცვლად სჭირდება შენარჩუნება ტრეკზე ზუსტად რომელიც ხმების byte

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
როდესაც თქვენ გაქვთ ინსტანციის RGB triple,

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, მწვანე კომპლექტი ff,

251
00:20:16,800 --> 00:20:22,060
რაც მაქსიმალური მნიშვნელობა შეგიძლიათ, შემდეგ კი წითელი ცვლადი მითითებული 0,

252
00:20:22,060 --> 00:20:27,870
მაშინ რა ფერი იქნებოდა ამ კონკრეტულ RGB სამმაგი წარმოადგენს? >> [სტუდენტი] მწვანე.

253
00:20:27,870 --> 00:20:29,150
მწვანე. სწორედ.

254
00:20:29,150 --> 00:20:34,480
ეს იქნება სასარგებლო იცოდეთ, რომ როდესაც თქვენ გაქვთ ინსტანციის RGB triple,

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
>> დიდი. Okay.

268
00:21:49,340 --> 00:21:56,360
ახლა, როდესაც ჩვენ გვესმის bitmaps ცოტა, გვესმოდეს, რომ ჩვენ გვაქვს ფაილის header

269
00:21:56,360 --> 00:22:00,790
და ინფორმაციის header ასოცირდება და მერე ამის შემდეგ, ჩვენ გვაქვს საინტერესო პერსონალის

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
>> ასე რომ ახლა შეგვიძლია სახის ვიფიქროთ აღდგენა bit.

273
00:22:17,270 --> 00:22:20,130
უკაცრავად. იფიქრეთ Whodunit.

274
00:22:20,130 --> 00:22:25,750
როცა ჩვენ გვაქვს ჩვენი ნახავ ფაილი, მაშინ ის, რაც ჩვენ გვსურს რომ არის წაიკითხონ მას pixel მიერ pixel

275
00:22:25,750 --> 00:22:33,860
და მერე რაღაცნაირად შეცვლის იმ პიქსელი ისე, რომ ჩვენ შეგვიძლია დაბეჭდავს იგი იკითხება ფორმატში.

276
00:22:33,860 --> 00:22:41,020
და ასე დაბეჭდავს, ჩვენ ვაპირებთ დავწეროთ pixel მიერ pixel შევიდა 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 არ არის მხოლოდ ხდის ზუსტი ასლი მოცემული Bitmap ფაილი და შემდეგ შედეგები იგი.

280
00:22:57,610 --> 00:23:01,900
ასე რომ, ეს უკვე ხსნის ფაილი თქვენთვის, ნათქვამია in pixel მიერ pixel,

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
აბა რა ეს იმას აქ, უბრალოდ ძირითადად იწყება კითხულობს, რათა Bitmap ფაილი დასაწყისია.

290
00:23:53,270 --> 00:23:56,700
დასაწყისში, როგორც ვიცით, შეიცავს BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
და ასე იმ sequences ბიტების იქნება პირდაპირ შეავსოთ 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
ანალოგიურად, რომ ის, რასაც ჩვენ გავაკეთებთ ამისთვის ინფორმაცია header.

298
00:24:34,660 --> 00:24:39,010
ამიტომ ჩვენ ვაგრძელებთ გასწვრივ ჩვენი ფაილის infile,

299
00:24:39,010 --> 00:24:44,360
და ჩვენ კითხულობს იმ ბიტი და ბაიტი და ჩვენ ჩართვის მათ პირდაპირ

300
00:24:44,360 --> 00:24:47,880
შევიდა ამ ინსტანციის ცვლადები, რომ ჩვენ მიღების.

301
00:24:49,370 --> 00:24:53,800
აქ ჩვენ უბრალოდ მიღების დარწმუნებული ვარ, რომ bitmap არის Bitmap.

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
ამიტომ, ჩვენ უნდა შევქმნათ ძირითადად ახალი bitmap ნულიდან.

305
00:25:07,710 --> 00:25:12,280
რას ვაკეთებთ არის ჩვენ უნდა დავრწმუნდეთ, რომ ჩვენ ასლი ფაილი header

306
00:25:12,280 --> 00:25:16,850
და ინფორმაციის header ისევე 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
ეს არის საკმაოდ სასარგებლო formula გამოთვლა რამდენად padding გაქვთ

313
00:25:52,790 --> 00:25:57,670
მოცემული სიგანე თქვენი ფაილი.

314
00:25:57,670 --> 00:26:04,120
მინდა ბიჭები უნდა გვახსოვდეს, რომ copy.c გვაქვს formula გაანგარიშების padding.

315
00:26:04,120 --> 00:26:07,970
Okay? ასე ყველას გვახსოვდეს, რომ. დიდი.

316
00:26:07,970 --> 00:26:14,050
ასეა, მაშინ რა copy.c აკეთებს შემდეგი არის ის iterates მეტი ყველა scanlines.

317
00:26:14,050 --> 00:26:23,730
იგი გადის რიგები და შემდეგ ინახავს ყველა triple, რომ ეს ნათქვამია

318
00:26:23,730 --> 00:26:26,920
და შემდეგ წერს იგი outfile.

319
00:26:26,920 --> 00:26:33,120
ასე შემდეგ აქ ჩვენ კითხულობს მხოლოდ ერთი RGB სამმაგი დროს

320
00:26:33,120 --> 00:26:39,860
და შემდეგ აყენებს, რომ იგივე სამმაგი შევიდა outfile.

321
00:26:41,120 --> 00:26:48,340
ადვილი ნაწილი არის ის, რომ padding არ არის RGB triple,

322
00:26:48,340 --> 00:26:55,200
და ა.შ. ჩვენ არ შეგვიძლია უბრალოდ წაიკითხა, რომ padding თანხის RGB საწოლიანი.

323
00:26:55,200 --> 00:27:01,460
რა უნდა გავაკეთოთ, ფაქტობრივად მხოლოდ გადავიდეს ჩვენი ფაილი თანამდებობა მაჩვენებელი გადატანა ჩვენი კურსორს

324
00:27:01,460 --> 00:27:06,840
to სახის გამოტოვოთ ყველა 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
ასე რომ იმას ნიშნავს, რომ ჩვენ გვჭირდება padding ხმების 0S.

328
00:27:18,220 --> 00:27:24,510
რა ეს იმას არის ამისთვის loop რომ აყენებს padding ხმების 0S ჩვენს outfile.

329
00:27:24,510 --> 00:27:31,170
და მაშინ საბოლოოდ, თქვენ დახურვა ორივე ფაილი. თქვენ დახურვა infile ასევე outfile.

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
ნაცვლად მხოლოდ რეალურად პირდაპირ კოპირება და pasting ეს

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
CP 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
>> ეს არის ჩვენი to-dos გავაკეთოთ ამისთვის 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
გახსოვდეთ, რომ მოცემული pixel triple, ისე მოცემული ცვლადი ტიპის 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
>> ასე რომ, როდესაც ჩვენ დაბრუნდა ჩვენი წითელი magnifying მინის მაგალითად,

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
ან იქნებ თქვენ გსურთ შეცვალოთ სხვადასხვა ფერი pixel სხვადასხვა ფერი.

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
>> Okay. ასე რომ Whodunit.

359
00:29:26,420 --> 00:29:32,760
ერთხელ თქვენ აწარმოებს Whodunit, თქვენ იცით ვინ culprit დანაშაულის იყო.

360
00:29:32,760 --> 00:29:35,540
>> ახლა ჩვენ ვაპირებთ წასვლა ზომის შეცვლა.

361
00:29:35,540 --> 00:29:37,990
ჩვენ ვაპირებთ კვლავ საქმე bitmaps.

362
00:29:37,990 --> 00:29:40,750
ის, რასაც ჩვენ ვაპირებთ გავაკეთოთ არის ჩვენ ვაპირებთ აქვს შეყვანის bitmap

363
00:29:40,750 --> 00:29:45,890
და მაშინ ჩვენ ვაპირებთ გაივლის მთელ რიგ და შემდეგ მიიღოს outfile bitmap

364
00:29:45,890 --> 00:29:51,380
აქ რომ ძირითადად ჩვენი infile მასშტაბური მიერ n.

365
00:29:54,670 --> 00:30:01,450
Say ჩემი ფაილი იყო მხოლოდ ერთი დიდი pixel.

366
00:30:01,450 --> 00:30:09,100
თუ ჩემი n იყო 3, სკალირების მიერ 3, მაშინ მინდა გავიმეორო, რომ pixel 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, ხედავთ, რომ პირველი ლურჯი pixel იქ გაიმეორა ორჯერ

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
ეს იმას ნიშნავს, რომ ჩვენი header ინფორმაციის შეიცვლება.

378
00:31:01,230 --> 00:31:03,790
და მერე რა ჩვენ გვსურს რომ არის განაახლოს header ინფორმაცია,

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
თქვენ გამოიყენოთ dot ოპერატორი, არა?

384
00:31:32,080 --> 00:31:36,420
ასეა, მაშინ გამოყენებით, რომ თქვენ იცით, რომ თქვენ უნდა შეცვალოს header ინფორმაცია.

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
შევხედოთ თუ არა ეს ფაილი სათაური, ან ინფორმაცია header რომ შეიცავს, რომ ინფორმაცია

389
00:31:57,730 --> 00:32:00,920
და შემდეგ შეცვალოს როგორც საჭიროა.

390
00:32:05,010 --> 00:32:12,470
ერთხელ, ვთქვათ CP 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 pixel მიერ pixel.

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
Say თქვენი N 2 და თქვენ ეს მოცემული infile.

400
00:32:56,890 --> 00:32:58,730
კურსორი აპირებს იწყება პირველი,

401
00:32:58,730 --> 00:33:03,530
და რა გსურთ, თუ N არის 2, გსურთ დაბეჭდე 2 იმ.

402
00:33:03,530 --> 00:33:05,490
ასე, რომ თქვენ დაბეჭდე 2 იმ.

403
00:33:05,490 --> 00:33:10,830
მაშინ კურსორი აპირებს გადავა შემდეგი pixel, რომელიც წითელი ერთი,

404
00:33:10,830 --> 00:33:18,400
და ის აპირებს ამობეჭდოთ 2 იმ წითელი პირობა, appending ის გადატანა რასაც ის გაკეთდეს ადრე.

405
00:33:18,400 --> 00:33:26,280
მაშინ კურსორი გადავა შემდეგი pixel და ჩაერთონ 2 იმ.

406
00:33:26,280 --> 00:33:37,180
თუ გადავხედავთ თავში copy.c ფარგლებში, რა ეს იმას უფლება აქ

407
00:33:37,180 --> 00:33:42,830
იგი ქმნის ახალ ინსტანციის RGB triple, ახალი ცვლადში triple.

408
00:33:42,830 --> 00:33:50,500
და აქ, როდესაც ეს ნათქვამია მივანიჭო, ნათქვამია მოხსენებაში საწყისი infile 1 RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
და ინახავს მას შიგნით რომ სამმაგი ცვლადი.

410
00:33:53,470 --> 00:33:57,590
ასეა, მაშინ თქვენ ნამდვილად აქვს ცვლადი წარმოადგენს კონკრეტულ pixel.

411
00:33:57,590 --> 00:34:05,290
მაშინ როდესაც ვწერთ, რა შეიძლება ჩვენ უნდა encase fwrite განაცხადი შევიდა ამისთვის loop

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
ასე რომ ჩვენ რეალურად აპირებს 2 გმირები padding არსებობს.

423
00:35:33,200 --> 00:35:38,720
>> ვინმეს გახსოვთ თუ გვაქვს formula გამოთვლა padding

424
00:35:38,720 --> 00:35:41,350
და სადაც ეს შეიძლება?

425
00:35:41,350 --> 00:35:45,160
[Inaudible სტუდენტი საპასუხოდ] >> Yeah, copy.c. მარჯვენა.

426
00:35:45,160 --> 00:35:49,800
არსებობს ფორმულა წელს copy.c გამოთვლა რამდენად padding გაქვთ

427
00:35:49,800 --> 00:35:53,810
მოცემულ კონკრეტულ სიგანე bitmap გამოსახულება.

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
უბრალოდ ფრთხილად, რადგან თქვენ ძირითადად იქნება საქმე ორი Bitmap images.

432
00:36:21,410 --> 00:36:23,410
თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ იყენებთ სწორი ვარიანტი.

433
00:36:23,410 --> 00:36:26,820
როდესაც თქვენ გაანგარიშების padding ამისთვის outfile, რომლის გამოყენებაც გსურთ სიგანე outfile

434
00:36:26,820 --> 00:36:29,860
და არა სიგანე წინა.

435
00:36:29,860 --> 00:36:37,240
>> დიდი. ამ ტიპის ზრუნავს გაჭიმვა მთელი bitmap გამოსახულება ჰორიზონტალურად.

436
00:36:37,240 --> 00:36:41,290
მაგრამ რაც ჩვენ გვსურს რომ რეალურად ეს მონაკვეთი ვერტიკალურად ასევე.

437
00:36:41,290 --> 00:36:48,760
ეს იქნება ცოტა trickier რადგან, როდესაც ჩვენ დასრულდა გადაწერა row

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
როგორც I ტიპის გააკეთა მინიშნება, არსებობს რამდენიმე განსხვავებული გზა ამის გაკეთება.

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. >> Yeah, სრულყოფილი. N - 1.

453
00:38:10,500 --> 00:38:14,390
ჩვენ გავაკეთეთ ეს ერთხელ უკვე, ასე რომ მაშინ ჩვენ გვინდა გავიმეოროთ, რომ დაუბრუნდეს პროცესი

454
00:38:14,390 --> 00:38:17,460
N - 1 ოდენობა ჯერ.

455
00:38:22,730 --> 00:38:25,860
Okay. ასე რომ თქვენ გაქვთ თქვენი Resize ფუნქციას.

456
00:38:25,860 --> 00:38:34,360
>> ახლა ჩვენ შეგვიძლია მოხვედრა ნამდვილად fun ნაწილი, ჩემი საყვარელი 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
და მაშინ იწყება და მას აქვს bunch of 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 ფაილები და განყოფილებიდან ფაილი bit გამოსადეგი.

467
00:39:23,990 --> 00:39:28,850
ეს ნამდვილად იქნებოდა ცოტა trickier თუ იგი არ იყო ამ კონკრეტულ ფორმატში.

468
00:39:28,850 --> 00:39:40,160
ყველა JPEG ფაილის რეალურად იწყება ორი შესაძლო sequences, ზემოთ ჩამოთვლილი.

469
00:39:40,160 --> 00:39:42,970
ძირითადად, როდესაც თქვენ გაქვთ ახალი JPEG ფაილის,

470
00:39:42,970 --> 00:39:52,720
იგი იწყება ან თანმიმდევრობა ffd8 ffe0 ან სხვა ერთი, ffd8 ffe1.

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
>> To სახის ვიზუალიზაციისთვის ეს, მე მივიღე სქემატური.

477
00:40:25,890 --> 00:40:36,910
კიდევ ერთი რამ შესახებ JPEGs არის, რომ ჩვენ შეგვიძლია წაიკითხა მათ sequences of 512 ბაიტი დროს,

478
00:40:36,910 --> 00:40:39,380
ანალოგიურად ერთად დასაწყისში ბარათი.

479
00:40:39,380 --> 00:40:43,370
ჩვენ არ უნდა მოხდეს შემოწმების თითოეული byte იმიტომ, რომ suck.

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
მაგრამ შემდეგ რა არის ვარსკვლავი მიუთითოს ერთი ორი დაწყებული sequences for 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
ისე, რომ თქვენ იცით, რომ თქვენ დააჭირეთ სხვა JPEG არის თუ მოხვდა კიდევ ერთი ვარსკვლავი,

490
00:41:32,050 --> 00:41:39,090
სხვა დაწყებული თანმიმდევრობა bytes.

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
თქვენ გაგრძელდება და მაშინ დააჭირეთ სხვა ვარსკვლავი, თქვენ მოხვდა სხვა JPEG,

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
და ეს იქნება ჩვენი ფაილი I / O ფუნქციები.

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
თუ ჩვენ მოხვდა ვარსკვლავი, თუ ჩვენ მოხვდა ერთ დაწყებული sequences,

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 ბეჭდავს ფაილის out შევიდა საქაღალდეში.

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 მოითხოვს, რომ მეორე JPEG ფაილის იქნეს დასახელებული 002 ნაცვლად მხოლოდ 2.

547
00:46:02,410 --> 00:46:09,160
ასე რომ, როდესაც თქვენ ამობეჭდოთ სახელი, მაშინ ალბათ დაგვჭირდება შეცვალოს placeholder ოდნავ.

548
00:46:09,160 --> 00:46:18,140
>> ვინმეს ახსოვს, თუ როგორ ჩვენ არ დავუშვებთ, დამატებითი ფართები როდესაც ჩვენ ბეჭდვა რაღაც?

549
00:46:18,140 --> 00:46:22,530
Yeah. >> [სტუდენტი] თქვენ დააყენა 3 შორის პროცენტით ნიშანი და 2. >> Yeah, სრულყოფილი.

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 ფუნქცია ფაქტიურად char array,

553
00:46:40,120 --> 00:46:42,520
რომელიც ჩვენ ადრე იცოდა როგორც სტრიქონები.

554
00:46:42,520 --> 00:46:50,700
იმ ნებას, სახის უფრო დროებითი შენახვის, უბრალოდ შეინახოს resultant სიმებიანი.

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 რადგან ჩვენ გვინდა, რომ მოხდეს null terminator ისევე.

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
და რომ შეიძლება იყოს ერთი ორი დაწყებული sequences.

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
და ამიტომ ეს არის სადაც ბონუს fun ნაწილი pset მოდის

578
00:49:16,430 --> 00:49:26,310
არის, რომ თქვენ კონკურენტი თქვენს სექციები მოძიების TFs in სურათები

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
>> და მე დასრულდა Walkthrough 4, ამიტომ მადლობა გადაგიხადოთ ყველა მობრძანებისათვის.

594
00:50:23,970 --> 00:50:29,330
წარმატებებს გისურვებთ კრიმინალისტთა. [ტაში]

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