Init

.gitignore

@@ -0,0 +1 @@
+/imgrecAaron

PC_CONFIG.py

@@ -0,0 +1,26 @@
+import os
+
+# Base directory for your project (automatically set to the script's directory)
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Configuration for Flask
+HOST = '0.0.0.0'  # or '0.0.0.0' for external access
+IMAGE_REC_PORT = 4000  # Port number for your Flask app
+
+# File directory paths
+FILE_DIRECTORY = os.path.join(BASE_DIR, 'data')  # Adjust according to your structure
+
+# Directories for image processing
+UPLOAD_FOLDER = os.path.join(FILE_DIRECTORY, 'image-rec', 'images')
+ANNOTATED_IMAGES = os.path.join(FILE_DIRECTORY, 'image-rec', 'annotated_images')
+ANNOTATED_ARCHIVE = os.path.join(FILE_DIRECTORY, 'image-rec', 'annotated_archive')
+STITCHED_IMAGES = os.path.join(FILE_DIRECTORY, 'image-rec', 'stitched_images')
+SAMPLE_IMAGES = os.path.join(FILE_DIRECTORY, 'image-rec', 'sample_images')
+
+if __name__ == '__main__':
+    # Ensure all necessary directories exist
+    os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+    os.makedirs(ANNOTATED_IMAGES, exist_ok=True)
+    os.makedirs(ANNOTATED_ARCHIVE, exist_ok=True)
+    os.makedirs(STITCHED_IMAGES, exist_ok=True)
+    os.makedirs(SAMPLE_IMAGES, exist_ok=True)

app.py

@@ -0,0 +1,722 @@
+from flask import Flask, request, jsonify, render_template_string, send_from_directory, send_file
+from flask_cors import CORS
+import os
+import importlib.util
+import time
+import zipfile
+import shutil
+import json
+from datetime import datetime
+from predict_task1 import Predictor
+from id_mapping import mapping
+from show_stitched import *
+import cv2
+import supervision as sv
+from ultralytics import YOLO
+
+app = Flask(__name__)
+CORS(app)
+
+# Load configuration
+config_dir = os.path.abspath(os.path.dirname(__file__))
+config_path = os.path.join(config_dir, 'PC_CONFIG.py')
+spec = importlib.util.spec_from_file_location("PC_CONFIG", config_path)
+PC_CONFIG = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(PC_CONFIG)
+
+HOST = PC_CONFIG.HOST
+PORT = PC_CONFIG.IMAGE_REC_PORT
+UPLOAD_FOLDER = os.path.join(PC_CONFIG.FILE_DIRECTORY, "image-rec", "images")
+DATASET_FOLDER = os.path.join(PC_CONFIG.BASE_DIR, "yolo_dataset")
+ANNOTATED_FOLDER = os.path.join(DATASET_FOLDER, "annotated_images")
+LABELS_FOLDER = os.path.join(DATASET_FOLDER, "labels")
+IMAGES_FOLDER = os.path.join(DATASET_FOLDER, "images")
+CLASS_MAPPING_FILE = os.path.join(DATASET_FOLDER, "classes.json")
+
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+# Initialize predictor
+predictor = Predictor()
+
+# Ensure directories exist
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(DATASET_FOLDER, exist_ok=True)
+os.makedirs(ANNOTATED_FOLDER, exist_ok=True)
+os.makedirs(LABELS_FOLDER, exist_ok=True)
+os.makedirs(IMAGES_FOLDER, exist_ok=True)
+
+# Initialize class mapping file
+if not os.path.exists(CLASS_MAPPING_FILE):
+    # Create initial class mapping from id_mapping.py
+    reverse_mapping = {str(v): k for k, v in mapping.items() if v != -1 and k is not None}
+    with open(CLASS_MAPPING_FILE, 'w', encoding='utf-8') as f:
+        json.dump(reverse_mapping, f, indent=2, ensure_ascii=False)
+
+def load_class_mapping():
+    """Load class mapping from JSON file"""
+    try:
+        with open(CLASS_MAPPING_FILE, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except:
+        return {}
+
+def save_class_mapping(class_mapping):
+    """Save class mapping to JSON file"""
+    with open(CLASS_MAPPING_FILE, 'w', encoding='utf-8') as f:
+        json.dump(class_mapping, f, indent=2, ensure_ascii=False)
+
+def generate_yolo_annotation(results, detection_id, image_width, image_height, class_name):
+    """Generate YOLO format annotation string"""
+    if not results or detection_id >= len(results[0].boxes):
+        return ""
+    
+    # Get class mapping
+    class_mapping = load_class_mapping()
+    
+    # Get class ID from mapping, if not found, add it
+    class_id = None
+    for id_str, name in class_mapping.items():
+        if name == class_name:
+            class_id = int(id_str)
+            break
+    
+    if class_id is None:
+        # Add new class to mapping
+        max_id = max([int(k) for k in class_mapping.keys()]) if class_mapping else -1
+        class_id = max_id + 1
+        class_mapping[str(class_id)] = class_name
+        save_class_mapping(class_mapping)
+    
+    # Get bounding box
+    box = results[0].boxes.xyxy[detection_id]
+    x1, y1, x2, y2 = box.tolist()
+    
+    # Convert to YOLO format (normalized)
+    x_center = ((x1 + x2) / 2) / image_width
+    y_center = ((y1 + y2) / 2) / image_height
+    width = (x2 - x1) / image_width
+    height = (y2 - y1) / image_height
+    
+    confidence = results[0].boxes.conf[detection_id].item()
+    
+    # YOLO format: class_id x_center y_center width height confidence
+    return f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f} {confidence:.6f}"
+
+def save_annotated_image(image, results, detection_id, filename):
+    """Save annotated image with bounding boxes"""
+    if not results or not results[0].boxes:
+        return None
+    
+    # Create supervision annotators
+    bounding_box_annotator = sv.BoundingBoxAnnotator()
+    label_annotator = sv.LabelAnnotator()
+    
+    # Convert YOLOv8 results to supervision format
+    boxes = results[0].boxes.xyxy.cpu().numpy()
+    confidences = results[0].boxes.conf.cpu().numpy()
+    class_ids = results[0].boxes.cls.cpu().numpy().astype(int)
+    
+    # Get class names
+    class_names = [results[0].names[class_id] for class_id in class_ids]
+    
+    # Create detections
+    detections = sv.Detections(
+        xyxy=boxes,
+        confidence=confidences,
+        class_id=class_ids
+    )
+    
+    # Annotate image
+    annotated_image = bounding_box_annotator.annotate(scene=image.copy(), detections=detections)
+    annotated_image = label_annotator.annotate(
+        scene=annotated_image, 
+        detections=detections,
+        labels=[f"{class_names[i]} {confidences[i]:.2f}" for i in range(len(class_names))]
+    )
+    
+    # Save annotated image
+    annotated_path = os.path.join(ANNOTATED_FOLDER, f"annotated_{filename}")
+    cv2.imwrite(annotated_path, annotated_image)
+    
+    return annotated_path
+
+def process_file(file_path, direction, task_type):
+    """Process uploaded file and generate predictions"""
+    print("File received and saved successfully.")
+    print(f"Direction received: {direction}")
+    print(f"Task type received: {task_type}")
+
+    startTime = datetime.now()
+    
+    # Load image
+    image = cv2.imread(file_path)
+    if image is None:
+        return None
+    
+    # Perform prediction
+    class_name, results, detection_id = predictor.predict_id(file_path, task_type)
+    class_id = str(mapping.get(class_name, -1))
+    
+    if class_name and results:
+        # Generate filename
+        timestamp = int(time.time())
+        base_filename = f"{class_name}_{timestamp}"
+        
+        # Save original image to dataset
+        image_filename = f"{base_filename}.jpg"
+        dataset_image_path = os.path.join(IMAGES_FOLDER, image_filename)
+        shutil.copy2(file_path, dataset_image_path)
+        
+        # Generate and save YOLO annotation
+        h, w = image.shape[:2]
+        yolo_annotation = generate_yolo_annotation(results, detection_id, w, h, class_name)
+        if yolo_annotation:
+            txt_filename = f"{base_filename}.txt"
+            txt_path = os.path.join(LABELS_FOLDER, txt_filename)
+            with open(txt_path, 'w') as f:
+                f.write(yolo_annotation)
+        
+        # Save annotated image
+        save_annotated_image(image, results, detection_id, image_filename)
+    
+    endTime = datetime.now()
+    totalTime = (endTime - startTime).total_seconds()
+    print(f"Predicted ID: {class_id}")
+    print(f"Time taken for Predicting Image = {totalTime} s")
+    
+    return class_id
+
+# HTML template for the frontend
+HTML_TEMPLATE = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>YOLO Image Recognition System</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+            background-color: #f5f5f5;
+        }
+        .header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        .container {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+        .card {
+            background-color: white;
+            padding: 20px;
+            border-radius: 10px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+        }
+        .image-display {
+            text-align: center;
+        }
+        .image-display img {
+            max-width: 100%;
+            max-height: 400px;
+            border: 2px solid #ddd;
+            border-radius: 8px;
+        }
+        .status {
+            padding: 10px;
+            border-radius: 5px;
+            margin-bottom: 15px;
+            font-weight: bold;
+        }
+        .status.waiting {
+            background-color: #fff3cd;
+            color: #856404;
+        }
+        .status.updated {
+            background-color: #d4edda;
+            color: #155724;
+        }
+        .upload-section {
+            text-align: center;
+        }
+        .upload-form {
+            display: inline-block;
+            text-align: left;
+        }
+        .form-group {
+            margin-bottom: 15px;
+        }
+        .form-group label {
+            display: block;
+            margin-bottom: 5px;
+            font-weight: bold;
+        }
+        .form-group input, .form-group select {
+            width: 300px;
+            padding: 8px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+        }
+        .btn {
+            background-color: #007bff;
+            color: white;
+            border: none;
+            padding: 12px 24px;
+            border-radius: 5px;
+            font-size: 16px;
+            cursor: pointer;
+            transition: background-color 0.3s;
+        }
+        .btn:hover {
+            background-color: #0056b3;
+        }
+        .btn:disabled {
+            background-color: #6c757d;
+            cursor: not-allowed;
+        }
+        .dataset-info {
+            grid-column: span 2;
+        }
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin-top: 15px;
+        }
+        .stat-card {
+            background-color: #f8f9fa;
+            padding: 15px;
+            border-radius: 5px;
+            text-align: center;
+        }
+        .stat-number {
+            font-size: 24px;
+            font-weight: bold;
+            color: #007bff;
+        }
+        .timestamp {
+            color: #666;
+            font-size: 12px;
+            margin-top: 10px;
+        }
+        .class-mapping {
+            max-height: 200px;
+            overflow-y: auto;
+            background-color: #f8f9fa;
+            padding: 10px;
+            border-radius: 5px;
+            font-family: monospace;
+            font-size: 12px;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>YOLO Image Recognition System</h1>
+        <p>Real-time image processing with dataset management</p>
+    </div>
+
+    <div class="container">
+        <div class="card">
+            <h3>Latest Recognition Result</h3>
+            <div id="status" class="status waiting">Waiting for recognition results...</div>
+            <div class="image-display">
+                <div id="result" style="display: none;">
+                    <img id="resultImage" />
+                    <div id="timestamp" class="timestamp"></div>
+                </div>
+                <div id="noResult" style="color: #666; padding: 40px;">
+                    No recognition results yet
+                </div>
+            </div>
+        </div>
+
+        <div class="card">
+            <h3>Upload Image for Recognition</h3>
+            <div class="upload-section">
+                <form id="uploadForm" class="upload-form" enctype="multipart/form-data">
+                    <div class="form-group">
+                        <label for="file">Select Image:</label>
+                        <input type="file" id="file" name="file" accept="image/*" required>
+                    </div>
+                    <div class="form-group">
+                        <label for="direction">Direction:</label>
+                        <select id="direction" name="direction" required>
+                            <option value="north">North</option>
+                            <option value="south">South</option>
+                            <option value="east">East</option>
+                            <option value="west">West</option>
+                        </select>
+                    </div>
+                    <div class="form-group">
+                        <label for="task_type">Task Type:</label>
+                        <select id="task_type" name="task_type" required>
+                            <option value="TASK_1">Task 1</option>
+                            <option value="TASK_2">Task 2</option>
+                        </select>
+                    </div>
+                    <button type="submit" class="btn">Upload and Predict</button>
+                </form>
+                <div id="uploadResult" style="margin-top: 15px;"></div>
+            </div>
+        </div>
+
+        <div class="card dataset-info">
+            <h3>Dataset Information</h3>
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <div class="stat-number" id="totalImages">0</div>
+                    <div>Total Images</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-number" id="totalClasses">0</div>
+                    <div>Total Classes</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-number" id="annotatedImages">0</div>
+                    <div>Annotated Images</div>
+                </div>
+                <div class="stat-card">
+                    <button id="downloadBtn" class="btn" onclick="downloadDataset()">
+                        Download Dataset
+                    </button>
+                </div>
+            </div>
+            <div style="margin-top: 20px;">
+                <h4>Class Mapping:</h4>
+                <div id="classMapping" class="class-mapping">Loading...</div>
+            </div>
+            <div id="downloadInfo" style="margin-top: 10px; color: #666;"></div>
+        </div>
+    </div>
+
+    <script>
+        let lastImagePath = '';
+        
+        // Check for latest results
+        async function checkLatestResult() {
+            try {
+                const response = await fetch('/latest-result');
+                const data = await response.json();
+                
+                if (data.success && data.image_path) {
+                    const newImagePath = data.image_path;
+                    
+                    if (newImagePath !== lastImagePath) {
+                        lastImagePath = newImagePath;
+                        
+                        const resultDiv = document.getElementById('result');
+                        const noResultDiv = document.getElementById('noResult');
+                        const resultImg = document.getElementById('resultImage');
+                        const timestampDiv = document.getElementById('timestamp');
+                        const statusDiv = document.getElementById('status');
+                        
+                        // Update image and timestamp
+                        resultImg.src = '/annotated/' + newImagePath + '?t=' + new Date().getTime();
+                        timestampDiv.textContent = 'Last updated: ' + new Date().toLocaleString();
+                        
+                        // Show result
+                        noResultDiv.style.display = 'none';
+                        resultDiv.style.display = 'block';
+                        
+                        // Update status
+                        statusDiv.className = 'status updated';
+                        statusDiv.textContent = 'New recognition result available';
+                        
+                        setTimeout(() => {
+                            statusDiv.className = 'status waiting';
+                            statusDiv.textContent = 'Waiting for next result...';
+                        }, 3000);
+                    }
+                }
+            } catch (error) {
+                console.error('Failed to check latest result:', error);
+            }
+        }
+        
+        // Update dataset statistics
+        async function updateDatasetStats() {
+            try {
+                const response = await fetch('/dataset-stats');
+                const data = await response.json();
+                
+                document.getElementById('totalImages').textContent = data.total_images || 0;
+                document.getElementById('totalClasses').textContent = data.total_classes || 0;
+                document.getElementById('annotatedImages').textContent = data.annotated_images || 0;
+                
+                // Update class mapping
+                const mappingDiv = document.getElementById('classMapping');
+                if (data.class_mapping) {
+                    let mappingText = '';
+                    for (const [id, name] of Object.entries(data.class_mapping)) {
+                        mappingText += `${id}: ${name}\\n`;
+                    }
+                    mappingDiv.textContent = mappingText || 'No classes defined yet';
+                } else {
+                    mappingDiv.textContent = 'No classes defined yet';
+                }
+            } catch (error) {
+                console.error('Failed to update dataset stats:', error);
+            }
+        }
+        
+        // Handle file upload
+        document.getElementById('uploadForm').addEventListener('submit', async function(e) {
+            e.preventDefault();
+            
+            const formData = new FormData(this);
+            const uploadResult = document.getElementById('uploadResult');
+            const submitBtn = this.querySelector('button[type="submit"]');
+            
+            submitBtn.disabled = true;
+            submitBtn.textContent = 'Processing...';
+            uploadResult.innerHTML = '<div style="color: #007bff;">Processing image...</div>';
+            
+            try {
+                const response = await fetch('/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                const result = await response.json();
+                
+                if (response.ok) {
+                    uploadResult.innerHTML = `
+                        <div style="color: #28a745;">
+                            <strong>Success!</strong><br>
+                            Predicted ID: ${result.predicted_id}
+                        </div>
+                    `;
+                    // Refresh dataset stats
+                    updateDatasetStats();
+                } else {
+                    uploadResult.innerHTML = `<div style="color: #dc3545;">Error: ${result.error}</div>`;
+                }
+            } catch (error) {
+                uploadResult.innerHTML = `<div style="color: #dc3545;">Error: ${error.message}</div>`;
+            } finally {
+                submitBtn.disabled = false;
+                submitBtn.textContent = 'Upload and Predict';
+            }
+        });
+        
+        // Download dataset
+        async function downloadDataset() {
+            const downloadBtn = document.getElementById('downloadBtn');
+            const downloadInfo = document.getElementById('downloadInfo');
+            
+            try {
+                downloadBtn.disabled = true;
+                downloadBtn.textContent = 'Preparing...';
+                downloadInfo.textContent = 'Creating ZIP file, please wait...';
+                downloadInfo.style.color = '#007bff';
+                
+                const response = await fetch('/download-dataset');
+                
+                if (response.ok) {
+                    const blob = await response.blob();
+                    const url = window.URL.createObjectURL(blob);
+                    const a = document.createElement('a');
+                    a.href = url;
+                    a.download = `yolo_dataset_${new Date().toISOString().slice(0,10)}.zip`;
+                    document.body.appendChild(a);
+                    a.click();
+                    window.URL.revokeObjectURL(url);
+                    document.body.removeChild(a);
+                    
+                    downloadInfo.textContent = 'Dataset downloaded successfully!';
+                    downloadInfo.style.color = '#28a745';
+                } else {
+                    const errorData = await response.json();
+                    downloadInfo.textContent = 'Error: ' + (errorData.message || 'Failed to download');
+                    downloadInfo.style.color = '#dc3545';
+                }
+            } catch (error) {
+                downloadInfo.textContent = 'Error: ' + error.message;
+                downloadInfo.style.color = '#dc3545';
+            } finally {
+                downloadBtn.disabled = false;
+                downloadBtn.textContent = 'Download Dataset';
+                setTimeout(() => { downloadInfo.textContent = ''; }, 5000);
+            }
+        }
+        
+        // Initialize
+        checkLatestResult();
+        updateDatasetStats();
+        
+        // Auto-refresh every 3 seconds
+        setInterval(checkLatestResult, 3000);
+        setInterval(updateDatasetStats, 10000);
+    </script>
+</body>
+</html>
+"""
+
+# Routes
+@app.route('/')
+def index():
+    """Home page with web interface"""
+    return render_template_string(HTML_TEMPLATE)
+
+@app.route('/status', methods=['GET'])
+def server_status():
+    """Health check endpoint"""
+    return jsonify({'status': 'OK'})
+
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    """Handle file upload and prediction"""
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file part'}), 400
+    
+    file = request.files['file']
+    direction = request.form.get('direction', 'north')
+    task_type = request.form.get('task_type', 'TASK_1')
+    
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'}), 400
+    
+    if file:
+        filename = os.path.basename(file.filename)
+        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(file_path)
+        
+        # Process the file and predict
+        class_id = process_file(file_path, direction, task_type)
+        
+        if class_id is not None:
+            return jsonify({
+                'message': 'File successfully uploaded and processed',
+                'predicted_id': class_id,
+                'direction': direction,
+                'task_type': task_type
+            }), 200
+        else:
+            return jsonify({'error': 'Failed to process image'}), 500
+
+@app.route('/latest-result')
+def get_latest_result():
+    """Get the latest annotated image"""
+    if not os.path.exists(ANNOTATED_FOLDER):
+        return jsonify({"success": False, "message": "Annotated folder not found"})
+    
+    # Get all annotated images
+    annotated_files = []
+    for filename in os.listdir(ANNOTATED_FOLDER):
+        if filename.startswith('annotated_') and filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+            filepath = os.path.join(ANNOTATED_FOLDER, filename)
+            mtime = os.path.getmtime(filepath)
+            annotated_files.append((filename, mtime))
+    
+    if not annotated_files:
+        return jsonify({"success": False, "message": "No annotated images found"})
+    
+    # Sort by modification time, get latest
+    annotated_files.sort(key=lambda x: x[1], reverse=True)
+    latest_file = annotated_files[0][0]
+    
+    return jsonify({
+        "success": True,
+        "image_path": latest_file,
+        "timestamp": annotated_files[0][1]
+    })
+
+@app.route('/annotated/<filename>')
+def serve_annotated_image(filename):
+    """Serve annotated images"""
+    return send_from_directory(ANNOTATED_FOLDER, filename)
+
+@app.route('/dataset-stats')
+def get_dataset_stats():
+    """Get dataset statistics"""
+    stats = {
+        'total_images': 0,
+        'total_classes': 0,
+        'annotated_images': 0,
+        'class_mapping': {}
+    }
+    
+    # Count images
+    if os.path.exists(IMAGES_FOLDER):
+        stats['total_images'] = len([f for f in os.listdir(IMAGES_FOLDER) if f.lower().endswith(('.png', '.jpg', '.jpeg'))])
+    
+    # Count annotated images
+    if os.path.exists(ANNOTATED_FOLDER):
+        stats['annotated_images'] = len([f for f in os.listdir(ANNOTATED_FOLDER) if f.lower().endswith(('.png', '.jpg', '.jpeg'))])
+    
+    # Load class mapping
+    stats['class_mapping'] = load_class_mapping()
+    stats['total_classes'] = len(stats['class_mapping'])
+    
+    return jsonify(stats)
+
+@app.route('/download-dataset')
+def download_dataset():
+    """Download the complete YOLO dataset as ZIP"""
+    if not os.path.exists(DATASET_FOLDER):
+        return jsonify({"success": False, "message": "Dataset folder not found"}), 404
+    
+    # Check if there are files to download
+    has_files = False
+    for folder in [IMAGES_FOLDER, LABELS_FOLDER, ANNOTATED_FOLDER]:
+        if os.path.exists(folder) and os.listdir(folder):
+            has_files = True
+            break
+    
+    if not has_files:
+        return jsonify({"success": False, "message": "No files found in dataset"}), 404
+    
+    # Create timestamp for filename
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    zip_filename = f"yolo_dataset_{timestamp}.zip"
+    zip_path = os.path.join(UPLOAD_FOLDER, zip_filename)
+    
+    try:
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            # Add all files from dataset structure
+            for root, dirs, files in os.walk(DATASET_FOLDER):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, DATASET_FOLDER)
+                    zipf.write(file_path, arcname)
+        
+        return send_file(zip_path, as_attachment=True, download_name=zip_filename)
+    
+    except Exception as e:
+        return jsonify({"success": False, "message": f"Error creating zip: {str(e)}"}), 500
+    
+    finally:
+        # Clean up temporary file
+        try:
+            if os.path.exists(zip_path):
+                os.remove(zip_path)
+        except:
+            pass
+
+@app.route('/display_stitched', methods=['POST'])
+def display_stitched():
+    """Display stitched images"""
+    try:
+        showAnnotatedStitched()
+        return jsonify({'display_stitched': 'OK'})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    print()
+    print(f"UPLOAD FOLDER: {UPLOAD_FOLDER}")
+    print(f"DATASET FOLDER: {DATASET_FOLDER}")
+    print(f"Starting Enhanced Image Recognition Server...")
+    print(f"Web interface available at: http://{HOST}:{PORT}")
+    
+    try:
+        app.run(host=HOST, port=PORT, debug=False)
+    except:
+        print('Unable to connect to configured host and port. Switching to localhost:4000.')
+        app.run(host='0.0.0.0', port=4000, debug=True)

http_client_ir.py

@@ -0,0 +1,48 @@
+import requests
+import PC_CONFIG
+
+class ImageRecognitionClient:
+    def __init__(self, host, port):
+        self.server_url = f"http://{host}:{port}"
+
+    def check_status(self):
+        """Check the status of the server."""
+        response = requests.get(f"{self.server_url}/status")
+        if response.status_code == 200:
+            return response.json()
+        else:
+            print(f"Error checking status: {response.status_code}")
+            return None
+
+    def send_file(self, file_path, direction, task_type):
+        with open(file_path, 'rb') as f:
+            files = {'file': f}
+            data = {'direction': direction, 'task_type': task_type}
+            response = requests.post(f"{self.server_url}/upload", files=files, data=data)
+            if response.status_code == 200:
+                print("File sent to the server successfully.")
+                print(response.json())
+                return response.json()
+            else:
+                print("Failed to send file to the server.")
+                print(response.text)
+                return None   
+        
+    def display_stitched(self):
+        response = requests.post(f"{self.server_url}/display_stitched")
+        if response.status_code == 200:
+            print("Stitched request sent to the server successfully.")
+            print(response.json())
+            return response.json()
+        else:
+            print("Failed to send stitched request to the server.")
+            print(response.text)
+            return None   
+
+if __name__ == "__main__":
+    host = '192.168.100.199'
+    port = '4000'
+    client = ImageRecognitionClient(host, port)
+    #client.check_status()
+    client.send_file('/Users/xot/Documents/UniversityWork/Y4S1/MDP/ImgRecAaron/data/image-rec/sample_images/IMG_9606.jpg', 'north', 'TASK_1')  # Adjust the file path and direction as needed
+    #client.display_stitched()

http_server_ir_task1.py

@@ -0,0 +1,91 @@
+from flask import Flask, request, jsonify
+import os
+import importlib.util
+from datetime import datetime
+from predict_task1 import Predictor
+from id_mapping import mapping
+#from show_annotation import start_annotation_process
+#from multiprocessing import Process, Queue
+#import cv2
+from show_stitched import *
+
+app = Flask(__name__)
+
+config_dir = os.path.abspath(os.path.dirname(__file__))
+config_path = os.path.join(config_dir, 'PC_CONFIG.py')
+spec = importlib.util.spec_from_file_location("PC_CONFIG", config_path)
+PC_CONFIG = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(PC_CONFIG)
+
+HOST = PC_CONFIG.HOST
+PORT = PC_CONFIG.IMAGE_REC_PORT
+UPLOAD_FOLDER =  os.path.join(PC_CONFIG.FILE_DIRECTORY,"image-rec","images")
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+def process_file(file_path, direction, task_type):
+    predictor = Predictor()
+    print("File received and saved successfully.")
+    print(f"Direction received: {direction}")
+    print(f"Task type received: {task_type}")
+
+    startTime = datetime.now()
+    class_name, results, detection_id = predictor.predict_id(file_path, task_type)  # Perform prediction
+    #show_annotation_queue.put((file_path, results, detection_id))
+    class_id = str(mapping.get(class_name, -1))
+    endTime = datetime.now()
+    totalTime = (endTime - startTime).total_seconds()
+    print(f"Predicted ID: {class_id}")
+    print(f"Time taken for Predicting Image = {totalTime} s")
+    return class_id
+
+@app.route('/status', methods=['GET'])
+def server_status():
+    return jsonify({'status': 'OK'})
+
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file part'}), 400
+    file = request.files['file']
+    direction = request.form['direction']
+    task_type = request.form['task_type']
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'}), 400
+    if file:
+        filename = os.path.basename(file.filename)
+        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(file_path)
+        # image = cv2.imread(file_path)
+        # cv2.imshow("Uploaded Image", image)
+        # cv2.waitKey(0)  # Wait until a key is pressed
+        # cv2.destroyAllWindows()  # Close the window
+
+        # Process the file and predict
+        class_id = process_file(file_path, direction, task_type)
+        return jsonify({'message': 'File successfully uploaded', 'predicted_id': class_id}), 200
+
+@app.route('/display_stitched', methods=['POST'])
+def display_stitched():
+    showAnnotatedStitched()
+    return jsonify({'display_stitched': 'OK'})
+
+if __name__ == '__main__':
+    # show_annotation_queue = Queue()
+    # process = Process(target=start_annotation_process, args=(show_annotation_queue,))
+    # process.start()
+
+    print()
+    print(f"UPLOAD FOLDER: {UPLOAD_FOLDER}")
+    # Port 5000 if free
+    '''
+    try:
+        app.run(host=HOST, port=PORT, debug=False)
+    except:
+        print('Unable to Connect to PC_CONFIG Host and Port. Switching to 0.0.0.0:4000.')
+        app.run(host='0.0.0.0', port=4000, debug=True)
+    '''
+
+    # Run on Port 4000
+    app.run(host='0.0.0.0', port=4000, debug=True)
+
+    #process.join()

http_server_ir_task2.py

@@ -0,0 +1,91 @@
+from flask import Flask, request, jsonify
+import os
+import importlib.util
+from datetime import datetime
+from predict_task2 import Predictor
+from id_mapping import mapping
+#from show_annotation import start_annotation_process
+#from multiprocessing import Process, Queue
+#import cv2
+from show_stitched import *
+
+app = Flask(__name__)
+
+config_dir = os.path.abspath(os.path.dirname(__file__))
+config_path = os.path.join(config_dir, 'PC_CONFIG.py')
+spec = importlib.util.spec_from_file_location("PC_CONFIG", config_path)
+PC_CONFIG = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(PC_CONFIG)
+
+HOST = PC_CONFIG.HOST
+PORT = PC_CONFIG.IMAGE_REC_PORT
+UPLOAD_FOLDER =  os.path.join(PC_CONFIG.FILE_DIRECTORY,"image-rec","images")
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+def process_file(file_path, direction, task_type):
+    predictor = Predictor()
+    print("File received and saved successfully.")
+    print(f"Direction received: {direction}")
+    print(f"Task type received: {task_type}")
+
+    startTime = datetime.now()
+    class_name, results, detection_id = predictor.predict_id(file_path, task_type)  # Perform prediction
+    #show_annotation_queue.put((file_path, results, detection_id))
+    class_id = str(mapping.get(class_name, -1))
+    endTime = datetime.now()
+    totalTime = (endTime - startTime).total_seconds()
+    print(f"Predicted ID: {class_id}")
+    print(f"Time taken for Predicting Image = {totalTime} s")
+    return class_id
+
+@app.route('/status', methods=['GET'])
+def server_status():
+    return jsonify({'status': 'OK'})
+
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file part'}), 400
+    file = request.files['file']
+    direction = request.form['direction']
+    task_type = request.form['task_type']
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'}), 400
+    if file:
+        filename = os.path.basename(file.filename)
+        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(file_path)
+        # image = cv2.imread(file_path)
+        # cv2.imshow("Uploaded Image", image)
+        # cv2.waitKey(0)  # Wait until a key is pressed
+        # cv2.destroyAllWindows()  # Close the window
+
+        # Process the file and predict
+        class_id = process_file(file_path, direction, task_type)
+        return jsonify({'message': 'File successfully uploaded', 'predicted_id': class_id}), 200
+
+@app.route('/display_stitched', methods=['POST'])
+def display_stitched():
+    showAnnotatedStitched()
+    return jsonify({'display_stitched': 'OK'})
+
+if __name__ == '__main__':
+    # show_annotation_queue = Queue()
+    # process = Process(target=start_annotation_process, args=(show_annotation_queue,))
+    # process.start()
+
+    print()
+    print(f"UPLOAD FOLDER: {UPLOAD_FOLDER}")
+    # Port 5000 if free
+    '''
+    try:
+        app.run(host=HOST, port=PORT, debug=False)
+    except:
+        print('Unable to Connect to PC_CONFIG Host and Port. Switching to 0.0.0.0:4000.')
+        app.run(host='0.0.0.0', port=4000, debug=True)
+    '''
+
+    # Run on Port 4000
+    app.run(host='0.0.0.0', port=4000, debug=True)
+
+    #process.join()

id_mapping.py

@@ -0,0 +1,34 @@
+mapping = {
+    "one": 11,
+    "two": 12,
+    "three": 13,
+    "four": 14,
+    "five": 15,
+    "six": 16,
+    "seven": 17,
+    "eight": 18,
+    "nine": 19,
+    "A": 20,
+    "B": 21,
+    "C": 22,
+    "D": 23,
+    "E": 24,
+    "F": 25,
+    "G": 26,
+    "H": 27,
+    "S": 28,
+    "T": 29,
+    "U": 30,
+    "V": 31,
+    "W": 32,
+    "X": 33,
+    "Y": 34,
+    "Z": 35,
+    "up": 36,
+    "down": 37,
+    "right": 38,
+    "left": 39,
+    "circle": 40,
+    "bullseye": -1,
+    None: -1
+}

predict_task1.py

@@ -0,0 +1,181 @@
+import cv2
+import os
+import time
+import importlib.util
+import supervision as sv
+from ultralytics import YOLO
+
+config_dir = os.path.abspath(os.path.dirname(__file__))
+config_path = os.path.join(config_dir, 'PC_CONFIG.py')
+spec = importlib.util.spec_from_file_location("PC_CONFIG", config_path)
+PC_CONFIG = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(PC_CONFIG)
+dir = str(os.path.join(PC_CONFIG.BASE_DIR, "weights", "best_task1_E256E.pt"))
+
+class Predictor:
+    def __init__(self):
+        # Load a pre-trained yolov8n model
+        print("dir:",dir)
+        self.model = YOLO(dir) # replace model here
+    #     self.print_class_ids()  # Print class IDs upon initialization
+
+    # def print_class_ids(self):
+    #     # Print all class names and their corresponding IDs
+    #     for id, name in enumerate(self.model.names):
+    #         print(f"ID: {id}, Name: {name}")
+
+    # def predict_id(self, image_file_path, task_type):
+    #     # Load the image
+    #     image = cv2.imread(image_file_path)
+
+    #     # Run inference on the image
+    #     results = self.model(image)
+
+    #     # Print results
+    #     print(results)
+    #     # Show annotation
+    #     self.show_annotation(image, results)
+
+    #     # Extract class name
+    #     class_name, largest_size, detection_id = None, -1, None
+    #     for result in results:  # Assuming 'results' is a list
+    #         print(f"task_type is {task_type}")
+
+    #         if task_type == "TASK_2":
+    #             for prediction in result.predictions:
+    #                 print(prediction)
+    #                 class_name = prediction.class_name
+    #                 detection_id = prediction.detection_id
+    #                 if class_name != "Bullseye":
+    #                     break
+    #         else:
+    #             for prediction in result.predictions:
+    #                 print(prediction)
+    #                 if largest_size == -1 or max(prediction.width, prediction.height) > largest_size:
+    #                     largest_size = max(prediction.width, prediction.height)
+    #                     class_name = prediction.class_name
+    #                     detection_id = prediction.detection_id
+
+    #     if class_name:
+    #         print("class_name = " + class_name)
+    #     else:
+    #         print("class_name = None")
+
+    #     return class_name, results, detection_id
+
+    def predict_id(self, image_file_path, task_type):
+        # Load the image
+        image = cv2.imread(image_file_path)
+        # Validation for image existence
+        if image is None:
+            print(f"Error: Could not read image at {image_file_path}")
+            return None, None, None
+
+        # Check the image size and resize if necessary
+        if image.shape[0] != 640 or image.shape[1] != 640:
+            image = cv2.resize(image, (640, 640))  # Resize to 640x640
+
+        # Run inference on the image
+        results = self.model(image)  # Directly pass the image
+
+        # Print results
+        print(results)
+
+        # Show annotation (using YOLOv8's plotting capabilities)
+        # results[0].show()
+
+        # Extract class name, largest size, and detection ID
+        class_name, largest_size, detection_id = None, -1, 0
+        boxes = results[0].boxes.xyxy  # Get bounding boxes (x1, y1, x2, y2)
+        scores = results[0].boxes.conf  # Get confidence scores
+        class_ids = results[0].boxes.cls  # Get class IDs
+
+        for i in range(len(boxes)):
+            print(f"task_type is {task_type}")
+
+            if task_type == "TASK_2":
+                if int(class_ids[i]) != 16:  # Replace with the ID for "Bulls Eye"
+                    class_name = results[0].names[int(class_ids[i])]  # Get class name
+                    detection_id = i
+                    break
+                else:
+                    print("Bullseye detected")
+                    class_name = "bullseye"
+                    detection_id = i
+            else:
+                # Determine the largest bounding box
+                box_width = boxes[i][2] - boxes[i][0]
+                box_height = boxes[i][3] - boxes[i][1]
+                size = max(box_width, box_height)
+                detection_id = i
+
+                if largest_size == -1 or size > largest_size:
+                    largest_size = size
+                    class_name = results[0].names[int(class_ids[i])]
+                    detection_id = i
+
+        if class_name:
+            print("class_name = " + class_name)
+            timestamp = int(time.time())
+            # Save the annotated image
+            try:
+                results[detection_id].save(f'../data/annotated_images/{class_name}_{timestamp}.jpg')
+            except:
+                print("error in saving photo!")
+        else:
+            print("class_name = None")
+
+        return class_name, results, detection_id
+
+
+    # def show_annotation(self, image, results):
+    #     # Create supervision annotators
+    #     bounding_box_annotator = sv.BoundingBoxAnnotator()
+    #     label_annotator = sv.LabelAnnotator()
+
+    #     # Process results from YOLOv8
+    #     detections = []
+    #     for result in results:
+    #         for detection in result.boxes.data:  # Accessing YOLOv8's box data
+    #             class_id = int(detection[5])  # Class ID
+    #             x1, y1, x2, y2 = map(int, detection[:4])  # Bounding box coordinates
+    #             score = float(detection[4])  # Confidence score
+
+    #             # Add to detections
+    #             detections.append({
+    #                 "bbox": [x1, y1, x2, y2],
+    #                 "confidence": score,
+    #                 "class_id": class_id
+    #             })
+
+    #     # Convert detections to the expected format for supervision
+    #     if detections:
+    #         detections = sv.Detections(
+    #             xyxy=[d["bbox"] for d in detections],
+    #             confidence=[d["confidence"] for d in detections],
+    #             class_id=[d["class_id"] for d in detections]
+    #         )
+
+    #         # Annotate the image with inference results
+    #         annotated_image = bounding_box_annotator.annotate(scene=image, detections=detections)
+    #         annotated_image = label_annotator.annotate(scene=annotated_image, detections=detections)
+
+    #         # Display the annotated image
+    #         try:
+    #             cv2.imshow("Annotated Image", annotated_image)
+    #             cv2.waitKey(0)  # Wait indefinitely until a key is pressed
+    #         except Exception as e:
+    #             print(f"Error displaying image: {e}")
+    #         finally:
+    #             cv2.destroyAllWindows()  # Close all OpenCV windows
+    #     else:
+    #         print("No detections found.")
+
+
+if __name__ == "__main__":
+    # Example usage
+    predictor = Predictor()
+    # Specify the path to your image
+    image_file_path = os.path.join(PC_CONFIG.FILE_DIRECTORY, "image-rec", "sample_images", "IMG_9325.jpg")
+    # Predict and display the class name
+    predictor.predict_id(image_file_path, "TASK_1")

predict_task2.py

@@ -0,0 +1,181 @@
+import cv2
+import os
+import time
+import importlib.util
+import supervision as sv
+from ultralytics import YOLO
+
+config_dir = os.path.abspath(os.path.dirname(__file__))
+config_path = os.path.join(config_dir, 'PC_CONFIG.py')
+spec = importlib.util.spec_from_file_location("PC_CONFIG", config_path)
+PC_CONFIG = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(PC_CONFIG)
+dir = str(os.path.join(PC_CONFIG.BASE_DIR, "weights", "best_task2.pt"))
+
+class Predictor:
+    def __init__(self):
+        # Load a pre-trained yolov8n model
+        print("dir:",dir)
+        self.model = YOLO(dir) # replace model here
+    #     self.print_class_ids()  # Print class IDs upon initialization
+
+    # def print_class_ids(self):
+    #     # Print all class names and their corresponding IDs
+    #     for id, name in enumerate(self.model.names):
+    #         print(f"ID: {id}, Name: {name}")
+
+    # def predict_id(self, image_file_path, task_type):
+    #     # Load the image
+    #     image = cv2.imread(image_file_path)
+
+    #     # Run inference on the image
+    #     results = self.model(image)
+
+    #     # Print results
+    #     print(results)
+    #     # Show annotation
+    #     self.show_annotation(image, results)
+
+    #     # Extract class name
+    #     class_name, largest_size, detection_id = None, -1, None
+    #     for result in results:  # Assuming 'results' is a list
+    #         print(f"task_type is {task_type}")
+
+    #         if task_type == "TASK_2":
+    #             for prediction in result.predictions:
+    #                 print(prediction)
+    #                 class_name = prediction.class_name
+    #                 detection_id = prediction.detection_id
+    #                 if class_name != "Bullseye":
+    #                     break
+    #         else:
+    #             for prediction in result.predictions:
+    #                 print(prediction)
+    #                 if largest_size == -1 or max(prediction.width, prediction.height) > largest_size:
+    #                     largest_size = max(prediction.width, prediction.height)
+    #                     class_name = prediction.class_name
+    #                     detection_id = prediction.detection_id
+
+    #     if class_name:
+    #         print("class_name = " + class_name)
+    #     else:
+    #         print("class_name = None")
+
+    #     return class_name, results, detection_id
+
+    def predict_id(self, image_file_path, task_type):
+        # Load the image
+        image = cv2.imread(image_file_path)
+        # Validation for image existence
+        if image is None:
+            print(f"Error: Could not read image at {image_file_path}")
+            return None, None, None
+
+        # Check the image size and resize if necessary
+        if image.shape[0] != 640 or image.shape[1] != 640:
+            image = cv2.resize(image, (640, 640))  # Resize to 640x640
+
+        # Run inference on the image
+        results = self.model(image)  # Directly pass the image
+
+        # Print results
+        print(results)
+
+        # Show annotation (using YOLOv8's plotting capabilities)
+        # results[0].show()
+
+        # Extract class name, largest size, and detection ID
+        class_name, largest_size, detection_id = None, -1, 0
+        boxes = results[0].boxes.xyxy  # Get bounding boxes (x1, y1, x2, y2)
+        scores = results[0].boxes.conf  # Get confidence scores
+        class_ids = results[0].boxes.cls  # Get class IDs
+
+        for i in range(len(boxes)):
+            print(f"task_type is {task_type}")
+
+            if task_type == "TASK_2":
+                if int(class_ids[i]) != 16:  # Replace with the ID for "Bulls Eye"
+                    class_name = results[0].names[int(class_ids[i])]  # Get class name
+                    detection_id = i
+                    break
+                else:
+                    print("Bullseye detected")
+                    class_name = "bullseye"
+                    detection_id = i
+            else:
+                # Determine the largest bounding box
+                box_width = boxes[i][2] - boxes[i][0]
+                box_height = boxes[i][3] - boxes[i][1]
+                size = max(box_width, box_height)
+                detection_id = i
+
+                if largest_size == -1 or size > largest_size:
+                    largest_size = size
+                    class_name = results[0].names[int(class_ids[i])]
+                    detection_id = i
+
+        if class_name:
+            print("class_name = " + class_name)
+            timestamp = int(time.time())
+            # Save the annotated image
+            try:
+                results[detection_id].save(f'../data/annotated_images/{class_name}_{timestamp}.jpg')
+            except:
+                print("error in saving photo!")
+        else:
+            print("class_name = None")
+
+        return class_name, results, detection_id
+
+
+    # def show_annotation(self, image, results):
+    #     # Create supervision annotators
+    #     bounding_box_annotator = sv.BoundingBoxAnnotator()
+    #     label_annotator = sv.LabelAnnotator()
+
+    #     # Process results from YOLOv8
+    #     detections = []
+    #     for result in results:
+    #         for detection in result.boxes.data:  # Accessing YOLOv8's box data
+    #             class_id = int(detection[5])  # Class ID
+    #             x1, y1, x2, y2 = map(int, detection[:4])  # Bounding box coordinates
+    #             score = float(detection[4])  # Confidence score
+
+    #             # Add to detections
+    #             detections.append({
+    #                 "bbox": [x1, y1, x2, y2],
+    #                 "confidence": score,
+    #                 "class_id": class_id
+    #             })
+
+    #     # Convert detections to the expected format for supervision
+    #     if detections:
+    #         detections = sv.Detections(
+    #             xyxy=[d["bbox"] for d in detections],
+    #             confidence=[d["confidence"] for d in detections],
+    #             class_id=[d["class_id"] for d in detections]
+    #         )
+
+    #         # Annotate the image with inference results
+    #         annotated_image = bounding_box_annotator.annotate(scene=image, detections=detections)
+    #         annotated_image = label_annotator.annotate(scene=annotated_image, detections=detections)
+
+    #         # Display the annotated image
+    #         try:
+    #             cv2.imshow("Annotated Image", annotated_image)
+    #             cv2.waitKey(0)  # Wait indefinitely until a key is pressed
+    #         except Exception as e:
+    #             print(f"Error displaying image: {e}")
+    #         finally:
+    #             cv2.destroyAllWindows()  # Close all OpenCV windows
+    #     else:
+    #         print("No detections found.")
+
+
+if __name__ == "__main__":
+    # Example usage
+    predictor = Predictor()
+    # Specify the path to your image
+    image_file_path = os.path.join(PC_CONFIG.FILE_DIRECTORY, "image-rec", "sample_images", "IMG_9325.jpg")
+    # Predict and display the class name
+    predictor.predict_id(image_file_path, "TASK_1")

requirements.txt

@@ -1,17 +1,51 @@
-ipython
-matplotlib>=3.2.2
-numpy>=1.18.5
-opencv-python>=4.1.2
-Pillow>=7.1.2
-PyYAML>=5.3.1
-requests>=2.23.0
-scipy>=1.4.1
-torch>=1.7.0,<2.6.0
-torchvision>=0.8.1
-tqdm>=4.41.0
-tensorboard>=2.4.1
-pandas>=1.1.4
-seaborn>=0.11.0
-imutils~=0.5.4
-Flask
-flask_cors
+blinker==1.8.2
+certifi==2024.8.30
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.1.1
+cycler==0.12.1
+defusedxml==0.7.1
+filelock==3.16.1
+flask==3.0.3
+fonttools==4.53.1
+fsspec==2024.9.0
+idna==3.10
+importlib-metadata==8.5.0
+importlib-resources==6.4.5
+itsdangerous==2.2.0
+jinja2==3.1.4
+kiwisolver==1.4.7
+MarkupSafe==2.1.5
+matplotlib==3.7.5
+mpmath==1.3.0
+networkx==3.1
+numpy==1.23.5
+opencv-python==4.10.0.84
+opencv-python-headless==4.10.0.84
+packaging==24.1
+pandas==2.0.3
+pillow==10.4.0
+psutil==6.0.0
+py-cpuinfo==9.0.0
+pyparsing==3.1.4
+python-dateutil==2.9.0.post0
+pytz==2024.2
+PyYAML==6.0.2
+requests==2.32.3
+scipy==1.10.0
+seaborn==0.13.2
+six==1.16.0
+supervision==0.23.0
+sympy==1.13.3
+torch==2.2.2
+torchvision==0.17.2
+tqdm==4.66.5
+typing-extensions==4.12.2
+tzdata==2024.1
+ultralytics==8.2.97
+ultralytics-thop==2.0.6
+urllib3==2.2.3
+werkzeug==3.0.4
+zipp==3.20.2
+flask-cors==4.0.0
+supervision==0.21.0

requirements_enhanced.txt

@@ -0,0 +1,5 @@
+# Enhanced Image Recognition Server Requirements
+# Additional dependencies for the enhanced server functionality
+
+flask-cors==4.0.0
+supervision==0.21.0

show_annotation.py

@@ -0,0 +1,132 @@
+import cv2
+import supervision as sv
+import time
+import os
+import importlib.util
+from id_mapping import mapping
+from multiprocessing import Process, Queue
+from predict import Predictor
+from show_stitched import showAnnotatedStitched
+import shutil
+from datetime import datetime
+
+
+config_dir = os.path.abspath(os.path.dirname(__file__))
+config_path = os.path.join(config_dir, 'PC_CONFIG.py')
+spec = importlib.util.spec_from_file_location("PC_CONFIG", config_path)
+PC_CONFIG = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(PC_CONFIG)
+
+
+def start_annotation_process(queue):
+    image_count = 0
+    file_dir =  os.path.join(PC_CONFIG.FILE_DIRECTORY,"image-rec","annotated_images")
+
+    archive_directory_content(file_dir)
+
+    while True:
+        if not queue.empty():
+
+            item = queue.get()  # Wait for an item from the queue
+            if item[0] == "STOP":  # Check for the termination signal
+                print("Stopping annotation process.")
+                break  # Exit the loop to end the process
+            print(f"item: {item}")
+            image_file_path, results, detection_id = item
+            image = cv2.imread(image_file_path)
+            image_count += 1
+            show_annotation(image, results, detection_id, image_count)
+
+    showAnnotatedStitched()
+
+def archive_directory_content(directory_path):
+    # Moves files with the specified extension from the given directory to an archive directory,
+    # except for files named .gitkeep.
+
+    archive_dir= os.path.join(PC_CONFIG.FILE_DIRECTORY,"image-rec","annotated_archive")
+    file_extension=".jpg"
+    os.makedirs(archive_dir, exist_ok=True)  # Create the archive directory if it doesn't exist
+    
+    for filename in os.listdir(directory_path):
+        if filename.endswith(file_extension) and filename != ".gitkeep":
+            timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+            new_filename = f"{filename.rsplit('.', 1)[0]}_{timestamp}.{filename.rsplit('.', 1)[1]}"
+            src_path = os.path.join(directory_path, filename)
+            dest_path = os.path.join(archive_dir, new_filename)
+            shutil.move(src_path, dest_path)
+            print(f"Moved and renamed: {src_path} to {dest_path}")
+
+def show_annotation(image, results, detection_id, image_count):
+    print(f"results[0]: {results[0]}")
+    predictions = results[0].predictions
+    filtered_predictions = [pred for pred in predictions if pred.detection_id == detection_id]
+    
+    if not filtered_predictions:
+        print("No matching detection_id found.")
+    
+    # Update the predictions list with only the filtered predictions
+    results[0].predictions = filtered_predictions
+    # Load the results into the supervision Detections API
+    detections = sv.Detections.from_inference(results[0].dict(by_alias=True, exclude_none=True))
+    print(f"detections : {detections}")
+    
+    class_name = "None"
+    annotated_image= image
+
+    if detections and detections.data and detections.data["class_name"]:
+        class_name = detections.data["class_name"][0]
+
+        class_id = str(mapping.get(class_name, -1))
+        updated_label = class_name + ", id=" + class_id
+        # updated_label = class_name + ", " + class_id
+
+        # Create supervision annotators
+        bounding_box_annotator = sv.BoundingBoxAnnotator()
+        label_annotator = sv.LabelAnnotator()
+    
+        # Annotate the image with inference results
+        annotated_image = bounding_box_annotator.annotate(scene=image, detections=detections)
+        annotated_image = label_annotator.annotate(scene=annotated_image, detections=detections, labels=[updated_label])
+
+    # Save the annotated image with a unique name
+    file_name = f"annotated_image{image_count}.jpg"
+    file_path = os.path.join(PC_CONFIG.FILE_DIRECTORY,"image-rec","annotated_images",file_name)
+
+    cv2.imwrite(file_path, annotated_image)
+    print(f"Image saved as {file_path}")
+
+    # Create a named window
+    window_name = f"Annotated Image {image_count}"
+    cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
+
+    # Move the window to a specific position on the screen
+    cv2.moveWindow(window_name, 0, 0)
+
+    # Display the saved annotated image
+    cv2.imshow(f"Annotated Image {image_count}", annotated_image)
+    cv2.waitKey(3000)  # Display the image for 3 seconds
+    cv2.destroyAllWindows()  # Close all OpenCV windows
+
+
+if __name__ == '__main__':
+    image_folder_path = os.path.join(PC_CONFIG.FILE_DIRECTORY, "image-rec", "sample_images")
+    show_annotation_queue = Queue()
+    process = Process(target=start_annotation_process, args=(show_annotation_queue,))
+    process.start()
+
+    predictor = Predictor()
+
+    # List all .jpg files in the specified directory
+    file_path_list = [os.path.join(image_folder_path, f) for f in os.listdir(image_folder_path) if f.endswith('.jpg')]
+
+    for file_path in file_path_list:
+        class_name, results, detection_id = predictor.predict_id(file_path)  # Perform prediction
+
+        print(f"result: {results}")
+        show_annotation_queue.put((file_path, results, detection_id))
+
+    # Send the termination signal to the process
+    show_annotation_queue.put(("STOP",))
+
+    # Wait for the process to finish
+    process.join()

show_stitched.py

@@ -0,0 +1,87 @@
+import matplotlib
+matplotlib.use('TkAgg')  # Use the TkAgg backend
+import matplotlib.pyplot as plt
+import matplotlib.image as mpimg
+import os
+import importlib.util
+import math
+from datetime import datetime
+import shutil
+
+config_dir = os.path.abspath(os.path.dirname(__file__))
+config_path = os.path.join(config_dir, 'PC_CONFIG.py')
+spec = importlib.util.spec_from_file_location("PC_CONFIG", config_path)
+PC_CONFIG = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(PC_CONFIG)
+
+def showAnnotatedStitched():
+    image_dir = os.path.join(PC_CONFIG.FILE_DIRECTORY,"image-rec","annotated_images")
+    image_files = [os.path.join(image_dir, filename) for filename in os.listdir(image_dir) if filename.endswith(".jpg")]
+    
+    # Adjust the layout to 2 by 4
+    num_cols = 4  # Number of columns
+    num_rows = 2  # Number of rows
+    
+    # Ensure there is at least one row if there are images
+    num_rows = max(1, math.ceil(len(image_files) / num_cols)) if image_files else 1
+
+    fig, axes = plt.subplots(num_rows, num_cols, figsize=(num_cols * 3, num_rows * 3), dpi=150)
+
+    # Check if there are any images to display
+    if image_files:
+        for i, ax in enumerate(axes.flat):
+            if i < len(image_files):
+                img = mpimg.imread(image_files[i])
+                ax.imshow(img)
+                ax.axis("off")
+            else:
+                ax.axis("off")
+    else:
+        # If no images, just hide all axes as there's nothing to display
+        for ax in axes.flat:
+            ax.axis("off")
+
+    plt.subplots_adjust(wspace=0, hspace=0)
+    plt.tight_layout(pad=0, h_pad=0, w_pad=0)
+
+    stitched_image_dir = os.path.join(PC_CONFIG.FILE_DIRECTORY, "image-rec", "stitched_images")
+    stitched_file_name = generate_filename_with_timestamp()
+    save_path = os.path.join(stitched_image_dir, stitched_file_name)
+    plt.savefig(save_path, bbox_inches='tight', pad_inches=0)
+    print(f"Figure saved to {save_path}")
+
+    manager = plt.get_current_fig_manager()
+    manager.window.wm_geometry("+0+0")  # Move the window to position (0, 0)
+
+    # plt.show()
+    archive_directory_content(image_dir)
+
+def generate_filename_with_timestamp(prefix="stitched_image", extension=".jpg"):
+    # Get the current date and time
+    now = datetime.now()
+    # Format the date and time as a string
+    timestamp = now.strftime("%Y-%m-%d_%H-%M-%S")
+    # Combine prefix, timestamp, and extension to form the filename
+    filename = f"{prefix}_{timestamp}{extension}"
+    return filename
+
+def archive_directory_content(directory_path):
+    # Moves files with the specified extension from the given directory to an archive directory,
+    # except for files named .gitkeep.
+
+    archive_dir= os.path.join(PC_CONFIG.FILE_DIRECTORY,"image-rec","annotated_archive")
+    file_extension=".jpg"
+    os.makedirs(archive_dir, exist_ok=True)  # Create the archive directory if it doesn't exist
+    
+    for filename in os.listdir(directory_path):
+        if filename.endswith(file_extension) and filename != ".gitkeep":
+            timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+            new_filename = f"{filename.rsplit('.', 1)[0]}_{timestamp}.{filename.rsplit('.', 1)[1]}"
+            src_path = os.path.join(directory_path, filename)
+            dest_path = os.path.join(archive_dir, new_filename)
+            shutil.move(src_path, dest_path)
+            print(f"Moved and renamed: {src_path} to {dest_path}")
+
+if __name__ == "__main__":
+    # Example usage
+    showAnnotatedStitched()

test_processAlgo.py

@@ -0,0 +1,245 @@
+def map_commands_to_paths(data):
+    transformed_commands = data["commands"]
+    paths = data["path"]
+    mapped_commands = []
+
+    # Initialize variables
+    non_snap_path_index = 0  # Tracks which path we're on
+
+    segment_start = True  # Flag to indicate if we are at the start of a new segment
+
+    for command in transformed_commands:
+        if command in ["FW003", "FW002", "BW002"]:
+            # At the start of a segment that requires a path
+            if segment_start and non_snap_path_index < len(paths):
+                mapped_commands.append((command, [paths[non_snap_path_index]]))
+                non_snap_path_index += 1
+            else:
+                mapped_commands.append((command, None))
+            segment_start = False  # Not at the start anymore
+        elif command in ["FL090", "FR090", "BL090", "BR090"]:
+            # These commands are continuation of a segment, no path assigned
+            mapped_commands.append((command, None))
+            segment_start = False  # Still not the start of a new segment
+        elif command.startswith("SNAP") or command == "FIN":
+            # SNAP and FIN are treated as their own segments but don't have paths
+            mapped_commands.append((command, None))
+            segment_start = True  # Next command could be the start of a new segment
+        else:
+            # For any command not explicitly handled above, assign the next path if available
+            if non_snap_path_index < len(paths):
+                mapped_commands.append((command, [paths[non_snap_path_index]]))
+                non_snap_path_index += 1
+            else:
+                mapped_commands.append((command, []))
+            segment_start = True  # Next command could be the start of a new segment
+
+    return mapped_commands
+
+if __name__ == "__main__":
+    # Provided input data
+
+    data =  {
+        "commands": [
+            "FW090",
+            "FW003",
+            "BR090",
+            "BW002",
+            "BW020",
+            "FW003",
+            "BR090",
+            "BW002",
+            "SNAP6_C",
+            "BW040",
+            "FW003",
+            "BL090",
+            "BW002",
+            "FW050",
+            "SNAP1_C",
+            "BW090",
+            "FW003",
+            "BL090",
+            "BW002",
+            "FW010",
+            "SNAP4_C",
+            "BW020",
+            "FW003",
+            "BL090",
+            "BW002",
+            "SNAP5_C",
+            "BW070",
+            "FW003",
+            "BR090",
+            "BW002",
+            "SNAP2_C",
+            "BW040",
+            "FW003",
+            "BL090",
+            "BW002",
+            "FW090",
+            "FW010",
+            "FW003",
+            "FL090",
+            "FW090",
+            "FW030",
+            "FW003",
+            "BR090",
+            "BW002",
+            "FW020",
+            "SNAP3_C",
+            "FIN"
+        ],
+        "distance": 184.0,
+        "path": [
+            {
+                "d": 0,
+                "s": -1,
+                "x": 1,
+                "y": 1
+            },
+            {
+                "d": 0,
+                "s": -1,
+                "x": 1,
+                "y": 10
+            },
+            {
+                "d": 6,
+                "s": -1,
+                "x": 3,
+                "y": 7
+            },
+            {
+                "d": 6,
+                "s": -1,
+                "x": 5,
+                "y": 7
+            },
+            {
+                "d": 4,
+                "s": 6,
+                "x": 8,
+                "y": 9
+            },
+            {
+                "d": 4,
+                "s": -1,
+                "x": 8,
+                "y": 13
+            },
+            {
+                "d": 6,
+                "s": -1,
+                "x": 10,
+                "y": 16
+            },
+            {
+                "d": 6,
+                "s": 1,
+                "x": 5,
+                "y": 16
+            },
+            {
+                "d": 6,
+                "s": -1,
+                "x": 14,
+                "y": 16
+            },
+            {
+                "d": 0,
+                "s": -1,
+                "x": 17,
+                "y": 14
+            },
+            {
+                "d": 0,
+                "s": 4,
+                "x": 17,
+                "y": 15
+            },
+            {
+                "d": 0,
+                "s": -1,
+                "x": 17,
+                "y": 13
+            },
+            {
+                "d": 2,
+                "s": 5,
+                "x": 15,
+                "y": 10
+            },
+            {
+                "d": 2,
+                "s": -1,
+                "x": 8,
+                "y": 10
+            },
+            {
+                "d": 0,
+                "s": 2,
+                "x": 5,
+                "y": 8
+            },
+            {
+                "d": 0,
+                "s": -1,
+                "x": 5,
+                "y": 4
+            },
+            {
+                "d": 2,
+                "s": -1,
+                "x": 3,
+                "y": 1
+            },
+            {
+                "d": 2,
+                "s": -1,
+                "x": 12,
+                "y": 1
+            },
+            {
+                "d": 2,
+                "s": 6,
+                "x": 13,
+                "y": 1
+            },
+            {
+                "d": 0,
+                "s": -1,
+                "x": 15,
+                "y": 4
+            },
+            {
+                "d": 0,
+                "s": -1,
+                "x": 15,
+                "y": 13
+            },
+            {
+                "d": 0,
+                "s": -1,
+                "x": 15,
+                "y": 16
+            },
+            {
+                "d": 6,
+                "s": -1,
+                "x": 17,
+                "y": 13
+            },
+            {
+                "d": 6,
+                "s": 3,
+                "x": 15,
+                "y": 13
+            }
+        ]
+    }
+    # Correct function call
+    command_path_mapping = map_commands_to_paths(data)
+
+    # Output the mapping for review
+    for mapping in command_path_mapping:
+        print(mapping)

test_yolocam.py

@@ -0,0 +1,61 @@
+import cv2
+import numpy as np
+from ultralytics import YOLO
+
+def get_camera_index():
+    index = 0
+    arr = []
+    while True:
+        cap = cv2.VideoCapture(index)
+        if not cap.read()[0]:
+            break
+        else:
+            arr.append(index)
+        cap.release()
+        index += 1
+    return arr
+
+# Get available cameras
+camera_indexes = get_camera_index()
+print(f"Available cameras: {camera_indexes}")
+
+# Try to use the last available camera (which is often an external or Continuity Camera)
+camera_index = camera_indexes[-1] if camera_indexes else 0
+
+# Initialize the webcam
+cap = cv2.VideoCapture(camera_index)
+
+# Initialize YOLOv8 model
+model = YOLO('../weights/best_task2.pt')
+
+# Set the input size
+INPUT_SIZE = (720, 720)
+
+while True:
+    # Read a frame from the webcam
+    ret, frame = cap.read()
+    if not ret:
+        break
+
+    # Resize the frame to 640x640
+    resized_frame = cv2.resize(frame, INPUT_SIZE)
+
+    # Run YOLOv8 inference on the resized frame
+    results = model(resized_frame)
+
+    # Visualize the results on the original frame
+    annotated_frame = results[0].plot()
+
+    # Resize the annotated frame back to the original size for display
+    annotated_frame = cv2.resize(annotated_frame, (frame.shape[1], frame.shape[0]))
+
+    # Display the annotated frame
+    cv2.imshow("YOLOv8 Inference", annotated_frame)
+
+    # Break the loop if 'q' is pressed
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# Release the webcam and close windows
+cap.release()
+cv2.destroyAllWindows()

weights/best_FullDS150E.pt

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

weights/best_FullDS200E.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68442001cb9008aaa6c84b9fedc2b5773a437fab739b5221d0e34d138150da70
+size 6248483

weights/best_task1_E128E.pt

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

weights/best_task1_E256E.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:632ed6138802fa71037494ef2aa707b5a9929f57c0743f4529b8f5cf013a5f42
+size 6257763

weights/best_task1_R128E.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3342982d0c13fb05b4cd0cc0c117eb09c93f8056e8c3a011b370f54c5d3b49ca
+size 6257699

weights/best_task2.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16085d85fbb216167840cd2b132fce9db0775ccbdf1bd8d107ad8f11f5bfa19e
+size 6229475