- SIFT ஐப் பயன்படுத்தி பொருள் கண்டறிதல்
- ORB ஐப் பயன்படுத்தி பொருள் கண்டறிதல்
- ஓரியண்டட் சாய்வுகளின் ஹிஸ்டோகிராம் (HOG கள்)
- ஓரியண்டட் சாய்வுகளின் ஹிஸ்டோகிராம் (HOG கள்), படிப்படியாக:
- HAAR அடுக்கை வகைப்படுத்திகள்
- முகம் மற்றும் கண் கண்டறிதல்
- நேரடி முகம் மற்றும் கண் கண்டறிதல்
- ட்யூனிங் கேஸ்கேட் வகைப்படுத்திகள்
- வீடியோக்களில் கார் மற்றும் பாதசாரி கண்டறிதல்
சாளரங்களில் பைதான் ஓபன்சிவியை நிறுவத் தொடங்கினோம், இதுவரை சில அடிப்படை பட செயலாக்கம், படப் பிரிவு மற்றும் பைத்தானைப் பயன்படுத்தி பொருள் கண்டறிதல் ஆகியவற்றைச் செய்துள்ளோம், அவை கீழே உள்ள பயிற்சிகளில் உள்ளன:
- பைதான் ஓபன்சிவி உடன் தொடங்குதல்: நிறுவல் மற்றும் அடிப்படை பட செயலாக்கம்
- பைத்தான் ஓபன்சிவியில் பட கையாளுதல்கள் (பகுதி 1)
- ஓபன்சிவியில் பட கையாளுதல்கள் (பகுதி -2)
- ஓபன்சிவியைப் பயன்படுத்தி படப் பிரிவு - ஒரு படத்தின் குறிப்பிட்ட பகுதிகளை பிரித்தெடுக்கிறது
பொருள் கண்டறிதலுக்கான பல்வேறு முறைகள் மற்றும் வழிமுறைகளைப் பற்றியும் நாங்கள் கற்றுக்கொண்டோம், அங்கு ஒவ்வொரு பொருளுக்கும் வெவ்வேறு வழிமுறைகளைப் பயன்படுத்தி சில முக்கிய புள்ளிகள் அடையாளம் காணப்பட்டன. இந்த டுடோரியலில் நிஜ வாழ்க்கை பொருட்களைக் கண்டறிய அந்த வழிமுறைகளைப் பயன்படுத்தப் போகிறோம், இங்கே நாம் கண்டறிதலுக்கு SIFT மற்றும் ORB ஐப் பயன்படுத்துகிறோம்.
SIFT ஐப் பயன்படுத்தி பொருள் கண்டறிதல்
இங்கே பொருள் கண்டறிதல் நேரடி வெப்கேம் ஸ்ட்ரீமைப் பயன்படுத்தி செய்யப்படும், எனவே அது பொருளை அங்கீகரித்தால் அது கண்டெடுக்கப்பட்ட பொருளைக் குறிக்கும். குறியீட்டில் முக்கிய பகுதி SIFT டிடெக்டர் என அழைக்கப்படும் செயல்பாட்டால் இயக்கப்படுகிறது, பெரும்பாலான செயலாக்கம் இந்த செயல்பாட்டால் செய்யப்படுகிறது.
குறியீட்டின் மற்ற பாதியில், நாங்கள் வெப்கேம் ஸ்ட்ரீமைத் திறக்கத் தொடங்குகிறோம், பின்னர் பட வார்ப்புருவை ஏற்றவும், அதாவது குறிப்பு படத்தை ஏற்றவும், அதாவது நிரல் உண்மையில் வெப்கேம் ஸ்ட்ரீம் வழியாக பார்க்கிறது.
அடுத்து, வெப்கேம் ஸ்ட்ரீமில் இருந்து படங்களை எல்லையற்ற போது சுழற்சியின் உதவியுடன் தொடர்ச்சியாகப் பிடிக்கிறோம், பின்னர் வெப்கேம் சட்டகத்தின் உயரத்தையும் அகலத்தையும் கைப்பற்றுகிறோம், அதன் பிறகு வட்டி பகுதி (ROI) பெட்டியின் அளவுருக்களை வரையறுக்கிறோம். வெப்கேம் சட்டகத்தின் தொடர்புடைய உயரத்தையும் அகலத்தையும் எடுத்துக்கொள்வதன் மூலம் எங்கள் பொருள் பொருந்தும். நாம் மேலே வரையறுத்துள்ள ROI அளவுருக்களிலிருந்து செவ்வகத்தை வரைகிறோம். பின்னர் இறுதியாக செவ்வகத்தை வெட்டி, குறியீட்டின் ஸ்விஃப்ட் டிடெக்டர் பகுதிக்கு உணவளிக்கவும்.
இப்போது SIFT டிடெக்டர் அடிப்படையில் இரண்டு உள்ளீடுகளைக் கொண்டுள்ளது, ஒன்று செதுக்கப்பட்ட படம் மற்றும் மற்றொன்று நாம் முன்பு வரையறுக்கப்பட்ட பட வார்ப்புரு, பின்னர் அது எங்களுக்கு சில போட்டிகளைத் தருகிறது, எனவே போட்டிகள் அடிப்படையில் செதுக்கப்பட்ட உருவத்தில் ஒத்திருக்கும் பொருள்கள் அல்லது முக்கிய புள்ளிகளின் எண்ணிக்கை மற்றும் இலக்கு படம். போட்டிகளுக்கான நுழைவாயிலின் மதிப்பை நாங்கள் வரையறுக்கிறோம், போட்டிகளின் மதிப்பு வாசலை விட அதிகமாக இருந்தால், எங்கள் திரையில் காணப்படும் படத்தை ROI செவ்வகத்தின் பச்சை நிறத்துடன் வைக்கிறோம்.
இப்போது குறியீட்டின் முக்கிய பகுதிக்குச் செல்வோம், இது SIFT டிடெக்டர் என அழைக்கப்படுகிறது, இது உள்ளீட்டை இரண்டு படங்களாக எடுத்துக்கொள்கிறது, ஒன்று அது பொருளைத் தேடும் படம், மற்றொன்று நாம் பொருத்த முயற்சிக்கும் பொருள் க்கு (பட வார்ப்புரு). சாம்பல் முதல் படத்தை அளவிட மற்றும் பட வார்ப்புருவை இரண்டாவது படமாக வரையறுக்கவும். பின்னர் நாம் ஒரு SIFT டிடெக்டர் பொருளை உருவாக்கி, OpenCV SIFT கண்டறிதல் மற்றும் கணக்கீட்டு செயல்பாட்டை இயக்குகிறோம், இதனால் முக்கிய புள்ளிகளைக் கண்டறிந்து விவரிப்பாளர்களைக் கணக்கிட, விவரிப்பாளர்கள் அடிப்படையில் முக்கிய புள்ளிகளைப் பற்றிய தகவல்களைச் சேமிக்கும் திசையன்கள், மேலும் நாம் பொருந்தும்போது இது மிகவும் முக்கியமானது படங்களின் விளக்கங்களுக்கு இடையில்.
பின்னர் FLANN அடிப்படையிலான மேட்சரை வரையறுக்கவும், அதன் பின்னால் பொருந்தக்கூடிய கணிதக் கோட்பாட்டிற்கு நாங்கள் செல்லவில்லை, ஆனால் அதைப் பற்றி நீங்கள் எளிதாக கூகிள் செய்யலாம். முதலாவதாக, குறியீட்டு kdtree ஐ பூஜ்ஜியமாக வரையறுக்கவும், பின்னர் குறியீட்டு மற்றும் தேடல் அளவுருக்களை அகராதி வடிவத்தில் அமைப்போம், நாம் பயன்படுத்தப் போகும் வழிமுறையை வரையறுக்கிறோம், இது KDTREE, மற்றும் நாம் பயன்படுத்தப் போகும் மரங்களின் எண்ணிக்கை, அதிக மரம் இது மிகவும் சிக்கலானதாகவும் மெதுவாகவும் பயன்படுத்துகிறோம். தேடல் அளவுருவில் காசோலைகளின் எண்ணிக்கையை வரையறுக்கிறது, இது அடிப்படையில் அது முடிக்கப் போகும் போட்டிகளின் எண்ணிக்கை.
குறியீட்டு அளவுருக்கள் மற்றும் தேடல் அளவுருக்கள் என நாம் முன்னர் வரையறுக்கப்பட்ட அளவுருவை ஏற்றுவதன் மூலம் எங்கள் FLANN அடிப்படையிலான மேட்சர் பொருளை உருவாக்கவும், இதன் அடிப்படையில் எங்கள் FLANN அடிப்படையிலான மேட்சரை உருவாக்கவும், இது KNN கேட்சர் ஆகும், இது KNN K- அருகிலுள்ள அண்டை நாடுகளாகும், அடிப்படையில் இது ஒரு வழி நாங்கள் அருகிலுள்ள மேட்சர்கள் மற்றும் டிஸ்கிரிப்டர்களைத் தேடுகிறோம், துவக்க மாறிலி k உடன் பொருத்தத்தை செய்கிறோம். இப்போது இந்த FLANN அடிப்படையிலான மேட்சர் நமக்கு கிடைக்கும் போட்டிகளின் எண்ணிக்கையை வழங்குகிறது.
FLANN அடிப்படையிலான பொருத்தம் ஒரு தோராயமானதாகும், எனவே FLANN அடிப்படையிலான மேட்சரின் துல்லியத்தை அதிகரிக்க நாம் லோவின் விகித சோதனையை செய்கிறோம், அது என்ன செய்கிறது என்பது knn flann அடிப்படையிலான மேட்சரிலிருந்து போட்டிகளைத் தேடுகிறது மற்றும் சில மெட்ரிக் அளவுருக்களை வரையறுக்கிறது, எந்த தூரத்திற்கு ஒரு சுறுசுறுப்பான செயல்பாடு, மற்றும் அது ஒரு முறை அளவுகோல்களை பூர்த்தி செய்தால் போட்டிகளை நல்ல போட்டிகளுடன் சேர்த்து, நல்ல போட்டிகளைத் தருகிறது, எனவே நேரடி வீடியோ ஸ்ட்ரீம் திரையின் மூலையில் காணப்படும் போட்டிகளின் எண்ணிக்கையைக் கூறுகிறது.
இப்போது மேலே உள்ள விளக்கத்திற்கான குறியீட்டைப் பார்ப்போம்:
cv2 இறக்குமதி எண்ணை np def sift_detector (new_image, image_template) ஆக இறக்குமதி செய்க : # உள்ளீட்டு படத்தை வார்ப்புருவுடன் ஒப்பிடும் செயல்பாடு # இது அவற்றுக்கு இடையேயான SIFT போட்டிகளின் எண்ணிக்கையை அளிக்கிறது image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) image2 = image_template # உருவாக்கு SIFT கண்டறிதல் பொருள் #sift = cv2.SIFT () sift = cv2.xfeatures2d.SIFT_create () # SIFT keypoints_1, descriptors_1 = sift.detectAndCompute (image1, none) keypoints_2, descriptomp_2 எதுவுமில்லை) # எங்கள் ஃபிளான் மேட்சருக்கான அளவுருக்களை வரையறுக்கவும் FLANN_INDEX_KDTREE = 0 index_params = dict (வழிமுறை = FLANN_INDEX_KDTREE, மரங்கள் = 3) search_params = dict என்று (காசோலைகளை = 100) # Flann பொருத்தியைச் பொருள் உருவாக்கவும் flann = cv2.FlannBasedMatcher (index_params, search_params) # கே அருகாமையிலுள்ளவற்றைப் முறை பயன்படுத்தி போட்டிகளில் பெறுதல் # முடிவுக்கான 'matchs' ஒரேவிதமான போட்டிகளின் எண்ணிக்கையை இரண்டு படங்களில் காணப்படுகிறது போட்டிகளில் = flann.knnMatch (டிஸ்கிரிப்டர்கள்_1, டிஸ்கிரிப்டர்கள்_2, கே = 2) # லோவின் விகித சோதனையைப் பயன்படுத்தி நல்ல போட்டிகளை சேமிக்கவும் good_matches = m க்கு n, n போட்டிகளில்: m.distance <0.7 * n.distance: good_matches.append (m) திரும்ப லென் (good_matches) cap = cv2.VideoCapture (0) # எங்கள் பட வார்ப்புருவை ஏற்றவும், இது எங்கள் குறிப்புப் படம் image_template = cv2.imread ('phone.jpg', 0) உண்மைதான்: # வெப்கேம் படங்களைப் பெறுக ret, frame = cap.read () # வெப்கேம் சட்டத்தின் உயரத்தின் அகலத்தையும் அகலத்தையும் பெறுங்கள், அகலம் = frame.shape # ROI பெட்டி பரிமாணங்களை வரையறுக்கவும் top_left_x = int (அகலம் / 3) top_left_y = int ((உயரம் / 2) + (உயரம் / 4)) bottom_right_x = int ((அகலம் / 3) * 2) bottom_right_y = int ((உயரம் / 2) - (உயரம் / 4)) # எங்கள் ஆர்வமுள்ள பகுதிக்கு செவ்வக சாளரத்தை வரையவும் cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) கவனிக்கப்படவேண்டிய # பயிர் ஜன்னல் நாங்கள் மேலே விவரிக்கப்பட்ட சரிசெய்யப்பட்டு = சட்ட # திருப்பு சட்ட நோக்குநிலை கிடைமட்டமாக சட்ட = cv2.flip (தர்க்க, 1) # ஐயும் பெறவும் சலி எண்ணிக்கை பொருந்துகிறதா போட்டிகளில் = sift_detector (சரிசெய்யப்பட்டு, image_template) # தற்போதைய எண் காட்டும் நிலை சரம் காண்பி. போட்டிகளின் cv2.putText (frame, str (match), (450,450), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 1) # பொருள் கண்டறிதலைக் குறிக்க எங்கள் வாசல் # SIFT கண்டறிதல் சிறிய தவறான நேர்மறைகளை அளிப்பதால் நாங்கள் 10 ஐப் பயன்படுத்துகிறோம் வாசல் = 10 # பொருத்தங்கள் எங்கள் நுழைவாயிலைத் தாண்டினால் , பொருத்தங்கள்> வாசல்: பொருள் : cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (frame, 'பொருள் கிடைத்தது', (50,50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('SIFT ஐப் பயன்படுத்தி பொருள் கண்டறிதல்', சட்டகம்) என்றால் cv2.nightKey (1) == 13: # 13 என்பது Enter விசை இடைவெளி cap.release () cv2.destroyAllWindows ()
ORB ஐப் பயன்படுத்தி பொருள் கண்டறிதல்
முக்கிய புள்ளிகளின் அடிப்படையில் மிகவும் துல்லியமான எண்ணிக்கையிலான போட்டிகளை இது உருவாக்குகிறது, இருப்பினும் அதன் காப்புரிமை பெற்றது மற்றும் வணிக பயன்பாடுகளுக்கு அதைப் பயன்படுத்துவதை கடினமாக்குகிறது என்பதால், SIFT ஐப் பயன்படுத்தி பொருள் கண்டறிதல் மிகவும் அருமையாகவும் துல்லியமாகவும் இருக்கிறது, அதற்கான வேறு வழி ORB வழிமுறை பொருள் கண்டறிதலுக்கு.
SIFT ஆல் பொருள் கண்டறிதல் முறையைப் போலவே, இதில் நாங்கள் நிரலை இரண்டு பகுதிகளாகப் பிரித்தோம், அதே இங்கே பின்பற்றப்படும்.
முதலாவதாக, இரண்டு உள்ளீடுகளை எடுக்கும் ORB_detector செயல்பாட்டை நாங்கள் வரையறுக்கிறோம், ஒன்று வெப்கேமிலிருந்து வரும் நேரடி ஸ்ட்ரீம் படம், மற்றொன்று பட வார்ப்புரு, இதன் அடிப்படையில் நாம் எங்கள் படத்துடன் பொருந்தப் போகிறோம். பின்னர் நாங்கள் எங்கள் வெப்கேம் படத்தை கிரேஸ்கேல் செய்து, பின்னர் எங்கள் ORB டிடெக்டரைத் துவக்குகிறோம், இதை 1000 முக்கிய புள்ளிகளிலும், அளவுகோல் அளவுருக்கள் 1.2 ஆகவும் அமைக்கிறோம். இந்த அளவுருக்களுடன் நீங்கள் எளிதாக விளையாடலாம், பின்னர் படங்களுக்கான முக்கிய புள்ளிகள் (கேபி) மற்றும் டிஸ்கிரிப்டர்கள் (டெஸ்) ஆகியவற்றைக் கண்டறியலாம் மற்றும் கண்டறிதலில் நாம் வரையறுக்கும் இரண்டாவது அளவுருவும் கணினி செயல்பாடு எதுவும் இல்லை, இது பட முகமூடியைப் பயன்படுத்தக் கேட்கிறதா இல்லையா? நாங்கள் அதை இங்கே மறுக்கிறோம்.
முன்னர் நாங்கள் FLANN அடிப்படையிலான மேட்சரைப் பயன்படுத்தி வந்த டிடெக்டருக்குச் செல்லுங்கள், ஆனால் இங்கே நாம் BFMatcher ஐப் பயன்படுத்துவோம், BFMatcher க்குள் இரண்டு அளவுருக்களை வரையறுக்கிறோம், ஒன்று NORM_HAMMING, மற்றொன்று குறுக்குவெட்டு அதன் மதிப்பு உண்மை.
மேலே வரையறுக்கப்பட்ட விளக்கங்களைப் பயன்படுத்தி அந்த இரண்டு படங்களுக்கிடையேயான போட்டிகளைக் கணக்கிடுங்கள், இது எல்லா போட்டிகளிலும் இந்த போட்டிகள் தோராயமாக இல்லாததால், லோவின் விகித சோதனை செய்ய வேண்டிய அவசியமில்லை என்பதால், போட்டிகளின் எண்ணிக்கையை வரிசைப்படுத்துகிறோம்., குறைந்த பட்சம் அதிக தூரம் பொருத்தம் சிறந்தது (இங்கே தூரம் என்பது புள்ளிகளுக்கு இடையிலான தூரம் என்று பொருள்), இறுதியில் நீள செயல்பாட்டைப் பயன்படுத்தி போட்டிகளின் எண்ணிக்கையைத் தருகிறோம்.
முக்கிய செயல்பாட்டில் , ஓர்ப் டிடெக்டர் அதிக சத்தத்தை உருவாக்குவதால், வாசலை மிக அதிக மதிப்புக்கு அமைக்கிறோம்.
இப்போது ORB அடிப்படையிலான கண்டறிதலுக்கான குறியீட்டைப் பார்ப்போம்
cv2 இறக்குமதி எண்ணை np def ORB_detector (new_image, image_template) ஆக இறக்குமதி செய்க : # உள்ளீட்டு படத்தை வார்ப்புருவுடன் ஒப்பிடும் செயல்பாடு # இது அவற்றுக்கு இடையேயான ORB போட்டிகளின் எண்ணிக்கையை அளிக்கிறது image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) # 1.2 orb = cv2.ORB_create (1000, 1.2) # அளவிடும் பிரமிடு காரணி கொண்ட 1000 முக்கிய புள்ளிகள் # அசல் படத்தின் முக்கிய புள்ளிகளைக் கண்டறியவும் (kp1, des1) = orb.detectAndCompute (image1, none) # சுழற்றப்பட்ட படத்தின் முக்கிய புள்ளிகளைக் கண்டறியவும் (kp2, des2) = orb.detectAndCompute (image_template, ஏதுமில்லை) # அணுப்பப்பட்டு உருவாக்கவும் # குறிப்பு நாங்கள் Flannbased பொருந்தும் இனி பயன்படுத்தப் போவதில்லை இருக்கிறோம் BF = cv2.BFMatcher (cv2.NORM_HAMMING, Crosscheck = உண்மை) # பொருந்தக்கூடிய போட்டிகளைச் செய்யுங்கள் = bf.match (des1, des2) # போட்டிகளை தூரத்தின் அடிப்படையில் வரிசைப்படுத்துங்கள். குறைந்த தூரம் # சிறந்தது பொருத்தங்கள் = வரிசைப்படுத்தப்பட்டவை (பொருத்தங்கள், விசை = லாம்ப்டா மதிப்பு: val.distance) திரும்ப லென் (பொருத்தங்கள்) தொப்பி = cv2.VideoCapture (0) # எங்கள் பட வார்ப்புருவை ஏற்றவும், இது எங்கள் குறிப்பு படம் image_template = cv2.imread ('phone.jpg', 0) # image_template = cv2.imread ('images / kitkat.jpg', 0) உண்மைதான்: # வெப்கேம் படங்களை மீண்டும் பெறவும் , frame = cap.read () # வெப்கேம் பிரேம் உயரத்தின் உயரத்தையும் அகலத்தையும் பெறவும் , width = frame.shape # ROI பெட்டி பரிமாணங்களை வரையறுக்கவும் (இவற்றில் சில விஷயங்கள் வளையத்திற்கு வெளியே இருக்க வேண்டும் என்பதை நினைவில் கொள்க) top_left_x = int (அகலம் / 3) top_left_y = int ((உயரம் / 2) + (உயரம் / 4)) bottom_right_x = int ((அகலம் / 3) * 2) bottom_right_y = int ((உயரம் / 2) - (உயரம் / 4)) # எங்கள் செவ்வக சாளரத்தை வரையவும் மண்டலத்தின் ஆர்வத்தை cv2.rectangle (தர்க்க (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) நாம் மேலே விவரிக்கப்பட்ட கவனிக்கப்படவேண்டிய # பயிர் ஜன்னல் சரிசெய்யப்பட்டு = சட்ட # திருப்பு சட்ட நோக்குநிலை கிடைமட்டமாக சட்ட = cv2.flip (தர்க்க, 1) # ORB பொருத்தங்களின் எண்ணிக்கையைப் பெறுங்கள் = ORB_detector (செதுக்கப்பட்ட, பட_வடிவம்) # நடப்பு இல்லை என்பதைக் காட்டும் நிலை சரம் காண்பி. போட்டிகளின் output_string = "பொருத்தங்கள் =" + str (பொருத்தங்கள்) cv2.putText (சட்டகம், வெளியீடு_ சரம், (50,450), cv2.FONT_HERSHEY_COMPLEX, 2, (250,0,150), 2) # பொருள் கண்டறிதலைக் குறிக்க எங்கள் வாசல் # புதிய படங்கள் அல்லது மின்னல் நிலைமைகளுக்கு நீங்கள் ஒரு பிட் பரிசோதனை செய்ய வேண்டியிருக்கும் # குறிப்பு: முதல் 1000 போட்டிகளைப் பெற ORB டிடெக்டர், 350 அடிப்படையில் ஒரு நிமிடம் 35% போட்டி வாசல் = 250 # போட்டிகள் நம்முடையதைத் தாண்டினால் தொடக்கநிலை அந்த பொருளின் கண்டறியப்பட்டுள்ளது என்றால் போட்டிகளில்> தெவிட்டுநிலை: cv2.rectangle (தர்க்க (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (தர்க்க, 'பொருள் உள்ளன', (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('ORB ஐப் பயன்படுத்தி பொருள் கண்டறிதல்', சட்டகம்) என்றால் cv2.nightKey (1) == 13: # 13 என்பது விசை விசையை உடைக்கும் தொப்பி. வெளியிடு () cv2.destroyAllWindows ()
ஓரியண்டட் சாய்வுகளின் ஹிஸ்டோகிராம் (HOG கள்)
இப்போது வேறுபட்ட விளக்கத்தைப் பற்றி பேசலாம், இது ஹிஸ்டோகிராம் ஆஃப் ஓரியண்டட் கிரேடியண்ட்ஸ் (HOG இன்).
HOG கள் மிகவும் அருமையான மற்றும் பயனுள்ள விளக்கங்கள் மற்றும் அவை பரவலாகவும் வெற்றிகரமாகவும் பொருளைக் கண்டறிவதற்குப் பயன்படுத்தப்படுகின்றன, முன்பு பார்த்தபடி SIFT மற்றும் ORB போன்ற பட விளக்கங்கள் நாம் முக்கிய புள்ளிகளைக் கணக்கிட வேண்டும், பின்னர் அந்த முக்கிய புள்ளிகளில் இருந்து விவரிப்பாளர்களைக் கணக்கிட வேண்டும், HOG அந்த செயல்முறையைச் செய்கிறது வித்தியாசமாக. இது அம்ச வெக்டார்களின் தொகுப்பிற்கு மாறாக பொருள்களை ஒற்றை அம்ச திசையனாக குறிக்கிறது, ஒவ்வொன்றும் படத்தின் ஒரு பகுதியைக் குறிக்கும். முழு படத்திற்கும் ஒற்றை திசையன் அம்சம் எங்களிடம் உள்ளது.
இது ஒரு படத்தின் மீது நெகிழ் சாளர கண்டுபிடிப்பாளரால் கணக்கிடப்படுகிறது, அங்கு ஒவ்வொரு நிலைக்கும் ஒரு HOG விவரிப்பான் கணக்கிடப்படுகிறது. பின்னர் ஒவ்வொரு நிலையும் ஒரு அம்ச திசையனுக்காக இணைக்கப்படுகிறது.
SIFT ஐப் போலவே படத்தின் அளவும் பிரமிடிங் மூலம் சரிசெய்யப்படுகிறது.
முன்னதாக நாங்கள் FLANN மற்றும் BFMatcher போன்ற மேட்சர்களைப் பயன்படுத்தினோம், ஆனால் HOG கள் அதை SVM (ஆதரவு திசையன் இயந்திரம்) வகைப்படுத்திகளின் உதவியுடன் வித்தியாசமாகச் செய்கின்றன, அங்கு கணக்கிடப்பட்ட ஒவ்வொரு HOG விளக்கமும் ஒரு SVM வகைப்படுத்தலுக்கு வழங்கப்படுகிறது, பொருள் கண்டுபிடிக்கப்பட்டதா இல்லையா என்பதை தீர்மானிக்க.
மனித கண்டறிதலுக்கான HOG களைப் பயன்படுத்துவதில் தலால் & தூண்டுதலின் ஒரு சிறந்த காகிதத்திற்கான இணைப்பு இங்கே:
ஓரியண்டட் சாய்வுகளின் ஹிஸ்டோகிராம் (HOG கள்), படிப்படியாக:
HOG ஐப் புரிந்துகொள்வது மிகவும் சிக்கலானதாக இருக்கலாம், ஆனால் இங்கே நாம் HOG இன் கோட்பாட்டை அது தொடர்பான கணிதத்தில் ஆழமாகச் செல்லாமல் மட்டுமே கையாளப் போகிறோம்.
எனவே இந்த படத்தை கொஞ்சம் பிக்சலேட்டட் செய்துள்ளோம், மேல் மூலையில் இங்கே 8x8 பிக்சல் பெட்டி உள்ளது, எனவே இந்த பெட்டியில் ஒவ்வொரு பிக்சலிலும் சாய்வு திசையன் அல்லது விளிம்பு நோக்குநிலைகளை கணக்கிடுகிறோம். எனவே இந்த பெட்டியில் பெட்டியின் உள்ளே பிக்சல்களின் பட சாய்வு திசையனைக் கணக்கிடுகிறோம் (அவை படத்தின் தீவிரத்தின் திசை அல்லது ஓட்டம்), மேலும் இது 64 (8 x 8) சாய்வு திசையன்களை உருவாக்குகிறது, பின்னர் அவை ஹிஸ்டோகிராமாக குறிப்பிடப்படுகின்றன. எனவே ஒவ்வொரு சாய்வு திசையனையும் குறிக்கும் ஒரு வரைபடத்தை கற்பனை செய்து பாருங்கள். எனவே அனைத்து புள்ளிகளும் அல்லது தீவிரங்களும் ஒரு திசையில் பொய் சொன்னால், அந்த திசைக்கான ஹிஸ்டோகிராம் 45 டிகிரி என்று சொல்லலாம், ஹிஸ்டோகிராம் 45 டிகிரியில் உச்சமாக இருக்கும்.
எனவே இப்போது நாம் செய்வது ஒவ்வொரு கலத்தையும் கோணத் தொட்டிகளாகப் பிரிப்பதாகும், அங்கு ஒவ்வொரு தொட்டியும் ஒரு சாய்வு திசைக்கு (எ.கா. x, y) ஒத்திருக்கும். தலால் மற்றும் ட்ரிக்ஸ் தாளில், அவர்கள் 9 பின்கள் 0-180 ° (20 ° ஒவ்வொரு தொட்டியும்) பயன்படுத்தினர். இது 64 திசையன்களை வெறும் 9 மதிப்புகளாகக் குறைக்கிறது. எனவே நாங்கள் செய்திருப்பது அளவைக் குறைத்தது, ஆனால் தேவையான அனைத்து முக்கிய தகவல்களையும் வைத்திருக்கிறது.
பன்றியைக் கணக்கிடுவதற்கான அடுத்த கட்டம் இயல்பாக்கம் ஆகும், வெளிச்ச மாற்றங்களுக்கு மாறுபாட்டை உறுதிசெய்ய சாய்வுகளை இயல்பாக்குகிறோம், அதாவது பிரகாசம் மற்றும் மாறுபாடு.
இந்த படத்தில், அந்தந்த திசைக்கு ஏற்ப சதுரத்தில் தீவிரத்தன்மை மதிப்புகள் காட்டப்படுகின்றன மற்றும் அனைத்திற்கும் ஒருவருக்கொருவர் 50 வித்தியாசம் உள்ளது
Δ எச் = 50, Δ வி = 50; = √50 2 +50 = 70.72, 70.72 / 100 = 0.707
அனைவருக்கும் 0.707 பெறும் சாய்வு அளவுகளால் திசையன்களைப் பிரிக்கிறோம், இது இயல்பாக்கம்.
இதேபோல், நாம் தீவிரத்தை மாற்றினால் அல்லது மாறுபாட்டை மாற்றினால் கீழேயுள்ள மதிப்புகள் கிடைக்கும்.
Δ எச் = 50, Δ வி = 50; = √50 2 +50 = 70.72, 70.72 / 100 = 0.707; Δ எச் = 100, Δ வி = 100; = √100 2 +100 = 141.42, 141.42 / 100 = 1.41
இயல்பாக்கம் ஒரு செல் மட்டத்தில் நடைபெறாது, அதற்கு பதிலாக அது ஒரு தொகுதி மட்டத்தில் நடைபெறுகிறது, எனவே இங்கே தொகுதிகள் அடிப்படையில் 4 கலங்களின் குழுவாகும், இது அண்டை தொகுதிகளை கணக்கில் எடுத்துக்கொள்கிறது, எனவே படத்தின் பெரிய பகுதிகளை கருத்தில் கொண்டு இயல்பாக்குதல்.
இப்போது குறியீட்டைப் பார்ப்போம்
NP போன்ற இறக்குமதி numpy இறக்குமதி CV2 PLT போன்ற இறக்குமதி matplotlib.pyplot # படத்தை ஏற்று பின்னர் கரும்சாயல்கள் படத்தை = cv2.imread ('elephant.jpg') சாம்பல் = cv2.cvtColor (படம், cv2.COLOR_BGR2GRAY) # காட்டு அசல் பட cv2.imshow (' உள்ளீட்டு படம் ', படம்) cv2.waitKey (0) # அளவுருக்களை வரையறுத்தல், செல் அளவு மற்றும் தொகுதி அளவு # hxw பிக்சல்களில் cell_size = (8, 8) # கலங்களில் உள்ள hxw block_size = (2, 2) # நோக்குநிலை பின்களின் எண்ணிக்கை nbins = 9 # ஓபன்சிவியின் HOG டிஸ்கிரிப்டரைப் பயன்படுத்துதல் # winSize என்பது செல் அளவு ஹாக் = cv2.HOGDescriptor (_winSize = (gray.shape // cell_size * cell_size, gray.shape // cell_size * cell_size), _blockSize = (block_size * cell_size, block_size * cell_size), _blockStride = (cell_size, cell_size), _cellSize = (cell_size, cell_size), _nbins = nbins வடிவம் hog_features ஐ உருவாக்க n_cells = (gray.shape // cell_size, gray.shape // cell_size) # நாம் முதலில் வரிசைகளால் குறியீட்டு தொகுதிகள். # hog_feats இப்போது ஒவ்வொரு திசையிலும் சாய்வு பெருக்கங்களைக் கொண்டுள்ளது, # ஒவ்வொரு குழுவிற்கும் அதன் குழுவின் ஒவ்வொரு கலத்திற்கும். அட்டவணைப்படுத்தல் என்பது வரிசைகள் மற்றும் நெடுவரிசைகள். hog_feats = hog.compute (சாம்பல்).மாற்றம் (n_cells - block_size + 1, n_cells - block_size + 1, block_size, block_size, nbins).மாற்றம் ((1, 0, 2, 3, 4)) # சாய்வு நோக்குநிலைகளை சேமிக்க nbin பரிமாணங்களுடன் எங்கள் சாய்வு வரிசையை உருவாக்கவும் சாய்வு = np.zeros ((n_cells, n_cells, nbins)) # பரிமாணங்களின் வரிசையை உருவாக்கவும் cell_count = np.full ((n_cells, n_cells, 1), 0, dtype = int) # பிளாக் இயல்பாக்க வரம்பில் off_y க்கான (block_size): வரம்பில் off_x க்கான (block_size): சாய்வு - block_size + off_y +1, off_x: n_cells - block_size + off_x +1] = \ hog_feats cell_count - block_size + off_y +1, off_x: n_cells - block_size + off_x + 1] + = 1 # சராசரி சாய்வு சாய்வு / = cell_count # மேட்லோட்லிப் # கோணத்தைப் பயன்படுத்தும் சதி HOG கள் 360 / nbins * திசை color_bins = 5 plt.pcolor (சாய்வு) plt.gca (). invert_yaxis () plt.gca (). set_aspect ('equal', adjustable = 'box') plt.colorbar () plt.show () cv2.destroyAllWindows ()
உள்ளீட்டு படம் எவ்வாறு HOG பிரதிநிதித்துவமாக குறிப்பிடப்படுகிறது என்பதை படம் காட்டுகிறது.
HAAR அடுக்கை வகைப்படுத்திகள்
முன்பு விவாதித்தபடி, ஒரு படத்திலிருந்து அம்சங்களை பிரித்தெடுக்கலாம் மற்றும் பொருட்களை வகைப்படுத்த அல்லது கண்டறிய அந்த அம்சங்களைப் பயன்படுத்தலாம்.
HAAR அடுக்கை வகைப்படுத்திகள் என்றால் என்ன? ஒரு படத்தில் உள்ள பொருட்களை அடையாளம் காண ஹார் வகை அம்சங்களை தொடர்ச்சியான வகைப்படுத்திகளில் (அடுக்கை) உள்ளிடும்
ஒரு பொருள் கண்டறிதல் முறை. ஒரு வகை பொருளை அடையாளம் காண அவர்கள் பயிற்சியளிக்கப்படுகிறார்கள், இருப்பினும், அவற்றில் பலவற்றை நாம் இணையாகப் பயன்படுத்தலாம் எ.கா. கண்களையும் முகங்களையும் ஒன்றாகக் கண்டறிதல்.
HAAR வகைப்படுத்திகள் விளக்கப்பட்டுள்ளன:
HAAR வகைப்படுத்திகள் நிறைய நேர்மறையான படங்கள் (அதாவது பொருளைக் கொண்ட படங்கள்) மற்றும்
எதிர்மறை படங்கள் (அதாவது பொருள் இல்லாத படங்கள்) ஆகியவற்றைப் பயன்படுத்தி பயிற்சி அளிக்கப்படுகின்றன.
அந்த படங்களை நாங்கள் பெற்றவுடன் , செவ்வக தொகுதிகளின் நெகிழ் சாளரங்களைப் பயன்படுத்தி அம்சங்களைப் பிரித்தெடுக்கிறோம். இந்த அம்சங்கள் (HAAR அம்சங்கள்) ஒற்றை மதிப்புடையவை மற்றும் கருப்பு செவ்வகங்களிலிருந்து வெள்ளை செவ்வகங்களின் கீழ் பிக்சல் தீவிரங்களின் தொகையைக் கழிப்பதன் மூலம் கணக்கிடப்படுகின்றன.
இருப்பினும், இது 24 x 24 பிக்சல்கள் (180,000 அம்சங்கள் உருவாக்கப்பட்டது) அடிப்படை சாளரத்திற்கு கூட, இது ஒரு அபத்தமான எண்ணிக்கையிலான கணக்கீடுகளாகும்.
எனவே ஆராய்ச்சியாளர்கள் ஒருங்கிணைந்த படங்கள் என்று ஒரு முறையை வகுத்தனர், இது நான்கு வரிசை குறிப்புகளுடன் கணக்கிடப்பட்டது. இருப்பினும், அவை இன்னும் 180,000 அம்சங்களைக் கொண்டிருந்தன , அவற்றில் பெரும்பாலானவை உண்மையான மதிப்பைச் சேர்க்கவில்லை.
உயர்த்துதல் பின்னர் ஃபிராய்ட் மற்றும் Schapire உடன் பெரும்பாலான அறிவுறுத்தும் அம்சங்கள், தீர்மானிக்க பயன்படுத்தப்படுகிறது AdaBoost மற்றும் அது படத்தில் பெரும்பாலான அறிவுறுத்தும் அம்சங்கள் காணப்படவில்லை. தவறான வகைப்பாடுகளுக்கு அதிக எடையுள்ள அபராதங்களை வழங்குவதன் மூலம், வலுவான வகைப்படுத்திகளை உருவாக்க பலவீனமான வகைப்படுத்திகளைப் பயன்படுத்துவதற்கான செயல்முறையே பூஸ்டிங். 180,000 அம்சங்களை 6000 ஆகக் குறைக்கிறது, இது இன்னும் கொஞ்சம் அம்சங்களாகும்.
அந்த 6000 அம்சங்களில், சில மற்றவர்களை விட தகவலறிந்ததாக இருக்கும். ஆகவே, பிராந்தியத்திற்கு ஒரு முகம் இருக்க முடியுமா என்பதை முதலில் சோதிக்க நாங்கள் மிகவும் தகவலறிந்த அம்சங்களைப் பயன்படுத்தினால் (தவறான நேர்மறைகள் பெரிய விஷயமல்ல). அவ்வாறு செய்வது அனைத்து 6000 அம்சங்களையும் ஒரே நேரத்தில் கணக்கிடுவதற்கான தேவையை நீக்குகிறது. இந்த கருத்து வகைப்படுத்திகளின் அடுக்கு என்று அழைக்கப்படுகிறது - முகத்தைக் கண்டறிவதற்கு, வயோலா ஜோன்ஸ் முறை 38 நிலைகளைப் பயன்படுத்தியது.
முகம் மற்றும் கண் கண்டறிதல்
ஆகவே, HAAR அடுக்கைப் பற்றி சில தத்துவார்த்த அறிவைப் பெற்ற பிறகு, நாங்கள் அதை இறுதியாக செயல்படுத்தப் போகிறோம், இதனால் விஷயங்களை மிகவும் தெளிவுபடுத்துவதற்காக நாம் பகுதிகளாக படிப்பினைகளை உடைப்போம், முதலில் நாம் முன் முகத்தைக் கண்டுபிடிப்போம், அதன் பிறகு முன் முகத்தைக் கண்டறிய நகர்த்துவோம் கண்கள் மற்றும் இறுதியாக வெப்கேம் மூலம் முகம் மற்றும் கண்களை நேரடியாக கண்டறிவோம்.
எனவே இதற்காக ஓபன்சிவி.xml கோப்புகளாக வழங்கிய முன் பயிற்சி பெற்ற வகைப்படுத்திகளைப் பயன்படுத்தப் போகிறோம், எக்ஸ்எம்எல் என்பது நீட்டிக்கக்கூடிய மார்க்அப் மொழியைக் குறிக்கிறது, இந்த மொழி பரந்த அளவிலான தரவைச் சேமிக்கப் பயன்படுகிறது, நீங்கள் அதில் ஒரு தரவுத்தளத்தை கூட உருவாக்கலாம்.
இந்த இணைப்பில் இந்த வகைப்படுத்திகளின் அணுகலை நீங்கள் பெறலாம் .
முகம் கண்டறிதல்
முன்பக்க முகத்தைக் கண்டறிவதற்கு முயற்சிப்போம், முன்பக்க முகம் கண்டுபிடிப்பாளரின் அடுக்கை அணுகலாம். எக்ஸ்எம்எல் கோப்பைப் பெற ஜிப் கோப்பை பிரித்தெடுக்கவும்.
இறக்குமதியை np இறக்குமதி cv2 # எங்கள் # வகைப்படுத்தி (எக்ஸ்எம்எல் கோப்பு வடிவம்) சேமித்து வைக்கப்பட்டுள்ள இடத்திற்கு ஓபன்சிவியின் கேஸ்கேட் கிளாசிஃபயர் செயல்பாட்டை சுட்டிக்காட்டுகிறோம் , குறியீடு மற்றும் வகைப்படுத்தியை ஒரே கோப்புறையில் வைத்திருக்க நினைவில் கொள்ளுங்கள் face_cascade = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') # ஏற்றவும் எங்கள் படம் அதை கிரேஸ்கேல் படமாக மாற்றுகிறது = cv2.imread ('Trump.jpg') சாம்பல் = cv2.cvtColor (படம், cv2.COLOR_BGR2GRAY) # எங்கள் வகைப்படுத்தி கண்டறியப்பட்ட முகத்தின் ROI ஐ ஒரு டப்பிளாக திருப்பி விடுகிறது # இது மேல் இடதுபுறத்தை சேமிக்கிறது ஒருங்கிணைப்பு மற்றும் கீழ் வலது ஒருங்கிணைப்புகள் # இது பட்டியல்களின் பட்டியலை வழங்குகிறது, அவை வெவ்வேறு முகங்களின் இருப்பிடமாகும். முகங்கள் = face_cascade.detectMultiScale (சாம்பல், 1.3, 5) # முகங்கள் எதுவும் கண்டறியப்படாதபோது, முகம்_குறிப்பான் திரும்பும் மற்றும் முகம் இருந்தால் வெற்று டப்பிள் (): அச்சிடு ("முகங்கள் எதுவும் காணப்படவில்லை") # நாங்கள் எங்கள் முகங்களின் வரிசை வழியாக மீண்டும் செய்கிறோம் மற்றும் முகங்களில் ஒவ்வொரு முகத்தின் மீதும் ஒரு செவ்வகத்தை # (x, y, w, h) முகங்களில்: cv2.rectangle (படம், (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('முகம் கண்டறிதல்', படம்) cv2.nightKey (0) cv2.destroyAllWindows ()
இப்போது முகம் மற்றும் கண் கண்டறிதலை ஒன்றாக இணைப்போம், அதே ஜிப் கோப்பில் கண் கண்டுபிடிப்பாளரின் அடுக்கை அணுகலாம்.
NP போன்ற இறக்குமதி numpy இறக்குமதி CV2 face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') படம் = cv2.imread ('Trump.jpg') சாம்பல் = cv2.cvtColor (படம், cv2.COLOR_BGR2GRAY) முகங்கள் = face_classifier.detectMultiScale (சாம்பல், 1.3, 5) # முகங்கள் எதுவும் கண்டறியப்படாதபோது, முகம்_குறிப்பான் திரும்பும் மற்றும் முகங்கள் இருந்தால் வெற்று டப்பிள் (): அச்சிடு ("முகம் இல்லை") (x, y, w, h) முகங்களில்: cv2.rectangle (img, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('img', img) roi_gray = சாம்பல் roi_color = img கண்கள் = eye_classifier.detectMultiScale (roi_gray) cv2.nightKey (0) கண்களில் (ex, ey, ew, eh): cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (255,255,0), 2) cv2.imshow ('img', img) cv2.waitKey (0) cv2.destroyAllWindows () cv2.waitKey (0)
எனவே இந்த குறியீடு முகத்தைக் கண்டறிவதற்கான குறியீட்டைப் போன்றது, ஆனால் இங்கே அவற்றைக் கண்டறிவதற்கான கண் அடுக்குகளையும் முறையையும் சேர்த்துள்ளோம், ஏனெனில் முகத்தின் சாம்பல் அளவிடப்பட்ட பதிப்பை கண்டறிதல் மல்டிஸ்கேலுக்கான அளவுருவாக நாங்கள் தேர்ந்தெடுத்துள்ளதை நீங்கள் காணலாம். கண்கள், கணக்கீட்டைக் குறைப்பதற்கு நம்மைக் கொண்டுவருகின்றன, ஏனெனில் நாங்கள் அந்த பகுதியில் மட்டுமே கண்களைக் கண்டறியப் போகிறோம்.
நேரடி முகம் மற்றும் கண் கண்டறிதல்
எனவே இப்போது வரை நாங்கள் முகம் மற்றும் கண் கண்டறிதலைச் செய்துள்ளோம், இப்போது வெப்கேமிலிருந்து நேரடி வீடியோ ஸ்ட்ரீமுடன் இதைச் செயல்படுத்தலாம். இதில் முகம் மற்றும் கண்களைக் கண்டறிவதை நாங்கள் செய்வோம், ஆனால் இந்த நேரத்தில் லைவ் ஸ்ட்ரீம் வெப்கேமை உருவாக்குவோம். பெரும்பாலான பயன்பாட்டில், உங்கள் முகத்தைச் சுற்றியுள்ள பெட்டியுடன் சிறப்பித்திருப்பதைக் காணலாம், ஆனால் இங்கே நாங்கள் வித்தியாசமாக ஏதாவது செய்துள்ளோம், உங்கள் முகம் வெட்டப்பட்டிருப்பதைக் காணலாம், கண்கள் அதில் மட்டுமே அடையாளம் காணும்.
எனவே இங்கே நாம் முகம் மற்றும் கண் வகைப்படுத்தி இரண்டையும் இறக்குமதி செய்கிறோம், மேலும் முகம் மற்றும் கண் கண்டறிதலுக்கான அனைத்து செயலாக்கங்களையும் செய்வதற்கான ஒரு செயல்பாட்டை வரையறுத்துள்ளோம். அதன்பிறகு வெப்கேம் ஸ்ட்ரீமைத் தொடங்கி, முகம் மற்றும் கண்கள் கண்டறியப்படுவதற்கு ஃபேஸ் டிடெக்டர் செயல்பாட்டை அழைத்தார். ஃபேஸ் டிடெக்டர் செயல்பாட்டின் உள்ளே நாம் வரையறுக்கும் அளவுரு நேரடி வலை கேம் ஸ்ட்ரீமின் தொடர்ச்சியான படங்கள்
cv2 இறக்குமதி எண்ணை np face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') def face_detector (img, size = 0.5): # சாம்பல் நிறத்தை மாற்றவும் (படம், cv2.COLOR_BGR2GRAY) எதிர்கொள்கிறது = face_classifier.detectMultiScale (சாம்பல், 1.3, 5) முகங்கள் () இருந்தால் உறுதியானதாக இருக்கும்: திரும்ப படம் முகங்கள் (x, y W, ஏ) க்கான: எக்ஸ் = எக்ஸ் - 50 W = டபிள்யு + 50 y = y - 50 h = h + 50 cv2.rectangle (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = சாம்பல் roi_color = img eyes = கண்களில் ( முன்னாள், கண், ஈவ், இ) கண்_ கிளாசிஃபயர்.டெடெக்ட் மல்டிஸ்கேல் (ரோய்_கிரே) : cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (0,0,255), 2) roi_color = cv2.flip (roi_color, 1) return roi_color cap = cv2. வீடியோ கேப்சர் (0) : உண்மை போது RET, பிரேம் = cap.read () cv2.imshow ('எமது வதனத்தின் கரைத்து', face_detector (பிரேம்)) என்றால் cv2.waitKey (1) == 13: # 13 விசையை உள்ளிடவும் உள்ளது இடைவெளி cap.release () cv2.destroyAllWindows ()
ட்யூனிங் கேஸ்கேட் வகைப்படுத்திகள்
உள்ளீட்டுப் படத்தைத் தவிர வேறு கண்டறிதல் மல்டிஸ்கேலுக்குள் வரையறுக்கப்பட்ட அளவுருக்கள் பின்வரும் முக்கியத்துவத்தைக் கொண்டுள்ளன
எங்கள் கிளாசிஃபயர். detMultiScale (உள்ளீட்டு படம், அளவிலான காரணி, குறைந்தபட்ச அயலவர்கள்)
- அளவீட்டு காரணி ஒவ்வொரு முறையும் நாம் அளவிடும்போது பட அளவை எவ்வளவு குறைக்கிறோம் என்பதைக் குறிப்பிடுகிறது. முகம் கண்டறிதலில் எ.கா. நாம் பொதுவாக 1.3 ஐப் பயன்படுத்துகிறோம். இதன் பொருள் ஒவ்வொரு முறையும் அளவிடப்படும்போது 30% குறைக்கிறோம். 1.05 போன்ற சிறிய மதிப்புகள் கணக்கிட அதிக நேரம் எடுக்கும், ஆனால் கண்டறியும் வீதத்தை அதிகரிக்கும்.
- குறைந்தபட்ச அக்கம்பக்கத்தினர் ஒவ்வொரு நேர்மறையான சாளரத்தையும் நேர்மறையான கண்டறிதலாகக் கருத வேண்டும். பொதுவாக 3-6 க்கு இடையில் அமைக்கப்படும். இது உணர்திறன் அமைப்பாக செயல்படுகிறது, குறைந்த மதிப்புகள் சில நேரங்களில் ஒற்றை முகத்தின் மீது பல மடங்கு முகங்களைக் கண்டறியும். உயர் மதிப்புகள் குறைவான தவறான நேர்மறைகளை உறுதி செய்யும், ஆனால் நீங்கள் சில முகங்களை இழக்க நேரிடும்.
வீடியோக்களில் கார் மற்றும் பாதசாரி கண்டறிதல்
இப்போது HAAR அடுக்கைப் பயன்படுத்தி வீடியோக்களில் பாதசாரிகள் மற்றும் கார்களைக் கண்டுபிடிப்போம், ஆனால் எந்தவொரு வீடியோவும் ஏற்றப்படுவதில்லை மற்றும் பிழையில்லாமல் குறியீடு தொகுக்கிறது நீங்கள் பின்வரும் படிகளைப் பின்பற்ற வேண்டும்:
குறியீட்டை இயக்கிய பின் எந்த வீடியோவும் ஏற்றப்படாவிட்டால், உங்கள் மலைப்பாம்பு நிறுவப்பட்ட இடத்தில் ஒட்டுவதற்கு எங்கள் opencv_ffmpeg.dl ஐ : copycv \ source \ 3rdparty \ ffmpeg இலிருந்து நகலெடுக்க வேண்டும். எ.கா. C: \ Anaconda2
இது நகலெடுக்கப்பட்டதும், நீங்கள் பயன்படுத்தும் OpenCV இன் பதிப்பின் படி கோப்பை மறுபெயரிட வேண்டும். நீங்கள் OpenCV 2.4.13 ஐப் பயன்படுத்துகிறீர்கள் என்றால், கோப்பின் பெயரை மறுபெயரிடுக: opencv_ffmpeg2413_64.dll அல்லது opencv_ffmpeg2413.dll (நீங்கள் இருந்தால் ஒரு X86 இயந்திரத்தைப் பயன்படுத்துதல்) opencv_ffmpeg310_64.dll அல்லது opencv_ffmpeg310.dll (நீங்கள் ஒரு X86 இயந்திரத்தைப் பயன்படுத்துகிறீர்கள் என்றால்)
செய்ய நீங்கள் python.exe எங்கே நிறுவப்படும் கண்டுபிடிக்க, வெறும் குறியீடு இந்த இரண்டு வரிகளை ரன், அது எங்கே மலைப்பாம்பு நிறுவப்படும் இடம் அச்சிட வேண்டும்.
இறக்குமதி sys அச்சு (sys.executable)
இப்போது நீங்கள் இந்த படிகளை வெற்றிகரமாக செய்திருந்தால், பாதசாரிகளைக் கண்டறிவதற்கான குறியீட்டிற்கு செல்லலாம் , நீங்கள் பாதசாரிகளைக் கண்டறிவதற்கான அடுக்கை வைத்திருக்கலாம் மற்றும் இங்கே இணைக்கப்பட்டுள்ள ஜிப் கோப்பிலிருந்து.
cv2 import numpy ஐ np ஆக இறக்குமதி செய்யுங்கள் # எங்கள் உடல் வகைப்படுத்தியை உருவாக்கவும் body_classifier = cv2.CascadeClassifier ('haarcascade_fullbody.xml') # வீடியோ கோப்பிற்கான வீடியோ பிடிப்பைத் தொடங்கவும் , இங்கே பாதசாரிகள் கண்டறியப்படும் வீடியோ கோப்பைப் பயன்படுத்துகிறோம் cap = cv2.VideoCapture ('walking.avi') # வீடியோவை லூப் வெற்றிகரமாக ஏற்றப்பட்டதும் cap.isOpened () போது: # வீடியோவின் ஒவ்வொரு சட்ட படித்தல் RET, பிரேம் = cap.read () # இங்கே நாம் சட்ட பெரிதாக்க உள்ளன, அதன் அளவு பாதியை, பெரிய படங்களில் சறுக்குவதற்கு நிறைய சாளரங்கள் இருப்பதால் , வகைப்படுத்தலை விரைவுபடுத்த நாங்கள் செய்கிறோம் , எனவே ஒட்டுமொத்தமாக தீர்மானத்தை குறைக்கிறோம் # வீடியோவை பாதியாகக் குறிக்கிறது 0.5 இது குறிக்கிறது, மேலும் விரைவான இடைக்கணிப்பு முறையையும் பயன்படுத்துகிறோம், இது # இன்டர்லீனியர் ஃபிரேம் = சி.வி 2.ரேசைஸ் (பிரேம், எதுவுமில்லை, எஃப்எக்ஸ் = 0.5, ஃபை = 0.5, இன்டர்போலேஷன் = சி.வி 2.இன்டர்_லைனியர்) சாம்பல் = சி.வி 2. cvtColor (frame, cv2.COLOR_BGR2GRAY) # எங்கள் உடல் வகைப்படுத்தி உடல்களுக்கு சட்டகத்தை அனுப்பவும் = body_classifier.detectMultiScale (சாம்பல், 1.2, 3) # உடல்களில் (x, y, w, h) அடையாளம் காணப்பட்ட எந்தவொரு உடலுக்கும் எல்லை பெட்டிகளை பிரித்தெடுக்கவும் : cv2. செவ்வகம் (சட்டகம், (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('பாதசாரிகள்', சட்டகம்) என்றால் cv2.waitKey (1) == 13: # 13 என்பது Enter Key break cap.release () cv2.destroyAllWindows ()
வீடியோவில் பாதசாரிகளை வெற்றிகரமாக கண்டறிந்த பிறகு, கார் கண்டறிதலுக்கான குறியீட்டிற்கு செல்லலாம், இங்கிருந்து பாதசாரிகளைக் கண்டறிவதற்கான அடுக்கை நீங்கள் வைத்திருக்கலாம்.
இறக்குமதி CV2 இறக்குமதி நேரம் NP போன்ற இறக்குமதி numpy எங்கள் உடல் வகைப்படுத்தி உருவாக்கவும் # car_classifier = cv2.CascadeClassifier ('haarcascade_car.xml') # வீடியோ கோப்பின் வீடியோ பிடிப்பு துவங்கு தொப்பி = cv2.VideoCapture ('cars.avi') # வீடியோவை லூப் வெற்றிகரமாக வந்தவுடன் ஏற்றப்படும் போது cap.isOpened (): time.sleep (.05) # படிக்க முதல் சட்ட RET, பிரேம் = cap.read () சாம்பல் = cv2.cvtColor (தர்க்க, cv2.COLOR_BGR2GRAY) எங்கள் கார் வகைப்படுத்தி அடைய # பாஸ் சட்ட கார்கள் = car_classifier.detectMultiScale (சாம்பல், 1.4, 2) # கார்களில் (x, y, w, h) அடையாளம் காணப்பட்ட எந்தவொரு உடல்களுக்கும் எல்லை பெட்டிகளை பிரித்தெடுக்கவும் : cv2.rectangle (frame, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('கார்கள்', பிரேம்) cv2.waitKey (1) == 13 என்றால்: # 13 விசையை உள்ளிடவும் உள்ளது இடைவெளி cap.release () cv2.destroyAllWindows ()
நாங்கள் நேரத்தைச் சேர்த்துள்ளதை நீங்கள் கவனித்திருக்கிறீர்கள் (தூக்கம் (.05) , இது பிரேம் வீதத்தின் தாமதம், எனவே எல்லா கார்களும் சரியாக அடையாளம் காணப்பட்டுள்ளன என்பதை உறுதிப்படுத்த முடியும், அல்லது அதற்கு ஒரு கருத்து லேபிளைச் சேர்ப்பதன் மூலம் அதை எளிதாக அகற்றலாம்.
இந்த கட்டுரை பைத்தானில் உள்ள மாஸ்டர் கம்ப்யூட்டர் விஷன் ™ ஓபன்சிவி 4 இலிருந்து ராஜீவ் ரத்தன் உருவாக்கிய உடெமி பற்றிய ஆழமான கற்றல் பாடத்துடன் குறிப்பிடப்பட்டுள்ளது, கணினி பார்வை மற்றும் பைதான் பற்றி மேலும் அறிய அதை குழுசேரவும்.