lsst::afw::image::MaskedImageFitsReader Class Reference

A FITS reader class for MaskedImages and their components. More...

#include <MaskedImageFitsReader.h>

Public Member Functions
	MaskedImageFitsReader (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
	Construct a FITS reader object.
	MaskedImageFitsReader (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
	Construct a FITS reader object.
	MaskedImageFitsReader (fits::Fits *fitsFile)
	Construct a FITS reader object.
	MaskedImageFitsReader (MaskedImageFitsReader const &)=delete
	MaskedImageFitsReader (MaskedImageFitsReader &&)=delete
MaskedImageFitsReader &	operator= (MaskedImageFitsReader const &)=delete
MaskedImageFitsReader &	operator= (MaskedImageFitsReader &&)=delete
	~MaskedImageFitsReader () noexcept
lsst::geom::Box2I	readBBox (ImageOrigin origin=PARENT)
	Read the bounding box of the on-disk image.
lsst::geom::Point2I	readXY0 (lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT)
	Read the image origin from the on-disk image or a subimage thereof.
template<typename MaskPixelT >
Mask< MaskPixelT >	readMask (lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool allowUnsafe=false)
	Read the mask plane.
template<typename MaskPixelT >
ndarray::Array< MaskPixelT, 2, 2 >	readMaskArray (lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
	Read the mask plane.
template<typename ImagePixelT , typename MaskPixelT = MaskPixel, typename VariancePixelT = VariancePixel>
MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >	read (lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool needAllHdus=false, bool allowUnsafe=false)
	Read the full MaskedImage.
std::string	getFileName () const
	Return the name of the file this reader targets.
std::string	readImageDType () const
	Read a string describing the pixel type of the on-disk image plane.
std::string	readMaskDType () const
	Read a string describing the pixel type of the on-disk image plane.
std::string	readVarianceDType () const
	Read a string describing the pixel type of the on-disk image plane.
std::shared_ptr< daf::base::PropertyList >	readPrimaryMetadata ()
	Read the FITS header of one of the HDUs.
std::shared_ptr< daf::base::PropertyList >	readImageMetadata ()
	Read the FITS header of one of the HDUs.
std::shared_ptr< daf::base::PropertyList >	readMaskMetadata ()
	Read the FITS header of one of the HDUs.
std::shared_ptr< daf::base::PropertyList >	readVarianceMetadata ()
	Read the FITS header of one of the HDUs.
template<typename ImagePixelT >
Image< ImagePixelT >	readImage (lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
	Read the image plane.
template<typename ImagePixelT >
ndarray::Array< ImagePixelT, 2, 2 >	readImageArray (lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
	Read the image plane.
template<typename VariancePixelT >
Image< VariancePixelT >	readVariance (lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
	Read the variance plane.
template<typename VariancePixelT >
ndarray::Array< VariancePixelT, 2, 2 >	readVarianceArray (lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
	Read the variance plane.

Friends
class	ExposureFitsReader

Detailed Description

A FITS reader class for MaskedImages and their components.

Exception Safety

All MaskedImageFitsReader methods provide strong exception safety, but exceptions thrown by the internal fits::Fits object itself may change its status variable or HDU pointer; MaskedImageFitsReader guards against this by resetting those before any use of the Fits object.

Definition at line 41 of file MaskedImageFitsReader.h.

Constructor & Destructor Documentation

MaskedImageFitsReader() [1/5]

lsst::afw::image::MaskedImageFitsReader::MaskedImageFitsReader ( std::string const & fileName, int hdu = fits::DEFAULT_HDU )

explicit

Construct a FITS reader object.

Parameters

fileName	Name of a file to open.
hdu	HDU index for the image plane, where 0 is the primary HDU and DEFAULT_HDU is the first non-empty HDU.

Definition at line 46 of file MaskedImageFitsReader.cc.

                                                                               :
    _imageReader(fileName, hdu),
    _maskReader(nextHdu(_imageReader._fitsFile)),
    _varianceReader(nextHdu(_maskReader._fitsFile))
{}

MaskedImageFitsReader() [2/5]

lsst::afw::image::MaskedImageFitsReader::MaskedImageFitsReader ( fits::MemFileManager & manager, int hdu = fits::DEFAULT_HDU )

explicit

Construct a FITS reader object.

Parameters

manager	Memory block containing a FITS file.
hdu	HDU index for the image plane, where 0 is the primary HDU and DEFAULT_HDU is the first non-empty HDU.

Definition at line 52 of file MaskedImageFitsReader.cc.

                                                                                 :
    _imageReader(manager, hdu),
    _maskReader(nextHdu(_imageReader._fitsFile)),
    _varianceReader(nextHdu(_maskReader._fitsFile))
{}

MaskedImageFitsReader() [3/5]

lsst::afw::image::MaskedImageFitsReader::MaskedImageFitsReader ( fits::Fits * fitsFile )

explicit

Construct a FITS reader object.

Parameters

fitsFile

Pointer to a CFITSIO file object. Lifetime will not be managed by the Reader object.

Definition at line 58 of file MaskedImageFitsReader.cc.

                                                                :
    _imageReader(fitsFile),
    _maskReader(nextHdu(_imageReader._fitsFile)),
    _varianceReader(nextHdu(_maskReader._fitsFile))
{}

MaskedImageFitsReader() [4/5]

lsst::afw::image::MaskedImageFitsReader::MaskedImageFitsReader ( MaskedImageFitsReader const & )

delete

MaskedImageFitsReader() [5/5]

lsst::afw::image::MaskedImageFitsReader::MaskedImageFitsReader ( MaskedImageFitsReader && )

delete

~MaskedImageFitsReader()

lsst::afw::image::MaskedImageFitsReader::~MaskedImageFitsReader ( )

defaultnoexcept

Member Function Documentation

getFileName()

std::string lsst::afw::image::MaskedImageFitsReader::getFileName ( ) const

inline

Return the name of the file this reader targets.

Definition at line 230 of file MaskedImageFitsReader.h.

{ return _imageReader.getFileName(); }

operator=() [1/2]

MaskedImageFitsReader & lsst::afw::image::MaskedImageFitsReader::operator= ( MaskedImageFitsReader && )

delete

operator=() [2/2]

MaskedImageFitsReader & lsst::afw::image::MaskedImageFitsReader::operator= ( MaskedImageFitsReader const & )

delete

read()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

template MaskedImage< std::uint64_t, MaskPixel, VariancePixel > lsst::afw::image::MaskedImageFitsReader::read	(	lsst::geom::Box2I const &	bbox = lsst::geom::Box2I(),
		ImageOrigin	origin = PARENT,
		bool	conformMasks = false,
		bool	needAllHdus = false,
		bool	allowUnsafe = false )

Read the full MaskedImage.

Parameters

bbox	A bounding box used to defined a subimage, or an empty box (default) to read the whole image.
origin	Coordinate system convention for the given box.
conformMasks	If True, conform the global mask dict to match this file.
needAllHdus	If True, refuse to read the image if the mask or variance plane is not present (the image plane is always required).
allowUnsafe	Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

In Python, this templated method is wrapped with an additional dtype argument to provide the type to read (for the image plane). This defaults to the type of the on-disk image.

Definition at line 170 of file MaskedImageFitsReader.cc.

  {
    // When reading a standard Masked Image, we expect four HDUs:
    // * The primary (HDU 0) is empty;
    // * The first extension (HDU 1) contains the image data;
    // * The second extension (HDU 2) contains mask data;
    // * The third extension (HDU 3) contains the variance.
    //
    // If the image HDU is unreadable, we will throw.
    //
    // If the user has specified a non-default HDU, we load image data from
    // that HDU, but do not attempt to load mask/variance data; rather, log a
    // warning and return (blank) defaults.
    //
    // If the mask and/or variance is unreadable, we log a warning and return
    // (blank) defaults.
 
    LOG_LOGGER _log = LOG_GET("lsst.afw.image.MaskedImageFitsReader");
 
    enum class Hdu { Primary = 0, Image, Mask, Variance };
 
    // If the user has requested a non-default HDU and we require all HDUs, we fail.
    if (needAllHdus && _imageReader.getHdu() > static_cast<int>(Hdu::Image)) {
        throw LSST_EXCEPT(fits::FitsError, "Cannot read all HDUs starting from non-default");
    }
 
    auto image = std::make_shared<Image<ImagePixelT>>(_imageReader.read<ImagePixelT>(bbox, origin,
                                                                                     allowUnsafe));
    std::shared_ptr<Mask<MaskPixelT>> mask;
    std::shared_ptr<Image<VariancePixelT>> variance;
 
    // only read other planes if they're in their normal HDUs
    if (_imageReader.getHdu() == static_cast<int>(Hdu::Image)) {
        // Do not even try if we are missing the HDU
        if (_maskReader._fitsFile) {
            try {
                mask = std::make_shared<Mask<MaskPixelT>>(
                    _maskReader.read<MaskPixelT>(bbox, origin, conformMasks, allowUnsafe)
                );
            } catch (fits::FitsError& e) {
                if (needAllHdus) {
                    LSST_EXCEPT_ADD(e, "Reading Mask");
                    throw e;
                }
                LOGL_WARN(_log, "Mask unreadable (%s); using default", e.what());
                // By resetting the status we are able to read the next HDU (the variance).
                _maskReader._fitsFile->status = 0;
            }
        } else if (needAllHdus) {
            throw LSST_EXCEPT(pex::exceptions::NotFoundError, "No mask extensions found");
        }
        if (_varianceReader._fitsFile) {
            try {
                variance = std::make_shared<Image<VariancePixelT>>(
                    _varianceReader.read<VariancePixelT>(bbox, origin, allowUnsafe)
                );
            } catch (fits::FitsError& e) {
                if (needAllHdus) {
                    LSST_EXCEPT_ADD(e, "Reading Variance");
                    throw e;
                }
                LOGL_WARN(_log, "Variance unreadable (%s); using default", e.what());
                // By resetting the status we are able to read the next HDU (the variance).
                _varianceReader._fitsFile->status = 0;
            }
        } else if (needAllHdus) {
            throw LSST_EXCEPT(pex::exceptions::NotFoundError, "No variance extensions found");
        }
    }
    return MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>(image, mask, variance);
}

readBBox()

lsst::geom::Box2I lsst::afw::image::MaskedImageFitsReader::readBBox

(

ImageOrigin

origin = PARENT

)

Read the bounding box of the on-disk image.

Parameters

origin

Coordinate system convention for the returned box. If LOCAL, the returned box will always have a minimum of (0, 0).

Definition at line 72 of file MaskedImageFitsReader.cc.

                                                                {
    return _imageReader.readBBox(origin);
}

readImage()

template<typename ImagePixelT >

template Image< std::uint64_t > lsst::afw::image::MaskedImageFitsReader::readImage	(	lsst::geom::Box2I const &	bbox = lsst::geom::Box2I(),
		ImageOrigin	origin = PARENT,
		bool	allowUnsafe = false )

Read the image plane.

Parameters

bbox	A bounding box used to defined a subimage, or an empty box (default) to read the whole image.
origin	Coordinate system convention for the given box.
allowUnsafe	Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

In Python, this templated method is wrapped with an additional dtype argument to provide the type to read. This defaults to the type of the on-disk image.

Definition at line 131 of file MaskedImageFitsReader.cc.

                                                                      {
    return _imageReader.read<ImagePixelT>(bbox, origin, allowUnsafe);
}

readImageArray()

template<typename ImagePixelT >

template ndarray::Array< std::uint64_t, 2, 2 > lsst::afw::image::MaskedImageFitsReader::readImageArray	(	lsst::geom::Box2I const &	bbox = lsst::geom::Box2I(),
		ImageOrigin	origin = PARENT,
		bool	allowUnsafe = false )

Read the image plane.

Parameters

bbox	A bounding box used to defined a subimage, or an empty box (default) to read the whole image.
origin	Coordinate system convention for the given box.
allowUnsafe	Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

In Python, this templated method is wrapped with an additional dtype argument to provide the type to read. This defaults to the type of the on-disk image.

Definition at line 137 of file MaskedImageFitsReader.cc.

                                                                                          {
    return _imageReader.readArray<ImagePixelT>(bbox, origin, allowUnsafe);
}

readImageDType()

std::string lsst::afw::image::MaskedImageFitsReader::readImageDType

(

)

const

Read a string describing the pixel type of the on-disk image plane.

Returns

A string of the form [u](int|float)<bits> (e.g. "uint16", "float64").

Definition at line 66 of file MaskedImageFitsReader.cc.

{ return _imageReader.readDType(); }

readImageMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::image::MaskedImageFitsReader::readImageMetadata

(

)

Read the FITS header of one of the HDUs.

Definition at line 106 of file MaskedImageFitsReader.cc.

                                                                            {
    if (!_imageMetadata) {
        _imageMetadata = _imageReader.readMetadata();
        checkExtType(_imageReader, _imageMetadata, "IMAGE");
    }
    return _imageMetadata;
}

readMask()

template<typename MaskPixelT >

template Mask< MaskPixel > lsst::afw::image::MaskedImageFitsReader::readMask	(	lsst::geom::Box2I const &	bbox = lsst::geom::Box2I(),
		ImageOrigin	origin = PARENT,
		bool	conformMasks = false,
		bool	allowUnsafe = false )

Read the mask plane.

Parameters

bbox	A bounding box used to defined a subimage, or an empty box (default) to read the whole image.
origin	Coordinate system convention for the given box.
conformMasks	If True, conform the global mask dict to match this file.
allowUnsafe	Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

In Python, this templated method is wrapped with an additional dtype argument to provide the type to read. This defaults to the type of the on-disk image.

Definition at line 144 of file MaskedImageFitsReader.cc.

                                                                                      {
    return _maskReader.read<MaskPixelT>(bbox, origin, conformMasks, allowUnsafe);
}

readMaskArray()

template<typename MaskPixelT >

template ndarray::Array< MaskPixel, 2, 2 > lsst::afw::image::MaskedImageFitsReader::readMaskArray	(	lsst::geom::Box2I const &	bbox = lsst::geom::Box2I(),
		ImageOrigin	origin = PARENT,
		bool	allowUnsafe = false )

Read the mask plane.

Parameters

bbox	A bounding box used to defined a subimage, or an empty box (default) to read the whole image.
origin	Coordinate system convention for the given box.
allowUnsafe	Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

In Python, this templated method is wrapped with an additional dtype argument to provide the type to read. This defaults to the type of the on-disk image.

Definition at line 150 of file MaskedImageFitsReader.cc.

                                                                                        {
    return _maskReader.readArray<MaskPixelT>(bbox, origin, allowUnsafe);
}

readMaskDType()

std::string lsst::afw::image::MaskedImageFitsReader::readMaskDType

(

)

const

Read a string describing the pixel type of the on-disk image plane.

Returns

A string of the form [u](int|float)<bits> (e.g. "uint16", "float64").

Definition at line 68 of file MaskedImageFitsReader.cc.

{ return _maskReader.readDType(); }

readMaskMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::image::MaskedImageFitsReader::readMaskMetadata

(

)

Read the FITS header of one of the HDUs.

Definition at line 114 of file MaskedImageFitsReader.cc.

                                                                           {
    if (!_maskMetadata) {
        _maskReader.readMetadata();
        checkExtType(_maskReader, _maskMetadata, "MASK");
    }
    return _maskMetadata;
}

readPrimaryMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::image::MaskedImageFitsReader::readPrimaryMetadata

(

)

Read the FITS header of one of the HDUs.

Definition at line 100 of file MaskedImageFitsReader.cc.

                                                                              {
    auto fitsFile = _imageReader._fitsFile;
    fits::HduMoveGuard guard(*fitsFile, 0);
    return fits::readMetadata(*fitsFile, /*strip=*/true);
}

readVariance()

template<typename VariancePixelT >

template Image< VariancePixel > lsst::afw::image::MaskedImageFitsReader::readVariance	(	lsst::geom::Box2I const &	bbox = lsst::geom::Box2I(),
		ImageOrigin	origin = PARENT,
		bool	allowUnsafe = false )

Read the variance plane.

Parameters

bbox	A bounding box used to defined a subimage, or an empty box (default) to read the whole image.
origin	Coordinate system convention for the given box.
allowUnsafe	Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

In Python, this templated method is wrapped with an additional dtype argument to provide the type to read. This defaults to the type of the on-disk image.

Definition at line 157 of file MaskedImageFitsReader.cc.

                                                                                                {
    return _varianceReader.read<VariancePixelT>(bbox, origin, allowUnsafe);
}

readVarianceArray()

template<typename VariancePixelT >

template ndarray::Array< VariancePixel, 2, 2 > lsst::afw::image::MaskedImageFitsReader::readVarianceArray	(	lsst::geom::Box2I const &	bbox = lsst::geom::Box2I(),
		ImageOrigin	origin = PARENT,
		bool	allowUnsafe = false )

Read the variance plane.

Parameters

bbox	A bounding box used to defined a subimage, or an empty box (default) to read the whole image.
origin	Coordinate system convention for the given box.
allowUnsafe	Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

In Python, this templated method is wrapped with an additional dtype argument to provide the type to read. This defaults to the type of the on-disk image.

Definition at line 163 of file MaskedImageFitsReader.cc.

                                                                                                {
    return _varianceReader.readArray<VariancePixelT>(bbox, origin, allowUnsafe);
}

readVarianceDType()

std::string lsst::afw::image::MaskedImageFitsReader::readVarianceDType

(

)

const

Read a string describing the pixel type of the on-disk image plane.

Returns

A string of the form [u](int|float)<bits> (e.g. "uint16", "float64").

Definition at line 70 of file MaskedImageFitsReader.cc.

{ return _varianceReader.readDType(); }

readVarianceMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::image::MaskedImageFitsReader::readVarianceMetadata

(

)

Read the FITS header of one of the HDUs.

Definition at line 122 of file MaskedImageFitsReader.cc.

                                                                               {
    if (!_varianceMetadata) {
        _varianceReader.readMetadata();
        checkExtType(_varianceReader, _varianceMetadata, "VARIANCE");
    }
    return _varianceMetadata;
}

readXY0()

lsst::geom::Point2I lsst::afw::image::MaskedImageFitsReader::readXY0	(	lsst::geom::Box2I const &	bbox = lsst::geom::Box2I(),
		ImageOrigin	origin = PARENT )

Read the image origin from the on-disk image or a subimage thereof.

Parameters

bbox	A bounding box used to defined a subimage, or an empty box (default) to use the whole image.
origin	Coordinate system convention for the given box. Ignored if bbox is empty.

Definition at line 76 of file MaskedImageFitsReader.cc.

                                                                                             {
    return _imageReader.readXY0(bbox, origin);
}

Friends And Related Symbol Documentation

ExposureFitsReader

friend class ExposureFitsReader

friend

Definition at line 234 of file MaskedImageFitsReader.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/include/lsst/afw/image/MaskedImageFitsReader.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/src/image/MaskedImageFitsReader.cc