1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Прохождение - Проблема 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
Хорошо. Привет всем, и добро пожаловать Пошаговое руководство 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
Викторина 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, опять же, вместо того, чтобы Суда ням-й обновление,

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
мы будем иметь дело с файлами входы и выходы, файловый ввод / вывод

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

36
00:02:09,030 --> 00:02:13,170
Так на самом деле понимания структуры как эти файлы будут организованы,

37
00:02:13,170 --> 00:02:16,170
как мы можем на самом деле переводить 0 и 1 в структурах

38
00:02:16,170 --> 00:02:19,040
и то, что мы действительно можем понять и интерпретировать и редактировать,

39
00:02:19,040 --> 00:02:21,000
что будет действительно важно,

40
00:02:21,000 --> 00:02:25,970
так происходит в JPEG и растровых файлов и понимания структуры из них.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, как обычно, начинается с раздела вопросов.

42
00:02:30,780 --> 00:02:36,600
Те, будет иметь дело с файлового ввода / вывода, и вы получите привыкли к этому.

43
00:02:36,600 --> 00:02:42,520
Тогда Часть 1 детективный роман, в котором вы дали растровый файл

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
Тогда, наконец, у нас есть Recover 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
Вы уже видели немного основы Еореп, FREAD, и FWRITE,

59
00:03:49,840 --> 00:03:54,350
но мы собираемся смотреть дальше в некотором файле ввода / вывода функций, таких как fputc,

60
00:03:54,350 --> 00:03:56,930
, в котором вы просто написать один символ за один раз,

61
00:03:56,930 --> 00:04:02,000
в FSEEK, где вы вроде переместить индикатор позиции файла вперед и назад,

62
00:04:02,000 --> 00:04:05,770
и некоторые другие. Но мы будем идти в этом немного позже, во время PSET.

63
00:04:08,050 --> 00:04:13,100
>> Итак, сначала просто попасть в файле ввода / вывода, прежде чем идти в PSET,

64
00:04:13,100 --> 00:04:19,860
, чтобы открыть файл, например, то, что вы должны сделать, это на самом деле установить указатель на файл.

65
00:04:19,860 --> 00:04:22,710
Поэтому у нас есть указатель на файл *.

66
00:04:22,710 --> 00:04:27,140
В этом случае, я звоню его в указатель, потому что это будет мой INFILE.

67
00:04:27,140 --> 00:04:33,340
И поэтому я собираюсь использовать функцию Еореп, а затем имя файла

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
Например, когда вы имеете дело с входной_файл

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

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
Скажем, у меня есть собака, структура и так, то я хочу прочитать двух собак одновременно.

90
00:06:06,810 --> 00:06:12,450
Что я могу сделать, это сказать размер одного элемента будет размер одной собаки

91
00:06:12,450 --> 00:06:14,770
и я собираюсь на самом деле читать два из них.

92
00:06:14,770 --> 00:06:18,290
Кроме того, что я мог сделать, это сказать, что я только собираюсь читать один элемент

93
00:06:18,290 --> 00:06:21,340
и что один элемент будет размером две собаки.

94
00:06:21,340 --> 00:06:24,320
Так вот аналогичная, как вы можете видов поиграть с размером и количеством

95
00:06:24,320 --> 00:06:28,250
в зависимости от того, что более интуитивно понятным для вас.

96
00:06:28,250 --> 00:06:30,810
>> Хорошо. Итак, теперь мы получим в письменном виде файлов.

97
00:06:30,810 --> 00:06:36,880
Если вы хотите записать файл, первый аргумент на самом деле, где вы читаете с.

98
00:06:36,880 --> 00:06:42,050
Так что в основном данные, которые вы собираетесь писать в файл,

99
00:06:42,050 --> 00:06:44,490
, который является из указателя в конце.

100
00:06:44,490 --> 00:06:47,670
Так что, когда вы имеете дело с PSET, убедитесь, что вы не запутались.

101
00:06:47,670 --> 00:06:50,480
Может быть, есть определение бок о бок.

102
00:06:50,480 --> 00:06:58,090
Вы можете вытащить определений в руководстве, введя мужчину, а затем FWRITE, например,

103
00:06:58,090 --> 00:06:59,950
в терминале, или вы можете обратиться к этому слайду

104
00:06:59,950 --> 00:07:03,570
и убедитесь, что вы используете правильный.

105
00:07:03,570 --> 00:07:08,700
Итак, еще раз, для FWRITE, когда у вас есть файл, который вы хотите записать в,

106
00:07:08,700 --> 00:07:14,290
что это будет последний аргумент, и что это будет указатель на этот файл.

107
00:07:14,290 --> 00:07:18,670
Итак вот как мы имеем дело с написанием, возможно, несколько байт в то время,

108
00:07:18,670 --> 00:07:21,820
но говорят, что вы просто хотите написать всего одну характера.

109
00:07:21,820 --> 00:07:25,940
Как мы увидим позже в этом, например, в растровые изображения мы должны его использовать.

110
00:07:25,940 --> 00:07:32,180
Вот тогда мы можем использовать fputc, по существу, просто положив один символ за раз, CHR,

111
00:07:32,180 --> 00:07:37,050
в указатель, и это наш из указателей нет.

112
00:07:38,700 --> 00:07:41,560
Так вот, когда мы стремимся или писать в файл,

113
00:07:41,560 --> 00:07:44,690
Файл отслеживать, где мы находимся.

114
00:07:44,690 --> 00:07:47,810
Так что это своего рода курсора, индикатор позиции файла.

115
00:07:47,810 --> 00:07:54,330
И поэтому, когда мы писать или читать снова в файл,

116
00:07:54,330 --> 00:07:56,760
файл на самом деле не помнит, где она есть,

117
00:07:56,760 --> 00:07:59,270
и так продолжается от того, где находится курсор.

118
00:07:59,270 --> 00:08:03,970
Это может быть полезно, если вы хотите, скажем, читать в определенном количестве, чтобы сделать что-то

119
00:08:03,970 --> 00:08:06,160
, а затем прочитать в следующем размере,

120
00:08:06,160 --> 00:08:10,700
но иногда мы могли бы вернуться назад или фактически начать с некоторого значения ссылки.

121
00:08:10,700 --> 00:08:16,870
Таким образом, то функция FSEEK, что он делает, это позволяет нам двигаться курсор в определенный файл

122
00:08:16,870 --> 00:08:19,680
определенное количество байт.

123
00:08:19,680 --> 00:08:24,260
И то, что мы должны сделать, это указать, где ссылки значение.

124
00:08:24,260 --> 00:08:31,520
Так что либо она движется вперед или назад от того, где в настоящее время находится курсор,

125
00:08:31,520 --> 00:08:35,750
или мы можем указать, что он просто должен двигаться в от начала файла

126
00:08:35,750 --> 00:08:37,090
или в конце файла.

127
00:08:37,090 --> 00:08:41,230
И поэтому вы можете передать в отрицательных или положительных значений к сумме,

128
00:08:41,230 --> 00:08:44,960
и что будет вид перемещения курсора вперед или назад.

129
00:08:46,170 --> 00:08:51,920
>> Прежде чем мы перейдем в другой psets, любые вопросы о файле 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 будет наш выходной файл.

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
Растровые изображения, по существу только расположение байтов

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
И так у нас есть две структуры сделали для нас, 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
Здесь мы имеем первые белые пиксели, что все 6 являются F, а затем у нас есть красные пиксели,

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 представляют? >> [Студент] Green.

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
Эти структуры для вас.

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 ЬурейеЕ структуры.

266
00:21:40,500 --> 00:21:46,840
У нас есть rgbtBlue, зеленый и красный, связанных с ним.

267
00:21:48,210 --> 00:21:49,340
>> Великий. Хорошо.

268
00:21:49,340 --> 00:21:56,360
Теперь, когда мы понимаем, растровые изображения немного, понимаем, что у нас есть файл заголовка

269
00:21:56,360 --> 00:22:00,790
и информация заголовков, связанных с ним, а затем после этого, у нас есть интересные вещи

270
00:22:00,790 --> 00:22:05,110
цветов, и эти цвета представлены RGBTRIPLE структуры,

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
Что copy.c делает, это просто делает точную копию данного растровый файл, а затем выводит его.

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
Что это делает он задает входной файл, то, что мы прошли в России в входной_файл здесь,

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
Проверяет, чтобы убедиться, что мы можем сделать новый выходной файл здесь.

289
00:23:45,630 --> 00:23:53,270
Затем, что она делает здесь, это только в основном начинает читать, чтобы растровый файл с самого начала.

290
00:23:53,270 --> 00:23:56,700
В начале, как мы знаем, содержит BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
и поэтому эти последовательности битов будет напрямую заполнить BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Итак, что мы имеем здесь говорят, что BITMAPFILEHEADER BF -

293
00:24:07,940 --> 00:24:13,150
Это наша новая переменная типа BITMAPFILEHEADER -

294
00:24:13,150 --> 00:24:22,560
мы собираемся положить внутрь BF то, что мы читаем в указатель, который является нашим INFILE.

295
00:24:22,560 --> 00:24:23,970
Сколько мы читаем?

296
00:24:23,970 --> 00:24:32,160
Мы читаем в сколько байт мы должны содержаться все BITMAPFILEHEADER.

297
00:24:32,160 --> 00:24:34,660
Кроме того, это то, что мы делаем для информации заголовка.

298
00:24:34,660 --> 00:24:39,010
Таким образом, мы продолжаем вдоль нашего файла в INFILE,

299
00:24:39,010 --> 00:24:44,360
и мы читаем эти биты и байты, и мы подключить их непосредственно в

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
>> Теперь у нас есть выходной файл, верно?

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

307
00:25:16,850 --> 00:25:22,850
Что мы делаем это мы пишем - и помните, что БФ переменную

308
00:25:22,850 --> 00:25:29,300
тип BITMAPFILEHEADER, так что мы делаем, мы просто используем, что содержание

309
00:25:29,300 --> 00:25:34,980
для записи в выходной файл.

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
Я хочу вас, ребята, помните, что в copy.c у нас есть формула для расчета заполнения.

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

316
00:26:07,970 --> 00:26:14,050
Итак, что делает следующий copy.c он перебирает все Scanlines.

317
00:26:14,050 --> 00:26:23,730
Он проходит через строки, а затем хранит каждая тройка, что он читает

318
00:26:23,730 --> 00:26:26,920
а затем записывает его в выходной файл.

319
00:26:26,920 --> 00:26:33,120
Таким образом, то здесь мы читаем только один RGB тройные в то время,

320
00:26:33,120 --> 00:26:39,860
, а затем положить в тот же тройку в выходной файл.

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 в нашей выходной_файл.

329
00:27:24,510 --> 00:27:31,170
И, наконец, вы закрываете оба файла. Вы закрываете INFILE, а также выходной_файл.

330
00:27:31,170 --> 00:27:34,870
>> Так вот, как copy.c работ,

331
00:27:34,870 --> 00:27:37,430
и это будет очень полезно.

332
00:27:39,720 --> 00:27:43,750
Вместо того чтобы просто на самом деле прямого копирования и вставки

333
00:27:43,750 --> 00:27:46,800
или просто глядя на него, и набрав в то, что вы хотите,

334
00:27:46,800 --> 00:27:49,440
Вы можете просто хочу, чтобы выполнить эту команду в терминале,

335
00:27:49,440 --> 00:27:54,520
ср copy.c whodunit.c, который создаст новый файл, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
, который содержит те же содержания, как копирование делает.

337
00:27:58,330 --> 00:28:03,880
Итак, что мы можем сделать, это использовать его в качестве основы, на которой строится и редактировать

338
00:28:03,880 --> 00:28:06,900
для наших детективный роман файл.

339
00:28:08,500 --> 00:28:14,670
>> Это наши с-DOS, чтобы сделать для детективный роман, но то, что делает copy.c

340
00:28:14,670 --> 00:28:16,730
на самом деле заботится о большинстве из них для нас.

341
00:28:16,730 --> 00:28:21,900
Так что все мы должны сделать, это изменить следующий пикселей по мере необходимости

342
00:28:21,900 --> 00:28:25,920
на самом деле сделать файл для чтения.

343
00:28:25,920 --> 00:28:32,960
Помните, что для данного пиксела тройной, так что для данной переменной типа RGBTRIPLE,

344
00:28:32,960 --> 00:28:35,990
Вы можете получить доступ синие, зеленые и красные значения.

345
00:28:35,990 --> 00:28:38,670
Это собирается пригодятся, потому что, если вы можете получить к ним доступ,

346
00:28:38,670 --> 00:28:41,770
это означает, что вы также можете проверить их,

347
00:28:41,770 --> 00:28:45,430
и это означает, что вы также можете изменить их.

348
00:28:45,430 --> 00:28:49,430
>> Поэтому, когда мы вернулись в наш красно например увеличительное стекло,

349
00:28:49,430 --> 00:28:53,390
В основном, это действует как своего рода фильтр для нас.

350
00:28:53,390 --> 00:28:58,160
Итак, что мы хотим сделать, это мы хотим, чтобы фильтровать все из троек, которые входя

351
00:28:58,160 --> 00:29:01,240
Есть несколько различных способов сделать это.

352
00:29:01,240 --> 00:29:07,100
В принципе, вы можете иметь любой тип фильтра Вы хотите.

353
00:29:07,100 --> 00:29:09,890
Может быть, вы хотите изменить все красные пиксели

354
00:29:09,890 --> 00:29:13,570
или, может быть, вы хотите изменить другого цвета пикселя на другой цвет.

355
00:29:13,570 --> 00:29:15,400
Это зависит от вас.

356
00:29:15,400 --> 00:29:19,580
Помните, что вы можете проверить, какой цвет пикселя

357
00:29:19,580 --> 00:29:23,000
а затем вы можете изменить его, как вы проходите.

358
00:29:24,410 --> 00:29:26,420
>> Хорошо. Так вот детективный роман.

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

364
00:29:45,890 --> 00:29:51,380
где это в основном наши входной_файл масштабируется с.

365
00:29:54,670 --> 00:30:01,450
Скажем мой файл был только один пиксель большой.

366
00:30:01,450 --> 00:30:09,100
Тогда, если моя п было 3 года, масштабирование на 3, то я хотел бы повторить, что пиксель п число раз,

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
Если у вас есть п = 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
>> Так вот, если бы мы подробно псевдокод для этого, мы хотим открыть файл.

374
00:30:47,600 --> 00:30:49,880
А потом, зная, что если мы вернемся сюда,

375
00:30:49,880 --> 00:30:54,540
мы видим, что ширина выходной файл будет отличаться от ширины INFILE.

376
00:30:54,540 --> 00:30:56,130
Что это значит?

377
00:30:56,130 --> 00:31:01,230
Это означает, что наша информация заголовка изменится.

378
00:31:01,230 --> 00:31:03,790
И то, что мы хотим сделать, это обновить информацию заголовка,

379
00:31:03,790 --> 00:31:11,820
зная, что когда мы читаем в файлы, если вы работаете на copy.c рамки,

380
00:31:11,820 --> 00:31:17,570
у нас уже есть переменная, которая указывает, какой размер и тому подобные вещи.

381
00:31:17,570 --> 00:31:24,060
Поэтому, как только у вас есть, что то, что вы можете сделать, это изменить эти конкретные переменные.

382
00:31:24,060 --> 00:31:29,380
Помните, если у вас есть структура, как получить доступ к переменным в этом.

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 copy.c Изменение размера.

391
00:32:12,470 --> 00:32:19,270
Это означает, что теперь Изменение размера содержит все, что содержится внутри копию

392
00:32:19,270 --> 00:32:24,490
потому что копия дает нам способ чтения, чтобы каждая строка пиксель за пикселем.

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
тех пор, как наша п больше 1.

396
00:32:43,580 --> 00:32:47,110
>> Тогда то, что мы хотим сделать, это мы хотим, чтобы растянуть его по горизонтали на п,

397
00:32:47,110 --> 00:32:50,490
а также растянуть его по вертикали на п.

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
и что вы хотите делать, если п 2, вы хотите распечатать в 2-х из них.

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

403
00:33:05,490 --> 00:33:10,830
Тогда ваш курсор будет переходить к следующему пикселя, который является красный,

404
00:33:10,830 --> 00:33:18,400
и это будет распечатать 2 из тех красных, добавляя его на то, что он делал раньше.

405
00:33:18,400 --> 00:33:26,280
Затем курсор перемещается к следующему пикселей и сделать в 2-х из них.

406
00:33:26,280 --> 00:33:37,180
Если вы посмотрите на copy.c рамки, что она делает здесь

407
00:33:37,180 --> 00:33:42,830
оно создает новый экземпляр 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
Затем, когда вы пишете, что вы можете сделать, это закрывать FWRITE заявление в цикл

412
00:34:05,290 --> 00:34:11,080
, который записывает его в свои выходной_файл столько раз, сколько необходимо.

413
00:34:17,449 --> 00:34:20,100
Это достаточно просто.

414
00:34:20,200 --> 00:34:27,590
Просто в основном, повторяют процесс написания п число раз масштабировать его по горизонтали.

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

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
Существует формула в copy.c посчитать, сколько у вас есть обивка

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
Когда вы расчете обивка для выходного файла, который вы хотите использовать ширину выходной_файл

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

452
00:38:03,960 --> 00:38:10,500
и переписать линию? >> [Студент] п - 1. >> Да, совершенно. п - 1.

453
00:38:10,500 --> 00:38:14,390
Мы сделали это один раз уже, так что потом мы хотим повторить процесс возвращения

454
00:38:14,390 --> 00:38:17,460
п - 1 количество раз.

455
00:38:22,730 --> 00:38:25,860
Хорошо. Так что у вас есть функции изменения размера.

456
00:38:25,860 --> 00:38:34,360
>> Теперь мы можем попасть в очень интересное, мой любимый PSET, который является восстановление.

457
00:38:34,360 --> 00:38:39,580
Вместо того, растровые изображения, на этот раз мы имеем дело с 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
А потом каждый файл 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
другой, начиная последовательность байтов.

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
>> Несколько основной вынос здесь:

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
>> Некоторые псевдокод для восстановления.

502
00:42:20,420 --> 00:42:22,570
Во-первых, мы собираемся открыть нашу картотеку,

503
00:42:22,570 --> 00:42:27,500
и это будет с помощью нашего файлового ввода / вывода.

504
00:42:27,500 --> 00:42:32,430
Мы собираемся повторить следующий процесс, пока мы не достигли конца файла.

505
00:42:32,430 --> 00:42:36,450
Мы собираемся читать 512 байт за один раз.

506
00:42:36,450 --> 00:42:39,180
И то, что я сказал здесь, что мы собираемся хранить его в буфер,

507
00:42:39,180 --> 00:42:46,230
так в основном держаться за тех 512 байт, пока мы точно знаем, что с ними делать.

508
00:42:46,230 --> 00:42:50,300
Тогда то, что мы хотим сделать, это мы хотим проверить, можем ли мы попали звезда или нет.

509
00:42:50,300 --> 00:42:57,960
Если мы попали звезды, если бы мы попали одного из исходных последовательностей,

510
00:42:57,960 --> 00:42:59,980
Затем мы знаем, что мы попали в новый файл JPEG.

511
00:42:59,980 --> 00:43:08,860
Что мы хотим сделать, это мы собираемся хотите создать новый файл в нашем каталоге pset4

512
00:43:08,860 --> 00:43:14,480
продолжать делать, что файл.

513
00:43:14,480 --> 00:43:18,220
А кроме того, если мы уже сделали JPEG и раньше,

514
00:43:18,220 --> 00:43:25,620
Затем мы хотим закончить этот файл и подтолкнуть ее к pset4 папку,

515
00:43:25,620 --> 00:43:29,780
где мы будем иметь, что файл хранится, потому что если мы не указываем, что мы закончили, что JPEG файлов,

516
00:43:29,780 --> 00:43:37,290
тогда мы будем в основном имеют неопределенную сумму. 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
Как и в Printf, которые только отчасти отпечатки значения из в терминал,

539
00:45:17,480 --> 00:45:23,910
Sprintf печатает файл из в папку.

540
00:45:23,910 --> 00:45:30,870
И что же это будет делать, если у меня было Sprintf, название, а затем строка есть,

541
00:45:30,870 --> 00:45:36,660
было бы распечатать 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Если предположить, что я закрыл файлы правильно,

543
00:45:41,020 --> 00:45:47,210
, который будет содержать файл, который я писала из.

544
00:45:47,210 --> 00:45:50,320
Но дело в том, что код, который я здесь

545
00:45:50,320 --> 00:45:53,360
не вполне удовлетворяет то, что PSET требуется.

546
00:45:53,360 --> 00:46:02,410
PSET требует, чтобы второй файл JPEG должны быть названы 002, а не только 2.

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
Да. >> [Студент] Вы ставите 3 между знаком процента и 2. >> Да, совершенно.

550
00:46:22,530 --> 00:46:25,610
Вы будете ставить 3 в данном случае, потому что мы хотим пространство для 3.

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

552
00:46:32,590 --> 00:46:40,120
Первый аргумент в Sprintf функции на самом деле массив символов,

553
00:46:40,120 --> 00:46:42,520
которые мы раньше знали как строки.

554
00:46:42,520 --> 00:46:50,700
Те, воля, вид больше похож на временное хранение, просто хранить результирующую строку.

555
00:46:50,700 --> 00:46:54,950
Вы не будете действительно иметь дело с этим, но вы должны включить его.

556
00:46:54,950 --> 00:47:00,710
>> Зная, что каждое имя файла имеет номер, который занимает три символа,

557
00:47:00,710 --> 00:47:06,770
и потом. JPG, как долго этот массив может быть?

558
00:47:09,070 --> 00:47:14,310
Выбросьте номер. Сколько символов в заголовке, в названии?

559
00:47:18,090 --> 00:47:26,320
Таким образом, есть 3 хэштеги, период, 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
является то, что вы соревнуетесь в разделах найти ТФ в фотографии

579
00:49:26,310 --> 00:49:34,610
и сфотографироваться с ними, чтобы доказать, что вы сделали PSET

580
00:49:34,610 --> 00:49:37,030
и поэтому вы можете увидеть, какие сотрудники имеют в своих картинах.

581
00:49:37,030 --> 00:49:41,510
И тогда вы делаете снимки с персоналом. Иногда вам придется преследовать их вниз.

582
00:49:41,510 --> 00:49:44,680
Вероятно, некоторые из них будут пытаться убежать от вас.

583
00:49:44,680 --> 00:49:47,320
Вы сфотографироваться с ними.

584
00:49:47,320 --> 00:49:51,190
Это продолжается. Это не из-за когда PSET связано.

585
00:49:51,190 --> 00:49:53,340
Сроки будут объявлены в спецификации.

586
00:49:53,340 --> 00:49:58,060
Тогда вместе с раздела, в зависимости от раздела принимает самое фотографий

587
00:49:58,060 --> 00:50:04,430
с самого сотрудников победит довольно удивительный приз.

588
00:50:04,430 --> 00:50:08,890
Это своего рода стимул, чтобы получить pset4 закончена как можно быстрее

589
00:50:08,890 --> 00:50:10,820
потому что тогда вы можете приступить к делу

590
00:50:10,820 --> 00:50:14,570
охота на все различные CS50 сотрудников.

591
00:50:14,570 --> 00:50:17,500
Это не обязательно, хотя, так что как только вы получите фотографии,

592
00:50:17,500 --> 00:50:20,310
Затем вы закончите с pset4.

593
00:50:20,310 --> 00:50:23,970
>> И я закончил с Пошаговое руководство 4, так что спасибо всем, кто пришел.

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

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