| from PIL import Image, ImageEnhance, ImageColor, ImageOps |
| import numpy as np |
| import torch |
| from server import PromptServer |
|
|
|
|
| class PreviewTextNode: |
| def __init__(self): |
| pass |
|
|
| @classmethod |
| def INPUT_TYPES(s): |
|
|
| return { |
| "required": { |
| "text": ("STRING", {"forceInput": True}), |
| }, |
| "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"}, |
| } |
|
|
| RETURN_TYPES = ("STRING",) |
| OUTPUT_NODE = True |
| FUNCTION = "preview_text" |
|
|
| CATEGORY = "AlekPet Nodes/extras" |
|
|
| def preview_text(self, text, prompt=None, extra_pnginfo=None): |
| return { |
| "ui": { |
| "string": [ |
| text, |
| ] |
| }, |
| "result": (text,), |
| } |
|
|
|
|
| |
| class HexToHueNode: |
|
|
| @classmethod |
| def INPUT_TYPES(cls): |
| return { |
| "required": { |
| "color_hex": ( |
| "STRING", |
| {"default": "#00ff33"}, |
| ), |
| }, |
| "hidden": {"unique_id": "UNIQUE_ID"}, |
| } |
|
|
| RETURN_TYPES = ("STRING", "FLOAT", "FLOAT", "STRING", "STRING") |
| RETURN_NAMES = ( |
| "string_hex", |
| "float_hue_degrees", |
| "float_hue_norm", |
| "string_hue_degrees", |
| "string_hue_norm", |
| ) |
| FUNCTION = "to_hue" |
| CATEGORY = "AlekPet Nodes/extras" |
|
|
| def to_hue(self, color_hex, unique_id): |
| hue_degrees = ColorsCorrectNode.hex_to_hue(color_hex) |
| hue_norm = ColorsCorrectNode.degrees_to_hue(hue_degrees) |
| PromptServer.instance.send_sync( |
| "alekpet_get_color_hex", {"color_hex": color_hex, "unique_id": unique_id} |
| ) |
| return (color_hex, hue_degrees, hue_norm, str(hue_degrees), str(hue_norm)) |
|
|
|
|
| class ColorsCorrectNode: |
|
|
| @classmethod |
| def INPUT_TYPES(cls): |
| return { |
| "required": { |
| "image": ("IMAGE",), |
| "brightness": ( |
| "FLOAT", |
| {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.05}, |
| ), |
| "contrast": ( |
| "FLOAT", |
| {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.05}, |
| ), |
| "saturation": ( |
| "FLOAT", |
| {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.05}, |
| ), |
| "gamma": ( |
| "FLOAT", |
| {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.05}, |
| ), |
| "hue_degrees": ( |
| "FLOAT", |
| {"default": 0.0, "min": 0.0, "max": 360.0, "step": 0.01}, |
| ), |
| "use_color": ( |
| "BOOLEAN", |
| {"default": True}, |
| ), |
| }, |
| "optional": { |
| "hex_color": ( |
| "STRING", |
| {"default": "#00FF33"}, |
| ), |
| }, |
| } |
|
|
| RETURN_TYPES = ("IMAGE",) |
| FUNCTION = "correct" |
| CATEGORY = "AlekPet Nodes/extras" |
|
|
| @staticmethod |
| def hex_to_rgb(hex_color): |
| return ImageColor.getcolor(hex_color, "RGB") |
|
|
| @staticmethod |
| def hex_to_hue(hex_color): |
| rgb = ImageColor.getcolor(hex_color, "RGB") |
| r, g, b = [x / 255.0 for x in rgb] |
| mx = max(r, g, b) |
| mn = min(r, g, b) |
| df = mx - mn |
|
|
| if mx == mn: |
| h = 0 |
| elif mx == r: |
| h = (60 * ((g - b) / df) + 360) % 360 |
| elif mx == g: |
| h = (60 * ((b - r) / df) + 120) % 360 |
| elif mx == b: |
| h = (60 * ((r - g) / df) + 240) % 360 |
|
|
| return h |
|
|
| @staticmethod |
| def adjust_brightness(image, factor): |
| enhancer = ImageEnhance.Brightness(image) |
| return enhancer.enhance(factor) |
|
|
| @staticmethod |
| def adjust_contrast(image, factor): |
| enhancer = ImageEnhance.Contrast(image) |
| return enhancer.enhance(factor) |
|
|
| @staticmethod |
| def adjust_saturation(image, factor): |
| enhancer = ImageEnhance.Color(image) |
| return enhancer.enhance(factor) |
|
|
| @staticmethod |
| def adjust_gamma(image, gamma): |
| inv_gamma = 1.0 / gamma |
| lut = [pow(x / 255.0, inv_gamma) * 255 for x in range(256)] |
| lut = np.array(lut * 3, dtype=np.uint8) |
| return image.point(lut) |
|
|
| @staticmethod |
| def degrees_to_hue(degrees): |
| degrees = degrees % 360 |
| hue = degrees / 360.0 |
|
|
| if hue > 0.5: |
| hue -= 1.0 |
| if hue < -0.5: |
| hue += 1.0 |
|
|
| return hue |
|
|
| @staticmethod |
| def adjust_hue(image, hue): |
| if not (-0.5 <= hue <= 0.5): |
| raise ValueError("hue value is not in [-0.5, 0.5].") |
|
|
| image_array = np.array(image.convert("RGB"), dtype=np.uint8) |
|
|
| hsv_image = Image.fromarray(image_array).convert("HSV") |
| hsv_array = np.array(hsv_image) |
|
|
| hsv_array[..., 0] = (hsv_array[..., 0].astype(int) + int(hue * 255)) % 256 |
|
|
| rgb_image = Image.fromarray(hsv_array, mode="HSV").convert("RGB") |
| return rgb_image |
|
|
| @staticmethod |
| def tint_image(image, hex_color): |
| return ImageOps.colorize(image.convert("L"), black="black", white=hex_color) |
|
|
| def correct( |
| self, |
| image, |
| use_color=True, |
| hex_color="#00FF33", |
| brightness=1.0, |
| contrast=1.0, |
| saturation=1.0, |
| gamma=1.0, |
| hue_degrees=0.0, |
| ): |
| i = 255.0 * image[0].cpu().numpy() |
| image = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8)) |
|
|
| if use_color: |
| image = ColorsCorrectNode.tint_image(image, hex_color) |
|
|
| image = ColorsCorrectNode.adjust_brightness(image, brightness) |
| image = ColorsCorrectNode.adjust_contrast(image, contrast) |
| image = ColorsCorrectNode.adjust_saturation(image, saturation) |
| image = ColorsCorrectNode.adjust_gamma(image, gamma) |
|
|
| hue_norm = ColorsCorrectNode.degrees_to_hue(hue_degrees) |
| image = ColorsCorrectNode.adjust_hue(image, hue_norm) |
|
|
| image = ImageOps.exif_transpose(image) |
| image = image.convert("RGB") |
| image = np.array(image).astype(np.float32) / 255.0 |
| image = torch.from_numpy(image)[None,] |
|
|
| return (image,) |
|
|
