>> [MUSIC ప్లే]
>> రాబ్ బౌడెన్: హాయ్, నేను రాబ్ ఉన్నాను, వీలు యొక్క పరిమాణానికి ఈ ప్రయత్నించండి.
కాబట్టి, మేము మళ్ళీ తో ఆరంభమవుతుంది ప్రాథమికంగా ఒక copy.c కాపీ, మరియు
కొన్ని మార్పులు చేయండి.
వెంటనే మేము, ఒక మార్పు చూడండి గమనించండి ఇక్కడ బదులుగా చూడటానికి తనిఖీ ఉంటే
argc, మేము తనిఖీ 3 సమాన కాదు అనుకుంటుంది argc నుండి, 4 సమానంగా లేదు ఉంటే
ఇప్పుడు మేము ఒక infile తీసుకోవడం లేదు మరియు outfile, కానీ మేము కూడా లో వేస్తున్నాము
మేము ఆ మొత్తం అని, అసలు చిత్రం స్కేలింగ్.
మేము ఆ లేదో ఉన్నారు, మేము కేవలం atoi ఉపయోగించి పూర్ణాంకం n మార్చేందుకు.
>> కాబట్టి, ఇప్పుడు మేము సృష్టించడానికి చూడాలని మారుపేర్ల, కేవలం 2 infile argv కాల్, మరియు
argv 3 outfile, argv 2 మరియు ఎందుకంటే argv 3 చాలా సహాయకారిగా పేర్లు కావు.
ఇప్పుడు మేము ఖచ్చితంగా n ఉంది చేయడానికి చెక్ అనుకుంటున్నారా హద్దుల్లో కాదనీ, కాబట్టి
స్పెక్ పేర్కొనే ఇది కంటే తక్కువ లేదా ఉంటే , సున్నాకి సమానం, లేదా 100 కంటే ఎక్కువ
ఆ చెల్లని పునఃపరిమాణం ఫాక్టర్, మరియు మేము ఆ యూజర్ హెచ్చరిస్తుంది ఉండాలి.
>> మేము అన్ని ఆ దాటి అయ్యాక, మేము చివరికి మా infile లెట్ మరియు మేము అవసరం
నిర్ధారించుకోండి తనిఖీ తప్పొప్పులకు ప్రారంభ కారణం విఫలం లేదు.
మేము కూడా మా outfile తెరిచి, మరియు మళ్ళీ నిర్ధారించుకోండి తనిఖీ లోపం
కారణం విఫలం లేదు.
కానీ తప్పకుండా ఉంటే ప్రారంభ outfile మేము దగ్గరగా అవసరమైన విఫలమైంది
ఇప్పటికే ఆరంభించబడింది infile,.
>> కాబట్టి, అప్పుడు, ఆ విఫలం లేదు ఊహిస్తూ we're - కేవలం వంటి copy.c--
శీర్షికలో చదవగల infile నుండి.
మేము అది ఒక చెల్లదు చేయడానికి చూడాలని బిట్మ్యాప్, కానీ ఇప్పుడు మేము కొన్ని చేయబోతున్నామని
ఒక బిట్ భిన్నంగా పనులు.
కాబట్టి మొదటి, మేము మీరు చూడాలని అసలు వెడల్పు మరియు ఎత్తు గుర్తు
infile యొక్క, ఎందుకంటే మేము చూడాలని outfile కోసం ఇది మారుతున్న.
కాబట్టి ఇప్పుడు విచిత్రమైన కారణాల గుర్తుంచుకోవాలి bi.biheight, ప్రతికూల, మరియు
కాబట్టి లో అసలు ఎత్తు, అనుకూల, మేము సంపూర్ణ విలువ తీసుకోవాలని.
>> ఇప్పుడు, పాడింగ్ అదే అన్నారు ఇది copy.c లో లెక్కింపు వంటి,
పాత వెడల్పు ఉపయోగించి, మరియు ఇప్పుడు మేము ఉన్నాము నిజానికి మార్చుకోబోతున్నారు
మా శీర్షికలో ఏమి యొక్క.
కాబట్టి మేము మా వెడల్పు గుణిస్తారు చూడాలని n, మేము ద్వారా వెడల్పు కొలిస్తే చేస్తున్నారు నుండి
మేము నుండి n, n ఎత్తు గుణిస్తారు n, స్కేలింగ్ మరియు ఇప్పుడు మనం
ఒక కొత్త పాడింగ్ కోసం లెక్కింపు కొత్త వెడల్పు ఆధారంగా.
>> కాబట్టి ఇప్పుడు మేము కొన్ని మార్చాలి మా శీర్షిక ఇతర ఖాళీలను.
Bi.biSizeImage భావించబడేది పిక్సెళ్ళు లో అన్ని బైట్లు పరిమాణం
మరియు చిత్రం యొక్క పాడింగ్.
కాబట్టి మా ఒక వరుస యొక్క పరిమాణం చిత్రం RGB యొక్క పరిమాణం ట్రిపుల్, పరిమాణం ఉంది
ఒక పిక్సెల్ యొక్క, సార్లు సంఖ్య వరుసగా పిక్సెళ్ళు, ప్లస్ పాడింగ్ వద్ద
వరుసగా ముగింపు.
మరియు తర్వాత మేము ద్వారా గుణించాలి చూడాలని పొందడానికి మా ఎత్తు సంపూర్ణ విలువ
బైట్లు మొత్తం సంఖ్య చిత్రం డేటా.
bf.bfSize కేవలం మొత్తం సంఖ్య మా చిత్రం డేటా బైట్లు, కాబట్టి
bi.biSizeImage, ప్లస్ మా శీర్షికలు యొక్క పరిమాణం.
కాబట్టి, బిట్మ్యాప్ ఫైల్ పరిమాణంపై జోడించడం బిట్మ్యాప్ సమాచారం యొక్క శీర్షిక, మరియు పరిమాణం
OK, శీర్షిక.
కాబట్టి మేము అవసరమైనవి మా శీర్షికల్లో మార్చడానికి.
ఇప్పుడు మేము బిట్మ్యాప్ ఫైలు శీర్షిక వ్రాసే చేస్తాము మా outfile, మరియు మా బిట్మ్యాప్ సమాచారం
ఇప్పుడు మా outfile శీర్షిక, మరియు మేము వెళ్లి సిద్ధంగా
నిజమైన పిక్సెళ్ళు పైగా.
>> కాబట్టి మేము కంటే iterate infile యొక్క స్కాన్ పంక్తులు.
కాబట్టి మేము oldheight కంటే iterate.
మేము గుర్తు అవసరమైన ఎందుకు ఉంది మేము మారుతుంది ముందు అసలు ఎత్తు,
మరియు n ద్వారా స్కేల్.
ఇప్పుడు మేము ఒక చదవండి చూడాలని ఒక లోకి infile వరుస
పరిమాణం oldwidth బఫర్.
RGB యొక్క ఇక్కడ, మేము freading చేస్తున్నారు పరిమాణం ట్రిపుల్, ఒక పిక్సెల్, మరియు పాత వెడల్పు
మా బఫర్ లోకి infile నుండి.
మరియు ఆ మొత్తం చేస్తాడు ఈ శ్రేణి లో వరుస.
కాబట్టి ఇప్పుడు, మేము n సార్లు iterate మీరు మా outfile n సార్లు ఈ వరుసగా ప్రింట్.
అందువలన, ఈ లూప్ చేస్తున్నది ఉంది.
ఇది లోపలి లూప్ పైగా iterating ఉంది శ్రేణి, ముద్రణ పైగా, స్వయంగా వరుస
శ్రేణి n కాలంలో ప్రతి పిక్సెల్.
కాబట్టి జేరోయేత్ మూలకం ముద్రించబడ్డాయి ఉంది n సార్లు, మొదటి మూలకం ఉంది
n సార్లు ముద్రించిన.
మరియు ఆ విధమైన ఎలా మేము చూడాలని ఉంది అడ్డంగా outfile లో స్థాయికి
ఈ లూప్, మేము n మళ్ళీ వెతికినా నుండి సార్లు, మేము వెళుతున్న ఉంది
నిలువుగా స్థాయి.
>> డౌన్ ఇక్కడ, మేము జోడించడానికి చూడండి ప్రతి వరుసలో చివర పాడింగ్.
ఈ కోసం లూప్ లోపల ఎందుకు పేర్కొంది కేవలం యొక్క n వరుసలు ముద్రించిన యొక్క
infile నుండి ఈ ఒక వరుసగా.
అప్పుడు డౌన్ ఇక్కడ, నేను పైగా skip వెళుతున్న infile లో పాడింగ్, ఒకసారి నుండి
మేము ఒక వరుస పూర్తి చేసిన infile, మనం శ్రద్ధ లేదు
ఏ పాడింగ్ ఉంది.
మేము రెండవ వరుసలో ను మీరు.
మరియు తర్వాత మేము తిరిగి లూప్ చేస్తాము మరియు అన్ని చేయండి మళ్ళీ రెండవ వరుసలో కోసం.
>> చివరగా, ఒకసారి మేము అన్ని ఆ పూర్తి చేసిన, మేము దగ్గరగా, infile మూసివేయవచ్చు
outfile, మరియు తిరిగి 0 మేము పూర్తి చేసిన ఎందుకంటే.
>> నా పేరు రాబ్ ఉంది, మరియు ఈ పునఃపరిమాణం ఉంది.
>> [MUSIC ప్లే]