Configure LFS

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text
+*.ipynb filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,54 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+bin/
+build/
+develop-eggs/
+dist/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+.tox/
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Rope
+.ropeproject
+
+# Django stuff:
+*.log
+*.pot
+
+# Sphinx documentation
+docs/_build/
+Share
+
+# mac
+.DS_Store

Backend/BrandRecognition/Dynamic/Brand_Count_Vid.py

@@ -0,0 +1,135 @@
+import cv2
+import numpy as np
+from collections import deque, defaultdict
+from ultralytics import YOLO
+
+
+
+def iou(box1, box2):
+    x1 = max(box1[0], box2[0])
+    y1 = max(box1[1], box2[1])
+    x2 = min(box1[2], box2[2])
+    y2 = min(box1[3], box2[3])
+
+    intersection = max(0, x2 - x1) * max(0, y2 - y1)
+    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
+
+    iou = intersection / float(area1 + area2 - intersection)
+    return iou
+
+def smooth_box(box_history):
+    if not box_history:
+        return None
+    return np.mean(box_history, axis=0)
+
+def process_video(input_path, output_path):
+    model = YOLO('kitkat_s.pt')
+    cap = cv2.VideoCapture(input_path)
+
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+
+    detected_items = {}
+    frame_count = 0
+
+    detections_history = defaultdict(lambda: defaultdict(int))
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        frame_count += 1
+
+        if frame_count % 5 == 0:
+            results = model(frame)
+
+            current_frame_detections = []
+
+            for r in results:
+                boxes = r.boxes
+                for box in boxes:
+                    x1, y1, x2, y2 = box.xyxy[0].tolist()
+                    conf = box.conf.item()
+                    cls = int(box.cls.item())
+                    brand = model.names[cls]
+
+                    current_frame_detections.append((brand, [x1, y1, x2, y2], conf))
+
+            for brand, box, conf in current_frame_detections:
+                matched = False
+                for item_id, item_info in detected_items.items():
+                    if iou(box, item_info['smoothed_box']) > 0.5:
+                        item_info['frames_detected'] += 1
+                        item_info['total_conf'] += conf
+                        item_info['box_history'].append(box)
+                        if len(item_info['box_history']) > 10:
+                            item_info['box_history'].popleft()
+                        item_info['smoothed_box'] = smooth_box(item_info['box_history'])
+                        item_info['last_seen'] = frame_count
+                        matched = True
+                        break
+
+                if not matched:
+                    item_id = len(detected_items)
+                    detected_items[item_id] = {
+                        'brand': brand,
+                        'box_history': deque([box], maxlen=10),
+                        'smoothed_box': box,
+                        'frames_detected': 1,
+                        'total_conf': conf,
+                        'last_seen': frame_count
+                    }
+
+                detections_history[brand][frame_count] += 1
+
+
+        for item_id, item_info in list(detected_items.items()):
+            if frame_count - item_info['last_seen'] > fps * 2:  # 2 seconds
+                del detected_items[item_id]
+                continue
+
+            if item_info['smoothed_box'] is not None:
+                alpha = 0.3
+                current_box = item_info['smoothed_box']
+                target_box = item_info['box_history'][-1] if item_info['box_history'] else current_box
+                interpolated_box = [
+                    current_box[i] * (1 - alpha) + target_box[i] * alpha
+                    for i in range(4)
+                ]
+                item_info['smoothed_box'] = interpolated_box
+
+                x1, y1, x2, y2 = map(int, interpolated_box)
+                cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                cv2.putText(frame, f"{item_info['brand']}",
+                            (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+
+        out.write(frame)
+
+    cap.release()
+    out.release()
+
+    total_frames = frame_count
+    confirmed_items = {}
+    for brand, frame_counts in detections_history.items():
+        detection_frames = len(frame_counts)
+        if detection_frames > total_frames * 0.1:
+            avg_count = sum(frame_counts.values()) / detection_frames
+            confirmed_items[brand] = round(avg_count)
+
+    return confirmed_items
+
+def annotate_video(input_video):
+    output_path = 'annotated_output.mp4'
+    confirmed_items = process_video(input_video, output_path)
+
+    item_list = [(brand, quantity) for brand, quantity in confirmed_items.items()]
+
+    status_message = "Video processed successfully!"
+
+    return output_path, item_list, status_message

Backend/BrandRecognition/Static/Brand_Count_Img.py

@@ -0,0 +1,132 @@
+import cv2
+import numpy as np
+from ultralytics import YOLO
+from Database.mongodb import DatabaseManager
+
+def preprocess_image(image, input_size=(640, 640), augment=False):
+    """
+    Advanced image preprocessing for multi-brand object detection.
+    
+    Args:
+        image (numpy.ndarray): Input image in BGR format.
+        input_size (tuple): Target image dimensions (width, height).
+        augment (bool): Apply data augmentation for training.
+    
+    Returns:
+        numpy.ndarray: Preprocessed image in RGB format.
+    """
+
+    # Convert image to RGB
+    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    # Resize and enhance
+    resized_image = cv2.resize(image_rgb, input_size, interpolation=cv2.INTER_NEAREST)
+    enhanced_image = cv2.convertScaleAbs(resized_image, alpha=1.65, beta=1.75)
+    
+    return enhanced_image
+
+def detect_grocery_items(image, model_path=None, threshold=0.5):
+    
+    """
+    Detect grocery items in an image.
+    
+    Args:
+        image (numpy.ndarray): Input image in BGR format.
+        model_path (str, optional): Path to YOLO model weights.
+        threshold (float, optional): Confidence threshold for detection.
+    
+    Returns:
+        tuple: Annotated image, summary table, and status message
+    """
+    
+    db_manager = DatabaseManager()
+    
+    # Validate image input
+    if image is None or image.size == 0:
+        return None, [], "Invalid image input"
+    
+    # Use default model path if not provided
+    if model_path is None:
+        model_path = 'Weights/kitkat_s.pt'
+    
+    # Load YOLO model
+    try:
+        model = YOLO(model_path)
+    except Exception as e:
+        return None, [], f"Model loading error: {str(e)}"
+    
+    # Preprocess image
+    processed_image = preprocess_image(image)
+    
+    # Detect objects
+    try:
+        results = model(processed_image)
+        
+        # If no results, return early
+        if len(results[0].boxes) == 0:
+            return processed_image, [], "No items detected"
+        
+        # Annotate image
+        annotated_image = results[0].plot()
+        
+        # Process detection results
+        class_ids = results[0].boxes.cls.cpu().numpy()
+        confidences = results[0].boxes.conf.cpu().numpy()
+        
+        # Aggregate results
+        class_counts = {}
+        class_confidences = {}
+
+        # Iterate over detected objects
+        for i, class_id in enumerate(class_ids):
+            
+            # Get class name and confidence
+            confidence = confidences[i]
+            
+            # Filter by confidence threshold
+            if confidence >= threshold:
+                
+                # Get class name
+                class_name = model.names[int(class_id)]
+                class_counts[class_name] = class_counts.get(class_name, 0) + 1
+
+                # Store confidence values
+                if class_name not in class_confidences:
+                    class_confidences[class_name] = []
+                    
+                # Add confidence value
+                class_confidences[class_name].append(confidence)
+        
+        # Create summary table
+        summary_table = [
+            [class_name, count, f"{np.mean(class_confidences[class_name]):.2f}"] 
+            for class_name, count in class_counts.items()
+        ]
+        
+        # Add brand records to the database
+        for brand, count in class_counts.items():
+            db_manager.add_brand_record(brand, count)
+        
+        # Convert back to RGB for display
+        annotated_image_rgb = annotated_image[:, :, ::-1]
+        
+        return annotated_image_rgb, summary_table, "Objects Recognised Successfully 🥳"
+    
+    except Exception as e:
+        return None, [], f"Detection error: {str(e)}"
+
+
+# Optional: Batch processing function
+def batch_detect_grocery_items(images, model_path=None, threshold=0.4):
+    """
+    Detect grocery items in multiple images.
+    
+    Args:
+        images (list): List of input images in BGR format.
+        model_path (str, optional): Path to YOLO model weights.
+        threshold (float, optional): Confidence threshold for detection.
+    
+    Returns:
+        list: List of detection results for each image
+    """
+    return [detect_grocery_items(img, model_path, threshold) for img in images]

Backend/Fruit_Freshness/Apples/Rotten Apple Labeller.v1-rotten-apples.yolov8.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ad993b6a4cda53115519046abf74f9b61cca502ce32a795f97c00e00afaaa50
+size 984758

Backend/Fruit_Freshness/Apples/Rotten Apple Labeller.v1-rotten-apples.yolov8/README.dataset.txt

@@ -0,0 +1,6 @@
+# Rotten Apple Labeller > Rotten Apples
+https://universe.roboflow.com/shyam-krishna/rotten-apple-labeller
+
+Provided by a Roboflow user
+License: CC BY 4.0
+

Backend/Fruit_Freshness/Apples/Rotten Apple Labeller.v1-rotten-apples.yolov8/README.roboflow.txt

@@ -0,0 +1,32 @@
+
+Rotten Apple Labeller - v1 Rotten Apples
+==============================
+
+This dataset was exported via roboflow.com on March 15, 2023 at 6:50 AM GMT
+
+Roboflow is an end-to-end computer vision platform that helps you
+* collaborate with your team on computer vision projects
+* collect & organize images
+* understand and search unstructured image data
+* annotate, and create datasets
+* export, train, and deploy computer vision models
+* use active learning to improve your dataset over time
+
+For state of the art Computer Vision training notebooks you can use with this dataset,
+visit https://github.com/roboflow/notebooks
+
+To find over 100k other datasets and pre-trained models, visit https://universe.roboflow.com
+
+The dataset includes 62 images.
+Rotten-Apples are annotated in YOLOv8 format.
+
+The following pre-processing was applied to each image:
+* Auto-orientation of pixel data (with EXIF-orientation stripping)
+* Resize to 416x416 (Stretch)
+
+The following augmentation was applied to create 3 versions of each source image:
+* 50% probability of horizontal flip
+* 50% probability of vertical flip
+* Equal probability of one of the following 90-degree rotations: none, clockwise, counter-clockwise, upside-down
+
+

Backend/Fruit_Freshness/Apples/Rotten Apple Labeller.v1-rotten-apples.yolov8/data.yaml

@@ -0,0 +1,13 @@
+train: ../train/images
+val: ../valid/images
+test: ../test/images
+
+nc: 1
+names: ['Rotten Apple']
+
+roboflow:
+  workspace: shyam-krishna
+  project: rotten-apple-labeller
+  version: 1
+  license: CC BY 4.0
+  url: https://universe.roboflow.com/shyam-krishna/rotten-apple-labeller/dataset/1

Backend/Fruit_Freshness/Apples/Rotten Apple Labeller.v1-rotten-apples.yolov8/test/labels/Screen-Shot-2018-06-07-at-2-54-49-PM_png.rf.2557a1048acae352cd5420528e467e18.txt

@@ -0,0 +1 @@
+0 0.4795673076923077 0.5108173076923077 0.7235576923076923 0.7836538461538461

Backend/Fruit_Freshness/Apples/Rotten Apple Labeller.v1-rotten-apples.yolov8/test/labels/Screen-Shot-2018-06-07-at-2-57-13-PM_png.rf.e9da17a0710d447581911d0a686a64bb.txt

@@ -0,0 +1 @@
+0 0.5853365384615384 0.5180288461538461 0.7175480769230769 0.7043269230769231

Backend/Fruit_Freshness/Apples/Rotten Apple Labeller.v1-rotten-apples.yolov8/test/labels/Screen-Shot-2018-06-07-at-3-02-24-PM_png.rf.fce9e910b977026e4356db03caaf7835.txt

@@ -0,0 +1 @@
+0 0.49759615384615385 0.4723557692307692 0.8028846153846154 0.8509615384615384

Backend/Fruit_Freshness/Apples/Rotten Apple Labeller.v1-rotten-apples.yolov8/test/labels/Screen-Shot-2018-06-07-at-3-02-51-PM_png.rf.193331860c01427edcafb663e15d5f8c.txt

@@ -0,0 +1 @@
+0 0.49038461538461536 0.4963942307692308 0.7223557692307693 0.7415865384615384