1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Opis przejścia - Set Problem 4]

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

3
00:00:05,000 --> 00:00:07,340
[To jest CS50. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
Dobrze. Witam wszystkich i zapraszamy do Walkthrough 4.

5
00:00:11,670 --> 00:00:14,270
>> Dziś nasza pset jest Forensics.

6
00:00:14,270 --> 00:00:18,080
Sądownictwo jest naprawdę zabawne pset która polega czynienia z plików bitmapowych

7
00:00:18,080 --> 00:00:21,550
aby odkryć kto popełnił zbrodnię.

8
00:00:21,550 --> 00:00:24,200
Następnie jedziemy do rozmiaru kilku bitmap,

9
00:00:24,200 --> 00:00:27,780
to mamy również zamiar poradzić sobie z naprawdę zabawnej części zwanej Recover,

10
00:00:27,780 --> 00:00:31,160
, w którym jesteśmy w zasadzie podał kartę pamięci

11
00:00:31,160 --> 00:00:34,350
w których ktoś przypadkowo usunięte wszystkie swoje pliki,

12
00:00:34,350 --> 00:00:38,860
i jesteśmy proszeni o odzyskanie tych plików.

13
00:00:38,860 --> 00:00:42,910
>> Ale najpierw, zanim dotrzemy do PSET, naprawdę tylko chcę pogratulować wszystkim.

14
00:00:42,910 --> 00:00:45,230
Zaraz się w połowie kursu.

15
00:00:45,230 --> 00:00:50,070
Quiz 0 jest już za nami, a my jesteśmy w pset4, więc zasadniczo, jesteśmy w połowie drogi.

16
00:00:50,070 --> 00:00:55,490
Mamy długą drogę, jeśli spojrzeć do psets, pset0 i pset1,

17
00:00:55,490 --> 00:00:57,300
Gratuluję więc pod uwagę, że

18
00:00:57,300 --> 00:01:00,760
i mamy zamiar dostać się do niektórych rzeczy naprawdę zabawne.

19
00:01:00,760 --> 00:01:07,070
>> Więc nasz przybornik do tego Pset znowu zamiast poleceniem sudo yum-y aktualizacji

20
00:01:07,070 --> 00:01:13,890
jesteśmy w stanie po prostu uruchomić update50 jeśli jesteś w wersji 17.3 lub nowszej z urządzenia.

21
00:01:13,890 --> 00:01:17,380
Więc należy uruchomić update50 - to dużo łatwiejsze, kilka mniej znaków -

22
00:01:17,380 --> 00:01:20,640
upewnić się, że jesteś w najnowszej wersji urządzenia.

23
00:01:20,640 --> 00:01:25,410
Szczególnie ważne jest, aby update50 kiedy zacząć używać CS50 Check.

24
00:01:25,410 --> 00:01:28,700
Więc upewnij się, że możesz to zrobić.

25
00:01:28,700 --> 00:01:30,760
>> Dla wszystkich sekcjach w tym zbior,

26
00:01:30,760 --> 00:01:34,350
będziemy mieć do czynienia z plików wejściowych i wyjściowych, plik I / O.

27
00:01:34,350 --> 00:01:38,140
Będziemy się iść przez wiele programów, które zajmują się tablicami

28
00:01:38,140 --> 00:01:40,350
wskazując na pliki i tego typu rzeczy,

29
00:01:40,350 --> 00:01:43,050
więc chcemy się upewnić, że naprawdę jesteśmy zaznajomieni i wygodne

30
00:01:43,050 --> 00:01:47,990
do czynienia z, jak wejścia i wyjścia na plikach.

31
00:01:47,990 --> 00:01:52,080
>> W kodzie dystrybucji tego pset jest plik o nazwie copy.c,

32
00:01:52,080 --> 00:01:55,280
i to, co mamy zamiar znaleźć będzie bardzo przydatne dla nas

33
00:01:55,280 --> 00:02:00,340
bo będziemy do końca się faktycznie kopiowanie copy.c plik

34
00:02:00,340 --> 00:02:05,350
i tylko lekko zmiany, aby móc uzyskać pierwsze 2 części zestawu problemu.

35
00:02:05,350 --> 00:02:09,030
>> I tak to, jak już wspomniałem wcześniej, mamy do czynienia z bitmapami oraz JPEG.

36
00:02:09,030 --> 00:02:13,170
Tak naprawdę zrozumienie struktury, jak te pliki są zorganizowane,

37
00:02:13,170 --> 00:02:16,170
jak naprawdę możemy przetłumaczyć 0s i 1s w elemencie

38
00:02:16,170 --> 00:02:19,040
i rzeczy, które możemy rzeczywiście zrozumieć i zinterpretować i edytować,

39
00:02:19,040 --> 00:02:21,000
, które będzie bardzo ważne,

40
00:02:21,000 --> 00:02:25,970
więc wchodząc plików JPEG i bitmapowych i zrozumienia struktury tych.

41
00:02:25,970 --> 00:02:30,780
>> Pset4 jak zwykle zaczyna się od części pytania.

42
00:02:30,780 --> 00:02:36,600
Będą zajmować pliku I / O i Ci przyzwyczajeni do tego.

43
00:02:36,600 --> 00:02:42,520
Następnie część 1 jest Whodunit, w którym dostaniemy plik bitmapy

44
00:02:42,520 --> 00:02:45,630
, który wygląda trochę jak czerwone kropki na całym ciele.

45
00:02:45,630 --> 00:02:52,180
A potem po prostu to, co zamierzamy zrobić, to ten plik i tylko lekko go edytować

46
00:02:52,180 --> 00:02:54,010
w wersji, że możemy czytać.

47
00:02:54,010 --> 00:02:56,000
Zasadniczo, po zakończeniu prac, będziemy mieli ten sam plik

48
00:02:56,000 --> 00:03:02,630
chyba, że ​​będziemy w stanie zobaczyć ukrytą wiadomość ukryta przez tych wszystkich kropek czerwonych.

49
00:03:02,630 --> 00:03:07,310
Następnie Resize to program, podany plik

50
00:03:07,310 --> 00:03:11,490
, a następnie z uwagi na nazwę pliku, który wyprowadza a następnie otrzymuje numer, jak również,

51
00:03:11,490 --> 00:03:16,850
będzie faktycznie zmienić rozmiar tej bitmapy przez to wartość całkowitą.

52
00:03:16,850 --> 00:03:19,240
Potem wreszcie mamy Pset odzyskać.

53
00:03:19,240 --> 00:03:24,160
Dane są karty pamięci, a następnie muszą odzyskać wszystkie zdjęcia

54
00:03:24,160 --> 00:03:25,920
przypadkowo usunięte

55
00:03:25,920 --> 00:03:31,420
ale jak nie dowiemy się, właściwie usunięte i usunięte z pliku;

56
00:03:31,420 --> 00:03:38,470
właśnie rodzaju porażka, gdzie byli w pliku, ale mamy zamiar odzyskać to.

57
00:03:38,470 --> 00:03:44,950
>> Great. Więc idzie do pliku I / O w szczególności, są to cała lista funkcji, które będziesz używać.

58
00:03:44,950 --> 00:03:49,840
Widziałeś już trochę podstaw fopen, fread i fwrite,

59
00:03:49,840 --> 00:03:54,350
ale będziemy szukać dalej do jakiegoś pliku funkcje I / O takie jak fputc,

60
00:03:54,350 --> 00:03:56,930
w którym można po prostu napisać jeden znak na raz,

61
00:03:56,930 --> 00:04:02,000
fseek, gdzie można trochę przesunąć wskaźnik pozycji pliku w przód iw tył,

62
00:04:02,000 --> 00:04:05,770
I jeszcze kilka innych. Ale będziemy wchodzić, że nieco później podczas PSET.

63
00:04:08,050 --> 00:04:13,100
>> Więc po pierwsze, po prostu dostać się do pliku I / O, zanim pójdziemy do PSET,

64
00:04:13,100 --> 00:04:19,860
otworzyć plik, na przykład, co musisz zrobić, to faktycznie ustawić wskaźnik do tego pliku.

65
00:04:19,860 --> 00:04:22,710
Więc mamy wskaźnik pliku *.

66
00:04:22,710 --> 00:04:27,140
W tym przypadku, dzwonię to w wskaźnik, ponieważ to będzie mój plik_we.

67
00:04:27,140 --> 00:04:33,340
I tak mam zamiar użyć funkcji fopen, a następnie nazwę pliku

68
00:04:33,340 --> 00:04:36,360
i tryb, w którym będę mieć do czynienia z plikiem.

69
00:04:36,360 --> 00:04:42,080
Więc nie ma "r" w tym przypadku do czytania, "w", do pisania, a następnie "" dla dopisywania.

70
00:04:42,080 --> 00:04:44,270
Na przykład, gdy masz do czynienia z INFILE

71
00:04:44,270 --> 00:04:47,310
i wszystko, co chcesz zrobić, to odczytać bity i bajty zapisane tam,

72
00:04:47,310 --> 00:04:50,420
wtedy pewnie będzie chciał użyć "r" jako tryb.

73
00:04:50,420 --> 00:04:54,520
Gdy chcesz właściwie napisać, niby zrobić nowy plik,

74
00:04:54,520 --> 00:04:57,220
to co mamy zamiar zrobić, to mamy zamiar otworzyć nowy plik

75
00:04:57,220 --> 00:05:02,410
i używać "w" tryb do zapisu.

76
00:05:02,410 --> 00:05:07,540
>> Więc gdy jesteś rzeczywiście czytanie do plików, struktura jest następująca.

77
00:05:07,540 --> 00:05:14,930
Najpierw to wskaźnik do struktury, która będzie zawierać bajtów, które czytasz.

78
00:05:14,930 --> 00:05:19,830
Tak, że będzie to lokalizacja Koniec bajtów czytasz.

79
00:05:19,830 --> 00:05:23,360
Jesteś wtedy zamiar podać wielkość, jak w zasadzie ile bajtów

80
00:05:23,360 --> 00:05:30,100
Twój program powinien czytać w pliku, rozmiar zasadniczo jednym elementem,

81
00:05:30,100 --> 00:05:32,620
a masz zamiar określić, ile elementów chcesz przeczytać.

82
00:05:32,620 --> 00:05:34,980
I w końcu, trzeba wiedzieć, gdzie czytasz z,

83
00:05:34,980 --> 00:05:37,580
tak, że to będzie Twój na wskaźnik.

84
00:05:37,580 --> 00:05:41,780
I kolorami te, ponieważ fread jest również bardzo podobny do fwrite,

85
00:05:41,780 --> 00:05:47,050
chyba chcesz się upewnić, że używasz odpowiedniej kolejności,

86
00:05:47,050 --> 00:05:51,960
upewnij się, że jesteś rzeczywiście zapisu i odczytu z prawego pliku.

87
00:05:54,910 --> 00:05:58,610
>> Tak jak poprzednio, a następnie, jeśli mają rozmiar elementu, jak i liczbę elementów,

88
00:05:58,610 --> 00:06:00,600
wtedy możemy grać tu trochę.

89
00:06:00,600 --> 00:06:06,810
Powiedz, mam struct pies i tak to chcę czytać dwa psy na raz.

90
00:06:06,810 --> 00:06:12,450
Co mogłem zrobić, to powiedzieć rozmiar jednego elementu będzie wielkość jednego psa

91
00:06:12,450 --> 00:06:14,770
i będę rzeczywiście przeczytać dwa.

92
00:06:14,770 --> 00:06:18,290
Ewentualnie, co mogłem zrobić, to powiedzieć, że jestem po prostu się czytać jeden element

93
00:06:18,290 --> 00:06:21,340
i że jednym z elementów będzie wielkość dwóch psów.

94
00:06:21,340 --> 00:06:24,320
Więc to jest analogiczne jak można trochę poeksperymentować z wielkości i liczby

95
00:06:24,320 --> 00:06:28,250
w zależności od tego, co jest bardziej intuicyjna dla Ciebie.

96
00:06:28,250 --> 00:06:30,810
>> Dobrze. Więc teraz mamy do plików pisania.

97
00:06:30,810 --> 00:06:36,880
Gdy chcesz zapisać plik, pierwszy argument jest w rzeczywistości, gdzie czytasz od.

98
00:06:36,880 --> 00:06:42,050
Tak, że w zasadzie dane, które masz zamiar napisać do pliku

99
00:06:42,050 --> 00:06:44,490
które jest z wskaźnik na końcu.

100
00:06:44,490 --> 00:06:47,670
Tak więc, gdy masz do czynienia z PSET, upewnij się, że nie gubi.

101
00:06:47,670 --> 00:06:50,480
Może mieć obok definicji siebie.

102
00:06:50,480 --> 00:06:58,090
Można wyciągnąć definicje w instrukcji wpisując człowieka i fwrite, na przykład,

103
00:06:58,090 --> 00:06:59,950
w terminalu, czy można powrócić do tego slajdu

104
00:06:59,950 --> 00:07:03,570
i upewnij się, że używasz właściwego.

105
00:07:03,570 --> 00:07:08,700
Więc jeszcze raz, dla fwrite, gdy masz plik, który chcesz dodać do,

106
00:07:08,700 --> 00:07:14,290
, że będzie to ostatni argument i że będzie to wskazówka do tego pliku.

107
00:07:14,290 --> 00:07:18,670
Więc to jest to, jak radzimy sobie z pisaniem może kilka bajtów na raz,

108
00:07:18,670 --> 00:07:21,820
ale, że chcesz po prostu napisać w jednym znaku pojedynczym.

109
00:07:21,820 --> 00:07:25,940
Jak zobaczymy później, w tym przykładzie, w bitmap musimy użyć.

110
00:07:25,940 --> 00:07:32,180
To kiedy możemy użyć fputc zasadniczo tylko wprowadzenie jeden znak na raz, chr,

111
00:07:32,180 --> 00:07:37,050
do wskaźnika pliku, a to nasz wskaźnik tam.

112
00:07:38,700 --> 00:07:41,560
Tak więc, gdy szukamy lub zapisu w pliku,

113
00:07:41,560 --> 00:07:44,690
Plik jest śledzenie, gdzie jesteśmy.

114
00:07:44,690 --> 00:07:47,810
Więc jest to rodzaj kursora, wskaźnika pozycji w pliku.

115
00:07:47,810 --> 00:07:54,330
I tak zawsze, kiedy pisać lub czytać ponownie do pliku,

116
00:07:54,330 --> 00:07:56,760
plik rzeczywiście pamięta, gdzie to jest,

117
00:07:56,760 --> 00:07:59,270
i tak dalej, z której znajduje się kursor.

118
00:07:59,270 --> 00:08:03,970
Może to być korzystne, jeśli chcesz, na przykład, czytać w pewnym coś zrobić

119
00:08:03,970 --> 00:08:06,160
i odczytu w poniższej kwoty

120
00:08:06,160 --> 00:08:10,700
ale czasami możemy chcieć wrócić i zacząć od pewnej wartości referencyjnej.

121
00:08:10,700 --> 00:08:16,870
Więc funkcja fseek, co robi jest pozwala przesuwać kursor w określonym pliku

122
00:08:16,870 --> 00:08:19,680
pewna liczba bajtów.

123
00:08:19,680 --> 00:08:24,260
A potem to, co musimy zrobić, to określić, gdzie wartość referencyjna jest.

124
00:08:24,260 --> 00:08:31,520
Więc albo porusza się do przodu lub do tyłu, skąd kursora,

125
00:08:31,520 --> 00:08:35,750
lub można określić, że powinno poruszać się tylko na początku pliku

126
00:08:35,750 --> 00:08:37,090
lub koniec pliku.

127
00:08:37,090 --> 00:08:41,230
I tak można przekazać w wartości ujemne lub dodatnie do kwoty

128
00:08:41,230 --> 00:08:44,960
i że będzie trochę przesunąć kursor do przodu lub do tyłu.

129
00:08:46,170 --> 00:08:51,920
>> Zanim przejdziemy do innych psets, wszelkie pytania na temat pliku I / O?

130
00:08:53,860 --> 00:08:59,990
Okay. Jak dostać się do innych przykładów, nie wahaj się mnie zatrzymać na pytania.

131
00:08:59,990 --> 00:09:06,930
>> Więc w kryminał, jesteś wręczył bitmapy podobną do tej czerwonej na slajdzie,

132
00:09:06,930 --> 00:09:14,510
i wygląda to tak - kilka czerwonych kropek - i naprawdę nie wiem, co jest napisane.

133
00:09:14,510 --> 00:09:23,310
Jeśli zez, możesz być w stanie zobaczyć nieznaczny niebieskawy kolor wewnątrz środku.

134
00:09:23,310 --> 00:09:26,270
Zasadniczo, to gdzie tekst jest przechowywany.

135
00:09:26,270 --> 00:09:30,270
Nie było morderstwo, co się stało, i musimy dowiedzieć się, kto to zrobił.

136
00:09:30,270 --> 00:09:36,760
Aby to zrobić, musimy trochę przekonwertować ten plik na format czytelny.

137
00:09:36,760 --> 00:09:42,740
Jeśli faceci kiedykolwiek spotkałem to, czasami nie będzie małe zestawy

138
00:09:42,740 --> 00:09:48,510
gdzie masz lupę z czerwonej folii. Ktokolwiek? Tak.

139
00:09:48,510 --> 00:09:52,770
Zatem będziesz ręką coś takiego, to masz lupę

140
00:09:52,770 --> 00:09:58,130
z czerwoną folią nad nim, można umieścić go na obrazie,

141
00:09:58,130 --> 00:10:03,410
i może być w stanie zobaczyć wiadomość ukryta w nim.

142
00:10:03,410 --> 00:10:07,080
Nie mamy szkło powiększające z czerwoną folią, więc zamiast będziemy rodzaj stworzyć własne

143
00:10:07,080 --> 00:10:09,060
w tym zbior.

144
00:10:09,060 --> 00:10:15,760
I tak użytkownik będzie whodunit wejściowe, a następnie pojęcia,. Bmp,

145
00:10:15,760 --> 00:10:18,800
tak że jest plik_we, to czerwony komunikat dot,

146
00:10:18,800 --> 00:10:23,550
a potem mówią verdict.bmp będzie nasza outfile.

147
00:10:23,550 --> 00:10:27,900
Tak to się dzieje, aby utworzyć nowy obraz bitmapowy podobny do pojęcia jeden

148
00:10:27,900 --> 00:10:32,600
wyjątkiem w czytelnym formacie, gdzie możemy zobaczyć ukrytą wiadomość.

149
00:10:32,600 --> 00:10:37,550
>> Ponieważ będziemy mieć do czynienia z edycji i manipulacji bitmap pewnego rodzaju,

150
00:10:37,550 --> 00:10:42,400
będziemy rodzaju nurkowania w do struktury tych plików bitmapowych.

151
00:10:42,400 --> 00:10:48,130
Poszliśmy nad tymi trochę mało w wykładzie, ale spójrzmy na nich trochę więcej.

152
00:10:48,130 --> 00:10:51,740
Bitmapy są zasadniczo tylko układ bajtów

153
00:10:51,740 --> 00:10:55,790
gdzie mamy określony, które bajty oznaczają co.

154
00:10:55,790 --> 00:11:00,540
Więc tutaj jest trochę jak z mapą bitmapy

155
00:11:00,540 --> 00:11:08,550
mówiąc, że zaczyna się od niektórych plików nagłówkowych, zaczyna niektóre informacje tam.

156
00:11:08,550 --> 00:11:16,540
Widać, że w około 14 bajtów liczby rozmiar wskazuje na bitmapy,

157
00:11:16,540 --> 00:11:18,520
i nadal się.

158
00:11:18,520 --> 00:11:23,810
Ale co tak naprawdę interesuje tu zaczyna wokół bajtowej liczby 54.

159
00:11:23,810 --> 00:11:26,060
Mamy te trójek RGB.

160
00:11:26,060 --> 00:11:30,760
Co się dzieje, że do zrobienia jest zawierać rzeczywistych pikseli, wartości kolorów.

161
00:11:30,760 --> 00:11:35,950
Wszystko powyżej, że w nagłówku jest kilka informacji

162
00:11:35,950 --> 00:11:41,240
odpowiada wielkości obrazu, szerokość obrazu, i wysokości.

163
00:11:41,240 --> 00:11:44,930
Kiedy idziemy do obicia później zobaczymy dlaczego rozmiar obrazka

164
00:11:44,930 --> 00:11:48,670
mogą być inne niż szerokości i wysokości.

165
00:11:48,670 --> 00:11:54,240
Więc do reprezentowania tych - te bitmapy są ciągami bajtów -

166
00:11:54,240 --> 00:11:59,370
co możemy zrobić, to powiedzieć, dobrze, będę pamiętać, że w indeksie 14,

167
00:11:59,370 --> 00:12:03,380
to, gdzie rozmiar jest, na przykład, ale zamiast tego, co zamierzamy zrobić, aby to ułatwić

168
00:12:03,380 --> 00:12:06,020
jest ująć go w struktury.

169
00:12:06,020 --> 00:12:08,880
A więc mamy dwa przypisać struktury stworzone dla nas, BITMAPFILEHEADER

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

171
00:12:10,440 --> 00:12:14,840
i tak, gdy czytamy w tym pliku, domyślnie będzie to będzie w porządku,

172
00:12:14,840 --> 00:12:22,360
i tak w porządku to też będzie wypełnić do zmiennych takich jak biWidth i biSize.

173
00:12:25,270 --> 00:12:31,230
I w końcu, każdy piksel reprezentuje trzy bajty.

174
00:12:31,230 --> 00:12:35,500
Pierwszym z nich jest ilość niebieskiego piksela, drugi ilość zieleni

175
00:12:35,500 --> 00:12:41,120
I w końcu, ilość czerwonych, gdzie 0 jest zasadniczo nie ma zielone niebieskie lub czerwone lub nie

176
00:12:41,120 --> 00:12:43,720
ff i maksymalną wartość.

177
00:12:43,720 --> 00:12:46,800
Są to wartości szesnastkowe.

178
00:12:46,800 --> 00:12:53,870
Więc jeśli mamy FF0000, to odpowiada maksymalnej ilości niebiesko

179
00:12:53,870 --> 00:12:58,890
a nie zielony i nie czerwony, więc wtedy, że nam się niebieski piksel.

180
00:12:58,890 --> 00:13:04,190
Następnie, jeśli mamy FF całej płyty, to znaczy, że mają biały piksel.

181
00:13:04,190 --> 00:13:11,370
Jest to rodzaj przeciwieństwie do zwykle, kiedy mówimy, RGB. To się naprawdę dzieje BGR.

182
00:13:12,750 --> 00:13:18,990
>> Jeśli więc faktycznie spojrzeć przykład bitmapy - pozwól mi wyciągnąć jeden tutaj.

183
00:13:31,560 --> 00:13:33,830
To jest trochę małe.

184
00:13:39,890 --> 00:13:47,840
Jestem powiększanie, i widzimy to piksele. To wygląda jak bloki koloru.

185
00:13:47,840 --> 00:13:50,110
Masz białe bloki, a następnie czerwone bloki.

186
00:13:50,110 --> 00:13:53,700
Jeśli grasz w Microsoft Paint, na przykład, można zrobić coś takiego

187
00:13:53,700 --> 00:13:58,960
by w zasadzie tylko malowanie niektórych kwadratów w określonej kolejności.

188
00:13:58,960 --> 00:14:08,060
Tak więc to, co przekłada się w mapie bitowej jest następujący.

189
00:14:08,060 --> 00:14:15,710
Tutaj mamy pierwszy biały piksele, że wszystkie 6 są f-tych, a następnie mamy czerwone piksele,

190
00:14:15,710 --> 00:14:19,910
wskazany przez 0000FF.

191
00:14:19,910 --> 00:14:27,940
I tak sekwencji bajtów, które musimy wskazuje obraz bitmapowy będzie wyglądać.

192
00:14:27,940 --> 00:14:32,230
Więc to, co zrobiłem tutaj jest tylko napisane te wszystkie bajty, a następnie barwione w czerwony

193
00:14:32,230 --> 00:14:37,550
tak, że można trochę zobaczyć, jeśli zez trochę, jak tego rodzaju wskazuje na buźkę.

194
00:14:40,180 --> 00:14:46,390
>> Sposób, że obraz bitmapowy praca jest mi wyobrazić sobie, że w zasadzie w postaci siatki.

195
00:14:46,390 --> 00:14:54,940
I tak domyślnie, każdy wiersz siatki musi być wielokrotność 4 bajtów.

196
00:15:00,520 --> 00:15:07,060
Jeśli spojrzymy na obraz bitmapowy, jesteś wypełnienie każdej wartości.

197
00:15:07,060 --> 00:15:17,370
Na przykład, możesz mieć tu czerwony, zielony tu, niebieski tutaj,

198
00:15:17,370 --> 00:15:24,950
ale musisz upewnić się, że obraz jest wypełniona wielokrotności czterech bajtów.

199
00:15:24,950 --> 00:15:32,200
Więc jeśli chcę mój obraz, aby być trzy bloki szerokości, to chciałbym umieścić pustą wartość

200
00:15:32,200 --> 00:15:35,640
w tej ostatniej, aby to przez cztery.

201
00:15:35,640 --> 00:15:39,530
Więc chciałbym dodać w coś, co my wywołującego dopełnienie.

202
00:15:39,530 --> 00:15:43,750
Idę tylko do wskazania, że ​​tam z x.

203
00:15:44,920 --> 00:15:54,160
Teraz, że chcemy obraz o 7 pikseli długo, na przykład.

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

205
00:16:04,750 --> 00:16:07,000
i wszystko to jest wypełnione kolorem.

206
00:16:07,000 --> 00:16:10,620
Sposób, że bitmapy pracy jest to, że musimy 8..

207
00:16:10,620 --> 00:16:12,460
W tej chwili mamy 1, 2, 3, 4, 5, 6, 7.

208
00:16:12,460 --> 00:16:19,360
Musimy 8 przestrzenie dla bitmapy, aby przeczytać poprawnie.

209
00:16:19,360 --> 00:16:25,600
Tak więc to, co mamy zrobić, to dodać tylko trochę wyściółki

210
00:16:25,600 --> 00:16:29,430
aby upewnić się, że wszystkie są jednolite szerokościach

211
00:16:29,430 --> 00:16:34,260
oraz, że wszystkie są szerokości przez 4.

212
00:16:42,110 --> 00:16:47,310
I tak wcześniej wskazano, wypychanie jako x lub falowane linii,

213
00:16:47,310 --> 00:16:53,880
ale w rzeczywistych obrazów bitmapowych wyściółka jest wskazywany przez 0 szesnastkowym.

214
00:16:53,880 --> 00:16:57,340
Więc to będzie pojedynczy znak, 0.

215
00:16:58,980 --> 00:17:06,329
Co może się przydać jest xxd polecenia.

216
00:17:06,329 --> 00:17:11,220
Co robi jest rzeczywiście pokazuje, jak podobne do tego, co robiłem wcześniej z buźki

217
00:17:11,220 --> 00:17:15,630
kiedy faktycznie wydrukowane, co każdy kolor będzie dla piksela

218
00:17:15,630 --> 00:17:21,800
i kolorami to po uruchomieniu xxd z następujących poleceń,

219
00:17:21,800 --> 00:17:28,670
wtedy rzeczywiście wydrukować co kolory są dla tych pikseli.

220
00:17:28,670 --> 00:17:33,810
Co trzeba zrobić, to tutaj wskazać, podobnie jak 54-s

221
00:17:33,810 --> 00:17:36,530
mówi, że mam zamiar rozpocząć na 54. bajcie

222
00:17:36,530 --> 00:17:40,820
bo przed tym, należy pamiętać, jeśli spojrzymy na mapę z map bitowych

223
00:17:40,820 --> 00:17:42,690
to wszystko informacje nagłówka i rzeczy w tym stylu.

224
00:17:42,690 --> 00:17:46,280
Ale to, co naprawdę dbają o to rzeczywiste piksele, które wskazują na kolor.

225
00:17:46,280 --> 00:17:52,700
Tak więc, dodając w tym flagi-s 54, to jesteśmy w stanie wyświetlić wartości kolorów.

226
00:17:52,700 --> 00:17:56,020
I nie martw się o skomplikowanych flag i tego typu rzeczy.

227
00:17:56,020 --> 00:18:05,020
W specyfikacji zestaw problemów, będziesz miał wskazówek co do sposobu korzystania xxd do wyświetlania pikseli.

228
00:18:07,070 --> 00:18:15,590
Więc jeśli tu widzisz, to niby wygląda na zielonym polu, to coś mały.

229
00:18:15,590 --> 00:18:23,610
I już kolorami w 00FF00 jako zasadniczo mówiąc nie niebieski, dużo zieleni, a nie czerwony.

230
00:18:23,610 --> 00:18:26,370
Tak, że odpowiada na zielony.

231
00:18:26,370 --> 00:18:31,920
Jak widać tutaj, widzimy zielony prostokąt.

232
00:18:31,920 --> 00:18:36,660
Ten zielony prostokąt jest tylko 3 pikseli szerokości, tak to, co mamy do zrobienia

233
00:18:36,660 --> 00:18:44,350
aby upewnić się, że obraz jest wielokrotnością 4 szerokości, to dodać w dodatkowym obiciem.

234
00:18:44,350 --> 00:18:49,460
I tak to jest to, jak widzisz te 0s tutaj.

235
00:18:49,460 --> 00:18:54,510
To rzeczywiście będzie wynik Twojej Pset Resize,

236
00:18:54,510 --> 00:19:01,350
zasadniczo biorąc małą bitmapę, a następnie rozszerzenie go przez 4.

237
00:19:01,350 --> 00:19:09,380
A więc to, co widzimy, jest to, że w rzeczywistości ten obraz jest 12 pikseli szerokości, ale 12 jest wielokrotnością 4,

238
00:19:09,380 --> 00:19:12,940
i tak naprawdę nie widzę żadnych 0s na końcu, bo nie trzeba już dodawać

239
00:19:12,940 --> 00:19:19,070
ponieważ jest w pełni wyściełane. To nie ma żadnych więcej miejsca.

240
00:19:20,720 --> 00:19:23,470
>> Okay. Wszelkie pytania dotyczące dopełnienia?

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

242
00:19:27,460 --> 00:19:32,520
>> Jak już wspomniano wcześniej, bitmapy są tylko ciąg bajtów.

243
00:19:32,520 --> 00:19:39,170
A więc to, co mamy, to zamiast konieczności śledzić dokładnie który to numer bajtu

244
00:19:39,170 --> 00:19:47,050
odpowiada do określonego elementu, faktycznie stworzyli struct do reprezentowania tego.

245
00:19:47,050 --> 00:19:50,930
Więc co mamy jest RGBTRIPLE struct.

246
00:19:50,930 --> 00:19:54,590
Gdy masz instancję RGB potrójne,

247
00:19:54,590 --> 00:20:00,970
ponieważ jest to typ zdefiniować struct, a następnie można przejść do rgbtBlue zmienną,

248
00:20:00,970 --> 00:20:09,520
Podobnie zielone i czerwone zmienne, które wskazują, jak bardzo niebieski, zielony, czerwony,

249
00:20:09,520 --> 00:20:11,580
odpowiednio, masz.

250
00:20:11,580 --> 00:20:16,800
>> Więc jeśli mamy niebieski zestaw zmienną na 0, zielony zestaw do FF

251
00:20:16,800 --> 00:20:22,060
która jest maksymalna wartość może mieć, a następnie czerwony zmienna ustawiona na 0,

252
00:20:22,060 --> 00:20:27,870
co wtedy kolor będzie ten konkretny RGB potrójny reprezentuje? >> [Uczeń] Green.

253
00:20:27,870 --> 00:20:29,150
Green. Dokładnie.

254
00:20:29,150 --> 00:20:34,480
To będzie przydatne wiedzieć, że gdy masz instancję RGB potrójne,

255
00:20:34,480 --> 00:20:41,340
rzeczywiście można przejść ilość kolorów - niebieski, zielony i czerwony - oddzielnie.

256
00:20:43,350 --> 00:20:54,900
>> Teraz, że rozmawialiśmy o strukturze, że rzućmy okiem na plik BMP.

257
00:20:54,900 --> 00:20:57,870
Są kodowanym dla Ciebie.

258
00:20:57,870 --> 00:21:01,820
Tutaj mamy struct BITMAPFILEHEADER.

259
00:21:01,820 --> 00:21:07,610
Interesująca jest rozmiar.

260
00:21:07,610 --> 00:21:12,660
Później mamy informację nagłówka, który ma jeszcze kilka rzeczy, które są interesujące dla nas,

261
00:21:12,660 --> 00:21:15,480
czyli wielkość, szerokości i wysokości.

262
00:21:15,480 --> 00:21:19,170
Jak pójdziemy na później, kiedy czytasz w do pliku,

263
00:21:19,170 --> 00:21:25,500
automatycznie odczytuje bo mamy ustawić kolejność jest taka sama.

264
00:21:25,500 --> 00:21:31,990
Więc biSize będzie zawierać odpowiednie bajty odpowiadające rzeczywistej wielkości obrazu.

265
00:21:34,700 --> 00:21:40,500
I to tutaj, na koniec, jak rozmawialiśmy o, mamy RGBTRIPLE typedef struct.

266
00:21:40,500 --> 00:21:46,840
Mamy rgbtBlue, zielony i czerwony z nim związane.

267
00:21:48,210 --> 00:21:49,340
>> Great. Okay.

268
00:21:49,340 --> 00:21:56,360
Teraz, kiedy rozumiemy bitmap trochę, zrozumieć, że mamy nagłówek pliku

269
00:21:56,360 --> 00:22:00,790
i nagłówek informacji związanych z nim, a następnie po tym, mamy ciekawe rzeczy

270
00:22:00,790 --> 00:22:05,110
z kolorów, a te kolory są reprezentowane przez RGBTRIPLE elemencie,

271
00:22:05,110 --> 00:22:12,710
a te z kolei są trzy wartości związane z niebieskie, zielone i czerwone.

272
00:22:12,710 --> 00:22:17,270
>> Więc teraz możemy trochę myślę o Przypomnij trochę.

273
00:22:17,270 --> 00:22:20,130
Przepraszam. Pomyśl o kryminał.

274
00:22:20,130 --> 00:22:25,750
Gdy mamy nasz plik wskazówkę, a potem to, co chcemy zrobić, to czytać w jej piksel po pikselu

275
00:22:25,750 --> 00:22:33,860
a potem jakoś zmienić te piksele tak, że możemy wyprowadzić go w czytelnej formie.

276
00:22:33,860 --> 00:22:41,020
I tak do wyprowadzania go, mamy zamiar napisać piksel po pikselu do verdict.bmp pliku.

277
00:22:41,020 --> 00:22:45,120
To trochę dużo do zrobienia. Zdajemy sobie sprawę, że.

278
00:22:45,120 --> 00:22:49,860
Więc, co zrobiliśmy to my faktycznie ci z copy.c.

279
00:22:49,860 --> 00:22:57,610
Co copy.c nie tylko tworzy dokładną kopię danego pliku mapy bitowej, a następnie wysyła go.

280
00:22:57,610 --> 00:23:01,900
Więc to już otwiera plik dla Ciebie, czyta w piksel po pikselu,

281
00:23:01,900 --> 00:23:04,510
a następnie zapisuje go do pliku wyjściowego.

282
00:23:04,510 --> 00:23:07,080
>> Rzućmy okiem na to.

283
00:23:13,390 --> 00:23:18,290
To jest zapewnienie właściwego użytkowania,

284
00:23:18,290 --> 00:23:22,640
uzyskanie nazw tutaj.

285
00:23:22,640 --> 00:23:29,940
Co to znaczy, że plik wejściowy ustawia się co my przekazany w INFILE tutaj

286
00:23:29,940 --> 00:23:34,750
który jest nasz drugi argument wiersza poleceń.

287
00:23:34,750 --> 00:23:37,640
Sprawdza się upewnić, że możemy otworzyć plik.

288
00:23:38,960 --> 00:23:44,860
Sprawdza, czy możemy zrobić nowy outfile tutaj.

289
00:23:45,630 --> 00:23:53,270
To co robi to tutaj, to po prostu w zasadzie zaczyna czytać w do plików graficznych od początku.

290
00:23:53,270 --> 00:23:56,700
Początki, jak wiadomo, zawiera BITMAPFILEHEADER,

291
00:23:56,700 --> 00:24:03,200
i tak te sekwencje bitów będzie bezpośrednio wypełnić BITMAPFILEHEADER.

292
00:24:03,200 --> 00:24:07,940
Więc co mamy tutaj jest powiedzenie, że BITMAPFILEHEADER BF -

293
00:24:07,940 --> 00:24:13,150
To nasza nowa zmienna BITMAPFILEHEADER typu -

294
00:24:13,150 --> 00:24:22,560
mamy zamiar umieścić wewnątrz bf, co czytamy w od wskaźnika, który jest naszym plik_we.

295
00:24:22,560 --> 00:24:23,970
Jak dużo czytamy?

296
00:24:23,970 --> 00:24:32,160
Czytamy w ile bajtów musimy zawierać cały BITMAPFILEHEADER.

297
00:24:32,160 --> 00:24:34,660
Podobnie, to co możemy zrobić w nagłówku info.

298
00:24:34,660 --> 00:24:39,010
Więc jesteśmy nadal wzdłuż naszego pliku w INFILE,

299
00:24:39,010 --> 00:24:44,360
i czytasz te bity i bajty, a my podłączając je bezpośrednio w

300
00:24:44,360 --> 00:24:47,880
do tych wystąpień zmiennych czyni, że jesteśmy.

301
00:24:49,370 --> 00:24:53,800
Tu po prostu upewnić się, że bitmapa jest bitmap.

302
00:24:57,670 --> 00:25:01,030
>> Teraz mamy outfile, prawda?

303
00:25:01,030 --> 00:25:04,420
Tak, to oznacza, gdy go utworzyć, jest zasadniczo puste.

304
00:25:04,420 --> 00:25:07,710
Musimy więc w zasadzie stworzyć nową bitmapę od podstaw.

305
00:25:07,710 --> 00:25:12,280
Co możemy zrobić, to musimy się upewnić, że możemy skopiować w nagłówku pliku

306
00:25:12,280 --> 00:25:16,850
i nagłówek informacji podobnie jak INFILE ma.

307
00:25:16,850 --> 00:25:22,850
Co możemy zrobić, to możemy napisać - i pamiętaj, że bf jest zmienna

308
00:25:22,850 --> 00:25:29,300
z BITMAPFILEHEADER typu, więc to, co możemy zrobić, to po prostu użyć tej treści

309
00:25:29,300 --> 00:25:34,980
napisać do outfile.

310
00:25:36,550 --> 00:25:38,510
Tutaj należy pamiętać, rozmawialiśmy o obicia,

311
00:25:38,510 --> 00:25:47,820
jak ważne jest, aby upewnić się, że ilość pikseli, które mamy jest wielokrotnością 4.

312
00:25:47,820 --> 00:25:52,790
Jest to całkiem przydatne wzór do obliczenia, ile masz wyściółka

313
00:25:52,790 --> 00:25:57,670
podana szerokość pliku.

314
00:25:57,670 --> 00:26:04,120
Chcę wam przypomnieć, że w copy.c mamy formułę obliczania dopełnienie.

315
00:26:04,120 --> 00:26:07,970
Okay? Więc wszyscy pamiętać. Great.

316
00:26:07,970 --> 00:26:14,050
Więc co robi następny copy.c jest to iteruje wszystkie scanlines.

317
00:26:14,050 --> 00:26:23,730
Przechodzi przez wiersze, a potem zapisuje każdy potrójny, że czyta

318
00:26:23,730 --> 00:26:26,920
, a następnie zapisuje się plik wyjściowy.

319
00:26:26,920 --> 00:26:33,120
Więc tutaj mamy tylko jedno czytanie RGB Triple w czasie

320
00:26:33,120 --> 00:26:39,860
a następnie wprowadzenie tego samego Triple do outfile.

321
00:26:41,120 --> 00:26:48,340
Najtrudniejsze jest to, że nie jest to dopełnienie RGB potrójne,

322
00:26:48,340 --> 00:26:55,200
i tak nie możemy przeczytać, że ilość dopełnienia trójek RGB.

323
00:26:55,200 --> 00:27:01,460
Co mamy zrobić, to faktycznie tylko przenieść nasz wskaźnik pozycji pliku, przenieść nasz kursor,

324
00:27:01,460 --> 00:27:06,840
do rodzaju przejść nad całą wyściółkę tak, że jesteśmy w następnym wierszu.

325
00:27:06,840 --> 00:27:12,990
I co wtedy robi to jest kopia pokazuje jak można dodać dopełnienie.

326
00:27:12,990 --> 00:27:14,990
Więc mamy obliczyć ile wyściółka musimy,

327
00:27:14,990 --> 00:27:18,220
więc to oznacza, że ​​musimy wiele wypychanie 0s.

328
00:27:18,220 --> 00:27:24,510
Co to znaczy dla pętli, który stawia szereg wypychanie 0s do naszego outfile.

329
00:27:24,510 --> 00:27:31,170
I wreszcie, można zamknąć oba pliki. Zamknięciu INFILE jak również OUTFILE.

330
00:27:31,170 --> 00:27:34,870
>> Więc tak copy.c prace,

331
00:27:34,870 --> 00:27:37,430
i że będzie to całkiem użyteczne.

332
00:27:39,720 --> 00:27:43,750
Zamiast faktycznie bezpośrednio skopiowanie i wklejenie

333
00:27:43,750 --> 00:27:46,800
lub po prostu patrząc na to i wpisując, co chcesz,

334
00:27:46,800 --> 00:27:49,440
może po prostu chcesz wykonać to polecenie w terminalu,

335
00:27:49,440 --> 00:27:54,520
cp copy.c whodunit.c, która stworzy nowy plik whodunit.c,

336
00:27:54,520 --> 00:27:58,330
, który zawiera dokładnie taką samą treść jak kopiowania.

337
00:27:58,330 --> 00:28:03,880
Tak więc, co możemy zrobić, to użyć tego jako ramy, na której można budować i edytować

338
00:28:03,880 --> 00:28:06,900
dla naszego pliku kryminalną.

339
00:28:08,500 --> 00:28:14,670
>> Są to nasze do-dos zrobić na kryminał, ale to co robi copy.c

340
00:28:14,670 --> 00:28:16,730
faktycznie dba o większość z nich dla nas.

341
00:28:16,730 --> 00:28:21,900
Więc wszystko, co musimy zrobić, to zmienić rozdzielczość, ile potrzeba

342
00:28:21,900 --> 00:28:25,920
aby rzeczywiście zrobić plik czytelny.

343
00:28:25,920 --> 00:28:32,960
Należy pamiętać, że dla danego piksela potrójnej, więc dla danego typu RGBTRIPLE zmiennej,

344
00:28:32,960 --> 00:28:35,990
można uzyskać dostęp do niebieski, zielony, czerwony i wartości.

345
00:28:35,990 --> 00:28:38,670
Że zamierza się przyda, bo jeśli można z nich korzystać,

346
00:28:38,670 --> 00:28:41,770
to oznacza, że ​​można również sprawdzić ich

347
00:28:41,770 --> 00:28:45,430
a to oznacza, że ​​można również zmienić.

348
00:28:45,430 --> 00:28:49,430
>> Więc kiedy wróciliśmy do naszego czerwonego np. lupy,

349
00:28:49,430 --> 00:28:53,390
zasadzie, że działał jako swego rodzaju filtr dla nas.

350
00:28:53,390 --> 00:28:58,160
Więc to, co chcemy zrobić, to chcemy, aby filtrować wszystkie trójek, które nadchodzą w.

351
00:28:58,160 --> 00:29:01,240
Istnieje kilka różnych sposobów, aby to zrobić.

352
00:29:01,240 --> 00:29:07,100
Zasadniczo, można mieć, niezależnie od typu filtru chcesz.

353
00:29:07,100 --> 00:29:09,890
Może chcesz zmienić wszystkie czerwone piksele

354
00:29:09,890 --> 00:29:13,570
a może chcesz zmienić inny piksel koloru na inny kolor.

355
00:29:13,570 --> 00:29:15,400
To zależy od Ciebie.

356
00:29:15,400 --> 00:29:19,580
Pamiętaj, że możesz sprawdzić, jaki kolor piksela jest

357
00:29:19,580 --> 00:29:23,000
a następnie można również zmienić go jak przechodzisz.

358
00:29:24,410 --> 00:29:26,420
>> Okay. Więc to Whodunit.

359
00:29:26,420 --> 00:29:32,760
Po uruchomieniu kryminał, będziesz wiedzieć, kto sprawcą zbrodni był.

360
00:29:32,760 --> 00:29:35,540
>> Teraz mamy zamiar iść do zmiany rozmiaru.

361
00:29:35,540 --> 00:29:37,990
Będziemy nadal mieć do czynienia z bitmapami.

362
00:29:37,990 --> 00:29:40,750
Co mamy zamiar zrobić, to będziemy mieć bitmapę wejściowego

363
00:29:40,750 --> 00:29:45,890
a następnie będziemy przechodzić w szeregu, a następnie uzyskać OUTFILE bitmapy

364
00:29:45,890 --> 00:29:51,380
gdzie to jest w zasadzie nasza plik_we skalowane przez n.

365
00:29:54,670 --> 00:30:01,450
Powiedz mój plik był tylko jeden piksel duże.

366
00:30:01,450 --> 00:30:09,100
Następnie, jeśli n to 3, skalowanie przez 3, to chciałbym powtórzyć, że piksel n ilość razy,

367
00:30:09,100 --> 00:30:14,410
tak 3 razy, a następnie również skalować go 3 razy, jak również.

368
00:30:14,410 --> 00:30:17,840
Więc widzisz, że skalowanie w pionie jak iw poziomie.

369
00:30:17,840 --> 00:30:19,680
>> I to tu jest przykład.

370
00:30:19,680 --> 00:30:27,590
Jeśli n = 2, widać, że pierwszy niebieski pixel nie powtarza się dwa razy

371
00:30:27,590 --> 00:30:30,930
poziomo, jak i dwa razy w pionie.

372
00:30:30,930 --> 00:30:38,040
A potem, że wciąż dalej, i tak masz bezpośredni skalowanie oryginalnego obrazu przez dwa.

373
00:30:40,920 --> 00:30:47,600
>> Więc gdybyśmy szczegółowo Pseudokod za to, że chcemy otworzyć plik.

374
00:30:47,600 --> 00:30:49,880
A potem, wiedząc, że jeśli wrócimy tutaj,

375
00:30:49,880 --> 00:30:54,540
widzimy, że szerokość w outfile będzie inna niż szerokość na INFILE.

376
00:30:54,540 --> 00:30:56,130
Co to znaczy?

377
00:30:56,130 --> 00:31:01,230
To oznacza, że ​​nasz nagłówek ulegnie zmianie.

378
00:31:01,230 --> 00:31:03,790
A więc to, co my chcemy zrobić to zaktualizować informacje nagłówka,

379
00:31:03,790 --> 00:31:11,820
wiedząc, że gdy czytamy w aktach, jeśli działa na copy.c ramach

380
00:31:11,820 --> 00:31:17,570
mamy już zmienną wskazującą na rozmiar jest i takie rzeczy.

381
00:31:17,570 --> 00:31:24,060
Więc kiedy już to, co możesz zrobić, to zmienić te poszczególne zmienne.

382
00:31:24,060 --> 00:31:29,380
Pamiętaj, że jeśli masz struct, jak uzyskać dostęp do zmiennych w tym.

383
00:31:29,380 --> 00:31:32,080
Możesz użyć operatora kropki, prawda?

384
00:31:32,080 --> 00:31:36,420
Tak więc przy użyciu tego, wiesz, że będziesz musiał zmienić informacje nagłówka.

385
00:31:36,480 --> 00:31:41,030
Tak tu jest tylko lista samych elementów, które będą się zmieniać w pliku.

386
00:31:41,030 --> 00:31:45,180
Rozmiar pliku będzie się zmieniać, obraz, jak również szerokość i wysokość.

387
00:31:45,180 --> 00:31:50,080
Więc wracając do mapy z map bitowych

388
00:31:50,080 --> 00:31:57,730
patrzeć czy to nagłówek pliku lub nagłówka informacji, który zawiera takie informacje

389
00:31:57,730 --> 00:32:00,920
, a następnie w razie potrzeby zmiany.

390
00:32:05,010 --> 00:32:12,470
Znowu, powiedzmy cp copy.c resize.c.

391
00:32:12,470 --> 00:32:19,270
To oznacza, że ​​teraz resize.c zawiera wszystko, co jest zawarte wewnątrz kopii

392
00:32:19,270 --> 00:32:24,490
ponieważ kopia daje nam sposób na czytanie w każdej linii skanowania piksel po pikselu.

393
00:32:24,490 --> 00:32:29,860
Lecz teraz, a nie tylko zmianę wartości tak jak my w kryminał,

394
00:32:29,860 --> 00:32:37,980
co chcemy zrobić, to chcemy zapisywać w kilku pikseli

395
00:32:37,980 --> 00:32:43,580
ile nasz n jest większe niż 1.

396
00:32:43,580 --> 00:32:47,110
>> Wtedy to, co chcemy zrobić, to chcemy rozciągnąć poziomo przez n,

397
00:32:47,110 --> 00:32:50,490
a także rozciągają się pionowo przez n.

398
00:32:50,490 --> 00:32:52,710
W jaki sposób możemy to zrobić?

399
00:32:52,710 --> 00:32:56,890
Wypowiedz n oznacza 2, a masz ten podany INFILE.

400
00:32:56,890 --> 00:32:58,730
Kursor ma się rozpocząć w pierwszej,

401
00:32:58,730 --> 00:33:03,530
i co chcesz zrobić, gdy n oznacza 2, aby wydrukować w 2 z nich.

402
00:33:03,530 --> 00:33:05,490
Więc drukować w 2 z nich.

403
00:33:05,490 --> 00:33:10,830
Następnie kursor będzie przejść do kolejnego piksela, która jest czerwona,

404
00:33:10,830 --> 00:33:18,400
i to będzie wydrukować 2 z tych czerwonych, dodając ją na to, co się stało wcześniej.

405
00:33:18,400 --> 00:33:26,280
Następnie kursor przesunie się do następnego piksela i zwrócić w 2 z nich.

406
00:33:26,280 --> 00:33:37,180
Jeśli spojrzeć wstecz na copy.c ram, co to robi tutaj

407
00:33:37,180 --> 00:33:42,830
jest to tworzy nową instancję RGB Trzyosobowy, nową zmienną o nazwie trzyosobowych.

408
00:33:42,830 --> 00:33:50,500
I tutaj, gdy wczytuje do niego, odczytuje z plik_we 1 RGBTRIPLE

409
00:33:50,500 --> 00:33:53,470
i zapisuje go w środku tej potrójnej zmiennej.

410
00:33:53,470 --> 00:33:57,590
Więc faktycznie masz zmienną reprezentującą ten konkretny piksel.

411
00:33:57,590 --> 00:34:05,290
Potem, kiedy piszesz, co możesz zrobić, to wstawcie do fwrite oświadczenie w pętli for

412
00:34:05,290 --> 00:34:11,080
który zapisuje go do outfile tyle razy, ile potrzeba.

413
00:34:17,449 --> 00:34:20,100
To jest dość proste.

414
00:34:20,200 --> 00:34:27,590
Wystarczy w zasadzie powtórzenie procesu pisania n liczbę razy go skalować poziomo.

415
00:34:27,590 --> 00:34:32,969
>> Ale wtedy musimy pamiętać, że nasze dopełnienie się zmieni.

416
00:34:47,350 --> 00:34:53,020
Wcześniej mieliśmy coś powiedzieć o długości 3.

417
00:34:53,020 --> 00:35:00,130
Wtedy po prostu dodać w ile dopełnienie? Jeszcze tylko jedno, aby to wielokrotność 4.

418
00:35:00,130 --> 00:35:10,480
Ale powiedzieć, że jesteśmy skalowania tego konkretnego obrazu przez n = 2.

419
00:35:10,480 --> 00:35:16,300
Więc ile niebieski pikseli mielibyśmy na końcu? Mielibyśmy 6.

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

421
00:35:21,470 --> 00:35:26,580
6 nie jest wielokrotnością 4. Co znajduje się najbliższa wielokrotność 4? Że będzie to 8.

422
00:35:26,580 --> 00:35:33,200
Więc jesteśmy naprawdę będziemy mieć 2 znaki wyściółką tam.

423
00:35:33,200 --> 00:35:38,720
>> Czy ktoś pamięta, jeśli mamy na wyliczenie dopełnienia

424
00:35:38,720 --> 00:35:41,350
i gdzie to może być?

425
00:35:41,350 --> 00:35:45,160
[Niesłyszalne reakcja studentów] >> Tak, copy.c. Racja.

426
00:35:45,160 --> 00:35:49,800
Istnieje formuła w copy.c obliczyć, ile masz wyściółka

427
00:35:49,800 --> 00:35:53,810
przy określonym szerokość bitmapy.

428
00:35:53,810 --> 00:36:02,950
Tak więc, że będzie to przydatne, gdy trzeba dodać w pewnym wyściółką

429
00:36:02,950 --> 00:36:06,160
rzeczywiście dowiedzieć się, ile wyściółka trzeba dodać.

430
00:36:10,820 --> 00:36:15,850
Ale jedna uwaga, jest jednak to, że chcesz, aby upewnić się, że używasz odpowiedniego rozmiaru.

431
00:36:15,850 --> 00:36:21,410
Tylko uważaj, bo jesteś po prostu będzie do czynienia z dwoma bitmapy.

432
00:36:21,410 --> 00:36:23,410
Chcesz, aby upewnić się, że używasz właściwego.

433
00:36:23,410 --> 00:36:26,820
Kiedy obliczania dopełnienie dla outfile, chcesz używać szerokość outfile

434
00:36:26,820 --> 00:36:29,860
i nie szerokości poprzedniego.

435
00:36:29,860 --> 00:36:37,240
>> Great. Tego rodzaju zajmuje rozciąganie całego obrazu bitmapy w poziomie.

436
00:36:37,240 --> 00:36:41,290
Ale to, co chcemy zrobić, jest faktycznie rozciągnąć go w pionie, jak również.

437
00:36:41,290 --> 00:36:48,760
To będzie trochę trudniejsze, bo gdy skończymy kopiowanie wiersz

438
00:36:48,760 --> 00:36:51,580
i pisania tego wiersza, nasz kursor będzie na końcu.

439
00:36:51,580 --> 00:36:56,210
Więc jeśli czytamy ponownie, to jest to po prostu się czytać do następnego wiersza.

440
00:36:56,210 --> 00:37:03,660
Więc to, co chcemy zrobić, to rodzaj znaleźć jakiś sposób na skopiowanie tych wierszy ponownie

441
00:37:03,660 --> 00:37:12,500
lub po prostu rodzaj biorąc ten wiersz, a następnie przepisanie go ponownie.

442
00:37:14,380 --> 00:37:17,940
Jak rodzaj wspomniał, istnieje kilka różnych sposobów, aby to zrobić.

443
00:37:17,940 --> 00:37:23,040
Co można zrobić, to jak idziesz przez i czytanie przez konkretnego scanline

444
00:37:23,040 --> 00:37:28,560
i zmieniając go w razie potrzeby, a następnie rodzaj sklepu wszystkich tych pikseli w tablicy.

445
00:37:28,560 --> 00:37:36,350
Potem na ciebie wiem, że trzeba wydrukować tę tablicę ponownie,

446
00:37:36,350 --> 00:37:39,830
i tak można po prostu użyć tej tablicy to zrobić.

447
00:37:39,830 --> 00:37:44,500
Innym sposobem na to jest można skopiować w dół o jeden wiersz,

448
00:37:44,500 --> 00:37:47,950
Rozumiem, że trzeba skopiować, że ponownie, więc rzeczywiście przesunąć kursor,

449
00:37:47,950 --> 00:37:50,950
i to będzie za pomocą fseek metody.

450
00:37:50,950 --> 00:37:56,410
Można przesunąć kursor z powrotem i powtórz proces kopiowania ponownie.

451
00:37:56,410 --> 00:38:03,960
>> Więc jeśli nasz numer skalowanie jest n, to ile razy trzeba by wrócić

452
00:38:03,960 --> 00:38:10,500
i przepisać linię? >> [Uczeń] n - 1. >> Tak, doskonały. n - 1.

453
00:38:10,500 --> 00:38:14,390
Zrobiliśmy to już raz, więc wtedy będziemy chcieli powtórzyć trwający proces tylną

454
00:38:14,390 --> 00:38:17,460
n - 1 ilość razy.

455
00:38:22,730 --> 00:38:25,860
Okay. Więc masz swoją funkcję zmiany rozmiaru.

456
00:38:25,860 --> 00:38:34,360
>> Teraz możemy dotrzeć do bardzo zabawnej strony, moja ulubiona PSET, który jest Recover.

457
00:38:34,360 --> 00:38:39,580
Zamiast bitmapy, tym razem mamy do czynienia z JPEG.

458
00:38:39,580 --> 00:38:43,370
Jesteśmy faktycznie nie otrzymał plik tylko z plików JPEG,

459
00:38:43,370 --> 00:38:46,600
mamy podane w zasadzie surowy format karty pamięci.

460
00:38:46,600 --> 00:38:51,790
I tak to zawiera trochę informacji i śmieci wartości na początku,

461
00:38:51,790 --> 00:38:57,240
, a następnie zaczyna się i ma kilka plików JPEG.

462
00:38:57,240 --> 00:39:03,430
Jednak pracujemy wręczył kartę gdzie zostały usunięte zdjęcia;

463
00:39:03,430 --> 00:39:08,300
zasadniczo, zapomnieliśmy, gdzie zdjęcia znajdują się w karcie.

464
00:39:08,300 --> 00:39:12,770
Tak więc naszym zadaniem w Recover jest przejście przez ten format karty

465
00:39:12,770 --> 00:39:16,500
i znaleźć te zdjęcia ponownie.

466
00:39:16,500 --> 00:39:23,990
>> Na szczęście, struktura plików JPEG i plik kart jest nieco pomocny.

467
00:39:23,990 --> 00:39:28,850
To z pewnością mogło być nieco trudniejsze, gdyby nie było w tym konkretnym formacie.

468
00:39:28,850 --> 00:39:40,160
Każdy plik JPEG faktycznie zaczyna się od dwóch możliwych sekwencji, wymienionych powyżej.

469
00:39:40,160 --> 00:39:42,970
Zasadniczo, gdy masz nowy plik w formacie JPEG,

470
00:39:42,970 --> 00:39:52,720
zaczyna się albo sekwencji ffd8 ffe0 lub drugi, ffd8 ffe1.

471
00:39:52,720 --> 00:39:59,530
Inną pomocną rzeczą jest wiedzieć, że pliki JPEG są przechowywane ciągły.

472
00:39:59,530 --> 00:40:03,380
Tak więc, gdy jeden plik JPEG kończy, drugi zaczyna.

473
00:40:03,380 --> 00:40:07,070
Więc nie każdy rodzaj w między wartościami jest.

474
00:40:07,070 --> 00:40:15,510
Po trafieniu początek JPEG, jeśli już zostały czytania w formacie JPEG,

475
00:40:15,510 --> 00:40:21,800
wiesz, że został trafiony koniec poprzedniego i na początku następnego.

476
00:40:21,800 --> 00:40:25,890
>> Do rodzaju wizualizacji tego, zrobiłem schemat.

477
00:40:25,890 --> 00:40:36,910
Inną rzeczą jest to, że JPEG możemy czytać je w sekwencji 512 bajtów na raz,

478
00:40:36,910 --> 00:40:39,380
Podobnie z początku karty.

479
00:40:39,380 --> 00:40:43,370
Nie trzeba sprawdzać każdy pojedynczy bajt bo to do dupy.

480
00:40:43,370 --> 00:40:48,200
Zamiast więc, co możemy zrobić, to właściwie tylko czytać w 512 bajtów na raz

481
00:40:48,200 --> 00:40:54,700
, a następnie, zamiast sprawdzania Pomiędzy tymi w tych małych drobnych plasterki,

482
00:40:54,700 --> 00:40:58,640
możemy po prostu sprawdzić na początek 512 bajtów.

483
00:40:58,640 --> 00:41:02,570
Zasadniczo, w obrazie, co widać w początku karty

484
00:41:02,570 --> 00:41:08,700
masz wartości, które nie są naprawdę istotne dla rzeczywistych JPEG samych.

485
00:41:08,700 --> 00:41:15,830
Ale to co mam jest gwiazda wskazać jedną z dwóch sekwencji wyjścia dla JPEG.

486
00:41:15,830 --> 00:41:19,910
Więc kiedy zobaczysz gwiazdę, wiesz, że masz plik JPEG.

487
00:41:19,910 --> 00:41:25,030
I wtedy każdy plik JPEG będzie niektóre wielokrotnością 512 bajtów

488
00:41:25,030 --> 00:41:27,880
ale niekoniecznie taką samą wielokrotność.

489
00:41:27,880 --> 00:41:32,050
Sposób, że wiesz, że został trafiony kolejny JPEG jeśli trafisz inną gwiazdę,

490
00:41:32,050 --> 00:41:39,090
drugim od sekwencji bajtów.

491
00:41:39,090 --> 00:41:43,330
Wtedy to, co masz o to masz czerwony plik JPEG ciągłą aż trafisz na gwiazdę,

492
00:41:43,330 --> 00:41:45,150
co wskazuje na nowy kolor.

493
00:41:45,150 --> 00:41:48,510
Nadal, a potem uderzył inną gwiazdę, trafiasz kolejny JPEG,

494
00:41:48,510 --> 00:41:50,590
można kontynuować aż do końca.

495
00:41:50,590 --> 00:41:53,180
Jesteś na ostatnim zdjęciu tutaj, różowy.

496
00:41:53,180 --> 00:41:58,220
Możesz przejść do końca, aż trafisz na znak końca pliku.

497
00:41:58,220 --> 00:42:00,820
To będzie naprawdę przydatne.

498
00:42:00,820 --> 00:42:03,170
>> Kilka głównych takeaways tutaj:

499
00:42:03,170 --> 00:42:06,670
Kartoteka nie zaczyna się w formacie JPEG,

500
00:42:06,670 --> 00:42:13,350
ale po JPEG uruchomieniu wszystkie JPEG są przechowywane obok siebie.

501
00:42:17,520 --> 00:42:20,420
>> Niektóre Pseudokod dla Recover.

502
00:42:20,420 --> 00:42:22,570
Po pierwsze, mamy zamiar otworzyć nasz plik karty,

503
00:42:22,570 --> 00:42:27,500
i to będzie za pomocą nasz plik I / O funkcji.

504
00:42:27,500 --> 00:42:32,430
Będziemy powtarzać następujący proces, dopóki nie dotarł do końca pliku.

505
00:42:32,430 --> 00:42:36,450
Będziemy czytać 512 bajtów na raz.

506
00:42:36,450 --> 00:42:39,180
I to, co powiedziałem o to będziemy go przechowywać w buforze,

507
00:42:39,180 --> 00:42:46,230
więc w zasadzie trzymać się tych 512 bajtów dopóki nie wiemy dokładnie, co z nimi zrobić.

508
00:42:46,230 --> 00:42:50,300
Wtedy to, co chcemy zrobić, to chcemy, aby sprawdzić, czy mamy uderzyć gwiazdę lub nie.

509
00:42:50,300 --> 00:42:57,960
Jeśli mamy hit gwiazdy, jeśli został trafiony jedną z sekwencji wyjściowych,

510
00:42:57,960 --> 00:42:59,980
to wiemy, że mamy hit nowy plik JPEG.

511
00:42:59,980 --> 00:43:08,860
Co będziemy chcieli zrobić, to mamy zamiar utworzyć nowy plik w katalogu naszego pset4

512
00:43:08,860 --> 00:43:14,480
o dokonywaniu tego pliku.

513
00:43:14,480 --> 00:43:18,220
Ale również, jeśli mamy już wykonane w formacie JPEG przed,

514
00:43:18,220 --> 00:43:25,620
to chcemy zakończyć ten plik i wciśnij go do pset4 folderze

515
00:43:25,620 --> 00:43:29,780
gdzie będziemy mieli, że plik zapisany, ponieważ jeśli nie określić, że mamy zakończony, że plik JPEG,

516
00:43:29,780 --> 00:43:37,290
wtedy będziemy w zasadzie mają nieokreśloną kwotę. W JPEG nigdy nie skończy.

517
00:43:37,290 --> 00:43:40,840
Dlatego chcemy, aby upewnić się, że gdy czytasz w do pliku JPEG i piśmie,

518
00:43:40,840 --> 00:43:46,590
chcemy specjalnie blisko, że aby otworzyć następny.

519
00:43:46,590 --> 00:43:48,430
Chcemy się sprawdzić kilka rzeczy.

520
00:43:48,430 --> 00:43:52,880
Chcemy sprawdzić, czy jesteśmy na początku nowego JPEG z naszym buforze

521
00:43:52,880 --> 00:43:56,780
a także jeśli już znalazłem JPEG przed

522
00:43:56,780 --> 00:44:03,930
dlatego, że zmieni swój proces lekko.

523
00:44:03,930 --> 00:44:07,880
Tak więc po przejściu przez całą drogę, a trafisz na koniec pliku,

524
00:44:07,880 --> 00:44:11,570
to co będziesz chciał zrobić, to będziemy chcieli, aby zamknąć wszystkie pliki, które są obecnie otwarte.

525
00:44:11,570 --> 00:44:14,100
To będzie prawdopodobnie ostatni plik JPEG, że masz,

526
00:44:14,100 --> 00:44:18,930
jak kartoteki, że już do czynienia.

527
00:44:21,940 --> 00:44:28,670
>> Ostatnią przeszkodą, że musimy rozwiązać to jak rzeczywiście zrobić plik JPEG

528
00:44:28,670 --> 00:44:31,950
i jak rzeczywiście przesunąć go do folderu.

529
00:44:33,650 --> 00:44:39,850
Pset wymaga, aby każdy JPEG, które można znaleźć w następującym formacie

530
00:44:39,850 --> 00:44:43,990
gdzie masz numer. jpg.

531
00:44:43,990 --> 00:44:50,750
Numer, nawet jeśli jest to 0, nazywamy to 000.jpg.

532
00:44:50,750 --> 00:44:55,730
Gdy znajdziesz w formacie JPEG w programie,

533
00:44:55,730 --> 00:44:58,040
będziesz chciał wymienić je w kolejności, w jakiej się znalazł.

534
00:44:58,040 --> 00:44:59,700
Co to znaczy?

535
00:44:59,700 --> 00:45:03,530
Musimy rodzaju śledzić ile odkryliśmy

536
00:45:03,530 --> 00:45:08,680
i co liczba powinna być każdego JPEG.

537
00:45:08,680 --> 00:45:13,800
Tutaj mamy zamiar skorzystać z funkcji sprintf.

538
00:45:13,800 --> 00:45:17,480
Podobna do printf, które po prostu rodzaj wydruków wartość obecnie w terminalu,

539
00:45:17,480 --> 00:45:23,910
sprintf drukuje plik się do folderu.

540
00:45:23,910 --> 00:45:30,870
A więc co by to zrobić, gdybym miał sprintf, tytuł, a następnie ciąg tam,

541
00:45:30,870 --> 00:45:36,660
byłoby wydrukować 2.jpg.

542
00:45:36,660 --> 00:45:41,020
Zakładając, że mam zamknięte moje pliki poprawnie,

543
00:45:41,020 --> 00:45:47,210
które zawiera plik, który był w tym piśmie się.

544
00:45:47,210 --> 00:45:50,320
Ale jedna rzecz jest to, że kod, który mam tutaj

545
00:45:50,320 --> 00:45:53,360
nie dość spełniają co pset wymaga.

546
00:45:53,360 --> 00:46:02,410
Pset wymaga sekund plików JPEG powinny być nazwane 002 zamiast tylko 2.

547
00:46:02,410 --> 00:46:09,160
Więc kiedy wydrukować nazwę, to może warto zmienić zastępczy lekko.

548
00:46:09,160 --> 00:46:18,140
>> Czy ktoś pamięta, jak pozwalają na dodatkowych spacji, gdy drukujemy coś?

549
00:46:18,140 --> 00:46:22,530
Tak. >> [Uczeń] Możesz umieścić 3 między znakiem procentu i 2. >> Tak, doskonały.

550
00:46:22,530 --> 00:46:25,610
Będziesz umieścić 3 w tym przypadku, ponieważ chcemy miejsca dla 3.

551
00:46:25,610 --> 00:46:32,590
% 3d prawdopodobnie dać 002.jpg zamiast 2.

552
00:46:32,590 --> 00:46:40,120
Pierwszy argument do funkcji sprintf jest rzeczywiście tablica char,

553
00:46:40,120 --> 00:46:42,520
których wcześniej znał jako łańcuchy.

554
00:46:42,520 --> 00:46:50,700
Będą, rodzaj bardziej jak składowania czasowego, po prostu zapisać wynikowy ciąg.

555
00:46:50,700 --> 00:46:54,950
Ty naprawdę nie będą mieć do czynienia z tym, ale trzeba go zawierać.

556
00:46:54,950 --> 00:47:00,710
>> Wiedząc, że każda nazwa pliku ma numer, który odbywa się trzy znaki,

557
00:47:00,710 --> 00:47:06,770
i wtedy. jpg, jak długo należy ta tablica będzie?

558
00:47:09,070 --> 00:47:14,310
Wyrzuć numer. Ile znaków w tytule, w imię?

559
00:47:18,090 --> 00:47:26,320
Więc jest 3 hashtags, okres, JPG. >> [Uczeń] 7. >> 7. Nie całkiem.

560
00:47:26,320 --> 00:47:32,000
Będziemy chcieli 8, ponieważ chcemy, aby umożliwić terminator null również.

561
00:47:45,340 --> 00:47:49,730
>> Wreszcie, po prostu wyciągnąć proces, będziesz robił za odzyskiwanie,

562
00:47:49,730 --> 00:47:55,420
masz jakąś informacje początkowy.

563
00:47:55,420 --> 00:48:02,460
Nadal, aż znajdziesz początek pliku JPEG,

564
00:48:02,460 --> 00:48:07,900
oraz, że może być jednym z dwóch sekwencji wyjściowych.

565
00:48:07,900 --> 00:48:12,510
Można przechowywać na czytanie. Każdy slash tutaj reprezentuje 512 bajtów.

566
00:48:12,510 --> 00:48:22,630
Można przechowywać na czytaniu, aby zapoznawali aż znowu pojawi sekwencję początkową.

567
00:48:22,630 --> 00:48:29,790
Kiedy już, że w końcu bieżącego JPEG - w tym przypadku, to jest czerwony,

568
00:48:29,790 --> 00:48:31,030
tak chcesz zakończyć to.

569
00:48:31,030 --> 00:48:35,540
Chcesz sprintf nazwy że w swojej pset4 folderze

570
00:48:35,540 --> 00:48:41,580
to chcesz otworzyć nowy JPEG, a następnie kontynuować czytanie

571
00:48:41,580 --> 00:48:46,370
aż pojawią się następne.

572
00:48:46,370 --> 00:48:49,040
Zachowaj na czytaniu, przechowywać na czytanie,

573
00:48:49,040 --> 00:48:56,290
i wreszcie, w końcu masz zamiar dotrzeć do końca pliku,

574
00:48:56,290 --> 00:49:00,360
i tak będziesz chciał, aby zamknąć ostatnią JPEG, które zostały z pracy,

575
00:49:00,360 --> 00:49:08,380
sprintf, że do swojego pset4 folderu, a następnie spójrz na wszystkie zdjęcia, które dostaliśmy.

576
00:49:08,380 --> 00:49:12,050
Te zdjęcia są faktycznie zdjęcia CS50 personelu,

577
00:49:12,050 --> 00:49:16,430
i tak to jest, gdy część zabawy premia z Pset przychodzi

578
00:49:16,430 --> 00:49:26,310
jest to, że są konkurencyjne w swoich sekcjach znaleźć TFS na zdjęciach

579
00:49:26,310 --> 00:49:34,610
i zdjęcia z nimi, aby udowodnić, że zrobiłeś z Pset

580
00:49:34,610 --> 00:49:37,030
i tak można zobaczyć, które pracownicy są na zdjęciach.

581
00:49:37,030 --> 00:49:41,510
Tak więc wykonywanie zdjęć z personelem. Czasami będziesz musiał gonić ich.

582
00:49:41,510 --> 00:49:44,680
Prawdopodobnie część z nich będzie starał się uciec od ciebie.

583
00:49:44,680 --> 00:49:47,320
Robić zdjęcia z nimi.

584
00:49:47,320 --> 00:49:51,190
To jest w toku. To nie z powodu, gdy zbior jest należny.

585
00:49:51,190 --> 00:49:53,340
Termin zostanie ogłoszony w spec.

586
00:49:53,340 --> 00:49:58,060
Następnie wraz z sekcji, w zależności od sekcji zajmuje najwięcej zdjęć

587
00:49:58,060 --> 00:50:04,430
z największą liczbą pracowników wygra dość niesamowite nagrody.

588
00:50:04,430 --> 00:50:08,890
To rodzaj zachęty, aby uzyskać pset4 zakończone tak szybko, jak to możliwe

589
00:50:08,890 --> 00:50:10,820
bo wtedy można zabrać się do pracy

590
00:50:10,820 --> 00:50:14,570
polowanie na wszystkich różnych CS50 pracowników.

591
00:50:14,570 --> 00:50:17,500
To nie jest obowiązkowe, choć, więc gdy się zdjęcia,

592
00:50:17,500 --> 00:50:20,310
wtedy są wykończone pset4.

593
00:50:20,310 --> 00:50:23,970
>> I jestem wykończony Walkthrough 4, więc dziękuję wszystkim za przybycie.

594
00:50:23,970 --> 00:50:29,330
Powodzenia z Forensics. [Oklaski]

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