Face Detection Project Part 1 - Image Detection

:information_source: Project Overview

• Difficulty Level: Intermediate
• Estimated Time: 2-3 hours
• Skills Practiced:
  • Working with OpenCV library
  • Image processing and manipulation
  • Understanding machine learning models (Haar Cascades)
  • Implementing face detection algorithms
  • Drawing shapes on images
  • Working with coordinates and loops

In this exciting project, you'll become a computer vision detective! We will build a Face Detector in OpenCV using the Haar Cascade Classifier. This is the same technology used in cameras to detect faces for autofocus! We will use trained data haarcascade_frontalface_default.xml from OpenCV: Open Source Computer Vision Library.

:dart: Project Roadmap

graph LR
    A[Phase 0: Setup] --> B[Phase 1: Import Libraries]
    B --> C[Phase 2: Load AI Model]
    C --> D[Phase 3: Process Image]
    D --> E[Phase 4: Detect Faces]
    E --> F[Phase 5: Display Results]
    
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#bbf,stroke:#333,stroke-width:2px
    style C fill:#bbf,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
    style E fill:#bbf,stroke:#333,stroke-width:2px
    style F fill:#9f9,stroke:#333,stroke-width:2px

Instructions: Follow the steps below

1. Click on the link: https://tinyurl.com/cc5nubj3
2. Download the P5_Face_Detector_template folder from Google Drive into your Program AI-2 folder.
3. Extract the folder and open the folder in VSCode.
4. For those without VSCode, please complete your exercise by following the guidelines here.

:bulb: Understanding Haar Cascades Think of Haar Cascades as a detective's handbook! Just like how you can recognize your friends' faces, the computer uses patterns it has learned from thousands of face images. The XML file contains these "face patterns" that help the computer spot faces!

To use face detection by Haar Cascade, there are 2 key requirements:

• Load trained data - The computer needs its "detective handbook" (the XML file)
• Process the image into grayscale - Black and white images are easier for the computer to analyze (like looking at shadows and shapes)

With these requirements fulfilled, Haar Cascade is able to detect the face in the image by giving the face coordinates which are starting point (x, y), width, and height - just like drawing a box around each face!

Phase 0: Prepare the Haar Cascades trained data

:warning: Important Setup Step! Make sure you download the XML file to the SAME folder as your Python files. If the file is in a different location, your program won't be able to find it!

1. Go to OpenCV: Open Source Computer Vision Library

2. Go to data > haarcascades

3. Download haarcascade_frontalface_default.xml in the project folder.

:white_check_mark: Checkpoint: You should now have the XML file in your project folder!

We will code in the image.py file to run the program.

Phase One: Import OpenCV

1. Import the OpenCV library as cv

# Import the computer vision library
import cv2 as cv

:bulb: Quick Reminder We use cv2 even though it's called OpenCV because that's the Python package name. The '2' doesn't mean version 2 - it's just how Python knows this library!

Phase 2: Load trained data

1. Load the trained data in haarcascade_frontalface_default.xml and store as variable trained_face_data

# Load the face detection model (our detective handbook!)
trained_face_data = cv.CascadeClassifier('haarcascade_frontalface_default.xml')

:warning: Common Error If you get an error saying "file not found", check that:

1. The XML file is in the same folder as your Python file
2. The filename is spelled correctly (it's quite long!)
3. You included the .xml extension

Phase 3: Image Processing for Detection

Now let's prepare our image for face detection! Think of this like adjusting a magnifying glass to see better.

1. Read the image of the outing.jpg file and store it as a variable img.

# Read the image file
img = cv.imread('outing.jpg')

2. Resize the image with the scale 0.2. (Can refer to Exercise C16)

# Make the image smaller (20% of original size) for faster processing
scale = 0.2
width = int(img.shape[1] * scale)
height = int(img.shape[0] * scale)
img = cv.resize(img, (width, height))

3. Convert the image to grayscale and store it as a variable gray_img. (Can refer to Exercise C16)

# Convert to black and white (grayscale)
gray_img = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

:bulb: Why Grayscale? Converting to grayscale is like looking at shadows - it helps the computer focus on shapes and patterns instead of being distracted by colors. This makes face detection much faster and more accurate!

:white_check_mark: Checkpoint: You now have a resized, grayscale image ready for face detection!

Phase 4: Face Detection

This is where the magic happens! Our AI detective will now search for faces in the image.

1. Detect faces using trained_face_data together with gray_img and stored as variable face_coordinates.

# Detect faces in the grayscale image
face_coordinates = trained_face_data.detectMultiScale(gray_img)

:bulb: Understanding detectMultiScale This function scans the image at different sizes (scales) to find faces. It returns a list of rectangles, where each rectangle contains a detected face!

2. Draw rectangles for each face using a for loop:
   1. Get the starting point, width and height of each face.
   2. Draw a green rectangle with thickness 2 for each face. (Can refer to Exercise C17)

# Draw a rectangle around each detected face
for (x, y, w, h) in face_coordinates:
    # x, y = top-left corner of the face
    # w = width of the face
    # h = height of the face
    cv.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
    # (0, 255, 0) = Green color in BGR format
    # 2 = thickness of the rectangle

:warning: Debugging Tip If no faces are detected:

• Check if the image file exists and is loaded correctly
• Try a different image with clear, front-facing faces
• Make sure the grayscale conversion worked properly
• Print len(face_coordinates) to see how many faces were found

Phase 5: Show image

Time to see your amazing face detection in action!

1. Keep showing the image with detected faces. (Can refer to Exercise C15)

# Display the image with face detection boxes
cv.imshow('Face Detector', img)

# Wait for any key to be pressed
cv.waitKey(0)

# Close all windows
cv.destroyAllWindows()

:bulb: Congratulations! You've just built your first AI-powered face detector! Press any key to close the window when you're done admiring your work.

:bug: Debugging Tips

Having trouble? Here are common issues and solutions:

:bulb: Best Practices

1. Always test with simple images first (1-2 faces)
2. Use print statements to debug (e.g., print(f"Found {len(face_coordinates)} faces"))
3. Save your work frequently
4. Comment your code to remember what each part does

Face Detection Project Part 2 - Video Detection

:information_source: Part 2 Overview

• Difficulty Level: Intermediate-Advanced
• Estimated Time: 1-2 hours
• New Skills: Real-time video processing, continuous detection, performance optimization

Ready to level up? In this project, we will advance our Face Detection from a single photo to live webcam video. You'll feel like you're building Instagram or Snapchat filters!

:emoji: Video Detection Roadmap

graph LR
    A[Import & Setup] --> B[Load Model]
    B --> C[Start Webcam]
    C --> D[Process Each Frame]
    D --> E[Detect & Draw]
    E --> F[Display Video]
    F --> G{Key Pressed?}
    G -->|No| D
    G -->|Yes 'Q'| H[Exit]
    
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
    style E fill:#bbf,stroke:#333,stroke-width:2px
    style H fill:#9f9,stroke:#333,stroke-width:2px

Instructions: Follow the steps below

1. Create a new file "video.py" in P5_Face_Detector_template folder
2. Refer to image.py to complete this project.
3. For those without VSCode, please complete your exercise by following the guidelines here.

We will code in the video.py file to run the program.

:warning: Webcam Permission When you run this program, your computer might ask for permission to use the webcam. Make sure to click "Allow" or your program won't work!

Phase One: Import OpenCV

1. Import the OpenCV library as cv

import cv2 as cv

Phase 2: Load trained data

1. Load the trained data in haarcascade_frontalface_default.xml and store as variable trained_face_data

trained_face_data = cv.CascadeClassifier('haarcascade_frontalface_default.xml')

Phase 3: Capture video by webcam

Now for the exciting part - turning on your webcam!

1. Capture the video by the webcam and store as a variable video.

# Start the webcam (0 means default camera)
video = cv.VideoCapture(0)

:bulb: Camera Selection

• Use 0 for your default camera (usually built-in webcam)
• Use 1 if you have an external camera connected
• If the camera doesn't work, try different numbers

We will use a while loop from Phase 4 to 6 for capturing every frame from the video.

:white_check_mark: Checkpoint: Your webcam should now be initialized and ready to capture frames!

Phase 4: Video Processing for Detection

Start your infinite loop here! This will keep running until you press 'Q'.

while True:

1. Read the frame of the video.

    # Capture a single frame from the video
    success, frame = video.read()
    
    # Check if frame was captured successfully
    if not success:
        break

2. Convert the frame to grayscale and store as gray_img.

    # Convert frame to grayscale for face detection
    gray_img = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)

Phase 5: Face Detection

1. Detect faces using trained_face_data and store as variable face_coordinates.

    # Detect faces in the current frame
    face_coordinates = trained_face_data.detectMultiScale(gray_img)

2. Draw rectangles for each face using a for loop:
   1. Get the starting point, width and height of each face.
   2. Draw a green rectangle with thickness 2 for each face.

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

Phase 6: Show video

1. Keep showing video with detected faces.

    # Display the frame with face boxes
    cv.imshow('Live Face Detector', frame)

2. Stop the video when Q is pressed (Refer to Exercise C15).

    # Check if 'Q' key is pressed
    if cv.waitKey(1) & 0xFF == ord('q'):
        break

# Clean up when done
video.release()
cv.destroyAllWindows()

:bulb: You Did It! Your live face detector is now complete! Run the program and watch as it detects faces in real-time. Press 'Q' to quit when you're done.

:warning: Performance Tips If your video is laggy:

1. Make sure no other programs are using your camera
2. Close unnecessary applications
3. Try reducing the video window size
4. Check your lighting - better lighting = better detection!

:rocket: Extension Challenges

Congratulations on completing the face detector! Ready for more? Here are some exciting challenges to level up your skills:

Challenge One: Eye Detection (Intermediate)

We had successfully created a face detector. OpenCV can detect other objects as well such as eyes. Challenge yourself with using haarcascade_eye.xml to detect eyes on face.

Hints:

• Download haarcascade_eye.xml from the same OpenCV repository
• Detect eyes ONLY within detected face regions for better accuracy
• Use a different color rectangle for eyes (maybe blue?)

Challenge 2: Face Counter (Beginner)

Add a face counter to display how many faces are detected in real-time!

# Add this to your video loop
num_faces = len(face_coordinates)
cv.putText(frame, f'Faces: {num_faces}', (10, 30), 
           cv.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

Challenge 3: Smile Detection (Advanced)

Use haarcascade_smile.xml to detect when people are smiling!

Challenge 4: Fun Filters (Expert)

Instead of rectangles, try:

• Adding sunglasses overlay on detected eyes
• Drawing mustaches on detected faces
• Creating a blur effect on faces for privacy

Challenge 5: Performance Monitor (Intermediate)

Add FPS (Frames Per Second) counter to see how fast your detector runs:

import time
# Add before the loop
fps_start_time = time.time()
fps_counter = 0

# Inside the loop
fps_counter += 1
if time.time() - fps_start_time > 1:
    fps = fps_counter
    fps_counter = 0
    fps_start_time = time.time()

:bulb: Pro Tips for Challenges

1. Start with one challenge at a time
2. Save backup copies of your working code
3. Use different colors for different detections
4. Test with various lighting conditions
5. Share your creations with friends and family!

:books: What You've Learned

In this project, you've mastered:

• :white_check_mark: Loading and using pre-trained AI models
• :white_check_mark: Processing images for computer vision
• :white_check_mark: Real-time video processing
• :white_check_mark: Drawing shapes on images and video
• :white_check_mark: Creating interactive applications
• :white_check_mark: Understanding coordinate systems

These are the building blocks for amazing computer vision applications like:

• Snapchat/Instagram filters
• Security systems
• Photography auto-focus
• Virtual reality experiences
• And much more!

Keep experimenting and have fun with computer vision! :tada: