- చిత్ర అనువాదం
- చిత్రం భ్రమణం
- చిత్రం అంకగణితం
- చిత్రం ఫ్లిప్పింగ్
- చిత్రం కత్తిరించడం
- చిత్రం పరిమాణం మార్చడం
ఇప్పుడు, మేము పైన పేర్కొన్న అన్ని ఇమేజ్ ప్రాసెసింగ్ అంశాలను వివరంగా వివరిస్తాము.
1. చిత్ర అనువాదం
ఇమేజ్ ట్రాన్స్‌లేషన్ అనేది ఇమేజ్ ప్రాసెసింగ్ పద్ధతి, ఇది చిత్రాన్ని x మరియు y-అక్షాల వెంట తరలించడానికి మాకు సహాయపడుతుంది. మేము చిత్రాన్ని పైకి, క్రిందికి, కుడి, ఎడమ లేదా ఏదైనా కలయికను తరలించవచ్చు.
మేము అనువాద మాతృకను M గుర్తుతో నిర్వచించవచ్చు మరియు క్రింద చూపిన విధంగా మేము దానిని గణిత రూపంలో సూచించవచ్చు:
ఈ ప్రోగ్రామ్ ద్వారా అనువాద చిత్రం యొక్క భావనను మనం అర్థం చేసుకోవచ్చు.
పైథాన్ కోడ్: మేము ఈ క్రింది ప్రోగ్రామ్ పేరును అలాగే ఉంచుతాము translate.py .
# అవసరమైన ప్యాకేజీలను దిగుమతి చేయండిదిగుమతి మొద్దుబారిన వంటి ఉదా
దిగుమతి argparse
దిగుమతి ఇముటిల్
దిగుమతి cv2
# మేము ఆర్గ్యుమెంట్ పార్సర్‌ని అమలు చేస్తాము
ap_obj = argparse. ఆర్గ్యుమెంట్ పార్సర్ ( )
ap_obj. add_argument ( '-k' , '--చిత్రం' , అవసరం = నిజమే ,
సహాయం = 'చిత్రం ఫైల్ యొక్క స్థానం' )
ఆర్గ్స్ = ఎవరిది ( ap_obj. పార్స్_ఆర్గ్స్ ( ) )
# చిత్రాన్ని లోడ్ చేసి, స్క్రీన్‌పై చూపించండి
చిత్రం = cv2. imread ( ఆర్గ్స్ [ 'చిత్రం' ] )
cv2. చూపించు ( 'Original_image' , చిత్రం )
# చిత్రం యొక్క అనువాదం NumPy మాతృక, ఇది క్రింద ఇవ్వబడింది:
# [[1, 0, shiftX], [0, 1, shiftY]]
# మేము చిత్రాలను వెంట మార్చడానికి పై NumPy మ్యాట్రిక్స్‌ని ఉపయోగించబోతున్నాము
# x-axis మరియు y-axis దిశలు. దీని కోసం, మనం కేవలం పిక్సెల్ విలువలను పాస్ చేయాలి.
# ఈ ప్రోగ్రామ్‌లో, మేము చిత్రాన్ని 30 పిక్సెల్‌లను కుడి వైపుకు తరలిస్తాము
# మరియు దిగువన 70 పిక్సెల్‌లు.
అనువాదం_మాట = ఉదా ఫ్లోట్32 ( [ [ 1 , 0 , 30 ] , [ 0 , 1 , 70 ] ] )
చిత్రం_అనువాదం = cv2. warpAffine ( చిత్రం , అనువాదం_మాట ,
( చిత్రం. ఆకారం [ 1 ] , చిత్రం. ఆకారం [ 0 ] ) )
cv2. చూపించు ( 'చిత్ర అనువాదం క్రిందికి మరియు కుడికి' , చిత్రం_అనువాదం )
# ఇప్పుడు, మేము చిత్రాలను వెంట మార్చడానికి పై NumPy మాతృకను ఉపయోగించబోతున్నాము
# x-axis (ఎడమ) మరియు y-axis (పైకి) దిశలు.
# ఇక్కడ, మేము 50 పిక్సెల్‌ల చిత్రాలను ఎడమవైపుకు తరలించబోతున్నాము
# మరియు పైకి 90 పిక్సెల్‌లు.
అనువాదం_మాట = ఉదా ఫ్లోట్32 ( [ [ 1 , 0 , - యాభై ] , [ 0 , 1 , - 90 ] ] )
చిత్రం_అనువాదం = cv2. warpAffine ( చిత్రం , అనువాదం_మాట ,
( చిత్రం. ఆకారం [ 1 ] , చిత్రం. ఆకారం [ 0 ] ) )
cv2. చూపించు ( 'చిత్ర అనువాదం పైకి మరియు ఎడమ' , చిత్రం_అనువాదం )
cv2. వేచి ఉండండి ( 0 )
లైన్లు 1 నుండి 5: మేము ఈ ప్రోగ్రామ్ కోసం OpenCV, argparser మరియు NumPy వంటి అన్ని అవసరమైన ప్యాకేజీలను దిగుమతి చేస్తున్నాము. ఇమ్యుటిల్స్ అనే మరో లైబ్రరీ ఉందని దయచేసి గమనించండి. ఇది OpenCV యొక్క ప్యాకేజీ కాదు. ఇది లైబ్రరీ మాత్రమే, అదే ఇమేజ్ ప్రాసెసింగ్‌ను సులభంగా చూపుతుంది.
మేము OpenCVని ఇన్‌స్టాల్ చేసినప్పుడు లైబ్రరీ ఇమ్యుటిల్స్ స్వయంచాలకంగా చేర్చబడవు. కాబట్టి ఇమ్యుటిల్స్‌ను ఇన్‌స్టాల్ చేయడానికి, మేము ఈ క్రింది పద్ధతిని ఉపయోగించాలి:
పిప్ ఇన్‌స్టాల్ ఇమ్యుటిల్స్
పంక్తులు 8 నుండి 15: మేము మా అగ్రపార్సర్‌ని సృష్టించాము మరియు మా చిత్రాన్ని లోడ్ చేసాము.
లైన్లు 24 నుండి 25: ఈ ప్రోగ్రామ్ విభాగంలో అనువాదం జరుగుతుంది. అనువాద మాతృక చిత్రం ఎన్ని పిక్సెల్‌లు పైకి లేదా క్రిందికి లేదా ఎడమ లేదా కుడికి తరలించబడుతుందో తెలియజేస్తుంది. OpenCVకి మ్యాట్రిక్స్ విలువ ఫ్లోటింగ్ పాయింట్ శ్రేణిలో ఉండటం అవసరం కాబట్టి, ట్రాన్స్‌లేషన్ మ్యాట్రిక్స్ ఫ్లోటింగ్ పాయింట్ శ్రేణుల్లో విలువలను తీసుకుంటుంది.
అనువాద మాతృక యొక్క మొదటి వరుస ఇలా కనిపిస్తుంది:
మాతృక యొక్క ఈ వరుస x-అక్షం కోసం. T యొక్క విలువ x చిత్రం ఎడమ లేదా కుడి వైపుకు మార్చబడుతుందో లేదో నిర్ణయిస్తుంది. మనం ప్రతికూల విలువను పాస్ చేస్తే, చిత్రం ఎడమ వైపుకు మార్చబడుతుంది మరియు సానుకూల విలువ ఉంటే, చిత్రం కుడి వైపుకు మార్చబడుతుంది.
మేము ఇప్పుడు మాతృక యొక్క రెండవ వరుసను ఈ క్రింది విధంగా నిర్వచించాము:
మాతృక యొక్క ఈ వరుస y-అక్షం కోసం. T యొక్క విలువ వై చిత్రాన్ని పైకి లేదా క్రిందికి మార్చాలా అనేది నిర్ణయిస్తుంది. మేము ప్రతికూల విలువను పాస్ చేస్తే, చిత్రం పైకి మారుతుందని అర్థం, మరియు విలువ సానుకూలంగా ఉంటే, అప్పుడు చిత్రం క్రిందికి మార్చబడుతుంది.
లైన్ 24 వద్ద మునుపటి ప్రోగ్రామ్‌లో, మేము tని నిర్వచించాము x = 30 మరియు టి వై = 70. కాబట్టి మేము చిత్రాన్ని 30 పిక్సెల్‌లను కుడి వైపుకు మరియు 70 పిక్సెల్‌లను క్రిందికి తరలిస్తున్నాము.
కానీ ప్రధాన చిత్ర అనువాద ప్రక్రియ లైన్ 25 వద్ద జరుగుతుంది, ఇక్కడ మేము అనువాద మాతృకను నిర్వచించాము cv2.warpAffine . ఈ ఫంక్షన్‌లో, మేము మూడు పారామితులను పాస్ చేస్తున్నాము: మొదటి పరామితి చిత్రం, రెండవ పరామితి అనువాద మాతృక మరియు మూడవ పరామితి చిత్రం పరిమాణం.
పంక్తి 27: లైన్ 27 ఫలితాన్ని అవుట్‌పుట్‌లో ప్రదర్శిస్తుంది.
ఇప్పుడు, మేము ఎడమ మరియు పైకి మరొక అనువాద మాతృకను అమలు చేస్తాము. దీని కోసం, మేము ప్రతికూల విలువలను నిర్వచించాలి.
లైన్ 33 నుండి 34: లైన్ 33 వద్ద మునుపటి ప్రోగ్రామ్‌లో, మేము tని నిర్వచించాము x = -50 మరియు టి వై = -90. కాబట్టి మేము చిత్రాన్ని 50 పిక్సెల్స్ ఎడమ వైపుకు మరియు 90 పిక్సెల్స్ పైకి తరలిస్తున్నాము. కానీ ప్రధాన చిత్ర అనువాద ప్రక్రియ లైన్ 34 వద్ద జరుగుతుంది, ఇక్కడ మేము అనువాద మాతృకను నిర్వచించాము cv2.warpAffine .
లైన్ 36 : లైన్ 36 అవుట్‌పుట్‌లో చూపిన విధంగా ఫలితాన్ని ప్రదర్శిస్తుంది.
మునుపటి కోడ్‌ను అమలు చేయడానికి, మేము క్రింద ఇచ్చిన విధంగా చిత్రం యొక్క పాత్‌ను ఇవ్వాలి.
అవుట్‌పుట్: python translate.py –image squirrel.jpg
ఇప్పుడు, మేము ఉపయోగించి అదే చిత్ర అనువాద ప్రోగ్రామ్‌ను అమలు చేస్తాము ఇముటిల్ గ్రంధాలయం. ఇమేజ్ ప్రాసెసింగ్ కోసం ఈ లైబ్రరీని ఉపయోగించడం చాలా సులభం. ఈ లైబ్రరీలో, మనం దాని గురించి ఆలోచించాల్సిన అవసరం లేదు cv2.warpAffine ఎందుకంటే ఈ లైబ్రరీ దీన్ని చూసుకుంటుంది. కాబట్టి imutils లైబ్రరీని ఉపయోగించి ఈ చిత్ర అనువాద ప్రోగ్రామ్‌ను అమలు చేద్దాం.
పైథాన్ కోడ్: మేము ఈ క్రింది ప్రోగ్రామ్ పేరును అలాగే ఉంచుతాము translate_imutils.py .
# అవసరమైన ప్యాకేజీలను దిగుమతి చేయండిదిగుమతి మొద్దుబారిన వంటి ఉదా
దిగుమతి argparse
దిగుమతి ఇముటిల్
దిగుమతి cv2
# ఈ ఫంక్షన్ చిత్ర అనువాదాన్ని అమలు చేస్తుంది మరియు
# అనువదించబడిన చిత్రాన్ని కాలింగ్ ఫంక్షన్‌కి అందిస్తుంది.
డెఫ్ అనువదించు ( చిత్రం , x , వై ) :
అనువాదం_మాతృక = ఉదా ఫ్లోట్32 ( [ [ 1 , 0 , x ] , [ 0 , 1 , వై ] ] )
చిత్రం_అనువాదం = cv2. warpAffine ( చిత్రం , అనువాదం_మాతృక ,
( చిత్రం. ఆకారం [ 1 ] , చిత్రం. ఆకారం [ 0 ] ) )
తిరిగి చిత్రం_అనువాదం
# ఆర్గ్యుమెంట్ పార్సర్‌ను నిర్మించండి మరియు ఆర్గ్యుమెంట్‌లను అన్వయించండి
ap = argparse. ఆర్గ్యుమెంట్ పార్సర్ ( )
ap. add_argument ( '-నేను' , '--చిత్రం' , అవసరం = నిజమే , సహాయం = 'చిత్రానికి మార్గం' )
ఆర్గ్స్ = ఎవరిది ( ap. పార్స్_ఆర్గ్స్ ( ) )
# చిత్రాన్ని లోడ్ చేసి, స్క్రీన్‌పై ప్రదర్శించండి
చిత్రం = cv2. imread ( ఆర్గ్స్ [ 'చిత్రం' ] )
cv2. చూపించు ( 'Original_image' , చిత్రం )
చిత్రం_అనువాదం = ఇముటిల్. అనువదించు ( చిత్రం , 10 , 70 )
cv2. చూపించు ( 'చిత్ర అనువాదం కుడివైపు మరియు దిగువ వైపు' ,
చిత్రం_అనువాదం )
cv2. వేచి ఉండండి ( 0 )
లైన్లు 9 నుండి 13: ప్రోగ్రామ్ యొక్క ఈ విభాగంలో అనువాదం జరుగుతుంది. అనువాద మాతృక చిత్రం ఎన్ని పిక్సెల్‌ల ద్వారా పైకి లేదా క్రిందికి లేదా ఎడమ లేదా కుడికి తరలించబడుతుందో తెలియజేస్తుంది.
ఈ పంక్తులు ఇప్పటికే వివరించబడ్డాయి, కానీ ఇప్పుడు మేము అనువదించు () అనే ఫంక్షన్‌ని నిర్మించబోతున్నాము మరియు దానిలో మూడు విభిన్న పారామితులను పంపుతాము. చిత్రం మొదటి పరామితిగా పనిచేస్తుంది. అనువాద మాతృక యొక్క x మరియు y విలువలు రెండవ మరియు మూడవ పారామితులకు అనుగుణంగా ఉంటాయి.
గమనిక : ఇది ఇప్పటికే imutils లైబ్రరీ ప్యాకేజీలో చేర్చబడినందున ప్రోగ్రామ్ లోపల ఈ అనువాద ఫంక్షన్‌ని నిర్వచించాల్సిన అవసరం లేదు. నేను సూటిగా వివరణ కోసం ప్రోగ్రామ్‌లో ఉపయోగించాను. పంక్తి 24లో చూపిన విధంగా మనం ఈ ఫంక్షన్‌ని నేరుగా ఇమ్యుటిల్స్‌తో కాల్ చేయవచ్చు.
పంక్తి 24: మునుపటి ప్రోగ్రామ్ లైన్ 24 వద్ద, మేము tx = 10 మరియు ty = 70 నిర్వచించమని చూపుతుంది. కాబట్టి మేము చిత్రాన్ని 10 పిక్సెల్‌లను కుడి వైపుకు మరియు 70 పిక్సెల్‌లను క్రిందికి తరలిస్తున్నాము.
ఈ ప్రోగ్రామ్‌లో, మేము ఏ cv2.warpAffine ఫంక్షన్‌ల గురించి పట్టించుకోము ఎందుకంటే అవి ఇప్పటికే imutils లైబ్రరీ ప్యాకేజీలో ఉన్నాయి.
మునుపటి కోడ్‌ని అమలు చేయడానికి, క్రింద ఇచ్చిన విధంగా మనం చిత్రం యొక్క మార్గాన్ని ఇవ్వాలి:
అవుట్‌పుట్:
పైథాన్ ఇమ్యుటిల్స్. py --చిత్రం ఉడుత. jpg 
2. ఇమేజ్ రొటేషన్
మునుపటి పాఠంలో (లేదా ఏదైనా కలయిక) చిత్రాన్ని పైకి, క్రిందికి, ఎడమ మరియు కుడికి ఎలా అనువదించాలో (అంటే, షిఫ్ట్) మేము పరిశీలించాము. తరువాత, ఇమేజ్ ప్రాసెసింగ్‌కు సంబంధించి మేము భ్రమణాన్ని చర్చిస్తాము.
భ్రమణం అని పిలువబడే ప్రక్రియలో ఒక చిత్రం తీటా అనే కోణం ద్వారా తిప్పబడుతుంది. మనం చిత్రాన్ని తిప్పుతున్న కోణం తీటా ద్వారా సూచించబడుతుంది. అదనంగా, నేను తిరిగే చిత్రాలను సులభతరం చేయడానికి రొటేట్ సౌలభ్యం ఫంక్షన్‌ను తదనంతరం అందిస్తాను.
అనువాదం వలె, మరియు బహుశా ఆశ్చర్యం లేదు, కోణం ద్వారా భ్రమణం, తీటా క్రింది ఆకృతిలో మాతృక Mని నిర్మించడం ద్వారా నిర్ణయించబడుతుంది:
ఈ మాత్రిక వెక్టార్ తీటా డిగ్రీలు (ఎక్స్, y)-కార్టీసియన్ ప్లేన్ ఇచ్చిన మూలం చుట్టూ తిప్పవచ్చు. సాధారణంగా, ఈ దృష్టాంతంలో, మూలం చిత్రం యొక్క కేంద్రంగా ఉంటుంది, కానీ వాస్తవానికి, మనం ఏదైనా యాదృచ్ఛిక (x, y) పాయింట్‌ని మా భ్రమణ కేంద్రంగా పేర్కొనవచ్చు.
తిప్పబడిన చిత్రం R అప్పుడు నేను నేరుగా మాతృక గుణకారాన్ని ఉపయోగించి అసలు చిత్రం నుండి సృష్టించబడుతుంది: R = IM
మరోవైపు, OpenCV, ఒక ఇమేజ్‌ని (1) స్కేల్ (అంటే, పునఃపరిమాణం) చేసే సామర్థ్యాన్ని అదనంగా అందిస్తుంది మరియు (2) చుట్టూ భ్రమణాన్ని నిర్వహించడానికి ఏకపక్ష భ్రమణ కేంద్రాన్ని అందిస్తుంది.
మా సవరించిన భ్రమణ మాతృక M క్రింద చూపబడింది:
అనే కొత్త ఫైల్‌ని తెరిచి, రూపొందించడం ద్వారా ప్రారంభిద్దాం తిప్పండి.py :
# అవసరమైన ప్యాకేజీలను దిగుమతి చేస్తోందిదిగుమతి మొద్దుబారిన వంటి ఉదా
దిగుమతి argparse
దిగుమతి ఇముటిల్
దిగుమతి cv2
# ఆర్గ్యుమెంట్‌పార్సర్ ఆబ్జెక్ట్‌ని సృష్టించడం మరియు ఆర్గ్యుమెంట్‌ను పార్సింగ్ చేయడం
apobj = argparse. ఆర్గ్యుమెంట్ పార్సర్ ( )
apobj. add_argument ( '-k' , '--చిత్రం' , అవసరం = నిజమే , సహాయం = 'చిత్ర మార్గం' )
వాదనలు = ఎవరిది ( apobj. పార్స్_ఆర్గ్స్ ( ) )
చిత్రం = cv2. imread ( వాదనలు [ 'చిత్రం' ] )
cv2. చూపించు ( 'Original_image' , చిత్రం )
# చిత్రం యొక్క కొలతలు ఉపయోగించి చిత్రం యొక్క మధ్యభాగాన్ని లెక్కించండి.
( ఎత్తు , వెడల్పు ) = చిత్రం. ఆకారం [ : 2 ]
( సెంటర్ఎక్స్ , కేంద్రంY ) = ( వెడల్పు / 2 , ఎత్తు / 2 )
# ఇప్పుడు, cv2ని ఉపయోగించి, మేము చిత్రాన్ని 55 డిగ్రీల వరకు తిప్పుతాము
# getRotationMatrix2D()ని ఉపయోగించి భ్రమణ మాతృకను నిర్ణయించండి
భ్రమణ మాతృక = cv2. getRotationMatrix2D ( ( సెంటర్ఎక్స్ , కేంద్రంY ) , 55 , 1.0 )
తిప్పబడిన చిత్రం = cv2. warpAffine ( చిత్రం , భ్రమణ మాతృక , ( వెడల్పు , ఎత్తు ) )
cv2. చూపించు ( 'చిత్రాన్ని 55 డిగ్రీలు తిప్పారు' , తిప్పబడిన చిత్రం )
cv2. వేచి ఉండండి ( 0 )
# చిత్రం ఇప్పుడు -85 డిగ్రీలతో తిప్పబడుతుంది.
భ్రమణ మాతృక = cv2. getRotationMatrix2D ( ( సెంటర్ఎక్స్ , కేంద్రంY ) , - 85 , 1.0 )
తిప్పబడిన చిత్రం = cv2. warpAffine ( చిత్రం , భ్రమణ మాతృక , ( వెడల్పు , ఎత్తు ) )
cv2. చూపించు ( 'చిత్రాన్ని -85 డిగ్రీలు తిప్పారు' , తిప్పబడిన చిత్రం )
cv2. వేచి ఉండండి ( 0 )
లైన్లు 1 నుండి 5: మేము ఈ ప్రోగ్రామ్ కోసం OpenCV, argparser మరియు NumPy వంటి అన్ని అవసరమైన ప్యాకేజీలను దిగుమతి చేస్తున్నాము. ఇమ్యుటిల్స్ అనే మరో లైబ్రరీ ఉందని దయచేసి గమనించండి. ఇది OpenCV యొక్క ప్యాకేజీ కాదు. ఇది లైబ్రరీ మాత్రమే, అదే ఇమేజ్ ప్రాసెసింగ్‌ను సులభంగా చూపించడానికి ఉపయోగించబడుతుంది.
మేము OpenCVని ఇన్‌స్టాల్ చేసినప్పుడు లైబ్రరీ ఇమ్యుటిల్స్ స్వయంచాలకంగా చేర్చబడవు. OpenCV ఇమ్యుటిల్స్‌ను ఇన్‌స్టాల్ చేస్తుంది. మేము ఈ క్రింది పద్ధతిని ఉపయోగించాలి:
పిప్ ఇన్‌స్టాల్ ఇమ్యుటిల్స్
పంక్తులు 8 నుండి 14: మేము మా అగ్రపార్సర్‌ని సృష్టించాము మరియు మా చిత్రాన్ని లోడ్ చేసాము. ఈ ఆర్గ్‌పార్సర్‌లో, మేము ఒక ఇమేజ్ ఆర్గ్యుమెంట్‌ను మాత్రమే ఉపయోగిస్తాము, ఇది భ్రమణాన్ని ప్రదర్శించడానికి ఈ ప్రోగ్రామ్‌లో మనం ఉపయోగించే చిత్రం యొక్క మార్గాన్ని తెలియజేస్తుంది.
చిత్రాన్ని తిప్పేటప్పుడు, మనం తప్పనిసరిగా భ్రమణ పివోట్ పాయింట్‌ని నిర్వచించాలి. ఎక్కువ సమయం, మీరు చిత్రాన్ని దాని మధ్యలో తిప్పాలనుకుంటున్నారు, కానీ OpenCV బదులుగా ఏదైనా యాదృచ్ఛిక పాయింట్‌ని ఎంచుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది. చిత్రాన్ని దాని మధ్యలో తిప్పండి.
లైన్లు 17 నుండి 18 చిత్రం యొక్క వెడల్పు మరియు ఎత్తును వరుసగా తీసుకుని, ఆపై ప్రతి పరిమాణాన్ని రెండుగా విభజించి చిత్రం యొక్క కేంద్రాన్ని స్థాపించండి.
మేము చిత్రాన్ని అనువదించడానికి మాతృకను నిర్వచించిన విధంగానే చిత్రాన్ని తిప్పడానికి మాతృకను నిర్మిస్తాము. మేము కేవలం కాల్ చేస్తాము cv2.getRotationMatrix2D NumPyని ఉపయోగించి మ్యాట్రిక్స్‌ను మాన్యువల్‌గా సృష్టించడం కంటే లైన్ 22లో పని చేస్తుంది (ఇది కొంచెం గజిబిజిగా ఉండవచ్చు).
ది cv2.getRotationMatrix2D ఫంక్షన్‌కు మూడు పారామితులు అవసరం. మొదటి ఇన్‌పుట్ కావలసిన భ్రమణ కోణం (ఈ సందర్భంలో, చిత్రం మధ్యలో). మేము చిత్రాన్ని ఎన్ని (అపసవ్యదిశలో) డిగ్రీలు తిప్పుతాము అని పేర్కొనడానికి తీటా ఉపయోగించబడుతుంది. ఇక్కడ, మేము చిత్రాన్ని 45 డిగ్రీలు తిప్పుతాము. చివరి ఎంపిక చిత్రం పరిమాణానికి సంబంధించినది.
చిత్రాన్ని స్కేలింగ్ చేయడం గురించి మేము ఇంకా చర్చించనప్పటికీ, మీరు చిత్రాన్ని దాని అసలు నిష్పత్తిలో ఉపయోగించాలని సూచించే 1.0తో ఫ్లోటింగ్ పాయింట్ నంబర్‌ను ఇక్కడ అందించవచ్చు. అయితే, మీరు 2.0 విలువను టైప్ చేస్తే, చిత్రం పరిమాణం రెట్టింపు అవుతుంది. 0.5 సంఖ్య చిత్రం పరిమాణాన్ని ఆ విధంగా తగ్గిస్తుంది.
పంక్తి 22 నుండి 23: నుండి మా భ్రమణ మాతృక M అందుకున్న తర్వాత cv2.getRotationMatrix2D ఫంక్షన్, మేము ఉపయోగించి మా చిత్రాన్ని రొటేట్ cv2.warpAffine లైన్ 23లో సాంకేతికత. ఫంక్షన్ యొక్క మొదటి ఇన్‌పుట్ మనం తిప్పాలనుకుంటున్న చిత్రం. అప్పుడు మా అవుట్‌పుట్ ఇమేజ్ యొక్క వెడల్పు మరియు ఎత్తు నిర్వచించబడతాయి, మా భ్రమణ మాతృక M. లైన్ 23లో, చిత్రం 55 డిగ్రీలతో తిప్పబడుతుంది.
మా చిత్రం తిప్పబడిందని మీరు గమనించవచ్చు.
లైన్లు 28 నుండి 30 రెండవ భ్రమణాన్ని ఏర్పాటు చేయండి. కోడ్‌లోని 22–23 పంక్తులు ఒకేలా ఉంటాయి, ఈసారి మనం 55కి విరుద్ధంగా -85 డిగ్రీలతో తిరుగుతున్నాము తప్ప.
మేము ఈ పాయింట్ వరకు చిత్రాన్ని దాని మధ్యలో తిప్పాము. మనం చిత్రాన్ని యాదృచ్ఛిక పాయింట్ చుట్టూ తిప్పాలనుకుంటే?
అనే కొత్త ఫైల్‌ని తెరిచి, రూపొందించడం ద్వారా ప్రారంభిద్దాం rotate.py:
# అవసరమైన ప్యాకేజీలను దిగుమతి చేస్తోందిదిగుమతి మొద్దుబారిన వంటి ఉదా
దిగుమతి argparse
దిగుమతి ఇముటిల్
దిగుమతి cv2
# ఆర్గ్యుమెంట్‌పార్సర్ ఆబ్జెక్ట్‌ని సృష్టించడం మరియు ఆర్గ్యుమెంట్‌ను పార్సింగ్ చేయడం
ap_obj = argparse. ఆర్గ్యుమెంట్ పార్సర్ ( )
ap_obj. add_argument ( '-k' , '--చిత్రం' , అవసరం = నిజమే , సహాయం = 'చిత్ర మార్గం' )
వాదన = ఎవరిది ( ap_obj. పార్స్_ఆర్గ్స్ ( ) )
# చిత్రాన్ని లోడ్ చేసి, స్క్రీన్‌పై ప్రదర్శించండి
చిత్రం = cv2. imread ( వాదన [ 'చిత్రం' ] )
cv2. చూపించు ( 'Original_image' , చిత్రం )
# చిత్రం యొక్క కొలతలు ఉపయోగించి చిత్రం యొక్క మధ్యభాగాన్ని లెక్కించండి.
( ఎత్తు , వెడల్పు ) = చిత్రం. ఆకారం [ : 2 ]
( సెంటర్ఎక్స్ , కేంద్రంY ) = ( వెడల్పు / 2 , ఎత్తు / 2 )
# ఇప్పుడు, cv2ని ఉపయోగించి, మేము చిత్రాన్ని 55 డిగ్రీల వరకు తిప్పుతాము
# getRotationMatrix2D()ని ఉపయోగించి భ్రమణ మాతృకను నిర్ణయించండి
భ్రమణ మాతృక = cv2. getRotationMatrix2D ( ( సెంటర్ఎక్స్ , కేంద్రంY ) , 55 , 1.0 )
తిప్పబడిన చిత్రం = cv2. warpAffine ( చిత్రం , భ్రమణ మాతృక , ( వెడల్పు , ఎత్తు ) )
cv2. చూపించు ( 'చిత్రాన్ని 55 డిగ్రీలు తిప్పారు' , తిప్పబడిన చిత్రం )
cv2. వేచి ఉండండి ( 0 )
# చిత్రం ఇప్పుడు -85 డిగ్రీలతో తిప్పబడుతుంది.
భ్రమణ మాతృక = cv2. getRotationMatrix2D ( ( సెంటర్ఎక్స్ , కేంద్రంY ) , - 85 , 1.0 )
తిప్పబడిన చిత్రం = cv2. warpAffine ( చిత్రం , భ్రమణ మాతృక , ( వెడల్పు , ఎత్తు ) )
cv2. చూపించు ( 'చిత్రాన్ని -85 డిగ్రీలు తిప్పారు' , తిప్పబడిన చిత్రం )
cv2. వేచి ఉండండి ( 0 )
# చిత్రం భ్రమణం కొన్ని ఏకపక్ష పాయింట్ నుండి, కేంద్రం నుండి కాదు
భ్రమణ మాతృక = cv2. getRotationMatrix2D ( ( సెంటర్ఎక్స్ - 40 , కేంద్రంY - 40 ) , 55 , 1.0 )
తిప్పబడిన చిత్రం = cv2. warpAffine ( చిత్రం , భ్రమణ మాతృక , ( వెడల్పు , ఎత్తు ) )
cv2. చూపించు ( 'ఏకపక్ష పాయింట్ల నుండి ఇమేజ్ రొటేషన్' , తిప్పబడిన చిత్రం )
cv2. వేచి ఉండండి ( 0 )
లైన్ 34 నుండి 35: ఇప్పుడు, ఈ కోడ్ ఒక వస్తువును తిప్పడానికి చాలా సాధారణమైనదిగా అనిపించాలి. చిత్రాన్ని ఒక పాయింట్ చుట్టూ 40 పిక్సెల్‌లు ఎడమవైపు మరియు 40 పిక్సెల్‌ల మధ్యలో తిప్పడానికి, మేము ఆదేశిస్తాము cv2.getRotationMatrix2D దాని మొదటి పరామితికి శ్రద్ధ వహించడానికి ఫంక్షన్.
మేము ఈ భ్రమణాన్ని వర్తింపజేసినప్పుడు ఉత్పత్తి చేయబడిన చిత్రం క్రింద చూపబడింది:
భ్రమణం యొక్క కేంద్రం ఇప్పుడు (x, y)-కోఆర్డినేట్ అని మనం స్పష్టంగా చూడవచ్చు, ఇది ఎడమవైపు 40 పిక్సెల్‌లు మరియు చిత్రం యొక్క కంప్యూటెడ్ సెంటర్‌కు ఎగువన 40 పిక్సెల్‌లు.
3. చిత్రం అంకగణితం
వాస్తవానికి, ఇమేజ్ అంకగణితం అనేది డేటా రకాలపై కొన్ని అదనపు పరిమితులతో కూడిన మ్యాట్రిక్స్ అదనం, మేము తర్వాత కవర్ చేస్తాము.
లీనియర్ ఆల్జీబ్రా యొక్క కొన్ని అందమైన ఫండమెంటల్స్‌పైకి వెళ్లడానికి కొంత సమయం తీసుకుందాం.
తదుపరి రెండు మాత్రికలను కలపడాన్ని పరిగణించండి:
మ్యాట్రిక్స్ జోడింపు ఎలాంటి ఫలితాన్ని ఇస్తుంది? సాధారణ సమాధానం మూలకం ద్వారా మూలకం, మాతృక ఎంట్రీల మొత్తం:
తగినంత సులభం, సరియైనదా?
ఈ సమయంలో కూడిక మరియు తీసివేత యొక్క ప్రాథమిక కార్యకలాపాలను మనమందరం అర్థం చేసుకున్నాము. అయినప్పటికీ, చిత్రాలతో పని చేస్తున్నప్పుడు మన కలర్ స్పేస్ మరియు డేటా రకం ద్వారా విధించబడిన పరిమితులను మనం గుర్తుంచుకోవాలి.
RGB చిత్రాలలో పిక్సెల్‌లు, ఉదాహరణకు, [0, 255] మధ్య వస్తాయి. మనం చూస్తున్నప్పుడు 250 తీవ్రతతో పిక్సెల్‌కు 10 జోడించడానికి ప్రయత్నిస్తే ఏమి జరుగుతుంది?
మేము ప్రామాణిక అంకగణిత సూత్రాలను వర్తింపజేస్తే మేము 260 విలువకు చేరుకుంటాము. 260 చెల్లుబాటు అయ్యే విలువ కాదు, ఎందుకంటే RGB చిత్రాలు 8-బిట్ సంతకం చేయని పూర్ణాంకాలుగా సూచించబడతాయి.
కాబట్టి ఏమి జరగాలి? ప్రతి పిక్సెల్‌ను 0 మరియు 255 మధ్య విలువ ఉండేలా క్లిప్ చేస్తూ, [0, 255] పరిధికి మించిన పిక్సెల్ లేదని నిర్ధారించుకోవడానికి మేము చెక్‌ను అమలు చేయాలా?
లేదా మేము 'చుట్టూ చుట్టి' మరియు మాడ్యులస్ ఆపరేషన్ చేస్తాము? మాడ్యులస్ నియమాలకు అనుగుణంగా, 10 నుండి 255కి జోడించడం వలన కేవలం 9 విలువ వస్తుంది.
[0, 255] పరిధికి మించిన చిత్రాలకు కూడికలు మరియు తీసివేతలను ఎలా నిర్వహించాలి?
నిజం ఏమిటంటే సరైన లేదా తప్పు సాంకేతికత లేదు; మీరు మీ పిక్సెల్‌లతో ఎలా పని చేస్తున్నారు మరియు మీరు ఏమి సాధించాలనుకుంటున్నారు అనే దానిపై ఆధారపడి ఉంటుంది.
కానీ OpenCVలో అదనంగా మరియు NumPyలో అదనంగా తేడాలు ఉన్నాయని గుర్తుంచుకోండి. మాడ్యులస్ అంకగణితం మరియు “ర్యాప్ ఎరౌండ్” NumPy ద్వారా చేయబడుతుంది. దీనికి విరుద్ధంగా, OpenCV క్లిప్పింగ్‌ని అమలు చేస్తుంది మరియు పిక్సెల్ విలువలు పరిధి [0, 255] నుండి ఎప్పటికీ వదలకుండా చూసుకుంటుంది.
అనే కొత్త ఫైల్‌ని సృష్టించడం ద్వారా ప్రారంభిద్దాం అంకగణితం.py మరియు దానిని తెరవడం:
# python arithmetic.py --image squirrel.jpg# అవసరమైన ప్యాకేజీలను దిగుమతి చేస్తోంది
దిగుమతి మొద్దుబారిన వంటి ఉదా
దిగుమతి argparse
దిగుమతి ఇముటిల్
దిగుమతి cv2
# ఆర్గ్యుమెంట్‌పార్సర్ ఆబ్జెక్ట్‌ని సృష్టించడం మరియు ఆర్గ్యుమెంట్‌ను పార్సింగ్ చేయడం
apObj = argparse. ఆర్గ్యుమెంట్ పార్సర్ ( )
apObj. add_argument ( '-k' , '--చిత్రం' , అవసరం = నిజమే , సహాయం = 'చిత్ర మార్గం' )
వాదనలు = ఎవరిది ( apObj. పార్స్_ఆర్గ్స్ ( ) )
చిత్రం = cv2. imread ( వాదనలు [ 'చిత్రం' ] )
cv2. చూపించు ( 'Original_image' , చిత్రం )
'''
మా పిక్సెల్‌ల విలువలు [0, 255] పరిధిలో ఉంటాయి
ఎందుకంటే చిత్రాలు NumPy శ్రేణులు, అవి సంతకం చేయని 8-బిట్ పూర్ణాంకాల వలె నిల్వ చేయబడతాయి.
cv2.add మరియు cv2.subtract వంటి ఫంక్షన్‌లను ఉపయోగిస్తున్నప్పుడు, విలువలు క్లిప్ చేయబడతాయి
ఈ పరిధికి అవి జోడించబడినా లేదా వెలుపలి నుండి తీసివేసినా కూడా
[0, 255] పరిధి. ఇక్కడ ఒక దృష్టాంతం ఉంది:
'''
ముద్రణ ( 'గరిష్టంగా 255: {}' . ఫార్మాట్ ( str ( cv2. జోడించు ( ఉదా uint8 ( [ 201 ] ) ,
ఉదా uint8 ( [ 100 ] ) ) ) ) )
ముద్రణ ( 'కనీసం 0: {}' . ఫార్మాట్ ( str ( cv2. తీసివేయుము ( ఉదా uint8 ( [ 60 ] ) ,
ఉదా uint8 ( [ 100 ] ) ) ) ) )
'''
NumPyని ఉపయోగించి ఈ శ్రేణులతో అంకగణిత కార్యకలాపాలు చేస్తున్నప్పుడు,
విలువ క్లిప్ చేయబడకుండా చుట్టుముడుతుంది
[0, 255]పరిధి. చిత్రాలను ఉపయోగిస్తున్నప్పుడు, దీన్ని ఉంచడం చాలా అవసరం
బుర్రలో.
'''
ముద్రణ ( 'చుట్టూ చుట్టండి: {}' . ఫార్మాట్ ( str ( ఉదా uint8 ( [ 201 ] ) + ఉదా. uint8 ( [ 100 ] ) ) ) )
ముద్రణ ( 'చుట్టూ చుట్టండి: {}' . ఫార్మాట్ ( str ( ఉదా uint8 ( [ 60 ] ) - ఉదా. uint8 ( [ 100 ] ) ) ) )
'''
మన ఇమేజ్‌లోని ప్రతి పిక్సెల్ ప్రకాశాన్ని 101తో గుణిద్దాం.
దీన్ని చేయడానికి, మేము మా మ్యాట్రిక్స్ వలె అదే పరిమాణంలో NumPy శ్రేణిని రూపొందిస్తాము,
వాటిని నింపి, 101తో గుణించి శ్రేణిని నింపండి
101లతో. చివరగా, మేము రెండు చిత్రాలను విలీనం చేస్తాము.
చిత్రం ఇప్పుడు 'ప్రకాశవంతంగా' ఉందని మీరు గమనించవచ్చు.
'''
మాతృక = ఉదా వాటిని ( చిత్రం. ఆకారం , dtype = 'uint8' ) * 101
చిత్రం_జోడించబడింది = cv2. జోడించు ( చిత్రం , మాతృక )
cv2. చూపించు ( 'జోడించిన చిత్రం ఫలితం' , చిత్రం_జోడించబడింది )
#ఇదే పద్ధతిలో, తీయడం ద్వారా మన చిత్రాన్ని ముదురు రంగులోకి మార్చుకోవచ్చు
అన్ని పిక్సెల్‌ల నుండి # 60 దూరంలో ఉంది.
మాతృక = ఉదా వాటిని ( చిత్రం. ఆకారం , dtype = 'uint8' ) * 60
చిత్రం_తీసివేయబడింది = cv2. తీసివేయుము ( చిత్రం , మాతృక )
cv2. చూపించు ( 'తీసిన చిత్రం ఫలితం' , చిత్రం_తీసివేయబడింది )
cv2. వేచి ఉండండి ( 0 )
లైన్లు 1 నుండి 16 మా ప్యాకేజీలను దిగుమతి చేసుకోవడం, మా ఆర్గ్యుమెంట్ పార్సర్‌ను కాన్ఫిగర్ చేయడం మరియు మా చిత్రాన్ని లోడ్ చేయడం వంటి మా సాధారణ ప్రక్రియను నిర్వహించడానికి ఉపయోగించబడుతుంది.
OpenCV మరియు NumPy జోడింపుల మధ్య వ్యత్యాసాన్ని నేను గతంలో ఎలా చర్చించానో గుర్తు చేస్తున్నారా? ఇప్పుడు మేము దానిని పూర్తిగా కవర్ చేసాము, మేము దానిని గ్రహించినట్లు నిర్ధారించుకోవడానికి ఒక నిర్దిష్ట సందర్భాన్ని చూద్దాం.
రెండు 8-బిట్ సంతకం చేయని పూర్ణాంకం NumPy శ్రేణులు నిర్వచించబడ్డాయి లైన్ 26 . 201 విలువ మొదటి శ్రేణిలోని ఏకైక మూలకం. రెండవ శ్రేణిలో ఒక సభ్యుడు మాత్రమే ఉన్నప్పటికీ, దాని విలువ 100. విలువలు OpenCV యొక్క cv2.add ఫంక్షన్‌ని ఉపయోగించి జోడించబడతాయి.
ఫలితం ఎలా ఉంటుందని మీరు అంచనా వేస్తున్నారు?
సాంప్రదాయిక అంకగణిత సూత్రాలకు అనుగుణంగా, సమాధానం 301గా ఉండాలి. కానీ మేము 8-బిట్ సంతకం చేయని పూర్ణాంకాలతో వ్యవహరిస్తున్నామని గుర్తుంచుకోండి, ఇది పరిధి [0, 255]లో మాత్రమే ఉంటుంది. మేము cv2.add పద్ధతిని ఉపయోగిస్తున్నందున, OpenCV క్లిప్పింగ్‌ను నిర్వహిస్తుంది మరియు అదనంగా గరిష్టంగా 255 ఫలితాన్ని మాత్రమే అందిస్తుంది.
దిగువ జాబితా యొక్క మొదటి పంక్తి ఈ కోడ్‌ను అమలు చేయడం ద్వారా ఫలితాన్ని చూపుతుంది:
అంకగణితం. pyగరిష్టంగా 255 : [ [ 255 ] ]
మొత్తం నిజానికి 255 సంఖ్యను ఉత్పత్తి చేసింది.
దానిని అనుసరించి, లైన్ 26 వ్యవకలనాన్ని సాధించడానికి cv2.subtractని ఉపయోగిస్తుంది. మరోసారి, మేము రెండు 8-బిట్ సంతకం చేయని పూర్ణాంకాల NumPy శ్రేణులను ఒక్కొక్క మూలకంతో నిర్వచించాము. మొదటి శ్రేణి విలువ 60, రెండవ శ్రేణి విలువ 100.
తీసివేత విలువ -40కి దారితీస్తుందని మా అంకగణితం నిర్దేశిస్తుంది, అయితే OpenCV మన కోసం క్లిప్పింగ్‌ను మరోసారి నిర్వహిస్తుంది. విలువ 0కి తగ్గించబడిందని మేము కనుగొన్నాము. దిగువన ఉన్న మా ఫలితం దీనిని ప్రదర్శిస్తుంది:
అంకగణితం. pyకనీస 0 : [ [ 0 ] ]
cv2ని ఉపయోగించి, 60 వ్యవకలనం నుండి 100ని తీసివేయండి, విలువ 0ని ఉత్పత్తి చేయండి.
గణనలను నిర్వహించడానికి OpenCV స్థానంలో NumPyని ఉపయోగిస్తే ఏమి జరుగుతుంది?
లైన్లు 38 మరియు 39 ఈ సమస్యను పరిష్కరించండి.
మొదట, రెండు 8-బిట్ సంతకం చేయని పూర్ణాంకం NumPy శ్రేణులు ఒక్కొక్క మూలకంతో నిర్వచించబడ్డాయి. మొదటి శ్రేణి విలువ 201, అయితే రెండవ శ్రేణి విలువ 100. మా జోడింపు కత్తిరించబడుతుంది మరియు మేము cv2.add ఫంక్షన్‌ని ఉపయోగిస్తే 255 విలువ తిరిగి ఇవ్వబడుతుంది.
NumPy, మరోవైపు, క్లిప్పింగ్ కాకుండా మాడ్యులో అంకగణితాన్ని 'చుట్టూ' చేస్తుంది. 255 విలువను చేరుకున్న తర్వాత NumPy సున్నాకి చుట్టుముడుతుంది మరియు 100 దశలను చేరుకునే వరకు మళ్లీ లెక్కింపు ప్రారంభమవుతుంది. ఇది దిగువ చూపిన అవుట్‌పుట్ యొక్క మొదటి పంక్తి ద్వారా నిర్ధారించబడింది:
అంకగణితం. pyచుట్టుముట్టండి: [ నాలుగు ఐదు ]
తర్వాత, మరో రెండు NumPy శ్రేణులు నిర్వచించబడ్డాయి, ఒకటి 50 విలువతో మరియు మరొకటి 100తో. ఈ వ్యవకలనం cv2.subtract పద్ధతి ద్వారా 0 ఫలితాన్ని అందించడానికి కత్తిరించబడుతుంది. కానీ క్లిప్పింగ్‌కు బదులుగా, NumPy అమలు చేస్తుందని మాకు తెలుసు. మాడ్యులో అంకగణితం. బదులుగా, మాడ్యులో విధానాలు చుట్టబడి, తీసివేత సమయంలో 0కి చేరుకున్న తర్వాత 255 నుండి వెనుకకు లెక్కించడం ప్రారంభిస్తాయి. కింది అవుట్‌పుట్ నుండి మనం దీనిని చూడవచ్చు:
అంకగణితం. pyచుట్టుముట్టండి: [ 207 ]
మరోసారి, మా టెర్మినల్ అవుట్‌పుట్ క్లిప్పింగ్ మరియు చుట్టూ చుట్టడం మధ్య వ్యత్యాసాన్ని ప్రదర్శిస్తుంది:
పూర్ణాంక అంకగణితాన్ని ప్రదర్శించేటప్పుడు మీరు కోరుకున్న ఫలితాన్ని గుర్తుంచుకోవడం చాలా ముఖ్యం. మీరు పరిధి [0, 255] వెలుపల ఏవైనా విలువలు క్లిప్ చేయాలనుకుంటున్నారా? ఆ తర్వాత OpenCV యొక్క అంతర్నిర్మిత చిత్ర అంకగణిత పద్ధతులను ఉపయోగించండి.
విలువలు [0, 255] మరియు మాడ్యులస్ అంకగణిత కార్యకలాపాల పరిధికి వెలుపల ఉన్నట్లయితే మీరు వాటిని చుట్టుముట్టాలనుకుంటున్నారా? NumPy శ్రేణులు సాధారణం వలె జోడించబడతాయి మరియు తీసివేయబడతాయి.
లైన్ 48 మా చిత్రం వలె అదే కొలతలు కలిగిన ఒక డైమెన్షనల్ NumPy శ్రేణిని నిర్వచిస్తుంది. మరోసారి, మా డేటా రకం 8-బిట్ సంతకం చేయని పూర్ణాంకాల అని మేము నిర్ధారిస్తాము. మేము 1కి బదులుగా 101 విలువలతో పూరించడానికి మా ఒక-అంకెల విలువలను 101తో గుణిస్తాము. చివరగా, అసలు ఇమేజ్‌కి 100ల మాతృకను జోడించడానికి cv2.add ఫంక్షన్‌ని ఉపయోగిస్తాము. ఇది ప్రతి పిక్సెల్ యొక్క తీవ్రతను 101 పెంచుతుంది, అలాగే 255 కంటే ఎక్కువ ప్రయత్నించే ఏవైనా విలువలు పరిధి [0, 255]కి క్లిప్ చేయబడిందని నిర్ధారిస్తుంది.
చిత్రం ఎలా గమనించదగ్గ ప్రకాశవంతంగా ఉందో మరియు అసలైన దానికంటే ఎక్కువగా 'వాష్ అవుట్'గా ఎలా కనిపిస్తుందో గమనించండి. ఎందుకంటే మేము పిక్సెల్‌లను వాటి పిక్సెల్ తీవ్రతలను 101 పెంచడం ద్వారా ప్రకాశవంతమైన రంగుల వైపు నడుపుతున్నాము.
చిత్రం యొక్క ప్రతి పిక్సెల్ తీవ్రత నుండి 60ని తీసివేయడానికి, మేము ముందుగా 60లతో నిండిన పంక్తి 54లో రెండవ NumPy శ్రేణిని ఏర్పాటు చేస్తాము.
ఈ వ్యవకలనం యొక్క ఫలితాలు క్రింది చిత్రంలో చిత్రీకరించబడ్డాయి:
మన చుట్టూ ఉన్న అంశాలు గతంలో కంటే ముదురు రంగులో కనిపిస్తాయి. ఎందుకంటే ప్రతి పిక్సెల్ నుండి 60 తీసివేయడం ద్వారా, మేము RGB కలర్ స్పేస్‌లోని పిక్సెల్‌లను ముదురు ప్రాంతాలకు తరలిస్తాము.
4. చిత్రం ఫ్లిప్పింగ్
భ్రమణ మాదిరిగానే, చిత్రాన్ని దాని x లేదా y-యాక్సిస్‌లో తిప్పడం OpenCV అందించే మరొక ఎంపిక. ఫ్లిప్పింగ్ కార్యకలాపాలు తరచుగా ఉపయోగించబడకపోయినా, మీరు వెంటనే చూడలేని వివిధ కారణాల వల్ల వాటిని తెలుసుకోవడం చాలా ప్రయోజనకరంగా ఉంటుంది.
చిత్రాలలో ముఖాలను గుర్తించే చిన్న స్టార్టప్ కంపెనీ కోసం మేము మెషిన్ లెర్నింగ్ వర్గీకరణను అభివృద్ధి చేస్తున్నాము. మా సిస్టమ్ ముఖం అంటే ఏమిటో 'నేర్చుకోవడానికి', మాకు నమూనా ముఖాలతో కూడిన ఒక రకమైన డేటాసెట్ అవసరం. దురదృష్టవశాత్తూ, కంపెనీ మాకు 40 ముఖాల చిన్న డేటాసెట్‌ను మాత్రమే అందించింది మరియు మేము మరింత సమాచారాన్ని సేకరించలేకపోయాము.
అయితే, మనం ఏమి చేస్తాము?
ముఖం ప్రతిబింబించినా లేదా ప్రతిబింబించకపోయినా ముఖంగా మిగిలిపోతుంది కాబట్టి, మేము ముఖం యొక్క ప్రతి చిత్రాన్ని అడ్డంగా తిప్పగలుగుతాము మరియు మిర్రర్డ్ వెర్షన్‌లను అదనపు శిక్షణ డేటాగా ఉపయోగించగలుగుతాము.
ఈ ఉదాహరణ తెలివితక్కువదని మరియు కృత్రిమంగా అనిపించవచ్చు, కానీ అది కాదు. ఫ్లిప్పింగ్ అనేది శిక్షణా దశలో మరింత డేటాను ఉత్పత్తి చేయడానికి బలమైన డీప్-లెర్నింగ్ అల్గారిథమ్‌లు ఉపయోగించే ఉద్దేశపూర్వక వ్యూహం.
ఈ మాడ్యూల్‌లో మీరు నేర్చుకునే ఇమేజ్ ప్రాసెసింగ్ పద్ధతులు పెద్ద కంప్యూటర్ విజన్ సిస్టమ్‌లకు పునాదిగా పనిచేస్తాయని మునుపటి నుండి స్పష్టంగా ఉంది.
లక్ష్యాలు:
ఉపయోగించి cv2.flip ఫంక్షన్, మీరు ఈ సెషన్‌లో చిత్రాన్ని అడ్డంగా మరియు నిలువుగా ఎలా తిప్పాలో నేర్చుకుంటారు.
ఫ్లిప్పింగ్ అనేది మేము అధ్యయనం చేసే తదుపరి ఇమేజ్ మానిప్యులేషన్. చిత్రం యొక్క x మరియు y-అక్షాలు తిప్పవచ్చు లేదా రెండూ కూడా చేయవచ్చు. మేము కోడింగ్‌లోకి ప్రవేశించే ముందు, మొదట ఇమేజ్ ఫ్లిప్ ఫలితాలను చూడటం ఉత్తమం. కింది చిత్రంలో క్షితిజ సమాంతరంగా తిప్పబడిన చిత్రాన్ని చూడండి:
మన అసలు చిత్రం ఎడమవైపు ఎలా ఉందో మరియు చిత్రం కుడి వైపున ఎలా అడ్డంగా ప్రతిబింబించబడిందో గమనించండి.
అనే కొత్త ఫైల్‌ని సృష్టించడం ద్వారా ప్రారంభిద్దాం flipping.py .
మీరు ఇమేజ్ ఫ్లిప్ యొక్క ఉదాహరణను చూసారు, కాబట్టి కోడ్‌ని పరిశీలిద్దాం:
# python flipping.py --image quirrel.jpg# అవసరమైన ప్యాకేజీలను దిగుమతి చేస్తోంది
దిగుమతి argparse
దిగుమతి cv2
# ఆర్గ్యుమెంట్ పార్సర్ యొక్క వస్తువును సృష్టించడం మరియు వాదనను అన్వయించడం
apObj = argparse. ఆర్గ్యుమెంట్ పార్సర్ ( )
apObj. add_argument ( '-నేను' , '--చిత్రం' , అవసరం = నిజమే , సహాయం = 'చిత్ర మార్గం' )
వాదన = ఎవరిది ( apObj. పార్స్_ఆర్గ్స్ ( ) )
చిత్రం = cv2. imread ( వాదన [ 'చిత్రం' ] )
cv2. చూపించు ( 'అసలు' , చిత్రం )
# చిత్రాన్ని అడ్డంగా తిప్పండి
చిత్రం తిప్పబడింది = cv2. కుదుపు ( చిత్రం , 1 )
cv2. చూపించు ( 'చిత్రం అడ్డంగా తిప్పబడింది' , చిత్రం తిప్పబడింది )
# చిత్రాన్ని నిలువుగా తిప్పండి
చిత్రం తిప్పబడింది = cv2. కుదుపు ( చిత్రం , 0 )
cv2. చూపించు ( 'చిత్రం నిలువుగా తిప్పబడింది' , చిత్రం తిప్పబడింది )
# చిత్రాన్ని రెండు అక్షాల వెంట తిప్పండి
చిత్రం తిప్పబడింది = cv2. కుదుపు ( చిత్రం , - 1 )
cv2. చూపించు ( 'అడ్డంగా & నిలువుగా తిప్పబడింది' , చిత్రం తిప్పబడింది )
cv2. వేచి ఉండండి ( 0 )
మా ప్యాకేజీలను దిగుమతి చేయడానికి, మా ఇన్‌పుట్‌లను అన్వయించడానికి మరియు డిస్క్ నుండి మా చిత్రాన్ని లోడ్ చేయడానికి మనం తీసుకునే దశలు lలో నిర్వహించబడతాయి ines 1 నుండి 12 .
cv2.flip ఫంక్షన్‌ని ఆన్ చేయడం ద్వారా లైన్ 15 , చిత్రాన్ని అడ్డంగా తిప్పడం సులభం. మేము ఫ్లిప్ చేయాలనుకుంటున్న ఇమేజ్ మరియు ఇమేజ్‌ని ఎలా తిప్పాలో తెలిపే నిర్దిష్ట కోడ్ లేదా ఫ్లాగ్ cv2.flip పద్ధతికి అవసరమైన రెండు ఆర్గ్యుమెంట్‌లు.
ఫ్లిప్ కోడ్ విలువ 1 అంటే మనం చిత్రాన్ని అడ్డంగా తిప్పడానికి y-అక్షం చుట్టూ తిప్పుతాము ( లైన్ 15 ) మేము 0 యొక్క ఫ్లిప్ కోడ్‌ను పేర్కొన్నట్లయితే, మేము చిత్రాన్ని x-అక్షం గురించి తిప్పాలనుకుంటున్నాము ( లైన్ 19 ) ప్రతికూల ఫ్లిప్ కోడ్ ( పంక్తి 23 ) చిత్రాన్ని రెండు అక్షాలపై తిప్పుతుంది.
ఈ సబ్జెక్ట్‌లోని సులభమైన ఉదాహరణలలో ఒకటి చిత్రాన్ని తిప్పడం, ఇది ప్రాథమికమైనది.
తర్వాత, మేము చిత్రాలను కత్తిరించడం గురించి చర్చిస్తాము మరియు నిర్దిష్ట చిత్ర భాగాలను సంగ్రహించడానికి NumPy అర్రే స్లైస్‌లను ఉపయోగిస్తాము.
5. ఇమేజ్ క్రాపింగ్
క్రాపింగ్, పేరు సూచించినట్లుగా, ఆసక్తి ఉన్న ప్రాంతాన్ని (లేదా కేవలం ROI) ఎంచుకోవడం మరియు తీసివేయడం అనే ప్రక్రియ, ఇది మనకు ఆసక్తిని కలిగించే చిత్రం యొక్క ప్రాంతం.
ముఖాన్ని గుర్తించే అప్లికేషన్ కోసం చిత్రం నుండి ముఖం కత్తిరించబడాలి. అదనంగా, మేము చిత్రాలలో కుక్కలను కనుగొనడానికి పైథాన్ స్క్రిప్ట్‌ను రూపొందిస్తున్నట్లయితే, మేము దానిని గుర్తించినప్పుడు దాని నుండి కుక్కను కత్తిరించాలనుకోవచ్చు.
లక్ష్యాలు: చిత్రం నుండి కత్తిరించే ప్రాంతాలకు NumPy శ్రేణి స్లైసింగ్‌ని ఉపయోగించడం మరియు సులభంగా ఉపయోగించడం మా ప్రధాన లక్ష్యం.
క్రాపింగ్ : మేము చిత్రాన్ని కత్తిరించినప్పుడు, మనకు ఆసక్తి లేని బాహ్య మూలకాలను తొలగించడమే మా లక్ష్యం. మా ROIని ఎంచుకునే ప్రక్రియ తరచుగా మా ఆసక్తి ఉన్న ప్రాంతాన్ని ఎంచుకోవడంగా సూచిస్తారు.
అనే కొత్త ఫైల్‌ను సృష్టించండి పంట.పై , దాన్ని తెరిచి, కింది కోడ్‌ను జోడించండి:
# పైథాన్ క్రాప్.పై# అవసరమైన ప్యాకేజీలను దిగుమతి చేస్తోంది
దిగుమతి cv2
# చిత్రం లోడ్ అవుతుంది మరియు స్క్రీన్‌పై ప్రదర్శించబడుతుంది
చిత్రం = cv2. imread ( 'squirrel.jpg' )
ముద్రణ ( చిత్రం. ఆకారం )
cv2. చూపించు ( 'అసలు' , చిత్రం )
# చిత్రాన్ని త్వరగా ట్రిమ్ చేయడానికి NumPy అర్రే స్లైస్‌లు ఉపయోగించబడతాయి
# మేము చిత్రం నుండి ఉడుత ముఖాన్ని కత్తిరించబోతున్నాము
ఉడుత = చిత్రం [ 35 : 90 , 35 : 100 ]
cv2. చూపించు ( 'ఉడుత ముఖం' , ఉడుత )
cv2. వేచి ఉండండి ( 0 )
# మరియు ఇప్పుడు, ఇక్కడ మేము మొత్తం శరీరాన్ని కత్తిరించబోతున్నాము
# ఉడుత
ఉడుత = చిత్రం [ 35 : 148 , 23 : 143 ]
cv2. చూపించు ( 'ఉడుత శరీరం' , ఉడుత )
cv2. వేచి ఉండండి ( 0 )
మేము డిస్క్ నుండి లోడ్ చేసే చిత్రాన్ని ఉపయోగించి పైథాన్ మరియు ఓపెన్‌సివిలో కత్తిరించడాన్ని చూపుతాము లైన్లు 5 మరియు 6 .
మేము కత్తిరించబోయే అసలు చిత్రం
ప్రాథమిక పంట పద్ధతులను మాత్రమే ఉపయోగించి, మేము చుట్టుపక్కల ప్రాంతం నుండి ఉడుత ముఖం మరియు ఉడుత శరీరాన్ని వేరు చేయాలని లక్ష్యంగా పెట్టుకున్నాము.
మేము చిత్రం గురించి మా ముందస్తు పరిజ్ఞానాన్ని ఉపయోగిస్తాము మరియు శరీరం మరియు ముఖం ఉన్న ప్రదేశానికి సంబంధించిన NumPy అర్రే స్లైస్‌లను మాన్యువల్‌గా సరఫరా చేస్తాము. సాధారణ పరిస్థితులలో, చిత్రంలో ముఖం మరియు శరీరాన్ని గుర్తించడానికి మేము సాధారణంగా మెషిన్ లెర్నింగ్ మరియు కంప్యూటర్ విజన్ అల్గారిథమ్‌లను ఉపయోగిస్తాము. అయితే ప్రస్తుతానికి విషయాలను సూటిగా ఉంచుదాం మరియు ఏదైనా గుర్తింపు నమూనాలను ఉపయోగించకుండా నివారించండి.
కేవలం ఒక లైన్ కోడ్‌తో చిత్రంలోని ముఖాన్ని మనం గుర్తించవచ్చు. లైన్ 13 , (35, 35) నుండి ప్రారంభమయ్యే చిత్రం యొక్క దీర్ఘచతురస్ర భాగాన్ని సంగ్రహించడానికి, మేము NumPy అర్రే స్లైస్‌లను (90, 100) అందిస్తాము. మేము చేసే ఎత్తు-మొదటి మరియు వెడల్పు-రెండవ క్రమంలో సూచికలతో పంటకు ఆహారం ఇవ్వడం గందరగోళంగా అనిపించవచ్చు, కానీ OpenCV చిత్రాలను NumPy శ్రేణులుగా నిల్వ చేస్తుందని గుర్తుంచుకోండి. ఫలితంగా, మేము x-అక్షానికి ముందు y-అక్షం కోసం విలువలను అందించాలి.
మా క్రాపింగ్‌ని నిర్వహించడానికి NumPyకి క్రింది నాలుగు సూచికలు అవసరం:
ప్రారంభం y: ప్రారంభంలో y-కోఆర్డినేట్. ఈ ఉదాహరణ కోసం, మేము y=35 వద్ద ప్రారంభిస్తాము.
ముగింపు y: ముగింపులో y కోఆర్డినేట్. y = 90 అయినప్పుడు మన పంట ఆగిపోతుంది.
ప్రారంభం x: స్లైస్ ప్రారంభం x కోఆర్డినేట్. పంట x=35 వద్ద ప్రారంభమవుతుంది.
ముగింపు x: స్లైస్ ముగింపు x-యాక్సిస్ కోఆర్డినేట్. x=100 వద్ద, మా స్లైస్ పూర్తయింది.
అదేవిధంగా, చిత్రం నుండి పూర్తి శరీరాన్ని సంగ్రహించడానికి మేము అసలు చిత్రం నుండి ప్రాంతాలను (23, 35) మరియు (143, 148) కత్తిరించాము లైన్ 19 .
శరీరం మరియు ముఖాన్ని మాత్రమే ప్రదర్శించడానికి చిత్రం కత్తిరించబడిందని మీరు గమనించవచ్చు.
6. చిత్రం పునఃపరిమాణం
చిత్రం యొక్క వెడల్పు మరియు ఎత్తును పెంచడం లేదా తగ్గించడం ప్రక్రియను స్కేలింగ్ లేదా సాధారణ పరిమాణం మార్చడం అంటారు. చిత్రం పరిమాణాన్ని మార్చేటప్పుడు చిత్రం యొక్క వెడల్పు మరియు దాని ఎత్తు యొక్క నిష్పత్తిలో ఉండే కారక నిష్పత్తిని పరిగణించాలి. కారక నిష్పత్తిని నిర్లక్ష్యం చేయడం వలన స్కేల్ చేయబడిన చిత్రాలు కుదించబడి మరియు వక్రీకరించినట్లు కనిపిస్తాయి:
మా ప్రారంభ చిత్రం ఎడమవైపు ఉంది. కుడివైపున, మీరు కారక నిష్పత్తిని నిర్వహించకుండా స్కేల్ చేయబడిన రెండు చిత్రాలను చూస్తారు, చిత్రం యొక్క వెడల్పు నిష్పత్తిని దాని ఎత్తుకు వక్రీకరించారు. మీ చిత్రాల పరిమాణాన్ని మార్చేటప్పుడు, మీరు సాధారణంగా కారక నిష్పత్తిని పరిగణించాలి.
మా పునఃపరిమాణం అల్గారిథమ్ ఉపయోగించే ఇంటర్పోలేషన్ టెక్నిక్, ఇమేజ్ పరిమాణాన్ని పెంచడానికి లేదా తగ్గించడానికి ఈ పిక్సెల్‌ల పొరుగు ప్రాంతాలను ఉపయోగించడానికి ఇంటర్పోలేషన్ ఫంక్షన్ యొక్క లక్ష్యాన్ని కూడా పరిగణనలోకి తీసుకోవాలి.
సాధారణంగా, చిత్రం యొక్క పరిమాణాన్ని కుదించడం చాలా ప్రభావవంతంగా ఉంటుంది. ఎందుకంటే చిత్రం నుండి పిక్సెల్‌లను తీసివేయడం అనేది ఇంటర్పోలేషన్ ఫంక్షన్ చేయాల్సిందల్లా. మరోవైపు, చిత్ర పరిమాణాన్ని పెంచాలంటే అంతకుముందు లేని పిక్సెల్‌ల మధ్య ఇంటర్పోలేషన్ పద్ధతి 'ఖాళీలను పూరించాలి'.
ఎడమవైపు మా అసలు చిత్రం ఉంది. చిత్రం మధ్యలో దాని అసలు పరిమాణంలో సగానికి తగ్గించబడింది, కానీ అది కాకుండా, చిత్రం యొక్క 'నాణ్యత'లో ఎటువంటి నష్టం జరగలేదు. అయినప్పటికీ, చిత్రం యొక్క పరిమాణం కుడివైపున గణనీయంగా పెంచబడింది. ఇది ఇప్పుడు 'ఎగిరింది' మరియు 'పిక్సలేటెడ్' గా కనిపిస్తుంది.
నేను ఇంతకు ముందు చెప్పినట్లుగా, మీరు సాధారణంగా చిత్రాన్ని పెంచడానికి బదులుగా దాని పరిమాణాన్ని తగ్గించాలనుకుంటున్నారు. చిత్ర పరిమాణాన్ని తగ్గించడం ద్వారా, మేము తక్కువ పిక్సెల్‌లను విశ్లేషిస్తాము మరియు తక్కువ 'శబ్దం'తో వ్యవహరించాల్సి ఉంటుంది, ఇది ఇమేజ్ ప్రాసెసింగ్ అల్గారిథమ్‌లను వేగంగా మరియు మరింత ఖచ్చితమైనదిగా చేస్తుంది.
అనువాదం మరియు భ్రమణం అనేవి ఇప్పటివరకు పరిష్కరించబడిన రెండు చిత్ర రూపాంతరాలు. ఇప్పుడు మనం చిత్రం పరిమాణాన్ని ఎలా మార్చాలో పరిశీలిస్తాము.
ఆశ్చర్యకరంగా, మేము cv2.resize పద్ధతిని ఉపయోగించి మా చిత్రాల పరిమాణాన్ని మారుస్తాము. నేను ఇంతకు ముందు సూచించినట్లుగా, ఈ పద్ధతిని ఉపయోగించేటప్పుడు మనం చిత్రం యొక్క కారక నిష్పత్తిని తప్పనిసరిగా పరిగణించాలి. కానీ మేము ప్రత్యేకతలను చాలా లోతుగా నమోదు చేయడానికి ముందు, మీకు ఒక ఉదాహరణ ఇవ్వడానికి నన్ను అనుమతించండి:
# python resize.py --image squirrel.jpg# అవసరమైన ప్యాకేజీలను దిగుమతి చేస్తోంది
దిగుమతి argparse
దిగుమతి cv2
# ఆర్గ్యుమెంట్ పార్సర్ యొక్క వస్తువును సృష్టించడం మరియు వాదనను అన్వయించడం
apObj = argparse. ఆర్గ్యుమెంట్ పార్సర్ ( )
apObj. add_argument ( '-k' , '--చిత్రం' , అవసరం = నిజమే , సహాయం = 'చిత్ర మార్గం' )
వాదనలు = ఎవరిది ( apObj. పార్స్_ఆర్గ్స్ ( ) )
# చిత్రాన్ని లోడ్ చేసి, స్క్రీన్‌పై ప్రదర్శించండి
చిత్రం = cv2. imread ( వాదనలు [ 'చిత్రం' ] )
cv2. చూపించు ( 'అసలు' , చిత్రం )
# చిత్రం వక్రంగా కనిపించకుండా నిరోధించడానికి, కారక నిష్పత్తి
# తప్పనిసరిగా పరిగణించబడాలి లేదా వైకల్యంతో ఉండాలి; అందువలన, మేము ఏమి గుర్తించాము
# ప్రస్తుత చిత్రానికి కొత్త చిత్రం నిష్పత్తి.
# మన కొత్త చిత్రం వెడల్పును 160 పిక్సెల్‌లుగా చేద్దాం.
అంశం = 160.0 / చిత్రం. ఆకారం [ 1 ]
పరిమాణం = ( 160 , int ( చిత్రం. ఆకారం [ 0 ] * కోణం ) )
# ఈ లైన్ వాస్తవ పరిమాణాన్ని మార్చే కార్యకలాపాలను చూపుతుంది
చిత్రం పునఃపరిమాణం = cv2. పునఃపరిమాణం ( చిత్రం , పరిమాణం , ఇంటర్పోలేషన్ = cv2. INTER_AREA )
cv2. చూపించు ( 'చిత్రం వెడల్పు పరిమాణం మార్చబడింది' , చిత్రం పునఃపరిమాణం )
# మనం చిత్రం యొక్క ఎత్తును మార్చాలనుకుంటే? - ఉపయోగించి
# అదే సూత్రం, మేము ఆకార నిష్పత్తి ఆధారంగా లెక్కించవచ్చు
# వెడల్పు కంటే ఎత్తులో. స్కేల్డ్ తయారు చేద్దాం
# చిత్రం ఎత్తు 70 పిక్సెల్‌లు.
అంశం = 70.0 / చిత్రం. ఆకారం [ 0 ]
పరిమాణం = ( int ( చిత్రం. ఆకారం [ 1 ] * కోణం ) , 70 )
# పునఃపరిమాణాన్ని అమలు చేయండి
చిత్రం పునఃపరిమాణం = cv2. పునఃపరిమాణం ( చిత్రం , పరిమాణం , ఇంటర్పోలేషన్ = cv2. INTER_AREA )
cv2. చూపించు ( 'చిత్రం ఎత్తు పరిమాణం మార్చబడింది' , చిత్రం పునఃపరిమాణం )
cv2. వేచి ఉండండి ( 0 )
లైన్లు 1-14 , మా ప్యాకేజీలను దిగుమతి చేసిన తర్వాత మరియు మా ఆర్గ్యుమెంట్ పార్సర్‌ను కాన్ఫిగర్ చేసిన తర్వాత, మేము మా చిత్రాన్ని లోడ్ చేసి ప్రదర్శిస్తాము.
20 మరియు 21 లైన్లు: సంబంధిత కోడింగ్ ఈ లైన్లలో ప్రారంభమవుతుంది . చిత్రాన్ని పరిమాణం మార్చేటప్పుడు దాని కారక నిష్పత్తిని తప్పనిసరిగా పరిగణనలోకి తీసుకోవాలి. చిత్రం యొక్క వెడల్పు మరియు ఎత్తు మధ్య నిష్పత్తిని కారక నిష్పత్తి అంటారు.
ఎత్తు / వెడల్పు కారక నిష్పత్తి.
మేము కారక నిష్పత్తిని పరిగణనలోకి తీసుకోకపోతే, మా పునఃపరిమాణం యొక్క ఫలితాలు వక్రీకరించబడతాయి.
పై లైన్ 20 , పరిమాణం పరిమాణం గణన పూర్తయింది. మేము ఈ కోడ్ లైన్‌లో మా కొత్త ఇమేజ్ వెడల్పును 160 పిక్సెల్‌లుగా అందిస్తాము. పాత ఎత్తుకు కొత్త ఎత్తుకు ఉన్న నిష్పత్తిని లెక్కించేందుకు, మేము ఇమేజ్‌ని ఉపయోగించి యాక్సెస్ చేసే పాత వెడల్పుతో భాగించిన కొత్త వెడల్పు (160 పిక్సెల్‌లు)గా మా నిష్పత్తిని (ఆస్పెక్ట్రేషియో) నిర్వచించాము. ఆకారం[1].
చిత్రం యొక్క కొత్త కొలతలు ఆన్‌లో ఉన్నాయి పంక్తి 21 మన నిష్పత్తి మనకు తెలిసినప్పుడు ఇప్పుడు లెక్కించవచ్చు. మరోసారి, కొత్త చిత్రం 160 పిక్సెల్‌ల వెడల్పును కలిగి ఉంటుంది. పాత ఎత్తును మా నిష్పత్తితో గుణించి, ఫలితాన్ని పూర్ణాంకానికి మార్చిన తర్వాత, ఎత్తు లెక్కించబడుతుంది. మేము ఈ ఆపరేషన్ చేయడం ద్వారా చిత్రం యొక్క అసలైన కారక నిష్పత్తిని నిర్వహించగలము.
పంక్తి 24 ఇక్కడ చిత్రం నిజంగా పరిమాణం మార్చబడింది. మేము పునఃపరిమాణం చేయాలనుకుంటున్న చిత్రం మొదటి వాదన, మరియు రెండవది మేము కొత్త చిత్రం కోసం లెక్కించిన కొలతలు. మా ఇంటర్పోలేషన్ పద్ధతి, ఇది అసలు ఇమేజ్‌ని పునఃపరిమాణం చేయడానికి అల్గోరిథం, ఇది చివరి పరామితి.
చివరగా, ఆన్ పంక్తి 25 , మేము మా స్కేల్ చిత్రాన్ని ప్రదర్శిస్తాము.
మేము మా నిష్పత్తి (ఆస్పెక్ట్రేషియో)ని పునర్నిర్వచించాము లైన్ 31 . మా కొత్త చిత్రం యొక్క ఎత్తు 70 పిక్సెల్‌లుగా ఉంటుంది. కొత్త ఎత్తు నుండి అసలు ఎత్తు నిష్పత్తిని పొందడానికి మేము 70ని అసలు ఎత్తుతో భాగిస్తాము.
తరువాత, మేము కొత్త చిత్రం యొక్క కొలతలు ఏర్పాటు చేస్తాము. కొత్త చిత్రం 70 పిక్సెల్‌ల ఎత్తును కలిగి ఉంటుంది, ఇది ఇప్పటికే తెలిసినది. కొత్త వెడల్పును ఉత్పత్తి చేయడానికి పాత వెడల్పును నిష్పత్తితో గుణించడం ద్వారా మేము చిత్రం యొక్క అసలు కారక నిష్పత్తిని మరోసారి ఉంచవచ్చు.
అప్పుడు చిత్రం వాస్తవానికి పరిమాణం మార్చబడుతుంది లైన్ 35 , మరియు ఇది ప్రదర్శించబడుతుంది లైన్ 36.
ఇక్కడ, కారక నిష్పత్తిని ఉంచేటప్పుడు మన అసలు చిత్రం యొక్క వెడల్పు మరియు ఎత్తును తగ్గించినట్లు మనం చూడవచ్చు. కారక నిష్పత్తిని నిర్వహించకపోతే మా చిత్రం వక్రీకరించినట్లు కనిపిస్తుంది.
ముగింపు
ఈ బ్లాగ్‌లో, మేము ప్రాథమిక విభిన్న ఇమేజ్ ప్రాసెసింగ్ కాన్సెప్ట్‌లను అధ్యయనం చేసాము. మేము OpenCV ప్యాకేజీ సహాయంతో చిత్ర అనువాదాన్ని చూశాము. మేము చిత్రాన్ని పైకి, క్రిందికి, కుడి మరియు ఎడమకు తరలించే పద్ధతులను చూశాము. శిక్షణ డేటాసెట్‌గా ఇవ్వడానికి సారూప్య చిత్రాల డేటాసెట్‌ను రూపొందించినప్పుడు ఈ పద్ధతులు చాలా ఉపయోగకరంగా ఉంటాయి, కాబట్టి యంత్రం అవి ఒకే విధంగా ఉన్నప్పటికీ విభిన్న చిత్రాలను చూస్తుంది. రొటేషన్ మ్యాట్రిక్స్‌ని ఉపయోగించి కార్టీసియన్ స్పేస్‌లోని ఏదైనా పాయింట్ చుట్టూ చిత్రాన్ని ఎలా తిప్పాలో కూడా ఈ కథనం మీకు నేర్పింది. ఈ మ్యాట్రిక్స్‌ని ఉపయోగించి OpenCV ఇమేజ్‌లను ఎలా తిప్పుతుందో మీరు కనుగొన్నారు మరియు స్పిన్నింగ్ ఇమేజ్‌ల యొక్క రెండు దృష్టాంతాలను చూసారు.
ఈ విభాగంలో కూడిక మరియు తీసివేత యొక్క రెండు ప్రాథమిక (కానీ ముఖ్యమైన) చిత్ర అంకగణిత కార్యకలాపాలు పరిశీలించబడ్డాయి. మీరు చూడగలిగినట్లుగా, ప్రాథమిక మాత్రికలను జోడించడం మరియు తీసివేయడం అనేది అన్ని చిత్ర అంకగణిత కార్యకలాపాలను కలిగి ఉంటుంది.
అదనంగా, మేము ఇమేజ్ అంకగణితం యొక్క ప్రత్యేకతలను పరిశోధించడానికి OpenCV మరియు NumPyని ఉపయోగించాము. ఈ పరిమితులను తప్పనిసరిగా గుర్తుంచుకోవాలి లేదా మీ చిత్రాలపై అంకగణిత కార్యకలాపాలను అమలు చేస్తున్నప్పుడు మీరు ఊహించని ఫలితాలను పొందే ప్రమాదం ఉంది.
NumPy మాడ్యులస్ ఆపరేషన్‌ను నిర్వహించి, 'చుట్టూ చుట్టుముట్టింది' అయినప్పటికీ, OpenCV జోడింపు మరియు వ్యవకలనం పరిధి [0, 255] కంటే ఎక్కువ విలువలు పరిధి లోపల సరిపోతాయని గుర్తుంచుకోవడం ముఖ్యం. మీ స్వంత కంప్యూటర్ విజన్ అప్లికేషన్‌లను అభివృద్ధి చేస్తున్నప్పుడు, దీన్ని గుర్తుంచుకోవడం గమ్మత్తైన బగ్‌ల వేటను నివారించడంలో మీకు సహాయం చేస్తుంది.
చిత్రాన్ని తిప్పడం అనేది నిస్సందేహంగా మేము ఈ కోర్సులో అన్వేషించే సరళమైన ఆలోచనలలో ఒకటి. మెషిన్ లెర్నింగ్‌లో మరింత శిక్షణ డేటా నమూనాలను రూపొందించడానికి ఫ్లిప్పింగ్ తరచుగా ఉపయోగించబడుతుంది, దీని ఫలితంగా మరింత శక్తివంతమైన మరియు నమ్మదగిన ఇమేజ్ వర్గీకరణలు లభిస్తాయి.
చిత్రం పరిమాణాన్ని మార్చడానికి OpenCVని ఎలా ఉపయోగించాలో కూడా మేము నేర్చుకున్నాము. మీరు ఉపయోగిస్తున్న ఇంటర్పోలేషన్ పద్ధతి మరియు మీ అసలు చిత్రం యొక్క కారక నిష్పత్తి రెండింటినీ పరిగణనలోకి తీసుకోవడం చాలా ముఖ్యం, తద్వారా ఫలితం వక్రీకరించినట్లు కనిపించదు.
చివరగా, చిత్ర నాణ్యత సమస్య అయితే, పెద్దది నుండి చిన్న చిత్రానికి మారడం ఎల్లప్పుడూ ఉత్తమమని గుర్తుంచుకోవడం చాలా ముఖ్యం. చాలా సందర్భాలలో, చిత్రాన్ని విస్తరించడం కళాఖండాలను సృష్టిస్తుంది మరియు దాని నాణ్యతను తగ్గిస్తుంది.