lsst::afw::math Namespace Reference

Namespaces
	detail
	details
	warper

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

Typedefs
typedef std::vector < boost::shared_ptr< Kernel > >	KernelList
typedef lsst::afw::image::VariancePixel	WeightPixel

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 }
	control what is calculated More...

Functions
template<typename PixelT >
boost::shared_ptr< Approximate < PixelT > >	makeApproximate (std::vector< double > const &x, std::vector< double > const &y, image::MaskedImage< PixelT > const &im, geom::Box2I const &bbox, ApproximateControl const &ctrl)
	A factory function to make Approximate objects. More...
UndersampleStyle	stringToUndersampleStyle (std::string const &style)
	Conversion function to switch a string to an UndersampleStyle. More...
template<typename ImageT >
boost::shared_ptr< ImageT >	binImage (ImageT const &in, int const binsize, lsst::afw::math::Property const flags)
template<typename ImageT >
boost::shared_ptr< ImageT >	binImage (ImageT const &in, int const binX, int const binY, lsst::afw::math::Property const flags)
boost::shared_ptr< BoundedField >	operator* (double const scale, boost::shared_ptr< BoundedField const > bf)
Interpolate::Style	stringToInterpStyle (std::string const &style)
	Conversion function to switch a string to an Interpolate::Style. More...
Interpolate::Style	lookupMaxInterpStyle (int const n)
	Get the highest order Interpolation::Style available for 'n' points. More...
int	lookupMinInterpPoints (Interpolate::Style const style)
	Get the minimum number of points needed to use the requested interpolation style. More...
boost::shared_ptr< Interpolate >	makeInterpolate (std::vector< double > const &x, std::vector< double > const &y, Interpolate::Style const style)
	A factory function to make Interpolate objects. More...
boost::shared_ptr< Interpolate >	makeInterpolate (ndarray::Array< double const, 1 > const &x, ndarray::Array< double const, 1 > const &y, Interpolate::Style const style)
template<typename ImageT >
ImageT::Ptr	offsetImage (ImageT const &inImage, float dx, float dy, std::string const &algorithmName, unsigned int buffer)
	Return an image offset by (dx, dy) using the specified algorithm. More...
template<typename ImageT >
void	randomUniformImage (ImageT *image, Random &rand)
	Set image to random numbers uniformly distributed in the range [0, 1) More...
template<typename ImageT >
void	randomUniformPosImage (ImageT *image, Random &rand)
	Set image to random numbers uniformly distributed in the range (0, 1) More...
template<typename ImageT >
void	randomUniformIntImage (ImageT *image, Random &rand, unsigned long n)
	Set image to random integers uniformly distributed in the range 0 ... More...
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) More...
template<typename ImageT >
void	randomGaussianImage (ImageT *image, Random &rand)
	Set image to random numbers with a gaussian N(0, 1) distribution. More...
template<typename ImageT >
void	randomChisqImage (ImageT *image, Random &rand, double const nu)
	Set image to random numbers with a chi^2_{nu} distribution. More...
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. More...
template<typename ImageT >
ImageT::Ptr	rotateImageBy90 (ImageT const &inImage, int nQuarter)
	Rotate an image by an integral number of quarter turns. More...
template<typename ImageT >
boost::shared_ptr< ImageT >	flipImage (ImageT const &inImage, bool flipLR, bool flipTB)
	Flip an image left–right and/or top–bottom. More...
Statistics	makeStatistics (afwImage::Mask< afwImage::MaskPixel > const &msk, int const flags, StatisticsControl const &sctrl)
	Specialization to handle Masks. More...
template<typename ImageT >
boost::shared_ptr< Background >	makeBackground (ImageT const &img, BackgroundControl const &bgCtrl)
	A convenience function that uses function overloading to make the correct type of Background. More...
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. More...
template<typename OutImageT , typename InImageT >
OutImageT::SinglePixel	convolveAtAPoint (typename InImageT::const_xy_locator inImageLocator, typename lsst::afw::image::Image< lsst::afw::math::Kernel::Pixel >::const_xy_locator kernelLocator, int kWidth, int kHeight)
	Apply convolution kernel to an image at one point. More...
template<typename OutImageT , typename InImageT >
OutImageT::SinglePixel	convolveAtAPoint (typename InImageT::const_xy_locator inImageLocator, std::vector< lsst::afw::math::Kernel::Pixel > const &kernelColList, std::vector< lsst::afw::math::Kernel::Pixel > const &kernelRowList)
	Apply separable convolution kernel to an image at one point. More...
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. More...
template<typename OutImageT , typename InImageT , typename KernelT >
void	convolve (OutImageT &convolvedImage, InImageT const &inImage, KernelT const &kernel, bool doNormalize, bool doCopyEdge=false)
	Old, deprecated version of convolve. More...
template<typename ImageT >
ImageT::SinglePixel	edgePixel (lsst::afw::image::detail::Image_tag)
	Return an off-the-edge pixel appropriate for a given Image type. More...
template<typename MaskedImageT >
MaskedImageT::SinglePixel	edgePixel (lsst::afw::image::detail::MaskedImage_tag)
	Return an off-the-edge pixel appropriate for a given MaskedImage type. More...
template<class UF >
UF::result_type	int1d (UF const &func, IntRegion< typename UF::result_type > &reg, typename UF::result_type const &abserr=DEFABSERR, typename UF::result_type const &relerr=DEFRELERR)
	Front end for the 1d integrator. More...
template<class BF , class YREG >
BF::result_type	int2d (BF const &func, IntRegion< typename BF::result_type > &reg, YREG const &yreg, typename BF::result_type const &abserr=DEFABSERR, typename BF::result_type const &relerr=DEFRELERR)
	Front end for the 2d integrator. More...
template<class TF , class YREG , class ZREG >
TF::result_type	int3d (TF const &func, IntRegion< typename TF::result_type > &reg, YREG const &yreg, ZREG const &zreg, typename TF::result_type const &abserr=DEFABSERR, typename TF::result_type const &relerr=DEFRELERR)
	Front end for the 3d integrator. More...
template<class BF >
BF::result_type	int2d (BF const &func, IntRegion< typename BF::result_type > &reg, IntRegion< typename BF::result_type > &yreg, typename BF::result_type const &abserr=DEFABSERR, typename BF::result_type const &relerr=DEFRELERR)
	Front end for the 2d integrator. More...
template<class TF >
TF::result_type	int3d (TF const &func, IntRegion< typename TF::result_type > &reg, IntRegion< typename TF::result_type > &yreg, IntRegion< typename TF::result_type > &zreg, typename TF::result_type const &abserr=DEFABSERR, typename TF::result_type const &relerr=DEFRELERR)
	Front end for the 3d integrator. More...
template<typename UnaryFunctionT >
UnaryFunctionT::result_type	integrate (UnaryFunctionT func, typename UnaryFunctionT::argument_type const a, typename UnaryFunctionT::argument_type const b, double eps=1.0e-6)
	The 1D integrator. More...
template<typename BinaryFunctionT >
BinaryFunctionT::result_type	integrate2d (BinaryFunctionT func, typename BinaryFunctionT::first_argument_type const x1, typename BinaryFunctionT::first_argument_type const x2, typename BinaryFunctionT::second_argument_type const y1, typename BinaryFunctionT::second_argument_type const y2, double eps=1.0e-6)
	The 2D integrator. More...
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. More...
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)
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)
template<typename PixelT >
lsst::afw::image::Image < PixelT >::Ptr	statisticsStack (std::vector< typename lsst::afw::image::Image< PixelT >::Ptr > &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. More...
template<typename PixelT >
void	statisticsStack (lsst::afw::image::Image< PixelT > &out, std::vector< typename lsst::afw::image::Image< PixelT >::Ptr > &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. More...
template<typename PixelT >
lsst::afw::image::MaskedImage < PixelT >::Ptr	statisticsStack (std::vector< typename lsst::afw::image::MaskedImage< PixelT >::Ptr > &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 MaskedImages. More...
template<typename PixelT >
void	statisticsStack (lsst::afw::image::MaskedImage< PixelT > &out, std::vector< typename lsst::afw::image::MaskedImage< PixelT >::Ptr > &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 MaskedImage. More...
template<typename PixelT >
std::shared_ptr< std::vector < PixelT > >	statisticsStack (std::vector< std::shared_ptr< 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. More...
template<typename PixelT >
lsst::afw::image::MaskedImage < PixelT >::Ptr	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. More...
template<typename PixelT >
lsst::afw::image::MaskedImage < PixelT >::Ptr	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. More...
Property	stringToStatisticsProperty (std::string const property)
	Conversion function to switch a string to a Property (see Statistics.h) More...
boost::shared_ptr < SeparableKernel >	makeWarpingKernel (std::string name)
	Return a warping kernel given its name. More...
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. More...
template<typename DestImageT , typename SrcImageT >
int	warpImage (DestImageT &destImage, lsst::afw::image::Wcs const &destWcs, SrcImageT const &srcImage, lsst::afw::image::Wcs 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. More...
template<typename DestImageT , typename SrcImageT >
int	warpImage (DestImageT &destImage, SrcImageT const &srcImage, lsst::afw::geom::XYTransform const &xyTransform, 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 an XYTransform instead of a pair of WCS to describe the transformation. More...
template<typename DestImageT , typename SrcImageT >
int	warpCenteredImage (DestImageT &destImage, SrcImageT const &srcImage, lsst::afw::geom::LinearTransform const &linearTransform, lsst::afw::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. More...

Variables
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. More...
deltafunction_kernel_tag	deltafunction_kernel_tag_
	Used as default value in argument lists. More...

Typedef Documentation

typedef std::vector<boost::shared_ptr< Kernel > > lsst::afw::math::KernelList

Definition at line 539 of file Kernel.h.

typedef lsst::afw::image::VariancePixel lsst::afw::math::WeightPixel

Definition at line 56 of file Statistics.h.

Enumeration Type Documentation

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.

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

enum lsst::afw::math::UndersampleStyle

Enumerator
THROW_EXCEPTION
REDUCE_INTERP_ORDER
INCREASE_NXNYSAMPLE

Definition at line 50 of file Background.h.

                      {
    THROW_EXCEPTION,
    REDUCE_INTERP_ORDER,
    INCREASE_NXNYSAMPLE
};

Function Documentation

template<typename ImageT >

boost::shared_ptr< ImageT > lsst::afw::math::binImage	(	ImageT const &	in,
		int const	binsize,
		lsst::afw::math::Property const	flags
	)

Parameters

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

Definition at line 41 of file binImage.cc.

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

template<typename ImageT >

boost::shared_ptr< ImageT > lsst::afw::math::binImage	(	ImageT const &	in,
		int const	binX,
		int const	binY,
		lsst::afw::math::Property const	flags
	)

Parameters

in	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 50 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;

    typename ImageT::Ptr out = typename ImageT::Ptr(
        new ImageT(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;
}

template<typename OutImageT , typename InImageT , typename KernelT >

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

Old, deprecated version of convolve.

Deprecated:

This version has no ability to control interpolation parameters.

Parameters

convolvedImage	convolved image; must be the same size as inImage
inImage	image to convolve
kernel	convolution kernel
doNormalize	if true, normalize the kernel, else use "as is"
doCopyEdge	if false (default), set edge pixels to the standard edge pixel; if true, copy edge pixels from input and set EDGE bit of mask

Definition at line 338 of file ConvolveImage.cc.

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

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 131 of file ConvolveImage.h.

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

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

Definition at line 150 of file ConvolveImage.h.

      {
        typedef typename MaskedImageT::Image::Pixel ImagePixelT;
        typedef typename MaskedImageT::Variance::Pixel VariancePixelT;

        return typename MaskedImageT::SinglePixel(
            std::numeric_limits<ImagePixelT>::has_quiet_NaN ?
                std::numeric_limits<ImagePixelT>::quiet_NaN() : 0,
            MaskedImageT::Mask::getPlaneBitMask("NO_DATA"),
            std::numeric_limits<VariancePixelT>::infinity());
    }

template<typename ImageT >

boost::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 101 of file rotateImage.cc.

                       {
    typename ImageT::Ptr 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;
}

template<class UF >

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

inline

Front end for the 1d integrator.

Definition at line 776 of file Integrate.h.

                                                                                        {

    typedef typename UF::result_type UfResult;
    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<UfResult> > children;
        reg.SubDivide(&children);
        integ_dbg2 << "Subdivided into " << children.size() << " children\n";
        UfResult answer = UfResult();
        UfResult err = 0;
        for (size_t i = 0; i<children.size(); i++) {
            IntRegion<UfResult>& 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<UfResult> modreg(1.0/(reg.Right() - 1.0), 0.0, reg.getDbgout());
            intGKP(Aux2<UF>(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<UfResult> modreg(0.0, 1.0/(reg.Left() + 1.0), reg.getDbgout());
            intGKP(Aux1<UF>(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();
    }
}

template<class BF , class YREG >

BF::result_type lsst::afw::math::int2d ( BF const &  func, IntRegion< typename BF::result_type > &  reg, YREG const &  yreg, typename BF::result_type const &  abserr = DEFABSERR, typename BF::result_type const &  relerr = DEFRELERR  )

inline

Front end for the 2d integrator.

Definition at line 837 of file Integrate.h.

                                                                                        {

    using namespace details;
    integ_dbg2 << "Starting int2d: range = ";
    integ_dbg2 << reg.Left() << ".." << reg.Right() << std::endl;
    Int2DAuxType<BF, YREG> faux(func, yreg, abserr*1.0e-3, relerr*1.0e-3);
    typename BF::result_type answer = int1d(faux, reg, abserr, relerr);
    integ_dbg2 << "done int2d  answer = " << answer << " +- " << reg.Err() << std::endl;
    return answer;
}

template<class BF >

BF::result_type lsst::afw::math::int2d ( BF const &  func, IntRegion< typename BF::result_type > &  reg, IntRegion< typename BF::result_type > &  yreg, typename BF::result_type const &  abserr = DEFABSERR, typename BF::result_type const &  relerr = DEFRELERR  )

inline

Front end for the 2d integrator.

Definition at line 878 of file Integrate.h.

                                                                                        {
    using namespace details;
    return int2d(func, reg, ConstantReg1<typename BF::result_type>(yreg), abserr, relerr);
}

template<class TF , class YREG , class ZREG >

TF::result_type lsst::afw::math::int3d ( TF const &  func, IntRegion< typename TF::result_type > &  reg, YREG const &  yreg, ZREG const &  zreg, typename TF::result_type const &  abserr = DEFABSERR, typename TF::result_type const &  relerr = DEFRELERR  )

inline

Front end for the 3d integrator.

Definition at line 857 of file Integrate.h.

                                                                                        {

    using namespace details;
    integ_dbg2 << "Starting int3d: range = ";
    integ_dbg2 << reg.Left() << ".." << reg.Right() << std::endl;
    Int3DAuxType<TF, YREG, ZREG> faux(func, yreg, zreg, abserr*1.e-3, relerr*1.e-3);
    typename TF::result_type answer = int1d(faux, reg, abserr, relerr);
    integ_dbg2 << "done int3d  answer = " << answer << " +- " << reg.Err() << std::endl;
    return answer;
}

template<class TF >

TF::result_type lsst::afw::math::int3d ( TF const &  func, IntRegion< typename TF::result_type > &  reg, IntRegion< typename TF::result_type > &  yreg, IntRegion< typename TF::result_type > &  zreg, typename TF::result_type const &  abserr = DEFABSERR, typename TF::result_type const &  relerr = DEFRELERR  )

inline

Front end for the 3d integrator.

Definition at line 892 of file Integrate.h.

                                                                                        {
    using namespace details;
    return int3d(func, reg, ConstantReg1<typename TF::result_type>(yreg),
                 ConstantReg2<typename TF::result_type>(zreg), abserr, relerr);
}

template<typename UnaryFunctionT >

UnaryFunctionT::result_type lsst::afw::math::integrate	(	UnaryFunctionT	func,
		typename UnaryFunctionT::argument_type const	a,
		typename UnaryFunctionT::argument_type 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 917 of file Integrate.h.

                                                                     {

    typedef typename UnaryFunctionT::argument_type Arg;
    IntRegion<Arg> region(a, b);

    return int1d(func, region, DEFABSERR, eps);
}

template<typename BinaryFunctionT >

BinaryFunctionT::result_type lsst::afw::math::integrate2d	(	BinaryFunctionT	func,
		typename BinaryFunctionT::first_argument_type const	x1,
		typename BinaryFunctionT::first_argument_type const	x2,
		typename BinaryFunctionT::second_argument_type const	y1,
		typename BinaryFunctionT::second_argument_type const	y2,
		double	eps = 1.0e-6
	)

The 2D integrator.

Note

Adapted from RHL's SDSS code

Definition at line 977 of file Integrate.h.

                                                                       {
    using namespace details;
    // note the more stringent eps requirement to ensure the requested limit
    // can be reached.
    FunctionWrapper<BinaryFunctionT> fwrap(func, x1, x2, eps);
    return integrate(fwrap, y1, y2, eps);
}

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 286 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];
    }
}

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 331 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)));
    }
}

template<typename PixelT >

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

A factory function to make Approximate objects.

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 295 of file Approximate.cc.

{
    switch (ctrl.getStyle()) {
      case ApproximateControl::CHEBYSHEV:
        return 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()));
    }
}

template<typename ImageT >

boost::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()

Examples:

spatialCellExample.cc.

Definition at line 467 of file Background.h.

                                                                                   {
    return PTR(Background)(new BackgroundMI(img, bgCtrl));
}

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

A factory function to make Interpolate objects.

Parameters

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

Examples:

splineInterpolate.cc.

Definition at line 375 of file Interpolate.cc.

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

boost::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
	)

Definition at line 388 of file Interpolate.cc.

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

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

related

Specialization to handle Masks.

Note

Although short, the definition can't be in the header as it must follow the specialization definition (g++ complained when this was in the header.)

Parameters

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

Examples:

imageStatistics.cc, and statistics.cc.

Definition at line 1107 of file Statistics.cc.

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

std::shared_ptr< afwMath::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 191 of file warpExposure.cc.

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

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
	)

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
	)

template<typename ImageT >

ImageT::Ptr lsst::afw::math::offsetImage	(	ImageT const &	inImage,
		float	dx,
		float	dy,
		std::string const &	algorithmName,
		unsigned int	buffer
	)

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

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

Parameters

inImage	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.

Definition at line 55 of file offsetImage.cc.

                                  {
    SeparableKernel::Ptr offsetKernel = makeWarpingKernel(algorithmName);

    typename ImageT::Ptr buffImage;
    if (buffer > 0) {
        // Paste input image into buffered image
        afwGeom::Extent2I const &dims = inImage.getDimensions();
        typename ImageT::Ptr buffered(new ImageT(dims.getX() + 2 * buffer, dims.getY() + 2 * buffer));
        buffImage = buffered;
        afwGeom::Box2I box(afwGeom::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());
    }

//    typename ImageT::Ptr convImage(new ImageT(buffImage, true)); // output image, a deep copy
    typename ImageT::Ptr 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->setCtrX(offsetKernel->getCtrX() + 1);
    }
    if (dKerY < 0) {
        offsetKernel->setCtrY(offsetKernel->getCtrY() + 1);
    }

    offsetKernel->setKernelParameters(std::make_pair(dKerX, dKerY));

    convolve(*convImage, *buffImage, *offsetKernel, true, true);

    typename ImageT::Ptr outImage;
    if (buffer > 0) {
        afwGeom::Box2I box(afwGeom::Point2I(buffer, buffer), inImage.getDimensions());
        typename ImageT::Ptr 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(geom::Point2I(inImage.getX0() + dOrigX, inImage.getY0() + dOrigY));

    return outImage;
}

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

Definition at line 103 of file BoundedField.cc.

                                                                            {
    return *bf*scale;
}

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

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

Definition at line 165 of file RandomImage.cc.

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

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

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

Definition at line 143 of file RandomImage.cc.

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

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

image	The image to set
rand	definition of random number algorithm, seed, etc.

Definition at line 155 of file RandomImage.cc.

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

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

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

Definition at line 177 of file RandomImage.cc.

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

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

image	The image to set
rand	definition of random number algorithm, seed, etc.

Definition at line 112 of file RandomImage.cc.

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

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

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

Definition at line 132 of file RandomImage.cc.

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

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

image	The image to set
rand	definition of random number algorithm, seed, etc.

Definition at line 122 of file RandomImage.cc.

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

template<typename ImageT >

ImageT::Ptr lsst::afw::math::rotateImageBy90	(	ImageT const &	inImage,
		int	nQuarter
	)

Rotate an image by an integral number of quarter turns.

Parameters

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

Definition at line 43 of file rotateImage.cc.

                                      {
    typename ImageT::Ptr 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(afwGeom::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(afwGeom::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;
}

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

Exceptions

lsst::pex::exceptions::InvalidParameterError

if outImage is not same dimensions as inImage1 and inImage2.

Parameters

outImage	output image
c1	coefficient for image 1
inImage1	input image 1
c2	coefficient for image 2
inImage2	input image 2

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

    typedef typename InImageT::const_x_iterator InConstXIter;
    typedef typename OutImageT::x_iterator OutXIter;
    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);
        }
    }
}

template<typename PixelT >

lsst::afw::image::Image<PixelT>::Ptr lsst::afw::math::statisticsStack	(	std::vector< typename lsst::afw::image::Image< PixelT >::Ptr > &	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

template<typename PixelT >

void lsst::afw::math::statisticsStack	(	lsst::afw::image::Image< PixelT > &	out,
		std::vector< typename lsst::afw::image::Image< PixelT >::Ptr > &	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

template<typename PixelT >

lsst::afw::image::MaskedImage<PixelT>::Ptr lsst::afw::math::statisticsStack	(	std::vector< typename lsst::afw::image::MaskedImage< PixelT >::Ptr > &	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 MaskedImages.

Parameters

images	MaskedImages to process
flags	statistics requested
sctrl	control structure
wvector	vector containing weights

template<typename PixelT >

void lsst::afw::math::statisticsStack	(	lsst::afw::image::MaskedImage< PixelT > &	out,
		std::vector< typename lsst::afw::image::MaskedImage< PixelT >::Ptr > &	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 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

template<typename PixelT >

std::shared_ptr<std::vector<PixelT> > lsst::afw::math::statisticsStack	(	std::vector< std::shared_ptr< 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

template<typename PixelT >

lsst::afw::image::MaskedImage<PixelT>::Ptr 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.

template<typename PixelT >

lsst::afw::image::MaskedImage<PixelT>::Ptr 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.

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 263 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];
}

afwMath::Property lsst::afw::math::stringToStatisticsProperty

(

std::string const

property

)

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

Definition at line 717 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;
    }
    return statisticsProperty[property];
}

UndersampleStyle lsst::afw::math::stringToUndersampleStyle

(

std::string const &

style

)

Conversion function to switch a string to an UndersampleStyle.

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

template<typename DestImageT , typename SrcImageT >

int lsst::afw::math::warpCenteredImage	(	DestImageT &	destImage,
		SrcImageT const &	srcImage,
		lsst::afw::geom::LinearTransform const &	linearTransform,
		lsst::afw::geom::Point2D const &	centerPosition,
		afwMath::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 564 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);
    afwGeom::Extent2D cLocal = afwGeom::Extent2D(centerPosition) - afwGeom::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
    afwGeom::AffineTransform affTran(linearTransform, cLocal - linearTransform(cLocal));
    afwGeom::AffineXYTransform affXYTransform(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, affXYTransform, control, padValue);
#endif

    // fix the origin and we're done.
    destImage.setXY0(srcImage.getXY0());

    return n;
}

template<typename DestExposureT , typename SrcExposureT >

int lsst::afw::math::warpExposure	(	DestExposureT &	destExposure,
		SrcExposureT const &	srcExposure,
		afwMath::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 Calib and Filter 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 282 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();
    std::shared_ptr<afwImage::Calib> calibCopy(new afwImage::Calib(*srcExposure.getCalib()));
    destExposure.setCalib(calibCopy);
    destExposure.setFilter(srcExposure.getFilter());
    return warpImage(mi, *destExposure.getWcs(), srcExposure.getMaskedImage(), *srcExposure.getWcs(),
        control, padValue);
}

template<typename DestImageT , typename SrcImageT >

int lsst::afw::math::warpImage	(	DestImageT &	destImage,
		lsst::afw::image::Wcs const &	destWcs,
		SrcImageT const &	srcImage,
		lsst::afw::image::Wcs const &	srcWcs,
		afwMath::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 is srcImage
lsst::pex::exceptions::MemoryError	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.

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 534 of file warpExposure.cc.

  {
    afwGeom::Point2D const destXY0(destImage.getXY0());
    afwImage::XYTransformFromWcsPair xyTransform{destWcs.clone(), srcWcs.clone()};
    afwMath::detail::XYTransformPositionFunctor const computeSrcPos{destXY0, xyTransform};
    return doWarpImage(destImage, srcImage, computeSrcPos, control, padValue);
}

template<typename DestImageT , typename SrcImageT >

int lsst::afw::math::warpImage	(	DestImageT &	destImage,
		SrcImageT const &	srcImage,
		lsst::afw::geom::XYTransform const &	xyTransform,
		afwMath::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 an XYTransform instead of a pair of WCS to describe the transformation.

Parameters

destImage	remapped image
srcImage	source image
xyTransform	xy transform mapping source position to destination position in the forward direction (but only the reverse direction is used)
control	control parameters
padValue	use this value for undefined (edge) pixels

Definition at line 550 of file warpExposure.cc.

  {
    afwGeom::Point2D const destXY0(destImage.getXY0());
    afwMath::detail::XYTransformPositionFunctor const computeSrcPos(destXY0, xyTransform);
    return doWarpImage(destImage, srcImage, computeSrcPos, control, padValue);
}

Variable Documentation

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

Definition at line 260 of file Integrate.h.

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

Definition at line 261 of file Integrate.h.

afwMath::deltafunction_kernel_tag lsst::afw::math::deltafunction_kernel_tag_

Used as default value in argument lists.

Definition at line 45 of file Kernel.cc.

afwMath::generic_kernel_tag lsst::afw::math::generic_kernel_tag_

Used as default value in argument lists.

Definition at line 44 of file Kernel.cc.

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

Definition at line 175 of file Integrate.h.