1
00:00:00,000 --> 00:00:12,240
>> [За възпроизвеждане на музика]

2
00:00:12,240 --> 00:00:15,870
>> ROB Боудън: Здравейте, аз съм Роб, нека
пробвай това за размер.

3
00:00:15,870 --> 00:00:21,100
Така че, ние отново ще започнем с
в основата на копие от резервното, и

4
00:00:21,100 --> 00:00:22,860
направи няколко промени.

5
00:00:22,860 --> 00:00:26,280
Имайте предвид, веднага виждаме промяна, където
вместо да се проверява, за да видите, ако

6
00:00:26,280 --> 00:00:30,440
argc не равно 3, ние искаме да се провери
ако argc не е равно на 4, тъй като

7
00:00:30,440 --> 00:00:34,350
Сега ние не сме просто като в INFILE
и outfile, но ние също така се вземат в

8
00:00:34,350 --> 00:00:38,980
н, който е сумата, която сме
мащабиране на оригиналното изображение от.

9
00:00:38,980 --> 00:00:44,340
След като ние сме сигурни, че можем просто
конвертирате н до цяло число, използвайки atoi.

10
00:00:44,340 --> 00:00:48,760
>> Така че, сега отиваме да се създаде някаква
псевдоними, просто се обадете ARGV 2 INFILE, и

11
00:00:48,760 --> 00:00:54,240
ARGV 3 outfile, защото ARGV 2 и
ARGV 3 не са много полезни имена.

12
00:00:54,240 --> 00:00:58,510
Сега искаме да се провери, за да се уверете, че н е
в границите, ние очакваме, така че

13
00:00:58,510 --> 00:01:02,910
спец. уточнява, че ако е по-малко от или
равно на нула, или по-голяма от 100,

14
00:01:02,910 --> 00:01:08,580
тогава това е невалиден преоразмеряване фактор,
и ние трябва да предупреждава потребителя за това.

15
00:01:08,580 --> 00:01:13,090
>> След като ние сме отвъд всичко това, ние можем да
най-накрая отвори нашия INFILE, и ние трябва

16
00:01:13,090 --> 00:01:16,270
на грешка проверка, за да се уверите, че
отваряне не се провали по някаква причина.

17
00:01:16,270 --> 00:01:19,860
Ние също трябва да отворите нашия outfile, и
отново грешка се уверете, че

18
00:01:19,860 --> 00:01:21,250
не се провали по някаква причина.

19
00:01:21,250 --> 00:01:26,270
Но бъдете сигурни, ако откриването на
outfile провали, че ние трябва да се затвори

20
00:01:26,270 --> 00:01:29,040
на INFILE, която вече е открит.

21
00:01:29,040 --> 00:01:33,690
>> Така че, ако се приеме, че не се провали, след това
we're - точно както и в резервното--

22
00:01:33,690 --> 00:01:36,140
ще прочетете в заглавната
от INFILE.

23
00:01:36,140 --> 00:01:40,130
Отиваме да се уверите, че това е валидно
растерна графика, но сега отиваме да се направят някои

24
00:01:40,130 --> 00:01:41,620
нещата малко по-различно.

25
00:01:41,620 --> 00:01:44,870
Така че, на първо място, ние ще искате да
Спомням си оригиналната широчина и височина

26
00:01:44,870 --> 00:01:48,290
на INFILE, защото ние ще
да го променя за outfile.

27
00:01:48,290 --> 00:01:53,890
Така че сега се помни, че за странни причини
bi.biheight, е отрицателно, и

28
00:01:53,890 --> 00:01:58,670
така че действителната височина, в положителен, ние
Искам да взема абсолютната стойност.

29
00:01:58,670 --> 00:02:02,580
>> Сега, пълнежът ще бъде същата
изчисление, тъй като беше в резервното,

30
00:02:02,580 --> 00:02:06,060
използвате стария ширината, и сега сме
всъщност няма да се промени

31
00:02:06,060 --> 00:02:07,320
Какво има в нашата заглавна.

32
00:02:07,320 --> 00:02:11,200
Така че ние отиваме да се размножават нашата ширина от
н, тъй като ние сме мащабиране на ширината от

33
00:02:11,200 --> 00:02:15,100
н, умножете височината от N, тъй като ние сме
мащабиране от N, а сега имаме

34
00:02:15,100 --> 00:02:19,250
изчисляване за нова подложка
на базата на новата ширина.

35
00:02:19,250 --> 00:02:21,840
>> Така че сега ние трябва да променим някои
други области в нашата заглавна.

36
00:02:21,840 --> 00:02:26,890
Bi.biSizeImage е трябвало да бъде
размер на всички байтове в пикселите

37
00:02:26,890 --> 00:02:28,520
и подплата на изображението.

38
00:02:28,520 --> 00:02:34,190
И така, размерът на един ред от нашия
снимката е размер на RGB тройна, размерът

39
00:02:34,190 --> 00:02:39,430
на един пиксел, умножен по броя на
пиксела в един ред, плюс пълнежа при

40
00:02:39,430 --> 00:02:40,910
на края на реда.

41
00:02:40,910 --> 00:02:45,200
И след това отиваме да се размножават, че от
абсолютната стойност на нашата височина, за да получите

42
00:02:45,200 --> 00:02:48,350
общия брой на байтовете
в данните на изображението.

43
00:02:48,350 --> 00:02:53,050
bf.bfSize е просто общия брой
байтове в нашите данни с изображения, така че

44
00:02:53,050 --> 00:02:56,530
bi.biSizeImage, плюс
размер на нашите заглавки.

45
00:02:56,530 --> 00:02:59,850
Така че, добавяйки, от размера на растерна графика файл
хедър, и размер на растерна информация

46
00:02:59,850 --> 00:03:00,800
хедър, OK.

47
00:03:00,800 --> 00:03:03,170
Така че това е всичко, което трябва да
промените в нашите заглавки.

48
00:03:03,170 --> 00:03:07,020
Сега ще пиша заглавието на растерна графика файл
в нашия outfile и нашата растерна информация

49
00:03:07,020 --> 00:03:09,880
служебната информация към нашия outfile, и сега
ние сме готови да започнем ще

50
00:03:09,880 --> 00:03:11,990
върху реалните пиксели.

51
00:03:11,990 --> 00:03:15,720
>> Така че ние искаме да обхождане
линии за сканиране на INFILE те години.

52
00:03:15,720 --> 00:03:17,730
Така че ние искаме да обхождане oldheight.

53
00:03:17,730 --> 00:03:20,830
Ето защо ние трябва да помним
оригинална височина, преди да го промените

54
00:03:20,830 --> 00:03:23,040
и да го мащабира от п.

55
00:03:23,040 --> 00:03:27,810
Сега отиваме да прочетете една-единствена
ред на INFILE в

56
00:03:27,810 --> 00:03:30,630
буфер с размер oldwidth.

57
00:03:30,630 --> 00:03:36,190
Така че тук, ние сме freading размер на RGB
тройни, един пиксел, и стари ширина

58
00:03:36,190 --> 00:03:39,760
тях от INFILE в нашия буфер.

59
00:03:39,760 --> 00:03:43,480
И това ще бъде един цял
ред в този масив.

60
00:03:43,480 --> 00:03:50,390
Така че сега, ние искаме да превъртите N пъти, за да
отпечатате този ред, за да ни outfile N пъти.

61
00:03:50,390 --> 00:03:52,510
И така, това е, което този цикъл се прави.

62
00:03:52,510 --> 00:03:57,910
Тази вътрешна линия е итерации над река
Самият ред, над масив, отпечатването

63
00:03:57,910 --> 00:04:00,710
всеки пиксел в масива п пъти.

64
00:04:00,710 --> 00:04:04,510
Така нулев елемент се отпечатва
п пъти, първият елемент е

65
00:04:04,510 --> 00:04:05,660
печатни п пъти.

66
00:04:05,660 --> 00:04:10,820
И това е нещо за това как ние ще се
хоризонтално мащабиране в outfile, и

67
00:04:10,820 --> 00:04:13,390
този цикъл, тъй като ние сме примка п
пъти, е как ние ще

68
00:04:13,390 --> 00:04:15,580
вертикално мащаб.

69
00:04:15,580 --> 00:04:19,850
>> Първа тук, ние виждаме, че ние трябва да добавите
пълнежа в края на всеки ред.

70
00:04:19,850 --> 00:04:25,050
Ето защо това е вътре в контура за
това е отпечатване на п редовете на само

71
00:04:25,050 --> 00:04:28,400
този един ред от INFILE.

72
00:04:28,400 --> 00:04:32,150
После тук, аз отивам да прескачам
пълнежа в INFILE, тъй като веднъж

73
00:04:32,150 --> 00:04:34,560
приключим с един ред от
INFILE, ние не се грижи за

74
00:04:34,560 --> 00:04:35,290
това, което е подложка.

75
00:04:35,290 --> 00:04:37,110
Ние просто искаме да стигнем до втория ред.

76
00:04:37,110 --> 00:04:40,870
И тогава ние ще контур обратно и да вършиш всичките
това отново за втория ред.

77
00:04:40,870 --> 00:04:44,406
>> И накрая, след като сме готови с всичко това,
можем да затворите INFILE, близо

78
00:04:44,406 --> 00:04:47,430
на outfile и връщане
0, защото сме готови.

79
00:04:47,430 --> 00:04:50,330
>> Моето име е Роб, и това е за преоразмеряване.

80
00:04:50,330 --> 00:04:54,934
>> [За възпроизвеждане на музика]