How to detect eyes in an image using OpenCV Python?

Haar cascade classifiers are machine learning-based algorithms trained to detect specific objects in images. For eye detection, we use pre-trained cascades that identify eyes by analyzing patterns from thousands of positive (eye images) and negative (non-eye images) samples.

Eye detection requires two haar cascades: one for detecting faces first, then another for detecting eyes within those face regions. This two-step approach improves accuracy by limiting the search area.

Required Haar Cascade Files

Download these pre-trained cascade files from the OpenCV GitHub repository:

• haarcascade_frontalface_default.xml for face detection

• haarcascade_eye_tree_eyeglasses.xml for eye detection

Note: Save the XML files in your project directory or specify the full path when loading them.

Step-by-Step Process

The eye detection process follows these steps:

1. Load the input image and convert it to grayscale

2. Initialize face and eye cascade classifiers

3. Detect faces using detectMultiScale()

4. For each detected face, extract the region of interest (ROI)

5. Detect eyes within the face ROI

6. Draw bounding rectangles around detected eyes

Example

Here's a complete program to detect eyes in an image using OpenCV:

import cv2
import numpy as np

# Create a sample image with synthetic data for demonstration
# In practice, use: img = cv2.imread('your_image.jpg')
img = np.ones((400, 400, 3), dtype=np.uint8) * 255

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

# Load pre-trained haar cascade classifiers
# Note: You need to download these XML files from OpenCV GitHub
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')

# Detect faces in the image
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=4)
print('Number of detected faces:', len(faces))

# Process each detected face
for (x, y, w, h) in faces:
    # Extract face region of interest
    roi_gray = gray[y:y+h, x:x+w]
    roi_color = img[y:y+h, x:x+w]
    
    # Detect eyes within the face ROI
    eyes = eye_cascade.detectMultiScale(roi_gray, scaleFactor=1.1, minNeighbors=5)
    
    # Draw rectangles around detected eyes
    for (ex, ey, ew, eh) in eyes:
        cv2.rectangle(roi_color, (ex, ey), (ex+ew, ey+eh), (0, 255, 255), 2)

# Display results
print('Eye detection complete')
print('Use cv2.imshow() and cv2.waitKey() to display the image with detected eyes')

Number of detected faces: 0
Eye detection complete
Use cv2.imshow() and cv2.waitKey() to display the image with detected eyes

Real-World Implementation

For actual eye detection with image files, use this approach:

import cv2

def detect_eyes(image_path):
    # Read the input image
    img = cv2.imread(image_path)
    if img is None:
        print("Could not load image")
        return
    
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Load cascade classifiers
    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
    eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')
    
    # Detect faces
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    
    eye_count = 0
    for (x, y, w, h) in faces:
        roi_gray = gray[y:y+h, x:x+w]
        roi_color = img[y:y+h, x:x+w]
        
        # Detect eyes in face region
        eyes = eye_cascade.detectMultiScale(roi_gray)
        eye_count += len(eyes)
        
        # Draw rectangles around eyes
        for (ex, ey, ew, eh) in eyes:
            cv2.rectangle(roi_color, (ex, ey), (ex+ew, ey+eh), (0, 255, 0), 2)
    
    print(f"Detected {len(faces)} faces and {eye_count} eyes")
    
    # Save or display result
    cv2.imwrite('result.jpg', img)
    return img

# Usage example
# result = detect_eyes('path_to_your_image.jpg')

Key Parameters

The detectMultiScale() function accepts important parameters:

• scaleFactor: How much the image size is reduced at each scale (typically 1.1-1.3)

• minNeighbors: How many neighbors each detection needs to retain (higher = fewer false positives)

• minSize/maxSize: Minimum and maximum detection window size

Conclusion

Eye detection using OpenCV haar cascades involves detecting faces first, then searching for eyes within face regions. This two-step approach improves accuracy and reduces false positives compared to detecting eyes in the entire image.