Example #1
0
def generate_letter(char, font_size, font_name):
    img_dim = (font_size + font_size / 2,) * 2
    img = new_image("RGB", img_dim, (0, 0, 0))
    img_draw = Draw(img)
    #font = PIL.ImageFont.ImageFont()
    #font.font = PIL.ImageFont.truetype(font_name, font_size)
    #font.color = tuple( [randrange(126, 256) for i in range(3)] )
    font = PIL.ImageFont.truetype(font_name, font_size)
    color = tuple( [randrange(126, 256) for i in range(3)] )
    img_draw.text((0, 0), char, color, font)
    #img = img_draw.flush()
    img = img.rotate(randrange(-30, 30), BICUBIC)
    mask = new_image("L", img.size, 0)
    mask.paste(img, (0, 0))
    return img, mask
def save_collage(filename, crown_dict, mse_dict):

    number_of_crowns = len(crown_dict)
    rows = ceil(number_of_crowns / 4)
    collage = new_image('RGB', (1200, 300 * rows))

    crowns = crown_dict.keys()

    font = ImageFont.truetype("arial.ttf", 15)

    i = 1
    h_offset = 0
    v_offset = 0

    for crown in crowns:
        img = crown_dict[crown].resize((300, 300))
        Draw(img).text((30, 5),
                       crown + ' with error: ' + str(mse_dict[crown]),
                       fill=(255, 255, 255),
                       font=font)
        collage.paste(img, (h_offset, v_offset))
        h_offset += 300
        if i % 4 == 0:
            v_offset += 300
            h_offset = 0
        i += 1

    if isdir(join('saved_files', filename)):
        rmtree(join('saved_files', filename))
    mkdir(join('saved_files', filename))

    collage.save(join('saved_files', filename, 'collage.jpg'))
    print('Collage saved: ' + join('saved_files', filename, 'collage.jpg'))
    collage.show()
Example #3
0
    def get_thumbnail(self, xnewsize, ynewsize, format=None, fit=False):
        # Get the handle
        handle = self._get_handle()
        if handle is None:
            return None, None
        format = format or self._get_format(handle)

        # Icon's thumbnail is the icon itself
        if format == 'ICO':
            return self.to_str(), format.lower()

        xsize, ysize = self.size
        xratio, yratio = float(xnewsize)/xsize, float(ynewsize)/ysize
        # Case 1: fit
        if fit:
            # Scale the image so no more than one side overflows
            ratio = max(xratio, yratio)
            im, xsize, ysize = self._scale_down(handle, ratio)

            # Crop the image so none side overflows
            xsize = min(xsize, xnewsize)
            ysize = min(ysize, ynewsize)
            im = im.crop((0, 0, xsize, ysize))

            # Paste the image into a background so it fits the target size
            if xsize < xnewsize or ysize < xnewsize:
                newsize = (xnewsize, ynewsize)
                background = new_image('RGBA', newsize, (255, 255, 255, 0))
                x = (xnewsize - xsize) / 2
                y = (ynewsize - ysize) / 2
                background.paste(im, (x, y))
                im = background

        # Case 2: thumbnail
        else:
            # Scale the image so none side overflows
            ratio = min(xratio, yratio)
            im, xsize, ysize = self._scale_down(handle, ratio)

        # To string
        output = StringIO()
        # JPEG : Convert to RGB
        if format.lower() == 'jpeg':
            im = im.convert("RGB")
        im.save(output, format, quality=80)
        value = output.getvalue()
        output.close()

        # Ok
        return value, format.lower()
Example #4
0
    def get_thumbnail(self, xnewsize, ynewsize, format=None, fit=False):
        # Get the handle
        handle = self._get_handle()
        if handle is None:
            return None, None
        format = format or self._get_format(handle)

        # Icon's thumbnail is the icon itself
        if format == 'ICO':
            return self.to_str(), format.lower()

        xsize, ysize = self.size
        xratio, yratio = float(xnewsize) / xsize, float(ynewsize) / ysize
        # Case 1: fit
        if fit:
            # Scale the image so no more than one side overflows
            ratio = max(xratio, yratio)
            im, xsize, ysize = self._scale_down(handle, ratio)

            # Crop the image so none side overflows
            xsize = min(xsize, xnewsize)
            ysize = min(ysize, ynewsize)
            im = im.crop((0, 0, xsize, ysize))

            # Paste the image into a background so it fits the target size
            if xsize < xnewsize or ysize < xnewsize:
                newsize = (xnewsize, ynewsize)
                background = new_image('RGBA', newsize, (255, 255, 255, 0))
                x = (xnewsize - xsize) / 2
                y = (ynewsize - ysize) / 2
                background.paste(im, (x, y))
                im = background

        # Case 2: thumbnail
        else:
            # Scale the image so none side overflows
            ratio = min(xratio, yratio)
            im, xsize, ysize = self._scale_down(handle, ratio)

        # To string
        output = StringIO()
        # JPEG : Convert to RGB
        if format.lower() == 'jpeg':
            im = im.convert("RGB")
        im.save(output, format, quality=80)
        value = output.getvalue()
        output.close()

        # Ok
        return value, format.lower()
Example #5
0
def generate_captcha(directory="tmp", letters=ascii_uppercase+digits,
        length=3, font_size=30, lines=5, mode="ellipse", font="FreeSerif.ttf"):
    """ Returns a tuple : (path, code) """
    dimensions = ((length + 1) * font_size, int(font_size * 2))
    path = "%s%s" % (os.path.join(directory, "".join(choice(ascii_letters) for
        i in xrange(7))), ".png")
    code = "".join(choice(letters) for i in range(length))
    background_color = tuple( [randrange(190, 230) for i in xrange(3)] )
    master = new_image("RGB", dimensions, background_color)

    # On colle les lettres
    for i, l in enumerate(code):
        img, mask = generate_letter(l, font_size, font)
        for _ in xrange(3):
            # On colle plusieurs fois pour plus de netteté
            master.paste(img, (font_size / 2 + font_size * i , font_size / 3),
                    mask)

    # Et on dessine quelques jolies lignes
    draw = Draw(master)
    for i in xrange(lines):
        color = tuple( [randrange(128, 190) for i in xrange(3)] )
        #pen = Pen("black", opacity=64)
        #pen.color = color
        w = dimensions[0]
        h = dimensions[1]
        geom = (randrange(0, int(w * 3. / 4)), randrange(0, h),
                randrange(int(w * 1. / 4), w), randrange(0, h))
        if mode == "mixed":
            mode_ = choice( ("ellipse", "line") )
        else:
            mode_ = mode
        if mode_ == "ellipse":
            draw.ellipse(geom, None, color)
        else:
            draw.line(geom, color, 1)
    with open(path, "w") as f:
        master.save(f)
    return (path, code)
 def gen_image(self):
     return new_image('1', self.size, '#FFFFFF')
Example #7
0
def image_crop(
    image: Union[bytes, Image],
    crop: Optional[Crop] = None,
    width_preview: Optional[int] = None,
    image_alt: Optional[str] = None,
    min_width: Optional[int] = None,
    min_height: Optional[int] = None,
    max_width: Optional[int] = None,
    max_height: Optional[int] = None,
    # FIXME: Changing these properties, the component is rerendered unfortunately.
    # ----
    # keep_selection: Optional[bool] = None,
    # disabled: Optional[bool] = None,
    # locked: Optional[bool] = None,
    rule_of_thirds: Optional[bool] = None,
    circular_crop: Optional[bool] = None,
    # ----
    key: Optional[str] = None,
) -> Optional[Image]:
    import dataclasses
    from io import BytesIO
    from os import path

    import streamlit as st
    from PIL.Image import composite as composite_image
    from PIL.Image import new as new_image
    from PIL.Image import open as open_image
    from PIL.ImageDraw import Draw
    from streamlit.components import v1 as components
    from streamlit.elements.image import image_to_url

    global _impl

    if _impl is None:
        if _DEBUG:
            option_address = st.get_option("browser.serverAddress")
            option_port = st.get_option("browser.serverPort")
            _impl = (
                components.declare_component(
                    "image_crop",
                    url="http://localhost:3001",
                ),
                lambda s: f"http://{option_address}:{option_port}" + s,
            )
        else:
            _impl = (
                components.declare_component(
                    "image_crop",
                    path=path.join(path.dirname(path.abspath(__file__)),
                                   "frontend/build"),
                ),
                lambda s: s,
            )

    if isinstance(image, Image):
        image_ = image
    else:
        image_ = open_image(BytesIO(image))

    width, _ = image_.size

    src = image_to_url(
        image_,
        width=min(width, width_preview) if width_preview else width,
        clamp=False,
        channels="RGB",
        output_format="auto",
        image_id="foo",
    )

    crop_ = None if crop is None else dataclasses.asdict(crop)

    default = {
        "width": 0.0,
        "height": 0.0,
        "x": 0.0,
        "y": 0.0,
    }

    component, build_url = _impl

    result = component(
        src=build_url(src),
        image_alt=image_alt,
        minWidth=min_width,
        minHeight=min_height,
        maxWidth=max_width,
        maxHeight=max_height,
        # FIXME: Changing these properties, the component is rerendered unfortunately.
        # ----
        keepSelection=None,
        disabled=None,
        locked=None,
        ruleOfThirds=rule_of_thirds,
        circularCrop=circular_crop,
        # ----
        crop=crop_,
        key=key,
        default=default,
    )

    w, h = image_.size

    w_crop = int(w * float(result["width"]) / 100)
    h_crop = int(h * float(result["height"]) / 100)
    x0 = int(w * float(result["x"]) / 100)
    y0 = int(h * float(result["y"]) / 100)
    x1 = x0 + w_crop
    y1 = y0 + h_crop

    if w_crop <= 0 or h_crop <= 0:
        return None
    else:
        image_crop = image_.crop((x0, y0, x1, y1))
        if circular_crop:
            background = new_image("RGBA", (w_crop, h_crop), (0, 0, 0, 0))
            mask = new_image("L", (w_crop, h_crop), 0)
            draw = Draw(mask)
            draw.ellipse((0, 0, w_crop, h_crop), fill="white")
            image_crop = composite_image(image_crop, background, mask)

        return image_crop
Example #8
0
File: file.py Project: mcbeet/beet
 def default(cls) -> Image:
     return new_image("RGB", (16, 16), "black")