Пример #1
0
def zealous_crop(page_groups):
    # Zealous crop all of the pages. Vertical margins can be cropped
    # however, but be sure to crop all pages the same horizontally.
    for idx in (0, 1):
        # min horizontal extremes
        minx = None
        maxx = None
        width = None
        for grp in page_groups:
            for pdf in grp[idx].values():
                bbox = ImageOps.invert(pdf.convert("L")).getbbox()
                if bbox is None: continue # empty
                minx = min(bbox[0], minx) if minx is not None else bbox[0]
                maxx = max(bbox[2], maxx) if maxx is not None else bbox[2]
                width = max(width, pdf.size[0]) if width is not None else pdf.size[0]
            if width != None:
                minx = max(0, minx-int(.02*width)) # add back some margins
                maxx = min(width, maxx+int(.02*width))
            # do crop
            for pg in grp[idx]:
                im = grp[idx][pg]
                bbox = ImageOps.invert(im.convert("L")).getbbox() # .invert() requires a grayscale image
                if bbox is None: bbox = [0, 0, im.size[0], im.size[1]] # empty page
                vpad = int(.02*im.size[1])
                im = im.crop( (0, max(0, bbox[1]-vpad), im.size[0], min(im.size[1], bbox[3]+vpad) ) )
                if os.environ.get("HORZCROP", "1") != "0":
                    im = im.crop( (minx, 0, maxx, im.size[1]) )
                grp[idx][pg] = im
def strip_processing(path, blur_radius=7, iter_steps=1, binarize_threshold=10):

    """Strip precessing function.

    Inputs:
    string: path of the image
    blur_radius: radius of gaussian blur
    iter_steps: execution times of denoise
    binarize_threshold: used as function lut's input

    Outputs:
    Image: the processed image."""

    gray=ImageOps.invert(ImageOps.grayscale(Image.open("stripes.jpg")))
    gray_blur=gray.filter(ImageFilter.GaussianBlur(blur_radius))
    high_freq=ImageMath.eval("25*(a-b)",a=gray,b=gray_blur).convert("L")

    binarized=ImageOps.invert(high_freq.point(lut(binarize_threshold))).convert("1")
    binarized_data=binarized.load()
    #binarized.show()

    height=binarized.height
    width=binarized.width

    pix=np.array([[np.uint8(binarized_data[j,i]) for j in range(width)] for i in range(height)])

    for i in range(iter_steps):
        pix=denoise(pix)

    answer=Image.fromarray(pix)
    #answer.show()
    #answer.save("test.bmp")
    return answer
Пример #3
0
    def make_inverted(self, image):

        if image == 1:
            self.img1.image = ImageOps.invert(self.img1.image)
        elif image == 2:
            self.img2.image = ImageOps.invert(self.img2.image)
        elif image == 3:
            self.img3.image = ImageOps.invert(self.img3.image)
Пример #4
0
def invertimage(image):
    if image.mode == 'RGBA':
        r,g,b,a = image.split()
        rgb_image = Image.merge('RGB', (r,g,b))
        inverted_image = ImageOps.invert(rgb_image)
        r2,g2,b2 = inverted_image.split()
        final_image = Image.merge('RGBA', (r2,g2,b2,a))
    else:
        final_image = ImageOps.invert(image)
    return final_image    
Пример #5
0
def get_RGB_split_inverted(image):
    if not is_RGB(image):
        raise Exception("Not RGB mode")

    image_r, image_g, image_b = image.split()
    image_rn = ImageOps.invert(image_r)
    image_gn = ImageOps.invert(image_g)
    image_bn = ImageOps.invert(image_b)

    return image_rn, image_gn, image_bn
Пример #6
0
	def threshold(img, thresh):
		"""Threshold an image"""
		
		pilIMG1 = Image.fromarray(img);
		pilInverted1 = ImageOps.invert(pilIMG1);
		inverted = numpy.asarray(pilInverted1);
		r, t = cv2.threshold(inverted, thresh, 0, type=cv.CV_THRESH_TOZERO);
		pilIMG2 = Image.fromarray(t);
		pilInverted2 = ImageOps.invert(pilIMG2);
		thresholded = numpy.asarray(pilInverted2);
		return thresholded;
Пример #7
0
def overlay_im_orig(images):
    if not images:
        return None
    min_im = None
    max_im = None
    for im in images:
        min_im = im if min_im == None else ImageChops.darker(im, min_im)
        max_im = im if max_im == None else ImageChops.lighter(im, max_im)
    overlay   = Image.new("RGBA", images[0].size, (255,255,255,255))
    overlay.paste(Image.new("RGB", images[0].size, COLOR1), None, ImageOps.invert(min_im))
    overlay.paste(Image.new("RGB", images[0].size, COLOR2), None, ImageOps.invert(max_im))
    return overlay
Пример #8
0
def make_all_night_image(day):
    # Normalize to midnight
    day_start = datetime(day.year, day.month, day.day, tzinfo=est)

    # Find that day's sunset
    obs = get_observer()
    sunset_time = sunset(obs, day_start)

    # And next day's sunrise
    sunrise_time = sunrise(obs, sunset_time)

    # One hour after and before to remove all light
    start_time = normalize_time(sunset_time + timedelta(hours=1))
    end_time = normalize_time(sunrise_time - timedelta(hours=1))

    normals = Normal.objects.filter(timestamp__gte=start_time, timestamp__lte=end_time, info__isnull=False)

    img_light = None

    for normal in normals:
        source = Image.open(normal.info.filepath)

        # Make light image
        if img_light is None:
            img_light = source
        else:
            img_light = ImageChops.lighter(img_light, source)


    # Put a date on the image
    daystr = day.strftime('%Y-%m-%d')
    canvas = ImageDraw.Draw(img_light)
    canvas.text((20,1500), daystr)

    # And save
    filename = daystr + '.png'
    filename_neg = daystr + '_neg.png'

    imagepath = os.path.join(TIMELAPSE_DIR, APP_DIR, 'allnight')
    
    # Make directory if it doesn't exist
    if not os.path.exists(imagepath):
        os.makedirs(imagepath)

    img_filepath = os.path.join(imagepath, filename)
    img_light.save(img_filepath)
    image_record = get_image_product(day_start, start_time, end_time, Product.ALLNIGHT, imagepath, filename)
    record_size(img_filepath, image_record)

    img_neg_filepath = os.path.join(imagepath, filename_neg)
    ImageOps.invert(img_light).save(img_neg_filepath)
    image_record_neg = get_image_product(day_start, start_time, end_time, Product.ALLNIGHT_NEG, imagepath, filename_neg)
    record_size(img_neg_filepath, image_record_neg)
Пример #9
0
def find_image_centroid(target_image, colour_threshold=166, use_mask=False, use_mask_gradient=False, verbose=False):

	if verbose:
		print('Converting image to greyscale, and detecting edges...')
	edge_detected_image = ImageOps.invert(target_image.copy().filter(ImageFilter.FIND_EDGES))

	# If we're using a mask (to try to direct detection to the edges of the image)
	if use_mask == True:

		# Gradient mask affects detection less, but is more "fair".
		if use_mask_gradient == True:
			mask = Image.new('L', (1,511))
			for y in range(511):
				mask.putpixel((0, 510-y), 254-int(fabs(254-y)))
			mask = mask.resize(target_image.size, Image.NEAREST)

		# Our normal mask is just a rectangle taking up twice the difference between the two image sizes
		elif use_mask_gradient == False:
			mask = Image.new('L', target_image.size)
			drawmask = ImageDraw.Draw(mask)
			drawmask.rectangle(
				[
					(fabs(target_image.size[0] - target_width)*2, fabs(target_image.size[1] - target_height)*2),
					(edge_detected_image.size[0] - fabs(target_image.size[0] - target_width)*2, edge_detected_image.size[1] - fabs(target_image.size[1] - target_height)*2)
				],
				fill=(255)
			)
			del drawmask

		# Overlaying the mask
		draw = ImageDraw.Draw(edge_detected_image)
		draw.bitmap([0,0], mask)
		del draw

	# Convert to greyscale, and apply a hard threshold to weed out less stark contrast
	edge_detected_image = ImageOps.invert(edge_detected_image).convert("L").point(lambda i: i > colour_threshold and 255 or 0)

	# Centroid logic contributed by Ben Stewart
	if verbose:
		print('Finding centroid...')

	# Sum of colours in image
	image_sum = sum([sum(row) for row in asarray(edge_detected_image)])

	weighted_rows = sum([y * sum(row) for y, row in enumerate(asarray(edge_detected_image))])
	centroid_y = weighted_rows / image_sum

	weighted_cols = sum([sum([x * val for x, val in enumerate(row)]) for row in asarray(edge_detected_image)])
	centroid_x = weighted_cols / image_sum

	return (centroid_x, centroid_y)
Пример #10
0
    def stitchedReverse(self, inputImageName, lookupImageNames):
        matches = []
        a = Image.open(self.getImagePathByName('A')).convert(mode='L', dither=Image.NONE)
        originalWidth, originalHeight = a.size
        halfWidth = originalWidth / 2

        left = 0
        top = 0
        right = halfWidth
        bottom = originalHeight
        leftHalf = a.crop((left, top, right, bottom))

        left = right
        right = originalWidth
        rightHalf = a.crop((left, top, right, bottom))

        stitched = Image.new('RGB', (originalWidth, originalHeight))
        stitched.paste(im=rightHalf, box=(0, 0))
        stitched.paste(im=leftHalf, box=(halfWidth, 0))
        stitched = stitched.convert(mode='L', dither=Image.NONE)

        for problemImageName in lookupImageNames:
            x = Image.open(self.getImagePathByName(problemImageName)).convert(mode='L', dither=Image.NONE)
            stitched1 = ImageOps.invert(stitched)
            try:
                p1, q1, r1, s1 = stitched1.getbbox()
                a1 = abs(p1 - r1) * abs(r1 - s1)
                x1 = ImageOps.invert(x)
                try:
                    p2, q2, r2, s2 = x1.getbbox()
                    a2 = abs(p2 - r2) * abs(r2 - s2)
                    p = q = r = s = None
                    if a1 <= a2:
                        p, q, r, s = p1, q1, r1, s1
                    else:
                        p, q, r, s = p2, q2, r2, s2
                    stitched1 = stitched.crop((p, q, r, s))
                    x1 = x.crop((p, q, r, s))
                    diff = self.getImageDifference(stitched1, x1)
                    log.info('{} diff: {}'.format(problemImageName, diff))
                    matches.append([problemImageName, diff])
                except TypeError:
                    # empty image
                    pass
            except TypeError:
                # empty image
                pass
        matches.sort(lambda x, y: cmp(x[1], y[1]))
        return matches
        pass
Пример #11
0
def main():
    im = Image.open('3.png')
    new_im = normalize_image(im)
    new_im.save('9_new.png')

    for path in glob.glob('Photo*.jpg'):
        user_im = Image.open(path)
        user_im = ImageOps.invert(user_im)
        user_im = user_im.crop(user_im.getbbox())
        user_im = ImageOps.invert(user_im)

        user_im = normalize_image(user_im)
        if correct_pixels_ratio(new_im, user_im) > 0.1:
            user_im.save('new_' + path)
Пример #12
0
def add_distortion(img, rotation=30, jitter=10, resize=0.05):
    dx = random.randint(-jitter, +jitter)
    dy = random.randint(-jitter, +jitter)
    dr = random.uniform(-rotation, +rotation)
    ds = random.uniform(1.0 - resize, 1.0 + resize)
    
    width, height = img.width, img.height

    img = ImageOps.invert(img)
    img = img.rotate(dr)
    img = ImageChops.offset(img, dx, dy)
    img = ImageOps.invert(img)
    
    return img
Пример #13
0
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()
Пример #14
0
Файл: rml.py Проект: Ames/RML
def doImage(path,rot):
    try:
        from PIL import Image, ImageOps
    except:
        err("please install Python Image Library")
        return
    
    try:
        img = Image.open(path)
    except:
        err("file "+path+" not found!")
        return
    

    # convert to greyscale, invert
    img=ImageOps.invert(img.convert('L'))
    
    if rot:
        img=img.rotate(90)
        
        
    # figure out the desired W and H
    
    if img.size[0]<=384:
        # if the image is less than the max, 
        # round the width up to a multible of 8
        img=img.crop((0,0,int(ceil(img.size[0]/8.)*8),img.size[1]))
    else:
        # if the image is larger than the max,
        # scale it down to the max
        img=img.resize((384,img.size[1]*384/img.size[0]))
    
    
    # if verbose, show the image.
    if myIO.verbose:
        ImageOps.invert(img).convert('1').show()
    
    # stringify
    imgStr=img.convert('1').tostring()
    
    
    info(path+' '+str(img.size))
    
    # (GS v)
    devSend('\x1D\x76\0\0'+twoBytes(img.size[0]/8)+twoBytes(img.size[1])+imgStr)
    
    # I think we should wait for the data to send/print
    time.sleep(6)
Пример #15
0
def startRecognition( infile, rotation=False, z=0 ):
  global newImage
  prefix = infile[:8]
  im = Image.open(infile)
  if rotation:
    im = im.rotate(rotation)
  width, height = im.size
  resized = im.resize( ( width/25, height/30 ), Image.BICUBIC )
  resized = ImageOps.invert(resized)
  imgData = barImage( resized )
  foundBarcode, newImage, newBar = False, False, False

  for probable_barcode in imgData.findBarcode():
    z+=1
    # Try the first 20 barcodes, and see if one of them is legit.
    if foundBarcode:
      continue
    try: 
      x1, y1 = (probable_barcode[1]-3)*25, (probable_barcode[2]) * 30
      x2, y2 = x1+635, y1+265
      if x2 > im.size[0] or y2 > im.size[1]:
        x2,y2 = im.size[0], im.size[1]
        x1,y1 = im.size[0]-800, im.size[1]-265
      newImage = im.crop((x1,y1,x2,y2))
      newBar   = barImage(newImage)
      foundBarcode = straightenBarcode ( newBar, "Hard", prefix=prefix ) 
      if DEBUG and not foundBarcode:
        smoo = im.crop( (x1,y1,x2,y2) )
        smoo.save("%s.fail.%03d.barcode.png" % (prefix, z) )
        print "Z:  ", z
    except:
      foundBarcode = False
      raise

  if foundBarcode:
    log.info("Found barcode for %s." % prefix )
    newImage.putdata(newBar.im.reshape(newBar.stride*newBar.height))
    newImage = ImageOps.invert(newImage)
    newImage.save("%s.barcode.pre.png" % prefix )
    try: 
      (x1, y1),(x2,y2)  = newBar.findBarcodeLimits("Hard")
      doPostBarcodeAnalysis(newImage.crop((x1-40,y1+1,x1+520,y1+90)), prefix )
    except:
      pass
  elif not rotation:
    startRecognition( infile, rotation=90, z=z )
  else:
    log.info("No barcode found for %s.", prefix)
Пример #16
0
def main():
    if not os.path.exists('emoji'):
        os.mkdir('emoji')

    for font, glyphs in fonts.items():
        for name, glyph in glyphs.items():
            try:
                colours = glyph.colours
                font_size = glyph.size
                glyph = glyph.letter
            except AttributeError:
                colours = [Icon.default_colour]
                font_size = 128

            imfont = ImageFont.truetype(font, font_size)
            for colour_name, colour in colours:
                im = Image.new("RGBA", (300, 300), (255, 255, 255, 0))

                draw = ImageDraw.Draw(im)
                draw.text((50, 50), glyph, font=imfont, fill=colour)

                # remove unneccessory whitespaces if needed
                im = im.crop(ImageOps.invert(im.convert('RGB')).getbbox())

                # im = ImageOps.invert(im)
                im.thumbnail(size, Image.ANTIALIAS)

                background = Image.new('RGBA', size, (255, 255, 255, 0))
                background.paste(
                    im,
                    ((size[0] - im.size[0]) // 2, (size[1] - im.size[1]) // 2))

                # write into file
                background.save(f"emoji/{colour_name}{name}.png")
Пример #17
0
    def update(self, speed):

        result = None

        if self.updateFlag:
            self.im = None
            self.updateFlag = False
            self.loadGif(self.gifList[self.gifIndex])

        if not self.im == None:
            if self.newFlag:
                self.newFlag = False
                result = self.frame

            else:
                currentTime = int(round(time.time() * 1000))
                elapsed = currentTime - self.lastTime

                if elapsed >= self.delay and self.delay > 0:
                    self.lastTime = currentTime
                    self.nextFrame()
                    result = self.frame

        if result != None:
            result = result.convert("RGB")

            if self.invertFlag:
                result = ImageOps.invert(result)

            if self.mirrorFlag:
                result = result.transpose(Image.FLIP_LEFT_RIGHT)

            result = result.getdata()

        return result
Пример #18
0
def segment(image_filepath, **kwargs):
    input_img = Image.open(image_filepath)

    # make a '1' bit image with the same size as the input_img
    mask_img = Image.new('1', input_img.size)

    # instantiate an ImageDraw object using the mask_img object
    mask_drawer = ImageDraw.Draw(mask_img)

    try:
        json_poly_data = json.loads(kwargs['JSON'])
    except ValueError:
        # There's a problem in the JSON - it may be malformed, or empty
        json_poly_data = []

    for polygon in json_poly_data:
        flattened_poly = [j for i in polygon for j in i]
        mask_drawer.polygon(flattened_poly, outline=1, fill=1)

    output_img = ImageMath.eval('b - a', a=input_img, b=mask_img)
    output_img = ImageOps.invert(output_img.convert('RGB'))

    encoded = json.dumps(json_poly_data)

    return {
        'tiff': output_img,
        'json': encoded
    }
Пример #19
0
    def _extract_percents(self, image, y_ticks, left_line_x) -> list:
        percents = []
        for tick in y_ticks:
            # todo 25 here is hardcoded and bug-prone estimation.
            # In fact we need to look for white strips from left to right.
            # First such stripe will be border of image and second border of percents. Its right-x coordinate is what we need here

            box = (25, tick - 5, left_line_x - 3, tick + 5)
            region = image.crop(box)

            text = region.crop(ImageOps.invert(region.convert('RGB')).getbbox())
            # debug
            # region.save(str(tick)+'.bmp')
            word = ''
            leftmost_unread_pixel = 0
            while leftmost_unread_pixel < text.size[0]:
                x_left = leftmost_unread_pixel
                x_right = leftmost_unread_pixel + self.tesser.max_width
                if x_right > text.size[0]:
                    x_right = text.size[0]
                glyph = Image.new('RGBA', (x_right - x_left, 8), (255, 255, 255))
                glyph.paste(text.crop((x_left, 0, x_right, 8)))
                letter, width = self.tesser.tess(glyph)
                word += letter
                leftmost_unread_pixel += width
            percents.append((float(word), tick))

        return sorted(percents)
Пример #20
0
def createDigitsModel(fontfile, digitheight):
    ttfont = ImageFont.truetype(fontfile, digitheight)
    samples =  np.empty((0,digitheight*(digitheight/2)))
    responses = []
    for n in range(10):
        pil_im = Image.new("RGB", (digitheight, digitheight*2))
        ImageDraw.Draw(pil_im).text((0, 0), str(n), font=ttfont)
        pil_im = pil_im.crop(pil_im.getbbox())
        pil_im = ImageOps.invert(pil_im)
        #pil_im.save(str(n) + ".png")

        # convert to cv image
        cv_image = cv2.cvtColor(np.array( pil_im ), cv2.COLOR_RGBA2BGRA)
        gray = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
        blur = cv2.GaussianBlur(gray,(5,5),0)
        thresh = cv2.adaptiveThreshold(blur,255,1,1,11,2)

        roi = cv2.resize(thresh,(digitheight,digitheight/2))
        responses.append( n )
        sample = roi.reshape((1,digitheight*(digitheight/2)))
        samples = np.append(samples,sample,0)

    samples = np.array(samples,np.float32)
    responses = np.array(responses,np.float32)
    
    model = cv2.KNearest()
    model.train(samples,responses)
    return model
Пример #21
0
    def __init__(self, img_source):
        """
        Load in an image
        
        :param img_source: PIL.Image, or filename to load one from.
        """
        if isinstance(img_source, Image.Image):
            img_original = img_source
        else:
            img_original = Image.open(img_source)

        # store image for eventual further processing (splitting)
        self.img_original = img_original

        # Convert to white RGB background, paste over white background
        # to strip alpha.
        img_original = img_original.convert('RGBA')
        im = Image.new("RGB", img_original.size, (255, 255, 255))
        im.paste(img_original, mask=img_original.split()[3])
        # Convert down to greyscale
        im = im.convert("L") 
        # Invert: Only works on 'L' images
        im = ImageOps.invert(im)
        # Pure black and white
        self._im = im.convert("1")
Пример #22
0
def apply_invert(pixbuf):
    '''
    negative of an image (darkest-->lightest | lightest-->darkest)
    '''
    width,height = pixbuf.get_width(),pixbuf.get_height() 
    y = ImageOps.invert(Image.frombytes(K.ImageConstants.RGB_SHORT_NAME,(width,height),pixbuf.get_pixels() ))
    return I.fromImageToPixbuf(y)
Пример #23
0
    def invert_and_resize(self,newsize=600):
        '''
        Given a position and uncertainty, create a finding chart from the DSS
        (Move this to another module)
    
        Requires PIL
        http://pythonmac.org/packages/py25-fat/index.html
        http://www.p16blog.com/p16/2008/05/appengine-installing-pil-on-os-x-1053.html
    
        '''
        # SDSS - later http://casjobs.sdss.org/ImgCutoutDR5/getjpeg.aspx?ra=264.191&dec=-25.212&scale=0.8&width=750&height=750
    
        self.img_size = newsize # in pixels

        try:
            im1 = Image.open(self.image_path)
        except:
            errstring = 'Could not open %s; image may be malformed.' % (self.image_path)
            raise IOError(errstring)

        # Invert Colors
        im1 = ImageOps.invert(im1)
        # Convert to color mode
        im1 = im1.convert('RGB')
        # Resize with a cubic spline - it looks nice.
        # Other options are NEAREST, BILINEAR, ANTIALIAS
        im1 = im1.resize((newsize,newsize),Image.BICUBIC)
        self.save_str = storepath+'FCBase.png'
        im1.save(self.save_str)
Пример #24
0
  def process_rasters_in_dir(self, rootdir):
    '''
        descends through a TMS tile structure and converts the images
        to a matrix of dimensions: num_images * width * height, dtype=numpy.uint8
    '''

    height = self.thumb_size
    width = self.thumb_size
    num_images = self.count_rasters_in_dir(rootdir)
    images = numpy.zeros(num_images * width * height, dtype=numpy.uint8)
    images = images.reshape(num_images, height, width)
    
    index = 0
    for folder, subs, files in os.walk(rootdir):
      for filename in files:
        if not filename.endswith('.jpg'):
            continue
        tile = self.tile_for_folder_and_filename(folder, filename, rootdir)
        image_filename = os.path.join(folder, filename)
        with open(image_filename, 'rb') as img_file:
          with Image.open(img_file) as open_pil_img:
            pil_image = open_pil_img.convert("L")
            pil_image = ImageOps.invert(pil_image)
        image_matrix = numpy.asarray(pil_image, dtype=numpy.uint8)
        images[index] = image_matrix
        index += 1
    print("Packing {} images to a matrix of size num_images * width * height, dtype=numpy.uint8".format(index))

    # Reshape to add a depth dimension
    return images.reshape(num_images, width, height, 1)
Пример #25
0
def crop(image):
    # Invert the image so the bounding box calculation works
    inverted = ImageOps.invert(image.convert('L'))
    # Found a bounding box for the non-white parts of the image
    box = inverted.getbbox()
    # Return the cropped image and bounding box
    return image.crop(box), box
Пример #26
0
	def convertImage(self, inputPath, outputPath):
		r = inputPath
		path = outputPath

		for root, dirs, files in os.walk(r):
			for f in files:
				if f.endswith('.gif'):
					if not os.path.exists(path): #Tworzony jest folder wyjsciowy
						os.makedirs(path)

					newroot = root.split(r)[1] #Te dwie linijki moga powodowac problemy, dlatego wazne jest, by obrazy do konwersji znajdowaly sie w podfolderach
					newroot = newroot.split('/')[1] #Podfolder

					f2 = f.split('.')[0]

					orgImg = Image.open(root + "/" + f)
					orgImg = orgImg.convert('L')
					orgSize = orgImg.size
					# niech beda tylko kwadratowe obrazy
					assert orgSize[0] == orgSize[1]
					assert self.newSize[0] == self.newSize[1]
					borderSize = int((self.newSize[0] - orgSize[0]) / 2)
					# dodanie bialej ramki
					newImg = ImageOps.expand(orgImg, borderSize, 0)
					# zapisanie wersji bez inwersji
					newImg.save(path + newroot + f2 + ".pgm")
					# dodanie wersji z inwersja
					newImg = ImageOps.invert(newImg)
					newImg.save(path + newroot + "n" + f2 + ".pgm")
Пример #27
0
    def __call__(self, img_group):

        if self.scale_worker is not None:
            img_group = self.scale_worker(img_group)
        image_w, image_h = img_group[0].size
        crop_w, crop_h = self.crop_size

        offsets = GroupMultiScaleCrop.fill_fix_offset(False, image_w, image_h, crop_w, crop_h)
        oversample_group = list()
        for o_w, o_h in offsets:
            normal_group = list()
            flip_group = list()
            for i, img in enumerate(img_group):
                crop = img.crop((o_w, o_h, o_w + crop_w, o_h + crop_h))
                normal_group.append(crop)
                flip_crop = crop.copy().transpose(Image.FLIP_LEFT_RIGHT)

                if img.mode == 'L' and i % 2 == 0:
                    flip_group.append(ImageOps.invert(flip_crop))
                else:
                    flip_group.append(flip_crop)

            oversample_group.extend(normal_group)
            oversample_group.extend(flip_group)
        return oversample_group
Пример #28
0
def filter_contrastToAlpha(image, baseDir):
  alpha = Image.new('L', image.size, 255)
  alpha.paste(image, mask=get_alpha(image))
  alpha = ImageOps.invert(alpha)
  alpha = ImageOps.autocontrast(alpha)

  return Image.merge('LA', [Image.new('L', image.size), alpha])
Пример #29
0
def tileify(image_data, num_blocks, max_shift):
    """
    Breaks image up into rectangles and shifts them a random distance
    Areas not covered by the moved rectangles are the negative of
    the original image
    """
    width = image_data.size[0]
    height = image_data.size[1]
    row_block_size = round(height / num_blocks)
    col_block_size = round(width / num_blocks)
    negative_image = ImageOps.invert(image_data)
    pixels = array(image_data)
    for row in xrange(num_blocks):
        inner_row_val = int(row_block_size * row)
        outer_row_val = int(row_block_size * row + row_block_size)
        for col in xrange(num_blocks):
            inner_col_val = int(col_block_size * col)
            outer_col_val = int(col_block_size * col + col_block_size)
            block = pixels[
                inner_row_val:outer_row_val,
                inner_col_val:outer_col_val
            ]
            location = calculate_random_location(
                inner_row_val,
                inner_col_val,
                max_shift
            )
            negative_image.paste(Image.fromarray(block), location)
    return negative_image
Пример #30
0
def invert(img):
    img = Image.fromarray(img)
    inverted_img = ImageOps.invert(img)
    inverted_img_array = np.asarray(inverted_img)
    return inverted_img_array
Пример #31
0
def invert(img, magnitude):
    img = ImageOps.invert(img)
    return img
Пример #32
0
def invert(img, **__):
    return ImageOps.invert(img)
Пример #33
0
import keras
import numpy as np
from PIL import Image, ImageOps
from keras.datasets import mnist
from keras.models import Sequential, load_model
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
from keras.preprocessing import image

print('Loading model...')
model = keras.models.load_model('models')

img_width, img_height = 28, 28

source = Image.open('./images/0_2.png').convert('L').resize((img_width, img_height), 0)
source = ImageOps.invert(source)
# pil_image = Image.fromarray(color_coverted)
# pil_image = pil_image.convert('L')
# pil_image = pil_image.resize((28, 28))

# test_image = image.load_img('./images/5.png', color_mode='grayscale', target_size=(img_width, img_height))

test_image = image.img_to_array(source)
test_image = test_image.astype('float32')
test_image = test_image.reshape(28, 28)
test_image = 255 - test_image
test_image /= 255
test_image = test_image.reshape(1, img_width * img_height)
print(test_image)

# test_image = image.img_to_array(source)
Пример #34
0
def crop_by_coords(original, coords, inv=False):
    img = original.crop(coords)
    if inv:
        img = ImageOps.invert(img)
    return img.resize((3 * length(coords), 3 * height(coords)))
Пример #35
0
            os.remove(os.path.join(angle_folder, file))

    w = h = args.size
    b = h / 2  # Height of the triangle
    A = (w / 2, b)  # Tip of the triangle
    for angle in np.linspace(15, 160, 30):
        angle_rad = np.deg2rad(angle / 2)
        name = os.path.join(angle_folder, f'angle{angle:03.0f}-{{}}.{args.filetype}')
        B = (w / 2 + b * np.tan(angle_rad), 0)
        C = (w / 2 - b * np.tan(angle_rad), 0)
        im = Image.new('L', (w, h), color=255)
        draw = ImageDraw.Draw(im)
        draw.polygon([C, B, A], fill='black')
        im.save(name.format('0'))
        if args.invert:
            ImageOps.invert(im).save(name.format('0i'))
        elif args.rotate and args.invert:
            im = im.rotate(90)
            im.save(name.format('1'))
            ImageOps.invert(im).save(name.format('1i'))
            im = im.rotate(90)
            im.save(name.format('2'))
            ImageOps.invert(im).save(name.format('2i'))
            im = im.rotate(90)
            im.save(name.format('3'))
            ImageOps.invert(im).save(name.format('3i'))
        elif args.rotate:
            im = im.rotate(90)
            im.save(name.format('1'))
            im = im.rotate(90)
            im.save(name.format('2'))
Пример #36
0
def invert(image: Image.Image, mode: str = "pillow") -> Image.Image:
    if 'pil' in mode.lower():
        return ImageOps.invert(image.convert('L')).convert('1')
    else:
        return Image.fromarray(obj=np.invert(np.array(image)), mode='1')
Пример #37
0
def main():
    args = parse_args()

    with open(args.font, 'r', encoding='utf-8') as f:
        font = json.load(f)

    if args.text == '-':
        text = sys.stdin.read().rstrip('\n')
    else:
        text = args.text

    if not text:
        sys.exit('Text is empty.')

    glyph_lookup = {}
    for glyph in font['glyphs']:
        glyph_lookup[glyph['codePoint']] = glyph

    kerning_lookup = {}
    for kerning_pair in font['kerningPairs']:
        cp1 = kerning_pair['codePoint1']
        cp2 = kerning_pair['codePoint2']
        kerning_lookup[(cp1, cp2)] = kerning_pair['amount']

    page_lookup = load_pages_for_text(
        text, font, os.path.dirname(args.font), glyph_lookup)

    min_canvas_size = get_image_size_for_text(
        text, font, glyph_lookup, kerning_lookup)

    padding_px = round(
        font['bakingOptions']['fontPxSize'] * args.padding)
    canvas_size = (
        min_canvas_size[0] + padding_px * 2,
        min_canvas_size[1] + padding_px * 2
    )

    grayscale_mode = all(p.mode == 'L' for p in page_lookup.values())
    if grayscale_mode:
        canvas_mode = 'L'
        fill_color = 0
    else:
        canvas_mode = 'RGBA'
        fill_color = (255, 255, 255, 0)

    canvas = Image.new(canvas_mode, canvas_size, fill_color)
    render_text(
        text, canvas, (padding_px, padding_px),
        font, glyph_lookup, page_lookup, kerning_lookup)

    if grayscale_mode:
        if args.transparent:
            new_canvas = Image.new('LA', canvas.size, (0, 255))
            new_canvas.putalpha(canvas)
            canvas = new_canvas
        else:
            canvas = ImageOps.invert(canvas)
    elif not args.transparent:
        bg = Image.new('RGB', canvas.size, (255 ,255, 255))
        bg.paste(canvas, mask=canvas.split()[-1])
        canvas = bg

    out_image_path = args.out_image
    if os.path.splitext(out_image_path)[1].lower() != '.png':
        out_image_path += '.png'

    out_image_dir = os.path.dirname(out_image_path)
    if out_image_dir:
        os.makedirs(out_image_dir, exist_ok=True)

    canvas.save(out_image_path, optimize=True)
Пример #38
0
    def __init__(self,
                 mapfile,
                 camera=None,
                 light=None,
                 width=100.0,
                 depth=100.0,
                 height=10.0,
                 divx=0,
                 divy=0,
                 ntiles=1.0,
                 name="",
                 x=0.0,
                 y=0.0,
                 z=0.0,
                 rx=0.0,
                 ry=0.0,
                 rz=0.0,
                 sx=1.0,
                 sy=1.0,
                 sz=1.0,
                 cx=0.0,
                 cy=0.0,
                 cz=0.0,
                 smooth=True,
                 cubic=False):
        """uses standard constructor for Shape

    Arguments:
      *mapfile*
        Greyscale image path/file, string.

    Keyword arguments:
      *width, depth, height*
        Of the map in world units.
      *divx, divy*
        Number of divisions into which the map will be divided.
        to create vertices
      *ntiles*
        Number of repeats for tiling the texture image.
      *smooth*
        Calculate normals with averaging rather than pointing
        straight up, slightly faster if false.
    """
        super(ElevationMap, self).__init__(camera, light, name, x, y, z, rx,
                                           ry, rz, sx, sy, sz, cx, cy, cz)
        if VERBOSE:
            print("Loading height map ...", mapfile)

        if divx > 200 or divy > 200:
            print("... Map size can't be bigger than 200x200 divisions")
            divx = 200
            divy = 200

        im = Image.open(mapfile)
        im = ImageOps.invert(im)
        ix, iy = im.size
        if (ix > 200 and divx == 0) or (divx > 0):
            if divx == 0:
                divx = 200
                divy = 200
            im = im.resize((divx, divy), Image.ANTIALIAS)
            ix, iy = im.size
        if not im.mode == "P":
            im = im.convert('P', palette=Image.ADAPTIVE)

        im = im.transpose(Image.FLIP_TOP_BOTTOM)
        im = im.transpose(Image.FLIP_LEFT_RIGHT)
        self.pixels = im.load()
        self.width = width
        self.depth = depth
        self.height = height
        self.ix = ix
        self.iy = iy
        self.ttype = GL_TRIANGLE_STRIP

        if VERBOSE:
            print("Creating Elevation Map ...", ix, iy)

        wh = width * 0.5
        hh = depth * 0.5
        ws = width / ix
        hs = depth / iy
        ht = height / 255.0
        tx = 1.0 * ntiles / ix
        ty = 1.0 * ntiles / iy

        verts = []
        norms = []
        tex_coords = []
        idx = []

        for y in xrange(0, iy):
            for x in xrange(0, ix):
                hgt = (self.pixels[x, y]) * ht
                this_x = -wh + x * ws
                this_z = -hh + y * hs
                if cubic:
                    """ this is a bit experimental. It tries to make the map either zero
          or height high. Vertices are moved 'under' adjacent ones if there is
          a step to make vertical walls. Goes wrong in places - mainly because
          it doesn't check diagonals
          """
                    if hgt > height / 2:
                        hgt = height
                    else:
                        hgt = 0.0
                    if hgt == 0 and y > 0 and y < iy - 1 and x > 0 and x < ix - 1:
                        if self.pixels[x - 1, y] > 127:
                            this_x = -wh + (x - 1) * ws
                        elif self.pixels[x + 1, y] > 127:
                            this_x = -wh + (x + 1) * ws
                        elif self.pixels[x, y - 1] > 127:
                            this_z = -hh + (y - 1) * hs
                        elif self.pixels[x, y + 1] > 127:
                            this_z = -hh + (y + 1) * hs
                        elif self.pixels[x - 1, y - 1] > 127:
                            this_x = -wh + (x - 1) * ws
                            this_z = -hh + (y - 1) * hs
                        elif self.pixels[x - 1, y + 1] > 127:
                            this_x = -wh + (x - 1) * ws
                            this_z = -hh + (y + 1) * hs
                        elif self.pixels[x + 1, y - 1] > 127:
                            this_x = -wh + (x + 1) * ws
                            this_z = -hh + (y - 1) * hs
                        elif self.pixels[x + 1, y + 1] > 127:
                            this_x = -wh + (x + 1) * ws
                            this_z = -hh + (y + 1) * hs
                verts.append((this_x, hgt, this_z))
                tex_coords.append(((ix - x) * tx, (iy - y) * ty))

        s = 0
        #create one long triangle_strip by alternating X directions
        for y in range(0, iy - 1):
            for x in range(0, ix - 1):
                i = (y * ix) + x
                idx.append((i, i + ix, i + ix + 1))
                idx.append((i + ix + 1, i + 1, i))
                s += 2

        self.buf = []
        self.buf.append(Buffer(self, verts, tex_coords, idx, None, smooth))
Пример #39
0
 def __init__(self, Numbers=None, max_Magnitude=None, **kwargs):
     '''
     Custom image data generator.
     Behaves like ImageDataGenerator, but allows color augmentation.
     '''
     super().__init__(preprocessing_function=self.__call__, **kwargs)
     
     self.transforms = ['autocontrast', 'equalize', 'rotate', 'solarize', 'color', 'posterize',
                        'contrast', 'brightness', 'sharpness', 'shearX', 'shearY', 'translateX', 'translateY']
     if Numbers is None:
         self.Numbers = len(self.transforms) // 2
     else:
         self.Numbers = Numbers
     if max_Magnitude is None:
         self.max_Magnitude = 10
     else:
         self.max_Magnitude = max_Magnitude
     fillcolor = 128
     self.ranges = {
         # these  Magnitude   range , you  must test  it  yourself , see  what  will happen  after these  operation ,
         # it is no  need to obey  the value  in  autoaugment.py
         "shearX": np.linspace(0, 0.3, 10),
         "shearY": np.linspace(0, 0.3, 10),
         "translateX": np.linspace(0, 0.2, 10),
         "translateY": np.linspace(0, 0.2, 10),
         "rotate": np.linspace(0, 360, 10),
         "color": np.linspace(0.0, 0.9, 10),
         "posterize": np.round(np.linspace(8, 4, 10), 0).astype(np.int),
         "solarize": np.linspace(256, 231, 10),
         "contrast": np.linspace(0.0, 0.5, 10),
         "sharpness": np.linspace(0.0, 0.9, 10),
         "brightness": np.linspace(0.0, 0.3, 10),
         "autocontrast": [0] * 10,
         "equalize": [0] * 10,           
         "invert": [0] * 10
     }
     self.func = {
         "shearX": lambda img, magnitude: img.transform(
             img.size, Image.AFFINE, (1, magnitude * random.choice([-1, 1]), 0, 0, 1, 0),
             Image.BICUBIC, fill=fillcolor),
         "shearY": lambda img, magnitude: img.transform(
             img.size, Image.AFFINE, (1, 0, 0, magnitude * random.choice([-1, 1]), 1, 0),
             Image.BICUBIC, fill=fillcolor),
         "translateX": lambda img, magnitude: img.transform(
             img.size, Image.AFFINE, (1, 0, magnitude * img.size[0] * random.choice([-1, 1]), 0, 1, 0),
             fill=fillcolor),
         "translateY": lambda img, magnitude: img.transform(
             img.size, Image.AFFINE, (1, 0, 0, 0, 1, magnitude * img.size[1] * random.choice([-1, 1])),
             fill=fillcolor),
         "rotate": lambda img, magnitude: self.rotate_with_fill(img, magnitude),
         # "rotate": lambda img, magnitude: img.rotate(magnitude * random.choice([-1, 1])),
         "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: img,
         "invert": lambda img, magnitude: ImageOps.invert(img)
     }
Пример #40
0
    life -= ultra_ability_4
    life -= ultra_ability_5

    first_aibility_damage = first_aibility * 601 / (magic_resistance_true +
                                                    601)
    life -= first_aibility_damage

    return int(life)


os.system('adb shell screencap -p /sdcard/1.png')
print("截图完毕")
os.system('adb pull /sdcard/1.png .')

img = Image.open('C:\\Users\\wkz\\1.png').convert('RGB')
inverted_image = ImageOps.invert(img)

ability_power_range = np.zeros((6, 4))
enemy_life_range = np.zeros((6, 4))
enemy_magic_resistance_range = np.zeros((6, 4))
level_range = np.zeros((6, 4))
for i in range(1, 6):
    ability_power_range[i] = np.array([
        int(474 * screen_width / 1920),
        int((133 * i + 210) * screen_height / 1080),
        int(572 * screen_width / 1920),
        int((133 * i + 273) * screen_height / 1080)
    ])
    enemy_life_range[i] = np.array([
        int(1220 * screen_width / 1920),
        int((133 * i + 210) * screen_height / 1080),
Пример #41
0
def invertirImagen(imagen):
    invertir = ImageOps.invert(imagen)
    return invertir
import idx2numpy
from PIL import Image
from PIL import ImageEnhance
from PIL import ImageOps 
coll=array([])

# TBD 
# 1. Take a file list
# 2. Example Data Images
#  


for n in range("""Nimber of Images"""):
	img=Image.open("""Image Name"""{0}.format(n)).convert("L") 	#Opening the image in Monochrome version
	img
	contr = ImageEnhance.Contrast(img)
	img = contr.enhance(3)                                                  
	bright = ImageEnhance.Brightness(img)                               
	img = bright.enhance(4)  		       			#Enhancement of Contrast and Brightness
	img=ImageOps.invert(img)		       			#Invert Image (White in Black)
	img=img.resize((28,28))  		       			#Conversion of Resolution to 28 X 28
	img	
	arr=array(img)							#Conversion of Image to 2D numpy array
	for i in range(28):
   		for j in range(28):
       			if(arr[i][j]==0):
       	     			arr[i][j]=1
        		else:
            			arr[i][j]=255		       		#Concersion to MNIST Datset format
idx2numpy.convert_to_file("""File Name""",arr)           		#Conversion 2D numpy array to idx2 format
def imgmsg_to_pil(img_msg, rgba=False):
    try:
        if img_msg._type == 'sensor_msgs/CompressedImage':
            pil_img = Image.open(BytesIO(img_msg.data))
            if pil_img.mode.startswith('BGR'):
                pil_img = pil_bgr2rgb(pil_img)
            pil_mode = 'RGB'
        else:
            pil_mode = 'RGB'
            if img_msg.encoding in ['mono8', '8UC1']:
                mode = 'L'
            elif img_msg.encoding == 'rgb8':
                mode = 'RGB'
            elif img_msg.encoding == 'bgr8':
                mode = 'BGR'
            elif img_msg.encoding in [
                    'bayer_rggb8', 'bayer_bggr8', 'bayer_gbrg8', 'bayer_grbg8'
            ]:
                mode = 'L'
            elif img_msg.encoding in [
                    'bayer_rggb16', 'bayer_bggr16', 'bayer_gbrg16',
                    'bayer_grbg16'
            ]:
                pil_mode = 'I;16'
                if img_msg.is_bigendian:
                    mode = 'I;16B'
                else:
                    mode = 'I;16L'
            elif img_msg.encoding == 'mono16' or img_msg.encoding == '16UC1':
                pil_mode = 'F'
                if img_msg.is_bigendian:
                    mode = 'F;16B'
                else:
                    mode = 'F;16'
            elif img_msg.encoding == '32FC1':
                pil_mode = 'F'
                if img_msg.is_bigendian:
                    mode = 'F;32BF'
                else:
                    mode = 'F;32F'
            elif img_msg.encoding == 'rgba8':
                mode = 'BGR'
            elif img_msg.encoding == 'bgra8':
                mode = 'RGB'
            else:
                raise Exception("Unsupported image format: %s" %
                                img_msg.encoding)
            pil_img = Image.frombuffer(pil_mode,
                                       (img_msg.width, img_msg.height),
                                       img_msg.data, 'raw', mode, 0, 1)

        # 16 bits conversion to 8 bits
        if pil_mode == 'I;16':
            pil_img = pil_img.convert('I').point(lambda i: i *
                                                 (1. / 256.)).convert('L')

        if pil_img.mode == 'F':
            pil_img = pil_img.point(lambda i: i * (1. / 256.)).convert('L')
            pil_img = ImageOps.autocontrast(pil_img)
            pil_img = ImageOps.invert(pil_img)

        if rgba and pil_img.mode != 'RGBA':
            pil_img = pil_img.convert('RGBA')

        return pil_img

    except Exception as ex:
        print('Can\'t convert image: %s' % ex, file=sys.stderr)
        return None
Пример #44
0
 def invert_alpha(self):
     if self.alpha:
         self.alpha = ImageOps.invert(self.alpha)
         self.clear_cache()
Пример #45
0
def conv_image_to_module(name, scale_factor):

    module = header % {"name": name.upper()}

    front_image = Image.open("%s_front.png" % name).transpose(Image.FLIP_TOP_BOTTOM) 
    print("Reading image from \"%s_front.png\"" % name)

    front_image_red, front_image_green, front_image_blue, front_image_alpha = front_image.split()

    # Soldermask needs to be inverted
    front_image_red = ImageOps.invert(front_image_red)
    front_image_red = Image.composite(front_image_red, front_image_alpha, front_image_alpha)
    front_image_red = front_image_red.point(lambda i: 0 if i < 127 else 1)
    red_array = np.array(front_image_red)
    bmp_red = potrace.Bitmap(red_array)
    path_red = bmp_red.trace(alphamax = 0.0, opttolerance = 50)

    # Soldermask needs to be inverted
    front_image_green = ImageOps.invert(front_image_green)
    front_image_green = Image.composite(front_image_green, front_image_alpha, front_image_alpha)
    front_image_green = front_image_green.point(lambda i: 0 if i < 127 else 1)
    green_array = np.array(front_image_green)
    bmp_green = potrace.Bitmap(green_array)
    path_green = bmp_green.trace(alphamax = 0.0, opttolerance = 50)

    front_image_blue = front_image_blue.point(lambda i: 0 if i < 127 else 1)
    blue_array = np.array(front_image_blue)
    bmp_blue = potrace.Bitmap(blue_array)
    path_blue = bmp_blue.trace(alphamax = 0.0, opttolerance = 50)

    front_image_alpha = front_image_alpha.point(lambda i: 0 if i < 127 else 1)
    front_image_alpha_array = np.array(front_image_alpha)
    bmp_alpha = potrace.Bitmap(front_image_alpha_array)
    path_alpha = bmp_alpha.trace(alphamax = 0.0, opttolerance = 50)

    w, h = front_image.size

    # print("Generating Outline layer from front alpha channel")
    # module += render_path_to_layer(path_alpha, "line", "20", scale_factor)

    print("Generating tKeepout layer from front red channel")
    module += render_path_to_layer(path_red, "poly", "39", scale_factor)
    print("Generating tStop layer from front green channel")
    module += render_path_to_layer(path_green, "poly", "29", scale_factor)
    print("Generating tPlace layer from front blue channel")
    module += render_path_to_layer(path_blue, "poly", "21", scale_factor)

    try:
        back_image = Image.open("%s_back.png" % name).transpose(Image.FLIP_TOP_BOTTOM) 
        back_image = ImageOps.mirror(back_image)
        print("Reading image from \"%s_back.png\"" % name)

        back_image_red, back_image_green, back_image_blue, back_image_alpha = back_image.split()

        back_image_red = back_image_red.point(lambda i: 0 if i < 127 else 1)
        red_array = np.array(back_image_red)
        bmp_red = potrace.Bitmap(red_array)
        path_red = bmp_red.trace(alphamax = 0.0, opttolerance = 50)

        # Soldermask needs to be inverted
        back_image_green = ImageOps.invert(back_image_green)
        back_image_green = back_image_green.point(lambda i: 0 if i < 127 else 1)
        green_array = np.array(back_image_green)
        bmp_green = potrace.Bitmap(green_array)
        path_green = bmp_green.trace(alphamax = 0.0, opttolerance = 50)

        back_image_blue = back_image_blue.point(lambda i: 0 if i < 127 else 1)
        blue_array = np.array(back_image_blue)
        bmp_blue = potrace.Bitmap(blue_array)
        path_blue = bmp_blue.trace(alphamax = 0.0, opttolerance = 50)

        print("Generating bKeepout layer from back red channel")
        module += render_path_to_layer(path_red, "poly", "40", scale_factor)
        print("Generating bStop layer from back green channel")
        module += render_path_to_layer(path_green, "poly", "30", scale_factor)
        print("Generating bPlace layer from back blue channel")
        module += render_path_to_layer(path_blue, "poly", "22", scale_factor)
    except IOError:
        pass

    module += footer % {"name": name.upper()}
    return module, (w * 25.4 / scale_factor, h * 25.4 / scale_factor)
Пример #46
0
def trim(image):
    inverted = ImageOps.invert(image.convert("RGB"))
    return image.crop(inverted.getbbox())
Пример #47
0
def start():
	startbutton.config(state='disabled')
	previewbutton.config(state='disabled')
	browsebutton.config(state='disabled')
	mvar = 'Creating wallpaper. Please wait...'
	messvar.set(mvar)

	### CODE ###
	print('>> Opening image...')
	img = i.open(filename)
	origimg = img # Original image to be used later
	wid, hei = math.ceil(img.size[1]*(16/9)), img.size[1] # Working out 16:9 width for original height

	# print(f'>> Orig size:   {img.size}')
	# print(f'>> New size:   {wid, hei}')

	mode = 'RGBA'
	global bkg
	bkg = i.new(mode, (wid, hei)) # Background

	if cmvar.get() == 1: # Colour map
		if invvar.get() == 1:
			cmblack = cmwvar.get()
			cmwhite = cmbvar.get()
		else:
			cmblack = cmbvar.get()
			cmwhite = cmwvar.get()
		img = img.convert('L') # Convert to greyscale
		img = ImageOps.colorize(img, black=cmblack, white=cmwhite) # colour map

	## Matplotlib colour map

	if plbvar.get() == 0:
		pass
	else:
		print(f'>> Applying {pltvar.get()} colour map...')
		pltcm = matplotlib.cm.get_cmap(pltvar.get()) # color map
		img = img.convert('L')
		img = np.array(img)
		img = pltcm(img)
		img = np.uint8(img*255)
		img = i.fromarray(img)

	## Invert colours

	if icvar.get() == 1: 
		print('>> Inverting image...')
		img = img.convert('RGB')
		# print(img.mode)
		img = ImageOps.invert(img)


	## Gaussian Blur

	blurval = int(blurslider.get()) # Slider value

	if blurval == 0: # Filter options
		pass
	else:
		print('>> Applying Gaussian Blur...')
		# blur = hei/()*8
		img = img.filter(ImageFilter.GaussianBlur(radius=(blurval*0.1))) # Gaussian blur
	
	## Darken

	if fopt.get() == 2: # If radio button 2 not chosen
		# https://stackoverflow.com/questions/43618910/pil-drawing-a-semi-transparent-square-overlay-on-image
		img = i.eval(img, lambda x: x/1.5)

	## Split image

	def split(pos): # Splits image in 2 and puts top half on the left and bottom on the right
		imgcent = math.ceil(hei/2) # Image center
		
		global fopt

		if pos == 't':
			print('>> Creating left background...')
			s = img.crop(box=(0,0,img.size[0],imgcent)) # Cropping image - 4 tuple: left,top,right,bottom
		elif pos == 'b':
			print('>> Creating right background...')
			s = img.crop(box=(0,imgcent,img.size[0],img.size[1]))	

		sr = s.resize(tuple(z*2 for z in s.size)) # Scaling up by 2 because img was split in two

		return sr

	## Working out where top and bottom splits are to be pasted
	print('>> Calculating dimensions...')
	sw = math.ceil((wid-img.size[0])/2) # split width

	tspos = (math.ceil((sw/2)-img.size[0]),0) # Top split position
	bspos = (math.ceil((wid-sw/2) - img.size[0]),0) # Bottom split position

	print('>> Creating background...')
	bkg.paste(split('t'), box=tspos)
	bkg.paste(split('b'), box=bspos)

	bkg.paste(origimg, box=(math.ceil((wid/2)-(img.size[0]/2)), 0)) # Paste original image in the center of new image
	
	# Add border
	if bordvar.get() == 1:
		bkg = ImageOps.expand(bkg,border=wid//100,fill='black')
	elif bordvar.get() == 0:
		pass

	prevbkg = bkg.resize((800,450)) # Resizing preview image to fit on canvas
	previmg = ImageTk.PhotoImage(image=prevbkg) # Creating a PhotoImage of image object to load on canvas
	preview.create_image(0,0, image=previmg, anchor='nw') # Loading photoimage on canvas
	preview.image = previmg # https://web.archive.org/web/20201111190625id_/http://effbot.org/pyfaq/why-do-my-tkinter-images-not-appear.htm
	# preview.itemconfig(setprev)
	# tkinter.Tk()
	# master.mainloop()

	# ~ Resetting GUI ~
	startbutton.config(state='normal')
	previewbutton.config(state='normal')
	browsebutton.config(state='normal')
	bordbutton.config(state='normal')
Пример #48
0
def inverse_color(image):
    if np.random.random() < 0.4:
        image = ImageOps.invert(image)
    return image
Пример #49
0
    lambda pil_img, level, _: pil_img.transpose(Image.FLIP_LEFT_RIGHT))
flip_ud = TransformT(
    'FlipUD',
    lambda pil_img, level, _: pil_img.transpose(Image.FLIP_TOP_BOTTOM))
# pylint:disable=g-long-lambda
auto_contrast = TransformT(
    'AutoContrast',
    lambda pil_img, level, _: ImageOps.autocontrast(
        pil_img.convert('RGB')).convert('RGBA'))
equalize = TransformT(
    'Equalize',
    lambda pil_img, level, _: ImageOps.equalize(
        pil_img.convert('RGB')).convert('RGBA'))
invert = TransformT(
    'Invert',
    lambda pil_img, level, _: ImageOps.invert(
        pil_img.convert('RGB')).convert('RGBA'))
# pylint:enable=g-long-lambda
blur = TransformT(
    'Blur', lambda pil_img, level, _: pil_img.filter(ImageFilter.BLUR))
smooth = TransformT(
    'Smooth',
    lambda pil_img, level, _: pil_img.filter(ImageFilter.SMOOTH))


def _rotate_impl(pil_img, level, _):
  """Rotates `pil_img` from -30 to 30 degrees depending on `level`."""
  degrees = int_parameter(level, 30)
  if random.random() > 0.5:
    degrees = -degrees
  return pil_img.rotate(degrees)
Пример #50
0
import struct
from PIL import Image, ImageOps
import os

target_name = 'ETL9B'

for root, dirs, files in os.walk(target_name):
    for i, file in enumerate(sorted(files)):
        filepath = os.path.join(root, file)
        print(file)

        sum_datasets = 40
        sum_words = 3036
        record_size = 576

        with open(filepath, 'rb') as f:
            for ds_idx in range(1, sum_datasets * sum_words + 1):
                f.seek(ds_idx * record_size)
                s = f.read(record_size)
                r = struct.unpack('>2H4s504s64x', s)
                i1 = Image.frombytes('1', (64, 63), r[3], 'raw')
                img = ImageOps.invert(i1.convert('L'))

                file_name = '{}_{}_{}_{}_{}.png'.format(
                    target_name, i, r[0],
                    hex(r[1])[2:], ds_idx)
                dir_name = "./{}_img/{}".format(target_name, hex(r[1])[2:])

                os.makedirs(dir_name, exist_ok=True)
                img.save(os.path.join(dir_name, file_name), 'PNG')
def char_to_picture(text="",
                    font_name="宋体",
                    background_color=(255, 255, 255),
                    text_color=(0, 0, 0),
                    pictrue_size=400,
                    text_position=(0, 0),
                    in_meddium=False,
                    reverse_color=False,
                    smooth_times=0,
                    noise=0):
    pictrue_shape = (pictrue_size, pictrue_size)
    im = Image.new("RGB", pictrue_shape, background_color)
    dr = ImageDraw.Draw(im)

    # 由于系统内部不是使用汉字文件名,而是英文名,在此转换
    if font_name == "宋体":
        font_name = "SIMSUN.ttc"
    if font_name == "楷体":
        font_name = "SIMKAI.ttf"
    if font_name == "黑体":
        font_name = "SIMHEI.ttf"
    if font_name == "等线":
        font_name = "DENG.ttf"
    if font_name == "仿宋":
        font_name = "SIMFANG.ttf"

    # 取得字体文件的位置
    font_dir = "C:\Windows\Fonts\\" + font_name
    font_size = int(pictrue_size * 0.8 / len(text))  # 设定文字的大小
    font = ImageFont.truetype(font_dir, font_size)

    # 开始绘图
    # 如果设置了居中,那么就居中
    # 英文字母的对齐方式并不一样
    char_dict = []
    for i in range(26):
        char_dict.append(chr(i + ord('a')))
        char_dict.append(chr(i + ord('A')))
    if in_meddium:
        char_num = len(text)
        text_position = (pictrue_shape[0] / 2 - char_num * font_size / 2,
                         pictrue_shape[1] / 2 - font_size / 2)  # 中文
        if text in char_dict:
            text_position = (pictrue_shape[0] / 2 - char_num * font_size / 4,
                             pictrue_shape[1] / 2 - font_size / 2)  # 英文

    # 开始绘制图像
    dr.text(text_position, text, font=font, fill=text_color)
    if reverse_color:
        im = ImageOps.invert(im)

    # 随机扰动
    if noise > 0:
        print("adding noise...")
        im_array = np.array(im)
        noise_num = noise * pictrue_size
        for i in range(noise_num):
            pos = (random.randint(0, pictrue_size - 1),
                   random.randint(0, pictrue_size - 1))
            color = [
                random.randint(0, 255),
                random.randint(0, 255),
                random.randint(0, 255)
            ]
            im_array[pos[0], pos[1], :] = color
        im = Image.fromarray(im_array)

    # 模糊化图片
    '''
    for i in range(smooth_times):
        im =im.filter(ImageFilter.GaussianBlur)
    '''
    im_array = np.array(im)
    for i in range(smooth_times):
        im_array = smooth(im_array)
    im = Image.fromarray(im_array)

    # 图片经过模糊后略有缩小
    im = im.resize(pictrue_shape)
    print("文字转换图片成功")
    return im
Пример #52
0
def invert_color(image):
    image = image.convert('L')
    image = ImageOps.invert(image)
    image = image.convert('1')
    return image
Пример #53
0
    def __init__(self,
                 dataset,
                 transformations=None,
                 n_classes=8000,
                 n_trans=100,
                 max_elms=10,
                 p=0.5):
        """ExemplarNet dataset.

        Args:
            dataset (torch.utils.data.Dataset): The dataset to train on.
            transformations (list, optional): Type of elementar transformations to use.
            n_classes (int, optional): Number of classes, i.e. the subset size of the dataset. Defaults to 8000.
            n_trans (int, optional): Number of combined transformations. Defaults to 100.
            max_elms (int, optional): Number of elementar transformations per combined transformation. Defaults to 10.
            p (float, optional): Prob. of an elmentar transformation to be part of a combined transformation. Defaults to 0.5.
        """
        pool = [
            transforms.RandomRotation(  # Rotation
                30,
                resample=False,
                expand=False,
                center=None,
                fill=None),
            transforms.RandomAffine(  # Shearing
                0,
                translate=None,
                scale=None,
                shear=30,
                resample=False,
                fillcolor=0),
            transforms.RandomAffine(  # Translate
                0,
                translate=(0.3, 0.3),
                scale=None,
                shear=None,
                resample=False,
                fillcolor=0),
            transforms.Lambda(lambda x: imo.autocontrast(x)),  # Autocontrast
            transforms.Lambda(lambda x: imo.invert(x)),  # Invert
            transforms.Lambda(lambda x: imo.equalize(x)),  # Equalize
            transforms.Lambda(lambda x: imo.solarize(x)),  # Solarize
            transforms.Lambda(lambda x: imo.posterize(
                x, bits=int(np.random.randint(4, 8) + 1))),  # Posterize
            transforms.Lambda(
                lambda x: ime.Color(x).enhance(np.random.uniform())),  # Color
            transforms.Lambda(lambda x: ime.Brightness(x).enhance(
                np.random.uniform())),  # Brightness
            transforms.Lambda(lambda x: ime.Contrast(x).enhance(
                np.random.uniform())),  # Contrast
            transforms.Lambda(lambda x: ime.Sharpness(x).enhance(
                np.random.uniform())),  # Sharpness
            transforms.Compose(  # Set black
                [
                    transforms.ToTensor(),
                    transforms.RandomErasing(1.0),
                    transforms.ToPILImage()
                ]),
            transforms.Lambda(
                lambda x: transforms.functional.to_grayscale(  # Grayscale
                    x, num_output_channels=3)),
            transforms.Lambda(lambda x: elastic_transform(x, sigma=10))
        ]

        # Processes full images and apply random cropping instead of gradient based sampling.
        indices = torch.randint(len(dataset), (n_classes, )).long()
        self.dataset = Subset(dataset, indices)
        self.p = p
        self.n_trans = n_trans
        elm_transformations = transformations if transformations is not None else pool

        self.transformations = []
        for _ in range(self.n_trans):
            transformation = []
            for t in range(max_elms):
                if random.random() < self.p:
                    transformation.append(
                        transforms.RandomChoice(elm_transformations))
            self.transformations.append(transforms.Compose(transformation))
Пример #54
0
def read(location, source):
    img = source.crop(location)
    img = RGBtoBW(img)
    img = ImageOps.invert(img)
    return img
Пример #55
0
def updateDisplay(config, pricestack, whichcoin, fiat):

    symbolstring = currency.symbol(fiat.upper())
    if fiat == "jpy":
        symbolstring = "¥"

    pricenow = pricestack[-1]
    currencythumbnail = 'currency/' + whichcoin + '.bmp'
    tokenimage = Image.open(os.path.join(picdir, currencythumbnail))
    sparkbitmap = Image.open(os.path.join(picdir, 'spark.bmp'))

    pricechange = str("%+d" % round(
        (pricestack[-1] - pricestack[0]) / pricestack[-1] * 100, 2)) + "%"
    if pricenow > 1000:
        pricenowstring = format(int(pricenow), ",")
    else:
        pricenowstring = str(float('%.5g' % pricenow))

    if config['display']['orientation'] == 0 or config['display'][
            'orientation'] == 180:
        epd = epd2in7.EPD()
        epd.Init_4Gray()
        image = Image.new('L', (epd.width, epd.height),
                          255)  # 255: clear the image with white
        draw = ImageDraw.Draw(image)
        draw.text((110, 80), "7day :", font=font_date, fill=0)
        draw.text((110, 95), pricechange, font=font_date, fill=0)
        # Print price to 5 significant figures
        draw.text((15, 200), symbolstring + pricenowstring, font=font, fill=0)
        draw.text((10, 10),
                  str(time.strftime("%a %H:%M %d %b %Y")),
                  font=font_date,
                  fill=0)
        image.paste(tokenimage, (10, 25))
        image.paste(sparkbitmap, (10, 125))
        if config['display']['orientation'] == 180:
            image = image.rotate(180, expand=True)

    if config['display']['orientation'] == 90 or config['display'][
            'orientation'] == 270:
        epd = epd2in7.EPD()
        epd.Init_4Gray()
        image = Image.new('L', (epd.height, epd.width),
                          255)  # 255: clear the image with white
        draw = ImageDraw.Draw(image)
        draw.text((100, 100), "7day : " + pricechange, font=font_date, fill=0)
        # Print price to 5 significant figures
        #       draw.text((20,120),symbolstring,font =fonthiddenprice,fill = 0)
        draw.text((10, 120),
                  symbolstring + pricenowstring,
                  font=fontHorizontal,
                  fill=0)
        image.paste(sparkbitmap, (80, 50))
        image.paste(tokenimage, (0, 0))
        draw.text((85, 5),
                  str(time.strftime("%a %H:%M %d %b %Y")),
                  font=font_date,
                  fill=0)
        if config['display']['orientation'] == 270:
            image = image.rotate(180, expand=True)
#       This is a hack to deal with the mirroring that goes on in 4Gray Horizontal
        image = ImageOps.mirror(image)

#   If the display is inverted, invert the image usinng ImageOps
    if config['display']['inverted'] == True:
        image = ImageOps.invert(image)


#   Send the image to the screen
    epd.display_4Gray(epd.getbuffer_4Gray(image))
    epd.sleep()
Пример #56
0
def invert_img(imdir,outdir):
    im = Image.open(imdir)
    out_filename = outdir
    ImageOps.invert(im).save(out_filename, 'JPEG', quality = 100)
Пример #57
0
    def __init__(self,
                 p1,
                 operation1,
                 magnitude_idx1,
                 p2,
                 operation2,
                 magnitude_idx2,
                 fillcolor=(128, 128, 128),
                 magnitude_factor=1):
        ranges = {
            "shearX": np.linspace(0, 0.3, 10),
            "shearY": np.linspace(0, 0.3, 10),
            "translateX": np.linspace(0, 150 / 331, 10),
            "translateY": np.linspace(0, 150 / 331, 10),
            "rotate": np.linspace(0, 30, 10),
            "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 = {
            "shearX":
            lambda img, magnitude: img.transform(img.size,
                                                 Image.AFFINE,
                                                 (1, magnitude * random.choice(
                                                     [-1, 1]), 0, 0, 1, 0),
                                                 Image.BICUBIC,
                                                 fillcolor=fillcolor),
            "shearY":
            lambda img, magnitude: img.transform(img.size,
                                                 Image.AFFINE,
                                                 (1, 0, 0, magnitude * random.
                                                  choice([-1, 1]), 1, 0),
                                                 Image.BICUBIC,
                                                 fillcolor=fillcolor),
            "translateX":
            lambda img, magnitude: img.transform(
                img.size,
                Image.AFFINE, (1, 0, magnitude * img.size[0] * random.choice(
                    [-1, 1]), 0, 1, 0),
                fillcolor=fillcolor),
            "translateY":
            lambda img, magnitude: img.transform(
                img.size,
                Image.AFFINE, (1, 0, 0, 0, 1, magnitude * img.size[1] * random.
                               choice([-1, 1])),
                fillcolor=fillcolor),
            "rotate":
            lambda img, magnitude: rotate_with_fill(img, magnitude),
            "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)
        }
        magnitude_1 = max(0, min(9, int(magnitude_factor * magnitude_idx1)))
        magnitude_2 = max(0, min(9, int(magnitude_factor * magnitude_idx2)))
        self.p1 = p1
        self.operation1 = func[operation1]
        self.magnitude1 = ranges[operation1][magnitude_1]
        self.p2 = p2
        self.operation2 = func[operation2]
        self.magnitude2 = ranges[operation2][magnitude_2]
Пример #58
0
    for l in range(LAYERS):
        l0 = PARTICLES_PER_LAYER * l
        l1 = min(PARTICLES_PER_LAYER * (l+1), PARTICLES)
        pixelLayer = getPixelData(windData, nx, ny, scaledW, scaledH, particleProperties[l0:l1], POINTS_PER_PARTICLE, VELOCITY_MULTIPLIER, MAGNITUDE_RANGE, LINE_WIDTH_RANGE, ALPHA_RANGE, BRIGHTNESS)
        pixelLayers[:,:,l] = pixelLayer
        sys.stdout.write('\r')
        sys.stdout.write("%s%%" % round(1.0*(l+1)/LAYERS*100,1))
        sys.stdout.flush()
    pixels = np.amax(pixelLayers, axis=2)
else:
    pixels = getPixelData(windData, nx, ny, scaledW, scaledH, particleProperties, POINTS_PER_PARTICLE, VELOCITY_MULTIPLIER, MAGNITUDE_RANGE, LINE_WIDTH_RANGE, ALPHA_RANGE, BRIGHTNESS)
print("Building image...")

# add pixels and invert
im = Image.fromarray(pixels, mode="L")
im = ImageOps.invert(im)
if SMOOTH_FACTOR > 0.0:
    im = im.resize((contentWidth, contentHeight), Image.LANCZOS)
if BLUR_RADIUS > 0:
    im = im.filter(ImageFilter.GaussianBlur(BLUR_RADIUS))

# crop if necessary
if cropToWidth and cropToHeight:
    im = im.crop((roundInt(OFFSETX), roundInt(OFFSETY), roundInt(OFFSETX+cropToWidth), roundInt(OFFSETY+cropToHeight)))

# add margin
base = Image.new('L', (roundInt(WIDTH), roundInt(HEIGHT)), 255)
cw, ch = im.size
base.paste(im, (contentX, contentY, contentX+cw, contentY+ch))

# add label
Пример #59
0
def invert(img: Image.Image) -> Image.Image:
    if not _is_pil_image(img):
        raise TypeError(f"img should be PIL Image. Got {type(img)}")
    return ImageOps.invert(img)
Пример #60
-1
    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"))