1
00:00:00,000 --> 00:00:12,240
>> [સંગીત વગાડવાનો]

2
00:00:12,240 --> 00:00:15,870
>> રોબ બોડેન: હાય, હું રોબ છું, ચાલો
માપ માટે આ પ્રયાસ કરો.

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
કેવી રીતે માની છો એકવાર, અમે કરી શકો છો ફક્ત
atoi મદદથી પૂર્ણાંક n એ રૂપાંતરિત કરો.

10
00:00:44,340 --> 00:00:48,760
>> તેથી, હવે અમે કેટલીક બનાવવા જઈ રહ્યાં છો
ઉપનામ, માત્ર 2 infile argv કહી, અને

11
00:00:48,760 --> 00:00:54,240
3 argv outfile, argv 2 અને કારણ
3 argv ખૂબ જ ઉપયોગી નામો નથી.

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
>> તો પછી, કે નિષ્ફળ ન હતી એમ ધારી રહ્યા છીએ
we're - જસ્ટ તરીકે 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
RGB ના અહીં, અમે કરી રહ્યાં છો freading કદ
ત્રણ, માત્ર એક પિક્સેલ, અને જૂના પહોળાઈ

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
એરે n એ સમયમાં દરેક પિક્સેલ.

64
00:04:00,710 --> 00:04:04,510
તેથી આ zeroth તત્વ મુદ્રિત કરવામાં આવી રહી છે
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
>> [સંગીત વગાડવાનો]