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

imgprocessor/parsers/resize.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+
+from PIL import Image, ImageOps
+from imgprocessor import enums, settings
+from imgprocessor.exceptions import ParamValidateException, ProcessLimitException
+from .base import BaseParser, pre_processing
+
+
+class ResizeParser(BaseParser):
+
+    KEY = enums.OpAction.RESIZE
+    ARGS = {
+        "m": {"type": enums.ArgType.STRING, "default": enums.ResizeMode.LFIT, "choices": enums.ResizeMode},
+        "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},
+        "l": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": settings.PROCESSOR_MAX_W_H},
+        "s": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": settings.PROCESSOR_MAX_W_H},
+        "limit": {"type": enums.ArgType.INTEGER, "default": 1, "choices": [0, 1]},
+        "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})$",
+        },
+        "p": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": 1000},
+    }
+
+    def __init__(
+        self,
+        m: str = enums.ResizeMode.LFIT,  # type: ignore
+        w: int = 0,
+        h: int = 0,
+        l: int = 0,  # noqa: E741
+        s: int = 0,
+        limit: int = 1,
+        color: str = "FFFFFF",
+        p: int = 0,
+        **kwargs: typing.Any,
+    ) -> None:
+        self.m = m
+        self.w = w
+        self.h = h
+        self.l = l  # noqa: E741
+        self.s = s
+        self.limit = limit
+        self.color = color
+        self.p = p
+
+    def compute(self, src_w: int, src_h: int) -> tuple:
+        """计算出`Image.resize`需要的参数"""
+        if self.w or self.h:
+            if self.m in [enums.ResizeMode.FIXED, enums.ResizeMode.PAD, enums.ResizeMode.FIT]:
+                # 有可能改变原图宽高比
+                if not (self.w and self.h):
+                    raise ParamValidateException(f"当m={self.m}的模式下，参数w和h都必不可少且不能为0")
+                # w,h按指定的即可，无需计算
+                w, h = self.w, self.h
+            elif self.m == enums.ResizeMode.MFIT:
+                # 等比缩放
+                if self.w and self.h:
+                    # 指定w与h的矩形外的最小图像
+                    if self.w / self.h > src_w / src_h:
+                        w, h = self.w, int(self.w * src_h / src_w)
+                    else:
+                        w, h = int(self.h * src_w / src_h), self.h
+                elif self.w:
+                    w, h = self.w, int(self.w * src_h / src_w)
+                else:
+                    w, h = int(self.h * src_w / src_h), self.h
+            else:
+                # 默认 enums.ResizeMode.LFIT
+                # 等比缩放
+                if self.w and self.h:
+                    # 指定w与h的矩形内的最大图像
+                    if self.w / self.h > src_w / src_h:
+                        w, h = int(self.h * src_w / src_h), self.h
+                    else:
+                        w, h = self.w, int(self.w * src_h / src_w)
+                elif self.w:
+                    w, h = self.w, int(self.w * src_h / src_w)
+                else:
+                    w, h = int(self.h * src_w / src_h), self.h
+        elif self.l:
+            # 按最长边缩放
+            if src_w > src_h:
+                w, h = self.l, int(src_h * self.l / src_w)
+            else:
+                w, h = int(src_w * self.l / src_h), self.l
+        elif self.s:
+            # 按最短边缩放
+            if src_w > src_h:
+                w, h = int(src_w * self.s / src_h), self.s
+            else:
+                w, h = self.s, int(src_h * self.s / src_w)
+        elif self.p:
+            # 按照比例缩放
+            w, h = int(src_w * self.p / 100), int(src_h * self.p / 100)
+        else:
+            # 缺少参数
+            raise ParamValidateException("resize操作缺少合法参数")
+
+        if self.limit and (w > src_w or h > src_h):
+            # 超过原图大小，默认不处理
+            w, h = (src_w, src_h)
+        elif w * h > settings.PROCESSOR_MAX_PIXEL:
+            raise ProcessLimitException(f"缩放的目标图像总像素不可超过{settings.PROCESSOR_MAX_PIXEL}像素")
+        return (w, h)
+
+    def do_action(self, im: Image) -> Image:
+        im = pre_processing(im)
+        size = self.compute(*im.size)
+        if size == im.size:
+            # 大小没有变化直接返回
+            return im
+        if self.m == enums.ResizeMode.PAD:
+            out = ImageOps.pad(im, size, color=f"#{self.color}")
+        elif self.m == enums.ResizeMode.FIT:
+            out = ImageOps.fit(im, size)
+        else:
+            out = im.resize(size, resample=Image.LANCZOS)
+        return out

imgprocessor/parsers/rotate.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+
+from PIL import Image
+
+from imgprocessor import enums
+from .base import BaseParser, pre_processing
+
+
+class RotateParser(BaseParser):
+
+    KEY = enums.OpAction.ROTATE
+    ARGS = {
+        # 顺时针旋转的度数
+        "value": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": 360},
+    }
+
+    def __init__(
+        self,
+        value: int = 0,
+        **kwargs: typing.Any,
+    ) -> None:
+        self.value = value
+
+    def do_action(self, im: Image) -> Image:
+        im = pre_processing(im)
+        if 0 < self.value < 360:
+            # 函数提供的是逆时针旋转
+            im = im.rotate(360 - self.value, expand=True)
+        return im

imgprocessor/parsers/watermark.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+
+from PIL import Image, ImageFont, ImageDraw
+
+from imgprocessor import enums, settings, utils
+from imgprocessor.exceptions import ParamValidateException
+from .base import BaseParser, pre_processing, compute_splice_two_im, compute_by_geography
+
+
+class WatermarkParser(BaseParser):
+
+    KEY = enums.OpAction.WATERMARK
+    ARGS = {
+        # 水印本身的不透明度，100表示完全不透明
+        "t": {"type": enums.ArgType.INTEGER, "default": 100, "min": 0, "max": 100},
+        "g": {"type": enums.ArgType.STRING, "choices": enums.Geography},
+        "x": {"type": enums.ArgType.INTEGER, "default": 10, "min": 0, "max": settings.PROCESSOR_MAX_W_H},
+        "y": {"type": enums.ArgType.INTEGER, "default": 10, "min": 0, "max": settings.PROCESSOR_MAX_W_H},
+        # percent field, eg: xy
+        "pf": {"type": enums.ArgType.STRING, "default": ""},
+        # 是否将图片水印或文字水印铺满原图; 值为1开启
+        "fill": {"type": enums.ArgType.INTEGER, "default": 0, "choices": [0, 1]},
+        "padx": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": 4096},
+        "pady": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": 4096},
+        # 图片水印路径
+        "image": {"type": enums.ArgType.STRING, "base64_encode": True},
+        # 水印的原始设计参照尺寸，会根据原图大小缩放水印
+        "design": {"type": enums.ArgType.INTEGER, "min": 1, "max": settings.PROCESSOR_MAX_W_H},
+        # 文字
+        "text": {"type": enums.ArgType.STRING, "base64_encode": True, "max_length": 64},
+        "font": {"type": enums.ArgType.STRING, "base64_encode": True},
+        "color": {"type": enums.ArgType.STRING, "default": "000000", "regex": "^([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$"},
+        "size": {"type": enums.ArgType.INTEGER, "default": 40, "min": 1, "max": 1000},
+        # 文字水印的阴影透明度, 0表示没有阴影
+        "shadow": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": 100},
+        # 顺时针旋转角度
+        "rotate": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": 360},
+        # 图文混合水印参数
+        # 文字和图片水印的前后顺序; 0表示图片水印在前；1表示文字水印在前
+        "order": {"type": enums.ArgType.INTEGER, "default": enums.PositionOrder.BEFORE, "choices": enums.PositionOrder},
+        # 文字水印和图片水印的对齐方式; 0表示文字水印和图片水印上对齐; 1表示文字水印和图片水印中对齐; 2: 表示文字水印和图片水印下对齐
+        "align": {"type": enums.ArgType.INTEGER, "default": enums.PositionAlign.BOTTOM, "choices": enums.PositionAlign},
+        # 文字水印和图片水印间的间距
+        "interval": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": 1000},
+    }
+
+    def __init__(
+        self,
+        t: int = 100,
+        g: typing.Optional[str] = None,
+        x: int = 10,
+        y: int = 10,
+        pf: str = "",
+        fill: int = 0,
+        padx: int = 0,
+        pady: int = 0,
+        image: typing.Optional[str] = None,
+        design: typing.Optional[int] = None,
+        text: typing.Optional[str] = None,
+        font: typing.Optional[str] = None,
+        color: str = "000000",
+        size: int = 40,
+        shadow: int = 0,
+        rotate: int = 0,
+        order: int = 0,
+        align: int = 2,
+        interval: int = 0,
+        **kwargs: typing.Any,
+    ) -> None:
+        self.t = t
+        self.g = g
+        self.x = x
+        self.y = y
+        self.pf = pf
+        self.fill = fill
+        self.padx = padx
+        self.pady = pady
+        self.image = image
+        self.design = design
+        self.text = text
+        self.font = font
+        self.color = color
+        self.size = size
+        self.shadow = shadow
+        self.rotate = rotate
+        self.order = order
+        self.align = align
+        self.interval = interval
+
+    def validate(self) -> None:
+        super().validate()
+        if not self.image and not self.text:
+            raise ParamValidateException("image或者text参数必须传递一个")
+
+    def get_watermark_im(self) -> Image:
+        """初始化水印对象"""
+        w1, h1, w2, h2 = 0, 0, 0, 0
+        icon = None
+        if self.image:
+            icon = Image.open(self.image)
+            icon = pre_processing(icon, use_alpha=True)
+            if not self.text:
+                # 没有文字，直接返回
+                return icon
+            w1, h1 = icon.size
+
+        try:
+            _font_path = self.font or settings.PROCESSOR_TEXT_FONT
+            font = ImageFont.truetype(_font_path, self.size)
+        except OSError:
+            raise ParamValidateException(f"未找到字体 {_font_path}")
+
+        if utils.get_pil_version() >= utils.Version("10.0.0"):
+            _, _, w2, h2 = font.getbbox(self.text)
+        else:
+            w2, h2 = font.getsize(self.text)
+
+        w, h, x1, y1, x2, y2 = compute_splice_two_im(
+            w1,
+            h1,
+            w2,
+            h2,
+            align=self.align,
+            order=self.order,
+            interval=self.interval,
+        )
+
+        mark = Image.new("RGBA", (w, h))
+        draw = ImageDraw.Draw(mark, mode="RGBA")
+
+        # 阴影要单独处理透明度，放在文字之前处理
+        if self.shadow:
+            offset = max(int(self.size / 20), 2)
+            shadow_color = "#000000"
+            # 左上到右下的阴影，只保留这一个
+            draw.text((x2 + offset, y2 + offset), self.text, font=font, fill=shadow_color)
+            # draw.text((x2 - offset, y2 + offset), self.text, font=font, fill=shadow_color)
+            # draw.text((x2 + offset, y2 - offset), self.text, font=font, fill=shadow_color)
+            # draw.text((x2 - offset, y2 - offset), self.text, font=font, fill=shadow_color)
+            _, _, _, alpha_channel = mark.split()
+            alpha_channel = alpha_channel.point(lambda i: min(int(255 * self.shadow / 100), i))
+            mark.putalpha(alpha_channel)
+
+        # 处理文字
+        draw.text((x2, y2), self.text, font=font, fill=f"#{self.color}")
+
+        if icon:
+            # icon放在文字之后粘贴，是因为文字要做一些其他处理
+            mark.paste(icon, (x1, y1), icon)
+
+        return mark
+
+    def do_action(self, im: Image) -> Image:
+        im = pre_processing(im, use_alpha=True)
+        src_w, src_h = im.size
+
+        pf = self.pf or ""
+        if self.g:
+            # g在的时候pf不生效
+            pf = ""
+
+        mark = self.get_watermark_im()
+        w, h = mark.size
+
+        if self.design:
+            # 处理缩放
+            rate = min(src_w, src_h) / self.design
+            if rate != 1:
+                w, h = int(w * rate), int(h * rate)
+                mark = mark.resize((w, h), resample=Image.LANCZOS)
+
+        if 0 < self.rotate < 360:
+            # 处理旋转
+            mark = mark.rotate(360 - self.rotate, expand=True)
+            # 旋转会改变大小
+            w, h = mark.size
+
+        if w > src_w or h > src_h:
+            # 水印大小超过原图了, 原图矩形内的最大图像
+            if w / h > src_w / src_h:
+                w, h = src_w, int(src_w * h / w)
+                self.x = 0
+            else:
+                w, h = int(src_h * w / h), src_h
+                self.y = 0
+            mark = mark.resize((w, h), resample=Image.LANCZOS)
+
+        if self.t < 100:
+            # 处理透明度
+            _, _, _, alpha_channel = mark.split()
+            alpha_channel = alpha_channel.point(lambda i: min(int(255 * self.t / 100), i))
+            mark.putalpha(alpha_channel)
+
+        # 计算位置，粘贴水印
+        x, y = compute_by_geography(src_w, src_h, self.x, self.y, w, h, self.g, pf)
+        im.paste(mark, (x, y), mark)
+
+        if self.fill:
+            # 铺满整个图片
+            # 寻找平铺最左上角的原点
+            wx, wy = x, y
+            while wx > 0:
+                wx = wx - w - self.padx
+            while wy > 0:
+                wy = wy - h - self.pady
+            # 往右下角方向平铺
+            ux = wx
+            while ux <= src_w:
+                uy = wy
+                while uy <= src_h:
+                    if (ux, uy) != (x, y):
+                        im.paste(mark, (ux, uy), mark)
+                    uy = uy + h + self.pady
+                ux = ux + w + self.padx
+
+        return im

imgprocessor/processor.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+import os
+import tempfile
+import colorsys
+
+from PIL import Image, ImageOps
+
+from imgprocessor import settings, enums
+from imgprocessor.exceptions import ProcessLimitException
+from imgprocessor.parsers import BaseParser, ProcessParams
+
+
+def handle_img_actions(ori_im: Image, actions: list[BaseParser]) -> Image:
+    src_w, src_h = ori_im.size
+    if src_w > settings.PROCESSOR_MAX_W_H or src_h > settings.PROCESSOR_MAX_W_H:
+        raise ProcessLimitException(
+            f"图像宽和高单边像素不能超过{settings.PROCESSOR_MAX_W_H}像素，输入图像({src_w}, {src_h})"
+        )
+    if src_w * src_h > settings.PROCESSOR_MAX_PIXEL:
+        raise ProcessLimitException(f"图像总像素不可超过{settings.PROCESSOR_MAX_PIXEL}像素，输入图像({src_w}, {src_h})")
+
+    im = ori_im
+    im = ImageOps.exif_transpose(im)
+
+    for parser in actions:
+        im = parser.do_action(im)
+
+    return im
+
+
+def save_img_to_file(
+    im: Image,
+    out_path: typing.Optional[str] = None,
+    **kwargs: typing.Any,
+) -> typing.Optional[typing.ByteString]:
+    fmt = kwargs.get("format") or im.format
+    kwargs["format"] = fmt
+
+    if fmt.upper() == enums.ImageFormat.JPEG and im.mode == "RGBA":
+        im = im.convert("RGB")
+
+    if not kwargs.get("quality"):
+        if fmt.upper() == enums.ImageFormat.JPEG and im.format == enums.ImageFormat.JPEG:
+            kwargs["quality"] = "keep"
+        else:
+            kwargs["quality"] = settings.PROCESSOR_DEFAULT_QUALITY
+
+    if out_path:
+        # icc_profile 是为解决色域的问题
+        im.save(out_path, **kwargs)
+        return None
+
+    # 没有传递保存的路径，返回文件内容
+    suffix = fmt or "png"
+    with tempfile.NamedTemporaryFile(suffix=f".{suffix}") as fp:
+        im.save(fp.name, **kwargs)
+        fp.seek(0)
+        content = fp.read()
+    return content
+
+
+def process_image_by_path(
+    input_path: str, out_path: str, params: typing.Union[ProcessParams, dict, str]
+) -> typing.Optional[typing.ByteString]:
+    """处理图像
+
+    Args:
+        input_path: 输入图像文件路径
+        out_path: 输出图像保存路径
+        params: 图像处理参数
+
+    Raises:
+        ProcessLimitException: 超过处理限制会抛出异常
+
+    Returns:
+        默认输出直接存储无返回，仅当out_path为空时会返回处理后图像的二进制内容
+    """
+    size = os.path.getsize(input_path)
+    if size > settings.PROCESSOR_MAX_FILE_SIZE * 1024 * 1024:
+        raise ProcessLimitException(f"图像文件大小不得超过{settings.PROCESSOR_MAX_FILE_SIZE}MB")
+    if isinstance(params, dict):
+        params = ProcessParams(**params)
+    elif isinstance(params, str):
+        params = ProcessParams.parse_str(params)
+    params = typing.cast(ProcessParams, params)
+
+    ori_im = Image.open(input_path)
+    # 处理图像
+    im = handle_img_actions(ori_im, params.actions)
+
+    kwargs = params.save_parser.compute(ori_im, im)
+    return save_img_to_file(im, out_path=out_path, **kwargs)
+
+
+def extract_main_color(img_path: str, delta_h: float = 0.3) -> str:
+    """获取图像主色调
+
+    Args:
+        img_path: 输入图像的路径
+        delta_h: 像素色相和平均色相做减法的绝对值小于改值，才用于计算主色调，取值范围[0,1]
+
+    Returns:
+        颜色值，eg: FFFFFF
+    """
+    r, g, b = 0, 0, 0
+    im = Image.open(img_path)
+    if im.mode != "RGB":
+        im = im.convert("RGB")
+    # 转换成HSV即 色相(Hue)、饱和度(Saturation)、明度(alue)，取值范围[0,1]
+    # 取H计算平均色相
+    all_h = [colorsys.rgb_to_hsv(*im.getpixel((x, y)))[0] for x in range(im.size[0]) for y in range(im.size[1])]
+    avg_h = sum(all_h) / (im.size[0] * im.size[1])
+    # 取与平均色相相近的像素色值rgb用于计算，像素值取值范围[0,255]
+    beyond = list(
+        filter(
+            lambda x: abs(colorsys.rgb_to_hsv(*x)[0] - avg_h) < delta_h,
+            [im.getpixel((x, y)) for x in range(im.size[0]) for y in range(im.size[1])],
+        )
+    )
+    if len(beyond):
+        r = int(sum(e[0] for e in beyond) / len(beyond))
+        g = int(sum(e[1] for e in beyond) / len(beyond))
+        b = int(sum(e[2] for e in beyond) / len(beyond))
+
+    color = "{}{}{}".format(hex(r)[2:].zfill(2), hex(g)[2:].zfill(2), hex(b)[2:].zfill(2))
+    return color.upper()

imgprocessor/utils.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# coding=utf-8
+import base64
+import PIL
+
+try:
+    # python3.12之后被移除
+    from distutils.version import StrictVersion as Version
+except Exception:
+    from packaging.version import Version  # type: ignore[no-redef]
+
+
+def get_pil_version() -> Version:
+    return Version(PIL.__version__)
+
+
+def base64url_encode(value: str) -> str:
+    """
+    对内容进行URL安全的Base64编码，需要将结果中的部分编码替换：
+
+    - 将结果中的加号 `+` 替换成短划线 `-`;
+    - 将结果中的正斜线 `/` 替换成下划线 `_`;
+    - 将结果中尾部的所有等号 `=` 省略。
+
+    Args:
+        value: 输入字符串
+
+    Returns:
+        返回编码后字符串
+
+    """
+    s = base64.urlsafe_b64encode(value.encode()).decode()
+    s = s.strip("=")
+    return s
+
+
+def base64url_decode(value: str) -> str:
+    """
+    对URL安全编码进行解码
+
+    Args:
+        value: 输入编码字符串
+
+    Returns:
+        解码后字符串
+
+    """
+    # 补全后面等号
+    padding = 4 - (len(value) % 4)
+    value = value + ("=" * padding)
+    # 解码
+    s = base64.urlsafe_b64decode(value.encode()).decode()
+    s = s.strip("=")
+    return s

py_img_processor-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Skyler Hu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.