Canine face - pain analysis

Analyzing Canine Facial Morphology for Pain Assessment Difficulty

Abstract

Assessing pain in dogs is challenging due to morphological variations across breeds that complicate standardized facial expression analysis. This project developed a pipeline using MediaPipe to analyze canine facial features, focusing on brachycephaly (snout length), hair occlusion around the eyes, and facial wrinkles. By processing a large dataset of dog images, we calculated “difficulty scores” for individual images and averaged them by breed to identify breeds where facial analysis for pain assessment is more challenging. The results offer a data-driven approach to understanding breed-specific variations, informing the development of robust automated pain assessment tools.

1. Introduction

Pain assessment in non-verbal species like dogs relies on behavioral and physiological indicators, with facial expressions being a promising metric (e.g., Glasgow Composite Pain Scale - Feline). However, diverse canine morphology, including extreme brachycephaly, excessive facial wrinkles, and hair occlusion around the eyes, obscures key facial landmarks, complicating consistent analysis. This project quantifies these morphological features using computer vision to identify breeds posing greater challenges for automated facial pain assessment.

2. Methodology

• 2.1 Data Collection and Preparation

  A dataset of dog images, organized by breed, was accessed from a specified image directory. A CSV file was generated listing each image’s path and corresponding breed.

import os
import pandas as pd

# Paths are configured here
IMAGE_DIR = '...' # Path to your image directory
OUTPUT_CSV_PATH = '...' # Path for the output CSV

image_data = []
for root, dirs, files in os.walk(IMAGE_DIR):
    for file in files:
        if file.lower().endswith('.jpg'):
            image_path = os.path.join(root, file)
            breed_name = os.path.basename(root)
            image_data.append({'image_path': image_path, 'breed': breed_name})

df = pd.DataFrame(image_data)
df.to_csv(OUTPUT_CSV_PATH, index=False)
print(f"Created '{os.path.basename(OUTPUT_CSV_PATH)}' with {len(df)} images.")

• 2.2 Facial Feature Analysis with MediaPipe

  MediaPipe’s Face Landmarker was used to detect facial landmarks in dog images, calculating three metrics: Brachycephaly Score (face width to snout length ratio), Hair Occlusion Score (edge density around eyes), and Wrinkle Score (edge density around the muzzle). A resumable processing loop handled large datasets, saving intermediate results to a CSV file.

import cv2
import math
import mediapipe as mp
from mediapipe.tasks import python
from mediapipe.tasks.python import vision
import pandas as pd
import numpy as np
import os
from tqdm.auto import tqdm

# Initialize detector and define scoring functions (details omitted for brevity)
# ... (detector initialization and get_brachy_score, get_hair_occlusion_score, get_wrinkle_score functions)

INPUT_METADATA_PATH = '...' # Path to metadata CSV
OUTPUT_SCORES_PATH = '...' # Path for output scores CSV
BATCH_SIZE = 100

# Resumable processing loop (details omitted for brevity)
# ... (loading data, checking for existing output, iterating through images, calculating scores, saving batches)

print("Phase 1 Complete! Scores CSV is ready.")

• 2.3 Difficulty Score Calculation and Breed Analysis

  Raw scores were normalized to a 0-1 scale, and a composite “difficulty score” was calculated by averaging the three normalized scores per image. Breed-specific difficulty scores were computed by averaging image scores per breed, with the top 5 easiest and hardest breeds saved to separate CSV files.

import pandas as pd
import numpy as np

# Paths are configured here
SCORES_CSV_PATH = '...' # Path to scores CSV
EASIEST_BREEDS_PATH = '...' # Path for easiest breeds CSV
HARDEST_BREEDS_PATH = '...' # Path for hardest breeds CSV

df = pd.read_csv(SCORES_CSV_PATH)
df.dropna(inplace=True)

# Normalize scores and calculate difficulty score (details omitted for brevity)
# ... (normalization and difficulty score calculation)

breed_difficulty = df.groupby('breed')['difficulty_score'].mean().sort_values()
easiest_breeds = breed_difficulty.head(5)
hardest_breeds = breed_difficulty.tail(5)

easiest_breeds.to_csv(EASIEST_BREEDS_PATH)
hardest_breeds.to_csv(HARDEST_BREEDS_PATH)

print("Phase 2 Complete! Key insights saved.")
print("\n--- Top 5 Hardest Breeds ---")
print(hardest_breeds)

• 2.4 Data Preparation for Application

  A final CSV file was created for application use, containing breed, public image URLs (generated from a Hugging Face dataset repository), and difficulty scores.

import pandas as pd
import numpy as np

# Configuration for Hugging Face dataset
HF_USERNAME = "..." # Your Hugging Face username
HF_DATASET_NAME = "..." # Your dataset name

# Path to scores CSV
SCORES_CSV_PATH = '...'

df = pd.read_csv(SCORES_CSV_PATH)
df.dropna(inplace=True)

# Calculate difficulty score if not already present (details omitted for brevity)
# ... (normalization and difficulty score calculation)

# Create public URLs and select columns (details omitted for brevity)
# ... (URL generation and column selection)

app_df.to_csv('...', index=False) # Path for app data CSV

print("Successfully created app_data.csv with public Hugging Face URLs!")

3. Results

The pipeline processed 20,104 dog images, with 2,074 successfully analyzed after removing rows with missing data. Difficulty scores were calculated based on brachycephaly, hair occlusion, and wrinkles, then averaged by breed. The top 5 hardest breeds for facial analysis were:

• Kelpie: 0.318842
• Whippet: 0.325176
• Afghan Hound: 0.335138
• Standard Schnauzer: 0.344147
• Kerry Blue Terrier: 0.385673

The resulting dataset, including normalized difficulty scores and public image URLs, is ready for applications like training breed-aware pain assessment models or creating interactive visualizations.

This is a prototype using Streamlit. Please click on the image.

4. Conclusion

This project quantifies how canine facial morphology impacts automated pain assessment, using MediaPipe to measure brachycephaly, hair occlusion, and wrinkles. The breed-specific difficulty scores highlight challenging breeds and provide a valuable resource for developing robust pain detection systems. Future work could validate these scores against expert assessments or integrate them into pain detection model training.

5. Next Steps

• Visualize the data: Create bar plots of breed difficulty or scatter plots of morphological scores.
• Build a demo application: Develop a web application or dashboard using app_data.csv to explore difficulty scores by breed.
• Validate scores: Compare difficulty scores with veterinary expert assessments.
• Integrate into pain detection models: Use difficulty scores to enhance model accuracy across breeds.
• Explore other features: Investigate additional facial features affecting analysis difficulty.

Source for dataset: Kaggle