glint_mask_tools/core/

sensor.rs

/// Sensor configuration and management system.
///
/// This module provides the sensor configuration system that defines how
/// different sensor types are handled, including their band configurations,
/// bit depths, and associated loaders.
use crate::error::{GlintError, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Represents a sensor band with its properties
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Band {
    /// Band name (e.g., "Red", "Green", "Blue", "NIR")
    pub name: String,
    /// Default threshold value for glint detection
    pub default_threshold: f64,
    /// Optional wavelength information in nanometers
    pub wavelength: Option<f64>,
    /// Optional band description
    pub description: Option<String>,
}

impl Band {
    /// Create a new band with default threshold
    pub fn new(name: impl Into<String>, default_threshold: f64) -> Self {
        Self {
            name: name.into(),
            default_threshold,
            wavelength: None,
            description: None,
        }
    }

    /// Create a new band with wavelength information
    pub fn with_wavelength(
        name: impl Into<String>,
        default_threshold: f64,
        wavelength: f64,
    ) -> Self {
        Self {
            name: name.into(),
            default_threshold,
            wavelength: Some(wavelength),
            description: None,
        }
    }

    /// Set the description for this band
    pub fn with_description(mut self, description: impl Into<String>) -> Self {
        self.description = Some(description.into());
        self
    }

    /// Validate the band configuration
    pub fn validate(&self) -> Result<()> {
        if self.default_threshold < 0.0 || self.default_threshold > 1.0 {
            return Err(GlintError::InvalidThreshold {
                value: self.default_threshold,
            });
        }

        if let Some(wavelength) = self.wavelength {
            if wavelength <= 0.0 || wavelength > 3000.0 {
                return Err(GlintError::validation(format!(
                    "Invalid wavelength: {} nm",
                    wavelength
                )));
            }
        }

        Ok(())
    }
}

/// Sensor configuration that defines how to handle a specific sensor type
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Sensor {
    /// Unique identifier for this sensor
    pub id: String,
    /// Human-readable name
    pub name: String,
    /// List of bands in order
    pub bands: Vec<Band>,
    /// Bit depth of the sensor data
    pub bit_depth: u8,
    /// Loader type identifier
    pub loader_type: String,
    /// Optional description
    pub description: Option<String>,
    /// Loader-specific configuration
    pub loader_config: HashMap<String, String>,
}

impl Sensor {
    /// Create a new sensor configuration
    pub fn new(
        id: impl Into<String>,
        name: impl Into<String>,
        bands: Vec<Band>,
        bit_depth: u8,
        loader_type: impl Into<String>,
    ) -> Self {
        Self {
            id: id.into(),
            name: name.into(),
            bands,
            bit_depth,
            loader_type: loader_type.into(),
            description: None,
            loader_config: HashMap::new(),
        }
    }

    /// Set the description for this sensor
    pub fn with_description(mut self, description: impl Into<String>) -> Self {
        self.description = Some(description.into());
        self
    }

    /// Add a loader configuration parameter
    pub fn with_loader_config(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.loader_config.insert(key.into(), value.into());
        self
    }

    /// Get the default thresholds for all bands
    pub fn default_thresholds(&self) -> Vec<f64> {
        self.bands.iter().map(|b| b.default_threshold).collect()
    }

    /// Get the number of bands
    pub fn band_count(&self) -> usize {
        self.bands.len()
    }

    /// Get band names
    pub fn band_names(&self) -> Vec<&str> {
        self.bands.iter().map(|b| b.name.as_str()).collect()
    }

    /// Validate the sensor configuration
    pub fn validate(&self) -> Result<()> {
        // Validate bit depth
        if !matches!(self.bit_depth, 8 | 16 | 32) {
            return Err(GlintError::InvalidBitDepth {
                bit_depth: self.bit_depth,
            });
        }

        // Validate bands
        if self.bands.is_empty() {
            return Err(GlintError::validation("Sensor must have at least one band"));
        }

        for band in &self.bands {
            band.validate()?;
        }

        // Check for duplicate band names
        let mut names = std::collections::HashSet::new();
        for band in &self.bands {
            if !names.insert(&band.name) {
                return Err(GlintError::validation(format!(
                    "Duplicate band name: {}",
                    band.name
                )));
            }
        }

        Ok(())
    }
}

/// Registry for managing sensor configurations
#[derive(Debug, Clone)]
pub struct SensorRegistry {
    sensors: HashMap<String, Sensor>,
}

impl SensorRegistry {
    /// Create a new empty sensor registry
    pub fn new() -> Self {
        Self {
            sensors: HashMap::new(),
        }
    }

    /// Create a registry with default sensors loaded from built-in TOML
    pub fn with_defaults() -> Self {
        let mut registry = Self::new();

        // Load default sensors from built-in TOML configuration
        if let Ok(sensors) = Self::load_builtin_sensors() {
            for sensor in sensors {
                registry.register_sensor(sensor).unwrap();
            }
        }

        registry
    }

    /// Create a registry with sensors loaded from user config, falling back to defaults
    pub fn from_user_config() -> Self {
        let mut registry = Self::new();

        // Try to load from user config first
        if let Ok(sensors) = Self::load_user_sensors() {
            for sensor in sensors {
                if registry.register_sensor(sensor).is_err() {
                    // If sensor registration fails, continue with others
                    continue;
                }
            }
        }

        // If no user sensors were loaded, fall back to built-in defaults
        if registry.is_empty() {
            if let Ok(sensors) = Self::load_builtin_sensors() {
                for sensor in sensors {
                    registry.register_sensor(sensor).unwrap();
                }
            }
        }

        registry
    }

    /// Load sensors from user configuration directory
    fn load_user_sensors() -> Result<Vec<Sensor>> {
        use crate::config::ConfigManager;

        let config_manager = ConfigManager::new();
        let config_dir = config_manager.get_config_dir()?;
        let config_path = config_dir.join("sensors.toml");

        // Create sample config if it doesn't exist
        if !config_path.exists() {
            std::fs::create_dir_all(&config_dir)
                .map_err(|_| GlintError::config("Failed to create config directory"))?;

            // Copy default sensors to user config
            config_manager.create_sample_config(&config_path)?;
        }

        config_manager.load_from_file(&config_path)
    }

    /// Load sensors from the built-in TOML configuration
    fn load_builtin_sensors() -> Result<Vec<Sensor>> {
        // Include the built-in sensor configuration at compile time
        const BUILTIN_CONFIG: &str = include_str!("../../sensor_configs/default_sensors.toml");

        let config_file: crate::config::sensor_config::SensorConfigFile =
            toml::from_str(BUILTIN_CONFIG).map_err(GlintError::Deserialization)?;

        // Validate version (for future compatibility)
        if config_file.version != "1.0" {
            return Err(GlintError::config(format!(
                "Unsupported configuration file version: {}",
                config_file.version
            )));
        }

        // Convert to sensors and validate
        let mut sensors = Vec::new();
        for sensor_config in config_file.sensors {
            let sensor = Sensor::from(sensor_config);
            sensor.validate()?;
            sensors.push(sensor);
        }

        Ok(sensors)
    }

    /// Register a new sensor
    pub fn register_sensor(&mut self, sensor: Sensor) -> Result<()> {
        sensor.validate()?;

        if self.sensors.contains_key(&sensor.id) {
            return Err(GlintError::validation(format!(
                "Sensor with ID '{}' already registered",
                sensor.id
            )));
        }

        self.sensors.insert(sensor.id.clone(), sensor);
        Ok(())
    }

    /// Get a sensor by ID
    pub fn get_sensor(&self, id: &str) -> Option<&Sensor> {
        self.sensors.get(id)
    }

    /// Get all registered sensor IDs
    pub fn sensor_ids(&self) -> Vec<&str> {
        self.sensors.keys().map(|s| s.as_str()).collect()
    }

    /// Get all registered sensors
    pub fn sensors(&self) -> Vec<&Sensor> {
        self.sensors.values().collect()
    }

    /// Remove a sensor
    pub fn remove_sensor(&mut self, id: &str) -> Option<Sensor> {
        self.sensors.remove(id)
    }

    /// Check if a sensor is registered
    pub fn has_sensor(&self, id: &str) -> bool {
        self.sensors.contains_key(id)
    }

    /// Get the number of registered sensors
    pub fn len(&self) -> usize {
        self.sensors.len()
    }

    /// Check if the registry is empty
    pub fn is_empty(&self) -> bool {
        self.sensors.is_empty()
    }

    /// Load sensors from a configuration file
    pub fn load_from_file(&mut self, path: &std::path::Path) -> Result<()> {
        // Use the config module for proper deserialization
        use crate::config::ConfigManager;
        let config_manager = ConfigManager::new();
        let sensors = config_manager.load_from_file(path)?;

        for sensor in sensors {
            self.register_sensor(sensor)?;
        }

        Ok(())
    }

    /// Save sensors to a configuration file
    pub fn save_to_file(&self, path: &std::path::Path) -> Result<()> {
        // Use the config module for proper serialization
        use crate::config::ConfigManager;
        let config_manager = ConfigManager::new();
        let sensors: Vec<Sensor> = self.sensors.values().cloned().collect();
        config_manager.save_to_file(&sensors, path)
    }
}

impl Default for SensorRegistry {
    fn default() -> Self {
        Self::new()
    }
}

/// Common band definitions for reuse
pub mod bands {
    use super::Band;

    /// Blue band (typically ~475nm)
    pub fn blue() -> Band {
        Band::with_wavelength("Blue", 0.875, 475.0)
            .with_description("Blue band for visible light imaging")
    }

    /// Green band (typically ~560nm)
    pub fn green() -> Band {
        Band::with_wavelength("Green", 1.0, 560.0)
            .with_description("Green band for visible light imaging")
    }

    /// Red band (typically ~650nm)
    pub fn red() -> Band {
        Band::with_wavelength("Red", 1.0, 650.0)
            .with_description("Red band for visible light imaging")
    }

    /// Red Edge band (typically ~730nm)
    pub fn red_edge() -> Band {
        Band::with_wavelength("Red Edge", 1.0, 730.0)
            .with_description("Red edge band for vegetation analysis")
    }

    /// Near-infrared band (typically ~840nm)
    pub fn near_ir() -> Band {
        Band::with_wavelength("Near-IR", 1.0, 840.0)
            .with_description("Near-infrared band for vegetation analysis")
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::tempdir;

    #[test]
    fn test_band_creation() {
        let band = Band::new("Red", 0.9);
        assert_eq!(band.name, "Red");
        assert_eq!(band.default_threshold, 0.9);
        assert!(band.wavelength.is_none());

        let band = Band::with_wavelength("Blue", 0.8, 475.0);
        assert_eq!(band.wavelength, Some(475.0));
    }

    #[test]
    fn test_band_validation() {
        let band = Band::new("Red", 0.5);
        assert!(band.validate().is_ok());

        let band = Band::new("Red", 1.5);
        assert!(band.validate().is_err());

        let band = Band::with_wavelength("Red", 0.5, -100.0);
        assert!(band.validate().is_err());
    }

    #[test]
    fn test_sensor_creation() {
        let bands = vec![
            Band::new("Red", 0.9),
            Band::new("Green", 0.8),
            Band::new("Blue", 0.7),
        ];

        let sensor = Sensor::new("rgb", "RGB Camera", bands, 8, "single_file");
        assert_eq!(sensor.id, "rgb");
        assert_eq!(sensor.band_count(), 3);
        assert_eq!(sensor.default_thresholds(), vec![0.9, 0.8, 0.7]);
    }

    #[test]
    fn test_sensor_validation() {
        let bands = vec![Band::new("Red", 0.9)];
        let sensor = Sensor::new("test", "Test", bands, 8, "single_file");
        assert!(sensor.validate().is_ok());

        let sensor = Sensor::new("test", "Test", vec![], 8, "single_file");
        assert!(sensor.validate().is_err());

        let bands = vec![Band::new("Red", 1.5)];
        let sensor = Sensor::new("test", "Test", bands, 8, "single_file");
        assert!(sensor.validate().is_err());
    }

    #[test]
    fn test_sensor_registry() {
        let mut registry = SensorRegistry::new();

        let bands = vec![Band::new("Red", 0.9)];
        let sensor = Sensor::new("test", "Test", bands, 8, "single_file");

        assert!(registry.register_sensor(sensor).is_ok());
        assert!(registry.has_sensor("test"));
        assert_eq!(registry.len(), 1);

        let retrieved = registry.get_sensor("test").unwrap();
        assert_eq!(retrieved.id, "test");
    }

    #[test]
    fn test_sensor_registry_file_operations() {
        let temp_dir = tempdir().unwrap();
        let config_path = temp_dir.path().join("sensors.toml");

        let mut registry = SensorRegistry::new();
        let bands = vec![Band::new("Red", 0.9)];
        let sensor = Sensor::new("test", "Test", bands, 8, "single_file");
        registry.register_sensor(sensor).unwrap();

        // Save to file
        registry.save_to_file(&config_path).unwrap();
        assert!(config_path.exists());

        // Load from file
        let mut new_registry = SensorRegistry::new();
        new_registry.load_from_file(&config_path).unwrap();
        assert!(new_registry.has_sensor("test"));
    }
}