wolfhece 2.1.123__py3-none-any.whl → 2.1.125__py3-none-any.whl

wolfhece/apps/version.py

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

wolfhece/lazviewer/laz_viewer.py

@@ -123,7 +123,7 @@ class Classification_LAZ():
 def choices_laz_colormap() -> list[str]:
 
     choices = [cur.name for cur in Colors_Lazviewer]
-    values  = [cur.value for cur in Colors_Lazviewer]
+    values  = [cur for cur in Colors_Lazviewer]
 
     return choices, values
 
@@ -699,8 +699,8 @@ class xyz_laz_grids():
         figmpl = MplFig(PRESET_LAYOUTS.DEFAULT)
 
         logging.info(_('Plotting'))
-        figmpl.plot(up_s,   up_z,  c=up_color  ,marker='.')
-        figmpl.plot(down_s, down_z,c=down_color,marker='+')
+        figmpl.scatter(up_s,   up_z,  c=up_color  ,marker='.')
+        figmpl.scatter(down_s, down_z,c=down_color,marker='+')
 
         if show:
             figmpl.Show()
@@ -764,7 +764,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
         self.classification = Classification_LAZ() # Classification of LAZ data --> defining colors if codification is used
         self.classification.init_2023() # Default classification for LAZ data
 
-        self._associated_color:int = Colors_Lazviewer.CODE_2023.value # Associated color type for LAZ data
+        self._associated_color:int = Colors_Lazviewer.CODE_2023 # Associated color type for LAZ data
 
         self.viewer:viewer = None       # PPTK viewer
 
@@ -792,7 +792,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
 
     def serialize(self):
         """ Serialize class : data and attributes """
-        return {'bounds':self._bounds, 'data':str(self._filename) + '.npz', 'associated_color':self._associated_color,
+        return {'bounds':self._bounds, 'data':str(self._filename) + '.npz', 'associated_color':self._associated_color.value,
                 'point_size':self._point_size, 'bg_color':self._bg_color, 'bg_color_top':self._bg_color_top,
                 'bg_color_bottom':self._bg_color_bottom, 'floor_level':self._floor_level, 'floor_color':self._floor_color,
                 'show_grid':self._show_grid, 'show_axis':self._show_axis, 'show_info':self._show_info}
@@ -838,8 +838,12 @@ class Wolf_LAZ_Data(Element_To_Draw):
         return self._associated_color
 
     @associated_color.setter
-    def associated_color(self, value:int):
-        self._associated_color = value
+    def associated_color(self, value:int | Colors_Lazviewer):
+
+        if isinstance(value, int):
+            self._associated_color = Colors_Lazviewer(value)
+        else:
+            self._associated_color = value
         self.set_colors()
 
     def merge(self, other:"Wolf_LAZ_Data"):
@@ -1331,9 +1335,9 @@ class Wolf_LAZ_Data(Element_To_Draw):
         ret = props.addparam('Floor', 'Level', self._floor_level, Type_Param.Float, 'Floor level')
         ret = props.addparam('Floor', 'Color', self._floor_color, Type_Param.Color, 'Floor color')
 
-        ret = props.addparam('Infos', 'Grid', self._show_grid, Type_Param.Logical, 'Show grid')
-        ret = props.addparam('Infos', 'Axis', self._show_axis, Type_Param.Logical, 'Show axis')
-        ret = props.addparam('Infos', 'values', self._show_info, Type_Param.Logical, 'Show info')
+        # ret = props.addparam('Infos', 'Grid', self._show_grid, Type_Param.Logical, 'Show grid')
+        # ret = props.addparam('Infos', 'Axis', self._show_axis, Type_Param.Logical, 'Show axis')
+        # ret = props.addparam('Infos', 'values', self._show_info, Type_Param.Logical, 'Show info')
 
         ret = props.addparam('Points', 'Size', self._point_size, Type_Param.Float, 'Point size')
 
@@ -1426,7 +1430,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
                 xyz[i,0] = float(xls.GetCellValue(i,0))
                 xyz[i,1] = float(xls.GetCellValue(i,1))
                 xyz[i,2] = float(xls.GetCellValue(i,2))
-                codes[i] = int(xls.GetCellValue(i,3))
+                codes[i] = float(xls.GetCellValue(i,3))
         except Exception as e:
             logging.error(e)
             logging.warning(_('Bad values in grid - Check your input'))
@@ -1556,9 +1560,9 @@ class Wolf_LAZ_Data(Element_To_Draw):
         color = np.asarray(props[('Floor', 'Color')])
         self.floor_color(color / 255.)
 
-        self.show_grid(props[('Infos', 'Grid')])
-        self.show_axis(props[('Infos', 'Axis')])
-        self.show_info(props[('Infos', 'values')])
+        # self.show_grid(props[('Infos', 'Grid')])
+        # self.show_axis(props[('Infos', 'Axis')])
+        # self.show_info(props[('Infos', 'values')])
 
         self.point_size = props[('Points', 'Size')]
 
@@ -1568,7 +1572,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
             self._select_only_codes = list(set([int(curcode) for curcode in codes_sel]))
         except Exception as e:
             logging.error(e)
-            logging.warning(_('Nullify selection filter - Check your input'))
+            logging.warning(_('Nullify selection filter - Check your input - Must be a list of integers separated by commas'))
             self._select_only_codes = []
 
     def _fill_props(self, full:bool = False):
@@ -1599,9 +1603,9 @@ class Wolf_LAZ_Data(Element_To_Draw):
             props[('Floor', 'Level')] = self._floor_level
             props[('Floor', 'Color')] = self._floor_color
 
-            props[('Infos', 'Grid')] = self._show_grid
-            props[('Infos', 'Axis')] = self._show_axis
-            props[('Infos', 'values')] = self._show_info
+            # props[('Infos', 'Grid')] = self._show_grid
+            # props[('Infos', 'Axis')] = self._show_axis
+            # props[('Infos', 'values')] = self._show_info
 
             props[('Points', 'Size')] = self._point_size
 
@@ -1610,6 +1614,15 @@ class Wolf_LAZ_Data(Element_To_Draw):
     def show_properties(self):
         """ Surcharged method (see Element_To_Draw) to show properties from MapViewer"""
         if self.viewer is None:
+            logging.info(_('No viewer / No properties'))
+            return
+
+        # test if a connexion exists
+        try:
+            lookat = self.viewer.get('lookat')
+        except:
+            self.viewer = None
+            logging.info(_('No viewer / No properties'))
             return
 
         self._create_props()

wolfhece/matplotlib_fig.py

@@ -2102,13 +2102,13 @@ class Matplotlib_Figure(wx.Frame):
 
         ax.scatter(x, y, **kwargs)
 
-        new_props = Matplolib_line_properties(ax.get_lines()[-1], self._axes_properties[idx_ax])
+        # new_props = Matplolib_line_properties(ax.get_lines()[-1], self._axes_properties[idx_ax])
 
-        if self.wx_exists:
-            new_props.add_props_to_sizer(self._collaps_pane.GetPane(), self._sizer_grid_props)
+        # if self.wx_exists:
+        #     new_props.add_props_to_sizer(self._collaps_pane.GetPane(), self._sizer_grid_props)
 
         ax_prop:Matplotlib_ax_properties = self._axes_properties[idx_ax]
-        ax_prop._lines.append(new_props)
+        # ax_prop._lines.append(new_props)
         ax_prop.get_properties()
 
         if self.wx_exists:

wolfhece/scenario/update_void.py

@@ -150,7 +150,7 @@ class Update_Sim:
         """
         pass
 
-    def update_deck(self, roof:WolfArray):
+    def update_deck(self, deck:WolfArray):
         """
         FR
 

wolfhece/sigmoid/circle_jax.py

@@ -0,0 +1,118 @@
+import jax
+import jax.numpy as jnp
+from jax import jit, vmap
+import matplotlib.pyplot as plt
+import numpy as np
+ 
+# Forcer float32
+jax.config.update("jax_enable_x64", False)
+ 
+# Fonction pour calculer l'aire immergée
+def wet_area(h, R):
+    h = jnp.clip(h, 0, 2 * R)
+    theta = 2 * jnp.arccos(1 - h / R)
+    area = (R**2 / 2) * (theta - jnp.sin(theta))
+    return area
+ 
+# Solution "analytique/numérique" classique pour h
+def analytical_h(R, f):
+    def solve_theta(theta):
+        return (theta - jnp.sin(theta)) / (2 * jnp.pi) - f
+    theta_min, theta_max = jnp.float32(0.0), jnp.float32(2 * jnp.pi)
+    for _ in range(50):
+        theta_mid = (theta_min + theta_max) / 2
+        val = solve_theta(theta_mid)
+        theta_max = jnp.where(val > 0, theta_mid, theta_max)
+        theta_min = jnp.where(val <= 0, theta_mid, theta_min)
+    theta = (theta_min + theta_max) / 2
+    return R * (1 - jnp.cos(theta / 2))
+ 
+# Fonction objectif avec sigmoïde adaptative aux deux bornes
+def objective(h, R, f):
+    total_area = jnp.pi * R**2
+    target_area = f * total_area
+    diff = wet_area(h, R) - target_area
+    # Échelle adaptative : plus kleine pour f près de 0 ou 1
+    scale_factor = jnp.minimum(f, 1. - f)  # Distance au bord le plus proche
+    scale = 0.05 * R**2 * jnp.maximum(scale_factor, 0.01)  # Éviter 0
+    return 1 / (1 + jnp.exp(-diff / scale))
+ 
+# Dichotomie douce améliorée
+@jit
+def soft_dichotomy(R, f, max_iter=200):
+    def body(state, _):
+        h_min, h_max = state
+        h_mid = (h_min + h_max) / 2
+        sigmoid_val = objective(h_mid, R, f)
+        h_min_new = h_min + (h_mid - h_min) * (1 - sigmoid_val)
+        h_max_new = h_max - (h_max - h_mid) * sigmoid_val
+        return (h_min_new, h_max_new), None
+ 
+    # Bornes initiales resserrées pour petits/grands f
+    h_min_init = jnp.float32(0.0)
+    h_max_init = jnp.float32(2 * R)
+    initial_state = (h_min_init, h_max_init)
+    final_state, _ = jax.lax.scan(body, initial_state, None, length=max_iter)
+    h_min, h_max = final_state
+    return (h_min + h_max) / 2
+
+# Dérivée par rapport à f
+grad_bisection = jax.grad(soft_dichotomy, argnums=1)
+ 
+  
+if __name__ == "__main__":
+    # Paramètres
+    R = jnp.float32(1.0)
+    f_values = jnp.linspace(jnp.float32(0.001), jnp.float32(0.999), 500)  # Plus près des bords
+    
+    # Calculs
+    h_numerical = vmap(lambda f: soft_dichotomy(R, f))(f_values)
+    h_analytical = vmap(lambda f: analytical_h(R, f))(f_values)
+    errors = jnp.abs(h_numerical - h_analytical)
+
+    grads = vmap(lambda f: grad_bisection(R, f))(f_values)
+
+    # Graphiques
+    plt.figure(figsize=(12, 5))
+    
+    plt.subplot(1, 3, 1)
+    plt.plot(f_values, h_numerical, label="Numérique (sigmoïde)", color="blue")
+    plt.plot(f_values, h_analytical, "--", label="Analytique", color="orange")
+    plt.xlabel("Fraction immergée (f)")
+    plt.ylabel("Hauteur (h)")
+    plt.title("Hauteur en fonction de f (float32)")
+    plt.legend()
+    plt.grid(True)
+    plt.yscale("log")  # Échelle log pour voir les extrêmes
+    
+    plt.subplot(1, 3, 2)
+    plt.plot(f_values, errors, color="red")
+    plt.xlabel("Fraction immergée (f)")
+    plt.ylabel("Erreur absolue (|h_num - h_ana|)")
+    plt.title("Erreur par rapport à la solution analytique")
+    plt.grid(True)
+    plt.yscale("log")  # Échelle log pour les erreurs
+
+    plt.subplot(1, 3, 3)
+    plt.plot(f_values, grads, label="Dérivée par rapport à f")
+    plt.xlabel("Fraction immergée (f)")
+    plt.ylabel("Gradient de f par rapport à h")
+    plt.legend()
+    plt.grid(True)
+
+    plt.tight_layout()
+    plt.show()
+    
+    # Tests spécifiques aux deux bornes
+    for f_test in [0., 0.001, 0.01, 0.5, 0.99, 0.999]:
+        f_test = jnp.float32(f_test)
+        h_num = soft_dichotomy(R, f_test)
+        h_ana = analytical_h(R, f_test)
+        grad_h = grad_bisection(R, f_test)
+        print(f"f = {f_test:.4f}:")
+        print(f"  h numérique = {h_num:.6f}")
+        print(f"  h analytique = {h_ana:.6f}")
+        print(f"  Gradient de h par rapport à f = {grad_h:.6f}")
+        print(f"  Erreur = {jnp.abs(h_num - h_ana):.6f}")
+        print(f"  Erreur relative = {jnp.abs(h_num - h_ana) / h_ana:.6e}")
+    pass

wolfhece/sigmoid/circle_jax_copilot.py

@@ -0,0 +1,169 @@
+import jax
+import jax.numpy as jnp
+from jax import jit, vmap
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.optimize import minimize, root_scalar
+
+# Forcer float32
+jax.config.update("jax_enable_x64", False)
+
+# Fonction pour calculer l'aire immergée
+def wet_area(h, R):
+    h = jnp.clip(h, 0, 2 * R)
+    theta = 2 * jnp.arccos(1 - h / R)
+    area = (R**2 / 2) * (theta - jnp.sin(theta))
+    return area
+
+# Solution numérique "classique" pour h
+def analytical_h(R, f):
+    def solve_theta(theta):
+        return (theta - jnp.sin(theta)) / (2 * jnp.pi) - f
+    theta_min, theta_max = jnp.float32(0.0), jnp.float32(2 * jnp.pi)
+    for _ in range(50):
+        theta_mid = (theta_min + theta_max) / 2
+        val = solve_theta(theta_mid)
+        theta_max = jnp.where(val > 0, theta_mid, theta_max)
+        theta_min = jnp.where(val <= 0, theta_mid, theta_min)
+    theta = (theta_min + theta_max) / 2
+    return R * (1 - jnp.cos(theta / 2))
+
+# # Fonction objectif avec pondération quadratique
+# def objective(h, R, f):
+#     total_area = jnp.pi * R**2
+#     target_area = f * total_area
+#     diff = wet_area(h, R) - target_area
+#     scale_factor = jnp.minimum(f, 1. - f)
+#     scale = 0.1 * R**2 * (scale_factor**2 + 0.01)  # Échelle quadratique
+#     return 1 / (1 + jnp.exp(-diff / scale))
+
+# def objective(h, R, f):
+#     total_area = jnp.pi * R**2
+#     target_area = f * total_area
+#     diff = wet_area(h, R) - target_area
+#     scale_factor = jnp.minimum(f, 1. - f)
+#     scale = 0.1 * R**2 * jnp.maximum(scale_factor, 0.01)
+#     return 0.5 * (1 + jnp.tanh(diff / scale))
+
+
+# Fonction objectif avec lissage (inchangée)
+def objective(h, R, f):
+    total_area = jnp.pi * R**2
+    target_area = f * total_area
+    diff = wet_area(h, R) - target_area
+    scale_factor = jnp.minimum(f, 1. - f)
+    scale = 0.05 * R**2 * jnp.maximum(scale_factor, 0.01)
+    return 1 / (1 + jnp.exp(-diff / scale))
+
+# Dichotomie douce avec préservation de la racine
+@jit
+def soft_dichotomy(R, f, max_iter=10000):
+    f_sym = jnp.minimum(f, 1 - f)
+
+    def body(state, _):
+        h_min, h_max = state
+        h_mid = (h_min + h_max) / 2
+        sigmoid_val = objective(h_mid, R, f_sym)
+
+        # Différences pour h_min, h_mid et h_max
+        diff_min = wet_area(h_min, R) - f_sym * jnp.pi * R**2
+        diff_max = wet_area(h_max, R) - f_sym * jnp.pi * R**2
+
+        # Facteurs de préservation lisses
+        preserve_min = jnp.exp(-jnp.abs(diff_min) / (0.01))  # Proche de 1 si h_min est racine
+        preserve_max = jnp.exp(-jnp.abs(diff_max) / (0.01))  # Proche de 1 si h_max est racine
+
+        # Mise à jour des bornes avec préservation
+        h_min_new = h_min + (1. - preserve_min) * (h_mid - h_min) * (1. - sigmoid_val)
+        h_max_new = h_max - (1. - preserve_max) * (h_max - h_mid) * sigmoid_val
+
+        # # Garantie que h_min_new < h_max_new
+        # h_min_new = jnp.minimum(h_min_new, h_mid - 0.01 * R)
+        # h_max_new = jnp.maximum(h_max_new, h_mid + 0.01 * R)
+
+        return (h_min_new, h_max_new), None
+
+    h_min_init = jnp.float32(0.0)
+    h_max_init = jnp.float32(2 * R)
+    initial_state = (h_min_init, h_max_init)
+    final_state, _ = jax.lax.scan(body, initial_state, None, length=max_iter)
+    h_min, h_max = final_state
+    h_sym = (h_min + h_max) / 2
+    return jnp.where(f <= 0.5, h_sym, 2 * R - h_sym)
+
+# Dérivée par rapport à f
+grad_bisection = jax.grad(soft_dichotomy, argnums=1)
+
+# Fonction objectif avec lissage
+def section(h, R, f):
+    total_area = jnp.pi * R**2
+    target_area = f * total_area
+    return wet_area(jnp.clip(h, 0, 2 * R), R) - target_area
+
+grad_section = jax.grad(section, argnums=0)
+
+# recherche de la recine de la section
+def find_root(R, f):
+    def fun(h):
+        return section(h, R, f)
+    def grad(h):
+        return grad_section(h, R, f)
+
+    h_root = root_scalar(fun, fprime=grad, x0=R)
+    return h_root.root
+
+h = find_root(1.,0.5)
+pass
+
+if __name__ == "__main__":
+    R = jnp.float32(1.0)
+    f_values = jnp.linspace(jnp.float32(0.00), jnp.float32(1.), 5000, endpoint=True)
+
+    h_numerical = vmap(lambda f: soft_dichotomy(R, f))(f_values)
+    h_analytical = vmap(lambda f: analytical_h(R, f))(f_values)
+    errors = jnp.abs(h_numerical - h_analytical)
+
+    grads = vmap(lambda f: grad_bisection(R, f))(f_values)
+
+    plt.figure(figsize=(12, 5))
+
+    plt.subplot(1, 3, 1)
+    plt.plot(f_values, h_numerical, label="Numérique (symétrie centrale)", color="blue")
+    plt.plot(f_values, h_analytical, "--", label="Analytique", color="orange")
+    plt.xlabel("Fraction immergée (f)")
+    plt.ylabel("Hauteur (h)")
+    plt.title("Hauteur en fonction de f (float32)")
+    plt.legend()
+    plt.grid(True)
+    # plt.yscale("log")
+
+    plt.subplot(1, 3, 2)
+    plt.plot(f_values, errors, color="red")
+    plt.xlabel("Fraction immergée (f)")
+    plt.ylabel("Erreur absolue (|h_num - h_ana|)")
+    plt.title("Erreur par rapport à la solution analytique")
+    plt.grid(True)
+    plt.yscale("log")
+
+    plt.subplot(1, 3, 3)
+    plt.plot(f_values, grads, label="Dérivée par rapport à f")
+    plt.xlabel("Fraction immergée (f)")
+    plt.ylabel("Gradient de f par rapport à h")
+    plt.legend()
+    plt.grid(True)
+
+    plt.tight_layout()
+    plt.show()
+
+    for f_test in [0., 0.001, 0.01, 0.5, 0.99, 0.999]:
+        f_test = jnp.float32(f_test)
+        h_num = soft_dichotomy(R, f_test)
+        h_ana = analytical_h(R, f_test)
+        grad_h = grad_bisection(R, f_test)
+        print(f"f = {f_test:.4f}:")
+        print(f"  h numérique = {h_num:.6f}")
+        print(f"  h analytique = {h_ana:.6f}")
+        print(f"  Gradient de h par rapport à f = {grad_h:.6f}")
+        print(f"  Erreur = {jnp.abs(h_num - h_ana):.6f}")
+        print(f"  Erreur relative = {jnp.abs(h_num - h_ana) / h_ana:.6e}")
+    pass