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

wolfhece/PyDraw.py

@@ -4001,10 +4001,17 @@ class WolfMapViewer(wx.Frame):
                                '2006-2007': 'ORTHO_2006_2007',
                                '2009-2010': 'ORTHO_2009_2010',
                                '2012-2013': 'ORTHO_2012_2013',
-                               '2015': 'ORTHO_2015', '2016': 'ORTHO_2016', '2017': 'ORTHO_2017',
-                               '2018': 'ORTHO_2018', '2019': 'ORTHO_2019', '2020': 'ORTHO_2020',
-                               '2021': 'ORTHO_2021', '2022 printemps': 'ORTHO_2022_PRINTEMPS', '2022 été': 'ORTHO_2022_ETE',
+                               '2015': 'ORTHO_2015',
+                               '2016': 'ORTHO_2016',
+                               '2017': 'ORTHO_2017',
+                               '2018': 'ORTHO_2018',
+                               '2019': 'ORTHO_2019',
+                               '2020': 'ORTHO_2020',
+                               '2021': 'ORTHO_2021',
+                               '2022 printemps': 'ORTHO_2022_PRINTEMPS',
+                               '2022 été': 'ORTHO_2022_ETE',
                                '2023 été': 'ORTHO_2023_ETE',
+                               'Last one': 'ORTHO_LAST',
                                }}
         data_2021 = {'EAU': {'IDW': 'ZONES_INONDEES_IDW',
                              'Emprise': 'ZONES_INONDEES',
@@ -4030,9 +4037,14 @@ class WolfMapViewer(wx.Frame):
                         ToCheck=False, id='Orthos France')
 
         forelist = {'EAU': {'Aqualim': 'RES_LIMNI_DGARNE', 'Alea': 'ALEA_INOND', 'Lidaxes': 'LIDAXES'},
-                    'LIMITES': {'Secteurs Statistiques': 'LIMITES_QS_STATBEL'},
-                    'INSPIRE': {'Limites administratives': 'AU_wms'},
-                    'PLAN_REGLEMENT': {'Plan Percellaire': 'CADMAP_2021_PARCELLES'}}
+                    'LIMITES': {'Secteurs Statistiques': 'LIMITES_QS_STATBEL',
+                                'Limites administratives': 'LIMITES_ADMINISTRATIVES'},
+                    'R3C': {'Limites Communes': 'Municipalities'},
+                    # 'INSPIRE': {'Limites administratives': 'AU_wms'},
+                    'PLAN_REGLEMENT': {'Plan Parcellaire 2021': 'CADMAP_2021_PARCELLES',
+                                       'Plan Parcellaire 2022': 'CADMAP_2022_PARCELLES',
+                                       'Plan Parcellaire 2023': 'CADMAP_2023_PARCELLES',
+                                       'Plan Parcellaire 2024': 'CADMAP_2024_PARCELLES'}}
 
         for idx, (k, item) in enumerate(forelist.items()):
             for kdx, (m, subitem) in enumerate(item.items()):
@@ -4041,6 +4053,12 @@ class WolfMapViewer(wx.Frame):
                                                     self, xmin, xmax, ymin, ymax, -99999, 1024),
                                 ToCheck=False, id=m)
 
+        # self.add_object(which='wmsfore',
+        #                 newobj=imagetexture('Cadastre Flandres', 'Plan Parcellaire 2024 (Flandres)', 'Adpf', '',
+        #                                     self, xmin, xmax, ymin, ymax, -99999, 1024, Vlaanderen=True),
+        #                 ToCheck=False, id='Plan Parcellaire 2024 (Flandres)')
+
+
     def set_compare(self, ListArrays:list[WolfArray]=None, share_colormap:bool=True):
         """
         Comparison of 2 arrays
@@ -5046,7 +5064,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()
@@ -5055,9 +5073,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 """
@@ -6483,11 +6504,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()
@@ -6497,9 +6518,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()
 
@@ -6713,7 +6736,7 @@ class WolfMapViewer(wx.Frame):
             autoscale = False
 
             from .scenario.config_manager import Config_Manager_2D_GPU
-            newmanager = Config_Manager_2D_GPU(mapviewer=self)
+            newmanager = Config_Manager_2D_GPU(mapviewer=self, create_ui_if_wx=True)
 
         elif itemlabel == _('Create acceptability manager...'):
             autoscale = False
@@ -8846,7 +8869,11 @@ class WolfMapViewer(wx.Frame):
         curobj = self.getobj_from_id(nameitem)
         myobj = self.treelist.GetItemData(myitem)
 
-        assert curobj is myobj, 'curobj is not myobj'
+        if curobj is not myobj:
+            logging.error(_('Bad association between object and tree item'))
+            logging.error(_('Do you have 2 objects with the same id ?'))
+            logging.error(_('It could be the case if you have drag/drop an object in the viewer...'))
+            logging.error(_('I will continue but it is not normal...'))
 
         self.treelist.SetToolTip(self.treelist.GetItemText(myitem))
 
@@ -9229,6 +9256,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:
@@ -9869,6 +9974,45 @@ 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 == '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 == '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)
@@ -10504,7 +10648,14 @@ class WolfMapViewer(wx.Frame):
 
                     newarray.nullify_border(width=1)
 
-                    self.add_object('array', newobj = newarray, id = self.active_array.idx + '_crop')
+                    #keys for arrays
+                    keys = self.get_list_keys(draw_type.ARRAYS, checked_state=False)
+                    new_key = self.active_array.idx + '_crop'
+
+                    while new_key in keys:
+                        new_key += '_'
+
+                    self.add_object('array', newobj = newarray, id = new_key)
 
                     self.Refresh()
 

wolfhece/PyGui.py

@@ -3751,4 +3751,4 @@ class Wolf2DGPUModel(GenMapManager):
         """ Append text to the information zone """
 
         if self.wx_exists:
-            self._txt_info.AppendText(text)
+            self._txt_info.AppendText(text)

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: