def image_tint(im, tint='#ff0000'): src = Image.new('RGB', im.size) src.paste(im) tr, tg, tb = getrgb(tint) tl = getcolor(tint, "L") # tint color's overall luminosity if not tl: tl = 1 # avoid division by zero tl = float(tl) # compute luminosity preserving tint factors sr, sg, sb = map(lambda tv: tv / tl, (tr, tg, tb)) # per component adjustments # create look-up tables to map luminosity to adjusted tint # (using floating-point math only to compute table) luts = (list(map(lambda lr: int(lr * sr + 0.5), range(256))) + list(map(lambda lg: int(lg * sg + 0.5), range(256))) + list(map(lambda lb: int(lb * sb + 0.5), range(256)))) l = grayscale(src) # 8-bit luminosity version of whole image if Image.getmodebands(src.mode) < 4: merge_args = (src.mode, (l, l, l)) # for RGB verion of grayscale else: # include copy of src image's alpha layer a = Image.new("L", src.size) a.putdata(src.getdata(3)) merge_args = (src.mode, (l, l, l, a)) # for RGBA verion of grayscale luts += range(256) # for 1:1 mapping of copied alpha values return Image.merge(*merge_args).point(luts)
def image_tint(src, tint='#fffab5'): if Image.isStringType(src): # file path? src = Image.open(src) if src.mode not in ['RGB', 'RGBA']: raise TypeError('Unsupported source image mode: {}'.format(src.mode)) src.load() tr, tg, tb = getrgb(tint) tl = getcolor(tint, "L") # tint color's overall luminosity if not tl: tl = 1 # avoid division by zero tl = float(tl) # compute luminosity preserving tint factors sr, sg, sb = map(lambda tv: tv/tl, (tr, tg, tb)) # per component # adjustments # create look-up tables to map luminosity to adjusted tint # (using floating-point math only to compute table) luts = (tuple(map(lambda lr: int(lr*sr + 0.5), range(256))) + tuple(map(lambda lg: int(lg*sg + 0.5), range(256))) + tuple(map(lambda lb: int(lb*sb + 0.5), range(256)))) l = grayscale(src) # 8-bit luminosity version of whole image if Image.getmodebands(src.mode) < 4: merge_args = (src.mode, (l, l, l)) # for RGB verion of grayscale else: # include copy of src image's alpha layer a = Image.new("L", src.size) a.putdata(src.getdata(3)) merge_args = (src.mode, (l, l, l, a)) # for RGBA verion of grayscale luts += tuple(range(256)) # for 1:1 mapping of copied alpha values return Image.merge(*merge_args).point(luts)
def image_tint(self, source_path, tint='#ffffff'): ''' Take an image from a path and convert it to a tinted string for sprite coloration. :param source_path: sting path to image :param tint: string color code in hex :return: string of modified image ''' img_source = Image.open(source_path) # Get the image from specified path tint_red, tint_green, tint_blue = getrgb(tint) # Get color tint of each color tint_lum = getcolor(tint, "L") # Tint color luminosity if tint_lum == 0: # Avoid division by 0 tint_lum = 1 tint_lum = float(tint_lum) # Compute luminosity preserving tint factors sr, sg, sb = map(lambda tv: tv / tint_lum, (tint_red, tint_green, tint_blue)) # per component adjustments # create look-up tables to map luminosity to adjusted tint # (using floating-point math only to compute table) luts = (list(map(lambda lr: int(lr * sr + 0.5), range(256))) + list(map(lambda lg: int(lg * sg + 0.5), range(256))) + list(map(lambda lb: int(lb * sb + 0.5), range(256)))) l = grayscale(img_source) # 8-bit luminosity version of whole image if Image.getmodebands(img_source.mode) < 4: merge_args = (img_source.mode, (l, l, l)) # for RGB verion of grayscale else: # include copy of img_source image's alpha layer a = Image.new("L", img_source.size) a.putdata(img_source.getdata(3)) merge_args = (img_source.mode, (l, l, l, a)) # for RGBA verion of grayscale luts += range(256) # for 1:1 mapping of copied alpha values return Image.merge(*merge_args).point(luts) # Return string of image
def image_tint(path: str, tint: str) -> Image: src = Image.open(path) if src.mode not in ("RGB", "RGBA"): raise TypeError(f"Unsupported source image mode: {src.mode}") src.load() tr, tg, tb = getrgb(tint) tl = getcolor(tint, "L") # tint color's overall luminosity if not tl: tl = 1 # avoid division by zero tl = float(tl) # compute luminosity preserving tint factors sr, sg, sb = map(lambda tv: tv / tl, (tr, tg, tb)) # per component # adjustments # create look-up tables to map luminosity to adjusted tint # (using floating-point math only to compute table) luts = (tuple(map(lambda lr: int(lr * sr + 0.5), range(256))) + tuple(map(lambda lg: int(lg * sg + 0.5), range(256))) + tuple(map(lambda lb: int(lb * sb + 0.5), range(256)))) l = grayscale(src) # 8-bit luminosity version of whole image if Image.getmodebands(src.mode) < 4: merge_args: tuple = (src.mode, (l, l, l) ) # for RGB verion of grayscale else: # include copy of src image's alpha layer a = Image.new("L", src.size) a.putdata(src.getdata(3)) merge_args = (src.mode, (l, l, l, a)) # for RGBA verion of grayscale luts += tuple(range(256)) # for 1:1 mapping of copied alpha values image = Image.merge(*merge_args).point(luts) new_image = Image.new("RGBA", image.size, "WHITE") # Create a white rgba background new_image.paste(image, (0, 0), image) return new_image
def image_tint(src, tint='#ffffff'): if Image.isStringType(src): # file path? src = Image.open(src) if src.mode not in ['RGB', 'RGBA']: raise TypeError('Unsupported source image mode: {}'.format(src.mode)) src.load() tr, tg, tb = getrgb(tint) tl = getcolor(tint, "L") # tint color's overall luminosity if not tl: tl = 1 # avoid division by zero tl = float(tl) # compute luminosity preserving tint factors sr, sg, sb = map(lambda tv: tv/tl, (tr, tg, tb)) # per component # adjustments # create look-up tables to map luminosity to adjusted tint # (using floating-point math only to compute table) luts = (tuple(map(lambda lr: int(lr*sr + 0.5), range(256))) + tuple(map(lambda lg: int(lg*sg + 0.5), range(256))) + tuple(map(lambda lb: int(lb*sb + 0.5), range(256)))) l = grayscale(src) # 8-bit luminosity version of whole image if Image.getmodebands(src.mode) < 4: merge_args = (src.mode, (l, l, l)) # for RGB verion of grayscale else: # include copy of src image's alpha layer a = Image.new("L", src.size) a.putdata(src.getdata(3)) merge_args = (src.mode, (l, l, l, a)) # for RGBA verion of grayscale luts += tuple(range(256)) # for 1:1 mapping of copied alpha values return Image.merge(*merge_args).point(luts)
def image_tint(src, tint="#ffffff"): # From https://stackoverflow.com/a/12310820 if src.mode not in ["RGB", "RGBA"]: raise TypeError("Unsupported source image mode: {}".format(src.mode)) src.load() tr, tg, tb = getrgb(tint) tl = getcolor(tint, "L") if not tl: tl = 1 tl = float(tl) sr, sg, sb = map(lambda tv: tv / tl, (tr, tg, tb)) luts = (tuple(map(lambda lr: int(lr * sr + 0.5), range(256))) + tuple(map(lambda lg: int(lg * sg + 0.5), range(256))) + tuple(map(lambda lb: int(lb * sb + 0.5), range(256)))) l = grayscale(src) if Image.getmodebands(src.mode) < 4: merge_args = (src.mode, (l, l, l)) else: a = Image.new("L", src.size) a.putdata(src.getdata(3)) luts += tuple(range(256)) return Image.merge(*merge_args).point(luts)
def get_binary_mask(obj_img, bg_img, bbox, new_w, new_h): bg_mask = Image.new('RGBA', bg_img.size, getcolor('rgba(0,0,0,0)', 'RGBA')) bg_mask.paste(obj_img, bbox, obj_img) bg_mask = bg_mask.resize((new_w, new_h)) mask = np.array(bg_mask)[:, :, -1] / 255 mask = np.rint(mask).astype(int) return mask
def image_tint(image, tint='#ffffff'): """ Function to merge two images without alpha Parameters: image (str): Path to the image tint (str): Hex code for the tint Returns: Image object for further use """ image = image.convert('RGBA') image.load() tr, tg, tb = getrgb(tint) tl = getcolor(tint, "L") # tint color's overall luminosity tl = 1 if not tl else tl # avoid division by zero tl = float(tl) # compute luminosity preserving tint factors sr, sg, sb = map(lambda tv: tv / tl, (tr, tg, tb)) # per component # adjustments # create look-up tables to map luminosity to adjusted tint # (using floating-point math only to compute table) luts = (tuple(map(lambda lr: int(lr * sr + 0.5), range(256))) + tuple(map(lambda lg: int(lg * sg + 0.5), range(256))) + tuple(map(lambda lb: int(lb * sb + 0.5), range(256)))) lum = grayscale(image) # 8-bit luminosity version of whole image if Image.getmodebands(image.mode) < 4: merge_args = (image.mode, (lum, lum, lum) ) # for RGB verion of grayscale else: # include copy of image image's alpha layer a = Image.new("L", image.size) a.putdata(image.getdata(3)) merge_args = (image.mode, (lum, lum, lum, a) ) # for RGBA verion of grayscale luts += tuple(range(256)) # for 1:1 mapping of copied alpha values return Image.merge(*merge_args).point(luts)
from pathlib import Path from sys import setrecursionlimit from PIL.ImageColor import getcolor import bfs, dfs # Folders INPUT_FOLDER = Path('mazes') OUTPUT_FOLDER = Path('solutions') # Maze Solving Algorithm ALGORITHM = bfs # Pixel Color PATH_COLOR = getcolor('red', 'RGB') SEARCH_COLOR = getcolor('gray', 'RGB') # Recursion Limit increase_recursion_limit = False if increase_recursion_limit: setrecursionlimit(9999)
def get_saturation(self, rgb_tuple): try: return getcolor('rgb' + repr(rgb_tuple), 'L') except: print "Bad tuple " + repr(rgb_tuple) return 51
from PIL import ImageDraw from PIL.ImageColor import getcolor config = dict( weizuotu = [ dict( name='rectangle', kwargs=dict( xy=[(x0, y0), (x1, y1)], fill=getcolor((r, g, b)) ) ) ] ) name_to_op = dict( )
for c in range(args.num_x): for i in range(len(lengths)): L = lengths[i] img = Image.open(join(args.source_path, args.input)) hL = L / 2 bbox = (int(cx[c] - hL), int(cy[r] - hL), int(cx[c] + hL), int(cy[r] + hL)) # Place mask or shape depending on args if args.mask is not None: mask = Image.open(join(mask_path, args.mask)) mask = mask.resize((L, L)) img.paste(mask, bbox, mask) else: mask = Image.new('RGBA', (L, L), getcolor('rgba(0,0,0,0)', 'RGBA')) draw = ImageDraw.Draw(mask) draw.ellipse((0, 0, L, L), fill=COLOR) img.paste(mask, bbox, mask) # Get binary mask of object for depth calculations bmask = get_binary_mask(mask, img, bbox, in_w, in_h) # Save the color image img.save(join(color_path, 'color_{}_{}_{}.png'.format(r, c, i))) # Convert to tensor orig_shape = img.size img = img.resize((opts['width'], opts['height'])) input = pilToTensor(img)
def get_saturation(self, rgb_tuple): try: return getcolor('rgb'+repr(rgb_tuple), 'L') except: print "Bad tuple "+repr(rgb_tuple) return 51