lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > Class Template Reference

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

#include <MaskedImage.h>

Classes
class	const_MaskedImageIterator
	An const iterator to the MaskedImage. More...
class	const_MaskedImageLocator
	A const locator for the MaskedImage. More...
struct	ImageTypeFactory
	A templated class to return this classes' type (present in Image/Mask/MaskedImage) More...
class	MaskedImageIterator
	An iterator to the MaskedImage. More...
class	MaskedImageIteratorBase
	The base class for MaskedImageIterators (const and non-const) More...
class	MaskedImageLocator
	A locator for the MaskedImage. More...
class	MaskedImageLocatorBase
	The base class for MaskedImageLocators (const and non-const) More...

Public Types
using	ImagePtr = std::shared_ptr<image::Image<ImagePixelT>>
	shared pointer to the Image
using	MaskPtr = std::shared_ptr<image::Mask<MaskPixelT>>
	shared pointer to the Mask
using	VariancePtr = std::shared_ptr<image::Image<VariancePixelT>>
	shared pointer to the variance Image
using	MaskPlaneDict = typename Mask<MaskPixelT>::MaskPlaneDict
	The Mask's MaskPlaneDict.
using	Variance = lsst::afw::image::Image<VariancePixelT>
using	Image = lsst::afw::image::Image<ImagePixelT>
using	Mask = lsst::afw::image::Mask<MaskPixelT>
using	image_category = detail::MaskedImage_tag
using	Pixel = lsst::afw::image::pixel::Pixel<ImagePixelT, MaskPixelT, VariancePixelT>
	A Pixel in the MaskedImage.
using	SinglePixel = lsst::afw::image::pixel::SinglePixel<ImagePixelT, MaskPixelT, VariancePixelT>
	A single Pixel of the same type as those in the MaskedImage.
using	iterator = MaskedImageIterator<typename Image::iterator, typename Mask::iterator, typename Variance::iterator>
using	const_iterator = const_MaskedImageIterator<typename Image::iterator, typename Mask::iterator, typename Variance::iterator>
using	reverse_iterator = MaskedImageIterator<typename Image::reverse_iterator, typename Mask::reverse_iterator, typename Variance::reverse_iterator>
using	x_iterator = MaskedImageIterator<typename Image::x_iterator, typename Mask::x_iterator, typename Variance::x_iterator>
	An iterator to a row of a MaskedImage.
using	const_x_iterator = const_MaskedImageIterator<typename Image::x_iterator, typename Mask::x_iterator, typename Variance::x_iterator>
	A const_iterator to a row of a MaskedImage.
using	fast_iterator = x_iterator
	A fast STL compliant iterator for contiguous images N.b.
using	y_iterator = MaskedImageIterator<typename Image::y_iterator, typename Mask::y_iterator, typename Variance::y_iterator>
	An iterator to a column of a MaskedImage.
using	const_y_iterator = const_MaskedImageIterator<typename Image::y_iterator, typename Mask::y_iterator, typename Variance::y_iterator>
	A const_iterator to a column of a MaskedImage.
using	xy_locator = MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>
	A locator for a MaskedImage.
using	const_xy_locator = const_MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>
	A const_locator for a MaskedImage.
using	xy_x_iterator = typename MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>::x_iterator
	an x_iterator associated with an xy_locator
using	xy_y_iterator = typename MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>::y_iterator
	an y_iterator associated with an xy_locator

Public Member Functions
	MaskedImage (unsigned int width, unsigned int height, MaskPlaneDict const &planeDict=MaskPlaneDict())
	Construct from a supplied dimensions.
	MaskedImage (lsst::geom::Extent2I const &dimensions=lsst::geom::Extent2I(), MaskPlaneDict const &planeDict=MaskPlaneDict())
	Construct from a supplied dimensions.
	MaskedImage (ImagePtr image, MaskPtr mask=MaskPtr(), VariancePtr variance=VariancePtr())
	Construct from a supplied Image and optional Mask and Variance.
	MaskedImage (lsst::geom::Box2I const &bbox, MaskPlaneDict const &planeDict=MaskPlaneDict())
	Create an MaskedImage of the specified size.
	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.
	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.
	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.
	MaskedImage (MaskedImage const &rhs, bool const deep=false)
	Copy constructor; shallow, unless deep is true.
	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.
template<typename OtherPixelT >
	MaskedImage (MaskedImage< OtherPixelT, MaskPixelT, VariancePixelT > const &rhs, const bool deep)
	generalised copy constructor; defined here in the header so that the compiler can instantiate N(N-1)/2 conversions between N ImageBase types.
MaskedImage &	operator= (MaskedImage const &rhs)
	Make the lhs use the rhs's pixels.
MaskedImage &	operator= (MaskedImage &&rhs)
virtual	~MaskedImage ()=default
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.
MaskedImage	operator[] (lsst::geom::Box2I const &bbox) const
	Return a subimage corresponding to the given box (interpreted as PARENT coordinates).
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.
MaskedImage &	operator+= (ImagePixelT const rhs)
	Add a scalar rhs to a MaskedImage.
MaskedImage &	operator+= (MaskedImage const &rhs)
	Add a MaskedImage rhs to a MaskedImage.
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.
MaskedImage &	operator-= (ImagePixelT const rhs)
	Subtract a scalar rhs from a MaskedImage.
MaskedImage &	operator-= (MaskedImage const &rhs)
	Subtract a MaskedImage rhs from a MaskedImage.
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.
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.
void	writeFits (fits::MemFileManager &manager, 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 FITS RAM file.
void	writeFits (fits::Fits &fitsfile, 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 FITS file.
void	writeFits (std::string const &fileName, fits::ImageWriteOptions const &imageOptions, fits::ImageWriteOptions const &maskOptions, fits::ImageWriteOptions const &varianceOptions, std::shared_ptr< daf::base::PropertySet const > metadata=nullptr, std::shared_ptr< daf::base::PropertySet const > imageMetadata=nullptr, std::shared_ptr< daf::base::PropertySet const > maskMetadata=nullptr, std::shared_ptr< daf::base::PropertySet const > varianceMetadata=nullptr) const
	Write a MaskedImage to a FITS file.
void	writeFits (fits::MemFileManager &manager, fits::ImageWriteOptions const &imageOptions, fits::ImageWriteOptions const &maskOptions, fits::ImageWriteOptions const &varianceOptions, std::shared_ptr< daf::base::PropertySet const > metadata=nullptr, std::shared_ptr< daf::base::PropertySet const > imageMetadata=nullptr, std::shared_ptr< daf::base::PropertySet const > maskMetadata=nullptr, std::shared_ptr< daf::base::PropertySet const > varianceMetadata=nullptr) const
	Write a MaskedImage to a FITS file.
void	writeFits (fits::Fits &fitsfile, fits::ImageWriteOptions const &imageOptions, fits::ImageWriteOptions const &maskOptions, fits::ImageWriteOptions const &varianceOptions, std::shared_ptr< daf::base::PropertySet const > metadata=nullptr, std::shared_ptr< daf::base::PropertySet const > imageMetadata=nullptr, std::shared_ptr< daf::base::PropertySet const > maskMetadata=nullptr, std::shared_ptr< daf::base::PropertySet const > varianceMetadata=nullptr) const
	Write a MaskedImage to a FITS file.
ImagePtr	getImage () const
	Return a (shared_ptr to) the MaskedImage's image.
void	setImage (Image const &other)
	Set the image plane's pixel values to those of another Image.
MaskPtr	getMask () const
	Return a (shared_ptr to) the MaskedImage's mask.
void	setMask (Mask const &other)
	Set the mask plane's pixel values to those of another Mask.
void	setVariance (Variance const &other)
	Set the variance plane's pixel values to those of another Image.
VariancePtr	getVariance () const
	Return a (shared_ptr to) the MaskedImage's variance.
int	getWidth () const
	Return the number of columns in the image.
int	getHeight () const
	Return the number of rows in the image.
lsst::geom::Extent2I	getDimensions () const
lsst::geom::Box2I	getBBox (ImageOrigin const origin=PARENT) const
int	getX0 () const
	Return the image's column-origin.
int	getY0 () const
	Return the image's row-origin.
lsst::geom::Point2I	getXY0 () const
	Return the image's origin.
void	setXY0 (int const x0, int const y0)
	Set the MaskedImage's origin.
void	setXY0 (lsst::geom::Point2I const origin)
	Set the MaskedImage's origin.
double	indexToPosition (double ind, lsst::afw::image::xOrY const xy) const
	Convert image index to image position (see Image::indexToPosition)
std::pair< int, double >	positionToIndex (double const pos, lsst::afw::image::xOrY const xy) const
	Convert image position to index (see Image::positionToIndex)
iterator	begin () const
	Return an iterator to the start of the image.
iterator	end () const
	Return an iterator to the end of the image.
iterator	at (int const x, int const y) const
	Return an iterator at the point (x, y)
reverse_iterator	rbegin () const
	Return a reverse_iterator to the start of the image.
reverse_iterator	rend () const
	Return a reverse_iterator to the end of the image.
fast_iterator	begin (bool contiguous) const
	Fast iterators to contiguous images.
fast_iterator	end (bool contiguous) const
	Return a fast iterator to the end of the image, which must be contiguous Note that the order in which pixels are visited is undefined.
x_iterator	row_begin (int y) const
	Return an x_iterator to the start of the image.
x_iterator	row_end (int y) const
	Return an x_iterator to the end of the image.
x_iterator	x_at (int x, int y) const
	Return an x_iterator at the point (x, y)
y_iterator	col_begin (int x) const
	Return an y_iterator to the start of the image.
y_iterator	col_end (int x) const
	Return an y_iterator to the end of the image.
y_iterator	y_at (int x, int y) const
	Return an y_iterator at the point (x, y)
xy_locator	xy_at (int x, int y) const
	Return an xy_locator at the point (x, y)

Static Public Member Functions
static MaskedImage	readFits (std::string const &filename)
	Read a MaskedImage from a regular FITS file.
static MaskedImage	readFits (fits::MemFileManager &manager)
	Read a MaskedImage from a FITS RAM file.

Detailed Description

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

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

Definition at line 74 of file MaskedImage.h.

Member Typedef Documentation

const_iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::const_iterator = const_MaskedImageIterator<typename Image::iterator, typename Mask::iterator, typename Variance::iterator>

Definition at line 532 of file MaskedImage.h.

const_x_iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::const_x_iterator = const_MaskedImageIterator<typename Image::x_iterator, typename Mask::x_iterator, typename Variance::x_iterator>

A const_iterator to a row of a MaskedImage.

Definition at line 543 of file MaskedImage.h.

const_xy_locator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::const_xy_locator = const_MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>

A const_locator for a MaskedImage.

Definition at line 556 of file MaskedImage.h.

const_y_iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::const_y_iterator = const_MaskedImageIterator<typename Image::y_iterator, typename Mask::y_iterator, typename Variance::y_iterator>

A const_iterator to a column of a MaskedImage.

Definition at line 551 of file MaskedImage.h.

fast_iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::fast_iterator = x_iterator

A fast STL compliant iterator for contiguous images N.b.

The order of pixel access is undefined

Definition at line 547 of file MaskedImage.h.

Image

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::Image = lsst::afw::image::Image<ImagePixelT>

Definition at line 86 of file MaskedImage.h.

image_category

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::image_category = detail::MaskedImage_tag

Definition at line 89 of file MaskedImage.h.

ImagePtr

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::ImagePtr = std::shared_ptr<image::Image<ImagePixelT>>

shared pointer to the Image

Definition at line 77 of file MaskedImage.h.

iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::iterator = MaskedImageIterator<typename Image::iterator, typename Mask::iterator, typename Variance::iterator>

Definition at line 530 of file MaskedImage.h.

Mask

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::Mask = lsst::afw::image::Mask<MaskPixelT>

Definition at line 87 of file MaskedImage.h.

MaskPlaneDict

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskPlaneDict = typename Mask<MaskPixelT>::MaskPlaneDict

The Mask's MaskPlaneDict.

Definition at line 83 of file MaskedImage.h.

MaskPtr

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskPtr = std::shared_ptr<image::Mask<MaskPixelT>>

shared pointer to the Mask

Definition at line 79 of file MaskedImage.h.

Pixel

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::Pixel = lsst::afw::image::pixel::Pixel<ImagePixelT, MaskPixelT, VariancePixelT>

A Pixel in the MaskedImage.

Definition at line 112 of file MaskedImage.h.

reverse_iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::reverse_iterator = MaskedImageIterator<typename Image::reverse_iterator, typename Mask::reverse_iterator, typename Variance::reverse_iterator>

Definition at line 534 of file MaskedImage.h.

SinglePixel

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::SinglePixel = lsst::afw::image::pixel::SinglePixel<ImagePixelT, MaskPixelT, VariancePixelT>

A single Pixel of the same type as those in the MaskedImage.

Definition at line 114 of file MaskedImage.h.

Variance

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::Variance = lsst::afw::image::Image<VariancePixelT>

Definition at line 85 of file MaskedImage.h.

VariancePtr

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::VariancePtr = std::shared_ptr<image::Image<VariancePixelT>>

shared pointer to the variance Image

Definition at line 81 of file MaskedImage.h.

x_iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::x_iterator = MaskedImageIterator<typename Image::x_iterator, typename Mask::x_iterator, typename Variance::x_iterator>

An iterator to a row of a MaskedImage.

Definition at line 541 of file MaskedImage.h.

xy_locator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::xy_locator = MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>

A locator for a MaskedImage.

Definition at line 554 of file MaskedImage.h.

xy_x_iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::xy_x_iterator = typename MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>::x_iterator

an x_iterator associated with an xy_locator

Definition at line 559 of file MaskedImage.h.

xy_y_iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::xy_y_iterator = typename MaskedImageLocator<typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator>::y_iterator

an y_iterator associated with an xy_locator

Definition at line 561 of file MaskedImage.h.

y_iterator

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

using lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::y_iterator = MaskedImageIterator<typename Image::y_iterator, typename Mask::y_iterator, typename Variance::y_iterator>

An iterator to a column of a MaskedImage.

Definition at line 549 of file MaskedImage.h.

Constructor & Destructor Documentation

MaskedImage() [1/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage ( unsigned int width, unsigned int height, MaskPlaneDict const & planeDict = MaskPlaneDict() )

explicit

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)

Definition at line 43 of file MaskedImage.cc.

        : _image(new Image(width, height)),
          _mask(new Mask(width, height, planeDict)),
          _variance(new Variance(width, height)) {
    *_image = 0;
    *_mask = 0x0;
    *_variance = 0;
}

MaskedImage() [2/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage ( lsst::geom::Extent2I const & dimensions = lsst::geom::Extent2I(), MaskPlaneDict const & planeDict = MaskPlaneDict() )

explicit

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)

Definition at line 54 of file MaskedImage.cc.

        : _image(new Image(dimensions)),
          _mask(new Mask(dimensions, planeDict)),
          _variance(new Variance(dimensions)) {
    *_image = 0;
    *_mask = 0x0;
    *_variance = 0;
}

MaskedImage() [3/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage ( ImagePtr image, MaskPtr mask = MaskPtr(), VariancePtr variance = VariancePtr() )

explicit

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

Definition at line 149 of file MaskedImage.cc.

        : _image(image != nullptr ? image : std::make_shared<Image>()),
          _mask(mask), _variance(variance) {
    conformSizes();
}

MaskedImage() [4/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage ( lsst::geom::Box2I const & bbox, MaskPlaneDict const & planeDict = MaskPlaneDict() )

explicit

Create an MaskedImage of the specified size.

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

Parameters

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

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

Definition at line 65 of file MaskedImage.cc.

        : _image(new Image(bbox)), _mask(new Mask(bbox, planeDict)), _variance(new Variance(bbox)) {
    *_image = 0;
    *_mask = 0x0;
    *_variance = 0;
}

MaskedImage() [5/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::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 )

explicit

Construct a MaskedImage by reading a regular FITS file.

Parameters

[in]	fileName	File to read.
[in,out]	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.
[in,out]	imageMetadata	Metadata read from the image HDU header.
[in,out]	maskMetadata	Metadata read from the mask HDU header.
[in,out]	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.

Definition at line 74 of file MaskedImage.cc.

        : _image(), _mask(), _variance() {
    MaskedImageFitsReader reader(fileName);
    *this = reader.read<ImagePixelT, MaskPixelT, VariancePixelT>(bbox, origin, conformMasks, needAllHdus,
                                                                 allowUnsafe);
    if (metadata) {
        metadata->combine(*reader.readPrimaryMetadata());
    }
    if (imageMetadata) {
        imageMetadata->combine(*reader.readImageMetadata());
    }
    if (maskMetadata) {
        maskMetadata->combine(*reader.readMaskMetadata());
    }
    if (varianceMetadata) {
        varianceMetadata->combine(*reader.readVarianceMetadata());
    }
}

MaskedImage() [6/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::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 )

explicit

Construct a MaskedImage by reading a FITS image in memory.

Parameters

[in]	manager	An object that manages the memory buffer to read.
[in,out]	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.
[in,out]	imageMetadata	Metadata read from the image HDU header.
[in,out]	maskMetadata	Metadata read from the mask HDU header.
[in,out]	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.

Definition at line 99 of file MaskedImage.cc.

        : _image(), _mask(), _variance() {
    MaskedImageFitsReader reader(manager);
    *this = reader.read<ImagePixelT, MaskPixelT, VariancePixelT>(bbox, origin, conformMasks, needAllHdus,
                                                                 allowUnsafe);
    if (metadata) {
        metadata->combine(*reader.readPrimaryMetadata());
    }
    if (imageMetadata) {
        imageMetadata->combine(*reader.readImageMetadata());
    }
    if (maskMetadata) {
        maskMetadata->combine(*reader.readMaskMetadata());
    }
    if (varianceMetadata) {
        varianceMetadata->combine(*reader.readVarianceMetadata());
    }
}

MaskedImage() [7/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::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 )

explicit

Construct a MaskedImage from an already-open FITS object.

Parameters

[in]	fitsfile	A FITS object to read from. Current HDU is ignored.
[in,out]	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.
[in,out]	imageMetadata	Metadata read from the image HDU header.
[in,out]	maskMetadata	Metadata read from the mask HDU header.
[in,out]	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.

Definition at line 124 of file MaskedImage.cc.

        : _image(), _mask(), _variance() {
    MaskedImageFitsReader reader(&fitsFile);
    *this = reader.read<ImagePixelT, MaskPixelT, VariancePixelT>(bbox, origin, conformMasks, needAllHdus,
                                                                 allowUnsafe);
    if (metadata) {
        metadata->combine(*reader.readPrimaryMetadata());
    }
    if (imageMetadata) {
        imageMetadata->combine(*reader.readImageMetadata());
    }
    if (maskMetadata) {
        maskMetadata->combine(*reader.readMaskMetadata());
    }
    if (varianceMetadata) {
        varianceMetadata->combine(*reader.readVarianceMetadata());
    }
}

MaskedImage() [8/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage	(	MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const &	rhs,
		bool const	deep = false )

Copy constructor; shallow, unless deep is true.

Parameters

rhs	Image to copy
deep	Make deep copy?

Definition at line 157 of file MaskedImage.cc.

        : _image(rhs._image), _mask(rhs._mask), _variance(rhs._variance) {
    if (deep) {
        _image = std::shared_ptr<Image>(new Image(*rhs.getImage(), deep));
        _mask = std::shared_ptr<Mask>(new Mask(*rhs.getMask(), deep));
        _variance = std::shared_ptr<Variance>(new Variance(*rhs.getVariance(), deep));
    }
    conformSizes();
}

MaskedImage() [9/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > &&

rhs

)

Definition at line 169 of file MaskedImage.cc.

        : MaskedImage(rhs, false) {}

MaskedImage() [10/11]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage	(	MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > 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

Definition at line 173 of file MaskedImage.cc.

        : _image(new Image(*rhs.getImage(), bbox, origin, deep)),
          _mask(rhs._mask ? new Mask(*rhs.getMask(), bbox, origin, deep) : static_cast<Mask*>(nullptr)),
          _variance(rhs._variance ? new Variance(*rhs.getVariance(), bbox, origin, deep)
                                  : static_cast<Variance*>(nullptr)) {
    conformSizes();
}

MaskedImage() [11/11]

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

template<typename OtherPixelT >

lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage ( MaskedImage< OtherPixelT, MaskPixelT, VariancePixelT > const & rhs, const bool deep )

inline

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

Parameters

rhs	Input image
deep	Must be true; needed to disambiguate

Definition at line 713 of file MaskedImage.h.

            : _image(), _mask(), _variance() {
        if (!deep) {
            throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                              "Only deep copies are permitted for MaskedImages with different pixel types");
        }
 
        _image = ImagePtr(new Image(*rhs.getImage(), deep));
        _mask = MaskPtr(new Mask(*rhs.getMask(), deep));
        _variance = VariancePtr(new Variance(*rhs.getVariance(), deep));
    }

~MaskedImage()

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

virtual lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::~MaskedImage ( )

virtualdefault

Member Function Documentation

assign()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::assign	(	MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > 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.

Definition at line 224 of file MaskedImage.cc.

                                                                                      {
    _image->assign(*rhs.getImage(), bbox, origin);
    _mask->assign(*rhs.getMask(), bbox, origin);
    _variance->assign(*rhs.getVariance(), bbox, origin);
}

at()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::at	(	int const	x,
		int const	y ) const

Return an iterator at the point (x, y)

Definition at line 592 of file MaskedImage.cc.

                                                                                       {
    typename Image::iterator imageEnd = getImage()->at(x, y);
    typename Mask::iterator maskEnd = getMask()->at(x, y);
    typename Variance::iterator varianceEnd = getVariance()->at(x, y);
 
    return iterator(imageEnd, maskEnd, varianceEnd);
}

begin() [1/2]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::begin

(

)

const

Return an iterator to the start of the image.

Definition at line 568 of file MaskedImage.cc.

                                                                  {
#if 0  // this doesn't compile; why?
    return iterator(_image->begin(), _mask->begin(), _variance->begin());
#else
    typename Image::iterator imageBegin = _image->begin();
    typename Mask::iterator maskBegin = _mask->begin();
    typename Variance::iterator varianceBegin = _variance->begin();
 
    return iterator(imageBegin, maskBegin, varianceBegin);
#endif
}

begin() [2/2]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::fast_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::begin

(

bool

contiguous

)

const

Fast iterators to contiguous images.

Return a fast iterator to the start of the image, which must be contiguous Note that the order in which pixels are visited is undefined.

Parameters

contiguous

Pixels are contiguous (must be true)

Exceptions

lsst::pex::exceptions::RuntimeError

Argument contiguous is false, or the pixels are not in fact contiguous

Definition at line 662 of file MaskedImage.cc.

                                                                                 {
    typename Image::fast_iterator imageBegin = _image->begin(contiguous);
    typename Mask::fast_iterator maskBegin = _mask->begin(contiguous);
    typename Variance::fast_iterator varianceBegin = _variance->begin(contiguous);
 
    return fast_iterator(imageBegin, maskBegin, varianceBegin);
}

col_begin()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::y_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::col_begin

(

int

x

)

const

Return an y_iterator to the start of the image.

Definition at line 642 of file MaskedImage.cc.

                                                                           {
    typename Image::y_iterator imageBegin = _image->col_begin(x);
    typename Mask::y_iterator maskBegin = _mask->col_begin(x);
    typename Variance::y_iterator varianceBegin = _variance->col_begin(x);
 
    return y_iterator(imageBegin, maskBegin, varianceBegin);
}

col_end()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::y_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::col_end

(

int

x

)

const

Return an y_iterator to the end of the image.

Definition at line 652 of file MaskedImage.cc.

                                                                         {
    typename Image::y_iterator imageEnd = getImage()->col_end(x);
    typename Mask::y_iterator maskEnd = getMask()->col_end(x);
    typename Variance::y_iterator varianceEnd = getVariance()->col_end(x);
 
    return y_iterator(imageEnd, maskEnd, varianceEnd);
}

end() [1/2]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::end

(

)

const

Return an iterator to the end of the image.

Definition at line 582 of file MaskedImage.cc.

                                                                {
    typename Image::iterator imageEnd = getImage()->end();
    typename Mask::iterator maskEnd = getMask()->end();
    typename Variance::iterator varianceEnd = getVariance()->end();
 
    return iterator(imageEnd, maskEnd, varianceEnd);
}

end() [2/2]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::fast_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::end

(

bool

contiguous

)

const

Return a fast iterator to the end of the image, which must be contiguous Note that the order in which pixels are visited is undefined.

Parameters

contiguous

Pixels are contiguous (must be true)

Exceptions

lsst::pex::exceptions::RuntimeError

Argument contiguous is false, or the pixels are not in fact contiguous

Definition at line 672 of file MaskedImage.cc.

                                                                               {
    typename Image::fast_iterator imageEnd = getImage()->end(contiguous);
    typename Mask::fast_iterator maskEnd = getMask()->end(contiguous);
    typename Variance::fast_iterator varianceEnd = getVariance()->end(contiguous);
 
    return fast_iterator(imageEnd, maskEnd, varianceEnd);
}

getBBox()

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

lsst::geom::Box2I lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getBBox ( ImageOrigin const origin = PARENT ) const

inline

Definition at line 1059 of file MaskedImage.h.

{ return _image->getBBox(origin); }

getDimensions()

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

lsst::geom::Extent2I lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getDimensions ( ) const

inline

Definition at line 1058 of file MaskedImage.h.

{ return _image->getDimensions(); }

getHeight()

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

int lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getHeight ( ) const

inline

Return the number of rows in the image.

Definition at line 1057 of file MaskedImage.h.

{ return _image->getHeight(); }

getImage()

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

ImagePtr lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getImage ( ) const

inline

Return a (shared_ptr to) the MaskedImage's image.

Definition at line 1019 of file MaskedImage.h.

{ return _image; }

getMask()

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

MaskPtr lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getMask ( ) const

inline

Return a (shared_ptr to) the MaskedImage's mask.

Definition at line 1031 of file MaskedImage.h.

{ return _mask; }

getVariance()

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

VariancePtr lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getVariance ( ) const

inline

Return a (shared_ptr to) the MaskedImage's variance.

Definition at line 1052 of file MaskedImage.h.

{ return _variance; }

getWidth()

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

int lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getWidth ( ) const

inline

Return the number of columns in the image.

Definition at line 1055 of file MaskedImage.h.

{ return _image->getWidth(); }

getX0()

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

int lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getX0 ( ) const

inline

Return the image's column-origin.

This will usually be 0 except for images created using the MaskedImage(fileName, hdu, BBox, mode) ctor or MaskedImage(ImageBase, BBox) cctor The origin can be reset with setXY0()

Definition at line 1067 of file MaskedImage.h.

{ return _image->getX0(); }

getXY0()

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

lsst::geom::Point2I lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getXY0 ( ) const

inline

Return the image's origin.

This will usually be (0, 0) except for images created using the MaskedImage(fileName, hdu, BBox, mode) ctor or MaskedImage(ImageBase, BBox) cctor The origin can be reset with setXY0

Definition at line 1083 of file MaskedImage.h.

{ return _image->getXY0(); }

getY0()

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

int lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getY0 ( ) const

inline

Return the image's row-origin.

This will usually be 0 except for images created using the MaskedImage(fileName, hdu, BBox, mode) ctor or MaskedImage(ImageBase, BBox) cctor The origin can be reset with setXY0()

Definition at line 1075 of file MaskedImage.h.

{ return _image->getY0(); }

indexToPosition()

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

double lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::indexToPosition ( double ind, lsst::afw::image::xOrY const xy ) const

inline

Convert image index to image position (see Image::indexToPosition)

Returns

image position

Parameters

ind	image index
xy	Is this a column or row coordinate?

Definition at line 1122 of file MaskedImage.h.

                                          {
        return getImage()->indexToPosition(ind, xy);
    }

operator*=() [1/3]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator*=

(

ImagePixelT const

rhs

)

Definition at line 343 of file MaskedImage.cc.

                                  {
    *_image *= rhs;
    *_variance *= rhs * rhs;
    return *this;
}

operator*=() [2/3]

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

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

inline

Definition at line 841 of file MaskedImage.h.

                                                                       {
        *_image *= rhs;
        *_variance *= rhs;  // yes, multiply twice
        *_variance *= rhs;
        return *this;
    }

operator*=() [3/3]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator*=

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const &

rhs

)

Definition at line 302 of file MaskedImage.cc.

                                   {
    // Must do variance before we modify the image values
    if (_image->getDimensions() != rhs._image->getDimensions()) {
        throw LSST_EXCEPT(pexExcept::LengthError,
                          boost::str(boost::format("Images are of different size, %dx%d v %dx%d") %
                                     _image->getWidth() % _image->getHeight() % rhs._image->getWidth() % rhs._image->getHeight()));
    }
    transform_pixels(_image->_getRawView(),         // lhs
                     rhs._image->_getRawView(),     // rhs,
                     _variance->_getRawView(),      // Var(lhs),
                     rhs._variance->_getRawView(),  // Var(rhs)
                     _variance->_getRawView(),      // result
                     productVariance<ImagePixelT, VariancePixelT>());
 
    *_image *= *rhs.getImage();
    *_mask |= *rhs.getMask();
    return *this;
}

operator+=() [1/4]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator+=

(

ImagePixelT const

rhs

)

Add a scalar rhs to a MaskedImage.

Definition at line 250 of file MaskedImage.cc.

                                  {
    *_image += rhs;
    return *this;
}

operator+=() [2/4]

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

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

inline

Definition at line 796 of file MaskedImage.h.

                                                                       {
        *_image += rhs;
        return *this;
    }

operator+=() [3/4]

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

MaskedImage & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator+= ( lsst::afw::math::Function2< double > const & function )

inline

Definition at line 800 of file MaskedImage.h.

                                                                          {
        *_image += function;
        return *this;
    }

operator+=() [4/4]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator+=

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > 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

Definition at line 233 of file MaskedImage.cc.

                                   {
    *_image += *rhs.getImage();
    *_mask |= *rhs.getMask();
    *_variance += *rhs.getVariance();
    return *this;
}

operator-=() [1/4]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator-=

(

ImagePixelT const

rhs

)

Subtract a scalar rhs from a MaskedImage.

Definition at line 274 of file MaskedImage.cc.

                                  {
    *_image -= rhs;
    return *this;
}

operator-=() [2/4]

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

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

inline

Definition at line 823 of file MaskedImage.h.

                                                                       {
        *_image -= rhs;
        return *this;
    }

operator-=() [3/4]

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

MaskedImage & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator-= ( lsst::afw::math::Function2< double > const & function )

inline

Definition at line 827 of file MaskedImage.h.

                                                                          {
        *_image -= function;
        return *this;
    }

operator-=() [4/4]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator-=

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > 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

Definition at line 257 of file MaskedImage.cc.

                                   {
    *_image -= *rhs.getImage();
    *_mask |= *rhs.getMask();
    *_variance += *rhs.getVariance();
    return *this;
}

operator/=() [1/3]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator/=

(

ImagePixelT const

rhs

)

Definition at line 414 of file MaskedImage.cc.

                                  {
    *_image /= rhs;
    *_variance /= rhs * rhs;
    return *this;
}

operator/=() [2/3]

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

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

inline

Definition at line 851 of file MaskedImage.h.

                                                                       {
        *_image /= rhs;
        *_variance /= rhs;  // yes, divide twice
        *_variance /= rhs;
        return *this;
    }

operator/=() [3/3]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator/=

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const &

rhs

)

Definition at line 373 of file MaskedImage.cc.

                                   {
    // Must do variance before we modify the image values
    if (_image->getDimensions() != rhs._image->getDimensions()) {
        throw LSST_EXCEPT(pexExcept::LengthError,
                          boost::str(boost::format("Images are of different size, %dx%d v %dx%d") %
                                     _image->getWidth() % _image->getHeight() % rhs._image->getWidth() % rhs._image->getHeight()));
    }
    transform_pixels(_image->_getRawView(),         // lhs
                     rhs._image->_getRawView(),     // rhs,
                     _variance->_getRawView(),      // Var(lhs),
                     rhs._variance->_getRawView(),  // Var(rhs)
                     _variance->_getRawView(),      // result
                     quotientVariance<ImagePixelT, VariancePixelT>());
 
    *_image /= *rhs.getImage();
    *_mask |= *rhs.getMask();
    return *this;
}

operator=() [1/4]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator= ( MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > && rhs )

default

operator=() [2/4]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator= ( MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const & rhs )

default

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

operator=() [3/4]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator=

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::Pixel const &

rhs

)

Set the pixels in the MaskedImage to the rhs.

Definition at line 204 of file MaskedImage.cc.

                                       {
    *_image = rhs.image();
    *_mask = rhs.mask();
    *_variance = rhs.variance();
 
    return *this;
}

operator=() [4/4]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > & lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator=

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::SinglePixel const &

rhs

)

Set the pixels in the MaskedImage to the rhs.

Definition at line 214 of file MaskedImage.cc.

                                             {
    *_image = rhs.image();
    *_mask = rhs.mask();
    *_variance = rhs.variance();
 
    return *this;
}

operator[]()

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

MaskedImage lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::operator[] ( lsst::geom::Box2I const & bbox ) const

inline

Return a subimage corresponding to the given box (interpreted as PARENT coordinates).

Definition at line 768 of file MaskedImage.h.

{ return subset(bbox); }

positionToIndex()

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

std::pair< int, double > lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::positionToIndex ( double const pos, lsst::afw::image::xOrY const xy ) const

inline

Convert image position to index (see Image::positionToIndex)

Returns

std::pair(nearest integer index, fractional part)

Parameters

pos	image position
xy	Is this a column or row coordinate?

Definition at line 1133 of file MaskedImage.h.

                    {
        return getImage()->positionToIndex(pos, xy);
    }

rbegin()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::reverse_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::rbegin

(

)

const

Return a reverse_iterator to the start of the image.

Definition at line 602 of file MaskedImage.cc.

                                                                   {
    typename Image::reverse_iterator imageBegin = _image->rbegin();
    typename Mask::reverse_iterator maskBegin = _mask->rbegin();
    typename Variance::reverse_iterator varianceBegin = _variance->rbegin();
 
    return reverse_iterator(imageBegin, maskBegin, varianceBegin);
}

readFits() [1/2]

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

static MaskedImage lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::readFits ( fits::MemFileManager & manager )

inlinestatic

Read a MaskedImage from a FITS RAM file.

Parameters

[in]

manager

Object that manages the memory to be read.

Definition at line 1012 of file MaskedImage.h.

                                                             {
        return MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>(manager);
    }

readFits() [2/2]

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

static MaskedImage lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::readFits ( std::string const & filename )

inlinestatic

Read a MaskedImage from a regular FITS file.

Parameters

[in]

filename

Name of the file to read.

Definition at line 1003 of file MaskedImage.h.

                                                           {
        return MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>(filename);
    }

rend()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::reverse_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::rend

(

)

const

Return a reverse_iterator to the end of the image.

Definition at line 612 of file MaskedImage.cc.

                                                                 {
    typename Image::reverse_iterator imageEnd = getImage()->rend();
    typename Mask::reverse_iterator maskEnd = getMask()->rend();
    typename Variance::reverse_iterator varianceEnd = getVariance()->rend();
 
    return reverse_iterator(imageEnd, maskEnd, varianceEnd);
}

row_begin()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::x_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::row_begin

(

int

y

)

const

Return an x_iterator to the start of the image.

Definition at line 622 of file MaskedImage.cc.

                                                                           {
    typename Image::x_iterator imageBegin = _image->row_begin(y);
    typename Mask::x_iterator maskBegin = _mask->row_begin(y);
    typename Variance::x_iterator varianceBegin = _variance->row_begin(y);
 
    return x_iterator(imageBegin, maskBegin, varianceBegin);
}

row_end()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::x_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::row_end

(

int

y

)

const

Return an x_iterator to the end of the image.

Definition at line 632 of file MaskedImage.cc.

                                                                         {
    typename Image::x_iterator imageEnd = getImage()->row_end(y);
    typename Mask::x_iterator maskEnd = getMask()->row_end(y);
    typename Variance::x_iterator varianceEnd = getVariance()->row_end(y);
 
    return x_iterator(imageEnd, maskEnd, varianceEnd);
}

scaledDivides()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::scaledDivides	(	double const	c,
		MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const &	rhs )

Definition at line 394 of file MaskedImage.cc.

                                                                                                 {
    // Must do variance before we modify the image values
    if (_image->getDimensions() != rhs._image->getDimensions()) {
        throw LSST_EXCEPT(pexExcept::LengthError,
                          str(boost::format("Images are of different size, %dx%d v %dx%d") %
                              _image->getWidth() % _image->getHeight() % rhs._image->getWidth() % rhs._image->getHeight()));
    }
    transform_pixels(_image->_getRawView(),         // lhs
                     rhs._image->_getRawView(),     // rhs,
                     _variance->_getRawView(),      // Var(lhs),
                     rhs._variance->_getRawView(),  // Var(rhs)
                     _variance->_getRawView(),      // result
                     scaledQuotientVariance<ImagePixelT, VariancePixelT>(c));
 
    (*_image).scaledDivides(c, *rhs.getImage());
    *_mask |= *rhs._mask;
}

scaledMinus()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::scaledMinus	(	double const	c,
		MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > 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

Definition at line 266 of file MaskedImage.cc.

                                                                                               {
    (*_image).scaledMinus(c, *rhs.getImage());
    *_mask |= *rhs.getMask();
    (*_variance).scaledPlus(c * c, *rhs.getVariance());
}

scaledMultiplies()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::scaledMultiplies	(	double const	c,
		MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const &	rhs )

Definition at line 323 of file MaskedImage.cc.

                                                                                                    {
    // Must do variance before we modify the image values
    if (_image->getDimensions() != rhs._image->getDimensions()) {
        throw LSST_EXCEPT(pexExcept::LengthError,
                          boost::str(boost::format("Images are of different size, %dx%d v %dx%d") %
                                     _image->getWidth() % _image->getHeight() % rhs._image->getWidth() % rhs._image->getHeight()));
    }
    transform_pixels(_image->_getRawView(),         // lhs
                     rhs._image->_getRawView(),     // rhs,
                     _variance->_getRawView(),      // Var(lhs),
                     rhs._variance->_getRawView(),  // Var(rhs)
                     _variance->_getRawView(),      // result
                     scaledProductVariance<ImagePixelT, VariancePixelT>(c));
 
    (*_image).scaledMultiplies(c, *rhs.getImage());
    *_mask |= *rhs.getMask();
}

scaledPlus()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::scaledPlus	(	double const	c,
		MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > 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

Definition at line 242 of file MaskedImage.cc.

                                                                                              {
    (*_image).scaledPlus(c, *rhs.getImage());
    *_mask |= *rhs.getMask();
    (*_variance).scaledPlus(c * c, *rhs.getVariance());
}

setImage()

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

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::setImage ( Image const & other )

inline

Set the image plane's pixel values to those of another Image.

This copies pixel values, not pointers.

Exceptions

pex::exceptions::LengthError

if dimensions do not match.

Definition at line 1028 of file MaskedImage.h.

{ _image->assign(other); }

setMask()

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

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::setMask ( Mask const & other )

inline

Set the mask plane's pixel values to those of another Mask.

This copies pixel values, not pointers.

Exceptions

pex::exceptions::LengthError

if dimensions do not match.

Definition at line 1040 of file MaskedImage.h.

{ _mask->assign(other); }

setVariance()

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

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::setVariance ( Variance const & other )

inline

Set the variance plane's pixel values to those of another Image.

This copies pixel values, not pointers.

Exceptions

pex::exceptions::LengthError

if dimensions do not match.

Definition at line 1049 of file MaskedImage.h.

{ _variance->assign(other); }

setXY0() [1/2]

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

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::setXY0 ( int const x0, int const y0 )

inline

Set the MaskedImage's origin.

The origin is usually set by the constructor, so you shouldn't need this function

Note

There are use cases (e.g. memory overlays) that may want to set these values, but don't do so unless you are an Expert.

Definition at line 1093 of file MaskedImage.h.

{ setXY0(lsst::geom::Point2I(x0, y0)); }

setXY0() [2/2]

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

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::setXY0 ( lsst::geom::Point2I const origin )

inline

Set the MaskedImage's origin.

The origin is usually set by the constructor, so you shouldn't need this function

Note

There are use cases (e.g. memory overlays) that may want to set these values, but don't do so unless you are an Expert.

Definition at line 1103 of file MaskedImage.h.

                                              {
        if (_image) {
            _image->setXY0(origin);
        }
 
        if (_mask) {
            _mask->setXY0(origin);
        }
 
        if (_variance) {
            _variance->setXY0(origin);
        }
    }

subset()

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

MaskedImage lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::subset ( lsst::geom::Box2I const & bbox, ImageOrigin origin = PARENT ) const

inline

Return a subimage corresponding to the given box.

Parameters

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

Returns

A subimage view into this.

This method is wrapped as getitem in Python.

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.

Definition at line 763 of file MaskedImage.h.

                                                                                     {
        return MaskedImage(*this, bbox, origin, false);
    }

swap()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::swap

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > &

rhs

)

Definition at line 194 of file MaskedImage.cc.

                                                                                {
    using std::swap;  // See Meyers, Effective C++, Item 25
 
    _image.swap(rhs._image);
    _mask.swap(rhs._mask);
    _variance.swap(rhs._variance);
}

writeFits() [1/6]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::writeFits	(	fits::Fits &	fitsfile,
		fits::ImageWriteOptions const &	imageOptions,
		fits::ImageWriteOptions const &	maskOptions,
		fits::ImageWriteOptions const &	varianceOptions,
		std::shared_ptr< daf::base::PropertySet const >	metadata = nullptr,
		std::shared_ptr< daf::base::PropertySet const >	imageMetadata = nullptr,
		std::shared_ptr< daf::base::PropertySet const >	maskMetadata = nullptr,
		std::shared_ptr< daf::base::PropertySet const >	varianceMetadata = nullptr ) const

Write a MaskedImage to a FITS file.

Parameters

[in]	fitsfile	An empty FITS file object.
[in]	imageOptions	Options controlling writing of image as FITS.
[in]	maskOptions	Options controlling writing of mask as FITS.
[in]	varianceOptions	Options controlling writing of variance as FITS.
[in]	metadata	Additional values to write to the primary HDU header (may be null).
[in]	imageMetadata	Metadata to be written to the image header.
[in]	maskMetadata	Metadata to be written to the mask header.
[in]	varianceMetadata	Metadata to be written to the variance header.

The FITS file will have four HDUs; the primary HDU will contain only metadata, while the image, mask, and variance HDU headers will use the "INHERIT='T'" convention to indicate that the primary metadata applies to those HDUs as well.

Definition at line 494 of file MaskedImage.cc.

                                                                        {
    std::shared_ptr<daf::base::PropertySet> header;
    if (metadata) {
        header = metadata->deepCopy();
    } else {
        header = std::make_shared<daf::base::PropertyList>();
    }
 
    if (fitsfile.countHdus() != 0) {
        throw LSST_EXCEPT(pex::exceptions::LogicError,
                          "MaskedImage::writeFits can only write to an empty file");
    }
    if (fitsfile.getHdu() < 1) {
        // Don't ever write images to primary; instead we make an empty primary.
        fitsfile.createEmpty();
    } else {
        fitsfile.setHdu(0);
    }
    fitsfile.writeMetadata(*header);
 
    processPlaneMetadata(imageMetadata.get(), header, "IMAGE");
    _image->writeFits(fitsfile, imageOptions, header.get(), _mask.get());
 
    processPlaneMetadata(maskMetadata.get(), header, "MASK");
    _mask->writeFits(fitsfile, maskOptions, header.get());
 
    processPlaneMetadata(varianceMetadata.get(), header, "VARIANCE");
    _variance->writeFits(fitsfile, varianceOptions, header.get(), _mask.get());
}

writeFits() [2/6]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::writeFits	(	fits::Fits &	fitsfile,
		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 FITS file.

Parameters

[in]	fitsfile	An empty FITS file object.
[in]	metadata	Additional values to write to the primary HDU header (may be null).
[in]	imageMetadata	Metadata to be written to the image header.
[in]	maskMetadata	Metadata to be written to the mask header.
[in]	varianceMetadata	Metadata to be written to the variance header.

The FITS file will have four HDUs; the primary HDU will contain only metadata, while the image, mask, and variance HDU headers will use the "INHERIT='T'" convention to indicate that the primary metadata applies to those HDUs as well.

Definition at line 458 of file MaskedImage.cc.

                                                                        {
    writeFits(fitsfile, fits::ImageWriteOptions(*_image), fits::ImageWriteOptions(*_mask),
              fits::ImageWriteOptions(*_variance), metadata, imageMetadata, maskMetadata, varianceMetadata);
}

writeFits() [3/6]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::writeFits	(	fits::MemFileManager &	manager,
		fits::ImageWriteOptions const &	imageOptions,
		fits::ImageWriteOptions const &	maskOptions,
		fits::ImageWriteOptions const &	varianceOptions,
		std::shared_ptr< daf::base::PropertySet const >	metadata = nullptr,
		std::shared_ptr< daf::base::PropertySet const >	imageMetadata = nullptr,
		std::shared_ptr< daf::base::PropertySet const >	maskMetadata = nullptr,
		std::shared_ptr< daf::base::PropertySet const >	varianceMetadata = nullptr ) const

Write a MaskedImage to a FITS file.

Parameters

[in]	manager	Manager object for the memory block to write to.
[in]	imageOptions	Options controlling writing of image as FITS.
[in]	maskOptions	Options controlling writing of mask as FITS.
[in]	varianceOptions	Options controlling writing of variance as FITS.
[in]	metadata	Additional values to write to the primary HDU header (may be null).
[in]	imageMetadata	Metadata to be written to the image header.
[in]	maskMetadata	Metadata to be written to the mask header.
[in]	varianceMetadata	Metadata to be written to the variance header.

The FITS file will have four HDUs; the primary HDU will contain only metadata, while the image, mask, and variance HDU headers will use the "INHERIT='T'" convention to indicate that the primary metadata applies to those HDUs as well.

Definition at line 481 of file MaskedImage.cc.

                                                                        {
    fits::Fits fitsfile(manager, "w", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile, imageOptions, maskOptions, varianceOptions, metadata, imageMetadata, maskMetadata,
              varianceMetadata);
}

writeFits() [4/6]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::writeFits	(	fits::MemFileManager &	manager,
		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 FITS RAM file.

Parameters

[in]	manager	Manager object for the memory block to write to.
[in]	metadata	Additional values to write to the primary HDU header (may be null).
[in]	imageMetadata	Metadata to be written to the image header.
[in]	maskMetadata	Metadata to be written to the mask header.
[in]	varianceMetadata	Metadata to be written to the variance header.

The FITS file will have four HDUs; the primary HDU will contain only metadata, while the image, mask, and variance HDU headers will use the "INHERIT='T'" convention to indicate that the primary metadata applies to those HDUs as well.

Definition at line 432 of file MaskedImage.cc.

                                                                        {
    fits::Fits fitsfile(manager, "w", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile, metadata, imageMetadata, maskMetadata, varianceMetadata);
}

writeFits() [5/6]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::writeFits	(	std::string const &	fileName,
		fits::ImageWriteOptions const &	imageOptions,
		fits::ImageWriteOptions const &	maskOptions,
		fits::ImageWriteOptions const &	varianceOptions,
		std::shared_ptr< daf::base::PropertySet const >	metadata = nullptr,
		std::shared_ptr< daf::base::PropertySet const >	imageMetadata = nullptr,
		std::shared_ptr< daf::base::PropertySet const >	maskMetadata = nullptr,
		std::shared_ptr< daf::base::PropertySet const >	varianceMetadata = nullptr ) const

Write a MaskedImage to a FITS file.

Parameters

[in]	fileName	Name of the file to write.
[in]	imageOptions	Options controlling writing of image as FITS.
[in]	maskOptions	Options controlling writing of mask as FITS.
[in]	varianceOptions	Options controlling writing of variance as FITS.
[in]	metadata	Additional values to write to the primary HDU header (may be null).
[in]	imageMetadata	Metadata to be written to the image header.
[in]	maskMetadata	Metadata to be written to the mask header.
[in]	varianceMetadata	Metadata to be written to the variance header.

The FITS file will have four HDUs; the primary HDU will contain only metadata, while the image, mask, and variance HDU headers will use the "INHERIT='T'" convention to indicate that the primary metadata applies to those HDUs as well.

Definition at line 468 of file MaskedImage.cc.

                                                                        {
    fits::Fits fitsfile(fileName, "w", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile, imageOptions, maskOptions, varianceOptions, metadata, imageMetadata, maskMetadata,
              varianceMetadata);
}

writeFits() [6/6]

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::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.

Parameters

[in]	fileName	Name of the file to write. When writing separate files, this is the "base" of the filename (e.g. foo reads foo_{img.msk.var}.fits).
[in]	metadata	Additional values to write to the primary HDU header (may be null).
[in]	imageMetadata	Metadata to be written to the image header.
[in]	maskMetadata	Metadata to be written to the mask header.
[in]	varianceMetadata	Metadata to be written to the variance header.

The FITS file will have four HDUs; the primary HDU will contain only metadata, while the image, mask, and variance HDU headers will use the "INHERIT='T'" convention to indicate that the primary metadata applies to those HDUs as well.

Definition at line 422 of file MaskedImage.cc.

                                                                        {
    fits::Fits fitsfile(fileName, "w", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile, metadata, imageMetadata, maskMetadata, varianceMetadata);
}

x_at()

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

x_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::x_at ( int x, int y ) const

inline

Return an x_iterator at the point (x, y)

Definition at line 1181 of file MaskedImage.h.

                                        {
#if 0
        typename Image::x_iterator imageEnd = getImage()->x_at(x, y);
        typename Mask::x_iterator maskEnd = getMask()->x_at(x, y);
        typename Variance::x_iterator varianceEnd = getVariance()->x_at(x, y);
#else  // bypass checks for non-NULL pointers
        typename Image::x_iterator imageEnd = _image->x_at(x, y);
        typename Mask::x_iterator maskEnd = _mask->x_at(x, y);
        typename Variance::x_iterator varianceEnd = _variance->x_at(x, y);
#endif
 
        return x_iterator(imageEnd, maskEnd, varianceEnd);
    }

xy_at()

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

xy_locator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::xy_at ( int x, int y ) const

inline

Return an xy_locator at the point (x, y)

Definition at line 1215 of file MaskedImage.h.

                                         {
#if 0
        typename Image::xy_locator imageEnd = getImage()->xy_at(x, y);
        typename Mask::xy_locator maskEnd = getMask()->xy_at(x, y);
        typename Variance::xy_locator varianceEnd = getVariance()->xy_at(x, y);
#else  // bypass checks for non-NULL pointers
        typename Image::xy_locator imageEnd = _image->xy_at(x, y);
        typename Mask::xy_locator maskEnd = _mask->xy_at(x, y);
        typename Variance::xy_locator varianceEnd = _variance->xy_at(x, y);
#endif
 
        return xy_locator(imageEnd, maskEnd, varianceEnd);
    }

y_at()

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

y_iterator lsst::afw::image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::y_at ( int x, int y ) const

inline

Return an y_iterator at the point (x, y)

Definition at line 1201 of file MaskedImage.h.

                                        {
#if 0
        typename Image::y_iterator imageEnd = getImage()->y_at(x, y);
        typename Mask::y_iterator maskEnd = getMask()->y_at(x, y);
        typename Variance::y_iterator varianceEnd = getVariance()->y_at(x, y);
#else  // bypass checks for non-NULL pointers
        typename Image::y_iterator imageEnd = _image->y_at(x, y);
        typename Mask::y_iterator maskEnd = _mask->y_at(x, y);
        typename Variance::y_iterator varianceEnd = _variance->y_at(x, y);
#endif
        return y_iterator(imageEnd, maskEnd, varianceEnd);
    }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/g9726552aa6+10f999ec6a/include/lsst/afw/image/MaskedImage.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/g9726552aa6+10f999ec6a/src/image/MaskedImage.cc