TTPLanet_SDXL_Controlnet_Tile_Realistic / TTP_tile_preprocessor_v5.py

better pre-processor for comfyui

6c6298e verified about 2 months ago

No virus

7.97 kB

	import cv2
	import numpy as np
	from PIL import Image
	import torch

	def pil2tensor(image: Image) -> torch.Tensor:
	return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)

	def tensor2pil(t_image: torch.Tensor) -> Image:
	return Image.fromarray(np.clip(255.0 * t_image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))

	def apply_gaussian_blur(image_np, ksize=5, sigmaX=1.0):
	if ksize % 2 == 0:
	ksize += 1 # ksize must be odd
	blurred_image = cv2.GaussianBlur(image_np, (ksize, ksize), sigmaX=sigmaX)
	return blurred_image

	def apply_guided_filter(image_np, radius, eps):
	# Convert image to float32 for the guided filter
	image_np_float = np.float32(image_np) / 255.0
	# Apply the guided filter
	filtered_image = cv2.ximgproc.guidedFilter(image_np_float, image_np_float, radius, eps)
	# Scale back to uint8
	filtered_image = np.clip(filtered_image * 255, 0, 255).astype(np.uint8)
	return filtered_image

	class TTPlanet_Tile_Preprocessor_GF:
	def __init__(self, blur_strength=3.0, radius=7, eps=0.01):
	self.blur_strength = blur_strength
	self.radius = radius
	self.eps = eps

	@classmethod
	def INPUT_TYPES(cls):
	return {
	"required": {
	"image": ("IMAGE",),
	"scale_factor": ("FLOAT", {"default": 1.00, "min": 1.00, "max": 8.00, "step": 0.05}),
	"blur_strength": ("FLOAT", {"default": 2.0, "min": 1.0, "max": 10.0, "step": 0.1}),
	"radius": ("INT", {"default": 7, "min": 1, "max": 20, "step": 1}),
	"eps": ("FLOAT", {"default": 0.01, "min": 0.001, "max": 0.1, "step": 0.001}),
	},
	"optional": {}
	}

	RETURN_TYPES = ("IMAGE",)
	RETURN_NAMES = ("image_output",)
	FUNCTION = 'process_image'
	CATEGORY = 'TTP_TILE'

	def process_image(self, image, scale_factor, blur_strength, radius, eps):
	ret_images = []

	for i in image:
	# Convert tensor to PIL for processing
	_canvas = tensor2pil(torch.unsqueeze(i, 0)).convert('RGB')
	img_np = np.array(_canvas)[:, :, ::-1] # RGB to BGR

	# Apply Gaussian blur
	img_np = apply_gaussian_blur(img_np, ksize=int(blur_strength), sigmaX=blur_strength / 2)

	# Apply Guided Filter
	img_np = apply_guided_filter(img_np, radius, eps)


	# Resize image
	height, width = img_np.shape[:2]
	new_width = int(width / scale_factor)
	new_height = int(height / scale_factor)
	resized_down = cv2.resize(img_np, (new_width, new_height), interpolation=cv2.INTER_AREA)
	resized_img = cv2.resize(resized_down, (width, height), interpolation=cv2.INTER_CUBIC)



	# Convert OpenCV back to PIL and then to tensor
	pil_img = Image.fromarray(resized_img[:, :, ::-1]) # BGR to RGB
	tensor_img = pil2tensor(pil_img)
	ret_images.append(tensor_img)

	return (torch.cat(ret_images, dim=0),)

	class TTPlanet_Tile_Preprocessor_Simple:
	def __init__(self, blur_strength=3.0):
	self.blur_strength = blur_strength

	@classmethod
	def INPUT_TYPES(cls):
	return {
	"required": {
	"image": ("IMAGE",),
	"scale_factor": ("FLOAT", {"default": 2.00, "min": 1.00, "max": 8.00, "step": 0.05}),
	"blur_strength": ("FLOAT", {"default": 1.0, "min": 1.0, "max": 20.0, "step": 0.1}),
	},
	"optional": {}
	}

	RETURN_TYPES = ("IMAGE",)
	RETURN_NAMES = ("image_output",)
	FUNCTION = 'process_image'
	CATEGORY = 'TTP_TILE'

	def process_image(self, image, scale_factor, blur_strength):
	ret_images = []

	for i in image:
	# Convert tensor to PIL for processing
	_canvas = tensor2pil(torch.unsqueeze(i, 0)).convert('RGB')

	# Convert PIL image to OpenCV format
	img_np = np.array(_canvas)[:, :, ::-1] # RGB to BGR

	# Resize image first if you want blur to apply after resizing
	height, width = img_np.shape[:2]
	new_width = int(width / scale_factor)
	new_height = int(height / scale_factor)
	resized_down = cv2.resize(img_np, (new_width, new_height), interpolation=cv2.INTER_AREA)
	resized_img = cv2.resize(resized_down, (width, height), interpolation=cv2.INTER_LANCZOS4)

	# Apply Gaussian blur after resizing
	img_np = apply_gaussian_blur(resized_img, ksize=int(blur_strength), sigmaX=blur_strength / 2)

	# Convert OpenCV back to PIL and then to tensor
	_canvas = Image.fromarray(img_np[:, :, ::-1]) # BGR to RGB
	tensor_img = pil2tensor(_canvas)
	ret_images.append(tensor_img)

	return (torch.cat(ret_images, dim=0),)

	class TTPlanet_Tile_Preprocessor_cufoff:
	def __init__(self, blur_strength=3.0, cutoff_frequency=30, filter_strength=1.0):
	self.blur_strength = blur_strength
	self.cutoff_frequency = cutoff_frequency
	self.filter_strength = filter_strength

	@classmethod
	def INPUT_TYPES(cls):
	return {
	"required": {
	"image": ("IMAGE",),
	"scale_factor": ("FLOAT", {"default": 1.00, "min": 1.00, "max": 8.00, "step": 0.05}),
	"blur_strength": ("FLOAT", {"default": 2.0, "min": 1.0, "max": 10.0, "step": 0.1}),
	"cutoff_frequency": ("INT", {"default": 100, "min": 0, "max": 256, "step": 1}),
	"filter_strength": ("FLOAT", {"default": 1.0, "min": 0.1, "max": 10.0, "step": 0.1}),
	},
	"optional": {}
	}

	RETURN_TYPES = ("IMAGE",)
	RETURN_NAMES = ("image_output",)
	FUNCTION = 'process_image'
	CATEGORY = 'TTP_TILE'

	def process_image(self, image, scale_factor, blur_strength, cutoff_frequency, filter_strength):
	ret_images = []

	for i in image:
	# Convert tensor to PIL for processing
	_canvas = tensor2pil(torch.unsqueeze(i, 0)).convert('RGB')
	img_np = np.array(_canvas)[:, :, ::-1] # RGB to BGR

	# Apply low pass filter with new strength parameter
	img_np = apply_low_pass_filter(img_np, cutoff_frequency, filter_strength)

	# Resize image
	height, width = img_np.shape[:2]
	new_width = int(width / scale_factor)
	new_height = int(height / scale_factor)
	resized_down = cv2.resize(img_np, (new_width, new_height), interpolation=cv2.INTER_AREA)
	resized_img = cv2.resize(resized_down, (width, height), interpolation=cv2.INTER_LANCZOS4)

	# Apply Gaussian blur
	img_np = apply_gaussian_blur(img_np, ksize=int(blur_strength), sigmaX=blur_strength / 2)

	# Convert OpenCV back to PIL and then to tensor
	pil_img = Image.fromarray(resized_img[:, :, ::-1]) # BGR to RGB
	tensor_img = pil2tensor(pil_img)
	ret_images.append(tensor_img)

	return (torch.cat(ret_images, dim=0),)

	NODE_CLASS_MAPPINGS = {
	"TTPlanet_Tile_Preprocessor_GF": TTPlanet_Tile_Preprocessor_GF,
	"TTPlanet_Tile_Preprocessor_Simple": TTPlanet_Tile_Preprocessor_Simple,
	"TTPlanet_Tile_Preprocessor_cufoff": TTPlanet_Tile_Preprocessor_cufoff
	}

	NODE_DISPLAY_NAME_MAPPINGS = {
	"TTPlanet_Tile_Preprocessor_GF": "🪐TTPlanet Tile Preprocessor GF",
	"TTPlanet_Tile_Preprocessor_Simple": "🪐TTPlanet Tile Preprocessor Simple",
	"TTPlanet_Tile_Preprocessor_cufoff": "🪐TTPlanet Tile Preprocessor cufoff"
	}