wolfhece 2.1.124__py3-none-any.whl → 2.1.126__py3-none-any.whl

wolfhece/apps/version.py

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

wolfhece/lazviewer/laz_viewer.py

@@ -17,6 +17,7 @@ from matplotlib.figure import Figure
 from shapely.geometry import LineString, Point, CAP_STYLE, Polygon
 from shapely.ops import prep
 import wx
+from tqdm import tqdm
 
 from . import viewer
 from ..PyWMS import getWalonmap
@@ -41,6 +42,7 @@ class Colors_Lazviewer(Enum):
     ORTHO_2006_2007 = 2006
     CODE_2013 = 0
     CODE_2023 = 2
+    CODE_2021_2022 = 3
     FROM_FILE = 1
 
 class Classification_LAZ():
@@ -68,6 +70,18 @@ class Classification_LAZ():
             9  : ['Eau', 'Eau',Colors.rgb_withalpha_float('aqua',1.)],
             10 : ['Ponts', 'Ponts',Colors.rgb_withalpha_float('lightyellow1',1.)]}
 
+    def init_2021_2022(self):
+
+        self.class_name = 'SPW 2021-2022'
+        self.classification={
+            0  : ['0', 'Pas de classification', Colors.rgb_withalpha_float('black',.2),],
+            1  : ['Hors-sol', 'building, toits et autres', Colors.rgb_withalpha_float('white',.2),],
+            2  : ['Sol', 'y compris talus et digues', Colors.rgb_withalpha_float('brown',1.)],
+            4  : ['Végétation', 'y compris la végétation linéaire', Colors.rgb_withalpha_float('forestgreen',1.)],
+            9  : ['Eau', 'Eau',Colors.rgb_withalpha_float('aqua',1.)],
+            10 : ['Ponts', 'Ponts',Colors.rgb_withalpha_float('lightyellow1',1.)],
+            15 : ['Ligne hautes-tension', 'Ligne hautes-tension',Colors.rgb_withalpha_float('lightcyan1',0.25)]}
+
     def init_2023(self):
 
         self.class_name = 'SPW-Geofit 2023'
@@ -155,8 +169,8 @@ class xyz_laz():
             parts = last_part.split('_')
 
             # L'origine est codée dans le nom de fichier
-            self.origx = float(parts[2])
-            self.origy = float(parts[3])
+            self.origx = float(parts[-3])
+            self.origy = float(parts[-2])
 
             dx = 2500.
             dy = 3500.
@@ -590,7 +604,8 @@ class xyz_laz_grids():
         dirs = listdir(dir_grids)
 
         for curdir in dirs:
-            self.grids.append(xyz_laz_grid(join(dir_grids,curdir)))
+            if Path(curdir).is_dir():
+                self.grids.append(xyz_laz_grid(join(dir_grids,curdir)))
 
     def scan_around(self, xy:Union[LineString,list[list[float], list[float]]], length_buffer=5.):
         """
@@ -707,42 +722,82 @@ class xyz_laz_grids():
 
         return figmpl
 
-    def create_from_laz(self, dir_laz:str, shape:str, ds:float = 50, force_format = np.float64):
+    def create_from_laz(self, dir_laz:str, shape:str=None, ds:float = 50, force_format = np.float64):
 
         try:
             from ..PyVertexvectors import Zones
         except:
             from wolfhece.PyVertexvectors import Zones
-        vecs = Zones(shape)
 
-        for entry in scandir(dir_laz):
+        vecs = None
+        if shape is not None:
+            vecs = Zones(shape)
+
+        dir_laz = Path(dir_laz)
+
+        for entry in tqdm(dir_laz.glob('**/*.laz')):
             if entry.is_file():
-                if entry.name.endswith('.laz'):
 
-                    file_wo_suf = entry.name.removesuffix('.laz')
-                    dirname = join(self.dir, file_wo_suf)
+                file_wo_suf = entry.stem
+                dirname = join(self.dir, file_wo_suf)
 
-                    if not exists(dirname):
-                        makedirs(dirname, exist_ok=True)
+                if not exists(dirname):
+                    makedirs(dirname, exist_ok=True)
 
-                        newlaz = xyz_laz_grid(mydir=dirname)
+                    newlaz = xyz_laz_grid(mydir=dirname)
 
+                    if vecs is not None:
                         vec = vecs.get_zone(file_wo_suf)
                         bounds = vec.myvectors[0].get_bounds()
+                    else:
+                        lazdata = laspy.read(entry)
+                        bounds = [[lazdata.x.min(), lazdata.y.min()],
+                                    [lazdata.x.max(), lazdata.y.max()]]
+
+                    bounds = [[math.floor(bounds[0][0]/ds)*ds, math.floor(bounds[0][1]/ds)*ds],
+                                        [math.ceil(bounds[1][0]/ds)*ds, math.ceil(bounds[1][1]/ds)*ds]]
+
+                    dx = bounds[1][0] -bounds[0][0]
+                    dy = bounds[1][1] -bounds[0][1]
+                    nb = max(int(dx/ds), int(dy/ds))
+
+                    self.grids.append(newlaz._sort_grid_np(entry,
+                                                        join(dirname, file_wo_suf),
+                                                        bounds=[[bounds[0][0], bounds[1][0]], [bounds[0][1], bounds[1][1]]],
+                                                        gridsize=[max(int(dx/ds),1), max(int(dy/ds),1)],
+                                                        force_format=force_format))
+
+    def create_bounds_shape(self, dir_laz:str, out_shape:str):
+        """ Create shape from laz files """
+        try:
+            from ..PyVertexvectors import Zones
+        except:
+            from wolfhece.PyVertexvectors import Zones
+
+        dir_laz = Path(dir_laz)
+        out_shape = Path(out_shape)
+
+        vecs = Zones()
+
+        for entry in tqdm(dir_laz.glob('**/*.laz')):
+            if entry.is_file():
+                lazdata = laspy.read(entry)
 
-                        bounds = [[math.floor(bounds[0][0]/ds)*ds, math.floor(bounds[0][1]/ds)*ds],
-                                            [math.ceil(bounds[1][0]/ds)*ds, math.ceil(bounds[1][1]/ds)*ds]]
+                bounds = [[lazdata.x.min(), lazdata.y.min()],
+                            [lazdata.x.max(), lazdata.y.max()]]
+                loczone = zone(name=entry.stem)
+                locvec = vector(name=entry.stem)
 
-                        dx = bounds[1][0] -bounds[0][0]
-                        dy = bounds[1][1] -bounds[0][1]
-                        nb = max(int(dx/ds), int(dy/ds))
+                locvec.add_vertex(wolfvertex(bounds[0][0], bounds[0][1]))
+                locvec.add_vertex(wolfvertex(bounds[1][0], bounds[0][1]))
+                locvec.add_vertex(wolfvertex(bounds[1][0], bounds[1][1]))
+                locvec.add_vertex(wolfvertex(bounds[0][0], bounds[1][1]))
+                locvec.close_force()
 
-                        self.grids.append(newlaz._sort_grid_np(entry.path,
-                                                            join(dirname, file_wo_suf),
-                                                            bounds=[[bounds[0][0], bounds[1][0]], [bounds[0][1], bounds[1][1]]],
-                                                            gridsize=[max(int(dx/ds),1), max(int(dy/ds),1)],
-                                                            force_format=force_format))
+                loczone.add_vector(locvec, forceparent=True)
+                vecs.add_zone(loczone, forceparent=True)
 
+        vecs.saveas(Path(self.dir) / out_shape)
 
 class Wolf_LAZ_Data(Element_To_Draw):
     """ Base class for LAZ data which can be imported in Pydraw.Mapviewer.
@@ -1145,6 +1200,8 @@ class Wolf_LAZ_Data(Element_To_Draw):
             logging.warning(_('No classification chosen - Abort !'))
         elif classification == 'SPW 2013-2014':
             self.classification.init_2013()
+        elif classification == 'SPW 2021-2022':
+            self.classification.init_2021_2022()
         else:
             self.classification.init_2023()
 
@@ -1900,6 +1957,34 @@ def get_colors(las:laspy.LasData, which_colors:Colors_Lazviewer, imsize=2000, fn
             name, comment, color = value
             colors[myclass==int(key)] = color
 
+    elif which_colors==Colors_Lazviewer.CODE_2021_2022.value:
+        """
+        - Rebus/non classés - Code 0;
+        - Hors-sol (building, toits et autres) - Code 1;
+        - Sol (y compris talus et digues) - Code 2;
+        - Végétation haute (y compris la végétation linéaire) - Code 4;
+        - Eau - Code 9;
+        - Pont – Code 10;
+        - Ligne hautes-tension - Code 15.
+        """
+        if type(las) is laspy.LasData:
+            myclass = las.classification
+        elif type(las) is list:
+            myclass=[]
+            for curlas in las:
+                myclass.append(curlas.classification)
+            myclass = np.concatenate(myclass)
+        else:
+            myclass = np.int8(las[:,3])
+
+        if palette_classif is None:
+            palette_classif = Classification_LAZ()
+            palette_classif.init_2021_2022()
+
+        for key, value in palette_classif.classification.items():
+            name, comment, color = value
+            colors[myclass==int(key)] = color
+
     elif which_colors==Colors_Lazviewer.CODE_2023.value:
 
         if palette_classif is None:

wolfhece/math_parser/calculator.py

@@ -116,7 +116,7 @@ class Calculator(wx.Frame):
             from ..PyDraw import draw_type
             ids = self._mapviewer.get_list_keys(drawing_type=draw_type.ARRAYS, checked_state=None)
             for id in ids:
-                self.memory_txt += id
+                self.memory_txt = id
 
     def memory_clear_event(self, e):
         self.memory_clear()

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