MRMesh/MRAffineXf.h

Go to the documentation of this file.

#pragma once
 
#include "MRMacros.h"
#include "MRMeshFwd.h"
#include <iosfwd>
#include <type_traits>
 
#if MR_COMPILING_ANY_BINDINGS
// In C: Include the headers for the matrices that are otherwise missing in the C bindings.
//     I'm not sure how the binding generator could possibly guess that it needs to include those.
// In Python: Need those headers to generate the implementation for `operator<<` and `operator>>`, which call into the same operators of matrices.
#include "MRMatrix2.h"
#include "MRMatrix3.h"
#endif
 
namespace MR
{
 
template <typename V>
struct AffineXf
{
    using T = typename V::ValueType;
    using M = typename V::MatrixType;
 
    M A;
    V b;
 
    constexpr AffineXf() noexcept = default;
    constexpr AffineXf( const M & A, const V & b ) noexcept : A( A ), b( b ) { }
 
    // Here `U == V` doesn't seem to cause any issues in the C++ code, but we're still disabling it because it somehow gets emitted
    //   when generating the bindings, and results in duplicate functions in C#.
    template <typename U> MR_REQUIRES_IF_SUPPORTED( !std::is_same_v<U, V> )
    constexpr explicit AffineXf( const AffineXf<U> & xf ) noexcept : A( xf.A ), b( xf.b ) { }
 
    [[nodiscard]] static constexpr AffineXf translation( const V & b ) noexcept { return AffineXf{ M{}, b }; }
    [[nodiscard]] static constexpr AffineXf linear( const M & A ) noexcept { return AffineXf{ A, V{} }; }
    [[nodiscard]] static constexpr AffineXf xfAround( const M & A, const V & stable ) noexcept { return AffineXf{ A, stable - A * stable }; }
 
    [[nodiscard]] constexpr V operator() ( const V & x ) const noexcept { return A * x + b; }
    [[nodiscard]] constexpr V linearOnly( const V & x ) const noexcept { return A * x; }
    [[nodiscard]] constexpr AffineXf inverse() const noexcept MR_REQUIRES_IF_SUPPORTED( !std::is_integral_v<T> );
 
    friend AffineXf<V> operator * ( const AffineXf<V> & u, const AffineXf<V> & v )
        { return { u.A * v.A, u.A * v.b + u.b }; }
 
    friend bool operator == ( const AffineXf<V> & a, const AffineXf<V> & b )
    {
        return a.A == b.A && a.b == b.b;
    }
 
    friend bool operator != ( const AffineXf<V> & a, const AffineXf<V> & b )
    {
        return !( a == b );
    }
 
    friend std::ostream& operator<<( std::ostream& s, const AffineXf& xf )
    {
        return s << xf.A << xf.b;
    }
 
    friend std::istream& operator>>( std::istream& s, AffineXf& xf )
    {
        return s >> xf.A >> xf.b;
    }
};
 
 
template <typename V>
inline constexpr AffineXf<V> AffineXf<V>::inverse() const noexcept MR_REQUIRES_IF_SUPPORTED( !std::is_integral_v<T> )
{
    AffineXf<V> res;
    res.A = A.inverse();
    res.b = -( res.A * b );
    return res;
}
 
 
} // namespace MR