LinearTransform.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_LINEAR_TRANSFORM_H
#define LSST_GEOM_LINEAR_TRANSFORM_H
 
#include "Eigen/Core"
#include "Eigen/Geometry"
 
#include "lsst/pex/exceptions/Runtime.h"
#include "lsst/geom/Point.h"
#include "lsst/geom/Angle.h"
 
namespace lsst {
namespace geom {
 
LSST_EXCEPTION_TYPE(SingularTransformException, lsst::pex::exceptions::RuntimeError,
                    lsst::geom::SingularTransformException)
 
 
class LinearTransform final {
public:
    enum Parameters { XX = 0, YX = 1, XY = 2, YY = 3 };
 
    typedef Eigen::Matrix<double, 4, 1> ParameterVector;
    typedef Eigen::Matrix<double, 2, 4> TransformDerivativeMatrix;
    typedef Eigen::Matrix<double, 4, 4> ProductDerivativeMatrix;
 
    typedef Eigen::Matrix<double, 2, 2, Eigen::DontAlign> Matrix;
 
    LinearTransform() noexcept : _matrix(Matrix::Identity()) {}
 
    explicit LinearTransform(Matrix const& matrix) noexcept : _matrix(matrix) {}
 
    // Can't use both =default and noexcept until Eigen supports noexcept
    LinearTransform(LinearTransform const& other) noexcept : _matrix(other._matrix){};
    LinearTransform(LinearTransform&& other) noexcept : _matrix(std::move(other._matrix)){};
    ~LinearTransform() noexcept = default;
 
    LinearTransform operator*(LinearTransform const& other) const noexcept {
        return LinearTransform(getMatrix() * other.getMatrix());
    }
 
    static LinearTransform makeScaling(double s) noexcept {
        return LinearTransform((Matrix() << s, 0.0, 0.0, s).finished());
    }
 
    static LinearTransform makeScaling(double s, double t) noexcept {
        return LinearTransform((Matrix() << s, 0.0, 0.0, t).finished());
    }
 
    static LinearTransform makeRotation(Angle t) noexcept {
        return LinearTransform(Matrix(Eigen::Rotation2D<double>(t.asRadians())));
    }
 
    // Can't use both =default and noexcept until Eigen supports noexcept
    LinearTransform& operator=(LinearTransform const& other) noexcept {
        _matrix = other._matrix;
        return *this;
    }
    LinearTransform& operator=(LinearTransform&& other) noexcept {
        _matrix = std::move(other._matrix);
        return *this;
    }
 
    LinearTransform& operator+=(LinearTransform const& other) noexcept {
        _matrix += other._matrix;
        return *this;
    }
 
    LinearTransform operator+(LinearTransform const& other) noexcept {
        LinearTransform tmp(*this);
        tmp += other;
        return tmp;
    }
 
    LinearTransform& operator-=(LinearTransform const& other) noexcept {
        _matrix -= other._matrix;
        return *this;
    }
 
    LinearTransform operator-(LinearTransform const& other) noexcept {
        LinearTransform tmp(*this);
        tmp -= other;
        return tmp;
    }
 
    ParameterVector const getParameterVector() const noexcept;
    void setParameterVector(ParameterVector const& vector) noexcept;
 
    Matrix const& getMatrix() const noexcept { return _matrix; }
    Matrix& getMatrix() noexcept { return _matrix; }
 
    double& operator[](int i) { return _matrix(i % 2, i / 2); }
    double const& operator[](int i) const { return const_cast<Matrix&>(_matrix)(i % 2, i / 2); }
 
    LinearTransform const inverted() const;
 
    double computeDeterminant() const noexcept;
 
    bool isIdentity() const noexcept { return getMatrix().isIdentity(); }
 
    Point2D operator()(Point2D const& p) const noexcept { return Point2D(getMatrix() * p.asEigen()); }
 
    Extent2D operator()(Extent2D const& p) const noexcept { return Extent2D(getMatrix() * p.asEigen()); }
 
 
    double applyX(double x, double y) const noexcept { return _matrix(0, 0)*x + _matrix(0, 1)*y; }
    double applyY(double x, double y) const noexcept { return _matrix(1, 0)*x + _matrix(1, 1)*y; }
 
    TransformDerivativeMatrix dTransform(Point2D const& input) const noexcept;
 
    TransformDerivativeMatrix dTransform(Extent2D const& input) const noexcept {
        return dTransform(Point2D(input));
    }
 
private:
    Matrix _matrix;
};
 
std::ostream& operator<<(std::ostream& os, lsst::geom::LinearTransform const& t);
 
}  // namespace geom
}  // namespace lsst
 
#endif  // !LSST_GEOM_LINEAR_TRANSFORM_H