def __call__(self, img, grnd): if random.random() < 0.5: img = img.filter(ImageFilter.GaussianBlur(radius=random.random())) return img, grnd
width=random.randint(1, 4), joint='curve') drawable_image.line(points3, fill=(180, 180, 180, random.randint(100, 255)), width=random.randint(1, 4), joint='curve') drawable_image.line(points4, fill=(180, 180, 180, random.randint(100, 255)), width=random.randint(1, 4), joint='curve') drawable_image.line(points5, fill=(180, 180, 180, random.randint(100, 255)), width=random.randint(1, 4), joint='curve') drawable_image.line(points6, fill=(180, 180, 180, random.randint(100, 255)), width=random.randint(1, 4), joint='curve') drawable_image.line(points7, fill=(180, 180, 180, random.randint(100, 255)), width=random.randint(1, 4), joint='curve') drawable_image.line(points8, fill=(180, 180, 180, random.randint(100, 255)), width=random.randint(1, 4), joint='curve') out = Image.alpha_composite(new_image, base) converted_out = out.convert("LA") blured = converted_out.filter(ImageFilter.GaussianBlur(radius=2)) blured = blured.filter(ImageFilter.SHARPEN) blured.show()
import numpy as np ##Imagen de muestra en el mismo directorio del archivo RGB = np.array(io.imread("balloon.jpg")) RGB2 = PIL.Image.open("jakob-nielsen-thumbs-up.jpg") LAB = np.array(color.rgb2lab(RGB2)) HSV = np.array(color.rgb2hsv(RGB2)) ##Aplicamos los filtros gaussianos y almacenamos en variables GAUSSIAN_KERNELS = [1, 3, 5] #RGB1 = filters.gaussian(RGB,GAUSSIAN_KERNELS[0]) RGB2 = RGB2.filter(ImageFilter.GaussianBlur(GAUSSIAN_KERNELS[1])) RGB2.save('blurred.png', 'png') #RGB3 = filters.gaussian(RGB,GAUSSIAN_KERNELS[2]) # #LAB1 = filters.gaussian(LAB,GAUSSIAN_KERNELS[0]) LAB2 = filters.gaussian(LAB, GAUSSIAN_KERNELS[1]) #LAB3 = filters.gaussian(LAB,GAUSSIAN_KERNELS[2]) # #HSV1 = filters.gaussian(HSV,GAUSSIAN_KERNELS[0]) HSV2 = filters.gaussian(HSV, GAUSSIAN_KERNELS[1]) #HSV3 = filters.gaussian(HSV,GAUSSIAN_KERNELS[2]) import foreground_estimation import bayesian
unlabeledset = torchvision.datasets.STL10(root='./data', split='unlabeled', download=True, transform=transform) unlabeledloader = torch.utils.data.DataLoader(unlabeledset, batch_size=4, shuffle=False, num_workers=2) print(type(unlabeledset.__getitem__(10)[0])) print(len(unlabeledset.__getitem__(10)[0])) print(unlabeledset.__getitem__(10)[1]) conv = transforms.ToPILImage() unconv = transforms.ToTensor() a = unlabeledset.__getitem__(10)[0] / 2. + 0.5 a = conv(a) a = a.filter(ImageFilter.GaussianBlur(radius=0.1)) b = unconv(a) print(type(a)) print(type(b)) a.show() imshow(b)
def __call__(self, x): sigma = random.uniform(self.sigma[0], self.sigma[1]) x = x.filter(ImageFilter.GaussianBlur(radius=sigma)) return x
def blurr(self, degree): self.image = self.image.filter(ImageFilter.GaussianBlur(radius=degree)) return self
def to_image(self): return self.img.filter(ImageFilter.GaussianBlur(self.blur_radius))
def generate( cls, index, text, font, out_dir, size, extension, skewing_angle, random_skew, blur, random_blur, background_type, distorsion_type, distorsion_orientation, is_handwritten, name_format, width, alignment, text_color, orientation, space_width, character_spacing, margins, fit, output_mask, word_split, image_dir, stroke_width=0, stroke_fill="#282828", image_mode="RGB", ): image = None margin_top, margin_left, margin_bottom, margin_right = margins horizontal_margin = margin_left + margin_right vertical_margin = margin_top + margin_bottom ########################## # Create picture of text # ########################## if is_handwritten: if orientation == 1: raise ValueError("Vertical handwritten text is unavailable") image, mask = handwritten_text_generator.generate(text, text_color) else: image, mask = computer_text_generator.generate( text, font, text_color, size, orientation, space_width, character_spacing, fit, word_split, stroke_width, stroke_fill, ) random_angle = rnd.randint(0 - skewing_angle, skewing_angle) rotated_img = image.rotate( skewing_angle if not random_skew else random_angle, expand=1) rotated_mask = mask.rotate( skewing_angle if not random_skew else random_angle, expand=1) ############################# # Apply distorsion to image # ############################# if distorsion_type == 0: distorted_img = rotated_img # Mind = blown distorted_mask = rotated_mask elif distorsion_type == 1: distorted_img, distorted_mask = distorsion_generator.sin( rotated_img, rotated_mask, vertical=(distorsion_orientation == 0 or distorsion_orientation == 2), horizontal=(distorsion_orientation == 1 or distorsion_orientation == 2), ) elif distorsion_type == 2: distorted_img, distorted_mask = distorsion_generator.cos( rotated_img, rotated_mask, vertical=(distorsion_orientation == 0 or distorsion_orientation == 2), horizontal=(distorsion_orientation == 1 or distorsion_orientation == 2), ) else: distorted_img, distorted_mask = distorsion_generator.random( rotated_img, rotated_mask, vertical=(distorsion_orientation == 0 or distorsion_orientation == 2), horizontal=(distorsion_orientation == 1 or distorsion_orientation == 2), ) ################################## # Resize image to desired format # ################################## # Horizontal text if orientation == 0: new_width = int( distorted_img.size[0] * (float(size - vertical_margin) / float(distorted_img.size[1]))) resized_img = distorted_img.resize( (new_width, size - vertical_margin), Image.ANTIALIAS) resized_mask = distorted_mask.resize( (new_width, size - vertical_margin), Image.NEAREST) background_width = width if width > 0 else new_width + horizontal_margin background_height = size # Vertical text elif orientation == 1: new_height = int( float(distorted_img.size[1]) * (float(size - horizontal_margin) / float(distorted_img.size[0]))) resized_img = distorted_img.resize( (size - horizontal_margin, new_height), Image.ANTIALIAS) resized_mask = distorted_mask.resize( (size - horizontal_margin, new_height), Image.NEAREST) background_width = size background_height = new_height + vertical_margin else: raise ValueError("Invalid orientation") ############################# # Generate background image # ############################# if background_type == 0: background_img = background_generator.gaussian_noise( background_height, background_width) elif background_type == 1: background_img = background_generator.plain_white( background_height, background_width) elif background_type == 2: background_img = background_generator.quasicrystal( background_height, background_width) else: background_img = background_generator.image( background_height, background_width, image_dir) background_mask = Image.new("RGB", (background_width, background_height), (0, 0, 0)) ############################# # Place text with alignment # ############################# new_text_width, _ = resized_img.size if alignment == 0 or width == -1: background_img.paste(resized_img, (margin_left, margin_top), resized_img) background_mask.paste(resized_mask, (margin_left, margin_top)) elif alignment == 1: background_img.paste( resized_img, (int(background_width / 2 - new_text_width / 2), margin_top), resized_img, ) background_mask.paste( resized_mask, (int(background_width / 2 - new_text_width / 2), margin_top), ) else: background_img.paste( resized_img, (background_width - new_text_width - margin_right, margin_top), resized_img, ) background_mask.paste( resized_mask, (background_width - new_text_width - margin_right, margin_top), ) ####################### # Apply gaussian blur # ####################### gaussian_filter = ImageFilter.GaussianBlur( radius=blur if not random_blur else rnd.randint(0, blur)) final_image = background_img.filter(gaussian_filter) final_mask = background_mask.filter(gaussian_filter) ############################################ # Change image mode (RGB, grayscale, etc.) # ############################################ final_image = final_image.convert(image_mode) final_mask = final_mask.convert(image_mode) ##################################### # Generate name for resulting image # ##################################### # We remove spaces if space_width == 0 if space_width == 0: text = text.replace(" ", "") if name_format == 0: image_name = "{}_{}.{}".format(text, str(index), extension) mask_name = "{}_{}_mask.png".format(text, str(index)) elif name_format == 1: image_name = "{}_{}.{}".format(str(index), text, extension) mask_name = "{}_{}_mask.png".format(str(index), text) elif name_format == 2: image_name = "{}.{}".format(str(index), extension) mask_name = "{}_mask.png".format(str(index)) else: print("{} is not a valid name format. Using default.".format( name_format)) image_name = "{}_{}.{}".format(text, str(index), extension) mask_name = "{}_{}_mask.png".format(text, str(index)) # Save the image if out_dir is not None: name = uuid.uuid4().hex + '.' + extension final_image.save(os.path.join(out_dir, name)) #print(np.array(final_image)) if output_mask == 1: final_mask.save(os.path.join(out_dir, mask_name)) else: if output_mask == 1: return final_image, final_mask return final_image, name
def process(self, image_width, image_height, image_translate_x, image_translate_y, image_flip_x, image_flip_y, image_rotate_degree, image_contrast, image_brightness, image_blur, image_saturate, image_opacity, frame_width, frame_height): """ Run process operations under image and return edited image path. If USE_CACHE is enabled and cache exists, method returns cached image path. :Args: - self (:class:`BkImageEditor`): BkImageEditor instance. - image_width (:class:`int`): Resize image to selected width. - image_height (:class:`int`): Resize image to selected height. - image_translate_x (:class:`int`): Move image by X axis. 0:0 is frame left top corner. - image_translate_y (:class:`int`): Move image by Y axis. 0:0 is frame left top corner. - image_flip_x (:class:`bool`): Flip image X axis. - image_flip_y (:class:`bool`): Flip image Y axis. - image_rotate_degree (:class:`int`): Rotate image degree. - image_contrast (:class:`int`): Image contrast level. - image_brightness (:class:`int`): Image brightness level. - image_blur (:class:`int`): Image blur level. - image_saturate (:class:`int`): Image saturate level. - image_opacity (:class:`int`): Image opacity level. - frame_width (:class:`int`): Frame/crop area width. - frame_height (:class:`int`): Frame/crop area height. :Returns: Path to edited image """ self._image_width = image_width self._image_height = image_height self._image_translate_x = image_translate_x self._image_translate_y = image_translate_y self._image_flip_x = image_flip_x self._image_flip_y = image_flip_y self._image_rotate_degree = image_rotate_degree self._image_contrast = image_contrast self._image_brightness = image_brightness self._image_blur = image_blur self._image_saturate = image_saturate self._image_opacity = image_opacity self._frame_width = frame_width self._frame_height = frame_height output_filepath = os.path.join(self._cache_folder, self.output_filename) # cache folder if not os.path.exists(self._cache_folder): # folder can be created by another process between os.path.exists and os.makedirs try: os.makedirs(self._cache_folder) except OSError: pass if self.USE_CACHE: if os.path.exists(output_filepath): return output_filepath try: # converted to have an alpha layer pil_region = self._input_image_file.convert( self._input_image_file.mode) # try to get icc profile try: icc_profile = self._input_image_file.info.get("icc_profile") except: icc_profile = None # resize image (not frame) pil_region = pil_region.resize( (self._image_width, self._image_height), Image.ANTIALIAS) # scale image (flip) if self._image_flip_x: pil_region = pil_region.transpose(Image.FLIP_LEFT_RIGHT) if self._image_flip_y: pil_region = pil_region.transpose(Image.FLIP_TOP_BOTTOM) # rotate image if self._image_rotate_degree != 0: pil_region = pil_region.rotate(self._image_rotate_degree) # apply frame cropping if self._image_rotate_degree in (-270, -90, 90, 270): xsize, ysize = self._image_width, self._image_height # initial image left-top coordiantes relatively to the frame x, y = self._image_translate_x, self._image_translate_y # image center coordinates xc = x + xsize / 2 yc = y + ysize / 2 # rotate degree rotate_deg = self._image_rotate_degree rotate_radians = math.radians(rotate_deg) # calculate left-top image coordinates (relatively to the frame) after rotation # used formula: # X = x0 + (x - x0) * cos(a) - (y - y0) * sin(a) # Y = y0 + (y - y0) * cos(a) + (x - x0) * sin(a) x1 = xc + (x - xc) * math.cos(rotate_radians) - ( y - yc) * math.sin(rotate_radians) y1 = yc + (y - yc) * math.cos(rotate_radians) + ( x - xc) * math.sin(rotate_radians) if rotate_deg in (-270, 90): x1 -= ysize # -90, 270 else: y1 -= xsize frame = (int(x1) * (-1), int(y1) * (-1), int(x1) * (-1) + self._frame_width, int(y1) * (-1) + self._frame_height) else: frame = (self._image_translate_x * (-1), self._image_translate_y * (-1), self._image_translate_x * (-1) + self._frame_width, self._image_translate_y * (-1) + self._frame_height) pil_region = pil_region.crop(frame) # contrast contr = ImageEnhance.Contrast(pil_region) pil_region = contr.enhance(self._image_contrast) # brightness brightness = ImageEnhance.Brightness(pil_region) pil_region = brightness.enhance(self._image_brightness) # saturate saturate = ImageEnhance.Color(pil_region) pil_region = saturate.enhance(self._image_saturate) # blur # TODO test this part one more time pil_region = pil_region.filter( ImageFilter.GaussianBlur(self._image_blur)) if icc_profile: pil_region.save(output_filepath, quality=self.QUALITY, dpi=(self.DPI, self.DPI), icc_profile=icc_profile) else: pil_region.save(output_filepath, quality=self.QUALITY, dpi=(self.DPI, self.DPI)) return output_filepath except (IOError, Exception) as e: logger.exception("BkImageEditor: {}. Image: {}".format( e.message, self._input_image_file)) return None
def Blur(path): img = Image.open(path) img_blur = img.filter(ImageFilter.GaussianBlur(2)) img_blur.save('a1.png') pat = 'a1.png' display(pat)
from PIL import Image, ImageFilter import os size = (725, 480) for i in os.listdir('.'): if i.endswith('.jfif'): image = Image.open(i) fileName, File_ext = os.path.splitext(i) print('{} and {}'.format(fileName, File_ext)) image.thumbnail( size) #this will helps to resize the image into 500,500 pixel image.save('Kohli png/{}.png'.format(fileName)) show_image = Image.open('kohli1.jpg') #show image show_image.show() rotate_image = Image.open( 'kohli2.jpg') #see the current directory(rotate an image into 90 deg) rotate_image.rotate(90).save('kohli2_90.jpg') bw_image = Image.open('kohli3.jpg') #grayscale image bw_image.convert(mode="L").save('kohli3_b&w.jpg') blur_image = Image.open('kohli4.jpg') #blur image blur_image.filter(ImageFilter.GaussianBlur(2)).save('kohli4_blur.jpg')
def execute_on(self, *args, **kwargs): super(TransformationGaussianBlur, self).execute_on(*args, **kwargs) return self.image.filter(ImageFilter.GaussianBlur(radius=self.radius))
image.save("kuş2.jpg") image.rotate(180).save("kuş3.jpg") image.rotate(90).save("kuş4.jpg") image.convert(mode="L").save("kuş5.jpg") degistir = (960, 600) image.thumbnail(degistir) image.save("kuş6.jpg") image.filter(ImageFilter.GaussianBlur(10)).save("kuş8.jpg") kırpılacak_alan = (340, 0, 950, 600) image2 = Image.open("atatürk.jpg") image2.crop(kırpılacak_alan).save("kuş9.jpg") # image.show() # image1.save("kuş2.jpg") # image1.rotate(180).save("kuş2.jpg") # image1.convert(mode = 'L').save("kuş2.jpg") # image1.thumbnail((300,300))
def captcha_to_string(img): rgb_dict = defaultdict(int) ans = "" # show_image(img) pix = img.load() width = img.size[0] height = img.size[1] for x in range(width): for y in range(height): res_code = validation(width, height, x, y, pix) if res_code == 1: for dx, dy in [(1, 0), (0, 1), (-1, 0), (0, -1)]: nx, ny = x + dx, y + dy rgb_dict[pix[nx, ny]] += 10 rgb_dict[pix[x, y]] += 10 elif res_code == 3: rgb_dict[pix[x, y]] += 1 else: img.putpixel((x, y), (255, 255, 255)) # show_image(img) rank = sorted(rgb_dict.items(), key=lambda k_v: k_v[1]) color_set = set([colr[0] for colr in rank[-4:]]) pix = img.load() for x in range(width): for y in range(height): p = (255, 255, 255) if pix[x, y] not in color_set else (0, 0, 0) img.putpixel((x, y), p) # phase2 = "phase2_" + filename # img.save(phase2) # show_image(img) # cut image vertically for recognition left = right = top = 0 bottom = height - 1 is_white = True is_char = False for x in range(width): for y in range(height): rgb = pix[x, y][:3] if y == 0: is_white = True elif rgb == (0, 0, 0): is_white = False if not is_white and not is_char: is_char = True left = x - 3 if is_char and is_white: is_char = False right = x + 3 c_img = img.crop((left, top, right, bottom)) c_img = c_img.resize((c_img.size[0] * 2, c_img.size[1] * 2)) c_img = c_img.filter(ImageFilter.GaussianBlur(radius=1)) # show_image(c_img) char = refine( pytesseract.image_to_string(c_img, lang='eng', config='--psm 7')) ans += char return ans
def filter(b64_img, filter_type): censor_str = Censor.censor logo_str = Logo.logo meta_data = b64_img[0:b64_img.index(',') + 1] img, info = convert_from_b64(b64_img) width, height = img.size #applies a black and white filter over the image if filter_type == 'black_and_white': img = img.convert('L') #applies a sepia filter over the image elif filter_type == 'sepia': sepia = make_linear_ramp() img = img.convert('L') img.putpalette(sepia) img = img.convert('RGB') #applies a blur to the image and adds a 'censored' image on top elif filter_type == 'censor': img = img.filter(ImageFilter.GaussianBlur(10)) censor_img = Image.open( BytesIO(b64decode(censor_str[censor_str.index(',') + 1:]))) censor_img = censor_img.resize((width, int(height / 5))) img.paste(censor_img, (0, int(height * 2 / 5))) #splits the image and half and shows the mirror image elif filter_type == 'mirror': for i in range(int(width / 2)): for j in range(height): img.putpixel((i, j), img.getpixel((width - i - 1, j))) #rotates image by 90 degrees counter clockwise elif filter_type == 'rotate_cc': img = img.rotate(90) #flips the image to show the 'opposite' verision elif filter_type == 'flip': img = img.transpose(Image.FLIP_LEFT_RIGHT) #applies several provided ImageFilter's to make the image seem a forgotten memory elif filter_type == 'blocked_out': img = img.filter(ImageFilter.CONTOUR) img = img.filter(ImageFilter.SHARPEN) img = img.filter(ImageFilter.DETAIL) img = img.filter(ImageFilter.SMOOTH) img = img.filter(ImageFilter.FIND_EDGES) #changes the color space from rgb to xyz elif filter_type == 'feeling_green': mat = (0.412453, 0.357580, 0.180423, 0, 0.212671, 0.715160, 0.072169, 0, 0.019334, 0.119193, 0.950227, 0) img = img.convert("RGB", mat) #applies a jester hat logo on the bottom right corner of the image elif filter_type == 'joker_logo': logo_img = Image.open( BytesIO(b64decode(logo_str[logo_str.index(',') + 1:]))) position = ((img.width - logo_img.width), (img.height - logo_img.height)) img.paste(logo_img, position, logo_img) #swaps color channels blue and red elif filter_type == 'swap_blue_red': r, g, b = img.split() img = Image.merge('RGB', (b, g, r)) #negate the image using ImageOps elif filter_type == 'forgotten_memory': img = ImageOps.invert(img) #apply a black border around the image elif filter_type == 'border_black': img = ImageOps.expand(img, border=50, fill='black') img = img.resize((width, height)) #apply a gold border around the image elif filter_type == 'border_gold': img = ImageOps.expand(img, border=50, fill='#FFD700') img = img.resize((width, height)) #blurs the perimeter of the image elif filter_type == 'border_blur': RADIUS = 20 perim = 2 * RADIUS back = Image.new('RGB', (width + perim, height + perim), (255, 255, 255)) back.paste(img, (RADIUS, RADIUS)) mask = Image.new('L', (width + perim, height + perim), 255) blck = Image.new('L', (width - perim, height - perim), 0) mask.paste(blck, (perim, perim)) blur = back.filter(ImageFilter.GaussianBlur(RADIUS / 2)) back.paste(blur, mask=mask) img = back img = img.resize((width, height)) #add text to image elif filter_type == 'quote_it': draw = ImageDraw.Draw(img) font1 = ImageFont.truetype('app/filterfonts/Roboto-BoldItalic.ttf', size=35) font2 = ImageFont.truetype('app/filterfonts/Roboto-Thin.ttf', size=40) font3 = ImageFont.truetype('app/filterfonts/Satisfy-Regular.ttf', size=40) font4 = ImageFont.truetype( 'app/filterfonts/JustAnotherHand-Regular.ttf', size=40) font5 = ImageFont.truetype('app/filterfonts/Schoolbell-Regular.ttf', size=40) font6 = ImageFont.truetype('app/filterfonts/Tinos-Regular.ttf', size=40) font = random.choice([font1, font2, font3, font4, font5, font6]) quotes = "Don't cry because it's over, smile because it happened.",\ "Not my circus, not my monkeys.",\ "Goals transform a random walk into a chase.",\ "WE LOVE TRELLO.",\ "Why are you dressed like someone died?",\ "Life Saving Tip: Do not eat erasers. Even if they smell like Japanese blue soda candy!",\ "YOU'RE*",\ "Can you get in done by tonight?",\ "I red dictionaries durig my childhood, thas why i splle goo",\ "I love deadlines. I love the whooshing noise they make as they go by." quote = random.choice(quotes) x, y = font.getsize(quote) white_text = 'rgb(255,255,255)' black_text = 'rgb(0, 0, 0)' gold_text = 'rgb(255, 215, 0)' steel_blue_text = 'rgb(176, 196, 222)' color = random.choice( [white_text, black_text, gold_text, steel_blue_text]) quote = textwrap.fill(quote, width=35) draw.text(((width - x) / width, (height - y) / 2), quote, fill=color, font=font) return convert_to_b64(img, meta_data)
break if n >= n_max: break for i in range(1, n + 1): if 0 in [ pixb[x + i, y + n], pixb[x + i, y - n], pixb[x - i, y + n], pixb[x - i, y - n], pixb[x + n, y + i], pixb[x + n, y - i], pixb[x - n, y + i], pixb[x - n, y - i] ]: flag = False l = sqrt(n**2 + i**2) a = (1 - l / n_max) / 2 if result_bit == sourse_bit: b1 = b0 else: b1 = int(r_end * (0.5 + (b0 - s_mid) / (2 * max(abs(b_min), b_max)))) x1 = x - img0.size[0] / 2 if 0 <= x1 < img0.size[0]: draw_surf.point((x1, y), b1) draw_mask.point((x1, y), int(a * r_end)) p = x * 200 / img0.size[0] if p % 5 < 0.01: print(str(int(p / 4)) + " %") img1.paste(back, (0, 0), mask) img1_blur = img1.filter(ImageFilter.GaussianBlur(n_max)) img1.paste(img1_blur, (0, 0), mask) img1.save(save_path) print("100 %")
def postprocess(outputs, ctx): num_detection = int(outputs['num_detections'][0]) def return_original(): image_bytes = io.BytesIO() ctx.image.save(image_bytes, format='PNG') outputs['output'] = image_bytes.getvalue() return outputs if num_detection < 1: return return_original() width = ctx.image.size[0] height = ctx.image.size[1] image_area = width * height detection_boxes = outputs["detection_boxes"][0][:num_detection] detection_boxes = detection_boxes * [height, width, height, width] detection_boxes = detection_boxes.astype(np.int32) # detection_scores = outputs["detection_scores"][0][:num_detection] detection_classes = outputs["detection_classes"][0][:num_detection] detection_masks = outputs["detection_masks"][0][:num_detection] masks = [] for i in range(num_detection): if int(detection_classes[i]) not in ctx.object_classes: continue mask_image = Image.fromarray(detection_masks[i]) box = detection_boxes[i] mask_image = mask_image.resize((box[3] - box[1], box[2] - box[0]), ctx.interpolation) box_mask = np.array(mask_image) box_mask = np.pad(box_mask, ((box[0], height - box[2]), (box[1], width - box[3])), 'constant') area = int(np.sum(np.greater_equal(box_mask, ctx.pixel_threshold).astype(np.int32))) if area * 100 / image_area < ctx.area_threshold: continue masks.append((area, box_mask)) if len(masks) < 1: return return_original() masks = sorted(masks, key=lambda row: -row[0]) total_mask = np.zeros((height, width), np.float32) for i in range(min(len(masks), ctx.max_objects)): total_mask = np.maximum(total_mask,masks[i][1]) if ctx.image_filter == 0: mask = np.less(total_mask, ctx.pixel_threshold) image = np.array(ctx.image) image = np.dstack((image, np.ones((height, width)) * 255)) image[mask] = 0 image = Image.fromarray(np.uint8(image)) elif ctx.image_filter == 5: #mask = np.less(total_mask, ctx.pixel_threshold) #total_mask[mask] = 0 total_mask = total_mask*255 image = Image.fromarray(np.uint8(total_mask)) else: mask = np.greater_equal(total_mask, ctx.pixel_threshold) image = np.array(ctx.image) objects = image[mask] radius = min(max(ctx.blur_radius,2),10) image = ctx.image.filter(ImageFilter.GaussianBlur(radius=radius)) image = np.array(image) image[mask] = objects image = Image.fromarray(np.uint8(image)) image_bytes = io.BytesIO() image.save(image_bytes, format='PNG') outputs['output'] = image_bytes.getvalue() return outputs
scaled_im = im.resize((w,h)) st.image(scaled_im) if sv: scaled_im.save('output.png',format='png') deg = st.slider('degrees',min_value==0,max_value=360) svr = st.checkbox('save rotated image?') if st.button('rotate image') and im: rot_img = img.rotate(deg,fillcolor=colr) st.image(rot_img) if svr: rot_img.save('rotated.png',format='png') if st.checkbox('show filters'): cols = st.beta_column(3) with cols[0]: st.image(im.filter(ImageFilter.EMBOSS,use_column_width=True)) with cols[1]: st.image(im.filter(ImageFilter.CONTOUR),use_column_width=True) with cols[2]: st.image(im.filter(ImageFilter.GaussianBlur(10)),use_column_width=True) cols = st.beta_column(3) with cols[0]: st.image(im.filter(ImageFilter.MinFilter,use_column_width=True)) with cols[1]: st.image(im.filter(ImageFilter.MaxFilter),use_column_width=True) with cols[2]: st.image(im.filter(ImageFilter.MedianFilter(7)),use_column_width=True)
def to_image(self, flip=False): if flip: return self.img.transpose(Image.FLIP_LEFT_RIGHT).filter(ImageFilter.GaussianBlur(self.blur_radius)) else: return self.img.filter(ImageFilter.GaussianBlur(self.blur_radius))
def gblur_patches(Iclean): Pclean = getPatchesDict(Iclean, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) idx = Pclean.shape[0] x_clean = np.zeros((13 * idx, 32, 32, 3)) x_dist = np.zeros((13 * idx, 32, 32, 3)) im = Image.fromarray(np.uint8(Iclean)) # No distortion Pdist = Pclean x_clean[0:idx, :, :, :] = Pclean x_dist[0:idx, :, :, :] = Pdist # Distortion level 1 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=0.5))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[idx:2 * idx, :, :, :] = Pclean x_dist[idx:2 * idx, :, :, :] = Pdist # Distortion level 2 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=1))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[2 * idx:3 * idx, :, :, :] = Pclean x_dist[2 * idx:3 * idx, :, :, :] = Pdist # Distortion level 3 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=1.5))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[3 * idx:4 * idx, :, :, :] = Pclean x_dist[3 * idx:4 * idx, :, :, :] = Pdist # Distortion level 4 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=2))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[4 * idx:5 * idx, :, :, :] = Pclean x_dist[4 * idx:5 * idx, :, :, :] = Pdist # Distortion level 5 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=2.5))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[5 * idx:6 * idx, :, :, :] = Pclean x_dist[5 * idx:6 * idx, :, :, :] = Pdist # Distortion level 6 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=3))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[6 * idx:7 * idx, :, :, :] = Pclean x_dist[6 * idx:7 * idx, :, :, :] = Pdist # Distortion level 7 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=3.5))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[7 * idx:8 * idx, :, :, :] = Pclean x_dist[7 * idx:8 * idx, :, :, :] = Pdist # Distortion level 8 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=4))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[8 * idx:9 * idx, :, :, :] = Pclean x_dist[8 * idx:9 * idx, :, :, :] = Pdist # Distortion level 9 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=4.5))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[9 * idx:10 * idx, :, :, :] = Pclean x_dist[9 * idx:10 * idx, :, :, :] = Pdist # Distortion level 10 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=5))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[10 * idx:11 * idx, :, :, :] = Pclean x_dist[10 * idx:11 * idx, :, :, :] = Pdist # Distortion level 11 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=5.5))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[11 * idx:12 * idx, :, :, :] = Pclean x_dist[11 * idx:12 * idx, :, :, :] = Pdist # Distortion level 12 Idist = np.array(im.filter(ImageFilter.GaussianBlur(radius=6))) Pdist = getPatchesDict(Idist, [32, 32], noPatches=4000, entropy_th=1.0, stride=[32, 32]) x_clean[12 * idx:13 * idx, :, :, :] = Pclean x_dist[12 * idx:13 * idx, :, :, :] = Pdist return x_clean, x_dist
def to_image(self, canvas_color=(255, 255, 255)): canvas = Image.new('RGBA', self.size, canvas_color + (0,)) paste_with_blured_borders(canvas, self.img, self.position, border_width=self.blured_border_width) if self.as_negative: canvas = canvas.filter(ImageFilter.GaussianBlur(self.blur_radius)) return canvas
def genBG(img, size, blur=41, bright=0.35): img = cropBG(img, size) img_blur = img.filter(ImageFilter.GaussianBlur(radius=blur)) enhancer = ImageEnhance.Brightness(img_blur) output = enhancer.enhance(bright) return output
def post_process_particle_layer(particle_layer): particle_layer = ImageEnhance.Contrast(particle_layer).enhance(1.5) particle_layer = ImageEnhance.Brightness(particle_layer).enhance(2.2) particle_layer = particle_layer.filter( ImageFilter.GaussianBlur(radius=1.5)) return particle_layer
def glowText(img, text=None, font_size=35, font_set=None, color=(255, 255, 255, 255), blur=2, logo=None, use_glow=True, yoffset=0): width, height = img.size ratio = 2 width = width * ratio height = height * ratio font_size = font_size * ratio blur = blur * ratio if font_set is None: _font = ImageFont.truetype("arial.ttf", font_size) else: _font = "arial.ttf" for font_i in [ font_set, getPath("Source/font.otf"), getPath("Source/font.otf"), "arial.ttf" ]: try: _font = ImageFont.truetype(font_i, font_size) break except: print("Cannot Use Font: {0}".format(font_i)) canvas = Image.new('RGBA', (width, height), color[:-1] + (0, )) draw = ImageDraw.Draw(canvas) if text: w, h = draw.textsize(text, font=_font) else: w, h = 0, 0 xoffset = 0 if logo is not None: lg_w, lg_h = logo.size hoffset = 1.1 lg_nh = round(font_size * hoffset) lg_nw = round(lg_w * lg_nh / lg_h) logo = logo.resize((lg_nw, lg_nh), Image.ANTIALIAS) if text: xoffset = lg_nw + font_size / 4 else: xoffset = lg_nw w = w + xoffset _x_logo = int(round((width - w) / 2)) _y_logo = int(round(yoffset * ratio - font_size * (hoffset - 1) / 2)) try: canvas.paste(logo, (_x_logo, _y_logo), logo) except: canvas.paste(logo, (_x_logo, _y_logo)) if text: draw.text(((width - w) / 2 + xoffset, yoffset * ratio), text, fill=color, font=_font) if use_glow: mask_blur = canvas.split()[-1] mask_blur = mask_blur.filter(ImageFilter.GaussianBlur(radius=blur * 2)) fg_blur = canvas.split()[0] fg_blur = fg_blur.filter(ImageFilter.GaussianBlur(radius=blur * 2)) glow_text = Image.merge("RGBA", (fg_blur, fg_blur, fg_blur, mask_blur)) glow_text = glow_text.resize(img.size, Image.ANTIALIAS) canvas = canvas.resize(img.size, Image.ANTIALIAS) img.paste(glow_text, (0, 0), mask=glow_text) img.paste(canvas, (0, 0), mask=canvas) else: canvas = canvas.resize(img.size, Image.ANTIALIAS) img.paste(canvas, (0, 0), mask=canvas) return img
def __call__(self, img): radius = np.random.uniform(0, self.max_radius) if np.random.random() < self.rand_prob: return img.filter(ImageFilter.GaussianBlur(radius)) else: return img
def main(): parser = argparse.ArgumentParser( description= 'Find latent representation of reference images using perceptual losses', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('src_dir', help='Directory with images for encoding') parser.add_argument('generated_images_dir', help='Directory for storing generated images') parser.add_argument('dlatent_dir', help='Directory for storing dlatent representations') parser.add_argument('--data_dir', default='data', help='Directory for storing optional models') parser.add_argument('--mask_dir', default='masks', help='Directory for storing optional masks') parser.add_argument('--load_last', default='', help='Start with embeddings from directory') parser.add_argument( '--dlatent_avg', default='', help= 'Use dlatent from file specified here for truncation instead of dlatent_avg from Gs' ) parser.add_argument( '--model_url', default= 'https://drive.google.com/uc?id=1MEGjdvVpUsu1jB4zrXZN7Y4kBBOzizDQ', help='Fetch a StyleGAN model to train on from this URL' ) # karras2019stylegan-ffhq-1024x1024.pkl parser.add_argument('--model_res', default=1024, help='The dimension of images in the StyleGAN model', type=int) parser.add_argument('--batch_size', default=1, help='Batch size for generator and perceptual model', type=int) parser.add_argument( '--optimizer', default='ggt', help='Optimization algorithm used for optimizing dlatents') # Perceptual model params parser.add_argument('--image_size', default=256, help='Size of images for perceptual model', type=int) parser.add_argument('--resnet_image_size', default=256, help='Size of images for the Resnet model', type=int) parser.add_argument('--lr', default=0.25, help='Learning rate for perceptual model', type=float) parser.add_argument('--decay_rate', default=0.9, help='Decay rate for learning rate', type=float) parser.add_argument('--iterations', default=100, help='Number of optimization steps for each batch', type=int) parser.add_argument( '--decay_steps', default=4, help='Decay steps for learning rate decay (as a percent of iterations)', type=float) parser.add_argument('--early_stopping', default=True, help='Stop early once training stabilizes', type=str2bool, nargs='?', const=True) parser.add_argument('--early_stopping_threshold', default=0.5, help='Stop after this threshold has been reached', type=float) parser.add_argument('--early_stopping_patience', default=10, help='Number of iterations to wait below threshold', type=int) parser.add_argument( '--load_effnet', default='data/finetuned_effnet.h5', help='Model to load for EfficientNet approximation of dlatents') parser.add_argument( '--load_resnet', default='data/finetuned_resnet.h5', help='Model to load for ResNet approximation of dlatents') parser.add_argument( '--use_preprocess_input', default=True, help='Call process_input() first before using feed forward net', type=str2bool, nargs='?', const=True) parser.add_argument( '--use_best_loss', default=True, help='Output the lowest loss value found as the solution', type=str2bool, nargs='?', const=True) parser.add_argument( '--average_best_loss', default=0.25, help= 'Do a running weighted average with the previous best dlatents found', type=float) parser.add_argument('--sharpen_input', default=True, help='Sharpen the input images', type=str2bool, nargs='?', const=True) # Loss function options parser.add_argument( '--use_vgg_loss', default=0.4, help='Use VGG perceptual loss; 0 to disable, > 0 to scale.', type=float) parser.add_argument('--use_vgg_layer', default=9, help='Pick which VGG layer to use.', type=int) parser.add_argument( '--use_pixel_loss', default=1.5, help='Use logcosh image pixel loss; 0 to disable, > 0 to scale.', type=float) parser.add_argument( '--use_mssim_loss', default=200, help='Use MS-SIM perceptual loss; 0 to disable, > 0 to scale.', type=float) parser.add_argument( '--use_lpips_loss', default=100, help='Use LPIPS perceptual loss; 0 to disable, > 0 to scale.', type=float) parser.add_argument( '--use_l1_penalty', default=0.5, help='Use L1 penalty on latents; 0 to disable, > 0 to scale.', type=float) parser.add_argument('--use_discriminator_loss', default=0.5, help='Use trained discriminator to evaluate realism.', type=float) parser.add_argument( '--use_adaptive_loss', default=False, help= 'Use the adaptive robust loss function from Google Research for pixel and VGG feature loss.', type=str2bool, nargs='?', const=True) # Generator params parser.add_argument('--randomize_noise', default=False, help='Add noise to dlatents during optimization', type=str2bool, nargs='?', const=True) parser.add_argument( '--tile_dlatents', default=False, help='Tile dlatents to use a single vector at each scale', type=str2bool, nargs='?', const=True) parser.add_argument( '--clipping_threshold', default=2.0, help='Stochastic clipping of gradient values outside of this threshold', type=float) # Masking params parser.add_argument('--load_mask', default=False, help='Load segmentation masks', type=str2bool, nargs='?', const=True) parser.add_argument( '--face_mask', default=True, help='Generate a mask for predicting only the face area', type=str2bool, nargs='?', const=True) parser.add_argument( '--use_grabcut', default=True, help= 'Use grabcut algorithm on the face mask to better segment the foreground', type=str2bool, nargs='?', const=True) parser.add_argument( '--scale_mask', default=1.4, help='Look over a wider section of foreground for grabcut', type=float) parser.add_argument( '--composite_mask', default=True, help='Merge the unmasked area back into the generated image', type=str2bool, nargs='?', const=True) parser.add_argument( '--composite_blur', default=8, help='Size of blur filter to smoothly composite the images', type=int) # Video params parser.add_argument('--video_dir', default='videos', help='Directory for storing training videos') parser.add_argument('--output_video', default=False, help='Generate videos of the optimization process', type=bool) parser.add_argument('--video_codec', default='MJPG', help='FOURCC-supported video codec name') parser.add_argument('--video_frame_rate', default=24, help='Video frames per second', type=int) parser.add_argument('--video_size', default=512, help='Video size in pixels', type=int) parser.add_argument( '--video_skip', default=1, help='Only write every n frames (1 = write every frame)', type=int) args, other_args = parser.parse_known_args() args.decay_steps *= 0.01 * args.iterations # Calculate steps as a percent of total iterations if args.output_video: import cv2 synthesis_kwargs = dict(output_transform=dict( func=tflib.convert_images_to_uint8, nchw_to_nhwc=False), minibatch_size=args.batch_size) ref_images = [ os.path.join(args.src_dir, x) for x in os.listdir(args.src_dir) ] ref_images = list(filter(os.path.isfile, ref_images)) if len(ref_images) == 0: raise Exception('%s is empty' % args.src_dir) os.makedirs(args.data_dir, exist_ok=True) os.makedirs(args.mask_dir, exist_ok=True) os.makedirs(args.generated_images_dir, exist_ok=True) os.makedirs(args.dlatent_dir, exist_ok=True) os.makedirs(args.video_dir, exist_ok=True) # Initialize generator and perceptual model tflib.init_tf() with open(args.model_url, 'rb') as f: #with dnnlib.util.open_url(args.model_url, cache_dir=config.cache_dir) as f: generator_network, discriminator_network, Gs_network = pickle.load(f) generator = Generator(Gs_network, args.batch_size, clipping_threshold=args.clipping_threshold, tiled_dlatent=args.tile_dlatents, model_res=args.model_res, randomize_noise=args.randomize_noise) if (args.dlatent_avg != ''): generator.set_dlatent_avg(np.load(args.dlatent_avg)) perc_model = None if (args.use_lpips_loss > 0.00000001): with open('model/vgg.pkl', 'rb') as f: #with dnnlib.util.open_url('https://drive.google.com/uc?id=1pTDtnnLXTYpcWNv2dtzb32F-tHDlU6di', cache_dir=config.cache_dir) as f: perc_model = pickle.load(f) perceptual_model = PerceptualModel(args, perc_model=perc_model, batch_size=args.batch_size) perceptual_model.build_perceptual_model(generator, discriminator_network) ff_model = None # Optimize (only) dlatents by minimizing perceptual loss between reference and generated images in feature space for images_batch in tqdm(split_to_batches(ref_images, args.batch_size), total=len(ref_images) // args.batch_size): names = [ os.path.splitext(os.path.basename(x))[0] for x in images_batch ] if args.output_video: video_out = {} for name in names: video_out[name] = cv2.VideoWriter( os.path.join(args.video_dir, '{}.avi'.format(name)), cv2.VideoWriter_fourcc(*args.video_codec), args.video_frame_rate, (args.video_size, args.video_size)) perceptual_model.set_reference_images(images_batch) dlatents = None if (args.load_last != ''): # load previous dlatents for initialization for name in names: dl = np.expand_dims(np.load( os.path.join(args.load_last, '{}.npy'.format(name))), axis=0) if (dlatents is None): dlatents = dl else: dlatents = np.vstack((dlatents, dl)) else: if (ff_model is None): if os.path.exists(args.load_resnet): from keras.applications.resnet50 import preprocess_input print("Loading ResNet Model:") ff_model = load_model(args.load_resnet) if (ff_model is None): if os.path.exists(args.load_effnet): import efficientnet from efficientnet import preprocess_input print("Loading EfficientNet Model:") ff_model = load_model(args.load_effnet) if (ff_model is not None): # predict initial dlatents with ResNet model if (args.use_preprocess_input): dlatents = ff_model.predict( preprocess_input( load_images(images_batch, image_size=args.resnet_image_size))) else: dlatents = ff_model.predict( load_images(images_batch, image_size=args.resnet_image_size)) if dlatents is not None: generator.set_dlatents(dlatents) op = perceptual_model.optimize(generator.dlatent_variable, iterations=args.iterations, use_optimizer=args.optimizer) pbar = tqdm(op, leave=False, total=args.iterations) vid_count = 0 best_loss = None best_dlatent = None avg_loss_count = 0 if args.early_stopping: avg_loss = prev_loss = None for loss_dict in pbar: if args.early_stopping: # early stopping feature if prev_loss is not None: if avg_loss is not None: avg_loss = 0.5 * avg_loss + (prev_loss - loss_dict["loss"]) if avg_loss < args.early_stopping_threshold: # count while under threshold; else reset avg_loss_count += 1 else: avg_loss_count = 0 if avg_loss_count > args.early_stopping_patience: # stop once threshold is reached print("") break else: avg_loss = prev_loss - loss_dict["loss"] pbar.set_description(" ".join(names) + ": " + "; ".join( ["{} {:.4f}".format(k, v) for k, v in loss_dict.items()])) if best_loss is None or loss_dict["loss"] < best_loss: if best_dlatent is None or args.average_best_loss <= 0.00000001: best_dlatent = generator.get_dlatents() else: best_dlatent = 0.25 * best_dlatent + 0.75 * generator.get_dlatents( ) if args.use_best_loss: generator.set_dlatents(best_dlatent) best_loss = loss_dict["loss"] if args.output_video and (vid_count % args.video_skip == 0): batch_frames = generator.generate_images() for i, name in enumerate(names): video_frame = PIL.Image.fromarray( batch_frames[i], 'RGB').resize( (args.video_size, args.video_size), PIL.Image.LANCZOS) video_out[name].write( cv2.cvtColor( np.array(video_frame).astype('uint8'), cv2.COLOR_RGB2BGR)) generator.stochastic_clip_dlatents() prev_loss = loss_dict["loss"] if not args.use_best_loss: best_loss = prev_loss print(" ".join(names), " Loss {:.4f}".format(best_loss)) if args.output_video: for name in names: video_out[name].release() # Generate images from found dlatents and save them if args.use_best_loss: generator.set_dlatents(best_dlatent) generated_images = generator.generate_images() generated_dlatents = generator.get_dlatents() for img_array, dlatent, img_path, img_name in zip( generated_images, generated_dlatents, images_batch, names): mask_img = None if args.composite_mask and (args.load_mask or args.face_mask): _, im_name = os.path.split(img_path) mask_img = os.path.join(args.mask_dir, '{}'.format(im_name)) if args.composite_mask and mask_img is not None and os.path.isfile( mask_img): orig_img = PIL.Image.open(img_path).convert('RGB') width, height = orig_img.size imask = PIL.Image.open(mask_img).convert('L').resize( (width, height)) imask = imask.filter( ImageFilter.GaussianBlur(args.composite_blur)) mask = np.array(imask) / 255 mask = np.expand_dims(mask, axis=-1) img_array = mask * np.array(img_array) + ( 1.0 - mask) * np.array(orig_img) img_array = img_array.astype(np.uint8) #img_array = np.where(mask, np.array(img_array), orig_img) img = PIL.Image.fromarray(img_array, 'RGB') img.save( os.path.join(args.generated_images_dir, '{}.png'.format(img_name)), 'PNG') np.save(os.path.join(args.dlatent_dir, '{}.npy'.format(img_name)), dlatent) generator.reset_dlatents()
from PIL import Image, ImageFilter #resimleri açmamızı sağlıyorlar image = Image.open("Kaplan.jpg") image2 = Image.open("aslan.jpg") #kaplan resmini farklı bir adla kaydetmemizi sağlayan komut satırı image.save("kaplan2.jpg") #resmimizin yönünü çevirmemizi sağlıyor.. image.rotate(155).save("kaplan3.jpg") #aslan resmimizi siyah beyaz yapıyor... image2.convert(mode="L").save("aslanSiyahBeyaz.jpg") # kaplan resmine yeni boyut veriyoruz..... degistir = (683, 360) image.thumbnail(degistir) image.save("kaplan4.jpg") #kaplan resmini blurluyoruz... image.filter(ImageFilter.GaussianBlur(10)).save("kaplan5.jpg") #resmi kırpıyoruz... kirpilacakAlan = (0, 0, 400, 300) image.crop(kirpilacakAlan).save("kaplan6.jpg")
def generate(PMS_uuid, url, authtoken, resolution, blurRadius, gradientTemplate, titleText, subtitleText, titleSize, subtitleSize, textColor, align, valign, offsetx, offsety, lineheight, blurStart, blurEnd, statusText): cachepath = sys.path[0]+"/assets/fanartcache" stylepath = sys.path[0]+"/assets/thumbnails" # Create cache filename id = re.search('/library/metadata/(?P<ratingKey>\S+)/art/(?P<fileId>\S+)', url) if id: # assumes URL in format "/library/metadata/<ratingKey>/art/fileId>" id = id.groupdict() cachefile = urllib.quote_plus(PMS_uuid +"_"+ id['ratingKey'] +"_"+ id['fileId'] +"_"+ resolution +"_"+ blurRadius) + titleText + subtitleText + gradientTemplate + ".jpg" else: fileid = posixpath.basename(urlparse.urlparse(url).path) cachefile = urllib.quote_plus(PMS_uuid +"_"+ fileid +"_"+ resolution +"_"+ blurRadius) + titleText + subtitleText + gradientTemplate + ".jpg" # quote: just to make sure... # Already created? dprint(__name__, 1, 'Check for Cachefile.') # Debug if os.path.isfile(cachepath+"/"+cachefile): dprint(__name__, 1, 'Cachefile found.') # Debug return "/fanartcache/"+cachefile # No! Request Background from PMS dprint(__name__, 1, 'No Cachefile found. Generating Background.') # Debug try: dprint(__name__, 1, 'Getting Remote Image.') # Debug xargs = {} if authtoken: xargs['X-Plex-Token'] = authtoken request = urllib2.Request(url, None, xargs) response = urllib2.urlopen(request).read() background = Image.open(io.BytesIO(response)) except urllib2.URLError as e: dprint(__name__, 0, 'URLError: {0} // url: {1}', e.reason, url) return "/thumbnails/Background_blank_" + resolution + ".jpg" except urllib2.HTTPError as e: dprint(__name__, 0, 'HTTPError: {0} {1} // url: {2}', str(e.code), e.msg, url) return "/thumbnails/Background_blank_" + resolution + ".jpg" except IOError as e: dprint(__name__, 0, 'IOError: {0} // url: {1}', str(e), url) return "/thumbnails/Background_blank_" + resolution + ".jpg" blurRadius = int(blurRadius) # Get gradient template dprint(__name__, 1, 'Merging Layers.') # Debug if resolution == '1080': width = 1920 height = 1080 blurStart = (1080/100) * int(blurStart) blurEnd = (1080/100) * int(blurEnd) blurRegion = (0, blurStart, 1920, blurEnd) # FT: get Background based on last Parameter layer = Image.open(stylepath + "/" + gradientTemplate + "_1080.png") else: width = 1280 height = 720 blurStart = (720/100) * int(blurStart) blurEnd = (720/100) * int(blurEnd) blurRegion = (0, blurStart, 1280, blurEnd) blurRadius = int(blurRadius / 1.5) layer = Image.open(stylepath + "/" + gradientTemplate + "_720.png") # Set background resolution and merge layers try: bgWidth, bgHeight = background.size dprint(__name__,1 ,"Background size: {0}, {1}", bgWidth, bgHeight) dprint(__name__,1 , "aTV Height: {0}, {1}", width, height) if bgHeight != height: background = background.resize((width, height), Image.ANTIALIAS) dprint(__name__,1 , "Resizing background") if blurRadius != 0: dprint(__name__,1 , "Blurring Lower Region") imgBlur = background.crop(blurRegion) imgBlur = imgBlur.filter(ImageFilter.GaussianBlur(blurRadius)) background.paste(imgBlur, blurRegion) background.paste(layer, ( 0, 0), layer) background = textToImage(stylepath, background, resolution, titleText, titleSize, textColor, align, valign, offsetx, offsety) if subtitleText != "": offsety = int(offsety) + int(lineheight) background = textToImage(stylepath, background, resolution, subtitleText, subtitleSize, textColor, align, valign, offsetx, offsety) # Handle 1080 / atv3 Text statusSize = 20 statusX = 80 statusY = 25 if resolution == '1080': statusSize = fullHDtext(statusSize) statusX = fullHDtext(statusX) statusY = fullHDtext(statusY) if statusText != "": background = textToImage(stylepath, background, resolution, statusText, statusSize, textColor, "right", "top", statusX, statusY) # Save to Cache background.save(cachepath+"/"+cachefile) except: dprint(__name__, 0, 'Error - Failed to generate background image.\n{0}', traceback.format_exc()) return "/thumbnails/Background_blank_" + resolution + ".jpg" dprint(__name__, 1, 'Cachefile generated.') # Debug return "/fanartcache/"+cachefile
def blur(event): img = Image.open(root.file) blurred = img.filter(ImageFilter.GaussianBlur(radius=15)) blurred.save("file.png")
def blur(image): many = 5 return image.filter(ImageFilter.GaussianBlur(many)).convert('RGB')