codekingpro/portable-devtools

1#
2# The Python Imaging Library
3# $Id$
4#
5# a simple math add-on for the Python Imaging Library
6#
7# History:
8# 1999-02-15 fl   Original PIL Plus release
9# 2005-05-05 fl   Simplified and cleaned up for PIL 1.1.6
10# 2005-09-12 fl   Fixed int() and float() for Python 2.4.1
11#
12# Copyright (c) 1999-2005 by Secret Labs AB
13# Copyright (c) 2005 by Fredrik Lundh
14#
15# See the README file for information on usage and redistribution.
16#
17from __future__ import annotations
18
19import builtins
20
21from . import Image, _imagingmath
22
23TYPE_CHECKING = False
24if TYPE_CHECKING:
25    from collections.abc import Callable
26    from types import CodeType
27    from typing import Any
28
29
30class _Operand:
31    """Wraps an image operand, providing standard operators"""
32
33    def __init__(self, im: Image.Image):
34        self.im = im
35
36    def __fixup(self, im1: _Operand | float) -> Image.Image:
37        # convert image to suitable mode
38        if isinstance(im1, _Operand):
39            # argument was an image.
40            if im1.im.mode in ("1", "L"):
41                return im1.im.convert("I")
42            elif im1.im.mode in ("I", "F"):
43                return im1.im
44            else:
45                msg = f"unsupported mode: {im1.im.mode}"
46                raise ValueError(msg)
47        else:
48            # argument was a constant
49            if isinstance(im1, (int, float)) and self.im.mode in ("1", "L", "I"):
50                return Image.new("I", self.im.size, im1)
51            else:
52                return Image.new("F", self.im.size, im1)
53
54    def apply(
55        self,
56        op: str,
57        im1: _Operand | float,
58        im2: _Operand | float | None = None,
59        mode: str | None = None,
60    ) -> _Operand:
61        im_1 = self.__fixup(im1)
62        if im2 is None:
63            # unary operation
64            out = Image.new(mode or im_1.mode, im_1.size, None)
65            try:
66                op = getattr(_imagingmath, f"{op}_{im_1.mode}")
67            except AttributeError as e:
68                msg = f"bad operand type for '{op}'"
69                raise TypeError(msg) from e
70            _imagingmath.unop(op, out.getim(), im_1.getim())
71        else:
72            # binary operation
73            im_2 = self.__fixup(im2)
74            if im_1.mode != im_2.mode:
75                # convert both arguments to floating point
76                if im_1.mode != "F":
77                    im_1 = im_1.convert("F")
78                if im_2.mode != "F":
79                    im_2 = im_2.convert("F")
80            if im_1.size != im_2.size:
81                # crop both arguments to a common size
82                size = (
83                    min(im_1.size[0], im_2.size[0]),
84                    min(im_1.size[1], im_2.size[1]),
85                )
86                if im_1.size != size:
87                    im_1 = im_1.crop((0, 0) + size)
88                if im_2.size != size:
89                    im_2 = im_2.crop((0, 0) + size)
90            out = Image.new(mode or im_1.mode, im_1.size, None)
91            try:
92                op = getattr(_imagingmath, f"{op}_{im_1.mode}")
93            except AttributeError as e:
94                msg = f"bad operand type for '{op}'"
95                raise TypeError(msg) from e
96            _imagingmath.binop(op, out.getim(), im_1.getim(), im_2.getim())
97        return _Operand(out)
98
99    # unary operators
100    def __bool__(self) -> bool:
101        # an image is "true" if it contains at least one non-zero pixel
102        return self.im.getbbox() is not None
103
104    def __abs__(self) -> _Operand:
105        return self.apply("abs", self)
106
107    def __pos__(self) -> _Operand:
108        return self
109
110    def __neg__(self) -> _Operand:
111        return self.apply("neg", self)
112
113    # binary operators
114    def __add__(self, other: _Operand | float) -> _Operand:
115        return self.apply("add", self, other)
116
117    def __radd__(self, other: _Operand | float) -> _Operand:
118        return self.apply("add", other, self)
119
120    def __sub__(self, other: _Operand | float) -> _Operand:
121        return self.apply("sub", self, other)
122
123    def __rsub__(self, other: _Operand | float) -> _Operand:
124        return self.apply("sub", other, self)
125
126    def __mul__(self, other: _Operand | float) -> _Operand:
127        return self.apply("mul", self, other)
128
129    def __rmul__(self, other: _Operand | float) -> _Operand:
130        return self.apply("mul", other, self)
131
132    def __truediv__(self, other: _Operand | float) -> _Operand:
133        return self.apply("div", self, other)
134
135    def __rtruediv__(self, other: _Operand | float) -> _Operand:
136        return self.apply("div", other, self)
137
138    def __mod__(self, other: _Operand | float) -> _Operand:
139        return self.apply("mod", self, other)
140
141    def __rmod__(self, other: _Operand | float) -> _Operand:
142        return self.apply("mod", other, self)
143
144    def __pow__(self, other: _Operand | float) -> _Operand:
145        return self.apply("pow", self, other)
146
147    def __rpow__(self, other: _Operand | float) -> _Operand:
148        return self.apply("pow", other, self)
149
150    # bitwise
151    def __invert__(self) -> _Operand:
152        return self.apply("invert", self)
153
154    def __and__(self, other: _Operand | float) -> _Operand:
155        return self.apply("and", self, other)
156
157    def __rand__(self, other: _Operand | float) -> _Operand:
158        return self.apply("and", other, self)
159
160    def __or__(self, other: _Operand | float) -> _Operand:
161        return self.apply("or", self, other)
162
163    def __ror__(self, other: _Operand | float) -> _Operand:
164        return self.apply("or", other, self)
165
166    def __xor__(self, other: _Operand | float) -> _Operand:
167        return self.apply("xor", self, other)
168
169    def __rxor__(self, other: _Operand | float) -> _Operand:
170        return self.apply("xor", other, self)
171
172    def __lshift__(self, other: _Operand | float) -> _Operand:
173        return self.apply("lshift", self, other)
174
175    def __rshift__(self, other: _Operand | float) -> _Operand:
176        return self.apply("rshift", self, other)
177
178    # logical
179    def __eq__(self, other: _Operand | float) -> _Operand:  # type: ignore[override]
180        return self.apply("eq", self, other)
181
182    def __ne__(self, other: _Operand | float) -> _Operand:  # type: ignore[override]
183        return self.apply("ne", self, other)
184
185    def __lt__(self, other: _Operand | float) -> _Operand:
186        return self.apply("lt", self, other)
187
188    def __le__(self, other: _Operand | float) -> _Operand:
189        return self.apply("le", self, other)
190
191    def __gt__(self, other: _Operand | float) -> _Operand:
192        return self.apply("gt", self, other)
193
194    def __ge__(self, other: _Operand | float) -> _Operand:
195        return self.apply("ge", self, other)
196
197
198# conversions
199def imagemath_int(self: _Operand) -> _Operand:
200    return _Operand(self.im.convert("I"))
201
202
203def imagemath_float(self: _Operand) -> _Operand:
204    return _Operand(self.im.convert("F"))
205
206
207# logical
208def imagemath_equal(self: _Operand, other: _Operand | float | None) -> _Operand:
209    return self.apply("eq", self, other, mode="I")
210
211
212def imagemath_notequal(self: _Operand, other: _Operand | float | None) -> _Operand:
213    return self.apply("ne", self, other, mode="I")
214
215
216def imagemath_min(self: _Operand, other: _Operand | float | None) -> _Operand:
217    return self.apply("min", self, other)
218
219
220def imagemath_max(self: _Operand, other: _Operand | float | None) -> _Operand:
221    return self.apply("max", self, other)
222
223
224def imagemath_convert(self: _Operand, mode: str) -> _Operand:
225    return _Operand(self.im.convert(mode))
226
227
228ops = {
229    "int": imagemath_int,
230    "float": imagemath_float,
231    "equal": imagemath_equal,
232    "notequal": imagemath_notequal,
233    "min": imagemath_min,
234    "max": imagemath_max,
235    "convert": imagemath_convert,
236}
237
238
239def lambda_eval(expression: Callable[[dict[str, Any]], Any], **kw: Any) -> Any:
240    """
241    Returns the result of an image function.
242
243    :py:mod:`~PIL.ImageMath` only supports single-layer images. To process multi-band
244    images, use the :py:meth:`~PIL.Image.Image.split` method or
245    :py:func:`~PIL.Image.merge` function.
246
247    :param expression: A function that receives a dictionary.
248    :param **kw: Values to add to the function's dictionary.
249    :return: The expression result. This is usually an image object, but can
250             also be an integer, a floating point value, or a pixel tuple,
251             depending on the expression.
252    """
253
254    args: dict[str, Any] = ops.copy()
255    args.update(kw)
256    for k, v in args.items():
257        if isinstance(v, Image.Image):
258            args[k] = _Operand(v)
259
260    out = expression(args)
261    try:
262        return out.im
263    except AttributeError:
264        return out
265
266
267def unsafe_eval(expression: str, **kw: Any) -> Any:
268    """
269    Evaluates an image expression. This uses Python's ``eval()`` function to process
270    the expression string, and carries the security risks of doing so. It is not
271    recommended to process expressions without considering this.
272    :py:meth:`~lambda_eval` is a more secure alternative.
273
274    :py:mod:`~PIL.ImageMath` only supports single-layer images. To process multi-band
275    images, use the :py:meth:`~PIL.Image.Image.split` method or
276    :py:func:`~PIL.Image.merge` function.
277
278    :param expression: A string containing a Python-style expression.
279    :param **kw: Values to add to the evaluation context.
280    :return: The evaluated expression. This is usually an image object, but can
281             also be an integer, a floating point value, or a pixel tuple,
282             depending on the expression.
283    """
284
285    # build execution namespace
286    args: dict[str, Any] = ops.copy()
287    for k in kw:
288        if "__" in k or hasattr(builtins, k):
289            msg = f"'{k}' not allowed"
290            raise ValueError(msg)
291
292    args.update(kw)
293    for k, v in args.items():
294        if isinstance(v, Image.Image):
295            args[k] = _Operand(v)
296
297    compiled_code = compile(expression, "<string>", "eval")
298
299    def scan(code: CodeType) -> None:
300        for const in code.co_consts:
301            if type(const) is type(compiled_code):
302                scan(const)
303
304        for name in code.co_names:
305            if name not in args and name != "abs":
306                msg = f"'{name}' not allowed"
307                raise ValueError(msg)
308
309    scan(compiled_code)
310    out = builtins.eval(expression, {"__builtins": {"abs": abs}}, args)
311    try:
312        return out.im
313    except AttributeError:
314        return out
315