lsst.afw.image::Mask< MaskPixelT > Class Template Reference

Represent a 2-dimensional array of bitmask pixels. More...

#include <Mask.h>

Inheritance diagram for lsst.afw.image::Mask< MaskPixelT >:

Classes
struct	ImageTypeFactory
	A templated class to return this classes' type (present in Image/Mask/MaskedImage) More...

Public Types
typedef boost::shared_ptr< Mask >	Ptr
typedef boost::shared_ptr < const Mask >	ConstPtr
typedef detail::MaskPlaneDict	MaskPlaneDict
typedef detail::Mask_tag	image_category
Public Types inherited from lsst.afw.image::ImageBase< MaskPixelT >
typedef boost::shared_ptr < ImageBase< MaskPixelT > >	Ptr
	A shared_ptr to an ImageBase. More...
typedef boost::shared_ptr < const ImageBase< MaskPixelT > >	ConstPtr
	A shared_ptr to a const ImageBase. More...
typedef detail::basic_tag	image_category
	trait class to identify type of image More...
typedef MaskPixelT	SinglePixel
	A single Pixel of the same type as those in the ImageBase. More...
typedef MaskPixelT	Pixel
	A pixel in this ImageBase. More...
typedef Reference< MaskPixelT > ::type	PixelReference
	A Reference to a PixelT. More...
typedef ConstReference < MaskPixelT >::type	PixelConstReference
	A ConstReference to a PixelT. More...
typedef _view_t::xy_locator	xy_locator
	An xy_locator. More...
typedef _view_t::xy_locator::const_t	const_xy_locator
	A const_xy_locator. More...
typedef _view_t::iterator	iterator
	An STL compliant iterator. More...
typedef _const_view_t::iterator	const_iterator
	An STL compliant const iterator. More...
typedef _view_t::reverse_iterator	reverse_iterator
	An STL compliant reverse iterator. More...
typedef _const_view_t::reverse_iterator	const_reverse_iterator
	An STL compliant const reverse iterator. More...
typedef _view_t::x_iterator	x_iterator
	An iterator for traversing the pixels in a row. More...
typedef x_iterator	fast_iterator
typedef _view_t::x_iterator	xy_x_iterator
	An iterator for traversing the pixels in a row, created from an xy_locator. More...
typedef _const_view_t::x_iterator	const_x_iterator
	A const iterator for traversing the pixels in a row. More...
typedef _view_t::y_iterator	y_iterator
	An iterator for traversing the pixels in a column. More...
typedef _view_t::y_iterator	xy_y_iterator
	An iterator for traversing the pixels in a row, created from an xy_locator. More...
typedef _const_view_t::y_iterator	const_y_iterator
	A const iterator for traversing the pixels in a column. More...
typedef ndarray::Array < MaskPixelT, 2, 1 >	Array
	A mutable ndarray representation of the image. More...
typedef ndarray::Array < MaskPixelTconst, 2, 1 >	ConstArray
	An immutable ndarray representation of the image. 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
	Mask (unsigned int width, unsigned int height, MaskPlaneDict const &planeDefs=MaskPlaneDict())
	Construct a Mask initialized to 0x0. More...
	Mask (unsigned int width, unsigned int height, MaskPixelT initialValue, MaskPlaneDict const &planeDefs=MaskPlaneDict())
	Construct a Mask initialized to a specified value. More...
	Mask (geom::Extent2I const &dimensions=geom::Extent2I(), MaskPlaneDict const &planeDefs=MaskPlaneDict())
	Construct a Mask initialized to 0x0. More...
	Mask (geom::Extent2I const &dimensions, MaskPixelT initialValue, MaskPlaneDict const &planeDefs=MaskPlaneDict())
	Construct a Mask initialized to a specified value. More...
	Mask (geom::Box2I const &bbox, MaskPlaneDict const &planeDefs=MaskPlaneDict())
	Construct a Mask initialized to 0x0. More...
	Mask (geom::Box2I const &bbox, MaskPixelT initialValue, MaskPlaneDict const &planeDefs=MaskPlaneDict())
	Construct a Mask initialized to a specified value. More...
	Mask (std::string const &fileName, int hdu=0, boost::shared_ptr< lsst::daf::base::PropertySet > metadata=boost::shared_ptr< lsst::daf::base::PropertySet >(), geom::Box2I const &bbox=geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false)
	Construct a Mask by reading a regular FITS file. More...
	Mask (fits::MemFileManager &manager, int hdu=0, boost::shared_ptr< lsst::daf::base::PropertySet > metadata=boost::shared_ptr< lsst::daf::base::PropertySet >(), geom::Box2I const &bbox=geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false)
	Construct a Mask by reading a FITS image in memory. More...
	Mask (fits::Fits &fitsfile, boost::shared_ptr< lsst::daf::base::PropertySet > metadata=boost::shared_ptr< lsst::daf::base::PropertySet >(), geom::Box2I const &bbox=geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false)
	Construct a Mask from an already-open FITS object. More...
template<typename OtherPixelT >
	Mask (Mask< OtherPixelT > const &rhs, const bool deep)
	Mask (const Mask &src, const bool deep=false)
	Construct a Mask from another Mask. More...
	Mask (const Mask &src, const geom::Box2I &bbox, ImageOrigin const origin=PARENT, const bool deep=false)
	Construct a Mask from a subregion of another Mask. More...
	Mask (ndarray::Array< MaskPixelT, 2, 1 > const &array, bool deep=false, geom::Point2I const &xy0=geom::Point2I())
void	swap (Mask &rhs)
Mask &	operator= (MaskPixelT const rhs)
Mask &	operator= (const Mask &rhs)
void	operator|= (Mask const &rhs)
	OR a Mask into a Mask. More...
void	operator|= (MaskPixelT const rhs)
	OR a bitmask into a Mask. More...
void	operator&= (Mask const &rhs)
	AND a Mask into a Mask. More...
void	operator&= (MaskPixelT const rhs)
	AND a bitmask into a Mask. More...
void	operator^= (Mask const &rhs)
	XOR a Mask into a Mask. More...
void	operator^= (MaskPixelT const rhs)
	XOR a bitmask into a Mask. More...
ImageBase< MaskPixelT > ::PixelReference	operator() (int x, int y)
	get a reference to the specified pixel More...
ImageBase< MaskPixelT > ::PixelConstReference	operator() (int x, int y) const
	get the specified pixel (const version) More...
bool	operator() (int x, int y, int plane) const
	is the specified mask plane set in the specified pixel? More...
ImageBase< MaskPixelT > ::PixelReference	operator() (int x, int y, CheckIndices const &)
	get a reference to the specified pixel checking array bounds More...
ImageBase< MaskPixelT > ::PixelConstReference	operator() (int x, int y, CheckIndices const &) const
	get the specified pixel with array checking (const version) More...
bool	operator() (int x, int y, int plane, CheckIndices const &) const
	is the specified mask plane set in the specified pixel, checking array bounds? More...
void	writeFits (std::string const &fileName, boost::shared_ptr< lsst::daf::base::PropertySet const > metadata=boost::shared_ptr< lsst::daf::base::PropertySet >(), std::string const &mode="w") const
	Write a mask to a regular FITS file. More...
void	writeFits (fits::MemFileManager &manager, boost::shared_ptr< lsst::daf::base::PropertySet const > metadata=boost::shared_ptr< lsst::daf::base::PropertySet >(), std::string const &mode="w") const
	Write a mask to a FITS RAM file. More...
void	writeFits (fits::Fits &fitsfile, boost::shared_ptr< lsst::daf::base::PropertySet const > metadata=boost::shared_ptr< lsst::daf::base::PropertySet const >()) const
	Write a mask to an open FITS file object. More...
std::string	getAsString (int x, int y)
void	clearAllMaskPlanes ()
	Clear all the pixels. More...
void	clearMaskPlane (int plane)
	Clear the specified bit in all pixels. More...
void	setMaskPlaneValues (const int plane, const int x0, const int x1, const int y)
	Set the bit specified by "planeId" for pixels (x0, y) ... (x1, y) More...
void	removeAndClearMaskPlane (const std::string &name, bool const removeFromDefault=false)
	Clear all pixels of the specified mask and remove the plane from the mask plane dictionary; optionally remove the plane from the default dictionary too. More...
MaskPlaneDict const &	getMaskPlaneDict () const
void	printMaskPlanes () const
	print the mask plane dictionary to std::cout More...
void	conformMaskPlanes (const MaskPlaneDict &masterPlaneDict)
	Adjust this mask to conform to the standard Mask class's mask plane dictionary, adding any new mask planes to the standard. More...
Public Member Functions inherited from lsst.afw.image::ImageBase< MaskPixelT >
	ImageBase (const geom::Extent2I &dimensions=geom::Extent2I())
	ImageBase (const geom::Box2I &bbox)
	ImageBase (const ImageBase &src, const bool deep=false)
	ImageBase (const ImageBase &src, const geom::Box2I &bbox, const ImageOrigin origin=PARENT, const bool deep=false)
	ImageBase (const ImageBase< OtherPixelT > &rhs, const bool deep)
	ImageBase (Array const &array, bool deep=false, geom::Point2I const &xy0=geom::Point2I())
virtual	~ImageBase ()
ImageBase &	operator= (const ImageBase &rhs)
ImageBase &	operator= (const MaskPixelTrhs)
void	operator<<= (const ImageBase &rhs)
PixelReference	operator() (int x, int y)
PixelReference	operator() (int x, int y, CheckIndices const &)
PixelConstReference	operator() (int x, int y) const
PixelConstReference	operator() (int x, int y, CheckIndices const &) const
PixelConstReference	get0 (int x, int y) const
PixelConstReference	get0 (int x, int y, CheckIndices const &check) const
void	set0 (int x, int y, const MaskPixelTv)
void	set0 (int x, int y, const MaskPixelTv, CheckIndices const &check)
int	getWidth () const
	Return the number of columns in the image. More...
int	getHeight () const
	Return the number of rows in the image. More...
int	getX0 () const
int	getY0 () const
geom::Point2I	getXY0 () const
std::pair< int, double >	positionToIndex (double const pos, lsst::afw::image::xOrY const xy) const
	Convert image position to index (nearest integer and fractional parts) More...
double	indexToPosition (double ind, lsst::afw::image::xOrY const xy) const
	Convert image index to image position. More...
geom::Extent2I	getDimensions () const
	Return the image's size; useful for passing to constructors. More...
void	swap (ImageBase &rhs)
Array	getArray ()
ConstArray	getArray () const
iterator	begin () const
fast_iterator	begin (bool) const
iterator	end () const
fast_iterator	end (bool) const
reverse_iterator	rbegin () const
reverse_iterator	rend () const
iterator	at (int x, int y) const
x_iterator	row_begin (int y) const
x_iterator	row_end (int y) const
	Return an x_iterator to the end of the y'th row. More...
x_iterator	x_at (int x, int y) const
	Return an x_iterator to the point (x, y) in the image. More...
y_iterator	col_begin (int x) const
y_iterator	col_end (int x) const
	Return an y_iterator to the end of the y'th row. More...
y_iterator	y_at (int x, int y) const
	Return an y_iterator to the point (x, y) in the image. More...
xy_locator	xy_at (int x, int y) const
void	setXY0 (geom::Point2I const origin)
void	setXY0 (int const x0, int const y0)
geom::Box2I	getBBox (ImageOrigin origin=PARENT) const
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 MaskPixelT	getPlaneBitMask (const std::vector< std::string > &names)
	Return the bitmask corresponding to a vector of plane names OR'd together. More...
static Mask	readFits (std::string const &filename, int hdu=0)
	Read a Mask from a regular FITS file. More...
static Mask	readFits (fits::MemFileManager &manager, int hdu=0)
	Read a Mask from a FITS RAM file. More...
static std::string	interpret (MaskPixelT value)
	Interpret a mask value as a comma-separated list of mask plane names. More...
static MaskPlaneDict	parseMaskPlaneMetadata (boost::shared_ptr< lsst::daf::base::PropertySet const >)
	Given a PropertySet that contains the MaskPlane assignments, setup the MaskPlanes. More...
static void	clearMaskPlaneDict ()
	Reset the maskPlane dictionary. More...
static int	addMaskPlane (const std::string &name)
static void	removeMaskPlane (const std::string &name)
static int	getMaskPlane (const std::string &name)
	Return the mask plane number corresponding to a plane name. More...
static MaskPixelT	getPlaneBitMask (const std::string &name)
	Return the bitmask corresponding to a plane name. More...
static int	getNumPlanesMax ()
static int	getNumPlanesUsed ()
	Reset the maskPlane dictionary. More...
static void	addMaskPlanesToMetadata (boost::shared_ptr< lsst::daf::base::PropertySet >)
	Given a PropertySet, replace any existing MaskPlane assignments with the current ones. More...
Static Public Member Functions inherited from lsst.afw.image::ImageBase< MaskPixelT >
static SinglePixel	PixelCast (SinglePixelT rhs)
	Convert a type to our SinglePixel type. 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	_initializePlanes (MaskPlaneDict const &planeDefs)
	Initialise mask planes; called by constructors. More...
void	checkMaskDictionaries (Mask const &other)

Static Private Member Functions
static boost::shared_ptr < detail::MaskDict >	_maskPlaneDict ()
static int	_setMaskPlaneDict (MaskPlaneDict const &mpd)
static int	addMaskPlane (std::string name, int plane)
	set the name of a mask plane, with minimal checking. More...
static int	getMaskPlaneNoThrow (const std::string &name)
	Return the mask plane number corresponding to a plane name, or -1 if not found. More...
static MaskPixelT	getBitMaskNoThrow (int plane)
	Return the bitmask corresponding to a plane ID, or 0 if invalid. More...
static MaskPixelT	getBitMask (int plane)
	Return the bitmask corresponding to plane ID. More...

Private Attributes
boost::shared_ptr < detail::MaskDict >	_maskDict

Static Private Attributes
static const std::string	maskPlanePrefix

Additional Inherited Members
Protected Member Functions inherited from lsst.afw.image::ImageBase< MaskPixelT >
_view_t	_getRawView () const
bool	isContiguous () const
Static Protected Member Functions inherited from lsst.afw.image::ImageBase< MaskPixelT >
static _view_t	_allocateView (geom::Extent2I const &dimensions, Manager::Ptr &manager)
static _view_t	_makeSubView (geom::Extent2I const &dimensions, geom::Extent2I const &offset, const _view_t &view)

Detailed Description

template<typename MaskPixelT = lsst::afw::image::MaskPixel>
class lsst.afw.image::Mask< MaskPixelT >

Represent a 2-dimensional array of bitmask pixels.

Some mask planes are always defined (although you can add more with Mask::addMaskPlane):

• BAD This pixel is known to be bad (e.g. the amplifier is not working)

• CR This pixel is contaminated by a cosmic ray

• DETECTED This pixel lies within an object's Footprint

• DETECTED_NEGATIVE This pixel lies within an object's Footprint, and the detection was looking for pixels below a specified level

• EDGE This pixel is too close to the edge to be processed properly

• INTRP This pixel has been interpolated over

  Note

  should be called INTERPOLATED

• SAT This pixel is saturated and has bloomed

  Note

  should be called SATURATED

• SUSPECT This pixel is untrustworthy, and you may wish to discard any Source containing it

Examples:

footprintFunctor.cc.

Definition at line 93 of file Mask.h.

Member Typedef Documentation

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

typedef boost::shared_ptr<const Mask> lsst.afw.image::Mask< MaskPixelT >::ConstPtr

Definition at line 96 of file Mask.h.

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

typedef detail::Mask_tag lsst.afw.image::Mask< MaskPixelT >::image_category

Definition at line 99 of file Mask.h.

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

typedef detail::MaskPlaneDict lsst.afw.image::Mask< MaskPixelT >::MaskPlaneDict

Definition at line 97 of file Mask.h.

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

typedef boost::shared_ptr<Mask> lsst.afw.image::Mask< MaskPixelT >::Ptr

Definition at line 95 of file Mask.h.

Constructor & Destructor Documentation

template<typename MaskPixelT >

lsst.afw.image::Mask< MaskPixelT >::Mask ( unsigned int  width, unsigned int  height, MaskPlaneDict const &  planeDefs = MaskPlaneDict()  )

explicit

Construct a Mask initialized to 0x0.

Parameters

width	number of columns
height	number of rows
planeDefs	desired mask planes

Definition at line 404 of file Mask.cc.

  :
    ImageBase<MaskPixelT>(afwGeom::ExtentI(width, height)) {
    _initializePlanes(planeDefs);
    *this = 0x0;
}

template<typename MaskPixelT>

lsst.afw.image::Mask< MaskPixelT >::Mask ( unsigned int  width, unsigned int  height, MaskPixelT  initialValue, MaskPlaneDict const &  planeDefs = MaskPlaneDict()  )

explicit

Construct a Mask initialized to a specified value.

Parameters

width	number of columns
height	number of rows
initialValue	Initial value
planeDefs	desired mask planes

Definition at line 418 of file Mask.cc.

  :
    ImageBase<MaskPixelT>(afwGeom::ExtentI(width, height)) {
    _initializePlanes(planeDefs);
    *this = initialValue;
}

template<typename MaskPixelT>

lsst.afw.image::Mask< MaskPixelT >::Mask ( geom::Extent2I const &  dimensions = geom::Extent2I(), MaskPlaneDict const &  planeDefs = MaskPlaneDict()  )

explicit

Construct a Mask initialized to 0x0.

Parameters

dimensions	Number of columns, rows
planeDefs	desired mask planes

Definition at line 433 of file Mask.cc.

  :
    ImageBase<MaskPixelT>(dimensions) {
    _initializePlanes(planeDefs);
    *this = 0x0;
}

template<typename MaskPixelT>

lsst.afw.image::Mask< MaskPixelT >::Mask ( geom::Extent2I const &  dimensions, MaskPixelT  initialValue, MaskPlaneDict const &  planeDefs = MaskPlaneDict()  )

explicit

Construct a Mask initialized to a specified value.

Parameters

dimensions	Number of columns, rows
initialValue	Initial value
planeDefs	desired mask planes

Definition at line 446 of file Mask.cc.

  :
    ImageBase<MaskPixelT>(dimensions) {
    _initializePlanes(planeDefs);
    *this = initialValue;
}

template<typename MaskPixelT>

lsst.afw.image::Mask< MaskPixelT >::Mask ( geom::Box2I const &  bbox, MaskPlaneDict const &  planeDefs = MaskPlaneDict()  )

explicit

Construct a Mask initialized to 0x0.

Parameters

bbox	Desired number of columns/rows and origin
planeDefs	desired mask planes

Definition at line 460 of file Mask.cc.

  :
    ImageBase<MaskPixelT>(bbox) {
    _initializePlanes(planeDefs);
    *this = 0x0;
}

template<typename MaskPixelT>

lsst.afw.image::Mask< MaskPixelT >::Mask ( geom::Box2I const &  bbox, MaskPixelT  initialValue, MaskPlaneDict const &  planeDefs = MaskPlaneDict()  )

explicit

Construct a Mask initialized to a specified value.

Parameters

bbox	Desired number of columns/rows and origin
initialValue	Initial value
planeDefs	desired mask planes

Definition at line 473 of file Mask.cc.

  :
    ImageBase<MaskPixelT>(bbox) {
    _initializePlanes(planeDefs);
    *this = initialValue;
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

lsst.afw.image::Mask< MaskPixelT >::Mask ( std::string const &  fileName, int  hdu = 0, boost::shared_ptr< lsst::daf::base::PropertySet >  metadata = boost::shared_ptr< lsst::daf::base::PropertySet >(), geom::Box2I const &  bbox = geom::Box2I(), ImageOrigin  origin = PARENT, bool  conformMasks = false  )

explicit

Construct a Mask by reading a regular FITS file.

Parameters

[in]	fileName	File to read.
[in]	hdu	HDU to read, 1-indexed (i.e. 1=Primary HDU). The special value of 0 reads the Primary HDU unless it is empty, in which case it reads the first extension HDU.
[in,out]	metadata	Metadata read from the header (may be null).
[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.

The meaning of the bitplanes is given in the header. If conformMasks is false (default), the bitvalues will be changed to match those in Mask's plane dictionary. If it's true, the bitvalues will be left alone, but Mask's dictionary will be modified to match the on-disk version.

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

lsst.afw.image::Mask< MaskPixelT >::Mask ( fits::MemFileManager &  manager, int  hdu = 0, boost::shared_ptr< lsst::daf::base::PropertySet >  metadata = boost::shared_ptr< lsst::daf::base::PropertySet >(), geom::Box2I const &  bbox = geom::Box2I(), ImageOrigin  origin = PARENT, bool  conformMasks = false  )

explicit

Construct a Mask by reading a FITS image in memory.

Parameters

[in]	manager	An object that manages the memory buffer to read.
[in]	hdu	HDU to read, 1-indexed (i.e. 1=Primary HDU). The special value of 0 reads the Primary HDU unless it is empty, in which case it reads the first extension HDU.
[in,out]	metadata	Metadata read from the header (may be null).
[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.

The meaning of the bitplanes is given in the header. If conformMasks is false (default), the bitvalues will be changed to match those in Mask's plane dictionary. If it's true, the bitvalues will be left alone, but Mask's dictionary will be modified to match the on-disk version.

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

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

explicit

Construct a Mask from an already-open FITS object.

Parameters

[in]	fitsfile	A FITS object to read from, already at the desired HDU.
[in,out]	metadata	Metadata read from the header (may be null).
[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.

The meaning of the bitplanes is given in the header. If conformMasks is false (default), the bitvalues will be changed to match those in Mask's plane dictionary. If it's true, the bitvalues will be left alone, but Mask's dictionary will be modified to match the on-disk version.

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

template<typename OtherPixelT >

lsst.afw.image::Mask< MaskPixelT >::Mask ( Mask< OtherPixelT > const &  rhs, const bool  deep  )

inline

Definition at line 211 of file Mask.h.

                                                        :
        image::ImageBase<MaskPixelT>(rhs, deep),
        _maskDict(rhs._maskDict) {}

template<typename MaskPixelT>

lsst.afw.image::Mask< MaskPixelT >::Mask	(	const Mask< MaskPixelT > &	src,
		const bool	deep = false
	)

Construct a Mask from another Mask.

Parameters

src	mask to copy
deep	deep copy? (construct a view with shared pixels if false)

Definition at line 500 of file Mask.cc.

  :
    ImageBase<MaskPixelT>(rhs, deep), _maskDict(rhs._maskDict) {
}

template<typename MaskPixelT>

lsst.afw.image::Mask< MaskPixelT >::Mask	(	const Mask< MaskPixelT > &	src,
		const geom::Box2I &	bbox,
		ImageOrigin const	origin = PARENT,
		const bool	deep = false
	)

Construct a Mask from a subregion of another Mask.

Parameters

src	mask to copy
bbox	subregion to copy
origin	coordinate system of the bbox
deep	deep copy? (construct a view with shared pixels if false)

Definition at line 487 of file Mask.cc.

  :
    ImageBase<MaskPixelT>(rhs, bbox, origin, deep), _maskDict(rhs._maskDict) {
}

template<typename MaskPixelT>

lsst.afw.image::Mask< MaskPixelT >::Mask ( ndarray::Array< MaskPixelT, 2, 1 > const &  array, bool  deep = false, geom::Point2I const &  xy0 = geom::Point2I()  )

explicit

Definition at line 508 of file Mask.cc.

                                                :
        image::ImageBase<MaskPixelT>(array, deep, xy0),
        _maskDict(detail::MaskDict::makeMaskDict()) {
}

Member Function Documentation

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::_initializePlanes ( MaskPlaneDict const &  planeDefs )

private

Initialise mask planes; called by constructors.

Definition at line 394 of file Mask.cc.

                                                                       {
    pexLog::Trace("afw.Mask", 5, boost::format("Number of mask planes: %d") % getNumPlanesMax());

    _maskDict = detail::MaskDict::makeMaskDict(planeDefs);
}

template<typename MaskPixelT >

boost::shared_ptr< detail::MaskDict > lsst.afw.image::Mask< MaskPixelT >::_maskPlaneDict ( )

staticprivate

Definition at line 1246 of file Mask.cc.

{
    return detail::MaskDict::makeMaskDict();
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

static int lsst.afw.image::Mask< MaskPixelT >::_setMaskPlaneDict ( MaskPlaneDict const &  mpd )

staticprivate

template<typename MaskPixelT >

int lsst.afw.image::Mask< MaskPixelT >::addMaskPlane ( const std::string &  name )

static

Definition at line 700 of file Mask.cc.

{
    int id = getMaskPlaneNoThrow(name); // see if the plane is already available

    if (id < 0) {                       // doesn't exist
        id = _maskPlaneDict()->getUnusedPlane();
    }

    // build new entry, adding the plane to all Masks where this is no contradiction

    if (id >= getNumPlanesMax()) {      // Max number of planes is already allocated
        throw LSST_EXCEPT(pexExcept::RuntimeError,
                          str(boost::format("Max number of planes (%1%) already used") % getNumPlanesMax()));
    }

    _state.forEachMaskDict(addPlaneFunctor(name, id));    

    return id;
}

template<typename MaskPixelT >

int lsst.afw.image::Mask< MaskPixelT >::addMaskPlane ( std::string  name, int  planeId  )

staticprivate

set the name of a mask plane, with minimal checking.

This is a private function and is mainly used by setMaskPlaneMetadata

Parameters

name	new name of mask plane
planeId	ID of mask plane to be (re)named

Definition at line 726 of file Mask.cc.

  {
    if (planeId < 0 || planeId >= getNumPlanesMax()) {
        throw LSST_EXCEPT(pexExcept::RangeError,
                     str(boost::format("mask plane ID must be between 0 and %1%") % (getNumPlanesMax() - 1)));
    }

    _maskPlaneDict()->add(name, planeId);

    return planeId;
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

void lsst.afw.image::Mask< MaskPixelT >::addMaskPlanesToMetadata ( boost::shared_ptr< lsst::daf::base::PropertySet >  )

static

Given a PropertySet, replace any existing MaskPlane assignments with the current ones.

Definition at line 1155 of file Mask.cc.

                                                                               {
    if (!metadata) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, "Null PTR(PropertySet)");
    }

    // First, clear existing MaskPlane metadata
    typedef std::vector<std::string> NameList;
    NameList paramNames = metadata->paramNames(false);
    for (NameList::const_iterator i = paramNames.begin(); i != paramNames.end(); ++i) {
        if (i->compare(0, maskPlanePrefix.size(), maskPlanePrefix) == 0) {
            metadata->remove(*i);
        }
    }

    MaskPlaneDict const& mpd = _maskPlaneDict()->getMaskPlaneDict();

    // Add new MaskPlane metadata
    for (MaskPlaneDict::const_iterator i = mpd.begin(); i != mpd.end() ; ++i) {
        std::string const& planeName = i->first;
        int const planeNumber = i->second;

        if (planeName != "") {
            metadata->add(maskPlanePrefix + planeName, planeNumber);
        }
    }
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

void lsst.afw.image::Mask< MaskPixelT >::checkMaskDictionaries ( Mask< MaskPixelT > const &  other )

private

Definition at line 1053 of file Mask.cc.

                                                                          {
    if (*_maskDict != *other._maskDict) {
        throw LSST_EXCEPT(pexExcept::RuntimeError, "Mask dictionaries do not match");
    }
}        

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::clearAllMaskPlanes

(

)

Clear all the pixels.

Definition at line 889 of file Mask.cc.

                                          {
    *this = 0;
}

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::clearMaskPlane

(

int

plane

)

Clear the specified bit in all pixels.

Definition at line 897 of file Mask.cc.

                                                 {
    *this &= ~getBitMask(planeId);
}

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::clearMaskPlaneDict ( )

static

Reset the maskPlane dictionary.

Definition at line 881 of file Mask.cc.

                                          {
    _maskPlaneDict()->clear();
}

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::conformMaskPlanes

(

const MaskPlaneDict &

masterPlaneDict

)

Adjust this mask to conform to the standard Mask class's mask plane dictionary, adding any new mask planes to the standard.

Ensures that this mask (presumably from some external source) has the same plane assignments as the Mask class. If a change in plane assignments is needed, the bits within each pixel are permuted as required. The provided currentPlaneDict describes the true state of the bits in this Mask's pixels and overrides its current MaskDict

Any new mask planes found in this mask are added to unused slots in the Mask class's mask plane dictionary.

Parameters

masterPlaneDict

mask plane dictionary currently in use for this mask

Definition at line 913 of file Mask.cc.

{
    PTR(detail::MaskDict) currentMD = detail::MaskDict::makeMaskDict(currentPlaneDict);

    if (*_maskDict == *currentMD) {
        if (*detail::MaskDict::makeMaskDict() == *_maskDict) {
            return;   // nothing to do
        }
    } else {
        //
        // Find out which planes need to be permuted
        //
        MaskPixelT keepBitmask = 0;       // mask of bits to keep
        MaskPixelT canonicalMask[sizeof(MaskPixelT)*8]; // bits in lsst::afw::image::Mask that should be
        MaskPixelT currentMask[sizeof(MaskPixelT)*8];   //           mapped to these bits
        int numReMap = 0;

        for (MaskPlaneDict::const_iterator i = currentPlaneDict.begin(); i != currentPlaneDict.end() ; i++) {
            std::string const name = i->first; // name of mask plane
            int const currentPlaneNumber = i->second; // plane number currently in use
            int canonicalPlaneNumber = getMaskPlaneNoThrow(name); // plane number in lsst::afw::image::Mask

            if (canonicalPlaneNumber < 0) {                  // no such plane; add it
                canonicalPlaneNumber = addMaskPlane(name);
            }
        
            if (canonicalPlaneNumber == currentPlaneNumber) {
                keepBitmask |= getBitMask(canonicalPlaneNumber); // bit is unchanged, so preserve it
            } else {
                canonicalMask[numReMap] = getBitMask(canonicalPlaneNumber);
                currentMask[numReMap]   = getBitMaskNoThrow(currentPlaneNumber);
                numReMap++;
            }
        }

        // Now loop over all pixels in Mask
        if (numReMap > 0) {
            for (int r = 0; r != this->getHeight(); ++r) { // "this->": Meyers, Effective C++, Item 43
                for (typename Mask::x_iterator ptr = this->row_begin(r), end = this->row_end(r);
                     ptr != end; ++ptr) {
                    MaskPixelT const pixel = *ptr;

                    MaskPixelT newPixel = pixel & keepBitmask; // value of invariant mask bits
                    for (int i = 0; i < numReMap; i++) {
                        if (pixel & currentMask[i]) newPixel |= canonicalMask[i];
                    }

                    *ptr = newPixel;
                }
            }
        }
    }
    // We've made the planes match the current mask dictionary
    _maskDict = detail::MaskDict::makeMaskDict();
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

std::string lsst.afw.image::Mask< MaskPixelT >::getAsString ( int  x, int  y  )

inline

Definition at line 311 of file Mask.h.

{ return interpret((*this)(x, y)); }

template<typename MaskPixelT >

MaskPixelT lsst.afw.image::Mask< MaskPixelT >::getBitMask ( int  planeId )

staticprivate

Return the bitmask corresponding to plane ID.

Exceptions

lsst::pex::exceptions::InvalidParameterError

if plane is invalid

Definition at line 803 of file Mask.cc.

                                                   {
    MaskPlaneDict const& mpd = _maskPlaneDict()->getMaskPlaneDict();
    
    for (MaskPlaneDict::const_iterator i = mpd.begin(); i != mpd.end(); ++i) {
        if (planeId == i->second) {
            MaskPixelT const bitmask = getBitMaskNoThrow(planeId);
            if (bitmask == 0) {         // failed
                break;
            }
            return bitmask;
        }
    }
    throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                      str(boost::format("Invalid mask plane ID: %d") % planeId));
}

template<typename MaskPixelT >

MaskPixelT lsst.afw.image::Mask< MaskPixelT >::getBitMaskNoThrow ( int  plane )

staticprivate

Return the bitmask corresponding to a plane ID, or 0 if invalid.

Definition at line 793 of file Mask.cc.

                                                          {
    return (planeId >= 0 && planeId < getNumPlanesMax()) ? (1 << planeId) : 0;
}

template<typename MaskPixelT >

int lsst.afw.image::Mask< MaskPixelT >::getMaskPlane ( const std::string &  name )

static

Return the mask plane number corresponding to a plane name.

Exceptions

lsst::pex::exceptions::InvalidParameterError

if plane is invalid

Definition at line 825 of file Mask.cc.

                                                        {
    int const plane = getMaskPlaneNoThrow(name);
    
    if (plane < 0) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                          str(boost::format("Invalid mask plane name: %s") % name));
    } else {
        return plane;
    }
}

template<typename MaskPixelT >

detail::MaskPlaneDict const & lsst.afw.image::Mask< MaskPixelT >::getMaskPlaneDict

(

)

const

Return the Mask's maskPlaneDict

Definition at line 745 of file Mask.cc.

{
    return _maskDict->getMaskPlaneDict();
}

template<typename MaskPixelT >

int lsst.afw.image::Mask< MaskPixelT >::getMaskPlaneNoThrow ( const std::string &  name )

staticprivate

Return the mask plane number corresponding to a plane name, or -1 if not found.

Definition at line 840 of file Mask.cc.

                                                               {
    return _maskPlaneDict()->getMaskPlane(name);
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

static int lsst.afw.image::Mask< MaskPixelT >::getNumPlanesMax ( )

inlinestatic

Definition at line 330 of file Mask.h.

{ return 8*sizeof(MaskPixelT); }

template<typename MaskPixelT >

int lsst.afw.image::Mask< MaskPixelT >::getNumPlanesUsed ( )

static

Reset the maskPlane dictionary.

Definition at line 872 of file Mask.cc.

{
    return _maskPlaneDict()->size();
}

template<typename MaskPixelT >

MaskPixelT lsst.afw.image::Mask< MaskPixelT >::getPlaneBitMask ( const std::vector< std::string > &  name )

static

Return the bitmask corresponding to a vector of plane names OR'd together.

Exceptions

lsst::pex::exceptions::InvalidParameterError

if plane is invalid

Definition at line 860 of file Mask.cc.

                                                                             {
    MaskPixelT mpix = 0x0;
    for (std::vector<std::string>::const_iterator it = name.begin(); it != name.end(); ++it) {
        mpix |= getBitMask(getMaskPlane(*it));
    }
    return mpix;
}

template<typename MaskPixelT >

MaskPixelT lsst.afw.image::Mask< MaskPixelT >::getPlaneBitMask ( const std::string &  name )

static

Return the bitmask corresponding to a plane name.

Exceptions

lsst::pex::exceptions::InvalidParameterError

if plane is invalid

Definition at line 850 of file Mask.cc.

                                                                  {
    return getBitMask(getMaskPlane(name));
}

template<typename MaskPixelT>

std::string lsst.afw.image::Mask< MaskPixelT >::interpret ( MaskPixelT  value )

static

Interpret a mask value as a comma-separated list of mask plane names.

Definition at line 684 of file Mask.cc.

{
    std::string result = "";
    MaskPlaneDict const& mpd = _maskPlaneDict()->getMaskPlaneDict();
    for (MaskPlaneDict::const_iterator iter = mpd.begin(); iter != mpd.end(); ++iter) {
        if (value & getBitMask(iter->second)) {
            if (result.size() > 0) {
                result += ",";
            }
            result += iter->first;
        }
    }
    return result;
}

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::operator&=

(

Mask< MaskPixelT > const &

rhs

)

AND a Mask into a Mask.

Definition at line 1104 of file Mask.cc.

                                                 {
    checkMaskDictionaries(rhs);

    if (this->getDimensions() != rhs.getDimensions()) {
        throw LSST_EXCEPT(pexExcept::LengthError,
                          str(boost::format("Images are of different size, %dx%d v %dx%d") %
                              this->getWidth() % this->getHeight() % rhs.getWidth() % rhs.getHeight()));
    }
    transform_pixels(_getRawView(), rhs._getRawView(), _getRawView(), bl::ret<MaskPixelT>(bl::_1 & bl::_2));
}

template<typename MaskPixelT>

void lsst.afw.image::Mask< MaskPixelT >::operator&=

(

MaskPixelT const

rhs

)

AND a bitmask into a Mask.

Definition at line 1096 of file Mask.cc.

                                                      {
    transform_pixels(_getRawView(), _getRawView(), bl::ret<MaskPixelT>(bl::_1 & val));
}

template<typename MaskPixelT >

ImageBase< MaskPixelT >::PixelReference lsst.afw.image::Mask< MaskPixelT >::operator()	(	int	x,
		int	y
	)

get a reference to the specified pixel

Parameters

x	x index
y	y index

Definition at line 977 of file Mask.cc.

  {
    return this->ImageBase<MaskPixelT>::operator()(x, y);
}

template<typename MaskPixelT >

ImageBase< MaskPixelT >::PixelConstReference lsst.afw.image::Mask< MaskPixelT >::operator()	(	int	x,
		int	y
	)		const

get the specified pixel (const version)

Parameters

x	x index
y	y index

Definition at line 1000 of file Mask.cc.

        {
    return this->ImageBase<MaskPixelT>::operator()(x, y);
}

template<typename MaskPixelT >

bool lsst.afw.image::Mask< MaskPixelT >::operator()	(	int	x,
		int	y,
		int	planeId
	)		const

is the specified mask plane set in the specified pixel?

Parameters

x	x index
y	y index
planeId	plane ID

Definition at line 1023 of file Mask.cc.

        {
    // !! converts an int to a bool
    return !!(this->ImageBase<MaskPixelT>::operator()(x, y) & getBitMask(planeId));
}

template<typename MaskPixelT >

ImageBase< MaskPixelT >::PixelReference lsst.afw.image::Mask< MaskPixelT >::operator()	(	int	x,
		int	y,
		CheckIndices const &	check
	)

get a reference to the specified pixel checking array bounds

Parameters

x	x index
y	y index
check	Check array bounds?

Definition at line 988 of file Mask.cc.

  {
    return this->ImageBase<MaskPixelT>::operator()(x, y, check);
}

template<typename MaskPixelT >

ImageBase< MaskPixelT >::PixelConstReference lsst.afw.image::Mask< MaskPixelT >::operator()	(	int	x,
		int	y,
		CheckIndices const &	check
	)		const

get the specified pixel with array checking (const version)

Parameters

x	x index
y	y index
check	Check array bounds?

Definition at line 1011 of file Mask.cc.

        {
    return this->ImageBase<MaskPixelT>::operator()(x, y, check);
}

template<typename MaskPixelT >

bool lsst.afw.image::Mask< MaskPixelT >::operator()	(	int	x,
		int	y,
		int	planeId,
		CheckIndices const &	check
	)		const

is the specified mask plane set in the specified pixel, checking array bounds?

Parameters

x	x index
y	y index
planeId	plane ID
check	Check array bounds?

Definition at line 1036 of file Mask.cc.

        {
    // !! converts an int to a bool
    return !!(this->ImageBase<MaskPixelT>::operator()(x, y, check) & getBitMask(planeId));
}

template<typename MaskPixelT>

Mask< MaskPixelT > & lsst.afw.image::Mask< MaskPixelT >::operator=

(

MaskPixelT const

rhs

)

Definition at line 538 of file Mask.cc.

                                                                  {
    fill_pixels(_getRawView(), rhs);

    return *this;
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

Mask& lsst.afw.image::Mask< MaskPixelT >::operator=

(

const Mask< MaskPixelT > &

rhs

)

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::operator^=

(

Mask< MaskPixelT > const &

rhs

)

XOR a Mask into a Mask.

Definition at line 1127 of file Mask.cc.

                                                 {
    checkMaskDictionaries(rhs);

    if (this->getDimensions() != rhs.getDimensions()) {
        throw LSST_EXCEPT(pexExcept::LengthError,
                          str(boost::format("Images are of different size, %dx%d v %dx%d") %
                              this->getWidth() % this->getHeight() % rhs.getWidth() % rhs.getHeight()));
    }
    transform_pixels(_getRawView(), rhs._getRawView(), _getRawView(), bl::ret<MaskPixelT>(bl::_1 ^ bl::_2));
}

template<typename MaskPixelT>

void lsst.afw.image::Mask< MaskPixelT >::operator^=

(

MaskPixelT const

rhs

)

XOR a bitmask into a Mask.

Definition at line 1119 of file Mask.cc.

                                                      {
    transform_pixels(_getRawView(), _getRawView(), bl::ret<MaskPixelT>(bl::_1 ^ val));
}

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::operator|=

(

Mask< MaskPixelT > const &

rhs

)

OR a Mask into a Mask.

Definition at line 1081 of file Mask.cc.

                                                 {
    checkMaskDictionaries(rhs);

    if (this->getDimensions() != rhs.getDimensions()) {
        throw LSST_EXCEPT(pexExcept::LengthError,
                          str(boost::format("Images are of different size, %dx%d v %dx%d") %
                              this->getWidth() % this->getHeight() % rhs.getWidth() % rhs.getHeight()));
    }
    transform_pixels(_getRawView(), rhs._getRawView(), _getRawView(), bl::ret<MaskPixelT>(bl::_1 | bl::_2));
}

template<typename MaskPixelT>

void lsst.afw.image::Mask< MaskPixelT >::operator|=

(

MaskPixelT const

rhs

)

OR a bitmask into a Mask.

Definition at line 1073 of file Mask.cc.

                                                      {
    transform_pixels(_getRawView(), _getRawView(), bl::ret<MaskPixelT>(bl::_1 | val));
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

Mask< MaskPixelT >::MaskPlaneDict lsst.afw.image::Mask< MaskPixelT >::parseMaskPlaneMetadata ( boost::shared_ptr< lsst::daf::base::PropertySet const >  )

static

Given a PropertySet that contains the MaskPlane assignments, setup the MaskPlanes.

Returns

a dictionary of mask plane name: plane ID

Definition at line 1188 of file Mask.cc.

  {
    MaskPlaneDict newDict;

    // First, clear existing MaskPlane metadata
    typedef std::vector<std::string> NameList;
    NameList paramNames = metadata->paramNames(false);
    int numPlanesUsed = 0; // number of planes used

    // Iterate over childless properties with names starting with maskPlanePrefix
    for (NameList::const_iterator i = paramNames.begin(); i != paramNames.end(); ++i) {
        if (i->compare(0, maskPlanePrefix.size(), maskPlanePrefix) == 0) {
            // split off maskPlanePrefix to obtain plane name
            std::string planeName = i->substr(maskPlanePrefix.size());
            int const planeId = metadata->getAsInt(*i);

            MaskPlaneDict::const_iterator plane = newDict.find(planeName);
            if (plane != newDict.end() && planeId != plane->second) {
               throw LSST_EXCEPT(pexExcept::RuntimeError,
                                 "File specifies plane " + planeName + " twice"); 
            }
            for (MaskPlaneDict::const_iterator j = newDict.begin(); j != newDict.end(); ++j) {
                if (planeId == j->second) {
                    throw LSST_EXCEPT(pexExcept::RuntimeError,
                                      str(boost::format("File specifies plane %s has same value (%d) as %s") %
                                          planeName % planeId % j->first));
                }
            }
            // build new entry
            if (numPlanesUsed >= getNumPlanesMax()) {
                // Max number of planes already allocated
                throw LSST_EXCEPT(pexExcept::RuntimeError,
                                  str(boost::format("Max number of planes (%1%) already used") %
                                      getNumPlanesMax()));
            }
            newDict[planeName] = planeId; 
        }
    }
    return newDict;
}

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::printMaskPlanes

(

)

const

print the mask plane dictionary to std::cout

Definition at line 1234 of file Mask.cc.

{
    _maskDict->print();
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

static Mask lsst.afw.image::Mask< MaskPixelT >::readFits ( std::string const &  filename, int  hdu = 0  )

inlinestatic

Read a Mask from a regular FITS file.

Parameters

[in]	filename	Name of the file to read.
[in]	hdu	Number of the "header-data unit" to read (where 1 is the Primary HDU). The default value of 0 is interpreted as "the first HDU with NAXIS != 0".

Definition at line 294 of file Mask.h.

                                                                {
        return Mask<MaskPixelT>(filename, hdu);
    }

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

static Mask lsst.afw.image::Mask< MaskPixelT >::readFits ( fits::MemFileManager &  manager, int  hdu = 0  )

inlinestatic

Read a Mask from a FITS RAM file.

Parameters

[in]	manager	Object that manages the memory to be read.
[in]	hdu	Number of the "header-data unit" to read (where 1 is the Primary HDU). The default value of 0 is interpreted as "the first HDU with NAXIS != 0".

Definition at line 305 of file Mask.h.

                                                                  {
        return Mask<MaskPixelT>(manager, hdu);
    }

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::removeAndClearMaskPlane	(	const std::string &	name,
		bool const	removeFromDefault = false
	)

Clear all pixels of the specified mask and remove the plane from the mask plane dictionary; optionally remove the plane from the default dictionary too.

Exceptions

lsst::pex::exceptions::InvalidParameterError

if plane is invalid

Parameters

name	name of maskplane
removeFromDefault	remove from default mask plane dictionary too

Definition at line 769 of file Mask.cc.

{
    clearMaskPlane(getMaskPlane(name)); // clear this bits in this Mask

    if (_maskDict == detail::MaskDict::makeMaskDict() && removeFromDefault) { // we are the default
        ;
    } else {
        _maskDict = _maskDict->clone();
    }

    _maskDict->erase(name);

    if (removeFromDefault && detail::MaskDict::makeMaskDict()->getMaskPlane(name) >= 0) {
        removeMaskPlane(name);
    }
}

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::removeMaskPlane ( const std::string &  name )

static

Definition at line 751 of file Mask.cc.

{
    if (detail::MaskDict::makeMaskDict()->getMaskPlane(name) < 0) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                          str(boost::format("Plane %s doesn't exist in the default Mask") % name));
    }

    detail::MaskDict::incrDefaultVersion(); // leave current Masks alone
    _maskPlaneDict()->erase(name);
}

template<typename MaskPixelT >

void lsst.afw.image::Mask< MaskPixelT >::setMaskPlaneValues	(	const int	plane,
		const int	x0,
		const int	x1,
		const int	y
	)

Set the bit specified by "planeId" for pixels (x0, y) ... (x1, y)

Definition at line 1142 of file Mask.cc.

                                                                                             {
    MaskPixelT const bitMask = getBitMask(planeId);
    
    for (int x = x0; x <= x1; x++) {
        operator()(x, y) = operator()(x, y) | bitMask;
    }
}

template<typename PixelT >

void lsst.afw.image::Mask< PixelT >::swap

(

Mask< MaskPixelT > &

rhs

)

Definition at line 517 of file Mask.cc.

                                 {
    using std::swap;                    // See Meyers, Effective C++, Item 25

    ImageBase<PixelT>::swap(rhs);
    swap(_maskDict, rhs._maskDict);
}

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

void lsst.afw.image::Mask< MaskPixelT >::writeFits	(	std::string const &	fileName,
		boost::shared_ptr< lsst::daf::base::PropertySet const >	metadata = boost::shared_ptr< lsst::daf::base::PropertySet >(),
		std::string const &	mode = "w"
	)		const

Write a mask to a regular FITS file.

Parameters

[in]	fileName	Name of the file to write.
[in]	metadata	Additional values to write to the header (may be null).
[in]	mode	"w"=Create a new file; "a"=Append a new HDU.

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

void lsst.afw.image::Mask< MaskPixelT >::writeFits	(	fits::MemFileManager &	manager,
		boost::shared_ptr< lsst::daf::base::PropertySet const >	metadata = boost::shared_ptr< lsst::daf::base::PropertySet >(),
		std::string const &	mode = "w"
	)		const

Write a mask 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 header (may be null).
[in]	mode	"w"=Create a new file; "a"=Append a new HDU.

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

void lsst.afw.image::Mask< MaskPixelT >::writeFits	(	fits::Fits &	fitsfile,
		boost::shared_ptr< lsst::daf::base::PropertySet const >	metadata = boost::shared_ptr< lsst::daf::base::PropertySet const  >()
	)		const

Write a mask to an open FITS file object.

Parameters

[in]	fitsfile	A FITS file already open to the desired HDU.
[in]	metadata	Additional values to write to the header (may be null).

Member Data Documentation

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

boost::shared_ptr< detail::MaskDict > lsst.afw.image::Mask< MaskPixelT >::_maskDict

private

Definition at line 342 of file Mask.h.

template<typename MaskPixelT = lsst::afw::image::MaskPixel>

std::string const lsst.afw.image::Mask< MaskPixelT >::maskPlanePrefix

staticprivate

Definition at line 346 of file Mask.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/Mask.h
• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/src/image/Mask.cc