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 clear_background(image, drawable):
# invert selection, thus selecting the background
pdb.gimp_selection_invert(image)
# clear background
pdb.gimp_edit_clear(drawable)
# invert selection
pdb.gimp_selection_invert(image)
def cookie_cutter_letter(img, substrate, right, font, letter):
'''Cut text shaped like letter out of the given layer.'''
temp_layer = gpdb.gimp_text_fontname(img, substrate, right, 0, letter, 1,
False, FONT_HEIGHT, PIXELS, font)
gpdb.gimp_selection_layer_alpha(temp_layer)
angle = random.uniform(*ANGLE_RANGE)
xaxis = right
yaxis = 15
# srcX = float(xaxis)
# dstX = float(srcX + random.uniform(0, 25))
# srcY = float(yaxis)
# dstY = float(srcY + random.uniform(0, 25))
# scaleX = scaleY = float(100)
# We need to save the selection as a channel so we can mess with
# the letter form.
shape = gpdb.gimp_selection_save(img)
gpdb.gimp_selection_none(img)
gpdb.gimp_floating_sel_remove(temp_layer)
# Distort the form of the individual letter:
shape = gpdb.gimp_item_transform_rotate(shape, angle, 0, xaxis, yaxis)
# We aren't doing any letter warping now, but if we were, this is the
# point where it should be done. We want to warp the shape of textLayer,
# which later serves as a cutout for the dark noise layer. If we warp the
# dark noise layer directly we will end up with warped dots.
#
# gpdb.gimp_context_set_transform_resize(TRANSFORM_RESIZE_CROP)
# shape = gpdb.gimp_item_transform_2d(shape, srcX, srcY, angle,
# scaleX, scaleY, dstX, dstY)
gpdb.gimp_selection_load(shape)
img.remove_channel(shape)
# Note the bounding box of the letter form so we can figure out
# where the next one should go.
bounds = gpdb.gimp_selection_bounds(img)
new_right = bounds[3] + LETTER_SPACING
# Actually cut the letter form out of the substate.
gpdb.gimp_selection_invert(img)
gpdb.gimp_edit_clear(substrate)
gpdb.gimp_selection_none(img)
return new_right
def change_num(image, inNumero):
layer = pdb.gimp_image_get_active_layer(image)
pdb.gimp_context_set_sample_transparent(True)
pdb.gimp_image_select_contiguous_color(image, CHANNEL_OP_REPLACE,layer, 1, 1)
pdb.gimp_selection_invert(image)
_, x, y, x2, y2 = pdb.gimp_selection_bounds(image)
xthird=x + ((x2 - x) // 4 * 3)
y = _find_black_not_transparent(image, layer, xthird, y)
pdb.gimp_context_set_sample_transparent(False)
pdb.gimp_image_select_contiguous_color(image, CHANNEL_OP_REPLACE, layer, xthird, y)
pdb.gimp_edit_clear(layer)
if inNumero > 1:
_, x, y, x2, y2 = pdb.gimp_selection_bounds(image)
ymiddle = y + ( (y2 - y) // 2)
keep = True
while keep:
if not _is_transparent(image, layer, x, ymiddle):
keep = False
pdb.gimp_context_set_sample_transparent(False)
pdb.gimp_context_set_sample_threshold(1)
pdb.gimp_image_select_contiguous_color(image, CHANNEL_OP_REPLACE, layer, x+1, ymiddle)
pdb.gimp_context_set_sample_threshold(0.1)
x += 1
pdb.gimp_edit_clear(layer)
_, x1, y1, x2, y2 = pdb.gimp_selection_bounds(image)
pdb.gimp_image_select_rectangle(image, CHANNEL_OP_REPLACE, x1, y1, x2-x1, y2-y1)
filename = GRAPH_PATH + str(inNumero) + ".png"
imagechiffre = pdb.gimp_file_load(filename, filename)
layerchiffre = pdb.gimp_image_get_active_layer(imagechiffre)
pdb.gimp_selection_all(imagechiffre)
pdb.gimp_edit_copy(layerchiffre)
pdb.gimp_image_delete(imagechiffre)
floating_sel = pdb.gimp_edit_paste(layer,False)
pdb.gimp_floating_sel_anchor(floating_sel)
def cookie_cutter_letter(img, substrate, right, font, letter):
'''Cut text shaped like letter out of the given layer.'''
temp_layer = gpdb.gimp_text_fontname(img, substrate, right, 0, letter,
1, False, FONT_HEIGHT, PIXELS, font)
gpdb.gimp_selection_layer_alpha(temp_layer)
angle = random.uniform(*ANGLE_RANGE)
xaxis = right
yaxis = 15
# srcX = float(xaxis)
# dstX = float(srcX + random.uniform(0, 25))
# srcY = float(yaxis)
# dstY = float(srcY + random.uniform(0, 25))
# scaleX = scaleY = float(100)
# We need to save the selection as a channel so we can mess with
# the letter form.
shape = gpdb.gimp_selection_save(img)
gpdb.gimp_selection_none(img)
gpdb.gimp_floating_sel_remove(temp_layer)
# Distort the form of the individual letter:
shape = gpdb.gimp_item_transform_rotate(shape, angle, 0, xaxis, yaxis)
# We aren't doing any letter warping now, but if we were, this is the
# point where it should be done. We want to warp the shape of textLayer,
# which later serves as a cutout for the dark noise layer. If we warp the
# dark noise layer directly we will end up with warped dots.
#
# gpdb.gimp_context_set_transform_resize(TRANSFORM_RESIZE_CROP)
# shape = gpdb.gimp_item_transform_2d(shape, srcX, srcY, angle,
# scaleX, scaleY, dstX, dstY)
gpdb.gimp_selection_load(shape)
img.remove_channel(shape)
# Note the bounding box of the letter form so we can figure out
# where the next one should go.
bounds = gpdb.gimp_selection_bounds(img)
new_right = bounds[3] + LETTER_SPACING
# Actually cut the letter form out of the substate.
gpdb.gimp_selection_invert(img)
gpdb.gimp_edit_clear(substrate)
gpdb.gimp_selection_none(img)
return new_right
def effet_texte(inColor, inImg):
layer = pdb.gimp_image_get_active_layer(inImg)
pdb.gimp_context_set_sample_transparent(True)
pdb.gimp_image_select_contiguous_color(inImg, CHANNEL_OP_REPLACE, layer, 1, 1)
pdb.gimp_selection_invert(inImg)
_, x, _, x2, y2 = pdb.gimp_selection_bounds(inImg)
xmiddle = x + (x2 - x) // 2
y = y2 - 1
keep = True
while keep:
if y < 0:
print("Error in effet_texte for img {} : y < 0 !".format(inImg))
return
if (not _is_transparent(inImg, layer, xmiddle, y)) and _is_black(inImg, layer, xmiddle, y):
keep = False
pdb.gimp_context_set_sample_transparent(False)
pdb.gimp_image_select_contiguous_color(inImg, CHANNEL_OP_REPLACE, layer, xmiddle, y)
pdb.gimp_edit_clear(layer)
y -= 1
_, x1, y1, x2, y2 = pdb.gimp_selection_bounds(inImg)
newlayer = pdb.gimp_layer_copy(layer, True)
pdb.gimp_image_select_rectangle(inImg, CHANNEL_OP_REPLACE, x1, y1, x2-x1, y2-y1)
pdb.gimp_context_set_sample_transparent(True)
pdb.gimp_image_select_contiguous_color(inImg, CHANNEL_OP_SUBTRACT, layer, x1, y1)
pdb.gimp_edit_clear(layer)
pdb.gimp_selection_invert(inImg)
pdb.gimp_image_insert_layer(inImg, newlayer, None, 0)
pdb.gimp_edit_clear(newlayer)
pdb.script_fu_layerfx_outer_glow(inImg, newlayer, inColor, 75, 0, 0, 0, 0, 5, 0, 1)
pdb.gimp_image_merge_visible_layers(inImg, CLIP_TO_IMAGE)
pdb.gimp_selection_none(inImg)
pdb.gimp_displays_flush()
def make_captcha(sx, sy, font_height, letter_spacing, left_margin, angle_range,
fonts, answer):
"""Generate a captcha consisting of the letters in answer.
:rtype: :class:`gimp.Image`
:returns: The CAPTCHA as a gimp-python image object.
"""
img = gimp.Image(sx, sy, RGB_IMAGE)
img.disable_undo()
light_noise_layer = gimp.Layer(img, 'light noise', sx, sy, RGB_IMAGE, 100,
NORMAL_MODE)
img.add_layer(light_noise_layer, 0)
gpdb.gimp_selection_none(img)
gpdb.gimp_drawable_fill(light_noise_layer, WHITE_FILL)
# plug_in_randomize_hurl at 1% 1 time is vastly superior to
# scatter_rgb here, but has a bug where it creates an artifact at
# the top of the image when invoked in a scripting context like
# this.
#
# Future experiment: dial down the amount of noise generated by
# scatter, then run it through levels to darken it, then
# blur. This should be equivalent to hurl + blur.
#gpdb.plug_in_randomize_hurl(img, light_noise_layer, 1, 1, 0, 0)
gpdb.plug_in_scatter_hsv(img, light_noise_layer, 1, 25, 200, 180)
gpdb.plug_in_gauss_iir(img, light_noise_layer, 1, 1, 1)
gpdb.gimp_desaturate(light_noise_layer)
# Next make pure black layer which we will copy repeatedly as a
# place to cut out letters.
blackLayer = gimp.Layer(img, 'black', sx, sy, RGB_IMAGE, 100, NORMAL_MODE)
img.add_layer(blackLayer, 0)
blackLayer.add_alpha()
gpdb.gimp_layer_add_alpha(blackLayer)
gpdb.gimp_drawable_fill(blackLayer, WHITE_FILL)
gpdb.gimp_invert(blackLayer)
# Loop through each letter, making it a separate black layer.
right = left_margin
last_substrate = None
for letter in answer:
font = random.choice(FONTS)
substrate = blackLayer.copy()
img.add_layer(substrate, 0)
new_right = cookie_cutter_letter(img, substrate, right, font, letter)
# look out for really narrow letters
if new_right - right < 20:
new_right += 5
right = new_right
img.remove_layer(blackLayer)
# Hide the light noise layer, then collapse all the remaining
# layers (all letters) into a single layer.
light_noise_layer.visible = False
textLayer = gpdb.gimp_image_merge_visible_layers(img, CLIP_TO_IMAGE)
light_noise_layer.visible = True
# Create a layer of dark noise which will display the letters.
dark_noise_layer = gimp.Layer(img, 'dark noise', sx, sy, RGB_IMAGE, 100,
MULTIPLY_MODE)
img.add_layer(dark_noise_layer, 1)
gpdb.gimp_drawable_fill(dark_noise_layer, WHITE_FILL)
gpdb.plug_in_randomize_hurl(img, dark_noise_layer, 25, 1, 0, 0)
gpdb.gimp_desaturate(dark_noise_layer)
# These next operations are ordered carefully. Changing the order
# dramatically affects how the output looks.
# Here's where we do the cutout operation.
gpdb.gimp_selection_layer_alpha(textLayer)
gpdb.gimp_selection_invert(img)
gpdb.gimp_edit_clear(dark_noise_layer)
gpdb.gimp_selection_none(img)
# After the cutout, blur the dark noise layer and then darken it:
gpdb.plug_in_gauss_iir(img, dark_noise_layer, 1, 1, 1)
gpdb.gimp_levels(dark_noise_layer, HISTOGRAM_VALUE, 127, 255, 0.25, 0, 255)
textLayer.visible = False
# If you start gimp without --no-interface with an X server, this
# line will let you see the image looks like at this point in the
# script, layers and all. It should be fine to move this line to
# any problematic part of the script for debugging.
#
# gimp.Display(gpdb.gimp_image_duplicate(img))
final = img.flatten()
gpdb.gimp_image_clean_all(img)
img.enable_undo()
return img, final
def cutter_single_image(
image, drawable,
limit, sl_thresh, sz_thresh,
bg_manual, bg_color, bg_corner, bg_x, bg_y,
padding, deskew, sq_crop, autoclose,
save_same, save_dir, save_ftype, save_dpi, jpg_qual, save_suffix
):
img_width = pdb.gimp_image_width(image)
img_height = pdb.gimp_image_height(image)
img_fullpath = pdb.gimp_image_get_filename(image)
img_filename = os.path.basename(img_fullpath)
img_name = '.'.join(img_filename.split('.')[:-1])
img_ext = save_ftype or img_filename.split('.')[-1].lower()
new_filename_tpl = ''.join([
img_name, '-', save_suffix, '-',
'%0', str(len(str(int(limit + 1)))), 'd',
'.', img_ext
])
new_fullpath_tpl = os.path.join(
os.path.dirname(img_fullpath) if save_same else save_dir,
new_filename_tpl
)
# gimp.message(new_fullpath_tpl)
# function code goes here...
gimp.context_push()
pdb.gimp_image_undo_disable(image)
# If the background wasn't manually defined, pick the colour from one of the four corners
# (using radius 5 average)
if not bg_manual:
if bg_corner in (1, 3):
bg_x = img_width - bg_x
if bg_corner in (2, 3):
bg_y = img_height - bg_y
bg_color = pdb.gimp_image_pick_color(image, drawable, bg_x, bg_y, True, True, 5)
pdb.gimp_context_set_defaults()
pdb.gimp_context_set_antialias(True)
pdb.gimp_context_set_sample_transparent(True)
pdb.gimp_context_set_sample_threshold_int(sl_thresh)
pdb.gimp_context_set_feather(True)
fr = min(img_width, img_height) / 100.0 # NOTE why???
pdb.gimp_context_set_feather_radius(fr, fr)
pdb.gimp_context_set_background(bg_color)
pdb.gimp_image_select_color(image, gimpfu.CHANNEL_OP_REPLACE, drawable, bg_color)
# convert inverted copy of the background selection to a path
pdb.gimp_selection_sharpen(image)
pdb.gimp_selection_invert(image)
# _, before = pdb.gimp_image_get_vectors(image)
pdb.plug_in_sel2path(image, drawable)
# _, after = pdb.gimp_image_get_vectors(image)
# newpath_id = list(set(after) - set(before))[0]
# newpath = gimp.Vectors.from_id(newpath_id)
# looks like newly created vector is always active, so this should be sufficent
newpath = pdb.gimp_image_get_active_vectors(image)
pdb.gimp_context_set_feather(False)
_, strokes = pdb.gimp_vectors_get_strokes(newpath)
extracted = 0
for stroke_id in strokes:
stroke_points = pdb.gimp_vectors_stroke_get_points(newpath, stroke_id)
# skip not closed paths
if not stroke_points[3]:
continue
temp_vector = pdb.gimp_vectors_new(image, '-temp-')
pdb.gimp_image_insert_vectors(image, temp_vector, None, -1)
pdb.gimp_vectors_stroke_new_from_points(temp_vector, *stroke_points)
pdb.gimp_image_select_item(image, gimpfu.CHANNEL_OP_REPLACE, temp_vector)
pdb.gimp_image_remove_vectors(image, temp_vector)
# check for minimum size
bounds = pdb.gimp_selection_bounds(image)
sizex = bounds[3] - bounds[1]
sizey = bounds[4] - bounds[2]
if (min(sizex, sizey) < sz_thresh or
sizex >= img_width or
sizey >= img_height):
continue
buffname = "dsibuff"
if deskew and pdb.gimp_procedural_db_proc_exists('gimp_deskew_plugin'):
pdb.gimp_progress_set_text('Running deskew plugin...')
pdb.gimp_image_select_rectangle(
image, gimpfu.CHANNEL_OP_REPLACE,
bounds[1], bounds[2], sizex, sizey
)
buffname = pdb.gimp_edit_named_copy(drawable, buffname)
temp_image = pdb.gimp_edit_named_paste_as_new(buffname)
temp_layer = pdb.gimp_image_get_active_layer(temp_image)
pdb.gimp_image_undo_disable(temp_image)
pdb.gimp_layer_flatten(temp_layer)
# RUN_NONINTERACTIVE causes 'calling error' exception
pdb.gimp_deskew_plugin(temp_image, temp_layer, 0, 0, 0, 0, True,
run_mode=gimpfu.RUN_INTERACTIVE)
pdb.gimp_image_resize_to_layers(temp_image)
pdb.gimp_layer_flatten(temp_layer)
pdb.gimp_image_select_contiguous_color(
temp_image, gimpfu.CHANNEL_OP_REPLACE, temp_layer, 0, 0
)
pdb.gimp_selection_invert(temp_image)
bounds = pdb.gimp_selection_bounds(temp_image)
sizex = bounds[3] - bounds[1]
sizey = bounds[4] - bounds[2]
pdb.gimp_selection_none(temp_image)
pdb.gimp_image_crop(temp_image, sizex, sizey, bounds[1], bounds[2])
if (sq_crop and sizex != sizey
and pdb.gimp_procedural_db_proc_exists('script_fu_addborder')):
if sizex > sizey:
dx = 0
dy = (sizex - sizey) * 0.5
else:
dx = (sizey - sizex) * 0.5
dy = 0
pdb.script_fu_addborder(temp_image, temp_layer, dx, dy, bg_color, 0)
pdb.gimp_image_raise_item_to_top(temp_image, temp_layer)
pdb.gimp_image_merge_visible_layers(temp_image, gimpfu.EXPAND_AS_NECESSARY)
temp_layer = pdb.gimp_image_get_active_layer(temp_image)
else:
temp_image = image
pdb.gimp_image_undo_disable(temp_image)
temp_layer = pdb.gimp_image_get_active_layer(temp_image)
if sq_crop:
c_x = 0.5 * (bounds[1] + bounds[3])
c_y = 0.5 * (bounds[2] + bounds[4])
hl = padding + max(sizex, sizey) * 0.5
sel_x = c_x - hl
sel_y = c_y - hl
sel_w = sel_h = 2 * hl
else:
sel_x = bounds[1]
sel_y = bounds[2]
sel_w = sizex
sel_h = sizey
pdb.gimp_image_select_rectangle(
temp_image, gimpfu.CHANNEL_OP_REPLACE,
sel_x, sel_y, sel_w, sel_h
)
buffname = pdb.gimp_edit_named_copy(drawable, buffname)
temp_image = pdb.gimp_edit_named_paste_as_new(buffname)
temp_layer = pdb.gimp_image_get_active_layer(temp_image)
if padding and pdb.gimp_procedural_db_proc_exists('script_fu_addborder'):
pdb.script_fu_addborder(temp_image, temp_layer, padding, padding, bg_color, 0)
pdb.gimp_image_merge_visible_layers(temp_image, gimpfu.EXPAND_AS_NECESSARY)
temp_layer = pdb.gimp_image_get_active_layer(temp_image)
pdb.gimp_image_undo_enable(temp_image)
temp_display = pdb.gimp_display_new(temp_image)
extracted += 1
filename = new_fullpath_tpl % (extracted, )
pdb.gimp_image_set_resolution(temp_image, save_dpi, save_dpi)
if img_ext == 'jpg':
pdb.file_jpeg_save(
temp_image, temp_layer, filename, filename,
jpg_qual, 0.1, 1, 1, '', 2, 0, 0, 1
)
else:
pdb.gimp_file_save(temp_image, temp_layer, filename, filename)
if autoclose:
pdb.gimp_display_delete(temp_display)
if extracted >= limit:
break
pdb.gimp_progress_set_text('Extracted %d images' % (extracted, ))
pdb.gimp_image_remove_vectors(image, newpath)
pdb.gimp_selection_none(image)
pdb.gimp_image_undo_enable(image)
pdb.gimp_progress_end()
pdb.gimp_displays_flush()
gimp.context_pop()
return extracted
def make_captcha(sx, sy, font_height, letter_spacing, left_margin,
angle_range, fonts, answer):
"""Generate a captcha consisting of the letters in answer.
:rtype: :class:`gimp.Image`
:returns: The CAPTCHA as a gimp-python image object.
"""
img = gimp.Image(sx, sy, RGB_IMAGE)
img.disable_undo()
light_noise_layer = gimp.Layer(img, 'light noise', sx, sy,
RGB_IMAGE, 100, NORMAL_MODE)
img.add_layer(light_noise_layer, 0)
gpdb.gimp_selection_none(img)
gpdb.gimp_drawable_fill(light_noise_layer, WHITE_FILL)
# plug_in_randomize_hurl at 1% 1 time is vastly superior to
# scatter_rgb here, but has a bug where it creates an artifact at
# the top of the image when invoked in a scripting context like
# this.
#
# Future experiment: dial down the amount of noise generated by
# scatter, then run it through levels to darken it, then
# blur. This should be equivalent to hurl + blur.
#gpdb.plug_in_randomize_hurl(img, light_noise_layer, 1, 1, 0, 0)
gpdb.plug_in_scatter_hsv(img, light_noise_layer, 1, 25, 200, 180)
gpdb.plug_in_gauss_iir(img, light_noise_layer, 1, 1, 1)
gpdb.gimp_desaturate(light_noise_layer)
# Next make pure black layer which we will copy repeatedly as a
# place to cut out letters.
blackLayer = gimp.Layer(img, 'black', sx, sy, RGB_IMAGE, 100, NORMAL_MODE)
img.add_layer(blackLayer, 0)
blackLayer.add_alpha()
gpdb.gimp_layer_add_alpha(blackLayer)
gpdb.gimp_drawable_fill(blackLayer, WHITE_FILL)
gpdb.gimp_invert(blackLayer)
# Loop through each letter, making it a separate black layer.
right = left_margin
last_substrate = None
for letter in answer:
font = random.choice(FONTS)
substrate = blackLayer.copy()
img.add_layer(substrate, 0)
new_right = cookie_cutter_letter(img, substrate, right, font, letter)
# look out for really narrow letters
if new_right - right < 20:
new_right += 5
right = new_right
img.remove_layer(blackLayer)
# Hide the light noise layer, then collapse all the remaining
# layers (all letters) into a single layer.
light_noise_layer.visible = False
textLayer = gpdb.gimp_image_merge_visible_layers(img, CLIP_TO_IMAGE)
light_noise_layer.visible = True
# Create a layer of dark noise which will display the letters.
dark_noise_layer = gimp.Layer(img, 'dark noise', sx, sy,
RGB_IMAGE, 100, MULTIPLY_MODE)
img.add_layer(dark_noise_layer, 1)
gpdb.gimp_drawable_fill(dark_noise_layer, WHITE_FILL)
gpdb.plug_in_randomize_hurl(img, dark_noise_layer, 25, 1, 0, 0)
gpdb.gimp_desaturate(dark_noise_layer)
# These next operations are ordered carefully. Changing the order
# dramatically affects how the output looks.
# Here's where we do the cutout operation.
gpdb.gimp_selection_layer_alpha(textLayer)
gpdb.gimp_selection_invert(img)
gpdb.gimp_edit_clear(dark_noise_layer)
gpdb.gimp_selection_none(img)
# After the cutout, blur the dark noise layer and then darken it:
gpdb.plug_in_gauss_iir(img, dark_noise_layer, 1, 1, 1)
gpdb.gimp_levels(dark_noise_layer, HISTOGRAM_VALUE, 127, 255, 0.25, 0, 255)
textLayer.visible = False
# If you start gimp without --no-interface with an X server, this
# line will let you see the image looks like at this point in the
# script, layers and all. It should be fine to move this line to
# any problematic part of the script for debugging.
#
# gimp.Display(gpdb.gimp_image_duplicate(img))
final = img.flatten()
gpdb.gimp_image_clean_all(img)
img.enable_undo()
return img, final
