lsst::afw::image::pixel Namespace Reference

Classes
class	BinaryExpr
	Class for representing binary operations. More...
class	BinaryExpr< ExprT1, double, ImageBinOp, MaskBinOp, VarianceBinOp >
	Partial specialization of BinaryExpr when ExprT2 is a double (i.e no mask/variance part) More...
struct	bitwise_or
	bitwise_or doesn't seem to be in std:: More...
struct	exprTraits
	A traits class to return the types of the image/mask/variance. 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	is_specialization
	Template for (e1 + e2) More...
struct	is_specialization< Template< Args... >, Template >
struct	noop
	A noop functor (useful for e.g. masks and variances when changing the sign of the image) More...
class	Pixel
	A pixel of a MaskedImage. More...
struct	PixelTypeTraits
	Pixel type traits. More...
class	SinglePixel
	A single pixel of the same type as a MaskedImage. More...
class	UnaryExpr
	Class for representing Unary operations. 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...

Typedefs
template<typename T1 , typename T2 >
using	valid_operands = std::enable_if_t<valid_binary_operands<T1, T2>>

Functions
template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >
SinglePixel< ImagePixelT, MaskPixelT, VariancePixelT >	makeSinglePixel (ImagePixelT x, MaskPixelT m, VariancePixelT v)
	Return a SinglePixel.
template<typename ExprT1 >
auto	operator- (ExprT1 e1)
	Template for -e1.
template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>
auto	operator+ (ExprT1 e1, ExprT2 e2)
template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>
ExprT1 &	operator+= (ExprT1 &e1, ExprT2 const &e2)
	template for e1 += e2
template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>
ExprT1	plus (ExprT1 &lhs, ExprT2 const &rhs, float covariance)
	Like operator+(), but assume that covariance's 2*alpha*sqrt(vx*vy)
template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, 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)
template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>
ExprT1	operator-= (ExprT1 &e1, ExprT2 e2)
	Template to evaluate e1 -= e2.
template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, 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)
template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>
ExprT1	operator*= (ExprT1 &e1, ExprT2 e2)
	Template to evaluate e1 *= e2.
template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, 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)
template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>
ExprT1	operator/= (ExprT1 &e1, ExprT2 e2)
	Template to evaluate e1 /= e2.
template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >
std::ostream &	operator<< (std::ostream &os, SinglePixel< ImagePixelT, MaskPixelT, VariancePixelT > const &v)
	Print a SinglePixel.
template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >
std::ostream &	operator<< (std::ostream &os, Pixel< ImagePixelT, MaskPixelT, VariancePixelT > const &v)
	Print a Pixel.
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.
	PYBIND11_MODULE (_pixel, mod)

Variables
template<typename T >
constexpr bool	is_valid_operand
template<typename T1 , typename T2 >
constexpr bool	valid_binary_operands = is_valid_operand<T1> && is_valid_operand<T2>

Typedef Documentation

valid_operands

template<typename T1 , typename T2 >

using lsst::afw::image::pixel::valid_operands = std::enable_if_t<valid_binary_operands<T1, T2>>

Definition at line 518 of file Pixel.h.

Function Documentation

makeSinglePixel()

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 134 of file Pixel.h.

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

operator*()

template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, 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 584 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);
}

operator*=()

template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>

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

Template to evaluate e1 *= e2.

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

operator+()

template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>

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

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

operator+=()

template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>

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

template for e1 += e2

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

operator-() [1/2]

template<typename ExprT1 >

auto lsst::afw::image::pixel::operator-

(

ExprT1

e1

)

Template for -e1.

Definition at line 494 of file Pixel.h.

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

operator-() [2/2]

template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, 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 563 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);
}

operator-=()

template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>

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

Template to evaluate e1 -= e2.

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

operator/()

template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, 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 605 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);
}

operator/=()

template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, ExprT2>>

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

Template to evaluate e1 /= e2.

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

operator<<() [1/3]

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 634 of file Pixel.h.

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

operator<<() [2/3]

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 628 of file Pixel.h.

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

operator<<() [3/3]

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 622 of file Pixel.h.

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

plus()

template<typename ExprT1 , typename ExprT2 , typename = valid_operands<ExprT1, 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 2*alpha*sqrt(vx*vy) (if variances are known)

Definition at line 549 of file Pixel.h.

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

PYBIND11_MODULE()

lsst::afw::image::pixel::PYBIND11_MODULE	(	_pixel	,
		mod	)

Definition at line 65 of file _pixel.cc.

                             {
    lsst::cpputils::python::WrapperCollection wrappers(mod, "lsst.afw.image.pixel");
    declareSinglePixel<float>(wrappers, "SinglePixelF");
    declareSinglePixel<double>(wrappers, "SinglePixelD");
    declareSinglePixel<int>(wrappers, "SinglePixelI");
    declareSinglePixel<std::uint16_t>(wrappers, "SinglePixelU");
    declareSinglePixel<std::uint64_t>(wrappers, "SinglePixelL");
    wrappers.finish();
}

Variable Documentation

is_valid_operand

template<typename T >

constexpr bool lsst::afw::image::pixel::is_valid_operand

inlineconstexpr

Initial value:

= std::is_integral<T>::value  ||
            std::is_floating_point_v<T> ||
            is_specialization<T, BinaryExpr>{} ||
            is_specialization<T, SinglePixel>{} ||
            is_specialization<T, Pixel>{}

Definition at line 509 of file Pixel.h.

                                            {} ||
            is_specialization<T, SinglePixel>{} ||
            is_specialization<T, Pixel>{};

valid_binary_operands

template<typename T1 , typename T2 >

constexpr bool lsst::afw::image::pixel::valid_binary_operands = is_valid_operand<T1> && is_valid_operand<T2>

constexpr

Definition at line 515 of file Pixel.h.