Default

app.py

@@ -1,12 +1,6 @@
 import numpy as np
 import gradio as gr
 import cv2
-from sklearn.cluster import DBSCAN
-from scipy import ndimage
-from skimage.feature import hog
-from skimage import filters
-import warnings
-warnings.filterwarnings('ignore')
 
 from models.HybridGNet2IGSC import Hybrid
 from utils.utils import scipy_to_torch_sparse, genMatrixesLungsHeart
@@ -55,80 +49,6 @@ def getMasks(landmarks, h, w):
     return RL_mask, LL_mask, H_mask
 
 
-def assess_image_quality(img):
-    """ประเมินคุณภาพของภาพสำหรับการปรับ threshold"""
-    try:
-        # 1. Contrast assessment
-        contrast = np.std(img)
-        
-        # 2. Noise assessment (using Laplacian variance)
-        laplacian_var = cv2.Laplacian(img, cv2.CV_64F).var()
-        
-        # 3. Edge density
-        edges = cv2.Canny((img * 255).astype(np.uint8), 50, 150)
-        edge_density = np.sum(edges > 0) / edges.size
-        
-        # 4. Brightness distribution
-        brightness_std = np.std(img)
-        
-        # Normalize scores (0-1)
-        contrast_score = min(contrast / 0.3, 1.0)
-        noise_score = min(laplacian_var / 500, 1.0)
-        edge_score = min(edge_density / 0.1, 1.0)
-        brightness_score = min(brightness_std / 0.25, 1.0)
-        
-        # Overall quality score
-        quality = (contrast_score * 0.3 + noise_score * 0.3 + 
-                  edge_score * 0.25 + brightness_score * 0.15)
-        
-        return {
-            'overall': min(quality, 1.0),
-            'contrast': contrast_score,
-            'noise': noise_score,
-            'edge_density': edge_score,
-            'brightness': brightness_score
-        }
-    except Exception as e:
-        print(f"Error in quality assessment: {e}")
-        return {'overall': 0.5, 'contrast': 0.5, 'noise': 0.5, 
-                'edge_density': 0.5, 'brightness': 0.5}
-
-def adaptive_thresholding(quality_scores, image_characteristics):
-    """กำหนด threshold แบบปรับเปลี่ยนตามคุณภาพภาพ"""
-    base_rotation_threshold = 3.0
-    base_tilt_threshold = 2.0
-    
-    quality = quality_scores['overall']
-    
-    # ปรับตามคุณภาพภาพ
-    if quality < 0.4:  # คุณภาพต่ำ
-        rotation_multiplier = 2.0
-        tilt_multiplier = 2.0
-    elif quality < 0.6:  # คุณภาพปานกลาง
-        rotation_multiplier = 1.5
-        tilt_multiplier = 1.5
-    elif quality > 0.8:  # คุณภาพสูง
-        rotation_multiplier = 0.8
-        tilt_multiplier = 0.8
-    else:  # คุณภาพดี
-        rotation_multiplier = 1.0
-        tilt_multiplier = 1.0
-    
-    # ปรับตาม characteristics อื่นๆ
-    if image_characteristics.get('has_medical_devices', False):
-        rotation_multiplier *= 1.3
-        tilt_multiplier *= 1.3
-    
-    if image_characteristics.get('patient_age', 'adult') == 'pediatric':
-        rotation_multiplier *= 1.2
-        tilt_multiplier *= 1.2
-    
-    return {
-        'rotation_threshold': base_rotation_threshold * rotation_multiplier,
-        'tilt_threshold': base_tilt_threshold * tilt_multiplier,
-        'confidence_threshold': 0.7 if quality > 0.6 else 0.5
-    }
-
 def calculate_image_tilt(landmarks):
     """Calculate image tilt angle based on lung symmetry"""
     RL = landmarks[0:44]  # Right lung
@@ -150,85 +70,6 @@ def calculate_image_tilt(landmarks):
     
     return angle_deg, rl_top, ll_top
 
-def detect_vertical_alignment(img):
-    """ตรวจจับการเอียงในแนวตั้ง (เช่น spine alignment)"""
-    try:
-        h, w = img.shape
-        
-        # Focus on central vertical region (spine area)
-        spine_region = img[:, w//3:2*w//3]
-        
-        # Apply edge detection
-        edges = cv2.Canny((spine_region * 255).astype(np.uint8), 30, 100)
-        
-        # Find vertical lines using Hough Transform
-        lines = cv2.HoughLines(edges, 1, np.pi/180, threshold=int(h*0.3))
-        
-        if lines is not None:
-            vertical_angles = []
-            for line in lines:
-                rho, theta = line[0]
-                angle = np.degrees(theta) - 90  # Convert to rotation angle
-                
-                # Filter for near-vertical lines
-                if abs(angle) < 20:
-                    vertical_angles.append(angle)
-            
-            if vertical_angles:
-                # Remove outliers and get median
-                angles_arr = np.array(vertical_angles)
-                Q1, Q3 = np.percentile(angles_arr, [25, 75])
-                IQR = Q3 - Q1
-                filtered = angles_arr[(angles_arr >= Q1 - 1.5*IQR) & 
-                                    (angles_arr <= Q3 + 1.5*IQR)]
-                
-                if len(filtered) > 0:
-                    return np.median(filtered)
-        
-        return 0
-    except Exception as e:
-        print(f"Error in vertical alignment detection: {e}")
-        return 0
-
-def ml_based_tilt_detection(img):
-    """ใช้ HOG features และ pattern recognition สำหรับตรวจจับการเอียง"""
-    try:
-        # Resize for consistent processing
-        resized = cv2.resize(img, (256, 256))
-        
-        # Extract HOG features
-        features = hog(resized, orientations=9, pixels_per_cell=(16, 16),
-                      cells_per_block=(2, 2), block_norm='L2-Hys')
-        
-        # Test multiple rotation angles
-        best_angle = 0
-        best_score = 0
-        
-        for test_angle in range(-20, 21, 2):
-            # Rotate image
-            center = (128, 128)
-            rotation_matrix = cv2.getRotationMatrix2D(center, test_angle, 1.0)
-            rotated = cv2.warpAffine(resized, rotation_matrix, (256, 256))
-            
-            # Extract features from rotated image
-            rotated_features = hog(rotated, orientations=9, pixels_per_cell=(16, 16),
-                                 cells_per_block=(2, 2), block_norm='L2-Hys')
-            
-            # Calculate symmetry score (simplified)
-            left_features = rotated_features[:len(rotated_features)//2]
-            right_features = rotated_features[len(rotated_features)//2:]
-            
-            # Correlation as symmetry measure
-            correlation = np.corrcoef(left_features, right_features)[0, 1]
-            if not np.isnan(correlation) and correlation > best_score:
-                best_score = correlation
-                best_angle = test_angle
-        
-        return best_angle if best_score > 0.3 else 0
-    except Exception as e:
-        print(f"Error in ML-based detection: {e}")
-        return 0
-
 def rotate_points(points, angle_deg, center):
     """Rotate points around a center by given angle"""
     angle_rad = np.radians(-angle_deg)  # Negative to correct the tilt
@@ -460,88 +301,27 @@ def validate_landmarks_consistency(landmarks, original_landmarks, threshold=0.05
         LL = landmarks[44:94]
         H = landmarks[94:]
         
-        original_RL = original_landmarks[0:44]
-        original_LL = original_landmarks[44:94]
-        original_H = original_landmarks[94:]
-        
-        validation_results = {
-            'heart_position': False,
-            'lung_symmetry': False,
-            'relative_change': False,
-            'anatomical_ratios': False,
-            'outlier_detection': False
-        }
-        
-        # 1. Heart position validation (enhanced)
         rl_center_x = np.mean(RL[:, 0])
         ll_center_x = np.mean(LL[:, 0])
         h_center_x = np.mean(H[:, 0])
         
-        # Heart should be between lung centers with some tolerance
-        lung_span = abs(rl_center_x - ll_center_x)
-        heart_deviation = min(abs(h_center_x - rl_center_x), abs(h_center_x - ll_center_x))
-        
-        if heart_deviation < lung_span * 0.6:  # Heart within 60% of lung span
-            validation_results['heart_position'] = True
-        
-        # 2. Lung symmetry validation
-        rl_centroid = np.mean(RL, axis=0)
-        ll_centroid = np.mean(LL, axis=0)
-        
-        # Check if lungs are reasonably symmetric
-        lung_distance = np.linalg.norm(rl_centroid - ll_centroid)
-        original_lung_distance = np.linalg.norm(np.mean(original_RL, axis=0) - np.mean(original_LL, axis=0))
-        
-        symmetry_change = abs(lung_distance - original_lung_distance) / original_lung_distance
-        if symmetry_change < 0.15:  # Less than 15% change in lung symmetry
-            validation_results['lung_symmetry'] = True
-        
-        # 3. Relative change validation (enhanced)
+        # Heart should be between lung centers
+        if not (min(rl_center_x, ll_center_x) <= h_center_x <= max(rl_center_x, ll_center_x)):
+            print("Warning: Heart position validation failed")
+            return False
+            
+        # Check if total change is reasonable
         total_change = np.mean(np.linalg.norm(landmarks - original_landmarks, axis=1))
         relative_change = total_change / np.mean(np.linalg.norm(original_landmarks, axis=1))
         
-        if relative_change < threshold:
-            validation_results['relative_change'] = True
-        
-        # 4. Anatomical ratios validation
-        # Heart width to lung span ratio should remain reasonable
-        heart_width = np.max(H[:, 0]) - np.min(H[:, 0])
-        lung_span_total = max(np.max(RL[:, 0]), np.max(LL[:, 0])) - min(np.min(RL[:, 0]), np.min(LL[:, 0]))
-        
-        original_heart_width = np.max(original_H[:, 0]) - np.min(original_H[:, 0])
-        original_lung_span = max(np.max(original_RL[:, 0]), np.max(original_LL[:, 0])) - min(np.min(original_RL[:, 0]), np.min(original_LL[:, 0]))
-        
-        current_ratio = heart_width / lung_span_total if lung_span_total > 0 else 0
-        original_ratio = original_heart_width / original_lung_span if original_lung_span > 0 else 0
-        
-        ratio_change = abs(current_ratio - original_ratio) / original_ratio if original_ratio > 0 else 0
-        if ratio_change < 0.1:  # Less than 10% change in anatomical ratios
-            validation_results['anatomical_ratios'] = True
-        
-        # 5. Outlier detection using DBSCAN
-        try:
-            all_points = landmarks.reshape(-1, 2)
-            clustering = DBSCAN(eps=20, min_samples=3).fit(all_points)
-            outlier_ratio = np.sum(clustering.labels_ == -1) / len(clustering.labels_)
+        if relative_change > threshold:
+            print(f"Warning: Landmarks changed by {relative_change:.3f}, exceeds threshold {threshold}")
+            return False
             
-            if outlier_ratio < 0.05:  # Less than 5% outliers
-                validation_results['outlier_detection'] = True
-        except:
-            validation_results['outlier_detection'] = True  # Default to True if clustering fails
-        
-        # Overall validation score
-        validation_score = sum(validation_results.values()) / len(validation_results)
-        
-        # Log detailed results
-        if validation_score < 0.8:
-            failed_checks = [k for k, v in validation_results.items() if not v]
-            print(f"Validation warnings - Failed checks: {failed_checks}")
-            print(f"Validation score: {validation_score:.2f}")
-        
-        return validation_score >= 0.6  # Require at least 60% of checks to pass
+        return True
         
     except Exception as e:
-        print(f"Error in enhanced landmark validation: {e}")
+        print(f"Error in landmark validation: {e}")
         return False
 
 def calculate_ctr_robust(landmarks, corrected_landmarks=None):
@@ -640,140 +420,85 @@ def calculate_ctr_robust(landmarks, corrected_landmarks=None):
         }
 
 
-def detect_image_rotation_advanced(img, quality_scores=None):
-    """Enhanced rotation detection using multiple methods with quality adaptation"""
+def detect_image_rotation_advanced(img):
+    """Enhanced rotation detection using multiple methods"""
     try:
         angles = []
-        confidence_scores = []
         
+        # Method 1: Edge-based detection with focus on spine/mediastinum
+        edges = cv2.Canny((img * 255).astype(np.uint8), 50, 150)
         h, w = img.shape
         
-        # Adaptive parameters based on image quality
-        if quality_scores and quality_scores['overall'] < 0.5:
-            edge_threshold_low, edge_threshold_high = 30, 100
-            hough_threshold_factor = 0.2
-            correlation_threshold = 0.25
-        else:
-            edge_threshold_low, edge_threshold_high = 50, 150
-            hough_threshold_factor = 0.3
-            correlation_threshold = 0.35
+        # Focus on central region where spine should be
+        spine_region = edges[h//4:3*h//4, w//3:2*w//3]
         
-        # Method 1: Multi-region edge detection
-        edges = cv2.Canny((img * 255).astype(np.uint8), edge_threshold_low, edge_threshold_high)
-        
-        # Focus on multiple regions
-        regions = {
-            'spine': edges[h//4:3*h//4, w//3:2*w//3],
-            'left_lung': edges[h//6:5*h//6, w//6:w//2],
-            'right_lung': edges[h//6:5*h//6, w//2:5*w//6]
-        }
-        
-        for region_name, region in regions.items():
-            lines = cv2.HoughLines(region, 1, np.pi/180, 
-                                 threshold=int(region.shape[0] * hough_threshold_factor))
-            if lines is not None:
-                region_angles = []
-                for line in lines[:3]:  # Top 3 lines per region
-                    rho, theta = line[0]
-                    angle = np.degrees(theta) - 90
-                    if abs(angle) < 25:  # Near vertical lines
-                        region_angles.append(angle)
-                
-                if region_angles:
-                    region_angle = np.median(region_angles)
-                    angles.append(region_angle)
-                    confidence_scores.append(len(region_angles) / 3.0)
+        # Find strong vertical lines (spine alignment)
+        lines = cv2.HoughLines(spine_region, 1, np.pi/180, threshold=50)
+        if lines is not None:
+            for line in lines[:5]:  # Top 5 lines
+                rho, theta = line[0]
+                angle = np.degrees(theta) - 90
+                if abs(angle) < 30:  # Near vertical lines
+                    angles.append(angle)
         
-        # Method 2: Enhanced chest boundary detection
+        # Method 2: Chest boundary detection
+        # Find chest outline using contours
         contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
         if contours:
-            # Get top 2 largest contours
-            sorted_contours = sorted(contours, key=cv2.contourArea, reverse=True)[:2]
+            # Get largest contour (chest boundary)
+            largest_contour = max(contours, key=cv2.contourArea)
             
-            for contour in sorted_contours:
-                if len(contour) >= 5 and cv2.contourArea(contour) > h*w*0.01:
-                    try:
-                        ellipse = cv2.fitEllipse(contour)
-                        chest_angle = ellipse[2] - 90
-                        if abs(chest_angle) < 30:
-                            angles.append(chest_angle)
-                            confidence_scores.append(cv2.contourArea(contour) / (h*w))
-                    except:
-                        continue
+            # Fit ellipse to chest boundary
+            if len(largest_contour) >= 5:
+                ellipse = cv2.fitEllipse(largest_contour)
+                chest_angle = ellipse[2] - 90  # Convert to rotation angle
+                if abs(chest_angle) < 45:
+                    angles.append(chest_angle)
+        
+        # Method 3: Template-based symmetry detection
+        # Check left-right symmetry
+        left_half = img[:, :w//2]
+        right_half = np.fliplr(img[:, w//2:])
+        
+        # Try different rotation angles to find best symmetry
+        best_angle = 0
+        best_correlation = 0
         
-        # Method 3: Multi-scale template matching
-        for scale in [1.0, 0.8, 0.6]:
-            scaled_h, scaled_w = int(h * scale), int(w * scale)
-            if scaled_h < 100 or scaled_w < 100:
-                continue
-                
-            scaled_img = cv2.resize(img, (scaled_w, scaled_h))
-            left_half = scaled_img[:, :scaled_w//2]
-            right_half = np.fliplr(scaled_img[:, scaled_w//2:])
-            
-            best_angle = 0
-            best_correlation = 0
-            
-            for test_angle in range(-18, 19, 3):
-                if test_angle == 0:
-                    test_left = left_half
-                else:
-                    center = (left_half.shape[1]//2, left_half.shape[0]//2)
-                    rotation_matrix = cv2.getRotationMatrix2D(center, test_angle, 1.0)
-                    test_left = cv2.warpAffine(left_half, rotation_matrix, 
-                                             (left_half.shape[1], left_half.shape[0]))
-                
-                try:
-                    correlation = cv2.matchTemplate(test_left, right_half, cv2.TM_CCOEFF_NORMED).max()
-                    if correlation > best_correlation:
-                        best_correlation = correlation
-                        best_angle = test_angle
-                except:
-                    continue
+        for test_angle in range(-15, 16, 2):
+            if test_angle == 0:
+                test_left = left_half
+            else:
+                center = (left_half.shape[1]//2, left_half.shape[0]//2)
+                rotation_matrix = cv2.getRotationMatrix2D(center, test_angle, 1.0)
+                test_left = cv2.warpAffine(left_half, rotation_matrix, 
+                                         (left_half.shape[1], left_half.shape[0]))
             
-            if best_correlation > correlation_threshold:
-                angles.append(best_angle)
-                confidence_scores.append(best_correlation * scale)  # Weight by scale
-        
-        # Method 4: Vertical alignment detection
-        vertical_angle = detect_vertical_alignment(img)
-        if abs(vertical_angle) > 1:
-            angles.append(vertical_angle)
-            confidence_scores.append(0.7)
+            # Calculate correlation
+            correlation = cv2.matchTemplate(test_left, right_half, cv2.TM_CCOEFF_NORMED).max()
+            if correlation > best_correlation:
+                best_correlation = correlation
+                best_angle = test_angle
         
-        # Method 5: ML-based detection
-        ml_angle = ml_based_tilt_detection(img)
-        if abs(ml_angle) > 1:
-            angles.append(ml_angle)
-            confidence_scores.append(0.6)
+        if best_correlation > 0.3:  # Good symmetry found
+            angles.append(best_angle)
         
-        # Combine all methods with weighted averaging
-        if angles and confidence_scores:
+        # Combine all methods
+        if angles:
+            # Remove outliers using IQR
             angles = np.array(angles)
-            confidence_scores = np.array(confidence_scores)
+            Q1, Q3 = np.percentile(angles, [25, 75])
+            IQR = Q3 - Q1
+            filtered_angles = angles[(angles >= Q1 - 1.5*IQR) & (angles <= Q3 + 1.5*IQR)]
             
-            # Remove extreme outliers (more than 2.5 standard deviations)
-            if len(angles) > 2:
-                z_scores = np.abs((angles - np.mean(angles)) / np.std(angles))
-                mask = z_scores < 2.5
-                angles = angles[mask]
-                confidence_scores = confidence_scores[mask]
-            
-            if len(angles) > 0:
-                # Weighted average
-                weights = confidence_scores / np.sum(confidence_scores)
-                final_angle = np.average(angles, weights=weights)
-                overall_confidence = np.mean(confidence_scores)
-                
-                # Only return angle if confidence is sufficient and angle is significant
-                if overall_confidence > 0.3 and abs(final_angle) > 1.5:
-                    return final_angle, overall_confidence
+            if len(filtered_angles) > 0:
+                final_angle = np.median(filtered_angles)
+                return final_angle if abs(final_angle) > 1 else 0
         
-        return 0, 0
+        return 0
         
     except Exception as e:
         print(f"Error in advanced rotation detection: {e}")
-        return 0, 0
+        return 0
 
 def rotate_image(img, angle):
     """Rotate image by given angle"""
@@ -816,35 +541,18 @@ def segment(input_img):
         original_img = cv2.imread(input_img, 0) / 255.0
         original_shape = original_img.shape[:2]
         
-        # Step 1: Assess image quality
-        quality_scores = assess_image_quality(original_img)
-        print(f"Image quality assessment: {quality_scores['overall']:.2f}")
-        
-        # Step 2: Detect medical devices or special characteristics
-        image_characteristics = {
-            'has_medical_devices': False,  # Could be enhanced with device detection
-            'patient_age': 'adult',        # Could be inferred from image characteristics
-            'image_type': 'standard'       # PA, AP, lateral, etc.
-        }
-        
-        # Step 3: Get adaptive thresholds
-        thresholds = adaptive_thresholding(quality_scores, image_characteristics)
-        
-        # Step 4: Enhanced rotation detection with quality adaptation
-        detected_rotation, rotation_confidence = detect_image_rotation_advanced(original_img, quality_scores)
+        # Step 1: Enhanced rotation detection (re-enabled)
+        detected_rotation = detect_image_rotation_advanced(original_img)
         was_rotated = False
         processing_img = original_img
         
-        # Step 5: Rotate image if significant rotation detected (adaptive threshold)
-        rotation_threshold = thresholds['rotation_threshold']
-        if abs(detected_rotation) > rotation_threshold and rotation_confidence > 0.4:
+        # Step 2: Rotate image if significant rotation detected
+        if abs(detected_rotation) > 3:
             processing_img, actual_rotation = rotate_image(original_img, -detected_rotation)
             was_rotated = True
-            print(f"Applied rotation correction: {detected_rotation:.1f}° (confidence: {rotation_confidence:.2f})")
+            print(f"Applied rotation correction: {detected_rotation:.1f}°")
         else:
             actual_rotation = 0
-            if abs(detected_rotation) > 1:
-                print(f"Rotation detected ({detected_rotation:.1f}°) but below threshold or low confidence")
 
         # Step 3: Preprocess the image
         img, (h, w, padding) = preprocess(processing_img)
@@ -866,96 +574,50 @@ def segment(input_img):
         # Step 7: Convert output to int
         output = output.astype('int')
 
-        # Step 8: Enhanced landmark correction with adaptive thresholds
-        tilt_angle, rl_top, ll_top = calculate_image_tilt(output)
-        tilt_threshold = thresholds['tilt_threshold']
-        
-        # Apply tilt correction with enhanced validation
-        corrected_data = None
-        if abs(tilt_angle) > tilt_threshold:
-            image_center = np.array([original_shape[1]/2, original_shape[0]/2])
-            
-            # Test correction
-            RL_test = rotate_points(output[0:44], tilt_angle, image_center)
-            LL_test = rotate_points(output[44:94], tilt_angle, image_center)
-            H_test = rotate_points(output[94:], tilt_angle, image_center)
-            
-            corrected_landmarks = np.vstack([RL_test, LL_test, H_test])
-            
-            # Enhanced validation with adaptive threshold
-            validation_threshold = 0.08 if quality_scores['overall'] < 0.5 else 0.05
-            if validate_landmarks_consistency(corrected_landmarks, output, validation_threshold):
-                corrected_data = (RL_test, LL_test, H_test, tilt_angle)
-                print(f"Anatomical tilt correction applied: {tilt_angle:.1f}°")
-            else:
-                print(f"Tilt correction validation failed, using original landmarks")
-        
-        # Step 9: Draw results on original image
-        outseg, final_corrected_data = drawOnTop(original_img, output, original_shape)
-        
-        # Use corrected data if available
-        if corrected_data is not None:
-            final_corrected_data = corrected_data
+        # Step 8: Draw results on original image
+        outseg, corrected_data = drawOnTop(original_img, output, original_shape)
         
     except Exception as e:
         print(f"Error in segmentation: {e}")
-        # Return a basic error response with quality info
-        error_msg = f"Error: {str(e)}"
-        if 'quality_scores' in locals():
-            error_msg += f" | Image Quality: {quality_scores['overall']:.2f}"
-        return None, None, 0, error_msg
+        # Return a basic error response
+        return None, None, 0, f"Error: {str(e)}"
 
     seg_to_save = (outseg.copy() * 255).astype('uint8')
     cv2.imwrite("tmp/overlap_segmentation.png", cv2.cvtColor(seg_to_save, cv2.COLOR_RGB2BGR))
 
-    # Step 10: Enhanced CTR calculation with quality metrics
-    ctr_result = calculate_ctr_robust(output, final_corrected_data)
+    # Step 9: Robust CTR calculation
+    ctr_result = calculate_ctr_robust(output, corrected_data)
     ctr_value = ctr_result['ctr']
-    actual_tilt_angle = ctr_result['tilt_angle']
+    tilt_angle = ctr_result['tilt_angle']
     
-    # Enhanced interpretation with comprehensive quality indicators
+    # Enhanced interpretation with quality indicators
     interpretation_parts = []
     
-    # CTR interpretation with confidence adjustment
-    confidence_modifier = ""
-    if quality_scores['overall'] < 0.4:
-        confidence_modifier = " (Low Image Quality)"
-    elif ctr_result['confidence'] == 'Low':
-        confidence_modifier = " (Uncertain)"
-    
+    # CTR interpretation
     if ctr_value < 0.5:
-        base_interpretation = f"Normal{confidence_modifier}"
+        base_interpretation = "Normal"
     elif 0.50 <= ctr_value <= 0.55:
-        base_interpretation = f"Mild Cardiomegaly (CTR 50-55%){confidence_modifier}"
+        base_interpretation = "Mild Cardiomegaly (CTR 50-55%)"
     elif 0.56 <= ctr_value <= 0.60:
-        base_interpretation = f"Moderate Cardiomegaly (CTR 56-60%){confidence_modifier}"
+        base_interpretation = "Moderate Cardiomegaly (CTR 56-60%)"
     elif ctr_value > 0.60:
-        base_interpretation = f"Severe Cardiomegaly (CTR > 60%){confidence_modifier}"
+        base_interpretation = "Severe Cardiomegaly (CTR > 60%)"
     else:
-        base_interpretation = f"Cardiomegaly{confidence_modifier}"
+        base_interpretation = "Cardiomegaly"
     
     interpretation_parts.append(base_interpretation)
     
-    # Add processing quality indicators
-    quality_info = []
+    # Add quality indicators
     if was_rotated:
-        quality_info.append(f"Rotation: {detected_rotation:.1f}° (conf: {rotation_confidence:.2f})")
+        interpretation_parts.append(f"Image rotation corrected ({detected_rotation:.1f}°)")
     
     if ctr_result['correction_applied']:
-        quality_info.append(f"Tilt: {actual_tilt_angle:.1f}°")
-    elif actual_tilt_angle > tilt_threshold:
-        quality_info.append(f"Residual tilt: {actual_tilt_angle:.1f}°")
-    
-    # Add image quality score
-    quality_info.append(f"Quality: {quality_scores['overall']:.2f}")
-    quality_info.append(f"Confidence: {ctr_result['confidence']}")
-    
-    if quality_info:
-        interpretation_parts.append(" | ".join(quality_info))
+        interpretation_parts.append(f"Anatomical tilt corrected ({tilt_angle:.1f}°)")
+    elif tilt_angle > 3:
+        interpretation_parts.append(f"Residual tilt detected ({tilt_angle:.1f}°)")
     
-    # Add method variance warning if needed
-    if ctr_result['method_variance'] > 0.03:
-        interpretation_parts.append(f"⚠️ Method variance: {ctr_result['method_variance']:.3f}")
+    # Add confidence indicator
+    interpretation_parts.append(f"Confidence: {ctr_result['confidence']}")
     
     final_interpretation = " | ".join(interpretation_parts)