OpenCV (Open Source Computer Vision Library) એ ઇમેજ પ્રોસેસિંગ અને કમ્પ્યુટર વિઝન ટાસ્ક્સ માટે એક શક્તિશાળી ટૂલ છે. આ માર્ગદર્શિકા પાયથન સાથે OpenCV નો ઉપયોગ કરીને સામાન્ય ઇમેજ મેનિપ્યુલેશન ઓપરેશન્સ કરવા માટેના પ્રેક્ટિકલ ઉદાહરણો પૂરા પાડે છે.

અનુક્રમણિકા

અનુક્રમણિકા
ઇન્સ્ટોલેશન અને સેટઅપ
બેઝિક ઇમેજ ઓપરેશન્સ
- ઇમેજ લોડિંગ અને ડિસ્પ્લેઇંગ
- પિક્સેલ્સ એક્સેસ અને મોડિફાય કરવા
ઇમેજ પર ડ્રોઇંગ
- લાઇન્સ અને રેક્ટેંગલ્સ
- સર્કલ્સ અને રેન્ડમ શેપ્સ
ઇમેજ ટ્રાન્સફોર્મેશન્સ
ઇમેજ અરિથમેટિક
બિટવાઇઝ ઓપરેશન્સ
માસ્કિંગ
કલર સ્પેસિસ
હિસ્ટોગ્રામ્સ
ઇમેજ સ્મૂધિંગ
થ્રેશોલ્ડિંગ
- સિમ્પલ થ્રેશોલ્ડિંગ
- એડેપ્ટિવ થ્રેશોલ્ડિંગ
એડ્જ ડિટેક્શન
- ગ્રેડિયન્ટ્સ (સોબેલ અને લેપ્લેસિયન)
- કેની એડ્જ ડિટેક્ટર
કન્ટૂર ડિટેક્શન
કોમન ઇશ્યુઝ ટ્રબલશૂટિંગ
ઉપસંહાર

ઇન્સ્ટોલેશન અને સેટઅપ

શરૂ કરતા પહેલા, ખાતરી કરો કે તમારી પાસે OpenCV ઇન્સ્ટોલ છે:

# pip દ્વારા OpenCV ઇન્સ્ટોલ કરો
pip install opencv-python

# વધારાના મોડ્યુલ્સ માટે (non-free અલ્ગોરિધમ્સ સહિત)
pip install opencv-contrib-python

આ ટ્યુટોરિયલ માટે, અમે OpenCV 4.x નો ઉપયોગ કરીશું, જેમાં જૂના વર્ઝન્સથી કેટલાક સિન્ટેક્સ ડિફરન્સ છે, ખાસ કરીને findContours() જેવા ફંક્શન્સમાં.

બેઝિક ઇમેજ ઓપરેશન્સ

ઇમેજ લોડિંગ અને ડિસ્પ્લેઇંગ

આવો બેસિક્સથી શરૂઆત કરીએ - ઇમેજ લોડ કરવી અને ડિસ્પ્લે કરવી:

import numpy as np
import cv2

# ફાઇલમાંથી ઇમેજ લોડ કરો
img = cv2.imread('path/to/your/image.png')

# ઇમેજને વિન્ડોમાં ડિસ્પ્લે કરો
cv2.imshow('image', img)

# કી પ્રેસની રાહ જુઓ (0 એટલે અનિશ્ચિત સમય સુધી રાહ જુઓ)
cv2.waitKey(0)

# બધી ખુલ્લી વિન્ડો બંધ કરો
cv2.destroyAllWindows()

# તમે રીસાઇઝેબલ વિન્ડો બનાવી શકો છો
cv2.namedWindow('image', cv2.WINDOW_NORMAL)
cv2.imshow('image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

# ઇમેજને નવી ફાઇલમાં સેવ કરો
cv2.imwrite('output.jpg', img)

પિક્સેલ્સ એક્સેસ અને મોડિફાય કરવા

તમે વ્યક્તિગત પિક્સેલ્સ અથવા રીજન્સને એક્સેસ અને મોડિફાય કરી શકો છો:

import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# કોઓર્ડિનેટ્સ (0, 0) પર પિક્સેલ વેલ્યુ એક્સેસ કરો
# નોંધ: OpenCV BGR કલર ઓર્ડર વાપરે છે, RGB નહીં
(b, g, r) = image[0, 0]
print("પિક્સેલ (0, 0) પર - Red: {}, Green: {}, Blue: {}".format(r, g, b))

# પિક્સેલ વેલ્યુ મોડિફાય કરો
image[0, 0] = (0, 0, 255)  # લાલ સેટ કરો
(b, g, r) = image[0, 0]
print("પિક્સેલ (0, 0) પર - Red: {}, Green: {}, Blue: {}".format(r, g, b))

# એક રીજન (ROI - Region of Interest) એક્સેસ કરો
corner = image[0:100, 0:100]
cv2.imshow("Corner", corner)

# કોર્નર રીજનને લીલા રંગમાં સેટ કરો
image[0:100, 0:100] = (0, 255, 0)
cv2.imshow("Updated", image)
cv2.waitKey(0)

ઇમેજ પર ડ્રોઇંગ

લાઇન્સ અને રેક્ટેંગલ્સ

તમે ઇમેજ પર વિવિધ આકારો દોરી શકો છો:

import numpy as np
import cv2

# એક ખાલી કેનવાસ (કાળી ઇમેજ) બનાવો
canvas = np.zeros((300, 300, 3), dtype="uint8")

# ટોપ-લેફ્ટથી બોટમ-રાઇટ સુધી લીલી લાઇન દોરો
green = (0, 255, 0)
cv2.line(canvas, (0, 0), (300, 300), green)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# ટોપ-રાઇટથી બોટમ-લેફ્ટ સુધી જાડી લાલ લાઇન દોરો
red = (0, 0, 255)
cv2.line(canvas, (300, 0), (0, 300), red, 3)  # 3 એ લાઇનની જાડાઈ છે
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# લીલો રેક્ટેંગલ દોરો
cv2.rectangle(canvas, (10, 10), (60, 60), green)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# જાડો લાલ રેક્ટેંગલ દોરો
cv2.rectangle(canvas, (50, 200), (200, 225), red, 5)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# ભરેલો વાદળી રેક્ટેંગલ દોરો
blue = (255, 0, 0)
cv2.rectangle(canvas, (200, 50), (225, 125), blue, -1)  # -1 એટલે ભરેલો
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

સર્કલ્સ અને રેન્ડમ શેપ્સ

આવો સર્કલ્સ (વર્તુળો) દોરીએ:

# નવો ખાલી કેનવાસ બનાવો
canvas = np.zeros((300, 300, 3), dtype="uint8")

# કેનવાસનું કેન્દ્ર શોધો
(centerX, centerY) = (canvas.shape[1] // 2, canvas.shape[0] // 2)
white = (255, 255, 255)

# કોન્સેન્ટ્રિક સર્કલ્સ (એક જ કેન્દ્ર વાળા વર્તુળો) દોરો
for r in range(0, 175, 25):
    cv2.circle(canvas, (centerX, centerY), r, white)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# રેન્ડમ સર્કલ્સ દોરો
for i in range(0, 25):
    # રેન્ડમ ત્રિજ્યા, રંગ અને પોઝિશન જનરેટ કરો
    radius = np.random.randint(5, high=200)
    color = np.random.randint(0, high=256, size=(3,)).tolist()
    pt = np.random.randint(0, high=300, size=(2,))
    
    # સર્કલ દોરો
    cv2.circle(canvas, tuple(pt), radius, color, -1)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

ઇમેજ ટ્રાન્સફોર્મેશન્સ

રોટેશન

ઇમેજને રોટેટ (ફેરવવું) કરવું એ એક સામાન્ય ઓપરેશન છે:

import imutils  # એક કન્વિનિયન્સ પેકેજ (pip install imutils)
import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# ઇમેજના પરિમાણો મેળવો
(h, w) = image.shape[:2]
center = (w // 2, h // 2)

# રોટેશન મેટ્રિક્સ જનરેટ કરો
M = cv2.getRotationMatrix2D(center, 45, 1.0)  # 45 ડિગ્રી, સ્કેલ 1.0
rotated = cv2.warpAffine(image, M, (w, h))
cv2.imshow("45 ડિગ્રી દ્વારા રોટેટેડ", rotated)

# -90 ડિગ્રી દ્વારા રોટેટ કરો
M = cv2.getRotationMatrix2D(center, -90, 1.0)
rotated = cv2.warpAffine(image, M, (w, h))
cv2.imshow("-90 ડિગ્રી દ્વારા રોટેટેડ", rotated)

# imutils કન્વિનિયન્સ ફંક્શનનો ઉપયોગ કરીને
rotated = imutils.rotate(image, 180)
cv2.imshow("180 ડિગ્રી દ્વારા રોટેટેડ", rotated)
cv2.waitKey(0)

રિસાઇઝિંગ

આસ્પેક્ટ રેશિયો જાળવીને ઇમેજનું રિસાઇઝ કરો:

import imutils
import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# પહોળાઈ પર આધારિત રિસાઇઝ
r = 150.0 / image.shape[1]  # પહોળાઈ = 150px બનાવવા માટે રેશિયો ગણો
dim = (150, int(image.shape[0] * r))  # આસ્પેક્ટ રેશિયો જાળવવા માટે નવી ઊંચાઈ ગણો
resized = cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
cv2.imshow("પહોળાઈ દ્વારા રિસાઇઝ્ડ", resized)

# ઊંચાઈ પર આધારિત રિસાઇઝ
r = 50.0 / image.shape[0]  # ઊંચાઈ = 50px બનાવવા માટે રેશિયો ગણો
dim = (int(image.shape[1] * r), 50)  # આસ્પેક્ટ રેશિયો જાળવવા માટે નવી પહોળાઈ ગણો
resized = cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
cv2.imshow("ઊંચાઈ દ્વારા રિસાઇઝ્ડ", resized)
cv2.waitKey(0)

# imutils કન્વિનિયન્સ ફંક્શન્સનો ઉપયોગ કરીને
resized = imutils.resize(image, width=100)
cv2.imshow("ફંક્શન દ્વારા રિસાઇઝ્ડ", resized)
cv2.waitKey(0)

resized = imutils.resize(image, height=50)
cv2.imshow("ફંક્શન દ્વારા રિસાઇઝ્ડ h=50", resized)
cv2.waitKey(0)

ફ્લિપિંગ

ઇમેજને હોરિઝોન્ટલી, વર્ટિકલી, અથવા બંને રીતે ફ્લિપ કરો:

import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# હોરિઝોન્ટલી ફ્લિપ કરો (1)
flipped = cv2.flip(image, 1)
cv2.imshow("હોરિઝોન્ટલી ફ્લિપ્ડ", flipped)

# વર્ટિકલી ફ્લિપ કરો (0)
flipped = cv2.flip(image, 0)
cv2.imshow("વર્ટિકલી ફ્લિપ્ડ", flipped)

# હોરિઝોન્ટલી અને વર્ટિકલી બંને રીતે ફ્લિપ કરો (-1)
flipped = cv2.flip(image, -1)
cv2.imshow("હોરિઝોન્ટલી અને વર્ટિકલી બંને રીતે ફ્લિપ્ડ", flipped)
cv2.waitKey(0)

ક્રોપિંગ

ઇમેજમાંથી ઇન્ટરેસ્ટનો રીજન ક્રોપ કરો:

import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# ક્રોપિંગ એરે સ્લાઇસિંગ [startY:endY, startX:endX] દ્વારા કરવામાં આવે છે
cropped = image[30:120, 240:335]
cv2.imshow("ક્રોપ્ડ", cropped)
cv2.waitKey(0)

ઇમેજ અરિથમેટિક

ઇમેજ અરિથમેટિક અને ઓવરફ્લો હેન્ડલિંગ સમજવું:

import numpy as np
import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# OpenCV ના add/subtract ફંક્શન્સ 8-બિટ ઓવરફ્લોને ક્લેમ્પિંગ દ્વારા હેન્ડલ કરે છે
print("255 નું મેક્સ: {}".format(cv2.add(np.uint8([200]), np.uint8([100]))))  # 255
print("0 નું મિન: {}".format(cv2.subtract(np.uint8([50]), np.uint8([100]))))  # 0

# પરંતુ NumPy રેપ અરાઉન્ડ (મોડ્યુલો 256) કરે છે
print("wrap around: {}".format(np.uint8([200]) + np.uint8([100])))  # 44 (200+100=300, 300%256=44)
print("wrap around: {}".format(np.uint8([50]) - np.uint8([100])))  # 206 (50-100=-50, -50%256=206)

# બ્રાઇટનેસ વધારો
M = np.ones(image.shape, dtype="uint8") * 100
added = cv2.add(image, M)
cv2.imshow("Added", added)

# બ્રાઇટનેસ ઘટાડો
M = np.ones(image.shape, dtype="uint8") * 50
subtracted = cv2.subtract(image, M)
cv2.imshow("Subtracted", subtracted)
cv2.waitKey(0)

બિટવાઇઝ ઓપરેશન્સ

ઇમેજ પર બિટવાઇઝ ઓપરેશન્સ કરો:

import numpy as np
import cv2

# એક રેક્ટેંગલ બનાવો
rectangle = np.zeros((300, 300), dtype="uint8")
cv2.rectangle(rectangle, (25, 25), (275, 275), 255, -1)
cv2.imshow("Rectangle", rectangle)

# એક સર્કલ બનાવો
circle = np.zeros((300, 300), dtype="uint8")
cv2.circle(circle, (150, 150), 150, 255, -1)
cv2.imshow("Circle", circle)

# બિટવાઇઝ AND (બંનેનું ઇન્ટરસેક્શન)
bitwiseAnd = cv2.bitwise_and(rectangle, circle)
cv2.imshow("AND", bitwiseAnd)
cv2.waitKey(0)

# બિટવાઇઝ OR (બંનેનું કોમ્બિનેશન)
bitwiseOr = cv2.bitwise_or(rectangle, circle)
cv2.imshow("OR", bitwiseOr)
cv2.waitKey(0)

# બિટવાઇઝ XOR (નોન-ઓવરલેપિંગ રીજન્સ)
bitwiseXor = cv2.bitwise_xor(rectangle, circle)
cv2.imshow("XOR", bitwiseXor)
cv2.waitKey(0)

# બિટવાઇઝ NOT (પિક્સેલ્સને ઇન્વર્ટ કરે છે)
bitwiseNot = cv2.bitwise_not(circle)
cv2.imshow("NOT", bitwiseNot)
cv2.waitKey(0)

માસ્કિંગ

ચોક્કસ ઇમેજ રીજન્સ પર ફોકસ કરવા માસ્ક એપ્લાય કરો:

import numpy as np
import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# રેક્ટેંગ્યુલર માસ્ક બનાવો
mask = np.zeros(image.shape[:2], dtype="uint8")
(cX, cY) = (image.shape[1] // 2, image.shape[0] // 2)
cv2.rectangle(mask, (cX - 75, cY - 75), (cX + 75, cY + 75), 255, -1)
cv2.imshow("Mask", mask)

# માસ્ક એપ્લાય કરો
masked = cv2.bitwise_and(image, image, mask=mask)
cv2.imshow("ઇમેજ પર માસ્ક એપ્લાય કર્યું", masked)
cv2.waitKey(0)

# સર્ક્યુલર માસ્ક બનાવો
mask = np.zeros(image.shape[:2], dtype="uint8")
cv2.circle(mask, (cX, cY), 100, 255, -1)
masked = cv2.bitwise_and(image, image, mask=mask)
cv2.imshow("Mask", mask)
cv2.imshow("ઇમેજ પર માસ્ક એપ્લાય કર્યું", masked)
cv2.waitKey(0)

કલર સ્પેસિસ

વિવિધ કલર સ્પેસિસ સાથે કામ કરો:

import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# ગ્રેસ્કેલમાં કન્વર્ટ કરો
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("Gray", gray)

# HSV કલર સ્પેસમાં કન્વર્ટ કરો
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
cv2.imshow("HSV", hsv)

# LAB કલર સ્પેસમાં કન્વર્ટ કરો
lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
cv2.imshow("L*a*b*", lab)
cv2.waitKey(0)

હિસ્ટોગ્રામ્સ

ગ્રેસ્કેલ હિસ્ટોગ્રામ્સ

ઇમેજ હિસ્ટોગ્રામ્સની ગણતરી અને વિઝ્યુઅલાઇઝેશન:

from matplotlib import pyplot as plt
import cv2

image = cv2.imread('path/to/your/image.png')
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("Original", image)

# હિસ્ટોગ્રામની ગણતરી
hist = cv2.calcHist([image], [0], None, [256], [0, 256])

# હિસ્ટોગ્રામને પ્લોટ કરો
plt.figure()
plt.title("ગ્રેસ્કેલ હિસ્ટોગ્રામ")
plt.xlabel("બિન્સ")
plt.ylabel("# પિક્સેલ્સ")
plt.plot(hist)
plt.xlim([0, 256])
plt.show()
cv2.waitKey(0)

કલર હિસ્ટોગ્રામ્સ

કલર હિસ્ટોગ્રામ્સની ગણતરી અને વિઝ્યુઅલાઇઝેશન:

from matplotlib import pyplot as plt
import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# ઇમેજને તેના ચેનલ્સમાં વિભાજિત કરો
chans = cv2.split(image)
colors = ("b", "g", "r")

# કલર હિસ્ટોગ્રામને પ્લોટ કરો
plt.figure()
plt.title("'ફ્લેટેન્ડ' કલર હિસ્ટોગ્રામ")
plt.xlabel("બિન્સ")
plt.ylabel("# પિક્સેલ્સ")

for (chan, color) in zip(chans, colors):
    hist = cv2.calcHist([chan], [0], None, [256], [0, 256])
    plt.plot(hist, color=color)
    plt.xlim([0, 256])

# ચેનલ્સની જોડી માટે 2D હિસ્ટોગ્રામ્સ
fig = plt.figure()

# ગ્રીન અને બ્લુ
ax = fig.add_subplot(131)
hist = cv2.calcHist([chans[1], chans[0]], [0, 1], None, [32, 32], [0, 256, 0, 256])
p = ax.imshow(hist, interpolation="nearest")
ax.set_title("G અને B માટે 2D કલર હિસ્ટોગ્રામ")
plt.colorbar(p)

# ગ્રીન અને રેડ
ax = fig.add_subplot(132)
hist = cv2.calcHist([chans[1], chans[2]], [0, 1], None, [32, 32], [0, 256, 0, 256])
p = ax.imshow(hist, interpolation="nearest")
ax.set_title("G અને R માટે 2D કલર હિસ્ટોગ્રામ")
plt.colorbar(p)

# બ્લુ અને રેડ
ax = fig.add_subplot(133)
hist = cv2.calcHist([chans[0], chans[2]], [0, 1], None, [32, 32], [0, 256, 0, 256])
p = ax.imshow(hist, interpolation="nearest")
ax.set_title("B અને R માટે 2D કલર હિસ્ટોગ્રામ")
plt.colorbar(p)

# હિસ્ટોગ્રામના ડાયમેન્શન્સ વિશે માહિતી
print("2D હિસ્ટોગ્રામનો આકાર: {}, {} વેલ્યુઝ સાથે".format(hist.shape, hist.flatten().shape[0]))

# 3D હિસ્ટોગ્રામ (બધી ત્રણ ચેનલ્સ)
hist = cv2.calcHist([image], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256])
print("3D હિસ્ટોગ્રામનો આકાર: {}, {} વેલ્યુઝ સાથે".format(hist.shape, hist.flatten().shape[0]))

plt.show()

હિસ્ટોગ્રામ ઇક્વલાઇઝેશન

હિસ્ટોગ્રામ ઇક્વલાઇઝેશનનો ઉપયોગ કરીને ઇમેજ કોન્ટ્રાસ્ટ સુધારો:

import numpy as np
import cv2

image = cv2.imread('path/to/your/image.png')
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# હિસ્ટોગ્રામ ઇક્વલાઇઝેશન લાગુ કરો
eq = cv2.equalizeHist(image)

# ઓરિજિનલ અને ઇક્વલાઇઝ્ડ ઇમેજને બાજુ-બાજુમાં બતાવો
cv2.imshow("હિસ્ટોગ્રામ ઇક્વલાઇઝેશન", np.hstack([image, eq]))
cv2.waitKey(0)

માસ્ક્ડ હિસ્ટોગ્રામ્સ

ચોક્કસ રીજન્સ માટે હિસ્ટોગ્રામ્સની ગણતરી કરો:

from matplotlib import pyplot as plt
import numpy as np
import cv2

def plot_histogram(image, title, mask=None):
    chans = cv2.split(image)
    colors = ("b", "g", "r")
    plt.figure()
    plt.title(title)
    plt.xlabel("બિન્સ")
    plt.ylabel("# પિક્સેલ્સ")

    for (chan, color) in zip(chans, colors):
        hist = cv2.calcHist([chan], [0], mask, [256], [0, 256])
        plt.plot(hist, color=color)
        plt.xlim([0, 256])

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)
plot_histogram(image, "ઓરિજિનલ ઇમેજ માટે હિસ્ટોગ્રામ")

# માસ્ક બનાવો
mask = np.zeros(image.shape[:2], dtype="uint8")
cv2.rectangle(mask, (15, 15), (130, 100), 255, -1)
cv2.imshow("માસ્ક", mask)

# માસ્ક લાગુ કરો
masked = cv2.bitwise_and(image, image, mask=mask)
cv2.imshow("માસ્ક એપ્લાય કરવું", masked)

# માસ્ક કરેલા રીજન માટે હિસ્ટોગ્રામની ગણતરી કરો
plot_histogram(image, "માસ્ક કરેલી ઇમેજ માટે હિસ્ટોગ્રામ", mask=mask)
plt.show()

ઇમેજ સ્મૂધિંગ

વિવિધ બ્લરિંગ મેથડ્સ લાગુ કરો:

import numpy as np
import cv2

image = cv2.imread('path/to/your/image.png')
cv2.imshow("Original", image)

# એવરેજ બ્લરિંગ
blurred = np.hstack([
    cv2.blur(image, (3, 3)),
    cv2.blur(image, (5, 5)),
    cv2.blur(image, (7, 7))
])
cv2.imshow("એવરેજ્ડ", blurred)
cv2.waitKey(0)

# ગોસિયન બ્લરિંગ (ઓછું બ્લર પરંતુ વધુ નેચરલ)
blurred = np.hstack([
    cv2.GaussianBlur(image, (3, 3), 0),
    cv2.GaussianBlur(image, (5, 5), 0),
    cv2.GaussianBlur(image, (7, 7), 0)
])
cv2.imshow("ગોસિયન", blurred)
cv2.waitKey(0)

# મિડિયન બ્લરિંગ (સોલ્ટ-એન્ડ-પેપર નોઈઝ દૂર કરવા માટે ઉત્તમ)
blurred = np.hstack([
    cv2.medianBlur(image, 3),
    cv2.medianBlur(image, 5),
    cv2.medianBlur(image, 7)
])
cv2.imshow("મિડિયન", blurred)
cv2.waitKey(0)

# બાઇલેટરલ ફિલ્ટરિંગ (બ્લર કરતી વખતે એજ જાળવે છે)
blurred = np.hstack([
    cv2.bilateralFilter(image, 5, 21, 21),
    cv2.bilateralFilter(image, 7, 31, 31),
    cv2.bilateralFilter(image, 9, 41, 41)
])
cv2.imshow("બાઇલેટરલ", blurred)
cv2.waitKey(0)

થ્રેશોલ્ડિંગ

સિમ્પલ થ્રેશોલ્ડિંગ

બાઇનરી થ્રેશોલ્ડિંગ લાગુ કરો:

import cv2

image = cv2.imread('path/to/your/image.png')
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(image, (5, 5), 0)
cv2.imshow("ઇમેજ", image)

# બાઇનરી થ્રેશોલ્ડિંગ
(T, thresh) = cv2.threshold(blurred, 155, 255, cv2.THRESH_BINARY)
cv2.imshow("થ્રેશોલ્ડ બાઇનરી", thresh)

# ઇન્વર્સ બાઇનરી થ્રેશોલ્ડિંગ
(T, threshInv) = cv2.threshold(blurred, 155, 255, cv2.THRESH_BINARY_INV)
cv2.imshow("થ્રેશોલ્ડ બાઇનરી ઇન્વર્સ", threshInv)

# ઓરિજિનલ ઇમેજ પર માસ્ક લાગુ કરો
cv2.imshow("સિક્કા", cv2.bitwise_and(image, image, mask=threshInv))
cv2.waitKey(0)

એડેપ્ટિવ થ્રેશોલ્ડિંગ

એડવાન્સ્ડ થ્રેશોલ્ડિંગ અલ્ગોરિધમ્સ વાપરો:

import mahotas  # pip install mahotas
import cv2

image = cv2.imread('path/to/your/image.png')
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(image, (5, 5), 0)
cv2.imshow("ઇમેજ", image)

# ઓત્સુની મેથડ (ઓટોમેટિકલી ઓપ્ટિમલ થ્રેશોલ્ડ નક્કી કરે છે)
T = mahotas.thresholding.otsu(blurred)
print("ઓત્સુનું થ્રેશોલ્ડ: {}".format(T))

thresh = image.copy()
thresh[thresh > T] = 255
thresh[thresh < 255] = 0
thresh = cv2.bitwise_not(thresh)
cv2.imshow("ઓત્સુ", thresh)

# રિડલર-કાલ્વાર્ડ મેથડ
T = mahotas.thresholding.rc(blurred)
print("રિડલર-કાલ્વાર્ડ: {}".format(T))
thresh = image.copy()
thresh[thresh > T] = 255
thresh[thresh < 255] = 0
thresh = cv2.bitwise_not(thresh)
cv2.imshow("રિડલર-કાલ્વાર્ડ", thresh)
cv2.waitKey(0)

એડ્જ ડિટેક્શન

ગ્રેડિયન્ટ્સ (સોબેલ અને લેપ્લેસિયન)

ગ્રેડિયન્ટ્સનો ઉપયોગ કરીને એડ્જ ડિટેક્ટ કરો:

import numpy as np
import cv2

image = cv2.imread('path/to/your/image.png')
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("Original", image)

# લેપ્લેસિયન ગ્રેડિયન્ટ
lap = cv2.Laplacian(image, cv2.CV_64F)
lap = np.uint8(np.absolute(lap))
cv2.imshow("લેપ્લેસિયન", lap)
cv2.waitKey(0)

# સોબેલ ગ્રેડિયન્ટ (x અને y દિશા)
sobelX = cv2.Sobel(image, cv2.CV_64F, 1, 0)  # x દિશા
sobelY = cv2.Sobel(image, cv2.CV_64F, 0, 1)  # y દિશા

# એબ્સોલ્યુટ વેલ્યુ લો અને 8-બિટમાં કન્વર્ટ કરો
sobelX = np.uint8(np.absolute(sobelX))
sobelY = np.uint8(np.absolute(sobelY))

# બંને દિશાઓને કમ્બાઇન કરો
sobelCombined = cv2.bitwise_or(sobelX, sobelY)

cv2.imshow("સોબેલ X", sobelX)
cv2.imshow("સોબેલ Y", sobelY)
cv2.imshow("સોબેલ કમ્બાઇન્ડ", sobelCombined)
cv2.waitKey(0)

કેની એડ્જ ડિટેક્ટર

કેની એડ્જ ડિટેક્ટરનો ઉપયોગ કરો:

import cv2

image = cv2.imread('path/to/your/image.png')
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
image = cv2.GaussianBlur(image, (5, 5), 0)
cv2.imshow("બ્લર્ડ", image)

# કેની એડ્જ ડિટેક્ટર લાગુ કરો (minVal=30, maxVal=150)
canny = cv2.Canny(image, 30, 150)
cv2.imshow("કેની", canny)
cv2.waitKey(0)

કન્ટૂર ડિટેક્શન

કન્ટૂર્સને ડિટેક્ટ અને પ્રોસેસ કરો:

import numpy as np
import cv2

image = cv2.imread('path/to/your/image.png')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (11, 11), 0)
cv2.imshow("ઇમેજ", image)

# એડ્જીસ ડિટેક્ટ કરો
edged = cv2.Canny(blurred, 30, 150)
cv2.imshow("એડ્જીસ", edged)

# કન્ટૂર્સ શોધો
# નોંધ: OpenCV 4.x માં, ફંક્શન માત્ર કન્ટૂર્સ અને હાયરાર્કી પરત કરે છે
contours, hierarchy = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
print("આ ઇમેજમાં હું {} ઓબ્જેક્ટ્સ ગણું છું".format(len(contours)))

# બધા કન્ટૂર્સ દોરો
coins = image.copy()
cv2.drawContours(coins, contours, -1, (0, 255, 0), 2)
cv2.imshow("સિક્કા", coins)
cv2.waitKey(0)

# દરેક કન્ટૂરને અલગથી પ્રોસેસ કરો
for (i, c) in enumerate(contours):
    # બાઉન્ડિંગ રેક્ટેંગલ મેળવો
    (x, y, w, h) = cv2.boundingRect(c)
    print("ઓબ્જેક્ટ #{}".format(i + 1))
    
    # ઓબ્જેક્ટને એક્સટ્રેક્ટ કરો
    obj = image[y:y + h, x:x + w]
    cv2.imshow("ઓબ્જેક્ટ", obj)
    
    # સર્ક્યુલર માસ્ક બનાવો
    mask = np.zeros(image.shape[:2], dtype="uint8")
    ((centerX, centerY), radius) = cv2.minEnclosingCircle(c)
    cv2.circle(mask, (int(centerX), int(centerY)), int(radius), 255, -1)
    mask = mask[y:y + h, x:x + w]
    
    # માસ્ક લાગુ કરો
    cv2.imshow("માસ્ક કરેલું ઓબ્જેક્ટ", cv2.bitwise_and(obj, obj, mask=mask))
    cv2.waitKey(0)

કોમન ઇશ્યુઝ ટ્રબલશૂટિંગ

અહીં એવી સમસ્યાઓના ઉકેલો છે જે તમને મળી શકે છે:

1. ઇમેજ લોડ થતી નથી

જો તમારી ઇમેજ લોડ થતી નથી, તો ચેક કરો:

ફાઇલનો પાથ સાચો છે
ફાઇલ અસ્તિત્વમાં છે
ફાઇલની પરમિશન્સ યોગ્ય છે
ફાઇલ માન્ય ઇમેજ ફોર્મેટમાં છે

રિલેટિવ પાથને બદલે ફુલ પાથનો ઉપયોગ કરવાનો પ્રયાસ કરો:

img = cv2.imread('/full/path/to/your/image.png')
if img is None:
    print("એરર: ઇમેજ લોડ થઈ શકી નથી")

2. OpenCV વર્ઝન કમ્પેટિબિલિટી

OpenCV 4.x એ કેટલાક ફંક્શન સિગ્નેચર્સ બદલ્યા છે:

જૂનું (OpenCV 3.x):

_, contours, hierarchy = cv2.findContours(...)

નવું (OpenCV 4.x):

contours, hierarchy = cv2.findContours(...)

તમારા OpenCV વર્ઝનને ચેક કરો:

print(cv2.__version__)

3. મોટી ઇમેજીસ સાથે મેમરી એરર્સ

મોટી ઇમેજીસ માટે, ધ્યાનમાં લો:

પહેલા ઇમેજને રિસાઇઝ કરવી
નાના ભાગોમાં પ્રોસેસિંગ કરવું
64-બિટ પાયથનનો ઉપયોગ કરવો
સિસ્ટમ સ્વેપ સ્પેસ વધારવી

4. વિન્ડોઝ બંધ થતી નથી

જો વિન્ડોઝ યોગ્ય રીતે બંધ થતી નથી:

બધી વિન્ડોઝ બંધ કરવા માટે cv2.destroyAllWindows() નો ઉપયોગ કરો
ખાતરી કરો કે બધા cv2.waitKey() કોલ્સ પ્રોસેસ થઈ રહ્યા છે
તમારા કોડમાં ઇન્ફિનિટ લૂપ્સ માટે ચેક કરો

5. ધીમું પરફોર્મન્સ

જો ઓપરેશન્સ ધીમા છે:

શક્ય હોય ત્યાં લૂપ્સની જગ્યાએ NumPy વેક્ટરાઇઝ્ડ ઓપરેશન્સનો ઉપયોગ કરો
મોટી ઇમેજીસને નાના સાઇઝ પર રિસાઇઝ કરો
વધુ કાર્યક્ષમ અલ્ગોરિધમ્સનો ઉપયોગ કરો (દા.ત., CHAIN_APPROX_NONEની જગ્યાએ CHAIN_APPROX_SIMPLE)
ડાયનેમિકલી ગ્રોઇંગને બદલે એરેને પહેલેથી એલોકેટ કરો

6. વિડિયો કેપ્ચર ઇશ્યુઝ

જો તમને વિડિયો સાથે મુશ્કેલી પડે છે:

cap = cv2.VideoCapture(0)  # 0 ડિફોલ્ટ કેમેરા માટે
if not cap.isOpened():
    print("એરર: વિડિયો સોર્સ ખોલી શકાયું નથી")
    exit()

while True:
    ret, frame = cap.read()
    if not ret:
        print("એરર: ફ્રેમ મેળવી શકાતું નથી")
        break
        
    cv2.imshow('વિડિયો', frame)
    
    # બહાર નીકળવા માટે 'q' દબાવો
    if cv2.waitKey(1) == ord('q'):
        break
        
cap.release()
cv2.destroyAllWindows()

7. કલર સ્પેસ કન્વર્ઝન એરર્સ

જો તમને કલર સ્પેસ કન્વર્ઝનમાં એરર્સ આવે છે:

ખાતરી કરો કે ઇમેજમાં કન્વર્ઝન માટે યોગ્ય ચેનલ્સની સંખ્યા છે
તમે માન્ય કન્વર્ઝન કોડનો ઉપયોગ કરી રહ્યા છો તેની ચકાસણી કરો

# BGR થી HSV માં કન્વર્ટ કરો (સાચું)
hsv = cv2.cvtColor(color_image, cv2.COLOR_BGR2HSV)

# આ નિષ્ફળ થશે જો ઇમેજ પહેલેથી જ ગ્રેસ્કેલ હોય
# પહેલા ચેનલ્સની સંખ્યા ચેક કરો
if len(image.shape) == 3:  # કલર ઇમેજ
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
else:
    gray = image  # પહેલેથી જ ગ્રેસ્કેલ

ઉપસંહાર

આ માર્ગદર્શિકા પાયથન માટે OpenCV માં આવશ્યક ઓપરેશન્સને આવરી લે છે. લાયબ્રેરી ઘણી વધુ એડવાન્સ્ડ ફીચર્સ ઓફર કરે છે જે ફેસ ડિટેક્શન, ઓબ્જેક્ટ ટ્રેકિંગ અને મશીન લર્નિંગ ઇન્ટિગ્રેશન જેવા ચોક્કસ એપ્લિકેશન્સ માટે છે.

વધુ એડવાન્સ્ડ ટોપિક્સ માટે, ઓફિશિયલ OpenCV ડોક્યુમેન્ટેશન અને ટ્યુટોરિયલ્સ https://docs.opencv.org/ પર ચેક કરો.

યાદ રાખો કે કમ્પ્યુટર વિઝન એપ્લિકેશન્સમાં ઘણી વખત તમારા ચોક્કસ કેસ માટે શ્રેષ્ઠ પરિણામો મેળવવા માટે પેરામીટર્સ સાથે પ્રયોગ કરવાની જરૂર પડે છે. વિવિધ અભિગમો અજમાવવાથી અને સેટિંગ્સને જરૂરિયાત મુજબ એડજસ્ટ કરવાથી ડરશો નહીં.