Default

app.py

@@ -111,10 +111,6 @@ def drawOnTop(img, landmarks, original_shape):
     tilt_text = f"Tilt: {tilt_angle:.1f} degrees"
     cv2.putText(image, tilt_text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 1, 0), 2)
     
-    # Add measurement method text
-    method_text = "Separate Lung Measurement"
-    cv2.putText(image, method_text, (10, h-30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0.8, 1), 2)
-    
     # Correct landmarks for tilt
     if abs(tilt_angle) > 2:  # Only correct if tilt is significant
         RL_corrected = rotate_points(RL, tilt_angle, image_center)
@@ -169,104 +165,46 @@ def drawOnTop(img, landmarks, original_shape):
                         (int(heart_end[0] - perp_x), int(heart_end[1] - perp_y)), 
                         (1, 0, 0), 2)
 
-    # Thorax measurement - separate left and right lung measurements
-    # Find widest points of each lung separately
-    rl_xmin = np.min(RL_corrected[:, 0])
-    rl_xmax = np.max(RL_corrected[:, 0])
-    ll_xmin = np.min(LL_corrected[:, 0])
-    ll_xmax = np.max(LL_corrected[:, 0])
-    
-    # Find center line (approximate midline of chest)
-    chest_center_x = (rl_xmin + rl_xmax + ll_xmin + ll_xmax) / 4
-    
-    # Right lung line: from rightmost point to center
-    rl_right_point = RL_corrected[np.argmax(RL_corrected[:, 0])]
-    rl_center_point = np.array([chest_center_x, rl_right_point[1]])
-    
-    # Left lung line: from leftmost point to center  
-    ll_left_point = LL_corrected[np.argmin(LL_corrected[:, 0])]
-    ll_center_point = np.array([chest_center_x, ll_left_point[1]])
-    
-    # Draw right lung measurement line (blue)
-    rl_points_corrected = np.array([rl_right_point, rl_center_point])
-    rl_points_display = rotate_points(rl_points_corrected, -tilt_angle, image_center)
-    rl_start = (int(rl_points_display[0, 0]), int(rl_points_display[0, 1]))
-    rl_end = (int(rl_points_display[1, 0]), int(rl_points_display[1, 1]))
-    image = cv2.line(image, rl_start, rl_end, (0, 0, 1), 2)
-    
-    # Draw left lung measurement line (blue)
-    ll_points_corrected = np.array([ll_left_point, ll_center_point])
-    ll_points_display = rotate_points(ll_points_corrected, -tilt_angle, image_center)
-    ll_start = (int(ll_points_display[0, 0]), int(ll_points_display[0, 1]))
-    ll_end = (int(ll_points_display[1, 0]), int(ll_points_display[1, 1]))
-    image = cv2.line(image, ll_start, ll_end, (0, 0, 1), 2)
-    
-    # Draw center line (dashed blue)
-    center_y_top = min(rl_right_point[1], ll_left_point[1]) - 50
-    center_y_bottom = max(rl_right_point[1], ll_left_point[1]) + 50
-    center_top = np.array([chest_center_x, center_y_top])
-    center_bottom = np.array([chest_center_x, center_y_bottom])
-    center_points_display = rotate_points(np.array([center_top, center_bottom]), -tilt_angle, image_center)
-    
-    # Draw dashed center line
-    center_start = (int(center_points_display[0, 0]), int(center_points_display[0, 1]))
-    center_end = (int(center_points_display[1, 0]), int(center_points_display[1, 1]))
+    # 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]))
     
-    # Create dashed line effect
-    line_length = np.sqrt((center_end[0] - center_start[0])**2 + (center_end[1] - center_start[1])**2)
-    dash_length = 10
-    num_dashes = int(line_length / (dash_length * 2))
+    # 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]
+    else:
+        thorax_ymin_corrected = LL_corrected[np.argmin(LL_corrected[:, 0]), 1]
+    if np.max(RL_corrected[:, 0]) > np.max(LL_corrected[:, 0]):
+        thorax_ymax_corrected = RL_corrected[np.argmax(RL_corrected[:, 0]), 1]
+    else:
+        thorax_ymax_corrected = LL_corrected[np.argmax(LL_corrected[:, 0]), 1]
+    thorax_y_corrected = np.mean([thorax_ymin_corrected, thorax_ymax_corrected])
     
-    for i in range(num_dashes):
-        start_ratio = (i * 2 * dash_length) / line_length
-        end_ratio = ((i * 2 + 1) * dash_length) / line_length
-        if end_ratio > 1:
-            end_ratio = 1
-        
-        dash_start_x = int(center_start[0] + (center_end[0] - center_start[0]) * start_ratio)
-        dash_start_y = int(center_start[1] + (center_end[1] - center_start[1]) * start_ratio)
-        dash_end_x = int(center_start[0] + (center_end[0] - center_start[0]) * end_ratio)
-        dash_end_y = int(center_start[1] + (center_end[1] - center_start[1]) * end_ratio)
-        
-        image = cv2.line(image, (dash_start_x, dash_start_y), (dash_end_x, dash_end_y), (0, 0.5, 1), 1)
+    # Rotate back to match the tilted image for display
+    thorax_points_corrected = np.array([[thorax_xmin_corrected, thorax_y_corrected], [thorax_xmax_corrected, thorax_y_corrected]])
+    thorax_points_display = rotate_points(thorax_points_corrected, -tilt_angle, image_center)  # Rotate back for display
     
-    # Add perpendicular lines at lung endpoints
-    line_length = 30
+    thorax_start = (int(thorax_points_display[0, 0]), int(thorax_points_display[0, 1]))
+    thorax_end = (int(thorax_points_display[1, 0]), int(thorax_points_display[1, 1]))
+    image = cv2.line(image, thorax_start, thorax_end, (0, 0, 1), 2)
     
-    # Right lung perpendicular lines
-    rl_dx = rl_end[0] - rl_start[0]
-    rl_dy = rl_end[1] - rl_start[1]
-    rl_length = np.sqrt(rl_dx**2 + rl_dy**2)
-    if rl_length > 0:
-        rl_perp_x = -rl_dy / rl_length * line_length
-        rl_perp_y = rl_dx / rl_length * line_length
-        
-        # Perpendicular lines at right lung endpoints
-        image = cv2.line(image, 
-                        (int(rl_start[0] + rl_perp_x), int(rl_start[1] + rl_perp_y)),
-                        (int(rl_start[0] - rl_perp_x), int(rl_start[1] - rl_perp_y)), 
-                        (0, 0, 1), 2)
-        image = cv2.line(image, 
-                        (int(rl_end[0] + rl_perp_x), int(rl_end[1] + rl_perp_y)),
-                        (int(rl_end[0] - rl_perp_x), int(rl_end[1] - rl_perp_y)), 
-                        (0, 0, 1), 2)
-    
-    # Left lung perpendicular lines
-    ll_dx = ll_end[0] - ll_start[0]
-    ll_dy = ll_end[1] - ll_start[1]
-    ll_length = np.sqrt(ll_dx**2 + ll_dy**2)
-    if ll_length > 0:
-        ll_perp_x = -ll_dy / ll_length * line_length
-        ll_perp_y = ll_dx / ll_length * line_length
-        
-        # Perpendicular lines at left lung endpoints
+    # Add perpendicular lines at thorax endpoints
+    thorax_dx = thorax_end[0] - thorax_start[0]
+    thorax_dy = thorax_end[1] - thorax_start[1]
+    thorax_length = np.sqrt(thorax_dx**2 + thorax_dy**2)
+    if thorax_length > 0:
+        perp_x = -thorax_dy / thorax_length * line_length
+        perp_y = thorax_dx / thorax_length * line_length
+        
+        # Perpendicular lines at start point
         image = cv2.line(image, 
-                        (int(ll_start[0] + ll_perp_x), int(ll_start[1] + ll_perp_y)),
-                        (int(ll_start[0] - ll_perp_x), int(ll_start[1] - ll_perp_y)), 
+                        (int(thorax_start[0] + perp_x), int(thorax_start[1] + perp_y)),
+                        (int(thorax_start[0] - perp_x), int(thorax_start[1] - perp_y)), 
                         (0, 0, 1), 2)
+        # Perpendicular lines at end point
         image = cv2.line(image, 
-                        (int(ll_end[0] + ll_perp_x), int(ll_end[1] + ll_perp_y)),
-                        (int(ll_end[0] - ll_perp_x), int(ll_end[1] - ll_perp_y)), 
+                        (int(thorax_end[0] + perp_x), int(thorax_end[1] + perp_y)),
+                        (int(thorax_end[0] - perp_x), int(thorax_end[1] - perp_y)), 
                         (0, 0, 1), 2)
     
     # Store corrected landmarks for CTR calculation
@@ -386,8 +324,8 @@ def validate_landmarks_consistency(landmarks, original_landmarks, threshold=0.05
         print(f"Error in landmark validation: {e}")
         return False
 
-def calculate_ctr_separate_lungs(landmarks, corrected_landmarks=None):
-    """Calculate CTR with separate left and right lung measurements (แบบแบ่งครึ่ง)"""
+def calculate_ctr_robust(landmarks, corrected_landmarks=None):
+    """Calculate CTR with multiple validation steps"""
     try:
         original_landmarks = landmarks.copy()
         
@@ -415,114 +353,70 @@ def calculate_ctr_separate_lungs(landmarks, corrected_landmarks=None):
             tilt_angle = 0
             correction_applied = False
         
-        # === การวัดแบบแบ่งครึ่ง (Separate Lung Measurement) ===
-        
-        # 1. หาจุดกึ่งกลางของหน้าอก (Midline)
-        chest_center_x = (np.min(RL[:, 0]) + np.max(RL[:, 0]) + np.min(LL[:, 0]) + np.max(LL[:, 0])) / 4
-        
-        # 2. การวัดความกว้างของหัวใจ (Cardiac Width)
-        cardiac_left = np.min(H[:, 0])    # ขอบซ้ายของหัวใจ
-        cardiac_right = np.max(H[:, 0])   # ขอบขวาของหัวใจ
-        cardiac_width_total = cardiac_right - cardiac_left
-        
-        # แบ่งความกว้างหัวใจออกเป็นซ้าย-ขวา
-        cardiac_left_width = chest_center_x - cardiac_left   # ความกว้างหัวใจฝั่งซ้าย
-        cardiac_right_width = cardiac_right - chest_center_x  # ความกว้างหัวใจฝั่งขวา
-        
-        # 3. การวัดความกว้างของปอด (Lung Width) แยกซ้าย-ขวา
-        right_lung_width = np.max(RL[:, 0]) - chest_center_x  # ความกว้างปอดขวา (จากกึ่งกลางไปขอบขวา)
-        left_lung_width = chest_center_x - np.min(LL[:, 0])   # ความกว้างปอดซ้าย (จากขอบซ้ายมาก��่งกลาง)
-        thoracic_width_total = right_lung_width + left_lung_width
+        # 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]))
         
-        # 4. คำนวณ CTR แบบต่างๆ
-        # CTR แบบดั้งเดิม (รวม)
-        ctr_traditional = cardiac_width_total / thoracic_width_total if thoracic_width_total > 0 else 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)
         
-        # CTR แบบแบ่งครึ่ง (แยกซ้าย-ขวา)
-        ctr_left_side = cardiac_left_width / left_lung_width if left_lung_width > 0 else 0
-        ctr_right_side = cardiac_right_width / right_lung_width if right_lung_width > 0 else 0
+        # Find widest points from centroids
+        h_distances = np.linalg.norm(H - h_centroid, axis=1)
+        cardiac_width_2 = 2 * np.max(h_distances)
         
-        # CTR เฉลี่ยจากการวัดแยก
-        ctr_separate_avg = (ctr_left_side + ctr_right_side) / 2
+        thoracic_width_2 = max(np.max(RL[:, 0]), np.max(LL[:, 0])) - min(np.min(RL[:, 0]), np.min(LL[:, 0]))
         
-        # 5. การวัดแบบ Percentile (ลดผลกระทบจากจุดผิดปกติ)
+        # Method 3: Percentile-based measurement (removes extreme outliers)
         cardiac_x_coords = H[:, 0]
-        cardiac_width_p95 = np.percentile(cardiac_x_coords, 95) - np.percentile(cardiac_x_coords, 5)
+        cardiac_width_3 = np.percentile(cardiac_x_coords, 95) - np.percentile(cardiac_x_coords, 5)
         
-        rl_x_coords = RL[:, 0]
-        ll_x_coords = LL[:, 0]
-        chest_center_x_p = (np.percentile(rl_x_coords, 50) + np.percentile(ll_x_coords, 50)) / 2
-        right_lung_width_p = np.percentile(rl_x_coords, 95) - chest_center_x_p
-        left_lung_width_p = chest_center_x_p - np.percentile(ll_x_coords, 5)
-        thoracic_width_p = right_lung_width_p + left_lung_width_p
+        lung_x_coords = np.concatenate([RL[:, 0], LL[:, 0]])
+        thoracic_width_3 = np.percentile(lung_x_coords, 95) - np.percentile(lung_x_coords, 5)
         
-        ctr_percentile = cardiac_width_p95 / thoracic_width_p if thoracic_width_p > 0 else 0
+        # 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
         
-        # 6. ตรวจสอบความสมมาตรของหัวใจ
-        cardiac_asymmetry = abs(cardiac_left_width - cardiac_right_width) / cardiac_width_total if cardiac_width_total > 0 else 0
-        lung_asymmetry = abs(left_lung_width - right_lung_width) / thoracic_width_total if thoracic_width_total > 0 else 0
-        
-        # 7. กำหนดค่าความเชื่อมั่น
-        ctr_values = [ctr_traditional, ctr_separate_avg, ctr_percentile]
+        # Validate consistency between methods
+        ctr_values = [ctr_1, ctr_2, ctr_3]
         ctr_std = np.std(ctr_values)
         
-        if ctr_std > 0.05:
+        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" 
+            confidence = "Medium"
         else:
             confidence = "High"
         
-        # เพิ่มการพิจารณาความสมมาตร
-        if cardiac_asymmetry > 0.3 or lung_asymmetry > 0.2:
-            confidence = "Low" if confidence == "High" else confidence
-        
-        # 8. ใช้ค่าเฉลี่ยถ่วงน้ำหนักสำหรับผลลัพธ์สุดท้าย
-        # ให้น้ำหนักมากกับ CTR แบบแบ่งครึ่งเพราะแม่นยำกว่า
-        final_ctr = (ctr_traditional * 0.3 + ctr_separate_avg * 0.5 + ctr_percentile * 0.2)
+        # Use median of methods for final result
+        final_ctr = np.median(ctr_values)
         
         return {
             'ctr': round(final_ctr, 3),
-            'ctr_traditional': round(ctr_traditional, 3),
-            'ctr_separate_avg': round(ctr_separate_avg, 3),
-            'ctr_left_side': round(ctr_left_side, 3),
-            'ctr_right_side': round(ctr_right_side, 3),
-            'cardiac_width_total': round(cardiac_width_total, 1),
-            'cardiac_left_width': round(cardiac_left_width, 1),
-            'cardiac_right_width': round(cardiac_right_width, 1),
-            'thoracic_width_total': round(thoracic_width_total, 1),
-            'left_lung_width': round(left_lung_width, 1),
-            'right_lung_width': round(right_lung_width, 1),
-            'cardiac_asymmetry': round(cardiac_asymmetry, 3),
-            'lung_asymmetry': round(lung_asymmetry, 3),
             'tilt_angle': abs(tilt_angle),
             'correction_applied': correction_applied,
             'confidence': confidence,
             'method_variance': round(ctr_std, 4),
-            'measurement_method': 'Separate Lung Analysis'
+            '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 separate lung CTR calculation: {e}")
+        print(f"Error in robust CTR calculation: {e}")
         return {
             'ctr': 0,
-            'ctr_traditional': 0,
-            'ctr_separate_avg': 0,
-            'ctr_left_side': 0,
-            'ctr_right_side': 0,
-            'cardiac_width_total': 0,
-            'cardiac_left_width': 0,
-            'cardiac_right_width': 0,
-            'thoracic_width_total': 0,
-            'left_lung_width': 0,
-            'right_lung_width': 0,
-            'cardiac_asymmetry': 0,
-            'lung_asymmetry': 0,
             'tilt_angle': 0,
             'correction_applied': False,
             'confidence': 'Error',
             'method_variance': 0,
-            'measurement_method': 'Error'
+            'individual_results': {}
         }
 
 
@@ -685,23 +579,23 @@ def segment(input_img):
         
     except Exception as e:
         print(f"Error in segmentation: {e}")
-        # Return a basic error response with all expected outputs
-        return None, None, 0, 0, 0, 0, 0, 0, f"Error: {str(e)}"
+        # 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 9: CTR calculation แบบแบ่งครึ่ง (Separate Lung Analysis)
-    ctr_result = calculate_ctr_separate_lungs(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']
     
-    # สร้างการแปลผลแบบละเอียด
+    # Enhanced interpretation with quality indicators
     interpretation_parts = []
     
     # CTR interpretation
     if ctr_value < 0.5:
-        base_interpretation = "Normal CTR"
+        base_interpretation = "Normal"
     elif 0.50 <= ctr_value <= 0.55:
         base_interpretation = "Mild Cardiomegaly (CTR 50-55%)"
     elif 0.56 <= ctr_value <= 0.60:
@@ -713,17 +607,6 @@ def segment(input_img):
     
     interpretation_parts.append(base_interpretation)
     
-    # เพิ่มข้อมูลการวัดแยกซ้าย-ขวา
-    if ctr_result['ctr_left_side'] > 0 and ctr_result['ctr_right_side'] > 0:
-        interpretation_parts.append(f"Left: {ctr_result['ctr_left_side']:.3f}, Right: {ctr_result['ctr_right_side']:.3f}")
-    
-    # ตรวจสอบความไม่สมมาตร
-    if ctr_result['cardiac_asymmetry'] > 0.2:
-        interpretation_parts.append(f"Cardiac asymmetry detected ({ctr_result['cardiac_asymmetry']:.2f})")
-    
-    if ctr_result['lung_asymmetry'] > 0.15:
-        interpretation_parts.append(f"Lung asymmetry detected ({ctr_result['lung_asymmetry']:.2f})")
-    
     # Add quality indicators
     if was_rotated:
         interpretation_parts.append(f"Image rotation corrected ({detected_rotation:.1f}°)")
@@ -733,37 +616,28 @@ def segment(input_img):
     elif tilt_angle > 3:
         interpretation_parts.append(f"Residual tilt detected ({tilt_angle:.1f}°)")
     
-    # Add confidence indicator and measurement method
-    interpretation_parts.append(f"Method: {ctr_result['measurement_method']}")
+    # Add confidence indicator
     interpretation_parts.append(f"Confidence: {ctr_result['confidence']}")
     
     final_interpretation = " | ".join(interpretation_parts)
 
-    return (outseg, "tmp/overlap_segmentation.png", ctr_value, 
-            ctr_result['ctr_traditional'], ctr_result['ctr_left_side'], 
-            ctr_result['ctr_right_side'], ctr_result['cardiac_width_total'], 
-            ctr_result['thoracic_width_total'], final_interpretation)
+    return outseg, "tmp/overlap_segmentation.png", ctr_value, final_interpretation
 
 
 if __name__ == "__main__":
     with gr.Blocks() as demo:
         gr.Markdown("""
-                    # Chest X-ray HybridGNet Segmentation with Advanced CTR Analysis
+                    # Chest X-ray HybridGNet Segmentation.
 
-                    Demo of the HybridGNet model with enhanced **Separate Lung CTR Measurement** (การวัด CTR แบบแบ่งครึ่ง)
+                    Demo of the HybridGNet model introduced in "Improving anatomical plausibility in medical image segmentation via hybrid graph neural networks: applications to chest x-ray analysis."
 
-                    ## Key Features:
-                    - **Separate Lung Analysis**: วัดปอดซ้าย-ขวาแยกกัน เหมือนในรูปที่คุณแนบมา
-                    - **Tilt Correction**: แก้ไขความเอียงของภาพอัตโนมัติ
-                    - **Asymmetry Detection**: ตรวจหาความไม่สมมาตรของหัวใจและปอด
-                    - **Multiple Measurement Methods**: รวมหลายวิธีการวัดเพื่อความแม่นยำ
+                    Instructions:
+                    1. Upload a chest X-ray image (PA or AP) in PNG or JPEG format.
+                    2. Click on "Segment Image".
 
-                    ## Instructions:
-                    1. Upload a chest X-ray image (PA or AP) in PNG or JPEG format
-                    2. Click on "Segment Image"
-                    3. ดูผลการวัด CTR แบบแยกซ้าย-ขวา พร้อมข้อมูลละเอียด
+                    Note: Pre-processing is not needed, it will be done automatically and removed after the segmentation.
 
-                    **Note**: ระบบจะประมวลผลและแก้ไขความเอียงของภาพอัตโนมัติ                   
+                    Please check citations below.                    
                     """)
 
         with gr.Tab("Segment Image"):
@@ -783,18 +657,8 @@ if __name__ == "__main__":
                     image_output = gr.Image(type="filepath", height=750)
 
                     with gr.Row():
-                        ctr_output = gr.Number(label="CTR (Overall)", precision=3)
-                        ctr_traditional = gr.Number(label="CTR (Traditional)", precision=3)
-                    
-                    with gr.Row():
-                        ctr_left = gr.Number(label="CTR Left Side", precision=3)
-                        ctr_right = gr.Number(label="CTR Right Side", precision=3)
-                    
-                    with gr.Row():
-                        cardiac_width = gr.Number(label="Cardiac Width (pixels)", precision=1)
-                        thoracic_width = gr.Number(label="Thoracic Width (pixels)", precision=1)
-                    
-                    ctr_interpretation = gr.Textbox(label="Detailed Analysis", interactive=False, lines=3)
+                        ctr_output = gr.Number(label="CTR (Cardiothoracic Ratio)")
+                        ctr_interpretation = gr.Textbox(label="Interpretation", interactive=False)
 
                     results = gr.File()
 
@@ -842,16 +706,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_traditional, queue=False)
-        clear_button.click(lambda: None, None, ctr_left, queue=False)
-        clear_button.click(lambda: None, None, ctr_right, queue=False)
-        clear_button.click(lambda: None, None, cardiac_width, queue=False)
-        clear_button.click(lambda: None, None, thoracic_width, queue=False)
         clear_button.click(lambda: None, None, ctr_interpretation, queue=False)
 
-        image_button.click(segment, inputs=image_input, 
-                          outputs=[image_output, results, ctr_output, ctr_traditional, 
-                                 ctr_left, ctr_right, cardiac_width, thoracic_width, ctr_interpretation], 
-                          queue=False)
+        image_button.click(segment, inputs=image_input, outputs=[image_output, results, ctr_output, ctr_interpretation], queue=False)
 
     demo.launch()