#边缘检测与轮廓提取：Canny算子、霍夫变换、轮廓分析完整指南

import numpy as np
import cv2

def compute_gradient_mag(image):
    """计算Sobel梯度幅值（简化边缘检测演示）"""
    gray = cv2.imread(image, 0) if isinstance(image, str) else image
    # Sobel算子（一阶导数，可检测x/y方向）
    grad_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
    grad_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
    # 计算梯度幅值（归一化到0-255方便显示）
    mag = np.sqrt(grad_x**2 + grad_y**2)
    return cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)

def auto_canny(image, sigma=0.33):
    """
    自动计算Canny阈值的最佳实践（基于图像中值）
    sigma越小，阈值越窄，检测到的边缘越多（可能含噪声）
    sigma越大，阈值越宽，边缘越干净（可能丢失细节）
    """
    gray = cv2.imread(image, 0) if isinstance(image, str) else image
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)  # 前置高斯滤波
    
    v = np.median(blurred)
    lower = int(max(0, (1.0 - sigma) * v))
    upper = int(min(255, (1.0 + sigma) * v))
    return cv2.Canny(blurred, lower, upper)

# 快速调用
edges = auto_canny("test.jpg")
cv2.imshow("Auto Canny", edges)
cv2.waitKey(0)

def detect_lines(image_path):
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    edges = auto_canny(gray)  # 复用前面的自动Canny
    
    # 概率霍夫变换参数
    lines = cv2.HoughLinesP(
        edges,
        rho=1,          # ρ的精度（像素）
        theta=np.pi/180,# θ的精度（弧度，1度）
        threshold=50,   # 累加器阈值（线段上的最小点数）
        minLineLength=50,# 最小线段长度
        maxLineGap=10   # 同一直线上两点的最大间隙（可连接断续线段）
    )
    
    # 绘制检测到的直线
    result = img.copy()
    if lines is not None:
        for x1,y1,x2,y2 in lines[:,0]:
            cv2.line(result, (x1,y1), (x2,y2), (0,255,0), 2)
    return result

def detect_circles(image_path):
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (9,9), 2)  # 强模糊去噪
    
    circles = cv2.HoughCircles(
        blurred,
        cv2.HOUGH_GRADIENT,
        dp=1,           # 累加器分辨率（dp=1时与原图一致）
        minDist=20,     # 圆心之间的最小距离（避免重复检测）
        param1=50,      # Canny的高阈值
        param2=30,      # 圆心检测阈值（越小圆越多）
        minRadius=5,    # 最小半径
        maxRadius=100   # 最大半径
    )
    
    # 绘制圆和圆心
    result = img.copy()
    if circles is not None:
        circles = np.round(circles[0,:]).astype("int")
        for x,y,r in circles:
            cv2.circle(result, (x,y), r, (0,255,0), 2)
            cv2.circle(result, (x,y), 2, (0,0,255), 3)
    return result

def extract_contours(image_path):
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 二值化（也可用自适应二值化处理光照不均）
    _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV)  # 反转：黑前景变白
    
    # 查找轮廓
    # RETR_EXTERNAL：只检测最外层轮廓
    # CHAIN_APPROX_SIMPLE：压缩水平/垂直/对角线的冗余点
    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # 绘制轮廓（-1表示绘制所有轮廓）
    result = img.copy()
    cv2.drawContours(result, contours, -1, (0,255,0), 2)
    return result

def analyze_contour(contour):
    """分析单个轮廓的核心特征"""
    # 1. 基础特征
    area = cv2.contourArea(contour)          # 面积
    perimeter = cv2.arcLength(contour, True) # 周长（True表示闭合）
    
    # 2. 边界矩形
    x,y,w,h = cv2.boundingRect(contour)      # 轴对齐边界矩形
    aspect_ratio = w/h                        # 长宽比
    
    # 3. 圆度（判断是否接近圆）
    circularity = 4 * np.pi * area / (perimeter**2) if perimeter > 0 else 0
    
    # 4. 凸包（判断是否是凸多边形）
    hull = cv2.convexHull(contour)
    solidity = area / cv2.contourArea(hull) if cv2.contourArea(hull) > 0 else 0
    
    return {
        "area": area,
        "perimeter": perimeter,
        "aspect_ratio": aspect_ratio,
        "circularity": circularity,
        "solidity": solidity,
        "bounding_box": (x,y,w,h)
    }

class SimpleShapeDetector:
    def detect(self, contour):
        # 1. 轮廓近似（压缩轮廓的拐点）
        perimeter = cv2.arcLength(contour, True)
        approx = cv2.approxPolyDP(contour, 0.04*perimeter, True)
        vertices = len(approx)
        
        # 2. 核心特征
        features = analyze_contour(contour)
        
        # 3. 形状判断
        if vertices == 3:
            return "Triangle"
        elif vertices == 4:
            return "Square" if 0.95 < features["aspect_ratio"] < 1.05 else "Rectangle"
        elif vertices == 5:
            return "Pentagon"
        elif features["circularity"] > 0.8:
            return "Circle"
        else:
            return "Polygon"
    
    def detect_in_image(self, image_path):
        img = cv2.imread(image_path)
        binary = cv2.threshold(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), 127, 255, cv2.THRESH_BINARY_INV)[1]
        contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        
        result = img.copy()
        for c in contours:
            if cv2.contourArea(c) < 200:  # 过滤小噪声
                continue
            # 识别形状并获取中心点
            shape = self.detect(c)
            M = cv2.moments(c)
            cX = int(M["m10"]/M["m00"]) if M["m00"] !=0 else 0
            cY = int(M["m01"]/M["m00"]) if M["m00"] !=0 else 0
            
            # 绘制结果
            cv2.drawContours(result, [c], -1, (0,255,0), 2)
            cv2.putText(result, shape, (cX-20, cY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
        return result