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>

Inheritance diagram for lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >:

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
typedef Image< ImagePixelT >::Ptr	ImagePtr
	shared pointer to the Image More...
typedef Mask< MaskPixelT >::Ptr	MaskPtr
	shared pointer to the Mask More...
typedef Image< VariancePixelT > ::Ptr	VariancePtr
	shared pointer to the variance Image More...
typedef boost::shared_ptr < MaskedImage >	Ptr
	shared pointer to a MaskedImage More...
typedef boost::shared_ptr < const MaskedImage >	ConstPtr
typedef Mask< MaskPixelT > ::MaskPlaneDict	MaskPlaneDict
	The Mask's MaskPlaneDict. More...
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. More...
typedef lsst::afw::image::pixel::SinglePixel < ImagePixelT, MaskPixelT, VariancePixelT >	SinglePixel
	A single Pixel of the same type as those in the MaskedImage. More...
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. More...
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. More...
typedef x_iterator	fast_iterator
typedef MaskedImageIterator < typename Image::y_iterator, typename Mask::y_iterator, typename Variance::y_iterator >	y_iterator
	An iterator to a column of a MaskedImage. More...
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. More...
typedef MaskedImageLocator < typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator >	xy_locator
	A locator for a MaskedImage. More...
typedef const_MaskedImageLocator < typename Image::xy_locator, typename Mask::xy_locator, typename Variance::xy_locator >	const_xy_locator
	A const_locator for a MaskedImage. More...
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 More...
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 More...
Public Types inherited from lsst::daf::base::Persistable
typedef boost::shared_ptr < Persistable >	Ptr
Public Types inherited from lsst::daf::base::Citizen
enum	{ magicSentinel = 0xdeadbeef }
typedef unsigned long	memId
	Type of the block's ID. More...
typedef memId(*	memNewCallback )(const memId cid)
	A function used to register a callback. More...
typedef memId(*	memCallback )(const Citizen *ptr)

Public Member 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. More...
	MaskedImage (geom::Extent2I const &dimensions=geom::Extent2I(), MaskPlaneDict const &planeDict=MaskPlaneDict())
	Construct from a supplied dimensions. The Image, Mask, and Variance will be set to zero. More...
	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. More...
	MaskedImage (geom::Box2I const &bbox, MaskPlaneDict const &planeDict=MaskPlaneDict())
	MaskedImage (std::string const &fileName, boost::shared_ptr< daf::base::PropertySet > metadata=boost::shared_ptr< daf::base::PropertySet >(), geom::Box2I const &bbox=geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool needAllHdus=false, boost::shared_ptr< daf::base::PropertySet > imageMetadata=boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet > maskMetadata=boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet > varianceMetadata=boost::shared_ptr< daf::base::PropertySet >())
	Construct a MaskedImage by reading a regular FITS file. More...
	MaskedImage (fits::MemFileManager &manager, boost::shared_ptr< daf::base::PropertySet > metadata=boost::shared_ptr< daf::base::PropertySet >(), geom::Box2I const &bbox=geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool needAllHdus=false, boost::shared_ptr< daf::base::PropertySet > imageMetadata=boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet > maskMetadata=boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet > varianceMetadata=boost::shared_ptr< daf::base::PropertySet >())
	Construct a MaskedImage by reading a FITS image in memory. More...
	MaskedImage (fits::Fits &fitsfile, boost::shared_ptr< daf::base::PropertySet > metadata=boost::shared_ptr< daf::base::PropertySet >(), geom::Box2I const &bbox=geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool needAllHdus=false, boost::shared_ptr< daf::base::PropertySet > imageMetadata=boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet > maskMetadata=boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet > varianceMetadata=boost::shared_ptr< daf::base::PropertySet >())
	Construct a MaskedImage from an already-open FITS object. More...
	MaskedImage (MaskedImage const &rhs, bool const deep=false)
	Copy constructor; shallow, unless deep is true. More...
	MaskedImage (MaskedImage const &rhs, 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. More...
template<typename OtherPixelT >
	MaskedImage (MaskedImage< OtherPixelT, MaskPixelT, VariancePixelT > const &rhs, const bool deep)
MaskedImage &	operator= (MaskedImage const &rhs)
	Make the lhs use the rhs's pixels. More...
virtual	~MaskedImage ()
void	swap (MaskedImage &rhs)
MaskedImage &	operator= (Pixel const &rhs)
MaskedImage &	operator= (SinglePixel const &rhs)
void	operator<<= (MaskedImage const &rhs)
void	operator+= (ImagePixelT const rhs)
	Add a scalar rhs to a MaskedImage. More...
void	operator+= (MaskedImage const &rhs)
void	operator+= (lsst::afw::image::Image< ImagePixelT > const &rhs)
void	operator+= (lsst::afw::math::Function2< double > const &function)
void	scaledPlus (double const c, MaskedImage const &rhs)
void	operator-= (ImagePixelT const rhs)
	Subtract a scalar rhs from a MaskedImage. More...
void	operator-= (MaskedImage const &rhs)
void	operator-= (lsst::afw::image::Image< ImagePixelT > const &rhs)
void	operator-= (lsst::afw::math::Function2< double > const &function)
void	scaledMinus (double const c, MaskedImage const &rhs)
void	operator*= (ImagePixelT const rhs)
void	operator*= (MaskedImage const &rhs)
void	operator*= (lsst::afw::image::Image< ImagePixelT > const &rhs)
void	scaledMultiplies (double const c, MaskedImage const &rhs)
void	operator/= (ImagePixelT const rhs)
void	operator/= (MaskedImage const &rhs)
void	operator/= (lsst::afw::image::Image< ImagePixelT > const &rhs)
void	scaledDivides (double const c, MaskedImage const &rhs)
void	writeFits (std::string const &fileName, boost::shared_ptr< daf::base::PropertySet const > metadata=boost::shared_ptr< daf::base::PropertySet const >(), boost::shared_ptr< daf::base::PropertySet const > imageMetadata=boost::shared_ptr< daf::base::PropertySet const >(), boost::shared_ptr< daf::base::PropertySet const > maskMetadata=boost::shared_ptr< daf::base::PropertySet const >(), boost::shared_ptr< daf::base::PropertySet const > varianceMetadata=boost::shared_ptr< daf::base::PropertySet const >()) const
	Write a MaskedImage to a regular FITS file. More...
void	writeFits (fits::MemFileManager &manager, boost::shared_ptr< daf::base::PropertySet const > metadata=boost::shared_ptr< daf::base::PropertySet const >(), boost::shared_ptr< daf::base::PropertySet const > imageMetadata=boost::shared_ptr< daf::base::PropertySet const >(), boost::shared_ptr< daf::base::PropertySet const > maskMetadata=boost::shared_ptr< daf::base::PropertySet const >(), boost::shared_ptr< daf::base::PropertySet const > varianceMetadata=boost::shared_ptr< daf::base::PropertySet const >()) const
	Write a MaskedImage to a FITS RAM file. More...
void	writeFits (fits::Fits &fitsfile, boost::shared_ptr< daf::base::PropertySet const > metadata=boost::shared_ptr< daf::base::PropertySet const >(), boost::shared_ptr< daf::base::PropertySet const > imageMetadata=boost::shared_ptr< daf::base::PropertySet const >(), boost::shared_ptr< daf::base::PropertySet const > maskMetadata=boost::shared_ptr< daf::base::PropertySet const >(), boost::shared_ptr< daf::base::PropertySet const > varianceMetadata=boost::shared_ptr< daf::base::PropertySet const >()) const
	Write a MaskedImage to a FITS RAM file. More...
ImagePtr	getImage (bool const noThrow=false) const
	Return a (Ptr to) the MaskedImage's image. More...
MaskPtr	getMask (bool const noThrow=false) const
	Return a (Ptr to) the MaskedImage's mask. More...
VariancePtr	getVariance (bool const noThrow=false) const
	Return a (Ptr to) the MaskedImage's variance. More...
int	getWidth () const
	Return the number of columns in the image. More...
int	getHeight () const
	Return the number of rows in the image. More...
geom::Extent2I	getDimensions () const
geom::Box2I	getBBox (ImageOrigin const origin=PARENT) const
int	getX0 () const
int	getY0 () const
geom::Point2I	getXY0 () const
void	setXY0 (int const x0, int const y0)
void	setXY0 (geom::Point2I const origin)
double	indexToPosition (double ind, lsst::afw::image::xOrY const xy) const
	Convert image index to image position (see Image::indexToPosition) More...
std::pair< int, double >	positionToIndex (double const pos, lsst::afw::image::xOrY const xy) const
	Convert image position to index (see Image::positionToIndex) More...
iterator	begin () const
	Return an iterator to the start of the image. More...
iterator	end () const
	Return an iterator to the end of the image. More...
iterator	at (int const x, int const y) const
	Return an iterator at the point (x, y) More...
reverse_iterator	rbegin () const
	Return a reverse_iterator to the start of the image. More...
reverse_iterator	rend () const
	Return a reverse_iterator to the end of the image. More...
fast_iterator	begin (bool) const
fast_iterator	end (bool) const
x_iterator	row_begin (int y) const
	Return an x_iterator to the start of the image. More...
x_iterator	row_end (int y) const
	Return an x_iterator to the end of the image. More...
x_iterator	x_at (int x, int y) const
	Return an x_iterator at the point (x, y) More...
y_iterator	col_begin (int x) const
	Return an y_iterator to the start of the image. More...
y_iterator	col_end (int x) const
	Return an y_iterator to the end of the image. More...
y_iterator	y_at (int x, int y) const
	Return an y_iterator at the point (x, y) More...
xy_locator	xy_at (int x, int y) const
	Return an xy_locator at the point (x, y) More...
Public Member Functions inherited from lsst::daf::base::Persistable
	Persistable (void)
virtual	~Persistable (void)
template<class Archive >
void	serialize (Archive &, unsigned int const)
Public Member Functions inherited from lsst::daf::base::Citizen
	Citizen (const std::type_info &)
	Citizen (Citizen const &)
	~Citizen ()
Citizen &	operator= (Citizen const &)
std::string	repr () const
	Return a string representation of a Citizen. More...
void	markPersistent (void)
	Mark a Citizen as persistent and not destroyed until process end. More...
memId	getId () const
	Return the Citizen's ID. More...

Static Public Member Functions
static MaskedImage	readFits (std::string const &filename)
	Read a MaskedImage from a regular FITS file. More...
static MaskedImage	readFits (fits::MemFileManager &manager)
	Read a MaskedImage from a FITS RAM file. More...
Static Public Member Functions inherited from lsst::daf::base::Citizen
static bool	hasBeenCorrupted ()
	Check all allocated blocks for corruption. More...
static memId	getNextMemId ()
	Return the memId of the next object to be allocated. More...
static int	init ()
	Called once when the memory system is being initialised. More...
static int	census (int, memId startingMemId=0)
	How many active Citizens are there? More...
static void	census (std::ostream &stream, memId startingMemId=0)
	Print a list of all active Citizens to stream, sorted by ID. More...
static const std::vector < const Citizen * > *	census ()
	Return a (newly allocated) std::vector of active Citizens sorted by ID. More...
static memId	setNewCallbackId (memId id)
	Call the NewCallback when block is allocated. More...
static memId	setDeleteCallbackId (memId id)
	Call the current DeleteCallback when block is deleted. More...
static memNewCallback	setNewCallback (memNewCallback func)
	Set the NewCallback function. More...
static memCallback	setDeleteCallback (memCallback func)
	Set the DeleteCallback function. More...
static memCallback	setCorruptionCallback (memCallback func)
	Set the CorruptionCallback function. More...

Private Member Functions
void	conformSizes ()

Private Attributes
ImagePtr	_image
MaskPtr	_mask
VariancePtr	_variance

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.

Examples:

footprintFunctor.cc, imageStatistics.cc, maskedImage1.cc, maskedImage2.cc, spatialCellExample.cc, and testSpatialCell.h.

Definition at line 77 of file MaskedImage.h.

Member Typedef Documentation

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

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

Definition at line 567 of file MaskedImage.h.

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

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

A const_iterator to a row of a MaskedImage.

Definition at line 581 of file MaskedImage.h.

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

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

A const_locator for a MaskedImage.

Definition at line 597 of file MaskedImage.h.

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

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

A const_iterator to a column of a MaskedImage.

Definition at line 590 of file MaskedImage.h.

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

typedef boost::shared_ptr<const MaskedImage> lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::ConstPtr

Definition at line 88 of file MaskedImage.h.

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

typedef x_iterator lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::fast_iterator

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

Definition at line 584 of file MaskedImage.h.

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

typedef lsst::afw::image::Image<ImagePixelT> lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::Image

Definition at line 93 of file MaskedImage.h.

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

typedef detail::MaskedImage_tag lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::image_category

Definition at line 96 of file MaskedImage.h.

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

typedef Image<ImagePixelT>::Ptr lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::ImagePtr

shared pointer to the Image

Definition at line 81 of file MaskedImage.h.

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

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

Definition at line 564 of file MaskedImage.h.

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

typedef lsst::afw::image::Mask<MaskPixelT> lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::Mask

Definition at line 94 of file MaskedImage.h.

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

typedef Mask<MaskPixelT>::MaskPlaneDict lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskPlaneDict

The Mask's MaskPlaneDict.

Definition at line 90 of file MaskedImage.h.

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

typedef Mask<MaskPixelT>::Ptr lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskPtr

shared pointer to the Mask

Definition at line 83 of file MaskedImage.h.

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

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

A Pixel in the MaskedImage.

Definition at line 115 of file MaskedImage.h.

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

typedef boost::shared_ptr<MaskedImage> lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::Ptr

shared pointer to a MaskedImage

Definition at line 87 of file MaskedImage.h.

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

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

Definition at line 570 of file MaskedImage.h.

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

typedef lsst::afw::image::pixel::SinglePixel<ImagePixelT, MaskPixelT, VariancePixelT> lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::SinglePixel

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

Definition at line 123 of file MaskedImage.h.

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

typedef lsst::afw::image::Image<VariancePixelT> lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::Variance

Definition at line 92 of file MaskedImage.h.

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

typedef Image<VariancePixelT>::Ptr lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::VariancePtr

shared pointer to the variance Image

Definition at line 85 of file MaskedImage.h.

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

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

An iterator to a row of a MaskedImage.

Definition at line 578 of file MaskedImage.h.

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

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

A locator for a MaskedImage.

Definition at line 594 of file MaskedImage.h.

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

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

an x_iterator associated with an xy_locator

Definition at line 601 of file MaskedImage.h.

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

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

an y_iterator associated with an xy_locator

Definition at line 604 of file MaskedImage.h.

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

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

An iterator to a column of a MaskedImage.

Definition at line 587 of file MaskedImage.h.

Constructor & Destructor Documentation

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.

Constructors

Parameters

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

Definition at line 53 of file MaskedImage.cc.

  :
    lsst::daf::base::Citizen(typeid(this)),
    _image(new Image(width, height)),
    _mask(new Mask(width, height, planeDict)),
    _variance(new Variance(width, height)) {
    *_image = 0;
    *_mask = 0x0;
    *_variance = 0;
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

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

explicit

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

Constructors

Parameters

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

Definition at line 72 of file MaskedImage.cc.

  :
    lsst::daf::base::Citizen(typeid(this)),
    _image(new Image(dimensions)),
    _mask(new Mask(dimensions, planeDict)),
    _variance(new Variance(dimensions)) {
    *_image = 0;
    *_mask = 0x0;
    *_variance = 0;
}

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 271 of file MaskedImage.cc.

  :
    lsst::daf::base::Citizen(typeid(this)),
    _image(image),
    _mask(mask),
    _variance(variance) {
    conformSizes();
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

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

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)

Definition at line 94 of file MaskedImage.cc.

  :
    lsst::daf::base::Citizen(typeid(this)),
    _image(new Image(bbox)),
    _mask(new Mask(bbox, planeDict)),
    _variance(new Variance(bbox)) {
    *_image = 0;
    *_mask = 0x0;
    *_variance = 0;
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

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

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.

Definition at line 108 of file MaskedImage.cc.

  : lsst::daf::base::Citizen(typeid(this)),
    _image(), _mask(), _variance() 
{
    fits::Fits fitsfile(fileName, "r", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    *this = MaskedImage(fitsfile, metadata, bbox, origin, conformMasks, needAllHdus,
                        imageMetadata, maskMetadata, varianceMetadata);
 }

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage ( fits::MemFileManager &  manager, boost::shared_ptr< daf::base::PropertySet >  metadata = boost::shared_ptr< daf::base::PropertySet >(), geom::Box2I const &  bbox = geom::Box2I(), ImageOrigin  origin = PARENT, bool  conformMasks = false, bool  needAllHdus = false, boost::shared_ptr< daf::base::PropertySet >  imageMetadata = boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet >  maskMetadata = boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet >  varianceMetadata = boost::shared_ptr< daf::base::PropertySet >()  )

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.

Definition at line 123 of file MaskedImage.cc.

  : lsst::daf::base::Citizen(typeid(this)),
    _image(), _mask(), _variance() 
{
    fits::Fits fitsfile(manager, "r", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    *this = MaskedImage(fitsfile, metadata, bbox, origin, conformMasks, needAllHdus,
                        imageMetadata, maskMetadata, varianceMetadata);
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage ( fits::Fits &  fitsfile, boost::shared_ptr< daf::base::PropertySet >  metadata = boost::shared_ptr< daf::base::PropertySet >(), geom::Box2I const &  bbox = geom::Box2I(), ImageOrigin  origin = PARENT, bool  conformMasks = false, bool  needAllHdus = false, boost::shared_ptr< daf::base::PropertySet >  imageMetadata = boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet >  maskMetadata = boost::shared_ptr< daf::base::PropertySet >(), boost::shared_ptr< daf::base::PropertySet >  varianceMetadata = boost::shared_ptr< daf::base::PropertySet >()  )

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.

Definition at line 170 of file MaskedImage.cc.

  : lsst::daf::base::Citizen(typeid(this)),
    _image(), _mask(), _variance() 
{
    // When reading a standard Masked Image, we expect four HDUs:
    // * The primary (HDU 1) is empty;
    // * The first extension (HDU 2) contains the image data;
    // * The second extension (HDU 3) contains mask data;
    // * The third extension (HDU 4) contains the variance.
    //
    // If the image HDU is unreadable, we will throw.
    //
    // If the user has specified a non-default HDU, we load image data from
    // that HDU, but do not attempt to load mask/variance data; rather, log a
    // warning and return (blank) defaults.
    //
    // If the mask and/or variance is unreadable, we log a warning and return
    // (blank) defaults.

    // We log warnings about image loading through a child logger, so the user
    // can disable them if required.
    pex::logging::Log log(pex::logging::Log::getDefaultLog(), "afw.image.MaskedImage");

    enum class Hdu {
        Primary = 1,
        Image,
        Mask,
        Variance
    };

    // If the user has requested a non-default HDU and we require all HDUs, we fail.
    if (needAllHdus && fitsfile.getHdu() > static_cast<int>(Hdu::Image)) {
        throw LSST_EXCEPT(fits::FitsError,
                          "Cannot read all HDUs starting from non-default");
    }

    if (metadata) {
        // Read primary metadata - only if user asks for it.
        // If the primary HDU is not empty, this may be the same as imageMetadata.
        auto prevHdu = fitsfile.getHdu();
        fitsfile.setHdu(static_cast<int>(Hdu::Primary));
        fitsfile.readMetadata(*metadata);
        fitsfile.setHdu(prevHdu);
    }

    // setHdu(0) jumps to the first extension iff the primary HDU is both
    // empty and currently selected.
    fitsfile.setHdu(0);
    ensureMetadata(imageMetadata);
    _image.reset(new Image(fitsfile, imageMetadata, bbox, origin));
    checkExtType(fitsfile, imageMetadata, "IMAGE");

    if (fitsfile.getHdu() != static_cast<int>(Hdu::Image)) {
        // Reading the image from a non-default HDU means we do not attempt to
        // read mask and variance.
        _mask.reset(new Mask(_image->getBBox()));
        _variance.reset(new Variance(_image->getBBox()));
    } else {
        try {
            fitsfile.setHdu(static_cast<int>(Hdu::Mask));
            ensureMetadata(maskMetadata);
            _mask.reset(new Mask(fitsfile, maskMetadata, bbox, origin, conformMasks));
            checkExtType(fitsfile, maskMetadata, "MASK");
        } catch(fits::FitsError &e) {
            if (needAllHdus) {
                LSST_EXCEPT_ADD(e, "Reading Mask");
                throw e;
            }
            log.warn("Mask unreadable; using default");
            // By resetting the status we are able to read the next HDU (the variance).
            fitsfile.status = 0;
            _mask.reset(new Mask(_image->getBBox()));
        }

        try {
            fitsfile.setHdu(static_cast<int>(Hdu::Variance));
            ensureMetadata(varianceMetadata);
            _variance.reset(new Variance(fitsfile, varianceMetadata, bbox, origin));
            checkExtType(fitsfile, varianceMetadata, "VARIANCE");
        } catch(fits::FitsError &e) {
            if (needAllHdus) {
                LSST_EXCEPT_ADD(e, "Reading Variance");
                throw e;
            }
            log.warn("Variance unreadable; using default");
            fitsfile.status = 0;
            _variance.reset(new Variance(_image->getBBox()));
        }
    }
}

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 287 of file MaskedImage.cc.

  :
    lsst::daf::base::Citizen(typeid(this)),
    _image(rhs._image), _mask(rhs._mask), _variance(rhs._variance) {
    if (deep) {
        _image =    typename Image::Ptr(new Image(*rhs.getImage(), deep));
        _mask =     typename Mask::Ptr(new Mask(*rhs.getMask(), deep));
        _variance = typename Variance::Ptr(new Variance(*rhs.getVariance(), deep));
    }
    conformSizes();
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::MaskedImage	(	MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const &	rhs,
		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 305 of file MaskedImage.cc.

  :
    lsst::daf::base::Citizen(typeid(this)),
    _image(new Image(*rhs.getImage(), bbox, origin, deep)),
    _mask(rhs._mask ? new Mask(*rhs.getMask(), bbox, origin, deep) : static_cast<Mask *>(NULL)),
    _variance(rhs._variance ? new Variance(*rhs.getVariance(), bbox, origin, deep) : static_cast<Variance *>(NULL)) {
    conformSizes();
}

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 717 of file MaskedImage.h.

      :
        lsst::daf::base::Citizen(typeid(this)), _image(), _mask(), _variance() {
        if (!deep) {
            throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                "Only deep copies are permitted for MaskedImages with different pixel types");
        }

        _image =    typename Image::Ptr(new Image(*rhs.getImage(), deep));
        _mask =     typename Mask::Ptr(new Mask(*rhs.getMask(), deep));
        _variance = typename Variance::Ptr(new Variance(*rhs.getVariance(), deep));
    }

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

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

inlinevirtual

Definition at line 737 of file MaskedImage.h.

{}

Member Function Documentation

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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 712 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);
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

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

(

void

)

const

Return an iterator to the start of the image.

Definition at line 688 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
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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.

Exceptions

lsst::pex::exceptions::Runtime

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

Parameters

contiguous

Pixels are contiguous (must be true)

Definition at line 792 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);
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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 764 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);
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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 774 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);
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::conformSizes ( )

private

Definition at line 649 of file MaskedImage.cc.

                                                                             {

    if (!_mask || _mask->getWidth() == 0 || _mask->getHeight() == 0) {
        _mask = MaskPtr(new Mask(_image->getBBox()));
        *_mask = 0;
    } else {
        if (_mask->getDimensions() != _image->getDimensions()) {
            throw LSST_EXCEPT(
                lsst::pex::exceptions::LengthError,
                (boost::format("Dimension mismatch: Image %dx%d v. Mask %dx%d") %
                    _image->getWidth() % _image->getHeight() % 
                    _mask->getWidth() % _mask->getHeight()
                ).str()
            );
        }
    }

    if (!_variance || _variance->getWidth() == 0 || _variance->getHeight() == 0) {
        _variance = VariancePtr(new Variance(_image->getBBox()));
        *_variance = 0;
    } else {
        if (_variance->getDimensions() != _image->getDimensions()) {
            throw LSST_EXCEPT(
                lsst::pex::exceptions::LengthError,
                (boost::format("Dimension mismatch: Image %dx%d v. Variance %dx%d") %
                    _image->getWidth() % _image->getHeight() % 
                    _variance->getWidth() % _variance->getHeight()
                ).str()
            );
        }
    }
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

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

(

void

)

const

Return an iterator to the end of the image.

Definition at line 702 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);
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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.

Exceptions

lsst::pex::exceptions::Runtime

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

Parameters

contiguous

Pixels are contiguous (must be true)

Definition at line 809 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);
}

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

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

inline

Definition at line 905 of file MaskedImage.h.

{return _image->getBBox(origin);}

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

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

inline

Definition at line 904 of file MaskedImage.h.

{return _image->getDimensions();}

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 903 of file MaskedImage.h.

{ return _image->getHeight(); }

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

ImagePtr lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getImage ( bool const  noThrow = false ) const

inline

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

Definition at line 869 of file MaskedImage.h.

                                                      {
        if (!_image && !noThrow) {
            throw LSST_EXCEPT(
                lsst::pex::exceptions::RuntimeError,
                "MaskedImage's Image is NULL"
            );
        }
        return _image;
    }

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

MaskPtr lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getMask ( bool const  noThrow = false ) const

inline

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

Definition at line 879 of file MaskedImage.h.

                                                    {
        if (!_mask && !noThrow) {
            throw LSST_EXCEPT(
                lsst::pex::exceptions::RuntimeError,
                "MaskedImage's Mask is NULL"
            );
        }

        return _mask;
    }

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

VariancePtr lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::getVariance ( bool const  noThrow = false ) const

inline

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

Definition at line 890 of file MaskedImage.h.

                                                            {
        if (!_variance && !noThrow) {
            throw LSST_EXCEPT(
                lsst::pex::exceptions::RuntimeError,
                "MaskedImage's Variance is NULL"
            );
        }

        return _variance;
    }

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 901 of file MaskedImage.h.

{ return _image->getWidth(); }

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 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 913 of file MaskedImage.h.

{ return _image->getX0(); }

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

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 929 of file MaskedImage.h.

{ return _image->getXY0(); }

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 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 921 of file MaskedImage.h.

{ return _image->getY0(); }

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 971 of file MaskedImage.h.

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

template<typename ImagePixelT, typename MaskPixelT , typename VariancePixelT >

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

(

ImagePixelT const

rhs

)

Definition at line 499 of file MaskedImage.cc.

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

template<typename ImagePixelT, typename MaskPixelT , typename VariancePixelT >

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

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const &

rhs

)

Definition at line 470 of file MaskedImage.cc.

                                                                                                 {
    // Must do variance before we modify the image values
    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();
}

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

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

inline

Definition at line 769 of file MaskedImage.h.

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

template<typename ImagePixelT, typename MaskPixelT , typename VariancePixelT >

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

(

ImagePixelT const

rhs

)

Add a scalar rhs to a MaskedImage.

Definition at line 414 of file MaskedImage.cc.

                                                                                                {
    *_image += rhs;
}

template<typename ImagePixelT, typename MaskPixelT , typename VariancePixelT >

void 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 391 of file MaskedImage.cc.

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

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

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

inline

Definition at line 749 of file MaskedImage.h.

                                                               {
        *_image += rhs;
    }

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

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

inline

Definition at line 752 of file MaskedImage.h.

                                                                  {
        *_image += function;
    }

template<typename ImagePixelT, typename MaskPixelT , typename VariancePixelT >

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

(

ImagePixelT const

rhs

)

Subtract a scalar rhs from a MaskedImage.

Definition at line 445 of file MaskedImage.cc.

                                                                                                {
    *_image -= rhs;
}

template<typename ImagePixelT, typename MaskPixelT , typename VariancePixelT >

void 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 424 of file MaskedImage.cc.

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

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

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

inline

Definition at line 759 of file MaskedImage.h.

                                                               {
        *_image -= rhs;
    }

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

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

inline

Definition at line 762 of file MaskedImage.h.

                                                                  {
        *_image -= function;
    }

template<typename ImagePixelT, typename MaskPixelT , typename VariancePixelT >

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

(

ImagePixelT const

rhs

)

Definition at line 556 of file MaskedImage.cc.

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

template<typename ImagePixelT, typename MaskPixelT , typename VariancePixelT >

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

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const &

rhs

)

Definition at line 527 of file MaskedImage.cc.

                                                                                                 {
    // Must do variance before we modify the image values
    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();
}

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

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

inline

Definition at line 778 of file MaskedImage.h.

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

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

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

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > const &

rhs

)

Copy the pixels from the rhs to the lhs

Note

operator=() is not equivalent to this command

Definition at line 377 of file MaskedImage.cc.

                                                                                                  {
    *_image <<= *rhs.getImage();
    *_mask <<= *rhs.getMask();
    *_variance <<= *rhs.getVariance();
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

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

(

image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > 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 operator<<=()

Parameters

rhs	Right hand side

Definition at line 328 of file MaskedImage.cc.

                        {}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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 350 of file MaskedImage.cc.

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

    return *this;
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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 363 of file MaskedImage.cc.

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

    return *this;
}

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 983 of file MaskedImage.h.

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

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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 722 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);
}

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 854 of file MaskedImage.h.

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

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 863 of file MaskedImage.h.

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

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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 732 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);
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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 742 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);
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

image::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 752 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);
}

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 541 of file MaskedImage.cc.

                                                                                                        {
    // Must do variance before we modify the image values
    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;
}

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 436 of file MaskedImage.cc.

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

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 484 of file MaskedImage.cc.

                                                                                                           {
    // Must do variance before we modify the image values
    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();
}

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 405 of file MaskedImage.cc.

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

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 939 of file MaskedImage.h.

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

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

void lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::setXY0 ( 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 951 of file MaskedImage.h.

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

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

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

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

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

(

MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > &

rhs

)

Definition at line 333 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);
}

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::writeFits	(	std::string const &	fileName,
		boost::shared_ptr< daf::base::PropertySet const >	metadata = boost::shared_ptr< daf::base::PropertySet const>(),
		boost::shared_ptr< daf::base::PropertySet const >	imageMetadata = boost::shared_ptr< daf::base::PropertySet const>(),
		boost::shared_ptr< daf::base::PropertySet const >	maskMetadata = boost::shared_ptr< daf::base::PropertySet const>(),
		boost::shared_ptr< daf::base::PropertySet const >	varianceMetadata = boost::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 562 of file MaskedImage.cc.

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

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::writeFits	(	fits::MemFileManager &	manager,
		boost::shared_ptr< daf::base::PropertySet const >	metadata = boost::shared_ptr< daf::base::PropertySet const>(),
		boost::shared_ptr< daf::base::PropertySet const >	imageMetadata = boost::shared_ptr< daf::base::PropertySet const>(),
		boost::shared_ptr< daf::base::PropertySet const >	maskMetadata = boost::shared_ptr< daf::base::PropertySet const>(),
		boost::shared_ptr< daf::base::PropertySet const >	varianceMetadata = boost::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 574 of file MaskedImage.cc.

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

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

void lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::writeFits	(	fits::Fits &	fitsfile,
		boost::shared_ptr< daf::base::PropertySet const >	metadata = boost::shared_ptr< daf::base::PropertySet const>(),
		boost::shared_ptr< daf::base::PropertySet const >	imageMetadata = boost::shared_ptr< daf::base::PropertySet const>(),
		boost::shared_ptr< daf::base::PropertySet const >	maskMetadata = boost::shared_ptr< daf::base::PropertySet const>(),
		boost::shared_ptr< daf::base::PropertySet const >	varianceMetadata = boost::shared_ptr< daf::base::PropertySet const>()
	)		const

Write a MaskedImage to a FITS RAM 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 604 of file MaskedImage.cc.

        {

    PTR(daf::base::PropertySet) hdr;
    if (metadata) {
        hdr = metadata->deepCopy();
    } else {
        hdr.reset(new 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(1);
    }
    fitsfile.writeMetadata(*hdr);

    processPlaneMetadata(imageMetadata, hdr, "IMAGE");
    _image->writeFits(fitsfile, hdr);

    processPlaneMetadata(maskMetadata, hdr, "MASK");
    _mask->writeFits(fitsfile, hdr);

    processPlaneMetadata(varianceMetadata, hdr, "VARIANCE");
    _variance->writeFits(fitsfile, hdr);
}

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 1006 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);
    }

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 1039 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);
    }

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 1024 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);
    }

Member Data Documentation

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

ImagePtr lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::_image

private

Definition at line 1058 of file MaskedImage.h.

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

MaskPtr lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::_mask

private

Definition at line 1059 of file MaskedImage.h.

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

VariancePtr lsst.afw.image::MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT >::_variance

private

Definition at line 1060 of file MaskedImage.h.

---

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

• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/include/lsst/afw/image/MaskedImage.h
• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/src/image/MaskedImage.cc