પાયથન સાથે OpenCV નો વ્યાપક માર્ગદર્શિકા

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

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

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)

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

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

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

print(cv2.__version__)

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()

# 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  # પહેલેથી જ ગ્રેસ્કેલ