It works for blur values <= 37. Values of 39 and higher reproduce the issue (the fill function adds 1 to radius if even, so 38 is not possible).

This is using the internal native windows server (Python 3.10.11, torch==2.2.0+cu121) on Windows 10, with a Zen 4 Ryzen CPU.

Here's a self-contained reproducer:

from __future__ import annotations
import torch
import torch.nn.functional as F
from torch import Tensor

def to_comfy(image: Tensor):
    return image.permute(0, 2, 3, 1)  # BCHW -> BHWC

def make_odd(x):
    if x > 0 and x % 2 == 0:
        return x + 1
    return x

def binary_erosion(mask: Tensor, radius: int):
    kernel = torch.ones(1, 1, radius * 2 + 1, radius * 2 + 1, device=mask.device)
    mask = F.pad(mask, (radius, radius, radius, radius), mode="constant", value=1)
    mask = F.conv2d(mask, kernel, groups=1)
    mask = (mask == kernel.numel()).to(mask.dtype)
    return mask

def to_torch(image: Tensor, mask: Tensor | None = None):
    if len(image.shape) == 3:
        image = image.unsqueeze(0)
    image = image.permute(0, 3, 1, 2)  # BHWC -> BCHW
    if mask is not None:
        if len(mask.shape) < 4:
            mask = mask.reshape(1, 1, mask.shape[-2], mask.shape[-1])
    if image.shape[2:] != mask.shape[2:]:
        raise ValueError(
            f"Image and mask must be the same size. {image.shape[2:]} != {mask.shape[2:]}"
        )
    return image, mask

def _gaussian_kernel(radius: int, sigma: float):
    x = torch.linspace(-radius, radius, steps=radius * 2 + 1)
    pdf = torch.exp(-0.5 * (x / sigma).pow(2))
    return pdf / pdf.sum()


def gaussian_blur(image: Tensor, radius: int, sigma: float = 0):
    c = image.shape[-3]
    if sigma <= 0:
        sigma = 0.3 * (radius - 1) + 0.8

    kernel = _gaussian_kernel(radius, sigma).to(image.device)
    kernel_x = kernel[..., None, :].repeat(c, 1, 1).unsqueeze(1)
    kernel_y = kernel[..., None].repeat(c, 1, 1).unsqueeze(1)

    image = F.pad(image, (radius, radius, radius, radius), mode="reflect")
    image = F.conv2d(image, kernel_x, groups=c)
    image = F.conv2d(image, kernel_y, groups=c)
    return image


def fill(image: Tensor, mask: Tensor, blur: int, falloff: int):
    blur = make_odd(blur)
    falloff = min(make_odd(falloff), blur - 2)
    image, mask = to_torch(image, mask)

    original = image.clone()
    alpha = mask.floor()
    if falloff > 0:
        erosion = binary_erosion(alpha, falloff)
        alpha = alpha * gaussian_blur(erosion, falloff)
    alpha = alpha.repeat(1, 3, 1, 1)

    image = gaussian_blur(image, blur)
    image = original + (image - original) * alpha
    return (to_comfy(image),)

mask = torch.rand([1, 1024, 1024], dtype=torch.float32, device=torch.device('cpu'))
image = torch.rand([1, 1024, 1024, 3], dtype=torch.float32, device=torch.device('cpu'))

# blur <= 37 works
ret = fill(image, mask, blur=39, falloff=9)

Uh oh!

Inpaint doesnt work #401

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions