1
00:00:00,000 --> 00:00:12,240
>> [Música tocando]

2
00:00:12,240 --> 00:00:15,870
>> ROB Bowden: Ola, eu son Rob, imos
tente iso ao tamaño.

3
00:00:15,870 --> 00:00:21,100
Entón, estamos de novo comezará con
basicamente unha copia do copy.c e

4
00:00:21,100 --> 00:00:22,860
facer algúns cambios.

5
00:00:22,860 --> 00:00:26,280
Nota inmediatamente vemos un cambio, onde
no canto de comprobar a ver se

6
00:00:26,280 --> 00:00:30,440
argc non coincide 3, queremos comprobar
se argc non é igual a 4, xa que

7
00:00:30,440 --> 00:00:34,350
agora non estamos só tendo en un InFile
e outfile, pero estamos tamén tendo en

8
00:00:34,350 --> 00:00:38,980
n, que é a cantidade que estamos
escalar a imaxe orixinal por.

9
00:00:38,980 --> 00:00:44,340
Unha vez que temos a certeza de que, podemos só
converterse n para un enteiro usando atoi.

10
00:00:44,340 --> 00:00:48,760
>> Entón, agora imos crear algúns
alias, pode conectar para argv 2 infile e

11
00:00:48,760 --> 00:00:54,240
argv 3 outfile porque argv 2 e
argv 3 non son nomes moi útil.

12
00:00:54,240 --> 00:00:58,510
Agora queremos comprobe que n é
dentro dos límites que esperar, polo tanto, o

13
00:00:58,510 --> 00:01:02,910
especificación especifica que se é menor ou
igual a cero, ou maior que 100,

14
00:01:02,910 --> 00:01:08,580
entón iso é un factor de cambio de tamaño válido,
e debemos avisar o usuario sobre iso.

15
00:01:08,580 --> 00:01:13,090
>> Xa que estamos ademais de todo isto, podemos
finalmente abrir nosa infile, e necesitamos

16
00:01:13,090 --> 00:01:16,270
ao erro asegúrese de que o
Entrada non deixou por algún motivo.

17
00:01:16,270 --> 00:01:19,860
Tamén necesitamos abrir o noso outfile, e
novo erro de verificación para asegurarse de que

18
00:01:19,860 --> 00:01:21,250
non fallou por algún motivo.

19
00:01:21,250 --> 00:01:26,270
Pero non se esqueza, a apertura da
outfile fracasado que necesitamos pechar

20
00:01:26,270 --> 00:01:29,040
o infile, que xa foi aberto.

21
00:01:29,040 --> 00:01:33,690
>> Así, supoñendo que non fallou, entón
estamos - así como en copy.c--

22
00:01:33,690 --> 00:01:36,140
vai ler na cabeceira
do InFile.

23
00:01:36,140 --> 00:01:40,130
Nós imos estar seguro que é un válido
bitmap, pero agora imos facer algunha

24
00:01:40,130 --> 00:01:41,620
as cousas un pouco diferente.

25
00:01:41,620 --> 00:01:44,870
Entón, primeiro, nós imos querer
Teña en conta que o ancho e alto orixinal

26
00:01:44,870 --> 00:01:48,290
do infile, porque nós imos
estar cambiando-o para o ficheiro de saída.

27
00:01:48,290 --> 00:01:53,890
Entón, agora recorda que, por razóns estrañas
bi.biheight, é negativo, e

28
00:01:53,890 --> 00:01:58,670
entón a altura real, en positivo,
quero tomar o valor absoluto.

29
00:01:58,670 --> 00:02:02,580
>> Agora, o estofado que será a mesma
cálculo como era no copy.c,

30
00:02:02,580 --> 00:02:06,060
empregando o ancho de idade, e agora estamos
realmente vai cambiar

31
00:02:06,060 --> 00:02:07,320
o que está na nosa cabeza.

32
00:02:07,320 --> 00:02:11,200
Entón, imos multiplicar nosa ancho por
n, xa que estamos escalando o ancho por

33
00:02:11,200 --> 00:02:15,100
n, multiplique a altura por n, xa que estamos
dimensionamento por n, e agora temos

34
00:02:15,100 --> 00:02:19,250
o cálculo dun novo estofado
con base na nova ancho.

35
00:02:19,250 --> 00:02:21,840
>> Entón agora necesitamos cambiar algunha
outros campos da nosa cabeceira.

36
00:02:21,840 --> 00:02:26,890
Bi.biSizeImage se quere que sexa o
tamaño de todos os bytes dos píxeles

37
00:02:26,890 --> 00:02:28,520
e recheo de imaxe.

38
00:02:28,520 --> 00:02:34,190
E así, o tamaño dunha soa liña de nosa
imaxe é o tamaño de triple RGB, o tamaño

39
00:02:34,190 --> 00:02:39,430
dun único pixel, veces o número de
píxeles nunha liña, máis o recheo de

40
00:02:39,430 --> 00:02:40,910
Ao final da liña.

41
00:02:40,910 --> 00:02:45,200
E entón imos multiplicar isto por
valor absoluto da nosa altura para comezar

42
00:02:45,200 --> 00:02:48,350
o número total de bytes
nos datos de imaxe.

43
00:02:48,350 --> 00:02:53,050
bf.bfSize é só o número total
de bytes dos datos de imaxe, de xeito

44
00:02:53,050 --> 00:02:56,530
bi.biSizeImage, máis o
tamaño das nosas cabeceiras.

45
00:02:56,530 --> 00:02:59,850
Así, engadindo sobre o tamaño do ficheiro de mapa de bits
cabeceira e tamaño de información bitmap

46
00:02:59,850 --> 00:03:00,800
cabeceira, Aceptar.

47
00:03:00,800 --> 00:03:03,170
Entón, iso é todo o que necesitamos
cambiar nas cabeceiras.

48
00:03:03,170 --> 00:03:07,020
Agora imos escribir a cabeceira do ficheiro de mapa de bits
ao noso outfile, e nosa información bitmap

49
00:03:07,020 --> 00:03:09,880
cabeceira para o noso arquivo de saída, e agora
estamos preparados para comezar a ir

50
00:03:09,880 --> 00:03:11,990
durante os píxels reais.

51
00:03:11,990 --> 00:03:15,720
>> Por iso, queremos iterado
liñas de varrido do infile.

52
00:03:15,720 --> 00:03:17,730
Por iso, queremos interactuar sobre oldheight.

53
00:03:17,730 --> 00:03:20,830
É por iso que necesitabamos para lembrar o
altura orixinal, antes de cambia-lo

54
00:03:20,830 --> 00:03:23,040
ea escalado polo n.

55
00:03:23,040 --> 00:03:27,810
Agora imos ler un único
liña do InFile nunha

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

57
00:03:30,630 --> 00:03:36,190
Entón, aquí, estamos freading tamaño do RGB
triple, un pixel, e vellos ancho

58
00:03:36,190 --> 00:03:39,760
los do InFile na nosa tapón.

59
00:03:39,760 --> 00:03:43,480
E iso vai ser un todo
liña nesta matriz.

60
00:03:43,480 --> 00:03:50,390
Entón, agora, queremos facer unha iteración n veces para
imprimir esta liña ao noso outfile n veces.

61
00:03:50,390 --> 00:03:52,510
E iso é o que este ciclo está facendo.

62
00:03:52,510 --> 00:03:57,910
Este loop interno está interactuando sobre o
remar si, sobre a matriz, a impresión

63
00:03:57,910 --> 00:04:00,710
cada pixel da matriz de n veces.

64
00:04:00,710 --> 00:04:04,510
Así, o elemento zeroth está sendo impreso
n veces, o primeiro elemento está a ser

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

66
00:04:05,660 --> 00:04:10,820
E iso é unha especie de como imos
horizontalmente escala no outfile, e

67
00:04:10,820 --> 00:04:13,390
este ciclo, xa que estamos en loop n
veces, é coma nós imos

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

69
00:04:15,580 --> 00:04:19,850
>> Aquí abaixo, vemos que necesitamos engadir
o recheo ao final de cada liña.

70
00:04:19,850 --> 00:04:25,050
É por iso que se trata dentro do loop para
que está imprimindo as n liñas de só

71
00:04:25,050 --> 00:04:28,400
esta liña desde a infile.

72
00:04:28,400 --> 00:04:32,150
Entón, aquí, eu vou pasar por riba
o recheo no infile, pois xa

73
00:04:32,150 --> 00:04:34,560
estamos a facer cunha liña de
infile, non se preocupan

74
00:04:34,560 --> 00:04:35,290
que o recheo era.

75
00:04:35,290 --> 00:04:37,110
Nós só queremos chegar á segunda liña.

76
00:04:37,110 --> 00:04:40,870
E entón nós imos volta ao comezo e facer todo
de novo para a segunda fileira.

77
00:04:40,870 --> 00:04:44,406
>> Por último, xa que estamos a facer con todo iso,
podemos pechar o infile, preto

78
00:04:44,406 --> 00:04:47,430
o ficheiro de saída e retorno
0 porque estamos a facer.

79
00:04:47,430 --> 00:04:50,330
>> O meu nome é Rob, e iso foi de cambio de tamaño.

80
00:04:50,330 --> 00:04:54,934
>> [Música tocando]