>> [MUSIC ప్లే]
>> రాబ్ బౌడెన్: ఎక్కువ.
నేను రాబ్ ఉన్నాను తెలియజేస్తుంది మరియు పరిమాణం ఈ సమస్య అప్.
కాబట్టి మేము వంటి copy.c ప్రారంభం చూడాలని ఒక టెంప్లేట్, కానీ మేము మాత్రం
చాలా కొన్ని మార్పులతో.
>> ఇప్పుడు మనం వెంటనే చేస్తున్న చూడండి ఒక మేము ఇకపై తనిఖీ చేస్తున్నాము పేరు మార్చడానికి
మా rxc ఇప్పుడు 3 సమానంగా, కానీ లేదు కోసం మేము rc తనిఖీ చేస్తున్నాము 4 సమానంగా లేదు.
మేము కూడా లో, చేర్చాలనుకుంటే నుండి ఫైలు లో మరియు అవుట్ ఫైళ్లు పాటు
ఈ అన్నారు ఇది వాదనలు, f మేము కొలిస్తే చేస్తున్నారు ఇది ద్వారా అంశం.
>> మేము ఆ యొక్క ఖచ్చితంగా ఉన్నాము కాబట్టి ఒకసారి, మేము కావలసిన స్ట్రింగ్ మార్చడానికి లు స్కాన్ F ఉపయోగించడానికి
ఒక ఫ్లోట్ argv1.
మరియు మేము నిల్వ చూడాలని ఆ అంశం.
ఈ అదనపు పాత్ర చూసుకోవాలి ఉంది మేము నిజంగా ఎంటర్ లేని
1.4 ABC లాగ కమాండ్ లైన్ వద్ద.
>> ఇప్పుడు మేము కొన్ని మారుపేర్ల సృష్టించడానికి చూడాలని RV2 మరియు RV3 లేని కారణంగా
చాలా సహాయకారిగా పేర్లు.
మేము, బదులుగా, కాల్ చూడాలని వాటిని ఫైలు లో మరియు ఫైల్.
ఇప్పుడు మేము నిర్ధారించుకోండి చూడాలని మా అంశం నిజానికి ఆమోదయోగ్యమని.
కాబట్టి అంశం కంటే తక్కువ లేదా సమానంగా ఉంటే సున్నా లేదా ఎక్కువ 100 కంటే, అప్పుడు వంటి శాతం
స్పెక్, మేము మానేయాలని ఆ అంశం.
>> మేము ఖచ్చితంగా ఉన్నప్పుడు అది ఇప్పుడు మేము, మంచి n ఫైల్ తెరిచి, మేము కలిగి
ఇది విజయవంతంగా ప్రారంభించబడింది నిర్ధారించుకోండి.
అది లేకపోతే, ఆ శూన్య చూపిస్తుంది.
మేము ఫైల్ను తెరవడం చూడాలని.
మరియు తిరిగి, మేము చేయడానికి చెక్ అనుకుంటున్నారా అది విజయవంతంగా విప్పి.
మరియు అది విజయవంతంగా అప్పుడు, ఓపెన్ పొతే మేము కూడా మూసి ఖచ్చితంగా ఉండాలి
n ఫైల్ ఇది నిజానికి విజయవంతంగా తెరిచింది, లేదంటే ఒక
మెమొరీ లీక్.
>> కాబట్టి ఇప్పుడు మేము బిట్మ్యాప్ లో చదవండి చూడాలని ఫైలు శీర్షిక మరియు బిట్మ్యాప్ సమాచారం
n ఫైల్ నుండి శీర్షిక.
మేము నిర్ధారించుకోండి చూడాలని n ఫైలు సరైన బిట్మ్యాప్ ఉంది.
OK.
>> కాబట్టి ఇప్పుడు మేము ఆరంభమవుతుంది చేస్తున్నారు కొన్ని మార్పులతో.
మేము మారుతున్న కావడం వలన విషయాలు, మేము మొదటి గుర్తు
n ఫైలు యొక్క పాత వెడల్పు.
మేము పాత పాడింగ్ గుర్తు అదే లెక్కింపు ఉపయోగించి n ఫైల్
copy.c. నుండి
>> ఇప్పుడు మేము మార్చడానికి వెళుతున్న బిట్మ్యాప్ సమాచారం శీర్షిక.
అందువలన మేము వెడల్పు రెండు గుణించడం చేస్తున్నారు మరియు నుండి అంశం ఎత్తు
మేము స్కేలింగ్ ఏమిటి.
మేము గుర్తించడానికి చూడాలని ఫైలు ద్వారా కొత్త పాడింగ్
కొత్త వెడల్పు ఉపయోగించి.
మరియు మేము కొత్త గుర్తించడానికి చూడాలని సంఖ్య ఉపయోగించి చిత్రం యొక్క పరిమాణం
అన్నారు ఇది ఒక వరుసగా బైట్లు వరుసగా పిక్సెళ్ళు సంఖ్య అని
సార్లు పిక్సెల్ పరిమాణం ప్లస్ చివరిలో పాడింగ్ బైట్లు సంఖ్య
ఆ వరుస యొక్క, మరియు అన్ని గుణించడం మేము కలిగి వరుసల సంఖ్య ద్వారా.
కాబట్టి ఆ బైట్లు సంఖ్య ఉంది మేము మా చిత్రం డేటా కలిగి.
>> Bf.Bfsize ఇప్పుడు సంఖ్య అన్నారు మా చిత్రం బీటా లో బైట్లు ప్లస్
మా శీర్షికలు యొక్క పరిమాణం.
బిట్మ్యాప్ ఫైల్ హెడర్ కాబట్టి ప్లస్ పరిమాణం మరియు బిట్మ్యాప్ సమాచారం శీర్షిక యొక్క పరిమాణం.
OK.
కాబట్టి మా శీర్షికలు కోసం ఇది.
మేము ఫైలు తల వ్రాసి చేయవచ్చు మా అవ్ట్ సమాచారం శీర్షిక
ఫైల్, మరియు మేము మధురంగా.
>> ఇప్పుడు ఇది నిజానికి ప్రారంభించడానికి సమయం పిక్సెల్ రాయడం
ఫైలు అవుట్ డేటా.
మేము పరిమాణం ఒక బఫర్ ప్రకటించాలని వెళుతున్న పాత వెడల్పు RGB ట్రిపుల్స్, మరియు మేము ఉన్నాము
ఒక వేరియబుల్ అని అన్నారు మేము చూడాలని ఇది వరుసగా నంబ్,
ప్రారంభంలో ప్రతికూల 1 సమానము.
మేము ఉపయోగించి కావడం చేస్తున్న చూస్తారు ఏ ట్రాక్ క్రమంలో
మేము ప్రస్తుతం లోడుచేసినతరువాత వరుసగా ఈ బఫర్ లోకి.
OK.
>> కాబట్టి ఇప్పుడు, ప్రామాణిక ఎడిషన్ కాకుండా బదులుగా లో పైగా iterating
ఫైలు, మేము ప్రతి పైగా iterate చూడాలని ఫైలు అవుట్ లో వరుస మరియు గుర్తించడానికి
మేము మీరు లో ఫైలు లో ఇది వరుసగా ఫైలు అవుట్ లో ఈ వరుసగా ఉంచండి.
కాబట్టి అన్ని వరుసలు పైగా iterating కొత్త ఎత్తు ఉపయోగించి దాఖలు, మేము మొదటి ఉన్నారు
పాత లో వరుసగా నిర్ణయించే అన్నారు మేము, ఇది ఉపయోగించడానికి వెళుతున్న దాఖలు
ఈ ప్రస్తుత తీసుకొని చేయబోవడం వరుసగా అంశం ద్వారా విభజించబడింది.
కాబట్టి మాకు వరుసగా ఇవ్వడం అవకాశముంది మేము కావలసిన పాత ఫైలు లో.
>> కాబట్టి ఇప్పుడు ఉంటే వరుసగా నంబ్ సమానం కాదు పాత y చేస్తుంది, మేము వరుస చదవడానికి చూడాలని
మేము మా ప్రస్తుత వరుసగా బఫర్ లోకి కావలసిన.
కాబట్టి మేము ఎలా అలా వెళ్తున్నారు?
మొదటి, మేము గుర్తించడానికి చూడాలని లో ఆ వరుస మొదలై స్థానం
అసలు ఫైల్.
కాబట్టి ఆ స్థానం అన్నారు మా శీర్షికలు అన్ని మరియు గత
ఇప్పుడు గత పాత y వరుసలు.
>> కాబట్టి ఎన్ని బైట్లు ఒకే వరుసలో ఉన్న?
మళ్ళీ, మూడు రెట్లు RGB యొక్క పరిమాణం పాత వెడల్పు ప్లస్ పాత పాడింగ్, అలా ఆ
ఒకే వరుసగా బైట్లు సంఖ్య.
మరియు మేము గత పాత y వరుసలు వెళ్ళకండి.
కాబట్టి మేము f కోరుకుంటారు చూడాలని మరియు మేము ఉన్నాము నుండి ప్రారంభించడానికి సెట్ కోరుకుంటారు ఉపయోగించి
ఒక ఫైలు ప్రారంభం.
మేము ఈ స్థానానికి కోరుకుంటారు f చూడాలని ఫైలు లో, మాకు ఉంచడం
మేము వరుసగా ప్రారంభం మా బఫర్ లోకి చదవడానికి.
>> మేము వరుసగా సెట్ చూడాలని పాత y సమానంగా నంబ్.
కాబట్టి ఇప్పుడు మేము లూప్ తిరిగి మరియు మేము కావలసిన మా అవ్ట్ ఫైలు లో అదే వరుస ఉపయోగించడానికి,
అప్పుడు మేము చదవడానికి వెళ్ళి లేదు అది మళ్ళీ అనవసరంగా.
కాబట్టి నిజంగా, వరుసగా నంబ్ ఉంది కేవలం కనిపి.
>> చివరకు, మేము చదవడానికి చూడాలని ప్రస్తుత వరుస పాత వెడల్పు RGB ట్రిపుల్స్
మేము అసలు ఫైల్ నుండి కావలసిన.
కాబట్టి ఇప్పుడు ప్రస్తుత వరుసగా నుండి పిక్సెళ్ళు కలిగి మేము కావలసిన అసలు ఫైల్
ఫైలు అవుట్ లోకి రాయడానికి.
కాబట్టి ఇప్పుడు, కేవలం పైన ఇష్టం, బదులుగా పాత ఫైలు మీద iterating, మేము అవసరం
కొత్త ఫైళ్లు వరుసలు పైగా iterate.
బాగా ఇక్కడ, బదులుగా మీద iterating యొక్క అన్ని పాత పిక్సెళ్ళు ఆ ప్రస్తుత వరుసగా,
మేము అన్ని పైగా iterate మీరు ఈ లో మా కొత్త ఫైల్లోని పిక్సెల్స్
ప్రత్యేక వరుసగా.
>> ఎందుకు మేము అలా అనుకుంటున్నారు?
మేము లేదు ఇక్కడ చూడండి ఎందుకంటే నిజానికి తప్పనిసరిగా అన్ని ఉపయోగించి
అసలు ఫైల్లోని పిక్సెల్స్.
మేము తగ్గిపోతున్న చేస్తుంటే, మేము ఎందుకంటే నిజానికి పిక్సెళ్ళు వెళ్ళకండి.
మరియు మేము ఈ చూడండి -
x అంశం ద్వారా విభజించబడింది -
మేము Y చెప్పారు పేరు దగ్గరగా ఇక్కడ అద్దం గుర్తించడానికి అంశం ద్వారా విభజించబడింది ఆ
పాత y-th వరుస అనుగుణంగా ఈ కొత్త ఫైలు లో y-th వరుస.
>> ఇప్పుడు మేము అన్ని రాయాలో పాత వరుసగా నుండి ఈ పిక్సెళ్ళు
మా కొత్త వరుసలో.
మేము ఉండే చేసిన, మేము అవసరం కేవలం మా వరుస చివరిలో పాడింగ్ చాలు
మరియు మేము తిరిగి లూప్ చేస్తాము మరియు కొనసాగుతుందని మా కొత్త ఫైలు లో అన్ని వరుసలను.
చివరిలో, మేము మా పాత దగ్గరగా అవసరం , ఫైల్ మా కొత్త ఫైలు మూసివేయండి, తిరిగి
సున్నా నష్టమూ వెళ్లిన కారణంగా.
>> నా పేరు రాబ్ ఉంది మరియు ఈ రీసెస్ ఉంది.
>> [MUSIC ప్లే]