diplotocus 0.5.0__tar.gz → 0.6.0__tar.gz

{diplotocus-0.5.0 → diplotocus-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diplotocus
-Version: 0.5.0
+Version: 0.6.0
 Summary: A python package to generate animations of matplotlib objects.
 Author-email: Tristan Boin <tristan.boin@obspm.fr>
 License-Expression: MIT

{diplotocus-0.5.0 → diplotocus-0.6.0}/docs/source/index.rst

@@ -45,7 +45,7 @@ Here's a quick example of the syntax of diplotocus:
    tl.animate(p)
 
    #We render our video
-   tl.save_video(path='../_static/demo.mp4')
+   tl.save_video(path='demo.mp4')
 
 .. raw:: html
 

{diplotocus-0.5.0 → diplotocus-0.6.0}/docs/source/notebooks/GUI.ipynb

@@ -11,6 +11,11 @@
     "\n",
     "![](../_static/Web_GUI.png)\n",
     "\n",
+    "```{warning}\n",
+    "\n",
+    "The GUI might not be as stable as the python interface. Feel free to report any issues you encounters.\n",
+    "```\n",
+    "\n",
     "When running diplotocus through this mode, you will make edit your animation through a local web page in your browser. This page communicates with a python server, which links the GUI and diplotocus objects in the background. Hence, everything you can do through python, you can do through the GUI, and vice versa.\n",
     "\n",
     "```{note}\n",

{diplotocus-0.5.0 → diplotocus-0.6.0}/docs/source/notebooks/animations.ipynb

@@ -817,6 +817,82 @@
     "tl.save_video('../_static/animations/axis_limits.mp4')"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "463d3df9",
+   "metadata": {},
+   "source": [
+    "### Axis pos and size\n",
+    "\n",
+    "```{eval-rst}\n",
+    ".. automethod:: diplotocus.animations.axis_pos_and_size\n",
+    "    :noindex:\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c01a5513",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0c53fc7065614884aba3cfb420806912",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/60 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Saved video ../_static/animations/axis_pos_and_size.mp4"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "                <video width=\"640\" height=\"360\" autoplay loop muted playsinline>\n",
+       "                <source src=\"../_static/animations/axis_pos_and_size.mp4?randId=4292\" type=\"video/mp4\">\n",
+       "                </video>\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import diplotocus as dpl\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig,ax = plt.subplots(1,2)\n",
+    "\n",
+    "tl = dpl.Timeline(fig=fig)\n",
+    "\n",
+    "a = dpl.axis_pos_and_size(start_width=0.0,end_width=0.4,duration=60,axis=ax[1])\n",
+    "\n",
+    "tl.animate(a)\n",
+    "tl.save_video('../_static/animations/axis_pos_and_size.mp4')"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "bc66aa88",

{diplotocus-0.5.0 → diplotocus-0.6.0}/docs/source/notebooks/plot_objects.ipynb

@@ -34,6 +34,7 @@
     "- `Rectangle()`\n",
     "- `RegularPolygon()`\n",
     "- `Wedge()`\n",
+    "- `bar()`\n",
     "\n",
     "Their signature are the same as the [matplotlib ones](https://matplotlib.org).\n",
     "\n",

diplotocus-0.6.0/src/diplotocus/_version.py

@@ -0,0 +1 @@
+__version__ = "0.6.0"

{diplotocus-0.5.0 → diplotocus-0.6.0}/src/diplotocus/animations.py

@@ -83,8 +83,6 @@ class plotObject:
         if self.mpl_obj_type is None:
             return None
         alias_map = self.mpl_obj_type._alias_map
-        if self.mpl_plot_type == plt.plot and False:
-            alias_map['color'] = ['c']
         return alias_map
 
     def get_possible_kwargs(self):
@@ -224,9 +222,13 @@ class plotObject:
             new_data_x = []
             new_data_y = []
             for i in range(len(data_x)):
-                new_data_x.append(data_x[i] + (anim['new_x'][i] - data_x[i])*t)
+                if anim['sequential']:
+                    _t = self.get_sequential_t(i,x,len(data_x),anim)
+                else:
+                    _t = t
+                new_data_x.append(data_x[i] + (anim['new_x'][i] - data_x[i])*_t)
                 if len(data_y) == len(anim['new_y']):
-                    new_data_y.append(data_y[i] + (anim['new_y'][i] - data_y[i])*t)
+                    new_data_y.append(data_y[i] + (anim['new_y'][i] - data_y[i])*_t)
             data_x = new_data_x
             data_y = new_data_y
 
@@ -234,26 +236,50 @@ class plotObject:
                 new_data_x_err = []
                 new_data_y_err = []
                 for i in range(len(kwargs['xerr'])):
-                    new_data_x_err.append(kwargs['xerr'][i] + (anim['new_x_err'][i] - kwargs['xerr'][i])*t)
-                    new_data_y_err.append(kwargs['yerr'][i] + (anim['new_y_err'][i] - kwargs['yerr'][i])*t)
+                    if anim['sequential']:
+                        _t = self.get_sequential_t(i,x,len(data_x),anim)
+                    else:
+                        _t = t
+                    new_data_x_err.append(kwargs['xerr'][i] + (anim['new_x_err'][i] - kwargs['xerr'][i])*_t)
+                    new_data_y_err.append(kwargs['yerr'][i] + (anim['new_y_err'][i] - kwargs['yerr'][i])*_t)
                 kwargs['xerr'] = new_data_x_err
                 kwargs['xerr'] = new_data_y_err
             elif self.__class__.__name__ == 'fill_between':
                 new_y1 = []
                 new_y2 = []
                 for i in range(len(kwargs['y1'])):
-                    new_y1.append(kwargs['y1'][i] + (anim['new_y1'][i] - kwargs['y1'][i])*t)
-                    new_y2.append(kwargs['y2'][i] + (anim['new_y2'][i] - kwargs['y2'][i])*t)
+                    if anim['sequential']:
+                        _t = self.get_sequential_t(i,x,len(data_x),anim)
+                    else:
+                        _t = t
+                    new_y1.append(kwargs['y1'][i] + (anim['new_y1'][i] - kwargs['y1'][i])*_t)
+                    new_y2.append(kwargs['y2'][i] + (anim['new_y2'][i] - kwargs['y2'][i])*_t)
                 kwargs['y1'] = new_y1
                 kwargs['y2'] = new_y2
             elif self.__class__.__name__ == 'fill_betweenx':
                 new_x1 = []
                 new_x2 = []
                 for i in range(len(kwargs['x1'])):
-                    new_x1.append(kwargs['x1'][i] + (anim['new_x1'][i] - kwargs['x1'][i])*t)
-                    new_x2.append(kwargs['x2'][i] + (anim['new_x2'][i] - kwargs['x2'][i])*t)
+                    if anim['sequential']:
+                        _t = self.get_sequential_t(i,x,len(data_x),anim)
+                    else:
+                        _t = t
+                    new_x1.append(kwargs['x1'][i] + (anim['new_x1'][i] - kwargs['x1'][i])*_t)
+                    new_x2.append(kwargs['x2'][i] + (anim['new_x2'][i] - kwargs['x2'][i])*_t)
                 kwargs['x1'] = new_x1
                 kwargs['x2'] = new_x2
+            elif self.__class__.__name__ == 'bar':
+                new_width = []
+                new_bottom = []
+                for i in range(len(data_x)):
+                    if anim['sequential']:
+                        _t = self.get_sequential_t(i,x,len(data_x),anim)
+                    else:
+                        _t = t
+                    new_width.append(kwargs['width'][i] + (anim['new_width'][i] - kwargs['width'][i])*_t)
+                    new_bottom.append(kwargs['bottom'][i] + (anim['new_bottom'][i] - kwargs['bottom'][i])*_t)
+                kwargs['width'] = new_width
+                kwargs['bottom'] = new_bottom
 
         data_x = to_np_array(data_x)
         data_y = to_np_array(data_y)
@@ -261,6 +287,19 @@ class plotObject:
         if self.function is not None:
             self.function(data_x,data_y,x,kwargs)
 
+    def get_sequential_t(self,i,x,size,anim):
+        delay = anim['delay'] + i/size*anim['duration']*(1-anim['subduration'])
+        duration = anim['duration']*anim['subduration']
+        if x < delay:
+            return 0
+        if x > delay + duration:
+            return 1
+        return self.get_t_from_x({
+            'delay':delay,
+            'duration':duration,
+            'easing':anim['easing'],
+        },x)
+    
     def initialize(self,timeline):
         self.tl = timeline
         if self.axis is None:
@@ -327,7 +366,7 @@ class plotObject:
         self.compute_timings()
         return self
 
-    def tween(self,property,start,end,duration,delay=0,easing=None,persistent=True):
+    def tween(self,property,start,end,duration,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1):
         """Animate a change in a property of the plot object.
 
         Parameters
@@ -344,10 +383,16 @@ class plotObject:
             the number of frames after what the animation starts playing.
         easing : callable, optional
             the easing used for this animation. If None, a linear easing is applied.
+        persistent : bool, default=True
+            if True, the plot object will continue to be plotted after its last animation has played.
+        sequential : bool, default=False
+            if True, the morphing will happen gradually over the data length
+        subduration : float, default=0.1
+            if sequential=True, the fractional duration of animation of each data point, in units of total duration
         """
-        return self.tweens([property],[start],[end],duration,delay,easing,persistent=persistent)
+        return self.tweens([property],[start],[end],duration,delay,easing,persistent=persistent,sequential=sequential,subduration=subduration)
     
-    def tweens(self,properties,starts,ends,duration,delay=0,easing=None,persistent=True):
+    def tweens(self,properties,starts,ends,duration,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1):
         """Animate multiple properties at once.
 
         Parameters
@@ -364,6 +409,12 @@ class plotObject:
             the number of frames after what the animation starts playing.
         easing : callable, optional
             the easing used for this animation. If None, a linear easing is applied.
+        persistent : bool, default=True
+            if True, the plot object will continue to be plotted after its last animation has played.
+        sequential : bool, default=False
+            if True, the morphing will happen gradually over the data length
+        subduration : float, default=0.1
+            if sequential=True, the fractional duration of animation of each data point, in units of total duration
         """
         starts = [to_np_array(start) for start in starts]
         ends = [to_np_array(end) for end in ends]
@@ -380,6 +431,8 @@ class plotObject:
                 'start':start,
                 'end':end,
                 'persistent':persistent,
+                'sequential':sequential,
+                'subduration':subduration,
                 'played':False
             }
             self.anims.append(new_anim)
@@ -436,16 +489,24 @@ class plotObject:
                 continue
             if anim['name'] != 'tween':
                 continue
-            _x = min(x,anim['duration'] + anim['delay'])
-            t = self.get_t_from_x(anim,_x)
-            t = np.clip(t,0,1)
             start = to_np_array(anim['start'])
             end = to_np_array(anim['end'])
-            current = start + (end - start)*t
+
+            _x = min(x,anim['duration'] + anim['delay'])
+
+            if anim['sequential'] == False:
+                t = self.get_t_from_x(anim,_x)
+                t = np.clip(t,0,1)
+                current = start + (end - start)*t
+            else:
+                current = []
+                for i in range(len(self.x)):
+                    _t = self.get_sequential_t(i,_x,len(self.x),anim)
+                    current.append(start + (end - start)*_t)
             kwargs[anim['property']] = current
         return kwargs
 
-    def show(self,duration,delay=0,easing=None,persistent=True):
+    def show(self,duration,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1):
         """Fade in plot objects.
 
         This is a shorthand animation that fades in plot objects. It is equivalent to `tween('alpha',0,1)`.
@@ -460,10 +521,14 @@ class plotObject:
             the easing used for this animation. If None, a linear easing is applied.
         persistent : bool, default=True
             if True, the plot object will continue to be plotted after its last animation has played.
+        sequential : bool, default=False
+            if True, the morphing will happen gradually over the data length
+        subduration : float, default=0.1
+            if sequential=True, the fractional duration of animation of each data point, in units of total duration
         """
-        return self.tween('alpha',start=0,end=1,duration=duration,delay=delay,easing=easing,persistent=persistent)
+        return self.tween('alpha',start=0,end=1,duration=duration,delay=delay,easing=easing,persistent=persistent,sequential=sequential,subduration=subduration)
 
-    def hide(self,duration,delay=0,easing=None,persistent=True):
+    def hide(self,duration,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1):
         """Fade out plot objects.
 
         This is a shorthand animation that fades out plot objects. It is equivalent to `tween('alpha',1,0)`.
@@ -478,8 +543,12 @@ class plotObject:
             the easing used for this animation. If None, a linear easing is applied.
         persistent : bool, default=True
             if True, the plot object will continue to be plotted after its last animation has played.
+        sequential : bool, default=False
+            if True, the morphing will happen gradually over the data length
+        subduration : float, default=0.1
+            if sequential=True, the fractional duration of animation of each data point, in units of total duration
         """
-        return self.tween('alpha',start=1,end=0,duration=duration,delay=delay,easing=easing,persistent=persistent)
+        return self.tween('alpha',start=1,end=0,duration=duration,delay=delay,easing=easing,persistent=persistent,sequential=sequential,subduration=subduration)
     
     def draw(self,duration,reverse=False,sort=None,delay=0,easing=None,persistent=True):
         """Animate the plot object by sequentially adding more points of the dataset.
@@ -705,7 +774,7 @@ class plotObject:
             else:
                 o.set_transform(self.T + self.axis.transData)
     
-    def morph(self,new_x,new_y,duration,delay=0,easing=None,persistent=True):
+    def morph(self,new_x,new_y,duration,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1):
         """Morph between the base dataset and a new dataset.
 
         Parameters
@@ -722,6 +791,10 @@ class plotObject:
             the easing used for this animation. If None, a linear easing is applied.
         persistent : bool, default=True
             if True, the plot object will continue to be plotted after its last animation has played.
+        sequential : bool, default=False
+            if True, the morphing will happen gradually over the data length
+        subduration : float, default=0.1
+            if sequential=True, the fractional duration of animation of each data point, in units of total duration
 
         For plot objects that take 1D datasets (e.g. hist()), `morph()` only accepts `new_x`.
         """
@@ -740,6 +813,8 @@ class plotObject:
             'new_x':new_x,
             'new_y':new_y,
             'persistent':persistent,
+            'sequential':sequential,
+            'subduration':subduration,
             'played':False
         })
         self.compute_timings()
@@ -775,7 +850,9 @@ class plotObject:
     def clean(self,x,clear_anims=True):
         if self.obj is not None and self.base_color is None:
             if isinstance(self.obj,(list,np.ndarray)):
-                self.base_color = self.obj[0].get_color()    
+                self.base_color = self.obj[0].get_color()
+            elif isinstance(self.obj,mpl.container.BarContainer):
+                self.base_color = self.obj[0].get_fc()
             elif hasattr(self.obj,'get_color'):
                 self.base_color = self.obj.get_color()
             if 'color' not in self.kwargs and 'c' not in self.kwargs and self.base_color is not None:
@@ -789,7 +866,8 @@ class plotObject:
                 self.x = anim['new_x']
                 self.y = anim['new_y']
 
-        if x >= self.x_min-1 and x < self.x_max-1 and self.obj is not None:
+        #if x >= self.x_min-1 and x < self.x_max-1 and self.obj is not None:
+        if self.obj is not None:
             if isinstance(self.obj,list):
                 for obj in self.obj:
                     try:
@@ -1005,6 +1083,94 @@ class axis_limits(plotObject):
             ylim_top    = anim['start_ylim'][1] + (anim['ylim'][1] - anim['start_ylim'][1])*t
             self.axis.set_ylim(ylim_bottom,ylim_top)
 
+class axis_pos_and_size(plotObject):
+    """
+    Resize the axis to a given position and size.
+
+    Parameters
+    ----------
+    end_left : float
+        Target left position
+    end_bottom : float
+        Target bottom position
+    end_width : float
+        Target width
+    end_height : float
+        Target height
+    start_left = float
+        Initial left position
+    start_bottom : float
+        Initial bottom position
+    start_width : float
+        Initial width
+    start_height : float
+        Initial height
+    pos : array-like
+        Target left and bottom position
+    size : array-like
+        Target width and height
+    duration : float
+        Duration of the animation
+    delay : float, default=0
+        Delay before starting
+    easing : callable, optional
+        Easing function
+    axis : matplotlib.axes.Axes, optional
+        Axis to plot on
+    """
+    def __init__(self,duration,
+                 end_left=None,end_bottom=None,end_width=None,end_height=None,
+                 start_left=None,start_bottom=None,start_width=None,start_height=None,
+                 delay=0,easing=None,axis=None,*args,**kwargs):
+        super().__init__(axis=axis,*args, **kwargs)
+        self.anims = [{
+            'name':'axis_move',
+            'duration':duration,
+            'delay':delay,
+            'easing':easing,
+            'persistent':True,
+            'start':[start_left,start_bottom,start_width,start_height],
+            'end':[end_left,end_bottom,end_width,end_height],
+            'played':False
+        }]
+        self.compute_timings()
+
+    def init(self):
+        left_i = self.axis.get_position().x0
+        bottom_i = self.axis.get_position().y0
+        width_i = self.axis.get_position().width
+        height_i = self.axis.get_position().height
+        if self.anims[0]['start'][0] is None:
+            self.anims[0]['start'][0] = left_i
+        if self.anims[0]['start'][1] is None:
+            self.anims[0]['start'][1] = bottom_i
+        if self.anims[0]['start'][2] is None:
+            self.anims[0]['start'][2] = width_i
+        if self.anims[0]['start'][3] is None:
+            self.anims[0]['start'][3] = height_i
+        if self.anims[0]['end'][0] is None:
+            self.anims[0]['end'][0] = left_i
+        if self.anims[0]['end'][1] is None:
+            self.anims[0]['end'][1] = bottom_i
+        if self.anims[0]['end'][2] is None:
+            self.anims[0]['end'][2] = width_i
+        if self.anims[0]['end'][3] is None:
+            self.anims[0]['end'][3] = height_i
+
+    def function(self,data_x,data_y,x,kwargs):
+        anim = self.anims[0]
+        if x < anim['delay']:
+            return
+        _x = min(x,anim['duration'] + anim['delay']-1)
+        t = self.get_t_from_x(anim,x)
+        width  = self.axis.get_xlim()[1]-self.axis.get_xlim()[0]
+        height = self.axis.get_ylim()[1]-self.axis.get_ylim()[0]
+        pos_x = anim['start'][0] + (anim['end'][0] - anim['start'][0])*t
+        pos_y = anim['start'][1] + (anim['end'][1] - anim['start'][1])*t
+        width = anim['start'][2] + (anim['end'][2] - anim['start'][2])*t
+        height = anim['start'][3] + (anim['end'][3] - anim['start'][3])*t
+        self.axis.set_position((pos_x,pos_y,width,height))
+
 class axis_move(plotObject):
     """
     Move the center of the axis to a given position.
@@ -2113,6 +2279,7 @@ class fill_between(plotObject):
         self.mpl_plot_type = plt.fill_between
         y1 = to_np_array(y1).reshape(-1)
         y2 = to_np_array(y2).reshape(-1)
+        x = to_np_array(x)
         if y1.size != x.size:
             y1 = np.ones_like(x)*y1[0]
         if y2.size != x.size:
@@ -2130,7 +2297,7 @@ class fill_between(plotObject):
                 self.kwargs['facecolor'] = self.base_color
         super().clean(x,clear_anims)
 
-    def morph(self,new_x,duration,new_y1=None,new_y2=None,delay=0,easing=None,persistent=True):
+    def morph(self,new_x,duration,new_y1=None,new_y2=None,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1):
         if new_y1 is None:
             new_y1 = self.y1
         if new_y2 is None:
@@ -2150,6 +2317,8 @@ class fill_between(plotObject):
             'new_y1':new_y1,
             'new_y2':new_y2,
             'persistent':persistent,
+            'sequential':sequential,
+            'subduration':subduration,
             'played':False
         })
         self.compute_timings()
@@ -2308,6 +2477,7 @@ class fill_betweenx(plotObject):
         self.mpl_plot_type = plt.fill_betweenx
         x1 = to_np_array(x1).reshape(-1)
         x2 = to_np_array(x2).reshape(-1)
+        y = to_np_array(y)
         if x1.size != y.size:
             x1 = np.ones_like(y)*x1[0]
         if x2.size != y.size:
@@ -2325,7 +2495,7 @@ class fill_betweenx(plotObject):
                 self.kwargs['facecolor'] = self.base_color
         super().clean(x,clear_anims)
     
-    def morph(self,new_y,duration,new_x1=None,new_x2=None,delay=0,easing=None,persistent=True):
+    def morph(self,new_y,duration,new_x1=None,new_x2=None,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1):
         if new_x1 is None:
             new_x1 = self.x1
         if new_x2 is None:
@@ -2345,6 +2515,8 @@ class fill_betweenx(plotObject):
             'new_x1':new_x1,
             'new_x2':new_x2,
             'persistent':persistent,
+            'sequential':sequential,
+            'subduration':subduration,
             'played':False
         })
         self.compute_timings()
@@ -2778,7 +2950,7 @@ class errorbar(plotObject):
         self.xerr = xerr
         self.yerr = yerr
 
-    def morph(self,new_x,new_y,duration,new_xerr=None,new_yerr=None,delay=0,easing=None,persistent=True):
+    def morph(self,new_x,new_y,duration,new_xerr=None,new_yerr=None,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1):
         if new_xerr is None:
             new_xerr = self.xerr
         if new_yerr is None:
@@ -2799,6 +2971,8 @@ class errorbar(plotObject):
             'new_x_err':new_xerr,
             'new_y_err':new_yerr,
             'persistent':persistent,
+            'sequential':sequential,
+            'subduration':subduration,
             'played':False
         })
         self.compute_timings()
@@ -3035,7 +3209,7 @@ class hist(plotObject):
                 self.kwargs['color'] = self.base_color
         super().clean(x,clear_anims)
     
-    def morph(self,new_x,duration,delay=0,easing=None,persistent=True,**kwargs):
+    def morph(self,new_x,duration,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1,**kwargs):
         if isinstance(new_x,numbers.Number):
             new_x = [new_x]
         
@@ -3047,6 +3221,8 @@ class hist(plotObject):
             'new_x':new_x,
             'new_y':np.zeros_like(self.y),
             'persistent':persistent,
+            'sequential':sequential,
+            'subduration':subduration,
             'played':False
         })
         self.compute_timings()
@@ -3530,7 +3706,7 @@ class contourf(plotObject):
         self._y = np.array(self._y)
         self.init_shape = z.shape
 
-    def morph(self,new_z,duration,delay=0,easing=None,persistent=True,**kwargs):
+    def morph(self,new_z,duration,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1,**kwargs):
         self.anims.append({
             'name':'morph',
             'duration':duration,
@@ -3539,6 +3715,8 @@ class contourf(plotObject):
             'new_x':np.ravel(new_z),
             'new_y':np.ravel(new_z),
             'persistent':persistent,
+            'sequential':sequential,
+            'subduration':subduration,
             'played':False
         })
         self.compute_timings()
@@ -4390,4 +4568,194 @@ class Wedge(plotObject):
             kwargs['theta2'] = kwargs['theta2'][0]
 
         self.obj = mpl.patches.Wedge(**kwargs)
-        self.axis.add_patch(self.obj)
+        self.axis.add_patch(self.obj)
+
+class bar(plotObject):
+    """
+    Make a bar plot.
+
+    The bars are positioned at *x* with the given *align*ment. Their
+    dimensions are given by *height* and *width*. The vertical baseline
+    is *bottom* (default 0).
+
+    Many parameters can take either a single value applying to all bars
+    or a sequence of values, one for each bar.
+
+    Parameters
+    ----------
+    x : float or array-like
+        The x coordinates of the bars. See also *align* for the
+        alignment of the bars to the coordinates.
+
+        Bars are often used for categorical data, i.e. string labels below
+        the bars. You can provide a list of strings directly to *x*.
+        ``bar(['A', 'B', 'C'], [1, 2, 3])`` is often a shorter and more
+        convenient notation compared to
+        ``bar(range(3), [1, 2, 3], tick_label=['A', 'B', 'C'])``. They are
+        equivalent as long as the names are unique. The explicit *tick_label*
+        notation draws the names in the sequence given. However, when having
+        duplicate values in categorical *x* data, these values map to the same
+        numerical x coordinate, and hence the corresponding bars are drawn on
+        top of each other.
+
+    height : float or array-like
+        The height(s) of the bars.
+
+        Note that if *bottom* has units (e.g. datetime), *height* should be in
+        units that are a difference from the value of *bottom* (e.g. timedelta).
+
+    width : float or array-like, default: 0.8
+        The width(s) of the bars.
+
+        Note that if *x* has units (e.g. datetime), then *width* should be in
+        units that are a difference (e.g. timedelta) around the *x* values.
+
+    bottom : float or array-like, default: 0
+        The y coordinate(s) of the bottom side(s) of the bars.
+
+        Note that if *bottom* has units, then the y-axis will get a Locator and
+        Formatter appropriate for the units (e.g. dates, or categorical).
+
+    align : {'center', 'edge'}, default: 'center'
+        Alignment of the bars to the *x* coordinates:
+
+        - 'center': Center the base on the *x* positions.
+        - 'edge': Align the left edges of the bars with the *x* positions.
+
+        To align the bars on the right edge pass a negative *width* and
+        ``align='edge'``.
+
+    Returns
+    -------
+    `.BarContainer`
+        Container with all the bars and optionally errorbars.
+
+    Other Parameters
+    ----------------
+    color : :mpltype:`color` or list of :mpltype:`color`, optional
+        The colors of the bar faces. This is an alias for *facecolor*.
+        If both are given, *facecolor* takes precedence.
+
+    facecolor : :mpltype:`color` or list of :mpltype:`color`, optional
+        The colors of the bar faces.
+        If both *color* and *facecolor are given, *facecolor* takes precedence.
+
+    edgecolor : :mpltype:`color` or list of :mpltype:`color`, optional
+        The colors of the bar edges.
+
+    linewidth : float or array-like, optional
+        Width of the bar edge(s). If 0, don't draw edges.
+
+    tick_label : str or list of str, optional
+        The tick labels of the bars.
+        Default: None (Use default numeric labels.)
+
+    label : str or list of str, optional
+        A single label is attached to the resulting `.BarContainer` as a
+        label for the whole dataset.
+        If a list is provided, it must be the same length as *x* and
+        labels the individual bars. Repeated labels are not de-duplicated
+        and will cause repeated label entries, so this is best used when
+        bars also differ in style (e.g., by passing a list to *color*.)
+
+    xerr, yerr : float or array-like of shape(N,) or shape(2, N), optional
+        If not *None*, add horizontal / vertical errorbars to the bar tips.
+        The values are +/- sizes relative to the data:
+
+        - scalar: symmetric +/- values for all bars
+        - shape(N,): symmetric +/- values for each bar
+        - shape(2, N): Separate - and + values for each bar. First row
+            contains the lower errors, the second row contains the upper
+            errors.
+        - *None*: No errorbar. (Default)
+
+        See :doc:`/gallery/statistics/errorbar_features` for an example on
+        the usage of *xerr* and *yerr*.
+
+    ecolor : :mpltype:`color` or list of :mpltype:`color`, default: 'black'
+        The line color of the errorbars.
+
+    capsize : float, default: :rc:`errorbar.capsize`
+        The length of the error bar caps in points.
+
+    error_kw : dict, optional
+        Dictionary of keyword arguments to be passed to the
+        `~.Axes.errorbar` method. Values of *ecolor* or *capsize* defined
+        here take precedence over the independent keyword arguments.
+
+    log : bool, default: False
+        If *True*, set the y-axis to be log scale.
+
+    data : indexable object, optional
+        DATA_PARAMETER_PLACEHOLDER
+
+    **kwargs : `.Rectangle` properties
+
+    %(Rectangle:kwdoc)s
+
+    See Also
+    --------
+    barh : Plot a horizontal bar plot.
+
+    Notes
+    -----
+    Stacked bars can be achieved by passing individual *bottom* values per
+    bar. See :doc:`/gallery/lines_bars_and_markers/bar_stacked`.
+    """
+    def __init__(self,x,height,width=0.8,bottom=0,easing=None,axis=None, *args, **kwargs):
+        #self.mpl_obj_type = mpl.container.BarContainer
+        self.mpl_obj_type = mpl.patches.Rectangle
+        self.mpl_plot_type = plt.bar
+        if np.ravel(width).size == 1:
+            width = np.ones_like(x)*width
+        if np.ravel(height).size == 1:
+            height = np.ones_like(x)*height
+        if np.ravel(bottom).size == 1:
+            bottom = np.ones_like(x)*bottom
+        kwargs['width'] = width
+        kwargs['bottom'] = bottom
+        super().__init__(easing=easing,axis=axis,*args, **kwargs)
+        self.x = x
+        self.y = height
+
+    def morph(self,new_x,new_height,duration,new_width=None,new_bottom=None,delay=0,easing=None,persistent=True,sequential=False,subduration=0.1):
+        if new_width is None:
+            new_width = self.kwargs['width']
+        elif np.ravel(new_width).size == 1:
+            new_width = np.ones_like(new_x)*new_width
+        if new_bottom is None:
+            new_bottom = self.kwargs['bottom']
+        elif np.ravel(new_bottom).size == 1:
+            new_bottom = np.ones_like(new_x)*new_bottom
+        if isinstance(new_x,numbers.Number):
+            new_x = [new_x]
+            new_height = [new_height]
+            new_width = [new_width]
+            new_bottom = [new_bottom]
+        
+        self.anims.append({
+            'name':'morph',
+            'duration':duration,
+            'delay':delay,
+            'easing':easing,
+            'new_x':new_x,
+            'new_y':new_height,
+            'new_width':new_width,
+            'new_bottom':new_bottom,
+            'persistent':persistent,
+            'sequential':sequential,
+            'subduration':subduration,
+            'played':False
+        })
+        self.compute_timings()
+        return self
+    
+    def function(self,data_x,data_y,x,kwargs):
+        #This is a hack because when plotting a bar with empty data, no children are stored
+        #but the color cycler still triggers, so a color is assigned by we can't know what
+        #it is. So instead we plot a single bar with height 0 and get its color.
+        if len(data_x) == 0:
+            data_x = [0]
+            data_y = [0]
+        obj = self.axis.bar(data_x,data_y,**kwargs)
+        self.obj = obj

{diplotocus-0.5.0 → diplotocus-0.6.0}/src/diplotocus/core.py

@@ -385,15 +385,17 @@ class Timeline:
                 f.write(self.timeline_str)
         sequence_fn = self.name + '/' + self.name  + '.txt'
 
+        ffmpeg_flags = '-hide_banner -loglevel error -vf "pad=ceil(iw/2)*2:ceil(ih/2)*2"'
+
         if '.mov' in video_fn:
             if multialpha:
-                command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -vf premultiply=inplace=1 -c:v prores_ks -profile:v 4 -pix_fmt yuva444p10le -hide_banner -loglevel error {}'.format(sequence_fn,video_fn)
+                command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -vf premultiply=inplace=1 -c:v prores_ks -profile:v 4 -pix_fmt yuva444p10le {} {}'.format(sequence_fn,ffmpeg_flags,video_fn)
             else:
-                command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -c:v prores -pix_fmt yuva444p10le -hide_banner -loglevel error {}'.format(sequence_fn,video_fn)
+                command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -c:v prores -pix_fmt yuva444p10le {} {}'.format(sequence_fn,ffmpeg_flags,video_fn)
         elif is_gif:
-            command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -lavfi "split[s0][s1];[s0]palettegen=reserve_transparent=1:stats_mode=diff[p];[s1][p]paletteuse=dither=sierra2_4a:alpha_threshold=128" -gifflags -offsetting -loop 0 -hide_banner -loglevel error {}'.format(sequence_fn,video_fn)
+            command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -lavfi "split[s0][s1];[s0]palettegen=reserve_transparent=1:stats_mode=diff[p];[s1][p]paletteuse=dither=sierra2_4a:alpha_threshold=128" -gifflags -offsetting -loop 0 {}'.format(sequence_fn,ffmpeg_flags,video_fn)
         else:
-            command = ffmpeg_path + ' -f concat -safe 0 -i {} -c:v libx264 -pix_fmt yuv420p -c:a aac -movflags +faststart -hide_banner -loglevel error -y {}'.format(sequence_fn,video_fn)
+            command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -c:v libx264 -pix_fmt yuv420p -c:a aac -movflags +faststart {} {}'.format(sequence_fn,ffmpeg_flags,video_fn)
         subprocess.run(shlex.split(command))
         if clean:
             shutil.rmtree(self.name)

{diplotocus-0.5.0 → diplotocus-0.6.0}/src/diplotocus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diplotocus
-Version: 0.5.0
+Version: 0.6.0
 Summary: A python package to generate animations of matplotlib objects.
 Author-email: Tristan Boin <tristan.boin@obspm.fr>
 License-Expression: MIT

diplotocus-0.5.0/src/diplotocus/_version.py

@@ -1 +0,0 @@
-__version__ = "0.5.0"