def classify_DCT(image1,image2,size=(32,32),part_size=(8,8)): """ 'image1' and 'image2' is a Image Object. You can build it by 'Image.open(path)'. 'Size' is parameter what the image will resize to it and then image will be compared by the pHash. It's 32 * 32 when it default. 'part_size' is a size of a part of the matrix after Discrete Cosine Transform,which need to next steps. It's 8 * 8 when it default. The function will return the hamming code,less is correct. """ assert size[0]==size[1],"size error" assert part_size[0]==part_size[1],"part_size error" image1 = image1.resize(size).convert('L').filter(ImageFilter.BLUR) image1 = ImageOps.equalize(image1) matrix = get_matrix(image1) DCT_matrix = DCT(matrix) List = sub_matrix_to_list(DCT_matrix, part_size) middle = get_middle(List) code1 = get_code(List, middle) image2 = image2.resize(size).convert('L').filter(ImageFilter.BLUR) image2 = ImageOps.equalize(image2) matrix = get_matrix(image2) DCT_matrix = DCT(matrix) List = sub_matrix_to_list(DCT_matrix, part_size) middle = get_middle(List) code2 = get_code(List, middle) return comp_code(code1, code2)
def hilightEdges(self): """ """ img = self.image.copy() img = ImageOps.equalize(img) xneg = ImageChops.difference(img, img.offset(-1,0)) xpos = ImageChops.difference(img, img.offset(1,0)) yneg = ImageChops.difference(img, img.offset(0,-1)) ypos = ImageChops.difference(img, img.offset(0,1)) xmax = ImageChops.lighter(xneg, xpos) ymax = ImageChops.lighter(yneg, ypos) xymax = ImageChops.lighter(xmax,ymax) xymax.show() xymax = ImageOps.autocontrast(xymax) xymax.show() xymax = ImageOps.posterize(xymax, 3) xymax = ImageOps.equalize(xymax) xymax.show() xymax = ImageOps.posterize(xymax, 2) xymax.show() self.image.show() self.image = ImageChops.screen(self.image, xymax) self.image.show()
def method3(im): # equalizes bands individually r,g,b,a = im.split() r = ImageOps.equalize(r) g = ImageOps.equalize(g) b = ImageOps.equalize(b) im_eq = Image.merge('RGBA', (r,g,b,a)) im_eq.save("test_m3.png")
def test_sanity(): ImageOps.autocontrast(lena("L")) ImageOps.autocontrast(lena("RGB")) ImageOps.autocontrast(lena("L"), cutoff=10) ImageOps.autocontrast(lena("L"), ignore=[0, 255]) ImageOps.colorize(lena("L"), (0, 0, 0), (255, 255, 255)) ImageOps.colorize(lena("L"), "black", "white") ImageOps.crop(lena("L"), 1) ImageOps.crop(lena("RGB"), 1) ImageOps.deform(lena("L"), deformer) ImageOps.deform(lena("RGB"), deformer) ImageOps.equalize(lena("L")) ImageOps.equalize(lena("RGB")) ImageOps.expand(lena("L"), 1) ImageOps.expand(lena("RGB"), 1) ImageOps.expand(lena("L"), 2, "blue") ImageOps.expand(lena("RGB"), 2, "blue") ImageOps.fit(lena("L"), (128, 128)) ImageOps.fit(lena("RGB"), (128, 128)) ImageOps.fit(lena("RGB").resize((1, 1)), (35, 35)) ImageOps.flip(lena("L")) ImageOps.flip(lena("RGB")) ImageOps.grayscale(lena("L")) ImageOps.grayscale(lena("RGB")) ImageOps.invert(lena("L")) ImageOps.invert(lena("RGB")) ImageOps.mirror(lena("L")) ImageOps.mirror(lena("RGB")) ImageOps.posterize(lena("L"), 4) ImageOps.posterize(lena("RGB"), 4) ImageOps.solarize(lena("L")) ImageOps.solarize(lena("RGB")) success()
def convert(action,image_name): # # actions = Actions() # image_path = gray(image_name) # # return image_path # return (render_template('core/convert.html', path=image_path, name=image_name)) # return action if not image_name: return (redirect('/')) else: if action == "gray": img = Image.open(UPLOAD_FOLDER + '/' + image_name).convert('L') elif action == "invert": img = Image.open(UPLOAD_FOLDER + '/' + image_name) img = ImageChops.invert(img) elif action == "sharpen": img = Image.open(UPLOAD_FOLDER + '/' + image_name).filter(ImageFilter.UnsharpMask(radius=2, percent=150, threshold=3)) elif action == "contrast": img = Image.open(UPLOAD_FOLDER + '/' + image_name) img = ImageOps.autocontrast(img, cutoff=5, ignore=None) elif action == "equalize": img = Image.open(UPLOAD_FOLDER + '/' + image_name) img = ImageOps.equalize(img, mask=None) elif action == "solarize": img = Image.open(UPLOAD_FOLDER + '/' + image_name) img = ImageOps.solarize(img, threshold=128) url = "/convert/"+action+"/"+image_name filename = str(time.time()) + image_name img.save(SAVE_FOLDER + '/' + filename) image_path = 'results/' + filename return (render_template('core/index.html', path=image_path, name=image_name, url=url))
def run(self): while True: try: camera = WebCamera.objects.get(pk = self._camera.id) if camera.motion_control: now = datetime.now() request = get_pool().request("GET", "%s?action=snapshot" % camera.internal_url) try: source = Image.open(BytesIO(request.data)) img = ImageOps.equalize(ImageOps.grayscale(source)) if self._previous is not None: out = ImageMath.eval("convert(a - b, 'L')", a = img, b = self._previous) out = out.filter(MedianFilter()) total = 0 for idx, val in enumerate(out.histogram()): total += val * idx if total > 3000000: camera.last_motion = now camera.save() filename = os.path.join(camera.motion_folder, "{:%Y%m%d-%H%M%S}.jpg".format(now)) source.save(filename) filesize = os.path.getsize(filename) if filesize < 6700: os.remove(filename) self._previous = img finally: request.close() else: self._previous = None except: print("Ignore Exception") sleep(1)
def pil_to_ascii(img, scalefactor=0.2, invert=False, equalize=True, lut='simple', aspect_correction_factor=None ): """ Generates an ascii string from a PIL image. Parameters ---------- img : PIL.Image PIL image to transform. scalefactor : float ASCII characters per pixel. invert : bool Invert luminance? equalize : bool equalize histogram (for best results do this). lut : str Name of the lookup table to use. Currently supports 'simple' and 'binary'. Returns ------- str Examples -------- >>> from asciisciit.misc import open_pil_img >>> img = open_pil_img("http://i.imgur.com/l2FU2J0.jpg") >>> text_img = pil_to_ascii(img, scalefactor=0.3) >>> print(text_img) >>> from PIL import Image >>> img = Image.open("some_image.png") >>> text_img = pil_to_ascii(img) >>> print(text_img) """ lookup = get_lut(lut) if aspect_correction_factor is None: aspect_correction_factor = get_aspect_correction_factor(lookup.exemplar) img = img.resize( (int(img.size[0]*scalefactor), int(img.size[1]*scalefactor*aspect_correction_factor)), Image.BILINEAR) img = img.convert("L") # convert to mono if equalize: img = ImageOps.equalize(img) if invert: img = ImageOps.invert(img) img = np.array(img, dtype=np.uint8) return u"\n" + u"".join(lookup.apply(img).flatten().tolist())
def apply_equalizer(pixbuf): ''' creates a uniform distribution of grayscale values in the output image ''' width,height = pixbuf.get_width(),pixbuf.get_height() y = ImageOps.equalize(Image.frombytes(K.ImageConstants.RGB_SHORT_NAME,(width,height),pixbuf.get_pixels() )) return I.fromImageToPixbuf(y)
def main(): parser = ArgumentParser() parser.add_argument("inage", metavar='INPUT', type=str) parser.add_argument("outage", metavar='OUTPUT', type=str) parser.add_argument("-p", "--palette", type=str, default="AUTO") parser.add_argument("-d", "--dither", type=str, default="BAYER") parser.add_argument("-iw", "--width", type=int, default=-1) parser.add_argument("-ih", "--height", type=int, default=-1) parser.add_argument("-m", "--matrix", type=int, default=-2) parser.add_argument("-e", "--equalize", action="store_true", default=False) args = parser.parse_args() image = Image.open(args.inage) if args.equalize: image = ImageOps.equalize(image) # Create target palette if args.palette.upper() == "GB": out_palette = gl_c.GAMENIPPER elif args.palette.upper() == "ISS": out_palette = gl_c.LOVE elif args.palette.upper() == "AUTO": out_palette = gl_c.hue_palette(comp_colours()) elif args.palette.upper() == "COMP": out_palette = gl_c.hue_palette(comp_colours(c_min=-0.1, c_max=0.1)) elif args.palette.upper() == "WHITE": out_palette = [(0, 0, 0)] out_palette += gl_c.hue_palette((random.random(),), low=128) out_palette.append((255, 255, 255)) elif args.palette.upper() == "MONO": out_palette = gl_c.mono_palette(4) else: out_palette = gl_c.GAMENIPPER num_colours = len(out_palette) # Resize Image bgcolor = "rgb(%d, %d, %d)" % out_palette[0] image = gl_u.resize(image, args.width, args.height) # Prequantize image = gl_c.quantize(image, gl_c.mono_palette(num_colours * 4)) # Create monochrome palette for quantization monos = gl_c.mono_palette(num_colours) # Dither image based on monochrome palette if args.dither.upper() == "FS": dithim = gl_d.floyd_steinberg(image, monos, mode="MONO").convert("RGB") elif args.dither.upper() == "BAYER": dithim = gl_d.bayer(image, monos, matrix=args.matrix).convert("RGB") else: dithim = gl_d.bayer(image, monos, matrix=args.matrix).convert("RGB") # Replace colours in image with target palette outim = gl_c.replace_colours(dithim, monos, out_palette) # Save dithered coloured image outim.save(args.outage)
def main(): image = Image.open('../lenna.png').convert('L') image.show('Original') plot_histogram('Original Histogram', image) equalized_image = ImageOps.equalize(image) equalized_image.show('Equalized image') plot_histogram('Equalized Histogram', equalized_image)
def process(self, image): """ Args: image: The image to process. Returns: a single image, or a list containing one or more images. """ BaseFilter.process(self, image) if self.mode != 'gray': raise RuntimeError("EqualizeHistogram only supports grayscale images.") if self.region == 'bbox': bbox = image.split()[1].getbbox() croppedImage = image.crop(bbox) croppedImage.load() alpha = croppedImage.split()[1] croppedImage = ImageOps.equalize(croppedImage.split()[0]) croppedImage.putalpha(alpha) image.paste(croppedImage, bbox) elif self.region == 'mask': bbox = image.split()[1].getbbox() croppedImage = image.crop(bbox) croppedImage.load() alpha = croppedImage.split()[1] # Fill in the part of the cropped image outside the bounding box with # uniformly-distributed noise noiseArray = \ numpy.random.randint(0, 255, croppedImage.size[0]*croppedImage.size[1]) noiseImage = Image.new('L', croppedImage.size) noiseImage.putdata(noiseArray) compositeImage = Image.composite(croppedImage, noiseImage, alpha) # Equalize the composite image compositeImage = ImageOps.equalize(compositeImage.split()[0]) # Paste the part of the equalized image within the mask back # into the cropped image croppedImage = Image.composite(compositeImage, croppedImage, alpha) croppedImage.putalpha(alpha) # Paste the cropped image back into the full image image.paste(croppedImage, bbox) elif self.region == 'all': alpha = image.split()[1] image = ImageOps.equalize(image.split()[0]) image.putalpha(alpha) return image
def pil_to_ascii(img, scalefactor=0.2, invert=False, equalize=True): """ Generates an ascii string from a PIL image. Parameters ---------- img : PIL.Image PIL image to transform. scalefactor : float ASCII characters per pixel invert : bool Invert luminance? equalize : bool equalize histogram (for best results do this) Returns ------- str Examples -------- >>> from asciisciit.misc import open_pil_img >>> img = open_pil_img("http://i.imgur.com/l2FU2J0.jpg") >>> text_img = pil_to_ascii(img, scalefactor=0.3) >>> print(text_img) >>> from PIL import Image >>> img = Image.open("some_image.png") >>> text_img = pil_to_ascii(img) >>> print(text_img) """ img = img.resize((int(img.size[0]*scalefactor), int(img.size[1]*scalefactor*ASPECTCORRECTIONFACTOR)), Image.BILINEAR) img = img.convert("L") # convert to mono if equalize: img = ImageOps.equalize(img) if invert: img = ImageOps.invert(img) text = "\n" ##TODO: custom LUT lut = GREYSCALE_UNIFORM #SLOW ##TODO: USE Image.point(lut) instead for y in range(0, img.size[1]): for x in range(0, img.size[0]): lum = img.getpixel((x, y)) row = bisect(BINS, lum) character = lut[row] text += character text += "\n" return text
def noise_steg_detect(image): orig_image = Image.open(image) equal_image = Image.open(image) equal_image = ImageOps.grayscale(equal_image) equal_image = ImageOps.equalize(equal_image) orig_image.show() equal_image.show()
def process_image(context, photo): if context['colorize'] or context['equalize']: photo = photo.convert('L') if context['equalize']: photo = ImageOps.equalize(photo) if context['colorize']: photo = ImageOps.colorize(photo, context['black'], context['white']) photo = photo.convert('RGBA') return photo
def classfiy_aHash(image1,image2,size=(8,8),exact=25): ''' 'image1' and 'image2' is a Image Object. You can build it by 'Image.open(path)'. 'Size' is parameter what the image will resize to it and then image will be compared by the algorithm. It's 8 * 8 when it default. 'exact' is parameter for limiting the Hamming code between 'image1' and 'image2',it's 25 when it default. The result become strict when the exact become less. This function return the true when the 'image1' and 'image2' are similar. ''' image1 = image1.resize(size).convert('L').filter(ImageFilter.BLUR) image1 = ImageOps.equalize(image1) code1 = getCode(image1, size) image2 = image2.resize(size).convert('L').filter(ImageFilter.BLUR) image2 = ImageOps.equalize(image2) code2 = getCode(image2, size) assert len(code1) == len(code2),"error" return compCode(code1, code2)<=exact
def prep(self, image): image = image.convert("L") if self.size: image = ImageOps.fit(image, self.size, method=Image.BICUBIC) if self.auto_contrast: image = ImageOps.autocontrast(image) if self.equalize: image = ImageOps.equalize(image) if self.invert: image = ImageOps.invert(image) return image
def equalize(image, amount=100): image = imtools.convert_safe_mode(image) if imtools.has_alpha(image): equalized = imtools.remove_alpha(image) else: equalized = image equalized = ImageOps.equalize(equalized) if imtools.has_alpha(image): imtools.put_alpha(equalized, imtools.get_alpha(image)) if amount < 100: equalized = imtools.blend(image, equalized, amount / 100.0) return equalized
def random_bands(sourceimg): """Randomly scramble color bands in image""" r, g, b = sourceimg.split() bands = [r, g, b] dice = [True] * 2 + [False] * 3 random.shuffle(dice) if dice.pop(): random.shuffle(bands) negbands = (ImageChops.invert(b) for b in bands) bands = [n if d else b for (b, n, d) in zip(bands, negbands, dice)] newimg = Image.merge('RGB', bands) newimg = ImageOps.equalize(newimg) return newimg
def crop_image_face(input_file, output_file, square, resize = (WIDTH, HEIGHT)): # Open image and adjust rectangle: image = Image.open(input_file) x, y, w, h = square x, y = max(x, 0), max(y, 0) w, h = min(w, image.size[0] - x), min(h, image.size[1] - y) # Crop image: face = image.crop((x, y, x + w, y + h)) if resize: face = face.resize(resize).convert("L") face = ImageOps.equalize(face) face.save(output_file)
def test_pil163(self): # Division by zero in equalize if < 255 pixels in image (@PIL163) i = hopper("RGB").resize((15, 16)) ImageOps.equalize(i.convert("L")) ImageOps.equalize(i.convert("P")) ImageOps.equalize(i.convert("RGB"))
def test_pil163(): # Division by zero in equalize if < 255 pixels in image (@PIL163) i = lena("RGB").resize((15, 16)) ImageOps.equalize(i.convert("L")) ImageOps.equalize(i.convert("P")) ImageOps.equalize(i.convert("RGB")) success()
def adjustImage(image): """ Returns image adjusted for facial detection. image -- input image to be adjusted type -- string representing adjustment type """ image = Image.fromarray(image) #brighten image = image.point(lambda p: p * 1.2) image = ImageOps.grayscale(image) image = ImageOps.equalize(image) #image = ImageOps.autocontrast(image) image = ImageOps.colorize(image, (0,0,0), (255,255,255)) return image
def _pre_process_image(cls, image, bbox): """ image is a PIL.Image bbox is x0,y0,x1,y1 """ # crop face if not already done so x0, y0, x1, y1 = bbox curr_width, curr_height = image.size if x1 <= curr_width and y1 <= curr_height: image = image.crop(bbox) image = ImageOps.grayscale(image) # convert to greyscale image = image.resize(cls.size, Image.ANTIALIAS) # resize to working size image = ImageOps.equalize(image) # equalize histogram return np.asarray(image.getdata())
def image_list(file): ''' Constructs list of 8px x 12px greyscale pieces from input image (In order from top left to bottom right as you would read a document in most languages) ''' im = Image.open(file) im = resize_image(im) im = im.convert("L") im = ImageOps.autocontrast(im) im = ImageOps.equalize(im) images = [] yo = 0 for y in range(im.size[1]/12): xo = 0 for x in range(im.size[0]/8): image_piece = im.crop((xo,yo,8*(x+1),12*(y+1))) images.append(image_piece) xo += 8 yo +=12 return images
def main(): parser = ArgumentParser() parser.add_argument("inage", metavar='INPUT', type=str) parser.add_argument("outage", metavar='OUTPUT', type=str) parser.add_argument("-d", "--dither", type=str, default="BAYER") parser.add_argument("-m", "--matrix", type=int, default=-2) parser.add_argument("-e", "--equalize", action="store_true", default=False) args = parser.parse_args() image = Image.open(args.inage) if args.equalize: image = ImageOps.equalize(image) # Resize Image image = gl_u.resize(image, 256, 192) # Pre-quantize image #image = gl_c.quantize(image, gl_c.median_cut(image, 32)) # image = gl_d.floyd_steinberg(image, ZX_HEX) # image.save(args.outage) # exit() # Quantize # outim = gl_c.quantize(image, palette) outim = Image.new("RGB", image.size, "black") for x in range(256 >> 3): for y in range(192 >> 3): block = attribute_block(image, x << 3, y << 3) outim.paste(block, (x << 3, y << 3)) # Dither image based on monochrome palette #if args.dither.upper() == "FS": #dithim = gl_d.floyd_steinberg(image, monos, mode="MONO").convert("RGB") #elif args.dither.upper() == "BAYER": #dithim = gl_d.bayer(image, monos, matrix=args.matrix).convert("RGB") #else: #dithim = gl_d.bayer(image, monos, matrix=args.matrix).convert("RGB") # Save zx-ified outim.save(args.outage)
def __getitem__(self, index): img_path, mask_path, mask_weak_path = self.imgs[index] # print("{} and {}".format(img_path,mask_path)) img = Image.open(img_path) # .convert('RGB') mask = Image.open(mask_path) # .convert('RGB') mask_weak = Image.open(mask_weak_path).convert('L') if self.equalize: img = ImageOps.equalize(img) if self.augmentation: img, mask, mask_weak = self.augment(img, mask, mask_weak) if self.transform: img = self.transform(img) mask = self.mask_transform(mask) mask = (mask == 1).long() # mask = self.mask_pixelvalue2OneHot(mask) mask_weak = self.mask_transform(mask_weak) return [img, mask, mask_weak, img_path]
def __getitem__(self, index): img_path, mask_path, mask_weak_path = self.imgs[index] assert Path(img_path).stem == Path(mask_path).stem == Path(mask_weak_path).stem img = Image.open(img_path).convert('L') # .convert('RGB') mask = Image.open(mask_path) # .convert('RGB') mask_weak = Image.open(mask_weak_path).convert('L') if self.equalize: img = ImageOps.equalize(img) if self.augment is not None and self.training == ModelMode.TRAIN: img, mask, mask_weak = self.augment(img, mask, mask_weak) self.transform = self.transform if self.transform is not None else default_transform img = self.transform['Img'](img) mask = self.transform['mask'](mask) mask = (mask >= 0.8).long() mask_weak = self.transform['mask'](mask_weak) mask_weak = (mask_weak >= 0.8).long() return [img, mask, mask_weak, img_path]
def image_list(file): im = Image.open(file) im = resize_image(im) im = im.convert("L") im = ImageOps.autocontrast(im) im = ImageOps.equalize(im) images = [] yo = 0 for y in range(im.size[1]/12): xo = 0 for x in range(im.size[0]/8): image_piece = im.crop((xo,yo,8*(x+1),12*(y+1))) images.append(image_piece) xo += 8 yo +=12 return images
def poison_scenario_preprocessing(batch): img_size = 48 img_out = [] quantization = 255.0 for im in batch: img_eq = ImageOps.equalize(Image.fromarray(im)) width, height = img_eq.size min_side = min(img_eq.size) center = width // 2, height // 2 left = center[0] - min_side // 2 top = center[1] - min_side // 2 right = center[0] + min_side // 2 bottom = center[1] + min_side // 2 img_eq = img_eq.crop((left, top, right, bottom)) img_eq = np.array(img_eq.resize([img_size, img_size])) / quantization img_out.append(img_eq) return np.array(img_out, dtype=np.float32)
def read_image(self, image_info): """Read from ppm image and return a ndarray with size [1, self.IMAGE_SIZE * self.IMAGE_SIZE + 1], in which the last element is the label.""" im = Image.open(image_info['path']) im = im.crop(image_info['box']) if self.ignore_small and (im.size[0] < self.IMAGE_SIZE or im.size[1] < self.IMAGE_SIZE): return None im = im.convert('L') im = im.resize((self.IMAGE_SIZE, self.IMAGE_SIZE)) im = ImageOps.equalize(im) data = im.tobytes() data = np.fromstring(data, dtype=np.uint8) data = np.append(data, [image_info['label']]) size = data.shape[0] data = np.reshape(data, [1, size]) return data
def split_normalize(image): """Splitting source image then normalize it. :param image: source image :return: blue and green channel """ im = Image.Image.split(image) g = ImageOps.equalize(im[1], mask = None) mean = Stat(im[2]).mean[0] b = np.array(im[2]).astype('float32') b /= (1.0 + mean) mean = Stat(g).mean[0] g = np.array(g).astype('float32') g /= (1.0 + mean) b = np.clip(b, 0, 1) g = np.clip(g, 0, 1) b *= 255.0 g *= 255.0 b = Image.fromarray(b.astype('uint8')) g = Image.fromarray(g.astype('uint8')) return b, g
def expand_tocolor(pil_image: PIL.Image, alpha: float = 1.2, beta: float = 1.0, equalize: bool = True) -> PIL.Image: if equalize: pil_image = ImageOps.equalize(pil_image) pil_image = pil_image.convert('L') imgarray = np.asarray(pil_image) # gray = np.array((imgarray[:, :, 0] * 3. * alpha) ** beta, dtype=np.float32) gray = np.array((imgarray * 3. * alpha) ** beta, dtype=np.float32) enhanced_B = gray.copy() enhanced_B[enhanced_B > 254] = 254 enhanced_G = (gray - 250) enhanced_G[enhanced_G > 254] = 254 enhanced_G[enhanced_G <= 40] = 40 enhanced_R = (gray - 510) enhanced_R[enhanced_R <= 20] = 20 enhanced_R[enhanced_R > 254] = 254 enhanced_RGB = np.dstack((enhanced_R, enhanced_G, enhanced_B)).astype(np.uint8) enhanced_color = PIL.Image.fromarray(enhanced_RGB) return enhanced_color
def __init__(self, p1, operation1, magnitude_idx1, p2, operation2, magnitude_idx2, fillcolor=(128, 128, 128)): ranges = { "color": np.linspace(0.0, 0.9, 10), "posterize": np.round(np.linspace(8, 4, 10), 0).astype(np.int), "solarize": np.linspace(256, 0, 10), "contrast": np.linspace(0.0, 0.9, 10), "sharpness": np.linspace(0.0, 0.9, 10), "brightness": np.linspace(0.0, 0.9, 10), "autocontrast": [0] * 10, "equalize": [0] * 10, "invert": [0] * 10 } # from https://stackoverflow.com/questions/5252170/specify-image-filling-color-when-rotating-in-python-with-pil-and-setting-expand def rotate_with_fill(img, magnitude): rot = img.convert("RGBA").rotate(magnitude) return Image.composite(rot, Image.new("RGBA", rot.size, (128,) * 4), rot).convert(img.mode) func = { "color": lambda img, magnitude: ImageEnhance.Color(img).enhance(1 + magnitude * random.choice([-1, 1])), "posterize": lambda img, magnitude: ImageOps.posterize(img, magnitude), "solarize": lambda img, magnitude: ImageOps.solarize(img, magnitude), "contrast": lambda img, magnitude: ImageEnhance.Contrast(img).enhance( 1 + magnitude * random.choice([-1, 1])), "sharpness": lambda img, magnitude: ImageEnhance.Sharpness(img).enhance( 1 + magnitude * random.choice([-1, 1])), "brightness": lambda img, magnitude: ImageEnhance.Brightness(img).enhance( 1 + magnitude * random.choice([-1, 1])), "autocontrast": lambda img, magnitude: ImageOps.autocontrast(img), "equalize": lambda img, magnitude: ImageOps.equalize(img), "invert": lambda img, magnitude: ImageOps.invert(img) } self.p1 = p1 self.operation1 = func[operation1] self.magnitude1 = ranges[operation1][magnitude_idx1] self.p2 = p2 self.operation2 = func[operation2] self.magnitude2 = ranges[operation2][magnitude_idx2]
def enhance_images(sharpness,contrast,glacier): #-- directory setup #- current directory current_dir = os.path.dirname(os.path.realpath(__file__)) main_dir = os.path.join(current_dir,'..','FrontLearning_data') glacier_ddir = os.path.join(main_dir,'%s.dir'%glacier) data_dir = os.path.join(glacier_ddir, 'data') trn_dir = os.path.join(data_dir,'train') tst_dir = os.path.join(data_dir,'test') #-- first read data images,names = load_data(trn_dir,tst_dir) #-- make output directory dictionary outdir = {} outdir['train'] = os.path.join(trn_dir,'images_equalize_autocontrast_smooth_edgeEnhance') outdir['test'] = os.path.join(tst_dir,'images_equalize_autocontrast_smooth_edgeEnhance') #-- loop through train and test data for t in ['test']:#,'train']: if (not os.path.isdir(outdir[t])): os.mkdir(outdir[t]) #-- loop through images and ehnance for m,n in zip(images[t],names[t]): #-- first blur the images to get rid of all the noise ''' sharp_obj = ImageEnhance.Sharpness(m) blurred = sharp_obj.enhance(sharpness) contr_obj = ImageEnhance.Contrast(blurred) final = contr_obj.enhance(contrast) contr_obj = ImageEnhance.Contrast(m) im = contr_obj.enhance(contrast) final = im.filter(ImageFilter.SMOOTH)#.filter(ImageFilter.EDGE_ENHANCE) ''' final = ImageOps.equalize(ImageOps.autocontrast(m.convert('L'))).filter(ImageFilter.SMOOTH).filter(ImageFilter.EDGE_ENHANCE) #-- write image to file final.save(os.path.join(outdir[t],'%s'%n))
def __getitem__(self, index): fat_path, inn_path,opp_path,wat_path,mask_path = self.imgs[index] img_f = Image.open(fat_path)#.convert('L') img_i = Image.open(inn_path)#.convert('L') img_o = Image.open(opp_path)#.convert('L') img_w = Image.open(wat_path)#.convert('L') mask = Image.open(mask_path).convert('L') if self.equalize: img = ImageOps.equalize(img) if self.augmentation: img, mask = self.augment(img, mask) if self.transform: img_f = self.transform(img_f) img_i = self.transform(img_i) img_o = self.transform(img_o) img_w = self.transform(img_w) mask = self.mask_transform(mask) return [img_f,img_i,img_o,img_w, mask, fat_path]
def v_sivinsko(slika, autokontrast=False, izravnava=False): """Sliko pretvori v sivinski barvni prostor. Args: slika: (object): PIL/Pillow objekt slike autokontrast (bool): Avtomatsko popravi kontrast slike. (Default: False) izravnava (bool): Skuša izravati histogram slike. (Default: False) Returns: object: PIL/Pillow objekt """ _slika = slika.copy() if _slika.mode != 'L': _slika.convert('L') if autokontrast: _slika = ImageOps.autocontrast(_slika) if izravnava: _slika = ImageOps.equalize(_slika) return _slika
def imageprocess(String2, int2): pil_im = Image.open("images/" + String2).convert( 'L') #opens said image converts to greyscale halfwidth = pil_im.size[ 0] / 2 #right now I crop from the center of the image halfheight = pil_im.size[ 1] / 2 #these two lines find the location we are cropping from, right now dead center twoThirdwidth = pil_im.size[ 0] / 1.25 #not actually 2/3rds anymore but... whatever twoThirdheight = pil_im.size[ 1] / 2.25 #These two lines decide how much of the image we get pil_im = pil_im.crop(( halfwidth - twoThirdwidth, #crop halfheight - twoThirdheight, halfwidth + twoThirdwidth, #that halfheight + twoThirdheight, ) #shit ) pil_im = array(pil_im) # convert the image to an array pil_im = ( 100.0 / 255 ) * pil_im + 100 #clamp the values... this might be changed a bit to offer more grey levels ( may provide higher contrast) pil_im = 255.0 * (pil_im / 255.0)**2 #quadratic transformation pil_im = Image.fromarray( uint8(pil_im) ) #in order to do the equalization the easy way, we need an image not an array pil_im = ImageOps.equalize(pil_im) #equalize that shit String2 = 'images/newpicture0' #save transformed image as newpicture# String2 = String2 + str(int2) pil_im.save(String2 + '.jpg') return
async def deepfry(ctx, quality=None, image_url=None): """Deep fries an image""" channel = ctx.message.channel if image_url == None: image_url = await check_pictures(channel) # Need to use requests to read the image otherwise it returns a 403:FORBIDDEN error response = requests.get(image_url) img = Image.open(BytesIO(response.content)) # Reading the raw image data img = img.convert('RGB') # Resizes and resamples the image multiple times, then crushes the histogram if quality == 'crush': width, height = img.width, img.height img = img.resize((int(width ** .75), int(height ** .75)), resample=Image.LANCZOS) img = img.resize((int(width ** .88), int(height ** .88)), resample=Image.BILINEAR) img = img.resize((int(width ** .9), int(height ** .9)), resample=Image.BICUBIC) img = img.resize((width, height), resample=Image.BICUBIC) img = ImageOps.posterize(img, 5) # Deep fries the image sharpness = ImageEnhance.Sharpness(img) img = sharpness.enhance(70) # Sharpness brightnesss = ImageEnhance.Brightness(img) img = brightnesss.enhance(2) # Brightness saturation = ImageEnhance.Color(img) img = saturation.enhance(2) # Saturation contrast = ImageEnhance.Contrast(img) img = contrast.enhance(3) # Contrast img = img.filter(ImageFilter.SMOOTH_MORE) img = ImageOps.equalize(img) img.save(fp=f'fried.jpg', format='JPEG', quality=8) await client.send_file(channel, 'fried.jpg') os.remove('fried.jpg')
def process_image(image): if make_decision(85): image = ImageOps.grayscale(image) image = ImageOps.colorize(image, get_random_hex_color(), get_random_hex_color(), get_random_hex_color()) # if with_decision(50): # image = ImageOps.flip(image) # if with_decision(50): # image = ImageOps.mirror(image) if make_decision(50): posterize_bits = random.randrange(1, 8) image = ImageOps.posterize(image, posterize_bits) if make_decision(50): threshold = random.randrange(0, 255) image = ImageOps.solarize(image, threshold) if make_decision(50): image = ImageOps.equalize(image) if make_decision(50): blur_radius = random.randrange(0, 3) image = image.filter(ImageFilter.GaussianBlur(blur_radius)) return image
def histeq(im,nbr_bins=256): ''' TODO: - use local method. Old version # get image histogram imhist,bins = histogram(im.flatten(),nbr_bins,normed=False) cdf = imhist.cumsum() # cumulative distribution function cdf = 255 * cdf / cdf[-1] # normalize # use linear interpolation of cdf to find new pixel values im2 = interp(im.flatten(),bins[:-1],cdf) im = im2.reshape(im.shape) ''' if type(im) is not Image: im = Image.fromarray(im) im = ImageOps.equalize(im) if type(im) is not np.ndarray: im = np.array(im) return im
def im_gamma_equalize(f_path, fname): file_path = os.path.join(f_path, fname) # 画像ファイルを取り込んで RGB を確保。 im = Image.open(file_path) im = im.convert("RGB") # ガンマ補正を解除して RGB=>YCbCr 変換 # Y だけガンマ補正をかけ直す。 im = _gamma_correction(im, 1 / 2.2) im = im.convert("YCbCr") yy, cb, cr = im.split() # linear yy,cc,cr yy = _gamma_correction(yy, 2.2) # 輝度に対してヒストグラム平坦化 yy = ImageOps.equalize(yy) # Y のガンマ補正を解除して YCbCR=>RGB 変換 # RGB にガンマ補正を掛け直す yy = _gamma_correction(yy, 1 / 2.2) im = Image.merge("YCbCr", (yy, cb, cr)) im = im.convert("RGB") return np.array(_gamma_correction(im, 2.2))
def random_image(sourceimg=None, size=(200, 100)): """Scramble source image to create placeholder image""" if sourceimg is None: sourceimg = Image.open(str(SOURCE_IMG)) width, height = size sqrt2 = 2**.5 regionsize = int(min( max(width, height) * sqrt2, min(sourceimg.size), )) inscribed = int(regionsize / sqrt2) x = random.randint(0, sourceimg.width - regionsize) y = random.randint(0, sourceimg.height - regionsize) subsection = sourceimg.crop([x, y, x + regionsize, y + regionsize]) angle = random.randint(0, 360) rotated = subsection.rotate(angle) ratio = width / height if ratio > 1: cw, ch = inscribed, inscribed / ratio else: cw, ch = inscribed * ratio, inscribed cropbox = ( (regionsize - cw) / 2, (regionsize - ch) / 2, (regionsize + cw) / 2, (regionsize + ch) / 2, ) cropped = rotated.crop(cropbox) blur = ImageFilter.GaussianBlur(1) result = cropped.resize((width, height)) enhanced = result.filter(blur) enhanced = random_bands(enhanced) blended = ImageChops.blend(result, enhanced, 0.5) blended = ImageChops.blend(blended, ImageOps.equalize(blended), 0.5) blended = blended.filter(blur) return blended
def image_to_hash( path_to_image ): """takes an image and returns its hash""" encStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; size = 18, 14 #size = 24, 16 bw = Image.open( path_to_image ) bw = bw.convert('L') bw = ImageOps.equalize(bw) bw = bw.point(lambda x: 0 if x<128 else 255, '1') bw = ImageOps.fit(bw, size, Image.ANTIALIAS) bw.save( "smally.jpg", "JPEG") pixels = bw.load() matrix = [] for row in range(size[1]): vector = [] for col in range(size[0]): color = pixels[col, row] if color == 255: color = 1 vector.append( color ) matrix.append( vector ) imHash = "" imHash += encStr[ int( size[0] / 6 ) ] for row in matrix: symbols = [ row[i:i + 6] for i in range(0, size[0], 6) ] for symbol in symbols: bin = "".join( str(x) for x in symbol ) number = int( bin, 2 ) char = encStr[ number ] imHash += char return imHash
def RGBComposite(TileName,Tm,TileDir,OutDir): st = time.time() #L2A_201912_T49RGQ_20200426T222639_R10m_NIR R = glob.glob(os.path.join(TileDir,'L2A_{}_{}_*_R60m_B04.tif').format(Tm,TileName))[0] G = glob.glob(os.path.join(TileDir, 'L2A_{}_{}_*_R60m_B03.tif').format(Tm,TileName))[0] B = glob.glob(os.path.join(TileDir, 'L2A_{}_{}_*_R60m_B02.tif').format(Tm,TileName))[0] assert os.path.exists(R),"no file name {} exists".format(R) assert os.path.exists(G), "no file name {} exists".format(G) assert os.path.exists(B), "no file name {} exists".format(B) Rr = gdal.Open(R) Gr = gdal.Open(G) Br = gdal.Open(B) proj = Rr.GetProjection() geotrans = Rr.GetGeoTransform() basename = os.path.basename(R).split("_") Name = basename[0]+'_'+basename[1]+'_'+basename[2]+'_'+basename[4]+'_'+'RGB'+'.tif' Path = os.path.join(OutDir,Name) Size = Rr.RasterXSize Data = np.zeros(shape=(Size,Size,3)) Data[:,:,0] = Rr.ReadAsArray()*0.0255 del Rr Data[:, :, 1] = Gr.ReadAsArray()*0.0255 del Gr Data[:, :, 2] = Br.ReadAsArray()*0.0255 del Br Data = Image.fromarray(np.uint8(Data)) Data =ImageOps.equalize(Data) write_Img(Data, Path, proj, geotrans, 1830, 1830, im_bands=3, dtype=gdal.GDT_Byte) del Data end = time.time() print(end - st)
def save_image(array, name, enhance=False): """saves 2d array of values 0-1 to a grayscale PNG""" if (array is None) or array.count() == 0: return import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt from PIL import Image, ImageOps if not os.path.isdir(settings.PNG_DIR): os.makedirs(settings.PNG_DIR) png = os.path.join(settings.PNG_DIR, str(name) + '.png') logger.debug('writing {}'.format(png)) array = plt.cm.jet(array) * 255 array = array.astype(np.uint8) image = Image.fromarray(array) if enhance: image = ImageOps.equalize(image) image = ImageOps.autocontrast(image) image.save(png)
def m3(): Image.MAX_IMAGE_PIXELS = None for fn in os.listdir("all"): if fn.endswith("TIF"): adj_fn = fn.split("_B")[1] if len(adj_fn) == 5: adj_fn = "0" + adj_fn adj_fn = "edited/A_" + adj_fn print(adj_fn) im = Image.open("all/" + fn) print(im.format, im.size, im.mode) if fn.endswith("8.TIF"): box = (800 * 2, 3500 * 2, 1200 * 2, 3900 * 2) region = im.crop(box) else: box = (800, 3500, 1200, 3900) region = im.crop(box) region = region.resize((800, 800)) region = ImageOps.equalize(region) region.save(adj_fn) print(region.size)
def equalize(self, image, params): return ImageOps.equalize(image)
def equalize(img, **__): return ImageOps.equalize(img)
from PIL import Image from PIL import ImageOps import matplotlib.pyplot as plt img = Image.open("/home/abes/Desktop/aa.jpeg") plt.figure(0) plt.subplot(223) plt.xlabel('Image Histogram') plt.imshow(img) gs_image = ImageOps.grayscale(img) hist = gs_image.histogram() for i in range(0, 256): plt.bar(i, hist[i]) plt.subplot(222) plt.xlabel('histogram equilised image') hist_eq = ImageOps.equalize(gs_image) plt.imshow(hist_eq) plt.subplot(224) plt.xlabel('histogram equalization') histeq = list(hist_eq.getdata()) for i in range(0, 256): plt.bar(i, histeq[i]) plt.show()
def transform(self, pil_img, label, **kwargs): return ImageOps.equalize(pil_img), label
def equalize(img, v): ''' {'method': 'equalize'} ''' return ImageOps.equalize(img)
def Equalize(self): img = Image.open(self, 'r') im_e = ImageOps.equalize(img) im_e.save(O_REAL_PATH, "JPEG", quality=100, optimize=True) img.close()
def normalized(img): if isinstance(img, np.ndarray): processed_img = ImageOps.equalize(PILImage.fromarray(img, mode='RGB')) else: processed_img = ImageOps.equalize(img) return processed_img
def equalize(img): if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) return ImageOps.equalize(img)
def run(dir_in, fn_out, cal_dir=None, hist_eq=True, invert=True, hist_eq_roi=None, scalar=None, rescale=True, bpr=True, raw=False): if not fn_out: dir_in = dir_in if dir_in[-1] == '/': dir_in = dir_in[:-1] fn_out = dir_in + '.png' fn_oute = dir_in + '_e.png' else: fn_out = fn_out fn_oute = fn_out _imgn, img_in = im_util.average_dir(dir_in, scalar=scalar) desc = dir_in print('Processing %s' % desc) im_wip = img_in print("Avg min: %u, max: %u" % (np.ndarray.min(np.array(im_wip)), np.ndarray.max(np.array(im_wip)))) if not raw: if not cal_dir: cal_dir = im_util.default_cal_dir(im_dir=dir_in) if not os.path.exists(cal_dir): print("WARNING: default calibration dir %s does not exist" % cal_dir) cal_dir = None if cal_dir: assert os.path.exists(cal_dir) print("Found calibration files at %s" % cal_dir) if rescale and cal_dir: ffimg = Image.open(os.path.join(cal_dir, 'ff.png')) np_ff2 = np.array(ffimg) dfimg = Image.open(os.path.join(cal_dir, 'df.png')) np_df2 = np.array(dfimg) # ff *should* be brighter than df # (due to .png pixel value inversion convention) mins = np.minimum(np_df2, np_ff2) maxs = np.maximum(np_df2, np_ff2) u16_mins = np.full(mins.shape, 0x0000, dtype=np.dtype('float')) u16_ones = np.full(mins.shape, 0x0001, dtype=np.dtype('float')) u16_maxs = np.full(mins.shape, 0xFFFF, dtype=np.dtype('float')) cal_det = maxs - mins # Prevent div 0 on bad pixels cal_det = np.maximum(cal_det, u16_ones) cal_scalar = 0xFFFF / cal_det np_in2 = np.array(im_wip) np_scaled = (np_in2 - mins) * cal_scalar # If it clipped, squish to good values np_scaled = np.minimum(np_scaled, u16_maxs) np_scaled = np.maximum(np_scaled, u16_mins) im_wip = Image.fromarray(np_scaled).convert("I") print("Rescale min: %u, max: %u" % (np.ndarray.min( np.array(im_wip)), np.ndarray.max(np.array(im_wip)))) # Seems this needs to be done after scaling or artifacts get amplified if bpr and cal_dir: badimg = Image.open(os.path.join(cal_dir, 'bad.png')) im_wip = im_util.do_bpr(im_wip, badimg) print("BPR min: %u, max: %u" % (np.ndarray.min( np.array(im_wip)), np.ndarray.max(np.array(im_wip)))) if invert: # IOError("not supported for this image mode") # im_wip = ImageOps.invert(im_wip) im_wip = im_util.im_inv16_slow(im_wip) print("Invert min: %u, max: %u" % (np.ndarray.min( np.array(im_wip)), np.ndarray.max(np.array(im_wip)))) print("Save %s" % fn_out) im_wip.save(fn_out) # https://stackoverflow.com/questions/43569566/adaptive-histogram-equalization-in-python # simple implementation # CV2 might also work if hist_eq: mode = os.getenv("FAXITRON_EQ_MODE", "0") print("Eq mode (FAXITRON_EQ_MODE) %s" % mode) if mode == "0": if hist_eq_roi: x1, y1, x2, y2 = hist_eq_roi ref_im = im_wip.crop((x1, y1, x2, y2)) else: ref_im = im_wip ref_np2 = np.array(ref_im) wip_np2 = np.array(im_wip) wip_np2 = im_util.histeq_np_apply( wip_np2, im_util.histeq_np_create(ref_np2)) im_wip = im_util.npf2im(wip_np2) elif mode == "convert": with util.AutoTempFN(suffix='.png') as tmpa: with util.AutoTempFN(suffix='.png') as tmpb: im_wip.save(tmpa) subprocess.check_call( "convert %s \( +clone -equalize \) -average %s" % (tmpa, tmpb), shell=True) im_wip = Image.open(tmpb) elif mode == "1": # OSError: not supported for this image mode im_wip = ImageOps.equalize(im_wip, mask=None) elif mode == "2": imnp = np.array(im_wip, dtype=np.uint16) im_wip = im_util.npf2im(exposure.equalize_hist(imnp)) elif mode == "3": # raise ValueError("Images of type float must be between -1 and 1.") imnp = np.array(im_wip, dtype=np.uint16) #imnp = np.ndarray.astype(imnp, dtype=np.float) print(np.ndarray.min(imnp), np.ndarray.max(imnp)) imnp = 1.0 * imnp / 0xFFFF im_wip = im_util.npf2im( exposure.equalize_adapthist(imnp, clip_limit=0.03)) else: raise Exception(mode) print("Save %s" % fn_oute) im_wip.save(fn_oute) print("Eq min: %u, max: %u" % (np.ndarray.min( np.array(im_wip)), np.ndarray.max(np.array(im_wip))))
def _imequalize(img): # equalize the image using PIL.ImageOps.equalize from PIL import ImageOps, Image img = Image.fromarray(img) equalized_img = np.asarray(ImageOps.equalize(img)) return equalized_img
def equalize(pil_image: PIL.Image) -> PIL.Image: return ImageOps.equalize(pil_image)
def test_sanity(self): ImageOps.autocontrast(hopper("L")) ImageOps.autocontrast(hopper("RGB")) ImageOps.autocontrast(hopper("L"), cutoff=10) ImageOps.autocontrast(hopper("L"), ignore=[0, 255]) ImageOps.autocontrast_preserve(hopper("L")) ImageOps.autocontrast_preserve(hopper("RGB")) ImageOps.autocontrast_preserve(hopper("L"), cutoff=10) ImageOps.autocontrast_preserve(hopper("L"), ignore=[0, 255]) ImageOps.colorize(hopper("L"), (0, 0, 0), (255, 255, 255)) ImageOps.colorize(hopper("L"), "black", "white") ImageOps.crop(hopper("L"), 1) ImageOps.crop(hopper("RGB"), 1) ImageOps.deform(hopper("L"), self.deformer) ImageOps.deform(hopper("RGB"), self.deformer) ImageOps.equalize(hopper("L")) ImageOps.equalize(hopper("RGB")) ImageOps.expand(hopper("L"), 1) ImageOps.expand(hopper("RGB"), 1) ImageOps.expand(hopper("L"), 2, "blue") ImageOps.expand(hopper("RGB"), 2, "blue") ImageOps.fit(hopper("L"), (128, 128)) ImageOps.fit(hopper("RGB"), (128, 128)) ImageOps.flip(hopper("L")) ImageOps.flip(hopper("RGB")) ImageOps.grayscale(hopper("L")) ImageOps.grayscale(hopper("RGB")) ImageOps.invert(hopper("L")) ImageOps.invert(hopper("RGB")) ImageOps.mirror(hopper("L")) ImageOps.mirror(hopper("RGB")) ImageOps.posterize(hopper("L"), 4) ImageOps.posterize(hopper("RGB"), 4) ImageOps.solarize(hopper("L")) ImageOps.solarize(hopper("RGB"))