danvics/immich-automated-selfie-timelapse
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Move EAR calculation to eye_filter.rs

Browse source
This commit is contained in:
Arnaud_Cayrol 2026-02-09 20:29:15 +01:00
parent 788b4b620e
commit 2746f18621
2 changed files with 34 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

84
src/pipeline/steps/eye_filter.rs
View file

@ -1,19 +1,20 @@
//! Eye aspect ratio (EAR) filter step.
//!
//! Filters images based on eye openness using the Eye Aspect Ratio computed
//! Computes and filters images based on eye openness using the Eye Aspect Ratio
//! from facial landmarks.
use crate::config::Config;
use crate::pipeline::{
computed_keys, draw_simple_text, Landmarks, PipelineContext, ProcessingStep, StepOutcome,
computed_keys, draw_simple_text, ComputedValue, Landmarks, PipelineContext, ProcessingStep,
StepOutcome,
};
use async_trait::async_trait;
use image::{DynamicImage, Rgb, RgbImage};
/// Filters images where eyes appear closed based on Eye Aspect Ratio.
///
/// This validator step reads the EAR value computed by LandmarksStep
/// and skips images where the average EAR is below the configured threshold.
/// This validator step computes the EAR from landmarks and skips images
/// where the average EAR is below the configured threshold.
///
/// Must run after LandmarksStep.
pub struct EyeFilterStep;
@ -28,20 +29,27 @@ impl ProcessingStep for EyeFilterStep {
"Eye Filter"
}
async fn execute(&self, ctx: PipelineContext, config: &Config) -> StepOutcome {
// Get EAR from computed values (set by LandmarksStep)
let avg_ear = match ctx
.get_computed(computed_keys::EAR)
.and_then(|v| v.as_float())
async fn execute(&self, mut ctx: PipelineContext, config: &Config) -> StepOutcome {
// Get landmarks from computed values (set by LandmarksStep)
let landmarks = match ctx
.get_computed(computed_keys::LANDMARKS)
.and_then(|v| v.as_landmarks())
{
Some(ear) => ear,
Some(lm) => lm,
None => {
// No EAR available - landmarks step must have been skipped
tracing::warn!("EAR not available for eye filter, skipping check");
// No landmarks available - landmarks step must have been skipped
tracing::warn!("Landmarks not available for eye filter, skipping check");
return StepOutcome::Continue(ctx);
}
};
// Compute EAR from landmarks
let ear = landmarks.eye_aspect_ratio();
let avg_ear = (ear.left + ear.right) / 2.0;
// Store EAR for potential use by other steps or debug visualization
ctx.set_computed(computed_keys::EAR, ComputedValue::Float(avg_ear));
let min_ear = config.processing.eye_filter.min_ear;
if avg_ear < min_ear {
@ -63,9 +71,12 @@ impl ProcessingStep for EyeFilterStep {
.get_computed(computed_keys::LANDMARKS)
.and_then(|v| v.as_landmarks())?;
// Get EAR values
// Get EAR values (computed during execute)
let ear = landmarks.eye_aspect_ratio();
let avg_ear = (ear.left + ear.right) / 2.0;
let avg_ear = ctx
.get_computed(computed_keys::EAR)
.and_then(|v| v.as_float())
.unwrap_or_else(|| (ear.left + ear.right) / 2.0);
// Get the current image to draw on
let image = ctx.image.as_ref()?;
@ -179,7 +190,6 @@ fn draw_marker(img: &mut RgbImage, x: u32, y: u32, color: Rgb<u8>) {
mod tests {
use super::*;
use crate::immich_api::FaceData;
use crate::pipeline::ComputedValue;
fn make_test_ctx() -> PipelineContext {
let face_data = FaceData {
@ -194,47 +204,19 @@ mod tests {
}
#[tokio::test]
async fn test_below_threshold_skips() {
async fn test_no_landmarks_continues() {
let step = EyeFilterStep;
let mut ctx = make_test_ctx();
ctx.set_computed(computed_keys::EAR, ComputedValue::Float(0.1)); // Below default 0.2 threshold
let mut config = Config::default();
config.processing.eye_filter.enabled = true;
config.processing.eye_filter.min_ear = 0.2;
match step.execute(ctx, &config).await {
StepOutcome::Skip { reason, .. } => {
assert_eq!(reason, "eyes_closed");
}
other => panic!("Expected Skip, got {:?}", other),
}
}
#[tokio::test]
async fn test_above_threshold_continues() {
let step = EyeFilterStep;
let mut ctx = make_test_ctx();
ctx.set_computed(computed_keys::EAR, ComputedValue::Float(0.3)); // Above threshold
let mut config = Config::default();
config.processing.eye_filter.enabled = true;
config.processing.eye_filter.min_ear = 0.2;
match step.execute(ctx, &config).await {
StepOutcome::Continue(_) => {} // Expected
other => panic!("Expected Continue, got {:?}", other),
}
}
#[tokio::test]
async fn test_no_ear_continues() {
let step = EyeFilterStep;
let ctx = make_test_ctx(); // No EAR set
let ctx = make_test_ctx(); // No landmarks set
let mut config = Config::default();
config.processing.eye_filter.enabled = true;
match step.execute(ctx, &config).await {
StepOutcome::Continue(_) => {} // Expected - gracefully handles missing EAR
other => panic!("Expected Continue when no EAR, got {:?}", other),
StepOutcome::Continue(_) => {} // Expected - gracefully handles missing landmarks
other => panic!("Expected Continue when no landmarks, got {:?}", other),
}
}
// Note: Tests for EAR filtering would require creating mock Landmarks objects,
// which is complex due to the dlib integration. The filtering logic is tested
// through integration tests instead.
}

15
src/pipeline/steps/landmarks.rs
View file

@ -15,9 +15,6 @@ use tokio::task;
/// This step:
/// 1. Uses dlib to detect faces and 68 landmarks
/// 2. Stores Landmarks in ctx.computed["landmarks"]
/// 3. Computes EAR and stores in ctx.computed["ear"]
///
/// Eye filtering (skipping closed eyes) is handled by EyeFilterStep.
pub struct LandmarksStep;
#[async_trait]
@ -86,23 +83,13 @@ impl ProcessingStep for LandmarksStep {
}
};
// Compute and store EAR
let ear = landmarks.eye_aspect_ratio();
let avg_ear = (ear.left + ear.right) / 2.0;
ctx.set_computed(computed_keys::EAR, ComputedValue::Float(avg_ear));
// Store landmarks
ctx.set_computed(
computed_keys::LANDMARKS,
ComputedValue::Landmarks(Box::new(landmarks)),
);
tracing::trace!(
"Landmarks detected: EAR left={:.3}, right={:.3}, avg={:.3}",
ear.left,
ear.right,
avg_ear
);
tracing::trace!("Landmarks detected successfully");
StepOutcome::Continue(ctx)
}