farm-ng-core
Namespaces | Classes | Functions | Variables
sophus::concepts Namespace Reference

Namespaces

 accessors
 
 base
 
 details
 

Classes

struct  CompatScalarEx
 
class  UnitVector
 

Functions

template<class TPoint , class TFunc , class TReduce >
void reduceArg (TPoint const &x, TReduce &reduce, TFunc &&func)
 
template<class TPoint , class TFunc , class TReduce >
void reduceArg (TPoint const &a, TPoint const &b, TReduce &reduce, TFunc &&func)
 
template<class TPoint , class TFunc , class TReduce >
auto reduce (TPoint const &x, TReduce const &initial, TFunc &&func) -> TReduce
 
template<class TPoint , class TFunc , class TReduce >
auto reduce (TPoint const &a, TPoint const &b, TReduce const &initial, TFunc &&func) -> TReduce
 

Variables

template<class TT >
concept DivisionRingImpl
 
template<class TT >
concept DivisionRingConcept
 
template<class TT >
concept Rotation2
 
template<class TT >
concept Rotation3
 
template<class TT >
concept SpiralSimilarity2 = accessors::SpiralSimilarity2<TT>
 
template<class TT >
concept SpiralSimilarity3 = accessors::SpiralSimilarity3<TT>
 
template<class TT >
concept Isometry2
 
template<class TT >
concept Isometry3
 
template<class TT >
concept Similarity2
 
template<class TT >
concept Similarity3
 
template<class TT >
concept Translation = accessors::Translation<TT>
 
template<class TT >
concept ImageSizeTrait
 
template<class TT >
concept ImageLayoutTrait
 
template<class TT >
concept ImageView
 
template<class TT >
concept DynImageView
 
template<class TT >
concept LieGroupImpl
 
template<class TT >
concept LieFactorGroupImpl
 
template<class TT >
concept LieGroup
 
template<class TT >
concept ManifoldImpl
 
template<class TT >
concept BaseManifold
 
template<class TT >
concept Manifold
 
template<class TT >
concept ParamsImpl
 
template<class TT >
concept Tangent
 
template<class TT >
concept Params
 
template<class TDerived >
concept EigenType = DerivedFrom<TDerived, Eigen::EigenBase<TDerived>>
 
template<class TDerived >
concept EigenDenseType = DerivedFrom<TDerived, Eigen::DenseBase<TDerived>>
 
template<class TDerived >
concept EigenMatrixType = DerivedFrom<TDerived, Eigen::MatrixBase<TDerived>>
 
template<class TDerived >
concept EigenArrayType = DerivedFrom<TDerived, Eigen::ArrayBase<TDerived>>
 
template<class TT1 , typename TT2 >
concept EigenSameDim
 
template<int kRows, int kCols, typename TT >
concept EigenWithDim
 
template<typename TT >
concept EigenVector3
 
template<int kRows, int kCols, typename TT >
concept EigenWithDimOrDynamic
 
template<class TT >
concept RealScalarType = std::is_floating_point_v<TT>
 
template<class TT >
concept IntegerScalarType = std::is_integral_v<TT>
 
template<class TT >
concept ScalarType = RealScalarType<TT> || IntegerScalarType<TT>
 
template<class TT >
concept RealEigenDenseType
 
template<class TT >
concept IntegerEigenDenseType
 
template<class TT >
concept RealPointType = RealScalarType<TT> || RealEigenDenseType<TT>
 
template<class TT >
concept IntegerPointType = IntegerScalarType<TT> || IntegerEigenDenseType<TT>
 
template<class TT >
concept PointType = RealPointType<TT> || IntegerPointType<TT>
 
template<class TDerived , class TBase >
concept DerivedFrom = std::is_base_of_v<TBase, TDerived>
 
template<class TBase , class TDerived >
concept IsBaseOf = std::is_base_of_v<TBase, TDerived>
 
template<class TT , class TU >
concept SameAs = std::is_same_v<TT, TU>
 
template<class TT >
concept EnumType = std::is_enum_v<TT>
 
template<class TT >
concept Arithmetic = std::is_arithmetic_v<TT>
 
template<class TFrom , class TTo >
concept ConvertibleTo
 
template<class TT , class... TArgs>
concept ConstructibleFrom
 
template<class T >
concept Range
 

Function Documentation

◆ reduce() [1/2]

template<class TPoint , class TFunc , class TReduce >
auto sophus::concepts::reduce ( TPoint const &  a,
TPoint const &  b,
TReduce const &  initial,
TFunc &&  func 
) -> TReduce

◆ reduce() [2/2]

template<class TPoint , class TFunc , class TReduce >
auto sophus::concepts::reduce ( TPoint const &  x,
TReduce const &  initial,
TFunc &&  func 
) -> TReduce

◆ reduceArg() [1/2]

template<class TPoint , class TFunc , class TReduce >
void sophus::concepts::reduceArg ( TPoint const &  a,
TPoint const &  b,
TReduce &  reduce,
TFunc &&  func 
)

◆ reduceArg() [2/2]

template<class TPoint , class TFunc , class TReduce >
void sophus::concepts::reduceArg ( TPoint const &  x,
TReduce &  reduce,
TFunc &&  func 
)

Variable Documentation

◆ Arithmetic

template<class TT >
concept sophus::concepts::Arithmetic = std::is_arithmetic_v<TT>

◆ BaseManifold

template<class TT >
concept sophus::concepts::BaseManifold
Initial value:
= Tangent<TT> &&
requires(TT m, typename TT::Tangent tangent) {
{ m.oplus(tangent) } -> ConvertibleTo<TT>;
{ m.ominus(m) } -> ConvertibleTo<typename TT::Tangent>;
}

◆ ConstructibleFrom

template<class TT , class... TArgs>
concept sophus::concepts::ConstructibleFrom
Initial value:
=
std::is_nothrow_destructible_v<TT> && std::is_constructible_v<TT, TArgs...>

◆ ConvertibleTo

template<class TFrom , class TTo >
concept sophus::concepts::ConvertibleTo
Initial value:
= std::is_convertible_v<TFrom, TTo> && requires {
static_cast<TTo>(std::declval<TFrom>());
}

◆ DerivedFrom

template<class TDerived , class TBase >
concept sophus::concepts::DerivedFrom = std::is_base_of_v<TBase, TDerived>

◆ DivisionRingConcept

template<class TT >
concept sophus::concepts::DivisionRingConcept
Initial value:
= DivisionRingImpl<typename TT::Impl> && requires(
TT r,
typename TT::Scalar real,
typename TT::Imag imag,
typename TT::Params params) {
{ r.operator+(r) } -> ::sophus::concepts::ConvertibleTo<TT>;
{ r.operator*(r) } -> ::sophus::concepts::ConvertibleTo<TT>;
{ r.conjugate() } -> ::sophus::concepts::ConvertibleTo<TT>;
{ r.inverse() } -> ::sophus::concepts::ConvertibleTo<TT>;
{ r.norm() } -> ::sophus::concepts::ConvertibleTo<typename TT::Scalar>;
{ r.squaredNorm() } -> ::sophus::concepts::ConvertibleTo<typename TT::Scalar>;
{ r.real() } -> ::sophus::concepts::ConvertibleTo<typename TT::Scalar>;
{ r.imag() } -> ::sophus::concepts::ConvertibleTo<typename TT::Imag>;
}

◆ DivisionRingImpl

template<class TT >
concept sophus::concepts::DivisionRingImpl

◆ DynImageView

template<class TT >
concept sophus::concepts::DynImageView
Initial value:
= ImageLayoutTrait<TT> && requires(TT self) {
{ self.layout() } -> ConvertibleTo<sophus::ImageLayout>;
{ self.pixelFormat() } -> ConvertibleTo<PixelFormat>;
}

◆ EigenArrayType

template<class TDerived >
concept sophus::concepts::EigenArrayType = DerivedFrom<TDerived, Eigen::ArrayBase<TDerived>>

◆ EigenDenseType

template<class TDerived >
concept sophus::concepts::EigenDenseType = DerivedFrom<TDerived, Eigen::DenseBase<TDerived>>

◆ EigenMatrixType

template<class TDerived >
concept sophus::concepts::EigenMatrixType = DerivedFrom<TDerived, Eigen::MatrixBase<TDerived>>

◆ EigenSameDim

template<class TT1 , typename TT2 >
concept sophus::concepts::EigenSameDim
Initial value:
= EigenDenseType<TT1> && EigenDenseType<TT2> &&
(TT1::RowsAtCompileTime == Eigen::Dynamic ||
TT1::RowsAtCompileTime == TT2::RowsAtCompileTime) &&
(TT1::ColsAtCompileTime == Eigen::Dynamic ||
TT1::ColsAtCompileTime == TT2::ColsAtCompileTime)

◆ EigenType

template<class TDerived >
concept sophus::concepts::EigenType = DerivedFrom<TDerived, Eigen::EigenBase<TDerived>>

◆ EigenVector3

template<typename TT >
concept sophus::concepts::EigenVector3
Initial value:
= EigenDenseType<TT> && TT::RowsAtCompileTime == 3 &&
TT::ColsAtCompileTime == 1

◆ EigenWithDim

template<int kRows, int kCols, typename TT >
concept sophus::concepts::EigenWithDim
Initial value:
= EigenDenseType<TT> && TT::RowsAtCompileTime ==
kRows&& TT::ColsAtCompileTime == kCols

◆ EigenWithDimOrDynamic

template<int kRows, int kCols, typename TT >
concept sophus::concepts::EigenWithDimOrDynamic
Initial value:
= EigenDenseType<TT> &&
(TT::RowsAtCompileTime == Eigen::Dynamic ||
TT::RowsAtCompileTime == kRows) &&
(TT::ColsAtCompileTime == Eigen::Dynamic ||
TT::ColsAtCompileTime == kCols)

◆ EnumType

template<class TT >
concept sophus::concepts::EnumType = std::is_enum_v<TT>

◆ ImageLayoutTrait

template<class TT >
concept sophus::concepts::ImageLayoutTrait
Initial value:
= ImageSizeTrait<TT> && requires(TT self) {
{ self.sizeBytes() } -> SameAs<size_t>;
{ self.pitchBytes() } -> SameAs<size_t>;
{ self.isEmpty() } -> SameAs<bool>;
{ self.imageSize() } -> ConvertibleTo<sophus::ImageSize>;
}

◆ ImageSizeTrait

template<class TT >
concept sophus::concepts::ImageSizeTrait
Initial value:
= requires(TT self) {
{ self.width() } -> SameAs<int>;
{ self.height() } -> SameAs<int>;
{ self.area() } -> SameAs<size_t>;
}

◆ ImageView

template<class TT >
concept sophus::concepts::ImageView
Initial value:
= ImageLayoutTrait<TT> && requires(TT self) {
{ self.layout() } -> ConvertibleTo<sophus::ImageLayout>;
}

◆ IntegerEigenDenseType

template<class TT >
concept sophus::concepts::IntegerEigenDenseType
Initial value:
=
EigenDenseType<TT> && std::is_integral_v<typename TT::Scalar>

◆ IntegerPointType

template<class TT >
concept sophus::concepts::IntegerPointType = IntegerScalarType<TT> || IntegerEigenDenseType<TT>

◆ IntegerScalarType

template<class TT >
concept sophus::concepts::IntegerScalarType = std::is_integral_v<TT>

◆ IsBaseOf

template<class TBase , class TDerived >
concept sophus::concepts::IsBaseOf = std::is_base_of_v<TBase, TDerived>

◆ Isometry2

template<class TT >
concept sophus::concepts::Isometry2
Initial value:
= accessors::Isometry2<TT> && accessors::Rotation2<TT> &&
accessors::UnitComplex<TT>

◆ Isometry3

template<class TT >
concept sophus::concepts::Isometry3
Initial value:
= accessors::Isometry3<TT> && accessors::Rotation3<TT> &&
accessors::UnitQuaternion<TT>

◆ LieFactorGroupImpl

template<class TT >
concept sophus::concepts::LieFactorGroupImpl
Initial value:
= LieGroupImpl<TT> && requires(
typename TT::Tangent tangent,
typename TT::Params params,
typename TT::Point point) {
{
TT::matV(params, tangent)
} -> ConvertibleTo<
Eigen::Matrix<typename TT::Scalar, TT::kPointDim, TT::kPointDim>>;
{
TT::matVInverse(params, tangent)
} -> ConvertibleTo<
Eigen::Matrix<typename TT::Scalar, TT::kPointDim, TT::kPointDim>>;
{
TT::adjOfTranslation(params, point)
} -> ConvertibleTo<
Eigen::Matrix<typename TT::Scalar, TT::kPointDim, TT::kDof>>;
{
TT::adOfTranslation(point)
} -> ConvertibleTo<
Eigen::Matrix<typename TT::Scalar, TT::kPointDim, TT::kPointDim>>;
}

◆ LieGroup

template<class TT >
concept sophus::concepts::LieGroup

◆ LieGroupImpl

template<class TT >
concept sophus::concepts::LieGroupImpl

◆ Manifold

template<class TT >
concept sophus::concepts::Manifold
Initial value:
= Params<TT> && Tangent<TT> && BaseManifold<TT> &&
requires(std::vector<TT> points) {
{ TT::average(points) } -> ConvertibleTo<std::optional<TT>>;
}

◆ ManifoldImpl

template<class TT >
concept sophus::concepts::ManifoldImpl
Initial value:
= Tangent<TT> &&
requires(typename TT::Tangent tangent, typename TT::Params params) {
{ TT::oplus(params, tangent) } -> ConvertibleTo<typename TT::Params>;
{ TT::ominus(params, params) } -> ConvertibleTo<typename TT::Tangent>;
}

◆ Params

template<class TT >
concept sophus::concepts::Params
Initial value:
= std::is_same_v<
typename TT::Params,
Eigen::Vector<typename TT::Scalar, TT::kNumParams>> &&
requires(TT m, typename TT::Params params) {
{ TT::fromParams(params) } -> ConvertibleTo<TT>;
{m.setParams(params)};
{ m.params() } -> ConvertibleTo<typename TT::Params>;
{ m.ptr() } -> ConvertibleTo<typename TT::Scalar const *>;
{ m.unsafeMutPtr() } -> ConvertibleTo<typename TT::Scalar *>;
}

◆ ParamsImpl

template<class TT >
concept sophus::concepts::ParamsImpl
Initial value:
= std::is_same_v<
typename TT::Params,
Eigen::Vector<typename TT::Scalar, TT::kNumParams>> &&
requires(typename TT::Params params) {
{ TT::areParamsValid(params) } -> ConvertibleTo<sophus::Expected<Success>>;
{ TT::paramsExamples() } -> ConvertibleTo<std::vector<typename TT::Params>>;
{
TT::invalidParamsExamples()
} -> ConvertibleTo<std::vector<typename TT::Params>>;
}

◆ PointType

template<class TT >
concept sophus::concepts::PointType = RealPointType<TT> || IntegerPointType<TT>

◆ Range

template<class T >
concept sophus::concepts::Range
Initial value:
= requires(T& t) {
t.begin();
t.end();
}

◆ RealEigenDenseType

template<class TT >
concept sophus::concepts::RealEigenDenseType
Initial value:
=
EigenDenseType<TT> && std::is_floating_point_v<typename TT::Scalar>

◆ RealPointType

template<class TT >
concept sophus::concepts::RealPointType = RealScalarType<TT> || RealEigenDenseType<TT>

◆ RealScalarType

template<class TT >
concept sophus::concepts::RealScalarType = std::is_floating_point_v<TT>

◆ Rotation2

template<class TT >
concept sophus::concepts::Rotation2
Initial value:
=
base::Rotation<TT> && ConstructibleFrom<TT, typename TT::Scalar> &&
accessors::Rotation2<TT> && accessors::UnitComplex<TT>

◆ Rotation3

template<class TT >
concept sophus::concepts::Rotation3
Initial value:
= base::Rotation<TT> && accessors::Rotation3<TT> &&
accessors::UnitQuaternion<TT>

◆ SameAs

template<class TT , class TU >
concept sophus::concepts::SameAs = std::is_same_v<TT, TU>

◆ ScalarType

template<class TT >
concept sophus::concepts::ScalarType = RealScalarType<TT> || IntegerScalarType<TT>

◆ Similarity2

template<class TT >
concept sophus::concepts::Similarity2
Initial value:
=
accessors::Similarity<TT> && accessors::SpiralSimilarity2<TT>

◆ Similarity3

template<class TT >
concept sophus::concepts::Similarity3
Initial value:
=
accessors::Similarity<TT> && accessors::SpiralSimilarity3<TT>

◆ SpiralSimilarity2

template<class TT >
concept sophus::concepts::SpiralSimilarity2 = accessors::SpiralSimilarity2<TT>

◆ SpiralSimilarity3

template<class TT >
concept sophus::concepts::SpiralSimilarity3 = accessors::SpiralSimilarity3<TT>

◆ Tangent

template<class TT >
concept sophus::concepts::Tangent
Initial value:
= std::is_same_v<
typename TT::Tangent,
Eigen::Vector<typename TT::Scalar, TT::kDof>> && requires() {
{ TT::tangentExamples() } -> ConvertibleTo<std::vector<typename TT::Tangent>>;
}

◆ Translation

template<class TT >
concept sophus::concepts::Translation = accessors::Translation<TT>
sophus::average
auto average(TSequenceContainer const &foo_from_bar_transforms) -> std::enable_if_t< std::is_same< typename TSequenceContainer::value_type, Translation< TScalar, kPointDim > >::value, std::optional< typename TSequenceContainer::value_type > >
Definition: average.h:81
sophus::concepts::Tangent
concept Tangent
Definition: params.h:34
sophus::concepts::ConvertibleTo
concept ConvertibleTo
Definition: utils.h:33
sophus::concepts::Params
concept Params
Definition: params.h:41