def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
kernel_x = eval_info.EvaluateProperty('Kernel X')
kernel_y = eval_info.EvaluateProperty('Kernel Y')
filter_type = eval_info.EvaluateProperty('Filter Type')
image = api.RenderImage()
img = ArrayFromImage(image1.GetImage())
if filter_type == "Box":
output_img = cv2.boxFilter(img, -1, (kernel_x, kernel_y))
elif filter_type == "Gaussian":
# Both values must be odd
if (kernel_x % 2) == 0 and (kernel_y % 2) == 0:
kernel_y += 1
kernel_x += 1
output_img = cv2.GaussianBlur(img, (0, 0),
sigmaX=kernel_x,
sigmaY=kernel_y)
image.SetAsImage(ArrayToImage(output_img).convert('RGBA'))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
path = eval_info.EvaluateProperty('File Path')
image = api.RenderImage()
if path != "":
if self._cachedPath != path:
try:
image.SetAsOpenedImage(path)
img = image.GetImage().convert('RGBA')
self._cachedPath = path
self._cachedImage = img
image.SetAsImage(img)
except FileNotFoundError:
print("FILE NOT FOUND")
else:
image.SetAsImage(self._cachedImage)
# if path != '':
# try:
# image.SetAsOpenedImage(path)
# image.SetAsImage(image.GetImage().convert('RGBA'))
# except FileNotFoundError:
# pass
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
sigma_val = eval_info.EvaluateProperty('Sigma')
intensity_val = eval_info.EvaluateProperty('Intensity')
# Convert the current image data to an array that scipy can use
im = ArrayFromImage(image1.GetImage())
# Create the image
if im.ndim == 3:
im_grey = np.zeros((im.shape[0], im.shape[1])).astype(float)
im_grey = (im[..., 0] * 0.3 + im[..., 1] * 0.6 + im[..., 2] * 0.1)
im = im_grey
im_smooth = self.SmoothGaussian(im, sigma_val)
sobel_x, sobel_y = self.Sobel(im_smooth)
# Calculate the normal map
generated_normal_map = self.ComputeNormalMap(
sobel_x,
sobel_y,
intensity_val
)
image = api.RenderImage()
image.SetAsImage(
ArrayToImage(generated_normal_map).convert('RGBA')
)
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
image = api.RenderImage()
image.SetAsImage(ImageChops.invert(image1.GetImage()).convert('RGBA'))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
channel = eval_info.EvaluateProperty('Image Channel')
greyscale = eval_info.EvaluateProperty('Greyscale')
image = api.RenderImage()
channel_img = image1.GetImage().getchannel(channel)
if greyscale != True and channel != "A":
if channel == "R":
color = (255, 0, 0)
elif channel == "G":
color = (0, 255, 0)
elif channel == "B":
color = (0, 0, 255)
final_img = ImageOps.colorize(channel_img, (0, 0, 0), color)
elif channel == "A":
inverted_img = ImageChops.invert(channel_img)
new_img = Image.new("RGBA", inverted_img.size, (0, 0, 0, 0))
layer_image = ImageOps.fit(new_img, inverted_img.size)
mask_image = ImageOps.fit(image1.GetImage(), inverted_img.size)
final_img = Image.composite(inverted_img, layer_image, mask_image)
else:
final_img = channel_img
image.SetAsImage(final_img.convert("RGBA"))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
kernel_size = eval_info.EvaluateProperty('Kernel Size')
kernel_x = eval_info.EvaluateProperty('Kernel X')
kernel_y = eval_info.EvaluateProperty('Kernel Y')
filter_type = eval_info.EvaluateProperty('Filter Type')
image = api.RenderImage()
img = ArrayFromImage(image1.GetImage())
img = img.copy(order='C')
ctx = moderngl.create_standalone_context()
texture = ctx.texture(img.shape[1::-1], img.shape[2], img)
window_size = 3840 // 2, 2160 // 2
image_processing = ImageTransformer(ctx, window_size)
# Headless
image_processing.render(texture)
output_img = image_processing.write()
image.SetAsImage(ArrayToImage(output_img).convert('RGBA'))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
distance = eval_info.EvaluateProperty('Distance')
image = api.RenderImage()
image.SetAsImage(image1.GetImage().effect_spread(distance))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
color = eval_info.EvaluateProperty('Color')
imgsize = eval_info.EvaluateProperty('Size')
image = api.RenderImage()
image.SetAsImage(Image.new("RGBA", (imgsize[0], imgsize[1]), color))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
main_image = eval_info.EvaluateParameter('Image')
text_pos = eval_info.EvaluateProperty('Text Position')
text = eval_info.EvaluateProperty('Text')
font = eval_info.EvaluateProperty('Font')
font_size = eval_info.EvaluateProperty('Font Size')
font_color = eval_info.EvaluateProperty('Font Color')
image = api.RenderImage()
# Create separate image so it doesn't draw on the original image
text_image = Image.new("RGBA",
size=main_image.GetImage().size,
color=(0, 0, 0, 1))
#draw = ImageDraw.Draw(text_image)
print("before font")
# # Load the font
# if sys.platform == "win32":
# font_path_prefix = "C:/Windows/Fonts/"
# elif sys.platform == "linux":
# font_path_prefix = "/usr/share/fonts/TTF/"
# else:
# print("WARNING: The text node does not currently support your operating system")
# return
# font_path = font_path_prefix + font + ".ttf"
#fnt = ImageFont.truetype("arial", font_size)
# print("after")
# TODO: Add support for all parameters from ImageDraw.Draw.text
# Todo: Add support for multiline text
#draw.multiline_text(text_pos, text, font=fnt, fill=font_color)
print(font_size, "size")
draw_text = ImageDraw.Draw(text_image)
text_font = ImageFont.truetype(font="C:/Windows/Fonts/arial.ttf",
size=30)
# Draw the text
draw_text.text(xy=(0, 0),
text="text",
font=text_font,
fill="black",
spacing=6,
align='left',
stroke_width=1,
stroke_fill="blue")
# Composite the two images together
composited_image = Image.alpha_composite(main_image.GetImage(),
text_image)
image.SetAsImage(composited_image)
self.NodeSetThumb(image.GetImage())
print("yes-past")
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
amount = eval_info.EvaluateProperty('Amount')
image = api.RenderImage()
enhancer = ImageEnhance.Color(image1.GetImage())
image.SetAsImage(enhancer.enhance(amount).convert('RGBA'))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
sigma = eval_info.EvaluateProperty('Sigma')
imgsize = eval_info.EvaluateProperty('Size')
image = api.RenderImage()
image.SetAsImage(
Image.effect_noise((imgsize[0], imgsize[1]),
sigma).convert("RGBA"))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image 1')
image2 = eval_info.EvaluateParameter('Image 2')
image = api.RenderImage()
main_image = image1.GetImage()
layer_image = ImageOps.fit(image2.GetImage(), main_image.size)
image.SetAsImage(Image.alpha_composite(main_image, layer_image))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
radius = eval_info.EvaluateProperty('Radius')
image = api.RenderImage()
image.SetAsImage(image1.GetImage().filter(
ImageFilter.GaussianBlur(radius)
).convert('RGBA'))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
layer = eval_info.EvaluateProperty('Layer')
layer_path = self._layers[layer]
image = api.RenderImage()
image.SetAsOpenedImage(layer_path)
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
direction = eval_info.EvaluateProperty('Direction')
image = api.RenderImage()
if direction == 'Horizontal':
image.SetAsImage(ImageOps.mirror(image1.GetImage()))
else:
image.SetAsImage(ImageOps.flip(image1.GetImage()))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
image2 = eval_info.EvaluateParameter('Overlay')
blendmode = eval_info.EvaluateProperty('Blend Mode')
image = api.RenderImage()
main_image = image1.GetImage()
layer_image = ImageOps.fit(image2.GetImage(), main_image.size)
if blendmode == 'Add':
img = ImageChops.add(main_image, layer_image)
elif blendmode == 'Add Modulo':
img = ImageChops.add_modulo(main_image, layer_image)
elif blendmode == 'Subtract':
img = ImageChops.subtract(main_image, layer_image)
elif blendmode == 'Subtract Modulo':
img = ImageChops.subtract_modulo(main_image, layer_image)
elif blendmode == 'Multiply':
img = ImageChops.multiply(main_image, layer_image)
elif blendmode == 'Screen':
img = ImageChops.screen(main_image, layer_image)
elif blendmode == 'Difference':
img = ImageChops.difference(main_image, layer_image)
elif blendmode == 'Darker':
img = ImageChops.darker(main_image, layer_image)
elif blendmode == 'Lighter':
img = ImageChops.lighter(main_image, layer_image)
elif blendmode == 'Soft Light':
img = ImageChops.soft_light(main_image, layer_image)
elif blendmode == 'Hard Light':
img = ImageChops.hard_light(main_image, layer_image)
elif blendmode == 'Overlay':
img = ImageChops.overlay(main_image, layer_image)
image.SetAsImage(img)
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
gradient = 0.5 # eval_info.EvaluateProperty('Gradient')
color1 = eval_info.EvaluateProperty('Color 1')
color2 = eval_info.EvaluateProperty('Color 2')
imgsize = eval_info.EvaluateProperty('Size')
gradientimage = Image.new("L", (imgsize[0], 1))
for x in range(imgsize[0]):
gradientimage.putpixel(
(x, 0),
int(225. * (1. - float(gradient) * float(x) / imgsize[0])))
gradient_image = ImageOps.colorize(
gradientimage.resize((imgsize[0], imgsize[1])), color1, color2)
image = api.RenderImage()
image.SetAsImage(gradient_image.convert('RGBA'))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
saturation_val = eval_info.EvaluateProperty('Saturation')
brightness_val = eval_info.EvaluateProperty('Brightness')
gamma_val = eval_info.EvaluateProperty('Gamma')
# Convert the current image data to an array
# that we can use and greyscale it.
im = ArrayFromImage(image1.GetImage())
gray_scale_img = cv2.equalizeHist(cv2.cvtColor(im, cv2.COLOR_BGR2GRAY))
generated_roughness_map = self.ComputeRoughnessMap(
gray_scale_img, saturation_val, brightness_val, gamma_val)
image = api.RenderImage()
image.SetAsImage(ArrayToImage(generated_roughness_map).convert('RGBA'))
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
main_image = eval_info.EvaluateParameter('Image')
text_pos = eval_info.EvaluateProperty('Text Position')
text = eval_info.EvaluateProperty('Text')
font = eval_info.EvaluateProperty('Font')
font_size = eval_info.EvaluateProperty('Font Size')
font_color = eval_info.EvaluateProperty('Font Color')
image = api.RenderImage()
# Create separate image so it doesn't draw on the original image
text_image = Image.new("RGBA",
size=main_image.GetImage().size,
color=(0, 0, 0, 1))
draw = ImageDraw.Draw(text_image)
# Load the font
if sys.platform == "win32":
font_path_prefix = "C:/Windows/Fonts/"
elif sys.platform == "linux":
font_path_prefix = "/usr/share/fonts/TTF/"
else:
print(
"WARNING: The text node does not currently support your operating system"
)
return
font_path = font_path_prefix + font + ".ttf"
fnt = ImageFont.truetype(font_path, font_size)
# TODO: Add support for all parameters from ImageDraw.Draw.text
# Todo: Add support for multiline text
draw.text(text_pos, text, font=fnt, fill=font_color)
# Composite the two images together
composited_image = Image.alpha_composite(main_image.GetImage(),
text_image)
image.SetAsImage(composited_image)
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
opacity = eval_info.EvaluateProperty('Opacity')
img = image1.GetImage().convert("RGBA")
# Make correction for slider range of 1-100
image_opacity = (opacity * 0.01)
# Only reduce the opacity if the value is acceptable
if not image_opacity < 0 or not image_opacity > 1:
alpha = ImageEnhance.Brightness(
img.split()[-1]).enhance(image_opacity)
img.putalpha(alpha)
image = api.RenderImage()
image.SetAsImage(img)
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
# TODO: Add a circle crop option
input_image = eval_info.EvaluateParameter('Image')
method = eval_info.EvaluateProperty("Method")
# Rectangle
x = eval_info.EvaluateProperty("X")
y = eval_info.EvaluateProperty("Y")
width = eval_info.EvaluateProperty("Width")
height = eval_info.EvaluateProperty("Height")
# Circle
center = eval_info.EvaluateProperty("Center")
radius = eval_info.EvaluateProperty("Radius")
input_image_array = ArrayFromImage(input_image.GetImage())
if method == "Rectangle":
output_image_array = input_image_array[y:y + height, x:x + width]
else:
# Create a blank mask
mask = np.zeros(shape=input_image_array.data.shape, dtype=np.uint8)
# Create the circle
circle_mask_colour = cv2.circle(mask, tuple(center), radius,
(255, 255, 255), -1)
# Convert the mask to gray scale
circle_mask = cv2.cvtColor(circle_mask_colour, cv2.COLOR_BGR2GRAY)
# Combine the mask and image
cropped_img = cv2.bitwise_and(input_image_array,
input_image_array,
mask=circle_mask)
# Crop the circle
circle_rect = cropped_img[center[1] - radius:center[1] + radius,
center[0] - radius:center[0] + radius]
output_image_array = circle_rect
image = api.RenderImage()
image.SetAsImage(ArrayToImage(output_image_array).convert("RGBA"))
self.NodeSetThumb(image.GetImage().convert("RGBA"))
return image
def NodeEvaluation(self, eval_info):
input_image = eval_info.EvaluateParameter("Image")
method = eval_info.EvaluateProperty("Method")
lower_threshold = eval_info.EvaluateProperty("Lower Threshold")
higher_threshold = eval_info.EvaluateProperty("Higher Threshold")
image = api.RenderImage()
# Consider removing the Pillow method?
if method == "Find Edges":
img = input_image.GetImage().convert("L").filter(
ImageFilter.FIND_EDGES)
image.SetAsImage(img.convert("RGBA"))
elif method == "Canny":
input_image_array = ArrayFromImage(input_image.GetImage())
output_image_array = cv2.Canny(input_image_array, lower_threshold,
higher_threshold)
image.SetAsImage(ArrayToImage(output_image_array).convert("RGBA"))
else:
image.SetAsImage(input_image.GetImage())
self.NodeSetThumb(image.GetImage())
return image
def NodeEvaluation(self, eval_info):
image1 = eval_info.EvaluateParameter('Image')
kernel_shape = eval_info.EvaluateProperty('Kernel Shape')
kernel_size = eval_info.EvaluateProperty('Kernel Size')
operation = eval_info.EvaluateProperty('Operation')
image = api.RenderImage()
img = ArrayFromImage(image1.GetImage())
if kernel_shape == "Rectangle":
kshape = cv2.MORPH_RECT
elif kernel_shape == "Ellipse":
kshape = cv2.MORPH_ELLIPSE
elif kernel_shape == "Cross":
kshape = cv2.MORPH_CROSS
kernel_img = cv2.getStructuringElement(kshape,
(kernel_size, kernel_size))
if operation == "Erode":
output_img = cv2.erode(img, kernel_img, iterations=1)
elif operation == "Dilate":
output_img = cv2.dilate(img, kernel_img, iterations=1)
elif operation == "Opening":
output_img = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel_img)
elif operation == "Closing":
output_img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel_img)
elif operation == "Top Hat":
output_img = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel_img)
elif operation == "Black Hat":
output_img = cv2.morphologyEx(img, cv2.MORPH_BLACKHAT, kernel_img)
image.SetAsImage(ArrayToImage(output_img).convert("RGBA"))
self.NodeSetThumb(image.GetImage())
return image
