1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [チュートリアル - 問題セット4]

2
00:00:02,700 --> 00:00:05,000
[Zamylaチャン - ハーバード大学]

3
00:00:05,000 --> 00:00:07,340
[これはCS50です。 -  CS50.TV]

4
00:00:08,210 --> 00:00:11,670
かしこまりました。みなさん、こんにちは、そしてチュートリアル4に歓迎しています。

5
00:00:11,670 --> 00:00:14,270
>> 今日私達のpsetにはフォレンジックです。

6
00:00:14,270 --> 00:00:18,080
フォレンジックは、ビットマップファイルを扱うことを含む本当に楽しいPSETです

7
00:00:18,080 --> 00:00:21,550
罪を犯した人を発見してください。

8
00:00:21,550 --> 00:00:24,200
その後、我々は、いくつかのビットマップファイルのサイズを変更するつもりだ

9
00:00:24,200 --> 00:00:27,780
その後、我々はまた、回復と呼ばれる本当に楽しい部分に対処するつもりだ

10
00:00:27,780 --> 00:00:31,160
採用された場合は、基本的にはメモリカードを手渡している

11
00:00:31,160 --> 00:00:34,350
ている誰かが誤ってすべてのファイルを削除している、

12
00:00:34,350 --> 00:00:38,860
そして我々は、それらのファイルを回復するよう求められます。

13
00:00:38,860 --> 00:00:42,910
>> 我々はPSETに入る前に、しかし、最初に、私は実際にちょうど皆を祝福したい。

14
00:00:42,910 --> 00:00:45,230
我々は、このコースの中間点で約だ。

15
00:00:45,230 --> 00:00:50,070
クイズ0人が私達の後ろにいて、私たちは途中でいるので、本質的に、pset4にいる。

16
00:00:50,070 --> 00:00:55,490
あなたのpset、PSET0とPSET1に戻って見れば我々は、長い道のりを歩んできました

17
00:00:55,490 --> 00:00:57,300
ので、そのことについて自分自身を祝福

18
00:00:57,300 --> 00:01:00,760
そして我々はいくつかの本当に楽しいものに得ようとしている。

19
00:01:00,760 --> 00:01:07,070
>> だからこのpsetの私たちのツールボックスは、再度、その代わりにsudoにyum-yのアップデートを実行しているの、

20
00:01:07,070 --> 00:01:13,890
あなたは上記のアプライアンスのバージョン17.3とでなら私達はちょうどupdate50を実行することができるしている。

21
00:01:13,890 --> 00:01:17,380
だからupdate50を実行してください - それは、いくつかの小さい文字が、ずっと簡単です - 

22
00:01:17,380 --> 00:01:20,640
は、アプライアンスの最新バージョンにいることを確認します。

23
00:01:20,640 --> 00:01:25,410
我々はCS50チェックを使用して起動したときに特にそれがupdate50に重要です。

24
00:01:25,410 --> 00:01:28,700
だから、あなたがそれを行うことを確認してください。

25
00:01:28,700 --> 00:01:30,760
>> このpsetのセクションのすべてのために、

26
00:01:30,760 --> 00:01:34,350
我々はファイルの入力と出力を扱うことになるだろう、ファイルI / O

27
00:01:34,350 --> 00:01:38,140
我々は、配列を処理するプログラムの多くは上に行くことになるだろう

28
00:01:38,140 --> 00:01:40,350
ファイルとそのようなことを指して、

29
00:01:40,350 --> 00:01:43,050
ので、我々は本当に身近で慣れていることを確認したい

30
00:01:43,050 --> 00:01:47,990
ファイルがどのように入力と出力に扱う。

31
00:01:47,990 --> 00:01:52,080
>> このpsetの配布コードで、それなのにと呼ばれるファイルです

32
00:01:52,080 --> 00:01:55,280
そしてそれは私たちにとって本当に便利にするために何が起こっているか私たちは見つけるつもりだ

33
00:01:55,280 --> 00:02:00,340
我々は終わろうとしているので、実際それなのにファイルをコピー

34
00:02:00,340 --> 00:02:05,350
とわずかに問題セットの最初の2つの部分を達成することができるようにそれを変更すること。

35
00:02:05,350 --> 00:02:09,030
>> それで、私は前に述べたように、我々はビットマップだけでなく、JPEGファイルを扱っている。

36
00:02:09,030 --> 00:02:13,170
だから本当に、それらのファイルがどのように編成されるかの構造を理解する

37
00:02:13,170 --> 00:02:16,170
私たちは本当に構造体に0と1を翻訳することができますどのように

38
00:02:16,170 --> 00:02:19,040
我々は実際に理解し、解釈し、編集できるもの、

39
00:02:19,040 --> 00:02:21,000
それは、本当に重要になるだろう

40
00:02:21,000 --> 00:02:25,970
そうJPEGやビットマップファイルに入るとそれらの構造を理解する。

41
00:02:25,970 --> 00:02:30,780
>> Pset4は、いつものように、質問のセクションから始まります。

42
00:02:30,780 --> 00:02:36,600
それらは、ファイルI / Oに対応し、あなたがそれに慣れるでしょう。

43
00:02:36,600 --> 00:02:42,520
その後、第1回では、ビットマップファイルを指定されていますが、それは、推理小説である

44
00:02:42,520 --> 00:02:45,630
それはすべての上に赤い点のような種類のものに見えます。

45
00:02:45,630 --> 00:02:52,180
そして、基本的に我々がやろうとしているこのファイルを取得しており、わずかにそれを編集

46
00:02:52,180 --> 00:02:54,010
我々が読むことができるバージョンに変換します。

47
00:02:54,010 --> 00:02:56,000
本質的には、一度我々は、我々が同じファイルがあるでしょう、終わる

48
00:02:56,000 --> 00:03:02,630
を除いて、我々はすべてのそれらの赤いドットで隠さ隠されたメッセージを見ることができるでしょう。

49
00:03:02,630 --> 00:03:07,310
その後、リサイズしてファイルを指定して、プログラムである

50
00:03:07,310 --> 00:03:11,490
そして、それは、出力したファイルの名前が与えられた後、同様に番号が与えられ

51
00:03:11,490 --> 00:03:16,850
実際にはその整数値でそのビットマップのサイズを変更します。

52
00:03:16,850 --> 00:03:19,240
それから最後に、我々は回復のpsetを持っています。

53
00:03:19,240 --> 00:03:24,160
我々は、メモリカードが与えられた後、すべての写真を回復するために有している

54
00:03:24,160 --> 00:03:25,920
誤って削除されたこと、

55
00:03:25,920 --> 00:03:31,420
しかし、我々が学ぶように、実際に削除され、ファイルから削除されません;

56
00:03:31,420 --> 00:03:38,470
彼らがファイルにあった場所の私達だけの種類は、失われたが、我々はそれを回復しようとしている。

57
00:03:38,470 --> 00:03:44,950
>> グレート。だから私は、O /ファイルに入って具体的には、これらは、使用するようになると機能の全リストです。

58
00:03:44,950 --> 00:03:49,840
あなたは既に少しの関数fopen、freadは、とfwriteの基本を見てきましたが、

59
00:03:49,840 --> 00:03:54,350
しかし、我々はそのようなは、fputcなどのI / O機能がいくつかのファイルにさらに見ていくつもりです、

60
00:03:54,350 --> 00:03:56,930
ているあなただけ、一度に1つの文字を書き込む

61
00:03:56,930 --> 00:04:02,000
あなた種類前後にファイル位置指示子を動かすのに、fseek、へ

62
00:04:02,000 --> 00:04:05,770
その後いくつかの他。しかし、我々は、pset間に少し後でその中に行くつもりです。

63
00:04:08,050 --> 00:04:13,100
>> そこでまず、私たちはpsetに入る直前に、ファイルI / Oに接続する為に、

64
00:04:13,100 --> 00:04:19,860
ファイルを開くには、例えば、どのようなあなたがしなければならないと、実際にそのファイルへのポインタを設定されています。

65
00:04:19,860 --> 00:04:22,710
だから我々は、FILE *ポインタを持っています。

66
00:04:22,710 --> 00:04:27,140
それは私のINFILEになるだろうので、この場合、私はそれをポインタで呼んでいる。

67
00:04:27,140 --> 00:04:33,340
そして、私は関数fopenして、ファイルの名前を使用するつもりだ

68
00:04:33,340 --> 00:04:36,360
その後、私はファイルを扱うことするつもりだするモード。

69
00:04:36,360 --> 00:04:42,080
だから読んで、このケースでは "r"、書き込みのためには "w"と入力し、追加するために "A"があります。

70
00:04:42,080 --> 00:04:44,270
例えば、あなたがINFILEを扱っているときに

71
00:04:44,270 --> 00:04:47,310
そしてあなたがしたいすべてが、そこに格納されているビットとバイトを読んで

72
00:04:47,310 --> 00:04:50,420
あなたはおそらくあなたのモードとして "r"を使用するつもりだ。

73
00:04:50,420 --> 00:04:54,520
あなたは実際に、新しいファイルを作るの種類を記述したい場合には、

74
00:04:54,520 --> 00:04:57,220
その後、私たちがやろうとしている、我々は新しいファイルを開くつもりです

75
00:04:57,220 --> 00:05:02,410
と書き込みのために "w"モードを使用します。

76
00:05:02,410 --> 00:05:07,540
>> それでは、あなたが実際にファイルに読んでいるときに、構造は次のとおりです。

77
00:05:07,540 --> 00:05:14,930
最初にあなたが読んでいるというバイトが含まれています構造体へのポインタが含まれています。

78
00:05:14,930 --> 00:05:19,830
だから、それはあなたが読んでいることをバイトの最後の場所になるだろう。

79
00:05:19,830 --> 00:05:23,360
その後、どのように多くのバイトは基本的に好きで、サイズを示すようになるだろう

80
00:05:23,360 --> 00:05:30,100
あなたのプログラムがファイルにで読み取る必要があり、サイズは基本的に1種の元素であり、

81
00:05:30,100 --> 00:05:32,620
その後、あなたが読みたいと思うどのように多くの要素を指定するつもりです。

82
00:05:32,620 --> 00:05:34,980
そして最後に、あなたは、あなたが読んでいるからどこに知っている必要があります

83
00:05:34,980 --> 00:05:37,580
だからそれはあなたの中のポインタになるだろう。

84
00:05:37,580 --> 00:05:41,780
freadがまた書き出し動作に非常によく似ていますので、私は、これらを色分けされ

85
00:05:41,780 --> 00:05:47,050
あなたは、正しい順序を使用していることを確認したい場合を除き、

86
00:05:47,050 --> 00:05:51,960
あなたが実際にデータを書き込んだり、ファイルを右から読んでいることを確認してください。

87
00:05:54,910 --> 00:05:58,610
>> それでは、前と同じように、我々は、素子の大きさだけでなく、要素の数を持っている場合、

88
00:05:58,610 --> 00:06:00,600
次に我々はここで少し周りを再生することができます。

89
00:06:00,600 --> 00:06:06,810
私は犬の構造を持っているので、私は一度に2匹の犬を読んでもらいたいと言う。

90
00:06:06,810 --> 00:06:12,450
私は何を行う可能性は、1つの要素の大きさが1犬の大きさになるだろうと言っている

91
00:06:12,450 --> 00:06:14,770
と私は実際にそれらの2つを読んでするつもりです。

92
00:06:14,770 --> 00:06:18,290
代わりに、私は何ができると、私はちょうど1つの要素を読み取るつもり言うさ

93
00:06:18,290 --> 00:06:21,340
と1つの要素は、2つの犬の大きさになるということ。

94
00:06:21,340 --> 00:06:24,320
ですから、大きさと数で種の周りを再生することができますどのように類似していることをだ

95
00:06:24,320 --> 00:06:28,250
あなたにとってより直感的だものに応じて。

96
00:06:28,250 --> 00:06:30,810
>> かしこまりました。だから今我々は、書き込みファイルを取得。

97
00:06:30,810 --> 00:06:36,880
どこから読んでいるあなたはどこでファイルを書き込みたい場合は、最初の引数は実際にある。

98
00:06:36,880 --> 00:06:42,050
だから基本的には、ファイルへの書き込みしようとしているデータですが、

99
00:06:42,050 --> 00:06:44,490
それは終わりに外にポインタです。

100
00:06:44,490 --> 00:06:47,670
ですから、PSETを扱っているときに、あなたが混乱しないようにしてください。

101
00:06:47,670 --> 00:06:50,480
多分側で定義側を持っています。

102
00:06:50,480 --> 00:06:58,090
あなたは、例えば、人間のように入力して手動で定義をプルアップしてから、書き出し動作することができます

103
00:06:58,090 --> 00:06:59,950
端末内か、このスライドに戻って参照することができます

104
00:06:59,950 --> 00:07:03,570
そしてあなたが右のいずれかを使用していることを確認してください。

105
00:07:03,570 --> 00:07:08,700
だからもう一度、あなたがに書き込むしたいファイルを持ってfwriteの、のために、

106
00:07:08,700 --> 00:07:14,290
それは、最後の引数になるだろう、それは、そのファイルへのポインタになるだろう。

107
00:07:14,290 --> 00:07:18,670
それでは、それは、我々はいつでも、おそらくいくつかのバイトを書いてどのように対処するかだ

108
00:07:18,670 --> 00:07:21,820
あなただけのただ一つの文字で書きたいと言う。

109
00:07:21,820 --> 00:07:25,940
我々は、この例の後半で説明するように、ビットマップで我々はそれを使用する必要があります。

110
00:07:25,940 --> 00:07:32,180
我々はfputcは使用することができたときにそれはだが、本質的にはCHRは、一度に1つの文字を入れて

111
00:07:32,180 --> 00:07:37,050
ファイル·ポインタに、それはそこに私たちの外にポインタです。

112
00:07:38,700 --> 00:07:41,560
それでは、私たちが求める、またはファイルに書き込むたびに、

113
00:07:41,560 --> 00:07:44,690
ファイルには、我々がどこにあるかを追跡しています。

114
00:07:44,690 --> 00:07:47,810
だから、カーソル、ファイル位置指示子のようなものだ。

115
00:07:47,810 --> 00:07:54,330
そして、私たちは書き込むたびに、またはファイルに再び読み込む

116
00:07:54,330 --> 00:07:56,760
それがどこにあるファイルは、実際には、記憶しています

117
00:07:56,760 --> 00:07:59,270
ので、それは、カーソルがどこにあるから続行されます。

118
00:07:59,270 --> 00:08:03,970
あなたがしたいときに何かをするために、特定の量で読む、と言う、有益なことができます

119
00:08:03,970 --> 00:08:06,160
その後、以下の量で読む

120
00:08:06,160 --> 00:08:10,700
しかし、時には我々は戻ったり、実際に一定の基準値から始めると良いでしょう。

121
00:08:10,700 --> 00:08:16,870
それでは、fseek関数は、何をするかは、私たちは、特定のファイルにカーソルを移動することができますされている

122
00:08:16,870 --> 00:08:19,680
特定のバイト数。

123
00:08:19,680 --> 00:08:24,260
そして、私たちがしなければならないと、基準値がどこにあるか指定するだけです。

124
00:08:24,260 --> 00:08:31,520
だからどちらか、カーソルが現在位置から前方または後方に移動し、

125
00:08:31,520 --> 00:08:35,750
あるいは、我々はそれだけで、ファイルの先頭からで移動するように指定することができます

126
00:08:35,750 --> 00:08:37,090
またはファイルの終わりから。

127
00:08:37,090 --> 00:08:41,230
そしてあなたは、量に負または正の値を渡すことができます

128
00:08:41,230 --> 00:08:44,960
それは一種の前方または後方のいずれかにカーソルを移動します。

129
00:08:46,170 --> 00:08:51,920
>> 我々は他のpsetに入る前に、ファイル上の任意の質問のI / O？

130
00:08:53,860 --> 00:08:59,990
オーケー。我々はより多くの例に入るように、質問のための私を停止して自由に感じる。

131
00:08:59,990 --> 00:09:06,930
>> だから推理小説で、あなたはスライド上のこの赤いほうに似たビットマップファイルを手渡ししている、

132
00:09:06,930 --> 00:09:14,510
そして、それはこのようになります - 赤いドットの束 - そしてあなたが本当に書かれているのか分からない。

133
00:09:14,510 --> 00:09:23,310
あなたが目を細めている場合は、真ん中の内側若干青みがかった色を見ることができるかもしれません。

134
00:09:23,310 --> 00:09:26,270
テキストが格納されている本質的に、それはです。

135
00:09:26,270 --> 00:09:30,270
そこに起こった殺人事件があって、我々はそれをやった人を見つける必要があります。

136
00:09:30,270 --> 00:09:36,760
そのために、我々は、読み取り可能な形式に画像を変換の種類があります。

137
00:09:36,760 --> 00:09:42,740
君たちは今までにこの発生した場合は、時には少しキットがあるだろう

138
00:09:42,740 --> 00:09:48,510
どこに赤い膜と虫眼鏡を持っているでしょう。誰ですか？うん。

139
00:09:48,510 --> 00:09:52,770
だから、あなたはこのような何かを手渡されると、虫眼鏡を持っているでしょう

140
00:09:52,770 --> 00:09:58,130
上に赤いフィルムを使用すれば、画像の上にそれを置くと、

141
00:09:58,130 --> 00:10:03,410
と、メッセージがその中に隠されて見ることができるでしょう。

142
00:10:03,410 --> 00:10:07,080
我々は、赤いフィルムと虫眼鏡を持っていないので、代わりに、私たちは一種の私達の自身のを作成しようとしている

143
00:10:07,080 --> 00:10:09,060
このPSETインチ

144
00:10:09,060 --> 00:10:15,760
そのため、ユーザーは、入力フーダニット、手がかりになるだろう。bmpファイルは、

145
00:10:15,760 --> 00:10:18,800
レッド·ドット·メッセージだinfileに、、ですので、

146
00:10:18,800 --> 00:10:23,550
その後、彼らは私たちのverdict.bmp outfileになるだろうと言っている。

147
00:10:23,550 --> 00:10:27,900
だから、手がかりのような新しいビットマップイメージを作成するために起こっている

148
00:10:27,900 --> 00:10:32,600
私たちは隠されたメッセージを見ることができます読み取り可能な形式で除く。

149
00:10:32,600 --> 00:10:37,550
>> 我々はいくつかの種のビットマップを編集および操作に対処しようとしているので、

150
00:10:37,550 --> 00:10:42,400
私たちは、これらのビットマップファイルの構造へのダイブの種類に行くんだ。

151
00:10:42,400 --> 00:10:48,130
私たちは、講義の中で、これらの少し上に行きましたが、いくつかのより多くのそれらに見ていきましょう。

152
00:10:48,130 --> 00:10:51,740
ビットマップは、本質的に単なるバイトの配列アール

153
00:10:51,740 --> 00:10:55,790
ここで我々は、バイトが何を意味している指定した。

154
00:10:55,790 --> 00:11:00,540
そこでここでは、ビットマップ画像の地図のような種類のものである

155
00:11:00,540 --> 00:11:08,550
それはいくつかのヘッダファイルから始まると言って、そこにいくつかの情報から始まります。

156
00:11:08,550 --> 00:11:16,540
あなたは、約バイト14番でサイズがビットマップ画像で示されていることがわかり

157
00:11:16,540 --> 00:11:18,520
そして、それは続行します。

158
00:11:18,520 --> 00:11:23,810
しかし、その後、私たちは本当にここに興味を持っているのはバイト数54の周り始めています。

159
00:11:23,810 --> 00:11:26,060
我々は、これらのRGBの3を持っています。

160
00:11:26,060 --> 00:11:30,760
何をするだろうと、実際のピクセルの色の値が含まれています。

161
00:11:30,760 --> 00:11:35,950
ヘッダーにいくつかの情報である上記のすべて

162
00:11:35,950 --> 00:11:41,240
画像のサイズ、画像の幅と高さに対応する。

163
00:11:41,240 --> 00:11:44,930
我々は、後で詰め物に入ると、我々が表示されますなぜ画像のサイズ

164
00:11:44,930 --> 00:11:48,670
幅または高さと異なる場合があります。

165
00:11:48,670 --> 00:11:54,240
それでは、これらを表現する - これらのビットマップ画像をバイトのシーケンスである - 

166
00:11:54,240 --> 00:11:59,370
大丈夫と言っている私たちは何ができるか、私は覚えているつもりです、そのインデックス14で、

167
00:11:59,370 --> 00:12:03,380
それは我々がこの作業を簡単にするためにやろうとしている代わりにサイズは、例えば、ある場所だが、

168
00:12:03,380 --> 00:12:06,020
構造体でそれをカプセル化しています。

169
00:12:06,020 --> 00:12:08,880
そして私たちは私たちのために作られた2つの構造体、BITMAPFILEHEADERを持っている

170
00:12:08,880 --> 00:12:10,440
とBITMAPINFOHEADER、

171
00:12:10,440 --> 00:12:14,840
そして私たちは、そのファイルへのリードはいつでも、デフォルトでは、順番に行くことになるだろう

172
00:12:14,840 --> 00:12:22,360
そしてそうするために、それはまた、そのようなbiWidthとbiSizeとして変数に埋めるために起こっている。

173
00:12:25,270 --> 00:12:31,230
そして最後に、すべてのピクセルが3バイトで表現されます。

174
00:12:31,230 --> 00:12:35,500
最初のものは、ピクセルの青の量であり、二つ目は、緑の量です

175
00:12:35,500 --> 00:12:41,120
そして最後に、0は本質的に青や緑のないされていない赤の量や赤なし

176
00:12:41,120 --> 00:12:43,720
その後ffは最大値です。

177
00:12:43,720 --> 00:12:46,800
これらは16進値です。

178
00:12:46,800 --> 00:12:53,870
それでは我々はFF0000を有していた場合、そのは青の最大量に対応

179
00:12:53,870 --> 00:12:58,890
その後緑と赤なしなので、その私たちに青の画素を与えないであろう全く。

180
00:12:58,890 --> 00:13:04,190
我々は軒並みFFのすべてを持っているならば、それは我々が白画素を持っていることを意味します。

181
00:13:04,190 --> 00:13:11,370
我々はRGBを言うとき、これは、典型的には反対のようなものです。これは、実際のBGRが起こっている。

182
00:13:12,750 --> 00:13:18,990
>> 我々は実際にビットマップ画像の一例に見ればそう - 私はここに1をプルアップしてみましょう。

183
00:13:31,560 --> 00:13:33,830
それは少し小さいです。

184
00:13:39,890 --> 00:13:47,840
私は、ズームしている、と我々はそれがピクセル化されたのがわかります。それは色のブロックのように見えます。

185
00:13:47,840 --> 00:13:50,110
その後、白いブロックと赤ブロックがあります。

186
00:13:50,110 --> 00:13:53,700
あなたはMicrosoftペイントで再生した場合、例えば、あなたは、そのような何かを作ることができる

187
00:13:53,700 --> 00:13:58,960
基本的には、特定の順序で特定の正方形を描くことによって。

188
00:13:58,960 --> 00:14:08,060
だから、これはビットマップに変換するものを、次のとおりです。

189
00:14:08,060 --> 00:14:15,710
、ここでは、すべての6のfであることを、最初に白のピクセルを持って、私たちは赤のピクセルを持っている

190
00:14:15,710 --> 00:14:19,910
0000FFで示される。

191
00:14:19,910 --> 00:14:27,940
それで、我々が持っているバイトのシーケンスは、ビットマップ画像を見に行くされている方法を示しています。

192
00:14:27,940 --> 00:14:32,230
それでは、私はここに行ったのはちょうどすべてのそれらのバイトを書き出され、赤で着色された後、

193
00:14:32,230 --> 00:14:37,550
あなたは親切なの見ることができるように、その種類は、スマイリーフェイスを示し、どのように目を細めて少し、もし。

194
00:14:40,180 --> 00:14:46,390
>> ビットマップイメージの仕事が私であることの方法は、グリッドとして、基本的にそれを思い描きます。

195
00:14:46,390 --> 00:14:54,940
それでデフォルトでは、グリッドのすべての行は、4バイトの倍数でなければなりません。

196
00:15:00,520 --> 00:15:07,060
我々はビットマップ画像を見れば、あなたは、すべての値を埋めている。

197
00:15:07,060 --> 00:15:17,370
例えば、あなたが、ここ、ここ、ここに青、緑、赤があるかもしれません

198
00:15:17,370 --> 00:15:24,950
しかし、あなたはイメージが4バイトの倍数で埋められていることを確認する必要があります。

199
00:15:24,950 --> 00:15:32,200
私は私のイメージは3ブロックワイドになりたいもしそうなら、私は空の値を入れなければならないでしょう

200
00:15:32,200 --> 00:15:35,640
それは4の倍数にするための最後の1インチ

201
00:15:35,640 --> 00:15:39,530
それでは、私たちはパディングを呼んでいる何かに追加することになります。

202
00:15:39,530 --> 00:15:43,750
私はそこに、xで示すつもりです。

203
00:15:44,920 --> 00:15:54,160
今、私たちは、例えば、7ピクセルの長さで画像が欲しいと言う。

204
00:15:54,160 --> 00:15:59,550
私たちは、1、2、3、4、5、6、7を持っている

205
00:16:04,750 --> 00:16:07,000
そしてそのすべてが色で塗りつぶされます。

206
00:16:07,000 --> 00:16:10,620
ビットマップイメージが動作している方法は、我々は第八が必要だということです。

207
00:16:10,620 --> 00:16:12,460
今、私たちは1、2、3、4、5、6、7を持っています。

208
00:16:12,460 --> 00:16:19,360
我々は正しく読み取るためにビットマップイメージの8つのスペースを必要としています。

209
00:16:19,360 --> 00:16:25,600
それでは我々は何をすべきかパディングのほんの少しで追加され

210
00:16:25,600 --> 00:16:29,430
すべての文字幅が均一であることを確認し

211
00:16:29,430 --> 00:16:34,260
とすべての文字幅が4の倍数であること。

212
00:16:42,110 --> 00:16:47,310
そして、私は以前に、xまたは波線としてパディング示さ

213
00:16:47,310 --> 00:16:53,880
しかし、実際のビットマップ画像にパディングは、16進数0で示されます。

214
00:16:53,880 --> 00:16:57,340
だからそれは、単一の文字、0になります。

215
00:16:58,980 --> 00:17:06,329
何が便利になるかもしれないとXXDコマンドです。

216
00:17:06,329 --> 00:17:11,220
それは何を行うのは実際に私がスマイリーと前に何をしたかのようになっている、あなたを示している

217
00:17:11,220 --> 00:17:15,630
私は実際にそれぞれの色が画素ごとにどのようになるか、プリントアウトするとき

218
00:17:15,630 --> 00:17:21,800
その後、あなたは、次のコマンドを使用してXXD実行すると、それを色分けされ

219
00:17:21,800 --> 00:17:28,670
それは実際の色はそれらのピクセルのために何であるかが出力されます。

220
00:17:28,670 --> 00:17:33,810
あなたは何をしなければならないと私は、-s 54のように、ここに示すの上にある

221
00:17:33,810 --> 00:17:36,530
私は第五十四バイトから開始するつもりだと言っている

222
00:17:36,530 --> 00:17:40,820
、その前に、我々はビットマップの地図に戻って見れば覚えているので、

223
00:17:40,820 --> 00:17:42,690
すべてのヘッダー情報とそのようなことは、そのだ。

224
00:17:42,690 --> 00:17:46,280
しかし、私たちが本当に気にして色を示す実際のピクセルです。

225
00:17:46,280 --> 00:17:52,700
だから、-S 54そのフラグを追加することによって、我々は、色の値を参照することができるしている。

226
00:17:52,700 --> 00:17:56,020
そして、そのような複雑なフラグや物事を心配しないでください。

227
00:17:56,020 --> 00:18:05,020
問題セットの仕様では、ピクセルを表示するXXD使用方法についての指示があるでしょう。

228
00:18:07,070 --> 00:18:15,590
ここで見たのであれば、それは一種の緑色のボックスに、この小さなことのように見えます。

229
00:18:15,590 --> 00:18:23,610
私は基本的には青、緑が多く、赤なしを言っていないよう00FF00を色分けされてきました。

230
00:18:23,610 --> 00:18:26,370
だからグリーンに対応しています。

231
00:18:26,370 --> 00:18:31,920
ここで見たように、我々は緑色の四角形を参照してください。

232
00:18:31,920 --> 00:18:36,660
この緑色の四角形は、私たちがしなければならないどのようなので、その後、わずか3ピクセル幅

233
00:18:36,660 --> 00:18:44,350
画像は4幅の倍数であることを確認するために、余分なパディングに追加するだけです。

234
00:18:44,350 --> 00:18:49,460
それで、あなたはここで、これらの0をどのように見ているかだ。

235
00:18:49,460 --> 00:18:54,510
これは実際に、あなたのリサイズpsetの結果になるでしょう

236
00:18:54,510 --> 00:19:01,350
基本的に小さなビットマップを服用した後、4でそれを拡大する。

237
00:19:01,350 --> 00:19:09,380
それで、私たちが見るものは、実際にはこの画像は12ピクセルの幅であるということですが、12は4の倍数である

238
00:19:09,380 --> 00:19:12,940
我々が何かを追加する必要はありませんので、それで我々は実際に末尾に0が表示されない

239
00:19:12,940 --> 00:19:19,070
それは完全に埋められているからだ。これは、任意のより多くの部屋を持っていません。

240
00:19:20,720 --> 00:19:23,470
>> オーケー。パディングについてのご質問？

241
00:19:25,150 --> 00:19:27,460
オーケー。クール。

242
00:19:27,460 --> 00:19:32,520
>> 私は前に述べたように、ビットマップは単にバイトシーケンスです。

243
00:19:32,520 --> 00:19:39,170
それで、私たちが持っていると、バイトの数を正確に追跡する必要があるのではなく、ある

244
00:19:39,170 --> 00:19:47,050
特定の要素に対応し、我々は実際にそれを表現する構造体を作成しました。

245
00:19:47,050 --> 00:19:50,930
だから、我々が持っているものRGBTRIPLE structです。

246
00:19:50,930 --> 00:19:54,590
あなたは、RGBトリプルのインスタンスを持っているときはいつでも、

247
00:19:54,590 --> 00:20:00,970
これは型定義構造体であるため、その後、rgbtBlue変数にアクセスすることができ、

248
00:20:00,970 --> 00:20:09,520
と表示され、同様に緑と赤の変数は、どのくらいの青、緑、赤、

249
00:20:09,520 --> 00:20:11,580
それぞれ、あなたは持っている。

250
00:20:11,580 --> 00:20:16,800
>> だから我々は0〜青に設定された変数、ffの緑のセットを持っていたら、

251
00:20:16,800 --> 00:20:22,060
、それはあなたが持つことができる最大値であり、続いて赤の変数が0に設定さ

252
00:20:22,060 --> 00:20:27,870
次に何色がこの特定のRGBトリプル表すでしょう？ >> [生徒]グリーン。

253
00:20:27,870 --> 00:20:29,150
グリーン。その通りです。

254
00:20:29,150 --> 00:20:34,480
それはあなたがRGBトリプルのインスタンスがあるときに知っておくと便利になるだろう、

255
00:20:34,480 --> 00:20:41,340
青、緑、赤 -   - 別々に、実際には色の量をアクセスすることができます。

256
00:20:43,350 --> 00:20:54,900
>> 今、私たちは、その構造について説明しましたので、次にBMPファイルを見てみましょう。

257
00:20:54,900 --> 00:20:57,870
これらはあなたのために作られた構造体です。

258
00:20:57,870 --> 00:21:01,820
ここでは、BITMAPFILEHEADER構造体を持っています。

259
00:21:01,820 --> 00:21:07,610
関心の大きさです。

260
00:21:07,610 --> 00:21:12,660
その後、我々は我々にとって興味深いものですいくつかのより多くのものを持っている情報のヘッダーを、持っている

261
00:21:12,660 --> 00:21:15,480
すなわちサイズ、幅、高さ。

262
00:21:15,480 --> 00:21:19,170
後ほどに行こうとして、ファイルにして読むとき、

263
00:21:19,170 --> 00:21:25,500
それは自動的に私達が同じになるように順番を設定しているので、システムに読み込まれます。

264
00:21:25,500 --> 00:21:31,990
だからbiSizeは画像の実際のサイズに対応する右のバイトが含まれます。

265
00:21:34,700 --> 00:21:40,500
そして、ここで、最後に、我々が話してきたように、我々はRGBTRIPLEます。typedef structを持っています。

266
00:21:40,500 --> 00:21:46,840
我々は、それに関連付けられているrgbtBlue、緑、および赤を持っています。

267
00:21:48,210 --> 00:21:49,340
>> グレート。オーケー。

268
00:21:49,340 --> 00:21:56,360
今、私たちは、ビットマップを少し理解することが、我々はファイルヘッダを持っていることを理解する

269
00:21:56,360 --> 00:22:00,790
とそれに関連付けられている情報のヘッダーと、その後、我々は面白いものを持っている

270
00:22:00,790 --> 00:22:05,110
色で、それらの色は、RGBTRIPLE構造体で表現され

271
00:22:05,110 --> 00:22:12,710
そしてそれらは、順番に、緑、青、赤に関連する3つの値を持っています。

272
00:22:12,710 --> 00:22:17,270
>> だから今、私たちは約ビットを回復すると思う一種のことができます。

273
00:22:17,270 --> 00:22:20,130
申し訳ありません。推理小説について考えてみよう。

274
00:22:20,130 --> 00:22:25,750
私達が私達の手掛かりファイルを持っているとき、我々が何をしたいピクセルによってそれピクセルに読み取られる

275
00:22:25,750 --> 00:22:33,860
我々が読める形式にして出力できるようにしてから、何とかしてそれらのピクセルを変更してください。

276
00:22:33,860 --> 00:22:41,020
そしてそれを出力するために、我々はverdict.bmpファイルに画素毎に記述するつもりです。

277
00:22:41,020 --> 00:22:45,120
それはやるべきことがたくさんのようなものだ。我々はそれを実現しています。

278
00:22:45,120 --> 00:22:49,860
だから我々は何をやったかを私たちは実際にcopy.c.をご提供してきましたさ

279
00:22:49,860 --> 00:22:57,610
それなのに何が行うことはただ与えられたビットマップファイルの正確なコピーを作成し、それを出力しています。

280
00:22:57,610 --> 00:23:01,900
だから、これはすでに、あなたのためにファイルをオープンし、画素毎に読み込み

281
00:23:01,900 --> 00:23:04,510
その後出力ファイルにそれを書き込みます。

282
00:23:04,510 --> 00:23:07,080
>> のは、その見てみましょう。

283
00:23:13,390 --> 00:23:18,290
これは、適切な使用を確保することです

284
00:23:18,290 --> 00:23:22,640
ここでファイル名を取得する。

285
00:23:22,640 --> 00:23:29,940
これは何を行うのは、それは我々がここでinfileに合格したものでは、入力ファイルを設定している

286
00:23:29,940 --> 00:23:34,750
それは私たちの2番目のコマンドライン引数です。

287
00:23:34,750 --> 00:23:37,640
我々は、ファイルを開くことができるかどうかをチェックします。

288
00:23:38,960 --> 00:23:44,860
我々がここの新しいファイルを作ることができるかどうかをチェックします。

289
00:23:45,630 --> 00:23:53,270
その後、これはここに何をするかは、それだけで基本的に最初からビットマップファイルで読み始めます。

290
00:23:53,270 --> 00:23:56,700
初めは、私たちが知っているように、BITMAPFILEHEADERが含まれています

291
00:23:56,700 --> 00:24:03,200
などのビットのこれらの配列は、直接BITMAPFILEHEADERに入力されます。

292
00:24:03,200 --> 00:24:07,940
だから我々はここに持っているものをそのBITMAPFILEHEADER bfと言っている - 

293
00:24:07,940 --> 00:24:13,150
ことは、タイプBITMAPFILEHEADERの私達の新しい変数だ - 

294
00:24:13,150 --> 00:24:22,560
我々は我々のINFILEであるポインタでから読んだものBFの中に配置しようとしている。

295
00:24:22,560 --> 00:24:23,970
我々はどのくらい読みますか？

296
00:24:23,970 --> 00:24:32,160
我々は全体BITMAPFILEHEADERが含まれている必要がどのように多くのバイトを読み込みます。

297
00:24:32,160 --> 00:24:34,660
同様に、それは我々が情報ヘッダーのための仕事だ。

298
00:24:34,660 --> 00:24:39,010
だから我々は、我々のファイルinfileに沿って継続している

299
00:24:39,010 --> 00:24:44,360
そして我々はそれらのビットとバイトを読んでいて、私たちは、直接それらを差し込むしている

300
00:24:44,360 --> 00:24:47,880
私たちが作っている変数のこれらのインスタンスに変換します。

301
00:24:49,370 --> 00:24:53,800
ここでは、単にビットマップはビットマップであることを確認して作っている。

302
00:24:57,670 --> 00:25:01,030
>> 今、私たちは右、outfileを持っている？

303
00:25:01,030 --> 00:25:04,420
それは我々がそれを作成したときに立っているように、それは本質的に空です。

304
00:25:04,420 --> 00:25:07,710
だから我々は基本的にゼロから新しいビットマップを作成する必要があります。

305
00:25:07,710 --> 00:25:12,280
我々がやっていることは、我々はファイルのヘッダにコピーすることを確認する必要がある

306
00:25:12,280 --> 00:25:16,850
そしてちょうどINFILEのような情報ヘッダがあります。

307
00:25:16,850 --> 00:25:22,850
とbfは変数であることを覚えている - 私たちがやっていることは我々が書いてある

308
00:25:22,850 --> 00:25:29,300
タイプBITMAPFILEHEADERのため、我々は何をすべきか、私たちはちょうどそのコンテンツを使用することです

309
00:25:29,300 --> 00:25:34,980
INTO OUTFILEを書き込むことができます。

310
00:25:36,550 --> 00:25:38,510
ここでは、パディングの話を覚えて、

311
00:25:38,510 --> 00:25:47,820
それは我々が持っているピクセルの量が4の倍数であることを確認することが重要だ方法。

312
00:25:47,820 --> 00:25:52,790
これはあなたが持っているどのくらいのパディング計算するのは非常に有用な式である

313
00:25:52,790 --> 00:25:57,670
あなたのファイルの幅を与えられた。

314
00:25:57,670 --> 00:26:04,120
私は君たちがそれなのに、私たちがパディングを計算するための式を持っていることを覚えておきたい。

315
00:26:04,120 --> 00:26:07,970
大丈夫ですか？だから誰もがあることを覚えています。グレート。

316
00:26:07,970 --> 00:26:14,050
それではそれなのに、次回何をするか、それが走査線のすべてを繰り返し処理しています。

317
00:26:14,050 --> 00:26:23,730
それは、最初の行を通過し、その後、読み取ったすべてのトリプルを格納

318
00:26:23,730 --> 00:26:26,920
その後OUTFILEに書き込みます。

319
00:26:26,920 --> 00:26:33,120
それでは、ここで我々は一度に1つのRGBトリプルを読んでいる

320
00:26:33,120 --> 00:26:39,860
その後INTO OUTFILEを同じトリプルを置く。

321
00:26:41,120 --> 00:26:48,340
トリッキーな部分は、パディングはRGBトリプルではないということです

322
00:26:48,340 --> 00:26:55,200
それで我々は単にRGBの3つ組がそのパディング量を読み取ることができません。

323
00:26:55,200 --> 00:27:01,460
私たちがしなければならないことはただ、私たちのカーソルを移動させ、私たちのファイル位置指示子を動かす実際

324
00:27:01,460 --> 00:27:06,840
我々は次の行にいるように、すべてのパディングを飛ばしの種類に。

325
00:27:06,840 --> 00:27:12,990
そして、これが何のコピーを使用すると、パディングを追加するかもしれないかを示しています。

326
00:27:12,990 --> 00:27:14,990
だから我々は、我々が必要とするどのくらい水増し計算した

327
00:27:14,990 --> 00:27:18,220
そう、それは我々が0のパディング数が必要であることを意味します。

328
00:27:18,220 --> 00:27:24,510
これは何には、弊社のINTO OUTFILEを0パディングの番号を入れますforループです。

329
00:27:24,510 --> 00:27:31,170
そして最後には、両方のファイルを閉じます。あなたは、INFILEと同様に出力ファイルを閉じます。

330
00:27:31,170 --> 00:27:34,870
>> だからそれはどのようなそれなのに作品は、

331
00:27:34,870 --> 00:27:37,430
そしてそれはかなり便利になるだろう。

332
00:27:39,720 --> 00:27:43,750
だけではなく、実際にそれを直接コピーして貼り付けるの

333
00:27:43,750 --> 00:27:46,800
またはちょうどそれを見て、あなたが好きに入力し、

334
00:27:46,800 --> 00:27:49,440
あなただけの、端末で次のコマンドを実行する必要があるかもしれませ

335
00:27:49,440 --> 00:27:54,520
新しいファイルを作成しますCPそれなのにwhodunit.c、whodunit.c、

336
00:27:54,520 --> 00:27:58,330
それはコピーがないとまったく同じ内容を含んでいます。

337
00:27:58,330 --> 00:28:03,880
それでは我々は何ができるかのフレームワークとしてその上に構築したり編集したりすることに使用されている

338
00:28:03,880 --> 00:28:06,900
私たちの推理ファイルに対して行われます。

339
00:28:08,500 --> 00:28:14,670
>> これらは私達へ-DOSは、推理小説のためにしていますが、それなのには何をするか

340
00:28:14,670 --> 00:28:16,730
実際に私たちのために、それらのほとんどの世話をされています。

341
00:28:16,730 --> 00:28:21,900
だから我々は次に何をする必要があるすべては、必要に応じてピクセルを変更です

342
00:28:21,900 --> 00:28:25,920
実際にファイルを読めるようにします。

343
00:28:25,920 --> 00:28:32,960
タイプRGBTRIPLEの与えられた変数のためにそう、トリプル与えられた画素のためにそのことを覚えていて、

344
00:28:32,960 --> 00:28:35,990
あなたは、青、緑、赤の値にアクセスできます。

345
00:28:35,990 --> 00:28:38,670
あなたがそれらにアクセスできる場合があるから重宝するだろう、

346
00:28:38,670 --> 00:28:41,770
それはあなたにも、それらを確認できることを意味します

347
00:28:41,770 --> 00:28:45,430
それはあなたも、それらを変更できることを意味します。

348
00:28:45,430 --> 00:28:49,430
>> だから我々は赤い虫眼鏡の例に戻って行ったとき、

349
00:28:49,430 --> 00:28:53,390
基本的に、それは私たちのためにフィルタの一種として行動していた。

350
00:28:53,390 --> 00:28:58,160
だから我々が何をしたいのか我々はインチ来ているトリプルのすべてをフィルタしたいです

351
00:28:58,160 --> 00:29:01,240
これを行うには、いくつかの異なる方法があります。

352
00:29:01,240 --> 00:29:07,100
基本的に、あなたはあなたが欲しいどんなタイプのフィルタができます。

353
00:29:07,100 --> 00:29:09,890
たぶん、あなたはすべて赤のピクセルを変更したい

354
00:29:09,890 --> 00:29:13,570
または多分あなたは別の色に別の色のピクセルを変更したい。

355
00:29:13,570 --> 00:29:15,400
それはあなた次第です。

356
00:29:15,400 --> 00:29:19,580
あなたはピクセルが何色であることをチェックできることを覚えておいてください

357
00:29:19,580 --> 00:29:23,000
あなたが通過しているとして、あなたはまた、それを変更することができます。

358
00:29:24,410 --> 00:29:26,420
>> オーケー。だからそれは推理小説だ。

359
00:29:26,420 --> 00:29:32,760
一度推理小説を実行すると、犯罪の犯人が誰であったか知っているよ。

360
00:29:32,760 --> 00:29:35,540
>> 今、私たちは、リサイズに行くつもりです。

361
00:29:35,540 --> 00:29:37,990
我々はまだビットマップを扱うことになるだろう。

362
00:29:37,990 --> 00:29:40,750
我々がしようとしているのは、我々は入力ビットマップを持っているつもりです

363
00:29:40,750 --> 00:29:45,890
それから私達は数を渡し、その後outfileのビットマップを取得するつもりだ

364
00:29:45,890 --> 00:29:51,380
それは、基本的には、nでスケーリング当社INFILEだ場所。

365
00:29:54,670 --> 00:30:01,450
私のファイルのサイズが大きいだけで1画素であったと言う。

366
00:30:01,450 --> 00:30:09,100
私のnが3で3、スケーリングあった場合、ここで、私は、時代のその画素数nを繰り返すでしょう

367
00:30:09,100 --> 00:30:14,410
そう3回、その後も同様に3回、それをスケールダウン。

368
00:30:14,410 --> 00:30:17,840
だからあなたは、私が水平垂直だけでなく、それをスケーリングしている参照してください。

369
00:30:17,840 --> 00:30:19,680
>> そして、ここに例があります。

370
00:30:19,680 --> 00:30:27,590
あなたは、n = 2を使用している場合は、まず、青の画素が2回が繰り返していることがわかり

371
00:30:27,590 --> 00:30:30,930
水平方向だけでなく縦方向に2倍として。

372
00:30:30,930 --> 00:30:38,040
その後に続いていること、そしてそのためには、2つのことで、元の画像の直接スケーリングを持っています。

373
00:30:40,920 --> 00:30:47,600
>> 我々はこのための詳細な擬似コードをした場合それでは、我々は、ファイルを開きたい。

374
00:30:47,600 --> 00:30:49,880
そして、我々はここに戻って行くことを知っている場合

375
00:30:49,880 --> 00:30:54,540
我々は、出力ファイルごとに幅がINFILEの幅は異なるものとしていることがわかります。

376
00:30:54,540 --> 00:30:56,130
どういう意味ですか？

377
00:30:56,130 --> 00:31:01,230
それが私たちのヘッダー情報が変更しようとしていることを意味します。

378
00:31:01,230 --> 00:31:03,790
それで、我々がやりたいだろうと、ヘッダ情報を更新している

379
00:31:03,790 --> 00:31:11,820
それなのにあなたはフレームワーク上で動作している場合、我々はファイルを読み込むときにことを知って、

380
00:31:11,820 --> 00:31:17,570
我々はすでにサイズが何であるかを示し、そのようなものの変数を持っています。

381
00:31:17,570 --> 00:31:24,060
だから、一度あなたが何をしたいかもしれないものは、それらの特定の変数を変更していることがあります。

382
00:31:24,060 --> 00:31:29,380
あなたは構造体を持っている場合は、その内の変数にアクセスする方法を、覚えておいてください。

383
00:31:29,380 --> 00:31:32,080
あなたは正しい、ドット演算子を使用できますか？

384
00:31:32,080 --> 00:31:36,420
さて、あなたはヘッダ情報を変更する必要がありますことを知っている使用して。

385
00:31:36,480 --> 00:31:41,030
そこでここでは、ファイルに変更しようとしている実際の要素のリストだけだ。

386
00:31:41,030 --> 00:31:45,180
ファイルサイズは、画像だけでなく、幅や高さを変更されようとしている。

387
00:31:45,180 --> 00:31:50,080
それでは、ビットマップの地図に戻って

388
00:31:50,080 --> 00:31:57,730
それは、その情報を含むファイルヘッダーやinfoヘッダのかどうかを見てみ

389
00:31:57,730 --> 00:32:00,920
その後、必要に応じて変更します。

390
00:32:05,010 --> 00:32:12,470
繰り返しになりますが、CPそれなのにresize.cを言う。

391
00:32:12,470 --> 00:32:19,270
resize.c今コピーの中に記載されたすべてのものが含まれていることを意味します

392
00:32:19,270 --> 00:32:24,490
コピーは私たちに画素が各走査線の画素に読み取る方法を提供するからである。

393
00:32:24,490 --> 00:32:29,860
現在、除くだけではなく、我々は推理小説でやったように値を変更する

394
00:32:29,860 --> 00:32:37,980
私たちがやりたいことは、我々は、複数の画素に書きたいです

395
00:32:37,980 --> 00:32:43,580
限り我々のnが1より大きいからである。

396
00:32:43,580 --> 00:32:47,110
>> その後、我々が何をしたいのか、私たちはnで水平に伸ばしたいです

397
00:32:47,110 --> 00:32:50,490
同様にnで垂直に伸ばす。

398
00:32:50,490 --> 00:32:52,710
どのように我々はこれを行うのでしょうか？

399
00:32:52,710 --> 00:32:56,890
あなたのnが2であり、このinfileを与えていると言う。

400
00:32:56,890 --> 00:32:58,730
カーソルは、最初のものから開始する予定です

401
00:32:58,730 --> 00:33:03,530
nが2である場合、何をやってみたいことは、あなたはそれらの2に印刷したい。

402
00:33:03,530 --> 00:33:05,490
それで、あなたはそれらの2で印刷します。

403
00:33:05,490 --> 00:33:10,830
次に、あなたのカーソルは赤1である次のピクセルに移動しようとしている、

404
00:33:10,830 --> 00:33:18,400
そしてそれは前に行っているものの上にそれを付加して、その赤いものの2をプリントアウトするために起こっている。

405
00:33:18,400 --> 00:33:26,280
その後、カーソルが次のピクセルに移動すると、それらの2に描画されます。

406
00:33:26,280 --> 00:33:37,180
あなたはここにこれが何それなのに枠組みに戻ってみると

407
00:33:37,180 --> 00:33:42,830
それは、RGBトリプル、トリプルと呼ばれる新しい変数の新しいインスタンスを作成しています。

408
00:33:42,830 --> 00:33:50,500
そして、それはその中に読み込みこことき、それはinfileを1 RGBTRIPLEから読み取る

409
00:33:50,500 --> 00:33:53,470
そのトリプル変数の中にそれを格納します。

410
00:33:53,470 --> 00:33:57,590
それでは、実際には、その特定のピクセルを表す変数を持っています。

411
00:33:57,590 --> 00:34:05,290
その後、あなたは何をしたいかもしれないもの、書くときforループにfwriteのステートメント包むです

412
00:34:05,290 --> 00:34:11,080
それは、必要に応じて何度でもあなたのOUTFILEに書き込みます。

413
00:34:17,449 --> 00:34:20,100
それは十分に簡単です。

414
00:34:20,200 --> 00:34:27,590
ただ、基本的に水平方向にスケーリングするために何回書き込みプロセス数nを繰り返します。

415
00:34:27,590 --> 00:34:32,969
>> しかし、その後、私達は私達のパディングが変更しようとしていることを覚えておく必要があります。

416
00:34:47,350 --> 00:34:53,020
以前、我々は長さが3のものを持っていたと言う。

417
00:34:53,020 --> 00:35:00,130
その後、我々はどれだけのパディングに追加することになります？もう一つだけそれは4の倍数にする。

418
00:35:00,130 --> 00:35:10,480
しかし、我々は、n = 2で、この特定の画像を拡大·縮小していると言う。

419
00:35:10,480 --> 00:35:16,300
それでは、どのように多くの青色の画素我々は最後に持っているでしょうか？我々は6を持っているでしょう。

420
00:35:16,300 --> 00:35:21,470
1、2、3、4、5、6。かしこまりました。

421
00:35:21,470 --> 00:35:26,580
6は4の倍数ではありません。 4の倍数に最も近い値とは何ですか？それが8になるだろう。

422
00:35:26,580 --> 00:35:33,200
だから我々は、実際にそこにパディングの2文字を持っているつもりです。

423
00:35:33,200 --> 00:35:38,720
>> 我々はパディングを計算する式を使用している場合は誰でも覚えていますか

424
00:35:38,720 --> 00:35:41,350
そしてそれはどこになるのでしょうか？

425
00:35:41,350 --> 00:35:45,160
[聞き取れない生徒の応答] >>うん、copy.c.右。

426
00:35:45,160 --> 00:35:49,800
あなたが持っているどのくらいのパディング計算するそれなのに中の式があります

427
00:35:49,800 --> 00:35:53,810
ビットマップイメージの特定の幅を与えられた。

428
00:35:53,810 --> 00:36:02,950
それでは、あなたはパディングの一定量で追加する必要がある場合に有用であることが起こっている

429
00:36:02,950 --> 00:36:06,160
実際にあなたが追加する必要がありますどのくらいのパディング把握する。

430
00:36:10,820 --> 00:36:15,850
しかし、一つのノートでは、しかし、あなたは右のサイズを使用していることを確認したいということです。

431
00:36:15,850 --> 00:36:21,410
あなたは基本的に2つのビットマップ画像を扱うことになるだろうからといって注意してください。

432
00:36:21,410 --> 00:36:23,410
あなたが右のいずれかを使用していることを確認したい。

433
00:36:23,410 --> 00:36:26,820
あなたは出力ファイルに対してパディングを計算しているとき、あなたはoutfileの幅を使用したい

434
00:36:26,820 --> 00:36:29,860
前のものではなく、幅。

435
00:36:29,860 --> 00:36:37,240
>> グレート。その種類は、水平方向に全体のビットマップ画像を引き伸ばしの世話をする。

436
00:36:37,240 --> 00:36:41,290
しかし、我々は何をしたいのか、実際に垂直だけでなく、それを伸ばしています。

437
00:36:41,290 --> 00:36:48,760
これは、我々は、行のコピーが完了したときので、少しトリッキーになるだろう

438
00:36:48,760 --> 00:36:51,580
その行を書いて、私たちのカーソルは最後になるだろう。

439
00:36:51,580 --> 00:36:56,210
我々は再び読み込むのであれば、それは単に次の行にで読み取るために起こっている。

440
00:36:56,210 --> 00:37:03,660
だから我々が何をしたいのか、もう一度、それらの行をコピーしていくつかの方法を見つけるの一種である

441
00:37:03,660 --> 00:37:12,500
またはその行を取って、再びそれを書き換えるだけの種類。

442
00:37:14,380 --> 00:37:17,940
私は種類のものに触れましたように、これを行うには、いくつかの異なる方法があります。

443
00:37:17,940 --> 00:37:23,040
あなたが通過して、特定の走査線を介して読んでいるようにあなたは何ができることはある

444
00:37:23,040 --> 00:37:28,560
し、必要に応じてそれを変更し、店舗の種類、配列内のそれらのすべてのピクセル。

445
00:37:28,560 --> 00:37:36,350
その後、あなたにあなたが再びその配列をプリントアウトする必要がありますことを知って、

446
00:37:36,350 --> 00:37:39,830
ので、あなたはちょうどそれを行うには、その配列を使用することができます。

447
00:37:39,830 --> 00:37:44,500
それを行うための別の方法は、あなたが1行下にコピーすることも可能です

448
00:37:44,500 --> 00:37:47,950
その再びコピーする必要があることを理解してますので、実際には、カーソルを移動する

449
00:37:47,950 --> 00:37:50,950
それはメソッドfseek関数を使用することになるだろう。

450
00:37:50,950 --> 00:37:56,410
あなたはすべての帰りにカーソルを移動してから、再度コピー処理を繰り返すことができます。

451
00:37:56,410 --> 00:38:03,960
>> 私たちのスケーリング数がnである場合、そうだとすれば、何回我々は戻って行かなければならない

452
00:38:03,960 --> 00:38:10,500
とラインを書き換える？ >> [学生]はn  -  1。 >>うん、完璧。 N  -  1。

453
00:38:10,500 --> 00:38:14,390
我々は一度すでにそれをやったので、次に我々は後戻りプロセスを繰り返したいと思う

454
00:38:14,390 --> 00:38:17,460
N  -  1回の量。

455
00:38:22,730 --> 00:38:25,860
オーケー。だから、あなたはあなたのリサイズ機能を持っています。

456
00:38:25,860 --> 00:38:34,360
>> 今、私たちは本当に楽しい部分、回復は私のお気に入りのpset、取得することができます。

457
00:38:34,360 --> 00:38:39,580
代わりにビットマップの、今回はJPEGファイルを扱っている。

458
00:38:39,580 --> 00:38:43,370
我々は実際にはJPEGのファイルが与えられていないんです、

459
00:38:43,370 --> 00:38:46,600
我々は基本的に生のメモリカードのフォーマットを与えている。

460
00:38:46,600 --> 00:38:51,790
それで、これは、初めに情報やごみの値のビットが含まれています

461
00:38:51,790 --> 00:38:57,240
そして、それが開始され、それは、JPEGファイルの束を持っています。

462
00:38:57,240 --> 00:39:03,430
しかし、我々は、我々は写真を削除したカードを手渡している。

463
00:39:03,430 --> 00:39:08,300
写真はカード​​内に置かれている本質的に、私たちは忘れてしまいました。

464
00:39:08,300 --> 00:39:12,770
それでは回復で私たちの使命は、このカードのフォーマットを通過することです

465
00:39:12,770 --> 00:39:16,500
そして再びそれらの写真を見つける。

466
00:39:16,500 --> 00:39:23,990
>> 幸いにも、JPEGファイルやカードファイルの構造は少し便利です。

467
00:39:23,990 --> 00:39:28,850
それは、この特定の形式になっていないなら、それは間違いなく少しトリッキーだったかもしれない。

468
00:39:28,850 --> 00:39:40,160
すべてのJPEGファイルは、実際には上記の2つの可能なシーケンスで始まります。

469
00:39:40,160 --> 00:39:42,970
基本的には、新しいJPEGファイルを、あるたびに

470
00:39:42,970 --> 00:39:52,720
それはシーケンスFFD8 FFE0または他の1、FFD8 FFE1どちらから始まります。

471
00:39:52,720 --> 00:39:59,530
知るためのもう一つの有用なことは、JPEGファイルが連続して格納されていることです。

472
00:39:59,530 --> 00:40:03,380
だから1 JPEGファイルが終了するたびに、他の1が開始されます。

473
00:40:03,380 --> 00:40:07,070
だからそこ値の間の任意の種類はありません。

474
00:40:07,070 --> 00:40:15,510
あなたは既にJPEGを読んできた場合、一度は、JPEGの開始を打つ

475
00:40:15,510 --> 00:40:21,800
あなたが以前のものと次の始まりの終わりをヒットしたことを知っています。

476
00:40:21,800 --> 00:40:25,890
>> これを視覚化の種類には、私は回路図を作りました。

477
00:40:25,890 --> 00:40:36,910
JPEGファイルについてもう一つは、我々は一度に512バイトの配列にそれらを読むことができるということです

478
00:40:36,910 --> 00:40:39,380
同様にカードの始まりである。

479
00:40:39,380 --> 00:40:43,370
我々はそれが吸うなるので一つ一つのバイトをチェックする必要はありません。

480
00:40:43,370 --> 00:40:48,200
だから代わりに、我々は何ができるかは、実際にはただ一度に512バイトが読み込まれる

481
00:40:48,200 --> 00:40:54,700
その後、代わりにそれらの小さなスライスのものの間にチェックインの、

482
00:40:54,700 --> 00:40:58,640
私達はちょうど512バイトの先頭を確認することができます。

483
00:40:58,640 --> 00:41:02,570
本質的に、この写真では、何を参照して、カードの先頭にある

484
00:41:02,570 --> 00:41:08,700
あなたは、実際のJPEGファイル自体には本当に関連していない値を持っています。

485
00:41:08,700 --> 00:41:15,830
しかし、私が持っているものをJPEGの二つの出発のいずれかのシーケンスを示す星である。

486
00:41:15,830 --> 00:41:19,910
だから、スターを見るたびに、あなたは、JPEGファイルを持っていることを知っている。

487
00:41:19,910 --> 00:41:25,030
そして、すべてのJPEGファイルは、512バイトの倍数であることを行っている

488
00:41:25,030 --> 00:41:27,880
しかし、同じ倍数である必要はありません。

489
00:41:27,880 --> 00:41:32,050
あなたが他の星をヒットした場合、あなたが別のJPEGをヒットしたことを知っている方法は、ある

490
00:41:32,050 --> 00:41:39,090
バイトの別の開始シーケンス。

491
00:41:39,090 --> 00:41:43,330
次にあなたがここに持っているもの、あなたが星に到達するまでの間は、赤のJPEGファイルが継続しているです

492
00:41:43,330 --> 00:41:45,150
これらは新しい色で示されます。

493
00:41:45,150 --> 00:41:48,510
続行してから、他の星を打つ、あなたは別のJPEGを打つ

494
00:41:48,510 --> 00:41:50,590
あなたは最後まですべての方法を継続する。

495
00:41:50,590 --> 00:41:53,180
あなたは、ここで最後の画像でピンクの一つだね。

496
00:41:53,180 --> 00:41:58,220
あなたはファイルの文字の終わりに到達するまでの間は、末尾に移動します。

497
00:41:58,220 --> 00:42:00,820
これは本当に便利になるだろう。

498
00:42:00,820 --> 00:42:03,170
>> ここではいくつかの主なポイント：

499
00:42:03,170 --> 00:42:06,670
カードファイルは、JPEGで始まらない

500
00:42:06,670 --> 00:42:13,350
JPEGが開始されると、しかし、JPEGファイルのすべてがお互いに並んで格納されています。

501
00:42:17,520 --> 00:42:20,420
>> 回復のためのいくつかの擬似コード。

502
00:42:20,420 --> 00:42:22,570
まず、我々は、我々のカードファイルを開くしようとしている

503
00:42:22,570 --> 00:42:27,500
そしてそれは私たちのファイルI / O関数を使用することになるだろう。

504
00:42:27,500 --> 00:42:32,430
我々は、ファイルの終わりに達するまで、以下の処理を繰り返すつもりです。

505
00:42:32,430 --> 00:42:36,450
我々は一度に512バイトを読むつもりです。

506
00:42:36,450 --> 00:42:39,180
と私がここで言ったことは、我々はバッファに格納するつもりです

507
00:42:39,180 --> 00:42:46,230
我々は彼らをどうするかを正確に知るまでそう基本的にはそれらの512バイトを保持しているためです。

508
00:42:46,230 --> 00:42:50,300
その後、我々が何をしたいのか、私たちがスターかどうかをヒットしたかどうかをチェックしたいです。

509
00:42:50,300 --> 00:42:57,960
我々が開始シーケンスのいずれかをヒットした場合、我々は、星をヒットした場合は、

510
00:42:57,960 --> 00:42:59,980
その後、我々は新しいJPEGファイルをヒットしたことを知っています。

511
00:42:59,980 --> 00:43:08,860
私たちがやりたいよ私たちは私たちのpset4ディレクトリに新しいファイルを作成するつもりだ

512
00:43:08,860 --> 00:43:14,480
そのファイルを作っていきたい。

513
00:43:14,480 --> 00:43:18,220
しかし、また、私たちは既に前にJPEGを作った場合、

514
00:43:18,220 --> 00:43:25,620
次に我々は、そのファイルを終了してpset4フォルダにそれをプッシュする

515
00:43:25,620 --> 00:43:29,780
我々は、そのJPEGファイルを終了したことを指定しない場合ので、私たちは、そのファイルが格納されている必要があります場所

516
00:43:29,780 --> 00:43:37,290
その後、我々は基本的に不確定な量を持っているでしょう。 JPEGは決して終わらないでしょう。

517
00:43:37,290 --> 00:43:40,840
だから我々は、我々はJPEGファイルにで読み取りおよび書き込みしているときことを確認したい

518
00:43:40,840 --> 00:43:46,590
我々は、具体的に次のものを開くためにそれを閉じたい。

519
00:43:46,590 --> 00:43:48,430
我々はいくつかのことを確認したいと思う。

520
00:43:48,430 --> 00:43:52,880
我々は我々のバッファを持つ、新しいJPEGの開始時にいるかどうかを確認したい

521
00:43:52,880 --> 00:43:56,780
そしてまた、我々は既に前にJPEGを発見した場合

522
00:43:56,780 --> 00:44:03,930
それはわずかにあなたのプロセスが変更されるため。

523
00:44:03,930 --> 00:44:07,880
それでは、あなたはすべての道を通って行くと、ファイルの最後にヒットした後、

524
00:44:07,880 --> 00:44:11,570
次にあなたがしたいと思う何を現在開いているファイルをすべてクローズしたいと思うです。

525
00:44:11,570 --> 00:44:14,100
それはおそらく、あなたが持っている最後のJPEGファイルになります

526
00:44:14,100 --> 00:44:18,930
同様にカードファイルなど、あなたが扱ってきたこと。

527
00:44:21,940 --> 00:44:28,670
>> 私たちが取り組む必要があることを最後の障害は、実際にJPEGファイルを作成する方法です

528
00:44:28,670 --> 00:44:31,950
そして実際にフォルダにそれをプッシュする方法について説明します。

529
00:44:33,650 --> 00:44:39,850
psetには、あなたが見つけたすべてのJPEGは、次の形式であることが必要

530
00:44:39,850 --> 00:44:43,990
どこで番号を持っていますJPG。

531
00:44:43,990 --> 00:44:50,750
数は、それが0であっても、我々はそれが000.jpg呼ぶ。

532
00:44:50,750 --> 00:44:55,730
あなたのプログラムでJPEGを見つけたときには、

533
00:44:55,730 --> 00:44:58,040
あなたは、それが見つかった順番に名前を付けたいとしている。

534
00:44:58,040 --> 00:44:59,700
これはどういう意味ですか？

535
00:44:59,700 --> 00:45:03,530
我々は、我々が見つけたどのように多くのトラックを一種のを維持する必要がある

536
00:45:03,530 --> 00:45:08,680
と各JPEGの数はどうあるべきか。

537
00:45:08,680 --> 00:45:13,800
ここでは、sprintf関数を利用するつもりです。

538
00:45:13,800 --> 00:45:17,480
は、printfと同様に、どの端末にプリントだけの種類の値のうち、

539
00:45:17,480 --> 00:45:23,910
sprintfのフォルダにファイルを出力します。

540
00:45:23,910 --> 00:45:30,870
そして私はその後はsprintf、タイトル、およびそこに文字列を持っていた場合、これはどうなるのか、

541
00:45:30,870 --> 00:45:36,660
それは2.JPGをプリントアウトするだろう。

542
00:45:36,660 --> 00:45:41,020
正しく、私はファイルを閉じてしまったと仮定すると

543
00:45:41,020 --> 00:45:47,210
それは私が書いていたファイルを含んでいるでしょう。

544
00:45:47,210 --> 00:45:50,320
しかし、1つの事は、私がここに持っていることをそのコードです

545
00:45:50,320 --> 00:45:53,360
かなりpsetには必要なものを満たしていません。

546
00:45:53,360 --> 00:46:02,410
psetには、第二のJPEGファイルは002の代わりに、わずか2という名前を付ける必要があることが必要です。

547
00:46:02,410 --> 00:46:09,160
だから、名前をプリントアウトしたときに、おそらくあなたは、わずかにプレースホルダを変更した方がいいでしょう。

548
00:46:09,160 --> 00:46:18,140
>> 誰もが私たちが何かを印刷するとき、我々は余分なスペースを可能にする方法を覚えていますか？

549
00:46:18,140 --> 00:46:22,530
うん。 >> [生徒]あなたは、パーセント記号と2の間に3を入れた。 >>うん、完璧。

550
00:46:22,530 --> 00:46:25,610
我々は3のためのスペースが欲しいので、この場合は3を置くことにしましょう​​。

551
00:46:25,610 --> 00:46:32,590
％3dは、おそらくあなたが002.JPGの代わりに2与えるだろう。

552
00:46:32,590 --> 00:46:40,120
sprintf関数への最初の引数は、実際にはchar型の配列です

553
00:46:40,120 --> 00:46:42,520
その我々が以前に文字列として知っていた。

554
00:46:42,520 --> 00:46:50,700
それらの意志、一時的な記憶のようなより多くのの種類は、単に結果の文字列を格納します。

555
00:46:50,700 --> 00:46:54,950
あなたは本当にこれに対処することはありませんが、あなたはそれをインクルードする必要があります。

556
00:46:54,950 --> 00:47:00,710
>> すべてのファイル名が3文字を占有数を持っていることを知って、

557
00:47:00,710 --> 00:47:06,770
その後のjpg、この配列はどのくらいであるべきか？

558
00:47:09,070 --> 00:47:14,310
番号を投げ出す。名前のタイトルで何文字？

559
00:47:18,090 --> 00:47:26,320
だからJPG 3ハッシュタグは、その期間は、あります。 >> [生徒] 7。 >> 7。はなく、かなり。

560
00:47:26,320 --> 00:47:32,000
我々は、我々が同様にnull終端できるようにしたいので、8をするつもりだ。

561
00:47:45,340 --> 00:47:49,730
>> 最後に、ちょうどあなたが回復のためにやっているだろうというプロセスを引き出すために、

562
00:47:49,730 --> 00:47:55,420
あなたには、いくつかの開始情報を持っています。

563
00:47:55,420 --> 00:48:02,460
JPEGファイルの先頭を見つけるまでは、引き続き

564
00:48:02,460 --> 00:48:07,900
そしてそれは2から始まる配列のどちらかにすることができます。

565
00:48:07,900 --> 00:48:12,510
あなたが読み続ける。ここにすべてのスラッシュが512バイトを表します。

566
00:48:12,510 --> 00:48:22,630
あなたは別の起動シーケンスに遭遇するまで読み続け、読み続ける。

567
00:48:22,630 --> 00:48:29,790
この場合には、それは赤一つだ - それがわかれば、あなたは現在のJPEGを終了することがある

568
00:48:29,790 --> 00:48:31,030
ので、あなたはそれを終了させたい。

569
00:48:31,030 --> 00:48:35,540
あなたは、あなたのpset4フォルダにそのsprintfの名前にしたい

570
00:48:35,540 --> 00:48:41,580
その後、新しいJPEGを開いてから読み続けたい

571
00:48:41,580 --> 00:48:46,370
あなたは次が見つかるまで。

572
00:48:46,370 --> 00:48:49,040
、読書を続ける、読書を続ける

573
00:48:49,040 --> 00:48:56,290
そして最後に、最終的に、あなたは、ファイルの最後に到達しようとしている

574
00:48:56,290 --> 00:49:00,360
ので、あなたは、あなたが使用していた最後のJPEG画像を閉じたいと思う

575
00:49:00,360 --> 00:49:08,380
sprintfはあなたのpset4フォルダに、次にあなたが得ていることは、すべての画像を見てみること。

576
00:49:08,380 --> 00:49:12,050
それらの写真は、実際にはCS50スタッフの写真です、

577
00:49:12,050 --> 00:49:16,430
psetのボーナス楽しみの一部が入ってくる場所なので、このは

578
00:49:16,430 --> 00:49:26,310
写真でTFSを見つけるために、あなたのセクションで競合しているということです

579
00:49:26,310 --> 00:49:34,610
そしてあなたはpsetをやったことを証明するために彼らと写真を撮る

580
00:49:34,610 --> 00:49:37,030
ので、あなたは、職員が写真であるかを確認することができます。

581
00:49:37,030 --> 00:49:41,510
だから、あなたはスタッフと一緒に写真を撮る。時には、あなたは彼らを追いかける必要があるでしょう。

582
00:49:41,510 --> 00:49:44,680
おそらくそれらのいくつかは、あなたから離れて実行しようとします。

583
00:49:44,680 --> 00:49:47,320
あなたも一緒に写真を撮る。

584
00:49:47,320 --> 00:49:51,190
これは進行中である。 psetのが原因である場合、それが原因ではありません。

585
00:49:51,190 --> 00:49:53,340
締め切りはspecに発表されます。

586
00:49:53,340 --> 00:49:58,060
その後、一緒にあなたのセクションと、いずれかのセクションでは、最も写真を撮る

587
00:49:58,060 --> 00:50:04,430
ほとんどのスタッフと非常に素晴らしい賞品を獲得します。

588
00:50:04,430 --> 00:50:08,890
取得するためのインセンティブのようなものだあなたのpset4はできるだけ早く終了

589
00:50:08,890 --> 00:50:10,820
その後、仕事に取り掛かることができるので、

590
00:50:10,820 --> 00:50:14,570
すべての異なるCS50職員を追い詰める。

591
00:50:14,570 --> 00:50:17,500
必須ではないですね、しかし、ので、一度は、写真を撮る

592
00:50:17,500 --> 00:50:20,310
次にあなたはpset4で終了しました。

593
00:50:20,310 --> 00:50:23,970
>> と私はチュートリアル4で終了しているので、来てくれて、すべてに感謝します。

594
00:50:23,970 --> 00:50:29,330
フォレンジックで頑張って。 [拍手]

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