Opencv ఉపయోగించి చిత్ర విభజన

మునుపటి ట్యుటోరియల్‌లలో, మేము ప్రాథమిక ఇమేజ్ ప్రాసెసింగ్ కోసం ఓపెన్‌సివిని ఉపయోగించాము మరియు కొన్ని ముందస్తు ఇమేజ్ ఎడిటింగ్ కార్యకలాపాలను చేసాము. మనకు తెలిసినట్లుగా, ఓపెన్‌సివి ఓపెన్ సోర్స్ కమ్యూటర్ విజన్ లైబ్రరీ, ఇది సి ++, పైథాన్ మరియు జావా ఇంటర్‌ఫేస్‌లను కలిగి ఉంది మరియు విండోస్, లైనక్స్, మాక్ ఓఎస్, ఐఓఎస్ మరియు ఆండ్రాయిడ్‌కు మద్దతు ఇస్తుంది. కాబట్టి దీనిని పైథాన్ మరియు లైనక్స్ వాతావరణంతో రాస్ప్బెర్రీ పైలో సులభంగా ఇన్స్టాల్ చేయవచ్చు. ఫేస్ డిటెక్షన్, ఫేస్ లాక్, ఆబ్జెక్ట్ ట్రాకింగ్, కార్ నంబర్ ప్లేట్ డిటెక్షన్, హోమ్ సెక్యూరిటీ సిస్టమ్ వంటి అనేక రియల్ టైమ్ ఇమేజ్ ప్రాసెసింగ్ అనువర్తనాలను రూపొందించడానికి ఓపెన్‌సివి మరియు అటాచ్డ్ కెమెరాతో రాస్‌ప్బెర్రీ పై ఉపయోగపడుతుంది. ఈ ట్యుటోరియల్‌లో మనం ఎలా చేయాలో నేర్చుకుంటాము OpenCV ఉపయోగించి చిత్ర విభజన. మేము చేయబోయే కార్యకలాపాలు క్రింద ఇవ్వబడ్డాయి:

• విభజన మరియు ఆకృతులు
• సోపానక్రమం మరియు తిరిగి పొందే మోడ్
• ఆకృతులను అంచనా వేయడం మరియు వాటి కుంభాకార పొట్టును కనుగొనడం
• కోనెక్స్ హల్
• సరిపోలే ఆకృతి
• ఆకారాలను గుర్తించడం (వృత్తం, దీర్ఘచతురస్రం, త్రిభుజం, చదరపు, నక్షత్రం)
• లైన్ డిటెక్షన్
• బొట్టును గుర్తించడం
• బొబ్బలను ఫిల్టర్ చేయడం - వృత్తాలు మరియు దీర్ఘవృత్తాలు లెక్కించడం

1. విభజన మరియు ఆకృతులు

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

లో ఆకృతులు చాలా ముఖ్యమైనవి

• ఆబ్జెక్ట్ డిటెక్షన్
• ఆకార విశ్లేషణ

వాస్తవ ప్రపంచ చిత్ర విశ్లేషణ నుండి MRI వంటి వైద్య చిత్ర విశ్లేషణ వరకు వారు చాలా విస్తృతమైన అనువర్తన క్షేత్రాన్ని కలిగి ఉన్నారు

చతురస్రాల ఆకృతులను సంగ్రహించడం ద్వారా ఓపెన్‌సివిలో ఆకృతులను ఎలా అమలు చేయాలో తెలుసుకుందాం.

దిగుమతి cv2 దిగుమతి NumPy NP వంటి

3 బ్లాక్ స్క్వేర్‌లతో సరళమైన చిత్రాన్ని లోడ్ చేద్దాం

image = cv2.imread ('squares.jpg') cv2.imshow ('ఇన్పుట్ ఇమేజ్', ఇమేజ్) cv2.nightKey (0)

గ్రేస్కేల్

బూడిద = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY)

కాన్నీ అంచులను కనుగొనండి

edged = cv2.Canny (బూడిద, 30,200) cv2.imshow ('కాన్నీ అంచులు', అంచు) cv2.nightKey (0)

ఆకృతులను కనుగొనడం

# మీ చిత్రం యొక్క కాపీని వాడండి, ఉదా. - ఎడ్జ్డ్.కోపీ (), ఓపెన్‌సివి వెర్షన్ _, ఆకృతులు, సోపానక్రమం = సివి 2 అప్‌గ్రేడ్ చేయడం వల్ల ఆకృతులను ఖాళీ ఆర్గ్యుమెంట్‌గా మార్చడానికి ముందు, # మేము _ ను జోడించాలి..findContours (అంచు, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('కాంటౌరింగ్ తర్వాత కాన్నీ అంచులు', అంచు) cv2.nightKey (0)

ఆకృతులు ఏమిటో తెలుసుకోవడానికి కాంటౌర్ ఫైల్‌ను ముద్రించడం

ముద్రణ (ఆకృతులు) ముద్రణ ('ఆకృతుల సంఖ్యలు కనుగొనబడ్డాయి =' + str (లెన్ (ఆకృతులు)))

అన్ని ఆకృతులను గీయండి

#v -1 అన్ని ఆకృతులను గీయడానికి 3 వ పరామితిగా cv2.drawContours (చిత్రం, ఆకృతులు, -1, (0,255,0), 3) cv2.imshow ('ఆకృతులు', చిత్రం) cv2.nightKey (0) cv2. destAllWindows ()

కన్సోల్ అవుట్పుట్ -],],], …,],],]], dtype = int32), అమరిక(],],

], …,

],],]], dtype = int32), శ్రేణి (],],], …,],],]], dtype = int32)]

ఆకృతుల సంఖ్యలు కనుగొనబడ్డాయి = 3. కాబట్టి మేము మొత్తం మూడు ఆకృతులను కనుగొన్నాము.

ఇప్పుడు, పై కోడ్‌లో మనం ఉపయోగించి కాంటౌర్ ఫైల్‌ను కూడా ప్రింట్ చేసాము , పై కన్సోల్ అవుట్‌పుట్‌లో ముద్రించినట్లుగా ఈ ఆకృతులు ఎలా ఉన్నాయో ఈ ఫైల్ చెబుతుంది.

పై కన్సోల్ అవుట్‌పుట్‌లో మనకు x, y పాయింట్ల కోఆర్డినేట్‌ల వలె కనిపించే మాతృక ఉంది. ఓపెన్‌సివి ఆకృతులను జాబితాల జాబితాలో నిల్వ చేస్తుంది. పై కన్సోల్ అవుట్‌పుట్‌ను మనం ఈ క్రింది విధంగా చూపించగలము:

CONTOUR 1 CONTOUR 2 CONTOUR 3

], శ్రేణి (], శ్రేణి (],],],],],],],

…,…,…,],],],],],],]], dtype = int32),]], dtype = int32),]], dtype = int32)]

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

ఇప్పుడు, ఆ శ్రేణిలోని మొదటి మూలకం CONTOUR 1 అని imagine హించుకోండి మరియు ఆ జాబితాలో అన్ని కోఆర్డినేట్ల జాబితా ఉంటుంది మరియు ఈ కోఆర్డినేట్లు ఆకుపచ్చ దీర్ఘచతురస్రాకార పెట్టెలుగా మనం చూసిన ఆకృతుల వెంట ఉన్న పాయింట్లు.

ఈ అక్షాంశాలను నిల్వ చేయడానికి వేర్వేరు పద్ధతులు ఉన్నాయి మరియు వీటిని ఉజ్జాయింపు పద్ధతులు అంటారు, ప్రాథమికంగా ఉజ్జాయింపు పద్ధతులు రెండు రకాలు

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE అన్ని సరిహద్దు బిందువులను నిల్వ చేస్తుంది, కాని మనకు అన్ని సరిహద్దు పాయింట్లు అవసరం లేదు, పాయింట్ సరళ రేఖను ఏర్పరుచుకుంటే, మనకు ఆ రేఖలో ప్రారంభ స్థానం మరియు ముగింపు స్థానం మాత్రమే అవసరం.

cv2.CHAIN_APPROX_SIMPLE బదులుగా సరిహద్దు ఆకృతుల ప్రారంభ మరియు ముగింపు పాయింట్లను మాత్రమే అందిస్తుంది, ఫలితం ఆకృతి సమాచారం యొక్క మరింత సమర్థవంతమైన నిల్వ.

_, ఆకృతులు, సోపానక్రమం = cv2.findContours (అంచు, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

పైన కోడ్ లో cv2.RETR_EXTERNAL అయితే తిరిగి పొందడం రీతి cv2.CHAIN_APPROX_NONE ఉంది

ఉజ్జాయింపు పద్ధతి.

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

2. సోపానక్రమం మరియు తిరిగి పొందడం మోడ్

రిట్రీవల్ మోడ్ ఉప ఆకృతులు, లేదా బాహ్య ఆకృతి లేదా అన్ని ఆకృతుల వంటి ఆకృతులలోని సోపానక్రమాన్ని నిర్వచిస్తుంది.

ఇప్పుడు సోపానక్రమం రకాల్లో నాలుగు రిట్రీవల్ మోడ్‌లు క్రమబద్ధీకరించబడ్డాయి.

cv2.RETR_LIST - అన్ని ఆకృతులను తిరిగి పొందుతుంది.

cv2.RETR_EXTERNAL - బాహ్య లేదా బాహ్య ఆకృతులను మాత్రమే తిరిగి పొందుతుంది.

cv2.RETR_CCOMP - 2-స్థాయి సోపానక్రమంలో అన్నింటినీ తిరిగి పొందుతుంది.

cv2.RETR_TREE - పూర్తి సోపానక్రమంలో అన్నింటినీ తిరిగి పొందుతుంది.

సోపానక్రమం క్రింది ఆకృతిలో నిల్వ చేయబడుతుంది

ఇప్పుడు మొదటి రెండు రిట్రీవల్ మోడ్‌ల మధ్య వ్యత్యాసాన్ని వివరిద్దాం, cv2.RETR_LIST మరియు cv2.RETR_EXTERNAL.

దిగుమతి cv2 దిగుమతి NumPy NP వంటి

3 బ్లాక్ స్క్వేర్‌లతో సరళమైన చిత్రాన్ని లోడ్ చేద్దాం

image = cv2.imread ('square donut.jpg') cv2.imshow ('ఇన్పుట్ ఇమేజ్', ఇమేజ్) cv2.nightKey (0)

గ్రేస్కేల్

బూడిద = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY)

కాన్నీ అంచులను కనుగొనండి

edged = cv2.Canny (బూడిద, 30,200) cv2.imshow ('కాన్నీ అంచులు', అంచు) cv2.nightKey (0)

ఆకృతులను కనుగొనడం

, edged.copy (ఆది) గుర్తించడం ఆకృతులను చిత్రం మార్చే నుండి - మీ చిత్రం, ఉదా యొక్క ఒక కాపీని #use # మమ్మల్ని ఓపెన్ CV వెర్షన్ అప్గ్రేడ్ కారణంగా ఖాళీ వాదన వంటి ఆకృతులను ముందు, జోడించడానికి _ కలిగి _, ఆకృతులను సోపాన = cv2.findContours (అంచు, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('కాంటౌరింగ్ తర్వాత కాన్నీ అంచులు', అంచు) cv2.nightKey (0)

ఆకృతులు ఏమిటో తెలుసుకోవడానికి కాంటౌర్ ఫైల్‌ను ముద్రించడం.

ముద్రణ (ఆకృతులు) ముద్రణ ('ఆకృతుల సంఖ్యలు కనుగొనబడ్డాయి =' + str (లెన్ (ఆకృతులు)))

అన్ని ఆకృతులను గీయండి

#v -1 అన్ని ఆకృతులను గీయడానికి 3 వ పరామితిగా cv2.drawContours (చిత్రం, ఆకృతులు, -1, (0,255,0), 3) cv2.imshow ('ఆకృతులు', చిత్రం) cv2.nightKey (0) cv2. destAllWindows

దిగుమతి cv2 దిగుమతి NumPy NP వంటి

3 బ్లాక్ స్క్వేర్‌లతో సరళమైన చిత్రాన్ని లోడ్ చేద్దాం

image = cv2.imread ('square donut.jpg') cv2.imshow ('ఇన్పుట్ ఇమేజ్', ఇమేజ్) cv2.nightKey (0)

గ్రేస్కేల్

బూడిద = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY)

కాన్నీ అంచులను కనుగొనండి

edged = cv2.Canny (బూడిద, 30,200) cv2.imshow ('కాన్నీ అంచులు', అంచు) cv2.nightKey (0)

ఆకృతులను కనుగొనడం

, edged.copy (ఆది) గుర్తించడం ఆకృతులను చిత్రం మార్చే నుండి - మీ చిత్రం, ఉదా యొక్క ఒక కాపీని #use # మమ్మల్ని ఓపెన్ CV వెర్షన్ అప్గ్రేడ్ కారణంగా ఖాళీ వాదన వంటి ఆకృతులను ముందు, జోడించడానికి _ కలిగి _, ఆకృతులను సోపాన = cv2.findContours (అంచు, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('కాంటౌరింగ్ తర్వాత కాన్నీ అంచులు', అంచు) cv2.nightKey (0)

ఆకృతులు ఏమిటో తెలుసుకోవడానికి కాంటౌర్ ఫైల్‌ను ముద్రించడం.

ముద్రణ (ఆకృతులు) ముద్రణ ('ఆకృతుల సంఖ్యలు కనుగొనబడ్డాయి =' + str (లెన్ (ఆకృతులు)))

అన్ని ఆకృతులను గీయండి

#v -1 అన్ని ఆకృతులను గీయడానికి 3 వ పరామితిగా cv2.drawContours (చిత్రం, ఆకృతులు, -1, (0,255,0), 3) cv2.imshow ('ఆకృతులు', చిత్రం) cv2.nightKey (0) cv2. destAllWindows ()

కాబట్టి పై కోడ్‌ల ప్రదర్శన ద్వారా cv2.RETR_LIST మరియు cv2.RETR_EXTERNNAL మధ్య వ్యత్యాసాన్ని cv2.RETR_EXTERNNAL లో స్పష్టంగా చూడవచ్చు. లోపలి ఆకృతులను విస్మరిస్తున్నప్పుడు బాహ్య ఆకృతులను మాత్రమే పరిగణనలోకి తీసుకుంటున్నాము.

Cv2.RETR_LIST లో ఉన్నప్పుడు లోపలి ఆకృతులను కూడా పరిగణనలోకి తీసుకుంటున్నారు.

3. ఆకృతులను అంచనా వేయడం మరియు వాటి కుంభాకార పొట్టును కనుగొనడం

ఆకృతులను అంచనా వేయడంలో, ఒక ఆకృతి ఆకారం మరొక ఆకృతి ఆకృతిపై అంచనా వేయబడుతుంది, ఇది మొదటి ఆకృతి ఆకారంతో సమానంగా ఉండకపోవచ్చు.

ఉజ్జాయింపు కోసం మేము ఓపెన్ సివి యొక్క సుమారుగా పాలిడిపి ఫంక్షన్‌ను ఉపయోగిస్తాము, ఇది క్రింద వివరించబడింది

cv2.approxPolyDP (ఆకృతి, ఉజ్జాయింపు ఖచ్చితత్వం, మూసివేయబడింది)

పారామితులు:

• సమోన్నత - మేము ఇంచుమించుగా అనుకుంటున్నారా వ్యక్తి కాంటౌర్ ఉంది.
• ఉజ్జాయింపు ఖచ్చితత్వం - ఉజ్జాయింపు యొక్క ఖచ్చితత్వాన్ని నిర్ణయించడంలో ముఖ్యమైన పరామితి, చిన్న విలువ ఖచ్చితమైన ఉజ్జాయింపును ఇస్తుంది, పెద్ద విలువలు మరింత సాధారణ సమాచారాన్ని ఇస్తాయి. మంచి బొటనవేలు నియమం కాంటౌర్ చుట్టుకొలతలో 5% కన్నా తక్కువ.
• మూసివేయబడింది - సుమారు ఆకృతి తెరిచి లేదా మూసివేయబడిందా అని చెప్పే బూలియన్ విలువ.

ఇంటి సరళమైన బొమ్మను అంచనా వేయడానికి ప్రయత్నిద్దాం

దిగుమతి NumPy NP వంటి దిగుమతి cv2

చిత్రాన్ని లోడ్ చేసి, కాపీని ఉంచండి

image = cv2.imread ('house.jpg') orig_image = image.copy () cv2.imshow ('అసలు చిత్రం', Orig_image) cv2.nightKey (0)

చిత్రాన్ని గ్రేస్కేల్ చేయండి మరియు బైనరైజ్ చేయండి

బూడిద = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY) ret, thresh = cv2.threshold (బూడిద, 127,255, cv2.THRESH_BINARY_INV)

ఆకృతులను కనుగొనండి

_, ఆకృతులు, సోపానక్రమం = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

ప్రతి ఆకృతి ద్వారా మళ్ళించండి మరియు వాటి సరిహద్దు దీర్ఘచతురస్రాన్ని లెక్కించండి

ఆకృతులలో సి కోసం: x, y, w, h = cv2.boundingRect (c) cv2.rectangle (orig_image, (x, y), (x + w, y + h), (0,0,255), 2) cv2.ఇమ్‌షో ('బౌండింగ్ రెక్ట్ ', ఆరిజ్_ఇమేజ్) cv2.nightKey (0)

ప్రతి ఆకృతి ద్వారా మళ్ళించండి మరియు సుమారు ఆకృతిని లెక్కించండి

ఆకృతులలో సి కోసం:

# కాంటౌర్ చుట్టుకొలత ఖచ్చితత్వం యొక్క శాతంగా ఖచ్చితత్వాన్ని లెక్కించండి = 0.03 * cv2.arcLength (సి, ట్రూ) సుమారు = cv2.approxPolyDP (సి, ఖచ్చితత్వం, నిజం) cv2.drawContours (చిత్రం,, 0, (0,255,0), 2) cv2.imshow ('అప్రోక్స్ పాలిడిపి', ఇమేజ్) cv2.nightKey (0) cv2.destroyAllWindows ()

4. కుంభాకార పొట్టు

కుంభాకార పొట్టు ప్రాథమికంగా బయటి అంచులు, ఇచ్చిన బొమ్మపై గీతలు గీయడం ద్వారా సూచించబడుతుంది.

ఇది వస్తువు చుట్టూ సరిపోయే అతిచిన్న బహుభుజి కావచ్చు.

cv2 దిగుమతి సంఖ్యను np image = cv2.imread ('star.jpg') బూడిద = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY) cv2.imshow ('అసలు చిత్రం', చిత్రం) cv2.nightKey (0)

చిత్రాన్ని త్రెషోల్డ్ చేయండి

ret, thresh = cv2.threshold (బూడిద, 176,255,0)

ఆకృతులను కనుగొనండి

_, ఆకృతులు, సోపానక్రమం = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

ఆకృతులను ప్రాంతాల వారీగా క్రమబద్ధీకరించండి, ఆపై అతిపెద్ద ఫ్రేమ్ ఆకృతిని తొలగించండి

n = లెన్ (ఆకృతులు) -1 ఆకృతులు = క్రమబద్ధీకరించబడినవి (ఆకృతులు, కీ = cv2.contourArea, రివర్స్ = తప్పుడు)

ఆకృతుల ద్వారా మళ్ళించి, కుంభాకార పొట్టును గీయండి

ఆకృతులలో సి కోసం:

hull = cv2.convexHull (c) cv2.drawContours (చిత్రం,, 0, (0,255,0), 2) cv2.imshow ('కుంభాకార హల్', చిత్రం) cv2.nightKey (0) cv2.destroyAllWindows ()

5. ఆకారాల ద్వారా ఆకృతిని సరిపోల్చడం

cv2.matchShapes (ఆకృతి టెంప్లేట్, ఆకృతి పద్ధతి, పద్ధతి పరామితి)

అవుట్పుట్ - మ్యాచ్ విలువ (తక్కువ విలువ అంటే దగ్గరి మ్యాచ్ అని అర్థం)

ఆకృతి టెంప్లేట్ - ఇది మేము క్రొత్త చిత్రంలో కనుగొనడానికి ప్రయత్నిస్తున్న మా సూచన ఆకృతి.

ఆకృతి - మేము వ్యతిరేకంగా తనిఖీ చేస్తున్న వ్యక్తిగత ఆకృతి.

విధానం - ఆకృతి సరిపోలిక రకం (1,2,3).

పద్ధతి పరామితి - ఒంటరిగా 0.0 గా వదిలివేయండి (పైథాన్ ఓపెన్‌సివిలో ఉపయోగించబడదు)

దిగుమతి cv2 దిగుమతి NumPy NP వంటి

ఆకార టెంప్లేట్ లేదా సూచన చిత్రాన్ని లోడ్ చేయండి

template = cv2.imread ('star.jpg', 0) cv2.imshow ('template', template) cv2.nightKey (0)

మేము సరిపోల్చడానికి ప్రయత్నిస్తున్న ఆకృతులతో లక్ష్య చిత్రాన్ని లోడ్ చేయండి

target = cv2.imread ('shapestomatch.jpg') బూడిద = cv2.cvtColor (లక్ష్యం, cv2.COLOR_BGR2GRAY)

Cv2.findContours ను ఉపయోగించే ముందు రెండు చిత్రాలను ముందుగా ప్రవేశపెట్టండి

ret, thresh1 = cv2.threshold (టెంప్లేట్, 127,255,0) ret, thresh2 = cv2.threshold (బూడిద, 127,255,0)

మూసలో ఆకృతులను కనుగొనండి

_, ఆకృతులను, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) కాబట్టి మేము ఇది అతిపెద్ద ఆకృతి తొలగించవచ్చు విస్తీర్ణపరంగా ఆకృతులను క్రమం # మమ్మల్ని అవసరం

చిత్ర రూపురేఖ

sorted_contours = క్రమబద్ధీకరించబడిన (ఆకృతులు, కీ = cv2.contourArea, రివర్స్ = ట్రూ) # మేము రెండవ అతిపెద్ద ఆకృతిని సంగ్రహిస్తాము, ఇది మా టెంప్లేట్ ఆకృతి అవుతుంది tempelate_contour = ఆకృతులు # రెండవ లక్ష్య చిత్రం నుండి ఆకృతులను సంగ్రహించండి _, ఆకృతులు, సోపానక్రమం = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) ఆకృతులలో సి: # లక్ష్య చిత్రంలోని ప్రతి ఆకృతి ద్వారా అక్షరాస్యత మరియు ఆకృతి ఆకారాన్ని సరిపోల్చడానికి cv2.matchShape ని ఉపయోగించండి = cv2.matchShapes (tempelate_contour, c, 1,0.0) ముద్రణ ("మ్యాచ్") #if మ్యాచ్ విలువ 0.15 కన్నా తక్కువ ఉంటే <0.16: close_contour = c else: closeest_contour = cv2.drawContours (లక్ష్యం,, - 1, (0,255,0), 3) cv2.imshow ('అవుట్పుట్', లక్ష్యం) cv2.waitKey (0) cv2.destroyAllWindows ()

కన్సోల్ అవుట్పుట్ -

0.16818605122199104

0.19946910256158912

0.18949760627309664

0.11101058276281539

వేర్వేరు గణిత ఫంక్షన్‌తో మూడు వేర్వేరు పద్ధతులు ఉన్నాయి, 1,2 మరియు 3 నుండి మారుతూ ఉండే cv2.matchShapes (tempelate_contour, c, 1, 0.0) పద్ధతి విలువలను భర్తీ చేయడం ద్వారా మేము ప్రతి పద్ధతిలో ప్రయోగాలు చేయవచ్చు, ప్రతి విలువకు మీరు వేర్వేరు మ్యాచ్ పొందుతారు కన్సోల్ అవుట్‌పుట్‌లోని విలువలు.

6. ఆకారాలను గుర్తించడం (వృత్తం, దీర్ఘచతురస్రం, త్రిభుజం, చదరపు, నక్షత్రం)

చిత్రం నుండి స్వయంచాలకంగా వివిధ రకాల ఆకృతులను గుర్తించడానికి ఓపెన్‌సివిని కూడా ఉపయోగించవచ్చు. దిగువ కోడ్‌ను ఉపయోగించడం ద్వారా మేము చిత్రం నుండి వృత్తం, దీర్ఘచతురస్రం, త్రిభుజం, చదరపు మరియు నక్షత్రాలను గుర్తించగలుగుతాము.

దిగుమతి cv2 దిగుమతి NumPy NP వంటి

బూడిద స్థాయి చిత్రాలను లోడ్ చేసి, ఆపై

చిత్రం = cv2.imread ('shapes.jpg') బూడిద = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY) cv2.imshow ('ఆకారాలు గుర్తించడం', చిత్రం) cv2.waitKey (0) విశ్రాంత, వేయు = cv2.threshold (బూడిద, 127,255,1)

ఆకృతులను సంగ్రహించండి

_, ఆకృతులు, సోపానక్రమం = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

ఆకృతులలో cnt కోసం:

సుమారు బహుభుజులతో పొందండి సుమారు = cv2.approxPolyDP (cnt, 0.01 * cv2.arcLength (cnt, ట్రూ), ట్రూ) లెన్ ఉంటే (సుమారుగా) == 3: shape_name = "త్రికోణం" cv2.drawContours (చిత్రం,, 0, (0,255, 0), - 1)

మధ్యలో వచనాన్ని ఉంచడానికి ఆకృతి కేంద్రాన్ని కనుగొనండి

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (చిత్రం, ఆకారం_పేరు, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0, 0), 1) ఎలిఫ్ లెన్ (సుమారు) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / మ)

ఆ నాలుగు వైపుల బహుభుజి చదరపు లేదా దీర్ఘచతురస్రం కాదా అని తనిఖీ చేయండి

# cv2.boundingRect ఎడమ వెడల్పు మరియు ఎత్తును పిక్సెల్‌లలో తిరిగి ఇవ్వండి, ఎగువ # ఎడమ మూలలో నుండి ప్రారంభించి , చదరపు కోసం అబ్స్ (wh) <= 3: shape_name = "చదరపు" # వచనాన్ని ఉంచడానికి కాంటౌర్ సెంటర్‌ను కనుగొంటే సుమారు సమానంగా ఉంటుంది . సెంటర్ cv2.drawContours (చిత్రం,, 0, (0,125,255), - 1) cv2.putText (చిత్రం, ఆకారం_పేరు, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) else: shape_name = "రియాక్టాంగిల్" # cv2.drawContours (చిత్రం,, 0, (0,0,255), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (చిత్రం, ఆకారం_పేరు, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) ఎలిఫ్ లెన్ (సుమారు) == 10: ఆకారం_పేరు = 'స్టార్' cv2.drawContours (చిత్రం,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (చిత్రం, ఆకారం_పేరు, (CX-50, CY), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) Elif లెన్ (సుమారుగా)> = 15: shape_name = 'సర్కిల్' cv2.drawContours (చిత్రం,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (చిత్రం, ఆకారం_పేరు, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('గుర్తించడం ఆకారాలు', చిత్రం) cv2.waitKey (0) cv2.destroyAllWindows ()

7. లైన్ డిటెక్షన్

ఓపెన్‌సివిలో లైన్ డిటెక్షన్ చాలా ముఖ్యమైన భావన, మరియు వాస్తవ ప్రపంచంలో మంచి ఉపయోగం ఉంది. అటానమస్ కార్లు దారులు మరియు రహదారులను గుర్తించడానికి లైన్ డిటెక్షన్ అల్గారిథమ్‌లను ఉపయోగిస్తాయి.

లైన్ డిటెక్షన్లో మేము రెండు అల్గోరిథంలతో వ్యవహరిస్తాము,

• హాఫ్ లైన్ అల్గోరిథం
• ప్రోబాలిస్టిక్ హాగ్ లైన్ అల్గోరిథం.

Y = mx + c అనే సమీకరణంతో హైస్కూల్ గణితం నుండి లైన్ యొక్క ప్రాతినిధ్యం మీరు గుర్తుంచుకోవచ్చు .

అయితే, ఓపెన్‌సివి లైన్‌లో మరొక మార్గం ద్వారా ప్రాతినిధ్యం వహిస్తుంది

Ρ = xcosӨ + ysincosӨ పైన ఉన్న సమీకరణం రేఖ యొక్క ఓపెన్‌సివి ప్రాతినిధ్యం, దీనిలో origin మూలం నుండి రేఖ యొక్క లంబ దూరం మరియు line అనేది ఈ రేఖ యొక్క సాధారణం నుండి మూలానికి ఏర్పడిన కోణం (రేడియన్లలో కొలుస్తారు, దీనిలో 1pi రేడియన్లు / 180 = 1 డిగ్రీ).

పంక్తిని గుర్తించడానికి ఓపెన్‌సివి ఫంక్షన్ ఇలా ఇవ్వబడింది

cv2.HoughLines (బైనరైజ్డ్ ఇమేజ్, ρ ఖచ్చితత్వం, Ө ఖచ్చితత్వం, థ్రెషోల్డ్), దీనిలో ప్రవేశ రేఖగా పరిగణించబడే కనీస ఓటు.

ఇప్పుడు ఓపెన్‌సివి యొక్క హాగ్ లైన్ ఫంక్షన్ సహాయంతో బాక్స్ ఇమేజ్ కోసం పంక్తులను గుర్తించండి.

దిగుమతి cv2 దిగుమతి NumPy NP వంటి చిత్రం = cv2.imread ('box.jpg')

గ్రేస్కేల్ మరియు కాన్నీ అంచులు సేకరించబడ్డాయి

బూడిద = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY) అంచులు = cv2.Canny (బూడిద, 100,170, ఎపర్చర్‌సైజ్ = 3)

1 పిక్సెల్ యొక్క rho ఖచ్చితత్వాన్ని ఉపయోగించి హాగ్ లైన్లను అమలు చేయండి

1 డిగ్రీ # లైన్ థ్రెషోల్డ్ (np.pi / 180) యొక్క # ఖచ్చితత్వం 240 (లైన్‌లోని పాయింట్ల సంఖ్య) పంక్తులు = cv2 గా సెట్ చేయబడింది. హౌఫ్లైన్స్ (అంచులు, 1, np.pi / 180, 240) # మేము మళ్ళిస్తాము ప్రతి పంక్తి ద్వారా మరియు # పరిధిలోని (0, లెన్ (పంక్తులు)) కోసం cv2.lines (అనగా ముగింపు పాయింట్లు అవసరం) ద్వారా ఫార్మాట్‌లోకి మార్చండి : రో కోసం, పంక్తులలో తీటా: a = np.cos (theta) b = np.sin (తీటా) x0 = a * rho y0 = b * rho x1 = int (x0 + 1000 * (- b)) y1 = int (y0 + 1000 * (a)) x2 = int (x0-1000 * (-b)) y2 = int (y0-1000 * (a)) cv2.line (చిత్రం, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('హాఫ్ లైన్స్', చిత్రం) cv2.nightKey (0) cv2.destroyAllWindows ()

ఇప్పుడు సంభావ్య హాగ్ లైన్ యొక్క ఇతర అల్గోరిథంతో లైన్ డిటెక్షన్ పైన పునరావృతం చేద్దాం.

సంభావ్య హాగ్ లైన్ వెనుక ఉన్న ఆలోచన ఏమిటంటే, పంక్తిని గుర్తించడానికి సరిపోయే పాయింట్ల యాదృచ్ఛిక ఉపసమితిని తీసుకోవడం.

ప్రాబబిలిస్టిక్ హాగ్ లైన్ కోసం ఓపెన్‌సివి ఫంక్షన్ cv2 గా సూచించబడుతుంది. HoughLinesP (బైనరైజ్డ్ ఇమేజ్, ρ ఖచ్చితత్వం, Ө ఖచ్చితత్వం, ప్రవేశ, కనీస పంక్తి పొడవు, గరిష్ట పంక్తి అంతరం)

ఇప్పుడు సంభావ్య హాగ్ పంక్తుల సహాయంతో బాక్స్ లైన్లను గుర్తించండి.

దిగుమతి cv2 దిగుమతి NumPy NP వంటి

గ్రేస్కేల్ మరియు కాన్నీ అంచులు సంగ్రహించబడ్డాయి

చిత్రం = cv2.imread ('box.jpg') బూడిద = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY) అంచులు = cv2.Canny (బూడిద, 50.150, apertureSize = 3) #again మేము అదే RHO మరియు తీటా ఖచ్చితత్త్వాలు ఉపయోగించడానికి #however, మేము 100 # మరియు కనిష్ట పంక్తి పొడవు 5 పిక్సెల్స్ మరియు 10 పిక్సెల్స్ పంక్తుల మధ్య గరిష్ట అంతరం = cv2.HoughLinesP (అంచులు, 1, np.pi / 180,100,100,10) i పరిధిలో (0, లెన్ (పంక్తులు)): పంక్తులలో x1, y1, x2, y2 కోసం: cv2.line (చిత్రం, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('ప్రోబాలిస్టిక్ హాఫ్ లైన్స్', ఇమేజ్) cv2.nightKey (0) cv2.destroyAllWindows

8. బొట్టును గుర్తించడం

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

ముఖ్య విషయాలను గీయడానికి మేము ఈ క్రింది వాదనలు తీసుకునే cv2.drawKeypoints ను ఉపయోగిస్తాము.

cv2.

జెండాలలో ఎక్కడ ఉండవచ్చు

cv2.DRAW_MATCHES_FLAGS_DEFAULT

cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS

cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG

cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS

మరియు ఇక్కడ ఖాళీగా ఉన్నది సున్నాల మాతృక ద్వారా ఒకటి కాదు

ఇప్పుడు పొద్దుతిరుగుడు పువ్వుల చిత్రంపై బొట్టును గుర్తించడం చేద్దాం, ఇక్కడ పువ్వులు అన్ని పుష్పాలలో సాధారణమైనవి కాబట్టి పువ్వుల కేంద్ర భాగాలుగా ఉంటాయి.

దిగుమతి cv2 దిగుమతి NumPy NP వంటి చిత్రం = cv2.imread ('Sunflowers.jpg', cv2.IMREAD_GRAYSCALE)

డిఫాల్ట్ పారామితులతో డిటెక్టర్ను సెటప్ చేయండి

డిటెక్టర్ = cv2.SimpleBlobDetector_create ()

బొబ్బలను గుర్తించండి

keypoints = detor.detect (చిత్రం)

గుర్తించిన బొబ్బలను ఎరుపు వృత్తాలుగా గీయండి

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS నిర్ధారించడానికి బొట్టు యొక్క పరిమాణం సర్కిల్ సంబంధించి #size ఖాళీ = np.zeros ((1,1)) blobs = cv2.drawKeypoints (చిత్రం, keypoints, ఖాళీ, (0,255,255), cv2.DRAW_MATCHES_FLAGS_DEFAULT)

కీ పాయింట్లను చూపించు

cv2.imshow ('blobs', blobs) cv2.nightKey (0) cv2.destroyAllWindows ()

కోడ్ బాగా పనిచేసినప్పటికీ, పువ్వుల అసమాన పరిమాణాల కారణంగా కొన్ని బొబ్బలు తప్పిపోతాయి, ఎందుకంటే ముందు భాగంలో ఉన్న పువ్వులు చివర పువ్వులతో పోలిస్తే పెద్దవి.

9. బొబ్బలను వడపోత - లెక్కింపు వృత్తాలు మరియు దీర్ఘవృత్తాలు

బొబ్బలు వాటి ఆకారం, పరిమాణం మరియు రంగు ప్రకారం ఫిల్టర్ చేయడానికి మేము పారామితులను ఉపయోగించవచ్చు. బొట్టు డిటెక్టర్‌తో పారామితులను ఉపయోగించడం కోసం మేము ఓపెన్‌సివి ఫంక్షన్‌ను ఉపయోగిస్తాము

cv2.SimpleBlobDetector_Params ()

ప్రధానంగా క్రింద జాబితా చేయబడిన ఈ నాలుగు పారామితుల ద్వారా బ్లాబ్‌లను ఫిల్టర్ చేయడాన్ని మేము చూస్తాము:

ప్రాంతం

params.filterByArea = ఒప్పు / తప్పుడు params.minArea = పిక్సెల్స్ params.maxArea = పిక్సెల్స్

వృత్తాకార

params.filterByCircularity = ఒప్పు / తప్పుడు params.minCircularity = 1 పరిపూర్ణంగా ఉండటం, 0 వ్యతిరేకం

కుంభాకారం - బొట్టు యొక్క ప్రాంతం / కుంభాకార పొట్టు యొక్క ప్రాంతం

params.filterByConvexity = ఒప్పు / తప్పుడు params.minConvexity = ప్రాంతం

జడత్వం

params.filterByInertia = ఒప్పు / తప్పుడు params.minInertiaRatio = 0.01

ఇప్పుడు పైన పేర్కొన్న పారామితుల ద్వారా బొబ్బలను ఫిల్టర్ చేయడానికి ప్రయత్నిద్దాం

cv2 దిగుమతి సంఖ్యను np image = cv2.imread ('blobs.jpg') cv2.imshow ('అసలైన చిత్రం', చిత్రం) cv2.waitKey (0)

డిఫాల్ట్ పారామితులను ఉపయోగించి డిటెక్టర్ను ప్రారంభించండి

డిటెక్టర్ = cv2.SimpleBlobDetector_create ()

బొబ్బలను గుర్తించండి

keypoints = detor.detect (చిత్రం)

ఎరుపు వృత్తాలుగా మా చిత్రంపై బొబ్బలు గీయండి

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (చిత్రం, కీ పాయింట్లు, ఖాళీ, (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len ( మొత్తం + కీ పాయింట్లు) (లెన్ (కీ పాయింట్స్)) cv2.putText (బ్లాబ్స్, టెక్స్ట్, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)

బొట్టు కీ పాయింట్‌లతో చిత్రాన్ని ప్రదర్శించండి

cv2.imshow ('డిఫాల్ట్ పారామితులను ఉపయోగించి బొట్టు', బొబ్బలు) cv2.nightKey (0)

మా వడపోత పారామితులను సెట్ చేయండి

# cv2.SimpleBlobDetector పారామ్‌లను ఉపయోగించి పారామితి అమరికను ప్రారంభించండి = cv2.SimpleBlobDetector_Params ()

ఏరియా ఫిల్టరింగ్ పారామితులను సెట్ చేయండి

params.filterByArea = నిజమైన params.minArea = 100

వృత్తాకార వడపోత పారామితులను సెట్ చేయండి

params.filterByCircularity = నిజమైన params.minCircularity = 0.9

కుంభాకార వడపోత పరామితిని సెట్ చేయండి

params.filterByConvexity = తప్పుడు params.minConvexity = 0.2

జడత్వం వడపోత పరామితిని సెట్ చేయండి

params.filterByInertia = నిజమైన params.minInertiaRatio = 0.01

పరామితితో డిటెక్టర్ సృష్టించండి

డిటెక్టర్ = cv2.SimpleBlobDetector_create (పారామ్‌లు)

బొబ్బలను గుర్తించండి

keypoints = detor.detect (చిత్రం)

చిత్రాలపై ఎరుపు వృత్తాలుగా బొబ్బలు గీయండి

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (చిత్రం, కీ పాయింట్లు, ఖాళీ, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len ( blobs nobs + వృత్తాకారాలు) str (len (keypoints)) cv2.putText (blobs, text, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

బొబ్బలు చూపించు

cv2.imshow ('వడపోత వృత్తాకార బొబ్బలు', బొబ్బలు) cv2.nightKey (0) cv2.destroyAllWindows ()

కాబట్టి పైథాన్-ఓపెన్‌సివిలో ఇమేజ్ సెగ్మెంటేషన్ చేయవచ్చు. కంప్యూటర్ దృష్టి మరియు ఓపెన్‌సివి గురించి బాగా అర్థం చేసుకోవడానికి, మునుపటి కథనాల ద్వారా వెళ్ళండి (పైథాన్ ఓపెన్‌సివిలో పైథాన్ ఓపెన్‌సివి మరియు ఇమేజ్ మానిప్యులేషన్స్‌తో ప్రారంభించండి మరియు మీరు కంప్యూటర్ విజన్‌తో ఏదైనా చల్లగా చేయగలుగుతారు.