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

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

3
00:00:05,000 --> 00:00:07,340
[Dit is CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
Oke. Hallo, iedereen, en welkom bij Walkthrough 4.

5
00:00:11,670 --> 00:00:14,270
>> Vandaag is onze PSET is Forensics.

6
00:00:14,270 --> 00:00:18,080
Forensics is echt een leuke PSET die inhoudt dat het omgaan met bitmap-bestanden

7
00:00:18,080 --> 00:00:21,550
om te ontdekken wie een misdrijf.

8
00:00:21,550 --> 00:00:24,200
Dan gaan we een aantal bitmap bestanden vergroten of verkleinen,

9
00:00:24,200 --> 00:00:27,780
dan kunnen we gaan ook te maken met een echt leuke deel genaamd Recover,

10
00:00:27,780 --> 00:00:31,160
waarin we in feite gaf een geheugenkaart

11
00:00:31,160 --> 00:00:34,350
waarin iemand heeft per ongeluk verwijderde al hun bestanden,

12
00:00:34,350 --> 00:00:38,860
en we zijn gevraagd om de bestanden te herstellen.

13
00:00:38,860 --> 00:00:42,910
>> Maar eerst, voordat we in de PSET, ik wil gewoon iedereen feliciteren.

14
00:00:42,910 --> 00:00:45,230
We staan ​​op het punt in het midden van deze cursus.

15
00:00:45,230 --> 00:00:50,070
Quiz 0 is achter ons, en we zijn op pset4, dus in wezen, we zijn halverwege.

16
00:00:50,070 --> 00:00:55,490
We hebben een lange weg afgelegd als je kijkt terug naar je psets, pset0 en pset1,

17
00:00:55,490 --> 00:00:57,300
dus feliciteer jezelf over,

18
00:00:57,300 --> 00:01:00,760
en we gaan krijgen in een aantal echt leuke dingen.

19
00:01:00,760 --> 00:01:07,070
>> Dus onze toolbox voor deze PSET, opnieuw, in plaats van het runnen van sudo yum-y update,

20
00:01:07,070 --> 00:01:13,890
we in staat om alleen nog maar update50 als je op versie 17.3 en hoger van het apparaat.

21
00:01:13,890 --> 00:01:17,380
Dus zorg ervoor dat update50 lopen - het is een stuk makkelijker, een paar minder tekens -

22
00:01:17,380 --> 00:01:20,640
om ervoor te zorgen dat je op de laatste versie van het apparaat.

23
00:01:20,640 --> 00:01:25,410
Vooral is het belangrijk om update50 wanneer we beginnen met CS50 Check.

24
00:01:25,410 --> 00:01:28,700
Dus zorg ervoor dat je dat doet.

25
00:01:28,700 --> 00:01:30,760
>> Voor alle secties van deze PSET,

26
00:01:30,760 --> 00:01:34,350
we gaan te maken hebben met file-en uitgangen, file I / O.

27
00:01:34,350 --> 00:01:38,140
We gaan te gaan over een heleboel programma's die omgaan met arrays

28
00:01:38,140 --> 00:01:40,350
verwijzen naar bestanden en dat soort dingen,

29
00:01:40,350 --> 00:01:43,050
dus we willen ervoor zorgen dat we echt vertrouwd en comfortabel

30
00:01:43,050 --> 00:01:47,990
het omgaan met hoe je input en output naar bestanden.

31
00:01:47,990 --> 00:01:52,080
>> In de verdeelsleutel voor deze PSET is een bestand met de naam copy.c,

32
00:01:52,080 --> 00:01:55,280
en dat is wat we gaan vinden zal zijn echt nuttig voor ons

33
00:01:55,280 --> 00:02:00,340
want we gaan om uiteindelijk daadwerkelijk het kopiëren van het bestand copy.c

34
00:02:00,340 --> 00:02:05,350
en net het iets wijzigen kunnen de eerste twee delen van het probleem te verwezenlijken.

35
00:02:05,350 --> 00:02:09,030
>> En zo dan als ik al zei, hebben we te maken met bitmaps als JPEG-bestanden.

36
00:02:09,030 --> 00:02:13,170
Dus echt begrijpen van de structuur van hoe deze bestanden worden georganiseerd,

37
00:02:13,170 --> 00:02:16,170
hoe kunnen we echt vertalen 0s en 1s in structs

38
00:02:16,170 --> 00:02:19,040
en de dingen die we eigenlijk kunnen begrijpen en interpreteren en bewerken,

39
00:02:19,040 --> 00:02:21,000
dat zal echt belangrijk,

40
00:02:21,000 --> 00:02:25,970
dus in te gaan op JPEG-en bitmap-bestanden en het begrijpen van de structuur van deze.

41
00:02:25,970 --> 00:02:30,780
>> Pset4 zoals gebruikelijk start met een vragen.

42
00:02:30,780 --> 00:02:36,600
Die zal zich bezighouden met file I / O en krijg je gewend aan dat.

43
00:02:36,600 --> 00:02:42,520
Dan deel 1 is Whodunit, waarin u een bitmap-bestand gegeven

44
00:02:42,520 --> 00:02:45,630
dat ziet er een soort rode stippen allemaal voorbij.

45
00:02:45,630 --> 00:02:52,180
En dan eigenlijk wat we gaan doen is dit bestand en net iets te bewerken

46
00:02:52,180 --> 00:02:54,010
in een versie die we kunnen lezen.

47
00:02:54,010 --> 00:02:56,000
In wezen, als we eenmaal klaar, zullen we hetzelfde bestand hebben,

48
00:02:56,000 --> 00:03:02,630
tenzij wij u in staat om de verborgen boodschap verborgen door al die rode stippen te zien.

49
00:03:02,630 --> 00:03:07,310
Dan Resize is een programma dat, gegeven een bestand

50
00:03:07,310 --> 00:03:11,490
en dan de naam van het bestand dat het systeem voert en daarna voorzien van een nummer en,

51
00:03:11,490 --> 00:03:16,850
zal dat bitmap eigenlijk verkleinen door die geheel getal.

52
00:03:16,850 --> 00:03:19,240
Dan tot slot, hebben we de Recover PSET.

53
00:03:19,240 --> 00:03:24,160
We krijgen een geheugenkaart en vervolgens moeten alle foto's terug te

54
00:03:24,160 --> 00:03:25,920
die per ongeluk zijn verwijderd,

55
00:03:25,920 --> 00:03:31,420
maar, zoals we leren, niet echt verwijderd en verwijderd uit het bestand;

56
00:03:31,420 --> 00:03:38,470
we gewoon een soort van verloren, waar ze in het bestand, maar we gaan dat herstellen.

57
00:03:38,470 --> 00:03:44,950
>> Geweldig. Dus ga in het dossier van I / O-specifiek, dit zijn een hele lijst van functies die je zult gebruiken.

58
00:03:44,950 --> 00:03:49,840
Je hebt al gezien een beetje de basis van fopen, fread, en fwrite,

59
00:03:49,840 --> 00:03:54,350
maar we gaan verder kijken naar een aantal file I / O-functies zoals fputc,

60
00:03:54,350 --> 00:03:56,930
waarin je gewoon schrijven een teken per keer,

61
00:03:56,930 --> 00:04:02,000
naar fseek, waar u soort verplaatst u de positie-indicator voor-en achteruit,

62
00:04:02,000 --> 00:04:05,770
en nog wat anderen. Maar we zullen gaan in dat een beetje later tijdens de PSET.

63
00:04:08,050 --> 00:04:13,100
>> Dus eerst, om gewoon in het dossier van I / O voordat we ingaan op de PSET,

64
00:04:13,100 --> 00:04:19,860
om een ​​bestand te openen, bijvoorbeeld, is wat je moet doen in feite zet je een verwijzing naar dat bestand.

65
00:04:19,860 --> 00:04:22,710
Dus hebben we een FILE * pointer.

66
00:04:22,710 --> 00:04:27,140
In dit geval, ik noemde het een in pointer, want dat gaat worden mijn infile.

67
00:04:27,140 --> 00:04:33,340
En dus ga ik om de functie fopen en vervolgens de naam van het bestand te gebruiken

68
00:04:33,340 --> 00:04:36,360
en dan de modus waarin ik ga te maken hebben met het bestand.

69
00:04:36,360 --> 00:04:42,080
Dus er is "r" in dit geval voor het lezen, "w" voor het schrijven, en vervolgens "a" voor het toevoegen.

70
00:04:42,080 --> 00:04:44,270
Bijvoorbeeld, wanneer je te maken hebt met een infile

71
00:04:44,270 --> 00:04:47,310
en alles wat je wilt doen is lezen de bits en bytes daar opgeslagen,

72
00:04:47,310 --> 00:04:50,420
dan ben je waarschijnlijk gaat te willen "r" als je wilt gebruiken.

73
00:04:50,420 --> 00:04:54,520
Als u wilt eigenlijk schrijven, soort van een nieuw bestand,

74
00:04:54,520 --> 00:04:57,220
dan wat we gaan doen is gaan we het nieuwe bestand te openen

75
00:04:57,220 --> 00:05:02,410
en gebruik de "w"-modus voor het schrijven.

76
00:05:02,410 --> 00:05:07,540
>> Dus toen je eigenlijk aan het lezen bent in de bestanden, de structuur is als volgt.

77
00:05:07,540 --> 00:05:14,930
Eerst moet je ook de pointer naar de struct dat bevat de bytes die je aan het lezen bent.

78
00:05:14,930 --> 00:05:19,830
Dus dat gaat de eindlocatie van de bytes die u nu leest zijn.

79
00:05:19,830 --> 00:05:23,360
Je gaat dan naar de grootte aan te geven, zoals in principe hoeveel bytes

80
00:05:23,360 --> 00:05:30,100
uw programma moet in lezen naar het bestand, de grootte in principe een element is,

81
00:05:30,100 --> 00:05:32,620
en dan zul je om aan te geven hoeveel elementen u wilt lezen.

82
00:05:32,620 --> 00:05:34,980
En dan tot slot, moet je weten waar je het lezen van,

83
00:05:34,980 --> 00:05:37,580
zodat dat gaat je in aanwijzer te zijn.

84
00:05:37,580 --> 00:05:41,780
Ik kleurcode deze omdat fread is ook zeer vergelijkbaar met fwrite,

85
00:05:41,780 --> 00:05:47,050
behalve dat u wilt ervoor zorgen dat u de juiste volgorde te gebruiken,

86
00:05:47,050 --> 00:05:51,960
Zorg ervoor dat je eigenlijk aan het schrijven bent naar of het lezen van het juiste bestand.

87
00:05:54,910 --> 00:05:58,610
>> Kortom, zoals voorheen, als we de grootte van het element en het aantal elementen,

88
00:05:58,610 --> 00:06:00,600
dan kunnen we hier spelen een beetje rond.

89
00:06:00,600 --> 00:06:06,810
Zeggen dat ik een hond struct en dus dan wil ik twee honden tegelijk lezen.

90
00:06:06,810 --> 00:06:12,450
Wat ik zou doen is de grootte van een element te zeggen gaat om de grootte van een hond te zijn

91
00:06:12,450 --> 00:06:14,770
en ik ga om daadwerkelijk te lezen twee van hen.

92
00:06:14,770 --> 00:06:18,290
Als alternatief is wat ik kon doen zeg ik ga gewoon een element lezen

93
00:06:18,290 --> 00:06:21,340
en dat ene element zal de grootte van twee honden.

94
00:06:21,340 --> 00:06:24,320
Dus dat is analoog hoe je kan soort van zaken rond met de grootte en het aantal

95
00:06:24,320 --> 00:06:28,250
afhankelijk van wat meer intuïtief aan u.

96
00:06:28,250 --> 00:06:30,810
>> Oke. Dus nu komen we bij het schrijven van bestanden.

97
00:06:30,810 --> 00:06:36,880
Wanneer u een bestand wilt schrijven, het eerste argument is eigenlijk waar je het lezen van.

98
00:06:36,880 --> 00:06:42,050
Dus dat is eigenlijk de gegevens die u gaat schrijven in het bestand,

99
00:06:42,050 --> 00:06:44,490
die de aanwijsstok eind.

100
00:06:44,490 --> 00:06:47,670
Dus als je te maken hebt met de PSET, zorg ervoor dat je niet in de war raken.

101
00:06:47,670 --> 00:06:50,480
Misschien de definities naast elkaar.

102
00:06:50,480 --> 00:06:58,090
U kunt trekken de definities in de handleiding door man en dan fwrite, bijvoorbeeld,

103
00:06:58,090 --> 00:06:59,950
in de terminal, of u kunt terug te verwijzen naar deze dia

104
00:06:59,950 --> 00:07:03,570
en zorg ervoor dat je de juiste gebruikt.

105
00:07:03,570 --> 00:07:08,700
Dus nogmaals, voor fwrite, wanneer u een bestand hebt dat u wilt schrijven in,

106
00:07:08,700 --> 00:07:14,290
dat gaat de laatste argument te zijn en dat gaat met een pointer naar dat bestand te zijn.

107
00:07:14,290 --> 00:07:18,670
Dus dan is dat de manier waarop we omgaan met het schrijven van misschien wel enkele bytes in een tijd,

108
00:07:18,670 --> 00:07:21,820
maar zeggen dat je gewoon wilt schrijven in slechts een enkel karakter.

109
00:07:21,820 --> 00:07:25,940
Zoals we later zullen zien in dit voorbeeld, in de bitmaps we moeten dat gebruiken.

110
00:07:25,940 --> 00:07:32,180
Dat is wanneer we kunnen gebruiken fputc wezen zomaar een teken per keer, chr,

111
00:07:32,180 --> 00:07:37,050
in de file-pointer, en dat is onze aanwijsstok daar.

112
00:07:38,700 --> 00:07:41,560
Dus dan wanneer we vragen of schrijven in een bestand,

113
00:07:41,560 --> 00:07:44,690
het bestand is het bijhouden van waar we zijn.

114
00:07:44,690 --> 00:07:47,810
Dus het is een soort van de cursor, de positie-indicator.

115
00:07:47,810 --> 00:07:54,330
En dus wanneer we schrijven of lezen weer in een bestand,

116
00:07:54,330 --> 00:07:56,760
het bestand daadwerkelijk onthoudt wanneer het,

117
00:07:56,760 --> 00:07:59,270
en zo verder waar de cursor.

118
00:07:59,270 --> 00:08:03,970
Dit kan nuttig zijn wanneer u wilt, zeg, gelezen in een bepaald bedrag om iets te doen

119
00:08:03,970 --> 00:08:06,160
en dan lezen in de volgende hoeveelheid,

120
00:08:06,160 --> 00:08:10,700
maar soms kunnen we terug willen of daadwerkelijk te gaan van een bepaalde referentiewaarde te starten.

121
00:08:10,700 --> 00:08:16,870
Dus dan is de fseek functie, wat het doet is het ons in staat stelt om de cursor in een bepaald bestand

122
00:08:16,870 --> 00:08:19,680
een aantal bytes.

123
00:08:19,680 --> 00:08:24,260
En dan wat we moeten doen, is bepalen waar de referentiewaarde is.

124
00:08:24,260 --> 00:08:31,520
Dus of het beweegt vooruit of achteruit vanaf waar de cursor momenteel,

125
00:08:31,520 --> 00:08:35,750
of we kunnen aangeven dat het gewoon zou moeten in gaan vanaf het begin van het bestand

126
00:08:35,750 --> 00:08:37,090
of vanaf het einde van het bestand.

127
00:08:37,090 --> 00:08:41,230
En zodat je kan passeren in negatieve of positieve waarden bedrag,

128
00:08:41,230 --> 00:08:44,960
en dat zal soort verplaatst u de cursor naar voren of naar achteren.

129
00:08:46,170 --> 00:08:51,920
>> Voordat we in de andere psets, vragen over file I / O?

130
00:08:53,860 --> 00:08:59,990
Oke. Als we in meer voorbeelden, voel je vrij om me te stoppen voor vragen.

131
00:08:59,990 --> 00:09:06,930
>> Dus in Whodunit, je gaf een bitmap-bestand vergelijkbaar met deze rode op de dia,

132
00:09:06,930 --> 00:09:14,510
en het ziet er zo uit - een bos van rode stippen - en je niet echt weet wat er geschreven.

133
00:09:14,510 --> 00:09:23,310
Als je scheel, kunt u in staat om een ​​lichte blauwachtige kleur in het midden te zien.

134
00:09:23,310 --> 00:09:26,270
In essentie, dat is waar de tekst wordt opgeslagen.

135
00:09:26,270 --> 00:09:30,270
Er was een moord die gebeurde, en we moeten om uit te vinden wie het gedaan heeft.

136
00:09:30,270 --> 00:09:36,760
Om dat te doen, moeten we soort van om te zetten dit beeld in een leesbaar formaat.

137
00:09:36,760 --> 00:09:42,740
Als jullie ooit ontmoet dit, soms zou er weinig kits

138
00:09:42,740 --> 00:09:48,510
waar zou je een vergrootglas met een rode folie. Iedereen? Ja.

139
00:09:48,510 --> 00:09:52,770
Dus je zou handen iets als dit, zou je een vergrootglas

140
00:09:52,770 --> 00:09:58,130
met de rode film over, zou je het over de afbeelding,

141
00:09:58,130 --> 00:10:03,410
en je zou in staat zijn om het bericht daarin verborgen.

142
00:10:03,410 --> 00:10:07,080
We hebben geen een vergrootglas met rode film, dus in plaats daarvan gaan we soort van onze eigen

143
00:10:07,080 --> 00:10:09,060
in deze PSET.

144
00:10:09,060 --> 00:10:15,760
En zodat de gebruiker gaat om input detectiveverhaal, dan is de aanwijzing,. Bmp,

145
00:10:15,760 --> 00:10:18,800
dus dat is de infile, dat is de rode stip bericht,

146
00:10:18,800 --> 00:10:23,550
en dan ze zeggen verdict.bmp gaat onze outfile zijn.

147
00:10:23,550 --> 00:10:27,900
Dus het gaat om een ​​nieuwe bitmapafbeelding vergelijkbaar met de aanwijzing een te maken

148
00:10:27,900 --> 00:10:32,600
behalve in een leesbaar formaat, waar we kunnen zien de verborgen boodschap.

149
00:10:32,600 --> 00:10:37,550
>> Omdat we gaan te maken hebben met het bewerken en manipuleren van bitmaps van een soort,

150
00:10:37,550 --> 00:10:42,400
we gaan voor soort duik in in de structuur van deze bitmap bestanden.

151
00:10:42,400 --> 00:10:48,130
We gingen op deze een beetje in college, maar laten we eens kijken naar hen wat meer.

152
00:10:48,130 --> 00:10:51,740
Bitmaps zijn in wezen slechts een arrangement van bytes

153
00:10:51,740 --> 00:10:55,790
waar we aangegeven welke bytes betekenen wat.

154
00:10:55,790 --> 00:11:00,540
Dus hier is een soort een kaart van de bitmapafbeelding

155
00:11:00,540 --> 00:11:08,550
te zeggen dat het begint met een aantal header files, begint met wat informatie in.

156
00:11:08,550 --> 00:11:16,540
Je ziet dat op ongeveer byte nummer 14 van de grootte wordt aangegeven van de bitmapafbeelding,

157
00:11:16,540 --> 00:11:18,520
en het blijft maar door.

158
00:11:18,520 --> 00:11:23,810
Maar dan wat we echt geïnteresseerd in hier begint rond byte nummer 54.

159
00:11:23,810 --> 00:11:26,060
We hebben deze RGB triples.

160
00:11:26,060 --> 00:11:30,760
Wat dat gaat doen, is bevat de eigenlijke pixels, de kleurwaarden.

161
00:11:30,760 --> 00:11:35,950
Alles wat boven die in de header is wat informatie

162
00:11:35,950 --> 00:11:41,240
overeenkomt met de grootte van het beeld, de breedte van het beeld en de hoogte.

163
00:11:41,240 --> 00:11:44,930
Als we gaan later in padding op, we zien waarom de grootte van het beeld

164
00:11:44,930 --> 00:11:48,670
kan anders zijn dan de breedte of de hoogte.

165
00:11:48,670 --> 00:11:54,240
Dus dan naar deze vertegenwoordigen - deze bitmapafbeeldingen zijn sequenties van bytes -

166
00:11:54,240 --> 00:11:59,370
wat we kunnen doen is zeggen: oke, ik ga om te onthouden dat op index 14,

167
00:11:59,370 --> 00:12:03,380
dat is waar de grootte is, bijvoorbeeld, maar in plaats daarvan wat we gaan doen om dit gemakkelijker te maken

168
00:12:03,380 --> 00:12:06,020
is ingekapseld in een struct.

169
00:12:06,020 --> 00:12:08,880
En dus hebben we twee structs voor ons gemaakt, een BITMAPFILEHEADER

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

171
00:12:10,440 --> 00:12:14,840
en dus wanneer we lezen in dat bestand, standaard het zal gaan in orde zijn,

172
00:12:14,840 --> 00:12:22,360
en dus met het oog het is ook gaat in te vullen in variabelen zoals biWidth en biSize.

173
00:12:25,270 --> 00:12:31,230
En tenslotte, wordt elke pixel vertegenwoordigd door drie bytes.

174
00:12:31,230 --> 00:12:35,500
De eerste is de hoeveelheid blauw in de pixel, de tweede is de hoeveelheid groen,

175
00:12:35,500 --> 00:12:41,120
en tenslotte de hoeveelheid rood, waarbij 0 wezen geen blauw of groen geen of geen rood

176
00:12:41,120 --> 00:12:43,720
en dan ff is de maximale waarde.

177
00:12:43,720 --> 00:12:46,800
Dit zijn hexadecimale waarden.

178
00:12:46,800 --> 00:12:53,870
Dus dan als we ff0000 dan die overeenkomt met de maximum hoeveelheid blauw

179
00:12:53,870 --> 00:12:58,890
en dan geen groen en geen rood, dus dan zou dat ons een blauwe pixel.

180
00:12:58,890 --> 00:13:04,190
Dan als we ff's over de hele linie, dan betekent dat dat we een witte pixel te hebben.

181
00:13:04,190 --> 00:13:11,370
Dit is een soort tegenovergestelde meestal als we zeggen RGB. Het is eigenlijk aan de hand BGR.

182
00:13:12,750 --> 00:13:18,990
>> Dus als we echt kijken naar een voorbeeld van een bitmapafbeelding - laat me trek een hier boven.

183
00:13:31,560 --> 00:13:33,830
Het is een beetje klein.

184
00:13:39,890 --> 00:13:47,840
Ik ben in te zoomen, en we kunnen zien dat het korrelig. Het lijkt erop dat blokken van kleur.

185
00:13:47,840 --> 00:13:50,110
Je hebt witte blokken en dan rode blokken.

186
00:13:50,110 --> 00:13:53,700
Als je speelt in Microsoft Paint, bijvoorbeeld, kon je zoiets

187
00:13:53,700 --> 00:13:58,960
door eigenlijk gewoon schilderen bepaalde pleinen in een bepaalde volgorde.

188
00:13:58,960 --> 00:14:08,060
Dus wat resulteert dit in de bitmap is als volgt.

189
00:14:08,060 --> 00:14:15,710
Hier hebben we eerste witte pixels, dat alle 6 zijn f, en dan hebben we rode pixels,

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

191
00:14:19,910 --> 00:14:27,940
En dus is de volgorde van de bytes die we hebben geeft aan hoe de bitmapafbeelding eruit komt te zien.

192
00:14:27,940 --> 00:14:32,230
Dus wat ik hier heb gedaan is gewoon uitgeschreven al die bytes en vervolgens gekleurd in het rood

193
00:14:32,230 --> 00:14:37,550
zodat u kunt soort te zien, als je scheel een beetje, hoe dat soort van een smiley aangeeft.

194
00:14:40,180 --> 00:14:46,390
>> De manier waarop bitmapafbeeldingen werk is dat ik voor ogen het in feite als een raster.

195
00:14:46,390 --> 00:14:54,940
En dus standaard, elke rij van het raster moet een veelvoud van 4 bytes.

196
00:15:00,520 --> 00:15:07,060
Als we kijken naar een bitmapafbeelding, je bent het invullen van elke waarde.

197
00:15:07,060 --> 00:15:17,370
Bijvoorbeeld, zou je hier een rode, een groene hier, een blauwe hier,

198
00:15:17,370 --> 00:15:24,950
maar je moet ervoor zorgen dat het beeld wordt gevuld met een veelvoud van vier bytes.

199
00:15:24,950 --> 00:15:32,200
Dus als ik wil dat mijn beeld wel drie blokken breed, dan zou ik naar een lege waarde toe te

200
00:15:32,200 --> 00:15:35,640
in de laatste om er een veelvoud van vier.

201
00:15:35,640 --> 00:15:39,530
Dus dan zou ik toevoegen in iets wat we noemen padding.

202
00:15:39,530 --> 00:15:43,750
Ik ga gewoon om aan te geven dat er met een x.

203
00:15:44,920 --> 00:15:54,160
Nu zeggen dat we willen een beeld dat is 7 pixels lang, bijvoorbeeld.

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

205
00:16:04,750 --> 00:16:07,000
en dat alles wordt ingevuld met kleur.

206
00:16:07,000 --> 00:16:10,620
De manier waarop bitmap-afbeeldingen te werken is dat we een 8e nodig hebben.

207
00:16:10,620 --> 00:16:12,460
Nu hebben we 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
We hebben 8 ruimten voor de bitmapafbeelding om volledig te kunnen lezen.

209
00:16:19,360 --> 00:16:25,600
Dus wat we moeten doen is toe te voegen in slechts een beetje padding

210
00:16:25,600 --> 00:16:29,430
ervoor zorgen dat alle breedtes uniformiteit

211
00:16:29,430 --> 00:16:34,260
en dat alle breedten een veelvoud van 4.

212
00:16:42,110 --> 00:16:47,310
En dus heb ik eerder aangegeven, padden als een x of een kronkelende lijn,

213
00:16:47,310 --> 00:16:53,880
maar in de feitelijke bitmapafbeeldingen de vulling wordt door een hexadecimale 0.

214
00:16:53,880 --> 00:16:57,340
Dus dat zou een enkel karakter, 0 zijn.

215
00:16:58,980 --> 00:17:06,329
Wat zou van pas komen is de XXD commando.

216
00:17:06,329 --> 00:17:11,220
Wat het doet is eigenlijk laat zien, zoals vergelijkbaar met wat ik gedaan heb voordat met de smiley

217
00:17:11,220 --> 00:17:15,630
toen ik eigenlijk uitgeprint wat elke kleur zou zijn voor de pixel

218
00:17:15,630 --> 00:17:21,800
en dan een kleurcode het, wanneer u XXD met de volgende commando's,

219
00:17:21,800 --> 00:17:28,670
dan is het ook daadwerkelijk uit te printen wat de kleuren zijn voor diegenen pixels.

220
00:17:28,670 --> 00:17:33,810
Wat u moet doen is hier geef ik aan, net als de-s 54

221
00:17:33,810 --> 00:17:36,530
zegt dat ik ga beginnen bij de 54e byte

222
00:17:36,530 --> 00:17:40,820
want voor dat herinneren als we terugkijken naar de kaart van de bitmaps,

223
00:17:40,820 --> 00:17:42,690
dat is alles wat de header-informatie en dat soort dingen.

224
00:17:42,690 --> 00:17:46,280
Maar wat we echt zorgen over de feitelijke pixels dat de kleur aan te geven.

225
00:17:46,280 --> 00:17:52,700
Dus door het toevoegen van die vlag,-s 54, dan zijn we in staat om de kleurwaarden te zien.

226
00:17:52,700 --> 00:17:56,020
En maak je geen zorgen over de ingewikkelde vlaggen en dat soort dingen.

227
00:17:56,020 --> 00:18:05,020
In het probleem set spec, dan moet je aanwijzingen over hoe te gebruiken XXD om de pixels weer te geven.

228
00:18:07,070 --> 00:18:15,590
Dus als je hier ziet, is het soort van ziet eruit als een groen vierkant, dit kleine ding.

229
00:18:15,590 --> 00:18:23,610
Ik heb een kleurcodering de 00FF00 als eigenlijk zeggen geen blauwe, veel groen, en geen rode.

230
00:18:23,610 --> 00:18:26,370
Zodat die overeenkomt met groen.

231
00:18:26,370 --> 00:18:31,920
Zoals je hier ziet, zien we een groene rechthoek.

232
00:18:31,920 --> 00:18:36,660
Deze groene rechthoek ligt op slechts 3 pixels breed, dus dan wat we moeten doen

233
00:18:36,660 --> 00:18:44,350
om ervoor te zorgen dat het beeld een veelvoud van 4 breed is toe te voegen in extra vulling.

234
00:18:44,350 --> 00:18:49,460
En dus dan is dat hoe je deze 0s hier te zien.

235
00:18:49,460 --> 00:18:54,510
Dit ook daadwerkelijk het gevolg zijn van uw Resize PSET,

236
00:18:54,510 --> 00:19:01,350
in wezen het nemen van de kleine bitmap en dan vergroten door 4.

237
00:19:01,350 --> 00:19:09,380
Wat we dus zien is dat eigenlijk deze afbeelding is 12 pixels breed, maar 12 is een veelvoud van 4,

238
00:19:09,380 --> 00:19:12,940
en dus hebben we eigenlijk niet zie geen 0s aan het eind omdat we geen behoefte aan een toe te voegen

239
00:19:12,940 --> 00:19:19,070
want het is volledig opgevuld. Het heeft geen meer ruimte.

240
00:19:20,720 --> 00:19:23,470
>> Oke. Heeft u vragen over padding?

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

242
00:19:27,460 --> 00:19:32,520
>> Zoals ik al zei, de bitmaps zijn slechts een sequentie van bytes.

243
00:19:32,520 --> 00:19:39,170
En dus wat we hebben is in plaats van om het bijhouden van precies welke aantal byte

244
00:19:39,170 --> 00:19:47,050
komt overeen met een specifiek element, we eigenlijk hebben een struct die vertegenwoordigen.

245
00:19:47,050 --> 00:19:50,930
Dus wat we hebben is een RGBTRIPLE struct.

246
00:19:50,930 --> 00:19:54,590
Wanneer u een exemplaar van een RGB-triple hebben,

247
00:19:54,590 --> 00:20:00,970
want dit is een type te definiëren struct, dan kunt u toegang krijgen tot de rgbtBlue variabele,

248
00:20:00,970 --> 00:20:09,520
eveneens de groene en rode variabelen, die aangeeft hoeveel blauw, groen, en rood,

249
00:20:09,520 --> 00:20:11,580
respectievelijk je hebt.

250
00:20:11,580 --> 00:20:16,800
>> Dus als we de blauwe variabele ingesteld op 0, de groene set om ff,

251
00:20:16,800 --> 00:20:22,060
Dit is de maximale waarde die u kan hebben, en daarna de rode variabele ingesteld op 0,

252
00:20:22,060 --> 00:20:27,870
dan welke kleur zou deze bijzondere RGB drievoudige vertegenwoordigen? >> [Student] Green.

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

254
00:20:29,150 --> 00:20:34,480
Het zal nuttig zijn om te weten dat wanneer u een exemplaar van een RGB-triple hebben,

255
00:20:34,480 --> 00:20:41,340
kun je eigenlijk toegang tot de hoeveelheid kleur - blauw, groen en rood - afzonderlijk.

256
00:20:43,350 --> 00:20:54,900
>> Nu we hebben gesproken over de structuur van dat, laten we een kijkje nemen op het BMP-bestand.

257
00:20:54,900 --> 00:20:57,870
Dit zijn structs voor u gemaakt.

258
00:20:57,870 --> 00:21:01,820
Hier hebben we een BITMAPFILEHEADER struct.

259
00:21:01,820 --> 00:21:07,610
Van belang is de grootte.

260
00:21:07,610 --> 00:21:12,660
Later hebben we de info-header, die een paar dingen die interessant zijn heeft voor ons,

261
00:21:12,660 --> 00:21:15,480
namelijk de grootte, de breedte en de hoogte.

262
00:21:15,480 --> 00:21:19,170
Als we gaan naar later, als je leest in het bestand,

263
00:21:19,170 --> 00:21:25,500
het leest automatisch in omdat we de volgorde hetzelfde te zijn.

264
00:21:25,500 --> 00:21:31,990
Dus de biSize bevat de juiste bytes die overeenkomen met de werkelijke grootte van de afbeelding.

265
00:21:34,700 --> 00:21:40,500
En dan hier, ten slotte, zoals we hebben het gehad over, wij hebben de RGBTRIPLE typedef struct.

266
00:21:40,500 --> 00:21:46,840
We hebben een rgbtBlue, Groen en Rood ermee verbonden zijn.

267
00:21:48,210 --> 00:21:49,340
>> Geweldig. Oke.

268
00:21:49,340 --> 00:21:56,360
Nu we begrijpen bitmaps een beetje begrijpen dat we een bestand header hebben

269
00:21:56,360 --> 00:22:00,790
en een info-header die ermee verbonden zijn en dan na dat, hebben we de interessante dingen

270
00:22:00,790 --> 00:22:05,110
van de kleuren en deze kleuren worden vertegenwoordigd door RGBTRIPLE structs,

271
00:22:05,110 --> 00:22:12,710
en die op hun beurt zijn drie waarden geassocieerd met de blauwe, groene en rode.

272
00:22:12,710 --> 00:22:17,270
>> Dus nu kunnen we soort van denken over het herstellen van een beetje.

273
00:22:17,270 --> 00:22:20,130
Sorry. Denk na over Whodunit.

274
00:22:20,130 --> 00:22:25,750
Wanneer we onze idee-bestand hebben, dan wat we willen doen, is te lezen in het pixel voor pixel

275
00:22:25,750 --> 00:22:33,860
en dan een of andere manier te veranderen die pixels, zodat we het kunnen uitvoeren in een leesbaar formaat.

276
00:22:33,860 --> 00:22:41,020
En dus om het uit te voeren, gaan we pixel schrijven voor pixel in de verdict.bmp bestand.

277
00:22:41,020 --> 00:22:45,120
Dat is een soort van een veel te doen. We realiseren ons dat.

278
00:22:45,120 --> 00:22:49,860
Dus wat we hebben gedaan is dat we je eigenlijk voorzien copy.c.

279
00:22:49,860 --> 00:22:57,610
Wat copy.c doet is gewoon een exacte kopie van een bepaalde bitmap-bestand dan en voert deze uit.

280
00:22:57,610 --> 00:23:01,900
Dus dit opent al het bestand voor u, leest in pixel voor pixel,

281
00:23:01,900 --> 00:23:04,510
en schrijft het vervolgens in in een output-bestand.

282
00:23:04,510 --> 00:23:07,080
>> Laten we eens een kijkje nemen op die.

283
00:23:13,390 --> 00:23:18,290
Dit is ervoor te zorgen correct gebruik,

284
00:23:18,290 --> 00:23:22,640
het verkrijgen van de bestandsnamen hier.

285
00:23:22,640 --> 00:23:29,940
Wat dit doet is het zet de input-file om te zijn wat we hebben doorgegeven in hier in de infile,

286
00:23:29,940 --> 00:23:34,750
dat is onze tweede command-line argument.

287
00:23:34,750 --> 00:23:37,640
Controles om ervoor te zorgen dat we het bestand te openen.

288
00:23:38,960 --> 00:23:44,860
Controles om ervoor te zorgen dat we een nieuwe outfile hier te maken.

289
00:23:45,630 --> 00:23:53,270
Maar wat dit hier doet, het alleen maar in principe begint te lezen in het bitmap-bestand vanaf het begin.

290
00:23:53,270 --> 00:23:56,700
Het begin, zoals we weten, bevat de BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
en dus die sequenties van bits direct invullen van de BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Dus wat we hier hebben is te zeggen dat BITMAPFILEHEADER bf -

293
00:24:07,940 --> 00:24:13,150
dat is onze nieuwe variabele van het type BITMAPFILEHEADER -

294
00:24:13,150 --> 00:24:22,560
we gaan zetten binnen bf wat we lezen in pointer, dat is onze infile.

295
00:24:22,560 --> 00:24:23,970
Hoeveel hebben we gelezen?

296
00:24:23,970 --> 00:24:32,160
We lezen in hoeveel bytes moeten we de hele BITMAPFILEHEADER bevatten.

297
00:24:32,160 --> 00:24:34,660
Ook dat is wat we doen voor de info header.

298
00:24:34,660 --> 00:24:39,010
Dus we verder langs ons dossier in de infile,

299
00:24:39,010 --> 00:24:44,360
en we zijn het lezen van deze bits en bytes, en we sluiten ze direct in

300
00:24:44,360 --> 00:24:47,880
in deze gevallen van de variabelen die we maken.

301
00:24:49,370 --> 00:24:53,800
Hier zijn we gewoon ervoor te zorgen dat de bitmap is een bitmap.

302
00:24:57,670 --> 00:25:01,030
>> Nu hebben we een outfile, toch?

303
00:25:01,030 --> 00:25:04,420
Dus zoals het nu is als we creëren, het is in wezen leeg.

304
00:25:04,420 --> 00:25:07,710
Dus moeten we eigenlijk een nieuwe bitmap vanaf nul.

305
00:25:07,710 --> 00:25:12,280
Wat wij doen is moeten we ervoor zorgen dat we kopiëren in de header

306
00:25:12,280 --> 00:25:16,850
en de info header net als de infile heeft.

307
00:25:16,850 --> 00:25:22,850
Wat wij doen is schrijven we - en vergeet niet dat bf is de variabele

308
00:25:22,850 --> 00:25:29,300
van het type BITMAPFILEHEADER, dus wat we doen is dat we gewoon gebruik maken van die inhoud

309
00:25:29,300 --> 00:25:34,980
te schrijven in de outfile.

310
00:25:36,550 --> 00:25:38,510
Hier herinneren we gesproken over padding,

311
00:25:38,510 --> 00:25:47,820
hoe belangrijk het is ervoor te zorgen dat het aantal pixels dat we een veelvoud van 4.

312
00:25:47,820 --> 00:25:52,790
Dit is een vrij nuttige formule om te berekenen hoeveel vulling je hebt

313
00:25:52,790 --> 00:25:57,670
gelet op de breedte van uw dossier.

314
00:25:57,670 --> 00:26:04,120
Ik wil dat jullie te onthouden dat in copy.c we een formule voor het berekenen van padding hebben.

315
00:26:04,120 --> 00:26:07,970
Oke? Dus iedereen onthouden. Geweldig.

316
00:26:07,970 --> 00:26:14,050
Dus wat doet copy.c volgende is het doorloopt alle scanlines.

317
00:26:14,050 --> 00:26:23,730
Het gaat door de rijen en vervolgens opgeslagen om triple die ze leest

318
00:26:23,730 --> 00:26:26,920
en schrijft het in de outfile.

319
00:26:26,920 --> 00:26:33,120
Dus dan hier zijn we aan het lezen bent slechts een RGB-triple in een tijd

320
00:26:33,120 --> 00:26:39,860
en dan zetten diezelfde triple in de outfile.

321
00:26:41,120 --> 00:26:48,340
Het lastige deel is dat de vulling niet een RGB triple,

322
00:26:48,340 --> 00:26:55,200
en dus kunnen we niet gewoon lezen dat padding hoeveelheid RGB triples.

323
00:26:55,200 --> 00:27:01,460
Wat we moeten doen is eigenlijk alleen maar bewegen ons positie-indicator, bewegen onze cursor,

324
00:27:01,460 --> 00:27:06,840
van de soort over te slaan alle padding, zodat we op de volgende rij.

325
00:27:06,840 --> 00:27:12,990
En wat dit doet is copy laat je zien hoe je zou willen om de vulling toe te voegen.

326
00:27:12,990 --> 00:27:14,990
Dus hebben we berekend hoeveel padding we nodig hebben,

327
00:27:14,990 --> 00:27:18,220
dus dat betekent dat we padding aantal 0s nodig hebben.

328
00:27:18,220 --> 00:27:24,510
Wat dit doet is een lus die padding aantal 0s zet in onze outfile.

329
00:27:24,510 --> 00:27:31,170
En dan tot slot, sluit u beide bestanden. U sluit de infile evenals de outfile.

330
00:27:31,170 --> 00:27:34,870
>> Dus dat is hoe copy.c werkt,

331
00:27:34,870 --> 00:27:37,430
en dat gaat behoorlijk nuttig.

332
00:27:39,720 --> 00:27:43,750
In plaats van alleen eigenlijk direct kopiëren en plakken

333
00:27:43,750 --> 00:27:46,800
of gewoon naar te kijken en te typen in wat je wilt,

334
00:27:46,800 --> 00:27:49,440
je kan gewoon wilt dit commando uit te voeren in de terminal,

335
00:27:49,440 --> 00:27:54,520
cp copy.c whodunit.c, die een nieuw bestand te maken, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
dat bevat exact dezelfde inhoud als kopie doet.

337
00:27:58,330 --> 00:28:03,880
Dus dan wat we kunnen doen is gebruik dat als een raamwerk waarop te bouwen en te bewerken

338
00:28:03,880 --> 00:28:06,900
voor onze whodunit-bestand.

339
00:28:08,500 --> 00:28:14,670
>> Dit zijn onze to-do's te doen voor Whodunit, maar wat copy.c doet

340
00:28:14,670 --> 00:28:16,730
daadwerkelijk verzorgt meeste voor ons.

341
00:28:16,730 --> 00:28:21,900
Dus alles wat we moeten gaan doen is verandering de pixels als dat nodig is

342
00:28:21,900 --> 00:28:25,920
om daadwerkelijk het bestand leesbaar.

343
00:28:25,920 --> 00:28:32,960
Bedenk dat voor een gegeven pixel triple, zodat voor een gegeven variabele van het type RGBTRIPLE,

344
00:28:32,960 --> 00:28:35,990
hebt u toegang tot de blauwe, groene en rode waarden.

345
00:28:35,990 --> 00:28:38,670
Dat zal van pas komen, want als je er toegang toe,

346
00:28:38,670 --> 00:28:41,770
dat betekent dat u ook controleren ze,

347
00:28:41,770 --> 00:28:45,430
en dat betekent dat u ook wijzigen.

348
00:28:45,430 --> 00:28:49,430
>> Dus toen we gingen terug naar onze rode vergrootglas bijvoorbeeld,

349
00:28:49,430 --> 00:28:53,390
in feite, werd dat als een soort filter voor ons.

350
00:28:53,390 --> 00:28:58,160
Dus wat we willen doen is dat we willen alle triples die komende inch filteren

351
00:28:58,160 --> 00:29:01,240
Er zijn verschillende manieren om dit te doen.

352
00:29:01,240 --> 00:29:07,100
In principe kunt u ongeacht het type filter dat u wilt.

353
00:29:07,100 --> 00:29:09,890
Misschien wilt u alle rode pixels wijzigen

354
00:29:09,890 --> 00:29:13,570
of misschien wilt u een andere kleur pixel te wijzigen in een andere kleur.

355
00:29:13,570 --> 00:29:15,400
Dat is aan jou.

356
00:29:15,400 --> 00:29:19,580
Vergeet niet dat u kunt controleren welke kleur de pixel

357
00:29:19,580 --> 00:29:23,000
en dan kun je ook veranderen als je doormaakt.

358
00:29:24,410 --> 00:29:26,420
>> Oke. Dus dat is Whodunit.

359
00:29:26,420 --> 00:29:32,760
Zodra u Whodunit loopt, zul je weten wie de dader van de misdaad was.

360
00:29:32,760 --> 00:29:35,540
>> Nu gaan we naar Formaat wijzigen.

361
00:29:35,540 --> 00:29:37,990
We gaan nog steeds te maken hebben met bitmaps.

362
00:29:37,990 --> 00:29:40,750
Wat we gaan doen is gaan we een ingang bitmap hebben

363
00:29:40,750 --> 00:29:45,890
en dan gaan we pas in een getal en vervolgens een outfile bitmap te krijgen

364
00:29:45,890 --> 00:29:51,380
waar dat is eigenlijk onze infile geschaald door n.

365
00:29:54,670 --> 00:30:01,450
Zeg mijn dossier was slechts een pixel groot.

366
00:30:01,450 --> 00:30:09,100
Dan, als mijn n was 3, schalen met 3, dan zou ik herhalen dat pixel n aantal keren,

367
00:30:09,100 --> 00:30:14,410
dus 3 keer, en dan ook schalen naar beneden 3 keer ook.

368
00:30:14,410 --> 00:30:17,840
Zo zie je maar dat ik het opschalen zowel verticaal als horizontaal.

369
00:30:17,840 --> 00:30:19,680
>> En dan is hier een voorbeeld.

370
00:30:19,680 --> 00:30:27,590
Als je n = 2, zie je dat de eerste blauwe pixel er twee keer herhaald

371
00:30:27,590 --> 00:30:30,930
zowel horizontaal als twee keer verticaal.

372
00:30:30,930 --> 00:30:38,040
En dan is dat verder op, en dus heb je een directe schaalvergroting van de oorspronkelijke afbeelding door twee.

373
00:30:40,920 --> 00:30:47,600
>> Dus dan als we voor het detail van de pseudocode voor deze willen we het bestand te openen.

374
00:30:47,600 --> 00:30:49,880
En dan te weten dat als we terug te gaan hier,

375
00:30:49,880 --> 00:30:54,540
zien we dat de breedte voor de outfile gaat om anders te zijn dan de breedte van de infile.

376
00:30:54,540 --> 00:30:56,130
Wat betekent dat?

377
00:30:56,130 --> 00:31:01,230
Dat betekent dat onze header informatie gaat veranderen.

378
00:31:01,230 --> 00:31:03,790
En dus wat we willen doen is het actualiseren van de header info,

379
00:31:03,790 --> 00:31:11,820
wetende dat wanneer we lezen in de bestanden als je die op de copy.c kader,

380
00:31:11,820 --> 00:31:17,570
hebben we al een variabele die aangeeft wat de omvang is en dat soort dingen.

381
00:31:17,570 --> 00:31:24,060
Dus zodra je dat hebt, wat je zou willen doen is die bepaalde variabelen.

382
00:31:24,060 --> 00:31:29,380
Vergeet niet, als je een struct, hoe je de variabelen binnen die te openen.

383
00:31:29,380 --> 00:31:32,080
U gebruikt de puntoperator, toch?

384
00:31:32,080 --> 00:31:36,420
Dus dan met behulp van dat, je weet dat je nodig hebt om de header info te veranderen.

385
00:31:36,480 --> 00:31:41,030
Dus hier is gewoon een lijst van de feitelijke elementen die zullen worden veranderen in uw bestand.

386
00:31:41,030 --> 00:31:45,180
Het bestand zal worden veranderen, het beeld, en de breedte en hoogte.

387
00:31:45,180 --> 00:31:50,080
Dus dan terug te gaan naar de kaart van de bitmaps,

388
00:31:50,080 --> 00:31:57,730
kijken of het nu de bestandsheader of de info header die deze informatie bevat

389
00:31:57,730 --> 00:32:00,920
en dan veranderen als dat nodig is.

390
00:32:05,010 --> 00:32:12,470
Nogmaals, laten we zeggen cp copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
Dat betekent dat resize.c nu alles wat er die binnen kopie bevat

392
00:32:19,270 --> 00:32:24,490
omdat kopie geeft ons een manier van het lezen in elk scanline pixel per pixel.

393
00:32:24,490 --> 00:32:29,860
Behalve nu, in plaats van alleen het veranderen van de waarden zoals wij deden in Whodunit,

394
00:32:29,860 --> 00:32:37,980
wat we willen doen is dat we willen om te schrijven in meerdere pixels

395
00:32:37,980 --> 00:32:43,580
zolang de n groter is dan 1.

396
00:32:43,580 --> 00:32:47,110
>> Dan wat we willen doen is dat we willen horizontaal uitrekken door n,

397
00:32:47,110 --> 00:32:50,490
als verticaal rekken door n.

398
00:32:50,490 --> 00:32:52,710
Hoe kunnen we dat doen?

399
00:32:52,710 --> 00:32:56,890
Zeg uw n 2 is en je dit gegeven infile.

400
00:32:56,890 --> 00:32:58,730
Uw cursor zal om te beginnen op de eerste,

401
00:32:58,730 --> 00:33:03,530
en wat je wilt doen als n 2, die u wilt afdrukken in 2 van die.

402
00:33:03,530 --> 00:33:05,490
Dus u afdrukt in 2 van die.

403
00:33:05,490 --> 00:33:10,830
Vervolgens de cursor gaat naar het volgende pixel, die de rode,

404
00:33:10,830 --> 00:33:18,400
en het gaat om uit te printen 2 van die rode, gehecht worden op wat het eerder gedaan.

405
00:33:18,400 --> 00:33:26,280
Dan is de cursor gaat naar de volgende pixel en trekken in 2 van die.

406
00:33:26,280 --> 00:33:37,180
Als je kijkt naar de copy.c kader, wat dit doet hier

407
00:33:37,180 --> 00:33:42,830
wordt het creëert een nieuwe instantie van een RGB-triple, een nieuwe variabele genaamd triple.

408
00:33:42,830 --> 00:33:50,500
En hier als het leest in het, het leest van de infile 1 RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
en slaat deze binnenkant van die triple variabele.

410
00:33:53,470 --> 00:33:57,590
Dus dan moet je eigenlijk een variabele die die bepaalde pixel.

411
00:33:57,590 --> 00:34:05,290
Dan wanneer je schrijft, wat je zou willen doen is omsluiten de fwrite verklaring in een lus

412
00:34:05,290 --> 00:34:11,080
dat schrijft deze in je outfile zo vaak als nodig.

413
00:34:17,449 --> 00:34:20,100
Dat is eenvoudig genoeg.

414
00:34:20,200 --> 00:34:27,590
Alleen maar in principe herhaal het schrijfproces n aantal keren om horizontaal te schalen.

415
00:34:27,590 --> 00:34:32,969
>> Maar dan moeten we niet vergeten dat onze padding gaat veranderen.

416
00:34:47,350 --> 00:34:53,020
Voorheen zeggen dat we hadden iets van lengte 3.

417
00:34:53,020 --> 00:35:00,130
Dan zouden we gewoon toevoegen in hoeveel padding? Nog een om er een veelvoud van 4.

418
00:35:00,130 --> 00:35:10,480
Maar zeggen dat we dit bijzondere beeld schaalvergroting door n = 2.

419
00:35:10,480 --> 00:35:16,300
Dus dan hoeveel blauwe pixels zouden we aan het eind? We zouden 6.

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

421
00:35:21,470 --> 00:35:26,580
6 is geen veelvoud van 4. Wat is het dichtstbijzijnde veelvoud van 4? Dat komt wel 8.

422
00:35:26,580 --> 00:35:33,200
Dus we zijn eigenlijk gaat om daar te hebben 2 karakters van padding.

423
00:35:33,200 --> 00:35:38,720
>> Heeft iemand herinner me als we een formule om te berekenen padding

424
00:35:38,720 --> 00:35:41,350
en waar dat zal zijn?

425
00:35:41,350 --> 00:35:45,160
[Onverstaanbaar student reactie] >> Ja, copy.c. Juist.

426
00:35:45,160 --> 00:35:49,800
Er is een formule in copy.c om te berekenen hoeveel vulling je hebt

427
00:35:49,800 --> 00:35:53,810
gegeven een bepaalde breedte van de bitmapafbeelding.

428
00:35:53,810 --> 00:36:02,950
Dus dan dat gaat handig zijn als je nodig hebt om toe te voegen in een zekere mate van vulling

429
00:36:02,950 --> 00:36:06,160
om daadwerkelijk uit te vinden hoeveel padding je nodig hebt om toe te voegen.

430
00:36:10,820 --> 00:36:15,850
Maar een noot is echter dat u wilt ervoor zorgen dat u de juiste maat gebruikt.

431
00:36:15,850 --> 00:36:21,410
Wees voorzichtig, want je bent in principe zal worden te maken met twee bitmapafbeeldingen.

432
00:36:21,410 --> 00:36:23,410
U wilt er zeker van zijn dat je de juiste gebruikt.

433
00:36:23,410 --> 00:36:26,820
Wanneer u de opvulling berekenen voor de outfile, wil je de breedte van de outfile gebruiken

434
00:36:26,820 --> 00:36:29,860
en niet de breedte van de vorige.

435
00:36:29,860 --> 00:36:37,240
>> Geweldig. Dat soort zorgt voor het oprekken van een hele bitmapafbeelding horizontaal.

436
00:36:37,240 --> 00:36:41,290
Maar wat we willen doen is eigenlijk uitrekken verticaal als goed.

437
00:36:41,290 --> 00:36:48,760
Dit gaat een beetje lastiger, want als we klaar zijn het kopiëren van een rij

438
00:36:48,760 --> 00:36:51,580
en het schrijven van die rij, is onze cursor gaat worden aan het eind.

439
00:36:51,580 --> 00:36:56,210
Dus als we lezen weer, dan is het gewoon om in te lezen naar de volgende regel.

440
00:36:56,210 --> 00:37:03,660
Dus wat we willen doen is een soort van een manier vinden van het kopiëren van die rijen weer

441
00:37:03,660 --> 00:37:12,500
of gewoon een soort van het nemen van die rij en dan herschrijven het weer.

442
00:37:14,380 --> 00:37:17,940
Zoals ik soort van gezinspeeld, zijn er verschillende manieren om dit te doen.

443
00:37:17,940 --> 00:37:23,040
Wat je zou kunnen doen is als je gaat door en het lezen van de bijzondere scanline

444
00:37:23,040 --> 00:37:28,560
en veranderen indien nodig, dan soort winkel al die pixels in een array.

445
00:37:28,560 --> 00:37:36,350
Later op weet je dat je nodig hebt om uit te printen die array weer,

446
00:37:36,350 --> 00:37:39,830
en dus kun je gewoon gebruik maken van die array om dat te doen.

447
00:37:39,830 --> 00:37:44,500
Een andere manier om het te doen is dat je zou kunnen kopiëren naar beneden een rij,

448
00:37:44,500 --> 00:37:47,950
begrijpen dat je nodig hebt om dat opnieuw te kopiëren, dus eigenlijk beweeg je cursor,

449
00:37:47,950 --> 00:37:50,950
en dat gaat worden met behulp van de methode fseek.

450
00:37:50,950 --> 00:37:56,410
Je kon je cursor weer helemaal en herhaal het kopieerproces.

451
00:37:56,410 --> 00:38:03,960
>> Dus als onze schaalvergroting getal n, dan hoe vaak zouden we om terug te gaan

452
00:38:03,960 --> 00:38:10,500
en herschrijven van een lijn? >> [Student] n - 1. >> Ja, perfect. n - 1.

453
00:38:10,500 --> 00:38:14,390
We hebben het gedaan al een keer, dus dan zullen we willen het terug te gaan herhalen

454
00:38:14,390 --> 00:38:17,460
n - 1 aantal keer.

455
00:38:22,730 --> 00:38:25,860
Oke. Dus daar heb je je resize functie.

456
00:38:25,860 --> 00:38:34,360
>> Nu we kunnen krijgen om een ​​echt leuke gedeelte, mijn favoriete PSET, dat is terug.

457
00:38:34,360 --> 00:38:39,580
In plaats van bitmaps, deze keer hebben we mee te maken hebben JPEG's.

458
00:38:39,580 --> 00:38:43,370
We zijn eigenlijk niet gegeven een bestand alleen van JPEG's,

459
00:38:43,370 --> 00:38:46,600
we krijgen in principe een raw formaat geheugenkaart.

460
00:38:46,600 --> 00:38:51,790
En dus dit bevat een beetje info en vuilnis waarden in het begin,

461
00:38:51,790 --> 00:38:57,240
en dan begint het en het heeft een bos van JPEG-bestanden.

462
00:38:57,240 --> 00:39:03,430
Echter, we overhandigde een kaartje waar we verwijderd van de foto's;

463
00:39:03,430 --> 00:39:08,300
wezen, hebben we vergeten waar de foto's bevinden zich in de kaart.

464
00:39:08,300 --> 00:39:12,770
Dus dan is onze taak in Recover is om te gaan door middel van deze kaart formaat

465
00:39:12,770 --> 00:39:16,500
en terug te vinden die foto's.

466
00:39:16,500 --> 00:39:23,990
>> Gelukkig, de structuur van de JPEG-bestanden en de kaart-bestand is een beetje nuttig.

467
00:39:23,990 --> 00:39:28,850
Het is zeker had kunnen zijn een beetje lastiger als het niet in dit specifieke formaat.

468
00:39:28,850 --> 00:39:40,160
Elke JPEG-bestand begint eigenlijk met twee mogelijke sequenties, hierboven vermeld.

469
00:39:40,160 --> 00:39:42,970
Kortom, wanneer je een nieuwe JPEG-bestand,

470
00:39:42,970 --> 00:39:52,720
het begint met ofwel de volgorde ffd8 ffe0 of de andere, ffd8 ffe1.

471
00:39:52,720 --> 00:39:59,530
Een ander nuttig ding om te weten is dat JPEG's aansluitend worden opgeslagen.

472
00:39:59,530 --> 00:40:03,380
Dus wanneer een JPEG bestand eindigt, de andere begint.

473
00:40:03,380 --> 00:40:07,070
Er is geen enkele vorm van in-tussen waarden zijn.

474
00:40:07,070 --> 00:40:15,510
Zodra je de start van een JPEG, als je al het lezen van een JPEG-,

475
00:40:15,510 --> 00:40:21,800
je weet dat je het einde van de vorige en het begin van de volgende hit.

476
00:40:21,800 --> 00:40:25,890
>> Om vorm van visualiseren dit, heb ik een schema.

477
00:40:25,890 --> 00:40:36,910
Een ander ding over JPEG-bestanden is dat we ze kunnen lezen in sequenties van 512 bytes per keer,

478
00:40:36,910 --> 00:40:39,380
Hetzelfde geldt voor de begin van de kaart.

479
00:40:39,380 --> 00:40:43,370
We hoeven niet te worden te controleren elke byte want dat zou zuigen.

480
00:40:43,370 --> 00:40:48,200
Dus in plaats daarvan wat we kunnen doen is eigenlijk alleen maar in 512 bytes te lezen op een moment

481
00:40:48,200 --> 00:40:54,700
en dan, in plaats van de controle tussen die in die piepkleine schijfjes,

482
00:40:54,700 --> 00:40:58,640
we kunnen gewoon check het begin van de 512 bytes.

483
00:40:58,640 --> 00:41:02,570
In wezen, op deze foto, wat je ziet is in het begin van de kaart,

484
00:41:02,570 --> 00:41:08,700
u heeft een waarde die niet echt relevant zijn voor de werkelijke JPEG's zelf.

485
00:41:08,700 --> 00:41:15,830
Maar wat ik een ster om een ​​van de twee uitgangsstoffen sequenties voor een JPEG geven.

486
00:41:15,830 --> 00:41:19,910
Dus wanneer je een ster ziet, weet u dat u een JPEG-bestand te hebben.

487
00:41:19,910 --> 00:41:25,030
En vervolgens om de JPEG-bestand gaat om een ​​aantal veelvoud van 512 bytes worden

488
00:41:25,030 --> 00:41:27,880
maar niet noodzakelijkerwijs hetzelfde meerdere.

489
00:41:27,880 --> 00:41:32,050
De manier waarop je weet dat je een andere JPEG geraakt is als je op een andere ster,

490
00:41:32,050 --> 00:41:39,090
een andere startvolgorde van bytes.

491
00:41:39,090 --> 00:41:43,330
Dan wat je hebt hier heb je de rode JPEG-bestand verder tot je een ster,

492
00:41:43,330 --> 00:41:45,150
die wordt aangegeven door een nieuwe kleur.

493
00:41:45,150 --> 00:41:48,510
U blijft en dan je hit een andere ster, je raakt een andere JPEG,

494
00:41:48,510 --> 00:41:50,590
u doorgaat helemaal tot het einde.

495
00:41:50,590 --> 00:41:53,180
Je bent op de laatste foto hier, de roze.

496
00:41:53,180 --> 00:41:58,220
Je gaat naar het einde tot je het einde van het bestand karakter.

497
00:41:58,220 --> 00:42:00,820
Dit gaat echt nuttig.

498
00:42:00,820 --> 00:42:03,170
>> Een paar belangrijke afhaalrestaurants hier:

499
00:42:03,170 --> 00:42:06,670
De kaart-bestand begint niet met een JPEG-,

500
00:42:06,670 --> 00:42:13,350
maar eenmaal JPEG begint, worden alle JPEG opgeslagen naast elkaar.

501
00:42:17,520 --> 00:42:20,420
>> Sommige pseudocode voor de Recover.

502
00:42:20,420 --> 00:42:22,570
Ten eerste, we gaan naar onze kaart bestand te openen,

503
00:42:22,570 --> 00:42:27,500
en dat gaat worden met behulp van onze file I / O-functies.

504
00:42:27,500 --> 00:42:32,430
We gaan het volgende proces herhalen totdat we aan het einde van het bestand.

505
00:42:32,430 --> 00:42:36,450
We gaan 512 bytes per keer lezen.

506
00:42:36,450 --> 00:42:39,180
En wat ik zei hier gaan we het op te slaan in een buffer,

507
00:42:39,180 --> 00:42:46,230
dus in principe vast te houden aan die 512 bytes tot we precies weten wat te doen met hen.

508
00:42:46,230 --> 00:42:50,300
Dan wat we willen doen is dat we willen nagaan of we hebben een ster of niet geraakt.

509
00:42:50,300 --> 00:42:57,960
Als we raakte een ster, als we geraakt een van de uitgangspunten sequenties,

510
00:42:57,960 --> 00:42:59,980
dan weten we dat we een nieuw JPEG-bestand te raken.

511
00:42:59,980 --> 00:43:08,860
Wat we willen doen is gaan we willen een nieuw bestand in onze pset4 map aan te maken

512
00:43:08,860 --> 00:43:14,480
te blijven maken dat bestand.

513
00:43:14,480 --> 00:43:18,220
Maar ook als we hebben al een JPEG-voor,

514
00:43:18,220 --> 00:43:25,620
dan willen we dat bestand te beëindigen en te duwen om de pset4 map,

515
00:43:25,620 --> 00:43:29,780
waar we hebben dat bestand opgeslagen, want als we niet aangeven dat we dat JPEG-bestand eindigde,

516
00:43:29,780 --> 00:43:37,290
dan zullen we in principe een onbepaalde hoeveelheid. De JPEG's zal nooit eindigen.

517
00:43:37,290 --> 00:43:40,840
Dus we willen er zeker van dat als we het lezen in een JPEG-bestand is en dat het schrijven,

518
00:43:40,840 --> 00:43:46,590
we willen eens sluiten dat om de volgende te openen.

519
00:43:46,590 --> 00:43:48,430
We willen verschillende dingen te controleren.

520
00:43:48,430 --> 00:43:52,880
We willen nagaan of we aan het begin van een nieuw JPEG met onze buffer

521
00:43:52,880 --> 00:43:56,780
en ook als we al hebben gevonden een JPEG voordat

522
00:43:56,780 --> 00:44:03,930
want dat zal je proces een beetje.

523
00:44:03,930 --> 00:44:07,880
Dan, nadat je door de hele weg en je raakt het einde van het bestand,

524
00:44:07,880 --> 00:44:11,570
dan wat je wilt doen is je wilt alle bestanden die momenteel zijn geopend sluiten.

525
00:44:11,570 --> 00:44:14,100
Dat is waarschijnlijk de laatste zal zijn JPEG-bestand dat je hebt,

526
00:44:14,100 --> 00:44:18,930
alsook de kaart bestand dat u hebt te maken met.

527
00:44:21,940 --> 00:44:28,670
>> De laatste hindernis die we moeten aanpakken is hoe om daadwerkelijk een JPEG-bestand

528
00:44:28,670 --> 00:44:31,950
en hoe je nu eigenlijk te duwen naar de map.

529
00:44:33,650 --> 00:44:39,850
De PSET vereist dat elke JPEG die je kunt vinden in het volgende formaat,

530
00:44:39,850 --> 00:44:43,990
waar u het nummer. jpg.

531
00:44:43,990 --> 00:44:50,750
Het aantal, ook al is het 0, noemen we het 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Wanneer u een JPEG in uw programma,

533
00:44:55,730 --> 00:44:58,040
je gaat te willen om het te noemen in de volgorde waarin het is gevonden.

534
00:44:58,040 --> 00:44:59,700
Wat betekent dit?

535
00:44:59,700 --> 00:45:03,530
We moeten dergelijke bijhouden hoeveel we hebben gevonden

536
00:45:03,530 --> 00:45:08,680
en wat het nummer van elke JPEG moet.

537
00:45:08,680 --> 00:45:13,800
Hier gaan we om te profiteren van de sprintf functie.

538
00:45:13,800 --> 00:45:17,480
Net als bij printf, die gewoon een soort van prenten een waarde uit in de terminal,

539
00:45:17,480 --> 00:45:23,910
sprintf drukt het bestand uit in de map.

540
00:45:23,910 --> 00:45:30,870
En dit dus wat zou doen als ik had sprintf, titel, en dan de string daar,

541
00:45:30,870 --> 00:45:36,660
het zou uitprinten 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Ervan uitgaande dat ik mijn bestanden correct afgesloten,

543
00:45:41,020 --> 00:45:47,210
dat zou bevatten het bestand dat ik had geschreven uit.

544
00:45:47,210 --> 00:45:50,320
Maar een ding is dat de code die ik hier heb

545
00:45:50,320 --> 00:45:53,360
niet helemaal voldoet aan wat de PSET vereist.

546
00:45:53,360 --> 00:46:02,410
De PSET vereist dat de tweede JPEG bestand moet de naam 002 in plaats van slechts 2.

547
00:46:02,410 --> 00:46:09,160
Dus wanneer u afdrukt uit de naam, dan misschien wilt u misschien de plaatsaanduiding iets te veranderen.

548
00:46:09,160 --> 00:46:18,140
>> Weet iemand nog hoe we zorgen voor extra spaties als we iets af te drukken?

549
00:46:18,140 --> 00:46:22,530
Ja. >> [Student] Je zet een 3 tussen het procentteken en de 2. >> Ja, perfect.

550
00:46:22,530 --> 00:46:25,610
Je zet een 3 in dit geval, want we willen ruimte voor 3.

551
00:46:25,610 --> 00:46:32,590
% 3d zou waarschijnlijk geven u 002.jpg in plaats van 2.

552
00:46:32,590 --> 00:46:40,120
Het eerste argument in de sprintf functie is eigenlijk een char array,

553
00:46:40,120 --> 00:46:42,520
die we eerder kenden als strings.

554
00:46:42,520 --> 00:46:50,700
Die wil, soort van meer als een tijdelijke opslag, maar slaan de resulterende tekenreeks.

555
00:46:50,700 --> 00:46:54,950
U zult niet echt te maken hebben met dit, maar je moet het op te nemen.

556
00:46:54,950 --> 00:47:00,710
>> Wetende dat elk bestand de naam van het nummer, dat in beslag neemt drie tekens heeft,

557
00:47:00,710 --> 00:47:06,770
en dan. jpg, moet deze array hoe lang zijn?

558
00:47:09,070 --> 00:47:14,310
Gooi een nummer. Hoeveel tekens in de titel, in de naam?

559
00:47:18,090 --> 00:47:26,320
Dus er is 3 hashtags, periode, jpg. >> [Student] 7. >> 7. Niet helemaal.

560
00:47:26,320 --> 00:47:32,000
We gaan tot 8 wilt, want we willen zorgen voor de null-terminator ook.

561
00:47:45,340 --> 00:47:49,730
>> Tot slot, om gewoon trekken uit het proces dat u zult moeten doen voor Recover,

562
00:47:49,730 --> 00:47:55,420
je een aantal begin informatie.

563
00:47:55,420 --> 00:48:02,460
U blijft totdat u het begin van een JPEG-bestand,

564
00:48:02,460 --> 00:48:07,900
en die ofwel een van de twee sequenties beginnen.

565
00:48:07,900 --> 00:48:12,510
Je blijft bij het lezen. Elke slash hier vertegenwoordigt 512 bytes.

566
00:48:12,510 --> 00:48:22,630
Je blijft op lezen, blijven lezen totdat je tegenkomt een andere startvolgorde.

567
00:48:22,630 --> 00:48:29,790
Zodra je dat hebt, je de huidige JPEG eindigen - in dit geval, het is de rode,

568
00:48:29,790 --> 00:48:31,030
dus je wilt dat een einde.

569
00:48:31,030 --> 00:48:35,540
U wilt sprintf de naam van die in uw pset4 map,

570
00:48:35,540 --> 00:48:41,580
dan wil je een nieuwe JPEG te openen en vervolgens op het lezen te houden

571
00:48:41,580 --> 00:48:46,370
totdat kom je de volgende.

572
00:48:46,370 --> 00:48:49,040
Blijf lezen, blijf lezen,

573
00:48:49,040 --> 00:48:56,290
en dan eindelijk, uiteindelijk, je gaat naar het einde van het bestand bereikt,

574
00:48:56,290 --> 00:49:00,360
en dus je wilt de laatste JPEG dichtbij dat u werkte,

575
00:49:00,360 --> 00:49:08,380
sprintf die in uw pset4 map en kijk dan naar alle van de foto's die je hebt gekregen.

576
00:49:08,380 --> 00:49:12,050
Die foto's zijn eigenlijk foto's van CS50 personeel,

577
00:49:12,050 --> 00:49:16,430
en dus dit is waar de bonus leuke gedeelte van de PSET komt in

578
00:49:16,430 --> 00:49:26,310
is dat je met elkaar concurreren in uw secties om de TFS in de foto's te vinden

579
00:49:26,310 --> 00:49:34,610
en foto's nemen met hen om te bewijzen dat u de PSET gedaan

580
00:49:34,610 --> 00:49:37,030
en zodat u kunt zien welke medewerkers zijn op de foto's.

581
00:49:37,030 --> 00:49:41,510
Dus dan moet je foto's maken met het personeel. Soms moet je ze achterna te zitten.

582
00:49:41,510 --> 00:49:44,680
Waarschijnlijk een van hen zal proberen weg te rennen van je.

583
00:49:44,680 --> 00:49:47,320
Je neemt foto's met hen.

584
00:49:47,320 --> 00:49:51,190
Dit is aan de gang. Het is niet verschuldigd wanneer de PSET is te wijten.

585
00:49:51,190 --> 00:49:53,340
De deadline zal worden aangekondigd in de spec.

586
00:49:53,340 --> 00:49:58,060
Dan samen met uw afdeling, afhankelijk van welke paragraaf neemt de meeste foto's

587
00:49:58,060 --> 00:50:04,430
met de meeste medewerkers wint een pretty awesome prijs.

588
00:50:04,430 --> 00:50:08,890
Dat is een soort van stimulans om uw pset4 eindigde zo snel mogelijk

589
00:50:08,890 --> 00:50:10,820
want dan kun je aan de slag gaan

590
00:50:10,820 --> 00:50:14,570
jacht op alle verschillende CS50 medewerkers.

591
00:50:14,570 --> 00:50:17,500
Dat is niet verplicht is, al, dus als je eenmaal de foto's,

592
00:50:17,500 --> 00:50:20,310
dan bent u klaar met pset4.

593
00:50:20,310 --> 00:50:23,970
>> En ik ben klaar met Walkthrough 4, dus alle dank u voor uw komst.

594
00:50:23,970 --> 00:50:29,330
Veel succes met Forensics. [Applaus]

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