K230 OpenCV (cv2) API Reference

Based on K230 CanMV firmware, referencing original OpenCV demos and opencv_demo collection ⚠️ K230 specific limitations marked | 📎 Source code examples included

Color Space Conversion

Example

xxxxxxxxxx
# BGR → Grayscale (preprocessing for edge detection, thresholding, etc.)
gray = cv2.cvtColor(img_np, cv2.COLOR_BGR2GRAY)

# BGR → HSV (must convert before inRange color segmentation)
hsv = cv2.cvtColor(img_np, cv2.COLOR_BGR2HSV)

Geometric Transformation

Example

xxxxxxxxxx
# Horizontal flip
img_np[:,:,:] = cv2.flip(img_np, 1)

# Rotate 45 degrees + scale 0.7x
M = cv2.getRotationMatrix2D((W//2, H//2), 45, 0.7)
img_np[:,:,:] = cv2.warpAffine(img_np, M, (W, H))

# Downsample for speed (commonly used for heavy operations like HoughCircles/matchTemplate)
small = cv2.resize(img_np, (320, 240))
gray = cv2.cvtColor(small, cv2.COLOR_BGR2GRAY)

Thresholding

Example

xxxxxxxxxx
# Fixed threshold 127
ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# OTSU automatic threshold (works better when grayscale brightness is uneven)
ret, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_OTSU)

# Adaptive Gaussian threshold (scenarios with local illumination changes)
binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                cv2.THRESH_BINARY, 11, 2)

Filtering (Blurring)

Example

xxxxxxxxxx
# Gaussian blur for denoising (required before Hough detection)
blur = cv2.GaussianBlur(gray, (7, 7), 1.5)

# Median blur (remove salt-and-pepper noise)
out = cv2.medianBlur(img_np, 7)

# Custom sharpening kernel
sharpen = np.array([[-1.0,-1.0,-1.0],[-1.0,9.0,-1.0],[-1.0,-1.0,-1.0]])
out = cv2.filter2D(img_np, -1, sharpen)

Edge Detection

Example

xxxxxxxxxx
# Canny dual threshold edge detection
edges = cv2.Canny(gray, 80, 200)

# Grayscale output → display
img_out = image.Image(W, H, image.GRAYSCALE, alloc=image.ALLOC_REF, data=edges)
Display.show_image(img_out)

# Color overlay output (white edges + original image)
edges = cv2.Canny(gray, 80, 200)
img_np[:,:,0] = cv2.add(img_np[:,:,0], edges)  # B channel
img_np[:,:,1] = cv2.add(img_np[:,:,1], edges)  # G channel
img_np[:,:,2] = cv2.add(img_np[:,:,2], edges)  # R channel
Display.show_image(img)

Morphology

Example

xxxxxxxxxx
# Create structuring elements
kr = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))     # Rectangular kernel
ke = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))  # Elliptic kernel

# Morphological operations on binary images
ret, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_OTSU)
closed = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kr)    # Closing for hole filling
opened = cv2.morphologyEx(binary, cv2.MORPH_OPEN, ke)     # Opening for denoising

Contour Analysis

Example

xxxxxxxxxx
# Complete contour pipeline
contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnt_limit = 0
for c in contours:
    area = cv2.contourArea(c)
    if area < 500: continue
    cnt_limit += 1
    if cnt_limit > 50: break              # Upper limit to prevent memory overflow

    peri = cv2.arcLength(c, True)
    approx = cv2.approxPolyDP(c, 0.02 * peri, True)   # Polygon approximation

    x, y, w, h = cv2.boundingRect(c)
    cv2.drawContours(img_np, [approx], -1, (0, 255, 0), 2)
    cv2.rectangle(img_np, (x, y), (x + w, y + h), (0, 0, 255), 1)
    cnt_n += 1

# moments for centroid calculation
m = cv2.moments(c)
if m["m00"] > 0:
    cx = int(m["m10"] / m["m00"])
    cy = int(m["m01"] / m["m00"])

Feature Detection

Example

xxxxxxxxxx
# Hough circle detection (downsampled for speed)
small = cv2.resize(img_np, (320, 240))
gray = cv2.cvtColor(small, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (7, 7), 1.5)
circles = cv2.HoughCircles(blur, 3, dp=1, minDist=60, param1=100,
                            param2=70, minRadius=10, maxRadius=100)
if circles is not None:
    for i in range(circles.shape[0]):
        if i >= 30: break
        x = int(circles[i, 0]) * 2    # K230 returns (N,3), not (N,1,3)
        y = int(circles[i, 1]) * 2    # Coordinates ×2 back to 640x480
        r = int(circles[i, 2]) * 2
        cv2.circle(img_np, (x, y), 3, (0, 255, 0), -1)
        cv2.circle(img_np, (x, y), r, (0, 0, 255), 2)

# Template matching
rmap = cv2.matchTemplate(binary, templ, cv2.TM_CCOEFF_NORMED)
minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc(rmap)
if maxVal > 0.6:
    cv2.rectangle(img_np, (maxLoc[0], maxLoc[1]),
                  (maxLoc[0] + TS, maxLoc[1] + TS), (0, 255, 0), 2)

Color Processing

Example

xxxxxxxxxx
# HSV color segmentation + green overlay
hsv = cv2.cvtColor(img_np, cv2.COLOR_BGR2HSV)
lo = np.array([35, 60, 60])   # Green HSV lower bound
hi = np.array([85, 255, 255]) # Green HSV upper bound
mask = cv2.inRange(hsv, lo, hi)
mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, ke)   # Opening for denoising
img_np[:,:,1] = cv2.add(img_np[:,:,1], mask)        # Green channel overlay

Arithmetic and Bitwise Operations

Example

xxxxxxxxxx
# Frame difference (motion detection)
if prev_np is not None:
    out = cv2.absdiff(img_np, prev_np)
    img_np[:,:,:] = out

# Inversion (negative effect)
img_np[:,:,:] = cv2.bitwise_not(img_np)

# ⚠️ add requires same-size arrays (scalar broadcasting not supported)
# Wrong: cv2.add(img_np, 50)
# Correct: pre-allocate same-size array
add50 = np.zeros((H, W, 3), dtype=np.uint8)
for c in range(W): add50[:, c, :] = 50
out = cv2.add(img_np, add50_3ch)

Pixel Transform

Example

xxxxxxxxxx
# Histogram equalization (enhance contrast)
out = cv2.equalizeHist(gray)

# convertScaleAbs: contrast ×1.5 brightness -30
out = cv2.convertScaleAbs(gray, alpha=1.5, beta=-30)

# LUT inversion mapping
lut = np.zeros((256, 1), dtype=np.uint8)
for i in range(256): lut[i, 0] = 255 - i
out = cv2.LUT(gray, lut)

Channel Operations

Example

xxxxxxxxxx
# Split channels, display single channel
b, g, r = cv2.split(img_np)
img_out = image.Image(W, H, image.GRAYSCALE, alloc=image.ALLOC_REF, data=b)
Display.show_image(img_out)

# Channel statistics
avg = cv2.mean(img_np)  # Returns (B_mean, G_mean, R_mean)

Drawing

Example

xxxxxxxxxx
cv2.line(img_np, (50, 80), (250, 80), (0, 255, 0), 3)
cv2.rectangle(img_np, (50, 120), (200, 200), (0, 255, 255), 3)
cv2.circle(img_np, (400, 160), 50, (0, 255, 0), 3)
cv2.ellipse(img_np, (160, 320), (80, 40), 0, 0, 360, (0, 255, 0), 3)
cv2.putText(img_np, "OpenCV K230", (220, 400),
            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2)
cv2.drawMarker(img_np, (400, 260), (0, 255, 0), cv2.MARKER_CROSS, 20, 3)
cv2.arrowedLine(img_np, (300, 80), (500, 80), (255, 0, 0), 3)

# fillPoly for triangle filling
tri = np.array([[80.0, 60.0], [160.0, 60.0], [120.0, 120.0]])
cv2.fillPoly(img_np, [tri], (255, 100, 100), cv2.LINE_AA)

File I/O (REPL exercises, no camera demo)

Display Method Quick Reference

# Color image (after modifying sensor native img, display)
img_np[:,:,:] = cv2.flip(img_np, 1)
Display.show_image(img)

# Grayscale image (cv2 output → image.Image wrapper)
edges = cv2.Canny(gray, 80, 200)
img_out = image.Image(W, H, image.GRAYSCALE, alloc=image.ALLOC_REF, data=edges)
Display.show_image(img_out)

# ⚠️ Color images cannot use image.Image(RGB888, ALLOC_REF) to wrap cv2 output!