1
00:00:00,000 --> 00:00:12,240
>> [MUSIC SPIEL]

2
00:00:12,240 --> 00:00:15,870
>> ROB BOWDEN: Hallo, ich bin Rob, wir
versuchen, diese für Größe.

3
00:00:15,870 --> 00:00:21,100
Also, wir sind wieder in Gang, mit zu beginnen
im Grunde eine Kopie der copy.c und

4
00:00:21,100 --> 00:00:22,860
ein paar Änderungen.

5
00:00:22,860 --> 00:00:26,280
Hinweis sofort sehen wir eine Veränderung, wo
anstatt zu überprüfen, ob

6
00:00:26,280 --> 00:00:30,440
argc nicht gleich 3, um zu überprüfen, wollen wir
wenn argc nicht gleich 4, da

7
00:00:30,440 --> 00:00:34,350
Jetzt sind wir nicht einfach nur in einer Eingabedatei
und Ausgabedatei, aber wir sind auch unter in

8
00:00:34,350 --> 00:00:38,980
n, die Menge, die wir sind ist
Skalierung des ursprünglichen Bildes durch.

9
00:00:38,980 --> 00:00:44,340
Sobald wir sicher sind, dass, können wir nur
n umwandeln in eine Ganzzahl mit atoi.

10
00:00:44,340 --> 00:00:48,760
>> So, jetzt werden wir einige erstellen
Aliase, rufen Sie einfach argv 2 infile und

11
00:00:48,760 --> 00:00:54,240
argv 3 outfile, denn argv 2 und
argv 3 sind nicht sehr hilfreich Namen.

12
00:00:54,240 --> 00:00:58,510
Nun, um zu überprüfen, um sicherzustellen, n wollen wir
innerhalb der Grenzen zu erwarten, so dass die

13
00:00:58,510 --> 00:01:02,910
Spezifikation legt fest, dass, wenn es kleiner oder
gleich Null oder größer als 100,

14
00:01:02,910 --> 00:01:08,580
dann ist das eine ungültige Resize-Faktor,
und wir sollten die Benutzer, dass zu warnen.

15
00:01:08,580 --> 00:01:13,090
>> Sobald wir über all das sind, können wir
endlich öffnen unsere infile, und wir brauchen

16
00:01:13,090 --> 00:01:16,270
Irrtum überprüfen, um sicherzustellen, dass die
Öffnung nicht scheitern aus irgendeinem Grund.

17
00:01:16,270 --> 00:01:19,860
Wir müssen auch unsere Ausgabedatei zu öffnen, und
wieder Fehler zu überprüfen, um sicherzustellen, dass

18
00:01:19,860 --> 00:01:21,250
blieb nicht aus irgendeinem Grund.

19
00:01:21,250 --> 00:01:26,270
Aber achten Sie darauf, wenn die Eröffnung des
outfile gescheitert, dass wir schließen

20
00:01:26,270 --> 00:01:29,040
die Eingabedatei, die bereits geöffnet wurde.

21
00:01:29,040 --> 00:01:33,690
>> Also, vorausgesetzt, dass nicht scheitern, dann
Freundin Höschen - wie in copy.c--

22
00:01:33,690 --> 00:01:36,140
gehen, um in der Kopfzeile zu lesen
aus der Eingabedatei.

23
00:01:36,140 --> 00:01:40,130
Wir werden sicherstellen, dass es eine gültige
Bitmap, aber jetzt werden wir einige tun

24
00:01:40,130 --> 00:01:41,620
die Dinge ein wenig anders.

25
00:01:41,620 --> 00:01:44,870
Also zuerst, wir gehen zu wollen
an die ursprüngliche Breite und Höhe

26
00:01:44,870 --> 00:01:48,290
der Eingabedatei, weil wir zu gehen
werden für die Ausgabedatei ändern es.

27
00:01:48,290 --> 00:01:53,890
So, jetzt daran erinnern, dass für die seltsamen Gründen
bi.biheight, negativ ist, und

28
00:01:53,890 --> 00:01:58,670
so dass die tatsächliche Höhe in positive, wir
wollen, um den absoluten Wert zu nehmen.

29
00:01:58,670 --> 00:02:02,580
>> Nun wird die Polsterung werde gleich sein
Berechnung, wie sie in copy.c war,

30
00:02:02,580 --> 00:02:06,060
mit der alten Breite, und jetzt sind wir
tatsächlich zu verändern

31
00:02:06,060 --> 00:02:07,320
Was ist in unserem Header.

32
00:02:07,320 --> 00:02:11,200
So werden wir in unseren Breiten multiplizieren
n, da wir durch Skalieren der Breite

33
00:02:11,200 --> 00:02:15,100
n, multiplizieren Sie die Höhe durch n, da wir
Skalierung von n, und jetzt haben wir

34
00:02:15,100 --> 00:02:19,250
die Berechnung für eine neue Polsterung
bezogen auf die neue Breite.

35
00:02:19,250 --> 00:02:21,840
>> So, jetzt, einige müssen wir ändern
anderen Bereichen in unserem Header.

36
00:02:21,840 --> 00:02:26,890
Bi.biSizeImage soll das sein
Größe aller Bytes in den Pixeln

37
00:02:26,890 --> 00:02:28,520
und Auffüllen des Bildes.

38
00:02:28,520 --> 00:02:34,190
Und so ist die Größe einer einzelnen Reihe unserer
Bild ist Größe der RGB-Tripel, die Größe

39
00:02:34,190 --> 00:02:39,430
eines einzelnen Pixels, mal der Anzahl der
Pixel in einer Reihe, sowie die Polsterung an

40
00:02:39,430 --> 00:02:40,910
das Ende der Reihe.

41
00:02:40,910 --> 00:02:45,200
Und dann werden wir, dass multiplizieren
Absolutwert der Höhe zu erhalten

42
00:02:45,200 --> 00:02:48,350
die Gesamtzahl der Bytes
in den Bilddaten.

43
00:02:48,350 --> 00:02:53,050
bf.bfSize ist nur die Gesamtzahl
von Bytes in unserer Bilddaten, so

44
00:02:53,050 --> 00:02:56,530
bi.biSizeImage zuzüglich der
Größe unserer Header.

45
00:02:56,530 --> 00:02:59,850
Also, das Hinzufügen von der Größe der Bitmap-Datei
Kopfzeile, und die Größe der Bitmap-Informationen

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

47
00:03:00,800 --> 00:03:03,170
Also das ist alles, was wir brauchen, um
ändern in unserem Header.

48
00:03:03,170 --> 00:03:07,020
Jetzt werden wir die Bitmap-Datei-Header zu schreiben
unsere outfile und unsere Bitmap-info

49
00:03:07,020 --> 00:03:09,880
header, unsere Ausgabedatei, und jetzt
wir sind bereit zu beginnen werde

50
00:03:09,880 --> 00:03:11,990
über den tatsächlichen Pixel.

51
00:03:11,990 --> 00:03:15,720
>> So zu durchlaufen wollen wir
Scanzeilen der Eingabedatei ist.

52
00:03:15,720 --> 00:03:17,730
Deshalb wollen wir über oldheight zu durchlaufen.

53
00:03:17,730 --> 00:03:20,830
Deshalb mussten wir daran erinnern, die
ursprüngliche Höhe, bevor wir es ändern

54
00:03:20,830 --> 00:03:23,040
und skaliert es durch n.

55
00:03:23,040 --> 00:03:27,810
Jetzt werden wir das Lesen eines einzelnen
Zeile der Eingabedatei in eine

56
00:03:27,810 --> 00:03:30,630
Puffer der Größe oldwidth.

57
00:03:30,630 --> 00:03:36,190
Also hier, wir sind freading Größe von RGB
Dreibett-, ein Pixel, und der alte Breite

58
00:03:36,190 --> 00:03:39,760
sie aus der Eingabedatei in unsere Puffer.

59
00:03:39,760 --> 00:03:43,480
Und das wird eine ganze sein
Zeile in diesem Array.

60
00:03:43,480 --> 00:03:50,390
So, jetzt zu n-mal zu durchlaufen wollen wir
drucken Sie diese Zeile, um unsere outfile n-mal.

61
00:03:50,390 --> 00:03:52,510
Und damit ist das, was diese Schleife tut.

62
00:03:52,510 --> 00:03:57,910
Diese innere Schleife über die Iteration
Zeile selbst, über die Anordnung, Druck-

63
00:03:57,910 --> 00:04:00,710
jeder Pixel in dem Array n mal.

64
00:04:00,710 --> 00:04:04,510
So dass das nullte Element gedruckt wird
n-mal, wobei das erste Element wird

65
00:04:04,510 --> 00:04:05,660
n-mal gedruckt.

66
00:04:05,660 --> 00:04:10,820
Und das ist eine Art, wie wir zu
horizontale Skalierung in der Ausgabedatei, und

67
00:04:10,820 --> 00:04:13,390
diese Schleife, da wir Looping n
Zeiten, ist, wie wir zu gehen

68
00:04:13,390 --> 00:04:15,580
vertikal Maßstab.

69
00:04:15,580 --> 00:04:19,850
>> Hier unten sehen wir, dass wir brauchen, um hinzuzufügen
die Polsterung am Ende jeder Zeile.

70
00:04:19,850 --> 00:04:25,050
Das ist, warum das so ist in der for-Schleife
das ist Ausdruck der n Zeilen nur

71
00:04:25,050 --> 00:04:28,400
diese eine Zeile aus der Eingabedatei.

72
00:04:28,400 --> 00:04:32,150
Dann ist hier unten, ich werde überspringen
die Polsterung in der Eingabedatei, da einmal

73
00:04:32,150 --> 00:04:34,560
wir mit einer Zeile der getan
infile, haben wir nicht zu kümmern

74
00:04:34,560 --> 00:04:35,290
was die Polsterung war.

75
00:04:35,290 --> 00:04:37,110
Wir wollen einfach nur in die zweite Reihe zu bekommen.

76
00:04:37,110 --> 00:04:40,870
Und dann werden wir Schleife zurück und alles tun,
Diese Mitteilung für die zweite Reihe.

77
00:04:40,870 --> 00:04:44,406
>> Schließlich, wenn wir mit allem, was getan,
können wir die Eingabedatei zu schließen, in der Nähe

78
00:04:44,406 --> 00:04:47,430
der Ausgabedatei und Rück
0, da wir fertig sind.

79
00:04:47,430 --> 00:04:50,330
>> Mein Name ist Rob, und das war Größenänderung.

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