test 001

app.py

@@ -1,6 +1,12 @@
 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
@@ -49,6 +55,80 @@ 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
@@ -70,6 +150,85 @@ 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
@@ -301,27 +460,88 @@ 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
-        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
+        # 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)
         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:
-            print(f"Warning: Landmarks changed by {relative_change:.3f}, exceeds threshold {threshold}")
-            return False
+        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_)
             
-        return True
+            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
         
     except Exception as e:
-        print(f"Error in landmark validation: {e}")
+        print(f"Error in enhanced landmark validation: {e}")
         return False
 
 def calculate_ctr_robust(landmarks, corrected_landmarks=None):
@@ -420,85 +640,140 @@ def calculate_ctr_robust(landmarks, corrected_landmarks=None):
         }
 
 
-def detect_image_rotation_advanced(img):
-    """Enhanced rotation detection using multiple methods"""
+def detect_image_rotation_advanced(img, quality_scores=None):
+    """Enhanced rotation detection using multiple methods with quality adaptation"""
     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
         
-        # Focus on central region where spine should be
-        spine_region = edges[h//4:3*h//4, w//3:2*w//3]
+        # 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
         
-        # 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 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)
         
-        # Method 2: Chest boundary detection
-        # Find chest outline using contours
+        # Method 2: Enhanced chest boundary detection
         contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
         if contours:
-            # Get largest contour (chest boundary)
-            largest_contour = max(contours, key=cv2.contourArea)
+            # Get top 2 largest contours
+            sorted_contours = sorted(contours, key=cv2.contourArea, reverse=True)[:2]
             
-            # 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
+            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
         
-        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]))
+        # 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:])
             
-            # 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
+            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
+            
+            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)
         
-        if best_correlation > 0.3:  # Good symmetry found
-            angles.append(best_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)
         
-        # Combine all methods
-        if angles:
-            # Remove outliers using IQR
+        # Combine all methods with weighted averaging
+        if angles and confidence_scores:
             angles = np.array(angles)
-            Q1, Q3 = np.percentile(angles, [25, 75])
-            IQR = Q3 - Q1
-            filtered_angles = angles[(angles >= Q1 - 1.5*IQR) & (angles <= Q3 + 1.5*IQR)]
+            confidence_scores = np.array(confidence_scores)
             
-            if len(filtered_angles) > 0:
-                final_angle = np.median(filtered_angles)
-                return final_angle if abs(final_angle) > 1 else 0
+            # 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
         
-        return 0
+        return 0, 0
         
     except Exception as e:
         print(f"Error in advanced rotation detection: {e}")
-        return 0
+        return 0, 0
 
 def rotate_image(img, angle):
     """Rotate image by given angle"""
@@ -541,18 +816,35 @@ def segment(input_img):
         original_img = cv2.imread(input_img, 0) / 255.0
         original_shape = original_img.shape[:2]
         
-        # Step 1: Enhanced rotation detection (re-enabled)
-        detected_rotation = detect_image_rotation_advanced(original_img)
+        # 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)
         was_rotated = False
         processing_img = original_img
         
-        # Step 2: Rotate image if significant rotation detected
-        if abs(detected_rotation) > 3:
+        # 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:
             processing_img, actual_rotation = rotate_image(original_img, -detected_rotation)
             was_rotated = True
-            print(f"Applied rotation correction: {detected_rotation:.1f}°")
+            print(f"Applied rotation correction: {detected_rotation:.1f}° (confidence: {rotation_confidence:.2f})")
         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)
@@ -574,50 +866,96 @@ def segment(input_img):
         # Step 7: Convert output to int
         output = output.astype('int')
 
-        # Step 8: Draw results on original image
-        outseg, corrected_data = drawOnTop(original_img, output, original_shape)
+        # 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
         
     except Exception as e:
         print(f"Error in segmentation: {e}")
-        # Return a basic error response
-        return None, None, 0, f"Error: {str(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
 
     seg_to_save = (outseg.copy() * 255).astype('uint8')
     cv2.imwrite("tmp/overlap_segmentation.png", cv2.cvtColor(seg_to_save, cv2.COLOR_RGB2BGR))
 
-    # Step 9: Robust CTR calculation
-    ctr_result = calculate_ctr_robust(output, corrected_data)
+    # Step 10: Enhanced CTR calculation with quality metrics
+    ctr_result = calculate_ctr_robust(output, final_corrected_data)
     ctr_value = ctr_result['ctr']
-    tilt_angle = ctr_result['tilt_angle']
+    actual_tilt_angle = ctr_result['tilt_angle']
     
-    # Enhanced interpretation with quality indicators
+    # Enhanced interpretation with comprehensive quality indicators
     interpretation_parts = []
     
-    # CTR interpretation
+    # 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)"
+    
     if ctr_value < 0.5:
-        base_interpretation = "Normal"
+        base_interpretation = f"Normal{confidence_modifier}"
     elif 0.50 <= ctr_value <= 0.55:
-        base_interpretation = "Mild Cardiomegaly (CTR 50-55%)"
+        base_interpretation = f"Mild Cardiomegaly (CTR 50-55%){confidence_modifier}"
     elif 0.56 <= ctr_value <= 0.60:
-        base_interpretation = "Moderate Cardiomegaly (CTR 56-60%)"
+        base_interpretation = f"Moderate Cardiomegaly (CTR 56-60%){confidence_modifier}"
     elif ctr_value > 0.60:
-        base_interpretation = "Severe Cardiomegaly (CTR > 60%)"
+        base_interpretation = f"Severe Cardiomegaly (CTR > 60%){confidence_modifier}"
     else:
-        base_interpretation = "Cardiomegaly"
+        base_interpretation = f"Cardiomegaly{confidence_modifier}"
     
     interpretation_parts.append(base_interpretation)
     
-    # Add quality indicators
+    # Add processing quality indicators
+    quality_info = []
     if was_rotated:
-        interpretation_parts.append(f"Image rotation corrected ({detected_rotation:.1f}°)")
+        quality_info.append(f"Rotation: {detected_rotation:.1f}° (conf: {rotation_confidence:.2f})")
     
     if ctr_result['correction_applied']:
-        interpretation_parts.append(f"Anatomical tilt corrected ({tilt_angle:.1f}°)")
-    elif tilt_angle > 3:
-        interpretation_parts.append(f"Residual tilt detected ({tilt_angle:.1f}°)")
+        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))
     
-    # Add confidence indicator
-    interpretation_parts.append(f"Confidence: {ctr_result['confidence']}")
+    # Add method variance warning if needed
+    if ctr_result['method_variance'] > 0.03:
+        interpretation_parts.append(f"⚠️ Method variance: {ctr_result['method_variance']:.3f}")
     
     final_interpretation = " | ".join(interpretation_parts)