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/afw/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,2> const & xCoeffs,
        ndarray::Array<double const,2,2> 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.rows() - 1; }

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

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

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

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

private:

    PolynomialTransform(int order);

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

    ndarray::EigenView<double,2,2> _xCoeffs;
    ndarray::EigenView<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,
        afw::geom::AffineTransform const & inputScaling,
        afw::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; }

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

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

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

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

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

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

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

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

#endif // !LSST_MEAS_ASTROM_PolynomialTransform_INCLUDED