lsst::afw::math Namespace Reference

Namespaces
namespace	_background
namespace	_backgroundList
namespace	_chebyshevBoundedField
namespace	_chebyshevBoundedFieldConfig
namespace	_spatialCell
namespace	_warper
namespace	detail
namespace	details

Classes
class	AnalyticKernel
	A kernel described by a function. More...
class	Approximate
	Approximate values for a MaskedImage. More...
class	ApproximateControl
	Control how to make an approximation. More...
class	Background
	A virtual base class to evaluate image background levels. More...
class	BackgroundControl
	Pass parameters to a Background object. More...
class	BackgroundMI
	A class to evaluate image background levels. More...
class	BasePolynomialFunction2
	Base class for 2-dimensional polynomials of the form: More...
class	BilinearWarpingKernel
	Bilinear warping: fast; good for undersampled data. More...
class	BoundedField
	An abstract base class for 2-d functions defined on an integer bounding boxes. More...
class	CandidateVisitor
class	Chebyshev1Function1
	1-dimensional weighted sum of Chebyshev polynomials of the first kind. More...
class	Chebyshev1Function2
	2-dimensional weighted sum of Chebyshev polynomials of the first kind. More...
class	ChebyshevBoundedField
	A BoundedField based on 2-d Chebyshev polynomials of the first kind. More...
class	ChebyshevBoundedFieldControl
	A control object used when fitting ChebyshevBoundedField to data (see ChebyshevBoundedField::fit) More...
class	ConvolutionControl
	Parameters to control convolution. More...
class	Covariogram
	The parent class of covariogram functions for use in Gaussian Process interpolation. More...
struct	deltafunction_kernel_tag
	Kernel has only one non-zero pixel. More...
class	DeltaFunctionKernel
	A kernel that has only one non-zero pixel (of value 1) More...
class	DoubleGaussianFunction2
	double Guassian (sum of two Gaussians) More...
struct	FitResults
	Results from minimizing a function. More...
class	FixedKernel
	A kernel created from an Image. More...
class	Function
	Basic Function class. More...
class	Function1
	A Function taking one argument. More...
class	Function2
	A Function taking two arguments. More...
class	GaussianFunction1
	1-dimensional Gaussian More...
class	GaussianFunction2
	2-dimensional Gaussian More...
class	GaussianProcess
	Stores values of a function sampled on an image and allows you to interpolate the function to unsampled points. More...
class	GaussianProcessTimer
	This is a structure for keeping track of how long the interpolation methods spend on different parts of the interpolation. More...
struct	generic_kernel_tag
	Tags carrying information about Kernels Kernel with no special properties. More...
class	ImageImposter
	A vector wrapper to provide a vector with the necessary methods and typedefs to be processed by Statistics as though it were an Image. More...
class	infinite_iterator
	This iterator will never increment. More...
class	IntegerDeltaFunction1
	1-dimensional integer delta function. More...
class	IntegerDeltaFunction2
	2-dimensional integer delta function. More...
class	Interpolate
class	InterpolateConstant
class	InterpolateGsl
struct	IntRegion
struct	is_analyticKernel
	traits class to determine if a Kernel is represented as an analytic function More...
struct	is_analyticKernel< AnalyticKernel >
struct	is_analyticKernel< KernelT * >
struct	is_analyticKernel< std::shared_ptr< KernelT > >
class	KdTree
	The data for GaussianProcess is stored in a KD tree to facilitate nearest-neighbor searches. More...
class	Kernel
	Kernels are used for convolution with MaskedImages and (eventually) Images. More...
struct	kernel_traits
	template trait class with information about Kernels More...
class	LanczosFunction1
	1-dimensional Lanczos function More...
class	LanczosFunction2
	2-dimensional separable Lanczos function More...
class	LanczosWarpingKernel
	Lanczos warping: accurate but slow and can introduce ringing artifacts. More...
class	LeastSquares
	Solver for linear least-squares problems. More...
class	LinearCombinationKernel
	A kernel that is a linear combination of fixed basis kernels. More...
class	MaskedVector
class	MaskImposter
	A Mask wrapper to provide an infinite_iterator for Mask::row_begin(). More...
class	NearestWarpingKernel
	Nearest neighbor warping: fast; good for undersampled data. More...
class	NeuralNetCovariogram
	a Covariogram that recreates a neural network with one hidden layer and infinite units in that layer More...
class	NullFunction1
	a class used in function calls to indicate that no Function1 is being provided More...
class	NullFunction2
	a class used in function calls to indicate that no Function2 is being provided More...
class	PixelAreaBoundedField
	A BoundedField that evaluate the pixel area of a SkyWcs in angular units. More...
class	PolynomialFunction1
	1-dimensional polynomial function. More...
class	PolynomialFunction2
	2-dimensional polynomial function with cross terms More...
class	ProductBoundedField
	A BoundedField that lazily multiplies a sequence of other BoundedFields. More...
class	Random
	A class that can be used to generate sequences of random numbers according to a number of different algorithms. More...
class	SeparableKernel
	A kernel described by a pair of functions: func(x, y) = colFunc(x) * rowFunc(y) More...
class	SpatialCell
	Class to ensure constraints for spatial modeling. More...
class	SpatialCellCandidate
	Base class for candidate objects in a SpatialCell. More...
class	SpatialCellCandidateIterator
	An iterator that only returns usable members of the SpatialCell. More...
class	SpatialCellImageCandidate
	Base class for candidate objects in a SpatialCell that are able to return an Image of some sort (e.g. More...
class	SpatialCellSet
	A collection of SpatialCells covering an entire image. More...
class	SquaredExpCovariogram
	SquaredExpCovariogram. More...
class	Statistics
	A class to evaluate image statistics. More...
class	StatisticsControl
	Pass parameters to a Statistics object. More...
class	TransformBoundedField
	A BoundedField based on geom::Transform<Poin2Endpoint, GenericEndpoint<1>>. More...
class	WarpingControl
	Parameters to control convolution. More...

Typedefs
using	KernelList = std::vector<std::shared_ptr<Kernel>>
using	WeightPixel = lsst::afw::image::VariancePixel
using	PyClass = py::class_<PixelAreaBoundedField, std::shared_ptr<PixelAreaBoundedField>, BoundedField>
using	ClsField = py::class_<TransformBoundedField, std::shared_ptr<TransformBoundedField>, BoundedField>

Enumerations
enum	UndersampleStyle { THROW_EXCEPTION , REDUCE_INTERP_ORDER , INCREASE_NXNYSAMPLE }
enum	Property {   NOTHING = 0x0 , ERRORS = 0x1 , NPOINT = 0x2 , MEAN = 0x4 ,   STDEV = 0x8 , VARIANCE = 0x10 , MEDIAN = 0x20 , IQRANGE = 0x40 ,   MEANCLIP = 0x80 , STDEVCLIP = 0x100 , VARIANCECLIP = 0x200 , MIN = 0x400 ,   MAX = 0x800 , SUM = 0x1000 , MEANSQUARE = 0x2000 , ORMASK = 0x4000 ,   NCLIPPED = 0x8000 , NMASKED = 0x10000 }
	control what is calculated More...

Functions
template<typename PixelT >
std::shared_ptr< Approximate< PixelT > >	makeApproximate (std::vector< double > const &x, std::vector< double > const &y, image::MaskedImage< PixelT > const &im, lsst::geom::Box2I const &bbox, ApproximateControl const &ctrl)
	Construct a new Approximate object, inferring the type from the type of the given MaskedImage.
UndersampleStyle	stringToUndersampleStyle (std::string const &style)
	Conversion function to switch a string to an UndersampleStyle.
template<typename ImageT >
std::shared_ptr< Background >	makeBackground (ImageT const &img, BackgroundControl const &bgCtrl)
	A convenience function that uses function overloading to make the correct type of Background.
std::shared_ptr< BoundedField >	operator* (double const scale, std::shared_ptr< BoundedField const > bf)
template<typename OutImageT , typename InImageT >
void	scaledPlus (OutImageT &outImage, double c1, InImageT const &inImage1, double c2, InImageT const &inImage2)
	Compute the scaled sum of two images.
template<typename OutImageT , typename InImageT >
OutImageT::SinglePixel	convolveAtAPoint (typename InImageT::const_xy_locator inImageLocator, image::Image< Kernel::Pixel >::const_xy_locator kernelLocator, int kWidth, int kHeight)
	Apply convolution kernel to an image at one point.
template<typename OutImageT , typename InImageT >
OutImageT::SinglePixel	convolveAtAPoint (typename InImageT::const_xy_locator inImageLocator, std::vector< Kernel::Pixel > const &kernelXList, std::vector< Kernel::Pixel > const &kernelYList)
	Apply separable convolution kernel to an image at one point.
template<typename OutImageT , typename InImageT , typename KernelT >
void	convolve (OutImageT &convolvedImage, InImageT const &inImage, KernelT const &kernel, ConvolutionControl const &convolutionControl=ConvolutionControl())
	Convolve an Image or MaskedImage with a Kernel, setting pixels of an existing output image.
template<typename ImageT >
ImageT::SinglePixel	edgePixel (lsst::afw::image::detail::Image_tag)
	Return an off-the-edge pixel appropriate for a given Image type.
template<typename MaskedImageT >
MaskedImageT::SinglePixel	edgePixel (lsst::afw::image::detail::MaskedImage_tag)
	Return an off-the-edge pixel appropriate for a given MaskedImage type.
template<typename UnaryFunctionT , typename Arg >
Arg	int1d (UnaryFunctionT func, IntRegion< Arg > &reg, Arg const &abserr=DEFABSERR, Arg const &relerr=DEFRELERR)
	Front end for the 1d integrator.
template<typename UnaryFunctionT , typename Arg >
auto	integrate (UnaryFunctionT func, Arg const a, Arg const b, double eps=1.0e-6)
	The 1D integrator.
template<typename BinaryFunctionT , typename X , typename Y >
auto	integrate2d (BinaryFunctionT func, X x1, X x2, Y y1, Y y2, double eps=1.0e-6)
	The 2D integrator.
std::shared_ptr< Interpolate >	makeInterpolate (std::vector< double > const &x, std::vector< double > const &y, Interpolate::Style const style=Interpolate::AKIMA_SPLINE)
	A factory function to make Interpolate objects.
std::shared_ptr< Interpolate >	makeInterpolate (ndarray::Array< double const, 1 > const &x, ndarray::Array< double const, 1 > const &y, Interpolate::Style const style=Interpolate::AKIMA_SPLINE)
Interpolate::Style	stringToInterpStyle (std::string const &style)
	Conversion function to switch a string to an Interpolate::Style.
Interpolate::Style	lookupMaxInterpStyle (int const n)
	Get the highest order Interpolation::Style available for 'n' points.
int	lookupMinInterpPoints (Interpolate::Style const style)
	Get the minimum number of points needed to use the requested interpolation style.
void	printKernel (lsst::afw::math::Kernel const &kernel, bool doNormalize, double x=0, double y=0, std::string pixelFmt="%7.3f")
	Print the pixel values of a Kernel to std::cout.
template<typename ReturnT >
FitResults	minimize (lsst::afw::math::Function1< ReturnT > const &function, std::vector< double > const &initialParameterList, std::vector< double > const &stepSizeList, std::vector< double > const &measurementList, std::vector< double > const &varianceList, std::vector< double > const &xPositionList, double errorDef)
	Find the minimum of a function(x)
template<typename ReturnT >
FitResults	minimize (lsst::afw::math::Function2< ReturnT > const &function, std::vector< double > const &initialParameterList, std::vector< double > const &stepSizeList, std::vector< double > const &measurementList, std::vector< double > const &varianceList, std::vector< double > const &xPositionList, std::vector< double > const &yPositionList, double errorDef)
	Find the minimum of a function(x, y)
template<typename ImageT >
std::shared_ptr< ImageT >	offsetImage (ImageT const &image, float dx, float dy, std::string const &algorithmName="lanczos5", unsigned int buffer=0)
	Return an image offset by (dx, dy) using the specified algorithm.
template<typename ImageT >
std::shared_ptr< ImageT >	rotateImageBy90 (ImageT const &image, int nQuarter)
	Rotate an image by an integral number of quarter turns.
template<typename ImageT >
std::shared_ptr< ImageT >	flipImage (ImageT const &inImage, bool flipLR, bool flipTB)
	Flip an image left–right and/or top–bottom.
template<typename ImageT >
std::shared_ptr< ImageT >	binImage (ImageT const &inImage, int const binX, int const binY, lsst::afw::math::Property const flags=lsst::afw::math::MEAN)
template<typename ImageT >
std::shared_ptr< ImageT >	binImage (ImageT const &inImage, int const binsize, lsst::afw::math::Property const flags=lsst::afw::math::MEAN)
template<typename ImageT >
void	randomUniformImage (ImageT *image, Random &rand)
	Set image to random numbers uniformly distributed in the range [0, 1)
template<typename ImageT >
void	randomUniformPosImage (ImageT *image, Random &rand)
	Set image to random numbers uniformly distributed in the range (0, 1)
template<typename ImageT >
void	randomUniformIntImage (ImageT *image, Random &rand, unsigned long n)
	Set image to random integers uniformly distributed in the range 0 ... n - 1.
template<typename ImageT >
void	randomFlatImage (ImageT *image, Random &rand, double const a, double const b)
	Set image to random numbers uniformly distributed in the range [a, b)
template<typename ImageT >
void	randomGaussianImage (ImageT *image, Random &rand)
	Set image to random numbers with a gaussian N(0, 1) distribution.
template<typename ImageT >
void	randomChisqImage (ImageT *image, Random &rand, double const nu)
	Set image to random numbers with a chi^2_{nu} distribution.
template<typename ImageT >
void	randomPoissonImage (ImageT *image, Random &rand, double const mu)
	Set image to random numbers with a Poisson distribution with mean mu (n.b.
template<typename PixelT >
std::shared_ptr< lsst::afw::image::Image< PixelT > >	statisticsStack (std::vector< std::shared_ptr< lsst::afw::image::Image< PixelT > > > &images, Property flags, StatisticsControl const &sctrl=StatisticsControl(), std::vector< lsst::afw::image::VariancePixel > const &wvector=std::vector< lsst::afw::image::VariancePixel >(0))
	A function to compute some statistics of a stack of Images.
template<typename PixelT >
void	statisticsStack (lsst::afw::image::Image< PixelT > &out, std::vector< std::shared_ptr< lsst::afw::image::Image< PixelT > > > &images, Property flags, StatisticsControl const &sctrl=StatisticsControl(), std::vector< lsst::afw::image::VariancePixel > const &wvector=std::vector< lsst::afw::image::VariancePixel >(0))
	@ brief compute statistical stack of Image.
template<typename PixelT >
std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > >	statisticsStack (std::vector< std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > > &images, Property flags, StatisticsControl const &sctrl, std::vector< lsst::afw::image::VariancePixel > const &wvector, image::MaskPixel clipped, std::vector< std::pair< image::MaskPixel, image::MaskPixel > > const &maskMap)
	A function to compute some statistics of a stack of Masked Images.
template<typename PixelT >
std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > >	statisticsStack (std::vector< std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > > &images, Property flags, StatisticsControl const &sctrl=StatisticsControl(), std::vector< lsst::afw::image::VariancePixel > const &wvector=std::vector< lsst::afw::image::VariancePixel >(0), image::MaskPixel clipped=0, image::MaskPixel excuse=0)
	A function to compute some statistics of a stack of Masked Images.
template<typename PixelT >
void	statisticsStack (lsst::afw::image::MaskedImage< PixelT > &out, std::vector< std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > > &images, Property flags, StatisticsControl const &sctrl, std::vector< lsst::afw::image::VariancePixel > const &wvector, image::MaskPixel clipped, std::vector< std::pair< image::MaskPixel, image::MaskPixel > > const &maskMap)
	A function to compute some statistics of a stack of Masked Images.
template<typename PixelT >
void	statisticsStack (lsst::afw::image::MaskedImage< PixelT > &out, std::vector< std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > > &images, Property flags, StatisticsControl const &sctrl=StatisticsControl(), std::vector< lsst::afw::image::VariancePixel > const &wvector=std::vector< lsst::afw::image::VariancePixel >(0), image::MaskPixel clipped=0, image::MaskPixel excuse=0)
	@ brief compute statistical stack of MaskedImage.
template<typename PixelT >
std::vector< PixelT >	statisticsStack (std::vector< std::vector< PixelT > > &vectors, Property flags, StatisticsControl const &sctrl=StatisticsControl(), std::vector< lsst::afw::image::VariancePixel > const &wvector=std::vector< lsst::afw::image::VariancePixel >(0))
	A function to compute some statistics of a stack of std::vectors.
template<typename PixelT >
std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > >	statisticsStack (lsst::afw::image::Image< PixelT > const &image, Property flags, char dimension, StatisticsControl const &sctrl=StatisticsControl())
	A function to compute statistics on the rows or columns of an image.
template<typename PixelT >
std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > >	statisticsStack (lsst::afw::image::MaskedImage< PixelT > const &image, Property flags, char dimension, StatisticsControl const &sctrl=StatisticsControl())
	A function to compute statistics on the rows or columns of an image.
Property	stringToStatisticsProperty (std::string const property)
	Conversion function to switch a string to a Property (see Statistics.h)
template<typename Pixel >
Statistics	makeStatistics (lsst::afw::image::Image< Pixel > const &img, lsst::afw::image::Mask< image::MaskPixel > const &msk, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Handle a watered-down front-end to the constructor (no variance)
template<typename ImageT , typename MaskT , typename VarianceT >
Statistics	makeStatistics (ImageT const &img, MaskT const &msk, VarianceT const &var, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Handle a straight front-end to the constructor.
template<typename Pixel >
Statistics	makeStatistics (lsst::afw::image::MaskedImage< Pixel > const &mimg, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Handle MaskedImages, just pass the getImage() and getMask() values right on through.
template<typename Pixel >
Statistics	makeStatistics (lsst::afw::image::MaskedImage< Pixel > const &mimg, lsst::afw::image::Image< WeightPixel > const &weights, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Handle MaskedImages, just pass the getImage() and getMask() values right on through.
Statistics	makeStatistics (lsst::afw::image::Mask< lsst::afw::image::MaskPixel > const &msk, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Specialization to handle Masks.
template<typename Pixel >
Statistics	makeStatistics (lsst::afw::image::Image< Pixel > const &img, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle regular (non-masked) Images.
template<typename EntryT >
Statistics	makeStatistics (std::vector< EntryT > const &v, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle std::vector<>
template<typename EntryT >
Statistics	makeStatistics (std::vector< EntryT > const &v, std::vector< WeightPixel > const &vweights, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle std::vector<>
template<typename EntryT >
Statistics	makeStatistics (lsst::afw::math::MaskedVector< EntryT > const &mv, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle lsst::afw::math::MaskedVector<>
template<typename EntryT >
Statistics	makeStatistics (lsst::afw::math::MaskedVector< EntryT > const &mv, std::vector< WeightPixel > const &vweights, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle lsst::afw::math::MaskedVector<>
std::shared_ptr< SeparableKernel >	makeWarpingKernel (std::string name)
	Return a warping kernel given its name.
template<typename DestExposureT , typename SrcExposureT >
int	warpExposure (DestExposureT &destExposure, SrcExposureT const &srcExposure, WarpingControl const &control, typename DestExposureT::MaskedImageT::SinglePixel padValue=lsst::afw::math::edgePixel< typename DestExposureT::MaskedImageT >(typename lsst::afw::image::detail::image_traits< typename DestExposureT::MaskedImageT >::image_category()))
	Warp (remap) one exposure to another.
template<typename DestImageT , typename SrcImageT >
int	warpImage (DestImageT &destImage, geom::SkyWcs const &destWcs, SrcImageT const &srcImage, geom::SkyWcs const &srcWcs, WarpingControl const &control, typename DestImageT::SinglePixel padValue=lsst::afw::math::edgePixel< DestImageT >(typename lsst::afw::image::detail::image_traits< DestImageT >::image_category()))
	Warp an Image or MaskedImage to a new Wcs.
template<typename DestImageT , typename SrcImageT >
int	warpImage (DestImageT &destImage, SrcImageT const &srcImage, geom::TransformPoint2ToPoint2 const &srcToDest, WarpingControl const &control, typename DestImageT::SinglePixel padValue=lsst::afw::math::edgePixel< DestImageT >(typename lsst::afw::image::detail::image_traits< DestImageT >::image_category()))
	A variant of warpImage that uses a Transform<Point2Endpoint, Point2Endpoint> instead of a pair of WCS to describe the transformation.
template<typename DestImageT , typename SrcImageT >
int	warpCenteredImage (DestImageT &destImage, SrcImageT const &srcImage, lsst::geom::LinearTransform const &linearTransform, lsst::geom::Point2D const &centerPosition, WarpingControl const &control, typename DestImageT::SinglePixel padValue=lsst::afw::math::edgePixel< DestImageT >(typename lsst::afw::image::detail::image_traits< DestImageT >::image_category()))
	Warp an image with a LinearTranform about a specified point.
void	wrapApproximate (lsst::utils::python::WrapperCollection &wrappers)
void	declareBackground (lsst::utils::python::WrapperCollection &wrappers)
void	wrapBackground (lsst::utils::python::WrapperCollection &wrappers)
void	declareBoundedField (lsst::utils::python::WrapperCollection &wrappers)
void	wrapBoundedField (lsst::utils::python::WrapperCollection &wrappers)
void	wrapChebyshevBoundedField (lsst::utils::python::WrapperCollection &wrappers)
void	wrapConvolveImage (lsst::utils::python::WrapperCollection &wrappers)
void	wrapFunction (lsst::utils::python::WrapperCollection &wrappers)
template<typename ReturnT >
void	declarePolynomialFunctions (lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix)
template<typename ReturnT >
void	declareChebyshevFunctions (lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix)
template<typename ReturnT >
void	declareGaussianFunctions (lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix)
template<typename ReturnT >
void	declareIntegerDeltaFunctions (lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix)
template<typename ReturnT >
void	declareLanczosFunctions (lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix)
void	wrapFunctionLibrary (lsst::utils::python::WrapperCollection &wrappers)
void	wrapGaussianProcess (lsst::utils::python::WrapperCollection &wrappers)
void	wrapInterpolate (lsst::utils::python::WrapperCollection &wrappers)
void	wrapKernel (lsst::utils::python::WrapperCollection &wrappers)
void	wrapLeastSquares (lsst::utils::python::WrapperCollection &wrappers)
void	wrapMinimize (lsst::utils::python::WrapperCollection &)
void	wrapOffsetImage (lsst::utils::python::WrapperCollection &)
void	wrapPixelAreaBoundedField (lsst::utils::python::WrapperCollection &)
void	wrapProductBoundedField (lsst::utils::python::WrapperCollection &)
void	wrapRandom (lsst::utils::python::WrapperCollection &)
void	wrapSpatialCell (lsst::utils::python::WrapperCollection &)
void	wrapStack (lsst::utils::python::WrapperCollection &)
void	wrapStatistics (lsst::utils::python::WrapperCollection &)
void	wrapTransformBoundedField (lsst::utils::python::WrapperCollection &)
void	wrapWarpExposure (lsst::utils::python::WrapperCollection &)
	PYBIND11_MODULE (_math, mod)
template<typename ImageT >
void	declareRandomImage (lsst::utils::python::WrapperCollection &wrappers)
void	declareRandom (lsst::utils::python::WrapperCollection &wrappers)
template<typename Pixel >
void	declareStatistics (lsst::utils::python::WrapperCollection &wrappers)
template<typename Pixel >
void	declareStatisticsVectorOverloads (lsst::utils::python::WrapperCollection &wrappers)
void	declareStatistics (lsst::utils::python::WrapperCollection &wrappers)
void	declareTransformBoundedField (lsst::utils::python::WrapperCollection &wrappers)
double	integrateTn (int n)
template<typename OutImageT , typename InImageT , typename KernelT >
void	convolve (OutImageT &convolvedImage, InImageT const &inImage, KernelT const &kernel, bool doNormalize, bool doCopyEdge)
template<typename PixelT >
std::shared_ptr< image::MaskedImage< PixelT > >	statisticsStack (std::vector< std::shared_ptr< image::MaskedImage< PixelT > > > &images, Property flags, StatisticsControl const &sctrl, WeightVector const &wvector, image::MaskPixel clipped, image::MaskPixel excuse)
template<typename PixelT >
std::shared_ptr< image::MaskedImage< PixelT > >	statisticsStack (std::vector< std::shared_ptr< image::MaskedImage< PixelT > > > &images, Property flags, StatisticsControl const &sctrl, WeightVector const &wvector, image::MaskPixel clipped, std::vector< std::pair< image::MaskPixel, image::MaskPixel > > const &maskMap)
template<typename PixelT >
void	statisticsStack (image::MaskedImage< PixelT > &out, std::vector< std::shared_ptr< image::MaskedImage< PixelT > > > &images, Property flags, StatisticsControl const &sctrl, WeightVector const &wvector, image::MaskPixel clipped, image::MaskPixel excuse)
template<typename PixelT >
void	statisticsStack (image::MaskedImage< PixelT > &out, std::vector< std::shared_ptr< image::MaskedImage< PixelT > > > &images, Property flags, StatisticsControl const &sctrl, WeightVector const &wvector, image::MaskPixel clipped, std::vector< std::pair< image::MaskPixel, image::MaskPixel > > const &maskMap)
template<typename PixelT >
std::shared_ptr< image::Image< PixelT > >	statisticsStack (std::vector< std::shared_ptr< image::Image< PixelT > > > &images, Property flags, StatisticsControl const &sctrl, WeightVector const &wvector)
template<typename PixelT >
void	statisticsStack (image::Image< PixelT > &out, std::vector< std::shared_ptr< image::Image< PixelT > > > &images, Property flags, StatisticsControl const &sctrl, WeightVector const &wvector)
template<typename PixelT >
std::vector< PixelT >	statisticsStack (std::vector< std::vector< PixelT > > &vectors, Property flags, StatisticsControl const &sctrl, WeightVector const &wvector)
template<typename PixelT >
std::shared_ptr< image::MaskedImage< PixelT > >	statisticsStack (image::Image< PixelT > const &image, Property flags, char dimension, StatisticsControl const &sctrl)
	A function to compute statistics on the rows or columns of an image.
template<typename PixelT >
std::shared_ptr< image::MaskedImage< PixelT > >	statisticsStack (image::MaskedImage< PixelT > const &image, Property flags, char dimension, StatisticsControl const &sctrl)
	A function to compute statistics on the rows or columns of an image.

Variables
template<typename T >
bool constexpr	IS_NOTHROW_INIT = noexcept(static_cast<T>(1.0))
	Test that a Function's return value is nothrow-castable to T.
double const	MOCK_INF = 1.e10
double const	DEFABSERR = 1.e-15
double const	DEFRELERR = 1.e-6
generic_kernel_tag	generic_kernel_tag_
	Used as default value in argument lists.
deltafunction_kernel_tag	deltafunction_kernel_tag_
	Used as default value in argument lists.

Typedef Documentation

ClsField

using lsst::afw::math::ClsField = py::class_<TransformBoundedField, std::shared_ptr<TransformBoundedField>, BoundedField>

Definition at line 42 of file _transformBoundedField.cc.

KernelList

using lsst::afw::math::KernelList = std::vector<std::shared_ptr<Kernel>>

Definition at line 462 of file Kernel.h.

PyClass

typedef py::class_< ProductBoundedField, std::shared_ptr< ProductBoundedField >, BoundedField > lsst::afw::math::PyClass = py::class_<PixelAreaBoundedField, std::shared_ptr<PixelAreaBoundedField>, BoundedField>

Definition at line 35 of file _pixelAreaBoundedField.cc.

WeightPixel

using lsst::afw::math::WeightPixel = lsst::afw::image::VariancePixel

Definition at line 48 of file Statistics.h.

Enumeration Type Documentation

Property

enum lsst::afw::math::Property

control what is calculated

Enumerator
NOTHING	We don't want anything.
ERRORS	Include errors of requested quantities.
NPOINT	number of sample points
MEAN	estimate sample mean
STDEV	estimate sample standard deviation
VARIANCE	estimate sample variance
MEDIAN	estimate sample median
IQRANGE	estimate sample inter-quartile range
MEANCLIP	estimate sample N-sigma clipped mean (N set in StatisticsControl, default=3)
STDEVCLIP	estimate sample N-sigma clipped stdev (N set in StatisticsControl, default=3)
VARIANCECLIP	estimate sample N-sigma clipped variance (N set in StatisticsControl, default=3)
MIN	estimate sample minimum
MAX	estimate sample maximum
SUM	find sum of pixels in the image
MEANSQUARE	find mean value of square of pixel values
ORMASK	get the or-mask of all pixels used.
NCLIPPED	number of clipped points
NMASKED	number of masked points

Definition at line 53 of file Statistics.h.

              {
    NOTHING = 0x0,         
    ERRORS = 0x1,          
    NPOINT = 0x2,          
    MEAN = 0x4,            
    STDEV = 0x8,           
    VARIANCE = 0x10,       
    MEDIAN = 0x20,         
    IQRANGE = 0x40,        
    MEANCLIP = 0x80,       
    STDEVCLIP = 0x100,     
    VARIANCECLIP = 0x200,  
    MIN = 0x400,           
    MAX = 0x800,           
    SUM = 0x1000,          
    MEANSQUARE = 0x2000,   
    ORMASK = 0x4000,       
    NCLIPPED = 0x8000,     
    NMASKED = 0x10000      
};

UndersampleStyle

enum lsst::afw::math::UndersampleStyle

Enumerator
THROW_EXCEPTION
REDUCE_INTERP_ORDER
INCREASE_NXNYSAMPLE

Definition at line 47 of file Background.h.

{ THROW_EXCEPTION, REDUCE_INTERP_ORDER, INCREASE_NXNYSAMPLE };

Function Documentation

binImage() [1/2]

template<typename ImageT >

std::shared_ptr< ImageT > lsst::afw::math::binImage	(	ImageT const &	inImage,
		int const	binsize,
		lsst::afw::math::Property const	flags = lsst::afw::math::MEAN )

Parameters

inImage	The image to bin
binsize	Output pixels are binsize*binsize input pixels
flags	how to generate super-pixels

Definition at line 39 of file binImage.cc.

                                                                                                     {
    return binImage(in, binsize, binsize, flags);
}

binImage() [2/2]

template<typename ImageT >

std::shared_ptr< ImageT > lsst::afw::math::binImage	(	ImageT const &	inImage,
		int const	binX,
		int const	binY,
		lsst::afw::math::Property const	flags = lsst::afw::math::MEAN )

Parameters

inImage	The image to bin
binX	Output pixels are binX*binY input pixels
binY	Output pixels are binX*binY input pixels
flags	how to generate super-pixels

Definition at line 44 of file binImage.cc.

                                                                  {
    if (flags != lsst::afw::math::MEAN) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                          (boost::format("Only afwMath::MEAN is supported, saw 0x%x") % flags).str());
    }
    if (binX <= 0 || binY <= 0) {
        throw LSST_EXCEPT(pexExcept::DomainError,
                          (boost::format("Binning must be >= 0, saw %dx%d") % binX % binY).str());
    }
 
    int const outWidth = in.getWidth() / binX;
    int const outHeight = in.getHeight() / binY;
 
    std::shared_ptr<ImageT> out =
            std::shared_ptr<ImageT>(new ImageT(lsst::geom::Extent2I(outWidth, outHeight)));
    out->setXY0(in.getXY0());
    *out = typename ImageT::SinglePixel(0);
 
    for (int oy = 0, iy = 0; oy < out->getHeight(); ++oy) {
        for (int i = 0; i != binY; ++i, ++iy) {
            typename ImageT::x_iterator optr = out->row_begin(oy);
            for (typename ImageT::x_iterator iptr = in.row_begin(iy), iend = iptr + binX * outWidth;
                 iptr < iend;) {
                typename ImageT::SinglePixel val = *iptr;
                ++iptr;
                for (int j = 1; j != binX; ++j, ++iptr) {
                    val += *iptr;
                }
                *optr += val;
                ++optr;
            }
        }
        for (typename ImageT::x_iterator ptr = out->row_begin(oy), end = out->row_end(oy); ptr != end;
             ++ptr) {
            *ptr /= binX * binY;
        }
    }
 
    return out;
}

convolve() [1/2]

template<typename OutImageT , typename InImageT , typename KernelT >

void lsst::afw::math::convolve	(	OutImageT &	convolvedImage,
		InImageT const &	inImage,
		KernelT const &	kernel,
		bool	doNormalize,
		bool	doCopyEdge )

Definition at line 190 of file ConvolveImage.cc.

                               {
    ConvolutionControl convolutionControl;
    convolutionControl.setDoNormalize(doNormalize);
    convolutionControl.setDoCopyEdge(doCopyEdge);
    convolve(convolvedImage, inImage, kernel, convolutionControl);
}

convolve() [2/2]

template<typename OutImageT , typename InImageT , typename KernelT >

void lsst::afw::math::convolve	(	OutImageT &	convolvedImage,
		InImageT const &	inImage,
		KernelT const &	kernel,
		ConvolutionControl const &	convolutionControl = ConvolutionControl() )

Convolve an Image or MaskedImage with a Kernel, setting pixels of an existing output image.

Various convolution kernels are available, including:

• FixedKernel: a kernel based on an image
• AnalyticKernel: a kernel based on a Function
• SeparableKernel: a kernel described by the product of two one-dimensional Functions: f0(x) * f1(y)
• LinearCombinationKernel: a linear combination of a set of spatially invariant basis kernels.
• DeltaFunctionKernel: a kernel that is all zeros except one pixel whose value is 1. Typically used as a basis kernel for LinearCombinationKernel.

If a kernel is spatially varying, its spatial model is computed at each pixel position on the image (pixel position, not pixel index). At present (2009-09-24) this position is computed relative to the lower left corner of the sub-image, but it will almost certainly change to be the lower left corner of the parent image.

All convolution is performed in real space. This allows convolution to handle masked pixels and spatially varying kernels. Although convolution of an Image with a spatially invariant kernel could, in fact, be performed in Fourier space, the code does not do this.

Note that mask bits are smeared by convolution; all nonzero pixels in the kernel smear the mask, even pixels that have very small values. Larger kernels smear the mask more and are also slower to convolve. Use the smallest kernel that will do the job.

convolvedImage has a border of edge pixels which cannot be computed normally. Normally these pixels are set to the standard edge pixel, as returned by edgePixel(). However, if your code cannot handle nans in the image or infs in the variance, you may set doCopyEdge true, in which case the edge pixels are set to the corresponding pixels of the input image and (if there is a mask) the mask EDGE bit is set.

The border of edge pixels has size:

• kernel.getCtr().getX() along the left edge
• kernel.getCtr().getY() along the bottom edge
• kernel.getWidth() - 1 - kernel.getCtr().getX() along the right edge
• kernel.getHeight() - 1 - kernel.getCtr().getY() along the top edge You can obtain a bounding box for the good pixels in the convolved image from a bounding box for the entire image using the Kernel method shrinkBBox.

Convolution has been optimized for the various kinds of kernels, as follows (listed approximately in order of decreasing speed):

• DeltaFunctionKernel convolution is a simple image shift.
• SeparableKernel convolution is performed by convolving the input by one of the two functions, then the result by the other function. Thus convolution with a kernel of size nCols x nRows becomes convolution with a kernel of size nCols x 1, followed by convolution with a kernel of size 1 x nRows.
• Convolution with spatially invariant versions of the other kernels is performed by computing the kernel image once and convolving with that. The code has been optimized for cache performance and so should be fairly efficient.
• Convolution with a spatially varying LinearCombinationKernel is performed by convolving the image by each basis kernel and combining the result by solving the spatial model. This will be efficient provided the kernel does not contain too many or very large basis kernels.
• Convolution with spatially varying AnalyticKernel is likely to be slow. The code simply computes the output one pixel at a time by computing the AnalyticKernel at that point and applying it to the input image. This is not favorable for cache performance (especially for large kernels) but avoids recomputing the AnalyticKernel. It is probably possible to do better.

Additional convolution functions include:

• convolveAtAPoint(): convolve a Kernel to an Image or MaskedImage at a point.
• basicConvolve(): convolve a Kernel with an Image or MaskedImage, but do not set the edge pixels of the output. Optimization of convolution for different types of Kernel are handled by different specializations of basicConvolve().

Parameters

[out]	convolvedImage	convolved image; must be the same size as inImage
[in]	inImage	image to convolve
[in]	kernel	convolution kernel
[in]	convolutionControl	convolution control parameters

Exceptions

lsst::pex::exceptions::InvalidParameterError	if convolvedImage is not the same size as inImage
lsst::pex::exceptions::InvalidParameterError	if inImage is smaller than kernel in columns and/or rows.
std::bad_alloc	when allocation of memory fails

Definition at line 181 of file ConvolveImage.cc.

                                                            {
    detail::basicConvolve(convolvedImage, inImage, kernel, convolutionControl);
    setEdgePixels(convolvedImage, kernel, inImage, convolutionControl.getDoCopyEdge(),
                  typename image::detail::image_traits<OutImageT>::image_category());
    convolvedImage.setXY0(inImage.getXY0());
}

convolveAtAPoint() [1/2]

template<typename OutImageT , typename InImageT >

OutImageT::SinglePixel lsst::afw::math::convolveAtAPoint ( typename InImageT::const_xy_locator inImageLocator, image::Image< Kernel::Pixel >::const_xy_locator kernelLocator, int kWidth, int kHeight )

inline

Apply convolution kernel to an image at one point.

Note

This subroutine sacrifices convenience for performance. The user is expected to figure out the kernel center and adjust the supplied pixel accessors accordingly. For an example of how to do this see convolve().

Parameters

inImageLocator	locator for image pixel that overlaps pixel (0,0) of kernel (the origin of the kernel, not its center)
kernelLocator	locator for (0,0) pixel of kernel (the origin of the kernel, not its center)
kWidth	number of columns in kernel
kHeight	number of rows in kernel

Definition at line 257 of file ConvolveImage.h.

                                                                                        {
    typename OutImageT::SinglePixel outValue = 0;
    for (int kRow = 0; kRow != kHeight; ++kRow) {
        for (image::Image<Kernel::Pixel>::const_xy_locator kEnd =
                     kernelLocator + image::detail::difference_type(kWidth, 0);
             kernelLocator != kEnd; ++inImageLocator.x(), ++kernelLocator.x()) {
            typename Kernel::Pixel const kVal = kernelLocator[0];
            if (kVal != 0) {
                outValue += *inImageLocator * kVal;
            }
        }
 
        inImageLocator += image::detail::difference_type(-kWidth, 1);
        kernelLocator += image::detail::difference_type(-kWidth, 1);
    }
 
    return outValue;
}

convolveAtAPoint() [2/2]

template<typename OutImageT , typename InImageT >

OutImageT::SinglePixel lsst::afw::math::convolveAtAPoint ( typename InImageT::const_xy_locator inImageLocator, std::vector< Kernel::Pixel > const & kernelXList, std::vector< Kernel::Pixel > const & kernelYList )

inline

Apply separable convolution kernel to an image at one point.

Note

This subroutine sacrifices convenience for performance. The user is expected to figure out the kernel center and adjust the supplied pixel accessors accordingly. For an example of how to do this see convolve().

Parameters

inImageLocator	locator for image pixel that overlaps pixel (0,0) of kernel (the origin of the kernel, not its center)
kernelXList	kernel column vector
kernelYList	kernel row vector

Definition at line 293 of file ConvolveImage.h.

                                                                                                   {
    using k_iter = typename std::vector<Kernel::Pixel>::const_iterator;
 
    using OutT = typename OutImageT::SinglePixel;
    OutT outValue = 0;
    for (double kValY : kernelYList) {
        OutT outValueY = 0;
        for (k_iter kernelXIter = kernelXList.begin(), xEnd = kernelXList.end(); kernelXIter != xEnd;
             ++kernelXIter, ++inImageLocator.x()) {
            typename Kernel::Pixel const kValX = *kernelXIter;
            if (kValX != 0) {
                outValueY += *inImageLocator * kValX;
            }
        }
 
        if (kValY != 0) {
            outValue += outValueY * kValY;
        }
 
        inImageLocator += image::detail::difference_type(-kernelXList.size(), 1);
    }
 
    return outValue;
}

declareBackground()

void lsst::afw::math::declareBackground

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 73 of file _background.cc.

                                                                   {
    /* Member types and enums */
    wrappers.wrapType(py::enum_<UndersampleStyle>(wrappers.module, "UndersampleStyle"),
                      [](auto &mod, auto &enm) {
                          enm.value("THROW_EXCEPTION", UndersampleStyle::THROW_EXCEPTION);
                          enm.value("REDUCE_INTERP_ORDER", UndersampleStyle::REDUCE_INTERP_ORDER);
                          enm.value("INCREASE_NXNYSAMPLE", UndersampleStyle::INCREASE_NXNYSAMPLE);
                          enm.export_values();
                      });
 
    using PyBackgroundControl = py::class_<BackgroundControl, std::shared_ptr<BackgroundControl>>;
    wrappers.wrapType(PyBackgroundControl(wrappers.module, "BackgroundControl"), [](auto &mod, auto &cls) {
        /* Constructors */
        cls.def(py::init<int const, int const, StatisticsControl const, Property const,
                         ApproximateControl const>(),
                "nxSample"_a, "nySample"_a, "sctrl"_a = StatisticsControl(), "prop"_a = MEANCLIP,
                "actrl"_a = ApproximateControl(ApproximateControl::UNKNOWN, 1));
        cls.def(py::init<int const, int const, StatisticsControl const, std::string const &,
                         ApproximateControl const>(),
                "nxSample"_a, "nySample"_a, "sctrl"_a, "prop"_a,
                "actrl"_a = ApproximateControl(ApproximateControl::UNKNOWN, 1));
        cls.def(py::init<Interpolate::Style const, int const, int const, UndersampleStyle const,
                         StatisticsControl const, Property const, ApproximateControl const>(),
                "style"_a, "nxSample"_a = 10, "nySample"_a = 10, "undersampleStyle"_a = THROW_EXCEPTION,
                "sctrl"_a = StatisticsControl(), "prop"_a = MEANCLIP,
                "actrl"_a = ApproximateControl(ApproximateControl::UNKNOWN, 1));
        cls.def(py::init<std::string const &, int const, int const, std::string const &,
                         StatisticsControl const, std::string const &, ApproximateControl const>(),
                "style"_a, "nxSample"_a = 10, "nySample"_a = 10, "undersampleStyle"_a = "THROW_EXCEPTION",
                "sctrl"_a = StatisticsControl(), "prop"_a = "MEANCLIP",
                "actrl"_a = ApproximateControl(ApproximateControl::UNKNOWN, 1));
 
        /* Members */
        cls.def("setNxSample", &BackgroundControl::setNxSample);
        cls.def("setNySample", &BackgroundControl::setNySample);
        cls.def("setInterpStyle",
                (void (BackgroundControl::*)(Interpolate::Style const)) & BackgroundControl::setInterpStyle);
        cls.def("setInterpStyle",
                (void (BackgroundControl::*)(std::string const &)) & BackgroundControl::setInterpStyle);
        cls.def("setUndersampleStyle", (void (BackgroundControl::*)(UndersampleStyle const)) &
                                               BackgroundControl::setUndersampleStyle);
        cls.def("setUndersampleStyle",
                (void (BackgroundControl::*)(std::string const &)) & BackgroundControl::setUndersampleStyle);
        cls.def("getNxSample", &BackgroundControl::getNxSample);
        cls.def("getNySample", &BackgroundControl::getNySample);
        cls.def("getInterpStyle", &BackgroundControl::getInterpStyle);
        cls.def("getUndersampleStyle", &BackgroundControl::getUndersampleStyle);
        cls.def("getStatisticsControl", (std::shared_ptr<StatisticsControl>(BackgroundControl::*)()) &
                                                BackgroundControl::getStatisticsControl);
        cls.def("getStatisticsProperty", &BackgroundControl::getStatisticsProperty);
        cls.def("setStatisticsProperty",
                (void (BackgroundControl::*)(Property)) & BackgroundControl::setStatisticsProperty);
        cls.def("setStatisticsProperty",
                (void (BackgroundControl::*)(std::string)) & BackgroundControl::setStatisticsProperty);
        cls.def("setApproximateControl", &BackgroundControl::setApproximateControl);
        cls.def("getApproximateControl", (std::shared_ptr<ApproximateControl>(BackgroundControl::*)()) &
                                                 BackgroundControl::getApproximateControl);
    });
    using PyBackground = py::class_<Background, std::shared_ptr<Background>>;
    wrappers.wrapType(PyBackground(wrappers.module, "Background"), [](auto &mod, auto &cls) {
        /* Members */
        declareGetImage<float>(cls, "F");
 
        cls.def("getAsUsedInterpStyle", &Background::getAsUsedInterpStyle);
        cls.def("getAsUsedUndersampleStyle", &Background::getAsUsedUndersampleStyle);
        cls.def("getApproximate", &Background::getApproximate, "actrl"_a,
                "undersampleStyle"_a = THROW_EXCEPTION);
        cls.def("getBackgroundControl",
                (std::shared_ptr<BackgroundControl>(Background::*)()) & Background::getBackgroundControl);
    });
 
    using PyBackgroundMI = py::class_<BackgroundMI, std::shared_ptr<BackgroundMI>, Background>;
    wrappers.wrapType(PyBackgroundMI(wrappers.module, "BackgroundMI"), [](auto &mod, auto &cls) {
        /* Constructors */
        cls.def(py::init<lsst::geom::Box2I const,
                         image::MaskedImage<typename Background::InternalPixelT> const &>(),
                "imageDimensions"_a, "statsImage"_a);
 
        /* Operators */
        cls.def("__iadd__", &BackgroundMI::operator+=);
        cls.def("__isub__", &BackgroundMI::operator-=);
 
        /* Members */
        cls.def("getStatsImage", &BackgroundMI::getStatsImage);
        cls.def("getImageBBox", &BackgroundMI::getImageBBox);
 
        // Yes, really only float
    });
}

declareBoundedField()

void lsst::afw::math::declareBoundedField

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 62 of file _boundedField.cc.

                                                                     {
    wrappers.wrapType(PyClass(wrappers.module, "BoundedField"), [](auto &mod, auto &cls) {
        table::io::python::addPersistableMethods<BoundedField>(cls);
 
        cls.def(
                "__rmul__", [](BoundedField &bf, double const scale) { return bf * scale; },
                py::is_operator());
        cls.def("__mul__", &BoundedField::operator*, py::is_operator());
        cls.def("__truediv__", &BoundedField::operator/, py::is_operator());
        cls.def("__eq__", &BoundedField::operator==, py::is_operator());
        cls.def("__ne__", &BoundedField::operator!=, py::is_operator());
 
        cls.def("evaluate", (double (BoundedField::*)(double, double) const) & BoundedField::evaluate);
        cls.def("evaluate", (ndarray::Array<double, 1, 1>(BoundedField::*)(
                                    ndarray::Array<double const, 1> const &,
                                    ndarray::Array<double const, 1> const &) const) &
                                    BoundedField::evaluate);
        cls.def("evaluate",
                (double (BoundedField::*)(lsst::geom::Point2D const &) const) & BoundedField::evaluate);
        cls.def("integrate", &BoundedField::integrate);
        cls.def("mean", &BoundedField::mean);
        cls.def("getBBox", &BoundedField::getBBox);
 
        // Pybind11 resolves overloads by picking the first one that might work
        declareTemplates<double>(cls);
        declareTemplates<float>(cls);
 
        utils::python::addOutputOp(cls, "__str__");
        cls.def("__repr__", [](BoundedField const &self) {
            std::ostringstream os;
            os << "BoundedField(" << self << ")";
            return os.str();
        });
    });
}

declareChebyshevFunctions()

template<typename ReturnT >

void lsst::afw::math::declareChebyshevFunctions	(	lsst::utils::python::WrapperCollection &	wrappers,
		const std::string &	suffix )

Definition at line 79 of file _functionLibrary.cc.

                                                                                                    {
    /* Chebyshev1Function1 */
 
    wrappers.wrapType(
            py::class_<Chebyshev1Function1<ReturnT>, std::shared_ptr<Chebyshev1Function1<ReturnT>>,
                       Function1<ReturnT>>(wrappers.module, ("Chebyshev1Function1" + suffix).c_str()),
            [](auto &mod, auto &cls) {
                cls.def(py::init<std::vector<double>, double, double>(), "params"_a, "minX"_a = -1,
                        "maxX"_a = 1);
                cls.def(py::init<unsigned int, double, double>(), "order"_a, "minX"_a = -1, "maxX"_a = 1);
 
                cls.def("__call__", &Chebyshev1Function1<ReturnT>::operator(), "x"_a);
                cls.def("clone", &Chebyshev1Function1<ReturnT>::clone);
                cls.def("getMinX", &Chebyshev1Function1<ReturnT>::getMinX);
                cls.def("getMaxX", &Chebyshev1Function1<ReturnT>::getMaxX);
                cls.def("getOrder", &Chebyshev1Function1<ReturnT>::getOrder);
                cls.def("isLinearCombination", &Chebyshev1Function1<ReturnT>::isLinearCombination);
                cls.def("toString", &Chebyshev1Function1<ReturnT>::toString, "prefix"_a = "");
 
                /* Chebyshev1Function2 */
            });
    wrappers.wrapType(py::class_<Chebyshev1Function2<ReturnT>, std::shared_ptr<Chebyshev1Function2<ReturnT>>,
                                 BasePolynomialFunction2<ReturnT>>(wrappers.module,
                                                                   ("Chebyshev1Function2" + suffix).c_str()),
                      [](auto &mod, auto &cls) {
                          cls.def(py::init<std::vector<double>, lsst::geom::Box2D const &>(), "params"_a,
                                  "xyRange"_a = lsst::geom::Box2D(lsst::geom::Point2D(-1.0, -1.0),
                                                                  lsst::geom::Point2D(1.0, 1.0)));
                          cls.def(py::init<unsigned int, lsst::geom::Box2D const &>(), "order"_a,
                                  "xyRange"_a = lsst::geom::Box2D(lsst::geom::Point2D(-1.0, -1.0),
                                                                  lsst::geom::Point2D(1.0, 1.0)));
 
                          cls.def("__call__", &Chebyshev1Function2<ReturnT>::operator(), "x"_a, "y"_a);
                          cls.def("clone", &Chebyshev1Function2<ReturnT>::clone);
                          cls.def("getXYRange", &Chebyshev1Function2<ReturnT>::getXYRange);
                          cls.def("truncate", &Chebyshev1Function2<ReturnT>::truncate, "order"_a);
                          cls.def("toString", &Chebyshev1Function2<ReturnT>::toString, "prefix"_a = "");
                          cls.def("isPersistable", &Chebyshev1Function2<ReturnT>::isPersistable);
                      });
};

declareGaussianFunctions()

template<typename ReturnT >

void lsst::afw::math::declareGaussianFunctions	(	lsst::utils::python::WrapperCollection &	wrappers,
		const std::string &	suffix )

Definition at line 121 of file _functionLibrary.cc.

                                                                                                   {
    /* GaussianFunction1 */
    wrappers.wrapType(py::class_<GaussianFunction1<ReturnT>, std::shared_ptr<GaussianFunction1<ReturnT>>,
                                 Function1<ReturnT>>(wrappers.module, ("GaussianFunction1" + suffix).c_str()),
                      [](auto &mod, auto &cls) {
                          cls.def(py::init<double>(), "sigma"_a);
 
                          cls.def("__call__", &GaussianFunction1<ReturnT>::operator(), "x"_a);
                          cls.def("clone", &GaussianFunction1<ReturnT>::clone);
                          cls.def("toString", &GaussianFunction1<ReturnT>::toString, "prefix"_a = "");
                      });
 
    wrappers.wrapType(py::class_<GaussianFunction2<ReturnT>, std::shared_ptr<GaussianFunction2<ReturnT>>,
                                 Function2<ReturnT>>(wrappers.module, ("GaussianFunction2" + suffix).c_str()),
                      [](auto &mod, auto &cls) {
                          /* GaussianFunction2 */
 
                          cls.def(py::init<double, double, double>(), "sigma1"_a, "sigma2"_a,
                                  "angle"_a = 0.0);
 
                          cls.def("__call__", &GaussianFunction2<ReturnT>::operator(), "x"_a, "y"_a);
                          cls.def("clone", &GaussianFunction2<ReturnT>::clone);
                          cls.def("toString", &GaussianFunction2<ReturnT>::toString, "prefix"_a = "");
                          cls.def("isPersistable", &GaussianFunction2<ReturnT>::isPersistable);
                      });
    /* DoubleGaussianFunction2 */
 
    wrappers.wrapType(
            py::class_<DoubleGaussianFunction2<ReturnT>, std::shared_ptr<DoubleGaussianFunction2<ReturnT>>,
                       Function2<ReturnT>>(wrappers.module, ("DoubleGaussianFunction2" + suffix).c_str()),
            [](auto &mod, auto &cls) {
                cls.def(py::init<double, double, double>(), "sigma1"_a, "sigma2"_a = 0, "ampl"_a = 0);
 
                cls.def("__call__", &DoubleGaussianFunction2<ReturnT>::operator(), "x"_a, "y"_a);
                cls.def("clone", &DoubleGaussianFunction2<ReturnT>::clone);
                cls.def("toString", &DoubleGaussianFunction2<ReturnT>::toString, "prefix"_a = "");
                cls.def("isPersistable", &DoubleGaussianFunction2<ReturnT>::isPersistable);
            });
};

declareIntegerDeltaFunctions()

template<typename ReturnT >

void lsst::afw::math::declareIntegerDeltaFunctions	(	lsst::utils::python::WrapperCollection &	wrappers,
		const std::string &	suffix )

Definition at line 162 of file _functionLibrary.cc.

                                                           {
    /* IntegerDeltaFunction1 */
 
    wrappers.wrapType(
            py::class_<IntegerDeltaFunction1<ReturnT>, std::shared_ptr<IntegerDeltaFunction1<ReturnT>>,
                       Function1<ReturnT>>(wrappers.module, ("IntegerDeltaFunction1" + suffix).c_str()),
            [](auto &mod, auto &cls) {
                cls.def(py::init<double>(), "xo"_a);
 
                cls.def("__call__", &IntegerDeltaFunction1<ReturnT>::operator(), "x"_a);
                cls.def("clone", &IntegerDeltaFunction1<ReturnT>::clone);
                cls.def("toString", &IntegerDeltaFunction1<ReturnT>::toString, "prefix"_a = "");
            });
    /* IntegerDeltaFunction2 */
 
    wrappers.wrapType(
            py::class_<IntegerDeltaFunction2<ReturnT>, std::shared_ptr<IntegerDeltaFunction2<ReturnT>>,
                       Function2<ReturnT>>(wrappers.module, ("IntegerDeltaFunction2" + suffix).c_str()),
            [](auto &mod, auto &cls) {
                cls.def(py::init<double, double>(), "xo"_a, "yo"_a);
 
                cls.def("__call__", &IntegerDeltaFunction2<ReturnT>::operator(), "x"_a, "y"_a);
                cls.def("clone", &IntegerDeltaFunction2<ReturnT>::clone);
                cls.def("toString", &IntegerDeltaFunction2<ReturnT>::toString, "prefix"_a = "");
            });
};

declareLanczosFunctions()

template<typename ReturnT >

void lsst::afw::math::declareLanczosFunctions	(	lsst::utils::python::WrapperCollection &	wrappers,
		const std::string &	suffix )

Definition at line 191 of file _functionLibrary.cc.

                                                                                                  {
    /* LanczosFunction1 */
 
    wrappers.wrapType(py::class_<LanczosFunction1<ReturnT>, std::shared_ptr<LanczosFunction1<ReturnT>>,
                                 Function1<ReturnT>>(wrappers.module, ("LanczosFunction1" + suffix).c_str()),
                      [](auto &mod, auto &cls) {
                          cls.def(py::init<unsigned int, double>(), "n"_a, "xOffset"_a = 0.0);
 
                          cls.def("__call__", &LanczosFunction1<ReturnT>::operator(), "x"_a);
                          cls.def("clone", &LanczosFunction1<ReturnT>::clone);
                          cls.def("getOrder", &LanczosFunction1<ReturnT>::getOrder);
                          cls.def("toString", &LanczosFunction1<ReturnT>::toString, "prefix"_a = "");
                      });
    /* LanczosFunction2 */
 
    wrappers.wrapType(py::class_<LanczosFunction2<ReturnT>, std::shared_ptr<LanczosFunction2<ReturnT>>,
                                 Function2<ReturnT>>(wrappers.module, ("LanczosFunction2" + suffix).c_str()),
                      [](auto &mod, auto &cls) {
                          /* LanczosFunction2 */
                          cls.def(py::init<unsigned int, double, double>(), "n"_a, "xOffset"_a = 0.0,
                                  "yOffset"_a = 0.0);
 
                          cls.def("__call__", &LanczosFunction2<ReturnT>::operator(), "x"_a, "y"_a);
                          cls.def("clone", &LanczosFunction2<ReturnT>::clone);
                          cls.def("getOrder", &LanczosFunction2<ReturnT>::getOrder);
                          cls.def("toString", &LanczosFunction2<ReturnT>::toString, "prefix"_a = "");
                      });
};

declarePolynomialFunctions()

template<typename ReturnT >

void lsst::afw::math::declarePolynomialFunctions	(	lsst::utils::python::WrapperCollection &	wrappers,
		const std::string &	suffix )

Definition at line 45 of file _functionLibrary.cc.

                                                                                                     {
    /* PolynomialFunction1 */
 
    wrappers.wrapType(
            py::class_<PolynomialFunction1<ReturnT>, std::shared_ptr<PolynomialFunction1<ReturnT>>,
                       Function1<ReturnT>>(wrappers.module, ("PolynomialFunction1" + suffix).c_str()),
            [](auto &mod, auto &cls) {
                cls.def(py::init<std::vector<double> const &>(), "params"_a);
                cls.def(py::init<unsigned int>(), "order"_a);
 
                cls.def("__call__", &PolynomialFunction1<ReturnT>::operator(), "x"_a);
                cls.def("clone", &PolynomialFunction1<ReturnT>::clone);
                cls.def("isLinearCombination", &PolynomialFunction1<ReturnT>::isLinearCombination);
                cls.def("getOrder", &PolynomialFunction1<ReturnT>::getOrder);
                cls.def("toString", &PolynomialFunction1<ReturnT>::toString, "prefix"_a = "");
            });
    /* PolynomialFunction2 */
    wrappers.wrapType(py::class_<PolynomialFunction2<ReturnT>, std::shared_ptr<PolynomialFunction2<ReturnT>>,
                                 BasePolynomialFunction2<ReturnT>>(wrappers.module,
                                                                   ("PolynomialFunction2" + suffix).c_str()),
                      [](auto &mod, auto &cls) {
                          cls.def(py::init<std::vector<double> const &>(), "params"_a);
                          cls.def(py::init<unsigned int>(), "order"_a);
 
                          cls.def("__call__", &PolynomialFunction2<ReturnT>::operator(), "x"_a, "y"_a);
                          cls.def("clone", &PolynomialFunction2<ReturnT>::clone);
                          cls.def("getOrder", &PolynomialFunction2<ReturnT>::getOrder);
                          cls.def("getDFuncDParameters", &PolynomialFunction2<ReturnT>::getDFuncDParameters);
                          cls.def("toString", &PolynomialFunction2<ReturnT>::toString, "prefix"_a = "");
                          cls.def("isPersistable", &PolynomialFunction2<ReturnT>::isPersistable);
                      });
};

declareRandom()

void lsst::afw::math::declareRandom

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 52 of file _random.cc.

                                                               {
    auto clsRandom = wrappers.wrapType(py::class_<Random>(wrappers.module, "Random"), [](auto &mod,
                                                                                         auto &cls) {
        /* Constructors */
        cls.def(py::init<Random::Algorithm, unsigned long>(), "algorithm"_a = Random::Algorithm::MT19937,
                "seed"_a = 1);
        cls.def(py::init<std::string const &, unsigned long>(), "algorithm"_a, "seed"_a = 1);
 
        /* Members */
        cls.def("deepCopy", &Random::deepCopy);
        cls.def("getAlgorithm", &Random::getAlgorithm);
        cls.def("getAlgorithmName", &Random::getAlgorithmName);
        cls.def_static("getAlgorithmNames", &Random::getAlgorithmNames);
        cls.def("getSeed", &Random::getSeed);
        cls.def("uniform", &Random::uniform);
        cls.def("uniformPos", &Random::uniformPos);
        cls.def("uniformInt", &Random::uniformInt);
        cls.def("flat", &Random::flat);
        cls.def("gaussian", &Random::gaussian);
        cls.def("chisq", &Random::chisq);
        cls.def("poisson", &Random::poisson);
 
        // getState and setState are special, their std::string cannot
        // be converted to a Python string (needs to go to bytes instead)
        // thus use the same solution as employed with Swig
        cls.def("getState", [](Random &self) -> py::object {
            std::string state = self.getState();
            return py::reinterpret_steal<py::object>(PyBytes_FromStringAndSize(state.data(), state.size()));
        });
        cls.def("setState", [](Random &self, py::bytes const &state) { self.setState(state); });
    });
    /* Member types and enums */
    wrappers.wrapType(py::enum_<Random::Algorithm>(clsRandom, "Algorithm"), [](auto &mod, auto &enm) {
        enm.value("MT19937", Random::Algorithm::MT19937);
        enm.value("RANLXS0", Random::Algorithm::RANLXS0);
        enm.value("RANLXS1", Random::Algorithm::RANLXS1);
        enm.value("RANLXS2", Random::Algorithm::RANLXS2);
        enm.value("RANLXD1", Random::Algorithm::RANLXD1);
        enm.value("RANLXD2", Random::Algorithm::RANLXD2);
        enm.value("RANLUX", Random::Algorithm::RANLUX);
        enm.value("RANLUX389", Random::Algorithm::RANLUX389);
        enm.value("CMRG", Random::Algorithm::CMRG);
        enm.value("MRG", Random::Algorithm::MRG);
        enm.value("TAUS", Random::Algorithm::TAUS);
        enm.value("TAUS2", Random::Algorithm::TAUS2);
        enm.value("GFSR4", Random::Algorithm::GFSR4);
        enm.value("NUM_ALGORITHMS", Random::Algorithm::NUM_ALGORITHMS);
        enm.export_values();
    });
}

declareRandomImage()

template<typename ImageT >

void lsst::afw::math::declareRandomImage

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 38 of file _random.cc.

                                                                    {
    wrappers.wrap([](auto &mod) {
        mod.def("randomUniformImage", (void (*)(ImageT *, Random &))randomUniformImage<ImageT>);
        mod.def("randomUniformPosImage", (void (*)(ImageT *, Random &))randomUniformPosImage<ImageT>);
        mod.def("randomUniformIntImage",
                (void (*)(ImageT *, Random &, unsigned long))randomUniformIntImage<ImageT>);
        mod.def("randomFlatImage",
                (void (*)(ImageT *, Random &, double const, double const))randomFlatImage<ImageT>);
        mod.def("randomGaussianImage", (void (*)(ImageT *, Random &))randomGaussianImage<ImageT>);
        mod.def("randomChisqImage", (void (*)(ImageT *, Random &, double const))randomChisqImage<ImageT>);
        mod.def("randomPoissonImage", (void (*)(ImageT *, Random &, double const))randomPoissonImage<ImageT>);
    });
}

declareStatistics() [1/2]

template<typename Pixel >

void lsst::afw::math::declareStatistics

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 37 of file _statistics.cc.

                                                                   {
    wrappers.wrap([](auto &mod) {
        mod.def("makeStatistics",
                (Statistics(*)(image::Image<Pixel> const &, image::Mask<image::MaskPixel> const &, int const,
                               StatisticsControl const &))makeStatistics<Pixel>,
                "img"_a, "msk"_a, "flags"_a, "sctrl"_a = StatisticsControl());
        mod.def("makeStatistics",
                (Statistics(*)(image::MaskedImage<Pixel> const &, int const,
                               StatisticsControl const &))makeStatistics<Pixel>,
                "mimg"_a, "flags"_a, "sctrl"_a = StatisticsControl());
        mod.def("makeStatistics",
                (Statistics(*)(image::MaskedImage<Pixel> const &, image::Image<WeightPixel> const &,
                               int const, StatisticsControl const &))makeStatistics<Pixel>,
                "mimg"_a, "weights"_a, "flags"_a, "sctrl"_a = StatisticsControl());
        mod.def("makeStatistics",
                (Statistics(*)(image::Mask<image::MaskPixel> const &, int const, StatisticsControl const &))
                        makeStatistics,  // this is not a template, just a regular overload
                "msk"_a, "flags"_a, "sctrl"_a = StatisticsControl());
        mod.def("makeStatistics",
                (Statistics(*)(image::Image<Pixel> const &, int const,
                               StatisticsControl const &))makeStatistics<Pixel>,
                "img"_a, "flags"_a, "sctrl"_a = StatisticsControl());
    });
}

declareStatistics() [2/2]

void lsst::afw::math::declareStatistics

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 76 of file _statistics.cc.

                                                                   {
    /* Module level */
    wrappers.wrapType(py::enum_<Property>(wrappers.module, "Property", py::arithmetic()),
                      [](auto &mod, auto &enm) {
                          enm.value("NOTHING", Property::NOTHING);
                          enm.value("ERRORS", Property::ERRORS);
                          enm.value("NPOINT", Property::NPOINT);
                          enm.value("MEAN", Property::MEAN);
                          enm.value("STDEV", Property::STDEV);
                          enm.value("VARIANCE", Property::VARIANCE);
                          enm.value("MEDIAN", Property::MEDIAN);
                          enm.value("IQRANGE", Property::IQRANGE);
                          enm.value("MEANCLIP", Property::MEANCLIP);
                          enm.value("STDEVCLIP", Property::STDEVCLIP);
                          enm.value("VARIANCECLIP", Property::VARIANCECLIP);
                          enm.value("MIN", Property::MIN);
                          enm.value("MAX", Property::MAX);
                          enm.value("SUM", Property::SUM);
                          enm.value("MEANSQUARE", Property::MEANSQUARE);
                          enm.value("ORMASK", Property::ORMASK);
                          enm.value("NCLIPPED", Property::NCLIPPED);
                          enm.value("NMASKED", Property::NMASKED);
                          enm.export_values();
                      });
 
    wrappers.wrap([](auto &mod) { mod.def("stringToStatisticsProperty", stringToStatisticsProperty); });
 
    using PyClass = py::class_<StatisticsControl, std::shared_ptr<StatisticsControl>>;
    auto control = wrappers.wrapType(PyClass(wrappers.module, "StatisticsControl"), [](auto &mod, auto &cls) {
        cls.def(py::init<double, int, lsst::afw::image::MaskPixel, bool,
                         typename StatisticsControl::WeightsBoolean>(),
                "numSigmaClip"_a = 3.0, "numIter"_a = 3, "andMask"_a = 0x0, "isNanSafe"_a = true,
                "useWeights"_a = StatisticsControl::WEIGHTS_NONE);
 
        cls.def("getMaskPropagationThreshold", &StatisticsControl::getMaskPropagationThreshold);
        cls.def("setMaskPropagationThreshold", &StatisticsControl::setMaskPropagationThreshold);
        cls.def("getNumSigmaClip", &StatisticsControl::getNumSigmaClip);
        cls.def("getNumIter", &StatisticsControl::getNumIter);
        cls.def("getAndMask", &StatisticsControl::getAndMask);
        cls.def("getNoGoodPixelsMask", &StatisticsControl::getNoGoodPixelsMask);
        cls.def("getNanSafe", &StatisticsControl::getNanSafe);
        cls.def("getWeighted", &StatisticsControl::getWeighted);
        cls.def("getWeightedIsSet", &StatisticsControl::getWeightedIsSet);
        cls.def("getCalcErrorFromInputVariance", &StatisticsControl::getCalcErrorFromInputVariance);
        cls.def("getCalcErrorMosaicMode", &StatisticsControl::getCalcErrorMosaicMode);
        cls.def("setNumSigmaClip", &StatisticsControl::setNumSigmaClip);
        cls.def("setNumIter", &StatisticsControl::setNumIter);
        cls.def("setAndMask", &StatisticsControl::setAndMask);
        cls.def("setNoGoodPixelsMask", &StatisticsControl::setNoGoodPixelsMask);
        cls.def("setNanSafe", &StatisticsControl::setNanSafe);
        cls.def("setWeighted", &StatisticsControl::setWeighted);
        cls.def("setCalcErrorFromInputVariance", &StatisticsControl::setCalcErrorFromInputVariance);
        cls.def("setCalcErrorMosaicMode", &StatisticsControl::setCalcErrorMosaicMode);
    });
 
    wrappers.wrapType(py::enum_<StatisticsControl::WeightsBoolean>(control, "WeightsBoolean"),
                      [](auto &mod, auto &enm) {
                          enm.value("WEIGHTS_FALSE", StatisticsControl::WeightsBoolean::WEIGHTS_FALSE);
                          enm.value("WEIGHTS_TRUE", StatisticsControl::WeightsBoolean::WEIGHTS_TRUE);
                          enm.value("WEIGHTS_NONE", StatisticsControl::WeightsBoolean::WEIGHTS_NONE);
                          enm.export_values();
                      });
 
    wrappers.wrapType(py::class_<Statistics>(wrappers.module, "Statistics"), [](auto &mod, auto &cls) {
        cls.def("getResult", &Statistics::getResult, "prop"_a = Property::NOTHING);
        cls.def("getError", &Statistics::getError, "prop"_a = Property::NOTHING);
        cls.def("getValue", &Statistics::getValue, "prop"_a = Property::NOTHING);
        cls.def("getOrMask", &Statistics::getOrMask);
    });
}

declareStatisticsVectorOverloads()

template<typename Pixel >

void lsst::afw::math::declareStatisticsVectorOverloads

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 63 of file _statistics.cc.

                                                                                  {
    wrappers.wrap([](auto &mod) {
        mod.def("makeStatistics",
                (Statistics(*)(std::vector<Pixel> const &, int const,
                               StatisticsControl const &))makeStatistics<Pixel>,
                "v"_a, "flags"_a, "sctrl"_a = StatisticsControl());
        mod.def("makeStatistics",
                (Statistics(*)(std::vector<Pixel> const &, std::vector<WeightPixel> const &, int const,
                               StatisticsControl const &))makeStatistics<Pixel>,
                "v"_a, "vweights"_a, "flags"_a, "sctrl"_a = StatisticsControl());
    });
}

declareTransformBoundedField()

void lsst::afw::math::declareTransformBoundedField

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 44 of file _transformBoundedField.cc.

                                                                              {
    wrappers.wrapType(ClsField(wrappers.module, "TransformBoundedField"), [](auto &mod, auto &cls) {
        cls.def(py::init<lsst::geom::Box2I const &, TransformBoundedField::Transform const &>(), "bbox"_a,
                "transform"_a);
 
        table::io::python::addPersistableMethods<TransformBoundedField>(cls);
 
        cls.def("__mul__", &TransformBoundedField::operator*, py::is_operator());
        cls.def("__eq__", &TransformBoundedField::operator==, py::is_operator());
 
        cls.def("getTransform", &TransformBoundedField::getTransform);
        cls.def("evaluate", (double (BoundedField::*)(double, double) const) & BoundedField::evaluate);
        cls.def("evaluate", (ndarray::Array<double, 1, 1>(TransformBoundedField::*)(
                                    ndarray::Array<double const, 1> const &,
                                    ndarray::Array<double const, 1> const &) const) &
                                    TransformBoundedField::evaluate);
        cls.def("evaluate", (double (TransformBoundedField::*)(lsst::geom::Point2D const &) const) &
                                    TransformBoundedField::evaluate);
    });
}

edgePixel() [1/2]

template<typename ImageT >

ImageT::SinglePixel lsst::afw::math::edgePixel

(

lsst::afw::image::detail::Image_tag

)

Return an off-the-edge pixel appropriate for a given Image type.

The value is quiet_NaN if that exists for the pixel type, else 0

Definition at line 198 of file ConvolveImage.h.

  {
    using SinglePixelT = typename ImageT::SinglePixel;
    return SinglePixelT(std::numeric_limits<SinglePixelT>::has_quiet_NaN
                                ? std::numeric_limits<SinglePixelT>::quiet_NaN()
                                : 0);
}

edgePixel() [2/2]

template<typename MaskedImageT >

MaskedImageT::SinglePixel lsst::afw::math::edgePixel

(

lsst::afw::image::detail::MaskedImage_tag

)

Return an off-the-edge pixel appropriate for a given MaskedImage type.

The components are:

• image = quiet_NaN if that exists for the pixel type, else 0
• mask = NO_DATA bit set
• variance = infinity if that exists for the pixel type, else 0

Exceptions

lsst::pex::exceptions::LogicError

Thrown if the global mask plane dictionary does not have a NO_DATA bit.

Definition at line 219 of file ConvolveImage.h.

  {
    using ImagePixelT = typename MaskedImageT::Image::Pixel;
    using VariancePixelT = typename MaskedImageT::Variance::Pixel;
 
    auto imagePixel = std::numeric_limits<ImagePixelT>::has_quiet_NaN
                              ? std::numeric_limits<ImagePixelT>::quiet_NaN()
                              : 0;
    auto maskPixel = MaskedImageT::Mask::getPlaneBitMask("NO_DATA");
    auto variancePixel = std::numeric_limits<VariancePixelT>::has_infinity
                                 ? std::numeric_limits<VariancePixelT>::infinity()
                                 : 0;
    return typename MaskedImageT::SinglePixel(imagePixel, maskPixel, variancePixel);
}

flipImage()

template<typename ImageT >

std::shared_ptr< ImageT > lsst::afw::math::flipImage	(	ImageT const &	inImage,
		bool	flipLR,
		bool	flipTB )

Flip an image left–right and/or top–bottom.

Parameters

inImage	The image to flip
flipLR	Flip left <--> right?
flipTB	Flip top <--> bottom?

Definition at line 92 of file rotateImage.cc.

                                                                                 {
    std::shared_ptr<ImageT> outImage(new ImageT(inImage, true));  // Output image
 
    if (flipLR) {
        if (flipTB) {
            for (int y = 0; y != inImage.getHeight(); ++y) {
                typename ImageT::x_iterator optr =
                        outImage->x_at(inImage.getWidth() - 1, inImage.getHeight() - y - 1);
                for (typename ImageT::x_iterator iptr = inImage.row_begin(y), end = inImage.row_end(y);
                     iptr != end; ++iptr, optr -= 1) {
                    *optr = *iptr;
                }
            }
        } else {
            for (int y = 0; y != inImage.getHeight(); ++y) {
                typename ImageT::x_iterator optr = outImage->x_at(inImage.getWidth() - 1, y);
                for (typename ImageT::x_iterator iptr = inImage.row_begin(y), end = inImage.row_end(y);
                     iptr != end; ++iptr, optr -= 1) {
                    *optr = *iptr;
                }
            }
        }
    } else {
        if (flipTB) {
            for (int y = 0; y != inImage.getHeight(); ++y) {
                typename ImageT::x_iterator optr = outImage->row_begin(inImage.getHeight() - y - 1);
                for (typename ImageT::x_iterator iptr = inImage.row_begin(y), end = inImage.row_end(y);
                     iptr != end; ++iptr, ++optr) {
                    *optr = *iptr;
                }
            }
        } else {
            ;  // nothing to do
        }
    }
 
    return outImage;
}

int1d()

template<typename UnaryFunctionT , typename Arg >

Arg lsst::afw::math::int1d ( UnaryFunctionT func, IntRegion< Arg > & reg, Arg const & abserr = DEFABSERR, Arg const & relerr = DEFRELERR )

inline

Front end for the 1d integrator.

Definition at line 704 of file Integrate.h.

                                                     {
    using namespace details;
 
    integ_dbg2 << "start int1d: " << reg.Left() << ".." << reg.Right() << std::endl;
 
    if ((reg.Left() <= -MOCK_INF && reg.Right() > 0) || (reg.Right() >= MOCK_INF && reg.Left() < 0)) {
        reg.AddSplit(0);
    }
 
    if (reg.NSplit() > 0) {
        std::vector<IntRegion<Arg> > children;
        reg.SubDivide(&children);
        integ_dbg2 << "Subdivided into " << children.size() << " children\n";
        Arg answer = Arg();
        Arg err = 0;
        for (size_t i = 0; i < children.size(); i++) {
            IntRegion<Arg> &child = children[i];
            integ_dbg2 << "i = " << i;
            integ_dbg2 << ": bounds = " << child.Left() << ", " << child.Right() << std::endl;
            answer += int1d(func, child, abserr, relerr);
            err += child.Err();
            integ_dbg2 << "subint = " << child.Area() << " +- " << child.Err() << std::endl;
        }
        reg.SetArea(answer, err);
        return answer;
 
    } else {
        if (reg.Left() <= -MOCK_INF) {
            integ_dbg2 << "left = -infinity, right = " << reg.Right() << std::endl;
            assert(reg.Right() <= 0.0);
            IntRegion<Arg> modreg(1.0 / (reg.Right() - 1.0), 0.0, reg.getDbgout());
            intGKP(Aux2<UnaryFunctionT>(func), modreg, abserr, relerr);
            reg.SetArea(modreg.Area(), modreg.Err());
        } else if (reg.Right() >= MOCK_INF) {
            integ_dbg2 << "left = " << reg.Left() << ", right = infinity\n";
            assert(reg.Left() >= 0.0);
            IntRegion<Arg> modreg(0.0, 1.0 / (reg.Left() + 1.0), reg.getDbgout());
            intGKP(Aux1<UnaryFunctionT>(func), modreg, abserr, relerr);
            reg.SetArea(modreg.Area(), modreg.Err());
        } else {
            integ_dbg2 << "left = " << reg.Left();
            integ_dbg2 << ", right = " << reg.Right() << std::endl;
            intGKP(func, reg, abserr, relerr);
        }
        integ_dbg2 << "done int1d  answer = " << reg.Area();
        integ_dbg2 << " +- " << reg.Err() << std::endl;
        return reg.Area();
    }
}

integrate()

template<typename UnaryFunctionT , typename Arg >

auto lsst::afw::math::integrate	(	UnaryFunctionT	func,
		Arg const	a,
		Arg const	b,
		double	eps = 1.0e-6 )

The 1D integrator.

Note

This simply wraps the int1d function above and handles the instantiation of the intRegion.

Definition at line 765 of file Integrate.h.

                                    {
    IntRegion<Arg> region(a, b);
    return int1d(func, region, DEFABSERR, eps);
}

integrate2d()

template<typename BinaryFunctionT , typename X , typename Y >

auto lsst::afw::math::integrate2d	(	BinaryFunctionT	func,
		X	x1,
		X	x2,
		Y	y1,
		Y	y2,
		double	eps = 1.0e-6 )

The 2D integrator.

Definition at line 779 of file Integrate.h.

                                                                                    {
    auto outer = [func, x1, x2, eps](auto y) {
        auto inner = [func, y](auto x) { return func(x, y); };
        return integrate(inner, x1, x2, eps);
    };
    return integrate(outer, y1, y2, eps);
}

integrateTn()

double lsst::afw::math::integrateTn

(

int

n

)

Definition at line 289 of file ChebyshevBoundedField.cc.

                          {
    if (n % 2 == 1)
        return 0;
    else
        return 2.0 / (1.0 - double(n * n));
}

lookupMaxInterpStyle()

Interpolate::Style lsst::afw::math::lookupMaxInterpStyle

(

int const

n

)

Get the highest order Interpolation::Style available for 'n' points.

Parameters

n	Number of points

Definition at line 279 of file Interpolate.cc.

                                                   {
    if (n < 1) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "n must be greater than 0");
    } else if (n > 4) {
        return Interpolate::AKIMA_SPLINE;
    } else {
        static std::vector<Interpolate::Style> styles;
        if (styles.empty()) {
            styles.resize(5);
 
            styles[0] = Interpolate::UNKNOWN;  // impossible to reach as we check for n < 1
            styles[1] = Interpolate::CONSTANT;
            styles[2] = Interpolate::LINEAR;
            styles[3] = Interpolate::CUBIC_SPLINE;
            styles[4] = Interpolate::CUBIC_SPLINE;
        }
        return styles[n];
    }
}

lookupMinInterpPoints()

int lsst::afw::math::lookupMinInterpPoints

(

Interpolate::Style const

style

)

Get the minimum number of points needed to use the requested interpolation style.

Parameters

style

The style in question

Definition at line 318 of file Interpolate.cc.

                                                        {
    static std::vector<int> minPoints;
    if (minPoints.empty()) {
        minPoints.resize(Interpolate::NUM_STYLES);
        minPoints[Interpolate::CONSTANT] = 1;
        minPoints[Interpolate::LINEAR] = 2;
        minPoints[Interpolate::NATURAL_SPLINE] = 3;
        minPoints[Interpolate::CUBIC_SPLINE] = 3;
        minPoints[Interpolate::CUBIC_SPLINE_PERIODIC] = 3;
        minPoints[Interpolate::AKIMA_SPLINE] = 5;
        minPoints[Interpolate::AKIMA_SPLINE_PERIODIC] = 5;
    }
 
    if (style >= 0 && style < Interpolate::NUM_STYLES) {
        return minPoints[style];
    } else {
        throw LSST_EXCEPT(
                pex::exceptions::OutOfRangeError,
                str(boost::format("Style %d is out of range 0..%d") % style % (Interpolate::NUM_STYLES - 1)));
    }
}

makeApproximate()

template<typename PixelT >

std::shared_ptr< Approximate< PixelT > > lsst::afw::math::makeApproximate	(	std::vector< double > const &	x,
		std::vector< double > const &	y,
		image::MaskedImage< PixelT > const &	im,
		lsst::geom::Box2I const &	bbox,
		ApproximateControl const &	ctrl )

Construct a new Approximate object, inferring the type from the type of the given MaskedImage.

Parameters

x	the x-values of points
y	the y-values of points
im	The values at (x, y)
bbox	Range where approximation should be valid
ctrl	desired approximation algorithm

Definition at line 279 of file Approximate.cc.

                                                                                     {
    switch (ctrl.getStyle()) {
        case ApproximateControl::CHEBYSHEV:
            return std::shared_ptr<Approximate<PixelT>>(
                    new ApproximateChebyshev<PixelT>(x, y, im, bbox, ctrl));
        default:
            throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                              str(boost::format("Unknown ApproximationStyle: %d") % ctrl.getStyle()));
    }
}

makeBackground()

template<typename ImageT >

std::shared_ptr< Background > lsst::afw::math::makeBackground	(	ImageT const &	img,
		BackgroundControl const &	bgCtrl )

A convenience function that uses function overloading to make the correct type of Background.

cf. std::make_pair()

Definition at line 526 of file Background.h.

                                                                                             {
    return std::shared_ptr<Background>(new BackgroundMI(img, bgCtrl));
}

makeInterpolate() [1/2]

std::shared_ptr< Interpolate > lsst::afw::math::makeInterpolate	(	ndarray::Array< double const, 1 > const &	x,
		ndarray::Array< double const, 1 > const &	y,
		Interpolate::Style const	style = Interpolate::AKIMA_SPLINE )

Definition at line 357 of file Interpolate.cc.

                                                                           {
    return makeInterpolate(std::vector<double>(x.begin(), x.end()), std::vector<double>(y.begin(), y.end()),
                           style);
}

makeInterpolate() [2/2]

std::shared_ptr< Interpolate > lsst::afw::math::makeInterpolate	(	std::vector< double > const &	x,
		std::vector< double > const &	y,
		Interpolate::Style const	style = Interpolate::AKIMA_SPLINE )

A factory function to make Interpolate objects.

Parameters

x	the x-values of points
y	the values at x[]
style	desired interpolator

Definition at line 347 of file Interpolate.cc.

                                                                           {
    switch (style) {
        case Interpolate::CONSTANT:
            return std::shared_ptr<Interpolate>(new InterpolateConstant(x, y, style));
        default:  // use GSL
            return std::shared_ptr<Interpolate>(new InterpolateGsl(x, y, style));
    }
}

makeStatistics() [1/10]

template<typename ImageT , typename MaskT , typename VarianceT >

Statistics makeStatistics	(	ImageT const &	img,
		MaskT const &	msk,
		VarianceT const &	var,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

Handle a straight front-end to the constructor.

Definition at line 373 of file Statistics.h.

                                                                                {
    return Statistics(img, msk, var, flags, sctrl);
}

makeStatistics() [2/10]

template<typename Pixel >

Statistics makeStatistics	(	lsst::afw::image::Image< Pixel > const &	img,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

The makeStatistics() overload to handle regular (non-masked) Images.

Parameters

img	Image (or Image) whose properties we want
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 427 of file Statistics.h.

  {
    // make a phony mask that will be compiled out
    MaskImposter<lsst::afw::image::MaskPixel> const msk;
    MaskImposter<WeightPixel> const var;
    return Statistics(img, msk, var, flags, sctrl);
}

makeStatistics() [3/10]

template<typename Pixel >

Statistics makeStatistics	(	lsst::afw::image::Image< Pixel > const &	img,
		lsst::afw::image::Mask< image::MaskPixel > const &	msk,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

Handle a watered-down front-end to the constructor (no variance)

Definition at line 361 of file Statistics.h.

                                                                                {
    MaskImposter<WeightPixel> var;
    return Statistics(img, msk, var, flags, sctrl);
}

makeStatistics() [4/10]

Statistics lsst::afw::math::makeStatistics	(	lsst::afw::image::Mask< lsst::afw::image::MaskPixel > const &	msk,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

Specialization to handle Masks.

Parameters

msk	Image (or MaskedImage) whose properties we want
flags	Describe what we want to calculate
sctrl	Control how things are calculated

Definition at line 1136 of file Statistics.cc.

                                                          {
    return Statistics(msk, msk, msk, flags, sctrl);
}

makeStatistics() [5/10]

template<typename Pixel >

Statistics makeStatistics	(	lsst::afw::image::MaskedImage< Pixel > const &	mimg,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

Handle MaskedImages, just pass the getImage() and getMask() values right on through.

Definition at line 383 of file Statistics.h.

                                                                                {
    if (sctrl.getWeighted() || sctrl.getCalcErrorFromInputVariance() || sctrl.getCalcErrorMosaicMode()) {
        return Statistics(*mimg.getImage(), *mimg.getMask(), *mimg.getVariance(), flags, sctrl);
    } else {
        MaskImposter<WeightPixel> var;
        return Statistics(*mimg.getImage(), *mimg.getMask(), var, flags, sctrl);
    }
}

makeStatistics() [6/10]

template<typename Pixel >

Statistics makeStatistics	(	lsst::afw::image::MaskedImage< Pixel > const &	mimg,
		lsst::afw::image::Image< WeightPixel > const &	weights,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

Handle MaskedImages, just pass the getImage() and getMask() values right on through.

Definition at line 398 of file Statistics.h.

                                                                                {
    if (sctrl.getWeighted() || sctrl.getCalcErrorFromInputVariance() || sctrl.getCalcErrorMosaicMode() ||
        (!sctrl.getWeightedIsSet() && (weights.getWidth() != 0 && weights.getHeight() != 0))) {
        return Statistics(*mimg.getImage(), *mimg.getMask(), *mimg.getVariance(), weights, flags, sctrl);
    } else {
        MaskImposter<WeightPixel> var;
        return Statistics(*mimg.getImage(), *mimg.getMask(), var, weights, flags, sctrl);
    }
}

makeStatistics() [7/10]

template<typename EntryT >

Statistics makeStatistics	(	lsst::afw::math::MaskedVector< EntryT > const &	mv,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

The makeStatistics() overload to handle lsst::afw::math::MaskedVector<>

Parameters

mv	MaskedVector
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 510 of file Statistics.h.

  {
    if (sctrl.getWeighted() || sctrl.getCalcErrorFromInputVariance() || sctrl.getCalcErrorMosaicMode()) {
        return Statistics(*mv.getImage(), *mv.getMask(), *mv.getVariance(), flags, sctrl);
    } else {
        MaskImposter<WeightPixel> var;
        return Statistics(*mv.getImage(), *mv.getMask(), var, flags, sctrl);
    }
}

makeStatistics() [8/10]

template<typename EntryT >

Statistics makeStatistics	(	lsst::afw::math::MaskedVector< EntryT > const &	mv,
		std::vector< WeightPixel > const &	vweights,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

The makeStatistics() overload to handle lsst::afw::math::MaskedVector<>

Parameters

mv	MaskedVector
vweights	weights
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 527 of file Statistics.h.

  {
    ImageImposter<WeightPixel> weights(vweights);
 
    if (sctrl.getWeighted() || sctrl.getCalcErrorFromInputVariance() || sctrl.getCalcErrorMosaicMode()) {
        return Statistics(*mv.getImage(), *mv.getMask(), *mv.getVariance(), weights, flags, sctrl);
    } else {
        MaskImposter<WeightPixel> var;
        return Statistics(*mv.getImage(), *mv.getMask(), var, weights, flags, sctrl);
    }
}

makeStatistics() [9/10]

template<typename EntryT >

Statistics makeStatistics	(	std::vector< EntryT > const &	v,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

The makeStatistics() overload to handle std::vector<>

Parameters

v	Image (or MaskedImage) whose properties we want
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 476 of file Statistics.h.

  {
    ImageImposter<EntryT> img(v);                   // wrap the vector in a fake image
    MaskImposter<lsst::afw::image::MaskPixel> msk;  // instantiate a fake mask that will be compiled out.
    MaskImposter<WeightPixel> var;
    return Statistics(img, msk, var, flags, sctrl);
}

makeStatistics() [10/10]

template<typename EntryT >

Statistics makeStatistics	(	std::vector< EntryT > const &	v,
		std::vector< WeightPixel > const &	vweights,
		int const	flags,
		StatisticsControl const &	sctrl = StatisticsControl() )

The makeStatistics() overload to handle std::vector<>

Parameters

v	Image (or MaskedImage) whose properties we want
vweights	Weights
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 491 of file Statistics.h.

  {
    ImageImposter<EntryT> img(v);                   // wrap the vector in a fake image
    MaskImposter<lsst::afw::image::MaskPixel> msk;  // instantiate a fake mask that will be compiled out.
    MaskImposter<WeightPixel> var;
 
    ImageImposter<WeightPixel> weights(vweights);
 
    return Statistics(img, msk, var, weights, flags, sctrl);
}

makeWarpingKernel()

std::shared_ptr< SeparableKernel > lsst::afw::math::makeWarpingKernel

(

std::string

name

)

Return a warping kernel given its name.

Intended for use with warpImage() and warpExposure().

Allowed names are:

• bilinear: return a BilinearWarpingKernel
• lanczos#: return a LanczosWarpingKernel of order #, e.g. lanczos4
• nearest: return a NearestWarpingKernel

A warping kernel is a subclass of SeparableKernel with the following properties (though for the sake of speed few, if any, of these are enforced):

• Width and height are even. This is unusual for a kernel, but it is more efficient because if the extra pixel was included it would always have value 0.
• The center pixels should be adjacent to the kernel center. Again, this avoids extra pixels that are sure to have value 0.
• It has two parameters: fractional x and fractional row position on the source image. The fractional position is the offset of the pixel position on the source from the center of a nearby source pixel:
  • The pixel whose center is just below or to the left of the source position: 0 <= fractional x and y < 0 and the kernel center is the default (size-1)/2.
  • The pixel whose center is just above or to the right of the source position: -1.0 < fractional x and y <= 0 and the kernel center must be set to (size+1)/2.

Definition at line 224 of file warpExposure.cc.

                                                                 {
    using KernelPtr = std::shared_ptr<SeparableKernel>;
    std::smatch matches;
    static const std::regex LanczosRE("lanczos(\\d+)");
    if (name == "bilinear") {
        return KernelPtr(new BilinearWarpingKernel());
    } else if (std::regex_match(name, matches, LanczosRE)) {
        std::string orderStr(matches[1].first, matches[1].second);
        int order = std::stoi(orderStr);
        return KernelPtr(new LanczosWarpingKernel(order));
    } else if (name == "nearest") {
        return KernelPtr(new NearestWarpingKernel());
    } else {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, "unknown warping kernel name: \"" + name + "\"");
    }
}

minimize() [1/2]

template<typename ReturnT >

FitResults lsst::afw::math::minimize	(	lsst::afw::math::Function1< ReturnT > const &	function,
		std::vector< double > const &	initialParameterList,
		std::vector< double > const &	stepSizeList,
		std::vector< double > const &	measurementList,
		std::vector< double > const &	varianceList,
		std::vector< double > const &	xPositionList,
		double	errorDef )

Find the minimum of a function(x)

Parameters

function	function(x) to be minimized
initialParameterList	initial guess for parameters
stepSizeList	step size for each parameter; use 0.0 to fix a parameter
measurementList	measured values
varianceList	variance for each measurement
xPositionList	x position of each measurement
errorDef	what is this?

Returns

true if minimum is valid, false otherwise

Uses the Minuit fitting package with a standard definition of chiSq (see MinimizerFunctionBase1).

Exceptions

lsst::pex::exceptions::InvalidParameterError

if any input vector is the wrong length

To do:

• Document stepSizeList better
• Document errorDef
• Compute stepSize automatically? (if so, find a different way to fix parameters)

Definition at line 176 of file minimize.cc.

                                     {
    unsigned int const nParameters = function.getNParameters();
    if (initialParameterList.size() != nParameters) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "initialParameterList is the wrong length");
    }
    if (stepSizeList.size() != nParameters) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "stepSizeList is the wrong length");
    }
    unsigned int const nMeasurements = measurementList.size();
    if (varianceList.size() != nMeasurements) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "varianceList is the wrong length");
    }
    if (xPositionList.size() != nMeasurements) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "xPositionList is the wrong length");
    }
 
    MinimizerFunctionBase1<ReturnT> minimizerFunc(function, measurementList, varianceList, xPositionList,
                                                  errorDef);
 
    ROOT::Minuit2::MnUserParameters fitPar;
    std::vector<std::string> paramNames;
    for (unsigned int i = 0; i < nParameters; ++i) {
        paramNames.push_back((boost::format("p%d") % i).str());
        fitPar.Add(paramNames[i].c_str(), initialParameterList[i], stepSizeList[i]);
    }
 
    ROOT::Minuit2::MnMigrad migrad(minimizerFunc, fitPar);
    ROOT::Minuit2::FunctionMinimum min = migrad();
    ROOT::Minuit2::MnMinos minos(minimizerFunc, min);
 
    FitResults fitResults;
    fitResults.chiSq = min.Fval();
    fitResults.isValid = min.IsValid() && std::isfinite(fitResults.chiSq);
    if (!fitResults.isValid) {
        LOGL_WARN("lsst.afw.math.minimize", "Fit failed to converge");
    }
 
    for (unsigned int i = 0; i < nParameters; ++i) {
        fitResults.parameterList.push_back(min.UserState().Value(paramNames[i].c_str()));
        if (fitResults.isValid) {
            fitResults.parameterErrorList.push_back(minos(i));
        } else {
            double e = min.UserState().Error(paramNames[i].c_str());
            std::pair<double, double> ep(-1 * e, e);
            fitResults.parameterErrorList.push_back(ep);
        }
    }
    return fitResults;
}

minimize() [2/2]

template<typename ReturnT >

FitResults lsst::afw::math::minimize	(	lsst::afw::math::Function2< ReturnT > const &	function,
		std::vector< double > const &	initialParameterList,
		std::vector< double > const &	stepSizeList,
		std::vector< double > const &	measurementList,
		std::vector< double > const &	varianceList,
		std::vector< double > const &	xPositionList,
		std::vector< double > const &	yPositionList,
		double	errorDef )

Find the minimum of a function(x, y)

Uses the Minuit fitting package with a standard definition of chiSq. (see MinimizerFunctionBase2).

Parameters

function	function(x,y) to be minimized
initialParameterList	initial guess for parameters
stepSizeList	step size for each parameter; use 0.0 to fix a parameter
measurementList	measured values
varianceList	variance for each measurement
xPositionList	x position of each measurement
yPositionList	y position of each measurement
errorDef	what is this?

Returns

true if minimum is valid, false otherwise

Exceptions

lsst::pex::exceptions::InvalidParameterError

if any input vector is the wrong length

To do:

• Document stepSizeList better
• Document errorDef
• Compute stepSize automatically? (if so, find a different way to fix parameters)

Definition at line 230 of file minimize.cc.

                                                                             {
    unsigned int const nParameters = function.getNParameters();
    if (initialParameterList.size() != nParameters) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "initialParameterList is the wrong length");
    }
    if (stepSizeList.size() != nParameters) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "stepSizeList is the wrong length");
    }
    unsigned int const nMeasurements = measurementList.size();
    if (varianceList.size() != nMeasurements) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "varianceList is the wrong length");
    }
    if (xPositionList.size() != nMeasurements) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "xPositionList is the wrong length");
    }
    if (yPositionList.size() != nMeasurements) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "yPositionList is the wrong length");
    }
 
    MinimizerFunctionBase2<ReturnT> minimizerFunc(function, measurementList, varianceList, xPositionList,
                                                  yPositionList, errorDef);
 
    ROOT::Minuit2::MnUserParameters fitPar;
    std::vector<std::string> paramNames;
    for (unsigned int i = 0; i < nParameters; ++i) {
        paramNames.push_back((boost::format("p%d") % i).str());
        fitPar.Add(paramNames[i].c_str(), initialParameterList[i], stepSizeList[i]);
    }
 
    ROOT::Minuit2::MnMigrad migrad(minimizerFunc, fitPar);
    ROOT::Minuit2::FunctionMinimum min = migrad();
    ROOT::Minuit2::MnMinos minos(minimizerFunc, min);
 
    FitResults fitResults;
    fitResults.chiSq = min.Fval();
    fitResults.isValid = min.IsValid() && std::isfinite(fitResults.chiSq);
    if (!fitResults.isValid) {
        LOGL_WARN("lsst.afw.math.minimize", "Fit failed to converge");
    }
 
    for (unsigned int i = 0; i < nParameters; ++i) {
        fitResults.parameterList.push_back(min.UserState().Value(paramNames[i].c_str()));
        if (fitResults.isValid) {
            fitResults.parameterErrorList.push_back(minos(i));
        } else {
            double e = min.UserState().Error(paramNames[i].c_str());
            std::pair<double, double> ep(-1 * e, e);
            fitResults.parameterErrorList.push_back(ep);
        }
    }
    return fitResults;
}

offsetImage()

template<typename ImageT >

std::shared_ptr< ImageT > lsst::afw::math::offsetImage	(	ImageT const &	image,
		float	dx,
		float	dy,
		std::string const &	algorithmName = "lanczos5",
		unsigned int	buffer = 0 )

Return an image offset by (dx, dy) using the specified algorithm.

Parameters

image	The image to offset
dx	move the image this far in the column direction
dy	move the image this far in the row direction
algorithmName	Type of resampling Kernel to use
buffer	Width of buffer (border) around kernel image to allow for warping edge effects (pixels). Values < 0 are treated as 0. This is only used during computation; the final image has the same dimensions as the kernel.

Note

The image pixels are always offset by a fraction of a pixel and the image origin (XY0) picks is modified to handle the integer portion of the offset. In the special case that the offset in both x and y lies in the range (-1, 1) the origin is not changed. Otherwise the pixels are shifted by (-0.5, 0.5] pixels and the origin shifted accordingly.

Exceptions

lsst::pex::exceptions::InvalidParameterError

if the algorithm is invalid

Definition at line 41 of file offsetImage.cc.

  {
    std::shared_ptr<SeparableKernel> offsetKernel = makeWarpingKernel(algorithmName);
 
    std::shared_ptr<ImageT> buffImage;
    if (buffer > 0) {
        // Paste input image into buffered image
        lsst::geom::Extent2I const& dims = inImage.getDimensions();
        std::shared_ptr<ImageT> buffered(new ImageT(dims.getX() + 2 * buffer, dims.getY() + 2 * buffer));
        buffImage = buffered;
        lsst::geom::Box2I box(lsst::geom::Point2I(buffer, buffer), dims);
        buffImage->assign(inImage, box);
    } else {
        buffImage = std::make_shared<ImageT>(inImage);
    }
 
    if (offsetKernel->getWidth() > buffImage->getWidth() ||
        offsetKernel->getHeight() > buffImage->getHeight()) {
        throw LSST_EXCEPT(pexExcept::LengthError,
                          (boost::format("Image of size %dx%d is too small to offset using a %s kernel"
                                         "(minimum %dx%d)") %
                           buffImage->getWidth() % buffImage->getHeight() % algorithmName %
                           offsetKernel->getWidth() % offsetKernel->getHeight())
                                  .str());
    }
 
    //    std::shared_ptr<ImageT> convImage(new ImageT(buffImage, true)); // output image, a deep copy
    std::shared_ptr<ImageT> convImage(new ImageT(buffImage->getDimensions()));  // Convolved image
 
    int dOrigX, dOrigY;
    double fracX, fracY;
    // If the offset in both axes is in (-1, 1) use it as is, and don't shift the origin
    if (dx > -1 && dx < 1 && dy > -1 && dy < 1) {
        dOrigX = 0;
        dOrigY = 0;
        fracX = dx;
        fracY = dy;
    } else {
        dOrigX = static_cast<int>(std::floor(dx + 0.5));
        dOrigY = static_cast<int>(std::floor(dy + 0.5));
        fracX = dx - dOrigX;
        fracY = dy - dOrigY;
    }
 
    // We seem to have to pass -fracX, -fracY to setKernelParameters, for reasons RHL doesn't understand
    double dKerX = -fracX;
    double dKerY = -fracY;
 
    //
    // If the shift is -ve, the generated shift kernel (e.g. Lanczos5) is quite asymmetric, with the
    // largest coefficients to the left of centre.  We therefore move the centre of calculated shift kernel
    // one to the right to center up the largest coefficients
    //
    if (dKerX < 0) {
        offsetKernel->setCtr(offsetKernel->getCtr() + lsst::geom::Extent2I(1, 0));
    }
    if (dKerY < 0) {
        offsetKernel->setCtr(offsetKernel->getCtr() + lsst::geom::Extent2I(0, 1));
    }
 
    offsetKernel->setKernelParameters(std::make_pair(dKerX, dKerY));
 
    ConvolutionControl convolutionControl;
    convolutionControl.setDoNormalize(true);
    convolutionControl.setDoCopyEdge(true);
    convolve(*convImage, *buffImage, *offsetKernel, convolutionControl);
 
    std::shared_ptr<ImageT> outImage;
    if (buffer > 0) {
        lsst::geom::Box2I box(lsst::geom::Point2I(buffer, buffer), inImage.getDimensions());
        std::shared_ptr<ImageT> out(new ImageT(*convImage, box, afwImage::LOCAL, true));
        outImage = out;
    } else {
        outImage = convImage;
    }
 
    // adjust the origin; do this after convolution since convolution also sets XY0
    outImage->setXY0(lsst::geom::Point2I(inImage.getX0() + dOrigX, inImage.getY0() + dOrigY));
 
    return outImage;
}

operator*()

std::shared_ptr< BoundedField > lsst::afw::math::operator*	(	double const	scale,
		std::shared_ptr< BoundedField const >	bf )

Definition at line 254 of file BoundedField.cc.

                                                                                                {
    return *bf * scale;
}

printKernel()

void lsst::afw::math::printKernel	(	lsst::afw::math::Kernel const &	kernel,
		bool	doNormalize,
		double	x = 0,
		double	y = 0,
		std::string	pixelFmt = "%7.3f" )

Print the pixel values of a Kernel to std::cout.

Rows increase upward and columns to the right; thus the lower left pixel is (0,0).

Parameters

kernel	the kernel
doNormalize	if true, normalize kernel
x	x at which to evaluate kernel
y	y at which to evaluate kernel
pixelFmt	format for pixel values

Definition at line 38 of file KernelFunctions.cc.

                                                                                                       {
    using Pixel = Kernel::Pixel;
 
    image::Image<Pixel> kImage(kernel.getDimensions());
    double kSum = kernel.computeImage(kImage, doNormalize, xPos, yPos);
 
    for (int y = kImage.getHeight() - 1; y >= 0; --y) {
        for (image::Image<Pixel>::const_x_iterator ptr = kImage.row_begin(y); ptr != kImage.row_end(y);
             ++ptr) {
            std::cout << boost::format(pixelFmt) % *ptr << " ";
        }
        std::cout << std::endl;
    }
 
    if (doNormalize && std::abs(static_cast<double>(kSum) - 1.0) > 1.0e-5) {
        std::cout << boost::format("Warning! Sum of all pixels = %9.5f != 1.0\n") % kSum;
    }
    std::cout << std::endl;
}

PYBIND11_MODULE()

lsst::afw::math::PYBIND11_MODULE	(	_math	,
		mod	)

Definition at line 51 of file _math.cc.

                            {
    lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.math");
    wrapApproximate(wrappers);
    wrapBackground(wrappers);
    wrapBoundedField(wrappers);
    wrapChebyshevBoundedField(wrappers);
    wrapConvolveImage(wrappers);
    wrapFunction(wrappers);
    wrapFunctionLibrary(wrappers);
    wrapGaussianProcess(wrappers);
    wrapInterpolate(wrappers);
    wrapKernel(wrappers);
    wrapLeastSquares(wrappers);
    wrapMinimize(wrappers);
    wrapOffsetImage(wrappers);
    wrapPixelAreaBoundedField(wrappers);
    wrapProductBoundedField(wrappers);
    wrapRandom(wrappers);
    wrapSpatialCell(wrappers);
    wrapStack(wrappers);
    wrapStatistics(wrappers);
    wrapTransformBoundedField(wrappers);
    wrapWarpExposure(wrappers);
    wrappers.finish();
}

randomChisqImage()

template<typename ImageT >

void lsst::afw::math::randomChisqImage	(	ImageT *	image,
		Random &	rand,
		double const	nu )

Set image to random numbers with a chi^2_{nu} distribution.

Parameters

[out]	image	The image to set
[in,out]	rand	definition of random number algorithm, seed, etc.
[in]	nu	number of degrees of freedom

Definition at line 135 of file RandomImage.cc.

                                                                    {
    lsst::afw::image::for_each_pixel(*image, do_chisq<typename ImageT::Pixel>(rand, nu));
}

randomFlatImage()

template<typename ImageT >

void lsst::afw::math::randomFlatImage	(	ImageT *	image,
		Random &	rand,
		double const	a,
		double const	b )

Set image to random numbers uniformly distributed in the range [a, b)

Parameters

[out]	image	The image to set
[in,out]	rand	definition of random number algorithm, seed, etc.
[in]	a	(inclusive) lower limit for random variates
[in]	b	(exclusive) upper limit for random variates

Definition at line 125 of file RandomImage.cc.

                                                                                  {
    lsst::afw::image::for_each_pixel(*image, do_flat<typename ImageT::Pixel>(rand, a, b));
}

randomGaussianImage()

template<typename ImageT >

void lsst::afw::math::randomGaussianImage	(	ImageT *	image,
		Random &	rand )

Set image to random numbers with a gaussian N(0, 1) distribution.

Parameters

[out]	image	The image to set
[in,out]	rand	definition of random number algorithm, seed, etc.

Definition at line 130 of file RandomImage.cc.

                                                      {
    lsst::afw::image::for_each_pixel(*image, do_gaussian<typename ImageT::Pixel>(rand));
}

randomPoissonImage()

template<typename ImageT >

void lsst::afw::math::randomPoissonImage	(	ImageT *	image,
		Random &	rand,
		double const	mu )

Set image to random numbers with a Poisson distribution with mean mu (n.b.

not per-pixel)

Parameters

[out]	image	The image to set
[in,out]	rand	definition of random number algorithm, seed, etc.
[in]	mu	mean of distribution

Definition at line 140 of file RandomImage.cc.

                                                                      {
    lsst::afw::image::for_each_pixel(*image, do_poisson<typename ImageT::Pixel>(rand, mu));
}

randomUniformImage()

template<typename ImageT >

void lsst::afw::math::randomUniformImage	(	ImageT *	image,
		Random &	rand )

Set image to random numbers uniformly distributed in the range [0, 1)

Parameters

[out]	image	The image to set
[in,out]	rand	definition of random number algorithm, seed, etc.

Definition at line 110 of file RandomImage.cc.

                                                     {
    lsst::afw::image::for_each_pixel(*image, do_uniform<typename ImageT::Pixel>(rand));
}

randomUniformIntImage()

template<typename ImageT >

void lsst::afw::math::randomUniformIntImage	(	ImageT *	image,
		Random &	rand,
		unsigned long	n )

Set image to random integers uniformly distributed in the range 0 ... n - 1.

Parameters

[out]	image	The image to set
[in,out]	rand	definition of random number algorithm, seed, etc.
[in]	n	(exclusive) upper limit for random variates

Definition at line 120 of file RandomImage.cc.

                                                                         {
    lsst::afw::image::for_each_pixel(*image, do_uniformInt<typename ImageT::Pixel>(rand, n));
}

randomUniformPosImage()

template<typename ImageT >

void lsst::afw::math::randomUniformPosImage	(	ImageT *	image,
		Random &	rand )

Set image to random numbers uniformly distributed in the range (0, 1)

Parameters

[out]	image	The image to set
[in,out]	rand	definition of random number algorithm, seed, etc.

Definition at line 115 of file RandomImage.cc.

                                                        {
    lsst::afw::image::for_each_pixel(*image, do_uniformPos<typename ImageT::Pixel>(rand));
}

rotateImageBy90()

template<typename ImageT >

std::shared_ptr< ImageT > lsst::afw::math::rotateImageBy90	(	ImageT const &	image,
		int	nQuarter )

Rotate an image by an integral number of quarter turns.

Parameters

image	The image to rotate
nQuarter	the desired number of quarter turns

Definition at line 39 of file rotateImage.cc.

                                                                           {
    std::shared_ptr<ImageT> outImage;  // output image
 
    while (nQuarter < 0) {
        nQuarter += 4;
    }
 
    switch (nQuarter % 4) {
        case 0:
            outImage.reset(new ImageT(inImage, true));  // a deep copy of inImage
            break;
        case 1:
            outImage.reset(new ImageT(lsst::geom::Extent2I(inImage.getHeight(), inImage.getWidth())));
 
            for (int y = 0; y != inImage.getHeight(); ++y) {
                typename ImageT::y_iterator optr = outImage->col_begin(inImage.getHeight() - y - 1);
                for (typename ImageT::x_iterator iptr = inImage.row_begin(y), end = inImage.row_end(y);
                     iptr != end; ++iptr, ++optr) {
                    *optr = *iptr;
                }
            }
 
            break;
        case 2:
            outImage.reset(new ImageT(inImage.getDimensions()));
 
            for (int y = 0; y != inImage.getHeight(); ++y) {
                typename ImageT::x_iterator optr =
                        outImage->x_at(inImage.getWidth() - 1, inImage.getHeight() - y - 1);
                for (typename ImageT::x_iterator iptr = inImage.row_begin(y), end = inImage.row_end(y);
                     iptr != end; ++iptr, optr -= 1) {
                    *optr = *iptr;
                }
            }
            break;
        case 3:
            outImage.reset(new ImageT(lsst::geom::Extent2I(inImage.getHeight(), inImage.getWidth())));
 
            for (int y = 0; y != inImage.getHeight(); ++y) {
                typename ImageT::y_iterator optr = outImage->y_at(y, inImage.getWidth() - 1);
                for (typename ImageT::x_iterator iptr = inImage.row_begin(y), end = inImage.row_end(y);
                     iptr != end; ++iptr, optr -= 1) {
                    *optr = *iptr;
                }
            }
 
            break;
    }
 
    return outImage;
}

scaledPlus()

template<typename OutImageT , typename InImageT >

void lsst::afw::math::scaledPlus	(	OutImageT &	outImage,
		double	c1,
		InImageT const &	inImage1,
		double	c2,
		InImageT const &	inImage2 )

Compute the scaled sum of two images.

outImage = c1 inImage1 + c2 inImage2

For example to linearly interpolate between two images set: c1 = 1.0 - fracDist c2 = fracDist where fracDist is the fractional distance of outImage from inImage1: location of outImage - location of inImage1 fracDist = ----------------------------------------— location of inImage2 - location of inImage1

Parameters

[out]	outImage	output image
[in]	c1	coefficient for image 1
[in]	inImage1	input image 1
[in]	c2	coefficient for image 2
[in]	inImage2	input image 2

Exceptions

lsst::pex::exceptions::InvalidParameterError

if outImage is not same dimensions as inImage1 and inImage2.

Definition at line 153 of file ConvolveImage.cc.

                                          {
    if (outImage.getDimensions() != inImage1.getDimensions()) {
        std::ostringstream os;
        os << "outImage dimensions = ( " << outImage.getWidth() << ", " << outImage.getHeight() << ") != ("
           << inImage1.getWidth() << ", " << inImage1.getHeight() << ") = inImage1 dimensions";
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, os.str());
    } else if (inImage1.getDimensions() != inImage2.getDimensions()) {
        std::ostringstream os;
        os << "inImage1 dimensions = ( " << inImage1.getWidth() << ", " << inImage1.getHeight() << ") != ("
           << inImage2.getWidth() << ", " << inImage2.getHeight() << ") = inImage2 dimensions";
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, os.str());
    }
 
    using InConstXIter = typename InImageT::const_x_iterator;
    using OutXIter = typename OutImageT::x_iterator;
    for (int y = 0; y != inImage1.getHeight(); ++y) {
        InConstXIter const end1 = inImage1.row_end(y);
        InConstXIter inIter1 = inImage1.row_begin(y);
        InConstXIter inIter2 = inImage2.row_begin(y);
        OutXIter outIter = outImage.row_begin(y);
        for (; inIter1 != end1; ++inIter1, ++inIter2, ++outIter) {
            *outIter = (*inIter1 * c1) + (*inIter2 * c2);
        }
    }
}

statisticsStack() [1/18]

template<typename PixelT >

void lsst::afw::math::statisticsStack	(	image::Image< PixelT > &	out,
		std::vector< std::shared_ptr< image::Image< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl,
		WeightVector const &	wvector )

Definition at line 359 of file Stack.cc.

                                                                                                  {
    checkObjectsAndWeights(images, wvector);
    checkOnlyOneFlag(flags);
    checkImageSizes(out, images);
 
    if (wvector.empty()) {
        return computeImageStack<PixelT, false>(out, images, flags, sctrl);
    } else {
        return computeImageStack<PixelT, true>(out, images, flags, sctrl, wvector);
    }
}

statisticsStack() [2/18]

template<typename PixelT >

std::shared_ptr< image::MaskedImage< PixelT > > lsst::afw::math::statisticsStack	(	image::Image< PixelT > const &	image,
		Property	flags,
		char	dimension,
		StatisticsControl const &	sctrl )

A function to compute statistics on the rows or columns of an image.

Definition at line 444 of file Stack.cc.

                                                                                                            {
    int x0 = image.getX0();
    int y0 = image.getY0();
    using MImage = image::MaskedImage<PixelT>;
    std::shared_ptr<MImage> imgOut;
 
    // do each row or column, one at a time
    // - create a subimage with a bounding box, and get the stats and assign the value to the output image
    if (dimension == 'x') {
        imgOut = std::shared_ptr<MImage>(new MImage(lsst::geom::Extent2I(1, image.getHeight())));
        int y = y0;
        typename MImage::y_iterator oEnd = imgOut->col_end(0);
        for (typename MImage::y_iterator oPtr = imgOut->col_begin(0); oPtr != oEnd; ++oPtr, ++y) {
            lsst::geom::Box2I bbox =
                    lsst::geom::Box2I(lsst::geom::Point2I(x0, y), lsst::geom::Extent2I(image.getWidth(), 1));
            image::Image<PixelT> subImage(image, bbox);
            Statistics stat = makeStatistics(subImage, flags | ERRORS, sctrl);
            *oPtr = typename image::MaskedImage<PixelT>::Pixel(stat.getValue(), 0x0,
                                                               stat.getError() * stat.getError());
        }
 
    } else if (dimension == 'y') {
        imgOut = std::shared_ptr<MImage>(new MImage(lsst::geom::Extent2I(image.getWidth(), 1)));
        int x = x0;
        typename MImage::x_iterator oEnd = imgOut->row_end(0);
        for (typename MImage::x_iterator oPtr = imgOut->row_begin(0); oPtr != oEnd; ++oPtr, ++x) {
            lsst::geom::Box2I bbox =
                    lsst::geom::Box2I(lsst::geom::Point2I(x, y0), lsst::geom::Extent2I(1, image.getHeight()));
            image::Image<PixelT> subImage(image, bbox);
            Statistics stat = makeStatistics(subImage, flags | ERRORS, sctrl);
            *oPtr = typename image::MaskedImage<PixelT>::Pixel(stat.getValue(), 0x0,
                                                               stat.getError() * stat.getError());
        }
    } else {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                          "Can only run statisticsStack in x or y for single image.");
    }
 
    return imgOut;
}

statisticsStack() [3/18]

template<typename PixelT >

void lsst::afw::math::statisticsStack	(	image::MaskedImage< PixelT > &	out,
		std::vector< std::shared_ptr< image::MaskedImage< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl,
		WeightVector const &	wvector,
		image::MaskPixel	clipped,
		image::MaskPixel	excuse )

Definition at line 250 of file Stack.cc.

                                            {
    checkObjectsAndWeights(images, wvector);
    checkOnlyOneFlag(flags);
    checkImageSizes(out, images);
 
    if (sctrl.getWeighted()) {
        if (wvector.empty()) {
            return computeMaskedImageStack<PixelT, true, true>(out, images, flags, sctrl, clipped,
                                                               excuse);  // use variance
        } else {
            return computeMaskedImageStack<PixelT, true, false>(out, images, flags, sctrl, clipped, excuse,
                                                                wvector);  // use wvector
        }
    } else {
        if (!wvector.empty()) {
            LOGL_WARN(_log,
               "Weights passed on to statisticsStack are ignored as sctrl.getWeighted() is False."
               "Set sctrl.setWeighted(True) for them to be used.");
        }
        return computeMaskedImageStack<PixelT, false, false>(out, images, flags, sctrl, clipped, excuse);
    }
}

statisticsStack() [4/18]

template<typename PixelT >

void lsst::afw::math::statisticsStack	(	image::MaskedImage< PixelT > &	out,
		std::vector< std::shared_ptr< image::MaskedImage< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl,
		WeightVector const &	wvector,
		image::MaskPixel	clipped,
		std::vector< std::pair< image::MaskPixel, image::MaskPixel > > const &	maskMap )

Definition at line 277 of file Stack.cc.

                                                                                        {
    checkObjectsAndWeights(images, wvector);
    checkOnlyOneFlag(flags);
    checkImageSizes(out, images);
 
    if (sctrl.getWeighted()) {
        if (wvector.empty()) {
            return computeMaskedImageStack<PixelT, true, true>(out, images, flags, sctrl, clipped,
                                                               maskMap);  // use variance
        } else {
            return computeMaskedImageStack<PixelT, true, false>(out, images, flags, sctrl, clipped, maskMap,
                                                                wvector);  // use wvector
        }
    } else {
        return computeMaskedImageStack<PixelT, false, false>(out, images, flags, sctrl, clipped, maskMap);
    }
}

statisticsStack() [5/18]

template<typename PixelT >

std::shared_ptr< image::MaskedImage< PixelT > > lsst::afw::math::statisticsStack	(	image::MaskedImage< PixelT > const &	image,
		Property	flags,
		char	dimension,
		StatisticsControl const &	sctrl )

A function to compute statistics on the rows or columns of an image.

Definition at line 487 of file Stack.cc.

                                                                                            {
    int const x0 = image.getX0();
    int const y0 = image.getY0();
    using MImage = image::MaskedImage<PixelT>;
    std::shared_ptr<MImage> imgOut;
 
    // do each row or column, one at a time
    // - create a subimage with a bounding box, and get the stats and assign the value to the output image
    if (dimension == 'x') {
        imgOut = std::shared_ptr<MImage>(new MImage(lsst::geom::Extent2I(1, image.getHeight())));
        int y = 0;
        typename MImage::y_iterator oEnd = imgOut->col_end(0);
        for (typename MImage::y_iterator oPtr = imgOut->col_begin(0); oPtr != oEnd; ++oPtr, ++y) {
            lsst::geom::Box2I bbox =
                    lsst::geom::Box2I(lsst::geom::Point2I(x0, y), lsst::geom::Extent2I(image.getWidth(), 1));
            image::MaskedImage<PixelT> subImage(image, bbox);
            Statistics stat = makeStatistics(subImage, flags | ERRORS, sctrl);
            *oPtr = typename image::MaskedImage<PixelT>::Pixel(stat.getValue(), 0x0,
                                                               stat.getError() * stat.getError());
        }
 
    } else if (dimension == 'y') {
        imgOut = std::shared_ptr<MImage>(new MImage(lsst::geom::Extent2I(image.getWidth(), 1)));
        int x = 0;
        typename MImage::x_iterator oEnd = imgOut->row_end(0);
        for (typename MImage::x_iterator oPtr = imgOut->row_begin(0); oPtr != oEnd; ++oPtr, ++x) {
            lsst::geom::Box2I bbox =
                    lsst::geom::Box2I(lsst::geom::Point2I(x, y0), lsst::geom::Extent2I(1, image.getHeight()));
            image::MaskedImage<PixelT> subImage(image, bbox);
            Statistics stat = makeStatistics(subImage, flags | ERRORS, sctrl);
            *oPtr = typename image::MaskedImage<PixelT>::Pixel(stat.getValue(), 0x0,
                                                               stat.getError() * stat.getError());
        }
    } else {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                          "Can only run statisticsStack in x or y for single image.");
    }
 
    return imgOut;
}

statisticsStack() [6/18]

template<typename PixelT >

void lsst::afw::math::statisticsStack	(	lsst::afw::image::Image< PixelT > &	out,
		std::vector< std::shared_ptr< lsst::afw::image::Image< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl = StatisticsControl(),
		std::vector< lsst::afw::image::VariancePixel > const &	wvector = std::vector< lsst::afw::image::VariancePixel >(0) )

@ brief compute statistical stack of Image.

Write to output image in-situ

Parameters

out	Output image
images	Images to process
flags	statistics requested
sctrl	Control structure
wvector	vector containing weights

statisticsStack() [7/18]

template<typename PixelT >

std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > lsst::afw::math::statisticsStack	(	lsst::afw::image::Image< PixelT > const &	image,
		Property	flags,
		char	dimension,
		StatisticsControl const &	sctrl = StatisticsControl() )

A function to compute statistics on the rows or columns of an image.

Definition at line 444 of file Stack.cc.

                                                                                                            {
    int x0 = image.getX0();
    int y0 = image.getY0();
    using MImage = image::MaskedImage<PixelT>;
    std::shared_ptr<MImage> imgOut;
 
    // do each row or column, one at a time
    // - create a subimage with a bounding box, and get the stats and assign the value to the output image
    if (dimension == 'x') {
        imgOut = std::shared_ptr<MImage>(new MImage(lsst::geom::Extent2I(1, image.getHeight())));
        int y = y0;
        typename MImage::y_iterator oEnd = imgOut->col_end(0);
        for (typename MImage::y_iterator oPtr = imgOut->col_begin(0); oPtr != oEnd; ++oPtr, ++y) {
            lsst::geom::Box2I bbox =
                    lsst::geom::Box2I(lsst::geom::Point2I(x0, y), lsst::geom::Extent2I(image.getWidth(), 1));
            image::Image<PixelT> subImage(image, bbox);
            Statistics stat = makeStatistics(subImage, flags | ERRORS, sctrl);
            *oPtr = typename image::MaskedImage<PixelT>::Pixel(stat.getValue(), 0x0,
                                                               stat.getError() * stat.getError());
        }
 
    } else if (dimension == 'y') {
        imgOut = std::shared_ptr<MImage>(new MImage(lsst::geom::Extent2I(image.getWidth(), 1)));
        int x = x0;
        typename MImage::x_iterator oEnd = imgOut->row_end(0);
        for (typename MImage::x_iterator oPtr = imgOut->row_begin(0); oPtr != oEnd; ++oPtr, ++x) {
            lsst::geom::Box2I bbox =
                    lsst::geom::Box2I(lsst::geom::Point2I(x, y0), lsst::geom::Extent2I(1, image.getHeight()));
            image::Image<PixelT> subImage(image, bbox);
            Statistics stat = makeStatistics(subImage, flags | ERRORS, sctrl);
            *oPtr = typename image::MaskedImage<PixelT>::Pixel(stat.getValue(), 0x0,
                                                               stat.getError() * stat.getError());
        }
    } else {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                          "Can only run statisticsStack in x or y for single image.");
    }
 
    return imgOut;
}

statisticsStack() [8/18]

template<typename PixelT >

void lsst::afw::math::statisticsStack	(	lsst::afw::image::MaskedImage< PixelT > &	out,
		std::vector< std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl,
		std::vector< lsst::afw::image::VariancePixel > const &	wvector,
		image::MaskPixel	clipped,
		std::vector< std::pair< image::MaskPixel, image::MaskPixel > > const &	maskMap )

A function to compute some statistics of a stack of Masked Images.

Parameters

[out]	out	Output MaskedImage.
[in]	images	MaskedImages to process.
[in]	flags	Statistics requested.
[in]	sctrl	Control structure.
[in]	wvector	Vector of weights.
[in]	clipped	Mask to set for pixels that were clipped (NOT rejected due to masks).
[in]	maskMap	Vector of pairs of mask pixel values; any pixel on an input with any of the bits in .first will result in all of the bits in .second being set on the corresponding pixel on the output.

If none of the input images are valid for some pixel, the afwMath::StatisticsControl::getNoGoodPixelsMask() bit(s) are set.

All the work is done in the function computeMaskedImageStack.

statisticsStack() [9/18]

template<typename PixelT >

void lsst::afw::math::statisticsStack	(	lsst::afw::image::MaskedImage< PixelT > &	out,
		std::vector< std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl = StatisticsControl(),
		std::vector< lsst::afw::image::VariancePixel > const &	wvector = std::vector< lsst::afw::image::VariancePixel >(0),
		image::MaskPixel	clipped = 0,
		image::MaskPixel	excuse = 0 )

@ brief compute statistical stack of MaskedImage.

Write to output image in-situ

Parameters

out	Output image
images	MaskedImages to process
flags	statistics requested
sctrl	control structure
wvector	vector containing weights
clipped	bitmask to set if any input was clipped or masked
excuse	bitmask to excuse from marking as clipped

statisticsStack() [10/18]

template<typename PixelT >

std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > lsst::afw::math::statisticsStack	(	lsst::afw::image::MaskedImage< PixelT > const &	image,
		Property	flags,
		char	dimension,
		StatisticsControl const &	sctrl = StatisticsControl() )

A function to compute statistics on the rows or columns of an image.

Definition at line 487 of file Stack.cc.

                                                                                            {
    int const x0 = image.getX0();
    int const y0 = image.getY0();
    using MImage = image::MaskedImage<PixelT>;
    std::shared_ptr<MImage> imgOut;
 
    // do each row or column, one at a time
    // - create a subimage with a bounding box, and get the stats and assign the value to the output image
    if (dimension == 'x') {
        imgOut = std::shared_ptr<MImage>(new MImage(lsst::geom::Extent2I(1, image.getHeight())));
        int y = 0;
        typename MImage::y_iterator oEnd = imgOut->col_end(0);
        for (typename MImage::y_iterator oPtr = imgOut->col_begin(0); oPtr != oEnd; ++oPtr, ++y) {
            lsst::geom::Box2I bbox =
                    lsst::geom::Box2I(lsst::geom::Point2I(x0, y), lsst::geom::Extent2I(image.getWidth(), 1));
            image::MaskedImage<PixelT> subImage(image, bbox);
            Statistics stat = makeStatistics(subImage, flags | ERRORS, sctrl);
            *oPtr = typename image::MaskedImage<PixelT>::Pixel(stat.getValue(), 0x0,
                                                               stat.getError() * stat.getError());
        }
 
    } else if (dimension == 'y') {
        imgOut = std::shared_ptr<MImage>(new MImage(lsst::geom::Extent2I(image.getWidth(), 1)));
        int x = 0;
        typename MImage::x_iterator oEnd = imgOut->row_end(0);
        for (typename MImage::x_iterator oPtr = imgOut->row_begin(0); oPtr != oEnd; ++oPtr, ++x) {
            lsst::geom::Box2I bbox =
                    lsst::geom::Box2I(lsst::geom::Point2I(x, y0), lsst::geom::Extent2I(1, image.getHeight()));
            image::MaskedImage<PixelT> subImage(image, bbox);
            Statistics stat = makeStatistics(subImage, flags | ERRORS, sctrl);
            *oPtr = typename image::MaskedImage<PixelT>::Pixel(stat.getValue(), 0x0,
                                                               stat.getError() * stat.getError());
        }
    } else {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                          "Can only run statisticsStack in x or y for single image.");
    }
 
    return imgOut;
}

statisticsStack() [11/18]

template<typename PixelT >

std::shared_ptr< image::Image< PixelT > > lsst::afw::math::statisticsStack	(	std::vector< std::shared_ptr< image::Image< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl,
		WeightVector const &	wvector )

Definition at line 347 of file Stack.cc.

                                                                     {
    if (images.size() == 0) {
        throw LSST_EXCEPT(pexExcept::LengthError, "Please specify at least one image to stack");
    }
    std::shared_ptr<image::Image<PixelT>> out(new image::Image<PixelT>(images[0]->getDimensions()));
    statisticsStack(*out, images, flags, sctrl, wvector);
    return out;
}

statisticsStack() [12/18]

template<typename PixelT >

std::shared_ptr< image::MaskedImage< PixelT > > lsst::afw::math::statisticsStack	(	std::vector< std::shared_ptr< image::MaskedImage< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl,
		WeightVector const &	wvector,
		image::MaskPixel	clipped,
		image::MaskPixel	excuse )

Definition at line 222 of file Stack.cc.

                               {
    if (images.size() == 0) {
        throw LSST_EXCEPT(pexExcept::LengthError, "Please specify at least one image to stack");
    }
    std::shared_ptr<image::MaskedImage<PixelT>> out(
            new image::MaskedImage<PixelT>(images[0]->getDimensions()));
    statisticsStack(*out, images, flags, sctrl, wvector, clipped, excuse);
    return out;
}

statisticsStack() [13/18]

template<typename PixelT >

std::shared_ptr< image::MaskedImage< PixelT > > lsst::afw::math::statisticsStack	(	std::vector< std::shared_ptr< image::MaskedImage< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl,
		WeightVector const &	wvector,
		image::MaskPixel	clipped,
		std::vector< std::pair< image::MaskPixel, image::MaskPixel > > const &	maskMap )

Definition at line 236 of file Stack.cc.

                                                                           {
    if (images.size() == 0) {
        throw LSST_EXCEPT(pexExcept::LengthError, "Please specify at least one image to stack");
    }
    std::shared_ptr<image::MaskedImage<PixelT>> out(
            new image::MaskedImage<PixelT>(images[0]->getDimensions()));
    statisticsStack(*out, images, flags, sctrl, wvector, clipped, maskMap);
    return out;
}

statisticsStack() [14/18]

template<typename PixelT >

std::shared_ptr< lsst::afw::image::Image< PixelT > > lsst::afw::math::statisticsStack	(	std::vector< std::shared_ptr< lsst::afw::image::Image< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl = StatisticsControl(),
		std::vector< lsst::afw::image::VariancePixel > const &	wvector = std::vector< lsst::afw::image::VariancePixel >(0) )

A function to compute some statistics of a stack of Images.

Parameters

images	Images to process
flags	statistics requested
sctrl	Control structure
wvector	vector containing weights

statisticsStack() [15/18]

template<typename PixelT >

std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > lsst::afw::math::statisticsStack	(	std::vector< std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl,
		std::vector< lsst::afw::image::VariancePixel > const &	wvector,
		image::MaskPixel	clipped,
		std::vector< std::pair< image::MaskPixel, image::MaskPixel > > const &	maskMap )

A function to compute some statistics of a stack of Masked Images.

Parameters

[in]	images	MaskedImages to process.
[in]	flags	Statistics requested.
[in]	sctrl	Control structure.
[in]	wvector	Vector of weights.
[in]	clipped	Mask to set for pixels that were clipped (NOT rejected due to masks).
[in]	maskMap	Vector of pairs of mask pixel values; any pixel on an input with any of the bits in .first will result in all of the bits in .second being set on the corresponding pixel on the output.

If none of the input images are valid for some pixel, the afwMath::StatisticsControl::getNoGoodPixelsMask() bit(s) are set.

All the work is done in the function computeMaskedImageStack.

statisticsStack() [16/18]

template<typename PixelT >

std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > lsst::afw::math::statisticsStack	(	std::vector< std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > > &	images,
		Property	flags,
		StatisticsControl const &	sctrl = StatisticsControl(),
		std::vector< lsst::afw::image::VariancePixel > const &	wvector = std::vector< lsst::afw::image::VariancePixel >(0),
		image::MaskPixel	clipped = 0,
		image::MaskPixel	excuse = 0 )

A function to compute some statistics of a stack of Masked Images.

If none of the input images are valid for some pixel, the afwMath::StatisticsControl::getNoGoodPixelsMask() bit(s) are set.

Delegates to the more general version of statisticsStack taking a maskMap.

Parameters

images	MaskedImages to process
flags	statistics requested
sctrl	control structure
wvector	vector containing weights
clipped	bitmask to set if any input was clipped or masked
excuse	bitmask to excuse from marking as clipped

statisticsStack() [17/18]

template<typename PixelT >

std::vector< PixelT > lsst::afw::math::statisticsStack	(	std::vector< std::vector< PixelT > > &	vectors,
		Property	flags,
		StatisticsControl const &	sctrl,
		WeightVector const &	wvector )

Definition at line 424 of file Stack.cc.

                                                                     {
    checkObjectsAndWeights(vectors, wvector);
    checkOnlyOneFlag(flags);
 
    if (wvector.empty()) {
        return computeVectorStack<PixelT, false>(vectors, flags, sctrl);
    } else {
        return computeVectorStack<PixelT, true>(vectors, flags, sctrl, wvector);
    }
}

statisticsStack() [18/18]

template<typename PixelT >

std::vector< PixelT > lsst::afw::math::statisticsStack	(	std::vector< std::vector< PixelT > > &	vectors,
		Property	flags,
		StatisticsControl const &	sctrl = StatisticsControl(),
		std::vector< lsst::afw::image::VariancePixel > const &	wvector = std::vector< lsst::afw::image::VariancePixel >(0) )

A function to compute some statistics of a stack of std::vectors.

Parameters

vectors	Vectors to process
flags	statistics requested
sctrl	control structure
wvector	vector containing weights

stringToInterpStyle()

Interpolate::Style lsst::afw::math::stringToInterpStyle

(

std::string const &

style

)

Conversion function to switch a string to an Interpolate::Style.

Parameters

style

desired type of interpolation

Definition at line 261 of file Interpolate.cc.

                                                             {
    static std::map<std::string, Interpolate::Style> gslInterpTypeStrings;
    if (gslInterpTypeStrings.empty()) {
        gslInterpTypeStrings["CONSTANT"] = Interpolate::CONSTANT;
        gslInterpTypeStrings["LINEAR"] = Interpolate::LINEAR;
        gslInterpTypeStrings["CUBIC_SPLINE"] = Interpolate::CUBIC_SPLINE;
        gslInterpTypeStrings["NATURAL_SPLINE"] = Interpolate::NATURAL_SPLINE;
        gslInterpTypeStrings["CUBIC_SPLINE_PERIODIC"] = Interpolate::CUBIC_SPLINE_PERIODIC;
        gslInterpTypeStrings["AKIMA_SPLINE"] = Interpolate::AKIMA_SPLINE;
        gslInterpTypeStrings["AKIMA_SPLINE_PERIODIC"] = Interpolate::AKIMA_SPLINE_PERIODIC;
    }
 
    if (gslInterpTypeStrings.find(style) == gslInterpTypeStrings.end()) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Interp style not found: " + style);
    }
    return gslInterpTypeStrings[style];
}

stringToStatisticsProperty()

Property lsst::afw::math::stringToStatisticsProperty

(

std::string const

property

)

Conversion function to switch a string to a Property (see Statistics.h)

Definition at line 762 of file Statistics.cc.

                                                              {
    static std::map<std::string, Property> statisticsProperty;
    if (statisticsProperty.size() == 0) {
        statisticsProperty["NOTHING"] = NOTHING;
        statisticsProperty["ERRORS"] = ERRORS;
        statisticsProperty["NPOINT"] = NPOINT;
        statisticsProperty["MEAN"] = MEAN;
        statisticsProperty["STDEV"] = STDEV;
        statisticsProperty["VARIANCE"] = VARIANCE;
        statisticsProperty["MEDIAN"] = MEDIAN;
        statisticsProperty["IQRANGE"] = IQRANGE;
        statisticsProperty["MEANCLIP"] = MEANCLIP;
        statisticsProperty["STDEVCLIP"] = STDEVCLIP;
        statisticsProperty["VARIANCECLIP"] = VARIANCECLIP;
        statisticsProperty["MIN"] = MIN;
        statisticsProperty["MAX"] = MAX;
        statisticsProperty["SUM"] = SUM;
        statisticsProperty["MEANSQUARE"] = MEANSQUARE;
        statisticsProperty["ORMASK"] = ORMASK;
        statisticsProperty["NCLIPPED"] = NCLIPPED;
        statisticsProperty["NMASKED"] = NMASKED;
    }
    return statisticsProperty[property];
}

stringToUndersampleStyle()

UndersampleStyle lsst::afw::math::stringToUndersampleStyle

(

std::string const &

style

)

Conversion function to switch a string to an UndersampleStyle.

Definition at line 117 of file Background.cc.

                                                                  {
    static std::map<std::string, UndersampleStyle> undersampleStrings;
    if (undersampleStrings.size() == 0) {
        undersampleStrings["THROW_EXCEPTION"] = THROW_EXCEPTION;
        undersampleStrings["REDUCE_INTERP_ORDER"] = REDUCE_INTERP_ORDER;
        undersampleStrings["INCREASE_NXNYSAMPLE"] = INCREASE_NXNYSAMPLE;
    }
 
    if (undersampleStrings.find(style) == undersampleStrings.end()) {
        throw LSST_EXCEPT(ex::InvalidParameterError, "Understample style not defined: " + style);
    }
    return undersampleStrings[style];
}

warpCenteredImage()

template<typename DestImageT , typename SrcImageT >

int lsst::afw::math::warpCenteredImage	(	DestImageT &	destImage,
		SrcImageT const &	srcImage,
		lsst::geom::LinearTransform const &	linearTransform,
		lsst::geom::Point2D const &	centerPosition,
		WarpingControl const &	control,
		typename DestImageT::SinglePixel	padValue = lsst::afw::math::edgePixel<DestImageT>(                typename lsst::afw::image::detail::image_traits<DestImageT>::image_category()) )

Warp an image with a LinearTranform about a specified point.

This enables warping an image of e.g. a PSF without translating the centroid.

Parameters

destImage	remapped image
srcImage	source image
linearTransform	linear transformation to apply
centerPosition	pixel position for location of linearTransform
control	control parameters
padValue	use this value for undefined (edge) pixels

Definition at line 666 of file warpExposure.cc.

                                                               {
    // force src and dest to be the same size and xy0
    if ((destImage.getWidth() != srcImage.getWidth()) || (destImage.getHeight() != srcImage.getHeight()) ||
        (destImage.getXY0() != srcImage.getXY0())) {
        std::ostringstream errStream;
        errStream << "src and dest images must have same size and xy0.";
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, errStream.str());
    }
 
    // set the xy0 coords to 0,0 to make life easier
    SrcImageT srcImageCopy(srcImage, true);
    srcImageCopy.setXY0(0, 0);
    destImage.setXY0(0, 0);
    lsst::geom::Extent2D cLocal =
            lsst::geom::Extent2D(centerPosition) - lsst::geom::Extent2D(srcImage.getXY0());
 
    // for the affine transform, the centerPosition will not only get sheared, but also
    // moved slightly.  So we'll include a translation to move it back by an amount
    // centerPosition - translatedCenterPosition
    lsst::geom::AffineTransform affTran(linearTransform, cLocal - linearTransform(cLocal));
    std::shared_ptr<geom::TransformPoint2ToPoint2> affineTransform22 = geom::makeTransform(affTran);
 
// now warp
#if 0
    static float t = 0.0;
    float t_before = 1.0*clock()/CLOCKS_PER_SEC;
    int n = warpImage(destImage, srcImageCopy, affTran, control, padValue);
    float t_after = 1.0*clock()/CLOCKS_PER_SEC;
    float dt = t_after - t_before;
    t += dt;
    std::cout <<srcImage.getWidth()<<"x"<<srcImage.getHeight()<<": "<< dt <<" "<< t <<std::endl;
#else
    int n = warpImage(destImage, srcImageCopy, *affineTransform22, control, padValue);
#endif
 
    // fix the origin and we're done.
    destImage.setXY0(srcImage.getXY0());
 
    return n;
}

warpExposure()

template<typename DestExposureT , typename SrcExposureT >

int lsst::afw::math::warpExposure	(	DestExposureT &	destExposure,
		SrcExposureT const &	srcExposure,
		WarpingControl const &	control,
		typename DestExposureT::MaskedImageT::SinglePixel	padValue = lsst::afw::math::edgePixel<typename DestExposureT::MaskedImageT>(                        typename lsst::afw::image::detail::image_traits<                                typename DestExposureT::MaskedImageT>::image_category()) )

Warp (remap) one exposure to another.

This is a convenience wrapper around warpImage().

Parameters

destExposure	Remapped exposure. Wcs and xy0 are read, MaskedImage is set, and PhotoCalib, FilterLabel and VisitInfo are copied from srcExposure. All other attributes are left alone (including Detector and Psf)
srcExposure	Source exposure
control	control parameters
padValue	use this value for undefined (edge) pixels

Definition at line 393 of file warpExposure.cc.

                                                                         {
    if (!destExposure.hasWcs()) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, "destExposure has no Wcs");
    }
    if (!srcExposure.hasWcs()) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, "srcExposure has no Wcs");
    }
    typename DestExposureT::MaskedImageT mi = destExposure.getMaskedImage();
    if (srcExposure.getInfo()->hasId()) {
        destExposure.getInfo()->setId(srcExposure.getInfo()->getId());
    }
    destExposure.setPhotoCalib(srcExposure.getPhotoCalib());
    destExposure.setFilter(srcExposure.getFilter());
    destExposure.getInfo()->setVisitInfo(srcExposure.getInfo()->getVisitInfo());
    return warpImage(mi, *destExposure.getWcs(), srcExposure.getMaskedImage(), *srcExposure.getWcs(), control,
                     padValue);
}

warpImage() [1/2]

template<typename DestImageT , typename SrcImageT >

int lsst::afw::math::warpImage	(	DestImageT &	destImage,
		geom::SkyWcs const &	destWcs,
		SrcImageT const &	srcImage,
		geom::SkyWcs const &	srcWcs,
		WarpingControl const &	control,
		typename DestImageT::SinglePixel	padValue = lsst::afw::math::edgePixel<DestImageT>(                      typename lsst::afw::image::detail::image_traits<DestImageT>::image_category()) )

Warp an Image or MaskedImage to a new Wcs.

See also convenience function warpExposure() to warp an Exposure.

Edge pixels are set to padValue; these are pixels that cannot be computed because they are too near the edge of srcImage or miss srcImage entirely.

Returns

the number of valid pixels in destImage (those that are not edge pixels).

Algorithm Without Interpolation:

For each integer pixel position in the remapped Exposure:

• The associated pixel position on srcImage is determined using the destination and source WCS
• The warping kernel's parameters are set based on the fractional part of the pixel position on srcImage
• The warping kernel is applied to srcImage at the integer portion of the pixel position to compute the remapped pixel value
• A flux-conservation factor is determined from the source and destination WCS and is applied to the remapped pixel

The scaling of intensity for relative area of source and destination uses two minor approximations:

• The area of the sky marked out by a pixel on the destination image corresponds to a parallellogram on the source image.
• The area varies slowly enough across the image that we can get away with computing the source area shifted by half a pixel up and to the left of the true area.

Algorithm With Interpolation:

Interpolation simply reduces the number of times WCS is used to map between destination and source pixel position. This computation is only made at a grid of points on the destination image, separated by interpLen pixels along rows and columns. All other source pixel positions are determined by linear interpolation between those grid points. Everything else remains the same.

Exceptions

lsst::pex::exceptions::InvalidParameterError	if destImage overlaps srcImage
std::bad_alloc	when allocation of CPU memory fails

Todo

Should support an additional color-based position correction in the remapping (differential chromatic refraction). This can be done either object-by-object or pixel-by-pixel.

Todo

Need to deal with oversampling and/or weight maps. If done we can use faster kernels than sinc.

Warning

The code that tests for image overlap is not guranteed to work correctly, based on the C++ standard. It is, in theory, possible for the code to report a "false positive", meaning that it may claim that images overlap when they do not. We don't believe that any of our current compilers have this problem. If, in the future, this becomes a problem then we will probably have to remove the test and rely on users being careful.

Parameters

destImage	remapped image
destWcs	WCS of remapped image
srcImage	source image
srcWcs	WCS of source image
control	control parameters
padValue	use this value for undefined (edge) pixels

Definition at line 441 of file warpExposure.cc.

                                                       {
    auto srcToDest = geom::makeWcsPairTransform(srcWcs, destWcs);
    return warpImage(destImage, srcImage, *srcToDest, control, padValue);
}

warpImage() [2/2]

template<typename DestImageT , typename SrcImageT >

int lsst::afw::math::warpImage	(	DestImageT &	destImage,
		SrcImageT const &	srcImage,
		geom::TransformPoint2ToPoint2 const &	srcToDest,
		WarpingControl const &	control,
		typename DestImageT::SinglePixel	padValue = lsst::afw::math::edgePixel<DestImageT>(                      typename lsst::afw::image::detail::image_traits<DestImageT>::image_category()) )

A variant of warpImage that uses a Transform<Point2Endpoint, Point2Endpoint> instead of a pair of WCS to describe the transformation.

Parameters

[in,out]	destImage	Destination image; all pixels are set
[in]	srcImage	Source image
[in]	srcToDest	Transformation from source to destination pixels, in parent coordinates; the inverse must be defined (and is the only direction used). makeWcsPairTransform(srcWcs, destWcs) is one way to compute this transform.
[in]	control	Warning control parameters
[in]	padValue	Value used for pixels in the destination image that are outside the region of pixels that can be computed from the source image

Returns

the number of good pixels

Definition at line 449 of file warpExposure.cc.

                                                       {
    if (imagesOverlap(destImage, srcImage)) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, "destImage overlaps srcImage; cannot warp");
    }
    if (destImage.getBBox(image::LOCAL).isEmpty()) {
        return 0;
    }
    // if src image is too small then don't try to warp
    std::shared_ptr<SeparableKernel> warpingKernelPtr = control.getWarpingKernel();
    try {
        warpingKernelPtr->shrinkBBox(srcImage.getBBox(image::LOCAL));
    } catch (lsst::pex::exceptions::InvalidParameterError const &) {
        for (int y = 0, height = destImage.getHeight(); y < height; ++y) {
            for (typename DestImageT::x_iterator destPtr = destImage.row_begin(y), end = destImage.row_end(y);
                 destPtr != end; ++destPtr) {
                *destPtr = padValue;
            }
        }
        return 0;
    }
    int interpLength = control.getInterpLength();
 
    std::shared_ptr<LanczosWarpingKernel const> const lanczosKernelPtr =
            std::dynamic_pointer_cast<LanczosWarpingKernel>(warpingKernelPtr);
 
    int numGoodPixels = 0;
 
    // compute a transform from local destination pixels to parent source pixels
    auto const parentDestToParentSrc = srcToDest.inverted();
    std::vector<double> const localDestToParentDestVec = {static_cast<double>(destImage.getX0()),
                                                          static_cast<double>(destImage.getY0())};
    auto const localDestToParentDest = geom::TransformPoint2ToPoint2(ast::ShiftMap(localDestToParentDestVec));
    auto const localDestToParentSrc = localDestToParentDest.then(*parentDestToParentSrc);
 
    // Get the source MaskedImage and a pixel accessor to it.
    int const srcWidth = srcImage.getWidth();
    int const srcHeight = srcImage.getHeight();
    LOGL_DEBUG("TRACE2.lsst.afw.math.warp", "source image width=%d; height=%d", srcWidth, srcHeight);
 
    int const destWidth = destImage.getWidth();
    int const destHeight = destImage.getHeight();
    LOGL_DEBUG("TRACE2.lsst.afw.math.warp", "remap image width=%d; height=%d", destWidth, destHeight);
 
    // Set each pixel of destExposure's MaskedImage
    LOGL_DEBUG("TRACE3.lsst.afw.math.warp", "Remapping masked image");
 
    int const maxCol = destWidth - 1;
    int const maxRow = destHeight - 1;
 
    detail::WarpAtOnePoint<DestImageT, SrcImageT> warpAtOnePoint(srcImage, control, padValue);
 
    if (interpLength > 0) {
        // Use interpolation. Note that 1 produces the same result as no interpolation
        // but uses this code branch, thus providing an easy way to compare the two branches.
 
        // Estimate for number of horizontal interpolation band edges, to reserve memory in vectors
        int const numColEdges = 2 + ((destWidth - 1) / interpLength);
 
        // A list of edge column indices for interpolation bands;
        // starts at -1, increments by interpLen (except the final interval), and ends at destWidth-1
        std::vector<int> edgeColList;
        edgeColList.reserve(numColEdges);
 
        // A list of 1/column width for horizontal interpolation bands; the first value is garbage.
        // The inverse is used for speed because the values are always multiplied.
        std::vector<double> invWidthList;
        invWidthList.reserve(numColEdges);
 
        // Compute edgeColList and invWidthList
        edgeColList.push_back(-1);
        invWidthList.push_back(0.0);
        for (int prevEndCol = -1; prevEndCol < maxCol; prevEndCol += interpLength) {
            int endCol = prevEndCol + interpLength;
            if (endCol > maxCol) {
                endCol = maxCol;
            }
            edgeColList.push_back(endCol);
            assert(endCol - prevEndCol > 0);
            invWidthList.push_back(1.0 / static_cast<double>(endCol - prevEndCol));
        }
        assert(edgeColList.back() == maxCol);
 
        // A list of delta source positions along the edge columns of the horizontal interpolation bands
        std::vector<lsst::geom::Extent2D> yDeltaSrcPosList(edgeColList.size());
 
        // A cache of pixel positions on the source corresponding to the previous or current row
        // of the destination image.
        // The first value is for column -1 because the previous source position is used to compute relative
        // area To simplify the indexing, use an iterator that starts at begin+1, thus: srcPosView =
        // srcPosList.begin() + 1 srcPosView[col-1] and lower indices are for this row srcPosView[col] and
        // higher indices are for the previous row
        std::vector<lsst::geom::Point2D> srcPosList(1 + destWidth);
        std::vector<lsst::geom::Point2D>::iterator const srcPosView = srcPosList.begin() + 1;
 
        std::vector<lsst::geom::Point2D> endColPosList;
        endColPosList.reserve(numColEdges);
 
        // Initialize srcPosList for row -1
        for (int endCol : edgeColList) {
            endColPosList.emplace_back(lsst::geom::Point2D(endCol, -1));
        }
        auto rightSrcPosList = localDestToParentSrc->applyForward(endColPosList);
        srcPosView[-1] = rightSrcPosList[0];
        for (int colBand = 1, endBand = edgeColList.size(); colBand < endBand; ++colBand) {
            int const prevEndCol = edgeColList[colBand - 1];
            int const endCol = edgeColList[colBand];
            lsst::geom::Point2D leftSrcPos = srcPosView[prevEndCol];
 
            lsst::geom::Extent2D xDeltaSrcPos =
                    (rightSrcPosList[colBand] - leftSrcPos) * invWidthList[colBand];
 
            for (int col = prevEndCol + 1; col <= endCol; ++col) {
                srcPosView[col] = srcPosView[col - 1] + xDeltaSrcPos;
            }
        }
 
        int endRow = -1;
        while (endRow < maxRow) {
            // Next horizontal interpolation band
 
            int prevEndRow = endRow;
            endRow = prevEndRow + interpLength;
            if (endRow > maxRow) {
                endRow = maxRow;
            }
            assert(endRow - prevEndRow > 0);
            double interpInvHeight = 1.0 / static_cast<double>(endRow - prevEndRow);
 
            // Set yDeltaSrcPosList for this horizontal interpolation band
            std::vector<lsst::geom::Point2D> destRowPosList;
            destRowPosList.reserve(edgeColList.size());
            for (int endCol : edgeColList) {
                destRowPosList.emplace_back(lsst::geom::Point2D(endCol, endRow));
            }
            auto bottomSrcPosList = localDestToParentSrc->applyForward(destRowPosList);
            for (int colBand = 0, endBand = edgeColList.size(); colBand < endBand; ++colBand) {
                int endCol = edgeColList[colBand];
                yDeltaSrcPosList[colBand] =
                        (bottomSrcPosList[colBand] - srcPosView[endCol]) * interpInvHeight;
            }
 
            for (int row = prevEndRow + 1; row <= endRow; ++row) {
                typename DestImageT::x_iterator destXIter = destImage.row_begin(row);
                srcPosView[-1] += yDeltaSrcPosList[0];
                for (int colBand = 1, endBand = edgeColList.size(); colBand < endBand; ++colBand) {
                    // Next vertical interpolation band
 
                    int const prevEndCol = edgeColList[colBand - 1];
                    int const endCol = edgeColList[colBand];
 
                    // Compute xDeltaSrcPos; remember that srcPosView contains
                    // positions for this row in prevEndCol and smaller indices,
                    // and positions for the previous row for larger indices (including endCol)
                    lsst::geom::Point2D leftSrcPos = srcPosView[prevEndCol];
                    lsst::geom::Point2D rightSrcPos = srcPosView[endCol] + yDeltaSrcPosList[colBand];
                    lsst::geom::Extent2D xDeltaSrcPos = (rightSrcPos - leftSrcPos) * invWidthList[colBand];
 
                    for (int col = prevEndCol + 1; col <= endCol; ++col, ++destXIter) {
                        lsst::geom::Point2D leftSrcPos = srcPosView[col - 1];
                        lsst::geom::Point2D srcPos = leftSrcPos + xDeltaSrcPos;
                        double relativeArea = computeRelativeArea(srcPos, leftSrcPos, srcPosView[col]);
 
                        srcPosView[col] = srcPos;
 
                        if (warpAtOnePoint(
                                    destXIter, srcPos, relativeArea,
                                    typename image::detail::image_traits<DestImageT>::image_category())) {
                            ++numGoodPixels;
                        }
                    }  // for col
                }      // for col band
            }          // for row
        }              // while next row band
 
    } else {
        // No interpolation
 
        // prevSrcPosList = source positions from the previous row; these are used to compute pixel area;
        // to begin, compute sources positions corresponding to destination row = -1
        std::vector<lsst::geom::Point2D> destPosList;
        destPosList.reserve(1 + destWidth);
        for (int col = -1; col < destWidth; ++col) {
            destPosList.emplace_back(lsst::geom::Point2D(col, -1));
        }
        auto prevSrcPosList = localDestToParentSrc->applyForward(destPosList);
 
        for (int row = 0; row < destHeight; ++row) {
            destPosList.clear();
            for (int col = -1; col < destWidth; ++col) {
                destPosList.emplace_back(lsst::geom::Point2D(col, row));
            }
            auto srcPosList = localDestToParentSrc->applyForward(destPosList);
 
            typename DestImageT::x_iterator destXIter = destImage.row_begin(row);
            for (int col = 0; col < destWidth; ++col, ++destXIter) {
                // column index = column + 1 because the first entry in srcPosList is for column -1
                auto srcPos = srcPosList[col + 1];
                double relativeArea =
                        computeRelativeArea(srcPos, prevSrcPosList[col], prevSrcPosList[col + 1]);
 
                if (warpAtOnePoint(destXIter, srcPos, relativeArea,
                                   typename image::detail::image_traits<DestImageT>::image_category())) {
                    ++numGoodPixels;
                }
            }  // for col
            // move points from srcPosList to prevSrcPosList (we don't care about what ends up in srcPosList
            // because it will be reallocated anyway)
            swap(srcPosList, prevSrcPosList);
        }  // for row
    }      // if interp
 
    return numGoodPixels;
}

wrapApproximate()

void lsst::afw::math::wrapApproximate

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 83 of file _approximate.cc.

                                                                 {
    wrappers.addSignatureDependency("lsst.afw.image");
    declareApproximate(wrappers);
}

wrapBackground()

void lsst::afw::math::wrapBackground

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 162 of file _background.cc.

                                                                {
    // FIXME: review when lsst.afw.image is converted to python wrappers
    wrappers.addInheritanceDependency("lsst.afw.image");
    declareBackground(wrappers);
    declareMakeBackground<image::Image<float>>(wrappers);
    declareMakeBackground<image::MaskedImage<float>>(wrappers);
    wrappers.wrap(
            [](auto &mod) { mod.def("stringToUndersampleStyle", stringToUndersampleStyle, "style"_a); });
}

wrapBoundedField()

void lsst::afw::math::wrapBoundedField

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 97 of file _boundedField.cc.

                                                                  {
    wrappers.addSignatureDependency("lsst.afw.table.io");
    declareBoundedField(wrappers);
}

wrapChebyshevBoundedField()

void lsst::afw::math::wrapChebyshevBoundedField

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 86 of file _chebyshevBoundedField.cc.

                                                                           {
    wrappers.addSignatureDependency("lsst.afw.image");
    declareChebyshevBoundedField(wrappers);
}

wrapConvolveImage()

void lsst::afw::math::wrapConvolveImage

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 94 of file _convolveImage.cc.

                                                                   {
    wrappers.addSignatureDependency("lsst.afw.image");
    declareConvolveImage(wrappers);
    declareAll<double, double>(wrappers);
    declareAll<double, float>(wrappers);
    declareAll<double, int>(wrappers);
    declareAll<double, std::uint16_t>(wrappers);
    declareAll<float, float>(wrappers);
    declareAll<float, int>(wrappers);
    declareAll<float, std::uint16_t>(wrappers);
    declareAll<int, int>(wrappers);
    declareAll<std::uint16_t, std::uint16_t>(wrappers);
}

wrapFunction()

void lsst::afw::math::wrapFunction

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 142 of file _function.cc.

                                                              {
    wrappers.addSignatureDependency("lsst.afw.table.io");
    declareAllFunctions<float>(wrappers, "F");
    declareAllFunctions<double>(wrappers, "D");
}

wrapFunctionLibrary()

void lsst::afw::math::wrapFunctionLibrary

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 220 of file _functionLibrary.cc.

                                                                     {
    wrappers.addInheritanceDependency("lsst.geom");
    declarePolynomialFunctions<float>(wrappers, "F");
    declareChebyshevFunctions<float>(wrappers, "F");
    declareGaussianFunctions<float>(wrappers, "F");
    declareIntegerDeltaFunctions<float>(wrappers, "F");
    declareLanczosFunctions<float>(wrappers, "F");
 
    declarePolynomialFunctions<double>(wrappers, "D");
    declareChebyshevFunctions<double>(wrappers, "D");
    declareGaussianFunctions<double>(wrappers, "D");
    declareIntegerDeltaFunctions<double>(wrappers, "D");
    declareLanczosFunctions<double>(wrappers, "D");
}

wrapGaussianProcess()

void lsst::afw::math::wrapGaussianProcess

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 153 of file _gaussianProcess.cc.

                                                                     {
    declareCovariograms<double>(wrappers, "D");
    declareGaussianProcess<double>(wrappers, "D");
    declareKdTree<double>(wrappers, "D");
}

wrapInterpolate()

void lsst::afw::math::wrapInterpolate

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 38 of file _interpolate.cc.

                                                                 {
    using PyClass = py::class_<Interpolate, std::shared_ptr<Interpolate>>;
 
    auto clsInterpolate = wrappers.wrapType(PyClass(wrappers.module, "Interpolate"), [](auto &mod,
                                                                                        auto &cls) {
        cls.def("interpolate", [](Interpolate &t, double const x) {
            /*
            We use a lambda function here because interpolate (with a double) is a virtual function
            and therefor cannot be wrapped directly.
            */
            return t.interpolate(x);
        });
 
        cls.def("interpolate", (std::vector<double>(Interpolate::*)(std::vector<double> const &) const) &
                                       Interpolate::interpolate);
        cls.def("interpolate",
                (ndarray::Array<double, 1>(Interpolate::*)(ndarray::Array<double const, 1> const &) const) &
                        Interpolate::interpolate);
 
        mod.def("makeInterpolate",
                (std::shared_ptr<Interpolate>(*)(std::vector<double> const &, std::vector<double> const &,
                                                 Interpolate::Style const))makeInterpolate,
                "x"_a, "y"_a, "style"_a = Interpolate::AKIMA_SPLINE);
        mod.def("makeInterpolate",
                (std::shared_ptr<Interpolate>(*)(ndarray::Array<double const, 1> const &,
                                                 ndarray::Array<double const, 1> const &y,
                                                 Interpolate::Style const))makeInterpolate,
                "x"_a, "y"_a, "style"_a = Interpolate::AKIMA_SPLINE);
 
        mod.def("stringToInterpStyle", stringToInterpStyle, "style"_a);
        mod.def("lookupMaxInterpStyle", lookupMaxInterpStyle, "n"_a);
        mod.def("lookupMinInterpPoints", lookupMinInterpPoints, "style"_a);
    });
    wrappers.wrapType(py::enum_<Interpolate::Style>(clsInterpolate, "Style"), [](auto &mod, auto &enm) {
        enm.value("UNKNOWN", Interpolate::Style::UNKNOWN);
        enm.value("CONSTANT", Interpolate::Style::CONSTANT);
        enm.value("LINEAR", Interpolate::Style::LINEAR);
        enm.value("NATURAL_SPLINE", Interpolate::Style::NATURAL_SPLINE);
        enm.value("CUBIC_SPLINE", Interpolate::Style::CUBIC_SPLINE);
        enm.value("CUBIC_SPLINE_PERIODIC", Interpolate::Style::CUBIC_SPLINE_PERIODIC);
        enm.value("AKIMA_SPLINE", Interpolate::Style::AKIMA_SPLINE);
        enm.value("AKIMA_SPLINE_PERIODIC", Interpolate::Style::AKIMA_SPLINE_PERIODIC);
        enm.value("NUM_STYLES", Interpolate::Style::NUM_STYLES);
        enm.export_values();
    });
}

wrapKernel()

void lsst::afw::math::wrapKernel

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 39 of file _kernel.cc.

                                                            {
    using PyKernel = py::class_<Kernel, std::shared_ptr<Kernel>>;
 
    wrappers.addSignatureDependency("lsst.afw.table");
    wrappers.addSignatureDependency("lsst.afw.table.io");
 
    wrappers.wrapType(PyKernel(wrappers.module, "Kernel"), [](auto &mod, auto &cls) {
        lsst::afw::table::io::python::addPersistableMethods<Kernel>(cls);
 
        cls.def("clone", &Kernel::clone);
        cls.def("resized", &Kernel::resized, "width"_a, "height"_a);
        cls.def("computeImage", &Kernel::computeImage, "image"_a, "doNormalize"_a, "x"_a = 0.0, "y"_a = 0.0);
        cls.def("getDimensions", &Kernel::getDimensions);
        cls.def("setDimensions", &Kernel::setDimensions);
        cls.def("setWidth", &Kernel::setWidth);
        cls.def("setHeight", &Kernel::setHeight);
        cls.def("getWidth", &Kernel::getWidth);
        cls.def("getHeight", &Kernel::getHeight);
        cls.def("getCtr", &Kernel::getCtr);
        cls.def("getBBox", &Kernel::getBBox);
        cls.def("getNKernelParameters", &Kernel::getNKernelParameters);
        cls.def("getNSpatialParameters", &Kernel::getNSpatialParameters);
        cls.def("getSpatialFunction", &Kernel::getSpatialFunction);
        cls.def("getSpatialFunctionList", &Kernel::getSpatialFunctionList);
        cls.def("getKernelParameter", &Kernel::getKernelParameter);
        cls.def("getKernelParameters", &Kernel::getKernelParameters);
        cls.def("growBBox", &Kernel::growBBox);
        cls.def("shrinkBBox", &Kernel::shrinkBBox);
        cls.def("setCtr", &Kernel::setCtr);
        cls.def("getSpatialParameters", &Kernel::getSpatialParameters);
        cls.def("isSpatiallyVarying", &Kernel::isSpatiallyVarying);
        cls.def("setKernelParameters",
                (void (Kernel::*)(std::vector<double> const &)) & Kernel::setKernelParameters);
        cls.def("setKernelParameters",
                (void (Kernel::*)(std::pair<double, double> const &)) & Kernel::setKernelParameters);
        cls.def("setSpatialParameters", &Kernel::setSpatialParameters);
        cls.def("computeKernelParametersFromSpatialModel", &Kernel::computeKernelParametersFromSpatialModel);
        cls.def("toString", &Kernel::toString, "prefix"_a = "");
        cls.def("computeCache", &Kernel::computeCache);
        cls.def("getCacheSize", &Kernel::getCacheSize);
    });
 
    using PyFixedKernel = py::class_<FixedKernel, std::shared_ptr<FixedKernel>, Kernel>;
    wrappers.wrapType(PyFixedKernel(wrappers.module, "FixedKernel"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        cls.def(py::init<lsst::afw::image::Image<Kernel::Pixel> const &>(), "image"_a);
        cls.def(py::init<lsst::afw::math::Kernel const &, lsst::geom::Point2D const &>(), "kernel"_a,
                "pos"_a);
        cls.def("clone", &FixedKernel::clone);
        cls.def("resized", &FixedKernel::resized, "width"_a, "height"_a);
        cls.def("toString", &FixedKernel::toString, "prefix"_a = "");
        cls.def("getSum", &FixedKernel::getSum);
        cls.def("isPersistable", &FixedKernel::isPersistable);
    });
 
    using PyAnalyticKernel = py::class_<AnalyticKernel, std::shared_ptr<AnalyticKernel>, Kernel>;
    wrappers.wrapType(PyAnalyticKernel(wrappers.module, "AnalyticKernel"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        // Workaround for NullSpatialFunction and py::arg not playing well with Citizen (TODO: no longer
        // needed?)
        cls.def(py::init<int, int, AnalyticKernel::KernelFunction const &>(), "width"_a, "height"_a,
                "kernelFunction"_a);
        cls.def(py::init<int, int, AnalyticKernel::KernelFunction const &, Kernel::SpatialFunction const &>(),
                "width"_a, "height"_a, "kernelFunction"_a, "spatialFunction"_a);
        cls.def(py::init<int, int, AnalyticKernel::KernelFunction const &,
                         std::vector<Kernel::SpatialFunctionPtr> const &>(),
                "width"_a, "height"_a, "kernelFunction"_a, "spatialFunctionList"_a);
        cls.def("clone", &AnalyticKernel::clone);
        cls.def("resized", &AnalyticKernel::resized, "width"_a, "height"_a);
        cls.def("computeImage", &AnalyticKernel::computeImage, "image"_a, "doNormalize"_a, "x"_a = 0.0,
                "y"_a = 0.0);
        cls.def("getKernelParameters", &AnalyticKernel::getKernelParameters);
        cls.def("getKernelFunction", &AnalyticKernel::getKernelFunction);
        cls.def("toString", &AnalyticKernel::toString, "prefix"_a = "");
        cls.def("isPersistable", &AnalyticKernel::isPersistable);
    });
 
    using PyDeltaFunctionKernel =
            py::class_<DeltaFunctionKernel, std::shared_ptr<DeltaFunctionKernel>, Kernel>;
    wrappers.wrapType(
            PyDeltaFunctionKernel(wrappers.module, "DeltaFunctionKernel"), [](auto &mod, auto &cls) {
                cls.def(py::init<int, int, lsst::geom::Point2I const &>(), "width"_a, "height"_a, "point"_a);
                cls.def("clone", &DeltaFunctionKernel::clone);
                cls.def("resized", &DeltaFunctionKernel::resized, "width"_a, "height"_a);
                cls.def("getPixel", &DeltaFunctionKernel::getPixel);
                cls.def("toString", &DeltaFunctionKernel::toString, "prefix"_a = "");
                cls.def("isPersistable", &DeltaFunctionKernel::isPersistable);
            });
 
    using PyLinearCombinationKernel =
            py::class_<LinearCombinationKernel, std::shared_ptr<LinearCombinationKernel>, Kernel>;
    wrappers.wrapType(
            PyLinearCombinationKernel(wrappers.module, "LinearCombinationKernel"), [](auto &mod, auto &cls) {
                cls.def(py::init<>());
                cls.def(py::init<KernelList const &, std::vector<double> const &>(), "kernelList"_a,
                        "kernelParameters"_a);
                cls.def(py::init<KernelList const &, Kernel::SpatialFunction const &>(), "kernelList"_a,
                        "spatialFunction"_a);
                cls.def(py::init<KernelList const &, std::vector<Kernel::SpatialFunctionPtr> const &>(),
                        "kernelList"_a, "spatialFunctionList"_a);
                cls.def("clone", &LinearCombinationKernel::clone);
                cls.def("resized", &LinearCombinationKernel::resized, "width"_a, "height"_a);
                cls.def("getKernelParameters", &LinearCombinationKernel::getKernelParameters);
                cls.def("getKernelList", &LinearCombinationKernel::getKernelList);
                cls.def("getKernelSumList", &LinearCombinationKernel::getKernelSumList);
                cls.def("getNBasisKernels", &LinearCombinationKernel::getNBasisKernels);
                cls.def("checkKernelList", &LinearCombinationKernel::checkKernelList);
                cls.def("isDeltaFunctionBasis", &LinearCombinationKernel::isDeltaFunctionBasis);
                cls.def("refactor", &LinearCombinationKernel::refactor);
                cls.def("toString", &LinearCombinationKernel::toString, "prefix"_a = "");
                cls.def("isPersistable", &LinearCombinationKernel::isPersistable);
            });
 
    using PySeparableKernel = py::class_<SeparableKernel, std::shared_ptr<SeparableKernel>, Kernel>;
    wrappers.wrapType(PySeparableKernel(wrappers.module, "SeparableKernel"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        // Workaround for NullSpatialFunction and py::arg not playing well with Citizen (TODO: no longer
        // needed?)
        cls.def(py::init<int, int, SeparableKernel::KernelFunction const &,
                         SeparableKernel::KernelFunction const &>(),
                "width"_a, "height"_a, "kernelColFunction"_a, "kernelRowFunction"_a);
        cls.def(py::init<int, int, SeparableKernel::KernelFunction const &,
                         SeparableKernel::KernelFunction const &, Kernel::SpatialFunction const &>(),
                "width"_a, "height"_a, "kernelColFunction"_a, "kernelRowFunction"_a, "spatialFunction"_a);
        cls.def(py::init<int, int, SeparableKernel::KernelFunction const &,
                         SeparableKernel::KernelFunction const &,
                         std::vector<Kernel::SpatialFunctionPtr> const &>(),
                "width"_a, "height"_a, "kernelColFunction"_a, "kernelRowFunction"_a, "spatialFunctionList"_a);
        cls.def("clone", &SeparableKernel::clone);
        cls.def("resized", &SeparableKernel::resized, "width"_a, "height"_a);
        cls.def("computeVectors", &SeparableKernel::computeVectors);
        cls.def("getKernelParameter", &SeparableKernel::getKernelParameter);
        cls.def("getKernelParameters", &SeparableKernel::getKernelParameters);
        cls.def("getKernelColFunction", &SeparableKernel::getKernelColFunction);
        cls.def("getKernelRowFunction", &SeparableKernel::getKernelRowFunction);
        cls.def("toString", &SeparableKernel::toString, "prefix"_a = "");
        cls.def("computeCache", &SeparableKernel::computeCache);
        cls.def("getCacheSize", &SeparableKernel::getCacheSize);
    });
}

wrapLeastSquares()

void lsst::afw::math::wrapLeastSquares

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 80 of file _leastSquares.cc.

                                                                  {
    declareLeastSquares<double, double, 0, 0>(wrappers);
}

wrapMinimize()

void lsst::afw::math::wrapMinimize

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 60 of file _minimize.cc.

                                                              {
    declareMinimize(wrappers);
    declareFitResults<double>(wrappers);
    declareFitResults<float>(wrappers);
}

wrapOffsetImage()

void lsst::afw::math::wrapOffsetImage

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 74 of file _offsetImage.cc.

                                                                 {
    using MaskPixel = lsst::afw::image::MaskPixel;
    wrappers.addSignatureDependency("lsst.afw.image");
 
    declareOffsetImage<lsst::afw::image::Image<int>>(wrappers);
    declareOffsetImage<lsst::afw::image::Image<float>>(wrappers);
    declareOffsetImage<lsst::afw::image::Image<double>>(wrappers);
    declareOffsetImage<lsst::afw::image::MaskedImage<int>>(wrappers);
    declareOffsetImage<lsst::afw::image::MaskedImage<float>>(wrappers);
    declareOffsetImage<lsst::afw::image::MaskedImage<double>>(wrappers);
 
    declareRotateImageBy90<lsst::afw::image::Image<std::uint16_t>>(wrappers);
    declareRotateImageBy90<lsst::afw::image::Image<int>>(wrappers);
    declareRotateImageBy90<lsst::afw::image::Image<float>>(wrappers);
    declareRotateImageBy90<lsst::afw::image::Image<double>>(wrappers);
    declareRotateImageBy90<lsst::afw::image::MaskedImage<std::uint16_t>>(wrappers);
    declareRotateImageBy90<lsst::afw::image::MaskedImage<int>>(wrappers);
    declareRotateImageBy90<lsst::afw::image::MaskedImage<float>>(wrappers);
    declareRotateImageBy90<lsst::afw::image::MaskedImage<double>>(wrappers);
    declareRotateImageBy90<lsst::afw::image::Mask<MaskPixel>>(wrappers);
 
    declareFlipImage<lsst::afw::image::Image<std::uint16_t>>(wrappers);
    declareFlipImage<lsst::afw::image::Image<int>>(wrappers);
    declareFlipImage<lsst::afw::image::Image<float>>(wrappers);
    declareFlipImage<lsst::afw::image::Image<double>>(wrappers);
    declareFlipImage<lsst::afw::image::MaskedImage<std::uint16_t>>(wrappers);
    declareFlipImage<lsst::afw::image::MaskedImage<int>>(wrappers);
    declareFlipImage<lsst::afw::image::MaskedImage<float>>(wrappers);
    declareFlipImage<lsst::afw::image::MaskedImage<double>>(wrappers);
    declareFlipImage<lsst::afw::image::Mask<MaskPixel>>(wrappers);
 
    declareBinImage<lsst::afw::image::Image<std::uint16_t>>(wrappers);
    declareBinImage<lsst::afw::image::Image<int>>(wrappers);
    declareBinImage<lsst::afw::image::Image<float>>(wrappers);
    declareBinImage<lsst::afw::image::Image<double>>(wrappers);
    declareBinImage<lsst::afw::image::MaskedImage<std::uint16_t>>(wrappers);
    declareBinImage<lsst::afw::image::MaskedImage<int>>(wrappers);
    declareBinImage<lsst::afw::image::MaskedImage<float>>(wrappers);
    declareBinImage<lsst::afw::image::MaskedImage<double>>(wrappers);
}

wrapPixelAreaBoundedField()

void lsst::afw::math::wrapPixelAreaBoundedField

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 37 of file _pixelAreaBoundedField.cc.

                                                                           {
    wrappers.wrapType(PyClass(wrappers.module, "PixelAreaBoundedField"), [](auto &mod, auto &cls) {
        cls.def(py::init<lsst::geom::Box2I const &, std::shared_ptr<afw::geom::SkyWcs const>,
                         lsst::geom::AngleUnit const &, double>(),
                "bbox"_a, "skyWcs"_a, "unit"_a = lsst::geom::radians, "scaling"_a = 1.0);
        // All other operations are wrapped by the BoundedField base class.
    });
}

wrapProductBoundedField()

void lsst::afw::math::wrapProductBoundedField

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 37 of file _productBoundedField.cc.

                                                                         {
    wrappers.wrapType(PyClass(wrappers.module, "ProductBoundedField"), [](auto &mod, auto &cls) {
        cls.def(py::init<std::vector<std::shared_ptr<BoundedField const>>>());
        // All other operations are wrapped by the BoundedField base class.
    });
}

wrapRandom()

void lsst::afw::math::wrapRandom

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 103 of file _random.cc.

                                                            {
    wrappers.addSignatureDependency("lsst.afw.image");
    declareRandom(wrappers);
    declareRandomImage<lsst::afw::image::Image<double>>(wrappers);
    declareRandomImage<lsst::afw::image::Image<float>>(wrappers);
}

wrapSpatialCell()

void lsst::afw::math::wrapSpatialCell

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 262 of file _spatialCell.cc.

                                                                 {
    declareSpatialCellCandidate(wrappers);
    declareSpatialCellCandidateIterator(wrappers);
    declareSpatialCell(wrappers);
    declareSpatialCellSet(wrappers);
    declareCandidateVisitor(wrappers);
    declareSpatialCellImageCandidate(wrappers);
    /* Test Members */
    declareTestClasses(wrappers);
}

wrapStack()

void lsst::afw::math::wrapStack

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 113 of file _stack.cc.

                                                           {
    wrappers.addSignatureDependency("lsst.afw.image");
    declareStatisticsStack<float>(wrappers);
    declareStatisticsStack<double>(wrappers);
}

wrapStatistics()

void lsst::afw::math::wrapStatistics

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 146 of file _statistics.cc.

                                                                {
    wrappers.addSignatureDependency("lsst.afw.image");
    declareStatistics(wrappers);
    declareStatistics<unsigned short>(wrappers);
    declareStatistics<double>(wrappers);
    declareStatistics<float>(wrappers);
    declareStatistics<int>(wrappers);
    // Declare vector overloads separately to prevent casting errors
    // that otherwise (mysteriously) occur when overloads are tried
    // in order.
    declareStatisticsVectorOverloads<unsigned short>(wrappers);
    declareStatisticsVectorOverloads<double>(wrappers);
    declareStatisticsVectorOverloads<float>(wrappers);
    declareStatisticsVectorOverloads<int>(wrappers);
}

wrapTransformBoundedField()

void lsst::afw::math::wrapTransformBoundedField

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 64 of file _transformBoundedField.cc.

                                                                           {
    wrappers.addSignatureDependency("lsst.afw.table.io");
    declareTransformBoundedField(wrappers);
}

wrapWarpExposure()

void lsst::afw::math::wrapWarpExposure

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 168 of file _warpExposure.cc.

                                                                  {
    wrappers.addSignatureDependency("lsst.afw.image");
    wrappers.addSignatureDependency("lsst.afw.geom.skyWcs");
 
    declareWarpExposure(wrappers);
    declareWarpingKernel<LanczosWarpingKernel>(wrappers, "LanczosWarpingKernel");
    declareSimpleWarpingKernel<BilinearWarpingKernel>(wrappers, "BilinearWarpingKernel");
    declareSimpleWarpingKernel<NearestWarpingKernel>(wrappers, "NearestWarpingKernel");
    declareWarpingFunctions<double, double>(wrappers);
    declareWarpingFunctions<double, float>(wrappers);
    declareWarpingFunctions<double, int>(wrappers);
    declareWarpingFunctions<double, std::uint16_t>(wrappers);
    declareWarpingFunctions<float, float>(wrappers);
    declareWarpingFunctions<float, int>(wrappers);
    declareWarpingFunctions<float, std::uint16_t>(wrappers);
    declareWarpingFunctions<int, int>(wrappers);
    declareWarpingFunctions<std::uint16_t, std::uint16_t>(wrappers);
}

Variable Documentation

DEFABSERR

double const lsst::afw::math::DEFABSERR = 1.e-15

Definition at line 238 of file Integrate.h.

DEFRELERR

double const lsst::afw::math::DEFRELERR = 1.e-6

Definition at line 239 of file Integrate.h.

deltafunction_kernel_tag_

deltafunction_kernel_tag lsst::afw::math::deltafunction_kernel_tag_

Used as default value in argument lists.

Definition at line 43 of file Kernel.cc.

generic_kernel_tag_

generic_kernel_tag lsst::afw::math::generic_kernel_tag_

Used as default value in argument lists.

Definition at line 42 of file Kernel.cc.

IS_NOTHROW_INIT

template<typename T >

bool constexpr lsst::afw::math::IS_NOTHROW_INIT = noexcept(static_cast<T>(1.0))

constexpr

Test that a Function's return value is nothrow-castable to T.

std::complex is an example of a numeric type that does not satisfy this requirement.

Definition at line 51 of file Function.h.

MOCK_INF

double const lsst::afw::math::MOCK_INF = 1.e10

Definition at line 137 of file Integrate.h.