File MaskedImage.h¶

namespace lsst

Class for a simple mapping implementing a generic AstrometryTransform.

Remove all non-astronomical counts from the Chunk Exposure’s pixels.

Forward declarations for lsst::utils::Cache

For details on the Cache class, see the Cache.h file.

It uses a template rather than a pointer so that the derived classes can use the specifics of the transform. The class simplePolyMapping overloads a few routines.

A base class for image defects

Numeric constants used by the Integrate.h integrator routines.

Compute Image Statistics

Note: Gauss-Kronrod-Patterson quadrature coefficients for use in quadpack routine qng. These coefficients were calculated with 101 decimal digit arithmetic by L. W. Fullerton, Bell Labs, Nov 1981.

Note: The Statistics class itself can only handle lsst::afw::image::MaskedImage() types. The philosophy has been to handle other types by making them look like lsst::afw::image::MaskedImage() and reusing that code. Users should have no need to instantiate a Statistics object directly, but should use the overloaded makeStatistics() factory functions.

namespace afw

namespace image

Functions

template<typename ImagePixelT, typename MaskPixelT, typename VariancePixelT> MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT> *makeMaskedImage(typename std::shared_ptr<Image<ImagePixelT>> image, typename std::shared_ptr<Mask<MaskPixelT>> mask = Mask<MaskPixelT>(), typename std::shared_ptr<Image<VariancePixelT>> variance = Image<VariancePixelT>())¶

Parameters

image: image
mask: mask
variance: variance

A function to return a MaskedImage of the correct type (cf. std::make_pair)

template<typename ImagePixelT1, typename ImagePixelT2> bool imagesOverlap(MaskedImage<ImagePixelT1, MaskPixel, VariancePixel> const &image1, MaskedImage<ImagePixelT2, MaskPixel, VariancePixel> const &image2)¶: Return true if the pixels for two masked images (image, variance or mask plane) overlap in memory.

template<typename ImagePixelT, typename MaskPixelT = lsst::afw::image::MaskPixel, typename VariancePixelT = lsst::afw::image::VariancePixel> class MaskedImage

#include <MaskedImage.h>

A class to manipulate images, masks, and variance as a single object.

Public Types

typedef std::shared_ptr<image::Image<ImagePixelT>> ImagePtr: shared pointer to the Image

typedef std::shared_ptr<image::Mask<MaskPixelT>> MaskPtr: shared pointer to the Mask

typedef std::shared_ptr<image::Image<VariancePixelT>> VariancePtr: shared pointer to the variance Image

typedef Mask<MaskPixelT>::MaskPlaneDict MaskPlaneDict: The Mask’s MaskPlaneDict.

typedef lsst::afw::image::Image<VariancePixelT> Variance

typedef lsst::afw::image::Image<ImagePixelT> Image

typedef lsst::afw::image::Mask<MaskPixelT> Mask

typedef detail::MaskedImage_tag image_category

typedef lsst::afw::image::pixel::Pixel<ImagePixelT, MaskPixelT, VariancePixelT> Pixel: A Pixel in the MaskedImage.

typedef lsst::afw::image::pixel::SinglePixel<ImagePixelT, MaskPixelT, VariancePixelT> SinglePixel: A single Pixel of the same type as those in the MaskedImage.

typedef MaskedImageIterator<typename Image::iterator, typename Mask::iterator, typename Variance::iterator> iterator

typedef const_MaskedImageIterator<typename Image::iterator, typename Mask::iterator, typename Variance::iterator> const_iterator

typedef MaskedImageIterator<typename Image::reverse_iterator, typename Mask::reverse_iterator, typename Variance::reverse_iterator> reverse_iterator

typedef MaskedImageIterator<typename Image::x_iterator, typename Mask::x_iterator, typename Variance::x_iterator> x_iterator: An iterator to a row of a MaskedImage.

typedef const_MaskedImageIterator<typename Image::x_iterator, typename Mask::x_iterator, typename Variance::x_iterator> const_x_iterator: A const_iterator to a row of a MaskedImage.

typedef x_iterator fast_iterator: A fast STL compliant iterator for contiguous images N.b. The order of pixel access is undefined

typedef MaskedImageIterator<typename Image::y_iterator, typename Mask::y_iterator, typename Variance::y_iterator> y_iterator: An iterator to a column of a MaskedImage.

typedef const_MaskedImageIterator<typename Image::y_iterator, typename Mask::y_iterator, typename Variance::y_iterator> const_y_iterator: A const_iterator to a column of a MaskedImage.

typedef MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator> xy_locator: A locator for a MaskedImage.

typedef const_MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator> const_xy_locator: A const_locator for a MaskedImage.

typedef MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>::x_iterator xy_x_iterator: an x_iterator associated with an xy_locator

typedef MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>::y_iterator xy_y_iterator: an y_iterator associated with an xy_locator

Public Functions

MaskedImage(unsigned int width, unsigned int height, MaskPlaneDict const &planeDict = MaskPlaneDict())

Construct from a supplied dimensions. The Image, Mask, and Variance will be set to zero

Parameters

width: number of columns
height: number of rows
planeDict: Make Mask conform to this mask layout (ignore if empty)

MaskedImage(lsst::geom::Extent2I const &dimensions = lsst::geom::Extent2I(), MaskPlaneDict const &planeDict = MaskPlaneDict())

Construct from a supplied dimensions. The Image, Mask, and Variance will be set to zero

Parameters

dimensions: Number of columns, rows in image
planeDict: Make Mask conform to this mask layout (ignore if empty)

MaskedImage(ImagePtr image, MaskPtr mask = MaskPtr(), VariancePtr variance = VariancePtr())

Construct from a supplied Image and optional Mask and Variance. The Mask and Variance will be set to zero if omitted

Parameters

image: Image
mask: Mask
variance: Variance Mask

MaskedImage(lsst::geom::Box2I const &bbox, MaskPlaneDict const &planeDict = MaskPlaneDict())

Create an MaskedImage of the specified size

The Image, Mask, and Variance will be set to zero

Note

Many lsst::afw::image and lsst::afw::math objects define a dimensions member which may be conveniently used to make objects of an appropriate size

Parameters

bbox: dimensions of image: width x height
planeDict: Make Mask conform to this mask layout (ignore if empty)

MaskedImage(std::string const &fileName, std::shared_ptr<daf::base::PropertySet> metadata = std::shared_ptr<daf::base::PropertySet>(), lsst::geom::Box2I const &bbox = lsst::geom::Box2I(), ImageOrigin origin = PARENT, bool conformMasks = false, bool needAllHdus = false, std::shared_ptr<daf::base::PropertySet> imageMetadata = std::shared_ptr<daf::base::PropertySet>(), std::shared_ptr<daf::base::PropertySet> maskMetadata = std::shared_ptr<daf::base::PropertySet>(), std::shared_ptr<daf::base::PropertySet> varianceMetadata = std::shared_ptr<daf::base::PropertySet>(), bool allowUnsafe = false)

Construct a MaskedImage by reading a regular FITS file.

Parameters

[in] fileName: File to read.
[inout] metadata: Metadata read from the primary HDU header.
[in] bbox: If non-empty, read only the pixels within the bounding box.
[in] origin: Coordinate system of the bounding box; if PARENT, the bounding box should take into account the xy0 saved with the image.
[in] conformMasks: If true, make Mask conform to the mask layout in the file.
[in] needAllHdus: If true, throw fits::FitsError if the mask and/or variance plane is missing. If false, silently initialize them to zero.
[inout] imageMetadata: Metadata read from the image HDU header.
[inout] maskMetadata: Metadata read from the mask HDU header.
[inout] varianceMetadata: Metadata read from the variance HDU header.
[in] allowUnsafe: Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

MaskedImage(fits::MemFileManager &manager, std::shared_ptr<daf::base::PropertySet> metadata = std::shared_ptr<daf::base::PropertySet>(), lsst::geom::Box2I const &bbox = lsst::geom::Box2I(), ImageOrigin origin = PARENT, bool conformMasks = false, bool needAllHdus = false, std::shared_ptr<daf::base::PropertySet> imageMetadata = std::shared_ptr<daf::base::PropertySet>(), std::shared_ptr<daf::base::PropertySet> maskMetadata = std::shared_ptr<daf::base::PropertySet>(), std::shared_ptr<daf::base::PropertySet> varianceMetadata = std::shared_ptr<daf::base::PropertySet>(), bool allowUnsafe = false)

Construct a MaskedImage by reading a FITS image in memory.

Parameters

[in] manager: An object that manages the memory buffer to read.
[inout] metadata: Metadata read from the primary HDU header.
[in] bbox: If non-empty, read only the pixels within the bounding box.
[in] origin: Coordinate system of the bounding box; if PARENT, the bounding box should take into account the xy0 saved with the image.
[in] conformMasks: If true, make Mask conform to the mask layout in the file.
[in] needAllHdus: If true, throw fits::FitsError if the mask and/or variance plane is missing. If false, silently initialize them to zero.
[inout] imageMetadata: Metadata read from the image HDU header.
[inout] maskMetadata: Metadata read from the mask HDU header.
[inout] varianceMetadata: Metadata read from the variance HDU header.
[in] allowUnsafe: Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

MaskedImage(fits::Fits &fitsfile, std::shared_ptr<daf::base::PropertySet> metadata = std::shared_ptr<daf::base::PropertySet>(), lsst::geom::Box2I const &bbox = lsst::geom::Box2I(), ImageOrigin origin = PARENT, bool conformMasks = false, bool needAllHdus = false, std::shared_ptr<daf::base::PropertySet> imageMetadata = std::shared_ptr<daf::base::PropertySet>(), std::shared_ptr<daf::base::PropertySet> maskMetadata = std::shared_ptr<daf::base::PropertySet>(), std::shared_ptr<daf::base::PropertySet> varianceMetadata = std::shared_ptr<daf::base::PropertySet>(), bool allowUnsafe = false)

Construct a MaskedImage from an already-open FITS object.

Parameters

[in] fitsfile: A FITS object to read from. Current HDU is ignored.
[inout] metadata: Metadata read from the primary HDU header.
[in] bbox: If non-empty, read only the pixels within the bounding box.
[in] origin: Coordinate system of the bounding box; if PARENT, the bounding box should take into account the xy0 saved with the image.
[in] conformMasks: If true, make Mask conform to the mask layout in the file.
[in] needAllHdus: If true, throw fits::FitsError if the mask and/or variance plane is missing. If false, silently initialize them to zero.
[inout] imageMetadata: Metadata read from the image HDU header.
[inout] maskMetadata: Metadata read from the mask HDU header.
[inout] varianceMetadata: Metadata read from the variance HDU header.
[in] allowUnsafe: Permit reading into the requested pixel type even when on-disk values may overflow or truncate.

MaskedImage(MaskedImage const &rhs, bool const deep = false)

Copy constructor; shallow, unless deep is true.

Parameters

rhs: Image to copy
deep: Make deep copy?

MaskedImage(MaskedImage &&rhs)

MaskedImage(MaskedImage const &rhs, lsst::geom::Box2I const &bbox, ImageOrigin const origin = PARENT, bool const deep = false)

Copy constructor of the pixels specified by bbox; shallow, unless deep is true.

Parameters

rhs: MaskedImage to copy
bbox: Specify desired region
origin: Specify the coordinate system of the bbox
deep: If false, new ImageBase shares storage with rhs; if true make a new, standalone, MaskedImage

template<typename OtherPixelT> MaskedImage(MaskedImage<OtherPixelT, MaskPixelT, VariancePixelT> const &rhs, const bool deep)

Parameters

rhs: Input image
deep: Must be true; needed to disambiguate

generalised copy constructor; defined here in the header so that the compiler can instantiate N(N-1)/2 conversions between N ImageBase types.

We only support converting the Image part

MaskedImage &operator=(MaskedImage const &rhs)

Make the lhs use the rhs’s pixels

If you are copying a scalar value, a simple lhs = scalar; is OK, but this is probably not the function that you want to use with an image. To copy pixel values from the rhs use assign(rhs)

Parameters

rhs: Right hand side

MaskedImage &operator=(MaskedImage &&rhs)

virtual ~MaskedImage()

void swap(MaskedImage &rhs)

MaskedImage &operator=(Pixel const &rhs): Set the pixels in the MaskedImage to the rhs.

MaskedImage &operator=(SinglePixel const &rhs): Set the pixels in the MaskedImage to the rhs.

MaskedImage subset(lsst::geom::Box2I const &bbox, ImageOrigin origin = PARENT) const

Return a subimage corresponding to the given box.

This method is wrapped as

getitem in Python.

Return

A subimage view into this.

Parameters

bbox: Bounding box of the subimage returned.
origin: Origin bbox is rleative to; PARENT accounts for xy0, LOCAL does not.

Note: This method permits mutable views to be obtained from const references to images (just as the copy constructor does). This is an intrinsic flaw in Image’s design.

MaskedImage operator[](lsst::geom::Box2I const &bbox) const: Return a subimage corresponding to the given box (interpreted as PARENT coordinates).

MaskedImage &operator<<=(MaskedImage const &rhs)

Copy the pixels from the rhs to the lhs

Note: operator=() is not equivalent to this command

void assign(MaskedImage const &rhs, lsst::geom::Box2I const &bbox = lsst::geom::Box2I(), ImageOrigin origin = PARENT)

Copy pixels from another masked image to a specified subregion of this masked image.

Parameters

[in] rhs: source image whose pixels are to be copied into this image (the destination)
[in] bbox: subregion of this image to set; if empty (the default) then all pixels are set
[in] origin: origin of bbox: if PARENT then the lower left pixel of this image is at xy0 if LOCAL then the lower left pixel of this image is at 0,0

Exceptions

lsst::pex::exceptions::LengthError: if the dimensions of rhs and the specified subregion of this image do not match.

MaskedImage &operator+=(ImagePixelT const rhs): Add a scalar rhs to a MaskedImage.

MaskedImage &operator+=(MaskedImage const &rhs)

Add a MaskedImage rhs to a MaskedImage

The image and variances are added; the masks are ORd together

Note: The pixels in the two images are taken to be independent. There is a Pixel operation (plus) which models the covariance, but this is not (yet?) available as full-MaskedImage operators

MaskedImage &operator+=(lsst::afw::image::Image<ImagePixelT> const &rhs)

MaskedImage &operator+=(lsst::afw::math::Function2<double> const &function)

void scaledPlus(double const c, MaskedImage const &rhs)

Add a scaled MaskedImage c*rhs to a MaskedImage

The image and variances are added; the masks are ORd together

Note: The pixels in the two images are taken to be independent. There is a Pixel operation (plus) which models the covariance, but this is not (yet?) available as full-MaskedImage operators

MaskedImage &operator-=(ImagePixelT const rhs): Subtract a scalar rhs from a MaskedImage.

MaskedImage &operator-=(MaskedImage const &rhs)

Subtract a MaskedImage rhs from a MaskedImage

The images are subtracted; the masks are ORd together; and the variances are added

Note: the pixels in the two images are taken to be independent

MaskedImage &operator-=(lsst::afw::image::Image<ImagePixelT> const &rhs)

MaskedImage &operator-=(lsst::afw::math::Function2<double> const &function)

void scaledMinus(double const c, MaskedImage const &rhs)

Subtract a scaled MaskedImage c*rhs from a MaskedImage

The images are subtracted; the masks are ORd together; and the variances are added

Note: the pixels in the two images are taken to be independent

MaskedImage &operator*=(ImagePixelT const rhs)

MaskedImage &operator*=(MaskedImage const &rhs)

MaskedImage &operator*=(lsst::afw::image::Image<ImagePixelT> const &rhs)

void scaledMultiplies(double const c, MaskedImage const &rhs)

MaskedImage &operator/=(ImagePixelT const rhs)

MaskedImage &operator/=(MaskedImage const &rhs)

MaskedImage &operator/=(lsst::afw::image::Image<ImagePixelT> const &rhs)

void scaledDivides(double const c, MaskedImage const &rhs)

void writeFits(std::string const &fileName, std::shared_ptr<daf::base::PropertySet const> metadata = std::shared_ptr<daf::base::PropertySet const>(), std::shared_ptr<daf::base::PropertySet const> imageMetadata = std::shared_ptr<daf::base::PropertySet const>(), std::shared_ptr<daf::base::PropertySet const> maskMetadata = std::shared_ptr<daf::base::PropertySet const>(), std::shared_ptr<daf::base::PropertySet const> varianceMetadata = std::shared_ptr<daf::base::PropertySet const>()) const

Write a MaskedImage to a regular FITS file.