1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Paso a paso - conxunto de problemas 4]

2
00:00:02,700 --> 00:00:05,000
[Zamyla Chan - Harvard University]

3
00:00:05,000 --> 00:00:07,340
[Esta é CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
Todo ben. Ola, todos, e ben benvida ao Paso a paso 4.

5
00:00:11,670 --> 00:00:14,270
>> Hoxe a nosa pset é Forensics.

6
00:00:14,270 --> 00:00:18,080
Forense é un pset moi divertido que implica xestionar arquivos de bitmap

7
00:00:18,080 --> 00:00:21,550
para descubrir quen cometeu un crime.

8
00:00:21,550 --> 00:00:24,200
Entón imos redimensionar algúns arquivos de bitmap,

9
00:00:24,200 --> 00:00:27,780
entón imos para xestionar unha parte moi divertido chamado recuperar,

10
00:00:27,780 --> 00:00:31,160
en que estamos, basicamente, entregoulle unha tarxeta de memoria

11
00:00:31,160 --> 00:00:34,350
en que alguén accidentalmente borrado todos os seus arquivos,

12
00:00:34,350 --> 00:00:38,860
e estamos pediu para recuperar estes arquivos.

13
00:00:38,860 --> 00:00:42,910
>> Pero, primeiro, antes de entrar na pset, realmente só quero felicitar todos.

14
00:00:42,910 --> 00:00:45,230
Estamos a piques de medio deste curso.

15
00:00:45,230 --> 00:00:50,070
0 Quiz está detrás de nós, e nós estamos en pset4, así, esencialmente, estamos a medio camiño.

16
00:00:50,070 --> 00:00:55,490
Percorremos un longo camiño, se ollar cara atrás a súa serie de exercicios, pset0 e pset1,

17
00:00:55,490 --> 00:00:57,300
para felicitar-se por tanto,

18
00:00:57,300 --> 00:01:00,760
e nós imos entrar en algunhas cousas realmente divertido.

19
00:01:00,760 --> 00:01:07,070
>> Polo tanto, a nosa caixa de ferramentas a este pset, de novo, en vez de correr o yum update-y sudo

20
00:01:07,070 --> 00:01:13,890
somos capaces de executar só update50 se está na versión 17,3 e por riba do aparello.

21
00:01:13,890 --> 00:01:17,380
Entón non se esqueza de executar update50 - é moito máis doado, algúns personaxes menos -

22
00:01:17,380 --> 00:01:20,640
estar seguro de que está na última versión do aparello.

23
00:01:20,640 --> 00:01:25,410
Especialmente é importante update50 cando comezar a usar CS50 Check.

24
00:01:25,410 --> 00:01:28,700
Entón, asegúrese de facelo.

25
00:01:28,700 --> 00:01:30,760
>> Para todas as seccións para este pset,

26
00:01:30,760 --> 00:01:34,350
imos estar lidando con entradas e saídas de arquivo, arquivo I / O.

27
00:01:34,350 --> 00:01:38,140
Nós imos estar pasando por unha serie de programas que lidan con matrices

28
00:01:38,140 --> 00:01:40,350
apuntando para arquivos e cousas así,

29
00:01:40,350 --> 00:01:43,050
por iso queremos estar seguro de que estamos realmente familiar e cómodo

30
00:01:43,050 --> 00:01:47,990
xestionar a forma de entrada e saída en arquivos.

31
00:01:47,990 --> 00:01:52,080
>> O código de distribución para este pset é un arquivo chamado copy.c,

32
00:01:52,080 --> 00:01:55,280
e iso é o que imos atopar, vai ser moi útil para nós

33
00:01:55,280 --> 00:02:00,340
porque nós imos acabar realmente copiar o ficheiro copy.c

34
00:02:00,340 --> 00:02:05,350
e só cambiando lixeiramente para ser capaz de alcanzar as 2 primeiras partes do conxunto de problemas.

35
00:02:05,350 --> 00:02:09,030
>> E entón, como dixen antes, estamos lidando con bitmaps, así como JPEGs.

36
00:02:09,030 --> 00:02:13,170
Entón, realmente comprender a estrutura como estes arquivos son organizados,

37
00:02:13,170 --> 00:02:16,170
como podemos realmente traducir os 0s e 1s en estruturas

38
00:02:16,170 --> 00:02:19,040
e as cousas que podemos realmente entender e interpretar e editar,

39
00:02:19,040 --> 00:02:21,000
que será realmente importante,

40
00:02:21,000 --> 00:02:25,970
para entrar en JPEG e arquivos de bitmap e comprender a estrutura destes.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, como de costume, comeza con unha sección de preguntas.

42
00:02:30,780 --> 00:02:36,600
Aqueles ha xestionar o ficheiro de E / S e levalo acostumado a iso.

43
00:02:36,600 --> 00:02:42,520
A continuación, parte 1 é Whodunit, en que recibe un arquivo de bitmap

44
00:02:42,520 --> 00:02:45,630
que parece moito con puntos vermellos todo.

45
00:02:45,630 --> 00:02:52,180
E entón basicamente o que imos facer é pegar este ficheiro e Edit-lo só lixeiramente

46
00:02:52,180 --> 00:02:54,010
nunha versión que podemos ler.

47
00:02:54,010 --> 00:02:56,000
Esencialmente, unha vez que termine, nós imos ter o mesmo arquivo,

48
00:02:56,000 --> 00:03:02,630
excepto nós imos ser capaces de ver a mensaxe agochada escondida por todos os puntos vermellos.

49
00:03:02,630 --> 00:03:07,310
Entón Resize é un programa que, dado un ficheiro

50
00:03:07,310 --> 00:03:11,490
e entón deu o nome do ficheiro que xera e, entón, dado un número, así como,

51
00:03:11,490 --> 00:03:16,850
vai realmente redimensionar este bitmap por ese valor enteiro.

52
00:03:16,850 --> 00:03:19,240
Entón, por fin, temos a pset recuperar.

53
00:03:19,240 --> 00:03:24,160
Recibimos unha tarxeta de memoria e logo ter que recuperar todas as fotos

54
00:03:24,160 --> 00:03:25,920
que foron borrados accidentalmente,

55
00:03:25,920 --> 00:03:31,420
mais, como veremos, non realmente excluídos e eliminados do arquivo;

56
00:03:31,420 --> 00:03:38,470
Nós medio que perdeu cando eles estaban no arquivo, pero imos recuperar iso.

57
00:03:38,470 --> 00:03:44,950
>> Grande. Entón vai en arquivo I / O, especialmente, estes son toda unha lista de funcións que estará usando.

58
00:03:44,950 --> 00:03:49,840
Xa viu un pouco o básico de fopen, fread e fwrite,

59
00:03:49,840 --> 00:03:54,350
pero imos ollar máis para un ficheiro I / O funciona como fputc,

60
00:03:54,350 --> 00:03:56,930
en que acaba de escribir un personaxe de cada vez,

61
00:03:56,930 --> 00:04:02,000
para fseek, onde tipo de mover o indicador de posición do ficheiro para adiante e cara atrás,

62
00:04:02,000 --> 00:04:05,770
e, a continuación, algúns outros. Pero nós falaremos sobre isto un pouco máis tarde, durante o pset.

63
00:04:08,050 --> 00:04:13,100
>> Entón, primeiro, só para entrar no arquivo I / O, antes de ir para o pset,

64
00:04:13,100 --> 00:04:19,860
para abrir un arquivo, por exemplo, o que ten que facer é realmente definir un punteiro para o arquivo.

65
00:04:19,860 --> 00:04:22,710
Polo tanto, temos un punteiro FILE *.

66
00:04:22,710 --> 00:04:27,140
Neste caso, eu estou chamando-o dun punteiro porque ese vai ser o meu infile.

67
00:04:27,140 --> 00:04:33,340
E así eu vou usar a función fopen e despois o nome do ficheiro

68
00:04:33,340 --> 00:04:36,360
e, a continuación, o modo en que eu vou estar lidando con o arquivo.

69
00:04:36,360 --> 00:04:42,080
Polo tanto, non hai "r", neste caso, para a lectura, "w" para a escrita, e entón "a" para engadir.

70
00:04:42,080 --> 00:04:44,270
Por exemplo, cando está lidando con un infile

71
00:04:44,270 --> 00:04:47,310
e todo o que quere facer é ler os bits e bytes almacenados alí,

72
00:04:47,310 --> 00:04:50,420
entón probablemente vai querer usar "r", como o seu modo.

73
00:04:50,420 --> 00:04:54,520
Cando queres realmente escribir, tipo de facer un novo arquivo,

74
00:04:54,520 --> 00:04:57,220
entón o que imos facer é que imos abrir o novo ficheiro

75
00:04:57,220 --> 00:05:02,410
e usar o "w" modo de escribir.

76
00:05:02,410 --> 00:05:07,540
>> Entón cando estás lendo nos arquivos, a estrutura é a seguinte.

77
00:05:07,540 --> 00:05:14,930
Primeiro incluír o punteiro para a estrutura que contén os bytes que estás lendo.

78
00:05:14,930 --> 00:05:19,830
Así que vai ser o lugar final de bytes que estás lendo.

79
00:05:19,830 --> 00:05:23,360
Está indo entón para indicar o tamaño, sabor basicamente cantos bytes

80
00:05:23,360 --> 00:05:30,100
seu programa ten que ler o ficheiro, o tamaño basicamente un elemento,

81
00:05:30,100 --> 00:05:32,620
e entón vai para especificar cantos elementos que quere ler.

82
00:05:32,620 --> 00:05:34,980
E entón, finalmente, ten que saber onde estás lendo,

83
00:05:34,980 --> 00:05:37,580
de xeito que vai ser o punteiro no.

84
00:05:37,580 --> 00:05:41,780
Eu codificados por cores estes porque fread tamén é moi semellante á fwrite,

85
00:05:41,780 --> 00:05:47,050
excepto que quere estar seguro de que use a orde correcta,

86
00:05:47,050 --> 00:05:51,960
asegúrese de que está realmente escribir ou ler o ficheiro correcto.

87
00:05:54,910 --> 00:05:58,610
>> Entón, a continuación, como antes, se temos a dimensión do elemento, así como o número de elementos,

88
00:05:58,610 --> 00:06:00,600
entón podemos xogar un pouco aquí.

89
00:06:00,600 --> 00:06:06,810
Digamos que teña unha estrutura can e entón quero ler dous cans dunha vez.

90
00:06:06,810 --> 00:06:12,450
O que eu podería facer é dicir o tamaño dun elemento que vai ser do tamaño dun can

91
00:06:12,450 --> 00:06:14,770
e eu vou realmente ler dous deles.

92
00:06:14,770 --> 00:06:18,290
Como alternativa, o que eu podería facer é dicir que eu estou indo só para ler un elemento

93
00:06:18,290 --> 00:06:21,340
e que un elemento vai ser o tamaño de dous cans.

94
00:06:21,340 --> 00:06:24,320
Entón, iso é análogo como pode tipo de xogar con tamaño e número

95
00:06:24,320 --> 00:06:28,250
dependendo do que é máis intuitivo para ti.

96
00:06:28,250 --> 00:06:30,810
>> Todo ben. Entón, agora temos de ficheiros escrita.

97
00:06:30,810 --> 00:06:36,880
Cando se quere escribir un arquivo, o primeiro argumento é realmente onde está lendo.

98
00:06:36,880 --> 00:06:42,050
Entón é iso, basicamente, os datos que vai escribir para o arquivo,

99
00:06:42,050 --> 00:06:44,490
Que é o punteiro no final.

100
00:06:44,490 --> 00:06:47,670
Entón, cando está lidando con o pset, asegúrese de que non confundirse.

101
00:06:47,670 --> 00:06:50,480
Quizais ter o lado definicións con cóbado.

102
00:06:50,480 --> 00:06:58,090
Podes puxar as definicións do manual, escribindo o home e despois fwrite, por exemplo,

103
00:06:58,090 --> 00:06:59,950
no terminal, ou pode referirse a este slide

104
00:06:59,950 --> 00:07:03,570
e asegúrese de que está a usar o camiño certo.

105
00:07:03,570 --> 00:07:08,700
Entón, de novo, para fwrite, cando ten un arquivo que quere escribir para,

106
00:07:08,700 --> 00:07:14,290
que vai ser o último argumento, e que vai ser un punteiro para o arquivo.

107
00:07:14,290 --> 00:07:18,670
Entón é así que xestione a escrita, quizais varios bytes de cada vez,

108
00:07:18,670 --> 00:07:21,820
pero dicir que quere só escribir só un personaxe único.

109
00:07:21,820 --> 00:07:25,940
Como veremos máis adiante neste exemplo, nos bitmaps que imos ter que usar isto.

110
00:07:25,940 --> 00:07:32,180
É cando podemos utilizar fputc, esencialmente, só poñendo un personaxe de cada vez, CHR,

111
00:07:32,180 --> 00:07:37,050
para o punteiro do ficheiro, e iso é o punteiro nosa alí.

112
00:07:38,700 --> 00:07:41,560
Entón sempre que buscar ou escribir nun ficheiro,

113
00:07:41,560 --> 00:07:44,690
o ficheiro é manter o control de onde estamos.

114
00:07:44,690 --> 00:07:47,810
Entón, é unha especie de cursor, o indicador de posición do ficheiro.

115
00:07:47,810 --> 00:07:54,330
E así, cada vez que escribir ou ler outra vez nun arquivo,

116
00:07:54,330 --> 00:07:56,760
o arquivo realmente se lembra de onde é,

117
00:07:56,760 --> 00:07:59,270
e por iso segue a partir de onde o cursor está.

118
00:07:59,270 --> 00:08:03,970
Isto pode ser beneficioso cando quere, por exemplo, ler unha certa cantidade para facer algo

119
00:08:03,970 --> 00:08:06,160
e en seguida, ler o seguinte cantidade,

120
00:08:06,160 --> 00:08:10,700
pero ás veces podemos querer volver ou comezar realmente a partir dun valor de referencia determinado.

121
00:08:10,700 --> 00:08:16,870
Entón a función fseek, o que fai é que nos permite mover o cursor nun determinado ficheiro

122
00:08:16,870 --> 00:08:19,680
un determinado número de bytes.

123
00:08:19,680 --> 00:08:24,260
E entón o que temos que facer é especificar onde o valor de referencia é.

124
00:08:24,260 --> 00:08:31,520
Así, ou se move cara adiante ou cara atrás, de onde o cursor está actualmente,

125
00:08:31,520 --> 00:08:35,750
ou podemos especificar que debe moverse en só a partir do inicio do arquivo

126
00:08:35,750 --> 00:08:37,090
ou desde o fin do ficheiro.

127
00:08:37,090 --> 00:08:41,230
E así pode pasar valores positivos ou negativos para montante,

128
00:08:41,230 --> 00:08:44,960
e que tipo de mover o cursor cara adiante ou cara atrás.

129
00:08:46,170 --> 00:08:51,920
>> Antes de entrar en serie de exercicios outros, dúbidas en arquivo I / O?

130
00:08:53,860 --> 00:08:59,990
Okay. Como entramos en máis exemplos, Sinto-se libre para me deixar para preguntas.

131
00:08:59,990 --> 00:09:06,930
>> Así, en Whodunit, está entregado un ficheiro bitmap semellante a esta vermello no slide,

132
00:09:06,930 --> 00:09:14,510
e parece que iso - unha morea de puntos vermellos - e non sabe realmente o que está escrito.

133
00:09:14,510 --> 00:09:23,310
Se vostede é Vesgo, pode ser capaz de ver unha lixeira cor azulada dentro da media.

134
00:09:23,310 --> 00:09:26,270
Esencialmente, que é onde o texto está almacenado.

135
00:09:26,270 --> 00:09:30,270
Houbo un asasinato que pasou, e necesitamos descubrir quen fixo iso.

136
00:09:30,270 --> 00:09:36,760
Co fin de facer iso, necesitamos tipo de converter esa imaxe nun formato lexible.

137
00:09:36,760 --> 00:09:42,740
Se vós xa atopou este, ás veces, non habería kits pequenos

138
00:09:42,740 --> 00:09:48,510
onde tería unha lupa cun filme vermello. Alguén? Si

139
00:09:48,510 --> 00:09:52,770
Entón sería algo handed así, que tería unha lupa

140
00:09:52,770 --> 00:09:58,130
co filme vermello sobre el, que ía poñelas sobre a imaxe,

141
00:09:58,130 --> 00:10:03,410
e sería capaz de ver a mensaxe agochada nela.

142
00:10:03,410 --> 00:10:07,080
Nós non temos unha lupa con película vermella, entón en vez imos especie de crear a nosa propia

143
00:10:07,080 --> 00:10:09,060
neste pset.

144
00:10:09,060 --> 00:10:15,760
E así, o usuario vai whodunit entrada, entón a pista. BMP,

145
00:10:15,760 --> 00:10:18,800
entón esa é a infile, esa é a mensaxe punto vermello,

146
00:10:18,800 --> 00:10:23,550
e entón eles están dicindo verdict.bmp vai ser o noso ficheiro de saída.

147
00:10:23,550 --> 00:10:27,900
Por iso, vai crear unha nova imaxe bitmap semellante á pista un

148
00:10:27,900 --> 00:10:32,600
excepto nun formato lexible, onde podemos ver a mensaxe oculta.

149
00:10:32,600 --> 00:10:37,550
>> Xa que imos estar lidando con edición e manipulación de bitmaps de calquera tipo,

150
00:10:37,550 --> 00:10:42,400
imos tipo de mergullo no estructura destes arquivos bitmap.

151
00:10:42,400 --> 00:10:48,130
Nós fomos sobre estes un pouco en clase, pero imos ollar para eles un pouco máis.

152
00:10:48,130 --> 00:10:51,740
Bitmaps son esencialmente só un arranxo de bytes

153
00:10:51,740 --> 00:10:55,790
onde teña indicado que máis significa o que.

154
00:10:55,790 --> 00:11:00,540
Entón aquí é como unha especie de mapa de imaxe de bitmap

155
00:11:00,540 --> 00:11:08,550
dicindo que comeza con algúns arquivos de cabeceira, comeza con unha información alí.

156
00:11:08,550 --> 00:11:16,540
Vostede ve que o número de bytes tamaño 14 indícase da imaxe bitmap,

157
00:11:16,540 --> 00:11:18,520
e segue.

158
00:11:18,520 --> 00:11:23,810
Pero entón o que estamos realmente interesados ​​en aquí está comezando en torno a byte número 54.

159
00:11:23,810 --> 00:11:26,060
Temos estes triplica RGB.

160
00:11:26,060 --> 00:11:30,760
O que vai facer é conter os píxeles reais, os valores de cor.

161
00:11:30,760 --> 00:11:35,950
Todo o anteriormente exposto, que a cabeceira é unha información

162
00:11:35,950 --> 00:11:41,240
correspondente ao tamaño da imaxe, o ancho da imaxe, e á altura.

163
00:11:41,240 --> 00:11:44,930
Cando imos para o recheo máis tarde, imos ver por que o tamaño da imaxe

164
00:11:44,930 --> 00:11:48,670
pode ser diferente do que a anchura ou altura.

165
00:11:48,670 --> 00:11:54,240
Entón para representar eses - estas imaxes bitmap son secuencias de bytes -

166
00:11:54,240 --> 00:11:59,370
o que podemos facer é dicir todo ben, eu vou lembrar que o índice 14,

167
00:11:59,370 --> 00:12:03,380
é aí onde o tamaño é, por exemplo, pero en vez diso o que imos facer para facer isto máis doado

168
00:12:03,380 --> 00:12:06,020
e compacta-lo nunha estrutura.

169
00:12:06,020 --> 00:12:08,880
E así temos dúas estruturas feitas para nós, un BITMAPFILEHEADER

170
00:12:08,880 --> 00:12:10,440
e un BITMAPINFOHEADER,

171
00:12:10,440 --> 00:12:14,840
e por iso sempre que lemos no para o arquivo, por defecto vai estar indo en orde,

172
00:12:14,840 --> 00:12:22,360
e así, de xeito que tamén vai cubrir en variables como biWidth e biSize.

173
00:12:25,270 --> 00:12:31,230
E, a continuación, finalmente, cada pixel é representado por tres bytes.

174
00:12:31,230 --> 00:12:35,500
O primeiro é a cantidade de azul no pixel, o segundo é a cantidade de verde,

175
00:12:35,500 --> 00:12:41,120
e, finalmente, a cantidade de vermello, onde 0 é esencialmente non verde, azul ou ningún ou ningún vermello

176
00:12:41,120 --> 00:12:43,720
e en seguida, ss é o valor máximo.

177
00:12:43,720 --> 00:12:46,800
Estes son valores hexadecimais.

178
00:12:46,800 --> 00:12:53,870
Entón, a continuación, se temos FF0000, a continuación, que corresponde á cantidade máxima de azul

179
00:12:53,870 --> 00:12:58,890
e, a continuación, sen verde e sen vermello, para, entón, que nos daría un pixel azul.

180
00:12:58,890 --> 00:13:04,190
Entón, se temos todos os FF a través da tarxeta, entón iso significa que temos un pixel branco.

181
00:13:04,190 --> 00:13:11,370
Esta é unha especie de oposto ao normalmente cando dicimos RGB. Está realmente a suceder BGR.

182
00:13:12,750 --> 00:13:18,990
>> Entón, se nós realmente ollar para un exemplo dunha imaxe bitmap - déixame sacar unha.

183
00:13:31,560 --> 00:13:33,830
É un pouco pequena.

184
00:13:39,890 --> 00:13:47,840
Estou de ampliar, e podemos ver que está pixelizada. Parece que os bloques de cores.

185
00:13:47,840 --> 00:13:50,110
Ten bloques brancos e despois bloques vermellos.

186
00:13:50,110 --> 00:13:53,700
Se xogar en Microsoft Paint, por exemplo, vostede podería facer algo así

187
00:13:53,700 --> 00:13:58,960
por basicamente só pintando algunhas prazas nunha orde específica.

188
00:13:58,960 --> 00:14:08,060
Entón, o que se traduce no bitmap é a seguinte.

189
00:14:08,060 --> 00:14:15,710
Aquí temos primeiro píxeles brancos, que todos os seis son f, e entón temos píxeles vermellos,

190
00:14:15,710 --> 00:14:19,910
indicado por 0000ff.

191
00:14:19,910 --> 00:14:27,940
E así a secuencia de bytes que temos indica como a imaxe bitmap vai mirar.

192
00:14:27,940 --> 00:14:32,230
Entón, o que eu teño feito aquí é só escrito todos eses bytes e colorido entón no vermello

193
00:14:32,230 --> 00:14:37,550
de modo que pode tipo de ver, se ollar de esguello un pouco, como este tipo de indica un rostro sorridente.

194
00:14:40,180 --> 00:14:46,390
>> O xeito que o traballo de imaxes bitmap é, eu imaxino que, basicamente, como unha reixa.

195
00:14:46,390 --> 00:14:54,940
E así por defecto, todas as liñas da reixa ten que ser un múltiplo de 4 bytes.

196
00:15:00,520 --> 00:15:07,060
Se olharmos para unha imaxe bitmap, está cubrindo todos os valores.

197
00:15:07,060 --> 00:15:17,370
Por exemplo, pode ter un vermello aquí, un verde aquí, dun azul aquí,

198
00:15:17,370 --> 00:15:24,950
pero tes que estar seguro de que a imaxe é cuberto con un múltiplo de catro bytes.

199
00:15:24,950 --> 00:15:32,200
Entón, se eu quero a miña imaxe para ser a tres bloques de ancho, entón eu tería que poñer un valor baleiro

200
00:15:32,200 --> 00:15:35,640
no último a facelo un múltiplo de catro.

201
00:15:35,640 --> 00:15:39,530
Entón gustaríame engadir algo que estamos chamando de recheo.

202
00:15:39,530 --> 00:15:43,750
Eu só vou para indicar que alí cun x.

203
00:15:44,920 --> 00:15:54,160
Agora dicir que queremos unha imaxe que é de 7 píxeles de lonxitude, por exemplo.

204
00:15:54,160 --> 00:15:59,550
Temos 1, 2, 3, 4, 5, 6, 7,

205
00:16:04,750 --> 00:16:07,000
e todo isto é cuberto coa cor.

206
00:16:07,000 --> 00:16:10,620
O xeito que as imaxes bitmap traballar é que necesitamos unha oitava.

207
00:16:10,620 --> 00:16:12,460
Agora temos 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
Necesitamos 8 espazos para a imaxe bitmap para ler correctamente.

209
00:16:19,360 --> 00:16:25,600
Entón o que temos que facer é engadir un pouco de recheo

210
00:16:25,600 --> 00:16:29,430
para asegurarse de que todas as ancho son uniformes

211
00:16:29,430 --> 00:16:34,260
e que todas as ancho son un múltiplo de 4.

212
00:16:42,110 --> 00:16:47,310
E así eu indicado anteriormente, acolchoar como un X ou unha liña sinuosa,

213
00:16:47,310 --> 00:16:53,880
pero as imaxes reais bitmap do estofo indícase por un 0 hexadecimal.

214
00:16:53,880 --> 00:16:57,340
Entón, que sería un personaxe único, 0.

215
00:16:58,980 --> 00:17:06,329
O que pode vir a cadra é o comando XXD.

216
00:17:06,329 --> 00:17:11,220
O que fai é, en realidade, mostra, como semellante ao que eu facía antes co Smiley

217
00:17:11,220 --> 00:17:15,630
cando realmente imprimiu o que cada cor sería a pixel

218
00:17:15,630 --> 00:17:21,800
e entón un código de cores que cando executar xxd cos seguintes comandos,

219
00:17:21,800 --> 00:17:28,670
entón el vai realmente imprimir o que as cores son para aqueles píxeles.

220
00:17:28,670 --> 00:17:33,810
O que ten que facer é por aquí que eu indicar, como o S-54

221
00:17:33,810 --> 00:17:36,530
di que eu vou comezar no byte 54

222
00:17:36,530 --> 00:17:40,820
porque, antes diso, lembre, se olharmos para o mapa dos bitmaps,

223
00:17:40,820 --> 00:17:42,690
que é toda a información da cabeceira e cousas así.

224
00:17:42,690 --> 00:17:46,280
Pero o que realmente importa é os píxeles reais que indican a cor.

225
00:17:46,280 --> 00:17:52,700
Así, engadindo que a bandeira,-s 54, entón somos capaces de ver os valores de cor.

226
00:17:52,700 --> 00:17:56,020
E non se preocupe coas bandeiras complicados e cousas así.

227
00:17:56,020 --> 00:18:05,020
Na especificación do conxunto de problemas, terá instrucións sobre como usar xxd para amosar os píxeles.

228
00:18:07,070 --> 00:18:15,590
Entón, se ve aquí, medio que se parece unha caixa verde, esa cousa pequena.

229
00:18:15,590 --> 00:18:23,610
Eu teño un código de cores a 00ff00 basicamente como dicir non azul, moi verde, e non vermello.

230
00:18:23,610 --> 00:18:26,370
De xeito que corresponde a verde.

231
00:18:26,370 --> 00:18:31,920
Como podes ver aquí, vemos un rectángulo verde.

232
00:18:31,920 --> 00:18:36,660
Este rectángulo verde é de só 3 píxeles de ancho, entón o que temos que facer

233
00:18:36,660 --> 00:18:44,350
para estar seguro de que a imaxe é un múltiplo de 4 ancha é engadir en estofado extra.

234
00:18:44,350 --> 00:18:49,460
E entón é así que ver eses 0s aquí.

235
00:18:49,460 --> 00:18:54,510
Isto vai realmente ser o resultado do seu pset Resize,

236
00:18:54,510 --> 00:19:01,350
esencialmente tomar o pequeno bitmap e despois ampliala lo por 4.

237
00:19:01,350 --> 00:19:09,380
E entón o que vemos é que, en realidade, esta imaxe é de 12 píxeles de ancho, pero 12 é un múltiplo de 4,

238
00:19:09,380 --> 00:19:12,940
e así nós realmente non vexo ningún 0s ao final, porque non necesita engadir ningún

239
00:19:12,940 --> 00:19:19,070
porque está totalmente cuberto. El non ten espazo máis.

240
00:19:20,720 --> 00:19:23,470
>> Okay. Calquera dúbida sobre o recheo?

241
00:19:25,150 --> 00:19:27,460
Okay. Cool.

242
00:19:27,460 --> 00:19:32,520
>> Como mencionei antes, os bitmaps son só unha secuencia de bytes.

243
00:19:32,520 --> 00:19:39,170
E entón o que temos é, en vez de ter saber exactamente o número de bytes que

244
00:19:39,170 --> 00:19:47,050
corresponde a un elemento específico, que realmente crearon unha estrutura para representar isto.

245
00:19:47,050 --> 00:19:50,930
Entón, o que temos é unha estrutura RGBTRIPLE.

246
00:19:50,930 --> 00:19:54,590
Sempre que ten unha instancia dun triplo RGB,

247
00:19:54,590 --> 00:20:00,970
porque este é un tipo de definir struct, entón pode acceder a variable rgbtBlue,

248
00:20:00,970 --> 00:20:09,520
Similarmente as variables verde e vermello, o que indicará a cantidade de azul, verde e vermello

249
00:20:09,520 --> 00:20:11,580
respectivamente, o que ten.

250
00:20:11,580 --> 00:20:16,800
>> Entón, se temos a variable azul a 0, o conxunto verde para FF,

251
00:20:16,800 --> 00:20:22,060
que é o valor máximo que pode ter, e entón a variable vermello definido como 0,

252
00:20:22,060 --> 00:20:27,870
entón o que a cor que neste particular RGB triplo representa? >> [Alumno] Verde.

253
00:20:27,870 --> 00:20:29,150
Green. Exactamente.

254
00:20:29,150 --> 00:20:34,480
Vai ser útil saber que sempre que teña unha instancia dun triplo RGB,

255
00:20:34,480 --> 00:20:41,340
realmente pode acceder a cantidade de memoria - azul, verde e vermello - separado.

256
00:20:43,350 --> 00:20:54,900
>> Agora que xa falamos sobre a estrutura do que imos dar un ollo ao ficheiro BMP.

257
00:20:54,900 --> 00:20:57,870
Estes son estruturas deseñadas para ti.

258
00:20:57,870 --> 00:21:01,820
Aquí temos unha estrutura BITMAPFILEHEADER.

259
00:21:01,820 --> 00:21:07,610
De interese é o tamaño.

260
00:21:07,610 --> 00:21:12,660
Máis tarde, temos a cabeceira da información, que ten máis algunhas cousas que son interesantes para nós,

261
00:21:12,660 --> 00:21:15,480
a saber, o tamaño, a anchura e altura.

262
00:21:15,480 --> 00:21:19,170
Como imos entrar en máis tarde, cando le o ficheiro,

263
00:21:19,170 --> 00:21:25,500
el automaticamente le porque definir a fin de ser o mesmo.

264
00:21:25,500 --> 00:21:31,990
Así, o biSize conterá os bytes dereitas que corresponden ao tamaño real da imaxe.

265
00:21:34,700 --> 00:21:40,500
E entón, aquí, por último, como falamos, temos a estrutura RGBTRIPLE typedef.

266
00:21:40,500 --> 00:21:46,840
Temos un rgbtBlue, verde e vermello asociados.

267
00:21:48,210 --> 00:21:49,340
>> Grande. Okay.

268
00:21:49,340 --> 00:21:56,360
Agora que entendemos bitmaps un pouco, entender que temos unha cabeceira do ficheiro

269
00:21:56,360 --> 00:22:00,790
e unha cabeceira información asociada a ela e despois diso, temos a parte interesante

270
00:22:00,790 --> 00:22:05,110
das cores, e as cores son representados por estruturas RGBTRIPLE,

271
00:22:05,110 --> 00:22:12,710
e os que, á súa vez, ten tres valores asociados ao azul, o verde eo vermello.

272
00:22:12,710 --> 00:22:17,270
>> Entón, agora, podemos tipo de pensar en recuperar un pouco.

273
00:22:17,270 --> 00:22:20,130
Sentímolo. Debería Whodunit.

274
00:22:20,130 --> 00:22:25,750
Cando temos o noso arquivo de pista, entón o que queremos facer é ler para el píxel por píxel

275
00:22:25,750 --> 00:22:33,860
e despois de algunha maneira cambiar os píxeles para que poidamos producir nun formato lexible.

276
00:22:33,860 --> 00:22:41,020
E así a saída, imos escribir pixel por pixel no arquivo verdict.bmp.

277
00:22:41,020 --> 00:22:45,120
Este é un tipo de moito para facelo. Nós entendemos iso.

278
00:22:45,120 --> 00:22:49,860
Entón, o que fixemos é que, en realidade, sempre que copy.c.

279
00:22:49,860 --> 00:22:57,610
O que fai é só copy.c fai unha copia exacta dun arquivo de bitmap dado e en seguida, xera-lo.

280
00:22:57,610 --> 00:23:01,900
Entón, iso xa abre o arquivo para ti, le en píxeles por pixel,

281
00:23:01,900 --> 00:23:04,510
e despois escribe-in nun ficheiro de saída.

282
00:23:04,510 --> 00:23:07,080
>> Imos dar un ollo niso.

283
00:23:13,390 --> 00:23:18,290
Este é asegurar unha utilización axeitada,

284
00:23:18,290 --> 00:23:22,640
recibindo os nomes aquí.

285
00:23:22,640 --> 00:23:29,940
O que isto significa que define o ficheiro de entrada para ser o que pasamos en en infile aquí,

286
00:23:29,940 --> 00:23:34,750
que é o noso argumento de liña de comandos segundo.

287
00:23:34,750 --> 00:23:37,640
Verifica para estar seguro de que podemos abrir o ficheiro.

288
00:23:38,960 --> 00:23:44,860
Comproba que podemos facer unha outfile novo aquí.

289
00:23:45,630 --> 00:23:53,270
Entón, o que iso fai aquí, é basicamente só comeza a ler para o ficheiro de bitmap dende o principio.

290
00:23:53,270 --> 00:23:56,700
O inicio, como se sabe, contén o BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
e así as secuencias de bits pode directamente encher o BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Entón o que temos aquí está dicindo que bf BITMAPFILEHEADER -

293
00:24:07,940 --> 00:24:13,150
esa é a nosa nova variable do tipo BITMAPFILEHEADER -

294
00:24:13,150 --> 00:24:22,560
imos poñer dentro bf que lemos no punteiro, que é o noso infile.

295
00:24:22,560 --> 00:24:23,970
Canto é que lemos?

296
00:24:23,970 --> 00:24:32,160
Lemos en cantos bytes que necesitamos para conter a BITMAPFILEHEADER todo.

297
00:24:32,160 --> 00:24:34,660
Do mesmo xeito, iso é o que nós facemos a cabeceira info.

298
00:24:34,660 --> 00:24:39,010
Entón, nós estamos continuando ao longo da nosa arquivo no infile,

299
00:24:39,010 --> 00:24:44,360
e estamos lendo os bits e bytes, e estamos ligando-os directamente no

300
00:24:44,360 --> 00:24:47,880
nestes casos das variables que estamos facendo.

301
00:24:49,370 --> 00:24:53,800
Aquí estamos só estar seguro de que o bitmap é un bitmap.

302
00:24:57,670 --> 00:25:01,030
>> Agora temos un outfile, non?

303
00:25:01,030 --> 00:25:04,420
Así como está cando a creamos, é esencialmente baleiro.

304
00:25:04,420 --> 00:25:07,710
Entón temos que, basicamente, crear un novo bitmap a partir de cero.

305
00:25:07,710 --> 00:25:12,280
O que facemos é que temos que estar seguro de que copiamos na cabeceira do arquivo

306
00:25:12,280 --> 00:25:16,850
eo cabeceira información como o infile ten.

307
00:25:16,850 --> 00:25:22,850
O que nós facemos é escribir - e lembre que bf é a variable

308
00:25:22,850 --> 00:25:29,300
de BITMAPFILEHEADER tipo, entón o que facemos é só usar este contido

309
00:25:29,300 --> 00:25:34,980
escribir no ficheiro de saída.

310
00:25:36,550 --> 00:25:38,510
Aquí, lembro que falou sobre o recheo,

311
00:25:38,510 --> 00:25:47,820
como é importante estar seguro de que a cantidade de píxeles que temos é un múltiplo de 4.

312
00:25:47,820 --> 00:25:52,790
Esta é unha fórmula moi útil para calcular a cantidade de recheo que ten

313
00:25:52,790 --> 00:25:57,670
dada a anchura do seu arquivo.

314
00:25:57,670 --> 00:26:04,120
Eu quero que vostedes lembrar que en copy.c temos unha fórmula para calcular o estofado.

315
00:26:04,120 --> 00:26:07,970
Ok? Entón, lembre que todos. Grande.

316
00:26:07,970 --> 00:26:14,050
Entón o que copy.c fai a seguir é que itera sobre todos os scanlines.

317
00:26:14,050 --> 00:26:23,730
El vai percorrer as liñas e despois almacena todos os triples que le

318
00:26:23,730 --> 00:26:26,920
e despois grava-lo no ficheiro de saída.

319
00:26:26,920 --> 00:26:33,120
Entón aquí estamos lendo só un RGB triplo de cada vez

320
00:26:33,120 --> 00:26:39,860
e logo poñer que Triple mesmos para o ficheiro de saída.

321
00:26:41,120 --> 00:26:48,340
A parte complicada é que o recheo non é unha tripla RGB,

322
00:26:48,340 --> 00:26:55,200
e por iso non pode só ler que cantidade de recheo de triples RGB.

323
00:26:55,200 --> 00:27:01,460
O que temos que facer é realmente só mover o noso indicador de posición do arquivo, mover noso cursor,

324
00:27:01,460 --> 00:27:06,840
que tipo de saltar sobre todo estofado de xeito que estamos na liña seguinte.

325
00:27:06,840 --> 00:27:12,990
E entón o que iso fai é copia mostra como pode querer engadir o estofado.

326
00:27:12,990 --> 00:27:14,990
Entón, nós calculamos a cantidade de recheo que necesitamos,

327
00:27:14,990 --> 00:27:18,220
o que significa que necesitamos número recheo de 0s.

328
00:27:18,220 --> 00:27:24,510
O que isto fai é un loop que pon estofo número de 0s no noso ficheiro de saída.

329
00:27:24,510 --> 00:27:31,170
E entón, finalmente, pechar os dous arquivos. Vostede pecha o infile, así como o ficheiro de saída.

330
00:27:31,170 --> 00:27:34,870
>> Entón é así que copy.c obras,

331
00:27:34,870 --> 00:27:37,430
e que vai ser moi útil.

332
00:27:39,720 --> 00:27:43,750
En vez de só a verdade directamente copiar e pegar

333
00:27:43,750 --> 00:27:46,800
ou só mirando para el e escribindo o que quere,

334
00:27:46,800 --> 00:27:49,440
pode só querer executar este comando no terminal,

335
00:27:49,440 --> 00:27:54,520
CP copy.c whodunit.c, que creará un novo arquivo, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
que contén exactamente o mesmo contido como copia fai.

337
00:27:58,330 --> 00:28:03,880
Entón o que podemos facer é usar isto como unha estrutura sobre a que construír e editar

338
00:28:03,880 --> 00:28:06,900
para o noso arquivo whodunit.

339
00:28:08,500 --> 00:28:14,670
>> Estes son os nosos para-dos a facer para Whodunit, pero o que fai copy.c

340
00:28:14,670 --> 00:28:16,730
é realmente toma conta da maioría deles a nós.

341
00:28:16,730 --> 00:28:21,900
Entón, todo o que cómpre facer agora é cambiar os píxeles que corresponda

342
00:28:21,900 --> 00:28:25,920
para realmente facer o ficheiro lexíbel.

343
00:28:25,920 --> 00:28:32,960
Lembre que para un determinado pixel triple, así, para unha determinada variable de RGBTRIPLE tipo,

344
00:28:32,960 --> 00:28:35,990
pode acceder aos azuis, os valores ecolóxicos e vermello.

345
00:28:35,990 --> 00:28:38,670
Isto vai vir a cadra, porque se pode acceder a eles,

346
00:28:38,670 --> 00:28:41,770
Isto significa que tamén pode ve-los,

347
00:28:41,770 --> 00:28:45,430
e iso significa que tamén pode muda-los.

348
00:28:45,430 --> 00:28:49,430
>> Entón, cando nós volvemos para o noso exemplo vermello lupa,

349
00:28:49,430 --> 00:28:53,390
basicamente, que estaba actuando como unha especie de filtro para nós.

350
00:28:53,390 --> 00:28:58,160
Entón, o que queremos facer é que queremos para filtrar todos os triples que están vindo dentro

351
00:28:58,160 --> 00:29:01,240
Existen varias maneiras diferentes de facelo.

352
00:29:01,240 --> 00:29:07,100
Basicamente, pode ter calquera tipo de filtro que quere.

353
00:29:07,100 --> 00:29:09,890
Quizais queira cambiar os píxeles vermellos

354
00:29:09,890 --> 00:29:13,570
ou quizais quere cambiar un pixel de cor diferente para unha cor diferente.

355
00:29:13,570 --> 00:29:15,400
Isto é con vostede.

356
00:29:15,400 --> 00:29:19,580
Lembre que pode comprobar que a cor do pixel é

357
00:29:19,580 --> 00:29:23,000
e entón tamén pode muda-lo como está pasando.

358
00:29:24,410 --> 00:29:26,420
>> Okay. Entón, iso é Whodunit.

359
00:29:26,420 --> 00:29:32,760
Unha vez que executar Whodunit, vai saber quen é o culpable do crime era.

360
00:29:32,760 --> 00:29:35,540
>> Agora estamos indo a ir a redimensionar.

361
00:29:35,540 --> 00:29:37,990
Nós imos aínda estar lidando con bitmaps.

362
00:29:37,990 --> 00:29:40,750
O que imos facer é que imos ter un bitmap de entrada

363
00:29:40,750 --> 00:29:45,890
e despois imos pasar nun número e en seguida, obter un bitmap outfile

364
00:29:45,890 --> 00:29:51,380
onde iso é basicamente a nosa infile escalado por n.

365
00:29:54,670 --> 00:30:01,450
Diga meu arquivo era só un pixel grande.

366
00:30:01,450 --> 00:30:09,100
Entón, se o meu n foi de 3, o deseño por 3, entón quere repetir que o pixel n número de veces,

367
00:30:09,100 --> 00:30:14,410
Polo tanto, 3 veces, e, a continuación, reducir a escala 3 veces tamén.

368
00:30:14,410 --> 00:30:17,840
Entón ve que eu estou escalando o en vertical coma en horizontal.

369
00:30:17,840 --> 00:30:19,680
>> E entón aquí está un exemplo.

370
00:30:19,680 --> 00:30:27,590
Se ten n = 2, ve que o primeiro pixel azul alí repetido dúas veces

371
00:30:27,590 --> 00:30:30,930
horizontalmente, así como dúas veces verticalmente.

372
00:30:30,930 --> 00:30:38,040
E, entón, que segue, e entón vostede ten unha escala directa da súa imaxe orixinal por dous.

373
00:30:40,920 --> 00:30:47,600
>> Entón, se fósemos para detallar o pseudocódigo para iso, queremos abrir o ficheiro.

374
00:30:47,600 --> 00:30:49,880
E entón, sabendo que volver aquí,

375
00:30:49,880 --> 00:30:54,540
vemos que a anchura para o outfile vai ser diferente do que a anchura para o infile.

376
00:30:54,540 --> 00:30:56,130
O que significa isto?

377
00:30:56,130 --> 00:31:01,230
Isto significa que o noso información de cabeceira vai cambiar.

378
00:31:01,230 --> 00:31:03,790
E entón o que queremos facer é actualizar a información da cabeceira,

379
00:31:03,790 --> 00:31:11,820
sabendo que cando lemos nos arquivos se está operando no marco copy.c,

380
00:31:11,820 --> 00:31:17,570
xa temos unha variable que indica que o tamaño é, e cousas así.

381
00:31:17,570 --> 00:31:24,060
Polo tanto, unha vez que ten, o que pode querer facer é cambiar as variables particulares.

382
00:31:24,060 --> 00:31:29,380
Teña en conta que, se ten unha estrutura, como acceder as variables dentro desa.

383
00:31:29,380 --> 00:31:32,080
Usa o operador punto, non?

384
00:31:32,080 --> 00:31:36,420
Entón usando iso, vostede sabe que vai ter para cambiar a información da cabeceira.

385
00:31:36,480 --> 00:31:41,030
Entón, aquí é só unha lista dos elementos reais que van estar cambiando no seu arquivo.

386
00:31:41,030 --> 00:31:45,180
O tamaño do ficheiro pode estar a cambiar, da imaxe, así como a anchura e altura.

387
00:31:45,180 --> 00:31:50,080
Entón, a continuación, volver ao mapa dos bitmaps,

388
00:31:50,080 --> 00:31:57,730
mira se é a cabeceira do ficheiro ou a cabeceira que contén información que a información

389
00:31:57,730 --> 00:32:00,920
e, a continuación, faga as modificacións necesarias.

390
00:32:05,010 --> 00:32:12,470
Unha vez máis, dicir CP copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
Isto significa que resize.c agora contén todo o que está contido dentro copia

392
00:32:19,270 --> 00:32:24,490
copia porque nos ofrece unha forma de ler para cada pixel por pixel scanline.

393
00:32:24,490 --> 00:32:29,860
Só que agora, en vez de só cambiando os valores como fixemos no Whodunit,

394
00:32:29,860 --> 00:32:37,980
o que queremos facer é que queremos escribir en múltiples píxeles

395
00:32:37,980 --> 00:32:43,580
sempre que o noso n é maior que 1.

396
00:32:43,580 --> 00:32:47,110
>> Entón, o que queremos facer é que queremos estirar horizontalmente por n,

397
00:32:47,110 --> 00:32:50,490
así como estirala-lo na vertical, n.

398
00:32:50,490 --> 00:32:52,710
Como podemos facer iso?

399
00:32:52,710 --> 00:32:56,890
Diga o n é 2 e ten ese infile dado.

400
00:32:56,890 --> 00:32:58,730
O cursor vai comezar no primeiro,

401
00:32:58,730 --> 00:33:03,530
eo que quere facer, se n é 2, quere imprimir en dúas delas.

402
00:33:03,530 --> 00:33:05,490
Entón imprimir en dúas delas.

403
00:33:05,490 --> 00:33:10,830
A continuación, o cursor vai cambiar para o próximo pixel, que é o vermello,

404
00:33:10,830 --> 00:33:18,400
e vai imprimir dúas daqueles vermellos, anexando-lo para o que está feito antes.

405
00:33:18,400 --> 00:33:26,280
A continuación, o cursor ha moverse ao seguinte pixel e deseñar en dúas delas.

406
00:33:26,280 --> 00:33:37,180
Se ollar cara atrás para o cadro copy.c, o que iso fai aquí

407
00:33:37,180 --> 00:33:42,830
é el crea unha nova instancia dun triplo RGB, unha nova variable chamada triple.

408
00:33:42,830 --> 00:33:50,500
E aquí, cando se le para el, el le a partir do 1 infile RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
e almacena-lo dentro desa variable triplo.

410
00:33:53,470 --> 00:33:57,590
Entón realmente ten unha variable que representa o pixel particular.

411
00:33:57,590 --> 00:34:05,290
Entón, cando escribe, o que pode querer facer é pechar a declaración fwrite para un ciclo

412
00:34:05,290 --> 00:34:11,080
que escribe na súa outfile tantas veces como sexa necesario.

413
00:34:17,449 --> 00:34:20,100
Isto é moi sinxelo.

414
00:34:20,200 --> 00:34:27,590
Basicamente só repetir o proceso de escritura n número de veces para escala-lo en horizontal.

415
00:34:27,590 --> 00:34:32,969
>> Pero, entón, hai que lembrar que o noso espazo vai cambiar.

416
00:34:47,350 --> 00:34:53,020
Anteriormente, dicir que tiña algo de lonxitude 3.

417
00:34:53,020 --> 00:35:00,130
Entón nós só engadir en canto estofado? Só unha para facelo un múltiplo de 4.

418
00:35:00,130 --> 00:35:10,480
Pero dicir que estamos escalando esa imaxe en particular ao n = 2.

419
00:35:10,480 --> 00:35:16,300
Entón cantos píxeles azuis teriamos a finais? Teriamos 6.

420
00:35:16,300 --> 00:35:21,470
1, 2, 3, 4, 5, 6. Todo ben.

421
00:35:21,470 --> 00:35:26,580
6 non é un múltiplo de catro. Cal é o múltiplo máis próximo de 4? Isto vai ser 8.

422
00:35:26,580 --> 00:35:33,200
Entón, nós estamos realmente vai ter dous caracteres de recheo alí.

423
00:35:33,200 --> 00:35:38,720
>> Alguén se lembra se temos unha fórmula para calcular o recheo

424
00:35:38,720 --> 00:35:41,350
e onde que podería ser?

425
00:35:41,350 --> 00:35:45,160
[Resposta do alumno inaudível] >> Si copy.c., Dereito.

426
00:35:45,160 --> 00:35:49,800
Hai unha fórmula en copy.c para calcular a cantidade de recheo que ten

427
00:35:49,800 --> 00:35:53,810
dada unha anchura particular da imaxe bitmap.

428
00:35:53,810 --> 00:36:02,950
Entón iso vai ser útil cando precisa engadir unha certa cantidade de estofado

429
00:36:02,950 --> 00:36:06,160
para realmente descubrir o que estofado precisa engadir.

430
00:36:10,820 --> 00:36:15,850
Pero unha nota, con todo, é que quere estar seguro de que está a usar o tamaño correcto.

431
00:36:15,850 --> 00:36:21,410
Só Tomé coidado porque está basicamente vai ser tratar con dúas imaxes bitmap.

432
00:36:21,410 --> 00:36:23,410
Quere estar seguro de que está a usar o camiño certo.

433
00:36:23,410 --> 00:36:26,820
Cando está calculando o recheo para o outfile, que desexa utilizar o ancho da outfile

434
00:36:26,820 --> 00:36:29,860
e non o ancho da anterior.

435
00:36:29,860 --> 00:36:37,240
>> Grande. Este tipo de coida de estirar unha imaxe bitmap enteiro horizontalmente.

436
00:36:37,240 --> 00:36:41,290
Pero o que queremos facer é realmente estirar-lo na vertical tamén.

437
00:36:41,290 --> 00:36:48,760
Este vai ser un pouco máis complicado, porque cando termine de copiar unha liña

438
00:36:48,760 --> 00:36:51,580
e escrita nesa liña, o noso cursor vai ser ao final.

439
00:36:51,580 --> 00:36:56,210
Entón, se ler de novo, el só vai ler a seguinte liña.

440
00:36:56,210 --> 00:37:03,660
Entón, o que queremos facer é unha especie de atopar algunha maneira de copiar as liñas novo

441
00:37:03,660 --> 00:37:12,500
ou só unha especie de tomar esa liña e despois reescribir-lo de novo.

442
00:37:14,380 --> 00:37:17,940
Como eu medio que aludiu, hai moitas maneiras diferentes de facelo.

443
00:37:17,940 --> 00:37:23,040
O que podería facer é como está pasando e lectura a través da scanline especial

444
00:37:23,040 --> 00:37:28,560
e cambia-lo, se é necesario, a continuación, tipo de tenda todos os píxeles nunha matriz.

445
00:37:28,560 --> 00:37:36,350
Despois, máis tarde vostede sabe que vai ter para imprimir esa matriz de novo,

446
00:37:36,350 --> 00:37:39,830
e así pode só usar esa matriz para facelo.

447
00:37:39,830 --> 00:37:44,500
Outra forma de facelo é que pode copiar unha liña para abaixo,

448
00:37:44,500 --> 00:37:47,950
entender que precisa copiar iso de novo, entón realmente mover o cursor,

449
00:37:47,950 --> 00:37:50,950
e que vai estar usando o fseek método.

450
00:37:50,950 --> 00:37:56,410
Pode mover o cursor todo o camiño de volta e repita o proceso de copia de novo.

451
00:37:56,410 --> 00:38:03,960
>> Entón, o noso número de escala é n, entón cantas veces teriamos que volver

452
00:38:03,960 --> 00:38:10,500
e reescribir unha liña? >> [Alumno] n - 1. >> Si, perfecto. n - 1.

453
00:38:10,500 --> 00:38:14,390
Nós fixemos iso unha vez máis, e por iso, entón imos querer repetir o proceso voltar

454
00:38:14,390 --> 00:38:17,460
n - 1 cantidade de veces.

455
00:38:22,730 --> 00:38:25,860
Okay. Polo tanto, ten a súa función de cambio de tamaño.

456
00:38:25,860 --> 00:38:34,360
>> Agora podemos chegar a unha parte moi divertido, miña pset favorito, que é recuperar.

457
00:38:34,360 --> 00:38:39,580
En vez de bitmaps, esta vez estamos lidando con JPEG.

458
00:38:39,580 --> 00:38:43,370
Non estamos realmente dado un ficheiro só de JPEGs,

459
00:38:43,370 --> 00:38:46,600
Estamos dando basicamente un formato de tarxeta de memoria prima.

460
00:38:46,600 --> 00:38:51,790
E así, este contén un pouco de valores e información de lixo, en principio,

461
00:38:51,790 --> 00:38:57,240
e entón comeza e ten unha morea de arquivos JPEG.

462
00:38:57,240 --> 00:39:03,430
Con todo, estamos entregou unha tarxeta onde nós excluímos as fotos;

463
00:39:03,430 --> 00:39:08,300
esencialmente, esquecemos onde as imaxes están situados dentro da tarxeta.

464
00:39:08,300 --> 00:39:12,770
Entón a nosa tarefa en recuperación e para pasar por este formato de tarxeta

465
00:39:12,770 --> 00:39:16,500
e atopar as fotos de novo.

466
00:39:16,500 --> 00:39:23,990
>> Afortunadamente, a estrutura de ficheiros JPEG eo arquivo de tarxeta é un pouco útil.

467
00:39:23,990 --> 00:39:28,850
El definitivamente podería ser un pouco máis complicado se non fose ese formato particular.

468
00:39:28,850 --> 00:39:40,160
Cada ficheiro JPEG realmente comeza con dúas secuencias posibles, listados enriba.

469
00:39:40,160 --> 00:39:42,970
Basicamente, sempre que ten un novo ficheiro JPEG,

470
00:39:42,970 --> 00:39:52,720
que comeza coa secuencia de calquera FFD8 FFE0 ou ​​outro, FFD8 ffe1.

471
00:39:52,720 --> 00:39:59,530
Outra cousa útil é saber que JPEGs son almacenados de forma contigua.

472
00:39:59,530 --> 00:40:03,380
Así, sempre que un arquivo JPEG remata, o outro empeza.

473
00:40:03,380 --> 00:40:07,070
Polo tanto, non hai ningún tipo de en-entre os valores alí.

474
00:40:07,070 --> 00:40:15,510
Despois de bater o inicio dun JPEG, se xa foi a lectura dun JPEG,

475
00:40:15,510 --> 00:40:21,800
vostede sabe que bateu o final do anterior eo inicio do próximo.

476
00:40:21,800 --> 00:40:25,890
>> Para tipo de ver iso, eu fixen un esquema.

477
00:40:25,890 --> 00:40:36,910
Outra cousa sobre JPEGs que pode le-los en secuencias de 512 bytes de cada vez,

478
00:40:36,910 --> 00:40:39,380
de forma semellante co inicio da tarxeta.

479
00:40:39,380 --> 00:40:43,370
Nós non precisamos de estar comprobar cada byte, porque iso sería un saco.

480
00:40:43,370 --> 00:40:48,200
Entón, en vez diso, o que podemos facer é realmente acaba de ler en 512 bytes de cada vez

481
00:40:48,200 --> 00:40:54,700
e entón, en vez de comprobar entre os naquelas pequenas franxas pequenas,

482
00:40:54,700 --> 00:40:58,640
podemos comprobar só o inicio dos 512 bytes.

483
00:40:58,640 --> 00:41:02,570
Esencialmente, neste cadro, o que ve é o inicio da tarxeta,

484
00:41:02,570 --> 00:41:08,700
ten valores que non son realmente relevantes para os JPEGs propiamente ditas.

485
00:41:08,700 --> 00:41:15,830
Pero entón o que eu teño é unha estrela para indicar unha das dúas secuencias de partida para un JPEG.

486
00:41:15,830 --> 00:41:19,910
Así, sempre que ve unha estrela, vostede sabe que ten un arquivo JPEG.

487
00:41:19,910 --> 00:41:25,030
E entón todos os ficheiros JPEG vai ser un múltiplo de 512 bytes

488
00:41:25,030 --> 00:41:27,880
pero non necesariamente o mesmo múltiple.

489
00:41:27,880 --> 00:41:32,050
O xeito que vostede sabe que bateu outro JPEG é se bater outra estrela,

490
00:41:32,050 --> 00:41:39,090
outra secuencia de partida bytes.

491
00:41:39,090 --> 00:41:43,330
Entón, o que ten aquí é que ten o vermello arquivo JPEG continuar ata que bata unha estrela,

492
00:41:43,330 --> 00:41:45,150
o que é indicado por unha nova cor.

493
00:41:45,150 --> 00:41:48,510
Vostede segue e despois de bater outra estrela, bateu outro JPEG,

494
00:41:48,510 --> 00:41:50,590
continúa todo o camiño ata o final.

495
00:41:50,590 --> 00:41:53,180
Vostede está na última foto aquí, a unha rosa.

496
00:41:53,180 --> 00:41:58,220
Vai para o fin até chegar ao final do ficheiro de caracteres.

497
00:41:58,220 --> 00:42:00,820
Isto vai ser realmente útil.

498
00:42:00,820 --> 00:42:03,170
>> A poucos takeaways principais aquí:

499
00:42:03,170 --> 00:42:06,670
O arquivo de tarxeta non comezar con un JPEG,

500
00:42:06,670 --> 00:42:13,350
pero unha vez que comeza un JPEG, todas as imaxes JPEG gárdanse de xeito conxunto entre si.

501
00:42:17,520 --> 00:42:20,420
>> Algúns pseudocódigo para a recuperar.

502
00:42:20,420 --> 00:42:22,570
En primeiro lugar, imos abrir o noso arquivo de tarxeta,

503
00:42:22,570 --> 00:42:27,500
e que vai estar usando o noso arquivo de E / S funcións.

504
00:42:27,500 --> 00:42:32,430
Imos repetir o proceso a seguir ata que teñamos acadado o final do arquivo.

505
00:42:32,430 --> 00:42:36,450
Nós imos ler 512 bytes de cada vez.

506
00:42:36,450 --> 00:42:39,180
E o que eu dixen aquí é que estamos indo a almacena-lo nun buffer,

507
00:42:39,180 --> 00:42:46,230
Entón, basicamente soster a eses 512 bytes ata que saibamos exactamente o que facer con eles.

508
00:42:46,230 --> 00:42:50,300
Entón, o que queremos facer é que queremos comprobar se se loita dunha estrela ou non.

509
00:42:50,300 --> 00:42:57,960
Se se loita dunha estrela, se se loita unha das secuencias iniciais,

510
00:42:57,960 --> 00:42:59,980
entón sabemos que se loita un novo ficheiro JPEG.

511
00:42:59,980 --> 00:43:08,860
O que queremos facer é que imos querer crear un novo arquivo no noso directorio pset4

512
00:43:08,860 --> 00:43:14,480
para continuar a facer ese arquivo.

513
00:43:14,480 --> 00:43:18,220
Pero tamén, se xa fixo un JPEG antes,

514
00:43:18,220 --> 00:43:25,620
entón queremos acabar con ese arquivo e empurra-lo para o cartafol pset4,

515
00:43:25,620 --> 00:43:29,780
onde teremos que ficheiro gardado, porque se non especificar que xa rematou o ficheiro JPEG,

516
00:43:29,780 --> 00:43:37,290
entón basicamente ten unha cantidade indeterminada. Os JPEGs nunca vai acabar.

517
00:43:37,290 --> 00:43:40,840
Entón, nós queremos estar seguro de que cando estamos lendo nun arquivo JPEG e escrita que,

518
00:43:40,840 --> 00:43:46,590
queremos pechar especificamente que, a fin de abrir o próximo.

519
00:43:46,590 --> 00:43:48,430
Imos querer comprobar varias cousas.

520
00:43:48,430 --> 00:43:52,880
Queremos comprobar se estamos no inicio dun novo JPEG co noso buffer

521
00:43:52,880 --> 00:43:56,780
e tamén xa ter atopado un JPEG antes

522
00:43:56,780 --> 00:44:03,930
porque iso vai cambiar o seu proceso lixeiramente.

523
00:44:03,930 --> 00:44:07,880
Entón despois de pasar por todo o camiño e acadar o fin do ficheiro,

524
00:44:07,880 --> 00:44:11,570
entón o que vai querer facer é que vai querer pechar todos os ficheiros que están abertos.

525
00:44:11,570 --> 00:44:14,100
Isto probablemente vai ser o último ficheiro JPEG que ten,

526
00:44:14,100 --> 00:44:18,930
así como o arquivo de tarxeta que está lidando.

527
00:44:21,940 --> 00:44:28,670
>> O último obstáculo que temos que afrontar é como realmente facer un arquivo JPEG

528
00:44:28,670 --> 00:44:31,950
e como realmente empurra-lo para o cartafol.

529
00:44:33,650 --> 00:44:39,850
O pset require que cada JPEG que atopa estar no seguinte formato,

530
00:44:39,850 --> 00:44:43,990
onde ten o número. jpg.

531
00:44:43,990 --> 00:44:50,750
O número, aínda que sexa 0, chamamos iso 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Sempre que atopar un JPEG no seu programa,

533
00:44:55,730 --> 00:44:58,040
vai querer nomealo na orde en que se atopa.

534
00:44:58,040 --> 00:44:59,700
O que significa isto?

535
00:44:59,700 --> 00:45:03,530
Necesitamos tipo de manter o control de cantos atopamos

536
00:45:03,530 --> 00:45:08,680
e que o número de cada JPEG debe ser.

537
00:45:08,680 --> 00:45:13,800
Aquí imos aproveitar da función sprintf.

538
00:45:13,800 --> 00:45:17,480
Semellante ao printf que só un tipo de impresións un valor fóra no terminal,

539
00:45:17,480 --> 00:45:23,910
sprintf imprime o arquivo na carpeta.

540
00:45:23,910 --> 00:45:30,870
E entón o que este faría se eu tivese sprintf título, e logo a corda alí,

541
00:45:30,870 --> 00:45:36,660
sería imprimir 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Supoñendo que eu Fechei meus arquivos correctamente,

543
00:45:41,020 --> 00:45:47,210
que contén o ficheiro que eu tiña escrito para fóra.

544
00:45:47,210 --> 00:45:50,320
Pero unha cousa é que o código que eu teño aquí

545
00:45:50,320 --> 00:45:53,360
non moi satisfacer o que require o pset.

546
00:45:53,360 --> 00:46:02,410
O pset require que o ficheiro JPEG segundo debe ser nomeado 002 en vez de só dous.

547
00:46:02,410 --> 00:46:09,160
Entón, cando imprimir o nome, entón quizais pode querer cambiar o espazo reservado lixeiramente.

548
00:46:09,160 --> 00:46:18,140
>> Alguén se lembra de como permitir espazos extras cando imprimir algo?

549
00:46:18,140 --> 00:46:22,530
Si >> [Alumno] Vostede coloca un 3 por cento entre o sinal ea 2. >> Si, perfecto.

550
00:46:22,530 --> 00:46:25,610
Vai poñer un 3 neste caso, porque queremos espazo para 3.

551
00:46:25,610 --> 00:46:32,590
3d% probablemente darlle 002.jpg vez de 2.

552
00:46:32,590 --> 00:46:40,120
O primeiro argumento para a función sprintf é na verdade unha matriz de char,

553
00:46:40,120 --> 00:46:42,520
que xa sabía como cadeas.

554
00:46:42,520 --> 00:46:50,700
Os vontade, especie de máis como un almacenamento temporal, só almacenar a cadea resultante.

555
00:46:50,700 --> 00:46:54,950
Realmente non vai ser tratar con isto, pero ten que inclui-lo.

556
00:46:54,950 --> 00:47:00,710
>> Sabendo que cada nome de ficheiro ten o número que leva ata tres personaxes,

557
00:47:00,710 --> 00:47:06,770
e despois. jpg, canto tempo debe ser esa matriz?

558
00:47:09,070 --> 00:47:14,310
Xoga fóra dun número. Cantos caracteres no título, o nome?

559
00:47:18,090 --> 00:47:26,320
Polo tanto, hai tres hashtags, período, jpg. >> [Alumno] 7. >> 7. Non é ben así.

560
00:47:26,320 --> 00:47:32,000
Nós imos querer 8 porque queremos permitir que o terminador nulo tamén.

561
00:47:45,340 --> 00:47:49,730
>> Finalmente, só para aproveitar o proceso que vai facer para recuperar,

562
00:47:49,730 --> 00:47:55,420
tes algunha información comezo.

563
00:47:55,420 --> 00:48:02,460
Vostede segue ata atopar o inicio dun ficheiro JPEG,

564
00:48:02,460 --> 00:48:07,900
e que pode ser calquera das dúas secuencias de partida.

565
00:48:07,900 --> 00:48:12,510
Vostede segue lendo. Cada barra aquí representa 512 bytes.

566
00:48:12,510 --> 00:48:22,630
Vostede segue a lectura, manter a lectura ata atopar outra secuencia de partida.

567
00:48:22,630 --> 00:48:29,790
Unha vez que ten iso, remata o actual JPEG - neste caso, é o vermello,

568
00:48:29,790 --> 00:48:31,030
así que quere acabar con iso.

569
00:48:31,030 --> 00:48:35,540
Queres sprintf o nome do que no seu cartafol pset4,

570
00:48:35,540 --> 00:48:41,580
Entón quere abrir un novo JPEG e manter a lectura

571
00:48:41,580 --> 00:48:46,370
ata o seguinte.

572
00:48:46,370 --> 00:48:49,040
Siga a ler, manter a lectura,

573
00:48:49,040 --> 00:48:56,290
e, finalmente, finalmente, vai chegar ao final do arquivo,

574
00:48:56,290 --> 00:49:00,360
e así que vai querer pechar o JPEG pasado que estaba a traballar,

575
00:49:00,360 --> 00:49:08,380
sprintf que na súa carpeta pset4, e despois ollar para todas as fotos que xa conquistou.

576
00:49:08,380 --> 00:49:12,050
Estas fotos son realmente imaxes de CS50 persoal,

577
00:49:12,050 --> 00:49:16,430
e por iso este é o lugar onde a parte divertida bonos do pset vén

578
00:49:16,430 --> 00:49:26,310
é que está competindo nas súas seccións para atopar os TFS nas fotos

579
00:49:26,310 --> 00:49:34,610
e sacar fotos con eles para probar que fixo o pset

580
00:49:34,610 --> 00:49:37,030
e así podes ver que os membros do equipo están nas fotos.

581
00:49:37,030 --> 00:49:41,510
Entón aproveitar fotos co persoal. Ás veces, ten que persegui-los.

582
00:49:41,510 --> 00:49:44,680
Probablemente algúns deles van tentar fuxir de ti.

583
00:49:44,680 --> 00:49:47,320
Sacar fotos con eles.

584
00:49:47,320 --> 00:49:51,190
Isto está en curso. Non é debido cando o pset é debido.

585
00:49:51,190 --> 00:49:53,340
O prazo será anunciado na especificación.

586
00:49:53,340 --> 00:49:58,060
A continuación, xunto coa súa sección, calquera sección leva máis fotos

587
00:49:58,060 --> 00:50:04,430
cos membros da maioría dos funcionarios vai gañar un premio moi legal.

588
00:50:04,430 --> 00:50:08,890
Este é un tipo de incentivo para que o seu pset4 rematar o máis rápido posible

589
00:50:08,890 --> 00:50:10,820
porque entón podes comezar a traballar

590
00:50:10,820 --> 00:50:14,570
cazando os diferentes CS50 funcionarios.

591
00:50:14,570 --> 00:50:17,500
Isto non é obrigatorio, pero, así que unha vez que obter as imaxes,

592
00:50:17,500 --> 00:50:20,310
entón está remate con pset4.

593
00:50:20,310 --> 00:50:23,970
>> E eu estou acabado con Paso a paso 4, polo tanto, grazas a todos por teren benvida.

594
00:50:23,970 --> 00:50:29,330
Boa sorte con Forensics. [Aplausos]

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