1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Procédure pas à pas - 4 Set problème]

2
00:00:02,700 --> 00:00:05,000
[Zamyla Chan - Université de Harvard]

3
00:00:05,000 --> 00:00:07,340
[C'est CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
Très bien. Bonjour à tous et bienvenue dans Procédure pas à pas 4.

5
00:00:11,670 --> 00:00:14,270
>> Aujourd'hui, notre pset est Forensics.

6
00:00:14,270 --> 00:00:18,080
Forensics est un pset vraiment amusant qui consiste à traiter les fichiers bitmap

7
00:00:18,080 --> 00:00:21,550
de découvrir qui a commis un crime.

8
00:00:21,550 --> 00:00:24,200
Ensuite, nous allons redimensionner certains fichiers bitmap,

9
00:00:24,200 --> 00:00:27,780
puis nous allons aussi faire face à une partie vraiment fun appelé Recover,

10
00:00:27,780 --> 00:00:31,160
dans laquelle nous sommes fondamentalement remis une carte mémoire

11
00:00:31,160 --> 00:00:34,350
dans laquelle quelqu'un a accidentellement supprimé tous leurs fichiers,

12
00:00:34,350 --> 00:00:38,860
et nous a demandé de récupérer ces fichiers.

13
00:00:38,860 --> 00:00:42,910
>> Mais d'abord, avant d'entrer dans le pset, je veux simplement féliciter tout le monde.

14
00:00:42,910 --> 00:00:45,230
Nous sommes sur au milieu de ce cours.

15
00:00:45,230 --> 00:00:50,070
Quiz 0 est derrière nous, et nous sommes à pset4, si essentiellement, nous sommes à mi-chemin.

16
00:00:50,070 --> 00:00:55,490
Nous avons parcouru un long chemin, si vous regardez en arrière à vos psets, PSET0 et pset1,

17
00:00:55,490 --> 00:00:57,300
si vous féliciter à ce sujet,

18
00:00:57,300 --> 00:01:00,760
et nous allons entrer dans quelque chose de vraiment amusant.

19
00:01:00,760 --> 00:01:07,070
>> Donc, notre boîte à outils pour ce pset, encore une fois, au lieu de courir sudo yum-y update,

20
00:01:07,070 --> 00:01:13,890
nous sommes en mesure de simplement exécuter update50 si vous êtes à la version 17.3 et au-dessus de l'appareil.

21
00:01:13,890 --> 00:01:17,380
Assurez-vous donc à courir update50 - c'est beaucoup plus facile, quelques personnages moins -

22
00:01:17,380 --> 00:01:20,640
afin de s'assurer que vous êtes à la dernière version de l'appareil.

23
00:01:20,640 --> 00:01:25,410
Surtout, il est important de update50 lorsque nous commençons à utiliser CS50 Check.

24
00:01:25,410 --> 00:01:28,700
Donc, assurez-vous que vous faites cela.

25
00:01:28,700 --> 00:01:30,760
>> Pour toutes les sections de ce pset,

26
00:01:30,760 --> 00:01:34,350
nous allons avoir affaire avec des entrées et sorties de fichiers, File I / O.

27
00:01:34,350 --> 00:01:38,140
Nous allons aller sur un grand nombre de programmes qui traitent avec des tableaux

28
00:01:38,140 --> 00:01:40,350
pointant vers des fichiers et des choses comme ça,

29
00:01:40,350 --> 00:01:43,050
Nous voulons donc nous assurer que nous sommes vraiment familier et confortable

30
00:01:43,050 --> 00:01:47,990
traitant de la façon de l'entrée et de sortie dans des fichiers.

31
00:01:47,990 --> 00:01:52,080
>> Dans le code de distribution de ce pset est un fichier appelé copy.c,

32
00:01:52,080 --> 00:01:55,280
et c'est ce que nous allons trouver va être vraiment utile pour nous

33
00:01:55,280 --> 00:02:00,340
parce que nous allons finir par copier l'copy.c

34
00:02:00,340 --> 00:02:05,350
et il suffit de modifier légèrement pour être en mesure d'atteindre les 2 premières parties du problème posé.

35
00:02:05,350 --> 00:02:09,030
>> Et alors que je l'ai mentionné plus tôt, nous avons affaire à des bitmaps ainsi que JPEG.

36
00:02:09,030 --> 00:02:13,170
Alors, vraiment comprendre la structure de la façon dont ces fichiers sont organisés,

37
00:02:13,170 --> 00:02:16,170
comment nous pouvons vraiment traduire le 0 et de 1 dans structs

38
00:02:16,170 --> 00:02:19,040
et les choses que nous pouvons réellement comprendre et d'interpréter et de modifier,

39
00:02:19,040 --> 00:02:21,000
qui sera très important,

40
00:02:21,000 --> 00:02:25,970
afin d'entrer dans les fichiers JPEG et bitmap et la compréhension de la structure de celles-ci.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, comme d'habitude, commence par une section de questions.

42
00:02:30,780 --> 00:02:36,600
Ceux-ci traitent avec le fichier d'E / S et de vous habitués à cela.

43
00:02:36,600 --> 00:02:42,520
Ensuite, la partie 1 est Whodunit, dans lequel on vous donne un fichier bitmap

44
00:02:42,520 --> 00:02:45,630
qui ressemble un peu à points rouges partout.

45
00:02:45,630 --> 00:02:52,180
Et puis, fondamentalement ce que nous allons faire est de prendre ce fichier et il suffit de modifier légèrement

46
00:02:52,180 --> 00:02:54,010
dans une version que l'on peut lire.

47
00:02:54,010 --> 00:02:56,000
Essentiellement, une fois terminer, nous aurons le même fichier,

48
00:02:56,000 --> 00:03:02,630
sauf que nous serons en mesure de voir le message caché caché par tous ces points rouges.

49
00:03:02,630 --> 00:03:07,310
Puis Resize est un programme qui, étant donné un fichier

50
00:03:07,310 --> 00:03:11,490
et alors le nom du fichier qui l'émet et reçoit un numéro et,

51
00:03:11,490 --> 00:03:16,850
sera effectivement redimensionner ce bitmap par cette valeur entière.

52
00:03:16,850 --> 00:03:19,240
Puis enfin, nous avons le pset Recover.

53
00:03:19,240 --> 00:03:24,160
On nous donne une carte mémoire et ensuite de récupérer toutes les photos

54
00:03:24,160 --> 00:03:25,920
qui ont été accidentellement supprimés,

55
00:03:25,920 --> 00:03:31,420
mais, comme nous allons apprendre, pas réellement supprimés et retirés du dossier;

56
00:03:31,420 --> 00:03:38,470
nous avons juste un peu perdu là où ils étaient dans le dossier, mais nous allons récupérer cela.

57
00:03:38,470 --> 00:03:44,950
>> Grande. Donc, allez dans le dossier I / O précisément, il s'agit de toute une liste de fonctions que vous allez utiliser.

58
00:03:44,950 --> 00:03:49,840
Vous avez déjà vu un peu les bases de la fonction fopen, fread fwrite, et,

59
00:03:49,840 --> 00:03:54,350
mais nous allons approfondir certains fichiers I / O fonctions telles que fputc,

60
00:03:54,350 --> 00:03:56,930
dans lequel vous venez d'écrire un caractère à la fois,

61
00:03:56,930 --> 00:04:02,000
à fseek, où vous sorte de déplacer l'indicateur de position avant et arrière,

62
00:04:02,000 --> 00:04:05,770
et puis quelques autres. Mais nous en discuterons un peu plus tard au cours de la pset.

63
00:04:08,050 --> 00:04:13,100
>> Alors d'abord, juste pour entrer dans le fichier I / O avant d'aller dans le pset,

64
00:04:13,100 --> 00:04:19,860
pour ouvrir un fichier, par exemple, ce que vous avez à faire est de définir un pointeur vers ce fichier.

65
00:04:19,860 --> 00:04:22,710
Nous avons donc un pointeur FILE *.

66
00:04:22,710 --> 00:04:27,140
Dans ce cas, je vais l'appeler un pointeur parce que ça va être mon infile.

67
00:04:27,140 --> 00:04:33,340
Et donc je vais utiliser la fonction fopen, puis le nom du fichier

68
00:04:33,340 --> 00:04:36,360
puis le mode dans lequel je vais être en charge du dossier.

69
00:04:36,360 --> 00:04:42,080
Il ya donc "r" dans ce cas pour la lecture, "w" pour l'écriture, puis «a» pour l'ajout.

70
00:04:42,080 --> 00:04:44,270
Par exemple, lorsque vous avez affaire à un infile

71
00:04:44,270 --> 00:04:47,310
et tout ce que vous voulez faire est de lire les bits et les octets qui y sont stockées,

72
00:04:47,310 --> 00:04:50,420
alors vous allez probablement vouloir utiliser "r" comme mode.

73
00:04:50,420 --> 00:04:54,520
Lorsque vous voulez vraiment écrire, sorte de créer un nouveau fichier,

74
00:04:54,520 --> 00:04:57,220
alors qu'est-ce que nous allons faire, c'est que nous allons ouvrir le nouveau fichier

75
00:04:57,220 --> 00:05:02,410
et utiliser le "w" en mode d'écriture.

76
00:05:02,410 --> 00:05:07,540
>> Alors quand vous êtes en train de lire dans les fichiers, la structure est la suivante.

77
00:05:07,540 --> 00:05:14,930
D'abord vous incluez le pointeur vers la structure qui contiendra les octets que vous lisez.

78
00:05:14,930 --> 00:05:19,830
Alors que va être la position de fin des octets que vous lisez.

79
00:05:19,830 --> 00:05:23,360
Vous êtes alors va pour indiquer la taille, comme essentiellement le nombre d'octets

80
00:05:23,360 --> 00:05:30,100
votre programme est à lire dans le fichier, la taille essentiellement un élément est,

81
00:05:30,100 --> 00:05:32,620
et puis vous allez spécifier le nombre d'éléments que vous souhaitez lire.

82
00:05:32,620 --> 00:05:34,980
Et puis enfin, vous devez savoir où vous lisez,

83
00:05:34,980 --> 00:05:37,580
de sorte que ça va être votre pointeur dans.

84
00:05:37,580 --> 00:05:41,780
J'ai un code de couleur, car ceux-ci fread est également très similaire à fwrite,

85
00:05:41,780 --> 00:05:47,050
sauf que vous voulez vous assurer que vous utilisez le bon ordre,

86
00:05:47,050 --> 00:05:51,960
assurez-vous que vous êtes en train d'écrire ou de lire à partir du fichier de droite.

87
00:05:54,910 --> 00:05:58,610
>> Alors que précédemment, si nous avons la taille de l'élément ainsi que le nombre d'éléments,

88
00:05:58,610 --> 00:06:00,600
alors on peut jouer ici un peu.

89
00:06:00,600 --> 00:06:06,810
Dire que j'ai une struct DOG et alors j'ai envie de lire deux chiens à la fois.

90
00:06:06,810 --> 00:06:12,450
Ce que je pourrais faire est de dire la taille d'un élément va être la taille d'un chien

91
00:06:12,450 --> 00:06:14,770
et je vais lire quand même deux d'entre eux.

92
00:06:14,770 --> 00:06:18,290
Sinon, ce que je pourrais faire est de dire que je vais tout simplement lire un élément

93
00:06:18,290 --> 00:06:21,340
et qu'un élément va être la taille de deux chiens.

94
00:06:21,340 --> 00:06:24,320
Donc, c'est la façon dont vous pouvez analogue genre de jeu autour de la taille et du nombre

95
00:06:24,320 --> 00:06:28,250
selon ce qui est plus intuitif.

96
00:06:28,250 --> 00:06:30,810
>> Très bien. Alors maintenant, nous arrivons à des fichiers d'écriture.

97
00:06:30,810 --> 00:06:36,880
Lorsque vous voulez écrire un fichier, le premier argument est en fait où vous lisez.

98
00:06:36,880 --> 00:06:42,050
Donc, c'est à peu près les données que vous allez écrire dans le fichier,

99
00:06:42,050 --> 00:06:44,490
qui est le pointeur à la fin.

100
00:06:44,490 --> 00:06:47,670
Ainsi, lorsque vous faites affaire avec le pset, assurez-vous de ne pas confondre.

101
00:06:47,670 --> 00:06:50,480
Peut-être que le côté définitions de l'autre.

102
00:06:50,480 --> 00:06:58,090
Vous pouvez tirer sur les définitions dans le manuel en tapant man et fwrite, par exemple,

103
00:06:58,090 --> 00:06:59,950
dans le terminal, ou vous pouvez vous référer à cette diapositive

104
00:06:59,950 --> 00:07:03,570
et assurez-vous que vous utilisez la bonne.

105
00:07:03,570 --> 00:07:08,700
Encore une fois, pour fwrite, quand vous avez un fichier que vous voulez écrire dans,

106
00:07:08,700 --> 00:07:14,290
qui va être le dernier argument et que ça va être un pointeur vers ce fichier.

107
00:07:14,290 --> 00:07:18,670
Alors c'est comme ça que nous traitons avec l'écriture peut-être plusieurs octets à la fois,

108
00:07:18,670 --> 00:07:21,820
mais disons que vous voulez juste écrire en un seul caractère.

109
00:07:21,820 --> 00:07:25,940
Comme nous le verrons plus tard dans cet exemple, les bitmaps nous devrons utiliser.

110
00:07:25,940 --> 00:07:32,180
C'est alors que nous pouvons utiliser fputc, essentiellement juste en mettant un caractère à la fois, chr,

111
00:07:32,180 --> 00:07:37,050
dans le pointeur de fichier, et c'est notre pointeur là-bas.

112
00:07:38,700 --> 00:07:41,560
Alors chaque fois que nous cherchons ou écrire dans un fichier,

113
00:07:41,560 --> 00:07:44,690
le fichier est garder la trace de l'endroit où nous sommes.

114
00:07:44,690 --> 00:07:47,810
Donc, c'est une sorte de curseur, l'indicateur de position.

115
00:07:47,810 --> 00:07:54,330
Et donc, chaque fois que nous écrivons ou relire dans un fichier,

116
00:07:54,330 --> 00:07:56,760
le fichier se souvient effectivement là où il est,

117
00:07:56,760 --> 00:07:59,270
et il continue de l'endroit où se trouve le curseur.

118
00:07:59,270 --> 00:08:03,970
Cela peut être utile lorsque vous souhaitez, par exemple, de lire dans un certain laps de faire quelque chose

119
00:08:03,970 --> 00:08:06,160
puis lire dans le montant suivant,

120
00:08:06,160 --> 00:08:10,700
mais parfois nous pourrions revenir en arrière ou en fait de partir d'une certaine valeur de référence.

121
00:08:10,700 --> 00:08:16,870
Alors la fonction fseek, ce qu'il fait est nous permet de déplacer le curseur dans un fichier donné

122
00:08:16,870 --> 00:08:19,680
un certain nombre d'octets.

123
00:08:19,680 --> 00:08:24,260
Et puis, ce que nous avons à faire est de spécifier l'endroit où la valeur de référence.

124
00:08:24,260 --> 00:08:31,520
Alors, soit il se déplace vers l'avant ou vers l'arrière de l'endroit où le curseur se trouve actuellement,

125
00:08:31,520 --> 00:08:35,750
ou nous pouvons spécifier qu'il doit simplement déplacer à partir du début du fichier

126
00:08:35,750 --> 00:08:37,090
ou à partir de la fin de l'image.

127
00:08:37,090 --> 00:08:41,230
Et afin que vous puissiez passer des valeurs négatives ou positives à la quantité,

128
00:08:41,230 --> 00:08:44,960
et qui sorte de déplacer le curseur vers l'avant ou vers l'arrière.

129
00:08:46,170 --> 00:08:51,920
>> Avant d'entrer dans les psets autres, des questions sur le fichier I / O?

130
00:08:53,860 --> 00:08:59,990
D'accord. Comme nous entrons dans d'autres exemples, n'hésitez pas à m'arrêter pour les questions.

131
00:08:59,990 --> 00:09:06,930
>> Donc, en Whodunit, vous êtes remis un fichier bitmap semblable à celui-rouge sur la diapositive,

132
00:09:06,930 --> 00:09:14,510
et il semble que cela - un tas de points rouges - et vous ne savez pas vraiment ce qui est écrit.

133
00:09:14,510 --> 00:09:23,310
Si vous strabisme, vous pourriez être en mesure de voir une légère coloration bleutée à l'intérieur du milieu.

134
00:09:23,310 --> 00:09:26,270
Essentiellement, c'est là où le texte est stocké.

135
00:09:26,270 --> 00:09:30,270
Il y avait une assassiner ce qui s'est passé, et nous avons besoin de savoir qui a fait ça.

136
00:09:30,270 --> 00:09:36,760
Pour ce faire, nous devons genre de convertir cette image en un format lisible.

137
00:09:36,760 --> 00:09:42,740
Si vous jamais rencontré ce, parfois, il serait petits kits

138
00:09:42,740 --> 00:09:48,510
où vous auriez une loupe avec un film rouge. N'importe qui? Ouais.

139
00:09:48,510 --> 00:09:52,770
Donc, vous serait quelque chose comme ceci mains, vous auriez une loupe

140
00:09:52,770 --> 00:09:58,130
avec le film rouge dessus, vous serait-il mis sur l'image,

141
00:09:58,130 --> 00:10:03,410
et vous serez en mesure de voir le message caché dedans.

142
00:10:03,410 --> 00:10:07,080
Nous n'avons pas une loupe avec un film rouge, de sorte qu'au lieu que nous allons sorte de créer notre propre

143
00:10:07,080 --> 00:10:09,060
dans ce jeu de processeurs.

144
00:10:09,060 --> 00:10:15,760
Et afin que l'utilisateur va polar entrée, puis l'indice,. Bmp,

145
00:10:15,760 --> 00:10:18,800
de sorte que c'est la infile, c'est le message red dot,

146
00:10:18,800 --> 00:10:23,550
et puis ils disent verdict.bmp va être notre fichier de sortie.

147
00:10:23,550 --> 00:10:27,900
Donc, il va créer une nouvelle image bitmap similaire à l'indice une

148
00:10:27,900 --> 00:10:32,600
sauf dans un format lisible où l'on peut voir le message caché.

149
00:10:32,600 --> 00:10:37,550
>> Puisque nous allons avoir affaire à éditer et manipuler des bitmaps d'une certaine sorte,

150
00:10:37,550 --> 00:10:42,400
nous allons type de plongée dans la structure de ces fichiers bitmap.

151
00:10:42,400 --> 00:10:48,130
Nous sommes allés sur ces bits un peu en cours, mais nous allons les examiner un peu plus.

152
00:10:48,130 --> 00:10:51,740
Les bitmaps sont essentiellement juste un arrangement d'octets

153
00:10:51,740 --> 00:10:55,790
où nous avons spécifié les octets dire quoi.

154
00:10:55,790 --> 00:11:00,540
Voici donc un peu comme une carte de l'image bitmap

155
00:11:00,540 --> 00:11:08,550
dire que cela commence avec certains fichiers d'en-tête, commence avec quelques informations là-dedans.

156
00:11:08,550 --> 00:11:16,540
Vous voyez que, à propos de l'octet numéro 14, la taille est indiquée sur l'image bitmap,

157
00:11:16,540 --> 00:11:18,520
et il continue son chemin.

158
00:11:18,520 --> 00:11:23,810
Mais alors qu'est-ce qui nous intéresse vraiment ici commence autour de l'octet numéro 54.

159
00:11:23,810 --> 00:11:26,060
Nous avons ces triplets RVB.

160
00:11:26,060 --> 00:11:30,760
Qu'est-ce que ça va faire, c'est de contenir les pixels réels, les valeurs de couleur.

161
00:11:30,760 --> 00:11:35,950
Tout ce qui précède que, dans l'en-tête est une information

162
00:11:35,950 --> 00:11:41,240
correspondant à la taille de l'image, la largeur de l'image, et la hauteur.

163
00:11:41,240 --> 00:11:44,930
Quand nous allons en rembourrage plus tard, nous verrons pourquoi la taille de l'image

164
00:11:44,930 --> 00:11:48,670
peut être différente de la largeur ou de la hauteur.

165
00:11:48,670 --> 00:11:54,240
Alors pour représenter celles-ci - ces images bitmap sont des séquences d'octets -

166
00:11:54,240 --> 00:11:59,370
ce que nous pourrions faire est de dire ok, je vais me souviens qu'à l'indice 14,

167
00:11:59,370 --> 00:12:03,380
c'est là que la taille est, par exemple, mais plutôt ce que nous allons faire pour rendre cela plus facile

168
00:12:03,380 --> 00:12:06,020
est de l'encapsuler dans une structure.

169
00:12:06,020 --> 00:12:08,880
Et nous avons donc deux structures faites pour nous, un BITMAPFILEHEADER

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

171
00:12:10,440 --> 00:12:14,840
et donc, chaque fois que nous lisons dans ce fichier, par défaut, il va se passer dans l'ordre,

172
00:12:14,840 --> 00:12:22,360
et ainsi de suite afin qu'elle va aussi à remplir dans des variables telles que biWidth et biSize.

173
00:12:25,270 --> 00:12:31,230
Et puis enfin, chaque pixel est représenté par trois octets.

174
00:12:31,230 --> 00:12:35,500
La première est la quantité de bleu dans le pixel, le second est la quantité de vert,

175
00:12:35,500 --> 00:12:41,120
et enfin, la quantité de rouge, où 0 est essentiellement pas de vert bleu ou rouge ou aucun

176
00:12:41,120 --> 00:12:43,720
puis ss est la valeur maximale.

177
00:12:43,720 --> 00:12:46,800
Ce sont des valeurs hexadécimales.

178
00:12:46,800 --> 00:12:53,870
Alors si nous avons ff0000, puis qui correspond à la quantité maximale de bleu

179
00:12:53,870 --> 00:12:58,890
et puis pas de vert et pas de rouge, oui, alors cela nous donnerait un pixel bleu.

180
00:12:58,890 --> 00:13:04,190
Alors, si nous avons tous ff de toute la ligne, cela signifie que nous avons un pixel blanc.

181
00:13:04,190 --> 00:13:11,370
C'est une sorte de face à généralement lorsque nous disons RVB. Il va vraiment BGR.

182
00:13:12,750 --> 00:13:18,990
>> Donc, si nous avons effectivement se pencher sur l'exemple d'une image bitmap - permettez-moi d'arracher ici.

183
00:13:31,560 --> 00:13:33,830
C'est un petit peu.

184
00:13:39,890 --> 00:13:47,840
Je suis un zoom avant, et nous pouvons voir qu'il est pixélisé. Il ressemble à des blocs de couleur.

185
00:13:47,840 --> 00:13:50,110
Vous avez blocs blancs, puis les blocs rouges.

186
00:13:50,110 --> 00:13:53,700
Si vous jouez dans Microsoft Paint, par exemple, vous pourriez faire quelque chose comme ça

187
00:13:53,700 --> 00:13:58,960
par tout simplement de peindre certaines cases dans un ordre spécifique.

188
00:13:58,960 --> 00:14:08,060
Alors, que cela se traduit dans le bitmap est la suivante.

189
00:14:08,060 --> 00:14:15,710
Ici, nous avons premiers pixels blancs, que tous les 6 sont f, puis nous avons pixels rouges,

190
00:14:15,710 --> 00:14:19,910
indiqué par 0000ff.

191
00:14:19,910 --> 00:14:27,940
Et si la séquence d'octets que nous avons indique comment l'image bitmap va regarder.

192
00:14:27,940 --> 00:14:32,230
Alors qu'est-ce que j'ai fait ici est juste d'écrire sur tous les octets et coloré dans le rouge

193
00:14:32,230 --> 00:14:37,550
de sorte que vous pouvez sorte de le voir, si vous strabisme un peu, comment ce genre de montre un visage souriant.

194
00:14:40,180 --> 00:14:46,390
>> La façon dont le travail bitmap images est je l'avais envisagée essentiellement comme une grille.

195
00:14:46,390 --> 00:14:54,940
Et si par défaut, chaque ligne de la grille doit être un multiple de 4 octets.

196
00:15:00,520 --> 00:15:07,060
Si l'on regarde une image bitmap, vous remplissez dans chaque valeur.

197
00:15:07,060 --> 00:15:17,370
Par exemple, vous pourriez avoir un rouge ici, ici un vert, un bleu ici,

198
00:15:17,370 --> 00:15:24,950
mais vous devez vous assurer que l'image est rempli avec un multiple de quatre octets.

199
00:15:24,950 --> 00:15:32,200
Donc, si je veux que mon image soit trois blocs de large, alors je dois mettre une valeur vide

200
00:15:32,200 --> 00:15:35,640
dans le dernier pour en faire un multiple de quatre.

201
00:15:35,640 --> 00:15:39,530
Alors, je voudrais ajouter quelque chose que nous appelons rembourrage.

202
00:15:39,530 --> 00:15:43,750
Je vais juste pour indiquer qu'il ya un x.

203
00:15:44,920 --> 00:15:54,160
Maintenant, disons que nous voulons une image qui est de 7 pixels de long, par exemple.

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

205
00:16:04,750 --> 00:16:07,000
et tout cela est rempli avec la couleur.

206
00:16:07,000 --> 00:16:10,620
La façon dont les images bitmap travail est que nous avons besoin d'un 8.

207
00:16:10,620 --> 00:16:12,460
Actuellement, nous avons 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
Nous avons besoin de 8 places pour l'image bitmap à lire correctement.

209
00:16:19,360 --> 00:16:25,600
Alors que nous avons à faire est d'ajouter dans un peu de rembourrage

210
00:16:25,600 --> 00:16:29,430
afin de s'assurer que toutes les largeurs sont uniformes

211
00:16:29,430 --> 00:16:34,260
et que toutes les largeurs sont un multiple de 4.

212
00:16:42,110 --> 00:16:47,310
Et si je l'ai déjà indiqué, rembourrage comme x ou une ligne ondulée,

213
00:16:47,310 --> 00:16:53,880
mais dans les images réelles bitmap le rembourrage est indiqué par un 0 en hexadécimal.

214
00:16:53,880 --> 00:16:57,340
Ce serait donc un caractère unique, 0.

215
00:16:58,980 --> 00:17:06,329
Quel pourrait être utile est la commande xxd.

216
00:17:06,329 --> 00:17:11,220
Ce qu'il fait est fait, vous montre, comme semblable à ce que je faisais avant avec le smiley

217
00:17:11,220 --> 00:17:15,630
quand j'ai fait imprimer ce que chaque couleur serait pour le pixel

218
00:17:15,630 --> 00:17:21,800
puis un code de couleur, lorsque vous exécutez xxd avec les commandes suivantes,

219
00:17:21,800 --> 00:17:28,670
alors il va vraiment imprimer ce que les couleurs sont pour ces pixels.

220
00:17:28,670 --> 00:17:33,810
Qu'est-ce que vous avez à faire est ici j'indique, comme le s-54

221
00:17:33,810 --> 00:17:36,530
me dit que je vais commencer à l'octet 54ème

222
00:17:36,530 --> 00:17:40,820
car avant cela, rappelez-vous, si nous regardons en arrière sur la carte des bitmaps,

223
00:17:40,820 --> 00:17:42,690
c'est tout ce que les informations d'en-tête et des choses comme ça.

224
00:17:42,690 --> 00:17:46,280
Mais ce qui nous intéresse vraiment, c'est sur les pixels réels qui indiquent la couleur.

225
00:17:46,280 --> 00:17:52,700
Donc, en ajoutant que le drapeau,-s 54, alors nous sommes en mesure de voir les valeurs de couleur.

226
00:17:52,700 --> 00:17:56,020
Et ne vous inquiétez pas les drapeaux compliquées et des choses comme ça.

227
00:17:56,020 --> 00:18:05,020
Dans la spécification problème posé, vous aurez des instructions sur la façon d'utiliser xxd pour afficher les pixels.

228
00:18:07,070 --> 00:18:15,590
Donc, si vous voyez ici, il sorte de ressemble à une boîte verte, cette petite chose.

229
00:18:15,590 --> 00:18:23,610
J'ai un code de couleur du 00ff00 que revient à dire pas de bleu, beaucoup de vert, et non rouge.

230
00:18:23,610 --> 00:18:26,370
Alors qui correspond au vert.

231
00:18:26,370 --> 00:18:31,920
Comme vous le voyez ici, nous voyons un rectangle vert.

232
00:18:31,920 --> 00:18:36,660
Ce rectangle vert est à seulement 3 pixels de large, de sorte que ce que nous avons à faire

233
00:18:36,660 --> 00:18:44,350
afin de s'assurer que l'image est un multiple de 4 de large est d'ajouter dans un rembourrage supplémentaire.

234
00:18:44,350 --> 00:18:49,460
Et alors c'est comme ça que vous voyez ces 0s ici.

235
00:18:49,460 --> 00:18:54,510
Ce sera effectivement le résultat de votre pset Redimensionner,

236
00:18:54,510 --> 00:19:01,350
prenant essentiellement la petite image, puis en l'agrandissant par 4.

237
00:19:01,350 --> 00:19:09,380
Et si ce que nous voyons, c'est que vraiment cette image est de 12 pixels de large, mais 12 est un multiple de 4,

238
00:19:09,380 --> 00:19:12,940
et si nous avons effectivement ne vois pas de 0s à la fin parce que nous n'avons pas besoin d'ajouter de

239
00:19:12,940 --> 00:19:19,070
car il est entièrement rembourré. Il n'a pas de place non plus.

240
00:19:20,720 --> 00:19:23,470
>> D'accord. Une question sur votre padding?

241
00:19:25,150 --> 00:19:27,460
D'accord. Cool.

242
00:19:27,460 --> 00:19:32,520
>> Comme je l'ai mentionné précédemment, les bitmaps sont juste une séquence d'octets.

243
00:19:32,520 --> 00:19:39,170
Et donc ce que nous avons est au lieu de devoir suivre exactement quel numéro de l'octet

244
00:19:39,170 --> 00:19:47,050
correspond à un élément spécifique, nous avons effectivement créé une structure pour représenter cela.

245
00:19:47,050 --> 00:19:50,930
Donc, ce que nous avons est une struct RGBTRIPLE.

246
00:19:50,930 --> 00:19:54,590
Chaque fois que vous avez une instance d'un triplet RVB,

247
00:19:54,590 --> 00:20:00,970
parce que c'est un type définissent struct, vous pouvez accéder à la variable rgbtBlue,

248
00:20:00,970 --> 00:20:09,520
de même, les variables de vert et rouge, qui indiquent combien bleu,, vert et rouge

249
00:20:09,520 --> 00:20:11,580
respectivement, que vous avez.

250
00:20:11,580 --> 00:20:16,800
>> Donc, si nous avons l'ensemble de variables bleu à 0, l'ensemble vert et suivants,

251
00:20:16,800 --> 00:20:22,060
qui est la valeur maximale que vous pouvez avoir, et puis le rouge variable à 0,

252
00:20:22,060 --> 00:20:27,870
alors quelle couleur serait-ce particulier RVB triple représentent-ils? >> [L'élève] Green.

253
00:20:27,870 --> 00:20:29,150
Vert. Exactement.

254
00:20:29,150 --> 00:20:34,480
Il va être intéressant de savoir que chaque fois que vous avez une instance d'un triplet RVB,

255
00:20:34,480 --> 00:20:41,340
vous pouvez accéder à la quantité de couleur - bleu, vert et rouge - séparément.

256
00:20:43,350 --> 00:20:54,900
>> Maintenant que nous avons parlé de la structure de cela, nous allons jeter un oeil au fichier BMP.

257
00:20:54,900 --> 00:20:57,870
Ce sont structs faites pour vous.

258
00:20:57,870 --> 00:21:01,820
Ici, nous avons une structure BITMAPFILEHEADER.

259
00:21:01,820 --> 00:21:07,610
D'intérêt est la taille.

260
00:21:07,610 --> 00:21:12,660
Plus tard, nous avons l'entête d'info, qui a un peu plus de choses qui sont intéressantes pour nous,

261
00:21:12,660 --> 00:21:15,480
à savoir la taille, la largeur et la hauteur.

262
00:21:15,480 --> 00:21:19,170
Comme nous allons passer à plus tard, quand vous lisez dans le fichier,

263
00:21:19,170 --> 00:21:25,500
il lit automatiquement parce que nous avons mis de l'ordre d'être le même.

264
00:21:25,500 --> 00:21:31,990
Si la biSize contiendra les octets bons qui correspondent à la taille réelle de l'image.

265
00:21:34,700 --> 00:21:40,500
Et puis voilà, enfin, comme nous en avons parlé, nous avons la struct typedef RGBTRIPLE.

266
00:21:40,500 --> 00:21:46,840
Nous avons un rgbtBlue, vert, rouge et qui lui est associé.

267
00:21:48,210 --> 00:21:49,340
>> Grande. D'accord.

268
00:21:49,340 --> 00:21:56,360
Maintenant que nous comprenons un peu bitmaps, de comprendre que nous avons un fichier d'en-tête

269
00:21:56,360 --> 00:22:00,790
et un collecteur d'informations qui lui est associé et puis après ça, nous avons les choses intéressantes

270
00:22:00,790 --> 00:22:05,110
des couleurs, et ces couleurs sont représentées par des structs RGBTRIPLE,

271
00:22:05,110 --> 00:22:12,710
et ceux qui, à leur tour, ont trois valeurs associées au bleu, le vert et le rouge.

272
00:22:12,710 --> 00:22:17,270
>> Alors maintenant, nous pouvons type de pensez à récupérer un peu.

273
00:22:17,270 --> 00:22:20,130
Désolé. Pensez à Whodunit.

274
00:22:20,130 --> 00:22:25,750
Quand nous avons notre fichier indice, alors ce que nous voulons faire est de lire pour elle, pixel par pixel

275
00:22:25,750 --> 00:22:33,860
puis changer quelque chose à ces pixels pour que nous puissions le sortir dans un format lisible.

276
00:22:33,860 --> 00:22:41,020
Et donc de le sortir, nous allons écrire pixel par pixel dans le fichier verdict.bmp.

277
00:22:41,020 --> 00:22:45,120
C'est le genre de beaucoup à faire. Nous sommes conscients que.

278
00:22:45,120 --> 00:22:49,860
Donc, ce que nous avons fait, c'est que nous avons effectivement mis à votre disposition copy.c.

279
00:22:49,860 --> 00:22:57,610
Qu'est-ce copy.c fait est fait juste une copie exacte d'un fichier bitmap donné, puis il sort.

280
00:22:57,610 --> 00:23:01,900
Donc, ce qui ouvre déjà le fichier pour vous, se lit en pixel par pixel,

281
00:23:01,900 --> 00:23:04,510
et écrit ensuite dans dans un fichier de sortie.

282
00:23:04,510 --> 00:23:07,080
>> Jetons un coup d'oeil.

283
00:23:13,390 --> 00:23:18,290
Ce n'est assurant le bon usage,

284
00:23:18,290 --> 00:23:22,640
obtenir les noms des fichiers ici.

285
00:23:22,640 --> 00:23:29,940
Qu'est-ce que cela fait est qu'il définit le fichier d'entrée à ce que nous avons adoptée en la infile ici,

286
00:23:29,940 --> 00:23:34,750
qui est notre deuxième ligne de commande argument.

287
00:23:34,750 --> 00:23:37,640
Vérifie que l'on peut ouvrir le fichier.

288
00:23:38,960 --> 00:23:44,860
Vérifie que nous pouvons faire une outfile nouveau ici.

289
00:23:45,630 --> 00:23:53,270
Alors qu'est-ce le cas ici, ça commence essentiellement de lecture dans le fichier bitmap depuis le début.

290
00:23:53,270 --> 00:23:56,700
Le début, comme nous le savons, contient le BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
et si ces séquences de bits sera directement remplir le BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Donc, ce que nous avons ici est dire que bf BITMAPFILEHEADER -

293
00:24:07,940 --> 00:24:13,150
c'est notre nouvelle variable de BITMAPFILEHEADER type -

294
00:24:13,150 --> 00:24:22,560
nous allons mettre à l'intérieur bf ce que nous lisons à partir de pointeur, qui est notre infile.

295
00:24:22,560 --> 00:24:23,970
Combien avons-nous lu?

296
00:24:23,970 --> 00:24:32,160
Nous lisons dans le nombre d'octets que nous devons contenir la BITMAPFILEHEADER ensemble.

297
00:24:32,160 --> 00:24:34,660
De la même manière, c'est ce que nous faisons pour l'entête d'info.

298
00:24:34,660 --> 00:24:39,010
Nous continuons donc notre fichier long dans le infile,

299
00:24:39,010 --> 00:24:44,360
et nous lisons les bits et les octets, et nous sommes les branchant directement dans

300
00:24:44,360 --> 00:24:47,880
dans ces cas, des variables que nous faisons.

301
00:24:49,370 --> 00:24:53,800
Ici, nous sommes juste s'assurer que le bitmap est un bitmap.

302
00:24:57,670 --> 00:25:01,030
>> Maintenant nous avons un fichier de sortie, non?

303
00:25:01,030 --> 00:25:04,420
Donc, en l'état où nous la créons, c'est essentiellement vide.

304
00:25:04,420 --> 00:25:07,710
Nous devons donc essentiellement de créer un nouveau bitmap à partir de zéro.

305
00:25:07,710 --> 00:25:12,280
Ce que nous faisons est que nous devons nous assurer que nous copier dans le fichier d'en-tête

306
00:25:12,280 --> 00:25:16,850
et l'entête d'info comme l'a infile.

307
00:25:16,850 --> 00:25:22,850
Ce que nous faisons est que nous écrivons - et n'oubliez pas que bf est la variable

308
00:25:22,850 --> 00:25:29,300
BITMAPFILEHEADER de type, de sorte que nous faisons est que nous venons d'utiliser ce contenu

309
00:25:29,300 --> 00:25:34,980
d'écrire dans le fichier de sortie.

310
00:25:36,550 --> 00:25:38,510
Ici, rappelez-vous, nous avons parlé de rembourrage,

311
00:25:38,510 --> 00:25:47,820
comment il est important de s'assurer que la quantité de pixels que nous avons est un multiple de 4.

312
00:25:47,820 --> 00:25:52,790
Il s'agit d'une formule très utile pour calculer combien vous avez rembourrage

313
00:25:52,790 --> 00:25:57,670
compte tenu de la largeur de votre dossier.

314
00:25:57,670 --> 00:26:04,120
Je veux que vous de se rappeler que dans copy.c nous avons une formule pour le calcul de rembourrage.

315
00:26:04,120 --> 00:26:07,970
Okay? Alors rappelez-vous que tout le monde. Grande.

316
00:26:07,970 --> 00:26:14,050
Alors, que fait copy.c prochain est-il une itération sur toutes les lignes de balayage.

317
00:26:14,050 --> 00:26:23,730
Elle passe par les lignes d'abord, puis stocke chaque triplet qu'il lit

318
00:26:23,730 --> 00:26:26,920
et écrit ensuite dans le fichier de sortie.

319
00:26:26,920 --> 00:26:33,120
Alors ici nous lisons une seule RGB triple à un moment

320
00:26:33,120 --> 00:26:39,860
et en mettant ensuite que les trois mêmes dans le fichier de sortie.

321
00:26:41,120 --> 00:26:48,340
Le point délicat est que le rembourrage n'est pas un triplet RVB,

322
00:26:48,340 --> 00:26:55,200
et si nous ne pouvons pas lire ce montant rembourrage de triplets RVB.

323
00:26:55,200 --> 00:27:01,460
Ce que nous avons à faire est de simplement déplacer notre indicateur de position, déplacez le curseur notre,

324
00:27:01,460 --> 00:27:06,840
de sorte de sauter par-dessus tout le rembourrage de sorte que nous sommes à la ligne suivante.

325
00:27:06,840 --> 00:27:12,990
Et alors qu'est-ce que cela fait est exemplaire vous montre comment vous pouvez ajouter du rembourrage.

326
00:27:12,990 --> 00:27:14,990
Nous avons donc calculé combien nous avons besoin de rembourrage,

327
00:27:14,990 --> 00:27:18,220
ce qui signifie que nous avons besoin de rembourrage nombre de 0.

328
00:27:18,220 --> 00:27:24,510
Qu'est-ce que cela fait est une boucle qui met numéro de rembourrage de 0s dans notre fichier de sortie.

329
00:27:24,510 --> 00:27:31,170
Et puis enfin, vous fermez les deux fichiers. Vous fermez la infile ainsi que le fichier de sortie.

330
00:27:31,170 --> 00:27:34,870
>> C'est comme ça que copy.c travaux,

331
00:27:34,870 --> 00:27:37,430
et que ça va être très utile.

332
00:27:39,720 --> 00:27:43,750
Au lieu de simplement fait directement copier-coller

333
00:27:43,750 --> 00:27:46,800
ou tout simplement regarder et en tapant ce que vous voulez,

334
00:27:46,800 --> 00:27:49,440
vous pourriez vouloir exécuter cette commande dans le terminal,

335
00:27:49,440 --> 00:27:54,520
cp copy.c whodunit.c, ce qui va créer un nouveau fichier, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
qui contient le contenu exactement la même que la copie ne.

337
00:27:58,330 --> 00:28:03,880
Alors ce que nous pouvons faire, c'est de l'utiliser comme un cadre sur lequel construire et modifier

338
00:28:03,880 --> 00:28:06,900
pour notre fichier polar.

339
00:28:08,500 --> 00:28:14,670
>> Ce sont nos listes de tâches à faire pour Whodunit, mais ce ne copy.c

340
00:28:14,670 --> 00:28:16,730
est s'occupe effectivement de la plupart de nous.

341
00:28:16,730 --> 00:28:21,900
Donc, tout ce que nous devons faire maintenant est de changer les pixels en fonction des besoins

342
00:28:21,900 --> 00:28:25,920
de faire réellement le fichier lisible.

343
00:28:25,920 --> 00:28:32,960
Rappelez-vous que pour un pixel donné triple, donc pour une variable donnée RGBTRIPLE type,

344
00:28:32,960 --> 00:28:35,990
vous pouvez accéder aux bleus, les valeurs vertes et rouges.

345
00:28:35,990 --> 00:28:38,670
Cela va venir dans maniable parce que si vous pouvez y accéder,

346
00:28:38,670 --> 00:28:41,770
ce qui signifie que vous pouvez également les consulter,

347
00:28:41,770 --> 00:28:45,430
ce qui signifie que vous pouvez également les modifier.

348
00:28:45,430 --> 00:28:49,430
>> Alors, quand nous sommes retournés à notre exemple loupe rouge,

349
00:28:49,430 --> 00:28:53,390
essentiellement, qui agissait comme une sorte de filtre pour nous.

350
00:28:53,390 --> 00:28:58,160
Donc, ce que nous voulons faire, c'est que nous voulons filtrer tous les triplets qui sont à venir po

351
00:28:58,160 --> 00:29:01,240
Il ya plusieurs façons de le faire.

352
00:29:01,240 --> 00:29:07,100
Fondamentalement, vous pouvez avoir n'importe quel type de filtre que vous souhaitez.

353
00:29:07,100 --> 00:29:09,890
Peut-être que vous voulez changer tous les pixels rouges

354
00:29:09,890 --> 00:29:13,570
ou peut-être que vous voulez changer un pixel de couleur différente d'une couleur différente.

355
00:29:13,570 --> 00:29:15,400
C'est à vous.

356
00:29:15,400 --> 00:29:19,580
N'oubliez pas que vous pouvez vérifier quelle est la couleur du pixel est

357
00:29:19,580 --> 00:29:23,000
et puis vous pouvez également le modifier comme vous le vivez.

358
00:29:24,410 --> 00:29:26,420
>> D'accord. Donc, c'est Whodunit.

359
00:29:26,420 --> 00:29:32,760
Une fois que vous exécutez Whodunit, vous saurez qui est le coupable du crime était.

360
00:29:32,760 --> 00:29:35,540
>> Maintenant, nous allons aller à redimensionner.

361
00:29:35,540 --> 00:29:37,990
Nous allons encore avoir affaire avec des bitmaps.

362
00:29:37,990 --> 00:29:40,750
Ce que nous allons faire, c'est que nous allons avoir un bitmap d'entrée

363
00:29:40,750 --> 00:29:45,890
puis nous allons passer dans un certain nombre, puis faire une image bitmap outfile

364
00:29:45,890 --> 00:29:51,380
où c'est essentiellement notre infile mise à l'échelle par n.

365
00:29:54,670 --> 00:30:01,450
Dis mon dossier était juste un gros pixel.

366
00:30:01,450 --> 00:30:09,100
Ensuite, si mon n est 3, mise à l'échelle par 3, alors je tiens à répéter que pixel n certain nombre de fois,

367
00:30:09,100 --> 00:30:14,410
donc 3 fois, et puis aussi le réduire 3 fois aussi.

368
00:30:14,410 --> 00:30:17,840
Donc, vous voyez que je suis en train de mise à l'échelle aussi bien verticalement qu'horizontalement.

369
00:30:17,840 --> 00:30:19,680
>> Et puis, voici un exemple.

370
00:30:19,680 --> 00:30:27,590
Si vous avez n = 2, on voit que le premier pixel bleu il répété deux fois

371
00:30:27,590 --> 00:30:30,930
aussi bien horizontalement que verticalement deux fois.

372
00:30:30,930 --> 00:30:38,040
Et puis qui se poursuit sur, et si vous avez une mise à l'échelle directe de votre image originale par deux.

373
00:30:40,920 --> 00:30:47,600
>> Alors, si nous étions au détail le pseudo-code pour cela, nous voulons ouvrir le fichier.

374
00:30:47,600 --> 00:30:49,880
Et puis, sachant que si nous revenons ici,

375
00:30:49,880 --> 00:30:54,540
nous voyons que la largeur de la outfile va être différente de la largeur de la infile.

376
00:30:54,540 --> 00:30:56,130
Qu'est-ce que ça veut dire?

377
00:30:56,130 --> 00:31:01,230
Cela signifie que nos informations d'en-tête va changer.

378
00:31:01,230 --> 00:31:03,790
Et donc ce que nous voudrons faire est de mettre à jour les informations d'en-tête,

379
00:31:03,790 --> 00:31:11,820
sachant que quand nous lisons dans les fichiers si vous vous trouvez sur le cadre copy.c,

380
00:31:11,820 --> 00:31:17,570
nous avons déjà une variable qui indique ce qui est de la taille et des choses comme ça.

381
00:31:17,570 --> 00:31:24,060
Donc, une fois que vous avez, ce que vous pouvez faire est de changer ces variables particulières.

382
00:31:24,060 --> 00:31:29,380
Rappelez-vous, si vous avez une structure, comment accéder à des variables au sein de cette.

383
00:31:29,380 --> 00:31:32,080
Vous pouvez utiliser l'opérateur point, non?

384
00:31:32,080 --> 00:31:36,420
Alors que l'aide, vous savez que vous aurez besoin de changer l'information d'en-tête.

385
00:31:36,480 --> 00:31:41,030
Alors, voici juste une liste des éléments réels qui vont se modifier dans votre fichier.

386
00:31:41,030 --> 00:31:45,180
La taille de fichier va changer, l'image, ainsi que la largeur et la hauteur.

387
00:31:45,180 --> 00:31:50,080
Donc, on peut ensuite revenir à la carte des bitmaps,

388
00:31:50,080 --> 00:31:57,730
regarde si c'est l'en-tête du fichier ou l'entête d'info qui contient l'information

389
00:31:57,730 --> 00:32:00,920
puis effectuez les modifications nécessaires.

390
00:32:05,010 --> 00:32:12,470
Encore une fois, dire cp copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
Cela signifie que resize.c contient maintenant tout ce qui est contenu à l'intérieur copie

392
00:32:19,270 --> 00:32:24,490
parce copie nous donne une façon de lire pour chaque pixel par pixel scanline.

393
00:32:24,490 --> 00:32:29,860
Sauf que maintenant, au lieu de simplement changer les valeurs comme nous l'avons fait dans Whodunit,

394
00:32:29,860 --> 00:32:37,980
ce que nous voulons faire, c'est que nous voulons écrire en pixels multiples

395
00:32:37,980 --> 00:32:43,580
aussi longtemps que notre n est supérieur à 1.

396
00:32:43,580 --> 00:32:47,110
>> Alors ce que nous voulons faire, c'est que nous voulons pour l'étirer horizontalement par n,

397
00:32:47,110 --> 00:32:50,490
ainsi que l'étirer verticalement par n.

398
00:32:50,490 --> 00:32:52,710
Comment pourrions-nous faire cela?

399
00:32:52,710 --> 00:32:56,890
Supposons que votre n est 2 et que vous avez cette donnée infile.

400
00:32:56,890 --> 00:32:58,730
Votre curseur va commencer à la première,

401
00:32:58,730 --> 00:33:03,530
et ce que vous voulez faire si n est 2, vous souhaitez imprimer en 2 de ceux-ci.

402
00:33:03,530 --> 00:33:05,490
Ainsi, vous imprimez en 2 de ceux-ci.

403
00:33:05,490 --> 00:33:10,830
Ensuite, le curseur va se déplacer au pixel suivant, qui est le rouge,

404
00:33:10,830 --> 00:33:18,400
et il va imprimer 2 de ces rouges, en l'ajoutant sur ce qu'il a fait avant.

405
00:33:18,400 --> 00:33:26,280
Ensuite, le curseur se déplace vers le pixel suivant et tirer dans 2 d'entre eux.

406
00:33:26,280 --> 00:33:37,180
Si vous regardez en arrière à la copy.c cadre, ce que cela fait ici

407
00:33:37,180 --> 00:33:42,830
il est crée une nouvelle instance d'un triplet RVB, une nouvelle variable appelée triple.

408
00:33:42,830 --> 00:33:50,500
Et là, quand il lit en lui, il lit le infile 1 RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
et les stocke à l'intérieur de cette variable triple.

410
00:33:53,470 --> 00:33:57,590
Alors vous avez réellement une variable représentant ce pixel particulier.

411
00:33:57,590 --> 00:34:05,290
Puis, quand vous écrivez, ce que vous pouvez faire est envelopper la déclaration fwrite dans une boucle for

412
00:34:05,290 --> 00:34:11,080
qu'il écrit dans votre fichier de sortie autant de fois que nécessaire.

413
00:34:17,449 --> 00:34:20,100
C'est assez simple.

414
00:34:20,200 --> 00:34:27,590
Juste essentiellement répéter le processus d'écriture n fois à l'échelle horizontalement.

415
00:34:27,590 --> 00:34:32,969
>> Mais nous devons nous rappeler que notre padding va changer.

416
00:34:47,350 --> 00:34:53,020
Auparavant, dire que nous avions quelque chose de longueur 3.

417
00:34:53,020 --> 00:35:00,130
Ensuite, nous avons voudrais simplement ajouter dans la marge intérieure? Un pas de plus pour en faire un multiple de 4.

418
00:35:00,130 --> 00:35:10,480
Mais dire que nous sommes l'extension de cette image particulière en n = 2.

419
00:35:10,480 --> 00:35:16,300
Alors combien de pixels bleus aurions-nous à la fin? Nous aurions 6.

420
00:35:16,300 --> 00:35:21,470
1, 2, 3, 4, 5, 6. Très bien.

421
00:35:21,470 --> 00:35:26,580
6 n'est pas un multiple de 4. Quelle est la plus proche multiple de 4? Cela va être 8.

422
00:35:26,580 --> 00:35:33,200
Donc, nous allons en fait d'avoir 2 caractères de rembourrage là.

423
00:35:33,200 --> 00:35:38,720
>> Est-ce que quelqu'un se souvient si nous avons une formule pour calculer rembourrage

424
00:35:38,720 --> 00:35:41,350
et où cela pourrait être?

425
00:35:41,350 --> 00:35:45,160
[Réponse de l'élève inaudible] >> Ouais, copy.c. Droite.

426
00:35:45,160 --> 00:35:49,800
Il existe une formule en copy.c de calculer combien vous avez rembourrage

427
00:35:49,800 --> 00:35:53,810
étant donné une certaine largeur de l'image bitmap.

428
00:35:53,810 --> 00:36:02,950
Alors qui va être utile lorsque vous avez besoin d'ajouter une certaine quantité de rembourrage

429
00:36:02,950 --> 00:36:06,160
pour vraiment comprendre à quel point vous avez besoin de rembourrage à ajouter.

430
00:36:10,820 --> 00:36:15,850
Mais on note, cependant, c'est que vous voulez vous assurer que vous utilisez la bonne taille.

431
00:36:15,850 --> 00:36:21,410
Il suffit de faire attention parce que vous êtes essentiellement allez avoir affaire avec deux images bitmap.

432
00:36:21,410 --> 00:36:23,410
Vous voulez vous assurer que vous utilisez la bonne.

433
00:36:23,410 --> 00:36:26,820
Lorsque vous calculez le rembourrage pour le fichier de sortie, vous souhaitez utiliser la largeur de la outfile

434
00:36:26,820 --> 00:36:29,860
et pas la largeur de la précédente.

435
00:36:29,860 --> 00:36:37,240
>> Grande. Ce genre de prend soin d'étirer une image bitmap entière horizontalement.

436
00:36:37,240 --> 00:36:41,290
Mais ce que nous voulons faire, c'est effectivement l'étirer verticalement.

437
00:36:41,290 --> 00:36:48,760
Cela va être un peu plus compliqué parce que quand nous avons fini de copier une ligne

438
00:36:48,760 --> 00:36:51,580
et de l'écriture de cette ligne, notre curseur va être à la fin.

439
00:36:51,580 --> 00:36:56,210
Donc, si nous lisons encore, alors il va tout simplement à lire à la ligne suivante.

440
00:36:56,210 --> 00:37:03,660
Alors qu'est-ce que nous voulons faire est une sorte de trouver un moyen de copier ces lignes à nouveau

441
00:37:03,660 --> 00:37:12,500
ou juste une sorte de prendre cette ligne, puis le réécrire à nouveau.

442
00:37:14,380 --> 00:37:17,940
Comme je l'ai mentionné genre d', il existe plusieurs façons différentes de faire ça.

443
00:37:17,940 --> 00:37:23,040
Qu'est-ce que vous pourriez faire, c'est que vous vivez et de la lecture à travers la ligne de balayage particulière

444
00:37:23,040 --> 00:37:28,560
et le changer si nécessaire, puis type de magasin tous les pixels dans un tableau.

445
00:37:28,560 --> 00:37:36,350
Puis, plus tard, vous savez que vous aurez besoin d'imprimer ce tableau encore,

446
00:37:36,350 --> 00:37:39,830
et si vous pouvez simplement utiliser ce tableau pour le faire.

447
00:37:39,830 --> 00:37:44,500
Une autre façon de le faire est que vous pourriez copier une ligne plus bas,

448
00:37:44,500 --> 00:37:47,950
comprendre que vous avez besoin de copier ce nouveau, donc en fait déplacer le curseur,

449
00:37:47,950 --> 00:37:50,950
et qui va être en utilisant la méthode fseek.

450
00:37:50,950 --> 00:37:56,410
Vous pouvez déplacer votre curseur complètement vers l'arrière, puis répétez le processus de copie.

451
00:37:56,410 --> 00:38:03,960
>> Donc, si notre numéro de mise à l'échelle est n, alors combien de fois devrions-nous revenir en arrière

452
00:38:03,960 --> 00:38:10,500
et réécrire une droite? >> [L'élève] n - 1. >> Ouais, parfait. n - 1.

453
00:38:10,500 --> 00:38:14,390
Nous l'avons fait une fois déjà, oui, alors nous voulons répéter le processus de retour en arrière

454
00:38:14,390 --> 00:38:17,460
n - 1 nombre de fois.

455
00:38:22,730 --> 00:38:25,860
D'accord. Donc là vous avez votre fonction de redimensionnement.

456
00:38:25,860 --> 00:38:34,360
>> Maintenant, nous pouvons arriver à une partie vraiment fun, mon pset favori, qui est Recover.

457
00:38:34,360 --> 00:38:39,580
Au lieu de bitmaps, cette fois nous avons affaire à des fichiers JPEG.

458
00:38:39,580 --> 00:38:43,370
Nous sommes effectivement pas donné d'un fichier, de JPEG,

459
00:38:43,370 --> 00:38:46,600
on nous donne essentiellement un format brut carte mémoire.

460
00:38:46,600 --> 00:38:51,790
Et si celui-ci contient un peu de valeurs d'information et d'ordures au début,

461
00:38:51,790 --> 00:38:57,240
et ensuite il commence et il a un tas de fichiers JPEG.

462
00:38:57,240 --> 00:39:03,430
Toutefois, nous a remis une carte où nous avons supprimé les photos;

463
00:39:03,430 --> 00:39:08,300
pour l'essentiel, nous avons oublié d'où les photos se trouvent dans la carte.

464
00:39:08,300 --> 00:39:12,770
Alors notre tâche dans Recover est de passer par ce format de carte

465
00:39:12,770 --> 00:39:16,500
et de trouver les images à nouveau.

466
00:39:16,500 --> 00:39:23,990
>> Heureusement, la structure des fichiers JPEG et le fichier de carte est un peu utile.

467
00:39:23,990 --> 00:39:28,850
Il a certainement aurait pu être un peu plus compliqué si ce n'était pas dans ce format particulier.

468
00:39:28,850 --> 00:39:40,160
Chaque fichier JPEG commence réellement avec deux séquences possibles, listés ci-dessus.

469
00:39:40,160 --> 00:39:42,970
Fondamentalement, lorsque vous avez un nouveau fichier JPEG,

470
00:39:42,970 --> 00:39:52,720
elle commence par la séquence supporte ffd8 FFE0 ou ​​l'autre, ffd8 FFE1.

471
00:39:52,720 --> 00:39:59,530
Une autre chose utile de savoir, c'est que les fichiers JPEG sont stockées de façon contiguë.

472
00:39:59,530 --> 00:40:03,380
Donc, chaque fois qu'un fichier JPEG se termine, l'autre commence.

473
00:40:03,380 --> 00:40:07,070
Il n'y a donc pas n'importe quel type d'entre-deux valeurs de y.

474
00:40:07,070 --> 00:40:15,510
Dès que vous atteignez le début d'un JPEG, si vous avez déjà lu un JPEG,

475
00:40:15,510 --> 00:40:21,800
vous savez que vous avez atteint la fin de la précédente et le début de la suivante.

476
00:40:21,800 --> 00:40:25,890
>> Pour genre de visualiser cela, j'ai fait un schéma.

477
00:40:25,890 --> 00:40:36,910
Une autre chose à propos de JPEG est que nous pouvons les lire dans des séquences de 512 octets à la fois,

478
00:40:36,910 --> 00:40:39,380
De la même façon avec le début de la carte.

479
00:40:39,380 --> 00:40:43,370
Nous n'avons pas besoin d'être vérifié chaque octet unique parce que ce serait sucer.

480
00:40:43,370 --> 00:40:48,200
Ainsi, au lieu, ce que nous pouvons faire, c'est en fait juste lu dans 512 octets à la fois

481
00:40:48,200 --> 00:40:54,700
puis, au lieu de vérifier entre ceux dans les tranches minuscules,

482
00:40:54,700 --> 00:40:58,640
nous pouvons simplement vérifier le début des 512 octets.

483
00:40:58,640 --> 00:41:02,570
Essentiellement, dans ce tableau, ce que vous voyez est à l'origine de la carte,

484
00:41:02,570 --> 00:41:08,700
vous avez des valeurs qui ne sont pas vraiment pertinentes pour les fichiers JPEG eux-mêmes.

485
00:41:08,700 --> 00:41:15,830
Mais alors qu'est-ce que j'ai, c'est une étoile pour indiquer l'une des deux séquences à partir d'un fichier JPEG.

486
00:41:15,830 --> 00:41:19,910
Donc, chaque fois que vous voyez une étoile, vous savez que vous avez un fichier JPEG.

487
00:41:19,910 --> 00:41:25,030
Et puis chaque fichier JPEG va être un multiple de 512 octets

488
00:41:25,030 --> 00:41:27,880
mais pas nécessairement le même multiple.

489
00:41:27,880 --> 00:41:32,050
La façon dont vous savez que vous avez touché un autre format JPEG est si vous frappez une autre étoile,

490
00:41:32,050 --> 00:41:39,090
une autre séquence d'octets de départ.

491
00:41:39,090 --> 00:41:43,330
Alors qu'est-ce que vous avez ici est que vous avez le fichier JPEG rouge continue jusqu'à ce que vous appuyez sur une étoile,

492
00:41:43,330 --> 00:41:45,150
qui est indiqué par une couleur différente.

493
00:41:45,150 --> 00:41:48,510
Vous continuez et puis vous cliquez sur une autre étoile, vous touchez un autre JPEG,

494
00:41:48,510 --> 00:41:50,590
vous continuez tout le chemin jusqu'à la fin.

495
00:41:50,590 --> 00:41:53,180
Vous êtes à la dernière image ici, la rose.

496
00:41:53,180 --> 00:41:58,220
Vous allez à la fin jusqu'à ce que vous atteignez le caractère de fin de fichier.

497
00:41:58,220 --> 00:42:00,820
Cela va être vraiment utile.

498
00:42:00,820 --> 00:42:03,170
>> A emporter quelques grandes ici:

499
00:42:03,170 --> 00:42:06,670
Le fichier de la carte ne démarre pas avec un fichier JPEG,

500
00:42:06,670 --> 00:42:13,350
mais une fois commence JPEG, toutes les images JPEG sont stockés côte à côte les uns aux autres.

501
00:42:17,520 --> 00:42:20,420
>> Certains pseudo-code pour le récupérer.

502
00:42:20,420 --> 00:42:22,570
Tout d'abord, nous allons ouvrir notre fichier de carte,

503
00:42:22,570 --> 00:42:27,500
et qui va être en utilisant notre fichier d'E / S des fonctions.

504
00:42:27,500 --> 00:42:32,430
Nous allons répéter le processus ci-dessous jusqu'à ce que nous avons atteint la fin du fichier.

505
00:42:32,430 --> 00:42:36,450
Nous allons lire 512 octets à la fois.

506
00:42:36,450 --> 00:42:39,180
Et ce que j'ai dit ici, c'est que nous allons les stocker dans une mémoire tampon,

507
00:42:39,180 --> 00:42:46,230
Donc, fondamentalement, conserver ces 512 octets jusqu'à ce que nous savons exactement quoi faire avec eux.

508
00:42:46,230 --> 00:42:50,300
Alors ce que nous voulons faire, c'est que nous voulons vérifier si nous avons touché une étoile ou pas.

509
00:42:50,300 --> 00:42:57,960
Si nous avons touché une étoile, si nous avons atteint l'une des séquences de départ,

510
00:42:57,960 --> 00:42:59,980
alors nous savons que nous avons atteint un nouveau fichier JPEG.

511
00:42:59,980 --> 00:43:08,860
Ce que nous allons veux faire, c'est que nous allons vouloir créer un nouveau fichier dans notre annuaire pset4

512
00:43:08,860 --> 00:43:14,480
de continuer à faire ce fichier.

513
00:43:14,480 --> 00:43:18,220
Mais aussi, si nous avons déjà fait un JPEG avant,

514
00:43:18,220 --> 00:43:25,620
alors nous voulons mettre fin à ce fichier et poussez-le vers le dossier pset4,

515
00:43:25,620 --> 00:43:29,780
où nous aurons ce fichier stocké parce que si on ne précise pas que nous avons terminé ce fichier JPEG,

516
00:43:29,780 --> 00:43:37,290
puis nous avons essentiellement un montant indéterminé. Les fichiers JPEG ne finira jamais.

517
00:43:37,290 --> 00:43:40,840
Donc, nous voulons nous assurer que lorsque nous lisons dans un fichier JPEG et d'écriture qui,

518
00:43:40,840 --> 00:43:46,590
on veut précisément près que, pour ouvrir le suivant.

519
00:43:46,590 --> 00:43:48,430
Nous voulons vérifier plusieurs choses.

520
00:43:48,430 --> 00:43:52,880
Nous voulons vérifier si nous sommes au début d'un nouveau JPEG avec notre tampon

521
00:43:52,880 --> 00:43:56,780
et même si nous avons déjà trouvé un JPEG avant d'

522
00:43:56,780 --> 00:44:03,930
parce que cela va changer votre processus légèrement.

523
00:44:03,930 --> 00:44:07,880
Alors une fois que vous passer par tout le chemin et vous frappez la fin du fichier,

524
00:44:07,880 --> 00:44:11,570
alors qu'est-ce que vous voulez faire, c'est que vous aurez envie de fermer tous les fichiers qui sont actuellement ouverts.

525
00:44:11,570 --> 00:44:14,100
Ce sera probablement le dernier fichier JPEG que vous avez,

526
00:44:14,100 --> 00:44:18,930
ainsi que le fichier de la carte que vous avez fait affaire.

527
00:44:21,940 --> 00:44:28,670
>> Le dernier obstacle que nous devons résoudre est comment faire réellement un fichier JPEG

528
00:44:28,670 --> 00:44:31,950
et comment fait pousser dans le dossier.

529
00:44:33,650 --> 00:44:39,850
Le pset exige que tous les JPEG que vous trouverez soit dans le format suivant,

530
00:44:39,850 --> 00:44:43,990
où vous avez le numéro. jpg.

531
00:44:43,990 --> 00:44:50,750
Le nombre, même si c'est 0, on appelle cela 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Lorsque vous trouvez un fichier JPEG dans votre programme,

533
00:44:55,730 --> 00:44:58,040
vous allez avoir à le nommer dans l'ordre dans lequel il se trouve.

534
00:44:58,040 --> 00:44:59,700
Qu'est-ce que cela signifie?

535
00:44:59,700 --> 00:45:03,530
Nous devons sorte de garder la trace de combien nous en avons trouvé

536
00:45:03,530 --> 00:45:08,680
et que le nombre de chacun JPEG devrait être.

537
00:45:08,680 --> 00:45:13,800
Ici, nous allons profiter de la fonction sprintf.

538
00:45:13,800 --> 00:45:17,480
Similaire à printf, qui vient de genre d'impressions sur une valeur dans le terminal,

539
00:45:17,480 --> 00:45:23,910
sprintf imprime le fichier sur dans le dossier.

540
00:45:23,910 --> 00:45:30,870
Et qu'est-ce que cela ferait si j'avais sprintf, le titre, puis la chaîne de là,

541
00:45:30,870 --> 00:45:36,660
il imprimer 2.jpg.

542
00:45:36,660 --> 00:45:41,020
En supposant que j'ai fermé mes fichiers correctement,

543
00:45:41,020 --> 00:45:47,210
qui contient le fichier que j'avais écrit sur.

544
00:45:47,210 --> 00:45:50,320
Mais une chose est que le code que j'ai ici

545
00:45:50,320 --> 00:45:53,360
n'est pas tout à satisfaire ce qui nécessite le pset.

546
00:45:53,360 --> 00:46:02,410
Le pset nécessite que le second fichier JPEG devrait être nommé 002 au lieu de seulement 2.

547
00:46:02,410 --> 00:46:09,160
Ainsi, lorsque vous imprimez le nom, alors peut-être que vous voudrez peut-être modifier légèrement l'espace réservé.

548
00:46:09,160 --> 00:46:18,140
>> Est-ce que quelqu'un se souvient de la façon dont nous permettent espaces supplémentaires lorsque nous imprimons quelque chose?

549
00:46:18,140 --> 00:46:22,530
Ouais. >> [L'élève] Tu mets un 3 entre le signe pour cent et le 2. >> Ouais, parfait.

550
00:46:22,530 --> 00:46:25,610
Vous mettrez un 3 dans ce cas parce que nous voulons l'espace pour 3.

551
00:46:25,610 --> 00:46:32,590
3d% serait probablement vous donner 002.jpg lieu de 2.

552
00:46:32,590 --> 00:46:40,120
Le premier argument dans la fonction sprintf est en fait un tableau de caractères,

553
00:46:40,120 --> 00:46:42,520
que nous avons précédemment connu en tant que chaînes.

554
00:46:42,520 --> 00:46:50,700
Ceux volonté, un peu plus comme un stockage temporaire, simplement stocker la chaîne résultante.

555
00:46:50,700 --> 00:46:54,950
Vous ne serez pas vraiment avoir affaire à cela, mais vous avez besoin de l'inclure.

556
00:46:54,950 --> 00:47:00,710
>> Sachant que chaque nom de fichier comporte le nombre, qui occupe trois caractères,

557
00:47:00,710 --> 00:47:06,770
puis. jpg, combien de temps devrait être ce tableau?

558
00:47:09,070 --> 00:47:14,310
Jetez un certain nombre. Combien de caractères dans le titre, dans le nom?

559
00:47:18,090 --> 00:47:26,320
Donc, il ya 3 hashtags, période, jpg. >> [L'élève] 7. >> 7. Pas tout à fait.

560
00:47:26,320 --> 00:47:32,000
Nous allons vouloir 8 parce que nous voulons pour permettre la terminaison nulle aussi.

561
00:47:45,340 --> 00:47:49,730
>> Enfin, il suffit de tirer sur le processus que vous allez faire pour les récupérer,

562
00:47:49,730 --> 00:47:55,420
vous avez des informations commencement.

563
00:47:55,420 --> 00:48:02,460
Vous continuez jusqu'à ce que vous trouver le début d'un fichier JPEG,

564
00:48:02,460 --> 00:48:07,900
et qui peut être soit une des deux séquences de départ.

565
00:48:07,900 --> 00:48:12,510
Vous continuez à lire. Chaque barre représente ici 512 octets.

566
00:48:12,510 --> 00:48:22,630
Vous continuez à lire, continuez à lire jusqu'à ce que vous rencontrez une autre séquence de démarrage.

567
00:48:22,630 --> 00:48:29,790
Une fois que vous avez cela, vous mettez fin à l'actuel JPEG - dans ce cas, c'est le rouge,

568
00:48:29,790 --> 00:48:31,030
si vous souhaitez mettre fin à cela.

569
00:48:31,030 --> 00:48:35,540
Vous voulez sprintf le nom de ce dossier dans votre pset4,

570
00:48:35,540 --> 00:48:41,580
alors vous voulez ouvrir une nouvelle JPEG, puis continuez à lire

571
00:48:41,580 --> 00:48:46,370
jusqu'à ce que vous rencontrez l'autre.

572
00:48:46,370 --> 00:48:49,040
Continuez à lire, continuez votre lecture,

573
00:48:49,040 --> 00:48:56,290
et enfin, par la suite, vous allez arriver à la fin du fichier,

574
00:48:56,290 --> 00:49:00,360
et si vous voulez fermer la dernière JPEG que vous travaillez avec,

575
00:49:00,360 --> 00:49:08,380
sprintf que dans votre dossier pset4, puis regarder toutes les photos que vous avez reçu.

576
00:49:08,380 --> 00:49:12,050
Ces images sont en fait des photos de CS50 personnel,

577
00:49:12,050 --> 00:49:16,430
et c'est donc là que la partie la plus amusante de bonus du jeu de processeurs vient en

578
00:49:16,430 --> 00:49:26,310
c'est que vous êtes en compétition dans vos sections pour trouver les facteurs de transcription dans les images

579
00:49:26,310 --> 00:49:34,610
et prendre des photos avec eux de prouver que vous avez fait le pset

580
00:49:34,610 --> 00:49:37,030
et afin que vous puissiez voir quels membres du personnel sont dans les images.

581
00:49:37,030 --> 00:49:41,510
Alors vous prenez des photos avec le personnel. Parfois, vous aurez à les pourchasser.

582
00:49:41,510 --> 00:49:44,680
Probablement certains d'entre eux va essayer de s'enfuir de chez vous.

583
00:49:44,680 --> 00:49:47,320
Vous prenez des photos avec eux.

584
00:49:47,320 --> 00:49:51,190
Ceci est en cours. Ce n'est pas exigible lorsque le pset est due.

585
00:49:51,190 --> 00:49:53,340
La date limite seront annoncés dans les spécifications.

586
00:49:53,340 --> 00:49:58,060
Puis, avec votre section, la section qui prend le plus de photos

587
00:49:58,060 --> 00:50:04,430
avec les membres du personnel la plupart gagneront un prix assez impressionnant.

588
00:50:04,430 --> 00:50:08,890
C'est le genre d'incitation pour obtenir votre pset4 fini aussi vite que possible

589
00:50:08,890 --> 00:50:10,820
car alors vous pouvez passer aux choses sérieuses

590
00:50:10,820 --> 00:50:14,570
traquer tous les CS50 différents membres du personnel.

591
00:50:14,570 --> 00:50:17,500
Ce n'est pas obligatoire, mais, une fois que vous obtenez les photos,

592
00:50:17,500 --> 00:50:20,310
alors vous avez terminé avec pset4.

593
00:50:20,310 --> 00:50:23,970
>> Et j'en aurai fini avec Walkthrough 4, alors je vous remercie tous d'être venus.

594
00:50:23,970 --> 00:50:29,330
Bonne chance avec Forensics. [Applaudissements]

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