wolfhece 2.0.13__py3-none-any.whl → 2.0.15__py3-none-any.whl

wolfhece/shaders/quad_geom_shader.glsl

@@ -1,33 +1,258 @@
 #version 460 core
 
 layout (points) in;
-layout (triangle_strip, max_vertices = 4) out;
+layout (triangle_strip, max_vertices = 20) out;
 
-uniform sampler2D texture;
+uniform sampler2DRect zText;
 uniform float zScale;
 uniform float dx;
+uniform float dy;
 uniform float origx;
 uniform float origy;
+uniform float width;
+uniform float height;
+uniform mat4 mvp;
+uniform int idx;
 
-void main() {
+uniform sampler1D colorPalette;  // Texture de gradient représentant la palette de couleurs
+
+uniform int paletteSize;  // Taille de la palette
+uniform float colorValues[256];  // Tableau de couleurs de la palette
+
+out vec3 ourColor;
+out vec3 Normal;   // Normale du fragment dans l'espace du monde
+out vec4 FragPos;  // Position du fragment dans l'espace du monde
+out vec3 ourCoord;
+
+vec3 mapColor(float zValue) {
+    float zColor = 0.0;
+
+    // Mapper la valeur sur base d'intervalles
+    if (zValue <= colorValues[0]) {
+        zColor = 0.0;
+    }
+    else if (zValue >= colorValues[paletteSize-1]) {
+        zColor = 1.0;
+    }
+    else {
+        for (int i = 1; i < paletteSize; i++) {
+        if (zValue <= colorValues[i]) {
+            float lower = colorValues[i-1];
+            float upper = colorValues[i];
+
+            zColor = ((zValue - lower) / (upper - lower) + float(i-1)) / float(paletteSize-1);
+
+            break;
+        }
+        }
+    }
+
+    // Interpoler entre les couleurs dans la palette
+    return texture(colorPalette, zColor).rgb;
+}
+
+float get_value(sampler2DRect tex, vec2 pos) {
+
+    float posx = (pos.x - origx) / dx;
+    float posy = (pos.y - origy) / dy;
+
+    vec2 texCoord = vec2(posx, posy);
+
+    float zValue = texture(tex, texCoord).r * zScale;
+    return zValue;
+}
+
+void horizontal(){
 
     float halfdx = dx/2.0;
+    float halfdy = dy/2.0;
+
+    float zValue = get_value(zText, gl_in[0].gl_Position.xy);
+    float zColor = 0.0;
 
-    vec2 texCoord = (gl_in[0].gl_Position.xy - vec2(origx, origy)) / dx + 0.5;
+    vec3 color = mapColor(zValue);
 
-    float zValue = texture(texture, texCoord).r * zScale;
+    float posx = (gl_in[0].gl_Position.x - origx) / dx ;// /width;
+    float posy = (gl_in[0].gl_Position.y - origy) / dy ;// /height;
+    ourCoord = vec3(posx, posy, idx);
 
-    gl_Position = vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y - halfdx, zValue, 1.0);
+    gl_Position = mvp * vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y - halfdy, zValue, 1.0);
+    ourColor = color;
+    Normal = vec3(0.0, 0.0, 1.0);
+    FragPos = vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y - halfdy, zValue, 1.0);
     EmitVertex();
 
-    gl_Position = vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y - halfdx, zValue, 1.0);
+    gl_Position = mvp * vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y - halfdy, zValue, 1.0);
+    ourColor = color;
+    Normal = vec3(0.0, 0.0, 1.0);
+    FragPos = vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y - halfdy, zValue, 1.0);
     EmitVertex();
 
-    gl_Position = vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y + halfdx, zValue, 1.0);
+    gl_Position = mvp * vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y + halfdy, zValue, 1.0);
+    ourColor = color;
+    Normal = vec3(0.0, 0.0, 1.0);
+    FragPos = vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y + halfdy, zValue, 1.0);
     EmitVertex();
 
-    gl_Position = vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y + halfdx, zValue, 1.0);
+    gl_Position = mvp * vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y + halfdy, zValue, 1.0);
+    ourColor = color;
+    Normal = vec3(0.0, 0.0, 1.0);
+    FragPos = vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y + halfdy, zValue, 1.0);
     EmitVertex();
 
     EndPrimitive();
+
+}
+
+void walls(){
+
+    float halfdx = dx/2.0;
+    float halfdy = dy/2.0;
+
+    vec2 posCenter = gl_in[0].gl_Position.xy;
+    vec2 posLeft   = vec2(posCenter.x - dx, posCenter.y);
+    vec2 posRight  = vec2(posCenter.x + dx, posCenter.y);
+    vec2 posUp     = vec2(posCenter.x     , posCenter.y + dy);
+    vec2 posDown   = vec2(posCenter.x     , posCenter.y - dy);
+
+    vec2 texCenter = vec2(((posCenter.x - origx) / dx ), ((posCenter.y - origy) / dy));
+    vec2 texLeft = vec2(((posLeft.x - origx) / dx ), ((posLeft.y - origy) / dy));
+    vec2 texRight = vec2(((posRight.x - origx) / dx ), ((posRight.y - origy) / dy));
+    vec2 texUp = vec2(((posUp.x - origx) / dx ), ((posUp.y - origy) / dy));
+    vec2 texDown = vec2(((posDown.x - origx) / dx ), ((posDown.y - origy) / dy));
+
+    // float zCenter = texture(zText, texCenter).r * zScale;
+    // float zLeft = texture(zText, texLeft).r * zScale;
+    // float zRight = texture(zText, texRight).r * zScale;
+    // float zUp = texture(zText, texUp).r * zScale;
+    // float zDown = texture(zText, texDown).r * zScale;
+
+    float zCenter = get_value(zText, posCenter);
+    float zLeft = get_value(zText, posLeft);
+    float zRight = get_value(zText, posRight);
+    float zUp = get_value(zText, posUp);
+    float zDown = get_value(zText, posDown);
+
+    if (zCenter > zLeft) {
+        gl_Position = mvp * vec4(posCenter.x - halfdx, posCenter.y - halfdy, zCenter, 1.0);
+        ourColor = mapColor(zCenter);
+        Normal = vec3(-1.0, 0.0, 0.0);
+        FragPos = vec4(posCenter.x - halfdx, posCenter.y - halfdy, zCenter, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x - halfdx, posCenter.y + halfdy, zCenter, 1.0);
+        ourColor = mapColor(zCenter);
+        Normal = vec3(-1.0, 0.0, 0.0);
+        FragPos = vec4(posCenter.x - halfdx, posCenter.y + halfdy, zCenter, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x - halfdx, posCenter.y - halfdy, zLeft, 1.0);
+        ourColor = mapColor(zLeft);
+        Normal = vec3(-1.0, 0.0, 0.0);
+        FragPos = vec4(posCenter.x - halfdx, posCenter.y - halfdy, zLeft, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x - halfdx, posCenter.y + halfdy, zLeft, 1.0);
+        ourColor = mapColor(zLeft);
+        Normal = vec3(-1.0, 0.0, 0.0);
+        FragPos = vec4(posCenter.x - halfdx, posCenter.y + halfdy, zLeft, 1.0);
+        EmitVertex();
+
+        EndPrimitive();
+    }
+
+    if (zCenter > zRight) {
+        gl_Position = mvp * vec4(posCenter.x + halfdx, posCenter.y - halfdy, zCenter, 1.0);
+        ourColor = mapColor(zCenter);
+        Normal = vec3(1.0, 0.0, 0.0);
+        FragPos = vec4(posCenter.x + halfdx, posCenter.y - halfdy, zCenter, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x + halfdx, posCenter.y + halfdy, zCenter, 1.0);
+        ourColor = mapColor(zCenter);
+        Normal = vec3(1.0, 0.0, 0.0);
+        FragPos = vec4(posCenter.x + halfdx, posCenter.y + halfdy, zCenter, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x + halfdx, posCenter.y - halfdy, zRight, 1.0);
+        ourColor = mapColor(zRight);
+        Normal = vec3(1.0, 0.0, 0.0);
+        FragPos = vec4(posCenter.x + halfdx, posCenter.y - halfdy, zRight, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x + halfdx, posCenter.y + halfdy, zRight, 1.0);
+        ourColor = mapColor(zRight);
+        Normal = vec3(1.0, 0.0, 0.0);
+        FragPos = vec4(posCenter.x + halfdx, posCenter.y + halfdy, zRight, 1.0);
+        EmitVertex();
+
+        EndPrimitive();
+    }
+
+    if (zCenter > zUp) {
+        gl_Position = mvp * vec4(posCenter.x - halfdx, posCenter.y + halfdy, zCenter, 1.0);
+        ourColor = mapColor(zCenter);
+        Normal = vec3(0.0, 1.0, 0.0);
+        FragPos = vec4(posCenter.x - halfdx, posCenter.y + halfdy, zCenter, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x + halfdx, posCenter.y + halfdy, zCenter, 1.0);
+        ourColor = mapColor(zCenter);
+        Normal = vec3(0.0, 1.0, 0.0);
+        FragPos = vec4(posCenter.x + halfdx, posCenter.y + halfdy, zCenter, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x - halfdx, posCenter.y + halfdy, zUp, 1.0);
+        ourColor = mapColor(zUp);
+        Normal = vec3(0.0, 1.0, 0.0);
+        FragPos = vec4(posCenter.x - halfdx, posCenter.y + halfdy, zUp, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x + halfdx, posCenter.y + halfdy, zUp, 1.0);
+        ourColor = mapColor(zUp);
+        Normal = vec3(0.0, 1.0, 0.0);
+        FragPos = vec4(posCenter.x + halfdx, posCenter.y + halfdy, zUp, 1.0);
+        EmitVertex();
+
+        EndPrimitive();
+    }
+
+    if (zCenter > zDown) {
+        gl_Position = mvp * vec4(posCenter.x - halfdx, posCenter.y - halfdy, zCenter, 1.0);
+        ourColor = mapColor(zCenter);
+        Normal = vec3(0.0, -1.0, 0.0);
+        FragPos = vec4(posCenter.x - halfdx, posCenter.y - halfdy, zCenter, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x + halfdx, posCenter.y - halfdy, zCenter, 1.0);
+        ourColor = mapColor(zCenter);
+        Normal = vec3(0.0, -1.0, 0.0);
+        FragPos = vec4(posCenter.x + halfdx, posCenter.y - halfdy, zCenter, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x - halfdx, posCenter.y - halfdy, zDown, 1.0);
+        ourColor = mapColor(zDown);
+        Normal = vec3(0.0, -1.0, 0.0);
+        FragPos = vec4(posCenter.x - halfdx, posCenter.y - halfdy, zDown, 1.0);
+        EmitVertex();
+
+        gl_Position = mvp * vec4(posCenter.x + halfdx, posCenter.y - halfdy, zDown, 1.0);
+        ourColor = mapColor(zDown);
+        Normal = vec3(0.0, -1.0, 0.0);
+        FragPos = vec4(posCenter.x + halfdx, posCenter.y - halfdy, zDown, 1.0);
+        EmitVertex();
+
+        EndPrimitive();
+    }
+
+
+}
+
+
+void main() {
+
+    horizontal();
+    walls();
+
+
 }

wolfhece/shaders/quadpos_frag_shader.glsl

@@ -0,0 +1,12 @@
+#version 460 core
+
+in vec4 gl_FragCoord ;
+in vec3 ourColor;
+
+out vec4 FragColor;
+
+void main() {
+
+    FragColor = vec4(ourColor, 1.);
+    
+}

wolfhece/shaders/quadpos_geom_shader.glsl

@@ -0,0 +1,76 @@
+#version 460 core
+
+layout (points) in;
+layout (triangle_strip, max_vertices = 20) out;
+
+uniform sampler2DRect zText;
+uniform float zScale;
+uniform float dx;
+uniform float dy;
+uniform float origx;
+uniform float origy;
+uniform mat4 mvp;
+
+uniform sampler1D colorPalette;  // Texture de gradient représentant la palette de couleurs
+
+uniform int paletteSize;  // Taille de la palette
+uniform float colorValues[256];  // Tableau de couleurs de la palette
+
+out vec3 ourColor;
+out vec4 FragPos;  // Position du fragment dans l'espace du monde
+
+
+float get_value(sampler2DRect tex, vec2 pos) {
+
+    float posx = (pos.x - origx) / dx;
+    float posy = (pos.y - origy) / dy;
+
+    vec2 texCoord = vec2(posx, posy);
+
+    float zValue = texture(tex, texCoord).r * zScale;
+    return zValue;
+}
+
+void horizontal(){
+
+    float halfdx = dx/2.0;
+    float halfdy = dy/2.0;
+
+    float zValue = get_value(zText, gl_in[0].gl_Position.xy);
+    float zColor = 0.0;
+
+    // float posx = (gl_in[0].gl_Position.x - origx) / dx;
+    // float posy = (gl_in[0].gl_Position.y - origy) / dy;
+    float posx = 1.;
+    float posy = 1.;
+
+    gl_Position = mvp * vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y - halfdy, zValue, 1.0);
+    ourColor = vec3(1.,0.,0.);
+    FragPos = vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y - halfdy, zValue, 1.0);
+    EmitVertex();
+
+    gl_Position = mvp * vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y - halfdy, zValue, 1.0);
+    ourColor = vec3(0.,1.,0.);
+    FragPos = vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y - halfdy, zValue, 1.0);
+    EmitVertex();
+
+    gl_Position = mvp * vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y + halfdy, zValue, 1.0);
+    ourColor = vec3(0.,0.,1.);
+    FragPos = vec4(gl_in[0].gl_Position.x - halfdx, gl_in[0].gl_Position.y + halfdy, zValue, 1.0);
+    EmitVertex();
+
+    gl_Position = mvp * vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y + halfdy, zValue, 1.0);
+    ourColor = vec3(1.,0.,0.);
+    FragPos = vec4(gl_in[0].gl_Position.x + halfdx, gl_in[0].gl_Position.y + halfdy, zValue, 1.0);
+    EmitVertex();
+
+    EndPrimitive();
+
+}
+
+
+void main() {
+
+    horizontal();
+
+}

wolfhece/shaders/simple_fragment_shader.glsl

@@ -2,7 +2,10 @@
 in vec3 ourColor;
 out vec4 FragColor;
 
+out vec2 FragCoord;
+
 void main()
 {
-FragColor = vec4(ourColor, 1.0);
+    FragColor = vec4(ourColor, 1.0);
+    FragCoord = gl_FragCoord.xy;
 }

wolfhece/shaders/simple_vertex_shader_mvp.glsl

@@ -0,0 +1,13 @@
+#version 460 core
+layout (location = 0) in vec3 aVertex;
+layout (location = 1) in vec3 aColor;
+
+out vec3 ourColor;
+
+uniform mat4 mvp;
+
+void main()
+{
+    gl_Position = mvp * vec4(aVertex, 1.0);
+    ourColor = aColor;
+}

wolfhece/shaders/vertex_shader_texture.glsl

@@ -0,0 +1,15 @@
+#version 460
+
+in vec3 aPos;
+in vec2 InTexCoords;
+
+out vec2 OutTexCoords;
+
+uniform mat4 transform;
+
+void main() {
+
+    gl_Position = transform * vec4(aPos, 1.0f);
+    OutTexCoords = InTexCoords;
+
+    }

wolfhece/wolf_array.py

@@ -56,6 +56,7 @@ from .xyz_file import XYZFile
 from .PyPalette import wolfpalette
 from .PyVertexvectors import Zones, vector, wolfvertex, zone, Triangulation
 from .PyVertex import cloud_vertices
+from .opengl.py3d import Cache_WolfArray_plot3D, WolfArray_plot3D
 
 WOLF_ARRAY_HILLSHAPE = -1
 WOLF_ARRAY_FULL_SINGLE = 1
@@ -2375,14 +2376,14 @@ class Ops_Array(wx.Frame):
             return
 
         curcol = dlg.GetColourData()
-        dlg.Destroy()
-
         rgb = curcol.GetColour()
 
-        k = gridto.GetGridCursorRow()
+
+        # k = gridto.GetGridCursorRow()
         gridto.SetCellValue(k, 1, str(rgb.red))
         gridto.SetCellValue(k, 2, str(rgb.green))
         gridto.SetCellValue(k, 3, str(rgb.blue))
+        dlg.Destroy()
 
 
 class SelectionData():
@@ -3374,6 +3375,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.mypal.automatic = True
         self.mygrid = {}
 
+        self._array3d = None
+        self.viewers3d:list[WolfArray_plot3D] = []
+
         self.cropini = crop
 
         if isinstance(srcheader, header_wolf):
@@ -3441,6 +3445,37 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
 
+    def get_centers(self, usenap:bool = True):
+        """ Get the centers of the cells """
+
+        if usenap:
+            ij = np.where(self.array.mask==False,)
+            xy = self.get_xy_from_ij_array(np.vstack((ij[0], ij[1])).T).copy().flatten()
+        else:
+            ij = np.meshgrid(np.arange(self.nbx), np.arange(self.nby))
+            ij = np.asarray([ij[0].flatten(), ij[1].flatten()]).T
+            xy = self.get_xy_from_ij_array(ij).copy().flatten()
+
+        return xy.astype(np.float32)
+
+    def prepare_3D(self):
+        """ Prepare the array for 3D display """
+
+        if self.array.ndim != 2:
+            logging.error(_('Array is not 2D'))
+            return
+
+        self._quads = self.get_centers()
+        ztext = np.require(self.array.data, dtype=np.float32, requirements=['F'])
+        ztext[self.array.mask] = self.array.min()
+        self._array3d = WolfArray_plot3D(self._quads,
+                                         self.dx, self.dy,
+                                         self.origx, self.origy,
+                                         zscale = 1.,
+                                         ztexture = ztext,
+                                         color_palette=self.mypal.get_colors_f32().flatten(),
+                                         color_values=self.mypal.values.astype(np.float32))
+
     def check_bounds_ij(self, i:int, j:int):
         """Check if i and j are inside the array bounds"""
         return i>=0 and j>=0 and i<self.nbx and j<self.nby
@@ -3517,17 +3552,20 @@ class WolfArray(Element_To_Draw, header_wolf):
             if id(cur.mypal) != id(self.mypal):
                 cur.mypal = self.mypal
 
-    def filter_inundation(self,eps):
+    def filter_inundation(self, epsilon:float = None, mask:np.ndarray = None):
         """
         Apply filter on array :
             - mask data below eps
             - mask data outisde linkedvec
         """
-        self.array[np.where(self.array<eps)] = 0.
+        if epsilon is not None:
+            self.array[np.where(self.array<epsilon)] = self.nullvalue
+        elif mask is not None:
+            self.array.data[mask] = self.nullvalue
 
         idx_nan  = np.where(np.isnan(self.array))
         if len(idx_nan[0])>0:
-            self.array[idx_nan] = 0.
+            self.array[idx_nan] = self.nullvalue
             self.array.mask[idx_nan] = True
             logging.warning(_('NaN values found in the array'))
             for i,j in zip(idx_nan[0],idx_nan[1]):
@@ -4516,7 +4554,8 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if not self.loaded and self.filename != '':
             # if not loaded, load it
-            self.read_data()
+            self.read_all()
+            # self.read_data()
             if self.masknull:
                 self.mask_data(self.nullvalue)
 
@@ -5590,12 +5629,17 @@ class WolfArray(Element_To_Draw, header_wolf):
                 self.rgb[pond<0,i] = self.rgb[pond<0,i] * (1.+pond[pond<0]) - pmin[pond<0,i] * pond[pond<0]
                 self.rgb[pond>0,i] = self.rgb[pond>0,i] * (1.-pond[pond>0]) + pmax[pond>0,i] * pond[pond>0]
 
-        self.rgb[self.array.mask] = [1., 1., 1., 1.]
+        self.rgb[self.array.mask] = [1., 1., 1., 0.]
 
         if self.myops is not None:
             # update the wx
             self.myops.update_palette()
 
+        if len(self.viewers3d) > 0:
+            for cur in self.viewers3d:
+                cur.update_palette(self.idx, self.mypal.get_colors_f32().flatten(), self.mypal.values.astype(np.float32))
+
+
     def plot(self, sx:float=None, sy:float=None, xmin:float=None, ymin:float=None, xmax:float=None, ymax:float=None, size:float=None):
         """
         Plot the array - OpenGL

wolfhece/wolfresults_2D.py

@@ -353,7 +353,7 @@ class Props_Res_2D(wx.Frame):
         Toolssizer = wx.BoxSizer(wx.VERTICAL)
         hbox = wx.BoxSizer(wx.HORIZONTAL)
         self._label_nullvalue = wx.StaticText(self._tools,label=_('Epsilon'))
-        self._txt_nullvalue = wx.TextCtrl(self._tools,value=str(self._parent.nullvalue), style=wx.TE_CENTER)
+        self._txt_nullvalue = wx.TextCtrl(self._tools,value=str(self._parent.epsilon), style=wx.TE_CENTER)
         self._txt_nullvalue.SetToolTip(_('Epsilon value under which the value is not plotted'))
         hbox.Add(self._label_nullvalue, 0, wx.EXPAND|wx.ALL)
         hbox.Add(self._txt_nullvalue, 1, wx.EXPAND|wx.ALL)
@@ -621,7 +621,7 @@ class Props_Res_2D(wx.Frame):
         if self._parent.nullvalue == np.nan:
             self._txt_nullvalue.Value = 'nan'
         else :
-            self._txt_nullvalue.Value = str(self._parent.nullvalue)
+            self._txt_nullvalue.Value = str(self._parent.epsilon)
 
         self.update_palette()
 
@@ -634,8 +634,8 @@ class Props_Res_2D(wx.Frame):
         else:
             newnull = float(newnull)
 
-        if self._parent.nullvalue != newnull:
-            self._parent.nullvalue = newnull
+        if self._parent.epsilon != newnull:
+            self._parent.epsilon = newnull
             self._parent.read_oneresult(self._parent.current_result)
             self._parent.set_currentview()
 
@@ -1417,7 +1417,8 @@ class OneWolfResult:
             - mask data below eps
             - mask data outisde linkedvec
         """
-        self._current.filter_inundation(self.epsilon)
+        mask = self.waterdepth.array < self.epsilon
+        self._current.filter_inundation(mask = mask)
 
     def set_current(self,which):
         self._which_current = which
@@ -1568,6 +1569,7 @@ class OneWolfResult:
 
         self._current.linkedvec = self.linkedvec
         self._current.idx = self.idx
+        self._current.nullvalue = self.waterdepth.nullvalue
 
     @property
     def min_field_size(self):
@@ -2032,14 +2034,14 @@ class Wolfresults_2D(Element_To_Draw):
 
         return x>=xmin and x<=xmax and y>=ymin and y<=ymax
 
-    @property
-    def nullvalue(self):
-        return self.epsilon
+    # @property
+    # def nullvalue(self):
+    #     return self.epsilon
 
-    @nullvalue.setter
-    def nullvalue(self, value):
-        self._epsilon_default = value
-        self.epsilon = self._epsilon_default
+    # @nullvalue.setter
+    # def nullvalue(self, value):
+    #     self._epsilon_default = value
+    #     self.epsilon = self._epsilon_default
 
     @property
     def alpha(self):

{wolfhece-2.0.13.dist-info → wolfhece-2.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.0.13
+Version: 2.0.15
 Author-email: Stéphane Champailler <stephane.champailler@uliege.be>, Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece
@@ -51,6 +51,7 @@ Requires-Dist: xarray
 Requires-Dist: rasterio
 Requires-Dist: h5py
 Requires-Dist: basemap
+Requires-Dist: exif
 
 Ce paquet contient l'interface graphique Python du logiciel WOLF (HECE - ULiège) de même que plusieurs outils de traitements topographique, hydraulique et hydrologique.