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 - Harvarduniversitetet]

3
00:00:05,000 --> 00:00:07,340
[Detta är CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
Okej. Hej, alla, och välkomna till Walkthrough 4.

5
00:00:11,670 --> 00:00:14,270
>> Idag vår pset är kriminalteknik.

6
00:00:14,270 --> 00:00:18,080
Forensics är ett riktigt roligt pset som innebär att hantera bitmappsfiler

7
00:00:18,080 --> 00:00:21,550
att upptäcka som begått ett brott.

8
00:00:21,550 --> 00:00:24,200
Sen ska vi ändra storlek några bitmappsfiler,

9
00:00:24,200 --> 00:00:27,780
då vi också kommer att ta itu med ett riktigt roligt del som kallas Recover,

10
00:00:27,780 --> 00:00:31,160
där vi i grund och botten överlämnade ett minneskort

11
00:00:31,160 --> 00:00:34,350
där någon har oavsiktligt raderade alla sina filer,

12
00:00:34,350 --> 00:00:38,860
och vi är ombedda att återställa dessa filer.

13
00:00:38,860 --> 00:00:42,910
>> Men först, innan vi kommer in i pset, jag verkligen bara vill gratulera alla.

14
00:00:42,910 --> 00:00:45,230
Vi är omkring vid mittpunkten av denna kurs.

15
00:00:45,230 --> 00:00:50,070
Quiz 0 är bakom oss, och vi är på pset4, så i huvudsak är vi halvvägs.

16
00:00:50,070 --> 00:00:55,490
Vi har kommit en lång väg om du ser tillbaka på dina psets, pset0 och pset1,

17
00:00:55,490 --> 00:00:57,300
så gratulera dig själv om det,

18
00:00:57,300 --> 00:01:00,760
och vi kommer att få in några riktigt roliga saker.

19
00:01:00,760 --> 00:01:07,070
>> Så vår verktygslåda för pset, igen, i stället för att köra sudo yum-y uppdateringen

20
00:01:07,070 --> 00:01:13,890
vi kan bara köra update50 om du är på version 17,3 eller högre av apparaten.

21
00:01:13,890 --> 00:01:17,380
Så se till att köra update50 - det är mycket lättare, några mindre tecken -

22
00:01:17,380 --> 00:01:20,640
att se till att du är på den senaste versionen av apparaten.

23
00:01:20,640 --> 00:01:25,410
Speciellt är det viktigt att update50 när vi börjar använda CS50 Sök.

24
00:01:25,410 --> 00:01:28,700
Så se till att du gör det.

25
00:01:28,700 --> 00:01:30,760
>> För alla avsnitt för denna pset,

26
00:01:30,760 --> 00:01:34,350
vi kommer att ha att göra med filen in-och utgångar, fil I / O.

27
00:01:34,350 --> 00:01:38,140
Vi kommer att gå över en massa program som behandlar matriser

28
00:01:38,140 --> 00:01:40,350
pekar på filer och sånt,

29
00:01:40,350 --> 00:01:43,050
så vi vill se till att vi är riktigt bekant och bekväm

30
00:01:43,050 --> 00:01:47,990
behandlar hur in-och utmatning till filer.

31
00:01:47,990 --> 00:01:52,080
>> I fördelningen kod för denna pset är en fil som heter copy.c,

32
00:01:52,080 --> 00:01:55,280
och det är vad vi kommer att hitta kommer att vara riktigt användbart för oss

33
00:01:55,280 --> 00:02:00,340
eftersom vi kommer att hamna faktiskt kopierar copy.c filen

34
00:02:00,340 --> 00:02:05,350
och bara ändra den något för att kunna uppnå de första 2 delarna av problemet uppsättningen.

35
00:02:05,350 --> 00:02:09,030
>> Och så då som jag nämnde tidigare har vi att göra med bitmappar samt JPEG.

36
00:02:09,030 --> 00:02:13,170
Så egentligen förstå strukturen för hur dessa filer är organiserade,

37
00:02:13,170 --> 00:02:16,170
hur vi kan verkligen översätta 0 och 1 i structs

38
00:02:16,170 --> 00:02:19,040
och saker som vi faktiskt kan förstå och tolka och redigera,

39
00:02:19,040 --> 00:02:21,000
som kommer att vara mycket viktigt,

40
00:02:21,000 --> 00:02:25,970
så gå in JPEG-och bitmappsfiler och förstå strukturen av dessa.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, som vanligt, börjar med en del av frågor.

42
00:02:30,780 --> 00:02:36,600
De kommer att behandla fil I / O och få dig van vid det.

43
00:02:36,600 --> 00:02:42,520
Då del 1 är deckare, där du ges en bitmappsfil

44
00:02:42,520 --> 00:02:45,630
som ser ungefär som röda prickar överallt.

45
00:02:45,630 --> 00:02:52,180
Och sedan i princip vad vi ska göra är att ta den här filen och bara redigera den något

46
00:02:52,180 --> 00:02:54,010
i en version som vi kan läsa.

47
00:02:54,010 --> 00:02:56,000
I huvudsak, när vi avslutar, vi får samma fil,

48
00:02:56,000 --> 00:03:02,630
utom vi kommer att kunna se de dolda budskap döljs av alla dessa röda prickar.

49
00:03:02,630 --> 00:03:07,310
Då Ändra storlek är ett program som, givet en fil

50
00:03:07,310 --> 00:03:11,490
och sedan fick namnet på filen att det avger och sedan tilldelas ett nummer också,

51
00:03:11,490 --> 00:03:16,850
faktiskt kommer att ändra storlek på den bitmappen av den heltalsvärde.

52
00:03:16,850 --> 00:03:19,240
Då slutligen har vi Recover pset.

53
00:03:19,240 --> 00:03:24,160
Vi får ett minneskort och sedan måste återvinna alla foton

54
00:03:24,160 --> 00:03:25,920
som har tagits bort av misstag,

55
00:03:25,920 --> 00:03:31,420
men som vi kommer att lära, inte bort och tas bort från filen,

56
00:03:31,420 --> 00:03:38,470
Vi bara typ av förlorade där de var i filen, men vi kommer att återkräva.

57
00:03:38,470 --> 00:03:44,950
>> Jättebra. Så gå in I / O-specifikt, det är en hel lista med funktioner som du kommer att använda.

58
00:03:44,950 --> 00:03:49,840
Du har redan sett lite grunderna i fopen, fread och fwrite,

59
00:03:49,840 --> 00:03:54,350
men vi kommer att titta närmare på en del fil-I / O-funktioner såsom fputc,

60
00:03:54,350 --> 00:03:56,930
där du skriver bara ett tecken i taget,

61
00:03:56,930 --> 00:04:02,000
till fseek där du slags flytta indikatorn filposition framåt och bakåt,

62
00:04:02,000 --> 00:04:05,770
och sedan några andra. Men vi ska gå in i det lite senare under pset.

63
00:04:08,050 --> 00:04:13,100
>> Så först, att bara få in I / O-innan vi går in i pset,

64
00:04:13,100 --> 00:04:19,860
att öppna en fil, till exempel, är vad du måste göra faktiskt ställa en pekare till filen.

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

66
00:04:22,710 --> 00:04:27,140
I det här fallet, jag kallar det en i pekare eftersom det kommer att bli min INFILE.

67
00:04:27,140 --> 00:04:33,340
Och så ska jag använda funktionen fopen och sedan namnet på filen

68
00:04:33,340 --> 00:04:36,360
och sedan läge där jag kommer att ha att göra med filen.

69
00:04:36,360 --> 00:04:42,080
Så det finns "r" i det här fallet för att läsa, "w" för skrivning, och sedan "A" för att lägga till.

70
00:04:42,080 --> 00:04:44,270
Till exempel när du arbetar med en INFILE

71
00:04:44,270 --> 00:04:47,310
och allt du vill göra är att läsa bits och bytes lagrade där,

72
00:04:47,310 --> 00:04:50,420
då du förmodligen kommer att vilja använda "r" som din läge.

73
00:04:50,420 --> 00:04:54,520
När du vill verkligen skriva, typ av göra en ny fil,

74
00:04:54,520 --> 00:04:57,220
vad vi ska göra är att vi ska öppna den nya filen

75
00:04:57,220 --> 00:05:02,410
och använd "w"-läge för att skriva.

76
00:05:02,410 --> 00:05:07,540
>> Så då när du faktiskt läser in filerna är strukturen enligt följande.

77
00:05:07,540 --> 00:05:14,930
Först inkluderar pekaren till struct som ska innehålla de bytes som du läser.

78
00:05:14,930 --> 00:05:19,830
Så det kommer att vara slutet platsen för byte som du läser.

79
00:05:19,830 --> 00:05:23,360
Du kan sedan kommer att indikera storleken gillar i princip hur många byte

80
00:05:23,360 --> 00:05:30,100
ditt program måste läsa in filen, storleken grunden en del är,

81
00:05:30,100 --> 00:05:32,620
och då du kommer att ange hur många element som du vill läsa.

82
00:05:32,620 --> 00:05:34,980
Och slutligen, måste du veta var du läser från,

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

84
00:05:37,580 --> 00:05:41,780
Jag färgkodade dessa eftersom fread är också mycket lik fwrite,

85
00:05:41,780 --> 00:05:47,050
förutom att du vill vara säker på att du använder rätt ordning,

86
00:05:47,050 --> 00:05:51,960
se till att du faktiskt skriver till eller läser från höger fil.

87
00:05:54,910 --> 00:05:58,610
>> Så då som förut, om vi har storleken av elementet samt antalet element,

88
00:05:58,610 --> 00:06:00,600
då kan vi leka här lite.

89
00:06:00,600 --> 00:06:06,810
Säg jag har en hund struct och så då vill jag läsa två hundar åt gången.

90
00:06:06,810 --> 00:06:12,450
Vad jag kan göra är att säga storleken på en del kommer att vara storleken på en hund

91
00:06:12,450 --> 00:06:14,770
och jag ska faktiskt läsa två av dem.

92
00:06:14,770 --> 00:06:18,290
Alternativt är att säga vad jag kunde göra jag bara tänker läsa en del

93
00:06:18,290 --> 00:06:21,340
och att en del kommer att vara storleken på två hundar.

94
00:06:21,340 --> 00:06:24,320
Så det är analog hur du kan slags leka med storlek och antal

95
00:06:24,320 --> 00:06:28,250
beroende på vad som är mer intuitiv för dig.

96
00:06:28,250 --> 00:06:30,810
>> Okej. Så nu får vi skriva filer.

97
00:06:30,810 --> 00:06:36,880
När du vill skriva en fil är det första argumentet faktiskt var du läser från.

98
00:06:36,880 --> 00:06:42,050
Så det är i princip de uppgifter som du ska skriva in i filen,

99
00:06:42,050 --> 00:06:44,490
vilket är den ute pekaren slutet.

100
00:06:44,490 --> 00:06:47,670
Så när du arbetar med pset, se till att du inte blir förvirrad.

101
00:06:47,670 --> 00:06:50,480
Kanske har definitionerna sida vid sida.

102
00:06:50,480 --> 00:06:58,090
Du kan dra definitionerna i handboken genom att skriva man och sedan fwrite, till exempel,

103
00:06:58,090 --> 00:06:59,950
i terminalen, eller så kan du hänvisa till denna bild

104
00:06:59,950 --> 00:07:03,570
och se till att du använder rätt.

105
00:07:03,570 --> 00:07:08,700
Så återigen, för fwrite, när du har en fil som du vill skriva in,

106
00:07:08,700 --> 00:07:14,290
det kommer att bli det sista argumentet och det kommer att bli en pekare till filen.

107
00:07:14,290 --> 00:07:18,670
Så då det är hur vi handskas med att skriva kanske flera byte i taget,

108
00:07:18,670 --> 00:07:21,820
men säger att du vill bara skriva på bara ett enda tecken.

109
00:07:21,820 --> 00:07:25,940
Som vi kommer att se senare i detta exempel, i bitmappar vi får använda den.

110
00:07:25,940 --> 00:07:32,180
Det är då vi kan använda fputc, i huvudsak bara sätta ett tecken i taget, chr,

111
00:07:32,180 --> 00:07:37,050
i filen pekaren, och det är vår ute pekare där.

112
00:07:38,700 --> 00:07:41,560
Så då när vi söker eller skriva i en fil,

113
00:07:41,560 --> 00:07:44,690
filen att hålla reda på var vi är.

114
00:07:44,690 --> 00:07:47,810
Så det är ett slags markör, filen lägesindikator.

115
00:07:47,810 --> 00:07:54,330
Och så när vi skriver eller läser igen i en fil,

116
00:07:54,330 --> 00:07:56,760
filen minns faktiskt där det är,

117
00:07:56,760 --> 00:07:59,270
och så fortsätter det där markören är.

118
00:07:59,270 --> 00:08:03,970
Detta kan vara bra när du vill, säg, läsa i en viss mängd för att göra något

119
00:08:03,970 --> 00:08:06,160
och sedan läsa i följande belopp,

120
00:08:06,160 --> 00:08:10,700
men ibland vi kanske vill gå tillbaka eller faktiskt börja från en viss referensvärde.

121
00:08:10,700 --> 00:08:16,870
Så då fseek funktionen, vad den gör är låter oss flytta markören i en viss fil

122
00:08:16,870 --> 00:08:19,680
ett visst antal byte.

123
00:08:19,680 --> 00:08:24,260
Och vad vi måste göra är ange var referensvärdet är.

124
00:08:24,260 --> 00:08:31,520
Så antingen det rör sig framåt eller bakåt från där markören för tillfället är,

125
00:08:31,520 --> 00:08:35,750
eller så kan vi ange att det bara skulle röra sig från början av filen

126
00:08:35,750 --> 00:08:37,090
eller från slutet av filen.

127
00:08:37,090 --> 00:08:41,230
Och så kan du skicka in negativa eller positiva värden till belopp,

128
00:08:41,230 --> 00:08:44,960
och som kommer slags flytta markören antingen framåt eller bakåt.

129
00:08:46,170 --> 00:08:51,920
>> Innan vi kommer till de andra psets, några frågor om fil-I / O?

130
00:08:53,860 --> 00:08:59,990
Okej. När vi kommer in fler exempel, gärna stoppa mig för frågor.

131
00:08:59,990 --> 00:09:06,930
>> Så i DECKARE, du gav en bitmappsfil som liknar detta röda på bilden,

132
00:09:06,930 --> 00:09:14,510
och det ser ut så här - ett gäng röda prickar - och du vet inte riktigt vad som är skrivet.

133
00:09:14,510 --> 00:09:23,310
Om du kisa, kanske du kan se en liten blåaktig färg inne i mitten.

134
00:09:23,310 --> 00:09:26,270
Huvudsak, det är där texten lagras.

135
00:09:26,270 --> 00:09:30,270
Det var ett mord som skedde, och vi måste ta reda på vem som gjorde det.

136
00:09:30,270 --> 00:09:36,760
För att kunna göra det måste vi sorts omvandla bilden till ett läsbart format.

137
00:09:36,760 --> 00:09:42,740
Om ni någonsin stött på detta, ibland skulle det finnas lite kit

138
00:09:42,740 --> 00:09:48,510
där du skulle ha ett förstoringsglas med en röd film. Någon? Ja.

139
00:09:48,510 --> 00:09:52,770
Så du skulle överlämnas något sådant, skulle du ha ett förstoringsglas

140
00:09:52,770 --> 00:09:58,130
med den röda filmen över den, skulle du placera den över bilden,

141
00:09:58,130 --> 00:10:03,410
och du skulle kunna se meddelandet gömd däri.

142
00:10:03,410 --> 00:10:07,080
Vi har inte ett förstoringsglas med röd film, så istället ska vi typ av skapa vår egen

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

144
00:10:09,060 --> 00:10:15,760
Och så att användaren ska mata DECKARE, sedan ledtråd,. Bmp,

145
00:10:15,760 --> 00:10:18,800
så det är INFILE, det är den röda pricken meddelandet,

146
00:10:18,800 --> 00:10:23,550
och då de säger verdict.bmp kommer att vara vår utfil.

147
00:10:23,550 --> 00:10:27,900
Så det kommer att skapa en ny bitmappsbild liknar ledtråden en

148
00:10:27,900 --> 00:10:32,600
förutom i ett läsbart format där vi kan se de dolda budskap.

149
00:10:32,600 --> 00:10:37,550
>> Eftersom vi kommer att ha att göra med att redigera och manipulera bitmappar av något slag,

150
00:10:37,550 --> 00:10:42,400
vi ska typ av dyk in i strukturen av dessa bitmappsfiler.

151
00:10:42,400 --> 00:10:48,130
Vi gick över dessa lite i föreläsning, men låt oss titta på dem lite mer.

152
00:10:48,130 --> 00:10:51,740
Bitmappar är i huvudsak bara ett arrangemang av byte

153
00:10:51,740 --> 00:10:55,790
där vi har angett vilka byte menar vad.

154
00:10:55,790 --> 00:11:00,540
Så här är ungefär som en karta över bitmappsbilden

155
00:11:00,540 --> 00:11:08,550
säger att det börjar med några header-filer, börjar med lite information där.

156
00:11:08,550 --> 00:11:16,540
Du ser att ungefär byte nummer 14 storleken anges av bitmappsbilden,

157
00:11:16,540 --> 00:11:18,520
och det fortsätter på.

158
00:11:18,520 --> 00:11:23,810
Men vad vi verkligen intresserade av här börjar runt byte nummer 54.

159
00:11:23,810 --> 00:11:26,060
Vi har dessa RGB tripplar.

160
00:11:26,060 --> 00:11:30,760
Vad som kommer att göra är att innehålla de faktiska pixlar, färgvärdena.

161
00:11:30,760 --> 00:11:35,950
Allt ovan att i huvudet är lite information

162
00:11:35,950 --> 00:11:41,240
motsvarar storleken på bilden, bredden på bilden, och höjden.

163
00:11:41,240 --> 00:11:44,930
När vi går in stoppning senare, vi får se varför storleken på bilden

164
00:11:44,930 --> 00:11:48,670
kan vara annorlunda än bredden eller höjden.

165
00:11:48,670 --> 00:11:54,240
Så då att representera dem - dessa bitmappsbilder är sekvenser av byte -

166
00:11:54,240 --> 00:11:59,370
vad vi kan göra är att säga okej, jag ska komma ihåg att på index 14,

167
00:11:59,370 --> 00:12:03,380
det är där storlek är till exempel utan vad vi ska göra för att underlätta detta

168
00:12:03,380 --> 00:12:06,020
är kapsla den i en struktur.

169
00:12:06,020 --> 00:12:08,880
Och så har vi två structs gjort för oss, en BITMAPFILEHEADER

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

171
00:12:10,440 --> 00:12:14,840
och så när vi läser in i filen som standard det kommer att gå i ordning,

172
00:12:14,840 --> 00:12:22,360
och så för det kommer också att fylla i till variabler såsom biWidth och biSize.

173
00:12:25,270 --> 00:12:31,230
Och slutligen, är varje pixel representeras av tre byte.

174
00:12:31,230 --> 00:12:35,500
Den första är mängden blått i pixeln, är den andra mängden grönt,

175
00:12:35,500 --> 00:12:41,120
och slutligen, mängden rött, där 0 är väsentligen ingen blå eller ingen grön eller inget rött

176
00:12:41,120 --> 00:12:43,720
och sedan ff är det maximala värdet.

177
00:12:43,720 --> 00:12:46,800
Dessa är hexadecimala värden.

178
00:12:46,800 --> 00:12:53,870
Så då om vi har FF0000, då motsvarar den maximala mängden blått

179
00:12:53,870 --> 00:12:58,890
och då ingen grön och ingen röd, så då skulle ge oss en blå pixel.

180
00:12:58,890 --> 00:13:04,190
Sen om vi har ff oss alla över hela linjen, då det innebär att vi har en vit pixel.

181
00:13:04,190 --> 00:13:11,370
Detta är typ av motsatsen till normalt när vi säger RGB. Det faktiskt kommer BGR.

182
00:13:12,750 --> 00:13:18,990
>> Så om vi verkligen undersöka ett exempel på en bitmappsbild - låt mig dra en här uppe.

183
00:13:31,560 --> 00:13:33,830
Det är lite små.

184
00:13:39,890 --> 00:13:47,840
Jag zooma in, och vi kan se det är taggiga ut. Det ser ut som block av färg.

185
00:13:47,840 --> 00:13:50,110
Du har vita block och sedan röda block.

186
00:13:50,110 --> 00:13:53,700
Om du spelar i Microsoft Paint, till exempel, kan du göra något liknande

187
00:13:53,700 --> 00:13:58,960
genom i princip bara måla vissa rutor i en viss ordning.

188
00:13:58,960 --> 00:14:08,060
Så vad detta innebär i bitmappen är som följer.

189
00:14:08,060 --> 00:14:15,710
Här har vi första vita pixlar, att alla 6 är F: s, och sedan har vi röda pixlar,

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

191
00:14:19,910 --> 00:14:27,940
Och så den sekvens byte som vi har visar hur bitmappsbilden kommer att se.

192
00:14:27,940 --> 00:14:32,230
Så vad jag har gjort här är just skrivit ut alla dessa byte och sedan färgade i rött

193
00:14:32,230 --> 00:14:37,550
så att du kan typen av se, om du kisar lite, hur den typen av indikerar en smiley.

194
00:14:40,180 --> 00:14:46,390
>> Det sätt som bitmappsbilder arbete är jag föreställer det i grunden som ett rutnät.

195
00:14:46,390 --> 00:14:54,940
Och så som standard har varje rad i rutnätet är en multipel av 4 byte.

196
00:15:00,520 --> 00:15:07,060
Om vi ​​tittar på en bitmappsbild, du fyller i alla värde.

197
00:15:07,060 --> 00:15:17,370
Till exempel kan du ha en röd här, en grön här, en blå här,

198
00:15:17,370 --> 00:15:24,950
men du måste se till att bilden fylls i med en multipel av fyra byte.

199
00:15:24,950 --> 00:15:32,200
Så om jag vill att min bild är tre kvarter bred, då skulle jag behöva sätta ett tomt värde

200
00:15:32,200 --> 00:15:35,640
i den sista för att göra det en multipel av fyra.

201
00:15:35,640 --> 00:15:39,530
Så då skulle jag lägga i något som vi kallar stoppning.

202
00:15:39,530 --> 00:15:43,750
Jag ska bara visa att det med ett x.

203
00:15:44,920 --> 00:15:54,160
Nu säger vi vill ha en bild som är 7 pixlar lång, till exempel.

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
och allt som är fylld med färg.

206
00:16:07,000 --> 00:16:10,620
Det sätt som bitmappsbilder fungera är att vi behöver en 8: e.

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

208
00:16:12,460 --> 00:16:19,360
Vi behöver 8 platser för bitmappsbilden för att läsa korrekt.

209
00:16:19,360 --> 00:16:25,600
Så vad vi måste göra är att lägga in bara lite stoppning

210
00:16:25,600 --> 00:16:29,430
att se till att alla bredder är enhetliga

211
00:16:29,430 --> 00:16:34,260
och att alla bredder är en multipel av 4.

212
00:16:42,110 --> 00:16:47,310
Och så jag visade tidigare vaddering som X eller en snirklig linje,

213
00:16:47,310 --> 00:16:53,880
men i själva bitmappsbilder stoppningen indikeras av en hexadecimal 0.

214
00:16:53,880 --> 00:16:57,340
Så det skulle vara ett enstaka tecken, 0.

215
00:16:58,980 --> 00:17:06,329
Vad kan vara bra att ha är den XXD kommandot.

216
00:17:06,329 --> 00:17:11,220
Vad den gör är faktiskt visar du, liksom liknar vad jag gjorde innan med smiley

217
00:17:11,220 --> 00:17:15,630
När jag skrivs faktiskt ut vad varje färg skulle vara för pixeln

218
00:17:15,630 --> 00:17:21,800
och sedan färgkodade det, när du kör XXD med följande kommandon,

219
00:17:21,800 --> 00:17:28,670
så kommer det faktiskt skriva ut vad färgerna är för dessa pixlar.

220
00:17:28,670 --> 00:17:33,810
Vad du behöver göra är över här jag ange som-s 54

221
00:17:33,810 --> 00:17:36,530
säger att jag ska börja på den 54: e byte

222
00:17:36,530 --> 00:17:40,820
eftersom innan att komma ihåg om vi ser tillbaka till kartan i bitmappar,

223
00:17:40,820 --> 00:17:42,690
det är allt rubrikinformation och sånt.

224
00:17:42,690 --> 00:17:46,280
Men vad vi verkligen bryr oss om är den faktiska pixlar som indikerar färgen.

225
00:17:46,280 --> 00:17:52,700
Så genom att lägga i den flagga,-s 54, då vi kan se färgvärdena.

226
00:17:52,700 --> 00:17:56,020
Och oroa dig inte om de komplicerade flaggor och sånt.

227
00:17:56,020 --> 00:18:05,020
I problembild spec, har du anvisningar om hur du XXD använda för att visa pixlar.

228
00:18:07,070 --> 00:18:15,590
Så om du ser här, det slags ser ut som en grön ruta, denna lilla sak.

229
00:18:15,590 --> 00:18:23,610
Jag har färgkodade för 00FF00 som i princip säga nej blå, mycket grönt och ingen röd.

230
00:18:23,610 --> 00:18:26,370
Så som motsvarar grönt.

231
00:18:26,370 --> 00:18:31,920
Som du ser här ser vi en grön rektangel.

232
00:18:31,920 --> 00:18:36,660
Denna gröna rektangeln är bara 3 pixlar bred, så vad vi måste göra

233
00:18:36,660 --> 00:18:44,350
att se till att bilden är en multipel av 4 bred är att lägga i extra stoppning.

234
00:18:44,350 --> 00:18:49,460
Och så då det är hur du ser dessa 0s här.

235
00:18:49,460 --> 00:18:54,510
Detta kommer faktiskt vara resultatet av din Omformatera pset,

236
00:18:54,510 --> 00:19:01,350
huvudsak tar lilla bitmapp och sedan utvidga den med 4.

237
00:19:01,350 --> 00:19:09,380
Och så vad vi ser är att faktiskt denna bild är 12 pixlar bred, men 12 är en multipel av 4,

238
00:19:09,380 --> 00:19:12,940
och så att vi faktiskt inte se någon 0s slutet eftersom vi inte behöver lägga något

239
00:19:12,940 --> 00:19:19,070
eftersom det är helt vadderad. Det har inte någon mer utrymme.

240
00:19:20,720 --> 00:19:23,470
>> Okej. Har du frågor om stoppning?

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

242
00:19:27,460 --> 00:19:32,520
>> Som jag nämnde tidigare, de bitmappar är bara en sekvens av bytes.

243
00:19:32,520 --> 00:19:39,170
Och så vad vi har är i stället för att behöva hålla reda på exakt vilka antalet byte

244
00:19:39,170 --> 00:19:47,050
motsvarar en specifik del, vi faktiskt har skapat en struktur för att representera det.

245
00:19:47,050 --> 00:19:50,930
Så vad vi har är en RGBTRIPLE struct.

246
00:19:50,930 --> 00:19:54,590
När du har en instans av en RGB trippel,

247
00:19:54,590 --> 00:20:00,970
eftersom detta är en typ definierar struct, så du kan komma åt rgbtBlue variabel,

248
00:20:00,970 --> 00:20:09,520
Likaså gröna och röda variabler, som indikerar hur mycket blått, grönt och rött,

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

250
00:20:11,580 --> 00:20:16,800
>> Så om vi har den blå variabeln inställd på 0, den gröna satt till ff,

251
00:20:16,800 --> 00:20:22,060
vilket är det högsta värde som du kan ha, och sedan den röda variabeln satt till 0,

252
00:20:22,060 --> 00:20:27,870
vad färg skulle detta RGB trippel representerar? >> [Elev] Green.

253
00:20:27,870 --> 00:20:29,150
Grön. Exakt.

254
00:20:29,150 --> 00:20:34,480
Det kommer att vara bra att veta att när du har en instans av en RGB trippel,

255
00:20:34,480 --> 00:20:41,340
du kan faktiskt komma åt mängden färg - blå, grön och röd - för sig.

256
00:20:43,350 --> 00:20:54,900
>> Nu när vi har pratat om strukturen av det, låt oss ta en titt på BMP-fil.

257
00:20:54,900 --> 00:20:57,870
Dessa är structs gjorda för dig.

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

259
00:21:01,820 --> 00:21:07,610
Av intresse är storleken.

260
00:21:07,610 --> 00:21:12,660
Senare har vi info huvudet, som har några fler saker som är intressant för oss,

261
00:21:12,660 --> 00:21:15,480
nämligen storleken, bredden och höjden.

262
00:21:15,480 --> 00:21:19,170
När vi ska gå in senare när du läser in i filen,

263
00:21:19,170 --> 00:21:25,500
det står automatiskt eftersom vi har ställt in för att vara detsamma.

264
00:21:25,500 --> 00:21:31,990
Så biSize innehåller rätt byte som motsvarar den verkliga storleken på bilden.

265
00:21:34,700 --> 00:21:40,500
Och sedan här, slutligen, som vi har pratat om, vi har RGBTRIPLE typedef struct.

266
00:21:40,500 --> 00:21:46,840
Vi har en rgbtBlue, grönt och rött i samband med det.

267
00:21:48,210 --> 00:21:49,340
>> Jättebra. Okej.

268
00:21:49,340 --> 00:21:56,360
Nu när vi förstår bitmappar lite, förstår att vi har ett filhuvud

269
00:21:56,360 --> 00:22:00,790
och ett info huvud i samband med det och sedan efter det har vi intressanta saker

270
00:22:00,790 --> 00:22:05,110
av färger och de färger representeras av RGBTRIPLE structs,

271
00:22:05,110 --> 00:22:12,710
och de har i sin tur har tre värden som är associerade till blått, grönt och rött.

272
00:22:12,710 --> 00:22:17,270
>> Så nu kan vi slags tänker på Återställa lite.

273
00:22:17,270 --> 00:22:20,130
Ursäkta. Tänk på deckare.

274
00:22:20,130 --> 00:22:25,750
När vi har vår ledtråd fil, vad vi vill göra är att läsa in till den pixel för pixel

275
00:22:25,750 --> 00:22:33,860
och sedan på något sätt ändra dessa pixlar så att vi kan mata den till ett läsbart format.

276
00:22:33,860 --> 00:22:41,020
Och så för att mata den, vi ska skriva pixel för pixel i verdict.bmp filen.

277
00:22:41,020 --> 00:22:45,120
Det är lite av en hel del att göra. Vi inser att.

278
00:22:45,120 --> 00:22:49,860
Så vad vi har gjort är att vi faktiskt har gett dig copy.c.

279
00:22:49,860 --> 00:22:57,610
Vad copy.c gör är bara gör en exakt kopia av en viss bitmappsfil och matar sedan ut det.

280
00:22:57,610 --> 00:23:01,900
Så detta öppnar redan filen för dig, läser in pixel för pixel,

281
00:23:01,900 --> 00:23:04,510
och sedan skriver det i en utdatafil.

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

283
00:23:13,390 --> 00:23:18,290
Detta är att se korrekt användning,

284
00:23:18,290 --> 00:23:22,640
få filnamnen här.

285
00:23:22,640 --> 00:23:29,940
Vad detta innebär är det sätter indatafilen är vad vi har gått in i INFILE här,

286
00:23:29,940 --> 00:23:34,750
vilket är vår andra kommandoradsargument.

287
00:23:34,750 --> 00:23:37,640
Kontrollerar att se till att vi kan öppna filen.

288
00:23:38,960 --> 00:23:44,860
Kontrollerar att vi kan göra en ny utfil här.

289
00:23:45,630 --> 00:23:53,270
Sedan vad detta innebär här, det bara grunden börjar läsa in till bitmappsfilen från början.

290
00:23:53,270 --> 00:23:56,700
Början, som vi vet, innehåller BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
och så dessa sekvenser av bitar kommer direkt fylla i BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Så vad vi har här säger att BITMAPFILEHEADER bf -

293
00:24:07,940 --> 00:24:13,150
Det är vår nya variabel av typen BITMAPFILEHEADER -

294
00:24:13,150 --> 00:24:22,560
vi kommer att sätta in bf vad vi läser från i pekare, vilket vår INFILE.

295
00:24:22,560 --> 00:24:23,970
Hur mycket läser vi?

296
00:24:23,970 --> 00:24:32,160
Vi läser i hur många byte behöver vi innehålla hela BITMAPFILEHEADER.

297
00:24:32,160 --> 00:24:34,660
Likaså är det vad vi gör för info sidhuvudet.

298
00:24:34,660 --> 00:24:39,010
Så vi fortsätter längs vår fil i INFILE,

299
00:24:39,010 --> 00:24:44,360
och vi läser dessa bitar och bytes, och vi ansluter dem direkt i

300
00:24:44,360 --> 00:24:47,880
i dessa fall av de variabler som vi gör.

301
00:24:49,370 --> 00:24:53,800
Här är vi bara se till att bitmappen är en bitmapp.

302
00:24:57,670 --> 00:25:01,030
>> Nu har vi en utfil, eller hur?

303
00:25:01,030 --> 00:25:04,420
Så som det ser när vi skapar det, är det i huvudsak tom.

304
00:25:04,420 --> 00:25:07,710
Så vi måste i princip skapa ett nytt bitmapp från grunden.

305
00:25:07,710 --> 00:25:12,280
Vad vi gör är att vi måste se till att vi kopierar i filhuvudet

306
00:25:12,280 --> 00:25:16,850
och info huvudet precis som INFILE har.

307
00:25:16,850 --> 00:25:22,850
Vad vi gör är att vi skriver - och kom ihåg att bf är den variabel

308
00:25:22,850 --> 00:25:29,300
av typen BITMAPFILEHEADER, så vad vi gör är att vi bara använder det innehåll

309
00:25:29,300 --> 00:25:34,980
skriva in i utfil.

310
00:25:36,550 --> 00:25:38,510
Här minns vi talade om stoppning,

311
00:25:38,510 --> 00:25:47,820
hur det är viktigt att se till att den mängd pixlar som vi har är en multipel av 4.

312
00:25:47,820 --> 00:25:52,790
Detta är en ganska bra formel för att beräkna hur mycket stoppning du har

313
00:25:52,790 --> 00:25:57,670
med tanke på bredden på din fil.

314
00:25:57,670 --> 00:26:04,120
Jag vill att ni ska komma ihåg att i copy.c vi har en formel för att beräkna stoppning.

315
00:26:04,120 --> 00:26:07,970
Okej? Så alla ihåg. Jättebra.

316
00:26:07,970 --> 00:26:14,050
Så vad copy.c gör härnäst är det itererar över alla Scanlines.

317
00:26:14,050 --> 00:26:23,730
Den går genom raderna först och sedan lagrar varje trippel att den läser

318
00:26:23,730 --> 00:26:26,920
och sedan skriver in den utfil.

319
00:26:26,920 --> 00:26:33,120
Så så här vi läser bara en RGB trippel i taget

320
00:26:33,120 --> 00:26:39,860
och sedan sätta samma trippel i utfil.

321
00:26:41,120 --> 00:26:48,340
Den svåra delen är att stoppningen inte är en RGB-trippel,

322
00:26:48,340 --> 00:26:55,200
och så att vi inte bara kan läsa det stoppning mängd RGB tripplar.

323
00:26:55,200 --> 00:27:01,460
Vad vi måste göra är faktiskt bara flytta vår indikator fil flyttar du vår markören,

324
00:27:01,460 --> 00:27:06,840
till typ av hoppa över all stoppning så att vi är på nästa rad.

325
00:27:06,840 --> 00:27:12,990
Och vad detta innebär är kopieringsskyddad visar hur du kanske vill lägga till stoppning.

326
00:27:12,990 --> 00:27:14,990
Så vi har beräknat hur mycket stoppning vi behöver,

327
00:27:14,990 --> 00:27:18,220
så det betyder att vi behöver stoppning antal 0s.

328
00:27:18,220 --> 00:27:24,510
Vad detta innebär är en for-slinga som sätter stoppning antal 0s i vår utfil.

329
00:27:24,510 --> 00:27:31,170
Och slutligen, stänger du båda filerna. Du stänger INFILE samt utfil.

330
00:27:31,170 --> 00:27:34,870
>> Så det är hur copy.c verk,

331
00:27:34,870 --> 00:27:37,430
och det kommer att vara ganska bra.

332
00:27:39,720 --> 00:27:43,750
Istället för att bara faktiskt direkt kopiera och klistra

333
00:27:43,750 --> 00:27:46,800
eller bara titta på den och skriva in vad du vill,

334
00:27:46,800 --> 00:27:49,440
du kanske bara vill köra detta kommando i terminalen,

335
00:27:49,440 --> 00:27:54,520
cp copy.c whodunit.c, vilket kommer att skapa en ny fil, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
som innehåller exakt samma innehåll som kopia gör.

337
00:27:58,330 --> 00:28:03,880
Så då vad vi kan göra är att använda det som ett ramverk på att bygga och redigera

338
00:28:03,880 --> 00:28:06,900
för vår DECKARE fil.

339
00:28:08,500 --> 00:28:14,670
>> Dessa är vår att-DOS att göra för DECKARE, men vad copy.c gör

340
00:28:14,670 --> 00:28:16,730
faktiskt tar hand om de flesta av dem för oss.

341
00:28:16,730 --> 00:28:21,900
Så allt vi behöver göra härnäst är att ändra pixlarna som behövs

342
00:28:21,900 --> 00:28:25,920
att faktiskt göra filen läsbar.

343
00:28:25,920 --> 00:28:32,960
Kom ihåg att för en given pixel trippel, så för en given variabel av typen RGBTRIPLE,

344
00:28:32,960 --> 00:28:35,990
kan du komma åt de blå, gröna och röda värden.

345
00:28:35,990 --> 00:28:38,670
Det kommer att komma till hands för om du kan komma åt dem,

346
00:28:38,670 --> 00:28:41,770
det betyder att du också kan kontrollera dem,

347
00:28:41,770 --> 00:28:45,430
och det betyder att du även kan ändra dem.

348
00:28:45,430 --> 00:28:49,430
>> Så när vi gick tillbaka till vårt röda förstoringsglas exempel

349
00:28:49,430 --> 00:28:53,390
princip, var att fungera som en slags filter för oss.

350
00:28:53,390 --> 00:28:58,160
Så vad vi vill göra är att vi vill filtrera alla tripplar som kommer in

351
00:28:58,160 --> 00:29:01,240
Det finns flera olika sätt att göra detta.

352
00:29:01,240 --> 00:29:07,100
I princip kan du ha vilken typ av filter du vill.

353
00:29:07,100 --> 00:29:09,890
Kanske du vill ändra alla röda pixlar

354
00:29:09,890 --> 00:29:13,570
eller kanske du vill ändra en annan färg pixel till en annan färg.

355
00:29:13,570 --> 00:29:15,400
Det är upp till dig.

356
00:29:15,400 --> 00:29:19,580
Kom ihåg att du kan kontrollera vilken färg pixeln är

357
00:29:19,580 --> 00:29:23,000
och sedan kan du också ändra det som du går igenom.

358
00:29:24,410 --> 00:29:26,420
>> Okej. Så det är deckare.

359
00:29:26,420 --> 00:29:32,760
När du kör DECKARE, vet du vem den skyldige för brottet var.

360
00:29:32,760 --> 00:29:35,540
>> Nu ska vi gå till Ändra storlek.

361
00:29:35,540 --> 00:29:37,990
Vi kommer att fortfarande ha att göra med bitmappar.

362
00:29:37,990 --> 00:29:40,750
Vad vi ska göra är att vi kommer att ha en ingång bitmapp

363
00:29:40,750 --> 00:29:45,890
och då ska vi gå på ett nummer och sedan få en utfil bitmapp

364
00:29:45,890 --> 00:29:51,380
där det är i princip vår INFILE skalas av n.

365
00:29:54,670 --> 00:30:01,450
Säg min fil var bara en pixel stor.

366
00:30:01,450 --> 00:30:09,100
Sedan om min n var 3, skalning med 3, då skulle jag upprepa att pixel n antal gånger,

367
00:30:09,100 --> 00:30:14,410
så 3 gånger och då också skala ner 3 gånger också.

368
00:30:14,410 --> 00:30:17,840
Så du ser att jag skalning det vertikalt och horisontellt.

369
00:30:17,840 --> 00:30:19,680
>> Och så här är ett exempel.

370
00:30:19,680 --> 00:30:27,590
Om du har n = 2, ser du att den första blå pixel det upprepas två gånger

371
00:30:27,590 --> 00:30:30,930
horisontellt samt två gånger vertikalt.

372
00:30:30,930 --> 00:30:38,040
Och då fortsätter vidare, och så har du en direkt skalning av den ursprungliga bilden med två.

373
00:30:40,920 --> 00:30:47,600
>> Så då om vi skulle detalj pseudokod för detta vill vi öppna filen.

374
00:30:47,600 --> 00:30:49,880
Och sedan veta att om vi går tillbaka hit,

375
00:30:49,880 --> 00:30:54,540
Vi ser att bredden för utfil kommer att vara annorlunda än bredden för infil.

376
00:30:54,540 --> 00:30:56,130
Vad betyder det?

377
00:30:56,130 --> 00:31:01,230
Det innebär att vår rubrikinformation kommer att förändras.

378
00:31:01,230 --> 00:31:03,790
Och så vad vi kommer att vilja göra är att uppdatera huvudet info,

379
00:31:03,790 --> 00:31:11,820
att veta att när vi läser i filerna om du arbetar på copy.c ramen,

380
00:31:11,820 --> 00:31:17,570
Vi har redan en variabel som visar vilken storlek är och sånt.

381
00:31:17,570 --> 00:31:24,060
Så när du har det, vad du skulle vilja göra är att byta dessa särskilda variabler.

382
00:31:24,060 --> 00:31:29,380
Kom ihåg att om du har en struct, hur du komma åt variablerna i det.

383
00:31:29,380 --> 00:31:32,080
Du använder punktoperatorn, eller hur?

384
00:31:32,080 --> 00:31:36,420
Så då använda den, du vet att du måste ändra rubriken info.

385
00:31:36,480 --> 00:31:41,030
Så här är bara en lista av de faktiska element som kommer att förändras i din fil.

386
00:31:41,030 --> 00:31:45,180
Filstorleken kommer att förändras, bilden, liksom bredden och höjden.

387
00:31:45,180 --> 00:31:50,080
Så då gå tillbaka till kartan på bitmappar,

388
00:31:50,080 --> 00:31:57,730
titta på om det är filhuvudet eller info rubrik som innehåller denna information

389
00:31:57,730 --> 00:32:00,920
och sedan ändra om det behövs.

390
00:32:05,010 --> 00:32:12,470
Återigen säger cp copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
Det innebär att resize.c nu innehåller allt som finns inuti kopia

392
00:32:19,270 --> 00:32:24,490
eftersom kopiering ger oss ett sätt att läsa in varje scanline pixel för pixel.

393
00:32:24,490 --> 00:32:29,860
Utom nu, i stället för att bara ändra värdena som vi gjorde i DECKARE,

394
00:32:29,860 --> 00:32:37,980
vad vi vill göra är att vi vill skriva i flera pixlar

395
00:32:37,980 --> 00:32:43,580
så länge som vår n är större än 1.

396
00:32:43,580 --> 00:32:47,110
>> Vad vi vill göra är att vi vill sträcka ut den horisontellt med n,

397
00:32:47,110 --> 00:32:50,490
samt sträcka den vertikalt med n..

398
00:32:50,490 --> 00:32:52,710
Hur kan vi göra detta?

399
00:32:52,710 --> 00:32:56,890
Säg din n är 2 och du har denna givna INFILE.

400
00:32:56,890 --> 00:32:58,730
Markören kommer att börja på den första,

401
00:32:58,730 --> 00:33:03,530
och vad du vill göra om n är 2, vill du skriva ut i 2 av dem.

402
00:33:03,530 --> 00:33:05,490
Så du skriva ut i 2 av dem.

403
00:33:05,490 --> 00:33:10,830
Sedan markören kommer att flytta till nästa pixel, vilket är den röda en,

404
00:33:10,830 --> 00:33:18,400
och det kommer att skriva ut 2 av de röda, lägga den på vad det gjort tidigare.

405
00:33:18,400 --> 00:33:26,280
Då markören flyttas till nästa pixel och dra i 2 av dem.

406
00:33:26,280 --> 00:33:37,180
Om man ser tillbaka till den copy.c ramen, vad detta innebär här

407
00:33:37,180 --> 00:33:42,830
är den skapar en ny instans av en RGB trippel, en ny variabel kallad triple.

408
00:33:42,830 --> 00:33:50,500
Och här när den läser in det, läser det från INFILE 1 RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
och lagrar det inne i den trippel variabel.

410
00:33:53,470 --> 00:33:57,590
Så då har du faktiskt en variabel som representerar just den pixeln.

411
00:33:57,590 --> 00:34:05,290
Sedan när du skriver, vad du skulle vilja göra är innesluta den fwrite uttalande i en for-slinga

412
00:34:05,290 --> 00:34:11,080
som skriver in den på din utfil så många gånger som behövs.

413
00:34:17,449 --> 00:34:20,100
Det är enkelt nog.

414
00:34:20,200 --> 00:34:27,590
Bara princip upprepa skrivprocessen n antal gånger för att skala den horisontellt.

415
00:34:27,590 --> 00:34:32,969
>> Men då måste vi komma ihåg att vår stoppning kommer att förändras.

416
00:34:47,350 --> 00:34:53,020
Tidigare säga att vi hade något med längden 3.

417
00:34:53,020 --> 00:35:00,130
Då skulle vi bara lägga in hur mycket stoppning? Bara en att göra det en multipel av 4.

418
00:35:00,130 --> 00:35:10,480
Men säger att vi skalar denna bild med n = 2.

419
00:35:10,480 --> 00:35:16,300
Så hur många blå bildpunkter skulle vi ha i slutet? Vi skulle ha 6.

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

421
00:35:21,470 --> 00:35:26,580
6 är inte en multipel av 4. Vad är närmaste multipel av 4? Det kommer att vara 8.

422
00:35:26,580 --> 00:35:33,200
Så vi faktiskt kommer att ha 2 tecken stoppning där.

423
00:35:33,200 --> 00:35:38,720
>> Minns någon om vi har en formel för att beräkna stoppning

424
00:35:38,720 --> 00:35:41,350
och där det kan vara?

425
00:35:41,350 --> 00:35:45,160
[Ohörbart elev svar] >> Ja, copy.c. Rätt.

426
00:35:45,160 --> 00:35:49,800
Det finns en formel i copy.c att beräkna hur mycket stoppning du har

427
00:35:49,800 --> 00:35:53,810
ges en särskild bredd bitmappsbilden.

428
00:35:53,810 --> 00:36:02,950
Så då det kommer att vara användbart när du behöver lägga till i en viss stoppning

429
00:36:02,950 --> 00:36:06,160
att faktiskt räkna ut hur mycket stoppning du behöver lägga till.

430
00:36:10,820 --> 00:36:15,850
Men en anmärkning, är dock att du vill vara säker på att du använder rätt storlek.

431
00:36:15,850 --> 00:36:21,410
Bara vara försiktig eftersom du i princip kommer att ha att göra med två bitmappsbilder.

432
00:36:21,410 --> 00:36:23,410
Du vill vara säker på att du använder rätt.

433
00:36:23,410 --> 00:36:26,820
När du beräkna stoppning för utfil, du vill använda bredden på utfil

434
00:36:26,820 --> 00:36:29,860
och inte bredden av den föregående.

435
00:36:29,860 --> 00:36:37,240
>> Jättebra. Denna typ av tar hand om stretching en hel bitmappsbild horisontellt.

436
00:36:37,240 --> 00:36:41,290
Men vad vi vill göra är att sträcka faktiskt vertikalt liksom.

437
00:36:41,290 --> 00:36:48,760
Detta kommer att bli lite svårare eftersom när vi har kopierat en rad

438
00:36:48,760 --> 00:36:51,580
och skriva den raden är vår markören kommer att vara i slutet.

439
00:36:51,580 --> 00:36:56,210
Så om vi läser igen, då det bara kommer att läsa in i nästa rad.

440
00:36:56,210 --> 00:37:03,660
Så vad vi vill göra är typ av att hitta något sätt att kopiera dessa rader igen

441
00:37:03,660 --> 00:37:12,500
eller bara typ att ta den raden och sedan skriva det igen.

442
00:37:14,380 --> 00:37:17,940
När jag slags hänvisade till, det finns flera olika sätt att göra detta.

443
00:37:17,940 --> 00:37:23,040
Vad du kan göra är som du går igenom och läsa igenom den särskilda avsökningsraden

444
00:37:23,040 --> 00:37:28,560
och ändra den vid behov, då slags lagra alla dessa pixlar i en array.

445
00:37:28,560 --> 00:37:36,350
Senare på du vet att du behöver för att skriva ut den arrayen igen,

446
00:37:36,350 --> 00:37:39,830
och så kan du bara använda den matris att göra det.

447
00:37:39,830 --> 00:37:44,500
Ett annat sätt att göra det är att du kan kopiera ner en rad,

448
00:37:44,500 --> 00:37:47,950
förstår att du behöver kopiera det igen, så faktiskt flytta markören,

449
00:37:47,950 --> 00:37:50,950
och det kommer att bli med metoden fseek.

450
00:37:50,950 --> 00:37:56,410
Du kan flytta markören hela vägen tillbaka och sedan upprepa kopieringen igen.

451
00:37:56,410 --> 00:38:03,960
>> Så om vi skalning nummer är n, hur många gånger skulle vi gå tillbaka

452
00:38:03,960 --> 00:38:10,500
och skriva en rad? >> [Eleven] n - 1. >> Ja, perfekt. n - 1.

453
00:38:10,500 --> 00:38:14,390
Vi har gjort det en gång redan, så vi kommer att vilja upprepa gå tillbaka processen

454
00:38:14,390 --> 00:38:17,460
n - 1 antal gånger.

455
00:38:22,730 --> 00:38:25,860
Okej. Där har ni er storleksändring funktion.

456
00:38:25,860 --> 00:38:34,360
>> Nu kan vi få till en riktigt rolig del, min favorit pset, vilket är Recover.

457
00:38:34,360 --> 00:38:39,580
Istället för bitmappar, denna gång vi har att göra med JPEG.

458
00:38:39,580 --> 00:38:43,370
Vi är faktiskt inte gett en fil bara av JPEG,

459
00:38:43,370 --> 00:38:46,600
vi ges grunden en RAW-format minneskort.

460
00:38:46,600 --> 00:38:51,790
Och så detta innehåller lite info och skräp värden i början,

461
00:38:51,790 --> 00:38:57,240
och då det börjar och den har en massa JPEG-filer.

462
00:38:57,240 --> 00:39:03,430
Men vi överlämnade en kort där vi har tagit bort bilderna;

463
00:39:03,430 --> 00:39:08,300
huvudsak har vi glömt var bilderna finns inom kort.

464
00:39:08,300 --> 00:39:12,770
Så då vår uppgift i Recover är att gå igenom detta kort format

465
00:39:12,770 --> 00:39:16,500
och hitta dessa bilder igen.

466
00:39:16,500 --> 00:39:23,990
>> Lyckligtvis är strukturen av JPEG-filer och kortet filen lite hjälp.

467
00:39:23,990 --> 00:39:28,850
Det definitivt kunde ha varit lite svårare om det inte vore i detta format.

468
00:39:28,850 --> 00:39:40,160
Varje JPEG-fil börjar faktiskt med två möjliga sekvenser, som anges ovan.

469
00:39:40,160 --> 00:39:42,970
I grund och botten, när du har en ny JPEG-fil,

470
00:39:42,970 --> 00:39:52,720
det börjar med antingen sekvensen ffd8 ffe0 eller den andra, ffd8 ffe1.

471
00:39:52,720 --> 00:39:59,530
En annan användbar sak att veta är att JPEG-bilder lagras intill varandra.

472
00:39:59,530 --> 00:40:03,380
Så när en JPEG-fil slutar, de övriga en starter.

473
00:40:03,380 --> 00:40:07,070
Så det finns inte någon form av in-mellan värden där.

474
00:40:07,070 --> 00:40:15,510
När du träffar i början av en JPEG, om du redan har läst en JPEG,

475
00:40:15,510 --> 00:40:21,800
du vet att du har drabbats slutet av föregående och början av nästa.

476
00:40:21,800 --> 00:40:25,890
>> Till typ av visualisera detta gjorde jag en schematisk.

477
00:40:25,890 --> 00:40:36,910
En annan sak om JPEG är att vi kan läsa dem i sekvenser av 512 byte i taget,

478
00:40:36,910 --> 00:40:39,380
liknande med början av kortet.

479
00:40:39,380 --> 00:40:43,370
Vi behöver inte vara att kontrollera varenda byte eftersom det skulle suga.

480
00:40:43,370 --> 00:40:48,200
Så istället vad vi kan göra är faktiskt bara läsa i 512 byte åt gången

481
00:40:48,200 --> 00:40:54,700
och sedan, i stället för att checka in mellan dem i de små små skivor,

482
00:40:54,700 --> 00:40:58,640
Vi kan bara kolla i början av 512 byte.

483
00:40:58,640 --> 00:41:02,570
Huvudsak på bilden, vad du ser är i början av kortet,

484
00:41:02,570 --> 00:41:08,700
du har värden som inte riktigt relevant för de faktiska JPEG själva.

485
00:41:08,700 --> 00:41:15,830
Men vad jag har är en stjärna för att ange en av de två start sekvenser för en JPEG.

486
00:41:15,830 --> 00:41:19,910
Så när du ser en stjärna, du vet att du har en JPEG-fil.

487
00:41:19,910 --> 00:41:25,030
Och därefter var JPEG-fil kommer att vara någon multipel av 512 byte

488
00:41:25,030 --> 00:41:27,880
men inte nödvändigtvis samma multipel.

489
00:41:27,880 --> 00:41:32,050
Det sätt som du vet att du har drabbats annan JPEG är om du träffar en annan stjärna,

490
00:41:32,050 --> 00:41:39,090
annan startsekvens byte.

491
00:41:39,090 --> 00:41:43,330
Vad ni har här är att du har den röda JPEG-fil fortsätter tills du träffar en stjärna,

492
00:41:43,330 --> 00:41:45,150
vilket indikeras av en ny färg.

493
00:41:45,150 --> 00:41:48,510
Du fortsätter sedan du träffar en annan stjärna, slår dig en JPEG,

494
00:41:48,510 --> 00:41:50,590
du fortsätter ända till slutet.

495
00:41:50,590 --> 00:41:53,180
Du är på sista bilden här, den rosa.

496
00:41:53,180 --> 00:41:58,220
Du går till slutet tills du träffar slutet av filen karaktär.

497
00:41:58,220 --> 00:42:00,820
Detta kommer att bli riktigt bra.

498
00:42:00,820 --> 00:42:03,170
>> Några viktiga takeaways här:

499
00:42:03,170 --> 00:42:06,670
Kortet Filen börjar inte med en JPEG,

500
00:42:06,670 --> 00:42:13,350
men när en JPEG startar, är alla JPEG lagrade sida vid sida till varandra.

501
00:42:17,520 --> 00:42:20,420
>> Vissa pseudokod för Recover.

502
00:42:20,420 --> 00:42:22,570
Först kommer vi att öppna våra kort fil,

503
00:42:22,570 --> 00:42:27,500
och det kommer att använda vår fil I / O funktioner.

504
00:42:27,500 --> 00:42:32,430
Vi kommer att upprepa följande process tills vi har nått slutet av filen.

505
00:42:32,430 --> 00:42:36,450
Vi kommer att läsa 512 byte i taget.

506
00:42:36,450 --> 00:42:39,180
Och vad jag sa här är att vi ska förvara den i en buffert,

507
00:42:39,180 --> 00:42:46,230
så i princip hålla fast vid de 512 byte tills vi vet exakt vad de ska göra med dem.

508
00:42:46,230 --> 00:42:50,300
Vad vi vill göra är att vi vill kontrollera om vi har träffat en stjärna eller inte.

509
00:42:50,300 --> 00:42:57,960
Om vi ​​har träffat en stjärna, om vi har drabbats en av utgångspunkterna sekvenser,

510
00:42:57,960 --> 00:42:59,980
då vet vi att vi har träffat en ny JPEG-fil.

511
00:42:59,980 --> 00:43:08,860
Vad vi vill göra är att vi kommer att vilja skapa en ny fil i vår pset4 katalog

512
00:43:08,860 --> 00:43:14,480
att fortsätta att göra den filen.

513
00:43:14,480 --> 00:43:18,220
Men också om vi har redan gjort en JPEG innan,

514
00:43:18,220 --> 00:43:25,620
då vi vill avsluta den filen och tryck på pset4 mappen

515
00:43:25,620 --> 00:43:29,780
där vi kommer att ha den filen lagras för om vi inte anger att vi har hamnat att JPEG-fil,

516
00:43:29,780 --> 00:43:37,290
då vi i grund och botten har en obestämd mängd. De JPEG tar aldrig slut.

517
00:43:37,290 --> 00:43:40,840
Så vi vill se till att när vi läser in en JPEG-fil och skriva det,

518
00:43:40,840 --> 00:43:46,590
Vi vill uttryckligen stänga den för att öppna nästa.

519
00:43:46,590 --> 00:43:48,430
Vi kommer att vilja kontrollera flera saker.

520
00:43:48,430 --> 00:43:52,880
Vi vill kontrollera om vi är i början av en ny JPEG med vår buffert

521
00:43:52,880 --> 00:43:56,780
och även om vi redan har hittat en JPEG innan

522
00:43:56,780 --> 00:44:03,930
eftersom det kommer att förändra din process något.

523
00:44:03,930 --> 00:44:07,880
Så då efter att du går igenom hela vägen och du träffar i slutet av filen,

524
00:44:07,880 --> 00:44:11,570
vad du vill göra är att du vill stänga alla filer som är öppna.

525
00:44:11,570 --> 00:44:14,100
Som förmodligen kommer att bli den sista JPEG-fil som du har,

526
00:44:14,100 --> 00:44:18,930
liksom det kort-fil som du har att göra med.

527
00:44:21,940 --> 00:44:28,670
>> Det sista hindret som vi måste ta itu är hur man faktiskt gör en JPEG-fil

528
00:44:28,670 --> 00:44:31,950
och hur man faktiskt driva det till mappen.

529
00:44:33,650 --> 00:44:39,850
Den pset kräver att varje JPEG som du hittar vara i följande format,

530
00:44:39,850 --> 00:44:43,990
där du har numret. JPG.

531
00:44:43,990 --> 00:44:50,750
Numret, även om det är 0, vi kallar det 000.jpg.

532
00:44:50,750 --> 00:44:55,730
När du hittar en JPEG i ditt program,

533
00:44:55,730 --> 00:44:58,040
du kommer att vilja namnge den i den ordning som det är finns.

534
00:44:58,040 --> 00:44:59,700
Vad betyder det här?

535
00:44:59,700 --> 00:45:03,530
Vi behöver sorts hålla reda på hur många vi har hittat

536
00:45:03,530 --> 00:45:08,680
och vad antalet varje JPEG bör vara.

537
00:45:08,680 --> 00:45:13,800
Här ska vi dra nytta av den sprintf funktionen.

538
00:45:13,800 --> 00:45:17,480
I likhet med printf, som bara typ av utskrifter ett värde ut i terminalen,

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

540
00:45:23,910 --> 00:45:30,870
Och så vad det skulle göra om jag hade sprintf, titel och sedan strängen där,

541
00:45:30,870 --> 00:45:36,660
Det skulle skriva ut 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Förutsatt att jag har stängt mina filer korrekt,

543
00:45:41,020 --> 00:45:47,210
som skulle innehålla filen som jag hade skrivit ut.

544
00:45:47,210 --> 00:45:50,320
Men en sak är att koden som jag har här

545
00:45:50,320 --> 00:45:53,360
inte riktigt uppfyller vad pset kräver.

546
00:45:53,360 --> 00:46:02,410
Den pset kräver att den andra JPEG-filen ska namnges 002 istället för bara 2.

547
00:46:02,410 --> 00:46:09,160
Så när du skriver ut namnet, så kanske du kanske vill ändra platshållaren något.

548
00:46:09,160 --> 00:46:18,140
>> Minns någon hur vi tillåter extra mellanslag när vi skriva ut något?

549
00:46:18,140 --> 00:46:22,530
Ja. >> [Elev] Du sätter en 3 mellan procenttecken och 2. >> Ja, perfekt.

550
00:46:22,530 --> 00:46:25,610
Du kommer att sätta en 3 i det här fallet eftersom vi vill plats för 3.

551
00:46:25,610 --> 00:46:32,590
% 3d skulle förmodligen ge dig 002.jpg istället för 2.

552
00:46:32,590 --> 00:46:40,120
Det första argumentet i sprintf funktionen är faktiskt en char array,

553
00:46:40,120 --> 00:46:42,520
som vi visste tidigare som strängar.

554
00:46:42,520 --> 00:46:50,700
De vilja, typ av mer som en tillfällig lagring, bara lagra den resulterande strängen.

555
00:46:50,700 --> 00:46:54,950
Du kommer inte riktigt att göra med detta, men du måste inkludera den.

556
00:46:54,950 --> 00:47:00,710
>> Att veta att varje filnamn har numret, som tar upp tre tecken,

557
00:47:00,710 --> 00:47:06,770
och då. jpg, hur länge denna array vara?

558
00:47:09,070 --> 00:47:14,310
Kasta ut ett nummer. Hur många tecken i rubriken, i namnet?

559
00:47:18,090 --> 00:47:26,320
Så det finns 3 hashtags, period, jpg. >> [Elev] 7. >> 7. Inte riktigt.

560
00:47:26,320 --> 00:47:32,000
Vi kommer att ha 8 eftersom vi vill tillåta null avslutare också.

561
00:47:45,340 --> 00:47:49,730
>> Slutligen, för att bara dra ut den process som du ska göra för Recover,

562
00:47:49,730 --> 00:47:55,420
du har någon början information.

563
00:47:55,420 --> 00:48:02,460
Du fortsätter tills du hittar början på en JPEG-fil,

564
00:48:02,460 --> 00:48:07,900
och som kan vara antingen en av två start sekvenser.

565
00:48:07,900 --> 00:48:12,510
Du håller på att läsa. Varje snedstreck här representerar 512 bytes.

566
00:48:12,510 --> 00:48:22,630
Du håller på att läsa, fortsätt läsa tills du stöter annan startsekvens.

567
00:48:22,630 --> 00:48:29,790
När du har det, du avslutar den aktuella JPEG - i det här fallet är det den röda,

568
00:48:29,790 --> 00:48:31,030
så du vill avsluta den.

569
00:48:31,030 --> 00:48:35,540
Du vill sprintf namnet på det i din pset4 mapp,

570
00:48:35,540 --> 00:48:41,580
då du vill öppna ett nytt JPEG och sedan hålla på att läsa

571
00:48:41,580 --> 00:48:46,370
tills du stöter på nästa.

572
00:48:46,370 --> 00:48:49,040
Fortsätta läsa, fortsätta läsa,

573
00:48:49,040 --> 00:48:56,290
och slutligen, så småningom kommer du att nå slutet av filen,

574
00:48:56,290 --> 00:49:00,360
och så du vill stänga den sista JPEG som du arbetade med,

575
00:49:00,360 --> 00:49:08,380
sprintf det i din pset4 mapp och sedan titta på alla de bilder som du har fått.

576
00:49:08,380 --> 00:49:12,050
Dessa bilder är faktiskt bilder på CS50 anställda,

577
00:49:12,050 --> 00:49:16,430
och så det är där bonusen roliga delen av pset kommer i

578
00:49:16,430 --> 00:49:26,310
är att du tävlar i dina sektioner för att hitta TF på bilderna

579
00:49:26,310 --> 00:49:34,610
och ta bilder med dem för att bevisa att du har gjort pset

580
00:49:34,610 --> 00:49:37,030
och så att du kan se vilka anställda är på bilderna.

581
00:49:37,030 --> 00:49:41,510
Så då du tar bilder med personalen. Ibland måste du jaga dem.

582
00:49:41,510 --> 00:49:44,680
Förmodligen några av dem kommer att försöka springa ifrån dig.

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

584
00:49:47,320 --> 00:49:51,190
Detta pågår. Det är inte på grund när pset beror.

585
00:49:51,190 --> 00:49:53,340
Tidsfristen kommer att meddelas i spec.

586
00:49:53,340 --> 00:49:58,060
Då tillsammans med din sektion, tar beroende avsnitt de bilderna

587
00:49:58,060 --> 00:50:04,430
med de mest anställda kommer att vinna en ganska häftigt pris.

588
00:50:04,430 --> 00:50:08,890
Det är typ av incitament för att få din pset4 slutade så snabbt som möjligt

589
00:50:08,890 --> 00:50:10,820
för då kan du komma till saken

590
00:50:10,820 --> 00:50:14,570
jaga alla de olika CS50 anställda.

591
00:50:14,570 --> 00:50:17,500
Det är inte obligatoriskt, men så när du får bilderna,

592
00:50:17,500 --> 00:50:20,310
då du är klar med pset4.

593
00:50:20,310 --> 00:50:23,970
>> Och jag är klar med Walkthrough 4, så tack alla för att ni kom.

594
00:50:23,970 --> 00:50:29,330
Lycka till med kriminalteknik. [Applåder]

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