1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Tutorial - Joc Problema 4]

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

3
00:00:05,000 --> 00:00:07,340
[Aquesta és CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
Està bé. Hola a tots i benvinguts a Tutorial 4.

5
00:00:11,670 --> 00:00:14,270
>> Avui el nostre conjunt de processadors és Forensics.

6
00:00:14,270 --> 00:00:18,080
Forense és un conjunt de processadors molt divertit que consisteix en tractar amb arxius de mapa de bits

7
00:00:18,080 --> 00:00:21,550
per descobrir que ha comès un crim.

8
00:00:21,550 --> 00:00:24,200
A continuació, anem a canviar la mida d'alguns arxius de mapa de bits,

9
00:00:24,200 --> 00:00:27,780
llavors nosaltres també farem front a una part molt divertit anomenat Recuperar,

10
00:00:27,780 --> 00:00:31,160
en què estem, bàsicament, va lliurar una targeta de memòria

11
00:00:31,160 --> 00:00:34,350
en què algú ha esborrat accidentalment tots els seus arxius,

12
00:00:34,350 --> 00:00:38,860
i se'ns demana que recuperar aquests arxius.

13
00:00:38,860 --> 00:00:42,910
>> Però primer, abans d'entrar en el conjunt de processadors, realment només vull felicitar a tothom.

14
00:00:42,910 --> 00:00:45,230
Estem a punt al punt mitjà d'aquest curs.

15
00:00:45,230 --> 00:00:50,070
Quiz 0 està darrere de nosaltres, i estem en pset4, pel que en essència, estem a mig camí.

16
00:00:50,070 --> 00:00:55,490
Hem recorregut un llarg camí si un mira cap enrere els seus conjunts de processadors, pset0 i pset1,

17
00:00:55,490 --> 00:00:57,300
així que felicitar per això,

18
00:00:57,300 --> 00:01:00,760
i entrarem en algunes coses realment divertides.

19
00:01:00,760 --> 00:01:07,070
>> Així que la nostra caixa d'eines per a aquest conjunt de processadors, de nou, en lloc d'executar sudo yum-i update,

20
00:01:07,070 --> 00:01:13,890
estem en condicions d'executar només update50 si vostè està en la versió 17.3 i superior de l'aparell.

21
00:01:13,890 --> 00:01:17,380
Així que assegureu-vos d'executar update50 - és un fàcil molt, uns pocs caràcters poc -

22
00:01:17,380 --> 00:01:20,640
per assegurar-se que vostè està en l'última versió de l'aparell.

23
00:01:20,640 --> 00:01:25,410
Sobretot és important update50 quan vam començar a utilitzar CS50 Check.

24
00:01:25,410 --> 00:01:28,700
Així que assegura't que ho fas.

25
00:01:28,700 --> 00:01:30,760
>> Per a totes les seccions d'aquest conjunt de processadors,

26
00:01:30,760 --> 00:01:34,350
estarem tractant amb entrades i sortides d'arxius, arxivar I / O.

27
00:01:34,350 --> 00:01:38,140
Anem a anar a través d'una gran quantitat de programes que tenen a veure amb els arranjaments

28
00:01:38,140 --> 00:01:40,350
apunta a arxius i coses per l'estil,

29
00:01:40,350 --> 00:01:43,050
pel que volem assegurar-nos que estem molt familiaritzats i còmodes

30
00:01:43,050 --> 00:01:47,990
tractar amb la forma d'entrada i sortida en els arxius.

31
00:01:47,990 --> 00:01:52,080
>> En el codi de distribució per al conjunt de processadors és un arxiu anomenat copy.c,

32
00:01:52,080 --> 00:01:55,280
i això és el que trobarem serà molt útil per a nosaltres

33
00:01:55,280 --> 00:02:00,340
perquè anem a acabar copiant l'arxiu copy.c

34
00:02:00,340 --> 00:02:05,350
i només es modifiquen lleugerament per ser capaç d'aconseguir els primers 2 parts del conjunt de problemes.

35
00:02:05,350 --> 00:02:09,030
>> I llavors, com he dit abans, es tracta de mapes de bits, així com JPEG.

36
00:02:09,030 --> 00:02:13,170
Així que en realitat la comprensió de l'estructura de com s'organitzen els arxius,

37
00:02:13,170 --> 00:02:16,170
com realment podem traduir el 0 i 1 en les estructures

38
00:02:16,170 --> 00:02:19,040
i les coses que en realitat podem entendre i interpretar i editar,

39
00:02:19,040 --> 00:02:21,000
que serà molt important,

40
00:02:21,000 --> 00:02:25,970
així que anar en JPEG i arxius de mapa de bits i la comprensió de l'estructura d'aquests.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, com de costum, comença amb una secció de preguntes.

42
00:02:30,780 --> 00:02:36,600
Els que s'ocuparà d'arxiu d'E / S i aconseguir que acostumats a això.

43
00:02:36,600 --> 00:02:42,520
A continuació, la part 1 és Qui ho va fer, en el qual se't dóna un arxiu de mapa de bits

44
00:02:42,520 --> 00:02:45,630
que es veu una mica com punts vermells per tot arreu.

45
00:02:45,630 --> 00:02:52,180
I bàsicament el que farem és prendre aquest arxiu i editar només lleugerament

46
00:02:52,180 --> 00:02:54,010
en una versió que es pot llegir.

47
00:02:54,010 --> 00:02:56,000
Bàsicament, un cop que acabem, tindrem el mateix arxiu,

48
00:02:56,000 --> 00:03:02,630
excepte que serà capaç de veure el missatge ocult amagat per tots els punts vermells.

49
00:03:02,630 --> 00:03:07,310
Llavors Resize és un programa que, donat un arxiu

50
00:03:07,310 --> 00:03:11,490
i després es dóna el nom de l'arxiu que s'envia i se li dona un número així,

51
00:03:11,490 --> 00:03:16,850
realitat que canvia la mida de mapa de bits que valor sencer.

52
00:03:16,850 --> 00:03:19,240
Llavors, finalment, tenim el conjunt de processadors Recover.

53
00:03:19,240 --> 00:03:24,160
Se'ns ha donat una targeta de memòria i després haver de recuperar totes les fotos

54
00:03:24,160 --> 00:03:25,920
que han estat esborrats accidentalment,

55
00:03:25,920 --> 00:03:31,420
però, com anem a aprendre, no elimina realment i s'elimina l'arxiu;

56
00:03:31,420 --> 00:03:38,470
simplement una mica perdut en el qual es trobaven a l'arxiu, però anem a recuperar això.

57
00:03:38,470 --> 00:03:44,950
>> Gran. Així que va a l'arxiu d'E / S en concret, es tracta de tota una llista de funcions que s'utilitzarà.

58
00:03:44,950 --> 00:03:49,840
Ja has vist una mica els fonaments de fopen, fread, fwrite, i

59
00:03:49,840 --> 00:03:54,350
però anem a aprofundir en algun arxiu d'E / S funciona com fputc,

60
00:03:54,350 --> 00:03:56,930
en el qual acaba d'escriure un caràcter alhora,

61
00:03:56,930 --> 00:04:02,000
a fseek, on es mou el tipus d'indicador de posició del fitxer endavant i cap enrere,

62
00:04:02,000 --> 00:04:05,770
i després alguns altres. Però entrarem en això una mica més tard, durant el conjunt de processadors.

63
00:04:08,050 --> 00:04:13,100
>> Així que primer, només per entrar a l'arxiu d'E / S abans d'entrar en el conjunt de processadors,

64
00:04:13,100 --> 00:04:19,860
per obrir un arxiu, per exemple, el que has de fer és establir realment un punter a aquest arxiu.

65
00:04:19,860 --> 00:04:22,710
Així que tenim un punter FILE *.

66
00:04:22,710 --> 00:04:27,140
En aquest cas, estic cridant un punter perquè això serà la meva infile.

67
00:04:27,140 --> 00:04:33,340
Així que vaig a utilitzar la funció fopen i després el nom de l'arxiu

68
00:04:33,340 --> 00:04:36,360
i llavors la manera en què jo vaig a estar tractant amb l'arxiu.

69
00:04:36,360 --> 00:04:42,080
Així que hi ha "r" en aquest cas per a la lectura, "w" per a escriptura, i després "a" per annexar.

70
00:04:42,080 --> 00:04:44,270
Per exemple, quan vostè està tractant amb un infile

71
00:04:44,270 --> 00:04:47,310
i tot el que vols fer és llegir els bits i els bytes emmagatzemats allà,

72
00:04:47,310 --> 00:04:50,420
llavors vostè està probablement va a voler utilitzar "r" com la seva manera.

73
00:04:50,420 --> 00:04:54,520
Quan vulgui escriure en realitat, una espècie de fer un nou arxiu,

74
00:04:54,520 --> 00:04:57,220
llavors el que farem és que anem a obrir el nou arxiu

75
00:04:57,220 --> 00:05:02,410
i l'ús de la "w" manera d'escriptura.

76
00:05:02,410 --> 00:05:07,540
>> Així que quan vostè està en realitat la lectura en els arxius, l'estructura és la següent.

77
00:05:07,540 --> 00:05:14,930
En primer lloc s'inclou el punter a l'estructura que conté els bytes que vostè està llegint.

78
00:05:14,930 --> 00:05:19,830
Així que serà la ubicació final dels bytes que s'està llegint.

79
00:05:19,830 --> 00:05:23,360
Estàs passant després a indicar la mida, igual que, bàsicament, la quantitat de bytes

80
00:05:23,360 --> 00:05:30,100
el seu programa ha de llegir a l'arxiu, la mida, bàsicament, un element és,

81
00:05:30,100 --> 00:05:32,620
i llavors vostè va a especificar quants elements desitjada.

82
00:05:32,620 --> 00:05:34,980
I finalment, vostè ha de saber on vostè present,

83
00:05:34,980 --> 00:05:37,580
així que això serà el punter a.

84
00:05:37,580 --> 00:05:41,780
I codificats per color aquests perquè fread és també molt similar a fwrite,

85
00:05:41,780 --> 00:05:47,050
llevat que vostè vol assegurar-se que s'utilitza l'ordre correcte,

86
00:05:47,050 --> 00:05:51,960
assegurar-se que en realitat estàs escrivint o llegint des de l'arxiu correcte.

87
00:05:54,910 --> 00:05:58,610
>> Així que, com abans, si tenim la mida de l'element, així com el nombre d'elements,

88
00:05:58,610 --> 00:06:00,600
llavors podem jugar aquí una mica.

89
00:06:00,600 --> 00:06:06,810
Dir que tinc una estructura GOS I llavors vull llegir dos gossos alhora.

90
00:06:06,810 --> 00:06:12,450
El que podria fer és dir la mida d'un element que serà de la mida d'un gos

91
00:06:12,450 --> 00:06:14,770
i jo vaig a llegir realment dos.

92
00:06:14,770 --> 00:06:18,290
D'altra banda, el que podria fer és dir que només vaig a llegir un dels elements

93
00:06:18,290 --> 00:06:21,340
i que un element serà la mida de dos gossos.

94
00:06:21,340 --> 00:06:24,320
Així que això és anàloga com pot tipus de joc una mica amb la mida i el nombre de

95
00:06:24,320 --> 00:06:28,250
depenent del que és més intuïtiu per a vostè.

96
00:06:28,250 --> 00:06:30,810
>> Està bé. Ara arribem als arxius d'escriptura.

97
00:06:30,810 --> 00:06:36,880
Per escriure un arxiu, el primer argument és en realitat on vostè està llegint.

98
00:06:36,880 --> 00:06:42,050
Així que això és, bàsicament, les dades que es van a escriure en el fitxer,

99
00:06:42,050 --> 00:06:44,490
que és el punter al final.

100
00:06:44,490 --> 00:06:47,670
Així que quan vostè està tractant amb el conjunt de processadors, assegureu-vos que no es confonguin.

101
00:06:47,670 --> 00:06:50,480
Potser tenir el costat definicions a costat.

102
00:06:50,480 --> 00:06:58,090
Pot estirar les definicions al manual teclejant man i fwrite, per exemple,

103
00:06:58,090 --> 00:06:59,950
a la terminal, o pot referir-se a aquesta diapositiva

104
00:06:59,950 --> 00:07:03,570
i assegureu-vos que utilitzeu la correcta.

105
00:07:03,570 --> 00:07:08,700
Així que de nou, per fwrite, quan vostè té un arxiu que es vol escriure en,

106
00:07:08,700 --> 00:07:14,290
que serà l'últim argument i això serà un punter a aquest arxiu.

107
00:07:14,290 --> 00:07:18,670
Així que això és el que tractem d'escriure potser multibytes alhora,

108
00:07:18,670 --> 00:07:21,820
però diu que vol escriure just en només un caràcter únic.

109
00:07:21,820 --> 00:07:25,940
Com veurem més endavant en aquest exemple, en els mapes de bits que haurem de fer servir això.

110
00:07:25,940 --> 00:07:32,180
És llavors quan podem utilitzar fputc, essencialment només posar un caràcter alhora, chr,

111
00:07:32,180 --> 00:07:37,050
al punter d'arxiu, i aquest és el nostre punter per aquí.

112
00:07:38,700 --> 00:07:41,560
Així que cada vegada de buscar o escriure en un arxiu,

113
00:07:41,560 --> 00:07:44,690
l'arxiu és no perdre de vista on estem.

114
00:07:44,690 --> 00:07:47,810
Així que és una mena de cursor, l'indicador de posició de l'arxiu.

115
00:07:47,810 --> 00:07:54,330
I així, cada vegada que escrivim o llegim de nou en un arxiu,

116
00:07:54,330 --> 00:07:56,760
l'arxiu realment recorda on està,

117
00:07:56,760 --> 00:07:59,270
i pel que continua des d'on està el cursor.

118
00:07:59,270 --> 00:08:03,970
Això pot ser beneficiós quan es vol, per exemple, llegir en una certa quantitat per fer alguna cosa

119
00:08:03,970 --> 00:08:06,160
i després llegir en les següents quantitats,

120
00:08:06,160 --> 00:08:10,700
però de vegades pot ser que vulgui tornar o en realitat parteixen d'un valor de referència determinat.

121
00:08:10,700 --> 00:08:16,870
Llavors la funció fseek, el que fa és que ens permet moure el cursor en un determinat arxiu

122
00:08:16,870 --> 00:08:19,680
un cert nombre de bytes.

123
00:08:19,680 --> 00:08:24,260
I llavors el que hem de fer és especificar que el valor de referència és.

124
00:08:24,260 --> 00:08:31,520
Així que, o es mou cap endavant o cap enrere des de la posició del cursor en l'actualitat és,

125
00:08:31,520 --> 00:08:35,750
o es pot especificar que només s'ha de moure des del principi de l'arxiu

126
00:08:35,750 --> 00:08:37,090
o des del final de l'arxiu.

127
00:08:37,090 --> 00:08:41,230
I pel que pot passar en valors negatius o positius a quantitat,

128
00:08:41,230 --> 00:08:44,960
i que classe de moure el cursor cap endavant o cap enrere.

129
00:08:46,170 --> 00:08:51,920
>> Abans d'entrar en els conjunts de processadors altres preguntes a l'arxiu I / O?

130
00:08:53,860 --> 00:08:59,990
Bé. En entrar en més exemples, no dubti en deixar de fer preguntes.

131
00:08:59,990 --> 00:09:06,930
>> Així que en Whodunit, et va lliurar un arxiu de mapa de bits similar a aquesta xarxa a la diapositiva,

132
00:09:06,930 --> 00:09:14,510
i sembla que això - un munt de punts vermells - i no se sap molt bé el que està escrit.

133
00:09:14,510 --> 00:09:23,310
Si escodrinya, vostè pot ser capaç de veure un lleuger color blavós a l'interior del centre.

134
00:09:23,310 --> 00:09:26,270
En essència, això és on el text s'emmagatzema.

135
00:09:26,270 --> 00:09:30,270
Hi va haver un assassinat que va ocórrer, i hem de saber qui ho va fer.

136
00:09:30,270 --> 00:09:36,760
Per tal de fer això, hem de convertir aquesta espècie d'imatge en un format llegible.

137
00:09:36,760 --> 00:09:42,740
Si vostès he trobat això, de vegades no hi hauria kits petits

138
00:09:42,740 --> 00:09:48,510
on tindria una lupa amb una capa de color vermell. Algú? Si.

139
00:09:48,510 --> 00:09:52,770
Així que seria alguna cosa com això sola mà, vostè tindria una lupa

140
00:09:52,770 --> 00:09:58,130
amb la pel · lícula de color vermell sobre ell, el posaria sobre la imatge,

141
00:09:58,130 --> 00:10:03,410
i que seria capaç de veure el missatge ocult en ella.

142
00:10:03,410 --> 00:10:07,080
No tenim una lupa amb pel · lícula vermell, així que en comptes que anem a la classe de crear el nostre propi

143
00:10:07,080 --> 00:10:09,060
en aquest conjunt de processadors.

144
00:10:09,060 --> 00:10:15,760
I així, l'usuari va a whodunit entrada, llavors la pista,. Bmp,

145
00:10:15,760 --> 00:10:18,800
així que aquesta és la infile, aquest és el missatge de punt vermell,

146
00:10:18,800 --> 00:10:23,550
i llavors ells estan dient verdict.bmp serà el nostre arxiu de sortida.

147
00:10:23,550 --> 00:10:27,900
Així que crearà una imatge de mapa de bits similar a la idea d'una

148
00:10:27,900 --> 00:10:32,600
excepte en un format llegible en el qual podem veure el missatge ocult.

149
00:10:32,600 --> 00:10:37,550
>> Ja que estarem tractant amb l'edició i manipulació de mapes de bits d'algun tipus,

150
00:10:37,550 --> 00:10:42,400
anem a classe de busseig a en l'estructura d'aquests arxius de mapa de bits.

151
00:10:42,400 --> 00:10:48,130
Vam anar poc aquestes una mica en la conferència, però anem a veure-hi una mica més.

152
00:10:48,130 --> 00:10:51,740
Els mapes de bits són essencialment només un arranjament de bytes

153
00:10:51,740 --> 00:10:55,790
on hem especificat què significa el octets.

154
00:10:55,790 --> 00:11:00,540
Així que aquí és com un mapa de la imatge de mapa de bits

155
00:11:00,540 --> 00:11:08,550
dient que s'inicia amb alguns arxius de capçalera, s'inicia amb una mica d'informació en aquest país.

156
00:11:08,550 --> 00:11:16,540
Ja veus que a això de byte número 14 s'indica la mida de la imatge de mapa de bits,

157
00:11:16,540 --> 00:11:18,520
i es continua.

158
00:11:18,520 --> 00:11:23,810
Però el que realment estem interessats aquí està començant voltant del nombre de bytes 54.

159
00:11:23,810 --> 00:11:26,060
Tenim aquests triples RGB.

160
00:11:26,060 --> 00:11:30,760
El que farà és contenir els píxels reals, els valors de color.

161
00:11:30,760 --> 00:11:35,950
Tot això que en la capçalera és informació

162
00:11:35,950 --> 00:11:41,240
corresponent a la de la imatge, l'amplada de la imatge, i l'altura.

163
00:11:41,240 --> 00:11:44,930
Quan entrem en el farciment més tard, veurem per què la mida de la imatge

164
00:11:44,930 --> 00:11:48,670
pot ser diferent de l'amplada o l'alçada.

165
00:11:48,670 --> 00:11:54,240
Així que per representar aquests - aquestes imatges de mapa de bits són seqüències de bytes -

166
00:11:54,240 --> 00:11:59,370
el que podem fer és dir bé, jo recordaré que en l'índex 14,

167
00:11:59,370 --> 00:12:03,380
aquí és on la mida és, per exemple, però en canvi el que farem perquè això sigui més fàcil

168
00:12:03,380 --> 00:12:06,020
està encapsulat en una estructura.

169
00:12:06,020 --> 00:12:08,880
I així tenim dues estructures fetes per a nosaltres, un BITMAPFILEHEADER

170
00:12:08,880 --> 00:12:10,440
i un BITMAPINFOHEADER,

171
00:12:10,440 --> 00:12:14,840
i així cada vegada que llegim a aquest arxiu, per defecte que anirà en ordre,

172
00:12:14,840 --> 00:12:22,360
i el que per a ella també va a omplir en variables com ara biWidth i biSize.

173
00:12:25,270 --> 00:12:31,230
I, finalment, cada píxel està representat per tres bytes.

174
00:12:31,230 --> 00:12:35,500
La primera és la quantitat de blau al píxel, el segon és la quantitat de verd,

175
00:12:35,500 --> 00:12:41,120
i finalment, la quantitat de vermell, on 0 és essencialment no verd blau o no o no vermella

176
00:12:41,120 --> 00:12:43,720
i després ff és el valor màxim.

177
00:12:43,720 --> 00:12:46,800
Aquests són valors hexadecimals.

178
00:12:46,800 --> 00:12:53,870
Així que si tenim ff0000, llavors correspon a la quantitat màxima de blau

179
00:12:53,870 --> 00:12:58,890
i després no hi ha verd i vermell no, és així, que ens donaria un píxel blau.

180
00:12:58,890 --> 00:13:04,190
Llavors, si tenim tota ff a tots els terrenys, llavors això vol dir que tenim un píxel blanc.

181
00:13:04,190 --> 00:13:11,370
Això és una mica contrari al general, quan diem RGB. En realitat va BGR.

182
00:13:12,750 --> 00:13:18,990
>> Així que si realment es veuen en un exemple d'una imatge de mapa de bits - vull una tirada aquí.

183
00:13:31,560 --> 00:13:33,830
És una mica petita.

184
00:13:39,890 --> 00:13:47,840
Estic un acostament, i podem veure que està pixelada. Sembla que els blocs de color.

185
00:13:47,840 --> 00:13:50,110
Vostè té blocs blancs i després els blocs vermells.

186
00:13:50,110 --> 00:13:53,700
Si jugues a Microsoft Paint, per exemple, vostè podria fer el mateix

187
00:13:53,700 --> 00:13:58,960
bàsicament per pintar alguns quadrats en un ordre específic.

188
00:13:58,960 --> 00:14:08,060
Així que el que es tradueix en el mapa de bits és la següent.

189
00:14:08,060 --> 00:14:15,710
Aquí tenim primer píxels blancs, que són totes les 6 f, i llavors tenim píxels vermells,

190
00:14:15,710 --> 00:14:19,910
indicat per 0000ff.

191
00:14:19,910 --> 00:14:27,940
I així, la seqüència de bytes que tenim indica com la imatge de mapa de bits es veurà.

192
00:14:27,940 --> 00:14:32,230
Així que el que hem fet aquí és només per escrit amb tots aquests bytes i després es pinta en vermell

193
00:14:32,230 --> 00:14:37,550
perquè pugui classe de veure, si vostè escodrinya una mica, com aquest tipus d'indica una cara somrient.

194
00:14:40,180 --> 00:14:46,390
>> La manera com el treball de les imatges de mapa de bits que és bàsicament l'imaginem com una quadrícula.

195
00:14:46,390 --> 00:14:54,940
I així, per defecte, cada fila de la graella ha de ser un múltiple de 4 bytes.

196
00:15:00,520 --> 00:15:07,060
Si ens fixem en una imatge de mapa de bits, que està omplint cada valor.

197
00:15:07,060 --> 00:15:17,370
Per exemple, podeu tenir un vermell per aquí, un verd aquí, un blau aquí,

198
00:15:17,370 --> 00:15:24,950
però vostè ha de assegurar-se que la imatge es completa amb un múltiple de quatre bytes.

199
00:15:24,950 --> 00:15:32,200
Així que si vull que la meva imatge sigui tres quadres d'ample, llavors jo hauria de posar un valor buit

200
00:15:32,200 --> 00:15:35,640
en l'últim perquè sigui un múltiple de quatre.

201
00:15:35,640 --> 00:15:39,530
Així que m'agradaria afegir una cosa en què estem cridant farcit.

202
00:15:39,530 --> 00:15:43,750
Jo només vaig a indicar que hi ha amb una x.

203
00:15:44,920 --> 00:15:54,160
Ara diem que volem una imatge que és de 7 píxels de llarg, per exemple.

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

205
00:16:04,750 --> 00:16:07,000
i tot això s'omple amb el color.

206
00:16:07,000 --> 00:16:10,620
La manera com les imatges de mapa de bits funciona és que necessitem una octava.

207
00:16:10,620 --> 00:16:12,460
Ara tenim 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
Necessitem 8 espais per a la imatge de mapa de bits a llegir correctament.

209
00:16:19,360 --> 00:16:25,600
Així que el que hem de fer és afegir en tan sols una mica de farciment

210
00:16:25,600 --> 00:16:29,430
per assegurar-se que totes les amplades són uniformes

211
00:16:29,430 --> 00:16:34,260
i que totes les amplades són un múltiple de 4.

212
00:16:42,110 --> 00:16:47,310
I així s'ha indicat anteriorment, el farciment com una X o una línia ondulada,

213
00:16:47,310 --> 00:16:53,880
però en les imatges de mapa de bits reals el farciment s'indica mitjançant un 0 hexadecimal.

214
00:16:53,880 --> 00:16:57,340
Així que seria un personatge únic, 0.

215
00:16:58,980 --> 00:17:06,329
El que podria ser útil és la comanda xxd.

216
00:17:06,329 --> 00:17:11,220
El que fa és en realitat mostra que, igual que similar al que feia abans amb el smiley

217
00:17:11,220 --> 00:17:15,630
quan en realitat el que imprimeix cada color seria per al píxel

218
00:17:15,630 --> 00:17:21,800
i després un codi de colors, quan s'executa xxd amb els següents comandaments,

219
00:17:21,800 --> 00:17:28,670
llavors en realitat s'imprimirà el que els colors són per a aquells píxels.

220
00:17:28,670 --> 00:17:33,810
El que has de fer és indicar aquí que, igual que la s-54

221
00:17:33,810 --> 00:17:36,530
diu que jo vaig a començar pel byte 54

222
00:17:36,530 --> 00:17:40,820
perquè abans d'això, recordeu que si mirem enrere per al mapa dels mapes de bits,

223
00:17:40,820 --> 00:17:42,690
aquesta és tota la informació de capçalera i coses per l'estil.

224
00:17:42,690 --> 00:17:46,280
Però el que realment importa és els píxels reals que indiquen el color.

225
00:17:46,280 --> 00:17:52,700
Per tant afegint en aquesta bandera,-s 54, llavors som capaços de veure els valors de color.

226
00:17:52,700 --> 00:17:56,020
I no et preocupis per les banderes complicades i coses per l'estil.

227
00:17:56,020 --> 00:18:05,020
En l'especificació del conjunt de problemes, tindrà instruccions sobre com utilitzar xxd per mostrar els píxels.

228
00:18:07,070 --> 00:18:15,590
Així que si vostè veu aquí, és com que s'assembla a una caixa verda, això és poca cosa.

229
00:18:15,590 --> 00:18:23,610
He codificat per colors com el 00FF00 bàsicament dient que no blau, molt verd i vermell no.

230
00:18:23,610 --> 00:18:26,370
Així que correspon a verd.

231
00:18:26,370 --> 00:18:31,920
Com es veu aquí, veiem un rectangle verd.

232
00:18:31,920 --> 00:18:36,660
Aquest rectangle verd és a 3 píxels d'ample, de manera que llavors el que hem de fer

233
00:18:36,660 --> 00:18:44,350
per assegurar-se que la imatge és un múltiple de 4 d'ample és afegir en un encoixinat addicional.

234
00:18:44,350 --> 00:18:49,460
I llavors així és com es veu aquests 0s aquí.

235
00:18:49,460 --> 00:18:54,510
En realitat, això és el resultat del seu conjunt de processadors de mida,

236
00:18:54,510 --> 00:19:01,350
essencialment prendre la petita mapa de bits i després ampliar per 4.

237
00:19:01,350 --> 00:19:09,380
I així, el que veiem és que en realitat aquesta imatge és de 12 píxels d'amplada, però 12 és un múltiple de 4,

238
00:19:09,380 --> 00:19:12,940
pel que en realitat no veig cap 0s al final perquè no cal afegir cap

239
00:19:12,940 --> 00:19:19,070
perquè està totalment encoixinat. No té sala més.

240
00:19:20,720 --> 00:19:23,470
>> Bé. Qualsevol pregunta sobre farcit?

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

242
00:19:27,460 --> 00:19:32,520
>> Com he esmentat abans, els mapes de bits són més que una seqüència de bytes.

243
00:19:32,520 --> 00:19:39,170
I així, el que tenim és en lloc d'haver de portar un registre d'exactament quin nombre de bytes

244
00:19:39,170 --> 00:19:47,050
correspon a un element específic, que en realitat han creat una estructura per representar això.

245
00:19:47,050 --> 00:19:50,930
Així que el que tenim és una estructura RGBTRIPLE.

246
00:19:50,930 --> 00:19:54,590
Sempre que tingui una instància d'un triple RGB,

247
00:19:54,590 --> 00:20:00,970
perquè es tracta d'un tipus struct defineix, llavors vostè pot accedir a la variable rgbtBlue,

248
00:20:00,970 --> 00:20:09,520
de manera similar les variables de verd i vermell, que indiquen la quantitat de blau, verd i vermell

249
00:20:09,520 --> 00:20:11,580
respectivament, que vostè té.

250
00:20:11,580 --> 00:20:16,800
>> Així que si tenim la variable de blau a 0, el conjunt verd a ff,

251
00:20:16,800 --> 00:20:22,060
que és el valor màxim que pot tenir, i llavors la variable vermell ajustat a 0,

252
00:20:22,060 --> 00:20:27,870
llavors, ¿quin color seria el particular triples RGB representa? >> [Estudiant] Green.

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

254
00:20:29,150 --> 00:20:34,480
Serà útil saber que cada vegada que tingui una instància d'un triple RGB,

255
00:20:34,480 --> 00:20:41,340
en realitat es pot accedir a la quantitat de color - blau, verd i vermell - per separat.

256
00:20:43,350 --> 00:20:54,900
>> Ara que hem parlat de l'estructura d'això, anem a fer una ullada a l'arxiu BMP.

257
00:20:54,900 --> 00:20:57,870
Aquestes són estructures fetes per a vostè.

258
00:20:57,870 --> 00:21:01,820
Aquí tenim una estructura BITMAPFILEHEADER.

259
00:21:01,820 --> 00:21:07,610
D'interès és la mida.

260
00:21:07,610 --> 00:21:12,660
Més tard, tenim la informació de capçalera, que té un parell de coses més que són interessants per a nosaltres,

261
00:21:12,660 --> 00:21:15,480
a saber, la grandària, l'amplada, i l'alçada.

262
00:21:15,480 --> 00:21:19,170
Com entrarem en més tard, quan es llegeix a l'arxiu,

263
00:21:19,170 --> 00:21:25,500
es llegeix automàticament en perquè hem creat l'ordre de ser el mateix.

264
00:21:25,500 --> 00:21:31,990
Així la biSize contindrà els bytes adequades que es corresponen amb la mida real de la imatge.

265
00:21:34,700 --> 00:21:40,500
I aquí, finalment, com ja hem parlat, tenim el typedef struct RGBTRIPLE.

266
00:21:40,500 --> 00:21:46,840
Tenim una rgbtBlue, verd i vermell associat a ell.

267
00:21:48,210 --> 00:21:49,340
>> Gran. Bé.

268
00:21:49,340 --> 00:21:56,360
Ara que entenem els mapes de bits una mica, entenem que tenim un arxiu de capçalera

269
00:21:56,360 --> 00:22:00,790
i una capçalera d'informació de la mateixa i després d'això, tenim les coses interessants

270
00:22:00,790 --> 00:22:05,110
dels colors, i els colors estan representats per les estructures RGBTRIPLE,

271
00:22:05,110 --> 00:22:12,710
i els que, al seu torn, té tres valors associats a la blava, el verd i el vermell.

272
00:22:12,710 --> 00:22:17,270
>> Així que ara, podem pensar en classe de recuperar una mica.

273
00:22:17,270 --> 00:22:20,130
Em sap greu. Penseu Whodunit.

274
00:22:20,130 --> 00:22:25,750
Quan tenim el nostre arxiu de pista, llavors el que volem fer és llegir-hi píxel per píxel

275
00:22:25,750 --> 00:22:33,860
i llavors d'alguna manera canviar els píxels de manera que puguem donar sortida a un format llegible.

276
00:22:33,860 --> 00:22:41,020
I així, per donar sortida, escriurem píxel per píxel a l'arxiu verdict.bmp.

277
00:22:41,020 --> 00:22:45,120
Això és una mica molt per fer. Ens adonem d'això.

278
00:22:45,120 --> 00:22:49,860
Així que el que hem fet és que hem fet li va proporcionar copy.c.

279
00:22:49,860 --> 00:22:57,610
El que fa és copy.c només fa una còpia exacta d'un arxiu de mapa de bits donat i després l'emet.

280
00:22:57,610 --> 00:23:01,900
Així que això ja s'obre l'arxiu per a vostè, es llegeix en píxel per píxel,

281
00:23:01,900 --> 00:23:04,510
i llavors s'escriu en un arxiu de sortida en.

282
00:23:04,510 --> 00:23:07,080
>> Anem a fer una ullada a això.

283
00:23:13,390 --> 00:23:18,290
Aquesta és assegurar l'ús adequat,

284
00:23:18,290 --> 00:23:22,640
obtenir els noms dels arxius aquí.

285
00:23:22,640 --> 00:23:29,940
El que això fa és que estableix el fitxer d'entrada sigui el que hem passat al infile aquí,

286
00:23:29,940 --> 00:23:34,750
que és el nostre segon argument de línia d'ordres.

287
00:23:34,750 --> 00:23:37,640
S'assegura que puguem obrir l'arxiu.

288
00:23:38,960 --> 00:23:44,860
Xecs per assegurar-nos que podem fer un nou arxiu de sortida aquí.

289
00:23:45,630 --> 00:23:53,270
Llavors, què fa aquest aquí, només, bàsicament, comença a llegir a l'arxiu de mapa de bits des del principi.

290
00:23:53,270 --> 00:23:56,700
El començament, com sabem, conté el BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
i pel que aquestes seqüències de bits directament completarà el BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Així que el que tenim aquí està dient que bf BITMAPFILEHEADER -

293
00:24:07,940 --> 00:24:13,150
aquesta és la nostra nova variable de tipus BITMAPFILEHEADER -

294
00:24:13,150 --> 00:24:22,560
posarem dins bf el que llegim de punter, que és el nostre infile.

295
00:24:22,560 --> 00:24:23,970
Quant llegim?

296
00:24:23,970 --> 00:24:32,160
Llegim en la quantitat de bytes que necessitem per contenir el BITMAPFILEHEADER conjunt.

297
00:24:32,160 --> 00:24:34,660
De la mateixa manera, això és el que fem per la informació de capçalera.

298
00:24:34,660 --> 00:24:39,010
Així que seguim al llarg del nostre arxiu al infile,

299
00:24:39,010 --> 00:24:44,360
i ens estem llegint els bits i bytes, i els estem connectant directament en

300
00:24:44,360 --> 00:24:47,880
en aquests casos de les variables que estem fent.

301
00:24:49,370 --> 00:24:53,800
Aquí només estem assegurant que el mapa de bits és un mapa de bits.

302
00:24:57,670 --> 00:25:01,030
>> Ara tenim un arxiu de sortida, no?

303
00:25:01,030 --> 00:25:04,420
Així que tal com està quan ho creguem, és essencialment buit.

304
00:25:04,420 --> 00:25:07,710
Així que hem de crear un nou mapa de bits, bàsicament, a partir de zero.

305
00:25:07,710 --> 00:25:12,280
El que fem és que ens hem d'assegurar de copiar a l'arxiu de capçalera

306
00:25:12,280 --> 00:25:16,850
i la informació de capçalera igual que el infile té.

307
00:25:16,850 --> 00:25:22,850
El que fem és escriure - i recordi que bf és la variable

308
00:25:22,850 --> 00:25:29,300
de BITMAPFILEHEADER tipus, així que el que fem és que només ha d'utilitzar aquest contingut

309
00:25:29,300 --> 00:25:34,980
per escriure al fitxer de sortida.

310
00:25:36,550 --> 00:25:38,510
En aquest sentit, recordo que parlem sobre el farciment,

311
00:25:38,510 --> 00:25:47,820
com és important assegurar-se que la quantitat de píxels que tenim és un múltiple de 4.

312
00:25:47,820 --> 00:25:52,790
Aquesta és una fórmula molt útil per calcular la quantitat de farciment que té

313
00:25:52,790 --> 00:25:57,670
donada l'amplada del seu arxiu.

314
00:25:57,670 --> 00:26:04,120
Jo vull que vostès recordin que en copy.c tenim una fórmula per al càlcul de farciment.

315
00:26:04,120 --> 00:26:07,970
¿D'acord? Així que tothom recorda això. Gran.

316
00:26:07,970 --> 00:26:14,050
Llavors, què fa copy.c següent és que es repeteix en totes les línies d'exploració.

317
00:26:14,050 --> 00:26:23,730
Passa a través de les files primera i després emmagatzema cada triple que es llegeix

318
00:26:23,730 --> 00:26:26,920
i llavors s'escriu al fitxer de sortida.

319
00:26:26,920 --> 00:26:33,120
Així que aquí estem llegint només un triple de RGB alhora

320
00:26:33,120 --> 00:26:39,860
i després posar que Triple mateixos a l'arxiu de sortida.

321
00:26:41,120 --> 00:26:48,340
La part difícil és que el farciment no és un triple RGB,

322
00:26:48,340 --> 00:26:55,200
i per tant no podem llegir aquesta quantitat de farcit triples RGB.

323
00:26:55,200 --> 00:27:01,460
El que hem de fer és en realitat només moure el nostre indicador de posició del fitxer, desplaçar el cursor,

324
00:27:01,460 --> 00:27:06,840
al tipus de saltar tot el farciment de manera que estem a la fila següent.

325
00:27:06,840 --> 00:27:12,990
I llavors el que fa és copiar mostra com és possible que vulgueu afegir el farcit.

326
00:27:12,990 --> 00:27:14,990
Per això hem calculat la quantitat de farciment que necessitem,

327
00:27:14,990 --> 00:27:18,220
el que significa que necessitem encoixinat nombre de 0s.

328
00:27:18,220 --> 00:27:24,510
El que fa és un bucle que situa el nombre de 0s encoixinat al nostre arxiu de sortida.

329
00:27:24,510 --> 00:27:31,170
I, finalment, es tanca dos arxius. Es tanca el infile així com l'arxiu de sortida.

330
00:27:31,170 --> 00:27:34,870
>> Així és com funciona copy.c,

331
00:27:34,870 --> 00:27:37,430
i això serà molt útil.

332
00:27:39,720 --> 00:27:43,750
En comptes de en realitat directament copiar i enganxar

333
00:27:43,750 --> 00:27:46,800
o simplement mirar i escriure el que vulguis,

334
00:27:46,800 --> 00:27:49,440
molts de vosaltres voleu per executar aquesta comanda a la terminal,

335
00:27:49,440 --> 00:27:54,520
cp copy.c whodunit.c i això tindrà un nou arxiu, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
que inclou el contingut exactament com còpia ho fa.

337
00:27:58,330 --> 00:28:03,880
Així que el que podem fer és usar això com una base sobre la qual construir i editar

338
00:28:03,880 --> 00:28:06,900
per al nostre arxiu novel · la policíaca.

339
00:28:08,500 --> 00:28:14,670
>> Aquestes són les nostres tasques pendents de fer per Whodunit, però què copy.c

340
00:28:14,670 --> 00:28:16,730
en realitat s'encarrega de la major part d'ells per a nosaltres.

341
00:28:16,730 --> 00:28:21,900
Així que tot el que hem de fer ara és canviar els píxels segons sigui necessari

342
00:28:21,900 --> 00:28:25,920
per fer realitat el fitxer de lectura.

343
00:28:25,920 --> 00:28:32,960
Recordeu que per a un píxel donat, triple, així que per a una variable donada d'RGBTRIPLE tipus,

344
00:28:32,960 --> 00:28:35,990
pot accedir als valors de blau, verd i vermell.

345
00:28:35,990 --> 00:28:38,670
Això serà molt útil perquè si es pot accedir a ells,

346
00:28:38,670 --> 00:28:41,770
que significa que també es pot comprovar,

347
00:28:41,770 --> 00:28:45,430
i això vol dir que també es pot canviar.

348
00:28:45,430 --> 00:28:49,430
>> Així que quan vam tornar al nostre exemple vermell lupa,

349
00:28:49,430 --> 00:28:53,390
bàsicament, que actuava com una mena de filtre per a nosaltres.

350
00:28:53,390 --> 00:28:58,160
Així que el que vull fer és que volem filtrar tots els triples que vénen polz

351
00:28:58,160 --> 00:29:01,240
Hi ha diverses maneres de fer això.

352
00:29:01,240 --> 00:29:07,100
Bàsicament, vostè pot tenir qualsevol tipus de filtre que desitgi.

353
00:29:07,100 --> 00:29:09,890
Potser vostè vol canviar tots els píxels vermells

354
00:29:09,890 --> 00:29:13,570
o potser voleu canviar un píxel de color a un color diferent.

355
00:29:13,570 --> 00:29:15,400
Això depèn de tu.

356
00:29:15,400 --> 00:29:19,580
Recordi que vostè pot veure que el color del píxel és

357
00:29:19,580 --> 00:29:23,000
i també es pot canviar a mesura que estàs passant.

358
00:29:24,410 --> 00:29:26,420
>> Bé. Així que això és Whodunit.

359
00:29:26,420 --> 00:29:32,760
Quan executi Qui ho va fer, vostè sabrà qui és el culpable del crim era.

360
00:29:32,760 --> 00:29:35,540
>> Ara anirem a canviar la mida.

361
00:29:35,540 --> 00:29:37,990
Anem a encara estar tractant amb mapes de bits.

362
00:29:37,990 --> 00:29:40,750
El que farem és que tindrem un mapa de bits d'entrada

363
00:29:40,750 --> 00:29:45,890
i després passarem a un nombre i obtenir un mapa de bits archivosalida

364
00:29:45,890 --> 00:29:51,380
on això és bàsicament el nostre infile escalat per n.

365
00:29:54,670 --> 00:30:01,450
Vaig donar la meva arxiu era només un píxel gran.

366
00:30:01,450 --> 00:30:09,100
Llavors, si el meu n va ser de 3, escalat per 3, llavors m'agradaria repetir aquest píxel n nombre de vegades,

367
00:30:09,100 --> 00:30:14,410
per la qual cosa 3 vegades, i després també redueix l'escala 3 vegades també.

368
00:30:14,410 --> 00:30:17,840
Així que ja veus que estic escalant tant vertical com horitzontalment.

369
00:30:17,840 --> 00:30:19,680
>> I heus aquí un exemple.

370
00:30:19,680 --> 00:30:27,590
Si té n = 2, es veu que el píxel blau principi no va repetir dues vegades

371
00:30:27,590 --> 00:30:30,930
tant horitzontal com verticalment dues vegades.

372
00:30:30,930 --> 00:30:38,040
I després que segueix endavant, i perquè tingui una ampliació directa de la imatge original en dues.

373
00:30:40,920 --> 00:30:47,600
>> Així que si ens anàvem a detall el pseudocodi per això, volem obrir l'arxiu.

374
00:30:47,600 --> 00:30:49,880
I després, sabent que si tornem aquí,

375
00:30:49,880 --> 00:30:54,540
veiem que l'amplada per l'arxiu de sortida que serà diferent de l'amplada de la infile.

376
00:30:54,540 --> 00:30:56,130
Què significa això?

377
00:30:56,130 --> 00:31:01,230
Això vol dir que la nostra informació de capçalera es canviarà.

378
00:31:01,230 --> 00:31:03,790
I què hem de voler fer és actualitzar la informació de la capçalera,

379
00:31:03,790 --> 00:31:11,820
sabent que quan llegim en els arxius si vostè està treballant en el marc copy.c,

380
00:31:11,820 --> 00:31:17,570
ja tenim una variable que indica quin és la mida és i coses així.

381
00:31:17,570 --> 00:31:24,060
Així que un cop aconseguit això, el que pot voler fer és canviar aquestes variables particulars.

382
00:31:24,060 --> 00:31:29,380
Recordi, si vostè té una estructura, com s'accedeix a les variables dins d'això.

383
00:31:29,380 --> 00:31:32,080
S'utilitza l'operador punt, no?

384
00:31:32,080 --> 00:31:36,420
Així que amb això, ja saps que hauràs de canviar la informació de la capçalera.

385
00:31:36,480 --> 00:31:41,030
Així que aquesta és només una llista dels elements reals que es canviaran a l'arxiu.

386
00:31:41,030 --> 00:31:45,180
La mida de l'arxiu que es va a canviar, la imatge, així com l'amplada i l'alçada.

387
00:31:45,180 --> 00:31:50,080
Així que tornar al mapa dels mapes de bits,

388
00:31:50,080 --> 00:31:57,730
veure si es tracta de la capçalera de l'arxiu o la informació de capçalera que conté aquesta informació

389
00:31:57,730 --> 00:32:00,920
i després canviar segons sigui necessari.

390
00:32:05,010 --> 00:32:12,470
Una vegada més, per exemple cp copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
Això vol dir que resize.c ara conté tot el que està contingut a l'interior còpia

392
00:32:19,270 --> 00:32:24,490
còpia perquè ens proporciona una forma de lectura en línia d'exploració a cada píxel a píxel.

393
00:32:24,490 --> 00:32:29,860
Només que ara, en comptes de canviar els valors com ho vam fer en Whodunit,

394
00:32:29,860 --> 00:32:37,980
el que volem fer és que volem escriure en diversos píxels

395
00:32:37,980 --> 00:32:43,580
mentre el nostre n és més gran que 1.

396
00:32:43,580 --> 00:32:47,110
>> Llavors el que vull fer és el volem estirar horitzontalment per n,

397
00:32:47,110 --> 00:32:50,490
així com que s'estenen verticalment per n.

398
00:32:50,490 --> 00:32:52,710
Com podem fer això?

399
00:32:52,710 --> 00:32:56,890
Diguem que el seu n és 2 i que té esta donat infile.

400
00:32:56,890 --> 00:32:58,730
El cursor es començarà pel primer,

401
00:32:58,730 --> 00:33:03,530
i el que vol fer si n és 2, que voleu imprimir en 2 d'ells.

402
00:33:03,530 --> 00:33:05,490
Així d'imprimir en dos d'ells.

403
00:33:05,490 --> 00:33:10,830
A continuació, el cursor es passarà a la següent píxel, que és el vermell,

404
00:33:10,830 --> 00:33:18,400
i que voleu imprimir 2 de aquests vermells, afegint que en el que ha fet abans.

405
00:33:18,400 --> 00:33:26,280
A continuació, el cursor es mourà a la següent píxel i dibuixar en 2 d'ells.

406
00:33:26,280 --> 00:33:37,180
Si es mira de nou a la copy.c marc, el que això fa aquí

407
00:33:37,180 --> 00:33:42,830
es crea una nova instància d'un triple RGB, una nova variable anomenada triple.

408
00:33:42,830 --> 00:33:50,500
I aquí quan llegeix-hi, ho fa des de l'1 infile RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
i s'emmagatzema en l'interior d'aquesta variable triple.

410
00:33:53,470 --> 00:33:57,590
Així que en realitat té una variable que representa aquest píxel en particular.

411
00:33:57,590 --> 00:34:05,290
Llavors, quan vostè escriu, el que pot voler fer és tancar la declaració fwrite en un bucle for

412
00:34:05,290 --> 00:34:11,080
que escriu en el seu arxiu de sortida tantes vegades com sigui necessari.

413
00:34:17,449 --> 00:34:20,100
Això és bastant simple.

414
00:34:20,200 --> 00:34:27,590
Així, bàsicament, repeteixi el procés d'escriptura núm nombre de vegades per escalar horitzontalment.

415
00:34:27,590 --> 00:34:32,969
>> Però hem de recordar que el nostre farcit es canviarà.

416
00:34:47,350 --> 00:34:53,020
Abans, dir que vam tenir una mica de longitud 3.

417
00:34:53,020 --> 00:35:00,130
Llavors ens tornaríem a afegir en el farciment? Només un més perquè sigui un múltiple de 4.

418
00:35:00,130 --> 00:35:10,480
Però dir que estem escalant aquesta imatge en particular per n = 2.

419
00:35:10,480 --> 00:35:16,300
Llavors quants píxels blaus tindríem al final? Hauríem 6.

420
00:35:16,300 --> 00:35:21,470
1, 2, 3, 4, 5, 6. Està bé.

421
00:35:21,470 --> 00:35:26,580
6 no és un múltiple de 4. Quin és el més proper múltiple de 4? Això serà 8.

422
00:35:26,580 --> 00:35:33,200
Així que estem realment tindrà dos caràcters de farciment allà.

423
00:35:33,200 --> 00:35:38,720
>> Algú recorda si tenim una fórmula per calcular el farciment

424
00:35:38,720 --> 00:35:41,350
i on podria estar?

425
00:35:41,350 --> 00:35:45,160
[Resposta dels estudiants inaudible] >> Sí, copy.c. Dreta.

426
00:35:45,160 --> 00:35:49,800
Hi ha una fórmula en copy.c per calcular la quantitat de farciment que té

427
00:35:49,800 --> 00:35:53,810
donat una amplada particular de la imatge de mapa de bits.

428
00:35:53,810 --> 00:36:02,950
Així que serà útil quan es necessita afegir en una certa quantitat de farcit

429
00:36:02,950 --> 00:36:06,160
d'entendre realment a terme el farciment ha de afegir.

430
00:36:10,820 --> 00:36:15,850
Però una nota, però, és que vostè vol assegurar-se que vostè està utilitzant la mida correcta.

431
00:36:15,850 --> 00:36:21,410
Només vés amb compte perquè estàs bàsicament estarà tractant amb dues imatges de mapa de bits.

432
00:36:21,410 --> 00:36:23,410
Vostè vol assegurar-se que utilitzeu la correcta.

433
00:36:23,410 --> 00:36:26,820
Quan vostè està calculant el farciment per l'arxiu de sortida, que desitja utilitzar tot l'ample de l'arxiu de sortida

434
00:36:26,820 --> 00:36:29,860
i no l'ample de l'anterior.

435
00:36:29,860 --> 00:36:37,240
>> Gran. Aquest tipus d'estirament es fa càrrec d'una imatge de mapa de bits total horitzontalment.

436
00:36:37,240 --> 00:36:41,290
Però el que vull fer és realment estirar verticalment també.

437
00:36:41,290 --> 00:36:48,760
Això serà una mica més complicat perquè quan hem acabat de copiar una fila

438
00:36:48,760 --> 00:36:51,580
i escriure aquesta fila, el nostre cursor estarà a l'extrem.

439
00:36:51,580 --> 00:36:56,210
Així que si tornem a llegir, llavors només va a llegir a la següent línia.

440
00:36:56,210 --> 00:37:03,660
Així que el que vull fer és una espècie de trobar alguna manera de copiar les files de nou

441
00:37:03,660 --> 00:37:12,500
o simplement prendre aquest tipus de fila i després tornar a escriure de nou.

442
00:37:14,380 --> 00:37:17,940
Com tipus d'al · lusió, hi ha diverses maneres de fer això.

443
00:37:17,940 --> 00:37:23,040
El que podria fer és que estàs passant i la lectura a través de la línia d'exploració especial

444
00:37:23,040 --> 00:37:28,560
i canviar segons sigui necessari i tot tipus de botiga dels píxels en una matriu.

445
00:37:28,560 --> 00:37:36,350
Després, més tard vostè sap que vostè haurà d'imprimir la matriu de nou,

446
00:37:36,350 --> 00:37:39,830
i pel que només es pot utilitzar la matriu per fer això.

447
00:37:39,830 --> 00:37:44,500
Una altra manera de fer-ho és que es podria copiar una fila cap avall,

448
00:37:44,500 --> 00:37:47,950
Entenc que ha de copiar de nou, pel que en realitat mou el cursor,

449
00:37:47,950 --> 00:37:50,950
i que utilitzarà el mètode fseek.

450
00:37:50,950 --> 00:37:56,410
Vostè pot moure el cursor fins al final de nou i repeteixi el procés de còpia de nou.

451
00:37:56,410 --> 00:38:03,960
>> Així que si el nostre nombre d'escala és n, llavors quantes vegades hem de tornar

452
00:38:03,960 --> 00:38:10,500
i tornar a escriure una línia? >> [Estudiant] n - 1. >> Sí, perfecte. n - 1.

453
00:38:10,500 --> 00:38:14,390
Ho hem fet ja una vegada, de manera que a continuació anem a voler repetir el procés de tornada enrere

454
00:38:14,390 --> 00:38:17,460
n - 1 quantitat de vegades.

455
00:38:22,730 --> 00:38:25,860
Bé. Així que aquí tenen la funció de canvi de mida.

456
00:38:25,860 --> 00:38:34,360
>> Ara podem arribar a una part molt divertit, el meu favorit conjunt de processadors, que és Recover.

457
00:38:34,360 --> 00:38:39,580
En lloc de mapes de bits, aquesta vegada estem tractant amb arxius JPEG.

458
00:38:39,580 --> 00:38:43,370
Estem en realitat no dóna un sol arxiu d'imatges JPEG,

459
00:38:43,370 --> 00:38:46,600
i quan ens donin bàsicament un format raw targeta de memòria.

460
00:38:46,600 --> 00:38:51,790
I pel que aquest conté una mica d'informació de valors i les escombraries al principi,

461
00:38:51,790 --> 00:38:57,240
i després comença i té un munt d'arxius JPEG.

462
00:38:57,240 --> 00:39:03,430
No obstant això, ens va lliurar una targeta en la qual ha esborrat les fotos;

463
00:39:03,430 --> 00:39:08,300
en essència, ens hem oblidat d'on les fotos es troben dins de la targeta.

464
00:39:08,300 --> 00:39:12,770
Així que la nostra tasca de recuperar és anar a través d'aquest format de targeta

465
00:39:12,770 --> 00:39:16,500
i trobar aquestes fotos una altra vegada.

466
00:39:16,500 --> 00:39:23,990
>> Per sort, l'estructura d'arxius JPEG i l'arxiu de la targeta és una mica d'ajuda.

467
00:39:23,990 --> 00:39:28,850
Que sens dubte podria haver estat una mica més complicat si no fos en aquest format en particular.

468
00:39:28,850 --> 00:39:40,160
Cada arxiu JPEG en realitat comença amb dues seqüències possibles, enumerats anteriorment.

469
00:39:40,160 --> 00:39:42,970
Bàsicament, cada vegada que tingui un nou arxiu JPEG,

470
00:39:42,970 --> 00:39:52,720
que comença amb la seqüència de qualsevol ffd8 FFE0 ol'altre, ffd8 ffe1.

471
00:39:52,720 --> 00:39:59,530
Una altra cosa útil és saber que els arxius JPEG s'emmagatzemen de forma contigua.

472
00:39:59,530 --> 00:40:03,380
Així que cada vegada que un arxiu JPEG acaba, l'altre comença.

473
00:40:03,380 --> 00:40:07,070
Així que no hi ha cap tipus d'en-entre els valors d'aquest país.

474
00:40:07,070 --> 00:40:15,510
Quan arribi l'inici d'un arxiu JPEG, si ja has estat llegint un arxiu JPEG,

475
00:40:15,510 --> 00:40:21,800
saps que has arribat al final de l'anterior i el començament de la següent.

476
00:40:21,800 --> 00:40:25,890
>> Per tipus de visualitzar això, vaig fer un esquema.

477
00:40:25,890 --> 00:40:36,910
Una altra cosa sobre els arxius JPEG és que podem llegir en les seqüències de 512 bytes al mateix temps,

478
00:40:36,910 --> 00:40:39,380
de manera similar amb el començament de la targeta.

479
00:40:39,380 --> 00:40:43,370
No necessitem estar comprovant cada byte únic, ja que seria un fàstic.

480
00:40:43,370 --> 00:40:48,200
Així que en comptes, el que podem fer és en realitat acabo de llegir en 512 bytes alhora

481
00:40:48,200 --> 00:40:54,700
i llavors, en lloc de comprovar entre els d'aquestes porcions diminutes,

482
00:40:54,700 --> 00:40:58,640
només podem comprovar l'inici dels 512 bytes.

483
00:40:58,640 --> 00:41:02,570
Essencialment, en aquesta imatge, el que es veu és en el començament de la targeta,

484
00:41:02,570 --> 00:41:08,700
ha valors que no són realment rellevants per als arxius JPEG en si mateixes.

485
00:41:08,700 --> 00:41:15,830
Però llavors el que tenim és un estel per indicar una de les dues seqüències de partida per a un JPEG.

486
00:41:15,830 --> 00:41:19,910
Així que cada vegada que vegi un estel, vostè sap que té un arxiu JPEG.

487
00:41:19,910 --> 00:41:25,030
I llavors tots els arxius JPEG serà un múltiple de 512 bytes

488
00:41:25,030 --> 00:41:27,880
però no necessàriament el mateix múltiple.

489
00:41:27,880 --> 00:41:32,050
La manera com vostè sap que vostè ha colpejat una altra JPEG és si es colpeja una altra estrella,

490
00:41:32,050 --> 00:41:39,090
altra seqüència de partida de bytes.

491
00:41:39,090 --> 00:41:43,330
Llavors, el que tenim aquí és que tingui l'arxiu JPEG vermell continua fins arribar a una estrella,

492
00:41:43,330 --> 00:41:45,150
que s'indica mitjançant un color nou.

493
00:41:45,150 --> 00:41:48,510
Vostè continua i llavors va colpejar una altra estrella, que va xocar amb un altre format JPEG,

494
00:41:48,510 --> 00:41:50,590
continua tot el camí fins al final.

495
00:41:50,590 --> 00:41:53,180
Ets a l'última foto aquí, el rosa.

496
00:41:53,180 --> 00:41:58,220
Veu fins al final fins arribar a la final del personatge arxiu.

497
00:41:58,220 --> 00:42:00,820
Això serà realment útil.

498
00:42:00,820 --> 00:42:03,170
>> A pocs robatoris de pilota principals aquí:

499
00:42:03,170 --> 00:42:06,670
L'arxiu de la targeta no s'inicia amb un arxiu JPEG,

500
00:42:06,670 --> 00:42:13,350
però una vegada que comença un JPEG, tots els arxius JPEG s'emmagatzemen costat a costat entre si.

501
00:42:17,520 --> 00:42:20,420
>> Alguns pseudocodi per a la Recuperació.

502
00:42:20,420 --> 00:42:22,570
En primer lloc, anem a obrir el nostre arxiu de targeta,

503
00:42:22,570 --> 00:42:27,500
i que estarà usant nostre arxiu d'E / S funcions.

504
00:42:27,500 --> 00:42:32,430
Anem a repetir el procés fins que hem arribat al final del fitxer.

505
00:42:32,430 --> 00:42:36,450
Anem a llegir 512 bytes alhora.

506
00:42:36,450 --> 00:42:39,180
I el que vull dir aquí és que anem a guardar-lo en un buffer,

507
00:42:39,180 --> 00:42:46,230
així que bàsicament s'aferren a aquests 512 bytes fins que sapiguem exactament què fer amb ells.

508
00:42:46,230 --> 00:42:50,300
Llavors el que vull fer és que volem comprovar si ens hem topat amb un estel o no.

509
00:42:50,300 --> 00:42:57,960
Si ens hem topat amb un estel, si hem colpejat una de les seqüències d'arrencada,

510
00:42:57,960 --> 00:42:59,980
llavors sabem que hem assolit un nou arxiu JPEG.

511
00:42:59,980 --> 00:43:08,860
El que vostè voldrà fer és que anem a voler crear un nou arxiu en el nostre directori pset4

512
00:43:08,860 --> 00:43:14,480
per seguir fent aquest arxiu.

513
00:43:14,480 --> 00:43:18,220
Però també, si ja hem fet un JPEG abans,

514
00:43:18,220 --> 00:43:25,620
llavors volem acabar amb aquest arxiu i empènyer a la carpeta pset4,

515
00:43:25,620 --> 00:43:29,780
on tindrem aquest arxiu guardat perquè si no s'especifica que hem acabat aquest arxiu JPEG,

516
00:43:29,780 --> 00:43:37,290
a continuació, que bàsicament tindràs una quantitat indeterminada. Els arxius JPEG no tindrà fi.

517
00:43:37,290 --> 00:43:40,840
Així que volem assegurar-nos que quan estem llegint en un arxiu JPEG i escrit que,

518
00:43:40,840 --> 00:43:46,590
que es vol tancar específicament que, per obrir el següent.

519
00:43:46,590 --> 00:43:48,430
Haurem de desitgi comprovar diverses coses.

520
00:43:48,430 --> 00:43:52,880
Volem comprovar si estem en el començament d'una nova JPEG amb el nostre buffer

521
00:43:52,880 --> 00:43:56,780
i també si ja ha trobat un JPEG abans

522
00:43:56,780 --> 00:44:03,930
perquè això canviarà el seu procés lleugerament.

523
00:44:03,930 --> 00:44:07,880
Així que després de passar per tot el camí i li va colpejar el final de l'arxiu,

524
00:44:07,880 --> 00:44:11,570
llavors el que vostè voldrà fer és que vostè vol tancar tots els arxius que estiguin oberts.

525
00:44:11,570 --> 00:44:14,100
Això probablement serà l'últim arxiu JPEG que vostè té,

526
00:44:14,100 --> 00:44:18,930
així com l'arxiu de targetes que vostè ha estat tractant.

527
00:44:21,940 --> 00:44:28,670
>> L'últim obstacle que hem d'abordar és com fer un arxiu JPEG

528
00:44:28,670 --> 00:44:31,950
i com en realitat l'empeny a la carpeta.

529
00:44:33,650 --> 00:44:39,850
El conjunt de processadors requereix que cada JPEG que es troba estar en el següent format,

530
00:44:39,850 --> 00:44:43,990
on tens el nombre. jpg.

531
00:44:43,990 --> 00:44:50,750
El nombre, fins i tot si és 0, l'anomenem 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Cada vegada que hi hagi un fitxer JPEG al programa,

533
00:44:55,730 --> 00:44:58,040
vostè va a voler donar-li un nom en l'ordre en què es trobi.

534
00:44:58,040 --> 00:44:59,700
Què vol dir això?

535
00:44:59,700 --> 00:45:03,530
Hem de tipus de seguiment de quants hem trobat

536
00:45:03,530 --> 00:45:08,680
i el que el nombre de cada JPEG ha de ser.

537
00:45:08,680 --> 00:45:13,800
Aquí aprofitarem la funció sprintf.

538
00:45:13,800 --> 00:45:17,480
Igual que printf, que només tipus d'impressions en un valor fora de la terminal,

539
00:45:17,480 --> 00:45:23,910
sprintf imprimeix el fitxer a la carpeta de sortida.

540
00:45:23,910 --> 00:45:30,870
I així el que això faria si tingués sprintf, títol, i després la cadena allà,

541
00:45:30,870 --> 00:45:36,660
seria imprimir 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Suposant que he tancat els meus arxius correctament,

543
00:45:41,020 --> 00:45:47,210
que conté l'arxiu que havia estat escrivint.

544
00:45:47,210 --> 00:45:50,320
Però una cosa és que el codi que tinc aquí

545
00:45:50,320 --> 00:45:53,360
no acaba de satisfer el que el conjunt de processadors requereix.

546
00:45:53,360 --> 00:46:02,410
El conjunt de processadors requereix que el segon arxiu JPEG ha de ser nomenat 002 en comptes de 2.

547
00:46:02,410 --> 00:46:09,160
Així que quan s'imprimeixi el nom, llavors potser vostè pot ser que vulgueu modificar lleugerament el marcador de posició.

548
00:46:09,160 --> 00:46:18,140
>> Algú recorda com permetre espais addicionals quan escrivim alguna cosa?

549
00:46:18,140 --> 00:46:22,530
Si. >> [Estudiant] Es posa un 3 per cent entre el signe i el 2. >> Sí, perfecte.

550
00:46:22,530 --> 00:46:25,610
Vas a posar un 3 en aquest cas perquè volem que l'espai per a 3.

551
00:46:25,610 --> 00:46:32,590
3d% probablement li donaria 002.jpg lloc de 2.

552
00:46:32,590 --> 00:46:40,120
El primer argument en la funció sprintf és en realitat una matriu de caràcters,

553
00:46:40,120 --> 00:46:42,520
que prèviament sabia com cadenes.

554
00:46:42,520 --> 00:46:50,700
Aquells voluntat, una mica més com un dipòsit temporal, només emmagatzemar la cadena resultant.

555
00:46:50,700 --> 00:46:54,950
En realitat, no es tracta d'això, sinó que cal incloure.

556
00:46:54,950 --> 00:47:00,710
>> Sabent que cada nom de fitxer té el nombre, que ocupa tres personatges,

557
00:47:00,710 --> 00:47:06,770
i llavors. jpg, quant de temps ha de ser aquesta matriu?

558
00:47:09,070 --> 00:47:14,310
Llenci a les escombraries un nombre. Quants caràcters al títol, en el nom?

559
00:47:18,090 --> 00:47:26,320
Així que hi ha tres hashtags, període, jpg. >> [Estudiant] 7. >> 7. No del tot.

560
00:47:26,320 --> 00:47:32,000
Anem a voler 8 perquè volem permetre el terminador nul també.

561
00:47:45,340 --> 00:47:49,730
>> Finalment, només per allargar el procés que es farà per recuperar,

562
00:47:49,730 --> 00:47:55,420
vostè té alguna informació començament.

563
00:47:55,420 --> 00:48:02,460
Continuar fins a trobar l'inici d'un arxiu JPEG,

564
00:48:02,460 --> 00:48:07,900
i que pot ser o bé una de les dues seqüències de partida.

565
00:48:07,900 --> 00:48:12,510
Tu segueix llegint. Cada barra representa aquí 512 bytes.

566
00:48:12,510 --> 00:48:22,630
Vostè segueixi llegint, seguiu llegint fins que es troba amb una altra seqüència d'arrencada.

567
00:48:22,630 --> 00:48:29,790
Un cop aconseguit això, s'acaba l'actual JPEG - en aquest cas, és el vermell,

568
00:48:29,790 --> 00:48:31,030
per la qual cosa vol posar fi a això.

569
00:48:31,030 --> 00:48:35,540
Vols sprintf el nom d'aquesta carpeta en el seu pset4,

570
00:48:35,540 --> 00:48:41,580
llavors vostè vol obrir una nova JPEG i després seguir llegint

571
00:48:41,580 --> 00:48:46,370
fins que es troba amb el següent.

572
00:48:46,370 --> 00:48:49,040
Segueix llegint, segueix llegint,

573
00:48:49,040 --> 00:48:56,290
i, finalment, amb el temps, has d'arribar al final de l'arxiu,

574
00:48:56,290 --> 00:49:00,360
i pel que vostè vol tancar l'última JPEG que estaves treballant,

575
00:49:00,360 --> 00:49:08,380
sprintf que a la seva carpeta pset4, i després veure totes les fotos que has aconseguit.

576
00:49:08,380 --> 00:49:12,050
Aquestes fotos són en realitat imatges de CS50 personal,

577
00:49:12,050 --> 00:49:16,430
i aquí és on ve la part divertida bonificació del conjunt de processadors es presenta en

578
00:49:16,430 --> 00:49:26,310
és que estan competint en les seves seccions per trobar la TFS a les fotos

579
00:49:26,310 --> 00:49:34,610
i prendre fotos amb ells per provar que vostè ha fet el conjunt de processadors

580
00:49:34,610 --> 00:49:37,030
i perquè pugui veure que els membres del personal estan a les fotos.

581
00:49:37,030 --> 00:49:41,510
Així que pren imatges amb el personal. De vegades hauràs de perseguir.

582
00:49:41,510 --> 00:49:44,680
Probablement alguns d'ells tractarà de fugir de tu.

583
00:49:44,680 --> 00:49:47,320
Es pren fotos amb ells.

584
00:49:47,320 --> 00:49:51,190
Això està en curs. No és exigible quan el conjunt de processadors cal.

585
00:49:51,190 --> 00:49:53,340
El termini es donaran a conèixer en l'especificació.

586
00:49:53,340 --> 00:49:58,060
Llavors, amb la seva secció, el que porta a la majoria de la secció fotos

587
00:49:58,060 --> 00:50:04,430
amb els membres de la majoria del personal es portaran un premi bastant impressionant.

588
00:50:04,430 --> 00:50:08,890
Això és una mena d'incentiu per obtenir el seu pset4 acabi com més aviat millor

589
00:50:08,890 --> 00:50:10,820
perquè llavors vostè pot anar per feina

590
00:50:10,820 --> 00:50:14,570
la caça de tots els diferents membres del personal CS50.

591
00:50:14,570 --> 00:50:17,500
Això no és obligatòria, però, així una vegada que les fotos,

592
00:50:17,500 --> 00:50:20,310
llavors ja ha acabat amb pset4.

593
00:50:20,310 --> 00:50:23,970
>> I he acabat amb Tutorial 4, així que gràcies a tots per venir.

594
00:50:23,970 --> 00:50:29,330
Bona sort amb Forense. [Aplaudiment]

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