def transform(dir): # Pull a list of all .png files in the CWD image_list = glob.glob(dir + '/*.png') # Iterate through Images and perform 29 mutations of each. for i in image_list: filename, extension = os.path.splitext(i) image = Image.open(i) count = 0 for j in range(-16, 17, 2): for k in range(-16, 17, 2): # invert so backgroud values are 0 new_image = invert(image) # Deform image based on k new_image = deform(new_image, k) # Rotate image based on j new_image = rotate(new_image, j) new_image = new_image.crop(new_image.getbbox()) # invert back new_image = invert(new_image) # Save new mutation to a new file new_filename = filename + "_" + str(count) + extension new_image.save(new_filename) new_image.close() count += 1 image.close() os.remove(filename + extension)
def corner_randomly_transform(image, corner, offset_x=0, offset_y=0, x_radius=CORNER_RADIUS, y_radius=CORNER_RADIUS, angle=0): draft_radius = int(np.sqrt(x_radius**2 + y_radius**2) + 2) # 1. offset real_corner = (corner[0] + offset_x, corner[1] + offset_y) draft_image = image.crop( (real_corner[0] - draft_radius, real_corner[1] - draft_radius, real_corner[0] + draft_radius, real_corner[1] + draft_radius)) # 2. rotate. It fills borders black; so we need invert it twice draft_image = invert(invert(draft_image).rotate(angle, expand=1)) # 3. crop corner corner_image = draft_image.crop((draft_image.size[0] // 2 - x_radius, draft_image.size[1] // 2 - y_radius, draft_image.size[0] // 2 + x_radius, draft_image.size[1] // 2 + y_radius)) # scale return corner_image.resize( (CORNER_FINAL_RADIUS * 2, CORNER_FINAL_RADIUS * 2))
def run_one(fname, outname): N = 1 im = img.open(fname) #im = im.filter(ImageFilter.BLUR) im = im.resize((600, 600), img.ANTIALIAS) im = im.convert('L') im = invert(im) x = np.asarray(im) y = x size = 3 for i in range(N): y = morph.dilate(y, morph.sedisk(size)) y = morph.close(y, morph.sedisk(size)) jm = img.fromarray(y) jm = invert(jm) jm = jm.resize((400, 400), img.ANTIALIAS) jm.save(outname)
def invert_image(image: Image) -> Image: if image.mode == 'RGBA': r, g, b, a = image.split() rgb_image = Image.merge('RGB', (r, g, b)) inverted_image = invert(rgb_image) r2, g2, b2 = inverted_image.split() return Image.merge('RGBA', (r2, g2, b2, a)) else: return invert(image)
def extract_images(img_id, img_dir, size, mode, debug=False): image_path = os.path.join(img_dir, img_id + '.tiff') image = openslide.OpenSlide(image_path) w0, h0 = image.level_dimensions[0] view = size thumbnail = invert(image.get_thumbnail((view, view))) img = np.array(thumbnail).mean(2) w1, h1 = thumbnail.size im = PIL.Image.new('RGB', (size, size)) im.paste( thumbnail, (random.randrange(size + 1 - w1), random.randrange(size + 1 - h1))) num = {32: 24} images = [] if debug: fig, ax = plt.subplots(1) ax.imshow(img) for level, n in num.items(): r = view // level label = skimage.measure.block_reduce(img, (r, r), np.mean) xs, ys = topk(label, level) ll = list(range(level)) if mode == 'train': random.shuffle(ll) ll = ll[:n] pts = [(x, y) for x, y in zip(xs[ll], ys[ll])] for x, y in pts: s0 = max(w0, h0) l = image.get_best_level_for_downsample(s0 // (level * size)) s = max(image.level_dimensions[l]) ix, iy = x * s0 // level, y * s0 // level crop_size = s // level if mode == 'train': t = s0 // level // 4 ix += random.randrange(-t, t) iy += random.randrange(-t, t) crop_size = int( random.uniform(0.8 * crop_size, 1.2 * crop_size)) im = image.read_region((iy, ix), l, (crop_size, crop_size)) if debug: rect = patches.Rectangle((y * r, x * r), r, r, linewidth=1, edgecolor='r', facecolor='none') ax.add_patch(rect) im = invert( im.resize((size, size), PIL.Image.BILINEAR).convert('RGB')) images += [im] if debug: for im in images: plt.figure() plt.imshow(np.array(im)) return images
def packImages(self, red, green, blue, alpha): r = Image.open(red) if red != "" else Image.new( mode="RGB", size=(1, 1), color=self.redDef.get()) g = Image.open(green) if green != "" else Image.new( mode="RGB", size=(1, 1), color=self.greenDef.get()) b = Image.open(blue) if blue != "" else Image.new( mode="RGB", size=(1, 1), color=self.blueDef.get()) if r.mode == "I;16": r.mode = "I" r = r.point(lambda i: i * (1. / 256)) if g.mode == "I;16": g.mode = "I" g = g.point(lambda i: i * (1. / 256)) if b.mode == "I;16": b.mode = "I" b = b.point(lambda i: i * (1. / 256)) if alpha != "": a = Image.open(alpha) if a.mode == "I;16": a.mode = "I" a = a.point(lambda i: i * (1. / 256)) if self.redInvert.get(): r = invert(r.convert("RGB")) if self.greenInvert.get(): g = invert(g.convert("RGB")) if self.blueInvert.get(): b = invert(b.convert("RGB")) if self.alphaInvert.get() and alpha != "": a = invert(a.convert("RGB")) size = max(r.size, g.size, b.size) if alpha == "" else max( r.size, g.size, b.size, a.size) if alpha != "": return Image.merge("RGBA", [ r.resize(size).convert("L"), g.resize(size).convert("L"), b.resize(size).convert("L"), a.resize(size).convert("L") ]) else: return Image.merge("RGB", [ r.resize(size).convert("L"), g.resize(size).convert("L"), b.resize(size).convert("L") ])
def invert_colors(image) -> Image: """ Function to invert colors of an image Parameters: image (str): Path to the image Returns: Image object for further use """ try: image = image.convert('RGBA') r, g, b, a = image.split() rgb_image = Image.merge('RGB', (r, g, b)) inverted_image = invert(rgb_image) r2, g2, b2 = inverted_image.split() final_transparent_image = Image.merge('RGBA', (r2, g2, b2, a)) image = final_transparent_image return image except Exception as exc: print("Error in invert_colors") print(exc) return None
def put_grapheme(canvas, x, y, file_info, name, rotate=False): '''Put a grapheme into a logogram, and write the resulting darknet bounding box annotation.''' canvas_w = canvas.width canvas_h = canvas.height sim = Image.open(file_info['filename']).convert("RGBA") w = sim.width h = sim.height if rotate: if random.random() > 0.5: sim = sim.transpose(Image.FLIP_LEFT_RIGHT) turns = random.randint(0, 4) sim = sim.rotate(turns * 90, resample=Image.BILINEAR, expand=True) if turns % 2 > 0: w, h = h, w if x + w > canvas_w: x -= x + w - canvas_w + 2 if y + h > canvas_h: y -= y + h - canvas_h + 2 # Convert white pixels to transparent sim.putalpha(invert(sim.convert("L"))) canvas.alpha_composite(sim, (x, y)) return { 'tags': file_info['tags'], 'box': [(x + w / 2) / canvas_w, (y + h / 2) / canvas_h, w / canvas_w, h / canvas_h] }
def do_convert(filename, img_out_path): ds = pydicom.dcmread(filename) img_an = ds.AccessionNumber # Debug Info ds_an = ds.AccessionNumber if 'AccessionNumber' in ds else None ds_pi = ds.PhotometricInterpretation if 'PhotometricInterpretation' in ds else None ds_ww = ds.WindowWidth if 'WindowWidth' in ds else None ds_wc = ds.WindowCenter if 'WindowCenter' in ds else None ds_ri = ds.RescaleIntercept if 'RescaleIntercept' in ds else None ds_rs = ds.RescaleSlope if 'RescaleSlope' in ds else None print(filename, "AccNo:", ds_an, "PI:", ds_pi, "WW:", ds_ww, "WC:", ds_wc, "RI:", ds_ri, "RS:", ds_rs) img_out_fullpath = join(img_out_path, img_an + '.png') if not exists(dirname(img_out_fullpath)): try: makedirs(dirname(img_out_fullpath)) except OSError as exc: # Guard against race condition if exc.errno != errno.EEXIST: raise """ #writer.writerow({'Image Index': img_an + '.png', 'No Finding': '1'}) """ img = read_dcm_to_image(ds) small_img = img.resize((1024, 1024)) small_img = small_img.convert('L') # MONOCHROME if ds.PhotometricInterpretation == 'MONOCHROME1': small_img = invert(small_img) small_img.save(img_out_fullpath)
def recover_rotate(self, image: Image, angle: int): """ Rotates the input image back to fit the original image, \ and fills in the parts that are missing due to rotation. Assumes that the angle of rotation is provided, and that the image \ has not been expanded when rotated (i.e. corners have been cut off). Also ssumes that no other modification has been made to the input. :param image: input image :type image: PIL.Image :param angle: the degree that the image was rotated (CCW) :type angle: int :return: the input image modified to match the original image :rtype: PIL.Image """ out = image.rotate(-angle) ''' for coord in product(range(self.original.size[1]), range(self.original.size[0])): if out.getpixel(coord) != 0: out.putpixel(coord, self.original.getpixel(coord)) ''' #mask = out.convert(mode="1",dither=None).convert('L') # insufficient masking mask = out.point(lambda x: 255*int(x>0)) mask = invert(mask).convert('1') out.paste(self.original,mask=mask) return out
def imagefile2array(filename): ''' Returns tuple of (width, height, string_definition). ''' img = Image.open(filename) if img.mode == 'RGBA': img.load() bmp = Image.new("RGB", img.size, (255, 255, 255)) # create new white image r, g, b, a = img.split() bmp = Image.composite(img, bmp, a) # create a composite elif img.mode == 'LA': img.load() bmp = Image.new("RGB", img.size, (255, 255, 255)) # create new white image l, a = img.split() bmp = Image.composite(img, bmp, a) # create a composite else: bmp = img bmp = invert(bmp) bmp = bmp.rotate(-90).transpose(Image.FLIP_LEFT_RIGHT) s = bmp.convert('1').tostring() byte_height = bmp.size[0] / 8 + (bmp.size[0] % 8 > 0) matrix = group(list(s), byte_height) matrix = transpose(matrix) bmp_array = ''.join(['\\x{0:02x}'.format(ord(x)) for x in flatten(matrix)]) return (bmp.size[1], bmp.size[0], bmp_array ) # bitmap was rotated, need to swap width and height
async def invert_user_avatar(self, ctx, *, member: Optional[Member] = None): """Get the inverted avatar of the member""" # Get member mentioned or set to author member = ctx.author if not member else member # Invert the image attach = await member.avatar_url.read() image = Image.open(io.BytesIO(attach)).convert('RGB') inverted = invert(image) # Save new inverted image as bytes file = io.BytesIO() inverted.save(file, format='PNG') file.seek(0) # Send image in an embed f = File(file, "inverted.png") embed = Embed(colour=self.bot.admin_colour, timestamp=datetime.datetime.utcnow()) embed.set_author(name=f"{member}'s Avatar | Inverted", icon_url=member.avatar_url) embed.set_image(url="attachment://inverted.png") embed.set_footer(text=f"Requested by {ctx.author}", icon_url=ctx.author.avatar_url) await ctx.send(file=f, embed=embed)
def invert_image_path(path): image_file = Image.open(path) # open colour image image_file = image_file.convert('L').resize([220, 155]) image_file = invert(image_file) image_array = np.array(image_file) image_array[image_array >= 50] = 255 image_array[image_array < 50] = 0 return image_array
def bw_transform_special(img): #Tratamiento especial para imágenes image = rgb2gray(img) image = invert(image) image = adjust_gamma(image, 2) image = adjust_sigmoid(image, .95) threshold_image = threshold_otsu(image) image = image > threshold_image return image
def data_URL_to_number_array(data_URL): base64_img = data_URL.split(',', 1)[1] img = Image.open(BytesIO(base64.b64decode(base64_img))).convert('L') img = img.resize((20, 20)) img = invert(img) img = ImageOps.autocontrast(img) img = ImageOps.expand(img, border=4) seq = list(img.getdata()) return [[seq[i + 28 * j] for i in range(28)] for j in range(28)]
def generate(args): """ generate puzzle """ def img_to_spr(img): """ split image into 10x10 sprites """ return [ img.crop((x, y, x + 10, y + 10)) for y in range(0, img.size[1], 10) for x in range(0, img.size[0], 10) ] def color_spr(spr, color): """ replace black in sprite with another color """ color = np.array(color) x, y, z = *spr.size, 3 # sprite dimensions spr = np.array(spr).reshape((x * y, z)) # reshape spr = np.hstack([color if sum(p) == 0 else p for p in spr]).reshape( (x, y, z)).astype(np.uint8) # color return Image.fromarray(spr) # ascii characters corresponding to `tileset.png` ascii_chr = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~' # map A-Z -> 1-26 chr_num = dict(zip(ascii_chr[33:59], range(1, 27))) chr_num[' '] = 27 # black letters on white background (by inverting the colours) img = invert(Image.open('tileset.png').convert('1').convert('RGB')) ascii_spr = img_to_spr(img)[32:127] spr = dict(zip(ascii_chr, ascii_spr)) # append padding so width % 3 == 0 if len(args.code) % 3: code = args.code + ' ' * (3 - len(args.code) % 3) else: code = args.code # insert the clue puz = Image.new('RGB', (10 * 3, 10 * (len(code) // 3 + 1))) puz.paste(color_spr(spr['R'], (255, 0, 0)), (0, 0)) # R puz.paste(color_spr(spr['G'], (0, 255, 0)), (10, 0)) # G puz.paste(color_spr(spr['B'], (0, 0, 255)), (20, 0)) # B # create the puzzle for i, char in enumerate(code): x, y = i % 3, i // 3 + 1 # determine the letter position color = np.random.randint(256, size=3) # randomise the RGB values color[x] = chr_num[char] # set the channel to the alphabet number puz.paste(color_spr(spr['RGB'[x]], color), (10 * x, 10 * y)) # insert the code puz.save(args.fname) print("Clue: proper channels") print("Puzzle saved:", args.fname)
def invert_image(image_file): image_file = image_file.convert('L').resize([220, 155]) image_file = invert(image_file) image_array = np.array(image_file) for i in range(image_array.shape[0]): for j in range(image_array.shape[1]): if image_array[i][j] <= 50: image_array[i][j] = 0 else: image_array[i][j] = 255 return image_array
def process_image(img, sig_param=.85): image = rgb2gray(img) image = pyramid_expand(image, order=3) theta = ImageSignalDigitalizer.skew_detect(image) image = rotate(image, np.rad2deg(theta) + ImageSignalDigitalizer.CONST_ANGLE, resize=True) image = invert(image) image = adjust_sigmoid(image, sig_param) image = ImageSignalDigitalizer.bw_transform(image) image = resize(image, (2048, 2048 * 2)) return image
def edge_extract(image: Image, point_from: tuple, point_to: tuple, edge_width: int): edge = image.crop(( min(point_from[0], point_to[0]) - 2 * edge_width, min(point_from[1], point_to[1]) - 2 * edge_width, max(point_from[0], point_to[0]) + 2 * edge_width, max(point_from[1], point_to[1]) + 2 * edge_width, )) vect_edge = np.array(point_from) - np.array(point_to) edge_len = np.linalg.norm(vect_edge) angle = np.arccos(np.dot(vect_edge, [0, 1]) / edge_len) * 180 / np.pi # we don't know if we should rotate on +angle or -angle. # if angle between vect and OX is < 90, then we 'll rotate on +angle; # else, on -angle if np.dot(vect_edge, [1, 0]) < 0: angle = -angle edge = invert(edge) edge = edge.rotate(angle=angle, expand=True) edge = invert(edge) new_center = np.array(edge.size) // 2 edge = edge.crop( (new_center[0] - edge_width / 2, new_center[1] - int(edge_len / 2), new_center[0] + edge_width / 2, new_center[1] + int(edge_len / 2))) return edge
async def _progress(self, percent): image = Image.new("RGB", (self.width, 12)) draw = ImageDraw.Draw(image) draw.pieslice([(3, 3), (11, 11)], start=90, end=270, fill="#fff", outline="#fff") draw.rectangle((5, 3, int((percent * (self.width - 8)) / 100) + 5, 11), outline="#fff", fill="#fff") image = invert(image) return image
def latexToImage(self, formula): image = Image.open(self.ownpnglatex(r"$"+formula+r"$", 'tmpFormula.png')) image = invert(image) image = image.convert("RGBA") datas = image.getdata() newData = [] for item in datas: if item[0] == 0 and item[1] == 0 and item[2] == 0: newData.append((255, 255, 255, 0)) else: newData.append(item) image.putdata(newData) return image
def find_bounds(im_names): print('finding max bounds in {}'.format(im_names)) max_bounds = [ 0, ] * 4 # left, upper, right, lower min_bounds = [ 999999, ] * 4 for im_name in im_names: with Image.open(im_name) as im: bounds = invert(im).getbbox() max_bounds = [max(bounds[i], max_bounds[i]) for i in range(4)] min_bounds = [min(bounds[i], min_bounds[i]) for i in range(4)] return (min(max_bounds[0], min_bounds[0]), min(max_bounds[1], min_bounds[1]), max(max_bounds[2], min_bounds[2]), max(max_bounds[3], min_bounds[3]))
def do_convert(filename, img_out_path, img_out_width=1024, img_out_square=True, use_ori_fname=False): (ori_fname, ori_fname_ext) = os.path.splitext(os.path.basename(filename)) ori_fname = ori_fname + ori_fname_ext if ori_fname_ext.lower() != '.png' else ori_fname ds = pydicom.dcmread(filename) img_an = ds.AccessionNumber # Debug Info ds_an = ds.AccessionNumber if 'AccessionNumber' in ds else None ds_pi = ds.PhotometricInterpretation if 'PhotometricInterpretation' in ds else None ds_ww = ds.WindowWidth if 'WindowWidth' in ds else None ds_wc = ds.WindowCenter if 'WindowCenter' in ds else None ds_ri = ds.RescaleIntercept if 'RescaleIntercept' in ds else None ds_rs = ds.RescaleSlope if 'RescaleSlope' in ds else None ds_uid = ds.SOPInstanceUID if 'SOPInstanceUID' in ds else None #print(filename, "AccNo:", ds_an, "PI:", ds_pi, "WW:", ds_ww, "WC:", ds_wc, "RI:", ds_ri, "RS:", ds_rs, "ori_fname:", ori_fname, "use_ori_fname:", use_ori_fname) out_fname = ds_an if ds_an and not use_ori_fname else ori_fname img_out_fullpath = join(img_out_path, out_fname + '.png') if not exists(dirname(img_out_fullpath)): try: makedirs(dirname(img_out_fullpath)) except OSError as exc: # Guard against race condition if exc.errno != errno.EEXIST: raise try: img = read_dcm_to_image(ds) except: return # calculate resize image width/height img_width, img_height = img.size img_out_width = int(img_out_width) if img_out_square: img_out_height = img_out_width else: img_out_height = int( img_out_width / float(img_width) * float(img_height) ) small_img = img.resize((img_out_width, img_out_height)) small_img = small_img.convert('L') # MONOCHROME if ds.PhotometricInterpretation == 'MONOCHROME1': small_img = invert(small_img) small_img.save(img_out_fullpath)
def convert_img(imagename): image = PIL.Image.open('decos/' + imagename + '.png') image = invert(image) thresh = 200 def fn(x): return 255 if x > thresh else 0 image = image.convert('L').point(fn, mode='1') image = image.filter(ImageFilter.EDGE_ENHANCE_MORE) # inverted_convert.save('images/'+imagename+'-inv.png') pil_image = image.convert('RGB') open_cv_image = array(pil_image) open_cv_image = open_cv_image[:, :, ::-1].copy() return (open_cv_image)
def style_image(image_path, model_path): image = Image.open(image_path) width, height = image.size alpha = image.convert('RGBA').split()[-1] # @TODO - import the mean color... mean_color = Image.new("RGB", image.size, (124, 116, 103)) rgb_image = image.convert('RGB') rgb_image.paste(mean_color, mask=invert(alpha)) cuda_available = torch.cuda and torch.cuda.is_available() device = torch.device("cuda" if cuda_available else "cpu") model = torch.load(model_path, map_location=device) image_filename = os.path.basename(image_path) model_filename = os.path.basename(model_path) model_name = os.path.splitext(model_filename)[0] os.makedirs(f"images/outputs/{model_name}", exist_ok=True) transform = style_transform() # Define model and load model checkpoint transformer = TransformerNet().to(device) transformer.load_state_dict(model) transformer.eval() # Prepare input image_tensor = Variable(transform(rgb_image)).to(device) image_tensor = image_tensor.unsqueeze(0) # Stylize image with torch.no_grad(): output_tensor = depro(transformer(image_tensor)) stylized_image = F.to_pil_image(output_tensor) \ .convert('RGBA') \ .crop((0, 0, width, height)) stylized_image.putalpha(alpha) stylized_image.save(f"images/outputs/{model_name}/{image_filename}", 'PNG')
def do_predict(models, path): results = [] ds, img = read_dcm_to_image(path) acc_no = ds.get('AccessionNumber', None) for model in models: # check if exists model_name = model.model_name model_ver = model.model_ver weight_name = model.weight_name weight_ver = model.weight_ver category = model.category global _use_db if _use_db: is_exist = check_if_pred_exists(acc_no, model_name, model_ver, weight_name, weight_ver, category) if is_exist: print("{} {} {} exists, skip.".format(acc_no, model_name, weight_name)) continue small_img = img.resize((model.width, model.height)) small_img = small_img.convert('L') # MONOCHROME if ds.PhotometricInterpretation == 'MONOCHROME1': small_img = invert(small_img) #exam_time = ds.get('AcquisitionDate', None) small_img_arr = np.array(small_img.convert('RGB')) prob = predict_image(small_img_arr, model.obj) result = { 'acc_no': acc_no, 'model_name': model_name, 'model_ver': model_ver, 'weight_name': weight_name, 'weight_ver': weight_ver, 'category': category, 'probability': prob[0][0] } results.append(result) return results
async def invert(self, ctx): """Display inverted version of image uploaded""" if ctx.message.attachments: for attachments in ctx.message.attachments: attach = await attachments.read() image = Image.open(io.BytesIO(attach)).convert('RGB') inverted = invert(image) # Save new grayscale image as bytes file = io.BytesIO() inverted.save(file, format='PNG') file.seek(0) await ctx.message.delete() # Send Grayscale Image await ctx.send(file=discord.File(file, "inverted.png")) else: await self.bot.generate_embed(ctx, desc="**Image Not Detected!**")
def get_name(img): img_arr = np.asarray(img) h, w, ch = img_arr.shape img_arr = img_arr[:h // 2, w // 2:] blue_mask = infer_blue_mask(img_arr) uy, ly, lx, rx = max_length_rectangle(blue_mask) # TODO certain blue color img_arr = img_arr[uy:ly, lx:rx] white_mask = infer_white_mask(img_arr) uy, ly, lx, rx = max_length_rectangle(white_mask) name_img = Image.fromarray(img_arr[:, :lx]) name_img = invert(name_img).convert('L') name = pytesseract.image_to_string(name_img, lang='eng', config='--psm 7') name = name.split('\n')[0] # TODO no name found return name
def load_cropped_image(src_path, output_size, grey_scale, invert_color=False): def _crop_background(numpy_src): def _get_vertex(img): index = 0 for i, items in enumerate(img): if items.max() != 0: # activate where background is '0' index = i break return index numpy_src_y1 = _get_vertex(numpy_src) numpy_src_y2 = len(numpy_src) - _get_vertex(np.flip(numpy_src, 0)) numpy_src_x1 = _get_vertex(np.transpose(numpy_src)) numpy_src_x2 = len(numpy_src[0]) - _get_vertex( np.flip(np.transpose(numpy_src), 0)) return numpy_src_x1, numpy_src_y1, numpy_src_x2, numpy_src_y2 if grey_scale: src_image = Image.open(src_path, 'r').convert('L') if invert_color: src_image = invert(src_image) # invert color numpy_image = np.asarray(src_image.getdata(), dtype=np.float64).reshape( (src_image.size[1], src_image.size[0])) numpy_image = np.asarray( numpy_image, dtype=np.uint8) # if values still in range 0-255 pil_image = Image.fromarray(numpy_image, mode='L') x1, y1, x2, y2 = _crop_background(numpy_image) pil_image = pil_image.crop((x1, y1, x2, y2)) pil_image = pil_image.resize([output_size, output_size]) else: pil_image = Image.open(src_path, 'r') return pil_image
def recolor(o_path, t_path, r_path): path = Path(__file__).resolve().parent.joinpath(o_path) texpath = Path(__file__).resolve().parent.joinpath(t_path) savepath = Path(__file__).resolve().parent.joinpath(r_path) image = invert(Image.open(path)).convert('HSV') texture = Image.open(texpath).resize(image.size).convert('HSV') data = image.load() texdata = texture.load() for i in range(image.size[0]): for j in range(image.size[1]): xy = (i, j) pixel = (texdata[i, j][0], texdata[i, j][1], data[i, j][2]) image.putpixel(xy, pixel) image.convert('RGB').save(savepath) original_image = mpimg.imread(path) texture_image = mpimg.imread(texpath) resulting_image = mpimg.imread(savepath)