sketchingpy.pillow_struct

  1"""Structures to support Pillow-based operations.
  2
  3License:
  4    BSD
  5"""
  6
  7import math
  8import typing
  9
 10import PIL.Image
 11import PIL.ImageDraw
 12
 13import sketchingpy.abstracted
 14import sketchingpy.const
 15import sketchingpy.state_struct
 16import sketchingpy.transform
 17
 18COLOR_TUPLE = typing.Union[typing.Tuple[int, int, int], typing.Tuple[int, int, int, int]]
 19
 20
 21class Rect:
 22    """Simple structure describing a region in a sketch."""
 23
 24    def __init__(self, x: float, y: float, width: float, height: float):
 25        """Create a new region.
 26
 27        Args:
 28            x: The x coordinate for the left side of the rectangle.
 29            y: The y coordinate for the top of the rectangle.
 30            width: Horizontal size of the rectangle in pixels.
 31            height: Vertical size of the rectangle in pixels.
 32        """
 33        self._x = x
 34        self._y = y
 35        self._width = width
 36        self._height = height
 37
 38    def get_x(self) -> float:
 39        """Get the starting x coordinate of this region.
 40
 41        Returns:
 42            The x coordinate for the left side of the rectangle.
 43        """
 44        return self._x
 45
 46    def get_y(self) -> float:
 47        """Get the starting y coordinate of this region.
 48
 49        Returns:
 50            The y coordinate for the top of the rectangle.
 51        """
 52        return self._y
 53
 54    def set_x(self, x: float):
 55        """"Set the starting x coordinate of this region.
 56
 57        Args:
 58            x: The x coordinate for the left side of the rectangle.
 59        """
 60        self._x = x
 61
 62    def set_y(self, y: float):
 63        """Set the starting y coordinate of this region.
 64
 65        Args:
 66            y: The y coordinate for the top of the rectangle.
 67        """
 68        self._y = y
 69
 70    def get_width(self) -> float:
 71        """Get the width of this region.
 72
 73        Returns:
 74            Horizontal size of the rectangle in pixels.
 75        """
 76        return self._width
 77
 78    def get_height(self) -> float:
 79        """Get the height of this region.
 80
 81        Returns;
 82            Vertical size of the rectangle in pixels.
 83        """
 84        return self._height
 85
 86    def get_center_x(self) -> float:
 87        """Get the middle x coordinate of this region.
 88
 89        Returns:
 90            Center horizontal coordinate of this region.
 91        """
 92        return self.get_x() + self.get_width() / 2
 93
 94    def get_center_y(self) -> float:
 95        """Get the middle y coordinate of this region.
 96
 97        Returns:
 98            Center vertical coordinate of this region.
 99        """
100        return self.get_y() + self.get_height() / 2
101
102    def set_center_x(self, x: float):
103        """Move this region by setting its center horizontal coordinate.
104
105        Args:
106            x: The x coordinate that should be the new center of the region.
107        """
108        new_x = x - self.get_width() / 2
109        self.set_x(new_x)
110
111    def set_center_y(self, y: float):
112        """Move this region by setting its center vertical coordinate.
113
114        Args:
115            y: The y coordinate that should be the new center of the region.
116        """
117        new_y = y - self.get_height() / 2
118        self.set_y(new_y)
119
120
121class WritableImage:
122    """Decorator around a Pillow image which can be written to."""
123
124    def __init__(self, image: PIL.Image.Image, drawable: PIL.ImageDraw.ImageDraw):
125        """Create a new writable image record.
126
127        Args:
128            image: The Pillow image that isn't writable.
129            drawable: The version of image which can be written to.
130        """
131        self._image = image
132        self._drawable = drawable
133
134    def get_image(self) -> PIL.Image.Image:
135        """Get the Pillow image.
136
137        Returns:
138            The Pillow image that isn't writable.
139        """
140        return self._image
141
142    def get_drawable(self) -> PIL.ImageDraw.ImageDraw:
143        """Get the version of the image which can be written to.
144
145        Returns:
146            The version of image which can be written to.
147        """
148        return self._drawable
149
150
151class TransformedDrawable:
152    """Interface for a transformed drawable component after transformation."""
153
154    def get_with_offset(self, x: float, y: float) -> 'TransformedDrawable':
155        """Get a new version of this same object but with a horizontal and vertical offset.
156
157        Args:
158            x: The horizontal offset in pixels.
159            y: The vertical offset in pixels.
160
161        Returns:
162            A copy of this drawable component but with a positional translation applied.
163        """
164        raise NotImplementedError('Use implementor.')
165
166    def transform(self, transformer: sketchingpy.transform.Transformer) -> 'TransformedDrawable':
167        """Get a new version of this same object but with a transformation applied.
168
169        Args:
170            transformer: Transformation matrix to apply.
171
172        Returns:
173            A copy of this drawable component but with a transformation applied.
174        """
175        raise NotImplementedError('Use implementor.')
176
177    def draw(self, target: WritableImage):
178        """Draw this component.
179
180        Args:
181            target: The image on which to draw this component.
182        """
183        raise NotImplementedError('Use implementor.')
184
185
186class TransformedWritable(TransformedDrawable):
187    """A writable image after transformation."""
188
189    def __init__(self, writable: WritableImage, native_x: float, native_y: float):
190        """Create a new record of a writable which is pre-transformed.
191
192        Args:
193            writable: The writable after transformation.
194            native_x: The horizontal position of where the image should be drawn.
195            native_y: The vertical position of where the image should be drawn.
196        """
197        self._writable = writable
198        self._native_x = native_x
199        self._native_y = native_y
200
201    def get_writable(self) -> WritableImage:
202        """Get the writable image.
203
204        Returns:
205            The image which has been pre-transformed.
206        """
207        return self._writable
208
209    def get_x(self) -> float:
210        """Get the intended x coordinate where this image should be drawn.
211
212        Returns:
213            The horizontal position of where the image should be drawn.
214        """
215        return self._native_x
216
217    def get_y(self) -> float:
218        """Get the intended y coordinate where this image should be drawn.
219
220        Returns:
221            The vertical position of where the image should be drawn.
222        """
223        return self._native_y
224
225    def get_with_offset(self, x: float, y: float) -> TransformedDrawable:
226        return TransformedWritable(self._writable, self._native_x + x, self._native_y + y)
227
228    def transform(self, transformer: sketchingpy.transform.Transformer) -> TransformedDrawable:
229        return get_transformed(
230            transformer,
231            self._writable.get_image(),
232            self._native_x,
233            self._native_y
234        )
235
236    def draw(self, target: WritableImage):
237        subject = self._writable.get_image()
238        native_pos = (int(self._native_x), int(self._native_y))
239        if subject.mode == 'RGB':
240            target.get_image().paste(subject, native_pos)
241        else:
242            target.get_image().paste(subject, native_pos, subject)
243
244
245class TransformedLine(TransformedDrawable):
246    """A pre-transformed simple two point line."""
247
248    def __init__(self, x1: float, y1: float, x2: float, y2: float, stroke: COLOR_TUPLE,
249        weight: float):
250        """Create a new record of a pre-transformed line.
251
252        Args:
253            x1: The first x coordinate.
254            y1: The first y coordinate.
255            x2: The second x coordinate.
256            y2: The second y coordinate.
257            stroke: The color with which to draw this line.
258            weight: The stroke weight to use when drawing.
259        """
260        self._x1 = x1
261        self._y1 = y1
262        self._x2 = x2
263        self._y2 = y2
264        self._stroke = stroke
265        self._weight = weight
266
267    def get_with_offset(self, x: float, y: float) -> TransformedDrawable:
268        return TransformedLine(
269            self._x1 + x,
270            self._y1 + y,
271            self._x2 + x,
272            self._y2 + y,
273            self._stroke,
274            self._weight
275        )
276
277    def transform(self, transformer: sketchingpy.transform.Transformer) -> TransformedDrawable:
278        point_1 = transformer.transform(self._x1, self._y1)
279        point_2 = transformer.transform(self._x2, self._y2)
280        weight = self._weight * point_1.get_scale()
281        return TransformedLine(
282            point_1.get_x(),
283            point_1.get_y(),
284            point_2.get_x(),
285            point_2.get_y(),
286            self._stroke,
287            weight
288        )
289
290    def draw(self, target: WritableImage):
291        target.get_drawable().line(
292            (
293                (self._x1, self._y1),
294                (self._x2, self._y2)
295            ),
296            fill=self._stroke,
297            width=self._weight
298        )
299
300
301class TransformedClear(TransformedDrawable):
302    """A pre-transformed clear operation."""
303
304    def __init__(self, color: COLOR_TUPLE):
305        """Create a record of a clear operation.
306
307        Args:
308            color: The color with which to clear.
309        """
310        self._color = color
311
312    def get_with_offset(self, x: float, y: float) -> TransformedDrawable:
313        return self
314
315    def transform(self, transformer: sketchingpy.transform.Transformer) -> TransformedDrawable:
316        return self
317
318    def draw(self, target: WritableImage):
319        image = target.get_image()
320        size = image.size
321        rect = (0, 0, size[0], size[1])
322        target.get_drawable().rectangle(rect, fill=self._color, width=0)
323
324
325def build_rect_with_mode(x1: float, y1: float, x2: float, y2: float,
326    native_mode: int) -> Rect:
327    """Build a rect with a mode of coordinate specification.
328
329    Args:
330        x1: The left or center x depending on mode.
331        y1: The top or center y depending on mode.
332        x2: The right or type of width depending on mode.
333        y2: The bottom or type of height depending on mode.
334        native_mode: The mode with which the coordinates were provided.
335
336    Returns:
337        Rect which interprets the given coordinates.
338    """
339    if native_mode == sketchingpy.const.CENTER:
340        start_x = x1 - math.floor(x2 / 2)
341        start_y = y1 - math.floor(y2 / 2)
342        width = x2
343        height = y2
344    elif native_mode == sketchingpy.const.RADIUS:
345        start_x = x1 - x2
346        start_y = y1 - y2
347        width = x2 * 2
348        height = y2 * 2
349    elif native_mode == sketchingpy.const.CORNER:
350        start_x = x1
351        start_y = y1
352        width = x2
353        height = y2
354    elif native_mode == sketchingpy.const.CORNERS:
355        (x1, y1, x2, y2) = sketchingpy.abstracted.reorder_coords(x1, y1, x2, y2)
356        start_x = x1
357        start_y = y1
358        width = x2 - x1
359        height = y2 - y1
360    else:
361        raise RuntimeError('Unknown mode: ' + str(native_mode))
362
363    return Rect(start_x, start_y, width, height)
364
365
366class Macro:
367    """Buffer-like object which keeps track of operations instead of the resulting raster."""
368
369    def __init__(self, width: float, height: float):
370        """Build a new macro record.
371
372        Args:
373            width: The horizontal size in pixels of the inteded area of drawing.
374            height: The vertical size in pixels of the inteded area of drawing.
375        """
376        self._width = width
377        self._height = height
378        self._elements: typing.List[TransformedDrawable] = []
379
380    def append(self, target: TransformedDrawable):
381        """Add a new drawable to this macro.
382
383        Args:
384            target: New element to add to this macro.
385        """
386        self._elements.append(target)
387
388    def get(self) -> typing.List[TransformedDrawable]:
389        """Get the elements in this macro.
390
391        Returns:
392            Operations for this macro.
393        """
394        return self._elements
395
396    def get_width(self) -> float:
397        """Get the width of the intended drawing area for this macro.
398
399        Returns:
400            Horizontal size of drawing area.
401        """
402        return self._width
403
404    def get_height(self) -> float:
405        """Get the vertical of the intended drawing area for this macro.
406
407        Returns:
408            Vertical size of drawing area.
409        """
410        return self._height
411
412
413def zero_rect(rect: Rect) -> Rect:
414    """Make a copy of a given rect but where the x and y coordinates are set to zero.
415
416    Args:
417        rect: The rect to put at 0, 0.
418
419    Returns:
420        Copy of the input rect set at 0, 0.
421    """
422    return Rect(0, 0, rect.get_width(), rect.get_height())
423
424
425def get_transformed(transformer: sketchingpy.transform.Transformer, surface: PIL.Image.Image,
426    x: float, y: float) -> TransformedWritable:
427    """Convert an image to a pre-transformed writable.
428
429    Args:
430        transformer: The transformation to pre-apply.
431        surface: The image on which to apply the transformation.
432        x: The intended horizontal draw location of the given position within the given
433            transformation.
434        y: The intended vertical draw location of the given position within the given
435            transformation.
436
437    Returns:
438        Writable with the given transformation pre-applied.
439    """
440    start_rect = Rect(x, y, surface.width, surface.height)
441
442    transformed_center = transformer.transform(
443        start_rect.get_center_x(),
444        start_rect.get_center_y()
445    )
446
447    has_scale = transformed_center.get_scale() != 1
448    has_rotation = transformed_center.get_rotation() != 0
449    has_content_transform = has_scale or has_rotation
450    if has_content_transform:
451        angle = transformed_center.get_rotation()
452        angle_transform = math.degrees(angle)
453        scale = transformed_center.get_scale()
454        surface = surface.rotate(angle_transform, expand=True)
455        surface = surface.resize((
456            int(surface.width * scale),
457            int(surface.height * scale)
458        ))
459
460    end_rect = Rect(x, y, surface.width, surface.height)
461    end_rect.set_center_x(transformed_center.get_x())
462    end_rect.set_center_y(transformed_center.get_y())
463
464    return TransformedWritable(
465        WritableImage(surface, PIL.ImageDraw.Draw(surface)),
466        end_rect.get_x(),
467        end_rect.get_y()
468    )
469
470
471def get_retransformed(transformer: sketchingpy.transform.Transformer,
472    target: TransformedWritable) -> TransformedWritable:
473    """Convert a transformed writable to a further pre-transformed writable.
474
475    Args:
476        transformer: The transformation to pre-apply.
477        target: The transformed writable to re-transform.
478
479    Returns:
480        Writable with the given transformation pre-applied.
481    """
482    return target.transform(transformer)  # type: ignore