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

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

3
00:00:05,000 --> 00:00:07,340
[Ini adalah CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
Baiklah. Halo, semua orang, dan selamat datang Walkthrough 4.

5
00:00:11,670 --> 00:00:14,270
>> Hari pset kami adalah Forensik.

6
00:00:14,270 --> 00:00:18,080
Forensik adalah pset benar-benar menyenangkan yang melibatkan berurusan dengan file bitmap

7
00:00:18,080 --> 00:00:21,550
untuk menemukan siapa melakukan kejahatan.

8
00:00:21,550 --> 00:00:24,200
Kemudian kita akan mengubah ukuran beberapa file bitmap,

9
00:00:24,200 --> 00:00:27,780
maka kita juga akan berurusan dengan bagian benar-benar menyenangkan disebut Recover,

10
00:00:27,780 --> 00:00:31,160
di mana kita pada dasarnya menyerahkan kartu memori

11
00:00:31,160 --> 00:00:34,350
di mana seseorang telah sengaja menghapus semua file mereka,

12
00:00:34,350 --> 00:00:38,860
dan kami diminta untuk memulihkan file-file.

13
00:00:38,860 --> 00:00:42,910
>> Tapi pertama-tama, sebelum kita masuk ke pset, saya benar-benar hanya ingin mengucapkan selamat kepada semua orang.

14
00:00:42,910 --> 00:00:45,230
Kami sekitar pada titik tengah dari kursus ini.

15
00:00:45,230 --> 00:00:50,070
Kuis 0 adalah di belakang kami, dan kami berada di pset4, jadi pada dasarnya, kita setengah.

16
00:00:50,070 --> 00:00:55,490
Kami telah datang jauh jika Anda melihat kembali ke psets Anda, pset0 dan pset1,

17
00:00:55,490 --> 00:00:57,300
jadi selamat kepada diri sendiri tentang hal itu,

18
00:00:57,300 --> 00:01:00,760
dan kita akan masuk ke beberapa hal yang sangat menyenangkan.

19
00:01:00,760 --> 00:01:07,070
>> Jadi toolbox kami untuk pset ini, sekali lagi, bukannya menjalankan sudo yum-y update,

20
00:01:07,070 --> 00:01:13,890
kami dapat hanya menjalankan update50 jika Anda berada di versi 17,3 dan di atas alat.

21
00:01:13,890 --> 00:01:17,380
Jadi pastikan untuk menjalankan update50 - itu jauh lebih mudah, karakter yang kurang beberapa -

22
00:01:17,380 --> 00:01:20,640
untuk memastikan bahwa Anda berada di versi terbaru dari alat.

23
00:01:20,640 --> 00:01:25,410
Terutama penting untuk update50 ketika kita mulai menggunakan CS50 Periksa.

24
00:01:25,410 --> 00:01:28,700
Jadi pastikan bahwa Anda melakukan itu.

25
00:01:28,700 --> 00:01:30,760
>> Untuk semua bagian untuk pset ini,

26
00:01:30,760 --> 00:01:34,350
kita akan berurusan dengan input file dan output, file I / O.

27
00:01:34,350 --> 00:01:38,140
Kita akan terjadi lebih banyak program yang berhubungan dengan array

28
00:01:38,140 --> 00:01:40,350
menunjuk ke file dan hal-hal seperti itu,

29
00:01:40,350 --> 00:01:43,050
jadi kami ingin memastikan bahwa kita benar-benar akrab dan nyaman

30
00:01:43,050 --> 00:01:47,990
berurusan dengan bagaimana input dan output ke dalam file.

31
00:01:47,990 --> 00:01:52,080
>> Dalam kode distribusi untuk pset ini adalah sebuah file yang bernama copy.c,

32
00:01:52,080 --> 00:01:55,280
dan itulah apa yang kita akan menemukan akan menjadi benar-benar berguna bagi kita

33
00:01:55,280 --> 00:02:00,340
karena kita akan benar-benar berakhir menyalin file copy.c

34
00:02:00,340 --> 00:02:05,350
dan hanya mengubah sedikit untuk bisa mencapai 2 bagian pertama dari sejumlah masalah.

35
00:02:05,350 --> 00:02:09,030
>> Dan begitu kemudian seperti yang saya sebutkan sebelumnya, kita berhadapan dengan bitmap serta JPEGs.

36
00:02:09,030 --> 00:02:13,170
Jadi benar-benar memahami struktur bagaimana file tersebut diatur,

37
00:02:13,170 --> 00:02:16,170
bagaimana kita benar-benar bisa menerjemahkan 0s dan 1s dalam structs

38
00:02:16,170 --> 00:02:19,040
dan hal-hal yang kita benar-benar bisa memahami dan menafsirkan dan mengedit,

39
00:02:19,040 --> 00:02:21,000
yang akan benar-benar penting,

40
00:02:21,000 --> 00:02:25,970
sehingga akan menjadi JPEG dan file bitmap dan memahami struktur dari mereka.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, seperti biasa, dimulai dengan bagian pertanyaan.

42
00:02:30,780 --> 00:02:36,600
Mereka akan berurusan dengan file I / O dan membuat Anda terbiasa untuk itu.

43
00:02:36,600 --> 00:02:42,520
Kemudian bagian 1 adalah cerita detektif, di mana Anda diberi sebuah file bitmap

44
00:02:42,520 --> 00:02:45,630
yang terlihat jenis seperti titik-titik merah di seluruh.

45
00:02:45,630 --> 00:02:52,180
Dan kemudian pada dasarnya apa yang akan kita lakukan adalah mengambil file ini dan hanya mengeditnya sedikit

46
00:02:52,180 --> 00:02:54,010
menjadi versi yang dapat kita baca.

47
00:02:54,010 --> 00:02:56,000
Pada dasarnya, setelah kami selesai, kami akan memiliki file yang sama,

48
00:02:56,000 --> 00:03:02,630
kecuali kita akan dapat melihat pesan tersembunyi tersembunyi oleh semua titik merah.

49
00:03:02,630 --> 00:03:07,310
Kemudian Resize adalah program yang, mengingat file

50
00:03:07,310 --> 00:03:11,490
dan kemudian diberi nama dari file yang output dan kemudian diberi nomor juga,

51
00:03:11,490 --> 00:03:16,850
benar-benar akan mengubah ukuran bitmap bahwa dengan itu nilai integer.

52
00:03:16,850 --> 00:03:19,240
Kemudian yang terakhir, kita memiliki pset Recover.

53
00:03:19,240 --> 00:03:24,160
Kami diberi kartu memori dan kemudian harus memulihkan semua foto

54
00:03:24,160 --> 00:03:25,920
yang telah sengaja dihapus,

55
00:03:25,920 --> 00:03:31,420
tetapi, seperti yang akan kita pelajari, tidak benar-benar dihapus dan dihapus dari file;

56
00:03:31,420 --> 00:03:38,470
kita hanya semacam hilang di mana mereka berada di file, tapi kami akan memulihkan.

57
00:03:38,470 --> 00:03:44,950
>> Besar. Jadi pergi ke file I / O khusus, ini adalah daftar seluruh fungsi yang akan Anda gunakan.

58
00:03:44,950 --> 00:03:49,840
Anda sudah melihat sedikit dasar-dasar fopen, fread, dan fwrite,

59
00:03:49,840 --> 00:03:54,350
tapi kita akan melihat lebih jauh ke beberapa file I / O fungsi seperti fputc,

60
00:03:54,350 --> 00:03:56,930
di mana Anda hanya menulis satu karakter pada satu waktu,

61
00:03:56,930 --> 00:04:02,000
untuk fseek, di mana Anda jenis memindahkan indikator posisi file maju dan mundur,

62
00:04:02,000 --> 00:04:05,770
dan kemudian beberapa orang lain. Tapi kita akan pergi ke yang sedikit kemudian selama pset tersebut.

63
00:04:08,050 --> 00:04:13,100
>> Jadi pertama, hanya untuk masuk ke file I / O sebelum kita masuk ke pset tersebut,

64
00:04:13,100 --> 00:04:19,860
untuk membuka file, misalnya, apa yang harus Anda lakukan adalah benar-benar mengatur pointer ke file tersebut.

65
00:04:19,860 --> 00:04:22,710
Jadi kita memiliki pointer * FILE.

66
00:04:22,710 --> 00:04:27,140
Dalam kasus ini, saya menyebutnya sebagai pointer dalam karena itu akan menjadi saya infile.

67
00:04:27,140 --> 00:04:33,340
Dan jadi aku akan menggunakan fopen fungsi dan kemudian nama file

68
00:04:33,340 --> 00:04:36,360
dan kemudian mode di mana aku akan berurusan dengan file tersebut.

69
00:04:36,360 --> 00:04:42,080
Jadi ada "r" dalam kasus ini untuk membaca, "w" untuk menulis, dan kemudian "a" untuk menambahkan.

70
00:04:42,080 --> 00:04:44,270
Misalnya, ketika Anda sedang berhadapan dengan infile

71
00:04:44,270 --> 00:04:47,310
dan semua yang ingin Anda lakukan adalah membaca bit dan byte disimpan di sana,

72
00:04:47,310 --> 00:04:50,420
maka Anda mungkin akan ingin menggunakan "r" sebagai mode Anda.

73
00:04:50,420 --> 00:04:54,520
Bila Anda ingin benar-benar menulis, jenis membuat file baru,

74
00:04:54,520 --> 00:04:57,220
maka apa yang akan kita lakukan adalah kita akan membuka file baru

75
00:04:57,220 --> 00:05:02,410
dan menggunakan "w" modus untuk menulis.

76
00:05:02,410 --> 00:05:07,540
>> Jadi ketika Anda benar-benar membaca ke dalam file, struktur adalah sebagai berikut.

77
00:05:07,540 --> 00:05:14,930
Pertama Anda termasuk pointer ke struct yang akan berisi byte yang Anda baca.

78
00:05:14,930 --> 00:05:19,830
Sehingga akan menjadi lokasi akhir byte yang Anda baca.

79
00:05:19,830 --> 00:05:23,360
Anda kemudian akan mengindikasikan ukuran, seperti pada dasarnya berapa banyak byte

80
00:05:23,360 --> 00:05:30,100
Program Anda harus membaca ke file, ukuran dasarnya adalah satu elemen,

81
00:05:30,100 --> 00:05:32,620
dan kemudian Anda akan menentukan berapa banyak elemen yang ingin Anda baca.

82
00:05:32,620 --> 00:05:34,980
Dan akhirnya, Anda harus tahu di mana Anda membaca dari,

83
00:05:34,980 --> 00:05:37,580
sehingga akan menjadi pointer dalam Anda.

84
00:05:37,580 --> 00:05:41,780
Aku warna-kode ini karena fread juga sangat mirip dengan fwrite,

85
00:05:41,780 --> 00:05:47,050
kecuali Anda ingin memastikan bahwa Anda menggunakan urutan yang benar,

86
00:05:47,050 --> 00:05:51,960
pastikan bahwa Anda benar-benar menulis atau membaca dari file kanan.

87
00:05:54,910 --> 00:05:58,610
>> Jadi seperti sebelumnya, jika kita memiliki ukuran elemen serta jumlah elemen,

88
00:05:58,610 --> 00:06:00,600
maka kita bisa bermain-main di sini sedikit.

89
00:06:00,600 --> 00:06:06,810
Katakanlah saya memiliki struct DOG dan kemudian saya ingin membaca dua anjing pada suatu waktu.

90
00:06:06,810 --> 00:06:12,450
Apa yang saya bisa lakukan adalah mengatakan ukuran satu elemen akan menjadi ukuran satu ANJING

91
00:06:12,450 --> 00:06:14,770
dan aku akan benar-benar membaca dua dari mereka.

92
00:06:14,770 --> 00:06:18,290
Atau, apa yang bisa saya lakukan adalah mengatakan saya hanya akan membaca satu elemen

93
00:06:18,290 --> 00:06:21,340
dan bahwa salah satu unsur yang akan menjadi ukuran dari dua anjing.

94
00:06:21,340 --> 00:06:24,320
Jadi itulah bagaimana Anda dapat analog jenis bermain-main dengan ukuran dan jumlah

95
00:06:24,320 --> 00:06:28,250
tergantung pada apa yang lebih intuitif untuk Anda.

96
00:06:28,250 --> 00:06:30,810
>> Baiklah. Jadi sekarang kita bisa menulis file.

97
00:06:30,810 --> 00:06:36,880
Bila Anda ingin menulis file, argumen pertama sebenarnya di mana Anda membaca dari.

98
00:06:36,880 --> 00:06:42,050
Sehingga pada dasarnya data yang Anda akan menulis ke dalam file,

99
00:06:42,050 --> 00:06:44,490
yang merupakan pointer keluar di akhir.

100
00:06:44,490 --> 00:06:47,670
Jadi, ketika Anda sedang berhadapan dengan pset, pastikan Anda tidak bingung.

101
00:06:47,670 --> 00:06:50,480
Mungkin memiliki sisi definisi berdampingan.

102
00:06:50,480 --> 00:06:58,090
Anda dapat menarik definisi di manual dengan mengetikkan manusia dan kemudian fwrite, misalnya,

103
00:06:58,090 --> 00:06:59,950
di terminal, atau Anda dapat merujuk kembali ke slide ini

104
00:06:59,950 --> 00:07:03,570
dan pastikan bahwa Anda menggunakan yang tepat.

105
00:07:03,570 --> 00:07:08,700
Jadi sekali lagi, untuk fwrite, bila Anda memiliki file yang Anda ingin menulis ke,

106
00:07:08,700 --> 00:07:14,290
yang akan menjadi argumen terakhir dan itu akan menjadi pointer ke file tersebut.

107
00:07:14,290 --> 00:07:18,670
Jadi itulah bagaimana kita berurusan dengan menulis mungkin beberapa byte pada suatu waktu,

108
00:07:18,670 --> 00:07:21,820
tapi katakan Anda ingin hanya menulis hanya dalam satu karakter tunggal.

109
00:07:21,820 --> 00:07:25,940
Seperti yang akan kita lihat nanti dalam contoh ini, dalam bitmaps kita harus menggunakannya.

110
00:07:25,940 --> 00:07:32,180
Saat itulah kita dapat menggunakan fputc, pada dasarnya hanya menempatkan satu karakter pada satu waktu, chr,

111
00:07:32,180 --> 00:07:37,050
ke pointer file, dan itu keluar kami pointer sana.

112
00:07:38,700 --> 00:07:41,560
Jadi setiap kali kita mencari atau menulis dalam sebuah file,

113
00:07:41,560 --> 00:07:44,690
file melacak di mana kita berada.

114
00:07:44,690 --> 00:07:47,810
Jadi itu adalah semacam kursor, indikator posisi file.

115
00:07:47,810 --> 00:07:54,330
Dan sehingga setiap kali kita menulis atau membaca lagi ke sebuah file,

116
00:07:54,330 --> 00:07:56,760
file benar-benar mengingat di mana itu,

117
00:07:56,760 --> 00:07:59,270
dan begitu terus dari mana kursor berada.

118
00:07:59,270 --> 00:08:03,970
Hal ini dapat bermanfaat bila Anda ingin, katakanlah, baca dalam jumlah tertentu untuk melakukan sesuatu

119
00:08:03,970 --> 00:08:06,160
dan kemudian membaca dalam jumlah berikut,

120
00:08:06,160 --> 00:08:10,700
tapi kadang-kadang kita mungkin ingin kembali atau benar-benar mulai dari nilai referensi tertentu.

121
00:08:10,700 --> 00:08:16,870
Jadi fungsi fseek, apa yang dilakukannya adalah memungkinkan kita untuk memindahkan kursor dalam file tertentu

122
00:08:16,870 --> 00:08:19,680
sejumlah byte.

123
00:08:19,680 --> 00:08:24,260
Dan kemudian apa yang harus kita lakukan adalah menentukan di mana nilai referensi.

124
00:08:24,260 --> 00:08:31,520
Jadi baik itu bergerak maju atau mundur dari mana kursor saat ini,

125
00:08:31,520 --> 00:08:35,750
atau kita dapat menetapkan bahwa ia hanya harus bergerak dari awal file

126
00:08:35,750 --> 00:08:37,090
atau dari akhir file.

127
00:08:37,090 --> 00:08:41,230
Dan sehingga Anda dapat lulus dalam nilai negatif atau positif terhadap jumlah,

128
00:08:41,230 --> 00:08:44,960
dan itu akan seperti memindahkan kursor baik maju atau mundur.

129
00:08:46,170 --> 00:08:51,920
>> Sebelum kita masuk ke psets lainnya, pertanyaan pada file I / O?

130
00:08:53,860 --> 00:08:59,990
Oke. Ketika kita masuk ke lebih banyak contoh, jangan ragu untuk menghentikan saya untuk pertanyaan.

131
00:08:59,990 --> 00:09:06,930
>> Jadi dalam cerita detektif, Anda menyerahkan file bitmap yang mirip dengan ini satu merah pada slide,

132
00:09:06,930 --> 00:09:14,510
dan terlihat seperti ini - sekelompok titik-titik merah - dan Anda tidak benar-benar tahu apa yang tertulis.

133
00:09:14,510 --> 00:09:23,310
Jika Anda juling, Anda mungkin dapat melihat warna kebiruan sedikit di dalam tengah.

134
00:09:23,310 --> 00:09:26,270
Pada dasarnya, di situlah teks disimpan.

135
00:09:26,270 --> 00:09:30,270
Ada pembunuhan yang terjadi, dan kita perlu mencari tahu siapa yang melakukannya.

136
00:09:30,270 --> 00:09:36,760
Untuk melakukan itu, kita perlu semacam mengkonversi gambar ini ke dalam format yang mudah dibaca.

137
00:09:36,760 --> 00:09:42,740
Jika kalian pernah mengalami hal ini, terkadang akan ada sedikit kit

138
00:09:42,740 --> 00:09:48,510
di mana Anda akan memiliki kaca pembesar dengan film merah. Siapa saja? Ya.

139
00:09:48,510 --> 00:09:52,770
Jadi Anda akan menjadi sesuatu tangan seperti ini, Anda akan memiliki kaca pembesar

140
00:09:52,770 --> 00:09:58,130
dengan film merah di atasnya, Anda akan meletakkannya di atas gambar,

141
00:09:58,130 --> 00:10:03,410
dan Anda akan dapat melihat pesan tersembunyi di dalamnya.

142
00:10:03,410 --> 00:10:07,080
Kami tidak memiliki kaca pembesar dengan film merah, jadi alih-alih kita akan menciptakan jenis kita sendiri

143
00:10:07,080 --> 00:10:09,060
di pset ini.

144
00:10:09,060 --> 00:10:15,760
Dan sehingga pengguna akan cerita detektif masukan, maka petunjuk tersebut,. Bmp,

145
00:10:15,760 --> 00:10:18,800
sehingga itulah infile, itulah pesan red dot,

146
00:10:18,800 --> 00:10:23,550
dan kemudian mereka mengatakan verdict.bmp akan menjadi outfile kami.

147
00:10:23,550 --> 00:10:27,900
Jadi itu akan membuat gambar bitmap baru yang mirip dengan petunjuk yang

148
00:10:27,900 --> 00:10:32,600
kecuali dalam format yang mudah dibaca di mana kita dapat melihat pesan tersembunyi.

149
00:10:32,600 --> 00:10:37,550
>> Karena kita akan berurusan dengan mengedit dan memanipulasi bitmap dari beberapa macam,

150
00:10:37,550 --> 00:10:42,400
kita akan jenis menyelam di dalam struktur file-file bitmap.

151
00:10:42,400 --> 00:10:48,130
Kami pergi selama ini agak sedikit di kuliah, tapi mari kita melihat ke mereka lagi.

152
00:10:48,130 --> 00:10:51,740
Bitmaps pada dasarnya hanya sebuah susunan byte

153
00:10:51,740 --> 00:10:55,790
di mana kita telah ditentukan yang byte berarti apa.

154
00:10:55,790 --> 00:11:00,540
Jadi di sini adalah jenis seperti peta gambar bitmap

155
00:11:00,540 --> 00:11:08,550
mengatakan bahwa hal itu dimulai dengan beberapa file header, dimulai dengan beberapa informasi di sana.

156
00:11:08,550 --> 00:11:16,540
Anda lihat bahwa pada sekitar byte nomor 14 ukuran ditunjukkan gambar bitmap,

157
00:11:16,540 --> 00:11:18,520
dan terus selanjutnya.

158
00:11:18,520 --> 00:11:23,810
Tapi kemudian apa yang kita benar-benar tertarik di sini mulai di nomor byte 54.

159
00:11:23,810 --> 00:11:26,060
Kami memiliki tiga kali lipat tersebut RGB.

160
00:11:26,060 --> 00:11:30,760
Apa yang akan lakukan adalah mengandung piksel yang sebenarnya, nilai warna.

161
00:11:30,760 --> 00:11:35,950
Segala sesuatu di atas yang di header adalah beberapa informasi

162
00:11:35,950 --> 00:11:41,240
sesuai dengan ukuran gambar, lebar gambar, dan ketinggian.

163
00:11:41,240 --> 00:11:44,930
Ketika kita masuk ke bantalan nanti, kita akan melihat mengapa ukuran gambar

164
00:11:44,930 --> 00:11:48,670
mungkin berbeda dari lebar atau ketinggian.

165
00:11:48,670 --> 00:11:54,240
Jadi untuk mewakili ini - gambar-gambar bitmap adalah urutan byte -

166
00:11:54,240 --> 00:11:59,370
apa yang bisa kita lakukan adalah mengatakan apa-apa, aku akan ingat bahwa pada indeks 14,

167
00:11:59,370 --> 00:12:03,380
situlah ukurannya, misalnya, melainkan apa yang akan kita lakukan untuk membuat ini lebih mudah

168
00:12:03,380 --> 00:12:06,020
yang merangkum dalam sebuah struct.

169
00:12:06,020 --> 00:12:08,880
Dan jadi kita memiliki dua struct dibuat untuk kita, seorang BITMAPFILEHEADER

170
00:12:08,880 --> 00:12:10,440
dan BITMAPINFOHEADER a,

171
00:12:10,440 --> 00:12:14,840
dan sehingga setiap kali kita membaca ke file tersebut, secara default itu akan terjadi dalam rangka,

172
00:12:14,840 --> 00:12:22,360
dan sebagainya dalam rangka itu juga akan mengisi ke dalam variabel seperti biWidth dan biSize.

173
00:12:25,270 --> 00:12:31,230
Dan akhirnya, setiap pixel diwakili oleh tiga byte.

174
00:12:31,230 --> 00:12:35,500
Yang pertama adalah jumlah dari biru di pixel, yang kedua adalah jumlah warna hijau,

175
00:12:35,500 --> 00:12:41,120
dan akhirnya, jumlah warna merah, di mana 0 adalah tidak ada dasarnya hijau biru atau tidak ada atau tidak merah

176
00:12:41,120 --> 00:12:43,720
dan kemudian ff adalah nilai maksimum.

177
00:12:43,720 --> 00:12:46,800
Ini adalah nilai-nilai heksadesimal.

178
00:12:46,800 --> 00:12:53,870
Jadi jika kita memiliki ff0000, maka yang sesuai dengan jumlah maksimum biru

179
00:12:53,870 --> 00:12:58,890
dan kemudian tidak hijau dan tidak ada merah, jadi maka itu akan memberi kita pixel biru.

180
00:12:58,890 --> 00:13:04,190
Kemudian jika kita memiliki semua ff di seluruh papan, maka itu berarti bahwa kita memiliki piksel putih.

181
00:13:04,190 --> 00:13:11,370
Ini adalah jenis berlawanan dengan biasanya ketika kita mengatakan RGB. Ini benar-benar akan BGR.

182
00:13:12,750 --> 00:13:18,990
>> Jadi, jika kita benar-benar melihat ke contoh gambar bitmap - biarkan aku menarik satu di sini.

183
00:13:31,560 --> 00:13:33,830
Ini adalah kecil.

184
00:13:39,890 --> 00:13:47,840
Aku meluncur masuk, dan kita bisa melihat itu pixelated. Sepertinya blok warna.

185
00:13:47,840 --> 00:13:50,110
Anda memiliki blok putih dan kemudian blok merah.

186
00:13:50,110 --> 00:13:53,700
Jika Anda bermain di Microsoft Paint, misalnya, Anda bisa membuat sesuatu seperti itu

187
00:13:53,700 --> 00:13:58,960
by dasarnya hanya melukis kotak tertentu dalam urutan tertentu.

188
00:13:58,960 --> 00:14:08,060
Jadi apa ini diterjemahkan dalam bitmap adalah sebagai berikut.

189
00:14:08,060 --> 00:14:15,710
Di sini kita memiliki piksel putih pertama, bahwa semua adalah milik 6 f, dan kemudian kita memiliki piksel merah,

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

191
00:14:19,910 --> 00:14:27,940
Dan sehingga urutan byte yang kita miliki menunjukkan bagaimana gambar bitmap akan terlihat.

192
00:14:27,940 --> 00:14:32,230
Jadi apa yang saya lakukan di sini hanya ditulis semua byte dan kemudian berwarna merah

193
00:14:32,230 --> 00:14:37,550
sehingga Anda dapat melihat jenis, jika Anda juling sedikit, bagaimana semacam itu menunjukkan wajah tersenyum.

194
00:14:40,180 --> 00:14:46,390
>> Cara yang bitmap gambar kerja adalah saya membayangkannya dasarnya sebagai kotak.

195
00:14:46,390 --> 00:14:54,940
Dan sebagainya secara default, setiap baris dari grid harus kelipatan dari 4 byte.

196
00:15:00,520 --> 00:15:07,060
Jika kita melihat sebuah gambar bitmap, Anda mengisi nilai setiap.

197
00:15:07,060 --> 00:15:17,370
Misalnya, Anda mungkin memiliki merah di sini, di sini hijau, biru di sini,

198
00:15:17,370 --> 00:15:24,950
tetapi Anda harus memastikan bahwa gambar diisi dengan kelipatan empat byte.

199
00:15:24,950 --> 00:15:32,200
Jadi jika saya ingin gambar saya menjadi tiga blok yang luas, maka saya harus menempatkan nilai kosong

200
00:15:32,200 --> 00:15:35,640
dalam yang terakhir untuk membuatnya kelipatan empat.

201
00:15:35,640 --> 00:15:39,530
Jadi saya akan menambahkan sesuatu yang kita panggil padding.

202
00:15:39,530 --> 00:15:43,750
Aku hanya akan menunjukkan bahwa ada suatu dengan x.

203
00:15:44,920 --> 00:15:54,160
Sekarang katakanlah kita ingin gambar yang 7 piksel panjang, misalnya.

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

205
00:16:04,750 --> 00:16:07,000
dan semua yang diisi dengan warna.

206
00:16:07,000 --> 00:16:10,620
Cara bahwa gambar bitmap bekerja adalah bahwa kita memerlukan 8.

207
00:16:10,620 --> 00:16:12,460
Saat ini kami memiliki 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
Kita perlu 8 ruang untuk gambar bitmap untuk membaca dengan benar.

209
00:16:19,360 --> 00:16:25,600
Jadi apa yang harus kita lakukan adalah menambahkan hanya sedikit padding

210
00:16:25,600 --> 00:16:29,430
untuk memastikan bahwa semua lebar yang seragam

211
00:16:29,430 --> 00:16:34,260
dan bahwa semua lebar merupakan kelipatan dari 4.

212
00:16:42,110 --> 00:16:47,310
Dan jadi saya sebelumnya menunjukkan, pelapis sebagai x atau berlekuk-lekuk garis,

213
00:16:47,310 --> 00:16:53,880
tetapi dalam gambar bitmap yang sebenarnya padding ditandai dengan 0 heksadesimal.

214
00:16:53,880 --> 00:16:57,340
Jadi itu akan menjadi karakter tunggal, 0.

215
00:16:58,980 --> 00:17:06,329
Apa yang mungkin berguna adalah perintah xxd.

216
00:17:06,329 --> 00:17:11,220
Apa yang dilakukannya adalah benar-benar menunjukkan Anda, seperti mirip dengan apa yang saya lakukan sebelumnya dengan tersenyum

217
00:17:11,220 --> 00:17:15,630
ketika saya benar-benar dicetak apa yang masing-masing warna akan untuk pixel

218
00:17:15,630 --> 00:17:21,800
dan kemudian warna-kode itu, ketika Anda menjalankan xxd dengan perintah berikut,

219
00:17:21,800 --> 00:17:28,670
maka benar-benar akan mencetak apa warna bagi mereka piksel.

220
00:17:28,670 --> 00:17:33,810
Apa yang harus Anda lakukan adalah di sini saya menunjukkan, seperti s-54

221
00:17:33,810 --> 00:17:36,530
mengatakan bahwa aku akan mulai pada byte 54

222
00:17:36,530 --> 00:17:40,820
karena sebelum itu, ingat jika kita melihat kembali ke peta bitmap,

223
00:17:40,820 --> 00:17:42,690
itu semua informasi header dan hal-hal seperti itu.

224
00:17:42,690 --> 00:17:46,280
Tapi apa yang kita benar-benar peduli adalah pixel aktual yang menunjukkan warna.

225
00:17:46,280 --> 00:17:52,700
Jadi dengan menambahkan pada bendera itu,-s 54, maka kita dapat melihat nilai warna.

226
00:17:52,700 --> 00:17:56,020
Dan jangan khawatir tentang bendera rumit dan hal-hal seperti itu.

227
00:17:56,020 --> 00:18:05,020
Dalam spec sejumlah masalah, Anda akan memiliki petunjuk tentang cara menggunakan xxd untuk menampilkan piksel.

228
00:18:07,070 --> 00:18:15,590
Jadi jika Anda lihat di sini, itu semacam tampak seperti kotak hijau, ini hal kecil.

229
00:18:15,590 --> 00:18:23,610
Saya sudah diberi warna 00FF00 sebagai dasarnya mengatakan tidak biru, banyak hijau, dan tidak ada merah.

230
00:18:23,610 --> 00:18:26,370
Sehingga sesuai dengan hijau.

231
00:18:26,370 --> 00:18:31,920
Seperti yang Anda lihat di sini, kita melihat persegi panjang hijau.

232
00:18:31,920 --> 00:18:36,660
Ini persegi panjang hijau hanya 3 pixel, sehingga kemudian apa yang harus kita lakukan

233
00:18:36,660 --> 00:18:44,350
untuk memastikan bahwa gambar merupakan kelipatan dari 4 lebar menambahkan padding tambahan.

234
00:18:44,350 --> 00:18:49,460
Dan begitu maka itulah bagaimana Anda melihat 0s ini di sini.

235
00:18:49,460 --> 00:18:54,510
Ini benar-benar akan menjadi hasil dari pset Resize Anda,

236
00:18:54,510 --> 00:19:01,350
pada dasarnya mengambil bitmap kecil dan kemudian memperbesarnya dengan 4.

237
00:19:01,350 --> 00:19:09,380
Dan jadi apa yang kita lihat adalah bahwa sebenarnya gambar ini adalah 12 pixel, tetapi 12 merupakan kelipatan dari 4,

238
00:19:09,380 --> 00:19:12,940
dan jadi kita benar-benar tidak melihat 0s di akhir karena kita tidak perlu menambahkan

239
00:19:12,940 --> 00:19:19,070
karena itu sepenuhnya empuk. Itu tidak memiliki ruang lagi.

240
00:19:20,720 --> 00:19:23,470
>> Oke. Setiap pertanyaan tentang bantalan?

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

242
00:19:27,460 --> 00:19:32,520
>> Seperti yang saya sebutkan sebelumnya, bitmaps hanya urutan byte.

243
00:19:32,520 --> 00:19:39,170
Dan jadi apa yang kita miliki adalah bukan perlu melacak persis jumlah byte

244
00:19:39,170 --> 00:19:47,050
sesuai dengan elemen tertentu, kita benar-benar telah menciptakan struct untuk menyatakan bahwa.

245
00:19:47,050 --> 00:19:50,930
Jadi apa yang kita miliki adalah struct RGBTRIPLE.

246
00:19:50,930 --> 00:19:54,590
Kapanpun Anda memiliki sebuah instance dari sebuah tiga RGB,

247
00:19:54,590 --> 00:20:00,970
karena ini adalah tipe mendefinisikan struct, maka Anda dapat mengakses variabel rgbtBlue,

248
00:20:00,970 --> 00:20:09,520
sama variabel Hijau dan Merah, yang akan menunjukkan berapa banyak biru, hijau, dan merah,

249
00:20:09,520 --> 00:20:11,580
masing-masing, yang Anda miliki.

250
00:20:11,580 --> 00:20:16,800
>> Jadi jika kita memiliki set variabel biru 0, set hijau untuk ff,

251
00:20:16,800 --> 00:20:22,060
yang merupakan nilai maksimum Anda dapat memiliki, dan kemudian variabel merah set ke 0,

252
00:20:22,060 --> 00:20:27,870
maka warna apa yang akan ini RGB tertentu mewakili tiga? >> [Mahasiswa] Green.

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

254
00:20:29,150 --> 00:20:34,480
Ini akan berguna untuk mengetahui bahwa setiap kali Anda memiliki sebuah instance dari sebuah tiga RGB,

255
00:20:34,480 --> 00:20:41,340
Anda benar-benar dapat mengakses jumlah warna - biru, hijau, dan merah - secara terpisah.

256
00:20:43,350 --> 00:20:54,900
>> Sekarang kita sudah bicara tentang struktur itu, mari kita lihat file BMP.

257
00:20:54,900 --> 00:20:57,870
Ini adalah struct dibuat untuk Anda.

258
00:20:57,870 --> 00:21:01,820
Di sini kita memiliki struct BITMAPFILEHEADER.

259
00:21:01,820 --> 00:21:07,610
Yang menarik adalah ukuran.

260
00:21:07,610 --> 00:21:12,660
Kemudian, kita memiliki header info, yang memiliki beberapa hal yang menarik untuk kita,

261
00:21:12,660 --> 00:21:15,480
yaitu ukuran, lebar, dan tinggi.

262
00:21:15,480 --> 00:21:19,170
Seperti kita akan masuk ke kemudian, ketika Anda membaca ke file tersebut,

263
00:21:19,170 --> 00:21:25,500
secara otomatis membaca di karena kami telah menetapkan perintah harus sama.

264
00:21:25,500 --> 00:21:31,990
Jadi biSize akan berisi byte yang tepat yang sesuai dengan ukuran sebenarnya dari gambar.

265
00:21:34,700 --> 00:21:40,500
Dan maka di sini, terakhir, seperti yang kita bicarakan, kita memiliki struct typedef RGBTRIPLE.

266
00:21:40,500 --> 00:21:46,840
Kami memiliki rgbtBlue, Hijau, dan Merah yang terkait dengannya.

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

268
00:21:49,340 --> 00:21:56,360
Sekarang kita mengerti bitmap sedikit, memahami bahwa kita memiliki file header

269
00:21:56,360 --> 00:22:00,790
dan header informasi yang terkait dengan itu dan kemudian setelah itu, kita memiliki hal menarik

270
00:22:00,790 --> 00:22:05,110
dari warna, dan warna-warna yang diwakili oleh structs RGBTRIPLE,

271
00:22:05,110 --> 00:22:12,710
dan mereka, pada gilirannya, memiliki tiga nilai yang terkait dengan biru, hijau, dan merah.

272
00:22:12,710 --> 00:22:17,270
>> Jadi sekarang, kita dapat berpikir tentang jenis Recover sedikit.

273
00:22:17,270 --> 00:22:20,130
Maaf. Pikirkan tentang cerita detektif.

274
00:22:20,130 --> 00:22:25,750
Ketika kita memiliki file petunjuk kami, maka apa yang kita ingin lakukan adalah membaca itu pixel demi pixel

275
00:22:25,750 --> 00:22:33,860
dan kemudian entah bagaimana mengubah mereka piksel sehingga kita dapat output ke dalam format yang mudah dibaca.

276
00:22:33,860 --> 00:22:41,020
Dan sehingga untuk output itu, kita akan menulis pixel demi pixel ke dalam file verdict.bmp.

277
00:22:41,020 --> 00:22:45,120
Itu semacam banyak yang harus dilakukan. Kami menyadari bahwa.

278
00:22:45,120 --> 00:22:49,860
Jadi apa yang kita lakukan adalah kita sudah benar-benar memberikan Anda copy.c.

279
00:22:49,860 --> 00:22:57,610
Apa copy.c tidak hanya membuat salinan persis dari file bitmap yang diberikan dan kemudian output itu.

280
00:22:57,610 --> 00:23:01,900
Jadi ini sudah membuka file untuk Anda, membaca dalam pixel demi pixel,

281
00:23:01,900 --> 00:23:04,510
dan kemudian menulis ke dalam file output.

282
00:23:04,510 --> 00:23:07,080
>> Mari kita lihat pada saat itu.

283
00:23:13,390 --> 00:23:18,290
Ini adalah memastikan penggunaan yang tepat,

284
00:23:18,290 --> 00:23:22,640
mendapatkan nama file di sini.

285
00:23:22,640 --> 00:23:29,940
Apa yang dilakukan adalah ia menetapkan file masukan untuk menjadi apa yang kita telah melewati di dalam infile sini,

286
00:23:29,940 --> 00:23:34,750
yang kedua kami baris perintah argumen.

287
00:23:34,750 --> 00:23:37,640
Cek untuk memastikan bahwa kita dapat membuka file tersebut.

288
00:23:38,960 --> 00:23:44,860
Cek untuk memastikan kita bisa membuat outfile baru di sini.

289
00:23:45,630 --> 00:23:53,270
Lalu apa hal ini di sini, itu hanya pada dasarnya mulai membaca ke file bitmap dari awal.

290
00:23:53,270 --> 00:23:56,700
Awal, seperti yang kita ketahui, mengandung BITMAPFILEHEADER tersebut,

291
00:23:56,700 --> 00:24:03,200
dan sehingga mereka urutan bit secara langsung akan mengisi BITMAPFILEHEADER tersebut.

292
00:24:03,200 --> 00:24:07,940
Jadi apa yang kita miliki di sini mengatakan bahwa bf BITMAPFILEHEADER -

293
00:24:07,940 --> 00:24:13,150
itu variabel baru kami BITMAPFILEHEADER jenis -

294
00:24:13,150 --> 00:24:22,560
kita akan dimasukkan ke dalam bf apa yang kita baca dari dalam pointer, yang kami infile.

295
00:24:22,560 --> 00:24:23,970
Berapa banyak kita baca?

296
00:24:23,970 --> 00:24:32,160
Kita membaca dalam berapa banyak byte kita perlu mengandung BITMAPFILEHEADER keseluruhan.

297
00:24:32,160 --> 00:24:34,660
Demikian pula, itulah yang kita lakukan untuk header info.

298
00:24:34,660 --> 00:24:39,010
Jadi kita terus bersama file kita di infile,

299
00:24:39,010 --> 00:24:44,360
dan kami sedang membaca yang bit dan byte, dan kami memasukkan mereka langsung di

300
00:24:44,360 --> 00:24:47,880
ke dalam contoh dari variabel yang kita membuat.

301
00:24:49,370 --> 00:24:53,800
Di sini kami hanya memastikan bahwa bitmap adalah bitmap.

302
00:24:57,670 --> 00:25:01,030
>> Sekarang kita memiliki outfile, kan?

303
00:25:01,030 --> 00:25:04,420
Jadi seperti berdiri ketika kita menciptakannya, itu pada dasarnya kosong.

304
00:25:04,420 --> 00:25:07,710
Jadi pada dasarnya kita harus membuat bitmap baru dari awal.

305
00:25:07,710 --> 00:25:12,280
Apa yang kita lakukan adalah kita harus memastikan bahwa kita copy dalam file header

306
00:25:12,280 --> 00:25:16,850
dan header informasi seperti infile memiliki.

307
00:25:16,850 --> 00:25:22,850
Apa yang kita lakukan adalah kita menulis - dan ingat bahwa bf adalah variabel

308
00:25:22,850 --> 00:25:29,300
dari BITMAPFILEHEADER jenis, sehingga apa yang kita lakukan adalah kita hanya menggunakan konten yang

309
00:25:29,300 --> 00:25:34,980
untuk menulis ke outfile tersebut.

310
00:25:36,550 --> 00:25:38,510
Di sini, ingat kita berbicara tentang padding,

311
00:25:38,510 --> 00:25:47,820
bagaimana hal itu penting untuk memastikan bahwa jumlah pixel yang kita miliki merupakan kelipatan dari 4.

312
00:25:47,820 --> 00:25:52,790
Ini adalah formula yang cukup berguna untuk menghitung berapa banyak bantalan yang Anda miliki

313
00:25:52,790 --> 00:25:57,670
mengingat lebar file Anda.

314
00:25:57,670 --> 00:26:04,120
Saya ingin kalian ingat bahwa di copy.c kita memiliki rumus untuk menghitung padding.

315
00:26:04,120 --> 00:26:07,970
Oke? Jadi setiap orang ingat itu. Besar.

316
00:26:07,970 --> 00:26:14,050
Jadi apa yang copy.c lakukan selanjutnya itu iterates atas semua scanlines.

317
00:26:14,050 --> 00:26:23,730
Ini melewati baris pertama dan kemudian menyimpan setiap tiga yang berbunyi

318
00:26:23,730 --> 00:26:26,920
dan kemudian menulis ke outfile tersebut.

319
00:26:26,920 --> 00:26:33,120
Jadi di sini kita membaca hanya satu RGB tiga pada suatu waktu

320
00:26:33,120 --> 00:26:39,860
dan kemudian menempatkan bahwa tiga sama ke outfile tersebut.

321
00:26:41,120 --> 00:26:48,340
Bagian tersulit adalah bahwa padding bukan tiga RGB,

322
00:26:48,340 --> 00:26:55,200
dan sehingga kita tidak bisa hanya membaca bahwa jumlah padding tiga kali lipat RGB.

323
00:26:55,200 --> 00:27:01,460
Apa yang harus kita lakukan sebenarnya hanya memindahkan indikator file posisi kami, kami memindahkan kursor,

324
00:27:01,460 --> 00:27:06,840
untuk jenis melompati semua padding sehingga kita berada di baris berikutnya.

325
00:27:06,840 --> 00:27:12,990
Dan kemudian apa hal ini adalah salinan menunjukkan Anda bagaimana Anda mungkin ingin menambahkan padding.

326
00:27:12,990 --> 00:27:14,990
Jadi kita telah menghitung berapa banyak bantalan yang kita butuhkan,

327
00:27:14,990 --> 00:27:18,220
sehingga berarti bahwa kita membutuhkan jumlah padding 0s.

328
00:27:18,220 --> 00:27:24,510
Apa yang dilakukan adalah untuk loop yang menempatkan jumlah padding 0s ke outfile kami.

329
00:27:24,510 --> 00:27:31,170
Dan akhirnya, Anda menutup kedua file. Anda menutup infile serta outfile tersebut.

330
00:27:31,170 --> 00:27:34,870
>> Jadi begitulah copy.c bekerja,

331
00:27:34,870 --> 00:27:37,430
dan itu akan menjadi sangat berguna.

332
00:27:39,720 --> 00:27:43,750
Alih-alih hanya benar-benar secara langsung menyalin dan paste

333
00:27:43,750 --> 00:27:46,800
atau hanya melihat dan mengetik dalam apa pun yang Anda inginkan,

334
00:27:46,800 --> 00:27:49,440
Anda mungkin hanya ingin menjalankan perintah ini di terminal,

335
00:27:49,440 --> 00:27:54,520
cp copy.c whodunit.c, yang akan membuat file baru, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
yang berisi konten yang sama persis seperti copy tidak.

337
00:27:58,330 --> 00:28:03,880
Jadi apa yang bisa kita lakukan adalah menggunakan itu sebagai kerangka yang di atasnya untuk membangun dan mengedit

338
00:28:03,880 --> 00:28:06,900
untuk file cerita detektif kami.

339
00:28:08,500 --> 00:28:14,670
>> Ini adalah kita-dos lakukan untuk cerita detektif, tapi apa tidak copy.c

340
00:28:14,670 --> 00:28:16,730
sebenarnya mengurus sebagian besar dari mereka untuk kita.

341
00:28:16,730 --> 00:28:21,900
Jadi semua yang perlu kita lakukan selanjutnya adalah mengubah piksel yang diperlukan

342
00:28:21,900 --> 00:28:25,920
untuk benar-benar membuat file yang dapat dibaca.

343
00:28:25,920 --> 00:28:32,960
Ingat bahwa untuk pixel diberikan tiga, sehingga untuk variabel tertentu RGBTRIPLE jenis,

344
00:28:32,960 --> 00:28:35,990
Anda dapat mengakses, nilai-nilai hijau biru, dan merah.

345
00:28:35,990 --> 00:28:38,670
Itu akan berguna karena jika Anda dapat mengaksesnya,

346
00:28:38,670 --> 00:28:41,770
yang berarti bahwa Anda juga dapat memeriksa mereka,

347
00:28:41,770 --> 00:28:45,430
dan itu berarti bahwa Anda juga dapat mengubahnya.

348
00:28:45,430 --> 00:28:49,430
>> Jadi ketika kita kembali ke contoh kaca pembesar merah kami,

349
00:28:49,430 --> 00:28:53,390
pada dasarnya, yang bertindak sebagai semacam filter bagi kita.

350
00:28:53,390 --> 00:28:58,160
Jadi apa yang ingin kita lakukan adalah kita ingin menyaring semua tiga kali lipat yang datang masuk

351
00:28:58,160 --> 00:29:01,240
Ada beberapa cara berbeda untuk melakukan hal ini.

352
00:29:01,240 --> 00:29:07,100
Pada dasarnya, Anda dapat memiliki apa pun jenis filter yang Anda inginkan.

353
00:29:07,100 --> 00:29:09,890
Mungkin Anda ingin mengubah semua piksel merah

354
00:29:09,890 --> 00:29:13,570
atau mungkin Anda ingin mengubah piksel warna yang berbeda dengan warna yang berbeda.

355
00:29:13,570 --> 00:29:15,400
Itu terserah Anda.

356
00:29:15,400 --> 00:29:19,580
Ingat bahwa Anda dapat memeriksa apa warna pixel adalah

357
00:29:19,580 --> 00:29:23,000
dan kemudian Anda juga bisa mengubahnya karena Anda akan melalui.

358
00:29:24,410 --> 00:29:26,420
>> Oke. Jadi itulah cerita detektif.

359
00:29:26,420 --> 00:29:32,760
Setelah Anda menjalankan cerita detektif, Anda akan tahu siapa biang keladi kejahatan itu.

360
00:29:32,760 --> 00:29:35,540
>> Sekarang kita akan pergi ke Resize.

361
00:29:35,540 --> 00:29:37,990
Kita akan tetap berurusan dengan bitmap.

362
00:29:37,990 --> 00:29:40,750
Apa yang akan kita lakukan adalah kita akan memiliki bitmap masukan

363
00:29:40,750 --> 00:29:45,890
dan kemudian kita akan lulus dalam sebuah nomor dan kemudian mendapatkan bitmap outfile

364
00:29:45,890 --> 00:29:51,380
di mana itu pada dasarnya kami infile skala oleh n.

365
00:29:54,670 --> 00:30:01,450
Katakanlah file saya adalah hanya satu pixel yang besar.

366
00:30:01,450 --> 00:30:09,100
Kemudian jika n saya 3, scaling dengan 3, maka saya akan mengulangi bahwa pixel n beberapa kali,

367
00:30:09,100 --> 00:30:14,410
sehingga 3 kali, dan kemudian juga skala itu turun 3 kali juga.

368
00:30:14,410 --> 00:30:17,840
Jadi Anda melihat saya skala secara vertikal maupun horizontal.

369
00:30:17,840 --> 00:30:19,680
>> Dan kemudian inilah contoh.

370
00:30:19,680 --> 00:30:27,590
Jika Anda memiliki n = 2, Anda melihat bahwa pixel biru pertama ada diulang dua kali

371
00:30:27,590 --> 00:30:30,930
horizontal maupun vertikal dua kali.

372
00:30:30,930 --> 00:30:38,040
Dan kemudian yang terus di, sehingga Anda memiliki skala langsung dari gambar asli Anda dengan dua.

373
00:30:40,920 --> 00:30:47,600
>> Jadi jika kita terhadap detail pseudocode untuk ini, kita ingin membuka file.

374
00:30:47,600 --> 00:30:49,880
Dan kemudian mengetahui bahwa jika kita pergi ke sini,

375
00:30:49,880 --> 00:30:54,540
kita melihat bahwa lebar untuk outfile ini akan berbeda dari lebar untuk infile.

376
00:30:54,540 --> 00:30:56,130
Apa artinya?

377
00:30:56,130 --> 00:31:01,230
Itu berarti bahwa informasi header kita akan berubah.

378
00:31:01,230 --> 00:31:03,790
Dan jadi apa kita ingin lakukan adalah memperbarui info header,

379
00:31:03,790 --> 00:31:11,820
mengetahui bahwa ketika kita membaca dalam file jika Anda beroperasi pada kerangka copy.c,

380
00:31:11,820 --> 00:31:17,570
kita sudah memiliki variabel yang menunjukkan ukuran apa itu dan hal-hal seperti itu.

381
00:31:17,570 --> 00:31:24,060
Jadi, sekali Anda memiliki itu, apa yang Anda mungkin ingin lakukan adalah mengubah variabel tertentu.

382
00:31:24,060 --> 00:31:29,380
Ingat, jika Anda memiliki struct, bagaimana Anda mengakses variabel dalam itu.

383
00:31:29,380 --> 00:31:32,080
Anda menggunakan operator titik, kan?

384
00:31:32,080 --> 00:31:36,420
Jadi kemudian menggunakan itu, Anda tahu bahwa Anda harus mengubah info header.

385
00:31:36,480 --> 00:31:41,030
Jadi di sini hanya daftar elemen yang sebenarnya yang akan mengubah dalam file Anda.

386
00:31:41,030 --> 00:31:45,180
Ukuran file akan berubah, gambar, serta lebar dan tinggi.

387
00:31:45,180 --> 00:31:50,080
Jadi akan kembali ke peta bitmap,

388
00:31:50,080 --> 00:31:57,730
melihat apakah itu header file atau header info yang berisi informasi yang

389
00:31:57,730 --> 00:32:00,920
dan kemudian mengubah sesuai kebutuhan.

390
00:32:05,010 --> 00:32:12,470
Sekali lagi, katakanlah cp copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
Itu berarti bahwa resize.c sekarang berisi semua yang terkandung di dalam copy

392
00:32:19,270 --> 00:32:24,490
karena copy memberikan kita cara membaca untuk setiap pixel scanline oleh pixel.

393
00:32:24,490 --> 00:32:29,860
Kecuali sekarang, bukan hanya mengubah nilai-nilai seperti yang kami lakukan di cerita detektif,

394
00:32:29,860 --> 00:32:37,980
apa yang ingin kita lakukan adalah kita ingin menulis dalam piksel beberapa

395
00:32:37,980 --> 00:32:43,580
asalkan n kami lebih besar dari 1.

396
00:32:43,580 --> 00:32:47,110
>> Lalu apa yang ingin kita lakukan adalah kita ingin meregangkan secara horisontal dengan n,

397
00:32:47,110 --> 00:32:50,490
serta peregangan secara vertikal oleh n.

398
00:32:50,490 --> 00:32:52,710
Bagaimana mungkin kita melakukan ini?

399
00:32:52,710 --> 00:32:56,890
Katakanlah Anda adalah n 2 dan Anda memiliki infile diberikan.

400
00:32:56,890 --> 00:32:58,730
Kursor Anda akan mulai yang pertama,

401
00:32:58,730 --> 00:33:03,530
dan apa yang ingin Anda lakukan jika n adalah 2, Anda ingin mencetak dalam 2 dari mereka.

402
00:33:03,530 --> 00:33:05,490
Jadi Anda mencetak dalam 2 dari mereka.

403
00:33:05,490 --> 00:33:10,830
Kemudian kursor Anda akan pindah ke piksel berikutnya, yang merupakan satu merah,

404
00:33:10,830 --> 00:33:18,400
dan itu akan mencetak 2 dari mereka yang merah, menambahkan itu ke apa itu dilakukan sebelumnya.

405
00:33:18,400 --> 00:33:26,280
Kemudian kursor akan pindah ke pixel berikutnya dan menarik 2 dari mereka.

406
00:33:26,280 --> 00:33:37,180
Jika Anda melihat kembali ke kerangka copy.c, apa hal ini di sini

407
00:33:37,180 --> 00:33:42,830
adalah menciptakan contoh baru dari tiga RGB, variabel baru yang disebut triple.

408
00:33:42,830 --> 00:33:50,500
Dan di sini ketika membaca ke dalamnya, ia membaca dari infile 1 RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
dan menyimpannya dalam variabel tiga.

410
00:33:53,470 --> 00:33:57,590
Jadi Anda benar-benar memiliki variabel yang mewakili bahwa pixel tertentu.

411
00:33:57,590 --> 00:34:05,290
Kemudian ketika Anda menulis, apa yang Anda mungkin ingin lakukan adalah menyelimuti pernyataan fwrite dalam untuk loop

412
00:34:05,290 --> 00:34:11,080
yang menulis ke outfile Anda sebanyak yang diperlukan.

413
00:34:17,449 --> 00:34:20,100
Itu cukup sederhana.

414
00:34:20,200 --> 00:34:27,590
Hanya pada dasarnya mengulangi proses penulisan n beberapa kali untuk skala itu horizontal.

415
00:34:27,590 --> 00:34:32,969
>> Tapi kemudian kita harus ingat bahwa bantalan kami akan berubah.

416
00:34:47,350 --> 00:34:53,020
Sebelumnya, katakanlah kita memiliki sesuatu yang panjang 3.

417
00:34:53,020 --> 00:35:00,130
Kemudian kita hanya akan menambahkan berapa banyak bantalan? Hanya satu lagi untuk membuatnya kelipatan dari 4.

418
00:35:00,130 --> 00:35:10,480
Namun mengatakan kita skala ini gambar tertentu dengan n = 2.

419
00:35:10,480 --> 00:35:16,300
Jadi berapa banyak piksel biru akan kita miliki di akhir? Kami akan memiliki 6.

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

421
00:35:21,470 --> 00:35:26,580
6 bukan kelipatan dari 4. Apa kelipatan terdekat dari 4? Itu akan menjadi 8.

422
00:35:26,580 --> 00:35:33,200
Jadi kita benar-benar akan memiliki 2 karakter padding di sana.

423
00:35:33,200 --> 00:35:38,720
>> Apakah ada yang ingat jika kita memiliki formula untuk menghitung bantalan

424
00:35:38,720 --> 00:35:41,350
dan di mana yang mungkin?

425
00:35:41,350 --> 00:35:45,160
[Respon terdengar mahasiswa] >> Ya, copy.c. Benar.

426
00:35:45,160 --> 00:35:49,800
Ada rumus di copy.c untuk menghitung berapa banyak bantalan yang Anda miliki

427
00:35:49,800 --> 00:35:53,810
diberikan lebar tertentu dari gambar bitmap.

428
00:35:53,810 --> 00:36:02,950
Jadi itu akan berguna ketika Anda perlu menambahkan dalam jumlah tertentu padding

429
00:36:02,950 --> 00:36:06,160
untuk benar-benar mencari tahu berapa banyak bantalan Anda perlu menambahkan.

430
00:36:10,820 --> 00:36:15,850
Tapi satu catatan, meskipun, adalah bahwa Anda ingin memastikan bahwa Anda menggunakan ukuran yang tepat.

431
00:36:15,850 --> 00:36:21,410
Hanya berhati-hati karena pada dasarnya Anda akan berhadapan dengan dua gambar bitmap.

432
00:36:21,410 --> 00:36:23,410
Anda ingin memastikan bahwa Anda menggunakan yang tepat.

433
00:36:23,410 --> 00:36:26,820
Ketika Anda menghitung padding untuk outfile, Anda ingin menggunakan lebar outfile

434
00:36:26,820 --> 00:36:29,860
dan tidak lebar dari sebelumnya.

435
00:36:29,860 --> 00:36:37,240
>> Besar. Semacam mengurus peregangan gambar bitmap seluruh horizontal.

436
00:36:37,240 --> 00:36:41,290
Tapi apa yang kita ingin lakukan adalah benar-benar peregangan secara vertikal juga.

437
00:36:41,290 --> 00:36:48,760
Ini akan menjadi sedikit rumit karena ketika kita sudah selesai menyalin baris

438
00:36:48,760 --> 00:36:51,580
dan menulis baris itu, kami kursor akan berada di akhir.

439
00:36:51,580 --> 00:36:56,210
Jadi jika kita membaca lagi, maka itu hanya akan membaca ke baris berikutnya.

440
00:36:56,210 --> 00:37:03,660
Jadi apa yang ingin kita lakukan adalah jenis menemukan beberapa cara untuk menyalin baris itu lagi

441
00:37:03,660 --> 00:37:12,500
atau hanya semacam mengambil baris itu dan kemudian menulis ulang lagi.

442
00:37:14,380 --> 00:37:17,940
Seperti aku agak menyinggung, ada beberapa cara berbeda untuk melakukan hal ini.

443
00:37:17,940 --> 00:37:23,040
Apa yang Anda bisa lakukan adalah karena Anda akan melalui dan membaca melalui scanline tertentu

444
00:37:23,040 --> 00:37:28,560
dan mengubahnya seperlunya, maka jenis toko semua orang piksel dalam array.

445
00:37:28,560 --> 00:37:36,350
Lalu kemudian pada Anda tahu bahwa Anda akan perlu untuk mencetak array lagi,

446
00:37:36,350 --> 00:37:39,830
dan sehingga Anda hanya dapat menggunakan array itu untuk melakukan itu.

447
00:37:39,830 --> 00:37:44,500
Cara lain untuk melakukannya adalah Anda bisa menyalin satu baris,

448
00:37:44,500 --> 00:37:47,950
memahami bahwa Anda perlu menyalin itu lagi, jadi sebenarnya memindahkan kursor Anda,

449
00:37:47,950 --> 00:37:50,950
dan itu akan menggunakan fseek metode.

450
00:37:50,950 --> 00:37:56,410
Anda bisa memindahkan kursor Anda sepanjang perjalanan kembali dan kemudian ulangi proses copy lagi.

451
00:37:56,410 --> 00:38:03,960
>> Jadi jika nomor skala kami adalah n, maka berapa kali kita akan harus kembali

452
00:38:03,960 --> 00:38:10,500
dan menulis ulang baris? >> [Mahasiswa] n - 1. >> Ya, sempurna. n - 1.

453
00:38:10,500 --> 00:38:14,390
Kami telah melakukannya sekali sudah, jadi maka kita akan ingin mengulang proses akan kembali

454
00:38:14,390 --> 00:38:17,460
n - 1 jumlah kali.

455
00:38:22,730 --> 00:38:25,860
Oke. Jadi di sana Anda memiliki fungsi resize Anda.

456
00:38:25,860 --> 00:38:34,360
>> Sekarang kita bisa sampai ke bagian benar-benar menyenangkan, pset favorit saya, yaitu Recover.

457
00:38:34,360 --> 00:38:39,580
Alih-alih bitmap, kali ini kita sedang berhadapan dengan JPEG.

458
00:38:39,580 --> 00:38:43,370
Kami benar-benar tidak diberi file hanya dari file JPEG,

459
00:38:43,370 --> 00:38:46,600
kita diberikan pada dasarnya format kartu memori baku.

460
00:38:46,600 --> 00:38:51,790
Dan jadi ini mengandung sedikit nilai info dan sampah di awal,

461
00:38:51,790 --> 00:38:57,240
dan kemudian mulai dan memiliki sekelompok file JPEG.

462
00:38:57,240 --> 00:39:03,430
Namun, kami menyerahkan kartu di mana kita telah menghapus foto-foto;

463
00:39:03,430 --> 00:39:08,300
pada dasarnya, kita sudah lupa di mana foto-foto yang terletak di dalam kartu.

464
00:39:08,300 --> 00:39:12,770
Jadi tugas kita dalam Recover adalah pergi melalui format kartu

465
00:39:12,770 --> 00:39:16,500
dan menemukan foto-foto lagi.

466
00:39:16,500 --> 00:39:23,990
>> Untungnya, struktur file JPEG dan file kartu sedikit membantu.

467
00:39:23,990 --> 00:39:28,850
Ini pasti bisa menjadi sedikit lebih sulit jika bukan dalam format tertentu.

468
00:39:28,850 --> 00:39:40,160
Setiap file JPEG sebenarnya dimulai dengan dua urutan yang mungkin, yang tercantum di atas.

469
00:39:40,160 --> 00:39:42,970
Pada dasarnya, setiap kali Anda memiliki file JPEG yang baru,

470
00:39:42,970 --> 00:39:52,720
dimulai dengan baik urutan ffd8 ffe0 atau yang lain, ffd8 ffe1.

471
00:39:52,720 --> 00:39:59,530
Hal lain yang membantu untuk tahu adalah bahwa file JPEG disimpan contiguously.

472
00:39:59,530 --> 00:40:03,380
Jadi, setiap kali satu file JPEG berakhir, yang lain dimulai.

473
00:40:03,380 --> 00:40:07,070
Jadi tidak ada apapun di antara nilai-nilai di sana.

474
00:40:07,070 --> 00:40:15,510
Setelah Anda menekan awal dari JPEG, jika Anda sudah pernah membaca JPEG,

475
00:40:15,510 --> 00:40:21,800
Anda tahu bahwa Anda telah memukul akhir sebelumnya dan awal dari yang berikutnya.

476
00:40:21,800 --> 00:40:25,890
>> Untuk jenis memvisualisasikan ini, saya membuat sebuah skema.

477
00:40:25,890 --> 00:40:36,910
Hal lain tentang file JPEG adalah bahwa kita dapat membacanya di urutan 512 byte pada suatu waktu,

478
00:40:36,910 --> 00:40:39,380
sama dengan awal kartu.

479
00:40:39,380 --> 00:40:43,370
Kita tidak perlu memeriksa setiap byte tunggal karena itu akan mengisap.

480
00:40:43,370 --> 00:40:48,200
Jadi, bukannya, apa yang bisa kita lakukan sebenarnya hanya membaca dalam 512 byte pada suatu waktu

481
00:40:48,200 --> 00:40:54,700
dan kemudian, bukannya memeriksa di antara mereka pada mereka irisan kecil kecil,

482
00:40:54,700 --> 00:40:58,640
kita hanya bisa memeriksa awal 512 byte.

483
00:40:58,640 --> 00:41:02,570
Pada dasarnya, dalam gambar ini, apa yang Anda lihat adalah di awal kartu,

484
00:41:02,570 --> 00:41:08,700
Anda memiliki nilai-nilai yang tidak benar-benar relevan dengan JPEG sebenarnya sendiri.

485
00:41:08,700 --> 00:41:15,830
Tapi kemudian apa yang saya miliki adalah bintang untuk menunjukkan salah satu dari dua urutan awal untuk JPEG.

486
00:41:15,830 --> 00:41:19,910
Jadi setiap kali Anda melihat seorang bintang, Anda tahu bahwa Anda memiliki file JPEG.

487
00:41:19,910 --> 00:41:25,030
Dan kemudian setiap file JPEG akan menjadi beberapa beberapa 512 byte

488
00:41:25,030 --> 00:41:27,880
namun belum tentu beberapa yang sama.

489
00:41:27,880 --> 00:41:32,050
Cara yang Anda tahu bahwa Anda telah memukul lain JPEG adalah jika anda menekan bintang lain,

490
00:41:32,050 --> 00:41:39,090
lain urutan mulai dari byte.

491
00:41:39,090 --> 00:41:43,330
Lalu apa yang Anda miliki di sini adalah Anda memiliki file JPEG merah terus sampai Anda mencapai bintang,

492
00:41:43,330 --> 00:41:45,150
yang ditunjukkan dengan warna baru.

493
00:41:45,150 --> 00:41:48,510
Anda terus dan kemudian Anda menekan bintang lain, anda menekan lain JPEG,

494
00:41:48,510 --> 00:41:50,590
Anda terus sepanjang jalan sampai akhir.

495
00:41:50,590 --> 00:41:53,180
Anda berada di gambar terakhir di sini, satu pink.

496
00:41:53,180 --> 00:41:58,220
Anda pergi ke akhir sampai Anda mencapai akhir dari karakter file.

497
00:41:58,220 --> 00:42:00,820
Ini akan menjadi benar-benar berguna.

498
00:42:00,820 --> 00:42:03,170
>> Sebuah utama takeaways beberapa di sini:

499
00:42:03,170 --> 00:42:06,670
Berkas kartu tidak dimulai dengan JPEG,

500
00:42:06,670 --> 00:42:13,350
tapi sekali JPEG dimulai, semua file JPEG disimpan berdampingan satu sama lain.

501
00:42:17,520 --> 00:42:20,420
>> Beberapa pseudocode untuk Recover.

502
00:42:20,420 --> 00:42:22,570
Pertama, kita akan membuka file kartu kami,

503
00:42:22,570 --> 00:42:27,500
dan itu akan menggunakan file kami I / O fungsi.

504
00:42:27,500 --> 00:42:32,430
Kita akan mengulang proses berikut sampai kita telah mencapai akhir file.

505
00:42:32,430 --> 00:42:36,450
Kita akan membaca 512 byte pada suatu waktu.

506
00:42:36,450 --> 00:42:39,180
Dan apa yang saya katakan di sini adalah kita akan menyimpannya dalam buffer,

507
00:42:39,180 --> 00:42:46,230
jadi pada dasarnya berpegang pada mereka 512 byte sampai kita tahu persis apa yang harus dilakukan dengan mereka.

508
00:42:46,230 --> 00:42:50,300
Lalu apa yang ingin kita lakukan adalah kita ingin memeriksa apakah kita telah mencapai bintang atau tidak.

509
00:42:50,300 --> 00:42:57,960
Jika kita telah memukul bintang, jika kita telah memukul salah satu dari urutan awal,

510
00:42:57,960 --> 00:42:59,980
maka kita tahu bahwa kita telah memukul file JPEG yang baru.

511
00:42:59,980 --> 00:43:08,860
Apa yang akan kita ingin lakukan adalah kita akan ingin membuat file baru di direktori pset4 kami

512
00:43:08,860 --> 00:43:14,480
untuk terus membuat file tersebut.

513
00:43:14,480 --> 00:43:18,220
Tapi juga, jika kita sudah membuat JPEG sebelumnya,

514
00:43:18,220 --> 00:43:25,620
maka kita ingin mengakhiri file itu dan mendorongnya ke folder pset4,

515
00:43:25,620 --> 00:43:29,780
di mana kita akan memiliki file yang disimpan karena jika kita tidak menentukan bahwa kita telah berakhir file JPEG,

516
00:43:29,780 --> 00:43:37,290
maka kita pada dasarnya akan memiliki jumlah tak tentu. File JPEG tidak akan pernah berakhir.

517
00:43:37,290 --> 00:43:40,840
Jadi kami ingin memastikan bahwa ketika kita membaca ke file JPEG dan menulis bahwa,

518
00:43:40,840 --> 00:43:46,590
kami ingin secara khusus menutup bahwa untuk membuka yang berikutnya.

519
00:43:46,590 --> 00:43:48,430
Kami akan ingin memeriksa beberapa hal.

520
00:43:48,430 --> 00:43:52,880
Kami ingin memeriksa apakah kita berada pada awal dari sebuah JPEG baru kami dengan buffer

521
00:43:52,880 --> 00:43:56,780
dan juga jika kita sudah telah menemukan JPEG sebelum

522
00:43:56,780 --> 00:44:03,930
karena itu akan mengubah proses Anda sedikit.

523
00:44:03,930 --> 00:44:07,880
Jadi setelah Anda pergi melalui semua jalan dan Anda memukul akhir file,

524
00:44:07,880 --> 00:44:11,570
maka apa yang akan Anda ingin lakukan adalah Anda akan ingin menutup semua file yang sedang terbuka.

525
00:44:11,570 --> 00:44:14,100
Yang mungkin akan menjadi file JPEG terakhir yang Anda miliki,

526
00:44:14,100 --> 00:44:18,930
serta file kartu yang Anda sudah berurusan dengan.

527
00:44:21,940 --> 00:44:28,670
>> Hambatan terakhir yang kita butuhkan untuk mengatasi adalah bagaimana untuk benar-benar membuat file JPEG

528
00:44:28,670 --> 00:44:31,950
dan bagaimana untuk benar-benar mendorong ke folder.

529
00:44:33,650 --> 00:44:39,850
Pset tersebut mengharuskan setiap JPEG yang Anda temukan dalam format berikut,

530
00:44:39,850 --> 00:44:43,990
di mana Anda memiliki nomor tersebut. jpg.

531
00:44:43,990 --> 00:44:50,750
Jumlah itu, bahkan jika itu 0, kita menyebutnya 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Setiap kali Anda menemukan JPEG dalam program Anda,

533
00:44:55,730 --> 00:44:58,040
Anda akan ingin nama itu dalam urutan bahwa itu ditemukan.

534
00:44:58,040 --> 00:44:59,700
Apa artinya ini?

535
00:44:59,700 --> 00:45:03,530
Kita perlu semacam melacak berapa banyak kita telah menemukan

536
00:45:03,530 --> 00:45:08,680
dan apa jumlah masing-masing JPEG seharusnya.

537
00:45:08,680 --> 00:45:13,800
Di sini kita akan mengambil keuntungan dari fungsi sprintf.

538
00:45:13,800 --> 00:45:17,480
Serupa dengan printf, yang hanya semacam mencetak nilai keluar ke terminal,

539
00:45:17,480 --> 00:45:23,910
sprintf mencetak file keluar ke folder.

540
00:45:23,910 --> 00:45:30,870
Dan jadi apa ini akan lakukan jika saya punya sprintf, judul, dan kemudian string sana,

541
00:45:30,870 --> 00:45:36,660
itu akan mencetak 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Dengan asumsi bahwa saya telah menutup file saya dengan benar,

543
00:45:41,020 --> 00:45:47,210
yang akan berisi file yang saya telah menuliskan.

544
00:45:47,210 --> 00:45:50,320
Tapi satu hal adalah bahwa kode yang saya miliki di sini

545
00:45:50,320 --> 00:45:53,360
tidak cukup memenuhi apa pset membutuhkan.

546
00:45:53,360 --> 00:46:02,410
Pset mengharuskan bahwa file JPEG kedua harus dinamai 002 bukan hanya 2.

547
00:46:02,410 --> 00:46:09,160
Jadi, ketika Anda mencetak nama, maka mungkin Anda mungkin ingin mengubah placeholder sedikit.

548
00:46:09,160 --> 00:46:18,140
>> Apakah ada yang ingat bagaimana kita memungkinkan untuk ruang tambahan ketika kita mencetak sesuatu?

549
00:46:18,140 --> 00:46:22,530
Ya. >> [Mahasiswa] Anda menempatkan 3 antara tanda persen dan 2 tersebut. >> Ya, sempurna.

550
00:46:22,530 --> 00:46:25,610
Anda akan menempatkan 3 dalam kasus ini karena kami ingin ruang untuk 3.

551
00:46:25,610 --> 00:46:32,590
3d% mungkin akan memberi Anda 002.jpg bukannya 2.

552
00:46:32,590 --> 00:46:40,120
Argumen pertama ke fungsi sprintf sebenarnya adalah array char,

553
00:46:40,120 --> 00:46:42,520
yang kita tahu sebelumnya sebagai string.

554
00:46:42,520 --> 00:46:50,700
Mereka kehendak, jenis lebih seperti penyimpanan sementara, hanya menyimpan string yang dihasilkan.

555
00:46:50,700 --> 00:46:54,950
Anda tidak akan benar-benar berhadapan dengan hal ini, tetapi Anda perlu untuk memasukkannya.

556
00:46:54,950 --> 00:47:00,710
>> Mengetahui bahwa setiap nama file memiliki nomor, yang memakan tiga karakter,

557
00:47:00,710 --> 00:47:06,770
dan kemudian jpg,. berapa lama harus array ini menjadi?

558
00:47:09,070 --> 00:47:14,310
Membuang nomor. Berapa banyak karakter dalam judul, dalam nama?

559
00:47:18,090 --> 00:47:26,320
Jadi ada 3 hashtags, periode, jpg. >> [Mahasiswa] 7. >> 7. Tidak cukup.

560
00:47:26,320 --> 00:47:32,000
Kami akan ingin 8 karena kami ingin memungkinkan null terminator juga.

561
00:47:45,340 --> 00:47:49,730
>> Akhirnya, hanya untuk menarik keluar proses yang Anda akan lakukan untuk Recover,

562
00:47:49,730 --> 00:47:55,420
Anda memiliki beberapa informasi awal.

563
00:47:55,420 --> 00:48:02,460
Anda terus sampai Anda menemukan awal dari file JPEG,

564
00:48:02,460 --> 00:48:07,900
dan itu bisa menjadi salah satu dari dua sekuens awal.

565
00:48:07,900 --> 00:48:12,510
Anda terus membaca. Setiap slash di sini mewakili 512 byte.

566
00:48:12,510 --> 00:48:22,630
Anda terus membaca, terus membaca sampai Anda menemukan lain urutan awal.

567
00:48:22,630 --> 00:48:29,790
Setelah Anda memiliki, Anda mengakhiri JPEG saat ini - dalam kasus ini, itu adalah satu merah,

568
00:48:29,790 --> 00:48:31,030
sehingga Anda ingin mengakhiri itu.

569
00:48:31,030 --> 00:48:35,540
Anda ingin sprintf nama itu ke folder pset4 Anda,

570
00:48:35,540 --> 00:48:41,580
maka Anda ingin membuka JPEG baru dan kemudian terus membaca

571
00:48:41,580 --> 00:48:46,370
sampai Anda menemukan berikutnya.

572
00:48:46,370 --> 00:48:49,040
Terus membaca, terus membaca,

573
00:48:49,040 --> 00:48:56,290
dan akhirnya, akhirnya, Anda akan mencapai akhir file,

574
00:48:56,290 --> 00:49:00,360
dan sehingga Anda akan ingin untuk menutup JPEG terakhir yang Anda bekerja dengan,

575
00:49:00,360 --> 00:49:08,380
sprintf yang menjadi folder pset4 Anda, dan kemudian melihat semua gambar yang Anda dapatkan.

576
00:49:08,380 --> 00:49:12,050
Foto-foto itu sebenarnya gambar CS50 staf,

577
00:49:12,050 --> 00:49:16,430
dan jadi ini adalah di mana menyenangkan bonus bagian dari pset datang di

578
00:49:16,430 --> 00:49:26,310
adalah bahwa Anda bersaing dalam bagian Anda untuk menemukan TF dalam gambar

579
00:49:26,310 --> 00:49:34,610
dan mengambil gambar dengan mereka untuk membuktikan bahwa Anda telah melakukan yang pset

580
00:49:34,610 --> 00:49:37,030
dan sehingga Anda dapat melihat mana anggota staf dalam gambar.

581
00:49:37,030 --> 00:49:41,510
Jadi Anda mengambil gambar dengan staf. Kadang-kadang Anda harus mengejar mereka turun.

582
00:49:41,510 --> 00:49:44,680
Mungkin beberapa dari mereka akan mencoba untuk lari dari Anda.

583
00:49:44,680 --> 00:49:47,320
Anda mengambil gambar dengan mereka.

584
00:49:47,320 --> 00:49:51,190
Ini sedang berlangsung. Ini bukan karena saat pset yang sudah jatuh tempo.

585
00:49:51,190 --> 00:49:53,340
Batas waktu akan diumumkan di spec.

586
00:49:53,340 --> 00:49:58,060
Kemudian bersama-sama dengan bagian Anda, mana bagian mengambil gambar yang paling

587
00:49:58,060 --> 00:50:04,430
dengan sebagian besar anggota staf akan memenangkan hadiah cukup mengagumkan.

588
00:50:04,430 --> 00:50:08,890
Itu semacam insentif untuk mendapatkan pset4 Anda selesai secepat mungkin

589
00:50:08,890 --> 00:50:10,820
karena Anda bisa turun ke bisnis

590
00:50:10,820 --> 00:50:14,570
memburu semua berbeda CS50 anggota staf.

591
00:50:14,570 --> 00:50:17,500
Itu tidak wajib, meskipun, jadi setelah Anda mendapatkan gambar,

592
00:50:17,500 --> 00:50:20,310
maka Anda selesai dengan pset4.

593
00:50:20,310 --> 00:50:23,970
>> Dan aku selesai dengan Walkthrough 4, jadi terima kasih semua untuk datang.

594
00:50:23,970 --> 00:50:29,330
Good luck dengan Forensik. [Tepuk tangan]

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