Update src/mango_disease_ontology.py

src/mango_disease_ontology.py

@@ -1,625 +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
+"""
+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 src/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()