AffineTransform.h

Go to the documentation of this file.

/*
 * Developed for the LSST Data Management System.
 * This product includes software developed by the LSST Project
 * (https://www.lsst.org).
 * See the COPYRIGHT file at the top-level directory of this distribution
 * for details of code ownership.
 *
 * 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 GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef LSST_GEOM_AFFINE_TRANSFORM_H
#define LSST_GEOM_AFFINE_TRANSFORM_H

#include <memory>
#include <iostream>

#include "Eigen/Core"

#include "lsst/geom/Point.h"
#include "lsst/geom/Extent.h"
#include "lsst/geom/LinearTransform.h"
#include "lsst/geom/Angle.h"

namespace lsst {
namespace geom {

class AffineTransform final {
public:
    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() noexcept : _linear(), _translation() {}

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

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

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

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

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

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

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

    AffineTransform(AffineTransform const &) noexcept = default;
    AffineTransform(AffineTransform &&) noexcept = default;
    ~AffineTransform() noexcept = default;


    AffineTransform const inverted() const;

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

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

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


    double applyX(double x, double y) const noexcept { return _linear.applyX(x, y) + _translation.getX(); }
    double applyY(double x, double y) const noexcept { return _linear.applyY(x, y) + _translation.getY(); }

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

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

    Matrix const getMatrix() const noexcept;

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

    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 noexcept {
        return AffineTransform(getLinear() * other.getLinear(),
                               getLinear()(other.getTranslation()) + getTranslation());
    }

    AffineTransform &operator=(AffineTransform const &) noexcept = default;
    AffineTransform &operator=(AffineTransform &&) noexcept = default;

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

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

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

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

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

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

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

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

private:
    LinearTransform _linear;
    Extent2D _translation;
};

std::ostream &operator<<(std::ostream &os, lsst::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);
}  // namespace geom
}  // namespace lsst

#endif  // !LSST_GEOM_AFFINE_TRANSFORM_H