Upload 2 files

eye_enlarger_v1.py

@@ -0,0 +1,441 @@
+import math
+from typing import List, Tuple
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+# Optional deps. Node works without them, but:
+# - SciPy or OpenCV is used for robust connected-components on the mask.
+# - OpenCV is required for Lanczos interpolation.
+try:
+    import cv2  # type: ignore
+except Exception:
+    cv2 = None
+
+try:
+    from scipy import ndimage  # type: ignore
+except Exception:
+    ndimage = None
+
+
+def _ensure_mask_2d_numpy(mask_t: torch.Tensor) -> np.ndarray:
+    """
+    Convert a ComfyUI MASK/IMAGE-like tensor into a single 2D numpy float32 array in [0,1].
+    Accepts shapes:
+      - [H, W]
+      - [H, W, C]
+      - [B, H, W]
+      - [B, H, W, C]
+    """
+    m = mask_t.detach().float().cpu()
+
+    if m.ndim == 2:
+        pass
+    elif m.ndim == 3:
+        # Either [H,W,C] or [B,H,W]
+        if m.shape[-1] in (1, 3, 4):
+            m = m[..., 0]
+        else:
+            m = m[0]
+    elif m.ndim == 4:
+        # [B,H,W,C]
+        if m.shape[-1] in (1, 3, 4):
+            m = m[0, ..., 0]
+        else:
+            m = m[0, 0]
+    else:
+        raise ValueError(f"Unsupported mask ndim={m.ndim}")
+
+    m_np = m.numpy().astype(np.float32)
+    if m_np.size == 0:
+        return m_np
+
+    # If someone fed an 8-bit mask as float, normalize.
+    if m_np.max() > 1.5:
+        m_np = m_np / 255.0
+    return np.clip(m_np, 0.0, 1.0).astype(np.float32)
+
+
+def _find_eye_centers_numpy(
+    mask_2d: np.ndarray,
+    max_centers: int = 2,
+    threshold: float = 0.5,
+    min_area: int = 16,
+) -> List[Tuple[float, float]]:
+    """
+    Detect up to `max_centers` white blobs in a black/white mask and return their centers (cx, cy),
+    in image pixel coordinates.
+
+    - Prefers OpenCV connectedComponentsWithStats when available
+    - Falls back to SciPy ndimage.label
+    - Final fallback: numpy-only split by largest x-gap (works well for 1-2 separated squares)
+    """
+    if mask_2d.size == 0:
+        return []
+
+    binary = mask_2d > threshold
+    if not binary.any():
+        return []
+
+    # --- OpenCV path (fast, robust) ---
+    if cv2 is not None:
+        bin_u8 = (binary.astype(np.uint8) * 255)
+        num, _labels, stats, _centroids = cv2.connectedComponentsWithStats(bin_u8, connectivity=8)
+        # label 0 is background
+        if num <= 1:
+            return []
+        areas = stats[1:, cv2.CC_STAT_AREA].astype(np.int64)
+        order = np.argsort(-areas)
+
+        centers: List[Tuple[float, float]] = []
+        for idx in order:
+            area = int(areas[idx])
+            if area < min_area:
+                continue
+            lab = idx + 1
+            x = int(stats[lab, cv2.CC_STAT_LEFT])
+            y = int(stats[lab, cv2.CC_STAT_TOP])
+            w = int(stats[lab, cv2.CC_STAT_WIDTH])
+            h = int(stats[lab, cv2.CC_STAT_HEIGHT])
+            # bounding-box center (matches "white square center" use-case)
+            cx = x + (w - 1) / 2.0
+            cy = y + (h - 1) / 2.0
+            centers.append((cx, cy))
+            if len(centers) >= max_centers:
+                break
+        return centers
+
+    # --- SciPy path ---
+    if ndimage is not None:
+        labeled, num = ndimage.label(binary)
+        if num <= 0:
+            return []
+        slices = ndimage.find_objects(labeled)
+        areas = ndimage.sum(binary.astype(np.uint8), labeled, index=np.arange(1, num + 1))
+        areas = np.asarray(areas, dtype=np.float32)
+        order = np.argsort(-areas)
+
+        centers = []
+        for idx in order:
+            if areas[idx] < min_area:
+                continue
+            sl = slices[idx]
+            if sl is None:
+                continue
+            ysl, xsl = sl
+            y0, y1 = ysl.start, ysl.stop
+            x0, x1 = xsl.start, xsl.stop
+            cx = (x0 + x1 - 1) / 2.0
+            cy = (y0 + y1 - 1) / 2.0
+            centers.append((cx, cy))
+            if len(centers) >= max_centers:
+                break
+        return centers
+
+    # --- Numpy-only fallback (assumes up to 2 separated blobs) ---
+    ys, xs = np.where(binary)
+    if xs.size < min_area:
+        return []
+
+    xs_sorted = np.sort(xs)
+    if xs_sorted.size < 2:
+        return [(float(xs_sorted[0]), float(ys[0]))]
+
+    diffs = np.diff(xs_sorted)
+    gap_idx = int(np.argmax(diffs))
+    gap = float(diffs[gap_idx])
+
+    gap_threshold = 10.0
+    centers: List[Tuple[float, float]] = []
+
+    if gap >= gap_threshold and max_centers >= 2:
+        split_x = (xs_sorted[gap_idx] + xs_sorted[gap_idx + 1]) / 2.0
+        left = binary.copy()
+        right = binary.copy()
+        left[:, int(math.ceil(split_x)) :] = False
+        right[:, : int(math.floor(split_x)) + 1] = False
+
+        for b in (left, right):
+            y2, x2 = np.where(b)
+            if x2.size < min_area:
+                continue
+            x0, x1 = int(x2.min()), int(x2.max())
+            y0, y1 = int(y2.min()), int(y2.max())
+            centers.append(((x0 + x1) / 2.0, (y0 + y1) / 2.0))
+            if len(centers) >= max_centers:
+                break
+    else:
+        x0, x1 = int(xs.min()), int(xs.max())
+        y0, y1 = int(ys.min()), int(ys.max())
+        centers.append(((x0 + x1) / 2.0, (y0 + y1) / 2.0))
+
+    return centers
+
+
+def _falloff_weight_torch(r: torch.Tensor, R: float, hardness: int) -> torch.Tensor:
+    """
+    Brush hardness like GIMP:
+      hardness=0   -> smooth falloff from center to radius
+      hardness=100 -> hard edge (full strength until radius)
+    """
+    R = float(max(R, 1e-6))
+    h = float(np.clip(hardness, 0, 100))
+    inner = R * (h / 100.0)
+
+    if inner >= R - 1e-6:
+        return (r <= R).to(r.dtype)
+
+    t = (r - inner) / (R - inner)
+    t = t.clamp(0.0, 1.0)
+    smooth = t * t * (3.0 - 2.0 * t)
+    return (1.0 - smooth) * (r <= R).to(r.dtype)
+
+
+def _bulge_warp_patch_torch_inplace(
+    img_nchw: torch.Tensor,  # [1,C,H,W]
+    cx: float,
+    cy: float,
+    radius: float,
+    hardness: int,
+    strength: int,
+    mode: str,  # "nearest" or "bilinear"
+) -> None:
+    _, _, H, W = img_nchw.shape
+    R = float(radius)
+
+    x0 = int(max(0, math.floor(cx - R)))
+    x1 = int(min(W, math.ceil(cx + R) + 1))
+    y0 = int(max(0, math.floor(cy - R)))
+    y1 = int(min(H, math.ceil(cy + R) + 1))
+    if (x1 - x0) < 2 or (y1 - y0) < 2:
+        return
+
+    patch = img_nchw[:, :, y0:y1, x0:x1]
+    ph = y1 - y0
+    pw = x1 - x0
+
+    cx_l = float(cx - x0)
+    cy_l = float(cy - y0)
+
+    device = patch.device
+    dtype = patch.dtype
+
+    ys = torch.arange(ph, device=device, dtype=torch.float32)
+    xs = torch.arange(pw, device=device, dtype=torch.float32)
+    y, x = torch.meshgrid(ys, xs, indexing="ij")
+
+    dx = x - cx_l
+    dy = y - cy_l
+    r = torch.sqrt(dx * dx + dy * dy + 1e-8)
+
+    w = _falloff_weight_torch(r, R, hardness)
+
+    amount = float(np.clip(strength, 0, 100)) / 100.0
+    s = 1.0 + amount * w  # scale factor (dest samples closer to center -> enlarges feature)
+
+    src_x = cx_l + dx / s
+    src_y = cy_l + dy / s
+
+    # Normalize to [-1,1] for grid_sample
+    x_norm = (src_x / (pw - 1)) * 2.0 - 1.0
+    y_norm = (src_y / (ph - 1)) * 2.0 - 1.0
+    grid = torch.stack((x_norm, y_norm), dim=-1).unsqueeze(0)  # [1,ph,pw,2]
+
+    warped = F.grid_sample(
+        patch,
+        grid.to(dtype),
+        mode=mode,
+        padding_mode="border",
+        align_corners=True,
+    )
+
+    img_nchw[:, :, y0:y1, x0:x1] = warped
+
+
+def _falloff_weight_numpy(r: np.ndarray, R: float, hardness: int) -> np.ndarray:
+    R = float(max(R, 1e-6))
+    h = float(np.clip(hardness, 0, 100))
+    inner = R * (h / 100.0)
+
+    if inner >= R - 1e-6:
+        return (r <= R).astype(np.float32)
+
+    t = (r - inner) / (R - inner)
+    t = np.clip(t, 0.0, 1.0)
+    smooth = t * t * (3.0 - 2.0 * t)
+    return (1.0 - smooth).astype(np.float32) * (r <= R).astype(np.float32)
+
+
+def _bulge_warp_patch_cv2_inplace(
+    img_hwc: np.ndarray,  # float32, [H,W,C], in [0,1]
+    cx: float,
+    cy: float,
+    radius: float,
+    hardness: int,
+    strength: int,
+    interp: str,  # "none"|"bilinear"|"lanczos"
+) -> None:
+    if cv2 is None:
+        raise RuntimeError("OpenCV (cv2) is required for Lanczos interpolation but is not installed.")
+
+    H, W, _ = img_hwc.shape
+    R = float(radius)
+
+    x0 = int(max(0, math.floor(cx - R)))
+    x1 = int(min(W, math.ceil(cx + R) + 1))
+    y0 = int(max(0, math.floor(cy - R)))
+    y1 = int(min(H, math.ceil(cy + R) + 1))
+    if (x1 - x0) < 2 or (y1 - y0) < 2:
+        return
+
+    patch = img_hwc[y0:y1, x0:x1]
+    ph, pw = patch.shape[:2]
+    cx_l = float(cx - x0)
+    cy_l = float(cy - y0)
+
+    xs, ys = np.meshgrid(np.arange(pw, dtype=np.float32), np.arange(ph, dtype=np.float32))
+    dx = xs - cx_l
+    dy = ys - cy_l
+    r = np.sqrt(dx * dx + dy * dy + 1e-8).astype(np.float32)
+
+    w = _falloff_weight_numpy(r, R, hardness)
+    amount = float(np.clip(strength, 0, 100)) / 100.0
+    s = 1.0 + amount * w
+
+    map_x = (cx_l + dx / s).astype(np.float32)
+    map_y = (cy_l + dy / s).astype(np.float32)
+
+    map_x = np.clip(map_x, 0.0, pw - 1.0)
+    map_y = np.clip(map_y, 0.0, ph - 1.0)
+
+    if interp == "none":
+        cv_interp = cv2.INTER_NEAREST
+    elif interp == "bilinear":
+        cv_interp = cv2.INTER_LINEAR
+    elif interp == "lanczos":
+        cv_interp = cv2.INTER_LANCZOS4
+    else:
+        cv_interp = cv2.INTER_LINEAR
+
+    warped = cv2.remap(
+        patch,
+        map_x,
+        map_y,
+        interpolation=cv_interp,
+        borderMode=cv2.BORDER_REFLECT_101,
+    )
+
+    img_hwc[y0:y1, x0:x1] = warped
+
+
+class EyeWarpEnlargeFromMask_v1:
+    """
+    ComfyUI node:
+      - Input: IMAGE + MASK
+      - Finds 1-2 white squares/blobs in mask
+      - Uses their centers as "eye positions"
+      - Applies a local "Grow/Bulge" warp around each center
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "mask": ("MASK",),
+                "size": ("INT", {"default": 60, "min": 1, "max": 2048, "step": 1}),
+                "hardness": ("INT", {"default": 50, "min": 0, "max": 100, "step": 1}),
+                "strength": ("INT", {"default": 50, "min": 0, "max": 100, "step": 1}),
+                "repeat": ("INT", {"default": 1, "min": 1, "max": 100, "step": 1}),
+                "interpolation": (["none", "bilinear", "lanczos"], {"default": "bilinear"}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "apply"
+    CATEGORY = "image/warp"
+
+    def apply(self, image, mask, size, hardness, strength, repeat, interpolation):
+        if not isinstance(image, torch.Tensor):
+            raise TypeError("image must be a torch.Tensor (ComfyUI IMAGE).")
+        if not isinstance(mask, torch.Tensor):
+            raise TypeError("mask must be a torch.Tensor (ComfyUI MASK).")
+
+        img = image
+        B, H, W, C = img.shape
+
+        # Align mask batch + resolution
+        m = mask
+        if m.ndim == 2:
+            m = m.unsqueeze(0)
+        if m.shape[0] != B:
+            if m.shape[0] == 1:
+                m = m.repeat(B, 1, 1)
+            else:
+                m = m[:B]
+
+        if m.shape[1] != H or m.shape[2] != W:
+            m = F.interpolate(m.unsqueeze(1), size=(H, W), mode="nearest").squeeze(1)
+
+        # Treat "size" like GIMP brush size (diameter): radius = size/2
+        radius = max(1.0, float(size) * 0.5)
+
+        outs = []
+        for i in range(B):
+            img_i = img[i : i + 1]  # [1,H,W,C]
+            mask_i_np = _ensure_mask_2d_numpy(m[i])  # [H,W] np
+
+            centers = _find_eye_centers_numpy(mask_i_np, max_centers=2, threshold=0.5, min_area=16)
+
+            if len(centers) == 0 or strength <= 0 or repeat <= 0:
+                outs.append(img_i)
+                continue
+
+            # Lanczos via OpenCV (CPU). Otherwise torch path.
+            if interpolation == "lanczos" and cv2 is not None:
+                img_np = img_i[0].detach().float().cpu().numpy()
+                if img_np.max() > 1.5:
+                    img_np = img_np / 255.0
+                img_np = np.clip(img_np, 0.0, 1.0).astype(np.float32)
+
+                for _ in range(int(repeat)):
+                    for cx, cy in centers:
+                        _bulge_warp_patch_cv2_inplace(
+                            img_np, cx, cy, radius, hardness, strength, interp="lanczos"
+                        )
+
+                out_i = torch.from_numpy(img_np).unsqueeze(0)
+                if img_i.device.type != "cpu":
+                    out_i = out_i.to(img_i.device)
+                outs.append(out_i)
+            else:
+                mode = "nearest" if interpolation == "none" else "bilinear"
+                img_nchw = img_i.permute(0, 3, 1, 2).contiguous().clone()
+
+                for _ in range(int(repeat)):
+                    for cx, cy in centers:
+                        _bulge_warp_patch_torch_inplace(
+                            img_nchw,
+                            cx=cx,
+                            cy=cy,
+                            radius=radius,
+                            hardness=hardness,
+                            strength=strength,
+                            mode=mode,
+                        )
+
+                out_i = img_nchw.permute(0, 2, 3, 1).contiguous()
+                outs.append(out_i)
+
+        out = torch.cat(outs, dim=0).clamp(0.0, 1.0)
+        return (out,)
+
+
+NODE_CLASS_MAPPINGS = {
+    "EyeWarpEnlargeFromMask_v1": EyeWarpEnlargeFromMask_v1,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "EyeWarpEnlargeFromMask_v1": "Eye Warp Enlarge (Mask Centers)",
+}

eye_enlarger_v2.py

@@ -0,0 +1,269 @@
+import numpy as np
+import torch
+
+try:
+    import cv2
+except Exception:
+    cv2 = None
+
+
+def _require_cv2():
+    if cv2 is None:
+        raise ImportError(
+            "Eye Warp Enlarge node requires OpenCV (cv2). "
+            "Install opencv-python in your ComfyUI environment."
+        )
+
+
+def _as_mask_2d(mask_tensor: torch.Tensor) -> np.ndarray:
+    """
+    ComfyUI MASK is typically (H, W) or (H, W, 1) as float [0..1].
+    This returns float32 (H, W).
+    """
+    m = mask_tensor.detach().float().cpu().numpy()
+    if m.ndim == 3:
+        # e.g. (H, W, 1) or (H, W, C) -> take first channel
+        m = m[:, :, 0]
+    if m.ndim != 2:
+        raise ValueError(f"Unsupported mask shape: {m.shape}")
+    return m.astype(np.float32, copy=False)
+
+
+def _resize_mask_to(mask_2d: np.ndarray, w: int, h: int) -> np.ndarray:
+    _require_cv2()
+    if mask_2d.shape == (h, w):
+        return mask_2d
+    return cv2.resize(mask_2d, (w, h), interpolation=cv2.INTER_NEAREST).astype(np.float32, copy=False)
+
+
+def _find_eye_centers_from_mask(mask_2d: np.ndarray, max_centers: int = 2):
+    """
+    Finds up to 2 connected white components in a binary-ish mask.
+    Returns centers as [(cx, cy), ...] in pixel coordinates (float).
+    """
+    _require_cv2()
+
+    h, w = mask_2d.shape
+    # Threshold to binary (mask is black/white but may be float)
+    binary = (mask_2d > 0.5).astype(np.uint8)
+    if binary.max() == 0:
+        return []
+
+    # Connected components
+    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(binary, connectivity=8)
+
+    # Filter components
+    img_area = float(h * w)
+    min_area = max(16, int(0.00001 * img_area))  # keep small squares, ignore tiny specks
+
+    comps = []
+    for label in range(1, num_labels):
+        area = int(stats[label, cv2.CC_STAT_AREA])
+        if area < min_area:
+            continue
+        # Ignore "everything is white" situations
+        if area > 0.95 * img_area:
+            continue
+        cx, cy = centroids[label]
+        comps.append((area, float(cx), float(cy)))
+
+    if not comps:
+        # Fallback: centroid of all white pixels
+        ys, xs = np.nonzero(binary)
+        if len(xs) == 0:
+            return []
+        return [(float(xs.mean()), float(ys.mean()))]
+
+    # Take largest components (squares)
+    comps.sort(key=lambda t: t[0], reverse=True)
+    comps = comps[:max_centers]
+    centers = [(cx, cy) for _, cx, cy in comps]
+    centers.sort(key=lambda p: p[0])  # left-to-right
+    return centers
+
+
+def _build_magnify_maps(h: int, w: int, cx: float, cy: float, size: int, hardness: int, strength: int):
+    """
+    Builds (map_x, map_y) for cv2.remap that performs a "magnify/bulge" enlarge centered at (cx, cy).
+
+    size: brush DIAMETER in pixels (like typical brush size).
+    hardness: 0..100, controls how much of the radius is full-strength before falling off.
+    strength: 0..100, magnification intensity.
+    """
+    _require_cv2()
+
+    diameter = float(max(1, size))
+    radius = max(1.0, diameter * 0.5)
+
+    hardness = float(np.clip(hardness, 0, 100))
+    strength = float(np.clip(strength, 0, 100))
+    s = strength / 100.0  # 0..1
+
+    # Brush hardness model:
+    # inner = full-strength radius portion, outer ring falls off.
+    inner = radius * (hardness / 100.0)
+
+    # Coordinate grid
+    yy, xx = np.mgrid[0:h, 0:w].astype(np.float32)
+    dx = xx - np.float32(cx)
+    dy = yy - np.float32(cy)
+    dist = np.sqrt(dx * dx + dy * dy)
+
+    falloff = np.zeros((h, w), dtype=np.float32)
+
+    if inner >= radius - 1e-6:
+        # Very hard brush: almost step edge
+        falloff[dist <= radius] = 1.0
+    else:
+        # Full strength inside inner radius
+        inside = dist <= inner
+        falloff[inside] = 1.0
+
+        # Smooth falloff in the ring (inner..radius)
+        ring = (dist > inner) & (dist < radius)
+        if np.any(ring):
+            u = (dist[ring] - inner) / max(radius - inner, 1e-6)  # 0..1
+            # Quadratic falloff (smooth-ish)
+            falloff[ring] = (1.0 - u) ** 2
+
+    active = dist < radius
+    if not np.any(active) or s <= 0.0:
+        # Identity maps
+        return xx, yy
+
+    # Local scale: 1..(1+s) depending on falloff
+    local_scale = 1.0 + (s * falloff)
+
+    map_x = xx.copy()
+    map_y = yy.copy()
+
+    # Inverse mapping for magnify:
+    # dest(p) samples from src closer to center: c + (p-c)/scale
+    map_x[active] = np.float32(cx) + dx[active] / local_scale[active]
+    map_y[active] = np.float32(cy) + dy[active] / local_scale[active]
+
+    return map_x.astype(np.float32, copy=False), map_y.astype(np.float32, copy=False)
+
+
+def _interp_flag(mode: str) -> int:
+    _require_cv2()
+    mode = (mode or "").lower().strip()
+    if mode == "none":
+        return cv2.INTER_NEAREST
+    if mode == "bilinear":
+        return cv2.INTER_LINEAR
+    if mode == "lanczos":
+        return cv2.INTER_LANCZOS4
+    return cv2.INTER_LINEAR
+
+
+class EyeWarpEnlargeFromMask_v2:
+    """
+    ComfyUI Node:
+    - image: IMAGE (B,H,W,C) float 0..1
+    - mask:  MASK  (B,H,W) float 0..1, containing 1 or 2 white squares
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "mask": ("MASK",),
+
+                # Brush settings
+                "size": ("INT", {"default": 60, "min": 1, "max": 2048, "step": 1}),
+                "hardness": ("INT", {"default": 50, "min": 0, "max": 100, "step": 1}),
+                "strength": ("INT", {"default": 50, "min": 0, "max": 100, "step": 1}),
+
+                # No mouse distance => user controls repeats/passes
+                "repeat": ("INT", {"default": 1, "min": 1, "max": 100, "step": 1}),
+
+                # Interpolation
+                "interpolation": (["bilinear", "lanczos", "none"],),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "apply"
+    CATEGORY = "image/warp"
+
+    def apply(self, image, mask, size=60, hardness=50, strength=50, repeat=1, interpolation="bilinear"):
+        _require_cv2()
+
+        if not isinstance(image, torch.Tensor):
+            raise TypeError("image must be a torch Tensor (ComfyUI IMAGE).")
+        if not isinstance(mask, torch.Tensor):
+            raise TypeError("mask must be a torch Tensor (ComfyUI MASK).")
+
+        device = image.device
+        dtype = image.dtype
+
+        # Ensure image is (B,H,W,C)
+        if image.ndim != 4:
+            raise ValueError(f"Expected image shape (B,H,W,C), got: {tuple(image.shape)}")
+        b, h, w, c = image.shape
+        if c not in (3, 4):
+            # still allow, but warn-ish via behavior
+            pass
+
+        # Ensure mask batch aligns (best effort)
+        if mask.ndim == 2:
+            mask = mask.unsqueeze(0)
+        if mask.ndim == 3 and mask.shape[0] != b:
+            # If single mask provided for a batch, broadcast it
+            if mask.shape[0] == 1 and b > 1:
+                mask = mask.repeat(b, 1, 1)
+        if mask.shape[0] != b:
+            raise ValueError(f"Mask batch ({mask.shape[0]}) does not match image batch ({b}).")
+
+        interp = _interp_flag(interpolation)
+
+        # Process on CPU with OpenCV, then return to original device
+        img_np = image.detach().float().cpu().numpy()
+        out_np = np.empty_like(img_np, dtype=np.float32)
+
+        for i in range(b):
+            frame = np.ascontiguousarray(img_np[i], dtype=np.float32)  # (H,W,C)
+
+            mask_2d = _as_mask_2d(mask[i])
+            mask_2d = _resize_mask_to(mask_2d, w=w, h=h)
+
+            centers = _find_eye_centers_from_mask(mask_2d, max_centers=2)
+
+            if not centers or strength <= 0 or size <= 0 or repeat <= 0:
+                out_np[i] = frame
+                continue
+
+            # Precompute remap maps per center
+            maps = []
+            for (cx, cy) in centers:
+                mx, my = _build_magnify_maps(h=h, w=w, cx=cx, cy=cy, size=size, hardness=hardness, strength=strength)
+                maps.append((mx, my))
+
+            # Apply multiple passes (repeat)
+            for _ in range(int(repeat)):
+                for (mx, my) in maps:
+                    frame = cv2.remap(
+                        frame,
+                        mx,
+                        my,
+                        interpolation=interp,
+                        borderMode=cv2.BORDER_REFLECT_101,
+                    )
+
+            # Clamp back to [0..1] to stay in ComfyUI's IMAGE range
+            frame = np.clip(frame, 0.0, 1.0)
+            out_np[i] = frame
+
+        out = torch.from_numpy(out_np).to(device=device, dtype=dtype)
+        return (out,)
+
+
+NODE_CLASS_MAPPINGS = {
+    "EyeWarpEnlargeFromMask_v2": EyeWarpEnlargeFromMask_v2
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "EyeWarpEnlargeFromMask_v2": "Eye Warp Enlarge (Mask Centers) v2"
+}