def build(self): import imageio pixels = imageio.imread(self.filepath) pixels = channels_to_front(pixels) transparent_types = {'.png'} filepath = Path(self.filepath) if pixels.shape[0] == 4 and filepath.suffix in transparent_types: # If normalise is False, then we return the alpha as an extra # channel, which can be useful if the alpha channel has semantic # meanings! if self.normalise: p = normalize_pixels_range(pixels[:3]) return MaskedImage(p, mask=pixels[-1].astype(np.bool), copy=False) else: return Image(pixels, copy=False) # Assumed not to have an Alpha channel if self.normalise: return Image(normalize_pixels_range(pixels), copy=False) else: return Image(pixels, copy=False)
def _pil_to_numpy(pil_image, normalize, convert=None): p = pil_image.convert(convert) if convert else pil_image p = channels_to_front(p) if normalize: return normalize_pixels_range(p) else: return p
def _pil_to_numpy(pil_image, normalise, convert=None): p = pil_image.convert(convert) if convert else pil_image p = channels_to_front(p) if normalise: return normalize_pixels_range(p) else: return p
def _pil_to_numpy(self, normalise, convert=None): p = self._pil_image.convert(convert) if convert else self._pil_image p = channels_to_front(p) if normalise: return normalise_pixels_range(p) else: return p
def imageio_to_menpo(imio_reader, index): pixels = imio_reader.get_data(index) pixels = channels_to_front(pixels) if self.normalise: return Image(normalise_pixels_range(pixels), copy=False) else: return Image(pixels, copy=False)
def imageio_importer(filepath, asset=None, normalize=True, **kwargs): r""" Imports images using the imageio library - which is actually fairly similar to our importing logic - but contains the necessary plugins to import lots of interesting image types like RAW images. Parameters ---------- filepath : `Path` Absolute filepath of the image. asset : `object`, optional An optional asset that may help with loading. This is unused for this implementation. normalize : `bool`, optional If ``True``, normalize between 0.0 and 1.0 and convert to float. If ``False`` just return whatever imageio imports. \**kwargs : `dict`, optional Any other keyword arguments. Returns ------- image : :map:`Image` or subclass The imported image. """ import imageio pixels = imageio.imread(str(filepath)) pixels = channels_to_front(pixels) transparent_types = {'.png'} if pixels.shape[0] == 4 and filepath.suffix in transparent_types: # If normalize is False, then we return the alpha as an extra # channel, which can be useful if the alpha channel has semantic # meanings! if normalize: p = normalize_pixels_range(pixels[:3]) return MaskedImage(p, mask=pixels[-1].astype(np.bool), copy=False) else: return Image(pixels, copy=False) # Assumed not to have an Alpha channel if normalize: return Image(normalize_pixels_range(pixels), copy=False) else: return Image(pixels, copy=False)
def imageio_importer(filepath, asset=None, normalise=True, **kwargs): r""" Imports images using the imageio library - which is actually fairly similar to our importing logic - but contains the necessary plugins to import lots of interesting image types like RAW images. Parameters ---------- filepath : `Path` Absolute filepath of the image. asset : `object`, optional An optional asset that may help with loading. This is unused for this implementation. normalise : `bool`, optional If ``True``, normalise between 0.0 and 1.0 and convert to float. If ``False`` just return whatever imageio imports. \**kwargs : `dict`, optional Any other keyword arguments. Returns ------- image : :map:`Image` or subclass The imported image. """ import imageio pixels = imageio.imread(str(filepath)) pixels = channels_to_front(pixels) transparent_types = {'.png'} if pixels.shape[0] == 4 and filepath.suffix in transparent_types: # If normalise is False, then we return the alpha as an extra # channel, which can be useful if the alpha channel has semantic # meanings! if normalise: p = normalize_pixels_range(pixels[:3]) return MaskedImage(p, mask=pixels[-1].astype(np.bool), copy=False) else: return Image(pixels, copy=False) # Assumed not to have an Alpha channel if normalise: return Image(normalize_pixels_range(pixels), copy=False) else: return Image(pixels, copy=False)
def imageio_to_menpo(imio_reader, index): pixels = imio_reader.get_data(index) pixels = channels_to_front(pixels) if pixels.shape[0] == 4: # If normalize is False, then we return the alpha as an extra # channel, which can be useful if the alpha channel has semantic # meanings! if normalize: p = normalize_pixels_range(pixels[:3]) return MaskedImage(p, mask=pixels[-1].astype(bool), copy=False) else: return Image(pixels, copy=False) # Assumed not to have an Alpha channel if normalize: return Image(normalize_pixels_range(pixels), copy=False) else: return Image(pixels, copy=False)
def imageio_to_menpo(imio_reader, index): pixels = imio_reader.get_data(index) pixels = channels_to_front(pixels) if pixels.shape[0] == 4: # If normalise is False, then we return the alpha as an extra # channel, which can be useful if the alpha channel has semantic # meanings! if normalise: p = normalize_pixels_range(pixels[:3]) return MaskedImage(p, mask=pixels[-1].astype(np.bool), copy=False) else: return Image(pixels, copy=False) # Assumed not to have an Alpha channel if normalise: return Image(normalize_pixels_range(pixels), copy=False) else: return Image(pixels, copy=False)