1
00:00:00,000 --> 00:00:12,240
>> [Muziek]

2
00:00:12,240 --> 00:00:15,870
>> ROB BOWDEN: Hoi, ik ben Rob, laten we
probeer dit op voor de grootte.

3
00:00:15,870 --> 00:00:21,100
Zo, zijn we weer gaan beginnen met
in feite een kopie van de copy.c en

4
00:00:21,100 --> 00:00:22,860
een paar wijzigingen.

5
00:00:22,860 --> 00:00:26,280
Opmerking meteen zien we een verandering, waar
in plaats van te controleren om te zien of

6
00:00:26,280 --> 00:00:30,440
argc niet gelijk 3, willen wij nagaan
Als argc niet gelijk 4, aangezien

7
00:00:30,440 --> 00:00:34,350
nu zijn we niet gewoon in een infile
en outfile, maar we zijn ook het nemen van

8
00:00:34,350 --> 00:00:38,980
n, dat is het bedrag dat we
schalen van de oorspronkelijke afbeelding door.

9
00:00:38,980 --> 00:00:44,340
Zodra we zijn er zeker van dat, we kunnen gewoon
converteren n naar een integer gebruik atoi.

10
00:00:44,340 --> 00:00:48,760
>> Zo, nu gaan we wat maken
aliassen, bel argv 2 infile, en

11
00:00:48,760 --> 00:00:54,240
argv 3 outfile, omdat argv 2 en
argv 3 zijn niet erg behulpzaam namen.

12
00:00:54,240 --> 00:00:58,510
Nu willen we controleren om er zeker n
binnen de grenzen die we verwachten, zodat de

13
00:00:58,510 --> 00:01:02,910
spec bepaalt dat indien het minder dan of
nul of groter dan 100,

14
00:01:02,910 --> 00:01:08,580
dan is dat een ongeldige resize factor,
en we moeten de gebruiker van die waarschuwen.

15
00:01:08,580 --> 00:01:13,090
>> Als we eenmaal voorbij dat alles, we kunnen
eindelijk open onze infile, en we moeten

16
00:01:13,090 --> 00:01:16,270
voor fouten controleren om ervoor te zorgen dat de
opening liet niet na om wat voor reden.

17
00:01:16,270 --> 00:01:19,860
We moeten ook onze outfile openen, en
weer fout controleren om ervoor te zorgen dat

18
00:01:19,860 --> 00:01:21,250
liet niet na om wat voor reden.

19
00:01:21,250 --> 00:01:26,270
Maar wees zeker of de opening van de
outfile niet dat we moeten sluiten

20
00:01:26,270 --> 00:01:29,040
de infile, die al werd geopend.

21
00:01:29,040 --> 00:01:33,690
>> Dus, ervan uitgaande dat niet mislukt, dan
We zijn - net als in copy.c--

22
00:01:33,690 --> 00:01:36,140
ga u in de kop
uit de infile.

23
00:01:36,140 --> 00:01:40,130
We gaan ervoor zorgen dat het een geldige
bitmap, maar nu gaan we wat doen

24
00:01:40,130 --> 00:01:41,620
dingen een beetje anders.

25
00:01:41,620 --> 00:01:44,870
Dus eerst gaan we naar willen
denk aan de oorspronkelijke breedte en hoogte

26
00:01:44,870 --> 00:01:48,290
van de infile, want we gaan
veranderen het voor de outfile.

27
00:01:48,290 --> 00:01:53,890
Dus nu niet vergeten dat voor vreemde redenen
bi.biheight, negatief is, en

28
00:01:53,890 --> 00:01:58,670
dus de werkelijke hoogte, in positieve, we
willen de absolute waarde te nemen.

29
00:01:58,670 --> 00:02:02,580
>> Nu de opvulling zal hetzelfde zijn
berekening zoals het was in copy.c,

30
00:02:02,580 --> 00:02:06,060
met behulp van de oude breedte, en nu zijn we
eigenlijk gaat veranderen

31
00:02:06,060 --> 00:02:07,320
wat in onze header.

32
00:02:07,320 --> 00:02:11,200
Dus we gaan onze breedte vermenigvuldigen met
n, omdat we aanpassen van de breedte van

33
00:02:11,200 --> 00:02:15,100
n, vermenigvuldig de hoogte door n, omdat we
schaalvergroting door n, en nu hebben we

34
00:02:15,100 --> 00:02:19,250
de berekening van een nieuwe vulling
gebaseerd op de nieuwe breedte.

35
00:02:19,250 --> 00:02:21,840
>> Dus nu moeten we wat veranderen
andere gebieden in onze header.

36
00:02:21,840 --> 00:02:26,890
Bi.biSizeImage wordt verondersteld het te zijn
grootte van alle bytes in de pixels

37
00:02:26,890 --> 00:02:28,520
en opvulling van het beeld.

38
00:02:28,520 --> 00:02:34,190
En de grootte van een enkele rij van onze
afbeelding is de grootte van RGB triple, de grootte

39
00:02:34,190 --> 00:02:39,430
van een pixel, maal het aantal
pixels in een rij, plus de padding op

40
00:02:39,430 --> 00:02:40,910
het einde van de rij.

41
00:02:40,910 --> 00:02:45,200
En dan gaan we dat vermenigvuldigt
absolute waarde van onze hoogte te krijgen

42
00:02:45,200 --> 00:02:48,350
het totale aantal bytes
in de beeldgegevens.

43
00:02:48,350 --> 00:02:53,050
bf.bfSize is gewoon het totaal aantal
bytes in onze beeldgegevens, zodat

44
00:02:53,050 --> 00:02:56,530
bi.biSizeImage, plus de
grootte van onze headers.

45
00:02:56,530 --> 00:02:59,850
Dus, het toevoegen van de grootte van bitmapbestand
header, en de grootte van de bitmap info

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

47
00:03:00,800 --> 00:03:03,170
Dus dat is alles wat we nodig hebben om
om in ons headers.

48
00:03:03,170 --> 00:03:07,020
Nu gaan we de bitmap-bestand header schrijven
onze outfile, en onze bitmap info

49
00:03:07,020 --> 00:03:09,880
header onze outfile, en nu
we zijn klaar om te beginnen gaan

50
00:03:09,880 --> 00:03:11,990
over de werkelijke pixels.

51
00:03:11,990 --> 00:03:15,720
>> Dus we willen meer dan herhalen
scanlijnen de infile's.

52
00:03:15,720 --> 00:03:17,730
Dus we willen oldheight itereren over.

53
00:03:17,730 --> 00:03:20,830
Dit is waarom we moesten denken aan de
oorspronkelijke hoogte, voordat we veranderen

54
00:03:20,830 --> 00:03:23,040
en geschaald door n.

55
00:03:23,040 --> 00:03:27,810
Nu gaan we lezen een enkele
rij van de infile een

56
00:03:27,810 --> 00:03:30,630
buffer van omvang oldwidth.

57
00:03:30,630 --> 00:03:36,190
Dus hier, we freading grootte van RGB
triple, een pixel, en oude breedte van

58
00:03:36,190 --> 00:03:39,760
ze uit de infile in onze buffer.

59
00:03:39,760 --> 00:03:43,480
En dat gaat een hele zijn
rij in deze array.

60
00:03:43,480 --> 00:03:50,390
Dus nu willen we n keer te herhalen om
print deze rij om onze outfile n keer.

61
00:03:50,390 --> 00:03:52,510
En dus dat is wat deze lus doet.

62
00:03:52,510 --> 00:03:57,910
Dit binnenste lus wordt itereren over de
rij zelf, over de array, drukkerij

63
00:03:57,910 --> 00:04:00,710
elk pixel in de matrix n keer.

64
00:04:00,710 --> 00:04:04,510
Dus de nulde element wordt afgedrukt
n keer, het eerste element is dat

65
00:04:04,510 --> 00:04:05,660
afgedrukt n keer.

66
00:04:05,660 --> 00:04:10,820
En dat is een soort van hoe we gaan
horizontaal te schalen in de outfile en

67
00:04:10,820 --> 00:04:13,390
deze lus, aangezien we looping n
tijden, is hoe we gaan

68
00:04:13,390 --> 00:04:15,580
verticaal schaal.

69
00:04:15,580 --> 00:04:19,850
>> Hier beneden, zien we dat we nodig hebben om toe te voegen
de bekleding aan het eind van elke rij.

70
00:04:19,850 --> 00:04:25,050
Dat is waarom dit in de lus
dat is het afdrukken van de n rijen van slechts

71
00:04:25,050 --> 00:04:28,400
deze rij uit de infile.

72
00:04:28,400 --> 00:04:32,150
Dan is hier beneden, ik ga dan overslaan
de opvulling in de infile, want zodra

73
00:04:32,150 --> 00:04:34,560
we zijn klaar met een rij van de
infile, hebben we niet de zorg over

74
00:04:34,560 --> 00:04:35,290
wat de vulling was.

75
00:04:35,290 --> 00:04:37,110
We willen gewoon de tweede rij te krijgen.

76
00:04:37,110 --> 00:04:40,870
En dan gaan we loop terug en alles doen
deze opnieuw voor de tweede rij.

77
00:04:40,870 --> 00:04:44,406
>> Tot slot, als we klaar zijn met dat alles,
kunnen we de infile sluiten, dicht

78
00:04:44,406 --> 00:04:47,430
de outfile en rendement
0 omdat we klaar zijn.

79
00:04:47,430 --> 00:04:50,330
>> Mijn naam is Rob, en dit was resize.

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