1# Copyright 2022, Niklas Hauser
  2# SPDX-License-Identifier: MPL-2.0
  3
  4"""
  5# PDF Graphics
  6
  7PDF uses a subset of the PostScript graphics language, which draws vector paths
  8with various rendering options. We are only interested in the basic properties,
  9in particular, for recognizing table cell borders.
 10
 11In addition, images support bitmap data.
 12"""
 13
 14import ctypes
 15from functools import cached_property
 16from enum import Enum
 17import pypdfium2 as pp
 18from ..utils import Point, Rectangle, Line
 19
 20
 21class Path(pp.PdfObject):
 22    """
 23    This class specializes `pypdfium2.PdfObject` to add accessors for  graphics
 24    containing vector paths of various configurations.
 25
 26    You must construct the paths by calling `modm_data.pdf.page.Page.paths`.
 27    """
 28    class Type(Enum):
 29        """Path Type"""
 30        LINE = 0
 31        BEZIER = 1
 32        MOVE = 2
 33
 34    class Cap(Enum):
 35        """Path Cap Type"""
 36        BUTT = 0
 37        ROUND = 1
 38        PROJECTING_SQUARE = 2
 39
 40    class Join(Enum):
 41        """Path Join Type"""
 42        MITER = 0
 43        ROUND = 1
 44        BEVEL = 2
 45
 46    # Overwrite the PdfPageObject.__new__ function
 47    def __new__(cls, *args, **kwargs):
 48        return object.__new__(cls)
 49
 50    def __init__(self, obj):
 51        """
 52        :param obj: PDF object of the path.
 53        """
 54        super().__init__(obj.raw, obj.page, obj.pdf, obj.level)
 55        assert pp.raw.FPDFPageObj_GetType(obj.raw) == pp.raw.FPDF_PAGEOBJ_PATH
 56        self.type = pp.raw.FPDF_PAGEOBJ_PATH
 57
 58    @cached_property
 59    def matrix(self) -> pp.PdfMatrix:
 60        """The transformation matrix."""
 61        return self.get_matrix()
 62
 63    @cached_property
 64    def count(self) -> int:
 65        """Number of segments in this path."""
 66        return pp.raw.FPDFPath_CountSegments(self)
 67
 68    @cached_property
 69    def fill(self) -> int:
 70        """The fill color encoded as 32-bit RGBA."""
 71        r, g, b, a = ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint()
 72        assert pp.raw.FPDFPageObj_GetFillColor(self, r, g, b, a)
 73        return r.value << 24 | g.value << 16 | b.value << 8 | a.value
 74
 75    @cached_property
 76    def stroke(self) -> int:
 77        """The stroke color encoded as 32-bit RGBA."""
 78        r, g, b, a = ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint()
 79        assert pp.raw.FPDFPageObj_GetStrokeColor(self, r, g, b, a)
 80        return r.value << 24 | g.value << 16 | b.value << 8 | a.value
 81
 82    @cached_property
 83    def width(self) -> float:
 84        """The stroke width."""
 85        width = ctypes.c_float()
 86        assert pp.raw.FPDFPageObj_GetStrokeWidth(self, width)
 87        return width.value
 88
 89    @cached_property
 90    def cap(self) -> Cap:
 91        """Line cap type."""
 92        return Path.Cap(pp.raw.FPDFPageObj_GetLineCap(self))
 93
 94    @cached_property
 95    def join(self) -> Join:
 96        """Line join type."""
 97        return Path.Join(pp.raw.FPDFPageObj_GetLineJoin(self))
 98
 99    @cached_property
100    def bbox(self) -> Rectangle:
101        """
102        Bounding box of the path.
103        .. warning::
104            The bounding is only approximated using the control points!
105            Therefore bezier curves will likely have a larger bounding box.
106        """
107        l, b = ctypes.c_float(), ctypes.c_float()
108        r, t = ctypes.c_float(), ctypes.c_float()
109        assert pp.raw.FPDFPageObj_GetBounds(self, l, b, r, t)
110        bbox = Rectangle(l.value, b.value, r.value, t.value)
111        if self.page.rotation:
112            bbox = Rectangle(bbox.p0.y, self.page.height - bbox.p1.x,
113                             bbox.p1.y, self.page.height - bbox.p0.x)
114        return bbox
115
116    @cached_property
117    def points(self) -> list[Point]:
118        """
119        List of points of the path. If the path is closed, the first point is
120        added to the end of the list.
121        """
122        points = []
123        for ii in range(self.count):
124            seg = pp.raw.FPDFPath_GetPathSegment(self, ii)
125            ptype = Path.Type(pp.raw.FPDFPathSegment_GetType(seg))
126            # The first point should always be MOVETO
127            assert ii or ptype == Path.Type.MOVE
128
129            x, y = ctypes.c_float(), ctypes.c_float()
130            assert pp.raw.FPDFPathSegment_GetPoint(seg, x, y)
131            x, y = self.matrix.on_point(x.value, y.value)
132            points.append(Point(x, y, type=ptype))
133
134            if pp.raw.FPDFPathSegment_GetClose(seg):
135                points.append(Point(points[0].x, points[0].y, type=Path.Type.LINE))
136
137        if self.page.rotation:
138            points = [Point(y, self.page.height - x, type=p.type) for p in points]
139        return points
140
141    @cached_property
142    def lines(self) -> list[Line]:
143        """List of lines between the path points."""
144        points = self.points
145        return [Line(points[ii], points[ii + 1], width=self.width,
146                     type=points[ii + 1].type) for ii in range(len(points) - 1)]
147
148    def __repr__(self) -> str:
149        points = ",".join(repr(p) for p in self.points)
150        return f"P{self.count}={points}"
151
152
153class Image(pp.PdfImage):
154    """
155    This class extends `pypdfium2.PdfImage` to align it with the interface of
156    the `Path` class so that it can be used in the same
157    algorithms without filtering.
158
159    You must construct the images by calling `modm_data.pdf.page.Page.images`.
160
161    .. note:: Images are currently ignored.
162    """
163    # Overwrite the PdfPageObject.__new__ function
164    def __new__(cls, *args, **kwargs):
165        return object.__new__(cls)
166
167    def __init__(self, obj):
168        """
169        :param obj: Page object of the image.
170        """
171        super().__init__(obj.raw, obj.page, obj.pdf, obj.level)
172        assert pp.raw.FPDFPageObj_GetType(obj.raw) == pp.raw.FPDF_PAGEOBJ_IMAGE
173        self.type = pp.raw.FPDF_PAGEOBJ_IMAGE
174
175        self.count: int = 4
176        """Number of segments. Always 4 due to rectangular image form.
177           (For compatibility with `Path.count`.)"""
178        self.stroke: int = 0
179        """The border stroke color. Always 0.
180           (For compatibility with `Path.stroke`.)"""
181        self.fill: int = 0
182        """The image fill color. Always 0.
183           (For compatibility with `Path.fill`.)"""
184        self.width: float = 0
185        """The border line width. Always 0.
186           (For compatibility with `Path.width`.)"""
187
188    @cached_property
189    def matrix(self) -> pp.PdfMatrix:
190        """The transformation matrix."""
191        return self.get_matrix()
192
193    @cached_property
194    def bbox(self) -> Rectangle:
195        """The bounding box of the image."""
196        bbox = Rectangle(*self.get_pos())
197        if self.page.rotation:
198            bbox = Rectangle(bbox.p0.y, self.page.height - bbox.p1.x,
199                             bbox.p1.y, self.page.height - bbox.p0.x)
200        return bbox
201
202    @cached_property
203    def points(self) -> list[Point]:
204        """
205        The 4 points of the bounding box.
206        (For compatibility with `Path.points`.)
207        """
208        points = self.bbox.points
209        if self.page.rotation:
210            points = [Point(p.y, self.page.height - p.x, p.type) for p in points]
211        return points
212
213    @cached_property
214    def lines(self) -> list[Line]:
215        """
216        The 4 lines of the bounding box.
217        (For compatibility with `Path.lines`.)
218        """
219        p = self.points
220        return [Line(p[0], p[1], p[1].type, 0), Line(p[1], p[2], p[2].type, 0),
221                Line(p[2], p[3], p[3].type, 0), Line(p[3], p[0], p[0].type, 0)]
222
223    def __repr__(self) -> str:
224        return f"I{self.bbox}"