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
Добре. Здравейте на всички, и добре дошли Walkthrough 4.

5
00:00:11,670 --> 00:00:14,270
>> Днес нашата pset е Криминалистите.

6
00:00:14,270 --> 00:00:18,080
Криминалистите е наистина забавно 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
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
и отиваме да влязат в някои наистина забавни неща.

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
>> В разпределението код за този pset е файл, наречен резервното

32
00:01:52,080 --> 00:01:55,280
и това е какво ще да се намери ще бъде наистина полезно за нас

33
00:01:55,280 --> 00:02:00,340
защото ние сме в крайна сметка ще копиране на резервното файл

34
00:02:00,340 --> 00:02:05,350
и просто да го променя леко, за да бъде в състояние да постигне първите две части на проблема набор.

35
00:02:05,350 --> 00:02:09,030
>> И така както споменах преди, ние се занимаваме с растерни изображения, както и 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 и растерни файлове и разбирането на структурата на тези.

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 е криминале, в която сте растерно файл

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
действително ще преоразмеряване, че растерна графика от тази целочислена стойност.

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 и неуспешно,

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
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
Така че ние имаме указател FILE *.

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" за писане, а след това "а" за добавяне.

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
Първо трябва да включва указател към структура, която ще съдържа байтове, които вие четете.

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 също е много подобно на неуспешно,

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
Да кажем, че имате куче структура и след това искам да прочета две кучета в даден момент.

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
Можете да дръпнете определенията в ръководството, като въведете човек и след това неуспешно, например,

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
Така че, отново неуспешно, когато имате файл, който искате да напишете,

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 по същество просто сложи един символ в даден момент, хр,

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
Добре. Като стигнем в повече примери, не се колебайте да ме спре за въпроси.

131
00:08:59,990 --> 00:09:06,930
>> Така че в криминале, ти подаде растерна графика файл, подобен на този червен на слайда,

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
, Така че потребителят да въведете криминале, тогава представа, 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
>> Тъй като ние ще трябва да се занимават с редактиране и манипулиране на растерни изображения от някакъв вид,

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
Bitmaps по същество са просто подреждане на байтове

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
Имаме тези RGB тройки.

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
Когато отидем в подложка по-късно, ще видим защо размера на изображението

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
се капсулират в структурата.

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
Първият от тях е в размер на синьо в пиксел, вторият е в размер на зелено,

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
Това е вид обратното на обикновено, когато казваме, RGB. Всъщност се случва BGR.

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
Гледам, и можем да видим, е пикселизирани. Тя изглежда като блокове на цвета.

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
Тогава какво това се превръща в растерна графика е както следва.

189
00:14:08,060 --> 00:14:15,710
Тук имаме първите бели пиксели, че всички шест са е, и след това имаме червени пиксела,

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
така че можете да вид, ако кривогледство малко, как този вид показва усмивка на лицето.

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
Тогава бих добавила нещо, което се обаждате подложка.

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
Значи, това, което трябва да направите, е да добавите само малко на подложка

210
00:16:25,600 --> 00:16:29,430
за да се уверите, че всички от широчините са еднакви

211
00:16:29,430 --> 00:16:34,260
и че всички от широчините са кратен на 4.

212
00:16:42,110 --> 00:16:47,310
И така аз се посочва, подложки като х или деформирано линия,

213
00:16:47,310 --> 00:16:53,880
но в реалните растерни изображения подложка е обозначено с шестнадесетичен 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
Това, което трябва да направите, е тук, показват, че като S 54

221
00:17:33,810 --> 00:17:36,530
казва, че аз ще започне в 54-ата байт

222
00:17:36,530 --> 00:17:40,820
защото преди това, не забравяйте, ако погледнем назад към картата на растерни изображения,

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 широк е да добавите допълнително подложка.

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
по същество като малък растерна графика, а след това неговото увеличаване с 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
>> Добре. Всякакви въпроси за подложка?

241
00:19:25,150 --> 00:19:27,460
Добре. Cool.

242
00:19:27,460 --> 00:19:32,520
>> Както споменах и преди, растерни изображения са само поредица от байтове.

243
00:19:32,520 --> 00:19:39,170
И така, това, което имаме, е, вместо да се налага да следите точно кой номер на байт

244
00:19:39,170 --> 00:19:47,050
съответства на определен елемент, ние всъщност са създали структура да представлява това.

245
00:19:47,050 --> 00:19:50,930
Така че това, което имаме, е RGBTRIPLE структура.

246
00:19:50,930 --> 00:19:54,590
Винаги, когато имате една инстанция на RGB тройна,

247
00:19:54,590 --> 00:20:00,970
защото това е вид определят структурата, след това можете да получите достъп до 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
тогава какъв цвят би това специално RGB тройна? >> Студент Грийн.

253
00:20:27,870 --> 00:20:29,150
Грийн. Точно така.

254
00:20:29,150 --> 00:20:34,480
Това ще бъде полезно да се знае, че ако имате например на RGB тройна,

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.

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 структура.

266
00:21:40,500 --> 00:21:46,840
Имаме rgbtBlue, Green и Red, свързани с нея.

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
Извинете. Помислете за криминале.

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
Какво резервното прави е просто прави точно копие на даден файл на растерна графика, а след това да подава.

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
имената на файловете тук.

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
отиваме да се сложат бе това, което четем от показалка, която е нашата 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
и четеш тези битове и байтове, и ние сме ги включите директно в

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
информация 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
Ето, не забравяйте, ние говорихме за подложка,

311
00:25:38,510 --> 00:25:47,820
колко е важно да се уверите, че размерът на пикселите, които имаме, е кратен на 4.

312
00:25:47,820 --> 00:25:52,790
Това е доста полезно формула, за да изчисли колко подложка имате

313
00:25:52,790 --> 00:25:57,670
даден на ширината на вашия файл.

314
00:25:57,670 --> 00:26:04,120
Искам вие да запомните, че в резервното имаме формула за изчисляване на подложка.

315
00:26:04,120 --> 00:26:07,970
Добре? Така че всеки помни това. Велики.

316
00:26:07,970 --> 00:26:14,050
Тогава какво резервното следващия е итерации над всички на 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
Значи тук ние четеш само един RGB тройна в даден момент

320
00:26:33,120 --> 00:26:39,860
и след това същата тази тройна в outfile.

321
00:26:41,120 --> 00:26:48,340
Трудната част е, че уплътнението не е RGB тройна,

322
00:26:48,340 --> 00:26:55,200
и затова не може просто да прочетете тази подложка размера на тройки RGB.

323
00:26:55,200 --> 00:27:01,460
Това, което трябва да направите, е всъщност само се движи нашата индикатор за положение файл, да се движи нашата курсора,

324
00:27:01,460 --> 00:27:06,840
да прескачам подложка, така че ние сме в следващия ред.

325
00:27:06,840 --> 00:27:12,990
И тогава какво прави това е копие, което показва как може да искате да добавите подложка.

326
00:27:12,990 --> 00:27:14,990
Така че ние сме изчислява колко подложка имаме нужда,

327
00:27:14,990 --> 00:27:18,220
така че това означава, че ние трябва подложка броя на 0s.

328
00:27:18,220 --> 00:27:24,510
Това не е цикъл, който поставя подложка броя на 0s в нашия outfile.

329
00:27:24,510 --> 00:27:31,170
И накрая, да затворите двата файла. Затваряте infile, както и outfile.

330
00:27:31,170 --> 00:27:34,870
>> Ето как резервното работи,

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
CP резервното 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
за нашето криминале файл.

339
00:28:08,500 --> 00:28:14,670
>> Това са ни до-DOS да направя за криминале, но какво резервното

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
>> Добре. Така че това е криминале.

359
00:29:26,420 --> 00:29:32,760
След като стартирате криминале, вие ще знаете кой е виновника на престъплението.

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
когато това е в основата infile мащабират от N.

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
така три пъти, а след това да го мащабирате три пъти, както добре.

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
знаейки, че когато четем във файловете Ако работите на резервното рамка,

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
Не забравяйте, че ако имате структурата, начина за достъп до променливи в това.

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
Така че отново се връща към картата на растерни изображения,

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
Отново, да речем CP резервното 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
Освен сега, вместо просто промяна на стойности, както направихме в криминале,

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, а имате предвид infile.

400
00:32:56,890 --> 00:32:58,730
Курсорът ще започне в първия,

401
00:32:58,730 --> 00:33:03,530
и това, което искате да направите, ако N е 2, искате да се отпечата в два от тези.

402
00:33:03,530 --> 00:33:05,490
Така че, да печатате в две от тези.

403
00:33:05,490 --> 00:33:10,830
Тогава курсорът ще се премести към следващото пиксела, която е червена,

404
00:33:10,830 --> 00:33:18,400
и ще отпечата две от тези червените, да го положат върху това, което е правил досега.

405
00:33:18,400 --> 00:33:26,280
Тогава курсорът ще се премести към следващото пиксел и изготвя в два от тези.

406
00:33:26,280 --> 00:33:37,180
Ако погледнем назад към резервното рамка, какво прави тук

407
00:33:37,180 --> 00:33:42,830
се създава нова инстанция на RGB тройни, нова променлива, наречена тройна.

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
Значи всъщност трябва променлива, представляваща този конкретен пиксел.

411
00:33:57,590 --> 00:34:05,290
Тогава, когато ти пиша, какво може да искате да направите, е оградете неуспешно отчет за контур

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
>> Но тогава ние трябва да помним, че нашата подложка няма да се промени.

416
00:34:47,350 --> 00:34:53,020
Преди да кажем, че има нещо с дължина 3.

417
00:34:53,020 --> 00:35:00,130
Тогава ние ще трябва само да добавите в колко подложка? Само още един, за да го кратен на 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. Какво е най-близкото кратно на четири? Това ще бъде 8.

422
00:35:26,580 --> 00:35:33,200
Така че ние всъщност се случва там да има 2 знака на подложка.

423
00:35:33,200 --> 00:35:38,720
>> Има ли някой помни ако имаме формула за изчисляване подложка

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
Има формула в резервното да се изчисли колко подложка имате

427
00:35:49,800 --> 00:35:53,810
определена ширина на растерно изображение.

428
00:35:53,810 --> 00:36:02,950
Така че това ще бъде полезно, когато трябва да добавите в определен период на подложка

429
00:36:02,950 --> 00:36:06,160
действително да разбера колко подложка, което трябва да се добави.

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, който искате да използвате ширината на 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
Както вид намекна, има няколко различни начина да направите това.

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
и да пренапише линия? >> [Ученик] - 1. >> Да, перфектно. 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
Добре. Така че има ли функция за преоразмеряване.

456
00:38:25,860 --> 00:38:34,360
>> Сега можем да стигнем до наистина забавната част, любимата ми pset, което е Възстановяване.

457
00:38:34,360 --> 00:38:39,580
Вместо на растерни изображения, този път си имаме работа с JPEG файлове.

458
00:38:39,580 --> 00:38:43,370
Ние всъщност не сме получили файл само на JPEG файлове,

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
Това определено може да са малко по-сложни, ако не беше в този формат.

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
започва с последователността ffd8 ffe0 или другата, ffd8 ffe1.

471
00:39:52,720 --> 00:39:59,530
Друг полезен нещо, което трябва да знаете е, че JPEG файлове се съхраняват Последователно.

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
Друго нещо, за JPEG файлове е, че ние може да ги прочете в поредици от 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
имате ценности, които наистина не са свързани с действителните самите JPEG файлове.

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
И тогава ще бъде някои кратно на 512 байта всеки файл, JPEG

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
друга поредица от байтове.

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 започва, всички на JPEG файлове се съхраняват редом един до друг.

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
Ако сме удари една звезда, ако сме си удари една от изходните последователности,

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
тогава ще основно трябва неопределен размер. JPEG файлове никога няма да свърши.

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
Подобно на ФОРМАТ, който просто разпечатки стойност в терминала,

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 изисква втория файл, JPEG трябва да се именуват 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. >> Да, перфектно.

550
00:46:22,530 --> 00:46:25,610
Ще сложи 3 в този случай, защото искаме пространство за 3.

551
00:46:25,610 --> 00:46:32,590
3D% вероятно ще ви даде 002.jpg вместо два.

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
Така че има три 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
>> И аз съм свършил с Walkthrough 4, така че благодаря на всички, че дойдохте.

594
00:50:23,970 --> 00:50:29,330
Успех с Криминалистите. [Аплодисменти]

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