use std::path::PathBuf;
use oxigaf::prelude::*;
fn parse_args() -> PathBuf {
let args: Vec<String> = std::env::args().collect();
for (i, arg) in args.iter().enumerate() {
if arg == "--model-dir" {
if let Some(path) = args.get(i + 1) {
return PathBuf::from(path);
}
}
}
PathBuf::from("data/flame_model")
}
fn main() -> oxigaf::Result<()> {
let model_dir = parse_args();
println!("OxiGAF Basic FLAME Example");
println!("==========================");
println!();
println!("Loading FLAME model from: {}", model_dir.display());
let model = match FlameModel::load(&model_dir) {
Ok(m) => {
println!(
"Model loaded successfully: {} vertices, {} faces",
m.num_vertices(),
m.faces.len()
);
m
}
Err(e) => {
eprintln!("Error loading FLAME model: {}", e);
eprintln!();
eprintln!("To run this example, you need FLAME model files:");
eprintln!(" 1. Download FLAME from https://flame.is.tue.mpg.de/");
eprintln!(" 2. Convert using: python scripts/convert_flame.py");
eprintln!(" 3. Run with: cargo run --example basic_flame -- --model-dir /path/to/converted/model");
eprintln!();
eprintln!("Alternatively, running in demo mode with synthetic data...");
demonstrate_api_without_model();
return Ok(());
}
};
println!();
println!("Creating FLAME parameters...");
let neutral_params = FlameParams::neutral();
println!(" Created neutral parameters");
let smiling_params = FlameParams::builder()
.shape(vec![0.5, -0.2, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
.expression(vec![0.8, 0.3, -0.1, 0.0, 0.0])
.root_rotation([0.1, 0.0, 0.05])
.jaw_rotation(0.08)
.translation([0.0, -0.05, 0.0])
.build();
println!(" Created smiling expression parameters");
if smiling_params.validate() {
println!(" Parameters validated: within typical ranges");
} else {
println!(" Warning: Some parameters outside typical ranges");
}
println!();
println!("Running FLAME forward pass...");
let neutral_mesh = model.forward(&neutral_params);
println!(
" Neutral mesh: {} vertices, {} faces",
neutral_mesh.vertices.len(),
neutral_mesh.faces.len()
);
let smiling_mesh = model.forward(&smiling_params);
println!(
" Smiling mesh: {} vertices, {} faces",
smiling_mesh.vertices.len(),
smiling_mesh.faces.len()
);
let max_displacement = neutral_mesh
.vertices
.iter()
.zip(smiling_mesh.vertices.iter())
.map(|(n, s)| {
let dx = s.x - n.x;
let dy = s.y - n.y;
let dz = s.z - n.z;
(dx * dx + dy * dy + dz * dz).sqrt()
})
.fold(0.0f32, f32::max);
println!(" Max vertex displacement: {:.4} units", max_displacement);
println!();
println!("Rendering normal maps...");
let camera = Camera::default_front(512, 512);
println!(
" Camera: {}x{}, focal={:.1}",
camera.width, camera.height, camera.focal_x
);
let neutral_normal_map = NormalMapRenderer::render(&neutral_mesh, &camera);
let smiling_normal_map = NormalMapRenderer::render(&smiling_mesh, &camera);
println!(" Rendered normal maps: {}x{}", camera.width, camera.height);
println!();
println!("Saving output images...");
let output_dir = std::env::temp_dir().join("oxigaf_examples");
if let Err(e) = std::fs::create_dir_all(&output_dir) {
eprintln!("Warning: Could not create output directory: {}", e);
}
let neutral_path = output_dir.join("normal_map_neutral.png");
let smiling_path = output_dir.join("normal_map_smiling.png");
match neutral_normal_map.save(&neutral_path) {
Ok(()) => println!(" Saved neutral normal map: {}", neutral_path.display()),
Err(e) => eprintln!(" Error saving neutral image: {}", e),
}
match smiling_normal_map.save(&smiling_path) {
Ok(()) => println!(" Saved smiling normal map: {}", smiling_path.display()),
Err(e) => eprintln!(" Error saving smiling image: {}", e),
}
println!();
println!("Example completed successfully!");
println!();
println!("Key takeaways:");
println!(" - FlameModel::load() loads model from .npy files");
println!(" - FlameParams::builder() provides type-safe parameter construction");
println!(" - model.forward(¶ms) generates posed mesh via LBS");
println!(" - NormalMapRenderer::render() creates normal map images");
println!();
println!("Output files saved to: {}", output_dir.display());
Ok(())
}
fn demonstrate_api_without_model() {
println!();
println!("API Demonstration (without model files)");
println!("=======================================");
println!();
println!("1. Creating neutral parameters:");
let neutral = FlameParams::neutral();
println!(
" Shape: {} coefficients, Expression: {} coefficients",
neutral.shape.len(),
neutral.expression.len()
);
println!(
" Pose: {} values (5 joints x 3 axis-angle)",
neutral.pose.len()
);
println!(" Translation: {:?}", neutral.translation);
println!();
println!("2. Using FlameParamsBuilder:");
let params = FlameParams::builder()
.shape(vec![1.0, -0.5, 0.3])
.expression(vec![0.8, 0.2])
.jaw_rotation(0.15)
.left_eye_rotation([0.1, 0.0, 0.0])
.translation([0.0, 0.1, 0.0])
.build();
println!(
" Built params with {} shape, {} expression coefficients",
params.shape.len(),
params.expression.len()
);
println!();
println!("3. Parameter validation:");
if params.validate() {
println!(" Parameters are within typical ranges");
}
println!();
println!("4. Accessing joint poses:");
for joint_idx in 0..FlameParams::NUM_JOINTS {
let joint_name = match joint_idx {
0 => "Root",
1 => "Neck",
2 => "Jaw",
3 => "Left Eye",
4 => "Right Eye",
_ => "Unknown",
};
let pose = params.joint_pose(joint_idx);
println!(
" {}: [{:.3}, {:.3}, {:.3}]",
joint_name, pose[0], pose[1], pose[2]
);
}
println!();
println!("To run with actual model files, see the prerequisites in the example source.");
}