medical_cache/

multi_res.rs

//! Multi-Resolution Image Generator
//!
//! Generates thumbnail (256×256) and mid-resolution (512×512) versions
//! of DICOM slices for progressive loading and efficient caching.

use std::sync::Arc;
use serde::{Deserialize, Serialize};
use tracing::debug;

use crate::config::ImageQuality;

/// Target dimensions for each quality level
pub const THUMBNAIL_SIZE: usize = 256;
pub const MID_RES_SIZE: usize = 512;

/// Multi-resolution image set for a single slice
#[derive(Debug, Clone)]
pub struct MultiResImage {
    /// Original image dimensions [width, height]
    pub original_size: [usize; 2],
    /// Thumbnail (256×256) - always available
    pub thumbnail: Option<Arc<Vec<u8>>>,
    /// Mid-resolution (512×512) - available based on config
    pub mid_res: Option<Arc<Vec<u8>>>,
    /// Full resolution - lazy loaded
    pub full_res: Option<Arc<Vec<u8>>>,
    /// Current highest quality available
    pub current_quality: ImageQuality,
    /// Whether full-res is being loaded
    pub loading_full: bool,
}

impl MultiResImage {
    /// Create empty multi-res image
    pub fn new(original_size: [usize; 2]) -> Self {
        Self {
            original_size,
            thumbnail: None,
            mid_res: None,
            full_res: None,
            current_quality: ImageQuality::Thumbnail,
            loading_full: false,
        }
    }

    /// Get the best available image data
    pub fn best_available(&self) -> Option<Arc<Vec<u8>>> {
        if let Some(ref full) = self.full_res {
            return Some(Arc::clone(full));
        }
        if let Some(ref mid) = self.mid_res {
            return Some(Arc::clone(mid));
        }
        if let Some(ref thumb) = self.thumbnail {
            return Some(Arc::clone(thumb));
        }
        None
    }

    /// Get image at specific quality level
    pub fn at_quality(&self, quality: ImageQuality) -> Option<Arc<Vec<u8>>> {
        match quality {
            ImageQuality::Thumbnail => self.thumbnail.clone(),
            ImageQuality::MidRes => self.mid_res.clone().or_else(|| self.thumbnail.clone()),
            ImageQuality::Full => self.full_res.clone()
                .or_else(|| self.mid_res.clone())
                .or_else(|| self.thumbnail.clone()),
        }
    }

    /// Check if we have the requested quality
    pub fn has_quality(&self, quality: ImageQuality) -> bool {
        match quality {
            ImageQuality::Thumbnail => self.thumbnail.is_some(),
            ImageQuality::MidRes => self.mid_res.is_some(),
            ImageQuality::Full => self.full_res.is_some(),
        }
    }

    /// Get memory usage in bytes
    pub fn memory_bytes(&self) -> usize {
        let mut total = 0;
        if let Some(ref t) = self.thumbnail {
            total += t.len();
        }
        if let Some(ref m) = self.mid_res {
            total += m.len();
        }
        if let Some(ref f) = self.full_res {
            total += f.len();
        }
        total
    }
}

/// Image resizer using bilinear interpolation
pub struct ImageResizer;

impl ImageResizer {
    /// Generate thumbnail from grayscale image data
    ///
    /// # Arguments
    /// * `data` - Raw pixel data (grayscale, 8-bit or 16-bit)
    /// * `width` - Original image width
    /// * `height` - Original image height
    /// * `bits_per_pixel` - 8 or 16
    ///
    /// # Returns
    /// Resized image data as 8-bit grayscale
    pub fn generate_thumbnail(
        data: &[u8],
        width: usize,
        height: usize,
        bits_per_pixel: usize,
    ) -> Vec<u8> {
        Self::resize(data, width, height, bits_per_pixel, THUMBNAIL_SIZE, THUMBNAIL_SIZE)
    }

    /// Generate mid-resolution image from grayscale image data
    pub fn generate_mid_res(
        data: &[u8],
        width: usize,
        height: usize,
        bits_per_pixel: usize,
    ) -> Vec<u8> {
        Self::resize(data, width, height, bits_per_pixel, MID_RES_SIZE, MID_RES_SIZE)
    }

    /// Resize image to target dimensions using bilinear interpolation
    ///
    /// Maintains aspect ratio by fitting within target dimensions
    pub fn resize(
        data: &[u8],
        src_width: usize,
        src_height: usize,
        bits_per_pixel: usize,
        target_width: usize,
        target_height: usize,
    ) -> Vec<u8> {
        // Calculate aspect-ratio-preserving dimensions
        let (dst_width, dst_height) = Self::fit_dimensions(
            src_width, src_height,
            target_width, target_height,
        );

        // Convert 16-bit to normalized f32 for processing
        let src_f32: Vec<f32> = if bits_per_pixel == 16 {
            data.chunks(2)
                .map(|chunk| {
                    let val = u16::from_le_bytes([chunk[0], chunk.get(1).copied().unwrap_or(0)]);
                    val as f32 / 65535.0
                })
                .collect()
        } else {
            data.iter().map(|&b| b as f32 / 255.0).collect()
        };

        // Perform bilinear interpolation
        let mut result = vec![0u8; dst_width * dst_height];

        let x_ratio = src_width as f32 / dst_width as f32;
        let y_ratio = src_height as f32 / dst_height as f32;

        for y in 0..dst_height {
            for x in 0..dst_width {
                let src_x = x as f32 * x_ratio;
                let src_y = y as f32 * y_ratio;

                let x0 = src_x.floor() as usize;
                let y0 = src_y.floor() as usize;
                let x1 = (x0 + 1).min(src_width - 1);
                let y1 = (y0 + 1).min(src_height - 1);

                let x_frac = src_x - x0 as f32;
                let y_frac = src_y - y0 as f32;

                // Get four neighboring pixels
                let p00 = src_f32.get(y0 * src_width + x0).copied().unwrap_or(0.0);
                let p10 = src_f32.get(y0 * src_width + x1).copied().unwrap_or(0.0);
                let p01 = src_f32.get(y1 * src_width + x0).copied().unwrap_or(0.0);
                let p11 = src_f32.get(y1 * src_width + x1).copied().unwrap_or(0.0);

                // Bilinear interpolation
                let top = p00 * (1.0 - x_frac) + p10 * x_frac;
                let bottom = p01 * (1.0 - x_frac) + p11 * x_frac;
                let value = top * (1.0 - y_frac) + bottom * y_frac;

                result[y * dst_width + x] = (value * 255.0).clamp(0.0, 255.0) as u8;
            }
        }

        result
    }

    /// Calculate dimensions that fit within target while preserving aspect ratio
    pub fn fit_dimensions(
        src_width: usize,
        src_height: usize,
        max_width: usize,
        max_height: usize,
    ) -> (usize, usize) {
        let width_ratio = max_width as f32 / src_width as f32;
        let height_ratio = max_height as f32 / src_height as f32;
        let ratio = width_ratio.min(height_ratio);

        let new_width = ((src_width as f32 * ratio).round() as usize).max(1);
        let new_height = ((src_height as f32 * ratio).round() as usize).max(1);

        (new_width, new_height)
    }

    /// Generate all resolution levels from full-res data
    pub fn generate_all_levels(
        data: &[u8],
        width: usize,
        height: usize,
        bits_per_pixel: usize,
    ) -> MultiResLevels {
        debug!(
            "Generating multi-res levels: {}x{} @ {}bpp",
            width, height, bits_per_pixel
        );

        let thumbnail = Self::generate_thumbnail(data, width, height, bits_per_pixel);
        let mid_res = Self::generate_mid_res(data, width, height, bits_per_pixel);

        // For full-res, convert to 8-bit if needed
        let full_res = if bits_per_pixel == 16 {
            // Simple linear mapping to 8-bit
            data.chunks(2)
                .map(|chunk| {
                    let val = u16::from_le_bytes([chunk[0], chunk.get(1).copied().unwrap_or(0)]);
                    (val >> 8) as u8
                })
                .collect()
        } else {
            data.to_vec()
        };

        MultiResLevels {
            thumbnail,
            mid_res,
            full_res,
            original_size: [width, height],
        }
    }
}

/// Generated multi-resolution levels
#[derive(Debug, Clone)]
pub struct MultiResLevels {
    /// 256×256 thumbnail
    pub thumbnail: Vec<u8>,
    /// 512×512 mid-resolution
    pub mid_res: Vec<u8>,
    /// Full resolution (8-bit)
    pub full_res: Vec<u8>,
    /// Original dimensions
    pub original_size: [usize; 2],
}

impl MultiResLevels {
    /// Get data for specific quality level
    pub fn get(&self, quality: ImageQuality) -> &[u8] {
        match quality {
            ImageQuality::Thumbnail => &self.thumbnail,
            ImageQuality::MidRes => &self.mid_res,
            ImageQuality::Full => &self.full_res,
        }
    }

    /// Get size for specific quality level
    pub fn size_for(&self, quality: ImageQuality) -> [usize; 2] {
        match quality {
            ImageQuality::Thumbnail => {
                let (w, h) = ImageResizer::fit_dimensions(
                    self.original_size[0],
                    self.original_size[1],
                    THUMBNAIL_SIZE,
                    THUMBNAIL_SIZE,
                );
                [w, h]
            }
            ImageQuality::MidRes => {
                let (w, h) = ImageResizer::fit_dimensions(
                    self.original_size[0],
                    self.original_size[1],
                    MID_RES_SIZE,
                    MID_RES_SIZE,
                );
                [w, h]
            }
            ImageQuality::Full => self.original_size,
        }
    }

    /// Total memory usage
    pub fn total_bytes(&self) -> usize {
        self.thumbnail.len() + self.mid_res.len() + self.full_res.len()
    }
}

/// Quality tracking for a slice
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QualityStatus {
    /// Study ID
    pub study_id: String,
    /// Series ID
    pub series_id: String,
    /// Slice index
    pub slice_index: usize,
    /// Current displayed quality
    pub current_quality: ImageQuality,
    /// Highest available quality
    pub available_quality: ImageQuality,
    /// Whether higher quality is loading
    pub is_loading: bool,
    /// Progress (0-100) if loading
    pub progress: u8,
}

impl QualityStatus {
    /// Create new quality status
    pub fn new(study_id: String, series_id: String, slice_index: usize) -> Self {
        Self {
            study_id,
            series_id,
            slice_index,
            current_quality: ImageQuality::Thumbnail,
            available_quality: ImageQuality::Thumbnail,
            is_loading: false,
            progress: 0,
        }
    }

    /// Update when new quality becomes available
    pub fn quality_ready(&mut self, quality: ImageQuality) {
        self.available_quality = quality;
        if self.is_loading && quality == ImageQuality::Full {
            self.is_loading = false;
            self.progress = 100;
        }
    }

    /// Start loading higher quality
    pub fn start_loading(&mut self) {
        self.is_loading = true;
        self.progress = 0;
    }

    /// Update loading progress
    pub fn update_progress(&mut self, progress: u8) {
        self.progress = progress.min(100);
    }

    /// Check if upgrade is needed
    pub fn needs_upgrade(&self) -> bool {
        self.current_quality < self.available_quality
    }
}

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

    #[test]
    fn test_fit_dimensions_landscape() {
        let (w, h) = ImageResizer::fit_dimensions(1024, 512, 256, 256);
        assert_eq!(w, 256);
        assert_eq!(h, 128);
    }

    #[test]
    fn test_fit_dimensions_portrait() {
        let (w, h) = ImageResizer::fit_dimensions(512, 1024, 256, 256);
        assert_eq!(w, 128);
        assert_eq!(h, 256);
    }

    #[test]
    fn test_fit_dimensions_square() {
        let (w, h) = ImageResizer::fit_dimensions(512, 512, 256, 256);
        assert_eq!(w, 256);
        assert_eq!(h, 256);
    }

    #[test]
    fn test_resize_8bit() {
        // Create a simple 4x4 gradient image
        let data: Vec<u8> = (0..16).map(|i| (i * 17) as u8).collect();

        let result = ImageResizer::resize(&data, 4, 4, 8, 2, 2);

        assert_eq!(result.len(), 4); // 2x2 output
        // Values should be interpolated
        assert!(result[0] < result[3]); // Gradient preserved
    }

    #[test]
    fn test_resize_16bit() {
        // Create a simple 4x4 16-bit image
        let mut data = Vec::new();
        for i in 0..16 {
            let val = (i * 4096) as u16;
            data.extend_from_slice(&val.to_le_bytes());
        }

        let result = ImageResizer::resize(&data, 4, 4, 16, 2, 2);

        assert_eq!(result.len(), 4); // 2x2 output
    }

    #[test]
    fn test_generate_all_levels() {
        // Create a 512x512 test image
        let data: Vec<u8> = (0..512 * 512).map(|i| (i % 256) as u8).collect();

        let levels = ImageResizer::generate_all_levels(&data, 512, 512, 8);

        // Check sizes
        assert_eq!(levels.thumbnail.len(), 256 * 256);
        assert_eq!(levels.mid_res.len(), 512 * 512);
        assert_eq!(levels.full_res.len(), 512 * 512);
    }

    #[test]
    fn test_multi_res_image() {
        let mut img = MultiResImage::new([512, 512]);

        assert!(!img.has_quality(ImageQuality::Thumbnail));

        img.thumbnail = Some(Arc::new(vec![0u8; 256 * 256]));
        assert!(img.has_quality(ImageQuality::Thumbnail));
        assert!(!img.has_quality(ImageQuality::Full));

        assert_eq!(img.current_quality, ImageQuality::Thumbnail);
    }

    #[test]
    fn test_quality_status() {
        let mut status = QualityStatus::new(
            "study1".to_string(),
            "series1".to_string(),
            0,
        );

        assert_eq!(status.current_quality, ImageQuality::Thumbnail);
        assert!(!status.is_loading);

        status.start_loading();
        assert!(status.is_loading);

        status.quality_ready(ImageQuality::Full);
        assert!(!status.is_loading);
        assert_eq!(status.available_quality, ImageQuality::Full);
    }
}