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

pyxllib/cv/xlpillib.py

@@ -0,0 +1,423 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2021/08/25 15:57
+
+"""
+图方便的时候，PilImg和CvImg可以进行图片类型转换，然后互相引用彼此已有的一个实现版本
+为了性能的时候，则尽量减少各种绕弯，使用最源生的代码来实现
+"""
+
+import base64
+import io
+import os
+import random
+
+import cv2
+import numpy as np
+import PIL.ExifTags
+import PIL.Image
+import PIL.ImageOps
+import requests
+
+try:
+    import accimage
+except ImportError:
+    accimage = None
+
+from pyxllib.prog.pupil import inject_members
+from pyxllib.file.specialist import XlPath, get_font_file
+from pyxllib.cv.xlcvlib import xlcv
+
+
+class PilImg(PIL.Image.Image):
+
+    def __1_read(self):
+        pass
+
+    @classmethod
+    def read(cls, file, flags=None, *, apply_exif_orientation=False, **kwargs) -> 'PilImg':
+        if PilImg.is_pil_image(file):
+            im = file
+        elif xlcv.is_cv2_image(file):
+            im = xlcv.to_pil_image(file)
+        elif XlPath.safe_init(file):
+            im = PIL.Image.open(str(file), **kwargs)
+        else:
+            raise TypeError(f'类型错误或文件不存在：{type(file)} {file}')
+        if apply_exif_orientation:
+            im = PilImg.apply_exif_orientation(im)
+        return PilImg.cvt_channel(im, flags)
+
+    @classmethod
+    def read_from_buffer(cls, buffer, flags=None, *, b64decode=False):
+        """ 先用opencv实现，以后可以再研究PIL.Image.frombuffer是否有更快处理策略 """
+        if b64decode:
+            buffer = base64.b64decode(buffer)
+        im = PIL.Image.open(io.BytesIO(buffer))
+        return PilImg.cvt_channel(im, flags)
+
+    @classmethod
+    def read_from_url(cls, url, flags=None, *, b64decode=False):
+        content = requests.get(url).content
+        return PilImg.read_from_buffer(content, flags, b64decode=b64decode)
+
+    def __2_attrs(self):
+        pass
+
+    def imsize(self):
+        return self.size[::-1]
+
+    def n_channels(self):
+        """ 通道数 """
+        return len(self.getbands())
+
+    def __3_write(self):
+        pass
+
+    def to_cv2_image(self):
+        """ pil图片转np图片 """
+        y = np.array(self)
+        y = cv2.cvtColor(y, cv2.COLOR_BGR2RGB) if y.size else None
+        return y
+
+    def is_pil_image(self):
+        if accimage is not None:
+            return isinstance(self, (PIL.Image.Image, accimage.Image))
+        else:
+            return isinstance(self, PIL.Image.Image)
+
+    def write(self, path, *, if_exists=None, **kwargs):
+        p = XlPath(path)
+        if p.exist_preprcs(if_exists):
+            os.makedirs(p.parent, exist_ok=True)
+            suffix = p.suffix[1:]
+            if suffix.lower() == 'jpg':
+                suffix = 'jpeg'
+            if self.mode in ('RGBA', 'P') and suffix == 'jpeg':
+                im = self.convert('RGB')
+            else:
+                im = self
+            im.save(str(p), suffix, **kwargs)
+
+    def cvt_channel(self, flags=None):
+        im = self
+        if flags is None or flags == -1: return im
+        n_c = im.n_channels
+        if flags == 0 and n_c > 1:
+            im = im.convert('L')
+        elif flags == 1 and n_c != 3:
+            im = im.convert('RGB')
+        return im
+
+    def to_buffer(self, ext='.jpg', *, b64encode=False):
+        # 主要是偷懒，不想重写一遍，就直接去调用cv版本的实现了
+        return xlcv.to_buffer(self.to_cv2_image(), ext, b64encode=b64encode)
+
+    def display(self):
+        """ 在jupyter中展示 """
+        try:
+            from IPython.display import display
+            display(self)
+        except ModuleNotFoundError:
+            pass
+
+    def __4_plot(self):
+        pass
+
+    def plot_border(self, border=1, fill='black'):
+        """ 给图片加上边框
+
+        Args:
+            self:
+            border: 边框的厚度
+            fill: 边框颜色
+
+        Returns: 一张新图
+        """
+        from PIL import ImageOps
+        im2 = ImageOps.expand(self, border=border, fill=fill)
+        return im2
+
+    def plot_text(self, text, xy=None, font_size=10, font_type='simfang.ttf', **kwargs):
+        """
+        :param xy: 写入文本的起始坐标，没写入则自动写在垂直居中位置
+        """
+        from PIL import ImageFont, ImageDraw
+        font_file = get_font_file(font_type)
+        font = ImageFont.truetype(font=str(font_file), size=font_size, encoding="utf-8")
+        draw = ImageDraw.Draw(self)
+        if xy is None:
+            w, h = font_getsize(font, text)
+            xy = ((self.size[0] - w) / 2, (self.size[1] - h) / 2)
+        draw.text(xy, text, font=font, **kwargs)
+        return self
+
+    def __5_resize(self):
+        pass
+
+    def reduce_area(self, area):
+        """ 根据面积上限缩小图片
+
+        即图片面积超过area时，按照等比例缩小到面积为area的图片
+        """
+        im = self
+        h, w = PilImg.imsize(im)
+        s = h * w
+        if s > area:
+            r = (area / s) ** 0.5
+            size = int(r * h), int(r * w)
+            im = PilImg.resize2(im, size)
+        return im
+
+    def resize2(self, size, **kwargs):
+        """
+        :param size: 默认是 (w, h)， 这里我倒过来 (h, w)
+            但计算机领域，确实经常都是用 (w, h) 的格式，毕竟横轴是x，纵轴才是y
+        :param kwargs:
+            resample=3，插值算法；有PIL.Image.NEAREST, ~BOX, ~BILINEAR, ~HAMMING, ~BICUBIC, ~LANCZOS等
+                默认是 PIL.Image.BICUBIC；如果mode是"1"或"P"模式，则总是 PIL.Image.NEAREST
+
+        >>> im = read(np.zeros([100, 200], dtype='uint8'), 0)
+        >>> self.size
+        (100, 200)
+        >>> im2 = im.reduce_area(50*50, **kwargs)
+        >>> im2.size
+        (35, 70)
+        """
+        # 注意pil图像尺寸接口都是[w,h]，跟标准的[h,w]相反
+        return self.resize(size[::-1], **kwargs)
+
+    def evaluate_image_file_size(self, suffix='.jpeg'):
+        """ 评估图像存成文件后的大小
+
+        :param suffix: 使用的图片类型
+        :return int: 存储后的文件大小，单位为字节
+        """
+        im = self
+
+        # save接口不支持jpg参数
+        if suffix[0] == '.':
+            suffix = suffix[1:]
+        if suffix.lower() == 'jpg':
+            suffix = 'jpeg'
+
+        file = io.BytesIO()
+        if im.mode in ('RGBA', 'P') and suffix == 'jpeg':
+            im = im.convert('RGB')
+        im.save(file, suffix)
+        return len(file.getvalue())
+
+    def reduce_filesize(self, filesize=None, suffix='.jpeg'):
+        """ 按照保存后的文件大小来压缩im
+
+        :param filesize: 单位Bytes
+            int, 可以用 300*1024 来表示 300KB
+            None, 可以不输入，默认读取后按原尺寸返回，这样看似没变化，其实图片一读一写，是会对手机拍照的很多大图进行压缩的
+
+        >> reduce_filesize(im, 300*1024, 'jpg')
+        """
+        im = self
+        # 循环处理
+        while filesize:
+            r = xlpil.evaluate_image_file_size(im, suffix) / filesize
+            if r <= 1:
+                break
+
+            # 假设图片面积和文件大小成正比，如果r=4，表示长宽要各减小至1/(r**0.5)才能到目标文件大小
+            rate = min(1 / (r ** 0.5), 0.95)  # 并且限制每轮至少要缩小至95%，避免可能会迭代太多轮
+            im = im.resize((int(im.size[0] * rate), int(im.size[1] * rate)))
+        return im
+
+    def trim(self, *, border=0, color=None):
+        """ 默认裁剪掉白色边缘，可以配合 get_backgroup_color 裁剪掉背景色
+
+        :param border: 上下左右保留多少边缘
+            输入一个整数，表示统一留边
+            也可以输入[int, int, int, int]，分别表示left top right bottom留白
+        :param color: 要裁剪的颜色，这是精确值，没有误差，如果需要模糊，可以提前预处理成精确值
+            这个默认值设成None，本来是想说支持灰度图，此时输入一个255的值就好
+            但是pil的灰度图机制好像有些不太一样，总之目前默认值还是自动会设成 (255, 255, 255)
+        :param percent-background: TODO 控制裁剪百分比上限
+        """
+        from PIL import Image, ImageChops
+        from pyxllib.algo.geo import xywh2ltrb, ltrb2xywh, ltrb_border
+
+        if color is None:
+            color = (255, 255, 255)
+        else:
+            color = tuple(color)
+
+        # 如果图片通道数跟预设的color不同，要断言
+        assert self.n_channels() == len(color), f'图片通道数{self.n_channels}跟预设的color{color}不同'
+
+        im = self
+        bg = Image.new(im.mode, im.size, color)
+        diff = ImageChops.difference(im, bg)
+        bbox = diff.getbbox()  # 如果im跟bg一样，也就是裁"消失"了，此时bbox值为None
+        if bbox:
+            if border:
+                ltrb = xywh2ltrb(bbox)
+                ltrb = ltrb_border(ltrb, border, im.size)
+                bbox = ltrb2xywh(ltrb)
+            im = im.crop(bbox)
+        return im
+
+    def __6_warp(self):
+        pass
+
+    def __x_other(self):
+        pass
+
+    def random_direction(self):
+        """ 假设原图片是未旋转的状态0
+
+        顺时针转90度是label=1，顺时针转180度是label2 ...
+        """
+        im = self
+        label = np.random.randint(4)
+        if label == 1:
+            # PIL的旋转角度，是指逆时针角度；但是我这里编号是顺时针
+            im = im.transpose(PIL.Image.ROTATE_270)
+        elif label == 2:
+            im = im.transpose(PIL.Image.ROTATE_180)
+        elif label == 3:
+            im = im.transpose(PIL.Image.ROTATE_90)
+        return im, label
+
+    def flip_direction(self, direction):
+        """
+        :param direction: 顺时针旋转几个90度
+            标记现在图片是哪个方向：0是正常，1是向右翻转，2是向下翻转，3是向左翻转
+        """
+        im = self
+        direction = direction % 4
+        if direction:
+            im = im.transpose({1: PIL.Image.ROTATE_270,
+                               2: PIL.Image.ROTATE_180,
+                               3: PIL.Image.ROTATE_90}[direction])
+        return im
+
+    def apply_exif_orientation(self):
+        """ 摆正图片角度
+
+        Image.open读取图片时，是手机严格正放时拍到的图片效果，
+        但手机拍照时是会记录旋转位置的，即可以判断是物理空间中，实际朝上、朝下的方向，
+        从而识别出正拍（代号1），顺时针旋转90度拍摄（代号8），顺时针180度拍摄（代号3）,顺时针270度拍摄（代号6）。
+        windows上的图片查阅软件能识别方向代号后正确摆放；
+        为了让python处理图片的时候能增加这个属性的考虑，这个函数能修正识别角度返回新的图片。
+
+        我自己写过个版本，后来发现 labelme.utils.image 写过功能更强的，抄了过来~~
+        """
+        im = self
+        try:
+            exif = im._getexif()
+        except AttributeError:
+            exif = None
+
+        if exif is None:
+            return im
+
+        exif = {
+            PIL.ExifTags.TAGS[k]: v
+            for k, v in exif.items()
+            if k in PIL.ExifTags.TAGS
+        }
+
+        orientation = exif.get("Orientation", None)
+
+        if orientation == 1:
+            # do nothing
+            return im
+        elif orientation == 2:
+            # left-to-right mirror
+            return PIL.ImageOps.mirror(im)
+        elif orientation == 3:
+            # rotate 180
+            return im.transpose(PIL.Image.ROTATE_180)
+        elif orientation == 4:
+            # top-to-bottom mirror
+            return PIL.ImageOps.flip(im)
+        elif orientation == 5:
+            # top-to-left mirror
+            return PIL.ImageOps.mirror(im.transpose(PIL.Image.ROTATE_270))
+        elif orientation == 6:
+            # rotate 270
+            return im.transpose(PIL.Image.ROTATE_270)
+        elif orientation == 7:
+            # top-to-right mirror
+            return PIL.ImageOps.mirror(im.transpose(PIL.Image.ROTATE_90))
+        elif orientation == 8:
+            # rotate 90
+            return im.transpose(PIL.Image.ROTATE_90)
+        else:
+            return im
+
+    def get_exif(self):
+        """ 旧函数名：查看图片的Exif信息 """
+        exif_data = self._getexif()
+        if exif_data:
+            exif = {PIL.ExifTags.TAGS[k]: v for k, v in exif_data.items() if k in PIL.ExifTags.TAGS}
+        else:
+            exif = None
+        return exif
+
+    def rgba2rgb(self):
+        if self.mode in ('RGBA', 'P'):
+            # 判断图片mode模式，如果是RGBA或P等可能有透明底，则和一个白底图片合成去除透明底
+            background = PIL.Image.new('RGBA', self.size, (255, 255, 255))
+            # composite是合成的意思。将右图的alpha替换为左图内容
+            self = PIL.Image.alpha_composite(background, self.convert('RGBA')).convert('RGB')
+        return self
+
+    def keep_subtitles(self, judge_func=None, trim_color=(255, 255, 255)):
+        im = self.to_cv2_image()
+        im = im.keep_subtitles(judge_func=judge_func, trim_color=trim_color)
+        return im.to_pil_image()
+
+
+# pil相比cv，由于无法类似CvImg这样新建一个和np.ndarray等效的类，所以还是比较支持嵌入到Image中直接操作
+inject_members(PilImg, PIL.Image.Image)
+
+xlpil = PilImg  # 与xlcv对称
+
+
+def font_getsize(font, text):
+    """ 官方自带的font.getsize遇到换行符的text，计算不准确
+    """
+    texts = text.split('\n')
+    sizes = [font.getsize(t) for t in texts]
+    w = max([w for w, h in sizes])
+    h = sum([h for w, h in sizes])
+    return w, h
+
+
+def create_text_image(text, size=None, *, xy=None, font_size=14, bg_color=None, text_color=None, **kwargs):
+    """ 生成文字图片
+
+    :param size: 注意我这里顺序是 (height, width)
+        默认None，根据写入的文字动态生成图片大小
+    :param bg_color: 背景图颜色，如 (0, 0, 0)
+        默认None，随机颜色
+    :param text_color: 文本颜色，如 (255, 255, 255)
+        默认None，随机颜色
+    """
+    if size is None:
+        from PIL import ImageFont, ImageDraw
+        font_file = get_font_file(kwargs.get('font_type', 'simfang.ttf'))
+        font = ImageFont.truetype(font=str(font_file), size=font_size, encoding="utf-8")
+        w, h = font_getsize(font, text)
+        size = (h + 10, w + 10)
+        xy = (5, 0)  # 自动生成尺寸的情况下，文本从左上角开始写
+
+    if bg_color is None:
+        bg_color = tuple([random.randint(0, 255) for i in range(3)])
+    if text_color is None:
+        text_color = tuple([random.randint(0, 255) for i in range(3)])
+
+    h, w = size
+    im: PilImg = PIL.Image.new('RGB', (w, h), tuple(bg_color))
+    im2 = im.plot_text(text, xy=xy, font_size=font_size, fill=tuple(text_color), **kwargs)
+
+    return im2

pyxllib/data/echarts.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2022/02/09 11:14
+
+
+"""
+Apache ECharts: https://echarts.apache.org/zh/index.html
+python版：pyechats的封装
+"""
+
+from pyxllib.prog.pupil import check_install_package
+
+check_install_package('pyecharts')
+
+# import types
+
+import pyecharts
+from pyecharts import options as opts
+from pyecharts.commons.utils import JsCode
+from pyecharts.globals import ChartType
+from pyecharts import types
+from pyecharts.charts import Bar, Line, Radar
+from pyecharts.charts.chart import Chart
+
+from pyxllib.prog.pupil import inject_members
+from pyxllib.prog.specialist import TicToc
+from pyxllib.file.specialist import XlPath
+
+
+class XlChart(Chart):
+    def set_title(self, title):
+        self.set_global_opts(title_opts=pyecharts.options.TitleOpts(title=title))
+
+    def add_series(self, name, data, *, type=None, color=None, labels=None,
+                   **kwargs):
+        """ 垃圾pyecharts，毁我青春~~
+
+        很多图x都不是等间距的，pyecharts处理不等间距x好像有很大的不兼容问题
+        需要手动添加x、y坐标位置
+
+        :param list|tuple labels: 直接提供现成的文本标签
+
+        """
+        if type is None:
+            type = self.__class__.__name__.lower()
+
+        if labels:
+            s = [[x[0][0], x[1]] for x in zip(data, labels)]
+            fmt = JsCode(f"function(x){{var m = new Map({s}); return m.get(x.value[0]);}}")
+            if 'label' not in kwargs:
+                kwargs['label'] = opts.LabelOpts(is_show=True, formatter=fmt)
+            elif isinstance(kwargs['label'], opts.LabelOpts):
+                kwargs['label'].opts['formatter'] = fmt
+            else:
+                kwargs['label']['show'] = True
+                kwargs['label']['formatter'] = fmt
+
+        self._append_color(color)
+        # self._append_legend(name, is_selected=True)
+        self._append_legend(name)
+
+        self.options.get('series').append(
+            {
+                'type': type,
+                'name': name,
+                'data': data,
+                **kwargs,
+            }
+        )
+        return self
+
+
+inject_members(XlChart, Chart)
+
+
+class XlLine(Line):
+    @classmethod
+    def from_dict(cls, yaxis, xaxis=None, *, title=None,
+                  xaxis_name=None, yaxis_name=None, **kwargs):
+        """ 查看一个数据的折线图
+
+        :param list|dict yaxis: 列表数据，或者字典name: values表示的多组数据
+        """
+        c = cls()
+
+        if isinstance(yaxis, (list, tuple)):
+            yaxis = {'value': yaxis}
+        if xaxis is None:
+            xaxis = list(range(max([len(v) for v in yaxis.values()])))
+        c.add_xaxis(xaxis)
+        for k, v in yaxis.items():
+            c.add_yaxis(k, v)
+
+        configs = {
+            'tooltip_opts': opts.TooltipOpts(trigger="axis"),
+            **kwargs,
+        }
+        c.set_global_opts(tooltip_opts=opts.TooltipOpts(trigger="axis"))
+        if title:
+            configs['title_opts'] = opts.TitleOpts(title=title)
+        if xaxis_name:
+            configs['xaxis_opts'] = opts.AxisOpts(name=xaxis_name, axislabel_opts=opts.LabelOpts(rotate=45, interval=0))
+        if yaxis_name:
+            configs['yaxis_opts'] = opts.AxisOpts(name=yaxis_name)
+        c.set_global_opts(**configs)
+        return c
+
+
+class XlBar(Bar):
+
+    @classmethod
+    def from_dict(cls, yaxis, xaxis=None, *, title=None,
+                  xaxis_name=None, yaxis_name=None, **kwargs):
+        """ 查看一个数据的条形图
+
+        :param list|dict yaxis: 列表数据，或者字典name: values表示的多组数据
+        """
+        c = cls()
+
+        if isinstance(yaxis, (list, tuple)):
+            yaxis = {'value': yaxis}
+        if xaxis is None:
+            xaxis = list(range(max([len(v) for v in yaxis.values()])))
+        c.add_xaxis(xaxis)
+        for k, v in yaxis.items():
+            c.add_yaxis(k, v)
+
+        configs = {
+            'tooltip_opts': opts.TooltipOpts(trigger="axis"),
+            **kwargs,
+        }
+        c.set_global_opts(tooltip_opts=opts.TooltipOpts(trigger="axis"))
+        if title:
+            configs['title_opts'] = opts.TitleOpts(title=title)
+        if xaxis_name:
+            configs['xaxis_opts'] = opts.AxisOpts(name=xaxis_name)
+        if yaxis_name:
+            configs['yaxis_opts'] = opts.AxisOpts(name=yaxis_name)
+        c.set_global_opts(**configs)
+        return c
+
+    @classmethod
+    def from_list(cls, yaxis, xaxis=None, *, title=None):
+        """
+        >> browser(pyecharts.charts.Bar.from_list(numbers))
+        """
+        return cls.from_dict({'value': list(yaxis)}, xaxis=xaxis, title=title)
+
+    @classmethod
+    def from_data_split_into_groups(cls, data, groups, *, title=None):
+        """根据给定的组数自动拆分数据并生成条形图
+        :param list data: 数据清单
+        :param int groups: 要拆分成的组数
+        """
+        # 找到最大值和最小值
+        min_val, max_val = min(data), max(data)
+
+        # 计算间隔
+        interval = (max_val - min_val) / groups
+
+        # 分组和标签
+        group_counts = [0] * groups
+        labels = []
+        # todo 如果数据量特别大，这里应该排序后，再用特殊方法计算分组
+        for value in data:
+            index = min(int((value - min_val) / interval), groups - 1)
+            group_counts[index] += 1
+
+        for i in range(groups):
+            labels.append(f"{min_val + interval * i:.2f}-{min_val + interval * (i + 1):.2f}")
+        # t = cls.from_dict({'value': group_counts}, xaxis=labels, title=title)
+
+        return cls.from_dict({'value': group_counts}, xaxis=labels, title=title)
+
+
+class XlRadar(Radar):
+    """ 雷达图 """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.color_idx = 0
+
+    def add(
+            self,
+            series_name: str,
+            data: types.Sequence[types.Union[opts.RadarItem, dict]],
+            *,
+            label_opts=None,
+            color: types.Optional[str] = None,
+            linestyle_opts=None,
+            **kwargs
+    ):
+        """ 标准库(2.0.5版)的雷达图颜色渲染有问题，这里要增加一个修正过程 """
+        if label_opts is None:
+            label_opts = opts.LabelOpts(is_show=False)
+
+        if linestyle_opts is None:
+            linestyle_opts = opts.LineStyleOpts(color=self.colors[self.color_idx % len(self.colors)])
+            self.color_idx += 1
+        elif linestyle_opts.get('color') is None:
+            linestyle_opts.update(color=self.colors[self.color_idx % len(self.colors)])
+            self.color_idx += 1
+
+        if color is None:
+            color = linestyle_opts.get('color')
+
+        return super(XlRadar, self).add(series_name, data,
+                                        label_opts=label_opts,
+                                        color=color,
+                                        linestyle_opts=linestyle_opts,
+                                        **kwargs)
+
+
+inject_members(XlBar, Bar)
+
+
+def render_echart_html(title='Awesome-pyecharts', body=''):
+    from pyxllib.text.xmllib import get_jinja_template
+    return get_jinja_template('echart_base.html').render(title=title, body=body)
+
+
+# 绘制帕累托累计图
+def draw_pareto_chart(data, accuracy=0.1, *, title='帕累托累积权重', value_unit_type='K'):
+    from pyxllib.algo.stat import pareto_accumulate
+    pts, labels = pareto_accumulate(data, accuracy=accuracy, value_unit_type=value_unit_type)
+    x = Line()
+    x.add_series(title, pts, labels=labels, label={'position': 'right'})
+    x.set_global_opts(
+        # x轴末尾要故意撑大一些，不然有部分内容会显示不全
+        xaxis_opts=opts.AxisOpts(name='条目数', max_=int(float(f'{pts[-1][0] * 1.2:.2g}'))),
+        yaxis_opts=opts.AxisOpts(name='累积和')
+    )
+    return x
+
+
+if __name__ == '__main__':
+    with TicToc(__name__):
+        pass