lsst.afw.math::SeparableKernel Class Reference

A kernel described by a pair of functions: func(x, y) = colFunc(x) * rowFunc(y) More...

#include <Kernel.h>

Inheritance diagram for lsst.afw.math::SeparableKernel:

Public Types
typedef boost::shared_ptr < SeparableKernel >	Ptr
typedef boost::shared_ptr < SeparableKernel const >	ConstPtr
typedef lsst::afw::math::Function1 < Pixel >	KernelFunction
typedef boost::shared_ptr < KernelFunction >	KernelFunctionPtr
Public Types inherited from lsst.afw.math::Kernel
typedef double	Pixel
typedef boost::shared_ptr< Kernel >	Ptr
typedef boost::shared_ptr < Kernel const >	ConstPtr
typedef boost::shared_ptr < lsst::afw::math::Function2 < double > >	SpatialFunctionPtr
typedef lsst::afw::math::Function2 < double >	SpatialFunction
typedef lsst::afw::math::NullFunction2 < double >	NullSpatialFunction
typedef generic_kernel_tag	kernel_fill_factor
Public Types inherited from lsst::daf::base::Citizen
enum	{ magicSentinel = 0xdeadbeef }
typedef unsigned long	memId
	Type of the block's ID. More...
typedef memId(*	memNewCallback )(const memId cid)
	A function used to register a callback. More...
typedef memId(*	memCallback )(const Citizen *ptr)
Public Types inherited from lsst::daf::base::Persistable
typedef boost::shared_ptr < Persistable >	Ptr

Public Member Functions
	SeparableKernel ()
	Construct an empty spatially invariant SeparableKernel of size 0x0. More...
	SeparableKernel (int width, int height, KernelFunction const &kernelColFunction, KernelFunction const &kernelRowFunction, Kernel::SpatialFunction const &spatialFunction=NullSpatialFunction())
	Construct a spatially invariant SeparableKernel, or a spatially varying SeparableKernel that uses the same functional form to model each function parameter. More...
	SeparableKernel (int width, int height, KernelFunction const &kernelColFunction, KernelFunction const &kernelRowFunction, std::vector< Kernel::SpatialFunctionPtr > const &spatialFunctionList)
	Construct a spatially varying SeparableKernel. More...
virtual	~SeparableKernel ()
virtual boost::shared_ptr< Kernel >	clone () const
	Return a pointer to a deep copy of this kernel. More...
double	computeVectors (std::vector< Pixel > &colList, std::vector< Pixel > &rowList, bool doNormalize, double x=0.0, double y=0.0) const
	Compute the column and row arrays in place, where kernel(col, row) = colList(col) * rowList(row) More...
virtual double	getKernelParameter (unsigned int i) const
virtual std::vector< double >	getKernelParameters () const
	Return the current kernel parameters. More...
KernelFunctionPtr	getKernelColFunction () const
	Get a deep copy of the col kernel function. More...
KernelFunctionPtr	getKernelRowFunction () const
	Get a deep copy of the row kernel function. More...
virtual std::string	toString (std::string const &prefix="") const
	Return a string representation of the kernel. More...
virtual void	computeCache (int const cacheSize)
	Compute a cache of Kernel values, if desired. More...
virtual int	getCacheSize () const
	Get the current cache size (0 if none) More...
Public Member Functions inherited from lsst.afw.math::Kernel
	Kernel ()
	Construct a null Kernel of size 0,0. More...
	Kernel (int width, int height, unsigned int nKernelParams, SpatialFunction const &spatialFunction=NullSpatialFunction())
	Construct a spatially invariant Kernel or a spatially varying Kernel with one spatial function that is duplicated as needed. More...
	Kernel (int width, int height, const std::vector< SpatialFunctionPtr > spatialFunctionList)
	Construct a spatially varying Kernel with a list of spatial functions (one per kernel parameter) More...
virtual	~Kernel ()
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. More...
geom::Extent2I const	getDimensions () const
	Return the Kernel's dimensions (width, height) More...
void	setDimensions (geom::Extent2I dims)
void	setWidth (int width)
void	setHeight (int height)
int	getWidth () const
	Return the Kernel's width. More...
int	getHeight () const
	Return the Kernel's height. More...
lsst::afw::geom::Point2I	getCtr () const
	Return index of kernel's center. More...
int	getCtrX () const
	Return x index of kernel's center. More...
int	getCtrY () const
	Return y index of kernel's center. More...
lsst::afw::geom::Box2I	getBBox () const
	return parent bounding box, with XY0 = -center More...
unsigned int	getNKernelParameters () const
	Return the number of kernel parameters (0 if none) More...
int	getNSpatialParameters () const
	Return the number of spatial parameters (0 if not spatially varying) More...
SpatialFunctionPtr	getSpatialFunction (unsigned int index) const
	Return a clone of the specified spatial function (one component of the spatial model) More...
std::vector< SpatialFunctionPtr >	getSpatialFunctionList () const
	Return a list of clones of the spatial functions. More...
lsst::afw::geom::Box2I	growBBox (lsst::afw::geom::Box2I const &bbox) const
lsst::afw::geom::Box2I	shrinkBBox (lsst::afw::geom::Box2I const &bbox) const
void	setCtr (lsst::afw::geom::Point2I ctr)
	Set index of kernel's center. More...
void	setCtrX (int ctrX)
	Set x index of kernel's center. More...
void	setCtrY (int ctrY)
	Set y index of kernel's center. More...
std::vector< std::vector < double > >	getSpatialParameters () const
	Return the spatial parameters parameters (an empty vector if not spatially varying) More...
bool	isSpatiallyVarying () const
	Return true iff the kernel is spatially varying (has a spatial function) More...
void	setKernelParameters (std::vector< double > const &params)
	Set the kernel parameters of a spatially invariant kernel. More...
void	setKernelParameters (std::pair< double, double > const &params)
	Set the kernel parameters of a 2-component spatially invariant kernel. More...
void	setSpatialParameters (const std::vector< std::vector< double > > params)
	Set the parameters of all spatial functions. More...
void	computeKernelParametersFromSpatialModel (std::vector< double > &kernelParams, double x, double y) const
	Compute the kernel parameters at a specified point. More...
Public Member Functions inherited from lsst::daf::base::Citizen
	Citizen (const std::type_info &)
	Citizen (Citizen const &)
	~Citizen ()
Citizen &	operator= (Citizen const &)
std::string	repr () const
	Return a string representation of a Citizen. More...
void	markPersistent (void)
	Mark a Citizen as persistent and not destroyed until process end. More...
memId	getId () const
	Return the Citizen's ID. More...
Public Member Functions inherited from lsst::daf::base::Persistable
	Persistable (void)
virtual	~Persistable (void)
template<class Archive >
void	serialize (Archive &, unsigned int const)
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 bool	isPersistable () const
	Return true if this particular object can be persisted using afw::table::io. More...
virtual	~Persistable ()

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

Private Member Functions
double	basicComputeVectors (std::vector< Pixel > &colList, std::vector< Pixel > &rowList, bool doNormalize) const
	Compute the column and row arrays in place, where kernel(col, row) = colList(col) * rowList(row) More...
template<class Archive >
void	serialize (Archive &ar, unsigned int const version)
virtual void	_setKernelXY ()

Private Attributes
KernelFunctionPtr	_kernelColFunctionPtr
KernelFunctionPtr	_kernelRowFunctionPtr
std::vector< Pixel >	_localColList
std::vector< Pixel >	_localRowList
std::vector< double >	_kernelX
std::vector< double >	_kernelY
std::vector< std::vector < double > >	_kernelRowCache
std::vector< std::vector < double > >	_kernelColCache

Friends
class	boost::serialization::access

Additional Inherited Members
Static Public Member Functions inherited from lsst.afw.table.io::PersistableFacade< SeparableKernel >
static boost::shared_ptr < SeparableKernel >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object. More...
static boost::shared_ptr < SeparableKernel >	readFits (std::string const &fileName, int hdu=0)
	Read an object from a regular FITS file. More...
static boost::shared_ptr < SeparableKernel >	readFits (fits::MemFileManager &manager, int hdu=0)
	Read an object from a FITS file in memory. More...
Static Public Member Functions inherited from lsst::daf::base::Citizen
static bool	hasBeenCorrupted ()
	Check all allocated blocks for corruption. More...
static memId	getNextMemId ()
	Return the memId of the next object to be allocated. More...
static int	init ()
	Called once when the memory system is being initialised. More...
static int	census (int, memId startingMemId=0)
	How many active Citizens are there? More...
static void	census (std::ostream &stream, memId startingMemId=0)
	Print a list of all active Citizens to stream, sorted by ID. More...
static const std::vector < const Citizen * > *	census ()
	Return a (newly allocated) std::vector of active Citizens sorted by ID. More...
static memId	setNewCallbackId (memId id)
	Call the NewCallback when block is allocated. More...
static memId	setDeleteCallbackId (memId id)
	Call the current DeleteCallback when block is deleted. More...
static memNewCallback	setNewCallback (memNewCallback func)
	Set the NewCallback function. More...
static memCallback	setDeleteCallback (memCallback func)
	Set the DeleteCallback function. More...
static memCallback	setCorruptionCallback (memCallback func)
	Set the CorruptionCallback function. More...
Static Public Member Functions inherited from lsst.afw.table.io::PersistableFacade< Kernel >
static boost::shared_ptr< Kernel >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object. More...
static boost::shared_ptr< Kernel >	readFits (std::string const &fileName, int hdu=0)
	Read an object from a regular FITS file. More...
static boost::shared_ptr< Kernel >	readFits (fits::MemFileManager &manager, int hdu=0)
	Read an object from a FITS file in memory. More...
Protected Types inherited from lsst.afw.table.io::Persistable
typedef io::OutputArchiveHandle	OutputArchiveHandle
Protected Attributes inherited from lsst.afw.math::Kernel
std::vector< SpatialFunctionPtr >	_spatialFunctionList

Detailed Description

A kernel described by a pair of functions: func(x, y) = colFunc(x) * rowFunc(y)

The function's x, y arguments are as follows:

• -getCtr() for the lower left corner pixel
• 0, 0 for the center pixel
• (getDimensions() - 1) - getCtr() for the upper right pixel

Note: each pixel is set to the value of the kernel function at the center of the pixel (rather than averaging the function over the area of the pixel).

Definition at line 986 of file Kernel.h.

Member Typedef Documentation

typedef boost::shared_ptr< SeparableKernel const> lsst.afw.math::SeparableKernel::ConstPtr

Definition at line 989 of file Kernel.h.

typedef lsst::afw::math::Function1<Pixel> lsst.afw.math::SeparableKernel::KernelFunction

Definition at line 990 of file Kernel.h.

typedef boost::shared_ptr< KernelFunction > lsst.afw.math::SeparableKernel::KernelFunctionPtr

Definition at line 991 of file Kernel.h.

typedef boost::shared_ptr< SeparableKernel > lsst.afw.math::SeparableKernel::Ptr

Definition at line 988 of file Kernel.h.

Constructor & Destructor Documentation

lsst.afw.math::SeparableKernel::SeparableKernel ( )

explicit

Construct an empty spatially invariant SeparableKernel of size 0x0.

Definition at line 35 of file SeparableKernel.cc.

:
    Kernel(),
    _kernelColFunctionPtr(),
    _kernelRowFunctionPtr(),
    _localColList(0), _localRowList(0),
    _kernelX(0), _kernelY(0),
    _kernelRowCache(0), _kernelColCache(0)
{
    _setKernelXY();
}

lsst.afw.math::SeparableKernel::SeparableKernel ( int  width, int  height, KernelFunction const &  kernelColFunction, KernelFunction const &  kernelRowFunction, Kernel::SpatialFunction const &  spatialFunction = NullSpatialFunction()  )

explicit

Construct a spatially invariant SeparableKernel, or a spatially varying SeparableKernel that uses the same functional form to model each function parameter.

Parameters

width	width of kernel
height	height of kernel
kernelColFunction	kernel column function
kernelRowFunction	kernel row function
spatialFunction	spatial function; one deep copy is made for each kernel column and row function parameter; if omitted or set to Kernel::NullSpatialFunction then the kernel is spatially invariant

Definition at line 47 of file SeparableKernel.cc.

  :
    Kernel(width, height, kernelColFunction.getNParameters() + kernelRowFunction.getNParameters(),
        spatialFunction),
    _kernelColFunctionPtr(kernelColFunction.clone()),
    _kernelRowFunctionPtr(kernelRowFunction.clone()),
    _localColList(width), _localRowList(height),
    _kernelX(width), _kernelY(height),
    _kernelRowCache(0), _kernelColCache(0)
{
    _setKernelXY();
}

lsst.afw.math::SeparableKernel::SeparableKernel ( int  width, int  height, KernelFunction const &  kernelColFunction, KernelFunction const &  kernelRowFunction, std::vector< Kernel::SpatialFunctionPtr > const &  spatialFunctionList  )

explicit

Construct a spatially varying SeparableKernel.

Exceptions

lsst::pex::exceptions::InvalidParameterError

if the length of spatialFunctionList != # kernel function parameters.

Parameters

width	width of kernel
height	height of kernel
kernelColFunction	kernel column function
kernelRowFunction	kernel row function
spatialFunctionList	list of spatial funcs, one per kernel column and row function parameter; a deep copy is made of each function

Definition at line 65 of file SeparableKernel.cc.

  :
    Kernel(width, height, spatialFunctionList),
    _kernelColFunctionPtr(kernelColFunction.clone()),
    _kernelRowFunctionPtr(kernelRowFunction.clone()),
    _localColList(width), _localRowList(height),
    _kernelX(width), _kernelY(height),
    _kernelRowCache(0), _kernelColCache(0)    
{
    if (kernelColFunction.getNParameters() + kernelRowFunction.getNParameters()
        != spatialFunctionList.size()) {
        std::ostringstream os;
        os << "kernelColFunction.getNParameters() + kernelRowFunction.getNParameters() = "
            << kernelColFunction.getNParameters() << " + " << kernelRowFunction.getNParameters()
            << " != " << spatialFunctionList.size() << " = " << "spatialFunctionList.size()";
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, os.str());
    }

    _setKernelXY();
}

virtual lsst.afw.math::SeparableKernel::~SeparableKernel ( )

inlinevirtual

Definition at line 1026 of file Kernel.h.

{}

Member Function Documentation

virtual void lsst.afw.math::SeparableKernel::_setKernelXY ( )

inlineprivatevirtual

Reimplemented from lsst.afw.math::Kernel.

Definition at line 1138 of file Kernel.h.

                                    {
            lsst::afw::geom::Extent2I const dim = getDimensions();
            lsst::afw::geom::Point2I const ctr = getCtr();

            assert (dim[0] == static_cast<int>(_kernelX.size()));
            for (int i = 0; i != dim.getX(); ++i) {
                _kernelX[i] = i - ctr.getX();
            }

            assert (dim[1] == static_cast<int>(_kernelY.size()));
            for (int i = 0; i != dim.getY(); ++i) {
                _kernelY[i] = i - ctr.getY();
            }
        }

double lsst.afw.math::SeparableKernel::basicComputeVectors ( std::vector< Pixel > &  colList, std::vector< Pixel > &  rowList, bool  doNormalize  ) const

private

Compute the column and row arrays in place, where kernel(col, row) = colList(col) * rowList(row)

Returns

the kernel sum (1.0 if doNormalize true)

Warning: the length of colList and rowList are not verified!

Exceptions

lsst::pex::exceptions::OverflowError

if doNormalize is true and the kernel sum is exactly 0

Parameters

colList	column vector
rowList	row vector
doNormalize	normalize the arrays (so sum of each is 1)?

Definition at line 190 of file SeparableKernel.cc.

        {
    double colSum = 0.0;
    if (_kernelColCache.empty()) {
        for (unsigned int i = 0; i != colList.size(); ++i) {
            double colFuncValue = (*_kernelColFunctionPtr)(_kernelX[i]);
            colList[i] = colFuncValue;
            colSum += colFuncValue;
        }
    } else {
        int const cacheSize = _kernelColCache.size();
        
        int const indx = this->getKernelParameter(0)*cacheSize;

        std::vector<double> &cachedValues = _kernelColCache.at(indx);
        for (unsigned int i = 0; i != colList.size(); ++i) {
            double colFuncValue = cachedValues[i];
            colList[i] = colFuncValue;
            colSum += colFuncValue;
        }
    }

    double rowSum = 0.0;
    if (_kernelRowCache.empty()) {
        for (unsigned int i = 0; i != rowList.size(); ++i) {
            double rowFuncValue = (*_kernelRowFunctionPtr)(_kernelY[i]);
            rowList[i] = rowFuncValue;
            rowSum += rowFuncValue;
        }
    } else {
        int const cacheSize = _kernelRowCache.size();
        
        int const indx = this->getKernelParameter(1)*cacheSize;
        
        std::vector<double> &cachedValues = _kernelRowCache.at(indx);
        for (unsigned int i = 0; i != rowList.size(); ++i) {
            double rowFuncValue = cachedValues[i];
            rowList[i] = rowFuncValue;
            rowSum += rowFuncValue;

#if 0
            if (indx == cacheSize/2) {
                if (::fabs(rowFuncValue - (*_kernelRowFunctionPtr)(_kernelX[i])) > 1e-2) {
                    std::cout << indx << " " << i << " "
                              << rowFuncValue << " "
                              << (*_kernelRowFunctionPtr)(_kernelX[i])
                              << std::endl;
                }
            }
#endif
        }
    }

    double imSum = colSum * rowSum;
    if (doNormalize) {
        if ((colSum == 0) || (rowSum == 0)) {
            throw LSST_EXCEPT(pexExcept::OverflowError, "Cannot normalize; kernel sum is 0");
        }
        for (std::vector<Pixel>::iterator colIter = colList.begin(); colIter != colList.end(); ++colIter) {
            *colIter /= colSum;
        }

        for (std::vector<Pixel>::iterator rowIter = rowList.begin(); rowIter != rowList.end(); ++rowIter) {
            *rowIter /= rowSum;
        }
        imSum = 1.0;
    }
    return imSum;
}

boost::shared_ptr< afwMath::Kernel > lsst.afw.math::SeparableKernel::clone ( ) const

virtual

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.

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

Definition at line 91 of file SeparableKernel.cc.

                                                       {
    PTR(afwMath::Kernel) retPtr;
    if (this->isSpatiallyVarying()) {
        retPtr.reset(new afwMath::SeparableKernel(this->getWidth(), this->getHeight(),
            *(this->_kernelColFunctionPtr), *(this->_kernelRowFunctionPtr), this->_spatialFunctionList));
    } else {
        retPtr.reset(new afwMath::SeparableKernel(this->getWidth(), this->getHeight(),
            *(this->_kernelColFunctionPtr), *(this->_kernelRowFunctionPtr)));
    }
    retPtr->setCtr(this->getCtr());
    retPtr->computeCache(this->getCacheSize());
    return retPtr;
}

void lsst.afw.math::SeparableKernel::computeCache ( int const  const )

virtual

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.

Parameters

const

cache size (number of double precision array elements in the x and y caches)

Reimplemented from lsst.afw.math::Kernel.

Definition at line 308 of file SeparableKernel.cc.

  {
    afwMath::SeparableKernel::KernelFunctionPtr func;

    func = getKernelColFunction();
    _computeCache(cacheSize, _kernelY, func, &_kernelColCache);

    func = getKernelRowFunction();
    _computeCache(cacheSize, _kernelX, func, &_kernelRowCache);
}

double lsst.afw.math::SeparableKernel::computeVectors	(	std::vector< Pixel > &	colList,
		std::vector< Pixel > &	rowList,
		bool	doNormalize,
		double	x = 0.0,
		double	y = 0.0
	)		const

Compute the column and row arrays in place, where kernel(col, row) = colList(col) * rowList(row)

x, y are ignored if there is no spatial function.

Returns

the kernel sum (1.0 if doNormalize true)

Exceptions

lsst::pex::exceptions::InvalidParameterError	if colList or rowList is the wrong size
lsst::pex::exceptions::OverflowError	if doNormalize is true and the kernel sum is exactly 0

Parameters

colList	column vector
rowList	row vector
doNormalize	normalize the image (so sum of each is 1)?
x	x (column position) at which to compute spatial function
y	y (row position) at which to compute spatial function

Definition at line 105 of file SeparableKernel.cc.

        {
    if (static_cast<int>(colList.size()) != this->getWidth()
        || static_cast<int>(rowList.size()) != this->getHeight()) {
        std::ostringstream os;
        os << "colList.size(), rowList.size() = ("
            << colList.size() << ", " << rowList.size()
            << ") != ("<< this->getWidth() << ", " << this->getHeight()
            << ") = " << "kernel dimensions";
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, os.str());
    }
    if (this->isSpatiallyVarying()) {
        this->setKernelParametersFromSpatialModel(x, y);
    }
    
    return basicComputeVectors(colList, rowList, doNormalize);
}

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

protectedvirtual

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.

Returns

The kernel sum

Implements lsst.afw.math::Kernel.

Definition at line 160 of file SeparableKernel.cc.

        {
    double imSum = basicComputeVectors(_localColList, _localRowList, doNormalize);

    for (int y = 0; y != image.getHeight(); ++y) {
        afwImage::Image<Pixel>::x_iterator imPtr = image.row_begin(y);
        for (std::vector<Pixel>::iterator colIter = _localColList.begin();
             colIter != _localColList.end(); ++colIter, ++imPtr) {
            *imPtr = (*colIter)*_localRowList[y];
        }
    }
    
    return imSum;
}

int lsst.afw.math::SeparableKernel::getCacheSize ( ) const

virtual

Get the current cache size (0 if none)

Reimplemented from lsst.afw.math::Kernel.

Definition at line 320 of file SeparableKernel.cc.

                                               {
    return _kernelColCache.size();
};

afwMath::SeparableKernel::KernelFunctionPtr lsst.afw.math::SeparableKernel::getKernelColFunction

(

)

const

Get a deep copy of the col kernel function.

Definition at line 128 of file SeparableKernel.cc.

        {
    return _kernelColFunctionPtr->clone();
}

virtual double lsst.afw.math::SeparableKernel::getKernelParameter ( unsigned int  i ) const

inlinevirtual

Return a particular Kernel Parameter (no bounds checking). This version is slow, but specialisations may be faster

Reimplemented from lsst.afw.math::Kernel.

Definition at line 1049 of file Kernel.h.

                                                                {
            unsigned int const ncol = _kernelColFunctionPtr->getNParameters();
            if (i < ncol) {
                return _kernelColFunctionPtr->getParameter(i);
            } else {
                i -= ncol;
                return _kernelRowFunctionPtr->getParameter(i);
            }
        }

std::vector< double > lsst.afw.math::SeparableKernel::getKernelParameters ( ) const

virtual

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 149 of file SeparableKernel.cc.

                                                                    {
    std::vector<double> allParams = _kernelColFunctionPtr->getParameters();
    std::vector<double> yParams = _kernelRowFunctionPtr->getParameters();
    std::copy(yParams.begin(), yParams.end(), std::back_inserter(allParams));
    return allParams;
}

afwMath::SeparableKernel::KernelFunctionPtr lsst.afw.math::SeparableKernel::getKernelRowFunction

(

)

const

Get a deep copy of the row kernel function.

Definition at line 133 of file SeparableKernel.cc.

        {
    return _kernelRowFunctionPtr->clone();
}

template<class Archive >

void lsst.afw.math::SeparableKernel::serialize ( Archive &  ar, unsigned int const  version  )

inlineprivate

Definition at line 1127 of file Kernel.h.

                                                                    {
                ar & make_nvp("k",
                    boost::serialization::base_object<Kernel>(*this));
                ar & make_nvp("colfn", _kernelColFunctionPtr);
                ar & make_nvp("rowfn", _kernelRowFunctionPtr);
                ar & make_nvp("cols", _localColList);
                ar & make_nvp("rows", _localRowList);
                ar & make_nvp("kernelX", _kernelX);
                ar & make_nvp("kernelY", _kernelY);
            }

void lsst.afw.math::SeparableKernel::setKernelParameter ( unsigned int  ind, double  value  ) const

protectedvirtual

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::InvalidParameterError

always (unless subclassed)

Reimplemented from lsst.afw.math::Kernel.

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

Definition at line 177 of file SeparableKernel.cc.

                                                                                    {
    unsigned int const nColParams = _kernelColFunctionPtr->getNParameters();
    if (ind < nColParams) {
        _kernelColFunctionPtr->setParameter(ind, value);
    } else {
        _kernelRowFunctionPtr->setParameter(ind - nColParams, value);
    }
}

std::string lsst.afw.math::SeparableKernel::toString ( std::string const &  prefix = "" ) const

virtual

Return a string representation of the kernel.

Reimplemented from lsst.afw.math::Kernel.

Definition at line 138 of file SeparableKernel.cc.

                                                                        {
    std::ostringstream os;
    os << prefix << "SeparableKernel:" << std::endl;
    os << prefix << "..x (width) function: "
        << (_kernelColFunctionPtr ? _kernelColFunctionPtr->toString() : "None") << std::endl;
    os << prefix << "..y (rows) function: "
        << (_kernelRowFunctionPtr ? _kernelRowFunctionPtr->toString() : "None") << std::endl;
    os << Kernel::toString(prefix + "\t");
    return os.str();
}

Friends And Related Function Documentation

friend class boost::serialization::access

friend

Definition at line 1125 of file Kernel.h.

Member Data Documentation

std::vector<std::vector<double> > lsst.afw.math::SeparableKernel::_kernelColCache

mutableprivate

Definition at line 1123 of file Kernel.h.

KernelFunctionPtr lsst.afw.math::SeparableKernel::_kernelColFunctionPtr

private

Definition at line 1113 of file Kernel.h.

std::vector<std::vector<double> > lsst.afw.math::SeparableKernel::_kernelRowCache

mutableprivate

Definition at line 1122 of file Kernel.h.

KernelFunctionPtr lsst.afw.math::SeparableKernel::_kernelRowFunctionPtr

private

Definition at line 1114 of file Kernel.h.

std::vector<double> lsst.afw.math::SeparableKernel::_kernelX

mutableprivate

Definition at line 1117 of file Kernel.h.

std::vector<double> lsst.afw.math::SeparableKernel::_kernelY

mutableprivate

Definition at line 1118 of file Kernel.h.

std::vector<Pixel> lsst.afw.math::SeparableKernel::_localColList

mutableprivate

Definition at line 1115 of file Kernel.h.

std::vector<Pixel> lsst.afw.math::SeparableKernel::_localRowList

mutableprivate

Definition at line 1116 of file Kernel.h.

---

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

• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/include/lsst/afw/math/Kernel.h
• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/src/math/SeparableKernel.cc