Upload 3 files

src/app.py

@@ -0,0 +1,869 @@
+import cv2
+import numpy as np
+from matplotlib import pyplot as plt
+
+class FruitDiseaseDetector:
+    def __init__(self):
+        self.disease_mask = None
+        self.healthy_mask = None
+        self.processed_image = None
+        
+    def remove_background(self, image):
+        """
+        Remove background from fruit image using multiple segmentation techniques
+        Returns the fruit mask and the image with background removed
+        """
+        # Method 1: GrabCut algorithm (most effective for fruits)
+        fruit_mask_grabcut = self._grabcut_segmentation(image)
+        
+        # Method 2: Color-based segmentation
+        fruit_mask_color = self._color_based_segmentation(image)
+        
+        # Method 3: Edge-based segmentation
+        fruit_mask_edge = self._edge_based_segmentation(image)
+        
+        # Combine all methods using voting
+        combined_mask = self._combine_masks([fruit_mask_grabcut, fruit_mask_color, fruit_mask_edge])
+        
+        # Post-process the mask
+        final_mask = self._post_process_mask(combined_mask)
+        
+        # Apply mask to image
+        result_image = image.copy()
+        result_image[final_mask == 0] = [0, 0, 0]  # Set background to black
+        
+        return final_mask, result_image
+    
+    def _grabcut_segmentation(self, image):
+        """Use GrabCut algorithm for mango foreground/background separation"""
+        height, width = image.shape[:2]
+        
+        # Initialize mask
+        mask = np.zeros((height, width), np.uint8)
+        
+        # Define rectangle around the mango (mangoes are typically oval/elongated)
+        # Adjust margins for mango shape - less margin on sides, more on top/bottom
+        margin_x = int(width * 0.10)   # Reduced horizontal margin for mango width
+        margin_y = int(height * 0.12)  # Slightly more vertical margin for mango length
+        rect = (margin_x, margin_y, width - 2*margin_x, height - 2*margin_y)
+        
+        # Initialize background and foreground models
+        bgd_model = np.zeros((1, 65), np.float64)
+        fgd_model = np.zeros((1, 65), np.float64)
+        
+        # Apply GrabCut with more iterations for better mango segmentation
+        cv2.grabCut(image, mask, rect, bgd_model, fgd_model, 8, cv2.GC_INIT_WITH_RECT)
+        
+        # Create binary mask (0 for background, 1 for foreground)
+        fruit_mask = np.where((mask == 2) | (mask == 0), 0, 255).astype(np.uint8)
+        
+        return fruit_mask
+    
+    def _color_based_segmentation(self, image):
+        """Segment mango using mango-specific color characteristics"""
+        # Convert to HSV for better color segmentation
+        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        
+        # Mango-specific color ranges (calibrated for mango dataset)
+        # Green mangoes (unripe) - broader green range for mangoes
+        lower_green1 = np.array([35, 25, 25])
+        upper_green1 = np.array([85, 255, 255])
+        
+        # Yellow/Orange mangoes (ripe) - extended range for mango ripeness
+        lower_yellow = np.array([10, 30, 30])
+        upper_yellow = np.array([35, 255, 255])
+        
+        # Red/Orange mangoes (very ripe) - specific to mango varieties
+        lower_red1 = np.array([0, 30, 30])
+        upper_red1 = np.array([15, 255, 255])
+        lower_red2 = np.array([165, 30, 30])
+        upper_red2 = np.array([180, 255, 255])
+        
+        # Yellowish-green mangoes (semi-ripe)
+        lower_yellow_green = np.array([25, 20, 40])
+        upper_yellow_green = np.array([45, 255, 255])
+        
+        # Create masks for mango color ranges
+        mask_green = cv2.inRange(hsv, lower_green1, upper_green1)
+        mask_yellow = cv2.inRange(hsv, lower_yellow, upper_yellow)
+        mask_red1 = cv2.inRange(hsv, lower_red1, upper_red1)
+        mask_red2 = cv2.inRange(hsv, lower_red2, upper_red2)
+        mask_yellow_green = cv2.inRange(hsv, lower_yellow_green, upper_yellow_green)
+        
+        # Combine all mango color masks
+        fruit_mask = cv2.bitwise_or(mask_green, mask_yellow)
+        fruit_mask = cv2.bitwise_or(fruit_mask, mask_red1)
+        fruit_mask = cv2.bitwise_or(fruit_mask, mask_red2)
+        fruit_mask = cv2.bitwise_or(fruit_mask, mask_yellow_green)
+        
+        # Include areas with moderate saturation and brightness (mango skin variations)
+        saturation = hsv[:, :, 1]  # Saturation channel
+        value = hsv[:, :, 2]       # Value channel
+        
+        # Mango skin can have lower saturation but still be fruit
+        _, moderate_sat_mask = cv2.threshold(saturation, 30, 255, cv2.THRESH_BINARY)
+        _, bright_mask = cv2.threshold(value, 50, 255, cv2.THRESH_BINARY)
+        
+        # Additional mask for pale/light mango areas
+        mango_skin_mask = cv2.bitwise_and(moderate_sat_mask, bright_mask)
+        
+        # Final combination optimized for mangoes
+        fruit_mask = cv2.bitwise_or(fruit_mask, mango_skin_mask)
+        
+        return fruit_mask
+    
+    def _edge_based_segmentation(self, image):
+        """Use edge detection and contour analysis for segmentation"""
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        
+        # Apply Gaussian blur
+        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+        
+        # Edge detection
+        edges = cv2.Canny(blurred, 50, 150)
+        
+        # Find contours
+        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Create mask
+        mask = np.zeros(gray.shape, np.uint8)
+        
+        if contours:
+            # Find the largest contour (assuming it's the fruit)
+            largest_contour = max(contours, key=cv2.contourArea)
+            
+            # Only consider if the contour is reasonably large
+            if cv2.contourArea(largest_contour) > (gray.shape[0] * gray.shape[1] * 0.1):
+                cv2.fillPoly(mask, [largest_contour], 255)
+        
+        return mask
+    
+    def _combine_masks(self, masks):
+        """Combine multiple masks using majority voting"""
+        height, width = masks[0].shape
+        combined = np.zeros((height, width), dtype=np.uint8)
+        
+        # Convert masks to binary (0 or 1)
+        binary_masks = [(mask > 127).astype(np.uint8) for mask in masks]
+        
+        # Sum all masks
+        mask_sum = np.sum(binary_masks, axis=0)
+        
+        # Use majority voting (at least 2 out of 3 methods agree)
+        combined[mask_sum >= 2] = 255
+        
+        return combined
+    
+    def _post_process_mask(self, mask):
+        """Clean up the mask using morphological operations"""
+        # Remove small noise
+        kernel_small = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+        cleaned = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel_small)
+        
+        # Fill small holes
+        kernel_large = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
+        cleaned = cv2.morphologyEx(cleaned, cv2.MORPH_CLOSE, kernel_large)
+        
+        # Find the largest connected component (should be the main fruit)
+        num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(cleaned, connectivity=8)
+        
+        if num_labels > 1:
+            # Find largest component (excluding background)
+            largest_label = 1 + np.argmax(stats[1:, cv2.CC_STAT_AREA])
+            
+            # Create mask with only the largest component
+            final_mask = np.zeros_like(cleaned)
+            final_mask[labels == largest_label] = 255
+        else:
+            final_mask = cleaned
+        
+        return final_mask
+
+    def preprocess_image(self, image):
+        """Preprocess the input image for disease detection"""
+        # Convert to different color spaces for better analysis
+        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
+        
+        # Apply Gaussian blur to reduce noise
+        blurred = cv2.GaussianBlur(image, (5, 5), 0)
+        
+        return blurred, hsv, lab
+    
+    def detect_diseased_areas(self, image, fruit_mask=None):
+        """
+        Detect mango diseases using color-based segmentation and texture analysis
+        Calibrated for: Alternaria, Anthracnose, Aspergillus (Black Mould), Lasiodiplodia (Stem Rot)
+        """
+        blurred, hsv, lab = self.preprocess_image(image)
+        
+        # Method 1: Detect Anthracnose (dark circular spots with orange/pink halos)
+        disease_mask1 = self._detect_anthracnose(hsv, lab)
+        
+        # Method 2: Detect Alternaria (brown/black irregular spots)
+        disease_mask2 = self._detect_alternaria(hsv, lab)
+        
+        # Method 3: Detect Aspergillus (Black Mould Rot - dark, fuzzy patches)
+        disease_mask3 = self._detect_aspergillus(hsv, lab)
+        
+        # Method 4: Detect Lasiodiplodia (Stem and Rot - soft, dark areas)
+        disease_mask4 = self._detect_lasiodiplodia(hsv, lab)
+        
+        # Method 5: General texture-based detection for rough/irregular surfaces
+        disease_mask5 = self._detect_texture_anomalies(blurred)
+        
+        # Method 6: Edge-based detection for irregular boundaries
+        disease_mask6 = self._detect_irregular_edges(blurred)
+        
+        # Combine disease-specific methods first (higher confidence)
+        primary_disease_mask = cv2.bitwise_or(disease_mask1, disease_mask2)
+        primary_disease_mask = cv2.bitwise_or(primary_disease_mask, disease_mask3)
+        primary_disease_mask = cv2.bitwise_or(primary_disease_mask, disease_mask4)
+        
+        # Secondary detection (texture and edges) - use only if there's significant evidence
+        secondary_mask = cv2.bitwise_and(disease_mask5, disease_mask6)
+        
+        # Combine primary and secondary with different weights
+        combined_mask = cv2.bitwise_or(primary_disease_mask, secondary_mask)
+        
+        # Apply fruit mask to limit detection to mango area only
+        if fruit_mask is not None:
+            combined_mask = cv2.bitwise_and(combined_mask, fruit_mask)
+        
+        # Post-processing: More aggressive noise removal for better accuracy
+        kernel_small = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+        kernel_medium = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+        
+        # Remove small noise (more aggressive)
+        combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_OPEN, kernel_small)
+        combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_OPEN, kernel_medium)
+        
+        # Fill small holes but not too aggressively
+        kernel_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+        combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_CLOSE, kernel_close)
+        
+        # Filter out very small regions (likely noise)
+        contours, _ = cv2.findContours(combined_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        filtered_mask = np.zeros_like(combined_mask)
+        min_area = 75  # Balanced minimum area for good detection
+        
+        for contour in contours:
+            if cv2.contourArea(contour) >= min_area:
+                cv2.fillPoly(filtered_mask, [contour], 255)
+        
+        return filtered_mask
+    
+    def _detect_anthracnose(self, hsv, lab):
+        """Detect Anthracnose disease - dark circular spots with orange/pink halos"""
+        # Anthracnose characteristics: Dark centers with lighter halos
+        # Use both HSV and LAB for better detection
+        
+        # Dark spots in HSV (less conservative thresholds)
+        lower_dark = np.array([0, 40, 0])
+        upper_dark = np.array([180, 255, 80])
+        dark_mask = cv2.inRange(hsv, lower_dark, upper_dark)
+        
+        # Reddish-brown areas (anthracnose lesions) - broader range
+        lower_reddish = np.array([0, 50, 15])
+        upper_reddish = np.array([25, 255, 140])
+        reddish_mask = cv2.inRange(hsv, lower_reddish, upper_reddish)
+        
+        # LAB color space for better brown/dark detection
+        l_channel = lab[:, :, 0]
+        a_channel = lab[:, :, 1]
+        
+        # Less conservative dark areas with reddish tint
+        _, dark_lab = cv2.threshold(l_channel, 85, 255, cv2.THRESH_BINARY_INV)
+        _, red_lab = cv2.threshold(a_channel, 135, 255, cv2.THRESH_BINARY)
+        
+        lab_anthracnose = cv2.bitwise_and(dark_lab, red_lab)
+        
+        # Combine HSV and LAB detections - use OR instead of AND for better sensitivity
+        anthracnose_mask = cv2.bitwise_or(dark_mask, reddish_mask)
+        anthracnose_mask = cv2.bitwise_or(anthracnose_mask, lab_anthracnose)
+        
+        return anthracnose_mask
+    
+    def _detect_alternaria(self, hsv, lab):
+        """Detect Alternaria disease - brown/black irregular spots with concentric rings"""
+        # Alternaria has characteristic brown to black lesions
+        
+        # Less conservative brown to black spots in HSV
+        lower_brown1 = np.array([5, 60, 5])
+        upper_brown1 = np.array([25, 255, 100])
+        
+        lower_brown2 = np.array([0, 40, 3])
+        upper_brown2 = np.array([20, 255, 80])
+        
+        brown_mask1 = cv2.inRange(hsv, lower_brown1, upper_brown1)
+        brown_mask2 = cv2.inRange(hsv, lower_brown2, upper_brown2)
+        
+        # Very dark areas (advanced alternaria) - less conservative
+        lower_black = np.array([0, 30, 0])
+        upper_black = np.array([180, 255, 50])
+        black_mask = cv2.inRange(hsv, lower_black, upper_black)
+        
+        # LAB space detection for brown lesions - less strict
+        l_channel = lab[:, :, 0]
+        _, dark_lab = cv2.threshold(l_channel, 70, 255, cv2.THRESH_BINARY_INV)
+        
+        # Combine alternaria indicators - use OR for better sensitivity
+        alternaria_mask = cv2.bitwise_or(brown_mask1, brown_mask2)
+        alternaria_mask = cv2.bitwise_or(alternaria_mask, black_mask)
+        alternaria_mask = cv2.bitwise_or(alternaria_mask, dark_lab)
+        
+        return alternaria_mask
+    
+    def _detect_aspergillus(self, hsv, lab):
+        """Detect Aspergillus (Black Mould Rot) - dark, fuzzy patches with irregular borders"""
+        # Aspergillus appears as very dark, irregular patches with possible greenish tints
+        
+        # Very dark areas in HSV - less conservative
+        lower_black = np.array([0, 20, 0])
+        upper_black = np.array([180, 255, 40])
+        black_mask = cv2.inRange(hsv, lower_black, upper_black)
+        
+        # Dark greenish areas (aspergillus can have greenish tint) - broader range
+        lower_dark_green = np.array([40, 40, 3])
+        upper_dark_green = np.array([80, 255, 60])
+        dark_green_mask = cv2.inRange(hsv, lower_dark_green, upper_dark_green)
+        
+        # Dark bluish-green areas (specific to aspergillus) - broader range
+        lower_blue_green = np.array([85, 30, 5])
+        upper_blue_green = np.array([120, 255, 80])
+        blue_green_mask = cv2.inRange(hsv, lower_blue_green, upper_blue_green)
+        
+        # LAB space for very dark areas - less conservative
+        l_channel = lab[:, :, 0]
+        b_channel = lab[:, :, 2]
+        
+        _, very_dark_lab = cv2.threshold(l_channel, 50, 255, cv2.THRESH_BINARY_INV)
+        
+        # Blue-green tint in LAB space (aspergillus characteristic) - broader range
+        _, blue_tint = cv2.threshold(b_channel, 110, 255, cv2.THRESH_BINARY_INV)
+        
+        lab_aspergillus = cv2.bitwise_and(very_dark_lab, blue_tint)
+        
+        # Combine aspergillus indicators - use OR for better sensitivity
+        aspergillus_mask = cv2.bitwise_or(black_mask, very_dark_lab)
+        aspergillus_mask = cv2.bitwise_or(aspergillus_mask, dark_green_mask)
+        aspergillus_mask = cv2.bitwise_or(aspergillus_mask, blue_green_mask)
+        aspergillus_mask = cv2.bitwise_or(aspergillus_mask, lab_aspergillus)
+        
+        return aspergillus_mask
+    
+    def _detect_lasiodiplodia(self, hsv, lab):
+        """Detect Lasiodiplodia (Stem and Rot disease) - soft, dark areas with brown/black coloration"""
+        # Lasiodiplodia characteristics: dark, soft areas with brown/black coloration
+        
+        # Brown rot areas - less conservative
+        lower_rot = np.array([8, 50, 10])
+        upper_rot = np.array([30, 255, 120])
+        rot_mask = cv2.inRange(hsv, lower_rot, upper_rot)
+        
+        # Dark spots with higher saturation (active rot) - less strict
+        lower_active_rot = np.array([0, 60, 5])
+        upper_active_rot = np.array([20, 255, 100])
+        active_rot_mask = cv2.inRange(hsv, lower_active_rot, upper_active_rot)
+        
+        # Very dark areas (advanced lasiodiplodia) - broader range
+        lower_very_dark = np.array([0, 30, 0])
+        upper_very_dark = np.array([30, 255, 60])
+        very_dark_mask = cv2.inRange(hsv, lower_very_dark, upper_very_dark)
+        
+        # LAB space for detecting rot areas - less conservative
+        l_channel = lab[:, :, 0]
+        a_channel = lab[:, :, 1]
+        
+        _, dark_rot = cv2.threshold(l_channel, 70, 255, cv2.THRESH_BINARY_INV)
+        _, red_tint = cv2.threshold(a_channel, 130, 255, cv2.THRESH_BINARY)
+        
+        lab_rot = cv2.bitwise_and(dark_rot, red_tint)
+        
+        # Combine lasiodiplodia indicators - use OR for better sensitivity
+        lasiodiplodia_mask = cv2.bitwise_or(rot_mask, active_rot_mask)
+        lasiodiplodia_mask = cv2.bitwise_or(lasiodiplodia_mask, very_dark_mask)
+        lasiodiplodia_mask = cv2.bitwise_or(lasiodiplodia_mask, lab_rot)
+        
+        return lasiodiplodia_mask
+    
+    def _detect_black_mould_rot(self, hsv, lab):
+        """Detect Black Mould Rot - dark, fuzzy patches with irregular borders (legacy method)"""
+        # This method is now replaced by _detect_aspergillus but kept for compatibility
+        return self._detect_aspergillus(hsv, lab)
+    
+    def _detect_stem_rot(self, hsv, lab):
+        """Detect Stem and Rot disease - soft, dark areas typically near stem end (legacy method)"""
+        # This method is now replaced by _detect_lasiodiplodia but kept for compatibility
+        return self._detect_lasiodiplodia(hsv, lab)
+    
+    def _detect_brown_spots(self, hsv):
+        """Detect brown/dark spots typical of fruit diseases (legacy method)"""
+        # Define HSV range for brown/dark diseased areas
+        # Brown spots: Low saturation, low value, wide hue range
+        lower_brown = np.array([0, 20, 20])
+        upper_brown = np.array([30, 255, 120])
+        
+        # Create mask for brown areas
+        brown_mask1 = cv2.inRange(hsv, lower_brown, upper_brown)
+        
+        # Additional brown range (reddish-brown)
+        lower_brown2 = np.array([150, 20, 20])
+        upper_brown2 = np.array([180, 255, 120])
+        brown_mask2 = cv2.inRange(hsv, lower_brown2, upper_brown2)
+        
+        # Combine brown masks
+        brown_mask = cv2.bitwise_or(brown_mask1, brown_mask2)
+        
+        return brown_mask
+    
+    def _detect_dark_spots_lab(self, lab):
+        """Detect dark spots using LAB color space"""
+        l_channel = lab[:, :, 0]
+        a_channel = lab[:, :, 1]
+        
+        # Dark areas have low L values
+        _, dark_mask = cv2.threshold(l_channel, 80, 255, cv2.THRESH_BINARY_INV)
+        
+        # Areas with high 'a' values (reddish) combined with darkness
+        _, red_mask = cv2.threshold(a_channel, 140, 255, cv2.THRESH_BINARY)
+        
+        # Combine dark and reddish areas
+        lab_mask = cv2.bitwise_and(dark_mask, red_mask)
+        
+        return lab_mask
+    
+    def _detect_texture_anomalies(self, image):
+        """Detect texture anomalies using local binary patterns concept (calibrated for mango)"""
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        
+        # Calculate local standard deviation (texture measure) - optimized for mango texture
+        kernel = np.ones((7, 7), np.float32) / 49  # Slightly smaller kernel for mango details
+        gray_float = gray.astype(np.float32)
+        mean = cv2.filter2D(gray_float, -1, kernel)
+        sqr_mean = cv2.filter2D(gray_float**2, -1, kernel)
+        
+        # Ensure variance is non-negative (handle floating point precision errors)
+        variance = sqr_mean - mean**2
+        variance = np.maximum(variance, 0)  # Clamp negative values to 0
+        std_dev = np.sqrt(variance)
+        
+        # Handle NaN and infinity values
+        std_dev = np.nan_to_num(std_dev, nan=0.0, posinf=255.0, neginf=0.0)
+        
+        # Normalize to 0-255 range
+        if std_dev.max() > 0:
+            std_dev = (std_dev / std_dev.max() * 255).astype(np.uint8)
+        else:
+            std_dev = std_dev.astype(np.uint8)
+        
+        # Higher threshold for mango diseases (less sensitive to normal texture)
+        _, texture_mask = cv2.threshold(std_dev, 30, 255, cv2.THRESH_BINARY)
+        
+        # Additional texture analysis for mango-specific roughness
+        # Use Sobel operators to detect rough areas - more conservative
+        sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+        sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+        sobel_magnitude = np.sqrt(sobelx**2 + sobely**2)
+        sobel_magnitude = np.uint8(sobel_magnitude / sobel_magnitude.max() * 255)
+        
+        # Higher threshold for rough texture detection (less sensitive)
+        _, rough_mask = cv2.threshold(sobel_magnitude, 50, 255, cv2.THRESH_BINARY)
+        
+        # Combine standard deviation and sobel-based texture detection
+        # Use AND operation to require both methods to agree (more conservative)
+        final_texture_mask = cv2.bitwise_and(texture_mask, rough_mask)
+        
+        return final_texture_mask
+    
+    def _detect_irregular_edges(self, image):
+        """Detect irregular edges that might indicate disease boundaries"""
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        
+        # Apply Canny edge detection
+        edges = cv2.Canny(gray, 50, 150)
+        
+        # Dilate edges to create regions
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+        dilated_edges = cv2.dilate(edges, kernel, iterations=2)
+        
+        return dilated_edges
+    
+    def calculate_disease_severity(self, image, disease_mask, fruit_mask):
+        """Calculate disease severity as percentage of affected area"""
+        if fruit_mask is not None:
+            # Use provided fruit mask
+            fruit_area = cv2.countNonZero(fruit_mask)
+        else:
+            # Fallback: create fruit mask (assuming fruit takes up most of the image)
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            _, fruit_mask = cv2.threshold(gray, 30, 255, cv2.THRESH_BINARY)
+            fruit_area = cv2.countNonZero(fruit_mask)
+        
+        # Calculate disease area (only within fruit region)
+        if fruit_mask is not None:
+            disease_in_fruit = cv2.bitwise_and(disease_mask, fruit_mask)
+            disease_area = cv2.countNonZero(disease_in_fruit)
+        else:
+            disease_area = cv2.countNonZero(disease_mask)
+        
+        if fruit_area == 0:
+            return 0
+        
+        severity_percentage = (disease_area / fruit_area) * 100
+        return min(severity_percentage, 100)  # Cap at 100%
+    
+    def classify_disease_level(self, severity_percentage):
+        """Classify mango disease level based on severity percentage (calibrated for mango)"""
+        if severity_percentage < 2:
+            return "Healthy", (0, 255, 0)  # Green - very strict for healthy
+        elif severity_percentage < 8:
+            return "Early Disease", (0, 255, 255)  # Yellow - early detection
+        elif severity_percentage < 20:
+            return "Moderate Disease", (0, 165, 255)  # Orange - moderate infection
+        elif severity_percentage < 40:
+            return "Severe Disease", (0, 100, 255)  # Red-Orange - severe infection
+        else:
+            return "Critical Disease", (0, 0, 255)  # Red - critical, unmarketable
+    
+    def process_image(self, image_path):
+        """Main processing function with background removal (calibrated for mango diseases)"""
+        # Load image
+        image = cv2.imread(image_path)
+        if image is None:
+            raise ValueError("Could not load image")
+        
+        print("Step 1: Removing background (mango-optimized)...")
+        # Remove background first
+        fruit_mask, image_no_bg = self.remove_background(image)
+        
+        print("Step 2: Detecting mango diseases (Alternaria, Anthracnose, Aspergillus, Lasiodiplodia)...")
+        # Detect diseased areas (only within mango region)
+        disease_mask = self.detect_diseased_areas(image_no_bg, fruit_mask)
+        
+        print("Step 3: Calculating mango disease severity...")
+        # Calculate severity
+        severity = self.calculate_disease_severity(image_no_bg, disease_mask, fruit_mask)
+        disease_level, color = self.classify_disease_level(severity)
+        
+        print("Step 4: Creating mango disease visualization...")
+        # Create output visualization with bounding boxes
+        output_image, disease_info = self._create_output_visualization(image, disease_mask, severity, disease_level, color, fruit_mask)
+        
+        # Store results
+        self.disease_mask = disease_mask
+        self.processed_image = output_image
+        self.fruit_mask = fruit_mask
+        self.image_no_bg = image_no_bg
+        self.disease_info = disease_info
+        
+        return {
+            'severity_percentage': severity,
+            'disease_level': disease_level,
+            'disease_mask': disease_mask,
+            'output_image': output_image,
+            'fruit_mask': fruit_mask,
+            'image_no_bg': image_no_bg,
+            'disease_info': disease_info,
+            'num_diseased_regions': len(disease_info)
+        }
+    
+    def _create_output_visualization(self, original, mask, severity, level, color, fruit_mask=None):
+        """Create visualization showing detected diseased areas with bounding boxes"""
+        # Start with original image
+        result = original.copy()
+        
+        # If we have a fruit mask, dim the background
+        if fruit_mask is not None:
+            background = np.zeros_like(original)
+            result = np.where(fruit_mask[..., np.newaxis] == 0, 
+                            background, result)
+        
+        # Create colored overlay for diseased areas
+        overlay = result.copy()
+        disease_info = []
+        
+        if np.any(mask > 0):  # Only if there are diseased areas
+            overlay[mask > 0] = color
+            
+            # Blend original image with overlay
+            result = cv2.addWeighted(result, 0.7, overlay, 0.3, 0)
+            
+            # Find contours and draw bounding boxes
+            contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            
+            # Filter contours by minimum area to avoid tiny noise
+            min_area = 50  # Minimum area threshold
+            valid_contours = [cnt for cnt in contours if cv2.contourArea(cnt) >= min_area]
+            
+            # Draw contours and bounding boxes
+            for i, contour in enumerate(valid_contours):
+                # Draw contour outline
+                cv2.drawContours(result, [contour], -1, color, 2)
+                
+                # Get bounding rectangle
+                x, y, w, h = cv2.boundingRect(contour)
+                
+                # Draw bounding box
+                cv2.rectangle(result, (x, y), (x + w, y + h), color, 3)
+                
+                # Calculate area of this diseased region
+                area = cv2.contourArea(contour)
+                disease_info.append({
+                    'id': i + 1,
+                    'bbox': (x, y, w, h),
+                    'area': area,
+                    'center': (x + w//2, y + h//2)
+                })
+                
+                # Add label with disease ID
+                label = f"D{i+1}"
+                label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)[0]
+                
+                # Position label above bounding box
+                label_x = x
+                label_y = y - 10 if y - 10 > 20 else y + h + 25
+                
+                # Draw label background
+                cv2.rectangle(result, 
+                            (label_x - 2, label_y - label_size[1] - 2),
+                            (label_x + label_size[0] + 2, label_y + 2),
+                            color, -1)
+                
+                # Draw label text
+                cv2.putText(result, label, (label_x, label_y), 
+                          cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+        
+        # Add overall statistics
+        num_diseases = len(disease_info)
+        text1 = f"{level}: {severity:.1f}%"
+        text2 = f"Diseased Regions: {num_diseases}"
+        
+        # Main status text
+        cv2.putText(result, text1, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, color, 2)
+        cv2.putText(result, text2, (10, 70), cv2.FONT_HERSHEY_SIMPLEX, 0.8, color, 2)
+        
+        # Add fruit outline
+        if fruit_mask is not None:
+            fruit_contours, _ = cv2.findContours(fruit_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            cv2.drawContours(result, fruit_contours, -1, (255, 255, 255), 2)
+        
+        return result, disease_info
+
+    def save_detailed_report(self, output_path, results):
+        """Save detailed report of disease detection results"""
+        report_path = output_path.replace('.jpg', '_report.txt').replace('.png', '_report.txt')
+        
+        with open(report_path, 'w') as f:
+            f.write("=== FRUIT DISEASE DETECTION REPORT ===\n")
+            f.write(f"Image processed: {output_path}\n")
+            f.write(f"Overall Disease Level: {results['disease_level']}\n")
+            f.write(f"Overall Severity: {results['severity_percentage']:.2f}%\n")
+            f.write(f"Number of Diseased Regions: {results['num_diseased_regions']}\n")
+            f.write("\n=== INDIVIDUAL DISEASE REGIONS ===\n")
+            
+            if results['disease_info']:
+                for disease in results['disease_info']:
+                    f.write(f"\nDisease Region D{disease['id']}:\n")
+                    f.write(f"  - Bounding Box: x={disease['bbox'][0]}, y={disease['bbox'][1]}, ")
+                    f.write(f"width={disease['bbox'][2]}, height={disease['bbox'][3]}\n")
+                    f.write(f"  - Area: {disease['area']:.0f} pixels\n")
+                    f.write(f"  - Center: ({disease['center'][0]}, {disease['center'][1]})\n")
+            else:
+                f.write("No diseased regions detected.\n")
+        
+        print(f"Detailed report saved: {report_path}")
+        return report_path
+    
+    def save_results(self, output_path, include_mask=True, include_background_removed=True):
+        """Save processing results"""
+        if self.processed_image is not None:
+            cv2.imwrite(output_path, self.processed_image)
+            print(f"Main result saved: {output_path}")
+        
+        if include_mask and self.disease_mask is not None:
+            mask_path = output_path.replace('.', '_disease_mask.')
+            cv2.imwrite(mask_path, self.disease_mask)
+            print(f"Disease mask saved: {mask_path}")
+        
+        if include_background_removed and hasattr(self, 'image_no_bg') and self.image_no_bg is not None:
+            bg_removed_path = output_path.replace('.', '_no_background.')
+            cv2.imwrite(bg_removed_path, self.image_no_bg)
+            print(f"Background removed image saved: {bg_removed_path}")
+        
+        if hasattr(self, 'fruit_mask') and self.fruit_mask is not None:
+            fruit_mask_path = output_path.replace('.', '_fruit_mask.')
+            cv2.imwrite(fruit_mask_path, self.fruit_mask)
+            print(f"Fruit mask saved: {fruit_mask_path}")
+
+# Example usage and testing function
+def demonstrate_disease_detection():
+    """Demonstrate the mango disease detection algorithm"""
+    detector = FruitDiseaseDetector()
+    
+    print("Mango Disease Detection Algorithm with Background Removal & Bounding Boxes")
+    print("========================================================================")
+    print("This algorithm detects mango diseases using:")
+    print("1. Mango-optimized background removal (GrabCut + Color + Edge detection)")
+    print("2. Anthracnose detection (dark circular spots with orange/pink halos)")
+    print("3. Alternaria detection (brown/black irregular spots with concentric rings)")
+    print("4. Aspergillus detection (black mould with greenish tints)")
+    print("5. Lasiodiplodia detection (stem rot with brown/black soft areas)")
+    print("6. Mango-calibrated texture analysis for rough surfaces")
+    print("7. Edge detection for irregular disease boundaries")
+    print("8. Individual disease region bounding boxes")
+    print()
+    
+    print("Algorithm Features for Mango:")
+    print("- Multi-method background removal optimized for mango shape")
+    print("- Disease-specific detection for common mango diseases")
+    print("- Individual region labeling (D1, D2, D3, etc.)")
+    print("- Mango-specific severity assessment (Healthy < 2%, Early < 8%, etc.)")
+    print("- Comprehensive reporting for mango disease management")
+    print("- Calibrated for mango color variations (green, yellow, orange, red)")
+    print("- Specialized detection for Aspergillus (Black Mould) and Lasiodiplodia (Stem Rot)")
+    
+    return detector
+
+# Batch testing function for algorithm validation
+def test_mango_detection_algorithm():
+    """Test the algorithm on multiple mango samples"""
+    detector = FruitDiseaseDetector()
+    
+    # Test cases with expected results - using correct file names
+    test_cases = [
+        ("SenMangoFruitDDS_bgremoved/Healthy/healthy_003.jpg", "Should be Healthy"),
+        ("SenMangoFruitDDS_bgremoved/Healthy/healthy_010.jpg", "Should be Healthy"),
+        ("SenMangoFruitDDS_bgremoved/Alternaria/Alternaria_005.jpg", "Should detect Alternaria"),
+        ("SenMangoFruitDDS_bgremoved/Alternaria/Alternaria_010.jpg", "Should detect Alternaria"),
+        ("SenMangoFruitDDS_bgremoved/Anthracnose/Anthracnose_002.jpg", "Should detect Anthracnose"),
+        ("SenMangoFruitDDS_bgremoved/Anthracnose/Anthracnose_010.jpg", "Should detect Anthracnose"),
+        ("SenMangoFruitDDS_bgremoved/Black Mould Rot/Aspergillus_001.jpg", "Should detect Aspergillus (Black Mould)"),
+        ("SenMangoFruitDDS_bgremoved/Black Mould Rot/Aspergillus_010.jpg", "Should detect Aspergillus (Black Mould)"),
+        ("SenMangoFruitDDS_bgremoved/Stem and Rot/Lasiodiplodia_001.jpg", "Should detect Lasiodiplodia (Stem Rot)"),
+        ("SenMangoFruitDDS_bgremoved/Stem and Rot/Lasiodiplodia_012.jpg", "Should detect Lasiodiplodia (Stem Rot)"),
+    ]
+    
+    print("=== MANGO DISEASE DETECTION ALGORITHM VALIDATION ===")
+    print("Testing multiple samples to validate algorithm performance")
+    print("Diseases: Alternaria, Anthracnose, Aspergillus (Black Mould), Lasiodiplodia (Stem Rot)")
+    print("=" * 80)
+    
+    results_summary = []
+    
+    for i, (image_path, expected) in enumerate(test_cases, 1):
+        print(f"\nTest {i}: {image_path}")
+        print(f"Expected: {expected}")
+        
+        try:
+            results = detector.process_image(image_path)
+            output_path = f"test_result_{i}.jpg"
+            
+            result_info = {
+                'test_id': i,
+                'image_path': image_path,
+                'expected': expected,
+                'detected_level': results['disease_level'],
+                'severity': results['severity_percentage'],
+                'num_regions': results['num_diseased_regions']
+            }
+            results_summary.append(result_info)
+            
+            print(f"Result: {results['disease_level']} ({results['severity_percentage']:.2f}%)")
+            print(f"Regions: {results['num_diseased_regions']}")
+            
+            # Save test result
+            detector.save_results(output_path, include_mask=True)
+            
+        except Exception as e:
+            print(f"Error: {e}")
+            results_summary.append({
+                'test_id': i,
+                'image_path': image_path,
+                'expected': expected,
+                'detected_level': 'ERROR',
+                'severity': 0.0,
+                'num_regions': 0
+            })
+        
+        print("-" * 50)
+    
+    # Print summary
+    print("\n" + "=" * 80)
+    print("TESTING SUMMARY")
+    print("=" * 80)
+    for result in results_summary:
+        status = "✓" if result['detected_level'] != 'Healthy' and 'Should detect' in result['expected'] else "✗" if result['detected_level'] == 'Healthy' and 'Should detect' in result['expected'] else "✓"
+        print(f"Test {result['test_id']:2d}: {status} {result['detected_level']} ({result['severity']:.1f}%) - {result['expected']}")
+    
+    return results_summary
+
+# Usage example:
+if __name__ == "__main__":
+    # Initialize mango disease detector
+    detector = FruitDiseaseDetector()
+    
+    # Test different disease types - uncomment to test specific diseases:
+    # image_path = "SenMangoFruitDDS_bgremoved/Healthy/healthy_003.jpg"  # Should be Healthy
+    # image_path = "SenMangoFruitDDS_bgremoved/Alternaria/Alternaria_005.jpg"  # Should detect Alternaria
+    # image_path = "SenMangoFruitDDS_bgremoved/Anthracnose/Anthracnose_002.jpg"  # Should detect Anthracnose
+    # image_path = "SenMangoFruitDDS_bgremoved/Black Mould Rot/Aspergillus_001.jpg"  # Should detect Aspergillus
+    image_path = "SenMangoFruitDDS_bgremoved/Stem and Rot/Lasiodiplodia_012.jpg"  # Should detect Lasiodiplodia
+    
+    output_path = "mango_disease_detection_result.jpg"  # Output file name
+    
+    try:
+        print("Processing mango image with calibrated algorithm...")
+        print(f"Input: {image_path}")
+        print(f"Output: {output_path}")
+        print("-" * 60)
+        
+        results = detector.process_image(image_path)
+        
+        print(f"\n=== MANGO DISEASE DETECTION RESULTS ===")
+        print(f"Disease Level: {results['disease_level']}")
+        print(f"Severity: {results['severity_percentage']:.2f}%")
+        print(f"Number of Diseased Regions: {results['num_diseased_regions']}")
+        
+        # Print individual disease information
+        if results['disease_info']:
+            print(f"\n=== INDIVIDUAL DISEASE REGIONS ===")
+            for disease in results['disease_info']:
+                print(f"Disease D{disease['id']}: Area={disease['area']:.0f} pixels, "
+                      f"Center=({disease['center'][0]}, {disease['center'][1]})")
+        else:
+            print("\n=== MANGO HEALTH STATUS ===")
+            print("No significant disease regions detected - mango appears healthy!")
+        
+        # Save results
+        detector.save_results(output_path, include_mask=True)
+        
+        # Save detailed report
+        detector.save_detailed_report(output_path, results)
+        
+        print(f"\n=== FILES SAVED ===")
+        print(f"Main result: {output_path}")
+        print(f"Disease mask: {output_path.replace('.', '_disease_mask.')}")
+        print(f"Background removed: {output_path.replace('.', '_no_background.')}")
+        print(f"Fruit mask: {output_path.replace('.', '_fruit_mask.')}")
+        print(f"Detailed report: {output_path.replace('.jpg', '_report.txt')}")
+        
+        print("\nMango disease detection completed successfully!")
+        print("The algorithm has been calibrated for mango-specific diseases:")
+        print("- Alternaria, Anthracnose, Aspergillus (Black Mould), Lasiodiplodia (Stem Rot)")
+        
+    except FileNotFoundError:
+        print(f"Error: Could not find mango image file '{image_path}'")
+        print("Please check the file path and make sure the image exists.")
+        print("\nAvailable test images:")
+        print("- SenMangoFruitDDS_bgremoved/Healthy/healthy_003.jpg")
+        print("- SenMangoFruitDDS_bgremoved/Alternaria/Alternaria_005.jpg")
+        print("- SenMangoFruitDDS_bgremoved/Anthracnose/Anthracnose_002.jpg")
+    except Exception as e:
+        print(f"Error processing mango image: {e}")
+    
+    # Uncomment below to see algorithm demonstration
+    # demonstrate_disease_detection()
+    
+    # Uncomment below to run batch testing
+    # test_mango_detection_algorithm()

src/mango_disease_ontology.py

@@ -0,0 +1,625 @@
+"""
+Mango Disease Detection Semantic Web Ontology
+Integrates OWL-RL reasoning with computer vision disease detection
+"""
+
+import os
+import json
+from datetime import datetime
+from typing import Dict, List, Tuple, Optional, Any
+import cv2
+import numpy as np
+
+# RDF and OWL libraries
+from rdflib import Graph, Namespace, Literal, URIRef, BNode
+from rdflib.namespace import RDF, RDFS, OWL, XSD
+import owlrl
+
+# Import our disease detection algorithm
+from app import FruitDiseaseDetector
+
+class MangoOntologyManager:
+    """
+    Semantic Web Ontology Manager for Mango Disease Detection
+    Uses OWL-RL reasoning to enhance disease detection with domain knowledge
+    """
+    
+    def __init__(self):
+        # Initialize RDF graph and namespaces
+        self.graph = Graph()
+        
+        # Define namespaces for our ontology
+        self.MANGO = Namespace("http://spotradar.org/mango-disease#")
+        self.DISEASE = Namespace("http://spotradar.org/disease#")
+        self.DETECTION = Namespace("http://spotradar.org/detection#")
+        self.VISUAL = Namespace("http://spotradar.org/visual#")
+        self.AGRI = Namespace("http://spotradar.org/agriculture#")
+        
+        # Bind namespaces to graph
+        self.graph.bind("mango", self.MANGO)
+        self.graph.bind("disease", self.DISEASE)
+        self.graph.bind("detection", self.DETECTION)
+        self.graph.bind("visual", self.VISUAL)
+        self.graph.bind("agri", self.AGRI)
+        self.graph.bind("owl", OWL)
+        self.graph.bind("rdfs", RDFS)
+        
+        # Initialize disease detector
+        self.detector = FruitDiseaseDetector()
+        
+        # Build the ontology
+        self._build_ontology()
+        
+        # Apply OWL-RL reasoning
+        self._apply_reasoning()
+    
+    def _build_ontology(self):
+        """Build the complete mango disease ontology"""
+        print("Building mango disease ontology...")
+        
+        # 1. Define top-level classes
+        self._define_core_classes()
+        
+        # 2. Define mango disease classes
+        self._define_disease_classes()
+        
+        # 3. Define visual characteristics
+        self._define_visual_properties()
+        
+        # 4. Define detection properties
+        self._define_detection_properties()
+        
+        # 5. Define severity levels
+        self._define_severity_levels()
+        
+        # 6. Define causal relationships
+        self._define_causal_relationships()
+        
+        # 7. Define temporal aspects
+        self._define_temporal_aspects()
+        
+        # 8. Define economic impact
+        self._define_economic_impact()
+        
+        print("Ontology structure built successfully!")
+    
+    def _define_core_classes(self):
+        """Define fundamental classes in the ontology"""
+        # Core classes
+        classes = [
+            (self.MANGO.Fruit, "Fruit"),
+            (self.MANGO.MangoFruit, "Mango Fruit"),
+            (self.DISEASE.Disease, "Disease"),
+            (self.DISEASE.FungalDisease, "Fungal Disease"),
+            (self.DISEASE.BacterialDisease, "Bacterial Disease"),
+            (self.VISUAL.VisualCharacteristic, "Visual Characteristic"),
+            (self.VISUAL.ColorCharacteristic, "Color Characteristic"),
+            (self.VISUAL.TextureCharacteristic, "Texture Characteristic"),
+            (self.VISUAL.ShapeCharacteristic, "Shape Characteristic"),
+            (self.DETECTION.DetectionResult, "Detection Result"),
+            (self.DETECTION.ImageAnalysis, "Image Analysis"),
+            (self.AGRI.SeverityLevel, "Severity Level"),
+            (self.AGRI.EconomicImpact, "Economic Impact"),
+        ]
+        
+        for class_uri, label in classes:
+            self.graph.add((class_uri, RDF.type, OWL.Class))
+            self.graph.add((class_uri, RDFS.label, Literal(label)))
+    
+    def _define_disease_classes(self):
+        """Define specific mango disease classes"""
+        # Mango is a subclass of Fruit
+        self.graph.add((self.MANGO.MangoFruit, RDFS.subClassOf, self.MANGO.Fruit))
+        
+        # Disease taxonomy
+        self.graph.add((self.DISEASE.FungalDisease, RDFS.subClassOf, self.DISEASE.Disease))
+        self.graph.add((self.DISEASE.BacterialDisease, RDFS.subClassOf, self.DISEASE.Disease))
+        
+        # Specific mango diseases
+        diseases = [
+            (self.DISEASE.Alternaria, "Alternaria", self.DISEASE.FungalDisease),
+            (self.DISEASE.Anthracnose, "Anthracnose", self.DISEASE.FungalDisease),
+            (self.DISEASE.Aspergillus, "Aspergillus (Black Mould Rot)", self.DISEASE.FungalDisease),
+            (self.DISEASE.Lasiodiplodia, "Lasiodiplodia (Stem and Rot)", self.DISEASE.FungalDisease),
+        ]
+        
+        for disease_uri, label, parent_class in diseases:
+            self.graph.add((disease_uri, RDF.type, OWL.Class))
+            self.graph.add((disease_uri, RDFS.label, Literal(label)))
+            self.graph.add((disease_uri, RDFS.subClassOf, parent_class))
+    
+    def _define_visual_properties(self):
+        """Define visual characteristics and properties"""
+        # Color properties
+        color_chars = [
+            (self.VISUAL.DarkBrown, "Dark Brown Color"),
+            (self.VISUAL.Black, "Black Color"),
+            (self.VISUAL.Orange, "Orange Color"),
+            (self.VISUAL.Pink, "Pink Color"),
+            (self.VISUAL.Green, "Green Color"),
+            (self.VISUAL.Yellow, "Yellow Color"),
+            (self.VISUAL.Red, "Red Color"),
+        ]
+        
+        for color_uri, label in color_chars:
+            self.graph.add((color_uri, RDF.type, OWL.Class))
+            self.graph.add((color_uri, RDFS.label, Literal(label)))
+            self.graph.add((color_uri, RDFS.subClassOf, self.VISUAL.ColorCharacteristic))
+        
+        # Texture properties
+        texture_chars = [
+            (self.VISUAL.Smooth, "Smooth Texture"),
+            (self.VISUAL.Rough, "Rough Texture"),
+            (self.VISUAL.Fuzzy, "Fuzzy Texture"),
+            (self.VISUAL.Irregular, "Irregular Texture"),
+            (self.VISUAL.Concentric, "Concentric Pattern"),
+        ]
+        
+        for texture_uri, label in texture_chars:
+            self.graph.add((texture_uri, RDF.type, OWL.Class))
+            self.graph.add((texture_uri, RDFS.label, Literal(label)))
+            self.graph.add((texture_uri, RDFS.subClassOf, self.VISUAL.TextureCharacteristic))
+        
+        # Shape properties
+        shape_chars = [
+            (self.VISUAL.Circular, "Circular Shape"),
+            (self.VISUAL.Irregular, "Irregular Shape"),
+            (self.VISUAL.Oval, "Oval Shape"),
+            (self.VISUAL.Elongated, "Elongated Shape"),
+        ]
+        
+        for shape_uri, label in shape_chars:
+            self.graph.add((shape_uri, RDF.type, OWL.Class))
+            self.graph.add((shape_uri, RDFS.label, Literal(label)))
+            self.graph.add((shape_uri, RDFS.subClassOf, self.VISUAL.ShapeCharacteristic))
+    
+    def _define_detection_properties(self):
+        """Define object and data properties for detection"""
+        # Object properties
+        properties = [
+            (self.DETECTION.hasDisease, "has disease"),
+            (self.DETECTION.hasVisualCharacteristic, "has visual characteristic"),
+            (self.DETECTION.hasSeverityLevel, "has severity level"),
+            (self.DETECTION.detectedIn, "detected in"),
+            (self.DETECTION.causedBy, "caused by"),
+            (self.DETECTION.affects, "affects"),
+            (self.DETECTION.hasSymptom, "has symptom"),
+            (self.AGRI.hasEconomicImpact, "has economic impact"),
+        ]
+        
+        for prop_uri, label in properties:
+            self.graph.add((prop_uri, RDF.type, OWL.ObjectProperty))
+            self.graph.add((prop_uri, RDFS.label, Literal(label)))
+        
+        # Data properties
+        data_properties = [
+            (self.DETECTION.severityPercentage, "severity percentage", XSD.float),
+            (self.DETECTION.numberOfRegions, "number of regions", XSD.integer),
+            (self.DETECTION.detectionConfidence, "detection confidence", XSD.float),
+            (self.DETECTION.imageWidth, "image width", XSD.integer),
+            (self.DETECTION.imageHeight, "image height", XSD.integer),
+            (self.DETECTION.detectionTimestamp, "detection timestamp", XSD.dateTime),
+            (self.VISUAL.hueValue, "hue value", XSD.integer),
+            (self.VISUAL.saturationValue, "saturation value", XSD.integer),
+            (self.VISUAL.brightnessValue, "brightness value", XSD.integer),
+            (self.AGRI.marketabilityScore, "marketability score", XSD.float),
+        ]
+        
+        for prop_uri, label, datatype in data_properties:
+            self.graph.add((prop_uri, RDF.type, OWL.DatatypeProperty))
+            self.graph.add((prop_uri, RDFS.label, Literal(label)))
+            self.graph.add((prop_uri, RDFS.range, datatype))
+    
+    def _define_severity_levels(self):
+        """Define severity level instances"""
+        severity_levels = [
+            (self.AGRI.Healthy, "Healthy", 0, 2),
+            (self.AGRI.EarlyDisease, "Early Disease", 2, 8),
+            (self.AGRI.ModerateDisease, "Moderate Disease", 8, 20),
+            (self.AGRI.SevereDisease, "Severe Disease", 20, 40),
+            (self.AGRI.CriticalDisease, "Critical Disease", 40, 100),
+        ]
+        
+        for level_uri, label, min_percent, max_percent in severity_levels:
+            self.graph.add((level_uri, RDF.type, self.AGRI.SeverityLevel))
+            self.graph.add((level_uri, RDFS.label, Literal(label)))
+            self.graph.add((level_uri, self.DETECTION.severityPercentage, Literal(min_percent, datatype=XSD.float)))
+            self.graph.add((level_uri, self.DETECTION.severityPercentage, Literal(max_percent, datatype=XSD.float)))
+    
+    def _define_causal_relationships(self):
+        """Define disease characteristics and causal relationships"""
+        # Alternaria characteristics
+        alternaria_symptoms = [
+            (self.DISEASE.Alternaria, self.DETECTION.hasSymptom, self.VISUAL.DarkBrown),
+            (self.DISEASE.Alternaria, self.DETECTION.hasSymptom, self.VISUAL.Black),
+            (self.DISEASE.Alternaria, self.DETECTION.hasSymptom, self.VISUAL.Irregular),
+            (self.DISEASE.Alternaria, self.DETECTION.hasSymptom, self.VISUAL.Concentric),
+        ]
+        
+        # Anthracnose characteristics
+        anthracnose_symptoms = [
+            (self.DISEASE.Anthracnose, self.DETECTION.hasSymptom, self.VISUAL.Black),
+            (self.DISEASE.Anthracnose, self.DETECTION.hasSymptom, self.VISUAL.Orange),
+            (self.DISEASE.Anthracnose, self.DETECTION.hasSymptom, self.VISUAL.Pink),
+            (self.DISEASE.Anthracnose, self.DETECTION.hasSymptom, self.VISUAL.Circular),
+        ]
+        
+        # Aspergillus characteristics
+        aspergillus_symptoms = [
+            (self.DISEASE.Aspergillus, self.DETECTION.hasSymptom, self.VISUAL.Black),
+            (self.DISEASE.Aspergillus, self.DETECTION.hasSymptom, self.VISUAL.Green),
+            (self.DISEASE.Aspergillus, self.DETECTION.hasSymptom, self.VISUAL.Fuzzy),
+            (self.DISEASE.Aspergillus, self.DETECTION.hasSymptom, self.VISUAL.Irregular),
+        ]
+        
+        # Lasiodiplodia characteristics
+        lasiodiplodia_symptoms = [
+            (self.DISEASE.Lasiodiplodia, self.DETECTION.hasSymptom, self.VISUAL.DarkBrown),
+            (self.DISEASE.Lasiodiplodia, self.DETECTION.hasSymptom, self.VISUAL.Black),
+            (self.DISEASE.Lasiodiplodia, self.DETECTION.hasSymptom, self.VISUAL.Irregular),
+        ]
+        
+        all_symptoms = alternaria_symptoms + anthracnose_symptoms + aspergillus_symptoms + lasiodiplodia_symptoms
+        
+        for subject, predicate, obj in all_symptoms:
+            self.graph.add((subject, predicate, obj))
+    
+    def _define_temporal_aspects(self):
+        """Define temporal progression of diseases"""
+        # Disease progression stages
+        stages = [
+            (self.DISEASE.EarlyStage, "Early Stage"),
+            (self.DISEASE.DevelopingStage, "Developing Stage"),
+            (self.DISEASE.AdvancedStage, "Advanced Stage"),
+            (self.DISEASE.CriticalStage, "Critical Stage"),
+        ]
+        
+        for stage_uri, label in stages:
+            self.graph.add((stage_uri, RDF.type, OWL.Class))
+            self.graph.add((stage_uri, RDFS.label, Literal(label)))
+            self.graph.add((stage_uri, RDFS.subClassOf, self.DISEASE.Disease))
+    
+    def _define_economic_impact(self):
+        """Define economic impact levels"""
+        impact_levels = [
+            (self.AGRI.NoImpact, "No Economic Impact", 100),
+            (self.AGRI.MinimalImpact, "Minimal Impact", 85),
+            (self.AGRI.ModerateImpact, "Moderate Impact", 60),
+            (self.AGRI.SevereImpact, "Severe Impact", 30),
+            (self.AGRI.CriticalImpact, "Critical Impact", 0),
+        ]
+        
+        for impact_uri, label, marketability in impact_levels:
+            self.graph.add((impact_uri, RDF.type, self.AGRI.EconomicImpact))
+            self.graph.add((impact_uri, RDFS.label, Literal(label)))
+            self.graph.add((impact_uri, self.AGRI.marketabilityScore, Literal(marketability, datatype=XSD.float)))
+    
+    def _apply_reasoning(self):
+        """Apply OWL-RL reasoning to the ontology"""
+        print("Applying OWL-RL reasoning...")
+        
+        # Apply OWL-RL inference rules
+        owlrl.DeductiveClosure(owlrl.OWLRL_Semantics).expand(self.graph)
+        
+        print(f"Ontology size after reasoning: {len(self.graph)} triples")
+    
+    def create_detection_instance(self, image_path: str, detection_results: Dict) -> URIRef:
+        """Create a semantic instance of a disease detection result"""
+        # Create unique URI for this detection
+        detection_id = f"detection_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{hash(image_path) % 10000}"
+        detection_uri = self.DETECTION[detection_id]
+        
+        # Add basic detection information
+        self.graph.add((detection_uri, RDF.type, self.DETECTION.DetectionResult))
+        self.graph.add((detection_uri, RDFS.label, Literal(f"Detection of {os.path.basename(image_path)}")))
+        self.graph.add((detection_uri, self.DETECTION.detectionTimestamp, 
+                       Literal(datetime.now(), datatype=XSD.dateTime)))
+        
+        # Add image properties
+        if 'image_properties' in detection_results:
+            props = detection_results['image_properties']
+            if 'width' in props:
+                self.graph.add((detection_uri, self.DETECTION.imageWidth, 
+                               Literal(props['width'], datatype=XSD.integer)))
+            if 'height' in props:
+                self.graph.add((detection_uri, self.DETECTION.imageHeight, 
+                               Literal(props['height'], datatype=XSD.integer)))
+        
+        # Add detection results
+        self.graph.add((detection_uri, self.DETECTION.severityPercentage, 
+                       Literal(detection_results['severity_percentage'], datatype=XSD.float)))
+        self.graph.add((detection_uri, self.DETECTION.numberOfRegions, 
+                       Literal(detection_results['num_diseased_regions'], datatype=XSD.integer)))
+        
+        # Map disease level to semantic class
+        disease_level = detection_results['disease_level']
+        severity_uri = self._map_severity_to_uri(disease_level)
+        if severity_uri:
+            self.graph.add((detection_uri, self.DETECTION.hasSeverityLevel, severity_uri))
+        
+        # Infer likely diseases based on detection patterns
+        inferred_diseases = self._infer_diseases(detection_results)
+        for disease_uri in inferred_diseases:
+            self.graph.add((detection_uri, self.DETECTION.hasDisease, disease_uri))
+        
+        # Calculate economic impact
+        economic_impact = self._calculate_economic_impact(detection_results['severity_percentage'])
+        self.graph.add((detection_uri, self.AGRI.hasEconomicImpact, economic_impact))
+        
+        return detection_uri
+    
+    def _map_severity_to_uri(self, disease_level: str) -> Optional[URIRef]:
+        """Map disease level string to severity URI"""
+        mapping = {
+            "Healthy": self.AGRI.Healthy,
+            "Early Disease": self.AGRI.EarlyDisease,
+            "Moderate Disease": self.AGRI.ModerateDisease,
+            "Severe Disease": self.AGRI.SevereDisease,
+            "Critical Disease": self.AGRI.CriticalDisease,
+        }
+        return mapping.get(disease_level)
+    
+    def _infer_diseases(self, detection_results: Dict) -> List[URIRef]:
+        """Infer likely diseases based on detection characteristics"""
+        inferred = []
+        severity = detection_results['severity_percentage']
+        
+        # Simple inference based on severity and patterns
+        # In a real system, this would use more sophisticated visual analysis
+        if severity > 5:  # If disease detected
+            # For demonstration, we'll use basic heuristics
+            # In practice, this would analyze color, texture, shape patterns
+            if severity < 15:
+                # Early stage diseases - could be multiple
+                inferred.extend([self.DISEASE.Alternaria, self.DISEASE.Anthracnose])
+            elif severity < 30:
+                # Moderate stage - more specific inference needed
+                inferred.append(self.DISEASE.Anthracnose)
+            else:
+                # Severe cases - possibly aggressive diseases
+                inferred.extend([self.DISEASE.Aspergillus, self.DISEASE.Lasiodiplodia])
+        
+        return inferred
+    
+    def _calculate_economic_impact(self, severity: float) -> URIRef:
+        """Calculate economic impact based on severity"""
+        if severity < 2:
+            return self.AGRI.NoImpact
+        elif severity < 8:
+            return self.AGRI.MinimalImpact
+        elif severity < 20:
+            return self.AGRI.ModerateImpact
+        elif severity < 40:
+            return self.AGRI.SevereImpact
+        else:
+            return self.AGRI.CriticalImpact
+    
+    def process_image_with_semantics(self, image_path: str) -> Dict[str, Any]:
+        """Process image with disease detection and create semantic annotations"""
+        print(f"Processing image with semantic analysis: {image_path}")
+        
+        # Run disease detection
+        detection_results = self.detector.process_image(image_path)
+        
+        # Add image properties
+        image = cv2.imread(image_path)
+        if image is not None:
+            detection_results['image_properties'] = {
+                'width': image.shape[1],
+                'height': image.shape[0],
+                'channels': image.shape[2] if len(image.shape) > 2 else 1
+            }
+        
+        # Create semantic instance
+        detection_uri = self.create_detection_instance(image_path, detection_results)
+        
+        # Query related semantic information
+        semantic_info = self.query_detection_semantics(detection_uri)
+        
+        # Combine results
+        enhanced_results = {
+            **detection_results,
+            'semantic_uri': str(detection_uri),
+            'semantic_info': semantic_info,
+            'ontology_inferences': self._get_ontology_inferences(detection_uri)
+        }
+        
+        return enhanced_results
+    
+    def query_detection_semantics(self, detection_uri: URIRef) -> Dict[str, Any]:
+        """Query semantic information about a detection"""
+        semantic_info = {
+            'diseases': [],
+            'severity_level': None,
+            'economic_impact': None,
+            'symptoms': [],
+            'recommendations': []
+        }
+        
+        # Query diseases
+        query = f"""
+        PREFIX detection: <{self.DETECTION}>
+        PREFIX disease: <{self.DISEASE}>
+        PREFIX rdfs: <{RDFS}>
+        
+        SELECT ?disease ?diseaseLabel WHERE {{
+            <{detection_uri}> detection:hasDisease ?disease .
+            ?disease rdfs:label ?diseaseLabel .
+        }}
+        """
+        
+        for row in self.graph.query(query):
+            semantic_info['diseases'].append({
+                'uri': str(row.disease),
+                'label': str(row.diseaseLabel)
+            })
+        
+        # Query severity level
+        query = f"""
+        PREFIX detection: <{self.DETECTION}>
+        PREFIX agri: <{self.AGRI}>
+        PREFIX rdfs: <{RDFS}>
+        
+        SELECT ?severityLevel ?severityLabel WHERE {{
+            <{detection_uri}> detection:hasSeverityLevel ?severityLevel .
+            ?severityLevel rdfs:label ?severityLabel .
+        }}
+        """
+        
+        for row in self.graph.query(query):
+            semantic_info['severity_level'] = {
+                'uri': str(row.severityLevel),
+                'label': str(row.severityLabel)
+            }
+            break
+        
+        # Query economic impact
+        query = f"""
+        PREFIX agri: <{self.AGRI}>
+        PREFIX rdfs: <{RDFS}>
+        
+        SELECT ?impact ?impactLabel ?marketability WHERE {{
+            <{detection_uri}> agri:hasEconomicImpact ?impact .
+            ?impact rdfs:label ?impactLabel .
+            ?impact agri:marketabilityScore ?marketability .
+        }}
+        """
+        
+        for row in self.graph.query(query):
+            semantic_info['economic_impact'] = {
+                'uri': str(row.impact),
+                'label': str(row.impactLabel),
+                'marketability_score': float(row.marketability)
+            }
+            break
+        
+        return semantic_info
+    
+    def _get_ontology_inferences(self, detection_uri: URIRef) -> List[str]:
+        """Get ontology-based inferences and recommendations"""
+        inferences = []
+        
+        # Query for related information using SPARQL
+        query = f"""
+        PREFIX detection: <{self.DETECTION}>
+        PREFIX disease: <{self.DISEASE}>
+        PREFIX visual: <{self.VISUAL}>
+        PREFIX rdfs: <{RDFS}>
+        
+        SELECT ?disease ?symptom ?symptomLabel WHERE {{
+            <{detection_uri}> detection:hasDisease ?disease .
+            ?disease detection:hasSymptom ?symptom .
+            ?symptom rdfs:label ?symptomLabel .
+        }}
+        """
+        
+        symptoms = []
+        for row in self.graph.query(query):
+            symptoms.append(str(row.symptomLabel))
+        
+        if symptoms:
+            inferences.append(f"Detected visual symptoms: {', '.join(symptoms)}")
+        
+        # Add treatment recommendations based on ontology
+        inferences.extend(self._get_treatment_recommendations(detection_uri))
+        
+        return inferences
+    
+    def _get_treatment_recommendations(self, detection_uri: URIRef) -> List[str]:
+        """Get treatment recommendations based on detected diseases"""
+        recommendations = []
+        
+        # Query detected diseases
+        query = f"""
+        PREFIX detection: <{self.DETECTION}>
+        PREFIX disease: <{self.DISEASE}>
+        PREFIX rdfs: <{RDFS}>
+        
+        SELECT ?disease ?diseaseLabel WHERE {{
+            <{detection_uri}> detection:hasDisease ?disease .
+            ?disease rdfs:label ?diseaseLabel .
+        }}
+        """
+        
+        disease_labels = []
+        for row in self.graph.query(query):
+            disease_labels.append(str(row.diseaseLabel))
+        
+        # Provide recommendations based on diseases
+        if "Alternaria" in disease_labels:
+            recommendations.append("Apply copper-based fungicide for Alternaria control")
+            recommendations.append("Improve air circulation and reduce humidity")
+        
+        if "Anthracnose" in disease_labels:
+            recommendations.append("Use preventive fungicide sprays for Anthracnose")
+            recommendations.append("Remove infected fruits and debris")
+        
+        if "Aspergillus" in disease_labels:
+            recommendations.append("Improve storage conditions to prevent Aspergillus")
+            recommendations.append("Reduce moisture and temperature in storage")
+        
+        if "Lasiodiplodia" in disease_labels:
+            recommendations.append("Improve field sanitation for Lasiodiplodia control")
+            recommendations.append("Avoid mechanical damage during harvest")
+        
+        return recommendations
+    
+    def export_ontology(self, output_path: str, format: str = "turtle"):
+        """Export the ontology to a file"""
+        print(f"Exporting ontology to {output_path} in {format} format...")
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(self.graph.serialize(format=format))
+        
+        print(f"Ontology exported successfully!")
+    
+    def get_ontology_statistics(self) -> Dict[str, int]:
+        """Get statistics about the ontology"""
+        stats = {
+            'total_triples': len(self.graph),
+            'classes': len(list(self.graph.subjects(RDF.type, OWL.Class))),
+            'object_properties': len(list(self.graph.subjects(RDF.type, OWL.ObjectProperty))),
+            'datatype_properties': len(list(self.graph.subjects(RDF.type, OWL.DatatypeProperty))),
+            'individuals': len(list(self.graph.subjects(RDF.type, self.DETECTION.DetectionResult))),
+        }
+        return stats
+    
+    def query_ontology(self, sparql_query: str) -> List[Dict]:
+        """Execute a SPARQL query on the ontology"""
+        results = []
+        for row in self.graph.query(sparql_query):
+            result_dict = {}
+            for var in row.labels:
+                result_dict[var] = str(row[var])
+            results.append(result_dict)
+        return results
+
+def demonstrate_semantic_detection():
+    """Demonstrate the semantic mango disease detection system"""
+    print("=" * 80)
+    print("SEMANTIC WEB ONTOLOGY FOR MANGO DISEASE DETECTION")
+    print("=" * 80)
+    print("Features:")
+    print("- OWL-RL reasoning for enhanced disease inference")
+    print("- Semantic annotation of detection results")
+    print("- Economic impact assessment")
+    print("- Treatment recommendations")
+    print("- SPARQL queries for knowledge discovery")
+    print()
+    
+    # Initialize semantic system
+    print("Initializing semantic ontology manager...")
+    ontology_manager = MangoOntologyManager()
+    
+    # Show ontology statistics
+    stats = ontology_manager.get_ontology_statistics()
+    print(f"Ontology Statistics:")
+    for key, value in stats.items():
+        print(f"  {key.replace('_', ' ').title()}: {value}")
+    print()
+    
+    return ontology_manager
+
+if __name__ == "__main__":
+    # Demonstrate the system
+    demonstrate_semantic_detection()

src/semantic_disease_analyzer.py

@@ -0,0 +1,371 @@
+"""
+Semantic Mango Disease Analysis Integration
+Combines computer vision detection with semantic web reasoning
+"""
+
+import os
+import json
+from typing import Dict, List, Any
+import cv2
+import numpy as np
+from datetime import datetime
+
+# Import our ontology manager
+from mango_disease_ontology import MangoOntologyManager
+
+class SemanticDiseaseAnalyzer:
+    """
+    Enhanced disease analyzer that combines computer vision with semantic reasoning
+    """
+    
+    def __init__(self):
+        self.ontology_manager = MangoOntologyManager()
+        print("Semantic Disease Analyzer initialized with OWL-RL reasoning!")
+    
+    def analyze_image_semantically(self, image_path: str, save_results: bool = True) -> Dict[str, Any]:
+        """
+        Perform semantic analysis of mango disease image
+        """
+        print(f"\n{'='*60}")
+        print(f"SEMANTIC ANALYSIS: {os.path.basename(image_path)}")
+        print(f"{'='*60}")
+        
+        try:
+            # Process with semantic enhancement
+            results = self.ontology_manager.process_image_with_semantics(image_path)
+            
+            # Print enhanced results
+            self._print_semantic_results(results)
+            
+            if save_results:
+                self._save_semantic_results(image_path, results)
+            
+            return results
+            
+        except FileNotFoundError:
+            print(f"Error: Image file not found: {image_path}")
+            return {}
+        except Exception as e:
+            print(f"Error during semantic analysis: {e}")
+            return {}
+    
+    def _print_semantic_results(self, results: Dict[str, Any]):
+        """Print comprehensive semantic analysis results"""
+        
+        # Basic detection results
+        print(f"COMPUTER VISION DETECTION:")
+        print(f"   Disease Level: {results['disease_level']}")
+        print(f"   Severity: {results['severity_percentage']:.2f}%")
+        print(f"   Diseased Regions: {results['num_diseased_regions']}")
+        
+        # Semantic information
+        semantic_info = results.get('semantic_info', {})
+        
+        print(f"\nSEMANTIC REASONING:")
+        
+        # Detected diseases from ontology
+        diseases = semantic_info.get('diseases', [])
+        if diseases:
+            print(f"   Inferred Diseases:")
+            for disease in diseases:
+                print(f"     - {disease['label']}")
+        else:
+            print(f"   No diseases inferred from ontology")
+        
+        # Severity classification
+        severity_level = semantic_info.get('severity_level')
+        if severity_level:
+            print(f"   Ontology Severity: {severity_level['label']}")
+        
+        # Economic impact
+        economic_impact = semantic_info.get('economic_impact')
+        if economic_impact:
+            print(f"   Economic Impact: {economic_impact['label']}")
+            print(f"   Marketability Score: {economic_impact['marketability_score']:.1f}%")
+        
+        # Ontology inferences
+        inferences = results.get('ontology_inferences', [])
+        if inferences:
+            print(f"\nONTOLOGY INFERENCES:")
+            for i, inference in enumerate(inferences, 1):
+                print(f"   {i}. {inference}")
+        
+        # Treatment recommendations
+        recommendations = [inf for inf in inferences if 'Apply' in inf or 'Improve' in inf or 'Remove' in inf or 'Use' in inf or 'Avoid' in inf or 'Reduce' in inf]
+        if recommendations:
+            print(f"\nTREATMENT RECOMMENDATIONS:")
+            for i, rec in enumerate(recommendations, 1):
+                print(f"   {i}. {rec}")
+    
+    def _save_semantic_results(self, image_path: str, results: Dict[str, Any]):
+        """Save semantic analysis results to files"""
+        base_name = os.path.splitext(os.path.basename(image_path))[0]
+        
+        # Save JSON results
+        json_path = f"semantic_analysis_{base_name}.json"
+        with open(json_path, 'w') as f:
+            # Make results JSON serializable
+            json_results = self._make_json_serializable(results)
+            json.dump(json_results, f, indent=2)
+        
+        print(f"\nRESULTS SAVED:")
+        print(f"   JSON Report: {json_path}")
+        
+        # Save visual results
+        if 'output_image' in results:
+            output_path = f"semantic_detection_{base_name}.jpg"
+            cv2.imwrite(output_path, results['output_image'])
+            print(f"   Visual Result: {output_path}")
+        
+        # Save ontology visualization
+        self._save_ontology_visualization(base_name, results)
+    
+    def _make_json_serializable(self, obj):
+        """Make object JSON serializable"""
+        if isinstance(obj, dict):
+            return {k: self._make_json_serializable(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [self._make_json_serializable(item) for item in obj]
+        elif isinstance(obj, np.ndarray):
+            return f"numpy_array_shape_{obj.shape}"
+        elif isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        else:
+            return obj
+    
+    def _save_ontology_visualization(self, base_name: str, results: Dict[str, Any]):
+        """Save ontology-based visualization"""
+        turtle_path = f"ontology_{base_name}.ttl"
+        self.ontology_manager.export_ontology(turtle_path, format="turtle")
+        print(f"   Ontology Export: {turtle_path}")
+    
+    def batch_semantic_analysis(self, image_folder: str = "SenMangoFruitDDS_bgremoved"):
+        """Perform batch semantic analysis on dataset"""
+        print(f"\n{'='*80}")
+        print("BATCH SEMANTIC ANALYSIS OF MANGO DATASET")
+        print(f"{'='*80}")
+        
+        if not os.path.exists(image_folder):
+            print(f"Error: Dataset folder not found: {image_folder}")
+            return
+        
+        # Disease categories in dataset
+        categories = ["Healthy", "Alternaria", "Anthracnose", "Black Mould Rot", "Stem and Rot"]
+        
+        batch_results = {}
+        
+        for category in categories:
+            category_path = os.path.join(image_folder, category)
+            if not os.path.exists(category_path):
+                print(f"Warning: Category folder not found: {category_path}")
+                continue
+            
+            print(f"\nProcessing category: {category}")
+            print("-" * 40)
+            
+            # Get sample images from category
+            image_files = [f for f in os.listdir(category_path) if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
+            
+            # Process first 3 images from each category
+            sample_images = image_files[:3]
+            
+            category_results = []
+            
+            for image_file in sample_images:
+                image_path = os.path.join(category_path, image_file)
+                print(f"\n  Analyzing: {image_file}")
+                
+                results = self.analyze_image_semantically(image_path, save_results=False)
+                if results:
+                    category_results.append({
+                        'filename': image_file,
+                        'expected_category': category,
+                        'detected_level': results.get('disease_level', 'Unknown'),
+                        'severity': results.get('severity_percentage', 0),
+                        'semantic_diseases': [d['label'] for d in results.get('semantic_info', {}).get('diseases', [])],
+                        'economic_impact': results.get('semantic_info', {}).get('economic_impact', {}).get('label', 'Unknown')
+                    })
+            
+            batch_results[category] = category_results
+        
+        # Save batch results
+        self._save_batch_results(batch_results)
+        
+        # Print summary
+        self._print_batch_summary(batch_results)
+        
+        return batch_results
+    
+    def _save_batch_results(self, batch_results: Dict):
+        """Save batch analysis results"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        json_path = f"batch_semantic_analysis_{timestamp}.json"
+        
+        with open(json_path, 'w') as f:
+            json.dump(batch_results, f, indent=2)
+        
+        print(f"\nBatch results saved: {json_path}")
+    
+    def _print_batch_summary(self, batch_results: Dict):
+        """Print summary of batch analysis"""
+        print(f"\n{'='*80}")
+        print("BATCH SEMANTIC ANALYSIS SUMMARY")
+        print(f"{'='*80}")
+        
+        total_images = 0
+        correct_detections = 0
+        
+        for category, results in batch_results.items():
+            print(f"\n{category.upper()}:")
+            
+            category_correct = 0
+            
+            for result in results:
+                total_images += 1
+                
+                expected = result['expected_category']
+                detected = result['detected_level']
+                semantic_diseases = result['semantic_diseases']
+                
+                # Check if detection is reasonable
+                is_correct = False
+                if expected == "Healthy" and detected == "Healthy":
+                    is_correct = True
+                elif expected != "Healthy" and detected != "Healthy":
+                    is_correct = True
+                
+                if is_correct:
+                    correct_detections += 1
+                    category_correct += 1
+                
+                status = "[CORRECT]" if is_correct else "[INCORRECT]"
+                
+                print(f"   {status} {result['filename']}: {detected} ({result['severity']:.1f}%)")
+                if semantic_diseases:
+                    print(f"      Semantic: {', '.join(semantic_diseases)}")
+                print(f"      Economic: {result['economic_impact']}")
+            
+            accuracy = (category_correct / len(results) * 100) if results else 0
+            print(f"   Category Accuracy: {accuracy:.1f}% ({category_correct}/{len(results)})")
+        
+        overall_accuracy = (correct_detections / total_images * 100) if total_images > 0 else 0
+        print(f"\nOVERALL SEMANTIC DETECTION ACCURACY: {overall_accuracy:.1f}% ({correct_detections}/{total_images})")
+    
+    def query_ontology_knowledge(self):
+        """Demonstrate ontology querying capabilities"""
+        print(f"\n{'='*80}")
+        print("ONTOLOGY KNOWLEDGE QUERIES")
+        print(f"{'='*80}")
+        
+        # Query 1: All diseases and their symptoms
+        print("\nQuery 1: Diseases and their visual symptoms")
+        query1 = """
+        PREFIX disease: <http://spotradar.org/disease#>
+        PREFIX detection: <http://spotradar.org/detection#>
+        PREFIX visual: <http://spotradar.org/visual#>
+        PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+        
+        SELECT ?diseaseLabel ?symptomLabel WHERE {
+            ?disease a disease:Disease .
+            ?disease rdfs:label ?diseaseLabel .
+            ?disease detection:hasSymptom ?symptom .
+            ?symptom rdfs:label ?symptomLabel .
+        }
+        ORDER BY ?diseaseLabel
+        """
+        
+        results1 = self.ontology_manager.query_ontology(query1)
+        for result in results1:
+            print(f"   {result['diseaseLabel']} → {result['symptomLabel']}")
+        
+        # Query 2: Economic impacts
+        print("\nQuery 2: Economic impact levels")
+        query2 = """
+        PREFIX agri: <http://spotradar.org/agriculture#>
+        PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+        
+        SELECT ?impactLabel ?marketability WHERE {
+            ?impact a agri:EconomicImpact .
+            ?impact rdfs:label ?impactLabel .
+            ?impact agri:marketabilityScore ?marketability .
+        }
+        ORDER BY DESC(?marketability)
+        """
+        
+        results2 = self.ontology_manager.query_ontology(query2)
+        for result in results2:
+            print(f"   {result['impactLabel']}: {float(result['marketability']):.0f}% marketability")
+        
+        # Query 3: Severity levels
+        print("\nQuery 3: Disease severity classification")
+        query3 = """
+        PREFIX agri: <http://spotradar.org/agriculture#>
+        PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+        
+        SELECT ?severityLabel WHERE {
+            ?severity a agri:SeverityLevel .
+            ?severity rdfs:label ?severityLabel .
+        }
+        """
+        
+        results3 = self.ontology_manager.query_ontology(query3)
+        for result in results3:
+            print(f"   • {result['severityLabel']}")
+    
+    def get_system_statistics(self):
+        """Get comprehensive system statistics"""
+        stats = self.ontology_manager.get_ontology_statistics()
+        
+        print(f"\n{'='*60}")
+        print("SEMANTIC SYSTEM STATISTICS")
+        print(f"{'='*60}")
+        
+        print(f"Ontology Metrics:")
+        for key, value in stats.items():
+            print(f"   {key.replace('_', ' ').title()}: {value:,}")
+        
+        return stats
+
+def main():
+    """Main demonstration of semantic disease detection"""
+    print("SEMANTIC MANGO DISEASE DETECTION SYSTEM")
+    print("Integrating Computer Vision with OWL-RL Reasoning")
+    
+    # Initialize analyzer
+    analyzer = SemanticDiseaseAnalyzer()
+    
+    # Show system statistics
+    analyzer.get_system_statistics()
+    
+    # Demonstrate ontology querying
+    analyzer.query_ontology_knowledge()
+    
+    # Test single image analysis
+    print(f"\n{'='*80}")
+    print("SINGLE IMAGE SEMANTIC ANALYSIS DEMO")
+    print(f"{'='*80}")
+    
+    # Try different disease types
+    test_images = [
+        "SenMangoFruitDDS_bgremoved/Healthy/healthy_003.jpg",
+        "SenMangoFruitDDS_bgremoved/Alternaria/Alternaria_005.jpg",
+        "SenMangoFruitDDS_bgremoved/Anthracnose/Anthracnose_002.jpg",
+        "SenMangoFruitDDS_bgremoved/Black Mould Rot/Aspergillus_001.jpg",
+        "SenMangoFruitDDS_bgremoved/Stem and Rot/Lasiodiplodia_012.jpg",
+    ]
+    
+    for image_path in test_images:
+        if os.path.exists(image_path):
+            analyzer.analyze_image_semantically(image_path)
+            break  # Just demo one for now
+    
+    # Uncomment for batch analysis
+    # print(f"\n{'='*80}")
+    # print("BATCH SEMANTIC ANALYSIS")
+    # print(f"{'='*80}")
+    # analyzer.batch_semantic_analysis()
+
+if __name__ == "__main__":
+    main()