Classes
class	BinaryExpr
	Class for representing binary operations. More...

struct	exprTraits
	A traits class to return the types of the image/mask/variance. More...

struct	bitwise_or
	bitwise_or doesn't seem to be in std:: More...

struct	variance_divides
	Calculate the variance when we divide two Pixels. More...

struct	variance_multiplies
	Calculate the variance when we multiply two Pixels. More...

struct	variance_plus
	Calculate the variance when we add (or subtract) two Pixels. More...

class	SinglePixel
	A single pixel of the same type as a MaskedImage. More...

struct	PixelTypeTraits
	Pixel type traits. More...

struct	PixelTypeTraits< SinglePixel< _ImagePixelT, _MaskPixelT, _VariancePixelT > >
	Specialization for a pixel of a MaskedImage. More...

class	Pixel
	A pixel of a MaskedImage. More...

struct	exprTraits< double >
	A specialisation of exprTraits for `double`. More...

struct	exprTraits< float >
	A specialisation of exprTraits for `float`. More...

struct	exprTraits< int >
	A specialisation of exprTraits for `int`. More...

struct	exprTraits< unsigned short >
	A specialisation of exprTraits for `unsigned` short. More...

struct	noop
	A noop functor (useful for e.g. masks and variances when changing the sign of the image) More...

struct	variance_plus_covar
	The variance of the sum of a pair of correlated pixels. More...

class	UnaryExpr
	Class for representing Unary operations. More...

class	BinaryExpr< ExprT1, double, ImageBinOp, MaskBinOp, VarianceBinOp >

Functions
template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >
SinglePixel< ImagePixelT, MaskPixelT, VariancePixelT >	makeSinglePixel (ImagePixelT x, MaskPixelT m, VariancePixelT v)

template<typename ExprT1 >
UnaryExpr< ExprT1, std::negate < typename exprTraits< ExprT1 > ::ImagePixelT >, noop < typename exprTraits< ExprT1 > ::MaskPixelT >, noop< typename exprTraits< ExprT1 > ::VariancePixelT > >	operator- (ExprT1 e1)
	Template for -e1. More...

template<typename ExprT1 , typename ExprT2 >
BinaryExpr< ExprT1, ExprT2, std::plus< typename exprTraits < ExprT1 >::ImagePixelT > , bitwise_or< typename exprTraits< ExprT1 > ::MaskPixelT >, variance_plus < typename exprTraits< ExprT1 > ::VariancePixelT > >	operator+ (ExprT1 e1, ExprT2 e2)
	Template for (e1 + e2) More...

template<typename ExprT1 , typename ExprT2 >
ExprT1	operator+= (ExprT1 &e1, ExprT2 e2)
	template for e1 += e2 More...

template<typename ExprT1 , typename ExprT2 >
ExprT1	plus (ExprT1 &lhs, ExprT2 const &rhs, float covariance)
	Like operator+(), but assume that covariance's 2alphasqrt(vx*vy) More...

template<typename ExprT1 , typename ExprT2 >
BinaryExpr< ExprT1, ExprT2, std::minus< typename exprTraits< ExprT1 > ::ImagePixelT >, bitwise_or < typename exprTraits< ExprT1 > ::MaskPixelT >, variance_plus < typename exprTraits< ExprT1 > ::VariancePixelT > >	operator- (ExprT1 e1, ExprT2 e2)
	Template to evaluate (e1 - e2) More...

template<typename ExprT1 , typename ExprT2 >
ExprT1	operator-= (ExprT1 &e1, ExprT2 e2)
	Template to evaluate e1 -= e2. More...

template<typename ExprT1 , typename ExprT2 >
BinaryExpr< ExprT1, ExprT2, std::multiplies< typename exprTraits< ExprT1 > ::ImagePixelT >, bitwise_or < typename exprTraits< ExprT1 > ::MaskPixelT > , variance_multiplies < typename exprTraits< ExprT1 > ::VariancePixelT > >	operator* (ExprT1 e1, ExprT2 e2)
	Template to evaluate (e1 * e2) More...

template<typename ExprT1 , typename ExprT2 >
ExprT1	operator*= (ExprT1 &e1, ExprT2 e2)
	Template to evaluate e1 *= e2. More...

template<typename ExprT1 , typename ExprT2 >
BinaryExpr< ExprT1, ExprT2, std::divides< typename exprTraits< ExprT1 > ::ImagePixelT >, bitwise_or < typename exprTraits< ExprT1 > ::MaskPixelT > , variance_divides< typename exprTraits< ExprT1 > ::VariancePixelT > >	operator/ (ExprT1 e1, ExprT2 e2)
	Template to evaluate (e1 / e2) More...

template<typename ExprT1 , typename ExprT2 >
ExprT1	operator/= (ExprT1 &e1, ExprT2 e2)
	Template to evaluate e1 /= e2. More...

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >
std::ostream &	operator<< (std::ostream &os, SinglePixel< ImagePixelT, MaskPixelT, VariancePixelT > const &v)
	Print a SinglePixel. More...

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >
std::ostream &	operator<< (std::ostream &os, Pixel< ImagePixelT, MaskPixelT, VariancePixelT > const &v)
	Print a Pixel. More...

template<typename ExprT1 , typename ExprT2 , typename BinOp , typename MaskBinOp , typename VarBinOp >
std::ostream &	operator<< (std::ostream &os, BinaryExpr< ExprT1, ExprT2, BinOp, MaskBinOp, VarBinOp > const &v)
	Evaluate and print a BinaryExpr. More...

Function Documentation

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

SinglePixel<ImagePixelT, MaskPixelT, VariancePixelT> lsst::afw::image::pixel::makeSinglePixel	(	ImagePixelT	x,
		MaskPixelT	m,
		VariancePixelT	v
	)

Return a SinglePixel

This function is useful as function overloading will choose the correct return type (cf. std::make_pair()

Definition at line 131 of file Pixel.h.

                                                                                                                     {
     return SinglePixel<ImagePixelT, MaskPixelT, VariancePixelT>(x, m, v);
 }

template<typename ExprT1 , typename ExprT2 >

BinaryExpr<ExprT1, ExprT2, std::multiplies<typename exprTraits<ExprT1>::ImagePixelT>, bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>, variance_multiplies<typename exprTraits<ExprT1>::VariancePixelT> > lsst::afw::image::pixel::operator*	(	ExprT1	e1,
		ExprT2	e2
	)

Template to evaluate (e1 * e2)

Definition at line 625 of file Pixel.h.

                                                                                                             {
     return BinaryExpr<ExprT1, ExprT2,
         std::multiplies<typename exprTraits<ExprT1>::ImagePixelT>,
         bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>,
         variance_multiplies<typename exprTraits<ExprT1>::VariancePixelT> >(e1,e2);
 }

template<typename ExprT1 , typename ExprT2 >

ExprT1 lsst::afw::image::pixel::operator*=	(	ExprT1 &	e1,
		ExprT2	e2
	)

Template to evaluate e1 *= e2.

Definition at line 634 of file Pixel.h.

                                          {
     e1 = BinaryExpr<ExprT1, ExprT2,
         std::multiplies<typename exprTraits<ExprT1>::ImagePixelT>,
         bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>,
         variance_multiplies<typename exprTraits<ExprT1>::VariancePixelT> >(e1,e2);
     return e1;
 }

template<typename ExprT1 , typename ExprT2 >

BinaryExpr<ExprT1, ExprT2, std::plus<typename exprTraits<ExprT1>::ImagePixelT>, bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>, variance_plus<typename exprTraits<ExprT1>::VariancePixelT> > lsst::afw::image::pixel::operator+	(	ExprT1	e1,
		ExprT2	e2
	)

Template for (e1 + e2)

Definition at line 544 of file Pixel.h.

                                                                                                       {
     return BinaryExpr<ExprT1, ExprT2,
         std::plus<typename exprTraits<ExprT1>::ImagePixelT>,
         bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>,
         variance_plus<typename exprTraits<ExprT1>::VariancePixelT> >(e1,e2);
 }

template<typename ExprT1 , typename ExprT2 >

ExprT1 lsst::afw::image::pixel::operator+=	(	ExprT1 &	e1,
		ExprT2	e2
	)

template for e1 += e2

Definition at line 553 of file Pixel.h.

                                          {
     e1 = BinaryExpr<ExprT1, ExprT2,
         std::plus<typename exprTraits<ExprT1>::ImagePixelT>,
         bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>,
         variance_plus<typename exprTraits<ExprT1>::VariancePixelT> >(e1,e2);
     return e1;
 }

template<typename ExprT1 >

UnaryExpr<ExprT1, std::negate<typename exprTraits<ExprT1>::ImagePixelT>, noop<typename exprTraits<ExprT1>::MaskPixelT>, noop<typename exprTraits<ExprT1>::VariancePixelT> > lsst::afw::image::pixel::operator- ( ExprT1 e1 )

Template for -e1.

Definition at line 531 of file Pixel.h.

                                                                                  {
     return UnaryExpr<ExprT1,
                   std::negate<typename exprTraits<ExprT1>::ImagePixelT>,
                   noop<typename exprTraits<ExprT1>::MaskPixelT>,
                   noop<typename exprTraits<ExprT1>::VariancePixelT> >(e1);
 }

template<typename ExprT1 , typename ExprT2 >

BinaryExpr<ExprT1, ExprT2, std::minus<typename exprTraits<ExprT1>::ImagePixelT>, bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>, variance_plus<typename exprTraits<ExprT1>::VariancePixelT> > lsst::afw::image::pixel::operator-	(	ExprT1	e1,
		ExprT2	e2
	)

Template to evaluate (e1 - e2)

Definition at line 602 of file Pixel.h.

                                                                                                       {
     return BinaryExpr<ExprT1, ExprT2,
         std::minus<typename exprTraits<ExprT1>::ImagePixelT>,
         bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>,
         variance_plus<typename exprTraits<ExprT1>::VariancePixelT> >(e1,e2);
 }

template<typename ExprT1 , typename ExprT2 >

ExprT1 lsst::afw::image::pixel::operator-=	(	ExprT1 &	e1,
		ExprT2	e2
	)

Template to evaluate e1 -= e2.

Definition at line 611 of file Pixel.h.

                                          {
     e1 = BinaryExpr<ExprT1, ExprT2,
         std::minus<typename exprTraits<ExprT1>::ImagePixelT>,
         bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>,
         variance_plus<typename exprTraits<ExprT1>::VariancePixelT> >(e1,e2);
     return e1;
 }

template<typename ExprT1 , typename ExprT2 >

BinaryExpr<ExprT1, ExprT2, std::divides<typename exprTraits<ExprT1>::ImagePixelT>, bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>, variance_divides<typename exprTraits<ExprT1>::VariancePixelT> > lsst::afw::image::pixel::operator/	(	ExprT1	e1,
		ExprT2	e2
	)

Template to evaluate (e1 / e2)

Definition at line 648 of file Pixel.h.

                                                                                                          {
     return BinaryExpr<ExprT1, ExprT2,
         std::divides<typename exprTraits<ExprT1>::ImagePixelT>,
         bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>,
         variance_divides<typename exprTraits<ExprT1>::VariancePixelT> >(e1,e2);
 }

template<typename ExprT1 , typename ExprT2 >

ExprT1 lsst::afw::image::pixel::operator/=	(	ExprT1 &	e1,
		ExprT2	e2
	)

Template to evaluate e1 /= e2.

Definition at line 657 of file Pixel.h.

                                          {
     e1 = BinaryExpr<ExprT1, ExprT2,
         std::divides<typename exprTraits<ExprT1>::ImagePixelT>,
         bitwise_or<typename exprTraits<ExprT1>::MaskPixelT>,
         variance_divides<typename exprTraits<ExprT1>::VariancePixelT> >(e1,e2);
     return e1;
 }

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

std::ostream& lsst::afw::image::pixel::operator<<	(	std::ostream &	os,
		SinglePixel< ImagePixelT, MaskPixelT, VariancePixelT > const &	v
	)

Print a SinglePixel.

Definition at line 668 of file Pixel.h.

                                                                                                       {
     return os << "(" << v.image() << ", " << v.mask() << ", " << v.variance() << ")";
 }

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

std::ostream& lsst::afw::image::pixel::operator<<	(	std::ostream &	os,
		Pixel< ImagePixelT, MaskPixelT, VariancePixelT > const &	v
	)

Print a Pixel.

Definition at line 674 of file Pixel.h.

                                                                                                 {
     return os << "(" << v.image() << ", " << v.mask() << ", " << v.variance() << ")";
 }

template<typename ExprT1 , typename ExprT2 , typename BinOp , typename MaskBinOp , typename VarBinOp >

std::ostream& lsst::afw::image::pixel::operator<<	(	std::ostream &	os,
		BinaryExpr< ExprT1, ExprT2, BinOp, MaskBinOp, VarBinOp > const &	v
	)

Evaluate and print a BinaryExpr.

Definition at line 680 of file Pixel.h.

                                                                                                         {
     return os << "(" << v.image() << ", " << v.mask() << ", " << v.variance() << ")";
 }

template<typename ExprT1 , typename ExprT2 >

ExprT1 lsst::afw::image::pixel::plus	(	ExprT1 &	lhs,
		ExprT2 const &	rhs,
		float	covariance
	)

inline

Like operator+(), but assume that covariance's 2*alpha*sqrt(vx*vy)

Parameters

lhs	Left hand value
rhs	Right hand value
covariance	Assume that covariance is 2alphasqrt(vx*vy) (if variances are known)

Definition at line 589 of file Pixel.h.

                    {
     return doPlus(lhs, rhs, covariance, typename boost::is_arithmetic<ExprT1>::type());
 }

Classes

Functions

Function Documentation