lsst.obs.base.formatters.fitsExposure.FitsImageFormatter Class Reference

Inheritance diagram for lsst.obs.base.formatters.fitsExposure.FitsImageFormatter:

Public Member Functions
def	metadata (self)
def	readMetadata (self)
def	stripMetadata (self)
def	readComponent (self, component, parameters=None)
def	readFull (self, parameters=None)
def	read (self, component=None)
def	write (self, inMemoryDataset)
def	getImageCompressionSettings (self, recipeName)
def	validateWriteRecipes (cls, recipes)

Static Public Attributes
	supportedExtensions = frozenset({".fits", ".fits.gz", ".fits.fz", ".fz", ".fit"})
string	extension = ".fits"
	supportedWriteParameters = frozenset({"recipe"})
dictionary	unsupportedParameters = {}

Detailed Description

Specialisation for `~lsst.afw.image.Image` reading.

Definition at line 421 of file fitsExposure.py.

Member Function Documentation

getImageCompressionSettings()

def lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.getImageCompressionSettings (   self,   recipeName  )

inherited

Retrieve the relevant compression settings for this recipe.

Parameters
----------
recipeName : `str`
    Label associated with the collection of compression parameters
    to select.

Returns
-------
settings : `dict`
    The selected settings.

Definition at line 304 of file fitsExposure.py.

    def getImageCompressionSettings(self, recipeName):
        """Retrieve the relevant compression settings for this recipe.
 
        Parameters
        ----------
        recipeName : `str`
            Label associated with the collection of compression parameters
            to select.
 
        Returns
        -------
        settings : `dict`
            The selected settings.
        """
        # if no recipe has been provided and there is no default
        # return immediately
        if not recipeName:
            if "default" not in self.writeRecipes:
                return {}
            recipeName = "default"
 
        if recipeName not in self.writeRecipes:
            raise RuntimeError(f"Unrecognized recipe option given for compression: {recipeName}")
 
        recipe = self.writeRecipes[recipeName]
 
        # Set the seed based on dataId
        seed = hash(tuple(self.dataId.items())) % 2**31
        for plane in ("image", "mask", "variance"):
            if plane in recipe and "scaling" in recipe[plane]:
                scaling = recipe[plane]["scaling"]
                if "seed" in scaling and scaling["seed"] == 0:
                    scaling["seed"] = seed
 
        return recipe
 

metadata()

def lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.metadata (   self )

inherited

The metadata read from this file. It will be stripped as
components are extracted from it
(`lsst.daf.base.PropertyList`).

Definition at line 95 of file fitsExposure.py.

    def metadata(self):
        """The metadata read from this file. It will be stripped as
        components are extracted from it
        (`lsst.daf.base.PropertyList`).
        """
        if self._metadata is None:
            self._metadata = self.readMetadata()
        return self._metadata
 

read()

def lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.read (   self,   component = None  )

inherited

Read data from a file.

Parameters
----------
component : `str`, optional
    Component to read from the file. Only used if the `StorageClass`
    for reading differed from the `StorageClass` used to write the
    file.

Returns
-------
inMemoryDataset : `object`
    The requested data as a Python object. The type of object
    is controlled by the specific formatter.

Raises
------
ValueError
    Component requested but this file does not seem to be a concrete
    composite.
KeyError
    Raised when parameters passed with fileDescriptor are not
    supported.

Definition at line 242 of file fitsExposure.py.

    def read(self, component=None):
        """Read data from a file.
 
        Parameters
        ----------
        component : `str`, optional
            Component to read from the file. Only used if the `StorageClass`
            for reading differed from the `StorageClass` used to write the
            file.
 
        Returns
        -------
        inMemoryDataset : `object`
            The requested data as a Python object. The type of object
            is controlled by the specific formatter.
 
        Raises
        ------
        ValueError
            Component requested but this file does not seem to be a concrete
            composite.
        KeyError
            Raised when parameters passed with fileDescriptor are not
            supported.
        """
        fileDescriptor = self.fileDescriptor
        if fileDescriptor.readStorageClass != fileDescriptor.storageClass:
            if component == "metadata":
                self.stripMetadata()
                return self.metadata
            elif component is not None:
                return self.readComponent(component)
            else:
                raise ValueError("Storage class inconsistency ({} vs {}) but no"
                                 " component requested".format(fileDescriptor.readStorageClass.name,
                                                               fileDescriptor.storageClass.name))
        return self.readFull()
 

readComponent()

def lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.readComponent (   self,   component,   parameters = None  )

inherited

Read a component held by the Exposure.

Parameters
----------
component : `str`, optional
    Component to read from the file.
parameters : `dict`, optional
    If specified, a dictionary of slicing parameters that
    overrides those in ``fileDescriptor``.

Returns
-------
obj : component-dependent
    In-memory component object.

Raises
------
KeyError
    Raised if the requested component cannot be handled.

Reimplemented in lsst.obs.base._fitsRawFormatterBase.FitsRawFormatterBase.

Definition at line 145 of file fitsExposure.py.

    def readComponent(self, component, parameters=None):
        """Read a component held by the Exposure.
 
        Parameters
        ----------
        component : `str`, optional
            Component to read from the file.
        parameters : `dict`, optional
            If specified, a dictionary of slicing parameters that
            overrides those in ``fileDescriptor``.
 
        Returns
        -------
        obj : component-dependent
            In-memory component object.
 
        Raises
        ------
        KeyError
            Raised if the requested component cannot be handled.
        """
 
        # Metadata is handled explicitly elsewhere
        componentMap = {'wcs': ('readWcs', False, None),
                        'coaddInputs': ('readCoaddInputs', False, None),
                        'psf': ('readPsf', False, None),
                        'image': ('readImage', True, None),
                        'mask': ('readMask', True, None),
                        'variance': ('readVariance', True, None),
                        'photoCalib': ('readPhotoCalib', False, None),
                        'bbox': ('readBBox', True, None),
                        'dimensions': ('readBBox', True, None),
                        'xy0': ('readXY0', True, None),
                        # TODO: deprecate in DM-27170, remove in DM-27177
                        'filter': ('readFilter', False, None),
                        # TODO: deprecate in DM-27177, remove in DM-27811
                        'filterLabel': ('readFilterLabel', False, None),
                        'validPolygon': ('readValidPolygon', False, None),
                        'apCorrMap': ('readApCorrMap', False, None),
                        'visitInfo': ('readVisitInfo', False, None),
                        'transmissionCurve': ('readTransmissionCurve', False, None),
                        'detector': ('readDetector', False, None),
                        'exposureInfo': ('readExposureInfo', False, None),
                        'summaryStats': ('readComponent', False, ExposureInfo.KEY_SUMMARY_STATS),
                        }
        method, hasParams, componentName = componentMap.get(component, (None, False, None))
 
        if method:
            # This reader can read standalone Image/Mask files as well
            # when dealing with components.
            reader = self._readerClass(self.fileDescriptor.location.path)
            caller = getattr(reader, method, None)
 
            if caller:
                if parameters is None:
                    parameters = self.fileDescriptor.parameters
                if parameters is None:
                    parameters = {}
                self.fileDescriptor.storageClass.validateParameters(parameters)
 
                if componentName is None:
                    if hasParams and parameters:
                        thisComponent = caller(**parameters)
                    else:
                        thisComponent = caller()
                else:
                    thisComponent = caller(componentName)
 
                if component == "dimensions" and thisComponent is not None:
                    thisComponent = thisComponent.getDimensions()
                return thisComponent
        else:
            raise KeyError(f"Unknown component requested: {component}")
 

readFull()

def lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.readFull (   self,   parameters = None  )

inherited

Read the full Exposure object.

Parameters
----------
parameters : `dict`, optional
    If specified a dictionary of slicing parameters that overrides
    those in ``fileDescriptor``.

Returns
-------
exposure : `~lsst.afw.image.Exposure`
    Complete in-memory exposure.

Reimplemented in lsst.obs.base._fitsRawFormatterBase.FitsRawFormatterBase.

Definition at line 219 of file fitsExposure.py.

    def readFull(self, parameters=None):
        """Read the full Exposure object.
 
        Parameters
        ----------
        parameters : `dict`, optional
            If specified a dictionary of slicing parameters that overrides
            those in ``fileDescriptor``.
 
        Returns
        -------
        exposure : `~lsst.afw.image.Exposure`
            Complete in-memory exposure.
        """
        fileDescriptor = self.fileDescriptor
        if parameters is None:
            parameters = fileDescriptor.parameters
        if parameters is None:
            parameters = {}
        fileDescriptor.storageClass.validateParameters(parameters)
        reader = self._readerClass(fileDescriptor.location.path)
        return reader.read(**parameters)
 

readMetadata()

def lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.readMetadata (   self )

inherited

Read all header metadata directly into a PropertyList.

Returns
-------
metadata : `~lsst.daf.base.PropertyList`
    Header metadata.

Reimplemented in lsst.obs.decam.rawFormatter.DarkEnergyCameraRawFormatter.

Definition at line 104 of file fitsExposure.py.

    def readMetadata(self):
        """Read all header metadata directly into a PropertyList.
 
        Returns
        -------
        metadata : `~lsst.daf.base.PropertyList`
            Header metadata.
        """
        md = readMetadata(self.fileDescriptor.location.path)
        fix_header(md)
        return md
 

stripMetadata()

def lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.stripMetadata (   self )

inherited

Remove metadata entries that are parsed into components.

This is only called when just the metadata is requested; stripping
entries there forces code that wants other components to ask for those
components directly rather than trying to extract them from the
metadata manually, which is fragile.  This behavior is an intentional
change from Gen2.

Parameters
----------
metadata : `~lsst.daf.base.PropertyList`
    Header metadata, to be modified in-place.

Reimplemented in lsst.obs.base._fitsRawFormatterBase.FitsRawFormatterBase.

Definition at line 116 of file fitsExposure.py.

    def stripMetadata(self):
        """Remove metadata entries that are parsed into components.
 
        This is only called when just the metadata is requested; stripping
        entries there forces code that wants other components to ask for those
        components directly rather than trying to extract them from the
        metadata manually, which is fragile.  This behavior is an intentional
        change from Gen2.
 
        Parameters
        ----------
        metadata : `~lsst.daf.base.PropertyList`
            Header metadata, to be modified in-place.
        """
        # TODO: make sure this covers everything, by delegating to something
        # that doesn't yet exist in afw.image.ExposureInfo.
        from lsst.afw.image import bboxFromMetadata
        from lsst.afw.geom import makeSkyWcs
 
        # Protect against the metadata being missing
        try:
            bboxFromMetadata(self.metadata)  # always strips
        except LookupError:
            pass
        try:
            makeSkyWcs(self.metadata, strip=True)
        except Exception:
            pass
 

validateWriteRecipes()

def lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.validateWriteRecipes (   cls,   recipes  )

inherited

Validate supplied recipes for this formatter.

The recipes are supplemented with default values where appropriate.

TODO: replace this custom validation code with Cerberus (DM-11846)

Parameters
----------
recipes : `dict`
    Recipes to validate. Can be empty dict or `None`.

Returns
-------
validated : `dict`
    Validated recipes. Returns what was given if there are no
    recipes listed.

Raises
------
RuntimeError
    Raised if validation fails.

Definition at line 341 of file fitsExposure.py.

    def validateWriteRecipes(cls, recipes):
        """Validate supplied recipes for this formatter.
 
        The recipes are supplemented with default values where appropriate.
 
        TODO: replace this custom validation code with Cerberus (DM-11846)
 
        Parameters
        ----------
        recipes : `dict`
            Recipes to validate. Can be empty dict or `None`.
 
        Returns
        -------
        validated : `dict`
            Validated recipes. Returns what was given if there are no
            recipes listed.
 
        Raises
        ------
        RuntimeError
            Raised if validation fails.
        """
        # Schemas define what should be there, and the default values (and by
        # the default value, the expected type).
        compressionSchema = {
            "algorithm": "NONE",
            "rows": 1,
            "columns": 0,
            "quantizeLevel": 0.0,
        }
        scalingSchema = {
            "algorithm": "NONE",
            "bitpix": 0,
            "maskPlanes": ["NO_DATA"],
            "seed": 0,
            "quantizeLevel": 4.0,
            "quantizePad": 5.0,
            "fuzz": True,
            "bscale": 1.0,
            "bzero": 0.0,
        }
 
        if not recipes:
            # We can not insist on recipes being specified
            return recipes
 
        def checkUnrecognized(entry, allowed, description):
            """Check to see if the entry contains unrecognised keywords"""
            unrecognized = set(entry) - set(allowed)
            if unrecognized:
                raise RuntimeError(
                    f"Unrecognized entries when parsing image compression recipe {description}: "
                    f"{unrecognized}")
 
        validated = {}
        for name in recipes:
            checkUnrecognized(recipes[name], ["image", "mask", "variance"], name)
            validated[name] = {}
            for plane in ("image", "mask", "variance"):
                checkUnrecognized(recipes[name][plane], ["compression", "scaling"],
                                  f"{name}->{plane}")
 
                np = {}
                validated[name][plane] = np
                for settings, schema in (("compression", compressionSchema),
                                         ("scaling", scalingSchema)):
                    np[settings] = {}
                    if settings not in recipes[name][plane]:
                        for key in schema:
                            np[settings][key] = schema[key]
                        continue
                    entry = recipes[name][plane][settings]
                    checkUnrecognized(entry, schema.keys(), f"{name}->{plane}->{settings}")
                    for key in schema:
                        value = type(schema[key])(entry[key]) if key in entry else schema[key]
                        np[settings][key] = value
        return validated
 
 

write()

def lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.write (   self,   inMemoryDataset  )

inherited

Write a Python object to a file.

Parameters
----------
inMemoryDataset : `object`
    The Python object to store.

Reimplemented in lsst.obs.base._fitsRawFormatterBase.FitsRawFormatterBase.

Definition at line 280 of file fitsExposure.py.

    def write(self, inMemoryDataset):
        """Write a Python object to a file.
 
        Parameters
        ----------
        inMemoryDataset : `object`
            The Python object to store.
        """
        # Update the location with the formatter-preferred file extension
        self.fileDescriptor.location.updateExtension(self.extension)
        outputPath = self.fileDescriptor.location.path
 
        # check to see if we have a recipe requested
        recipeName = self.writeParameters.get("recipe")
        recipe = self.getImageCompressionSettings(recipeName)
        if recipe:
            # Can not construct a PropertySet from a hierarchical
            # dict but can update one.
            ps = PropertySet()
            ps.update(recipe)
            inMemoryDataset.writeFitsWithOptions(outputPath, options=ps)
        else:
            inMemoryDataset.writeFits(outputPath)
 

Member Data Documentation

extension

string lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.extension = ".fits"

staticinherited

Definition at line 86 of file fitsExposure.py.

supportedExtensions

lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.supportedExtensions = frozenset({".fits", ".fits.gz", ".fits.fz", ".fz", ".fit"})

staticinherited

Definition at line 85 of file fitsExposure.py.

supportedWriteParameters

lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.supportedWriteParameters = frozenset({"recipe"})

staticinherited

Definition at line 88 of file fitsExposure.py.

unsupportedParameters

dictionary lsst.obs.base.formatters.fitsExposure.FitsExposureFormatter.unsupportedParameters = {}

staticinherited

Definition at line 91 of file fitsExposure.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/0.2.1/Linux64/obs_base/21.0.0-27-gbbd0d29+ae871e0f33/python/lsst/obs/base/formatters/fitsExposure.py