A purely radial polynomial distortion, up to 6th order. More...

#include <XYTransform.h>

Inheritance diagram for lsst::afw::geom::RadialXYTransform:

Public Types
typedef afw::geom::Point2D	Point2D

typedef afw::geom::AffineTransform	AffineTransform

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 Member Functions
	RadialXYTransform (std::vector< double > const &coeffs)

	RadialXYTransform (RadialXYTransform const &)

	RadialXYTransform (RadialXYTransform &&)

RadialXYTransform &	operator= (RadialXYTransform const &)

RadialXYTransform &	operator= (RadialXYTransform &&)

	~RadialXYTransform ()

virtual std::shared_ptr< XYTransform >	clone () const
	returns a deep copy More...

virtual std::shared_ptr< XYTransform >	invert () const
	returns a "deep inverse" in this sense that the forward+inverse transforms do not share state default implementation; subclass may override More...

virtual Point2D	forwardTransform (Point2D const &point) const
	virtuals for forward and reverse transforms More...

virtual Point2D	reverseTransform (Point2D const &point) const

virtual AffineTransform	linearizeForwardTransform (Point2D const &point) const
	linearized forward and reversed transforms More...

virtual AffineTransform	linearizeReverseTransform (Point2D const &point) const
	default implementation; subclass may override More...

std::vector< double >	getCoeffs () 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...

Static Public Member Functions
static std::vector< double >	polyInvert (std::vector< double > const &coeffs)
	These static member functions operate on polynomials represented by vector<double>. More...

static double	polyEval (std::vector< double > const &coeffs, double x)

static Point2D	polyEval (std::vector< double > const &coeffs, Point2D const &p)

static double	polyEvalDeriv (std::vector< double > const &coeffs, double x)

static AffineTransform	polyEvalJacobian (std::vector< double > const &coeffs, Point2D const &p)

static double	polyEvalInverse (std::vector< double > const &coeffs, std::vector< double > const &icoeffs, double x)

static Point2D	polyEvalInverse (std::vector< double > const &coeffs, std::vector< double > const &icoeffs, Point2D const &p)

static AffineTransform	polyEvalInverseJacobian (std::vector< double > const &coeffs, std::vector< double > const &icoeffs, Point2D const &p)

static AffineTransform	makeAffineTransform (double x, double y, double f, double g)

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...

Census
Provide a list of current Citizens
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...

callbackIDs
Set callback Ids. The old Id is returned
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...

callbacks
Set the New/Delete callback functions; in each case the previously installed callback is returned. These callback functions return a value which is Added to the previously registered id. The default callback functions are called default{New,Delete}Callback; you may want to set a break point in these callbacks from your favourite debugger
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...

Protected Attributes
std::vector< double >	_coeffs

std::vector< double >	_icoeffs

Detailed Description

A purely radial polynomial distortion, up to 6th order.

Deprecated:: Deprecated in 14.0. Will be removed in 15.0; it is superseded by geom::makeRadialTransform.

forwardTransform(pt) = pt * scale where:

scale = (coeffs[1] r + coeffs[2] r^2 + ...) / r
r = magnitude of pt

Warning: reverseTransform will fail if the polynomial is too far from linear (ticket #3152)

Exceptions

lsst::pex::exceptions::InvalidParameterError if coeffs.size() > 0 and any of the following are true: coeffs.size() == 1, coeffs[0] != 0 or coeffs[1] == 0

Definition at line 225 of file XYTransform.h.

Member Typedef Documentation

◆ AffineTransform

typedef afw::geom::AffineTransform lsst::afw::geom::XYTransform::AffineTransform

inherited

Definition at line 52 of file XYTransform.h.

◆ memCallback

typedef memId(* lsst::daf::base::Citizen::memCallback) (const Citizen *ptr)

inherited

Definition at line 59 of file Citizen.h.

◆ memId

typedef unsigned long lsst::daf::base::Citizen::memId

inherited

Type of the block's ID.

Definition at line 56 of file Citizen.h.

◆ memNewCallback

typedef memId(* lsst::daf::base::Citizen::memNewCallback) (const memId cid)

inherited

A function used to register a callback.

Definition at line 58 of file Citizen.h.

◆ Point2D

typedef afw::geom::Point2D lsst::afw::geom::XYTransform::Point2D

inherited

Definition at line 51 of file XYTransform.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

inherited

Enumerator
magicSentinel

Definition at line 86 of file Citizen.h.

86 { magicSentinel = 0xdeadbeef };

lsst::daf::base::Citizen::magicSentinel

Definition: Citizen.h:86

Constructor & Destructor Documentation

◆ RadialXYTransform() [1/3]

lsst::afw::geom::RadialXYTransform::RadialXYTransform ( std::vector< double > const & coeffs )

Parameters

coeffs radial polynomial coefficients; if size == 0 then gives the identity transformation; otherwise must satisfy: size > 1, coeffs[0] == 0, and coeffs[1] != 0

Definition at line 37 of file RadialXYTransform.cc.

                                                                     : XYTransform() {
     if (coeffs.size() == 0) {
         // constructor called with no arguments = identity transformation
         _coeffs.resize(2);
         _coeffs[0] = 0.0;
         _coeffs[1] = 1.0;
     } else {
         if ((coeffs.size() == 1) || (coeffs[0] != 0.0) || (coeffs[1] == 0.0)) {
             // Discontinuous or singular transformation; presumably unintentional so throw exception
             throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                               "invalid parameters for radial distortion: need coeffs.size() != 1, "
                               "coeffs[0]==0, coeffs[1]!=0");
         }
         _coeffs = coeffs;
     }
 
     _icoeffs = polyInvert(_coeffs);
 }

◆ RadialXYTransform() [2/3]

lsst::afw::geom::RadialXYTransform::RadialXYTransform ( RadialXYTransform const & )

default

◆ RadialXYTransform() [3/3]

lsst::afw::geom::RadialXYTransform::RadialXYTransform ( RadialXYTransform && )

default

◆ ~RadialXYTransform()

lsst::afw::geom::RadialXYTransform::~RadialXYTransform ( )

default

Member Function Documentation

◆ census() [1/3]

int lsst::daf::base::Citizen::census	(	int	,
		memId	startingMemId = `0`
	)

staticinherited

How many active Citizens are there?

Parameters

startingMemId Don't print Citizens with lower IDs

Definition at line 261 of file Citizen.cc.

       {
     if (startingMemId == 0) {              // easy
         ReadGuard guard(citizenLock);
         return _activeCitizens.size();
     }
 
     int n = 0;
     ReadGuard guard(citizenLock);
     for (table::iterator cur = _activeCitizens.begin();
          cur != _activeCitizens.end(); cur++) {
         if (cur->first->_CitizenId >= startingMemId) {
             n++;
         }
     }
 
     return n;    
 }

◆ census() [2/3]

void lsst::daf::base::Citizen::census	(	std::ostream &	stream,
		memId	startingMemId = `0`
	)

staticinherited

Print a list of all active Citizens to stream, sorted by ID.

Parameters

stream	stream to print to
startingMemId	Don't print Citizens with lower IDs

Definition at line 284 of file Citizen.cc.

       {
     ReadGuard guard(citizenLock);
 
     std::unique_ptr<std::vector<Citizen const*> const> leaks(Citizen::census());
 
     for (std::vector<Citizen const *>::const_iterator citizen = leaks->begin(), end = leaks->end();
          citizen != end; ++citizen) {
         if ((*citizen)->getId() >= startingMemId) {
             stream << (*citizen)->repr() << "\n";
         }
     }
 }

◆ census() [3/3]

std::vector< dafBase::Citizen const * > const * lsst::daf::base::Citizen::census ( )

staticinherited

Return a (newly allocated) std::vector of active Citizens sorted by ID.

You are responsible for deleting it; or you can say std::unique_ptr<std::vector<Citizen const*> const> leaks(Citizen::census()); and not bother (that becomes std::unique_ptr in C++11)

Definition at line 316 of file Citizen.cc.

                                                                {
     std::vector<Citizen const*>* vec =
         new std::vector<Citizen const*>(0);
     ReadGuard guard(citizenLock);
     vec->reserve(_activeCitizens.size());
 
     for (table::iterator cur = _activeCitizens.begin();
          cur != _activeCitizens.end(); cur++) {
         vec->push_back(dynamic_cast<Citizen const*>(cur->first));
     }
         
     std::sort(vec->begin(), vec->end(), cmpId);
 
     return vec;
 }

◆ clone()

std::shared_ptr< XYTransform > lsst::afw::geom::RadialXYTransform::clone ( ) const

virtual

returns a deep copy

Implements lsst::afw::geom::XYTransform.

Definition at line 62 of file RadialXYTransform.cc.

                                                           {
     return std::make_shared<RadialXYTransform>(_coeffs);
 }

◆ forwardTransform()

Point2D lsst::afw::geom::RadialXYTransform::forwardTransform ( Point2D const & point ) const

virtual

virtuals for forward and reverse transforms

These routines are responsible for throwing exceptions if the 'point' arg is outside the domain of the transform.

Implements lsst::afw::geom::XYTransform.

Definition at line 70 of file RadialXYTransform.cc.

70 { return polyEval(_coeffs, p); }

lsst::afw::geom::RadialXYTransform::_coeffs

std::vector< double > _coeffs

Definition: XYTransform.h:273

lsst::afw::geom::RadialXYTransform::polyEval

static double polyEval(std::vector< double > const &coeffs, double x)

Definition: RadialXYTransform.cc:136

◆ getCoeffs()

std::vector<double> lsst::afw::geom::RadialXYTransform::getCoeffs ( ) const

inline

Definition at line 246 of file XYTransform.h.

246 { return _coeffs; }

lsst::afw::geom::RadialXYTransform::_coeffs

std::vector< double > _coeffs

Definition: XYTransform.h:273

◆ getId()

dafBase::Citizen::memId lsst::daf::base::Citizen::getId ( ) const

inherited

Return the Citizen's ID.

Definition at line 218 of file Citizen.cc.

                                                 {
     return _CitizenId;
 }

◆ getNextMemId()

dafBase::Citizen::memId lsst::daf::base::Citizen::getNextMemId ( )

staticinherited

Return the memId of the next object to be allocated.

Definition at line 223 of file Citizen.cc.

                                                  {
     return _nextMemId();
 }

◆ hasBeenCorrupted()

bool lsst::daf::base::Citizen::hasBeenCorrupted ( )

staticinherited

Check all allocated blocks for corruption.

Definition at line 347 of file Citizen.cc.

                                       {
     ReadGuard guard(citizenLock);
     for (table::iterator cur = _activeCitizens.begin();
          cur != _activeCitizens.end(); cur++) {
         if (cur->first->_hasBeenCorrupted()) {
             return true;
         }
     }
     for (table::iterator cur = _persistentCitizens.begin();
          cur != _persistentCitizens.end(); cur++) {
         if (cur->first->_hasBeenCorrupted()) {
             return true;
         }
     }
 
     return false;
 }

◆ init()

int lsst::daf::base::Citizen::init ( )

staticinherited

Called once when the memory system is being initialised.

Definition at line 208 of file Citizen.cc.

                          {
     volatile int dummy = 1;
     return dummy;
 }

◆ invert()

std::shared_ptr< XYTransform > lsst::afw::geom::RadialXYTransform::invert ( ) const

virtual

returns a "deep inverse" in this sense that the forward+inverse transforms do not share state default implementation; subclass may override

Reimplemented from lsst::afw::geom::XYTransform.

Definition at line 66 of file RadialXYTransform.cc.

                                                            {
     return std::make_shared<RadialXYTransform>(_coeffs);
 }

◆ linearizeForwardTransform()

AffineTransform lsst::afw::geom::RadialXYTransform::linearizeForwardTransform ( Point2D const & point ) const

virtual

linearized forward and reversed transforms

Deprecated:: Deprecated in 14.0. Will be removed in 15.0; it is superseded by geom::linearizeTransform.

These are virtual but not pure virtual; there is a default implementation which calls forwardTransform() or reverseTransform() and takes finite differences with step size equal to one.

The following should always be satisfied for an arbitrary Point2D p (and analogously for the reverse transform) this->forwardTransform(p) == this->linearizeForwardTransform(p)(p);default implementation; subclass may override

Reimplemented from lsst::afw::geom::XYTransform.

Definition at line 76 of file RadialXYTransform.cc.

                                                                                    {
     return polyEvalJacobian(_coeffs, p);
 }

◆ linearizeReverseTransform()

AffineTransform lsst::afw::geom::RadialXYTransform::linearizeReverseTransform ( Point2D const & point ) const

virtual

default implementation; subclass may override

Reimplemented from lsst::afw::geom::XYTransform.

Definition at line 80 of file RadialXYTransform.cc.

                                                                                    {
     return polyEvalInverseJacobian(_coeffs, _icoeffs, p);
 }

◆ makeAffineTransform()

AffineTransform lsst::afw::geom::RadialXYTransform::makeAffineTransform	(	double	x,
		double	y,
		double	f,
		double	g
	)

static

Definition at line 220 of file RadialXYTransform.cc.

                                                                                                      {
     double r = ::hypot(x, y);
 
     if (r <= 0.0) {
         AffineTransform ret;
         ret[0] = ret[3] = rderiv;  // ret = rderiv * (identity)
         return ret;
     }
 
     //
     // Note: calculation of "t" is numerically unstable as r->0, since p'(r) and p(r)/r will be
     // nearly equal.  However, detailed analysis shows that this is actually OK.  The numerical
     // instability means that the roundoff error in t is O(10^{-17}) even though t is formally O(r).
     //
     // Propagating through the formulas below, the AffineTransform is
     // [rderiv*I + O(r) + O(10^{-17})] which is fine (assuming rderiv is nonzero as r->0).
     //
     double t = rderiv - rnew / r;
 
     AffineTransform ret;
     ret[0] = (rderiv * x * x + rnew / r * y * y) / (r * r);  // a00
     ret[1] = ret[2] = t * x * y / (r * r);                   // a01 == a10 for this transform
     ret[3] = (rderiv * y * y + rnew / r * x * x) / (r * r);  // a11
     ret[4] = -t * x;                                         // v0
     ret[5] = -t * y;                                         // v1
     return ret;
 }

◆ markPersistent()

void lsst::daf::base::Citizen::markPersistent ( void )

inherited

Mark a Citizen as persistent and not destroyed until process end.

Definition at line 248 of file Citizen.cc.

                                         {
     WriteGuard guard(citizenLock);
     _persistentCitizens[this] = _activeCitizens[this];
     _activeCitizens.erase(this);
 }

◆ operator=() [1/2]

RadialXYTransform & lsst::afw::geom::RadialXYTransform::operator= ( RadialXYTransform const & )

default

◆ operator=() [2/2]

RadialXYTransform & lsst::afw::geom::RadialXYTransform::operator= ( RadialXYTransform && )

default

◆ polyEval() [1/2]

double lsst::afw::geom::RadialXYTransform::polyEval	(	std::vector< double > const &	coeffs,
		double	x
	)

static

Definition at line 136 of file RadialXYTransform.cc.

                                                                             {
     int n = coeffs.size();
 
     double ret = 0.0;
     for (int i = n - 1; i >= 0; i--) ret = ret * x + coeffs[i];
 
     return ret;
 }

◆ polyEval() [2/2]

Point2D lsst::afw::geom::RadialXYTransform::polyEval	(	std::vector< double > const &	coeffs,
		Point2D const &	p
	)

static

Definition at line 145 of file RadialXYTransform.cc.

                                                                                      {
     double r = p.asEigen().norm();
 
     if (r > 0.0) {
         double rnew = polyEval(coeffs, r);
         return Point2D(rnew * p.getX() / r, rnew * p.getY() / r);
     }
 
     if (coeffs.size() == 0 || coeffs[0] != 0.0) {
         throw LSST_EXCEPT(pexEx::InvalidParameterError, "invalid parameters for radial distortion");
     }
 
     return Point2D(0, 0);
 }

◆ polyEvalDeriv()

double lsst::afw::geom::RadialXYTransform::polyEvalDeriv	(	std::vector< double > const &	coeffs,
		double	x
	)

static

Definition at line 160 of file RadialXYTransform.cc.

                                                                                  {
     int n = coeffs.size();
 
     double ret = 0.0;
     for (int i = n - 1; i >= 1; i--) ret = ret * x + i * coeffs[i];
 
     return ret;
 }

◆ polyEvalInverse() [1/2]

double lsst::afw::geom::RadialXYTransform::polyEvalInverse	(	std::vector< double > const &	coeffs,
		std::vector< double > const &	icoeffs,
		double	x
	)

static

Definition at line 176 of file RadialXYTransform.cc.

                                                                                       {
     static const int maxIter = 1000;
     double tolerance = 1.0e-14 * x;
 
     double r = polyEval(icoeffs, x);  // initial guess
     int iter = 0;
 
     for (;;) {
         double dx = x - polyEval(coeffs, r);  // residual
         if (fabs(dx) <= tolerance) return r;
         if (iter++ > maxIter) {
             throw LSST_EXCEPT(pexEx::RuntimeError,
                               "max iteration count exceeded in RadialXYTransform::polyEvalInverse");
         }
         r += dx / polyEvalDeriv(coeffs, r);  // Newton-Raphson iteration
     }
 }

◆ polyEvalInverse() [2/2]

Point2D lsst::afw::geom::RadialXYTransform::polyEvalInverse	(	std::vector< double > const &	coeffs,
		std::vector< double > const &	icoeffs,
		Point2D const &	p
	)

static

Definition at line 195 of file RadialXYTransform.cc.

                                                                                                {
     double r = p.asEigen().norm();
 
     if (r > 0.0) {
         double rnew = polyEvalInverse(coeffs, icoeffs, r);
         return Point2D(rnew * p.getX() / r, rnew * p.getY() / r);
     }
 
     if (coeffs.size() == 0 || coeffs[0] != 0.0) {
         throw LSST_EXCEPT(pexEx::InvalidParameterError, "invalid parameters for radial distortion");
     }
 
     return Point2D(0, 0);
 }

◆ polyEvalInverseJacobian()

AffineTransform lsst::afw::geom::RadialXYTransform::polyEvalInverseJacobian	(	std::vector< double > const &	coeffs,
		std::vector< double > const &	icoeffs,
		Point2D const &	p
	)

static

Definition at line 211 of file RadialXYTransform.cc.

                                                                              {
     double r = p.asEigen().norm();
     double rnew = polyEvalInverse(coeffs, icoeffs, r);
     double rderiv = 1.0 / polyEvalDeriv(coeffs, rnew);
     return makeAffineTransform(p.getX(), p.getY(), rnew, rderiv);
 }

◆ polyEvalJacobian()

AffineTransform lsst::afw::geom::RadialXYTransform::polyEvalJacobian	(	std::vector< double > const &	coeffs,
		Point2D const &	p
	)

static

Definition at line 169 of file RadialXYTransform.cc.

                                                                                                      {
     double r = p.asEigen().norm();
     double rnew = polyEval(coeffs, r);
     double rderiv = polyEvalDeriv(coeffs, r);
     return makeAffineTransform(p.getX(), p.getY(), rnew, rderiv);
 }

◆ polyInvert()

std::vector< double > lsst::afw::geom::RadialXYTransform::polyInvert ( std::vector< double > const & coeffs )

static

These static member functions operate on polynomials represented by vector<double>.

They are intended mainly as helpers for the virtual member functions above, but are declared public since there are also some unit tests which call them.

Definition at line 95 of file RadialXYTransform.cc.

                                                                                {
     static const unsigned int maxN = 7;  // degree of output polynomial + 1
 
     //
     // Some sanity checks.  The formulas for the inversion below assume c0 == 0 and c1 != 0
     //
     if (coeffs.size() <= 1 || coeffs.size() > maxN || coeffs[0] != 0.0 || coeffs[1] == 0.0)
         throw LSST_EXCEPT(pexEx::InvalidParameterError,
                           "invalid parameters in RadialXYTransform::polyInvert");
 
     std::vector<double> c = coeffs;
     c.resize(maxN, 0.0);
 
     std::vector<double> ic(maxN);
 
     ic[0] = 0.0;
 
     ic[1] = 1.0;
     ic[1] /= c[1];
 
     ic[2] = -c[2];
     ic[2] /= std::pow(c[1], 3);
 
     ic[3] = 2.0 * c[2] * c[2] - c[1] * c[3];
     ic[3] /= std::pow(c[1], 5);
 
     ic[4] = 5.0 * c[1] * c[2] * c[3] - 5.0 * c[2] * c[2] * c[2] - c[1] * c[1] * c[4];
     ic[4] /= std::pow(c[1], 7);
 
     ic[5] = 6.0 * c[1] * c[1] * c[2] * c[4] + 3.0 * c[1] * c[1] * c[3] * c[3] - c[1] * c[1] * c[1] * c[5] +
             14.0 * std::pow(c[2], 4) - 21.0 * c[1] * c[2] * c[2] * c[3];
     ic[5] /= std::pow(c[1], 9);
 
     ic[6] = 7.0 * c[1] * c[1] * c[1] * c[2] * c[5] + 84.0 * c[1] * c[2] * c[2] * c[2] * c[3] +
             7.0 * c[1] * c[1] * c[1] * c[3] * c[4] - 28.0 * c[1] * c[1] * c[2] * c[3] * c[3] -
             std::pow(c[1], 4) * c[6] - 28.0 * c[1] * c[1] * c[2] * c[2] * c[4] - 42.0 * std::pow(c[2], 5);
     ic[6] /= std::pow(c[1], 11);
 
     return ic;
 }

◆ repr()

std::string lsst::daf::base::Citizen::repr ( ) const

inherited

Return a string representation of a Citizen.

Definition at line 239 of file Citizen.cc.

                                      {
     return boost::str(boost::format("%d: %08x %s")
                       % _CitizenId
                       % this
                       % lsst::utils::demangleType(_typeName)
                      );
 }

◆ reverseTransform()

Point2D lsst::afw::geom::RadialXYTransform::reverseTransform ( Point2D const & point ) const

virtual

Implements lsst::afw::geom::XYTransform.

Definition at line 72 of file RadialXYTransform.cc.

                                                                   {
     return polyEvalInverse(_coeffs, _icoeffs, p);
 }

◆ setCorruptionCallback()

dafBase::Citizen::memCallback lsst::daf::base::Citizen::setCorruptionCallback ( Citizen::memCallback func )

staticinherited

Set the CorruptionCallback function.

Parameters

func	function be called when block is found to be corrupted

Definition at line 426 of file Citizen.cc.

                                                      {
     Citizen::memCallback old = _corruptionCallback;
     _corruptionCallback = func;
 
     return old;
 }

◆ setDeleteCallback()

dafBase::Citizen::memCallback lsst::daf::base::Citizen::setDeleteCallback ( Citizen::memCallback func )

staticinherited

Set the DeleteCallback function.

Parameters

func	function be called when desired block is deleted

Definition at line 416 of file Citizen.cc.

       {
     Citizen::memCallback old = _deleteCallback;
     _deleteCallback = func;
 
     return old;
 }

◆ setDeleteCallbackId()

dafBase::Citizen::memId lsst::daf::base::Citizen::setDeleteCallbackId ( Citizen::memId id )

staticinherited

Call the current DeleteCallback when block is deleted.

Parameters

id	Desired ID

Definition at line 381 of file Citizen.cc.

       {
     WriteGuard guard(citizenLock);
     Citizen::memId oldId = _deleteId;
     _deleteId = id;
 
     return oldId;
 }

◆ setNewCallback()

dafBase::Citizen::memNewCallback lsst::daf::base::Citizen::setNewCallback ( Citizen::memNewCallback func )

staticinherited

Set the NewCallback function.

Parameters

func	The new function to be called when a designated block is allocated

Definition at line 406 of file Citizen.cc.

       {
     Citizen::memNewCallback old = _newCallback;
     _newCallback = func;
 
     return old;
 }

◆ setNewCallbackId()

dafBase::Citizen::memId lsst::daf::base::Citizen::setNewCallbackId ( Citizen::memId id )

staticinherited

Call the NewCallback when block is allocated.

Parameters

id	Desired ID

Definition at line 370 of file Citizen.cc.

       {
     WriteGuard guard(citizenLock);
     Citizen::memId oldId = _newId;
     _newId = id;
 
     return oldId;
 }

Member Data Documentation

◆ _coeffs

std::vector<double> lsst::afw::geom::RadialXYTransform::_coeffs

protected

Definition at line 273 of file XYTransform.h.

◆ _icoeffs

std::vector<double> lsst::afw::geom::RadialXYTransform::_icoeffs

protected

Definition at line 274 of file XYTransform.h.

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

/home/jenkins-slave/snowflake/release/lsstsw/stack/Linux64/afw/15.0-16-g953e39cab/include/lsst/afw/geom/XYTransform.h
/home/jenkins-slave/snowflake/release/lsstsw/stack/Linux64/afw/15.0-16-g953e39cab/src/geom/RadialXYTransform.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ AffineTransform

◆ memCallback

◆ memId

◆ memNewCallback

◆ Point2D

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ RadialXYTransform() [1/3]

◆ RadialXYTransform() [2/3]

◆ RadialXYTransform() [3/3]

◆ ~RadialXYTransform()

Member Function Documentation

◆ census() [1/3]

◆ census() [2/3]

◆ census() [3/3]

◆ clone()

◆ forwardTransform()

◆ getCoeffs()

◆ getId()

◆ getNextMemId()

◆ hasBeenCorrupted()

◆ init()

◆ invert()

◆ linearizeForwardTransform()

◆ linearizeReverseTransform()

◆ makeAffineTransform()

◆ markPersistent()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ polyEval() [1/2]

◆ polyEval() [2/2]

◆ polyEvalDeriv()

◆ polyEvalInverse() [1/2]

◆ polyEvalInverse() [2/2]

◆ polyEvalInverseJacobian()

◆ polyEvalJacobian()

◆ polyInvert()

◆ repr()

◆ reverseTransform()

◆ setCorruptionCallback()

◆ setDeleteCallback()

◆ setDeleteCallbackId()

◆ setNewCallback()

◆ setNewCallbackId()

Member Data Documentation

◆ _coeffs

◆ _icoeffs