PolynomialTransform.h

Go to the documentation of this file.

// -*- LSST-C++ -*-

/*
 * LSST Data Management System
 * Copyright 2016 LSST/AURA
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef LSST_MEAS_ASTROM_PolynomialTransform_INCLUDED
#define LSST_MEAS_ASTROM_PolynomialTransform_INCLUDED

#include "ndarray/eigen.h"
#include "lsst/geom/Point.h"
#include "lsst/geom/AffineTransform.h"

namespace lsst {
namespace meas {
namespace astrom {

class SipForwardTransform;
class SipReverseTransform;
class ScaledPolynomialTransform;

class PolynomialTransform {
public:
    static PolynomialTransform convert(ScaledPolynomialTransform const& other);

    static PolynomialTransform convert(SipForwardTransform const& other);

    static PolynomialTransform convert(SipReverseTransform const& other);

    PolynomialTransform(ndarray::Array<double const, 2, 0> const& xCoeffs,
                        ndarray::Array<double const, 2, 0> const& yCoeffs);

    PolynomialTransform(PolynomialTransform const& other);

    PolynomialTransform(PolynomialTransform&& other);

    PolynomialTransform& operator=(PolynomialTransform const& other);

    PolynomialTransform& operator=(PolynomialTransform&& other);

    void swap(PolynomialTransform& other);

    int getOrder() const { return _xCoeffs.getSize<0>() - 1; }

    ndarray::Array<double const, 2, 2> getXCoeffs() const { return _xCoeffs.shallow(); }

    ndarray::Array<double const, 2, 2> getYCoeffs() const { return _yCoeffs.shallow(); }

    geom::AffineTransform linearize(geom::Point2D const& in) const;

    geom::Point2D operator()(geom::Point2D const& in) const;

private:
    PolynomialTransform(int order);

    friend PolynomialTransform compose(geom::AffineTransform const& t1, PolynomialTransform const& t2);
    friend PolynomialTransform compose(PolynomialTransform const& t1, geom::AffineTransform const& t2);
    friend class ScaledPolynomialTransformFitter;
    friend class SipForwardTransform;
    friend class SipReverseTransform;
    friend class ScaledPolynomialTransform;

    ndarray::Array<double, 2, 2> _xCoeffs;
    ndarray::Array<double, 2, 2> _yCoeffs;
    mutable Eigen::VectorXd _u;  // workspace for operator() and linearize
    mutable Eigen::VectorXd _v;
};

class ScaledPolynomialTransform {
public:
    static ScaledPolynomialTransform convert(PolynomialTransform const& poly);

    static ScaledPolynomialTransform convert(SipForwardTransform const& sipForward);

    static ScaledPolynomialTransform convert(SipReverseTransform const& sipReverse);

    ScaledPolynomialTransform(PolynomialTransform const& poly, geom::AffineTransform const& inputScaling,
                              geom::AffineTransform const& outputScalingInverse);

    ScaledPolynomialTransform(ScaledPolynomialTransform const& other) = default;

    ScaledPolynomialTransform(ScaledPolynomialTransform&& other) = default;

    ScaledPolynomialTransform& operator=(ScaledPolynomialTransform const& other) = default;

    ScaledPolynomialTransform& operator=(ScaledPolynomialTransform&& other) = default;

    void swap(ScaledPolynomialTransform& other);

    PolynomialTransform const& getPoly() const { return _poly; }

    geom::AffineTransform const& getInputScaling() const { return _inputScaling; }

    geom::AffineTransform const& getOutputScalingInverse() const { return _outputScalingInverse; }

    geom::AffineTransform linearize(geom::Point2D const& in) const;

    geom::Point2D operator()(geom::Point2D const& in) const;

private:
    friend class ScaledPolynomialTransformFitter;
    PolynomialTransform _poly;
    geom::AffineTransform _inputScaling;
    geom::AffineTransform _outputScalingInverse;
};

PolynomialTransform compose(geom::AffineTransform const& t1, PolynomialTransform const& t2);

PolynomialTransform compose(PolynomialTransform const& t1, geom::AffineTransform const& t2);

}  // namespace astrom
}  // namespace meas
}  // namespace lsst

#endif  // !LSST_MEAS_ASTROM_PolynomialTransform_INCLUDED