1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Walkthrough - Problem Set 4]

2
00:00:02,700 --> 00:00:05,000
[Zamyla Chan - Harvard University]

3
00:00:05,000 --> 00:00:07,340
[Dette er CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
OK. Hei, alle sammen, og velkommen til Walkthrough 4.

5
00:00:11,670 --> 00:00:14,270
>> I dag vårt pset er Forensics.

6
00:00:14,270 --> 00:00:18,080
Forensics er en veldig morsom pset som innebærer håndtering av bitmap-filer

7
00:00:18,080 --> 00:00:21,550
å oppdage hvem begått en forbrytelse.

8
00:00:21,550 --> 00:00:24,200
Så vi kommer til å endre størrelsen noen bitmap-filer,

9
00:00:24,200 --> 00:00:27,780
så vi kommer også til å håndtere en veldig morsom del kalt gjenvinning,

10
00:00:27,780 --> 00:00:31,160
der vi i utgangspunktet ga et minnekort

11
00:00:31,160 --> 00:00:34,350
der noen har et uhell slettet alle sine filer,

12
00:00:34,350 --> 00:00:38,860
og vi blir bedt om å gjenopprette filene.

13
00:00:38,860 --> 00:00:42,910
>> Men først, før vi kommer inn i pset, jeg egentlig bare ønsker å gratulere alle.

14
00:00:42,910 --> 00:00:45,230
Vi er i ferd med på midtpunktet av dette kurset.

15
00:00:45,230 --> 00:00:50,070
Quiz 0 er bak oss, og vi er på pset4, så egentlig er vi halvveis.

16
00:00:50,070 --> 00:00:55,490
Vi har kommet en lang vei hvis du ser tilbake til psets, pset0 og pset1,

17
00:00:55,490 --> 00:00:57,300
så gratulere deg om det,

18
00:00:57,300 --> 00:01:00,760
og vi kommer til å få inn noen virkelig morsomme ting.

19
00:01:00,760 --> 00:01:07,070
>> Så vår verktøykasse for denne pset, igjen, i stedet for å kjøre sudo yum-y-oppdatering,

20
00:01:07,070 --> 00:01:13,890
vi er i stand til å bare kjøre update50 hvis du er på versjon 17.3 og nyere av apparatet.

21
00:01:13,890 --> 00:01:17,380
Så sørg for å kjøre update50 - det er mye enklere, noen mindre tegn -

22
00:01:17,380 --> 00:01:20,640
å sørge for at du er på den nyeste versjonen av apparatet.

23
00:01:20,640 --> 00:01:25,410
Spesielt er det viktig å update50 når vi begynner å bruke CS50 Check.

24
00:01:25,410 --> 00:01:28,700
Så sørg for at du gjør det.

25
00:01:28,700 --> 00:01:30,760
>> For alle delene for denne pset,

26
00:01:30,760 --> 00:01:34,350
vi kommer til å være håndtere fil innganger og utganger, fil I / O.

27
00:01:34,350 --> 00:01:38,140
Vi kommer til å gå over en rekke programmer som omhandler matriser

28
00:01:38,140 --> 00:01:40,350
peker til filer og sånt,

29
00:01:40,350 --> 00:01:43,050
så vi ønsker å være sikker på at vi er veldig kjent og komfortabel

30
00:01:43,050 --> 00:01:47,990
arbeider med hvordan inngang og utgang til filer.

31
00:01:47,990 --> 00:01:52,080
>> I fordelingen koden for denne pset er en fil som heter copy.c,

32
00:01:52,080 --> 00:01:55,280
og det er det vi kommer til å finne kommer til å være veldig nyttig for oss

33
00:01:55,280 --> 00:02:00,340
fordi vi kommer til å ende opp med faktisk å kopiere copy.c filen

34
00:02:00,340 --> 00:02:05,350
og bare endre det litt å kunne oppnå de første 2 deler av oppgaven.

35
00:02:05,350 --> 00:02:09,030
>> Og så da, som jeg nevnte tidligere, har vi å gjøre med punktgrafikk samt JPEG.

36
00:02:09,030 --> 00:02:13,170
Så egentlig å forstå strukturen av hvordan disse filene er organisert,

37
00:02:13,170 --> 00:02:16,170
hvordan vi virkelig kan oversette den 0'er og 1'ere i structs

38
00:02:16,170 --> 00:02:19,040
og ting som vi faktisk kan forstå og tolke og redigere,

39
00:02:19,040 --> 00:02:21,000
som vil være veldig viktig,

40
00:02:21,000 --> 00:02:25,970
så gå inn JPEG og bitmap-filer og forstå strukturen av disse.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, som vanlig, begynner med en del spørsmål.

42
00:02:30,780 --> 00:02:36,600
De vil håndtere fil I / O og få deg vant til det.

43
00:02:36,600 --> 00:02:42,520
Da del 1 er whodunit, der du får en bitmap fil

44
00:02:42,520 --> 00:02:45,630
som ser typen som røde prikker over hele kroppen.

45
00:02:45,630 --> 00:02:52,180
Og deretter i utgangspunktet hva vi skal gjøre er å ta denne filen og bare redigere det litt

46
00:02:52,180 --> 00:02:54,010
inn i en versjon som vi kan lese.

47
00:02:54,010 --> 00:02:56,000
I hovedsak, når vi er ferdige, vil vi ha den samme filen,

48
00:02:56,000 --> 00:03:02,630
bortsett fra vi vil være i stand til å se det skjulte budskapet skjult av alle de røde prikkene.

49
00:03:02,630 --> 00:03:07,310
Deretter Resize er et program som, gitt en fil

50
00:03:07,310 --> 00:03:11,490
og deretter gitt navnet på filen som det utganger og deretter gitt et tall som godt,

51
00:03:11,490 --> 00:03:16,850
faktisk vil endre størrelsen at bitmap ved at heltallsverdi.

52
00:03:16,850 --> 00:03:19,240
Så til slutt, har vi Recover pset.

53
00:03:19,240 --> 00:03:24,160
Vi får et minnekort og deretter har å gjenopprette alle bildene

54
00:03:24,160 --> 00:03:25,920
som har blitt slettet ved et uhell,

55
00:03:25,920 --> 00:03:31,420
men, som vi skal lære, ikke egentlig slettet og fjernet fra filen;

56
00:03:31,420 --> 00:03:38,470
vi bare slags mistet hvor de var i filen, men vi kommer til å gjenopprette det.

57
00:03:38,470 --> 00:03:44,950
>> Flott. Så gå inn fil I / O spesielt, disse er en hel liste over funksjoner som du skal bruke.

58
00:03:44,950 --> 00:03:49,840
Du har allerede sett litt grunnleggende fopen, fread og fwrite,

59
00:03:49,840 --> 00:03:54,350
men vi kommer til å se nærmere på noen fil I / O-funksjoner som fputc,

60
00:03:54,350 --> 00:03:56,930
der du bare skrive ett tegn om gangen,

61
00:03:56,930 --> 00:04:02,000
til fseek, der du slags flytte filen posisjonsindikator forover og bakover,

62
00:04:02,000 --> 00:04:05,770
og deretter noen andre. Men vi vil gå inn på det litt senere i løpet av pset.

63
00:04:08,050 --> 00:04:13,100
>> Så først, bare for å komme inn fil I / O før vi går inn i pset,

64
00:04:13,100 --> 00:04:19,860
å åpne en fil, for eksempel, er hva du har å gjøre faktisk sette en peker til den filen.

65
00:04:19,860 --> 00:04:22,710
Så vi har en fil * peker.

66
00:04:22,710 --> 00:04:27,140
I dette tilfellet, jeg kaller det en i peker fordi det kommer til å være min infile.

67
00:04:27,140 --> 00:04:33,340
Og så jeg kommer til å bruke funksjonen fopen og så navnet på filen

68
00:04:33,340 --> 00:04:36,360
og deretter hvilken modus jeg kommer til å være håndtere filen.

69
00:04:36,360 --> 00:04:42,080
Så det er "r" i dette tilfellet for å lese, "w" for skriving, og deretter "a" for å føye til.

70
00:04:42,080 --> 00:04:44,270
For eksempel, når du arbeider med en infile

71
00:04:44,270 --> 00:04:47,310
og alt du ønsker å gjøre er å lese bits og bytes lagret der,

72
00:04:47,310 --> 00:04:50,420
så er du sannsynligvis kommer til å ønske å bruke "r" som modusen.

73
00:04:50,420 --> 00:04:54,520
Når du ønsker å faktisk skrive, type lage en ny fil,

74
00:04:54,520 --> 00:04:57,220
så hva vi skal gjøre er at vi kommer til å åpne den nye filen

75
00:04:57,220 --> 00:05:02,410
og bruke "w"-modus for å skrive.

76
00:05:02,410 --> 00:05:07,540
>> Så når du faktisk leser inn filene, er strukturen som følger.

77
00:05:07,540 --> 00:05:14,930
Først inkluderer pekeren til struct som skal inneholde de bytes som du leser.

78
00:05:14,930 --> 00:05:19,830
Så det kommer til å være slutten plasseringen av bytes som du leser.

79
00:05:19,830 --> 00:05:23,360
Du deretter kommer til å indikere størrelsen, liker i utgangspunktet hvor mange byte

80
00:05:23,360 --> 00:05:30,100
programmet har å lese i til filen, størrelsen utgangspunktet en del er,

81
00:05:30,100 --> 00:05:32,620
og du kommer til å spesifisere hvor mange elementer du ønsker å lese.

82
00:05:32,620 --> 00:05:34,980
Og så til slutt, må du vite hvor du leser fra,

83
00:05:34,980 --> 00:05:37,580
så det kommer til å bli din i pekeren.

84
00:05:37,580 --> 00:05:41,780
Jeg fargekodet disse fordi fread er også svært lik fwrite,

85
00:05:41,780 --> 00:05:47,050
bortsett fra at du vil være sikker på at du bruker riktig rekkefølge,

86
00:05:47,050 --> 00:05:51,960
sørg for at du faktisk skriver til eller leser fra høyre fil.

87
00:05:54,910 --> 00:05:58,610
>> Så da som før, hvis vi har størrelsen av elementet samt antall elementer,

88
00:05:58,610 --> 00:06:00,600
så kan vi spille rundt her litt.

89
00:06:00,600 --> 00:06:06,810
Si jeg har en hund struct og så da vil jeg lese to hunder om gangen.

90
00:06:06,810 --> 00:06:12,450
Hva jeg kunne gjøre er å si størrelsen på ett element kommer til å være på størrelse med en hund

91
00:06:12,450 --> 00:06:14,770
og jeg kommer til å faktisk lese to av dem.

92
00:06:14,770 --> 00:06:18,290
Alternativt er å si hva jeg kunne gjøre jeg bare kommer til å lese ett element

93
00:06:18,290 --> 00:06:21,340
og at ett element kommer til å være på størrelse med to hunder.

94
00:06:21,340 --> 00:06:24,320
Så det er analogt hvordan du kan slags lek rundt med størrelse og antall

95
00:06:24,320 --> 00:06:28,250
avhengig av hva som er mer intuitive for deg.

96
00:06:28,250 --> 00:06:30,810
>> OK. Så nå får vi til å skrive filer.

97
00:06:30,810 --> 00:06:36,880
Når du ønsker å skrive en fil, er det første argumentet faktisk der du leser fra.

98
00:06:36,880 --> 00:06:42,050
Så det er i utgangspunktet dataene du skal skrive inn filen,

99
00:06:42,050 --> 00:06:44,490
som er den ute pekeren på slutten.

100
00:06:44,490 --> 00:06:47,670
Så når du arbeider med pset, sørg for at du ikke blir forvirret.

101
00:06:47,670 --> 00:06:50,480
Kanskje har definisjonene side ved side.

102
00:06:50,480 --> 00:06:58,090
Du kan trekke definisjonene opp i manualen ved å skrive mannen og så fwrite, for eksempel,

103
00:06:58,090 --> 00:06:59,950
i terminalen, eller du kan se tilbake på dette lysbildet

104
00:06:59,950 --> 00:07:03,570
og sørg for at du bruker den rette.

105
00:07:03,570 --> 00:07:08,700
Så igjen, for fwrite, når du har en fil som du ønsker å skrive inn,

106
00:07:08,700 --> 00:07:14,290
som kommer til å bli det siste argumentet, og det kommer til å være en peker til den filen.

107
00:07:14,290 --> 00:07:18,670
Så da det er hvordan vi håndterer skrive kanskje flere byte om gangen,

108
00:07:18,670 --> 00:07:21,820
men si at du ønsker å bare skrive i bare ett enkelt tegn.

109
00:07:21,820 --> 00:07:25,940
Som vi skal se senere i dette eksempelet, i punktgrafikk må vi bruke det.

110
00:07:25,940 --> 00:07:32,180
Det er da vi kan bruke fputc, egentlig bare å sette en karakter på en gang, chr,

111
00:07:32,180 --> 00:07:37,050
inn i filen pekeren, og det er vår ute pekeren der.

112
00:07:38,700 --> 00:07:41,560
Så da når vi søker eller skrive i en fil,

113
00:07:41,560 --> 00:07:44,690
filen er å holde styr på hvor vi er.

114
00:07:44,690 --> 00:07:47,810
Så det er en slags markør, filen posisjonsindikator.

115
00:07:47,810 --> 00:07:54,330
Og så når vi skriver eller leser igjen i en fil,

116
00:07:54,330 --> 00:07:56,760
filen husker faktisk hvor det er,

117
00:07:56,760 --> 00:07:59,270
og så det fortsetter fra der markøren er.

118
00:07:59,270 --> 00:08:03,970
Dette kan være nyttig når du vil, sier lese i en viss å gjøre noe

119
00:08:03,970 --> 00:08:06,160
og deretter lese i følgende beløp,

120
00:08:06,160 --> 00:08:10,700
men noen ganger vi kanskje vil gå tilbake eller faktisk starte fra en bestemt referanseverdi.

121
00:08:10,700 --> 00:08:16,870
Så da fseek funksjon, hva den gjør er tillater oss å flytte markøren i en bestemt fil

122
00:08:16,870 --> 00:08:19,680
et visst antall av bytes.

123
00:08:19,680 --> 00:08:24,260
Og hva vi må gjøre er å angi hvor referanseverdien er.

124
00:08:24,260 --> 00:08:31,520
Så enten den beveger seg fremover eller bakover fra der markøren i øyeblikket er,

125
00:08:31,520 --> 00:08:35,750
eller vi kan angi at det skal bare bevege seg i fra begynnelsen av filen

126
00:08:35,750 --> 00:08:37,090
eller fra slutten av filen.

127
00:08:37,090 --> 00:08:41,230
Og så kan du passere i negative eller positive verdier til beløp,

128
00:08:41,230 --> 00:08:44,960
og som vil slags flytte markøren enten forover eller bakover.

129
00:08:46,170 --> 00:08:51,920
>> Før vi kommer inn i de andre psets, noen spørsmål på fil I / O?

130
00:08:53,860 --> 00:08:59,990
Okay. Som vi får inn flere eksempler, gjerne stoppe meg for spørsmål.

131
00:08:59,990 --> 00:09:06,930
>> Så i whodunit, du levert en bitmap fil som ligner på denne røde på lysbildet,

132
00:09:06,930 --> 00:09:14,510
og det ser ut som dette - en haug med røde prikker - og du vet ikke egentlig hva som er skrevet.

133
00:09:14,510 --> 00:09:23,310
Hvis du myse, kan du være i stand til å se en liten blåaktig farge på innsiden midten.

134
00:09:23,310 --> 00:09:26,270
I hovedsak er det der teksten er lagret.

135
00:09:26,270 --> 00:09:30,270
Det var et mord som skjedde, og vi trenger å finne ut hvem som gjorde det.

136
00:09:30,270 --> 00:09:36,760
For å gjøre det, må vi slags konvertere dette bildet til et lesbart format.

137
00:09:36,760 --> 00:09:42,740
Hvis dere noen gang støtt på dette, noen ganger ville det være lite kits

138
00:09:42,740 --> 00:09:48,510
der du vil ha et forstørrelsesglass med en rød film. Anyone? Ja.

139
00:09:48,510 --> 00:09:52,770
Så du ville være handed noe som dette, ville du ha et forstørrelsesglass

140
00:09:52,770 --> 00:09:58,130
med den røde film over det, ville du sette den over bildet,

141
00:09:58,130 --> 00:10:03,410
og du ville være i stand til å se meldingen skjult der.

142
00:10:03,410 --> 00:10:07,080
Vi har ikke et forstørrelsesglass med rød film, så i stedet vi skal til slags lage vår egen

143
00:10:07,080 --> 00:10:09,060
i denne pset.

144
00:10:09,060 --> 00:10:15,760
Og slik at brukeren skal inn whodunit, så ledetråd,. Bmp,

145
00:10:15,760 --> 00:10:18,800
så det er infile, det er den røde prikken meldingen,

146
00:10:18,800 --> 00:10:23,550
og deretter de sier verdict.bmp kommer til å være vår utfil.

147
00:10:23,550 --> 00:10:27,900
Så det kommer til å opprette en ny punktgrafikkbilde lik ledetråd en

148
00:10:27,900 --> 00:10:32,600
bortsett fra i et lesbart format der vi kan se det skjulte budskapet.

149
00:10:32,600 --> 00:10:37,550
>> Siden vi kommer til å håndtere redigering og manipulering punktgrafikk av noe slag,

150
00:10:37,550 --> 00:10:42,400
vi kommer til å slags dykk i inn i strukturen av disse bitmap-filer.

151
00:10:42,400 --> 00:10:48,130
Vi gikk over disse litt i foredrag, men la oss se nærmere på dem litt mer.

152
00:10:48,130 --> 00:10:51,740
Punktgrafikk er egentlig bare et arrangement av bytes

153
00:10:51,740 --> 00:10:55,790
hvor vi har angitt som bytes mener det.

154
00:10:55,790 --> 00:11:00,540
Så her er typen som et kart over punktgrafikkbildet

155
00:11:00,540 --> 00:11:08,550
sier at det starter med noen header filer, starter med litt informasjon der.

156
00:11:08,550 --> 00:11:16,540
Du ser at på ca byte nummer 14 størrelsen er angitt av punktgrafikkbildet,

157
00:11:16,540 --> 00:11:18,520
og det fortsetter.

158
00:11:18,520 --> 00:11:23,810
Men så hva vi virkelig er interessert i her er i ferd rundt byte nummer 54.

159
00:11:23,810 --> 00:11:26,060
Vi har disse RGB tremannsrom.

160
00:11:26,060 --> 00:11:30,760
Hva som kommer til å gjøre er å inneholde de faktiske piksler, fargeverdiene.

161
00:11:30,760 --> 00:11:35,950
Alt over det i overskriften er litt informasjon

162
00:11:35,950 --> 00:11:41,240
tilsvarende bildestørrelsen, bredden av bildet, og høyden.

163
00:11:41,240 --> 00:11:44,930
Når vi går inn i polstring senere, vil vi se hvorfor størrelsen på bildet

164
00:11:44,930 --> 00:11:48,670
kan være annerledes enn bredden eller høyden.

165
00:11:48,670 --> 00:11:54,240
Så da å representere disse - disse punktgrafikkbilder er sekvenser av bytes -

166
00:11:54,240 --> 00:11:59,370
hva vi kunne gjøre er å si greit, jeg kommer til å huske at på 14-indeksen,

167
00:11:59,370 --> 00:12:03,380
det er der størrelsen er, for eksempel, men i stedet hva vi skal gjøre for å gjøre dette enklere

168
00:12:03,380 --> 00:12:06,020
er kapsle den i en struct.

169
00:12:06,020 --> 00:12:08,880
Og så har vi to structs gjort for oss, en BITMAPFILEHEADER

170
00:12:08,880 --> 00:12:10,440
og en BITMAPINFOHEADER,

171
00:12:10,440 --> 00:12:14,840
og så når vi leser i til denne filen, som standard det kommer til å gå i orden,

172
00:12:14,840 --> 00:12:22,360
og så for det er også kommer til å fylle inn variabler som biWidth og biSize.

173
00:12:25,270 --> 00:12:31,230
Og så til slutt, hver piksel representert med tre byte.

174
00:12:31,230 --> 00:12:35,500
Den første er mengden av blått i pixel, den andre er mengden av grønt,

175
00:12:35,500 --> 00:12:41,120
og til slutt, mengden av rødt, hvor 0 er egentlig ingen blå eller ingen grønne eller ingen rød

176
00:12:41,120 --> 00:12:43,720
og deretter ff er den maksimale verdien.

177
00:12:43,720 --> 00:12:46,800
Dette er heksadesimale verdier.

178
00:12:46,800 --> 00:12:53,870
Så hvis vi har FF0000, så det tilsvarer den maksimale mengden av blått

179
00:12:53,870 --> 00:12:58,890
og deretter ingen grønn og ingen røde, så da det ville gi oss en blå pixel.

180
00:12:58,890 --> 00:13:04,190
Så hvis vi har ff oss alle over hele linja, så det betyr at vi har en hvit piksel.

181
00:13:04,190 --> 00:13:11,370
Dette er slags motsatt typisk når vi sier RGB. Det som faktisk skjer BGR.

182
00:13:12,750 --> 00:13:18,990
>> Så hvis vi faktisk se på et eksempel på et punktgrafikkbilde - la meg trekke en opp her.

183
00:13:31,560 --> 00:13:33,830
Det er litt for liten.

184
00:13:39,890 --> 00:13:47,840
Jeg zoomet inn, og vi kan se det er kornete. Det ser ut som blokker av farge.

185
00:13:47,840 --> 00:13:50,110
Du har hvite blokker og deretter rødt blokker.

186
00:13:50,110 --> 00:13:53,700
Hvis du spiller i Microsoft Paint, for eksempel, kan du gjøre noe sånt

187
00:13:53,700 --> 00:13:58,960
ved utgangspunktet bare male noen kvadrater i en bestemt rekkefølge.

188
00:13:58,960 --> 00:14:08,060
Så hva dette betyr i bitmap er som følger.

189
00:14:08,060 --> 00:14:15,710
Her har vi første hvite piksler, at alle 6 er f-tallet, og da har vi røde piksler,

190
00:14:15,710 --> 00:14:19,910
angitt med 0000FF.

191
00:14:19,910 --> 00:14:27,940
Og så sekvensen av byte som vi har indikerer hvordan punktgrafikkbildet kommer til å se.

192
00:14:27,940 --> 00:14:32,230
Så det jeg har gjort her er bare skrevet ut alle disse byte og deretter farget i rødt

193
00:14:32,230 --> 00:14:37,550
slik at du kan slags se, hvis du myse litt, hvordan den slags indikerer en smiley ansikt.

194
00:14:40,180 --> 00:14:46,390
>> Den måten som bitmap bilder arbeid er jeg ser det i utgangspunktet som et rutenett.

195
00:14:46,390 --> 00:14:54,940
Og så ved standard har hver rad i rutenettet for å være et multiplum av 4 byte.

196
00:15:00,520 --> 00:15:07,060
Hvis vi ser på et punktgrafikkbilde, du fyller hver verdi.

197
00:15:07,060 --> 00:15:17,370
For eksempel kan du ha en rød her, en grønn her, en blå her,

198
00:15:17,370 --> 00:15:24,950
men du må sørge for at bildet er fylt med et multiplum av fire byte.

199
00:15:24,950 --> 00:15:32,200
Så hvis jeg vil at min bilde for å være tre blokker bred, så jeg måtte sette en tom verdi

200
00:15:32,200 --> 00:15:35,640
i den siste til å gjøre det til en multippel på fire.

201
00:15:35,640 --> 00:15:39,530
Så da ville jeg legge inn noe som vi kaller polstring.

202
00:15:39,530 --> 00:15:43,750
Jeg skal bare indikere at det med en x.

203
00:15:44,920 --> 00:15:54,160
Nå sier vi ønsker et bilde som er 7 piksler lang, for eksempel.

204
00:15:54,160 --> 00:15:59,550
Vi har 1, 2, 3, 4, 5, 6, 7,

205
00:16:04,750 --> 00:16:07,000
og alt dette er fylt i med farge.

206
00:16:07,000 --> 00:16:10,620
Den måten som punktgrafikkbilder fungere er at vi trenger en åttende.

207
00:16:10,620 --> 00:16:12,460
Akkurat nå har vi 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
Vi trenger 8 plasser for punktgrafikkbildet å lese riktig.

209
00:16:19,360 --> 00:16:25,600
Så hva vi har å gjøre er å legge inn bare en bit av padding

210
00:16:25,600 --> 00:16:29,430
å sørge for at alle de bredder er ensartet

211
00:16:29,430 --> 00:16:34,260
og at alle de bredder er et multiplum av 4.

212
00:16:42,110 --> 00:16:47,310
Og så jeg tidligere indikert, utfylling som en x eller en snirklete linje,

213
00:16:47,310 --> 00:16:53,880
men i selve punktgrafikkbilder padding er angitt med en heksadesimal 0.

214
00:16:53,880 --> 00:16:57,340
Så det ville være et enkelt tegn, 0.

215
00:16:58,980 --> 00:17:06,329
Hva som kan komme til nytte er xxd kommandoen.

216
00:17:06,329 --> 00:17:11,220
Hva den gjør er faktisk viser deg, liker ligner på hva jeg gjorde før med smiley

217
00:17:11,220 --> 00:17:15,630
når jeg faktisk skrevet ut hva hver farge ville være for piksel

218
00:17:15,630 --> 00:17:21,800
og deretter fargekodet det, når du kjører xxd med følgende kommandoer,

219
00:17:21,800 --> 00:17:28,670
så vil det faktisk skrive ut hva fargene er for de piksler.

220
00:17:28,670 --> 00:17:33,810
Hva du trenger å gjøre er over her jeg viser, i likhet med-s 54

221
00:17:33,810 --> 00:17:36,530
sier at jeg kommer til å starte på den 54. byte

222
00:17:36,530 --> 00:17:40,820
fordi før det, husk hvis vi ser tilbake til kart over punktgrafikk,

223
00:17:40,820 --> 00:17:42,690
det er alt topp informasjon og sånt.

224
00:17:42,690 --> 00:17:46,280
Men hva vi virkelig bryr seg om er de faktiske piksler som indikerer fargen.

225
00:17:46,280 --> 00:17:52,700
Så ved å legge i det flagget,-s 54, så vi er i stand til å se fargeverdiene.

226
00:17:52,700 --> 00:17:56,020
Og ikke bekymre deg om de kompliserte flagg og sånt.

227
00:17:56,020 --> 00:18:05,020
I oppgavesettet spec, vil du ha instruksjoner om hvordan du bruker xxd å vise piksler.

228
00:18:07,070 --> 00:18:15,590
Så hvis du ser her, den slags ser ut som en grønn boks, denne lille tingen.

229
00:18:15,590 --> 00:18:23,610
Jeg har fargekodet den 00FF00 som i utgangspunktet si ingen blå, mye grønt, og ingen røde.

230
00:18:23,610 --> 00:18:26,370
Slik som tilsvarer til grønt.

231
00:18:26,370 --> 00:18:31,920
Som du ser her, ser vi en grønn firkant.

232
00:18:31,920 --> 00:18:36,660
Denne grønne rektangelet er bare 3 piksler bred, så da hva vi har å gjøre

233
00:18:36,660 --> 00:18:44,350
å sørge for at bildet er et multiplum av fire brede er å legge inn ekstra polstring.

234
00:18:44,350 --> 00:18:49,460
Og så da det er hvordan du ser disse 0s her.

235
00:18:49,460 --> 00:18:54,510
Dette vil faktisk være et resultat av din Resize pset,

236
00:18:54,510 --> 00:19:01,350
hovedsak tar den lille bitmap og deretter forstørrer det med 4.

237
00:19:01,350 --> 00:19:09,380
Og så det vi ser er at faktisk dette bildet er 12 piksler bred, men 12 er et multiplum av 4,

238
00:19:09,380 --> 00:19:12,940
og slik at vi faktisk ikke se noen 0s på slutten fordi vi ikke trenger å legge til

239
00:19:12,940 --> 00:19:19,070
fordi det er fullt polstret. Det har ikke noe mer plass.

240
00:19:20,720 --> 00:19:23,470
>> Okay. Eventuelle spørsmål om utfylling?

241
00:19:25,150 --> 00:19:27,460
Okay. Cool.

242
00:19:27,460 --> 00:19:32,520
>> Som jeg nevnte tidligere, de punktgrafikk er bare en sekvens av bytes.

243
00:19:32,520 --> 00:19:39,170
Og så det vi har er stedet for å måtte holde styr på nøyaktig hvilke antall byte

244
00:19:39,170 --> 00:19:47,050
svarer til en bestemt element, vi faktisk har skapt en struct å representere det.

245
00:19:47,050 --> 00:19:50,930
Så det vi har er en RGBTRIPLE struct.

246
00:19:50,930 --> 00:19:54,590
Når du har en forekomst av et RGB-trippel,

247
00:19:54,590 --> 00:20:00,970
fordi dette er en type definere struct, så kan du få tilgang til rgbtBlue variabel,

248
00:20:00,970 --> 00:20:09,520
likeledes de grønne og røde variabler, som vil indikere hvor mye blått, grønt og rødt,

249
00:20:09,520 --> 00:20:11,580
henholdsvis, har du.

250
00:20:11,580 --> 00:20:16,800
>> Så hvis vi har den blå variabel satt til 0, den grønne settet til ff,

251
00:20:16,800 --> 00:20:22,060
som er den maksimale verdien du kan ha, og deretter det røde variabelen satt til 0,

252
00:20:22,060 --> 00:20:27,870
så hvilken farge ville denne spesielle RGB triple representere? >> [Student] Green.

253
00:20:27,870 --> 00:20:29,150
Green. Akkurat.

254
00:20:29,150 --> 00:20:34,480
Det kommer til å være nyttig å vite at når du har en forekomst av et RGB-trippel,

255
00:20:34,480 --> 00:20:41,340
du kan faktisk få tilgang mengden farge - blå, grønn og rød - separat.

256
00:20:43,350 --> 00:20:54,900
>> Nå som vi har snakket om strukturen av det, la oss ta en titt på BMP-filen.

257
00:20:54,900 --> 00:20:57,870
Dette er structs gjort for deg.

258
00:20:57,870 --> 00:21:01,820
Her har vi en BITMAPFILEHEADER struct.

259
00:21:01,820 --> 00:21:07,610
Av interesse er størrelsen.

260
00:21:07,610 --> 00:21:12,660
Senere har vi info header, som har noen flere ting som er interessant for oss,

261
00:21:12,660 --> 00:21:15,480
nemlig størrelsen, bredden og høyden.

262
00:21:15,480 --> 00:21:19,170
Som vi vil gå inn senere, når du leser i til filen,

263
00:21:19,170 --> 00:21:25,500
det står automatisk i fordi vi har satt for å være den samme.

264
00:21:25,500 --> 00:21:31,990
Så biSize vil inneholde de riktige bytes som tilsvarer den faktiske størrelsen på bildet.

265
00:21:34,700 --> 00:21:40,500
Og så her, til slutt, som vi har snakket om, har vi RGBTRIPLE typedef struct.

266
00:21:40,500 --> 00:21:46,840
Vi har en rgbtBlue, Grønn og Rød knyttet til den.

267
00:21:48,210 --> 00:21:49,340
>> Flott. Okay.

268
00:21:49,340 --> 00:21:56,360
Nå som vi forstår punktgrafikk litt, forstår at vi har en filhodet

269
00:21:56,360 --> 00:22:00,790
og en info header forbundet med det, og så etter det, har vi interessante ting

270
00:22:00,790 --> 00:22:05,110
av fargene, og disse fargene er representert ved RGBTRIPLE structs,

271
00:22:05,110 --> 00:22:12,710
og de i sin tur har tre verdier som er knyttet til den blå, grønne og røde.

272
00:22:12,710 --> 00:22:17,270
>> Så nå kan vi på en måte tenker på Gjenopprett litt.

273
00:22:17,270 --> 00:22:20,130
Unnskyld. Tenk på whodunit.

274
00:22:20,130 --> 00:22:25,750
Når vi har vår ledetråd fil, så hva vi ønsker å gjøre er å lese på den piksel for piksel

275
00:22:25,750 --> 00:22:33,860
og deretter noe endre disse piksler, slik at vi kan sende det til et lesbart format.

276
00:22:33,860 --> 00:22:41,020
Og så å sende det, kommer vi til å skrive piksel for piksel i verdict.bmp filen.

277
00:22:41,020 --> 00:22:45,120
Det er litt for mye å gjøre. Vi skjønner det.

278
00:22:45,120 --> 00:22:49,860
Så det vi har gjort er at vi faktisk har gitt deg med copy.c.

279
00:22:49,860 --> 00:22:57,610
Hva copy.c gjør er bare lager en nøyaktig kopi av et gitt bitmap fil og deretter utganger det.

280
00:22:57,610 --> 00:23:01,900
Så dette åpner allerede filen for deg, leser i piksel for piksel,

281
00:23:01,900 --> 00:23:04,510
og skriver deretter det til en utdatafil.

282
00:23:04,510 --> 00:23:07,080
>> La oss ta en titt på det.

283
00:23:13,390 --> 00:23:18,290
Dette er å sikre riktig bruk,

284
00:23:18,290 --> 00:23:22,640
får filnavnene her.

285
00:23:22,640 --> 00:23:29,940
Hva dette er det setter inndatafilen å være hva vi har gått på i det infile her,

286
00:23:29,940 --> 00:23:34,750
som er vår andre kommandolinje-argument.

287
00:23:34,750 --> 00:23:37,640
Sjekker å sørge for at vi kan åpne filen.

288
00:23:38,960 --> 00:23:44,860
Sjekker å sikre at vi kan lage en ny utfil her.

289
00:23:45,630 --> 00:23:53,270
Så hva dette gjør her, det bare starter utgangspunktet leser inn til bitmap fil fra begynnelsen.

290
00:23:53,270 --> 00:23:56,700
Begynnelsen, som vi vet, inneholder BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
og så de sekvenser av bits vil direkte fylle ut BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Så det vi har her sier at BITMAPFILEHEADER bf -

293
00:24:07,940 --> 00:24:13,150
det er vår nye variabel av typen BITMAPFILEHEADER -

294
00:24:13,150 --> 00:24:22,560
vi kommer til å sette inne bf hva vi leser fra i pekeren, som er vår infile.

295
00:24:22,560 --> 00:24:23,970
Hvor mye leser vi?

296
00:24:23,970 --> 00:24:32,160
Vi leser i hvor mange byte vi trenger å inneholde hele BITMAPFILEHEADER.

297
00:24:32,160 --> 00:24:34,660
Tilsvarende, det er hva vi gjør for info header.

298
00:24:34,660 --> 00:24:39,010
Så vi fortsetter langs fil vår i innfil,

299
00:24:39,010 --> 00:24:44,360
og vi leser disse bits og bytes, og vi koble dem direkte i

300
00:24:44,360 --> 00:24:47,880
i disse tilfeller av de variablene som vi gjør.

301
00:24:49,370 --> 00:24:53,800
Her er vi bare å sørge for at bitmap er punktgrafikk.

302
00:24:57,670 --> 00:25:01,030
>> Nå har vi en utfil, ikke sant?

303
00:25:01,030 --> 00:25:04,420
Slik som det står når vi skaper det, er det egentlig tom.

304
00:25:04,420 --> 00:25:07,710
Så vi må i utgangspunktet lage en ny bitmap fra bunnen av.

305
00:25:07,710 --> 00:25:12,280
Hva vi gjør er at vi må sørge for at vi kopierer i filhodet

306
00:25:12,280 --> 00:25:16,850
og info header akkurat som infile har.

307
00:25:16,850 --> 00:25:22,850
Hva vi gjør er vi skriver - og husk at bf er variabelen

308
00:25:22,850 --> 00:25:29,300
av typen BITMAPFILEHEADER, så det vi gjør er vi bare bruke dette innholdet

309
00:25:29,300 --> 00:25:34,980
å skrive inn i utfil.

310
00:25:36,550 --> 00:25:38,510
Her husker vi snakket om padding,

311
00:25:38,510 --> 00:25:47,820
hvordan det er viktig å sørge for at mengden av piksler som vi har er et multiplum av fire.

312
00:25:47,820 --> 00:25:52,790
Dette er en ganske nyttig formel for å beregne hvor mye polstring du har

313
00:25:52,790 --> 00:25:57,670
gitt bredden av filen.

314
00:25:57,670 --> 00:26:04,120
Jeg ønsker dere å huske at i copy.c har vi en formel for beregning padding.

315
00:26:04,120 --> 00:26:07,970
Ok? Så alle husker det. Flott.

316
00:26:07,970 --> 00:26:14,050
Så hva copy.c gjør neste er det gjentar over alle de scanlines.

317
00:26:14,050 --> 00:26:23,730
Det går gjennom radene først og deretter lagrer hver trippel at den leser

318
00:26:23,730 --> 00:26:26,920
og skriver den med til den utfil.

319
00:26:26,920 --> 00:26:33,120
Så da her vi leser bare én RGB trippel gangen

320
00:26:33,120 --> 00:26:39,860
og deretter sette det samme trippel i utfil.

321
00:26:41,120 --> 00:26:48,340
Den vanskelige delen er at padding er ikke en RGB trippel,

322
00:26:48,340 --> 00:26:55,200
og så vi kan ikke bare lese det padding mengde RGB tremannsrom.

323
00:26:55,200 --> 00:27:01,460
Hva vi trenger å gjøre er faktisk bare flytte vår fil indikator, flytte vår markøren,

324
00:27:01,460 --> 00:27:06,840
å slags hoppe over all utfylling slik at vi er på neste rad.

325
00:27:06,840 --> 00:27:12,990
Og så hva dette gjør er å kopiere viser deg hvordan du kanskje vil legge til padding.

326
00:27:12,990 --> 00:27:14,990
Så vi har beregnet hvor mye polstring vi trenger,

327
00:27:14,990 --> 00:27:18,220
så det betyr at vi trenger padding antall 0s.

328
00:27:18,220 --> 00:27:24,510
Hva dette er en for løkke som setter polstring antall 0s inn utfil vår.

329
00:27:24,510 --> 00:27:31,170
Og så til slutt, lukker du begge filene. Du lukker infile samt utfil.

330
00:27:31,170 --> 00:27:34,870
>> Så det er slik copy.c fungerer,

331
00:27:34,870 --> 00:27:37,430
og det kommer til å være ganske nyttig.

332
00:27:39,720 --> 00:27:43,750
I stedet for bare faktisk direkte kopiere og lime det

333
00:27:43,750 --> 00:27:46,800
eller bare se på det og skrive inn hva du vil,

334
00:27:46,800 --> 00:27:49,440
kanskje du bare ønsker å utføre denne kommandoen i terminalen,

335
00:27:49,440 --> 00:27:54,520
cp copy.c whodunit.c, noe som vil skape en ny fil, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
som inneholder nøyaktig samme innhold som kopi gjør.

337
00:27:58,330 --> 00:28:03,880
Så hva vi kan gjøre er å bruke den som et rammeverk ved å bygge og redigere

338
00:28:03,880 --> 00:28:06,900
for vår whodunit fil.

339
00:28:08,500 --> 00:28:14,670
>> Dette er vår to-dos å gjøre for whodunit, men hva copy.c gjør

340
00:28:14,670 --> 00:28:16,730
er tar faktisk vare på de fleste av dem for oss.

341
00:28:16,730 --> 00:28:21,900
Så alt vi trenger å gjøre neste er å endre bildepunktene som nødvendig

342
00:28:21,900 --> 00:28:25,920
å faktisk gjøre filen lesbar.

343
00:28:25,920 --> 00:28:32,960
Husk at for en gitt piksel trippel, så for en gitt variabel av typen RGBTRIPLE,

344
00:28:32,960 --> 00:28:35,990
du kan få tilgang til blå, grønn og rød verdier.

345
00:28:35,990 --> 00:28:38,670
Det kommer til å komme godt fordi hvis du kan få tilgang til dem,

346
00:28:38,670 --> 00:28:41,770
det betyr at du også kan kontrollere dem,

347
00:28:41,770 --> 00:28:45,430
og det betyr at du også kan endre dem.

348
00:28:45,430 --> 00:28:49,430
>> Så når vi gikk tilbake til vår rød forstørrelsesglass eksempel

349
00:28:49,430 --> 00:28:53,390
I utgangspunktet var det fungerte som en slags filter for oss.

350
00:28:53,390 --> 00:28:58,160
Så det vi ønsker å gjøre er vi ønsker å filtrere alle tripler som kommer i.

351
00:28:58,160 --> 00:29:01,240
Det finnes flere forskjellige måter å gjøre dette.

352
00:29:01,240 --> 00:29:07,100
I utgangspunktet kan du ha uansett hva slags filter du ønsker.

353
00:29:07,100 --> 00:29:09,890
Kanskje du ønsker å endre alle røde piksler

354
00:29:09,890 --> 00:29:13,570
eller kanskje du ønsker å endre en annen farge pixel til en annen farge.

355
00:29:13,570 --> 00:29:15,400
Det er opp til deg.

356
00:29:15,400 --> 00:29:19,580
Husk at du kan sjekke hvilken farge piksel er

357
00:29:19,580 --> 00:29:23,000
og deretter kan du også endre det som du går gjennom.

358
00:29:24,410 --> 00:29:26,420
>> Okay. Så det er whodunit.

359
00:29:26,420 --> 00:29:32,760
Når du kjører whodunit, vet du hvem som den skyldige av kriminalitet var.

360
00:29:32,760 --> 00:29:35,540
>> Nå skal vi gå til Resize.

361
00:29:35,540 --> 00:29:37,990
Vi kommer til å fortsatt være å håndtere punktgrafikk.

362
00:29:37,990 --> 00:29:40,750
Hva vi kommer til å gjøre er at vi kommer til å ha en inngang bitmap

363
00:29:40,750 --> 00:29:45,890
og vi kommer til å passere i en rekke, og deretter få en utfil bitmap

364
00:29:45,890 --> 00:29:51,380
hvor det er utgangspunktet vårt infile skalert med n.

365
00:29:54,670 --> 00:30:01,450
Si min filen var bare én piksel store.

366
00:30:01,450 --> 00:30:09,100
Så hvis min n var 3, skalering med 3, så ville jeg gjenta at pixel n antall ganger,

367
00:30:09,100 --> 00:30:14,410
så 3 ganger, og deretter også skalere det ned 3 ganger også.

368
00:30:14,410 --> 00:30:17,840
Så du ser jeg skalere den vertikalt og horisontalt.

369
00:30:17,840 --> 00:30:19,680
>> Og så er her et eksempel.

370
00:30:19,680 --> 00:30:27,590
Hvis du har n = 2, ser du at den første blå pixel det gjentas to ganger

371
00:30:27,590 --> 00:30:30,930
horisontalt samt to ganger vertikalt.

372
00:30:30,930 --> 00:30:38,040
Og da fortsetter, og så har du en direkte skalering av det opprinnelige bildet av to.

373
00:30:40,920 --> 00:30:47,600
>> Så hvis vi skulle detalj pseudokode for dette, ønsker vi å åpne filen.

374
00:30:47,600 --> 00:30:49,880
Og så vet at hvis vi går tilbake hit,

375
00:30:49,880 --> 00:30:54,540
ser vi at bredden for utfil kommer til å være annerledes enn bredden for infile.

376
00:30:54,540 --> 00:30:56,130
Hva betyr det?

377
00:30:56,130 --> 00:31:01,230
Det betyr at vår hodeinformasjon kommer til å endre.

378
00:31:01,230 --> 00:31:03,790
Og så hva vi ønsker å gjøre er å oppdatere header info,

379
00:31:03,790 --> 00:31:11,820
vel vitende om at når vi leser i filene hvis du opererer på copy.c rammeverk,

380
00:31:11,820 --> 00:31:17,570
vi allerede har en variabel som indikerer hva størrelsen er og ting som det.

381
00:31:17,570 --> 00:31:24,060
Så når du har det, hva du kanskje ønsker å gjøre er å endre de aktuelle variabler.

382
00:31:24,060 --> 00:31:29,380
Husk, hvis du har en struct, hvordan du får tilgang til variabler innenfor det.

383
00:31:29,380 --> 00:31:32,080
Du bruker dot operatør, ikke sant?

384
00:31:32,080 --> 00:31:36,420
Så da bruker det, vet du at du må endre overskriften info.

385
00:31:36,480 --> 00:31:41,030
Så her er bare en liste over de faktiske elementer som kommer til å være i endring i filen.

386
00:31:41,030 --> 00:31:45,180
Filstørrelsen skal være i endring, bildet, samt bredden og høyden.

387
00:31:45,180 --> 00:31:50,080
Så da går tilbake til kart over punktgrafikk,

388
00:31:50,080 --> 00:31:57,730
se på om det er filhodet eller info header som inneholder denne informasjonen

389
00:31:57,730 --> 00:32:00,920
og deretter endre etter behov.

390
00:32:05,010 --> 00:32:12,470
Igjen, sier cp copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
Det betyr at resize.c nå inneholder alt som er inneholdt i kopi

392
00:32:19,270 --> 00:32:24,490
fordi kopien gir oss en måte å lese på hver enkelt scanline piksel for piksel.

393
00:32:24,490 --> 00:32:29,860
Bortsett fra nå, i stedet for bare å endre verdiene som vi gjorde i whodunit,

394
00:32:29,860 --> 00:32:37,980
hva vi ønsker å gjøre er vi ønsker å skrive i flere piksler

395
00:32:37,980 --> 00:32:43,580
så lenge vår n er større enn 1.

396
00:32:43,580 --> 00:32:47,110
>> Så hva vi ønsker å gjøre er vi ønsker å strekke det horisontalt n,

397
00:32:47,110 --> 00:32:50,490
samt strekke det vertikalt av n.

398
00:32:50,490 --> 00:32:52,710
Hvordan kan vi gjøre dette?

399
00:32:52,710 --> 00:32:56,890
Si din n er 2 og du har dette gitt infile.

400
00:32:56,890 --> 00:32:58,730
Markøren kommer til å starte på den første,

401
00:32:58,730 --> 00:33:03,530
og hva du vil gjøre hvis n er 2, vil du skrive ut i 2 av disse.

402
00:33:03,530 --> 00:33:05,490
Så du skrive ut i to av disse.

403
00:33:05,490 --> 00:33:10,830
Deretter markøren kommer til å gå til neste piksel, som er den røde,

404
00:33:10,830 --> 00:33:18,400
og det kommer til å skrive ut to av de røde, tilføye det på hva det har gjort før.

405
00:33:18,400 --> 00:33:26,280
Deretter markøren vil flytte til neste piksel og trekke i 2 av disse.

406
00:33:26,280 --> 00:33:37,180
Hvis du ser tilbake til copy.c rammeverk, hva dette betyr her

407
00:33:37,180 --> 00:33:42,830
er det skaper en ny forekomst av et RGB-trippel, en ny variabel kalt trippel.

408
00:33:42,830 --> 00:33:50,500
Og her når den leser inn i det, leser det fra infile en RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
og lagrer den på innsiden av det trippel variabel.

410
00:33:53,470 --> 00:33:57,590
Så da du faktisk har en variabel som representerer den aktuelle piksel.

411
00:33:57,590 --> 00:34:05,290
Så når du skriver, hva du kanskje ønsker å gjøre er encase fwrite setningen i en for loop

412
00:34:05,290 --> 00:34:11,080
som skriver det inn utfil din så mange ganger som nødvendig.

413
00:34:17,449 --> 00:34:20,100
Det er enkelt nok.

414
00:34:20,200 --> 00:34:27,590
Bare utgangspunktet gjenta skriveprosessen n antall ganger for å skalere den horisontalt.

415
00:34:27,590 --> 00:34:32,969
>> Men da må vi huske at vår padding kommer til å endre seg.

416
00:34:47,350 --> 00:34:53,020
Tidligere si at vi hadde noe av lengde 3.

417
00:34:53,020 --> 00:35:00,130
Da ville vi bare legge i hvor mye polstring? Bare en mer for å gjøre det til en multippel av 4.

418
00:35:00,130 --> 00:35:10,480
Men sier at vi skalere dette bestemt bilde av n = 2.

419
00:35:10,480 --> 00:35:16,300
Så da hvor mange blå piksler ville vi ha til slutt? Vi ville ha seks.

420
00:35:16,300 --> 00:35:21,470
1, 2, 3, 4, 5, 6. OK.

421
00:35:21,470 --> 00:35:26,580
6 er ikke et multiplum av 4. Hva er det nærmeste multiplum av 4? Det kommer til å være 8.

422
00:35:26,580 --> 00:35:33,200
Så vi faktisk kommer til å ha to tegn av padding der.

423
00:35:33,200 --> 00:35:38,720
>> Husker noen hvis vi har en formel for å beregne padding

424
00:35:38,720 --> 00:35:41,350
og hvor det kan være?

425
00:35:41,350 --> 00:35:45,160
[Uhørlig student respons] >> Ja, copy.c. Høyre.

426
00:35:45,160 --> 00:35:49,800
Det er en formel i copy.c å beregne hvor mye polstring du har

427
00:35:49,800 --> 00:35:53,810
gitt en bestemt bredde av det punktgrafikkbilde.

428
00:35:53,810 --> 00:36:02,950
Så da det kommer til å være nyttig når du trenger å legge i en viss padding

429
00:36:02,950 --> 00:36:06,160
å faktisk finne ut hvor mye polstring du trenger å legge til.

430
00:36:10,820 --> 00:36:15,850
Men ett notat, skjønt, er at du vil være sikker på at du bruker riktig størrelse.

431
00:36:15,850 --> 00:36:21,410
Bare vær forsiktig fordi du i utgangspunktet skal gjøre med to punktgrafikkbilder.

432
00:36:21,410 --> 00:36:23,410
Du ønsker å være sikker på at du bruker den rette.

433
00:36:23,410 --> 00:36:26,820
Når du beregner padding for utfil, du vil bruke bredden på utfil

434
00:36:26,820 --> 00:36:29,860
og ikke bredden av den forrige.

435
00:36:29,860 --> 00:36:37,240
>> Flott. Den slags tar seg av strekke en hel punktgrafikkbilde horisontalt.

436
00:36:37,240 --> 00:36:41,290
Men hva vi ønsker å gjøre er å strekke det faktisk vertikalt også.

437
00:36:41,290 --> 00:36:48,760
Dette kommer til å være litt mer komplisert fordi når vi er ferdig med å kopiere en rad

438
00:36:48,760 --> 00:36:51,580
og skriver at rad, vår markøren kommer til å være på slutten.

439
00:36:51,580 --> 00:36:56,210
Så hvis vi leser igjen, så det er bare kommer til å lese på neste linje.

440
00:36:56,210 --> 00:37:03,660
Så det vi ønsker å gjøre er slags finne en måte å kopiere disse radene igjen

441
00:37:03,660 --> 00:37:12,500
eller bare slags ta raden og deretter skrive det igjen.

442
00:37:14,380 --> 00:37:17,940
Som jeg slags antydet, er det flere forskjellige måter å gjøre dette.

443
00:37:17,940 --> 00:37:23,040
Hva du kan gjøre er som du går gjennom og lese gjennom den aktuelle scanline

444
00:37:23,040 --> 00:37:28,560
og endre det som er nødvendig, deretter type butikk alle disse pikslene i en matrise.

445
00:37:28,560 --> 00:37:36,350
Senere på deg vet at du må skrive ut denne matrisen igjen,

446
00:37:36,350 --> 00:37:39,830
og så kan du bare bruke denne matrisen til å gjøre det.

447
00:37:39,830 --> 00:37:44,500
En annen måte å gjøre det er at du kan kopiere én rad ned,

448
00:37:44,500 --> 00:37:47,950
forstår at du trenger å kopiere det igjen, så faktisk flytte markøren,

449
00:37:47,950 --> 00:37:50,950
og det kommer til å bruke den metoden fseek.

450
00:37:50,950 --> 00:37:56,410
Du kan flytte markøren helt tilbake og gjenta kopieringen på nytt.

451
00:37:56,410 --> 00:38:03,960
>> Så hvis vår skalering nummer er n, så hvor mange ganger må vi gå tilbake

452
00:38:03,960 --> 00:38:10,500
og skrive en linje? >> [Student] n - 1. >> Ja, perfekt. n - 1.

453
00:38:10,500 --> 00:38:14,390
Vi har gjort det en gang allerede, så da vi ønsker å gjenta kommer tilbake prosessen

454
00:38:14,390 --> 00:38:17,460
n - 1 antall ganger.

455
00:38:22,730 --> 00:38:25,860
Okay. Så der har du din resize funksjon.

456
00:38:25,860 --> 00:38:34,360
>> Nå kan vi få til en veldig morsom del, min favoritt pset, som er friske.

457
00:38:34,360 --> 00:38:39,580
I stedet for punktgrafikk, denne gangen vi har å gjøre med JPEG.

458
00:38:39,580 --> 00:38:43,370
Vi faktisk ikke får en fil bare av JPEG,

459
00:38:43,370 --> 00:38:46,600
vi får i utgangspunktet en rå minnekort format.

460
00:38:46,600 --> 00:38:51,790
Og så dette inneholder litt av info og søppel verdier i begynnelsen,

461
00:38:51,790 --> 00:38:57,240
og det begynner og den har en haug med JPEG-filer.

462
00:38:57,240 --> 00:39:03,430
Men vi ga et kort hvor vi har slettet bildene;

463
00:39:03,430 --> 00:39:08,300
hovedsak har vi glemt hvor bildene ligger innenfor kort.

464
00:39:08,300 --> 00:39:12,770
Så da er vår oppgave i Recover er å gå gjennom dette kortet format

465
00:39:12,770 --> 00:39:16,500
og finne de bildene igjen.

466
00:39:16,500 --> 00:39:23,990
>> Heldigvis, er strukturen i JPEG-filer og kortet filen litt nyttig.

467
00:39:23,990 --> 00:39:28,850
Det kunne definitivt ha vært litt mer komplisert hvis det ikke var i dette formatet.

468
00:39:28,850 --> 00:39:40,160
Hver JPEG-fil starter faktisk med to mulige sekvenser, som er nevnt ovenfor.

469
00:39:40,160 --> 00:39:42,970
I utgangspunktet, når du har en ny JPEG-fil,

470
00:39:42,970 --> 00:39:52,720
den starter med enten sekvensen ffd8 ffe0 eller den andre, ffd8 ffe1.

471
00:39:52,720 --> 00:39:59,530
En annen nyttig ting å vite er at JPEG lagres contiguously.

472
00:39:59,530 --> 00:40:03,380
Så når en JPEG-fil slutter, den andre starter.

473
00:40:03,380 --> 00:40:07,070
Så det er ikke noen form for i-mellom verdiene der.

474
00:40:07,070 --> 00:40:15,510
Når du treffer starten på en JPEG, hvis du allerede har lest en JPEG,

475
00:40:15,510 --> 00:40:21,800
du vet at du har truffet på slutten av forrige og begynnelsen av neste.

476
00:40:21,800 --> 00:40:25,890
>> Å slags visualisere dette, gjorde jeg en skjematisk.

477
00:40:25,890 --> 00:40:36,910
En annen ting om JPEG er at vi kan lese dem i sekvenser på 512 bytes om gangen,

478
00:40:36,910 --> 00:40:39,380
tilsvarende med begynnelsen av kortet.

479
00:40:39,380 --> 00:40:43,370
Vi trenger ikke å være sjekker hver eneste byte fordi det ville suge.

480
00:40:43,370 --> 00:40:48,200
Så i stedet, hva vi kan gjøre er faktisk bare lese i 512 bytes om gangen

481
00:40:48,200 --> 00:40:54,700
og da, i stedet for å sjekke inn mellom de i de bitte små skiver,

482
00:40:54,700 --> 00:40:58,640
Vi kan bare sjekke begynnelsen av 512 byte.

483
00:40:58,640 --> 00:41:02,570
Hovedsak, i dette bildet, det du ser er i begynnelsen av kortet,

484
00:41:02,570 --> 00:41:08,700
du har verdier som ikke er virkelig relevant for de faktiske JPEG selv.

485
00:41:08,700 --> 00:41:15,830
Men hva jeg har er en stjerne for å indikere en av de to start sekvenser for en JPEG.

486
00:41:15,830 --> 00:41:19,910
Så når du ser en stjerne, vet du at du har en JPEG-fil.

487
00:41:19,910 --> 00:41:25,030
Og deretter hver JPEG-fil skal være noen flere på 512 bytes

488
00:41:25,030 --> 00:41:27,880
men ikke nødvendigvis det samme flere.

489
00:41:27,880 --> 00:41:32,050
Måten du vet at du har truffet en annen JPEG er hvis du treffer en annen stjerne,

490
00:41:32,050 --> 00:41:39,090
en annen startrekkefølge bytes.

491
00:41:39,090 --> 00:41:43,330
Så hva du har her er at du har den røde JPEG-fil fortsetter til du treffer en stjerne,

492
00:41:43,330 --> 00:41:45,150
som er angitt med en ny farge.

493
00:41:45,150 --> 00:41:48,510
Du fortsetter og du treffer en annen stjerne, du treffer en annen JPEG,

494
00:41:48,510 --> 00:41:50,590
du fortsetter helt til slutten.

495
00:41:50,590 --> 00:41:53,180
Du er på det siste bildet her, den rosa.

496
00:41:53,180 --> 00:41:58,220
Du gå til slutten før du treffer slutten av filen karakter.

497
00:41:58,220 --> 00:42:00,820
Dette kommer til å være veldig nyttig.

498
00:42:00,820 --> 00:42:03,170
>> Noen viktigste takeaways her:

499
00:42:03,170 --> 00:42:06,670
Kortet filen starter ikke med en JPEG,

500
00:42:06,670 --> 00:42:13,350
men når en JPEG starter, blir alle JPEG lagret side om side med hverandre.

501
00:42:17,520 --> 00:42:20,420
>> Noen pseudokode for Recover.

502
00:42:20,420 --> 00:42:22,570
Først, vi kommer til å åpne våre kort fil,

503
00:42:22,570 --> 00:42:27,500
og det kommer til å bruke vår fil I / O-funksjoner.

504
00:42:27,500 --> 00:42:32,430
Vi kommer til å gjenta følgende prosess før vi har nådd slutten av filen.

505
00:42:32,430 --> 00:42:36,450
Vi kommer til å lese 512 bytes om gangen.

506
00:42:36,450 --> 00:42:39,180
Og det jeg sa her er vi kommer til å lagre den i en buffer,

507
00:42:39,180 --> 00:42:46,230
så i utgangspunktet holde på de 512 bytes før vi vet nøyaktig hva de skal gjøre med dem.

508
00:42:46,230 --> 00:42:50,300
Så hva vi ønsker å gjøre er vi ønsker å sjekke om vi har truffet en stjerne eller ikke.

509
00:42:50,300 --> 00:42:57,960
Hvis vi har truffet en stjerne, hvis vi har truffet et av utgangspunktene sekvenser,

510
00:42:57,960 --> 00:42:59,980
da vet vi at vi har truffet en ny JPEG-fil.

511
00:42:59,980 --> 00:43:08,860
Hva vi ønsker å gjøre er vi kommer til å ønske å opprette en ny fil i vår pset4 katalog

512
00:43:08,860 --> 00:43:14,480
å fortsette å gjøre denne filen.

513
00:43:14,480 --> 00:43:18,220
Men også, hvis vi har allerede gjort en JPEG før,

514
00:43:18,220 --> 00:43:25,620
så vi ønsker å avslutte denne filen og skyv den mot pset4 mappe,

515
00:43:25,620 --> 00:43:29,780
der vi vil ha den filen lagret fordi hvis vi ikke angir at vi har endte som JPEG-fil,

516
00:43:29,780 --> 00:43:37,290
så får vi i utgangspunktet har en ubestemt beløp. De JPEG vil aldri ta slutt.

517
00:43:37,290 --> 00:43:40,840
Så vi vil være sikker på at når vi leser i en JPEG-fil og skrive det,

518
00:43:40,840 --> 00:43:46,590
vi ønsker å spesifikt nær at for å åpne neste.

519
00:43:46,590 --> 00:43:48,430
Vi ønsker å sjekke flere ting.

520
00:43:48,430 --> 00:43:52,880
Vi ønsker å sjekke om vi er i starten av en ny JPEG med buffer vår

521
00:43:52,880 --> 00:43:56,780
og også hvis vi allerede har funnet en JPEG før

522
00:43:56,780 --> 00:44:03,930
fordi det vil endre prosessen litt.

523
00:44:03,930 --> 00:44:07,880
Så når du går gjennom hele veien og du treffer slutten av filen,

524
00:44:07,880 --> 00:44:11,570
så hva du ønsker å gjøre er at du ønsker å lukke alle filene som er åpne.

525
00:44:11,570 --> 00:44:14,100
Det vil trolig være den siste JPEG-fil som du har,

526
00:44:14,100 --> 00:44:18,930
samt kort fil som du har hatt befatning med.

527
00:44:21,940 --> 00:44:28,670
>> Den siste hindringen som vi må takle er hvordan du faktisk lage en JPEG-fil

528
00:44:28,670 --> 00:44:31,950
og hvordan du faktisk skyve den til mappen.

529
00:44:33,650 --> 00:44:39,850
Den pset krever at hver JPEG som du finner være i følgende format,

530
00:44:39,850 --> 00:44:43,990
hvor du har nummeret. jpg.

531
00:44:43,990 --> 00:44:50,750
Nummeret, selv om det er 0, kaller vi det 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Når du finner en JPEG i programmet,

533
00:44:55,730 --> 00:44:58,040
du kommer til å gi den navnet i den rekkefølgen det er funnet.

534
00:44:58,040 --> 00:44:59,700
Hva betyr dette?

535
00:44:59,700 --> 00:45:03,530
Vi trenger å slags holde styr på hvor mange vi har funnet

536
00:45:03,530 --> 00:45:08,680
og hva antallet av hver JPEG bør være.

537
00:45:08,680 --> 00:45:13,800
Her skal vi dra nytte av sprintf funksjon.

538
00:45:13,800 --> 00:45:17,480
I likhet med printf, som bare slags utskrifter en verdi ut i terminalen,

539
00:45:17,480 --> 00:45:23,910
sprintf skriver filen ut i mappen.

540
00:45:23,910 --> 00:45:30,870
Og så hva dette ville gjøre hvis jeg hadde sprintf, tittel og deretter strengen der,

541
00:45:30,870 --> 00:45:36,660
det ville skrive ut 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Forutsatt at jeg har lukket filene mine riktig,

543
00:45:41,020 --> 00:45:47,210
som vil inneholde filen som jeg hadde skrevet ut.

544
00:45:47,210 --> 00:45:50,320
Men en ting er at koden som jeg har her

545
00:45:50,320 --> 00:45:53,360
ikke helt tilfredsstiller hva pset krever.

546
00:45:53,360 --> 00:46:02,410
Den pset krever at andre JPEG filen skal hete 002 i stedet for bare to.

547
00:46:02,410 --> 00:46:09,160
Så når du skriver ut navnet, så kanskje kan det være lurt å endre plassholderen litt.

548
00:46:09,160 --> 00:46:18,140
>> Husker noen hvordan vi tillater for ekstra mellomrom når vi ut noe?

549
00:46:18,140 --> 00:46:22,530
Ja. >> [Student] Du setter en 3 mellom prosenttegn og to. >> Ja, perfekt.

550
00:46:22,530 --> 00:46:25,610
Du vil sette en 3 i dette tilfellet fordi vi vil ha plass til tre.

551
00:46:25,610 --> 00:46:32,590
% 3d ville trolig gi deg 002.jpg istedenfor 2.

552
00:46:32,590 --> 00:46:40,120
Det første argumentet i sprintf funksjonen er faktisk en char array,

553
00:46:40,120 --> 00:46:42,520
som vi tidligere kjente som strenger.

554
00:46:42,520 --> 00:46:50,700
De vilje, type mer som en midlertidig lagring, bare lagre den resulterende strengen.

555
00:46:50,700 --> 00:46:54,950
Du vil egentlig ikke håndtere dette, men du må ta det.

556
00:46:54,950 --> 00:47:00,710
>> Vel vitende om at hver filnavnet har nummer, som tar opp tre tegn,

557
00:47:00,710 --> 00:47:06,770
og da. jpg, bør hvor lenge denne tabellen være?

558
00:47:09,070 --> 00:47:14,310
Kaste ut et tall. Hvor mange tegn i tittelen, i navnet?

559
00:47:18,090 --> 00:47:26,320
Så det er 3 hashtags, punktum, jpg. >> [Student] 7. >> 7. Ikke helt.

560
00:47:26,320 --> 00:47:32,000
Vi kommer til å ønske 8 fordi vi ønsker å tillate for null terminator også.

561
00:47:45,340 --> 00:47:49,730
>> Til slutt, bare trekke ut prosessen som du skal gjøre for gjenvinning,

562
00:47:49,730 --> 00:47:55,420
du har noen begynnelse informasjon.

563
00:47:55,420 --> 00:48:02,460
Du fortsetter til du finner starten på en JPEG-fil,

564
00:48:02,460 --> 00:48:07,900
og som kan være enten en av to utgangspunkter sekvenser.

565
00:48:07,900 --> 00:48:12,510
Du holder på å lese. Hver skråstrek her representerer 512 bytes.

566
00:48:12,510 --> 00:48:22,630
Du holder på å lese, holder på å lese før du får en annen startsekvens.

567
00:48:22,630 --> 00:48:29,790
Når du har det, du vil avslutte den aktuelle JPEG - i dette tilfellet er det den røde,

568
00:48:29,790 --> 00:48:31,030
så du ønsker å avslutte det.

569
00:48:31,030 --> 00:48:35,540
Du ønsker å sprintf navnet på det inn i din pset4 mappe,

570
00:48:35,540 --> 00:48:41,580
så du ønsker å åpne en ny JPEG og deretter holde på lesing

571
00:48:41,580 --> 00:48:46,370
til du støter på den neste.

572
00:48:46,370 --> 00:48:49,040
Holder på å lese, holder på å lese,

573
00:48:49,040 --> 00:48:56,290
og så til slutt, til slutt, du kommer til å nå slutten av filen,

574
00:48:56,290 --> 00:49:00,360
og så vil du ønsker å lukke den siste JPEG som du arbeidet med,

575
00:49:00,360 --> 00:49:08,380
sprintf at inn pset4 mappe, og deretter se på alle bildene som du har fått.

576
00:49:08,380 --> 00:49:12,050
Disse bildene er faktisk bilder av CS50 ansatte,

577
00:49:12,050 --> 00:49:16,430
og så dette er hvor bonus morsom del av pset kommer i

578
00:49:16,430 --> 00:49:26,310
er at du konkurrerer i seksjonene dine for å finne de TFS i bildene

579
00:49:26,310 --> 00:49:34,610
og ta bilder med dem for å bevise at du har gjort det pset

580
00:49:34,610 --> 00:49:37,030
og så kan du se hvilke ansatte er på bildene.

581
00:49:37,030 --> 00:49:41,510
Så da kan du ta bilder med personalet. Noen ganger må du jage dem ned.

582
00:49:41,510 --> 00:49:44,680
Sannsynligvis noen av dem vil prøve å løpe vekk fra deg.

583
00:49:44,680 --> 00:49:47,320
Du ta bilder med dem.

584
00:49:47,320 --> 00:49:51,190
Dette er pågående. Det er ikke på grunn av når pset skyldes.

585
00:49:51,190 --> 00:49:53,340
Fristen vil bli annonsert i spec.

586
00:49:53,340 --> 00:49:58,060
Deretter sammen med inndelingen, tar hvilken seksjon de fleste bildene

587
00:49:58,060 --> 00:50:04,430
med de fleste ansatte vil vinne en ganske imponerende premie.

588
00:50:04,430 --> 00:50:08,890
Det er slags insentiv til å få pset4 ferdig så raskt som mulig

589
00:50:08,890 --> 00:50:10,820
fordi da kan du komme ned til virksomheten

590
00:50:10,820 --> 00:50:14,570
jakte ned alle de forskjellige CS50 ansatte.

591
00:50:14,570 --> 00:50:17,500
Det er ikke obligatorisk, skjønt, så når du får bildene,

592
00:50:17,500 --> 00:50:20,310
så er du ferdig med pset4.

593
00:50:20,310 --> 00:50:23,970
>> Og jeg er ferdig med Walkthrough 4, så takk skal du ha for å komme.

594
00:50:23,970 --> 00:50:29,330
Lykke til med Forensics. [Applaus]

595
00:50:29,330 --> 00:50:31,000
[CS50.TV]