def prepare_tts(img, _, output_folder): # pylint: disable=R0914
""" Prepare a TTS sheet image.
"""
gimp.progress_init('Prepare a TTS sheet image...')
pdb.gimp_undo_push_group_start(img)
try:
file_name, _ = _get_filename_backside(img, 'jpg')
except Exception: # pylint: disable=W0703
pdb.gimp_undo_push_group_end(img)
return
parts = file_name.split('_')
num = int(parts[-3])
rows = int(parts[-4])
columns = int(parts[-5])
new_width = columns * 750
new_height = rows * 1050
pdb.gimp_image_scale(img, new_width, new_height)
json_path = re.sub(r'\.jpg$', '.json', pdb.gimp_image_get_filename(img))
try:
with open(json_path, 'r') as fobj:
cards = json.load(fobj)
except Exception: # pylint: disable=W0703
pdb.gimp_undo_push_group_end(img)
return
cards = [c['path'] for c in cards]
if len(cards) != num:
pdb.gimp_undo_push_group_end(img)
return
card_rows = [
cards[i * columns:(i + 1) * columns]
for i in range((len(cards) + columns - 1) // columns)
]
if len(card_rows) != rows:
pdb.gimp_undo_push_group_end(img)
return
for i, card_row in enumerate(card_rows):
for j, card_path in enumerate(card_row):
if not os.path.exists(card_path):
pdb.gimp_undo_push_group_end(img)
return
card_layer = pdb.gimp_file_load_layer(img, card_path)
pdb.gimp_image_insert_layer(img, card_layer, None, -1)
rotation = _get_rotation(card_layer)
if rotation:
_rotate(card_layer, True)
pdb.gimp_layer_set_offsets(card_layer, j * 750, i * 1050)
pdb.gimp_image_merge_down(img, card_layer, 1)
pdb.file_jpeg_save(img, img.layers[0],
os.path.join(output_folder, file_name), file_name, 1, 0,
1, 0, '', 2, 1, 0, 0)
pdb.gimp_undo_push_group_end(img)
def load_caches(args):
inColorFondR, inColorFondG, inColorFondB, outDir = args.split(" ")
inDir, inNameLayerFleche = GRAPH_PATH + "layers/", "layer_fleche-1.png"
inColorFondR, inColorFondG, inColorFondB = int(inColorFondR), int(
inColorFondG), int(inColorFondB)
nb, listimg = pdb.file_glob(inDir + "*.png", 1)
baseimage = pdb.gimp_image_new(10, 10, RGB)
fondcolor = (inColorFondR, inColorFondG, inColorFondB)
for filename in listimg:
layer = pdb.gimp_file_load_layer(baseimage, filename)
pdb.gimp_image_insert_layer(baseimage, layer, None, 0)
pdb.gimp_image_resize_to_layers(baseimage)
pdb.gimp_message("Layers chargés")
pdb.gimp_selection_all(baseimage)
layerfond = pdb.gimp_image_get_layers(baseimage)[1][0]
layerfond = gimp.Item.from_id(layerfond)
fond = pdb.gimp_layer_copy(layerfond, 1)
_, _, _, xmax, ymax = pdb.gimp_selection_bounds(baseimage)
pdb.gimp_item_set_name(fond, "layer_fond.png")
pdb.gimp_image_insert_layer(baseimage, fond, None, 0)
pdb.gimp_edit_clear(fond)
pdb.gimp_image_select_round_rectangle(baseimage, CHANNEL_OP_REPLACE, 0, 0,
xmax, ymax, 35, 35)
pdb.gimp_selection_shrink(baseimage, 3)
pdb.gimp_selection_feather(baseimage, 20)
pdb.gimp_context_set_foreground(fondcolor)
pdb.gimp_edit_fill(fond, FILL_FOREGROUND)
pdb.gimp_image_lower_item_to_bottom(baseimage, fond)
pdb.plug_in_hsv_noise(baseimage, fond, 5, 38, 63, 74)
pdb.gimp_selection_none(baseimage)
pdb.gimp_message("Fond créé")
caches(baseimage, inNameLayerFleche, "layer_fond.png")
pdb.gimp_message("Cache créé")
layercache = pdb.gimp_image_get_layer_by_name(baseimage, "cache.png")
layerfond = pdb.gimp_image_get_layer_by_name(baseimage, "layer_fond.png")
layerfleche = pdb.gimp_image_get_layer_by_name(baseimage,
inNameLayerFleche)
pdb.gimp_item_set_visible(layerfond, True)
pdb.gimp_image_merge_down(baseimage, layercache, CLIP_TO_IMAGE)
pdb.gimp_item_set_visible(layerfleche, True)
pdb.gimp_image_merge_down(baseimage, layerfleche, CLIP_TO_IMAGE)
pdb.gimp_image_scale(baseimage, 900, 550)
# drawable = pdb.gimp_image_get_active_drawable(baseimage)
pdb.script_fu_multiple_layer_actions(baseimage, None, 0, 0, (0, 0, 0), 4,
0, 0, 0, 0, 0)
pdb.gimp_message("Taille de l'image ajustée")
pdb.script_fu_export_layers(baseimage, None, outDir, "~l")
pdb.gimp_message("Layers enregistrés")
def put_text(text, left, right, top, bottom):
"""Puts some text in the center of a rectangle."""
pdb.gimp_progress_pulse()
text_size = DPI / 4 # type: int
text_layer = pdb.gimp_text_layer_new(
image, text, "sans-serif", text_size,
gimpfu.PIXELS) # type: gimp.Layer
image.add_layer(text_layer, 0)
move_drawable_to(text_layer, Corner.CENTER,
(left + right) // 2, (top + bottom) // 2)
pdb.gimp_image_merge_down(image, text_layer,
gimpfu.CLIP_TO_BOTTOM_LAYER)
def cree_background(inLayer, inLayerF, Img):
"""Add background to inLayer"""
newlayer = pdb.gimp_layer_copy(inLayer, True)
newfond = pdb.gimp_layer_copy(inLayerF, True)
layername = pdb.gimp_item_get_name(inLayer)
pdb.gimp_item_set_visible(newlayer, True)
pdb.gimp_image_insert_layer(Img, newlayer, None, 0)
pdb.gimp_image_set_active_layer(Img, inLayer)
pdb.gimp_image_insert_layer(Img, newfond, None, -1)
pdb.gimp_image_lower_item(Img, newfond)
pdb.gimp_item_set_visible(newfond, 1)
pdb.gimp_context_set_sample_transparent(True)
pdb.gimp_image_select_contiguous_color(Img, CHANNEL_OP_REPLACE, newlayer,
10, 10)
pdb.gimp_edit_clear(newfond)
pdb.gimp_item_set_visible(inLayer, True)
clipped_layer = pdb.gimp_image_merge_down(Img, inLayer, CLIP_TO_IMAGE)
pdb.gimp_item_set_name(clipped_layer, layername)
pdb.gimp_selection_invert(Img)
pdb.gimp_context_set_foreground((117, 117, 154))
pdb.gimp_edit_fill(newlayer, FILL_FOREGROUND)
floating_sel = pdb.gimp_edit_paste(newlayer, 0)
pdb.gimp_layer_set_opacity(floating_sel, 70)
pdb.gimp_floating_sel_anchor(floating_sel)
pdb.gimp_layer_set_opacity(newlayer, 85)
pdb.gimp_selection_none(Img)
layerfinal = pdb.gimp_image_get_layer_by_name(Img, layername)
pdb.gimp_item_set_visible(layerfinal, False)
def add_black_outline(image, drawable, original_layer_position, width, height,
offx, offy):
# make selection bigger
steps = 3
pdb.gimp_selection_grow(image, steps)
# create new layer
type = RGBA_IMAGE
name = "text background"
opacity = 100
mode = NORMAL_MODE
layer_textbg = pdb.gimp_layer_new(image, width, height, type, name,
opacity, mode)
position = original_layer_position + 1
pdb.gimp_image_add_layer(image, layer_textbg, position)
#offset new layer by info
pdb.gimp_layer_set_offsets(layer_textbg, offx, offy)
# select layer
image.active_layer = layer_textbg
# set FG Color to black
foreground = (0, 0, 0)
pdb.gimp_context_set_foreground(foreground)
# fill selection with black
fill_mode = FG_BUCKET_FILL
paint_mode = NORMAL_MODE
opacity = 100
threshold = 0
sample_merged = 0
x = 0
y = 0
pdb.gimp_bucket_fill(layer_textbg, fill_mode, paint_mode, opacity,
threshold, sample_merged, x, y)
# select the text layer and merge it to the black outline
merge_layer = image.layers[original_layer_position]
merge_type = EXPAND_AS_NECESSARY
layer = pdb.gimp_image_merge_down(image, merge_layer, merge_type)
return layer
def python_text_border(image, drawable, thickness=5, colour=(0, 0, 0)):
"""The plugin's main function."""
text_layer = image.active_layer
layer_name = text_layer.name
pdb.gimp_image_select_item(image, 2, text_layer)
pdb.gimp_selection_grow(image, thickness)
border_layer = gimp.Layer(
image, 'border', image.width, image.height, gimpfu.RGBA_IMAGE, 100,
gimpfu.NORMAL_MODE)
position = pdb.gimp_image_get_layer_position(image, text_layer)
image.add_layer(border_layer, position + 1)
old_fg = gimp.get_foreground()
gimp.set_foreground(colour)
pdb.gimp_edit_fill(border_layer, gimpfu.FOREGROUND_FILL)
gimp.set_foreground(old_fg)
layer = pdb.gimp_image_merge_down(image, text_layer, 0)
pdb.gimp_layer_set_name(layer, layer_name)
def stickerify_bordure(image, current_layer, black_grow=3, white_grow=12, shadow=True, canvas_increase=0, resize=False):
def duplicate_layer():
copy = current_layer.copy()
image.add_layer(copy)
# copy is added above so we want to go down a bit
image.active_layer = current_layer
return copy
def fill_black():
pdb.gimp_edit_bucket_fill(current_layer, 1, 0, 100, 255, 0, 0, 0)
def fill_white():
pdb.gimp_edit_bucket_fill(current_layer, 0, 0, 100, 255, 0, 0, 0)
def set_colors():
pdb.gimp_context_set_foreground((255, 255, 255))
pdb.gimp_context_set_background((0, 0, 0))
pdb.gimp_context_push()
pdb.gimp_image_undo_group_start(image)
# clean selection to avoid bugs
pdb.gimp_selection_none(image)
set_colors()
# resize early to avoid compressing the bordure
if resize:
width, height = image.width, image.height
if width == height:
new_width, new_height = 512, 512
elif width > height:
new_width, new_height = 512, int(height * (512.0 / width))
elif width < height:
new_width, new_height = int(width * (512.0 / height)), 512
pdb.gimp_image_scale(image, new_width, new_height)
if canvas_increase:
width, height = image.width, image.height
width_increase = int(width * (canvas_increase / 100))
height_increase = int(height * (canvas_increase / 100))
pdb.gimp_image_resize(image,
width + width_increase,
height + height_increase,
int(width_increase / 2),
int(height_increase / 2))
pdb.gimp_layer_resize_to_image_size(current_layer)
duplicate_layer()
# alpha to selection
pdb.gimp_image_select_item(image, 0, current_layer)
pdb.gimp_selection_grow(image, black_grow)
fill_black()
second_layer = duplicate_layer()
pdb.gimp_selection_grow(image, white_grow)
fill_white()
if shadow:
duplicate_layer()
fill_black()
current_layer.translate(8, 8)
pdb.gimp_selection_all(image)
pdb.plug_in_gauss(image, current_layer, 20, 20, 0)
pdb.gimp_layer_set_opacity(current_layer, 70)
pdb.gimp_image_merge_down(image, second_layer, 0)
if shadow:
pdb.gimp_image_merge_down(image, image.active_layer, 0)
pdb.gimp_layer_set_name(image.active_layer, "Sticker bordure")
pdb.gimp_selection_none(image)
pdb.gimp_image_undo_group_end(image)
pdb.gimp_context_pop()
pdb.gimp_displays_flush()
def stickerify_bordure(image,
tdrawable,
black_grow=3,
white_grow=12,
shadow=True):
def duplicate_layer():
copy = current_layer.copy()
image.add_layer(copy)
# copy is added above so we want to go down a bit
image.active_layer = current_layer
return copy
def fill_black():
pdb.gimp_edit_bucket_fill(current_layer, 1, 0, 100, 255, 0, 0, 0)
def fill_white():
pdb.gimp_edit_bucket_fill(current_layer, 0, 0, 100, 255, 0, 0, 0)
def set_colors():
pass
pdb.gimp_context_push()
pdb.gimp_image_undo_group_start(image)
pdb.gimp_context_set_foreground((255, 255, 255))
pdb.gimp_context_set_background((0, 0, 0))
set_colors()
current_layer = image.active_layer
duplicate_layer()
# alpha to selection
pdb.gimp_image_select_item(image, 0, current_layer)
pdb.gimp_selection_grow(image, black_grow)
fill_black()
second_layer = duplicate_layer()
pdb.gimp_selection_grow(image, white_grow)
fill_white()
if shadow:
duplicate_layer()
fill_black()
current_layer.translate(8, 8)
pdb.gimp_selection_all(image)
pdb.plug_in_gauss(image, current_layer, 20, 20, 0)
pdb.gimp_layer_set_opacity(current_layer, 70)
pdb.gimp_image_merge_down(image, second_layer, 0)
if shadow:
pdb.gimp_image_merge_down(image, image.active_layer, 0)
pdb.gimp_image_undo_group_end(image)
pdb.gimp_context_pop()
pdb.gimp_displays_flush()