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

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

3
00:00:05,000 --> 00:00:07,340
[Questo è CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
Bene. Ciao a tutti, e benvenuti a Walkthrough 4.

5
00:00:11,670 --> 00:00:14,270
>> Oggi la nostra pset è Forensics.

6
00:00:14,270 --> 00:00:18,080
Forensics è un pset davvero divertente che coinvolge fare con file bitmap

7
00:00:18,080 --> 00:00:21,550
per scoprire chi ha commesso un reato.

8
00:00:21,550 --> 00:00:24,200
Poi andremo a ridimensionare alcuni file bitmap,

9
00:00:24,200 --> 00:00:27,780
allora stiamo anche andando a che fare con una parte davvero divertente chiamato Recover,

10
00:00:27,780 --> 00:00:31,160
in cui stiamo praticamente consegnato una scheda di memoria

11
00:00:31,160 --> 00:00:34,350
in cui qualcuno ha accidentalmente cancellato tutti i loro file,

12
00:00:34,350 --> 00:00:38,860
e abbiamo chiesto di recuperare i file.

13
00:00:38,860 --> 00:00:42,910
>> Ma prima, prima di entrare in pset, ho davvero voglia di congratularmi con tutti.

14
00:00:42,910 --> 00:00:45,230
Siamo circa a metà di questo corso.

15
00:00:45,230 --> 00:00:50,070
Quiz 0 è dietro di noi, e siamo a pset4, quindi in sostanza, siamo a metà strada.

16
00:00:50,070 --> 00:00:55,490
Abbiamo percorso una lunga strada, se si guarda indietro alle vostre pset, pset0 e pset1,

17
00:00:55,490 --> 00:00:57,300
quindi congratularmi con te su questo,

18
00:00:57,300 --> 00:01:00,760
e stiamo per entrare in alcune cose davvero divertenti.

19
00:01:00,760 --> 00:01:07,070
>> Così la nostra cassetta degli attrezzi per questo pset, ancora una volta, invece di eseguire sudo yum-y update,

20
00:01:07,070 --> 00:01:13,890
siamo in grado di eseguire solo update50 se siete alla versione 17.3 e superiore dell'apparecchio.

21
00:01:13,890 --> 00:01:17,380
Quindi, essere sicuri di eseguire update50 - è molto più facile, alcuni caratteri meno -

22
00:01:17,380 --> 00:01:20,640
per assicurarsi che siete al l'ultima versione dell'apparecchio.

23
00:01:20,640 --> 00:01:25,410
Soprattutto è importante update50 quando iniziare ad usare CS50 Check.

24
00:01:25,410 --> 00:01:28,700
Quindi assicuratevi che l'hai fatto.

25
00:01:28,700 --> 00:01:30,760
>> Per tutte le sezioni di questo pset,

26
00:01:30,760 --> 00:01:34,350
stiamo andando a che fare con file di input e output, file I / O.

27
00:01:34,350 --> 00:01:38,140
Stiamo per andare in un sacco di programmi che si occupano di array

28
00:01:38,140 --> 00:01:40,350
puntano ai file e cose del genere,

29
00:01:40,350 --> 00:01:43,050
quindi vogliamo fare in modo che siamo molto familiare e confortevole

30
00:01:43,050 --> 00:01:47,990
che fare con il modo di input e output in file.

31
00:01:47,990 --> 00:01:52,080
>> Nel codice di distribuzione per questo pset è un file chiamato impossibile fare,

32
00:01:52,080 --> 00:01:55,280
ed è quello che stiamo andando a trovare sta per essere veramente utile per noi

33
00:01:55,280 --> 00:02:00,340
perché stiamo andando a finire copiando il file di impossibile fare

34
00:02:00,340 --> 00:02:05,350
e semplicemente modificando leggermente per poter raggiungere i primi due parti del problema proposto.

35
00:02:05,350 --> 00:02:09,030
>> E così poi come ho detto prima, abbiamo a che fare con le immagini bitmap, nonché JPEG.

36
00:02:09,030 --> 00:02:13,170
Quindi, in realtà la comprensione della struttura di come questi file sono organizzati,

37
00:02:13,170 --> 00:02:16,170
come si può davvero tradurre il 0 e 1 in strutture

38
00:02:16,170 --> 00:02:19,040
e le cose che si possono realmente capire e interpretare e modificare,

39
00:02:19,040 --> 00:02:21,000
che sarà molto importante,

40
00:02:21,000 --> 00:02:25,970
in modo da andare in JPEG e file bitmap e comprendere la struttura di quelli.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, come al solito, inizia con una sezione di domande.

42
00:02:30,780 --> 00:02:36,600
Chi si occuperà di file di I / O e farti abituato a questo.

43
00:02:36,600 --> 00:02:42,520
Poi parte 1 è Whodunit, in cui si è dato un file bitmap

44
00:02:42,520 --> 00:02:45,630
che sembra un po 'come puntini rossi in tutto.

45
00:02:45,630 --> 00:02:52,180
E poi in fondo quello che stiamo andando a fare è prendere questo file e solo modificarlo un po '

46
00:02:52,180 --> 00:02:54,010
in una versione che possiamo leggere.

47
00:02:54,010 --> 00:02:56,000
In sostanza, una volta finito, avremo lo stesso file,

48
00:02:56,000 --> 00:03:02,630
tranne saremo in grado di vedere il messaggio nascosto nascosto da tutti quei puntini rossi.

49
00:03:02,630 --> 00:03:07,310
Poi Resize è un programma che, dato un file

50
00:03:07,310 --> 00:03:11,490
e poi dato il nome del file che emette e poi dato un numero come pure,

51
00:03:11,490 --> 00:03:16,850
effettivamente ridimensionare che bitmap da tale valore intero.

52
00:03:16,850 --> 00:03:19,240
Poi, infine, abbiamo la pset Recover.

53
00:03:19,240 --> 00:03:24,160
Ci viene data una scheda di memoria e quindi sono tenuti a recuperare tutte le foto

54
00:03:24,160 --> 00:03:25,920
che sono stati accidentalmente cancellati,

55
00:03:25,920 --> 00:03:31,420
ma, come vedremo, imparino, non effettivamente eliminati e rimosso dal file;

56
00:03:31,420 --> 00:03:38,470
abbiamo perso solo tipo di dove si trovavano nel file, ma abbiamo intenzione di recuperare tale.

57
00:03:38,470 --> 00:03:44,950
>> Grande. Quindi, andando nel file di I / O in particolare, si tratta di tutta una serie di funzioni che verranno utilizzati.

58
00:03:44,950 --> 00:03:49,840
Hai già visto un po 'le basi di fopen, fread, fwrite, e

59
00:03:49,840 --> 00:03:54,350
ma abbiamo intenzione di approfondire un po 'di file di I / O, quali funzioni fputc,

60
00:03:54,350 --> 00:03:56,930
in cui è sufficiente scrivere un carattere alla volta,

61
00:03:56,930 --> 00:04:02,000
a fseek, dove tipo di spostare l'indicatore di posizione del file in avanti e indietro,

62
00:04:02,000 --> 00:04:05,770
e poi alcuni altri. Ma andiamo in quello un po 'più tardi nel corso della pset.

63
00:04:08,050 --> 00:04:13,100
>> Quindi, prima, giusto per entrare in file di I / O prima di andare in pset,

64
00:04:13,100 --> 00:04:19,860
per aprire un file, per esempio, quello che dovete fare è in realtà impostare un puntatore al file.

65
00:04:19,860 --> 00:04:22,710
Così abbiamo un puntatore FILE *.

66
00:04:22,710 --> 00:04:27,140
In questo caso, sto definendolo un puntatore perché sarà la mia infile.

67
00:04:27,140 --> 00:04:33,340
E così ho intenzione di utilizzare la funzione fopen e quindi il nome del file

68
00:04:33,340 --> 00:04:36,360
e poi il modo in cui ho intenzione di avere a che fare con il file.

69
00:04:36,360 --> 00:04:42,080
Quindi c'è "r", in questo caso per la lettura, "w" per la scrittura, e quindi "a" per aggiungere.

70
00:04:42,080 --> 00:04:44,270
Per esempio, quando hai a che fare con un infile

71
00:04:44,270 --> 00:04:47,310
e tutto quello che voglio fare è leggere i bit e byte memorizzati,

72
00:04:47,310 --> 00:04:50,420
allora probabilmente stai andando a voler usare "r" come modalità.

73
00:04:50,420 --> 00:04:54,520
Quando si desidera scrivere in realtà, una sorta di creare un nuovo file,

74
00:04:54,520 --> 00:04:57,220
allora quello che andremo a fare è che andremo ad aprire il nuovo file

75
00:04:57,220 --> 00:05:02,410
e utilizzare la modalità "w" per la scrittura.

76
00:05:02,410 --> 00:05:07,540
>> Allora quando si è in realtà la lettura nei file, la struttura è la seguente.

77
00:05:07,540 --> 00:05:14,930
Prima di includere il puntatore alla struttura che conterrà i byte che si sta leggendo.

78
00:05:14,930 --> 00:05:19,830
In modo che sarà la posizione finale dei byte che si sta leggendo.

79
00:05:19,830 --> 00:05:23,360
Stai andando poi per indicare la dimensione, come in pratica il numero di byte

80
00:05:23,360 --> 00:05:30,100
il vostro programma deve leggere il file, il formato in genere da un elemento,

81
00:05:30,100 --> 00:05:32,620
e poi si sta andando a specificare il numero di elementi che si desidera leggere.

82
00:05:32,620 --> 00:05:34,980
E poi, infine, è necessario sapere dove stai leggendo,

83
00:05:34,980 --> 00:05:37,580
in modo che sarà il puntatore in.

84
00:05:37,580 --> 00:05:41,780
I colori diversi, perché questi fread è anche molto simile a fwrite,

85
00:05:41,780 --> 00:05:47,050
se non si vuole fare in modo di utilizzare il giusto ordine,

86
00:05:47,050 --> 00:05:51,960
fare in modo che si sta effettivamente scrittura o la lettura dal file di destra.

87
00:05:54,910 --> 00:05:58,610
>> Quindi come prima, se abbiamo la dimensione dell'elemento e il numero di elementi,

88
00:05:58,610 --> 00:06:00,600
allora possiamo giocare qui un po '.

89
00:06:00,600 --> 00:06:06,810
Dire che ho una struttura DOG e così poi voglio leggere due cani alla volta.

90
00:06:06,810 --> 00:06:12,450
Quello che ho potuto fare è dire le dimensioni di un elemento sarà la dimensione di un cane

91
00:06:12,450 --> 00:06:14,770
e ho intenzione di leggere in realtà due di loro.

92
00:06:14,770 --> 00:06:18,290
In alternativa, quello che ho potuto fare è dire che sto solo andando a leggere un elemento

93
00:06:18,290 --> 00:06:21,340
e che un elemento sta per essere la dimensione di due cani.

94
00:06:21,340 --> 00:06:24,320
Ecco, questo è analogo come è possibile tipo di gioco in giro con dimensioni e numero

95
00:06:24,320 --> 00:06:28,250
a seconda di cosa è più intuitivo per voi.

96
00:06:28,250 --> 00:06:30,810
>> Bene. Così ora si arriva a file di scrittura.

97
00:06:30,810 --> 00:06:36,880
Quando si desidera scrivere un file, il primo argomento è in realtà dove si sta leggendo da.

98
00:06:36,880 --> 00:06:42,050
Ecco, questo è fondamentalmente i dati che si sta per scrivere nel file,

99
00:06:42,050 --> 00:06:44,490
che è il puntatore alla fine.

100
00:06:44,490 --> 00:06:47,670
Così, quando hai a che fare con il pset, fare attenzione a non confondersi.

101
00:06:47,670 --> 00:06:50,480
Forse avere il lato definizioni a fianco.

102
00:06:50,480 --> 00:06:58,090
È possibile tirare le definizioni nel manuale digitando man e poi fwrite, per esempio,

103
00:06:58,090 --> 00:06:59,950
nel terminale, oppure è possibile fare riferimento a questa diapositiva

104
00:06:59,950 --> 00:07:03,570
e assicurarsi che si sta utilizzando quella giusta.

105
00:07:03,570 --> 00:07:08,700
Quindi, di nuovo, per la fwrite, quando si dispone di un file che si desidera scrivere in,

106
00:07:08,700 --> 00:07:14,290
che sta per essere l'ultimo argomento e che sta per essere un puntatore a tale file.

107
00:07:14,290 --> 00:07:18,670
Allora è così che abbiamo a che fare con la scrittura, forse diversi byte alla volta,

108
00:07:18,670 --> 00:07:21,820
ma che tu voglia scrivere solo in un singolo carattere.

109
00:07:21,820 --> 00:07:25,940
Come vedremo più avanti in questo esempio, nelle bitmap dovremo usare quello.

110
00:07:25,940 --> 00:07:32,180
In quel momento possiamo usare fputc, essenzialmente solo mettendo un carattere alla volta, chr,

111
00:07:32,180 --> 00:07:37,050
nel puntatore a file, e questo è il nostro puntatore fuori.

112
00:07:38,700 --> 00:07:41,560
Allora ogni volta che cerchiamo o scrivere in un file,

113
00:07:41,560 --> 00:07:44,690
il file è tenere traccia di dove ci troviamo.

114
00:07:44,690 --> 00:07:47,810
Quindi è una sorta di cursore, l'indicatore di posizione del file.

115
00:07:47,810 --> 00:07:54,330
E così ogni volta che scrivere o leggere di nuovo in un file,

116
00:07:54,330 --> 00:07:56,760
il file in realtà si ricorda dove si trova,

117
00:07:56,760 --> 00:07:59,270
e così continua da dove si trova il cursore.

118
00:07:59,270 --> 00:08:03,970
Questo può essere utile quando si desidera, ad esempio, letto in una certa quantità di fare qualcosa

119
00:08:03,970 --> 00:08:06,160
e quindi leggere nelle seguenti quantità,

120
00:08:06,160 --> 00:08:10,700
ma a volte si potrebbe desiderare di tornare indietro o di fatto, a partire da un valore di riferimento certo.

121
00:08:10,700 --> 00:08:16,870
Allora la funzione fseek, ciò che fa è permette di spostare il cursore in un determinato file

122
00:08:16,870 --> 00:08:19,680
un certo numero di byte.

123
00:08:19,680 --> 00:08:24,260
E poi quello che dobbiamo fare è specificare dove il valore di riferimento è.

124
00:08:24,260 --> 00:08:31,520
Quindi, o si muove in avanti o indietro da dove si trova il cursore al momento,

125
00:08:31,520 --> 00:08:35,750
oppure si può specificare che deve solo muovere in dall'inizio del file

126
00:08:35,750 --> 00:08:37,090
o dalla fine del file.

127
00:08:37,090 --> 00:08:41,230
E così è possibile passare a valori negativi o positivi alla quantità,

128
00:08:41,230 --> 00:08:44,960
e che tipo di spostare il cursore in avanti o indietro.

129
00:08:46,170 --> 00:08:51,920
>> Prima di entrare nei pset altri, tutte le questioni sui file I / O?

130
00:08:53,860 --> 00:08:59,990
Va bene. Man mano che in altri esempi, non esitate a fermarmi per le domande.

131
00:08:59,990 --> 00:09:06,930
>> Quindi, in Whodunit, si sta consegnato un file bitmap simile a questo rosso sulla diapositiva,

132
00:09:06,930 --> 00:09:14,510
e sembra che questo - un mucchio di punti rossi - e non so davvero cosa c'è scritto.

133
00:09:14,510 --> 00:09:23,310
Se si strabismo, si può essere in grado di vedere una leggera colorazione bluastra all'interno del mezzo.

134
00:09:23,310 --> 00:09:26,270
In sostanza, è lì che il testo è memorizzato.

135
00:09:26,270 --> 00:09:30,270
C'è stato un omicidio che è successo, e abbiamo bisogno di scoprire chi lo ha fatto.

136
00:09:30,270 --> 00:09:36,760
Per fare questo, abbiamo bisogno di convertire questo tipo di immagine in un formato leggibile.

137
00:09:36,760 --> 00:09:42,740
Se voi ragazzi mai incontrato questo, a volte non ci sarebbe kit piccoli

138
00:09:42,740 --> 00:09:48,510
dove si avrebbe una lente di ingrandimento con una pellicola rosso. Nessuno? Gia '.

139
00:09:48,510 --> 00:09:52,770
Così si sarebbe qualcosa di mano in questo modo, si avrebbe una lente d'ingrandimento

140
00:09:52,770 --> 00:09:58,130
con la pellicola rossa su di esso, si sarebbe messo sopra l'immagine,

141
00:09:58,130 --> 00:10:03,410
e si sarebbe in grado di vedere il messaggio nascosto in essa.

142
00:10:03,410 --> 00:10:07,080
Noi non abbiamo una lente di ingrandimento con la pellicola rossa, così invece che andremo a creare il nostro tipo di propria

143
00:10:07,080 --> 00:10:09,060
in questo pset.

144
00:10:09,060 --> 00:10:15,760
E così che l'utente sta per giallo, allora l'indizio,. Bmp,

145
00:10:15,760 --> 00:10:18,800
quindi questo è il infile, questo è il messaggio di punto rosso,

146
00:10:18,800 --> 00:10:23,550
e poi dicono verdict.bmp sarà il nostro file di emissione.

147
00:10:23,550 --> 00:10:27,900
Così sta andando a creare una nuova immagine bitmap simile a uno indizio

148
00:10:27,900 --> 00:10:32,600
se non in un formato leggibile in cui possiamo vedere il messaggio nascosto.

149
00:10:32,600 --> 00:10:37,550
>> Dal momento che stiamo andando a che fare con la modifica e la manipolazione di immagini bitmap di qualche tipo,

150
00:10:37,550 --> 00:10:42,400
stiamo andando a tipo di immersione in nella struttura di questi file bitmap.

151
00:10:42,400 --> 00:10:48,130
Siamo andati oltre questi un po 'in conferenza, ma guardiamo in loro un po' di più.

152
00:10:48,130 --> 00:10:51,740
Bitmap sono essenzialmente solo un accordo di byte

153
00:10:51,740 --> 00:10:55,790
dove abbiamo specificato che byte dire quello.

154
00:10:55,790 --> 00:11:00,540
Così qui è un po 'come una mappa dell'immagine bitmap

155
00:11:00,540 --> 00:11:08,550
dicendo che inizia con alcuni file di intestazione, inizia con alcune informazioni in là.

156
00:11:08,550 --> 00:11:16,540
Si vede che a circa 14 il numero di byte di dimensione è indicata l'immagine bitmap,

157
00:11:16,540 --> 00:11:18,520
e continua su.

158
00:11:18,520 --> 00:11:23,810
Ma allora che cosa stiamo realmente interessa qui sta iniziando intorno numero di byte 54.

159
00:11:23,810 --> 00:11:26,060
Abbiamo questi triple RGB.

160
00:11:26,060 --> 00:11:30,760
Cosa che sta per fare è contenere i pixel effettivi, i valori di colore.

161
00:11:30,760 --> 00:11:35,950
Tutto ciò al di sopra che nell'intestazione sono alcune informazioni

162
00:11:35,950 --> 00:11:41,240
corrispondente alla dimensione dell'immagine, la larghezza dell'immagine, e l'altezza.

163
00:11:41,240 --> 00:11:44,930
Quando andiamo in imbottitura in seguito, vedremo perché la dimensione dell'immagine

164
00:11:44,930 --> 00:11:48,670
potrebbero essere diverse o della larghezza.

165
00:11:48,670 --> 00:11:54,240
Allora per rappresentare questi - queste immagini bitmap sono sequenze di byte -

166
00:11:54,240 --> 00:11:59,370
quello che abbiamo potuto fare è dire che va bene, ho intenzione di ricordare che al punto 14,

167
00:11:59,370 --> 00:12:03,380
è lì che la dimensione è, per esempio, ma invece quello che andremo a fare per rendere questo più facile

168
00:12:03,380 --> 00:12:06,020
sta incapsulare in una struttura.

169
00:12:06,020 --> 00:12:08,880
E così abbiamo due strutture fatte per noi, un BITMAPFILEHEADER

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

171
00:12:10,440 --> 00:12:14,840
e così ogni volta che si legge per quel file, per impostazione predefinita, sta per andare in ordine,

172
00:12:14,840 --> 00:12:22,360
e così in ordine è anche andando a riempire in variabili quali biWidth e biSize.

173
00:12:25,270 --> 00:12:31,230
E infine, ogni pixel è rappresentato da tre byte.

174
00:12:31,230 --> 00:12:35,500
La prima è la quantità di blu nel pixel, il secondo è la quantità di verde,

175
00:12:35,500 --> 00:12:41,120
e, infine, la quantità di rosso, dove 0 è essenzialmente blu o verde o non è rosso

176
00:12:41,120 --> 00:12:43,720
e poi ff è il valore massimo.

177
00:12:43,720 --> 00:12:46,800
Si tratta di valori esadecimali.

178
00:12:46,800 --> 00:12:53,870
Allora se abbiamo ff0000, poi che corrisponde all'importo massimo di blu

179
00:12:53,870 --> 00:12:58,890
e poi non verde e non rosso, e allora che ci avrebbe dato un pixel blu.

180
00:12:58,890 --> 00:13:04,190
Poi se abbiamo FF tutto su tutta la linea, allora ciò significa che abbiamo un pixel bianco.

181
00:13:04,190 --> 00:13:11,370
Questa è una specie di fronte al solito quando si dice RGB. In realtà andando BGR.

182
00:13:12,750 --> 00:13:18,990
>> Quindi, se abbiamo effettivamente guardare in un esempio di un'immagine bitmap - fammi un tiro qui.

183
00:13:31,560 --> 00:13:33,830
E 'un po' piccola.

184
00:13:39,890 --> 00:13:47,840
Sono lo zoom, e possiamo vedere che è sgranata. Sembra blocchi di colore.

185
00:13:47,840 --> 00:13:50,110
Non ci sono blocchi bianchi e poi blocchi rossi.

186
00:13:50,110 --> 00:13:53,700
Se si gioca in Microsoft Paint, per esempio, si potrebbe fare una cosa del genere

187
00:13:53,700 --> 00:13:58,960
fondamentalmente solo da dipingere alcuni quadratini in un ordine specifico.

188
00:13:58,960 --> 00:14:08,060
E allora che cosa questo si traduce nella bitmap è la seguente.

189
00:14:08,060 --> 00:14:15,710
Qui abbiamo prima pixel bianchi, che tutti e 6 sono f, e poi abbiamo pixel rossi,

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

191
00:14:19,910 --> 00:14:27,940
E così la sequenza di byte che abbiamo indica come l'immagine bitmap è andare a guardare.

192
00:14:27,940 --> 00:14:32,230
Quindi quello che ho fatto qui è solo scritto tutti quei byte e poi colorate in rosso

193
00:14:32,230 --> 00:14:37,550
modo che sia possibile tipo di vedere, se si strabismo un po ', come questo tipo di indica una faccina sorridente.

194
00:14:40,180 --> 00:14:46,390
>> Il modo in cui le immagini bitmap lavoro io lo immagino in pratica come una griglia.

195
00:14:46,390 --> 00:14:54,940
E così di default, ogni riga della griglia deve essere un multiplo di 4 byte.

196
00:15:00,520 --> 00:15:07,060
Se guardiamo un'immagine bitmap, si sta riempiendo in ogni valore.

197
00:15:07,060 --> 00:15:17,370
Per esempio, si potrebbe avere un rosso qui, un verde qui, un blu qui,

198
00:15:17,370 --> 00:15:24,950
ma bisogna fare in modo che l'immagine viene riempita con un multiplo di quattro byte.

199
00:15:24,950 --> 00:15:32,200
Quindi, se voglio che la mia immagine da tre blocchi di larghezza, quindi vorrei mettere un valore vuoto

200
00:15:32,200 --> 00:15:35,640
in ultimo a un multiplo di quattro.

201
00:15:35,640 --> 00:15:39,530
Allora vorrei aggiungere in qualcosa che stiamo chiamando imbottitura.

202
00:15:39,530 --> 00:15:43,750
Sto solo andando a indicare che lì con una x.

203
00:15:44,920 --> 00:15:54,160
Ora, dire che vogliamo un'immagine che è lunga 7 pixel, per esempio.

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

205
00:16:04,750 --> 00:16:07,000
e tutto questo è riempita di colore.

206
00:16:07,000 --> 00:16:10,620
Il modo in cui le immagini bitmap lavoro è che abbiamo bisogno di un 8.

207
00:16:10,620 --> 00:16:12,460
In questo momento ci sono 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
Abbiamo bisogno di 8 spazi per l'immagine bitmap di leggere correttamente.

209
00:16:19,360 --> 00:16:25,600
Quindi quello che dobbiamo fare è aggiungere in un po 'di imbottitura

210
00:16:25,600 --> 00:16:29,430
fare in modo che tutte le larghezze sono uniformi

211
00:16:29,430 --> 00:16:34,260
e che tutte le larghezze sono un multiplo di 4.

212
00:16:42,110 --> 00:16:47,310
E così ho indicato in precedenza, imbottitura come x o una linea ondulata,

213
00:16:47,310 --> 00:16:53,880
ma nelle immagini reali bitmap l'imbottitura è indicata da uno 0 esadecimale.

214
00:16:53,880 --> 00:16:57,340
In modo che sarebbe un singolo carattere, 0.

215
00:16:58,980 --> 00:17:06,329
Ciò che potrebbe tornare utile è il comando xxd.

216
00:17:06,329 --> 00:17:11,220
Ciò che fa è in realtà mostra, come simile a quello che ho fatto prima con lo smiley

217
00:17:11,220 --> 00:17:15,630
quando ho stampato quello che ogni colore sarebbe per il pixel

218
00:17:15,630 --> 00:17:21,800
e poi colori diversi, quando si esegue xxd con i seguenti comandi,

219
00:17:21,800 --> 00:17:28,670
allora verrà la stampa cosa i colori sono per quei pixel.

220
00:17:28,670 --> 00:17:33,810
Quello che devi fare è qui indico, come il-s 54

221
00:17:33,810 --> 00:17:36,530
dice che ho intenzione di iniziare al byte 54

222
00:17:36,530 --> 00:17:40,820
perché prima che, ricordo se torniamo ad osservare la mappa delle bitmap,

223
00:17:40,820 --> 00:17:42,690
è tutto quello che le informazioni di intestazione e cose del genere.

224
00:17:42,690 --> 00:17:46,280
Ma quello che ci interessa davvero è il pixel effettivi che indicano il colore.

225
00:17:46,280 --> 00:17:52,700
Quindi, con l'aggiunta di quella bandiera,-s 54, quindi siamo in grado di vedere i valori di colore.

226
00:17:52,700 --> 00:17:56,020
E non preoccuparti per le bandiere complicate e cose del genere.

227
00:17:56,020 --> 00:18:05,020
Nel set di specifiche problema, avrete indicazioni su come utilizzare xxd per visualizzare i pixel.

228
00:18:07,070 --> 00:18:15,590
Quindi, se vedete qui, che tipo di aspetto di una scatola verde, questa piccola cosa.

229
00:18:15,590 --> 00:18:23,610
Ho un codice colore la 00FF00 fondamentalmente come dire di no blu, un sacco di verde e non rosso.

230
00:18:23,610 --> 00:18:26,370
In modo che corrisponda a verde.

231
00:18:26,370 --> 00:18:31,920
Come potete vedere qui, si vede un rettangolo verde.

232
00:18:31,920 --> 00:18:36,660
Questo rettangolo verde è a soli 3 pixel di larghezza, e allora che cosa dobbiamo fare

233
00:18:36,660 --> 00:18:44,350
fare in modo che l'immagine sia un multiplo di 4 larga è aggiungere nella imbottitura extra.

234
00:18:44,350 --> 00:18:49,460
E così allora è così che si vede 0s questi qui.

235
00:18:49,460 --> 00:18:54,510
Questo sarà effettivamente il risultato del tuo pset Ridimensiona,

236
00:18:54,510 --> 00:19:01,350
essenzialmente prendendo la piccola bitmap e poi ingrandendola per 4.

237
00:19:01,350 --> 00:19:09,380
E così ciò che vediamo è che in realtà questa immagine è di 12 pixel di larghezza, ma 12 è un multiplo di 4,

238
00:19:09,380 --> 00:19:12,940
e quindi in realtà non si vede alcun 0s alla fine perché non abbiamo bisogno di aggiungere qualsiasi

239
00:19:12,940 --> 00:19:19,070
perché è completamente imbottito. Essa non ha spazio più.

240
00:19:20,720 --> 00:19:23,470
>> Va bene. Avete domande su imbottitura?

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

242
00:19:27,460 --> 00:19:32,520
>> Come ho detto prima, le bitmap sono solo una sequenza di byte.

243
00:19:32,520 --> 00:19:39,170
E così ciò che abbiamo è invece di aver bisogno di tenere traccia di esattamente quale numero di byte

244
00:19:39,170 --> 00:19:47,050
corrisponde ad un elemento specifico, in realtà abbiamo creato una struttura per rappresentare questo.

245
00:19:47,050 --> 00:19:50,930
Quindi ciò che abbiamo è una struct RGBTRIPLE.

246
00:19:50,930 --> 00:19:54,590
Ogni volta che si dispone di un'istanza di una tripla RGB,

247
00:19:54,590 --> 00:20:00,970
perché questo è un tipo di definire struct, allora si può accedere alla variabile rgbtBlue,

248
00:20:00,970 --> 00:20:09,520
allo stesso modo le variabili di verde e rosso, che indicano la quantità di blu,, verde e rosso

249
00:20:09,520 --> 00:20:11,580
rispettivamente, si ha.

250
00:20:11,580 --> 00:20:16,800
>> Quindi, se abbiamo il set blu variabile a 0, la serie verde per ff,

251
00:20:16,800 --> 00:20:22,060
che è il valore massimo che si può avere, e quindi la variabile rosso impostato su 0,

252
00:20:22,060 --> 00:20:27,870
allora di che colore sarebbe questo particolare RGB triplice rappresenta? >> [Studente] Verde.

253
00:20:27,870 --> 00:20:29,150
Verde. Esattamente.

254
00:20:29,150 --> 00:20:34,480
E 'intenzione di essere utile sapere che ogni volta che si dispone di un'istanza di una tripla RGB,

255
00:20:34,480 --> 00:20:41,340
si può effettivamente accedere alla quantità di colore - blu, verde e rosso - separatamente.

256
00:20:43,350 --> 00:20:54,900
>> Ora che abbiamo parlato della struttura di questo, diamo uno sguardo al file BMP.

257
00:20:54,900 --> 00:20:57,870
Si tratta di strutture realizzate per voi.

258
00:20:57,870 --> 00:21:01,820
Qui abbiamo una struttura BITMAPFILEHEADER.

259
00:21:01,820 --> 00:21:07,610
Di notevole interesse è la dimensione.

260
00:21:07,610 --> 00:21:12,660
In seguito, abbiamo le informazioni nell'intestazione, che ha ancora alcune cose che sono interessanti per noi,

261
00:21:12,660 --> 00:21:15,480
cioè la dimensione, la larghezza e l'altezza.

262
00:21:15,480 --> 00:21:19,170
Come ci occuperemo in seguito, quando si legge nel file di,

263
00:21:19,170 --> 00:21:25,500
si legge automaticamente, perché abbiamo impostato l'ordine di essere la stessa.

264
00:21:25,500 --> 00:21:31,990
Così il biSize conterrà i byte giusti che corrispondono alla dimensione effettiva dell'immagine.

265
00:21:34,700 --> 00:21:40,500
E poi qui, infine, come abbiamo parlato, abbiamo la struttura RGBTRIPLE typedef.

266
00:21:40,500 --> 00:21:46,840
Abbiamo un rgbtBlue, verde e rosso ad esso associati.

267
00:21:48,210 --> 00:21:49,340
>> Grande. Va bene.

268
00:21:49,340 --> 00:21:56,360
Ora che abbiamo capito bitmap un po ', capire che abbiamo un file di intestazione

269
00:21:56,360 --> 00:22:00,790
e un'intestazione informazioni ad esso associato e poi, dopo che, abbiamo la roba interessante

270
00:22:00,790 --> 00:22:05,110
dei colori, ed i colori sono rappresentati da strutture RGBTRIPLE,

271
00:22:05,110 --> 00:22:12,710
e quelli, a loro volta, hanno tre valori associati al blu, al verde e al rosso.

272
00:22:12,710 --> 00:22:17,270
>> Così ora, possiamo tipo di pensare di recuperare un po '.

273
00:22:17,270 --> 00:22:20,130
Scusi. Pensate Whodunit.

274
00:22:20,130 --> 00:22:25,750
Quando abbiamo il nostro file indizio, allora quello che vogliamo fare è leggere ad esso pixel per pixel

275
00:22:25,750 --> 00:22:33,860
e quindi in qualche modo cambiare i pixel in modo che siamo in grado di produrre in un formato leggibile.

276
00:22:33,860 --> 00:22:41,020
E così per l'output, abbiamo intenzione di scrivere pixel per pixel nel file verdict.bmp.

277
00:22:41,020 --> 00:22:45,120
Questo è il tipo di un sacco da fare. Ci rendiamo conto che.

278
00:22:45,120 --> 00:22:49,860
Quindi quello che abbiamo fatto è che abbiamo in realtà è dotato di copy.c.

279
00:22:49,860 --> 00:22:57,610
Che cosa fa è impossibile fare fa solo una copia esatta di un file bitmap dato e poi lo trasmette.

280
00:22:57,610 --> 00:23:01,900
Così si apre già il file per te, legge in pixel per pixel,

281
00:23:01,900 --> 00:23:04,510
e poi scrive in in un file di output.

282
00:23:04,510 --> 00:23:07,080
>> Diamo uno sguardo a questo.

283
00:23:13,390 --> 00:23:18,290
Questo è garantire un uso corretto,

284
00:23:18,290 --> 00:23:22,640
ottenere i nomi dei file qui.

285
00:23:22,640 --> 00:23:29,940
Quello che fa è che imposta il file di input di essere quello che abbiamo passato in infile qui,

286
00:23:29,940 --> 00:23:34,750
che è il nostro secondo argomento della riga di comando.

287
00:23:34,750 --> 00:23:37,640
Controlli per fare in modo che siamo in grado di aprire il file.

288
00:23:38,960 --> 00:23:44,860
Verifica che si può fare un nuovo file di output qui.

289
00:23:45,630 --> 00:23:53,270
Allora cosa fa qui, solo che inizia soprattutto la lettura per il file bitmap dall'inizio.

290
00:23:53,270 --> 00:23:56,700
L'inizio, come si sa, contiene il BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
e così quelle sequenze di bit sarà direttamente compilare il BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Quindi ciò che abbiamo qui sta dicendo che bf BITMAPFILEHEADER -

293
00:24:07,940 --> 00:24:13,150
questa è la nostra nuova variabile di tipo BITMAPFILEHEADER -

294
00:24:13,150 --> 00:24:22,560
stiamo andando a mettere dentro bf quanto si legge da in puntatore, che è la nostra infile.

295
00:24:22,560 --> 00:24:23,970
Quanto leggiamo?

296
00:24:23,970 --> 00:24:32,160
Leggiamo in quanti byte abbiamo bisogno di contenere l'intera BITMAPFILEHEADER.

297
00:24:32,160 --> 00:24:34,660
Allo stesso modo, questo è quello che facciamo per le informazioni nell'intestazione.

298
00:24:34,660 --> 00:24:39,010
Quindi stiamo proseguendo il nostro file in infile,

299
00:24:39,010 --> 00:24:44,360
e stiamo leggendo quei bit e byte, e li stiamo collegando direttamente in

300
00:24:44,360 --> 00:24:47,880
in questi casi, le variabili che stiamo facendo.

301
00:24:49,370 --> 00:24:53,800
Qui stiamo solo facendo in modo che l'immagine bitmap è una bitmap.

302
00:24:57,670 --> 00:25:01,030
>> Ora abbiamo un file di output, giusto?

303
00:25:01,030 --> 00:25:04,420
Quindi, così com'è quando si crea, è essenzialmente vuota.

304
00:25:04,420 --> 00:25:07,710
Quindi dobbiamo creare fondamentalmente una nuova bitmap da zero.

305
00:25:07,710 --> 00:25:12,280
Quello che facciamo è che dobbiamo fare in modo di copiare nel file di intestazione

306
00:25:12,280 --> 00:25:16,850
e le informazioni nell'intestazione proprio come il infile ha.

307
00:25:16,850 --> 00:25:22,850
Quello che facciamo è che scriviamo - e ricordare che bf è la variabile

308
00:25:22,850 --> 00:25:29,300
BITMAPFILEHEADER di tipo, quindi quello che facciamo è che basta utilizzare tale contenuto

309
00:25:29,300 --> 00:25:34,980
da scrivere nel file di output.

310
00:25:36,550 --> 00:25:38,510
Qui, ricordo che abbiamo parlato di imbottitura,

311
00:25:38,510 --> 00:25:47,820
come è importante assicurarsi che la quantità di pixel che abbiamo è un multiplo di 4.

312
00:25:47,820 --> 00:25:52,790
Si tratta di una formula molto utile per calcolare la quantità di imbottitura si ha

313
00:25:52,790 --> 00:25:57,670
data la larghezza del file.

314
00:25:57,670 --> 00:26:04,120
Voglio che voi ragazzi a ricordare che in copy.c abbiamo una formula per il calcolo imbottitura.

315
00:26:04,120 --> 00:26:07,970
Va bene? Così tutti ricordo. Grande.

316
00:26:07,970 --> 00:26:14,050
E allora cosa fa impossibile fare il prossimo è che itera su tutte le linee di scansione.

317
00:26:14,050 --> 00:26:23,730
Si passa attraverso le righe e poi memorizza ogni tripla che si legge

318
00:26:23,730 --> 00:26:26,920
scrive e poi nel file di output.

319
00:26:26,920 --> 00:26:33,120
Allora qui stiamo leggendo un solo RGB tripla alla volta

320
00:26:33,120 --> 00:26:39,860
e poi mettere che tripla stessi nel file di output.

321
00:26:41,120 --> 00:26:48,340
La parte difficile è che l'imbottitura non è una tripla RGB,

322
00:26:48,340 --> 00:26:55,200
e quindi non può semplicemente leggere tale importo imbottitura di terne RGB.

323
00:26:55,200 --> 00:27:01,460
Quello che dobbiamo fare è in realtà solo spostare il nostro indicatore di posizione del file, spostare il nostro cursore,

324
00:27:01,460 --> 00:27:06,840
al tipo di saltare tutto l'imbottitura in modo che siamo alla riga successiva.

325
00:27:06,840 --> 00:27:12,990
E poi che questo non è copia vi mostra come si potrebbe desiderare di aggiungere l'imbottitura.

326
00:27:12,990 --> 00:27:14,990
Proprio per questo abbiamo calcolato quanto imbottitura cui abbiamo bisogno,

327
00:27:14,990 --> 00:27:18,220
in modo che significa che abbiamo bisogno di imbottitura numero di 0.

328
00:27:18,220 --> 00:27:24,510
Quello che fa è un ciclo for che mette numero imbottitura di 0 nel nostro file di output.

329
00:27:24,510 --> 00:27:31,170
E poi, infine, si chiude entrambi i file. Si chiude la infile così come il file di emissione.

330
00:27:31,170 --> 00:27:34,870
>> Ecco, questo è impossibile fare come funziona,

331
00:27:34,870 --> 00:27:37,430
e che sta per essere molto utile.

332
00:27:39,720 --> 00:27:43,750
Invece di limitarsi a realtà direttamente copiarlo e incollarlo

333
00:27:43,750 --> 00:27:46,800
o solo a guardarla e digitando quello che vuoi,

334
00:27:46,800 --> 00:27:49,440
si potrebbe semplicemente voler eseguire questo comando nel terminale,

335
00:27:49,440 --> 00:27:54,520
cp impossibile fare whodunit.c, che creerà un nuovo file, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
che contiene il contenuto esattamente come fa copia.

337
00:27:58,330 --> 00:28:03,880
E allora cosa si può fare è utilizzare che come un quadro su cui costruire e modificare

338
00:28:03,880 --> 00:28:06,900
per il nostro file di giallo.

339
00:28:08,500 --> 00:28:14,670
>> Queste sono le nostre cose da fare da fare per Whodunit, ma quello che fa impossibile fare

340
00:28:14,670 --> 00:28:16,730
è in realtà prende cura della maggior parte di loro per noi.

341
00:28:16,730 --> 00:28:21,900
Quindi tutto quello che dobbiamo fare adesso è cambiare i pixel in base alle esigenze

342
00:28:21,900 --> 00:28:25,920
per rendere effettivamente il file leggibile.

343
00:28:25,920 --> 00:28:32,960
Ricordate che per un dato pixel tripla, quindi per una data variabile di tipo RGBTRIPLE,

344
00:28:32,960 --> 00:28:35,990
è possibile accedere ai valori di blu, verde e rosso.

345
00:28:35,990 --> 00:28:38,670
Che sta per tornare utile, perché se è possibile accedere,

346
00:28:38,670 --> 00:28:41,770
questo significa che si può anche verificare,

347
00:28:41,770 --> 00:28:45,430
e questo significa che si può anche cambiare.

348
00:28:45,430 --> 00:28:49,430
>> Così, quando siamo tornati al nostro esempio rosso lente di ingrandimento,

349
00:28:49,430 --> 00:28:53,390
in fondo, che agiva come una sorta di filtro per noi.

350
00:28:53,390 --> 00:28:58,160
Quindi, quello che vogliamo fare è che vogliamo filtrare tutte le triple che sono provenienti pollici

351
00:28:58,160 --> 00:29:01,240
Ci sono diversi modi per farlo.

352
00:29:01,240 --> 00:29:07,100
In sostanza, si può avere qualsiasi tipo di filtro che si desidera.

353
00:29:07,100 --> 00:29:09,890
Forse si desidera modificare tutti i pixel rossi

354
00:29:09,890 --> 00:29:13,570
o forse si desidera modificare un pixel di colore diverso di un colore diverso.

355
00:29:13,570 --> 00:29:15,400
Dipende da voi.

356
00:29:15,400 --> 00:29:19,580
Ricordate che è possibile verificare il colore del pixel è

357
00:29:19,580 --> 00:29:23,000
e poi si può anche cambiare, come si sta passando.

358
00:29:24,410 --> 00:29:26,420
>> Va bene. Ecco, questo è Whodunit.

359
00:29:26,420 --> 00:29:32,760
Una volta che si esegue Whodunit, saprete chi è il colpevole del delitto era.

360
00:29:32,760 --> 00:29:35,540
>> Ora stiamo per andare a ridimensionare.

361
00:29:35,540 --> 00:29:37,990
Stiamo andando ancora a che fare con le bitmap.

362
00:29:37,990 --> 00:29:40,750
Quello che andremo a fare è che stiamo andando ad avere una bitmap di input

363
00:29:40,750 --> 00:29:45,890
e poi andremo a passare in un numero e quindi ottenere una bitmap file di output

364
00:29:45,890 --> 00:29:51,380
dove questo è fondamentalmente il nostro infile scalato per n.

365
00:29:54,670 --> 00:30:01,450
Dire il mio file era solo un pixel di grandi dimensioni.

366
00:30:01,450 --> 00:30:09,100
Poi se il mio n è stato di 3, scala da 3, quindi vorrei ripetere che pixel n volte,

367
00:30:09,100 --> 00:30:14,410
così 3 volte, e poi anche scala verso il basso 3 volte pure.

368
00:30:14,410 --> 00:30:17,840
Così si vede che sto scalando in verticale che in orizzontale.

369
00:30:17,840 --> 00:30:19,680
>> E poi ecco un esempio.

370
00:30:19,680 --> 00:30:27,590
Se si dispone di n = 2, si vede che il primo pixel blu si ripete due volte

371
00:30:27,590 --> 00:30:30,930
orizzontalmente che verticalmente due volte.

372
00:30:30,930 --> 00:30:38,040
E poi, che continua, e così si ha una scala diretta dell'immagine originale per due.

373
00:30:40,920 --> 00:30:47,600
>> Allora se dovessimo dettaglio lo pseudocodice per questo, vogliamo aprire il file.

374
00:30:47,600 --> 00:30:49,880
E poi sapere che se torniamo qui,

375
00:30:49,880 --> 00:30:54,540
si vede che la larghezza per il file di output sarà diverso rispetto alla larghezza del infile.

376
00:30:54,540 --> 00:30:56,130
Che cosa vuol dire?

377
00:30:56,130 --> 00:31:01,230
Questo significa che le nostre informazioni di intestazione sta per cambiare.

378
00:31:01,230 --> 00:31:03,790
E allora cosa dobbiamo provare a fare è aggiornare le informazioni di intestazione,

379
00:31:03,790 --> 00:31:11,820
sapendo che quando si legge nei file se si opera sul quadro impossibile fare,

380
00:31:11,820 --> 00:31:17,570
abbiamo già una variabile che indica la dimensione è e cose del genere.

381
00:31:17,570 --> 00:31:24,060
Quindi, una volta che hai, quello che si potrebbe desiderare di fare è cambiare le variabili particolari.

382
00:31:24,060 --> 00:31:29,380
Ricordate, se si dispone di una struttura, come accedere alle variabili all'interno di quella.

383
00:31:29,380 --> 00:31:32,080
Si utilizza l'operatore punto, giusto?

384
00:31:32,080 --> 00:31:36,420
Allora con questo, sai che hai bisogno di cambiare le informazioni di intestazione.

385
00:31:36,480 --> 00:31:41,030
Così qui è solo un elenco degli elementi reali che stanno per essere la modifica nel file.

386
00:31:41,030 --> 00:31:45,180
La dimensione del file sta per cambiare, l'immagine, così come la larghezza e l'altezza.

387
00:31:45,180 --> 00:31:50,080
Allora tornando alla mappa delle bitmap,

388
00:31:50,080 --> 00:31:57,730
guarda se è l'intestazione del file o l'intestazione info che contiene tali informazioni

389
00:31:57,730 --> 00:32:00,920
e quindi modificare come necessario.

390
00:32:05,010 --> 00:32:12,470
Anche in questo caso, ad esempio cp impossibile fare resize.c.

391
00:32:12,470 --> 00:32:19,270
Ciò significa che resize.c ora contiene tutto quello che è contenuto all'interno di copia

392
00:32:19,270 --> 00:32:24,490
copia perché ci fornisce un modo di lettura per ciascun pixel per pixel scanline.

393
00:32:24,490 --> 00:32:29,860
Eccetto che ora, invece di cambiare i valori come abbiamo fatto in Whodunit,

394
00:32:29,860 --> 00:32:37,980
quello che vogliamo fare è che vogliamo scrivere in più pixel

395
00:32:37,980 --> 00:32:43,580
purché il nostro n è maggiore di 1.

396
00:32:43,580 --> 00:32:47,110
>> Poi quello che vogliamo fare è che vogliamo allungare orizzontalmente da n,

397
00:32:47,110 --> 00:32:50,490
così come si estendono verticalmente dal n.

398
00:32:50,490 --> 00:32:52,710
Come possiamo fare questo?

399
00:32:52,710 --> 00:32:56,890
Dite il vostro n è 2 e si ha questa data infile.

400
00:32:56,890 --> 00:32:58,730
Il cursore sta per iniziare al primo,

401
00:32:58,730 --> 00:33:03,530
e che cosa si vuole fare, se n è 2, si desidera stampare in 2 di questi.

402
00:33:03,530 --> 00:33:05,490
Così si stampa in 2 di questi.

403
00:33:05,490 --> 00:33:10,830
Poi il cursore sta per passare al pixel successivo, che è quello rosso,

404
00:33:10,830 --> 00:33:18,400
e sta andando a stampare 2 di quelle rosse, aggiungendo che su ciò che è fatto prima.

405
00:33:18,400 --> 00:33:26,280
Quindi il cursore si sposterà al pixel successivo e disegnare in 2 di questi.

406
00:33:26,280 --> 00:33:37,180
Se si guarda indietro al impossibile fare il quadro, cosa fa qui

407
00:33:37,180 --> 00:33:42,830
si crea una nuova istanza di un triplo RGB, una nuova variabile chiamata triple.

408
00:33:42,830 --> 00:33:50,500
E qui quando si legge in esso, si legge dal 1 infile RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
e lo memorizza all'interno della variabile tripla.

410
00:33:53,470 --> 00:33:57,590
Quindi in realtà hanno una variabile che rappresenta quel pixel particolare.

411
00:33:57,590 --> 00:34:05,290
Poi, quando si scrive, quello che si potrebbe desiderare di fare è racchiudere l'istruzione fwrite in un ciclo for

412
00:34:05,290 --> 00:34:11,080
che scrive nel file di output il numero di volte necessario.

413
00:34:17,449 --> 00:34:20,100
Questo è abbastanza semplice.

414
00:34:20,200 --> 00:34:27,590
Proprio in fondo ripetere il processo di scrittura n volte di scalare orizzontalmente.

415
00:34:27,590 --> 00:34:32,969
>> Ma dobbiamo ricordare che la nostra imbottitura sta per cambiare.

416
00:34:47,350 --> 00:34:53,020
In precedenza, dire che abbiamo avuto qualcosa di lunghezza 3.

417
00:34:53,020 --> 00:35:00,130
Poi ci sarebbe solo aggiungere in quanto imbottitura? Solo uno di più per renderlo un multiplo di 4.

418
00:35:00,130 --> 00:35:10,480
Ma dire che stiamo scalando questa immagine particolare n = 2.

419
00:35:10,480 --> 00:35:16,300
Allora il numero di pixel blu avremmo alla fine? Avremmo 6.

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

421
00:35:21,470 --> 00:35:26,580
6 non è un multiplo di 4. Qual è il più vicino multiplo di 4? Che sta per essere 8.

422
00:35:26,580 --> 00:35:33,200
Quindi stiamo effettivamente andando ad avere 2 caratteri di padding lì.

423
00:35:33,200 --> 00:35:38,720
>> Qualcuno ricorda se abbiamo una formula per calcolare imbottitura

424
00:35:38,720 --> 00:35:41,350
e dove potrebbe essere?

425
00:35:41,350 --> 00:35:45,160
[Risposta degli studenti incomprensibile] >> Sì, copy.c. Giusto.

426
00:35:45,160 --> 00:35:49,800
C'è una formula impossibile fare a calcolare la quantità di imbottitura si ha

427
00:35:49,800 --> 00:35:53,810
data una particolare larghezza dell'immagine bitmap.

428
00:35:53,810 --> 00:36:02,950
E allora che sta per essere utile quando è necessario aggiungere una certa quantità di imbottitura

429
00:36:02,950 --> 00:36:06,160
per capire effettivamente quanta imbottitura è necessario aggiungere.

430
00:36:10,820 --> 00:36:15,850
Ma una nota, però, è che si vuole fare in modo che si sta utilizzando la giusta dimensione.

431
00:36:15,850 --> 00:36:21,410
Basta stare attenti perché si sta in fondo andando a che fare con due immagini bitmap.

432
00:36:21,410 --> 00:36:23,410
Si vuole fare in modo che si sta utilizzando quella giusta.

433
00:36:23,410 --> 00:36:26,820
Quando si sta calcolando l'imbottitura per il file di output, che si desidera utilizzare la larghezza del file di output

434
00:36:26,820 --> 00:36:29,860
e non la larghezza della precedente.

435
00:36:29,860 --> 00:36:37,240
>> Grande. Questo tipo di cura si estende una intera immagine bitmap in senso orizzontale.

436
00:36:37,240 --> 00:36:41,290
Ma quello che vogliamo fare è in realtà tratto verticale pure.

437
00:36:41,290 --> 00:36:48,760
Ciò sta andando essere un po 'più complicato, perché quando abbiamo terminato di copiare una riga

438
00:36:48,760 --> 00:36:51,580
e la scrittura di tale riga, il nostro cursore sarà alla fine.

439
00:36:51,580 --> 00:36:56,210
Quindi, se si legge di nuovo, allora è solo andando a leggere alla riga successiva.

440
00:36:56,210 --> 00:37:03,660
Quindi, quello che vogliamo fare è una specie di trovare il modo di copiare tali righe di nuovo

441
00:37:03,660 --> 00:37:12,500
o solo tipo di prendere quella riga e poi riscrivere di nuovo.

442
00:37:14,380 --> 00:37:17,940
Come tipo di accennato, ci sono diversi modi per farlo.

443
00:37:17,940 --> 00:37:23,040
Che cosa si potrebbe fare è come si sta attraversando e la lettura attraverso la linea di scansione particolare

444
00:37:23,040 --> 00:37:28,560
e la modifica, se necessario, quindi tipo di negozio tutti quei pixel in una matrice.

445
00:37:28,560 --> 00:37:36,350
Poi, in seguito a sapere che hai bisogno di stampare che ancora l'array,

446
00:37:36,350 --> 00:37:39,830
e così si può semplicemente utilizzare tale matrice per farlo.

447
00:37:39,830 --> 00:37:44,500
Un altro modo per farlo è che si può copiare in basso di una riga,

448
00:37:44,500 --> 00:37:47,950
capire che è necessario copiare di nuovo, quindi in realtà spostare il cursore,

449
00:37:47,950 --> 00:37:50,950
e che ha intenzione di utilizzare il metodo di fseek.

450
00:37:50,950 --> 00:37:56,410
Si potrebbe spostare il cursore per tutto il tragitto e poi ripetere il processo di copia di nuovo.

451
00:37:56,410 --> 00:38:03,960
>> Quindi, se il nostro numero di scala è n, allora quante volte dobbiamo tornare indietro

452
00:38:03,960 --> 00:38:10,500
e riscrivere una linea? >> [Studente] n - 1. >> Si ', perfetto. n - 1.

453
00:38:10,500 --> 00:38:14,390
Ce l'abbiamo fatta già una volta, e allora dobbiamo provare a ripetere il processo di tornare indietro

454
00:38:14,390 --> 00:38:17,460
n - 1 quantità di volte.

455
00:38:22,730 --> 00:38:25,860
Va bene. Così ci avete la funzione di ridimensionamento.

456
00:38:25,860 --> 00:38:34,360
>> Ora siamo in grado di arrivare a una parte davvero divertente, il mio preferito pset, che è Recover.

457
00:38:34,360 --> 00:38:39,580
Invece di bitmap, questa volta abbiamo a che fare con file JPEG.

458
00:38:39,580 --> 00:38:43,370
Non siamo in realtà in un file solo di JPEG,

459
00:38:43,370 --> 00:38:46,600
ci è dato fondamentalmente un formato di scheda di memoria prima.

460
00:38:46,600 --> 00:38:51,790
E così questo contiene un po 'di informazioni e valori spazzatura in principio,

461
00:38:51,790 --> 00:38:57,240
e poi inizia e ha un sacco di file JPEG.

462
00:38:57,240 --> 00:39:03,430
Tuttavia, stiamo consegnata una tessera in cui abbiamo cancellato le foto;

463
00:39:03,430 --> 00:39:08,300
in sostanza, abbiamo dimenticato dove le foto si trovano all'interno della carta.

464
00:39:08,300 --> 00:39:12,770
Allora il nostro compito in Recuperare è di passare attraverso questo formato carta

465
00:39:12,770 --> 00:39:16,500
e trovare quelle immagini di nuovo.

466
00:39:16,500 --> 00:39:23,990
>> Per fortuna, la struttura dei file JPEG e il file di carta è un po 'utile.

467
00:39:23,990 --> 00:39:28,850
E 'sicuramente avrebbe potuto essere un po' più complicato se non fosse in questo particolare formato.

468
00:39:28,850 --> 00:39:40,160
Ogni file JPEG inizia in realtà con due possibili sequenze, di cui sopra.

469
00:39:40,160 --> 00:39:42,970
In pratica, ogni volta che si dispone di un nuovo file JPEG,

470
00:39:42,970 --> 00:39:52,720
inizia con la sequenza di FFD8 FFE0 o l'altra, FFD8 ffe1.

471
00:39:52,720 --> 00:39:59,530
Un'altra cosa utile da sapere è che i file JPEG sono memorizzati in modo contiguo.

472
00:39:59,530 --> 00:40:03,380
Così ogni volta che un file JPEG termina, gli altri si parte.

473
00:40:03,380 --> 00:40:07,070
Quindi non vi è alcun tipo di in-tra i valori lì.

474
00:40:07,070 --> 00:40:15,510
Una volta raggiunto l'inizio di una JPEG, se hai già letto un JPEG,

475
00:40:15,510 --> 00:40:21,800
sai che hai raggiunto la fine della precedente e l'inizio di quello successivo.

476
00:40:21,800 --> 00:40:25,890
>> Per visualizzare questo tipo di, ho fatto uno schema.

477
00:40:25,890 --> 00:40:36,910
Un'altra cosa JPEG è che possiamo leggere in sequenze di 512 byte alla volta,

478
00:40:36,910 --> 00:40:39,380
analogamente con l'inizio della carta.

479
00:40:39,380 --> 00:40:43,370
Non abbiamo bisogno di essere controllando ogni singolo byte perché avrebbe fatto schifo.

480
00:40:43,370 --> 00:40:48,200
Così, invece, quello che possiamo fare è in realtà appena letto in 512 byte alla volta

481
00:40:48,200 --> 00:40:54,700
e poi, invece di controllare tra quelle in quelle fette piccolo piccolo,

482
00:40:54,700 --> 00:40:58,640
possiamo solo controllare l'inizio dei 512 byte.

483
00:40:58,640 --> 00:41:02,570
In sostanza, in questo quadro, quello che vedi è all'inizio della carta,

484
00:41:02,570 --> 00:41:08,700
si dispone di valori che non sono realmente rilevanti per i file JPEG veri e propri.

485
00:41:08,700 --> 00:41:15,830
Ma poi quello che ho è una stella per indicare una delle due sequenze di partenza per un file JPEG.

486
00:41:15,830 --> 00:41:19,910
Così ogni volta che vedi una stella, lo sai che hai un file JPEG.

487
00:41:19,910 --> 00:41:25,030
E poi ogni file JPEG sta per essere un multiplo di 512 byte

488
00:41:25,030 --> 00:41:27,880
ma non necessariamente la stessa multiple.

489
00:41:27,880 --> 00:41:32,050
Il modo in cui si sa che hai colpito un altro JPEG è se si colpisce un'altra stella,

490
00:41:32,050 --> 00:41:39,090
un'altra sequenza iniziale di byte.

491
00:41:39,090 --> 00:41:43,330
Allora quello che abbiamo qui è di avere il file JPEG rosso continuando fino a colpire una stella,

492
00:41:43,330 --> 00:41:45,150
che è indicato da un nuovo colore.

493
00:41:45,150 --> 00:41:48,510
Si prosegue e poi si preme un'altra stella, che ha colpito un altro JPEG,

494
00:41:48,510 --> 00:41:50,590
si continua tutta la strada fino alla fine.

495
00:41:50,590 --> 00:41:53,180
Sei in l'ultima immagine qui, quello rosa.

496
00:41:53,180 --> 00:41:58,220
Si va fino alla fine fino a colpire il carattere di fine file.

497
00:41:58,220 --> 00:42:00,820
Questo sta per essere veramente utile.

498
00:42:00,820 --> 00:42:03,170
>> A pochi takeaway principali qui:

499
00:42:03,170 --> 00:42:06,670
Il file di scheda non si avvia con un JPEG,

500
00:42:06,670 --> 00:42:13,350
ma una volta JPEG inizia, tutte le immagini JPEG sono memorizzati affiancati l'uno all'altro.

501
00:42:17,520 --> 00:42:20,420
>> Alcuni pseudocodice per il Recupero.

502
00:42:20,420 --> 00:42:22,570
In primo luogo, stiamo per aprire il nostro file di carta,

503
00:42:22,570 --> 00:42:27,500
e che ha intenzione di utilizzare il nostro file funzioni I / O.

504
00:42:27,500 --> 00:42:32,430
Abbiamo intenzione di ripetere il seguente processo finché non avremo raggiunto la fine del file.

505
00:42:32,430 --> 00:42:36,450
Stiamo andando a leggere 512 byte alla volta.

506
00:42:36,450 --> 00:42:39,180
E quello che ho detto qui è che stiamo andando a memorizzare in un buffer,

507
00:42:39,180 --> 00:42:46,230
Quindi, in pratica conservare queste 512 byte finché non sappiamo esattamente cosa fare con loro.

508
00:42:46,230 --> 00:42:50,300
Poi quello che vogliamo fare è che vogliamo verificare se abbiamo colpito una stella o meno.

509
00:42:50,300 --> 00:42:57,960
Se abbiamo colpito una stella, se abbiamo colpito una delle sequenze di partenza,

510
00:42:57,960 --> 00:42:59,980
allora sappiamo che abbiamo raggiunto un nuovo file JPEG.

511
00:42:59,980 --> 00:43:08,860
Che cosa dobbiamo provare a fare è che stiamo andando a voler creare un nuovo file nella directory pset4

512
00:43:08,860 --> 00:43:14,480
di continuare a fare quel file.

513
00:43:14,480 --> 00:43:18,220
Ma anche, se abbiamo già fatto una prima JPEG,

514
00:43:18,220 --> 00:43:25,620
poi vogliamo porre fine a tale file e spingerlo nella cartella pset4,

515
00:43:25,620 --> 00:43:29,780
dove avremo il file memorizzato perché se non si specifica che abbiamo finito il file JPEG,

516
00:43:29,780 --> 00:43:37,290
poi ci sono fondamentalmente un importo indeterminato. I file JPEG non avrà mai fine.

517
00:43:37,290 --> 00:43:40,840
Così vuole fare in modo che, quando stiamo leggendo in un file JPEG e per iscritto che,

518
00:43:40,840 --> 00:43:46,590
vogliamo chiudere specificamente che per aprire quella successiva.

519
00:43:46,590 --> 00:43:48,430
Noi ti consigliamo di controllare diverse cose.

520
00:43:48,430 --> 00:43:52,880
Vogliamo verificare se siamo all'inizio di un nuovo file JPEG con il nostro tampone

521
00:43:52,880 --> 00:43:56,780
e anche se abbiamo già trovato una prima JPEG

522
00:43:56,780 --> 00:44:03,930
perché che cambierà il processo un po '.

523
00:44:03,930 --> 00:44:07,880
Allora dopo si passa attraverso tutto il percorso e si colpisce la fine del file,

524
00:44:07,880 --> 00:44:11,570
allora che cosa si vorrà fare è ti consigliamo di chiudere tutti i file che sono attualmente aperti.

525
00:44:11,570 --> 00:44:14,100
Questo sarà probabilmente l'ultimo file JPEG che avete,

526
00:44:14,100 --> 00:44:18,930
nonché il file della scheda che hai avuto a che fare con.

527
00:44:21,940 --> 00:44:28,670
>> L'ultimo ostacolo che dobbiamo affrontare è come fare in realtà un file JPEG

528
00:44:28,670 --> 00:44:31,950
e come in realtà spingere alla cartella.

529
00:44:33,650 --> 00:44:39,850
Il pset richiede che ogni JPEG che si trova essere nel formato seguente,

530
00:44:39,850 --> 00:44:43,990
dove si ha il numero. jpg.

531
00:44:43,990 --> 00:44:50,750
Il numero, anche se è 0, lo chiamiamo 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Ogni volta che si trova un JPEG nel programma,

533
00:44:55,730 --> 00:44:58,040
si sta andando a voler dare un nome nel modo che ha trovato.

534
00:44:58,040 --> 00:44:59,700
Che cosa significa?

535
00:44:59,700 --> 00:45:03,530
Abbiamo bisogno di sorta di tenere traccia di quante abbiamo trovato

536
00:45:03,530 --> 00:45:08,680
e che il numero di ciascun JPEG dovrebbe essere.

537
00:45:08,680 --> 00:45:13,800
Qui stiamo andando a sfruttare la funzione sprintf.

538
00:45:13,800 --> 00:45:17,480
Simile a printf, che solo tipo di stampa su un valore nel terminale,

539
00:45:17,480 --> 00:45:23,910
sprintf stampa il file nella cartella fuori.

540
00:45:23,910 --> 00:45:30,870
E così ciò che questo avrebbe fatto se avessi sprintf, titolo, e quindi la stringa lì,

541
00:45:30,870 --> 00:45:36,660
sarebbe stampare 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Supponendo che ho chiuso i miei file in modo corretto,

543
00:45:41,020 --> 00:45:47,210
che dovrebbe contenere il file che avevo scritto fuori.

544
00:45:47,210 --> 00:45:50,320
Ma una cosa è che il codice che ho qui

545
00:45:50,320 --> 00:45:53,360
non tutto ciò che soddisfa il pset richiede.

546
00:45:53,360 --> 00:46:02,410
Il pset richiede che il secondo file JPEG deve essere denominato 002 invece di 2.

547
00:46:02,410 --> 00:46:09,160
Così, quando si stampa il nome, allora forse si potrebbe desiderare di modificare il segnaposto leggermente.

548
00:46:09,160 --> 00:46:18,140
>> Qualcuno ricorda come ci permettono di spazi aggiuntivi quando stampare qualcosa?

549
00:46:18,140 --> 00:46:22,530
Gia '. >> [Studente] Hai messo un 3 tra il segno di percentuale e il 2. >> Si ', perfetto.

550
00:46:22,530 --> 00:46:25,610
Potrai inserire un 3 in questo caso perché ci vuole spazio per 3.

551
00:46:25,610 --> 00:46:32,590
3d% probabilmente vi darà 002.jpg invece di 2.

552
00:46:32,590 --> 00:46:40,120
Il primo argomento nella funzione sprintf è in realtà un array di caratteri,

553
00:46:40,120 --> 00:46:42,520
che abbiamo precedentemente conosciuto come stringhe.

554
00:46:42,520 --> 00:46:50,700
Quelli volontà, un po 'più simile a un deposito temporaneo, basta memorizzare la stringa risultante.

555
00:46:50,700 --> 00:46:54,950
Non sarà davvero a che fare con questo, ma è necessario includerlo.

556
00:46:54,950 --> 00:47:00,710
>> Sapendo che ogni nome di file ha il numero, che occupa tre caratteri,

557
00:47:00,710 --> 00:47:06,770
e poi. jpg, per quanto tempo dovrebbe essere questa matrice?

558
00:47:09,070 --> 00:47:14,310
Buttate via un numero. Quanti caratteri per il titolo, nel nome?

559
00:47:18,090 --> 00:47:26,320
Quindi ci sono tre hashtags, periodo, jpg. >> [Studente] 7. >> 7. Non proprio.

560
00:47:26,320 --> 00:47:32,000
Stiamo andando a voler 8 perché vogliamo consentire il terminatore null pure.

561
00:47:45,340 --> 00:47:49,730
>> Infine, solo per tirare fuori il processo che vi ritroverete a fare per recuperare,

562
00:47:49,730 --> 00:47:55,420
avete alcune informazioni inizio.

563
00:47:55,420 --> 00:48:02,460
Si prosegue fino a trovare l'inizio di un file JPEG,

564
00:48:02,460 --> 00:48:07,900
e che può essere una delle due sequenze di partenza.

565
00:48:07,900 --> 00:48:12,510
Continui a leggere. Ogni barra qui rappresenta 512 byte.

566
00:48:12,510 --> 00:48:22,630
Continui a leggere, continua a leggere fino a quando si incontra un'altra sequenza di partenza.

567
00:48:22,630 --> 00:48:29,790
Una volta che avete, si termina l'attuale JPEG - in questo caso, è quello rosso,

568
00:48:29,790 --> 00:48:31,030
così si vuole porre fine a tale.

569
00:48:31,030 --> 00:48:35,540
Si desidera sprintf il nome di tale nella cartella pset4,

570
00:48:35,540 --> 00:48:41,580
poi si vuole aprire un nuovo formato JPEG e poi continuare a leggere

571
00:48:41,580 --> 00:48:46,370
fino a quando si verifica il successivo.

572
00:48:46,370 --> 00:48:49,040
Continuate a leggere, continuate a leggere,

573
00:48:49,040 --> 00:48:56,290
e poi finalmente, alla fine, si sta andando a raggiungere la fine del file,

574
00:48:56,290 --> 00:49:00,360
e così si vorrà chiudere l'ultima JPEG che si stava lavorando,

575
00:49:00,360 --> 00:49:08,380
sprintf che nella cartella pset4, e poi guardare tutte le immagini che hai ottenuto.

576
00:49:08,380 --> 00:49:12,050
Quelle immagini sono in realtà immagini di CS50 personale,

577
00:49:12,050 --> 00:49:16,430
e quindi questo è dove la parte divertente bonus del pset è disponibile in

578
00:49:16,430 --> 00:49:26,310
è che sono in competizione per le sezioni per trovare i TF nelle immagini

579
00:49:26,310 --> 00:49:34,610
e scattare foto con loro per dimostrare che hai fatto il pset

580
00:49:34,610 --> 00:49:37,030
e in modo da poter vedere quali sono i membri del personale nelle immagini.

581
00:49:37,030 --> 00:49:41,510
Allora si scattano foto con il personale. A volte dovrete inseguire giù.

582
00:49:41,510 --> 00:49:44,680
Probabilmente alcuni di loro cercheranno di scappare da te.

583
00:49:44,680 --> 00:49:47,320
È scattare foto con loro.

584
00:49:47,320 --> 00:49:51,190
Questo è in corso. Non è dovuto quando il pset è dovuto.

585
00:49:51,190 --> 00:49:53,340
Il termine sarà annunciato nelle specifiche.

586
00:49:53,340 --> 00:49:58,060
Poi, insieme con la sezione, qualunque sia il capitolo prende il maggior numero di immagini

587
00:49:58,060 --> 00:50:04,430
con i membri dello staff più vincerà un premio piuttosto impressionante.

588
00:50:04,430 --> 00:50:08,890
Questo è il tipo di incentivo per ottenere la vostra pset4 finito il più rapidamente possibile

589
00:50:08,890 --> 00:50:10,820
perché allora si può ottenere al lavoro

590
00:50:10,820 --> 00:50:14,570
caccia a tutti i diversi membri dello staff CS50.

591
00:50:14,570 --> 00:50:17,500
Non è obbligatorio, però, quindi una volta che le immagini,

592
00:50:17,500 --> 00:50:20,310
allora avete finito con pset4.

593
00:50:20,310 --> 00:50:23,970
>> E ho finito con Walkthrough 4, quindi grazie a tutti per essere venuti.

594
00:50:23,970 --> 00:50:29,330
Buona fortuna con Forensics. [Applausi]

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