wolfhece 2.1.108__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
@@ -5064,7 +5087,7 @@ class WolfMapViewer(wx.Frame):
         value = dlg.GetValue()/100.
         dlg.Destroy()
 
-        fig,ax = self.mylazgrid.plot_laz(self.active_vector.asshapely_ls(), length_buffer=value, show=False)
+        fig = self.mylazgrid.plot_laz_wx(self.active_vector.asshapely_ls(), length_buffer=value, show=True)
 
         if self.active_array is not None:
             copy_vec = vector()
@@ -5073,9 +5096,12 @@ class WolfMapViewer(wx.Frame):
             copy_vec.get_values_on_vertices(self.active_array)
             s,z = copy_vec.get_sz()
             notmasked = np.where(z != -99999.)
-            ax.plot(s[notmasked], z[notmasked], c='black', linewidth=2.0)
 
-        fig.show()
+            fig.plot(s,z, c='black', linewidth=2.0)
+
+            # ax.plot(s[notmasked], z[notmasked], c='black', linewidth=2.0)
+
+        # fig.show()
 
     def clip_laz_gridded(self):
         """ Clip laz grid on current zoom """
@@ -6267,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
 
@@ -6282,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
 
@@ -6501,11 +6540,11 @@ class WolfMapViewer(wx.Frame):
             self.select_active_array_from_laz(self.active_array)
 
         elif itemlabel == _('Plot LAZ around active vector'):
-
+            autoscale = False
             self.plot_laz_around_active_vec()
 
         elif itemlabel == _('Plot LAZ around temporary vector'):
-
+            autoscale = False
             self.active_vector = vector()
             self.active_vector.add_vertex(wolfvertex(0.,0.))
             self.mimicme()
@@ -6515,9 +6554,11 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel == _('Change colors - Classification'):
 
             if self.mylazgrid is not None:
+                autoscale = False
                 self.mylazgrid.colors.interactive_update_colors()
 
         elif itemlabel == _('Multiviewer'):
+            autoscale = False
             dlg = wx.NumberEntryDialog(self, _("Additional viewers"), _("How many?"), _("How many additional viewers?"),1, 0, 5)
             ret = dlg.ShowModal()
 
@@ -9037,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
 
@@ -9251,6 +9340,84 @@ class WolfMapViewer(wx.Frame):
             self.active_vector.find_minmax()
             self.active_zone.find_minmax()
 
+        elif self.action == 'move vector':
+
+            if self.active_vector is None:
+                logging.warning(_('No vector selected -- Please select a vector first !'))
+                return
+
+            if self.active_vector._start_move is None:
+                self.active_vector._start_move = (x, y)
+                return
+
+            delta_x = x - self.active_vector._start_move[0]
+            delta_y = y - self.active_vector._start_move[1]
+
+            if shiftdown:
+                delta_y = 0.
+
+            if alt:
+                delta_x = 0.
+
+            self.active_vector.move(delta_x, delta_y)
+            self.active_vector.clear_cache()
+            self.end_action(_('End move vector'))
+
+        elif self.action == 'rotate vector':
+
+            if self.active_vector is None:
+                logging.warning(_('No vector selected -- Please select a vector first !'))
+                return
+
+            if self.active_vector._rotation_center is None:
+                self.active_vector._rotation_center = (x,y)
+                return
+
+            if shiftdown:
+                if ctrl:
+                    self.active_vector._rotation_step = None
+                else:
+                    # Set the rotation step
+                    self.active_vector._rotation_step = np.degrees(np.arctan2(y - self.active_vector._rotation_center[1], x - self.active_vector._rotation_center[0]))
+
+            self.active_vector.rotate_xy(x, y)
+            self.active_vector.clear_cache()
+            self.end_action(_('End rotate vector'))
+
+        elif self.action == 'move zone':
+
+            if self.active_zone is None:
+                logging.warning(_('No zone selected -- Please select a zone first !'))
+                return
+
+            if self.active_zone._start_move is None:
+                self.active_zone._start_move = (x, y)
+                return
+
+            if shiftdown:
+                delta_y = 0.
+
+            if alt:
+                delta_x = 0.
+
+            self.active_zone.move(x - self.active_zone._start_move[0], y - self.active_zone._start_move[1])
+            self.active_zone.clear_cache()
+            self.end_action(_('End move zone'))
+
+        elif self.action == 'rotate zone':
+
+            if self.active_zone is None:
+                logging.warning(_('No zone selected -- Please select a zone first !'))
+                return
+
+            if self.active_zone._rotation_center is None:
+                self.active_zone._rotation_center = (x,y)
+                return
+
+            self.active_zone.rotate_xy(x, y)
+            self.active_zone.clear_cache()
+            self.end_action(_('End rotate zone'))
+
         elif self.action == 'dynamic parallel':
             # Create a dynamic parallel line
             if ctrl:
@@ -9891,6 +10058,68 @@ class WolfMapViewer(wx.Frame):
             if self.action == 'dynamic parallel':
                 self.active_zone.parallel_active(self.dynapar_dist)
 
+            if self.action == 'move vector':
+                if self.active_vector is not None:
+                    if self.active_vector._start_move is not None:
+
+                        delta_x = x - self.active_vector._start_move[0]
+                        delta_y = y - self.active_vector._start_move[1]
+
+                        if shiftdown:
+                            delta_y = 0.
+
+                        if altdown:
+                            delta_x = 0.
+
+                        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:
+                        delta_x = x - self.active_zone._start_move[0]
+                        delta_y = y - self.active_zone._start_move[1]
+
+                        if shiftdown:
+                            delta_y = 0.
+
+                        if altdown:
+                            delta_x = 0.
+
+                        self.active_zone.move(delta_x, delta_y)
+
+            if self.action == 'rotate zone':
+                if self.active_zone is not None:
+                    if self.active_zone._rotation_center is not None:
+                        self.active_zone.rotate_xy(x, y)
+
             self.Paint()
 
         self._last_mouse_pos = (x,y,pos)

wolfhece/PyVertex.py

@@ -113,6 +113,22 @@ class wolfvertex:
         self.in_use = True
         self.values = None
 
+    def rotate(self, angle:float, center:tuple):
+        """ Rotate the vertex
+
+        :param angle: angle in radians (positive for counterclockwise)
+        :param center: center of the rotation (x, y)
+        """
+
+        x = self.x - center[0]
+        y = self.y - center[1]
+
+        x1 = x * math.cos(angle) - y * math.sin(angle)
+        y1 = x * math.sin(angle) + y * math.cos(angle)
+
+        self.x = x1 + center[0]
+        self.y = y1 + center[1]
+
     def as_shapelypoint(self):
         """ Return a shapely Point """
 
@@ -725,7 +741,7 @@ class cloud_vertices(Element_To_Draw):
         logging.info(_('Number of entities : ')+str(len(msp)))
         logging.info(_('Number of layers : ')+str(len(doc.layers)))
         logging.info(_('Treating entities... '))
-                     
+
         # Bouclage sur les éléments du DXF
         k=0
         for e in msp: