@tushar-br/desktop 1.0.282 → 1.0.283

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/PIL/ImageDraw.py

@@ -0,0 +1,1036 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# drawing interface operations
+#
+# History:
+# 1996-04-13 fl   Created (experimental)
+# 1996-08-07 fl   Filled polygons, ellipses.
+# 1996-08-13 fl   Added text support
+# 1998-06-28 fl   Handle I and F images
+# 1998-12-29 fl   Added arc; use arc primitive to draw ellipses
+# 1999-01-10 fl   Added shape stuff (experimental)
+# 1999-02-06 fl   Added bitmap support
+# 1999-02-11 fl   Changed all primitives to take options
+# 1999-02-20 fl   Fixed backwards compatibility
+# 2000-10-12 fl   Copy on write, when necessary
+# 2001-02-18 fl   Use default ink for bitmap/text also in fill mode
+# 2002-10-24 fl   Added support for CSS-style color strings
+# 2002-12-10 fl   Added experimental support for RGBA-on-RGB drawing
+# 2002-12-11 fl   Refactored low-level drawing API (work in progress)
+# 2004-08-26 fl   Made Draw() a factory function, added getdraw() support
+# 2004-09-04 fl   Added width support to line primitive
+# 2004-09-10 fl   Added font mode handling
+# 2006-06-19 fl   Added font bearing support (getmask2)
+#
+# Copyright (c) 1997-2006 by Secret Labs AB
+# Copyright (c) 1996-2006 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import math
+import struct
+from collections.abc import Sequence
+from typing import cast
+
+from . import Image, ImageColor, ImageText
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import ModuleType
+    from typing import Any, AnyStr
+
+    from . import ImageDraw2, ImageFont
+    from ._typing import Coords, _Ink
+
+# experimental access to the outline API
+Outline: Callable[[], Image.core._Outline] = Image.core.outline
+
+"""
+A simple 2D drawing interface for PIL images.
+<p>
+Application code should use the <b>Draw</b> factory, instead of
+directly.
+"""
+
+
+class ImageDraw:
+    font: (
+        ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont | None
+    ) = None
+
+    def __init__(self, im: Image.Image, mode: str | None = None) -> None:
+        """
+        Create a drawing instance.
+
+        :param im: The image to draw in.
+        :param mode: Optional mode to use for color values.  For RGB
+           images, this argument can be RGB or RGBA (to blend the
+           drawing into the image).  For all other modes, this argument
+           must be the same as the image mode.  If omitted, the mode
+           defaults to the mode of the image.
+        """
+        im._ensure_mutable()
+        blend = 0
+        if mode is None:
+            mode = im.mode
+        if mode != im.mode:
+            if mode == "RGBA" and im.mode == "RGB":
+                blend = 1
+            else:
+                msg = "mode mismatch"
+                raise ValueError(msg)
+        if mode == "P":
+            self.palette = im.palette
+        else:
+            self.palette = None
+        self._image = im
+        self.im = im.im
+        self.draw = Image.core.draw(self.im, blend)
+        self.mode = mode
+        if mode in ("I", "F"):
+            self.ink = self.draw.draw_ink(1)
+        else:
+            self.ink = self.draw.draw_ink(-1)
+        if mode in ("1", "P", "I", "F"):
+            # FIXME: fix Fill2 to properly support matte for I+F images
+            self.fontmode = "1"
+        else:
+            self.fontmode = "L"  # aliasing is okay for other modes
+        self.fill = False
+
+    def getfont(
+        self,
+    ) -> ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont:
+        """
+        Get the current default font.
+
+        To set the default font for this ImageDraw instance::
+
+            from PIL import ImageDraw, ImageFont
+            draw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
+
+        To set the default font for all future ImageDraw instances::
+
+            from PIL import ImageDraw, ImageFont
+            ImageDraw.ImageDraw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
+
+        If the current default font is ``None``,
+        it is initialized with ``ImageFont.load_default()``.
+
+        :returns: An image font."""
+        if not self.font:
+            # FIXME: should add a font repository
+            from . import ImageFont
+
+            self.font = ImageFont.load_default()
+        return self.font
+
+    def _getfont(
+        self, font_size: float | None
+    ) -> ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont:
+        if font_size is not None:
+            from . import ImageFont
+
+            return ImageFont.load_default(font_size)
+        else:
+            return self.getfont()
+
+    def _getink(
+        self, ink: _Ink | None, fill: _Ink | None = None
+    ) -> tuple[int | None, int | None]:
+        result_ink = None
+        result_fill = None
+        if ink is None and fill is None:
+            if self.fill:
+                result_fill = self.ink
+            else:
+                result_ink = self.ink
+        else:
+            if ink is not None:
+                if isinstance(ink, str):
+                    ink = ImageColor.getcolor(ink, self.mode)
+                if self.palette and isinstance(ink, tuple):
+                    ink = self.palette.getcolor(ink, self._image)
+                result_ink = self.draw.draw_ink(ink)
+            if fill is not None:
+                if isinstance(fill, str):
+                    fill = ImageColor.getcolor(fill, self.mode)
+                if self.palette and isinstance(fill, tuple):
+                    fill = self.palette.getcolor(fill, self._image)
+                result_fill = self.draw.draw_ink(fill)
+        return result_ink, result_fill
+
+    def arc(
+        self,
+        xy: Coords,
+        start: float,
+        end: float,
+        fill: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw an arc."""
+        ink, fill = self._getink(fill)
+        if ink is not None:
+            self.draw.draw_arc(xy, start, end, ink, width)
+
+    def bitmap(
+        self, xy: Sequence[int], bitmap: Image.Image, fill: _Ink | None = None
+    ) -> None:
+        """Draw a bitmap."""
+        bitmap.load()
+        ink, fill = self._getink(fill)
+        if ink is None:
+            ink = fill
+        if ink is not None:
+            self.draw.draw_bitmap(xy, bitmap.im, ink)
+
+    def chord(
+        self,
+        xy: Coords,
+        start: float,
+        end: float,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a chord."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_chord(xy, start, end, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            self.draw.draw_chord(xy, start, end, ink, 0, width)
+
+    def ellipse(
+        self,
+        xy: Coords,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw an ellipse."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_ellipse(xy, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            self.draw.draw_ellipse(xy, ink, 0, width)
+
+    def circle(
+        self,
+        xy: Sequence[float],
+        radius: float,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a circle given center coordinates and a radius."""
+        ellipse_xy = (xy[0] - radius, xy[1] - radius, xy[0] + radius, xy[1] + radius)
+        self.ellipse(ellipse_xy, fill, outline, width)
+
+    def line(
+        self,
+        xy: Coords,
+        fill: _Ink | None = None,
+        width: int = 0,
+        joint: str | None = None,
+    ) -> None:
+        """Draw a line, or a connected sequence of line segments."""
+        ink = self._getink(fill)[0]
+        if ink is not None:
+            self.draw.draw_lines(xy, ink, width)
+            if joint == "curve" and width > 4:
+                points: Sequence[Sequence[float]]
+                if isinstance(xy[0], (list, tuple)):
+                    points = cast(Sequence[Sequence[float]], xy)
+                else:
+                    points = [
+                        cast(Sequence[float], tuple(xy[i : i + 2]))
+                        for i in range(0, len(xy), 2)
+                    ]
+                for i in range(1, len(points) - 1):
+                    point = points[i]
+                    angles = [
+                        math.degrees(math.atan2(end[0] - start[0], start[1] - end[1]))
+                        % 360
+                        for start, end in (
+                            (points[i - 1], point),
+                            (point, points[i + 1]),
+                        )
+                    ]
+                    if angles[0] == angles[1]:
+                        # This is a straight line, so no joint is required
+                        continue
+
+                    def coord_at_angle(
+                        coord: Sequence[float], angle: float
+                    ) -> tuple[float, ...]:
+                        x, y = coord
+                        angle -= 90
+                        distance = width / 2 - 1
+                        return tuple(
+                            p + (math.floor(p_d) if p_d > 0 else math.ceil(p_d))
+                            for p, p_d in (
+                                (x, distance * math.cos(math.radians(angle))),
+                                (y, distance * math.sin(math.radians(angle))),
+                            )
+                        )
+
+                    flipped = (
+                        angles[1] > angles[0] and angles[1] - 180 > angles[0]
+                    ) or (angles[1] < angles[0] and angles[1] + 180 > angles[0])
+                    coords = [
+                        (point[0] - width / 2 + 1, point[1] - width / 2 + 1),
+                        (point[0] + width / 2 - 1, point[1] + width / 2 - 1),
+                    ]
+                    if flipped:
+                        start, end = (angles[1] + 90, angles[0] + 90)
+                    else:
+                        start, end = (angles[0] - 90, angles[1] - 90)
+                    self.pieslice(coords, start - 90, end - 90, fill)
+
+                    if width > 8:
+                        # Cover potential gaps between the line and the joint
+                        if flipped:
+                            gap_coords = [
+                                coord_at_angle(point, angles[0] + 90),
+                                point,
+                                coord_at_angle(point, angles[1] + 90),
+                            ]
+                        else:
+                            gap_coords = [
+                                coord_at_angle(point, angles[0] - 90),
+                                point,
+                                coord_at_angle(point, angles[1] - 90),
+                            ]
+                        self.line(gap_coords, fill, width=3)
+
+    def shape(
+        self,
+        shape: Image.core._Outline,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+    ) -> None:
+        """(Experimental) Draw a shape."""
+        shape.close()
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_outline(shape, fill_ink, 1)
+        if ink is not None and ink != fill_ink:
+            self.draw.draw_outline(shape, ink, 0)
+
+    def pieslice(
+        self,
+        xy: Coords,
+        start: float,
+        end: float,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a pieslice."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_pieslice(xy, start, end, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            self.draw.draw_pieslice(xy, start, end, ink, 0, width)
+
+    def point(self, xy: Coords, fill: _Ink | None = None) -> None:
+        """Draw one or more individual pixels."""
+        ink, fill = self._getink(fill)
+        if ink is not None:
+            self.draw.draw_points(xy, ink)
+
+    def polygon(
+        self,
+        xy: Coords,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a polygon."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_polygon(xy, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            if width == 1:
+                self.draw.draw_polygon(xy, ink, 0, width)
+            elif self.im is not None:
+                # To avoid expanding the polygon outwards,
+                # use the fill as a mask
+                mask = Image.new("1", self.im.size)
+                mask_ink = self._getink(1)[0]
+                draw = Draw(mask)
+                draw.draw.draw_polygon(xy, mask_ink, 1)
+
+                self.draw.draw_polygon(xy, ink, 0, width * 2 - 1, mask.im)
+
+    def regular_polygon(
+        self,
+        bounding_circle: Sequence[Sequence[float] | float],
+        n_sides: int,
+        rotation: float = 0,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a regular polygon."""
+        xy = _compute_regular_polygon_vertices(bounding_circle, n_sides, rotation)
+        self.polygon(xy, fill, outline, width)
+
+    def rectangle(
+        self,
+        xy: Coords,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a rectangle."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_rectangle(xy, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            self.draw.draw_rectangle(xy, ink, 0, width)
+
+    def rounded_rectangle(
+        self,
+        xy: Coords,
+        radius: float = 0,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+        *,
+        corners: tuple[bool, bool, bool, bool] | None = None,
+    ) -> None:
+        """Draw a rounded rectangle."""
+        if isinstance(xy[0], (list, tuple)):
+            (x0, y0), (x1, y1) = cast(Sequence[Sequence[float]], xy)
+        else:
+            x0, y0, x1, y1 = cast(Sequence[float], xy)
+        if x1 < x0:
+            msg = "x1 must be greater than or equal to x0"
+            raise ValueError(msg)
+        if y1 < y0:
+            msg = "y1 must be greater than or equal to y0"
+            raise ValueError(msg)
+        if corners is None:
+            corners = (True, True, True, True)
+
+        d = radius * 2
+
+        x0 = round(x0)
+        y0 = round(y0)
+        x1 = round(x1)
+        y1 = round(y1)
+        full_x, full_y = False, False
+        if all(corners):
+            full_x = d >= x1 - x0 - 1
+            if full_x:
+                # The two left and two right corners are joined
+                d = x1 - x0
+            full_y = d >= y1 - y0 - 1
+            if full_y:
+                # The two top and two bottom corners are joined
+                d = y1 - y0
+            if full_x and full_y:
+                # If all corners are joined, that is a circle
+                return self.ellipse(xy, fill, outline, width)
+
+        if d == 0 or not any(corners):
+            # If the corners have no curve,
+            # or there are no corners,
+            # that is a rectangle
+            return self.rectangle(xy, fill, outline, width)
+
+        r = int(d // 2)
+        ink, fill_ink = self._getink(outline, fill)
+
+        def draw_corners(pieslice: bool) -> None:
+            parts: tuple[tuple[tuple[float, float, float, float], int, int], ...]
+            if full_x:
+                # Draw top and bottom halves
+                parts = (
+                    ((x0, y0, x0 + d, y0 + d), 180, 360),
+                    ((x0, y1 - d, x0 + d, y1), 0, 180),
+                )
+            elif full_y:
+                # Draw left and right halves
+                parts = (
+                    ((x0, y0, x0 + d, y0 + d), 90, 270),
+                    ((x1 - d, y0, x1, y0 + d), 270, 90),
+                )
+            else:
+                # Draw four separate corners
+                parts = tuple(
+                    part
+                    for i, part in enumerate(
+                        (
+                            ((x0, y0, x0 + d, y0 + d), 180, 270),
+                            ((x1 - d, y0, x1, y0 + d), 270, 360),
+                            ((x1 - d, y1 - d, x1, y1), 0, 90),
+                            ((x0, y1 - d, x0 + d, y1), 90, 180),
+                        )
+                    )
+                    if corners[i]
+                )
+            for part in parts:
+                if pieslice:
+                    self.draw.draw_pieslice(*(part + (fill_ink, 1)))
+                else:
+                    self.draw.draw_arc(*(part + (ink, width)))
+
+        if fill_ink is not None:
+            draw_corners(True)
+
+            if full_x:
+                self.draw.draw_rectangle((x0, y0 + r + 1, x1, y1 - r - 1), fill_ink, 1)
+            elif x1 - r - 1 > x0 + r + 1:
+                self.draw.draw_rectangle((x0 + r + 1, y0, x1 - r - 1, y1), fill_ink, 1)
+            if not full_x and not full_y:
+                left = [x0, y0, x0 + r, y1]
+                if corners[0]:
+                    left[1] += r + 1
+                if corners[3]:
+                    left[3] -= r + 1
+                self.draw.draw_rectangle(left, fill_ink, 1)
+
+                right = [x1 - r, y0, x1, y1]
+                if corners[1]:
+                    right[1] += r + 1
+                if corners[2]:
+                    right[3] -= r + 1
+                self.draw.draw_rectangle(right, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            draw_corners(False)
+
+            if not full_x:
+                top = [x0, y0, x1, y0 + width - 1]
+                if corners[0]:
+                    top[0] += r + 1
+                if corners[1]:
+                    top[2] -= r + 1
+                self.draw.draw_rectangle(top, ink, 1)
+
+                bottom = [x0, y1 - width + 1, x1, y1]
+                if corners[3]:
+                    bottom[0] += r + 1
+                if corners[2]:
+                    bottom[2] -= r + 1
+                self.draw.draw_rectangle(bottom, ink, 1)
+            if not full_y:
+                left = [x0, y0, x0 + width - 1, y1]
+                if corners[0]:
+                    left[1] += r + 1
+                if corners[3]:
+                    left[3] -= r + 1
+                self.draw.draw_rectangle(left, ink, 1)
+
+                right = [x1 - width + 1, y0, x1, y1]
+                if corners[1]:
+                    right[1] += r + 1
+                if corners[2]:
+                    right[3] -= r + 1
+                self.draw.draw_rectangle(right, ink, 1)
+
+    def text(
+        self,
+        xy: tuple[float, float],
+        text: AnyStr | ImageText.Text,
+        fill: _Ink | None = None,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        anchor: str | None = None,
+        spacing: float = 4,
+        align: str = "left",
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        stroke_width: float = 0,
+        stroke_fill: _Ink | None = None,
+        embedded_color: bool = False,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Draw text."""
+        if isinstance(text, ImageText.Text):
+            image_text = text
+        else:
+            if font is None:
+                font = self._getfont(kwargs.get("font_size"))
+            image_text = ImageText.Text(
+                text, font, self.mode, spacing, direction, features, language
+            )
+            if embedded_color:
+                image_text.embed_color()
+            if stroke_width:
+                image_text.stroke(stroke_width, stroke_fill)
+
+        def getink(fill: _Ink | None) -> int:
+            ink, fill_ink = self._getink(fill)
+            if ink is None:
+                assert fill_ink is not None
+                return fill_ink
+            return ink
+
+        ink = getink(fill)
+        if ink is None:
+            return
+
+        stroke_ink = None
+        if image_text.stroke_width:
+            stroke_ink = (
+                getink(image_text.stroke_fill)
+                if image_text.stroke_fill is not None
+                else ink
+            )
+
+        for xy, anchor, line in image_text._split(xy, anchor, align):
+
+            def draw_text(ink: int, stroke_width: float = 0) -> None:
+                mode = self.fontmode
+                if stroke_width == 0 and embedded_color:
+                    mode = "RGBA"
+                coord = []
+                for i in range(2):
+                    coord.append(int(xy[i]))
+                start = (math.modf(xy[0])[0], math.modf(xy[1])[0])
+                try:
+                    mask, offset = image_text.font.getmask2(  # type: ignore[union-attr,misc]
+                        line,
+                        mode,
+                        direction=direction,
+                        features=features,
+                        language=language,
+                        stroke_width=stroke_width,
+                        stroke_filled=True,
+                        anchor=anchor,
+                        ink=ink,
+                        start=start,
+                        *args,
+                        **kwargs,
+                    )
+                    coord = [coord[0] + offset[0], coord[1] + offset[1]]
+                except AttributeError:
+                    try:
+                        mask = image_text.font.getmask(  # type: ignore[misc]
+                            line,
+                            mode,
+                            direction,
+                            features,
+                            language,
+                            stroke_width,
+                            anchor,
+                            ink,
+                            start=start,
+                            *args,
+                            **kwargs,
+                        )
+                    except TypeError:
+                        mask = image_text.font.getmask(line)
+                if mode == "RGBA":
+                    # image_text.font.getmask2(mode="RGBA")
+                    # returns color in RGB bands and mask in A
+                    # extract mask and set text alpha
+                    color, mask = mask, mask.getband(3)
+                    ink_alpha = struct.pack("i", ink)[3]
+                    color.fillband(3, ink_alpha)
+                    x, y = coord
+                    if self.im is not None:
+                        self.im.paste(
+                            color, (x, y, x + mask.size[0], y + mask.size[1]), mask
+                        )
+                else:
+                    self.draw.draw_bitmap(coord, mask, ink)
+
+            if stroke_ink is not None:
+                # Draw stroked text
+                draw_text(stroke_ink, image_text.stroke_width)
+
+                # Draw normal text
+                if ink != stroke_ink:
+                    draw_text(ink)
+            else:
+                # Only draw normal text
+                draw_text(ink)
+
+    def multiline_text(
+        self,
+        xy: tuple[float, float],
+        text: AnyStr,
+        fill: _Ink | None = None,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        anchor: str | None = None,
+        spacing: float = 4,
+        align: str = "left",
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        stroke_width: float = 0,
+        stroke_fill: _Ink | None = None,
+        embedded_color: bool = False,
+        *,
+        font_size: float | None = None,
+    ) -> None:
+        return self.text(
+            xy,
+            text,
+            fill,
+            font,
+            anchor,
+            spacing,
+            align,
+            direction,
+            features,
+            language,
+            stroke_width,
+            stroke_fill,
+            embedded_color,
+            font_size=font_size,
+        )
+
+    def textlength(
+        self,
+        text: AnyStr,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        embedded_color: bool = False,
+        *,
+        font_size: float | None = None,
+    ) -> float:
+        """Get the length of a given string, in pixels with 1/64 precision."""
+        if font is None:
+            font = self._getfont(font_size)
+        image_text = ImageText.Text(
+            text,
+            font,
+            self.mode,
+            direction=direction,
+            features=features,
+            language=language,
+        )
+        if embedded_color:
+            image_text.embed_color()
+        return image_text.get_length()
+
+    def textbbox(
+        self,
+        xy: tuple[float, float],
+        text: AnyStr,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        anchor: str | None = None,
+        spacing: float = 4,
+        align: str = "left",
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        stroke_width: float = 0,
+        embedded_color: bool = False,
+        *,
+        font_size: float | None = None,
+    ) -> tuple[float, float, float, float]:
+        """Get the bounding box of a given string, in pixels."""
+        if font is None:
+            font = self._getfont(font_size)
+        image_text = ImageText.Text(
+            text, font, self.mode, spacing, direction, features, language
+        )
+        if embedded_color:
+            image_text.embed_color()
+        if stroke_width:
+            image_text.stroke(stroke_width)
+        return image_text.get_bbox(xy, anchor, align)
+
+    def multiline_textbbox(
+        self,
+        xy: tuple[float, float],
+        text: AnyStr,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        anchor: str | None = None,
+        spacing: float = 4,
+        align: str = "left",
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        stroke_width: float = 0,
+        embedded_color: bool = False,
+        *,
+        font_size: float | None = None,
+    ) -> tuple[float, float, float, float]:
+        return self.textbbox(
+            xy,
+            text,
+            font,
+            anchor,
+            spacing,
+            align,
+            direction,
+            features,
+            language,
+            stroke_width,
+            embedded_color,
+            font_size=font_size,
+        )
+
+
+def Draw(im: Image.Image, mode: str | None = None) -> ImageDraw:
+    """
+    A simple 2D drawing interface for PIL images.
+
+    :param im: The image to draw in.
+    :param mode: Optional mode to use for color values.  For RGB
+       images, this argument can be RGB or RGBA (to blend the
+       drawing into the image).  For all other modes, this argument
+       must be the same as the image mode.  If omitted, the mode
+       defaults to the mode of the image.
+    """
+    try:
+        return getattr(im, "getdraw")(mode)
+    except AttributeError:
+        return ImageDraw(im, mode)
+
+
+def getdraw(im: Image.Image | None = None) -> tuple[ImageDraw2.Draw | None, ModuleType]:
+    """
+    :param im: The image to draw in.
+    :returns: A (drawing context, drawing resource factory) tuple.
+    """
+    from . import ImageDraw2
+
+    draw = ImageDraw2.Draw(im) if im is not None else None
+    return draw, ImageDraw2
+
+
+def floodfill(
+    image: Image.Image,
+    xy: tuple[int, int],
+    value: float | tuple[int, ...],
+    border: float | tuple[int, ...] | None = None,
+    thresh: float = 0,
+) -> None:
+    """
+    .. warning:: This method is experimental.
+
+    Fills a bounded region with a given color.
+
+    :param image: Target image.
+    :param xy: Seed position (a 2-item coordinate tuple). See
+        :ref:`coordinate-system`.
+    :param value: Fill color.
+    :param border: Optional border value.  If given, the region consists of
+        pixels with a color different from the border color.  If not given,
+        the region consists of pixels having the same color as the seed
+        pixel.
+    :param thresh: Optional threshold value which specifies a maximum
+        tolerable difference of a pixel value from the 'background' in
+        order for it to be replaced. Useful for filling regions of
+        non-homogeneous, but similar, colors.
+    """
+    # based on an implementation by Eric S. Raymond
+    # amended by yo1995 @20180806
+    pixel = image.load()
+    assert pixel is not None
+    x, y = xy
+    try:
+        background = pixel[x, y]
+        if _color_diff(value, background) <= thresh:
+            return  # seed point already has fill color
+        pixel[x, y] = value
+    except (ValueError, IndexError):
+        return  # seed point outside image
+    edge = {(x, y)}
+    # use a set to keep record of current and previous edge pixels
+    # to reduce memory consumption
+    full_edge = set()
+    while edge:
+        new_edge = set()
+        for x, y in edge:  # 4 adjacent method
+            for s, t in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)):
+                # If already processed, or if a coordinate is negative, skip
+                if (s, t) in full_edge or s < 0 or t < 0:
+                    continue
+                try:
+                    p = pixel[s, t]
+                except (ValueError, IndexError):
+                    pass
+                else:
+                    full_edge.add((s, t))
+                    if border is None:
+                        fill = _color_diff(p, background) <= thresh
+                    else:
+                        fill = p not in (value, border)
+                    if fill:
+                        pixel[s, t] = value
+                        new_edge.add((s, t))
+        full_edge = edge  # discard pixels processed
+        edge = new_edge
+
+
+def _compute_regular_polygon_vertices(
+    bounding_circle: Sequence[Sequence[float] | float], n_sides: int, rotation: float
+) -> list[tuple[float, float]]:
+    """
+    Generate a list of vertices for a 2D regular polygon.
+
+    :param bounding_circle: The bounding circle is a sequence defined
+        by a point and radius. The polygon is inscribed in this circle.
+        (e.g. ``bounding_circle=(x, y, r)`` or ``((x, y), r)``)
+    :param n_sides: Number of sides
+        (e.g. ``n_sides=3`` for a triangle, ``6`` for a hexagon)
+    :param rotation: Apply an arbitrary rotation to the polygon
+        (e.g. ``rotation=90``, applies a 90 degree rotation)
+    :return: List of regular polygon vertices
+        (e.g. ``[(25, 50), (50, 50), (50, 25), (25, 25)]``)
+
+    How are the vertices computed?
+    1. Compute the following variables
+        - theta: Angle between the apothem & the nearest polygon vertex
+        - side_length: Length of each polygon edge
+        - centroid: Center of bounding circle (1st, 2nd elements of bounding_circle)
+        - polygon_radius: Polygon radius (last element of bounding_circle)
+        - angles: Location of each polygon vertex in polar grid
+            (e.g. A square with 0 degree rotation => [225.0, 315.0, 45.0, 135.0])
+
+    2. For each angle in angles, get the polygon vertex at that angle
+        The vertex is computed using the equation below.
+            X= xcos(φ) + ysin(φ)
+            Y= −xsin(φ) + ycos(φ)
+
+        Note:
+            φ = angle in degrees
+            x = 0
+            y = polygon_radius
+
+        The formula above assumes rotation around the origin.
+        In our case, we are rotating around the centroid.
+        To account for this, we use the formula below
+            X = xcos(φ) + ysin(φ) + centroid_x
+            Y = −xsin(φ) + ycos(φ) + centroid_y
+    """
+    # 1. Error Handling
+    # 1.1 Check `n_sides` has an appropriate value
+    if not isinstance(n_sides, int):
+        msg = "n_sides should be an int"  # type: ignore[unreachable]
+        raise TypeError(msg)
+    if n_sides < 3:
+        msg = "n_sides should be an int > 2"
+        raise ValueError(msg)
+
+    # 1.2 Check `bounding_circle` has an appropriate value
+    if not isinstance(bounding_circle, (list, tuple)):
+        msg = "bounding_circle should be a sequence"
+        raise TypeError(msg)
+
+    if len(bounding_circle) == 3:
+        if not all(isinstance(i, (int, float)) for i in bounding_circle):
+            msg = "bounding_circle should only contain numeric data"
+            raise ValueError(msg)
+
+        *centroid, polygon_radius = cast(list[float], list(bounding_circle))
+    elif len(bounding_circle) == 2 and isinstance(bounding_circle[0], (list, tuple)):
+        if not all(
+            isinstance(i, (int, float)) for i in bounding_circle[0]
+        ) or not isinstance(bounding_circle[1], (int, float)):
+            msg = "bounding_circle should only contain numeric data"
+            raise ValueError(msg)
+
+        if len(bounding_circle[0]) != 2:
+            msg = "bounding_circle centre should contain 2D coordinates (e.g. (x, y))"
+            raise ValueError(msg)
+
+        centroid = cast(list[float], list(bounding_circle[0]))
+        polygon_radius = cast(float, bounding_circle[1])
+    else:
+        msg = (
+            "bounding_circle should contain 2D coordinates "
+            "and a radius (e.g. (x, y, r) or ((x, y), r) )"
+        )
+        raise ValueError(msg)
+
+    if polygon_radius <= 0:
+        msg = "bounding_circle radius should be > 0"
+        raise ValueError(msg)
+
+    # 1.3 Check `rotation` has an appropriate value
+    if not isinstance(rotation, (int, float)):
+        msg = "rotation should be an int or float"  # type: ignore[unreachable]
+        raise ValueError(msg)
+
+    # 2. Define Helper Functions
+    def _apply_rotation(point: list[float], degrees: float) -> tuple[float, float]:
+        return (
+            round(
+                point[0] * math.cos(math.radians(360 - degrees))
+                - point[1] * math.sin(math.radians(360 - degrees))
+                + centroid[0],
+                2,
+            ),
+            round(
+                point[1] * math.cos(math.radians(360 - degrees))
+                + point[0] * math.sin(math.radians(360 - degrees))
+                + centroid[1],
+                2,
+            ),
+        )
+
+    def _compute_polygon_vertex(angle: float) -> tuple[float, float]:
+        start_point = [polygon_radius, 0]
+        return _apply_rotation(start_point, angle)
+
+    def _get_angles(n_sides: int, rotation: float) -> list[float]:
+        angles = []
+        degrees = 360 / n_sides
+        # Start with the bottom left polygon vertex
+        current_angle = (270 - 0.5 * degrees) + rotation
+        for _ in range(n_sides):
+            angles.append(current_angle)
+            current_angle += degrees
+            if current_angle > 360:
+                current_angle -= 360
+        return angles
+
+    # 3. Variable Declarations
+    angles = _get_angles(n_sides, rotation)
+
+    # 4. Compute Vertices
+    return [_compute_polygon_vertex(angle) for angle in angles]
+
+
+def _color_diff(
+    color1: float | tuple[int, ...], color2: float | tuple[int, ...]
+) -> float:
+    """
+    Uses 1-norm distance to calculate difference between two values.
+    """
+    first = color1 if isinstance(color1, tuple) else (color1,)
+    second = color2 if isinstance(color2, tuple) else (color2,)
+
+    return sum(abs(first[i] - second[i]) for i in range(len(second)))