LR - Calculation TEST001

app.py

@@ -131,6 +131,11 @@ 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])
@@ -166,9 +171,6 @@ 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]
@@ -207,6 +209,54 @@ 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)
 
@@ -325,7 +375,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"""
+    """Calculate CTR with multiple validation steps and bilateral analysis"""
     try:
         original_landmarks = landmarks.copy()
         
@@ -353,9 +403,33 @@ 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 = 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]))
+        cardiac_width_1 = cardiac_width
+        thoracic_width_1 = thoracic_width
         
         # Method 2: Centroid-based measurement (more robust to outliers)
         h_centroid = np.mean(H, axis=0)
@@ -366,7 +440,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 = max(np.max(RL[:, 0]), np.max(LL[:, 0])) - min(np.min(RL[:, 0]), np.min(LL[:, 0]))
+        thoracic_width_2 = thoracic_width
         
         # Method 3: Percentile-based measurement (removes extreme outliers)
         cardiac_x_coords = H[:, 0]
@@ -395,6 +469,22 @@ 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),
@@ -405,6 +495,17 @@ 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)
             }
         }
         
@@ -416,7 +517,17 @@ def calculate_ctr_robust(landmarks, corrected_landmarks=None):
             'correction_applied': False,
             'confidence': 'Error',
             'method_variance': 0,
-            'individual_results': {}
+            '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
+            }
         }
 
 
@@ -579,8 +690,9 @@ def segment(input_img):
         
     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 all expected outputs
+        error_msg = f"Error: {str(e)}"
+        return None, None, 0, 0, 0, 0, 0, "Error", error_msg
 
     seg_to_save = (outseg.copy() * 255).astype('uint8')
     cv2.imwrite("tmp/overlap_segmentation.png", cv2.cvtColor(seg_to_save, cv2.COLOR_RGB2BGR))
@@ -589,6 +701,7 @@ 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 = []
@@ -607,6 +720,22 @@ 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}°)")
@@ -619,9 +748,19 @@ def segment(input_img):
     # Add confidence indicator
     interpretation_parts.append(f"Confidence: {ctr_result['confidence']}")
     
-    final_interpretation = " | ".join(interpretation_parts)
+    final_interpretation = "\n".join(interpretation_parts)
 
-    return outseg, "tmp/overlap_segmentation.png", ctr_value, final_interpretation
+    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
 
 
 if __name__ == "__main__":
@@ -657,8 +796,16 @@ if __name__ == "__main__":
                     image_output = gr.Image(type="filepath", height=750)
 
                     with gr.Row():
-                        ctr_output = gr.Number(label="CTR (Cardiothoracic Ratio)")
-                        ctr_interpretation = gr.Textbox(label="Interpretation", interactive=False)
+                        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)
 
                     results = gr.File()
 
@@ -705,9 +852,8 @@ 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, ctr_output, queue=False)
-        clear_button.click(lambda: None, None, ctr_interpretation, 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)
 
-        image_button.click(segment, inputs=image_input, outputs=[image_output, results, ctr_output, 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)
 
     demo.launch()