เทสสมการคำนวน CTR 001

app.py

@@ -293,48 +293,211 @@ def removePreprocess(output, info):
     return output
 
 
-def calculate_ctr(landmarks, corrected_landmarks=None):
-    if corrected_landmarks is not None:
-        RL, LL, H, tilt_angle = corrected_landmarks
-    else:
-        H = landmarks[94:]
+def validate_landmarks_consistency(landmarks, original_landmarks, threshold=0.05):
+    """Validate that corrected landmarks maintain anatomical consistency"""
+    try:
+        # Check if heart is still between lungs
         RL = landmarks[0:44]
         LL = landmarks[44:94]
-        tilt_angle = 0
-    
-    cardiac_width = np.max(H[:, 0]) - np.min(H[:, 0])
-    thoracic_width = max(np.max(RL[:, 0]), np.max(LL[:, 0])) - min(np.min(RL[:, 0]), np.min(LL[:, 0]))
-    ctr = cardiac_width / thoracic_width if thoracic_width > 0 else 0
-    return round(ctr, 3), abs(tilt_angle)
-
+        H = landmarks[94:]
+        
+        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
+        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
+            
+        return True
+        
+    except Exception as e:
+        print(f"Error in landmark validation: {e}")
+        return False
 
-def detect_image_rotation(img):
-    """Detect rotation angle of chest X-ray using basic image analysis"""
+def calculate_ctr_robust(landmarks, corrected_landmarks=None):
+    """Calculate CTR with multiple validation steps"""
     try:
-        # Apply edge detection
+        original_landmarks = landmarks.copy()
+        
+        if corrected_landmarks is not None:
+            RL, LL, H, tilt_angle = corrected_landmarks
+            
+            # Validate correction
+            corrected_all = np.vstack([RL, LL, H])
+            if validate_landmarks_consistency(corrected_all, original_landmarks):
+                landmarks_to_use = corrected_all
+                correction_applied = True
+            else:
+                # Use original landmarks if validation fails
+                H = landmarks[94:]
+                RL = landmarks[0:44]
+                LL = landmarks[44:94]
+                landmarks_to_use = landmarks
+                correction_applied = False
+                tilt_angle = 0
+        else:
+            H = landmarks[94:]
+            RL = landmarks[0:44]
+            LL = landmarks[44:94]
+            landmarks_to_use = landmarks
+            tilt_angle = 0
+            correction_applied = False
+        
+        # Method 1: Traditional width measurement
+        cardiac_width_1 = np.max(H[:, 0]) - np.min(H[:, 0])
+        thoracic_width_1 = max(np.max(RL[:, 0]), np.max(LL[:, 0])) - min(np.min(RL[:, 0]), np.min(LL[:, 0]))
+        
+        # Method 2: Centroid-based measurement (more robust to outliers)
+        h_centroid = np.mean(H, axis=0)
+        rl_centroid = np.mean(RL, axis=0)
+        ll_centroid = np.mean(LL, axis=0)
+        
+        # Find widest points from centroids
+        h_distances = np.linalg.norm(H - h_centroid, axis=1)
+        cardiac_width_2 = 2 * np.max(h_distances)
+        
+        thoracic_width_2 = max(np.max(RL[:, 0]), np.max(LL[:, 0])) - min(np.min(RL[:, 0]), np.min(LL[:, 0]))
+        
+        # Method 3: Percentile-based measurement (removes extreme outliers)
+        cardiac_x_coords = H[:, 0]
+        cardiac_width_3 = np.percentile(cardiac_x_coords, 95) - np.percentile(cardiac_x_coords, 5)
+        
+        lung_x_coords = np.concatenate([RL[:, 0], LL[:, 0]])
+        thoracic_width_3 = np.percentile(lung_x_coords, 95) - np.percentile(lung_x_coords, 5)
+        
+        # Calculate CTR for each method
+        ctr_1 = cardiac_width_1 / thoracic_width_1 if thoracic_width_1 > 0 else 0
+        ctr_2 = cardiac_width_2 / thoracic_width_2 if thoracic_width_2 > 0 else 0
+        ctr_3 = cardiac_width_3 / thoracic_width_3 if thoracic_width_3 > 0 else 0
+        
+        # Validate consistency between methods
+        ctr_values = [ctr_1, ctr_2, ctr_3]
+        ctr_std = np.std(ctr_values)
+        
+        if ctr_std > 0.05:  # High variance between methods
+            print(f"Warning: CTR calculation methods show high variance (std: {ctr_std:.3f})")
+            confidence = "Low"
+        elif ctr_std > 0.02:
+            confidence = "Medium"
+        else:
+            confidence = "High"
+        
+        # Use median of methods for final result
+        final_ctr = np.median(ctr_values)
+        
+        return {
+            'ctr': round(final_ctr, 3),
+            'tilt_angle': abs(tilt_angle),
+            'correction_applied': correction_applied,
+            'confidence': confidence,
+            'method_variance': round(ctr_std, 4),
+            'individual_results': {
+                'traditional': round(ctr_1, 3),
+                'centroid': round(ctr_2, 3),
+                'percentile': round(ctr_3, 3)
+            }
+        }
+        
+    except Exception as e:
+        print(f"Error in robust CTR calculation: {e}")
+        return {
+            'ctr': 0,
+            'tilt_angle': 0,
+            'correction_applied': False,
+            'confidence': 'Error',
+            'method_variance': 0,
+            'individual_results': {}
+        }
+
+
+def detect_image_rotation_advanced(img):
+    """Enhanced rotation detection using multiple methods"""
+    try:
+        angles = []
+        
+        # Method 1: Edge-based detection with focus on spine/mediastinum
         edges = cv2.Canny((img * 255).astype(np.uint8), 50, 150)
+        h, w = img.shape
         
-        # Find lines using Hough transform
-        lines = cv2.HoughLines(edges, 1, np.pi/180, threshold=100)
+        # Focus on central region where spine should be
+        spine_region = edges[h//4:3*h//4, w//3:2*w//3]
         
-        if lines is not None and len(lines) > 0:
-            angles = []
-            for line in lines[:min(10, len(lines))]:  # Consider top 10 lines
+        # 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  # Convert to rotation angle
-                # Filter for nearly horizontal or vertical lines
-                if abs(angle) < 30 or abs(angle) > 60:
+                angle = np.degrees(theta) - 90
+                if abs(angle) < 30:  # Near vertical lines
                     angles.append(angle)
+        
+        # Method 2: Chest boundary detection
+        # Find chest outline using contours
+        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)
             
-            if angles:
-                # Take median angle to avoid outliers
-                rotation_angle = np.median(angles)
-                if abs(rotation_angle) > 2:  # Only if significant rotation
-                    return rotation_angle
+            # 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 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]))
+            
+            # 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
+        
+        if best_correlation > 0.3:  # Good symmetry found
+            angles.append(best_angle)
+        
+        # Combine all methods
+        if angles:
+            # Remove outliers using IQR
+            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)]
+            
+            if len(filtered_angles) > 0:
+                final_angle = np.median(filtered_angles)
+                return final_angle if abs(final_angle) > 1 else 0
         
         return 0
+        
     except Exception as e:
-        print(f"Error in rotation detection: {e}")
+        print(f"Error in advanced rotation detection: {e}")
         return 0
 
 def rotate_image(img, angle):
@@ -378,28 +541,40 @@ def segment(input_img):
         original_img = cv2.imread(input_img, 0) / 255.0
         original_shape = original_img.shape[:2]
         
-        # Step 1: For now, skip rotation detection to avoid errors
-        # TODO: Re-implement rotation detection after fixing coordinate transformation
-        detected_rotation = 0  # Temporarily disabled
+        # Step 1: Enhanced rotation detection (re-enabled)
+        detected_rotation = detect_image_rotation_advanced(original_img)
         was_rotated = False
         processing_img = original_img
-
-        # Step 2: Preprocess the image
+        
+        # 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}°")
+        else:
+            actual_rotation = 0
+
+        # Step 3: Preprocess the image
         img, (h, w, padding) = preprocess(processing_img)
 
-        # Step 3: AI segmentation
+        # Step 4: AI segmentation
         data = torch.from_numpy(img).unsqueeze(0).unsqueeze(0).to(device).float()
 
         with torch.no_grad():
             output = hybrid(data)[0].cpu().numpy().reshape(-1, 2)
 
-        # Step 4: Remove preprocessing
+        # Step 5: Remove preprocessing
         output = removePreprocess(output, (h, w, padding))
         
-        # Step 5: Convert output to int
+        # Step 6: Rotate landmarks back if image was rotated
+        if was_rotated:
+            center = np.array([original_shape[1]/2, original_shape[0]/2])
+            output = rotate_points(output, actual_rotation, center)
+        
+        # Step 7: Convert output to int
         output = output.astype('int')
 
-        # Step 6: Draw results on original image
+        # Step 8: Draw results on original image
         outseg, corrected_data = drawOnTop(original_img, output, original_shape)
         
     except Exception as e:
@@ -410,32 +585,47 @@ def segment(input_img):
     seg_to_save = (outseg.copy() * 255).astype('uint8')
     cv2.imwrite("tmp/overlap_segmentation.png", cv2.cvtColor(seg_to_save, cv2.COLOR_RGB2BGR))
 
-    ctr_value, tilt_angle = calculate_ctr(output, corrected_data)
+    # Step 9: Robust CTR calculation
+    ctr_result = calculate_ctr_robust(output, corrected_data)
+    ctr_value = ctr_result['ctr']
+    tilt_angle = ctr_result['tilt_angle']
     
-    # Add rotation info to interpretation
-    rotation_warning = ""
-    if was_rotated:
-        rotation_warning = f" (🔄 Image was rotated {detected_rotation:.1f}° for AI processing)"
-    
-    # Add remaining tilt warning (after AI processing correction)
-    tilt_warning = ""
-    if tilt_angle > 5:
-        tilt_warning = f" (⚠️ Remaining tilt: {tilt_angle:.1f}°)"
-    elif tilt_angle > 2:
-        tilt_warning = f" (Minor tilt: {tilt_angle:.1f}°)"
+    # Enhanced interpretation with quality indicators
+    interpretation_parts = []
     
+    # CTR interpretation
     if ctr_value < 0.5:
-        interpretation = f"Normal{rotation_warning}{tilt_warning}"
-    elif 0.51 <= ctr_value <= 0.55:
-        interpretation = f"Mild Cardiomegaly (CTR 51-55%){rotation_warning}{tilt_warning}"
+        base_interpretation = "Normal"
+    elif 0.50 <= ctr_value <= 0.55:
+        base_interpretation = "Mild Cardiomegaly (CTR 50-55%)"
     elif 0.56 <= ctr_value <= 0.60:
-        interpretation = f"Moderate Cardiomegaly (CTR 56-60%){rotation_warning}{tilt_warning}"
+        base_interpretation = "Moderate Cardiomegaly (CTR 56-60%)"
     elif ctr_value > 0.60:
-        interpretation = f"Severe Cardiomegaly (CTR > 60%){rotation_warning}{tilt_warning}"
+        base_interpretation = "Severe Cardiomegaly (CTR > 60%)"
     else:
-        interpretation = f"Cardiomegaly{rotation_warning}{tilt_warning}"
+        base_interpretation = "Cardiomegaly"
+    
+    interpretation_parts.append(base_interpretation)
+    
+    # Add quality indicators
+    if was_rotated:
+        interpretation_parts.append(f"🔄 Image rotation corrected ({detected_rotation:.1f}°)")
+    
+    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}°)")
+    
+    # Add confidence indicator
+    confidence_icons = {'High': '✅', 'Medium': '⚡', 'Low': '⚠️', 'Error': '❌'}
+    interpretation_parts.append(f"{confidence_icons[ctr_result['confidence']]} Confidence: {ctr_result['confidence']}")
+    
+    if ctr_result['method_variance'] > 0.02:
+        interpretation_parts.append(f"📊 Method variance: {ctr_result['method_variance']:.3f}")
+    
+    final_interpretation = " | ".join(interpretation_parts)
 
-    return outseg, "tmp/overlap_segmentation.png", ctr_value, interpretation
+    return outseg, "tmp/overlap_segmentation.png", ctr_value, final_interpretation
 
 
 if __name__ == "__main__":