ఓపెన్‌సివిని ఉపయోగించి రియల్ లైఫ్ ఆబ్జెక్ట్ డిటెక్షన్ - లైవ్ వీడియోలోని వస్తువులను గుర్తించడం

మేము విండోస్‌లో పైథాన్ ఓపెన్‌సివిని ఇన్‌స్టాల్ చేయడంతో ప్రారంభించాము మరియు ఇప్పటివరకు పైథాన్ ఉపయోగించి కొన్ని ప్రాథమిక ఇమేజ్ ప్రాసెసింగ్, ఇమేజ్ సెగ్మెంటేషన్ మరియు ఆబ్జెక్ట్ డిటెక్షన్ చేసాము, ఇవి ఈ క్రింది ట్యుటోరియల్‌లలో ఉన్నాయి:

• పైథాన్ ఓపెన్‌సివితో ప్రారంభించడం: ఇన్‌స్టాలేషన్ మరియు బేసిక్ ఇమేజ్ ప్రాసెసింగ్
• పైథాన్ ఓపెన్‌సివి (పార్ట్ 1) లో చిత్ర మానిప్యులేషన్స్
• ఓపెన్‌సివి (పార్ట్ -2) లో చిత్ర మానిప్యులేషన్స్
• OpenCV ని ఉపయోగించి చిత్ర విభజన - చిత్రం యొక్క నిర్దిష్ట ప్రాంతాలను సంగ్రహిస్తుంది

ఆబ్జెక్ట్ డిటెక్షన్ కోసం వివిధ పద్ధతులు మరియు అల్గోరిథంల గురించి కూడా మేము తెలుసుకున్నాము, ఇక్కడ ప్రతి వస్తువుకు కొన్ని అల్గోరిథంలను ఉపయోగించి కొన్ని ముఖ్య అంశాలు గుర్తించబడతాయి. ఈ ట్యుటోరియల్‌లో మేము నిజ జీవిత వస్తువులను గుర్తించడానికి ఆ అల్గారిథమ్‌లను ఉపయోగించబోతున్నాము, ఇక్కడ మేము గుర్తించడానికి SIFT మరియు ORB ని ఉపయోగిస్తాము.

SIFT ఉపయోగించి ఆబ్జెక్ట్ డిటెక్షన్

ఇక్కడ ఆబ్జెక్ట్ డిటెక్షన్ లైవ్ వెబ్‌క్యామ్ స్ట్రీమ్‌ను ఉపయోగించి చేయబడుతుంది, కనుక ఇది ఆబ్జెక్ట్‌ను గుర్తించినట్లయితే అది కనుగొన్న ఆబ్జెక్ట్‌ను పేర్కొంటుంది. కోడ్‌లో ప్రధాన భాగం SIFT డిటెక్టర్ అని పిలువబడే ఫంక్షన్ ద్వారా ఆడబడుతుంది, చాలా ప్రాసెసింగ్ ఈ ఫంక్షన్ ద్వారా జరుగుతుంది.

మరియు కోడ్ యొక్క మిగిలిన భాగంలో, మేము వెబ్‌క్యామ్ స్ట్రీమ్‌ను తెరవడం ప్రారంభిస్తాము, ఆపై ఇమేజ్ టెంప్లేట్‌ను లోడ్ చేయండి, అనగా రిఫరెన్స్ ఇమేజ్, అంటే ప్రోగ్రామ్ వాస్తవానికి వెబ్‌క్యామ్ స్ట్రీమ్ ద్వారా చూస్తోంది.

తరువాత, మేము నిరంతరం అనంతం సహాయంతో వెబ్క్యామ్ స్ట్రీమ్ నుండి చిత్రాలు బంధించే ఉంటాయి అయితే లూప్, ఆపై వెబ్క్యామ్ ఫ్రేమ్ యొక్క సంబంధిత ఎత్తు మరియు వెడల్పు సంగ్రాహకం, ఆపై తరువాత వడ్డీ (ROI) బాక్స్ ప్రాంతానికి పారామితులు నిర్వచించటానికి దీనిలో వెబ్‌క్యామ్ ఫ్రేమ్ యొక్క సంబంధిత ఎత్తు మరియు వెడల్పు తీసుకోవడం ద్వారా మా వస్తువు సరిపోతుంది. ఆపై మేము పైన నిర్వచించిన ROI పారామితుల నుండి దీర్ఘచతురస్రాన్ని గీస్తాము. చివరకు దీర్ఘచతురస్రాన్ని కత్తిరించండి మరియు కోడ్ యొక్క SWIFT డిటెక్టర్ భాగంలో తినిపించండి.

ఇప్పుడు SIFT డిటెక్టర్ ప్రాథమికంగా రెండు ఇన్‌పుట్‌లను కలిగి ఉంది, ఒకటి కత్తిరించిన చిత్రం మరియు మరొకటి మనం ఇంతకుముందు నిర్వచించిన ఇమేజ్ టెంప్లేట్ మరియు అది మాకు కొన్ని మ్యాచ్‌లను ఇస్తుంది, కాబట్టి మ్యాచ్‌లు ప్రాథమికంగా కత్తిరించిన చిత్రంలో సమానమైన వస్తువులు లేదా కీ పాయింట్ల సంఖ్య మరియు లక్ష్య చిత్రం. అప్పుడు మేము మ్యాచ్‌ల కోసం థ్రెషోల్డ్ విలువను నిర్వచిస్తాము, మ్యాచ్‌ల విలువ థ్రెషోల్డ్ కంటే ఎక్కువగా ఉంటే, ROI దీర్ఘచతురస్రం యొక్క ఆకుపచ్చ రంగుతో మన స్క్రీన్‌పై కనిపించే చిత్రాన్ని ఉంచుతాము.

ఇప్పుడు కోడ్ యొక్క ప్రధాన భాగానికి తిరిగి వెళ్దాం, దీనిని SIFT డిటెక్టర్ అని పిలుస్తారు, ఇది ఇన్పుట్ను రెండు చిత్రాలుగా తీసుకుంటుంది ఒకటి అది వస్తువు కోసం వెతుకుతున్న చిత్రం మరియు మరొకటి మనం సరిపోల్చడానికి ప్రయత్నిస్తున్న వస్తువు (చిత్ర టెంప్లేట్) కు. అప్పుడు బూడిద మొదటి చిత్రాన్ని స్కేల్ చేయండి మరియు ఇమేజ్ టెంప్లేట్‌ను రెండవ చిత్రంగా నిర్వచించండి. అప్పుడు మేము ఒక SIFT డిటెక్టర్ ఆబ్జెక్ట్‌ను సృష్టించి, ఓపెన్‌సివి SIFT డిటెక్షన్ మరియు కంప్యూట్ ఫంక్షన్‌ను నడుపుతాము, తద్వారా కీ పాయింట్లను గుర్తించి, డిస్క్రిప్టర్లను లెక్కించడానికి, డిస్క్రిప్టర్లు ప్రాథమికంగా కీ పాయింట్ల గురించి సమాచారాన్ని నిల్వ చేసే వెక్టర్స్, మరియు మేము మ్యాచింగ్ చేస్తున్నప్పుడు ఇది చాలా ముఖ్యమైనది చిత్రాల వివరణల మధ్య.

ఆపై FLANN ఆధారిత మ్యాచర్‌ను నిర్వచించండి, మేము దాని వెనుక సరిపోలిక యొక్క గణిత సిద్ధాంతంలోకి వెళ్ళడం లేదు, కానీ మీరు దాని గురించి సులభంగా గూగుల్ చేయవచ్చు. మొదట, ఇండెక్స్ kdtree ని సున్నాకి నిర్వచించండి, ఆపై మేము డిక్షనరీ ఫార్మాట్‌లో ఇండెక్స్ మరియు సెర్చ్ పారామితులను సెట్ చేస్తాము, మనం ఉపయోగించబోయే అల్గోరిథంను KDTREE అని నిర్వచించాము మరియు మనం ఉపయోగించబోయే చెట్ల సంఖ్య, ఎక్కువ చెట్టు మేము మరింత క్లిష్టంగా మరియు నెమ్మదిగా ఉపయోగిస్తాము. మరియు శోధన పరామితిలో చెక్కుల సంఖ్యను నిర్వచించండి, ఇది ప్రాథమికంగా అది పూర్తి చేయబోయే మ్యాచ్‌ల సంఖ్య.

ఇండెక్స్ పారామితులు మరియు శోధన పారామితులు అని మేము ఇంతకుముందు నిర్వచించిన పరామితిని లోడ్ చేయడం ద్వారా మా FLANN ఆధారిత మ్యాచర్ ఆబ్జెక్ట్‌ని సృష్టించండి మరియు దీని ఆధారంగా మా FLANN ఆధారిత మ్యాచర్‌ను సృష్టించండి, ఇది KNN మ్యాచర్, ఇక్కడ KNN K- సమీప పొరుగువారు, ప్రాథమికంగా ఇది ఒక మార్గం మేము సమీప మ్యాచర్‌లు మరియు డిస్క్రిప్టర్‌ల కోసం చూస్తాము మరియు ప్రారంభ స్థిరాంకం k తో మ్యాచింగ్ చేస్తాము. ఇప్పుడు ఈ FLANN ఆధారిత మ్యాచర్ మనకు లభించే మ్యాచ్‌ల సంఖ్యను తిరిగి ఇస్తుంది.

FLANN ఆధారిత మ్యాచింగ్ కేవలం ఒక ఉజ్జాయింపు, తద్వారా FLANN ఆధారిత మ్యాచర్ యొక్క ఖచ్చితత్వాన్ని పెంచడానికి మేము లోవే యొక్క నిష్పత్తి పరీక్షను నిర్వహిస్తాము మరియు అది ఏమిటంటే అది knn ఫ్లాన్ బేస్డ్ మ్యాచర్ నుండి మ్యాచ్‌ల కోసం చూస్తుంది మరియు ఇక్కడ దూరం ఉన్న కొన్ని మెట్రిక్ పారామితులను నిర్వచిస్తుంది.

ఇప్పుడు పై వివరణ కోసం కోడ్ చూద్దాం:

cv2 దిగుమతి సంఖ్యను np def sift_detector (new_image, image_template) గా దిగుమతి చేయండి : # ఇన్పుట్ చిత్రాన్ని టెంప్లేట్‌తో పోల్చిన ఫంక్షన్ # ఇది వాటి మధ్య SIFT సరిపోలికల సంఖ్యను తిరిగి ఇస్తుంది image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) image2 = image_template # Create SIFT డిటెక్టర్ ఆబ్జెక్ట్ #sift = cv2.SIFT () sift = cv2.xfeatures2d.SIFT_create () # SIFT కీ పాయింట్స్_1, డిస్క్రిప్టర్స్_1 = sift.detectAndCompute (ఇమేజ్ 1, ఏదీ లేదు) కీ పాయింట్స్_2 ఏదీ లేదు) # మా ఫ్లాన్ మ్యాచర్ కోసం పారామితులను నిర్వచించండి FLANN_INDEX_KDTREE = 0 index_params = dict (అల్గోరిథం = FLANN_INDEX_KDTREE, చెట్లు = 3) search_params = dict (తనిఖీలు = 100) # ఫ్లాన్ మ్యాచర్ ఆబ్జెక్ట్‌ను సృష్టించండి flann = cv2.FlannBasedMatcher (index_params, search_params) # K- సమీప పొరుగు పద్ధతిని ఉపయోగించి మ్యాచ్‌లను పొందండి # ఫలితం 'మ్యాచ్‌లు' రెండు చిత్రాల మ్యాచ్‌లలో కనిపించే సారూప్య మ్యాచ్‌ల సంఖ్య = flann.knnMatch (descriptors_1, descriptors_2, k = 2) # స్టోర్ లొవె యొక్క నిష్పత్తి పరీక్ష ఉపయోగించి మంచి మ్యాచ్ good_matches = m, అది 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 (ఫ్రేమ్, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # పైన కత్తిరించిన పంట విండో = కత్తిరించిన = ఫ్రేమ్ # ఫ్లిప్ ఫ్రేమ్ ధోరణిని అడ్డంగా ఫ్రేమ్ = cv2.flip (ఫ్రేమ్, 1) # SIFT సరిపోలికల సంఖ్యను పొందండి సరిపోలికలు = కత్తిరించబడినవి image_template) # ప్రస్తుత సంఖ్యను చూపించే స్థితి స్ట్రింగ్‌ను ప్రదర్శించు. మ్యాచ్‌ల యొక్క cv2.putText (ఫ్రేమ్, స్ట్రింగ్ (మ్యాచ్‌లు), (450,450), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 1) # ఆబ్జెక్ట్ డిసిసిటాన్‌ను సూచించడానికి మా ప్రవేశం # SIFT డిటెక్టర్ చిన్న తప్పుడు పాజిట్‌లను తిరిగి ఇస్తుంది కాబట్టి థ్రెషోల్డ్ = 10 # మ్యాచ్‌లు మా ప్రవేశానికి మించి ఉంటే మ్యాచ్‌లు> థ్రెషోల్డ్: 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 ('SIFT ఉపయోగించి ఆబ్జెక్ట్ డిటెక్టర్', ఫ్రేమ్) ఉంటే cv2.nightKey (1) == 13: # 13 ఎంటర్ కీ బ్రేక్ క్యాప్. విడుదల () cv2.destroyAllWindows ()

ORB ఉపయోగించి ఆబ్జెక్ట్ డిటెక్షన్

SIFT ని ఉపయోగించి ఆబ్జెక్ట్ డిటెక్షన్ చాలా బాగుంది మరియు ఖచ్చితమైనది, ఎందుకంటే ఇది కీ పాయింట్ల ఆధారంగా చాలా ఖచ్చితమైన మ్యాచ్‌లను ఉత్పత్తి చేస్తుంది, అయితే దాని పేటెంట్ మరియు వాణిజ్య అనువర్తనాల కోసం దీన్ని ఉపయోగించడం కష్టతరం చేస్తుంది, దీనికి ఇతర మార్గం ORB అల్గోరిథం వస్తువు గుర్తింపు కోసం.

SIFT చేత ఆబ్జెక్ట్ డిటెక్షన్ పద్ధతి మాదిరిగానే, దీనిలో మేము ప్రోగ్రామ్‌ను రెండు భాగాలుగా విభజించాము, అదే ఇక్కడ అనుసరించబడుతుంది.

మొదట, మేము రెండు ఇన్పుట్లను తీసుకునే ORB_detector ఫంక్షన్‌ను నిర్వచిస్తాము, ఒకటి వెబ్‌క్యామ్ నుండి వచ్చే లైవ్ స్ట్రీమ్ ఇమేజ్ మరియు మరొకటి ఇమేజ్ టెంప్లేట్, దీని ఆధారంగా మనం మా ఇమేజ్‌కి సరిపోలబోతున్నాం. అప్పుడు మేము మా వెబ్‌క్యామ్ ఇమేజ్‌ని గ్రేస్కేల్ చేసి, ఆపై మా ORB డిటెక్టర్‌ను ప్రారంభిస్తాము, మరియు మేము దానిని ఇక్కడ 1000 కీ పాయింట్ల వద్ద మరియు 1.2 యొక్క స్కేలింగ్ పారామితుల వద్ద సెట్ చేస్తున్నాము. మీరు ఈ పారామితులతో సులభంగా ఆడుకోవచ్చు, ఆపై చిత్రాల కోసం కీ పాయింట్స్ (కెపి) మరియు డిస్క్రిప్టర్స్ (డెస్) ను గుర్తించండి మరియు మేము గుర్తించడంలో రెండవ పరామితిని గుర్తించాము మరియు కంప్యూట్ ఫంక్షన్ ఏదీ లేదు, ఇది ఇమేజ్ మాస్క్ వాడకాన్ని అడుగుతోంది లేదా కాదు మరియు మేము దానిని ఇక్కడ తిరస్కరించాము.

ఇంతకుముందు మేము FLANN ఆధారిత మ్యాచర్‌ని ఉపయోగిస్తున్న డిటెక్టర్‌కి వెళ్ళండి, కాని ఇక్కడ మనం BFMatcher ని ఉపయోగిస్తాము మరియు BFMatcher లోపల మేము రెండు పారామితులను నిర్వచించాము ఒకటి NORM_HAMMING మరియు మరొకటి క్రాస్ చెక్ దీని విలువ TRUE.

పైన నిర్వచించిన డిస్క్రిప్టర్లను ఉపయోగించి ఆ రెండు చిత్రాల మధ్య మ్యాచ్‌లను సరిపోల్చండి, ఈ మ్యాచ్‌లు ఉజ్జాయింపు కానందున అన్ని మ్యాచ్‌ల సంఖ్యను తిరిగి ఇస్తుంది మరియు అందువల్ల లోవే యొక్క నిష్పత్తి పరీక్ష చేయవలసిన అవసరం లేదు, బదులుగా మేము దూరాన్ని బట్టి మ్యాచ్‌లను క్రమబద్ధీకరిస్తాము, కనీసం మ్యాచ్ ఎక్కువ దూరం మంచిది (ఇక్కడ దూరం అంటే పాయింట్ల మధ్య దూరం), మరియు చివరికి మేము పొడవు ఫంక్షన్ ఉపయోగించి మ్యాచ్‌ల సంఖ్యను తిరిగి ఇస్తాము.

మరియు ప్రధాన ఫంక్షన్లో మేము ప్రవేశాన్ని చాలా ఎక్కువ విలువకు సెట్ చేస్తాము , ఎందుకంటే ఆర్బ్ డిటెక్టర్ చాలా శబ్దాన్ని ఉత్పత్తి చేస్తుంది.

ఇప్పుడు ORB ఆధారిత గుర్తింపు కోసం కోడ్‌ను చూద్దాం

దిగుమతి cv2 NP దిగుమతి NumPy డెఫ్ ORB_detector (new_image, image_template): టెంప్లేట్ ఇన్పుట్ చిత్రం పోల్చి # ఫంక్షన్ # ఇది అప్పుడు ORB సంఖ్య తిరిగి వాటి మధ్య మ్యాచ్లు image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) తో ORB డిటెక్టర్ # సృష్టించు 1.2 orb = cv2.ORB_create (1000, 1.2) యొక్క స్కేలింగ్ పిరమిడ్ కారకంతో 1000 కీ పాయింట్లు # అసలు చిత్రం యొక్క కీ పాయింట్లను గుర్తించండి (kp1, des1) = orb.detectAndCompute (image1, none) # తిప్పబడిన చిత్రం యొక్క కీ పాయింట్లను కనుగొనండి (kp2, des2) = orb.detectAndCompute (image_template, none) # మ్యాచర్‌ని సృష్టించండి # గమనిక మేము ఇకపై ఫ్లాన్‌బేస్డ్ మ్యాచింగ్‌ను ఉపయోగించము bf = cv2.BFMatcher (cv2.NORM_HAMMING, crossCheck = True) # సరిపోలే మ్యాచ్‌లు చేయండి = bf.match (des1, des2) # దూరాన్ని బట్టి మ్యాచ్‌లను క్రమబద్ధీకరించండి. తక్కువ దూరం # మంచి మ్యాచ్‌లు = క్రమబద్ధీకరించబడింది (మ్యాచ్‌లు, కీ = లాంబ్డా వాల్: వాల్.డిస్టెన్స్) రిటర్న్ లెన్ (మ్యాచ్‌లు) క్యాప్ = సివి 2.వీడియోకాప్చర్ (0) # మా ఇమేజ్ టెంప్లేట్‌ను లోడ్ చేయండి, ఇది మా రిఫరెన్స్ ఇమేజ్ ఇమేజ్_టెంప్లేట్ = సివి 2.ఇమ్రేడ్ ('phone.jpg', 0) # image_template = cv2.imread ('images / kitkat.jpg', 0) అయితే ట్రూ: # వెబ్‌క్యామ్ చిత్రాలను పొందండి ret, 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), (దిగువ_రైట్_ఎక్స్, దిగువ_రైట్_వై), 255, 3) # క్రాప్ చేసిన పైన మేము పరిశీలించిన పంట విండో = ఫ్రేమ్ # ఫ్రేమ్ విన్యాసాన్ని అడ్డంగా ఫ్రేమ్ = cv2.flip (ఫ్రేమ్, 1) # ORB సరిపోలికల సంఖ్యను పొందండి = ORB_detector (కత్తిరించబడింది, image_template) # ప్రస్తుత సంఖ్యను చూపించే స్థితి స్ట్రింగ్‌ను ప్రదర్శించు. of match_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) ప్రవణత వెక్టర్లను ఉత్పత్తి చేస్తుంది, తరువాత వాటిని హిస్టోగ్రామ్‌గా సూచిస్తారు. కాబట్టి ప్రతి ప్రవణత వెక్టర్‌ను సూచించే హిస్టోగ్రామ్‌ను imagine హించుకోండి. కాబట్టి అన్ని పాయింట్లు లేదా తీవ్రతలు ఒక దిశలో అబద్దం చెబితే, ఆ దిశకు హిస్టోగ్రాం 45 డిగ్రీలు అని చెప్పండి, హిస్టోగ్రాం 45 డిగ్రీల వద్ద గరిష్టంగా ఉంటుంది.

కాబట్టి ఇప్పుడు మనం చేసేది ఏమిటంటే, ప్రతి కణాన్ని కోణీయ డబ్బాలుగా విభజిస్తాము, ఇక్కడ ప్రతి బిన్ ప్రవణత దిశకు (ఉదా. X, y) అనుగుణంగా ఉంటుంది. దలాల్ మరియు ట్రిగ్స్ కాగితంలో, వారు 9 బిన్స్ 0-180 ° (20 ° ప్రతి బిన్) ను ఉపయోగించారు. ఇది 64 వెక్టర్లను కేవలం 9 విలువలకు సమర్థవంతంగా తగ్గిస్తుంది. కాబట్టి మేము చేసినది పరిమాణాన్ని తగ్గించింది, కానీ అవసరమైన అన్ని కీలక సమాచారాన్ని ఉంచుతుంది.

హాగ్‌ను లెక్కించడంలో తదుపరి దశ సాధారణీకరణ, ప్రకాశం మార్పులకు అనగా ప్రకాశం మరియు కాంట్రాస్ట్‌కు మార్పు లేకుండా ఉండేలా మేము ప్రవణతలను సాధారణీకరిస్తాము.

ఈ చిత్రంలో, తీవ్రత విలువలు సంబంధిత దిశకు అనుగుణంగా చదరపులో చూపబడతాయి మరియు అన్నింటికీ ఒకదానికొకటి 50 తేడా ఉంటుంది

Δ _H = 50, Δ _v = 50; = √50 ² +50 = 70.72, 70.72 / 100 = 0.707

అందరికీ 0.707 లభించే ప్రవణత ద్వారా వెక్టర్లను విభజిస్తాము, ఇది సాధారణీకరణ.

అదేవిధంగా, మేము తీవ్రతను మార్చినా లేదా కాంట్రాస్ట్‌ను మార్చినా ఈ క్రింది విలువలను పొందుతాము.

Δ _H = 50, Δ _v = 50; = √50 ² +50 = 70.72, 70.72 / 100 = 0.707; Δ _H = 100, Δ _v = 100; = √100 ² +100 = 141.42, 141.42 / 100 = 1.41

సాధారణీకరణ సెల్ స్థాయిలో జరగదు, బదులుగా ఇది బ్లాక్ స్థాయిలో జరుగుతుంది, కాబట్టి ఇక్కడ బ్లాక్స్ ప్రాథమికంగా 4 కణాల సమూహం, ఇది పొరుగు బ్లాకులను పరిగణనలోకి తీసుకుంటుంది కాబట్టి చిత్రం యొక్క పెద్ద విభాగాలను పరిగణనలోకి తీసుకునేటప్పుడు సాధారణీకరించండి.

ఇప్పుడు కోడ్ చూద్దాం

దిగుమతి సంఖ్యను np దిగుమతి cv2 దిగుమతి matplotlib.pyplot గా plt # చిత్రాన్ని లోడ్ చేయండి అప్పుడు గ్రేస్కేల్ చిత్రం = cv2.imread ('elephant.jpg') బూడిద = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY) # అసలు చిత్రాన్ని చూపించు cv2.imshow (' ఇన్పుట్ ఇమేజ్ ', ఇమేజ్) cv2.nightKey (0) # పారామితులను నిర్వచించడం, సెల్ పరిమాణం మరియు బ్లాక్ పరిమాణం # hxw పిక్సెల్‌లలో cell_size = (8, 8) # hxw కణాలలో block_size = (2, 2) # ఓరియంటేషన్ డబ్బాల సంఖ్య nbins = 9 # ఓపెన్‌సివి యొక్క HOG డిస్క్రిప్టర్‌ను ఉపయోగించడం # winSize అనేది సెల్ పరిమాణం యొక్క గుణకారానికి కత్తిరించబడిన చిత్రం హాగ్ = cv2.HOGDescriptor (_winSize = (గ్రే.షాప్ // సెల్_సైజ్ * సెల్_సైజ్, 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) # మనం ఉపయోగిస్తున్న NumPy శ్రేణి ఆకారం సృష్టించండి hog_features సృష్టించడానికి n_cells = (గ్రే.షాప్ // సెల్_సైజ్, గ్రే.షాప్ // సెల్_సైజ్) # మేము మొదట అడ్డు వరుసల వారీగా బ్లాక్స్ చేస్తాము. # హాగ్_ఫీట్స్ ఇప్పుడు ప్రతి దిశకు ప్రవణత వ్యాప్తిని కలిగి ఉంది, # ప్రతి గుంపుకు దాని గుంపులోని ప్రతి కణానికి. ఇండెక్సింగ్ వరుసల ద్వారా మరియు నిలువు వరుసల ద్వారా ఉంటుంది. hog_feats = hog.compute (బూడిదరంగు).రెషెప్ (n_ సెల్ - బ్లాక్_సైజ్ + 1, n_ సెల్స్ - బ్లాక్_సైజ్ + 1, బ్లాక్_సైజ్, బ్లాక్_సైజ్, ఎన్బిన్స్).మార్పిడి ((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 # మ్యాట్‌ప్లోట్లిబ్ # కోణం ఉపయోగించి HOT లు 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 ఫైల్‌లుగా అందించిన ముందస్తు శిక్షణ పొందిన వర్గీకరణదారులను ఉపయోగించబోతున్నాము, xml అంటే ఎక్స్‌టెన్సిబుల్ మార్కప్ లాంగ్వేజ్, ఈ భాష చాలా ఎక్కువ డేటాను నిల్వ చేయడానికి ఉపయోగించబడుతుంది, మీరు దానిపై డేటాబేస్ను కూడా నిర్మించవచ్చు.

మీరు ఈ లింక్ వద్ద ఈ వర్గీకరణదారుల ప్రాప్యతను కలిగి ఉండవచ్చు .

ముఖం గుర్తించడం

ఫ్రంటల్ ఫేస్ డిటెక్షన్ కోసం ప్రయత్నిద్దాం, ఫ్రంటల్ ఫేస్ డిటెక్టర్ యొక్క క్యాస్కేడ్ కోసం మీరు ఇక్కడ యాక్సెస్ చేయవచ్చు. Xml ఫైల్ పొందడానికి జిప్ ఫైల్ను సేకరించండి.

వంటి NP దిగుమతి NumPy దిగుమతి cv2 # మన ఎక్కడ OpenCV యొక్క CascadeClassifier ఫంక్షన్ చూపుతూ # వర్గీకరణ (XML ఫైల్ ఫార్మాట్) నిల్వ ఉంది, అదే ఫోల్డర్ లో కోడ్ మరియు వర్గీకరణ ఉంచాలని గుర్తుంచుకోవాలి 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 దిగుమతి cv2 face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') img = cv2.imread ('Trump.jpg') బూడిద cv2.COLOR_BGR2GRAY) = face_classifier.detectMultiScale (బూడిద, 1.3, 5) ఎదుర్కొంటుంది # ఎటువంటి ముఖాలు కనుగొనబడింది చేసినప్పుడు, face_classifier తిరిగి మరియు ఖాళీ tuple ముఖాలు ఉంటే (): ముద్రణ ("నో ఫేస్ దొరకలేదు") , w, h (x, y కోసం) ముఖాల్లో: 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.night.com (0) cv2.destroyAllWindows () cv2.nightKey (0)

కాబట్టి ఈ కోడ్ ముఖాన్ని గుర్తించే కోడ్ మాదిరిగానే ఉంటుంది, కానీ ఇక్కడ మేము వాటిని గుర్తించడానికి కంటి క్యాస్కేడ్లు మరియు పద్ధతిని జోడించాము, ఎందుకంటే మీరు ముఖం యొక్క గ్రే స్కేల్డ్ వెర్షన్‌ను డిటెక్ట్ మల్టీ స్కేల్ కోసం పరామితిగా ఎంచుకున్నాము కళ్ళు, గణన తగ్గింపుకు మనలను తీసుకువస్తాయి, ఎందుకంటే మేము ఆ ప్రాంతంలో మాత్రమే కళ్ళను గుర్తించబోతున్నాము.

లైవ్ ఫేస్ మరియు ఐ డిటెక్షన్

కాబట్టి ఇప్పటి వరకు మేము ముఖం మరియు కంటిని గుర్తించాము, ఇప్పుడు వెబ్‌క్యామ్ నుండి ప్రత్యక్ష వీడియో స్ట్రీమ్‌తో దీన్ని అమలు చేద్దాం. దీనిలో మేము ముఖం మరియు కళ్ళను గుర్తించాము, కాని ఈసారి వెబ్‌క్యామ్‌ను ప్రత్యక్ష ప్రసారం కోసం చేస్తాము. చాలా అనువర్తనంలో మీ ముఖం దాని చుట్టూ ఉన్న పెట్టెతో హైలైట్ చేయబడిందని మీరు కనుగొంటారు, కానీ ఇక్కడ మేము మీ ముఖాన్ని కత్తిరించుకుంటామని మరియు కళ్ళు మాత్రమే గుర్తించగలవు అని మేము భిన్నంగా చేసాము.

కాబట్టి ఇక్కడ మేము ముఖం మరియు కంటి వర్గీకరణ రెండింటినీ దిగుమతి చేస్తున్నాము మరియు ముఖం మరియు కంటిని గుర్తించడం కోసం అన్ని ప్రాసెసింగ్ చేయడానికి ఒక ఫంక్షన్‌ను నిర్వచించాము. మరియు ఆ తరువాత వెబ్‌క్యామ్ స్ట్రీమ్‌ను ప్రారంభించి, ముఖం మరియు కళ్ళు గుర్తించబడటానికి ఫేస్ డిటెక్టర్ ఫంక్షన్‌ను పిలిచారు. ఫేస్ డిటెక్టర్ ఫంక్షన్ లోపల మేము నిర్వచించే పరామితి లైవ్ వెబ్ కామ్ స్ట్రీమ్ నుండి నిరంతర చిత్రాలు

దిగుమతి cv2 NP దిగుమతి NumPy face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') డెఫ్ face_detector (img, పరిమాణం = 0.5): # Convert చిత్రం గ్రేస్కేల్ బూడిద = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ముఖాలు = face_classifier.detectMultiScale (బూడిదరంగు, 1.3, 5) ముఖాలు ఉంటే (): ముఖాలలో (x, y, w, h) కోసం img ని తిరిగి ఇవ్వండి : x = x - 50 w = 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 = కళ్ళలో ( ex, ey, ew, eh) కోసం eye_classifier.detectMultiScale (roi_gray) : 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. ట్రూ అయితే: ret, frame = cap.read () cv2.imshow ('మా ఫేస్ ఎక్స్‌ట్రాక్టర్', ఫేస్_డెటెక్టర్ (ఫ్రేమ్)) అయితే cv2.nightKey (1) == 13: # 13 ఎంటర్ కీ బ్రేక్ క్యాప్. విడుదల () cv2.destroyAllWindows ()

ట్యూనింగ్ క్యాస్కేడ్ వర్గీకరణ

ఇన్పుట్ ఇమేజ్ కాకుండా డిటెక్ట్ మల్టీ స్కేల్ లోపల నిర్వచించిన పారామితులు కింది ప్రాముఖ్యతను కలిగి ఉన్నాయి

మా క్లాస్సిఫైయర్. detMultiScale (ఇన్పుట్ ఇమేజ్, స్కేల్ ఫాక్టర్, కనిష్ట పొరుగువారు)

• స్కేల్ ఫాక్టర్ మేము స్కేల్ చేసిన ప్రతిసారీ చిత్ర పరిమాణాన్ని ఎంత తగ్గిస్తామో తెలుపుతుంది. ముఖం గుర్తించడంలో మేము సాధారణంగా 1.3 ని ఉపయోగిస్తాము. దీని అర్థం ప్రతిసారీ స్కేల్ అయినప్పుడు మేము 30% తగ్గిస్తాము. 1.05 వంటి చిన్న విలువలు గణించడానికి ఎక్కువ సమయం పడుతుంది, కానీ గుర్తించే రేటును పెంచుతుంది.

• కనిష్ట పొరుగువారు సానుకూల గుర్తింపుగా పరిగణించడానికి ప్రతి సంభావ్య విండో కలిగి ఉన్న పొరుగువారి సంఖ్యను పేర్కొంటుంది. సాధారణంగా 3-6 మధ్య సెట్ చేయండి. ఇది సున్నితత్వ అమరికగా పనిచేస్తుంది, తక్కువ విలువలు కొన్నిసార్లు ఒకే ముఖం మీద గుణకార ముఖాలను కనుగొంటాయి. అధిక విలువలు తక్కువ తప్పుడు పాజిటివ్లను నిర్ధారిస్తాయి, కానీ మీరు కొన్ని ముఖాలను కోల్పోవచ్చు.

వీడియోలలో కారు మరియు పాదచారుల గుర్తింపు

ఇప్పుడు మేము HAAR క్యాస్కేడ్లను ఉపయోగించి వీడియోలలో పాదచారులను మరియు కార్లను కనుగొంటాము, అయితే ఒకవేళ వీడియో లోడ్ అవ్వడం లేదు మరియు లోపం లేకుండా కోడ్ కంపైల్ చేస్తుంది మీరు ఈ క్రింది దశలను అనుసరించాలి:

కోడ్‌ను అమలు చేసిన తర్వాత వీడియో లోడ్ చేయకపోతే , మీ పైథాన్ ఇన్‌స్టాల్ చేయబడిన చోట అతికించడానికి మీరు మా opencv_ffmpeg.dl నుండి : opencv \ మూలాలు \ 3rdparty \ ffmpeg ను కాపీ చేయవలసి ఉంటుంది. ఉదా : C: \ అనకొండ 2

ఇది కాపీ అయిన తర్వాత మీరు ఉపయోగిస్తున్న ఓపెన్‌సివి వెర్షన్ ప్రకారం ఫైల్ పేరు మార్చాలి. మీరు ఓపెన్‌సివి 2.4.13 ఉపయోగిస్తుంటే ఫైల్‌ను పేరు మార్చండి: opencv_ffmpeg2413_64.dll లేదా opencv_ffmpeg2413.dll (మీరు ఉంటే X86 మెషీన్ను ఉపయోగించి) opencv_ffmpeg310_64.dll లేదా opencv_ffmpeg310.dll (మీరు X86 మెషీన్ను ఉపయోగిస్తుంటే)

కు మీరు python.exe సంస్థాపించబడిన తెలుసుకోవచ్చు, కోడ్ యొక్క ఈ రెండు పంక్తులు అమలు, అది python సంస్థాపించబడిన స్థానాన్ని ప్రింట్.

దిగుమతి sys ముద్రణ (sys.executable)

ఇప్పుడు మీరు ఈ దశలను విజయవంతంగా చేసి ఉంటే , పాదచారుల గుర్తింపు కోసం కోడ్‌కు వెళ్దాం , మీరు పాదచారుల గుర్తింపు కోసం క్యాస్కేడ్ కలిగి ఉండవచ్చు మరియు ఇక్కడ జతచేయబడిన జిప్ ఫైల్ నుండి.

cv2 దిగుమతి సంఖ్యను np గా దిగుమతి చేయండి # మా బాడీ క్లాస్‌ఫైయర్‌ను సృష్టించండి body_classifier = cv2.CascadeClassifier ('haarcascade_fullbody.xml') # వీడియో ఫైల్ కోసం వీడియో క్యాప్చర్‌ను ప్రారంభించండి, ఇక్కడ మేము పాదచారులను గుర్తించే వీడియో ఫైల్‌ను ఉపయోగిస్తున్నాము cap = cv2.VideoCapture ('walking.avi') # లూప్ వీడియో ఒకసారి విజయవంతంగా లోడ్ cap.isOpened () అయితే: # వీడియో యొక్క ప్రతి ఫ్రేమ్ పఠనం విశ్రాంత, ఫ్రేమ్ = cap.read () # ఇక్కడ మేము ఫ్రేమ్ పునఃపరిమాణం ఉంటాయి, దాని పరిమాణం సగానికి, మేము వర్గీకరణను వేగవంతం చేయడానికి చేస్తున్నాము # ఎందుకంటే పెద్ద చిత్రాలకు స్లైడ్ చేయడానికి చాలా ఎక్కువ విండోస్ ఉన్నాయి, కాబట్టి మొత్తంగా మేము రిజల్యూషన్‌ను తగ్గిస్తాము # సగం వీడియో అంటే 0.5 సూచిస్తుంది, మరియు మేము కూడా వేగంగా ఇంటర్‌పోలేషన్ పద్ధతిని ఉపయోగిస్తున్నాము, అది # ఇంటర్‌లీనియర్ ఫ్రేమ్ = సివి 2.రెసైజ్ (ఫ్రేమ్, ఏదీ లేదు, ఎఫ్ఎక్స్ = 0.5, ఫై = 0.5, ఇంటర్‌పోలేషన్ = సివి 2.ఇంటర్_లైన్) బూడిద = సివి 2. cvtColor (ఫ్రేమ్, cv2.COLOR_BGR2GRAY) # మా బాడీ వర్గీకరణ శరీరాలకు ఫ్రేమ్‌ను పాస్ చేయండి = body_classifier.detectMultiScale (బూడిద, 1.2, 3) # శరీరాలలో (x, y, w, h) గుర్తించబడిన ఏదైనా శరీరాల కోసం సరిహద్దు పెట్టెలను సంగ్రహించండి : cv2. cv2.nightKey (1) == 13 ఉంటే దీర్ఘచతురస్రం (ఫ్రేమ్, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('పాదచారులు', ఫ్రేమ్) : # 13 ఎంటర్ కీ బ్రేక్ క్యాప్. విడుదల () cv2.destroyAllWindows ()

వీడియోలో పాదచారులను విజయవంతంగా గుర్తించిన తరువాత, కార్ల గుర్తింపు కోసం కోడ్‌కు వెళ్దాం , మీరు ఇక్కడ నుండి పాదచారులను గుర్తించడానికి క్యాస్‌కేడ్‌ను కలిగి ఉండవచ్చు.

cv2 దిగుమతి సమయం దిగుమతి సంఖ్యను np # మా బాడీ వర్గీకరణను సృష్టించండి car_classifier = cv2.CascadeClassifier ('haarcascade_car.xml') # వీడియో ఫైల్ క్యాప్ కోసం వీడియో క్యాప్చర్ ప్రారంభించండి = cv2.VideoCapture ('cars.avi') # వీడియో విజయవంతంగా పూర్తయిన తర్వాత లూప్ లోడ్ చేస్తున్నప్పుడు cap.isOpened (): time.sleep (.05) # చదవండి మొదటి ఫ్రేమ్ విశ్రాంత, ఫ్రేమ్ = 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.nightKey (1) == 13: # 13 ఎంటర్ కీ బ్రేక్ క్యాప్. విడుదల () cv2.destroyAllWindows ()

మేము సమయం జోడించినట్లు మీరు గమనించారు. నిద్ర (.05) , ఇది ఫ్రేమ్ రేటులో ఆలస్యం కాబట్టి అన్ని కార్లు సరిగ్గా గుర్తించబడిందని మీరు ధృవీకరించవచ్చు లేదా దానికి వ్యాఖ్య లేబుల్‌ను జోడించడం ద్వారా మీరు దాన్ని సులభంగా తొలగించవచ్చు.

ఈ కథనాన్ని పైథాన్‌లోని మాస్టర్ కంప్యూటర్ విజన్ ™ ఓపెన్‌సివి 4 నుండి ఉడీమీపై డీప్ లెర్నింగ్ కోర్సుతో రాజీవ్ రతన్ రూపొందించారు, కంప్యూటర్ విజన్ మరియు పైథాన్ గురించి మరింత తెలుసుకోవడానికి దీన్ని చందా చేయండి.