1
00:00:00,000 --> 00:00:12,240
>> [REPRODUCCIÓN DE MÚSICA]

2
00:00:12,240 --> 00:00:15,870
>> ROB Bowden: Hola, soy Rob, vamos a
probar esto en el tamaño.

3
00:00:15,870 --> 00:00:21,100
Por lo tanto, estamos de nuevo vamos a comenzar con
básicamente una copia de la copy.c, y

4
00:00:21,100 --> 00:00:22,860
hacer algunos cambios.

5
00:00:22,860 --> 00:00:26,280
Nota inmediatamente vemos un cambio, donde
en lugar de comprobar para ver si

6
00:00:26,280 --> 00:00:30,440
argc no es igual a 3, queremos comprobar
si argc no es igual a 4, ya que

7
00:00:30,440 --> 00:00:34,350
Ahora no sólo estamos tomando en un infile
y archivo de salida, pero estamos teniendo también en

8
00:00:34,350 --> 00:00:38,980
n, que es la cantidad que estamos
escalar la imagen original.

9
00:00:38,980 --> 00:00:44,340
Una vez que estemos seguros de ello, no podemos simplemente
convertir n en un entero usando atoi.

10
00:00:44,340 --> 00:00:48,760
>> Así que, ahora que vamos a crear un poco de
alias, simplemente llaman argv 2 infile y

11
00:00:48,760 --> 00:00:54,240
argv 3 archivosalida, porque argv 2 y
argv 3 no son nombres muy útiles.

12
00:00:54,240 --> 00:00:58,510
Ahora queremos comprobar para asegurarse de que n es
dentro de los límites se espera, por lo que el

13
00:00:58,510 --> 00:01:02,910
spec especifica que si es inferior o
igual a cero, o mayor que 100,

14
00:01:02,910 --> 00:01:08,580
entonces eso es un factor de cambio de tamaño no válido,
y debemos advertir al usuario de ello.

15
00:01:08,580 --> 00:01:13,090
>> Una vez que estamos más allá de todo eso, podemos
finalmente abrir nuestra infile, y necesitamos

16
00:01:13,090 --> 00:01:16,270
al error de comprobación para asegurarse de que el
apertura no falló por alguna razón.

17
00:01:16,270 --> 00:01:19,860
También tenemos que abrir nuestro archivo de salida, y
nuevo error de comprobación para asegurarse de que

18
00:01:19,860 --> 00:01:21,250
no falló por alguna razón.

19
00:01:21,250 --> 00:01:26,270
Pero estar seguro de si la apertura de la
archivosalida falló que necesitamos para cerrar

20
00:01:26,270 --> 00:01:29,040
el infile, que ya estaba abierta.

21
00:01:29,040 --> 00:01:33,690
>> Así, en el supuesto de que no fallan,
; somos - al igual que en copy.c--

22
00:01:33,690 --> 00:01:36,140
va a leer en la cabecera
Del infile.

23
00:01:36,140 --> 00:01:40,130
Vamos a asegurarse de que es un válido
mapa de bits, pero ahora vamos a hacer un poco de

24
00:01:40,130 --> 00:01:41,620
las cosas un poco diferente.

25
00:01:41,620 --> 00:01:44,870
Así que en primer lugar, vamos a querer
recordar la anchura y altura original

26
00:01:44,870 --> 00:01:48,290
del infile, porque vamos a
estar cambiando para el archivo de salida.

27
00:01:48,290 --> 00:01:53,890
Así que ahora recordar que por razones extrañas
bi.biheight, es negativo, y

28
00:01:53,890 --> 00:01:58,670
por lo que la altura real, en positivo,
quieren tomar el valor absoluto.

29
00:01:58,670 --> 00:02:02,580
>> Ahora, el relleno va a ser la misma
cálculo como lo fue en copy.c,

30
00:02:02,580 --> 00:02:06,060
utilizando el antiguo ancho, y ahora estamos
en realidad va a cambiar

31
00:02:06,060 --> 00:02:07,320
lo que está en nuestra cabecera.

32
00:02:07,320 --> 00:02:11,200
Así que vamos a multiplicar nuestro ancho por
n, ya que estamos escalando el ancho de

33
00:02:11,200 --> 00:02:15,100
n, multiplique la altura por n, ya que estamos
escalar por n, y ahora tenemos

34
00:02:15,100 --> 00:02:19,250
el cálculo de un nuevo acolchado
basado en el nuevo ancho.

35
00:02:19,250 --> 00:02:21,840
>> Así que ahora tenemos que cambiar algunos
otros campos de nuestra cabecera.

36
00:02:21,840 --> 00:02:26,890
Bi.biSizeImage se supone que es el
El tamaño de todos los bytes en los píxeles

37
00:02:26,890 --> 00:02:28,520
y el relleno de la imagen.

38
00:02:28,520 --> 00:02:34,190
Y lo que el tamaño de una sola fila de nuestra
la imagen es el tamaño del RGB triple, el tamaño

39
00:02:34,190 --> 00:02:39,430
de un solo píxel, multiplicado por el número de
píxeles en una fila, más el relleno en

40
00:02:39,430 --> 00:02:40,910
el final de la fila.

41
00:02:40,910 --> 00:02:45,200
Y luego vamos a multiplicar por
valor absoluto de nuestra altura para obtener

42
00:02:45,200 --> 00:02:48,350
el número total de bytes
en los datos de imagen.

43
00:02:48,350 --> 00:02:53,050
bf.bfSize es sólo el número total
de bytes de los datos de imagen, por lo que

44
00:02:53,050 --> 00:02:56,530
bi.biSizeImage, además de la
tamaño de nuestros cabeceras.

45
00:02:56,530 --> 00:02:59,850
Así, la adición en el tamaño de archivo de mapa de bits
encabezado, y el tamaño de los datos de mapa de bits

46
00:02:59,850 --> 00:03:00,800
encabezado, OK.

47
00:03:00,800 --> 00:03:03,170
Así que eso es todo lo que necesitamos
cambiar en nuestras cabeceras.

48
00:03:03,170 --> 00:03:07,020
Ahora vamos a escribir el encabezado del archivo de mapa de bits
en nuestro archivo de salida, y nuestra información de mapa de bits

49
00:03:07,020 --> 00:03:09,880
cabecera en nuestro archivo de salida, y ahora
estamos listos para empezar a ir

50
00:03:09,880 --> 00:03:11,990
sobre los píxeles reales.

51
00:03:11,990 --> 00:03:15,720
>> Así que queremos recorrer en iteración
líneas de exploración del INFILE.

52
00:03:15,720 --> 00:03:17,730
Así que queremos recorrer en iteración oldheight.

53
00:03:17,730 --> 00:03:20,830
Esta es la razón que necesitábamos para recordar la
altura original, antes de que nos cambiamos

54
00:03:20,830 --> 00:03:23,040
y escalado por n.

55
00:03:23,040 --> 00:03:27,810
Ahora vamos a leer un solo
fila de la infile en un

56
00:03:27,810 --> 00:03:30,630
buffer de tamaño oldwidth.

57
00:03:30,630 --> 00:03:36,190
Así que aquí, estamos freading tamaño de RGB
triple, un píxel, y la anchura de edad de

58
00:03:36,190 --> 00:03:39,760
desde el archivo de entrada en nuestro buffer.

59
00:03:39,760 --> 00:03:43,480
Y eso va a ser un todo
remar en esta matriz.

60
00:03:43,480 --> 00:03:50,390
Así que ahora, queremos repetir n veces para
imprimir esta fila en nuestro archivo de salida n veces.

61
00:03:50,390 --> 00:03:52,510
Y eso es lo que este bucle está haciendo.

62
00:03:52,510 --> 00:03:57,910
Este bucle interior está iterando sobre el
fila en sí, sobre la matriz, la impresión

63
00:03:57,910 --> 00:04:00,710
cada píxel de la matriz de n veces.

64
00:04:00,710 --> 00:04:04,510
De modo que el elemento de orden cero se está imprimiendo
n veces, el primer elemento está siendo

65
00:04:04,510 --> 00:04:05,660
impreso n veces.

66
00:04:05,660 --> 00:04:10,820
Y eso es una especie de cómo vamos a
horizontalmente escala en el archivo de salida, y

67
00:04:10,820 --> 00:04:13,390
este bucle, ya que estamos en bucle n
veces, es la forma en que vamos a

68
00:04:13,390 --> 00:04:15,580
escala vertical.

69
00:04:15,580 --> 00:04:19,850
>> Aquí abajo, vemos que tenemos que añadir
el relleno al final de cada fila.

70
00:04:19,850 --> 00:04:25,050
Es por eso que esto es dentro del bucle de
eso es imprimir las n filas de sólo

71
00:04:25,050 --> 00:04:28,400
éste fila de la infile.

72
00:04:28,400 --> 00:04:32,150
Entonces aquí, voy a pasar por alto
el relleno en el archivo de entrada, ya que una vez

73
00:04:32,150 --> 00:04:34,560
hemos terminado con una fila de la
infile, no importa

74
00:04:34,560 --> 00:04:35,290
¿cuál fue el relleno.

75
00:04:35,290 --> 00:04:37,110
Sólo queremos llegar a la segunda fila.

76
00:04:37,110 --> 00:04:40,870
Y luego vamos a bucle de nuevo y hacer todo
esto de nuevo para la segunda fila.

77
00:04:40,870 --> 00:04:44,406
>> Finalmente, una vez que hemos terminado con todo eso,
podemos cerrar el archivo de entrada, cerca

78
00:04:44,406 --> 00:04:47,430
el archivo de salida, y el retorno
0 porque hemos terminado.

79
00:04:47,430 --> 00:04:50,330
>> Mi nombre es Rob, y esto era de tamaño.

80
00:04:50,330 --> 00:04:54,934
>> [REPRODUCCIÓN DE MÚSICA]