@sailingrotevista/rotevista-dash 6.2.7 → 6.2.8

package/index.js

@@ -559,21 +559,22 @@ module.exports = function (app) {
    * Raccoglie i 30 record da 1 minuto, estrae i picchi, unisce gli angoli
    * e applica la scrematura del percentile al 5% prima di salvare lo slot.
    */
-  function freeze30mSlot(slotTimestamp) {
-    const startTime = slotTimestamp;
-    const endTime = slotTimestamp + 1800000; // 30 minuti in millisecondi
+    function freeze30mSlot(slotTimestamp) {
+        const startTime = slotTimestamp;
+        const endTime = slotTimestamp + 1800000; // 30 minuti in millisecondi
 
-    // 1. Estrae i record storici del TWD e del TWS che ricadono in quella mezz'ora
-    const twdPoints = histories['twd'].filter(p => p.time >= startTime && p.time < endTime);
-    const twsPoints = histories['tws'].filter(p => p.time >= startTime && p.time < endTime);
+        // 1. Estrae i record storici del TWD e del TWS che ricadono in quella mezz'ora
+        const twdPoints = histories['twd'].filter(p => p.time >= startTime && p.time < endTime);
+        const twsPoints = histories['tws'].filter(p => p.time >= startTime && p.time < endTime);
 
-    if (twdPoints.length === 0) return; // Se non ci sono dati, salta lo slot
+        if (twdPoints.length === 0) return; // Se non ci sono dati, salta lo slot
 
-    // 2. Calcola il vento massimo sostenuto (in nodi) registrato nel periodo
-    const twsVals = twsPoints.map(p => p.val).filter(v => isFinite(v));
-    const maxTws = twsVals.length > 0 ? Math.max(...twsVals) : 0;
+        // 2. Calcola il vento massimo sostenuto (in nodi) registrato nel periodo
+        const twsVals = twsPoints.map(p => p.val).filter(v => isFinite(v));
+        const maxTws = twsVals.length > 0 ? Math.max(...twsVals) : 0;
+        const minTws = twsVals.length > 0 ? Math.min(...twsVals) : 0; // Chirurgico: Calcoliamo il vento minimo del periodo
 
-    // 3. Estrae tutti gli estremi angolari catturati minuto per minuto
+        // 3. Estrae tutti gli estremi angolari catturati minuto per minuto
     let allAngles = [];
     twdPoints.forEach(p => {
       allAngles.push(p.val);
@@ -611,15 +612,16 @@ module.exports = function (app) {
     const finalMin = (finalAvg + minDiff + Math.PI * 2) % (Math.PI * 2);
     const finalMax = (finalAvg + maxDiff + Math.PI * 2) % (Math.PI * 2);
 
-    // 7. Salva l'arco compresso e pulito nello store dedicato
-    windRadarSlots.push({
-      timestamp: startTime,
-      twdMin: finalMin,
-      twdMax: finalMax,
-      twsPeak: maxTws
-    });
+        // 7. Salva l'arco compresso e pulito nello store dedicato
+            windRadarSlots.push({
+              timestamp: startTime,
+              twdMin: finalMin,
+              twdMax: finalMax,
+              twsPeak: maxTws,
+              twsMin: minTws // Chirurgico: Salviamo il vento minimo per poter tracciare la variabilità (Gust Factor)
+            });
 
-    // Pruning: manteniamo in RAM solo le ultime 6 ore (12 slot)
+            // Pruning: manteniamo in RAM solo le ultime 6 ore (12 slot)
     while (windRadarSlots.length > 12) {
       windRadarSlots.shift();
     }

package/package.json

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

package/radar.html

@@ -417,21 +417,22 @@
         }
 
         // --- 4. MOTORE DI CALCOLO DELL'ANELLO 1 (Presente Mobile) ---
-        function calculateActive30mRing() {
-            const now = Date.now();
-            const start30m = now - 1800000;
+                function calculateActive30mRing() {
+                    const now = Date.now();
+                    const start30m = now - 1800000;
 
-            const twdRecent = store.twdMinuteBuffer.filter(p => p.time >= start30m);
-            const twsRecent = store.twsMinuteBuffer.filter(p => p.time >= start30m);
+                    const twdRecent = store.twdMinuteBuffer.filter(p => p.time >= start30m);
+                    const twsRecent = store.twsMinuteBuffer.filter(p => p.time >= start30m);
 
-            if (twdRecent.length === 0) return null;
+                    if (twdRecent.length === 0) return null;
 
-            const twsVals = twsRecent.map(p => p.val).filter(v => isFinite(v));
-            const maxTws = twsVals.length > 0 ? Math.max(...twsVals) : 0;
+                    const twsVals = twsRecent.map(p => p.val).filter(v => isFinite(v));
+                    const maxTws = twsVals.length > 0 ? Math.max(...twsVals) : 0;
+                    const minTws = twsVals.length > 0 ? Math.min(...twsVals) : 0; // Chirurgico: Troviamo il vento minimo reale degli ultimi 30 minuti
 
-            if (maxTws < CALM_THRESHOLD_KTS) {
-                return { twsPeak: maxTws, twdMin: 0, twdMax: 360, isCalm: true };
-            }
+                    if (maxTws < CALM_THRESHOLD_KTS) {
+                        return { twsPeak: maxTws, twsMin: minTws, twdMin: 0, twdMax: 360, isCalm: true };
+                    }
 
             let allAngles = [];
             twdRecent.forEach(p => {
@@ -459,15 +460,16 @@
             const maxDiff = Math.max(...finalDiffs);
 
             const finalMinDeg = Math.round(radToDeg((finalAvg + minDiff + Math.PI * 2) % (Math.PI * 2)));
-            const finalMaxDeg = Math.round(radToDeg((finalAvg + maxDiff + Math.PI * 2) % (Math.PI * 2)));
-
-            return {
-                twdMin: finalMinDeg,
-                twdMax: finalMaxDeg,
-                twsPeak: maxTws,
-                isCalm: false
-            };
-        }
+                        const finalMaxDeg = Math.round(radToDeg((finalAvg + maxDiff + Math.PI * 2) % (Math.PI * 2)));
+
+                        return {
+                            twdMin: finalMinDeg,
+                            twdMax: finalMaxDeg,
+                            twsPeak: maxTws,
+                            twsMin: minTws, // Chirurgico: Ritorniamo anche il valore minimo per abilitare la sfumatura sull'Anello 1
+                            isCalm: false
+                        };
+                    }
 
         // --- 5. MOTORE GRAFICO DI DISEGNO ---
         function drawCompassTicks() {
@@ -642,21 +644,23 @@
             radarDataList.push(activeRing);
 
             // 3. ANELLI da 2 a 7 (I 6 slot storici da 30 min passati salvati dal server, pari a 3 ore)
-            for (let i = 1; i <= 6; i++) {
-                const targetTimestamp = current30mSlot - (i * 1800000);
-                const matchedSlot = windRadarSlots.find(s => s.timestamp === targetTimestamp);
-                
-                if (matchedSlot) {
-                    radarDataList.push({
-                        twdMin: Math.round(radToDeg(matchedSlot.twdMin)),
-                        twdMax: Math.round(radToDeg(matchedSlot.twdMax)),
-                        twsPeak: matchedSlot.twsPeak,
-                        isCalm: matchedSlot.twsPeak < CALM_THRESHOLD_KTS
-                    });
-                } else {
-                    radarDataList.push(null);
-                }
-            }
+                        for (let i = 1; i <= 6; i++) {
+                            const targetTimestamp = current30mSlot - (i * 1800000);
+                            const matchedSlot = windRadarSlots.find(s => s.timestamp === targetTimestamp);
+                            
+                            if (matchedSlot) {
+                                radarDataList.push({
+                                    twdMin: Math.round(radToDeg(matchedSlot.twdMin)),
+                                    twdMax: Math.round(radToDeg(matchedSlot.twdMax)),
+                                    twsPeak: matchedSlot.twsPeak,
+                                    // Chirurgico: Estraiamo il minimo storico con protezione di compatibilità se assente
+                                    twsMin: matchedSlot.twsMin !== undefined ? matchedSlot.twsMin : matchedSlot.twsPeak,
+                                    isCalm: matchedSlot.twsPeak < CALM_THRESHOLD_KTS
+                                });
+                            } else {
+                                radarDataList.push(null);
+                            }
+                        }
 
             document.getElementById('debug-rings-count').innerText = radarDataList.filter(p => p !== null).length + "/8";
 
@@ -685,17 +689,47 @@
                 }
 
                 // Caso B: Arco Direzionale
-                const grad = getChordAlignedGradient(gradId, radius, data.twsPeak, data.twdMin, data.twdMax);
-                let strokeColor = '';
-
-                if (grad.type === 'gradient') {
-                    defsContainer.innerHTML += grad.xml;
-                    strokeColor = grad.url;
-                } else {
-                    strokeColor = grad.color;
-                }
+                                let strokeColor = '';
+                                
+                                // Chirurgico: Definita la funzione di colorazione universale basata sulle soglie dei Reef di bordo
+                                const getColorForSpeed = (tws) => {
+                                    const R1 = REEF1; const R2 = REEF2; const R3 = REEF3;
+                                    if (tws < R1 * 0.4) return '#ffffff'; // Bianco (Calma)
+                                    if (tws < R1 * 0.75) return '#00C851'; // Verde (Regolare)
+                                    if (tws < R1) return '#ff9800'; // Arancio (1° Reef Alert)
+                                    if (tws < R2) return '#ffaa00'; // Dorato (Transizione)
+                                    if (tws < R2 + (R3 - R2) * 0.5) return '#ff3b30'; // Rosso (2° Reef Alert)
+                                    return '#9c27b0'; // Viola (Storm / Temporale)
+                                };
+
+                                // Chirurgico: Estraiamo i limiti minimi e massimi dell'arco corrente
+                                // Se è la previsione, usiamo il vento medio e le raffiche di Open-Meteo, altrimenti i minimi e i picchi in RAM
+                                const baseTws = data.isFuture && futureForecast ? futureForecast.tws : (data.twsMin !== undefined ? data.twsMin : data.twsPeak);
+                                const peakTws = data.isFuture && futureForecast ? futureForecast.gust : data.twsPeak;
+
+                                const baseColor = getColorForSpeed(baseTws);
+                                const peakColor = getColorForSpeed(peakTws);
+
+                                if (baseColor !== peakColor) {
+                                    // Se c'è variabilità d'intensità (raffica), disegnamo il gradiente termico dinamico lungo l'arco (Min -> Max -> Min)
+                                    const startPt = polarToCartesian(200, 200, radius, data.twdMax);
+                                    const endPt = polarToCartesian(200, 200, radius, data.twdMin);
+                                    
+                                    const xml = `
+                                        <linearGradient id="${gradId}" x1="${startPt.x.toFixed(1)}" y1="${startPt.y.toFixed(1)}" x2="${endPt.x.toFixed(1)}" y2="${endPt.y.toFixed(1)}" gradientUnits="userSpaceOnUse">
+                                            <stop offset="0%" stop-color="${baseColor}" />
+                                            <stop offset="50%" stop-color="${peakColor}" />
+                                            <stop offset="100%" stop-color="${baseColor}" />
+                                        </linearGradient>
+                                    `;
+                                    defsContainer.innerHTML += xml;
+                                    strokeColor = `url(#${gradId})`;
+                                } else {
+                                    // Se il vento è costante (base e picco ricadono nella stessa fascia), usiamo il colore solido puro
+                                    strokeColor = baseColor;
+                                }
 
-                const pathData = describeArc(200, 200, radius, data.twdMin, data.twdMax);
+                                const pathData = describeArc(200, 200, radius, data.twdMin, data.twdMax);
 
                                 // Chirurgico: Se è l'anello futuro (isFuture), non disegniamo il bordo nero per evitare artefatti "a doppia bolla"
                                 if (!data.isFuture) {