Update code

Author: johnsamuelwrites

public/app.js

@@ -1,13 +1,14 @@
 const MAX_DIM = 1200;
-const MAX_TUILES_WASM = 8000;
+// Maximum tiles the WASM module will store (matches _MAX_TUILES in hexagonify_wasm.ml).
+const MAX_TUILES_WASM = 2000;
 
-// Approximate tile density (tiles per unit area / cote^2) for each tiling method.
-// Used to estimate the minimum safe cote before calling generer_tuiles.
+// Tile density per (cote² / image area) for each tiling method, used to warn
+// the user when the requested tile size would exceed the WASM tile cap.
 const DENSITE_METHODE = {
-  hex: 0.40, square: 1.0, triangle: 2.35,
-  trihex: 2.70, snub_trihex: 4.2, triangulaire_elongue: 1.65,
-  carre_snub: 1.25, rhombitrihex: 2.05, carre_tronque: 0.28,
-  grand_rhombitrihex: 0.38, hex_tronque: 0.60,
+  hex: 0.50, square: 1.0, triangle: 2.50,
+  trihex: 1.0, snub_trihex: 2.50, triangulaire_elongue: 1.70,
+  carre_snub: 1.30, rhombitrihex: 1.0, carre_tronque: 0.30,
+  grand_rhombitrihex: 0.10, hex_tronque: 0.40,
 };
 
 function coteSuretePourImage(w, h, methode) {
@@ -322,18 +323,9 @@ async function rendreSortie() {
     const coteDemande = cote;
     const coteMin = coteSuretePourImage(w, h, state.method);
     if (cote < coteMin) cote = coteMin;
-    let nTuiles;
-    for (let tentative = 0; tentative < 6; tentative++) {
-      try {
-        nTuiles = Number(wasm.generer_tuiles(w, h, cote, code));
-        break;
-      } catch (err) {
-        if (tentative >= 5) throw err;
-        cote = Math.ceil(cote * 1.5);
-      }
-    }
+    const nTuiles = Number(wasm.generer_tuiles(w, h, cote, code));
     if (cote !== coteDemande) {
-      status.textContent = `Taille ajustee a ${cote}px (limite memoire WASM).`;
+      status.textContent = `Taille ajustee a ${cote}px (limite du mode ${state.method}).`;
     }
     if (cote !== state.side) {
       state.side = cote;

scripts/compile_wasm.ml

@@ -55,6 +55,7 @@ déf generer_wat_et_wasm(source):
     soit wasmtime         = importlib.import_module("wasmtime")
     soit programme        = charger_programme(source)
     soit texte_wat        = WATCodeGenerator().generate(programme)
+    texte_wat = texte_wat.replace('(memory (export "memory") 4)', '(memory (export "memory") 16)')
     soit octets_wasm      = wasmtime.wat2wasm(texte_wat)
     retour [texte_wat, octets_wasm]
 

src/hexagonify_wasm.ml

@@ -3,6 +3,13 @@ importer math
 # Module WASM-compatible pour le carrelage d'images.
 # Exporte les primitives geometriques et les generateurs de tuiles
 # utilises par l'interface JavaScript.
+#
+# Stockage pre-alloue : evite append() (O(N²) memoire avec allocateur
+# par bosse) en faveur d'indices dans des tableaux de taille fixe.
+
+_MAX_TUILES     = 2000
+_MAX_COORDS     = 24000   # 2000 tuiles × 12 sommets au plus
+_MAX_KM_SAMPLES = 96
 
 
 # ── Hexagone (sommet pointu en haut) ──────────────────────────
@@ -134,21 +141,21 @@ déf tri_arete_y3(x1, y1, x2, y2):
 
 
 # ── K-means (couleur representative) ─────────────────────────
+# Tableaux pre-alloues : pas d'append(), pas de croissance quadratique.
 
-_km_r = []
-_km_g = []
-_km_b = []
+_km_r = [0.0 pour _ dans range(_MAX_KM_SAMPLES)]
+_km_g = [0.0 pour _ dans range(_MAX_KM_SAMPLES)]
+_km_b = [0.0 pour _ dans range(_MAX_KM_SAMPLES)]
 _km_k = 3
+_km_n = 0
 _km_res_r = 0
 _km_res_g = 0
 _km_res_b = 0
 
 
 déf km_init(k):
-    global _km_r, _km_g, _km_b, _km_k, _km_res_r, _km_res_g, _km_res_b
-    _km_r = []
-    _km_g = []
-    _km_b = []
+    global _km_n, _km_k, _km_res_r, _km_res_g, _km_res_b
+    _km_n = 0
     _km_k = entier(k)
     _km_res_r = 0
     _km_res_g = 0
@@ -157,10 +164,13 @@ déf km_init(k):
 
 
 déf km_ajouter(r, g, b):
-    global _km_r, _km_g, _km_b
-    _km_r.append(r)
-    _km_g.append(g)
-    _km_b.append(b)
+    global _km_r, _km_g, _km_b, _km_n
+    si _km_n >= _MAX_KM_SAMPLES:
+        retour 0
+    _km_r[_km_n] = r
+    _km_g[_km_n] = g
+    _km_b[_km_n] = b
+    _km_n = _km_n + 1
     retour 0
 
 
@@ -172,8 +182,8 @@ déf _dist2(r1, g1, b1, r2, g2, b2):
 
 
 déf km_calculer(max_iter):
-    global _km_res_r, _km_res_g, _km_res_b, _km_k, _km_r, _km_g, _km_b
-    n = len(_km_r)
+    global _km_res_r, _km_res_g, _km_res_b, _km_k, _km_r, _km_g, _km_b, _km_n
+    n = _km_n
     si n == 0:
         retour 0
     k = min(_km_k, n)
@@ -237,32 +247,31 @@ déf km_b():
 
 
 # ── Stockage global des tuiles ────────────────────────────────
+# Tableaux pre-alloues une seule fois au chargement du module.
+# _tuiles_reinit() remet seulement les compteurs a zero : aucune
+# allocation supplementaire par rendu, memoire en O(1).
 
-_tuiles_xs = []
-_tuiles_ys = []
-_tuiles_off = []
-_tuiles_n = []
-_vus_n = []
-_vus_cx = []
-_vus_cy = []
+_tuiles_xs  = [0.0 pour _ dans range(_MAX_COORDS)]
+_tuiles_ys  = [0.0 pour _ dans range(_MAX_COORDS)]
+_tuiles_off = [0.0 pour _ dans range(_MAX_TUILES)]
+_tuiles_n   = [0.0 pour _ dans range(_MAX_TUILES)]
+_vus_n      = [0.0 pour _ dans range(_MAX_TUILES)]
+_vus_cx     = [0.0 pour _ dans range(_MAX_TUILES)]
+_vus_cy     = [0.0 pour _ dans range(_MAX_TUILES)]
+_nb_tuiles  = 0
+_nb_coords  = 0
 
 
 déf _tuiles_reinit():
-    global _tuiles_xs, _tuiles_ys, _tuiles_off, _tuiles_n
-    global _vus_n, _vus_cx, _vus_cy
-    _tuiles_xs = []
-    _tuiles_ys = []
-    _tuiles_off = []
-    _tuiles_n = []
-    _vus_n = []
-    _vus_cx = []
-    _vus_cy = []
+    global _nb_tuiles, _nb_coords
+    _nb_tuiles = 0
+    _nb_coords = 0
     retour 0
 
 
 déf _ajouter_poly(xs, ys, larg, haut):
     global _tuiles_xs, _tuiles_ys, _tuiles_off, _tuiles_n
-    global _vus_n, _vus_cx, _vus_cy
+    global _vus_n, _vus_cx, _vus_cy, _nb_tuiles, _nb_coords
     n = len(xs)
     si n == 0:
         retour 0
@@ -292,17 +301,21 @@ déf _ajouter_poly(xs, ys, larg, haut):
         retour 0
     cx = entier(cx * 100.0) / 100.0
     cy = entier(cy * 100.0) / 100.0
-    pour k dans range(len(_vus_n)):
+    pour k dans range(_nb_tuiles):
         si _vus_n[k] == n et _vus_cx[k] == cx et _vus_cy[k] == cy:
             retour 0
-    _vus_n.append(n)
-    _vus_cx.append(cx)
-    _vus_cy.append(cy)
-    _tuiles_off.append(len(_tuiles_xs))
-    _tuiles_n.append(n)
+    si _nb_tuiles >= _MAX_TUILES ou _nb_coords + n > _MAX_COORDS:
+        retour 0
+    _vus_n[_nb_tuiles]      = n
+    _vus_cx[_nb_tuiles]     = cx
+    _vus_cy[_nb_tuiles]     = cy
+    _tuiles_off[_nb_tuiles] = _nb_coords
+    _tuiles_n[_nb_tuiles]   = n
     pour i dans range(n):
-        _tuiles_xs.append(xs[i])
-        _tuiles_ys.append(ys[i])
+        _tuiles_xs[_nb_coords + i] = xs[i]
+        _tuiles_ys[_nb_coords + i] = ys[i]
+    _nb_tuiles = _nb_tuiles + 1
+    _nb_coords = _nb_coords + n
     retour 1
 
 
@@ -621,7 +634,7 @@ déf generer_tuiles(larg, haut, a, methode):
         _gen_grand_rhombitrihex(larg, haut, a)
     si m == 10:
         _gen_hex_tronque(larg, haut, a)
-    retour len(_tuiles_off)
+    retour _nb_tuiles
 
 
 déf tuile_n_sommets(i):