def run(): if gimp_shelf.has_key('socket_server') and gimp_shelf['socket_server']: gimp.message( "WARNING: '%s' is already running!" % SocketService.titleServer) return SocketService().run()
def move_drawable_to( drawable, # type: gimp.Image corner, # type: Corner x, # type: int y # type: int ): # type: (...) -> None """Moves a corner of a drawable to the position (x, y).""" left, top = pdb.gimp_drawable_offsets(drawable) # type: int, int width, height = pdb.gimp_drawable_mask_bounds(drawable)[ 3:] # type: int, int right = left + width # type: int bottom = top + height # type: int dx, dy = 0, 0 # type: int if corner == Corner.TOP_LEFT: dx = x - left dy = y - top elif corner == Corner.TOP_RIGHT: dx = x - right dy = y - top elif corner == Corner.BOTTOM_LEFT: dx = x - left dy = y - bottom elif corner == Corner.BOTTOM_RIGHT: dx = x - right dy = y - bottom elif corner == Corner.CENTER: dx = x - (left + right) // 2 dy = y - (top + bottom) // 2 else: gimp.message("Invalid corner %s" % repr(corner)) return pdb.gimp_layer_translate(drawable, dx, dy)
def checkFiles(self): nameMethod = self.nameClass + "::checkFiles" print("%s : Enter" % (nameMethod)) if not path.isfile(self.filenameBackground): print("%s : The following doesn't appear to be a file : %s" % (nameMethod, self.filenameBackground)) gimp.message("Hello!!!") raise Exception("Plugin is about to terminate!!!") for filenameForeground in self.listFilenamesForeground: if (not path.isfile(filenameForeground)): print("%s : The following doesn't appear to be a file : %s" % (nameMethod, filenameForeground)) raise Exception("Plugin is about to terminate!!!") print("%s : Exit" % (nameMethod))
def file_load_lepton(filename, raw_filename): ''' Save the current layer into a PNG file, a JPEG file and a BMP file. Parameters: image : image The current image. layer : layer The layer of the image that is selected. file : string The file to open in a new layer. ''' # Indicates that the process has started. gimp.progress_init("Opening '" + filename + "'...") try: tmpdirobj = mkdtemp() tmp_dirname = tmpdirobj jpeg_fn = os.path.join(tmp_dirname, "from_lep.jpeg") subprocess.check_call(["lepton", filename, jpeg_fn]) fileImage = pdb.file_jpeg_load(jpeg_fn, filename) if (fileImage is None): gimp.message("The image could not be opened since" + "it is not an image file.") shutil.rmtree(tmp_dirname) return fileImage except Exception as err: gimp.message("Unexpected error: " + str(err)) raise err
def checkLists(self): nameMethod = self.nameClass + "::checkLists" print("%s : Enter" % (nameMethod)) print("%s : Number of elements in list = %d" % (nameMethod, len(self.listFilenamesForeground))) if self.filenameBackground == None: gimp.message("A) You must specify a background image file.") elif ((len(self.listFilenamesForeground) == 0) or ((len(self.listFilenamesForeground) == 1) and (self.listfilenamesForeground == ''))): gimp.message( "B) You must specify at least one foreground image file.") print("%s : Number of foreground image files = 0") % (nameMethod) else: self.checkFiles() print("%s : Exit" % (nameMethod))
def png(image=None): if not image: image = gimp.image_list()[0] prefix = pdb.gimp_image_get_filename(image)[:-4] + "_" gimp.progress_init("Save frames as {}_*.png".format(prefix)) for (layer_index, layer) in enumerate(image.layers): try: filename = "{}{:02d}.png".format(prefix, int(layer.name)) except ValueError: filename = "{}{}.png".format(prefix, layer.name) pdb.file_png_save( image, layer, filename, None, True, # interlace 9, # compression True, # bkgd True, # gama True, # offs True, # phys True, # time ) gimp.progress_update(100 * (layer_index + 1) / len(image.layers)) gimp.message("All frames saved as {}_*.png".format(prefix))
def run(image, drawable): #startPyDevClient() if gimp_shelf.has_key('socket_server') and gimp_shelf['socket_server']: gimp.message("WARNING: '%s' is already running!" % SocketService.titleServer) return SocketService().run(image)
def predict(self, *args, **kwargs): assert self.model_file is not None model_proxy = ModelProxy(self.model_file) try: return model_proxy(*args, **kwargs) except: error_info = self._format_error(traceback.format_exc()) gimp.message(error_info) raise
def exportCcodeBin(timg, tdrawable, filename, colormode): pr = tdrawable.get_pixel_rgn(0, 0, timg.width, timg.height, False, False) i = 0 j = 0 size = timg.width * timg.height #image size if colormode == 0: gimp.message("12-bit mode not yet implemented") elif colormode == 1: data = [] while (j < timg.height): while (i < timg.width): data.append(packColor(pr[i, j])) i += 1 j += 1 i = 0 savefile = open(filename, "wb") for byte in data: savefile.write(struct.pack('H', byte)) savefile.close() elif colormode == 2: gimp.message("18-bit mode not yet implemented") elif colormode == 3: gimp.message("24-bit mode not yet implemented") else: gimp.message("Error: No color mode selected")
def destroy(self, widget): # if is closing and still playing try to stop and send a message with info. if self.is_playing: self.is_playing = False gimp.message( "Please do not close the image with FAnim playing the animation." ) if widget != False: # for when this function is called without valid image variable. # return to the normal layers order. pdb.script_fu_reverse_layers(self.image, None) self.on_goto(None, START) #save the settings before quit. Utils.save_conffile(CONF_FILENAME, self.get_settings()) gtk.main_quit()
def gif(image=None, suffix=None, fps=24): if not image: image = gimp.image_list()[0] file_path = pdb.gimp_image_get_filename(image)[:-4] if suffix: file_path += "_" + suffix.strip() file_path += ".gif" ms = int(1000.0 / fps) temp_image = False try: gimp.progress_init( "Save animated GIF @ {} fps = {} ms/frame as {}".format( fps, ms, file_path)) if pdb.gimp_image_base_type(image) != 2: temp_image = True image = pdb.gimp_image_duplicate(image) pdb.gimp_image_convert_indexed( image, 0, # dither-type=CONVERT-DITHER-NONE 0, # palette-type=CONVERT-PALETTE-GENERATE 255, # num-cols False, # alpha-dither False, # remove-unused "" # palette ) gimp.progress_update(50) pdb.file_gif_save( image, image.layers[0], file_path, file_path, True, # interlace True, # loop ms, # default-delay 2 # default-dispose ) gimp.progress_update(100) gimp.message("Saved animated GIF @ {} fps = {} ms/frame as {}".format( fps, ms, file_path)) finally: if temp_image: pdb.gimp_image_delete(image)
def draw_mark( image, # type: gimp.Image directions, x0, # type: int y0, # type: int size, # type: int distance # type: int ): # type: (...) -> None """Draws a mark at position where one must cut or fold the paper.""" x, y, width, height = 0, 0, 0, 0 # type: int, int, int, int for direction in directions: # type: Direction if direction == Direction.UP: x = x0 - 1 y = y0 - distance - size width = 2 height = size elif direction == Direction.DOWN: x = x0 - 1 y = y0 + distance width = 2 height = size elif direction == Direction.LEFT: x = x0 - distance - size y = y0 - 1 width = size height = 2 elif direction == Direction.RIGHT: x = x0 + distance y = y0 - 1 width = size height = 2 else: gimp.message("Invalid direction %s" % repr(direction)) return pdb.gimp_image_select_rectangle(image, gimpfu.CHANNEL_OP_REPLACE, x, y, width, height) pdb.gimp_edit_fill(image.active_layer, gimpfu.FOREGROUND_FILL) pdb.gimp_selection_none(image)
def run(self): # Socket try: self.sock.bind( ( '127.0.0.1', self.port ) ) except socket.error as msg_socket: msg = "Socket Error: %s" % str( msg_socket ) gimp.message( "%s: %s!" % ( self.titleServer, msg ) ) self.quit() return self.sock.listen( 1 ) gimp.message( "'%s' is running..." % self.titleServer ) gimp_shelf['socket_server'] = True self.conn, client = self.sock.accept() while True: sdata = self.conn.recv(4096) if not sdata: self.quit() # Call by client sock.close() break try: data = json.loads( sdata ) except ValueError: continue if not 'function' in data: continue if data['function'] == 'add_image': self.pathfileImage = data['filename'] self.paramImage.clear() self.paramImage = data['paramImage'] else: self.pathfileImageSelect = data['filename'] functions = { 'add_image': self.add_image, 'create_selection_image': self.create_selection_image } functions[ data['function'] ]()
def exportCcode(timg, tdrawable, iconname, filename, colormode): pr = tdrawable.get_pixel_rgn(0, 0, timg.width, timg.height, False, False) i = 0 j = 0 size = timg.width * timg.height #LCD size output = "/*\nC code Exported from Gimp\n\nicon size in pixels: width=" + str( timg.width) + ", height:" + str(timg.height) + "\n*/\n\n" if colormode == 0: gimp.message("12-bit mode not yet implemented") elif colormode == 1: output += "uint16_t " + iconname + "[" + "%(size)d" % { "size": size } + "]={\n" while (j < timg.height - 1): while (i < timg.width - 1): output += packColor(pr[i, j]) + "," i += 1 output += packColor(pr[i, j]) #the last column, no comma output += ",\n" #end of each row j += 1 i = 0 while (i < timg.width - 1): #the last row, no comma output += packColor(pr[i, j]) + "," i += 1 output += packColor(pr[i, j]) #the last column, no comma output += "\n};" savefile = open(filename, "w") savefile.write(output) savefile.close() elif colormode == 2: gimp.message("18-bit mode not yet implemented") elif colormode == 3: output += "typedef struct{ \nunsigned char \nr,\ng,\nb;\n}RGB;\n\nRGB " + iconname + "[" + "%(size)d" % { "size": size } + "]={\n" while (j < timg.height - 1): while (i < timg.width - 1): output += array2struct(pr[i, j]) + "," i += 1 output += array2struct(pr[i, j]) #the last column, no comma output += ",\n" #end of each row j += 1 i = 0 while (i < timg.height - 1): #the last row, no comma output += array2struct(pr[i, j]) + "," i += 1 output += array2struct(pr[i, j]) #the last column, no comma output += "\n};" savefile = open(filename, "w") savefile.write(output) savefile.close() else: gimp.message("Error: No color mode selected" ) #will hardly happen as we now have a default colormode
def exportCcode(timg, tdrawable,iconname,filename,colormode): pr =tdrawable.get_pixel_rgn(0, 0, timg.width,timg.height, False, False); i=0 j=0 size = timg.width*timg.height #LCD size output = "/*\nC code Exported from Gimp\n\nicon size in pixels: width="+str(timg.width)+", height:"+str(timg.height)+"\n*/\n\n" if colormode==0: gimp.message("12-bit mode not yet implemented") elif colormode==1: output += "uint16_t "+iconname+"[" + "%(size)d" % {"size":size} + "]={\n" while (j<timg.height-1): while (i<timg.width-1): output += packColor(pr[i,j]) + "," i+=1 output += packColor(pr[i,j]) #the last column, no comma output += ",\n" #end of each row j+=1 i=0 while (i<timg.width-1): #the last row, no comma output += packColor(pr[i,j]) + "," i+=1 output += packColor(pr[i,j]) #the last column, no comma output += "\n};" savefile = open(filename,"w") savefile.write(output) savefile.close() elif colormode==2: gimp.message("18-bit mode not yet implemented") elif colormode==3: output += "typedef struct{ \nunsigned char \nr,\ng,\nb;\n}RGB;\n\nRGB "+iconname+"[" + "%(size)d" % {"size":size} + "]={\n" while (j<timg.height-1): while (i<timg.width-1): output += array2struct(pr[i,j]) + "," i+=1 output += array2struct(pr[i,j]) #the last column, no comma output += ",\n" #end of each row j+=1 i=0 while (i<timg.height-1): #the last row, no comma output += array2struct(pr[i,j]) + "," i+=1 output += array2struct(pr[i,j]) #the last column, no comma output += "\n};" savefile = open(filename,"w") savefile.write(output) savefile.close() else: gimp.message("Error: No color mode selected")#will hardly happen as we now have a default colormode
def run(self, image): # Socket try: self.sock.bind(('', self.port)) except socket.error as msg_socket: msg = "Socket Error: %s" % str(msg_socket) gimp.message("%s: %s!" % (self.titleServer, msg)) self.quit() return self.sock.listen(1) gimp.message("'%s' is running..." % self.titleServer) gimp_shelf['socket_server'] = True self.filename = image.filename vreturn = self.isTifImage() if not vreturn['isOk']: gimp.message("%s Running -- CLOSE and OPEN the TIF image!" % self.titleServer) self.conn, client = self.sock.accept() while True: sdata = self.conn.recv(4096) if not sdata: self.quit() # Call by client sock.close() break try: data = json.loads(sdata) except ValueError, e: continue if not data.has_key('function'): continue self.filename = data['filename'] functions = { 'add_image': self.add_image, 'add_image_overwrite': self.add_image_overwrite, 'create_selection_image': self.create_selection_image } functions[data['function']]()
def create_wraps( src_image, # type: gimp.Image box_width_mm, # type: float box_height_mm, # type: float box_depth_mm, # type: float thickness_mm, # type: float flap_size_mm, # type: float inside_size_mm, # type: float crop_mark_size_mm, # type: float crop_mark_distance_mm # type: float ): # type: (...) -> None """Creates two wrap images from a template image.""" # Convert the dimensions from mm to px box_width = mm_to_px(box_width_mm) # type: int box_height = mm_to_px(box_height_mm) # type: int box_depth = mm_to_px(box_depth_mm) # type: int thickness = mm_to_px(thickness_mm) # type: int flap_size = mm_to_px(flap_size_mm) # type: int inside_size = mm_to_px(inside_size_mm) # type: int crop_mark_size = mm_to_px(crop_mark_size_mm) # type: int crop_mark_distance = mm_to_px(crop_mark_distance_mm) # type: int half_box_height = box_height // 2 # type: int half_box_height_plus_extra = \ half_box_height + thickness + inside_size # type: int # Coordinates in the source image src_xs, src_ys = template_coordinates(box_width, box_height, box_depth) # type: int, int src_image_width = src_xs[-1] - src_xs[0] # type: int src_image_height = src_ys[-1] - src_ys[0] # type: int # Coordinates in the destination images dst_xs, dst_ys = wrap_coordinates(box_width, box_height, box_depth, thickness, inside_size, flap_size, crop_mark_size, crop_mark_distance) dst_image_width = dst_xs[-1] - dst_xs[0] # type: int dst_image_height = dst_ys[-1] - dst_ys[0] # type: int # Make sure we have the right dimensions if src_image.width != src_image_width or \ src_image.height != src_image_height: gimp.message( "Template image has the wrong size. " "Expected %dpx x %dpx (%dmm x %dmm) " "but got %dpx x %dpx (%dmm x %dmm)." % (src_image_width, src_image_height, px_to_mm(src_image_width), px_to_mm(src_image_height), src_image.width, src_image.height, px_to_mm(src_image.width), px_to_mm(src_image.height))) return # Draw stuff onto both destination images in the same way def draw(dst_image, copy_and_rotate_definitions): """Copies regions from the input image to a wrap image.""" dst_layer = gimp.Layer(dst_image, "Wrap", dst_image_width, dst_image_height, gimpfu.RGB_IMAGE, 100, gimpfu.NORMAL_MODE) # type: gimp.Layer dst_layer.fill(gimpfu.WHITE_FILL) dst_image.add_layer(dst_layer, 0) # Add guides for x in dst_xs: # type: int dst_image.add_vguide(x) for y in dst_ys: # type: int dst_image.add_hguide(y) # Take the layers from the template and move and rotate them # into position for d in copy_and_rotate_definitions: pdb.gimp_progress_pulse() copy_and_rotate_rectangle( src_image, # src_image d[0], # src_x d[1], # src_y d[2], # src_width d[3], # src_height dst_layer, # dst_layer d[4], # dst_x d[5], # dst_y d[6], # dst_corner d[7]) # rotation_angle # Copy strips from the sides to create the flaps on the front # and the back pdb.gimp_progress_pulse() copy_and_rotate_rectangle(dst_image, dst_xs[1], dst_ys[4], half_box_height_plus_extra, flap_size, dst_layer, dst_xs[5], dst_ys[4], Corner.BOTTOM_RIGHT, 90) pdb.gimp_progress_pulse() copy_and_rotate_rectangle(dst_image, dst_xs[1], dst_ys[6], half_box_height_plus_extra, flap_size, dst_layer, dst_xs[5], dst_ys[7], Corner.TOP_RIGHT, 270) pdb.gimp_progress_pulse() copy_and_rotate_rectangle(dst_image, dst_xs[6], dst_ys[4], half_box_height_plus_extra, flap_size, dst_layer, dst_xs[6], dst_ys[4], Corner.BOTTOM_LEFT, 270) pdb.gimp_progress_pulse() copy_and_rotate_rectangle(dst_image, dst_xs[6], dst_ys[6], half_box_height_plus_extra, flap_size, dst_layer, dst_xs[6], dst_ys[7], Corner.TOP_LEFT, 90) # Marks for cutting and folding draw_mark(dst_image, (Direction.UP, Direction.LEFT), dst_xs[4], dst_ys[1], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.UP, ), dst_xs[5], dst_ys[1], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.UP, ), dst_xs[6], dst_ys[1], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.UP, Direction.RIGHT), dst_xs[7], dst_ys[1], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.UP, Direction.LEFT), dst_xs[1], dst_ys[4], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.UP, Direction.RIGHT), dst_xs[10], dst_ys[4], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.DOWN, Direction.LEFT), dst_xs[1], dst_ys[7], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.DOWN, Direction.RIGHT), dst_xs[10], dst_ys[7], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.DOWN, Direction.LEFT), dst_xs[4], dst_ys[10], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.DOWN, ), dst_xs[5], dst_ys[10], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.DOWN, ), dst_xs[6], dst_ys[10], crop_mark_size, crop_mark_distance) draw_mark(dst_image, (Direction.DOWN, Direction.RIGHT), dst_xs[7], dst_ys[10], crop_mark_size, crop_mark_distance) pdb.gimp_selection_none(dst_image) # Define where from and where to we want to copy # Each line looks like this: # (src_x, src_y, src_width, src_height, # dst_x, dst_y, dst_corner, rotation_angle) copy_and_rotate_definitions_top = ( # Top (src_xs[1], src_ys[0], box_width, box_depth, dst_xs[5], dst_ys[4], Corner.TOP_LEFT, 0), # Left (src_xs[0], src_ys[1], box_depth, half_box_height_plus_extra, dst_xs[5], dst_ys[4], Corner.TOP_RIGHT, 90), # Front (src_xs[1], src_ys[1], box_width, half_box_height_plus_extra, dst_xs[5], dst_ys[7], Corner.TOP_LEFT, 0), # Right (src_xs[2], src_ys[1], box_depth, half_box_height_plus_extra, dst_xs[6], dst_ys[4], Corner.TOP_LEFT, 270), # Back (src_xs[3], src_ys[1], box_width, half_box_height_plus_extra, dst_xs[5], dst_ys[4], Corner.BOTTOM_LEFT, 180), ) copy_and_rotate_definitions_bottom = ( # Left (src_xs[0], src_ys[3] - half_box_height_plus_extra, box_depth, half_box_height_plus_extra, dst_xs[5], dst_ys[4], Corner.TOP_RIGHT, 270), # Front (src_xs[1], src_ys[3] - half_box_height_plus_extra, box_width, half_box_height_plus_extra, dst_xs[5], dst_ys[1], Corner.TOP_LEFT, 0), # Right (src_xs[2], src_ys[3] - half_box_height_plus_extra, box_depth, half_box_height_plus_extra, dst_xs[6], dst_ys[4], Corner.TOP_LEFT, 90 ), # Back (src_xs[3], src_ys[3] - half_box_height_plus_extra, box_width, half_box_height_plus_extra, dst_xs[5], dst_ys[10], Corner.BOTTOM_LEFT, 180), # Bottom (src_xs[1], src_ys[3], box_width, box_depth, dst_xs[5], dst_ys[4], Corner.TOP_LEFT, 0), ) with DefaultContext(): dst_image_top = gimp.Image(dst_image_width, dst_image_height, gimpfu.RGB) # type: gimp.Image with PausedUndo(dst_image_top): draw(dst_image_top, copy_and_rotate_definitions_top) gimp.Display(dst_image_top) dst_image_bottom = gimp.Image(dst_image_width, dst_image_height, gimpfu.RGB) # type: gimp.Image with PausedUndo(dst_image_bottom): draw(dst_image_bottom, copy_and_rotate_definitions_bottom) gimp.Display(dst_image_bottom) gimp.displays_flush()
def \ superimpose_image_over_another_noninteractive( # image, # drawable, list_filenames, list_filenames_superimpose # horizontalLocation, # verticalLocation ) : nameFunction = "superimpose_image_over_another_interactive" print("----------------------------------------") print("%s : Enter" % (nameFunction)) IFS = ";" # listFiles = fileContents.split(IFS) listFiles = list_filenames.split(IFS) listFiles_superimpose = list_filenames_superimpose.split(IFS) print("%s : Number of elements in list = %d" % (nameFunction, len(listFiles))) print("%s : File list = %s" % (nameFunction, listFiles)) print("%s : Number of elements in list = %d" % (nameFunction, len(listFiles_superimpose))) print("%s : File list = %s" % (nameFunction, listFiles_superimpose)) if (len(listFiles) == 0): print("%s : Number of background image files = 0 : a") % (nameFunction) # errdialog = gtk.MessageDialog( # None, # 0, # gtk.MESSAGE_ERROR, # gtk.BUTTONS_OK, # "A) You must specify at least one background image file." # ) # errdialog.show_all() # errdialog.run() # raise Exception("You must specify at least one background image file.") elif (len(listFiles_superimpose) == 0): gimp.message( "B) You must specify at least one superimpose image file.") print("%s : Number of superimpose image files = 0 : a") % ( nameFunction) # raise Exception("You must specify at least one superimpose image file.") # elif (len(listFiles) == 1) : and elif (listFiles[0] == ''): gimp.message("C) You must specify at least one background image file.") print("%s : Number of background image files = 0 : b") % (nameFunction) # raise Exception("You must specify at least one background image file.") # elif (len(listFiles_superimpose) == 1) and elif (listFiles_superimpose[0] == ''): gimp.message( "D) You must specify at least one superimpose image file.") print("%s : Number of superimpose image files = 0 : b") % ( nameFunction) # raise Exception("You must specify at least one superimpose image file.") elif len(listFiles) != len(listFiles_superimpose): gimp.message( "E) The number of files specified must be the same for both background and superimpose images." ) print( "%s : The number of files specified must be the same for both background and superimpose images!" ) % (nameFunction) # raise Exception("The number of files specified must be the same for both background and superimpose images!") indexList = 0 for filename in listFiles: indexList = indexList + 1 print("%s : ========================================" % (nameFunction)) print("%s : Filename = %s" % (nameFunction, filename)) print("%s : ========================================" % (nameFunction)) if (not path.isfile(filename)): print("%s : > is NOT a file" % (nameFunction)) continue filename_superimpose = listFiles_superimpose[indexList - 1] print("%s : ========================================" % (nameFunction)) print("%s : Filename of image to superimpose = %s" % (nameFunction, filename_superimpose)) print("%s : ========================================" % (nameFunction)) if (not path.isfile(filename_superimpose)): print("%s : > is NOT a file" % (nameFunction)) gimp.progress_init("Superimposing one image over the other") image = pdb.gimp_file_load(filename, filename) drawable = pdb.gimp_image_get_active_layer(image) # Start a GIMP Undo group, as this will allow the actions of this Plugin to be undone in one step. pdb.gimp_undo_push_group_start(image) widthImage = image.width heightImage = image.height widthDrawable = drawable.width heightDrawable = drawable.height print("Width image = %s" % widthImage) print("Height image = %s" % heightImage) print("Width drawable = %s" % widthDrawable) print("Height drawable = %s" % heightDrawable) # print("Horizontal location = %s" % horizontalLocation) # print("Vertical location = %s" % verticalLocation) print("Image filename = %s" % image.filename) # Open the image file to be superimposed and get its drawable object. image_super = pdb.gimp_file_load(filename_superimpose, filename_superimpose) drawable_super = pdb.gimp_image_get_active_layer(image_super) print("Width super image = %s" % image_super.width) print("Height super image = %s" % image_super.height) print("Width super drawable = %s" % drawable_super.width) print("Height super drawable = %s" % drawable_super.height) # How many layers does the current image now contain? # # Use gimp-edit-copy and gimp-edit-paste? copy_result = pdb.gimp_edit_copy(drawable_super) if (copy_result == True): print("True") else: print("False") print("Selection copy result = %s" % copy_result) # pdb.gimp_drawable_update(drawable, horizontalLocation, verticalLocation, 384, 216) # The following operation should paste the image which is in the buffer, into a new layer of the # original image. pdb.gimp_edit_paste(drawable, True) widthImage = image.width heightImage = image.height widthDrawable = drawable.width heightDrawable = drawable.height print("Width image = %s" % widthImage) print("Height image = %s" % heightImage) print("Width drawable = %s" % widthDrawable) print("Height drawable = %s" % heightDrawable) # print("Horizontal location = %s" % horizontalLocation) # print("Vertical location = %s" % verticalLocation) # Move the # pdb.gimp_drawable_update() drawable_new = pdb.gimp_image_flatten(image) pdb.gimp_file_save(image, drawable_new, filename, filename) # End the GIMP Undo group. pdb.gimp_undo_push_group_end(image) # Close the image now that we have finished with it, otherwise it will use up memory unnecessarily. pdb.gimp_image_delete(image) # End of for loop. print("%s : Exit" % (nameFunction))
def plugin_hello(): gimp.message("Hello, GIMP world!\n")
def quit(self): gimp.message( "%s: Stopped!" % self.titleServer) gimp_shelf['socket_server'] = False self.conn = None
#!/usr/bin/python import traceback from gimpfu import pdb, gimp import gimpfu as gfu infile = "test.jpg" outfile = "out.png" try: image = pdb.gimp_file_load(infile, infile, run_mode=gfu.RUN_NONINTERACTIVE) # w = 200 # h = round(w * image.height / float(image.width)) # pdb.gimp_image_scale(image, w, h) pdb.python_fu_super_resolution(image, image.active_layer) image.flatten() pdb.gimp_file_save(image, image.active_layer, outfile, outfile, run_mode=gfu.RUN_NONINTERACTIVE) except: gimp.message("ERROR:\n" + traceback.format_exc()) pdb.gimp_quit(1)
def printMessage(message): pdb.gimp_progress_end() gimp.message(message)
def quit(self): gimp.message("%s: Stopped!" % self.titleServer) gimp_shelf['socket_server'] = False self.conn = None
def sheet(image=None, cols=0): if not image: image = gimp.image_list()[0] if not cols: best = (1, 10000000) for cols in range(1, len(image.layers) + 1): rows = (len(image.layers) + (cols - 1)) // cols (sheet_width, sheet_height) = (cols * image.width, rows * image.height) sheet_aspect_ratio = sheet_width / sheet_height if sheet_width > sheet_height else sheet_height / sheet_width if sheet_aspect_ratio < best[1]: best = (cols, sheet_aspect_ratio) cols = best[0] file_path = "{}_sheet_{}_frames_{}_columns_{}x{}.png".format( pdb.gimp_image_get_filename(image)[:-4], len(image.layers), cols, image.width, image.height) gimp.progress_init("Save sheet as {}".format(file_path)) rows = (len(image.layers) + (cols - 1)) // cols sheet = pdb.gimp_image_new(image.width * cols, image.height * rows, 0) try: sheet_layer = pdb.gimp_layer_new( sheet, sheet.width, sheet.height, 1, # type = RGBA-IMAGE "sprite sheet", 100, # opacity = 100 % 0 # mode = LAYER-MODE-NORMAL-LEGACY ) pdb.gimp_image_insert_layer(sheet, sheet_layer, None, 0) (row, col) = (0, 0) for (layer_index, layer) in enumerate(image.layers): pdb.gimp_selection_none(image) pdb.gimp_layer_resize_to_image_size(layer) pdb.gimp_edit_copy(layer) floating = pdb.gimp_edit_paste(sheet_layer, True) (left, top) = floating.offsets pdb.gimp_layer_translate(floating, col * image.width - left, row * image.height - top) pdb.gimp_floating_sel_anchor(floating) col += 1 if col >= cols: col = 0 row += 1 gimp.progress_update(100 * (layer_index + 1) / len(image.layers)) pdb.file_png_save( sheet, sheet_layer, file_path, None, True, # interlace 9, # compression True, # bkgd True, # gama True, # offs True, # phys True, # time ) gimp.message("All frames saved as {}".format(file_path)) finally: pdb.gimp_image_delete(sheet)
def hello_world(): gimp.message("Hello, GIMP world!\n")