From 268063e31749d852209ad56f6c1bee4083d5a59d Mon Sep 17 00:00:00 2001 From: Christopher Anderson Date: Sun, 10 Aug 2025 22:47:27 +1000 Subject: [PATCH] Add pillarbox_blur mode for proportional image resizing with blurred background. --- nodes/image_nodes.py | 139 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 136 insertions(+), 3 deletions(-) diff --git a/nodes/image_nodes.py b/nodes/image_nodes.py index 937ffce..e049c93 100644 --- a/nodes/image_nodes.py +++ b/nodes/image_nodes.py @@ -2436,7 +2436,7 @@ class ImageResizeKJv2: "width": ("INT", { "default": 512, "min": 0, "max": MAX_RESOLUTION, "step": 1, }), "height": ("INT", { "default": 512, "min": 0, "max": MAX_RESOLUTION, "step": 1, }), "upscale_method": (s.upscale_methods,), - "keep_proportion": (["stretch", "resize", "pad", "pad_edge", "crop"], { "default": False }), + "keep_proportion": (["stretch", "resize", "pad", "pad_edge", "crop", "pillarbox_blur"], { "default": False }), "pad_color": ("STRING", { "default": "0, 0, 0", "tooltip": "Color to use for padding."}), "crop_position": (["center", "top", "bottom", "left", "right"], { "default": "center" }), "divisible_by": ("INT", { "default": 2, "min": 0, "max": 512, "step": 1, }), @@ -2476,7 +2476,140 @@ highest dimension. width = W if height == 0: height = H - + + # Pillarbox blur path: build blurred background that fills the target canvas, + # overlay resized foreground centered on top. + if keep_proportion == "pillarbox_blur": + # Adjust to divisibility first, since we are producing the final canvas here + if divisible_by > 1: + width = width - (width % divisible_by) + height = height - (height % divisible_by) + + image = image.to(device) + if mask is not None: + mask = mask.to(device) + + # Compute foreground fit size (keep aspect, fit inside target) + ratio_fit = min(width / W, height / H) if (W > 0 and H > 0) else 1.0 + fg_w = max(1, int(round(W * ratio_fit))) + fg_h = max(1, int(round(H * ratio_fit))) + + # Foreground placement (center) + pad_left = (width - fg_w) // 2 + pad_right = width - fg_w - pad_left + pad_top = (height - fg_h) // 2 + pad_bottom = height - fg_h - pad_top + + # Prepare output tensors + out_image = torch.zeros((B, height, width, C), dtype=image.dtype, device=device) + out_mask = None + + # Helper: separable gaussian blur for NCHW + def _gaussian_blur_nchw(img_nchw, sigma_px): + if sigma_px <= 0: + return img_nchw + radius = max(1, int(3.0 * float(sigma_px))) + k = 2 * radius + 1 + x = torch.arange(-radius, radius + 1, device=img_nchw.device, dtype=img_nchw.dtype) + k1 = torch.exp(-(x * x) / (2.0 * float(sigma_px) * float(sigma_px))) + k1 = k1 / k1.sum() + kx = k1.view(1, 1, 1, k) + ky = k1.view(1, 1, k, 1) + c = img_nchw.shape[1] + kx = kx.repeat(c, 1, 1, 1) + ky = ky.repeat(c, 1, 1, 1) + img_nchw = F.conv2d(img_nchw, kx, padding=(0, radius), groups=c) + img_nchw = F.conv2d(img_nchw, ky, padding=(radius, 0), groups=c) + return img_nchw + + # Build per-batch frames + for b in range(B): + # Background: scale-to-fill (keep aspect), then center-crop to (height, width) + scale_fill = max(width / float(W), height / float(H)) if (W > 0 and H > 0) else 1.0 + bg_w = max(1, int(round(W * scale_fill))) + bg_h = max(1, int(round(H * scale_fill))) + + src_b = image[b].movedim(-1, 0).unsqueeze(0) # 1,C,H,W + bg = common_upscale(src_b, bg_w, bg_h, upscale_method, crop="disabled") + + # Center crop to canvas + y0 = max(0, (bg_h - height) // 2) + x0 = max(0, (bg_w - width) // 2) + y1 = min(bg_h, y0 + height) + x1 = min(bg_w, x0 + width) + bg = bg[:, :, y0:y1, x0:x1] + + # If rounding made it a hair off, pad to exact size + if bg.shape[2] != height or bg.shape[3] != width: + pad_h = height - bg.shape[2] + pad_w = width - bg.shape[3] + pad_top_fix = max(0, pad_h // 2) + pad_bottom_fix = max(0, pad_h - pad_top_fix) + pad_left_fix = max(0, pad_w // 2) + pad_right_fix = max(0, pad_w - pad_left_fix) + bg = F.pad(bg, (pad_left_fix, pad_right_fix, pad_top_fix, pad_bottom_fix), mode="replicate") + + # Blur strength scales with output size + sigma = max(1.0, 0.006 * float(min(height, width))) + bg = _gaussian_blur_nchw(bg, sigma_px=sigma) + + # 20% saturation reduction (Rec.709 luma) + if C >= 3: + r, g, bch = bg[:, 0:1], bg[:, 1:2], bg[:, 2:3] + luma = 0.2126 * r + 0.7152 * g + 0.0722 * bch + gray = torch.cat([luma, luma, luma], dim=1) + desat = 0.20 + rgb = torch.cat([r, g, bch], dim=1) + rgb = rgb * (1.0 - desat) + gray * desat + bg[:, 0:3, :, :] = rgb + + # Dim to keep attention on foreground + dim = 0.35 + bg = torch.clamp(bg * dim, 0.0, 1.0) + + # Write background to canvas + out_image[b] = bg.squeeze(0).movedim(0, -1) + + # Resize foreground to fit size and composite at center + fg = common_upscale(image.movedim(-1, 1), fg_w, fg_h, upscale_method, crop="disabled").movedim(1, -1) + out_image[:, pad_top:pad_top+fg_h, pad_left:pad_left+fg_w, :] = fg + + # Mask handling + if mask is not None: + # Transform mask like the foreground + if upscale_method == "lanczos": + # Use the same path as elsewhere in this node for lanczos + fg_mask = common_upscale(mask.unsqueeze(1).repeat(1, 3, 1, 1), fg_w, fg_h, upscale_method, crop="disabled").movedim(1, -1)[:, :, :, 0] + else: + fg_mask = common_upscale(mask.unsqueeze(1), fg_w, fg_h, upscale_method, crop="disabled").squeeze(1) + + out_mask = torch.ones((B, height, width), dtype=image.dtype, device=device) + out_mask[:, pad_top:pad_top+fg_h, pad_left:pad_left+fg_w] = fg_mask + else: + out_mask = torch.ones((B, height, width), dtype=image.dtype, device=device) + out_mask[:, pad_top:pad_top+fg_h, pad_left:pad_left+fg_w] = 0.0 + + # Progress UI (kept consistent with existing code) + if unique_id and PromptServer is not None: + try: + num_elements = out_image.numel() + element_size = out_image.element_size() + memory_size_mb = (num_elements * element_size) / (1024 * 1024) + PromptServer.instance.send_progress_text( + f"Output: {out_image.shape[0]} x {out_image.shape[2]} x {out_image.shape[1]} | {memory_size_mb:.2f}MB", + unique_id + ) + except: + pass + + return ( + out_image.cpu(), + out_image.shape[2], + out_image.shape[1], + out_mask.cpu() if out_mask is not None else torch.zeros(64, 64, device=torch.device("cpu"), dtype=torch.float32), + ) + + # Existing logic for other modes if keep_proportion == "resize" or keep_proportion.startswith("pad"): # If one of the dimensions is zero, calculate it to maintain the aspect ratio if width == 0 and height != 0: @@ -2615,7 +2748,7 @@ highest dimension. pass return(out_image.cpu(), out_image.shape[2], out_image.shape[1], out_mask.cpu() if out_mask is not None else torch.zeros(64,64, device=torch.device("cpu"), dtype=torch.float32)) - + import pathlib class LoadAndResizeImage: _color_channels = ["alpha", "red", "green", "blue"]