#---------------------------------------------------------------------------------------------------------------------#
# Comfyroll Studio custom nodes by RockOfFire and Akatsuzi https://github.com/Suzie1/ComfyUI_Comfyroll_CustomNodes
# for ComfyUI https://github.com/comfyanonymous/ComfyUI
#---------------------------------------------------------------------------------------------------------------------#
import numpy as np
import torch
import os
import random
from PIL import Image, ImageDraw, ImageFont, ImageOps, ImageEnhance
from ..config import color_mapping
font_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "fonts")
file_list = [f for f in os.listdir(font_dir) if os.path.isfile(os.path.join(font_dir, f)) and f.lower().endswith(".ttf")]
def tensor2pil(image):
return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
def pil2tensor(image):
return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
def align_text(align, img_height, text_height, text_pos_y, margins):
if align == "center":
text_plot_y = img_height / 2 - text_height / 2 + text_pos_y
elif align == "top":
text_plot_y = text_pos_y + margins
elif align == "bottom":
text_plot_y = img_height - text_height + text_pos_y - margins
return text_plot_y
def justify_text(justify, img_width, line_width, margins):
if justify == "left":
text_plot_x = 0 + margins
elif justify == "right":
text_plot_x = img_width - line_width - margins
elif justify == "center":
text_plot_x = img_width/2 - line_width/2
return text_plot_x
def get_text_size(draw, text, font):
bbox = draw.textbbox((0, 0), text, font=font)
# Calculate the text width and height
text_width = bbox[2] - bbox[0]
text_height = bbox[3] - bbox[1]
return text_width, text_height
def draw_masked_text(text_mask, text,
font_name, font_size,
margins, line_spacing,
position_x, position_y,
align, justify,
rotation_angle, rotation_options):
# Create the drawing context
draw = ImageDraw.Draw(text_mask)
# Define font settings
font_folder = "fonts"
font_file = os.path.join(font_folder, font_name)
resolved_font_path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), font_file)
font = ImageFont.truetype(str(resolved_font_path), size=font_size)
# Split the input text into lines
text_lines = text.split('\n')
# Calculate the size of the text plus padding for the tallest line
max_text_width = 0
max_text_height = 0
for line in text_lines:
# Calculate the width and height of the current line
line_width, line_height = get_text_size(draw, line, font)
line_height = line_height + line_spacing
max_text_width = max(max_text_width, line_width)
max_text_height = max(max_text_height, line_height)
# Get the image width and height
image_width, image_height = text_mask.size
image_center_x = image_width / 2
image_center_y = image_height / 2
text_pos_y = position_y
sum_text_plot_y = 0
text_height = max_text_height * len(text_lines)
for line in text_lines:
# Calculate the width of the current line
line_width, _ = get_text_size(draw, line, font)
# Get the text x and y positions for each line
text_plot_x = position_x + justify_text(justify, image_width, line_width, margins)
text_plot_y = align_text(align, image_height, text_height, text_pos_y, margins)
# Add the current line to the text mask
draw.text((text_plot_x, text_plot_y), line, fill=255, font=font)
text_pos_y += max_text_height # Move down for the next line
sum_text_plot_y += text_plot_y # Sum the y positions
# Calculate centers for rotation
text_center_x = text_plot_x + max_text_width / 2
text_center_y = sum_text_plot_y / len(text_lines)
if rotation_options == "text center":
rotated_text_mask = text_mask.rotate(rotation_angle, center=(text_center_x, text_center_y))
elif rotation_options == "image center":
rotated_text_mask = text_mask.rotate(rotation_angle, center=(image_center_x, image_center_y))
return rotated_text_mask
def draw_text_on_image(draw, y_position, bar_width, bar_height, text, font, text_color, font_outline):
# Calculate the width and height of the text
text_width, text_height = get_text_size(draw, text, font)
if font_outline == "thin":
outline_thickness = text_height // 40
elif font_outline == "thick":
outline_thickness = text_height // 20
elif font_outline == "extra thick":
outline_thickness = text_height // 10
outline_color = (0, 0, 0)
text_lines = text.split('\n')
if len(text_lines) == 1:
x = (bar_width - text_width) // 2
y = y_position + (bar_height - text_height) // 2 - (bar_height * 0.10)
if font_outline == "none":
draw.text((x, y), text, fill=text_color, font=font)
else:
draw.text((x, y), text, fill=text_color, font=font, stroke_width=outline_thickness, stroke_fill='black')
elif len(text_lines) > 1:
# Calculate the width and height of the text
text_width, text_height = get_text_size(draw, text_lines[0], font)
x = (bar_width - text_width) // 2
y = y_position + (bar_height - text_height * 2) // 2 - (bar_height * 0.15)
if font_outline == "none":
draw.text((x, y), text_lines[0], fill=text_color, font=font)
else:
draw.text((x, y), text_lines[0], fill=text_color, font=font, stroke_width=outline_thickness, stroke_fill='black')
# Calculate the width and height of the text
text_width, text_height = get_text_size(draw, text_lines[1], font)
x = (bar_width - text_width) // 2
y = y_position + (bar_height - text_height * 2) // 2 + text_height - (bar_height * 0.00)
if font_outline == "none":
draw.text((x, y), text_lines[1], fill=text_color, font=font)
else:
draw.text((x, y), text_lines[1], fill=text_color, font=font, stroke_width=outline_thickness, stroke_fill='black')
def get_font_size(draw, text, max_width, max_height, font_path, max_font_size):
# Adjust the max-width to allow for start and end padding
max_width = max_width * 0.9
# Start with the maximum font size
font_size = max_font_size
font = ImageFont.truetype(str(font_path), size=font_size)
# Get the first two lines
text_lines = text.split('\n')[:2]
if len(text_lines) == 2:
font_size = min(max_height//2, max_font_size)
font = ImageFont.truetype(str(font_path), size=font_size)
# Calculate max text width and height with the current font
max_text_width = 0
longest_line = text_lines[0]
for line in text_lines:
# Calculate the width and height of the current line
line_width, line_height = get_text_size(draw, line, font)
if line_width > max_text_width:
longest_line = line
max_text_width = max(max_text_width, line_width)
# Calculate the width and height of the text
text_width, text_height = get_text_size(draw, text, font)
# Decrease the font size until it fits within the bounds
while max_text_width > max_width or text_height > 0.88 * max_height / len(text_lines):
font_size -= 1
font = ImageFont.truetype(str(font_path), size=font_size)
max_text_width, text_height = get_text_size(draw, longest_line, font)
return font
def hex_to_rgb(hex_color):
hex_color = hex_color.lstrip('#') # Remove the '#' character, if present
r = int(hex_color[0:2], 16)
g = int(hex_color[2:4], 16)
b = int(hex_color[4:6], 16)
return (r, g, b)
def text_panel(image_width, image_height, text,
font_name, font_size, font_color,
font_outline_thickness, font_outline_color,
background_color,
margins, line_spacing,
position_x, position_y,
align, justify,
rotation_angle, rotation_options):
"""
Create an image with text overlaid on a background.
Returns:
PIL.Image.Image: Image with text overlaid on the background.
"""
# Create PIL images for the text and background layers and text mask
size = (image_width, image_height)
panel = Image.new('RGB', size, background_color)
# Draw the text on the text mask
image_out = draw_text(panel, text,
font_name, font_size, font_color,
font_outline_thickness, font_outline_color,
background_color,
margins, line_spacing,
position_x, position_y,
align, justify,
rotation_angle, rotation_options)
return image_out
def draw_text(panel, text,
font_name, font_size, font_color,
font_outline_thickness, font_outline_color,
bg_color,
margins, line_spacing,
position_x, position_y,
align, justify,
rotation_angle, rotation_options):
# Create the drawing context
draw = ImageDraw.Draw(panel)
# Define font settings
font_folder = "fonts"
font_file = os.path.join(font_folder, font_name)
resolved_font_path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), font_file)
font = ImageFont.truetype(str(resolved_font_path), size=font_size)
# Split the input text into lines
text_lines = text.split('\n')
# Calculate the size of the text plus padding for the tallest line
max_text_width = 0
max_text_height = 0
for line in text_lines:
# Calculate the width and height of the current line
line_width, line_height = get_text_size(draw, line, font)
line_height = line_height + line_spacing
max_text_width = max(max_text_width, line_width)
max_text_height = max(max_text_height, line_height)
# Get the image center
image_center_x = panel.width / 2
image_center_y = panel.height / 2
text_pos_y = position_y
sum_text_plot_y = 0
text_height = max_text_height * len(text_lines)
for line in text_lines:
# Calculate the width and height of the current line
line_width, line_height = get_text_size(draw, line, font)
# Get the text x and y positions for each line
text_plot_x = position_x + justify_text(justify, panel.width, line_width, margins)
text_plot_y = align_text(align, panel.height, text_height, text_pos_y, margins)
# Add the current line to the text mask
draw.text((text_plot_x, text_plot_y), line, fill=font_color, font=font, stroke_width=font_outline_thickness, stroke_fill=font_outline_color)
text_pos_y += max_text_height # Move down for the next line
sum_text_plot_y += text_plot_y # Sum the y positions
text_center_x = text_plot_x + max_text_width / 2
text_center_y = sum_text_plot_y / len(text_lines)
if rotation_options == "text center":
rotated_panel = panel.rotate(rotation_angle, center=(text_center_x, text_center_y), resample=Image.BILINEAR)
elif rotation_options == "image center":
rotated_panel = panel.rotate(rotation_angle, center=(image_center_x, image_center_y), resample=Image.BILINEAR)
return rotated_panel
def combine_images(images, layout_direction='horizontal'):
"""
Combine a list of PIL Image objects either horizontally or vertically.
Args:
images (list of PIL.Image.Image): List of PIL Image objects to combine.
layout_direction (str): 'horizontal' for horizontal layout, 'vertical' for vertical layout.
Returns:
PIL.Image.Image: Combined image.
"""
if layout_direction == 'horizontal':
combined_width = sum(image.width for image in images)
combined_height = max(image.height for image in images)
else:
combined_width = max(image.width for image in images)
combined_height = sum(image.height for image in images)
combined_image = Image.new('RGB', (combined_width, combined_height))
x_offset = 0
y_offset = 0 # Initialize y_offset for vertical layout
for image in images:
combined_image.paste(image, (x_offset, y_offset))
if layout_direction == 'horizontal':
x_offset += image.width
else:
y_offset += image.height
return combined_image
def apply_outline_and_border(images, outline_thickness, outline_color, border_thickness, border_color):
for i, image in enumerate(images):
# Apply the outline
if outline_thickness > 0:
image = ImageOps.expand(image, outline_thickness, fill=outline_color)
# Apply the border
if border_thickness > 0:
image = ImageOps.expand(image, border_thickness, fill=border_color)
images[i] = image
return images
def get_color_values(color, color_hex, color_mapping):
#Get RGB values for the text and background colors.
if color == "custom":
color_rgb = hex_to_rgb(color_hex)
else:
color_rgb = color_mapping.get(color, (0, 0, 0)) # Default to black if the color is not found
return color_rgb
def hex_to_rgb(hex_color):
hex_color = hex_color.lstrip('#') # Remove the '#' character, if present
r = int(hex_color[0:2], 16)
g = int(hex_color[2:4], 16)
b = int(hex_color[4:6], 16)
return (r, g, b)
def crop_and_resize_image(image, target_width, target_height):
width, height = image.size
aspect_ratio = width / height
target_aspect_ratio = target_width / target_height
if aspect_ratio > target_aspect_ratio:
# Crop the image's width to match the target aspect ratio
crop_width = int(height * target_aspect_ratio)
crop_height = height
left = (width - crop_width) // 2
top = 0
else:
# Crop the image's height to match the target aspect ratio
crop_height = int(width / target_aspect_ratio)
crop_width = width
left = 0
top = (height - crop_height) // 2
# Perform the center cropping
cropped_image = image.crop((left, top, left + crop_width, top + crop_height))
return cropped_image
def create_and_paste_panel(page, border_thickness, outline_thickness,
panel_width, panel_height, page_width,
panel_color, bg_color, outline_color,
images, i, j, k, len_images, reading_direction):
panel = Image.new("RGB", (panel_width, panel_height), panel_color)
if k < len_images:
img = images[k]
image = crop_and_resize_image(img, panel_width, panel_height)
image.thumbnail((panel_width, panel_height), Image.Resampling.LANCZOS)
panel.paste(image, (0, 0))
panel = ImageOps.expand(panel, border=outline_thickness, fill=outline_color)
panel = ImageOps.expand(panel, border=border_thickness, fill=bg_color)
new_panel_width, new_panel_height = panel.size
if reading_direction == "right to left":
page.paste(panel, (page_width - (j + 1) * new_panel_width, i * new_panel_height))
else:
page.paste(panel, (j * new_panel_width, i * new_panel_height))
def reduce_opacity(img, opacity):
"""Returns an image with reduced opacity."""
assert opacity >= 0 and opacity <= 1
if img.mode != 'RGBA':
img = img.convert('RGBA')
else:
img = img.copy()
alpha = img.split()[3]
alpha = ImageEnhance.Brightness(alpha).enhance(opacity)
img.putalpha(alpha)
return img
def random_hex_color():
# Generate three random values for RGB
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
# Convert RGB to hex format
hex_color = "#{:02x}{:02x}{:02x}".format(r, g, b)
return hex_color
def random_rgb():
# Generate three random values for RGB
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
# Format RGB as a string in the format "128,128,128"
rgb_string = "{},{},{}".format(r, g, b)
return rgb_string
def make_grid_panel(images, max_columns):
# Calculate dimensions for the grid
num_images = len(images)
num_rows = (num_images - 1) // max_columns + 1
combined_width = max(image.width for image in images) * min(max_columns, num_images)
combined_height = max(image.height for image in images) * num_rows
combined_image = Image.new('RGB', (combined_width, combined_height))
x_offset, y_offset = 0, 0 # Initialize offsets
for image in images:
combined_image.paste(image, (x_offset, y_offset))
x_offset += image.width
if x_offset >= max_columns * image.width:
x_offset = 0
y_offset += image.height
return combined_image
def interpolate_color(color0, color1, t):
"""
Interpolate between two colors.
"""
return tuple(int(c0 * (1 - t) + c1 * t) for c0, c1 in zip(color0, color1))