assembly-opencv 1.0.0__py3-none-any.whl

assembly/CornerDetection.py

@@ -0,0 +1,117 @@
+import cv2
+import numpy as np
+
+from assembly.description.Decoration import func_description, class_description
+
+'''
+角点检测算子
+
+输入：灰度图
+输出：角点坐标列表
+'''
+
+
+@class_description(
+    title="角点检测",
+    description="角点检测算子是一种图像特征提取技术，用于检测图像中的特征点，如角点、边缘、斑点等。",
+    level=9
+)
+class CornerDetection(object):
+
+    @func_description(
+        title="角点检测Harris算法:",
+        description="基于图像局部灰度变化，通过计算像素点在x/y 方向的梯度，构建结构张量矩阵（梯度自相关矩阵），再通过响应函数判断是否为角点"
+    )
+    @staticmethod
+    def corner_harris(gray):
+        """
+        :name Harris角点检测
+        :param gray: 单通道图
+        :return list:角点坐标列表
+        """
+
+        image_float = np.float32(gray)
+        dst = cv2.cornerHarris(image_float, blockSize=2, ksize=3, k=0.04)
+        dst = cv2.dilate(dst, None)
+        ret, dst = cv2.threshold(dst, 0.01 * dst.max(), 255, 0)
+        dst = np.uint8(dst)
+        ret, labels, stats, centroids = cv2.connectedComponentsWithStats(dst)
+        result = [[stats[i][0], stats[i][1]] for i in range(1, ret)]
+        return result
+
+    @func_description(
+        title="角点检测Shi-Tomasi算法:",
+        description="Harris 算法的改进版，直接利用矩阵 M 的最小特征值判断角点"
+    )
+    @staticmethod
+    def corner_shi_tomasi(gray):
+        """
+        :name Shi-Tomasi角点检测
+        :param gray: 单通道图
+        :return list:角点坐标列表
+        """
+        corners = cv2.goodFeaturesToTrack(gray, maxCorners=100, qualityLevel=0.01, minDistance=10)
+        corners = np.intp(corners)
+        print(corners.reshape(-1, 2).tolist())
+        print(corners[0].ravel)
+        result = [[i.ravel] for i in corners]
+        return result
+
+    @func_description(
+        title="角点检测FAST算法:",
+        description="基于像素灰度差异的高效角点检测算法，不直接用于角点检测，但可以用于特征匹配"
+    )
+    @staticmethod
+    def corner_fast(gray, threshold=30, nonmaxSuppression=True):
+        """
+        :name FAST角点检测
+        :param gray: 单通道图
+        :param threshold: 阈值
+        :param nonmaxSuppression: 是否关闭非极大值抑制
+        :return list:角点坐标列表
+        """
+
+        fast = cv2.FastFeatureDetector_create(threshold=threshold)
+
+        if nonmaxSuppression:
+            # 关闭非极大值抑制
+            fast.setNonmaxSuppression(0)
+        # 检测图像上的关键点
+        kp = fast.detect(gray, None)
+
+        result = [[point.pt] for point in kp]
+        return result
+
+
+# def corner_SIFT(gray):
+#     # 使用SIFT检测关键点并计算描述符
+#     sift = cv2.SIFT_create()
+#     keypoints, descriptors = sift.detectAndCompute(gray, None)
+#
+#     # 在图像上绘制关键点（实际上是特征点）
+#     image_with_keypoints = cv2.drawKeypoints(gray, keypoints, None, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
+#     return image_with_keypoints
+
+
+# 暴露方法
+def corner_detection_fast(gray_img, threshold=30, nonmaxSuppression=True):
+    return CornerDetection.corner_fast(gray_img, threshold, nonmaxSuppression)
+
+def corner_detection_shi_tomasi(gray_img):
+    return CornerDetection.corner_shi_tomasi(gray_img)
+
+def corner_detection_harris(gray_img):
+    return CornerDetection.corner_harris(gray_img)
+
+
+if __name__ == '__main__':
+    corner_detection = CornerDetection()
+    img = cv2.imdecode(np.fromfile(r"C:\Users\GT-LAPTOP-043\Downloads\黑白格.jpg", dtype=np.uint8),
+                       cv2.IMREAD_COLOR)
+    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    # show_image("gray_img", gray_img, 500, 500)
+    print("corner_harris", corner_detection.corner_harris(gray_img))
+    print("corner_shi_tomasi", corner_detection.corner_shi_tomasi(gray_img))
+    print("corner_fast", corner_detection.corner_fast(gray_img))
+
+    cv2.destroyAllWindows()

assembly/DrawImage.py

@@ -0,0 +1,297 @@
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+from assembly.description.Decoration import func_description, class_description
+from assembly.GeneralUtil import show_image
+
+'''
+绘制图像
+
+输入：原始图
+输出：原始图
+'''
+
+
+@class_description(
+    title="绘制图像",
+    description="在图像上绘制轮廓，包括点，线，矩形，圆等基本图形",
+    level=2
+)
+class DrawImage(object):
+
+    @func_description(
+        title="生成空白图像",
+        description="生成指定大小和颜色的空白图像"
+    )
+    @staticmethod
+    def generate_blank_image(width, height, color=(0, 0, 0)):
+        """
+        :name 生成空白图像
+        :param width: 图像宽度
+        :param height: 图像高度
+        :param color: 图像颜色
+        :return img: 空白图像
+        """
+        img = np.zeros((height, width, 3), np.uint8)
+        img[:] = color
+
+        return img
+
+    @func_description(
+        title="绘制轮廓",
+        description="在图像上绘制轮廓"
+    )
+    @staticmethod
+    def draw_contours(img, contours, contour_color=(0, 255, 0), thickness=2):
+        """
+        :name 绘制轮廓
+        :param img: 原始图
+        :param contours: 轮廓列表
+        :param contour_color: 轮廓颜色
+        :param thickness: 轮廓线宽
+        :return img: 绘制轮廓后的图像
+        """
+        img_draw = img.copy()
+        cv2.drawContours(img_draw, contours, -1, contour_color, thickness)
+
+        return img_draw
+
+    @func_description(
+        title="绘制点",
+        description="在图像上绘制点"
+    )
+    @staticmethod
+    def draw_points(img, points, point_color=(0, 0, 255), thickness=2):
+        """
+        :name 绘制点
+        :param img: 原始图
+        :param points: 点列表，格式为 [(x1, y1), (x2, y2), ...]
+        :param point_color: 点颜色
+        :param thickness: 点大小
+        :return img: 绘制点后的图像
+        """
+        img_draw = img.copy()
+        for point in points:
+            cv2.circle(img_draw, point, thickness, point_color, -1)
+
+        return img_draw
+
+    @func_description(
+        title="绘制线",
+        description="在图像上绘制线"
+    )
+    @staticmethod
+    def draw_lines(img, lines, line_color=(0, 255, 255), thickness=2):
+        """
+        :name 绘制线
+        :param img: 原始图
+        :param lines: 线列表，格式为 [(x1, y1, x2, y2), (x3, y3, x4, y4), ...]
+        :param line_color: 线颜色
+        :param thickness: 线宽
+        :return img: 绘制线后的图像
+        """
+        img_draw = img.copy()
+        for line in lines:
+            cv2.line(img_draw, (line[0], line[1]), (line[2], line[3]), line_color, thickness)
+
+        return img_draw
+
+    @func_description(
+        title="绘制矩形",
+        description="在图像上绘制矩形"
+    )
+    @staticmethod
+    def draw_rectangles(img, rectangles, rectangle_color=(255, 0, 0), thickness=2):
+        """
+        :name 绘制矩形
+        :param img: 原始图
+        :param rectangles: 矩形列表，格式为 [(x1, y1, w, h), (x2, y2, w, h), ...]
+        :param rectangle_color: 矩形颜色
+        :param thickness: 矩形线宽
+        :return img: 绘制矩形后的图像
+        """
+        img_draw = img.copy()
+        for rectangle in rectangles:
+            cv2.rectangle(img_draw, (rectangle[0], rectangle[1]),
+                          (rectangle[0] + rectangle[2], rectangle[1] + rectangle[3]), rectangle_color, thickness)
+
+        return img_draw
+
+    @func_description(
+        title="绘制圆",
+        description="在图像上绘制圆"
+    )
+    @staticmethod
+    def draw_circles(img, circles, circle_color=(255, 255, 0), thickness=2):
+        """
+        :name 绘制圆
+        :param img: 原始图
+        :param circles: 圆列表，格式为 [(x, y, r), (x, y, r), ...]
+        :param circle_color: 圆颜色
+        :param thickness: 圆线宽
+        :return img: 绘制圆后的图像
+        """
+        img_draw = img.copy()
+        for circle in circles:
+            cv2.circle(img_draw, (circle[0], circle[1]), circle[2], circle_color, thickness)
+
+        return img_draw
+
+    @func_description(
+        title="绘制椭圆",
+        description="在图像上绘制椭圆"
+    )
+    @staticmethod
+    def draw_ellipses(img, ellipses, ellipse_color=(0, 255, 255), thickness=2):
+        """
+        :name 绘制椭圆
+        :param img: 原始图
+        :param ellipses: 椭圆列表，格式为 [(x, y, w, h), (x, y, w, h), ...]
+        :param ellipse_color: 椭圆颜色
+        :param thickness: 椭圆线宽
+        :return img: 绘制椭圆后的图像
+        """
+        img_draw = img.copy()
+        for ellipse in ellipses:
+            cv2.ellipse(img_draw, (ellipse[0], ellipse[1]), (ellipse[2], ellipse[3]), 0, 0, 360, ellipse_color,
+                        thickness)
+
+        return img_draw
+
+    @func_description(
+        title="绘制多边形",
+        description="在图像上绘制多边形"
+    )
+    @staticmethod
+    def draw_polygons(img, polygons, polygon_color=(255, 0, 255), thickness=2):
+        """
+        :name 绘制多边形
+        :param img: 原始图
+        :param polygons: 多边形列表，格式为 [[(x1, y1), (x2, y2), ...], [(x1, y1), (x2, y2), ...], ...]
+        :param polygon_color: 多边形颜色
+        :param thickness: 多边形线宽
+        :return img: 绘制多边形后的图像
+        """
+        img_draw = img.copy()
+        for polygon in polygons:
+            cv2.polylines(img_draw, [np.array(polygon, dtype=np.int32)], True, polygon_color, thickness)
+
+        return img_draw
+
+    @func_description(
+        title="绘制文字",
+        description="在图像上绘制文字"
+    )
+    @staticmethod
+    def draw_text(img, text, text_position, text_color=(0, 0, 0), font_size=12, font_bold=False):
+        """
+        :name 绘制文字
+        :param img: 原始图
+        :param text: 文字内容
+        :param text_position: 文字位置，格式为 (x, y)
+        :param text_color: 文字颜色
+        :param font_size: 文字大小
+        :param font_bold: 是否加粗
+        :return img: 绘制文字后的图像
+        """
+        img_draw = img.copy()
+        # 转换为Pillow图像
+        img_pil = Image.fromarray(cv2.cvtColor(img_draw, cv2.COLOR_BGR2RGB))
+        # 加载字体
+        font = ImageFont.truetype("../front/simsun.ttc", font_size, index=1 if font_bold else 0)  # 替换为实际的字体路径
+        # 在Pillow图像上绘制中文
+        draw = ImageDraw.Draw(img_pil)
+        draw.text(text_position, text, font=font, fill=text_color)
+        # 转换回OpenCV格式
+        img_draw = cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2BGR)
+
+        return img_draw
+
+    @func_description(
+        title="绘制边框",
+        description="在图像四周增加边框"
+    )
+    @staticmethod
+    def draw_border(img, border_width=5, border_color=(255, 255, 255)):
+        """
+        :name 绘制边框
+        :param img: 原始图
+        :param border_width: 边框宽度
+        :param border_color: 边框颜色
+        :return img: 绘制边框后的图像
+        """
+        img_draw = img.copy()
+        img_draw = cv2.copyMakeBorder(img_draw, border_width, border_width, border_width, border_width,
+                                      cv2.BORDER_CONSTANT, value=border_color)
+
+        return img_draw
+
+
+# 暴露外部调用方法
+
+def generate_blank_image(width, height, color=(0, 0, 0)):
+    return DrawImage.generate_blank_image(width, height, color)
+
+def draw_contours(img, contours, contour_color=(0, 255, 0), thickness=2):
+    return DrawImage.draw_contours(img, contours, contour_color, thickness)
+
+def draw_points(img, points, point_color=(0, 0, 255), radius=5, thickness=-1):
+    return DrawImage.draw_points(img, points, point_color, radius, thickness)
+
+def draw_lines(img, lines, line_color=(255, 0, 0), thickness=2):
+    return DrawImage.draw_lines(img, lines, line_color, thickness)
+
+def draw_rectangles(img, rectangles, rectangle_color=(255, 0, 0), thickness=2):
+    return DrawImage.draw_rectangles(img, rectangles, rectangle_color, thickness)
+
+def draw_circles(img, circles, circle_color=(0, 255, 255), thickness=2):
+    return DrawImage.draw_circles(img, circles, circle_color, thickness)
+
+def draw_ellipses(img, ellipses, ellipse_color=(0, 255, 255), thickness=2):
+    return DrawImage.draw_ellipses(img, ellipses, ellipse_color, thickness)
+
+def draw_polygons(img, polygons, polygon_color=(255, 0, 255), thickness=2):
+    return DrawImage.draw_polygons(img, polygons, polygon_color, thickness)
+
+def draw_text(img, text, text_position, text_color=(0, 0, 0), font_size=12, font_bold=False):
+    return DrawImage.draw_text(img, text, text_position, text_color, font_size, font_bold)
+
+def draw_border(img, border_width=5, border_color=(255, 255, 255)):
+    return DrawImage.draw_border(img, border_width, border_color)
+
+
+
+if __name__ == '__main__':
+    draw_image = DrawImage()
+    img = draw_image.generate_blank_image(500, 500, (255, 255, 255))
+    show_image("img", img)
+
+    img = draw_image.draw_contours(img, [np.array([[100, 100], [200, 100], [200, 200], [100, 200]])])
+    show_image("img", img)
+
+    img = draw_image.draw_points(img, [[100, 100], [200, 200], [300, 300]])
+    show_image("img", img)
+
+    img = draw_image.draw_lines(img, [(50, 50, 450, 450), (450, 50, 50, 450)])
+    show_image("img", img)
+
+    img = draw_image.draw_rectangles(img, [(100, 100, 100, 100), (200, 200, 100, 100)])
+    show_image("img", img)
+
+    img = draw_image.draw_circles(img, [(100, 100, 50), (200, 200, 100)])
+    show_image("img", img)
+
+    img = draw_image.draw_ellipses(img, [(100, 100, 100, 50), (200, 200, 50, 100)])
+    show_image("img", img)
+
+    img = draw_image.draw_polygons(img, [[(100, 100), (200, 100), (200, 200), (100, 200)],
+                                         [(300, 300), (400, 300), (400, 400), (300, 400)]])
+    show_image("img", img)
+
+    img = draw_image.draw_text(img, "特丝特 特丝特", (100, 100), font_size=24, font_bold=True)
+    img = draw_image.draw_text(img, "特丝特 特丝特", (100, 150), font_size=24, font_bold=False)
+    show_image("img", img)
+
+    img = draw_image.draw_border(img, 10, (0, 0, 0))
+    show_image("img", img)

assembly/EdgeDetection.py

@@ -0,0 +1,190 @@
+import cv2
+import numpy as np
+
+from assembly.description.Decoration import func_description, class_description
+from assembly.GeneralUtil import show_image
+
+'''
+边缘检测算子
+
+输入：灰度图
+输出：边缘轮廓图
+'''
+
+
+@class_description(
+    title="边缘检测",
+    description="边缘检测是图像处理中常用的技术，其目的是识别图像中的明显特征，并从中提取其特征点，从而对图像进行分析、处理、识别等。",
+    level=8
+)
+class EdgeDetection(object):
+
+    @func_description(
+        title="边缘检测Canny算法",
+        description="最经典的边缘检测算法之一，其核心目标是在噪声图像中提取精确、单像素宽、连续的边缘"
+    )
+    @staticmethod
+    def edge_canny(gray, threshold1=50, threshold2=150, apertureSize=3, kernel=3):
+        """
+        :name Canny边缘检测算法
+        :param gray: 单通道图
+        :param threshold1: 阈值1
+        :param threshold2: 阈值2
+        :param apertureSize: 孔径大小
+        :param kernel: 卷积核大小
+        :return binary: 二值化图
+        """
+        if kernel and kernel in [3, 5, 7]:
+            gray = cv2.GaussianBlur(gray, (kernel, kernel), 0)  # 高斯去噪
+        # 调用Canny
+        edges = cv2.Canny(gray, threshold1=threshold1, threshold2=threshold2, apertureSize=apertureSize)
+        return edges
+
+    @func_description(
+        title="边缘检测Sobel算法",
+        description="Sobel算子（索贝尔算子）利用像素上、下、左、右邻域的灰度加权算法，根据在边缘点处达到极值这一原理进行边缘检测。"
+    )
+    @staticmethod
+    def edge_sobel(gray, ksize=3):
+        """
+        :name Sobel边缘检测算法
+        :param gray: 单通道图
+        :param ksize: 卷积核大小
+        :return binary: 二值化图
+        """
+        # 计算 Sobel X 和 Y 方向的梯度
+        dst_sobel_x = cv2.Sobel(gray, cv2.CV_16S, 1, 0, ksize=ksize)
+        dst_sobel_y = cv2.Sobel(gray, cv2.CV_16S, 0, 1, ksize=ksize)
+        # 转换为绝对值并缩放到 8 位
+        dst_sobel_x = cv2.convertScaleAbs(dst_sobel_x)
+        dst_sobel_y = cv2.convertScaleAbs(dst_sobel_y)
+        # 合并 X 和 Y 方向的梯度
+        dst = cv2.add(dst_sobel_x, dst_sobel_y)
+        return dst
+
+    @func_description(
+        title="边缘检测Scharr算法",
+        description="Sobel算子与Scharr算子比较：Sobel算子的缺点是，当结构较小是，精确度不高，Scharr算子具有更高的精度"
+    )
+    @staticmethod
+    def edge_scharr(gray):
+        """
+        :name Scharr边缘检测算法
+        :param gray: 单通道图
+        :return binary: 二值化图
+        """
+        # 计算水平方向边缘信息
+        scharrx = cv2.Scharr(gray, cv2.CV_64F, 1, 0)
+        # 计算垂直方向边缘信息
+        scharry = cv2.Scharr(gray, cv2.CV_64F, 0, 1)
+        # 求绝对值
+        scharrx = cv2.convertScaleAbs(scharrx)
+        scharry = cv2.convertScaleAbs(scharry)
+        # 水平方向和垂直方向的边缘叠加
+        scharrxy = cv2.addWeighted(scharrx, 0.5, scharry, 0.5, 0)
+        return scharrxy
+
+    @func_description(
+        title="边缘检测Laplacian算法",
+        description="拉普拉斯算子是一种二阶导数算子，其具有旋转不变性，可以满足不同方向的图像边缘锐化（边缘检测）的要求。"
+    )
+    @staticmethod
+    def edge_laplacian(gray):
+        """
+        :name Laplacian边缘检测算法
+        :param gray: 单通道图
+        :return binary: 二值化图
+        """
+        # 计算边缘信息
+        laplace = cv2.Laplacian(gray, cv2.CV_64F)
+        # 求绝对值
+        laplace = cv2.convertScaleAbs(laplace)
+        return laplace
+
+    @func_description(
+        title="边缘检测Roberts算法",
+        description="Roberts算子又称为交叉微分算法，是基于交叉差分的梯度算法，通过局部差分计算检测边缘线条。"
+    )
+    @staticmethod
+    def edge_roberts(gray):
+        """
+        :name Roberts边缘检测算法
+        :param gray: 单通道图
+        :return binary: 二值化图
+        """
+        # 定义 roberts 卷积核（注意 dtype 必须为 float32 以确保计算精度）
+        kernel_roberts_x = np.array([[-1, 0],
+                                     [0, 1]], dtype=np.float32)
+        kernel_roberts_y = np.array([[0, -1],
+                                     [1, 0]], dtype=np.float32)
+        # 执行卷积（输出类型设为 CV_32F 保留正负值）
+        dst = self.dege_filter2D(gray, kernel_roberts_x, kernel_roberts_y)
+        return dst
+
+    @func_description(
+        title="边缘检测Prewitt算法",
+        description="Prewitt边缘算子是一种边缘样板算子。由理想的边缘算子图像构成，依次用边缘样板去检测图像，与被检测区域最为相似的样板给出最大值，用这个最大值作为算子的输出。"
+    )
+    @staticmethod
+    def edge_prewitt(gray):
+        """
+        :name Prewitt边缘检测算法
+        :param gray: 单通道图
+        :return binary: 二值化图
+        """
+        # 定义 Prewitt 卷积核（注意 dtype 必须为 float32 以确保计算精度）
+        kernel_prewitt_x = np.array([[-1, 0, 1],
+                                     [-1, 0, 1],
+                                     [-1, 0, 1]], dtype=np.float32)
+        kernel_prewitt_y = np.array([[-1, -1, -1],
+                                     [0, 0, 0],
+                                     [1, 1, 1]], dtype=np.float32)
+        # 执行卷积（输出类型设为 CV_32F 保留正负值）
+        dst = self.dege_filter2D(gray, kernel_prewitt_x, kernel_prewitt_y)
+        return dst
+
+    @staticmethod
+    def dege_filter2D(gray, kernel_x, kernel_y):
+        '''封装方法 利用filter2D实现边缘检测算法'''
+        dst_prewitt_x = cv2.filter2D(gray, cv2.CV_32F, kernel_x)
+        dst_prewitt_y = cv2.filter2D(gray, cv2.CV_32F, kernel_y)
+        dst_prewitt_x = cv2.convertScaleAbs(dst_prewitt_x)
+        dst_prewitt_y = cv2.convertScaleAbs(dst_prewitt_y)
+        dst = cv2.add(dst_prewitt_x, dst_prewitt_y)
+        return dst
+
+
+# 保留方法
+def edge_canny(gray, threshold1=50, threshold2=150, apertureSize=3, kernel=3):
+    return EdgeDetection.edge_canny(gray, threshold1, threshold2, apertureSize, kernel)
+
+def edge_sobel(gray, ksize=3):
+    return EdgeDetection.edge_sobel(gray, ksize)
+
+def edge_scharr(gray):
+    return EdgeDetection.edge_scharr(gray)
+
+def edge_laplacian(gray):
+    return EdgeDetection.edge_laplacian(gray)
+
+def edge_roberts(gray):
+    return EdgeDetection.edge_roberts(gray)
+
+def edge_prewitt(gray):
+    return EdgeDetection.edge_prewitt(gray)
+
+
+if __name__ == '__main__':
+    edge_detection = EdgeDetection()
+    img = cv2.imdecode(np.fromfile(r"C:\Users\GT-LAPTOP-043\Downloads\黑白格.jpg", dtype=np.uint8),
+                       cv2.IMREAD_COLOR)
+    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    show_image("gray_img", gray_img, 500, 500)
+    show_image("edge_canny", edge_detection.edge_canny(gray_img), 500, 500)
+    show_image("edge_sobel", edge_detection.edge_sobel(gray_img), 500, 500)
+    show_image("edge_scharr", edge_detection.edge_scharr(gray_img), 500, 500)
+    show_image("edge_laplacian", edge_detection.edge_laplacian(gray_img), 500, 500)
+    show_image("edge_roberts", edge_detection.edge_roberts(gray_img), 500, 500)
+    show_image("edge_prewitt", edge_detection.edge_prewitt(gray_img), 500, 500)
+
+    cv2.destroyAllWindows()

assembly/GeneralUtil.py

@@ -0,0 +1,103 @@
+import cv2
+import numpy as np
+
+from assembly.description.Decoration import func_description, class_description
+
+'''
+常用工具
+
+输入：任意
+输出：任意
+'''
+
+
+@class_description(
+    title="常用工具",
+    description="包含通道转化、ROI、Mask等常用工具",
+    level=1
+)
+class GeneralUtil(object):
+
+    @func_description(
+        title="BGR转灰度",
+        description="BGR图像转换为灰度"
+    )
+    @staticmethod
+    def color_transform_gray(img):
+        """
+           :name 转灰度图
+           :param img: 原图: img
+           :return img: 转化后图片: img
+        """
+        return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+    @func_description(
+        title="BGR转HSV",
+        description="BGR图像转换为HSV"
+    )
+    @staticmethod
+    def color_transform_hsv(img):
+        """
+           :name 转换颜色空间
+           :param img: 原图: img
+           :return img: 转化后图片: img
+        """
+        return cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+
+
+    @func_description(
+        title="读图",
+        description="读取图像"
+    )
+    @staticmethod
+    def read_img(img_path):
+        """
+        :name 读取图像
+        :param img_path: 图片名: library_menu_select
+        :return img: 原图: img
+        """
+        return cv2.imdecode(np.fromfile(img_path, dtype=np.uint8), cv2.IMREAD_COLOR)
+
+    @staticmethod
+    def write_img(img, img_path):
+        """
+        :name 写入图像
+        :param img: 原图: img
+        :param img_path: 图片名: library_menu_select
+        :return None
+        """
+        cv2.imencode('.jpg', img)[1].tofile(img_path)
+
+    @staticmethod
+    def find_contours(img, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_SIMPLE):
+        """
+        :name 查找轮廓
+        :param img: 原图: img
+        :return contours: 轮廓列表: contours
+        """
+        contours, _ = cv2.findContours(img, mode, method)
+        return contours
+
+# 暴露方法
+def color_transform_gray(img):
+    return GeneralUtil.color_transform_gray(img)
+
+def color_transform_hsv(img):
+    return GeneralUtil.color_transform_hsv(img)
+
+def read_img(img_path):
+    return GeneralUtil.read_img(img_path)
+
+def write_img(img, img_path):
+    GeneralUtil.write_img(img, img_path)
+
+def find_contours(img, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_SIMPLE):
+    return GeneralUtil.find_contours(img, mode, method)
+
+def show_image(win_name, img, wx=None, wy=None):
+    cv2.namedWindow(win_name, cv2.WINDOW_NORMAL)
+    if wx is not None and wy is not None:
+        cv2.resizeWindow(win_name, wx, wy)
+    cv2.imshow(win_name, img)
+    cv2.waitKey(0)
+