py-img-processor 1.0.0__py3-none-any.whl

imgprocessor/parsers/base.py

@@ -0,0 +1,353 @@
+import typing
+
+try:
+    # python3.11只后
+    from typing import Self  # type: ignore
+except Exception:
+    from typing_extensions import Self
+
+import re
+
+from PIL import Image, ImageOps
+
+from imgprocessor import enums, utils
+from imgprocessor.exceptions import ParamValidateException, ParamParseException
+
+
+class BaseParser(object):
+    # 用来定义参数
+    KEY: typing.Any = ""
+    ARGS: dict = {}
+
+    def __init__(self, **kwargs: typing.Any) -> None:
+        pass
+
+    @classmethod
+    def init(cls, data: dict, enable_base64: bool = False) -> Self:
+        params = cls.validate_args(enable_base64=enable_base64, **data)
+        ins = cls(**params)
+        ins.validate()
+        return ins
+
+    @classmethod
+    def init_by_str(cls, param_str: str) -> Self:
+        data = cls.parse_str(param_str)
+        return cls.init(data, enable_base64=True)
+
+    def validate(self) -> None:
+        """由子类继承实现各类实例的数据校验"""
+        pass
+
+    def do_action(self, im: Image) -> Image:
+        raise NotImplementedError
+
+    def to_dict(self) -> dict:
+        data = {}
+        for k in self.ARGS.keys():
+            if k in self.__dict__:
+                data[k] = self.__dict__.get(k)
+        return data
+
+    @classmethod
+    def validate_args(cls, enable_base64: bool = False, **kwargs: typing.Any) -> dict:
+        data = {}
+        for key, config in cls.ARGS.items():
+            _type = config["type"]
+            _default = config.get("default")
+            if key not in kwargs:
+                required = config.get("required")
+                if required:
+                    raise ParamValidateException(f"缺少必要参数{key}")
+                # 配置的default仅当在没有传递值的时候才生效
+                if _default is not None:
+                    data[key] = _default
+            else:
+                value = kwargs.get(key)
+                try:
+                    if _type == enums.ArgType.INTEGER:
+                        value = cls._validate_number(value, **config)
+                    elif _type == enums.ArgType.FLOAT:
+                        value = cls._validate_number(value, use_float=True, **config)
+                    elif _type == enums.ArgType.STRING:
+                        value = cls._validate_str(value, enable_base64=enable_base64, **config)
+
+                    choices = config.get("choices")
+                    if choices and value not in choices:
+                        raise ParamValidateException(f"{key}枚举值只能是其中之一 {choices.values}")
+                except ParamValidateException as e:
+                    raise ParamValidateException(f"参数 {key}={value} 不符合要求：{e}")
+                data[key] = value
+
+        return data
+
+    @classmethod
+    def _validate_str(
+        cls,
+        value: typing.Any,
+        enable_base64: bool = False,
+        regex: typing.Optional[str] = None,
+        base64_encode: bool = False,
+        max_length: typing.Optional[int] = None,
+        **kwargs: dict,
+    ) -> str:
+        if not isinstance(value, str):
+            raise ParamValidateException("参数类型不符合要求，必须是字符串类型")
+        if enable_base64 and base64_encode:
+            value = utils.base64url_decode(value)
+        if max_length is not None and len(value) > max_length:
+            raise ParamValidateException(f"长度不允许超过{max_length}个字符")
+        if regex and not re.match(regex, value):
+            raise ParamValidateException(f"不符合格式要求，需符合正则：{regex}")
+        return value
+
+    @classmethod
+    def _validate_number(
+        cls,
+        value: typing.Any,
+        min: typing.Optional[int] = None,
+        max: typing.Optional[int] = None,
+        use_float: bool = False,
+        **kwargs: dict,
+    ) -> typing.Union[int, float]:
+        if isinstance(value, int) or (use_float and isinstance(value, (int, float))):
+            v = value
+        elif isinstance(value, str):
+            if not value.isdigit():
+                if use_float:
+                    try:
+                        v = float(value)
+                    except Exception:
+                        raise ParamValidateException("参数类型不符合要求，必须是数值")
+                else:
+                    raise ParamValidateException("参数类型不符合要求，必须是整数")
+            else:
+                v = int(value)
+        else:
+            raise ParamValidateException("必须是整数")
+        if min is not None and v < min:
+            raise ParamValidateException(f"参数不在取值范围内，最小值为{min}")
+        if max is not None and v > max:
+            raise ParamValidateException(f"参数不在取值范围内，最大值为{max}")
+
+        return v
+
+    @classmethod
+    def parse_str(cls, param_str: str) -> dict:
+        """将字符串参数转化为json格式数据
+
+        Args:
+            param_str: 字符串参数，示例：`resize,h_100,m_lfit`
+
+        Raises:
+            exceptions.ParseParamException: 解析参数不符合预期会抛出异常
+
+        Returns:
+            输出json格式参数，例如返回`{"key": "resize", "h": "100", "m": "lfit"}`
+        """
+        params = {}
+        info = param_str.split(",")
+        key = info[0]
+        if key != cls.KEY:
+            raise ParamParseException(f"解析出来的key={key}与{cls.__name__}.KEY={cls.KEY}不匹配")
+        for item in info[1:]:
+            info = item.split("_", 1)
+            if len(info) == 2:
+                k, v = info
+                params[k] = v
+            else:
+                params["value"] = info[0]
+
+        params["key"] = key
+        return params
+
+
+def pre_processing(im: Image, use_alpha: bool = False) -> Image:
+    """预处理图像，默认转成`RGB`，若为`use_alpha=True`转为`RGBA`
+
+    Args:
+        im: 输入图像
+        use_alpha: 是否处理透明度
+
+    Returns:
+        输出图像
+    """
+    # 去掉方向信息
+    orientation = im.getexif().get(0x0112)
+    if orientation and 2 <= orientation <= 8:
+        im = ImageOps.exif_transpose(im)
+
+    if im.mode not in ["RGB", "RGBA"]:
+        # 统一处理成RGBA进行操作:
+        # 1. 像rotate/resize操作需要RGB模式；
+        # 2. 像水印操作需要RGBA；
+        im = im.convert("RGBA")
+
+    if use_alpha and im.mode != "RGBA":
+        im = im.convert("RGBA")
+
+    return im
+
+
+def compute_by_geography(
+    src_w: int, src_h: int, x: int, y: int, w: int, h: int, g: typing.Optional[str], pf: str
+) -> tuple[int, int]:
+    """计算 大小(w,h)的图像相对于(src_w, src_h)图像的原点(x,y)位置"""
+    if g == enums.Geography.NW:
+        x, y = 0, 0
+    elif g == enums.Geography.NORTH:
+        x, y = int(src_w / 2 - w / 2), 0
+    elif g == enums.Geography.NE:
+        x, y = src_w - w, 0
+    elif g == enums.Geography.WEST:
+        x, y = 0, int(src_h / 2 - h / 2)
+    elif g == enums.Geography.CENTER:
+        x, y = int(src_w / 2 - w / 2), int(src_h / 2 - h / 2)
+    elif g == enums.Geography.EAST:
+        x, y = src_w - w, int(src_h / 2 - h / 2)
+    elif g == enums.Geography.SW:
+        x, y = 0, src_h - h
+    elif g == enums.Geography.SOUTH:
+        x, y = int(src_w / 2 - w / 2), src_h - h
+    elif g == enums.Geography.SE:
+        x, y = src_w - w, src_h - h
+    elif pf:
+        if "x" in pf:
+            if x < 0 or x > 100:
+                raise ParamValidateException(f"pf={pf}包含了x，所以x作为百分比取值范围为[0,100]")
+            x = int(src_w * x / 100)
+        if "y" in pf:
+            if y < 0 or y > 100:
+                raise ParamValidateException(f"pf={pf}包含了y，所以y作为百分比取值范围为[0,100]")
+            y = int(src_h * y / 100)
+    return x, y
+
+
+def compute_by_ratio(src_w: int, src_h: int, ratio: str) -> tuple[int, int]:
+    """根据输入宽高，按照比例比计算出最大区域
+
+    Args:
+        src_w: 输入宽度
+        src_h: 输入高度
+        ratio: 比例字符串，eg "4:3"
+
+    Returns:
+        计算后的宽高
+    """
+    w_r, h_r = ratio.split(":")
+    wr, hr = int(w_r), int(h_r)
+    if src_w * hr > src_h * wr:
+        # 相对于目标比例，宽长了
+        w = int(src_h * wr / hr)
+        h = src_h
+    elif src_w * hr < src_h * wr:
+        w = src_w
+        h = int(src_w * hr / wr)
+    else:
+        # 刚好符合比例
+        w, h = src_w, src_h
+    return w, h
+
+
+def compute_splice_two_im(
+    w1: int,
+    h1: int,
+    w2: int,
+    h2: int,
+    align: int = enums.PositionAlign.VERTIAL_CENTER,  # type: ignore
+    order: int = enums.PositionOrder.BEFORE,  # type: ignore
+    interval: int = 0,
+) -> tuple:
+    """拼接2个图像，计算整体大小和元素原点位置；数值单位都是像素
+
+    Args:
+        w1: 第1个元素的宽
+        h1: 第1个元素的高
+        w2: 第2个元素的宽
+        h2: 第2个元素的高
+        align: 对齐方式  see enums.PositionAlign
+        order: 排序 see enums.PositionOrder
+        interval: 元素之间的间隔
+
+    Returns:
+        整体占位w宽度
+        整体占位y宽度
+        第1个元素的原点位置x1
+        第1个元素的原点位置y1
+        第2个元素的原点位置x2
+        第2个元素的原点位置y2
+    """
+    if align in [enums.PositionAlign.TOP, enums.PositionAlign.HORIZONTAL_CENTER, enums.PositionAlign.BOTTOM]:
+        # 水平顺序
+        # 计算整体占位大小w,h
+        w, h = w1 + w2 + interval, max(h1, h2)
+
+        if align == enums.PositionAlign.TOP:
+            y1, y2 = 0, 0
+        elif align == enums.PositionAlign.BOTTOM:
+            y1, y2 = h - h1, h - h2
+        else:
+            y1, y2 = int((h - h1) / 2), int((h - h2) / 2)
+
+        if order == enums.PositionOrder.BEFORE:
+            x1, x2 = 0, w1 + interval
+        else:
+            x1, x2 = w2 + interval, 0
+    else:
+        # 垂直
+        w, h = max(w1, w2), h1 + h2 + interval
+        if align == enums.PositionAlign.LEFT:
+            x1, x2 = 0, 0
+        elif align == enums.PositionAlign.RIGHT:
+            x1, x2 = w - w1, w - w2
+        else:
+            x1, x2 = int((w - w1) / 2), int((w - w2) / 2)
+
+        if order == enums.PositionOrder.BEFORE:
+            y1, y2 = 0, h1 + interval
+        else:
+            y1, y2 = h2 + interval, 0
+
+    return w, h, x1, y1, x2, y2
+
+
+class ImgSaveParser(BaseParser):
+    KEY = ""
+    ARGS = {
+        "format": {"type": enums.ArgType.STRING, "default": None},
+        "quality": {"type": enums.ArgType.INTEGER, "default": None, "min": 1, "max": 100},
+        # 1 表示将原图设置成渐进显示
+        "interlace": {"type": enums.ArgType.INTEGER, "default": 0, "choices": [0, 1]},
+    }
+
+    def __init__(
+        self,
+        format: typing.Optional[str] = None,
+        quality: typing.Optional[int] = None,
+        interlace: int = 0,
+        **kwargs: typing.Any,
+    ) -> None:
+        self.format = format
+        self.quality = quality
+        self.interlace = interlace
+
+    def validate(self) -> None:
+        super().validate()
+        if self.format:
+            fmt_values = [v.lower() for v in enums.ImageFormat.values]
+            if self.format not in fmt_values:
+                raise ParamValidateException(f"参数 format 只能是其中之一：{fmt_values}")
+
+    def compute(self, in_im: Image, out_im: Image) -> dict:
+        kwargs = {
+            "format": self.format or in_im.format,
+            # png 和 gif 格式的选项是 interlace（一般翻译成交错），jpeg(jpg) 的选项则是 progressive （翻译成 渐进）
+            "progressive": True if self.interlace else False,
+            "interlace": self.interlace,
+        }
+        # 为了解决色域问题
+        icc_profile = in_im.info.get("icc_profile")
+        if icc_profile:
+            kwargs["icc_profile"] = icc_profile
+        if self.quality:
+            kwargs["quality"] = self.quality
+        return kwargs

imgprocessor/parsers/blur.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+
+from PIL import Image, ImageFilter
+
+from imgprocessor import enums
+from .base import BaseParser, pre_processing
+
+
+class BlurParser(BaseParser):
+
+    KEY = enums.OpAction.BLUR
+    ARGS = {
+        # 模糊半径，值越大，图片越模糊
+        "r": {"type": enums.ArgType.INTEGER, "required": True, "min": 1, "max": 50},
+    }
+
+    def __init__(
+        self,
+        r: int = 0,
+        **kwargs: typing.Any,
+    ) -> None:
+        self.r = r
+
+    def do_action(self, im: Image) -> Image:
+        im = pre_processing(im)
+        im = im.filter(ImageFilter.GaussianBlur(radius=self.r))
+        return im

imgprocessor/parsers/circle.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+
+from PIL import Image, ImageDraw
+
+from imgprocessor import enums, settings
+from .base import BaseParser, pre_processing
+
+
+class CircleParser(BaseParser):
+
+    KEY = enums.OpAction.CIRCLE
+    ARGS = {
+        "r": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": settings.PROCESSOR_MAX_W_H},
+    }
+
+    def __init__(
+        self,
+        r: int = 0,
+        **kwargs: typing.Any,
+    ) -> None:
+        self.r = r
+
+    def compute(self, src_w: int, src_h: int) -> int:
+        r = self.r
+
+        min_s = int(min(src_w, src_h) / 2)
+        if not r or r > min_s:
+            # 没有设置或是超过最大内切圆的半径，按照最大内切圆的半径处理
+            r = min_s
+
+        return r
+
+    def do_action(self, im: Image) -> Image:
+        im = pre_processing(im, use_alpha=True)
+
+        src_w, src_h = im.size
+        rad = self.compute(*im.size)
+        # 放大倍数，解决圆角锯齿问题
+        expand = 6
+        new_rad = rad * expand
+        circle = Image.new("L", (new_rad * 2, new_rad * 2), 0)
+        ImageDraw.Draw(circle).ellipse((0, 0, new_rad * 2, new_rad * 2), fill=255)
+        circle = circle.resize((rad * 2, rad * 2), resample=Image.LANCZOS)
+
+        alpha = Image.new("L", (src_w, src_h), 255)
+        alpha.paste(circle.crop((0, 0, rad, rad)), (0, 0))
+        alpha.paste(circle.crop((0, rad, rad, rad * 2)), (0, src_h - rad))
+        alpha.paste(circle.crop((rad, 0, rad * 2, rad)), (src_w - rad, 0))
+        alpha.paste(circle.crop((rad, rad, rad * 2, rad * 2)), (src_w - rad, src_h - rad))
+        im.putalpha(alpha)
+        return im

imgprocessor/parsers/crop.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+from PIL import Image
+from imgprocessor import enums, settings
+from imgprocessor.exceptions import ParamValidateException
+from .base import BaseParser, pre_processing, compute_by_geography, compute_by_ratio
+
+
+class CropParser(BaseParser):
+
+    KEY = enums.OpAction.CROP
+    ARGS = {
+        "w": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": settings.PROCESSOR_MAX_W_H},
+        "h": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": settings.PROCESSOR_MAX_W_H},
+        "ratio": {"type": enums.ArgType.STRING, "regex": r"^\d+:\d+$"},
+        "x": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": settings.PROCESSOR_MAX_W_H},
+        "y": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": settings.PROCESSOR_MAX_W_H},
+        "g": {"type": enums.ArgType.STRING, "choices": enums.Geography},
+        # percent field, eg: xywh
+        "pf": {"type": enums.ArgType.STRING, "default": ""},
+        # padding right
+        "padr": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": settings.PROCESSOR_MAX_W_H},
+        # padding bottom
+        "padb": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": settings.PROCESSOR_MAX_W_H},
+        # 左和上通过x,y控制
+    }
+
+    def __init__(
+        self,
+        w: int = 0,
+        h: int = 0,
+        ratio: typing.Optional[str] = None,
+        x: int = 0,
+        y: int = 0,
+        g: typing.Optional[str] = None,
+        pf: str = "",
+        padr: int = 0,
+        padb: int = 0,
+        **kwargs: typing.Any,
+    ) -> None:
+        self.w = w
+        self.h = h
+        self.ratio = ratio
+        self.x = x
+        self.y = y
+        self.g = g
+        self.pf = pf
+        self.padr = padr
+        self.padb = padb
+
+    def compute(self, src_w: int, src_h: int) -> tuple:
+        x, y, w, h = self.x, self.y, self.w, self.h
+
+        pf = self.pf or ""
+        if self.g:
+            # g在的时候pf不生效
+            pf = ""
+
+        # 处理w,h; w,h默认原图大小
+        if self.ratio:
+            w, h = compute_by_ratio(src_w, src_h, self.ratio)
+        else:
+            if "w" in pf:
+                if w < 0 or w > 100:
+                    raise ParamValidateException(f"pf={pf}包含了w，所以w作为百分比取值范围为[0,100]")
+                w = int(src_w * w / 100)
+            elif not w:
+                w = src_w
+
+            if "h" in pf:
+                if h < 0 or h > 100:
+                    raise ParamValidateException(f"pf={pf}包含了h，所以h作为百分比取值范围为[0,100]")
+                h = int(src_h * h / 100)
+            elif not h:
+                h = src_h
+
+        # 按照其他方式计算x,y
+        x, y = compute_by_geography(src_w, src_h, x, y, w, h, self.g, pf)
+
+        # 处理裁边
+        if self.padr:
+            w = w - self.padr
+        if self.padb:
+            h = h - self.padb
+
+        if x < 0 or y < 0 or w <= 0 or h <= 0 or x + w > src_w or y + h > src_h:
+            raise ParamValidateException(f"(x, y, w, h)={(x, y, w, h)} 区域超过了原始图片")
+
+        return x, y, w, h
+
+    def do_action(self, im: Image) -> Image:
+        im = pre_processing(im)
+        x, y, w, h = self.compute(*im.size)
+
+        if x == 0 and y == 0 and (w, h) == im.size:
+            # 大小没有变化直接返回
+            return im
+        im = im.crop((x, y, x + w, y + h))
+        return im

imgprocessor/parsers/gray.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+
+from PIL import Image
+
+from imgprocessor import enums
+from .base import BaseParser
+
+
+class GrayParser(BaseParser):
+
+    KEY = enums.OpAction.GRAY
+    ARGS = {}
+
+    def __init__(
+        self,
+        **kwargs: typing.Any,
+    ) -> None:
+        pass
+
+    def do_action(self, im: Image) -> Image:
+        im = im.convert("L")
+        return im

imgprocessor/parsers/merge.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+
+from PIL import Image
+
+from imgprocessor import enums, settings
+from .base import BaseParser, pre_processing, compute_by_geography, compute_splice_two_im
+
+
+class MergeParser(BaseParser):
+
+    KEY = enums.OpAction.MERGE
+    ARGS = {
+        # 要处理的图片
+        "image": {"type": enums.ArgType.STRING, "required": True, "base64_encode": True},
+        # 对image的处理参数
+        "action": {"type": enums.ArgType.STRING, "base64_encode": True},
+        # 使用输入图像的大小作为参照进行缩放
+        "p": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": 1000},
+        # 对齐方式
+        "order": {"type": enums.ArgType.INTEGER, "choices": enums.PositionOrder},
+        "align": {"type": enums.ArgType.INTEGER, "default": enums.PositionAlign.BOTTOM, "choices": enums.PositionAlign},
+        "interval": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": 1000},
+        # 粘贴的位置
+        "g": {"type": enums.ArgType.STRING, "choices": enums.Geography},
+        "x": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": settings.PROCESSOR_MAX_W_H},
+        "y": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": settings.PROCESSOR_MAX_W_H},
+        "pf": {"type": enums.ArgType.STRING, "default": ""},
+        # 拼接后大小包含2个图像，空白区域使用color颜色填充
+        "color": {
+            "type": enums.ArgType.STRING,
+            "default": "FFFFFF",
+            "regex": r"^([0-9a-fA-F]{6}|[0-9a-fA-F]{8}|[0-9a-fA-F]{3,4})$",
+        },
+    }
+
+    def __init__(
+        self,
+        image: typing.Optional[str] = None,
+        action: typing.Optional[str] = None,
+        p: int = 0,
+        order: typing.Optional[int] = None,
+        align: int = 2,
+        interval: int = 0,
+        g: typing.Optional[str] = None,
+        x: int = 0,
+        y: int = 0,
+        pf: str = "",
+        color: str = "FFFFFF",
+        **kwargs: typing.Any,
+    ) -> None:
+        self.image = image
+        self.action = action
+        self.p = p
+        self.order = order
+        self.align = align
+        self.interval = interval
+        self.g = g
+        self.x = x
+        self.y = y
+        self.pf = pf
+        self.color = color
+
+    def compute(self, src_w: int, src_h: int, w2: int, h2: int) -> tuple:
+        if self.order in enums.PositionOrder:  # type: ignore
+            order = typing.cast(int, self.order)
+            w, h, x1, y1, x2, y2 = compute_splice_two_im(
+                src_w,
+                src_h,
+                w2,
+                h2,
+                align=self.align,
+                order=order,
+                interval=self.interval,
+            )
+        else:
+            x, y = compute_by_geography(src_w, src_h, self.x, self.y, w2, h2, self.g, self.pf)
+            x1, y1, x2, y2 = 0, 0, x, y
+            if x < 0:
+                # 一般是因为第2张图像大小大于第1张
+                x1, x2 = -x, 0
+            if y < 0:
+                y1, y2 = -y, 0
+
+            # 计算新建画布的大小
+            w, h = max(x + w2, src_w, w2), max(y + h2, src_h, h2)
+
+        return w, h, x1, y1, x2, y2
+
+    def do_action(self, im: Image) -> Image:
+        im = pre_processing(im, use_alpha=True)
+        src_w, src_h = im.size
+
+        im2 = Image.open(self.image)
+        im2 = pre_processing(im2, use_alpha=True)
+        if self.action:
+            from imgprocessor.processor import ProcessParams, handle_img_actions
+
+            params = ProcessParams.parse_str(self.action)
+            im2 = handle_img_actions(im2, params.actions)
+        if self.p:
+            w2, h2 = int(src_w * self.p / 100), int(src_h * self.p / 100)
+            im2 = im2.resize((w2, h2), resample=Image.LANCZOS)
+        w2, h2 = im2.size
+
+        w, h, x1, y1, x2, y2 = self.compute(src_w, src_h, w2, h2)
+        out = Image.new("RGBA", (w, h), color=f"#{self.color}")
+        out.paste(im, (x1, y1), im)
+        out.paste(im2, (x2, y2), im2)
+        return out