use std::path::Path;
use oxigaf::prelude::*;
use oxigaf::render::gaussian::{GaussianAttributes, GaussianModel};
fn create_demo_model(num_gaussians: usize, sh_degree: u32) -> GaussianModel {
let mut gaussians = Vec::with_capacity(num_gaussians);
let sh_per = ((sh_degree + 1) * (sh_degree + 1) * 3) as usize;
let mut sh_coeffs = Vec::with_capacity(num_gaussians * sh_per);
let mut seed = 42u64;
let mut random_f32 = || -> f32 {
seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1);
((seed >> 32) as f32) / (u32::MAX as f32 / 2.0) - 1.0
};
for _ in 0..num_gaussians {
let x = random_f32() * 0.2;
let y = random_f32() * 0.2;
let z = random_f32() * 0.2;
let rx = random_f32() * 0.1;
let ry = random_f32() * 0.1;
let rz = random_f32() * 0.1;
let rw = 1.0;
gaussians.push(GaussianAttributes {
position: [x, y, z],
_pad0: 0.0,
rotation: [rx, ry, rz, rw],
scale: [-5.0, -5.0, -5.0], opacity: -2.0, });
for _ in 0..sh_per {
sh_coeffs.push(random_f32() * 0.5);
}
}
GaussianModel {
gaussians,
sh_coeffs,
sh_degree,
face_indices: vec![0; num_gaussians],
barycentric: vec![[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]; num_gaussians],
local_offsets: vec![[0.0, 0.0, 0.0]; num_gaussians],
is_rigid: vec![true; num_gaussians],
}
}
fn main() {
println!("OxiGAF Training Loop Example");
println!("============================");
println!();
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.with_target(false)
.init();
match pollster::block_on(run_training()) {
Ok(()) => {
println!();
println!("Example completed successfully!");
}
Err(e) => {
eprintln!("Error: {}", e);
std::process::exit(1);
}
}
}
async fn run_training() -> oxigaf::Result<()> {
println!("Configuring training...");
let training_config = TrainingConfig {
total_iterations: 100,
views_per_step: 2,
density_control_interval: 25,
density_control_start: 20,
density_control_end: 80,
opacity_reset_interval: 50,
checkpoint_interval: 50,
log_interval: 10,
guidance_scale_start: 7.5,
guidance_scale_end: 3.0,
guidance_anneal_steps: 100,
optimizer: OptimizerConfig::default(),
loss: LossConfig::default(),
density: DensityConfig::default(),
init: InitConfig {
num_rigid: 500, num_flexible: 500,
initial_scale: -5.0,
initial_opacity: -2.0,
sh_degree: 0, },
..Default::default()
};
if let Err(e) = training_config.validate() {
eprintln!("Invalid training config: {}", e);
return Err(oxigaf::OxigafError::Trainer(e));
}
println!(" Total iterations: {}", training_config.total_iterations);
println!(" Views per step: {}", training_config.views_per_step);
println!(
" Density control: {} - {} (every {})",
training_config.density_control_start,
training_config.density_control_end,
training_config.density_control_interval
);
println!();
println!("Creating initial Gaussian model...");
let num_initial = training_config.init.num_rigid + training_config.init.num_flexible;
let model = create_demo_model(num_initial, training_config.init.sh_degree);
println!(" {} Gaussians, SH degree {}", model.len(), model.sh_degree);
println!();
println!("Configuring rasterizer...");
let raster_config = RasterConfig::new()
.with_resolution(256, 256) .with_sh_degree(training_config.init.sh_degree)
.with_background([1.0, 1.0, 1.0]);
println!(
" Resolution: {}x{}",
raster_config.image_width, raster_config.image_height
);
println!();
println!("Initializing trainer...");
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..wgpu::InstanceDescriptor::new_without_display_handle()
});
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
apply_limit_buckets: false,
})
.await
.map_err(|e| {
oxigaf::OxigafError::Render(oxigaf::render::RenderError::GpuInit(format!(
"No suitable GPU adapter found: {}",
e
)))
})?;
let adapter_info = adapter.get_info();
println!(" GPU: {} ({:?})", adapter_info.name, adapter_info.backend);
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor {
label: Some("oxigaf_trainer"),
required_features: wgpu::Features::empty(),
required_limits: wgpu::Limits::default(),
memory_hints: wgpu::MemoryHints::Performance,
experimental_features: wgpu::ExperimentalFeatures::default(),
trace: wgpu::Trace::Off,
})
.await
.map_err(|e| {
oxigaf::OxigafError::Render(oxigaf::render::RenderError::DeviceCreationFailed(
e.to_string(),
))
})?;
let seed = 42u64;
let mut trainer = Trainer::new(
training_config.clone(),
model,
raster_config,
device,
queue,
seed,
)?;
println!(
" Trainer initialized with {} Gaussians",
trainer.model.len()
);
println!();
println!("Starting training...");
println!();
let checkpoint_dir = std::env::temp_dir()
.join("oxigaf_examples")
.join("checkpoints");
if let Err(e) = std::fs::create_dir_all(&checkpoint_dir) {
eprintln!("Warning: Could not create checkpoint directory: {}", e);
}
for _ in 0..training_config.total_iterations {
let output = trainer.train_step()?;
if output.iteration % training_config.log_interval == 0 {
println!(
" Iteration {:4} | Loss: {:.6} | Gaussians: {:5} | L1: {:.4} SSIM: {:.4}",
output.iteration,
output.loss.total,
output.num_gaussians,
output.loss.l1,
output.loss.ssim,
);
}
if output.iteration % training_config.checkpoint_interval == 0 {
let checkpoint_path = checkpoint_dir.join(format!("ckpt_{:06}.json", output.iteration));
match trainer.save_checkpoint(&checkpoint_path) {
Ok(()) => println!(" -> Saved checkpoint: {}", checkpoint_path.display()),
Err(e) => eprintln!(" -> Checkpoint save failed: {}", e),
}
}
}
println!();
println!("Training complete!");
println!(" Final Gaussians: {}", trainer.model.len());
let final_checkpoint = checkpoint_dir.join("ckpt_final.json");
trainer.save_checkpoint(&final_checkpoint)?;
println!(" Final checkpoint: {}", final_checkpoint.display());
println!();
println!("Demonstrating checkpoint load...");
demonstrate_checkpoint_load(&final_checkpoint)?;
println!();
println!("Key takeaways:");
println!(" - TrainingConfig holds all hyperparameters");
println!(" - Trainer::new() requires GPU device and queue");
println!(" - train_step() runs one complete iteration");
println!(" - save_checkpoint()/from_checkpoint() for persistence");
println!(" - Density control automatically splits/prunes Gaussians");
println!();
println!("Checkpoints saved to: {}", checkpoint_dir.display());
Ok(())
}
fn demonstrate_checkpoint_load(checkpoint_path: &Path) -> oxigaf::Result<()> {
let checkpoint = oxigaf::trainer::checkpoint::load_checkpoint(checkpoint_path)?;
println!(" Loaded checkpoint:");
println!(" Version: {}", checkpoint.version);
println!(" Iteration: {}", checkpoint.iteration);
println!(" Gaussians: {}", checkpoint.positions.len());
println!(" SH degree: {}", checkpoint.sh_degree);
println!(
" Optimizer groups: {}",
checkpoint.optimizer_groups.len()
);
let restored_model = oxigaf::trainer::checkpoint::restore_model(&checkpoint);
println!(" Restored model: {} Gaussians", restored_model.len());
Ok(())
}