AffineTransform.h

Go to the documentation of this file.

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

/*
 * LSST Data Management System
 * Copyright 2008-2014 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/>.
 */

#ifndef LSST_AFW_MATH_AFFINE_TRANSFORM_H
#define LSST_AFW_MATH_AFFINE_TRANSFORM_H

#include <memory>
#include "Eigen/Core"
#include <iostream>
#include "lsst/afw/geom/Point.h"
#include "lsst/afw/geom/Extent.h"
#include "lsst/afw/geom/LinearTransform.h"
#include "lsst/afw/geom/Angle.h"

namespace lsst {
namespace afw {
namespace geom {

class AffineTransform {
public:
    typedef std::shared_ptr<AffineTransform> Ptr;
    typedef std::shared_ptr<AffineTransform const> ConstPtr;

    enum Parameters {XX=0,YX=1,XY=2,YY=3,X=4,Y=5};

    typedef Eigen::Matrix3d Matrix;
    typedef Eigen::Matrix<double,6,1> ParameterVector;
    typedef Eigen::Matrix<double,2,6> TransformDerivativeMatrix;


    AffineTransform() : _linear(), _translation() {}

    explicit AffineTransform(Eigen::Matrix3d const & matrix)
      : _linear(matrix.block<2,2>(0,0)),
        _translation(matrix.block<2,1>(0,2))
    {}

    explicit AffineTransform(Eigen::Matrix2d const & linear)
      : _linear(linear), _translation() {}

    explicit AffineTransform(Eigen::Vector2d const & translation)
      : _linear(), _translation(translation) {}

    explicit AffineTransform(
        Eigen::Matrix2d const & linear, Eigen::Vector2d const & translation
    ) : _linear(linear), _translation(translation) {}

    AffineTransform(LinearTransform const & linear)
      : _linear(linear), _translation() {}

    explicit AffineTransform(Extent2D const & translation)
      : _linear(), _translation(translation) {}

    explicit AffineTransform(
        LinearTransform const & linear, Extent2D const & translation
    ) : _linear(linear), _translation(translation) {}


    AffineTransform const invert() const;

    bool isIdentity() const { return getMatrix().isIdentity(); }


    Point2D operator()(Point2D const &p) const {
        return Point2D(_linear(p) + _translation);
    }

    Extent2D operator()(Extent2D const &p) const {
        return Extent2D(_linear(p));
    }

    Extent2D const & getTranslation() const {return _translation;}
    Extent2D & getTranslation() {return _translation;}

    LinearTransform const & getLinear() const {return _linear;}
    LinearTransform & getLinear() {return _linear;}

    Matrix const getMatrix() const;

    ParameterVector const getParameterVector() const;
    void setParameterVector(ParameterVector const & vector);

    double & operator[](int i) {
        return (i < 4) ? _linear[i] : _translation[i - 4];
    }
    double operator[](int i) const {
        return (i < 4) ? _linear[i] : _translation[i - 4];
    }

    AffineTransform operator*(AffineTransform const & other) const {
        return AffineTransform(
            getLinear()*other.getLinear(),
            getLinear()(other.getTranslation()) + getTranslation()
        );
    }

    AffineTransform & operator =(AffineTransform const & other) {
        _linear = other._linear;
        _translation = other._translation;
        return *this;
    }

    AffineTransform & operator+=(AffineTransform const & other) {
        _linear += other._linear;
        _translation += other._translation;
        return *this;
    }

    AffineTransform operator+(AffineTransform const & other) {
        AffineTransform tmp(*this);
        tmp += other;
        return tmp;
    }

    AffineTransform & operator-=(AffineTransform const & other) {
        _linear -= other._linear;
        _translation -= other._translation;
        return *this;
    }

    AffineTransform operator-(AffineTransform const & other) {
        AffineTransform tmp(*this);
        tmp -= other;
        return tmp;
    }

    static AffineTransform makeScaling(double s) {
        return AffineTransform(LinearTransform::makeScaling(s));
    }

    static AffineTransform makeScaling(double s, double t) {
        return AffineTransform(LinearTransform::makeScaling(s, t));
    }
    static AffineTransform makeRotation(Angle t) {
        return AffineTransform(LinearTransform::makeRotation(t));
    }

    static AffineTransform makeTranslation(Extent2D translation) {
        return AffineTransform(translation);
    }

    TransformDerivativeMatrix dTransform(Point2D const & input) const;
    TransformDerivativeMatrix dTransform(Extent2D const & input) const;

private:

    LinearTransform _linear;
    Extent2D _translation;
};

std::ostream & operator<<(std::ostream & os, lsst::afw::geom::AffineTransform const & transform);


//
// Returns the unique AffineTransform A such that A(p_i)=q_i for i=1,2,3
//
AffineTransform makeAffineTransformFromTriple(Point2D const &p1, Point2D const &p2, Point2D const &p3,
                                              Point2D const &q1, Point2D const &q2, Point2D const &q3);


}}}

#endif // !LSST_AFW_MATH_AFFINE_TRANSFORM_H