pyxllib 0.0.43__py3-none-any.whl → 0.3.197__py3-none-any.whl

pyxllib/cv/slidercaptcha.py

@@ -0,0 +1,137 @@
+import os
+import cv2
+import numpy as np
+from xlproject.code4101 import XlPath
+
+from pyxllib.file.specialist import download_file
+from pyxllib.prog.pupil import is_url
+
+
+class SliderCaptchaLocator:
+    """ 滑动验证码的位置定位
+
+    由于缺口一般是一个黑底图，整体颜色是偏暗的，可以利用这个特性来定位列所在位置
+    """
+
+    def __init__(self, background_image_path, slider_image_path=None):
+        """
+        :param background_image_path: 背景主图片
+        :param slider_image_path: 滑动条图片
+        """
+        # 支持输入是url的情况
+        if is_url(background_image_path):
+            background_image_path = download_file(background_image_path, temp=True, ext='.png')
+        if is_url(slider_image_path):
+            slider_image_path = download_file(slider_image_path, temp=True, ext='.png')
+        # 初始化图片等数据
+        self.image_path = background_image_path
+        self.image = cv2.imread(self.image_path)
+        self.darkest_rows = None
+        self.column_averages = None
+        self.enhanced_averages = None
+        self.radius = 24
+        if slider_image_path is not None:
+            # 先读取图片
+            template_image = cv2.imread(slider_image_path)
+            # 取图片宽度的40%作为radius
+            self.radius = int(template_image.shape[1] * 0.4)
+
+    def select_darkest_part_rows(self, fraction=0.1):
+        """
+        选择最暗的部分行，供下游计算列的平均暗度
+
+        :param float fraction: 最暗行的比例
+        :return: 最暗行的图像部分
+        """
+        if self.darkest_rows is None:
+            average_row_values = np.mean(self.image, axis=(1, 2))
+            threshold_index = int(len(average_row_values) * fraction)
+            darkest_indices = np.argsort(average_row_values)[:threshold_index]
+            self.darkest_rows = self.image[darkest_indices]
+        return self.darkest_rows
+
+    def calculate_column_averages(self):
+        """
+        计算列的平均强度。
+
+        :return: 列的平均强度
+        """
+        if self.column_averages is None:
+            rows = self.select_darkest_part_rows()
+            column_values = np.mean(rows, axis=0)
+            column_intensity = np.mean(column_values, axis=1)
+            min_val, max_val = np.min(column_intensity), np.max(column_intensity)
+            self.column_averages = ((column_intensity - min_val) / (max_val - min_val) * 255).astype(
+                np.uint8) if max_val != min_val else np.zeros_like(column_intensity)
+        return self.column_averages
+
+    def enhance_column_averages(self):
+        """
+        增强列平均值，利用验证码的黑度图的对称性，进行一个增强，使得其他非验证码的零散黑条变白
+
+        :param int radius: 对比半径，这个建议设成模版图宽度的40%~50%
+        :return: 增强后的列平均值
+        """
+        if self.enhanced_averages is None:
+            averages = self.calculate_column_averages()
+            length = len(averages)
+            enhanced = np.zeros_like(averages)
+            for i in range(length):
+                max_value = averages[i]
+                for j in range(1, self.radius // 2 + 1):
+                    if i - j >= 0 and i + j < length:
+                        max_value = max(max_value, abs(int(averages[i - j]) - int(averages[i + j])))
+                enhanced[i] = max_value
+            self.enhanced_averages = enhanced
+        return self.enhanced_averages
+
+    def find_captcha_position(self, threshold=50):
+        """
+        查找验证码的位置。
+
+        :param int threshold: 达到多少像素后，开始计算中位数
+        :return: 验证码的列中心位置
+        """
+        intensities = self.enhance_column_averages()
+        indices = []
+        for intensity in range(256):
+            new_indices = np.where(intensities == intensity)[0]
+            if len(indices) + len(new_indices) > threshold:
+                indices.extend(new_indices[:threshold - len(indices)])
+                break
+            indices.extend(new_indices)
+        return int(np.median(indices))
+
+    def draw_red_line(self, position, line_thickness=3):
+        """
+        在图像上绘制红线。
+
+        :param int position: 红线位置
+        :param int line_thickness: 线宽
+        :return: 绘制红线后的图像
+        """
+        gray_image = np.tile(self.calculate_column_averages(), (100, 1)).astype(np.uint8)
+        color_image = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2BGR)
+        cv2.line(color_image, (position, 0), (position, gray_image.shape[0]), (0, 0, 255), line_thickness)
+        return color_image
+
+    def debug(self):
+        position = self.find_captcha_position()
+        final_image = self.draw_red_line(position)
+        cv2.imshow('Image with Red Line', final_image)
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+
+
+def main():
+    os.chdir(XlPath.desktop())
+    locator = SliderCaptchaLocator('cap_union_new_getcapbysig.png')
+    position = locator.find_captcha_position()
+    final_image = locator.draw_red_line(position)
+    cv2.imshow('Image with Red Line', final_image)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    main()

pyxllib/cv/trackbartools.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 # @Author : 陈坤泽
 # @Email  : 877362867@qq.com
-# @Data   : 2020/09/30 10:45
+# @Date   : 2020/09/30 10:45
 
 """
 这个文件默认不加载到cv里，需要使用的时候再导入
@@ -11,59 +11,151 @@ from pyxlib.cv.debugtools import *
 """
 
 import math
+import time
 
-from pyxllib.basic import TicToc
-from pyxllib.cv.cvlib import *
+import cv2
+import numpy as np
+
+from pyxllib.prog.specialist import TicToc
+from pyxllib.cv.expert import xlcv
 
 
 class TrackbarTool:
     """ 滑动条控件组
     """
 
-    def __init__(self, winname, img, flags=0):
-        img = xlcv.read(img)
-        cv2.namedWindow(winname, flags)
-        cv2.imshow(winname, img)
+    def __init__(self, winname=None, *, imgproc=None, img=None, flags=1, verbose=0, delay=100):
+        """
+        Args:
+            winname: 窗口名可以不输入，可以从func获取，或者有默认窗口名
+            imgproc: 有时候明确要对指定的函数进行可视化分析
+            img: 图片可以不输入，可以内置一个图片
+            flags: 0 窗口可以调节大小，1 窗口按照图片大小固定
+            verbose: 0 静默模式，1 显示每次运行时间，2 显示每次运行时间及参数值
+            delay: 有时候改动滑动条，并不想立即生效，可以设置延时，这里单位是ms
+                即如果delay时间段内已经有执行过回调函数，会避免重复执行
+        """
+
+        if winname is None:
+            if imgproc:
+                winname = imgproc.__name__
+            else:
+                winname = 'TrackbarTool'
+
+        if img is None:
+            img = np.zeros([500, 100, 3], dtype='uint8')
+        else:
+            img = xlcv.read(img)
+
         self.winname = winname
         self.img = img
+        cv2.namedWindow(winname, flags)
+        cv2.imshow(winname, self.img)
+
+        self.imgproc = imgproc
         self.trackbar_names = {}
 
+        self.verbose = verbose
+
+        self.delay = delay
+        self.last_run_time = 0
+
+    @classmethod
+    def from_album(cls, obj, **kwargs):
+        """ albumentations的类功能 """
+
+        def imgproc(img, **kws):
+            f = obj(**kws, p=1)  # p是概率，这里做可视化，是百分百执行
+            return f(image=img)['image']
+
+        return cls(**kwargs, imgproc=imgproc, winname=obj.__name__)
+
     def imshow(self, img=None):
         """ 刷新显示的图片 """
         if img is None:
             img = self.img
         cv2.imshow(self.winname, img)
 
-    def default_run(self, x):
+    def create_trackbar(self, name, count, value=0, *, vmaps=None, on_change=None):
+        """ 创建一个滑动条
+
+        :param name: 滑动条名称
+        :param int count: 上限值
+        :param int value: 初始值
+        :param list[func(int)] vmaps: 滑动条只能设置整数值，但有些参数不一定是整数，可以写个自定义的映射函数
+        :param on_change: 自定义，额外扩展的回调函数
+        :return:
+        """
+        if on_change is None:
+            on_change = self._on_change
+        self.trackbar_names[name] = {'count': count, 'value': value, 'vmaps': vmaps}
+        cv2.createTrackbar(name, self.winname, value, count, on_change)
+
+    def default_run(self, **kwargs):
         """ 默认执行器，这个在类继承后，基本都是要自定义成自己的功能的
 
-        TODO 从1滑到20，会运行20次，可以研究一个机制，来只运行一次
+        kwargs里存储了当前所有滑动条的取值
+        如果有设置vmap，
         """
-        kwargs = {}
-        for k in self.trackbar_names.keys():
-            kwargs[k] = self[k]
-        print(kwargs)
+        pass
 
-    def create_trackbar(self, trackbar_name, count, value=0, on_change=None):
-        """ 创建一个滑动条
+    def _on_change(self, x):
+        """ 默认的回调函数，x是对应滑动条当前的取值
 
-        :param trackbar_name: 滑动条名称
-        :param count: 上限值
-        :param on_change: 回调函数
-        :param value: 初始值
-        :return:
+        如果需要对每个特定滑动条做特殊定制操作，可以create_trackbar传入特殊on_change
+        这里的_on_change是所有滑动条统一回调版本，不区分是哪个滑动条改动了
         """
-        if on_change is None:
-            on_change = self.default_run
-        cv2.createTrackbar(trackbar_name, self.winname, value, count, on_change)
+        # 1 记录运行时间
+        cur_time = time.time() * 1000
+        if cur_time - self.last_run_time < self.delay:
+            return
+        else:
+            self.last_run_time = cur_time
+
+        # 2 生成、解析滑动条的参数值
+        kwargs = {}
+        for k, v in self.trackbar_names.items():
+            x = cv2.getTrackbarPos(k, self.winname)
+            if v['vmaps']:
+                for kk, func in v['vmaps'].items():
+                    kwargs[kk] = func(x)
+            else:
+                kwargs[k] = x
+
+        # 3 执行绑定的功能
+        tt = TicToc()
+        if self.imgproc:
+            try:
+                dst = self.imgproc(self.img, **kwargs)
+                self.imshow(dst)
+            except Exception as e:
+                if 'missing required argument' in e.args[0]:
+                    pass
+                else:
+                    raise e
+        else:
+            self.default_run(**kwargs)
+
+        # 4 是否显示运行信息
+        if self.verbose == 1:
+            tt.toc()
+        elif self.verbose == 2:
+            tt.toc(kwargs)
 
     def __getitem__(self, item):
         """ 可以通过 Trackbars 来获取滑动条当前值
 
         :param item: 滑动条名称
+            扩展：也支持获取vmaps后对应的名称及值
         :return: 当前取值
         """
-        return cv2.getTrackbarPos(item, self.winname)
+        if item in self.trackbar_names:
+            return cv2.getTrackbarPos(item, self.winname)
+        else:
+            for k, v in self.trackbar_names.items():
+                if v['vmaps'] and item in v['vmaps'].keys():
+                    x = cv2.getTrackbarPos(k, self.winname)
+                    return v['vmaps']['item'](x)
 
 
 class ErodeTool(TrackbarTool):
@@ -72,25 +164,18 @@ class ErodeTool(TrackbarTool):
     HoughLinesPTool('handwriting/C100001448573-002.png')
     """
 
-    def __init__(self, img, winname='ErodeTool', flags=1):
-        super().__init__(winname, img, flags)
-
-        # 1 增加控件
+    def __init__(self, img, winname='ErodeTool', flags=1, *, verbose=2):
+        super().__init__(winname, img=img, flags=flags, verbose=verbose)
         self.create_trackbar('size_x', 100, 15)
         self.create_trackbar('size_y', 100, 15)
 
-        # 2 初始化执行一遍
-        self.default_run(0)
-
-    def default_run(self, x):
+    def default_run(self, **kwargs):
         """ 默认执行器
         """
-        tt = TicToc()
-        size = self['size_x'], self['size_y']
+        size = kwargs['size_x'], kwargs['size_y']
         element = cv2.getStructuringElement(cv2.MORPH_RECT, size)
         dst = cv2.erode(self.img, element)
         self.imshow(dst)
-        tt.toc(f'element_size={size}')
 
 
 class HoughLinesPTool(TrackbarTool):
@@ -99,14 +184,14 @@ class HoughLinesPTool(TrackbarTool):
     HoughLinesPTool('handwriting/C100001448573-002.png')
     """
 
-    def __init__(self, img, winname='HoughLinesPTool', flags=1):
-        super().__init__(winname, img, flags)
+    def __init__(self, img, winname='HoughLinesPTool', flags=1, *, verbose=2):
+        super().__init__(winname, img=img, flags=flags, verbose=verbose)
 
         # 1 增加控件
         # 以像素为单位的距离精度
-        self.create_trackbar('rho*10', 100, 10)
+        self.create_trackbar('rho*10', 100, 10, vmaps={'rho': lambda x: x / 10})
         # 以弧度为单位的角度精度
-        self.create_trackbar('theta*pi/360', 10, 2)
+        self.create_trackbar('theta*pi/360', 10, 2, vmaps={'theta': lambda x: x * math.pi / 360})
         # 累加平面的阈值参数
         self.create_trackbar('threshold', 200, 80)
         # 最低线段长度
@@ -121,17 +206,46 @@ class HoughLinesPTool(TrackbarTool):
             gray_img = self.img
         self.binary_img = cv2.adaptiveThreshold(gray_img, 255, 0, 1, 11, 3)
 
-        # 3 初始化执行一遍
-        self.default_run(0)
-
-    def default_run(self, x):
+    def default_run(self, **kwargs):
         """ 默认执行器
         """
-        tt = TicToc()
-        lines = cv2.HoughLinesP(self.binary_img,
-                                self['rho*10'] / 10, self['theta*pi/360'] * math.pi / 360,
-                                self['threshold'], self['minLineLength'], self['maxLineGap'])
+        lines = cv2.HoughLinesP(self.binary_img, kwargs['rho'], kwargs['theta'],
+                                kwargs['threshold'], kwargs['minLineLength'], kwargs['maxLineGap'])
         if lines is None: lines = np.array([])
         # 处理用二值化，显示用原图
-        self.imshow(CvPlot.lines(self.img, lines))
-        tt.toc(f'x={x} lines.shape={lines.squeeze().shape}')
+        self.imshow(xlcv.lines(self.img, lines))
+
+
+def test_adaptiveThreshold(img=None):
+    """ 滑动条工具使用方法的示例 """
+    # 1 图片可以传入路径，这里做一个随机图片
+    if img is None:
+        img = np.random.randint(0, 255, [500, 200], dtype='uint8')
+    else:
+        img = xlcv.read(img, 0)  # 确保是单通道灰度图
+
+    # 2 指定要分析的函数
+    t = TrackbarTool(imgproc=cv2.adaptiveThreshold, img=img, verbose=2, delay=100)
+    t.create_trackbar('maxValue', 255, 255)  # 添加滑动条：名称，最大值，默认值
+    # 创建滑动条过程中，可能会报错，因为参数还不全，指定的imgproc还无法运行，可以先不用管
+    t.create_trackbar('adaptiveMethod', 10, 0)
+    t.create_trackbar('thresholdType', 10, 1)
+    t.create_trackbar('blockSize', 100, 11)
+    t.create_trackbar('C', 20, 3)
+    # t.imshow(img2)  # 临时显式其他图片处理效果。如果需要持久修改，可以更改self.img的值
+    cv2.waitKey()
+
+
+def test_CoarseDropout(img=None):
+    """ 做albumentations库里类功能的示例写法 """
+    import albumentations as A
+
+    if img is None:
+        img = np.random.randint(0, 255, [500, 200], dtype='uint8')
+
+    t = TrackbarTool.from_album(A.CoarseDropout, img=img, verbose=2)
+    t.create_trackbar('max_holes', 50, 8)
+    t.create_trackbar('max_height', 50, 8)
+    t.create_trackbar('max_width', 50, 8)
+    t.create_trackbar('fill_value', 255, 0)
+    cv2.waitKey()