Update app.py

app.py

@@ -0,0 +1,371 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import torch
+import tensorflow as tf
+import cv2
+import tempfile
+from PIL import Image
+from ultralytics import YOLO
+from transformers import AutoImageProcessor, AutoModelForImageClassification, pipeline
+import matplotlib.pyplot as plt
+import time
+from datetime import datetime
+import os
+import requests
+from torchvision import transforms
+from torchvision.models import mobilenet_v3_large, MobileNet_V3_Large_Weights
+import torch.nn.functional as F
+
+# Load Models
+species_processor = AutoImageProcessor.from_pretrained("microsoft/resnet-50")
+species_model = AutoModelForImageClassification.from_pretrained("microsoft/resnet-50").eval()
+yolo_model = YOLO("yolov8x.pt")
+threat_model = pipeline("image-classification", model="nateraw/vit-base-beans")
+
+# Habitat Analysis Model
+class HabitatAnalyzer:
+    def __init__(self):
+        self.CLASSES = ['vegetation', 'water', 'urban', 'barren']
+    
+    def analyze_vegetation(self, image_array):
+        ndvi = (image_array[:, :, 3] - image_array[:, :, 0]) / (image_array[:, :, 3] + image_array[:, :, 0] + 1e-8)
+        return ndvi
+    
+    def detect_land_changes(self, image1, image2):
+        return cv2.absdiff(image1, image2)
+
+class SpeciesMonitoringSystem:
+    def __init__(self):
+        self.detection_model = mobilenet_v3_large(weights=MobileNet_V3_Large_Weights.DEFAULT)
+        self.detection_model.eval()
+        
+        self.species_classes = [
+            'deer', 'elk', 'moose', 'bear', 'wolf', 'mountain lion', 'bobcat', 
+            'lynx', 'bighorn sheep', 'bison', 'wild boar', 'caribou', 'antelope',
+            'coyote', 'jaguar', 'leopard', 'tiger', 'lion', 'gorilla', 'chimpanzee',
+            'fox', 'raccoon', 'beaver', 'badger', 'otter', 'wolverine', 'porcupine',
+            'skunk', 'opossum', 'armadillo', 'wild cat', 'jackal', 'hyena',
+            'marten', 'fisher', 'weasel', 'mink', 'coati', 'monkey', 'lemur',
+            'rabbit', 'squirrel', 'chipmunk', 'rat', 'mouse', 'vole', 'mole',
+            'shrew', 'bat', 'hedgehog', 'gopher', 'prairie dog', 'muskrat',
+            'hamster', 'guinea pig', 'ferret', 'chinchilla', 'dormouse',
+            'eagle', 'hawk', 'falcon', 'owl', 'vulture', 'condor', 'crow', 'raven',
+            'woodpecker', 'duck', 'goose', 'swan', 'heron', 'crane', 'stork',
+            'pelican', 'flamingo', 'penguin', 'ostrich', 'emu', 'kiwi', 'peacock',
+            'pheasant', 'quail', 'grouse', 'turkey', 'cardinal', 'bluejay',
+            'sparrow', 'finch', 'warbler', 'thrush', 'swallow', 'hummingbird',
+            'snake', 'lizard', 'turtle', 'tortoise', 'alligator', 'crocodile',
+            'iguana', 'gecko', 'monitor lizard', 'chameleon', 'python', 'cobra',
+            'viper', 'rattlesnake', 'boa', 'anaconda', 'skink', 'bearded dragon',
+            'frog', 'toad', 'salamander', 'newt', 'axolotl', 'caecilian',
+            'tree frog', 'bullfrog', 'fire salamander', 'spotted salamander',
+            'salmon', 'trout', 'bass', 'pike', 'catfish', 'carp', 'perch',
+            'tuna', 'swordfish', 'marlin', 'shark', 'ray', 'eel', 'sturgeon',
+            'barracuda', 'grouper', 'snapper', 'cod', 'halibut', 'flounder',
+            'whale', 'dolphin', 'porpoise', 'seal', 'sea lion', 'walrus',
+            'orca', 'narwhal', 'beluga', 'manatee', 'dugong', 'sea otter',
+            'butterfly', 'moth', 'beetle', 'ant', 'bee', 'wasp', 'spider',
+            'scorpion', 'centipede', 'millipede', 'crab', 'lobster', 'shrimp',
+            'octopus', 'squid', 'jellyfish', 'starfish', 'sea urchin', 'coral',
+            'snail', 'slug', 'earthworm', 'leech'
+        ]
+        
+        self.transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                               std=[0.229, 0.224, 0.225])
+        ])
+
+    def detect_species(self, image):
+        img_tensor = self.transform(image).unsqueeze(0)
+        
+        with torch.no_grad():
+            outputs = self.detection_model(img_tensor)
+            probabilities = F.softmax(outputs, dim=1)
+            
+        top_prob, top_class = torch.topk(probabilities, 3)
+        results = []
+        
+        for i in range(3):
+            species = self.species_classes[top_class[0][i] % len(self.species_classes)]
+            confidence = top_prob[0][i].item() * 100
+            results.append((species, confidence))
+            
+        return results
+
+    def count_population(self, image):
+        gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
+        blur = cv2.GaussianBlur(gray, (5, 5), 0)
+        _, thresh = cv2.threshold(blur, 127, 255, cv2.THRESH_BINARY)
+        contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        img_with_contours = np.array(image).copy()
+        cv2.drawContours(img_with_contours, contours, -1, (0, 255, 0), 2)
+        
+        return len(contours), Image.fromarray(img_with_contours)
+
+    def assess_health(self, image):
+        img_array = np.array(image)
+        avg_color = np.mean(img_array, axis=(0, 1))
+        texture_measure = np.std(img_array)
+        color_variation = np.std(avg_color)
+        
+        color_score = np.mean(avg_color) / 255 * 100
+        texture_score = min(100, texture_measure / 2)
+        variation_score = min(100, color_variation * 2)
+        
+        health_score = (color_score * 0.4 + texture_score * 0.3 + variation_score * 0.3)
+        
+        if health_score > 80:
+            status = "Excellent"
+        elif health_score > 60:
+            status = "Good"
+        elif health_score > 40:
+            status = "Fair"
+        else:
+            status = "Poor"
+            
+        indicators = {
+            "Color Vibrancy": color_score,
+            "Texture Complexity": texture_score,
+            "Pattern Variation": variation_score
+        }
+            
+        return status, health_score, indicators
+
+def detect_threat(image, labels):
+    results = threat_model(image)
+    for result in results:
+        if result['label'] in labels and result['score'] > 0.5:
+            return f"{result['label']} Detected with confidence {result['score']:.2f}"
+    return "No Threat Detected"
+
+def detect_land_changes(image1_path, image2_path):
+    image1 = Image.open(image1_path)
+    image2 = Image.open(image2_path)
+    
+    image_array1 = np.array(image1)
+    image_array2 = np.array(image2)
+    
+    if image_array1.shape != image_array2.shape:
+        return "Error: Images must be the same size."
+    
+    changes = cv2.absdiff(image_array1, image_array2)
+    
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.image(image1, caption="Image 1")
+    with col2:
+        st.image(image2, caption="Image 2")
+    with col3:
+        st.image(changes, caption="Changes Detected")
+    
+    change_percent = np.sum(changes > 50) / changes.size * 100
+    st.write(f"Changed Area: {change_percent:.2f}%")
+    
+    return changes
+
+def main():
+    habitat_analyzer = HabitatAnalyzer()
+    
+    st.sidebar.title("Navigation")
+    option = st.sidebar.radio("Select an Analysis Type:",
+                             ["Species Monitoring", "Land Change Detection", "Animal Monitoring", "Threat Detection"])
+
+    if option == "Species Monitoring":
+        st.title("Species Identification")
+        monitoring_system = SpeciesMonitoringSystem()
+    
+        uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
+        
+        if uploaded_file is not None:
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Uploaded Image", use_column_width=True)
+            
+            progress_bar = st.progress(0)
+            
+            with st.spinner("Analyzing image..."):
+                col1, col2, col3 = st.columns(3)
+                
+                progress_bar.progress(30)
+                species_results = monitoring_system.detect_species(image)
+                
+                progress_bar.progress(60)
+                count, marked_image = monitoring_system.count_population(image)
+                
+                progress_bar.progress(90)
+                health_status, health_score, health_indicators = monitoring_system.assess_health(image)
+                
+                with col1:
+                    st.subheader("🔍 Species Detection")
+                    for species, confidence in species_results:
+                        st.write(f"**{species.title()}**")
+                        st.progress(confidence/100)
+                        st.caption(f"Confidence: {confidence:.1f}%")
+                
+                with col2:
+                    st.subheader("👥 Population Count")
+                    st.write(f"**Detected Animals:** {count}")
+                    st.image(marked_image, caption="Detection Visualization", use_column_width=True)
+                
+                with col3:
+                    st.subheader("💪 Health Assessment")
+                    st.write(f"**Status:** {health_status}")
+                    st.write(f"**Overall Score:** {health_score:.1f}/100")
+                    
+                    for indicator, value in health_indicators.items():
+                        st.write(f"**{indicator}:**")
+                        st.progress(value/100)
+                        st.caption(f"{value:.1f}%")
+            
+            progress_bar.progress(100)
+            
+            st.sidebar.markdown("---")
+            st.sidebar.markdown("### Analysis Details")
+            st.sidebar.text(f"Analyzed at: {time.strftime('%Y-%m-%d %H:%M:%S')}")
+            st.sidebar.text(f"Image size: {image.size}")
+            
+            st.markdown("---")
+            st.subheader("📊 Export Results")
+            
+            summary = f"""Wildlife Monitoring Analysis Report
+            Date: {time.strftime('%Y-%m-%d %H:%M:%S')}
+
+            Species Detection Results:
+            {'-' * 30}
+            """
+            for species, confidence in species_results:
+                summary += f"\n{species.title()}: {confidence:.1f}% confidence"
+            
+            summary += f"""\n\nPopulation Count:
+            {'-' * 30}
+            Total detected: {count} individuals
+
+            Health Assessment:
+            {'-' * 30}
+            Status: {health_status}
+            Overall Score: {health_score:.1f}/100
+            """
+            for indicator, value in health_indicators.items():
+                summary += f"\n{indicator}: {value:.1f}%"
+            
+            st.download_button(
+                label="Download Analysis Report",
+                data=summary,
+                file_name="wildlife_analysis_report.txt",
+                mime="text/plain"
+            )
+
+    elif option == "Land Change Detection":
+        st.title("🌍 Land Change Detection")
+        uploaded_file2 = st.file_uploader("Upload first image", type=['tif', 'png', 'jpg'])
+        uploaded_file3 = st.file_uploader("Upload second image", type=['tif', 'png', 'jpg'])
+
+        if uploaded_file2 is not None and uploaded_file3 is not None:
+            detect_land_changes(uploaded_file2, uploaded_file3)
+
+    elif option == "Animal Monitoring":
+        st.title("Animal Monitoring")
+        uploaded_file4 = st.file_uploader("Upload Image/Video", type=["jpg", "jpeg", "png", "mp4"])
+        
+        if uploaded_file4:
+            if uploaded_file4.type.startswith("image"):
+                file_bytes = np.asarray(bytearray(uploaded_file4.read()), dtype=np.uint8)
+                image = cv2.imdecode(file_bytes, 1)
+                
+                if image is None:
+                    st.error("Error loading image. Please upload a valid image file.")
+                else:
+                    results = yolo_model(image)
+                    for result in results:
+                        for box in result.boxes.xyxy:
+                            x1, y1, x2, y2 = map(int, box[:4])
+                            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                            
+                    st.image(image, caption="Detected Animals", channels="BGR")
+                    st.write(f"Estimated Count: {len(results[0].boxes)}")
+            
+            elif uploaded_file4.type.startswith("video"):
+                tfile = tempfile.NamedTemporaryFile(delete=False)
+                tfile.write(uploaded_file4.read())
+                cap = cv2.VideoCapture(tfile.name)
+                
+                if not cap.isOpened():
+                    st.error("Error loading video. Please upload a valid video file.")
+                else:
+                    stframe = st.empty()
+                    st.write("Processing video...")
+                    
+                    while cap.isOpened():
+                        ret, frame = cap.read()
+                        if not ret:
+                            break
+                        
+                        frame = cv2.resize(frame, (640, 480))
+                        results = yolo_model(frame)
+                        
+                        for result in results:
+                            for box in result.boxes.xyxy:
+                                x1, y1, x2, y2 = map(int, box[:4])
+                                cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                        
+                        stframe.image(frame, channels="BGR")
+                        time.sleep(0.03)
+                    
+                    cap.release()
+
+    elif option == "Threat Detection":
+        st.title("Threat Detection and Prevention")
+        st.sidebar.header("Choose Threat Detection")
+        detection_option = st.sidebar.selectbox(
+            "Select an option", 
+            ["Poaching Alerts"]
+        )
+        
+        if detection_option in ["Poaching Alerts"]:
+            uploaded_file7 = st.file_uploader("Upload Image", type=['jpg', 'jpeg', 'png'])
+
+            if uploaded_file7:
+                image = Image.open(uploaded_file7)
+                st.image(image, caption="Uploaded Image", use_column_width=True)
+                
+                if detection_option == "Poaching Alerts":
+                    st.subheader("🎯 Poaching Activity Detection")
+                    
+                    with st.spinner("Analyzing image for potential poaching activities..."):
+                        results = yolo_model(image)
+                        
+                        poaching_objects = ['person', 'gun', 'knife', 'truck', 'car']
+                        detections = {}
+                        
+                        for result in results:
+                            for box in result.boxes:
+                                cls = int(box.cls[0])
+                                conf = float(box.conf[0])
+                                label = result.names[cls]
+                                
+                                if label in poaching_objects and conf > 0.3:
+                                    detections[label] = conf
+                        
+                        if detections:
+                            for obj, conf in detections.items():
+                                st.progress(conf)
+                                st.write(f"{obj.title()}: {conf*100:.1f}% confidence")
+                            
+                            annotated_img = np.array(image)
+                            for result in results:
+                                for box in result.boxes:
+                                    x1, y1, x2, y2 = map(int, box.xyxy[0])
+                                    cv2.rectangle(annotated_img, (x1, y1), (x2, y2), (255, 0, 0), 2)
+                            
+                            st.image(annotated_img, caption="Detected Objects", use_column_width=True)
+                            
+                            if any(conf > 0.7 for conf in detections.values()):
+                                st.error("⚠️ High-risk poaching activity detected! Alert sent to authorities.")
+                        else:
+                            st.success("No suspicious activities detected.")
+
+if __name__ == "__main__":
+    main()