1
00:00:00,000 --> 00:00:12,240
>> [GIOCO MUSICA]

2
00:00:12,240 --> 00:00:15,870
>> ROB BOWDEN: Ciao, mi chiamo Rob, LET'S
provare questo su per le dimensioni.

3
00:00:15,870 --> 00:00:21,100
Così, stiamo di nuovo andando per iniziare
sostanzialmente una copia del copy.c, e

4
00:00:21,100 --> 00:00:22,860
fare alcuni cambiamenti.

5
00:00:22,860 --> 00:00:26,280
Notiamo subito vediamo un cambiamento, dove
invece di controllare per vedere se

6
00:00:26,280 --> 00:00:30,440
argc non uguale a 3, vogliamo controllare
se argc non è uguale a 4, dal momento che

7
00:00:30,440 --> 00:00:34,350
Ora non stiamo solo prendendo in infile
e outfile, ma stiamo anche prendendo in

8
00:00:34,350 --> 00:00:38,980
n, che è la quantità che siamo
ridimensionamento dell'immagine originale.

9
00:00:38,980 --> 00:00:44,340
Una volta che siamo sicuri di questo, possiamo solo
convertire i n un numero intero con atoi.

10
00:00:44,340 --> 00:00:48,760
>> Così, ora stiamo andando a creare qualche
alias, basta chiamare argv 2 infile, e

11
00:00:48,760 --> 00:00:54,240
argv 3 outfile, perché argv 2 e
argv 3 non sono nomi molto utile.

12
00:00:54,240 --> 00:00:58,510
Ora vogliamo verificare che n è
all'interno dei limiti ci aspettiamo, così la

13
00:00:58,510 --> 00:01:02,910
spec specifica che se è minore o
pari a zero, o maggiore di 100,

14
00:01:02,910 --> 00:01:08,580
allora questo è un fattore di ridimensionamento non valido,
e dovremmo avvertire l'utente di questo.

15
00:01:08,580 --> 00:01:13,090
>> Una volta che siamo là di tutto ciò, possiamo
infine aprire il nostro infile, e abbiamo bisogno di

16
00:01:13,090 --> 00:01:16,270
per errore di controllo per assicurarsi che il
apertura non ha mancato per qualche motivo.

17
00:01:16,270 --> 00:01:19,860
Abbiamo anche bisogno di aprire la nostra outfile, e
nuovo errore di controllo per assicurarsi che

18
00:01:19,860 --> 00:01:21,250
non ha mancato per qualche motivo.

19
00:01:21,250 --> 00:01:26,270
Ma essere sicuri se l'apertura della
outfile fallito che abbiamo bisogno di chiudere

20
00:01:26,270 --> 00:01:29,040
il infile, che era già aperto.

21
00:01:29,040 --> 00:01:33,690
>> Quindi, supponendo che non ha mancato, poi
Ne siamo - proprio come in copy.c--

22
00:01:33,690 --> 00:01:36,140
andando a leggere nell'intestazione
dal infile.

23
00:01:36,140 --> 00:01:40,130
Stiamo per assicurarsi che sia una valida
bitmap, ma ora stiamo andando a fare un po '

24
00:01:40,130 --> 00:01:41,620
le cose un po 'diverso.

25
00:01:41,620 --> 00:01:44,870
Quindi in primo luogo, stiamo andando a voler
ricordare la larghezza e l'altezza originale

26
00:01:44,870 --> 00:01:48,290
del infile, perché stiamo andando a
stia cambiando per il file di output.

27
00:01:48,290 --> 00:01:53,890
Così ora ricordare che per motivi strani
bi.biheight, è negativo, e

28
00:01:53,890 --> 00:01:58,670
così l'altezza effettiva, in positivo, abbiamo
vuole prendere il valore assoluto.

29
00:01:58,670 --> 00:02:02,580
>> Ora, l'imbottitura sarà lo stesso
calcolo come era nel copy.c,

30
00:02:02,580 --> 00:02:06,060
utilizzando il vecchio larghezza, e ora siamo
in realtà andando a cambiare

31
00:02:06,060 --> 00:02:07,320
Cosa c'è nella nostra intestazione.

32
00:02:07,320 --> 00:02:11,200
Quindi stiamo andando a moltiplicare la nostra larghezza per
n, dal momento che stiamo scalando la larghezza

33
00:02:11,200 --> 00:02:15,100
n, moltiplicare l'altezza n, dal momento che siamo
scala da n, e ora abbiamo

34
00:02:15,100 --> 00:02:19,250
il calcolo per una nuova imbottitura
basato sulla nuova larghezza.

35
00:02:19,250 --> 00:02:21,840
>> Così ora abbiamo bisogno di cambiare un po '
altri campi del nostro colpo di testa.

36
00:02:21,840 --> 00:02:26,890
Bi.biSizeImage dovrebbe essere l'
dimensioni di tutti i byte dei pixel

37
00:02:26,890 --> 00:02:28,520
e imbottitura dell'immagine.

38
00:02:28,520 --> 00:02:34,190
E quindi la dimensione di una sola fila di nostra
immagine è di dimensione triplo RGB, la dimensione

39
00:02:34,190 --> 00:02:39,430
di un singolo pixel, il numero di volte
pixel in una riga, più l'imbottitura in

40
00:02:39,430 --> 00:02:40,910
alla fine della riga.

41
00:02:40,910 --> 00:02:45,200
E poi andremo a moltiplicare per
valore assoluto della nostra altezza per ottenere

42
00:02:45,200 --> 00:02:48,350
il numero totale di byte
nei dati di immagine.

43
00:02:48,350 --> 00:02:53,050
bf.bfSize è solo il numero totale
di byte nei nostri dati di immagine, in modo da

44
00:02:53,050 --> 00:02:56,530
bi.biSizeImage, più il
dimensione delle nostre intestazioni.

45
00:02:56,530 --> 00:02:59,850
Quindi, l'aggiunta delle dimensioni del file bitmap
intestazione, e le dimensioni delle informazioni di bitmap

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

47
00:03:00,800 --> 00:03:03,170
Ecco, questo è tutto quello che dobbiamo
modifiche nelle nostre intestazioni.

48
00:03:03,170 --> 00:03:07,020
Ora scriveremo l'intestazione del file bitmap
alla nostra outfile, e la nostra informazioni bitmap

49
00:03:07,020 --> 00:03:09,880
intestazione alla nostra outfile, e ora
siamo pronti per cominciare ad andare

50
00:03:09,880 --> 00:03:11,990
sui pixel reali.

51
00:03:11,990 --> 00:03:15,720
>> Quindi vogliamo iterare
linee di scansione del infile.

52
00:03:15,720 --> 00:03:17,730
Quindi vogliamo iterare oldheight.

53
00:03:17,730 --> 00:03:20,830
Questo è il motivo per cui abbiamo bisogno di ricordare la
altezza originale, prima che noi cambiamo

54
00:03:20,830 --> 00:03:23,040
e scalato dal n.

55
00:03:23,040 --> 00:03:27,810
Ora stiamo andando a leggere un singolo
riga della infile in un

56
00:03:27,810 --> 00:03:30,630
buffer di dimensioni oldwidth.

57
00:03:30,630 --> 00:03:36,190
Così qui, stiamo freading dimensione RGB
tripla, un pixel, e il vecchio larghezza

58
00:03:36,190 --> 00:03:39,760
li dal infile nel nostro buffer.

59
00:03:39,760 --> 00:03:43,480
E questo sta andando essere un intero
remare in questo array.

60
00:03:43,480 --> 00:03:50,390
Così ora, vogliamo iterare n volte a
stampare questa riga al nostro outfile n volte.

61
00:03:50,390 --> 00:03:52,510
Ed è quello che questo ciclo sta facendo.

62
00:03:52,510 --> 00:03:57,910
Questo ciclo interno è scorrere il
riga stessa, sulla matrice, stampa

63
00:03:57,910 --> 00:04:00,710
ciascun pixel nella matrice n volte.

64
00:04:00,710 --> 00:04:04,510
Quindi l'elemento zeroth viene stampato
n volte, il primo elemento è essere

65
00:04:04,510 --> 00:04:05,660
stampata n volte.

66
00:04:05,660 --> 00:04:10,820
E questo genere di come stiamo andando a
scalare orizzontalmente nel file di output, e

67
00:04:10,820 --> 00:04:13,390
questo ciclo, dal momento che stiamo looping n
volte, è come stiamo andando a

68
00:04:13,390 --> 00:04:15,580
scala verticale.

69
00:04:15,580 --> 00:04:19,850
>> Quaggiù, vediamo che abbiamo bisogno di aggiungere
l'imbottitura alla fine di ogni riga.

70
00:04:19,850 --> 00:04:25,050
Ecco perché questo è all'interno del ciclo for
che è la stampa delle n righe di appena

71
00:04:25,050 --> 00:04:28,400
questa riga dalla infile.

72
00:04:28,400 --> 00:04:32,150
Poi qui, ho intenzione di saltare
l'imbottitura in infile, poiché una volta

73
00:04:32,150 --> 00:04:34,560
abbiamo finito con una sola riga della
infile, non ci preoccupiamo

74
00:04:34,560 --> 00:04:35,290
ciò che l'imbottitura è stato.

75
00:04:35,290 --> 00:04:37,110
Vogliamo solo arrivare alla seconda fila.

76
00:04:37,110 --> 00:04:40,870
E poi faremo ciclo indietro e fare tutto
questo nuovo per la seconda fila.

77
00:04:40,870 --> 00:04:44,406
>> Infine, una volta che avremo finito con tutto ciò che,
possiamo chiudere il infile, close

78
00:04:44,406 --> 00:04:47,430
il outfile e ritorno
0 perché abbiamo finito.

79
00:04:47,430 --> 00:04:50,330
>> Il mio nome è Rob, e questo era ridimensionamento.

80
00:04:50,330 --> 00:04:54,934
>> [GIOCO MUSICA]