add area detection

app.py

@@ -28,7 +28,7 @@ logger = logging.getLogger('forestai')
 
 # Feature styles for trees only
 FEATURE_STYLES = {
-    'trees': {"color": "green", "fillColor": "yellow", "fillOpacity": 0.3, "weight": 2}
+    'trees': {"color": "yellow", "fillColor": "yellow", "fillOpacity": 0.3, "weight": 2}
 }
 
 # Example file path
@@ -134,6 +134,14 @@ def create_split_view_map(geojson_data, bounds):
             )
             geojson_layer.add_to(m)
 
+        # Add red outline for the region bounding box
+        folium.Rectangle(
+            bounds=[[south, west], [north, east]],
+            color='red',
+            weight=3,
+            fill=False
+        ).add_to(m)
+
         # Add split view plugin
         plugins.SideBySideLayers(
             layer_left=left_layer,

utils/advanced_extraction.py

@@ -12,26 +12,38 @@ def extract_features_from_geotiff(image_path, output_folder, feature_type="trees
         logging.info(f"Extracting {feature_type} from {image_path}")
         
         with rasterio.open(image_path) as src:
+            logging.info(f"Image shape: {src.shape}, bands: {src.count}")
+            
             # Enhanced NDVI calculation
             if src.count >= 3:
                 red = src.read(1).astype(float)
                 green = src.read(2).astype(float)
                 nir = src.read(4).astype(float) if src.count >= 4 else green
                 
+                logging.info(f"Red band range: {red.min():.3f} to {red.max():.3f}")
+                logging.info(f"Green band range: {green.min():.3f} to {green.max():.3f}")
+                logging.info(f"NIR band range: {nir.min():.3f} to {nir.max():.3f}")
+                
                 # Improved NDVI calculation
                 ndvi = np.divide(nir - red, nir + red + 1e-10)
                 
                 # Adaptive thresholding based on image statistics
                 ndvi_mean = np.mean(ndvi)
                 ndvi_std = np.std(ndvi)
-                threshold = max(0.3, ndvi_mean + 0.5 * ndvi_std)  # More adaptive threshold
+                threshold = max(0.05, ndvi_mean + 0.1 * ndvi_std)  # More lenient threshold
+                
+                logging.info(f"NDVI mean: {ndvi_mean:.3f}, std: {ndvi_std:.3f}, threshold: {threshold:.3f}")
                 
                 mask = ndvi > threshold
+                logging.info(f"Mask pixels above threshold: {np.sum(mask)} out of {mask.size}")
             else:
                 band = src.read(1)
+                logging.info(f"Single band range: {band.min():.3f} to {band.max():.3f}")
                 # Adaptive threshold for single-band images
-                threshold = np.percentile(band, 70)  # Increased from 60
+                threshold = np.percentile(band, 40)  # Reduced from 70 to be more lenient
+                logging.info(f"Single band threshold: {threshold:.3f}")
                 mask = band > threshold
+                logging.info(f"Mask pixels above threshold: {np.sum(mask)} out of {mask.size}")
             
             # Get bounds
             bounds = src.bounds
@@ -45,30 +57,38 @@ def extract_features_from_geotiff(image_path, output_folder, feature_type="trees
         
         # Convert to uint8 for OpenCV processing
         mask_uint8 = (mask * 255).astype(np.uint8)
+        logging.info(f"Mask uint8 range: {mask_uint8.min()} to {mask_uint8.max()}")
         
         # Morphological operations to clean up the mask
         kernel = np.ones((3, 3), np.uint8)
         mask_cleaned = cv2.morphologyEx(mask_uint8, cv2.MORPH_CLOSE, kernel)
         mask_cleaned = cv2.morphologyEx(mask_cleaned, cv2.MORPH_OPEN, kernel)
         
+        logging.info(f"After morphological ops: {np.sum(mask_cleaned > 0)} pixels")
+        
         # Find contours instead of using grid
         contours, _ = cv2.findContours(mask_cleaned, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        logging.info(f"Found {len(contours)} contours")
         
         # Filter contours by area and create features
         features = []
         height, width = mask.shape
-        min_area = (height * width) * 0.001  # Minimum 0.1% of image area
-        max_area = (height * width) * 0.1    # Maximum 10% of image area
+        min_area = (height * width) * 0.0001  # Minimum 0.01% of image area (reduced from 0.1%)
+        max_area = (height * width) * 0.2     # Maximum 20% of image area (increased from 10%)
+        
+        logging.info(f"Area filter: min={min_area:.0f}, max={max_area:.0f}")
         
         for i, contour in enumerate(contours):
             area = cv2.contourArea(contour)
+            logging.info(f"Contour {i}: area={area:.0f}")
             
             # Filter by area
             if area < min_area or area > max_area:
+                logging.info(f"Contour {i}: filtered out (area {area:.0f} not in range)")
                 continue
             
             # Simplify contour for better polygon shape
-            epsilon = 0.02 * cv2.arcLength(contour, True)
+            epsilon = 0.005 * cv2.arcLength(contour, True)
             approx = cv2.approxPolyDP(contour, epsilon, True)
             
             # Convert contour points to geographic coordinates
@@ -109,6 +129,7 @@ def extract_features_from_geotiff(image_path, output_folder, feature_type="trees
                 }
                 
                 features.append(feature)
+                logging.info(f"Contour {i}: added as feature with {len(polygon_coords)} points")
         
         logging.info(f"Extracted {len(features)} tree features")