Add working hover functionality with dBZ values

- Create hover data with lat/lon coordinates mapped to dBZ values
- Sample every 10th pixel to create manageable dataset
- Add invisible CircleMarkers with tooltips showing exact dBZ values
- Convert pixel coordinates to approximate lat/lon for Canada radar bounds
- Limit to 100 hover points on map to prevent performance issues
- Add comprehensive logging for hover data creation

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -125,31 +125,34 @@ class RadarAnalysisApp:
             wms_layer.add_to(m)
             folium.LayerControl().add_to(m)
             
-            # Add JavaScript for hover functionality to show dBZ values
-            hover_script = """
-            <script>
-            // Function to get dBZ value at mouse position
-            function getDBZValue(latlng) {
-                // This would need to be connected to the analysis data
-                // For now, show coordinates
-                return `Lat: ${latlng.lat.toFixed(4)}, Lng: ${latlng.lng.toFixed(4)}`;
-            }
-            
-            // Add hover event to map
-            setTimeout(function() {
-                if (window.map_data) {
-                    window.map_data.on('mousemove', function(e) {
-                        const popup = L.popup()
-                            .setLatLng(e.latlng)
-                            .setContent(getDBZValue(e.latlng))
-                            .openOn(window.map_data);
-                    });
-                }
-            }, 1000);
-            </script>
-            """
-            
-            m.get_root().html.add_child(folium.Element(hover_script))
+            # Add dBZ hover points if analysis data is available
+            if show_analysis:
+                try:
+                    # Try to get the latest analysis
+                    radar_file = self.fetch_current_radar()
+                    if radar_file:
+                        result = self.analyzer.analyze_radar(radar_file, "radar_legendwellcropped.png")
+                        hover_data = result.get('hover_data', {})
+                        hover_points = hover_data.get('points', [])
+                        
+                        print(f"Adding {len(hover_points)} hover points to map")
+                        
+                        # Add invisible markers for hover functionality
+                        for point in hover_points[:100]:  # Limit to 100 points to avoid overload
+                            folium.CircleMarker(
+                                location=[point['lat'], point['lon']],
+                                radius=3,
+                                popup=f"dBZ: {point['dbz']} ({point['intensity']})",
+                                tooltip=f"dBZ: {point['dbz']}",
+                                color='transparent',
+                                fillColor='transparent',
+                                fillOpacity=0,
+                                opacity=0
+                            ).add_to(m)
+                            
+                except Exception as e:
+                    print(f"Error adding hover data: {e}")
+                    pass
             
             # Add info panel
             info_html = """

radar_analyzer.py

@@ -495,19 +495,74 @@ class CanadianRadarAnalyzer:
             annotated_bgr = cv2.cvtColor(annotated_image, cv2.COLOR_RGB2BGR)
             cv2.imwrite(output_filename, annotated_bgr)
             
+            # Create hover data for map integration
+            hover_data = self.create_hover_data(analysis['precipitation_map'])
+            
             # Prepare results
             results = {
                 'analysis': analysis,
                 'regions': regions,
                 'output_file': output_filename,
                 'input_file': radar_image_path,
-                'legend_file': legend_path
+                'legend_file': legend_path,
+                'hover_data': hover_data
             }
             
             return results
             
         except Exception as e:
             raise Exception(f"Radar analysis failed: {str(e)}")
+    
+    def create_hover_data(self, dbz_map: np.ndarray) -> Dict:
+        """
+        Create simplified hover data for map integration.
+        Sample every Nth pixel to avoid huge datasets.
+        """
+        height, width = dbz_map.shape
+        sample_rate = 10  # Sample every 10th pixel to reduce data size
+        
+        hover_points = []
+        
+        # Canada radar bounds (approximate)
+        lat_min, lat_max = 42.0, 84.0
+        lon_min, lon_max = -142.0, -52.0
+        
+        print(f"Creating hover data from {width}x{height} dBZ map...")
+        
+        for y in range(0, height, sample_rate):
+            for x in range(0, width, sample_rate):
+                dbz_value = dbz_map[y, x]
+                
+                if dbz_value > 0:  # Only include pixels with precipitation
+                    # Convert pixel coordinates to lat/lon (approximate)
+                    lat = lat_max - (y / height) * (lat_max - lat_min)
+                    lon = lon_min + (x / width) * (lon_max - lon_min)
+                    
+                    hover_points.append({
+                        'lat': round(lat, 4),
+                        'lon': round(lon, 4),
+                        'dbz': round(dbz_value, 1),
+                        'intensity': self.categorize_dbz_simple(dbz_value)
+                    })
+        
+        print(f"Created {len(hover_points)} hover points")
+        
+        return {
+            'points': hover_points,
+            'total_points': len(hover_points),
+            'sample_rate': sample_rate
+        }
+    
+    def categorize_dbz_simple(self, dbz_value: float) -> str:
+        """Simple dBZ categorization for hover display."""
+        if dbz_value < 1.0:
+            return "Very Light"
+        elif dbz_value < 8.0:
+            return "Light-Moderate"
+        elif dbz_value < 32.0:
+            return "Heavy"
+        else:
+            return "Intense"
 
 if __name__ == "__main__":
     # Test the analyzer