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

2
00:00:12,240 --> 00:00:15,870
>> ROB Bowden: Oi, eu sou Rob, vamos
tente isso para o tamanho.

3
00:00:15,870 --> 00:00:21,100
Então, estamos de novo vai começar com
basicamente uma cópia do copy.c e

4
00:00:21,100 --> 00:00:22,860
fazer algumas mudanças.

5
00:00:22,860 --> 00:00:26,280
Nota imediatamente vemos uma mudança, onde
em vez de verificar para ver se

6
00:00:26,280 --> 00:00:30,440
argc não é igual 3, queremos verificar
se argc não é igual a 4, já que

7
00:00:30,440 --> 00:00:34,350
agora não estamos apenas levando-se em um InFile
e outfile, mas estamos também levando-se em

8
00:00:34,350 --> 00:00:38,980
n, que é a quantidade que estamos
dimensionamento da imagem original de.

9
00:00:38,980 --> 00:00:44,340
Uma vez que temos a certeza de que, podemos apenas
converter n para um inteiro usando atoi.

10
00:00:44,340 --> 00:00:48,760
>> Então, agora vamos criar alguns
aliases, basta ligar para argv 2 infile e

11
00:00:48,760 --> 00:00:54,240
argv 3 outfile, porque argv 2 e
argv 3 não são nomes muito útil.

12
00:00:54,240 --> 00:00:58,510
Agora queremos verifique se n é
dentro dos limites que esperar, portanto, o

13
00:00:58,510 --> 00:01:02,910
especificação especifica que se é menor ou
igual a zero, ou maior do que 100,

14
00:01:02,910 --> 00:01:08,580
então isso é um fator de redimensionamento inválido,
e devemos avisar o usuário sobre isso.

15
00:01:08,580 --> 00:01:13,090
>> Uma vez que estamos além de tudo isso, podemos
finalmente abrir nossa infile, e precisamos

16
00:01:13,090 --> 00:01:16,270
ao erro certifique-se de que o
abertura não deixou por algum motivo.

17
00:01:16,270 --> 00:01:19,860
Nós também precisamos abrir nosso outfile, e
novamente erro de verificação para certificar-se de que

18
00:01:19,860 --> 00:01:21,250
não falhou por algum motivo.

19
00:01:21,250 --> 00:01:26,270
Mas não se esqueça, se a abertura da
outfile fracassado que precisamos fechar

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

21
00:01:29,040 --> 00:01:33,690
>> Assim, supondo que não falhou, então
estamos - assim como em copy.c--

22
00:01:33,690 --> 00:01:36,140
vai ler no cabeçalho
do InFile.

23
00:01:36,140 --> 00:01:40,130
Nós vamos ter certeza que é um válido
bitmap, mas agora vamos fazer alguma

24
00:01:40,130 --> 00:01:41,620
as coisas um pouco diferente.

25
00:01:41,620 --> 00:01:44,870
Então, primeiro, nós vamos querer
lembre-se a largura e altura original

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

27
00:01:48,290 --> 00:01:53,890
Então, agora lembre-se que, por razões estranhas
bi.biheight, é negativo, e

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

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

30
00:02:02,580 --> 00:02:06,060
usando a largura de idade, e agora estamos
realmente vai mudar

31
00:02:06,060 --> 00:02:07,320
o que está na nossa cabeça.

32
00:02:07,320 --> 00:02:11,200
Então, vamos multiplicar nossa largura por
n, uma vez que estamos escalando o largura por

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

34
00:02:15,100 --> 00:02:19,250
o cálculo de um novo estofamento
com base na nova largura.

35
00:02:19,250 --> 00:02:21,840
>> Então agora precisamos mudar alguma
outros campos do nosso cabeçalho.

36
00:02:21,840 --> 00:02:26,890
Bi.biSizeImage é suposto ser o
tamanho de todos os bytes dos pixels

37
00:02:26,890 --> 00:02:28,520
e preenchimento da imagem.

38
00:02:28,520 --> 00:02:34,190
E assim, o tamanho de uma única linha de nossa
imagem é o tamanho de triplo RGB, o tamanho

39
00:02:34,190 --> 00:02:39,430
de um único pixel, vezes o número de
pixels em uma linha, mais o preenchimento de

40
00:02:39,430 --> 00:02:40,910
No final da linha.

41
00:02:40,910 --> 00:02:45,200
E então vamos multiplicar isso por
valor absoluto da nossa altura para começar

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

43
00:02:48,350 --> 00:02:53,050
bf.bfSize é apenas o número total
de bytes nos dados de imagem, de modo

44
00:02:53,050 --> 00:02:56,530
bi.biSizeImage, mais o
tamanho das nossas cabeçalhos.

45
00:02:56,530 --> 00:02:59,850
Assim, acrescentando sobre o tamanho do arquivo de bitmap
cabeçalho e tamanho de informações bitmap

46
00:02:59,850 --> 00:03:00,800
cabeçalho, OK.

47
00:03:00,800 --> 00:03:03,170
Então, isso é tudo o que precisamos
alterar nos cabeçalhos.

48
00:03:03,170 --> 00:03:07,020
Agora vamos escrever o cabeçalho do arquivo bitmap
ao nosso outfile, e nossa informação bitmap

49
00:03:07,020 --> 00:03:09,880
cabeçalho para o nosso arquivo de saída, e agora
nós estamos prontos para começar a ir

50
00:03:09,880 --> 00:03:11,990
sobre os pixéis reais.

51
00:03:11,990 --> 00:03:15,720
>> Por isso, queremos iterar
linhas de varredura do infile.

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

53
00:03:17,730 --> 00:03:20,830
É por isso que precisávamos para lembrar o
altura original, antes de alterá-lo

54
00:03:20,830 --> 00:03:23,040
e escalado pelo n.

55
00:03:23,040 --> 00:03:27,810
Agora vamos ler um único
linha do InFile numa

56
00:03:27,810 --> 00:03:30,630
tampão de tamanho oldwidth.

57
00:03:30,630 --> 00:03:36,190
Então, aqui, nós estamos freading tamanho do RGB
triplo, um pixel, e velhos largura

58
00:03:36,190 --> 00:03:39,760
los do InFile em nosso tampão.

59
00:03:39,760 --> 00:03:43,480
E isso vai ser um todo
linha nesta matriz.

60
00:03:43,480 --> 00:03:50,390
Então, agora, nós queremos fazer uma iteração n vezes para
imprimir esta linha ao nosso outfile n vezes.

61
00:03:50,390 --> 00:03:52,510
E é isso que este ciclo está fazendo.

62
00:03:52,510 --> 00:03:57,910
Este loop interno está interagindo sobre o
remar si, sobre a matriz, a impressão

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

64
00:04:00,710 --> 00:04:04,510
Assim, o elemento zeroth está a ser impresso
n vezes, o primeiro elemento está sendo

65
00:04:04,510 --> 00:04:05,660
impresso n vezes.

66
00:04:05,660 --> 00:04:10,820
E isso é uma espécie de como vamos
horizontalmente escala no outfile, e

67
00:04:10,820 --> 00:04:13,390
este ciclo, já que estamos em loop n
vezes, é como nós vamos

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

69
00:04:15,580 --> 00:04:19,850
>> Aqui em baixo, vemos que precisamos adicionar
o enchimento no final de cada linha.

70
00:04:19,850 --> 00:04:25,050
É por isso que este é dentro do loop para
que está imprimindo as n linhas de apenas

71
00:04:25,050 --> 00:04:28,400
esta linha a partir da infile.

72
00:04:28,400 --> 00:04:32,150
Então, aqui, eu vou passar por cima
do preenchimento no infile, pois uma vez

73
00:04:32,150 --> 00:04:34,560
estamos a fazer com uma linha da
infile, não se preocupam com

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

75
00:04:35,290 --> 00:04:37,110
Nós apenas queremos chegar à segunda linha.

76
00:04:37,110 --> 00:04:40,870
E então nós vamos volta ao início e fazer tudo
novamente para a segunda fileira.

77
00:04:40,870 --> 00:04:44,406
>> Finalmente, uma vez que estamos a fazer com tudo isso,
podemos fechar o infile, perto

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

79
00:04:47,430 --> 00:04:50,330
>> Meu nome é Rob, e isso foi de redimensionamento.

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