Exemplo n.º 1
0
    def test_scale(self):
        # Test the scaling function
        i = hopper("L").resize((50, 50))

        with self.assertRaises(ValueError):
            ImageOps.scale(i, -1)

        newimg = ImageOps.scale(i, 1)
        self.assertEqual(newimg.size, (50, 50))

        newimg = ImageOps.scale(i, 2)
        self.assertEqual(newimg.size, (100, 100))

        newimg = ImageOps.scale(i, 0.5)
        self.assertEqual(newimg.size, (25, 25))
Exemplo n.º 2
0
def test_scale():
    # Test the scaling function
    i = hopper("L").resize((50, 50))

    with pytest.raises(ValueError):
        ImageOps.scale(i, -1)

    newimg = ImageOps.scale(i, 1)
    assert newimg.size == (50, 50)

    newimg = ImageOps.scale(i, 2)
    assert newimg.size == (100, 100)

    newimg = ImageOps.scale(i, 0.5)
    assert newimg.size == (25, 25)
Exemplo n.º 3
0
    def test_scale(self):
        # Test the scaling function
        i = hopper("L").resize((50, 50))

        with self.assertRaises(ValueError):
            ImageOps.scale(i, -1)

        newimg = ImageOps.scale(i, 1)
        self.assertEqual(newimg.size, (50, 50))

        newimg = ImageOps.scale(i, 2)
        self.assertEqual(newimg.size, (100, 100))

        newimg = ImageOps.scale(i, 0.5)
        self.assertEqual(newimg.size, (25, 25))
Exemplo n.º 4
0
def atkinson_dither(image_string):
    image = base64_to_PIL_image(image_string)
    image = image.convert('L')
    pix = image.load()
    w, h = image.size
    for y in range(h):
        for x in range(w):
            old = pix[x, y]
            new = 0 if old < 127 else 255
            pix[x, y] = new
            quant_error = old - new
            if x < w - 1:
                pix[x + 1, y] += quant_error * 1 // 8
            if x < w - 2:
                pix[x + 2, y] += quant_error * 1 // 8
            if x > 0 and y < h - 1:
                pix[x - 1, y + 1] += quant_error * 1 // 8
            if y < h - 1:
                pix[x, y + 1] += quant_error * 1 // 8
            if y < h - 2:
                pix[x, y + 2] += quant_error * 1 // 8
            if x < w - 1 and y < h - 1:
                pix[x + 1, y + 1] += quant_error * 1 // 8

    if w > 1024 or h > 512:
        image = ImageOps.scale(image, 0.75)
    return PIL_image_to_base64(image)
Exemplo n.º 5
0
def save_scale():
    if request.method == "POST":
        image_src = 'static/uploads/img.png'
        im = Image.open(image_src)
        factor = int(request.get_data()) * 2 / 100
        im = ImageOps.scale(im, factor)
        im.save('static/uploads/img.png')
Exemplo n.º 6
0
def draw_name_box(name: str, type_: str) -> Image:
    image = Image.new("RGBA", CARD_SIZE, (255, 0, 0, 0))

    # Draw a half-opaque rectangle
    name_box = ImageDraw.Draw(image)
    name_box.rectangle(
        [
            NAME_BOX_X,
            NAME_BOX_Y,
            NAME_BOX_SIZE_X + NAME_BOX_X,
            NAME_BOX_SIZE_Y + NAME_BOX_Y,
        ],
        fill=COLOUR_CODE,
    )

    # Write the unit name
    font_size = NAME_BOX_SIZE_Y - (2 * NAME_BOX_MARGIN)
    logging.info("Font size is %s", font_size)

    font = ImageFont.truetype(
        str(ROOT_FOLDER / "SourceSansPro-SemiBold.ttf"),
        size=font_size,
    )

    name_box.text(
        (NAME_BOX_X + NAME_BOX_MARGIN, NAME_BOX_Y + NAME_BOX_SIZE_Y / 2),
        name,
        font=font,
        fill=(1, 0, 0),
        anchor="lm",
    )

    # Add the unit icon
    icon_file = UNIT_ICON_FOLDER / (type_.lower() + ".png")
    if not icon_file.exists():
        raise RuntimeError("No unit icon found: ", type_)

    with Image.open(icon_file) as icon_im:
        icon_im = icon_im.crop(icon_im.getbbox())
        scaling_factor = (NAME_BOX_SIZE_Y -
                          2 * NAME_BOX_MARGIN) / icon_im.height
        logging.info("Rescale icon %s with factor %s", icon_file,
                     scaling_factor)
        rescaled_icon = ImageOps.scale(icon_im, scaling_factor)

        extreme_x = NAME_BOX_X + NAME_BOX_SIZE_X - NAME_BOX_MARGIN
        extreme_y = NAME_BOX_Y + NAME_BOX_SIZE_Y - NAME_BOX_MARGIN

        image.paste(
            rescaled_icon,
            (
                extreme_x - rescaled_icon.width,
                extreme_y - rescaled_icon.height,
                extreme_x,
                extreme_y,
            ),
            rescaled_icon,
        )

    return image
Exemplo n.º 7
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--color', '-c', type=int, nargs=3, help="Main color of the sprite",
                        default=(0, 255, 0))
    parser.add_argument('--outline', '-o', type=int, nargs=3, help="Color of the sprite's outline")
    parser.add_argument('--background', '-b', type=int, nargs=3, help="Color of the background",
                        default=(255, 255, 255))
    parser.add_argument('--transparency', '-t', action='store_true',
                        help="Use transparent background")
    parser.add_argument('--size', '-s', type=int, default=10,
                        help="Desired size in pixels for the desired result image")
    parser.add_argument('--random-color', '-r', action='store_true',
                        help="The main color used will be random, and the outline will be automatically darkened")

    args = parser.parse_args()

    outline = args.outline and tuple(args.outline)
    if args.random_color:
        # Set random color regardless of what was set in the args
        args.color = [randint(0, 255) for _ in range(3)]

    # Generate image
    img = create_sprite(generate_bitmap(), tuple(args.color),
                        outline, tuple(args.background), args.transparency)
    # Save image to a file as PNG with a random filename
    random_filename = ''.join(choice(string.ascii_letters) for _ in range(16))
    # Scale the image to the desired size
    if args.size > 10:
        img = ImageOps.scale(img, args.size / 10, resample=Image.NONE)
    img.save(random_filename + '.png')
Exemplo n.º 8
0
def atkinson_dither(in_file):
    img = Image.open(in_file).convert('L')
    pixel = img.load()
    w, h = img.size
    for y in range(h):
        for x in range(w):
            oldpixel = pixel[x, y]
            newpixel = round(oldpixel / 256, 0)
            pixel[x, y] = newpixel
            quant_error = oldpixel - newpixel
            if x < w - 1:
                pixel[x + 1, y] += quant_error * 1 // 8
            if x < w - 2:
                pixel[x + 2, y] += quant_error * 1 // 8
            if x > 0 and y < h - 1:
                pixel[x - 1, y + 1] += quant_error * 1 // 8
            if y < h - 1:
                pixel[x, y + 1] += quant_error * 1 // 8
            if y < h - 2:
                pixel[x, y + 2] += quant_error * 1 // 8
            if x < w - 1 and y < h - 1:
                pixel[x + 1, y + 1] += quant_error * 1 // 8

    if w > 1024 or h > 512:
        img = ImageOps.scale(img, 0.75)
    img.save(in_file + "_output.png")
    return in_file + '_output.png'
Exemplo n.º 9
0
def colour_dither(in_file):
    img = Image.open(in_file).convert('RGB')
    print('hello')
    size = img.size
    if size[0] > 1024 or size[1] > 512:
        img = ImageOps.scale(img, 0.75)
        print("size reduced")
    img_data = list(img.getdata())
    length = len(list(img.getdata()))
    freq_dist = FreqDist(img_data)
    top_256_colours = freq_dist.most_common(256)
    palette = []
    for colour in top_256_colours:
        palette.append(colour[0])
    while len(palette) < 256:
        palette.append((0, 0, 0))
    try:
        flat_palette = reduce(lambda a, b: a + b, palette)
        assert len(flat_palette) == 768
        palette_img = Image.new('P', (1, 1), 0)
        palette_img.putpalette(flat_palette)
        newimage = img.quantize(palette=palette_img)
        newimage.save(in_file + '_output.png')
        return in_file + '_output.png'
    except Exception as inst:
        print(type(inst))
        print(inst.args)
        return in_file
Exemplo n.º 10
0
    def resize_image(self, image):
        (img_width, img_height) = image.size

        logging.info("orig {}/{}".format(img_width, img_height))

        if not self.upscale and ((img_width <= self.basewidth) and
                                 (img_height <= self.baseheight)):
            ratio = 1
        else:
            ratio = min(self.basewidth / img_width,
                        self.baseheight / img_height)
            logging.info("ratio: {}".format(ratio))

        wsize = int(img_width * ratio)
        hsize = int(img_height * ratio)

        logging.info("new size: {}/{}".format(wsize, hsize))

        try:
            resized_image = ImageOps.scale(image, ratio)
        except:
            logging.warning("exception in ImageOps.scale: {}".format(
                sys.exc_info()[0]))

        image.close()

        return (resized_image)
Exemplo n.º 11
0
 def _update_zoom(self, *change):
     """
     Update the cached zoomed image.
     This operation is time consuming and should be computed
     as little as possible.
     """
     self.zoomed_image = ImageOps.scale(self.current_image, self.zoom_scale)
     self._update_crop()
def do_texture(path, id, textures, values, thumb_sizes, args):
    if not path:
        return

    if path not in textures:
        return

    pptr = textures[path]

    texture = pptr.read()
    flipped = None

    filename, exists = get_filename(args.outdir, args.orig_dir, id, ext=".png")

    if not (args.skip_existing and exists):
        print("-> %r" % (filename))
        flipped = ImageOps.scale(texture.image, 1).convert("RGB")
        flipped.save(filename)

    for format in args.formats:
        ext = "." + format
        filename, exists = get_filename(args.outdir,
                                        args.tiles_dir,
                                        id,
                                        ext=ext)
        if not (args.skip_existing and exists):
            tile_texture = generate_tile_image(texture.image, values["tile"])
            print("-> %r" % (filename))
            tile_texture.save(filename)

        if ext == ".png":
            # skip png generation for thumbnails
            continue

        for sz in thumb_sizes:
            thumb_dir = "%ix" % (sz)
            filename, exists = get_filename(args.outdir,
                                            thumb_dir,
                                            id,
                                            ext=ext)
            if not (args.skip_existing and exists):
                if not flipped:
                    flipped = ImageOps.scale(texture.image, 1).convert("RGB")
                thumb_texture = flipped.resize((sz, sz))
                print("-> %r" % (filename))
                thumb_texture.save(filename)
    def PaintGraphicsArea(self, paintEvent):
        self.outputView.ResultGraphicsArea.setAutoFillBackground(True)
        painter = QtGui.QPainter(self.outputView.ResultGraphicsArea)

        displayImage = ImageOps.invert(
            self.application.nestingRun.DisplayImage)
        scaleFactor = min(
            self.outputView.ResultGraphicsArea.height() / displayImage.height,
            self.outputView.ResultGraphicsArea.width() / displayImage.width)
        displayImage = ImageOps.scale(displayImage, scaleFactor)
        painter.drawImage(0, 0, ImageQt.ImageQt(displayImage))
Exemplo n.º 14
0
def rescale(im):
    # Assume 72 DPI if we don't know, as this is
    # one of the lowest common DPI values.
    try:
        dpi = im.info['dpi']
    except KeyError:
        dpi = 72

    target_dpi = 300
    factor = target_dpi / dpi

    return ImageOps.scale(im, factor)
Exemplo n.º 15
0
def scalare():
    if request.method == "POST":
        delete_images()
        image_src = 'static/uploads/img.png'
        im = Image.open(image_src)
        # Convertim datele primite care apartin [0,100] in date care apartin [0,2]
        # Pentru factor = 1 imaginea este cea originala, valori din ce in ce mai mici (<1) imaginea se micsoreaza
        # si pentru valori din ce in ce mai mari (>1) imaginea se mareste
        factor = int(request.get_data()) * 2 / 100
        im_scale = ImageOps.scale(im, factor)
        imgname = 'img_scale_' + str(factor) + '.png'
        im_scale.save('static/uploads/' + imgname)
        image_url_scale = url_for('static', filename="uploads/" + imgname)
        return jsonify({'image_url_scale': image_url_scale})
Exemplo n.º 16
0
def fit_image(img: Image.Image,
              size) -> Tuple[Image.Image, Tuple[int, int, int, int]]:
    img_width, img_height = img.size
    desired_width, desired_height = size

    ratio = min(desired_width / img_width, desired_height / img_height)
    img = ImageOps.scale(img, ratio)

    width, height = img.size
    x, y = ((desired_width - width) // 2, (desired_height - height) // 2)

    border = (x, y, desired_width - x - width, desired_height - y - height)
    img = ImageOps.expand(img, border=border, fill="white")

    return img, (x, y, width, height)
Exemplo n.º 17
0
    def reload_image_label(self, image, label):
        if image.size[0] > _img_size[0] or image.size[1] > _img_size[1]:
            img = ImageOps.scale(
                image,
                min((expected / actual
                     for expected, actual in zip(_img_size, image.size))))
        else:
            img = image

        if img.mode != "RGB":
            img = img_utils.add_transparency_grid(img)

        img_tk = ImageTk.PhotoImage(img)

        label.configure(image=img_tk)
        label.image = img_tk
Exemplo n.º 18
0
def generate_pixel_image(image_string):
    '''
    https://stackoverflow.com/questions/30520666/pixelate-image-with-pillow

    '''
    block_size = 16
    size = (block_size, block_size)
    image = base64_to_PIL_image(image_string)
    im = image.convert('RGB')
    img_data = list(im.getdata())
    freq_dist = FreqDist(set(img_data))
    most_common = freq_dist.most_common(256)
    palette = []
    for colour in most_common:
        palette.append(colour[0])
    while len(palette) < 256:
        palette.append((0, 0, 0))
    try:
        flat_palette = reduce(lambda a, b: a + b, palette)
        assert len(flat_palette) == 768
        palette_img = Image.new('P', (1, 1), 0)
        palette_img.putpalette(flat_palette)
        multiplier = 8
        scaled_img = im.resize((size[0] * multiplier, size[1] * multiplier),
                               Image.ANTIALIAS)
        reduced_img = scaled_img.quantize(palette=palette_img)
        rgb_img = reduced_img.convert('RGB')
        out = Image.new('RGB', size)
        for x in range(size[0]):
            for y in range(size[1]):
                #sample and get average color in the corresponding square
                histogram = defaultdict(int)
                for x2 in range(x * multiplier, (x + 1) * multiplier):
                    for y2 in range(y * multiplier, (y + 1) * multiplier):
                        histogram[rgb_img.getpixel((x2, y2))] += 1
                color = max(histogram.items(), key=operator.itemgetter(1))[0]
                out.putpixel((x, y), color)

        new_file = ImageOps.scale(out, 50)
        print("pixe_image done")
        output = PIL_image_to_base64(new_file)
    #https://docs.python.org/3/tutorial/errors.html
    except Exception as inst:
        print(type(inst))
        print(inst.args)
        output = image_string
    return output
Exemplo n.º 19
0
def image_merge(in_file):
    img = Image.open(in_file).convert('RGB')
    size = img.size
    if size[0] > 1024 or size[1] > 512:
        img = ImageOps.scale(img, 0.75)
        print("size reduced")
    r, g, b = img.split()
    colours = []
    colours.extend([r, g, b])
    a = choice(colours)
    b = choice(colours)
    c = choice(colours)
    a = ImageChops.offset(a, randint(-20, 20), randint(-10, 10))
    #ImageChops.multiply(g, r).save(in_file+'_output.png')
    Image.merge("RGB", (a, b, c)).save(in_file + '_output.png')
    print("image_merge done\n")
    return in_file + '_output.png'
Exemplo n.º 20
0
def generate_pixel_image(in_file):
    block_size = 16
    size = (block_size, block_size)
    im = Image.open(in_file).convert('RGB')
    img_data = list(im.getdata())
    length = len(list(im.getdata()))
    freq_dist = FreqDist(set(img_data))
    top_ten_colours = freq_dist.most_common(256)
    palette = []
    for colour in top_ten_colours:
        palette.append(colour[0])
    while len(palette) < 256:
        palette.append((0, 0, 0))
    try:
        flat_palette = reduce(lambda a, b: a + b, palette)
        assert len(flat_palette) == 768
        palette_img = Image.new('P', (1, 1), 0)
        palette_img.putpalette(flat_palette)
        multiplier = 8
        scaled_img = im.resize((size[0] * multiplier, size[1] * multiplier),
                               Image.ANTIALIAS)
        reduced_img = scaled_img.quantize(palette=palette_img)
        rgb_img = reduced_img.convert('RGB')
        out = Image.new('RGB', size)
        for x in range(size[0]):
            for y in range(size[1]):
                #sample and get average color in the corresponding square
                histogram = defaultdict(int)
                for x2 in range(x * multiplier, (x + 1) * multiplier):
                    for y2 in range(y * multiplier, (y + 1) * multiplier):
                        histogram[rgb_img.getpixel((x2, y2))] += 1
                color = max(histogram.items(), key=operator.itemgetter(1))[0]
                out.putpixel((x, y), color)

        new_file = ImageOps.scale(out, 50)
        out_file, ext = in_file, ext = os.path.splitext(in_file)
        new_file.save(out_file + "_output.png")
        print("pixe_image done")
        return (out_file + "_output.png")
    #https://docs.python.org/3/tutorial/errors.html
    except Exception as inst:
        print(type(inst))
        print(inst.args)
        return (in_file)
Exemplo n.º 21
0
def main(filename, mode, tone):
	if path.isfile(filename):
		source_im = Image.open(filename)
		width, hight = source_im.size
		if mode == "wide":
			ratio = 5000/width
		if mode == "high":
			ratio = 5000/hight
		im = ImageOps.scale(source_im,ratio*0.8)
		wi, hi = im.size 
		wi2 = int((5000 - wi)/2)
		hi2 = int((5000 - hi)/2) 
		if tone == "light":
			im = ImageOps.expand(im, border = (wi2,hi2), fill="#E5E5E5")
		if tone == "dark":
			im = ImageOps.expand(im, border = (wi2,hi2), fill="#0e0e0e")
		im.save(f'exp_{filename}')
	else:
        	exit("No source file found!")
Exemplo n.º 22
0
        async def create_level_image(ctx, name, url, level, rank):
            colors = {
                range(0, 10): (155, 155, 155),
                range(10, 20): (192, 41, 66),
                range(20, 30): (217, 91, 67),
                range(30, 40): (254, 204, 35),
                range(40, 50): (70, 122, 60),
                range(50, 60): (78, 141, 219),
                range(60, 70): (118, 82, 201),
                range(70, 80): (194, 82, 201),
                range(80, 90): (84, 36, 55),
                range(90, 100): (153, 124, 82)
            }

            for color_range in colors:
                if level <= 100 and level in color_range:
                    color = colors[color_range]
                    break
                elif 1000 > level > 100 and level - int(
                        str(level)[0]) * 100 in color_range:
                    color = colors[color_range]
                    break
            else:
                color = (155, 155, 155),

            role = ctx.message.author.roles

            xp_current_lvl = await self.lvl_xp(level)
            xp_next_lvl = await self.lvl_xp(level + 1)
            xp_current = get_xp_from_user(ctx.guild.id, name.id)

            step = xp_next_lvl - xp_current_lvl
            state = xp_current - xp_current_lvl

            try:
                img = Image.open(r'img/stats/bg{}.png'.format(
                    round(round(state / step * 100) / 2)))
            except:
                img = Image.open(r'img/stats/bg0.png')

            response = requests.get(url)
            pb = Image.open(BytesIO(response.content))
            img = ImageOps.scale(img, factor=2)
            img = ImageOps.expand(img, border=150, fill="black")

            pb = pb.resize((456, 430), Image.ANTIALIAS)
            pb = ImageOps.expand(pb, border=15, fill=f'{max(role).colour}')

            img.paste(pb, (130, 75))

            xp_string = f"XP: {xp_current} / {xp_next_lvl}"

            # Font Positions
            level_positions = {
                1: (410, 585),
                2: (355, 585),
                3: (300, 585),
                4: (230, 585)
            }
            nxt_level_positions = {
                1: (1720, 585),
                2: (1705, 585),
                3: (1700, 585),
                4: (1700, 585)
            }

            # Draw Name
            draw = ImageDraw.Draw(img)
            name_level_size = 130 if len(
                str(name)) <= 19 else 130 - (len(str(name)) - 19) * 5
            draw.text((680, 175),
                      f"Rank: #{rank} Level: {level}",
                      color,
                      font=ImageFont.truetype('fonts/micross.ttf',
                                              name_level_size))
            draw.text((680, 330),
                      f"{name}",
                      color,
                      font=ImageFont.truetype('fonts/micross.ttf',
                                              name_level_size))

            # Draw Lvl
            draw.text(level_positions[len(str(level))],
                      f"{level}",
                      color,
                      font=ImageFont.truetype('fonts/micross.ttf', 130))
            draw.text(nxt_level_positions[len(str(level))],
                      f"{level + 1}",
                      color,
                      font=ImageFont.truetype('fonts/micross.ttf', 130))

            # Draw XP
            xp_position = (830 - int((int(len(xp_string) - 12) * 25)), 775)
            draw.text(xp_position,
                      xp_string, (68, 180, 132),
                      font=ImageFont.truetype('fonts/CORBEL.TTF', 115))

            with BytesIO() as output:
                img.save(output, format="PNG")
                output.seek(0)
                await ctx.send(
                    file=discord.File(fp=output, filename="image.png"))
Exemplo n.º 23
0
 async def _process_commands(self, command: str, path: str):  # noqa c901
     ar = [x.split(" ") for x in [a.strip(" ") for a in command.split(',')]]
     im: Image = PIL.Image.open(path)
     # im.load()
     im = im.convert("RGBA")
     print(ar)
     fmt = "png"
     for e in ar:
         for i in range(3):
             e.append(None)
         if e[0] == "convert":
             mode = e[1]
             if not mode or mode not in "bw,rgb,rgba,luma,web,adaptive":
                 raise commands.ConversionError("Unknown conversion mode",
                                                original=None)
             if mode == "bw":
                 im = im.convert("1")
             if mode in ["rgb", "rgba"]:
                 im = im.convert(mode.upper())
             if mode == "luma":
                 im = im.convert("L")
             if mode == "web":
                 im = im.convert("P")
             if mode == "adaptive":
                 im = im.convert(
                     "P",
                     palette=ADAPTIVE,
                     colors=min(int(e[2]), 256) if e[2] else 256)
         if e[0] == "format":
             if not e[1] or e[1] not in "png,jpg,gif".split(","):
                 raise commands.ConversionError(
                     f"Invalid output format {e[1]}", original=None)
             fmt = e[1]
         if e[0] == "bw":
             im = im.convert("1").convert("RGBA")
         if e[0] == "luma":
             im = im.convert("L").convert("RGBA")
         if e[0] == "autocontrast":
             im = im.convert("RGB")
             im = ImageOps.autocontrast(im, int(e[1]) if e[1] else 0)
             im = im.convert("RGBA")
         if e[0] == "rotate":
             im = im.rotate(int(e[1]))
         if e[0] == "invert":
             im = ImageOps.invert(im)
         if e[0] == "grayscale":
             im = ImageOps.grayscale(im)
         if e[0] == "equalize":
             im = ImageOps.equalize(im)
         if e[0] == "sepia":
             im = ImageOps.colorize(ImageOps.grayscale(im), (0, 0, 0),
                                    (255, 255, 255),
                                    mid=(112, 66, 20))
         if e[0] == "colorize":
             im = ImageOps.colorize(ImageOps.grayscale(im), (0, 0, 0),
                                    (255, 255, 255),
                                    mid=self._color(e[1]))
         if e[0] == "posterize":
             im = ImageOps.posterize(im, int(e[1]) if e[1] else 128)
         if e[0] == "solarize":
             im = im.convert("RGB")
             if len(e) > 1:
                 a = int(e[1])
             else:
                 a = 128
             im = ImageOps.solarize(im, a)
             im = im.convert("RGBA")
         if e[0] == "flip":
             im = ImageOps.flip(im)
         if e[0] == "mirror":
             im = ImageOps.mirror(im)
         if e[0] == "blur":
             if len(e) > 1:
                 a = int(e[1])
             else:
                 a = 2
             im = im.filter(ImageFilter.GaussianBlur(a))
         if e[0] == "boxblur":
             if len(e) > 1:
                 a = int(e[1])
             else:
                 a = 2
             im = im.filter(ImageFilter.BoxBlur(a))
         if e[0] == "sharpen":
             im = im.filter(
                 ImageFilter.UnsharpMask(
                     int(e[1]) if e[1] else 2,
                     int(e[2]) if e[2] else 150,
                     int(e[3]) if e[3] else 3))
         if e[0] == "scale":
             im = ImageOps.scale(im, float(e[1]))
         if e[0] == "pscale":
             im = ImageOps.scale(im, float(e[1]), PIL.Image.NEAREST)
         if e[0] == "scalexy":
             im = im.resize((int(im.width * float(e[1])),
                             int(im.height * float(e[2]))))
         if e[0] == "pscalexy":
             im = im.resize((int(
                 im.width * float(e[1])), int(im.height * float(e[2]))),
                            PIL.Image.NEAREST)
         if e[0] == "scaleto":
             im = im.resize((int(e[1]), int(e[2])), PIL.Image.BICUBIC)
         if e[0] == "pscaleto":
             im = im.resize((int(e[1]), int(e[2])), PIL.Image.NEAREST)
         if e[0] == "potografy":
             im = im.resize((int(im.width / 20), int(im.height / 4)),
                            PIL.Image.NEAREST)
             im = im.resize((int(im.width * 20), int(im.height * 4)),
                            PIL.Image.NEAREST)
             im = ImageOps.posterize(im, 2)
             im = ImageOps.colorize(ImageOps.grayscale(im), (0, 0, 0),
                                    (255, 255, 255),
                                    mid=(112, 66, 20))
             im = im.rotate(25)
         if e[0] == "matrix":
             size = (im.width, im.height)
             im = im.resize((int(e[1]), int(e[2])), PIL.Image.NEAREST)
             im = im.resize(size, PIL.Image.NEAREST)
     a = path.split(".")
     async with self.lock:
         self.counter += 1
     b = str(self.counter) + "." + fmt  # + a[-1]
     im.save(b)
     return True, b, os.path.getsize(b)
Exemplo n.º 24
0
    def get(self, request, pk=None, project_pk=None, image_filename=""):
        """
        Generate a thumbnail on the fly for a particular task's image
        """
        task = self.get_and_check_task(request, pk)
        image = ImageUpload.objects.filter(task=task, image=assets_directory_path(task.id, task.project.id, image_filename)).first()

        if image is None:
            raise exceptions.NotFound()

        image_path = image.path()
        if not os.path.isfile(image_path):
            raise exceptions.NotFound()

        try:
            thumb_size = int(self.request.query_params.get('size', 512))
            if thumb_size < 1:
                raise ValueError()

            quality = int(self.request.query_params.get('quality', 75))
            if quality < 0 or quality > 100:
                raise ValueError()
                
            center_x = float(self.request.query_params.get('center_x', '0.5'))
            center_y = float(self.request.query_params.get('center_y', '0.5'))
            if center_x < -0.5 or center_x > 1.5 or center_y < -0.5 or center_y > 1.5:
                raise ValueError()

            draw_points = self.request.query_params.getlist('draw_point')
            point_colors = self.request.query_params.getlist('point_color')
            point_radiuses = self.request.query_params.getlist('point_radius')
            
            points = []
            i = 0
            for p in draw_points:
                coords = list(map(float, p.split(",")))
                if len(coords) != 2:
                    raise ValueError()

                points.append({
                    'x': coords[0],
                    'y': coords[1],
                    'color': hex2rgb(point_colors[i]) if i < len(point_colors) else (255, 255, 255),
                    'radius': float(point_radiuses[i]) if i < len(point_radiuses) else 1.0,
                })

                i += 1
            
            zoom = float(self.request.query_params.get('zoom', '1'))
            if zoom < 0.1 or zoom > 10:
                raise ValueError()

        except ValueError:
            raise exceptions.ValidationError("Invalid query parameters")

        with Image.open(image_path) as img:
            if img.mode != 'RGB':
                img = normalize(img)
                img = img.convert('RGB')
            w, h = img.size
            thumb_size = min(max(w, h), thumb_size)
            
            # Move image center
            if center_x != 0.5 or center_y != 0.5:
                img = img.crop((
                        w * (center_x - 0.5),
                        h * (center_y - 0.5),
                        w * (center_x + 0.5),
                        h * (center_y + 0.5)
                    ))
            
            # Scale
            scale_factor = 1
            off_x = 0
            off_y = 0

            if zoom != 1:
                scale_factor = (2 ** (zoom - 1))
                off_x = w / 2.0 - w / scale_factor / 2.0
                off_y = h / 2.0 - h / scale_factor / 2.0
                win = img.crop((off_x, off_y, 
                                off_x + (w / scale_factor),
                                off_y + (h / scale_factor)
                    ))
                img = ImageOps.scale(win, scale_factor, Image.NEAREST)

            sw, sh = w * scale_factor, h * scale_factor

            # Draw points
            for p in points:
                d = ImageDraw.Draw(img)
                r = p['radius'] * max(w, h) / 100.0
                
                sx = (p['x'] + (0.5 - center_x)) * sw
                sy = (p['y'] + (0.5 - center_y)) * sh
                x = sx - off_x * scale_factor
                y = sy - off_y * scale_factor

                d.ellipse([(x - r, y - r), 
                           (x + r, y + r)], outline=p['color'], width=int(max(1.0, math.floor(r / 3.0))))
            
            img.thumbnail((thumb_size, thumb_size))
            output = io.BytesIO()
            img.save(output, format='JPEG', quality=quality)

            res = HttpResponse(content_type="image/jpeg")
            res['Content-Disposition'] = 'inline'
            res.write(output.getvalue())
            output.close()

            return res
Exemplo n.º 25
0
def draw_stat_box(
    move: str,
    attacks: str,
    range_: str,
    hits: str,
    save: str,
) -> Image:
    image = Image.new("RGBA", CARD_SIZE, (255, 0, 0, 0))

    # Draw a half-opaque rectangle
    box = ImageDraw.Draw(image)
    box.rectangle(
        [
            STAT_BOX_X,
            STAT_BOX_Y,
            STAT_BOX_SIZE_X + STAT_BOX_X,
            STAT_BOX_SIZE_Y + STAT_BOX_Y,
        ],
        fill=COLOUR_CODE,
    )

    # Draw lines
    for index in range(1, 5):
        y_position = (STAT_BOX_Y + STAT_BOX_MARGIN + (2 * index) *
                      ((STAT_BOX_SIZE_Y - 2 * STAT_BOX_MARGIN) / 10))
        box.line(
            (
                STAT_BOX_X + STAT_BOX_MARGIN,
                y_position,
                STAT_BOX_X + STAT_BOX_SIZE_X - STAT_BOX_MARGIN,
                y_position,
            ),
            fill=(1, 0, 0),
        )

    # Add icons
    for index, icon in enumerate(["move", "attacks", "range", "hits", "save"]):
        x_position = int(STAT_BOX_X + (STAT_BOX_SIZE_X / 4))
        y_position = int(STAT_BOX_Y + STAT_BOX_MARGIN + (1 + 2 * index) *
                         ((STAT_BOX_SIZE_Y - 2 * STAT_BOX_MARGIN) / 10))
        icon_file = STAT_ICON_FOLDER / (icon + ".png")
        with Image.open(icon_file) as icon_im:
            icon_im = icon_im.crop(icon_im.getbbox())
            scaling_factor = 35 / icon_im.height
            logging.info("Rescale icon %s with factor %s", icon_file,
                         scaling_factor)
            rescaled_icon = ImageOps.scale(icon_im, scaling_factor)
        image.paste(
            rescaled_icon,
            (
                x_position - rescaled_icon.width // 2,
                y_position - rescaled_icon.height // 2,
            ),
            rescaled_icon,
        )

    # Write the stats
    font = ImageFont.truetype(
        str(ROOT_FOLDER / "SourceSansPro-SemiBold.ttf"),
        size=STAT_BOX_FONT_SIZE,
    )

    for index, stat in enumerate([move, attacks, range_, hits, save]):
        y_position = (STAT_BOX_Y + STAT_BOX_MARGIN + (1 + 2 * index) *
                      ((STAT_BOX_SIZE_Y - 2 * STAT_BOX_MARGIN) / 10))
        box.text(
            (STAT_BOX_X + (3 * STAT_BOX_SIZE_X / 4), y_position),
            stat,
            font=font,
            fill=(1, 0, 0),
            anchor="mm",
        )
    return image
Exemplo n.º 26
0
    def augmentation(self, img, mask, whole_image=False):
        ow = img.size[0]
        oh = img.size[1]
        rh = self.h_size
        rw = self.w_size
        if random.random() < 0.5:
            img = ImageOps.flip(img)
            mask = ImageOps.flip(mask)
        if random.random() < 0.5:
            img = ImageOps.mirror(img)
            mask = ImageOps.mirror(mask)
        '''
        if random.random() > 0.5:
            if random.random() < 0.5:
                zoom = random.uniform(1.0, 1.5)
                img = ImageOps.scale(img, zoom, Image.BILINEAR)
                mask = ImageOps.scale(mask, zoom)
                # x1 = random.randint(0, round(ow * zoom - ow))
                # y1 = random.randint(0, round(oh * zoom - oh))
                x1 = int(round((ow * zoom - ow) / 2.))
                y1 = int(round((oh * zoom - oh) / 2.))
                img = img.crop((x1, y1, x1 + ow, y1 + oh))
                mask = mask.crop((x1, y1, x1 + ow, y1 + oh))

            else:
                scale = random.uniform(0.5, 1.0)
                crop_h = int(oh * scale)
                crop_w = int(ow * scale)
                # x1 = random.randint(0, round(ow - crop_w))
                # y1 = random.randint(0, round(oh - crop_h))
                x1 = int(round((ow - crop_w) / 2.))
                y1 = int(round((oh - crop_h) / 2.))
                img = img.crop((x1, y1, x1 + crop_w, y1 + crop_h))
                mask = mask.crop((x1, y1, x1 + crop_w, y1 + crop_h))
        '''
        if random.random() < 0.5:
            zoom = random.uniform(1.0, 1.5)
            img = ImageOps.scale(img, zoom, Image.BILINEAR)
            mask = ImageOps.scale(mask, zoom)
            x1 = int(round((ow * zoom - ow) / 2.))
            y1 = int(round((oh * zoom - oh) / 2.))
            img = img.crop((x1, y1, x1 + ow, y1 + oh))
            mask = mask.crop((x1, y1, x1 + ow, y1 + oh))

        if random.random() < 0.5:
            scale = random.uniform(0.5, 1.0)
            crop_h = int(oh * scale)
            crop_w = int(ow * scale)
            x1 = int(round((ow - crop_w) / 2.))
            y1 = int(round((oh - crop_h) / 2.))
            img = img.crop((x1, y1, x1 + crop_w, y1 + crop_h))
            mask = mask.crop((x1, y1, x1 + crop_w, y1 + crop_h))
        '''
        if random.random() < 0.5:
            shift_pix = random.randint(-20, 20)
            img = ImageChops.offset(img, shift_pix)
            mask = ImageChops.offset(mask, shift_pix)
        '''
        if random.random() < 0.5:
            angle = random.uniform(-10, 10)
            img = img.rotate(angle, resample=Image.BILINEAR)
            mask = mask.rotate(angle)

        img = img.resize((rw, rh), resample=Image.BILINEAR)
        mask = mask.resize((rw, rh), resample=Image.NEAREST)
        return img, mask
Exemplo n.º 27
0
images = {}
heights_px = []
widths_px = []

for file in glob.glob('*.png'):
    name = Path(file).stem
    im = Image.open(file)
    images[name] = im
    heights_px.append(im.height)
    widths_px.append(im.width)

#%% padding to max h and w
max_w_px = max(widths_px)
max_h_px = max(heights_px)

for im in images:
    images[im] = ImageOps.pad(images[im],
                              size=(max_w_px, max_h_px),
                              color='white')

#%% calculate image sizes with respect to columns and pagesize
page_w_px = int(dpi * page_w_cm // 2.54)
page_h_px = int(dpi * page_h_cm // 2.54)

max_allowed_w_px = page_w_px // columns
scale = max_allowed_w_px / max_w_px

for im in images:
    images[im] = ImageOps.scale(images[im], scale)
    images[im].save(im + '.png')
Exemplo n.º 28
0
 def __init__(self, filename, scale=1):
     self.img = Image.open(filename)
     self.extract_tags()
     if scale != 1:
         self.img = ImageOps.scale(self.img, scale)
Exemplo n.º 29
0
from PIL import Image, ImageFilter, ImageOps

base = Image.open('assets/test.jpg')

# Crop image all sides equal
img_crop = ImageOps.crop(base, border=50)
img_crop.save('crop_image.jpg')

# Crop image with (left,upper,right,lower) pixels
img_crop1 = base.crop((0, 380, 600, 510))
img_crop1.save('crop1_image.jpg')

# Scale Image
img_scale = ImageOps.scale(base, 0.5)
img_scale.save('scale_image.jpg')

# Convert Image to grey scale
img_grey = ImageOps.grayscale(base)
img_grey.save('grey_image.jpg')

# Invert image
img_inv = ImageOps.invert(base)
img_inv.save('invert_image.jpg')

# Solarize image
img_solarize = ImageOps.solarize(base, threshold=100)
img_solarize.save('solarize_image.jpg')

# Applying BOX BLUR
img_blur = base.filter(filter=ImageFilter.BoxBlur(2))
img_blur.save('blur_image.jpg')