1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Tutorial - Set Problema 4]

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

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

4
00:00:08,210 --> 00:00:11,670
Está bien. Hola a todos y bienvenidos a Tutorial 4.

5
00:00:11,670 --> 00:00:14,270
>> Hoy nuestro conjunto de procesadores es Forensics.

6
00:00:14,270 --> 00:00:18,080
Forense es un conjunto de procesadores muy divertido que consiste en tratar con archivos de mapa de bits

7
00:00:18,080 --> 00:00:21,550
para descubrir que ha cometido un crimen.

8
00:00:21,550 --> 00:00:24,200
A continuación, vamos a cambiar el tamaño de algunos archivos de mapa de bits,

9
00:00:24,200 --> 00:00:27,780
entonces nosotros también vamos a hacer frente a una parte muy divertido llamado Recuperar,

10
00:00:27,780 --> 00:00:31,160
en el que estamos, básicamente, entregó una tarjeta de memoria

11
00:00:31,160 --> 00:00:34,350
en el que alguien ha borrado accidentalmente todos sus archivos,

12
00:00:34,350 --> 00:00:38,860
y se nos pide que recuperar esos archivos.

13
00:00:38,860 --> 00:00:42,910
>> Pero primero, antes de entrar en el conjunto de procesadores, realmente sólo quiero felicitar a todo el mundo.

14
00:00:42,910 --> 00:00:45,230
Estamos a punto en el punto medio de este curso.

15
00:00:45,230 --> 00:00:50,070
Quiz 0 está detrás de nosotros, y estamos en pset4, por lo que en esencia, estamos a mitad de camino.

16
00:00:50,070 --> 00:00:55,490
Hemos recorrido un largo camino si uno mira hacia atrás a sus conjuntos de procesadores, pset0 y pset1,

17
00:00:55,490 --> 00:00:57,300
así que felicitarse por eso,

18
00:00:57,300 --> 00:01:00,760
y vamos a entrar en algunas cosas realmente divertidas.

19
00:01:00,760 --> 00:01:07,070
>> Así que nuestra caja de herramientas para este conjunto de procesadores, de nuevo, en lugar de ejecutar sudo yum-y update,

20
00:01:07,070 --> 00:01:13,890
estamos en condiciones de ejecutar sólo update50 si usted está en la versión 17.3 y superior del aparato.

21
00:01:13,890 --> 00:01:17,380
Así que asegúrese de ejecutar update50 - es un fácil mucho, unos pocos caracteres menos -

22
00:01:17,380 --> 00:01:20,640
para asegurarse de que usted está en la última versión del aparato.

23
00:01:20,640 --> 00:01:25,410
Sobre todo es importante update50 cuando empezamos a usar CS50 Check.

24
00:01:25,410 --> 00:01:28,700
Así que asegúrate de que lo haces.

25
00:01:28,700 --> 00:01:30,760
>> Para todas las secciones de este conjunto de procesadores,

26
00:01:30,760 --> 00:01:34,350
vamos a estar tratando con entradas y salidas de archivos, archivar I / O.

27
00:01:34,350 --> 00:01:38,140
Vamos a ir a través de una gran cantidad de programas que tienen que ver con los arreglos

28
00:01:38,140 --> 00:01:40,350
apunta a archivos y cosas por el estilo,

29
00:01:40,350 --> 00:01:43,050
por lo que queremos asegurarnos de que estamos muy familiarizados y cómodos

30
00:01:43,050 --> 00:01:47,990
tratar con la forma de entrada y salida en los archivos.

31
00:01:47,990 --> 00:01:52,080
>> En el código de distribución para el conjunto de procesadores es un archivo llamado copy.c,

32
00:01:52,080 --> 00:01:55,280
y eso es lo que vamos a encontrar va a ser muy útil para nosotros

33
00:01:55,280 --> 00:02:00,340
porque vamos a terminar copiando el archivo copy.c

34
00:02:00,340 --> 00:02:05,350
y sólo se modifican ligeramente para ser capaz de lograr los primero 2 partes del conjunto de problemas.

35
00:02:05,350 --> 00:02:09,030
>> Y entonces, como he dicho antes, se trata de mapas de bits, así como JPEG.

36
00:02:09,030 --> 00:02:13,170
Así que en realidad la comprensión de la estructura de cómo se organizan los archivos,

37
00:02:13,170 --> 00:02:16,170
cómo realmente podemos traducir el 0 y 1 en las estructuras

38
00:02:16,170 --> 00:02:19,040
y las cosas que en realidad podemos entender e interpretar y editar,

39
00:02:19,040 --> 00:02:21,000
que va a ser muy importante,

40
00:02:21,000 --> 00:02:25,970
así que ir en JPEG y archivos de mapa de bits y la comprensión de la estructura de esos.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, como de costumbre, comienza con una sección de preguntas.

42
00:02:30,780 --> 00:02:36,600
Los que se ocupará de archivo de E / S y conseguir que acostumbrados a eso.

43
00:02:36,600 --> 00:02:42,520
A continuación, la parte 1 es Quién lo hizo, en el que se te da un archivo de mapa de bits

44
00:02:42,520 --> 00:02:45,630
que se ve un poco como puntos rojos por todas partes.

45
00:02:45,630 --> 00:02:52,180
Y básicamente lo que vamos a hacer es tomar este archivo y editarlo sólo ligeramente

46
00:02:52,180 --> 00:02:54,010
en una versión que se puede leer.

47
00:02:54,010 --> 00:02:56,000
Básicamente, una vez que terminemos, vamos a tener el mismo archivo,

48
00:02:56,000 --> 00:03:02,630
excepto que será capaz de ver el mensaje oculto escondido por todos los puntos rojos.

49
00:03:02,630 --> 00:03:07,310
Entonces Resize es un programa que, dado un archivo

50
00:03:07,310 --> 00:03:11,490
y luego se da el nombre del archivo que se envía y se le da un número, así,

51
00:03:11,490 --> 00:03:16,850
realidad que cambia el tamaño de mapa de bits que valor entero.

52
00:03:16,850 --> 00:03:19,240
Entonces, por último, tenemos el conjunto de procesadores Recover.

53
00:03:19,240 --> 00:03:24,160
Se nos ha dado una tarjeta de memoria y luego tener que recuperar todas las fotos

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

55
00:03:25,920 --> 00:03:31,420
pero, como vamos a aprender, no elimina realmente y se elimina del archivo;

56
00:03:31,420 --> 00:03:38,470
simplemente un poco perdido en el que se encontraban en el archivo, pero vamos a recuperar eso.

57
00:03:38,470 --> 00:03:44,950
>> Grande. Así que va en el archivo de E / S en concreto, se trata de toda una lista de funciones que se va a utilizar.

58
00:03:44,950 --> 00:03:49,840
Ya has visto un poco los fundamentos de fopen, fread, fwrite, y

59
00:03:49,840 --> 00:03:54,350
pero vamos a profundizar en algún archivo de E / S funciona como fputc,

60
00:03:54,350 --> 00:03:56,930
en el que acaba de escribir un carácter a la vez,

61
00:03:56,930 --> 00:04:02,000
a fseek, donde se mueve el tipo de indicador de posición del fichero hacia delante y hacia atrás,

62
00:04:02,000 --> 00:04:05,770
y luego algunos otros. Pero vamos a entrar en eso un poco más tarde, durante el conjunto de procesadores.

63
00:04:08,050 --> 00:04:13,100
>> Así que primero, sólo para entrar en el archivo de E / S antes de entrar en el conjunto de procesadores,

64
00:04:13,100 --> 00:04:19,860
para abrir un archivo, por ejemplo, lo que tienes que hacer es establecer realmente un puntero a ese archivo.

65
00:04:19,860 --> 00:04:22,710
Así que tenemos un puntero FILE *.

66
00:04:22,710 --> 00:04:27,140
En este caso, estoy llamándolo un puntero porque eso va a ser mi infile.

67
00:04:27,140 --> 00:04:33,340
Así que voy a utilizar la función fopen y luego el nombre del archivo

68
00:04:33,340 --> 00:04:36,360
y entonces el modo en el que yo voy a estar tratando con el archivo.

69
00:04:36,360 --> 00:04:42,080
Así que hay "r" en este caso para la lectura, "w" para escritura, y luego "a" para anexar.

70
00:04:42,080 --> 00:04:44,270
Por ejemplo, cuando usted está tratando con un infile

71
00:04:44,270 --> 00:04:47,310
y todo lo que quieres hacer es leer los bits y los bytes almacenados allí,

72
00:04:47,310 --> 00:04:50,420
entonces usted está probablemente va a querer utilizar "r" como su modo.

73
00:04:50,420 --> 00:04:54,520
Cuando quiera escribir en realidad, una especie de hacer un nuevo archivo,

74
00:04:54,520 --> 00:04:57,220
entonces lo que vamos a hacer es que vamos a abrir el nuevo archivo

75
00:04:57,220 --> 00:05:02,410
y el uso de la "w" modo de escritura.

76
00:05:02,410 --> 00:05:07,540
>> Así que cuando usted está en realidad la lectura en los archivos, la estructura es la siguiente.

77
00:05:07,540 --> 00:05:14,930
En primer lugar se incluye el puntero a la estructura que contiene los bytes que usted está leyendo.

78
00:05:14,930 --> 00:05:19,830
Así que va a ser la ubicación final de los bytes que se está leyendo.

79
00:05:19,830 --> 00:05:23,360
Estás pasando luego a indicar el tamaño, al igual que, básicamente, la cantidad de bytes

80
00:05:23,360 --> 00:05:30,100
su programa tiene que leer en el archivo, el tamaño, básicamente, un elemento es,

81
00:05:30,100 --> 00:05:32,620
y entonces usted va a especificar cuántos elementos que desea leer.

82
00:05:32,620 --> 00:05:34,980
Y finalmente, usted tiene que saber dónde usted está leyendo,

83
00:05:34,980 --> 00:05:37,580
así que eso va a ser el puntero en.

84
00:05:37,580 --> 00:05:41,780
I codificados por color estos porque fread es también muy similar a fwrite,

85
00:05:41,780 --> 00:05:47,050
a menos que usted quiere asegurarse de que se utiliza el orden correcto,

86
00:05:47,050 --> 00:05:51,960
asegurarse de que en realidad estás escribiendo o leyendo desde el archivo correcto.

87
00:05:54,910 --> 00:05:58,610
>> Así que, como antes, si tenemos el tamaño del elemento, así como el número de elementos,

88
00:05:58,610 --> 00:06:00,600
entonces podemos jugar aquí un poco.

89
00:06:00,600 --> 00:06:06,810
Decir que tengo una estructura PERRO Y entonces quiero leer dos perros a la vez.

90
00:06:06,810 --> 00:06:12,450
Lo que podría hacer es decir el tamaño de un elemento que va a ser del tamaño de un perro

91
00:06:12,450 --> 00:06:14,770
y yo voy a leer realmente dos de ellos.

92
00:06:14,770 --> 00:06:18,290
Por otra parte, lo que podría hacer es decir que sólo voy a leer uno de los elementos

93
00:06:18,290 --> 00:06:21,340
y que un elemento va a ser el tamaño de dos perros.

94
00:06:21,340 --> 00:06:24,320
Así que eso es análoga cómo puede tipo de juego un poco con el tamaño y el número de

95
00:06:24,320 --> 00:06:28,250
dependiendo de lo que es más intuitivo para usted.

96
00:06:28,250 --> 00:06:30,810
>> Está bien. Ahora llegamos a los archivos de escritura.

97
00:06:30,810 --> 00:06:36,880
Si desea escribir un archivo, el primer argumento es en realidad donde usted está leyendo.

98
00:06:36,880 --> 00:06:42,050
Así que eso es, básicamente, los datos que se van a escribir en el fichero,

99
00:06:42,050 --> 00:06:44,490
que es el puntero al final.

100
00:06:44,490 --> 00:06:47,670
Así que cuando usted está tratando con el conjunto de procesadores, asegúrese de que no se confundan.

101
00:06:47,670 --> 00:06:50,480
Tal vez tener el lado definiciones a lado.

102
00:06:50,480 --> 00:06:58,090
Puede tirar de las definiciones en el manual tecleando man y fwrite, por ejemplo,

103
00:06:58,090 --> 00:06:59,950
en la terminal, o puede referirse a esta diapositiva

104
00:06:59,950 --> 00:07:03,570
y asegúrese de que está utilizando la correcta.

105
00:07:03,570 --> 00:07:08,700
Así que de nuevo, por fwrite, cuando usted tiene un archivo que se desea escribir en,

106
00:07:08,700 --> 00:07:14,290
que va a ser el último argumento y eso va a ser un puntero a ese archivo.

107
00:07:14,290 --> 00:07:18,670
Así que eso es lo que tratamos de escribir tal vez varios bytes a la vez,

108
00:07:18,670 --> 00:07:21,820
pero dice que quiere escribir justo en sólo un carácter único.

109
00:07:21,820 --> 00:07:25,940
Como veremos más adelante en este ejemplo, en los mapas de bits que tendremos que usar eso.

110
00:07:25,940 --> 00:07:32,180
Es entonces cuando podemos utilizar fputc, esencialmente sólo poner un carácter a la vez, chr,

111
00:07:32,180 --> 00:07:37,050
en el puntero de archivo, y ese es nuestro puntero a cabo allí.

112
00:07:38,700 --> 00:07:41,560
Así que cada vez que buscar o escribir en un archivo,

113
00:07:41,560 --> 00:07:44,690
el archivo es no perder de vista donde estamos.

114
00:07:44,690 --> 00:07:47,810
Así que es una especie de cursor, el indicador de posición del archivo.

115
00:07:47,810 --> 00:07:54,330
Y así, cada vez que escribimos o leemos de nuevo en un archivo,

116
00:07:54,330 --> 00:07:56,760
el archivo realmente recuerda donde está,

117
00:07:56,760 --> 00:07:59,270
y por lo que continúa desde donde está el cursor.

118
00:07:59,270 --> 00:08:03,970
Esto puede ser beneficioso cuando se quiere, por ejemplo, leer en una cierta cantidad para hacer algo

119
00:08:03,970 --> 00:08:06,160
y luego leer en las siguientes cantidades,

120
00:08:06,160 --> 00:08:10,700
pero a veces puede ser que desee volver o en realidad parten de un valor de referencia determinado.

121
00:08:10,700 --> 00:08:16,870
Entonces la función fseek, lo que hace es que nos permite mover el cursor en un determinado archivo

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

123
00:08:19,680 --> 00:08:24,260
Y entonces lo que tenemos que hacer es especificar que el valor de referencia es.

124
00:08:24,260 --> 00:08:31,520
Así que, o se mueve hacia delante o hacia atrás desde la posición del cursor en la actualidad es,

125
00:08:31,520 --> 00:08:35,750
o se puede especificar que solo debe moverse desde el principio del archivo

126
00:08:35,750 --> 00:08:37,090
o desde el final del archivo.

127
00:08:37,090 --> 00:08:41,230
Y por lo que puede pasar en valores negativos o positivos a cantidad,

128
00:08:41,230 --> 00:08:44,960
y que clase de mover el cursor hacia adelante o hacia atrás.

129
00:08:46,170 --> 00:08:51,920
>> Antes de entrar en los conjuntos de procesadores otras preguntas en el archivo I / O?

130
00:08:53,860 --> 00:08:59,990
Bien. Al entrar en más ejemplos, no dude en dejar de hacer preguntas.

131
00:08:59,990 --> 00:09:06,930
>> Así que en Whodunit, te entregó un archivo de mapa de bits similar a esta red en la diapositiva,

132
00:09:06,930 --> 00:09:14,510
y parece que esto - un montón de puntos rojos - y no se sabe muy bien lo que está escrito.

133
00:09:14,510 --> 00:09:23,310
Si usted escudriña, usted puede ser capaz de ver un ligero color azulado en el interior del centro.

134
00:09:23,310 --> 00:09:26,270
En esencia, eso es donde el texto se almacena.

135
00:09:26,270 --> 00:09:30,270
Hubo un asesinato que ocurrió, y tenemos que averiguar quién lo hizo.

136
00:09:30,270 --> 00:09:36,760
Con el fin de hacer eso, tenemos que convertir esta especie de imagen en un formato legible.

137
00:09:36,760 --> 00:09:42,740
Si ustedes he encontrado esto, a veces no habría kits pequeños

138
00:09:42,740 --> 00:09:48,510
donde tendría una lupa con una capa de color rojo. ¿Alguien? Si.

139
00:09:48,510 --> 00:09:52,770
Así que sería algo como esto sola mano, usted tendría una lupa

140
00:09:52,770 --> 00:09:58,130
con la película de color rojo sobre él, lo pondría sobre la imagen,

141
00:09:58,130 --> 00:10:03,410
y que sería capaz de ver el mensaje oculto en ella.

142
00:10:03,410 --> 00:10:07,080
No tenemos una lupa con película rojo, así que en vez que vamos a la clase de crear nuestro propio

143
00:10:07,080 --> 00:10:09,060
en este conjunto de procesadores.

144
00:10:09,060 --> 00:10:15,760
Y así, el usuario va a whodunit entrada, entonces la pista,. Bmp,

145
00:10:15,760 --> 00:10:18,800
así que esa es la infile, ese es el mensaje de punto rojo,

146
00:10:18,800 --> 00:10:23,550
y entonces ellos están diciendo verdict.bmp va a ser nuestro archivo de salida.

147
00:10:23,550 --> 00:10:27,900
Así que va a crear una imagen de mapa de bits similar a la idea de una

148
00:10:27,900 --> 00:10:32,600
excepto en un formato legible en el que podemos ver el mensaje oculto.

149
00:10:32,600 --> 00:10:37,550
>> Ya que vamos a estar tratando con la edición y manipulación de mapas de bits de algún tipo,

150
00:10:37,550 --> 00:10:42,400
vamos a clase de buceo en en la estructura de estos archivos de mapa de bits.

151
00:10:42,400 --> 00:10:48,130
Fuimos poco estas un poco en la conferencia, pero vamos a ver en ellos un poco más.

152
00:10:48,130 --> 00:10:51,740
Los mapas de bits son esencialmente sólo un arreglo de bytes

153
00:10:51,740 --> 00:10:55,790
donde hemos especificado qué significa lo bytes.

154
00:10:55,790 --> 00:11:00,540
Así que aquí es algo así como un mapa de la imagen de mapa de bits

155
00:11:00,540 --> 00:11:08,550
diciendo que se inicia con algunos archivos de cabecera, se inicia con un poco de información en ese país.

156
00:11:08,550 --> 00:11:16,540
Ya ves que a eso de byte número 14 se indica el tamaño de la imagen de mapa de bits,

157
00:11:16,540 --> 00:11:18,520
y se continúa.

158
00:11:18,520 --> 00:11:23,810
Pero lo que realmente estamos interesados ​​aquí está empezando alrededor del número de bytes 54.

159
00:11:23,810 --> 00:11:26,060
Tenemos estos triples RGB.

160
00:11:26,060 --> 00:11:30,760
Lo que va a hacer es contener los píxeles reales, los valores de color.

161
00:11:30,760 --> 00:11:35,950
Todo lo anterior que en la cabecera es información

162
00:11:35,950 --> 00:11:41,240
correspondiente al tamaño de la imagen, la anchura de la imagen, y la altura.

163
00:11:41,240 --> 00:11:44,930
Cuando entramos en el relleno más tarde, vamos a ver por qué el tamaño de la imagen

164
00:11:44,930 --> 00:11:48,670
puede ser diferente de la anchura o la altura.

165
00:11:48,670 --> 00:11:54,240
Así que para representar estos - estas imágenes de mapa de bits son secuencias de bytes -

166
00:11:54,240 --> 00:11:59,370
lo que podemos hacer es decir bien, yo voy a recordar que en el índice 14,

167
00:11:59,370 --> 00:12:03,380
ahí es donde el tamaño es, por ejemplo, pero en cambio lo que vamos a hacer para que esto sea más fácil

168
00:12:03,380 --> 00:12:06,020
está encapsulado en una estructura.

169
00:12:06,020 --> 00:12:08,880
Y así tenemos dos estructuras hechas para nosotros, un BITMAPFILEHEADER

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

171
00:12:10,440 --> 00:12:14,840
y así cada vez que leemos a ese archivo, por defecto que va a ir en orden,

172
00:12:14,840 --> 00:12:22,360
y lo que para ella también va a rellenar en variables tales como biWidth y biSize.

173
00:12:25,270 --> 00:12:31,230
Y, finalmente, cada píxel está representado por tres bytes.

174
00:12:31,230 --> 00:12:35,500
La primera es la cantidad de azul en el píxel, el segundo es la cantidad de verde,

175
00:12:35,500 --> 00:12:41,120
y finalmente, la cantidad de rojo, donde 0 es esencialmente no verde azul o no o no roja

176
00:12:41,120 --> 00:12:43,720
y luego ff es el valor máximo.

177
00:12:43,720 --> 00:12:46,800
Estos son valores hexadecimales.

178
00:12:46,800 --> 00:12:53,870
Así que si tenemos ff0000, entonces corresponde a la cantidad máxima de azul

179
00:12:53,870 --> 00:12:58,890
y luego no hay verde y rojo no, es así, que nos daría un píxel azul.

180
00:12:58,890 --> 00:13:04,190
Entonces, si tenemos toda ff en todos los terrenos, entonces eso significa que tenemos un pixel blanco.

181
00:13:04,190 --> 00:13:11,370
Esto es un poco contrario a lo general, cuando decimos RGB. En realidad va BGR.

182
00:13:12,750 --> 00:13:18,990
>> Así que si realmente se ven en un ejemplo de una imagen de mapa de bits - quiero un tirón aquí.

183
00:13:31,560 --> 00:13:33,830
Es un poco pequeña.

184
00:13:39,890 --> 00:13:47,840
Estoy un acercamiento, y podemos ver que está pixelada. Parece que los bloques de color.

185
00:13:47,840 --> 00:13:50,110
Usted tiene bloques blancos y luego los bloques rojos.

186
00:13:50,110 --> 00:13:53,700
Si juegas en Microsoft Paint, por ejemplo, usted podría hacer algo así

187
00:13:53,700 --> 00:13:58,960
básicamente por pintar algunos cuadrados en un orden específico.

188
00:13:58,960 --> 00:14:08,060
Así que lo que se traduce en el mapa de bits es la siguiente.

189
00:14:08,060 --> 00:14:15,710
Aquí tenemos primero píxeles blancos, que son todas las 6 f, y entonces tenemos píxeles rojos,

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

191
00:14:19,910 --> 00:14:27,940
Y así, la secuencia de bytes que tenemos indica cómo la imagen de mapa de bits se va a ver.

192
00:14:27,940 --> 00:14:32,230
Así que lo que hemos hecho aquí es sólo por escrito con todos esos bytes y después se colorea en rojo

193
00:14:32,230 --> 00:14:37,550
para que pueda clase de ver, si usted escudriña un poco, cómo ese tipo de indica una cara sonriente.

194
00:14:40,180 --> 00:14:46,390
>> La forma en que el trabajo de las imágenes de mapa de bits que es básicamente lo imaginamos como una cuadrícula.

195
00:14:46,390 --> 00:14:54,940
Y así, de forma predeterminada, cada fila de la rejilla tiene que ser un múltiplo de 4 bytes.

196
00:15:00,520 --> 00:15:07,060
Si nos fijamos en una imagen de mapa de bits, que está llenando cada valor.

197
00:15:07,060 --> 00:15:17,370
Por ejemplo, usted podría tener un rojo por aquí, un verde aquí, un azul aquí,

198
00:15:17,370 --> 00:15:24,950
pero usted tiene que asegurarse de que la imagen se completa con un múltiplo de cuatro bytes.

199
00:15:24,950 --> 00:15:32,200
Así que si quiero que mi imagen sea tres cuadras de ancho, entonces yo tendría que poner un valor vacío

200
00:15:32,200 --> 00:15:35,640
en el último para que sea un múltiplo de cuatro.

201
00:15:35,640 --> 00:15:39,530
Así que me gustaría añadir algo en lo que estamos llamando relleno.

202
00:15:39,530 --> 00:15:43,750
Yo sólo voy a indicar que hay con una x.

203
00:15:44,920 --> 00:15:54,160
Ahora decimos que queremos una imagen que es de 7 píxeles de largo, por ejemplo.

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

205
00:16:04,750 --> 00:16:07,000
y todo eso se rellena con el color.

206
00:16:07,000 --> 00:16:10,620
La forma en que las imágenes de mapa de bits funciona es que necesitamos una octava.

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

208
00:16:12,460 --> 00:16:19,360
Necesitamos 8 espacios para la imagen de mapa de bits a leer correctamente.

209
00:16:19,360 --> 00:16:25,600
Así que lo que tenemos que hacer es añadir en tan sólo un poco de relleno

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

211
00:16:29,430 --> 00:16:34,260
y que todas las anchuras son un múltiplo de 4.

212
00:16:42,110 --> 00:16:47,310
Y así se ha indicado anteriormente, el relleno como una X o una línea ondulada,

213
00:16:47,310 --> 00:16:53,880
pero en las imágenes de mapa de bits reales el relleno se indica mediante un 0 hexadecimal.

214
00:16:53,880 --> 00:16:57,340
Así que sería un personaje único, 0.

215
00:16:58,980 --> 00:17:06,329
Lo que podría ser útil es el comando xxd.

216
00:17:06,329 --> 00:17:11,220
Lo que hace es en realidad muestra que, al igual que similar a lo que hacía antes con el smiley

217
00:17:11,220 --> 00:17:15,630
cuando en realidad lo que imprime cada color sería para el píxel

218
00:17:15,630 --> 00:17:21,800
y luego un código de colores, cuando se ejecuta xxd con los siguientes comandos,

219
00:17:21,800 --> 00:17:28,670
entonces en realidad se imprimirá lo que los colores son para aquellos píxeles.

220
00:17:28,670 --> 00:17:33,810
Lo que tienes que hacer es indicar aquí que, al igual que la s-54

221
00:17:33,810 --> 00:17:36,530
dice que yo voy a empezar por el byte 54a

222
00:17:36,530 --> 00:17:40,820
porque antes de eso, recuerde que si echamos la vista atrás para el mapa de los mapas de bits,

223
00:17:40,820 --> 00:17:42,690
esa es toda la información de cabecera y cosas por el estilo.

224
00:17:42,690 --> 00:17:46,280
Pero lo que realmente importa es los píxeles reales que indican el color.

225
00:17:46,280 --> 00:17:52,700
Por lo tanto añadiendo en esa bandera,-s 54, entonces somos capaces de ver los valores de color.

226
00:17:52,700 --> 00:17:56,020
Y no te preocupes por las banderas complicadas y cosas por el estilo.

227
00:17:56,020 --> 00:18:05,020
En la especificación del conjunto de problemas, tendrá instrucciones sobre cómo utilizar xxd para mostrar los píxeles.

228
00:18:07,070 --> 00:18:15,590
Así que si usted ve aquí, es como que se parece a una caja verde, esto es poca cosa.

229
00:18:15,590 --> 00:18:23,610
He codificado por colores como el 00ff00 básicamente diciendo que no azul, mucho verde y rojo no.

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

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

232
00:18:31,920 --> 00:18:36,660
Este rectángulo verde está a sólo 3 píxeles de ancho, por lo que entonces lo que tenemos que hacer

233
00:18:36,660 --> 00:18:44,350
para asegurarse de que la imagen es un múltiplo de 4 de ancho es añadir en un acolchado adicional.

234
00:18:44,350 --> 00:18:49,460
Y entonces así es como se ve estos 0s aquí.

235
00:18:49,460 --> 00:18:54,510
En realidad, esto será el resultado de su conjunto de procesadores de tamaño,

236
00:18:54,510 --> 00:19:01,350
esencialmente tomando el pequeño mapa de bits y luego ampliarlo por 4.

237
00:19:01,350 --> 00:19:09,380
Y así, lo que vemos es que en realidad esta imagen es de 12 píxeles de ancho, pero 12 es un múltiplo de 4,

238
00:19:09,380 --> 00:19:12,940
por lo que en realidad no veo ninguna 0s al final porque no es necesario añadir ningún

239
00:19:12,940 --> 00:19:19,070
porque está totalmente acolchado. No tiene sala más.

240
00:19:20,720 --> 00:19:23,470
>> Bien. Cualquier pregunta acerca de relleno?

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

242
00:19:27,460 --> 00:19:32,520
>> Como he mencionado antes, los mapas de bits son más que una secuencia de bytes.

243
00:19:32,520 --> 00:19:39,170
Y así, lo que tenemos es en lugar de tener que llevar un registro de exactamente qué número de bytes

244
00:19:39,170 --> 00:19:47,050
corresponde a un elemento específico, que en realidad han creado una estructura para representar eso.

245
00:19:47,050 --> 00:19:50,930
Así que lo que tenemos es una estructura RGBTRIPLE.

246
00:19:50,930 --> 00:19:54,590
Siempre que tenga una instancia de un triple RGB,

247
00:19:54,590 --> 00:20:00,970
porque se trata de un tipo struct define, entonces usted puede acceder a la variable rgbtBlue,

248
00:20:00,970 --> 00:20:09,520
de manera similar las variables de verde y rojo, que indican la cantidad de azul, verde y rojo

249
00:20:09,520 --> 00:20:11,580
respectivamente, que usted tiene.

250
00:20:11,580 --> 00:20:16,800
>> Así que si tenemos la variable de azul a 0, el conjunto verde a ff,

251
00:20:16,800 --> 00:20:22,060
que es el valor máximo que puede tener, y entonces la variable rojo ajustado a 0,

252
00:20:22,060 --> 00:20:27,870
entonces, ¿qué color sería el particular triples RGB representa? >> [Estudiante] Green.

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

254
00:20:29,150 --> 00:20:34,480
Va a ser útil saber que cada vez que tenga una instancia de un triple RGB,

255
00:20:34,480 --> 00:20:41,340
en realidad se puede acceder a la cantidad de color - azul, verde y rojo - por separado.

256
00:20:43,350 --> 00:20:54,900
>> Ahora que hemos hablado de la estructura de eso, vamos a echar un vistazo al archivo BMP.

257
00:20:54,900 --> 00:20:57,870
Estas son estructuras hechas para usted.

258
00:20:57,870 --> 00:21:01,820
Aquí tenemos una estructura BITMAPFILEHEADER.

259
00:21:01,820 --> 00:21:07,610
De interés es el tamaño.

260
00:21:07,610 --> 00:21:12,660
Más tarde, tenemos la información de cabecera, que tiene un par de cosas más que son interesantes para nosotros,

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

262
00:21:15,480 --> 00:21:19,170
Como vamos a entrar en más tarde, cuando se lee en el archivo,

263
00:21:19,170 --> 00:21:25,500
se lee automáticamente en porque hemos creado la orden de ser el mismo.

264
00:21:25,500 --> 00:21:31,990
Así la biSize contendrá los bytes adecuadas que se corresponden con el tamaño real de la imagen.

265
00:21:34,700 --> 00:21:40,500
Y aquí, por último, como ya hemos hablado, tenemos el typedef struct RGBTRIPLE.

266
00:21:40,500 --> 00:21:46,840
Tenemos una rgbtBlue, verde y rojo asociado a él.

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

268
00:21:49,340 --> 00:21:56,360
Ahora que entendemos los mapas de bits un poco, entendemos que tenemos un archivo de cabecera

269
00:21:56,360 --> 00:22:00,790
y una cabecera de información de la misma y después de eso, tenemos las cosas interesantes

270
00:22:00,790 --> 00:22:05,110
de los colores, y los colores están representados por las estructuras RGBTRIPLE,

271
00:22:05,110 --> 00:22:12,710
y los que, a su vez, tiene tres valores asociados a la azul, el verde y el rojo.

272
00:22:12,710 --> 00:22:17,270
>> Así que ahora, podemos pensar en clase de recuperar un poco.

273
00:22:17,270 --> 00:22:20,130
Lo siento. Piense Whodunit.

274
00:22:20,130 --> 00:22:25,750
Cuando tenemos nuestro archivo de pista, entonces lo que queremos hacer es leer a ella pixel por pixel

275
00:22:25,750 --> 00:22:33,860
y entonces de alguna manera cambiar los píxeles de manera que podamos dar salida a un formato legible.

276
00:22:33,860 --> 00:22:41,020
Y así, para dar salida, vamos a escribir pixel por pixel en el archivo verdict.bmp.

277
00:22:41,020 --> 00:22:45,120
Eso es un poco mucho para hacer. Nos damos cuenta de eso.

278
00:22:45,120 --> 00:22:49,860
Así que lo que hemos hecho es que hemos hecho le proporcionó copy.c.

279
00:22:49,860 --> 00:22:57,610
Lo que hace es copy.c sólo hace una copia exacta de un archivo de mapa de bits dado y luego la emite.

280
00:22:57,610 --> 00:23:01,900
Así que esto ya se abre el archivo para usted, se lee en pixel por pixel,

281
00:23:01,900 --> 00:23:04,510
y entonces se escribe en un archivo de salida en.

282
00:23:04,510 --> 00:23:07,080
>> Vamos a echar un vistazo a eso.

283
00:23:13,390 --> 00:23:18,290
Esta es asegurar el uso adecuado,

284
00:23:18,290 --> 00:23:22,640
obtener los nombres de los archivos aqui.

285
00:23:22,640 --> 00:23:29,940
Lo que esto hace es que establece el archivo de entrada sea lo que hemos pasado en el infile aquí,

286
00:23:29,940 --> 00:23:34,750
que es nuestro segundo argumento de línea de comandos.

287
00:23:34,750 --> 00:23:37,640
Se asegura de que podamos abrir el archivo.

288
00:23:38,960 --> 00:23:44,860
Cheques para asegurarnos de que podemos hacer un nuevo archivo de salida aquí.

289
00:23:45,630 --> 00:23:53,270
Entonces, ¿qué hace este aquí, sólo, básicamente, comienza a leer en el archivo de mapa de bits desde el principio.

290
00:23:53,270 --> 00:23:56,700
El comienzo, como sabemos, contiene el BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
y por lo que esas secuencias de bits directamente completará el BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Así que lo que tenemos aquí está diciendo que bf BITMAPFILEHEADER -

293
00:24:07,940 --> 00:24:13,150
esa es nuestra nueva variable de tipo BITMAPFILEHEADER -

294
00:24:13,150 --> 00:24:22,560
vamos a poner dentro bf lo que leemos de puntero, que es nuestro infile.

295
00:24:22,560 --> 00:24:23,970
¿Cuánto leemos?

296
00:24:23,970 --> 00:24:32,160
Leemos en la cantidad de bytes que necesitamos para contener el BITMAPFILEHEADER conjunto.

297
00:24:32,160 --> 00:24:34,660
Del mismo modo, eso es lo que hacemos por la información de cabecera.

298
00:24:34,660 --> 00:24:39,010
Así que seguimos a lo largo de nuestro archivo en el infile,

299
00:24:39,010 --> 00:24:44,360
y nos estamos leyendo los bits y bytes, y los estamos conectando directamente en

300
00:24:44,360 --> 00:24:47,880
en estos casos de las variables que estamos haciendo.

301
00:24:49,370 --> 00:24:53,800
Aquí sólo estamos asegurando que el mapa de bits es un mapa de bits.

302
00:24:57,670 --> 00:25:01,030
>> Ahora tenemos un archivo de salida, ¿no?

303
00:25:01,030 --> 00:25:04,420
Así que tal y como está cuando lo creamos, es esencialmente vacío.

304
00:25:04,420 --> 00:25:07,710
Así que tenemos que crear un nuevo mapa de bits, básicamente, a partir de cero.

305
00:25:07,710 --> 00:25:12,280
Lo que hacemos es que tenemos que asegurarnos de que copiar en el archivo de cabecera

306
00:25:12,280 --> 00:25:16,850
y la información de cabecera al igual que el infile tiene.

307
00:25:16,850 --> 00:25:22,850
Lo que hacemos es escribir - y recuerde que bf es la variable

308
00:25:22,850 --> 00:25:29,300
de BITMAPFILEHEADER tipo, así que lo que hacemos es que sólo tiene que utilizar ese contenido

309
00:25:29,300 --> 00:25:34,980
para escribir en el archivo de salida.

310
00:25:36,550 --> 00:25:38,510
En este sentido, recuerdo que hablamos sobre el relleno,

311
00:25:38,510 --> 00:25:47,820
cómo es importante asegurarse de que la cantidad de píxeles que tenemos es un múltiplo de 4.

312
00:25:47,820 --> 00:25:52,790
Esta es una fórmula muy útil para calcular la cantidad de relleno que tiene

313
00:25:52,790 --> 00:25:57,670
dada la anchura de su archivo.

314
00:25:57,670 --> 00:26:04,120
Yo quiero que ustedes recuerden que en copy.c tenemos una fórmula para el cálculo de relleno.

315
00:26:04,120 --> 00:26:07,970
¿De acuerdo? Así que todo el mundo recuerda eso. Grande.

316
00:26:07,970 --> 00:26:14,050
Entonces, ¿qué hace copy.c siguiente es que se repite en todas las líneas de exploración.

317
00:26:14,050 --> 00:26:23,730
Pasa a través de las filas primera y luego almacena cada triple que se lee

318
00:26:23,730 --> 00:26:26,920
y entonces se escribe en el archivo de salida.

319
00:26:26,920 --> 00:26:33,120
Así que aquí estamos leyendo sólo un triple de RGB a la vez

320
00:26:33,120 --> 00:26:39,860
y luego poner que Triple mismos en el archivo de salida.

321
00:26:41,120 --> 00:26:48,340
La parte difícil es que el relleno no es un triple RGB,

322
00:26:48,340 --> 00:26:55,200
y por lo tanto no podemos leer esa cantidad de relleno triples RGB.

323
00:26:55,200 --> 00:27:01,460
Lo que tenemos que hacer es en realidad sólo mover nuestro indicador de posición del fichero, desplazar el cursor,

324
00:27:01,460 --> 00:27:06,840
al tipo de saltarse todo el relleno de modo que estamos en la fila siguiente.

325
00:27:06,840 --> 00:27:12,990
Y entonces lo que hace es copiar muestra cómo es posible que desee agregar el relleno.

326
00:27:12,990 --> 00:27:14,990
Para ello hemos calculado la cantidad de relleno que necesitamos,

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

328
00:27:18,220 --> 00:27:24,510
Lo que hace es un bucle que sitúa el número de 0s acolchado en nuestro archivo de salida.

329
00:27:24,510 --> 00:27:31,170
Y, finalmente, se cierra ambos archivos. Se cierra el infile así como el archivo de salida.

330
00:27:31,170 --> 00:27:34,870
>> Así es como funciona copy.c,

331
00:27:34,870 --> 00:27:37,430
y eso va a ser muy útil.

332
00:27:39,720 --> 00:27:43,750
En lugar de simplemente en realidad directamente copiar y pegar

333
00:27:43,750 --> 00:27:46,800
o simplemente mirarlo y escribir lo que quieras,

334
00:27:46,800 --> 00:27:49,440
puede que desee para ejecutar este comando en la terminal,

335
00:27:49,440 --> 00:27:54,520
cp copy.c whodunit.c, lo que creará un nuevo archivo, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
que incluye el contenido exactamente igual que copia lo hace.

337
00:27:58,330 --> 00:28:03,880
Así que lo que podemos hacer es usar eso como una base sobre la cual construir y editar

338
00:28:03,880 --> 00:28:06,900
para nuestro archivo novela policíaca.

339
00:28:08,500 --> 00:28:14,670
>> Estas son nuestras tareas pendientes que hacer para Whodunit, pero ¿qué copy.c

340
00:28:14,670 --> 00:28:16,730
en realidad se encarga de la mayor parte de ellos para nosotros.

341
00:28:16,730 --> 00:28:21,900
Así que todo lo que tenemos que hacer ahora es cambiar los píxeles según sea necesario

342
00:28:21,900 --> 00:28:25,920
para hacer realidad el archivo legible.

343
00:28:25,920 --> 00:28:32,960
Recuerde que para un píxel dado, triple, así que para una variable dada de RGBTRIPLE tipo,

344
00:28:32,960 --> 00:28:35,990
puede acceder a los valores de azul, verde y rojo.

345
00:28:35,990 --> 00:28:38,670
Eso va a ser muy útil porque si se puede acceder a ellos,

346
00:28:38,670 --> 00:28:41,770
que significa que también se puede comprobar,

347
00:28:41,770 --> 00:28:45,430
y eso significa que también se puede cambiar.

348
00:28:45,430 --> 00:28:49,430
>> Así que cuando volvimos a nuestro ejemplo rojo lupa,

349
00:28:49,430 --> 00:28:53,390
básicamente, que actuaba como una especie de filtro para nosotros.

350
00:28:53,390 --> 00:28:58,160
Así que lo que quiero hacer es que queremos filtrar todos los triples que vienen pulg

351
00:28:58,160 --> 00:29:01,240
Hay varias maneras de hacer esto.

352
00:29:01,240 --> 00:29:07,100
Básicamente, usted puede tener cualquier tipo de filtro que desee.

353
00:29:07,100 --> 00:29:09,890
Tal vez usted quiere cambiar todos los píxeles rojos

354
00:29:09,890 --> 00:29:13,570
o tal vez desea cambiar un píxel de color a un color diferente.

355
00:29:13,570 --> 00:29:15,400
Eso depende de ti.

356
00:29:15,400 --> 00:29:19,580
Recuerde que usted puede ver que el color del píxel es

357
00:29:19,580 --> 00:29:23,000
y también se puede cambiar a medida que estás pasando.

358
00:29:24,410 --> 00:29:26,420
>> Bien. Así que eso es Whodunit.

359
00:29:26,420 --> 00:29:32,760
Una vez que ejecute Quién lo hizo, usted sabrá quién es el culpable del crimen era.

360
00:29:32,760 --> 00:29:35,540
>> Ahora vamos a ir a cambiar el tamaño.

361
00:29:35,540 --> 00:29:37,990
Vamos a todavía estar tratando con mapas de bits.

362
00:29:37,990 --> 00:29:40,750
Lo que vamos a hacer es que vamos a tener un mapa de bits de entrada

363
00:29:40,750 --> 00:29:45,890
y luego vamos a pasar en un número y obtener un mapa de bits archivosalida

364
00:29:45,890 --> 00:29:51,380
donde eso es básicamente nuestro infile escalado por n.

365
00:29:54,670 --> 00:30:01,450
Di mi archivo era sólo un pixel grande.

366
00:30:01,450 --> 00:30:09,100
Entonces, si mi n fue de 3, escalado por 3, entonces me gustaría repetir ese pixel n número de veces,

367
00:30:09,100 --> 00:30:14,410
por lo que 3 veces, y luego también reduce la escala 3 veces también.

368
00:30:14,410 --> 00:30:17,840
Así que ya ves que estoy escalando tanto vertical como horizontalmente.

369
00:30:17,840 --> 00:30:19,680
>> Y he aquí un ejemplo.

370
00:30:19,680 --> 00:30:27,590
Si tiene n = 2, se ve que el píxel azul principio no repitió dos veces

371
00:30:27,590 --> 00:30:30,930
tanto horizontal como verticalmente dos veces.

372
00:30:30,930 --> 00:30:38,040
Y luego que sigue adelante, y para que tenga una ampliación directa de la imagen original en dos.

373
00:30:40,920 --> 00:30:47,600
>> Así que si nos íbamos a detalle el pseudocódigo para esto, queremos abrir el archivo.

374
00:30:47,600 --> 00:30:49,880
Y luego, a sabiendas de que si volvemos aquí,

375
00:30:49,880 --> 00:30:54,540
vemos que la anchura para el archivo de salida que va a ser diferente de la anchura de la infile.

376
00:30:54,540 --> 00:30:56,130
¿Qué significa eso?

377
00:30:56,130 --> 00:31:01,230
Eso significa que nuestra información de cabecera se va a cambiar.

378
00:31:01,230 --> 00:31:03,790
¿Y qué vamos a querer hacer es actualizar la información de la cabecera,

379
00:31:03,790 --> 00:31:11,820
sabiendo que cuando leemos en los archivos si usted está trabajando en el marco copy.c,

380
00:31:11,820 --> 00:31:17,570
ya tenemos una variable que indica cuál es el tamaño es y cosas así.

381
00:31:17,570 --> 00:31:24,060
Así que una vez conseguido eso, lo que puede querer hacer es cambiar esas variables particulares.

382
00:31:24,060 --> 00:31:29,380
Recuerde, si usted tiene una estructura, cómo se accede a las variables dentro de eso.

383
00:31:29,380 --> 00:31:32,080
Se utiliza el operador punto, ¿no?

384
00:31:32,080 --> 00:31:36,420
Así que con eso, ya sabes que tendrás que cambiar la información de la cabecera.

385
00:31:36,480 --> 00:31:41,030
Así que esta es sólo una lista de los elementos reales que se van a cambiar en el archivo.

386
00:31:41,030 --> 00:31:45,180
El tamaño del archivo que se va a cambiar, la imagen, así como la anchura y la altura.

387
00:31:45,180 --> 00:31:50,080
Así que volver al mapa de los mapas de bits,

388
00:31:50,080 --> 00:31:57,730
ver si se trata de la cabecera del archivo o la información de cabecera que contiene esa información

389
00:31:57,730 --> 00:32:00,920
y luego cambiar según sea necesario.

390
00:32:05,010 --> 00:32:12,470
Una vez más, por ejemplo cp copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
Eso significa que resize.c ahora contiene todo lo que está contenido en el interior copia

392
00:32:19,270 --> 00:32:24,490
copia porque nos proporciona una forma de lectura en línea de exploración a cada píxel a píxel.

393
00:32:24,490 --> 00:32:29,860
Sólo que ahora, en vez de cambiar los valores como lo hicimos en Whodunit,

394
00:32:29,860 --> 00:32:37,980
lo que queremos hacer es que queremos escribir en varios píxeles

395
00:32:37,980 --> 00:32:43,580
mientras nuestro n es mayor que 1.

396
00:32:43,580 --> 00:32:47,110
>> Entonces lo que quiero hacer es lo queremos estirar horizontalmente por n,

397
00:32:47,110 --> 00:32:50,490
así como que se extienden verticalmente por n.

398
00:32:50,490 --> 00:32:52,710
¿Cómo podemos hacer esto?

399
00:32:52,710 --> 00:32:56,890
Digamos que su n es 2 y que tiene esta dado infile.

400
00:32:56,890 --> 00:32:58,730
El cursor se va a empezar por el primero,

401
00:32:58,730 --> 00:33:03,530
y lo que quiere hacer si n es 2, que desea imprimir en 2 de ellos.

402
00:33:03,530 --> 00:33:05,490
Así que imprimir en dos de ellos.

403
00:33:05,490 --> 00:33:10,830
A continuación, el cursor se va a pasar a la siguiente píxel, que es el rojo,

404
00:33:10,830 --> 00:33:18,400
y que va a imprimir 2 de esos rojos, añadiendo que en lo que ha hecho antes.

405
00:33:18,400 --> 00:33:26,280
A continuación, el cursor se moverá a la siguiente píxel y dibujar en 2 de ellos.

406
00:33:26,280 --> 00:33:37,180
Si se mira de nuevo a la copy.c marco, lo que esto hace aquí

407
00:33:37,180 --> 00:33:42,830
se crea una nueva instancia de un triple RGB, una nueva variable llamada triple.

408
00:33:42,830 --> 00:33:50,500
Y aquí cuando lee en él, lo hace desde el 1 infile RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
y se almacena en el interior de esa variable triple.

410
00:33:53,470 --> 00:33:57,590
Así que en realidad tiene una variable que representa ese píxel en particular.

411
00:33:57,590 --> 00:34:05,290
Entonces, cuando usted escribe, lo que puede querer hacer es encerrar la declaración fwrite en un bucle for

412
00:34:05,290 --> 00:34:11,080
que escribe en su archivo de salida tantas veces como sea necesario.

413
00:34:17,449 --> 00:34:20,100
Eso es bastante simple.

414
00:34:20,200 --> 00:34:27,590
Así, básicamente, repita el proceso de escritura n número de veces para escalar horizontalmente.

415
00:34:27,590 --> 00:34:32,969
>> Pero tenemos que recordar que nuestro relleno se va a cambiar.

416
00:34:47,350 --> 00:34:53,020
Antes, decir que tuvimos algo de longitud 3.

417
00:34:53,020 --> 00:35:00,130
Entonces nos volveríamos a añadir en el relleno? Sólo uno más para que sea un múltiplo de 4.

418
00:35:00,130 --> 00:35:10,480
Pero decir que estamos escalando esta imagen en particular por n = 2.

419
00:35:10,480 --> 00:35:16,300
Entonces ¿cuántos píxeles azules tendríamos al final? Tendríamos 6.

420
00:35:16,300 --> 00:35:21,470
1, 2, 3, 4, 5, 6. Está bien.

421
00:35:21,470 --> 00:35:26,580
6 no es un múltiplo de 4. ¿Cuál es el más cercano múltiplo de 4? Eso va a ser 8.

422
00:35:26,580 --> 00:35:33,200
Así que estamos realmente va a tener dos caracteres de relleno allí.

423
00:35:33,200 --> 00:35:38,720
>> ¿Alguien recuerda si tenemos una fórmula para calcular el relleno

424
00:35:38,720 --> 00:35:41,350
y dónde podría estar?

425
00:35:41,350 --> 00:35:45,160
[Respuesta de los estudiantes inaudible] >> Sí, copy.c. Derecha.

426
00:35:45,160 --> 00:35:49,800
Hay una fórmula en copy.c para calcular la cantidad de relleno que tiene

427
00:35:49,800 --> 00:35:53,810
dado una anchura particular de la imagen de mapa de bits.

428
00:35:53,810 --> 00:36:02,950
Así que va a ser útil cuando se necesita agregar en una cierta cantidad de relleno

429
00:36:02,950 --> 00:36:06,160
de entender realmente a cabo el relleno tiene que agregar.

430
00:36:10,820 --> 00:36:15,850
Pero una nota, sin embargo, es que usted quiere asegurarse de que usted está usando el tamaño correcto.

431
00:36:15,850 --> 00:36:21,410
Sólo ten cuidado porque estás básicamente va a estar tratando con dos imágenes de mapa de bits.

432
00:36:21,410 --> 00:36:23,410
Usted quiere asegurarse de que está utilizando la correcta.

433
00:36:23,410 --> 00:36:26,820
Cuando usted está calculando el relleno para el archivo de salida, que desea utilizar todo el ancho del archivo de salida

434
00:36:26,820 --> 00:36:29,860
y no el ancho de la anterior.

435
00:36:29,860 --> 00:36:37,240
>> Grande. Ese tipo de estiramiento se hace cargo de una imagen de mapa de bits total horizontalmente.

436
00:36:37,240 --> 00:36:41,290
Pero lo que quiero hacer es realmente estirar verticalmente también.

437
00:36:41,290 --> 00:36:48,760
Esto va a ser un poco más complicado porque cuando hemos terminado de copiar una fila

438
00:36:48,760 --> 00:36:51,580
y escribir esa fila, nuestro cursor va a estar en el extremo.

439
00:36:51,580 --> 00:36:56,210
Así que si volvemos a leer, entonces sólo va a leer en la siguiente línea.

440
00:36:56,210 --> 00:37:03,660
Así que lo que quiero hacer es una especie de encontrar alguna forma de copiar las filas de nuevo

441
00:37:03,660 --> 00:37:12,500
o simplemente tomar ese tipo de fila y luego volver a escribir de nuevo.

442
00:37:14,380 --> 00:37:17,940
Como tipo de alusión, hay varias maneras de hacer esto.

443
00:37:17,940 --> 00:37:23,040
Lo que podría hacer es que estás pasando y la lectura a través de la línea de exploración especial

444
00:37:23,040 --> 00:37:28,560
y cambiarlo según sea necesario y todo tipo de tienda de los píxeles en una matriz.

445
00:37:28,560 --> 00:37:36,350
Luego, más tarde usted sabe que usted tendrá que imprimir la matriz de nuevo,

446
00:37:36,350 --> 00:37:39,830
y por lo que sólo se puede utilizar la matriz para hacer eso.

447
00:37:39,830 --> 00:37:44,500
Otra manera de hacerlo es que se podría copiar una fila hacia abajo,

448
00:37:44,500 --> 00:37:47,950
Entiendo que tiene que copiar de nuevo, por lo que en realidad mueve el cursor,

449
00:37:47,950 --> 00:37:50,950
y que va a utilizar el método fseek.

450
00:37:50,950 --> 00:37:56,410
Usted puede mover el cursor hasta el final de nuevo y repita el proceso de copia de nuevo.

451
00:37:56,410 --> 00:38:03,960
>> Así que si nuestro número de escala es n, entonces ¿cuántas veces tenemos que volver

452
00:38:03,960 --> 00:38:10,500
y volver a escribir una línea? >> [Estudiante] n - 1. >> Sí, perfecto. n - 1.

453
00:38:10,500 --> 00:38:14,390
Lo hemos hecho ya una vez, por lo que a continuación vamos a querer repetir el proceso de vuelta atrás

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

455
00:38:22,730 --> 00:38:25,860
Bien. Así que ahí tienen la función de cambio de tamaño.

456
00:38:25,860 --> 00:38:34,360
>> Ahora podemos llegar a una parte muy divertido, mi favorito conjunto de procesadores, que es Recover.

457
00:38:34,360 --> 00:38:39,580
En lugar de mapas de bits, esta vez estamos tratando con archivos JPEG.

458
00:38:39,580 --> 00:38:43,370
Estamos en realidad no da un solo archivo de imágenes JPEG,

459
00:38:43,370 --> 00:38:46,600
y cuando nos den básicamente un formato raw tarjeta de memoria.

460
00:38:46,600 --> 00:38:51,790
Y por lo que este contiene un poco de información de valores y la basura en el principio,

461
00:38:51,790 --> 00:38:57,240
y luego empieza y tiene un montón de archivos JPEG.

462
00:38:57,240 --> 00:39:03,430
Sin embargo, nos entregó una tarjeta en la que ha borrado las fotos;

463
00:39:03,430 --> 00:39:08,300
en esencia, nos hemos olvidado de donde las fotos se encuentran dentro de la tarjeta.

464
00:39:08,300 --> 00:39:12,770
Así que nuestra tarea de recuperar es ir a través de este formato de tarjeta

465
00:39:12,770 --> 00:39:16,500
y encontrar esas fotos otra vez.

466
00:39:16,500 --> 00:39:23,990
>> Por suerte, la estructura de archivos JPEG y el archivo de la tarjeta es un poco de ayuda.

467
00:39:23,990 --> 00:39:28,850
Que sin duda podría haber sido un poco más complicado si no fuera en este formato en particular.

468
00:39:28,850 --> 00:39:40,160
Cada archivo JPEG en realidad comienza con dos secuencias posibles, enumerados anteriormente.

469
00:39:40,160 --> 00:39:42,970
Básicamente, cada vez que tenga un nuevo archivo JPEG,

470
00:39:42,970 --> 00:39:52,720
que comienza con la secuencia de cualquiera de ffd8 FFE0 o el otro, ffd8 ffe1.

471
00:39:52,720 --> 00:39:59,530
Otra cosa útil es saber que los archivos JPEG se almacenan de forma contigua.

472
00:39:59,530 --> 00:40:03,380
Así que cada vez que un archivo JPEG termina, el otro comienza.

473
00:40:03,380 --> 00:40:07,070
Así que no hay ningún tipo de en-entre los valores de ese país.

474
00:40:07,070 --> 00:40:15,510
Una vez que llegue el inicio de un archivo JPEG, si ya has estado leyendo un archivo JPEG,

475
00:40:15,510 --> 00:40:21,800
sabes que has llegado al final de la anterior y el comienzo de la siguiente.

476
00:40:21,800 --> 00:40:25,890
>> Para tipo de visualizar esto, hice un esquema.

477
00:40:25,890 --> 00:40:36,910
Otra cosa sobre los archivos JPEG es que podemos leer en las secuencias de 512 bytes a la vez,

478
00:40:36,910 --> 00:40:39,380
de manera similar con el comienzo de la tarjeta.

479
00:40:39,380 --> 00:40:43,370
No necesitamos estar comprobando cada byte único, ya que sería un asco.

480
00:40:43,370 --> 00:40:48,200
Así que en vez, lo que podemos hacer es en realidad acabo de leer en 512 bytes a la vez

481
00:40:48,200 --> 00:40:54,700
y entonces, en lugar de comprobar entre los de esas porciones diminutas,

482
00:40:54,700 --> 00:40:58,640
sólo podemos comprobar el inicio de los 512 bytes.

483
00:40:58,640 --> 00:41:02,570
Esencialmente, en esta imagen, lo que se ve es en el comienzo de la tarjeta,

484
00:41:02,570 --> 00:41:08,700
tiene valores que no son realmente relevantes para los archivos JPEG en sí mismas.

485
00:41:08,700 --> 00:41:15,830
Pero entonces lo que tenemos es una estrella para indicar una de las dos secuencias de partida para un JPEG.

486
00:41:15,830 --> 00:41:19,910
Así que cada vez que vea una estrella, usted sabe que tiene un archivo JPEG.

487
00:41:19,910 --> 00:41:25,030
Y entonces todos los archivos JPEG va a ser un múltiplo de 512 bytes

488
00:41:25,030 --> 00:41:27,880
pero no necesariamente el mismo múltiplo.

489
00:41:27,880 --> 00:41:32,050
La forma en que usted sabe que usted ha golpeado otra JPEG es si se golpea otra estrella,

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

491
00:41:39,090 --> 00:41:43,330
Entonces, lo que tenemos aquí es que tenga el archivo JPEG rojo continúa hasta llegar a una estrella,

492
00:41:43,330 --> 00:41:45,150
que se indica mediante un color nuevo.

493
00:41:45,150 --> 00:41:48,510
Usted continúa y entonces golpeó otra estrella, que chocó con otro formato JPEG,

494
00:41:48,510 --> 00:41:50,590
continúa todo el camino hasta el final.

495
00:41:50,590 --> 00:41:53,180
Estás en la última foto aquí, el rosa.

496
00:41:53,180 --> 00:41:58,220
Ve hasta el final hasta llegar a la final del personaje archivo.

497
00:41:58,220 --> 00:42:00,820
Esto va a ser realmente útil.

498
00:42:00,820 --> 00:42:03,170
>> A pocos robos de balón principales aquí:

499
00:42:03,170 --> 00:42:06,670
El archivo de la tarjeta no se inicia con un archivo JPEG,

500
00:42:06,670 --> 00:42:13,350
pero una vez que comienza un JPEG, todos los archivos JPEG se almacenan lado a lado entre sí.

501
00:42:17,520 --> 00:42:20,420
>> Algunos pseudocódigo para la Recuperación.

502
00:42:20,420 --> 00:42:22,570
En primer lugar, vamos a abrir nuestro archivo de tarjeta,

503
00:42:22,570 --> 00:42:27,500
y que va a estar usando nuestro archivo de E / S funciones.

504
00:42:27,500 --> 00:42:32,430
Vamos a repetir el siguiente proceso hasta que hemos llegado al final del archivo.

505
00:42:32,430 --> 00:42:36,450
Vamos a leer 512 bytes a la vez.

506
00:42:36,450 --> 00:42:39,180
Y lo que quiero decir aquí es que vamos a guardarlo en un buffer,

507
00:42:39,180 --> 00:42:46,230
así que básicamente se aferran a esos 512 bytes hasta que sepamos exactamente qué hacer con ellos.

508
00:42:46,230 --> 00:42:50,300
Entonces lo que quiero hacer es que queremos comprobar si nos hemos topado con una estrella o no.

509
00:42:50,300 --> 00:42:57,960
Si nos hemos topado con una estrella, si hemos golpeado una de las secuencias de arranque,

510
00:42:57,960 --> 00:42:59,980
entonces sabemos que hemos alcanzado un nuevo archivo JPEG.

511
00:42:59,980 --> 00:43:08,860
Lo que usted querrá hacer es que vamos a querer crear un nuevo archivo en nuestro directorio pset4

512
00:43:08,860 --> 00:43:14,480
para seguir haciendo ese archivo.

513
00:43:14,480 --> 00:43:18,220
Pero también, si ya hemos hecho un JPEG antes,

514
00:43:18,220 --> 00:43:25,620
entonces queremos acabar con ese archivo y empujar a la carpeta pset4,

515
00:43:25,620 --> 00:43:29,780
donde tendremos ese archivo guardado porque si no se especifica que hemos terminado ese archivo JPEG,

516
00:43:29,780 --> 00:43:37,290
a continuación, que básicamente tendrás una cantidad indeterminada. Los archivos JPEG no tendrá fin.

517
00:43:37,290 --> 00:43:40,840
Así que queremos asegurarnos de que cuando estamos leyendo en un archivo JPEG y escrito que,

518
00:43:40,840 --> 00:43:46,590
que se quiere cerrar específicamente que, para abrir el siguiente.

519
00:43:46,590 --> 00:43:48,430
Tendremos que desee comprobar varias cosas.

520
00:43:48,430 --> 00:43:52,880
Queremos comprobar si estamos en el comienzo de una nueva JPEG con nuestro buffer

521
00:43:52,880 --> 00:43:56,780
y también si ya ha encontrado un JPEG antes

522
00:43:56,780 --> 00:44:03,930
porque eso va a cambiar su proceso ligeramente.

523
00:44:03,930 --> 00:44:07,880
Así que después de pasar por todo el camino y le golpeó el final del archivo,

524
00:44:07,880 --> 00:44:11,570
entonces lo que usted querrá hacer es que usted quiere cerrar todos los archivos que estén abiertos.

525
00:44:11,570 --> 00:44:14,100
Esto probablemente será el último archivo JPEG que usted tiene,

526
00:44:14,100 --> 00:44:18,930
así como el archivo de tarjetas que usted ha estado tratando.

527
00:44:21,940 --> 00:44:28,670
>> El último obstáculo que tenemos que abordar es cómo hacer realidad un archivo JPEG

528
00:44:28,670 --> 00:44:31,950
y cómo en realidad lo empuja a la carpeta.

529
00:44:33,650 --> 00:44:39,850
El conjunto de procesadores requiere que cada JPEG que se encuentra estar en el siguiente formato,

530
00:44:39,850 --> 00:44:43,990
donde tienes el número. jpg.

531
00:44:43,990 --> 00:44:50,750
El número, incluso si es 0, lo llamamos 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Cada vez que encuentre un archivo JPEG en el programa,

533
00:44:55,730 --> 00:44:58,040
usted va a querer darle un nombre en el orden en que se encuentre.

534
00:44:58,040 --> 00:44:59,700
¿Qué quiere decir esto?

535
00:44:59,700 --> 00:45:03,530
Tenemos que tipo de seguimiento de cuántos hemos encontrado

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

537
00:45:08,680 --> 00:45:13,800
Aquí vamos a aprovechar la función sprintf.

538
00:45:13,800 --> 00:45:17,480
Al igual que printf, que sólo tipo de impresiones en un valor fuera de la terminal,

539
00:45:17,480 --> 00:45:23,910
sprintf imprime el archivo en la carpeta de salida.

540
00:45:23,910 --> 00:45:30,870
Y así lo que esto haría si tuviera sprintf, título, y luego la cadena allí,

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

542
00:45:36,660 --> 00:45:41,020
Suponiendo que he cerrado mis archivos correctamente,

543
00:45:41,020 --> 00:45:47,210
que contiene el archivo que había estado escribiendo.

544
00:45:47,210 --> 00:45:50,320
Pero una cosa es que el código que tengo aquí

545
00:45:50,320 --> 00:45:53,360
no acaba de satisfacer lo que el conjunto de procesadores requiere.

546
00:45:53,360 --> 00:46:02,410
El conjunto de procesadores requiere que el segundo archivo JPEG debe ser nombrado 002 en vez de 2.

547
00:46:02,410 --> 00:46:09,160
Así que cuando se imprima el nombre, entonces tal vez usted puede ser que desee modificar ligeramente el marcador de posición.

548
00:46:09,160 --> 00:46:18,140
>> ¿Alguien recuerda cómo permitir espacios adicionales cuando escribamos algo?

549
00:46:18,140 --> 00:46:22,530
Si. >> [Estudiante] Se pone un 3 por ciento entre el signo y el 2. >> Sí, perfecto.

550
00:46:22,530 --> 00:46:25,610
Vas a poner un 3 en este caso porque queremos que el espacio para 3.

551
00:46:25,610 --> 00:46:32,590
3d% probablemente le daría 002.jpg lugar de 2.

552
00:46:32,590 --> 00:46:40,120
El primer argumento en la función sprintf es en realidad una matriz de caracteres,

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

554
00:46:42,520 --> 00:46:50,700
Aquellos voluntad, un poco más como un depósito temporal, sólo almacenar la cadena resultante.

555
00:46:50,700 --> 00:46:54,950
En realidad, no se trata de esto, sino que hay que incluir.

556
00:46:54,950 --> 00:47:00,710
>> Sabiendo que cada nombre de archivo tiene el número, que ocupa tres personajes,

557
00:47:00,710 --> 00:47:06,770
y entonces. jpg, ¿cuánto tiempo debe ser esta matriz?

558
00:47:09,070 --> 00:47:14,310
Tire a la basura un número. ¿Cuántos caracteres en el título, en el nombre?

559
00:47:18,090 --> 00:47:26,320
Así que hay tres hashtags, período, jpg. >> [Estudiante] 7. >> 7. No del todo.

560
00:47:26,320 --> 00:47:32,000
Vamos a querer 8 porque queremos permitir el terminador nulo también.

561
00:47:45,340 --> 00:47:49,730
>> Por último, sólo para alargar el proceso que se va a hacer para recuperar,

562
00:47:49,730 --> 00:47:55,420
usted tiene alguna información comienzo.

563
00:47:55,420 --> 00:48:02,460
Continuar hasta encontrar el inicio de un archivo JPEG,

564
00:48:02,460 --> 00:48:07,900
y que puede ser o bien una de las dos secuencias de partida.

565
00:48:07,900 --> 00:48:12,510
Tú sigue leyendo. Cada barra representa aquí 512 bytes.

566
00:48:12,510 --> 00:48:22,630
Usted siga leyendo, siga leyendo hasta que se encuentra con otra secuencia de arranque.

567
00:48:22,630 --> 00:48:29,790
Una vez conseguido eso, se termina el actual JPEG - en este caso, es el rojo,

568
00:48:29,790 --> 00:48:31,030
por lo que desea poner fin a eso.

569
00:48:31,030 --> 00:48:35,540
¿Quieres sprintf el nombre de esa carpeta en su pset4,

570
00:48:35,540 --> 00:48:41,580
entonces usted quiere abrir una nueva JPEG y luego seguir leyendo

571
00:48:41,580 --> 00:48:46,370
hasta que se encuentra con el siguiente.

572
00:48:46,370 --> 00:48:49,040
Sigue leyendo, sigue leyendo,

573
00:48:49,040 --> 00:48:56,290
y, finalmente, con el tiempo, vas a llegar al final del archivo,

574
00:48:56,290 --> 00:49:00,360
y por lo que usted quiere cerrar la última JPEG que estabas trabajando,

575
00:49:00,360 --> 00:49:08,380
sprintf que en su carpeta pset4, y luego ver todas las fotos que has conseguido.

576
00:49:08,380 --> 00:49:12,050
Esas fotos son en realidad imágenes de CS50 personal,

577
00:49:12,050 --> 00:49:16,430
y aquí es donde viene la parte divertida bonificación del conjunto de procesadores se presenta en

578
00:49:16,430 --> 00:49:26,310
es que están compitiendo en sus secciones para encontrar la TFS en las fotos

579
00:49:26,310 --> 00:49:34,610
y tomarse fotos con ellos para probar que usted ha hecho el conjunto de procesadores

580
00:49:34,610 --> 00:49:37,030
y para que pueda ver que los miembros del personal están en las fotos.

581
00:49:37,030 --> 00:49:41,510
Así que toma imágenes con el personal. A veces tendrás que perseguirlos.

582
00:49:41,510 --> 00:49:44,680
Probablemente algunos de ellos tratará de huir de ti.

583
00:49:44,680 --> 00:49:47,320
Se toma fotos con ellos.

584
00:49:47,320 --> 00:49:51,190
Esto está en curso. No es exigible cuando el conjunto de procesadores es debido.

585
00:49:51,190 --> 00:49:53,340
El plazo se darán a conocer en la especificación.

586
00:49:53,340 --> 00:49:58,060
Entonces, junto con su sección, lo que lleva a la mayoría de la sección fotos

587
00:49:58,060 --> 00:50:04,430
con los miembros de la mayoría del personal se llevarán un premio bastante impresionante.

588
00:50:04,430 --> 00:50:08,890
Eso es una especie de incentivo para obtener su pset4 termine lo antes posible

589
00:50:08,890 --> 00:50:10,820
porque entonces usted puede ir al grano

590
00:50:10,820 --> 00:50:14,570
la caza de todos los diferentes miembros del personal CS50.

591
00:50:14,570 --> 00:50:17,500
Eso no es obligatoria, sin embargo, así una vez que las fotos,

592
00:50:17,500 --> 00:50:20,310
entonces ya ha terminado con pset4.

593
00:50:20,310 --> 00:50:23,970
>> Y he terminado con Tutorial 4, así que gracias a todos por venir.

594
00:50:23,970 --> 00:50:29,330
Buena suerte con Forense. [Aplauso]

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