sketchingpy.sketch2dstatic

  1"""Pillow-based renderer for Sketchingpy.
  2
  3License:
  4    BSD
  5"""
  6
  7import copy
  8import typing
  9import PIL.Image
 10import PIL.ImageColor
 11import PIL.ImageFont
 12
 13has_matplot_lib = False
 14try:
 15    import matplotlib.pyplot  # type: ignore
 16    has_matplot_lib = True
 17except:
 18    pass
 19
 20
 21has_numpy_lib = False
 22try:
 23    import numpy
 24    has_numpy_lib = True
 25except:
 26    pass
 27
 28import sketchingpy.abstracted
 29import sketchingpy.const
 30import sketchingpy.control_struct
 31import sketchingpy.data_struct
 32import sketchingpy.local_data_struct
 33import sketchingpy.pillow_struct
 34import sketchingpy.pillow_util
 35import sketchingpy.state_struct
 36import sketchingpy.transform
 37
 38DEFAULT_FPS = 20
 39MANUAL_OFFSET = False
 40TRANSFORMED_WRITABLE = sketchingpy.pillow_struct.TransformedWritable
 41
 42
 43class Sketch2DStatic(sketchingpy.abstracted.Sketch):
 44    """Pillow-based Sketch renderer."""
 45
 46    def __init__(self, width: int, height: int, title: typing.Optional[str] = None,
 47        loading_src: typing.Optional[str] = None):
 48        """Create a new Pillow-based sketch.
 49
 50        Args:
 51            width: The width of the sketch in pixels. This will be used as the horizontal image
 52                size.
 53            height: The height of the sketch in pixels. This will be used as the vertical image
 54                size.
 55            title: Title for the sketch. Ignored, reserved for future use.
 56            loading_src: ID for loading screen. Ignored, reserved for future use.
 57        """
 58        super().__init__()
 59
 60        # System params
 61        self._width = width
 62        self._height = height
 63
 64        # Internal image
 65        native_size = (self._width, self._height)
 66        target_image = PIL.Image.new('RGB', native_size)
 67        target_draw = PIL.ImageDraw.Draw(target_image, 'RGBA')
 68
 69        self._target_writable = sketchingpy.pillow_struct.WritableImage(target_image, target_draw)
 70        self._base_writable = self._target_writable
 71        self._buffers: typing.Dict[str, sketchingpy.pillow_struct.WritableImage] = {}
 72
 73        self._target_macro: typing.Optional[sketchingpy.pillow_struct.Macro] = None
 74        self._macros: typing.Dict[str, sketchingpy.pillow_struct.Macro] = {}
 75        self._in_macro = False
 76
 77        # Other internals
 78        self._transformer = sketchingpy.transform.Transformer()
 79        self._transformer_stack: typing.List[sketchingpy.transform.Transformer] = []
 80
 81    ##########
 82    # Buffer #
 83    ##########
 84
 85    def create_buffer(self, name: str, width: int, height: int,
 86        background: typing.Optional[str] = None):
 87        if name in self._buffers:
 88            del self._buffers[name]
 89
 90        if name in self._macros:
 91            del self._macros[name]
 92
 93        has_alpha = self._get_is_color_transparent(background)
 94        if has_alpha:
 95            self._macros[name] = sketchingpy.pillow_struct.Macro(width, height)
 96        else:
 97            self._buffers[name] = self._make_buffer_surface(
 98                sketchingpy.pillow_struct.Rect(0, 0, width, height)
 99            )
100            rect = (0, 0, width, height)
101            self._buffers[name].get_drawable().rectangle(rect, fill=background, width=0)
102
103    def enter_buffer(self, name: str):
104        if name in self._buffers:
105            self._target_writable = self._buffers[name]
106            self._in_macro = False
107        else:
108            self._target_macro = self._macros[name]
109            self._in_macro = True
110
111    def exit_buffer(self):
112        self._target_writable = self._base_writable
113        self._in_macro = False
114
115    def draw_buffer(self, x: float, y: float, name: str):
116        if name in self._buffers:
117            subject = self._buffers[name]
118            transformed = self._get_transformed(subject.get_image(), x, y)
119            self._draw_or_queue_transformed(transformed)
120        elif name in self._macros:
121            compiled = self._macros[name].get()
122            moved = map(lambda piece: piece.get_with_offset(x, y), compiled)
123            if self._in_macro:
124                for piece in moved:
125                    self._get_target_marco().append(piece)
126            else:
127                for piece in moved:
128                    self._get_retransformed(piece).draw(self._target_writable)  # type: ignore
129        else:
130            raise RuntimeError('Unknown buffer: ' + name)
131
132    ############
133    # Controls #
134    ############
135
136    def get_keyboard(self) -> typing.Optional[sketchingpy.control_struct.Keyboard]:
137        return None
138
139    def get_mouse(self) -> typing.Optional[sketchingpy.control_struct.Mouse]:
140        return None
141
142    ########
143    # Data #
144    ########
145
146    def get_data_layer(self) -> typing.Optional[sketchingpy.data_struct.DataLayer]:
147        return sketchingpy.local_data_struct.LocalDataLayer()
148
149    ###########
150    # Dialogs #
151    ###########
152
153    def get_dialog_layer(self) -> typing.Optional[sketchingpy.dialog_struct.DialogLayer]:
154        return None
155
156    ###########
157    # Drawing #
158    ###########
159
160    def clear(self, color_hex: str):
161        color = PIL.ImageColor.getrgb(color_hex)
162        transformed = sketchingpy.pillow_struct.TransformedClear(color)
163        self._draw_or_queue_transformed(transformed)
164
165    def draw_arc(self, x1: float, y1: float, x2: float, y2: float, a1: float,
166        a2: float):
167        state_machine = self._get_current_state_machine()
168
169        stroke_enabled = state_machine.get_stroke_enabled()
170        fill_enabled = state_machine.get_fill_enabled()
171        stroke_native = state_machine.get_stroke_native()
172        fill_native = state_machine.get_fill_native()
173        stroke_weight = state_machine.get_stroke_weight()
174
175        mode_native = state_machine.get_arc_mode_native()
176        rect = self._build_rect_with_mode(x1, y1, x2, y2, mode_native)
177
178        a1_rad = self._convert_to_radians(a1)
179        a2_rad = self._convert_to_radians(a2)
180
181        pillow_util_image = sketchingpy.pillow_util.make_arc_image(
182            rect.get_x(),
183            rect.get_y(),
184            rect.get_width(),
185            rect.get_height(),
186            a1_rad,
187            a2_rad,
188            stroke_enabled,
189            fill_enabled,
190            stroke_native if stroke_enabled else None,
191            fill_native if fill_enabled else None,
192            stroke_weight
193        )
194
195        transformed = self._get_transformed(
196            pillow_util_image.get_image(),
197            pillow_util_image.get_x(),
198            pillow_util_image.get_y()
199        )
200
201        self._draw_or_queue_transformed(transformed)
202
203    def draw_ellipse(self, x1: float, y1: float, x2: float, y2: float):
204        state_machine = self._get_current_state_machine()
205
206        stroke_enabled = state_machine.get_stroke_enabled()
207        fill_enabled = state_machine.get_fill_enabled()
208        stroke_native = state_machine.get_stroke_native()
209        fill_native = state_machine.get_fill_native()
210        stroke_weight = state_machine.get_stroke_weight()
211
212        mode_native = state_machine.get_ellipse_mode_native()
213        rect = self._build_rect_with_mode(x1, y1, x2, y2, mode_native)
214
215        pillow_util_image = sketchingpy.pillow_util.make_ellipse_image(
216            rect.get_x(),
217            rect.get_y(),
218            rect.get_width(),
219            rect.get_height(),
220            stroke_enabled,
221            fill_enabled,
222            stroke_native,
223            fill_native,
224            stroke_weight
225        )
226
227        transformed = self._get_transformed(
228            pillow_util_image.get_image(),
229            pillow_util_image.get_x(),
230            pillow_util_image.get_y()
231        )
232
233        self._draw_or_queue_transformed(transformed)
234
235    def draw_line(self, x1: float, y1: float, x2: float, y2: float):
236        state_machine = self._get_current_state_machine()
237        if not state_machine.get_stroke_enabled():
238            return
239
240        stroke_color = state_machine.get_stroke_native()
241        stroke_weight = state_machine.get_stroke_weight_native()
242
243        point_1 = self._transformer.transform(x1, y1)
244        point_2 = self._transformer.transform(x2, y2)
245
246        transformed = sketchingpy.pillow_struct.TransformedLine(
247            point_1.get_x(),
248            point_1.get_y(),
249            point_2.get_x(),
250            point_2.get_y(),
251            stroke_color,
252            stroke_weight * point_1.get_scale()
253        )
254        self._draw_or_queue_transformed(transformed)
255
256    def draw_rect(self, x1: float, y1: float, x2: float, y2: float):
257        state_machine = self._get_current_state_machine()
258
259        stroke_enabled = state_machine.get_stroke_enabled()
260        fill_enabled = state_machine.get_fill_enabled()
261        stroke_native = state_machine.get_stroke_native()
262        fill_native = state_machine.get_fill_native()
263        stroke_weight = state_machine.get_stroke_weight()
264
265        mode_native = state_machine.get_rect_mode_native()
266        rect = self._build_rect_with_mode(x1, y1, x2, y2, mode_native)
267
268        pillow_util_image = sketchingpy.pillow_util.make_rect_image(
269            rect.get_x(),
270            rect.get_y(),
271            rect.get_width(),
272            rect.get_height(),
273            stroke_enabled,
274            fill_enabled,
275            stroke_native,
276            fill_native,
277            stroke_weight
278        )
279
280        transformed = self._get_transformed(
281            pillow_util_image.get_image(),
282            pillow_util_image.get_x(),
283            pillow_util_image.get_y()
284        )
285
286        self._draw_or_queue_transformed(transformed)
287
288    def draw_shape(self, shape: sketchingpy.shape_struct.Shape):
289        if not shape.get_is_finished():
290            raise RuntimeError('Finish your shape before drawing.')
291
292        state_machine = self._get_current_state_machine()
293
294        stroke_enabled = state_machine.get_stroke_enabled()
295        fill_enabled = state_machine.get_fill_enabled()
296        stroke_native = state_machine.get_stroke_native()
297        fill_native = state_machine.get_fill_native()
298        stroke_weight = state_machine.get_stroke_weight()
299
300        pillow_util_image = sketchingpy.pillow_util.make_shape_image(
301            shape,
302            stroke_enabled,
303            fill_enabled,
304            stroke_native if stroke_enabled else None,
305            fill_native if fill_enabled else None,
306            stroke_weight
307        )
308
309        transformed = self._get_transformed(
310            pillow_util_image.get_image(),
311            pillow_util_image.get_x(),
312            pillow_util_image.get_y()
313        )
314        self._draw_or_queue_transformed(transformed)
315
316    def draw_text(self, x: float, y: float, content: str):
317        content = str(content)
318        state_machine = self._get_current_state_machine()
319
320        y = y + 1
321
322        stroke_enabled = state_machine.get_stroke_enabled()
323        fill_enabled = state_machine.get_fill_enabled()
324        stroke_native = state_machine.get_stroke_native()
325        fill_native = state_machine.get_fill_native()
326        stroke_weight = state_machine.get_stroke_weight()
327
328        text_font = state_machine.get_text_font_native()
329
330        align_info = state_machine.get_text_align_native()
331        anchor_str = align_info.get_horizontal_align() + align_info.get_vertical_align()
332
333        pillow_util_image = sketchingpy.pillow_util.make_text_image(
334            x,
335            y,
336            content,
337            text_font,
338            stroke_enabled,
339            fill_enabled,
340            stroke_native,
341            fill_native,
342            stroke_weight,
343            anchor_str
344        )
345
346        transformed = self._get_transformed(
347            pillow_util_image.get_image(),
348            pillow_util_image.get_x(),
349            pillow_util_image.get_y()
350        )
351        self._draw_or_queue_transformed(transformed)
352
353    ##########
354    # Events #
355    ##########
356
357    def on_step(self, callback: sketchingpy.abstracted.StepCallback):
358        pass
359
360    def on_quit(self, callback: sketchingpy.abstracted.QuitCallback):
361        pass
362
363    #########
364    # Image #
365    #########
366
367    def get_image(self, src: str) -> sketchingpy.abstracted.Image:
368        return PillowImage(src)
369
370    def draw_image(self, x: float, y: float, image: sketchingpy.abstracted.Image):
371        if not image.get_is_loaded():
372            return
373
374        image_mode_native = self._get_current_state_machine().get_image_mode_native()
375
376        rect = self._build_rect_with_mode(
377            x,
378            y,
379            image.get_width(),
380            image.get_height(),
381            image_mode_native
382        )
383
384        surface = image.get_native()
385
386        transformed = self._get_transformed(surface, rect.get_x(), rect.get_y())
387        self._draw_or_queue_transformed(transformed)
388
389    def save_image(self, path: str):
390        if self._in_macro:
391            width = self._get_target_marco().get_width()
392            height = self._get_target_marco().get_height()
393            target = self._make_buffer_surface(sketchingpy.pillow_struct.Rect(0, 0, width, height))
394
395            for compiled in self._get_target_marco().get():
396                compiled.draw(target)
397
398            target.get_image().save(path)
399        else:
400            self._target_writable.get_image().save(path)
401
402    #########
403    # State #
404    #########
405
406    def push_transform(self):
407        self._transformer_stack.append(copy.deepcopy(self._transformer))
408
409    def pop_transform(self):
410        if len(self._transformer_stack) == 0:
411            raise RuntimeError('Transformation stack empty.')
412
413        self._transformer = self._transformer_stack.pop()
414
415    ##########
416    # System #
417    ##########
418
419    def get_millis_shown(self):
420        return 0
421
422    def get_native(self):
423        return self._target_writable
424
425    def set_fps(self, rate: int):
426        pass
427
428    def set_title(self, title: str):
429        pass
430
431    def quit(self):
432        pass
433
434    def show(self, ax=None):
435        if has_matplot_lib and has_numpy_lib:
436            if ax is None:
437                ax = matplotlib.pyplot.subplot(111)
438                ax.axis('off')
439
440            ax.imshow(numpy.asarray(self._target_writable.get_image()))
441        else:
442            raise RuntimeError('Install matplotlib and numpy or use save instead.')
443
444    def show_and_quit(self, ax=None):
445        pass
446
447    #############
448    # Transform #
449    #############
450
451    def translate(self, x: float, y: float):
452        self._transformer.translate(x, y)
453
454    def rotate(self, angle_mirror: float):
455        angle = -1 * angle_mirror
456        angle_rad = self._convert_to_radians(angle)
457        self._transformer.rotate(angle_rad)
458
459    def scale(self, scale: float):
460        self._transformer.scale(scale)
461
462    ###########
463    # Support #
464    ###########
465
466    def _get_target_marco(self) -> sketchingpy.pillow_struct.Macro:
467        assert self._target_macro is not None
468        return self._target_macro
469
470    def _draw_or_queue_transformed(self,
471        transformed: sketchingpy.pillow_struct.TransformedDrawable):
472        if self._in_macro:
473            self._get_target_marco().append(transformed)
474        else:
475            transformed.draw(self._target_writable)
476
477    def _create_state_machine(self) -> sketchingpy.state_struct.SketchStateMachine:
478        return PillowSketchStateMachine()
479
480    def _make_buffer_surface(self,
481        rect: sketchingpy.pillow_struct.Rect) -> sketchingpy.pillow_struct.WritableImage:
482        native_size = (round(rect.get_width()), round(rect.get_height()))
483        target_image = PIL.Image.new('RGB', native_size, (255, 255, 255, 0))
484        target_draw = PIL.ImageDraw.Draw(target_image, 'RGBA')
485        return sketchingpy.pillow_struct.WritableImage(target_image, target_draw)
486
487    def _offset_stroke_weight(self, rect: sketchingpy.pillow_struct.Rect,
488        stroke_weight: float) -> sketchingpy.pillow_struct.Rect:
489        if not MANUAL_OFFSET:
490            return rect
491
492        half_weight = stroke_weight / 2
493        return sketchingpy.pillow_struct.Rect(
494            rect.get_x() - half_weight,
495            rect.get_y() - half_weight,
496            rect.get_width() + half_weight * 2,
497            rect.get_height() + half_weight * 2
498        )
499
500    def _offset_fill_weight(self, rect: sketchingpy.pillow_struct.Rect,
501        stroke_weight: float) -> sketchingpy.pillow_struct.Rect:
502        if not MANUAL_OFFSET:
503            return rect
504
505        half_weight = stroke_weight / 2
506        return sketchingpy.pillow_struct.Rect(
507            rect.get_x() + half_weight,
508            rect.get_y() + half_weight,
509            rect.get_width() - half_weight * 2,
510            rect.get_height() - half_weight * 2
511        )
512
513    def _zero_rect(self, rect: sketchingpy.pillow_struct.Rect) -> sketchingpy.pillow_struct.Rect:
514        return sketchingpy.pillow_struct.zero_rect(rect)
515
516    def _build_rect_with_mode(self, x1: float, y1: float, x2: float, y2: float,
517        native_mode: int) -> sketchingpy.pillow_struct.Rect:
518        return sketchingpy.pillow_struct.build_rect_with_mode(x1, y1, x2, y2, native_mode)
519
520    def _get_transformed(self, surface: PIL.Image.Image, x: float,
521        y: float) -> sketchingpy.pillow_struct.TransformedWritable:
522        return sketchingpy.pillow_struct.get_transformed(
523            self._transformer,
524            surface,
525            x,
526            y
527        )
528
529    def _get_retransformed(self, target: TRANSFORMED_WRITABLE) -> TRANSFORMED_WRITABLE:
530        return sketchingpy.pillow_struct.get_retransformed(
531            self._transformer,
532            target
533        )
534
535
536class PillowSketchStateMachine(sketchingpy.state_struct.SketchStateMachine):
537
538    def __init__(self):
539        super().__init__()
540        self._fill_native = self._convert_color(super().get_fill())
541        self._stroke_native = self._convert_color(super().get_stroke())
542        self._font_cache = {}
543        self._text_align_native = self._transform_text_align(super().get_text_align_native())
544
545    def set_fill(self, fill: str):
546        super().set_fill(fill)
547        self._fill_native = self._convert_color(super().get_fill())
548
549    def get_fill_native(self):
550        return self._fill_native
551
552    def set_stroke(self, stroke: str):
553        super().set_stroke(stroke)
554        self._stroke_native = self._convert_color(super().get_stroke())
555
556    def get_stroke_native(self):
557        return self._stroke_native
558
559    def get_text_font_native(self):
560        font = self.get_text_font()
561        key = '%s.%d' % (font.get_identifier(), font.get_size())
562
563        if key not in self._font_cache:
564            new_font = PIL.ImageFont.truetype(font.get_identifier(), font.get_size())
565            self._font_cache[key] = new_font
566
567        return self._font_cache[key]
568
569    def set_text_align(self, text_align: sketchingpy.state_struct.TextAlign):
570        super().set_text_align(text_align)
571        self._text_align_native = self._transform_text_align(super().get_text_align_native())
572
573    def get_text_align_native(self):
574        return self._text_align_native
575
576    def _transform_text_align(self,
577        text_align: sketchingpy.state_struct.TextAlign) -> sketchingpy.state_struct.TextAlign:
578
579        HORIZONTAL_ALIGNS = {
580            sketchingpy.const.LEFT: 'l',
581            sketchingpy.const.CENTER: 'm',
582            sketchingpy.const.RIGHT: 'r'
583        }
584
585        VERTICAL_ALIGNS = {
586            sketchingpy.const.TOP: 't',
587            sketchingpy.const.CENTER: 'm',
588            sketchingpy.const.BASELINE: 's',
589            sketchingpy.const.BOTTOM: 'b'
590        }
591
592        return sketchingpy.state_struct.TextAlign(
593            HORIZONTAL_ALIGNS[text_align.get_horizontal_align()],
594            VERTICAL_ALIGNS[text_align.get_vertical_align()]
595        )
596
597    def _convert_color(self, target: str) -> sketchingpy.pillow_struct.COLOR_TUPLE:
598        return PIL.ImageColor.getrgb(target)
599
600
601class PillowImage(sketchingpy.abstracted.Image):
602
603    def __init__(self, src: str):
604        super().__init__(src)
605        self._native = PIL.Image.open(src)
606
607    def get_width(self) -> float:
608        return self._native.width
609
610    def get_height(self) -> float:
611        return self._native.height
612
613    def resize(self, width: float, height: float):
614        self._native = self._native.resize((int(width), int(height)))
615
616    def get_native(self):
617        return self._native
618
619    def get_is_loaded(self):
620        return True