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

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 = 108
+        self.patch = 110
 
     def __str__(self):
 

wolfhece/lazviewer/laz_viewer.py

@@ -23,6 +23,7 @@ from ..PyWMS import getWalonmap
 from ..PyTranslate import _
 from ..color_constants import Colors
 from ..PyParams import Wolf_Param
+from ..matplotlib_fig import Matplotlib_Figure as mplfig
 
 """
 Importation et visualisation de données LAS et LAZ
@@ -620,6 +621,27 @@ class xyz_laz_grids():
 
         return fig,ax
 
+    def plot_laz_wx(self, xy:Union[LineString, list[list[float], list[float]]], length_buffer=5., show=True):
+        """
+        Dessin des points LAZ sur un graphique Matplotlib
+        """
+
+        (up_s, up_z, up_color), (down_s, down_z, down_color) = self.scan_around(xy, length_buffer)
+
+        figmpl = mplfig()
+        figmpl.presets()
+        fig = figmpl.fig
+        ax = figmpl.cur_ax
+
+        logging.info(_('Plotting'))
+        ax.scatter(up_s,   up_z,  c=up_color  ,marker='.')
+        ax.scatter(down_s, down_z,c=down_color,marker='+')
+
+        if show:
+            figmpl.Show()
+
+        return figmpl
+
     def create_from_laz(self, dir_laz:str, shape:str, ds:float = 50, force_format = np.float64):
 
         try: