359 lines
11 KiB
Rust
359 lines
11 KiB
Rust
//! CT scan analysis using 3D CNN.
|
|
//!
|
|
//! Analyzes CT scans to detect lesions, measure dimensions, and characterize findings.
|
|
|
|
use tumorboard_shared::{
|
|
CTFindings, ImagingStudy, Lesion, LesionLocation, LesionType, OrganMeasurement, RegionHU,
|
|
};
|
|
|
|
/// Error type for CT analysis.
|
|
#[derive(Debug, thiserror::Error)]
|
|
pub enum CTAnalysisError {
|
|
/// No scans provided.
|
|
#[error("No CT scans provided")]
|
|
NoScans,
|
|
|
|
/// Invalid scan data.
|
|
#[error("Invalid scan data: {0}")]
|
|
InvalidData(String),
|
|
}
|
|
|
|
/// CT scan analyzer using simulated 3D CNN.
|
|
#[derive(Debug)]
|
|
pub struct CTAnalyzer {
|
|
/// Detection threshold.
|
|
detection_threshold: f32,
|
|
/// Minimum lesion size (mm).
|
|
min_lesion_size: f32,
|
|
}
|
|
|
|
impl Default for CTAnalyzer {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl CTAnalyzer {
|
|
/// Create a new CT analyzer.
|
|
#[must_use]
|
|
pub fn new() -> Self {
|
|
Self {
|
|
detection_threshold: 0.5,
|
|
min_lesion_size: 3.0,
|
|
}
|
|
}
|
|
|
|
/// Create with custom thresholds.
|
|
#[must_use]
|
|
pub fn with_thresholds(detection_threshold: f32, min_lesion_size: f32) -> Self {
|
|
Self {
|
|
detection_threshold,
|
|
min_lesion_size,
|
|
}
|
|
}
|
|
|
|
/// Analyze CT studies.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// Returns error if no studies are provided or data is invalid.
|
|
pub fn analyze(&self, studies: &[&ImagingStudy]) -> Result<CTFindings, CTAnalysisError> {
|
|
if studies.is_empty() {
|
|
return Err(CTAnalysisError::NoScans);
|
|
}
|
|
|
|
// Detect lesions
|
|
let lesions = self.detect_lesions(studies);
|
|
|
|
// Get organ measurements
|
|
let organ_measurements = self.measure_organs(studies);
|
|
|
|
// Analyze Hounsfield units
|
|
let hu_analysis = self.analyze_hu(studies);
|
|
|
|
// Generate assessment
|
|
let assessment = self.generate_assessment(&lesions);
|
|
|
|
// Calculate confidence
|
|
let confidence = self.calculate_confidence(studies, &lesions);
|
|
|
|
Ok(CTFindings {
|
|
lesions,
|
|
organ_measurements,
|
|
hu_analysis,
|
|
assessment,
|
|
confidence,
|
|
})
|
|
}
|
|
|
|
/// Detect lesions in the CT studies.
|
|
fn detect_lesions(&self, studies: &[&ImagingStudy]) -> Vec<Lesion> {
|
|
let mut lesions = Vec::new();
|
|
|
|
// Simulate lesion detection based on study properties
|
|
// In real implementation, this would use a 3D CNN
|
|
|
|
for study in studies {
|
|
for image in &study.images {
|
|
// Check body region for lung lesion simulation
|
|
if matches!(image.body_region, tumorboard_shared::BodyRegion::Chest) {
|
|
// Primary lung lesion
|
|
let primary_lesion = Lesion {
|
|
id: "L001".to_string(),
|
|
location: LesionLocation {
|
|
organ: "Lung".to_string(),
|
|
region: "Right upper lobe".to_string(),
|
|
center: [45.0, 120.0, 85.0],
|
|
},
|
|
size: [32.0, 28.0, 25.0],
|
|
volume: 11_700.0,
|
|
lesion_type: LesionType::Nodule,
|
|
malignancy_probability: 0.85,
|
|
confidence: 0.92,
|
|
};
|
|
lesions.push(primary_lesion);
|
|
|
|
// Possible satellite nodule (higher res imaging)
|
|
if image.spacing[2] <= 2.0 {
|
|
let satellite = Lesion {
|
|
id: "L002".to_string(),
|
|
location: LesionLocation {
|
|
organ: "Lung".to_string(),
|
|
region: "Right upper lobe, satellite".to_string(),
|
|
center: [52.0, 115.0, 82.0],
|
|
},
|
|
size: [8.0, 7.0, 6.0],
|
|
volume: 175.0,
|
|
lesion_type: LesionType::Nodule,
|
|
malignancy_probability: 0.65,
|
|
confidence: 0.78,
|
|
};
|
|
lesions.push(satellite);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Filter by detection threshold
|
|
lesions
|
|
.into_iter()
|
|
.filter(|l| l.confidence >= self.detection_threshold)
|
|
.filter(|l| l.size[0] >= self.min_lesion_size)
|
|
.collect()
|
|
}
|
|
|
|
/// Measure organs.
|
|
fn measure_organs(&self, studies: &[&ImagingStudy]) -> Vec<OrganMeasurement> {
|
|
let mut measurements = Vec::new();
|
|
|
|
for study in studies {
|
|
for image in &study.images {
|
|
if matches!(image.body_region, tumorboard_shared::BodyRegion::Chest) {
|
|
// Heart measurements
|
|
measurements.push(OrganMeasurement {
|
|
organ: "Heart".to_string(),
|
|
measurement_type: "Cardiothoracic ratio".to_string(),
|
|
value: 0.48,
|
|
unit: "ratio".to_string(),
|
|
normal_range: Some((0.40, 0.50)),
|
|
is_abnormal: false,
|
|
});
|
|
|
|
// Aorta
|
|
measurements.push(OrganMeasurement {
|
|
organ: "Aorta".to_string(),
|
|
measurement_type: "Ascending diameter".to_string(),
|
|
value: 35.0,
|
|
unit: "mm".to_string(),
|
|
normal_range: Some((20.0, 37.0)),
|
|
is_abnormal: false,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
measurements
|
|
}
|
|
|
|
/// Analyze Hounsfield units.
|
|
fn analyze_hu(&self, _studies: &[&ImagingStudy]) -> Vec<RegionHU> {
|
|
vec![
|
|
RegionHU {
|
|
region: "Lesion L001".to_string(),
|
|
mean: 35.0,
|
|
std_dev: 12.0,
|
|
interpretation: "Soft tissue density, consistent with solid mass".to_string(),
|
|
},
|
|
RegionHU {
|
|
region: "Normal lung".to_string(),
|
|
mean: -850.0,
|
|
std_dev: 50.0,
|
|
interpretation: "Normal aerated lung parenchyma".to_string(),
|
|
},
|
|
]
|
|
}
|
|
|
|
/// Calculate overall confidence.
|
|
fn calculate_confidence(&self, studies: &[&ImagingStudy], lesions: &[Lesion]) -> f32 {
|
|
let mut confidence: f32 = 0.7;
|
|
|
|
// Better resolution = higher confidence
|
|
for study in studies {
|
|
for image in &study.images {
|
|
if image.spacing[2] <= 1.0 {
|
|
confidence += 0.15;
|
|
} else if image.spacing[2] <= 2.0 {
|
|
confidence += 0.1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// More lesions detected = more confident in analysis
|
|
if !lesions.is_empty() {
|
|
confidence += 0.05;
|
|
}
|
|
|
|
confidence.min(0.98)
|
|
}
|
|
|
|
/// Generate overall assessment.
|
|
fn generate_assessment(&self, lesions: &[Lesion]) -> String {
|
|
if lesions.is_empty() {
|
|
return "No significant lesions identified.".to_string();
|
|
}
|
|
|
|
let primary = &lesions[0];
|
|
let mut assessment = format!(
|
|
"Suspicious {:?} in {} measuring {:.1} x {:.1} x {:.1} mm.",
|
|
primary.lesion_type,
|
|
primary.location.region,
|
|
primary.size[0],
|
|
primary.size[1],
|
|
primary.size[2]
|
|
);
|
|
|
|
if primary.malignancy_probability > 0.7 {
|
|
assessment.push_str(" Highly suspicious for malignancy.");
|
|
} else if primary.malignancy_probability > 0.4 {
|
|
assessment.push_str(" Intermediate suspicion for malignancy.");
|
|
}
|
|
|
|
if lesions.len() > 1 {
|
|
assessment.push_str(&format!(
|
|
" {} additional nodule(s) identified.",
|
|
lesions.len() - 1
|
|
));
|
|
}
|
|
|
|
assessment
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use tumorboard_shared::{BodyRegion, ImageDimensions, ImageMetadata, ImagingModality};
|
|
|
|
fn create_test_study() -> ImagingStudy {
|
|
ImagingStudy {
|
|
study_id: "CT001".to_string(),
|
|
modality: ImagingModality::CT,
|
|
images: vec![ImageMetadata {
|
|
id: "CT001-001".to_string(),
|
|
modality: ImagingModality::CT,
|
|
acquisition_date: "2024-01-15".to_string(),
|
|
dimensions: ImageDimensions {
|
|
width: 512,
|
|
height: 512,
|
|
depth: 300,
|
|
},
|
|
spacing: [0.7, 0.7, 1.25],
|
|
body_region: BodyRegion::Chest,
|
|
series_description: Some("Chest CT".to_string()),
|
|
}],
|
|
description: Some("Chest CT with contrast".to_string()),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_ct_analyzer_creation() {
|
|
let analyzer = CTAnalyzer::new();
|
|
assert!(analyzer.detection_threshold > 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_analyze_single_study() {
|
|
let analyzer = CTAnalyzer::new();
|
|
let study = create_test_study();
|
|
|
|
let result = analyzer.analyze(&[&study]);
|
|
assert!(result.is_ok());
|
|
|
|
let findings = result.unwrap();
|
|
assert!(!findings.lesions.is_empty());
|
|
assert!(findings.confidence > 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_no_studies_error() {
|
|
let analyzer = CTAnalyzer::new();
|
|
let result = analyzer.analyze(&[]);
|
|
assert!(result.is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn test_lesion_detection() {
|
|
let analyzer = CTAnalyzer::new();
|
|
let study = create_test_study();
|
|
|
|
let findings = analyzer.analyze(&[&study]).unwrap();
|
|
|
|
// Should detect the primary lung lesion
|
|
assert!(!findings.lesions.is_empty());
|
|
let primary = &findings.lesions[0];
|
|
assert!(primary.location.region.contains("upper lobe"));
|
|
assert!(primary.malignancy_probability > 0.5);
|
|
}
|
|
|
|
#[test]
|
|
fn test_organ_measurements() {
|
|
let analyzer = CTAnalyzer::new();
|
|
let study = create_test_study();
|
|
|
|
let findings = analyzer.analyze(&[&study]).unwrap();
|
|
|
|
assert!(!findings.organ_measurements.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn test_hu_analysis() {
|
|
let analyzer = CTAnalyzer::new();
|
|
let study = create_test_study();
|
|
|
|
let findings = analyzer.analyze(&[&study]).unwrap();
|
|
|
|
assert!(!findings.hu_analysis.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn test_custom_thresholds() {
|
|
let analyzer = CTAnalyzer::with_thresholds(0.9, 10.0);
|
|
let study = create_test_study();
|
|
|
|
let findings = analyzer.analyze(&[&study]).unwrap();
|
|
// Higher threshold may filter out some lesions
|
|
// The primary lesion has confidence 0.92, so it should still be detected
|
|
assert!(!findings.lesions.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn test_assessment_generation() {
|
|
let analyzer = CTAnalyzer::new();
|
|
let study = create_test_study();
|
|
|
|
let findings = analyzer.analyze(&[&study]).unwrap();
|
|
assert!(!findings.assessment.is_empty());
|
|
assert!(findings.assessment.contains("Suspicious"));
|
|
}
|
|
}
|