Add mmlogger - and log some basic metrics for the camera solver.

The mmlogger is intended to be a zero-cost feature that is used as an
explicit resource and passed to each function and used.

Author: david-cattermole

Cargo.lock

@@ -8,6 +8,7 @@ members = [
     "lib/mmsolverlibs",
     "lib/rust/mmcamerasolve-bin",
     "lib/rust/mmcholmod",
+    "lib/rust/mmlogger",
     "lib/rust/mmcore",
     "lib/rust/mmimage",
     "lib/rust/mmio",
@@ -60,6 +61,7 @@ mmcore_cppbind = { path = "./lib/cppbind/mmcore" }
 mmcore_rust = { path = "./lib/rust/mmcore" }
 mmimage_cppbind = { path = "./lib/cppbind/mmimage" }
 mmimage_rust = { path = "./lib/rust/mmimage" }
+mmlogger = { path = "./lib/rust/mmlogger" }
 mmio_rust = { path = "./lib/rust/mmio" }
 mmlens_cppbind = { path = "./lib/cppbind/mmlens" }
 mmlens_rust = { path = "./lib/rust/mmlens" }

Cargo.toml

@@ -11,10 +11,12 @@ path = "src/main.rs"
 
 [features]
 default = []
+logging = []
 visualization = ["mmsfm/visualization"]
 
 [dependencies]
 anyhow = { workspace = true }
+mmlogger = { workspace = true }
 mmio = { package = "mmio_rust", path = "../mmio" }
 mmlens = { package = "mmlens_cppbind", path = "../../cppbind/mmlens" }
 mmsfm = { package = "mmsfm_rust", path = "../mmsfm", default-features = false }

lib/rust/mmcamerasolve-bin/Cargo.toml

@@ -142,6 +142,7 @@ pub struct CliArgs {
 
     /// Optional path to a Nuke .nk lens distortion file.
     pub nuke_lens_file: Option<String>,
+
 }
 
 impl Default for CliArgs {

lib/rust/mmcamerasolve-bin/src/cli.rs

@@ -37,6 +37,7 @@ use std::time::Instant;
 use cli::{
     parse_args, print_help, print_version, CliArgs, ParseResult, SolverType,
 };
+use mmlogger::Logger;
 use mmio::bundle_writer::{write_bundle_file, BundlePoint};
 use mmio::kuper_writer::{
     extract_zxy_euler_angles, maya_pose_to_kuper, write_kuper_file,
@@ -115,7 +116,26 @@ fn run() -> Result<()> {
         }
     };
 
-    run_camera_solve(&args)
+    #[cfg(feature = "logging")]
+    {
+        std::fs::create_dir_all(&args.output_dir)
+            .with_context(|| format!("Failed to create output directory: {}", args.output_dir))?;
+        let log_filename = match &args.prefix {
+            Some(prefix) => format!("{}_solve.log", prefix),
+            None => "solve.log".to_string(),
+        };
+        let log_path = format!("{}/{}", args.output_dir, log_filename);
+        let file = std::fs::File::create(&log_path)
+            .with_context(|| format!("Failed to create log file: {}", log_path))?;
+        let mut log = mmlogger::TeeLogger::new(file, std::io::stderr());
+        run_camera_solve(&args, &mut log)
+    }
+
+    #[cfg(not(feature = "logging"))]
+    {
+        let mut log = mmlogger::NoOpLogger;
+        run_camera_solve(&args, &mut log)
+    }
 }
 
 fn setup_thread_pool(threads: Option<usize>) -> Result<()> {
@@ -233,7 +253,7 @@ impl IntermediateResultWriter for FileIntermediateResultWriter {
     }
 }
 
-fn run_camera_solve(args: &CliArgs) -> Result<()> {
+fn run_camera_solve<L: Logger>(args: &CliArgs, logger: &mut L) -> Result<()> {
     let total_start = Instant::now();
 
     // Load solver settings file if provided.
@@ -242,6 +262,7 @@ fn run_camera_solve(args: &CliArgs) -> Result<()> {
             if !args.quiet {
                 println!("Loading solver settings from: {}", settings_path);
             }
+            logger.log("INFO", &format!("Loading solver settings from: {}", settings_path));
             let s = parse_mmsettings_file(settings_path)
                 .map_err(|e| anyhow::anyhow!("{}", e))?;
             Some(s)
@@ -284,6 +305,8 @@ fn run_camera_solve(args: &CliArgs) -> Result<()> {
     let (file_info, mut markers) = parse_file(&args.uv_file)
         .with_context(|| format!("Failed to load UV file: {}", args.uv_file))?;
 
+    logger.log("INFO", &format!("Loaded {} markers from: {}", markers.len(), args.uv_file));
+
     if !args.quiet {
         println!("  Loaded {} markers", markers.len());
         println!("  Format version: {:?}", file_info.version);
@@ -534,6 +557,7 @@ fn run_camera_solve(args: &CliArgs) -> Result<()> {
         println!();
         println!("Running camera solve...");
     }
+    logger.log("INFO", "Running camera solve...");
 
     // Create intermediate result writer if enabled.
     let intermediate_writer: Option<Arc<dyn IntermediateResultWriter>> = if args
@@ -602,6 +626,14 @@ fn run_camera_solve(args: &CliArgs) -> Result<()> {
         None => camera_intrinsics,
     };
 
+    logger.log("INFO", &format!(
+        "Solve completed in {:.2}s: {} cameras, {} bundles, mean_err={:.4}px",
+        solve_duration.as_secs_f64(),
+        camera_poses.len(),
+        bundle_positions.len(),
+        quality_metrics.mean_reprojection_error,
+    ));
+
     if !args.quiet {
         println!();
         println!("Solve completed!");
@@ -898,6 +930,8 @@ fn run_camera_solve(args: &CliArgs) -> Result<()> {
         println!("Done!");
     }
 
+    logger.log("INFO", &format!("Total time: {:.2}s", total_time_secs));
+
     Ok(())
 }
 

lib/rust/mmcamerasolve-bin/src/main.rs

@@ -33,7 +33,7 @@ fi
 # Build release version for faster execution.
 echo "Building mmcamerasolve-bin (release mode)..."
 # cargo build --release -p mmcamerasolve-bin
-cargo build --release -p mmcamerasolve-bin --features visualization
+cargo build --release -p mmcamerasolve-bin --features visualization,logging
 echo ""
 
 MM_CAMERA_SOLVE="${PROJECT_ROOT}/target/release/mmcamerasolve"

lib/rust/mmcamerasolve-bin/test.bash

@@ -0,0 +1,6 @@
+[package]
+name = "mmlogger"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+publish.workspace = true

lib/rust/mmlogger/Cargo.toml

@@ -0,0 +1,76 @@
+//
+// Copyright (C) 2026 David Cattermole.
+//
+// This file is part of mmSolver.
+//
+// mmSolver is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// mmSolver is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with mmSolver.  If not, see <https://www.gnu.org/licenses/>.
+// ====================================================================
+//
+
+//! Zero-cost structured logger with compile-time feature gating.
+//!
+//! All types are generic over `std::io::Write` with static dispatch
+//! (no vtable overhead). When using `NoOpLogger`, calls are
+//! completely eliminated by the compiler.
+
+use std::io::Write;
+
+/// Trait for structured logging with zero-cost when disabled.
+pub trait Logger {
+    fn log(&mut self, level: &str, msg: &str);
+}
+
+/// Logger that writes to any `Write` implementor.
+pub struct BaseLogger<W: Write> {
+    writer: W,
+}
+
+impl<W: Write> BaseLogger<W> {
+    pub fn new(writer: W) -> Self {
+        Self { writer }
+    }
+}
+
+impl<W: Write> Logger for BaseLogger<W> {
+    fn log(&mut self, level: &str, msg: &str) {
+        let _ = writeln!(self.writer, "[{}] {}", level, msg);
+    }
+}
+
+/// Logger that writes to two outputs simultaneously.
+pub struct TeeLogger<W1: Write, W2: Write> {
+    writer1: W1,
+    writer2: W2,
+}
+
+impl<W1: Write, W2: Write> TeeLogger<W1, W2> {
+    pub fn new(writer1: W1, writer2: W2) -> Self {
+        Self { writer1, writer2 }
+    }
+}
+
+impl<W1: Write, W2: Write> Logger for TeeLogger<W1, W2> {
+    fn log(&mut self, level: &str, msg: &str) {
+        let _ = writeln!(self.writer1, "[{}] {}", level, msg);
+        let _ = writeln!(self.writer2, "[{}] {}", level, msg);
+    }
+}
+
+/// No-op logger with zero runtime cost.
+pub struct NoOpLogger;
+
+impl Logger for NoOpLogger {
+    #[inline(always)]
+    fn log(&mut self, _level: &str, _msg: &str) {}
+}

lib/rust/mmlogger/src/lib.rs

@@ -176,7 +176,7 @@ ${RUST_CARGO_EXE} build --release --target-dir ${BUILD_MMSOLVER_RUST_DIR}
 # Build mmcamerasolve Rust binary.
 echo "Building mmcamerasolve Rust binary... (${PROJECT_ROOT})"
 cd ${MMCAMERASOLVE_RUST_ROOT}
-${RUST_CARGO_EXE} build --release --package mmcamerasolve-bin --target-dir ${BUILD_MMSOLVER_RUST_DIR}
+${RUST_CARGO_EXE} build --release --package mmcamerasolve-bin --features logging --target-dir ${BUILD_MMSOLVER_RUST_DIR}
 
 # Optionally use "UNIX Makefiles" as the build system generator.
 CMAKE_GENERATOR="Ninja"

scripts/internal/build_mmSolver_linux.bash

@@ -172,7 +172,7 @@ if errorlevel 1 goto failed_to_build_rust
 :: Build mmcamerasolve Rust binary.
 ECHO Building mmcamerasolve Rust binary... (%PROJECT_ROOT%)
 CHDIR "%MMCAMERASOLVE_RUST_ROOT%"
-%RUST_CARGO_EXE% build %RELEASE_FLAG% --package mmcamerasolve-bin --target-dir "%BUILD_MMSOLVER_RUST_DIR%"
+%RUST_CARGO_EXE% build %RELEASE_FLAG% --package mmcamerasolve-bin --features logging --target-dir "%BUILD_MMSOLVER_RUST_DIR%"
 if errorlevel 1 goto failed_to_build_rust
 
 :: MinGW is a common install for developers on Windows and