def caches(inImg, inNameLayerFleche, inNameLayerFond): path_cadenas = GRAPH_PATH + "images/cadenas.png" imagecadenas = pdb.gimp_file_load(path_cadenas, path_cadenas) layercadenas = pdb.gimp_image_get_active_layer(imagecadenas) pdb.gimp_selection_all(imagecadenas) pdb.gimp_edit_copy(layercadenas) pdb.gimp_image_delete(imagecadenas) layerfond = pdb.gimp_image_get_layer_by_name(inImg, inNameLayerFond) layerfleche = pdb.gimp_image_get_layer_by_name(inImg, inNameLayerFleche) _, alayers = pdb.gimp_image_get_layers(inImg) for layercurrent in alayers: pdb.gimp_selection_none(inImg) layercurrent = gimp.Item.from_id(layercurrent) pdb.script_fu_add_bevel(inImg, layercurrent, 5, 0, 0) pdb.gimp_item_set_visible(layercurrent, False) layername = pdb.gimp_item_get_name(layercurrent) if not (layername == inNameLayerFleche or layername == inNameLayerFond): cree_background(layercurrent, layerfond, inImg) cache = pdb.gimp_image_merge_visible_layers(inImg, CLIP_TO_IMAGE) pdb.script_fu_add_bevel(inImg, cache, 5, 0, 0) pdb.gimp_item_set_name(cache, "cache.png") pdb.gimp_image_lower_item_to_bottom(inImg, layerfleche) pdb.gimp_image_lower_item_to_bottom(inImg, cache) pdb.gimp_image_lower_item_to_bottom(inImg, layerfond)
def pythonSaveToClean(image): # Prep pdb.gimp_image_undo_group_start(image) pdb.gimp_context_push() # Code filename_old = pdb.gimp_image_get_filename(image) filename = filename_old.replace("_CLEAN", "") # drawable = pdb.gimp_image_get_active_drawable(image) path = os.path.dirname(filename) path += "_CLEAN" name = os.path.basename(filename) out_file = os.path.join(path, name) # Create CLEAN folder if not os.path.exists(path): os.makedirs(path) # Merge visible layers in new image and export in CLEAN folder new_image = pdb.gimp_image_duplicate(image) layer = pdb.gimp_image_merge_visible_layers(new_image, CLIP_TO_IMAGE) pdb.gimp_file_save(new_image, layer, out_file, out_file) pdb.gimp_image_delete(new_image) pdb.gimp_image_clean_all(image) # Finish pdb.gimp_context_pop() pdb.gimp_image_undo_group_end(image) pdb.gimp_displays_flush()
def pythonSaveToEditJpeg(image): # Prep pdb.gimp_image_undo_group_start(image) pdb.gimp_context_push() # Code # drawable = pdb.gimp_image_get_active_drawable(image) filename = pdb.gimp_image_get_filename(image) temp = filename.replace("_CLEAN", "") temp2 = temp.replace("_EDIT", "") filename = temp2.replace("_XCF", "") path = os.path.dirname(filename) path += "_EDIT" name = os.path.basename(filename) out_file = os.path.join(path, name) out_file = os.path.splitext(out_file)[0] + '.jpg' # Create _EDIT folder if not os.path.exists(path): os.makedirs(path) # Merge visible layers in new image and export in JPEG new_image = pdb.gimp_image_duplicate(image) layer = pdb.gimp_image_merge_visible_layers(new_image, CLIP_TO_IMAGE) pdb.gimp_file_save(new_image, layer, out_file, out_file) pdb.gimp_image_delete(new_image) pdb.gimp_image_clean_all(image) # Finish pdb.gimp_context_pop() pdb.gimp_image_undo_group_end(image) pdb.gimp_displays_flush()
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 merge_layer(img, layer_1, layer_2): """ merge layers """ # keep current state layer_state = [] for layer in img.layers: if layer != layer_1 and layer != layer_2: layer_state.append((layer, layer.visible)) # set layer_1 and layer_2 visible for layer in img.layers: layer.visible = False layer_1.visible = True layer_2.visible = True # merge new_layer = pdb.gimp_image_merge_visible_layers(img, 0) # set old state for layer in layer_state: layer[0].visible = layer[1] return new_layer
def createTechIcons(timg, tdrawable,file,folder, outFolder,scaleTo): for fileName in os.listdir(folder): # backGroundImage=pdb.gimp_file_load(file, file) # backGroundLayer=backGroundImage.layers[0] if fileName[-4:]!=".dds": continue outFile=outFolder+"/"+"tech_"+fileName image=pdb.gimp_file_load(folder+"/"+fileName, folder+"/"+fileName) pdb.gimp_image_scale(image,scaleTo,scaleTo) pdb.gimp_image_resize(image,52,52,-1,-1) for layer in image.layers: pdb.gimp_layer_resize_to_image_size(layer) # layer_group = pdb.gimp_layer_group_new(image) layer_group=pdb.gimp_item_get_parent(image.layers[0]) layer=pdb.gimp_file_load_layer(image, file) pdb.gimp_image_insert_layer(image,layer,layer_group,1)#(image, layer, parent, position) for layer in image.layers: pdb.gimp_item_set_visible(layer,True) layer = pdb.gimp_image_merge_visible_layers(image, 0) pdb.gimp_image_set_active_layer(image, layer) drawable = pdb.gimp_image_get_active_layer(image) # with open("E:/out.txt",'w') as outTxt: # outTxt.write(outFile) pdb.file_dds_save(image, drawable, outFile,outFile,0,0,0,0,0,0,0)
from gimpfu import pdb filename = "hall_of_fame_large.xcf" image = pdb.gimp_file_load(filename, filename) pdb.gimp_image_scale(image, 1280, 800) outfilename = "hall_of_fame.png" layer = pdb.gimp_image_merge_visible_layers(image, 1) pdb.gimp_file_save(image, layer, outfilename, outfilename)
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
def layerToDDS(timg, tdrawable, file, argumentFile, outFolder, byName, scaleBool, scaleTo): #, argumentFile,hmm,blub): # num_layers, layer_ids = pdb.gimp_image_get_layers(image) # with open("E:/out.txt",'w') as outTxt: # outTxt.write(str(os.getcwd())) outFolder = os.path.dirname(file) + "/" + outFolder if not os.path.exists(outFolder): os.makedirs(outFolder) if argumentFile.lower() == "all": image = pdb.gimp_file_load(file, file) fileContent = [] for layer in image.layers: layername = pdb.gimp_item_get_name(layer) fileContent.append(layername + " " + layername) byName = True else: with open(argumentFile, 'r') as argfile: fileContent = [line for line in argfile] for l in fileContent: image = pdb.gimp_file_load(file, file) if scaleBool: if scaleTo: pdb.gimp_image_resize(image, 52, 52, -26, -26) else: pdb.gimp_image_scale(image, 52, 52) line = shlex.split(l) outFile = outFolder + "/" + line[0] if outFile[-4:] != ".dds": outFile += ".dds" for layer in image.layers: # layer = pdb.gimp_image_get_layer_by_name(image, id) pdb.gimp_item_set_visible(layer, False) layers = [] for i, word in enumerate(line[1:]): if byName: if word[:4] == "MOVE": word2 = word[5:] layer = pdb.gimp_image_get_layer_by_name(image, word2) # pdb.gimp_item_set_visible(layer,True) pdb.gimp_layer_scale(layer, 40, 40, False) pdb.gimp_image_set_active_layer(image, layer) drawable = pdb.gimp_image_get_active_layer(image) if word[4] == "L": pdb.script_fu_move_layer_to(image, drawable, -2.5, 5) elif word[4] == "R": pdb.script_fu_move_layer_to(image, drawable, 17.5, 5) line[1 + i] = line[1 + i][5:] # pdb.gimp_item_set_visible(layer,False) for word in line[1:]: #outTxt.write(word+"\n") #layers.append(pdb.gimp_layer_copy(image.layers[int(word)],False)) #pdb.gimp_image_insert_layer(image, layer,image.layers[int(word)], 0) try: if byName: pdb.gimp_item_set_visible( pdb.gimp_image_get_layer_by_name(image, word), True) else: pdb.gimp_item_set_visible(image.layers[int(word)], True) except: pdb.gimp_message("Error parsing line " + " ".join(line) + ". Probably a missing/invalid item") raise if scaleBool and scaleTo: for word in line[2:]: if byName: layer = pdb.gimp_image_get_layer_by_name(image, word) else: layer = image.layers[int(word)] pdb.gimp_layer_scale(layer, scaleTo, scaleTo, False) pdb.gimp_layer_resize(layer, 52, 52, -1, -1) # for layer in layers: # outTxt.write("{!s}".format(layer)) # pdb.gimp_item_set_visible(layer, True) #pdb.gimp_item_set_visible(image.layers[3], True) #pdb.gimp_item_set_visible(image.layers[5], True) layer = pdb.gimp_image_merge_visible_layers(image, 0) pdb.gimp_image_set_active_layer(image, layer) drawable = pdb.gimp_image_get_active_layer(image) for layerIt in image.layers: if layerIt != layer or not scaleTo: pdb.gimp_layer_resize_to_image_size(layerIt) try: pdb.file_dds_save(image, drawable, outFile, outFile, 0, 0, 0, 0, 0, 0, 0) except: pdb.file_dds_save(image, drawable, outFile, outFile, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)