lsst::jointcal::Gtransfo Class Reference

a virtual (interface) class for geometric transformations. More...

#include <Gtransfo.h>

Inheritance diagram for lsst::jointcal::Gtransfo:

Public Member Functions
virtual void	apply (const double xIn, const double yIn, double &xOut, double &yOut) const =0
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...
virtual void	dump (std::ostream &stream=std::cout) const =0
	dumps the transfo coefficients to stream. More...
std::string	__str__ ()
virtual double	fit (StarMatchList const &starMatchList)=0
	fits a transfo to a std::list of Point pairs (p1,p2, the Point fields in StarMatch). More...
void	transformStar (FatPoint &in) const
	allows to write MyTransfo(MyStar) More...
virtual double	getJacobian (Point const &point) const
	returns the local jacobian. More...
virtual std::unique_ptr< Gtransfo >	clone () const =0
	returns a copy (allocated by new) of the transformation. 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 double	getJacobian (const double x, const double y) const
	returns the local jacobian. 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
virtual	~Gtransfo ()

Detailed Description

a virtual (interface) class for geometric transformations.

We implement here One Gtransfo interface class, and actual derived classes. Composition in the usual (mathematical) sense is provided using gtransfoCompose(), and some classes (e.g. GtransfoLin) handle a * operator. Generic inversion by iteration exists, but it is at least 10 times slower than the corresponding "direct transformation". If a transfo has an analytical inverse, then providing inverseTransfo is obviously a very good idea. Before resorting to inverseTransfo, consider using StarMatchList::inverseTransfo(). GtransfoLin::inverted() and TanPixelToRaDec::inverted() exist. The classes also provide derivation and linear approximation.

Definition at line 65 of file Gtransfo.h.

Constructor & Destructor Documentation

~Gtransfo()

virtual lsst::jointcal::Gtransfo::~Gtransfo ( )

inlinevirtual

Definition at line 197 of file Gtransfo.h.

{};

Member Function Documentation

__str__()

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

inline

Definition at line 94 of file Gtransfo.h.

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

apply() [1/4]

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

pure virtual

Implemented in lsst::jointcal::UserTransfo, lsst::jointcal::TanRaDecToPixel, lsst::jointcal::BaseTanWcs, lsst::jointcal::GtransfoSkyWcs, lsst::jointcal::GtransfoComposition, lsst::jointcal::GtransfoPoly, lsst::jointcal::GtransfoInverse, and lsst::jointcal::GtransfoIdentity.

apply() [2/4]

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

inline

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() [3/4]

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

inline

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() [4/4]

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

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;
}

clone()

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

pure virtual

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

Implemented in lsst::jointcal::UserTransfo, lsst::jointcal::TanRaDecToPixel, lsst::jointcal::TanSipPixelToRaDec, lsst::jointcal::TanPixelToRaDec, lsst::jointcal::GtransfoSkyWcs, lsst::jointcal::GtransfoLin, lsst::jointcal::GtransfoComposition, lsst::jointcal::GtransfoPoly, lsst::jointcal::GtransfoInverse, and lsst::jointcal::GtransfoIdentity.

composeAndReduce()

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

virtual

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

virtual

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()

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

pure virtual

dumps the transfo coefficients to stream.

Implemented in lsst::jointcal::UserTransfo, lsst::jointcal::TanRaDecToPixel, lsst::jointcal::TanSipPixelToRaDec, lsst::jointcal::TanPixelToRaDec, lsst::jointcal::GtransfoSkyWcs, lsst::jointcal::GtransfoComposition, lsst::jointcal::GtransfoPoly, lsst::jointcal::GtransfoInverse, and lsst::jointcal::GtransfoIdentity.

fit()

virtual double lsst::jointcal::Gtransfo::fit ( StarMatchList const &  starMatchList )

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

Implemented in lsst::jointcal::UserTransfo, lsst::jointcal::TanRaDecToPixel, lsst::jointcal::TanSipPixelToRaDec, lsst::jointcal::TanPixelToRaDec, lsst::jointcal::GtransfoSkyWcs, lsst::jointcal::GtransfoLinRot, lsst::jointcal::GtransfoLinShift, lsst::jointcal::GtransfoComposition, lsst::jointcal::GtransfoPoly, lsst::jointcal::GtransfoInverse, and lsst::jointcal::GtransfoIdentity.

getJacobian() [1/2]

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

inlinevirtual

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

virtual

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

inlinevirtual

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

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

virtual

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

virtual

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

)

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

virtual

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

virtual

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 )

virtual

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

virtual

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

inlinevirtual

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

virtual

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

virtual

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

inline

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

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

virtual

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