👁️ Computer Vision Fundamentals

import cv2
import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

class IndustrialVisionSystem:
    def __init__(self):
        self.camera = cv2.VideoCapture(0)
        self.setup_camera()
        
    def setup_camera(self):
        """Configure camera parameters"""
        self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
        self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)
        self.camera.set(cv2.CAP_PROP_FPS, 30)
        self.camera.set(cv2.CAP_PROP_EXPOSURE, -6)  # Manual exposure
        
    def preprocess_image(self, image):
        """Image preprocessing pipeline"""
        # Convert to grayscale
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        # Noise reduction
        denoised = cv2.bilateralFilter(gray, 9, 75, 75)
        
        # Histogram equalization
        equalized = cv2.equalizeHist(denoised)
        
        # Gaussian blur
        blurred = cv2.GaussianBlur(equalized, (5, 5), 0)
        
        return blurred
        
    def detect_edges(self, image):
        """Edge detection using Canny algorithm"""
        # Auto-threshold calculation
        sigma = 0.33
        median = np.median(image)
        lower = int(max(0, (1.0 - sigma) * median))
        upper = int(min(255, (1.0 + sigma) * median))
        
        edges = cv2.Canny(image, lower, upper)
        return edges
        
    def find_contours(self, edges):
        """Find and filter contours"""
        contours, _ = cv2.findContours(
            edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
        )
        
        # Filter contours by area
        min_area = 1000
        max_area = 50000
        filtered_contours = []
        
        for contour in contours:
            area = cv2.contourArea(contour)
            if min_area < area < max_area:
                filtered_contours.append(contour)
                
        return filtered_contours
        
    def extract_features(self, contour):
        """Extract geometric features from contour"""
        features = {}
        
        # Area and perimeter
        features['area'] = cv2.contourArea(contour)
        features['perimeter'] = cv2.arcLength(contour, True)
        
        # Bounding rectangle
        x, y, w, h = cv2.boundingRect(contour)
        features['aspect_ratio'] = float(w) / h
        features['rect_area'] = w * h
        features['extent'] = features['area'] / features['rect_area']
        
        # Minimum enclosing circle
        (cx, cy), radius = cv2.minEnclosingCircle(contour)
        features['circularity'] = features['area'] / (np.pi * radius**2)
        
        # Moments for centroid
        M = cv2.moments(contour)
        if M['m00'] != 0:
            features['centroid_x'] = int(M['m10'] / M['m00'])
            features['centroid_y'] = int(M['m01'] / M['m00'])
        
        return features
        
    def classify_object(self, features):
        """Simple rule-based classification"""
        aspect_ratio = features['aspect_ratio']
        circularity = features['circularity']
        extent = features['extent']
        
        if circularity > 0.8:
            return "Circle/Gauge"
        elif 0.8 < aspect_ratio < 1.2 and extent > 0.8:
            return "Square/Display"
        elif aspect_ratio > 2.0:
            return "Rectangle/Panel"
        else:
            return "Unknown"
            
    def process_frame(self, frame):
        """Complete processing pipeline"""
        results = []
        
        # Preprocessing
        processed = self.preprocess_image(frame)
        
        # Edge detection
        edges = self.detect_edges(processed)
        
        # Find contours
        contours = self.find_contours(edges)
        
        # Process each contour
        for contour in contours:
            features = self.extract_features(contour)
            classification = self.classify_object(features)
            
            result = {
                'contour': contour,
                'features': features,
                'classification': classification
            }
            results.append(result)
            
        return results, edges
        
    def draw_results(self, frame, results):
        """Draw detection results on frame"""
        output = frame.copy()
        
        for i, result in enumerate(results):
            contour = result['contour']
            classification = result['classification']
            features = result['features']
            
            # Draw contour
            cv2.drawContours(output, [contour], -1, (0, 255, 0), 2)
            
            # Draw bounding rectangle
            x, y, w, h = cv2.boundingRect(contour)
            cv2.rectangle(output, (x, y), (x+w, y+h), (255, 0, 0), 2)
            
            # Add text label
            label = f"{classification} #{i+1}"
            cv2.putText(output, label, (x, y-10), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
            
            # Add feature info
            info = f"Area: {features['area']:.0f}"
            cv2.putText(output, info, (x, y+h+20), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
                       
        return output
        
    def run_continuous(self):
        """Main processing loop"""
        print("Starting Industrial Vision System...")
        print("Press 'q' to quit, 's' to save frame")
        
        while True:
            ret, frame = self.camera.read()
            if not ret:
                print("Failed to grab frame")
                break
                
            # Process frame
            results, edges = self.process_frame(frame)
            
            # Draw results
            output = self.draw_results(frame, results)
            
            # Display results
            cv2.imshow('Original', frame)
            cv2.imshow('Edges', edges)
            cv2.imshow('Detection Results', output)
            
            # Print results to console
            if results:
                print(f"Detected {len(results)} objects:")
                for i, result in enumerate(results):
                    print(f"  Object {i+1}: {result['classification']}")
            
            # Handle key presses
            key = cv2.waitKey(1) & 0xFF
            if key == ord('q'):
                break
            elif key == ord('s'):
                timestamp = cv2.getTickCount()
                cv2.imwrite(f'capture_{timestamp}.jpg', output)
                print(f"Saved frame as capture_{timestamp}.jpg")
                
        # Cleanup
        self.camera.release()
        cv2.destroyAllWindows()

# Usage example
if __name__ == "__main__":
    vision_system = IndustrialVisionSystem()
    vision_system.run_continuous()