Update app.py

app.py

@@ -131,11 +131,6 @@ def drawOnTop(img, landmarks, original_shape):
     # Draw measurement lines that follow the image tilt for visual accuracy
     # Use corrected coordinates for accurate measurement, but draw tilted lines for visual appeal
     
-    # Calculate thoracic midline for bilateral measurements
-    thorax_xmin_corrected = min(np.min(RL_corrected[:, 0]), np.min(LL_corrected[:, 0]))
-    thorax_xmax_corrected = max(np.max(RL_corrected[:, 0]), np.max(LL_corrected[:, 0]))
-    thorax_midline_corrected = (thorax_xmin_corrected + thorax_xmax_corrected) / 2
-    
     # Heart (red line) - calculate positions from corrected coordinates
     heart_xmin_corrected = np.min(H_corrected[:, 0])
     heart_xmax_corrected = np.max(H_corrected[:, 0])
@@ -171,6 +166,9 @@ def drawOnTop(img, landmarks, original_shape):
                         (1, 0, 0), 2)
 
     # Thorax (blue line) - calculate positions from corrected coordinates
+    thorax_xmin_corrected = min(np.min(RL_corrected[:, 0]), np.min(LL_corrected[:, 0]))
+    thorax_xmax_corrected = max(np.max(RL_corrected[:, 0]), np.max(LL_corrected[:, 0]))
+    
     # Find y at leftmost and rightmost points (corrected)
     if np.min(RL_corrected[:, 0]) < np.min(LL_corrected[:, 0]):
         thorax_ymin_corrected = RL_corrected[np.argmin(RL_corrected[:, 0]), 1]
@@ -209,54 +207,6 @@ def drawOnTop(img, landmarks, original_shape):
                         (int(thorax_end[0] - perp_x), int(thorax_end[1] - perp_y)), 
                         (0, 0, 1), 2)
     
-    # === DRAW BILATERAL MEASUREMENT LINES ===
-    # Draw thoracic midline (vertical white dashed line)
-    midline_points_corrected = np.array([[thorax_midline_corrected, thorax_y_corrected - 100], 
-                                       [thorax_midline_corrected, thorax_y_corrected + 100]])
-    midline_points_display = rotate_points(midline_points_corrected, -tilt_angle, image_center)
-    
-    midline_start = (int(midline_points_display[0, 0]), int(midline_points_display[0, 1]))
-    midline_end = (int(midline_points_display[1, 0]), int(midline_points_display[1, 1]))
-    
-    # Draw dashed line by drawing short segments
-    dash_length = 10
-    gap_length = 5
-    total_length = np.sqrt((midline_end[0] - midline_start[0])**2 + (midline_end[1] - midline_start[1])**2)
-    num_segments = int(total_length / (dash_length + gap_length))
-    
-    for i in range(0, num_segments, 2):  # Every other segment for dashed effect
-        start_ratio = i * (dash_length + gap_length) / total_length
-        end_ratio = (i * (dash_length + gap_length) + dash_length) / total_length
-        if end_ratio > 1:
-            end_ratio = 1
-            
-        dash_start = (
-            int(midline_start[0] + start_ratio * (midline_end[0] - midline_start[0])),
-            int(midline_start[1] + start_ratio * (midline_end[1] - midline_start[1]))
-        )
-        dash_end = (
-            int(midline_start[0] + end_ratio * (midline_end[0] - midline_start[0])),
-            int(midline_start[1] + end_ratio * (midline_end[1] - midline_start[1]))
-        )
-        image = cv2.line(image, dash_start, dash_end, (1, 1, 1), 2)
-    
-    # Draw bilateral measurement lines
-    # Left side cardiac measurement (cyan)
-    left_cardiac_points = np.array([[thorax_midline_corrected, heart_y_corrected], [heart_xmin_corrected, heart_y_corrected]])
-    left_cardiac_display = rotate_points(left_cardiac_points, -tilt_angle, image_center)
-    image = cv2.line(image, 
-                    (int(left_cardiac_display[0, 0]), int(left_cardiac_display[0, 1])),
-                    (int(left_cardiac_display[1, 0]), int(left_cardiac_display[1, 1])), 
-                    (0, 1, 1), 2)
-    
-    # Right side cardiac measurement (yellow)
-    right_cardiac_points = np.array([[thorax_midline_corrected, heart_y_corrected], [heart_xmax_corrected, heart_y_corrected]])
-    right_cardiac_display = rotate_points(right_cardiac_points, -tilt_angle, image_center)
-    image = cv2.line(image, 
-                    (int(right_cardiac_display[0, 0]), int(right_cardiac_display[0, 1])),
-                    (int(right_cardiac_display[1, 0]), int(right_cardiac_display[1, 1])), 
-                    (1, 1, 0), 2)
-    
     # Store corrected landmarks for CTR calculation
     return image, (RL_corrected, LL_corrected, H_corrected, tilt_angle)
 
@@ -375,7 +325,7 @@ def validate_landmarks_consistency(landmarks, original_landmarks, threshold=0.05
         return False
 
 def calculate_ctr_robust(landmarks, corrected_landmarks=None):
-    """Calculate CTR with multiple validation steps and bilateral analysis"""
+    """Calculate CTR with multiple validation steps"""
     try:
         original_landmarks = landmarks.copy()
         
@@ -403,33 +353,9 @@ def calculate_ctr_robust(landmarks, corrected_landmarks=None):
             tilt_angle = 0
             correction_applied = False
         
-        # Calculate thoracic midline for bilateral analysis
-        thoracic_left_edge = min(np.min(RL[:, 0]), np.min(LL[:, 0]))
-        thoracic_right_edge = max(np.max(RL[:, 0]), np.max(LL[:, 0]))
-        thoracic_midline = (thoracic_left_edge + thoracic_right_edge) / 2
-        thoracic_width = thoracic_right_edge - thoracic_left_edge
-        
-        # Calculate cardiac boundaries
-        cardiac_left_edge = np.min(H[:, 0])
-        cardiac_right_edge = np.max(H[:, 0])
-        cardiac_center = np.mean(H[:, 0])
-        cardiac_width = cardiac_right_edge - cardiac_left_edge
-        
-        # === BILATERAL CTR ANALYSIS ===
-        # Left-side measurements (from thoracic midline to left edge)
-        left_thoracic_width = thoracic_midline - thoracic_left_edge
-        left_cardiac_width = thoracic_midline - cardiac_left_edge
-        left_ctr = left_cardiac_width / left_thoracic_width if left_thoracic_width > 0 else 0
-        
-        # Right-side measurements (from thoracic midline to right edge)  
-        right_thoracic_width = thoracic_right_edge - thoracic_midline
-        right_cardiac_width = cardiac_right_edge - thoracic_midline
-        right_ctr = right_cardiac_width / right_thoracic_width if right_thoracic_width > 0 else 0
-        
-        # === TRADITIONAL TOTAL CTR METHODS ===
         # Method 1: Traditional width measurement
-        cardiac_width_1 = cardiac_width
-        thoracic_width_1 = thoracic_width
+        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)
@@ -440,7 +366,7 @@ def calculate_ctr_robust(landmarks, corrected_landmarks=None):
         h_distances = np.linalg.norm(H - h_centroid, axis=1)
         cardiac_width_2 = 2 * np.max(h_distances)
         
-        thoracic_width_2 = thoracic_width
+        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]
@@ -469,22 +395,6 @@ def calculate_ctr_robust(landmarks, corrected_landmarks=None):
         # Use median of methods for final result
         final_ctr = np.median(ctr_values)
         
-        # === ASYMMETRY ANALYSIS ===
-        # Calculate cardiac asymmetry ratio (how much heart deviates to one side)
-        cardiac_shift = cardiac_center - thoracic_midline
-        cardiac_asymmetry_ratio = abs(cardiac_shift) / (thoracic_width / 2) if thoracic_width > 0 else 0
-        
-        # Determine which side the heart is shifted towards
-        if cardiac_shift > thoracic_width * 0.02:  # > 2% of thoracic width
-            heart_position = "Right-shifted"
-        elif cardiac_shift < -thoracic_width * 0.02:  # < -2% of thoracic width
-            heart_position = "Left-shifted"
-        else:
-            heart_position = "Centered"
-        
-        # Calculate bilateral ratio (left CTR / right CTR)
-        bilateral_ratio = left_ctr / right_ctr if right_ctr > 0 else 0
-        
         return {
             'ctr': round(final_ctr, 3),
             'tilt_angle': abs(tilt_angle),
@@ -495,17 +405,6 @@ def calculate_ctr_robust(landmarks, corrected_landmarks=None):
                 'traditional': round(ctr_1, 3),
                 'centroid': round(ctr_2, 3),
                 'percentile': round(ctr_3, 3)
-            },
-            # New bilateral analysis results
-            'bilateral_analysis': {
-                'left_ctr': round(left_ctr, 3),
-                'right_ctr': round(right_ctr, 3),
-                'bilateral_ratio': round(bilateral_ratio, 3),
-                'cardiac_asymmetry_ratio': round(cardiac_asymmetry_ratio, 3),
-                'heart_position': heart_position,
-                'thoracic_midline_x': round(thoracic_midline, 1),
-                'cardiac_center_x': round(cardiac_center, 1),
-                'cardiac_shift_px': round(cardiac_shift, 1)
             }
         }
         
@@ -517,17 +416,7 @@ def calculate_ctr_robust(landmarks, corrected_landmarks=None):
             'correction_applied': False,
             'confidence': 'Error',
             'method_variance': 0,
-            'individual_results': {},
-            'bilateral_analysis': {
-                'left_ctr': 0,
-                'right_ctr': 0,
-                'bilateral_ratio': 0,
-                'cardiac_asymmetry_ratio': 0,
-                'heart_position': 'Unknown',
-                'thoracic_midline_x': 0,
-                'cardiac_center_x': 0,
-                'cardiac_shift_px': 0
-            }
+            'individual_results': {}
         }
 
 
@@ -690,9 +579,8 @@ def segment(input_img):
         
     except Exception as e:
         print(f"Error in segmentation: {e}")
-        # Return a basic error response with all expected outputs
-        error_msg = f"Error: {str(e)}"
-        return None, None, 0, 0, 0, 0, 0, "Error", 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))
@@ -701,7 +589,6 @@ def segment(input_img):
     ctr_result = calculate_ctr_robust(output, corrected_data)
     ctr_value = ctr_result['ctr']
     tilt_angle = ctr_result['tilt_angle']
-    bilateral = ctr_result['bilateral_analysis']
     
     # Enhanced interpretation with quality indicators
     interpretation_parts = []
@@ -720,22 +607,6 @@ def segment(input_img):
     
     interpretation_parts.append(base_interpretation)
     
-    # Add bilateral analysis
-    bilateral_parts = []
-    bilateral_parts.append(f"L-CTR: {bilateral['left_ctr']}")
-    bilateral_parts.append(f"R-CTR: {bilateral['right_ctr']}")
-    bilateral_parts.append(f"L/R Ratio: {bilateral['bilateral_ratio']}")
-    
-    # Analyze cardiac position
-    if bilateral['heart_position'] != 'Centered':
-        bilateral_parts.append(f"Heart: {bilateral['heart_position']}")
-        
-    # Check for significant asymmetry
-    if bilateral['cardiac_asymmetry_ratio'] > 0.1:
-        bilateral_parts.append(f"Asymmetry: {bilateral['cardiac_asymmetry_ratio']:.2f}")
-    
-    interpretation_parts.append(" | ".join(bilateral_parts))
-    
     # Add quality indicators
     if was_rotated:
         interpretation_parts.append(f"Image rotation corrected ({detected_rotation:.1f}°)")
@@ -748,19 +619,9 @@ def segment(input_img):
     # Add confidence indicator
     interpretation_parts.append(f"Confidence: {ctr_result['confidence']}")
     
-    final_interpretation = "\n".join(interpretation_parts)
+    final_interpretation = " | ".join(interpretation_parts)
 
-    bilateral = ctr_result['bilateral_analysis']
-    
-    return (outseg, 
-            "tmp/overlap_segmentation.png", 
-            ctr_result['ctr'],  # Total CTR
-            bilateral['left_ctr'],  # Left CTR  
-            bilateral['right_ctr'],  # Right CTR
-            bilateral['bilateral_ratio'],  # L/R Ratio
-            bilateral['cardiac_asymmetry_ratio'],  # Asymmetry
-            bilateral['heart_position'],  # Heart Position
-            final_interpretation)  # Clinical Interpretation
+    return outseg, "tmp/overlap_segmentation.png", ctr_value, final_interpretation
 
 
 if __name__ == "__main__":
@@ -796,16 +657,8 @@ if __name__ == "__main__":
                     image_output = gr.Image(type="filepath", height=750)
 
                     with gr.Row():
-                        with gr.Column():
-                            ctr_total = gr.Number(label="Total CTR", precision=3)
-                            ctr_left = gr.Number(label="Left CTR", precision=3)  
-                            ctr_right = gr.Number(label="Right CTR", precision=3)
-                        with gr.Column():
-                            bilateral_ratio = gr.Number(label="L/R Ratio", precision=3)
-                            asymmetry_ratio = gr.Number(label="Asymmetry", precision=3)
-                            heart_position = gr.Textbox(label="Heart Position", interactive=False)
-                    
-                    ctr_interpretation = gr.Textbox(label="Clinical Interpretation", interactive=False, lines=4)
+                        ctr_output = gr.Number(label="CTR (Cardiothoracic Ratio)")
+                        ctr_interpretation = gr.Textbox(label="Interpretation", interactive=False)
 
                     results = gr.File()
 
@@ -852,8 +705,9 @@ if __name__ == "__main__":
 
         clear_button.click(lambda: None, None, image_input, queue=False)
         clear_button.click(lambda: None, None, image_output, queue=False)
-        clear_button.click(lambda: (None, None, None, None, None, None, None), None, [ctr_total, ctr_left, ctr_right, bilateral_ratio, asymmetry_ratio, heart_position, ctr_interpretation], queue=False)
+        clear_button.click(lambda: None, None, ctr_output, queue=False)
+        clear_button.click(lambda: None, None, ctr_interpretation, queue=False)
 
-        image_button.click(segment, inputs=image_input, outputs=[image_output, results, ctr_total, ctr_left, ctr_right, bilateral_ratio, asymmetry_ratio, heart_position, ctr_interpretation], queue=False)
+        image_button.click(segment, inputs=image_input, outputs=[image_output, results, ctr_output, ctr_interpretation], queue=False)
 
     demo.launch()