assembly-opencv 1.0.0__py3-none-any.whl

assembly/GeometricChanges.py

@@ -0,0 +1,171 @@
+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=3
+)
+class GeometricChanges(object):
+
+    @func_description(
+        title="图像翻转",
+        description="对图像进行水平或垂直翻转"
+    )
+    @staticmethod
+    def flip_image(img, mode='horizontal'):
+        """
+        :name 图像翻转
+        :param img: 原始图
+        :param mode: 翻转模式，'horizontal'表示水平翻转，'vertical'表示垂直翻转
+        :return img: 翻转后的图像
+        """
+        if mode == 'horizontal':
+            img_flipped = cv2.flip(img, 1)
+        elif mode == 'vertical':
+            img_flipped = cv2.flip(img, 0)
+        else:
+            raise ValueError("Invalid mode. Use 'horizontal' or 'vertical'.")
+
+        return img_flipped
+
+    @func_description(
+        title="图像旋转",
+        description="对图像进行旋转"
+    )
+    @staticmethod
+    def rotate_image(img, angle):
+        """
+        :name 图像旋转
+        :param img: 原始图
+        :param angle: 旋转角度，正值表示逆时针旋转，负值表示顺时针旋转
+        :return img: 旋转后的图像
+        """
+        (h, w) = img.shape[:2]
+        center = (w // 2, h // 2)
+
+        M = cv2.getRotationMatrix2D(center, angle, 1.0)
+        img_rotated = cv2.warpAffine(img, M, (w, h))
+
+        return img_rotated
+
+    @func_description(
+        title="图像缩放",
+        description="对图像进行缩放"
+    )
+    @staticmethod
+    def scale_image(img, scale_x, scale_y):
+        """
+        :name 图像缩放
+        :param img: 原始图
+        :param scale_x: 水平缩放因子
+        :param scale_y: 垂直缩放因子
+        :return img: 缩放后的图像
+        """
+        img_scaled = cv2.resize(img, None, fx=scale_x, fy=scale_y, interpolation=cv2.INTER_LINEAR)
+        return img_scaled
+
+    @func_description(
+        title="图像裁剪",
+        description="对图像进行裁剪"
+    )
+    @staticmethod
+    def crop_image(img, x, y, width, height):
+        """
+        :name 图像裁剪
+        :param img: 原始图
+        :param x: 裁剪区域左上角x坐标
+        :param y: 裁剪区域左上角y坐标
+        :param width: 裁剪区域宽度
+        :param height: 裁剪区域高度
+        :return img: 裁剪后的图像
+        """
+        img_cropped = img[y:y+height, x:x+width]
+        return img_cropped
+
+    @func_description(
+        title="图像透视变换",
+        description="将图像从一个视平面投影到另一个视平面的几何变换，用于解决图像的透视畸变问题（如近大远小的视觉效果），或实现视角转换（如从倾斜图像恢复正视图）"
+    )
+    @staticmethod
+    def perspective_transform(img, src_points, dst_points):
+        """
+        :name 图像透视变换
+        :param img: 原始图
+        :param src_points: 源点坐标，形如[[x1, y1], [x2, y2], [x3, y3], [x4, y4]]
+        :param dst_points: 目标点坐标，形如[[x1', y1'], [x2', y2'], [x3', y3'], [x4', y4']]
+        :return img: 透视变换后的图像
+        """
+        src_pts = np.array(src_points, dtype=np.float32)
+        dst_pts = np.array(dst_points, dtype=np.float32)
+
+        M = cv2.getPerspectiveTransform(src_pts, dst_pts)
+        (h, w) = img.shape[:2]
+        img_transformed = cv2.warpPerspective(img, M, (w, h))
+
+        return img_transformed
+
+    @func_description(
+        title="图像仿射变换",
+        description="仿射变换也称仿射投影，是指几何中，对一个向量空间进行线性变换并接上一个平移，变换为另一个向量空间"
+    )
+    @staticmethod
+    def wrap_affine(img, src_points, dst_points):
+        """
+        :name 图像仿射变换
+        :param img: 原始图
+        :param src_points: 源点坐标，形如[[x1, y1], [x2, y2], [x3, y3]]
+        :param dst_points: 目标点坐标，形如[[x1', y1'], [x2', y2'], [x3', y3']]
+        :return img: 仿射变换后的图像
+        """
+        src_pts = np.array(src_points, dtype=np.float32)
+        dst_pts = np.array(dst_points, dtype=np.float32)
+
+        M = cv2.getAffineTransform(src_pts, dst_pts)
+        (h, w) = img.shape[:2]
+        img_transformed = cv2.warpAffine(img, M, (w, h))
+
+        return img_transformed
+
+# 暴露方法
+def flip_image(img, mode='horizontal'):
+    return GeometricChanges.flip_image(img, mode)
+
+def rotate_image(img, angle):
+    return GeometricChanges.rotate_image(img, angle)
+
+def scale_image(img, scale_x, scale_y):
+    return GeometricChanges.scale_image(img, scale_x, scale_y)
+
+def crop_image(img, x, y, width, height):
+    return GeometricChanges.crop_image(img, x, y, width, height)
+
+def perspective_transform(img, src_points, dst_points):
+    return GeometricChanges.perspective_transform(img, src_points, dst_points)
+
+def wrap_affine(img, src_points, dst_points):
+    return GeometricChanges.wrap_affine(img, src_points, dst_points)
+
+
+
+if __name__ == '__main__':
+    geo = GeometricChanges()
+    img = cv2.imdecode(np.fromfile(r"D:\新能源\2025-08\top\20250827165052_186_32_1(1).jpg", dtype=np.uint8),
+                       cv2.IMREAD_COLOR)
+    show_image("img", img)
+
+    trans_img = geo.wrap_affine(img, [[100,100],[200,100],[100,200]], [[150,150],[250,150],[150,250]])
+    show_image("wrap_affine",trans_img)
+    trans_img = geo.perspective_transform(img, [[100,100],[200,100],[100,200],[200,200]], [[150,150],[250,150],[150,250],[250,250]])
+    show_image("perspective_transform",trans_img)

assembly/ImageEnhance.py

@@ -0,0 +1,242 @@
+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=5
+)
+class ImageEnhance(object):
+
+    @func_description(
+        title="亮度/对比度调整",
+        description="通过调整图像的亮度，使得图像更加鲜艳，适用彩色/灰色图像"
+    )
+    @staticmethod
+    def enhance_brightness(img, alpha=1.0, beta=0.0):
+        """
+        :name 亮度/对比度调整
+        :param img: 多通道图
+        :param alpha: 亮度调节因子
+        :param beta: 亮度偏移量
+        :return img: 多通道图
+        """
+        return cv2.convertScaleAbs(img, alpha=alpha, beta=beta)
+
+    @func_description(
+        title="伽马校正",
+        description="通过对图像进行非线性拉伸，使得图像的对比度更加均匀，适用彩色/灰色图像"
+    )
+    @staticmethod
+    def enhance_gamma_correction(img, gamma=1.0):
+        """
+        :name 伽马校正
+        :param img: 多通道图
+        :param gamma: 伽马值
+        :return img: 多通道图
+        """
+        inv_gamma = 1.0 / gamma
+        table = np.array([((i / 255.0) ** inv_gamma) * 255 for i in np.arange(0, 256)]).astype("uint8")
+        return cv2.LUT(img, table)
+
+    @func_description(
+        title="均值滤波",
+        description="通过减少图像中的噪声，使得图像更加平滑，适用彩色/灰色图像"
+    )
+    @staticmethod
+    def enhance_smoothing(img, kernel_size=3):
+        """
+        :name 均值滤波
+        :param img: 多通道图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :return img: 多通道图
+        """
+        if kernel_size % 2 == 0:
+            kernel_size += 1
+        return cv2.blur(img, (kernel_size, kernel_size))
+
+    @func_description(
+        title="高斯滤波",
+        description="通过对图像进行平滑，使得图像更加平滑，适用彩色/灰色图像"
+    )
+    @staticmethod
+    def enhance_gaussian_filtering(img, kernel_size=3, sigma=0):
+        """
+        :name 高斯滤波
+        :param img: 多通道图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :param sigma: 标准差
+        :return img: 多通道图
+        """
+        if kernel_size % 2 == 0:
+            kernel_size += 1
+        return cv2.GaussianBlur(img, (kernel_size, kernel_size), sigma)
+
+    @func_description(
+        title="中值滤波",
+        description="通过减少图像中的椒盐噪声，使得图像更加平滑，适用彩色/灰色图像"
+    )
+    @staticmethod
+    def enhance_median_filtering(img, kernel_size=3):
+        """
+        :name 中值滤波
+        :param img: 多通道图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :return img: 多通道图
+        """
+        if kernel_size % 2 == 0:
+            kernel_size += 1
+        return cv2.medianBlur(img, kernel_size)
+
+    @func_description(
+        title="双边滤波",
+        description="通过在平滑图像的同时保留边缘信息，使得图像更加清晰，适用彩色/灰色图像"
+    )
+    @staticmethod
+    def enhance_bilateral_filtering(img, d=9, sigma_color=75, sigma_space=75):
+        """
+        :name 双边滤波
+        :param img: 多通道图
+        :param d: 领域直径
+        :param sigma_color: 颜色空间标准差
+        :param sigma_space: 坐标空间标准差
+        :return img: 多通道图
+        """
+        return cv2.bilateralFilter(img, d, sigma_color, sigma_space)
+
+    @func_description(
+        title="锐化",
+        description="通过增强图像的边缘信息，使得图像更加清晰，适用彩色/灰色图像"
+    )
+    @staticmethod
+    def enhance_sharpening(img, kernel_size=3):
+        """
+        :name 锐化
+        :param img: 多通道图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :return img: 多通道图
+        """
+        kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
+        if kernel_size % 2 == 0:
+            kernel_size += 1
+        return cv2.filter2D(img, -1, kernel, borderType=cv2.BORDER_REPLICATE)
+
+    @func_description(
+        title="拉普拉斯增强",
+        description="通过对图像进行非线性拉伸，使得图像的对比度更加均匀，适用于灰度图像"
+    )
+    @staticmethod
+    def enhance_laplacian_enhancement(gray, kernel_size=3):
+        """
+        :name 拉普拉斯增强
+        :param gray: 单通道图
+        :param kernel_size: 卷积核大小，必须为奇数
+        :return gray: 单通道图
+        """
+        if kernel_size % 2 == 0:
+            kernel_size += 1
+        return cv2.Laplacian(gray, cv2.CV_64F, ksize=kernel_size)
+
+    @func_description(
+        title="直方图均衡化",
+        description="通过调整图像的对比度来增强图像的视觉效果，适用于灰度图像"
+    )
+    @staticmethod
+    def enhance_histogram_equalization(gray):
+        """
+        :name 直方图均衡化
+        :param gray: 单通道图
+        :return gray: 单通道图
+        """
+        equalized = cv2.equalizeHist(gray)
+        return equalized
+
+    @func_description(
+        title="CLAHE(自适应直方图均衡化):",
+        description="通过对图像进行自适应直方图均衡化，可以增强图像的对比度和亮度，适用于灰度图像"
+    )
+    @staticmethod
+    def enhance_adaptive_histogram_equalization(gray, clip_limit=2.0, tile_size=(8, 8)):
+        """
+        :name CLAHE(自适应直方图均衡化)
+        :param gray: 单通道图
+        :param clip_limit: 裁剪限值
+        :param tile_size: 块大小
+        :return gray: 单通道图
+        """
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_size)
+        return clahe.apply(gray)
+
+
+# 暴露方法
+def enhance_brightness(img, alpha=1.5, beta=0):
+    return ImageEnhance.enhance_brightness(img, alpha, beta)
+
+def enhance_gamma_correction(img, gamma=1.5):
+    return ImageEnhance.enhance_gamma_correction(img, gamma)
+
+def enhance_smoothing(img, kernel_size=3):
+    return ImageEnhance.enhance_smoothing(img, kernel_size)
+
+def enhance_gaussian_filtering(img, kernel_size=3, sigma=0):
+    return ImageEnhance.enhance_gaussian_filtering(img, kernel_size, sigma)
+
+def enhance_median_filtering(img, kernel_size=3):
+    return ImageEnhance.enhance_median_filtering(img, kernel_size)
+
+def enhance_bilateral_filtering(img, d=9, sigma_color=75, sigma_space=75):
+    return ImageEnhance.enhance_bilateral_filtering(img, d, sigma_color, sigma_space)
+
+def enhance_sharpening(img, kernel_size=3):
+    return ImageEnhance.enhance_sharpening(img, kernel_size)
+
+def enhance_laplacian_enhancement(img, kernel_size=3):
+    return ImageEnhance.enhance_laplacian_enhancement(img, kernel_size)
+
+def enhance_histogram_equalization(img):
+    return ImageEnhance.enhance_histogram_equalization(img)
+
+def enhance_adaptive_histogram_equalization(img, clip_limit=2.0, tile_size=(8, 8)):
+    return ImageEnhance.enhance_adaptive_histogram_equalization(img, clip_limit, tile_size)
+
+
+
+if __name__ == '__main__':
+    image_enhance = ImageEnhance()
+    img = cv2.imdecode(np.fromfile(r"D:\新能源\2025-08\top\20250827165052_186_32_1(1).jpg", dtype=np.uint8),
+                       cv2.IMREAD_COLOR)
+
+    show_image("gray_img", img)
+    enhanced_img = image_enhance.enhance_brightness(img, alpha=1.5, beta=0)
+    show_image("enhance_brightness", enhanced_img)
+    enhanced_img = image_enhance.enhance_gamma_correction(img, gamma=1.5)
+    show_image("enhance_gamma_correction", enhanced_img)
+    enhanced_img = image_enhance.enhance_laplacian_enhancement(img, kernel_size=3)
+    show_image("enhance_laplacian_enhancement", enhanced_img)
+    enhanced_img = image_enhance.enhance_smoothing(img, kernel_size=3)
+    show_image("enhance_smoothing", enhanced_img)
+    enhanced_img = image_enhance.enhance_gaussian_filtering(img, kernel_size=3, sigma=0)
+    show_image("enhance_gaussian_filtering", enhanced_img)
+    enhanced_img = image_enhance.enhance_median_filtering(img, kernel_size=3)
+    show_image("enhance_median_filtering", enhanced_img)
+    enhanced_img = image_enhance.enhance_bilateral_filtering(gray_img, d=9, sigma_color=75, sigma_space=75)
+    show_image("enhance_bilateral_filtering", enhanced_img)
+    enhanced_img = image_enhance.enhance_sharpening(img, kernel_size=3)
+    show_image("enhance_sharpening", enhanced_img)
+
+    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    enhanced_img = image_enhance.enhance_histogram_equalization(gray_img)
+    show_image("enhance_histogram_equalization", enhanced_img)
+    enhanced_img = image_enhance.enhance_adaptive_histogram_equalization(gray_img)
+    show_image("enhance_adaptive_histogram_equalization", enhanced_img)

assembly/ImageOperation.py

@@ -0,0 +1,186 @@
+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=6
+)
+class ImageOperation(object):
+
+    @func_description(
+        title="加法运算",
+        description="实现饱和加法（结果超过255时截断为255）"
+    )
+    @staticmethod
+    def image_add(img1, img2):
+        """
+        :name 加法运算
+        :param img1: 原始图1
+        :param img2: 原始图2
+        :return: img: 加法运算后的图像
+        """
+        img_added = cv2.add(img1, img2)
+        return img_added
+
+    @func_description(
+        title="减法运算",
+        description="实现饱和减法（结果小于0时截断为0）"
+    )
+    @staticmethod
+    def image_subtract(img1, img2):
+        """
+        :name 减法运算
+        :param img1: 原始图1
+        :param img2: 原始图2
+        :return: img: 减法运算后的图像
+        """
+        img_subtracted = cv2.subtract(img1, img2)
+        return img_subtracted
+
+    @func_description(
+        title="乘法运算",
+        description="对两个图像的每个像素进行逐元素乘法操作,增强对比度"
+    )
+    @staticmethod
+    def image_multiply(img1, img2):
+        """
+        :name 乘法运算
+        :param img1: 原始图1
+        :param img2: 原始图2
+        :return: img: 乘法运算后的图像
+        """
+        img_multiplied = cv2.multiply(img1, img2)
+        return img_multiplied
+
+    @func_description(
+        title="除法运算",
+        description="对两个图像的每个像素进行逐元素除法操作,用于光照归一化"
+    )
+    @staticmethod
+    def image_divide(img1, img2):
+        """
+        :name 除法运算
+        :param img1: 原始图1
+        :param img2: 原始图2
+        :return: img: 除法运算后的图像
+        """
+        img_divided = cv2.divide(img1, img2)
+        return img_divided
+
+    @func_description(
+        title="按位与运算",
+        description="对两个图像的每个像素进行按位与操作"
+    )
+    @staticmethod
+    def image_bitwise_and(img1, img2):
+        """
+        :name 按位与运算
+        :param img1: 原始图1
+        :param img2: 原始图2
+        :return: img: 按位与运算后的图像
+        """
+        img_and = cv2.bitwise_and(img1, img2)
+        return img_and
+
+    @func_description(
+        title="按位或运算",
+        description="对两个图像的每个像素进行按位或操作"
+    )
+    @staticmethod
+    def image_bitwise_or(img1, img2):
+        """
+        :name 按位或运算
+        :param img1: 原始图1
+        :param img2: 原始图2
+        :return: img: 按位或运算后的图像
+        """
+        img_or = cv2.bitwise_or(img1, img2)
+        return img_or
+
+    @func_description(
+        title="按位异或运算",
+        description="对两个图像的每个像素进行按位异或操作"
+    )
+    @staticmethod
+    def image_bitwise_xor(img1, img2):
+        """
+        :name 按位异或运算
+        :param img1: 原始图1
+        :param img2: 原始图2
+        :return: img: 按位异或运算后的图像
+        """
+        img_xor = cv2.bitwise_xor(img1, img2)
+        return img_xor
+
+    @func_description(
+        title="按位非运算",
+        description="对图像的每个像素进行按位非操作"
+    )
+    @staticmethod
+    def image_bitwise_not(img):
+        """
+        :name 按位非运算
+        :param img: 原始图
+        :return: img: 按位非运算后的图像
+        """
+        img_not = cv2.bitwise_not(img)
+        return img_not
+
+    @func_description(
+        title="图像加权混合",
+        description="通过加权平均的方式将两幅图像混合在一起"
+    )   
+    @staticmethod
+    def image_blend(img1, img2, alpha=0.5, beta=0.5, gamma=0):
+        """
+        :name 图像加权混合
+        :param img1: 原始图1
+        :param img2: 原始图2
+        :param alpha: 图像1的权重
+        :param beta: 图像2的权重
+        :param gamma: 标量值，添加到每个和中
+        :return: img: 混合后的图像
+        """
+        img_blended = cv2.addWeighted(img1, alpha, img2, beta, gamma)
+        return img_blended
+
+# 暴露方法
+def image_add(img1, img2):
+    return ImageOperation.image_add(img1, img2)
+
+def image_subtract(img1, img2):
+    return ImageOperation.image_subtract(img1, img2)
+
+def image_multiply(img1, img2):
+    return ImageOperation.image_multiply(img1, img2)
+
+def image_divide(img1, img2):
+    return ImageOperation.image_divide(img1, img2)
+
+def image_bitwise_and(img1, img2):
+    return ImageOperation.image_bitwise_and(img1, img2)
+
+def image_bitwise_or(img1, img2):
+    return ImageOperation.image_bitwise_or(img1, img2)
+
+def image_bitwise_xor(img1, img2):
+    return ImageOperation.image_bitwise_xor(img1, img2)
+
+def image_bitwise_not(img):
+    return ImageOperation.image_bitwise_not(img)
+    
+def image_blend(img1, img2, alpha=0.5, beta=0.5, gamma=0):
+    return ImageOperation.image_blend(img1, img2, alpha, beta, gamma)
+