XYTransform.h

Go to the documentation of this file.

// -*- lsst-c++ -*-

/*
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 *
 * 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/>.
 */

/*
 * Class representing an invertible 2D transform
 */

#ifndef LSST_AFW_GEOM_XYTRANSFORM_H
#define LSST_AFW_GEOM_XYTRANSFORM_H

#include <string>
#include <memory>
#include "lsst/pex/exceptions.h"
#include "lsst/daf/base.h"
#include "lsst/afw/geom/AffineTransform.h"
#include "lsst/afw/geom/ellipses.h"

namespace lsst {
namespace afw {
namespace geom {

class XYTransform : public daf::base::Citizen {
public:
    typedef afw::geom::Point2D Point2D;
    typedef afw::geom::AffineTransform AffineTransform;

    explicit XYTransform();
    XYTransform(XYTransform const &);
    XYTransform(XYTransform &&);
    XYTransform &operator=(XYTransform const &);
    XYTransform &operator=(XYTransform &&);
    virtual ~XYTransform() = default;

    virtual std::shared_ptr<XYTransform> clone() const = 0;

    virtual std::shared_ptr<XYTransform> invert() const;

    virtual Point2D forwardTransform(Point2D const &point) const = 0;
    virtual Point2D reverseTransform(Point2D const &point) const = 0;

    virtual AffineTransform linearizeForwardTransform(Point2D const &point) const;
    virtual AffineTransform linearizeReverseTransform(Point2D const &point) const;
};

class IdentityXYTransform : public XYTransform {
public:
    IdentityXYTransform();
    IdentityXYTransform(IdentityXYTransform const &);
    IdentityXYTransform(IdentityXYTransform &&);
    IdentityXYTransform &operator=(IdentityXYTransform const &);
    IdentityXYTransform &operator=(IdentityXYTransform &&);
    ~IdentityXYTransform();

    virtual std::shared_ptr<XYTransform> clone() const;
    virtual Point2D forwardTransform(Point2D const &point) const;
    virtual Point2D reverseTransform(Point2D const &point) const;
    virtual AffineTransform linearizeForwardTransform(Point2D const &point) const;
    virtual AffineTransform linearizeReverseTransform(Point2D const &point) const;
};

class InvertedXYTransform : public XYTransform {
public:
    InvertedXYTransform(std::shared_ptr<XYTransform const> base);
    InvertedXYTransform(InvertedXYTransform const &);
    InvertedXYTransform(InvertedXYTransform &&);
    InvertedXYTransform &operator=(InvertedXYTransform const &);
    InvertedXYTransform &operator=(InvertedXYTransform &&);
    ~InvertedXYTransform();

    virtual std::shared_ptr<XYTransform> clone() const;
    virtual std::shared_ptr<XYTransform> invert() const;
    virtual Point2D forwardTransform(Point2D const &point) const;
    virtual Point2D reverseTransform(Point2D const &point) const;
    virtual AffineTransform linearizeForwardTransform(Point2D const &point) const;
    virtual AffineTransform linearizeReverseTransform(Point2D const &point) const;

protected:
    std::shared_ptr<XYTransform const> _base;
};

class MultiXYTransform : public XYTransform {
public:
    typedef std::vector<std::shared_ptr<XYTransform const>> TransformList;
    MultiXYTransform(TransformList const &transformList);
    MultiXYTransform(MultiXYTransform const &);
    MultiXYTransform(MultiXYTransform &&);
    MultiXYTransform &operator=(MultiXYTransform const &);
    MultiXYTransform &operator=(MultiXYTransform &&);
    ~MultiXYTransform();

    virtual std::shared_ptr<XYTransform> clone() const;
    virtual Point2D forwardTransform(Point2D const &point) const;
    virtual Point2D reverseTransform(Point2D const &point) const;
    virtual AffineTransform linearizeForwardTransform(Point2D const &point) const;
    virtual AffineTransform linearizeReverseTransform(Point2D const &point) const;
    TransformList getTransformList() const { return _transformList; }

private:
    TransformList _transformList;
};

class AffineXYTransform : public XYTransform {
public:
    AffineXYTransform(AffineTransform const &affineTransform);
    AffineXYTransform(AffineXYTransform const &);
    AffineXYTransform(AffineXYTransform &&);
    AffineXYTransform &operator=(AffineXYTransform const &);
    AffineXYTransform &operator=(AffineXYTransform &&);
    ~AffineXYTransform();

    virtual std::shared_ptr<XYTransform> clone() const;
    virtual Point2D forwardTransform(Point2D const &position) const;
    virtual Point2D reverseTransform(Point2D const &position) const;
    virtual AffineTransform linearizeForwardTransform(Point2D const &position) const;
    virtual AffineTransform linearizeReverseTransform(Point2D const &position) const;
    AffineTransform getForwardTransform() const;
    AffineTransform getReverseTransform() const;

protected:
    AffineTransform _forwardAffineTransform;
    AffineTransform _reverseAffineTransform;
};

class RadialXYTransform : public XYTransform {
public:
    RadialXYTransform(std::vector<double> const &coeffs

    );
    RadialXYTransform(RadialXYTransform const &);
    RadialXYTransform(RadialXYTransform &&);
    RadialXYTransform &operator=(RadialXYTransform const &);
    RadialXYTransform &operator=(RadialXYTransform &&);
    ~RadialXYTransform();

    virtual std::shared_ptr<XYTransform> clone() const;
    virtual std::shared_ptr<XYTransform> invert() const;
    virtual Point2D forwardTransform(Point2D const &point) const;
    virtual Point2D reverseTransform(Point2D const &point) const;
    virtual AffineTransform linearizeForwardTransform(Point2D const &point) const;
    virtual AffineTransform linearizeReverseTransform(Point2D const &point) const;
    std::vector<double> getCoeffs() const { return _coeffs; }

    static std::vector<double> polyInvert(std::vector<double> const &coeffs);
    static double polyEval(std::vector<double> const &coeffs, double x);
    static Point2D polyEval(std::vector<double> const &coeffs, Point2D const &p);
    static double polyEvalDeriv(std::vector<double> const &coeffs, double x);

    static AffineTransform polyEvalJacobian(std::vector<double> const &coeffs, Point2D const &p);

    static double polyEvalInverse(std::vector<double> const &coeffs, std::vector<double> const &icoeffs,
                                  double x);

    static Point2D polyEvalInverse(std::vector<double> const &coeffs, std::vector<double> const &icoeffs,
                                   Point2D const &p);

    static AffineTransform polyEvalInverseJacobian(std::vector<double> const &coeffs,
                                                   std::vector<double> const &icoeffs, Point2D const &p);

    static AffineTransform makeAffineTransform(double x, double y, double f, double g);

protected:
    std::vector<double> _coeffs;
    std::vector<double> _icoeffs;
};
}
}
}

#endif