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;
    LinearTransform const invert() const { return inverted(); };

    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()); }

    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