|
|
|
|
|
from .categories import NodeCategories |
|
from .shared import * |
|
from .dreamtypes import * |
|
|
|
|
|
class DreamImageAreaSampler: |
|
NODE_NAME = "Sample Image Area as Palette" |
|
|
|
@classmethod |
|
def INPUT_TYPES(cls): |
|
return { |
|
"required": { |
|
"image": ("IMAGE",), |
|
"samples": ("INT", {"default": 256, "min": 1, "max": 1024 * 4}), |
|
"seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), |
|
"area": (["top-left", "top-center", "top-right", |
|
"center-left", "center", "center-right", |
|
"bottom-left", "bottom-center", "bottom-right"],) |
|
}, |
|
} |
|
|
|
CATEGORY = NodeCategories.IMAGE_COLORS |
|
RETURN_TYPES = (RGBPalette.ID,) |
|
RETURN_NAMES = ("palette",) |
|
FUNCTION = "result" |
|
|
|
@classmethod |
|
def IS_CHANGED(cls, *values): |
|
return ALWAYS_CHANGED_FLAG |
|
|
|
def _get_pixel_area(self, img: DreamImage, area): |
|
w = img.width |
|
h = img.height |
|
wpart = round(w / 3) |
|
hpart = round(h / 3) |
|
x0 = 0 |
|
x1 = wpart - 1 |
|
x2 = wpart |
|
x3 = wpart + wpart - 1 |
|
x4 = wpart + wpart |
|
x5 = w - 1 |
|
y0 = 0 |
|
y1 = hpart - 1 |
|
y2 = hpart |
|
y3 = hpart + hpart - 1 |
|
y4 = hpart + hpart |
|
y5 = h - 1 |
|
if area == "center": |
|
return (x2, y2, x3, y3) |
|
elif area == "top-center": |
|
return (x2, y0, x3, y1) |
|
elif area == "bottom-center": |
|
return (x2, y4, x3, y5) |
|
elif area == "center-left": |
|
return (x0, y2, x1, y3) |
|
elif area == "top-left": |
|
return (x0, y0, x1, y1) |
|
elif area == "bottom-left": |
|
return (x0, y4, x1, y5) |
|
elif area == "center-right": |
|
return (x4, y2, x5, y3) |
|
elif area == "top-right": |
|
return (x4, y0, x5, y1) |
|
elif area == "bottom-right": |
|
return (x4, y4, x5, y5) |
|
|
|
def result(self, image, samples, seed, area): |
|
result = list() |
|
r = random.Random() |
|
r.seed(seed) |
|
for data in image: |
|
di = DreamImage(tensor_image=data) |
|
area = self._get_pixel_area(di, area) |
|
|
|
pixels = list() |
|
for i in range(samples): |
|
x = r.randint(area[0], area[2]) |
|
y = r.randint(area[1], area[3]) |
|
pixels.append(di.get_pixel(x, y)) |
|
result.append(RGBPalette(colors=pixels)) |
|
|
|
return (tuple(result),) |
|
|
|
|
|
class DreamImageSampler: |
|
NODE_NAME = "Sample Image as Palette" |
|
|
|
@classmethod |
|
def INPUT_TYPES(cls): |
|
return { |
|
"required": { |
|
"image": ("IMAGE",), |
|
"samples": ("INT", {"default": 1024, "min": 1, "max": 1024 * 4}), |
|
"seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}) |
|
}, |
|
} |
|
|
|
CATEGORY = NodeCategories.IMAGE_COLORS |
|
RETURN_TYPES = (RGBPalette.ID,) |
|
RETURN_NAMES = ("palette",) |
|
FUNCTION = "result" |
|
|
|
@classmethod |
|
def IS_CHANGED(cls, *values): |
|
return ALWAYS_CHANGED_FLAG |
|
|
|
def result(self, image, samples, seed): |
|
result = list() |
|
r = random.Random() |
|
r.seed(seed) |
|
for data in image: |
|
di = DreamImage(tensor_image=data) |
|
pixels = list() |
|
for i in range(samples): |
|
x = r.randint(0, di.width - 1) |
|
y = r.randint(0, di.height - 1) |
|
pixels.append(di.get_pixel(x, y)) |
|
result.append(RGBPalette(colors=pixels)) |
|
|
|
return (tuple(result),) |
|
|
|
|
|
class DreamColorAlign: |
|
NODE_NAME = "Palette Color Align" |
|
|
|
@classmethod |
|
def INPUT_TYPES(cls): |
|
return { |
|
"required": SharedTypes.palette | { |
|
"target_align": (RGBPalette.ID,), |
|
"alignment_factor": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 10.0, "step": 0.1}), |
|
} |
|
} |
|
|
|
CATEGORY = NodeCategories.IMAGE_COLORS |
|
RETURN_TYPES = (RGBPalette.ID,) |
|
RETURN_NAMES = ("palette",) |
|
FUNCTION = "result" |
|
|
|
@classmethod |
|
def IS_CHANGED(cls, *values): |
|
return ALWAYS_CHANGED_FLAG |
|
|
|
def result(self, palette: Tuple[RGBPalette], target_align: Tuple[RGBPalette], alignment_factor: float): |
|
results = list() |
|
|
|
def _limit(c): |
|
return max(min(c, 255), 0) |
|
|
|
for i in range(len(palette)): |
|
p = palette[i] |
|
t = target_align[i] |
|
(_, _, r1, g1, b1) = p.analyze() |
|
(_, _, r2, g2, b2) = t.analyze() |
|
|
|
dr = (r2 - r1) * alignment_factor |
|
dg = (g2 - g1) * alignment_factor |
|
db = (b2 - b1) * alignment_factor |
|
new_pixels = list() |
|
for pixel in p: |
|
r = _limit(round(pixel[0] + (255 * dr))) |
|
g = _limit(round(pixel[1] + (255 * dg))) |
|
b = _limit(round(pixel[1] + (255 * db))) |
|
new_pixels.append((r, g, b)) |
|
results.append(RGBPalette(colors=new_pixels)) |
|
return (tuple(results),) |
|
|
|
|
|
class DreamColorShift: |
|
NODE_NAME = "Palette Color Shift" |
|
|
|
@classmethod |
|
def INPUT_TYPES(cls): |
|
return { |
|
"required": SharedTypes.palette | { |
|
"red_multiplier": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1}), |
|
"green_multiplier": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1}), |
|
"blue_multiplier": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1}), |
|
"fixed_brightness": (["yes", "no"],), |
|
} |
|
} |
|
|
|
CATEGORY = NodeCategories.IMAGE_COLORS |
|
RETURN_TYPES = (RGBPalette.ID,) |
|
RETURN_NAMES = ("palette",) |
|
FUNCTION = "result" |
|
|
|
@classmethod |
|
def IS_CHANGED(cls, *values): |
|
return ALWAYS_CHANGED_FLAG |
|
|
|
def result(self, palette, red_multiplier, green_multiplier, blue_multiplier, fixed_brightness): |
|
results = list() |
|
|
|
def _limit(c): |
|
return max(min(c, 255), 0) |
|
|
|
for p in palette: |
|
new_pixels = list() |
|
for pixel in p: |
|
s = pixel[0] + pixel[1] + pixel[2] |
|
r = _limit(round(pixel[0] * red_multiplier)) |
|
g = _limit(round(pixel[1] * green_multiplier)) |
|
b = _limit(round(pixel[2] * blue_multiplier)) |
|
if fixed_brightness == "yes": |
|
brightness_factor = max(s, 1) / float(max(r + g + b, 1)) |
|
r = _limit(round(r * brightness_factor)) |
|
g = _limit(round(g * brightness_factor)) |
|
b = _limit(round(b * brightness_factor)) |
|
|
|
new_pixels.append((r, g, b)) |
|
results.append(RGBPalette(colors=new_pixels)) |
|
return (tuple(results),) |
|
|
|
|
|
class DreamImageColorShift: |
|
NODE_NAME = "Image Color Shift" |
|
ICON = "🖼" |
|
@classmethod |
|
def INPUT_TYPES(cls): |
|
return { |
|
"required": {"image": ("IMAGE",), |
|
"red_multiplier": ("FLOAT", {"default": 1.0, "min": 0.0}), |
|
"green_multiplier": ("FLOAT", {"default": 1.0, "min": 0.0}), |
|
"blue_multiplier": ("FLOAT", {"default": 1.0, "min": 0.0}), |
|
}, |
|
|
|
} |
|
|
|
CATEGORY = NodeCategories.IMAGE_COLORS |
|
RETURN_TYPES = ("IMAGE",) |
|
RETURN_NAMES = ("image",) |
|
FUNCTION = "result" |
|
|
|
@classmethod |
|
def IS_CHANGED(cls, *values): |
|
return ALWAYS_CHANGED_FLAG |
|
|
|
def result(self, image, red_multiplier, green_multiplier, blue_multiplier): |
|
proc = DreamImageProcessor(inputs=image) |
|
|
|
def recolor(im: DreamImage, *a, **args): |
|
return (im.adjust_colors(red_multiplier, green_multiplier, blue_multiplier),) |
|
|
|
return proc.process(recolor) |
|
|
|
|
|
class DreamImageBrightness: |
|
NODE_NAME = "Image Brightness Adjustment" |
|
ICON = "☼" |
|
|
|
@classmethod |
|
def INPUT_TYPES(cls): |
|
return { |
|
"required": {"image": ("IMAGE",), |
|
"factor": ("FLOAT", {"default": 1.0, "min": 0.0}), |
|
}, |
|
|
|
} |
|
|
|
CATEGORY = NodeCategories.IMAGE_COLORS |
|
RETURN_TYPES = ("IMAGE",) |
|
RETURN_NAMES = ("image",) |
|
FUNCTION = "result" |
|
|
|
@classmethod |
|
def IS_CHANGED(cls, *values): |
|
return ALWAYS_CHANGED_FLAG |
|
|
|
def result(self, image, factor): |
|
proc = DreamImageProcessor(inputs=image) |
|
|
|
def change(im: DreamImage, *a, **args): |
|
return (im.change_brightness(factor),) |
|
|
|
return proc.process(change) |
|
|
|
|
|
class DreamImageContrast: |
|
NODE_NAME = "Image Contrast Adjustment" |
|
ICON = "◐" |
|
|
|
@classmethod |
|
def INPUT_TYPES(cls): |
|
return { |
|
"required": {"image": ("IMAGE",), |
|
"factor": ("FLOAT", {"default": 1.0, "min": 0.0}), |
|
}, |
|
|
|
} |
|
|
|
CATEGORY = NodeCategories.IMAGE_COLORS |
|
RETURN_TYPES = ("IMAGE",) |
|
RETURN_NAMES = ("image",) |
|
FUNCTION = "result" |
|
|
|
@classmethod |
|
def IS_CHANGED(cls, *values): |
|
return ALWAYS_CHANGED_FLAG |
|
|
|
def result(self, image, factor): |
|
proc = DreamImageProcessor(inputs=image) |
|
|
|
def change(im: DreamImage, *a, **args): |
|
return (im.change_contrast(factor),) |
|
|
|
return proc.process(change) |
|
|
|
|
|
class DreamComparePalette: |
|
NODE_NAME = "Compare Palettes" |
|
ICON = "📊" |
|
|
|
@classmethod |
|
def INPUT_TYPES(cls): |
|
return { |
|
"required": { |
|
"a": (RGBPalette.ID,), |
|
"b": (RGBPalette.ID,), |
|
}, |
|
} |
|
|
|
CATEGORY = NodeCategories.IMAGE_COLORS |
|
RETURN_TYPES = ("FLOAT", "FLOAT", "FLOAT", "FLOAT") |
|
RETURN_NAMES = ( |
|
"brightness_multiplier", "contrast_multiplier", "red_multiplier", "green_multiplier", "blue_multiplier") |
|
FUNCTION = "result" |
|
|
|
@classmethod |
|
def IS_CHANGED(cls, *values): |
|
return ALWAYS_CHANGED_FLAG |
|
|
|
def result(self, a, b): |
|
MIN_VALUE = 1 / 255.0 |
|
|
|
brightness = list() |
|
contrasts = list() |
|
reds = list() |
|
greens = list() |
|
blues = list() |
|
|
|
for i in range(min(len(a), len(b))): |
|
(bright, ctr, red, green, blue) = a[i].analyze() |
|
(bright2, ctr2, red2, green2, blue2) = b[i].analyze() |
|
brightness.append(bright2 / max(MIN_VALUE, bright)) |
|
contrasts.append(ctr2 / max(MIN_VALUE, ctr)) |
|
reds.append(red2 / max(MIN_VALUE, red)) |
|
greens.append(green2 / max(MIN_VALUE, green)) |
|
blues.append(blue2 / max(MIN_VALUE, blue)) |
|
|
|
n = len(brightness) |
|
|
|
return (sum(brightness) / n, sum(contrasts) / n, sum(reds) / n, |
|
sum(greens) / n, sum(blues) / n) |
|
|
|
|
|
class DreamAnalyzePalette: |
|
NODE_NAME = "Analyze Palette" |
|
ICON = "📊" |
|
|
|
@classmethod |
|
def INPUT_TYPES(cls): |
|
return { |
|
"required": SharedTypes.palette |
|
, |
|
} |
|
|
|
CATEGORY = NodeCategories.IMAGE_COLORS |
|
RETURN_TYPES = ("FLOAT", "FLOAT", "FLOAT", "FLOAT", "FLOAT") |
|
RETURN_NAMES = ("brightness", "contrast", "redness", "greenness", "blueness") |
|
FUNCTION = "result" |
|
|
|
@classmethod |
|
def IS_CHANGED(cls, *values): |
|
return ALWAYS_CHANGED_FLAG |
|
|
|
def result(self, palette): |
|
f = 1.0 / len(palette) |
|
(w, c, r, g, b) = (0, 0, 0, 0, 0) |
|
for p in palette: |
|
(brightness, contrast, red, green, blue) = p.analyze() |
|
w += brightness |
|
c += contrast |
|
r += red |
|
g += green |
|
b += blue |
|
|
|
return w * f, c * f, r * f, g * f, b * f |
|
|
