nouvelle version de relief

Dezip.py

@@ -0,0 +1,73 @@
+import shutil
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor
+import py7zr
+
+Dossier = "/media/remy/T7/IGNDonnee/"
+
+SOURCE = Path(Dossier)
+SORTIE = Path(Dossier)
+
+TYPES = ["DST", "MNT", "SRC"]
+
+NB_THREADS = 4
+
+for t in TYPES:
+	(SORTIE / t).mkdir(exist_ok=True)
+
+(SOURCE / "FAIT").mkdir(exist_ok=True)
+
+temp = Path("_temp_rgealti")
+
+if temp.exists():
+	shutil.rmtree(temp)
+
+def compresser_fichier(args):
+	fichier, dossier_sortie = args
+
+	archive_sortie = dossier_sortie / f"{fichier.name}.7z"
+
+	with py7zr.SevenZipFile(archive_sortie, "w") as z:
+		z.write(fichier, arcname=fichier.name)
+
+archives = list(
+	SOURCE.glob("RGEALTI_2-0_1M_ASC_LAMB93-IGN69_D0*.7z")
+)
+
+with ThreadPoolExecutor(max_workers=NB_THREADS) as pool:
+
+	for archive in archives:
+		print(archive)
+
+		if temp.exists():
+			shutil.rmtree(temp)
+
+		temp.mkdir()
+
+		# Extraction archive source
+		with py7zr.SevenZipFile(archive, "r") as z:
+			z.extractall(temp)
+		print("fin Extraction")
+
+		taches = []
+
+		for t in TYPES:
+			for dossier in temp.rglob(f"RGEALTI_{t}_1M_*"):
+
+				if dossier.is_dir():
+
+					for fichier in dossier.iterdir():
+
+						if fichier.is_file():
+							taches.append((fichier, SORTIE / t))
+
+		list(pool.map(compresser_fichier, taches))
+
+		# Déplacement archive traitée
+		shutil.move(
+			str(archive),
+			str(SOURCE / "FAIT" / archive.name)
+		)
+
+if temp.exists():
+	shutil.rmtree(temp)

GPS.py

@@ -0,0 +1,69 @@
+import re
+from pyproj import Transformer
+
+
+def _dms_vers_decimal(coord):
+	"""Convertit une coordonnée DMS ou décimale en degrés décimaux."""
+
+	if isinstance(coord, (int, float)):
+		return float(coord)
+
+	match = re.match(
+		r"(\d+)[°\s]+(\d+)'(\d+(?:\.\d+)?)\"?([NSEW])",
+		coord.strip(),
+		re.IGNORECASE
+	)
+
+	if not match:
+		raise ValueError(f"Coordonnée invalide : {coord}")
+
+	deg, minute, sec, direction = match.groups()
+
+	valeur = (
+		float(deg)
+		+ float(minute) / 60
+		+ float(sec) / 3600
+	)
+
+	if direction.upper() in ("S", "W"):
+		valeur *= -1
+
+	return valeur
+
+
+def gps_vers_lambert93(latitude, longitude) -> str:
+	"""
+	Convertit des coordonnées GPS (décimal ou DMS) vers Lambert-93.
+
+	Exemples :
+		gps_vers_lambert93(48.85825, 2.29453)
+		gps_vers_lambert93('48°51\'29.7"N', '2°17\'40.3"E')
+	"""
+
+	latitude = _dms_vers_decimal(latitude)
+	longitude = _dms_vers_decimal(longitude)
+
+	transformer = Transformer.from_crs(
+		"EPSG:4326",
+		"EPSG:2154",
+		always_xy=True
+	)
+
+	x, y = transformer.transform(longitude, latitude)
+
+	return f"{round(x / 1000):04d};{round(y / 1000):04d}"
+
+
+def listeLambertCentre(latitude, longitude,kilometre):
+	e, n = map(int, gps_vers_lambert93(latitude, longitude).split(";"))
+
+	debut_est = e - (kilometre // 2)
+	debut_nord = n + (kilometre // 2)
+
+	liste = []
+
+	for nord in range(debut_nord, debut_nord - kilometre, -1):
+		for est in range(debut_est, debut_est + kilometre):
+			liste.append(f"{est:04d};{nord:04d}")
+
+	return liste

IGN.py

@@ -0,0 +1,144 @@
+import os
+import json
+import tempfile
+
+import py7zr
+import numpy as np
+from scipy.ndimage import zoom
+
+
+def Construit(nom, listeLambert, dossier, reduction=1):
+	"""
+	Construit un fichier RCL contenant une matrice d'altitudes.
+
+	Args:
+		nom:
+			Nom du fichier de sortie sans extension.
+
+		listeLambert:
+			Liste des tuiles Lambert classées Nord-Ouest vers Sud-Est.
+
+		dossier:
+			Dossier contenant les archives RGEALTI .asc.7z.
+
+		reduction:
+			Facteur de réduction de résolution.
+			1 = résolution originale
+			2 = réduction par 2 avec interpolation bicubique
+			5 = réduction par 5 avec interpolation bicubique
+	"""
+
+	if reduction < 1:
+		raise ValueError("La réduction doit être >= 1")
+
+	nom = nom + ".rcl"
+
+	taille = int(len(listeLambert) ** 0.5)
+
+	if taille * taille != len(listeLambert):
+		raise ValueError("La liste ne forme pas un carré complet")
+
+	resultat = []
+
+	with tempfile.TemporaryDirectory() as tmp:
+
+		# Parcours des lignes de tuiles du Nord vers le Sud
+		for ligne_tuile in range(taille):
+
+			ligne_fichiers = listeLambert[
+				ligne_tuile * taille:
+				(ligne_tuile + 1) * taille
+			]
+
+			fichiers = []
+
+			# Ouverture des tuiles Est-Ouest
+			for lambert in ligne_fichiers:
+
+				archive_path = os.path.join(
+					dossier,
+					f"RGEALTI_FXX_{lambert.replace(';', '_')}_MNT_LAMB93_IGN69.asc.7z"
+				)
+
+				with py7zr.SevenZipFile(
+					archive_path,
+					mode="r"
+				) as archive:
+
+					noms = archive.getnames()
+					archive.extractall(path=tmp)
+
+				nom_asc = None
+
+				for fichier in noms:
+					if fichier.endswith(".asc"):
+						nom_asc = os.path.join(tmp, fichier)
+						break
+
+				if nom_asc is None:
+					raise FileNotFoundError(
+						f"Aucun fichier ASC trouvé dans {archive_path}"
+					)
+
+				f = open(nom_asc, "r")
+
+				# Suppression de l'entête ASC
+				for _ in range(6):
+					next(f)
+
+				fichiers.append(f)
+
+
+			# Lecture des 1000 lignes de cette bande
+			for _ in range(1000):
+
+				ligne_complete = []
+
+				for f in fichiers:
+					ligne_complete.extend(
+						float(x)
+						for x in f.readline().split()
+					)
+
+				resultat.append(ligne_complete)
+
+
+			for f in fichiers:
+				f.close()
+
+
+	# Conversion numpy
+	terrain = np.array(
+		resultat,
+		dtype=np.float32
+	)
+
+
+	# Réduction bicubique
+	if reduction > 1:
+
+		nouvelle_hauteur = terrain.shape[0] / reduction
+		nouvelle_largeur = terrain.shape[1] / reduction
+
+		terrain = zoom(
+			terrain,
+			(
+				nouvelle_hauteur / terrain.shape[0],
+				nouvelle_largeur / terrain.shape[1]
+			),
+			order=3
+		)
+
+
+	# Retour en liste pour JSON
+	resultat = terrain.tolist()
+
+
+	with open(nom, "w") as f:
+		json.dump(resultat, f)
+
+
+	print(
+		f"RCL créé : {nom} "
+		f"({len(resultat)} x {len(resultat[0])})"
+	)

MNT.py

@@ -0,0 +1,171 @@
+import os
+import tempfile
+import py7zr
+
+
+def ConstruitMNT(nom, listeLambert, dossier, reduction=1):
+
+	"""
+	Construit un fichier RCL simple à partir de tuiles Lambert.
+
+	Format RCL :
+	ligne 1 : facteur
+	ligne 2 : largeur
+	ligne 3 : hauteur
+	ligne 4 : liste des altitudes
+
+	reduction :
+		1 = résolution originale
+		2 = moyenne sur blocs 2x2
+		5 = moyenne sur blocs 5x5
+	"""
+	
+	dossier = dossier + "MNT"
+	if reduction < 1:
+		raise ValueError("La réduction doit être >= 1")
+
+
+	taille = int(len(listeLambert) ** 0.5)
+
+	if taille * taille != len(listeLambert):
+		raise ValueError("La liste ne forme pas un carré complet")
+
+
+	terrain = []
+
+
+	with tempfile.TemporaryDirectory() as tmp:
+
+		for ligne_tuile in range(taille):
+
+			ligne_fichiers = listeLambert[
+				ligne_tuile * taille:
+				(ligne_tuile + 1) * taille
+			]
+
+
+			fichiers = []
+
+
+			for lambert in ligne_fichiers:
+
+				archive_path = os.path.join(
+					dossier,
+					f"RGEALTI_FXX_{lambert.replace(';','_')}_MNT_LAMB93_IGN69.asc.7z"
+				)
+
+
+				with py7zr.SevenZipFile(
+					archive_path,
+					"r"
+				) as archive:
+
+					noms = archive.getnames()
+					archive.extractall(tmp)
+
+
+				nom_asc = None
+
+				for fichier in noms:
+					if fichier.endswith(".asc"):
+						nom_asc = os.path.join(tmp, fichier)
+						break
+
+
+				f = open(nom_asc, "r")
+
+
+				for _ in range(6):
+					next(f)
+
+
+				fichiers.append(f)
+
+
+
+			for _ in range(1000):
+
+				ligne = []
+
+				for f in fichiers:
+
+					ligne.extend(
+						float(x)
+						for x in f.readline().split()
+					)
+
+				terrain.append(ligne)
+
+
+			for f in fichiers:
+				f.close()
+
+
+
+	# -------------------------------
+	# Réduction par moyenne
+	# -------------------------------
+
+	if reduction > 1:
+
+		nouvelle_hauteur = len(terrain) // reduction
+		nouvelle_largeur = len(terrain[0]) // reduction
+
+		nouveau = []
+
+
+		for y in range(nouvelle_hauteur):
+
+			ligne = []
+
+			for x in range(nouvelle_largeur):
+
+				somme = 0
+				nombre = 0
+
+
+				for yy in range(
+					y * reduction,
+					(y + 1) * reduction
+				):
+
+					for xx in range(
+						x * reduction,
+						(x + 1) * reduction
+					):
+
+						somme += terrain[yy][xx]
+						nombre += 1
+
+
+				ligne.append(
+					somme / nombre
+				)
+
+
+			nouveau.append(ligne)
+
+
+		terrain = nouveau
+
+
+
+	hauteur = len(terrain)
+	largeur = len(terrain[0])
+
+
+	donnees = []
+
+	for ligne in terrain:
+		donnees.extend(ligne)
+
+	with open(nom + ".rcl", "w") as f:
+		f.write("1\n")
+		f.write(str(largeur) + "\n")
+		f.write(str(hauteur) + "\n")
+		f.write(str(donnees))
+		
+	print(
+		f"RCL créé : {nom}.rcl "
+		f"({largeur} x {hauteur})"
+	)

OBJ.py

@@ -0,0 +1,54 @@
+import json
+
+
+def transformeOBJ(nom, pas=1):
+	"""
+	Transforme un fichier RCL (matrice d'altitudes) en fichier OBJ.
+
+	Args:
+		nom : nom du fichier sans extension
+		pas : distance entre deux points en mètres
+
+	Créé :
+		nom.obj
+	"""
+
+	# Lecture du RCL
+	with open(nom + ".rcl", "r") as f:
+		terrain = json.load(f)
+
+	hauteur = len(terrain)
+	largeur = len(terrain[0])
+
+	fichier_obj = nom + ".obj"
+
+	with open(fichier_obj, "w") as obj:
+
+		# Création des sommets
+		for y in range(hauteur):
+			for x in range(largeur):
+				obj.write(
+					f"v {x * pas} {y * pas} {terrain[y][x]}\n"
+				)
+
+		# Création des faces
+		for y in range(hauteur - 1):
+			for x in range(largeur - 1):
+
+				# index OBJ commence à 1
+				p1 = y * largeur + x + 1
+				p2 = p1 + 1
+				p3 = p1 + largeur
+				p4 = p3 + 1
+
+				# Premier triangle
+				obj.write(
+					f"f {p1} {p2} {p3}\n"
+				)
+
+				# Deuxième triangle
+				obj.write(
+					f"f {p2} {p4} {p3}\n"
+				)
+
+	print(f"Fichier créé : {fichier_obj}")

STEP.py

@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+"""
+transformeSTEP.py
+
+Lit un fichier .rcl (grille d'altitudes) et génère un solide au format STEP.
+
+Format attendu du fichier .rcl :
+    ligne 1 : ignorée (non utilisée)
+    ligne 2 : X  -> largeur de la grille (nombre de colonnes)
+    ligne 3 : Y  -> hauteur de la grille (nombre de lignes)
+    suite   : X*Y valeurs flottantes (altitudes), écrites comme une liste
+              Python "[v1, v2, v3, ...]" pouvant s'étendre sur plusieurs lignes.
+
+Dépendances :
+    pip install numpy
+    pythonocc-core (conseillé via conda) :
+        conda install -c conda-forge pythonocc-core
+
+    Si vous n'avez pas conda, cherchez une roue (wheel) pythonocc-core
+    compatible avec votre OS/version de Python, l'installation via pip seul
+    ne fonctionne pas sur toutes les plateformes.
+"""
+
+import re
+import numpy as np
+
+from OCC.Core.gp import gp_Pnt
+from OCC.Core.BRepBuilderAPI import (
+    BRepBuilderAPI_MakePolygon,
+    BRepBuilderAPI_MakeFace,
+    BRepBuilderAPI_Sewing,
+    BRepBuilderAPI_MakeSolid,
+)
+from OCC.Core.TopoDS import topods, TopoDS_Shell
+from OCC.Core.BRep import BRep_Builder
+from OCC.Core.TopExp import TopExp_Explorer
+from OCC.Core.TopAbs import TopAbs_SHELL
+from OCC.Core.STEPControl import STEPControl_Writer, STEPControl_AsIs
+from OCC.Core.IFSelect import IFSelect_RetDone
+from OCC.Core.BRepLib import breplib
+
+
+# ----------------------------------------------------------------------
+# 1) Lecture / extraction des informations du fichier .rcl
+# ----------------------------------------------------------------------
+def lire_et_extraire_infos(nomDonne):
+    """
+    Lit un fichier .rcl et retourne (X, Y, grille) où grille est un
+    tableau numpy de forme (Y, X) contenant les altitudes.
+    """
+    with open(nomDonne, "r") as f:
+        lignes = f.readlines()
+
+    if len(lignes) < 4:
+        raise ValueError(f"Fichier {nomDonne} trop court / mal formé.")
+
+    # ligne 1 (index 0) : non utilisée
+    X = int(lignes[1].strip())
+    Y = int(lignes[2].strip())
+
+    # Le reste du fichier contient la liste des altitudes, potentiellement
+    # répartie sur plusieurs lignes -> on regroupe tout et on extrait
+    # tous les nombres flottants (gère aussi la notation scientifique).
+    reste = "".join(lignes[3:])
+    valeurs_str = re.findall(r"-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?", reste)
+    valeurs = [float(v) for v in valeurs_str]
+
+    attendu = X * Y
+    if len(valeurs) < attendu:
+        raise ValueError(
+            f"Nombre de valeurs insuffisant dans {nomDonne} : "
+            f"{len(valeurs)} lues, {attendu} attendues (X={X}, Y={Y})."
+        )
+    valeurs = valeurs[:attendu]
+
+    grille = np.array(valeurs, dtype=float).reshape(Y, X)
+    return X, Y, grille
+
+
+# ----------------------------------------------------------------------
+# 2) Construction du solide (mur + toit + plancher) à partir de la grille
+# ----------------------------------------------------------------------
+def _face_triangle(p1, p2, p3):
+    """Crée une face plane triangulaire à partir de 3 gp_Pnt."""
+    poly = BRepBuilderAPI_MakePolygon()
+    poly.Add(p1)
+    poly.Add(p2)
+    poly.Add(p3)
+    poly.Close()
+    return BRepBuilderAPI_MakeFace(poly.Wire()).Face()
+
+
+def _face_quad(p1, p2, p3, p4):
+    """Crée une face plane quadrangulaire à partir de 4 gp_Pnt (ordre = contour)."""
+    poly = BRepBuilderAPI_MakePolygon()
+    poly.Add(p1)
+    poly.Add(p2)
+    poly.Add(p3)
+    poly.Add(p4)
+    poly.Close()
+    return BRepBuilderAPI_MakeFace(poly.Wire()).Face()
+
+
+def construire_solide_depuis_grille(grille, echelle_xy=1.0, echelle_z=1.0,
+                                     z_base=None, pas=1):
+    """
+    Construit un solide B-Rep (OpenCASCADE) à partir d'une grille d'altitudes.
+
+    grille     : tableau numpy (Y, X) d'altitudes
+    echelle_xy : facteur d'échelle appliqué aux coordonnées X/Y (pas de grille -> unités)
+    echelle_z  : facteur d'échelle appliqué aux altitudes
+    z_base     : altitude du plancher (par défaut : min(grille) - 10% de l'amplitude)
+    pas        : sous-échantillonnage de la grille (1 = pleine résolution).
+                 Pour de grandes grilles (ex. 1000x1000), un solide B-Rep
+                 avec un million de facettes est très lourd : augmentez "pas"
+                 (ex. 5, 10, 20 ...) pour réduire le nombre de faces.
+
+    Retourne un TopoDS_Solid.
+    """
+    Y, X = grille.shape
+
+    # Sous-échantillonnage éventuel pour garder un nombre de facettes raisonnable
+    xs = list(range(0, X, pas))
+    if xs[-1] != X - 1:
+        xs.append(X - 1)
+    ys = list(range(0, Y, pas))
+    if ys[-1] != Y - 1:
+        ys.append(Y - 1)
+
+    sous_grille = grille[np.ix_(ys, xs)]
+    ny, nx = sous_grille.shape
+
+    if z_base is None:
+        zmin, zmax = float(sous_grille.min()), float(sous_grille.max())
+        amplitude = max(zmax - zmin, 1.0)
+        z_base = zmin - 0.1 * amplitude
+
+    # Points du toit (top[j][i]) et points du plancher directement en dessous
+    top = [[gp_Pnt(i * echelle_xy, j * echelle_xy, sous_grille[j, i] * echelle_z)
+            for i in range(nx)] for j in range(ny)]
+    bas = [[gp_Pnt(i * echelle_xy, j * echelle_xy, z_base)
+            for i in range(nx)] for j in range(ny)]
+
+    faces = []
+
+    # --- Toit : chaque case de la grille -> 2 triangles ---
+    for j in range(ny - 1):
+        for i in range(nx - 1):
+            p1, p2 = top[j][i], top[j][i + 1]
+            p3, p4 = top[j + 1][i + 1], top[j + 1][i]
+            faces.append(_face_triangle(p1, p2, p3))
+            faces.append(_face_triangle(p1, p3, p4))
+
+    # --- Murs latéraux (4 côtés du rectangle) ---
+    def mur(p_top_a, p_top_b, p_bas_a, p_bas_b):
+        faces.append(_face_triangle(p_top_a, p_top_b, p_bas_b))
+        faces.append(_face_triangle(p_top_a, p_bas_b, p_bas_a))
+
+    # côté j = 0
+    for i in range(nx - 1):
+        mur(top[0][i], top[0][i + 1], bas[0][i], bas[0][i + 1])
+    # côté j = ny-1
+    for i in range(nx - 1):
+        mur(top[ny - 1][i], top[ny - 1][i + 1], bas[ny - 1][i], bas[ny - 1][i + 1])
+    # côté i = 0
+    for j in range(ny - 1):
+        mur(top[j][0], top[j + 1][0], bas[j][0], bas[j + 1][0])
+    # côté i = nx-1
+    for j in range(ny - 1):
+        mur(top[j][nx - 1], top[j + 1][nx - 1], bas[j][nx - 1], bas[j + 1][nx - 1])
+
+    # --- Plancher : un unique rectangle plan à z_base ---
+    faces.append(_face_quad(bas[0][0], bas[0][nx - 1], bas[ny - 1][nx - 1], bas[ny - 1][0]))
+
+    # --- Couture des faces en une coque fermée ---
+    sewing = BRepBuilderAPI_Sewing(1e-6)
+    for f in faces:
+        sewing.Add(f)
+    sewing.Perform()
+    coque = sewing.SewedShape()
+
+    # Récupère le TopoDS_Shell résultant de la couture
+    explorer = TopExp_Explorer(coque, TopAbs_SHELL)
+    if not explorer.More():
+        raise RuntimeError("Échec de la couture : aucune coque produite.")
+    shell = topods.Shell(explorer.Current())
+
+    # --- Construction du solide à partir de la coque fermée ---
+    make_solid = BRepBuilderAPI_MakeSolid(shell)
+    if not make_solid.IsDone():
+        raise RuntimeError("Échec de la création du solide à partir de la coque.")
+    solide = make_solid.Solid()
+
+    # S'assure que les normales sont correctement orientées vers l'extérieur
+    breplib.OrientClosedSolid(solide)
+
+    return solide
+
+
+# ----------------------------------------------------------------------
+# 3) Export STEP
+# ----------------------------------------------------------------------
+def exporter_step(solide, chemin_fichier):
+    writer = STEPControl_Writer()
+    writer.Transfer(solide, STEPControl_AsIs)
+    status = writer.Write(chemin_fichier)
+    if status != IFSelect_RetDone:
+        raise RuntimeError(f"Échec de l'écriture du fichier STEP : {chemin_fichier}")
+
+
+# ----------------------------------------------------------------------
+# 4) Fonction principale, sur le modèle de transformeSTL
+# ----------------------------------------------------------------------
+def transformeSTEP(nom, echelle_xy=1.0, echelle_z=1.0, z_base=None, pas=1):
+    """
+    Lit nom + ".rcl", construit un solide à partir de la grille d'altitudes
+    et écrit nom + ".step".
+
+    pas : sous-échantillonnage de la grille (voir construire_solide_depuis_grille).
+          Pour une grille 1000x1000, commencez par exemple avec pas=10 ou plus
+          pour garder un temps de calcul raisonnable, puis diminuez si besoin.
+    """
+    nomDonne = nom + ".rcl"
+    X, Y, donne = lire_et_extraire_infos(nomDonne)
+
+    solide = construire_solide_depuis_grille(
+        donne, echelle_xy=echelle_xy, echelle_z=echelle_z,
+        z_base=z_base, pas=pas
+    )
+
+    nomSortie = nom + ".step"
+    exporter_step(solide, nomSortie)
+    print(f"Fichier STEP généré : {nomSortie}")
+    return nomSortie
+
+

STL.py

@@ -0,0 +1,108 @@
+from stl import mesh
+import numpy as np
+
+
+def lire_et_extraire_infos(nom_fichier):
+	entiers = []
+	tableau_float = []
+	try:
+		with open(nom_fichier, 'r') as fichier:
+			lignes = fichier.readlines()
+			
+			for i in range(3):
+				entiers.append(
+					int(lignes[i].strip()))  # Convertit en entier et supprime les espaces en début et fin de ligne
+			
+			quatrieme_ligne = lignes[3].strip('[]\n').split(',')
+			tableau_float = [float(x) for x in quatrieme_ligne]
+		
+		return entiers, tableau_float
+	except FileNotFoundError:
+		print(f"Le fichier '{nom_fichier}' n'a pas été trouvé.")
+		return None, None
+
+
+def transformeSTL(nom):
+	nomDonne = nom + ".rcl"
+	donne = lire_et_extraire_infos(nomDonne)
+	
+	deplacement_metres = donne[0][0]
+	lenX = donne[0][1]
+	lenY = donne[0][2]
+	test = donne[1]
+	
+	facteur = deplacement_metres
+	
+	test = [nombre / facteur for nombre in test]
+	mini = min(test) - 1
+	test = [nombre - mini for nombre in test]
+	
+	vertices = np.zeros((lenX * lenY * 2, 3), dtype=float)
+	y = 0
+	for i in range(0, lenX):
+		for j in range(0, lenY):
+			vertices[y] = [i, j, 0]
+			vertices[y + 1] = [i, j, test[i * lenY + j]]
+			y = y + 2
+	
+	nb = (lenX * 2 - 2)
+	faces1 = np.zeros((nb, 3), dtype=int)
+	y = 0
+	for i in range(0, lenX * 2 - 2, 2):
+		faces1[y] = [i, i + 1, i + 2]
+		faces1[y + 1] = [i + 1, i + 3, i + 2]
+		y = y + 2
+	
+	nb = lenY * 2 - 2
+	faces2 = np.zeros((nb, 3), dtype=int)
+	y = 0
+	for i in range(0, lenX * 2 * lenY - lenY * 2, lenX * 2):
+		faces2[y] = [i, i + 1, i + lenX * 2]
+		faces2[y + 1] = [i + 1, i + lenX * 2 + 1, i + lenX * 2]
+		y = y + 2
+	
+	nb = (lenX * 2 - 2)
+	Start3 = (lenX * 2 * lenY) - lenX * 2
+	faces3 = np.zeros((nb, 3), dtype=int)
+	y = 0
+	for i in range(Start3, lenX * 2 - 2 + Start3, 2):
+		faces3[y] = [i, i + 1, i + 2]
+		faces3[y + 1] = [i + 1, i + 3, i + 2]
+		y = y + 2
+	
+	nb = lenY * 2 - 2
+	Start4 = lenX * 2 - 2
+	faces4 = np.zeros((nb, 3), dtype=int)
+	y = 0
+	for i in range(Start4, lenX * 2 * lenY - lenY * 2 + Start4, lenX * 2):
+		faces4[y] = [i, i + 1, i + lenX * 2]
+		faces4[y + 1] = [i + 1, i + lenX * 2 + 1, i + lenX * 2]
+		y = y + 2
+	
+	nb = 2
+	faces5 = np.zeros((nb, 3), dtype=int)
+	faces5[0] = [0, lenX * 2 - 2, (lenX * 2 * lenY) - lenX * 2]
+	faces5[1] = [lenX * 2 - 2, lenX * lenY * 2 - 2, (lenX * 2 * lenY) - lenX * 2]
+	
+	nb = lenX * lenY * 2
+	faces6 = np.zeros((nb, 3), dtype=int)
+	y = 0
+	for j in range(0, lenY - 1):
+		for i in range(lenX * 2 * j + 1, lenX * 2 * j + lenX * 2 - 1, 2):
+			faces6[y] = [i, i + 2, lenX * 2 + i]
+			faces6[y + 1] = [i + 2, lenX * 2 + i + 2, lenX * 2 + i]
+			y = y + 2
+	
+	faces = np.concatenate((faces1, faces2, faces3, faces4, faces5, faces6), axis=0)
+	
+	# Créez le maillage STL
+	
+	cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+	
+	for i, f in enumerate(faces):
+		for j in range(3):
+			cube.vectors[i][j] = vertices[f[j], :]
+	
+	# Sauvegardez le cube au format STL
+	nomSTL = nom + ".stl"
+	cube.save(nomSTL)

Vieux/GPS.py

@@ -0,0 +1,34 @@
+import math
+
+def longitudePlus(longitude_actuelle, deplacement_metre,latitude):
+	rayon_terre_metres = 6371000
+	latitude_radians = math.radians(latitude)
+	circonference_terre_metres = 2 * math.pi * rayon_terre_metres * math.cos(latitude_radians)
+	longueur_degre_longitude_metres = circonference_terre_metres / 360
+	return longitude_actuelle + (deplacement_metre / longueur_degre_longitude_metres)
+	 
+def longitudeMoins(longitude_actuelle, deplacement_metre, latitude):
+	rayon_terre_metres = 6371000
+	latitude_radians = math.radians(latitude)
+	circonference_terre_metres = 2 * math.pi * rayon_terre_metres * math.cos(latitude_radians)
+	longueur_degre_longitude_metres = circonference_terre_metres / 360
+	print(type(longitude_actuelle))
+	return longitude_actuelle - (deplacement_metre / longueur_degre_longitude_metres)
+
+
+def latitudePlus(latitude_actuelle, deplacement_metre):
+	rayon_terre_metres = 6371000
+	return latitude_actuelle - (deplacement_metre / rayon_terre_metres) * (180 / math.pi)
+	
+def latitudeMoins(latitude_actuelle, deplacement_metre):
+	rayon_terre_metres = 6371000
+	nouvelle_latitude = latitude_actuelle + (deplacement_metre / rayon_terre_metres) * (180 / math.pi)
+	return nouvelle_latitude
+
+def Milieu(Latitude,Longitude,distance,definition):
+	Latitude=latitudeMoins(Latitude,distance/2)
+	Longitude=longitudeMoins(Longitude,distance/2,Latitude)	
+	lenX=int(distance/definition)
+	lenY=int(distance/definition)
+	deplacement_metres = definition
+	return Latitude,Longitude,lenX,lenY,deplacement_metres

Vieux/IGN.py

@@ -0,0 +1,65 @@
+import requests
+import json
+import time
+
+def alt(longitude, latitude):
+	if len(longitude) != len(latitude):
+		print ("Les tableaux de longitude et de latitude doivent avoir la même taille.")
+		return "error"
+	total_elements = len(longitude)
+	batch_size = 175
+
+	start = 0
+	res=[]
+	i=0
+	while start < total_elements:
+		print(i,"/",total_elements/150)
+		i=i+1
+		end = min(start + batch_size, total_elements)
+	
+
+		longitude_batch = longitude[start:end]
+		latitude_batch = latitude[start:end]
+
+		res=res+req(longitude_batch, latitude_batch, len(longitude_batch))
+
+		# Mettez à jour l'indice de début pour le prochain lot
+		start = end
+	return res
+		
+
+def req(latitude, longitude,nb):
+	longi=""
+	latti=""
+	for i in range(nb):
+		if i > 0:
+			longi += "|"
+			latti += "|"
+			
+		longi += str(longitude[i])
+		latti += str(latitude[i])
+		
+	
+	url = f'https://wxs.ign.fr/calcul/alti/rest/elevation.json?lon={longi}&lat={latti}&zonly=true'
+	print(url)
+	while(1):
+		try:
+			response = requests.get(url)
+			
+			if response.status_code == 200:
+				try:
+					data = json.loads(response.text)
+				
+					if 'elevations' in data:
+						elevation = data['elevations']
+						return elevation
+					else:
+						print("Impossible d'obtenir l'altitude pour les coordonnées spécifiées.")
+				except:
+					print(url)
+					print(latitude,",",longitude)
+					time.sleep(1)
+			else:
+				print(f"Erreur de réponse de l'API. Code de statut : {response.status_code}")
+		except requests.exceptions.RequestException as e:
+			print(f"Une erreur s'est produite lors de la requête : {e}")

Vieux/IGN/GPS.py

@@ -0,0 +1,34 @@
+import math
+
+def longitudePlus(longitude_actuelle, deplacement_metre,latitude):
+	rayon_terre_metres = 6371000
+	latitude_radians = math.radians(latitude)
+	circonference_terre_metres = 2 * math.pi * rayon_terre_metres * math.cos(latitude_radians)
+	longueur_degre_longitude_metres = circonference_terre_metres / 360
+	return longitude_actuelle + (deplacement_metre / longueur_degre_longitude_metres)
+	 
+def longitudeMoins(longitude_actuelle, deplacement_metre, latitude):
+	rayon_terre_metres = 6371000
+	latitude_radians = math.radians(latitude)
+	circonference_terre_metres = 2 * math.pi * rayon_terre_metres * math.cos(latitude_radians)
+	longueur_degre_longitude_metres = circonference_terre_metres / 360
+	print(type(longitude_actuelle))
+	return longitude_actuelle - (deplacement_metre / longueur_degre_longitude_metres)
+
+
+def latitudePlus(latitude_actuelle, deplacement_metre):
+	rayon_terre_metres = 6371000
+	return latitude_actuelle - (deplacement_metre / rayon_terre_metres) * (180 / math.pi)
+	
+def latitudeMoins(latitude_actuelle, deplacement_metre):
+	rayon_terre_metres = 6371000
+	nouvelle_latitude = latitude_actuelle + (deplacement_metre / rayon_terre_metres) * (180 / math.pi)
+	return nouvelle_latitude
+
+def Milieu(Latitude,Longitude,distance,definition):
+	Latitude=latitudeMoins(Latitude,distance/2)
+	Longitude=longitudeMoins(Longitude,distance/2,Latitude)	
+	lenX=int(distance/definition)
+	lenY=int(distance/definition)
+	deplacement_metres = definition
+	return Latitude,Longitude,lenX,lenY,deplacement_metres

Vieux/IGN/IGN.py

@@ -0,0 +1,65 @@
+import requests
+import json
+import time
+
+def alt(longitude, latitude):
+	if len(longitude) != len(latitude):
+		print ("Les tableaux de longitude et de latitude doivent avoir la même taille.")
+		return "error"
+	total_elements = len(longitude)
+	batch_size = 175
+
+	start = 0
+	res=[]
+	i=0
+	while start < total_elements:
+		print(i,"/",total_elements/150)
+		i=i+1
+		end = min(start + batch_size, total_elements)
+	
+
+		longitude_batch = longitude[start:end]
+		latitude_batch = latitude[start:end]
+
+		res=res+req(longitude_batch, latitude_batch, len(longitude_batch))
+
+		# Mettez à jour l'indice de début pour le prochain lot
+		start = end
+	return res
+		
+
+def req(latitude, longitude,nb):
+	longi=""
+	latti=""
+	for i in range(nb):
+		if i > 0:
+			longi += "|"
+			latti += "|"
+			
+		longi += str(longitude[i])
+		latti += str(latitude[i])
+		
+	
+	url = f'https://wxs.ign.fr/calcul/alti/rest/elevation.json?lon={longi}&lat={latti}&zonly=true'
+	print(url)
+	while(1):
+		try:
+			response = requests.get(url)
+			
+			if response.status_code == 200:
+				try:
+					data = json.loads(response.text)
+				
+					if 'elevations' in data:
+						elevation = data['elevations']
+						return elevation
+					else:
+						print("Impossible d'obtenir l'altitude pour les coordonnées spécifiées.")
+				except:
+					print(url)
+					print(latitude,",",longitude)
+					time.sleep(1)
+			else:
+				print(f"Erreur de réponse de l'API. Code de statut : {response.status_code}")
+		except requests.exceptions.RequestException as e:
+			print(f"Une erreur s'est produite lors de la requête : {e}")

Vieux/IGN/STL.py

@@ -0,0 +1,115 @@
+from stl import mesh
+import numpy as np
+
+def lire_et_extraire_infos(nom_fichier):
+	entiers = []
+	tableau_float = []
+	try:
+		with open(nom_fichier, 'r') as fichier:
+			lignes = fichier.readlines()
+			
+			for i in range(3):
+				entiers.append(int(lignes[i].strip()))  # Convertit en entier et supprime les espaces en début et fin de ligne
+			
+			quatrieme_ligne = lignes[3].strip('[]\n').split(',')
+			tableau_float = [float(x) for x in quatrieme_ligne]
+
+		return entiers, tableau_float
+	except FileNotFoundError:
+		print(f"Le fichier '{nom_fichier}' n'a pas été trouvé.")
+		return None, None
+
+
+def transformeSTL(nom):
+	nomDonne = nom+".rcl"
+	donne = lire_et_extraire_infos(nomDonne)
+
+	deplacement_metres=donne[0][0]
+	lenX=donne[0][1]
+	lenY=donne[0][2]
+	test=donne[1]
+
+	facteur = deplacement_metres
+
+	test = [nombre / facteur for nombre in test]
+	mini=min(test)-1
+	test = [nombre - mini for nombre in test]
+
+	vertices = np.zeros((lenX*lenY * 2,3) , dtype=float)
+	y=0
+	for i in range (0,lenX):
+		for j in range (0,lenY):
+			vertices[y]= [i,j,0]
+			vertices[y+1]= [i,j,test[i*lenY+j]]
+			y=y+2
+
+
+
+	nb=(lenX*2-2)
+	faces1 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2-2,2):
+		faces1[y] = [i,i+1 ,i+2]
+		faces1[y+1] = [i+1 ,i+3,i+2]
+		y=y+2
+
+
+
+	nb=lenY*2-2
+	faces2 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2*lenY-lenY*2 ,lenX*2):
+		faces2[y] 	= [i,i+1,i+lenX*2]
+		faces2[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb=(lenX*2-2)
+	Start3 = (lenX*2*lenY)-lenX*2
+	faces3 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start3,lenX*2-2+Start3,2):
+		faces3[y] = [i,i+1 ,i+2]
+		faces3[y+1] = [i+1,i+3 ,i+2]
+		y=y+2
+
+	nb = lenY*2-2
+	Start4 = lenX*2-2
+	faces4 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start4,lenX*2*lenY-lenY*2 +Start4,lenX*2):
+		faces4[y] 	= [i,i+1,i+lenX*2]
+		faces4[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb = 2
+	faces5 = np.zeros((nb,3), dtype=int)
+	faces5[0] =[0,lenX*2-2,(lenX*2*lenY)-lenX*2]
+	faces5[1] =[lenX*2-2,lenX*lenY*2-2,(lenX*2*lenY)-lenX*2]
+
+
+	nb=lenX*lenY*2
+	faces6 = np.zeros((nb,3), dtype=int)
+	y=0
+	for j in range(0,lenY-1):
+		for i in range(lenX*2*j+1,lenX*2*j+lenX*2-1,2):
+			faces6[y]=[i,i+2,lenX*2+i]
+			faces6[y+1]=[i+2,lenX*2+i+2,lenX*2+i]
+			y=y+2
+			
+
+	faces=np.concatenate((faces1, faces2,faces3,faces4,faces5,faces6), axis=0)
+
+	# Créez le maillage STL
+	
+	
+	cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+
+	for i, f in enumerate(faces):
+		for j in range(3):
+			cube.vectors[i][j] = vertices[f[j], :]
+
+	#Sauvegardez le cube au format STL
+	nomSTL=nom+".stl"
+	cube.save(nomSTL)
+
+	#"""

Vieux/IGN/STLperso.py

@@ -0,0 +1,113 @@
+from stl import mesh
+import numpy as np
+
+def lire_et_extraire_infos(nom_fichier):
+	entiers = []
+	tableau_float = []
+	try:
+		with open(nom_fichier, 'r') as fichier:
+			lignes = fichier.readlines()
+			
+			for i in range(3):
+				entiers.append(int(lignes[i].strip()))  # Convertit en entier et supprime les espaces en début et fin de ligne
+			
+			quatrieme_ligne = lignes[3].strip('[]\n').split(',')
+			tableau_float = [float(x) for x in quatrieme_ligne]
+
+		return entiers, tableau_float
+	except FileNotFoundError:
+		print(f"Le fichier '{nom_fichier}' n'a pas été trouvé.")
+		return None, None
+
+
+def transformeSTL(nom):
+	nomDonne = nom+".rcl"
+	donne = lire_et_extraire_infos(nomDonne)
+
+	deplacement_metres=donne[0][0]
+	lenX=donne[0][1]
+	lenY=donne[0][2]
+	test=donne[1]
+
+	facteur = deplacement_metres
+
+	test = [nombre / facteur for nombre in test]
+	mini=min(test)-1
+	test = [nombre - mini for nombre in test]
+
+	vertices = np.zeros((lenX*lenY * 2,3) , dtype=float)
+	y=0
+	for i in range (0,lenX):
+		for j in range (0,lenY):
+			vertices[y]= [i,j,0]
+			vertices[y+1]= [i,j,test[i*lenY+j]]
+			y=y+2
+
+
+
+	nb=(lenX*2-2)
+	faces1 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2-2,2):
+		faces1[y] = [i,i+1 ,i+2]
+		faces1[y+1] = [i+1 ,i+3,i+2]
+		y=y+2
+
+
+
+	nb=lenY*2-2
+	faces2 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2*lenY-lenY*2 ,lenX*2):
+		faces2[y] 	= [i,i+1,i+lenX*2]
+		faces2[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb=(lenX*2-2)
+	Start3 = (lenX*2*lenY)-lenX*2
+	faces3 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start3,lenX*2-2+Start3,2):
+		faces3[y] = [i,i+1 ,i+2]
+		faces3[y+1] = [i+1,i+3 ,i+2]
+		y=y+2
+
+	nb = lenY*2-2
+	Start4 = lenX*2-2
+	faces4 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start4,lenX*2*lenY-lenY*2 +Start4,lenX*2):
+		faces4[y] 	= [i,i+1,i+lenX*2]
+		faces4[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb = 2
+	faces5 = np.zeros((nb,3), dtype=int)
+	faces5[0] =[0,lenX*2-2,(lenX*2*lenY)-lenX*2]
+	faces5[1] =[lenX*2-2,lenX*lenY*2-2,(lenX*2*lenY)-lenX*2]
+
+
+	nb=lenX*lenY*2
+	faces6 = np.zeros((nb,3), dtype=int)
+	y=0
+	for j in range(0,lenY-1):
+		for i in range(lenX*2*j+1,lenX*2*j+lenX*2-1,2):
+			faces6[y]=[i,i+2,lenX*2+i]
+			faces6[y+1]=[i+2,lenX*2+i+2,lenX*2+i]
+			y=y+2
+			
+
+	faces=np.concatenate((faces1, faces2,faces3,faces4,faces5,faces6), axis=0)
+
+	# Créez le maillage STL
+	cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+
+	for i, f in enumerate(faces):
+		for j in range(3):
+			cube.vectors[i][j] = vertices[f[j], :]
+
+	#Sauvegardez le cube au format STL
+	nomSTL=nom+".stl"
+	cube.save(nomSTL)
+
+	#"""

Vieux/IGN/main.py

@@ -0,0 +1,38 @@
+#pip install numpy-stl
+
+from GPS import *
+from recupere import *
+#from STLperso import *
+
+#45.221435, 5.016486 tersanne
+#45.171243, 5.722483 Grenoble
+#45.831949, 6.864395 mont blanc
+#45.010632, 5.443115 Vercors
+#45.849367, 6.182756 LacAnnecy
+#27.987348, 86.922997 Everest
+nom = "test"
+Latitude = 45.010632
+Longitude = 5.443115
+distance = 100
+definition = 30
+
+gps = Milieu(Latitude,Longitude,distance,definition)
+
+latitudeStart = gps[0]
+longitudeStart = gps[1]
+deplacement_metres = gps[4]
+facteur = deplacement_metres
+lenX=gps[2]
+lenY=gps[3]
+
+print("Latitude de départ:", latitudeStart)
+print("Longitude de départ:", longitudeStart)
+print("Déplacement en mètres:", deplacement_metres)
+print("Facteur:", facteur)
+print("Longueur en X:", lenX)
+print("Longueur en Y:", lenY)
+
+
+recupere(latitudeStart,longitudeStart,deplacement_metres,facteur,lenX,lenY,nom)
+
+#transformeSTL(nom)

Vieux/IGN/recupere.py

@@ -0,0 +1,39 @@
+#from stl import mesh
+import numpy as np
+import requests
+import math
+import time
+import datetime
+
+from IGN import alt
+from GPS import *
+
+
+def ecrire_donnees(deplacement_metres,lenX,lenY,altitude,nom):
+	now = datetime.datetime.now()
+	date_heure = now.strftime("%Y-%m-%d-%H-%M-%S")
+	#nom_fichier = f"Donne({date_heure}).txt"
+	nom_fichier = nom+".rcl"
+	with open(nom_fichier, "w") as fichier:
+		fichier.write(f"{deplacement_metres}\n")
+		fichier.write(f"{lenX}\n")
+		fichier.write(f"{lenY}\n")
+		fichier.write(f"{altitude}\n")
+
+def recupere(latitudeStart,longitudeStart,deplacement_metres,facteur,lenX,lenY,nom):
+	Tabaltitude=[]
+	latitude=latitudeStart
+	TabLongitude=[]
+	TabLatittude=[]
+	for j in range (0,lenX):
+		longitude=longitudeStart
+		for i in range (0,lenY):
+			TabLongitude.append(longitude)
+			TabLatittude.append(latitude)
+			longitude=longitudePlus(longitude,deplacement_metres,latitude)
+		latitude=latitudePlus(latitude,deplacement_metres)
+		
+	Tabaltitude=alt(TabLatittude,TabLongitude)
+	ecrire_donnees(deplacement_metres,lenX,lenY,Tabaltitude,nom)
+
+	# print(latitude,",",longitude)

Vieux/OpenElevation/GPS.py

@@ -0,0 +1,34 @@
+import math
+
+def longitudePlus(longitude_actuelle, deplacement_metre,latitude):
+	rayon_terre_metres = 6371000
+	latitude_radians = math.radians(latitude)
+	circonference_terre_metres = 2 * math.pi * rayon_terre_metres * math.cos(latitude_radians)
+	longueur_degre_longitude_metres = circonference_terre_metres / 360
+	return longitude_actuelle + (deplacement_metre / longueur_degre_longitude_metres)
+	 
+def longitudeMoins(longitude_actuelle, deplacement_metre, latitude):
+	rayon_terre_metres = 6371000
+	latitude_radians = math.radians(latitude)
+	circonference_terre_metres = 2 * math.pi * rayon_terre_metres * math.cos(latitude_radians)
+	longueur_degre_longitude_metres = circonference_terre_metres / 360
+	print(type(longitude_actuelle))
+	return longitude_actuelle - (deplacement_metre / longueur_degre_longitude_metres)
+
+
+def latitudePlus(latitude_actuelle, deplacement_metre):
+	rayon_terre_metres = 6371000
+	return latitude_actuelle - (deplacement_metre / rayon_terre_metres) * (180 / math.pi)
+	
+def latitudeMoins(latitude_actuelle, deplacement_metre):
+	rayon_terre_metres = 6371000
+	nouvelle_latitude = latitude_actuelle + (deplacement_metre / rayon_terre_metres) * (180 / math.pi)
+	return nouvelle_latitude
+
+def Milieu(Latitude,Longitude,distance,definition):
+	Latitude=latitudeMoins(Latitude,distance/2)
+	Longitude=longitudeMoins(Longitude,distance/2,Latitude)	
+	lenX=int(distance/definition)
+	lenY=int(distance/definition)
+	deplacement_metres = definition
+	return Latitude,Longitude,lenX,lenY,deplacement_metres

Vieux/OpenElevation/OpenElevation.py

@@ -0,0 +1,63 @@
+import requests
+import json
+import time
+
+def alt(longitude, latitude):
+	if len(longitude) != len(latitude):
+		print ("Les tableaux de longitude et de latitude doivent avoir la même taille.")
+		return "error"
+	total_elements = len(longitude)
+	batch_size = 200
+
+	start = 0
+	res=[]
+	i=0
+	while start < total_elements:
+		print(i,"/",total_elements/batch_size)
+		i=i+1
+		end = min(start + batch_size, total_elements)
+	
+
+		longitude_batch = longitude[start:end]
+		latitude_batch = latitude[start:end]
+
+		res=res+req(longitude_batch, latitude_batch, len(longitude_batch))
+
+		# Mettez à jour l'indice de début pour le prochain lot
+		start = end
+	return res
+		
+def req(latitude, longitude,nb):
+	url = f'https://api.open-elevation.com/api/v1/lookup?locations='
+	for i in range(nb):
+			url +=  str(latitude[i])
+			url += ","
+			url += str(longitude[i])
+			url += "|"
+	
+	while(1):
+		try:
+			response = requests.get(url)
+			
+			if response.status_code == 200:
+				try:
+					data = json.loads(response.text)
+					elevations = [result['elevation'] for result in data['results']]
+
+					return elevations
+					
+					"""if 'elevations' in data:
+						elevation = data['elevations']
+						return elevation
+					else:
+						print("Impossible d'obtenir l'altitude pour les coordonnées spécifiées.")
+					"""
+				except:
+					print("impossible de decode")
+					# ~ print(url)
+					# ~ print(latitude,",",longitude)
+					time.sleep(1)
+			else:
+				print(f"Erreur de réponse de l'API. Code de statut : {response.status_code}")
+		except requests.exceptions.RequestException as e:
+			print(f"Une erreur s'est produite lors de la requête : {e}")

Vieux/OpenElevation/STL.py

@@ -0,0 +1,113 @@
+from stl import mesh
+import numpy as np
+
+def lire_et_extraire_infos(nom_fichier):
+	entiers = []
+	tableau_float = []
+	try:
+		with open(nom_fichier, 'r') as fichier:
+			lignes = fichier.readlines()
+			
+			for i in range(3):
+				entiers.append(int(lignes[i].strip()))  # Convertit en entier et supprime les espaces en début et fin de ligne
+			
+			quatrieme_ligne = lignes[3].strip('[]\n').split(',')
+			tableau_float = [float(x) for x in quatrieme_ligne]
+
+		return entiers, tableau_float
+	except FileNotFoundError:
+		print(f"Le fichier '{nom_fichier}' n'a pas été trouvé.")
+		return None, None
+
+
+def transformeSTL(nom):
+	nomDonne = nom+".rcl"
+	donne = lire_et_extraire_infos(nomDonne)
+
+	deplacement_metres=donne[0][0]
+	lenX=donne[0][1]
+	lenY=donne[0][2]
+	test=donne[1]
+
+	facteur = deplacement_metres
+
+	test = [nombre / facteur for nombre in test]
+	mini=min(test)-1
+	test = [nombre - mini for nombre in test]
+
+	vertices = np.zeros((lenX*lenY * 2,3) , dtype=float)
+	y=0
+	for i in range (0,lenX):
+		for j in range (0,lenY):
+			vertices[y]= [i,j,0]
+			vertices[y+1]= [i,j,test[i*lenY+j]]
+			y=y+2
+
+
+
+	nb=(lenX*2-2)
+	faces1 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2-2,2):
+		faces1[y] = [i,i+1 ,i+2]
+		faces1[y+1] = [i+1 ,i+3,i+2]
+		y=y+2
+
+
+
+	nb=lenY*2-2
+	faces2 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2*lenY-lenY*2 ,lenX*2):
+		faces2[y] 	= [i,i+1,i+lenX*2]
+		faces2[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb=(lenX*2-2)
+	Start3 = (lenX*2*lenY)-lenX*2
+	faces3 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start3,lenX*2-2+Start3,2):
+		faces3[y] = [i,i+1 ,i+2]
+		faces3[y+1] = [i+1,i+3 ,i+2]
+		y=y+2
+
+	nb = lenY*2-2
+	Start4 = lenX*2-2
+	faces4 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start4,lenX*2*lenY-lenY*2 +Start4,lenX*2):
+		faces4[y] 	= [i,i+1,i+lenX*2]
+		faces4[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb = 2
+	faces5 = np.zeros((nb,3), dtype=int)
+	faces5[0] =[0,lenX*2-2,(lenX*2*lenY)-lenX*2]
+	faces5[1] =[lenX*2-2,lenX*lenY*2-2,(lenX*2*lenY)-lenX*2]
+
+
+	nb=lenX*lenY*2
+	faces6 = np.zeros((nb,3), dtype=int)
+	y=0
+	for j in range(0,lenY-1):
+		for i in range(lenX*2*j+1,lenX*2*j+lenX*2-1,2):
+			faces6[y]=[i,i+2,lenX*2+i]
+			faces6[y+1]=[i+2,lenX*2+i+2,lenX*2+i]
+			y=y+2
+			
+
+	faces=np.concatenate((faces1, faces2,faces3,faces4,faces5,faces6), axis=0)
+
+	# Créez le maillage STL
+	cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+
+	for i, f in enumerate(faces):
+		for j in range(3):
+			cube.vectors[i][j] = vertices[f[j], :]
+
+	#Sauvegardez le cube au format STL
+	nomSTL=nom+".stl"
+	cube.save(nomSTL)
+
+	#"""

Vieux/OpenElevation/main.py

@@ -0,0 +1,36 @@
+from GPS import *
+from recupere import *
+from STL import *
+
+#45.221435, 5.016486 tersanne
+#45.171243, 5.722483 Grenoble
+#45.831949, 6.864395 mont blanc
+#45.010632, 5.443115 Vercors
+#45.849367, 6.182756 LacAnnecy
+#27.987348, 86.922997 Everest
+nom = "Everest"
+Latitude = 27.987348
+Longitude = 86.922997
+distance = 5000
+definition = 50
+
+gps = Milieu(Latitude,Longitude,distance,definition)
+
+latitudeStart = gps[0]
+longitudeStart = gps[1]
+deplacement_metres = gps[4]
+facteur = deplacement_metres
+lenX=gps[2]
+lenY=gps[3]
+
+print("Latitude de départ:", latitudeStart)
+print("Longitude de départ:", longitudeStart)
+print("Déplacement en mètres:", deplacement_metres)
+print("Facteur:", facteur)
+print("Longueur en X:", lenX)
+print("Longueur en Y:", lenY)
+
+
+recupere(latitudeStart,longitudeStart,deplacement_metres,facteur,lenX,lenY,nom)
+
+transformeSTL(nom)

Vieux/OpenElevation/recupere.py

@@ -0,0 +1,41 @@
+from stl import mesh
+import numpy as np
+import requests
+import math
+import time
+import datetime
+
+from OpenElevation import alt
+from GPS import *
+
+
+
+
+def ecrire_donnees(deplacement_metres,lenX,lenY,altitude,nom):
+	now = datetime.datetime.now()
+	date_heure = now.strftime("%Y-%m-%d-%H-%M-%S")
+	#nom_fichier = f"Donne({date_heure}).txt"
+	nom_fichier = nom+".rcl"
+	with open(nom_fichier, "w") as fichier:
+		fichier.write(f"{deplacement_metres}\n")
+		fichier.write(f"{lenX}\n")
+		fichier.write(f"{lenY}\n")
+		fichier.write(f"{altitude}\n")
+
+def recupere(latitudeStart,longitudeStart,deplacement_metres,facteur,lenX,lenY,nom):
+	Tabaltitude=[]
+	latitude=latitudeStart
+	TabLongitude=[]
+	TabLatittude=[]
+	for j in range (0,lenX):
+		longitude=longitudeStart
+		for i in range (0,lenY):
+			TabLongitude.append(longitude)
+			TabLatittude.append(latitude)
+			longitude=longitudePlus(longitude,deplacement_metres,latitude)
+		latitude=latitudePlus(latitude,deplacement_metres)
+		
+	Tabaltitude=alt(TabLatittude,TabLongitude)
+	ecrire_donnees(deplacement_metres,lenX,lenY,Tabaltitude,nom)
+
+	# print(latitude,",",longitude)

Vieux/STL.py

@@ -0,0 +1,116 @@
+from stl import mesh
+import numpy as np
+
+def lire_et_extraire_infos(nom_fichier):
+	entiers = []
+	tableau_float = []
+	try:
+		with open(nom_fichier, 'r') as fichier:
+			lignes = fichier.readlines()
+			
+			for i in range(3):
+				entiers.append(int(lignes[i].strip()))  # Convertit en entier et supprime les espaces en début et fin de ligne
+			
+			quatrieme_ligne = lignes[3].strip('[]\n').split(',')
+			tableau_float = [float(x) for x in quatrieme_ligne]
+
+		return entiers, tableau_float
+	except FileNotFoundError:
+		print(f"Le fichier '{nom_fichier}' n'a pas été trouvé.")
+		return None, None
+
+
+def transformeSTL(nom):
+	nomDonne = nom+".rcl"
+	donne = lire_et_extraire_infos(nomDonne)
+
+	deplacement_metres=donne[0][0]
+	lenX=donne[0][1]
+	lenY=donne[0][2]
+	test=donne[1]
+
+	facteur = deplacement_metres
+
+	test = [nombre / facteur for nombre in test]
+	mini=min(test)-1
+	test = [nombre - mini for nombre in test]
+
+	vertices = np.zeros((lenX*lenY * 2,3) , dtype=float)
+	y=0
+	for i in range (0,lenX):
+		for j in range (0,lenY):
+			vertices[y]= [i,j,0]
+			vertices[y+1]= [i,j,test[i*lenY+j]]
+			y=y+2
+
+
+
+	nb=(lenX*2-2)
+	faces1 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2-2,2):
+		faces1[y] = [i,i+1 ,i+2]
+		faces1[y+1] = [i+1 ,i+3,i+2]
+		y=y+2
+
+
+
+	nb=lenY*2-2
+	faces2 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2*lenY-lenY*2 ,lenX*2):
+		faces2[y] 	= [i,i+1,i+lenX*2]
+		faces2[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb=(lenX*2-2)
+	Start3 = (lenX*2*lenY)-lenX*2
+	faces3 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start3,lenX*2-2+Start3,2):
+		faces3[y] = [i,i+1 ,i+2]
+		faces3[y+1] = [i+1,i+3 ,i+2]
+		y=y+2
+
+	nb = lenY*2-2
+	Start4 = lenX*2-2
+	faces4 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start4,lenX*2*lenY-lenY*2 +Start4,lenX*2):
+		faces4[y] 	= [i,i+1,i+lenX*2]
+		faces4[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb = 2
+	faces5 = np.zeros((nb,3), dtype=int)
+	faces5[0] =[0,lenX*2-2,(lenX*2*lenY)-lenX*2]
+	faces5[1] =[lenX*2-2,lenX*lenY*2-2,(lenX*2*lenY)-lenX*2]
+
+
+	nb=lenX*lenY*2
+	faces6 = np.zeros((nb,3), dtype=int)
+	y=0
+	for j in range(0,lenY-1):
+		for i in range(lenX*2*j+1,lenX*2*j+lenX*2-1,2):
+			faces6[y]=[i,i+2,lenX*2+i]
+			faces6[y+1]=[i+2,lenX*2+i+2,lenX*2+i]
+			y=y+2
+			
+
+	faces=np.concatenate((faces1, faces2,faces3,faces4,faces5,faces6), axis=0)
+
+	# Créez le maillage STL
+	
+	
+	cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+
+	for i, f in enumerate(faces):
+		for j in range(3):
+			cube.vectors[i][j] = vertices[f[j], :]
+
+	#Sauvegardez le cube au format STL
+	nomSTL=nom+".stl"
+	cube.save(nomSTL)
+
+	#"""
+transformeSTL("testreduit")

Vieux/STLperso.py

@@ -0,0 +1,113 @@
+from stl import mesh
+import numpy as np
+
+def lire_et_extraire_infos(nom_fichier):
+	entiers = []
+	tableau_float = []
+	try:
+		with open(nom_fichier, 'r') as fichier:
+			lignes = fichier.readlines()
+			
+			for i in range(3):
+				entiers.append(int(lignes[i].strip()))  # Convertit en entier et supprime les espaces en début et fin de ligne
+			
+			quatrieme_ligne = lignes[3].strip('[]\n').split(',')
+			tableau_float = [float(x) for x in quatrieme_ligne]
+
+		return entiers, tableau_float
+	except FileNotFoundError:
+		print(f"Le fichier '{nom_fichier}' n'a pas été trouvé.")
+		return None, None
+
+
+def transformeSTL(nom):
+	nomDonne = nom+".rcl"
+	donne = lire_et_extraire_infos(nomDonne)
+
+	deplacement_metres=donne[0][0]
+	lenX=donne[0][1]
+	lenY=donne[0][2]
+	test=donne[1]
+
+	facteur = deplacement_metres
+
+	test = [nombre / facteur for nombre in test]
+	mini=min(test)-1
+	test = [nombre - mini for nombre in test]
+
+	vertices = np.zeros((lenX*lenY * 2,3) , dtype=float)
+	y=0
+	for i in range (0,lenX):
+		for j in range (0,lenY):
+			vertices[y]= [i,j,0]
+			vertices[y+1]= [i,j,test[i*lenY+j]]
+			y=y+2
+
+
+
+	nb=(lenX*2-2)
+	faces1 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2-2,2):
+		faces1[y] = [i,i+1 ,i+2]
+		faces1[y+1] = [i+1 ,i+3,i+2]
+		y=y+2
+
+
+
+	nb=lenY*2-2
+	faces2 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2*lenY-lenY*2 ,lenX*2):
+		faces2[y] 	= [i,i+1,i+lenX*2]
+		faces2[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb=(lenX*2-2)
+	Start3 = (lenX*2*lenY)-lenX*2
+	faces3 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start3,lenX*2-2+Start3,2):
+		faces3[y] = [i,i+1 ,i+2]
+		faces3[y+1] = [i+1,i+3 ,i+2]
+		y=y+2
+
+	nb = lenY*2-2
+	Start4 = lenX*2-2
+	faces4 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start4,lenX*2*lenY-lenY*2 +Start4,lenX*2):
+		faces4[y] 	= [i,i+1,i+lenX*2]
+		faces4[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb = 2
+	faces5 = np.zeros((nb,3), dtype=int)
+	faces5[0] =[0,lenX*2-2,(lenX*2*lenY)-lenX*2]
+	faces5[1] =[lenX*2-2,lenX*lenY*2-2,(lenX*2*lenY)-lenX*2]
+
+
+	nb=lenX*lenY*2
+	faces6 = np.zeros((nb,3), dtype=int)
+	y=0
+	for j in range(0,lenY-1):
+		for i in range(lenX*2*j+1,lenX*2*j+lenX*2-1,2):
+			faces6[y]=[i,i+2,lenX*2+i]
+			faces6[y+1]=[i+2,lenX*2+i+2,lenX*2+i]
+			y=y+2
+			
+
+	faces=np.concatenate((faces1, faces2,faces3,faces4,faces5,faces6), axis=0)
+
+	# Créez le maillage STL
+	cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+
+	for i, f in enumerate(faces):
+		for j in range(3):
+			cube.vectors[i][j] = vertices[f[j], :]
+
+	#Sauvegardez le cube au format STL
+	nomSTL=nom+".stl"
+	cube.save(nomSTL)
+
+	#"""

Vieux/Test/CubeV2.py

@@ -0,0 +1,38 @@
+from stl import mesh
+import numpy as np
+
+# Définir les sommets du cube
+vertices = np.array([
+    [-1, -1, -1],
+    [+1, -1, -1],
+    [+1, +1, -1],
+    [-1, +1, -1],
+    [-1, -1, +1],
+    [+1, -1, +1],
+    [+1, +1, +1],
+    [-1, +1, +1]
+])
+
+# Définir les faces du cube (triangles individuels)
+faces = np.array([
+    [0, 1, 2],
+    [0, 2, 3],
+    [0, 4, 5],
+    [0, 5, 1],
+    [1, 5, 6],
+    [1, 6, 2],
+    [2, 6, 7],
+    [2, 7, 3],
+    [3, 7, 4],
+    [3, 4, 0],
+    [4, 7, 6],
+    [4, 6, 5]
+])
+
+# Créer le maillage STL
+cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+for i, f in enumerate(faces):
+    cube.vectors[i] = vertices[f]
+
+# Sauvegarder le cube au format STL
+cube.save('cube.stl')

Vieux/Test/cube.py

@@ -0,0 +1,165 @@
+from stl import mesh
+import numpy as np
+
+# Créer un cube 3D
+vertices = np.array([[0,0,0],
+					[0,0,1],
+					[1,0,0],
+					[1,0,1],
+					[2,0,0],
+					[2,0,2],
+					[3,0,0],
+					[3,0,2],
+					[0,1,0],
+					[0,1,1],
+					[1,1,0],
+					[1,1,1],
+					[2,1,0],
+					[2,1,2],
+					[3,1,0],
+					[3,1,2],
+					[0,2,0],
+					[0,2,1],
+					[1,2,0],
+					[1,2,1],
+					[2,2,0],
+					[2,2,2],
+					[3,2,0],
+					[3,2,2],
+					[0,3,0],
+					[0,3,1],
+					[1,3,0],
+					[1,3,1],
+					[2,3,0],
+					[2,3,2],
+					[3,3,0],
+					[3,3,2]])
+					
+vertices3 = np.array([[0,0,0],
+					[0,0,1],
+					[1,0,0],
+					[1,0,1],
+					[2,0,0],
+					[2,0,2],
+					[0,1,0],
+					[0,1,1],
+					[1,1,0],
+					[1,1,1],
+					[2,1,0],
+					[2,1,2],
+					[0,2,0],
+					[0,2,1],
+					[1,2,0],
+					[1,2,1],
+					[2,2,0],
+					[2,2,2]])
+					
+					
+vertices4 = np.array([[0,0,0],
+					[0,0,1],
+					[1,0,0],
+					[1,0,1],
+					[2,0,0],
+					[2,0,2],
+					[3,0,0],
+					[3,0,2],
+					[0,1,0],
+					[0,1,1],
+					[1,1,0],
+					[1,1,1],
+					[2,1,0],
+					[2,1,2],
+					[3,1,0],
+					[3,1,2],
+					[0,2,0],
+					[0,2,1],
+					[1,2,0],
+					[1,2,1],
+					[2,2,0],
+					[2,2,2],
+					[3,2,0],
+					[3,2,2],
+					[0,3,0],
+					[0,3,1],
+					[1,3,0],
+					[1,3,1],
+					[2,3,0],
+					[2,3,2],
+					[3,3,0],
+					[3,3,2]])
+
+"""			
+vertices=vertices3
+lenX = 3
+lenY = 3
+
+"""
+vertices=vertices4
+lenX = 4
+lenY = 4
+
+
+
+nb=(lenX*2-2)
+faces1 = np.zeros((nb, 3), dtype=int)
+y=0
+for i in range(0,lenX*2-2,2):
+	faces1[y] = [i,i+1 ,i+2]
+	faces1[y+1] = [i+1 ,i+3,i+2]
+	y=y+2
+
+
+
+nb=lenY*2-2
+faces2 = np.zeros((nb, 3), dtype=int)
+y=0
+for i in range(0,lenX*lenY+1,lenX*2):
+	faces2[y] 	= [i,i+1,i+lenX*2]
+	faces2[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+	y=y+2
+
+nb=(lenX*2-2)
+Start3 = (lenX*2*lenY)-lenX*2
+faces3 = np.zeros((nb, 3), dtype=int)
+y=0
+for i in range(Start3,lenX*2-2+Start3,2):
+	faces3[y] = [i,i+1 ,i+2]
+	faces3[y+1] = [i+1,i+3 ,i+2]
+	y=y+2
+
+nb = lenY*2-2
+Start4 = lenX*2-2
+faces4 = np.zeros((nb, 3), dtype=int)
+y=0
+for i in range(Start4,lenX*lenY+1+Start4,lenX*2):
+	faces4[y] 	= [i,i+1,i+lenX*2]
+	faces4[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+	y=y+2
+
+nb = 2
+faces5 = np.zeros((nb,3), dtype=int)
+faces5[0] =[0,lenX*2-2,(lenX*2*lenY)-lenX*2]
+faces5[1] =[lenX*2-2,lenX*lenY*2-2,(lenX*2*lenY)-lenX*2]
+
+
+nb=lenX*lenY*2
+faces6 = np.zeros((nb,3), dtype=int)
+y=0
+for j in range(0,lenY-1):
+	for i in range(lenX*2*j+1,lenX*2*j+lenX*2-1,2):
+		faces6[y]=[i,i+2,lenX*2+i]
+		faces6[y+1]=[i+2,lenX*2+i+2,lenX*2+i]
+		y=y+2
+		
+
+faces=np.concatenate((faces1, faces2,faces3,faces4,faces5,faces6), axis=0)
+
+# Créez le maillage STL
+cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+
+for i, f in enumerate(faces):
+    for j in range(3):
+        cube.vectors[i][j] = vertices[f[j], :]
+
+#Sauvegardez le cube au format STL
+cube.save('cube.stl')

Vieux/Test/test.py

@@ -0,0 +1,119 @@
+from stl import mesh
+import numpy as np
+import requests
+import math
+import time
+import json
+
+# Coordonnées GPS (latitude, longitude) du point dont vous souhaitez obtenir l'altitude
+latitudeStart = 44.903360
+longitudeStart = 5.356751
+
+deplacement_metres = 100
+
+facteur = deplacement_metres
+
+lenX=10
+lenY=10
+
+import math
+
+test=[1430.0, 1369.85, 1298.29, 1229.3, 1175.09, 1138.52, 1124.26, 1105.4, 1095.02, 1082.01, 1422.49, 1349.6, 1284.16, 1210.23, 1150.72, 1114.83, 1097.72, 1091.05, 1078.23, 1069.26, 1414.12, 1336.12, 1270.67, 1190.59, 1125.19, 1096.12, 1082.26, 1073.76, 1063.9, 1058.02, 1402.96, 1340.04, 1267.52, 1164.27, 1101.05, 1080.91, 1072.28, 1064.41, 1056.36, 1051.67, 1381.24, 1321.08, 1247.24, 1137.52, 1083.51, 1074.58, 1067.2, 1054.67, 1048.43, 1047.06, 1355.6, 1297.31, 1215.26, 1115.71, 1084.07, 1077.54, 1059.52, 1047.86, 1044.04, 1043.31, 1326.47, 1265.13, 1183.72, 1107.97, 1083.95, 1067.03, 1054.31, 1044.21, 1041.29, 1041.12, 1296.84, 1233.47, 1162.75, 1111.98, 1088.34, 1069.63, 1055.8, 1045.91, 1042.01, 1040.87, 1272.49, 1214.92, 1160.39, 1117.79, 1086.36, 1067.9, 1057.78, 1048.49, 1043.65, 1041.59, 1261.53, 1207.49, 1164.9, 1121.47, 1088.72, 1073.59, 1062.01, 1057.08, 1055.04, 1056.71]
+"""
+latitude=latitudeStart
+for j in range (0,lenX):
+	longitude=longitudeStart
+	print(j,"/",lenX)
+	for i in range (0,lenY):
+		altitude = alt(latitude,longitude)
+		# print(latitude,",",longitude)
+		# print(altitude)
+		longitude=longitudePlus(longitude,deplacement_metres)
+		test.append(altitude)
+		# time.sleep(0.1)
+	latitude=latitudePlus(latitude,deplacement_metres)
+
+print(latitude,",",longitude)
+
+print(test)
+"""
+test = [nombre / facteur for nombre in test]
+mini=min(test)-1
+test = [nombre - mini for nombre in test]
+
+vertices = np.zeros((lenX*lenY * 2,3) , dtype=float)
+y=0
+for i in range (0,lenX):
+	for j in range (0,lenY):
+		vertices[y]= [i,j,0]
+		vertices[y+1]= [i,j,test[i*lenY+j]]
+		y=y+2
+
+
+
+nb=(lenX*2-2)
+faces1 = np.zeros((nb, 3), dtype=int)
+y=0
+for i in range(0,lenX*2-2,2):
+	faces1[y] = [i,i+1 ,i+2]
+	faces1[y+1] = [i+1 ,i+3,i+2]
+	y=y+2
+
+
+
+nb=lenY*2-2
+faces2 = np.zeros((nb, 3), dtype=int)
+y=0
+for i in range(0,lenX*2*lenY-lenY*2 ,lenX*2):
+	faces2[y] 	= [i,i+1,i+lenX*2]
+	faces2[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+	y=y+2
+
+nb=(lenX*2-2)
+Start3 = (lenX*2*lenY)-lenX*2
+faces3 = np.zeros((nb, 3), dtype=int)
+y=0
+for i in range(Start3,lenX*2-2+Start3,2):
+	print(i)
+	faces3[y] = [i,i+1 ,i+2]
+	faces3[y+1] = [i+1,i+3 ,i+2]
+	y=y+2
+
+nb = lenY*2-2
+Start4 = lenX*2-2
+faces4 = np.zeros((nb, 3), dtype=int)
+y=0
+for i in range(Start4,lenX*2*lenY-lenY*2+Start4,lenX*2):
+	faces4[y] 	= [i,i+1,i+lenX*2]
+	faces4[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+	y=y+2
+
+nb = 2
+faces5 = np.zeros((nb,3), dtype=int)
+faces5[0] =[0,lenX*2-2,(lenX*2*lenY)-lenX*2]
+faces5[1] =[lenX*2-2,lenX*lenY*2-2,(lenX*2*lenY)-lenX*2]
+
+
+nb=lenX*lenY*2
+faces6 = np.zeros((nb,3), dtype=int)
+y=0
+for j in range(0,lenY-1):
+	for i in range(lenX*2*j+1,lenX*2*j+lenX*2-1,2):
+		faces6[y]=[i,i+2,lenX*2+i]
+		faces6[y+1]=[i+2,lenX*2+i+2,lenX*2+i]
+		y=y+2
+
+faces=np.concatenate((faces1, faces2,faces3,faces4,faces5,faces6), axis=0)
+
+
+# Créez le maillage STL
+cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+
+for i, f in enumerate(faces):
+    for j in range(3):
+        cube.vectors[i][j] = vertices[f[j], :]
+
+#Sauvegardez le cube au format STL
+cube.save('IGN.stl')
+
+#"""

Vieux/Vieux/geonames.py

@@ -0,0 +1,24 @@
+import requests
+
+def alt(latitude, longitude):
+	# URL de l'API Geonames
+	
+	http://api.geonames.org/srtm1?lats=50.01,51.01&lngs=10.2,11.2&username=demo
+	url = f'http://api.geonames.org/srtm3JSON?lat={latitude}&lng={longitude}&username=faloro'
+
+	try:
+		response = requests.get(url)
+		
+		if response.status_code == 200:
+			data = response.json()
+			
+			if 'srtm3' in data:
+				elevation = data['srtm3']
+				return elevation
+			else:
+				print(data)
+				#print("Impossible d'obtenir l'altitude pour les coordonnées spécifiées.")
+		else:
+			print(f"Erreur de réponse de l'API. Code de statut : {response.status_code}")
+	except requests.exceptions.RequestException as e:
+		print(f"Une erreur s'est produite lors de la requête : {e}")

Vieux/geonames.py

@@ -0,0 +1,24 @@
+import requests
+
+def alt(latitude, longitude):
+	# URL de l'API Geonames
+	
+	http://api.geonames.org/srtm1?lats=50.01,51.01&lngs=10.2,11.2&username=demo
+	url = f'http://api.geonames.org/srtm3JSON?lat={latitude}&lng={longitude}&username=faloro'
+
+	try:
+		response = requests.get(url)
+		
+		if response.status_code == 200:
+			data = response.json()
+			
+			if 'srtm3' in data:
+				elevation = data['srtm3']
+				return elevation
+			else:
+				print(data)
+				#print("Impossible d'obtenir l'altitude pour les coordonnées spécifiées.")
+		else:
+			print(f"Erreur de réponse de l'API. Code de statut : {response.status_code}")
+	except requests.exceptions.RequestException as e:
+		print(f"Une erreur s'est produite lors de la requête : {e}")

Vieux/main.py

@@ -0,0 +1,38 @@
+#pip install numpy-stl
+
+from GPS import *
+from recupere import *
+#from STLperso import *
+
+#45.221435, 5.016486 tersanne
+#45.171243, 5.722483 Grenoble
+#45.831949, 6.864395 mont blanc
+#45.010632, 5.443115 Vercors
+#45.849367, 6.182756 LacAnnecy
+#27.987348, 86.922997 Everest
+nom = "test"
+Latitude = 45.010632
+Longitude = 5.443115
+distance = 100
+definition = 30
+
+gps = Milieu(Latitude,Longitude,distance,definition)
+
+latitudeStart = gps[0]
+longitudeStart = gps[1]
+deplacement_metres = gps[4]
+facteur = deplacement_metres
+lenX=gps[2]
+lenY=gps[3]
+
+print("Latitude de départ:", latitudeStart)
+print("Longitude de départ:", longitudeStart)
+print("Déplacement en mètres:", deplacement_metres)
+print("Facteur:", facteur)
+print("Longueur en X:", lenX)
+print("Longueur en Y:", lenY)
+
+
+recupere(latitudeStart,longitudeStart,deplacement_metres,facteur,lenX,lenY,nom)
+
+#transformeSTL(nom)

Vieux/open-meteo/GPS.py

@@ -0,0 +1,34 @@
+import math
+
+def longitudePlus(longitude_actuelle, deplacement_metre,latitude):
+	rayon_terre_metres = 6371000
+	latitude_radians = math.radians(latitude)
+	circonference_terre_metres = 2 * math.pi * rayon_terre_metres * math.cos(latitude_radians)
+	longueur_degre_longitude_metres = circonference_terre_metres / 360
+	return longitude_actuelle + (deplacement_metre / longueur_degre_longitude_metres)
+	 
+def longitudeMoins(longitude_actuelle, deplacement_metre, latitude):
+	rayon_terre_metres = 6371000
+	latitude_radians = math.radians(latitude)
+	circonference_terre_metres = 2 * math.pi * rayon_terre_metres * math.cos(latitude_radians)
+	longueur_degre_longitude_metres = circonference_terre_metres / 360
+	print(type(longitude_actuelle))
+	return longitude_actuelle - (deplacement_metre / longueur_degre_longitude_metres)
+
+
+def latitudePlus(latitude_actuelle, deplacement_metre):
+	rayon_terre_metres = 6371000
+	return latitude_actuelle - (deplacement_metre / rayon_terre_metres) * (180 / math.pi)
+	
+def latitudeMoins(latitude_actuelle, deplacement_metre):
+	rayon_terre_metres = 6371000
+	nouvelle_latitude = latitude_actuelle + (deplacement_metre / rayon_terre_metres) * (180 / math.pi)
+	return nouvelle_latitude
+
+def Milieu(Latitude,Longitude,distance,definition):
+	Latitude=latitudeMoins(Latitude,distance/2)
+	Longitude=longitudeMoins(Longitude,distance/2,Latitude)	
+	lenX=int(distance/definition)
+	lenY=int(distance/definition)
+	deplacement_metres = definition
+	return Latitude,Longitude,lenX,lenY,deplacement_metres

Vieux/open-meteo/STL.py

@@ -0,0 +1,113 @@
+from stl import mesh
+import numpy as np
+
+def lire_et_extraire_infos(nom_fichier):
+	entiers = []
+	tableau_float = []
+	try:
+		with open(nom_fichier, 'r') as fichier:
+			lignes = fichier.readlines()
+			
+			for i in range(3):
+				entiers.append(int(lignes[i].strip()))  # Convertit en entier et supprime les espaces en début et fin de ligne
+			
+			quatrieme_ligne = lignes[3].strip('[]\n').split(',')
+			tableau_float = [float(x) for x in quatrieme_ligne]
+
+		return entiers, tableau_float
+	except FileNotFoundError:
+		print(f"Le fichier '{nom_fichier}' n'a pas été trouvé.")
+		return None, None
+
+
+def transformeSTL(nom):
+	nomDonne = nom+".rcl"
+	donne = lire_et_extraire_infos(nomDonne)
+
+	deplacement_metres=donne[0][0]
+	lenX=donne[0][1]
+	lenY=donne[0][2]
+	test=donne[1]
+
+	facteur = deplacement_metres
+
+	test = [nombre / facteur for nombre in test]
+	mini=min(test)-1
+	test = [nombre - mini for nombre in test]
+
+	vertices = np.zeros((lenX*lenY * 2,3) , dtype=float)
+	y=0
+	for i in range (0,lenX):
+		for j in range (0,lenY):
+			vertices[y]= [i,j,0]
+			vertices[y+1]= [i,j,test[i*lenY+j]]
+			y=y+2
+
+
+
+	nb=(lenX*2-2)
+	faces1 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2-2,2):
+		faces1[y] = [i,i+1 ,i+2]
+		faces1[y+1] = [i+1 ,i+3,i+2]
+		y=y+2
+
+
+
+	nb=lenY*2-2
+	faces2 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(0,lenX*2*lenY-lenY*2 ,lenX*2):
+		faces2[y] 	= [i,i+1,i+lenX*2]
+		faces2[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb=(lenX*2-2)
+	Start3 = (lenX*2*lenY)-lenX*2
+	faces3 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start3,lenX*2-2+Start3,2):
+		faces3[y] = [i,i+1 ,i+2]
+		faces3[y+1] = [i+1,i+3 ,i+2]
+		y=y+2
+
+	nb = lenY*2-2
+	Start4 = lenX*2-2
+	faces4 = np.zeros((nb, 3), dtype=int)
+	y=0
+	for i in range(Start4,lenX*2*lenY-lenY*2 +Start4,lenX*2):
+		faces4[y] 	= [i,i+1,i+lenX*2]
+		faces4[y+1] = [i+1,i+lenX*2+1,i+lenX*2]
+		y=y+2
+
+	nb = 2
+	faces5 = np.zeros((nb,3), dtype=int)
+	faces5[0] =[0,lenX*2-2,(lenX*2*lenY)-lenX*2]
+	faces5[1] =[lenX*2-2,lenX*lenY*2-2,(lenX*2*lenY)-lenX*2]
+
+
+	nb=lenX*lenY*2
+	faces6 = np.zeros((nb,3), dtype=int)
+	y=0
+	for j in range(0,lenY-1):
+		for i in range(lenX*2*j+1,lenX*2*j+lenX*2-1,2):
+			faces6[y]=[i,i+2,lenX*2+i]
+			faces6[y+1]=[i+2,lenX*2+i+2,lenX*2+i]
+			y=y+2
+			
+
+	faces=np.concatenate((faces1, faces2,faces3,faces4,faces5,faces6), axis=0)
+
+	# Créez le maillage STL
+	cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+
+	for i, f in enumerate(faces):
+		for j in range(3):
+			cube.vectors[i][j] = vertices[f[j], :]
+
+	#Sauvegardez le cube au format STL
+	nomSTL=nom+".stl"
+	cube.save(nomSTL)
+
+	#"""

Vieux/open-meteo/main.py

@@ -0,0 +1,36 @@
+from GPS import *
+from recupere import *
+from STL import *
+
+#45.221435, 5.016486 tersanne
+#45.171243, 5.722483 Grenoble
+#45.831949, 6.864395 mont blanc
+#45.010632, 5.443115 Vercors
+#45.849367, 6.182756 LacAnnecy
+#27.987348, 86.922997 Everest
+nom = "Everest"
+Latitude = 27.987348
+Longitude = 86.922997
+distance = 5000
+definition = 50
+
+gps = Milieu(Latitude,Longitude,distance,definition)
+
+latitudeStart = gps[0]
+longitudeStart = gps[1]
+deplacement_metres = gps[4]
+facteur = deplacement_metres
+lenX=gps[2]
+lenY=gps[3]
+
+print("Latitude de départ:", latitudeStart)
+print("Longitude de départ:", longitudeStart)
+print("Déplacement en mètres:", deplacement_metres)
+print("Facteur:", facteur)
+print("Longueur en X:", lenX)
+print("Longueur en Y:", lenY)
+
+
+recupere(latitudeStart,longitudeStart,deplacement_metres,facteur,lenX,lenY,nom)
+
+transformeSTL(nom)

Vieux/open-meteo/openMeteo.py

@@ -0,0 +1,68 @@
+import requests
+import json
+import time
+
+def alt(longitude, latitude):
+	if len(longitude) != len(latitude):
+		print ("Les tableaux de longitude et de latitude doivent avoir la même taille.")
+		return "error"
+	total_elements = len(longitude)
+	batch_size = 100
+
+	start = 0
+	res=[]
+	i=0
+	while start < total_elements:
+		print(i,"/",total_elements/batch_size)
+		i=i+1
+		end = min(start + batch_size, total_elements)
+	
+
+		longitude_batch = longitude[start:end]
+		latitude_batch = latitude[start:end]
+
+		res=res+req(longitude_batch, latitude_batch, len(longitude_batch))
+
+		# Mettez à jour l'indice de début pour le prochain lot
+		start = end
+	return res
+		
+
+def req(latitude, longitude,nb):
+	longi=""
+	latti=""
+	for i in range(nb):
+		if i > 0:
+			longi += ","
+			latti += ","
+			
+		longi += str(longitude[i])
+		latti += str(latitude[i])
+		
+	
+	url = f'https://api.open-meteo.com/v1/elevation?latitude={latti}&longitude={longi}'
+	
+	rd=0
+	while(1):
+		print(rd)
+		rd=rd+1
+		try:
+			response = requests.get(url)
+			
+			if response.status_code == 200:
+				try:
+					data = json.loads(response.text)
+				
+					if 'elevation' in data:
+						elevation = data['elevation']
+						return elevation
+					else:
+						print("Impossible d'obtenir l'altitude pour les coordonnées spécifiées.")
+				except:
+					print(url)
+					print(latitude,",",longitude)
+					time.sleep(1)
+			else:
+				print(f"Erreur de réponse de l'API. Code de statut : {response.status_code}")
+		except requests.exceptions.RequestException as e:
+			print(f"Une erreur s'est produite lors de la requête : {e}")

Vieux/open-meteo/recupere.py

@@ -0,0 +1,41 @@
+from stl import mesh
+import numpy as np
+import requests
+import math
+import time
+import datetime
+
+from openMeteo import alt
+from GPS import *
+
+
+
+
+def ecrire_donnees(deplacement_metres,lenX,lenY,altitude,nom):
+	now = datetime.datetime.now()
+	date_heure = now.strftime("%Y-%m-%d-%H-%M-%S")
+	#nom_fichier = f"Donne({date_heure}).txt"
+	nom_fichier = nom+".rcl"
+	with open(nom_fichier, "w") as fichier:
+		fichier.write(f"{deplacement_metres}\n")
+		fichier.write(f"{lenX}\n")
+		fichier.write(f"{lenY}\n")
+		fichier.write(f"{altitude}\n")
+
+def recupere(latitudeStart,longitudeStart,deplacement_metres,facteur,lenX,lenY,nom):
+	Tabaltitude=[]
+	latitude=latitudeStart
+	TabLongitude=[]
+	TabLatittude=[]
+	for j in range (0,lenX):
+		longitude=longitudeStart
+		for i in range (0,lenY):
+			TabLongitude.append(longitude)
+			TabLatittude.append(latitude)
+			longitude=longitudePlus(longitude,deplacement_metres,latitude)
+		latitude=latitudePlus(latitude,deplacement_metres)
+		
+	Tabaltitude=alt(TabLatittude,TabLongitude)
+	ecrire_donnees(deplacement_metres,lenX,lenY,Tabaltitude,nom)
+
+	# print(latitude,",",longitude)

Vieux/recupere.py

@@ -0,0 +1,39 @@
+#from stl import mesh
+import numpy as np
+import requests
+import math
+import time
+import datetime
+
+from IGN import alt
+from GPS import *
+
+
+def ecrire_donnees(deplacement_metres,lenX,lenY,altitude,nom):
+	now = datetime.datetime.now()
+	date_heure = now.strftime("%Y-%m-%d-%H-%M-%S")
+	#nom_fichier = f"Donne({date_heure}).txt"
+	nom_fichier = nom+".rcl"
+	with open(nom_fichier, "w") as fichier:
+		fichier.write(f"{deplacement_metres}\n")
+		fichier.write(f"{lenX}\n")
+		fichier.write(f"{lenY}\n")
+		fichier.write(f"{altitude}\n")
+
+def recupere(latitudeStart,longitudeStart,deplacement_metres,facteur,lenX,lenY,nom):
+	Tabaltitude=[]
+	latitude=latitudeStart
+	TabLongitude=[]
+	TabLatittude=[]
+	for j in range (0,lenX):
+		longitude=longitudeStart
+		for i in range (0,lenY):
+			TabLongitude.append(longitude)
+			TabLatittude.append(latitude)
+			longitude=longitudePlus(longitude,deplacement_metres,latitude)
+		latitude=latitudePlus(latitude,deplacement_metres)
+		
+	Tabaltitude=alt(TabLatittude,TabLongitude)
+	ecrire_donnees(deplacement_metres,lenX,lenY,Tabaltitude,nom)
+
+	# print(latitude,",",longitude)

Vieux/testEnregistreFrance.py

@@ -0,0 +1,186 @@
+import requests
+import json
+import os
+import time
+from multiprocessing import Pool, cpu_count
+
+# Paramètres globaux
+MIN_LAT, MAX_LAT = 41.0, 51.0
+MIN_LON, MAX_LON = -5.0, 8.0
+RESOLUTION = 0.000003  # Environ 30 cm
+BATCH_SIZE = 175
+MAX_FILE_SIZE = 2 * 1024 * 1024  # 2 Mo
+SECTIONS_FILE = 'sections.json'
+STATE_FILE = 'progress_state.json'
+
+def generate_sections(lat_step=0.1, lon_step=0.1):
+	"""Génère une liste de sections couvrant la France avec affichage de la progression."""
+	sections = []
+	total_steps = int((MAX_LAT - MIN_LAT) / lat_step) * int((MAX_LON - MIN_LON) / lon_step)
+	completed_steps = 0
+	
+	lat = MIN_LAT
+	while lat < MAX_LAT:
+		lon = MIN_LON
+		while lon < MAX_LON:
+			sections.append((lat, lon))
+			lon += lon_step
+			completed_steps += 1
+			percentage = (completed_steps / total_steps) * 100
+			print(f"Progression de la création des sections : {percentage:.2f}%")
+		lat += lat_step
+	return sections
+
+def save_sections(sections):
+	"""Sauvegarde les sections dans un fichier JSON."""
+	with open(SECTIONS_FILE, 'w') as f:
+		json.dump(sections, f)
+	print(f"Sections saved to {SECTIONS_FILE}")
+
+def load_sections():
+	"""Charge les sections à partir du fichier JSON."""
+	if os.path.exists(SECTIONS_FILE):
+		with open(SECTIONS_FILE, 'r') as f:
+			sections = json.load(f)
+	else:
+		sections = generate_sections()
+		save_sections(sections)
+	return sections
+
+def req(longitude, latitude):
+	"""Envoie une requête à l'API pour obtenir les altitudes."""
+	longi = "|".join(map(str, longitude))
+	latti = "|".join(map(str, latitude))
+	
+	url = f'https://wxs.ign.fr/calcul/alti/rest/elevation.json?lon={longi}&lat={latti}&zonly=true'
+	
+	while True:
+		try:
+			response = requests.get(url)
+			if response.status_code == 200:
+				data = response.json()
+				if 'elevations' in data:
+					return data['elevations']
+				else:
+					print("Impossible d'obtenir l'altitude pour les coordonnées spécifiées.")
+					return []
+			else:
+				print(f"Erreur de réponse de l'API. Code de statut : {response.status_code}")
+				time.sleep(1)
+		except requests.exceptions.RequestException as e:
+			print(f"Une erreur s'est produite lors de la requête : {e}")
+			time.sleep(1)
+
+def is_section_in_france(lat, lon):
+	"""Vérifie si une section est en France en testant les altitudes aux quatre coins."""
+	coords = [
+		(lat, lon),
+		(lat + 0.1, lon),
+		(lat, lon + 0.1),
+		(lat + 0.1, lon + 0.1)
+	]
+	for coord in coords:
+		elevation = req([coord[1]], [coord[0]])
+		if elevation and elevation[0] == -99999.0:
+			return False
+	return True
+
+def filter_sections_in_france(sections):
+	"""Filtre les sections pour ne conserver que celles en France."""
+	total_sections = len(sections)
+	valid_sections = []
+	for i, section in enumerate(sections):
+		if is_section_in_france(section[0], section[1]):
+			valid_sections.append(section)
+		percentage = (i + 1) / total_sections * 100
+		print(f"Progression de la vérification des sections : {percentage:.2f}%")
+	save_sections(valid_sections)
+	return valid_sections
+
+def process_section(section):
+	"""Récupère les altitudes pour une section donnée avec une résolution fine."""
+	lat, lon = section
+	data = []
+
+	current_lat = lat
+	while current_lat < lat + 0.1 and current_lat < MAX_LAT:
+		current_lon = lon
+		while current_lon < lon + 0.1 and current_lon < MAX_LON:
+			latitudes = [current_lat]
+			longitudes = [current_lon]
+			new_data = req(longitudes, latitudes)
+			if new_data:
+				data += new_data
+			current_lon += RESOLUTION
+		current_lat += RESOLUTION
+
+	return data
+
+def save_section(data, file_index):
+	"""Sauvegarde les données dans un fichier JSON."""
+	filename = f'data_part_{file_index}.json'
+	with open(filename, 'w') as f:
+		json.dump(data, f)
+	print(f"Data saved to {filename}")
+
+def load_progress():
+	"""Charge l'état du programme à partir du fichier d'état."""
+	if os.path.exists(STATE_FILE):
+		with open(STATE_FILE, 'r') as f:
+			state = json.load(f)
+	else:
+		state = {
+			"current_section_index": 0,
+			"file_index": 0
+		}
+	return state
+
+def save_state(state):
+	"""Sauvegarde l'état du programme dans un fichier d'état."""
+	with open(STATE_FILE, 'w') as f:
+		json.dump(state, f)
+
+def process_and_save(section, file_index):
+	"""Traite une section et sauvegarde le résultat."""
+	data = process_section(section)
+	if data:
+		save_section(data, file_index)
+		file_index += 1
+	return file_index
+
+def main():
+	sections = load_sections()
+	sections = filter_sections_in_france(sections)
+	state = load_progress()
+
+	current_section_index = state["current_section_index"]
+	file_index = state["file_index"]
+
+	total_sections = len(sections)
+	num_cores = max(1, cpu_count() - 1)  # Utiliser tous les cœurs sauf un pour le parallélisme local
+
+	while current_section_index < total_sections:
+		end_index = min(current_section_index + num_cores, total_sections)
+		sections_to_process = sections[current_section_index:end_index]
+		
+		with Pool(num_cores) as pool:
+			results = pool.starmap(process_and_save, [(section, file_index) for section in sections_to_process])
+		
+		# Mettre à jour file_index
+		file_index = max(results)
+
+		current_section_index = end_index
+
+		# Mettre à jour l'état
+		state["current_section_index"] = current_section_index
+		state["file_index"] = file_index
+		save_state(state)
+
+if __name__ == "__main__":
+	main()
+	# Vérification des versions installées
+	import requests
+	import urllib3
+
+	print("Requests version:", requests.__version__)
+	print("Urllib3 version:", urllib3.__version__)

main.py

@@ -0,0 +1,32 @@
+from GPS import *
+from MNT import *
+
+from STL import *
+from OBJ import *
+from STEP import *
+
+#45.221435, 5.016486 tersanne
+#45.171243, 5.722483 Grenoble
+#45.831949, 6.864395 mont blanc
+#45.010632, 5.443115 Vercors
+#45.849367, 6.182756 LacAnnecy
+#27.987348, 86.922997 Everest
+#48.858250, 2.294528 Tour Eiffel
+#48.855446, 2.347489 Paris Centre
+
+
+C = 48.855446, 2.347489
+Latitude = C[0]
+Longitude = C[1]
+distance = 1
+#FacteurReduction =  (distance - 1) // 3 + 1
+
+dossier="/media/remy/T7/IGNDonnee/"
+dossier="C:/Users/RemyCluze/Desktop/"
+
+listeLamber = listeLambertCentre(Latitude,Longitude,distance)
+
+nom = "testSRC"
+ConstruitMNT(nom,listeLamber,dossier,1)
+#transformeSTL(nom)
+transformeSTEP(nom,echelleXY=.25,echelleZ=0.25,nbPolesX=100,nbPolesY=100)

requirements.txt

@@ -0,0 +1,16 @@
+backports.zstd==1.6.0
+brotli==1.2.0
+certifi==2026.7.22
+inflate64==1.0.4
+multivolumefile==0.2.3
+numpy==2.5.1
+numpy-stl==4.0.0
+psutil==7.2.2
+py7zr==1.1.3
+pybcj==1.0.8
+pycryptodomex==3.23.0
+pyppmd==1.3.1
+pyproj==3.7.2
+python-utils==4.0.0
+texttable==1.7.0
+typing_extensions==4.16.0

test_bspline.step

@@ -0,0 +1,61 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION(('B-SPLINE SURFACE TEST'),'2;1');
+FILE_NAME('test_bspline.step','2026-08-21T00:00:00',('Python'),('Python'),'RCL STEP generator','RCL STEP generator','');
+FILE_SCHEMA(('CONFIG_CONTROL_DESIGN'));
+ENDSEC;
+DATA;
+#1=APPLICATION_CONTEXT('configuration controlled 3d designs of mechanical parts and assemblies');
+#2=APPLICATION_PROTOCOL_DEFINITION('international standard','config_control_design',2010,#1);
+#3=PRODUCT_CONTEXT('',#1,'mechanical');
+#4=PRODUCT('TEST_BSPLINE','TEST_BSPLINE','',(#3));
+#5=PRODUCT_DEFINITION_FORMATION('1','',#4);
+#6=PRODUCT_DEFINITION_CONTEXT('part definition',#1,'design');
+#7=PRODUCT_DEFINITION('design','',#5,#6);
+#8=PRODUCT_DEFINITION_SHAPE('', '',#7);
+#9=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#10=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#11=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#12=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#9,#10,#11))REPRESENTATION_CONTEXT('TEST','3D'));
+#13=CARTESIAN_POINT('',(0,0,0));
+#14=CARTESIAN_POINT('',(3.33333333333,0,0));
+#15=CARTESIAN_POINT('',(6.66666666667,0,0));
+#16=CARTESIAN_POINT('',(10,0,0));
+#17=CARTESIAN_POINT('',(0,3.33333333333,0));
+#18=CARTESIAN_POINT('',(3.33333333333,3.33333333333,5));
+#19=CARTESIAN_POINT('',(6.66666666667,3.33333333333,5));
+#20=CARTESIAN_POINT('',(10,3.33333333333,0));
+#21=CARTESIAN_POINT('',(0,6.66666666667,0));
+#22=CARTESIAN_POINT('',(3.33333333333,6.66666666667,5));
+#23=CARTESIAN_POINT('',(6.66666666667,6.66666666667,5));
+#24=CARTESIAN_POINT('',(10,6.66666666667,0));
+#25=CARTESIAN_POINT('',(0,10,0));
+#26=CARTESIAN_POINT('',(3.33333333333,10,0));
+#27=CARTESIAN_POINT('',(6.66666666667,10,0));
+#28=CARTESIAN_POINT('',(10,10,0));
+#29=B_SPLINE_SURFACE_WITH_KNOTS('TEST_SURFACE',3,3,((#13,#14,#15,#16),(#17,#18,#19,#20),(#21,#22,#23,#24),(#25,#26,#27,#28)),.UNSPECIFIED.,.F.,.F.,.F.,(4,4),(4,4),(0.,1.),(0.,1.),.UNSPECIFIED.);
+#30=B_SPLINE_CURVE_WITH_KNOTS('',3,(#13,#17,#21,#25),.UNSPECIFIED.,.F.,.F.,(4,4),(0.,1.),.UNSPECIFIED.);
+#31=B_SPLINE_CURVE_WITH_KNOTS('',3,(#13,#14,#15,#16),.UNSPECIFIED.,.F.,.F.,(4,4),(0.,1.),.UNSPECIFIED.);
+#32=B_SPLINE_CURVE_WITH_KNOTS('',3,(#16,#20,#24,#28),.UNSPECIFIED.,.F.,.F.,(4,4),(0.,1.),.UNSPECIFIED.);
+#33=B_SPLINE_CURVE_WITH_KNOTS('',3,(#28,#27,#26,#25),.UNSPECIFIED.,.F.,.F.,(4,4),(0.,1.),.UNSPECIFIED.);
+#34=VERTEX_POINT('',#13);
+#35=VERTEX_POINT('',#16);
+#36=VERTEX_POINT('',#28);
+#37=VERTEX_POINT('',#25);
+#38=EDGE_CURVE('',#34,#37,#30,.T.);
+#39=EDGE_CURVE('',#37,#36,#33,.T.);
+#40=EDGE_CURVE('',#36,#35,#32,.T.);
+#41=EDGE_CURVE('',#35,#34,#31,.T.);
+#42=ORIENTED_EDGE('',*,*,#38,.T.);
+#43=ORIENTED_EDGE('',*,*,#39,.T.);
+#44=ORIENTED_EDGE('',*,*,#40,.T.);
+#45=ORIENTED_EDGE('',*,*,#41,.T.);
+#46=EDGE_LOOP('',(#42,#43,#44,#45));
+#47=FACE_OUTER_BOUND('',#46,.T.);
+#48=ADVANCED_FACE(('',(#47),#29,.T.);
+#49=OPEN_SHELL('',(#48));
+#50=SHELL_BASED_SURFACE_MODEL('',(#49));
+#51=MANIFOLD_SURFACE_SHAPE_REPRESENTATION('TEST_BSPLINE',(#50),#12);
+#52=SHAPE_DEFINITION_REPRESENTATION(#8,#51);
+ENDSEC;
+END-ISO-10303-21;