@sailingrotevista/rotevista-dash 7.0.16 → 7.0.18

package/app.js

@@ -23,7 +23,7 @@ let CONFIG = {
         minSpeed: 0.5,
         stabilityBreakout: 15
     },
-    graphs: { reef1: 10, reef2: 15, historyMinutes: 10, samples: 60 },
+    graphs: { reef1: 10, reef2: 15, historyMinutes: 5, samples: 60 },
     scales: {
         stw: { stdMax: 4, hercSpan: 2, step: 1 },
         sog: { stdMax: 4, hercSpan: 2, step: 1 },
@@ -744,11 +744,20 @@ function startDisplayLoop() {
         }
 
         if (lastAvgUIUpdate % 3 === 0) {
-            let hObj = getCircularAverageFromBuffer(store.longBuf.hdg, CONFIG.averaging.longWindow * 2, false);
-            let cObj = getCircularAverageFromBuffer(store.longBuf.cog, CONFIG.averaging.longWindow, false);
-            let awObj = getCircularAverageFromBuffer(store.longBuf.awa, CONFIG.averaging.longWindow, true);
-            let twObj = getCircularAverageFromBuffer(store.longBuf.twa, CONFIG.averaging.longWindow, true);
-            let twdObj = getCircularAverageFromBuffer(store.longBuf.twd, CONFIG.averaging.longWindow, false);
+            const baseThreshold = CONFIG.averaging.stabilityThreshold || 0.95;
+            const breakout = CONFIG.averaging.stabilityBreakout || 15;
+            
+            // CALCOLO DIFFERENZIALE: Tolleranza del vento proporzionale alla sensibilità di base.
+            // Rilassiamo la soglia del vento di 0.13 rispetto alla prua (es. se la prua richiede 0.95, il vento richiede 0.82)
+            const windThreshold = Math.max(0.60, baseThreshold - 0.13);
+
+            let hObj = getCircularAverageFromBuffer(store.longBuf.hdg, CONFIG.averaging.longWindow * 2, false, now, baseThreshold, breakout);
+            let cObj = getCircularAverageFromBuffer(store.longBuf.cog, CONFIG.averaging.longWindow, false, now, baseThreshold, breakout);
+            
+            // Applichiamo la soglia differenziale ottimizzata per i tre dati legati al vento
+            let awObj = getCircularAverageFromBuffer(store.longBuf.awa, CONFIG.averaging.longWindow, true, now, windThreshold, breakout);
+            let twObj = getCircularAverageFromBuffer(store.longBuf.twa, CONFIG.averaging.longWindow, true, now, windThreshold, breakout);
+            let twdObj = getCircularAverageFromBuffer(store.longBuf.twd, CONFIG.averaging.longWindow, false, now, windThreshold, breakout);
 
             // --- GESTIONE DINAMICA ETICHETTA TACK/GYBE CON ISTERESI DI 10 GRADI ---
             if (ui.tackLabel) {
@@ -964,11 +973,11 @@ function manageHistory(type, value) {
     const bucketReady = (now - store.lastUpdates[type] > bucketIntervalMs) || store.histories[type].length === 0;
     if (!bucketReady) return;
 
-    // --- 5. AGGREGAZIONE SEMANTICA ---
+    // --- 5. AGGREGAZIONE SEMANTICA (Ottimizzata a zero-allocazioni di array intermedi) ---
     let finalValue = value;
 
     if (tempBuf.length > 0) {
-        // A. VENTO -> SUSTAINED PEAK (EMA Time-Aware)
+        // A. VENTO -> SUSTAINED PEAK (EMA Time-Aware) (0 allocazioni)
         if (type === 'tws' || type === 'aws') {
             const tauMs = 2500;
             let ema = tempBuf[0].val;
@@ -982,17 +991,32 @@ function manageHistory(type, value) {
             }
             finalValue = maxSustained;
         }
-        // B. PROFONDITÀ -> MINIMO
+        // B. PROFONDITÀ -> MINIMO (In-place loop, 0 allocazioni)
         else if (type === 'depth') {
-            const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
-            if (vals.length > 0) finalValue = Math.min(...vals);
+            let minVal = Infinity;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const v = tempBuf[i].val;
+                if (isFinite(v) && v < minVal) {
+                    minVal = v;
+                }
+            }
+            if (minVal !== Infinity) {
+                finalValue = minVal;
+            }
         }
-        // C. VELOCITÀ -> MEDIA
+        // C. VELOCITÀ -> MEDIA (In-place loop, 0 allocazioni)
         else {
-            const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
-            if (vals.length > 0) {
-                const sum = vals.reduce((a, b) => a + b, 0);
-                finalValue = sum / tempBuf.length;
+            let sum = 0;
+            let count = 0;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const v = tempBuf[i].val;
+                if (isFinite(v)) {
+                    sum += v;
+                    count++;
+                }
+            }
+            if (count > 0) {
+                finalValue = sum / count;
             }
         }
     }

package/index.js

@@ -351,81 +351,111 @@ module.exports = function (app) {
         let isTwdType = (type === 'twd');
 
         if (tempBuf.length > 0) {
-            // ==========================================================================
-            // CASO PARTICOLARE: DIREZIONE VENTO (TWD) -> MEDIA PESATA E LIMITI MIN/MAX
-            // ==========================================================================
-            if (isTwdType) {
-                // 1. Identifica il vento massimo del minuto (in m/s)
-                const twsVals = tempBuf.map(p => p.tws || 0);
-                const maxTwsInMinute = Math.max(...twsVals, 0);
-
-                // 2. Calcola la soglia dinamica di pressione: max tra 40% del picco e soglia di calma piatta (in m/s)
-                const calmThresholdMs = CALM_THRESHOLD_KTS / 1.94384;
-                const pressureThreshold = Math.max(maxTwsInMinute * PRESSURE_FILTER_RATIO, calmThresholdMs);
-
-                // 3. Esclude le direzioni registrate quando il vento era debole (sotto la soglia di pressione)
-                const activePoints = tempBuf.filter(p => (p.tws || 0) >= pressureThreshold);
-                const pointsToUse = activePoints.length > 0 ? activePoints : tempBuf; // Fallback se tutto è calma piatta
-
-                // 4. Media Vettoriale Pesata (TWS * sin, TWS * cos)
-                let sumSin = 0;
-                let sumCos = 0;
-                let totalWeight = 0;
-                pointsToUse.forEach(p => {
-                    const weight = Math.max(p.tws || 0.1, 0.05); // Evita pesi a zero
-                    sumSin += weight * Math.sin(p.val);
-                    sumCos += weight * Math.cos(p.val);
-                    totalWeight += weight;
-                });
-                const avgAngle = Math.atan2(sumSin, sumCos);
-                const finalAvg = (avgAngle + Math.PI * 2) % (Math.PI * 2);
-
-                // 5. Calcolo di Min e Max angolare del minuto (rispetto alla media per gestire l'oltrepasso di 0/360°)
-                let diffs = pointsToUse.map(p => {
-                    let diff = p.val - finalAvg;
-                    return Math.atan2(Math.sin(diff), Math.cos(diff)); // Srotolamento tra -PI e +PI
-                });
-
-                const minDiff = Math.min(...diffs);
-                const maxDiff = Math.max(...diffs);
-
-                const finalMin = (finalAvg + minDiff + Math.PI * 2) % (Math.PI * 2);
-                const finalMax = (finalAvg + maxDiff + Math.PI * 2) % (Math.PI * 2);
-
-                finalValue = {
-                    val: finalAvg,
-                    min: finalMin,
-                    max: finalMax
-                };
+        // ==========================================================================
+        // CASO PARTICOLARE: DIREZIONE VENTO (TWD) -> MEDIA PESATA E LIMITI MIN/MAX
+        // ==========================================================================
+        if (isTwdType) {
+            // 1. Identifica il vento massimo del minuto (in m/s) - Loop in-place (0 allocazioni)
+            let maxTwsInMinute = 0;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const tws = tempBuf[i].tws || 0;
+                if (tws > maxTwsInMinute) maxTwsInMinute = tws;
             }
-            // A. VENTO VELOCITÀ -> SUSTAINED PEAK (EMA Time-Aware)
-            else if (type === 'tws' || type === 'aws') {
-                const tauMs = 2500;
-                let ema = tempBuf[0].val;
-                let maxSustained = ema;
-
-                for (let i = 1; i < tempBuf.length; i++) {
-                    const dt = Math.max(1, tempBuf[i].time - tempBuf[i-1].time);
-                    const alpha = 1 - Math.exp(-dt / tauMs);
-                    ema = (tempBuf[i].val * alpha) + (ema * (1 - alpha));
-                    if (isFinite(ema) && ema > maxSustained) maxSustained = ema;
+
+            // 2. Calcola la soglia dinamica di pressione
+            const calmThresholdMs = CALM_THRESHOLD_KTS / 1.94384;
+            const pressureThreshold = Math.max(maxTwsInMinute * PRESSURE_FILTER_RATIO, calmThresholdMs);
+
+            // 3. Determina in un unico passaggio se ci sono punti attivi sopra la soglia (0 allocazioni)
+            let hasActivePoints = false;
+            for (let i = 0; i < tempBuf.length; i++) {
+                if ((tempBuf[i].tws || 0) >= pressureThreshold) {
+                    hasActivePoints = true;
+                    break;
                 }
-                finalValue = maxSustained;
             }
-            // B. PROFONDITÀ -> MINIMO
-            else if (type === 'depth') {
-                const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
-                if (vals.length > 0) finalValue = Math.min(...vals);
+
+            // 4. Media Vettoriale Pesata (0 allocazioni di array)
+            let sumSin = 0;
+            let sumCos = 0;
+            let totalWeight = 0;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const p = tempBuf[i];
+                if (hasActivePoints && (p.tws || 0) < pressureThreshold) continue;
+
+                const weight = Math.max(p.tws || 0.1, 0.05);
+                sumSin += weight * Math.sin(p.val);
+                sumCos += weight * Math.cos(p.val);
+                totalWeight += weight;
             }
-            // C. VELOCITÀ BARCA / ALTRO -> MEDIA
-            else {
-                const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
-                if (vals.length > 0) {
-                    const sum = vals.reduce((a, b) => a + b, 0);
-                    finalValue = sum / tempBuf.length;
+            const avgAngle = Math.atan2(sumSin, sumCos);
+            const finalAvg = (avgAngle + Math.PI * 2) % (Math.PI * 2);
+
+            // 5. Calcolo di Min e Max angolare del minuto (0 allocazioni di array)
+            let minDiff = 0;
+            let maxDiff = 0;
+            let firstDiff = true;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const p = tempBuf[i];
+                if (hasActivePoints && (p.tws || 0) < pressureThreshold) continue;
+
+                const diff = Math.atan2(Math.sin(p.val - finalAvg), Math.cos(p.val - finalAvg));
+                if (firstDiff) {
+                    minDiff = diff;
+                    maxDiff = diff;
+                    firstDiff = false;
+                } else {
+                    if (diff < minDiff) minDiff = diff;
+                    if (diff > maxDiff) maxDiff = diff;
                 }
             }
+
+            const finalMin = (finalAvg + minDiff + Math.PI * 2) % (Math.PI * 2);
+            const finalMax = (finalAvg + maxDiff + Math.PI * 2) % (Math.PI * 2);
+
+            finalValue = {
+                val: finalAvg,
+                min: finalMin,
+                max: finalMax
+            };
         }
+        // A. VENTO VELOCITÀ -> SUSTAINED PEAK (EMA Time-Aware) (Inalterato per minimizzare le modifiche)
+        else if (type === 'tws' || type === 'aws') {
+            const tauMs = 2500;
+            let ema = tempBuf[0].val;
+            let maxSustained = ema;
+
+            for (let i = 1; i < tempBuf.length; i++) {
+                const dt = Math.max(1, tempBuf[i].time - tempBuf[i-1].time);
+                const alpha = 1 - Math.exp(-dt / tauMs);
+                ema = (tempBuf[i].val * alpha) + (ema * (1 - alpha));
+                if (isFinite(ema) && ema > maxSustained) maxSustained = ema;
+            }
+            finalValue = maxSustained;
+        }
+        // B. PROFONDITÀ -> MINIMO (Ottimizzato a 0 allocazioni)
+        else if (type === 'depth') {
+            let minVal = Infinity;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const v = tempBuf[i].val;
+                if (isFinite(v) && v < minVal) minVal = v;
+            }
+            if (minVal !== Infinity) finalValue = minVal;
+        }
+        // C. VELOCITÀ BARCA / ALTRO -> MEDIA (Ottimizzato a 0 allocazioni)
+        else {
+            let sum = 0;
+            let count = 0;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const v = tempBuf[i].val;
+                if (isFinite(v)) {
+                    sum += v;
+                    count++;
+                }
+            }
+            if (count > 0) finalValue = sum / count;
+        }
+    }
 
         // Validazione e clamping di sicurezza (non si applica all'oggetto TWD)
         if (!isTwdType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailingrotevista/rotevista-dash",
-  "version": "7.0.16",
+  "version": "7.0.18",
   "description": "Wind Dashboard with navigation and course aids",
   "main": "index.js",
   "publishConfig": {

package/style.css

@@ -601,3 +601,12 @@ body.night-mode {
 .night-mode #wind-radar circle[stroke="#b0bec5"] {
     stroke: #440000 !important;
 }
+
+/* ==========================================================================
+   13. SMORZAMENTO FLUIDO AGHI A 60FPS (DAMPING HARDWARE)
+   ========================================================================== */
+
+/* Applichiamo la transizione fluida a tutti i puntatori mantenendo i perni nativi dell'SVG */
+#awa-pointer, #twa-pointer, #track-pointer, #twd-arrow, #twd-boat-wrap {
+    transition: transform 0.9s cubic-bezier(0.25, 0.8, 0.25, 1);
+}