wolfhece 2.2.36__py3-none-any.whl → 2.2.38__py3-none-any.whl

wolfhece/PyDraw.py

@@ -12229,6 +12229,46 @@ class WolfMapViewer(wx.Frame):
                     self.selected_object.active_vector.parentzone.add_vector(vec_raster, forceparent=True, update_struct=True)
                     self.selected_object.active_vector.parentzone.reset_listogl()
 
+        elif  _('Extrude on active array') in text:
+
+            if isinstance(self.selected_object, Picc_data):
+
+                if self.active_array is None:
+                    logging.warning(_('No active array selected'))
+                    return
+
+                logging.info(_('Extruding polygons on active array'))
+                logging.info(_('Please wait, it could take some time...'))
+                self.selected_object.extrude_polygons(self.active_array)
+                logging.info(_('Extrusion done !'))
+
+                self.active_array.reset_plot()
+                self.Refresh()
+
+        elif  _('Interpolate on active array') in text:
+
+            if isinstance(self.selected_object, Zones):
+
+                if self.active_array is None:
+                    logging.warning(_('No active array selected'))
+                    return
+
+                dlg = wx.SingleChoiceDialog(None, _('With respect to the array values, keep the extruded values which are ?'), _('Interpolate on active array'), ['Above', 'Below', 'All'], style=wx.CHOICEDLG_STYLE)
+                ret = dlg.ShowModal()
+                if ret != wx.ID_OK:
+                    dlg.Destroy()
+                    return
+                choice = dlg.GetStringSelection().lower()
+                dlg.Destroy()
+
+
+                logging.info(_('Interpolating polygons on active array'))
+                logging.info(_('Please wait, it could take some time...'))
+                for curzone in self.selected_object.myzones:
+                    self.active_array.interpolate_on_polygons(curzone, keep = choice)
+                logging.info(_('Interpolation done !'))
+
+
     def OnClose(self, event):
         """ Close the application """
 
@@ -12292,6 +12332,7 @@ class WolfMapViewer(wx.Frame):
         nameitem = self.treelist.GetItemText(myitem).lower()
 
         ctrl = wx.GetKeyState(wx.WXK_CONTROL)
+        shiftdown = wx.GetKeyState(wx.WXK_SHIFT)
 
         # ctrl = event.ControlDown()
 
@@ -12345,6 +12386,8 @@ class WolfMapViewer(wx.Frame):
             else:
                 if issubclass(type(curobj), WolfArray):
                     curobj.uncheck_plot(not ctrl,ctrl)
+                elif isinstance(curobj, Picc_data):
+                    curobj.uncheck_plot(ctrl, shiftdown)
                 else:
                     curobj.uncheck_plot()
 
@@ -15157,6 +15200,9 @@ class WolfMapViewer(wx.Frame):
             tracks.append(_('Rasterize active zone'))
             tracks.append(_('Rasterize active vector'))
 
+            tracks.append(_('Extrude on active array'))
+            tracks.append(_('Interpolate on active array'))
+
             # Récupération des items du menu contextuel
             menuitems = self.popupmenu.GetMenuItems()
             text = [cur.GetItemLabelText() for cur in menuitems]
@@ -15197,6 +15243,7 @@ class WolfMapViewer(wx.Frame):
             if isinstance(self.selected_object, Zones):
                 self.popupmenu.Append(wx.ID_ANY, _('Rasterize active zone'), _('Rasterize active zone'))
                 self.popupmenu.Append(wx.ID_ANY, _('Rasterize active vector'), _('Rasterize active vector'))
+                self.popupmenu.Append(wx.ID_ANY, _('Interpolate on active array'), _('Interpolate Z-values on active array'))
 
             if isinstance(self.selected_object, Zones | Bridge | Weir):
                 self.popupmenu.Append(wx.ID_ANY, _('Export to Shape file'), _('Export to Shape file'))
@@ -15229,6 +15276,9 @@ class WolfMapViewer(wx.Frame):
                 moviemenu.Append(wx.ID_ANY, _('Load flight'), _('Load flight'))
                 moviemenu.Append(wx.ID_ANY, _('Save flight'), _('Save flight'))
 
+            if isinstance(self.selected_object, Picc_data):
+                self.popupmenu.Append(wx.ID_ANY, _('Extrude on active array'), _('Extrude building elevation on active array'))
+
             self.treelist.PopupMenu(self.popupmenu)
 
     def zoom_on_whole_walonia(self):

wolfhece/PyVertex.py

@@ -1061,6 +1061,13 @@ class cloud_vertices(Element_To_Draw):
 
         if self.myprop.legendvisible:
 
+            dx = xmax - xmin
+            dy = ymax - ymin
+
+            if dx > 50_000. or dy > 50_000.:
+                logging.warning(_('Too large bounds for legend plot -- skipping'))
+                return
+
             mapviewer = self.get_mapviewer()
 
             which_legend = self.myprop.legendtext

wolfhece/PyVertexvectors.py

@@ -1336,6 +1336,8 @@ class vector:
         self._lengthparts2D=None
         self._lengthparts3D=None
 
+        self._simplified_geometry = False
+
         if type(lines)==list:
             if len(lines)>0:
                 self.myname=lines[0]
@@ -2276,6 +2278,43 @@ class vector:
 
         return len(not_in_use) > 0
 
+    def check_if_interior_exists(self):
+        """ Check if the vector has an interior and adapt in_use accordingly.
+
+        The verification is only made in 2D, as the interior is defined as a pair of segments that correspond exactly to the same coordinates.
+        Z coordinates are not taken into account in this verification.
+
+                """
+
+        xy = self.xy
+        if self.closed and (xy[0,0] == xy[-1,0] and xy[0,1] == xy[-1,1]):
+            # If the vector is closed, we remove the last vertex to avoid checking it
+            xy = xy[:-1]
+
+        xy_unique, inverse, count = np.unique(xy, return_inverse=True, return_counts=True, axis=0)
+
+        duplicate_found = False
+
+        if xy.shape[0] != xy_unique.shape[0]:
+            # There are duplicates, we need to test if the duplicate form a segment
+
+            # Find the duplicate indices
+            duplicate_indices = np.where(count > 1)[0]
+            # Find the inverse indices of the duplicates
+            duplicate_indices = np.where(np.isin(inverse, duplicate_indices))[0]
+            diff = np.diff(duplicate_indices)
+
+            for i in range(len(diff)):
+                # Set the in_use property to False for the vertices that are not used
+                if diff[i] == 1:
+                    self.myvertices[duplicate_indices[i+1]].in_use = False
+                    duplicate_found = True
+
+        if duplicate_found:
+            self.reset_linestring()
+            self._reset_listogl()
+
+
     @property
     def nb_interiors(self) -> int:
         """ Return the number of interiors in the vector.
@@ -2336,10 +2375,32 @@ class vector:
                 return tri.get_triangles_as_listwolfvertices()
 
             else:
-                if self.myprop.closed and (self.myvertices[0].x != self.myvertices[-1].x or self.myvertices[0].y != self.myvertices[-1].y):
-                    return [self.myvertices + [self.myvertices[0]]]
+                if self._simplified_geometry:
+                    if self.myprop.closed and (self.myvertices[0].x != self.myvertices[-1].x or self.myvertices[0].y != self.myvertices[-1].y):
+                        return [self.myvertices + [self.myvertices[0]]]
+                    else:
+                        return [self.myvertices]
                 else:
-                    return [self.myvertices]
+                    xx, yy = self.polygon.exterior.xy
+
+                    # On translate les coordonnées pour éviter les erreurs de triangulation
+                    tr_x = np.array(xx).min()
+                    tr_y = np.array(yy).min()
+
+                    xx = np.array(xx)-tr_x
+                    yy = np.array(yy)-tr_y
+
+                    geom = {'vertices' : [[x,y] for x,y in zip(xx[:-1],yy[:-1])], 'segments' : [[i,i+1] for i in range(len(xx)-2)]+[[len(xx)-2,0]]}
+
+                    try:
+                        delaunay = triangle.triangulate(geom, 'p')
+                        tri = []
+                        for curtri in delaunay['triangles']:
+                            # on traduit les coordonnées pour revenir dans le monde réel
+                            tri.append([wolfvertex(delaunay['vertices'][curtri[i]][0] + tr_x, delaunay['vertices'][curtri[i]][1] + tr_y) for i in range(3)])
+                        return tri
+                    except:
+                        pass
 
         else:
             if self.has_interior:
@@ -2509,28 +2570,35 @@ class vector:
                             logging.debug(_('Polygon not in Polygon'))
 
                 else:
-                    #En attendant de lier WOLF-Fortran, on utilise la triangulation contrainte de la librairie Triangle -- https://rufat.be/triangle/
-                    xx, yy = ls.exterior.xy
-
-                    # On translate les coordonnées pour éviter les erreurs de triangulation
-                    tr_x = np.array(xx).min()
-                    tr_y = np.array(yy).min()
-
-                    xx = np.array(xx)-tr_x
-                    yy = np.array(yy)-tr_y
-
-                    geom = {'vertices' : [[x,y] for x,y in zip(xx[:-1],yy[:-1])], 'segments' : [[i,i+1] for i in range(len(xx)-2)]+[[len(xx)-2,0]]}
-
-                    try:
-                        delaunay = triangle.triangulate(geom, 'p')
-                        for curtri in delaunay['triangles']:
-                            glBegin(GL_POLYGON)
-                            for i in range(3):
-                                # on retraduit les coordonnées pour revenir dans le monde réel
-                                glVertex2d(delaunay['vertices'][curtri[i]][0] + tr_x, delaunay['vertices'][curtri[i]][1] + tr_y)
-                            glEnd()
-                    except:
-                        pass
+                    # #En attendant de lier WOLF-Fortran, on utilise la triangulation contrainte de la librairie Triangle -- https://rufat.be/triangle/
+                    # xx, yy = ls.exterior.xy
+
+                    # # On translate les coordonnées pour éviter les erreurs de triangulation
+                    # tr_x = np.array(xx).min()
+                    # tr_y = np.array(yy).min()
+
+                    # xx = np.array(xx)-tr_x
+                    # yy = np.array(yy)-tr_y
+
+                    # geom = {'vertices' : [[x,y] for x,y in zip(xx[:-1],yy[:-1])], 'segments' : [[i,i+1] for i in range(len(xx)-2)]+[[len(xx)-2,0]]}
+
+                    # try:
+                    #     delaunay = triangle.triangulate(geom, 'p')
+                    #     for curtri in delaunay['triangles']:
+                    #         glBegin(GL_POLYGON)
+                    #         for i in range(3):
+                    #             # on retraduit les coordonnées pour revenir dans le monde réel
+                    #             glVertex2d(delaunay['vertices'][curtri[i]][0] + tr_x, delaunay['vertices'][curtri[i]][1] + tr_y)
+                    #         glEnd()
+                    # except:
+                    #     pass
+
+                    all_polys = self.get_subpolygons()
+                    for curpoly in all_polys:
+                        glBegin(GL_POLYGON)
+                        for curvertex in curpoly:
+                            glVertex2d(curvertex.x, curvertex.y)
+                        glEnd()
 
             else:
                 all_polys = self.get_subpolygons()
@@ -2975,6 +3043,28 @@ class vector:
            gridto.SetCellValue(k,5,'1' if curv.in_use else '0')
            k+=1
 
+    def _fillgrid_only_i(self, gridto:CpGrid):
+        """
+        Remplissage d'un CpGrid
+        """
+        curv:wolfvertex
+
+        gridto.SetColLabelValue(0,'X')
+        gridto.SetColLabelValue(1,'Y')
+        gridto.SetColLabelValue(2,'Z')
+        gridto.SetColLabelValue(3,'value')
+        gridto.SetColLabelValue(4,'s curvi')
+        gridto.SetColLabelValue(5,'in use')
+
+        nb=gridto.GetNumberRows()
+        if len(self.myvertices)-nb>0:
+            gridto.AppendRows(len(self.myvertices)-nb)
+        k=0
+
+        for curv in self.myvertices:
+           gridto.SetCellValue(k, 5, '1' if curv.in_use else '0')
+           k+=1
+
     def updatefromgrid(self,gridfrom:CpGrid):
         """
         Mise à jour depuis un CpGrid
@@ -3435,6 +3525,12 @@ class vector:
         self.myprop.legendy = centroid.y
         self.myprop.legendtext = text if text else self.myname
 
+    def set_legend_visible(self, visible:bool=True):
+        """
+        Set the visibility of the legend.
+        """
+        self.myprop.legendvisible = visible
+
     def set_legend_position_to_centroid(self):
         """
         Positionne la légende au centre du vecteur
@@ -4045,6 +4141,11 @@ class zone:
             # Object can be created from a shapely object
             self.import_shapelyobj(fromshapely)
 
+    def check_if_interior_exists(self):
+        """ Check if the zone has at least one vector with interior points """
+
+        list(map(lambda curvec: curvec.check_if_interior_exists(), self.myvectors))
+
     def add_values(self, key:str, values:np.ndarray):
         """ add values to the zone """
 
@@ -4052,8 +4153,7 @@ class zone:
             logging.warning(_('Number of vectors and values do not match'))
             return
 
-        for curvec, curval in zip(self.myvectors, values):
-            curvec.add_value(key, curval)
+        list(map(lambda cur: cur[0].add_value(key, cur[1]), zip(self.myvectors, values)))
 
     def get_values(self, key:str) -> np.ndarray:
         """ get values from the zone """
@@ -4063,25 +4163,21 @@ class zone:
     def set_colors_from_value(self, key:str, cmap:wolfpalette | Colormap | cm.ScalarMappable, vmin:float= 0., vmax:float= 1.):
         """ Set the colors for the zone """
 
-        for curvec in self.myvectors:
-            curvec.set_color_from_value(key, cmap, vmin, vmax)
+        list(map(lambda curvec: curvec.set_color_from_value(key, cmap, vmin, vmax), self.myvectors))
 
     def set_alpha(self, alpha:int):
         """ Set the alpha for the zone """
 
-        for curvec in self.myvectors:
-            curvec.set_alpha(alpha)
+        list(map(lambda curvec: curvec.set_alpha(alpha), self.myvectors))
 
     def set_filled(self, filled:bool):
         """ Set the filled for the zone """
 
-        for curvec in self.myvectors:
-            curvec.set_filled(filled)
+        list(map(lambda curvec: curvec.set_filled(filled), self.myvectors))
 
     def check_if_open(self):
         """ Check if the vectors in the zone are open """
-        for curvec in self.myvectors:
-            curvec.check_if_open()
+        list(map(lambda curvect: curvect.check_if_open(), self.myvectors))
 
     def buffer(self, distance:float, resolution:int=16, inplace:bool = False) -> 'zone':
         """ Create a new zone with a buffer around each vector """
@@ -4106,24 +4202,21 @@ class zone:
         Set the legend text for the zone
         """
 
-        for curvect in self.myvectors:
-            curvect.set_legend_text(text)
+        list(map(lambda curvect: curvect.set_legend_text(text), self.myvectors))
 
     def set_legend_text_from_values(self, key:str):
         """
         Set the legend text for the zone from a value
         """
 
-        for curvect in self.myvectors:
-            curvect.set_legend_text_from_value(key)
+        list(map(lambda curvect: curvect.set_legend_text_from_value(key), self.myvectors))
+
 
     def set_legend_position(self, x, y):
         """
         Set the legend position for the zone
         """
-
-        for curvect in self.myvectors:
-            curvect.set_legend_position(x, y)
+        list(map(lambda curvect: curvect.set_legend_position(x, y), self.myvectors))
 
     @property
     def area(self):
@@ -4139,15 +4232,14 @@ class zone:
         """
         Set the cache for the zone and all its vectors
         """
-        for curvect in self.myvectors:
-            curvect.set_cache()
+
+        list(map(lambda curvect: curvect.set_cache(), self.myvectors))
 
     def clear_cache(self):
         """
         Clear the cache for the zone and all its vectors
         """
-        for curvect in self.myvectors:
-            curvect.clear_cache()
+        list(map(lambda curvect: curvect.clear_cache(), self.myvectors))
 
         self._move_start = None
         self._move_step = None
@@ -4507,8 +4599,9 @@ class zone:
         else:
             fig = ax.figure
 
-        for curvect in self.myvectors:
-            curvect.plot_matplotlib(ax)
+        # for curvect in self.myvectors:
+        #     curvect.plot_matplotlib(ax)
+        list(map(lambda curvect: curvect.plot_matplotlib(ax), self.myvectors))
 
         return fig, ax
 
@@ -6199,9 +6292,13 @@ class zone:
         """
         Set the legend to the centroid of the vectors
         """
+        list(map(lambda curvec: curvec.set_legend_to_centroid(), self.myvectors))
 
-        for curvec in self.myvectors:
-            curvec.set_legend_position_to_centroid()
+    def set_legend_visible(self, visible:bool=True):
+        """
+        Set the visibility of the legend for all vectors in the zone
+        """
+        list(map(lambda curvec: curvec.set_legend_visible(visible), self.myvectors))
 
 class Zones(wx.Frame, Element_To_Draw):
     """
@@ -6410,6 +6507,11 @@ class Zones(wx.Frame, Element_To_Draw):
 
         return [curzone.myname for curzone in self.myzones]
 
+    def check_if_interior_exists(self):
+        """ Check if the zone has at least one vector with interior points """
+        for curzone in self.myzones:
+            curzone.check_if_interior_exists()
+
     def add_values(self, key:str, values:np.ndarray | dict):
         """
         Add values to the zones
@@ -6910,7 +7012,7 @@ class Zones(wx.Frame, Element_To_Draw):
                 curvect.myprop.color = curcolor
                 curvect.myprop.alpha = 180
                 curvect.myprop.transparent = True
-                curvect.myprop.filled = filled
+                curvect.myprop.filled = filled and curvect.closed
 
     def set_width(self, width:int) -> None:
         """ Change with of all vectors in all zones """
@@ -7351,6 +7453,10 @@ class Zones(wx.Frame, Element_To_Draw):
             self.updatevertices.SetToolTip(_("Transfer the coordinates from the editor to the memory and update the plot"))
             self.updatevertices.Bind(wx.EVT_BUTTON,self.Onupdatevertices)
 
+            self._test_interior = wx.Button(self,label=_('Test interior'))
+            self._test_interior.SetToolTip(_("Test if some segments of the active vector are exactly the same"))
+            self._test_interior.Bind(wx.EVT_BUTTON,self.Ontest_interior)
+
             self.plot_mpl = wx.Button(self,label=_('Plot xy'))
             self.plot_mpl.SetToolTip(_("Plot the active vector in a new window (matplotlib)"))
             self.plot_mpl.Bind(wx.EVT_BUTTON,self.Onplotmpl)
@@ -7360,7 +7466,7 @@ class Zones(wx.Frame, Element_To_Draw):
             self.plot_mplsz.Bind(wx.EVT_BUTTON,self.Onplotmplsz)
 
             sizer_add_update.Add(self.addrows,1, wx.EXPAND)
-            sizer_add_update.Add(self.updatevertices,3, wx.EXPAND)
+            sizer_add_update.Add(self.updatevertices, 1, wx.EXPAND)
             sizer_add_update.Add(self.plot_mpl,1, wx.EXPAND)
             sizer_add_update.Add(self.plot_mplsz,1, wx.EXPAND)
 
@@ -7516,6 +7622,8 @@ class Zones(wx.Frame, Element_To_Draw):
 
             box_interp_indices = wx.BoxSizer(wx.HORIZONTAL)
             box_interp_indices.Add(self.interpxyz,1,wx.EXPAND)
+            box_interp_indices.Add(self._test_interior, 1, wx.EXPAND)
+
 
             boxright.Add(box_interp_indices,0,wx.EXPAND)
 
@@ -7691,7 +7799,7 @@ class Zones(wx.Frame, Element_To_Draw):
             self.fill_structure()
 
             self.treelist.SetSize(200,500)
-            self.SetSize(600,700)
+            self.SetSize(650,700)
 
             self.SetSizer(box)
 
@@ -9062,6 +9170,18 @@ class Zones(wx.Frame, Element_To_Draw):
         self.active_vector.updatefromgrid(self.xls)
         self.find_minmax(True)
 
+    def Ontest_interior(self, event:wx.MouseEvent):
+        """ Test if the active vector has interior portions """
+        if self.verify_activevec():
+            return
+
+        self.active_vector.check_if_interior_exists()
+
+        self.active_vector._fillgrid_only_i(self.xls)
+
+        self.get_mapviewer().Paint()
+
+
     def Onplotmpl(self, event:wx.MouseEvent):
         """
         Plot active vector in matplotlib

wolfhece/apps/version.py

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