lsst::jointcal::UserTransfo Class Reference

a run-time transfo that allows users to define a Gtransfo with minimal coding (just the transfo routine). More...

#include <Gtransfo.h>

Inheritance diagram for lsst::jointcal::UserTransfo:

Public Member Functions
	UserTransfo (GtransfoFun &fun, const void *userData)
	the transfo routine and extra data that it may need. More...
void	apply (const double xIn, const double yIn, double &xOut, double &yOut) const
void	dump (std::ostream &stream=std::cout) const
	dumps the transfo coefficients to stream. More...
double	fit (StarMatchList const &starMatchList)
	fits a transfo to a std::list of Point pairs (p1,p2, the Point fields in StarMatch). More...
std::unique_ptr< Gtransfo >	clone () const
	returns a copy (allocated by new) of the transformation. More...
void	apply (Point const &in, Point &out) const
	applies the tranfo to in and writes into out. Is indeed virtual. More...
Point	apply (Point const &in) const
	All these apply(..) shadow the virtual one in derived classes, unless one writes "using Gtransfo::apply". More...
Frame	apply (Frame const &inputframe, bool inscribed) const
	Transform a bounding box, taking either the inscribed or circumscribed box. More...
std::string	__str__ ()
void	transformStar (FatPoint &in) const
	allows to write MyTransfo(MyStar) More...
virtual double	getJacobian (Point const &point) const
	returns the local jacobian. More...
virtual double	getJacobian (const double x, const double y) const
	returns the local jacobian. More...
virtual std::unique_ptr< Gtransfo >	composeAndReduce (Gtransfo const &right) const
	Return a reduced composition of newTransfo = this(right()), or nullptr if it cannot be reduced. More...
virtual void	computeDerivative (Point const &where, GtransfoLin &derivative, const double step=0.01) const
	Computes the local Derivative of a transfo, w.r.t. More...
virtual GtransfoLin	linearApproximation (Point const &where, const double step=0.01) const
	linear (local) approximation. More...
virtual void	transformPosAndErrors (const FatPoint &in, FatPoint &out) const
virtual void	transformErrors (Point const &where, const double *vIn, double *vOut) const
	transform errors (represented as double[3] in order V(xx),V(yy),Cov(xy)) More...
virtual std::unique_ptr< Gtransfo >	inverseTransfo (const double precision, const Frame &region) const
	returns an inverse transfo. Numerical if not overloaded. More...
void	getParams (double *params) const
	params should be at least Npar() long More...
void	offsetParams (Eigen::VectorXd const &delta)
virtual double	paramRef (const int i) const
virtual double &	paramRef (const int i)
virtual void	paramDerivatives (Point const &where, double *dx, double *dy) const
	Derivative w.r.t parameters. More...
virtual std::unique_ptr< Gtransfo >	roughInverse (const Frame &region) const
	Rough inverse. More...
virtual int	getNpar () const
	returns the number of parameters (to compute chi2's) More...
virtual std::shared_ptr< ast::Mapping >	toAstMap (jointcal::Frame const &domain) const
	Create an equivalent AST mapping for this transformation, including an analytic inverse if possible. More...
void	write (const std::string &fileName) const
virtual void	write (std::ostream &stream) const

Detailed Description

a run-time transfo that allows users to define a Gtransfo with minimal coding (just the transfo routine).

Definition at line 729 of file Gtransfo.h.

Constructor & Destructor Documentation

UserTransfo()

lsst::jointcal::UserTransfo::UserTransfo	(	GtransfoFun &	fun,
		const void *	userData
	)

the transfo routine and extra data that it may need.

Definition at line 1699 of file Gtransfo.cc.

        : _userFun(userFun), _userData(userData) {}

Member Function Documentation

__str__()

std::string lsst::jointcal::Gtransfo::__str__ ( )

inlineinherited

Definition at line 94 of file Gtransfo.h.

                        {
        std::stringstream s;
        dump(s);
        return s.str();
    }

apply() [1/4]

void lsst::jointcal::Gtransfo::apply ( Point const &  in, Point &  out  ) const

inlineinherited

applies the tranfo to in and writes into out. Is indeed virtual.

Definition at line 71 of file Gtransfo.h.

{ apply(in.x, in.y, out.x, out.y); }

apply() [2/4]

Point lsst::jointcal::Gtransfo::apply ( Point const &  in ) const

inlineinherited

All these apply(..) shadow the virtual one in derived classes, unless one writes "using Gtransfo::apply".

Definition at line 75 of file Gtransfo.h.

                                       {
        double xout, yout;
        apply(in.x, in.y, xout, yout);
        return Point(xout, yout);
    }

apply() [3/4]

Frame lsst::jointcal::Gtransfo::apply ( Frame const &  inputframe, bool  inscribed  ) const

inherited

Transform a bounding box, taking either the inscribed or circumscribed box.

Parameters

[in]	inputframe	The frame to be transformed.
[in]	inscribed	Return the inscribed (true) or circumscribed (false) box.

Returns

The transformed frame.

Definition at line 74 of file Gtransfo.cc.

                                                                   {
    // 2 opposite corners
    double xtmin1, xtmax1, ytmin1, ytmax1;
    apply(inputframe.xMin, inputframe.yMin, xtmin1, ytmin1);
    apply(inputframe.xMax, inputframe.yMax, xtmax1, ytmax1);
    Frame fr1(std::min(xtmin1, xtmax1), std::min(ytmin1, ytmax1), std::max(xtmin1, xtmax1),
              std::max(ytmin1, ytmax1));
    // 2 other corners
    double xtmin2, xtmax2, ytmin2, ytmax2;
    apply(inputframe.xMin, inputframe.yMax, xtmin2, ytmax2);
    apply(inputframe.xMax, inputframe.yMin, xtmax2, ytmin2);
    Frame fr2(std::min(xtmin2, xtmax2), std::min(ytmin2, ytmax2), std::max(xtmin2, xtmax2),
              std::max(ytmin2, ytmax2));

    if (inscribed) return fr1 * fr2;
    return fr1 + fr2;
}

apply() [4/4]

void lsst::jointcal::UserTransfo::apply ( const double  xIn, const double  yIn, double &  xOut, double &  yOut  ) const

virtual

Implements lsst::jointcal::Gtransfo.

Definition at line 1702 of file Gtransfo.cc.

                                                                                            {
    _userFun(xIn, yIn, xOut, yOut, _userData);
}

clone()

std::unique_ptr< Gtransfo > lsst::jointcal::UserTransfo::clone ( ) const

virtual

returns a copy (allocated by new) of the transformation.

Implements lsst::jointcal::Gtransfo.

Definition at line 1716 of file Gtransfo.cc.

                                                 {
    return std::unique_ptr<Gtransfo>(new UserTransfo(*this));
}

composeAndReduce()

std::unique_ptr< Gtransfo > lsst::jointcal::Gtransfo::composeAndReduce ( Gtransfo const &  right ) const

virtualinherited

Return a reduced composition of newTransfo = this(right()), or nullptr if it cannot be reduced.

"Reduced" in this context means that they are capable of being merged into a single transform, for example, for two polynomials:

\[ f(x) = 1 + x^2, g(x) = -1 + 3x \]

we would have h = f.composeAndReduce(g) == 2 - 6x + 9x^2.

To be overloaded by derived classes if they can properly reduce the composition.

Parameters

right

The transform to apply first.

Returns

The new reduced and composed gtransfo, or nullptr if no such reduction is possible.

Reimplemented in lsst::jointcal::GtransfoIdentity.

Definition at line 92 of file Gtransfo.cc.

                                {  // by default no way to compose
    return std::unique_ptr<Gtransfo>(nullptr);
}

computeDerivative()

void lsst::jointcal::Gtransfo::computeDerivative ( Point const &  where, GtransfoLin &  derivative, const double  step = 0.01  ) const

virtualinherited

Computes the local Derivative of a transfo, w.r.t.

the Derivative is represented by a GtransfoLin, in which (hopefully), the offset terms are zero.

position.

Step is used for numerical derivation.

Derivative should transform a vector of offsets into a vector of offsets.

Reimplemented in lsst::jointcal::GtransfoLin, lsst::jointcal::GtransfoPoly, and lsst::jointcal::GtransfoIdentity.

Definition at line 116 of file Gtransfo.cc.

                                                                                                     {
    double x = where.x;
    double y = where.y;
    double xp0, yp0;
    apply(x, y, xp0, yp0);

    double xp, yp;
    apply(x + step, y, xp, yp);
    derivative.a11() = (xp - xp0) / step;
    derivative.a21() = (yp - yp0) / step;
    apply(x, y + step, xp, yp);
    derivative.a12() = (xp - xp0) / step;
    derivative.a22() = (yp - yp0) / step;
    derivative.dx() = 0;
    derivative.dy() = 0;
}

dump()

void lsst::jointcal::UserTransfo::dump ( std::ostream &  stream = std::cout ) const

virtual

dumps the transfo coefficients to stream.

Implements lsst::jointcal::Gtransfo.

Definition at line 1706 of file Gtransfo.cc.

                                            {
    stream << "UserTransfo with user function @ " << _userFun << "and userData@ " << _userData << endl;
}

fit()

double lsst::jointcal::UserTransfo::fit ( StarMatchList const &  starMatchList )

virtual

fits a transfo to a std::list of Point pairs (p1,p2, the Point fields in StarMatch).

After the fit this(p1) yields approximately p2. The returned value is the sum of squared residuals. If you want to fit a partial transfo (e.g. such that this(T1(p1)) = T2(p2), use StarMatchList::applyTransfo beforehand.

Implements lsst::jointcal::Gtransfo.

Definition at line 1710 of file Gtransfo.cc.

                                             {
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                      "UserTransfo::fit is NOT implemented (and will never be)) ");
    return -1;
}

getJacobian() [1/2]

virtual double lsst::jointcal::Gtransfo::getJacobian ( Point const &  point ) const

inlinevirtualinherited

returns the local jacobian.

Definition at line 111 of file Gtransfo.h.

{ return getJacobian(point.x, point.y); }

getJacobian() [2/2]

double lsst::jointcal::Gtransfo::getJacobian ( const double  x, const double  y  ) const

virtualinherited

returns the local jacobian.

Definition at line 97 of file Gtransfo.cc.

                                                                 {
    double x2, y2;
    double eps = x * 0.01;
    if (eps == 0) eps = 0.01;
    apply(x, y, x2, y2);
    double dxdx, dydx;
    apply(x + eps, y, dxdx, dydx);
    dxdx -= x2;
    dydx -= y2;
    double dxdy, dydy;
    apply(x, y + eps, dxdy, dydy);
    dxdy -= x2;
    dydy -= y2;
    return ((dxdx * dydy - dxdy * dydx) / (eps * eps));
}

getNpar()

virtual int lsst::jointcal::Gtransfo::getNpar ( ) const

inlinevirtualinherited

returns the number of parameters (to compute chi2's)

Reimplemented in lsst::jointcal::GtransfoLinScale, lsst::jointcal::GtransfoLinRot, lsst::jointcal::GtransfoLinShift, lsst::jointcal::GtransfoPoly, and lsst::jointcal::GtransfoIdentity.

Definition at line 180 of file Gtransfo.h.

{ return 0; }

getParams()

void lsst::jointcal::Gtransfo::getParams ( double *  params ) const

inherited

params should be at least Npar() long

Definition at line 210 of file Gtransfo.cc.

                                             {
    int npar = getNpar();
    for (int i = 0; i < npar; ++i) params[i] = paramRef(i);
}

inverseTransfo()

std::unique_ptr< Gtransfo > lsst::jointcal::Gtransfo::inverseTransfo ( const double  precision, const Frame &  region  ) const

virtualinherited

returns an inverse transfo. Numerical if not overloaded.

precision and region refer to the "input" side of this, and hence to the output side of the returned Gtransfo.

Reimplemented in lsst::jointcal::TanRaDecToPixel, lsst::jointcal::TanSipPixelToRaDec, lsst::jointcal::TanPixelToRaDec, lsst::jointcal::GtransfoLin, and lsst::jointcal::GtransfoInverse.

Definition at line 292 of file Gtransfo.cc.

                                                                                                  {
    return std::unique_ptr<Gtransfo>(new GtransfoInverse(this, precision, region));
}

linearApproximation()

GtransfoLin lsst::jointcal::Gtransfo::linearApproximation ( Point const &  where, const double  step = 0.01  ) const

virtualinherited

linear (local) approximation.

Reimplemented in lsst::jointcal::GtransfoLin, and lsst::jointcal::GtransfoIdentity.

Definition at line 133 of file Gtransfo.cc.

                                                                                     {
    Point outwhere = apply(where);
    GtransfoLin der;
    computeDerivative(where, der, step);
    return GtransfoLinShift(outwhere.x, outwhere.y) * der * GtransfoLinShift(-where.x, -where.y);
}

offsetParams()

void lsst::jointcal::Gtransfo::offsetParams ( Eigen::VectorXd const &  delta )

inherited

Definition at line 215 of file Gtransfo.cc.

                                                      {
    int npar = getNpar();
    for (int i = 0; i < npar; ++i) paramRef(i) += delta[i];
}

paramDerivatives()

void lsst::jointcal::Gtransfo::paramDerivatives ( Point const &  where, double *  dx, double *  dy  ) const

virtualinherited

Derivative w.r.t parameters.

Derivatives should be al least 2*NPar long. first Npar, for x, last Npar for y.

Reimplemented in lsst::jointcal::GtransfoPoly.

Definition at line 229 of file Gtransfo.cc.

                                                                       {
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                      "Gtransfo::paramDerivatives() should never be called ");
}

paramRef() [1/2]

double lsst::jointcal::Gtransfo::paramRef ( const int  i ) const

virtualinherited

Reimplemented in lsst::jointcal::GtransfoPoly.

Definition at line 220 of file Gtransfo.cc.

                                         {
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                      std::string("Gtransfo::paramRef should never be called "));
}

paramRef() [2/2]

double & lsst::jointcal::Gtransfo::paramRef ( const int  i )

virtualinherited

Reimplemented in lsst::jointcal::GtransfoPoly.

Definition at line 225 of file Gtransfo.cc.

                                    {
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Gtransfo::paramRef should never be called ");
}

roughInverse()

std::unique_ptr< Gtransfo > lsst::jointcal::Gtransfo::roughInverse ( const Frame &  region ) const

virtualinherited

Rough inverse.

Stored by the numerical inverter to guess starting point for the trials. Just here to enable overloading.

Reimplemented in lsst::jointcal::TanRaDecToPixel, lsst::jointcal::TanPixelToRaDec, and lsst::jointcal::GtransfoInverse.

Definition at line 190 of file Gtransfo.cc.

                                                                        {
    // "in" and "out" refer to the inverse direction.
    Point centerOut = region.getCenter();
    Point centerIn = apply(centerOut);
    GtransfoLin der;
    computeDerivative(centerOut, der, std::sqrt(region.getArea()) / 5.);
    der = der.inverted();
    der = GtransfoLinShift(centerOut.x, centerOut.y) * der * GtransfoLinShift(-centerIn.x, -centerIn.y);
    return std::unique_ptr<Gtransfo>(new GtransfoLin(der));
}

toAstMap()

virtual std::shared_ptr<ast::Mapping> lsst::jointcal::Gtransfo::toAstMap ( jointcal::Frame const &  domain ) const

inlinevirtualinherited

Create an equivalent AST mapping for this transformation, including an analytic inverse if possible.

Parameters

domain

The domain of the transfo, to help find an inverse.

Returns

An AST Mapping that represents this transformation.

Reimplemented in lsst::jointcal::GtransfoPoly, and lsst::jointcal::GtransfoIdentity.

Definition at line 189 of file Gtransfo.h.

                                                                                  {
        throw std::logic_error("toAstMap is not implemented for this class.");
    }

transformErrors()

void lsst::jointcal::Gtransfo::transformErrors ( Point const &  where, const double *  vIn, double *  vOut  ) const

virtualinherited

transform errors (represented as double[3] in order V(xx),V(yy),Cov(xy))

Definition at line 157 of file Gtransfo.cc.

                                                                                        {
    GtransfoLin der;
    computeDerivative(where, der, 0.01);
    double a11 = der.A11();
    double a22 = der.A22();
    double a21 = der.A21();
    double a12 = der.A12();

    /*      (a11 a12)          (vxx  vxy)
       M =  (       )  and V = (        )
            (a21 a22)          (xvy  vyy)

       Vxx = Vin[0], vyy = Vin[1], Vxy = Vin[2];
       we want to compute M*V*tp(M)
       A lin alg light package would be perfect...
    */
    int xx = 0;
    int yy = 1;
    int xy = 2;
    // M*V :

    double b11 = a11 * vIn[xx] + a12 * vIn[xy];
    double b22 = a21 * vIn[xy] + a22 * vIn[yy];
    double b12 = a11 * vIn[xy] + a12 * vIn[yy];
    double b21 = a21 * vIn[xx] + a22 * vIn[xy];

    // (M*V) * tp(M)

    vOut[xx] = b11 * a11 + b12 * a12;
    vOut[xy] = b11 * a21 + b12 * a22;
    vOut[yy] = b21 * a21 + b22 * a22;
}

transformPosAndErrors()

void lsst::jointcal::Gtransfo::transformPosAndErrors ( const FatPoint &  in, FatPoint &  out  ) const

virtualinherited

Reimplemented in lsst::jointcal::TanRaDecToPixel, and lsst::jointcal::GtransfoPoly.

Definition at line 140 of file Gtransfo.cc.

                                                                            {
    FatPoint res;  // in case in and out are the same address...
    res = apply(in);
    GtransfoLin der;
    // could save a call here, since Derivative needs the transform of where that we already have
    // 0.01 may not be a very good idea in all cases. May be we should provide a way of altering that.
    computeDerivative(in, der, 0.01);
    double a11 = der.A11();
    double a22 = der.A22();
    double a21 = der.A21();
    double a12 = der.A12();
    res.vx = a11 * (a11 * in.vx + 2 * a12 * in.vxy) + a12 * a12 * in.vy;
    res.vy = a21 * a21 * in.vx + a22 * a22 * in.vy + 2. * a21 * a22 * in.vxy;
    res.vxy = a21 * a11 * in.vx + a22 * a12 * in.vy + (a21 * a12 + a11 * a22) * in.vxy;
    out = res;
}

transformStar()

void lsst::jointcal::Gtransfo::transformStar ( FatPoint &  in ) const

inlineinherited

allows to write MyTransfo(MyStar)

Definition at line 108 of file Gtransfo.h.

{ transformPosAndErrors(in, in); }

write() [1/2]

void lsst::jointcal::Gtransfo::write ( const std::string &  fileName ) const

inherited

Definition at line 239 of file Gtransfo.cc.

                                                    {
    ofstream s(fileName.c_str());
    write(s);
    bool ok = !s.fail();
    s.close();
    if (!ok)
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          "Gtransfo::write, something went wrong for file " + fileName);
}

write() [2/2]

void lsst::jointcal::Gtransfo::write ( std::ostream &  stream ) const

virtualinherited

Reimplemented in lsst::jointcal::GtransfoPoly, and lsst::jointcal::GtransfoIdentity.

Definition at line 249 of file Gtransfo.cc.

                                          {
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                      "Gtransfo::write(ostream), should never be called. MEans that it is missing in some "
                      "derived class ");
}

---

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

• /j/snowflake/release/lsstsw/stack/Linux64/jointcal/16.0-25-g07af9f2+1/include/lsst/jointcal/Gtransfo.h
• /j/snowflake/release/lsstsw/stack/Linux64/jointcal/16.0-25-g07af9f2+1/src/Gtransfo.cc