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
לכן, אנחנו שוב הולכים להתחיל עם
בעצם העתק של copy.c, ו

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
n, שהוא הסכום שאנחנו
קנה מידה של התמונה המקורית על ידי.

9
00:00:38,980 --> 00:00:44,340
ברגע שאנחנו בטוחים בכך, אנחנו יכולים רק
להמיר n למספר שלם באמצעות 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
עכשיו אנחנו רוצים לבדוק כדי להפוך n בטוח הוא
בגבולות שאנו מצפים, ולכן

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
>> אז, בהנחה שלא נכשלו, אז
אנחנו גוף - בדיוק כמו בcopy.c--

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
>> עכשיו, הריפוד הולך להיות אותו הדבר
חישוב כפי שהיה בcopy.c,

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
אז אנחנו הולכים להכפיל את הרוחב שלנו על ידי
n, שכן אנחנו קנה מידה של הרוחב על ידי

33
00:02:11,200 --> 00:02:15,100
n, הכפל את הגובה על ידי 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
כותרת, על אישור.

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
וטפס אותו על ידי n.

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
לולאה פנימית זה iterating מעל
שורה עצמו, על המערך, ההדפסה

63
00:03:57,910 --> 00:04:00,710
כל פיקסל במערך n פעמים.

64
00:04:00,710 --> 00:04:04,510
אז אלמנט האפס הוא להיות מודפס
n פעמים, הרכיב הראשון הוא להיות

65
00:04:04,510 --> 00:04:05,660
הודפס פעמים n.

66
00:04:05,660 --> 00:04:10,820
וזה סוג של איך אנחנו הולכים
אופקית בקנה מידה בoutfile, ו

67
00:04:10,820 --> 00:04:13,390
לולאה זו, שכן אנחנו לולאת n
פעמים, היא איך אנחנו הולכים

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
זו הסיבה שזה נמצא בישוב ללולאה
שמדפיס את שורות n רק

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
>> [השמעת מוסיקה]