ఓపెన్‌సివిలో చిత్ర అవకతవకలు (భాగం

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

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

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

• బిట్‌వైస్ ఆపరేషన్స్ మరియు మాస్కింగ్
• కన్వల్యూషన్ & అస్పష్టత
• పదునుపెట్టడం - చిత్రాన్ని తిప్పికొట్టడం
• త్రెషోల్డింగ్ (బైనరైజేషన్)
• విస్ఫారణం, ఎరోషన్, ఓపెనింగ్ / క్లోజింగ్
• ఎడ్జ్ డిటెక్షన్ మరియు ఇమేజ్ ప్రవణతలు
• పెర్స్పెక్టివ్ & అఫైన్ ట్రాన్స్ఫార్మ్
• లైవ్ స్కెచ్ అప్లికేషన్

1. బిట్‌వైస్ ఆపరేషన్స్ మరియు మాస్కింగ్

బిట్‌వైజ్ ఆపరేషన్లు ఇమేజ్ మాస్కింగ్‌లో మీకు సహాయపడతాయి మరియు కొన్ని సాధారణ చిత్రాలను సృష్టించడానికి మీకు సహాయపడతాయి.

ఒక చదరపు తయారు

cv2 దిగుమతి సంఖ్యను np # మేము రెండు కొలతలు మాత్రమే ఉపయోగిస్తాము ఎందుకంటే ఇది గ్రేస్కేల్ చిత్రం, మేము # రంగు చిత్రాన్ని ఉపయోగిస్తుంటే, అప్పుడు మేము ఒక దీర్ఘచతురస్రం = np.zeros ((300,300,3), np.uint8) # చదరపు చదరపు = np.zeros ((300,300), np.uint8) cv2.rectangle (చదరపు, (50,50), (250,250), 255, -1) cv2.imshow ("చదరపు", చదరపు) cv2 ను తయారు చేయడం. waitKey (0)

దీర్ఘవృత్తాన్ని తయారు చేయడం

ellipse = np.zeros ((300,300), np.uint8) cv2.ellipse (దీర్ఘవృత్తాంతం, (150,150), (150,150), 30,0,180,255, -1) cv2.imshow ("దీర్ఘవృత్తాంతం", దీర్ఘవృత్తాంతం) cv2.nightKey (0)

బిట్‌వైజ్ ఆపరేషన్‌లతో ప్రయోగాలు చేస్తున్నారు

రెండు కలిసే చోట మాత్రమే #AND_ చూపిస్తుంది

BitwiseAND = cv2.bitwise_and (చదరపు, దీర్ఘవృత్తాంతం) cv2.imshow ("AND", BitwiseAND) cv2.nightKey (0)

చదరపు లేదా దీర్ఘవృత్తం ఉన్న చోట మాత్రమే #OR_ చూపిస్తుంది

BitwiseOR = cv2.bitwise_or (చదరపు, దీర్ఘవృత్తాంతం) cv2.imshow ("OR", BitwiseOR) cv2.nightKey (0)

#XOR_ స్వయంగా ఉన్న చోట మాత్రమే చూపిస్తుంది

BitwiseXOR = cv2.bitwise_xor (చదరపు, దీర్ఘవృత్తాంతం) cv2.imshow ("XOR", BitwiseXOR) cv2.nightKey (0)

#NOT_ దీర్ఘవృత్తం మరియు NOT ఆపరేషన్‌లో భాగం కాని ప్రతిదాన్ని ఒకే వ్యక్తికి మాత్రమే వర్తింపజేస్తుంది

BitwiseNOT_elp = cv2.bitwise_not (దీర్ఘవృత్తాంతం) cv2.imshow ("NOT_ellipse", BitwiseNOT_elp) cv2.nightKey (0) cv2.destroyAllWindows ()

2. కన్వల్యూషన్ & అస్పష్టత

ఒక కాన్వోల్యూషన్ సాధారణంగా అసలు ఫంక్షన్ యొక్క మార్పు చేసిన వెర్షన్ని ఇది ఒక మూడవ పనిని ఉత్పత్తి రెండు విధులు నిర్వహించేవారు ఒక గణిత ఆపరేషన్ ఉంది.

అవుట్పుట్ చిత్రం = చిత్రం ఫంక్షన్ _{కెర్నల్ పరిమాణం}

లో కంప్యూటర్ విజన్ మేము కెర్నల్ మేము మా చిత్రం పైగా మా మోసగించటం ఫంక్షన్ అమలు ఇది పైగా పరిమాణం తెలుపుటకు వార్తలు ఉపయోగించండి.

అస్పష్టత అనేది ఒక ప్రాంతం (కెర్నల్) లోని పిక్సెల్‌లను సగటున చేసే ఆపరేషన్

ఓపెన్‌సివి కెర్నల్‌లను వర్తింపజేయడం ద్వారా ఒక చిత్రాన్ని అస్పష్టం చేస్తుంది, ఏదైనా పిక్సెల్ యొక్క విలువను వేర్వేరు పొరుగు పిక్సెల్‌లతో కలపడం ద్వారా కెర్నల్ ఎలా మారుతుందో మీకు చెబుతుంది.

సరళంగా చెప్పాలంటే, ఇమేజ్ కన్వల్యూషన్ అనేది ఒక మూలకం వారీగా రెండు మాత్రికల గుణకారం మరియు తరువాత మొత్తం.

కింది ఉదాహరణ ద్వారా మనం దానిని అర్థం చేసుకోవచ్చు.

పైది 3X3 కెర్నల్.

చిత్రాలను ప్రకాశవంతం చేయడం లేదా ముదురు చేయడం వంటివి మాదిరిగానే మేము తీవ్రతను పెంచుతున్నాము లేదా తీవ్రతను తగ్గించాము.

లెట్ యొక్క పరీక్ష opencv పద్ధతి filter2D గొడవ ఫంక్షన్ cv2.filter2D ఇచ్చిన, (చిత్రం, -1, కెర్నల్)

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

# 3x3 కెర్నల్ మాతృకను సృష్టిస్తోంది

kernel_3x3 = np.ones ((3,3), np.float32) / 9

# మేము కెర్నల్‌ను చిత్రంతో కలుపుకోవడానికి cv2.filter2D ని ఉపయోగిస్తాము

blurred = cv2.filter2D (చిత్రం, -1, కెర్నల్_3x3) cv2.imshow ('3x3_blurring', అస్పష్టంగా) cv2.nightKey (0)

# 7x7 కెర్నల్ మాతృకను సృష్టిస్తోంది

kernel_7x7 = np.ones ((7,7), np.float32) / 49

# మేము కెర్నల్‌ను చిత్రంతో కలుపుకోవడానికి cv2.filter2D ని ఉపయోగిస్తాము

blurred = cv2.filter2D (చిత్రం, -1, కెర్నల్_7x7) cv2.imshow ('7x7_blurring', అస్పష్టంగా) cv2.nightKey (0) cv2.destroyAllWindows ()

ఉన్నాయి పద్ధతులు గొడవ ఇతర రకాల చాలా:

cv2.blur - పేర్కొన్న విండోపై సగటు విలువ.

cv2.GaussianBlur - సారూప్యమైనది కాని గాస్సియన్ విండోను ఉపయోగిస్తుంది (మధ్యలో ఉన్న పాయింట్లపై ఎక్కువ ప్రాధాన్యత ఇస్తుంది).

cv2.medianBlur– విండోలోని అన్ని మూలకాల మధ్యస్థాన్ని ఉపయోగిస్తుంది.

cv2.bilateralFilter- అంచులను పదునుగా ఉంచేటప్పుడు బ్లర్స్, ఇది అంచులను మరియు పంక్తి వివరాలను సంరక్షిస్తుంది.

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

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

cv2.blur:

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

# cv2.blur blur = cv2.blur (చిత్రం, (3,3 % ) cv2.imshow ('సగటు', అస్పష్టత) cv2.nightKey (0)

cv2.GaussianBlur:

# cv2.GaussianBlur # బాక్స్ ఫిల్టర్ స్థానంలో, గాస్సియన్ కెర్నల్ గౌస్సియన్ = cv2. గాస్సియన్ బ్లూర్ (ఇమేజ్, (7,7), 0) cv2.imshow ('గాస్సియన్ బ్లర్రింగ్', గాస్సియన్) cv2.nightKey (0)

cv2.medianBlur:

ఇది కెర్నల్ ప్రాంతం క్రింద అన్ని పిక్సెల్‌ల మధ్యస్థం తీసుకుంటుంది మరియు కేంద్ర మూలకం ఈ మధ్యస్థ విలువతో భర్తీ చేయబడుతుంది.

# cv2.medianBlur # కెర్నల్ ప్రాంతం క్రింద ఉన్న అన్ని పిక్సెల్‌ల మధ్యస్థాన్ని తీసుకుంటుంది మరియు సెంట్రల్ ఎలిమెంట్ # ఈ సగటు విలువతో భర్తీ చేయబడింది. మధ్యస్థ = cv2.medianBlur (చిత్రం, 5) cv2.imshow ('మధ్యస్థ గొడవ', సగటు) cv2.waitKey (0)

cv2.bilateralFilter:

అంచులను పదునుగా ఉంచేటప్పుడు శబ్దం తొలగించడంలో ద్వైపాక్షిక చాలా ప్రభావవంతంగా ఉంటుంది

అంచులను పదునైన ద్వైపాక్షిక = cv2.bilateralFilter (చిత్రం, 9,75,75) cv2.imshow ('ద్వైపాక్షిక అస్పష్టత', ద్వైపాక్షిక) cv2.nightKey (0) cv2 ఉంచేటప్పుడు శబ్దం తొలగించడంలో # cv2.bilateralFilter # ద్వైపాక్షిక చాలా ప్రభావవంతంగా ఉంటుంది . destAllWindows ()

చిత్రం డి-శబ్దం-నాన్ లోకల్ అంటే డెనోయిజింగ్

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

# పారామీటర్ తర్వాత ఏదీ వడపోత బలం 'h' కాదు (5-10 మంచి పరిధి) # తదుపరి రంగు భాగాలకు h, మళ్ళీ h వలె అదే విలువగా సెట్ చేయబడింది

dst = cv2.fastNlMeansDenoisingColored (చిత్రం, ఏదీ లేదు, 6,6,7,21) cv2.imshow ('ఫాస్ట్ అంటే డెనోయిస్', dst ) cv2.waitKey (0) cv2.destroyAllWindows ()

స్థానికేతర మార్గాల యొక్క 4 వైవిధ్యాలు ఉన్నాయి

cv2.fastNlMeansDenoising () - ఒకే బూడిద స్థాయి చిత్రం కోసం

cv2.fastNlMeansDenoisingColored () - ఒకే రంగు చిత్రం

cv2.fastNlmeansDenoisingMulti () - ఇమేజ్ సీక్వెన్స్ గ్రేస్కేల్ కోసం

cv2.fastNlmeansDenoisingcoloredMulti () - చిత్ర శ్రేణి రంగు కోసం

3. పదునుపెట్టడం - చిత్రాన్ని తిప్పికొట్టడం

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

కెర్నల్ =,

మా కెర్నల్ మాతృక ఒకటి వరకు ఉంటుంది, కాబట్టి సాధారణీకరించాల్సిన అవసరం లేదు (అనగా అసలు మాదిరిగానే అదే ప్రకాశానికి కారకం ద్వారా గుణించాలి), కెర్నల్ 1 కు సాధారణీకరించబడకపోతే చిత్రం ప్రకాశవంతంగా లేదా ముదురు రంగులో ఉంటుంది.

దిగుమతి cv2 దిగుమతి NumPy NP వంటి చిత్రం = cv2.imread ('elephant.jpg') cv2.imshow ('అసలు', చిత్రం) cv2.waitKey (0)

kernel_sharpening = np.array (,

])

# ఇన్‌పుట్ చిత్రానికి పదునుపెట్టే కెర్నల్‌ను వర్తింపజేయడం

పదునుపెట్టిన = cv2.filter2D (చిత్రం, -1, కెర్నల్_షార్పెనింగ్) cv2.imshow ('పదునుపెట్టిన చిత్రం', పదునుపెట్టింది) cv2.nightKey (0) cv2.destroyAllWindows ()

4. త్రెషోడింగ్ (బైనరైజేషన్)

త్రెషోల్డింగ్ అనేది ఒక చిత్రాన్ని బైనరీ రూపంలోకి మార్చే చర్య. ఓపెన్‌సివిలో థ్రెషోల్డింగ్ కోసం ప్రత్యేక ఫంక్షన్ ఉంది

Cv2.threshold (చిత్రం, ప్రవేశ విలువ, గరిష్ట విలువ, ప్రవేశ రకం)

కింది ప్రవేశ రకాలు ఉన్నాయి:

• cv2.THRESH_BINARY - సర్వసాధారణం
• cv2. THRESH_BINARY_INV - సర్వసాధారణం
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• cv2. THRESH_TOZERO_INV

గమనిక: థ్రెషోల్డ్‌కు ముందు చిత్రాన్ని గ్రేస్‌కేల్‌గా మార్చడానికి చిత్రం అవసరం

దిగుమతి cv2 దిగుమతి NumPy NP వంటి గ్రేస్కేల్ వంటి #load చిత్రం చిత్రం = cv2.imread ('gradient.jpg', 0) cv2.imshow ('అసలు', చిత్రం) cv2.waitKey (0)

# విలువ 127 కన్నా తక్కువ 0 (నలుపు), మరియు 127 పైన 255 (తెలుపు) కి వెళ్తుంది

_, thresh1 = cv2.threshold (చిత్రం, 127,255, cv2.THRESH_BINARY) cv2.imshow ('1 ప్రవేశ', త్రెష్ 1) cv2.nightKey (0)

127 కంటే తక్కువ # విలువ 255 కి మరియు 127 పైన ఉన్న విలువలు 0 కి వెళ్తాయి (పై రివర్స్)

_, thresh2 = cv2.threshold (చిత్రం, 127,255, cv2.THRESH_BINARY_INV) cv2.imshow ('2 ప్రవేశ', త్రెష్ 2) cv2.nightKey (0)

127 పైన ఉన్న # విలువ 127 వద్ద కత్తిరించబడింది (ఉంచబడింది), 255 వాదన ఉపయోగించబడదు.

_, thresh3 = cv2.threshold (చిత్రం, 127,255, cv2.THRESH_TRUNC) cv2.imshow ('3 త్రెష్ ట్రంక్', త్రెష్ 3) cv2.nightKey (0)

127 కంటే తక్కువ # విలువలు 0 కి వెళ్తాయి, 127 పైన మారవు

_, thresh4 = cv2.threshold (చిత్రం, 127,255, cv2.THRESH_TOZERO) cv2.imshow ('4 ప్రవేశ', త్రెష్ 4) cv2.nightKey (0)

పైన పేర్కొన్న # రివర్స్, 127 కన్నా తక్కువ, 127 పైన సున్నాకి వెళుతుంది

_, thresh5 = cv2.threshold (చిత్రం, 127.255, cv2.THRESH_TOZERO_INV) cv2.imshow ('5 ప్రవేశ', thresh5) cv2.waitKey (0) cv2.destroyAllWindows ()

5. విస్ఫారణం, ఎరోషన్, ఓపెనింగ్ / క్లోజింగ్

గణిత పదనిర్మాణ శాస్త్రంలో ఇవి ఆపరేషన్లు

డైలేషన్ - ఇది చిత్రంలోని వస్తువు యొక్క సరిహద్దులకు పిక్సెల్‌లను జోడిస్తుంది.

ఎరోషన్ - చిత్రంలోని వస్తువు సరిహద్దుల వద్ద పిక్సెల్‌లను తొలగిస్తుంది.

ఓపెనింగ్ - ఎరోషన్ తరువాత డైలేషన్.

మూసివేయడం - విస్ఫోటనం తరువాత కోత.

చిత్రాలను మొదట కోతకు గురిచేస్తుంది (శబ్దాన్ని తొలగిస్తుంది) మరియు దానిని విడదీస్తుంది కాబట్టి చిత్రాలను డీనోయిజ్ చేయడానికి తెరవడం చాలా సహాయపడుతుంది.

విస్ఫోటనం మరియు కోతతో గందరగోళం

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

గుర్తుంచుకోండి, వ్యాకోచాన్ని అయితే ఒక చిత్రం లో వస్తువులు సరిహద్దులను పిక్సెల్స్ జతచేస్తుంది ఎరోజన్ ఒక చిత్రం వస్తువులను సరిహద్దుల వద్ద పిక్సెళ్ళు తొలగిస్తుంది

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

# ఎరోషన్

# మన కెర్నల్ పరిమాణాన్ని నిర్వచించుకుందాం

kernel = np.ones ((5,5), np.uint8)

# ఇప్పుడు మేము చిత్రాన్ని క్షీణింపజేస్తాము, ఇక్కడ పునరావృతం మీరు చిత్రాన్ని ఎరోడ్ చేయాలనుకుంటున్నది కాదు

ఎరోషన్ = సివి 2.రోడ్ (ఇమేజ్, కెర్నల్, పునరావృత్తులు = 1) సివి 2.ఇమ్‌షో ('ఎరోషన్', ఎరోషన్) సివి 2.వైట్‌కే (0)

# డైలేషన్

dilation = cv2.dilate (చిత్రం, కెర్నల్, పునరావృత్తులు = 1) cv2.imshow ('డైలేషన్', డైలేషన్) cv2.nightKey (0)

# తెరవడం, శబ్దాన్ని తొలగించడానికి మంచిది

ఓపెనింగ్ = cv2.morphologyEx (చిత్రం, cv2.MORPH_OPEN, కెర్నల్) cv2.imshow ('ఓపెనింగ్', ఓపెనింగ్) cv2.nightKey (0)

# మూసివేయడం, శబ్దాన్ని తొలగించడానికి మంచిది

closeing = cv2.morphologyEx (చిత్రం, cv2.MORPH_CLOSE, కెర్నల్) cv2.imshow ('మూసివేయడం', మూసివేయడం) cv2.nightCey (0) cv2.destroyAllWindows ()

6. ఎడ్జ్ డిటెక్షన్ మరియు ఇమేజ్ ప్రవణతలు

కంప్యూటర్ దృష్టిలో ఎడ్జ్ డిటెక్షన్ చాలా ముఖ్యమైన ప్రాంతం, ముఖ్యంగా ఆకృతులతో వ్యవహరించేటప్పుడు.

అంచులను చిత్ర సరిహద్దులుగా నిర్వచించవచ్చు, వాస్తవానికి అవి చిత్రాలలో వస్తువును నిర్వచించే అంచులు, అవి చిత్రం గురించి చాలా సమాచారాన్ని సంరక్షిస్తాయి.

అధికారికంగా అంచులను చిత్రంలోని ఆకస్మిక మార్పులు (నిలిపివేతలు) గా నిర్వచించవచ్చు మరియు అవి పిక్సెల్‌ల వలె ఎక్కువ సమాచారాన్ని ఎన్‌కోడ్ చేయవచ్చు.

కంప్యూటర్ దృష్టి చిత్రాన్ని ఎలా గుర్తిస్తుంది మరియు గుర్తిస్తుందో పై చిత్రం చూపిస్తుంది.

ఎడ్జ్ డిటెక్షన్ అల్గోరిథంలు: - ఎడ్జ్ డిటెక్షన్ అల్గోరిథంలలో మూడు ప్రధాన రకాలు ఉన్నాయి

• సోబెల్ - నిలువు లేదా క్షితిజ సమాంతర చిత్రాలకు ప్రాధాన్యత ఇవ్వడం.
• లాప్లాసియన్ - తక్కువ లోపం రేటు, బాగా నిర్వచించిన అంచులు మరియు ఖచ్చితమైన గుర్తింపు కారణంగా సరైనది.
• కాన్నీ ఎడ్జ్ డిటెక్షన్ అల్గోరిథం (1986 లో జాన్.ఎఫ్.కానీ చేత పంపిణీ చేయబడింది)

1. గాస్సియన్ బ్లర్ వర్తిస్తుంది

2. చిత్రం యొక్క తీవ్రత ప్రవణతను కనుగొంటుంది

3. గరిష్టం కాని అణచివేతను వర్తింపజేస్తుంది (అనగా అంచులు లేని పిక్సెల్‌లను తొలగిస్తుంది).

4. హిస్టెరిసిస్ ప్రవేశాన్ని వర్తిస్తుంది (అనగా పిక్సెల్ ఎగువ మరియు దిగువ ప్రవేశంలో ఉంటే, అది అంచుగా పరిగణించబడుతుంది)

cv2 దిగుమతి సంఖ్యను np image = cv2.imread ('input.jpg', 0) ఎత్తు, వెడల్పు = image.shape

# సోబెల్

# సోబెల్ అంచులను ఎక్స్‌ట్రాక్ట్ చేస్తోంది

sobel_x = cv2.Sobel (చిత్రం, cv2.CV_64F, 0,1, ksize = 5) sobel_y = cv2.Sobel (చిత్రం, cv2.CV_64F, 1,0, ksize = 5) cv2.imshow ('అసలు', చిత్రం) cv2.waitKey (0) cv2.imshow ('sobelx', sobel_x) cv2.nightKey (0)

# తెలివిగా

cv2.imshow ('sobely', sobel_y) cv2.nightKey (0)

sobel_OR = cv2.bitwise_or (sobel_x, sobel_y) cv2.imshow ('sobelOR', sobel_OR) cv2.nightKey (0)

#laplaian

laplacian = cv2.Laplacian (చిత్రం, cv2.CV_64F) cv2.imshow ('లాప్లాసియన్', లాప్లాసియన్) cv2.nightKey (0)

# కన్నీ ఎడ్జ్ డిటెక్షన్ అల్గోరిథం ప్రవణత విలువలను

పరిమితులుగా ఉపయోగిస్తుంది.

థ్రెషోల్డ్ 2 కంటే పెద్ద # ప్రవణత ఒక అంచుగా పరిగణించబడుతుంది.

థ్రెషోల్డ్ 1 కంటే పెద్ద ప్రవణత అంచుగా పరిగణించబడదు.

ప్రవేశ 1 మరియు ప్రవేశ 2 మధ్య లో #values గాని అంచు లేదా non-అంచు విధంగా ఉన్నాయి

ఇందులో, వారి తీవ్రతలను ఎలా కనెక్ట్ #on కేసు క్రింద 60 ఏ విలువ ఉంటాయి భావిస్తారు

అంచులు #non wheareas పైన 120 ఏ విలువ అంచులు వలె భావిస్తారు.

canny = cv2.Canny (చిత్రం, 60,120) cv2.imshow ('canny', canny ) cv2.nightKey (0) cv2.destroyAllWindows ()

14. పెర్స్పెక్టివ్ & అఫైన్ ట్రాన్స్ఫార్మ్

ఒక అడుగు వెనక్కి తీసుకుందాం మరియు అఫిన్ మరియు నాన్-అఫైన్ పరివర్తనలను పరిశీలిద్దాం, క్రింద చూపిన అసలు చిత్రం స్పష్టంగా నాన్ అఫిన్ ఇమేజ్, ఎందుకంటే అంచులు ఏదో ఒక సమయంలో కలుసుకోబోతున్నాయి, అయితే, మేము దానిని వార్పింగ్ మరియు దృక్పథాన్ని తీసుకోవడం ద్వారా నిఠారుగా చేయవచ్చు రూపాంతరం.

ఈ దృక్పథ పరివర్తన కోసం మనకు అసలు చిత్రం యొక్క నాలుగు కోఆర్డినేట్లు అవసరం, ఆపై అవుట్పుట్ ఇమేజ్ యొక్క నాలుగు పాయింట్లు అవసరం, అవి పాయింట్స్_ఏ మరియు పాయింట్స్_బి ద్వారా సూచించబడతాయి. మొదట ఈ పాయింట్ల సహాయంతో మేము ట్రాన్స్ఫర్మేషన్ మ్యాట్రిక్స్, M ను గెట్పెర్స్పెక్టివ్ ట్రాన్స్ఫార్మ్ ఫంక్షన్ సహాయంతో లెక్కిస్తాము.

ఆపై ఈ మాతృక తుది ఉత్పత్తిని ఉత్పత్తి చేయడానికి వార్ప్‌పెర్స్పెక్టివ్ ఫంక్షన్‌కు ఇవ్వబడుతుంది.

ఇప్పుడు మొదట పెర్స్పెక్టివ్ ట్రాన్స్ఫార్మ్ ను ప్రయత్నిద్దాం.

cv2 దిగుమతి నంపీని np దిగుమతి matplotlib.pyplot గా plt image = cv2.imread ('paper.jpg') cv2.imshow ('అసలు', చిత్రం) cv2.nightKey (0)

అసలు చిత్రం యొక్క 4 మూలల # సమన్వయం

points_A = np.float32 (,,,])

కావలసిన అవుట్పుట్ యొక్క 4 మూలల #

కోఆర్డినేట్లు # మేము A4 పేపర్ 1: 1.41 యొక్క నిష్పత్తిని ఉపయోగిస్తాము

points_B = np.float32 (,,,])

# పరివర్తన పరివర్తన మాతృక, M ను లెక్కించడానికి రెండు పాయింట్ల రెండు సెట్లను ఉపయోగించండి

M = cv2.getPerspectiveTransform (points_A, points_B) వార్పేడ్ = cv2.warpPerspective (చిత్రం, M, (420,594)) cv2.imshow ('warpprespective', వంచబడని) cv2.waitKey (0) cv2.destroyAllWindows ()

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

cv2 దిగుమతి సంఖ్యను np దిగుమతి matplotlib.pyplot గా plt image = cv2.imread ('box.jpg') అడ్డు వరుసలు, cols = image.shape cv2.imshow ('అసలు', చిత్రం) cv2.nightKey (0)

అసలు చిత్రం యొక్క 3 మూలల # సమన్వయం

points_A = np.float32 (,,])

కావలసిన అవుట్పుట్ యొక్క 3 మూలల #

కోఆర్డినేట్లు # మేము A4 కాగితం 1: 1.41 యొక్క నిష్పత్తిని ఉపయోగిస్తాము

points_B = np.float32 (,,])

# అఫిన్

# ట్రాన్స్ఫర్మేషన్ మ్యాట్రిక్స్, M.

M = cv2.getAffineTransform (points_A, points_B) వార్పేడ్ = cv2.warpAffine (చిత్రం, M, (కాలమ్లు, వరుసలు)) cv2.imshow ('warpaffine', వంచబడని) cv2.waitKey (0) cv2.destroyAllWindows ()

8. లైవ్ స్కెచ్ అప్లికేషన్

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

కాబట్టి ఈ ప్రోగ్రామ్ ప్రారంభంలో మనం “ డెఫ్ స్కెచ్ (ఇమేజ్) ” క్రింద ఒక నిర్దిష్ట సమూహ ప్రకటనలను చూడవచ్చు : ఇది ఒక ఫంక్షన్ యొక్క అధికారిక నిర్వచనం, ఒక నిర్దిష్ట అవుట్పుట్ కోసం స్టేట్మెంట్ల సమూహం కలిసి పనిచేస్తుంది.

కాబట్టి ఈ స్కెచ్ ఒక ఫంక్షన్, పైథాన్ ఫంక్షన్ “డెఫ్” చేత నిర్వచించబడింది మరియు “:” గుర్తుతో ముగుస్తుంది. ఫంక్షన్ లోపల ఉండటానికి అవసరమైన స్టేట్మెంట్లు లేదా ఫంక్షన్ సరిగ్గా పనిచేయడానికి అవసరమైనవి మీరు చెప్పవచ్చు, ఫంక్షన్ ద్వారా స్వయంచాలకంగా సమలేఖనం చేయబడతాయి. కాబట్టి ఫంక్షన్ల నుండి బయటకు రావడానికి అవసరమైన స్టేట్మెంట్లను పూర్తిగా సమలేఖనం చేయాలి. తదుపరి సూచనల కోసం మీరు పైథాన్‌లో విధులు ఎలా నిర్వచించబడతాయనే దానిపై గూగుల్‌ను చూడవచ్చు.

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

గమనిక కూడా ఆ ఫంక్షన్ వాదనలు చిత్రం పడుతుంది మరియు రెండు వాదనలు RET మరియు ముసుగు తిరిగి. రిట్ అనేది బూలియన్ అయితే ఫంక్షన్ విజయవంతంగా నడుస్తుందో లేదో మరియు మాస్క్ ఫంక్షన్ యొక్క తుది అవుట్పుట్ అనగా ప్రాసెస్ చేయబడిన చిత్రం.

అప్పుడు రెండవ భావన opencv లో ఆపరేటింగ్ వెబ్క్యామ్ ఉంది ద్వారా జరుగుతుంది cv2.VideoCapture (0) ఫంక్షన్, ఒక వస్తువు చిత్రం నిల్వ ఇది క్యాప్ మూతతో చదవగల cap.read () గమనించండి ఫంక్షన్ కూడా ఇక్కడ టోపీ. చదవండి () అనంతం లోపల ఉంటుంది, అయితే ఇది చిత్రాలను నిరంతరం సంగ్రహించవలసి ఉంటుంది, దీనికి ప్రత్యక్ష వీడియో యొక్క భావాన్ని ఇస్తుంది, ఇక్కడ వీడియో యొక్క ఫ్రేమ్ రేట్ మీ వెబ్‌క్యామ్ యొక్క ఫ్రేమ్ రేటుగా ఉంటుంది, ఇది ఎక్కువగా 24 నుండి 60 మధ్య ఉంటుంది fps.

cap.read () రిట్ మరియు ఫ్రేమ్‌ను అందిస్తుంది, ఇక్కడ ఫంక్షన్ విజయవంతంగా నడుస్తుందో లేదో సూచించే బూలియన్ మరియు ఫ్రేమ్ వెబ్‌క్యామ్ తీసిన చిత్రాన్ని కలిగి ఉంటుంది.

లైవ్ స్కెచ్‌ను అమలు చేయడానికి పూర్తి పైథాన్ ఓపెన్‌సివి కోడ్ క్రింద ఉంది

దిగుమతి cv2 దిగుమతి NumPy NP వంటి #sketch రూపొందిస్తున్న ఫంక్షన్ డెఫ్ స్కెచ్ (చిత్రం): కు #convert చిత్రం గ్రేస్కేల్ img_gray = cv2.cvtColor (చిత్రం, cv2.COLOR_BGR2GRAY) ఉపయోగించి గాస్సియన్ బ్లర్ చిత్రం అప్ #cleaning img_gray_blur = cv2.GaussianBlur (img_gray, (5,5), 0) #extract అంచులు canny_edges = cv2.Canny (img_gray_blur, 10,70) ఒక విలోమం binarize చిత్రం #do విశ్రాంత, ముసుగు = cv2.threshold (canny_edges, 70.255, cv2.THRESH_BINARY_INV) తిరిగి ముసుగు #initialize వెబ్క్యామ్, టోపీ అనేది వీడియో క్యాప్చర్ అందించిన వస్తువు # ఇది విజయవంతమైందో లేదో సూచించే బూలియన్ కలిగి ఉంది (ret) #it కూడా వెబ్క్యామ్ (ఫ్రేమ్) నుండి సేకరించిన చిత్రాలను కలిగి క్యాప్ = cv2.VideoCapture (0) ట్రూ అయితే: విశ్రాంత, ఫ్రేమ్ = cap.read () cv2.imshow ('livesketcher', స్కెచ్ (ఫ్రేమ్)) cv2.waitKey ఉంటే (1) == 13: # 13 enterkey ఉంది విరామం #release కెమెరా మరియు విండోను, cap.release సహాయంతో () తో వెబ్క్యామ్ విడుదల గుర్తుంచుకోండి cap.release () (cv2.destroyAllWindows)

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