assembly-opencv 1.0.0__py3-none-any.whl

assembly/ImageSegmentation.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=7
+)
+class ImageSegmentation(object):
+
+    @func_description(
+        title="RGB阈值分割",
+        description="通过指定的RGB阈值范围将图像分割为前景和背景"
+    )
+    @staticmethod
+    def rgb_threshold(img, lower_bound=(0, 0, 0), upper_bound=(255, 255, 255)):
+        """
+        :name RGB阈值分割
+        :param img: 原始图
+        :param lower_bound: bgr下限
+        :param upper_bound: bgr上限
+        :return: binary: 二值化图
+        """
+        mask = cv2.inRange(img, np.array(lower_bound), np.array(upper_bound))
+        return mask
+
+    @func_description(
+        title="HSV阈值分割",
+        description="通过指定的HSV阈值范围将图像分割为前景和背景"
+    )
+    @staticmethod
+    def hsv_threshold(img, lower_bound=(0, 0, 0), upper_bound=(179, 255, 255)):
+        """
+        :name HSV阈值分割
+        :param img: 原始图
+        :param lower_bound: hsv下限
+        :param upper_bound: hsv上限
+        :return: binary: 二值化图
+        """
+        hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+        h, s, v = cv2.split(hsv)
+        mask = cv2.inRange(hsv, np.array(lower_bound), np.array(upper_bound))
+        return mask
+
+    @func_description(
+        title="固定阈值分割",
+        description="通过指定的阈值范围将图像分割为前景和背景"
+    )
+    @staticmethod
+    def normal_threshold(gray, thresh, maxval=255, is_inv=False):
+        """
+        :name 固定阈值分割
+        :param gray: 单通道图
+        :param thresh: 阈值
+        :param maxval: 满足阈值赋予的新值
+        :param is_inv: 阈值类型，默认 False cv2.THRESH_BINARY，True为 cv2.THRESH_BINARY_INV
+        :return: binary: 二值化图
+        """
+        if is_inv:
+            THRESH_TYPE = cv2.THRESH_BINARY_INV
+        else:
+            THRESH_TYPE = cv2.THRESH_BINARY
+        retval, binary = cv2.threshold(gray, thresh, maxval, THRESH_TYPE)
+        return binary
+
+    @func_description(
+        title="Otsu阈值分割",
+        description="通过分析图像的灰度直方图自动计算全局阈值，将图像分割为前景和背景"
+    )
+    @staticmethod
+    def otsu_threshold(gray, maxval=255, is_inv=False):
+        """
+        :name Otsu阈值分割
+        :param gray: 单通道图
+        :param maxval: 满足阈值赋予的新值
+        :param is_inv: 阈值类型，默认 False cv2.THRESH_BINARY，True为 cv2.THRESH_BINARY_INV
+        :return: binary: 二值化图
+        """
+        if is_inv:
+            THRESH_TYPE = cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU
+        else:
+            THRESH_TYPE = cv2.THRESH_BINARY + cv2.THRESH_OTSU
+        retval, binary = cv2.threshold(gray, 0, maxval, THRESH_TYPE)
+        return binary
+
+    @func_description(
+        title="自适应阈值分割",
+        description="根据图像局部区域的灰度变化自动计算阈值，将图像分割为前景和背景"
+    )   
+    @staticmethod
+    def adaptive_threshold(gray, maxval=255, method=cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                           is_inv=False, block_size=11, C=2):
+        """
+        :name 自适应阈值分割
+        :param gray: 单通道图
+        :param maxval: 满足阈值赋予的新值
+        :param method: 计算阈值的方法，默认 cv2.ADAPTIVE_THRESH_GAUSSIAN_C，可选 cv2.ADAPTIVE_THRESH_MEAN_C
+        :param is_inv: 阈值类型，默认 False cv2.THRESH_BINARY，True为 cv2.THRESH_BINARY_INV
+        :param block_size: 计算阈值的邻域大小，必须为奇数
+        :param C: 从计算得到的阈值中减去的常数
+        :return: binary: 二值化图
+        """
+        if is_inv:
+            THRESH_TYPE = cv2.THRESH_BINARY_INV
+        else:
+            THRESH_TYPE = cv2.THRESH_BINARY
+        if block_size % 2 == 0:
+            raise ValueError("block_size must be an odd number")
+        binary = cv2.adaptiveThreshold(gray, maxval, method, THRESH_TYPE, block_size, C)
+        return binary
+
+    @func_description(
+        title="漫水填充分割",
+        description="通过从种子点开始扩展区域，将图像分割为不同的区域"
+    )
+    @staticmethod
+    def flood_fill(gray, seed_point, new_val, lo_diff=5, up_diff=5, flags=4):
+        """
+        :name 漫水填充分割
+        :param gray: 单通道图
+        :param seed_point: 种子点，格式为 (x, y)
+        :param new_val: 新值，格式为 (B, G, R)
+        :param lo_diff: 低差分，表示允许的颜色变化范围
+        :param up_diff: 高差分，表示允许的颜色变化范围
+        :param flags: 漫水填充的连接方式，默认 4，可选 8
+        :return: binary: 二值化图
+        """
+        img_copy = gray.copy()
+        h, w = img_copy.shape[:2]
+        mask = np.zeros((h + 2, w + 2), np.uint8)
+        num_filled_pixels, image, mask, rect = cv2.floodFill(img_copy, mask, seed_point, new_val, (lo_diff,),
+                                                             (up_diff,), flags)
+        # 裁剪掩膜（去除边缘的多余像素）
+        binary_mask = mask[1:-1, 1:-1]  # 得到(h, w)尺寸的掩膜
+        # 生成二值图：填充区=黑色(0)，其余=白色(255)
+        binary_result = np.where(binary_mask > 0, 0, 255).astype(np.uint8)
+        return binary_result
+
+
+# 暴露方法
+def rgb_threshold(img, lower_bound=(0, 0, 0), upper_bound=(255, 255, 255)):
+    return ImageSegmentation.rgb_threshold(img, lower_bound, upper_bound)
+
+def hsv_threshold(img, lower_bound=(0, 0, 0), upper_bound=(179, 255, 255)):
+    return ImageSegmentation.hsv_threshold(img, lower_bound, upper_bound)
+
+def normal_threshold(gray, thresh, maxval=255, is_inv=False):
+    return ImageSegmentation.normal_threshold(gray, thresh, maxval, is_inv)
+
+def otsu_threshold(gray, maxval=255, is_inv=False):
+    return ImageSegmentation.otsu_threshold(gray, maxval, is_inv)
+
+def adaptive_threshold(gray, maxval=255, method=cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                           is_inv=False, block_size=11, C=2):
+    return ImageSegmentation.adaptive_threshold(gray, maxval, method, is_inv, block_size, C)
+
+def flood_fill(gray, seed_point, new_val, lo_diff=5, up_diff=5, flags=4):
+    return ImageSegmentation.flood_fill(gray, seed_point, new_val, lo_diff, up_diff, flags)
+
+
+
+if __name__ == '__main__':
+    image_segment = ImageSegmentation()
+    img = cv2.imdecode(np.fromfile(r"C:\Users\GT-LAPTOP-043\Downloads\test.jpg", dtype=np.uint8),
+                       cv2.IMREAD_COLOR)
+    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    show_image("gray_img", gray_img)
+    binary_img = image_segment.rgb_threshold(img, lower_bound=[0, 0, 0], upper_bound=[100, 100, 100])
+    show_image("rgb_threshold", binary_img)
+    binary_img = image_segment.hsv_threshold(img, lower_bound=[0, 0, 0], upper_bound=[179, 255, 100])
+    show_image("hsv_threshold", binary_img)
+    binary_img = image_segment.normal_threshold(gray_img, 127, is_inv=True)
+    show_image("normal_threshold", binary_img)
+    binary_img = image_segment.otsu_threshold(gray_img, is_inv=True)
+    show_image("otsu_threshold", binary_img)
+    binary_img = image_segment.adaptive_threshold(gray_img, is_inv=True)
+    show_image("adaptive_threshold", binary_img)
+    binary_img = image_segment.flood_fill(gray_img, (50, 50), 255)
+    show_image("flood_fill", binary_img)

assembly/MorphologicalChange.py

@@ -0,0 +1,221 @@
+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=4
+)
+class MorphologicalChange(object):
+
+    @func_description(
+        title="腐蚀操作",
+        description="腐蚀操作会使图像中的前景物体变小，去除小的噪点，断开细小的连接"
+    )
+    @staticmethod
+    def mlc_erode(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+        """
+        :name 腐蚀操作
+        :param binary: 二值化图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :param kernel_type: 卷积核类型，默认矩形 cv2.MORPH_RECT, 可选 cv2.MORPH_ELLIPSE, cv2.MORPH_CROSS
+        :param iterations: 腐蚀次数
+        :return binary: 二值化图
+        """
+        if kernel_size % 2 == 0:
+            raise ValueError("kernel_size must be an odd number")
+        kernel = cv2.getStructuringElement(kernel_type, (kernel_size, kernel_size))
+        eroded = cv2.erode(binary, kernel, iterations=iterations)
+        return eroded
+
+    @func_description(
+        title="膨胀操作",
+        description="膨胀操作会使图像中的前景物体变大，填充小的空白，连接物体上的小洞"
+    )
+    @staticmethod
+    def mlc_dilate(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+        """
+        :name 膨胀操作
+        :param binary: 二值化图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :param kernel_type: 卷积核类型，默认矩形 cv2.MORPH_RECT, 可选 cv2.MORPH_ELLIPSE, cv2.MORPH_CROSS
+        :param iterations: 膨胀次数
+        :return binary: 二值化图
+        """
+        if kernel_size % 2 == 0:
+            raise ValueError("kernel_size must be an odd number")
+        kernel = cv2.getStructuringElement(kernel_type, (kernel_size, kernel_size))
+        dilated = cv2.dilate(binary, kernel, iterations=iterations)
+        return dilated
+
+    @func_description(
+        title="开运算",
+        description="先腐蚀后膨胀，去除小的噪点，断开细小的连接"
+    )
+    @staticmethod
+    def mlc_open(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+        """
+        :name 开运算
+        :param binary: 二值化图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :param kernel_type: 卷积核类型，默认矩形 cv2.MORPH_RECT, 可选 cv2.MORPH_ELLIPSE, cv2.MORPH_CROSS
+        :param iterations: 开操作次数
+        :return binary: 二值化图
+        """
+        if kernel_size % 2 == 0:
+            raise ValueError("kernel_size must be an odd number")
+        kernel = cv2.getStructuringElement(kernel_type, (kernel_size, kernel_size))
+        opened = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel, iterations=iterations)
+        return opened
+
+    @func_description(
+        title="闭运算",
+        description="先膨胀后腐蚀，填充小的空白，连接物体上的小洞"
+    )
+    @staticmethod
+    def mlc_close(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+        """
+        :name 闭运算
+        :param binary: 二值化图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :param kernel_type: 卷积核类型，默认矩形 cv2.MORPH_RECT, 可选 cv2.MORPH_ELLIPSE, cv2.MORPH_CROSS
+        :param iterations: 闭操作次数
+        :return binary: 二值化图
+        """
+        if kernel_size % 2 == 0:
+            raise ValueError("kernel_size must be an odd number")
+        kernel = cv2.getStructuringElement(kernel_type, (kernel_size, kernel_size))
+        closed = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel, iterations=iterations)
+        return closed
+
+    @func_description(
+        title="形态学梯度",
+        description="形态学梯度是图像的梯度，表示图像中前景物体与背景之间的差异"
+    )
+    @staticmethod
+    def mlc_gradient(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+        """
+        :name 形态学梯度
+        :param binary: 二值化图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :param kernel_type: 卷积核类型，默认矩形 cv2.MORPH_RECT, 可选 cv2.MORPH_ELLIPSE, cv2.MORPH_CROSS
+        :param iterations: 形态学梯度次数
+        :return binary: 二值化图
+        """
+        if kernel_size % 2 == 0:
+            raise ValueError("kernel_size must be an odd number")
+        kernel = cv2.getStructuringElement(kernel_type, (kernel_size, kernel_size))
+        gradient = cv2.morphologyEx(binary, cv2.MORPH_GRADIENT, kernel, iterations=iterations)
+        return gradient
+
+    @func_description(
+        title="顶帽操作",
+        description="顶帽操作是原始图像与开操作结果之间的差异，突出图像中的小亮区域"
+    )
+    @staticmethod
+    def mlc_top_hat(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+        """
+        :name 顶帽操作
+        :param binary: 二值化图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :param kernel_type: 卷积核类型，默认矩形 cv2.MORPH_RECT, 可选 cv2.MORPH_ELLIPSE, cv2.MORPH_CROSS
+        :param iterations: 顶帽操作次数
+        :return img:顶帽操作后的图像
+        """
+        if kernel_size % 2 == 0:
+            raise ValueError("kernel_size must be an odd number")
+        kernel = cv2.getStructuringElement(kernel_type, (kernel_size, kernel_size))
+        tophat = cv2.morphologyEx(binary, cv2.MORPH_TOPHAT, kernel, iterations=iterations)
+        return tophat
+
+    @func_description(
+        title="黑帽操作",
+        description="黑帽操作是闭操作结果与原始图像之间的差异，突出图像中的小暗区域"
+    )
+    @staticmethod
+    def mlc_black_hat(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+        """
+        :name 黑帽操作
+        :param binary: 二值化图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :param kernel_type: 卷积核类型，默认矩形 cv2.MORPH_RECT, 可选 cv2.MORPH_ELLIPSE, cv2.MORPH_CROSS
+        :param iterations: 黑帽操作次数
+        :return binary: 二值化图
+        """
+        if kernel_size % 2 == 0:
+            raise ValueError("kernel_size must be an odd number")
+        kernel = cv2.getStructuringElement(kernel_type, (kernel_size, kernel_size))
+        blackhat = cv2.morphologyEx(binary, cv2.MORPH_BLACKHAT, kernel, iterations=iterations)
+        return blackhat
+
+    @func_description(
+        title="骨架化",
+        description="骨架化是将图像中连通区域的边界线去除，使图像变成一个单一的轮廓线"
+    )
+    @staticmethod
+    def mlc_skeletonize(binary):
+        """
+        :name 骨架化
+        :param binary: 二值化图
+        :return binary: 二值化图
+        """
+        skeleton = cv2.ximgproc.thinning(binary)
+        return skeleton
+
+
+# 暴露方法
+
+def mlc_erode(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+    return MorphologicalChange.mlc_erode(binary, kernel_size, kernel_type, iterations)
+
+def mlc_dilate(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+    return MorphologicalChange.mlc_dilate(binary, kernel_size, kernel_type, iterations)
+
+def mlc_open(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+    return MorphologicalChange.mlc_open(binary, kernel_size, kernel_type, iterations)
+
+def mlc_close(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+    return MorphologicalChange.mlc_close(binary, kernel_size, kernel_type, iterations)
+
+def mlc_gradient(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+    return MorphologicalChange.mlc_gradient(binary, kernel_size, kernel_type, iterations)
+
+def mlc_top_hat(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+    return MorphologicalChange.mlc_top_hat(binary, kernel_size, kernel_type, iterations)
+
+def mlc_black_hat(binary, kernel_size=3, kernel_type=cv2.MORPH_RECT, iterations=1):
+    return MorphologicalChange.mlc_black_hat(binary, kernel_size, kernel_type, iterations)
+
+def mlc_skeletonize(binary):
+    return MorphologicalChange.mlc_skeletonize(binary)
+
+
+if __name__ == '__main__':
+    morphological_change = MorphologicalChange()
+    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)
+    ret, gray_img = cv2.threshold(gray_img, 127, 255, cv2.THRESH_BINARY_INV, gray_img)
+
+    show_image("gray_img", gray_img, 500, 500)
+    show_image("mlc_erode", morphological_change.mlc_erode(gray_img), 500, 500)
+    show_image("mlc_dilate", morphological_change.mlc_dilate(gray_img), 500, 500)
+    show_image("mlc_open", morphological_change.mlc_open(gray_img), 500, 500)
+    show_image("mlc_close", morphological_change.mlc_close(gray_img), 500, 500)
+    show_image("mlc_gradient", morphological_change.mlc_gradient(gray_img), 500, 500)
+    show_image("mlc_top_hat", morphological_change.mlc_top_hat(gray_img), 500, 500)
+    show_image("mlc_black_hat", morphological_change.mlc_black_hat(gray_img), 500, 500)
+    show_image("mlc_skeletonize", morphological_change.mlc_skeletonize(gray_img), 500, 500)
+
+    cv2.destroyAllWindows()