Download code/factor_interventions.py from ij/anima-style-factor-intervention-v4: direct link, hf CLI and curl.
- Browser
- Download file 13.2 kB
-
https://huggingface.co/datasets/ij/anima-style-factor-intervention-v4/resolve/main/code/factor_interventions.py
- Command line
-
hf download hf://datasets/ij/anima-style-factor-intervention-v4/code/factor_interventions.py
-
curl -L -o factor_interventions.py https://huggingface.co/datasets/ij/anima-style-factor-intervention-v4/resolve/main/code/factor_interventions.py
13.2 kB
| from __future__ import annotations | |
| import math | |
| import cv2 | |
| import numpy as np | |
| from PIL import Image | |
| from .image_preprocess import canonical_square, decode_rgb | |
| FACTORS = ("line", "color", "texture", "geometry") | |
| INTERVENTION_VERSION = "lens-safe-v4" | |
| TRAIN_FAMILIES = { | |
| "line": ("dilate_erode", "blur_sharpen", "darkness_contrast"), | |
| "color": ("palette_remap", "split_tone", "tone_curve"), | |
| "texture": ("smooth_detail", "frequency", "grain_noise"), | |
| "geometry": ("crop_zoom_translate", "perspective", "lens_warp"), | |
| } | |
| VALIDATION_FAMILIES = { | |
| "line": "edge_overlay", | |
| "color": "channel_mixer", | |
| "texture": "median_speckle", | |
| "geometry": "shear", | |
| } | |
| LEVELS = {"weak": 0.50, "medium": 0.80, "strong": 1.0} | |
| def _uint8(array: np.ndarray) -> np.ndarray: | |
| return np.clip(array, 0, 255).astype(np.uint8) | |
| def _edges(array: np.ndarray) -> np.ndarray: | |
| gray = cv2.cvtColor(array, cv2.COLOR_RGB2GRAY) | |
| return cv2.Canny(gray, 60, 150).astype(np.float32) / 255.0 | |
| def _pixel_transform( | |
| image: Image.Image, factor: str, family: str, signed: float, seed: int | |
| ) -> Image.Image: | |
| magnitude = abs(signed) | |
| direction = 1 if signed >= 0 else -1 | |
| array = np.asarray(image.convert("RGB"), dtype=np.uint8) | |
| if factor == "line": | |
| if family in {"dilate_erode", "edge_overlay"}: | |
| edge = _edges(array) | |
| kernel_size = 3 if magnitude <= 0.5 else 5 if magnitude < 1.0 else 7 | |
| kernel = np.ones((kernel_size, kernel_size), np.uint8) | |
| edge = cv2.dilate(edge, kernel) | |
| if direction > 0: | |
| alpha = (0.72 if family == "edge_overlay" else 0.64) * magnitude | |
| result = array.astype(np.float32) * (1.0 - alpha * edge[..., None]) | |
| else: | |
| smooth = cv2.bilateralFilter(array, 11, 80, 9).astype(np.float32) | |
| weight = np.clip(0.90 * magnitude * edge, 0.0, 0.90)[..., None] | |
| result = array * (1.0 - weight) + smooth * weight | |
| elif family == "blur_sharpen": | |
| blurred = cv2.GaussianBlur(array, (0, 0), 1.2 + 2.4 * magnitude) | |
| result = blurred if direction < 0 else cv2.addWeighted( | |
| array, 1.0 + 1.45 * magnitude, blurred, -1.45 * magnitude, 0 | |
| ) | |
| elif family == "darkness_contrast": | |
| edge = cv2.GaussianBlur(_edges(array), (0, 0), 1.0) | |
| if direction > 0: | |
| result = array.astype(np.float32) * (1.0 - 0.70 * magnitude * edge[..., None]) | |
| else: | |
| smooth = cv2.GaussianBlur(array, (0, 0), 2.6) | |
| weight = np.clip(0.90 * magnitude * edge, 0.0, 0.90)[..., None] | |
| result = array * (1.0 - weight) + smooth * weight | |
| else: | |
| raise ValueError(f"unknown line family: {family}") | |
| return Image.fromarray(_uint8(result)) | |
| if factor == "color": | |
| unit = array.astype(np.float32) / 255.0 | |
| if family == "palette_remap": | |
| hsv = cv2.cvtColor(array, cv2.COLOR_RGB2HSV).astype(np.float32) | |
| hsv[..., 0] = np.mod(hsv[..., 0] + direction * 30.0 * magnitude, 180.0) | |
| saturation = 1.0 + 0.95 * magnitude if direction > 0 else 1.0 - 0.70 * magnitude | |
| hsv[..., 1] *= saturation | |
| hsv[..., 2] = 255.0 * np.power( | |
| hsv[..., 2] / 255.0, math.exp(-direction * 0.38 * magnitude) | |
| ) | |
| result = cv2.cvtColor(_uint8(hsv), cv2.COLOR_HSV2RGB).astype(np.float32) | |
| balance = direction * 0.16 * magnitude | |
| result[..., 0] *= 1.0 + balance | |
| result[..., 2] *= 1.0 - balance | |
| elif family == "split_tone": | |
| luminance = np.sum(unit * np.array([0.213, 0.715, 0.072], np.float32), axis=2) | |
| shadows = np.power(1.0 - luminance, 1.4)[..., None] | |
| highlights = np.power(luminance, 1.4)[..., None] | |
| cool_shadow = np.array([-0.16, 0.02, 0.28], np.float32) | |
| warm_highlight = np.array([0.30, 0.12, -0.14], np.float32) | |
| result = unit + direction * magnitude * ( | |
| shadows * cool_shadow + highlights * warm_highlight | |
| ) | |
| result = 0.5 + (result - 0.5) * (1.0 + 0.38 * magnitude) | |
| result = _uint8(result * 255.0) | |
| hsv = cv2.cvtColor(result, cv2.COLOR_RGB2HSV).astype(np.float32) | |
| hsv[..., 0] = np.mod(hsv[..., 0] + direction * 12.0 * magnitude, 180.0) | |
| hsv[..., 1] *= 1.0 + 0.40 * magnitude | |
| result = cv2.cvtColor(_uint8(hsv), cv2.COLOR_HSV2RGB) | |
| elif family == "tone_curve": | |
| channel_gamma = np.exp( | |
| direction * magnitude * np.array([-0.62, -0.18, 0.48], np.float32) | |
| ) | |
| result = np.power(np.clip(unit, 0.0, 1.0), channel_gamma) | |
| contrast = 1.0 + direction * 0.48 * magnitude | |
| result = 0.5 + (result - 0.5) * contrast | |
| luminance = np.sum(result * np.array([0.213, 0.715, 0.072], np.float32), axis=2, keepdims=True) | |
| result = luminance + (result - luminance) * (1.0 + 0.55 * magnitude) | |
| result *= 1.0 + direction * 0.10 * magnitude | |
| result = result * 255.0 | |
| elif family == "channel_mixer": | |
| delta = np.array( | |
| [[0.22, 0.12, -0.20], [-0.12, 0.20, 0.08], [0.08, -0.20, 0.24]], | |
| np.float32, | |
| ) | |
| matrix = np.eye(3, dtype=np.float32) + direction * magnitude * delta | |
| result = unit @ matrix.T | |
| result = np.power( | |
| np.clip(result, 0.0, 1.0), math.exp(-direction * 0.45 * magnitude) | |
| ) | |
| result = 255.0 * result | |
| else: | |
| raise ValueError(f"unknown color family: {family}") | |
| return Image.fromarray(_uint8(result)) | |
| if factor == "texture": | |
| result = array.astype(np.float32) | |
| if family == "smooth_detail": | |
| smooth = cv2.bilateralFilter(array, 13, 70 + 55 * magnitude, 11) | |
| if direction < 0: | |
| result = cv2.addWeighted(array, 1.0 - 0.85 * magnitude, smooth, 0.85 * magnitude, 0) | |
| else: | |
| result = array + (array.astype(np.float32) - smooth) * 1.35 * magnitude | |
| elif family == "frequency": | |
| low = cv2.GaussianBlur(array, (0, 0), 1.5 + 1.5 * magnitude) | |
| high = array.astype(np.float32) - low.astype(np.float32) | |
| result = array + direction * high * 1.55 * magnitude | |
| elif family in {"grain_noise", "median_speckle"}: | |
| if direction < 0: | |
| kernel = 5 if magnitude >= 0.8 else 3 | |
| median = cv2.medianBlur(array, kernel) | |
| result = cv2.addWeighted(array, 1.0 - 0.85 * magnitude, median, 0.85 * magnitude, 0) | |
| else: | |
| rng = np.random.default_rng(seed) | |
| noise = rng.normal(0, 26.0 * magnitude, array.shape[:2]).astype(np.float32) | |
| noise = cv2.GaussianBlur(noise, (0, 0), 0.35)[..., None] | |
| result = array.astype(np.float32) + noise | |
| else: | |
| raise ValueError(f"unknown texture family: {family}") | |
| return Image.fromarray(_uint8(result)) | |
| raise ValueError(f"pixel transform does not support factor: {factor}") | |
| def _apply_homography( | |
| image: Image.Image, matrix: np.ndarray | |
| ) -> tuple[Image.Image, callable]: | |
| array = np.asarray(image) | |
| height, width = array.shape[:2] | |
| warped = cv2.warpPerspective( | |
| array, matrix, (width, height), flags=cv2.INTER_LANCZOS4, borderMode=cv2.BORDER_REFLECT_101 | |
| ) | |
| def map_points(points: np.ndarray) -> np.ndarray: | |
| return cv2.perspectiveTransform(points.astype(np.float32)[None], matrix)[0] | |
| return Image.fromarray(warped), map_points | |
| def _geometry_transform( | |
| image: Image.Image, family: str, signed: float, seed: int | |
| ) -> tuple[Image.Image, callable]: | |
| magnitude = abs(signed) | |
| direction = 1 if signed >= 0 else -1 | |
| width, height = image.size | |
| center = np.array([width / 2, height / 2], dtype=np.float32) | |
| if family == "crop_zoom_translate": | |
| rng = np.random.default_rng(seed) | |
| scale = 1.0 + direction * 0.20 * magnitude | |
| shift = np.array( | |
| [direction * 0.10 * width, (1 if rng.integers(2) else -1) * 0.07 * height], | |
| dtype=np.float32, | |
| ) * magnitude | |
| matrix = np.array( | |
| [[scale, 0, center[0] * (1 - scale) + shift[0]], [0, scale, center[1] * (1 - scale) + shift[1]], [0, 0, 1]], | |
| dtype=np.float32, | |
| ) | |
| return _apply_homography(image, matrix) | |
| if family in {"perspective", "shear"}: | |
| source = np.array([[0, 0], [width - 1, 0], [width - 1, height - 1], [0, height - 1]], np.float32) | |
| if family == "perspective": | |
| delta = direction * 0.15 * width * magnitude | |
| target = source + np.array([[delta, 0], [-delta, delta * 0.35], [delta, 0], [-delta, -delta * 0.35]], np.float32) | |
| else: | |
| delta = direction * 0.18 * width * magnitude | |
| target = source + np.array([[delta, 0], [delta, 0], [-delta, 0], [-delta, 0]], np.float32) | |
| return _apply_homography(image, cv2.getPerspectiveTransform(source, target)) | |
| if family == "lens_warp": | |
| # Keep radial deformation perceptible without creating a bubble silhouette. | |
| radial_strength = float( | |
| np.interp(magnitude, [0.5, 0.8, 1.0], [0.035, 0.055, 0.075]) | |
| ) | |
| k = direction * radial_strength | |
| yy, xx = np.indices((height, width), dtype=np.float32) | |
| xd = (xx - center[0]) / (width / 2) | |
| yd = (yy - center[1]) / (height / 2) | |
| xs, ys = xd.copy(), yd.copy() | |
| for _ in range(4): | |
| radius2 = xs * xs + ys * ys | |
| factor = 1.0 + k * radius2 | |
| xs, ys = xd / factor, yd / factor | |
| map_x = xs * (width / 2) + center[0] | |
| map_y = ys * (height / 2) + center[1] | |
| warped = cv2.remap( | |
| np.asarray(image), map_x, map_y, cv2.INTER_LANCZOS4, borderMode=cv2.BORDER_REFLECT_101 | |
| ) | |
| def map_points(points: np.ndarray) -> np.ndarray: | |
| normalized = (points - center) / np.array([width / 2, height / 2]) | |
| radius2 = np.square(normalized).sum(axis=1, keepdims=True) | |
| return center + normalized * (1.0 + k * radius2) * np.array([width / 2, height / 2]) | |
| return Image.fromarray(warped), map_points | |
| raise ValueError(f"unknown geometry family: {family}") | |
| def _face_box_in_square(metadata: dict, crop_box: tuple[int, int, int, int], size: int) -> np.ndarray | None: | |
| box = (metadata.get("face_detection") or {}).get("primary_box") | |
| if box is None: | |
| return None | |
| left, top, right, bottom = crop_box | |
| scale_x = size / (right - left) | |
| scale_y = size / (bottom - top) | |
| x0, y0, x1, y1 = map(float, box) | |
| return np.array( | |
| [[(x0 - left) * scale_x, (y0 - top) * scale_y], [(x1 - left) * scale_x, (y0 - top) * scale_y], [(x1 - left) * scale_x, (y1 - top) * scale_y], [(x0 - left) * scale_x, (y1 - top) * scale_y]], | |
| dtype=np.float32, | |
| ) | |
| def _crop_face(image: Image.Image, points: np.ndarray, size: int, padding: float = 0.25) -> Image.Image: | |
| x0, y0 = points.min(axis=0) | |
| x1, y1 = points.max(axis=0) | |
| if x1 <= 0 or y1 <= 0 or x0 >= image.width or y0 >= image.height: | |
| raise ValueError("transformed face left the image") | |
| side = max(x1 - x0, y1 - y0) * (1 + 2 * padding) | |
| if side < 8: | |
| raise ValueError("transformed face is too small") | |
| cx, cy = (x0 + x1) / 2, (y0 + y1) / 2 | |
| box = (max(0, cx - side / 2), max(0, cy - side / 2), min(image.width, cx + side / 2), min(image.height, cy + side / 2)) | |
| crop = image.crop(tuple(map(int, map(round, box)))) | |
| if min(crop.size) < 4: | |
| raise ValueError("invalid transformed face crop") | |
| return crop.resize((size, size), Image.Resampling.LANCZOS) | |
| def apply_intervention( | |
| full_bytes: bytes, | |
| face_bytes: bytes | None, | |
| metadata: dict, | |
| spec: dict, | |
| *, | |
| size: int = 512, | |
| ) -> tuple[Image.Image, Image.Image | None]: | |
| full, crop_box = canonical_square(decode_rgb(full_bytes), size) | |
| signed = float(spec["signed_intensity"]) | |
| seed = int(spec["operation_seed"]) | |
| factor = str(spec["factor"]) | |
| family = str(spec["family"]) | |
| if factor == "geometry": | |
| transformed, map_points = _geometry_transform(full, family, signed, seed) | |
| points = _face_box_in_square(metadata, crop_box, size) | |
| face = None | |
| if points is not None: | |
| try: | |
| face = _crop_face(transformed, map_points(points), size) | |
| except ValueError: | |
| face = None | |
| if face is None and face_bytes is not None: | |
| face_source, _ = canonical_square(decode_rgb(face_bytes), size) | |
| face, _ = _geometry_transform(face_source, family, signed, seed ^ 0x5A17) | |
| return transformed, face | |
| transformed = _pixel_transform(full, factor, family, signed, seed) | |
| face = None | |
| if face_bytes is not None: | |
| face, _ = canonical_square(decode_rgb(face_bytes), size) | |
| face = _pixel_transform(face, factor, family, signed, seed ^ 0x5A17) | |
| return transformed, face | |