#include <Pixel.h>

Inheritance diagram for lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >:

Public Types
using	ImagePixelT = _ImagePixelT

using	MaskPixelT = _MaskPixelT

using	VariancePixelT = _VariancePixelT

Public Member Functions
	Pixel (ImagePixelT const &image, MaskPixelT const &mask=0x0, VariancePixelT const &variance=0)
	Construct a Pixel from references to its image/mask/variance components.

	Pixel (SinglePixel< ImagePixelT, MaskPixelT, VariancePixelT > &rhs)

	Pixel (Pixel const &rhs)=default

	Pixel (Pixel &&rhs)=default

	~Pixel ()=default

Pixel	operator= (Pixel const &rhs)

template<typename rhsExpr>
Pixel	operator= (rhsExpr const &rhs)
	Assign a Pixel by evaluating an expression.

Pixel	operator= (Pixel &&rhs)

Pixel	operator= (double const &rhs_image)
	set the image part of a Pixel to rhs_image (the mask and variance are set to 0)

Pixel	operator= (int const &rhs_image)
	set the image part of a Pixel to rhs_image (the mask and variance are set to 0)

ImagePixelT	image () const
	Return the image part of a Pixel.

MaskPixelT	mask () const
	Return the mask part of a Pixel.

VariancePixelT	variance () const
	Return the variance part of a Pixel.

std::size_t	hash_value () const noexcept
	Return a hash of this object.

Friends
template<typename T1, typename T2, typename T3>
bool	operator== (Pixel const &lhs, Pixel< T1, T2, T3 > const &rhs)
	Return true if two pixels are equal (in all three of image, mask, and variance) Fix C++20 compilation ambiguous overload problem by creating overloads.

template<typename T1, typename T2, typename T3>
bool	operator== (Pixel const &lhs, SinglePixel< T1, T2, T3 > const &rhs)

template<typename T1>
bool	operator!= (Pixel const &lhs, T1 const &rhs)
	Return true iff two pixels are unequal (in at least one of image, mask, and variance)

template<typename ExprT>
Pixel	operator+= (Pixel const &e1, ExprT const &e2)
	Evaluate e1 += e2, and return e1.

template<typename ExprT>
Pixel	operator-= (Pixel const &e1, ExprT const &e2)
	Evaluate e1 -= e2, and return e1.

template<typename ExprT>
Pixel	operator*= (Pixel const &e1, ExprT const &e2)
	Evaluate e1 *= e2, and return e1.

template<typename ExprT>
Pixel	operator/= (Pixel const &e1, ExprT const &e2)
	Evaluate e1 /= e2, and return e1.

Detailed Description

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>
class lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >

A pixel of a MaskedImage.

Definition at line 141 of file Pixel.h.

Member Typedef Documentation

◆ ImagePixelT

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

using lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::ImagePixelT = _ImagePixelT

Definition at line 143 of file Pixel.h.

◆ MaskPixelT

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

using lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::MaskPixelT = _MaskPixelT

Definition at line 144 of file Pixel.h.

◆ VariancePixelT

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

using lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::VariancePixelT = _VariancePixelT

Definition at line 145 of file Pixel.h.

Constructor & Destructor Documentation

◆ Pixel() [1/4]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::Pixel	(	ImagePixelT const &	image,
		MaskPixelT const &	mask = 0x0,
		VariancePixelT const &	variance = 0 )

inline

Construct a Pixel from references to its image/mask/variance components.

Definition at line 151 of file Pixel.h.

            : _image(const_cast<ImagePixelT&>(image)),
              _mask(const_cast<MaskPixelT&>(mask)),
              _variance(const_cast<VariancePixelT&>(variance)) {}

◆ Pixel() [2/4]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::Pixel ( SinglePixel< ImagePixelT, MaskPixelT, VariancePixelT > & rhs )

inline

Definition at line 156 of file Pixel.h.

157 : _image(rhs._image), _mask(rhs._mask), _variance(rhs._variance) {}

lsst::afw::image::pixel::Pixel

A pixel of a MaskedImage.

Definition Pixel.h:141

◆ Pixel() [3/4]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::Pixel ( Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > const & rhs )

default

◆ Pixel() [4/4]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::Pixel ( Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > && rhs )

default

◆ ~Pixel()

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::~Pixel ( )

default

Member Function Documentation

◆ hash_value()

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

std::size_t lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::hash_value ( ) const

inlinenoexcept

Return a hash of this object.

Definition at line 232 of file Pixel.h.

                                          {
        // Completely arbitrary seed
        // Convert to double to avoid inconsistently hashing equal numbers of different types
        return cpputils::hashCombine(17, static_cast<double>(image()), static_cast<double>(mask()),
                                  static_cast<double>(variance()));
    }

◆ image()

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

ImagePixelT lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::image ( ) const

inline

Return the image part of a Pixel.

Definition at line 205 of file Pixel.h.

205{ return _image; }

◆ mask()

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

MaskPixelT lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::mask ( ) const

inline

Return the mask part of a Pixel.

Definition at line 207 of file Pixel.h.

207{ return _mask; }

◆ operator=() [1/5]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

Pixel lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::operator= ( double const & rhs_image )

inline

set the image part of a Pixel to rhs_image (the mask and variance are set to 0)

Definition at line 188 of file Pixel.h.

                                             {
        _image = rhs_image;
        _mask = 0;
        _variance = 0;
 
        return *this;
    }

◆ operator=() [2/5]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

Pixel lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::operator= ( int const & rhs_image )

inline

set the image part of a Pixel to rhs_image (the mask and variance are set to 0)

Definition at line 197 of file Pixel.h.

                                          {
        _image = rhs_image;
        _mask = 0;
        _variance = 0;
 
        return *this;
    }

◆ operator=() [3/5]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

Pixel lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::operator= ( Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > && rhs )

inline

Definition at line 185 of file Pixel.h.

185{ return *this = rhs; }

◆ operator=() [4/5]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

Pixel lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::operator= ( Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > const & rhs )

inline

Definition at line 163 of file Pixel.h.

                                      {  // the following template won't stop the compiler trying to generate
                                         // operator=
        _variance = rhs.variance();      // evaluate before we update image()
        _image = rhs.image();
        _mask = rhs.mask();
 
        return *this;
    }

◆ operator=() [5/5]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

template<typename rhsExpr>

Pixel lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::operator= ( rhsExpr const & rhs )

inline

Assign a Pixel by evaluating an expression.

We use C++ template expressions to build a compile-time parse tree to evaluate Pixel expressions; this is where we evaluate the rhs and set the Pixel's values

Definition at line 177 of file Pixel.h.

                                        {
        _variance = rhs.variance();  // evaluate before we update image()
        _image = rhs.image();
        _mask = rhs.mask();
 
        return *this;
    }

◆ variance()

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

VariancePixelT lsst::afw::image::pixel::Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT >::variance ( ) const

inline

Return the variance part of a Pixel.

Definition at line 209 of file Pixel.h.

209{ return _variance; }

Friends And Related Symbol Documentation

◆ operator!=

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

template<typename T1>

bool operator!=	(	Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > const &	lhs,
		T1 const &	rhs )

friend

Return true iff two pixels are unequal (in at least one of image, mask, and variance)

Definition at line 227 of file Pixel.h.

                                                            {
        return !(lhs == rhs);
    }

◆ operator*=

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

template<typename ExprT>

Pixel operator*=	(	Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > const &	e1,
		ExprT const &	e2 )

friend

Evaluate e1 *= e2, and return e1.

Definition at line 262 of file Pixel.h.

                                                              {
        Pixel tmp(e1);  // n.b. shares storage with e1 but gets around "const" (which is required)
        tmp = BinaryExpr<Pixel, ExprT, std::multiplies<ImagePixelT>, bitwise_or<MaskPixelT>,
                         variance_multiplies<VariancePixelT> >(tmp, e2);
        return tmp;
    }

◆ operator+=

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

template<typename ExprT>

Pixel operator+=	(	Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > const &	e1,
		ExprT const &	e2 )

friend

Evaluate e1 += e2, and return e1.

Definition at line 244 of file Pixel.h.

                                                              {
        Pixel tmp(e1);  // n.b. shares storage with e1 but gets around "const" (which is required)
        tmp = BinaryExpr<Pixel, ExprT, std::plus<ImagePixelT>, bitwise_or<MaskPixelT>,
                         variance_plus<VariancePixelT> >(tmp, e2);
        return tmp;
    }

◆ operator-=

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

template<typename ExprT>

Pixel operator-=	(	Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > const &	e1,
		ExprT const &	e2 )

friend

Evaluate e1 -= e2, and return e1.

Definition at line 253 of file Pixel.h.

                                                              {
        Pixel tmp(e1);  // n.b. shares storage with e1 but gets around "const" (which is required)
        tmp = BinaryExpr<Pixel, ExprT, std::minus<ImagePixelT>, bitwise_or<MaskPixelT>,
                         variance_plus<VariancePixelT> >(tmp, e2);
        return tmp;
    }

◆ operator/=

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

template<typename ExprT>

Pixel operator/=	(	Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > const &	e1,
		ExprT const &	e2 )

friend

Evaluate e1 /= e2, and return e1.

Definition at line 271 of file Pixel.h.

                                                              {
        Pixel tmp(e1);  // n.b. shares storage with e1 but gets around "const" (which is required)
        tmp = BinaryExpr<Pixel, ExprT, std::divides<ImagePixelT>, bitwise_or<MaskPixelT>,
                         variance_divides<VariancePixelT> >(tmp, e2);
        return tmp;
    }

◆ operator== [1/2]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

template<typename T1, typename T2, typename T3>

bool operator==	(	Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > const &	lhs,
		Pixel< T1, T2, T3 > const &	rhs )

friend

Return true if two pixels are equal (in all three of image, mask, and variance) Fix C++20 compilation ambiguous overload problem by creating overloads.

Definition at line 217 of file Pixel.h.

                                                                         {
        return lhs.image() == rhs.image() && lhs.mask() == rhs.mask() && lhs.variance() == rhs.variance();
    }

◆ operator== [2/2]

template<typename _ImagePixelT, typename _MaskPixelT, typename _VariancePixelT = double>

template<typename T1, typename T2, typename T3>

bool operator==	(	Pixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > const &	lhs,
		SinglePixel< T1, T2, T3 > const &	rhs )

friend

Definition at line 221 of file Pixel.h.

                                                                                 {
        return lhs.image() == rhs.image() && lhs.mask() == rhs.mask() && lhs.variance() == rhs.variance();
    }

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-10.1.0/Linux/afw/g4595892280+fef73a337f/include/lsst/afw/image/Pixel.h

Public Types

Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ ImagePixelT

◆ MaskPixelT

◆ VariancePixelT

Constructor & Destructor Documentation

◆ Pixel() [1/4]

◆ Pixel() [2/4]

◆ Pixel() [3/4]

◆ Pixel() [4/4]

◆ ~Pixel()

Member Function Documentation

◆ hash_value()

◆ image()

◆ mask()

◆ operator=() [1/5]

◆ operator=() [2/5]

◆ operator=() [3/5]

◆ operator=() [4/5]

◆ operator=() [5/5]

◆ variance()

Friends And Related Symbol Documentation

◆ operator!=

◆ operator*=

◆ operator+=

◆ operator-=

◆ operator/=

◆ operator== [1/2]

◆ operator== [2/2]