Upload 20 files

speech_to_text.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug  1 11:23:30 2024
+
+@author: ysnrfd
+"""
+
+import whisper
+
+# بارگذاری مدل
+model = whisper.load_model("medium")
+

untitled1.py

@@ -0,0 +1,100 @@
+import cv2
+import numpy as np
+
+def adjust_brightness_contrast(image, beta=50, alpha=1.5):
+    # افزایش روشنایی و کنتراست تصویر
+    return cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
+
+def gamma_correction(image, gamma=2.0):
+    # تبدیل تصویر به فضای رنگی YUV
+    yuv_image = cv2.cvtColor(image, cv2.COLOR_BGR2YUV)
+    
+    # اعمال تصحیح گاما بر روی کانال Y
+    yuv_image[..., 0] = np.clip(np.power(yuv_image[..., 0] / 255.0, gamma) * 255.0, 0, 255).astype(np.uint8)
+    
+    # تبدیل مجدد به فضای رنگی BGR
+    return cv2.cvtColor(yuv_image, cv2.COLOR_YUV2BGR)
+
+def apply_clahe(image):
+    # تبدیل تصویر به فضای رنگی خاکستری
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    # ایجاد شیء CLAHE و تنظیم پارامترها
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+    
+    # اعمال CLAHE بر روی تصویر خاکستری
+    clahe_image = clahe.apply(gray_image)
+    
+    # تبدیل تصویر خاکستری به BGR
+    return cv2.cvtColor(clahe_image, cv2.COLOR_GRAY2BGR)
+
+def enhance_details(image):
+    # استفاده از sharpening filter برای افزایش جزئیات
+    kernel = np.array([[0, -1, 0],
+                       [-1, 5, -1],
+                       [0, -1, 0]])
+    sharpened_image = cv2.filter2D(image, -1, kernel)
+    
+    return sharpened_image
+
+def convert_to_hsv(image):
+    # تبدیل تصویر به فضای رنگی HSV
+    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+    
+    # افزایش روشنایی در کانال V
+    hsv_image[..., 2] = cv2.convertScaleAbs(hsv_image[..., 2], alpha=1.5, beta=30)
+    
+    # تبدیل مجدد به فضای رنگی BGR
+    return cv2.cvtColor(hsv_image, cv2.COLOR_HSV2BGR)
+
+def improve_low_light(image):
+    # تبدیل به فضای رنگی HSV برای افزایش روشنایی
+    hsv_image = convert_to_hsv(image)
+    
+    # تنظیم روشنایی و کنتراست
+    bright_image = adjust_brightness_contrast(hsv_image, beta=50, alpha=1.5)
+    
+    # تصحیح گاما
+    gamma_corrected_image = gamma_correction(bright_image, gamma=2.0)
+    
+    # اعمال CLAHE برای افزایش کنتراست محلی
+    clahe_image = apply_clahe(gamma_corrected_image)
+    
+    # افزایش جزئیات
+    detailed_image = enhance_details(clahe_image)
+    
+    return detailed_image
+
+def main():
+    # اتصال به دوربین (0 برای دوربین پیش‌فرض)
+    cap = cv2.VideoCapture(0)
+
+    if not cap.isOpened():
+        print("خطا: دوربین باز نشد!")
+        return
+
+    while True:
+        # خواندن فریم از دوربین
+        ret, frame = cap.read()
+
+        if not ret:
+            print("خطا: نمی‌توان فریم را خواند!")
+            break
+
+        # بهبود تصویر در شرایط نور کم
+        improved_frame = improve_low_light(frame)
+
+        # نمایش تصویر اصلی و تصویر بهبود یافته
+        cv2.imshow('Original Frame', frame)
+        cv2.imshow('Improved Frame', improved_frame)
+
+        # خروج از برنامه با فشار دادن کلید 'q'
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    # آزادسازی منابع و بستن پنجره‌ها
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

untitled10.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Aug  3 21:09:27 2024
+
+@author: ysnrfd
+"""
+
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Aug  3 21:01:48 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+import numpy as np
+
+def main():
+    # Initialize video capture
+    cap = cv2.VideoCapture(0)
+    
+    if not cap.isOpened():
+        print("Error: Unable to open camera.")
+        return
+
+    # Create background subtractor with KNN
+    backSub = cv2.createBackgroundSubtractorKNN(history=10, dist2Threshold=15.0, detectShadows=True)
+
+    try:
+        while True:
+            # Read frame from the camera
+            ret, frame = cap.read()
+
+            if not ret:
+                print("Error: Unable to read frame.")
+                break
+
+            # Apply background subtraction
+            fgMask = backSub.apply(frame)
+
+            # Apply morphological operations
+            kernel = np.ones((1, 1), np.uint8)
+            fgMask = cv2.morphologyEx(fgMask, cv2.MORPH_CLOSE, kernel)
+            fgMask = cv2.morphologyEx(fgMask, cv2.MORPH_OPEN, kernel)
+
+            # Apply Gaussian blur to reduce noise
+            blurred = cv2.GaussianBlur(fgMask, (1, 1), 0)
+
+            # Find contours
+            contours, _ = cv2.findContours(blurred, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+            # Draw bounding boxes around detected objects
+            for contour in contours:
+                if cv2.contourArea(contour) > 10:  # Filter out small contours
+                    x, y, w, h = cv2.boundingRect(contour)
+                    cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+                    
+
+            # Display the results
+            cv2.imshow('Frame', frame)
+            cv2.imshow('Foreground Mask', fgMask)
+
+            # Exit loop if 'q' is pressed
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                break
+
+    finally:
+        # Release resources
+        cap.release()
+        cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

untitled11.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Aug  3 22:20:23 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+import numpy as np
+from skimage import exposure, img_as_float
+from scipy.ndimage import gaussian_filter
+
+def enhance_image(image):
+    # تبدیل تصویر به فضای رنگی خاکستری
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    # نرمال‌سازی و تبدیل به float
+    gray_image_float = img_as_float(gray_image)
+    
+    # تبدیل لگاریتمی برای افزایش کنتراست
+    log_transformed = np.log1p(gray_image_float * 255)
+    
+    # نرمال‌سازی شدت تصویر
+    log_transformed = exposure.rescale_intensity(log_transformed, in_range='image')
+    
+    # استفاده از فیلتر گوسی برای کاهش نویز
+    denoised_image = gaussian_filter(log_transformed, sigma=1)
+    
+    # بازگشت به دامنه اصلی تصویر
+    enhanced_image = (denoised_image * 255).astype(np.uint8)
+    
+    # استفاده از افزایش کنتراست هیستوگرام
+    enhanced_image = exposure.equalize_hist(enhanced_image) * 255
+    enhanced_image = enhanced_image.astype(np.uint8)
+    
+    # تبدیل تصویر به فضای رنگی BGR
+    enhanced_image = cv2.cvtColor(enhanced_image, cv2.COLOR_GRAY2BGR)
+    
+    return enhanced_image
+
+# باز کردن دوربین (عدد 0 برای دوربین پیش‌فرض)
+cap = cv2.VideoCapture(0)
+
+while True:
+    # خواندن یک فریم از دوربین
+    ret, frame = cap.read()
+    
+    if not ret:
+        break
+    
+    # بهبود تصویر
+    enhanced_frame = enhance_image(frame)
+    
+    # نمایش تصویر بهبود یافته
+    cv2.imshow('Night Vision', enhanced_frame)
+    
+    # خروج از حلقه با زدن کلید 'q'
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# آزادسازی منابع
+cap.release()
+cv2.destroyAllWindows()

untitled12.py

@@ -0,0 +1,38 @@
+import cv2
+import numpy as np
+
+# تابع برای شبیه‌سازی تصویر مادون قرمز
+def simulate_ir(image):
+    # تبدیل تصویر به فضای رنگی خاکستری
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    # معکوس کردن تصویر خاکستری برای شبیه‌سازی تصویر مادون قرمز
+    ir_image = cv2.bitwise_not(gray_image)
+    
+    return ir_image
+
+# باز کردن دوربین (عدد 0 نشان‌دهنده دوربین پیش‌فرض است)
+cap = cv2.VideoCapture(0)
+
+while True:
+    # خواندن فریم از دوربین
+    ret, frame = cap.read()
+    
+    if not ret:
+        print("خطا در خواندن فریم")
+        break
+    
+    # شبیه‌سازی تصویر مادون قرمز
+    ir_frame = simulate_ir(frame)
+    
+    # نمایش تصویر اصلی و شبیه‌سازی شده
+    cv2.imshow('Original Frame', frame)
+    cv2.imshow('Simulated IR Frame', ir_frame)
+    
+    # خروج از حلقه با فشار دادن کلید 'q'
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# آزاد کردن دوربین و بستن تمام پنجره‌ها
+cap.release()
+cv2.destroyAllWindows()

untitled13.py

@@ -0,0 +1,57 @@
+import cv2
+import numpy as np
+from ultralytics import YOLO
+
+# Load YOLOv8x model and move it to GPU if available
+model = YOLO('yolov8n.pt')  # Use 'yolov8n.pt' for even faster processing if accuracy is acceptable
+
+# Open a connection to the camera
+cap = cv2.VideoCapture(0)
+
+# Check if the camera opened successfully
+if not cap.isOpened():
+    print("Error: Could not open camera.")
+    exit()
+
+# Set the camera resolution (lower resolution for faster processing)
+cap.set(cv2.CAP_PROP_FRAME_WIDTH, 320)  # Reduced resolution for speed
+cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 240)  # Reduced resolution for speed
+
+while True:
+    # Capture frame-by-frame
+    ret, frame = cap.read()
+    if not ret:
+        print("Error: Failed to capture image")
+        break
+
+    # Convert to grayscale for night vision effect
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    
+    # Apply a color map to simulate night vision
+    night_vision = cv2.applyColorMap(gray, cv2.COLORMAP_HOT)
+
+    # Convert the frame to the format required by YOLOv8
+    night_vision_rgb = cv2.cvtColor(night_vision, cv2.COLOR_BGR2RGB)
+
+    # Perform object detection with YOLOv8x
+    results = model(night_vision_rgb, stream=True, imgsz=320)  # Further reduced image size for speed
+
+    # Draw bounding boxes and labels on the night vision image
+    for result in results:
+        boxes = result.boxes.data.cpu().numpy()
+        for box in boxes:
+            x1, y1, x2, y2, score, class_id = map(int, box)
+            label = f"{model.names[class_id]}: {score:.2f}"
+            cv2.rectangle(night_vision, (x1, y1), (x2, y2), (0, 255, 0), 1)  # Thin box for speed
+            cv2.putText(night_vision, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)  # Thin text for speed
+
+    # Display the resulting frame
+    cv2.imshow('Night Vision YOLOv8x', night_vision)
+
+    # Break the loop on 'q' key press
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# Release the capture and close all windows
+cap.release()
+cv2.destroyAllWindows()

untitled14.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Aug  4 13:35:09 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+from ultralytics import YOLO
+
+# Load the YOLOv8n model (nano) for ultra-fast inference
+model = YOLO('yolov10n.pt')  # Replace with the path to your YOLOv8n model
+
+# Open a connection to the camera
+cap = cv2.VideoCapture(0)
+
+# Check if the camera opened successfully
+if not cap.isOpened():
+    print("Error: Could not open camera.")
+    exit()
+
+# Set the camera resolution (lower resolution for speed)
+cap.set(cv2.CAP_PROP_FRAME_WIDTH, 512)
+cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 512)
+
+while True:
+    # Capture frame-by-frame
+    ret, frame = cap.read()
+    if not ret:
+        print("Error: Failed to capture image")
+        break
+
+    # Perform object detection with YOLOv8n
+    results = model(frame, imgsz=512, stream=True)  # Adjust img size if necessary
+
+    # Draw bounding boxes and labels on the frame
+    for result in results:
+        boxes = result.boxes.data.cpu().numpy()
+        for box in boxes:
+            x1, y1, x2, y2, score, class_id = map(int, box)
+            label = f"{model.names[class_id]}: {score:.2f}"
+            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 1)  # Thin box for speed
+            cv2.putText(frame, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)  # Thin text for speed
+
+    # Display the resulting frame
+    cv2.imshow('YOLOv8n Real-Time Detection', frame)
+
+    # Break the loop on 'q' key press
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# Release the capture and close all windows
+cap.release()
+cv2.destroyAllWindows()

untitled15.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Aug  4 13:39:00 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+import numpy as np
+
+# Initialize the background subtractor
+background_subtractor = cv2.createBackgroundSubtractorMOG2()
+
+# Open a connection to the camera
+cap = cv2.VideoCapture(0)
+
+# Check if the camera opened successfully
+if not cap.isOpened():
+    print("Error: Could not open camera.")
+    exit()
+
+while True:
+    # Capture frame-by-frame
+    ret, frame = cap.read()
+    if not ret:
+        print("Error: Failed to capture image")
+        break
+
+    # Apply background subtraction
+    fg_mask = background_subtractor.apply(frame)
+
+    # Find contours of the detected objects
+    contours, _ = cv2.findContours(fg_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Draw contours on the frame
+    for contour in contours:
+        if cv2.contourArea(contour) > 15:  # Adjust the threshold for contour area
+            x, y, w, h = cv2.boundingRect(contour)
+            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 1)
+            cv2.putText(frame, "Anomaly Detected", (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+
+    # Display the resulting frame
+    cv2.imshow('Ghost Detector (Anomaly Detection)', frame)
+
+    # Break the loop on 'q' key press
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# Release the capture and close all windows
+cap.release()
+cv2.destroyAllWindows()

untitled16.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Aug  4 13:48:50 2024
+
+@author: ysnrfd
+"""
+
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Advanced Ghost Detection Script with Machine Learning Integration and Real-Time Performance Enhancements
+"""
+
+import cv2
+import numpy as np
+from threading import Thread
+from queue import Queue
+from ultralytics import YOLO
+
+class AdvancedGhostDetector:
+    def __init__(self, video_source=0, contour_area_threshold=100, model_path='yolov8s.pt'):
+        self.video_source = video_source
+        self.contour_area_threshold = contour_area_threshold
+        self.background_subtractor = cv2.createBackgroundSubtractorMOG2()
+        self.cap = cv2.VideoCapture(self.video_source)
+        self.frame_queue = Queue(maxsize=10)
+        self.model = YOLO(model_path)
+
+        if not self.cap.isOpened():
+            raise IOError("Error: Could not open camera.")
+
+    def capture_frames(self):
+        while True:
+            ret, frame = self.cap.read()
+            if not ret:
+                print("Error: Failed to capture image")
+                break
+            if not self.frame_queue.full():
+                self.frame_queue.put(frame)
+
+    def process_frame(self, frame):
+        # Apply background subtraction
+        fg_mask = self.background_subtractor.apply(frame)
+
+        # Find contours of the detected objects
+        contours, _ = cv2.findContours(fg_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        # Draw contours on the frame
+        for contour in contours:
+            if cv2.contourArea(contour) > self.contour_area_threshold:
+                x, y, w, h = cv2.boundingRect(contour)
+                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+                cv2.putText(frame, "Anomaly Detected", (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+
+        return frame
+
+    def detect_objects(self, frame):
+        # Convert frame to RGB for YOLOv8
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = self.model(rgb_frame, imgsz=320)
+
+        # Draw bounding boxes and labels on the frame
+        for result in results:
+            boxes = result.boxes.data.cpu().numpy()
+            for box in boxes:
+                x1, y1, x2, y2, score, class_id = map(int, box)
+                label = f"{self.model.names[class_id]}: {score:.2f}"
+                cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                cv2.putText(frame, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+
+        return frame
+
+    def display_frame(self, frame):
+        # Display the resulting frame
+        cv2.imshow('Advanced Ghost Detector', frame)
+
+    def run(self):
+        capture_thread = Thread(target=self.capture_frames, daemon=True)
+        capture_thread.start()
+
+        while True:
+            if not self.frame_queue.empty():
+                frame = self.frame_queue.get()
+                processed_frame = self.process_frame(frame)
+                detected_frame = self.detect_objects(processed_frame)
+                self.display_frame(detected_frame)
+
+                # Break the loop on 'q' key press
+                if cv2.waitKey(1) & 0xFF == ord('q'):
+                    break
+
+        self.cleanup()
+
+    def cleanup(self):
+        # Release the capture and close all windows
+        self.cap.release()
+        cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    try:
+        detector = AdvancedGhostDetector(video_source=0, contour_area_threshold=1000, model_path='yolov8n.pt')
+        detector.run()
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        cv2.destroyAllWindows()

untitled18.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Aug  4 14:49:57 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+import mediapipe as mp
+
+# Initialize MediaPipe Pose module
+mp_pose = mp.solutions.pose
+pose = mp_pose.Pose()
+
+# Initialize MediaPipe Drawing module
+mp_drawing = mp.solutions.drawing_utils
+
+# Initialize webcam
+cap = cv2.VideoCapture(0)
+
+while True:
+    # Read frame from webcam
+    ret, frame = cap.read()
+    if not ret:
+        break
+
+    # Convert the frame to RGB
+    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+    # Process the frame and get pose landmarks
+    results = pose.process(frame_rgb)
+
+    # Draw pose landmarks on the frame
+    if results.pose_landmarks:
+        mp_drawing.draw_landmarks(frame, results.pose_landmarks, mp_pose.POSE_CONNECTIONS)
+
+    # Display the resulting frame
+    cv2.imshow("Pose Detection", frame)
+
+    # Exit on 'q' key press
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# Release resources
+cap.release()
+cv2.destroyAllWindows()

untitled2.py

@@ -0,0 +1,106 @@
+import cv2
+import numpy as np
+from skimage import exposure, filters
+from scipy.ndimage import gaussian_filter
+
+def adjust_brightness_contrast(image, beta=50, alpha=1.5):
+    """افزایش روشنایی و کنتراست تصویر"""
+    return cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
+
+def gamma_correction(image, gamma=2.0):
+    """تصحیح گاما برای تنظیم روشنایی و کنتراست کلی"""
+    yuv_image = cv2.cvtColor(image, cv2.COLOR_BGR2YUV)
+    yuv_image[..., 0] = np.clip(np.power(yuv_image[..., 0] / 255.0, gamma) * 255.0, 0, 255).astype(np.uint8)
+    return cv2.cvtColor(yuv_image, cv2.COLOR_YUV2BGR)
+
+def apply_clahe(image):
+    """اعمال CLAHE برای بهبود کنتراست محلی"""
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+    clahe_image = clahe.apply(gray_image)
+    return cv2.cvtColor(clahe_image, cv2.COLOR_GRAY2BGR)
+
+def convert_to_hsv(image):
+    """تبدیل تصویر به فضای رنگی HSV و افزایش روشنایی"""
+    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+    hsv_image[..., 2] = cv2.convertScaleAbs(hsv_image[..., 2], alpha=1.5, beta=30)
+    return cv2.cvtColor(hsv_image, cv2.COLOR_HSV2BGR)
+
+def enhance_details(image):
+    """افزایش جزئیات با استفاده از فیلتر شارپنینگ"""
+    kernel = np.array([[0, -1, 0],
+                       [-1, 5, -1],
+                       [0, -1, 0]])
+    sharpened_image = cv2.filter2D(image, -1, kernel)
+    return sharpened_image
+
+def noise_reduction(image):
+    """کاهش نویز با استفاده از فیلتر وینزر"""
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    denoised_image = cv2.fastNlMeansDenoising(gray_image, None, h=10, templateWindowSize=7, searchWindowSize=21)
+    return cv2.cvtColor(denoised_image, cv2.COLOR_GRAY2BGR)
+
+def enhance_contrast(image):
+    """افزایش کنتراست با استفاده از تکنیک‌های پیشرفته"""
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    equalized_image = exposure.equalize_hist(gray_image)
+    return cv2.cvtColor((exposure.rescale_intensity(equalized_image, out_range=(0, 255))).astype(np.uint8), cv2.COLOR_GRAY2BGR)
+
+def improve_low_light(image):
+    """بهبود تصویر در شرایط نور کم"""
+    # مرحله 1: افزایش روشنایی اولیه
+    bright_image = adjust_brightness_contrast(image, beta=50, alpha=1.5)
+    
+    # مرحله 2: تصحیح گاما
+    gamma_corrected_image = gamma_correction(bright_image, gamma=2.0)
+    
+    # مرحله 3: افزایش کنتراست با CLAHE
+    clahe_image = apply_clahe(gamma_corrected_image)
+    
+    # مرحله 4: تبدیل به فضای رنگی HSV و افزایش روشنایی
+    hsv_image = convert_to_hsv(clahe_image)
+    
+    # مرحله 5: افزایش جزئیات با فیلتر شارپنینگ
+    detailed_image = enhance_details(hsv_image)
+    
+    # مرحله 6: کاهش نویز (اگر نیاز باشد)
+    # denoised_image = noise_reduction(detailed_image)
+    
+    # مرحله 7: افزایش کنتراست نهایی
+    final_image = enhance_contrast(detailed_image)
+    
+    return final_image
+
+def main():
+    """اتصال به دوربین و نمایش تصویر بهبود یافته"""
+    cap = cv2.VideoCapture(0)
+
+    if not cap.isOpened():
+        print("خطا: دوربین باز نشد!")
+        return
+
+    while True:
+        # خواندن فریم از دوربین
+        ret, frame = cap.read()
+
+        if not ret:
+            print("خطا: نمی‌توان فریم را خواند!")
+            break
+
+        # بهبود تصویر در شرایط نور کم
+        improved_frame = improve_low_light(frame)
+
+        # نمایش تصویر اصلی و تصویر بهبود یافته
+        cv2.imshow('Original Frame', frame)
+        cv2.imshow('Improved Frame', improved_frame)
+
+        # خروج از برنامه با فشار دادن کلید 'q'
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    # آزادسازی منابع و بستن پنجره‌ها
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

untitled20.py

@@ -0,0 +1,44 @@
+import cv2
+import mediapipe as mp
+
+# Initialize Mediapipe Pose and Drawing modules
+mp_pose = mp.solutions.pose
+mp_drawing = mp.solutions.drawing_utils
+
+# Set up pose detection
+pose = mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5)
+
+# Initialize camera
+cap = cv2.VideoCapture(0)
+
+while cap.isOpened():
+    ret, frame = cap.read()
+    if not ret:
+        break
+
+    # Flip the frame horizontally for a later selfie-view display
+    frame = cv2.flip(frame, 1)
+    # Convert the BGR image to RGB
+    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    # Process the frame and get pose landmarks
+    results = pose.process(rgb_frame)
+
+    # Draw landmarks on the frame
+    if results.pose_landmarks:
+        mp_drawing.draw_landmarks(frame, results.pose_landmarks, mp_pose.POSE_CONNECTIONS)
+
+        # Access and print the 3D landmarks
+        landmarks = results.pose_landmarks.landmark
+        for i, landmark in enumerate(landmarks):
+            print(f"Landmark {i}: x={landmark.x}, y={landmark.y}, z={landmark.z}")
+
+    # Display the frame
+    cv2.imshow('Pose Detection', frame)
+
+    # Break the loop if 'q' is pressed
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# Release resources
+cap.release()
+cv2.destroyAllWindows()

untitled21.py

@@ -0,0 +1,53 @@
+import cv2
+import numpy as np
+
+def detect_anomalies(frame1, frame2):
+    # Convert images to grayscale
+    gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
+    gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
+    
+    # Compute the absolute difference between the two images
+    diff = cv2.absdiff(gray1, gray2)
+    
+    # Threshold the difference to get binary image
+    _, thresh = cv2.threshold(diff, 50, 255, cv2.THRESH_BINARY)
+    
+    # Find contours of the anomalies
+    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    # Draw contours on the original frame
+    for contour in contours:
+        if cv2.contourArea(contour) > 500:  # Filter small contours
+            x, y, w, h = cv2.boundingRect(contour)
+            cv2.rectangle(frame1, (x, y), (x+w, y+h), (0, 255, 0), 2)
+    
+    return frame1
+
+# Initialize video capture (0 is usually the default camera)
+cap = cv2.VideoCapture(0)
+
+# Read the first frame to initialize the previous frame
+ret, prev_frame = cap.read()
+
+while True:
+    # Read the current frame
+    ret, curr_frame = cap.read()
+    if not ret:
+        break
+    
+    # Detect anomalies between previous and current frame
+    result_frame = detect_anomalies(prev_frame, curr_frame)
+    
+    # Display the result
+    cv2.imshow('Anomalies Detected', result_frame)
+    
+    # Update previous frame
+    prev_frame = curr_frame
+    
+    # Exit on 'q' key press
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# Release video capture and close windows
+cap.release()
+cv2.destroyAllWindows()

untitled22.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Aug  4 16:08:30 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+import numpy as np
+
+def detect_anomalies(frame1, frame2, min_contour_area=1, threshold_value=7):
+    """
+    Detects anomalies between two frames and highlights them.
+
+    Parameters:
+    - frame1: The previous frame.
+    - frame2: The current frame.
+    - min_contour_area: Minimum area for a contour to be considered an anomaly.
+    - threshold_value: Threshold value for binary conversion.
+
+    Returns:
+    - The frame with anomalies highlighted.
+    """
+    # Convert images to grayscale
+    gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
+    gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
+    
+    # Compute the absolute difference between the two images
+    diff = cv2.absdiff(gray1, gray2)
+    
+    # Apply GaussianBlur to reduce noise and improve thresholding
+    blurred = cv2.GaussianBlur(diff, (5, 5), 0)
+    
+    # Threshold the difference to get a binary image
+    _, thresh = cv2.threshold(blurred, threshold_value, 255, cv2.THRESH_BINARY)
+    
+    # Find contours of the anomalies
+    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    # Draw contours on the original frame
+    for contour in contours:
+        if cv2.contourArea(contour) > min_contour_area:  # Filter small contours
+            x, y, w, h = cv2.boundingRect(contour)
+            cv2.rectangle(frame1, (x, y), (x+w, y+h), (0, 255, 0), 1)
+    
+    return frame1
+
+def main():
+    # Initialize video capture (0 is usually the default camera)
+    cap = cv2.VideoCapture(0)
+
+    # Check if the camera opened successfully
+    if not cap.isOpened():
+        print("Error: Could not open video capture.")
+        return
+
+    # Read the first frame to initialize the previous frame
+    ret, prev_frame = cap.read()
+    if not ret:
+        print("Error: Could not read initial frame.")
+        cap.release()
+        return
+
+    while True:
+        # Read the current frame
+        ret, curr_frame = cap.read()
+        if not ret:
+            print("Error: Could not read frame.")
+            break
+        
+        # Detect anomalies between previous and current frame
+        result_frame = detect_anomalies(prev_frame, curr_frame)
+        
+        # Display the result
+        cv2.imshow('Anomalies Detected', result_frame)
+        
+        # Update previous frame
+        prev_frame = curr_frame
+        
+        # Exit on 'q' key press
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    # Release video capture and close windows
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

untitled23.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Aug  4 16:11:43 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+import numpy as np
+
+def detect_anomalies(frame1, frame2, min_contour_area=1, threshold_value=8, blur_ksize=(5, 5)):
+    """
+    Detects anomalies between two frames with high sensitivity.
+
+    Parameters:
+    - frame1: The previous frame.
+    - frame2: The current frame.
+    - min_contour_area: Minimum area for a contour to be considered an anomaly.
+    - threshold_value: Threshold value for binary conversion.
+    - blur_ksize: Kernel size for Gaussian blur.
+
+    Returns:
+    - The frame with anomalies highlighted.
+    """
+    # Convert images to grayscale
+    gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
+    gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
+    
+    # Compute the absolute difference between the two images
+    diff = cv2.absdiff(gray1, gray2)
+    
+    # Apply GaussianBlur to reduce noise and improve thresholding
+    blurred = cv2.GaussianBlur(diff, blur_ksize, 0)
+    
+    # Threshold the difference to get a binary image
+    _, thresh = cv2.threshold(blurred, threshold_value, 255, cv2.THRESH_BINARY)
+    
+    # Find contours of the anomalies
+    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    # Draw contours on the original frame
+    for contour in contours:
+        if cv2.contourArea(contour) > min_contour_area:  # Filter small contours
+            x, y, w, h = cv2.boundingRect(contour)
+            cv2.rectangle(frame1, (x, y), (x+w, y+h), (0, 255, 0), 1)
+    
+    return frame1
+
+def main():
+    # Initialize video capture (0 is usually the default camera)
+    cap = cv2.VideoCapture(0)
+
+    # Check if the camera opened successfully
+    if not cap.isOpened():
+        print("Error: Could not open video capture.")
+        return
+
+    # Read the first frame to initialize the previous frame
+    ret, prev_frame = cap.read()
+    if not ret:
+        print("Error: Could not read initial frame.")
+        cap.release()
+        return
+
+    while True:
+        # Read the current frame
+        ret, curr_frame = cap.read()
+        if not ret:
+            print("Error: Could not read frame.")
+            break
+        
+        # Detect anomalies between previous and current frame
+        result_frame = detect_anomalies(prev_frame, curr_frame)
+        
+        # Display the result
+        cv2.imshow('Anomalies Detected', result_frame)
+        
+        # Update previous frame
+        prev_frame = curr_frame
+        
+        # Exit on 'q' key press
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    # Release video capture and close windows
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

untitled3.py

@@ -0,0 +1,87 @@
+import cv2
+import numpy as np
+from skimage import exposure, filters
+
+def adjust_brightness_contrast_gray(image, alpha=2.0, beta=50):
+    """افزایش روشنایی و کنتراست تصویر خاکستری"""
+    return cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
+
+def gamma_correction_gray(image, gamma=2.0):
+    """تصحیح گاما برای تنظیم روشنایی و کنتراست کلی در تصاویر خاکستری"""
+    image = image / 255.0
+    image = np.power(image, gamma)
+    return (image * 255).astype(np.uint8)
+
+def apply_clahe_gray(image):
+    """اعمال CLAHE برای بهبود کنتراست محلی در تصاویر خاکستری"""
+    clahe = cv2.createCLAHE(clipLimit=8.0, tileGridSize=(1, 1))
+    clahe_image = clahe.apply(image)
+    return clahe_image
+
+def enhance_details_gray(image):
+    """افزایش جزئیات با استفاده از فیلتر شارپنینگ در تصاویر خاکستری"""
+    kernel = np.array([[0, -1, 0],
+                       [-1, 5, -1],
+                       [0, -1, 0]])
+    sharpened_image = cv2.filter2D(image, -1, kernel)
+    return sharpened_image
+
+def reduce_noise_gray(image):
+    """کاهش نویز با استفاده از فیلتر نهایی"""
+    return cv2.fastNlMeansDenoising(image, None, h=10, templateWindowSize=7, searchWindowSize=21)
+
+def improve_low_light_gray(image):
+    """بهبود تصویر خاکستری در شرایط نور کم"""
+    # مرحله 1: افزایش روشنایی و کنتراست اولیه
+    bright_image = adjust_brightness_contrast_gray(image, alpha=5.0, beta=10)
+    
+    # مرحله 2: تصحیح گاما
+    gamma_corrected_image = gamma_correction_gray(bright_image, gamma=1.0)
+    
+    # مرحله 3: افزایش کنتراست با CLAHE
+    clahe_image = apply_clahe_gray(gamma_corrected_image)
+    
+    # مرحله 4: افزایش جزئیات با فیلتر شارپنینگ
+    detailed_image = enhance_details_gray(clahe_image)
+    
+    # مرحله 5: کاهش نویز
+    denoised_image = reduce_noise_gray(detailed_image)
+    
+    return denoised_image
+
+def main():
+    """اتصال به دوربین و نمایش تصویر بهبود یافته"""
+    cap = cv2.VideoCapture(0)
+
+    if not cap.isOpened():
+        print("خطا: دوربین باز نشد!")
+        return
+
+    while True:
+        # خواندن فریم از دوربین
+        ret, frame = cap.read()
+
+        if not ret:
+            print("خطا: نمی‌توان فریم را خواند!")
+            break
+
+        # تبدیل فریم به خاکستری
+        gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+        # بهبود تصویر خاکستری در شرایط نور کم
+        improved_frame = improve_low_light_gray(gray_frame)
+
+        # نمایش تصویر اصلی و تصویر بهبود یافته
+        cv2.imshow('Original Frame', gray_frame)
+        cv2.imshow('Improved Frame', improved_frame)
+
+        # خروج از برنامه با فشار دادن کلید 'q'
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    # آزادسازی منابع و بستن پنجره‌ها
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

untitled4.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Aug  3 19:32:54 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+import numpy as np
+from skimage import exposure
+
+def adjust_brightness_contrast(image, alpha=2.0, beta=50):
+    """افزایش روشنایی و کنتراست تصویر"""
+    return cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
+
+def gamma_correction(image, gamma=2.0):
+    """تصحیح گاما برای تنظیم روشنایی و کنتراست کلی"""
+    image = image / 255.0
+    image = np.power(image, gamma)
+    return (image * 255).astype(np.uint8)
+
+def apply_clahe(image):
+    """اعمال CLAHE برای بهبود کنتراست محلی"""
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    return clahe.apply(image)
+
+def enhance_low_light(image):
+    """بهبود تصویر در شرایط کم‌نور"""
+    # مرحله 1: تبدیل به خاکستری
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    # مرحله 2: افزایش روشنایی و کنتراست
+    bright_contrast_image = adjust_brightness_contrast(gray_image, alpha=1.5, beta=70)
+    
+    # مرحله 3: تصحیح گاما
+    gamma_corrected_image = gamma_correction(bright_contrast_image, gamma=5)
+    
+    # مرحله 4: افزایش کنتراست محلی با CLAHE
+    clahe_image = apply_clahe(gamma_corrected_image)
+    
+    return clahe_image
+
+def main():
+    """اتصال به دوربین و نمایش تصویر بهبود یافته"""
+    cap = cv2.VideoCapture(0)
+
+    if not cap.isOpened():
+        print("خطا: دوربین باز نشد!")
+        return
+
+    while True:
+        # خواندن فریم از دوربین
+        ret, frame = cap.read()
+
+        if not ret:
+            print("خطا: نمی‌توان فریم را خواند!")
+            break
+
+        # بهبود تصویر در شرایط کم‌نور
+        improved_frame = enhance_low_light(frame)
+
+        # نمایش تصویر اصلی و تصویر بهبود یافته
+        cv2.imshow('Original Frame', cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY))
+        cv2.imshow('Improved Frame', improved_frame)
+
+        # خروج از برنامه با فشار دادن کلید 'q'
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    # آزادسازی منابع و بستن پنجره‌ها
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

untitled6.py

@@ -0,0 +1,53 @@
+import cv2
+import numpy as np
+
+def main():
+    # ایجاد شیء VideoCapture برای دسترسی به دوربین
+    cap = cv2.VideoCapture(0)
+
+    # ایجاد مدل پس‌زمینه با استفاده از MOG2
+    backSub = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=16, detectShadows=True)
+
+    if not cap.isOpened():
+        print("خطا در باز کردن دوربین")
+        return
+
+    while True:
+        # خواندن فریم از دوربین
+        ret, frame = cap.read()
+
+        if not ret:
+            print("خطا در خواندن فریم")
+            break
+
+        # پردازش تصویر با مدل پس‌زمینه
+        fgMask = backSub.apply(frame)
+
+        # استفاده از فیلتر مورفولوژیکی برای بهبود نتایج
+        kernel = np.ones((5, 5), np.uint8)
+        fgMask = cv2.morphologyEx(fgMask, cv2.MORPH_CLOSE, kernel)
+        fgMask = cv2.morphologyEx(fgMask, cv2.MORPH_OPEN, kernel)
+
+        # پیدا کردن کانتورهای موجود در تصویر باینری
+        contours, _ = cv2.findContours(fgMask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        # کشیدن مربع دور هر کانتور
+        for contour in contours:
+            if cv2.contourArea(contour) > 500:  # برای فیلتر کردن کوچکترین کانتورها
+                x, y, w, h = cv2.boundingRect(contour)
+                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+
+        # نمایش فریم اصلی و ماسک پس‌زمینه
+        cv2.imshow('Frame', frame)
+        cv2.imshow('Foreground Mask', fgMask)
+
+        # خروج از حلقه با فشار دادن کلید 'q'
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    # آزادسازی منابع
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

untitled7.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Aug  3 21:01:48 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+import numpy as np
+
+def main():
+    # ایجاد شیء VideoCapture برای دسترسی به دوربین
+    cap = cv2.VideoCapture(0)
+
+    # ایجاد مدل پس‌زمینه با استفاده از KNN
+    backSub = cv2.createBackgroundSubtractorKNN(history=500, dist2Threshold=400.0, detectShadows=True)
+
+    if not cap.isOpened():
+        print("خطا در باز کردن دوربین")
+        return
+
+    while True:
+        # خواندن فریم از دوربین
+        ret, frame = cap.read()
+
+        if not ret:
+            print("خطا در خواندن فریم")
+            break
+
+        # پردازش تصویر با مدل پس‌زمینه
+        fgMask = backSub.apply(frame)
+
+        # استفاده از فیلترهای مورفولوژیکی برای بهبود نتایج
+        kernel = np.ones((5, 5), np.uint8)
+        fgMask = cv2.morphologyEx(fgMask, cv2.MORPH_CLOSE, kernel)
+        fgMask = cv2.morphologyEx(fgMask, cv2.MORPH_OPEN, kernel)
+        
+        # استفاده از فیلتر گوسی برای کاهش نویز
+        blurred = cv2.GaussianBlur(fgMask, (5, 5), 0)
+
+        # پیدا کردن کانتورهای موجود در تصویر باینری
+        contours, _ = cv2.findContours(blurred, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        # کشیدن مربع دور هر کانتور
+        for contour in contours:
+            if cv2.contourArea(contour) > 500:  # برای فیلتر کردن کوچکترین کانتورها
+                x, y, w, h = cv2.boundingRect(contour)
+                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+
+        # نمایش فریم اصلی و ماسک پس‌زمینه
+        cv2.imshow('Frame', frame)
+        cv2.imshow('Foreground Mask', fgMask)
+
+        # خروج از حلقه با فشار دادن کلید 'q'
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    # آزادسازی منابع
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

untitled9.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Aug  3 21:01:48 2024
+
+@author: ysnrfd
+"""
+
+import cv2
+import numpy as np
+
+def main():
+    # Initialize video capture
+    cap = cv2.VideoCapture(0)
+
+    # Create background subtractor with KNN
+    backSub = cv2.createBackgroundSubtractorKNN(history=500, dist2Threshold=.512, detectShadows=True)
+
+    if not cap.isOpened():
+        print("Error: Unable to open camera.")
+        return
+
+    try:
+        while True:
+            # Read frame from the camera
+            ret, frame = cap.read()
+
+            if not ret:
+                print("Error: Unable to read frame.")
+                break
+
+            # Apply background subtraction
+            fgMask = backSub.apply(frame)
+
+            # Apply morphological operations
+            kernel = np.ones((5, 5), np.uint8)
+            fgMask = cv2.morphologyEx(fgMask, cv2.MORPH_CLOSE, kernel)
+            fgMask = cv2.morphologyEx(fgMask, cv2.MORPH_OPEN, kernel)
+
+            # Apply Gaussian blur to reduce noise
+            blurred = cv2.GaussianBlur(fgMask, (5, 5), 0)
+
+            # Find contours
+            contours, _ = cv2.findContours(blurred, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+            # Draw bounding boxes around detected objects
+            for contour in contours:
+                if cv2.contourArea(contour) > 500:  # Filter out small contours
+                    x, y, w, h = cv2.boundingRect(contour)
+                    cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+
+            # Display the results
+            cv2.imshow('Frame', frame)
+            cv2.imshow('Foreground Mask', fgMask)
+
+            # Exit loop if 'q' is pressed
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                break
+
+    finally:
+        # Release resources
+        cap.release()
+        cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()