lsst::jointcal::AstrometryTransformIdentity Class Reference

A do-nothing transformation. It anyway has dummy routines to mimick a AstrometryTransform. More...

#include <AstrometryTransform.h>

Inheritance diagram for lsst::jointcal::AstrometryTransformIdentity:

Public Member Functions
	AstrometryTransformIdentity ()
	constructor. More...
void	apply (const double xIn, const double yIn, double &xOut, double &yOut) const override
	xOut = xIn; yOut = yIn ! More...
double	fit (StarMatchList const &starMatchList) override
	fits a transform to a std::list of Point pairs (p1,p2, the Point fields in StarMatch). More...
std::unique_ptr< AstrometryTransform >	composeAndReduce (AstrometryTransform const &right) const override
	Return a reduced composition of newTransform = this(right()), or nullptr if it cannot be reduced. More...
void	print (std::ostream &out) const override
	prints the transform coefficients to stream. More...
std::size_t	getNpar () const override
	returns the number of parameters (to compute chi2's) More...
std::unique_ptr< AstrometryTransform >	clone () const override
	returns a copy (allocated by new) of the transformation. More...
void	computeDerivative (Point const &where, AstrometryTransformLinear &derivative, const double step=0.01) const override
	Computes the local Derivative of a transform, w.r.t. More...
virtual AstrometryTransformLinear	linearApproximation (Point const &where, const double step=0.01) const override
	linear approximation. More...
std::shared_ptr< ast::Mapping >	toAstMap (jointcal::Frame const &domain) const override
	Create an equivalent AST mapping for this transformation, including an analytic inverse if possible. More...
void	write (std::ostream &s) const override
void	read (std::istream &s)
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 AstrometryTransform::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
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 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< AstrometryTransform >	inverseTransform (const double precision, const Frame &region) const
	returns an inverse transform. 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 (Eigen::Index const i) const
virtual double &	paramRef (Eigen::Index const i)
virtual void	paramDerivatives (Point const &where, double *dx, double *dy) const
	Derivative w.r.t parameters. More...
virtual std::unique_ptr< AstrometryTransform >	roughInverse (const Frame &region) const
	Rough inverse. More...
void	write (const std::string &fileName) const

Detailed Description

A do-nothing transformation. It anyway has dummy routines to mimick a AstrometryTransform.

Definition at line 219 of file AstrometryTransform.h.

Constructor & Destructor Documentation

AstrometryTransformIdentity()

lsst::jointcal::AstrometryTransformIdentity::AstrometryTransformIdentity ( )

inline

constructor.

Definition at line 222 of file AstrometryTransform.h.

{}

Member Function Documentation

__str__()

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

inlineinherited

Definition at line 94 of file AstrometryTransform.h.

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

apply() [1/4]

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

inlineoverridevirtual

xOut = xIn; yOut = yIn !

Implements lsst::jointcal::AstrometryTransform.

Definition at line 225 of file AstrometryTransform.h.

                                                                                              {
        xOut = xIn;
        yOut = yIn;
    }  // to speed up

apply() [2/4]

Frame lsst::jointcal::AstrometryTransform::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 76 of file AstrometryTransform.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() [3/4]

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

inlineinherited

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

Definition at line 75 of file AstrometryTransform.h.

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

apply() [4/4]

void lsst::jointcal::AstrometryTransform::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 AstrometryTransform.h.

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

clone()

std::unique_ptr<AstrometryTransform> lsst::jointcal::AstrometryTransformIdentity::clone ( ) const

inlineoverridevirtual

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

Implements lsst::jointcal::AstrometryTransform.

Definition at line 244 of file AstrometryTransform.h.

                                                              {
        return std::unique_ptr<AstrometryTransform>(new AstrometryTransformIdentity);
    }

composeAndReduce()

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

inlineoverridevirtual

Return a reduced composition of newTransform = 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 AstrometryTransform, or nullptr if no such reduction is possible.

Reimplemented from lsst::jointcal::AstrometryTransform.

Definition at line 236 of file AstrometryTransform.h.

                                                                                                         {
        return right.clone();
    }

computeDerivative()

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

overridevirtual

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

the Derivative is represented by a AstrometryTransformLinear, 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 from lsst::jointcal::AstrometryTransform.

Definition at line 439 of file AstrometryTransform.cc.

                                                                        {
    derivative = AstrometryTransformLinear();
}

fit()

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

inlineoverridevirtual

fits a transform 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 transform (e.g. such that this(T1(p1)) = T2(p2), use StarMatchList::applyTransform beforehand.

Implements lsst::jointcal::AstrometryTransform.

Definition at line 230 of file AstrometryTransform.h.

                                                            {
        throw pexExcept::TypeError(
                "AstrometryTransformIdentity is the identity transformation: it cannot be fit to anything.");
    }

getJacobian() [1/2]

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

virtualinherited

returns the local jacobian.

Definition at line 99 of file AstrometryTransform.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));
}

getJacobian() [2/2]

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

inlinevirtualinherited

returns the local jacobian.

Definition at line 110 of file AstrometryTransform.h.

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

getNpar()

std::size_t lsst::jointcal::AstrometryTransformIdentity::getNpar ( ) const

inlineoverridevirtual

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

Reimplemented from lsst::jointcal::AstrometryTransform.

Definition at line 242 of file AstrometryTransform.h.

{ return 0; }

getParams()

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

inherited

params should be at least Npar() long

Definition at line 216 of file AstrometryTransform.cc.

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

inverseTransform()

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

virtualinherited

returns an inverse transform. Numerical if not overloaded.

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

Reimplemented in lsst::jointcal::AstrometryTransformInverse, lsst::jointcal::AstrometryTransformLinear, lsst::jointcal::TanRaDecToPixel, lsst::jointcal::TanSipPixelToRaDec, and lsst::jointcal::TanPixelToRaDec.

Definition at line 303 of file AstrometryTransform.cc.

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

linearApproximation()

AstrometryTransformLinear lsst::jointcal::AstrometryTransformIdentity::linearApproximation ( Point const &  where, const double  step = 0.01  ) const

overridevirtual

linear approximation.

Reimplemented from lsst::jointcal::AstrometryTransform.

Definition at line 444 of file AstrometryTransform.cc.

                                                                                               {
    AstrometryTransformLinear result;
    return result;  // rely on default AstrometryTransformlin constructor;
}

offsetParams()

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

inherited

Definition at line 221 of file AstrometryTransform.cc.

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

paramDerivatives()

void lsst::jointcal::AstrometryTransform::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::AstrometryTransformPolynomial.

Definition at line 236 of file AstrometryTransform.cc.

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

paramRef() [1/2]

double & lsst::jointcal::AstrometryTransform::paramRef ( Eigen::Index const  i )

virtualinherited

Reimplemented in lsst::jointcal::AstrometryTransformPolynomial.

Definition at line 231 of file AstrometryTransform.cc.

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

paramRef() [2/2]

double lsst::jointcal::AstrometryTransform::paramRef ( Eigen::Index const  i ) const

virtualinherited

Reimplemented in lsst::jointcal::AstrometryTransformPolynomial.

Definition at line 226 of file AstrometryTransform.cc.

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

print()

void lsst::jointcal::AstrometryTransformIdentity::print ( std::ostream &  out ) const

inlineoverridevirtual

prints the transform coefficients to stream.

Implements lsst::jointcal::AstrometryTransform.

Definition at line 240 of file AstrometryTransform.h.

{ out << "x' = x\ny' = y" << std::endl; }

read()

void lsst::jointcal::AstrometryTransformIdentity::read

(

std::istream &

s

)

Definition at line 458 of file AstrometryTransform.cc.

                                                      {
    int format;
    stream >> format;
    if (format != 1)
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          " AstrometryTransformIdentity::read : format is not 1 ");
}

roughInverse()

std::unique_ptr< AstrometryTransform > lsst::jointcal::AstrometryTransform::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::AstrometryTransformInverse.

Definition at line 195 of file AstrometryTransform.cc.

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

toAstMap()

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

overridevirtual

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

Parameters

domain

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

Returns

An AST Mapping that represents this transformation.

Reimplemented from lsst::jointcal::AstrometryTransform.

Definition at line 450 of file AstrometryTransform.cc.

                                                                                           {
    return std::make_shared<ast::UnitMap>(2);  // a AstrometryTransformIdentity is identically ast::UnitMap(2)
}

transformErrors()

void lsst::jointcal::AstrometryTransform::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 162 of file AstrometryTransform.cc.

                                                                                                   {
    AstrometryTransformLinear 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::AstrometryTransform::transformPosAndErrors ( const FatPoint &  in, FatPoint &  out  ) const

virtualinherited

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

Definition at line 145 of file AstrometryTransform.cc.

                                                                                       {
    FatPoint res;  // in case in and out are the same address...
    res = apply(in);
    AstrometryTransformLinear 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::AstrometryTransform::transformStar ( FatPoint &  in ) const

inlineinherited

Definition at line 107 of file AstrometryTransform.h.

{ transformPosAndErrors(in, in); }

write() [1/2]

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

inherited

Definition at line 246 of file AstrometryTransform.cc.

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

write() [2/2]

void lsst::jointcal::AstrometryTransformIdentity::write ( std::ostream &  s ) const

overridevirtual

Reimplemented from lsst::jointcal::AstrometryTransform.

Definition at line 454 of file AstrometryTransform.cc.

                                                             {
    stream << "AstrometryTransformIdentity 1" << endl;
}

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/jointcal/22.0.1-25-g5bf6245+3ad8ecd50b/include/lsst/jointcal/AstrometryTransform.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/jointcal/22.0.1-25-g5bf6245+3ad8ecd50b/src/AstrometryTransform.cc