- பட மொழிபெயர்ப்பு
- பட சுழற்சி
- படம் எண்கணிதம்
- படத்தை புரட்டுகிறது
- படத்தை செதுக்குதல்
- படத்தின் அளவை மாற்றுதல்
இப்போது, மேலே குறிப்பிட்டுள்ள அனைத்து பட செயலாக்க தலைப்புகளையும் விரிவாக விளக்குவோம்.
1. பட மொழிபெயர்ப்பு
பட மொழிபெயர்ப்பு என்பது x மற்றும் y-அச்சுகளில் படத்தை நகர்த்த உதவும் ஒரு பட செயலாக்க முறையாகும். படத்தை மேலே, கீழ், வலது, இடது அல்லது எந்த கலவையையும் நகர்த்தலாம்.
மொழிபெயர்ப்பு மேட்ரிக்ஸை எம் குறியீட்டைக் கொண்டு வரையறுக்கலாம், மேலும் கீழே காட்டப்பட்டுள்ளபடி அதை கணித வடிவத்தில் குறிப்பிடலாம்:
இந்த நிரல் மூலம் மொழிபெயர்ப்பு படத்தின் கருத்தை நாம் புரிந்து கொள்ளலாம்.
பைதான் குறியீடு: பின்வரும் நிரலின் பெயரை அப்படியே வைத்திருப்போம் translate.py .
# தேவையான தொகுப்புகளை இறக்குமதி செய்யவும்இறக்குமதி உணர்ச்சியற்ற என எ.கா.
இறக்குமதி argparse
இறக்குமதி imutil
இறக்குமதி cv2
# நாங்கள் வாத பாகுபடுத்தியை செயல்படுத்துகிறோம்
ap_obj = argparse. வாதப் பாகுபடுத்தி ( )
ap_obj. add_argument ( '-k' , '--படம்' , தேவை = உண்மை ,
உதவி = 'படக் கோப்பின் இடம்' )
args = யாருடைய ( ap_obj. parse_args ( ) )
# படத்தை ஏற்றி திரையில் காட்டவும்
படம் = cv2. imread ( args [ 'படம்' ] )
cv2. காட்சி ( 'அசல்_படம்' , படம் )
# படத்தை மொழிபெயர்ப்பது ஒரு NumPy மேட்ரிக்ஸ் ஆகும், இது கீழே கொடுக்கப்பட்டுள்ளது:
# [[1, 0, shiftX], [0, 1, shiftY]]
# மேலே உள்ள NumPy மேட்ரிக்ஸைப் பயன்படுத்தி படங்களை மாற்றப் போகிறோம்
# x-அச்சு மற்றும் y-அச்சு திசைகள். இதற்கு, நாம் பிக்சல் மதிப்புகளை அனுப்ப வேண்டும்.
# இந்த நிரலில், படத்தை 30 பிக்சல்கள் வலதுபுறமாக நகர்த்துவோம்
# மற்றும் கீழே நோக்கி 70 பிக்சல்கள்.
மொழிபெயர்ப்பு_மேட் = எ.கா. மிதவை32 ( [ [ 1 , 0 , 30 ] , [ 0 , 1 , 70 ] ] )
படம்_மொழிபெயர்ப்பு = cv2. warpAffine ( படம் , மொழிபெயர்ப்பு_மேட் ,
( படம். வடிவம் [ 1 ] , படம். வடிவம் [ 0 ] ) )
cv2. காட்சி ( 'பட மொழிபெயர்ப்பு கீழ் மற்றும் வலது' , படம்_மொழிபெயர்ப்பு )
# இப்போது, மேலே உள்ள NumPy மேட்ரிக்ஸைப் பயன்படுத்தி படங்களை மாற்றப் போகிறோம்
# x-அச்சு (இடது) மற்றும் y-அச்சு (மேல்) திசைகள்.
# இங்கே, 50 பிக்சல்கள் உள்ள படங்களை இடது பக்கம் நகர்த்தப் போகிறோம்
# மற்றும் 90 பிக்சல்கள் மேல் நோக்கி.
மொழிபெயர்ப்பு_மேட் = எ.கா. மிதவை32 ( [ [ 1 , 0 , - ஐம்பது ] , [ 0 , 1 , - 90 ] ] )
படம்_மொழிபெயர்ப்பு = cv2. warpAffine ( படம் , மொழிபெயர்ப்பு_மேட் ,
( படம். வடிவம் [ 1 ] , படம். வடிவம் [ 0 ] ) )
cv2. காட்சி ( 'பட மொழிபெயர்ப்பு மேல் மற்றும் இடது' , படம்_மொழிபெயர்ப்பு )
cv2. காத்திருக்கவும் ( 0 )
வரி 1 முதல் 5 வரை: இந்த திட்டத்திற்கு தேவையான OpenCV, argparser மற்றும் NumPy போன்ற அனைத்து தொகுப்புகளையும் நாங்கள் இறக்குமதி செய்கிறோம். இமுட்டில்ஸ் என்ற மற்றொரு நூலகம் உள்ளது என்பதை தயவுசெய்து கவனிக்கவும். இது OpenCV இன் தொகுப்பு அல்ல. இது ஒரே மாதிரியான பட செயலாக்கத்தை எளிதாகக் காண்பிக்கும் ஒரு நூலகம்.
நாம் OpenCV ஐ நிறுவும் போது நூலக இம்யூட்டில்கள் தானாகவே சேர்க்கப்படாது. எனவே இமுட்டில்களை நிறுவ, பின்வரும் முறையைப் பயன்படுத்த வேண்டும்:
pip நிறுவல் இமுட்டில்ஸ்
வரிகள் 8 முதல் 15 வரை: நாங்கள் எங்கள் agrparser ஐ உருவாக்கி எங்கள் படத்தை ஏற்றினோம்.
வரிகள் 24 முதல் 25 வரை: இந்த நிரல் பிரிவில் மொழிபெயர்ப்பு நடைபெறுகிறது. படம் எத்தனை பிக்சல்கள் மேல் அல்லது கீழ் அல்லது இடது அல்லது வலது பக்கம் நகர்த்தப்படும் என்பதை மொழிபெயர்ப்பு மேட்ரிக்ஸ் நமக்குக் கூறுகிறது. ஓபன்சிவிக்கு மேட்ரிக்ஸ் மதிப்பு மிதக்கும் புள்ளி வரிசையில் இருக்க வேண்டும் என்பதால், மொழிபெயர்ப்பு அணி மிதக்கும் புள்ளி அணிகளில் மதிப்புகளை எடுக்கும்.
மொழிபெயர்ப்பு மேட்ரிக்ஸின் முதல் வரிசை இதுபோல் தெரிகிறது:
மேட்ரிக்ஸின் இந்த வரிசை x-அச்சுக்கானது. டி இன் மதிப்பு எக்ஸ் படத்தை இடது அல்லது வலது பக்கமாக மாற்ற வேண்டுமா என்பதை முடிவு செய்யும். நாம் எதிர்மறை மதிப்பைக் கடந்து சென்றால், படம் இடது பக்கத்திற்கு மாற்றப்படும் என்று அர்த்தம், மேலும் மதிப்பு நேர்மறையாக இருந்தால், படம் வலது பக்கமாக மாற்றப்படும்.
இப்போது அணியின் இரண்டாவது வரிசையை பின்வருமாறு வரையறுப்போம்:
மேட்ரிக்ஸின் இந்த வரிசை y-அச்சுக்கானது. t இன் மதிப்பு ஒய் படத்தை மேலே அல்லது கீழ் பக்கமாக மாற்ற வேண்டுமா என்பதை முடிவு செய்யும். நாம் ஒரு எதிர்மறை மதிப்பைக் கடந்து சென்றால், படம் தலைகீழாக மாற்றப்படும் என்று அர்த்தம், மேலும் மதிப்பு நேர்மறையாக இருந்தால், படம் கீழ்நிலைக்கு மாற்றப்படும் என்று அர்த்தம்.
வரி 24 இல் முந்தைய நிரலில், t ஐ வரையறுக்கிறோம் எக்ஸ் = 30 மற்றும் டி ஒய் = 70. எனவே படத்தை 30 பிக்சல்கள் வலது பக்கமாகவும் 70 பிக்சல்கள் கீழ்நோக்கியும் நகர்த்துகிறோம்.
ஆனால் முக்கிய பட மொழிபெயர்ப்பு செயல்முறை வரி 25 இல் நடைபெறுகிறது, அங்கு நாம் மொழிபெயர்ப்பு மேட்ரிக்ஸை வரையறுக்கிறோம் cv2.warpAffine . இந்த செயல்பாட்டில், நாங்கள் மூன்று அளவுருக்களைக் கடந்து செல்கிறோம்: முதல் அளவுரு படம், இரண்டாவது அளவுரு மொழிபெயர்ப்பு அணி மற்றும் மூன்றாவது அளவுரு படத்தின் பரிமாணம்.
வரி 27: வரி 27 வெளியீட்டில் முடிவைக் காண்பிக்கும்.
இப்போது, இடது மற்றும் தலைகீழாக மற்றொரு மொழிபெயர்ப்பு மேட்ரிக்ஸை செயல்படுத்துவோம். இதற்கு, எதிர்மறை மதிப்புகளை நாம் வரையறுக்க வேண்டும்.
வரி 33 முதல் 34 வரை: வரி 33 இல் முந்தைய நிரலில், t ஐ வரையறுக்கிறோம் எக்ஸ் = -50 மற்றும் டி ஒய் = -90. எனவே படத்தை 50 பிக்சல்கள் இடது பக்கமாகவும் 90 பிக்சல்கள் மேல் பக்கமாகவும் நகர்த்துகிறோம். ஆனால் முக்கிய பட மொழிபெயர்ப்பு செயல்முறை வரி 34 இல் நடைபெறுகிறது, அங்கு நாம் மொழிபெயர்ப்பு மேட்ரிக்ஸை வரையறுக்கிறோம் cv2.warpAffine .
வரி 36 : வரி 36 வெளியீட்டில் காட்டப்பட்டுள்ளபடி முடிவைக் காண்பிக்கும்.
முந்தைய குறியீட்டை இயக்க, கீழே கொடுக்கப்பட்டுள்ளபடி படத்தின் பாதையை கொடுக்க வேண்டும்.
வெளியீடு: python translate.py –image squirrel.jpg
இப்போது, அதே பட மொழிபெயர்ப்பு திட்டத்தைப் பயன்படுத்தி செயல்படுத்துவோம் imutil நூலகம். இந்த நூலகம் பட செயலாக்கத்திற்கு பயன்படுத்த மிகவும் எளிதானது. இந்த நூலகத்தில் நாம் சிந்திக்க வேண்டியதில்லை cv2.warpAffine ஏனெனில் இந்த நூலகம் இதை கவனித்துக்கொள்ளும். எனவே imutils நூலகத்தைப் பயன்படுத்தி இந்த பட மொழிபெயர்ப்பு திட்டத்தை செயல்படுத்துவோம்.
பைதான் குறியீடு: பின்வரும் நிரலின் பெயரை அப்படியே வைத்திருப்போம் translate_imutils.py .
# தேவையான தொகுப்புகளை இறக்குமதி செய்யவும்இறக்குமதி உணர்ச்சியற்ற என எ.கா.
இறக்குமதி argparse
இறக்குமதி imutil
இறக்குமதி cv2
# இந்தச் செயல்பாடு பட மொழிபெயர்ப்பு மற்றும்
# மொழிமாற்றம் செய்யப்பட்ட படத்தை அழைப்பு செயல்பாட்டிற்கு திருப்பி அனுப்புகிறது.
def மொழிபெயர் ( படம் , எக்ஸ் , ஒய் ) :
மொழிபெயர்ப்பு_மேட்ரிக்ஸ் = எ.கா. மிதவை32 ( [ [ 1 , 0 , எக்ஸ் ] , [ 0 , 1 , ஒய் ] ] )
படம்_மொழிபெயர்ப்பு = cv2. warpAffine ( படம் , மொழிபெயர்ப்பு_மேட்ரிக்ஸ் ,
( படம். வடிவம் [ 1 ] , படம். வடிவம் [ 0 ] ) )
திரும்ப படம்_மொழிபெயர்ப்பு
# வாத பாகுபடுத்தி மற்றும் வாதங்களை அலசவும்
ஏப் = argparse. வாதப் பாகுபடுத்தி ( )
ஏப். add_argument ( '-நான்' , '--படம்' , தேவை = உண்மை , உதவி = 'படத்திற்கான பாதை' )
args = யாருடைய ( ஏப். parse_args ( ) )
# படத்தை ஏற்றி திரையில் காண்பிக்கவும்
படம் = cv2. imread ( args [ 'படம்' ] )
cv2. காட்சி ( 'அசல்_படம்' , படம் )
படம்_மொழிபெயர்ப்பு = imutil. மொழிபெயர் ( படம் , 10 , 70 )
cv2. காட்சி ( 'பட மொழிபெயர்ப்பு வலதுபுறம் மற்றும் கீழே' ,
படம்_மொழிபெயர்ப்பு )
cv2. காத்திருக்கவும் ( 0 )
வரிகள் 9 முதல் 13 வரை: நிரலின் இந்த பகுதியில் மொழிபெயர்ப்பு நடைபெறுகிறது. படம் எத்தனை பிக்சல்கள் மூலம் மேல் அல்லது கீழ் அல்லது இடது அல்லது வலது பக்கம் நகர்த்தப்படும் என்பதை மொழிபெயர்ப்பு மேட்ரிக்ஸ் நமக்குத் தெரிவிக்கிறது.
இந்த வரிகள் ஏற்கனவே விளக்கப்பட்டுள்ளன, ஆனால் இப்போது நாம் மொழிபெயர்ப்பு () எனப்படும் ஒரு செயல்பாட்டை உருவாக்கி அதில் மூன்று தனித்துவமான அளவுருக்களை அனுப்பப் போகிறோம். படமே முதல் அளவுருவாக செயல்படுகிறது. மொழிபெயர்ப்பு மேட்ரிக்ஸின் x மற்றும் y மதிப்புகள் இரண்டாவது மற்றும் மூன்றாவது அளவுருக்களுக்கு ஒத்திருக்கும்.
குறிப்பு : இது ஏற்கனவே imutils லைப்ரரி தொகுப்பில் சேர்க்கப்பட்டுள்ளதால் நிரலின் உள்ளே இந்த மொழிபெயர்ப்பு செயல்பாட்டை வரையறுக்க வேண்டிய அவசியமில்லை. நேரடியான விளக்கத்திற்காக நான் அதை நிரலுக்குள் பயன்படுத்தினேன். வரி 24 இல் காட்டப்பட்டுள்ளபடி, இந்த செயல்பாட்டை நாம் நேரடியாக இமுட்டில்ஸ் மூலம் அழைக்கலாம்.
வரி 24: முந்தைய நிரல் வரி 24 இல், tx = 10 மற்றும் ty = 70 ஐ வரையறுக்கிறோம். எனவே படத்தை 10 பிக்சல்கள் வலது பக்கமாகவும், 70 பிக்சல்கள் கீழ்நோக்கியும் நகர்த்துகிறோம்.
இந்த திட்டத்தில், எந்த cv2.warpAffine செயல்பாடுகளையும் நாங்கள் பொருட்படுத்த மாட்டோம், ஏனெனில் அவை ஏற்கனவே imutils லைப்ரரி தொகுப்பில் உள்ளன.
முந்தைய குறியீட்டை இயக்க, கீழே கொடுக்கப்பட்டுள்ளபடி படத்தின் பாதையை கொடுக்க வேண்டும்:
வெளியீடு:
மலைப்பாம்பு இமுட்டில்ஸ். பை --பட அணில். jpg 
2. பட சுழற்சி
முந்தைய பாடத்தில் (அல்லது ஏதேனும் கலவையில்) ஒரு படத்தை மேலே, கீழ், இடது மற்றும் வலதுபுறமாக எவ்வாறு மொழிபெயர்ப்பது (அதாவது, ஷிப்ட்) என்பதை நாங்கள் படித்தோம். அடுத்து, பட செயலாக்கத்துடன் தொடர்புடைய சுழற்சியைப் பற்றி விவாதிப்போம்.
ஒரு படம் ஒரு கோணம், தீட்டா, சுழற்சி எனப்படும் ஒரு செயல்பாட்டில் சுழற்றப்படுகிறது. படத்தை நாம் சுழலும் கோணம் தீட்டாவால் குறிக்கப்படும். கூடுதலாக, சுழலும் படங்களை எளிமையாக்க, சுழலும் வசதிக்கான செயல்பாட்டை நான் வழங்குவேன்.
மொழிபெயர்ப்பைப் போலவே, ஒருவேளை ஆச்சரியப்படுவதற்கில்லை, ஒரு கோணத்தில் சுழற்சி, தீட்டா என்பது பின்வரும் வடிவத்தில் ஒரு அணி M ஐ உருவாக்குவதன் மூலம் தீர்மானிக்கப்படுகிறது:
இந்த அணி ஒரு திசையன் தீட்டா டிகிரிகளை (எதிர் கடிகார திசையில்) கொடுக்கப்பட்ட (x, y)-கார்டீசியன் விமானத்தைச் சுற்றி சுழற்றலாம். சாதாரணமாக, இந்த சூழ்நிலையில், தோற்றம் படத்தின் மையமாக இருக்கும், ஆனால் உண்மையில், நாம் எந்த சீரற்ற (x, y) புள்ளியையும் நமது சுழற்சி மையமாக குறிப்பிடலாம்.
சுழற்றப்பட்ட படம் R பின்னர் அசல் படத்திலிருந்து நான் நேரடியான அணி பெருக்கத்தைப் பயன்படுத்தி உருவாக்கப்படுகிறது: R = IM
மறுபுறம், OpenCV கூடுதலாக ஒரு படத்தை (1) அளவை (அதாவது, மறுஅளவிடுதல்) மற்றும் (2) சுற்றிச் சுழற்றுவதற்கு ஒரு தன்னிச்சையான சுழற்சி மையத்தை வழங்குகிறது.
எங்கள் மாற்றியமைக்கப்பட்ட சுழற்சி அணி M கீழே காட்டப்பட்டுள்ளது:
என்ற புதிய கோப்பைத் திறந்து உருவாக்குவதன் மூலம் ஆரம்பிக்கலாம் சுழற்று.py :
# தேவையான தொகுப்புகளை இறக்குமதி செய்கிறதுஇறக்குமதி உணர்ச்சியற்ற என எ.கா.
இறக்குமதி argparse
இறக்குமதி imutil
இறக்குமதி cv2
# வாதத்தை பாகுபடுத்தி பொருளை உருவாக்குதல் மற்றும் வாதத்தை பாகுபடுத்துதல்
apobj = argparse. வாதப் பாகுபடுத்தி ( )
apobj. add_argument ( '-k' , '--படம்' , தேவை = உண்மை , உதவி = 'பட பாதை' )
வாதங்கள் = யாருடைய ( apobj. parse_args ( ) )
படம் = cv2. imread ( வாதங்கள் [ 'படம்' ] )
cv2. காட்சி ( 'அசல்_படம்' , படம் )
# படத்தின் பரிமாணங்களைப் பயன்படுத்தி படத்தின் மையத்தைக் கணக்கிடுங்கள்.
( உயரம் , அகலம் ) = படம். வடிவம் [ : 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 இமுட்டில்களை நிறுவுகிறது. நாம் பின்வரும் முறையைப் பயன்படுத்த வேண்டும்:
pip நிறுவல் இமுட்டில்ஸ்
வரிகள் 8 முதல் 14 வரை: நாங்கள் எங்கள் agrparser ஐ உருவாக்கி எங்கள் படத்தை ஏற்றினோம். இந்த argparser இல், நாம் ஒரே ஒரு பட வாதத்தைப் பயன்படுத்துகிறோம், இது சுழற்சியை நிரூபிக்க இந்த நிரலில் நாம் பயன்படுத்தும் படத்தின் பாதையை நமக்குத் தெரிவிக்கும்.
ஒரு படத்தைச் சுழற்றும்போது, சுழற்சியின் மையப் புள்ளியை நாம் வரையறுக்க வேண்டும். பெரும்பாலான நேரங்களில், நீங்கள் ஒரு படத்தை அதன் மையத்தில் சுழற்ற விரும்புவீர்கள், ஆனால் அதற்கு பதிலாக எந்த சீரற்ற புள்ளியையும் தேர்வு செய்ய OpenCV உங்களை அனுமதிக்கிறது. படத்தை அதன் மையத்தில் சுழற்றுவோம்.
வரிகள் 17 முதல் 18 வரை படத்தின் அகலம் மற்றும் உயரத்தை முறையே எடுத்து, ஒவ்வொரு பரிமாணத்தையும் இரண்டாகப் பிரித்து படத்தின் மையத்தை நிறுவவும்.
ஒரு படத்தை மொழிபெயர்க்க ஒரு மேட்ரிக்ஸை வரையறுத்ததைப் போலவே ஒரு படத்தைச் சுழற்ற ஒரு அணியை உருவாக்குகிறோம். நாம் தான் அழைப்போம் cv2.getRotationMatrix2D NumPy ஐப் பயன்படுத்தி மேட்ரிக்ஸை கைமுறையாக உருவாக்குவதை விட வரி 22 இல் செயல்படும் (இது கொஞ்சம் சிரமமாக இருக்கலாம்).
தி cv2.getRotationMatrix2D செயல்பாட்டிற்கு மூன்று அளவுருக்கள் தேவை. முதல் உள்ளீடு விரும்பிய சுழற்சி கோணம் (இந்த வழக்கில், படத்தின் மையம்). படத்தை எத்தனை (எதிர் கடிகார திசையில்) டிகிரிகளில் சுழற்றுவோம் என்பதைக் குறிப்பிட தீட்டா பயன்படுத்தப்படுகிறது. இங்கே, படத்தை 45 டிகிரி சுழற்றுவோம். இறுதி விருப்பம் படத்தின் அளவுடன் தொடர்புடையது.
படத்தை அளவிடுவது பற்றி நாங்கள் இன்னும் விவாதிக்கவில்லை என்றாலும், படத்தை அதன் அசல் விகிதத்தில் பயன்படுத்த வேண்டும் என்பதைக் குறிக்கும் 1.0 உடன் மிதக்கும் புள்ளி எண்ணை இங்கே வழங்கலாம். இருப்பினும், நீங்கள் 2.0 மதிப்பைத் தட்டச்சு செய்தால், படத்தின் அளவு இரட்டிப்பாகும். 0.5 என்ற எண்ணானது படத்தின் அளவைக் குறைக்கிறது.
வரி 22 முதல் 23 வரை: எங்கள் சுழற்சி அணி எம் பெற்ற பிறகு cv2.getRotationMatrix2D செயல்பாடு, நாங்கள் எங்கள் படத்தைப் பயன்படுத்தி சுழற்றுகிறோம் cv2.warpAffine வரி 23 இல் நுட்பம். செயல்பாட்டின் முதல் உள்ளீடு நாம் சுழற்ற விரும்பும் படமாகும். எங்கள் வெளியீட்டுப் படத்தின் அகலம் மற்றும் உயரம் பின்னர் எங்கள் சுழற்சி அணி M உடன் வரையறுக்கப்படுகிறது. வரி 23 இல், படம் பின்னர் 55 டிகிரிகளால் சுழற்றப்படுகிறது.
எங்கள் படம் சுழற்றப்பட்டதை நீங்கள் கவனிக்கலாம்.
வரிகள் 28 முதல் 30 வரை இரண்டாவது சுழற்சியை அமைக்கவும். குறியீட்டின் 22-23 கோடுகள் ஒரே மாதிரியாக இருக்கும், இந்த முறை நாம் 55 க்கு எதிராக -85 டிகிரி சுழற்றுகிறோம்.
ஒரு படத்தை அதன் மையத்தைச் சுற்றி இது வரை சுழற்றியுள்ளோம். ஒரு சீரற்ற புள்ளியைச் சுற்றி படத்தைச் சுழற்ற விரும்பினால் என்ன செய்வது?
என்ற புதிய கோப்பைத் திறந்து உருவாக்குவதன் மூலம் ஆரம்பிக்கலாம் rotate.py:
# தேவையான தொகுப்புகளை இறக்குமதி செய்கிறதுஇறக்குமதி உணர்ச்சியற்ற என எ.கா.
இறக்குமதி argparse
இறக்குமதி imutil
இறக்குமதி cv2
# வாதத்தை பாகுபடுத்தி பொருளை உருவாக்குதல் மற்றும் வாதத்தை பாகுபடுத்துதல்
ap_obj = argparse. வாதப் பாகுபடுத்தி ( )
ap_obj. add_argument ( '-k' , '--படம்' , தேவை = உண்மை , உதவி = 'பட பாதை' )
வாதம் = யாருடைய ( ap_obj. parse_args ( ) )
# படத்தை ஏற்றி திரையில் காண்பிக்கவும்
படம் = cv2. imread ( வாதம் [ 'படம்' ] )
cv2. காட்சி ( 'அசல்_படம்' , படம் )
# படத்தின் பரிமாணங்களைப் பயன்படுத்தி படத்தின் மையத்தைக் கணக்கிடுங்கள்.
( உயரம் , அகலம் ) = படம். வடிவம் [ : 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]க்கு இடையில் விழும். பிக்சலில் 10ஐப் பார்க்கும்போது 250 இன் செறிவு கொண்ட பிக்சலில் சேர்க்க முயற்சித்தால் என்ன நடக்கும்?
நிலையான எண்கணிதக் கொள்கைகளைப் பயன்படுத்தினால், 260 மதிப்பை அடைவோம். RGB படங்கள் 8-பிட் கையொப்பமிடப்படாத முழு எண்களாகக் குறிப்பிடப்படுவதால், 260 என்பது சரியான மதிப்பு அல்ல.
அதனால் என்ன நிகழ வேண்டும்? எந்த பிக்சல்களும் [0, 255] வரம்பிற்கு அப்பால் இல்லை என்பதை உறுதிப்படுத்த, ஒவ்வொரு பிக்சலையும் 0 மற்றும் 255 க்கு இடையில் உள்ள மதிப்பைக் கொண்டிருக்கும்படி ஒரு காசோலையை இயக்க வேண்டுமா?
அல்லது நாம் 'சுற்றி' மற்றும் ஒரு மாடுலஸ் அறுவை சிகிச்சை செய்ய? மாடுலஸ் விதிகளுக்கு இணங்க, 10 ஐ 255 ஐக் கூட்டினால் 9 மதிப்பு கிடைக்கும்.
[0, 255] வரம்பிற்கு அப்பாற்பட்ட படங்களில் கூட்டல் மற்றும் கழித்தல் எவ்வாறு கையாளப்பட வேண்டும்?
உண்மை என்னவென்றால், சரியான அல்லது தவறான நுட்பம் இல்லை; உங்கள் பிக்சல்களுடன் நீங்கள் எவ்வாறு வேலை செய்கிறீர்கள் மற்றும் நீங்கள் எதை அடைய விரும்புகிறீர்கள் என்பதைப் பொறுத்தது.
ஆனால் OpenCV இல் சேர்ப்பதற்கும் NumPy இல் சேர்ப்பதற்கும் வேறுபாடுகள் உள்ளன என்பதை நினைவில் கொள்ளுங்கள். மாடுலஸ் எண்கணிதம் மற்றும் 'முறுக்கு' ஆகியவை NumPy ஆல் செய்யப்படும். இதற்கு நேர்மாறாக, OpenCV கிளிப்பிங்கைச் செயல்படுத்தும் மற்றும் பிக்சல் மதிப்புகள் வரம்பிலிருந்து வெளியேறாது என்பதை உறுதி செய்யும் [0, 255].
என்ற புதிய கோப்பை உருவாக்குவதன் மூலம் தொடங்குவோம் எண்கணிதம்.py மற்றும் அதை திறப்பது:
# python arithmetic.py --image squirrel.jpg# தேவையான தொகுப்புகளை இறக்குமதி செய்கிறது
இறக்குமதி உணர்ச்சியற்ற என எ.கா.
இறக்குமதி argparse
இறக்குமதி imutil
இறக்குமதி cv2
# வாதத்தை பாகுபடுத்தி பொருளை உருவாக்குதல் மற்றும் வாதத்தை பாகுபடுத்துதல்
apObj = argparse. வாதப் பாகுபடுத்தி ( )
apObj. add_argument ( '-k' , '--படம்' , தேவை = உண்மை , உதவி = 'பட பாதை' )
வாதங்கள் = யாருடைய ( apObj. parse_args ( ) )
படம் = cv2. imread ( வாதங்கள் [ 'படம்' ] )
cv2. காட்சி ( 'அசல்_படம்' , படம் )
'''
எங்கள் பிக்சல்களின் மதிப்புகள் வரம்பில் இருக்கும் [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-பிட் கையொப்பமிடாத முழு எண்களைக் கையாளுகிறோம் என்பதை நினைவில் கொள்ளுங்கள், இது வரம்பில் மட்டுமே இருக்க முடியும். நாங்கள் cv2.add முறையைப் பயன்படுத்துவதால், OpenCV கிளிப்பிங்கைக் கையாளுகிறது மற்றும் கூடுதலாக அதிகபட்சமாக 255 முடிவை மட்டுமே தருகிறது.
கீழே உள்ள பட்டியலின் முதல் வரி இந்த குறியீட்டை இயக்குவதன் விளைவைக் காட்டுகிறது:
எண்கணிதம். பைஅதிகபட்சம் 255 : [ [ 255 ] ]
இந்த கூட்டுத்தொகை உண்மையில் 255 எண்ணை உருவாக்கியது.
அதைத் தொடர்ந்து, வரி 26 கழிப்பதைச் செய்ய cv2.subtract ஐப் பயன்படுத்துகிறது. மீண்டும், இரண்டு 8-பிட் கையொப்பமிடாத முழு எண்கள் NumPy அணிவரிசைகளை ஒவ்வொன்றிலும் ஒரு தனிமத்துடன் வரையறுக்கிறோம். முதல் அணிவரிசையின் மதிப்பு 60, இரண்டாவது அணிவரிசையின் மதிப்பு 100 ஆகும்.
கழித்தல் -40 மதிப்பில் விளைய வேண்டும் என்று எங்கள் எண்கணிதம் கட்டளையிடுகிறது, ஆனால் OpenCV மீண்டும் எங்களுக்காக கிளிப்பிங்கைக் கையாளுகிறது. மதிப்பு 0 ஆக குறைக்கப்பட்டதை நாங்கள் கண்டறிந்துள்ளோம். கீழே உள்ள எங்கள் முடிவு இதை நிரூபிக்கிறது:
எண்கணிதம். பைகுறைந்தபட்சம் 0 : [ [ 0 ] ]
cv2 ஐப் பயன்படுத்தி, 60 கழித்தலில் இருந்து 100ஐக் கழித்து, மதிப்பு 0 ஐ உருவாக்குகிறது.
கணக்கீடுகளைச் செய்ய OpenCV க்குப் பதிலாக NumPy ஐப் பயன்படுத்தினால் என்ன நடக்கும்?
வரிகள் 38 மற்றும் 39 இந்த சிக்கலை தீர்க்கவும்.
முதலில், இரண்டு 8-பிட் கையொப்பமிடாத முழு எண் NumPy அணிவரிசைகள் ஒவ்வொன்றும் ஒரு தனி உறுப்புடன் வரையறுக்கப்படுகின்றன. முதல் அணிவரிசையின் மதிப்பு 201, அதேசமயம் இரண்டாவது அணிவரிசையின் மதிப்பு 100. எங்கள் கூட்டல் குறைக்கப்படும், மேலும் cv2.add செயல்பாட்டைப் பயன்படுத்தினால் 255 மதிப்பு வழங்கப்படும்.
NumPy, மறுபுறம், 'சுற்றும்' மற்றும் கிளிப்பிங் செய்வதற்கு பதிலாக மாடுலோ எண்கணிதத்தை செய்கிறது. NumPy 255 இன் மதிப்பை அடைந்தவுடன் பூஜ்ஜியமாகச் சுற்றி, 100 படிகள் அடையும் வரை எண்ணும். இது வெளியீட்டின் முதல் வரியால் உறுதிப்படுத்தப்பட்டுள்ளது, இது கீழே காட்டப்பட்டுள்ளது:
எண்கணிதம். பைசுற்றி வளைக்கவும்: [ நான்கு. ஐந்து ]
பின்னர், மேலும் இரண்டு NumPy அணிவரிசைகள் வரையறுக்கப்படுகின்றன, ஒன்று 50 மதிப்புடன் மற்றொன்று 100. இந்தக் கழித்தல் cv2.subtract முறை மூலம் 0 இன் முடிவைத் தரும். ஆனால் கிளிப்பிங்கிற்குப் பதிலாக, NumPy செயல்படுத்துகிறது என்பதை நாங்கள் அறிவோம். தொகுதி எண்கணிதம். அதற்குப் பதிலாக, மாடுலோ செயல்முறைகள் சுற்றிக் கொண்டு, கழித்தலின் போது 0 ஐ அடைந்தவுடன் 255 இலிருந்து பின்நோக்கி எண்ணத் தொடங்கும். பின்வரும் வெளியீட்டில் இருந்து நாம் இதைக் காணலாம்:
எண்கணிதம். பைசுற்றி வளைக்கவும்: [ 207 ]
மீண்டும் ஒருமுறை, எங்கள் முனைய வெளியீடு கிளிப்பிங் மற்றும் சுற்றி வளைத்தல் ஆகியவற்றுக்கு இடையேயான வேறுபாட்டை நிரூபிக்கிறது:
முழு எண் கணிதத்தைச் செய்யும்போது நீங்கள் விரும்பிய முடிவை மனதில் வைத்திருப்பது முக்கியம். [0, 255] வரம்பிற்கு வெளியே ஏதேனும் மதிப்புகள் கிளிப் செய்யப்பட வேண்டுமா? அதன் பிறகு OpenCV இன் உள்ளமைக்கப்பட்ட பட எண்கணித நுட்பங்களைப் பயன்படுத்தவும்.
மதிப்புகள் [0, 255] மற்றும் மாடுலஸ் எண்கணித செயல்பாடுகளின் வரம்பிற்கு அப்பாற்பட்டதாக இருந்தால் அவற்றைச் சுற்றி வைக்க வேண்டுமா? NumPy வரிசைகள் பின்னர் சாதாரணமாக சேர்க்கப்பட்டு வழக்கம் போல் கழிக்கப்படும்.
வரி 48 நமது படத்தின் அதே பரிமாணங்களைக் கொண்ட ஒரு பரிமாண NumPy வரிசையை வரையறுக்கிறது. மீண்டும், எங்கள் தரவு வகை 8-பிட் கையொப்பமிடப்படாத முழு எண்களாக இருப்பதை உறுதிசெய்கிறோம். 1 க்கு பதிலாக 101 இன் மதிப்புகளை நிரப்ப, ஒரு இலக்க மதிப்புகளின் அணியை 101 ஆல் பெருக்குவோம். இறுதியாக, அசல் படத்திற்கு 100களின் அணியைச் சேர்க்க cv2.add செயல்பாட்டைப் பயன்படுத்துகிறோம். இது ஒவ்வொரு பிக்சலின் தீவிரத்தையும் 101 ஆல் அதிகரிக்கிறது, அதே நேரத்தில் 255 ஐத் தாண்ட முயற்சிக்கும் எந்த மதிப்புகளும் [0, 255] வரம்பில் இணைக்கப்படுவதை உறுதி செய்கிறது.
படம் எப்படி கவனிக்கத்தக்க வகையில் பிரகாசமாக உள்ளது மற்றும் அசலை விட 'கழுவி' அதிகமாகத் தோன்றுகிறது என்பதைக் கவனியுங்கள். ஏனென்றால், பிக்சல்களின் தீவிரத்தை 101 ஆல் உயர்த்துவதன் மூலம், பிரகாசமான வண்ணங்களை நோக்கி பிக்சல்களை இயக்குகிறோம்.
படத்தின் ஒவ்வொரு பிக்சல் தீவிரத்திலிருந்தும் 60ஐக் கழிப்பதற்காக, முதலில் 60களில் நிரப்பப்பட்ட இரண்டாவது NumPy வரிசையை வரி 54 இல் நிறுவுகிறோம்.
இந்த கழித்தல் முடிவுகள் பின்வரும் படத்தில் சித்தரிக்கப்பட்டுள்ளன:
நம்மைச் சுற்றியுள்ள பொருட்கள் முன்பு இருந்ததை விட கணிசமாக இருண்டதாகத் தெரிகிறது. ஏனெனில் ஒவ்வொரு பிக்சலிலிருந்தும் 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. parse_args ( ) )
படம் = cv2. imread ( வாதம் [ 'படம்' ] )
cv2. காட்சி ( 'அசல்' , படம் )
# படத்தை கிடைமட்டமாக புரட்டவும்
படம் புரட்டப்பட்டது = cv2. புரட்டவும் ( படம் , 1 )
cv2. காட்சி ( 'படம் கிடைமட்டமாக புரட்டப்பட்டது' , படம் புரட்டப்பட்டது )
# படத்தை செங்குத்தாக புரட்டவும்
படம் புரட்டப்பட்டது = cv2. புரட்டவும் ( படம் , 0 )
cv2. காட்சி ( 'படம் செங்குத்தாக புரட்டப்பட்டது' , படம் புரட்டப்பட்டது )
# படத்தை இரண்டு அச்சுகளிலும் புரட்டவும்
படம் புரட்டப்பட்டது = cv2. புரட்டவும் ( படம் , - 1 )
cv2. காட்சி ( 'கிடைமட்டமாகவும் செங்குத்தாகவும் புரட்டப்பட்டது' , படம் புரட்டப்பட்டது )
cv2. காத்திருக்கவும் ( 0 )
எங்கள் தொகுப்புகளை இறக்குமதி செய்யவும், உள்ளீடுகளை அலசவும், வட்டில் இருந்து படத்தை ஏற்றவும் நாம் எடுக்கும் படிகள் l இல் கையாளப்படுகின்றன. இன்ஸ் 1 முதல் 12 வரை .
cv2.flip செயல்பாட்டை ஆன் செய்வதன் மூலம் வரி 15 , ஒரு படத்தை கிடைமட்டமாக புரட்டுவது எளிது. நாம் புரட்ட விரும்பும் படம் மற்றும் படத்தை எப்படி புரட்டுவது என்பதைக் குறிப்பிடும் ஒரு குறிப்பிட்ட குறியீடு அல்லது கொடி ஆகியவை cv2.flip முறைக்கு தேவையான இரண்டு வாதங்கள்.
ஃபிளிப் கோட் மதிப்பு 1 என்றால், படத்தை கிடைமட்டமாக புரட்டுவதற்காக y-அச்சில் சுழற்றுவோம் ( வரி 15 ) 0 இன் ஃபிளிப் குறியீட்டைக் குறிப்பிட்டால், படத்தை x-அச்சு ( வரி 19 ) எதிர்மறை ஃபிளிப் குறியீடு ( வரி 23 ) படத்தை இரண்டு அச்சுகளிலும் சுழற்றுகிறது.
இந்த விஷயத்தில் எளிதான எடுத்துக்காட்டுகளில் ஒன்று ஒரு படத்தை புரட்டுவது, இது அடிப்படை.
அடுத்து, படங்களை செதுக்குவது பற்றி விவாதிப்போம் மற்றும் குறிப்பிட்ட படப் பகுதிகளைப் பிரித்தெடுக்க NumPy வரிசை துண்டுகளைப் பயன்படுத்துவோம்.
5. பட செதுக்குதல்
க்ராப்பிங், பெயர் குறிப்பிடுவது போல, ஆர்வமுள்ள பகுதியை (அல்லது வெறுமனே ROI) தேர்ந்தெடுத்து அகற்றும் செயல்முறையாகும், இது நமக்கு விருப்பமான படத்தின் பகுதி.
முகம் கண்டறிதல் பயன்பாட்டிற்கு படத்தில் இருந்து முகத்தை செதுக்க வேண்டும். கூடுதலாக, படங்களில் நாய்களைக் கண்டறிய பைதான் ஸ்கிரிப்டை உருவாக்கினால், படத்தைக் கண்டுபிடிக்கும் போது நாயை வெட்ட வேண்டும்.
இலக்குகள்: ஒரு படத்திலிருந்து பகுதிகளை செதுக்க NumPy வரிசை ஸ்லைசிங்கைப் பயன்படுத்தி எளிதாகப் பழகிக்கொள்வதே எங்கள் முக்கிய குறிக்கோள்.
பயிர் செய்தல் : நாம் ஒரு படத்தை செதுக்கும்போது, நமக்கு விருப்பமில்லாத வெளிப்புற கூறுகளை அகற்றுவதே எங்கள் குறிக்கோள். எங்கள் ROI ஐத் தேர்ந்தெடுக்கும் செயல்முறை பெரும்பாலும் எங்கள் ஆர்வமுள்ள பகுதியைத் தேர்ந்தெடுப்பதாகக் குறிப்பிடப்படுகிறது.
என்ற புதிய கோப்பை உருவாக்கவும் பயிர்.பை , அதைத் திறந்து, பின்வரும் குறியீட்டைச் சேர்க்கவும்:
# மலைப்பாம்பு பயிர்.py# தேவையான தொகுப்புகளை இறக்குமதி செய்கிறது
இறக்குமதி 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. parse_args ( ) )
# படத்தை ஏற்றி திரையில் காண்பிக்கவும்
படம் = cv2. imread ( வாதங்கள் [ 'படம்' ] )
cv2. காட்சி ( 'அசல்' , படம் )
# படம் வளைந்து, விகிதத்தில் தோன்றுவதைத் தடுக்க
# கருதப்பட வேண்டும் அல்லது சிதைக்கப்பட வேண்டும்; எனவே, நாம் என்ன கண்டுபிடிக்கிறோம்
# தற்போதைய படத்திற்கு புதிய படத்தின் விகிதம்.
# நமது புதிய படத்தின் அகலத்தை 160 பிக்சல்களாக ஆக்குவோம்.
அம்சம் = 160.0 / படம். வடிவம் [ 1 ]
பரிமாணம் = ( 160 , முழு எண்ணாக ( படம். வடிவம் [ 0 ] * அம்சம் ) )
# இந்த வரி உண்மையான மறுஅளவிடுதல் செயல்பாடுகளைக் காண்பிக்கும்
மறுஅளவிடப்பட்ட படம் = cv2. அளவை மாற்றவும் ( படம் , பரிமாணம் , இடைச்செருகல் = cv2. INTER_AREA )
cv2. காட்சி ( 'பட அகலம் மாற்றப்பட்டது' , மறுஅளவிடப்பட்ட படம் )
# படத்தின் உயரத்தை மாற்ற விரும்பினால் என்ன செய்வது? - பயன்படுத்தி
# அதே கொள்கையின் அடிப்படையில், விகிதத்தை நாம் கணக்கிடலாம்
# அகலத்தை விட உயரத்தில். அளவீடு செய்வோம்
# படத்தின் உயரம் 70 பிக்சல்கள்.
அம்சம் = 70.0 / படம். வடிவம் [ 0 ]
பரிமாணம் = ( முழு எண்ணாக ( படம். வடிவம் [ 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 ஐ எவ்வாறு பயன்படுத்துவது என்பதையும் நாங்கள் கற்றுக்கொண்டோம். நீங்கள் பயன்படுத்தும் இடைக்கணிப்பு முறை மற்றும் உங்கள் அசல் படத்தின் விகிதத்தை மறுஅளவாக்கும்போது, முடிவு சிதைந்து போகாமல் இருக்க, இரண்டையும் கருத்தில் கொள்வது மிகவும் முக்கியம்.
இறுதியாக, படத்தின் தரம் ஒரு பிரச்சினையாக இருந்தால், பெரிய படத்திலிருந்து சிறிய படத்திற்கு மாறுவது எப்போதும் சிறந்தது என்பதை நினைவில் கொள்வது அவசியம். பெரும்பாலான சந்தர்ப்பங்களில், ஒரு படத்தை பெரிதாக்குவது கலைப்பொருட்களை உருவாக்குகிறது மற்றும் அதன் தரத்தை குறைக்கிறது.