def draw_circle_2(img, layer, c_x, c_y, rayon, color): """ draw a plain circle on layer """ start_x = c_x - rayon if c_x - rayon > 0 else 0 start_y = c_y - rayon if c_y - rayon > 0 else 0 width = rayon * 2 height = rayon * 2 print(start_x, start_y, c_x, c_y, width, height) # Make sure this layer supports alpha so we can write to each pixel's # alpha component layer.add_alpha() circle_layer = pdb.gimp_layer_new(img, layer.width, layer.height, RGBA_IMAGE, "circle", 100, LAYER_MODE_NORMAL) pdb.gimp_image_insert_layer(img, circle_layer, None, 0) source_region = layer.get_pixel_rgn(start_x, start_y, width + 1, height + 1, False, False) pixel_size = len(source_region[start_x, start_y]) print("pixel_size:", pixel_size) region = circle_layer.get_pixel_rgn(start_x, start_y, start_x + width + 1, start_y + height + 1, True, True) pixels = array("B", "\x00" * (width * height * pixel_size)) for y in xrange(0, height): for x in xrange(0, width): index = (x + width * y) * pixel_size # pixel = source_pixels[index: index + pixel_size] new_pixel = array('B', [color[0], color[1], color[2], 255]) # Write the modified pixel out to our destination array xx = x - rayon yy = y - rayon a = xx * xx + yy * yy b = rayon * rayon if a <= b: pixels[index:index + pixel_size] = new_pixel # Copy the whole array into the writeable pixel region region[start_x:start_x + width, start_y:start_y + height] = pixels.tostring() # Write our changes back over the original layer circle_layer.flush() circle_layer.merge_shadow(True) circle_layer.update(start_x, start_y, width, height) # merge the circle layer and the background layer new_layer = merge_layer(img, layer, circle_layer) return new_layer
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 paste_in_new_image(image2, ilayer, width, height, offx, offy): # create a new layer in the second image type = RGBA_IMAGE name = "information text {}".format(ilayer + 1) opacity = 100 mode = NORMAL_MODE layer_info = pdb.gimp_layer_new(image2, width, height, type, name, opacity, mode) position = 0 pdb.gimp_image_add_layer(image2, layer_info, position) # paste image drawable = image2.layers[0] paste_into = True floating_sel = pdb.gimp_edit_paste(drawable, paste_into) pdb.gimp_floating_sel_anchor(floating_sel) # move to original visor position pdb.gimp_layer_set_offsets(drawable, offx, offy)
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 halftone_gimp(img, layer, slide_density, slide_circle_size, work_size_flag, work_size_width, revert_size_flag, black_strength, slide_angle): # Obtain layer dimensions. width = layer.width height = layer.height print("original size:", width, height) print("density", slide_density) D = int(slide_density) print("circle size", "slide_circle_size") C = int(slide_circle_size) print("black strength", black_strength) B = int(black_strength) ANGLES = POSSIBLE_ANGLES[int(slide_angle) - 1] print("angles", ANGLES) # New image dimensions if work_size_flag is True: new_width = int(work_size_width) new_height = int(height * (new_width / float(width))) print("new_size:", new_width, new_height) scale_image(img, new_width, new_height) else: new_width = width new_height = height add_cmyk_layers(img, layer) halftone_layers = [None] * 4 for k in range(0, 4): current_layer = find_layer(img, COMPONENT_STRING[k]) rotate_layer(current_layer, ANGLES[k]) halftone_layers[k] = pdb.gimp_layer_new( img, current_layer.width, current_layer.height, RGBA_IMAGE, COMPONENT_STRING[k] + " halftone", 100, MULTIPLY_MODE) pdb.gimp_image_insert_layer(img, halftone_layers[k], None, 0) pdb.gimp_drawable_fill(halftone_layers[k], FILL_WHITE) start = timer() halftone_layer(img, current_layer, halftone_layers[k], D, COLORS[k], C, B) end = timer() print("halftone in ", end - start) rotate_layer(halftone_layers[k], -ANGLES[k]) x0, y0 = pdb.gimp_drawable_offsets(halftone_layers[k]) non_empty, x1, y1, x2, y2 = pdb.gimp_selection_bounds(img) print(x0, y0) print(x1, y1, x2, y2) xx = new_width / 2 - current_layer.width / 2 yy = new_height / 2 - current_layer.height / 2 # print xx, yy pdb.gimp_layer_set_offsets(halftone_layers[k], x0 + xx, y0 + yy) for i_layer in COMPONENT_STRING: del_layer = find_layer(img, i_layer) img.remove_layer(del_layer) for i_layer in img.layers: if i_layer.name.endswith("halftone"): i_layer.visible = False # if revert_size_flag is True: # scale_image(img, width, height) else: i_layer.visible = False for i_layer in img.layers: if i_layer.name.endswith("halftone"): current_layer = pdb.gimp_layer_new(img, new_width, new_height, RGBA_IMAGE, "_" + i_layer.name + "_", 100, MULTIPLY_MODE) pdb.gimp_image_insert_layer(img, current_layer, None, 0) pdb.gimp_rect_select(img, 0, 0, new_width, new_height, 2, 0, 0) pdb.gimp_edit_copy(i_layer) new_layer = pdb.gimp_edit_paste(current_layer, True) pdb.gimp_floating_sel_anchor(new_layer) for i_layer in img.layers: if i_layer.name.endswith("halftone"): print(i_layer.name) img.remove_layer(i_layer) if revert_size_flag is True: scale_image(img, width, height)
def add_cmyk_layers(img, layer): """ decompose layer in cmyk components """ # Obtain layer dimensions. width = layer.width height = layer.height # Make sure this layer supports alpha so we can write to each pixel's alpha # component layer.add_alpha() for k in range(0, 4): # Grab a pixel region (readonly) covering the entire image and copy # pixel data into an array source_region = layer.get_pixel_rgn(0, 0, width, height, False, False) source_pixels = array("B", source_region[0:width, 0:height]) pixel_size = len(source_region[0, 0]) print("pixel_size", pixel_size) # Create component layer in the Image component_layer = pdb.gimp_layer_new(img, width, height, RGBA_IMAGE, COMPONENT_STRING[k], 100, LAYER_MODE_NORMAL) pdb.gimp_image_insert_layer(img, component_layer, None, 0) pdb.gimp_drawable_fill(component_layer, FILL_WHITE) # Create another region (writeable) and an array that can store all # our modified pixels component_region = component_layer.get_pixel_rgn( 0, 0, width, height, True, True) component_pixels = array("B", "\x00" * (width * height * pixel_size)) gimp.progress_init("getting " + COMPONENT_STRING[k] + " component layer...") x = 0 y = 0 # Loop through every pixel in the image/layer for y in xrange(0, (height - 1)): for x in xrange(0, (width - 1)): gimp.progress_update(1.0 * y / height) source_index = (x + width * y) * pixel_size pixel = source_pixels[source_index:source_index + pixel_size] # Write the modified pixel out to our destination array component_pixel = pixel # intensity = 0 if k == 3: # black specific intensity = pixel[k] # intensity = int(round(pixel[0] * 0.2126 + # pixel[1] * 0.7152 + # pixel[2] * 0.0722)) # c_linear = (pixel[0] / 255.0) * 0.2126 # + (pixel[1] / 255.0) * 0.7152 # + (pixel[2] / 255.0) * 0.0722 # intensity = 12.92 * c_linear if c_linear <= 0.0031308 else 1.055 * \ # pow(c_linear, 1/2.4) - 0.055 # intensity = int(round(intensity*255.0)) intensity = int( round(pixel[0] * 0.299 + pixel[1] * 0.587 + pixel[2] * 0.114)) else: intensity = pixel[k] component_pixel[3] = (255 - intensity) component_pixel[0] = COLORS[k][0] component_pixel[1] = COLORS[k][1] component_pixel[2] = COLORS[k][2] component_pixels[source_index:source_index + pixel_size] = component_pixel # Copy the whole array into the writeable pixel region component_region[0:width, 0:height] = component_pixels.tostring() # Write our changes back over the original layer component_layer.flush() component_layer.merge_shadow(True) component_layer.update(0, 0, width, height) pdb.gimp_progress_end() pdb.gimp_displays_flush()