commit d8a8e887ef2cd528f61fc4ade6dd389b3dbb41b2 · cduck.me/drawsvg

+10

drawSvg/__init__.py

···

       48
       48
        
       from .raster import Raster

     

       49
       49
        
       from .drawing import Drawing

     

       50
       50
        
       from .elements import *

     

       51
       51
       +
       from .video import (

     

       52
       52
       +
           render_svg_frames,

     

       53
       53
       +
           save_video,

     

       54
       54
       +
       )

     

       55
       55
       +
       from .animation import (

     

       56
       56
       +
           Animation,

     

       57
       57
       +
           animate_video,

     

       58
       58
       +
           animate_jupyter,

     

       59
       59
       +
       )

     

       60
       60
       +
       

     

       51
       61
        
       

     

       52
       62
        
       # Make all elements available in the elements module

     

       53
       63
        
       from . import defs

+104

drawSvg/animation.py

···

       1
       1
       +
       import time

     

       2
       2
       +
       

     

       3
       3
       +
       from . import video

     

       4
       4
       +
       

     

       5
       5
       +
       

     

       6
       6
       +
       class Animation:

     

       7
       7
       +
           def __init__(self, draw_func=None, callback=None):

     

       8
       8
       +
               self.frames = []

     

       9
       9
       +
               if draw_func is None:

     

       10
       10
       +
                   draw_func = lambda d:d

     

       11
       11
       +
               self.draw_func = draw_func

     

       12
       12
       +
               if callback is None:

     

       13
       13
       +
                   callback = lambda d:None

     

       14
       14
       +
               self.callback = callback

     

       15
       15
       +
       

     

       16
       16
       +
           def append_frame(self, frame):

     

       17
       17
       +
               self.frames.append(frame)

     

       18
       18
       +
               self.callback(frame)

     

       19
       19
       +
       

     

       20
       20
       +
           def draw_frame(self, *args, **kwargs):

     

       21
       21
       +
               frame = self.draw_func(*args, **kwargs)

     

       22
       22
       +
               self.append_frame(frame)

     

       23
       23
       +
               return frame

     

       24
       24
       +
       

     

       25
       25
       +
           def save_video(self, file, **kwargs):

     

       26
       26
       +
               video.save_video(self.frames, file, **kwargs)

     

       27
       27
       +
       

     

       28
       28
       +
       

     

       29
       29
       +
       class AnimationContext:

     

       30
       30
       +
           def __init__(self, draw_func=None, out_file=None,

     

       31
       31
       +
                        jupyter=False, pause=False, clear=True, delay=0, disable=False,

     

       32
       32
       +
                        video_args=None, _patch_delay=0.05):

     

       33
       33
       +
               self.jupyter = jupyter

     

       34
       34
       +
               self.disable = disable

     

       35
       35
       +
               if self.jupyter and not self.disable:

     

       36
       36
       +
                   from IPython import display

     

       37
       37
       +
                   self._jupyter_clear_output = display.clear_output

     

       38
       38
       +
                   self._jupyter_display = display.display

     

       39
       39
       +
                   callback = self.draw_jupyter_frame

     

       40
       40
       +
               else:

     

       41
       41
       +
                   callback = None

     

       42
       42
       +
               self.anim = Animation(draw_func, callback=callback)

     

       43
       43
       +
               self.out_file = out_file

     

       44
       44
       +
               self.pause = pause

     

       45
       45
       +
               self.clear = clear

     

       46
       46
       +
               self.delay = delay

     

       47
       47
       +
               if video_args is None:

     

       48
       48
       +
                   video_args = {}

     

       49
       49
       +
               self.video_args = video_args

     

       50
       50
       +
               self._patch_delay = _patch_delay

     

       51
       51
       +
       

     

       52
       52
       +
           def draw_jupyter_frame(self, frame):

     

       53
       53
       +
               if self.clear:

     

       54
       54
       +
                   self._jupyter_clear_output(wait=True)

     

       55
       55
       +
               self._jupyter_display(frame)

     

       56
       56
       +
               if self.pause:

     

       57
       57
       +
                   # Patch.  Jupyter sometimes clears the input field otherwise.

     

       58
       58
       +
                   time.sleep(self._patch_delay)

     

       59
       59
       +
                   input('Next?')

     

       60
       60
       +
               elif self.delay != 0:

     

       61
       61
       +
                   time.sleep(self.delay)

     

       62
       62
       +
       

     

       63
       63
       +
           def __enter__(self):

     

       64
       64
       +
               return self.anim

     

       65
       65
       +
       

     

       66
       66
       +
           def __exit__(self, exc_type, exc_value, exc_traceback):

     

       67
       67
       +
               if exc_value is None:

     

       68
       68
       +
                   # No error

     

       69
       69
       +
                   if self.out_file is not None and not self.disable:

     

       70
       70
       +
                       self.anim.save_video(self.out_file, **self.video_args)

     

       71
       71
       +
       

     

       72
       72
       +
       

     

       73
       73
       +
       def animate_video(out_file, draw_func=None, jupyter=False, **video_args):

     

       74
       74
       +
           '''

     

       75
       75
       +
           Returns a context manager that stores frames and saves a video when the

     

       76
       76
       +
           context exits.

     

       77
       77
       +
       

     

       78
       78
       +
           Example:

     

       79
       79
       +
           ```

     

       80
       80
       +
           with animate_video('video.mp4') as draw_frame:

     

       81
       81
       +
               while True:

     

       82
       82
       +
                   ...

     

       83
       83
       +
                   draw_frame(...)

     

       84
       84
       +
           ```

     

       85
       85
       +
           '''

     

       86
       86
       +
           return AnimationContext(draw_func=draw_func, out_file=out_file,

     

       87
       87
       +
                                   jupyter=jupyter, video_args=video_args)

     

       88
       88
       +
       

     

       89
       89
       +
       

     

       90
       90
       +
       def animate_jupyter(draw_func=None, pause=False, clear=True, delay=0.1,

     

       91
       91
       +
                           **kwargs):

     

       92
       92
       +
           '''

     

       93
       93
       +
           Returns a context manager that displays frames in a Jupyter notebook.

     

       94
       94
       +
       

     

       95
       95
       +
           Example:

     

       96
       96
       +
           ```

     

       97
       97
       +
           with animate_jupyter(delay=0.5) as draw_frame:

     

       98
       98
       +
               while True:

     

       99
       99
       +
                   ...

     

       100
       100
       +
                   draw_frame(...)

     

       101
       101
       +
           ```

     

       102
       102
       +
           '''

     

       103
       103
       +
           return AnimationContext(draw_func=draw_func, jupyter=True, pause=pause,

     

       104
       104
       +
                                   clear=clear, delay=delay, **kwargs)

+54

drawSvg/video.py

···

       1
       1
       +
       import numpy as np

     

       2
       2
       +
       import imageio

     

       3
       3
       +
       

     

       4
       4
       +
       from .drawing import Drawing

     

       5
       5
       +
       

     

       6
       6
       +
       

     

       7
       7
       +
       def render_svg_frames(frames, align_bottom=False, align_right=False,

     

       8
       8
       +
                             bg=(255,)*4, **kwargs):

     

       9
       9
       +
           arr_frames = [imageio.imread(d.rasterize().pngData)

     

       10
       10
       +
                         for d in frames]

     

       11
       11
       +
           max_width = max(map(lambda arr:arr.shape[1], arr_frames))

     

       12
       12
       +
           max_height = max(map(lambda arr:arr.shape[0], arr_frames))

     

       13
       13
       +
       

     

       14
       14
       +
           def mod_frame(arr):

     

       15
       15
       +
               new_arr = np.zeros((max_height, max_width) + arr.shape[2:],

     

       16
       16
       +
                                  dtype=arr.dtype)

     

       17
       17
       +
               new_arr[:,:] = bg[:new_arr.shape[-1]]

     

       18
       18
       +
               if align_bottom:

     

       19
       19
       +
                   slice0 = slice(-arr.shape[0], None)

     

       20
       20
       +
               else:

     

       21
       21
       +
                   slice0 = slice(None, arr.shape[0])

     

       22
       22
       +
               if align_right:

     

       23
       23
       +
                   slice1 = slice(-arr.shape[1], None)

     

       24
       24
       +
               else:

     

       25
       25
       +
                   slice1 = slice(None, arr.shape[1])

     

       26
       26
       +
               new_arr[slice0, slice1] = arr

     

       27
       27
       +
               return new_arr

     

       28
       28
       +
           return list(map(mod_frame, arr_frames))

     

       29
       29
       +
       

     

       30
       30
       +
       def save_video(frames, file, **kwargs):

     

       31
       31
       +
           '''

     

       32
       32
       +
           Save a series of drawings as a GIF or video.

     

       33
       33
       +
       

     

       34
       34
       +
           Arguments:

     

       35
       35
       +
               frames: A list of `Drawing`s or a list of `numpy.array`s.

     

       36
       36
       +
               file: File name or file like object to write the video to.  The

     

       37
       37
       +
                   extension determines the output format.

     

       38
       38
       +
               align_bottom: If frames are different sizes, align the bottoms of each

     

       39
       39
       +
                   frame in the video.

     

       40
       40
       +
               align_right: If frames are different sizes, align the right edge of each

     

       41
       41
       +
                   frame in the video.

     

       42
       42
       +
               bg: If frames are different sizes, fill the background with this color.

     

       43
       43
       +
                   (default is white: (255, 255, 255, 255))

     

       44
       44
       +
               duration: If writing a GIF, sets the duration of each frame.

     

       45
       45
       +
               fps: If writing a video, sets the frame rate in FPS.

     

       46
       46
       +
               **kwargs: Other arguments to imageio.mimsave().

     

       47
       47
       +
       

     

       48
       48
       +
           '''

     

       49
       49
       +
           if isinstance(frames[0], Drawing):

     

       50
       50
       +
               frames = render_svg_frames(frames, **kwargs)

     

       51
       51
       +
           kwargs.pop('align_bottom', None)

     

       52
       52
       +
           kwargs.pop('align_right', None)

     

       53
       53
       +
           kwargs.pop('bg', None)

     

       54
       54
       +
           imageio.mimsave(file, frames, **kwargs)