OpenCV

graph TD
    A[OpenCV] --> B[Core Functionality]
    A --> C[Image Processing]
    A --> D[Video Analysis]
    A --> E[Feature Detection]
    A --> F[Machine Learning]
    A --> G[Object Detection]
    A --> H[Camera Calibration]
    A --> I[3D Reconstruction]

    B --> B1[Data Structures]
    B --> B2[Matrix Operations]
    B --> B3[Memory Management]
    B --> B4[Drawing Functions]

    C --> C1[Filtering]
    C --> C2[Transformations]
    C --> C3[Color Space Conversion]
    C --> C4[Morphological Operations]

    D --> D1[Video Capture]
    D --> D2[Video Writing]
    D --> D3[Background Subtraction]
    D --> D4[Optical Flow]

    E --> E1[Feature Detectors]
    E --> E2[Feature Descriptors]
    E --> E3[Feature Matching]
    E --> E4[Keypoint Algorithms]

    F --> F1[Supervised Learning]
    F --> F2[Unsupervised Learning]
    F --> F3[Statistical Methods]
    F --> F4[Neural Networks]

    G --> G1[Face Detection]
    G --> G2[Object Detection]
    G --> G3[Pose Estimation]
    G --> G4[Segmentation]

    H --> H1[Camera Matrix]
    H --> H2[Distortion Coefficients]
    H --> H3[Pose Estimation]
    H --> H4[Stereo Calibration]

    I --> I1[Structure from Motion]
    I --> I2[Multi-view Geometry]
    I --> I3[Depth Estimation]
    I --> I4[Point Clouds]

    style A fill:#5C6BC0,stroke:#333
    style B fill:#42A5F5,stroke:#333
    style C fill:#66BB6A,stroke:#333
    style D fill:#9575CD,stroke:#333
    style E fill:#FF7043,stroke:#333
    style F fill:#FFA726,stroke:#333
    style G fill:#EC407A,stroke:#333
    style H fill:#AB47BC,stroke:#333
    style I fill:#4DB6AC,stroke:#333

# Basic OpenCV example
import cv2
import numpy as np
import matplotlib.pyplot as plt

print("Basic OpenCV Example...")

# 1. Load and display an image
print("\nLoading and displaying image...")
image = cv2.imread('example.jpg')  # Replace with actual image path

if image is None:
    print("Could not load image. Using sample image instead.")
    # Create a sample image if file not found
    image = np.zeros((300, 400, 3), dtype=np.uint8)
    cv2.putText(image, 'OpenCV Example', (50, 150),
                cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
else:
    print(f"Image loaded successfully. Shape: {image.shape}")

# Convert from BGR to RGB for matplotlib
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Display image
plt.figure(figsize=(8, 6))
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')
plt.show()

# 2. Basic image operations
print("\nBasic image operations...")

# Convert to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
print(f"Grayscale image shape: {gray.shape}")

# Apply Gaussian blur
blurred = cv2.GaussianBlur(gray, (5, 5), 0)

# Edge detection with Canny
edges = cv2.Canny(blurred, 50, 150)

# Display processed images
plt.figure(figsize=(15, 5))

plt.subplot(1, 3, 1)
plt.imshow(gray, cmap='gray')
plt.title('Grayscale')
plt.axis('off')

plt.subplot(1, 3, 2)
plt.imshow(blurred, cmap='gray')
plt.title('Blurred')
plt.axis('off')

plt.subplot(1, 3, 3)
plt.imshow(edges, cmap='gray')
plt.title('Edges')
plt.axis('off')

plt.tight_layout()
plt.show()

# 3. Drawing functions
print("\nDrawing functions...")
# Create a copy of the original image
drawing = image.copy()

# Draw a line
cv2.line(drawing, (50, 50), (200, 50), (0, 255, 0), 2)

# Draw a rectangle
cv2.rectangle(drawing, (50, 100), (200, 200), (255, 0, 0), 2)

# Draw a circle
cv2.circle(drawing, (125, 250), 30, (0, 0, 255), -1)  # -1 fills the circle

# Draw text
cv2.putText(drawing, 'OpenCV', (50, 290),
            cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)

# Display drawing
drawing_rgb = cv2.cvtColor(drawing, cv2.COLOR_BGR2RGB)
plt.figure(figsize=(8, 6))
plt.imshow(drawing_rgb)
plt.title('Drawing Functions')
plt.axis('off')
plt.show()

# 4. Image transformations
print("\nImage transformations...")

# Resize
resized = cv2.resize(image, (200, 200))

# Rotate
(h, w) = image.shape[:2]
center = (w // 2, h // 2)
M = cv2.getRotationMatrix2D(center, 45, 1.0)
rotated = cv2.warpAffine(image, M, (w, h))

# Flip
flipped = cv2.flip(image, 1)

# Display transformations
plt.figure(figsize=(15, 5))

plt.subplot(1, 3, 1)
plt.imshow(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB))
plt.title('Resized')
plt.axis('off')

plt.subplot(1, 3, 2)
plt.imshow(cv2.cvtColor(rotated, cv2.COLOR_BGR2RGB))
plt.title('Rotated')
plt.axis('off')

plt.subplot(1, 3, 3)
plt.imshow(cv2.cvtColor(flipped, cv2.COLOR_BGR2RGB))
plt.title('Flipped')
plt.axis('off')

plt.tight_layout()
plt.show()

# Video processing example
import cv2
import time

print("\nVideo Processing Example...")

# 1. Capture video from webcam
print("Capturing video from webcam...")
cap = cv2.VideoCapture(0)  # 0 for default camera

if not cap.isOpened():
    print("Could not open webcam. Using sample video instead.")
    # Create a sample video writer for demonstration
    fourcc = cv2.VideoWriter_fourcc(*'XVID')
    out = cv2.VideoWriter('sample_output.avi', fourcc, 20.0, (640, 480))

    # Create sample frames
    for i in range(50):
        frame = np.zeros((480, 640, 3), dtype=np.uint8)
        cv2.putText(frame, f'Sample Frame {i+1}', (100, 240),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
        out.write(frame)

    out.release()
    cap = cv2.VideoCapture('sample_output.avi')

# 2. Process video frames
print("Processing video frames...")
frame_count = 0
start_time = time.time()

while cap.isOpened():
    ret, frame = cap.read()

    if not ret:
        print("End of video stream.")
        break

    frame_count += 1

    # Convert to grayscale
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Apply Gaussian blur
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)

    # Edge detection
    edges = cv2.Canny(blurred, 50, 150)

    # Display frames
    cv2.imshow('Original', frame)
    cv2.imshow('Edges', edges)

    # Break the loop if 'q' is pressed
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 3. Release resources
cap.release()
cv2.destroyAllWindows()

end_time = time.time()
print(f"Processed {frame_count} frames in {end_time - start_time:.2f} seconds")
print(f"Average FPS: {frame_count / (end_time - start_time):.2f}")

# 4. Video processing with object detection
print("\nVideo processing with object detection...")

# Load pre-trained face detector
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# Re-open video capture
cap = cv2.VideoCapture(0)

if not cap.isOpened():
    cap = cv2.VideoCapture('sample_output.avi')

frame_count = 0
start_time = time.time()

while cap.isOpened():
    ret, frame = cap.read()

    if not ret:
        break

    frame_count += 1

    # Convert to grayscale for face detection
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Detect faces
    faces = face_cascade.detectMultiScale(gray, 1.1, 4)

    # Draw rectangles around faces
    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)

    # Display frame with detections
    cv2.imshow('Face Detection', frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

end_time = time.time()
print(f"Processed {frame_count} frames with face detection")
print(f"Average FPS: {frame_count / (end_time - start_time):.2f}")

# Feature detection and matching example
import cv2
import numpy as np

print("\nFeature Detection and Matching...")

# 1. Load images
print("Loading images...")
image1 = cv2.imread('scene1.jpg', cv2.IMREAD_GRAYSCALE)  # Replace with actual image paths
image2 = cv2.imread('scene2.jpg', cv2.IMREAD_GRAYSCALE)

if image1 is None or image2 is None:
    print("Could not load images. Using sample images instead.")
    # Create sample images
    image1 = np.zeros((300, 400), dtype=np.uint8)
    cv2.rectangle(image1, (50, 50), (200, 200), 255, -1)
    cv2.circle(image1, (300, 150), 50, 255, -1)

    image2 = np.zeros((300, 400), dtype=np.uint8)
    cv2.rectangle(image2, (70, 70), (220, 220), 255, -1)
    cv2.circle(image2, (280, 130), 60, 255, -1)

# 2. Initialize ORB detector
print("Initializing ORB detector...")
orb = cv2.ORB_create(nfeatures=1000)

# 3. Find keypoints and descriptors
print("Finding keypoints and descriptors...")
kp1, des1 = orb.detectAndCompute(image1, None)
kp2, des2 = orb.detectAndCompute(image2, None)

print(f"Found {len(kp1)} keypoints in image 1")
print(f"Found {len(kp2)} keypoints in image 2")

# 4. Draw keypoints
print("Drawing keypoints...")
image1_kp = cv2.drawKeypoints(image1, kp1, None, color=(0, 255, 0), flags=0)
image2_kp = cv2.drawKeypoints(image2, kp2, None, color=(0, 255, 0), flags=0)

# Display keypoints
plt.figure(figsize=(15, 5))

plt.subplot(1, 2, 1)
plt.imshow(image1_kp, cmap='gray')
plt.title('Image 1 Keypoints')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(image2_kp, cmap='gray')
plt.title('Image 2 Keypoints')
plt.axis('off')

plt.tight_layout()
plt.show()

# 5. Feature matching with BFMatcher
print("Feature matching with BFMatcher...")
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)

# Match descriptors
matches = bf.match(des1, des2)

# Sort matches by distance
matches = sorted(matches, key=lambda x: x.distance)

# Draw first 20 matches
matched_image = cv2.drawMatches(image1, kp1, image2, kp2, matches[:20], None,
                               flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)

plt.figure(figsize=(15, 8))
plt.imshow(matched_image)
plt.title('Feature Matching (First 20 Matches)')
plt.axis('off')
plt.show()

# 6. Feature matching with FLANN
print("Feature matching with FLANN...")
# FLANN parameters
FLANN_INDEX_LSH = 6
index_params = dict(algorithm=FLANN_INDEX_LSH,
                    table_number=6,
                    key_size=12,
                    multi_probe_level=1)
search_params = dict(checks=50)

flann = cv2.FlannBasedMatcher(index_params, search_params)

# Match descriptors
flann_matches = flann.knnMatch(des1, des2, k=2)

# Apply ratio test
good_matches = []
for m, n in flann_matches:
    if m.distance < 0.7 * n.distance:
        good_matches.append(m)

# Draw good matches
flann_matched_image = cv2.drawMatches(image1, kp1, image2, kp2, good_matches[:20], None,
                                      flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)

plt.figure(figsize=(15, 8))
plt.imshow(flann_matched_image)
plt.title('FLANN Feature Matching (Good Matches)')
plt.axis('off')
plt.show()

print(f"Found {len(good_matches)} good matches with FLANN")

# 7. Homography estimation
print("Homography estimation...")
if len(good_matches) > 4:
    # Extract location of good matches
    src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
    dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)

    # Find homography
    M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)

    # Use homography to warp image1 to image2 perspective
    h, w = image1.shape
    pts = np.float32([[0, 0], [0, h-1], [w-1, h-1], [w-1, 0]]).reshape(-1, 1, 2)
    dst = cv2.perspectiveTransform(pts, M)

    # Draw bounding box in image2
    image2_with_box = cv2.polylines(image2.copy(), [np.int32(dst)], True, 255, 3, cv2.LINE_AA)

    plt.figure(figsize=(8, 6))
    plt.imshow(image2_with_box, cmap='gray')
    plt.title('Object Localization with Homography')
    plt.axis('off')
    plt.show()
else:
    print("Not enough matches to compute homography")

# Object detection with deep learning example
import cv2
import numpy as np

print("\nObject Detection with Deep Learning...")

# 1. Load pre-trained model
print("Loading pre-trained model...")
# Load YOLOv3 model
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")  # Replace with actual paths

if net.empty():
    print("Could not load YOLO model. Using sample detection instead.")
    # Create a sample detection function for demonstration
    def sample_detection(image):
        # Create sample detections
        h, w = image.shape[:2]
        detections = []

        # Add some sample detections
        detections.append((0, 0.95, (w//4, h//4, w//2, h//2)))  # person
        detections.append((5, 0.85, (3*w//4, h//4, w//2, h//2)))  # bus
        detections.append((1, 0.90, (w//2, 3*h//4, w//4, h//4)))  # bicycle

        return detections
else:
    # Load COCO class names
    with open("coco.names", "r") as f:  # Replace with actual path
        classes = [line.strip() for line in f.readlines()]

    # Get output layer names
    layer_names = net.getLayerNames()
    output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]

    def yolo_detection(image):
        height, width = image.shape[:2]

        # Create blob from image
        blob = cv2.dnn.blobFromImage(image, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
        net.setInput(blob)
        outs = net.forward(output_layers)

        # Process detections
        class_ids = []
        confidences = []
        boxes = []

        for out in outs:
            for detection in out:
                scores = detection[5:]
                class_id = np.argmax(scores)
                confidence = scores[class_id]

                if confidence > 0.5:
                    # Object detected
                    center_x = int(detection[0] * width)
                    center_y = int(detection[1] * height)
                    w = int(detection[2] * width)
                    h = int(detection[3] * height)

                    # Rectangle coordinates
                    x = int(center_x - w / 2)
                    y = int(center_y - h / 2)

                    boxes.append([x, y, w, h])
                    confidences.append(float(confidence))
                    class_ids.append(class_id)

        # Apply non-max suppression
        indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)

        detections = []
        for i in range(len(boxes)):
            if i in indexes:
                detections.append((class_ids[i], confidences[i], boxes[i]))

        return detections

# 2. Load image
print("Loading image...")
image = cv2.imread('street_scene.jpg')  # Replace with actual image path

if image is None:
    print("Could not load image. Using sample image instead.")
    # Create sample image
    image = np.zeros((480, 640, 3), dtype=np.uint8)
    cv2.rectangle(image, (100, 100), (300, 300), (0, 255, 0), 2)  # person
    cv2.rectangle(image, (400, 100), (600, 300), (255, 0, 0), 2)  # car
    cv2.rectangle(image, (200, 350), (400, 450), (0, 0, 255), 2)  # traffic light

# 3. Perform detection
print("Performing object detection...")
if net.empty():
    detections = sample_detection(image)
    classes = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus']
else:
    detections = yolo_detection(image)

# 4. Draw detections
print("Drawing detections...")
image_with_detections = image.copy()

for class_id, confidence, box in detections:
    x, y, w, h = box
    if net.empty():
        label = f"{classes[class_id]}: {confidence:.2f}"
    else:
        label = f"{classes[class_id]}: {confidence:.2f}"

    # Draw bounding box
    cv2.rectangle(image_with_detections, (x, y), (x + w, y + h), (0, 255, 0), 2)

    # Draw label
    cv2.putText(image_with_detections, label, (x, y - 10),
                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

# 5. Display results
print("Displaying results...")
plt.figure(figsize=(12, 8))
plt.imshow(cv2.cvtColor(image_with_detections, cv2.COLOR_BGR2RGB))
plt.title('Object Detection Results')
plt.axis('off')
plt.show()

# 6. Video object detection
print("\nVideo object detection...")
cap = cv2.VideoCapture(0)  # Use webcam

if not cap.isOpened():
    print("Could not open webcam. Using sample video instead.")
    # Create sample video for demonstration
    fourcc = cv2.VideoWriter_fourcc(*'XVID')
    out = cv2.VideoWriter('sample_detection.avi', fourcc, 10.0, (640, 480))

    for i in range(30):
        frame = np.zeros((480, 640, 3), dtype=np.uint8)
        cv2.putText(frame, f'Sample Frame {i+1}', (100, 240),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
        out.write(frame)

    out.release()
    cap = cv2.VideoCapture('sample_detection.avi')

frame_count = 0
start_time = time.time()

while cap.isOpened():
    ret, frame = cap.read()

    if not ret:
        break

    frame_count += 1

    # Perform detection
    if net.empty():
        detections = sample_detection(frame)
    else:
        detections = yolo_detection(frame)

    # Draw detections
    for class_id, confidence, box in detections:
        x, y, w, h = box
        if net.empty():
            label = f"{classes[class_id]}: {confidence:.2f}"
        else:
            label = f"{classes[class_id]}: {confidence:.2f}"

        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
        cv2.putText(frame, label, (x, y - 10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

    # Display frame
    cv2.imshow('Video Object Detection', frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

end_time = time.time()
print(f"Processed {frame_count} frames with object detection")
print(f"Average FPS: {frame_count / (end_time - start_time):.2f}")

# GPU acceleration example
import cv2
import time

print("\nGPU Acceleration Example...")

# Check if CUDA is available
if cv2.cuda.getCudaEnabledDeviceCount() > 0:
    print("CUDA is available. Using GPU acceleration.")
    use_gpu = True
else:
    print("CUDA is not available. Using CPU.")
    use_gpu = False

# 1. Load image
print("Loading image...")
image = cv2.imread('large_image.jpg')  # Replace with actual image path

if image is None:
    print("Could not load image. Using sample image instead.")
    # Create a large sample image
    image = np.zeros((2000, 3000, 3), dtype=np.uint8)
    cv2.putText(image, 'GPU Acceleration Example', (500, 1000),
                cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 3)

# 2. CPU processing
print("\nCPU processing...")
start_time = time.time()

# Convert to grayscale
gray_cpu = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply Gaussian blur
blurred_cpu = cv2.GaussianBlur(gray_cpu, (21, 21), 0)

# Edge detection
edges_cpu = cv2.Canny(blurred_cpu, 50, 150)

cpu_time = time.time() - start_time
print(f"CPU processing time: {cpu_time:.4f} seconds")

# 3. GPU processing (if available)
if use_gpu:
    print("\nGPU processing...")
    start_time = time.time()

    # Upload image to GPU
    gpu_image = cv2.cuda_GpuMat()
    gpu_image.upload(image)

    # Convert to grayscale on GPU
    gpu_gray = cv2.cuda.cvtColor(gpu_image, cv2.COLOR_BGR2GRAY)

    # Apply Gaussian blur on GPU
    gpu_blurred = cv2.cuda.createGaussianFilter(cv2.CV_8UC1, cv2.CV_8UC1, (21, 21), 0)
    gpu_blurred = gpu_blurred.apply(gpu_gray)

    # Edge detection on GPU
    gpu_edges = cv2.cuda.Canny(gpu_blurred, 50, 150)

    # Download result from GPU
    edges_gpu = gpu_edges.download()

    gpu_time = time.time() - start_time
    print(f"GPU processing time: {gpu_time:.4f} seconds")
    print(f"Speedup: {cpu_time / gpu_time:.2f}x")

    # Compare results
    print("\nComparing results...")
    diff = cv2.absdiff(edges_cpu, edges_gpu)
    non_zero = cv2.countNonZero(diff)
    print(f"Pixel differences: {non_zero}")

    if non_zero == 0:
        print("CPU and GPU results are identical")
    else:
        print("CPU and GPU results differ")

    # Display GPU result
    plt.figure(figsize=(10, 6))
    plt.imshow(edges_gpu, cmap='gray')
    plt.title('GPU Edge Detection')
    plt.axis('off')
    plt.show()
else:
    print("\nGPU not available. Skipping GPU processing.")

    # Display CPU result
    plt.figure(figsize=(10, 6))
    plt.imshow(edges_cpu, cmap='gray')
    plt.title('CPU Edge Detection')
    plt.axis('off')
    plt.show()

# 4. Benchmark with multiple operations
print("\nBenchmarking with multiple operations...")

def cpu_benchmark(image, iterations=10):
    start_time = time.time()

    for _ in range(iterations):
        # Multiple operations
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(gray, (11, 11), 0)
        edges = cv2.Canny(blurred, 50, 150)
        dilated = cv2.dilate(edges, None, iterations=2)
        eroded = cv2.erode(dilated, None, iterations=2)

    return (time.time() - start_time) / iterations

def gpu_benchmark(image, iterations=10):
    start_time = time.time()

    # Upload image to GPU
    gpu_image = cv2.cuda_GpuMat()
    gpu_image.upload(image)

    for _ in range(iterations):
        # Multiple operations on GPU
        gpu_gray = cv2.cuda.cvtColor(gpu_image, cv2.COLOR_BGR2GRAY)
        gpu_blurred = cv2.cuda.createGaussianFilter(cv2.CV_8UC1, cv2.CV_8UC1, (11, 11), 0)
        gpu_blurred = gpu_blurred.apply(gpu_gray)
        gpu_edges = cv2.cuda.Canny(gpu_blurred, 50, 150)
        gpu_dilated = cv2.cuda.createMorphologyFilter(cv2.MORPH_DILATE, cv2.CV_8UC1, None)
        gpu_dilated = gpu_dilated.apply(gpu_edges)
        gpu_eroded = cv2.cuda.createMorphologyFilter(cv2.MORPH_ERODE, cv2.CV_8UC1, None)
        gpu_eroded = gpu_eroded.apply(gpu_dilated)

    # Download final result
    gpu_eroded.download()

    return (time.time() - start_time) / iterations

print("Running CPU benchmark...")
cpu_avg_time = cpu_benchmark(image)
print(f"CPU average time per iteration: {cpu_avg_time:.4f} seconds")

if use_gpu:
    print("Running GPU benchmark...")
    gpu_avg_time = gpu_benchmark(image)
    print(f"GPU average time per iteration: {gpu_avg_time:.4f} seconds")
    print(f"Speedup: {cpu_avg_time / gpu_avg_time:.2f}x")

# Multithreading example
import cv2
import time
import threading
import queue

print("\nMultithreading Example...")

# 1. Create a video processing pipeline
print("Creating video processing pipeline...")

# Shared queues
frame_queue = queue.Queue(maxsize=10)
processed_queue = queue.Queue(maxsize=10)

# Processing function
def process_frame(frame):
    """Process a single frame"""
    # Convert to grayscale
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Apply Gaussian blur
    blurred = cv2.GaussianBlur(gray, (11, 11), 0)

    # Edge detection
    edges = cv2.Canny(blurred, 50, 150)

    # Find contours
    contours, _ = cv2.findContours(edges.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    # Draw contours
    result = frame.copy()
    cv2.drawContours(result, contours, -1, (0, 255, 0), 2)

    return result

# Producer thread - reads frames from video source
def producer():
    print("Producer thread started...")
    cap = cv2.VideoCapture(0)  # Use webcam

    if not cap.isOpened():
        print("Could not open webcam. Using sample video instead.")
        # Create sample video for demonstration
        fourcc = cv2.VideoWriter_fourcc(*'XVID')
        out = cv2.VideoWriter('sample_threading.avi', fourcc, 15.0, (640, 480))

        for i in range(45):
            frame = np.zeros((480, 640, 3), dtype=np.uint8)
            cv2.putText(frame, f'Sample Frame {i+1}', (100, 240),
                        cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
            out.write(frame)

        out.release()
        cap = cv2.VideoCapture('sample_threading.avi')

    frame_count = 0
    start_time = time.time()

    while True:
        ret, frame = cap.read()

        if not ret:
            break

        frame_count += 1

        # Put frame in queue (non-blocking)
        try:
            frame_queue.put_nowait(frame)
        except queue.Full:
            # Queue is full, skip frame
            continue

    cap.release()
    print(f"Producer finished. Processed {frame_count} frames in {time.time() - start_time:.2f} seconds")

# Consumer thread - processes frames
def consumer():
    print("Consumer thread started...")
    processed_count = 0
    start_time = time.time()

    while True:
        try:
            # Get frame from queue (with timeout)
            frame = frame_queue.get(timeout=5)

            # Process frame
            processed_frame = process_frame(frame)
            processed_count += 1

            # Put processed frame in output queue
            try:
                processed_queue.put_nowait(processed_frame)
            except queue.Full:
                # Output queue is full, skip
                continue

            frame_queue.task_done()

        except queue.Empty:
            # No more frames to process
            break

    print(f"Consumer finished. Processed {processed_count} frames in {time.time() - start_time:.2f} seconds")

# Display thread - shows processed frames
def display():
    print("Display thread started...")
    displayed_count = 0
    start_time = time.time()

    while True:
        try:
            # Get processed frame from queue (with timeout)
            frame = processed_queue.get(timeout=5)

            displayed_count += 1

            # Display frame
            cv2.imshow('Multithreaded Processing', frame)

            if cv2.waitKey(1) & 0xFF == ord('q'):
                break

            processed_queue.task_done()

        except queue.Empty:
            # No more frames to display
            break

    cv2.destroyAllWindows()
    print(f"Display finished. Displayed {displayed_count} frames in {time.time() - start_time:.2f} seconds")

# 2. Run the pipeline
print("\nRunning multithreaded pipeline...")
start_time = time.time()

# Create and start threads
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
display_thread = threading.Thread(target=display)

producer_thread.start()
consumer_thread.start()
display_thread.start()

# Wait for threads to finish
producer_thread.join()
consumer_thread.join()

# Give display thread time to finish
time.sleep(1)
display_thread.join()

total_time = time.time() - start_time
print(f"\nMultithreaded pipeline completed in {total_time:.2f} seconds")

# 3. Compare with single-threaded approach
print("\nComparing with single-threaded approach...")
def single_threaded_processing():
    print("Running single-threaded processing...")
    cap = cv2.VideoCapture(0)  # Use webcam

    if not cap.isOpened():
        cap = cv2.VideoCapture('sample_threading.avi')

    frame_count = 0
    start_time = time.time()

    while True:
        ret, frame = cap.read()

        if not ret:
            break

        frame_count += 1

        # Process frame
        processed_frame = process_frame(frame)

        # Display frame
        cv2.imshow('Single-threaded Processing', processed_frame)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

    return frame_count, time.time() - start_time

frame_count, single_time = single_threaded_processing()
print(f"Single-threaded processed {frame_count} frames in {single_time:.2f} seconds")

# Note: The actual speedup depends on the number of CPU cores and the workload
print(f"\nComparison:")
print(f"Single-threaded: {single_time:.2f} seconds")
print(f"Multithreaded: {total_time:.2f} seconds")
if total_time > 0:
    print(f"Speedup: {single_time / total_time:.2f}x")