hypercube-compute 2.0.0

package/src/core/TriadeGrid.ts

@@ -0,0 +1,119 @@
+import { TriadeMasterBuffer } from './TriadeMasterBuffer';
+import { TriadeCubeV2 } from './TriadeCubeV2';
+import type { ITriadeEngine } from '../engines/ITriadeEngine';
+
+/**
+ * TriadeGrid gère un assemblage N x M de TriadeCubes adjacents.
+ * Il assure la communication "Boundary Exchange" (Ghost Cells) entre les cubes
+ * à la fin de chaque étape de calcul pour unifier la simulation.
+ */
+export class TriadeGrid {
+    public cubes: (TriadeCubeV2 | null)[][] = [];
+    public readonly cols: number;
+    public readonly rows: number;
+    public readonly cubeSize: number;
+    public isPeriodic: boolean;
+
+    constructor(
+        cols: number,
+        rows: number,
+        cubeSize: number,
+        masterBuffer: TriadeMasterBuffer,
+        engineFactory: () => ITriadeEngine,
+        numFaces: number = 6,
+        isPeriodic: boolean = true
+    ) {
+        this.cols = cols;
+        this.rows = rows;
+        this.cubeSize = cubeSize;
+        this.isPeriodic = isPeriodic;
+
+        // Allocation de la grille de cubes
+        for (let y = 0; y < rows; y++) {
+            this.cubes[y] = [];
+            for (let x = 0; x < cols; x++) {
+                const cube = new TriadeCubeV2(cubeSize, masterBuffer, numFaces);
+                cube.setEngine(engineFactory());
+                this.cubes[y][x] = cube;
+            }
+        }
+    }
+
+    /**
+     * Calcule une étape complète de la grille.
+     * 1. Exécute "compute()" sur chaque cube
+     * 2. Synchronise les bords (Boundary Exchange) sur les faces demandées
+     */
+    compute(facesToSynchronize: number | number[] = 0) {
+        // 1. Calcul (Intra-Cube)
+        for (let y = 0; y < this.rows; y++) {
+            for (let x = 0; x < this.cols; x++) {
+                this.cubes[y][x]?.compute();
+            }
+        }
+
+        // 2. Synchronisation des bords O(1) Data Copy
+        const faces = Array.isArray(facesToSynchronize) ? facesToSynchronize : [facesToSynchronize];
+        for (const f of faces) {
+            this.synchronizeBoundaries(f);
+        }
+    }
+
+    /**
+     * Recopie les vecteurs périphériques (1 pixel de profondeur) vers les bords des voisins.
+     */
+    private synchronizeBoundaries(f: number) {
+        const s = this.cubeSize;
+        const s_minus_1 = s - 1;
+        const s_minus_2 = s - 2;
+
+        // PASS 1: X-axis (Left/Right)
+        for (let y = 0; y < this.rows; y++) {
+            for (let x = 0; x < this.cols; x++) {
+                const cube = this.cubes[y][x]!;
+                const data = cube.faces[f];
+
+                // Right neighbor
+                if (x < this.cols - 1 || this.isPeriodic) {
+                    const rightCube = this.cubes[y][(x + 1) % this.cols]!;
+                    const rightData = rightCube.faces[f];
+                    for (let row = 1; row < s_minus_1; row++) {
+                        rightData[row * s + 0] = data[row * s + s_minus_2];
+                    }
+                }
+
+                // Left neighbor
+                if (x > 0 || this.isPeriodic) {
+                    const leftCube = this.cubes[y][(x - 1 + this.cols) % this.cols]!;
+                    const leftData = leftCube.faces[f];
+                    for (let row = 1; row < s_minus_1; row++) {
+                        leftData[row * s + s_minus_1] = data[row * s + 1];
+                    }
+                }
+            }
+        }
+
+        // PASS 2: Y-axis (Top/Bottom) - Copying full rows which perfectly transfers the corners (ghost columns from PASS 1) 
+        // to diagonal neighbors automatically!
+        for (let y = 0; y < this.rows; y++) {
+            for (let x = 0; x < this.cols; x++) {
+                const cube = this.cubes[y][x]!;
+                const data = cube.faces[f];
+
+                // Bottom neighbor
+                if (y < this.rows - 1 || this.isPeriodic) {
+                    const bottomCube = this.cubes[(y + 1) % this.rows][x]!;
+                    const bottomData = bottomCube.faces[f];
+                    bottomData.set(data.subarray(s_minus_2 * s, s_minus_2 * s + s), 0);
+                }
+
+                // Top neighbor
+                if (y > 0 || this.isPeriodic) {
+                    const topCube = this.cubes[(y - 1 + this.rows) % this.rows][x]!;
+                    const topData = topCube.faces[f];
+                    topData.set(data.subarray(1 * s, 1 * s + s), s_minus_1 * s);
+                }
+            }
+        }
+    }
+}

package/src/core/TriadeMasterBuffer.ts

@@ -0,0 +1,37 @@
+export class TriadeMasterBuffer {
+    public readonly buffer: ArrayBuffer;
+    private offset: number = 0;
+
+    /**
+     * Alloue un unique bloc de mémoire vive (ArrayBuffer) pour l'ensemble du système.
+     * @param totalBytes Taille totale de la RAM allouée (par défaut 100 MB).
+     */
+    constructor(totalBytes: number = 100 * 1024 * 1024) {
+        this.buffer = new ArrayBuffer(totalBytes);
+    }
+
+    /**
+     * Alloue les octets nécessaires pour un Cube de 6 Faces en O(1) sans fragmentation.
+     * @param mapSize Résolution (ex: 400x400)
+     * @returns L'offset de départ dans l'ArrayBuffer
+     */
+    allocateCube(mapSize: number, numFaces: number = 6): number {
+        const floatsPerFace = mapSize * mapSize;
+        const bytesPerFace = floatsPerFace * Float32Array.BYTES_PER_ELEMENT; // 4 octets
+        const totalCubeBytes = bytesPerFace * numFaces;
+
+        if (this.offset + totalCubeBytes > this.buffer.byteLength) {
+            throw new Error(`[TriadeMasterBuffer] Out Of Memory. Impossible d'allouer ${totalCubeBytes} bytes supplémentaires.`);
+        }
+
+        const startOffset = this.offset;
+        this.offset += totalCubeBytes;
+
+        return startOffset;
+    }
+
+    /** Retourne la quantité de RAM consommée */
+    getUsedMemoryInMB(): string {
+        return (this.offset / (1024 * 1024)).toFixed(2) + ' MB';
+    }
+}

package/src/engines/AerodynamicsEngine.ts

@@ -0,0 +1,134 @@
+import type { ITriadeEngine } from "./ITriadeEngine";
+
+export class AerodynamicsEngine implements ITriadeEngine {
+    public dragScore: number = 0;
+    private initialized: boolean = false;
+
+    public get name(): string {
+        return "Lattice Boltzmann D2Q9 (O(1))";
+    }
+
+    public compute(faces: Float32Array[], mapSize: number): void {
+        const N = mapSize;
+        const obstacles = faces[18];
+        const ux_out = faces[19];
+        const uy_out = faces[20];
+        const curl_out = faces[21];
+
+        // Vecteurs du modèle D2Q9
+        const cx = [0, 1, 0, -1, 0, 1, -1, -1, 1];
+        const cy = [0, 0, 1, 0, -1, 1, 1, -1, -1];
+        const w = [4.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0, 1.0 / 36.0, 1.0 / 36.0, 1.0 / 36.0, 1.0 / 36.0];
+        const opp = [0, 3, 4, 1, 2, 7, 8, 5, 6]; // Rebonds opposés
+
+        const u0 = 0.12; // Vitesse de Mach 0.12 pour générer de sublimes tourbillons
+        const omega = 1.95; // Relaxation (Haute turbulence si proche de 2.0)
+
+        // 0. INITIALISATION (F_eq)
+        if (!this.initialized) {
+            for (let idx = 0; idx < N * N; idx++) {
+                const rho = 1.0;
+                const ux = u0; const uy = 0.0;
+                const u_sq = ux * ux + uy * uy;
+                for (let i = 0; i < 9; i++) {
+                    const cu = cx[i] * ux + cy[i] * uy;
+                    const feq = w[i] * rho * (1.0 + 3.0 * cu + 4.5 * cu * cu - 1.5 * u_sq);
+                    faces[i][idx] = feq;
+                    faces[i + 9][idx] = feq;
+                }
+            }
+            this.initialized = true;
+        }
+
+        let frameDrag = 0;
+
+        // 1. LBM CORE (Collision & Streaming O(1))
+        for (let y = 1; y < N - 1; y++) {
+            for (let x = 1; x < N - 1; x++) {
+                const idx = y * N + x;
+
+                if (obstacles[idx] > 0) {
+                    // BOUNCE BACK: L'air se cogne contre l'Aileron et repart en arrière
+                    for (let i = 1; i < 9; i++) {
+                        const originX = x - cx[i];
+                        const originY = y - cy[i];
+                        const originIdx = originY * N + originX;
+                        // Renvoi de la distribution
+                        faces[opp[i] + 9][originIdx] = faces[i][originIdx];
+
+                        // On mesure la puissance de l'impact direct (Portance/Traînée)
+                        if (i === 1) frameDrag += faces[1][originIdx];
+                    }
+                    ux_out[idx] = 0;
+                    uy_out[idx] = 0;
+                    continue; // Skip the fluid equations for solid material
+                }
+
+                // Macroscopique : Densité et Vitesse
+                let rho = 0;
+                let ux = 0;
+                let uy = 0;
+                for (let i = 0; i < 9; i++) {
+                    const f_val = faces[i][idx];
+                    rho += f_val;
+                    ux += cx[i] * f_val;
+                    uy += cy[i] * f_val;
+                }
+
+                // INLET : Vent continu forcé à gauche (Tunnel Aerodynamique)
+                if (x === 1) {
+                    ux = u0 * rho;
+                    uy = 0.0;
+                }
+
+                if (rho > 0) {
+                    ux /= rho;
+                    uy /= rho;
+                }
+                ux_out[idx] = ux;
+                uy_out[idx] = uy;
+
+                // BGK COLLISION EQUATION
+                const u_sq = ux * ux + uy * uy;
+                for (let i = 0; i < 9; i++) {
+                    const cu = cx[i] * ux + cy[i] * uy;
+                    const feq = w[i] * rho * (1.0 + 3.0 * cu + 4.5 * cu * cu - 1.5 * u_sq);
+
+                    // Relaxation de Navier-Stokes (Le secret profond du gaz)
+                    const f_post = faces[i][idx] * (1.0 - omega) + feq * omega;
+
+                    // STREAMING : Propagation vers les 8 voisins (+ le centre)
+                    let nx = x + cx[i];
+                    let ny = y + cy[i];
+
+                    // Effet de bord (Enroulement du tunnel en haut / en bas)
+                    if (ny < 1) ny = N - 2;
+                    else if (ny > N - 2) ny = 1;
+
+                    // OUTLET : Sortie libre (Gradient zero)
+                    if (nx > N - 2) nx = N - 2;
+
+                    faces[i + 9][ny * N + nx] = f_post;
+                }
+            }
+        }
+
+        // 2. SWAP BUFFERS
+        for (let i = 0; i < 9; i++) {
+            faces[i].set(faces[i + 9]);
+        }
+
+        // Exagération du calcul de drag pour UI
+        this.dragScore = this.dragScore * 0.9 + (frameDrag * 1000) * 0.1;
+
+        // 3. VORTICITY (Curl) POUR L'EFFET "WOW"
+        for (let y = 1; y < N - 1; y++) {
+            for (let x = 1; x < N - 1; x++) {
+                const idx = y * N + x;
+                const dUy_dx = uy_out[idx + 1] - uy_out[idx - 1];
+                const dUx_dy = ux_out[idx + N] - ux_out[idx - N];
+                curl_out[idx] = dUy_dx - dUx_dy;
+            }
+        }
+    }
+}

package/src/engines/EcosystemEngineO1.ts

@@ -0,0 +1,73 @@
+import type { ITriadeEngine } from "./ITriadeEngine";
+
+export class EcosystemEngineO1 implements ITriadeEngine {
+    public get name(): string {
+        return "Guerre des Triades (Rouge vs Bleu)";
+    }
+
+    public compute(faces: Float32Array[], mapSize: number): void {
+        const current = faces[1];
+        const next = faces[2];
+
+        // Automate Cellulaire Combat (Jeu de la vie + Bataille de Factions)
+        // STRICT O(1) : Sans mémoire asymétrique ni allocation.
+        for (let y = 0; y < mapSize; y++) {
+            for (let x = 0; x < mapSize; x++) {
+                const idx = y * mapSize + x;
+                const state = current[idx];
+
+                let blues = 0;
+                let reds = 0;
+
+                const yM = y > 0 ? y - 1 : mapSize - 1;
+                const yP = y < mapSize - 1 ? y + 1 : 0;
+                const xM = x > 0 ? x - 1 : mapSize - 1;
+                const xP = x < mapSize - 1 ? x + 1 : 0;
+
+                // Comptage de voisinage (Moore)
+                const n1 = current[yM * mapSize + xM]; if (n1 === 2) blues++; else if (n1 === 3) reds++;
+                const n2 = current[yM * mapSize + x]; if (n2 === 2) blues++; else if (n2 === 3) reds++;
+                const n3 = current[yM * mapSize + xP]; if (n3 === 2) blues++; else if (n3 === 3) reds++;
+                const n4 = current[y * mapSize + xM]; if (n4 === 2) blues++; else if (n4 === 3) reds++;
+                const n5 = current[y * mapSize + xP]; if (n5 === 2) blues++; else if (n5 === 3) reds++;
+                const n6 = current[yP * mapSize + xM]; if (n6 === 2) blues++; else if (n6 === 3) reds++;
+                const n7 = current[yP * mapSize + x]; if (n7 === 2) blues++; else if (n7 === 3) reds++;
+                const n8 = current[yP * mapSize + xP]; if (n8 === 2) blues++; else if (n8 === 3) reds++;
+
+                const total = blues + reds;
+
+                if (state !== 2 && state !== 3) { // Vide (ou anciens restes de map végétale)
+                    // Règle de Naissance GOL (Exactement 3 parents vivants)
+                    if (total === 3) {
+                        next[idx] = (blues > reds) ? 2 : 3; // L'Allégeance de l'enfant va au camp majoritaire
+                    }
+                    // Renforts aéroportés aléatoires pour garantir l'agitation infinie (Noise factor)
+                    else if (Math.random() < 0.0005) {
+                        next[idx] = Math.random() < 0.5 ? 2 : 3;
+                    }
+                    else {
+                        next[idx] = 0; // Reste un champ de bataille vide
+                    }
+                }
+                else if (state === 2) { // Troupe BLEUE
+                    // Combat: Frappe fatale ! Si 2 Rouges sont au contact, le Bleu se fait annihiler
+                    if (reds >= 2) next[idx] = 0;
+                    // Règle de Survie GOL classique (2 ou 3 camarades de vie)
+                    else if (total === 2 || total === 3) next[idx] = 2;
+                    // Isolement, ou Étouffement par surpopulation GOL
+                    else next[idx] = 0;
+                }
+                else if (state === 3) { // Troupe ROUGE
+                    // Combat: Frappe fatale ! Si 2 Bleus sont au contact, le Rouge se fait annihilé
+                    if (blues >= 2) next[idx] = 0;
+                    // Règle de Survie GOL classique
+                    else if (total === 2 || total === 3) next[idx] = 3;
+                    // Isolement ou Surpopulation
+                    else next[idx] = 0;
+                }
+            }
+        }
+
+        current.set(next); // Synchronisation du Front O(1)
+    }
+}

package/src/engines/GameOfLifeEngine.ts

@@ -0,0 +1,61 @@
+import type { ITriadeEngine } from "./ITriadeEngine";
+
+export class GameOfLifeEngine implements ITriadeEngine {
+    public get name(): string {
+        return "Ecosystème Tensoriel (Plantes, Herbivores, Carnivores)";
+    }
+
+    public compute(faces: Float32Array[], mapSize: number): void {
+        const current = faces[1]; // Face 1: État actuel (t)
+        const next = faces[2];    // Face 2: État futur (t+1)
+
+        // Double boucle optimisée pour accès mémoires continus
+        for (let y = 0; y < mapSize; y++) {
+
+            const top = (y === 0) ? mapSize - 1 : y - 1;
+            const bottom = (y === mapSize - 1) ? 0 : y + 1;
+
+            const topRow = top * mapSize;
+            const midRow = y * mapSize;
+            const botRow = bottom * mapSize;
+
+            for (let x = 0; x < mapSize; x++) {
+                const left = (x === 0) ? mapSize - 1 : x - 1;
+                const right = (x === mapSize - 1) ? 0 : x + 1;
+
+                const idx = midRow + x;
+                const state = current[idx]; // 0: Vide, 1: Plante, 2: Herbi, 3: Carni
+
+                // Le prédateur / successeur de l'état actuel
+                let targetState = state + 1;
+                if (targetState > 3) targetState = 0;
+
+                let predators = 0;
+
+                // Von Neumann Neighborhood (Plus organique pour la croissance)
+                if (current[topRow + x] === targetState) predators++;
+                if (current[midRow + left] === targetState) predators++;
+                if (current[midRow + right] === targetState) predators++;
+                if (current[botRow + x] === targetState) predators++;
+
+                // Moore Neighborhood (Diagonales) avec moins de poids
+                if (current[topRow + left] === targetState) predators++;
+                if (current[topRow + right] === targetState) predators++;
+                if (current[botRow + left] === targetState) predators++;
+                if (current[botRow + right] === targetState) predators++;
+
+                // Seuil à 1 ou 2 selon l'état offre une dynamique d'essaim très organique
+                const threshold = (state === 0) ? 1 : 2; // Le vide est colonisé vite, les autres survivent plus
+
+                if (predators >= threshold) {
+                    next[idx] = targetState;
+                } else {
+                    next[idx] = state;
+                }
+            }
+        }
+
+        // Swap / Recopie mémoire ultra-rapide de l'état (t+1) vers (t)
+        current.set(next);
+    }
+}

package/src/engines/HeatmapEngine.ts

@@ -0,0 +1,60 @@
+import type { ITriadeEngine } from './ITriadeEngine';
+
+export class HeatmapEngine implements ITriadeEngine {
+    public readonly name = "Heatmap (O1 Spatial Convolution)";
+    public radius: number;
+    public weight: number;
+
+    /**
+     * @param radius Rayon d'influence en cellules
+     * @param weight Coefficient multiplicateur à l'arrivée
+     */
+    constructor(radius: number = 10, weight: number = 1.0) {
+        this.radius = radius;
+        this.weight = weight;
+    }
+
+    /**
+     * Exécute le Summed Area Table Algorithm (Face 5) suivi 
+     * d'un Box Filter O(1) vers la Synthèse (Face 3).
+     */
+    compute(faces: Float32Array[], mapSize: number): void {
+        const face2 = faces[1]; // Contexte Binaire d'entrée
+        const face3 = faces[2]; // Synthèse de Diffusion
+        const face5 = faces[4]; // Cheat-code O(1) SAT
+
+        // 1. O(N) : Génération Cristallisée (Integral Image)
+        for (let y = 0; y < mapSize; y++) {
+            for (let x = 0; x < mapSize; x++) {
+                const idx = y * mapSize + x;
+                const val = face2[idx];
+                const top = y > 0 ? face5[(y - 1) * mapSize + x] : 0;
+                const left = x > 0 ? face5[y * mapSize + (x - 1)] : 0;
+                const topLeft = (y > 0 && x > 0) ? face5[(y - 1) * mapSize + (x - 1)] : 0;
+
+                face5[idx] = val + top + left - topLeft;
+            }
+        }
+
+        // 2. O(N) : Extraction d'Influence Indépendante du Rayon
+        for (let y = 0; y < mapSize; y++) {
+            for (let x = 0; x < mapSize; x++) {
+                // Clamping (Borne Map) rapide
+                const minX = Math.max(0, x - this.radius);
+                const minY = Math.max(0, y - this.radius);
+                const maxX = Math.min(mapSize - 1, x + this.radius);
+                const maxY = Math.min(mapSize - 1, y + this.radius);
+
+                // Récupération O(1) des Opcodes d'angles
+                const A = (minX > 0 && minY > 0) ? face5[(minY - 1) * mapSize + (minX - 1)] : 0;
+                const B = (minY > 0) ? face5[(minY - 1) * mapSize + maxX] : 0;
+                const C = (minX > 0) ? face5[maxY * mapSize + (minX - 1)] : 0;
+                const D = face5[maxY * mapSize + maxX];
+
+                // Différence des coins
+                const sum = D - B - C + A;
+                face3[y * mapSize + x] = sum * this.weight;
+            }
+        }
+    }
+}

package/src/engines/ITriadeEngine.ts

@@ -0,0 +1,29 @@
+/**
+ * Type alias to explicitly signal to AI that this array is a Flat Tensor (1D array simulating 2D/3D).
+ * @AI_RULE DO NOT iterate using functional array methods (map, forEach, reduce). DO NOT use `push` or `splice`.
+ */
+export type FlatTensorView = Float32Array;
+
+/**
+ * Interface fondamentale (Le Contract) pour tout algorithme physique dans Triade Engine.
+ * Implémentée par les moteurs LBM, GameOfLife, SAT.
+ */
+export interface ITriadeEngine {
+    /**
+     * @description Exécute un pas de simulation mathématique à l'intérieur d'un TriadeCube.
+     * @param faces Les 6 (ou N) "Views" (FlatTensorView) pointant vers la VRAM continue.
+     * @param mapSize La dimension N (N x N) de ce chunk spatial.
+     * 
+     * @AI_RULE CRITICAL_PERFORMANCE: This method runs inside a hot loop (like 60 FPS).
+     * @AI_RULE ZERO_ALLOCATION: DO NOT instantiate any object (`new Object()`, `[]`, `{}`) inside this scope to avoid Garbage Collection.
+     * @AI_RULE MEMORY_ACCESS: Use 1D sequential iterations `for (let i = 0; i < length; i++)`. Read/Write values via `faces[index][i]`. Map 2D coords using `index = y * mapSize + x`.
+     * @AI_RULE ERROR_HANDLING: If generating errors, be highly verbose for self-correction. Example: `throw new Error("[Triade] Out of bounds: index ${i} exceeds size ${length}")`
+     */
+    compute(faces: FlatTensorView[], mapSize: number): void;
+
+    /** 
+     * Identifiant explicite du moteur algorithmique.
+     * @AI_RULE This MUST match the semantic context of the Engine (e.g., 'Navier-Stokes-LBM-D2Q9', 'Game-Of-Life').
+     */
+    get name(): string;
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+export * from './Triade';
+
+// Core
+export * from './core/TriadeCubeV2';
+export * from './core/TriadeGrid';
+export * from './core/TriadeMasterBuffer';
+
+// Engines
+export * from './engines/ITriadeEngine';
+export * from './engines/AerodynamicsEngine';
+export * from './engines/EcosystemEngineO1';
+export * from './engines/GameOfLifeEngine';
+export * from './engines/HeatmapEngine';
+
+// IO / Adapters
+export * from './io/CanvasAdapter';
+export * from './io/WebGLAdapter';
+
+// Addons
+export * from './addons/ocean-simulation/OceanEngine';
+export { OceanSimulatorAddon } from './addons/ocean-simulation/OceanSimulatorAddon';
+export * from './addons/ocean-simulation/OceanWebGLRenderer';
+export * from './addons/ocean-simulation/OceanWorld';
+
+// Templates
+export * from './templates/BlankEngine';

package/src/io/CanvasAdapter.ts

@@ -0,0 +1,41 @@
+export class CanvasAdapter {
+    /**
+     * Lit un Tenseur Plat (Face de Float32Array) et le peint sur un contexte Canvas Native.
+     * Cette interface sépare la logique de rendu (UI) du moteur mathématique (Triade).
+     */
+    static renderFaceToCanvas(
+        faceData: Float32Array,
+        mapSize: number,
+        ctx: CanvasRenderingContext2D,
+        options: { colorScheme: 'heat' | 'grayscale', normalizeMax?: number } = { colorScheme: 'grayscale' }
+    ) {
+        const imgData = ctx.getImageData(0, 0, mapSize, mapSize);
+        const data = imgData.data;
+
+        // Auto-normalization si l'utilisateur ne connait pas le Max possible de sa matrice.
+        let max = options.normalizeMax || 0.0001;
+        if (!options.normalizeMax) {
+            for (let i = 0; i < faceData.length; i++) {
+                if (faceData[i] > max) max = faceData[i];
+            }
+        }
+
+        // Colorisation O(N)
+        for (let i = 0; i < faceData.length; i++) {
+            const val = faceData[i] / max;
+            const p = i * 4;
+
+            if (options.colorScheme === 'heat') {
+                data[p] = val * 255;                           // R
+                data[p + 1] = (val > 0.5 ? (val - 0.5) * 510 : 0); // G (jaunit si forte intensité)
+                data[p + 2] = val * 50;                          // B
+                data[p + 3] = 255;                               // Alpha
+            } else {
+                const c = val * 255;
+                data[p] = c; data[p + 1] = c; data[p + 2] = c;
+                data[p + 3] = 255;
+            }
+        }
+        ctx.putImageData(imgData, 0, 0);
+    }
+}