>> [REPRODUCCIÓN DE MÚSICA]
>> ROB Bowden: Hola, soy Rob, vamos a probar esto en el tamaño.
Por lo tanto, estamos de nuevo vamos a comenzar con básicamente una copia de la copy.c, y
hacer algunos cambios.
Nota inmediatamente vemos un cambio, donde en lugar de comprobar para ver si
argc no es igual a 3, queremos comprobar si argc no es igual a 4, ya que
Ahora no sólo estamos tomando en un infile y archivo de salida, pero estamos teniendo también en
n, que es la cantidad que estamos escalar la imagen original.
Una vez que estemos seguros de ello, no podemos simplemente convertir n en un entero usando atoi.
>> Así que, ahora que vamos a crear un poco de alias, simplemente llaman argv 2 infile y
argv 3 archivosalida, porque argv 2 y argv 3 no son nombres muy útiles.
Ahora queremos comprobar para asegurarse de que n es dentro de los límites se espera, por lo que el
spec especifica que si es inferior o igual a cero, o mayor que 100,
entonces eso es un factor de cambio de tamaño no válido, y debemos advertir al usuario de ello.
>> Una vez que estamos más allá de todo eso, podemos finalmente abrir nuestra infile, y necesitamos
al error de comprobación para asegurarse de que el apertura no falló por alguna razón.
También tenemos que abrir nuestro archivo de salida, y nuevo error de comprobación para asegurarse de que
no falló por alguna razón.
Pero estar seguro de si la apertura de la archivosalida falló que necesitamos para cerrar
el infile, que ya estaba abierta.
>> Así, en el supuesto de que no fallan, ; somos - al igual que en copy.c--
va a leer en la cabecera Del infile.
Vamos a asegurarse de que es un válido mapa de bits, pero ahora vamos a hacer un poco de
las cosas un poco diferente.
Así que en primer lugar, vamos a querer recordar la anchura y altura original
del infile, porque vamos a estar cambiando para el archivo de salida.
Así que ahora recordar que por razones extrañas bi.biheight, es negativo, y
por lo que la altura real, en positivo, quieren tomar el valor absoluto.
>> Ahora, el relleno va a ser la misma cálculo como lo fue en copy.c,
utilizando el antiguo ancho, y ahora estamos en realidad va a cambiar
lo que está en nuestra cabecera.
Así que vamos a multiplicar nuestro ancho por n, ya que estamos escalando el ancho de
n, multiplique la altura por n, ya que estamos escalar por n, y ahora tenemos
el cálculo de un nuevo acolchado basado en el nuevo ancho.
>> Así que ahora tenemos que cambiar algunos otros campos de nuestra cabecera.
Bi.biSizeImage se supone que es el El tamaño de todos los bytes en los píxeles
y el relleno de la imagen.
Y lo que el tamaño de una sola fila de nuestra la imagen es el tamaño del RGB triple, el tamaño
de un solo píxel, multiplicado por el número de píxeles en una fila, más el relleno en
el final de la fila.
Y luego vamos a multiplicar por valor absoluto de nuestra altura para obtener
el número total de bytes en los datos de imagen.
bf.bfSize es sólo el número total de bytes de los datos de imagen, por lo que
bi.biSizeImage, además de la tamaño de nuestros cabeceras.
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
encabezado, OK.
Así que eso es todo lo que necesitamos cambiar en nuestras cabeceras.
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
cabecera en nuestro archivo de salida, y ahora estamos listos para empezar a ir
sobre los píxeles reales.
>> Así que queremos recorrer en iteración líneas de exploración del INFILE.
Así que queremos recorrer en iteración oldheight.
Esta es la razón que necesitábamos para recordar la altura original, antes de que nos cambiamos
y escalado por n.
Ahora vamos a leer un solo fila de la infile en un
buffer de tamaño oldwidth.
Así que aquí, estamos freading tamaño de RGB triple, un píxel, y la anchura de edad de
desde el archivo de entrada en nuestro buffer.
Y eso va a ser un todo remar en esta matriz.
Así que ahora, queremos repetir n veces para imprimir esta fila en nuestro archivo de salida n veces.
Y eso es lo que este bucle está haciendo.
Este bucle interior está iterando sobre el fila en sí, sobre la matriz, la impresión
cada píxel de la matriz de n veces.
De modo que el elemento de orden cero se está imprimiendo n veces, el primer elemento está siendo
impreso n veces.
Y eso es una especie de cómo vamos a horizontalmente escala en el archivo de salida, y
este bucle, ya que estamos en bucle n veces, es la forma en que vamos a
escala vertical.
>> Aquí abajo, vemos que tenemos que añadir el relleno al final de cada fila.
Es por eso que esto es dentro del bucle de eso es imprimir las n filas de sólo
éste fila de la infile.
Entonces aquí, voy a pasar por alto el relleno en el archivo de entrada, ya que una vez
hemos terminado con una fila de la infile, no importa
¿cuál fue el relleno.
Sólo queremos llegar a la segunda fila.
Y luego vamos a bucle de nuevo y hacer todo esto de nuevo para la segunda fila.
>> Finalmente, una vez que hemos terminado con todo eso, podemos cerrar el archivo de entrada, cerca
el archivo de salida, y el retorno 0 porque hemos terminado.
>> Mi nombre es Rob, y esto era de tamaño.
>> [REPRODUCCIÓN DE MÚSICA]