lsst::jointcal::GtransfoInverse Class Reference

Inheritance diagram for lsst::jointcal::GtransfoInverse:

Public Member Functions
	GtransfoInverse (const Gtransfo *direct, const double precision, const Frame &region)
void	apply (const double xIn, const double yIn, double &xOut, double &yOut) const
	implements an iterative (Gauss-Newton) solver. More...
void	dump (ostream &stream) 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...
virtual std::unique_ptr< Gtransfo >	clone () const
	returns a copy (allocated by new) of the transformation. More...
	GtransfoInverse (GtransfoInverse const &)
std::unique_ptr< Gtransfo >	roughInverse (const Frame &) const
	Overload the "generic routine". More...
std::unique_ptr< Gtransfo >	inverseTransfo (double, const Frame &) const
	Inverse transfo: returns the direct one! More...
	~GtransfoInverse ()
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...
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 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

Definition at line 259 of file Gtransfo.cc.

Constructor & Destructor Documentation

GtransfoInverse() [1/2]

lsst::jointcal::GtransfoInverse::GtransfoInverse	(	const Gtransfo *	direct,
		const double	precision,
		const Frame &	region
	)

Definition at line 296 of file Gtransfo.cc.

                                                                                                    {
    _direct = direct->clone();
    _roughInverse = _direct->roughInverse(region);
    precision2 = precision * precision;
}

GtransfoInverse() [2/2]

lsst::jointcal::GtransfoInverse::GtransfoInverse

(

GtransfoInverse const &

model

)

Definition at line 302 of file Gtransfo.cc.

                                                             : Gtransfo() {
    _direct = model._direct->clone();
    _roughInverse = model._roughInverse->clone();
    precision2 = model.precision2;
}

~GtransfoInverse()

lsst::jointcal::GtransfoInverse::~GtransfoInverse

(

)

Definition at line 308 of file Gtransfo.cc.

{}

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::GtransfoInverse::apply ( const double  xIn, const double  yIn, double &  xOut, double &  yOut  ) const

virtual

implements an iterative (Gauss-Newton) solver.

It resorts to the Derivative function: 4 calls to the direct transfo per iteration.

Implements lsst::jointcal::Gtransfo.

Definition at line 316 of file Gtransfo.cc.

                                                                                                {
    Point in(xIn, yIn);
    Point outGuess = _roughInverse->apply(in);
    GtransfoLin directDer, reverseDer;
    int loop = 0;
    int maxloop = 20;
    double move2;
    do {
        loop++;
        Point inGuess = _direct->apply(outGuess);
        _direct->computeDerivative(outGuess, directDer);
        reverseDer = directDer.inverted();
        double xShift, yShift;
        reverseDer.apply(xIn - inGuess.x, yIn - inGuess.y, xShift, yShift);
        outGuess.x += xShift;
        outGuess.y += yShift;
        move2 = xShift * xShift + yShift * yShift;
    } while ((move2 > precision2) && (loop < maxloop));
    if (loop == maxloop) LOGLS_WARN(_log, "Problems applying GtransfoInverse at " << in);
    xOut = outGuess.x;
    yOut = outGuess.y;
}

clone()

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

virtual

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

Implements lsst::jointcal::Gtransfo.

Definition at line 347 of file Gtransfo.cc.

                                                     {
    return std::unique_ptr<Gtransfo>(new GtransfoInverse(*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::GtransfoInverse::dump ( ostream &  stream ) const

virtual

dumps the transfo coefficients to stream.

Implements lsst::jointcal::Gtransfo.

Definition at line 339 of file Gtransfo.cc.

                                                {
    stream << " GtransfoInverse of  :" << endl << *_direct << endl;
}

fit()

double lsst::jointcal::GtransfoInverse::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 343 of file Gtransfo.cc.

                                                 {
    throw pexExcept::RuntimeError("Cannot fit a GtransfoInverse. Use StarMatchList::inverseTransfo instead.");
}

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::GtransfoInverse::inverseTransfo ( double  , const Frame &    ) const

inlinevirtual

Inverse transfo: returns the direct one!

Reimplemented from lsst::jointcal::Gtransfo.

Definition at line 284 of file Gtransfo.cc.

{ return _direct->clone(); }

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::GtransfoInverse::roughInverse ( const Frame &  ) const

inlinevirtual

Overload the "generic routine".

Reimplemented from lsst::jointcal::Gtransfo.

Definition at line 281 of file Gtransfo.cc.

{ return _direct->clone(); }

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

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