LSST Applications g04c3c9f7ca+2075667efa,g1e125bf412+5f448d5fcf,g2079a07aa2+3e9fd84d81,g2305ad1205+b635cf1488,g2bbee38e9b+6c6beb4891,g337abbeb29+6c6beb4891,g33d1c0ed96+6c6beb4891,g3a166c0a6a+6c6beb4891,g50ff169b8f+96c6868917,g52b1c1532d+585e252eca,g591dd9f2cf+42f171e1e6,g5c3423f6d4+d536b04327,g607f77f49a+d536b04327,g6f43f06aed+ca1339dc19,g858d7b2824+d536b04327,g8ee334c5b4+d7f9608c2f,g9963eaa53e+b3dc1655d3,g998f4353bf+d536b04327,g99cad8db69+8ef2408349,g9ddcbc5298+9a081db1e4,ga1e77700b3+2cbb763275,gadfd92a7e4+aec2f3b930,gae0086650b+585e252eca,gb0e22166c9+0e73c8378f,gb3b7280ab2+cb5fdb229e,gbb8dafda3b+a327199e22,gc120e1dc64+88074880ea,gc28159a63d+6c6beb4891,gcdd4ae20e8+bd241b2308,gcde1bda545+903e937d91,gcf0d15dbbd+bd241b2308,gdaeeff99f8+f9a426f77a,gddc38dedce+585e252eca,ge79ae78c31+6c6beb4891,gfbcc870c63+b310236976,w.2024.23
LSST Data Management Base Package
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | List of all members
lsst::afw::math::LinearCombinationKernel Class Reference

A kernel that is a linear combination of fixed basis kernels. More...

#include <Kernel.h>

Inheritance diagram for lsst::afw::math::LinearCombinationKernel:
lsst::afw::table::io::PersistableFacade< LinearCombinationKernel > lsst::afw::math::Kernel lsst::afw::table::io::PersistableFacade< Kernel > lsst::afw::table::io::Persistable

Classes

class  Factory
 

Public Types

using Pixel = double
 
using SpatialFunctionPtr = std::shared_ptr<lsst::afw::math::Function2<double>>
 
using SpatialFunction = lsst::afw::math::Function2<double>
 
using NullSpatialFunction = lsst::afw::math::NullFunction2<double>
 
using kernel_fill_factor = generic_kernel_tag
 

Public Member Functions

 LinearCombinationKernel ()
 Construct an empty LinearCombinationKernel of size 0x0.
 
 LinearCombinationKernel (KernelList const &kernelList, std::vector< double > const &kernelParameters)
 Construct a spatially invariant LinearCombinationKernel.
 
 LinearCombinationKernel (KernelList const &kernelList, Kernel::SpatialFunction const &spatialFunction)
 Construct a spatially varying LinearCombinationKernel, where the spatial model is described by one function (that is cloned to give one per basis kernel).
 
 LinearCombinationKernel (KernelList const &kernelList, std::vector< Kernel::SpatialFunctionPtr > const &spatialFunctionList)
 Construct a spatially varying LinearCombinationKernel, where the spatial model is described by a list of functions (one per basis kernel).
 
 LinearCombinationKernel (const LinearCombinationKernel &)=delete
 
 LinearCombinationKernel (LinearCombinationKernel &&)=delete
 
LinearCombinationKerneloperator= (const LinearCombinationKernel &)=delete
 
LinearCombinationKerneloperator= (LinearCombinationKernel &&)=delete
 
 ~LinearCombinationKernel () override=default
 
std::shared_ptr< Kernelclone () const override
 Return a pointer to a deep copy of this kernel.
 
std::shared_ptr< Kernelresized (int width, int height) const override
 Return a pointer to a clone with specified kernel dimensions.
 
std::vector< double > getKernelParameters () const override
 Return the current kernel parameters.
 
virtual KernelList const & getKernelList () const
 Get the fixed basis kernels.
 
std::vector< double > getKernelSumList () const
 Get the sum of the pixels of each fixed basis kernel.
 
int getNBasisKernels () const
 Get the number of basis kernels.
 
void checkKernelList (const KernelList &kernelList) const
 Check that all kernels have the same size and center and that none are spatially varying.
 
bool isDeltaFunctionBasis () const
 Return true if all basis kernels are instances of DeltaFunctionKernel.
 
std::shared_ptr< Kernelrefactor () const
 Refactor the kernel as a linear combination of N bases where N is the number of parameters for the spatial model.
 
std::string toString (std::string const &prefix="") const override
 Return a string representation of the kernel.
 
bool isPersistable () const noexcept override
 Return true if this particular object can be persisted using afw::table::io.
 
double computeImage (lsst::afw::image::Image< Pixel > &image, bool doNormalize, double x=0.0, double y=0.0) const
 Compute an image (pixellized representation of the kernel) in place.
 
lsst::geom::Extent2I const getDimensions () const
 Return the Kernel's dimensions (width, height)
 
void setDimensions (lsst::geom::Extent2I dims)
 
void setWidth (int width)
 
void setHeight (int height)
 
int getWidth () const
 Return the Kernel's width.
 
int getHeight () const
 Return the Kernel's height.
 
lsst::geom::Point2I getCtr () const
 Return index of kernel's center.
 
lsst::geom::Box2I getBBox () const
 return parent bounding box, with XY0 = -center
 
unsigned int getNKernelParameters () const
 Return the number of kernel parameters (0 if none)
 
int getNSpatialParameters () const
 Return the number of spatial parameters (0 if not spatially varying)
 
SpatialFunctionPtr getSpatialFunction (unsigned int index) const
 Return a clone of the specified spatial function (one component of the spatial model)
 
std::vector< SpatialFunctionPtrgetSpatialFunctionList () const
 Return a list of clones of the spatial functions.
 
virtual double getKernelParameter (unsigned int i) const
 Return a particular Kernel Parameter (no bounds checking).
 
lsst::geom::Box2I growBBox (lsst::geom::Box2I const &bbox) const
 Given a bounding box for pixels one wishes to compute by convolving an image with this kernel, return the bounding box of pixels that must be accessed on the image to be convolved.
 
lsst::geom::Box2I shrinkBBox (lsst::geom::Box2I const &bbox) const
 Given a bounding box for an image one wishes to convolve with this kernel, return the bounding box for the region of pixels that can be computed.
 
void setCtr (lsst::geom::Point2I ctr)
 Set index of kernel's center.
 
std::vector< std::vector< double > > getSpatialParameters () const
 Return the spatial parameters parameters (an empty vector if not spatially varying)
 
bool isSpatiallyVarying () const
 Return true iff the kernel is spatially varying (has a spatial function)
 
void setKernelParameters (std::vector< double > const &params)
 Set the kernel parameters of a spatially invariant kernel.
 
void setKernelParameters (std::pair< double, double > const &params)
 Set the kernel parameters of a 2-component spatially invariant kernel.
 
void setSpatialParameters (const std::vector< std::vector< double > > params)
 Set the parameters of all spatial functions.
 
void computeKernelParametersFromSpatialModel (std::vector< double > &kernelParams, double x, double y) const
 Compute the kernel parameters at a specified point.
 
virtual void computeCache (int const)
 Compute a cache of Kernel values, if desired.
 
virtual int getCacheSize () const
 Get the current size of the kernel cache (0 if none or if caches not supported)
 
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< LinearCombinationKernelreadFits (fits::Fits &fitsfile)
 Read an object from an already open FITS object.
 
static std::shared_ptr< LinearCombinationKernelreadFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
 Read an object from a regular FITS file.
 
static std::shared_ptr< LinearCombinationKernelreadFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
 Read an object from a FITS file in memory.
 
static std::shared_ptr< LinearCombinationKerneldynamicCast (std::shared_ptr< Persistable > const &ptr)
 Dynamically cast a shared_ptr.
 
static std::shared_ptr< KernelreadFits (fits::Fits &fitsfile)
 Read an object from an already open FITS object.
 
static std::shared_ptr< KernelreadFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
 Read an object from a regular FITS file.
 
static std::shared_ptr< KernelreadFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
 Read an object from a FITS file in memory.
 
static std::shared_ptr< KerneldynamicCast (std::shared_ptr< Persistable > const &ptr)
 Dynamically cast a shared_ptr.
 

Protected Types

using OutputArchiveHandle = io::OutputArchiveHandle
 

Protected Member Functions

double doComputeImage (lsst::afw::image::Image< Pixel > &image, bool doNormalize) const override
 Low-level version of computeImage.
 
std::string getPersistenceName () const override
 Return the unique name used to persist this object and look up its factory.
 
void write (OutputArchiveHandle &handle) const override
 Write the object to one or more catalogs.
 
void setKernelParameter (unsigned int ind, double value) const override
 Set one kernel parameter.
 
std::string getPythonModule () const override
 Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.
 
void setKernelParametersFromSpatialModel (double x, double y) const
 Set the kernel parameters from the spatial model (if any).
 

Protected Attributes

std::vector< SpatialFunctionPtr_spatialFunctionList
 

Detailed Description

A kernel that is a linear combination of fixed basis kernels.

Convolution may be performed by first convolving the image with each fixed kernel, then adding the resulting images using the (possibly spatially varying) kernel coefficients.

The basis kernels are cloned (deep copied) so you may safely modify your own copies.

Warnings:

Definition at line 703 of file Kernel.h.

Member Typedef Documentation

◆ kernel_fill_factor

Definition at line 118 of file Kernel.h.

◆ NullSpatialFunction

Definition at line 115 of file Kernel.h.

◆ OutputArchiveHandle

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

Definition at line 108 of file Persistable.h.

◆ Pixel

using lsst::afw::math::Kernel::Pixel = double
inherited

Definition at line 112 of file Kernel.h.

◆ SpatialFunction

Definition at line 114 of file Kernel.h.

◆ SpatialFunctionPtr

Definition at line 113 of file Kernel.h.

Constructor & Destructor Documentation

◆ LinearCombinationKernel() [1/6]

lsst::afw::math::LinearCombinationKernel::LinearCombinationKernel ( )
explicit

Construct an empty LinearCombinationKernel of size 0x0.

Definition at line 48 of file LinearCombinationKernel.cc.

49 : Kernel(),
50 _kernelList(),
51 _kernelImagePtrList(),
52 _kernelSumList(),
53 _kernelParams(),
54 _isDeltaFunctionBasis(false) {}
Kernel()
Construct a null Kernel of size 0,0.
Definition Kernel.cc:49

◆ LinearCombinationKernel() [2/6]

lsst::afw::math::LinearCombinationKernel::LinearCombinationKernel ( KernelList const & kernelList,
std::vector< double > const & kernelParameters )
explicit

Construct a spatially invariant LinearCombinationKernel.

Parameters
kernelListlist of (shared pointers to const) basis kernels
kernelParameterskernel coefficients

Definition at line 56 of file LinearCombinationKernel.cc.

58 : Kernel(kernelList[0]->getWidth(), kernelList[0]->getHeight(), kernelList.size()),
59 _kernelList(),
60 _kernelImagePtrList(),
61 _kernelSumList(),
62 _kernelParams(kernelParameters),
63 _isDeltaFunctionBasis(false) {
64 if (kernelList.size() != kernelParameters.size()) {
66 os << "kernelList.size() = " << kernelList.size() << " != " << kernelParameters.size() << " = "
67 << "kernelParameters.size()";
69 }
70 checkKernelList(kernelList);
71 _setKernelList(kernelList);
72}
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition Exception.h:48
std::ostream * os
Definition Schema.cc:557
int getHeight() const
Return the Kernel's height.
Definition Kernel.h:229
int getWidth() const
Return the Kernel's width.
Definition Kernel.h:224
void checkKernelList(const KernelList &kernelList) const
Check that all kernels have the same size and center and that none are spatially varying.
Reports invalid arguments.
Definition Runtime.h:66
T size(T... args)

◆ LinearCombinationKernel() [3/6]

lsst::afw::math::LinearCombinationKernel::LinearCombinationKernel ( KernelList const & kernelList,
Kernel::SpatialFunction const & spatialFunction )
explicit

Construct a spatially varying LinearCombinationKernel, where the spatial model is described by one function (that is cloned to give one per basis kernel).

Parameters
kernelListlist of (shared pointers to const) basis kernels
spatialFunctionspatial function; one deep copy is made for each basis kernel

Definition at line 74 of file LinearCombinationKernel.cc.

76 : Kernel(kernelList[0]->getWidth(), kernelList[0]->getHeight(), kernelList.size(), spatialFunction),
77 _kernelList(),
78 _kernelImagePtrList(),
79 _kernelSumList(),
80 _kernelParams(std::vector<double>(kernelList.size())),
81 _isDeltaFunctionBasis(false) {
82 checkKernelList(kernelList);
83 _setKernelList(kernelList);
84}

◆ LinearCombinationKernel() [4/6]

lsst::afw::math::LinearCombinationKernel::LinearCombinationKernel ( KernelList const & kernelList,
std::vector< Kernel::SpatialFunctionPtr > const & spatialFunctionList )
explicit

Construct a spatially varying LinearCombinationKernel, where the spatial model is described by a list of functions (one per basis kernel).

Parameters
kernelListlist of (shared pointers to const) kernels
spatialFunctionListlist of spatial functions, one per basis kernel
Exceptions
lsst::pex::exceptions::InvalidParameterErrorif the length of spatialFunctionList != # kernels

Definition at line 86 of file LinearCombinationKernel.cc.

88 : Kernel(kernelList[0]->getWidth(), kernelList[0]->getHeight(), spatialFunctionList),
89 _kernelList(),
90 _kernelImagePtrList(),
91 _kernelSumList(),
92 _kernelParams(std::vector<double>(kernelList.size())),
93 _isDeltaFunctionBasis(false) {
94 if (kernelList.size() != spatialFunctionList.size()) {
96 os << "kernelList.size() = " << kernelList.size() << " != " << spatialFunctionList.size() << " = "
97 << "spatialFunctionList.size()";
99 }
100 checkKernelList(kernelList);
101 _setKernelList(kernelList);
102}

◆ LinearCombinationKernel() [5/6]

lsst::afw::math::LinearCombinationKernel::LinearCombinationKernel ( const LinearCombinationKernel & )
delete

◆ LinearCombinationKernel() [6/6]

lsst::afw::math::LinearCombinationKernel::LinearCombinationKernel ( LinearCombinationKernel && )
delete

◆ ~LinearCombinationKernel()

lsst::afw::math::LinearCombinationKernel::~LinearCombinationKernel ( )
overridedefault

Member Function Documentation

◆ checkKernelList()

void lsst::afw::math::LinearCombinationKernel::checkKernelList ( const KernelList & kernelList) const

Check that all kernels have the same size and center and that none are spatially varying.

Exceptions
lsst::pex::exceptions::InvalidParameterErrorif the check fails

Definition at line 132 of file LinearCombinationKernel.cc.

132 {
133 if (kernelList.size() < 1) {
134 throw LSST_EXCEPT(pexExcept::InvalidParameterError, "kernelList has no elements");
135 }
136
137 lsst::geom::Extent2I const dim0 = kernelList[0]->getDimensions();
138 lsst::geom::Point2I const ctr0 = kernelList[0]->getCtr();
139
140 for (unsigned int ii = 0; ii < kernelList.size(); ++ii) {
141 if (kernelList[ii]->getDimensions() != dim0) {
143 (boost::format("kernel %d has different size than kernel 0") % ii).str());
144 }
145 if (kernelList[ii]->getCtr() != ctr0) {
147 (boost::format("kernel %d has different center than kernel 0") % ii).str());
148 }
149 if (kernelList[ii]->isSpatiallyVarying()) {
151 (boost::format("kernel %d is spatially varying") % ii).str());
152 }
153 }
154}
lsst::geom::Extent2I const getDimensions() const
Return the Kernel's dimensions (width, height)
Definition Kernel.h:212
lsst::geom::Point2I getCtr() const
Return index of kernel's center.
Definition Kernel.h:234
bool isSpatiallyVarying() const
Return true iff the kernel is spatially varying (has a spatial function)
Definition Kernel.h:333

◆ clone()

std::shared_ptr< Kernel > lsst::afw::math::LinearCombinationKernel::clone ( ) const
overridevirtual

Return a pointer to a deep copy of this kernel.

This kernel exists instead of a copy constructor so one can obtain a copy of an actual kernel instead of a useless copy of the base class.

Every kernel subclass must override this method.

Returns
a pointer to a deep copy of the kernel

Implements lsst::afw::math::Kernel.

Definition at line 104 of file LinearCombinationKernel.cc.

104 {
106 if (this->isSpatiallyVarying()) {
107 retPtr.reset(new LinearCombinationKernel(this->_kernelList, this->_spatialFunctionList));
108 } else {
109 retPtr.reset(new LinearCombinationKernel(this->_kernelList, this->_kernelParams));
110 }
111 retPtr->setCtr(this->getCtr());
112 return retPtr;
113}
std::vector< SpatialFunctionPtr > _spatialFunctionList
Definition Kernel.h:449
LinearCombinationKernel()
Construct an empty LinearCombinationKernel of size 0x0.
T reset(T... args)

◆ computeCache()

virtual void lsst::afw::math::Kernel::computeCache ( int const )
inlinevirtualinherited

Compute a cache of Kernel values, if desired.

Warning
: few kernel classes actually support this, in which case this is a no-op and getCacheSize always returns 0.

Reimplemented in lsst::afw::math::SeparableKernel.

Definition at line 397 of file Kernel.h.

398 {}

◆ computeImage()

double lsst::afw::math::Kernel::computeImage ( lsst::afw::image::Image< Pixel > & image,
bool doNormalize,
double x = 0.0,
double y = 0.0 ) const
inherited

Compute an image (pixellized representation of the kernel) in place.

Parameters
imageimage whose pixels are to be set (output); xy0 of the image will be set to -kernel.getCtr()
doNormalizenormalize the image (so sum is 1)?
xx (column position) at which to compute spatial function
yy (row position) at which to compute spatial function
Returns
The kernel sum
Exceptions
lsst::pex::exceptions::InvalidParameterErrorif the image is the wrong size
lsst::pex::exceptions::OverflowErrorif doNormalize is true and the kernel sum is exactly 0
Note
computeNewImage has been retired; it doesn't need to be a member

Definition at line 76 of file Kernel.cc.

76 {
77 if (image.getDimensions() != this->getDimensions()) {
79 os << "image dimensions = ( " << image.getWidth() << ", " << image.getHeight() << ") != ("
80 << this->getWidth() << ", " << this->getHeight() << ") = kernel dimensions";
82 }
83 image.setXY0(-_ctrX, -_ctrY);
84 if (this->isSpatiallyVarying()) {
86 }
87 return doComputeImage(image, doNormalize);
88}
int y
Definition SpanSet.cc:48
virtual double doComputeImage(lsst::afw::image::Image< Pixel > &image, bool doNormalize) const =0
Low-level version of computeImage.
void setKernelParametersFromSpatialModel(double x, double y) const
Set the kernel parameters from the spatial model (if any).
Definition Kernel.cc:217

◆ computeKernelParametersFromSpatialModel()

void lsst::afw::math::Kernel::computeKernelParametersFromSpatialModel ( std::vector< double > & kernelParams,
double x,
double y ) const
inherited

Compute the kernel parameters at a specified point.

Warning: this is a low-level function that assumes kernelParams is the right length. It will fail in unpredictable ways if that condition is not met.

Definition at line 135 of file Kernel.cc.

136 {
137 std::vector<double>::iterator paramIter = kernelParams.begin();
138 std::vector<SpatialFunctionPtr>::const_iterator funcIter = _spatialFunctionList.begin();
139 for (; funcIter != _spatialFunctionList.end(); ++funcIter, ++paramIter) {
140 *paramIter = (*(*funcIter))(x, y);
141 }
142}
T begin(T... args)

◆ doComputeImage()

double lsst::afw::math::LinearCombinationKernel::doComputeImage ( lsst::afw::image::Image< Pixel > & image,
bool doNormalize ) const
overrideprotectedvirtual

Low-level version of computeImage.

Before this is called the image dimensions are checked, the image's xy0 is set and the kernel's parameters are set. This routine sets the pixels, including normalization if requested.

Parameters
imageimage whose pixels are to be set (output)
doNormalizenormalize the image (so sum is 1)?
Returns
The kernel sum

Implements lsst::afw::math::Kernel.

Definition at line 247 of file LinearCombinationKernel.cc.

247 {
248 image = 0.0;
249 double imSum = 0.0;
250 std::vector<std::shared_ptr<image::Image<Pixel>>>::const_iterator kImPtrIter =
251 _kernelImagePtrList.begin();
252 std::vector<double>::const_iterator kSumIter = _kernelSumList.begin();
253 std::vector<double>::const_iterator kParIter = _kernelParams.begin();
254 for (; kImPtrIter != _kernelImagePtrList.end(); ++kImPtrIter, ++kSumIter, ++kParIter) {
255 image.scaledPlus(*kParIter, **kImPtrIter);
256 imSum += (*kSumIter) * (*kParIter);
257 }
258
259 if (doNormalize) {
260 if (imSum == 0) {
261 throw LSST_EXCEPT(pexExcept::OverflowError, "Cannot normalize; kernel sum is 0");
262 }
263 image /= imSum;
264 imSum = 1;
265 }
266
267 return imSum;
268}
Reports when the result of an arithmetic operation is too large for the destination type.
Definition Runtime.h:124
T end(T... args)

◆ dynamicCast() [1/2]

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::LogicErrorif the cast fails

param[in] ptr The pointer to be cast.

Returns
The cast pointer.
Exceptions
lsst::pex::exceptions::TypeErrorIf the dynamic cast fails.

Definition at line 218 of file Persistable.cc.

◆ dynamicCast() [2/2]

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::LogicErrorif the cast fails

param[in] ptr The pointer to be cast.

Returns
The cast pointer.
Exceptions
lsst::pex::exceptions::TypeErrorIf the dynamic cast fails.

Definition at line 218 of file Persistable.cc.

◆ getBBox()

lsst::geom::Box2I lsst::afw::math::Kernel::getBBox ( ) const
inlineinherited

return parent bounding box, with XY0 = -center

Definition at line 239 of file Kernel.h.

239 {
240 return lsst::geom::Box2I(lsst::geom::Point2I(-_ctrX, -_ctrY), lsst::geom::Extent2I(_width, _height));
241 }
An integer coordinate rectangle.
Definition Box.h:55

◆ getCacheSize()

virtual int lsst::afw::math::Kernel::getCacheSize ( ) const
inlinevirtualinherited

Get the current size of the kernel cache (0 if none or if caches not supported)

Reimplemented in lsst::afw::math::SeparableKernel.

Definition at line 403 of file Kernel.h.

403{ return 0; };

◆ getCtr()

lsst::geom::Point2I lsst::afw::math::Kernel::getCtr ( ) const
inlineinherited

Return index of kernel's center.

Definition at line 234 of file Kernel.h.

234{ return lsst::geom::Point2I(_ctrX, _ctrY); }
Point< int, 2 > Point2I
Definition Point.h:321

◆ getDimensions()

lsst::geom::Extent2I const lsst::afw::math::Kernel::getDimensions ( ) const
inlineinherited

Return the Kernel's dimensions (width, height)

Definition at line 212 of file Kernel.h.

212{ return lsst::geom::Extent2I(_width, _height); }
Extent< int, 2 > Extent2I
Definition Extent.h:397

◆ getHeight()

int lsst::afw::math::Kernel::getHeight ( ) const
inlineinherited

Return the Kernel's height.

Definition at line 229 of file Kernel.h.

229{ return _height; }

◆ getKernelList()

KernelList const & lsst::afw::math::LinearCombinationKernel::getKernelList ( ) const
virtual

Get the fixed basis kernels.

Definition at line 156 of file LinearCombinationKernel.cc.

156{ return _kernelList; }

◆ getKernelParameter()

virtual double lsst::afw::math::Kernel::getKernelParameter ( unsigned int i) const
inlinevirtualinherited

Return a particular Kernel Parameter (no bounds checking).

This version is slow, but specialisations may be faster

Reimplemented in lsst::afw::math::SeparableKernel.

Definition at line 277 of file Kernel.h.

277{ return getKernelParameters()[i]; }
virtual std::vector< double > getKernelParameters() const
Return the current kernel parameters.
Definition Kernel.cc:165

◆ getKernelParameters()

std::vector< double > lsst::afw::math::LinearCombinationKernel::getKernelParameters ( ) const
overridevirtual

Return the current kernel parameters.

If the kernel is spatially varying then the parameters are those last computed. See also computeKernelParametersFromSpatialModel. If there are no kernel parameters then returns an empty vector.

Reimplemented from lsst::afw::math::Kernel.

Definition at line 160 of file LinearCombinationKernel.cc.

160{ return _kernelParams; }

◆ getKernelSumList()

std::vector< double > lsst::afw::math::LinearCombinationKernel::getKernelSumList ( ) const

Get the sum of the pixels of each fixed basis kernel.

Definition at line 158 of file LinearCombinationKernel.cc.

158{ return _kernelSumList; }

◆ getNBasisKernels()

int lsst::afw::math::LinearCombinationKernel::getNBasisKernels ( ) const
inline

Get the number of basis kernels.

Definition at line 768 of file Kernel.h.

768{ return static_cast<int>(_kernelList.size()); };

◆ getNKernelParameters()

unsigned int lsst::afw::math::Kernel::getNKernelParameters ( ) const
inlineinherited

Return the number of kernel parameters (0 if none)

Definition at line 246 of file Kernel.h.

246{ return _nKernelParams; }

◆ getNSpatialParameters()

int lsst::afw::math::Kernel::getNSpatialParameters ( ) const
inlineinherited

Return the number of spatial parameters (0 if not spatially varying)

Definition at line 251 of file Kernel.h.

251 {
252 return this->isSpatiallyVarying() ? _spatialFunctionList[0]->getNParameters() : 0;
253 }

◆ getPersistenceName()

std::string lsst::afw::math::LinearCombinationKernel::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 365 of file LinearCombinationKernel.cc.

365 {
366 return getLinearCombinationKernelPersistenceName();
367}

◆ getPythonModule()

std::string lsst::afw::math::Kernel::getPythonModule ( ) const
overrideprotectedvirtualinherited

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.

Reimplemented in lsst::afw::math::LanczosWarpingKernel, and lsst::afw::math::NearestWarpingKernel.

Definition at line 224 of file Kernel.cc.

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

◆ getSpatialFunction()

Kernel::SpatialFunctionPtr lsst::afw::math::Kernel::getSpatialFunction ( unsigned int index) const
inherited

Return a clone of the specified spatial function (one component of the spatial model)

Parameters
indexindex of desired spatial function; must be in range [0, number spatial parameters - 1]
Returns
a shared pointer to a spatial function. The function is a deep copy, so setting its parameters has no effect on the kernel.
Exceptions
lsst::pex::exceptions::InvalidParameterErrorif kernel not spatially varying
lsst::pex::exceptions::InvalidParameterErrorif index out of range

Definition at line 144 of file Kernel.cc.

144 {
145 if (index >= _spatialFunctionList.size()) {
146 if (!this->isSpatiallyVarying()) {
147 throw LSST_EXCEPT(pexExcept::InvalidParameterError, "kernel is not spatially varying");
148 } else {
149 std::ostringstream errStream;
150 errStream << "index = " << index << "; must be < , " << _spatialFunctionList.size();
152 }
153 }
154 return _spatialFunctionList[index]->clone();
155}
T str(T... args)

◆ getSpatialFunctionList()

std::vector< Kernel::SpatialFunctionPtr > lsst::afw::math::Kernel::getSpatialFunctionList ( ) const
inherited

Return a list of clones of the spatial functions.

Returns
a list of shared pointers to spatial functions. The functions are deep copies, so setting their parameters has no effect on the kernel.

Definition at line 157 of file Kernel.cc.

157 {
158 std::vector<SpatialFunctionPtr> spFuncCopyList;
159 for (auto const &spFuncIter : _spatialFunctionList) {
160 spFuncCopyList.push_back((*spFuncIter).clone());
161 }
162 return spFuncCopyList;
163}
T push_back(T... args)

◆ getSpatialParameters()

std::vector< std::vector< double > > lsst::afw::math::Kernel::getSpatialParameters ( ) const
inlineinherited

Return the spatial parameters parameters (an empty vector if not spatially varying)

Definition at line 321 of file Kernel.h.

321 {
322 std::vector<std::vector<double>> spatialParams;
323 std::vector<SpatialFunctionPtr>::const_iterator spFuncIter = _spatialFunctionList.begin();
324 for (; spFuncIter != _spatialFunctionList.end(); ++spFuncIter) {
325 spatialParams.push_back((*spFuncIter)->getParameters());
326 }
327 return spatialParams;
328 }

◆ getWidth()

int lsst::afw::math::Kernel::getWidth ( ) const
inlineinherited

Return the Kernel's width.

Definition at line 224 of file Kernel.h.

224{ return _width; }

◆ growBBox()

lsst::geom::Box2I lsst::afw::math::Kernel::growBBox ( lsst::geom::Box2I const & bbox) const
inherited

Given a bounding box for pixels one wishes to compute by convolving an image with this kernel, return the bounding box of pixels that must be accessed on the image to be convolved.

Thus the box shifted by -kernel.getCtr() and its size is expanded by kernel.getDimensions()-1.

Returns
the bbox expanded by the kernel.

Definition at line 167 of file Kernel.cc.

167 {
168 return lsst::geom::Box2I(
170 lsst::geom::Extent2I(bbox.getDimensions() + getDimensions() - lsst::geom::Extent2I(1, 1)));
171}
AmpInfoBoxKey bbox
Definition Amplifier.cc:117

◆ isDeltaFunctionBasis()

bool lsst::afw::math::LinearCombinationKernel::isDeltaFunctionBasis ( ) const
inline

Return true if all basis kernels are instances of DeltaFunctionKernel.

Definition at line 780 of file Kernel.h.

780{ return _isDeltaFunctionBasis; };

◆ isPersistable()

bool lsst::afw::math::LinearCombinationKernel::isPersistable ( ) const
inlineoverridevirtualnoexcept

Return true if this particular object can be persisted using afw::table::io.

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

Definition at line 820 of file Kernel.h.

820{ return true; }

◆ isSpatiallyVarying()

bool lsst::afw::math::Kernel::isSpatiallyVarying ( ) const
inlineinherited

Return true iff the kernel is spatially varying (has a spatial function)

Definition at line 333 of file Kernel.h.

333{ return _spatialFunctionList.size() != 0; }

◆ operator=() [1/2]

LinearCombinationKernel & lsst::afw::math::LinearCombinationKernel::operator= ( const LinearCombinationKernel & )
delete

◆ operator=() [2/2]

LinearCombinationKernel & lsst::afw::math::LinearCombinationKernel::operator= ( LinearCombinationKernel && )
delete

◆ readFits() [1/6]

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

Read an object from an already open FITS object.

Parameters
[in]fitsfileFITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

◆ readFits() [2/6]

Read an object from an already open FITS object.

Parameters
[in]fitsfileFITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

◆ readFits() [3/6]

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

Read an object from a FITS file in memory.

Parameters
[in]managerManager for the memory to read from.
[in]hduHDU 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.

◆ readFits() [4/6]

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

Read an object from a FITS file in memory.

Parameters
[in]managerManager for the memory to read from.
[in]hduHDU 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.

◆ readFits() [5/6]

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

Read an object from a regular FITS file.

Parameters
[in]fileNameName of the file to read.
[in]hduHDU 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.

◆ readFits() [6/6]

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

Read an object from a regular FITS file.

Parameters
[in]fileNameName of the file to read.
[in]hduHDU 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.

◆ refactor()

std::shared_ptr< Kernel > lsst::afw::math::LinearCombinationKernel::refactor ( ) const

Refactor the kernel as a linear combination of N bases where N is the number of parameters for the spatial model.

Refactoring is only possible if all of the following are true:

  • Kernel is spatially varying
  • The spatial functions are a linear combination of coefficients (return isLinearCombination() true).
  • The spatial functions all are the same class (and so have the same functional form) Refactoring produces a kernel that is faster to compute only if the number of basis kernels is greater than the number of parameters in the spatial model.

Details: A spatially varying LinearCombinationKernel consisting of M basis kernels and using a spatial model that is a linear combination of N coefficients can be expressed as: K(x,y) = K0 (C00 F0(x,y) + C10 F1(x,y) + C20 F2(x,y) + ... + CN0 FN(x,y))

  • K1 (C01 F0(x,y) + C11 F1(x,y) + C21 F2(x,y) + ... + CN1 FN(x,y))
  • K2 (C02 F0(x,y) + C12 F1(x,y) + C22 F2(x,y) + ... + CN2 FN(x,y))
  • ...
  • KM (C0M F0(x,y) + C1M F1(x,y) + C2M F2(x,y) + ... + CNM FN(x,y))

This is equivalent to the following linear combination of N basis kernels:

    =      K0' F0(x,y) + K1' F1(x,y) + K2' F2(x,y) + ... + KN' FN(x,y)

      where Ki' = sum over j of Kj Cij

This is what refactor returns provided the required conditions are met. However, the spatial functions for the refactored kernel are the same as those for the original kernel (for generality and simplicity) with all coefficients equal to 0 except one that is set to 1; hence they are not computed optimally.

Thanks to Kresimir Cosic for inventing or reinventing this useful technique.

Returns
a shared pointer to new kernel, or empty pointer if refactoring not possible

Definition at line 162 of file LinearCombinationKernel.cc.

162 {
163 if (!this->isSpatiallyVarying()) {
165 }
166 Kernel::SpatialFunctionPtr const firstSpFuncPtr = this->_spatialFunctionList[0];
167 if (!firstSpFuncPtr->isLinearCombination()) {
169 }
170
171 using KernelImage = image::Image<Kernel::Pixel>;
172 using KernelImagePtr = std::shared_ptr<KernelImage>;
173 using KernelImageList = std::vector<KernelImagePtr>;
174
175 // create kernel images for new refactored basis kernels
176 int const nSpatialParameters = this->getNSpatialParameters();
177 KernelImageList newKernelImagePtrList;
178 newKernelImagePtrList.reserve(nSpatialParameters);
179 for (int i = 0; i < nSpatialParameters; ++i) {
180 KernelImagePtr kernelImagePtr(new KernelImage(this->getDimensions()));
181 newKernelImagePtrList.push_back(kernelImagePtr);
182 }
183 KernelImage kernelImage(this->getDimensions());
184 std::vector<Kernel::SpatialFunctionPtr>::const_iterator spFuncPtrIter =
185 this->_spatialFunctionList.begin();
186 KernelList::const_iterator kIter = _kernelList.begin();
187 KernelList::const_iterator const kEnd = _kernelList.end();
188 auto &firstSpFunc = *firstSpFuncPtr;
189 auto &firstType = typeid(firstSpFunc); // noncopyable object of static storage duration
190 for (; kIter != kEnd; ++kIter, ++spFuncPtrIter) {
191 auto &spFunc = **spFuncPtrIter;
192 if (typeid(spFunc) != firstType) {
194 }
195
196 (**kIter).computeImage(kernelImage, false);
197 for (int i = 0; i < nSpatialParameters; ++i) {
198 double spParam = (*spFuncPtrIter)->getParameter(i);
199 newKernelImagePtrList[i]->scaledPlus(spParam, kernelImage);
200 }
201 }
202
203 // create new kernel; the basis kernels are fixed kernels computed above
204 // and the corresponding spatial model is the same function as the original kernel,
205 // but with all coefficients zero except coeff_i = 1.0
206 KernelList newKernelList;
207 newKernelList.reserve(nSpatialParameters);
208 KernelImageList::iterator newKImPtrIter = newKernelImagePtrList.begin();
209 KernelImageList::iterator const newKImPtrEnd = newKernelImagePtrList.end();
210 for (; newKImPtrIter != newKImPtrEnd; ++newKImPtrIter) {
211 newKernelList.push_back(std::shared_ptr<Kernel>(new FixedKernel(**newKImPtrIter)));
212 }
213 std::vector<SpatialFunctionPtr> newSpFunctionPtrList;
214 for (int i = 0; i < nSpatialParameters; ++i) {
215 std::vector<double> newSpParameters(nSpatialParameters, 0.0);
216 newSpParameters[i] = 1.0;
217 SpatialFunctionPtr newSpFunctionPtr = firstSpFuncPtr->clone();
218 newSpFunctionPtr->setParameters(newSpParameters);
219 newSpFunctionPtrList.push_back(newSpFunctionPtr);
220 }
222 new LinearCombinationKernel(newKernelList, newSpFunctionPtrList));
223 refactoredKernel->setCtr(this->getCtr());
224 return refactoredKernel;
225}
A class to represent a 2-dimensional array of pixels.
Definition Image.h:51
virtual std::shared_ptr< Function2< ReturnT > > clone() const =0
Return a pointer to a deep copy of this function.
std::shared_ptr< lsst::afw::math::Function2< double > > SpatialFunctionPtr
Definition Kernel.h:113
int getNSpatialParameters() const
Return the number of spatial parameters (0 if not spatially varying)
Definition Kernel.h:251
std::vector< std::shared_ptr< Kernel > > KernelList
Definition Kernel.h:462
T reserve(T... args)

◆ resized()

std::shared_ptr< Kernel > lsst::afw::math::LinearCombinationKernel::resized ( int width,
int height ) const
overridevirtual

Return a pointer to a clone with specified kernel dimensions.

Parameters
widthNumber of columns in pixels
heightNumber of rows in pixels
Returns
a pointer to a clone with new dimensions.

Must be implemented by derived classes.

Implements lsst::afw::math::Kernel.

Definition at line 115 of file LinearCombinationKernel.cc.

115 {
116 KernelList kernelList;
117 kernelList.reserve(getKernelList().size());
118 for (const std::shared_ptr<Kernel> &kIter : getKernelList()) {
119 kernelList.push_back(kIter->resized(width, height));
120 }
121
123 if (isSpatiallyVarying()) {
124 retPtr = std::make_shared<LinearCombinationKernel>(kernelList, _spatialFunctionList);
125 } else {
126 retPtr = std::make_shared<LinearCombinationKernel>(kernelList, _kernelParams);
127 }
128
129 return retPtr;
130}
virtual KernelList const & getKernelList() const
Get the fixed basis kernels.

◆ setCtr()

void lsst::afw::math::Kernel::setCtr ( lsst::geom::Point2I ctr)
inlineinherited

Set index of kernel's center.

Definition at line 312 of file Kernel.h.

312 {
313 _ctrX = ctr.getX();
314 _ctrY = ctr.getY();
315 _setKernelXY();
316 }
virtual void _setKernelXY()
Definition Kernel.h:459

◆ setDimensions()

void lsst::afw::math::Kernel::setDimensions ( lsst::geom::Extent2I dims)
inlineinherited

Definition at line 214 of file Kernel.h.

214 {
215 _width = dims.getX();
216 _height = dims.getY();
217 }

◆ setHeight()

void lsst::afw::math::Kernel::setHeight ( int height)
inlineinherited

Definition at line 219 of file Kernel.h.

219{ _height = height; }

◆ setKernelParameter()

void lsst::afw::math::LinearCombinationKernel::setKernelParameter ( unsigned int ind,
double value ) const
overrideprotectedvirtual

Set one kernel parameter.

Classes that have kernel parameters must subclass this function.

This function is marked "const", despite modifying unimportant internals, so that computeImage can be const.

Exceptions
lsst::pex::exceptions::InvalidParameterErroralways (unless subclassed)

Reimplemented from lsst::afw::math::Kernel.

Definition at line 270 of file LinearCombinationKernel.cc.

270 {
271 this->_kernelParams[ind] = value;
272}

◆ setKernelParameters() [1/2]

void lsst::afw::math::Kernel::setKernelParameters ( std::pair< double, double > const & params)
inlineinherited

Set the kernel parameters of a 2-component spatially invariant kernel.

Warning
This is a low-level method intended for maximum efficiency when using warping kernels. No error checking is performed. Use the std::vector<double> form if you want safety.

Definition at line 363 of file Kernel.h.

363 {
364 this->setKernelParameter(0, params.first);
365 this->setKernelParameter(1, params.second);
366 }
virtual void setKernelParameter(unsigned int ind, double value) const
Set one kernel parameter.
Definition Kernel.cc:213

◆ setKernelParameters() [2/2]

void lsst::afw::math::Kernel::setKernelParameters ( std::vector< double > const & params)
inlineinherited

Set the kernel parameters of a spatially invariant kernel.

Exceptions
lsst::pex::exceptions::RuntimeErrorif the kernel has a spatial function
lsst::pex::exceptions::InvalidParameterErrorif the params vector is the wrong length

Definition at line 341 of file Kernel.h.

341 {
342 if (this->isSpatiallyVarying()) {
343 throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError, "Kernel is spatially varying");
344 }
345 const unsigned int nParams = this->getNKernelParameters();
346 if (nParams != params.size()) {
348 (boost::format("Number of parameters is wrong, saw %d expected %d") % nParams %
349 params.size())
350 .str());
351 }
352 for (unsigned int ii = 0; ii < nParams; ++ii) {
353 this->setKernelParameter(ii, params[ii]);
354 }
355 }
unsigned int getNKernelParameters() const
Return the number of kernel parameters (0 if none)
Definition Kernel.h:246
Reports errors that are due to events beyond the control of the program.
Definition Runtime.h:104

◆ setKernelParametersFromSpatialModel()

void lsst::afw::math::Kernel::setKernelParametersFromSpatialModel ( double x,
double y ) const
protectedinherited

Set the kernel parameters from the spatial model (if any).

This function has no effect if there is no spatial model.

This function is marked "const", despite modifying unimportant internals, so that computeImage can be const.

Definition at line 217 of file Kernel.cc.

217 {
218 std::vector<SpatialFunctionPtr>::const_iterator funcIter = _spatialFunctionList.begin();
219 for (int ii = 0; funcIter != _spatialFunctionList.end(); ++funcIter, ++ii) {
220 this->setKernelParameter(ii, (*(*funcIter))(x, y));
221 }
222}

◆ setSpatialParameters()

void lsst::afw::math::Kernel::setSpatialParameters ( const std::vector< std::vector< double > > params)
inherited

Set the parameters of all spatial functions.

Params is indexed as [kernel parameter][spatial parameter]

Exceptions
lsst::pex::exceptions::InvalidParameterErrorif params is the wrong shape (if this exception is thrown then no parameters are changed)

Definition at line 110 of file Kernel.cc.

110 {
111 // Check params size before changing anything
112 unsigned int nKernelParams = this->getNKernelParameters();
113 if (params.size() != nKernelParams) {
114 throw LSST_EXCEPT(
116 (boost::format("params has %d entries instead of %d") % params.size() % nKernelParams).str());
117 }
118 unsigned int nSpatialParams = this->getNSpatialParameters();
119 for (unsigned int ii = 0; ii < nKernelParams; ++ii) {
120 if (params[ii].size() != nSpatialParams) {
122 (boost::format("params[%d] has %d entries instead of %d") % ii %
123 params[ii].size() % nSpatialParams)
124 .str());
125 }
126 }
127 // Set parameters
128 if (nSpatialParams > 0) {
129 for (unsigned int ii = 0; ii < nKernelParams; ++ii) {
130 this->_spatialFunctionList[ii]->setParameters(params[ii]);
131 }
132 }
133}

◆ setWidth()

void lsst::afw::math::Kernel::setWidth ( int width)
inlineinherited

Definition at line 218 of file Kernel.h.

218{ _width = width; }

◆ shrinkBBox()

lsst::geom::Box2I lsst::afw::math::Kernel::shrinkBBox ( lsst::geom::Box2I const & bbox) const
inherited

Given a bounding box for an image one wishes to convolve with this kernel, return the bounding box for the region of pixels that can be computed.

Thus the box shifted by kernel.getCtr() and its size is reduced by kernel.getDimensions()-1.

Returns
the bbox shrunk by the kernel.
Exceptions
lsst::pex::exceptions::InvalidParameterErrorif the resulting box would have dimension < 1 in either axis

Definition at line 173 of file Kernel.cc.

173 {
174 if ((bbox.getWidth() < getWidth()) || ((bbox.getHeight() < getHeight()))) {
176 os << "bbox dimensions = " << bbox.getDimensions() << " < (" << getWidth() << ", " << getHeight()
177 << ") in one or both dimensions";
179 }
180 return lsst::geom::Box2I(
182 lsst::geom::Extent2I(bbox.getWidth() + 1 - getWidth(), bbox.getHeight() + 1 - getHeight()));
183}

◆ toString()

std::string lsst::afw::math::LinearCombinationKernel::toString ( std::string const & prefix = "") const
overridevirtual

Return a string representation of the kernel.

Reimplemented from lsst::afw::math::Kernel.

Definition at line 227 of file LinearCombinationKernel.cc.

227 {
229 os << prefix << "LinearCombinationKernel:" << std::endl;
230 os << prefix << "..Kernels:" << std::endl;
231 for (auto const &i : _kernelList) {
232 os << i->toString(prefix + "\t");
233 }
234 os << "..parameters: [ ";
235 for (std::vector<double>::const_iterator i = _kernelParams.begin(); i != _kernelParams.end(); ++i) {
236 if (i != _kernelParams.begin()) os << ", ";
237 os << *i;
238 }
239 os << " ]" << std::endl;
240 os << Kernel::toString(prefix + "\t");
241 return os.str();
242}
std::string prefix
virtual std::string toString(std::string const &prefix="") const
Return a string representation of the kernel.
Definition Kernel.cc:185
T endl(T... args)

◆ write()

void lsst::afw::math::LinearCombinationKernel::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 369 of file LinearCombinationKernel.cc.

369 {
370 bool isVarying = isSpatiallyVarying();
371 LinearCombinationKernelPersistenceHelper const keys(getNBasisKernels(), isVarying);
372 std::shared_ptr<afw::table::BaseRecord> record = keys.write(handle, *this);
373 if (isVarying) {
374 for (std::size_t n = 0; n < keys.components.getSize(); ++n) {
375 record->set(keys.components[n], handle.put(_kernelList[n]));
376 record->set(keys.spatialFunctions[n], handle.put(_spatialFunctionList[n]));
377 }
378 } else {
379 for (std::size_t n = 0; n < keys.components.getSize(); ++n) {
380 record->set(keys.components[n], handle.put(_kernelList[n]));
381 record->set(keys.amplitudes[n], _kernelParams[n]);
382 }
383 }
384}
int getNBasisKernels() const
Get the number of basis kernels.
Definition Kernel.h:768

◆ 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]fitsfileOpen FITS object to write to.

Definition at line 18 of file Persistable.cc.

18 {
19 OutputArchive archive;
20 archive.put(this);
21 archive.writeFits(fitsfile);
22}

◆ 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]managerName of the file to write to.
[in]modeIf "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.

29 {
30 fits::Fits fitsfile(manager, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
31 writeFits(fitsfile);
32}
void writeFits(std::string const &fileName, std::string const &mode="w") const
Write the object to a regular FITS file.

◆ 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]fileNameName of the file to write to.
[in]modeIf "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.

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

Member Data Documentation

◆ _spatialFunctionList

std::vector<SpatialFunctionPtr> lsst::afw::math::Kernel::_spatialFunctionList
protectedinherited

Definition at line 449 of file Kernel.h.


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