def apply_stroke():
global stroke_done, opacity_done, stroke_initial_color
if opacity_done:
image.undo()
opacity_done = False
if stroke_done:
image.undo()
stroke_done = False
image.do_begin()
if chosen_radius > 0.5:
layer.duplicate()
disk_id = layer.get_id()
filters.blur(name=filters.BLUR_DISK, radius=chosen_radius-0.5)
filters.filter_function(red=overlay_color.red/255, green=overlay_color.green/255, blue=overlay_color.blue/255, alpha="min(alpha*"+str(chosen_radius*5)+",(1-alpha)*"+str(chosen_radius*5)+")", gamma_correction=False)
layer.select_id(stroke_layer_id)
else:
disk_id = None
filters.blur(name=filters.BLUR_CORONA, radius=chosen_radius+0.5)
filters.filter_function(red=overlay_color.red/255, green=overlay_color.green/255, blue=overlay_color.blue/255, alpha="min(alpha*"+str(chosen_radius)+",(1-alpha)*"+str(chosen_radius)+")", gamma_correction=False)
if disk_id is not None:
layer.select_id(disk_id)
layer.merge_over()
layer.set_registry("overlay-color", overlay_color)
stroke_initial_color = overlay_color
stroke_done = image.do_end()
apply_opacity()
def button_ok_click():
global source_layer_id, chosen_radius, chosen_offset
layer.select_id(source_layer_id)
layer.set_registry("stroke-radius", chosen_radius)
layer.set_registry("stroke-layer-id", stroke_layer_id)
image.set_registry("stroke-radius", chosen_radius)
image.do_end()
exit()
def button_ok_click():
global source_layer_id, chosen_radius, chosen_angle
layer.select_id(source_layer_id)
layer.set_registry(REGISTRY_NAME + "-radius", chosen_radius)
layer.set_registry(REGISTRY_NAME + "-angle", chosen_angle)
layer.set_registry(REGISTRY_NAME + "-layer-id", shadow_layer_id)
image.set_registry(REGISTRY_NAME + "-radius", chosen_radius)
image.set_registry(REGISTRY_NAME + "-angle", chosen_angle)
image.do_end()
exit()
def create_shadow_layer():
global shadow_layer_id
image.do_begin()
if shadow_layer_id != None:
layer.select_id(shadow_layer_id)
layer.remove()
layer.select_id(source_layer_id)
layer.duplicate()
layer.rasterize()
layer.set_name(FRIENDLY_NAME + " of " + source_layer_name)
layer.set_registry(REGISTRY_NAME + "-source-layer-id", source_layer_id)
shadow_layer_id = layer.get_id()
layer.set_registry("overlay-color", overlay_color)
layer.set_opacity(chosen_opacity)
image.do_end()
def create_shadow_layer():
global shadow_layer_id
image.do_begin()
if shadow_layer_id != None:
layer.select_id(shadow_layer_id)
layer.remove()
layer.select_id(source_layer_id)
layer.duplicate()
layer.set_name(FRIENDLY_NAME + " - " + source_layer_name)
layer.set_registry("shadow-source-layer-id", source_layer_id)
shadow_layer_id = layer.get_id()
shadow_index = image.get_layer_index()
image.move_layer_index(shadow_index, shadow_index - 1)
filters.filter_function(red=overlay_color.red / 255,
green=overlay_color.green / 255,
blue=overlay_color.blue / 255,
gamma_correction=False)
layer.set_registry("overlay-color", overlay_color)
layer.set_opacity(chosen_opacity)
image.do_end()
def apply_blur():
global blur_done, opacity_done
if opacity_done:
image.undo()
opacity_done = False
if blur_done:
image.undo()
blur_done = False
image.do_begin()
if chosen_radius == 0:
filters.filter_function(alpha=0, gamma_correction=False)
else:
layer.duplicate()
layer.set_opacity(255)
filters.filter_function(red="alpha",
green="alpha",
blue="alpha",
alpha=1,
gamma_correction=False)
mask_layer_id = layer.get_id()
layer.select_id(shadow_layer_id)
filters.filter_function(red=overlay_color.red / 255,
green=overlay_color.green / 255,
blue=overlay_color.blue / 255,
gamma_correction=False)
tools.choose(tools.MOVE_LAYER)
offset = (math.sin(chosen_angle * math.pi / 180) * chosen_radius,
-math.cos(chosen_angle * math.pi / 180) * chosen_radius)
tools.mouse([(0, 0), (offset[0], offset[1])])
layer.select_id(mask_layer_id)
layer.duplicate()
mask_layer_id2 = layer.get_id()
layer.select_id(mask_layer_id)
tools.choose(tools.MOVE_LAYER)
tools.mouse([(offset[0] / 2, offset[1] / 2), (0, 0)])
colors.linear_negative()
layer.set_blend_op(layer.BLEND_MASK)
layer.merge_over()
mask_layer_id = mask_layer_id2
filters.blur(radius=chosen_radius)
layer.select_id(mask_layer_id)
layer.set_blend_op(layer.BLEND_MASK)
layer.merge_over()
blur_done = image.do_end()
apply_opacity()
def create_stroke_layer():
global stroke_layer_id
image.do_begin()
if stroke_layer_id != None:
layer.select_id(stroke_layer_id)
stroke_index = image.get_layer_index()
selection.select_all()
selection.delete()
layer.select_id(source_layer_id)
layer.duplicate()
image.move_layer_index(image.get_layer_index(), stroke_index+1)
layer.merge_over()
else:
layer.select_id(source_layer_id)
layer.duplicate()
layer.set_name("Stroke of "+source_layer_name)
layer.set_registry("stroke-source-layer-id", source_layer_id)
stroke_layer_id = layer.get_id()
stroke_index = image.get_layer_index()
image.move_layer_index(stroke_index, stroke_index-1)
image.do_end()
"alpha": "255",
"blend": layer.BLEND_HARD_LIGHT
})
channels.append({
"name": "Hue",
"channel": "H",
"hue": "hue",
"saturation": "1",
"lightness": "0.5",
"alpha": "255",
"blend": layer.BLEND_DRAW
})
channels_id = []
for ch in channels:
layer.select_id(layer_id)
layer.duplicate()
filters.filter_function(hue=ch["hue"],
saturation=ch["saturation"],
lightness=ch["lightness"],
alpha=ch["alpha"],
gamma_correction=False)
layer.set_name(ch["name"] + " channel")
layer.set_opacity(layer_opacity)
if ch["channel"] != channels[-1]:
layer.set_blend_op(ch["blend"])
layer.set_registry("split-channel", ch["channel"])
layer.set_registry("split-source-id", layer_id)
channels_id.append(layer.get_id())
layer.select_id(layer_id)
def button_cancel_click():
if image.do_end():
image.undo()
layer.select_id(source_layer_id)
exit()
translation = dict(zip(english, dialog.translate_text(english)))
if layer.is_empty():
dialog.show_message(translation["Layer is empty"])
exit()
############ image processing
FRIENDLY_NAME = dialog.get_script_name()
MAX_RADIUS = 100
MAX_OFFSET = 100
MAX_OPACITY = 255
source_layer_id = layer.get_registry("shadow-source-layer-id")
if source_layer_id is not None:
layer.select_id(source_layer_id)
else:
source_layer_id = layer.get_id()
source_layer_name = layer.get_name()
chosen_radius = layer.get_registry("shadow-radius")
if chosen_radius == None:
chosen_radius = image.get_registry("shadow-radius")
if chosen_radius == None:
chosen_radius = 10
chosen_offset = layer.get_registry("shadow-offset")
if chosen_offset == None or len(chosen_offset) != 2:
chosen_offset = image.get_registry("shadow-offset")
if chosen_offset == None or len(chosen_offset) != 2:
chosen_offset = (10, 10)
# Merge RGB channels
from lazpaint import image, dialog, layer
try:
from PIL import Image
except ImportError:
dialog.show_message("Please install Pillow for Python.")
exit()
channels_id = None
image.do_begin()
if layer.get_registry("split-channel") is not None:
layer_id = layer.get_registry("split-source-id")
if image.contains_layer_id(layer_id):
layer.select_id(layer_id)
channels_id = layer.get_registry("split-channels-id")
else:
channels_id = []
for i in range(1, image.get_layer_count() + 1):
image.select_layer_index(i)
cur_layer_id = layer.get_registry("split-source-id")
if cur_layer_id == layer_id:
channels_id.append(layer.get_id())
else:
layer_id = layer.get_id()
channels_id = layer.get_registry("split-channels-id")
if channels_id is None:
dialog.show_message("Current layer is not split")
exit()
source_layer_id = layer.get_id()
source_layer_name = layer.get_name()
chosen_radius = layer.get_registry("stroke-radius")
if chosen_radius == None:
chosen_radius = image.get_registry("stroke-radius")
if chosen_radius == None:
chosen_radius = 10
stroke_layer_id = layer.get_registry("stroke-layer-id")
if image.get_layer_index(stroke_layer_id) == None:
stroke_layer_id = None
if stroke_layer_id is not None:
layer.select_id(stroke_layer_id)
chosen_opacity = layer.get_opacity()
overlay_color = colors.str_to_RGBA(layer.get_registry("overlay-color"))
layer.select_id(source_layer_id)
else:
chosen_opacity = layer.get_opacity()
overlay_color = None
if overlay_color is None:
overlay_color = colors.BLACK
def create_stroke_layer():
global stroke_layer_id
image.do_begin()
if stroke_layer_id != None:
layer.select_id(stroke_layer_id)
def iterate_layers():
prev_id = layer.get_id()
for layer_id in get_all_layers_id():
layer.select_id(layer_id)
yield layer_id
layer.select_id(prev_id)
