In Python, image processing unlocks powerful capabilities for computer vision, data augmentation, and automation—master these techniques to excel in ML engineering interviews and real-world applications! 🖼 

# PIL/Pillow Basics - The essential image library
from PIL import Image

# Open and display image
img = Image.open("input.jpg")
img.show()

# Convert formats
img.save("output.png")
img.convert("L").save("grayscale.jpg")  # RGB to grayscale

# Basic transformations
img.rotate(90).save("rotated.jpg")
img.resize((300, 300)).save("resized.jpg")
img.transpose(Image.FLIP_LEFT_RIGHT).save("mirrored.jpg")

more explain: https://hackmd.io/@husseinsheikho/imageprocessing

#Python #ImageProcessing #ComputerVision #Pillow #OpenCV #MachineLearning #CodingInterview #DataScience #Programming #TechJobs #DeveloperTips #AI #DeepLearning #CloudComputing #Docker #BackendDevelopment #SoftwareEngineering #CareerGrowth #TechTips #Python3

#YOLOv8 #ComputerVision #TrafficManagement #Python #AI #SmartCity

Lesson: Detecting Traffic Congestion in Road Lanes with YOLOv8

This tutorial will guide you through building a system to monitor traffic on a highway from a video feed. We'll use YOLOv8 to detect vehicles and then define specific zones (lanes) to count the number of vehicles within them, determining if a lane is congested.

---

#Step 1: Project Setup and Dependencies

We need to install ultralytics for YOLOv8 and opencv-python for video and image processing. numpy is also essential for handling the coordinates of our detection zones.

pip install ultralytics opencv-python numpy

Create a Python script (e.g., traffic_monitor.py) and import the necessary libraries.

import cv2
import numpy as np
from ultralytics import YOLO

# Hashtags: #Setup #Python #OpenCV #YOLOv8

---

#Step 2: Model Loading and Lane Definition

We'll load a pre-trained YOLOv8 model, which is excellent at detecting common objects like cars, trucks, and buses. The most critical part of this step is defining the zones of interest (our lanes) as polygons on the video frame. You will need to adjust these coordinates to match the perspective of your specific video.

You will also need a video file, for example, traffic_video.mp4.

# Load a pre-trained YOLOv8 model (yolov8n.pt is small and fast)
model = YOLO('yolov8n.pt')

# Path to your video file
VIDEO_PATH = 'traffic_video.mp4'

# Define the polygons for two lanes.
# IMPORTANT: You MUST adjust these coordinates for your video's perspective.
# Each polygon is a numpy array of [x, y] coordinates.
LANE_1_POLYGON = np.array([[20, 400], [450, 400], [450, 250], [20, 250]], np.int32)
LANE_2_POLYGON = np.array([[500, 400], [980, 400], [980, 250], [500, 250]], np.int32)

# Define the congestion threshold. If vehicle count > this, the lane is congested.
CONGESTION_THRESHOLD = 10

# Hashtags: #Configuration #AIModel #SmartCity

---

#Step 3: Main Loop for Detection and Counting

This is the core of our program. We will loop through each frame of the video, run vehicle detection, and then check if the center of each detected vehicle falls inside our predefined lane polygons. We will keep a count for each lane.

cap = cv2.VideoCapture(VIDEO_PATH)

while cap.isOpened():
    success, frame = cap.read()
    if not success:
        break

    # Run YOLOv8 inference on the frame
    results = model(frame)

    # Initialize vehicle counts for each lane for the current frame
    lane_1_count = 0
    lane_2_count = 0

    # Process detection results
    for r in results:
        for box in r.boxes:
            # Check if the detected object is a vehicle
            class_id = int(box.cls[0])
            class_name = model.names[class_id]
            
            if class_name in ['car', 'truck', 'bus', 'motorbike']:
                # Get bounding box coordinates
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                
                # Calculate the center point of the bounding box
                center_x = (x1 + x2) // 2
                center_y = (y1 + y2) // 2

                # Check if the center point is inside Lane 1
                if cv2.pointPolygonTest(LANE_1_POLYGON, (center_x, center_y), False) >= 0:
                    lane_1_count += 1
                
                # Check if the center point is inside Lane 2
                elif cv2.pointPolygonTest(LANE_2_POLYGON, (center_x, center_y), False) >= 0:
                    lane_2_count += 1

# Hashtags: #RealTime #ObjectDetection #VideoProcessing

(Note: The code below should be placed inside the while loop of Step 3)

---

#Step 4: Visualization and Displaying Results

After counting the vehicles, we need to visualize the results on the video frame. We will draw the lane polygons, display the vehicle count for each, and change the lane's color to red if it is considered congested based on our threshold.

# --- Visualization --- (This code continues inside the while loop)

    # Draw the lane polygons on the frame
    cv2.polylines(frame, [LANE_1_POLYGON], isClosed=True, color=(255, 255, 0), thickness=2)
    cv2.polylines(frame, [LANE_2_POLYGON], isClosed=True, color=(255, 255, 0), thickness=2)

    # Check for congestion and display status for Lane 1
    if lane_1_count > CONGESTION_THRESHOLD:
        status_1 = "CONGESTED"
        color_1 = (0, 0, 255) # Red
    else:
        status_1 = "NORMAL"
        color_1 = (0, 255, 0) # Green
    
    cv2.putText(frame, f"Lane 1: {lane_1_count} ({status_1})", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, color_1, 2)

    # Check for congestion and display status for Lane 2
    if lane_2_count > CONGESTION_THRESHOLD:
        status_2 = "CONGESTED"
        color_2 = (0, 0, 255) # Red
    else:
        status_2 = "NORMAL"
        color_2 = (0, 255, 0) # Green

    cv2.putText(frame, f"Lane 2: {lane_2_count} ({status_2})", (530, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, color_2, 2)
    
    # Display the frame with detections and status
    cv2.imshow("Traffic Congestion Monitor", frame)

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

cap.release()
cv2.destroyAllWindows()

# Hashtags: #DataVisualization #OpenCV #TrafficFlow

---

#Step 5: Results and Discussion

When you run the script, a video window will appear. You will see:
• Yellow polygons outlining the defined lanes.
• Text at the top indicating the number of vehicles in each lane and its status ("NORMAL" or "CONGESTED").
• The status text and its color will change in real-time based on the vehicle count exceeding the CONGESTION_THRESHOLD.

Discussion of Results:
Threshold is Key: The CONGESTION_THRESHOLD is the most important variable to tune. A value of 10 might be too high for a short lane or too low for a long one. It must be calibrated based on the specific camera view and what is considered "congested" for that road.
Polygon Accuracy: The system's accuracy is highly dependent on how well you define the LANE_POLYGON coordinates. They must accurately map to the lanes in the video, accounting for perspective.
Limitations: This method only measures vehicle density (number of cars in an area). It does not measure traffic flow (vehicle speed). A lane could have many cars moving quickly (high density, but not congested) or a few stopped cars (low density, but very congested).
Potential Improvements:
Object Tracking: Implement an object tracker (like DeepSORT or BoT-SORT) to assign a unique ID to each car. This would allow you to calculate the average speed of vehicles within each lane, providing a much more reliable measure of congestion.
Time-Based Analysis: Analyze data over time. A lane that is consistently above the threshold for more than a minute is a stronger indicator of a traffic jam than a brief spike in vehicle count.

#ProjectComplete #AIforCities #Transportation

━━━━━━━━━━━━━━━
By: @CodeProgrammer ✨