pil - python show image

Obtener tamaño de imagen SIN cargar imagen en la memoria

Question

Entiendo que puede obtener el tamaño de la imagen usando PIL de la siguiente manera

from PIL import Image
im = Image.open(image_filename)
width, height = im.size

Sin embargo, me gustaría obtener el ancho y alto de la imagen sin tener que cargar la imagen en la memoria. ¿Es eso posible? Solo estoy haciendo estadísticas sobre el tamaño de las imágenes y no me importan los contenidos de la imagen. Solo quiero hacer que mi procesamiento sea más rápido.

Answer 1

A menudo obtengo tamaños de imagen en Internet. Por supuesto, no puede descargar la imagen y luego cargarla para analizar la información. Es demasiado lento. Mi método es alimentar trozos a un contenedor de imágenes y probar si puede analizar la imagen cada vez. Detener el ciclo cuando obtengo la información que quiero.

Extraje el núcleo de mi código y lo modifiqué para analizar los archivos locales.

from PIL import ImageFile

ImPar=ImageFile.Parser()
with open(r"D:/testpic/test.jpg", "rb") as f:
    ImPar=ImageFile.Parser()
    chunk = f.read(2048)
    count=2048
    while chunk != "":
        ImPar.feed(chunk)
        if ImPar.image:
            break
        chunk = f.read(2048)
        count+=2048
    print(ImPar.image.size)
    print(count)

Salida:

(2240, 1488)
38912

El tamaño real del archivo es de 1.543.580 bytes y solo lee 38.912 bytes para obtener el tamaño de la imagen. Espero que esto ayude

Answer 2

Como los comentarios aluden, PIL no carga la imagen en la memoria al llamar a .open . Mirando los documentos de PIL 1.1.7 , el docstring para .open dice:

def open(fp, mode="r"):
    "Open an image file, without loading the raster data"

Hay algunas operaciones de archivo en la fuente como:

 ...
 prefix = fp.read(16)
 ...
 fp.seek(0)
 ...

pero estos difícilmente constituyen la lectura de todo el archivo. De hecho, .open simplemente devuelve un objeto de archivo y el nombre de archivo en caso de éxito. Además, los docs dicen:

abrir (archivo, modo = "r")

Abre e identifica el archivo de imagen dado.

Esta es una operación floja; esta función identifica el archivo, pero los datos de la imagen real no se leen desde el archivo hasta que intente procesar los datos (o llame al método de carga ).

Profundizando más, vemos que .open llamadas _open que es una sobrecarga específica de formato de imagen. Cada una de las implementaciones de _open se puede encontrar en un archivo nuevo, por ej. Los archivos .jpeg están en JpegImagePlugin.py . Veamos eso en profundidad.

Aquí las cosas parecen ser un poco complicadas, hay un bucle infinito que se rompe cuando se encuentra el marcador jpeg:

    while True:

        s = s + self.fp.read(1)
        i = i16(s)

        if i in MARKER:
            name, description, handler = MARKER[i]
            # print hex(i), name, description
            if handler is not None:
                handler(self, i)
            if i == 0xFFDA: # start of scan
                rawmode = self.mode
                if self.mode == "CMYK":
                    rawmode = "CMYK;I" # assume adobe conventions
                self.tile = [("jpeg", (0,0) + self.size, 0, (rawmode, ""))]
                # self.__offset = self.fp.tell()
                break
            s = self.fp.read(1)
        elif i == 0 or i == 65535:
            # padded marker or junk; move on
            s = "/xff"
        else:
            raise SyntaxError("no marker found")

Que parece que podría leer todo el archivo si estaba mal formado. Si lee el marcador de información OK, sin embargo, debería aparecer temprano. El handler funciones finalmente configura self.size que son las dimensiones de la imagen.

Answer 3

Esta answer tiene otra buena resolución, pero falta el formato pgm . Esta answer ha resuelto el pgm . Y agrego el bmp .

Códigos está debajo

import struct, imghdr, re, magic

def get_image_size(fname):
    ''''''Determine the image type of fhandle and return its size.
    from draco''''''
    with open(fname, ''rb'') as fhandle:
        head = fhandle.read(32)
        if len(head) != 32:
            return
        if imghdr.what(fname) == ''png'':
            check = struct.unpack(''>i'', head[4:8])[0]
            if check != 0x0d0a1a0a:
                return
            width, height = struct.unpack(''>ii'', head[16:24])
        elif imghdr.what(fname) == ''gif'':
            width, height = struct.unpack(''<HH'', head[6:10])
        elif imghdr.what(fname) == ''jpeg'':
            try:
                fhandle.seek(0) # Read 0xff next
                size = 2
                ftype = 0
                while not 0xc0 <= ftype <= 0xcf:
                    fhandle.seek(size, 1)
                    byte = fhandle.read(1)
                    while ord(byte) == 0xff:
                        byte = fhandle.read(1)
                    ftype = ord(byte)
                    size = struct.unpack(''>H'', fhandle.read(2))[0] - 2
                # We are at a SOFn block
                fhandle.seek(1, 1)  # Skip `precision'' byte.
                height, width = struct.unpack(''>HH'', fhandle.read(4))
            except Exception: #IGNORE:W0703
                return
        elif imghdr.what(fname) == ''pgm'':
            header, width, height, maxval = re.search(
                b"(^P5/s(?:/s*#.*[/r/n])*"
                b"(/d+)/s(?:/s*#.*[/r/n])*"
                b"(/d+)/s(?:/s*#.*[/r/n])*"
                b"(/d+)/s(?:/s*#.*[/r/n]/s)*)", head).groups()
            width = int(width)
            height = int(height)
        elif imghdr.what(fname) == ''bmp'':
            _, width, height, depth = re.search(
                b"((/d+)/sx/s"
                b"(/d+)/sx/s"
                b"(/d+))", str).groups()
            width = int(width)
            height = int(height)
        else:
            return
        return width, height

Answer 4

Otra forma corta de hacerlo en sistemas Unix. Depende de la salida del file que no estoy seguro de que esté estandarizado en todos los sistemas. Esto probablemente no debería usarse en el código de producción. Además, la mayoría de los archivos JPEG no informan el tamaño de la imagen.

import subprocess, re
image_size = list(map(int, re.findall(''(/d+)x(/d+)'', subprocess.getoutput("file " + filename))[-1]))

Answer 5

Si no te importa el contenido de la imagen, es probable que PIL sea una exageración.

Sugiero analizar el resultado del módulo de magia python:

>>> t = magic.from_file(''teste.png'')
>>> t
''PNG image data, 782 x 602, 8-bit/color RGBA, non-interlaced''
>>> re.search(''(/d+) x (/d+)'', t).groups()
(''782'', ''602'')

Este es un contenedor de libmagic que lee el menor número posible de bytes para identificar una firma de tipo de archivo.

[actualizar]

Hmmm, desafortunadamente, cuando se aplica a jpegs, lo anterior da "''datos de imagen JPEG, estándar EXIF ​​2.21'' ''''. ¡Sin tamaño de imagen! - Alex Flint

Parece que los jpegs son resistentes a la magia. :-)

Puedo ver por qué: para obtener las dimensiones de la imagen para los archivos JPEG, es posible que tenga que leer más bytes que los que le gustan a libmagic para leer.

Me subí las mangas y llegué con este fragmento no probado (lo obtuve de GitHub) que no requiere módulos de terceros.

#-------------------------------------------------------------------------------
# Name:        get_image_size
# Purpose:     extract image dimensions given a file path using just
#              core modules
#
# Author:      Paulo Scardine (based on code from Emmanuel VAÏSSE)
#
# Created:     26/09/2013
# Copyright:   (c) Paulo Scardine 2013
# Licence:     MIT
#-------------------------------------------------------------------------------
#!/usr/bin/env python
import os
import struct

class UnknownImageFormat(Exception):
    pass

def get_image_size(file_path):
    """
    Return (width, height) for a given img file content - no external
    dependencies except the os and struct modules from core
    """
    size = os.path.getsize(file_path)

    with open(file_path) as input:
        height = -1
        width = -1
        data = input.read(25)

        if (size >= 10) and data[:6] in (''GIF87a'', ''GIF89a''):
            # GIFs
            w, h = struct.unpack("<HH", data[6:10])
            width = int(w)
            height = int(h)
        elif ((size >= 24) and data.startswith(''/211PNG/r/n/032/n'')
              and (data[12:16] == ''IHDR'')):
            # PNGs
            w, h = struct.unpack(">LL", data[16:24])
            width = int(w)
            height = int(h)
        elif (size >= 16) and data.startswith(''/211PNG/r/n/032/n''):
            # older PNGs?
            w, h = struct.unpack(">LL", data[8:16])
            width = int(w)
            height = int(h)
        elif (size >= 2) and data.startswith(''/377/330''):
            # JPEG
            msg = " raised while trying to decode as JPEG."
            input.seek(0)
            input.read(2)
            b = input.read(1)
            try:
                while (b and ord(b) != 0xDA):
                    while (ord(b) != 0xFF): b = input.read(1)
                    while (ord(b) == 0xFF): b = input.read(1)
                    if (ord(b) >= 0xC0 and ord(b) <= 0xC3):
                        input.read(3)
                        h, w = struct.unpack(">HH", input.read(4))
                        break
                    else:
                        input.read(int(struct.unpack(">H", input.read(2))[0])-2)
                    b = input.read(1)
                width = int(w)
                height = int(h)
            except struct.error:
                raise UnknownImageFormat("StructError" + msg)
            except ValueError:
                raise UnknownImageFormat("ValueError" + msg)
            except Exception as e:
                raise UnknownImageFormat(e.__class__.__name__ + msg)
        else:
            raise UnknownImageFormat(
                "Sorry, don''t know how to get information from this file."
            )

    return width, height