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
typedef ChebyshevBoundedFieldControl	Control

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

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

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

boost::shared_ptr < ChebyshevBoundedField >	relocate (geom::Box2I const &bbox) const

virtual double	evaluate (geom::Point2D const &position) const

virtual bool	isPersistable () const
	ChebyshevBoundedField is always persistable. More...

virtual boost::shared_ptr < BoundedField >	operator* (double const scale) const

Public Member Functions inherited from lsst::afw::math::BoundedField
double	evaluate (double x, double y) const

ndarray::Array< double, 1, 1 >	evaluate (ndarray::Array< double const, 1 > const &x, ndarray::Array< double const, 1 > const &y) const

geom::Box2I	getBBox () const

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

template<typename T >
void	addToImage (image::Image< T > &image, double scaleBy=1.0, bool overlapOnly=false) const

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

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

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

virtual	~BoundedField ()

Public Member Functions inherited from lsst::afw::table::io::Persistable
void	writeFits (std::string const &fileName, std::string const &mode="w") const
	Write the object to a regular FITS file. More...

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

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

virtual	~Persistable ()

Static Public Member Functions
static boost::shared_ptr < ChebyshevBoundedField >	fit (afw::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. More...

static boost::shared_ptr < ChebyshevBoundedField >	fit (afw::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. More...

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

Static Public Member Functions inherited from lsst::afw::table::io::PersistableFacade< ChebyshevBoundedField >
static boost::shared_ptr < ChebyshevBoundedField >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object. More...

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

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

Static Public Member Functions inherited from lsst::afw::table::io::PersistableFacade< BoundedField >
static boost::shared_ptr < BoundedField >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object. More...

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

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

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

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

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

Protected Member Functions inherited from lsst::afw::math::BoundedField
	BoundedField (geom::Box2I const &bbox)

Protected Member Functions inherited from lsst::afw::table::io::Persistable
	Persistable ()

	Persistable (Persistable const &other)

void	operator= (Persistable const &other)

Private Member Functions
	ChebyshevBoundedField (afw::geom::Box2I const &bbox)

Private Attributes
geom::AffineTransform	_toChebyshevRange

ndarray::Array< double const, 2, 2 >	_coefficients

Additional Inherited Members
Protected Types inherited from lsst::afw::table::io::Persistable
typedef io::OutputArchiveHandle	OutputArchiveHandle

Detailed Description

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

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 69 of file ChebyshevBoundedField.h.

Member Typedef Documentation

typedef ChebyshevBoundedFieldControl lsst::afw::math::ChebyshevBoundedField::Control

Definition at line 75 of file ChebyshevBoundedField.h.

Constructor & Destructor Documentation

lsst::afw::math::ChebyshevBoundedField::ChebyshevBoundedField	(	afw::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 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 Box2D(bbox) is mapped to [-1, 1]x[-1, 1].

Definition at line 58 of file ChebyshevBoundedField.cc.

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

lsst::afw::math::ChebyshevBoundedField::ChebyshevBoundedField ( afw::geom::Box2I const & bbox )

explicitprivate

Definition at line 66 of file ChebyshevBoundedField.cc.

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

Member Function Documentation

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

virtual

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 310 of file ChebyshevBoundedField.cc.

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

boost::shared_ptr< ChebyshevBoundedField > lsst::afw::math::ChebyshevBoundedField::fit	(	afw::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 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 161 of file ChebyshevBoundedField.cc.

   {
     // Initialize the result object, so we can make use of the AffineTransform it builds
     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;
 }

boost::shared_ptr< ChebyshevBoundedField > lsst::afw::math::ChebyshevBoundedField::fit	(	afw::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 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 182 of file ChebyshevBoundedField.cc.

   {
     // Initialize the result object, so we can make use of the AffineTransform it builds
     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.
     matrix.asEigen<Eigen::ArrayXpr>().colwise() *= w.asEigen<Eigen::ArrayXpr>();
     ndarray::Array<double,1,1> wz = ndarray::copy(z);
     wz.asEigen<Eigen::ArrayXpr>() *= w.asEigen<Eigen::ArrayXpr>();
     // 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;
 }

template<typename T >

boost::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 210 of file ChebyshevBoundedField.cc.

   {
     // Initialize the result object, so we can make use of the AffineTransform it builds
     geom::Box2I bbox = img.getBBox(image::PARENT);
     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;
 }

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 162 of file ChebyshevBoundedField.h.

162 { return _coefficients; }

lsst::afw::math::ChebyshevBoundedField::_coefficients

ndarray::Array< double const, 2, 2 > _coefficients

Definition: ChebyshevBoundedField.h:201

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

protectedvirtual

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 379 of file ChebyshevBoundedField.cc.

                                                           {
     return getChebyshevBoundedFieldPersistenceName();
 }

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

protectedvirtual

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 383 of file ChebyshevBoundedField.cc.

                                                        {
     return "lsst.afw.math";
 }

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

inlinevirtual

ChebyshevBoundedField is always persistable.

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

Definition at line 181 of file ChebyshevBoundedField.h.

181 { return true; }

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

virtual

Return a scaled BoundedField

Parameters

[in] scale Scaling factor

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

Definition at line 398 of file ChebyshevBoundedField.cc.

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

boost::shared_ptr< ChebyshevBoundedField > lsst::afw::math::ChebyshevBoundedField::relocate ( 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 261 of file ChebyshevBoundedField.cc.

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

boost::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 234 of file ChebyshevBoundedField.cc.

                                                                                      {
     if (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 (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 boost::make_shared<ChebyshevBoundedField>(getBBox(), coefficients);
 }

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

protectedvirtual

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 387 of file ChebyshevBoundedField.cc.

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

Member Data Documentation

ndarray::Array<double const,2,2> lsst::afw::math::ChebyshevBoundedField::_coefficients

private

Definition at line 201 of file ChebyshevBoundedField.h.

geom::AffineTransform lsst::afw::math::ChebyshevBoundedField::_toChebyshevRange

private

Definition at line 200 of file ChebyshevBoundedField.h.

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

/home/lsstsw/stack/Linux64/afw/11.0-2-g04d2804/include/lsst/afw/math/ChebyshevBoundedField.h
/home/lsstsw/stack/Linux64/afw/11.0-2-g04d2804/src/math/ChebyshevBoundedField.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation