1
00:00:00,000 --> 00:00:00,996

2
00:00:00,996 --> 00:00:12,470
>> [Musikgengivelse]

3
00:00:12,470 --> 00:00:13,210
>> ROB BOWDEN: Hej.

4
00:00:13,210 --> 00:00:16,870
Jeg er Rob og lad os størrelse
op i dette problem.

5
00:00:16,870 --> 00:00:20,990
Så vi vil til at starte med copy.c som
en skabelon, men vi kommer til at være

6
00:00:20,990 --> 00:00:23,340
gør en hel del ændringer.

7
00:00:23,340 --> 00:00:27,570
>> Nu ser vi, vi straks gøre en
ændre, hvor vi ikke længere tjekker

8
00:00:27,570 --> 00:00:31,560
for vores RXC ikke lig 3, men nu
Vi tjekker rc ikke er lig 4..

9
00:00:31,560 --> 00:00:34,670
Da vi ønsker også at omfatte
Foruden de i filen og filer ud

10
00:00:34,670 --> 00:00:39,550
argumenter, f som kommer til at være på denne
faktor, som vi skalering.

11
00:00:39,550 --> 00:00:45,430
>> Så når vi er sikre på, at vi ønsker at
bruge s scanning f konvertere strengen

12
00:00:45,430 --> 00:00:49,030
argv1 til en float.

13
00:00:49,030 --> 00:00:51,330
Og vi kommer til at gemme
at faktor.

14
00:00:51,330 --> 00:00:55,180
Denne ekstra karakter er at sikre
at vi rent faktisk ikke ind

15
00:00:55,180 --> 00:00:59,200
noget lignende 1,4 ABC
på kommandolinjen.

16
00:00:59,200 --> 00:01:02,960
>> Nu skal vi til at skabe nogle aliaser
da RV2 og RV3 ikke

17
00:01:02,960 --> 00:01:04,310
meget nyttige navne.

18
00:01:04,310 --> 00:01:07,660
Vi er i stedet kommer til at ringe
dem i filen og ud fil.

19
00:01:07,660 --> 00:01:11,580
Nu skal vi sørge for, at
vores faktor var faktisk gyldig.

20
00:01:11,580 --> 00:01:16,330
Så hvis faktor er mindre end eller lig med
nul eller større end 100, så som pr

21
00:01:16,330 --> 00:01:19,660
spec, bør vi afvise
denne faktor.

22
00:01:19,660 --> 00:01:23,890
>> Når vi er sikker på, det er godt, vi nu kan
åbne n fil, og vi er nødt til at gøre

23
00:01:23,890 --> 00:01:25,950
sikker på, at det med succes blev åbnet.

24
00:01:25,950 --> 00:01:28,630
Hvis det ikke gjorde det, vil det returnere null.

25
00:01:28,630 --> 00:01:30,390
Vi kommer til at åbne ud-filen.

26
00:01:30,390 --> 00:01:33,420
Og igen, vi ønsker at tjekke for at
sikker på det er med succes åbnet.

27
00:01:33,420 --> 00:01:37,270
Og hvis det ikke lykkedes at åbne, så
vi også nødt til at være sikker på at lukke

28
00:01:37,270 --> 00:01:40,870
n fil, der oprindeligt blev succesfuldt
åbnet, ellers har vi en

29
00:01:40,870 --> 00:01:42,600
hukommelsesfejl.

30
00:01:42,600 --> 00:01:46,350
>> Så nu vil vi læse i bitmap
filens header og bitmap info

31
00:01:46,350 --> 00:01:48,890
header fra n fil.

32
00:01:48,890 --> 00:01:52,360
Vi kommer til at sørge for, at
n fil var et gyldigt bitmap.

33
00:01:52,360 --> 00:01:52,640
OK.

34
00:01:52,640 --> 00:01:55,100
>> Så nu vil vi til at starte
at lave nogle ændringer.

35
00:01:55,100 --> 00:01:58,840
Så fordi vi kommer til at være under forandring
ting, vi først ønsker at huske

36
00:01:58,840 --> 00:02:01,510
gamle bredde n fil.

37
00:02:01,510 --> 00:02:05,160
Vi ønsker at huske det gamle polstring af
n-filen ved hjælp af den samme beregning

38
00:02:05,160 --> 00:02:06,990
fra copy.c.

39
00:02:06,990 --> 00:02:09,840
>> Og nu vi kommer til at ændre
bitmap info header.

40
00:02:09,840 --> 00:02:13,630
Og så vi multiplicere både bredden
og højden af ​​faktor, da

41
00:02:13,630 --> 00:02:15,750
det er, hvad vi er skalering af.

42
00:02:15,750 --> 00:02:18,420
Vi kommer til at bestemme
ny polstring af filen ved

43
00:02:18,420 --> 00:02:21,140
ved hjælp af den nye bredde.

44
00:02:21,140 --> 00:02:27,330
Og vi kommer til at bestemme den nye
størrelsen på billedet ved hjælp af antallet af

45
00:02:27,330 --> 00:02:31,610
bytes i en enkelt række, som vil
være antallet af pixels i den række

46
00:02:31,610 --> 00:02:35,960
gange størrelsen af ​​en pixel plus
antal byte polstring ved udgangen

47
00:02:35,960 --> 00:02:40,310
af denne række, og multiplicere alle,
med antallet af rækker, vi har.

48
00:02:40,310 --> 00:02:43,800
Så det er det antal bytes
vi har i vores billeddata.

49
00:02:43,800 --> 00:02:48,190
>> Bf.Bfsize nu kommer til at være nummer
bytes i vores image beta plus

50
00:02:48,190 --> 00:02:49,350
størrelsen af ​​vores overskrifter.

51
00:02:49,350 --> 00:02:53,910
Så plus størrelse på bitmap-fil header
og størrelse af bitmap-info header.

52
00:02:53,910 --> 00:02:54,510
OK.

53
00:02:54,510 --> 00:02:56,440
Så det er det for vores overskrifter.

54
00:02:56,440 --> 00:02:59,030
Vi kan skrive filen hoved og
info header til vores ud

55
00:02:59,030 --> 00:03:01,590
fil, og vi er gode.

56
00:03:01,590 --> 00:03:03,800
>> Nu er det tid til at starte faktisk
skrive pixel

57
00:03:03,800 --> 00:03:05,120
data til ud-filen.

58
00:03:05,120 --> 00:03:10,460
Vi kommer til at erklære en buffer størrelse
gamle bredde RGB tredobler, og vi er

59
00:03:10,460 --> 00:03:13,790
kommer til at erklære en variabel kaldet
række følelsesløse, som er, at vi kommer til at

60
00:03:13,790 --> 00:03:15,640
indledningsvis sættes lig negativ 1.

61
00:03:15,640 --> 00:03:19,090
Vi vil se, at vi kommer til at bruge
at for at holde styr på, hvad

62
00:03:19,090 --> 00:03:22,640
række vi i øjeblikket har indlæst
i denne buffer.

63
00:03:22,640 --> 00:03:23,290
OK.

64
00:03:23,290 --> 00:03:28,750
>> Så nu i modsætning til den standard udgave,
i stedet for iteration over på i

65
00:03:28,750 --> 00:03:32,900
fil, vi kommer til at gentage over hver
række i ud-filen og finde ud

66
00:03:32,900 --> 00:03:38,130
hvilken række i in fil, vi ønsker at
placere i denne række i ud-filen.

67
00:03:38,130 --> 00:03:44,930
Så iteration i alle rækker i ud
fil ved hjælp af den nye højde, er vi først

68
00:03:44,930 --> 00:03:48,890
kommer til at bestemme rækken i den gamle
fil vi kommer til at bruge, som vi er

69
00:03:48,890 --> 00:03:53,560
kommer til at gøre ved at tage denne aktuelle
række divideret med faktor.

70
00:03:53,560 --> 00:03:58,000
Så det kommer til at give os rækken
i den gamle fil, vi ønsker.

71
00:03:58,000 --> 00:04:03,310
>> Så nu, hvis rækken følelsesløs ikke lige gamle y,
vi er nødt til at læse rækken

72
00:04:03,310 --> 00:04:05,940
at vi ønsker i vores nuværende rækken buffer.

73
00:04:05,940 --> 00:04:07,700
Så hvordan skal vi gøre det?

74
00:04:07,700 --> 00:04:11,650
Først, vi kommer til at finde ud af
position, der begynder at række i

75
00:04:11,650 --> 00:04:13,100
originale fil.

76
00:04:13,100 --> 00:04:18,630
Så denne stilling bliver
forbi alle vores overskrifter og

77
00:04:18,630 --> 00:04:21,589
nu forbi gamle y rækker.

78
00:04:21,589 --> 00:04:23,880
>> Og så hvor mange bytes
er i en enkelt række?

79
00:04:23,880 --> 00:04:28,740
Igen, størrelsen af ​​RGB tredobbelt gange gammel
bredde plus gamle polstring, så det er

80
00:04:28,740 --> 00:04:30,640
antal bytes i en enkelt række.

81
00:04:30,640 --> 00:04:33,680
Og vi ønsker at springe forbi gamle y rækker.

82
00:04:33,680 --> 00:04:37,580
Så vi kommer til at f søge, og vi er
bruge søge indstillet til at starte fra

83
00:04:37,580 --> 00:04:39,100
begyndelsen af ​​en fil.

84
00:04:39,100 --> 00:04:42,740
Vi kommer til at f søge at denne position
i filen, sætte os på

85
00:04:42,740 --> 00:04:46,500
starten af ​​rækken, vi ønsker
at læse i vores buffer.

86
00:04:46,500 --> 00:04:48,510
>> Vi kommer til at sætte række
følelsesløs svarende til gamle y.

87
00:04:48,510 --> 00:04:53,080
Så nu, hvis vi loop tilbage, og vi ønsker at
bruge den samme række i vores ud-fil,

88
00:04:53,080 --> 00:04:55,970
så vi kommer ikke til at læse
det i igen unødigt.

89
00:04:55,970 --> 00:04:59,310
Så virkelig, række følelsesløs er
blot en optimering.

90
00:04:59,310 --> 00:05:05,500
>> Endelig vil vi læse i
aktuelle række gamle bredde RGB tredobler

91
00:05:05,500 --> 00:05:08,040
at vi ønsker fra den oprindelige fil.

92
00:05:08,040 --> 00:05:12,270
Så nu cur række indeholder pixels fra
den originale fil, vi ønsker at

93
00:05:12,270 --> 00:05:14,200
skrive ind i ud-fil.

94
00:05:14,200 --> 00:05:18,960
Så nu, ligesom ovenfor, i stedet for
iteration over den gamle fil, vi har brug for

95
00:05:18,960 --> 00:05:22,560
det til at gentage over de nye filer rækker.

96
00:05:22,560 --> 00:05:27,450
Nå her, i stedet for iteration over alle
af de gamle pixels, der i nuværende række,

97
00:05:27,450 --> 00:05:31,210
vi ønsker at gentage over alle
pixels i vores nye fil i denne

98
00:05:31,210 --> 00:05:32,480
bestemt række.

99
00:05:32,480 --> 00:05:34,140
>> Hvorfor ønsker vi at gøre det?

100
00:05:34,140 --> 00:05:38,960
Fordi vi ser her, at vi ikke
faktisk nødvendigvis at bruge alle de

101
00:05:38,960 --> 00:05:41,020
pixels i den oprindelige fil.

102
00:05:41,020 --> 00:05:46,630
Fordi hvis vi skrumper, vi måske
faktisk ønsker at springe pixels.

103
00:05:46,630 --> 00:05:48,090
Og vi ser, at det -

104
00:05:48,090 --> 00:05:49,690
x divideret med faktor -

105
00:05:49,690 --> 00:05:55,620
nøje afspejler op her, hvor vi siger y
divideret med faktor at regne ud, at

106
00:05:55,620 --> 00:06:02,480
den gamle y-te række svarer til
y-te række i den nye fil.

107
00:06:02,480 --> 00:06:05,880
>> Nu skal vi til at skrive alle
disse pixels fra den gamle række

108
00:06:05,880 --> 00:06:07,440
ind i vores nye række.

109
00:06:07,440 --> 00:06:10,890
Når vi har gjort det, er vi nødt til bare
sætte polstring i slutningen af ​​vores rækken

110
00:06:10,890 --> 00:06:15,540
og vi vil løkke tilbage og fortsætte
alle rækkerne i vores nye fil.

111
00:06:15,540 --> 00:06:19,390
I slutningen, er vi nødt til at lukke vores gamle
fil, skal du lukke vores nye fil, og tilbagevenden

112
00:06:19,390 --> 00:06:21,540
nul, fordi alt gik fint.

113
00:06:21,540 --> 00:06:24,220
>> Mit navn er Rob og dette var Recess.

114
00:06:24,220 --> 00:06:29,184
>> [Musikgengivelse]