LSSTApplications
20.0.0
LSSTDataManagementBasePackage
|
Namespaces | |
background | |
backgroundList | |
chebyshevBoundedFieldConfig | |
chebyshevBoundedFieldContinued | |
convolveImage | |
detail | |
details | |
kernel | |
mathLib | |
spatialCell | |
warper | |
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 |
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 | |
typedef std::vector< std::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, 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. More... | |
UndersampleStyle | stringToUndersampleStyle (std::string const &style) |
Conversion function to switch a string to an UndersampleStyle. More... | |
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. More... | |
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. More... | |
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. More... | |
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. 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 > ®, 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 > ®, 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 > ®, 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 > ®, 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 > ®, 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... | |
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. More... | |
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. 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... | |
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) |
Find the minimum of a function(x) More... | |
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) More... | |
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. More... | |
template<typename ImageT > | |
std::shared_ptr< ImageT > | rotateImageBy90 (ImageT const &image, int nQuarter) |
Rotate an image by an integral number of quarter turns. More... | |
template<typename ImageT > | |
std::shared_ptr< ImageT > | flipImage (ImageT const &inImage, bool flipLR, bool flipTB) |
Flip an image left–right and/or top–bottom. More... | |
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) 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 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. More... | |
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. More... | |
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. More... | |
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. More... | |
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. More... | |
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. More... | |
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. More... | |
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. More... | |
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. More... | |
Property | stringToStatisticsProperty (std::string const property) |
Conversion function to switch a string to a Property (see Statistics.h) More... | |
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) More... | |
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. More... | |
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. More... | |
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. More... | |
Statistics | makeStatistics (lsst::afw::image::Mask< lsst::afw::image::MaskPixel > const &msk, int const flags, StatisticsControl const &sctrl=StatisticsControl()) |
Specialization to handle Masks. More... | |
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. More... | |
template<typename EntryT > | |
Statistics | makeStatistics (std::vector< EntryT > const &v, int const flags, StatisticsControl const &sctrl=StatisticsControl()) |
The makeStatistics() overload to handle std::vector<> More... | |
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<> More... | |
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<> More... | |
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<> More... | |
std::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, 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. More... | |
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. More... | |
template<typename DestImageT , typename SrcImageT > | |
int | warpCenteredImage (DestImageT &destImage, SrcImageT const &srcImage, lsst::geom::LinearTransform const &linearTransform, lsst::geom::Point2D const ¢erPosition, 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... | |
PYBIND11_MODULE (approximate, mod) | |
PYBIND11_MODULE (background, mod) | |
PYBIND11_MODULE (convolveImage, mod) | |
PYBIND11_MODULE (function, mod) | |
template<typename ReturnT > | |
void | declarePolynomialFunctions (py::module &mod, const std::string &suffix) |
template<typename ReturnT > | |
void | declareChebyshevFunctions (py::module &mod, const std::string &suffix) |
template<typename ReturnT > | |
void | declareGaussianFunctions (py::module &mod, const std::string &suffix) |
template<typename ReturnT > | |
void | declareIntegerDeltaFunctions (py::module &mod, const std::string &suffix) |
template<typename ReturnT > | |
void | declareLanczosFunctions (py::module &mod, const std::string &suffix) |
PYBIND11_MODULE (functionLibrary, mod) | |
PYBIND11_MODULE (offsetImage, mod) | |
void | wrapTestClasses (py::module &mod) |
PYBIND11_MODULE (spatialCell, mod) | |
template<typename Pixel > | |
void | declareStatistics (py::module &mod) |
template<typename Pixel > | |
void | declareStatisticsVectorOverloads (py::module &mod) |
PYBIND11_MODULE (statistics, mod) | |
PYBIND11_MODULE (warpExposure, mod) | |
double | integrateTn (int n) |
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. More... | |
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. More... | |
Variables | |
template<typename T > | |
constexpr bool | IS_NOTHROW_INIT = noexcept(static_cast<T>(1.0)) |
Test that a Function's return value is nothrow-castable to T. More... | |
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... | |
Definition at line 58 of file Statistics.h.
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 63 of file Statistics.h.
Enumerator | |
---|---|
THROW_EXCEPTION | |
REDUCE_INTERP_ORDER | |
INCREASE_NXNYSAMPLE |
Definition at line 47 of file Background.h.
std::shared_ptr< ImageT > lsst::afw::math::binImage | ( | ImageT const & | inImage, |
int const | binsize, | ||
lsst::afw::math::Property const | flags = lsst::afw::math::MEAN |
||
) |
inImage | The image to bin |
binsize | Output pixels are binsize*binsize input pixels |
flags | how to generate super-pixels |
Definition at line 38 of file binImage.cc.
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 |
||
) |
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 43 of file binImage.cc.
void lsst::afw::math::convolve | ( | OutImageT & | convolvedImage, |
InImageT const & | inImage, | ||
KernelT const & | kernel, | ||
bool | doNormalize, | ||
bool | doCopyEdge = false |
||
) |
Old, deprecated version of convolve.
[out] | convolvedImage | convolved image; must be the same size as inImage |
[in] | inImage | image to convolve |
[in] | kernel | convolution kernel |
[in] | doNormalize | if true, normalize the kernel, else use "as is" |
[in] | 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 199 of file ConvolveImage.cc.
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:
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:
Convolution has been optimized for the various kinds of kernels, as follows (listed approximately in order of decreasing speed):
Additional convolution functions include:
afw/examples offers programs that time convolution including timeConvolve and timeSpatiallyVaryingConvolve.
[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 |
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 190 of file ConvolveImage.cc.
|
inline |
Apply convolution kernel to an image at one point.
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 277 of file ConvolveImage.h.
|
inline |
Apply separable convolution kernel to an image at one point.
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 313 of file ConvolveImage.h.
void lsst::afw::math::declareChebyshevFunctions | ( | py::module & | mod, |
const std::string & | suffix | ||
) |
Definition at line 75 of file functionLibrary.cc.
void lsst::afw::math::declareGaussianFunctions | ( | py::module & | mod, |
const std::string & | suffix | ||
) |
Definition at line 113 of file functionLibrary.cc.
void lsst::afw::math::declareIntegerDeltaFunctions | ( | py::module & | mod, |
const std::string & | suffix | ||
) |
Definition at line 150 of file functionLibrary.cc.
void lsst::afw::math::declareLanczosFunctions | ( | py::module & | mod, |
const std::string & | suffix | ||
) |
Definition at line 175 of file functionLibrary.cc.
void lsst::afw::math::declarePolynomialFunctions | ( | py::module & | mod, |
const std::string & | suffix | ||
) |
Definition at line 43 of file functionLibrary.cc.
void lsst::afw::math::declareStatistics | ( | py::module & | mod | ) |
Definition at line 36 of file statistics.cc.
void lsst::afw::math::declareStatisticsVectorOverloads | ( | py::module & | mod | ) |
Definition at line 59 of file statistics.cc.
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 218 of file ConvolveImage.h.
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:
lsst::pex::exceptions::LogicError | Thrown if the global mask plane dictionary does not have a NO_DATA bit. |
Definition at line 239 of file ConvolveImage.h.
std::shared_ptr< ImageT > lsst::afw::math::flipImage | ( | ImageT const & | inImage, |
bool | flipLR, | ||
bool | flipTB | ||
) |
Flip an image left–right and/or top–bottom.
inImage | The image to flip |
flipLR | Flip left <--> right? |
flipTB | Flip top <--> bottom? |
Definition at line 92 of file rotateImage.cc.
|
inline |
Front end for the 1d integrator.
Definition at line 765 of file Integrate.h.
|
inline |
Front end for the 2d integrator.
Definition at line 855 of file Integrate.h.
|
inline |
|
inline |
Front end for the 3d integrator.
Definition at line 867 of file Integrate.h.
|
inline |
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.
Definition at line 886 of file Integrate.h.
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 |
||
) |
double lsst::afw::math::integrateTn | ( | int | n | ) |
Definition at line 290 of file ChebyshevBoundedField.cc.
Interpolate::Style lsst::afw::math::lookupMaxInterpStyle | ( | int const | n | ) |
Get the highest order Interpolation::Style available for 'n' points.
n | Number of points |
Definition at line 275 of file Interpolate.cc.
int lsst::afw::math::lookupMinInterpPoints | ( | Interpolate::Style const | style | ) |
Get the minimum number of points needed to use the requested interpolation style.
style | The style in question |
Definition at line 314 of file Interpolate.cc.
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.
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.
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 552 of file Background.h.
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 353 of file Interpolate.cc.
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.
x | the x-values of points |
y | the values at x[] |
style | desired interpolator |
Definition at line 343 of file Interpolate.cc.
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 366 of file Statistics.h.
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.
img | Image (or Image) whose properties we want |
flags | Describe what we want to calculate |
sctrl | Control calculation |
Definition at line 420 of file Statistics.h.
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 354 of file Statistics.h.
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.
msk | Image (or MaskedImage) whose properties we want |
flags | Describe what we want to calculate |
sctrl | Control how things are calculated |
Definition at line 1113 of file Statistics.cc.
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 376 of file Statistics.h.
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 391 of file Statistics.h.
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<>
mv | MaskedVector |
flags | Describe what we want to calculate |
sctrl | Control calculation |
Definition at line 503 of file Statistics.h.
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<>
mv | MaskedVector |
vweights | weights |
flags | Describe what we want to calculate |
sctrl | Control calculation |
Definition at line 520 of file Statistics.h.
Statistics makeStatistics | ( | std::vector< EntryT > const & | v, |
int const | flags, | ||
StatisticsControl const & | sctrl = StatisticsControl() |
||
) |
The makeStatistics() overload to handle std::vector<>
v | Image (or MaskedImage) whose properties we want |
flags | Describe what we want to calculate |
sctrl | Control calculation |
Definition at line 469 of file Statistics.h.
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<>
v | Image (or MaskedImage) whose properties we want |
vweights | Weights |
flags | Describe what we want to calculate |
sctrl | Control calculation |
Definition at line 484 of file Statistics.h.
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:
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):
Definition at line 161 of file warpExposure.cc.
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)
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? |
Uses the Minuit fitting package with a standard definition of chiSq (see MinimizerFunctionBase1).
lsst::pex::exceptions::InvalidParameterError | if any input vector is the wrong length |
To do:
Definition at line 175 of file minimize.cc.
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).
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? |
lsst::pex::exceptions::InvalidParameterError | if any input vector is the wrong length |
To do:
Definition at line 229 of file minimize.cc.
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.
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. |
lsst::pex::exceptions::InvalidParameterError | if the algorithm is invalid |
Definition at line 41 of file offsetImage.cc.
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.
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).
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.
lsst::afw::math::PYBIND11_MODULE | ( | approximate | , |
mod | |||
) |
Definition at line 56 of file approximate.cc.
lsst::afw::math::PYBIND11_MODULE | ( | background | , |
mod | |||
) |
Definition at line 73 of file background.cc.
lsst::afw::math::PYBIND11_MODULE | ( | convolveImage | , |
mod | |||
) |
Definition at line 74 of file convolveImage.cc.
lsst::afw::math::PYBIND11_MODULE | ( | function | , |
mod | |||
) |
Definition at line 143 of file function.cc.
lsst::afw::math::PYBIND11_MODULE | ( | functionLibrary | , |
mod | |||
) |
Definition at line 200 of file functionLibrary.cc.
lsst::afw::math::PYBIND11_MODULE | ( | offsetImage | , |
mod | |||
) |
Definition at line 66 of file offsetImage.cc.
lsst::afw::math::PYBIND11_MODULE | ( | spatialCell | , |
mod | |||
) |
Definition at line 239 of file spatialCell.cc.
lsst::afw::math::PYBIND11_MODULE | ( | statistics | , |
mod | |||
) |
Definition at line 68 of file statistics.cc.
lsst::afw::math::PYBIND11_MODULE | ( | warpExposure | , |
mod | |||
) |
Definition at line 133 of file warpExposure.cc.
void lsst::afw::math::randomChisqImage | ( | ImageT * | image, |
Random & | rand, | ||
double const | nu | ||
) |
Set image to random numbers with a chi^2_{nu} distribution.
[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.
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)
[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.
void lsst::afw::math::randomGaussianImage | ( | ImageT * | image, |
Random & | rand | ||
) |
Set image to random numbers with a gaussian N(0, 1) distribution.
[out] | image | The image to set |
[in,out] | rand | definition of random number algorithm, seed, etc. |
Definition at line 130 of file RandomImage.cc.
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)
[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.
void lsst::afw::math::randomUniformImage | ( | ImageT * | image, |
Random & | rand | ||
) |
Set image to random numbers uniformly distributed in the range [0, 1)
[out] | image | The image to set |
[in,out] | rand | definition of random number algorithm, seed, etc. |
Definition at line 110 of file RandomImage.cc.
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
[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.
void lsst::afw::math::randomUniformPosImage | ( | ImageT * | image, |
Random & | rand | ||
) |
Set image to random numbers uniformly distributed in the range (0, 1)
[out] | image | The image to set |
[in,out] | rand | definition of random number algorithm, seed, etc. |
Definition at line 115 of file RandomImage.cc.
std::shared_ptr< ImageT > lsst::afw::math::rotateImageBy90 | ( | ImageT const & | image, |
int | nQuarter | ||
) |
Rotate an image by an integral number of quarter turns.
image | The image to rotate |
nQuarter | the desired number of quarter turns |
Definition at line 39 of file rotateImage.cc.
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
[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 |
lsst::pex::exceptions::InvalidParameterError | if outImage is not same dimensions as inImage1 and inImage2. |
Definition at line 162 of file ConvolveImage.cc.
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 | ||
) |
std::shared_ptr<image::MaskedImage<PixelT> > lsst::afw::math::statisticsStack | ( | image::Image< PixelT > const & | image, |
Property | flags, | ||
char | dimension, | ||
StatisticsControl const & | sctrl | ||
) |
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 | ||
) |
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 | ||
) |
std::shared_ptr<image::MaskedImage<PixelT> > lsst::afw::math::statisticsStack | ( | image::MaskedImage< PixelT > const & | image, |
Property | flags, | ||
char | dimension, | ||
StatisticsControl const & | sctrl | ||
) |
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
out | Output image |
images | Images to process |
flags | statistics requested |
sctrl | Control structure |
wvector | vector containing weights |
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() |
||
) |
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.
[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.
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
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 |
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() |
||
) |
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 338 of file Stack.cc.
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 | ||
) |
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 | ||
) |
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.
images | Images to process |
flags | statistics requested |
sctrl | Control structure |
wvector | vector containing weights |
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.
[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.
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.
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 |
std::vector<PixelT> lsst::afw::math::statisticsStack | ( | std::vector< std::vector< PixelT >> & | vectors, |
Property | flags, | ||
StatisticsControl const & | sctrl, | ||
WeightVector const & | wvector | ||
) |
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.
vectors | Vectors to process |
flags | statistics requested |
sctrl | control structure |
wvector | vector containing weights |
Interpolate::Style lsst::afw::math::stringToInterpStyle | ( | std::string const & | style | ) |
Conversion function to switch a string to an Interpolate::Style.
style | desired type of interpolation |
Definition at line 257 of file Interpolate.cc.
Property lsst::afw::math::stringToStatisticsProperty | ( | std::string const | property | ) |
Conversion function to switch a string to a Property (see Statistics.h)
Definition at line 747 of file Statistics.cc.
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.
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.
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 510 of file warpExposure.cc.
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().
destExposure | Remapped exposure. Wcs and xy0 are read, MaskedImage is set, and PhotoCalib, Filter 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 238 of file warpExposure.cc.
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.
Algorithm Without Interpolation:
For each integer pixel position in the remapped Exposure:
The scaling of intensity for relative area of source and destination uses two minor approximations:
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.
lsst::pex::exceptions::InvalidParameterError | if destImage overlaps srcImage |
std::bad_alloc | when allocation of CPU memory fails |
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 283 of file warpExposure.cc.
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.
[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 |
Definition at line 291 of file warpExposure.cc.
void lsst::afw::math::wrapTestClasses | ( | py::module & | mod | ) |
<
<
<
<
<
<
Definition at line 156 of file spatialCell.cc.
double const lsst::afw::math::DEFABSERR = 1.e-15 |
Definition at line 272 of file Integrate.h.
double const lsst::afw::math::DEFRELERR = 1.e-6 |
Definition at line 273 of file Integrate.h.
deltafunction_kernel_tag lsst::afw::math::deltafunction_kernel_tag_ |
generic_kernel_tag lsst::afw::math::generic_kernel_tag_ |
|
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.
double const lsst::afw::math::MOCK_INF = 1.e10 |
Definition at line 171 of file Integrate.h.