382 lines
11 KiB
Python
382 lines
11 KiB
Python
#
|
|
# The Python Imaging Library
|
|
# Pillow fork
|
|
#
|
|
# Python implementation of the PixelAccess Object
|
|
#
|
|
# Copyright (c) 1997-2009 by Secret Labs AB. All rights reserved.
|
|
# Copyright (c) 1995-2009 by Fredrik Lundh.
|
|
# Copyright (c) 2013 Eric Soroos
|
|
#
|
|
# See the README file for information on usage and redistribution
|
|
#
|
|
|
|
# Notes:
|
|
#
|
|
# * Implements the pixel access object following Access.c
|
|
# * Taking only the tuple form, which is used from python.
|
|
# * Fill.c uses the integer form, but it's still going to use the old
|
|
# Access.c implementation.
|
|
#
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import sys
|
|
from typing import TYPE_CHECKING
|
|
|
|
from ._deprecate import deprecate
|
|
|
|
FFI: type
|
|
try:
|
|
from cffi import FFI
|
|
|
|
defs = """
|
|
struct Pixel_RGBA {
|
|
unsigned char r,g,b,a;
|
|
};
|
|
struct Pixel_I16 {
|
|
unsigned char l,r;
|
|
};
|
|
"""
|
|
ffi = FFI()
|
|
ffi.cdef(defs)
|
|
except ImportError as ex:
|
|
# Allow error import for doc purposes, but error out when accessing
|
|
# anything in core.
|
|
from ._util import DeferredError
|
|
|
|
FFI = ffi = DeferredError.new(ex)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
if TYPE_CHECKING:
|
|
from . import Image
|
|
|
|
|
|
class PyAccess:
|
|
def __init__(self, img: Image.Image, readonly: bool = False) -> None:
|
|
deprecate("PyAccess", 11)
|
|
vals = dict(img.im.unsafe_ptrs)
|
|
self.readonly = readonly
|
|
self.image8 = ffi.cast("unsigned char **", vals["image8"])
|
|
self.image32 = ffi.cast("int **", vals["image32"])
|
|
self.image = ffi.cast("unsigned char **", vals["image"])
|
|
self.xsize, self.ysize = img.im.size
|
|
self._img = img
|
|
|
|
# Keep pointer to im object to prevent dereferencing.
|
|
self._im = img.im
|
|
if self._im.mode in ("P", "PA"):
|
|
self._palette = img.palette
|
|
|
|
# Debugging is polluting test traces, only useful here
|
|
# when hacking on PyAccess
|
|
# logger.debug("%s", vals)
|
|
self._post_init()
|
|
|
|
def _post_init(self) -> None:
|
|
pass
|
|
|
|
def __setitem__(
|
|
self,
|
|
xy: tuple[int, int] | list[int],
|
|
color: float | tuple[int, ...] | list[int],
|
|
) -> None:
|
|
"""
|
|
Modifies the pixel at x,y. The color is given as a single
|
|
numerical value for single band images, and a tuple for
|
|
multi-band images. In addition to this, RGB and RGBA tuples
|
|
are accepted for P and PA images.
|
|
|
|
:param xy: The pixel coordinate, given as (x, y). See
|
|
:ref:`coordinate-system`.
|
|
:param color: The pixel value.
|
|
"""
|
|
if self.readonly:
|
|
msg = "Attempt to putpixel a read only image"
|
|
raise ValueError(msg)
|
|
(x, y) = xy
|
|
if x < 0:
|
|
x = self.xsize + x
|
|
if y < 0:
|
|
y = self.ysize + y
|
|
(x, y) = self.check_xy((x, y))
|
|
|
|
if (
|
|
self._im.mode in ("P", "PA")
|
|
and isinstance(color, (list, tuple))
|
|
and len(color) in [3, 4]
|
|
):
|
|
# RGB or RGBA value for a P or PA image
|
|
if self._im.mode == "PA":
|
|
alpha = color[3] if len(color) == 4 else 255
|
|
color = color[:3]
|
|
palette_index = self._palette.getcolor(color, self._img)
|
|
color = (palette_index, alpha) if self._im.mode == "PA" else palette_index
|
|
|
|
return self.set_pixel(x, y, color)
|
|
|
|
def __getitem__(self, xy: tuple[int, int] | list[int]) -> float | tuple[int, ...]:
|
|
"""
|
|
Returns the pixel at x,y. The pixel is returned as a single
|
|
value for single band images or a tuple for multiple band
|
|
images
|
|
|
|
:param xy: The pixel coordinate, given as (x, y). See
|
|
:ref:`coordinate-system`.
|
|
:returns: a pixel value for single band images, a tuple of
|
|
pixel values for multiband images.
|
|
"""
|
|
(x, y) = xy
|
|
if x < 0:
|
|
x = self.xsize + x
|
|
if y < 0:
|
|
y = self.ysize + y
|
|
(x, y) = self.check_xy((x, y))
|
|
return self.get_pixel(x, y)
|
|
|
|
putpixel = __setitem__
|
|
getpixel = __getitem__
|
|
|
|
def check_xy(self, xy: tuple[int, int]) -> tuple[int, int]:
|
|
(x, y) = xy
|
|
if not (0 <= x < self.xsize and 0 <= y < self.ysize):
|
|
msg = "pixel location out of range"
|
|
raise ValueError(msg)
|
|
return xy
|
|
|
|
def get_pixel(self, x: int, y: int) -> float | tuple[int, ...]:
|
|
raise NotImplementedError()
|
|
|
|
def set_pixel(
|
|
self, x: int, y: int, color: float | tuple[int, ...] | list[int]
|
|
) -> None:
|
|
raise NotImplementedError()
|
|
|
|
|
|
class _PyAccess32_2(PyAccess):
|
|
"""PA, LA, stored in first and last bytes of a 32 bit word"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = ffi.cast("struct Pixel_RGBA **", self.image32)
|
|
|
|
def get_pixel(self, x: int, y: int) -> tuple[int, int]:
|
|
pixel = self.pixels[y][x]
|
|
return pixel.r, pixel.a
|
|
|
|
def set_pixel(self, x, y, color):
|
|
pixel = self.pixels[y][x]
|
|
# tuple
|
|
pixel.r = min(color[0], 255)
|
|
pixel.a = min(color[1], 255)
|
|
|
|
|
|
class _PyAccess32_3(PyAccess):
|
|
"""RGB and friends, stored in the first three bytes of a 32 bit word"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = ffi.cast("struct Pixel_RGBA **", self.image32)
|
|
|
|
def get_pixel(self, x: int, y: int) -> tuple[int, int, int]:
|
|
pixel = self.pixels[y][x]
|
|
return pixel.r, pixel.g, pixel.b
|
|
|
|
def set_pixel(self, x, y, color):
|
|
pixel = self.pixels[y][x]
|
|
# tuple
|
|
pixel.r = min(color[0], 255)
|
|
pixel.g = min(color[1], 255)
|
|
pixel.b = min(color[2], 255)
|
|
pixel.a = 255
|
|
|
|
|
|
class _PyAccess32_4(PyAccess):
|
|
"""RGBA etc, all 4 bytes of a 32 bit word"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = ffi.cast("struct Pixel_RGBA **", self.image32)
|
|
|
|
def get_pixel(self, x: int, y: int) -> tuple[int, int, int, int]:
|
|
pixel = self.pixels[y][x]
|
|
return pixel.r, pixel.g, pixel.b, pixel.a
|
|
|
|
def set_pixel(self, x, y, color):
|
|
pixel = self.pixels[y][x]
|
|
# tuple
|
|
pixel.r = min(color[0], 255)
|
|
pixel.g = min(color[1], 255)
|
|
pixel.b = min(color[2], 255)
|
|
pixel.a = min(color[3], 255)
|
|
|
|
|
|
class _PyAccess8(PyAccess):
|
|
"""1, L, P, 8 bit images stored as uint8"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = self.image8
|
|
|
|
def get_pixel(self, x: int, y: int) -> int:
|
|
return self.pixels[y][x]
|
|
|
|
def set_pixel(self, x, y, color):
|
|
try:
|
|
# integer
|
|
self.pixels[y][x] = min(color, 255)
|
|
except TypeError:
|
|
# tuple
|
|
self.pixels[y][x] = min(color[0], 255)
|
|
|
|
|
|
class _PyAccessI16_N(PyAccess):
|
|
"""I;16 access, native bitendian without conversion"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = ffi.cast("unsigned short **", self.image)
|
|
|
|
def get_pixel(self, x: int, y: int) -> int:
|
|
return self.pixels[y][x]
|
|
|
|
def set_pixel(self, x, y, color):
|
|
try:
|
|
# integer
|
|
self.pixels[y][x] = min(color, 65535)
|
|
except TypeError:
|
|
# tuple
|
|
self.pixels[y][x] = min(color[0], 65535)
|
|
|
|
|
|
class _PyAccessI16_L(PyAccess):
|
|
"""I;16L access, with conversion"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = ffi.cast("struct Pixel_I16 **", self.image)
|
|
|
|
def get_pixel(self, x: int, y: int) -> int:
|
|
pixel = self.pixels[y][x]
|
|
return pixel.l + pixel.r * 256
|
|
|
|
def set_pixel(self, x, y, color):
|
|
pixel = self.pixels[y][x]
|
|
try:
|
|
color = min(color, 65535)
|
|
except TypeError:
|
|
color = min(color[0], 65535)
|
|
|
|
pixel.l = color & 0xFF
|
|
pixel.r = color >> 8
|
|
|
|
|
|
class _PyAccessI16_B(PyAccess):
|
|
"""I;16B access, with conversion"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = ffi.cast("struct Pixel_I16 **", self.image)
|
|
|
|
def get_pixel(self, x: int, y: int) -> int:
|
|
pixel = self.pixels[y][x]
|
|
return pixel.l * 256 + pixel.r
|
|
|
|
def set_pixel(self, x, y, color):
|
|
pixel = self.pixels[y][x]
|
|
try:
|
|
color = min(color, 65535)
|
|
except Exception:
|
|
color = min(color[0], 65535)
|
|
|
|
pixel.l = color >> 8
|
|
pixel.r = color & 0xFF
|
|
|
|
|
|
class _PyAccessI32_N(PyAccess):
|
|
"""Signed Int32 access, native endian"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = self.image32
|
|
|
|
def get_pixel(self, x: int, y: int) -> int:
|
|
return self.pixels[y][x]
|
|
|
|
def set_pixel(self, x, y, color):
|
|
self.pixels[y][x] = color
|
|
|
|
|
|
class _PyAccessI32_Swap(PyAccess):
|
|
"""I;32L/B access, with byteswapping conversion"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = self.image32
|
|
|
|
def reverse(self, i):
|
|
orig = ffi.new("int *", i)
|
|
chars = ffi.cast("unsigned char *", orig)
|
|
chars[0], chars[1], chars[2], chars[3] = chars[3], chars[2], chars[1], chars[0]
|
|
return ffi.cast("int *", chars)[0]
|
|
|
|
def get_pixel(self, x: int, y: int) -> int:
|
|
return self.reverse(self.pixels[y][x])
|
|
|
|
def set_pixel(self, x, y, color):
|
|
self.pixels[y][x] = self.reverse(color)
|
|
|
|
|
|
class _PyAccessF(PyAccess):
|
|
"""32 bit float access"""
|
|
|
|
def _post_init(self, *args, **kwargs):
|
|
self.pixels = ffi.cast("float **", self.image32)
|
|
|
|
def get_pixel(self, x: int, y: int) -> float:
|
|
return self.pixels[y][x]
|
|
|
|
def set_pixel(self, x, y, color):
|
|
try:
|
|
# not a tuple
|
|
self.pixels[y][x] = color
|
|
except TypeError:
|
|
# tuple
|
|
self.pixels[y][x] = color[0]
|
|
|
|
|
|
mode_map = {
|
|
"1": _PyAccess8,
|
|
"L": _PyAccess8,
|
|
"P": _PyAccess8,
|
|
"I;16N": _PyAccessI16_N,
|
|
"LA": _PyAccess32_2,
|
|
"La": _PyAccess32_2,
|
|
"PA": _PyAccess32_2,
|
|
"RGB": _PyAccess32_3,
|
|
"LAB": _PyAccess32_3,
|
|
"HSV": _PyAccess32_3,
|
|
"YCbCr": _PyAccess32_3,
|
|
"RGBA": _PyAccess32_4,
|
|
"RGBa": _PyAccess32_4,
|
|
"RGBX": _PyAccess32_4,
|
|
"CMYK": _PyAccess32_4,
|
|
"F": _PyAccessF,
|
|
"I": _PyAccessI32_N,
|
|
}
|
|
|
|
if sys.byteorder == "little":
|
|
mode_map["I;16"] = _PyAccessI16_N
|
|
mode_map["I;16L"] = _PyAccessI16_N
|
|
mode_map["I;16B"] = _PyAccessI16_B
|
|
|
|
mode_map["I;32L"] = _PyAccessI32_N
|
|
mode_map["I;32B"] = _PyAccessI32_Swap
|
|
else:
|
|
mode_map["I;16"] = _PyAccessI16_L
|
|
mode_map["I;16L"] = _PyAccessI16_L
|
|
mode_map["I;16B"] = _PyAccessI16_N
|
|
|
|
mode_map["I;32L"] = _PyAccessI32_Swap
|
|
mode_map["I;32B"] = _PyAccessI32_N
|
|
|
|
|
|
def new(img: Image.Image, readonly: bool = False) -> PyAccess | None:
|
|
access_type = mode_map.get(img.mode, None)
|
|
if not access_type:
|
|
logger.debug("PyAccess Not Implemented: %s", img.mode)
|
|
return None
|
|
return access_type(img, readonly)
|