wolfhece 2.1.108__py3-none-any.whl → 2.1.110__py3-none-any.whl

wolfhece/matplotlib_fig.py

@@ -2,6 +2,7 @@ from matplotlib.backends.backend_wx import NavigationToolbar2Wx as NavigationToo
 from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
 from typing import Literal
 from matplotlib.figure import Figure
+from matplotlib.axes import Axes
 import matplotlib.pyplot as plt
 from matplotlib.gridspec import GridSpec
 import numpy as np
@@ -11,6 +12,8 @@ from wolfhece.PyParams import Wolf_Param, new_json
 from wolfhece.PyTranslate import _
 from wolfhece.PyVertex import getRGBfromI
 
+from PIL import Image, ImageOps
+
 
 import wx
 from matplotlib.backend_bases import KeyEvent, MouseEvent
@@ -55,7 +58,7 @@ def sanitize_fmt(fmt):
 
 class Matplotlib_ax_properties():
 
-    def __init__(self, ax =None) -> None:
+    def __init__(self, ax:Axes =None) -> None:
 
         self._ax = ax
         self._myprops = None
@@ -64,29 +67,55 @@ class Matplotlib_ax_properties():
         self._tmp_line_prop:Matplolib_line_properties = None
         self._selected_line = -1
 
-        self.title = 'Figure'
-        self.xtitle = 'X [m]'
-        self.ytitle = 'Y [m]'
-        self.legend = False
-        self.xmin = 0.
-        self.xmax = 1.
-        self.ymin = 0.
-        self.ymax = 1.
-        self.gridx_major = False
-        self.gridy_major = False
-        self.gridx_minor = False
-        self.gridy_minor = False
-
-        self._equal_axis = 0
-        self.scaling_factor = 1.
-
-        self.ticks_x = 1.
-        self.ticks_y = 1.
-        self.ticks_label_x = 1.
-        self.ticks_label_y = 1.
-
-        self.format_x = '.2f'
-        self.format_y = '.2f'
+        if ax is None:
+            self.title = 'Figure'
+            self.xtitle = 'X [m]'
+            self.ytitle = 'Y [m]'
+            self.legend = False
+            self.xmin = -99999
+            self.xmax = -99999
+            self.ymin = -99999
+            self.ymax = -99999
+            self.gridx_major = False
+            self.gridy_major = False
+            self.gridx_minor = False
+            self.gridy_minor = False
+
+            self._equal_axis = 0
+            self.scaling_factor = 1.
+
+            self.ticks_x = 1.
+            self.ticks_y = 1.
+            self.ticks_label_x = 1.
+            self.ticks_label_y = 1.
+
+            self.format_x = '.2f'
+            self.format_y = '.2f'
+        else:
+            self.title = ax.get_title()
+            self.xtitle = ax.get_xlabel()
+            self.ytitle = ax.get_ylabel()
+            self.legend = ax.get_legend() is not None
+            self.xmin = -99999
+            self.xmax = -99999
+            self.ymin = -99999
+            self.ymax = -99999
+            self.gridx_major = False
+            self.gridy_major = False
+            self.gridx_minor = False
+            self.gridy_minor = False
+
+            aspect = ax.get_aspect()
+            self._equal_axis = 0 if aspect == 'auto' else 1 if aspect == 1. else 2
+            self.scaling_factor = aspect
+
+            self.ticks_x = ax.get_xticks()
+            self.ticks_y = ax.get_yticks
+            self.ticks_label_x = ax.get_xticklabels()
+            self.ticks_label_y = ax.get_yticklabels()
+
+            self.format_x = '.2f'
+            self.format_y = '.2f'
 
         self._set_props()
 
@@ -234,9 +263,10 @@ class Matplotlib_ax_properties():
             return
 
         lines = self._ax.get_lines()
+        img   = self._ax.get_images()
 
-        if len(lines) == 0:
-            logging.warning('No lines found')
+        if len(lines) == 0 and len(img) == 0:
+            logging.warning('No lines/image found')
             return
 
         xmin = np.inf
@@ -253,6 +283,13 @@ class Matplotlib_ax_properties():
             ymin = min(ymin, np.min(y))
             ymax = max(ymax, np.max(y))
 
+        for im in img:
+            x = im.get_extent()
+            xmin = min(xmin, x[0])
+            xmax = max(xmax, x[1])
+            ymin = min(ymin, x[2])
+            ymax = max(ymax, x[3])
+
         return xmin, xmax, ymin, ymax
 
     def fill_property(self, verbosity= True):
@@ -346,8 +383,10 @@ class Matplotlib_ax_properties():
         ax.xaxis.grid(self.gridx_major)
         ax.yaxis.grid(self.gridy_major)
 
-        ax.set_xticks(self.ticks_x, self.ticks_label_x)
-        ax.set_yticks(self.ticks_y, self.ticks_label_y)
+        if len(self.ticks_x) <= 100:
+            ax.set_xticks(self.ticks_x, self.ticks_label_x)
+        if len(self.ticks_y) <= 100:
+           ax.set_yticks(self.ticks_y, self.ticks_label_y)
 
         if self.legend:
             update = any(line.update_legend for line in self._lines)
@@ -612,11 +651,62 @@ class Matplolib_line_properties():
 
         self.update_legend = False
 
+        self._scales = [1.0, 1.0]
+        self._origin_world = [0.0, 0.0]
+        self._origin_local = [0.0, 0.0]
+
         self._set_props()
 
         if self._line is not None:
             self.get_properties()
 
+    def get_xydata(self, two_columns:bool = False):
+        """ Get the xy data """
+
+        if self._line is None:
+            return None
+
+        if two_columns:
+            return (self._line.get_xdata() - self._origin_local[0]) * self._scales[0] + self._origin_world[0], \
+                   (self._line.get_ydata() - self._origin_local[1]) * self._scales[1] + self._origin_world[1]
+        else:
+            return np.array([(self._line.get_xdata() - self._origin_local[0]) * self._scales[0] + self._origin_world[0],
+                             (self._line.get_ydata() - self._origin_local[1]) * self._scales[1] + self._origin_world[1]]).T
+
+    def set_xydata(self, xy_data:np.ndarray):
+        """ Set the xy data """
+
+        if self._line is None:
+            return
+
+        self._line.set_xdata((xy_data[:,0] - self._origin_world[0]) / self._scales[0] + self._origin_local[0])
+        self._line.set_ydata((xy_data[:,1] - self._origin_world[1]) / self._scales[1] + self._origin_local[1])
+
+    @property
+    def xdata(self):
+        return self.get_xydata(two_columns= True)[0]
+
+    @property
+    def ydata(self):
+        return self.get_xydata(two_columns= True)[1]
+
+    @property
+    def xydata(self):
+        return self.get_xydata()
+
+    @xydata.setter
+    def xydata(self, value):
+
+        if not isinstance(value, np.ndarray):
+            logging.warning('xydata must be a numpy array')
+            return
+
+        if value.shape[1] != 2:
+            logging.warning('xydata must have 2 columns')
+            return
+
+        self.set_xydata(value)
+
     @property
     def ax_props(self):
         return self._ax_props
@@ -821,6 +911,14 @@ class Matplolib_line_properties():
         self._myprops.addparam('Picker', 'Picker', self.picker, 'Logical', 'Picker')
         self._myprops.addparam('Picker', 'Picker radius', self.picker_radius, 'Float', 'Picker radius')
 
+        self._myprops.addparam('Scales', 'X scale', self._scales[0], 'Float', 'X scale')
+        self._myprops.addparam('Scales', 'Y scale', self._scales[1], 'Float', 'Y scale')
+
+        self._myprops.addparam('Origin', 'X world', self._origin_world[0], 'Float', 'X origin into world')
+        self._myprops.addparam('Origin', 'Y world', self._origin_world[1], 'Float', 'Y origin into world')
+        self._myprops.addparam('Origin', 'X local', self._origin_local[0], 'Float', 'X origin into local references')
+        self._myprops.addparam('Origin', 'Y local', self._origin_local[1], 'Float', 'Y origin into local references')
+
         self._myprops.Populate()
         # self._myprops.Layout()
         # self._myprops.SetSizeHints(500,500)
@@ -848,6 +946,14 @@ class Matplolib_line_properties():
         self._myprops[('Picker', 'Picker')] = self.picker
         self._myprops[('Picker', 'Picker radius')] = self.picker_radius
 
+        self._myprops[('Scales', 'X scale')] = self._scales[0]
+        self._myprops[('Scales', 'Y scale')] = self._scales[1]
+
+        self._myprops[('Origin', 'X world')] = self._origin_world[0]
+        self._myprops[('Origin', 'Y world')] = self._origin_world[1]
+        self._myprops[('Origin', 'X local')] = self._origin_local[0]
+        self._myprops[('Origin', 'Y local')] = self._origin_local[1]
+
         self._myprops.Populate()
 
     def ui(self):
@@ -902,6 +1008,15 @@ class Matplolib_line_properties():
         self.picker = self._myprops[('Picker', 'Picker')]
         self.picker_radius = self._myprops[('Picker', 'Picker radius')]
 
+        self._scales[0] = self._myprops[('Scales', 'X scale')]
+        self._scales[1] = self._myprops[('Scales', 'Y scale')]
+
+        self._origin_world[0] = self._myprops[('Origin', 'X world')]
+        self._origin_world[1] = self._myprops[('Origin', 'Y world')]
+
+        self._origin_local[0] = self._myprops[('Origin', 'X local')]
+        self._origin_local[1] = self._myprops[('Origin', 'Y local')]
+
         self.set_properties()
 
     def set_properties(self, line:Line2D = None):
@@ -946,13 +1061,19 @@ class Matplolib_line_properties():
     def show_properties(self):
         self.ui()
 
+    @property
+    def has_world_transfer(self):
+        return self._scales[0] != 1.0 or self._scales[1] != 1.0 or self._origin_world[0] != 0. or self._origin_world[1] != 0. or self._origin_local[0] != 0. or self._origin_local[1] != 0.
+
     def to_dict(self) -> str:
         """ properties to dict """
 
-        xdata = self._line.get_xdata().tolist()
-        ydata = self._line.get_ydata().tolist()
+        # We need to store the local data
+        xy = self._line.get_xydata()
+        xdata = xy[:,0].tolist()
+        ydata = xy[:,1].tolist()
 
-        return {'color':self.color,
+        locdict = {'color':self.color,
                 'linewidth':self.linewidth,
                 'linestyle':self.linestyle,
                 'marker':self.marker,
@@ -967,12 +1088,31 @@ class Matplolib_line_properties():
                 'picker':self.picker,
                 'picker_radius':self.picker_radius,
                 'xdata':xdata,
-                'ydata':ydata}
+                'ydata':ydata,
+                'xscale':self._scales[0],
+                'yscale':self._scales[1],
+                'xorigin_world':self._origin_world[0],
+                'yorigin_world':self._origin_world[1],
+                'xorigin_local':self._origin_local[0],
+                'yorigin_local':self._origin_local[1]}
+
+        if self.has_world_transfer:
+            world_xdata, world_ydata = self.get_xydata(two_columns = True)
+            world_xdata = world_xdata.tolist()
+            world_ydata = world_ydata.tolist()
+
+            locdict['world_xdata'] = world_xdata
+            locdict['world_ydata'] = world_ydata
+
+        return locdict
 
     def from_dict(self, props:dict):
         """ properties from dict """
 
-        keys = ['color', 'linewidth', 'linestyle', 'marker', 'markersize', 'alpha', 'label', 'markerfacecolor', 'markeredgecolor', 'markeredgewidth', 'visible', 'zorder', 'picker', 'picker_radius']
+        keys = ['color', 'linewidth', 'linestyle', 'marker', 'markersize', 'alpha',
+                'label', 'markerfacecolor', 'markeredgecolor', 'markeredgewidth',
+                'visible', 'zorder', 'picker', 'picker_radius',
+                'xscale', 'yscale', 'xorigin_world', 'yorigin_world', 'xorigin_local', 'yorigin_local']
 
         for key in keys:
             try:
@@ -981,11 +1121,63 @@ class Matplolib_line_properties():
                 logging.warning('Key not found in properties dict')
                 pass
 
+        # ATTENTION : The next 2 lines are done in the to_dict method of the axes
+        # xydata = np.array([props['xdata'], props['ydata']]).T
+        # self.set_xydata(xydata)
+
         self.populate()
         self.set_properties()
 
         return self
 
+    @property
+    def xscale(self):
+        return self._scales[0]
+
+    @xscale.setter
+    def xscale(self, value):
+        self._scales[0] = value
+
+    @property
+    def yscale(self):
+        return self._scales[1]
+
+    @yscale.setter
+    def yscale(self, value):
+        self._scales[1] = value
+
+    @property
+    def xorigin_world(self):
+        return self._origin_world[0]
+
+    @xorigin_world.setter
+    def xorigin_world(self, value):
+        self._origin_world[0] = value
+
+    @property
+    def yorigin_world(self):
+        return self._origin_world[1]
+
+    @yorigin_world.setter
+    def yorigin_world(self, value):
+        self._origin_world[1] = value
+
+    @property
+    def xorigin_local(self):
+        return self._origin_local[0]
+
+    @xorigin_local.setter
+    def xorigin_local(self, value):
+        self._origin_local[0] = value
+
+    @property
+    def yorigin_local(self):
+        return self._origin_local[1]
+
+    @yorigin_local.setter
+    def yorigin_local(self, value):
+        self._origin_local[1] = value
+
     def add_props_to_sizer(self, frame:wx.Frame, sizer:wx.BoxSizer):
         """ Add the properties to a sizer """
 
@@ -1013,8 +1205,9 @@ class Matplolib_line_properties():
         self._line = None
 
 class PRESET_LAYOUTS(Enum):
-    DEFAULT = (1,1)
-    MAT2X2  = (2,2)
+    DEFAULT = (1,1, 'auto')
+    MAT2X2  = (2,2, 'auto')
+    DEFAULT_EQUAL = (1,1, 'equal')
 class Matplotlib_Figure(wx.Frame):
     """  Matplotlib Figure with wx Frame """
 
@@ -1043,7 +1236,8 @@ class Matplotlib_Figure(wx.Frame):
 
         self.wx_exists = wx.App.Get() is not None
 
-        self.fig = plt.figure()
+        self.fig = Figure()
+        # self.fig.set_visible(False)
         dpi = self.fig.get_dpi()
         size_x, size_y = self.fig.get_size_inches()
 
@@ -1053,10 +1247,22 @@ class Matplotlib_Figure(wx.Frame):
         self.ax_dict:dict[str,Axes] = {}    # dict of axes
         self.ax:list[Axes] = []             # list of axes -- always flatten
         self.shown_props = None     # shown properties
+        self._shiftdown = False
+
+        self._action = None
+        self._keep_first_point = True
 
         self.apply_layout(layout)   # apply the layout
         pass
 
+    @property
+    def action(self):
+        return self._action
+
+    @action.setter
+    def action(self, value):
+        self._action = value
+
     def presets(self, which:PRESET_LAYOUTS = PRESET_LAYOUTS.DEFAULT):
         """ Presets """
 
@@ -1102,12 +1308,12 @@ class Matplotlib_Figure(wx.Frame):
                 # store the axes in a list -- So we can access them by index, not only by name
                 self.ax = [ax for ax in self.ax_dict.values()]
             else:
-                # Tuple or list of 2 elements - subplots
-                if len(layout) != 2:
-                    logging.warning('Layout must be a tuple or a list of 2 elements')
+                # Tuple or list of 3 elements - subplots
+                if len(layout) != 3:
+                    logging.warning('Layout must be a tuple or a list of 3 elements (nbrows:int, nbcols:int, aspect_ratio:str|float)')
                     return
 
-                self.nbrows, self.nbcols = layout
+                self.nbrows, self.nbcols, ratio = layout
                 if self.nbrows*self.nbcols == 1:
                     # Convert to list -- subplots returns a single Axes but we want a list
                     self.ax = [self.fig.subplots(self.nbrows, self.nbcols)]
@@ -1115,6 +1321,14 @@ class Matplotlib_Figure(wx.Frame):
                     # Flatten the axes -- sbplots returns a 2D array of Axes but we want a list
                     self.ax = self.fig.subplots(self.nbrows, self.nbcols).flatten()
 
+                for curax in self.ax:
+                    if ratio == 'auto':
+                        curax.set_aspect('auto')
+                    elif ratio == 'equal':
+                        curax.set_aspect('equal')
+                    else:
+                        curax.set_aspect(ratio)
+
                 # store the axes in a dict -- So we can access them by name, not only by index
                 self.ax_dict = {f'{i}':ax for i, ax in enumerate(self.ax)}
                 for key,ax in self.ax_dict.items():
@@ -1192,6 +1406,7 @@ class Matplotlib_Figure(wx.Frame):
         self._canvas.mpl_connect('motion_notify_event', self.UpdateStatusBar)
         self._canvas.mpl_connect('button_press_event', self.OnClickCanvas)
         self._canvas.mpl_connect('key_press_event', self.OnKeyCanvas)
+        self._canvas.mpl_connect('key_release_event', self.OnKeyRelease)
 
         # Toolbar - Matplotlib
         # --------------------
@@ -1280,6 +1495,9 @@ class Matplotlib_Figure(wx.Frame):
         self._add_row = wx.Button(win, -1, 'Add rows')
         self._add_row.Bind(wx.EVT_BUTTON, self.add_row_to_grid)
 
+        self._new_line = wx.Button(win, -1, 'New line')
+        self._new_line.Bind(wx.EVT_BUTTON, self.onnew_line)
+
         self._add_line = wx.Button(win, -1, 'Add line')
         self._add_line.Bind(wx.EVT_BUTTON, self.onadd_line)
 
@@ -1287,10 +1505,19 @@ class Matplotlib_Figure(wx.Frame):
         self._del_line.Bind(wx.EVT_BUTTON, self.ondel_line)
 
         self._sizer_xls.Add(self._xls, 1, wx.EXPAND)
-        self._sizer_xls.Add(self._update_xy, 0, wx.EXPAND)
-        self._sizer_xls.Add(self._add_row, 0, wx.EXPAND)
-        self._sizer_xls.Add(self._add_line, 0, wx.EXPAND)
-        self._sizer_xls.Add(self._del_line, 0, wx.EXPAND)
+
+        self._sizer_update_add = wx.BoxSizer(wx.HORIZONTAL)
+        self._sizer_add_remove = wx.BoxSizer(wx.HORIZONTAL)
+
+        self._sizer_xls.Add(self._sizer_update_add, 0, wx.EXPAND)
+        self._sizer_xls.Add(self._sizer_add_remove, 0, wx.EXPAND)
+
+        self._sizer_update_add.Add(self._update_xy, 1, wx.EXPAND)
+        self._sizer_update_add.Add(self._add_row, 1, wx.EXPAND)
+
+        self._sizer_add_remove.Add(self._new_line, 1, wx.EXPAND)
+        self._sizer_add_remove.Add(self._add_line, 1, wx.EXPAND)
+        self._sizer_add_remove.Add(self._del_line, 1, wx.EXPAND)
 
         # Properties sizer
         # ---------------
@@ -1396,7 +1623,11 @@ class Matplotlib_Figure(wx.Frame):
 
     @property
     def cur_line(self) -> Line2D:
-        return self.cur_ax.get_lines()[int(self._line_current.GetSelection())]
+
+        if self._line_current.GetSelection() == -1:
+            return None
+        else:
+            return self.cur_ax.get_lines()[int(self._line_current.GetSelection())]
 
     def get_figax(self):
 
@@ -1447,6 +1678,10 @@ class Matplotlib_Figure(wx.Frame):
     def show_curline_properties(self):
         # self.cur_line_properties.ui()
         self._hide_all_props()
+
+        if self._line_current.GetSelection() == -1:
+            return
+
         self.cur_line_properties.show_props()
         # self.Layout()
         self._sizer_grid_props.Layout()
@@ -1519,13 +1754,25 @@ class Matplotlib_Figure(wx.Frame):
 
         if event.key == 'escape':
             self._axes_properties[int(self._ax_current.GetSelection())].reset_selection()
+        elif event.key == 'shift':
+            self._shiftdown = True
+        elif event.key == 'enter':
+            if self.action is not None:
+                action, callback = self.action
+                if action == 'Digitize':
+                    callback((0,0), 'End Digitize')
+
+    def OnKeyRelease(self, event:KeyEvent):
+        if event.key == 'shift':
+            self._shiftdown = False
 
     def OnClickCanvas(self, event:MouseEvent):
 
         rclick = event.button == 3
         lclick = event.button == 1
+        middle = event.button == 2
 
-        if not rclick:
+        if not (rclick or middle):
             return
 
         if event.inaxes:
@@ -1533,21 +1780,81 @@ class Matplotlib_Figure(wx.Frame):
             idx= ax.get_figure().axes.index(event.inaxes)
             x, y = event.xdata, event.ydata
 
-            dist_min = 1e6
-            line_min = None
-
-            for line in ax.get_lines():
-                xy = line.get_xydata()
-                dist = np.linalg.norm(xy - np.array([x,y]), axis=1)
-                idx_min = np.argmin(dist)
-                if dist[idx_min] < dist_min:
-                    dist_min = dist[idx_min]
-                    line_min = line
-
-            self._ax_current.SetSelection(idx)
-            self._fill_lines_ax(idx = ax.get_lines().index(line_min))
-            self._axes_properties[idx].select_line(ax.get_lines().index(line_min))
-            self.fill_grid_with_xy(line_min)
+            if middle:
+                if self.action is not None:
+                    action, callback = self.action
+                    if action == 'Digitize':
+                        callback((0,0), 'End Digitize')
+
+            if rclick:
+
+                if self._shiftdown:
+                    # add a point to the current line, update the grid and plot
+                    xy = self.cur_line.get_xydata()
+
+                    if xy.shape[0] == 1:
+                        if self._keep_first_point:
+                            xy = np.vstack((xy, [x,y]))
+                        else:
+                            xy = np.asarray([[x,y]])
+                            self._keep_first_point = True
+                    else:
+                        xy = np.vstack((xy, [x,y]))
+
+                    self.cur_line.set_data(xy[:,0], xy[:,1])
+                    self.fill_grid_with_xy_np(self.cur_line_properties.get_xydata())
+                    self._canvas.draw()
+
+                if self.action is not None:
+
+                    action, callback = self.action
+
+                    if action == 'Digitize':
+                        if not self._shiftdown:
+                            logging.warning('Shift must be down to digitize')
+                    elif action == 'Ref X':
+                        if not self._shiftdown:
+                            logging.warning('Shift must be down to set X reference')
+                        else:
+                            callback((x,y), action)
+                    elif action == 'Ref Y':
+                        if not self._shiftdown:
+                            logging.warning('Shift must be down to set Y reference')
+                        else:
+                            callback((x,y), action)
+                    elif action == 'Origin':
+                        if not self._shiftdown:
+                            logging.warning('Shift must be down to set origin')
+                        else:
+                            callback((x,y), action)
+
+                elif not self._shiftdown:
+                    # Find the closest line and select it
+
+                    lines = ax.get_lines()
+                    if len(lines) == 0:
+                        logging.warning('No lines !')
+                        return
+
+                    dist_min = 1e6
+                    line_min = None
+
+                    for line in lines:
+                        xy = line.get_xydata()
+                        if xy.shape[0] == 0:
+                            continue
+
+                        dist = np.linalg.norm(xy - np.array([x,y]), axis=1)
+                        idx_min = np.argmin(dist)
+                        if dist[idx_min] < dist_min:
+                            dist_min = dist[idx_min]
+                            line_min = line
+
+                    self._ax_current.SetSelection(idx)
+                    self._fill_lines_ax(idx = lines.index(line_min))
+                    self._axes_properties[idx].select_line(lines.index(line_min))
+
+                    self.fill_grid_with_xy_np(self.cur_line_properties.get_xydata())
 
             self.show_curline_properties()
 
@@ -1572,6 +1879,27 @@ class Matplotlib_Figure(wx.Frame):
             grid.SetCellValue(i, colx, str(xy[i,0]))
             grid.SetCellValue(i, coly, str(xy[i,1]))
 
+    def fill_grid_with_xy_np(self, xy:np.ndarray, grid:CpGrid = None, colx:int= 0, coly:int= 1):
+
+        if grid is None:
+            grid = self._xls
+
+        grid.ClearGrid()
+
+        if grid.GetNumberRows() < len(xy):
+            grid.AppendRows(len(xy)-grid.GetNumberRows())
+        elif grid.GetNumberRows() > len(xy):
+            grid.DeleteRows(len(xy), grid.GetNumberRows()-len(xy))
+
+        for i in range(len(xy)):
+            grid.SetCellValue(i, colx, str(xy[i,0]))
+            grid.SetCellValue(i, coly, str(xy[i,1]))
+
+    def get_xy_from_grid(self):
+        """ Get the xy from the grid """
+
+        return self._get_xy_from_grid(self._xls)
+
     def update_line_from_grid(self, event):
 
         line = self.cur_line
@@ -1588,7 +1916,8 @@ class Matplotlib_Figure(wx.Frame):
             xy[i,0] = float(self._xls.GetCellValue(i, 0))
             xy[i,1] = float(self._xls.GetCellValue(i, 1))
 
-        line.set_data(xy[:,0], xy[:,1])
+        self.cur_line_properties.set_xydata(xy)
+        self._canvas.draw()
         self.update_layout()
 
     def add_row_to_grid(self, event):
@@ -1609,6 +1938,23 @@ class Matplotlib_Figure(wx.Frame):
         xy = self._get_xy_from_grid(self._xls)
         self.add_line(xy, self.cur_ax)
 
+    def onnew_line(self, event):
+        """ Add a plot to the current ax """
+        self.new_line()
+
+    def new_line(self, ax:Axes=None, **kwargs) -> Matplolib_line_properties:
+        """ Add a plot to the current ax """
+
+        curline = self.cur_line
+        if curline is not None:
+            xy = curline.get_xydata()
+            xy = np.asarray([[xy[0,0],xy[0,1]]])
+        else:
+            xy = np.asarray([[0,0]])
+
+        self._keep_first_point = False
+        return self.add_line(xy, ax, **kwargs)
+
     def _get_xy_from_grid(self, grid:CpGrid, colx:int= 0, coly:int= 1):
         """ Get the xy from a grid """
 
@@ -1627,7 +1973,7 @@ class Matplotlib_Figure(wx.Frame):
 
         return xy
 
-    def add_line(self, xy:np.ndarray, ax:Axes=None, **kwargs):
+    def add_line(self, xy:np.ndarray, ax:Axes=None, **kwargs) -> Matplolib_line_properties:
         """ Add a plot to the current ax """
 
         ax, idx_ax = self.get_ax_idx(ax)
@@ -1637,23 +1983,44 @@ class Matplotlib_Figure(wx.Frame):
         cur_ax_prop:Matplotlib_ax_properties = self._axes_properties[idx_ax]
         cur_ax_prop._lines.append(Matplolib_line_properties(ax.get_lines()[-1], cur_ax_prop))
         cur_ax_prop._lines[-1].add_props_to_sizer(self._collaps_pane.GetPane(), self._sizer_grid_props)
+
+        self._fill_lines_ax(len(ax.get_lines())-1)
+
         self.update_layout()
+        self._canvas.SetFocus()
+
+        return self.cur_ax_properties._lines[-1]
+
+    def add_image(self, image:np.ndarray | str, ax:Axes= None, **kwargs):
+
+        ax, idx_ax = self.get_ax_idx(ax)
+
+        if isinstance(image, str):
+            image = ImageOps.flip(Image.open(image))
+            ax.axis('off')  # clear x-axis and y-axis
+
+        ax.imshow(image, **kwargs)
+
+        self.update_layout()
+        self._canvas.SetFocus()
 
     def ondel_line(self, event):
         """ Remove a plot from the current ax """
 
+        if self._line_current.GetSelection() == -1:
+            return
+
         dlg = wx.MessageDialog(self, _('Do you want to remove the selected line?\n\nSuch action is irrevocable !\n\nPlease consider to set "Visible" to "False" to hide data'), _('Remove line'), wx.YES_NO | wx.ICON_QUESTION | wx.NO_DEFAULT)
 
         ret = dlg.ShowModal()
         if ret == wx.ID_NO:
             return
 
-        if self._line_current.GetSelection() == -1:
-            return
-
         idx = self._line_current.GetSelection()
         self.del_line(idx)
 
+        self._fill_lines_ax()
+
     def del_line(self, idx:int):
         """ Delete a line """