1332 lines
51 KiB
Python
1332 lines
51 KiB
Python
# -*- coding: utf-8 -*-
|
|
# imageio is distributed under the terms of the (new) BSD License.
|
|
|
|
# styletest: ignore E261
|
|
|
|
""" Module imageio/freeimage.py
|
|
|
|
This module contains the wrapper code for the freeimage library.
|
|
The functions defined in this module are relatively thin; just thin
|
|
enough so that arguments and results are native Python/numpy data
|
|
types.
|
|
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import ctypes
|
|
import threading
|
|
import logging
|
|
import numpy
|
|
|
|
from ..core import (
|
|
get_remote_file,
|
|
load_lib,
|
|
Dict,
|
|
resource_dirs,
|
|
IS_PYPY,
|
|
get_platform,
|
|
InternetNotAllowedError,
|
|
NeedDownloadError,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
TEST_NUMPY_NO_STRIDES = False # To test pypy fallback
|
|
|
|
FNAME_PER_PLATFORM = {
|
|
"osx32": "libfreeimage-3.16.0-osx10.6.dylib", # universal library
|
|
"osx64": "libfreeimage-3.16.0-osx10.6.dylib",
|
|
"win32": "FreeImage-3.15.4-win32.dll",
|
|
"win64": "FreeImage-3.15.1-win64.dll",
|
|
"linux32": "libfreeimage-3.16.0-linux32.so",
|
|
"linux64": "libfreeimage-3.16.0-linux64.so",
|
|
}
|
|
|
|
|
|
def download(directory=None, force_download=False):
|
|
""" Download the FreeImage library to your computer.
|
|
|
|
Parameters
|
|
----------
|
|
directory : str | None
|
|
The directory where the file will be cached if a download was
|
|
required to obtain the file. By default, the appdata directory
|
|
is used. This is also the first directory that is checked for
|
|
a local version of the file.
|
|
force_download : bool | str
|
|
If True, the file will be downloaded even if a local copy exists
|
|
(and this copy will be overwritten). Can also be a YYYY-MM-DD date
|
|
to ensure a file is up-to-date (modified date of a file on disk,
|
|
if present, is checked).
|
|
"""
|
|
plat = get_platform()
|
|
if plat and plat in FNAME_PER_PLATFORM:
|
|
fname = "freeimage/" + FNAME_PER_PLATFORM[plat]
|
|
get_remote_file(fname=fname, directory=directory, force_download=force_download)
|
|
fi._lib = None # allow trying again (needed to make tests work)
|
|
|
|
|
|
def get_freeimage_lib():
|
|
""" Ensure we have our version of the binary freeimage lib.
|
|
"""
|
|
|
|
lib = os.getenv("IMAGEIO_FREEIMAGE_LIB", None)
|
|
if lib: # pragma: no cover
|
|
return lib
|
|
|
|
# Get filename to load
|
|
# If we do not provide a binary, the system may still do ...
|
|
plat = get_platform()
|
|
if plat and plat in FNAME_PER_PLATFORM:
|
|
try:
|
|
return get_remote_file("freeimage/" + FNAME_PER_PLATFORM[plat], auto=False)
|
|
except InternetNotAllowedError:
|
|
pass
|
|
except NeedDownloadError:
|
|
raise NeedDownloadError(
|
|
"Need FreeImage library. "
|
|
"You can obtain it with either:\n"
|
|
" - download using the command: "
|
|
"imageio_download_bin freeimage\n"
|
|
" - download by calling (in Python): "
|
|
"imageio.plugins.freeimage.download()\n"
|
|
)
|
|
except RuntimeError as e: # pragma: no cover
|
|
logger.warning(str(e))
|
|
|
|
|
|
# Define function to encode a filename to bytes (for the current system)
|
|
efn = lambda x: x.encode(sys.getfilesystemencoding())
|
|
|
|
# 4-byte quads of 0,v,v,v from 0,0,0,0 to 0,255,255,255
|
|
GREY_PALETTE = numpy.arange(0, 0x01000000, 0x00010101, dtype=numpy.uint32)
|
|
|
|
|
|
class FI_TYPES(object):
|
|
FIT_UNKNOWN = 0
|
|
FIT_BITMAP = 1
|
|
FIT_UINT16 = 2
|
|
FIT_INT16 = 3
|
|
FIT_UINT32 = 4
|
|
FIT_INT32 = 5
|
|
FIT_FLOAT = 6
|
|
FIT_DOUBLE = 7
|
|
FIT_COMPLEX = 8
|
|
FIT_RGB16 = 9
|
|
FIT_RGBA16 = 10
|
|
FIT_RGBF = 11
|
|
FIT_RGBAF = 12
|
|
|
|
dtypes = {
|
|
FIT_BITMAP: numpy.uint8,
|
|
FIT_UINT16: numpy.uint16,
|
|
FIT_INT16: numpy.int16,
|
|
FIT_UINT32: numpy.uint32,
|
|
FIT_INT32: numpy.int32,
|
|
FIT_FLOAT: numpy.float32,
|
|
FIT_DOUBLE: numpy.float64,
|
|
FIT_COMPLEX: numpy.complex128,
|
|
FIT_RGB16: numpy.uint16,
|
|
FIT_RGBA16: numpy.uint16,
|
|
FIT_RGBF: numpy.float32,
|
|
FIT_RGBAF: numpy.float32,
|
|
}
|
|
|
|
fi_types = {
|
|
(numpy.uint8, 1): FIT_BITMAP,
|
|
(numpy.uint8, 3): FIT_BITMAP,
|
|
(numpy.uint8, 4): FIT_BITMAP,
|
|
(numpy.uint16, 1): FIT_UINT16,
|
|
(numpy.int16, 1): FIT_INT16,
|
|
(numpy.uint32, 1): FIT_UINT32,
|
|
(numpy.int32, 1): FIT_INT32,
|
|
(numpy.float32, 1): FIT_FLOAT,
|
|
(numpy.float64, 1): FIT_DOUBLE,
|
|
(numpy.complex128, 1): FIT_COMPLEX,
|
|
(numpy.uint16, 3): FIT_RGB16,
|
|
(numpy.uint16, 4): FIT_RGBA16,
|
|
(numpy.float32, 3): FIT_RGBF,
|
|
(numpy.float32, 4): FIT_RGBAF,
|
|
}
|
|
|
|
extra_dims = {
|
|
FIT_UINT16: [],
|
|
FIT_INT16: [],
|
|
FIT_UINT32: [],
|
|
FIT_INT32: [],
|
|
FIT_FLOAT: [],
|
|
FIT_DOUBLE: [],
|
|
FIT_COMPLEX: [],
|
|
FIT_RGB16: [3],
|
|
FIT_RGBA16: [4],
|
|
FIT_RGBF: [3],
|
|
FIT_RGBAF: [4],
|
|
}
|
|
|
|
|
|
class IO_FLAGS(object):
|
|
FIF_LOAD_NOPIXELS = 0x8000 # loading: load the image header only
|
|
# # (not supported by all plugins)
|
|
BMP_DEFAULT = 0
|
|
BMP_SAVE_RLE = 1
|
|
CUT_DEFAULT = 0
|
|
DDS_DEFAULT = 0
|
|
EXR_DEFAULT = 0 # save data as half with piz-based wavelet compression
|
|
EXR_FLOAT = 0x0001 # save data as float instead of half (not recommended)
|
|
EXR_NONE = 0x0002 # save with no compression
|
|
EXR_ZIP = 0x0004 # save with zlib compression, in blocks of 16 scan lines
|
|
EXR_PIZ = 0x0008 # save with piz-based wavelet compression
|
|
EXR_PXR24 = 0x0010 # save with lossy 24-bit float compression
|
|
EXR_B44 = 0x0020 # save with lossy 44% float compression
|
|
# # - goes to 22% when combined with EXR_LC
|
|
EXR_LC = 0x0040 # save images with one luminance and two chroma channels,
|
|
# # rather than as RGB (lossy compression)
|
|
FAXG3_DEFAULT = 0
|
|
GIF_DEFAULT = 0
|
|
GIF_LOAD256 = 1 # Load the image as a 256 color image with ununsed
|
|
# # palette entries, if it's 16 or 2 color
|
|
GIF_PLAYBACK = 2 # 'Play' the GIF to generate each frame (as 32bpp)
|
|
# # instead of returning raw frame data when loading
|
|
HDR_DEFAULT = 0
|
|
ICO_DEFAULT = 0
|
|
ICO_MAKEALPHA = 1 # convert to 32bpp and create an alpha channel from the
|
|
# # AND-mask when loading
|
|
IFF_DEFAULT = 0
|
|
J2K_DEFAULT = 0 # save with a 16:1 rate
|
|
JP2_DEFAULT = 0 # save with a 16:1 rate
|
|
JPEG_DEFAULT = 0 # loading (see JPEG_FAST);
|
|
# # saving (see JPEG_QUALITYGOOD|JPEG_SUBSAMPLING_420)
|
|
JPEG_FAST = 0x0001 # load the file as fast as possible,
|
|
# # sacrificing some quality
|
|
JPEG_ACCURATE = 0x0002 # load the file with the best quality,
|
|
# # sacrificing some speed
|
|
JPEG_CMYK = 0x0004 # load separated CMYK "as is"
|
|
# # (use | to combine with other load flags)
|
|
JPEG_EXIFROTATE = 0x0008 # load and rotate according to
|
|
# # Exif 'Orientation' tag if available
|
|
JPEG_QUALITYSUPERB = 0x80 # save with superb quality (100:1)
|
|
JPEG_QUALITYGOOD = 0x0100 # save with good quality (75:1)
|
|
JPEG_QUALITYNORMAL = 0x0200 # save with normal quality (50:1)
|
|
JPEG_QUALITYAVERAGE = 0x0400 # save with average quality (25:1)
|
|
JPEG_QUALITYBAD = 0x0800 # save with bad quality (10:1)
|
|
JPEG_PROGRESSIVE = 0x2000 # save as a progressive-JPEG
|
|
# # (use | to combine with other save flags)
|
|
JPEG_SUBSAMPLING_411 = 0x1000 # save with high 4x1 chroma
|
|
# # subsampling (4:1:1)
|
|
JPEG_SUBSAMPLING_420 = 0x4000 # save with medium 2x2 medium chroma
|
|
# # subsampling (4:2:0) - default value
|
|
JPEG_SUBSAMPLING_422 = 0x8000 # save /w low 2x1 chroma subsampling (4:2:2)
|
|
JPEG_SUBSAMPLING_444 = 0x10000 # save with no chroma subsampling (4:4:4)
|
|
JPEG_OPTIMIZE = 0x20000 # on saving, compute optimal Huffman coding tables
|
|
# # (can reduce a few percent of file size)
|
|
JPEG_BASELINE = 0x40000 # save basic JPEG, without metadata or any markers
|
|
KOALA_DEFAULT = 0
|
|
LBM_DEFAULT = 0
|
|
MNG_DEFAULT = 0
|
|
PCD_DEFAULT = 0
|
|
PCD_BASE = 1 # load the bitmap sized 768 x 512
|
|
PCD_BASEDIV4 = 2 # load the bitmap sized 384 x 256
|
|
PCD_BASEDIV16 = 3 # load the bitmap sized 192 x 128
|
|
PCX_DEFAULT = 0
|
|
PFM_DEFAULT = 0
|
|
PICT_DEFAULT = 0
|
|
PNG_DEFAULT = 0
|
|
PNG_IGNOREGAMMA = 1 # loading: avoid gamma correction
|
|
PNG_Z_BEST_SPEED = 0x0001 # save using ZLib level 1 compression flag
|
|
# # (default value is 6)
|
|
PNG_Z_DEFAULT_COMPRESSION = 0x0006 # save using ZLib level 6 compression
|
|
# # flag (default recommended value)
|
|
PNG_Z_BEST_COMPRESSION = 0x0009 # save using ZLib level 9 compression flag
|
|
# # (default value is 6)
|
|
PNG_Z_NO_COMPRESSION = 0x0100 # save without ZLib compression
|
|
PNG_INTERLACED = 0x0200 # save using Adam7 interlacing (use | to combine
|
|
# # with other save flags)
|
|
PNM_DEFAULT = 0
|
|
PNM_SAVE_RAW = 0 # Writer saves in RAW format (i.e. P4, P5 or P6)
|
|
PNM_SAVE_ASCII = 1 # Writer saves in ASCII format (i.e. P1, P2 or P3)
|
|
PSD_DEFAULT = 0
|
|
PSD_CMYK = 1 # reads tags for separated CMYK (default is conversion to RGB)
|
|
PSD_LAB = 2 # reads tags for CIELab (default is conversion to RGB)
|
|
RAS_DEFAULT = 0
|
|
RAW_DEFAULT = 0 # load the file as linear RGB 48-bit
|
|
RAW_PREVIEW = 1 # try to load the embedded JPEG preview with included
|
|
# # Exif Data or default to RGB 24-bit
|
|
RAW_DISPLAY = 2 # load the file as RGB 24-bit
|
|
SGI_DEFAULT = 0
|
|
TARGA_DEFAULT = 0
|
|
TARGA_LOAD_RGB888 = 1 # Convert RGB555 and ARGB8888 -> RGB888.
|
|
TARGA_SAVE_RLE = 2 # Save with RLE compression
|
|
TIFF_DEFAULT = 0
|
|
TIFF_CMYK = 0x0001 # reads/stores tags for separated CMYK
|
|
# # (use | to combine with compression flags)
|
|
TIFF_PACKBITS = 0x0100 # save using PACKBITS compression
|
|
TIFF_DEFLATE = 0x0200 # save using DEFLATE (a.k.a. ZLIB) compression
|
|
TIFF_ADOBE_DEFLATE = 0x0400 # save using ADOBE DEFLATE compression
|
|
TIFF_NONE = 0x0800 # save without any compression
|
|
TIFF_CCITTFAX3 = 0x1000 # save using CCITT Group 3 fax encoding
|
|
TIFF_CCITTFAX4 = 0x2000 # save using CCITT Group 4 fax encoding
|
|
TIFF_LZW = 0x4000 # save using LZW compression
|
|
TIFF_JPEG = 0x8000 # save using JPEG compression
|
|
TIFF_LOGLUV = 0x10000 # save using LogLuv compression
|
|
WBMP_DEFAULT = 0
|
|
XBM_DEFAULT = 0
|
|
XPM_DEFAULT = 0
|
|
|
|
|
|
class METADATA_MODELS(object):
|
|
FIMD_COMMENTS = 0
|
|
FIMD_EXIF_MAIN = 1
|
|
FIMD_EXIF_EXIF = 2
|
|
FIMD_EXIF_GPS = 3
|
|
FIMD_EXIF_MAKERNOTE = 4
|
|
FIMD_EXIF_INTEROP = 5
|
|
FIMD_IPTC = 6
|
|
FIMD_XMP = 7
|
|
FIMD_GEOTIFF = 8
|
|
FIMD_ANIMATION = 9
|
|
|
|
|
|
class METADATA_DATATYPE(object):
|
|
FIDT_BYTE = 1 # 8-bit unsigned integer
|
|
FIDT_ASCII = 2 # 8-bit bytes w/ last byte null
|
|
FIDT_SHORT = 3 # 16-bit unsigned integer
|
|
FIDT_LONG = 4 # 32-bit unsigned integer
|
|
FIDT_RATIONAL = 5 # 64-bit unsigned fraction
|
|
FIDT_SBYTE = 6 # 8-bit signed integer
|
|
FIDT_UNDEFINED = 7 # 8-bit untyped data
|
|
FIDT_SSHORT = 8 # 16-bit signed integer
|
|
FIDT_SLONG = 9 # 32-bit signed integer
|
|
FIDT_SRATIONAL = 10 # 64-bit signed fraction
|
|
FIDT_FLOAT = 11 # 32-bit IEEE floating point
|
|
FIDT_DOUBLE = 12 # 64-bit IEEE floating point
|
|
FIDT_IFD = 13 # 32-bit unsigned integer (offset)
|
|
FIDT_PALETTE = 14 # 32-bit RGBQUAD
|
|
FIDT_LONG8 = 16 # 64-bit unsigned integer
|
|
FIDT_SLONG8 = 17 # 64-bit signed integer
|
|
FIDT_IFD8 = 18 # 64-bit unsigned integer (offset)
|
|
|
|
dtypes = {
|
|
FIDT_BYTE: numpy.uint8,
|
|
FIDT_SHORT: numpy.uint16,
|
|
FIDT_LONG: numpy.uint32,
|
|
FIDT_RATIONAL: [("numerator", numpy.uint32), ("denominator", numpy.uint32)],
|
|
FIDT_LONG8: numpy.uint64,
|
|
FIDT_SLONG8: numpy.int64,
|
|
FIDT_IFD8: numpy.uint64,
|
|
FIDT_SBYTE: numpy.int8,
|
|
FIDT_UNDEFINED: numpy.uint8,
|
|
FIDT_SSHORT: numpy.int16,
|
|
FIDT_SLONG: numpy.int32,
|
|
FIDT_SRATIONAL: [("numerator", numpy.int32), ("denominator", numpy.int32)],
|
|
FIDT_FLOAT: numpy.float32,
|
|
FIDT_DOUBLE: numpy.float64,
|
|
FIDT_IFD: numpy.uint32,
|
|
FIDT_PALETTE: [
|
|
("R", numpy.uint8),
|
|
("G", numpy.uint8),
|
|
("B", numpy.uint8),
|
|
("A", numpy.uint8),
|
|
],
|
|
}
|
|
|
|
|
|
class Freeimage(object):
|
|
""" Class to represent an interface to the FreeImage library.
|
|
This class is relatively thin. It provides a Pythonic API that converts
|
|
Freeimage objects to Python objects, but that's about it.
|
|
The actual implementation should be provided by the plugins.
|
|
|
|
The recommended way to call into the Freeimage library (so that
|
|
errors and warnings show up in the right moment) is to use this
|
|
object as a context manager:
|
|
with imageio.fi as lib:
|
|
lib.FreeImage_GetPalette()
|
|
|
|
"""
|
|
|
|
_API = {
|
|
# All we're doing here is telling ctypes that some of the
|
|
# FreeImage functions return pointers instead of integers. (On
|
|
# 64-bit systems, without this information the pointers get
|
|
# truncated and crashes result). There's no need to list
|
|
# functions that return ints, or the types of the parameters
|
|
# to these or other functions -- that's fine to do implicitly.
|
|
# Note that the ctypes immediately converts the returned void_p
|
|
# back to a python int again! This is really not helpful,
|
|
# because then passing it back to another library call will
|
|
# cause truncation-to-32-bits on 64-bit systems. Thanks, ctypes!
|
|
# So after these calls one must immediately re-wrap the int as
|
|
# a c_void_p if it is to be passed back into FreeImage.
|
|
"FreeImage_AllocateT": (ctypes.c_void_p, None),
|
|
"FreeImage_FindFirstMetadata": (ctypes.c_void_p, None),
|
|
"FreeImage_GetBits": (ctypes.c_void_p, None),
|
|
"FreeImage_GetPalette": (ctypes.c_void_p, None),
|
|
"FreeImage_GetTagKey": (ctypes.c_char_p, None),
|
|
"FreeImage_GetTagValue": (ctypes.c_void_p, None),
|
|
"FreeImage_CreateTag": (ctypes.c_void_p, None),
|
|
"FreeImage_Save": (ctypes.c_void_p, None),
|
|
"FreeImage_Load": (ctypes.c_void_p, None),
|
|
"FreeImage_LoadFromMemory": (ctypes.c_void_p, None),
|
|
"FreeImage_OpenMultiBitmap": (ctypes.c_void_p, None),
|
|
"FreeImage_LoadMultiBitmapFromMemory": (ctypes.c_void_p, None),
|
|
"FreeImage_LockPage": (ctypes.c_void_p, None),
|
|
"FreeImage_OpenMemory": (ctypes.c_void_p, None),
|
|
# 'FreeImage_ReadMemory': (ctypes.c_void_p, None),
|
|
# 'FreeImage_CloseMemory': (ctypes.c_void_p, None),
|
|
"FreeImage_GetVersion": (ctypes.c_char_p, None),
|
|
"FreeImage_GetFIFExtensionList": (ctypes.c_char_p, None),
|
|
"FreeImage_GetFormatFromFIF": (ctypes.c_char_p, None),
|
|
"FreeImage_GetFIFDescription": (ctypes.c_char_p, None),
|
|
"FreeImage_ColorQuantizeEx": (ctypes.c_void_p, None),
|
|
# Pypy wants some extra definitions, so here we go ...
|
|
"FreeImage_IsLittleEndian": (ctypes.c_int, None),
|
|
"FreeImage_SetOutputMessage": (ctypes.c_void_p, None),
|
|
"FreeImage_GetFIFCount": (ctypes.c_int, None),
|
|
"FreeImage_IsPluginEnabled": (ctypes.c_int, None),
|
|
"FreeImage_GetFileType": (ctypes.c_int, None),
|
|
#
|
|
"FreeImage_GetTagType": (ctypes.c_int, None),
|
|
"FreeImage_GetTagLength": (ctypes.c_int, None),
|
|
"FreeImage_FindNextMetadata": (ctypes.c_int, None),
|
|
"FreeImage_FindCloseMetadata": (ctypes.c_void_p, None),
|
|
#
|
|
"FreeImage_GetFIFFromFilename": (ctypes.c_int, None),
|
|
"FreeImage_FIFSupportsReading": (ctypes.c_int, None),
|
|
"FreeImage_FIFSupportsWriting": (ctypes.c_int, None),
|
|
"FreeImage_FIFSupportsExportType": (ctypes.c_int, None),
|
|
"FreeImage_FIFSupportsExportBPP": (ctypes.c_int, None),
|
|
"FreeImage_GetHeight": (ctypes.c_int, None),
|
|
"FreeImage_GetWidth": (ctypes.c_int, None),
|
|
"FreeImage_GetImageType": (ctypes.c_int, None),
|
|
"FreeImage_GetBPP": (ctypes.c_int, None),
|
|
"FreeImage_GetColorsUsed": (ctypes.c_int, None),
|
|
"FreeImage_ConvertTo32Bits": (ctypes.c_void_p, None),
|
|
"FreeImage_GetPitch": (ctypes.c_int, None),
|
|
"FreeImage_Unload": (ctypes.c_void_p, None),
|
|
}
|
|
|
|
def __init__(self):
|
|
|
|
# Initialize freeimage lib as None
|
|
self._lib = None
|
|
|
|
# A lock to create thread-safety
|
|
self._lock = threading.RLock()
|
|
|
|
# Init log messages lists
|
|
self._messages = []
|
|
|
|
# Select functype for error handler
|
|
if sys.platform.startswith("win"):
|
|
functype = ctypes.WINFUNCTYPE
|
|
else:
|
|
functype = ctypes.CFUNCTYPE
|
|
|
|
# Create output message handler
|
|
@functype(None, ctypes.c_int, ctypes.c_char_p)
|
|
def error_handler(fif, message):
|
|
message = message.decode("utf-8")
|
|
self._messages.append(message)
|
|
while (len(self._messages)) > 256:
|
|
self._messages.pop(0)
|
|
|
|
# Make sure to keep a ref to function
|
|
self._error_handler = error_handler
|
|
|
|
@property
|
|
def lib(self):
|
|
if self._lib is None:
|
|
try:
|
|
self.load_freeimage()
|
|
except OSError as err:
|
|
self._lib = "The freeimage library could not be loaded: "
|
|
self._lib += str(err)
|
|
if isinstance(self._lib, str):
|
|
raise RuntimeError(self._lib)
|
|
return self._lib
|
|
|
|
def has_lib(self):
|
|
try:
|
|
self.lib
|
|
except Exception:
|
|
return False
|
|
return True
|
|
|
|
def load_freeimage(self):
|
|
""" Try to load the freeimage lib from the system. If not successful,
|
|
try to download the imageio version and try again.
|
|
"""
|
|
# Load library and register API
|
|
success = False
|
|
try:
|
|
# Try without forcing a download, but giving preference
|
|
# to the imageio-provided lib (if previously downloaded)
|
|
self._load_freeimage()
|
|
self._register_api()
|
|
if self.lib.FreeImage_GetVersion().decode("utf-8") >= "3.15":
|
|
success = True
|
|
except OSError:
|
|
pass
|
|
|
|
if not success:
|
|
# Ensure we have our own lib, try again
|
|
get_freeimage_lib()
|
|
self._load_freeimage()
|
|
self._register_api()
|
|
|
|
# Wrap up
|
|
self.lib.FreeImage_SetOutputMessage(self._error_handler)
|
|
self.lib_version = self.lib.FreeImage_GetVersion().decode("utf-8")
|
|
|
|
def _load_freeimage(self):
|
|
|
|
# Define names
|
|
lib_names = ["freeimage", "libfreeimage"]
|
|
exact_lib_names = [
|
|
"FreeImage",
|
|
"libfreeimage.dylib",
|
|
"libfreeimage.so",
|
|
"libfreeimage.so.3",
|
|
]
|
|
# Add names of libraries that we provide (that file may not exist)
|
|
res_dirs = resource_dirs()
|
|
plat = get_platform()
|
|
if plat: # Can be None on e.g. FreeBSD
|
|
fname = FNAME_PER_PLATFORM[plat]
|
|
for dir in res_dirs:
|
|
exact_lib_names.insert(0, os.path.join(dir, "freeimage", fname))
|
|
|
|
# Add the path specified with IMAGEIO_FREEIMAGE_LIB:
|
|
lib = os.getenv("IMAGEIO_FREEIMAGE_LIB", None)
|
|
if lib is not None:
|
|
exact_lib_names.insert(0, lib)
|
|
|
|
# Load
|
|
try:
|
|
lib, fname = load_lib(exact_lib_names, lib_names, res_dirs)
|
|
except OSError as err: # pragma: no cover
|
|
err_msg = str(err) + "\nPlease install the FreeImage library."
|
|
raise OSError(err_msg)
|
|
|
|
# Store
|
|
self._lib = lib
|
|
self.lib_fname = fname
|
|
|
|
def _register_api(self):
|
|
# Albert's ctypes pattern
|
|
for f, (restype, argtypes) in self._API.items():
|
|
func = getattr(self.lib, f)
|
|
func.restype = restype
|
|
func.argtypes = argtypes
|
|
|
|
## Handling of output messages
|
|
|
|
def __enter__(self):
|
|
self._lock.acquire()
|
|
return self.lib
|
|
|
|
def __exit__(self, *args):
|
|
self._show_any_warnings()
|
|
self._lock.release()
|
|
|
|
def _reset_log(self):
|
|
""" Reset the list of output messages. Call this before
|
|
loading or saving an image with the FreeImage API.
|
|
"""
|
|
self._messages = []
|
|
|
|
def _get_error_message(self):
|
|
""" Get the output messages produced since the last reset as
|
|
one string. Returns 'No known reason.' if there are no messages.
|
|
Also resets the log.
|
|
"""
|
|
if self._messages:
|
|
res = " ".join(self._messages)
|
|
self._reset_log()
|
|
return res
|
|
else:
|
|
return "No known reason."
|
|
|
|
def _show_any_warnings(self):
|
|
""" If there were any messages since the last reset, show them
|
|
as a warning. Otherwise do nothing. Also resets the messages.
|
|
"""
|
|
if self._messages:
|
|
logger.warning("imageio.freeimage warning: " + self._get_error_message())
|
|
self._reset_log()
|
|
|
|
def get_output_log(self):
|
|
""" Return a list of the last 256 output messages
|
|
(warnings and errors) produced by the FreeImage library.
|
|
"""
|
|
# This message log is not cleared/reset, but kept to 256 elements.
|
|
return [m for m in self._messages]
|
|
|
|
def getFIF(self, filename, mode, bb=None):
|
|
""" Get the freeimage Format (FIF) from a given filename.
|
|
If mode is 'r', will try to determine the format by reading
|
|
the file, otherwise only the filename is used.
|
|
|
|
This function also tests whether the format supports reading/writing.
|
|
"""
|
|
with self as lib:
|
|
|
|
# Init
|
|
ftype = -1
|
|
if mode not in "rw":
|
|
raise ValueError('Invalid mode (must be "r" or "w").')
|
|
|
|
# Try getting format from the content. Note that some files
|
|
# do not have a header that allows reading the format from
|
|
# the file.
|
|
if mode == "r":
|
|
if bb is not None:
|
|
fimemory = lib.FreeImage_OpenMemory(ctypes.c_char_p(bb), len(bb))
|
|
ftype = lib.FreeImage_GetFileTypeFromMemory(
|
|
ctypes.c_void_p(fimemory), len(bb)
|
|
)
|
|
lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
|
|
if (ftype == -1) and os.path.isfile(filename):
|
|
ftype = lib.FreeImage_GetFileType(efn(filename), 0)
|
|
# Try getting the format from the extension
|
|
if ftype == -1:
|
|
ftype = lib.FreeImage_GetFIFFromFilename(efn(filename))
|
|
|
|
# Test if ok
|
|
if ftype == -1:
|
|
raise ValueError('Cannot determine format of file "%s"' % filename)
|
|
elif mode == "w" and not lib.FreeImage_FIFSupportsWriting(ftype):
|
|
raise ValueError('Cannot write the format of file "%s"' % filename)
|
|
elif mode == "r" and not lib.FreeImage_FIFSupportsReading(ftype):
|
|
raise ValueError('Cannot read the format of file "%s"' % filename)
|
|
return ftype
|
|
|
|
def create_bitmap(self, filename, ftype, flags=0):
|
|
""" create_bitmap(filename, ftype, flags=0)
|
|
Create a wrapped bitmap object.
|
|
"""
|
|
return FIBitmap(self, filename, ftype, flags)
|
|
|
|
def create_multipage_bitmap(self, filename, ftype, flags=0):
|
|
""" create_multipage_bitmap(filename, ftype, flags=0)
|
|
Create a wrapped multipage bitmap object.
|
|
"""
|
|
return FIMultipageBitmap(self, filename, ftype, flags)
|
|
|
|
|
|
class FIBaseBitmap(object):
|
|
def __init__(self, fi, filename, ftype, flags):
|
|
self._fi = fi
|
|
self._filename = filename
|
|
self._ftype = ftype
|
|
self._flags = flags
|
|
self._bitmap = None
|
|
self._close_funcs = []
|
|
|
|
def __del__(self):
|
|
self.close()
|
|
|
|
def close(self):
|
|
if (self._bitmap is not None) and self._close_funcs:
|
|
for close_func in self._close_funcs:
|
|
try:
|
|
with self._fi:
|
|
fun = close_func[0]
|
|
fun(*close_func[1:])
|
|
except Exception: # pragma: no cover
|
|
pass
|
|
self._close_funcs = []
|
|
self._bitmap = None
|
|
|
|
def _set_bitmap(self, bitmap, close_func=None):
|
|
""" Function to set the bitmap and specify the function to unload it.
|
|
"""
|
|
if self._bitmap is not None:
|
|
pass # bitmap is converted
|
|
if close_func is None:
|
|
close_func = self._fi.lib.FreeImage_Unload, bitmap
|
|
|
|
self._bitmap = bitmap
|
|
if close_func:
|
|
self._close_funcs.append(close_func)
|
|
|
|
def get_meta_data(self):
|
|
|
|
# todo: there is also FreeImage_TagToString, is that useful?
|
|
# and would that work well when reading and then saving?
|
|
|
|
# Create a list of (model_name, number) tuples
|
|
models = [
|
|
(name[5:], number)
|
|
for name, number in METADATA_MODELS.__dict__.items()
|
|
if name.startswith("FIMD_")
|
|
]
|
|
|
|
# Prepare
|
|
metadata = Dict()
|
|
tag = ctypes.c_void_p()
|
|
|
|
with self._fi as lib:
|
|
|
|
# Iterate over all FreeImage meta models
|
|
for model_name, number in models:
|
|
|
|
# Find beginning, get search handle
|
|
mdhandle = lib.FreeImage_FindFirstMetadata(
|
|
number, self._bitmap, ctypes.byref(tag)
|
|
)
|
|
mdhandle = ctypes.c_void_p(mdhandle)
|
|
if mdhandle:
|
|
|
|
# Iterate over all tags in this model
|
|
more = True
|
|
while more:
|
|
# Get info about tag
|
|
tag_name = lib.FreeImage_GetTagKey(tag).decode("utf-8")
|
|
tag_type = lib.FreeImage_GetTagType(tag)
|
|
byte_size = lib.FreeImage_GetTagLength(tag)
|
|
char_ptr = ctypes.c_char * byte_size
|
|
data = char_ptr.from_address(lib.FreeImage_GetTagValue(tag))
|
|
# Convert in a way compatible with Pypy
|
|
tag_bytes = bytes(bytearray(data))
|
|
# The default value is the raw bytes
|
|
tag_val = tag_bytes
|
|
# Convert to a Python value in the metadata dict
|
|
if tag_type == METADATA_DATATYPE.FIDT_ASCII:
|
|
tag_val = tag_bytes.decode("utf-8", "replace")
|
|
elif tag_type in METADATA_DATATYPE.dtypes:
|
|
dtype = METADATA_DATATYPE.dtypes[tag_type]
|
|
if IS_PYPY and isinstance(dtype, (list, tuple)):
|
|
pass # pragma: no cover - or we get a segfault
|
|
else:
|
|
try:
|
|
tag_val = numpy.frombuffer(
|
|
tag_bytes, dtype=dtype
|
|
).copy()
|
|
if len(tag_val) == 1:
|
|
tag_val = tag_val[0]
|
|
except Exception: # pragma: no cover
|
|
pass
|
|
# Store data in dict
|
|
subdict = metadata.setdefault(model_name, Dict())
|
|
subdict[tag_name] = tag_val
|
|
# Next
|
|
more = lib.FreeImage_FindNextMetadata(
|
|
mdhandle, ctypes.byref(tag)
|
|
)
|
|
|
|
# Close search handle for current meta model
|
|
lib.FreeImage_FindCloseMetadata(mdhandle)
|
|
|
|
# Done
|
|
return metadata
|
|
|
|
def set_meta_data(self, metadata):
|
|
|
|
# Create a dict mapping model_name to number
|
|
models = {}
|
|
for name, number in METADATA_MODELS.__dict__.items():
|
|
if name.startswith("FIMD_"):
|
|
models[name[5:]] = number
|
|
|
|
# Create a mapping from numpy.dtype to METADATA_DATATYPE
|
|
def get_tag_type_number(dtype):
|
|
for number, numpy_dtype in METADATA_DATATYPE.dtypes.items():
|
|
if dtype == numpy_dtype:
|
|
return number
|
|
else:
|
|
return None
|
|
|
|
with self._fi as lib:
|
|
|
|
for model_name, subdict in metadata.items():
|
|
|
|
# Get model number
|
|
number = models.get(model_name, None)
|
|
if number is None:
|
|
continue # Unknown model, silent ignore
|
|
|
|
for tag_name, tag_val in subdict.items():
|
|
|
|
# Create new tag
|
|
tag = lib.FreeImage_CreateTag()
|
|
tag = ctypes.c_void_p(tag)
|
|
|
|
try:
|
|
# Convert Python value to FI type, val
|
|
is_ascii = False
|
|
if isinstance(tag_val, str):
|
|
try:
|
|
tag_bytes = tag_val.encode("ascii")
|
|
is_ascii = True
|
|
except UnicodeError:
|
|
pass
|
|
if is_ascii:
|
|
tag_type = METADATA_DATATYPE.FIDT_ASCII
|
|
tag_count = len(tag_bytes)
|
|
else:
|
|
if not hasattr(tag_val, "dtype"):
|
|
tag_val = numpy.array([tag_val])
|
|
tag_type = get_tag_type_number(tag_val.dtype)
|
|
if tag_type is None:
|
|
logger.warning(
|
|
"imageio.freeimage warning: Could not "
|
|
"determine tag type of %r." % tag_name
|
|
)
|
|
continue
|
|
tag_bytes = tag_val.tostring()
|
|
tag_count = tag_val.size
|
|
# Set properties
|
|
lib.FreeImage_SetTagKey(tag, tag_name.encode("utf-8"))
|
|
lib.FreeImage_SetTagType(tag, tag_type)
|
|
lib.FreeImage_SetTagCount(tag, tag_count)
|
|
lib.FreeImage_SetTagLength(tag, len(tag_bytes))
|
|
lib.FreeImage_SetTagValue(tag, tag_bytes)
|
|
# Store tag
|
|
tag_key = lib.FreeImage_GetTagKey(tag)
|
|
lib.FreeImage_SetMetadata(number, self._bitmap, tag_key, tag)
|
|
|
|
except Exception as err: # pragma: no cover
|
|
logger.warning(
|
|
"imagio.freeimage warning: Could not set tag "
|
|
"%r: %s, %s"
|
|
% (tag_name, self._fi._get_error_message(), str(err))
|
|
)
|
|
finally:
|
|
lib.FreeImage_DeleteTag(tag)
|
|
|
|
|
|
class FIBitmap(FIBaseBitmap):
|
|
""" Wrapper for the FI bitmap object.
|
|
"""
|
|
|
|
def allocate(self, array):
|
|
|
|
# Prepare array
|
|
assert isinstance(array, numpy.ndarray)
|
|
shape = array.shape
|
|
dtype = array.dtype
|
|
|
|
# Get shape and channel info
|
|
r, c = shape[:2]
|
|
if len(shape) == 2:
|
|
n_channels = 1
|
|
elif len(shape) == 3:
|
|
n_channels = shape[2]
|
|
else:
|
|
n_channels = shape[0]
|
|
|
|
# Get fi_type
|
|
try:
|
|
fi_type = FI_TYPES.fi_types[(dtype.type, n_channels)]
|
|
self._fi_type = fi_type
|
|
except KeyError:
|
|
raise ValueError("Cannot write arrays of given type and shape.")
|
|
|
|
# Allocate bitmap
|
|
with self._fi as lib:
|
|
bpp = 8 * dtype.itemsize * n_channels
|
|
bitmap = lib.FreeImage_AllocateT(fi_type, c, r, bpp, 0, 0, 0)
|
|
bitmap = ctypes.c_void_p(bitmap)
|
|
|
|
# Check and store
|
|
if not bitmap: # pragma: no cover
|
|
raise RuntimeError(
|
|
"Could not allocate bitmap for storage: %s"
|
|
% self._fi._get_error_message()
|
|
)
|
|
self._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
|
|
|
|
def load_from_filename(self, filename=None):
|
|
if filename is None:
|
|
filename = self._filename
|
|
|
|
with self._fi as lib:
|
|
# Create bitmap
|
|
bitmap = lib.FreeImage_Load(self._ftype, efn(filename), self._flags)
|
|
bitmap = ctypes.c_void_p(bitmap)
|
|
|
|
# Check and store
|
|
if not bitmap: # pragma: no cover
|
|
raise ValueError(
|
|
'Could not load bitmap "%s": %s'
|
|
% (self._filename, self._fi._get_error_message())
|
|
)
|
|
self._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
|
|
|
|
# def load_from_bytes(self, bb):
|
|
# with self._fi as lib:
|
|
# # Create bitmap
|
|
# fimemory = lib.FreeImage_OpenMemory(
|
|
# ctypes.c_char_p(bb), len(bb))
|
|
# bitmap = lib.FreeImage_LoadFromMemory(
|
|
# self._ftype, ctypes.c_void_p(fimemory), self._flags)
|
|
# bitmap = ctypes.c_void_p(bitmap)
|
|
# lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
|
|
#
|
|
# # Check
|
|
# if not bitmap:
|
|
# raise ValueError('Could not load bitmap "%s": %s'
|
|
# % (self._filename, self._fi._get_error_message()))
|
|
# else:
|
|
# self._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
|
|
|
|
def save_to_filename(self, filename=None):
|
|
if filename is None:
|
|
filename = self._filename
|
|
|
|
ftype = self._ftype
|
|
bitmap = self._bitmap
|
|
fi_type = self._fi_type # element type
|
|
|
|
with self._fi as lib:
|
|
# Check if can write
|
|
if fi_type == FI_TYPES.FIT_BITMAP:
|
|
can_write = lib.FreeImage_FIFSupportsExportBPP(
|
|
ftype, lib.FreeImage_GetBPP(bitmap)
|
|
)
|
|
else:
|
|
can_write = lib.FreeImage_FIFSupportsExportType(ftype, fi_type)
|
|
if not can_write:
|
|
raise TypeError("Cannot save image of this format " "to this file type")
|
|
|
|
# Save to file
|
|
res = lib.FreeImage_Save(ftype, bitmap, efn(filename), self._flags)
|
|
# Check
|
|
if not res: # pragma: no cover, we do so many checks, this is rare
|
|
raise RuntimeError(
|
|
'Could not save file "%s": %s'
|
|
% (self._filename, self._fi._get_error_message())
|
|
)
|
|
|
|
# def save_to_bytes(self):
|
|
# ftype = self._ftype
|
|
# bitmap = self._bitmap
|
|
# fi_type = self._fi_type # element type
|
|
#
|
|
# with self._fi as lib:
|
|
# # Check if can write
|
|
# if fi_type == FI_TYPES.FIT_BITMAP:
|
|
# can_write = lib.FreeImage_FIFSupportsExportBPP(ftype,
|
|
# lib.FreeImage_GetBPP(bitmap))
|
|
# else:
|
|
# can_write = lib.FreeImage_FIFSupportsExportType(ftype, fi_type)
|
|
# if not can_write:
|
|
# raise TypeError('Cannot save image of this format '
|
|
# 'to this file type')
|
|
#
|
|
# # Extract the bytes
|
|
# fimemory = lib.FreeImage_OpenMemory(0, 0)
|
|
# res = lib.FreeImage_SaveToMemory(ftype, bitmap,
|
|
# ctypes.c_void_p(fimemory),
|
|
# self._flags)
|
|
# if res:
|
|
# N = lib.FreeImage_TellMemory(ctypes.c_void_p(fimemory))
|
|
# result = ctypes.create_string_buffer(N)
|
|
# lib.FreeImage_SeekMemory(ctypes.c_void_p(fimemory), 0)
|
|
# lib.FreeImage_ReadMemory(result, 1, N, ctypes.c_void_p(fimemory))
|
|
# result = result.raw
|
|
# lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
|
|
#
|
|
# # Check
|
|
# if not res:
|
|
# raise RuntimeError('Could not save file "%s": %s'
|
|
# % (self._filename, self._fi._get_error_message()))
|
|
#
|
|
# # Done
|
|
# return result
|
|
|
|
def get_image_data(self):
|
|
dtype, shape, bpp = self._get_type_and_shape()
|
|
array = self._wrap_bitmap_bits_in_array(shape, dtype, False)
|
|
with self._fi as lib:
|
|
isle = lib.FreeImage_IsLittleEndian()
|
|
|
|
# swizzle the color components and flip the scanlines to go from
|
|
# FreeImage's BGR[A] and upside-down internal memory format to
|
|
# something more normal
|
|
def n(arr):
|
|
# return arr[..., ::-1].T # Does not work on numpypy yet
|
|
if arr.ndim == 1: # pragma: no cover
|
|
return arr[::-1].T
|
|
elif arr.ndim == 2: # Always the case here ...
|
|
return arr[:, ::-1].T
|
|
elif arr.ndim == 3: # pragma: no cover
|
|
return arr[:, :, ::-1].T
|
|
elif arr.ndim == 4: # pragma: no cover
|
|
return arr[:, :, :, ::-1].T
|
|
|
|
if len(shape) == 3 and isle and dtype.type == numpy.uint8:
|
|
b = n(array[0])
|
|
g = n(array[1])
|
|
r = n(array[2])
|
|
if shape[0] == 3:
|
|
return numpy.dstack((r, g, b))
|
|
elif shape[0] == 4:
|
|
a = n(array[3])
|
|
return numpy.dstack((r, g, b, a))
|
|
else: # pragma: no cover - we check this earlier
|
|
raise ValueError("Cannot handle images of shape %s" % shape)
|
|
|
|
# We need to copy because array does *not* own its memory
|
|
# after bitmap is freed.
|
|
a = n(array).copy()
|
|
return a
|
|
|
|
def set_image_data(self, array):
|
|
|
|
# Prepare array
|
|
assert isinstance(array, numpy.ndarray)
|
|
shape = array.shape
|
|
dtype = array.dtype
|
|
with self._fi as lib:
|
|
isle = lib.FreeImage_IsLittleEndian()
|
|
|
|
# Calculate shape and channels
|
|
r, c = shape[:2]
|
|
if len(shape) == 2:
|
|
n_channels = 1
|
|
w_shape = (c, r)
|
|
elif len(shape) == 3:
|
|
n_channels = shape[2]
|
|
w_shape = (n_channels, c, r)
|
|
else:
|
|
n_channels = shape[0]
|
|
|
|
def n(arr): # normalise to freeimage's in-memory format
|
|
return arr[::-1].T
|
|
|
|
wrapped_array = self._wrap_bitmap_bits_in_array(w_shape, dtype, True)
|
|
# swizzle the color components and flip the scanlines to go to
|
|
# FreeImage's BGR[A] and upside-down internal memory format
|
|
# The BGR[A] order is only used for 8bits per channel images
|
|
# on little endian machines. For everything else RGB[A] is
|
|
# used.
|
|
if len(shape) == 3 and isle and dtype.type == numpy.uint8:
|
|
R = array[:, :, 0]
|
|
G = array[:, :, 1]
|
|
B = array[:, :, 2]
|
|
wrapped_array[0] = n(B)
|
|
wrapped_array[1] = n(G)
|
|
wrapped_array[2] = n(R)
|
|
if shape[2] == 4:
|
|
A = array[:, :, 3]
|
|
wrapped_array[3] = n(A)
|
|
else:
|
|
wrapped_array[:] = n(array)
|
|
if self._need_finish:
|
|
self._finish_wrapped_array(wrapped_array)
|
|
|
|
if len(shape) == 2 and dtype.type == numpy.uint8:
|
|
with self._fi as lib:
|
|
palette = lib.FreeImage_GetPalette(self._bitmap)
|
|
palette = ctypes.c_void_p(palette)
|
|
if not palette:
|
|
raise RuntimeError("Could not get image palette")
|
|
try:
|
|
palette_data = GREY_PALETTE.ctypes.data
|
|
except Exception: # pragma: no cover - IS_PYPY
|
|
palette_data = GREY_PALETTE.__array_interface__["data"][0]
|
|
ctypes.memmove(palette, palette_data, 1024)
|
|
|
|
def _wrap_bitmap_bits_in_array(self, shape, dtype, save):
|
|
"""Return an ndarray view on the data in a FreeImage bitmap. Only
|
|
valid for as long as the bitmap is loaded (if single page) / locked
|
|
in memory (if multipage). This is used in loading data, but
|
|
also during saving, to prepare a strided numpy array buffer.
|
|
|
|
"""
|
|
# Get bitmap info
|
|
with self._fi as lib:
|
|
pitch = lib.FreeImage_GetPitch(self._bitmap)
|
|
bits = lib.FreeImage_GetBits(self._bitmap)
|
|
|
|
# Get more info
|
|
height = shape[-1]
|
|
byte_size = height * pitch
|
|
itemsize = dtype.itemsize
|
|
|
|
# Get strides
|
|
if len(shape) == 3:
|
|
strides = (itemsize, shape[0] * itemsize, pitch)
|
|
else:
|
|
strides = (itemsize, pitch)
|
|
|
|
# Create numpy array and return
|
|
data = (ctypes.c_char * byte_size).from_address(bits)
|
|
try:
|
|
self._need_finish = False
|
|
if TEST_NUMPY_NO_STRIDES:
|
|
raise NotImplementedError()
|
|
return numpy.ndarray(shape, dtype=dtype, buffer=data, strides=strides)
|
|
except NotImplementedError:
|
|
# IS_PYPY - not very efficient. We create a C-contiguous
|
|
# numpy array (because pypy does not support Fortran-order)
|
|
# and shape it such that the rest of the code can remain.
|
|
if save:
|
|
self._need_finish = True # Flag to use _finish_wrapped_array
|
|
return numpy.zeros(shape, dtype=dtype)
|
|
else:
|
|
bb = bytes(bytearray(data))
|
|
array = numpy.frombuffer(bb, dtype=dtype).copy()
|
|
# Deal with strides
|
|
if len(shape) == 3:
|
|
array.shape = shape[2], strides[-1] // shape[0], shape[0]
|
|
array2 = array[: shape[2], : shape[1], : shape[0]]
|
|
array = numpy.zeros(shape, dtype=array.dtype)
|
|
for i in range(shape[0]):
|
|
array[i] = array2[:, :, i].T
|
|
else:
|
|
array.shape = shape[1], strides[-1]
|
|
array = array[: shape[1], : shape[0]].T
|
|
return array
|
|
|
|
def _finish_wrapped_array(self, array): # IS_PYPY
|
|
""" Hardcore way to inject numpy array in bitmap.
|
|
"""
|
|
# Get bitmap info
|
|
with self._fi as lib:
|
|
pitch = lib.FreeImage_GetPitch(self._bitmap)
|
|
bits = lib.FreeImage_GetBits(self._bitmap)
|
|
bpp = lib.FreeImage_GetBPP(self._bitmap)
|
|
# Get channels and realwidth
|
|
nchannels = bpp // 8 // array.itemsize
|
|
realwidth = pitch // nchannels
|
|
# Apply padding for pitch if necessary
|
|
extra = realwidth - array.shape[-2]
|
|
assert 0 <= extra < 10
|
|
# Make sort of Fortran, also take padding (i.e. pitch) into account
|
|
newshape = array.shape[-1], realwidth, nchannels
|
|
array2 = numpy.zeros(newshape, array.dtype)
|
|
if nchannels == 1:
|
|
array2[:, : array.shape[-2], 0] = array.T
|
|
else:
|
|
for i in range(nchannels):
|
|
array2[:, : array.shape[-2], i] = array[i, :, :].T
|
|
# copy data
|
|
data_ptr = array2.__array_interface__["data"][0]
|
|
ctypes.memmove(bits, data_ptr, array2.nbytes)
|
|
del array2
|
|
|
|
def _get_type_and_shape(self):
|
|
bitmap = self._bitmap
|
|
|
|
# Get info on bitmap
|
|
with self._fi as lib:
|
|
w = lib.FreeImage_GetWidth(bitmap)
|
|
h = lib.FreeImage_GetHeight(bitmap)
|
|
self._fi_type = fi_type = lib.FreeImage_GetImageType(bitmap)
|
|
if not fi_type:
|
|
raise ValueError("Unknown image pixel type")
|
|
|
|
# Determine required props for numpy array
|
|
bpp = None
|
|
dtype = FI_TYPES.dtypes[fi_type]
|
|
|
|
if fi_type == FI_TYPES.FIT_BITMAP:
|
|
with self._fi as lib:
|
|
bpp = lib.FreeImage_GetBPP(bitmap)
|
|
has_pallette = lib.FreeImage_GetColorsUsed(bitmap)
|
|
if has_pallette:
|
|
# Examine the palette. If it is grayscale, we return as such
|
|
if has_pallette == 256:
|
|
palette = lib.FreeImage_GetPalette(bitmap)
|
|
palette = ctypes.c_void_p(palette)
|
|
p = (ctypes.c_uint8 * (256 * 4)).from_address(palette.value)
|
|
p = numpy.frombuffer(p, numpy.uint32).copy()
|
|
if (GREY_PALETTE == p).all():
|
|
extra_dims = []
|
|
return numpy.dtype(dtype), extra_dims + [w, h], bpp
|
|
# Convert bitmap and call this method again
|
|
newbitmap = lib.FreeImage_ConvertTo32Bits(bitmap)
|
|
newbitmap = ctypes.c_void_p(newbitmap)
|
|
self._set_bitmap(newbitmap)
|
|
return self._get_type_and_shape()
|
|
elif bpp == 8:
|
|
extra_dims = []
|
|
elif bpp == 24:
|
|
extra_dims = [3]
|
|
elif bpp == 32:
|
|
extra_dims = [4]
|
|
else: # pragma: no cover
|
|
# raise ValueError('Cannot convert %d BPP bitmap' % bpp)
|
|
# Convert bitmap and call this method again
|
|
newbitmap = lib.FreeImage_ConvertTo32Bits(bitmap)
|
|
newbitmap = ctypes.c_void_p(newbitmap)
|
|
self._set_bitmap(newbitmap)
|
|
return self._get_type_and_shape()
|
|
else:
|
|
extra_dims = FI_TYPES.extra_dims[fi_type]
|
|
|
|
# Return dtype and shape
|
|
return numpy.dtype(dtype), extra_dims + [w, h], bpp
|
|
|
|
def quantize(self, quantizer=0, palettesize=256):
|
|
""" Quantize the bitmap to make it 8-bit (paletted). Returns a new
|
|
FIBitmap object.
|
|
Only for 24 bit images.
|
|
"""
|
|
with self._fi as lib:
|
|
# New bitmap
|
|
bitmap = lib.FreeImage_ColorQuantizeEx(
|
|
self._bitmap, quantizer, palettesize, 0, None
|
|
)
|
|
bitmap = ctypes.c_void_p(bitmap)
|
|
|
|
# Check and return
|
|
if not bitmap:
|
|
raise ValueError(
|
|
'Could not quantize bitmap "%s": %s'
|
|
% (self._filename, self._fi._get_error_message())
|
|
)
|
|
|
|
new = FIBitmap(self._fi, self._filename, self._ftype, self._flags)
|
|
new._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
|
|
new._fi_type = self._fi_type
|
|
return new
|
|
|
|
|
|
# def convert_to_32bit(self):
|
|
# """ Convert to 32bit image.
|
|
# """
|
|
# with self._fi as lib:
|
|
# # New bitmap
|
|
# bitmap = lib.FreeImage_ConvertTo32Bits(self._bitmap)
|
|
# bitmap = ctypes.c_void_p(bitmap)
|
|
#
|
|
# # Check and return
|
|
# if not bitmap:
|
|
# raise ValueError('Could not convert bitmap to 32bit "%s": %s' %
|
|
# (self._filename,
|
|
# self._fi._get_error_message()))
|
|
# else:
|
|
# new = FIBitmap(self._fi, self._filename, self._ftype,
|
|
# self._flags)
|
|
# new._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
|
|
# new._fi_type = self._fi_type
|
|
# return new
|
|
|
|
|
|
class FIMultipageBitmap(FIBaseBitmap):
|
|
""" Wrapper for the multipage FI bitmap object.
|
|
"""
|
|
|
|
def load_from_filename(self, filename=None):
|
|
if filename is None: # pragma: no cover
|
|
filename = self._filename
|
|
|
|
# Prepare
|
|
create_new = False
|
|
read_only = True
|
|
keep_cache_in_memory = False
|
|
|
|
# Try opening
|
|
with self._fi as lib:
|
|
|
|
# Create bitmap
|
|
multibitmap = lib.FreeImage_OpenMultiBitmap(
|
|
self._ftype,
|
|
efn(filename),
|
|
create_new,
|
|
read_only,
|
|
keep_cache_in_memory,
|
|
self._flags,
|
|
)
|
|
multibitmap = ctypes.c_void_p(multibitmap)
|
|
|
|
# Check
|
|
if not multibitmap: # pragma: no cover
|
|
err = self._fi._get_error_message()
|
|
raise ValueError(
|
|
'Could not open file "%s" as multi-image: %s'
|
|
% (self._filename, err)
|
|
)
|
|
self._set_bitmap(multibitmap, (lib.FreeImage_CloseMultiBitmap, multibitmap))
|
|
|
|
# def load_from_bytes(self, bb):
|
|
# with self._fi as lib:
|
|
# # Create bitmap
|
|
# fimemory = lib.FreeImage_OpenMemory(
|
|
# ctypes.c_char_p(bb), len(bb))
|
|
# multibitmap = lib.FreeImage_LoadMultiBitmapFromMemory(
|
|
# self._ftype, ctypes.c_void_p(fimemory), self._flags)
|
|
# multibitmap = ctypes.c_void_p(multibitmap)
|
|
# #lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
|
|
# self._mem = fimemory
|
|
# self._bytes = bb
|
|
# # Check
|
|
# if not multibitmap:
|
|
# raise ValueError('Could not load multibitmap "%s": %s'
|
|
# % (self._filename, self._fi._get_error_message()))
|
|
# else:
|
|
# self._set_bitmap(multibitmap,
|
|
# (lib.FreeImage_CloseMultiBitmap, multibitmap))
|
|
|
|
def save_to_filename(self, filename=None):
|
|
if filename is None: # pragma: no cover
|
|
filename = self._filename
|
|
|
|
# Prepare
|
|
create_new = True
|
|
read_only = False
|
|
keep_cache_in_memory = False
|
|
|
|
# Open the file
|
|
# todo: Set flags at close func
|
|
with self._fi as lib:
|
|
multibitmap = lib.FreeImage_OpenMultiBitmap(
|
|
self._ftype,
|
|
efn(filename),
|
|
create_new,
|
|
read_only,
|
|
keep_cache_in_memory,
|
|
0,
|
|
)
|
|
multibitmap = ctypes.c_void_p(multibitmap)
|
|
|
|
# Check
|
|
if not multibitmap: # pragma: no cover
|
|
msg = 'Could not open file "%s" for writing multi-image: %s' % (
|
|
self._filename,
|
|
self._fi._get_error_message(),
|
|
)
|
|
raise ValueError(msg)
|
|
self._set_bitmap(multibitmap, (lib.FreeImage_CloseMultiBitmap, multibitmap))
|
|
|
|
def __len__(self):
|
|
with self._fi as lib:
|
|
return lib.FreeImage_GetPageCount(self._bitmap)
|
|
|
|
def get_page(self, index):
|
|
""" Return the sub-bitmap for the given page index.
|
|
Please close the returned bitmap when done.
|
|
"""
|
|
with self._fi as lib:
|
|
|
|
# Create low-level bitmap in freeimage
|
|
bitmap = lib.FreeImage_LockPage(self._bitmap, index)
|
|
bitmap = ctypes.c_void_p(bitmap)
|
|
if not bitmap: # pragma: no cover
|
|
raise ValueError(
|
|
"Could not open sub-image %i in %r: %s"
|
|
% (index, self._filename, self._fi._get_error_message())
|
|
)
|
|
|
|
# Get bitmap object to wrap this bitmap
|
|
bm = FIBitmap(self._fi, self._filename, self._ftype, self._flags)
|
|
bm._set_bitmap(
|
|
bitmap, (lib.FreeImage_UnlockPage, self._bitmap, bitmap, False)
|
|
)
|
|
return bm
|
|
|
|
def append_bitmap(self, bitmap):
|
|
""" Add a sub-bitmap to the multi-page bitmap.
|
|
"""
|
|
with self._fi as lib:
|
|
# no return value
|
|
lib.FreeImage_AppendPage(self._bitmap, bitmap._bitmap)
|
|
|
|
|
|
# Create instance
|
|
fi = Freeimage()
|