Update main.py

main.py

@@ -551,14 +551,48 @@ class WatermelonProcessor:
         target_rind_mask, rind_source, rind_overlap_ratio, r_warn = self.choose_target_rind_mask(rind_mask, flesh_combined)
         warnings.extend(r_warn)
         
-        # Bridge the gap for the unified flesh boundary (visuals and smoothed fit)
-        bridge_k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (45, 45))
-        flesh_closed = cv2.morphologyEx(flesh_combined, cv2.MORPH_CLOSE, bridge_k)
         mark("mask_parse")
 
-        # 3. EXTRACTION
+        # 3. EXTRACTION (Rind First)
         rind_data = self.get_polar_data(target_rind_mask)
+        if rind_data is None:
+            return fail("No stable perimeter.", measurement_unit="cm" if cm_per_px else "px", scale_source="color_checker" if cm_per_px else "original_pixels", color_checker_found=checker_corners is not None, rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio)
+
+        t_r, raw_r_r, (cx, cy), raw_rind_cnt = rind_data
+        pts_r_raw = raw_rind_cnt.reshape(-1, 2).astype(np.float32)
+
+        # --- NEW SCAN-LINE FLESH GAP FILLING (Preserves V-shape) ---
+        _, (ma, Ma), angle = cv2.fitEllipse(raw_rind_cnt) if len(raw_rind_cnt) > 5 else (None, (0,0), 0)
+        rot_angle = angle if ma < Ma else angle + 90
+        M_rot = cv2.getRotationMatrix2D((cx, cy), rot_angle, 1.0)
+        M_inv = cv2.getRotationMatrix2D((cx, cy), -rot_angle, 1.0)
+        
+        l_rot = cv2.warpAffine(flesh_l_m, M_rot, (w, h))
+        r_rot = cv2.warpAffine(flesh_r_m, M_rot, (w, h))
+        
+        l_idx = np.where(l_rot > 0)[1]
+        r_idx = np.where(r_rot > 0)[1]
+        if len(l_idx) > 0 and len(r_idx) > 0 and np.mean(l_idx) > np.mean(r_idx):
+            l_rot, r_rot = r_rot, l_rot
+            
+        flesh_closed_rot = cv2.bitwise_or(l_rot, r_rot)
+        y_l, y_r = np.where(l_rot > 0)[0], np.where(r_rot > 0)[0]
+        if len(y_l) > 0 and len(y_r) > 0:
+            for y in range(max(np.min(y_l), np.min(y_r)), min(np.max(y_l), np.max(y_r))):
+                row_l = np.where(l_rot[y, :] > 0)[0]
+                row_r = np.where(r_rot[y, :] > 0)[0]
+                if len(row_l) > 0 and len(row_r) > 0:
+                    x_start = row_l[-1]
+                    x_end = row_r[0]
+                    if x_start < x_end:
+                        flesh_closed_rot[y, x_start:x_end] = 255
+
+        flesh_closed = cv2.warpAffine(flesh_closed_rot, M_inv, (w, h))
+        _, flesh_closed = cv2.threshold(flesh_closed, 127, 255, cv2.THRESH_BINARY)
+
+        # Now extract the unified flesh data
         flesh_data = self.get_polar_data(flesh_closed)
+        # -----------------------------------------------------------
         if rind_data is None:
             return fail("No stable perimeter.", measurement_unit="cm" if cm_per_px else "px", scale_source="color_checker" if cm_per_px else "original_pixels", color_checker_found=checker_corners is not None, rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio)
 
@@ -683,46 +717,49 @@ class WatermelonProcessor:
                 
             def draw_base(r_m, f_m):
                 out = image.copy().astype(np.float32)
-                alpha = 0.42
-                # Green tint for rind
+                alpha = 0.21 # Half transparency
+                # Rind fill: Green
                 out[..., 0] = np.where(r_m > 0, out[..., 0]*(1-alpha) + 0, out[..., 0])
                 out[..., 1] = np.where(r_m > 0, out[..., 1]*(1-alpha) + 170, out[..., 1])
                 out[..., 2] = np.where(r_m > 0, out[..., 2]*(1-alpha) + 0, out[..., 2])
                 
-                # Orange/Flesh tint for the flesh
-                out[..., 0] = np.where(f_m > 0, out[..., 0]*(1-alpha) + 60, out[..., 0])
-                out[..., 1] = np.where(f_m > 0, out[..., 1]*(1-alpha) + 120, out[..., 1])
+                # Flesh fill: Red
+                out[..., 0] = np.where(f_m > 0, out[..., 0]*(1-alpha) + 0, out[..., 0])
+                out[..., 1] = np.where(f_m > 0, out[..., 1]*(1-alpha) + 0, out[..., 1])
                 out[..., 2] = np.where(f_m > 0, out[..., 2]*(1-alpha) + 255, out[..., 2])
                 
                 out = np.clip(out, 0, 255).astype(np.uint8)
-                if checker_corners is not None: cv2.polylines(out, [np.int32(checker_corners)], True, (0, 165, 255), 4)
+                if checker_corners is not None: 
+                    cv2.polylines(out, [np.int32(checker_corners)], True, (0, 165, 255), 4)
                 if len(midline) > 1: 
                     cv2.polylines(out, [midline.astype(np.int32)], False, (0, 255, 255), 3)
                     pt1, pt2 = tuple(midline[0].astype(int)), tuple(midline[-1].astype(int))
                     for pt in (pt1, pt2):
-                        cv2.circle(out, pt, 8, (0,0,0), 2); cv2.circle(out, pt, 6, (255,255,255), -1)
+                        cv2.circle(out, pt, 8, (0,0,0), 2)
+                        cv2.circle(out, pt, 6, (255,255,255), -1)
                 return out
 
             # RAW
             out_raw = draw_base(target_rind_mask, flesh_closed) 
             cv2.line(out_raw, raw_h_line[0], raw_h_line[1], (255, 100, 255), 2)
             cv2.line(out_raw, raw_w_line[0], raw_w_line[1], (255, 255, 100), 2)
-            # Flesh border first
+            
             f_cnts_raw, _ = cv2.findContours(flesh_closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-            if f_cnts_raw: cv2.polylines(out_raw, [max(f_cnts_raw, key=cv2.contourArea)], True, (255, 50, 50), 3)
-            # Rind border
-            cv2.polylines(out_raw, [raw_rind_cnt], True, (0, 200, 0), 3)
+            if f_cnts_raw: 
+                cv2.polylines(out_raw, [max(f_cnts_raw, key=cv2.contourArea)], True, (0, 0, 255), 2) # Red, 2px
+            cv2.polylines(out_raw, [raw_rind_cnt], True, (0, 200, 0), 2) # Dark Green, 2px
             res.image_raw_base64 = encode_img(out_raw)
 
             # SMOOTH
             if sm_rind_cnt is not None:
-                out_sm = draw_base(sm_rind_mask, sm_flesh_mask)
+                # Use raw fills for the smoothed preview (decoupled visual)
+                out_sm = draw_base(target_rind_mask, flesh_closed) 
                 cv2.line(out_sm, sm_h_line[0], sm_h_line[1], (255, 100, 255), 2)
                 cv2.line(out_sm, sm_w_line[0], sm_w_line[1], (255, 255, 100), 2)
                 
-                # Thinner lines, distinct bright colors
-                if sm_flesh_cnt is not None: cv2.polylines(out_sm, [sm_flesh_cnt], True, (255, 150, 50), 2)
-                cv2.polylines(out_sm, [sm_rind_cnt], True, (0, 255, 127), 2)
+                if sm_flesh_cnt is not None: 
+                    cv2.polylines(out_sm, [sm_flesh_cnt], True, (0, 0, 255), 2) # Red, 2px
+                cv2.polylines(out_sm, [sm_rind_cnt], True, (0, 200, 0), 2) # Dark Green, 2px
                 res.image_sm_base64 = encode_img(out_sm)
             
         mark("render")