Update app.py

app.py

@@ -1,87 +1,84 @@
 import torch
+from transformers import AutoFeatureExtractor, AutoModelForObjectDetection
 import cv2
-from transformers import DetrImageProcessor, DetrForObjectDetection
-import numpy as np
-
-# Load the pre-trained DETR model from Hugging Face for object detection
-model_name = "facebook/detr-resnet-50"
-processor = DetrImageProcessor.from_pretrained(model_name)
-model = DetrForObjectDetection.from_pretrained(model_name)
-
-# Initialize video capture (use 0 for webcam or video file path)
-cap = cv2.VideoCapture('video_feed.mp4')  # Use 0 for webcam
-def detect_people_and_fight(frame):
-    # Convert the frame to RGB (Hugging Face models expect RGB input)
-    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-
-    # Process the image to get the required inputs for the model
-    inputs = processor(images=frame_rgb, return_tensors="pt")
-
-    # Perform inference to detect objects in the image
-    with torch.no_grad():
-        outputs = model(**inputs)
-
-    # Get the predicted labels, boxes, and scores
-    target_sizes = torch.tensor([frame.shape[0:2]])
-    results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.5)[0]
-
-    people_count = 0
-    bounding_boxes = []
-    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-        if label.item() == 0:  # class '0' is the label for "person"
-            people_count += 1
-            x_min, y_min, x_max, y_max = box.tolist()
-            bounding_boxes.append((x_min, y_min, x_max, y_max))
-            # Draw bounding box around detected people
-            cv2.rectangle(frame, (int(x_min), int(y_min)), (int(x_max), int(y_max)), (0, 255, 0), 2)
-
-    # Return the number of people detected and the bounding boxes
-    return people_count, bounding_boxes
-def detect_fight(bounding_boxes, frame):
-    fight_detected = False
-    # Check if there are at least two people
-    if len(bounding_boxes) > 1:
-        for i in range(len(bounding_boxes)):
-            for j in range(i + 1, len(bounding_boxes)):
-                # Calculate distance between the centers of the bounding boxes
-                x1, y1, x2, y2 = bounding_boxes[i]
-                x3, y3, x4, y4 = bounding_boxes[j]
-
-                # Compute center points of bounding boxes
-                center1 = (int((x1 + x2) / 2), int((y1 + y2) / 2))
-                center2 = (int((x3 + x4) / 2), int((y3 + y4) / 2))
-
-                # Calculate Euclidean distance between the two centers
-                dist = np.sqrt((center1[0] - center2[0]) ** 2 + (center1[1] - center2[1]) ** 2)
-
-                # If people are too close to each other (e.g., less than 50 pixels), we assume a potential fight
-                if dist < 50:  # Threshold distance can be adjusted
-                    fight_detected = True
-                    cv2.line(frame, center1, center2, (0, 0, 255), 2)  # Draw a line between the two people
-
-    return fight_detected
-while True:
-    ret, frame = cap.read()
-    if not ret:
-        break
-
-    # Detect people in the frame
-    people_count, bounding_boxes = detect_people_and_fight(frame)
-
-    # Check for fight (if multiple people are very close to each other)
-    fight_detected = detect_fight(bounding_boxes, frame)
-
-    # Display results on the frame
-    cv2.putText(frame, f"People detected: {people_count}", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
-    if fight_detected:
-        cv2.putText(frame, "Fight Detected!", (50, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
-
-    # Show the resulting frame
-    cv2.imshow("Crowd and Fight Detection", frame)
-
-    # Exit the loop when 'q' is pressed
-    if cv2.waitKey(1) & 0xFF == ord('q'):
-        break
-
-cap.release()
-cv2.destroyAllWindows()
+import pandas as pd
+import smtplib
+from datetime import datetime, timedelta
+
+# Load pre-trained model
+model_name = "hustvl/yolos-small"
+feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
+model = AutoModelForObjectDetection.from_pretrained(model_name)
+
+def detect_number_plates(image):
+    # Pre-process image
+    inputs = feature_extractor(images=image, return_tensors="pt")
+    
+    # Run object detection
+    outputs = model(**inputs)
+    
+    # Extract detected number plates
+    number_plates = []
+    for i, detection in enumerate(outputs):
+        for j, score in enumerate(detection["scores"]):
+            if score > 0.5 and detection["labels"][j] == 7:  # 7 is the class ID for number plates
+                x1, y1, x2, y2 = detection["boxes"][j]
+                number_plates.append((x1, y1, x2, y2))
+    
+    return number_plates
+
+    def save_to_excel(number_plates):
+    # Create a pandas DataFrame
+    df = pd.DataFrame({
+        "Date": [datetime.now().strftime("%Y-%m-%d %H:%M:%S") for _ in range(len(number_plates))],
+        "Number Plate": [f"{x1}, {y1}, {x2}, {y2}" for x1, y1, x2, y2 in number_plates]
+    })
+    
+    # Append to existing Excel file or create a new one
+    try:
+        existing_df = pd.read_excel("number_plates.xlsx")
+        combined_df = pd.concat([existing_df, df])
+        combined_df.to_excel("number_plates.xlsx", index=False)
+    except FileNotFoundError:
+        df.to_excel("number_plates.xlsx", index=False)
+
+        def monitor_vehicles(number_plates):
+    # Load registered number plates from a file or database
+    registered_plates = pd.read_csv("registered_plates.csv")["Number Plate"].tolist()
+    
+    # Check each detected number plate
+    for x1, y1, x2, y2 in number_plates:
+        number_plate = f"{x1}, {y1}, {x2}, {y2}"
+        if number_plate not in registered_plates:
+            # Check if the vehicle has been present for more than 24 hours
+            try:
+                existing_df = pd.read_excel("number_plates.xlsx")
+                vehicle_entries = existing_df[existing_df["Number Plate"] == number_plate]
+                if len(vehicle_entries) > 0 and (datetime.now() - vehicle_entries.iloc[-1]["Date"]).total_seconds() > 86400:
+                    # Send an alert email
+                    send_alert_email(number_plate)
+            except FileNotFoundError:
+                pass
+
+
+                def send_alert_email(number_plate):
+    # Set up email server
+    server = smtplib.SMTP("smtp.gmail.com", 587)
+    server.starttls()
+    server.login("your_email@gmail.com", "your_password")
+    
+    # Send email
+    subject = "Unregistered Vehicle Alert"
+    body = f"Unregistered vehicle with number plate {number_plate} has been present for more than 24 hours."
+    message = f"Subject: {subject}\n\n{body}"
+    server.sendmail("your_email@gmail.com", "recipient_email@gmail.com", message)
+    server.quit()
+
+    def main(image_path):
+    image = cv2.imread(image_path)
+    number_plates = detect_number_plates(image)
+    save_to_excel(number_plates)
+    monitor_vehicles(number_plates)
+
+# Example usage
+main("/Users/majjikarthikreddy/Downloads/WhatsApp Image 2025-04-10 at 10.29.25.jpeg")