A BoundedField based on 2-d Chebyshev polynomials of the first kind. More...

#include <ChebyshevBoundedField.h>

Inheritance diagram for lsst::afw::math::ChebyshevBoundedField:

Public Types
using	Control = ChebyshevBoundedFieldControl

Public Member Functions
	ChebyshevBoundedField (lsst::geom::Box2I const &bbox, ndarray::Array< double const, 2, 2 > const &coefficients)
	Initialize the field from its bounding box an coefficients.

	ChebyshevBoundedField (ChebyshevBoundedField const &)

	ChebyshevBoundedField (ChebyshevBoundedField &&)

ChebyshevBoundedField &	operator= (ChebyshevBoundedField const &)=delete

ChebyshevBoundedField &	operator= (ChebyshevBoundedField &&)=delete

	~ChebyshevBoundedField () override

ndarray::Array< double const, 2, 2 >	getCoefficients () const
	Return the coefficient matrix.

std::shared_ptr< ChebyshevBoundedField >	truncate (Control const &ctrl) const
	Return a new ChebyshevBoudedField with maximum orders set by the given control object.

std::shared_ptr< ChebyshevBoundedField >	relocate (lsst::geom::Box2I const &bbox) const
	Return a new ChebyshevBoundedField with domain set to the given bounding box.

double	evaluate (lsst::geom::Point2D const &position) const override
	Evaluate the field at the given point.

double	integrate () const override
	Compute the integral of this function over its bounding-box.

double	mean () const override
	Compute the mean of this function over its bounding-box.

bool	isPersistable () const noexcept override
	ChebyshevBoundedField is always persistable.

std::shared_ptr< BoundedField >	operator* (double const scale) const override
	Return a scaled BoundedField.

bool	operator== (BoundedField const &rhs) const override
	BoundedFields (of the same sublcass) are equal if their bounding boxes and parameters are equal.

double	evaluate (double x, double y) const
	Evaluate the field at the given point.

virtual ndarray::Array< double, 1, 1 >	evaluate (ndarray::Array< double const, 1 > const &x, ndarray::Array< double const, 1 > const &y) const
	Evaluate the field at multiple arbitrary points.

lsst::geom::Box2I	getBBox () const
	Return the bounding box that defines the region where the field is valid.

template<typename T>
void	fillImage (image::Image< T > &image, bool overlapOnly=false, int xStep=1, int yStep=1) const
	Assign the field to an image, overwriting values already present.

template<typename T>
void	addToImage (image::Image< T > &image, double scaleBy=1.0, bool overlapOnly=false, int xStep=1, int yStep=1) const
	Add the field or a constant multiple of it to an image in-place.

template<typename T>
void	multiplyImage (image::Image< T > &image, bool overlapOnly=false, int xStep=1, int yStep=1) const
	Multiply an image by the field in-place.

template<typename T>
void	multiplyImage (image::MaskedImage< T > &image, bool overlapOnly=false) const

template<typename T>
void	divideImage (image::Image< T > &image, bool overlapOnly=false, int xStep=1, int yStep=1) const
	Divide an image by the field in-place.

template<typename T>
void	divideImage (image::MaskedImage< T > &image, bool overlapOnly=false) const

std::shared_ptr< BoundedField >	operator/ (double scale) const

bool	operator!= (BoundedField const &rhs) const
	BoundedFields (of the same sublcass) are equal if their bounding boxes and parameters are equal.

void	writeFits (std::string const &fileName, std::string const &mode="w") const
	Write the object to a regular FITS file.

void	writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
	Write the object to a FITS image in memory.

void	writeFits (fits::Fits &fitsfile) const
	Write the object to an already-open FITS object.

Static Public Member Functions
static std::shared_ptr< ChebyshevBoundedField >	fit (lsst::geom::Box2I const &bbox, ndarray::Array< double const, 1 > const &x, ndarray::Array< double const, 1 > const &y, ndarray::Array< double const, 1 > const &z, Control const &ctrl)
	Fit a Chebyshev approximation to non-gridded data with equal weights.

static std::shared_ptr< ChebyshevBoundedField >	fit (lsst::geom::Box2I const &bbox, ndarray::Array< double const, 1 > const &x, ndarray::Array< double const, 1 > const &y, ndarray::Array< double const, 1 > const &z, ndarray::Array< double const, 1 > const &w, Control const &ctrl)
	Fit a Chebyshev approximation to non-gridded data with unequal weights.

static ndarray::Array< double, 2, 2 >	makeFitMatrix (lsst::geom::Box2I const &bbox, ndarray::Array< double const, 1 > const &x, ndarray::Array< double const, 1 > const &y, Control const &ctrl)
	Construct a matrix that can be used to fit or evaluate a Chebyshev polynomial at a set of points.

template<typename T>
static std::shared_ptr< ChebyshevBoundedField >	fit (image::Image< T > const &image, Control const &ctrl)
	Fit a Chebyshev approximation to gridded data with equal weights.

static std::shared_ptr< ChebyshevBoundedField >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object.

static std::shared_ptr< ChebyshevBoundedField >	readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
	Read an object from a regular FITS file.

static std::shared_ptr< ChebyshevBoundedField >	readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
	Read an object from a FITS file in memory.

static std::shared_ptr< ChebyshevBoundedField >	dynamicCast (std::shared_ptr< Persistable > const &ptr)
	Dynamically cast a shared_ptr.

static std::shared_ptr< BoundedField >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object.

static std::shared_ptr< BoundedField >	readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
	Read an object from a regular FITS file.

static std::shared_ptr< BoundedField >	readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
	Read an object from a FITS file in memory.

static std::shared_ptr< BoundedField >	dynamicCast (std::shared_ptr< Persistable > const &ptr)
	Dynamically cast a shared_ptr.

Protected Types
using	OutputArchiveHandle = io::OutputArchiveHandle

Protected Member Functions
std::string	getPersistenceName () const override
	Return the unique name used to persist this object and look up its factory.

std::string	getPythonModule () const override
	Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

void	write (OutputArchiveHandle &handle) const override
	Write the object to one or more catalogs.

Private Member Functions
std::string	toString () const override

Detailed Description

A BoundedField based on 2-d Chebyshev polynomials of the first kind.

The 2-d Chebyshev polynomial used here is defined as:

\[f(x,y) = \sum_i \sum_j a_{i,j} T_i(x) T_j(y) \]

where \(T_n(x)\) is the n-th order Chebyshev polynomial of \(x\) and \(a_{i,j}\) is the corresponding coefficient of the (i,j) polynomial term.

ChebyshevBoundedField supports fitting to gridded and non-gridded data, as well coefficient matrices with different x- and y-order.

There is currently quite a bit of duplication of functionality between ChebyshevBoundedField, ApproximateChebyshev, and Chebyshev1Function2; the intent is that ChebyshevBoundedField will ultimately replace ApproximateChebyshev and should be preferred over Chebyshev1Function2 when the parametrization interface that is part of the Function2 class is not needed.

Definition at line 76 of file ChebyshevBoundedField.h.

Member Typedef Documentation

◆ Control

using lsst::afw::math::ChebyshevBoundedField::Control = ChebyshevBoundedFieldControl

Definition at line 79 of file ChebyshevBoundedField.h.

◆ OutputArchiveHandle

using lsst::afw::table::io::Persistable::OutputArchiveHandle = io::OutputArchiveHandle

protectedinherited

Definition at line 108 of file Persistable.h.

Constructor & Destructor Documentation

◆ ChebyshevBoundedField() [1/3]

lsst::afw::math::ChebyshevBoundedField::ChebyshevBoundedField	(	lsst::geom::Box2I const &	bbox,
		ndarray::Array< double const, 2, 2 > const &	coefficients )

Initialize the field from its bounding box an coefficients.

This constructor is mostly intended for testing purposes and persistence, but it also provides a way to initialize the object from Chebyshev coefficients derived from some external source.

Note that because the bounding box provided is always an integer bounding box, and LSST convention puts the center of each pixel at an integer, the actual floating-point domain of the Chebyshev functions is lsst::geom::Box2D(bbox), that is, the box that contains the entirety of all the pixels included in the integer bounding box.

The coefficients are ordered [y,x], so the shape is (orderY+1, orderX+1), and the arguments to the Chebyshev functions are transformed such that the region lsst::geom::Box2D(bbox) is mapped to [-1, 1]x[-1, 1].

Example:

bbox = lsst::geom::Box2I(lsst::geom::Point2I(10, 20), lsst::geom::Point2I(30, 40));
ndarray::Array<double, 2, 2> coeffs = ndarray::allocate(ndarray::makeVector(2, 2));
coeffs[0][0] = 1;
coeffs[1][0] = 2;
coeffs[0][1] = 3;
coeffs[1][1] = 4;
ndarray::Array<double, 2, 2> coeffs = ndarray::external(data);
poly = ChebyshevBoundedField(bbox, coeffs);

will result in the following polynomial:

\[f(x,y) = 1 T_0(x) T_0(y) + 2 T_0(x) T_1(y) + 3 T_1(x) T_0(y) + 4 T_1(x) T_1(y) \]

Definition at line 59 of file ChebyshevBoundedField.cc.

        : BoundedField(bbox),
          _toChebyshevRange(makeChebyshevRangeTransform(lsst::geom::Box2D(bbox))),
          _coefficients(coefficients) {}

◆ ChebyshevBoundedField() [2/3]

lsst::afw::math::ChebyshevBoundedField::ChebyshevBoundedField ( ChebyshevBoundedField const & )

default

◆ ChebyshevBoundedField() [3/3]

lsst::afw::math::ChebyshevBoundedField::ChebyshevBoundedField ( ChebyshevBoundedField && )

default

◆ ~ChebyshevBoundedField()

lsst::afw::math::ChebyshevBoundedField::~ChebyshevBoundedField ( )

overridedefault

Member Function Documentation

◆ addToImage()

template<typename T>

template void lsst::afw::math::BoundedField::addToImage	(	image::Image< T > &	image,
		double	scaleBy = 1.0,
		bool	overlapOnly = false,
		int	xStep = 1,
		int	yStep = 1 ) const

inherited

Add the field or a constant multiple of it to an image in-place.

Parameters

[out]	image	Image to add to.
[in]	scaleBy	Multiply the field by this before adding it to the image.
[in]	overlapOnly	If true, only modify the region in the intersection of image.getBBox(image::PARENT) and this->getBBox().
[in]	xStep	Distance between grid points in X to evaluate; values between grid points will be linearly interpolated.
[in]	yStep	Distance between grid points in Y to evaluate; values between grid points will be linearly interpolated.

Exceptions

pex::exceptions::RuntimeError if the bounding boxes do not overlap and overlapOnly=false.

Definition at line 329 of file BoundedField.cc.

                                               {
    applyToImage(*this, img, ScaledAdd(scaleBy), overlapOnly, xStep, yStep);
}

◆ divideImage() [1/2]

template<typename T>

void lsst::afw::math::BoundedField::divideImage	(	image::Image< T > &	image,
		bool	overlapOnly = false,
		int	xStep = 1,
		int	yStep = 1 ) const

inherited

Divide an image by the field in-place.

Parameters

[out]	image	Image to fill.
[in]	overlapOnly	If true, only modify the region in the intersection of image.getBBox(image::PARENT) and this->getBBox().
[in]	xStep	Distance between grid points in X to evaluate; values between grid points will be linearly interpolated.
[in]	yStep	Distance between grid points in Y to evaluate; values between grid points will be linearly interpolated.

Exceptions

pex::exceptions::RuntimeError if the bounding boxes do not overlap and overlapOnly=false.

Definition at line 345 of file BoundedField.cc.

                                                                                               {
    applyToImage(*this, img, Divide(), overlapOnly, xStep, yStep);
}

◆ divideImage() [2/2]

template<typename T>

void lsst::afw::math::BoundedField::divideImage	(	image::MaskedImage< T > &	image,
		bool	overlapOnly = false ) const

inherited

Definition at line 350 of file BoundedField.cc.

                                                                               {
    applyToImage(*this, img, Divide(), overlapOnly, 1, 1);
}

◆ dynamicCast() [1/2]

template std::shared_ptr< meas::extensions::psfex::PsfexPsf > lsst::afw::table::io::PersistableFacade< BoundedField >::dynamicCast ( std::shared_ptr< Persistable > const & ptr )

staticinherited

Dynamically cast a shared_ptr.

Dynamically cast a shared pointer and raise on failure.

You must provide an explicit template instantiation in the .cc file for each class that inherits from PersistableFacade. Designed to work around RTTI issues on macOS with hidden symbols;

Exceptions

lsst::pex::exceptions::LogicError if the cast fails

param[in] ptr The pointer to be cast.

Returns: The cast pointer.

Exceptions

lsst::pex::exceptions::TypeError If the dynamic cast fails.

Definition at line 218 of file Persistable.cc.

                                                                                        {
    auto result = std::dynamic_pointer_cast<T>(ptr);
    if (!result) {
        throw LSST_EXCEPT(pex::exceptions::TypeError, "Dynamic pointer cast failed");
    }
    return result;
}

◆ dynamicCast() [2/2]

template std::shared_ptr< meas::extensions::psfex::PsfexPsf > lsst::afw::table::io::PersistableFacade< ChebyshevBoundedField >::dynamicCast ( std::shared_ptr< Persistable > const & ptr )

staticinherited

Dynamically cast a shared_ptr.

Dynamically cast a shared pointer and raise on failure.

You must provide an explicit template instantiation in the .cc file for each class that inherits from PersistableFacade. Designed to work around RTTI issues on macOS with hidden symbols;

Exceptions

lsst::pex::exceptions::LogicError if the cast fails

param[in] ptr The pointer to be cast.

Returns: The cast pointer.

Exceptions

lsst::pex::exceptions::TypeError If the dynamic cast fails.

Definition at line 218 of file Persistable.cc.

                                                                                        {
    auto result = std::dynamic_pointer_cast<T>(ptr);
    if (!result) {
        throw LSST_EXCEPT(pex::exceptions::TypeError, "Dynamic pointer cast failed");
    }
    return result;
}

◆ evaluate() [1/3]

double lsst::afw::math::BoundedField::evaluate	(	double	x,
		double	y ) const

inline

Evaluate the field at the given point.

This delegates to the evaluate() method that takes lsst::geom::Point2D.

There is no bounds-checking on the given position; this is the responsibility of the user, who can almost always do it more efficiently.

Definition at line 76 of file BoundedField.h.

76{ return evaluate(lsst::geom::Point2D(x, y)); }

lsst::afw::math::ChebyshevBoundedField::evaluate

double evaluate(lsst::geom::Point2D const &position) const override

Evaluate the field at the given point.

Definition ChebyshevBoundedField.cc:296

lsst::geom::Point2D

Point< double, 2 > Point2D

Definition Point.h:324

◆ evaluate() [2/3]

double lsst::afw::math::ChebyshevBoundedField::evaluate ( lsst::geom::Point2D const & position ) const

overridevirtual

Evaluate the field at the given point.

This is the only abstract method to be implemented by subclasses.

Subclasses should not provide bounds checking on the given position; this is the responsibility of the user, who can almost always do it more efficiently.

Implements lsst::afw::math::BoundedField.

Definition at line 296 of file ChebyshevBoundedField.cc.

                                                                            {
    lsst::geom::Point2D p = _toChebyshevRange(position);
    return evaluateFunction1d(RecursionArrayImitator(_coefficients, p.getX()), p.getY(),
                              _coefficients.getSize<0>());
}

◆ evaluate() [3/3]

ndarray::Array< double, 1, 1 > lsst::afw::math::BoundedField::evaluate	(	ndarray::Array< double const, 1 > const &	x,
		ndarray::Array< double const, 1 > const &	y ) const

virtual

Evaluate the field at multiple arbitrary points.

Parameters

[in]	x	array of x coordinates, same shape as y
[in]	y	array of y coordinates, same shape as x

Returns: an array of output values, same shape as x and y

There is no bounds-checking on the given positions; this is the responsibility of the user, who can almost always do it more efficiently.

Reimplemented from lsst::afw::math::BoundedField.

Definition at line 88 of file BoundedField.cc.

                                                                                                  {
    ndarray::Array<double, 1, 1> out = ndarray::allocate(x.getSize<0>());
    for (int i = 0, n = x.getSize<0>(); i < n; ++i) {
        out[i] = evaluate(x[i], y[i]);
    }
    return out;
}

◆ fillImage()

template<typename T>

template void lsst::afw::math::BoundedField::fillImage	(	image::Image< T > &	image,
		bool	overlapOnly = false,
		int	xStep = 1,
		int	yStep = 1 ) const

inherited

Assign the field to an image, overwriting values already present.

Parameters

[out]	image	Image to fill.
[in]	overlapOnly	If true, only modify the region in the intersection of image.getBBox(image::PARENT) and this->getBBox().
[in]	xStep	Distance between grid points in X to evaluate; values between grid points will be linearly interpolated.
[in]	yStep	Distance between grid points in Y to evaluate; values between grid points will be linearly interpolated.

Exceptions

pex::exceptions::RuntimeError if the bounding boxes do not overlap and overlapOnly=false.

Definition at line 324 of file BoundedField.cc.

                                                                                             {
    applyToImage(*this, img, Assign(), overlapOnly, xStep, yStep);
}

◆ fit() [1/3]

template<typename T>

std::shared_ptr< ChebyshevBoundedField > lsst::afw::math::ChebyshevBoundedField::fit	(	image::Image< T > const &	image,
		Control const &	ctrl )

static

Fit a Chebyshev approximation to gridded data with equal weights.

Parameters

[in]	image	The Image containing the data to fit. image.getBBox(PARENT) is used as the bounding box of the BoundedField.
[in]	ctrl	Specifies the orders and triangularity of the coefficient matrix.

Instantiated for float and double.

Note: if the image to be fit is a binned version of the actual image the field should correspond to, call relocate() with the unbinned image's bounding box after fitting.

Definition at line 208 of file ChebyshevBoundedField.cc.

                                                                                       {
    // Initialize the result object, so we can make use of the AffineTransform it builds
    lsst::geom::Box2I bbox = img.getBBox(image::PARENT);
    std::shared_ptr<ChebyshevBoundedField> result(new ChebyshevBoundedField(bbox));
    // This packer object knows how to map the 2-d Chebyshev functions onto a 1-d array,
    // using only those that the control says should have nonzero coefficients.
    Packer const packer(ctrl);
    ndarray::Array<double, 2, 2> matrix = makeMatrix(bbox, result->_toChebyshevRange, packer, ctrl);
    // Flatten the data image into a 1-d vector.
    ndarray::Array<double, 2, 2> imgCopy = ndarray::allocate(img.getArray().getShape());
    imgCopy.deep() = img.getArray();
    ndarray::Array<double const, 1, 1> z = ndarray::flatten<1>(imgCopy);
    // Solve the linear least squares problem.
    LeastSquares lstsq = LeastSquares::fromDesignMatrix(matrix, z, LeastSquares::NORMAL_EIGENSYSTEM);
    // Unpack the solution into a 2-d matrix, with zeros for values we didn't fit.
    result->_coefficients = packer.unpack(lstsq.getSolution());
    return result;
}

◆ fit() [2/3]

std::shared_ptr< ChebyshevBoundedField > lsst::afw::math::ChebyshevBoundedField::fit	(	lsst::geom::Box2I const &	bbox,
		ndarray::Array< double const, 1 > const &	x,
		ndarray::Array< double const, 1 > const &	y,
		ndarray::Array< double const, 1 > const &	z,
		Control const &	ctrl )

static

Fit a Chebyshev approximation to non-gridded data with equal weights.

Parameters

[in]	bbox	Integer bounding box of the resulting approximation. All given points must lie within lsst::geom::Box2D(bbox).
[in]	x	Array of x coordinate values.
[in]	y	Array of y coordinate values.
[in]	z	Array of field values to be fit at each (x,y) point.
[in]	ctrl	Specifies the orders and triangularity of the coefficient matrix.

Definition at line 148 of file ChebyshevBoundedField.cc.

                                                                                       {
    // Initialize the result object, so we can make use of the AffineTransform it builds
    std::shared_ptr<ChebyshevBoundedField> result(new ChebyshevBoundedField(bbox));
    // This packer object knows how to map the 2-d Chebyshev functions onto a 1-d array,
    // using only those that the control says should have nonzero coefficients.
    Packer const packer(ctrl);
    // Create a "design matrix" for the linear least squares problem (A in min||Ax-b||)
    ndarray::Array<double, 2, 2> matrix = makeMatrix(x, y, result->_toChebyshevRange, packer, ctrl);
    // Solve the linear least squares problem.
    LeastSquares lstsq = LeastSquares::fromDesignMatrix(matrix, z, LeastSquares::NORMAL_EIGENSYSTEM);
    // Unpack the solution into a 2-d matrix, with zeros for values we didn't fit.
    result->_coefficients = packer.unpack(lstsq.getSolution());
    return result;
}

◆ fit() [3/3]

std::shared_ptr< ChebyshevBoundedField > lsst::afw::math::ChebyshevBoundedField::fit	(	lsst::geom::Box2I const &	bbox,
		ndarray::Array< double const, 1 > const &	x,
		ndarray::Array< double const, 1 > const &	y,
		ndarray::Array< double const, 1 > const &	z,
		ndarray::Array< double const, 1 > const &	w,
		Control const &	ctrl )

static

Fit a Chebyshev approximation to non-gridded data with unequal weights.

Parameters

[in]	bbox	Integer bounding box of the resulting approximation. All given points must lie within lsst::geom::Box2D(bbox).
[in]	x	Array of x coordinate values.
[in]	y	Array of y coordinate values.
[in]	z	Array of field values to be fit at each (x,y) point.
[in]	w	Array of weights for each point in the fit. For points with Gaussian noise, w = 1/sigma.
[in]	ctrl	Specifies the orders and triangularity of the coefficient matrix.

Definition at line 167 of file ChebyshevBoundedField.cc.

                                                                                       {
    // Initialize the result object, so we can make use of the AffineTransform it builds
    std::shared_ptr<ChebyshevBoundedField> result(new ChebyshevBoundedField(bbox));
    // This packer object knows how to map the 2-d Chebyshev functions onto a 1-d array,
    // using only those that the control says should have nonzero coefficients.
    Packer const packer(ctrl);
    // Create a "design matrix" for the linear least squares problem ('A' in min||Ax-b||)
    ndarray::Array<double, 2, 2> matrix = makeMatrix(x, y, result->_toChebyshevRange, packer, ctrl);
    // We want to do weighted least squares, so we multiply both the data vector 'b' and the
    // matrix 'A' by the weights.
    ndarray::asEigenArray(matrix).colwise() *= ndarray::asEigenArray(w);
    ndarray::Array<double, 1, 1> wz = ndarray::copy(z);
    ndarray::asEigenArray(wz) *= ndarray::asEigenArray(w);
    // Solve the linear least squares problem.
    LeastSquares lstsq = LeastSquares::fromDesignMatrix(matrix, wz, LeastSquares::NORMAL_EIGENSYSTEM);
    // Unpack the solution into a 2-d matrix, with zeros for values we didn't fit.
    result->_coefficients = packer.unpack(lstsq.getSolution());
    return result;
}

◆ getBBox()

lsst::geom::Box2I lsst::afw::math::BoundedField::getBBox ( ) const

inlineinherited

Return the bounding box that defines the region where the field is valid.

Because this is an integer bounding box, its minimum and maximum positions are the centers of the pixels where the field is valid, but the field can be assumed to be valid to the edges of those pixels, which is the boundary you'd get by converting the returned lsst::geom::Box2I into a lsst::geom::Box2D.

Definition at line 113 of file BoundedField.h.

113{ return _bbox; }

◆ getCoefficients()

ndarray::Array< double const, 2, 2 > lsst::afw::math::ChebyshevBoundedField::getCoefficients ( ) const

inline

Return the coefficient matrix.

The coefficients are ordered [y,x], so the shape is (orderY+1, orderX+1).

Definition at line 203 of file ChebyshevBoundedField.h.

203{ return _coefficients; }

◆ getPersistenceName()

std::string lsst::afw::math::ChebyshevBoundedField::getPersistenceName ( ) const

overrideprotectedvirtual

Return the unique name used to persist this object and look up its factory.

Must be less than ArchiveIndexSchema::MAX_NAME_LENGTH characters.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 372 of file ChebyshevBoundedField.cc.

                                                          {
    return getChebyshevBoundedFieldPersistenceName();
}

◆ getPythonModule()

std::string lsst::afw::math::ChebyshevBoundedField::getPythonModule ( ) const

overrideprotectedvirtual

Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

Must be less than ArchiveIndexSchema::MAX_MODULE_LENGTH characters.

Will be ignored if empty.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 376 of file ChebyshevBoundedField.cc.

376{ return "lsst.afw.math"; }

◆ integrate()

double lsst::afw::math::ChebyshevBoundedField::integrate ( ) const

overridevirtual

Compute the integral of this function over its bounding-box.

Returns: The value of the integral.

Reimplemented from lsst::afw::math::BoundedField.

Definition at line 311 of file ChebyshevBoundedField.cc.

                                              {
    double result = 0;
    double determinant = getBBox().getArea() / 4.0;
    for (ndarray::Size j = 0; j < _coefficients.getSize<0>(); j++) {
        for (ndarray::Size i = 0; i < _coefficients.getSize<1>(); i++) {
            result += _coefficients[j][i] * integrateTn(i) * integrateTn(j);
        }
    }
    return result * determinant;
}

◆ isPersistable()

bool lsst::afw::math::ChebyshevBoundedField::isPersistable ( ) const

inlineoverridevirtualnoexcept

ChebyshevBoundedField is always persistable.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 228 of file ChebyshevBoundedField.h.

228{ return true; }

◆ makeFitMatrix()

ndarray::Array< double, 2, 2 > lsst::afw::math::ChebyshevBoundedField::makeFitMatrix	(	lsst::geom::Box2I const &	bbox,
		ndarray::Array< double const, 1 > const &	x,
		ndarray::Array< double const, 1 > const &	y,
		Control const &	ctrl )

static

Construct a matrix that can be used to fit or evaluate a Chebyshev polynomial at a set of points.

Parameters

[in]	bbox	Integer bounding box of the resulting approximation. All given points must lie within lsst::geom::Box2D(bbox).
[in]	x	Array of x coordinate values.
[in]	y	Array of y coordinate values (same size as `x`).
[in]	ctrl	Specifies the orders and triangularity of the coefficient matrix.

Returns: A matrix with shape (x.size(), ctrl.computeSize()). The order of coefficients is unspecified, but will always be the same for the same ctrl (so you can make one matrix to fit coefficients from some points, and another to evaluate the polynomial at other points).

Definition at line 192 of file ChebyshevBoundedField.cc.

  {
    // Initialize a temporary result object, so we can make use of the AffineTransform it builds
    std::shared_ptr<ChebyshevBoundedField> result(new ChebyshevBoundedField(bbox));
    // This packer object knows how to map the 2-d Chebyshev functions onto a 1-d array,
    // using only those that the control says should have nonzero coefficients.
    Packer const packer(ctrl);
    // Create a "design matrix" for the linear least squares problem (A in min||Ax-b||)
    return makeMatrix(x, y, result->_toChebyshevRange, packer, ctrl);
}

◆ mean()

double lsst::afw::math::ChebyshevBoundedField::mean ( ) const

overridevirtual

Compute the mean of this function over its bounding-box.

Returns: The value of the mean.

Reimplemented from lsst::afw::math::BoundedField.

Definition at line 322 of file ChebyshevBoundedField.cc.

322{ return integrate() / getBBox().getArea(); }

lsst::afw::math::ChebyshevBoundedField::integrate

double integrate() const override

Compute the integral of this function over its bounding-box.

Definition ChebyshevBoundedField.cc:311

◆ multiplyImage() [1/2]

template<typename T>

void lsst::afw::math::BoundedField::multiplyImage	(	image::Image< T > &	image,
		bool	overlapOnly = false,
		int	xStep = 1,
		int	yStep = 1 ) const

inherited

Multiply an image by the field in-place.

Parameters

[out]	image	Image to fill.
[in]	overlapOnly	If true, only modify the region in the intersection of image.getBBox(image::PARENT) and this->getBBox().
[in]	xStep	Distance between grid points in X to evaluate; values between grid points will be linearly interpolated.
[in]	yStep	Distance between grid points in Y to evaluate; values between grid points will be linearly interpolated.

Exceptions

pex::exceptions::RuntimeError if the bounding boxes do not overlap and overlapOnly=false.

Definition at line 335 of file BoundedField.cc.

                                                                                                 {
    applyToImage(*this, img, Multiply(), overlapOnly, xStep, yStep);
}

◆ multiplyImage() [2/2]

template<typename T>

void lsst::afw::math::BoundedField::multiplyImage	(	image::MaskedImage< T > &	image,
		bool	overlapOnly = false ) const

inherited

Definition at line 340 of file BoundedField.cc.

                                                                                 {
    applyToImage(*this, img, Multiply(), overlapOnly, 1, 1);
}

◆ operator!=()

bool lsst::afw::math::BoundedField::operator!= ( BoundedField const & rhs ) const

inlineinherited

BoundedFields (of the same sublcass) are equal if their bounding boxes and parameters are equal.

Definition at line 206 of file BoundedField.h.

206{ return !(*this == rhs); };

◆ operator*()

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

overridevirtual

Return a scaled BoundedField.

Parameters

[in] scale Scaling factor

Implements lsst::afw::math::BoundedField.

Definition at line 390 of file ChebyshevBoundedField.cc.

                                                                                     {
    return std::make_shared<ChebyshevBoundedField>(getBBox(), ndarray::copy(getCoefficients() * scale));
}

◆ operator/()

std::shared_ptr< BoundedField > lsst::afw::math::BoundedField::operator/ ( double scale ) const

inlineinherited

Definition at line 201 of file BoundedField.h.

201{ return (*this) * (1.0 / scale); }

lsst::afw.display.ds9.scale

scale(algorithm, min, max=None, frame=None)

Definition ds9.py:108

◆ operator=() [1/2]

ChebyshevBoundedField & lsst::afw::math::ChebyshevBoundedField::operator= ( ChebyshevBoundedField && )

delete

◆ operator=() [2/2]

ChebyshevBoundedField & lsst::afw::math::ChebyshevBoundedField::operator= ( ChebyshevBoundedField const & )

delete

◆ operator==()

bool lsst::afw::math::ChebyshevBoundedField::operator== ( BoundedField const & rhs ) const

overridevirtual

BoundedFields (of the same sublcass) are equal if their bounding boxes and parameters are equal.

Implements lsst::afw::math::BoundedField.

Definition at line 394 of file ChebyshevBoundedField.cc.

                                                                    {
    auto rhsCasted = dynamic_cast<ChebyshevBoundedField const*>(&rhs);
    if (!rhsCasted) return false;
 
    return (getBBox() == rhsCasted->getBBox()) &&
           (_coefficients.getShape() == rhsCasted->_coefficients.getShape()) &&
           all(equal(_coefficients, rhsCasted->_coefficients));
}

◆ readFits() [1/6]

static std::shared_ptr< BoundedField > lsst::afw::table::io::PersistableFacade< BoundedField >::readFits ( fits::Fits & fitsfile )

inlinestaticinherited

Read an object from an already open FITS object.

Parameters

[in] fitsfile FITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

                                                         {
        return dynamicCast(Persistable::_readFits(fitsfile));
    }

◆ readFits() [2/6]

static std::shared_ptr< BoundedField > lsst::afw::table::io::PersistableFacade< BoundedField >::readFits	(	fits::MemFileManager &	manager,
		int	hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a FITS file in memory.

Parameters

[in]	manager	Manager for the memory to read from.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 205 of file Persistable.h.

                                                                                             {
        return dynamicCast(Persistable::_readFits(manager, hdu));
    }

◆ readFits() [3/6]

static std::shared_ptr< BoundedField > lsst::afw::table::io::PersistableFacade< BoundedField >::readFits	(	std::string const &	fileName,
		int	hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a regular FITS file.

Parameters

[in]	fileName	Name of the file to read.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 194 of file Persistable.h.

                                                                                           {
        return dynamicCast(Persistable::_readFits(fileName, hdu));
    }

◆ readFits() [4/6]

static std::shared_ptr< ChebyshevBoundedField > lsst::afw::table::io::PersistableFacade< ChebyshevBoundedField >::readFits ( fits::Fits & fitsfile )

inlinestaticinherited

Read an object from an already open FITS object.

Parameters

[in] fitsfile FITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

                                                         {
        return dynamicCast(Persistable::_readFits(fitsfile));
    }

◆ readFits() [5/6]

static std::shared_ptr< ChebyshevBoundedField > lsst::afw::table::io::PersistableFacade< ChebyshevBoundedField >::readFits	(	fits::MemFileManager &	manager,
		int	hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a FITS file in memory.

Parameters

[in]	manager	Manager for the memory to read from.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 205 of file Persistable.h.

                                                                                             {
        return dynamicCast(Persistable::_readFits(manager, hdu));
    }

◆ readFits() [6/6]

static std::shared_ptr< ChebyshevBoundedField > lsst::afw::table::io::PersistableFacade< ChebyshevBoundedField >::readFits	(	std::string const &	fileName,
		int	hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a regular FITS file.

Parameters

[in]	fileName	Name of the file to read.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 194 of file Persistable.h.

                                                                                           {
        return dynamicCast(Persistable::_readFits(fileName, hdu));
    }

◆ relocate()

std::shared_ptr< ChebyshevBoundedField > lsst::afw::math::ChebyshevBoundedField::relocate ( lsst::geom::Box2I const & bbox ) const

Return a new ChebyshevBoundedField with domain set to the given bounding box.

Because this leaves the coefficients unchanged, it is equivalent to transforming the function by the affine transform that maps the old box to the new one.

Definition at line 254 of file ChebyshevBoundedField.cc.

                                                                                                    {
    return std::make_shared<ChebyshevBoundedField>(bbox, _coefficients);
}

◆ toString()

std::string lsst::afw::math::ChebyshevBoundedField::toString ( ) const

overrideprivatevirtual

Implements lsst::afw::math::BoundedField.

Definition at line 403 of file ChebyshevBoundedField.cc.

                                                {
    std::ostringstream os;
    os << "ChebyshevBoundedField (" << _coefficients.getShape() << " coefficients in y,x)";
    return os.str();
}

◆ truncate()

std::shared_ptr< ChebyshevBoundedField > lsst::afw::math::ChebyshevBoundedField::truncate ( Control const & ctrl ) const

Return a new ChebyshevBoudedField with maximum orders set by the given control object.

Definition at line 230 of file ChebyshevBoundedField.cc.

                                                                                              {
    if (static_cast<std::size_t>(ctrl.orderX) >= _coefficients.getSize<1>()) {
        throw LSST_EXCEPT(pex::exceptions::LengthError,
                          (boost::format("New x order (%d) exceeds old x order (%d)") % ctrl.orderX %
                           (_coefficients.getSize<1>() - 1))
                                  .str());
    }
    if (static_cast<std::size_t>(ctrl.orderY) >= _coefficients.getSize<0>()) {
        throw LSST_EXCEPT(pex::exceptions::LengthError,
                          (boost::format("New y order (%d) exceeds old y order (%d)") % ctrl.orderY %
                           (_coefficients.getSize<0>() - 1))
                                  .str());
    }
    ndarray::Array<double, 2, 2> coefficients = ndarray::allocate(ctrl.orderY + 1, ctrl.orderX + 1);
    coefficients.deep() = _coefficients[ndarray::view(0, ctrl.orderY + 1)(0, ctrl.orderX + 1)];
    if (ctrl.triangular) {
        Packer packer(ctrl);
        ndarray::Array<double, 1, 1> packed = ndarray::allocate(packer.size);
        packer.pack(packed, coefficients);
        packer.unpack(coefficients, packed);
    }
    return std::make_shared<ChebyshevBoundedField>(getBBox(), coefficients);
}

◆ write()

void lsst::afw::math::ChebyshevBoundedField::write ( OutputArchiveHandle & handle ) const

overrideprotectedvirtual

Write the object to one or more catalogs.

The handle object passed to this function provides an interface for adding new catalogs and adding nested objects to the same archive (while checking for duplicates). See OutputArchiveHandle for more information.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 378 of file ChebyshevBoundedField.cc.

                                                                   {
    PersistenceHelper const keys(_coefficients.getSize<1>(), _coefficients.getSize<0>());
    table::BaseCatalog catalog = handle.makeCatalog(keys.schema);
    std::shared_ptr<table::BaseRecord> record = catalog.addNew();
    record->set(keys.orderX, _coefficients.getSize<1>() - 1);
    record->set(keys.bbox, getBBox());
    (*record)[keys.coefficients].deep() = ndarray::flatten<1>(_coefficients);
    handle.saveCatalog(catalog);
}

◆ writeFits() [1/3]

void lsst::afw::table::io::Persistable::writeFits ( fits::Fits & fitsfile ) const

inherited

Write the object to an already-open FITS object.

Parameters

[in] fitsfile Open FITS object to write to.

Definition at line 18 of file Persistable.cc.

                                                    {
    OutputArchive archive;
    archive.put(this);
    archive.writeFits(fitsfile);
}

◆ writeFits() [2/3]

void lsst::afw::table::io::Persistable::writeFits	(	fits::MemFileManager &	manager,
		std::string const &	mode = "w" ) const

inherited

Write the object to a FITS image in memory.

Parameters

[in]	manager	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 29 of file Persistable.cc.

                                                                                    {
    fits::Fits fitsfile(manager, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

◆ writeFits() [3/3]

void lsst::afw::table::io::Persistable::writeFits	(	std::string const &	fileName,
		std::string const &	mode = "w" ) const

inherited

Write the object to a regular FITS file.

Parameters

[in]	fileName	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 24 of file Persistable.cc.

                                                                                  {
    fits::Fits fitsfile(fileName, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

The documentation for this class was generated from the following files:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/afw/g0485b4d2cb+c8d56b10d4/include/lsst/afw/math/ChebyshevBoundedField.h
/j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/afw/g0485b4d2cb+c8d56b10d4/src/math/ChebyshevBoundedField.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ Control

◆ OutputArchiveHandle

Constructor & Destructor Documentation

◆ ChebyshevBoundedField() [1/3]

◆ ChebyshevBoundedField() [2/3]

◆ ChebyshevBoundedField() [3/3]

◆ ~ChebyshevBoundedField()

Member Function Documentation

◆ addToImage()

◆ divideImage() [1/2]

◆ divideImage() [2/2]

◆ dynamicCast() [1/2]

◆ dynamicCast() [2/2]

◆ evaluate() [1/3]

◆ evaluate() [2/3]

◆ evaluate() [3/3]

◆ fillImage()

◆ fit() [1/3]

◆ fit() [2/3]

◆ fit() [3/3]

◆ getBBox()

◆ getCoefficients()

◆ getPersistenceName()

◆ getPythonModule()

◆ integrate()

◆ isPersistable()

◆ makeFitMatrix()

◆ mean()

◆ multiplyImage() [1/2]

◆ multiplyImage() [2/2]

◆ operator!=()

◆ operator*()

◆ operator/()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ readFits() [1/6]

◆ readFits() [2/6]

◆ readFits() [3/6]

◆ readFits() [4/6]

◆ readFits() [5/6]

◆ readFits() [6/6]

◆ relocate()

◆ toString()

◆ truncate()

◆ write()

◆ writeFits() [1/3]

◆ writeFits() [2/3]

◆ writeFits() [3/3]