"""Fuse a fidelity-SR anchor with the high-frequency residual of VARSR outputs.""" import argparse from pathlib import Path import numpy as np import torch import torch.nn.functional as functional from PIL import Image DEFAULT_EXTENSIONS = ".png,.jpg,.jpeg,.JPG,.JPEG" def parse_args(): parser = argparse.ArgumentParser( description="Blend a fidelity anchor with the high-frequency component of VARSR images.", formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) parser.add_argument("--anchor_dir", required=True, help="Directory of SwinIR/HAT fidelity-anchor images.") parser.add_argument("--varsr_dir", required=True, help="Directory of raw VARSR images at the same HR size.") parser.add_argument("--output_dir", required=True, help="Directory for anchor + VARSR-frequency targets.") parser.add_argument( "--varsr_high_freq_weight", type=float, default=0.5, help="Interpolation from anchor high frequencies (0) to VARSR high frequencies (1).", ) parser.add_argument("--frequency_levels", type=int, default=5, help="Number of multi-scale frequency levels.") parser.add_argument( "--pairing", choices=("stem", "index"), default="stem", help="Pair images by matching relative stems, or explicitly by sorted index when legacy VARSR names differ.", ) parser.add_argument("--device", choices=("cpu", "cuda"), default="cpu", help="Fusion compute device.") parser.add_argument("--gpu", type=int, default=0, help="CUDA index used only with --device cuda.") parser.add_argument("--extensions", default=DEFAULT_EXTENSIONS, help="Comma-separated image extensions.") parser.add_argument("--save_ext", default=".png", help="Output extension; PNG is recommended.") parser.add_argument("--limit", type=int, default=0, help="Only process the first N images when greater than 0.") parser.add_argument("--overwrite", action="store_true", help="Overwrite existing outputs.") args = parser.parse_args() if not 0.0 <= args.varsr_high_freq_weight <= 1.0: parser.error("--varsr_high_freq_weight must be in [0, 1]") if args.frequency_levels <= 0: parser.error("--frequency_levels must be positive") if args.gpu < 0: parser.error("--gpu must be non-negative") return args def normalize_extensions(raw_extensions): extensions = set() for raw_extension in raw_extensions.split(","): extension = raw_extension.strip().lower() if extension: extensions.add(extension if extension.startswith(".") else f".{extension}") return extensions def iter_images(root, extensions): return sorted( path for path in root.rglob("*") if path.is_file() and path.suffix.lower() in extensions ) def relative_stem(path, root): return path.relative_to(root).with_suffix("").as_posix().lower() def index_images(root, extensions): image_index = {} for image_path in iter_images(root, extensions): key = relative_stem(image_path, root) if key in image_index: raise RuntimeError(f"Duplicate relative image stem in {root}: {key}") image_index[key] = image_path return image_index def resolve_device(args): if args.device == "cpu": return torch.device("cpu") if not torch.cuda.is_available(): raise RuntimeError("--device cuda was requested, but CUDA is unavailable") if args.gpu >= torch.cuda.device_count(): raise RuntimeError( f"Requested --gpu {args.gpu}, but PyTorch sees CUDA indices " f"0..{torch.cuda.device_count() - 1}" ) return torch.device(f"cuda:{args.gpu}") def pil_to_tensor(image, device): array = np.array(image.convert("RGB"), dtype=np.float32, copy=True) return torch.from_numpy(array).permute(2, 0, 1).unsqueeze(0).div_(255.0).to(device) def tensor_to_pil(tensor): array = ( tensor.detach() .squeeze(0) .permute(1, 2, 0) .clamp(0.0, 1.0) .mul(255.0) .round() .to(torch.uint8) .cpu() .numpy() ) return Image.fromarray(array, mode="RGB") def multiscale_blur(image, radius): kernel_values = torch.tensor( [[0.0625, 0.125, 0.0625], [0.125, 0.25, 0.125], [0.0625, 0.125, 0.0625]], dtype=image.dtype, device=image.device, ) kernel = kernel_values.view(1, 1, 3, 3).repeat(image.shape[1], 1, 1, 1) padded = functional.pad(image, (radius, radius, radius, radius), mode="replicate") return functional.conv2d(padded, kernel, groups=image.shape[1], dilation=radius) def split_high_low_frequency(image, levels): high_frequency = torch.zeros_like(image) low_frequency = image for level in range(levels): blurred = multiscale_blur(low_frequency, radius=2**level) high_frequency += low_frequency - blurred low_frequency = blurred return high_frequency, low_frequency def fuse_anchor_and_varsr(anchor, varsr, high_freq_weight, frequency_levels): anchor_high, _ = split_high_low_frequency(anchor, frequency_levels) varsr_high, _ = split_high_low_frequency(varsr, frequency_levels) return (anchor + high_freq_weight * (varsr_high - anchor_high)).clamp(0.0, 1.0) def output_path_for(reference_path, reference_dir, output_dir, save_ext): relative_path = reference_path.relative_to(reference_dir) suffix = save_ext if save_ext else relative_path.suffix if suffix and not suffix.startswith("."): suffix = f".{suffix}" return (output_dir / relative_path).with_suffix(suffix) def main(): args = parse_args() anchor_dir = Path(args.anchor_dir) varsr_dir = Path(args.varsr_dir) output_dir = Path(args.output_dir) extensions = normalize_extensions(args.extensions) if not anchor_dir.is_dir(): raise FileNotFoundError(f"Anchor directory does not exist: {anchor_dir}") if not varsr_dir.is_dir(): raise FileNotFoundError(f"VARSR directory does not exist: {varsr_dir}") anchor_images = index_images(anchor_dir, extensions) anchor_paths = iter_images(anchor_dir, extensions) varsr_images = iter_images(varsr_dir, extensions) if args.limit > 0: varsr_images = varsr_images[: args.limit] if not varsr_images: raise RuntimeError(f"No VARSR images found in {varsr_dir}") if args.pairing == "stem": image_pairs = [] for varsr_path in varsr_images: key = relative_stem(varsr_path, varsr_dir) anchor_path = anchor_images.get(key) if anchor_path is None: raise FileNotFoundError( f"No anchor image matching relative stem '{key}' in {anchor_dir}. " "If these are corresponding legacy outputs with different names, rerun with --pairing index." ) image_pairs.append((anchor_path, varsr_path)) else: if len(anchor_paths) != len(varsr_images): raise ValueError( f"--pairing index requires equal image counts, got {len(anchor_paths)} anchor image(s) " f"and {len(varsr_images)} VARSR image(s)." ) image_pairs = list(zip(anchor_paths, varsr_images)) device = resolve_device(args) if device.type == "cuda": torch.cuda.set_device(device) print(f"Anchor fusion device: {device} ({torch.cuda.get_device_name(device)})") else: print("Anchor fusion device: cpu") print( f"Found {len(image_pairs)} image pair(s). Writing to {output_dir}\n" f"Fusion: target = anchor + beta * (high(VARSR) - high(anchor)); " f"beta={args.varsr_high_freq_weight}, frequency_levels={args.frequency_levels}, pairing={args.pairing}" ) for index, (anchor_path, varsr_path) in enumerate(image_pairs, 1): output_path = output_path_for(anchor_path, anchor_dir, output_dir, args.save_ext) if output_path.exists() and not args.overwrite: print(f"[{index}/{len(image_pairs)}] skip existing {output_path}") continue with Image.open(anchor_path) as anchor_source, Image.open(varsr_path) as varsr_source: anchor_image = anchor_source.convert("RGB") varsr_image = varsr_source.convert("RGB") if anchor_image.size != varsr_image.size: raise ValueError( f"Size mismatch for '{key}': anchor {anchor_image.size}, VARSR {varsr_image.size}" ) with torch.inference_mode(): anchor_tensor = pil_to_tensor(anchor_image, device) varsr_tensor = pil_to_tensor(varsr_image, device) fused_tensor = fuse_anchor_and_varsr( anchor_tensor, varsr_tensor, args.varsr_high_freq_weight, args.frequency_levels, ) output_path.parent.mkdir(parents=True, exist_ok=True) save_kwargs = {"quality": 95} if output_path.suffix.lower() in {".jpg", ".jpeg"} else {} tensor_to_pil(fused_tensor).save(output_path, **save_kwargs) print(f"[{index}/{len(image_pairs)}] {varsr_path} + {anchor_path} -> {output_path}") if __name__ == "__main__": main()