Esempio n. 1
0
def imdirect_open(fp):
    """Opens, identifies the given image file, and rotates it if it is a JPEG.

    Note that this method does NOT employ the lazy loading methodology that
    the PIL Images otherwise use. This is done to avoid having to save new

    Args:
        fp: A filename (string), pathlib.Path object or a file-like object.

    Returns:
        The image as an :py:class:`~PIL.Image.Image` object.

    Raises:
        IOError: If the file cannot be found, or the image cannot be
            opened and identified.

    """

    img = pil_open(fp, 'r')
    if img.format == 'JPEG':
        # Read Exif tag on image.
        if isinstance(fp, string_types):
            exif = piexif.load(text_type_to_use(fp))
        else:
            fp.seek(0)
            exif = piexif.load(fp.read())

        # If orientation field is missing or equal to 1, nothing needs to be done.
        orientation_value = exif.get('0th',
                                     {}).get(piexif.ImageIFD.Orientation)
        if orientation_value is None or orientation_value == 1:
            return img
        # Otherwise, rotate the image and update the exif accordingly.
        img_rot = autorotate(img)
        exif = update_exif_for_rotated_image(exif)

        # Now, lets restore the output image to
        # PIL.JpegImagePlugin.JpegImageFile class with the correct,
        # updated Exif information.
        # Save image as JPEG to get a correct byte representation of
        # the image and then read it back.
        with io.BytesIO() as bio:
            img_rot.save(bio, format='jpeg', exif=piexif.dump(exif))
            bio.seek(0)
            img_rot_new = pil_open(bio, 'r')
            # Since we use a BytesIO we need to avoid the lazy
            # loading of the PIL image. Therefore, we explicitly
            # load the data here.
            img_rot_new.load()
        img = img_rot_new

    return img
Esempio n. 2
0
 def clean_image(self):
     data = self.cleaned_data["image"]
     if data:
         if data.size > 41943040:
             raise forms.ValidationError("Image must be smaller than 5MB")
         self.image_format = pil_open(data.file).format
         if not self.image_format in self.IMAGE_FORMATS:
             raise forms.ValidationError("Images cannot be of type %s" % data.content_type)
     return data
Esempio n. 3
0
 def clean_image(self):
     data = self.cleaned_data["image"]
     if data:
         if data.size > 4194304:
             raise forms.ValidationError(_("Community images cannot be larger than 512K"))
         self.image_format = pil_open(data.file).format
         if not self.image_format in GroupForm.IMAGE_FORMATS:
             raise forms.ValidationError(_("Images cannot be of type %(type)s") % {"type": data.content_type})
     return data
 def clean_image(self):
     data = self.cleaned_data["image"]
     if data:
         if data.size > 41943040:
             raise forms.ValidationError("Image must be smaller than 5MB")
         self.image_format = pil_open(data.file).format
         if not self.image_format in self.IMAGE_FORMATS:
             raise forms.ValidationError("Images cannot be of type %s" %
                                         data.content_type)
     return data
Esempio n. 5
0
def loadImage(imageName):
    im = pil_open(imageName)
    try:
        ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBA", 0, -1)
    except SystemError:
        ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBX", 0, -1)
    ID = glGenTextures(1)
    glBindTexture(GL_TEXTURE_2D, ID)
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4)
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ix, iy, 0, GL_RGBA, GL_UNSIGNED_BYTE, image)
    return ID
Esempio n. 6
0
 def clean_image(self):
     data = self.cleaned_data["image"]
     if data:
         if data.size > 4194304:
             raise forms.ValidationError(
                 "Community images cannot be larger than 512K")
         self.image_format = pil_open(data.file).format
         if not self.image_format in GroupForm.IMAGE_FORMATS:
             raise forms.ValidationError("Images cannot be of type %s" %
                                         data.content_type)
     return data
Esempio n. 7
0
def difference(img, dest):
    fiarr = numpy.asarray(Image(img))
    fiarr = fiarr[..., ::-1]

    pilarr = numpy.asarray(pil_open(img))

    fiarr = fiarr.astype(numpy.int16)
    pilarr = pilarr.astype(numpy.int16)
    diff = numpy.absolute(fiarr - pilarr)

    toimage(diff).convert("L").save(dest)
Esempio n. 8
0
def loadImage(imageName):
    im = pil_open(imageName)
    try:
        ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBA", 0, -1)
    except SystemError:
        ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBX", 0, -1)
    ID = glGenTextures(1)
    glBindTexture(GL_TEXTURE_2D, ID)
    glPixelStorei(GL_UNPACK_ALIGNMENT,4)
    glTexImage2D(
        GL_TEXTURE_2D, 0, GL_RGBA, ix, iy, 0, GL_RGBA, GL_UNSIGNED_BYTE, image
    )
    return ID
Esempio n. 9
0
    def test_toBuffer_PIL(self):
        try:
            from PIL.Image import open as pil_open
        except ImportError:
            return
        imgbuf = self.img.toBuffer()
        pilimg = pil_open(imgbuf)
        self.assertEqual(pilimg.format, 'JPEG')
        self.assertEqual(pilimg.size, self.img.size)
        del pilimg

        pilimg = self.img.toPIL(format=fi.FIF_PNG)
        self.assertEqual(pilimg.format, 'PNG')
        del pilimg
Esempio n. 10
0
def _save_with_exif_and_return_PIL_image(mat, orientation_value):
    i = Image.new('L', (len(mat[0]), len(mat)))
    i.putdata(list(chain(*mat)))
    exif = {'0th': {piexif.ImageIFD.Orientation: orientation_value}}
    with io.BytesIO() as b:
        i.save(b,
               format='jpeg',
               exif=piexif.dump(exif),
               quality=100,
               subsampling=0)
        b.seek(0)
        i = pil_open(b)
        i.load()
    i.putdata(list(chain(*mat)))
    return i
Esempio n. 11
0
def _validate_image(image_path):
    """
    Check file existence, image is correct PNG,
        dimension is 512x? or ?x512 and file size < 350KB
    
    :param image_path: The image for a sticker
    :return: Boolean if all limits on stickers met
    """
    try:
        with pil_open(image_path) as image:
            criteria = [
                max(image.size) == 512, image.format == 'PNG',
                image_path.stat().st_size < 350 * 1000
            ]
            return True if all(criteria) else False
    except IOError:
        print(ERROR_INVAILD_STICKER_IMAGE % image_path.name)
        return False  # invalid image or just 404
Esempio n. 12
0
def load_image(file_name,texture_id):
    im = pil_open(file_name)
    try:
        width,height,image = im.size[0], im.size[1], im.tobytes("raw", "RGBX", 0, -1)
    except SystemError:
        width,height,image = im.size[0], im.size[1], im.tobytes("raw", "RGBX", 0, -1)

    
    # To use OpenGL 4.2 ARB_texture_storage to automatically generate a single mipmap layer
    # uncomment the 3 lines below.  Note that this should replaced glTexImage2D below.
    #bind_texture(texture_id,'DEFAULT')
    #glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, width, height);
    #glTexSubImage2D(GL_TEXTURE_2D,0,0,0,width,height,GL_RGBA,GL_UNSIGNED_BYTE,image)

    # "Bind" the newly created texture : all future texture functions will modify this texture
    bind_texture(texture_id,'MIN_FILTER')
    glTexImage2D(
           GL_TEXTURE_2D, 0, 3, width, height, 0,
           GL_RGBA, GL_UNSIGNED_BYTE, image
       )
    return texture_id
Esempio n. 13
0
def load_image(file_name):
    im = pil_open(file_name)
    try:
        width,height,image = im.size[0], im.size[1], im.tostring("raw", "RGBA", 0, -1)
    except SystemError:
        width,height,image = im.size[0], im.size[1], im.tostring("raw", "RGBX", 0, -1)

    texture_id =  glGenTextures(1)

    # To use OpenGL 4.2 ARB_texture_storage to automatically generate a single mipmap layer
    # uncomment the 3 lines below.  Note that this should replaced glTexImage2D below.
    #bind_texture(texture_id,'DEFAULT')
    #glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, width, height);
    #glTexSubImage2D(GL_TEXTURE_2D,0,0,0,width,height,GL_RGBA,GL_UNSIGNED_BYTE,image)
    
    # "Bind" the newly created texture : all future texture functions will modify this texture
    bind_texture(texture_id,'MIN_FILTER')
    glTexImage2D(
           GL_TEXTURE_2D, 0, 3, width, height, 0,
           GL_RGBA, GL_UNSIGNED_BYTE, image
       )
    return texture_id
Esempio n. 14
0
def update_exif_for_rotated_image(exif):
    """Modifies the Exif tag if rotation has been performed.

    0th, 1st
    --------
    ImageWidth = 256
    ImageLength = 257
    XResolution = 282
    YResolution = 283
    TileWidth = 322
    TileLength = 323

    Exif
    ----
    PixelXDimension = 40962
    PixelYDimension = 40963

    Args:
        exif (dict): The parsed Exif tag

    Returns:
        The modified Exif dict.

    """
    orientation_value = exif.get('0th', ).get(
        piexif.ImageIFD.Orientation, exif.get('1st', ).get(
            piexif.ImageIFD.Orientation, None))

    if orientation_value is not None:
        # Update orientation.
        exif['0th'][piexif.ImageIFD.Orientation] = 1
        if exif.get('1st', {}).get(piexif.ImageIFD.Orientation) is not None:
            exif['1st'][piexif.ImageIFD.Orientation] = 1

        # If 90 or 270 degree rotation, x dimensions are now y dimensions,
        # so flip all such properties.
        if orientation_value > 4:
            for exif_tag in ['0th', '1st']:
                if exif.get(exif_tag) is not None:
                    x, y = (exif.get(exif_tag).get(piexif.ImageIFD.ImageWidth),
                            exif.get(exif_tag).get(piexif.ImageIFD.ImageLength))
                    if x is not None and y is not None:
                        exif[exif_tag][piexif.ImageIFD.ImageWidth] = y
                        exif[exif_tag][piexif.ImageIFD.ImageLength] = x

                    x, y = (exif.get(exif_tag).get(piexif.ImageIFD.XResolution),
                            exif.get(exif_tag).get(piexif.ImageIFD.YResolution))
                    if x is not None and y is not None:
                        exif[exif_tag][piexif.ImageIFD.XResolution] = y
                        exif[exif_tag][piexif.ImageIFD.YResolution] = x

                    x, y = (exif.get(exif_tag).get(piexif.ImageIFD.TileWidth),
                            exif.get(exif_tag).get(piexif.ImageIFD.TileLength))
                    if x is not None and y is not None:
                        exif[exif_tag][piexif.ImageIFD.TileWidth] = y
                        exif[exif_tag][piexif.ImageIFD.TileLength] = x
            if exif.get('Exif') is not None:
                x, y = (exif.get('Exif').get(piexif.ExifIFD.PixelXDimension),
                        exif.get('Exif').get(piexif.ExifIFD.PixelYDimension))
                if x is not None and y is not None:
                    exif['Exif'][piexif.ExifIFD.PixelXDimension] = y
                    exif['Exif'][piexif.ExifIFD.PixelYDimension] = x
        if exif.get('thumbnail') is not None:
            try:
                thumbnail = pil_open(io.BytesIO(exif.get('thumbnail')))
                thumbnail = autorotate(thumbnail, orientation=orientation_value)
                with io.BytesIO() as bio:
                    thumbnail.save(bio, format='jpeg')
                    bio.seek(0)
                    exif['thumbnail'] = bio.read()
            except Exception as e:
                warnings.warn("deprecated", DeprecationWarning)

    return exif
Esempio n. 15
0
from io import BytesIO
from os import environ

# Package in current directory
from tensorflow.lite.python.interpreter import Interpreter

INTERPRETER = Interpreter(model_path='../model.tflite')
INTERPRETER.allocate_tensors()

INPUT_DETAILS  = INTERPRETER.get_input_details()
OUTPUT_DETAILS = INTERPRETER.get_output_details()

with open("../example.png", "rb") as image_file:
    encoded_string = b64encode(image_file.read())

image_binary = pil_open(BytesIO(b64decode(encoded_string)))
image_binary = image_binary.resize([96, 96])

full_image_np = asarray(image_binary, dtype='float32')/255.
arr = []

BATCH_SIZE = 1

arr = []
for i in range(BATCH_SIZE):
    arr.append(full_image_np)

full_image_np = asarray(arr, dtype='float32')

start_time = int(round(time.time() * 1000))
for i in range(16384//BATCH_SIZE):
Esempio n. 16
0
def basic_output():
    set_env(title="PyWebIO Test")
    set_scope('top')

    put_markdown('### Basic')
    for i in range(3):
        put_text('text_%s' % i)

    put_text('测试空格:20空格:[%s]结束' % (' ' * 20))

    for i in range(3):
        put_text('inline_text_%s' % i, inline=True)

    put_markdown("""### put_markdown 测试
    `行内代码`

    无序列表:
    - 北京
    - 上海
    - 天津

    有序列表:
    1. 北京
    2. 上海
    3. 天津

    [链接](./#)
    ~~删除线~~
    """,
                 lstrip=True)

    put_link('链接', '#')

    put_text('<hr/>:')
    put_html("<hr/>")

    put_markdown('### Style')
    style(put_text('Red'), 'color:red')

    style([put_text('Red'), put_markdown('~~del~~')], 'color:red')

    put_table([
        ['A', 'B'],
        ['C', style(put_text('Red'), 'color:red')],
    ])

    put_collapse('title',
                 style([
                     put_text('text'),
                     put_markdown('~~del~~'),
                 ], 'margin-left:20px'),
                 open=True)

    put_markdown('### Table')
    put_table([
        ['Name', 'Gender', 'Address'],
        ['Wang', 'M', 'China'],
        ['Liu', 'W', 'America'],
    ])

    put_table([
        ['Wang', 'M', 'China'],
        ['Liu', 'W', 'America'],
    ],
              header=['Name', 'Gender', 'Address'])

    put_table([
        {
            "Course": "OS",
            "Score": "80"
        },
        {
            "Course": "DB",
            "Score": "93"
        },
    ],
              header=["Course", "Score"])

    put_table([
        {
            "Course": "OS",
            "Score": "80"
        },
        {
            "Course": "DB",
            "Score": "93"
        },
    ],
              header=[("课程", "Course"), ("得分", "Score")])

    img_data = open(path.join(here_dir, 'assets', 'img.png'), 'rb').read()
    put_table(
        [['Type', 'Content'], ['text', '<hr/>'],
         ['html', put_html('X<sup>2</sup>')],
         ['buttons',
          put_buttons(['A', 'B'], onclick=None, small=True)],
         ['markdown',
          put_markdown('`awesome PyWebIO!`\n - 1\n - 2\n - 3')],
         ['file', put_file('hello.text', b'')], ['image',
                                                 put_image(img_data)],
         [
             'table',
             put_table([['A', 'B'], [put_markdown('`C`'),
                                     put_markdown('`D`')]])
         ]])

    put_markdown('### Code')
    with use_scope('scroll_basis'):
        put_code(
            json.dumps(dict(name='pywebio', author='wangweimin'), indent=4),
            'json')

    put_text('move ⬆ code block to screen ... :')
    with use_scope('scroll_basis_btns'):
        put_buttons(buttons=[
            ('BOTTOM', Position.BOTTOM),
            ('TOP', Position.TOP),
            ('MIDDLE', Position.MIDDLE),
        ],
                    onclick=lambda pos: scroll_to('scroll_basis', pos))

    def show_popup():
        popup('Popup title', [
            put_html('<h3>Popup Content</h3>'), 'html: <br/>',
            put_table(
                [['Type', 'Content'],
                 ['html', put_html('X<sup>2</sup>')], ['text', '<hr/>'],
                 ['buttons', put_buttons(['A', 'B'], onclick=...)],
                 ['markdown', put_markdown('`Awesome PyWebIO!`')],
                 ['file', put_file('hello.text', b'')],
                 ['table', put_table([['A', 'B'], ['C', 'D']])]]),
            put_buttons(['close_popup()'], onclick=lambda _: close_popup())
        ],
              size=PopupSize.NORMAL)

    with use_scope('popup_btn'):
        put_buttons([('popup()', '')], onclick=[show_popup])

    def edit_row(choice, row):
        put_text("You click %s button at row %s" % (choice, row),
                 scope='table_cell_buttons')

    with use_scope('table_cell_buttons'):
        put_table([
            ['Idx', 'Actions'],
            [
                '1',
                put_buttons(['edit', 'delete'],
                            onclick=partial(edit_row, row=1))
            ],
            [
                '2',
                put_buttons(['edit', 'delete'],
                            onclick=partial(edit_row, row=2))
            ],
            [
                '3',
                put_buttons(['edit', 'delete'],
                            onclick=partial(edit_row, row=3))
            ],
        ])

    with use_scope('put_buttons'):
        put_buttons(['A', 'B', 'C'],
                    onclick=partial(put_text, scope='put_buttons'))

    put_markdown('### Image')
    put_image(img_data)
    from PIL.Image import open as pil_open
    pil_img = pil_open(path.join(here_dir, 'assets', 'img.png'))
    put_image(pil_img, width="30px")
    put_image(
        'https://cdn.jsdelivr.net/gh/wang0618/pywebio/test/assets/img.png',
        height="50px")

    put_file('hello_word.txt', b'hello word!')

    put_collapse('Collapse', [
        'text',
        put_markdown('~~删除线~~'),
        put_table([
            ['商品', '价格'],
            ['苹果', '5.5'],
            ['香蕉', '7'],
        ])
    ],
                 open=True)
    put_collapse('title', 'something', open=True)

    put_scrollable('scrollable\n' * 20, height=50, keep_bottom=True)

    put_markdown('### Scope')
    with use_scope('scope1'):
        put_text("to be cleared")
        clear()
        put_text('A')  # 输出内容: A
        put_text('B', position=0)  # 输出内容: B A
        put_text('C', position=-2)  # 输出内容: B C A
        with use_scope('scope2'):
            put_text('scope2')
            put_text('scope2')
        put_text('D', position=1)  # 输出内容: B D C A

    put_text('before=top again', scope='top')

    with use_scope('to_remove'):
        put_text('to remove')
    remove('to_remove')

    put_markdown('### Info')
    session_info = get_info()
    from django.http import HttpRequest
    from flask import Request
    from tornado.httputil import HTTPServerRequest
    from aiohttp.web import BaseRequest
    request_type = {
        'tornado': HTTPServerRequest,
        'flask': Request,
        'django': HttpRequest,
        'aiohttp': BaseRequest,
    }
    request_ok = isinstance(session_info.request,
                            request_type.get(session_info.backend))
    if not request_ok:
        print(
            'Error: request check error: backend %s, request type %s, class %s'
            % (session_info.backend, type(
                session_info.request).__name__, session_info.request))
    put_markdown(rf"""### 会话信息
    ```
    * `user_agent`:
        * `is_mobile` (bool): {session_info.user_agent.is_mobile}
        * `is_tablet` (bool): {session_info.user_agent.is_tablet}
        * `is_pc` (bool): {session_info.user_agent.is_pc}
        * `is_touch_capable` (bool): {session_info.user_agent.is_touch_capable}

        * `browser.family` (str): {session_info.user_agent.browser.family}

        * `os.family` (str): {session_info.user_agent.os.family}
        * `os.version` (tuple): {session_info.user_agent.os.version}
        * `os.version_string` (str): {session_info.user_agent.os.version_string}

        * `device.family` (str): {session_info.user_agent.device.family}
        * `device.brand` (str): {session_info.user_agent.device.brand}
        * `device.model` (str): {session_info.user_agent.device.model}
    * `user_language` (str): {session_info.user_language}
    * `server_host` (str): {session_info.server_host}
    * `origin` (str): {session_info.origin or 'http://' + session_info.server_host}
    * `user_ip` (str): {session_info.user_ip}
    * `request type check` (str): {request_ok}
    ```
    """,
                 strip_indent=4)

    put_markdown('### Layout')
    put_row([
        put_column([
            put_code('A'),
            put_row([
                put_code('B1'),
                None,
                put_code('B2'),
                None,
                put_code('B3'),
            ]),
            put_code('C'),
        ]),
        None,
        put_code('python'),
        None,
        style(put_code('python\n' * 20), 'max-height:200px;'),
    ])

    put_grid([[
        style(put_code('[%s,%s]' % (x, y)), 'margin-right:10px;')
        for y in range(4)
    ] for x in range(5)],
             direction='column')

    put_row([style(put_code(i), 'margin-right:10px;') for i in range(4)],
            'repeat(auto-fill, 25%)')

    put_markdown('### Span')
    cell = lambda text: style(put_code(text), 'margin-right:10px;')
    put_grid([
        [span(cell('A'), col=2), None],
        [span(cell('C'), row=2, col=2),
         span(cell('D'), row=2)],
        [],
    ],
             cell_width='1fr',
             cell_height='1fr')

    put_table([
        ['C'],
        [span('E', col=2)],
    ], header=[span('A', row=2), 'B'])

    put_processbar('processbar', 0.3)

    set_processbar('processbar', 0.6)

    put_loading()

    # output
    hobby = output(put_text('Coding'))
    put_table([['Name', 'Hobbies'], ['Wang', hobby]])

    hobby.reset(put_text('Movie'))
    hobby.append(put_text('Music'), put_text('Drama'))
    hobby.insert(0, put_markdown('**Coding**'))
Esempio n. 17
0
    for i in xrange(RW_COUNT):
        tiff = Image(TIFF)
        arr = asarray(tiff)
        arr = arr[..., ::-1]
        bytescale(arr, 64, 192)
    end = time() - start
    print " - tiff load + numpy.asarray() with bytescale() %0.3f sec" % end

# -------------------------------------------------------------------
# PIL load
hdr = "PIL %s (with standard libjpeg)" % PIL_VERSION
print "\n%s\n%s" % (hdr, "-" * len(hdr))

start = time()
for i in xrange(RW_COUNT):
    pil_open(IMG).load()
end = time() - start
print " - read JPEG %0.3f sec" % end

# load resaved
pil_open(IMG).save("pon_rewrite_pil.jpg")
start = time()
for i in xrange(RW_COUNT):
    pil_open("pon_rewrite_pil.jpg").load()
end = time() - start
print " - read JPEG %0.3f sec (resaved)" % end

# write
img = pil_open(IMG)
img.load()
start = time()
Esempio n. 18
0
    for i in xrange(RW_COUNT):
        tiff = Image(TIFF)
        arr = asarray(tiff)
        arr = arr[..., ::-1]
        bytescale(arr, 64, 192)
    end = time() - start
    print " - tiff load + numpy.asarray() with bytescale() %0.3f sec" % end

# -------------------------------------------------------------------
# PIL load
hdr = "PIL %s (with standard libjpeg)" % PIL_VERSION
print "\n%s\n%s" % (hdr, "-" * len(hdr))

start = time()
for i in xrange(RW_COUNT):
    pil_open(IMG).load()
end = time() - start
print " - read JPEG %0.3f sec" % end

# load resaved
pil_open(IMG).save("pon_rewrite_pil.jpg")
start = time()
for i in xrange(RW_COUNT):
    pil_open("pon_rewrite_pil.jpg").load()
end = time() - start
print " - read JPEG %0.3f sec (resaved)" % end

# write
img = pil_open(IMG)
img.load()
start = time()
Esempio n. 19
0
def pil(src=IMG, dst=OUT, pil_open=pil_open):
    img = pil_open(src)
    for w, h in ((128, 182), (300, 427), (500, 712), (700, 997), (900, 1281)):
        new = img.resize((w, h), ANTIALIAS)
        new.save(dst)
Esempio n. 20
0
def test_open():
    img = Image.open(img_path).as_pil()
    pil_img = pil_open(img_path)

    assert pil_equals(img, pil_img)