Update src/ai_processor.py

src/ai_processor.py

@@ -766,182 +766,34 @@ class AIProcessor:
         self.dataset_id = DATASET_ID
         self.hf_token = HF_TOKEN
 
-    # ---------------------------------------------------------------------
-    # Skin tone estimation helpers
-    # ---------------------------------------------------------------------
-    def _estimate_skin_tone(self, bgr_roi: np.ndarray, mask01: np.ndarray) -> Tuple[str, float]:
-        """
-        Estimate the Fitzpatrick skin tone based on the non-wound region within the ROI.
-        We convert to CIELAB, compute the mean L* and b* over non-wound pixels and
-        derive the Individual Typology Angle (ITA). The ITA is then mapped to a
-        Fitzpatrick skin type using Del Bino et al. ranges【854677944493859†L221-L227】.
-        Returns a (label, ita_degrees) tuple.
-        """
-        try:
-            # Convert ROI to Lab (OpenCV uses L:0-100, a,b:-128..127)
-            lab = cv2.cvtColor(bgr_roi, cv2.COLOR_BGR2LAB).astype(np.float32)
-            L = lab[..., 0] * (100.0 / 255.0)  # scale L to [0,100]
-            b_channel = lab[..., 2] - 128.0    # b* in [-128,127]
-            # Invert mask to sample non-wound skin
-            non_wound = (mask01 == 0)
-            if non_wound.sum() == 0:
-                # fallback: use entire ROI
-                non_wound = np.ones_like(mask01, dtype=bool)
-            mean_L = float(L[non_wound].mean())
-            mean_b = float(b_channel[non_wound].mean())
-            # Compute ITA (Del Bino): arctan((L* - 50)/b*) * 180/pi
-            # Avoid division by zero
-            ita_rad = np.arctan2((mean_L - 50.0), max(mean_b, 1e-6))
-            ita_deg = float(np.degrees(ita_rad))
-            # Map ITA to Fitzpatrick type (Del Bino classification)
-            # Very light: ITA>55; Light:41-55; Intermediate:28-41; Tan:10-28;
-            # Brown:-30 to 10; Dark:<=-30【854677944493859†L221-L227】
-            if ita_deg > 55:
-                label = "Type I (Very Light)"
-            elif ita_deg > 41:
-                label = "Type II (Light)"
-            elif ita_deg > 28:
-                label = "Type III (Intermediate)"
-            elif ita_deg > 10:
-                label = "Type IV (Tan)"
-            elif ita_deg > -30:
-                label = "Type V (Brown)"
-            else:
-                label = "Type VI (Dark)"
-            return label, ita_deg
-        except Exception:
-            return "Unknown", 0.0
-
-    # ---------------------------------------------------------------------
-    # Tissue classification helpers
-    # ---------------------------------------------------------------------
-    def _classify_tissue_map(self, bgr_roi: np.ndarray, mask01: np.ndarray) -> Tuple[np.ndarray, str]:
-        """
-        Classify each pixel in the wound mask into tissue types based on HSV.
-        - Necrotic: very dark (V<50)
-        - Slough: yellow/green hues (Hue between ~15 and ~40 in OpenCV's 0-179 scale)
-        - Granulation: remaining (reds/oranges)
-        Returns the classification map (same size as mask) with integer codes
-        (0=background/outside wound, 1=granulation, 2=slough, 3=necrotic) and a
-        summary label based on majority class.
-        """
-        h, w = mask01.shape
-        class_map = np.zeros((h, w), dtype=np.uint8)
-        try:
-            hsv = cv2.cvtColor(bgr_roi, cv2.COLOR_BGR2HSV)
-            H, S, V = cv2.split(hsv)
-            # Define masks within wound
-            wound_pixels = (mask01 == 1)
-            # Initialize counts
-            counts = {1: 0, 2: 0, 3: 0}
-            # Classification thresholds
-            # Compute categories using boolean masks for performance
-            necrotic_mask = (V < 50) & wound_pixels
-            # Hue thresholds for slough (yellow) in OpenCV scale (0-179). Yellow ~ 15-40
-            slough_mask = (H >= 15) & (H <= 40) & (V >= 50) & wound_pixels
-            # Remaining wound pixels are granulation
-            granulation_mask = wound_pixels & (~necrotic_mask) & (~slough_mask)
-            class_map[granulation_mask] = 1
-            class_map[slough_mask] = 2
-            class_map[necrotic_mask] = 3
-            counts[1] = int(granulation_mask.sum())
-            counts[2] = int(slough_mask.sum())
-            counts[3] = int(necrotic_mask.sum())
-            total = sum(counts.values())
-            # Determine summary type
-            if total == 0:
-                return class_map, "Unknown"
-            # Compute percentages
-            percents = {k: v / total for k, v in counts.items()}
-            max_class = max(percents, key=percents.get)
-            if percents[max_class] < 0.6:
-                summary = "Mixed"
-            else:
-                summary = {1: "Granulation", 2: "Slough", 3: "Necrotic"}.get(max_class, "Unknown")
-            return class_map, summary
-        except Exception:
-            return class_map, "Unknown"
-
-    def _create_tissue_overlay(self, roi: np.ndarray, mask01: np.ndarray, class_map: np.ndarray) -> np.ndarray:
-        """
-        Create a colored overlay for the wound region based on tissue classification.
-        Colors: granulation→red, slough→yellow, necrotic→black. Outside the wound
-        region retains the original ROI. Blending uses alpha to retain texture.
-        """
-        overlay = roi.copy()
-        try:
-            # Define color mapping BGR
-            colors = {
-                1: np.array([0, 0, 255], dtype=np.uint8),      # granulation: red
-                2: np.array([0, 255, 255], dtype=np.uint8),    # slough: yellow
-                3: np.array([0, 0, 0], dtype=np.uint8),        # necrotic: black (eschar)
-            }
-            alpha = 0.5
-            for class_id, color in colors.items():
-                mask_cls = (class_map == class_id)
-                if mask_cls.any():
-                    # Create a color array same shape as ROI
-                    col_img = np.zeros_like(roi)
-                    col_img[:] = color
-                    # Blend only for class pixels
-                    overlay[mask_cls] = cv2.addWeighted(roi[mask_cls], 1 - alpha, col_img[mask_cls], alpha, 0)
-            # Draw boundary of wound
-            cnts, _ = cv2.findContours((mask01 * 255).astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-            if cnts:
-                cv2.drawContours(overlay, cnts, -1, (255, 255, 255), 2)
-        except Exception:
-            pass
-        return overlay
-
     def _ensure_analysis_dir(self) -> str:
         out_dir = os.path.join(self.uploads_dir, "analysis")
         os.makedirs(out_dir, exist_ok=True)
         return out_dir
 
-    def perform_visual_analysis(
-        self,
-        image_pil: Image.Image,
-        manual_mask_path: Optional[str] = None,
-        mask_adjustment: int = 0
-    ) -> Dict:
+    def perform_visual_analysis(self, image_pil: Image.Image) -> Dict:
         """
-        Perform the visual analysis pipeline with optional manual mask and adjustment.
-        Steps:
-        1) Detect the wound ROI using YOLO.
-        2) If manual_mask_path is provided, use it as the wound mask; otherwise run
-           segmentation (model-first, fallback to KMeans) and clean the result.
-        3) Apply optional morphological adjustment (dilation/erosion) to fine-tune
-           the mask.
-        4) Measure length, width, and area in cm using EXIF-calibrated px/cm.
-        5) Compute skin tone and tissue classification within the ROI.
-        6) Generate color-coded overlays and save outputs.
-        Returns a dictionary with measurements, paths, and classification info.
+        YOLO detect → crop ROI → segment_wound(ROI) → clean mask →
+        minAreaRect measurement (cm) using EXIF px/cm → save outputs.
         """
         try:
-            # Calibration via EXIF
             px_per_cm, exif_meta = estimate_px_per_cm_from_exif(image_pil, DEFAULT_PX_PER_CM)
+            # Guardrails for calibration to avoid huge area blow-ups
             px_per_cm = float(np.clip(px_per_cm, 20.0, 350.0))
             if (exif_meta or {}).get("used") != "exif":
-                logging.warning(
-                    f"Calibration fallback used: px_per_cm={px_per_cm:.2f} (default). Prefer ruler/Aruco for accuracy."
-                )
+                logging.warning(f"Calibration fallback used: px_per_cm={px_per_cm:.2f} (default). Prefer ruler/Aruco for accuracy.")
 
-            # Convert full image to BGR
             image_cv = cv2.cvtColor(np.array(image_pil.convert("RGB")), cv2.COLOR_RGB2BGR)
 
             # --- Detection ---
             det_model = self.models_cache.get("det")
             if det_model is None:
                 raise RuntimeError("YOLO model not loaded")
-            # CPU inference
+            # Force CPU inference and avoid CUDA touch
             results = det_model.predict(image_cv, verbose=False, device="cpu")
-            if (
-                not results
-                or not getattr(results[0], "boxes", None)
-                or len(results[0].boxes) == 0
-            ):
+            if (not results) or (not getattr(results[0], "boxes", None)) or (len(results[0].boxes) == 0):
                 try:
-                    import gradio as gr  # type: ignore
+                    import gradio as gr
                     raise gr.Error("No wound could be detected.")
                 except Exception:
                     raise RuntimeError("No wound could be detected.")
@@ -953,7 +805,7 @@ class AIProcessor:
             roi = image_cv[y1:y2, x1:x2].copy()
             if roi.size == 0:
                 try:
-                    import gradio as gr  # type: ignore
+                    import gradio as gr
                     raise gr.Error("Detected ROI is empty.")
                 except Exception:
                     raise RuntimeError("Detected ROI is empty.")
@@ -961,49 +813,15 @@ class AIProcessor:
             out_dir = self._ensure_analysis_dir()
             ts = datetime.now().strftime("%Y%m%d_%H%M%S")
 
-            # --- Mask determination ---
-            seg_debug = {"used": None, "reason": None, "positive_fraction": 0.0, "thr": None}
-            if manual_mask_path and os.path.exists(manual_mask_path):
-                try:
-                    user_mask = cv2.imread(manual_mask_path, cv2.IMREAD_GRAYSCALE)
-                    # Resize to ROI if needed
-                    if user_mask.shape != roi.shape[:2]:
-                        user_mask = cv2.resize(user_mask, (roi.shape[1], roi.shape[0]), interpolation=cv2.INTER_NEAREST)
-                    mask01 = (user_mask > 127).astype(np.uint8)
-                    # Clean mask
-                    if mask01.any():
-                        mask01 = _clean_mask(mask01)
-                    seg_debug.update({"used": "manual_mask", "reason": "provided_by_user"})
-                except Exception as e:
-                    logging.warning(f"Manual mask load failed: {e}; falling back to auto segmentation")
-                    manual_mask_path = None
-                    mask01 = None  # to be set by auto segmentation
-            else:
-                mask01 = None
-
-            if mask01 is None:
-                # Run segmentation
-                mask_u8_255, seg_debug = segment_wound(roi, ts, out_dir)
-                mask01 = (mask_u8_255 > 127).astype(np.uint8)
-                if mask01.any():
-                    mask01 = _clean_mask(mask01)
-                    logging.debug(f"Mask postproc: px_after={int(mask01.sum())}")
-                else:
-                    logging.debug("Segmentation produced empty mask")
-
-            # --- Apply morphological adjustment ---
-            if mask01.any() and isinstance(mask_adjustment, (int, float)):
-                adj = int(mask_adjustment)
-                if adj != 0:
-                    k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
-                    if adj > 0:
-                        mask01 = cv2.dilate(mask01, k, iterations=adj)
-                    elif adj < 0:
-                        mask01 = cv2.erode(mask01, k, iterations=abs(adj))
-                    # Re-clean to keep a single connected region
-                    mask01 = _clean_mask(mask01)
-
-            # --- Measurement ---
+            # --- Segmentation (model-first + KMeans fallback) ---
+            mask_u8_255, seg_debug = segment_wound(roi, ts, out_dir)
+            mask01 = (mask_u8_255 > 127).astype(np.uint8)
+
+            if mask01.any():
+                mask01 = _clean_mask(mask01)
+                logging.debug(f"Mask postproc: px_after={int(mask01.sum())}")
+
+            # --- Measurement (accurate & conservative) ---
             if mask01.any():
                 length_cm, breadth_cm, (box_pts, _) = measure_min_area_rect(mask01, px_per_cm)
                 area_poly_cm2, largest_cnt = area_cm2_from_contour(mask01, px_per_cm)
@@ -1011,69 +829,62 @@ class AIProcessor:
                     surface_area_cm2 = clamp_area_with_minrect(largest_cnt, px_per_cm, area_poly_cm2)
                 else:
                     surface_area_cm2 = area_poly_cm2
+
+                anno_roi = draw_measurement_overlay(roi, mask01, box_pts, length_cm, breadth_cm)
                 segmentation_empty = False
             else:
-                # Use ROI bounding box dimensions as fallback
-                h_px = max(0, y2 - y1)
-                w_px = max(0, x2 - x1)
+                # Fallback if seg failed: use ROI dimensions
+                h_px = max(0, y2 - y1); w_px = max(0, x2 - x1)
                 length_cm = round(max(h_px, w_px) / px_per_cm, 2)
                 breadth_cm = round(min(h_px, w_px) / px_per_cm, 2)
                 surface_area_cm2 = round((h_px * w_px) / (px_per_cm ** 2), 2)
+                anno_roi = roi.copy()
+                cv2.rectangle(anno_roi, (2, 2), (anno_roi.shape[1]-3, anno_roi.shape[0]-3), (0, 0, 255), 3)
+                cv2.line(anno_roi, (0, 0), (anno_roi.shape[1]-1, anno_roi.shape[0]-1), (0, 0, 255), 2)
+                cv2.line(anno_roi, (anno_roi.shape[1]-1, 0), (0, anno_roi.shape[0]-1), (0, 0, 255), 2)
                 box_pts = None
                 segmentation_empty = True
 
-            # --- Skin tone and tissue classification ---
-            skin_label, ita_deg = self._estimate_skin_tone(roi, mask01)
-            tissue_map, tissue_type = self._classify_tissue_map(roi, mask01)
-
-            # --- Overlays ---
-            # ROI overlay: color-coded by tissue type
-            if mask01.any():
-                roi_overlay = self._create_tissue_overlay(roi, mask01, tissue_map)
-            else:
-                roi_overlay = roi.copy()
-
-            # Annotated ROI with measurement arrows
-            if not segmentation_empty:
-                anno_roi = draw_measurement_overlay(roi, mask01, box_pts, length_cm, breadth_cm)
-            else:
-                # Draw bounding box lines on fallback ROI
-                anno_roi = roi.copy()
-                cv2.rectangle(
-                    anno_roi,
-                    (2, 2),
-                    (anno_roi.shape[1] - 3, anno_roi.shape[0] - 3),
-                    (0, 0, 255),
-                    3,
-                )
-                cv2.line(anno_roi, (0, 0), (anno_roi.shape[1] - 1, anno_roi.shape[0] - 1), (0, 0, 255), 2)
-                cv2.line(anno_roi, (anno_roi.shape[1] - 1, 0), (0, anno_roi.shape[0] - 1), (0, 0, 255), 2)
-
-            # Save files
+            # --- Save visualizations ---
             original_path = os.path.join(out_dir, f"original_{ts}.png")
             cv2.imwrite(original_path, image_cv)
-            # Detection visualization
+
             det_vis = image_cv.copy()
             cv2.rectangle(det_vis, (x1, y1), (x2, y2), (0, 255, 0), 2)
             detection_path = os.path.join(out_dir, f"detection_{ts}.png")
             cv2.imwrite(detection_path, det_vis)
-            # Save mask
+
             roi_mask_path = os.path.join(out_dir, f"roi_mask_{ts}.png")
             cv2.imwrite(roi_mask_path, (mask01 * 255).astype(np.uint8))
-            # Save ROI overlay (tissue color-coded)
+
+            # ROI overlay (mask tint + contour, without arrows)
+            mask255 = (mask01 * 255).astype(np.uint8)
+            mask3   = cv2.merge([mask255, mask255, mask255])
+            red     = np.zeros_like(roi); red[:] = (0, 0, 255)
+            alpha   = 0.55
+            tinted  = cv2.addWeighted(roi, 1 - alpha, red, alpha, 0)
+            if mask255.any():
+                roi_overlay = np.where(mask3 > 0, tinted, roi)
+                cnts, _ = cv2.findContours(mask255, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+                cv2.drawContours(roi_overlay, cnts, -1, (255, 255, 255), 2)
+            else:
+                roi_overlay = anno_roi
+
             seg_full = image_cv.copy()
             seg_full[y1:y2, x1:x2] = roi_overlay
             segmentation_path = os.path.join(out_dir, f"segmentation_{ts}.png")
             cv2.imwrite(segmentation_path, seg_full)
+
             segmentation_roi_path = os.path.join(out_dir, f"segmentation_roi_{ts}.png")
             cv2.imwrite(segmentation_roi_path, roi_overlay)
-            # Annotated full-frame overlay
+
+            # Annotated (mask + arrows + labels) in full-frame
             anno_full = image_cv.copy()
             anno_full[y1:y2, x1:x2] = anno_roi
             annotated_seg_path = os.path.join(out_dir, f"segmentation_annotated_{ts}.png")
             cv2.imwrite(annotated_seg_path, anno_full)
 
-            # --- Optional wound type classification ---
+            # --- Optional classification ---
             wound_type = "Unknown"
             cls_pipe = self.models_cache.get("cls")
             if cls_pipe is not None:
@@ -1084,7 +895,7 @@ class AIProcessor:
                 except Exception as e:
                     logging.warning(f"Classification failed: {e}")
 
-            # Log segmentation summary
+            # Log end-of-seg summary
             seg_summary = {
                 "seg_used": seg_debug.get("used"),
                 "seg_reason": seg_debug.get("reason"),
@@ -1102,7 +913,8 @@ class AIProcessor:
                 "surface_area_cm2": surface_area_cm2,
                 "px_per_cm": round(px_per_cm, 2),
                 "calibration_meta": exif_meta,
-                # detection_confidence is intentionally omitted (removed from UI)
+                "detection_confidence": float(results[0].boxes.conf[0].cpu().item())
+                    if getattr(results[0].boxes, "conf", None) is not None else 0.0,
                 "detection_image_path": detection_path,
                 "segmentation_image_path": annotated_seg_path,
                 "segmentation_annotated_path": annotated_seg_path,
@@ -1111,14 +923,55 @@ class AIProcessor:
                 "segmentation_empty": segmentation_empty,
                 "segmentation_debug": seg_debug,
                 "original_image_path": original_path,
-                "skin_tone_label": skin_label,
-                "ita_degrees": round(ita_deg, 2),
-                "tissue_type": tissue_type,
             }
         except Exception as e:
             logging.error(f"Visual analysis failed: {e}", exc_info=True)
             raise
 
+    # -------------------------------------------------------------------------
+    # Helper: refine measurements from a binary mask
+    # -------------------------------------------------------------------------
+    def _refine_metrics_from_mask(self, mask: np.ndarray, px_per_cm: float) -> Tuple[float, float, float]:
+        """
+        Given a binary mask and pixel‑per‑centimeter calibration, compute length, breadth and area.
+
+        The mask should be a 2D numpy array of dtype uint8 or bool where 1 indicates wound pixels.
+
+        Parameters
+        ----------
+        mask : np.ndarray
+            Binary mask of the wound region, shape (H, W). Non‑zero values denote wound pixels.
+        px_per_cm : float
+            Estimated pixels per centimeter calibration factor.
+
+        Returns
+        -------
+        tuple[float, float, float]
+            (length_cm, breadth_cm, area_cm2)
+
+        Notes
+        -----
+        This method approximates the wound measurements by computing the axis‑aligned bounding box
+        around all wound pixels and calculating the longer and shorter sides as length and width.
+        The surface area is computed as the number of wound pixels divided by (px_per_cm**2).
+        """
+        if mask is None or mask.size == 0 or not np.any(mask):
+            return 0.0, 0.0, 0.0
+        # Ensure binary mask
+        mask01 = (mask > 0).astype(np.uint8)
+        # Find coordinates of wound pixels
+        coords = np.argwhere(mask01)
+        y_min, x_min = coords.min(axis=0)
+        y_max, x_max = coords.max(axis=0)
+        height_px = int(y_max - y_min + 1)
+        width_px = int(x_max - x_min + 1)
+        # Compute length as the larger dimension
+        length_cm = round(max(height_px, width_px) / float(px_per_cm), 2)
+        breadth_cm = round(min(height_px, width_px) / float(px_per_cm), 2)
+        area_px = int(mask01.sum())
+        area_cm2 = round(area_px / (float(px_per_cm) ** 2), 2)
+        return length_cm, breadth_cm, area_cm2
+
     # ---------- Knowledge base + reporting ----------
     def query_guidelines(self, query: str) -> str:
         try:
@@ -1220,16 +1073,7 @@ Automated analysis provides quantitative measurements; verify via clinical exami
     def full_analysis_pipeline(self, image_pil: Image.Image, questionnaire_data: Dict) -> Dict:
         try:
             saved_path = self.save_and_commit_image(image_pil)
-            # Extract optional mask path and adjustment from questionnaire_data
-            manual_mask_path = None
-            mask_adjustment = 0
-            if isinstance(questionnaire_data, dict):
-                manual_mask_path = questionnaire_data.get("manual_mask_path") or questionnaire_data.get("manual_mask")
-                try:
-                    mask_adjustment = int(questionnaire_data.get("mask_adjustment", 0) or 0)
-                except Exception:
-                    mask_adjustment = 0
-            visual_results = self.perform_visual_analysis(image_pil, manual_mask_path, mask_adjustment)
+            visual_results = self.perform_visual_analysis(image_pil)
 
             pi = questionnaire_data or {}
             patient_info = (
@@ -1272,8 +1116,42 @@ Automated analysis provides quantitative measurements; verify via clinical exami
                 "guideline_context": "",
             }
 
-    def analyze_wound(self, image, questionnaire_data: Dict) -> Dict:
+    def analyze_wound(
+        self,
+        image,
+        questionnaire_data: Dict,
+        seg_adjust: float = 0.0,
+        manual_mask_path: Optional[str] = None,
+    ) -> Dict:
+        """
+        Analyze a wound image and return a dictionary with visual analysis, report and paths.
+
+        Parameters
+        ----------
+        image : str | PIL.Image.Image | np.ndarray
+            The input wound image. May be a filepath, PIL image or numpy array.
+        questionnaire_data : Dict
+            Auxiliary questionnaire information.
+        seg_adjust : float, optional
+            Percentage adjustment to apply to the automatically generated segmentation mask. A positive
+            value will dilate (expand) the wound mask, while a negative value will erode (shrink)
+            the mask. Defaults to 0.0 (no adjustment).
+        manual_mask_path : Optional[str], optional
+            Filepath to a user‑provided mask image. If provided and valid, this mask will
+            override the automatically generated segmentation for length, width and area
+            measurement. The mask should be a binary image where non‑zero values correspond
+            to wound pixels. Defaults to None.
+
+        Returns
+        -------
+        Dict
+            A dictionary containing keys such as ``success``, ``visual_analysis``, ``report`` and
+            ``saved_image_path``. If either ``seg_adjust`` or ``manual_mask_path`` is provided and
+            metrics can be recalculated, the returned ``visual_analysis`` will reflect the
+            adjusted measurements.
+        """
         try:
+            # Normalize input to PIL
             if isinstance(image, str):
                 if not os.path.exists(image):
                     raise ValueError(f"Image file not found: {image}")
@@ -1285,7 +1163,69 @@ Automated analysis provides quantitative measurements; verify via clinical exami
             else:
                 raise ValueError(f"Unsupported image type: {type(image)}")
 
-            return self.full_analysis_pipeline(image_pil, questionnaire_data or {})
+            # Run the standard pipeline
+            result = self.full_analysis_pipeline(image_pil, questionnaire_data or {})
+
+            # If neither manual mask nor adjustment specified, return as is
+            if (not manual_mask_path) and (abs(seg_adjust) < 1e-5):
+                return result
+
+            # Extract visual analysis and calibration from result
+            visual = result.get("visual_analysis", {})
+            px_per_cm = float(visual.get("px_per_cm", DEFAULT_PX_PER_CM))
+            # Attempt to load the ROI mask generated by the pipeline
+            roi_mask_path = visual.get("roi_mask_path")
+            mask_img = None
+
+            # Use manual mask if provided
+            if manual_mask_path:
+                try:
+                    if os.path.exists(manual_mask_path):
+                        mask_img = Image.open(manual_mask_path)
+                    else:
+                        logging.warning(f"Manual mask path does not exist: {manual_mask_path}")
+                except Exception as e:
+                    logging.warning(f"Failed to load manual mask: {e}")
+            elif roi_mask_path and os.path.exists(roi_mask_path):
+                # Otherwise load the automatically generated ROI mask
+                try:
+                    mask_img = Image.open(roi_mask_path)
+                except Exception as e:
+                    logging.warning(f"Failed to load ROI mask for adjustment: {e}")
+
+            if mask_img is not None:
+                # Convert to numpy for processing
+                mask_np = np.array(mask_img.convert("L"))
+                # If adjustment is requested and no manual mask override
+                if (manual_mask_path is None) and (abs(seg_adjust) >= 1e-5):
+                    # Determine the number of iterations based on percentage; roughly 5% increments
+                    iter_count = max(1, int(round(abs(seg_adjust) / 5)))
+                    kernel = np.ones((3, 3), np.uint8)
+                    try:
+                        if seg_adjust > 0:
+                            # Dilate (expand) mask
+                            mask_np = cv2.dilate((mask_np > 127).astype(np.uint8), kernel, iterations=iter_count)
+                        else:
+                            # Erode (shrink) mask
+                            mask_np = cv2.erode((mask_np > 127).astype(np.uint8), kernel, iterations=iter_count)
+                    except Exception as e:
+                        logging.warning(f"Segmentation adjustment failed: {e}")
+                else:
+                    # If manual mask provided, binarize it directly
+                    mask_np = (mask_np > 127).astype(np.uint8)
+
+                # Recalculate length, width and area using the adjusted or manual mask
+                try:
+                    length_cm, breadth_cm, area_cm2 = self._refine_metrics_from_mask(mask_np, px_per_cm)
+                    visual["length_cm"] = length_cm
+                    visual["breadth_cm"] = breadth_cm
+                    visual["surface_area_cm2"] = area_cm2
+                    # Indicate that segmentation was refined manually or adjusted
+                    visual["segmentation_refined"] = bool(manual_mask_path) or (abs(seg_adjust) >= 1e-5)
+                except Exception as e:
+                    logging.warning(f"Failed to recalculate metrics from mask: {e}")
+            result["visual_analysis"] = visual
+            return result
         except Exception as e:
             logging.error(f"Wound analysis error: {e}")
             return {