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

wolfhece/PyDraw.py

@@ -116,6 +116,12 @@ except ImportError as e:
     print(e)
     raise ImportError("Error importing pyshields, pyviews, PyConfig, GraphProfile, pybridges, tools_mpl, wolf_tiles, lagrangian.particle_system_ui, opengl.py3d, pyGui1D. Please check your installation.")
 
+try:
+    from .apps.curvedigitizer import Digitizer
+except ImportError as e:
+    print(e)
+    raise ImportError("Error importing apps.curvedigitizer. Please check your installation.")
+
 ID_SELECTCS = 1000
 ID_SORTALONG = 1001
 ID_LOCMINMAX = 1002
@@ -1363,6 +1369,7 @@ class WolfMapViewer(wx.Frame):
         self.menu_contour_from_arrays = self.tools_menu.Append(wx.ID_ANY, _("Create contour from checked arrays..."), _("Create contour"))
         self.menu_calculator = self.tools_menu.Append(wx.ID_ANY, _("Calculator..."), _("Calculator"))
         self.menu_views = self.tools_menu.Append(wx.ID_ANY, _("Memory views..."), _("Memory views"))
+        self.menu_digitizer = self.tools_menu.Append(wx.ID_ANY, _("Image digitizer..."), _("Image Digitizer"))
         self.calculator = None
         self.memory_views = None
         self._memory_views_gui = None
@@ -1708,6 +1715,8 @@ class WolfMapViewer(wx.Frame):
 
             self._menuinteractptri = self.trianglesmenu.Append(wx.ID_ANY, _("Interpolate on active triangulation..."), _("InterpolateTri"))
             self._menucomparetri = self.trianglesmenu.Append(wx.ID_ANY, _("Compare triangles to array..."), _("Comparison"))
+            self._menumovetri = self.trianglesmenu.Append(wx.ID_ANY, _("Move triangles..."), _("Move triangles"))
+            self._menurotatetri = self.trianglesmenu.Append(wx.ID_ANY, _("Rotate triangles..."), _("Rotate triangles"))
 
 
     def create_cloud_menu(self):
@@ -3143,6 +3152,20 @@ class WolfMapViewer(wx.Frame):
 
             self.active_array.compare_tri(self.active_tri)
 
+    def move_triangles(self):
+        """ Move the active triangles """
+        if self.active_tri is None:
+            logging.warning(_('No active triangles -- Please activate triangles first'))
+            return
+        self.start_action('move triangles', 'Move the current triangulation -- Please select 2 points to define the translation vector')
+
+    def rotate_triangles(self):
+        """ Rotate the active triangles """
+        if self.active_tri is None:
+            logging.warning(_('No active triangles -- Please activate triangles first'))
+            return
+        self.start_action('rotate triangles', 'Rotate the current triangulation -- Please select 1 point for the center')
+
     def copy_canvasogl(self, mpl:bool= True, ds:float= 0., figsizes= [10.,10.], palette:wolfpalette = None):
         """
         Generate image based on UI context and copy to the Clipboard
@@ -6270,6 +6293,14 @@ class WolfMapViewer(wx.Frame):
             autoscale = False
             self.compare_tri2array()
 
+        elif itemlabel ==  _("Move triangles..."):
+            autoscale = False
+            self.move_triangles()
+
+        elif itemlabel == _("Rotate triangles..."):
+            autoscale = False
+            self.rotate_triangles()
+
         elif itemlabel ==  _("Create contour from checked arrays..."):
             autoscale = False
 
@@ -6285,6 +6316,11 @@ class WolfMapViewer(wx.Frame):
             else:
                 self.calculator.Show()
 
+        elif itemlabel == _('Image digitizer...'):
+            autoscale = False
+
+            new_digitizer = Digitizer()
+
         elif itemlabel == _("Memory views..."):
             autoscale = False
 
@@ -9042,6 +9078,54 @@ class WolfMapViewer(wx.Frame):
 
             self.rightdown = (x, y)
 
+        elif self.action == 'move triangles':
+
+            if self.active_tri is None:
+                logging.warning(_('No triangles selected -- Please select a triangulation first !'))
+                return
+
+            if self.active_tri._start_move is None:
+                self.active_tri._start_move = (x, y)
+                return
+
+            delta_x = x - self.active_tri._start_move[0]
+            delta_y = y - self.active_tri._start_move[1]
+
+            if shiftdown:
+                delta_y = 0.
+
+            if alt:
+                delta_x = 0.
+
+            self.active_tri.move(delta_x, delta_y)
+            self.active_tri.reset_plot()
+            self.active_tri._start_move = None
+            self.active_tri.clear_cache()
+            self.end_action(_('End move triangulation'))
+
+        elif self.action == 'rotate triangles':
+
+            if self.active_tri is None:
+                logging.warning(_('No vector selected -- Please select a triangulation first !'))
+                return
+
+            if self.active_tri._rotation_center is None:
+                self.active_tri._rotation_center = (x,y)
+                return
+
+            if shiftdown:
+                if ctrl:
+                    self.active_tri._rotation_step = None
+                else:
+                    # Set the rotation step
+                    self.active_tri._rotation_step = np.degrees(np.arctan2(y - self.active_tri._rotation_center[1], x - self.active_tri._rotation_center[0]))
+
+            self.active_tri.rotate_xy(x, y)
+            self.active_tri._rotation_center = None
+            self.active_tri.clear_cache()
+            self.active_tri.reset_plot()
+            self.end_action(_('End rotate triangulation'))
+
         elif 'pick landmap' in self.action:
             # Pick a landmap if loaded
 
@@ -9989,11 +10073,34 @@ class WolfMapViewer(wx.Frame):
 
                         self.active_vector.move(delta_x, delta_y)
 
+            if self.action == 'move triangles':
+                if self.active_tri is not None:
+                    if self.active_tri._start_move is not None:
+
+                        delta_x = x - self.active_tri._start_move[0]
+                        delta_y = y - self.active_tri._start_move[1]
+
+                        if shiftdown:
+                            delta_y = 0.
+
+                        if altdown:
+                            delta_x = 0.
+
+                        self.active_tri.move(delta_x, delta_y)
+
+                        self.active_tri.reset_plot()
+
             if self.action == 'rotate vector':
                 if self.active_vector is not None:
                     if self.active_vector._rotation_center is not None:
                         self.active_vector.rotate_xy(x, y)
 
+            if self.action == 'rotate triangles':
+                if self.active_tri is not None:
+                    if self.active_tri._rotation_center is not None:
+                        self.active_tri.rotate_xy(x, y)
+                        self.active_tri.reset_plot()
+
             if self.action == 'move zone':
                 if self.active_zone is not None:
                     if self.active_zone._start_move is not None:

wolfhece/PyVertexvectors.py

@@ -59,6 +59,12 @@ class Triangulation(Element_To_Draw):
         self.nb_tri = len(tri)
         self.nb_pts = len(pts)
 
+        self._start_move = None
+        self._move_step = None  # step for a move
+        self._rotation_center = None
+        self._rotation_step = None
+        self._cache = None
+
         if fn !='':
             self.filename=fn
             self.read(fn)
@@ -370,6 +376,7 @@ class Triangulation(Element_To_Draw):
                 glPolygonMode(GL_FRONT_AND_BACK,GL_LINE)
 
                 glEndList()
+                glCallList(self.id_list)
             except:
                 logging.warning('Problem with OpenGL plot - Triangulation.plot')
         else:
@@ -420,6 +427,67 @@ class Triangulation(Element_To_Draw):
         self.nb_pts = len(self.pts)
         self.nb_tri = len(self.tri)
         self.valid_format()
+
+    def set_cache(self):
+        """ Set the cache for the vertices """
+
+        self._cache = self.pts.copy()
+
+    def clear_cache(self):
+        """ Clear the cache for the vertices """
+
+        self._cache = None
+
+    def move(self, delta_x:float, delta_y:float, use_cache:bool = True):
+        """ Move the vertices by a delta_x and delta_y
+
+        :param delta_x: delta x [m]
+        :param delta_y: delta y [m]
+        """
+
+        if use_cache and self._cache is None:
+            self.set_cache()
+
+        if use_cache:
+            self.pts[:,0] = self._cache[:,0] + delta_x
+            self.pts[:,1] = self._cache[:,1] + delta_y
+        else:
+            self.pts[:,0] += delta_x
+            self.pts[:,1] += delta_y
+
+    def rotate(self, angle:float, center:tuple, use_cache:bool = True):
+        """ Rotate the vertices around a center
+
+        :param angle: angle in degrees -- positive for clockwise rotation
+        :param center: center of rotation
+        """
+        angle = np.radians(angle)
+        c,s = np.cos(angle), np.sin(angle)
+        R = np.array([[c,-s],[s,c]])
+
+        if use_cache and self._cache is None:
+            self.set_cache()
+
+        if use_cache:
+            locxy = self._cache[:,:2] - np.array(center)
+            self.pts[:,:2] = np.dot(R,locxy.T).T + np.array(center)
+        else:
+            locxy = self.pts[:,:2] - np.array(center)
+            self.pts[:,:2] = np.dot(R,locxy.T).T + np.array(center)
+
+    def rotate_xy(self, x:float, y:float, use_cache:bool = True):
+        """ Rotate the vector around the rotation center and a xy point """
+
+        if self._rotation_center is None:
+            logging.error('No rotation center defined -- set it before rotating by this routine')
+            return self
+
+        angle = np.degrees(np.arctan2(-(y-self._rotation_center[1]), x-self._rotation_center[0]))
+
+        if self._rotation_step is not None:
+            angle = np.round(angle/self._rotation_step)*self._rotation_step
+
+        return self.rotate(-angle, center=self._rotation_center, use_cache=use_cache)
 class vectorproperties:
     """ Vector properties """
     used:bool

wolfhece/apps/curvedigitizer.py

@@ -13,170 +13,226 @@ myappid = 'wolf_hece_uliege' # arbitrary string
 ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
 
 from ..PyTranslate import _
+from ..matplotlib_fig import Matplotlib_Figure, PRESET_LAYOUTS
 
 import wx
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+from matplotlib.backend_bases import KeyEvent, MouseEvent
+from PIL import Image, ImageOps
 
-def main():
-    """
-    Main function of curve digitizer
+import logging
 
-    """
-    plt.ion()
-    ex = wx.App()
-    ex.MainLoop()
-    curves=[]
-    # open the dialog
-    file=wx.FileDialog(None,_("Select image to digitize"),
-            wildcard="jpeg image (*.jpg)|*.jpg|png image (*.png)|*.png")
-    if file.ShowModal() == wx.ID_CANCEL:
-        return
-    else:
-        #récuparétaion du nom de fichier avec chemin d'accès
-        filein =file.GetPath()
-
-    # show the image
-    img = mpimg.imread(filein)
-    fig, ax = plt.subplots()
-    ax.imshow(img)
-    ax.axis('off')  # clear x-axis and y-axis
-
-    # get reference length in x direction
-    xfactor = getReferenceLength(0)
-
-    MsgBox = wx.MessageDialog(None,_('Do you want to use the same reference along Y?'),style=wx.YES_NO)
-    result=MsgBox.ShowModal()
-    if result == wx.ID_YES:
-       yfactor=xfactor
-    else:
-        # get the reference length in y direction
-        yfactor = getReferenceLength(1)
-
-    print(xfactor)
-    print(yfactor)
-
-    origin = getOrigin()
-
-    # digitize curves until stoped by the user
-    reply = wx.ID_YES
-    show=True
-    while reply==wx.ID_YES:
-        if show:
-            wx.MessageBox(_("Please digitize the curve.\n" +
-                "Left click: select point\n"+
-                "Right click: undo\n"+
-                "Middle click or Return: finish"),
-                _("Digitize curve"))
-            show=False
-
-        # get the curve points
-        x = plt.ginput(
-            -1,
-            timeout=0,
-            show_clicks=True
-            )
-        x = np.asarray(x)
+class Digitizer:
 
-        ax.plot(x[:,0],x[:,1],'g','linewidth',1.5)
+    def __init__(self):
 
-        # convert the curve points from pixels to coordinates
-        x[:,0] = (x[:,0]-origin[0]) * xfactor
-        x[:,1] = (x[:,1]-origin[1]) * yfactor
+        """
+        Main function of curve digitizer
+        """
 
-        curves.append(x)
-        print(x)
+        plt.ion()
 
-        MsgBox = wx.MessageDialog(None,_("Digitize another curve?"),style=wx.YES_NO)
-        reply=MsgBox.ShowModal()
+        # self.curves=[]
 
-    # write the data to a file
-    # first get the filename
-    validFile = False
+        # open the dialog
+        file = wx.FileDialog(None,_("Select image to digitize"),
+                wildcard="gif image (*.gif)|*.gif|jpeg image (*.jpg)|*.jpg|png image (*.png)|*.png|All files (*.*)|*.*",)
 
-    while not validFile:
-        file=wx.FileDialog(None,_("Select file to save the data"), wildcard=_("Simple text files (.txt)|*.txt"))
         if file.ShowModal() == wx.ID_CANCEL:
-            wx.MessageBox(_("Please select a filename to save the data"),_("Filename error"))
+            return
         else:
             #récuparétaion du nom de fichier avec chemin d'accès
-            fileout =file.GetPath()
-            validFile = True
-
-    # write the data to file
-    f=open(fileout,'w')
-    i=0
-    for loccurv in curves:
-        i+=1
-        f.write('line'+str(i)+'\n')
-        for idx,xy in enumerate(loccurv):
-            f.write('{:14.6f}\t{:14.6f}\n'.format(xy[0],xy[1]))
-    f.close()
-
-    # clear the figure
-    plt.clf()
-
-def getReferenceLength(index):
-    """
-    Get the reference length in the requested direction
-
-    USAGE: factor = getReferenceLength(index)
-
-    :param index : 0 for x-direction or 1 for y-direction
-
-    """
-
-    # define a 'direction' string
-    direction = 'x' if index == 0 else 'y'
-
-    # get the reference length
-    reply = wx.ID_NO
-    while reply==wx.ID_NO:
-        wx.MessageBox(_("Use the mouse to select the reference length\n") +
-            _("Click the start and the end of the reference length"),_("Select reference length"))
-        coord = plt.ginput(
-            2,
-            timeout=0,
-            show_clicks=True
-            ) # capture only two points
-        # ask for a valid length
-        validLength = False
-        while not validLength:
-            dlg=wx.TextEntryDialog(None,_("Enter the reference length"))
-            dlg.ShowModal()
-            reflength=float(dlg.GetValue())
-            dlg.Destroy()
-
-            if isinstance(reflength, float):
-                validLength = True
+            self.filein =file.GetPath()
+
+        # show the image
+        self.figure = Matplotlib_Figure(PRESET_LAYOUTS.DEFAULT_EQUAL)
+        self.figure.cur_ax.set_aspect('equal')
+        self.figure.fig_properties._axes[0]._equal_axis == 1
+
+        # win = self.figure._collaps_pane.GetPane()
+        # self._convert_xy = wx.Button(win, -1, 'Convert XY to world coordinates')
+        # self._convert_xy.Bind(wx.EVT_BUTTON, self.convert_xy)
+        # self.figure._sizer_xls.Add(self._convert_xy, 0, wx.EXPAND)
+        # self.figure.Layout()
+
+        self.figure.add_image(self.filein, origin='lower')
+        self.fig.tight_layout()
+
+        self.ref_x = []
+        self.ref_y = []
+
+        self.ref_x_length = 0
+        self.ref_y_length = 0
+
+        self.xy = []
+
+        # get reference length in x direction
+        wx.MessageBox(_("Use SHIFT + Right Mouse Button to select two points as X reference.\n\nWe will use only the delta X to calculate the scaling factor.\nSo, the Y distance will be ignored."),_("Select reference X"))
+        self.new_line(is_world=False, label = 'Reference X', color='black', linewidth=2)
+        self.figure.action = ('Ref X', self._callback_pt)
+
+    @property
+    def ax(self) -> Axes:
+        return self.figure.ax[0]
+
+    @property
+    def fig(self) -> Figure:
+        return self.figure.fig
+
+    # def convert_xy(self, event):
+    #     """
+    #     Convert the pixel coordinates to world coordinates
+    #     """
+    #     xy = self.figure.get_xy_from_grid()
+
+    #     xy[:,0] = (xy[:,0] - self.origin_img[0]) * self.factor_X + self.origin_world[0]
+    #     xy[:,1] = (xy[:,1] - self.origin_img[1]) * self.factor_Y + self.origin_world[1]
+
+    #     self.figure.fill_grid_with_xy_np(xy)
+
+    def new_line(self, is_world:bool = True, ax=None, **kwargs):
+
+        line_props = self.figure.new_line(ax=ax, **kwargs)
+
+        if is_world:
+            line_props.xscale = self.factor_X
+            line_props.yscale = self.factor_Y
+            line_props.xorigin_world = self.origin_world[0]
+            line_props.yorigin_world = self.origin_world[1]
+            line_props.xorigin_local = self.origin_img[0]
+            line_props.yorigin_local = self.origin_img[1]
+            line_props.populate()
+
+    def _callback_digitize(self, xy, which):
+
+        if which == 'Digitize':
+            pass
+            # self.xy.append(xy)
+        elif which == 'End Digitize':
+
+            MsgBox = wx.MessageDialog(None,_("Digitize another curve?"),style=wx.YES_NO)
+            reply=MsgBox.ShowModal()
+
+            if reply == wx.ID_YES:
+                self.new_line()
             else:
-                wx.MessageBox(_("Please provide a valid length"),_("Error"))
+                self.figure.action = None
 
-        # calculate scaling factor
-        deltaref=coord[1][index]-coord[0][index]
-        factor=reflength/deltaref
+    def _callback_origin(self, xy, which):
 
-        reply = wx.MessageDialog(None,"{:4.0f} pixels in {:s} direction corresponding to {:4.4f} units. Is this correct?".format(deltaref, direction, reflength),style=wx.YES_NO)
+        if which == 'Origin':
+            self.origin_img = xy
 
-    return factor
+            valid_origin = False
+            while not valid_origin:
+                dlg = wx.TextEntryDialog(None,_("Set the origin coordinate (X,Y)"),_("Set the origin"), "0,0")
+                ret = dlg.ShowModal()
 
-def getOrigin():
-    """
-    Get the Origin
+                if ret == wx.ID_OK:
+                    origin = dlg.GetValue().split(',')
 
-    """
-    wx.MessageBox(_("Click one point"),_("Select an origin"))
-    coord = plt.ginput(
-        1,
-        timeout=0,
-        show_clicks=True
-        ) # capture only one points
+                    try:
+                        self.origin_world = (float(origin[0]),float(origin[1]))
+                        valid_origin = True
+                    except:
+                        valid_origin = False
 
-    msg=_('The origin is ')+ '(%d ; %d)' % (coord[0][0],coord[0][1])
-    wx.MessageBox(msg)
-    return (coord[0][0],coord[0][1])
+            wx.MessageBox(_("Please digitize the curve.\n\n" +
+                " - MAJ + Right click  : add point\n"+
+                " - Press Enter : finish"),
+                _("Digitize curve"))
+
+            self.new_line(is_world = True, label = 'Curve', linewidth=1.5)
+            self.figure.action = ('Digitize', self._callback_digitize)
+
+    def _callback_pt(self, xy, which):
+
+        if which == 'Ref X':
+            self.ref_x.append(xy)
+
+            if len(self.ref_x) == 2:
+
+                validLength = False
+                dlg=wx.TextEntryDialog(None,_("Enter the reference length [user unit | mm | cm | m | km]"))
+
+                while not validLength:
+                    dlg.ShowModal()
+
+                    try:
+                        self.ref_x_length = float(dlg.GetValue())
+                        if self.ref_x_length > 0:
+                            validLength = True
+                    except:
+                        validLength = False
+
+                dlg.Destroy()
+
+                # calculate scaling factor
+                deltaref = np.abs(self.ref_x[1][0] - self.ref_x[0][0])
+                self.factor_X = self.ref_x_length / deltaref
+
+                reply = wx.MessageDialog(None,"{:4.0f} pixels in {:s} direction corresponding to {:4.4f} units. Is this correct?".format(deltaref, 'X', self.ref_x_length),style=wx.YES_NO)
+
+                if reply.ShowModal() == wx.ID_NO:
+                    logging.info(_('Retry !'))
+                    self.ref_x = []
+                    self.ref_x_length = 0
+                else:
+                    self.figure.action = None
+                    MsgBox = wx.MessageDialog(None,_('Do you want to use the same reference along Y?'),style=wx.YES_NO)
+                    result=MsgBox.ShowModal()
+                    if result == wx.ID_YES:
+                        self.factor_Y = self.factor_X
+
+                        wx.MessageBox(_("Click one point for a reference in local axis (s,z)"),_("Select an origin"))
+                        self.new_line(is_world = False, label = 'Origin', color='red', linewidth=4)
+                        self.figure.action = ('Origin', self._callback_origin)
+                    else:
+                        # get the reference length in y direction
+                        self.new_line(is_world = False, label = 'Reference Y', color='black', linewidth=2)
+                        wx.MessageBox(_("Use SHIFT + Right Mouse Button to select two points as Y reference.\n\nWe will use only the delta Y to calculate the scaling factor.\nSo, the X distance will be ignored."),_("Select reference Y"))
+                        self.figure.action = ('Ref Y', self._callback_pt)
+
+        elif which == 'Ref Y':
+            self.ref_y.append(xy)
+
+            if len(self.ref_y) == 2:
+
+                validLength = False
+                dlg=wx.TextEntryDialog(None,_("Enter the reference length [user unit | mm | cm | m | km]"))
+                while not validLength:
+                    dlg.ShowModal()
+
+                    try:
+                        self.ref_y_length = float(dlg.GetValue())
+                        if self.ref_y_length > 0:
+                            validLength = True
+                    except:
+                        validLength = False
+
+                dlg.Destroy()
+
+                # calculate scaling factor
+                deltaref = np.abs(self.ref_y[1][1] - self.ref_y[0][1])
+                self.factor_Y = self.ref_y_length / deltaref
+
+                reply = wx.MessageDialog(None,"{:4.0f} pixels in {:s} direction corresponding to {:4.4f} units. Is this correct?".format(deltaref, 'Y', self.ref_y_length),style=wx.YES_NO)
+
+                if reply.ShowModal() == wx.ID_NO:
+                    logging.info(_('Retry !'))
+                    self.ref_y = []
+                    self.ref_y_length = 0
+                else:
+                    wx.MessageBox(_("Click one point for a reference in local axis (s,z)"),_("Select an origin"))
+                    self.new_line(is_world = False, label = 'Origin', color='red', linewidth=4)
+                    self.figure.action = ('Origin', self._callback_origin)
 
 if __name__ == "__main__":
     # run the main function
-    main()
+    ex = wx.App()
+    digit = Digitizer()
+    ex.MainLoop()

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 109
+        self.patch = 110
 
     def __str__(self):