farm-ng-core
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
sophus Namespace Reference

Image MutImage, owning images types. More...

Namespaces

 ceres
 
 concepts
 
 detail
 
 jet_helpers
 
 lie
 
 linalg
 
 test
 

Classes

class  AffineTransform
 
struct  AnyImagePredicate
 
class  BasisSpline
 
class  BasisSplineFn
 
class  BasisSplineImpl
 
struct  BasisSplineSegment
 
class  BrownConradyTransform
 
struct  CameraInRig
 Camera as part of a sensor rig. More...
 
class  CameraModel
 Concrete camera model class. More...
 
class  CameraModelT
 Camera model class template for pinhole-like camera projections. More...
 
struct  ClippingPlanes
 
struct  ClosestApproachResult
 
class  Complex
 
class  ComplexImpl
 
class  DynImage
 Type-erased image with shared ownership, and read-only access to pixels. Type is nullable. More...
 
class  DynImageView
 
struct  GroupManifold
 
class  Identity
 
class  Image
 Image read-only access to pixels and shared ownership, hence cheap to copy. Type is nullable. More...
 
class  ImageLayout
 Layout of the image: width, height and pitch in bytes. More...
 
struct  ImageSize
 Image size, hence its width and height. More...
 
struct  ImageTraits
 Number type. More...
 
struct  ImageTraits< Eigen::Matrix< TT, kNumChannelsT, 1 > >
 
struct  ImageView
 A view of an (immutable) image, which does not own the data. More...
 
class  ImuModel
 
struct  IndexAndU
 
struct  IntensityImagePredicate
 
class  InverseDepthPoint3
 Inverse depth point representation. More...
 
class  Isometry2
 
class  Isometry3
 
struct  IsUniformRandomBitGenerator
 
class  KannalaBrandtK3Transform
 
struct  Mapper
 Helper for mapping tangent vectors (scalars) over pointers to data. More...
 
struct  Mapper< TScalar, typename std::enable_if< kIsMappableV< TScalar > >::type >
 
struct  MaybeLeakingUniqueDataAreaDeleter
 
struct  MultiCameraRig
 Sensor rig with multiple cameras. More...
 
class  MutDynImage
 
class  MutDynImageView
 
class  MutImage
 A image with write access to pixels and exclusive ownership. There is no copy constr / copy assignment, but move constr / assignment. More...
 
class  MutImageView
 View of a mutable image, which does not own the data. More...
 
struct  PixelFormat
 
struct  PointTraits
 
struct  PointTraits< TPoint >
 
class  PointTransformer
 Functor to efficiently transform a number of point given a Isometry3 pose. More...
 
class  Pose3
 
class  ProductManifold
 
struct  ProjectionOrtho
 
struct  ProjectionZ1
 
class  Quaternion
 
class  QuaternionImpl
 
class  Ray
 
class  Region
 A region is a closed interval [a, b] with a being the lower bound (=min) and b being the upper bound (=max). More...
 
class  Rotation2
 
class  Rotation3
 
class  Scaling
 
struct  ScalingNonOrthogonalityAcceleroModel
 
struct  ScalingNonOrthogonalityGyroModel
 
class  ScalingTranslation
 
class  Similarity2
 
class  Similarity3
 
class  SpiralSimilarity2
 
class  SpiralSimilarity3
 
class  SplineBasisFunction
 
class  Translation
 
struct  UninitTag
 
struct  UniqueDataAreaDeleter
 
class  UnitVector
 
struct  VectorManifold
 

Typedefs

using RegionI = Region< int >
 
using RegionF32 = Region< float >
 
using RegionF64 = Region< double >
 
template<concepts::ScalarType TScalar>
using Region2 = Region< Eigen::Array< TScalar, 2, 1 > >
 
using Region2I = Region2< int >
 
using Region2F32 = Region2< float >
 
using Region2F64 = Region2< double >
 
template<concepts::ScalarType TScalar>
using Region3 = Region< Eigen::Array< TScalar, 3, 1 > >
 
using Region3I = Region3< int >
 
using Region3F32 = Region3< float >
 
using Region3F64 = Region3< double >
 
template<concepts::ScalarType TScalar>
using Region4 = Region< Eigen::Array< TScalar, 4, 1 > >
 
using Region4I = Region4< int >
 
using Region4F32 = Region4< float >
 
using Region4F64 = Region4< double >
 
template<class TScalar >
using IsSpecialized = decltype(complete(std::declval< TScalar * >()))
 
template<class TScalar >
using IsMappable = IsSpecialized< Eigen::internal::traits< std::decay_t< TScalar > >>
 Type trait used to distinguish mappable vector types from scalars. More...
 
using InverseDepthPoint3F64 = InverseDepthPoint3< double >
 
template<class TScalar >
using Ray2 = Ray< TScalar, 2 >
 
template<class TScalar >
using Ray3 = Ray< TScalar, 3 >
 
using Ray2F64 = Ray2< double >
 
using Ray3F64 = Ray3< double >
 
template<class TAllocator = Eigen::aligned_allocator<uint8_t>>
using AnyImage = DynImage< AnyImagePredicate, TAllocator >
 Image representing any number of channels (>=1) and any floating and unsigned integral channel type. More...
 
using AnyImageView = DynImageView< AnyImagePredicate >
 
template<class TAllocator = Eigen::aligned_allocator<uint8_t>>
using MutAnyImage = MutDynImage< AnyImagePredicate, TAllocator >
 
using MutAnyImageView = MutDynImageView< AnyImagePredicate >
 
template<class TAllocator = Eigen::aligned_allocator<uint8_t>>
using IntensityImage = DynImage< IntensityImagePredicate, TAllocator >
 Image to represent intensity image / texture as grayscale (=1 channel), RGB (=3 channel ) and RGBA (=4 channel), either uint8_t [0-255], uint16 [0-65535] or float [0.0-1.0] channel type. More...
 
using IntensityImageView = DynImageView< IntensityImagePredicate >
 
template<class TAllocator = Eigen::aligned_allocator<uint8_t>>
using MutIntensityImage = MutDynImage< IntensityImagePredicate, TAllocator >
 
using MutIntensityImageView = MutDynImageView< IntensityImagePredicate >
 
template<class TChannel >
using Pixel2 = Eigen::Matrix< TChannel, 2, 1 >
 
using Pixel2U8 = Pixel2< uint8_t >
 
using Pixel2U16 = Pixel2< uint16_t >
 
using Pixel2F32 = Pixel2< float >
 
template<class TChannel >
using Pixel3 = Eigen::Matrix< TChannel, 3, 1 >
 
using Pixel3U8 = Pixel3< uint8_t >
 
using Pixel3U16 = Pixel3< uint16_t >
 
using Pixel3F32 = Pixel3< float >
 
template<class TChannel >
using Pixel4 = Eigen::Matrix< TChannel, 4, 1 >
 
using Pixel4U8 = Pixel4< uint8_t >
 
using Pixel4U16 = Pixel4< uint16_t >
 
using Pixel4F32 = Pixel4< float >
 
using ImageViewBool = ImageView< bool >
 
using MutImageViewBool = MutImageView< bool >
 
using ImageViewU8 = ImageView< uint8_t >
 
using ImageViewU16 = ImageView< uint16_t >
 
using ImageViewF32 = ImageView< float >
 
using MutImageViewU8 = MutImageView< uint8_t >
 
using MutImageViewU16 = MutImageView< uint16_t >
 
using MutImageViewF32 = MutImageView< float >
 
template<class TChannel >
using ImageView3 = ImageView< Pixel3< TChannel > >
 
using ImageView3U8 = ImageView3< uint8_t >
 
using ImageView3U16 = ImageView3< uint16_t >
 
using ImageView3F32 = ImageView3< float >
 
template<class TChannel >
using MutImageView3 = MutImageView< Pixel3< TChannel > >
 
using MutImageView3U8 = MutImageView3< uint8_t >
 
using MutImageView3U16 = MutImageView3< uint16_t >
 
using MutImageView3F32 = MutImageView3< float >
 
template<class TChannel >
using ImageView4 = ImageView< Pixel4< TChannel > >
 
using ImageView4U8 = ImageView4< uint8_t >
 
using ImageView4U16 = ImageView4< uint16_t >
 
using ImageView4F32 = ImageView4< float >
 
template<class TChannel >
using MutImageView4 = MutImageView< Pixel4< TChannel > >
 
using MutImageView4U8 = MutImageView4< uint8_t >
 
using MutImageView4U16 = MutImageView4< uint16_t >
 
using MutImageView4F32 = MutImageView4< float >
 
using ImageBool = Image< bool >
 
using MutImageBool = MutImage< bool >
 
using ImageU8 = Image< uint8_t >
 
using ImageU16 = Image< uint16_t >
 
using ImageF32 = Image< float >
 
using MutImageU8 = MutImage< uint8_t >
 
using MutImageU16 = MutImage< uint16_t >
 
using MutImageF32 = MutImage< float >
 
template<class TChannel >
using Image3 = Image< Pixel3< TChannel > >
 
using Image3U8 = Image3< uint8_t >
 
using Image3U16 = Image3< uint16_t >
 
using Image3F32 = Image3< float >
 
template<class TChannel >
using MutImage3 = MutImage< Pixel3< TChannel > >
 
using MutImage3U8 = MutImage3< uint8_t >
 
using MutImage3U16 = MutImage3< uint16_t >
 
using MutImage3F32 = MutImage3< float >
 
template<class TChannel >
using Image4 = Image< Pixel4< TChannel > >
 
using Image4U8 = Image4< uint8_t >
 
using Image4U16 = Image4< uint16_t >
 
using Image4F32 = Image4< float >
 
template<class TChannel >
using MutImage4 = MutImage< Pixel4< TChannel > >
 
using MutImage4U8 = MutImage4< uint8_t >
 
using MutImage4U16 = MutImage4< uint16_t >
 
using MutImage4F32 = MutImage4< float >
 
template<class TAllocator >
using UniqueDataArea = std::unique_ptr< uint8_t, MaybeLeakingUniqueDataAreaDeleter< TAllocator > >
 
template<concepts::LieGroup TGroup>
using LeftPlus = GroupManifold< TGroup, ManifoldPlusType::left_plus >
 
template<concepts::LieGroup TGroup>
using RightPlus = GroupManifold< TGroup, ManifoldPlusType::right_plus >
 
template<class TScalar >
using Identity2 = Identity< TScalar, 2 >
 
template<class TScalar >
using Identity3 = Identity< TScalar, 3 >
 
using Isometry2F32 = Isometry2< float >
 
using Isometry2F64 = Isometry2< double >
 
using Isometry3F32 = Isometry3< float >
 
using Isometry3F64 = Isometry3< double >
 
template<class TScalar >
using SE3 = Isometry3< TScalar >
 
using SE3f = Isometry3< float >
 
using SE3d = Isometry3< double >
 
using Pose3F32 = Pose3< float >
 
using Pose3F64 = Pose3< double >
 
using Rotation2F32 = Rotation2< float >
 
using Rotation2F64 = Rotation2< double >
 
using Rotation3F32 = Rotation3< float >
 
using Rotation3F64 = Rotation3< double >
 
template<class TScalar >
using SO3 = Rotation3< TScalar >
 
using SO3f = Rotation3< float >
 
using SO3d = Rotation3< double >
 
template<class TScalar >
using Scaling2 = Scaling< TScalar, 2 >
 
template<class TScalar >
using Scaling3 = Scaling< TScalar, 3 >
 
template<class TScalar >
using ScalingTranslation2 = ScalingTranslation< TScalar, 2 >
 
template<class TScalar >
using ScalingTranslation3 = ScalingTranslation< TScalar, 3 >
 
using ScalingTranslation2F64 = ScalingTranslation2< double >
 
using ScalingTranslation3F64 = ScalingTranslation3< double >
 
using Similarity2F32 = Similarity2< float >
 
using Similarity2F64 = Similarity2< double >
 
using Similarity3F32 = Similarity3< float >
 
using Similarity3F64 = Similarity3< double >
 
using SpiralSimilarity2F32 = SpiralSimilarity2< float >
 
using SpiralSimilarity2F64 = SpiralSimilarity2< double >
 
using SpiralSimilarity3F32 = SpiralSimilarity3< float >
 
using SpiralSimilarity3F64 = SpiralSimilarity3< double >
 
template<class TScalar >
using Translation2 = Translation< TScalar, 2 >
 
template<class TScalar >
using Translation3 = Translation< TScalar, 3 >
 
using Translation2F32 = Translation2< float >
 
using Translation2F64 = Translation2< double >
 
using Translation3F32 = Translation3< float >
 
using Translation3F64 = Translation3< double >
 
using QuaternionF64 = Quaternion< double >
 
template<class TScalar >
using UnitVector3 = UnitVector< TScalar, 3 >
 
template<class TScalar >
using UnitVector2 = UnitVector< TScalar, 2 >
 
using UnitVector2F64 = UnitVector2< double >
 
using UnitVector3F64 = UnitVector3< double >
 
using PinholeModel = CameraModelT< double, AffineTransform, ProjectionZ1 >
 Pinhole camera model. More...
 
using BrownConradyModel = CameraModelT< double, BrownConradyTransform, ProjectionZ1 >
 Brown Conrady camera model. More...
 
using KannalaBrandtK3Model = CameraModelT< double, KannalaBrandtK3Transform, ProjectionZ1 >
 KannalaBrandt camera model with k0, k1, k2, k3. More...
 
using OrthographicModel = CameraModelT< double, AffineTransform, ProjectionOrtho >
 
using CameraDistortionVariant = std::variant< PinholeModel, BrownConradyModel, KannalaBrandtK3Model, OrthographicModel >
 Variant of camera models. More...
 
using GyroModelVariant = std::variant< ScalingNonOrthogonalityGyroModel< double > >
 
using AcceleroModelVariant = std::variant< ScalingNonOrthogonalityAcceleroModel< double > >
 
template<class TScalar >
using OrthographicModelT = CameraModelT< TScalar, AffineTransform, ProjectionOrtho >
 

Enumerations

enum  SegmentCase { SegmentCase::first, SegmentCase::normal, SegmentCase::last }
 

Functions

template<class TScalar , class TFn >
auto curveNumDiff (TFn curve, TScalar t, TScalar h=kEpsilonSqrt< TScalar >) -> decltype(details::Curve< TScalar >::numDiff(std::move(curve), t, h))
 Calculates the derivative of a curve at a point t. More...
 
template<class TScalar , int kMatrixDim, int kM, class TScalarOrVector , class TFn >
auto vectorFieldNumDiff (TFn vector_field, TScalarOrVector const &a, TScalar eps=kEpsilonSqrt< TScalar >) -> Eigen::Matrix< TScalar, kMatrixDim, kM >
 Calculates the derivative of a vector field at a point a. More...
 
template<class TT >
auto operator== (Region< TT > const &lhs, Region< TT > const &rhs) -> bool
 
template<class TScalar , std::size_t = sizeof(TScalar)>
constexpr std::true_type complete (TScalar *)
 
constexpr std::false_type complete (...)
 
 SOPHUS_ENUM (NumberType,(fixed_point, floating_point))
 
auto fitPlaneToPoints (Eigen::Matrix3Xd const &points) -> Eigen::Hyperplane< double, 3 >
 
auto fitPlaneToPoints (std::vector< Eigen::Vector3d > const &points) -> Eigen::Hyperplane< double, 3 >
 
auto fitPlaneToPoints (std::vector< Eigen::Vector3f > const &points) -> Eigen::Hyperplane< double, 3 >
 
template<class TScalar >
auto normalFromRotation2 (Rotation2< TScalar > const &foo_rotation_line) -> Eigen::Vector2< TScalar >
 Takes in a rotation foo_rotation_plane and returns the corresponding line normal along the y-axis (in reference frame foo). More...
 
template<class TScalar >
auto rotation2FromNormal (Eigen::Vector2< TScalar > normal_in_foo) -> Rotation2< TScalar >
 Takes in line normal in reference frame foo and constructs a corresponding rotation matrix foo_rotation_line. More...
 
template<class TScalar >
auto normalFromRotation3 (Rotation3< TScalar > const &foo_rotation_plane) -> Eigen::Vector3< TScalar >
 Takes in a rotation foo_rotation_plane and returns the corresponding plane normal along the z-axis (in reference frame foo). More...
 
template<class TScalar >
auto rotation3FromNormal (Eigen::Vector3< TScalar > const &normal_in_foo, Eigen::Vector3< TScalar > x_dir_hint_foo=Eigen::Vector3< TScalar >(TScalar(1), TScalar(0), TScalar(0)), Eigen::Vector3< TScalar > y_dir_hint_foo=Eigen::Vector3< TScalar >(TScalar(0), TScalar(1), TScalar(0))) -> Eigen::Matrix3< TScalar >
 Takes in plane normal in reference frame foo and constructs a corresponding rotation matrix foo_rotation_plane. More...
 
template<class TScalar >
auto rotation3FromPlane (Eigen::Vector3< TScalar > const &normal_in_foo) -> Rotation3< TScalar >
 Takes in plane normal in reference frame foo and constructs a corresponding rotation matrix foo_rotation_plane. More...
 
template<class TScalar >
auto lineFromIsometry (Isometry2< TScalar > const &foo_from_line) -> Eigen::Hyperplane< TScalar, 2 >
 Returns a line (wrt. to frame foo), given a pose of the line in reference frame foo. More...
 
template<class TScalar >
auto isometryFromLine (Eigen::Hyperplane< TScalar, 2 > const &line_in_foo) -> Isometry2< TScalar >
 Returns the pose T_foo_line, given a line in reference frame foo. More...
 
template<class TScalar >
auto planeFromIsometry (Isometry3< TScalar > const &foo_from_plane) -> Eigen::Hyperplane< TScalar, 3 >
 Returns a plane (wrt. to frame foo), given a pose of the plane in reference frame foo. More...
 
template<class TScalar >
auto isometryFromPlane (Eigen::Hyperplane< TScalar, 3 > const &plane_in_foo) -> Isometry3< TScalar >
 Returns the pose foo_from_plane, given a plane in reference frame foo. More...
 
template<class TScalar , int kMatrixDim>
auto makeHyperplaneUnique (Eigen::Hyperplane< TScalar, kMatrixDim > const &plane) -> Eigen::Hyperplane< TScalar, kMatrixDim >
 Takes in a hyperplane and returns unique representation by ensuring that the offset is not negative. More...
 
template<class TT >
auto proj (InverseDepthPoint3< TT > const &inverse_depth_point) -> Eigen::Matrix< TT, 2, 1 >
 Projects 3-point (a,b,psi) = (x/z,y/z,1/z) through the origin (0,0,0) onto the plane z=1. Hence it returns (a,b) = (x/z, y/z). More...
 
template<class TT >
auto dxProjX (InverseDepthPoint3< TT > const &) -> Eigen::Matrix< TT, 2, 3 >
 Returns point derivative of inverse depth point projection: More...
 
template<class TT >
auto dxProjExpXPointAt0 (InverseDepthPoint3< TT > const &inverse_depth_point) -> Eigen::Matrix< TT, 2, 6 >
 Returns pose derivative of inverse depth point projection at the identity: More...
 
template<class TT >
auto scaledTransform (sophus::Isometry3< TT > const &foo_from_bar, InverseDepthPoint3< TT > const &inverse_depth_point_in_bar) -> Eigen::Matrix< TT, 3, 1 >
 Transforms inverse_depth point in frame bar to a scaled inverse depth point in frame foo. Here the scale is psi, the input inverse depth. More...
 
template<class TT >
auto projTransform (sophus::Isometry3< TT > const &foo_from_bar, InverseDepthPoint3< TT > const &inverse_depth_point_in_bar) -> Eigen::Matrix< TT, 2, 1 >
 Transforms inverse_depth point from frame bar to frame foo followed by a projection. More...
 
template<class TT >
auto operator* (Isometry2< TT > const &bar_from_foo, Ray< TT, 2 > const &ray_foo) -> Ray< TT, 2 >
 
template<class TT >
auto operator* (Isometry3< TT > const &bar_from_foo, Ray< TT, 3 > const &ray_foo) -> Ray< TT, 3 >
 
template<class TT >
auto operator* (Isometry3< TT > const &bar_from_foo, UnitVector< TT, 3 > const &v_foo) -> Ray< TT, 3 >
 
template<class TT >
auto operator* (Similarity2< TT > const &b_from_a, Ray2< TT > const &ray_a) -> Ray2< TT >
 
template<class TT >
auto operator* (Similarity3< TT > const &b_from_a, Ray3< TT > const &ray_a) -> Ray3< TT >
 
template<class TT >
auto closestApproachParameters (Ray3< TT > const &line_0, Ray3< TT > const &line_1) -> std::optional< ClosestApproachResult< TT >>
 For two parametric lines in lambda0 and lambda1 respectively,. More...
 
template<class TT >
auto closestApproach (Ray3< TT > const &line_0, Ray3< TT > const &line_1) -> std::optional< Eigen::Vector3< TT >>
 For two lines line_0 and line_1 returns the mid-point of the line segment connecting one point from each of the lines which are closest to one another according to the l2 distance measure. More...
 
template<typename TUserFunc , class TPredicate = IntensityImagePredicate, class TAllocator = Eigen::aligned_allocator<uint8_t>>
void visitImage (TUserFunc &&func, DynImage< TPredicate, TAllocator > const &image)
 
template<class TUserFunc , class TPredicate = IntensityImagePredicate>
void visitImage (TUserFunc &&func, DynImageView< TPredicate > const &image)
 
auto half (ImageSize size) -> ImageSize
 If the original width [height] is odd, the new width [height] will be: (width+1)/2 [height+1)/2]. More...
 
auto operator== (ImageSize const &lhs, ImageSize const &rhs) -> bool
 Equality operator. More...
 
auto operator!= (ImageSize const &lhs, ImageSize const &rhs) -> bool
 
auto operator< (ImageSize const &lhs, ImageSize const &rhs) -> bool
 Ordering operator, for keys in sets and maps. More...
 
auto operator<< (std::ostream &os, ImageSize const &image_size) -> std::ostream &
 Ostream operator. More...
 
template<class TPixel >
auto imageCoordsInterval (ImageSize image_size, int border=0) -> Region2I
 
auto count (ImageViewBool mask, bool truth_value) -> int
 Returns number of pixels equal truth_value in mask. More...
 
auto countTrue (ImageViewBool mask) -> int
 Returns number of true pixels in mask. More...
 
auto countFalse (ImageViewBool mask) -> int
 Returns number of false pixels in mask. More...
 
auto isAllTrue (ImageViewBool mask) -> bool
 Returns true if all pixels are true. More...
 
auto isAnyTrue (ImageViewBool mask) -> bool
 Returns true if at least one pixel is true. More...
 
auto neg (ImageViewBool mask) -> MutImageBool
 Returns boolean image with the result per pixel: More...
 
auto firstPixel (ImageViewBool mask, bool truth_value) -> std::optional< Eigen::Vector2i >
 Returns first pixel of mask which equals truth_value, nullopt otherwise. More...
 
auto firstTruePixel (ImageViewBool mask) -> std::optional< Eigen::Vector2i >
 Returns first true pixel, nullopt otherwise. More...
 
auto firstFalsePixel (ImageViewBool mask) -> std::optional< Eigen::Vector2i >
 Returns first false pixel, nullopt otherwise. More...
 
template<class TPixel >
auto isEqualMask (ImageView< TPixel > lhs, ImageView< TPixel > rhs) -> MutImageBool
 Returns boolean image with the result per pixel: More...
 
template<class TPixel >
auto isLessMask (ImageView< TPixel > lhs, ImageView< TPixel > rhs) -> MutImageBool
 Returns boolean image with the result per pixel: More...
 
template<class TPixel >
auto isGreaterMask (ImageView< TPixel > lhs, ImageView< TPixel > rhs) -> MutImageBool
 Returns boolean image with the result per pixel: More...
 
template<class TPixel >
auto isNearMask (ImageView< TPixel > lhs, ImageView< TPixel > rhs, typename ImageTraits< TPixel >::ChannelT thr) -> MutImageBool
 Returns boolean image with the result per pixel: More...
 
template<class TT >
auto interpolate (sophus::ImageView< TT > const &image, Eigen::Vector2f uv) -> TT
 
auto operator== (ImageLayout const &lhs, ImageLayout const &rhs) -> bool
 Equality operator. More...
 
auto operator!= (ImageLayout const &lhs, ImageLayout const &rhs) -> bool
 
auto operator<< (std::ostream &os, ImageLayout const &layout) -> std::ostream &
 Ostream operator. More...
 
auto operator== (PixelFormat const &lhs, PixelFormat const &rhs) -> bool
 
auto operator<< (std::ostream &os, PixelFormat const &type) -> std::ostream &
 Example: PixelFormat::fromTemplate<float>() outputs: "1F32"; PixelFormat::fromTemplate<Eigen::Matrix<uint8_t,4,1>>() outputs: "4U8";. More...
 
 SOPHUS_ENUM (ManifoldPlusType,(left_plus, right_plus))
 
template<concepts::Range TSequenceContainer>
auto iterativeMean (TSequenceContainer const &foo_from_bar_transforms, int max_num_iterations) -> std::optional< typename TSequenceContainer::value_type >
 Calculates mean iteratively. More...
 
template<concepts::Range TSequenceContainer, int kPointDim = TSequenceContainer::value_type::kDof, class TScalar = typename TSequenceContainer::value_type::Scalar>
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 > >
 
template<concepts::Range TSequenceContainer, class TScalar = typename TSequenceContainer::value_type::Scalar>
auto average (TSequenceContainer const &foo_from_bar_transforms) -> std::enable_if_t< std::is_same< typename TSequenceContainer::value_type, Rotation2< TScalar > >::value, std::optional< typename TSequenceContainer::value_type > >
 
template<concepts::Range TSequenceContainer, class TScalar = typename TSequenceContainer::value_type::Scalar>
auto average (TSequenceContainer const &foo_from_bar_transforms, int max_num_iterations=20) -> std::enable_if_t< std::is_same< typename TSequenceContainer::value_type, Isometry2< TScalar > >::value, std::optional< typename TSequenceContainer::value_type > >
 
template<concepts::Range TSequenceContainer, int kPointDim = TSequenceContainer::value_type::kPointDim, class TScalar = typename TSequenceContainer::value_type::Scalar>
auto average (TSequenceContainer const &foo_from_bar_transforms, int max_num_iterations=20) -> std::enable_if_t< std::is_same< typename TSequenceContainer::value_type, ScalingTranslation< TScalar, kPointDim > >::value, std::optional< typename TSequenceContainer::value_type > >
 
template<concepts::LieGroup TGroup, concepts::ConvertibleTo< typename TGroup::Scalar > TScalar>
auto interpolate (TGroup const &foo_from_bar, TGroup const &foo_from_daz, TScalar p=TScalar(0.5f)) -> TGroup
 This function interpolates between two Lie group elements foo_from_bar and foo_from_daz with an interpolation factor of alpha in [0, 1]. More...
 
template<class TScalar >
auto rotThroughPoints (UnitVector3< TScalar > const &from, UnitVector3< TScalar > const &to) -> Rotation3< TScalar >
 Construct rotation which would take unit direction vector from into to such that to = rotThroughPoints(from,to) * from. I.e. that the rotated point from is colinear with to (equal up to scale) More...
 
template<class TScalar >
auto rotThroughPoints (Eigen::Vector< TScalar, 3 > const &from, Eigen::Vector< TScalar, 3 > const &to) -> Rotation3< TScalar >
 Construct rotation which would take direction vector from into to such that to \propto rotThroughPoints(from,to) * from. I.e. that the rotated point from is colinear with to (equal up to scale) More...
 
template<class TTo , class TT >
auto cast (const TT &p)
 
template<class TPoint >
auto proj (Eigen::MatrixBase< TPoint > const &p) -> Eigen::Vector< typename TPoint::Scalar, TPoint::RowsAtCompileTime - 1 >
 Projects 3-point (x,y,z) through the origin (0,0,0) onto the plane z=1. Hence it returns (x/z, y/z). More...
 
template<class TPoint >
auto unproj (Eigen::MatrixBase< TPoint > const &p, const typename TPoint::Scalar &z=1.0) -> Eigen::Vector< typename TPoint::Scalar, TPoint::RowsAtCompileTime+1 >
 Maps point on the z=1 plane (a,b) to homogeneous representation of the same point: (z*a, z*b, z). Z defaults to 1. More...
 
template<class TD >
auto isOrthogonal (Eigen::MatrixBase< TD > const &r) -> bool
 Takes in arbitrary square matrix and returns true if it is orthogonal. More...
 
template<class TD >
auto isScaledOrthogonalAndPositive (Eigen::MatrixBase< TD > const &s_r) -> bool
 Takes in arbitrary square matrix and returns true if it is "scaled-orthogonal" with positive determinant. More...
 
template<class TD >
auto makeRotationMatrix (Eigen::MatrixBase< TD > const &r) -> std::enable_if_t< std::is_floating_point< typename TD::Scalar >::value, Eigen::Matrix< typename TD::Scalar, TD::RowsAtCompileTime, TD::RowsAtCompileTime >>
 Takes in arbitrary square matrix (2x2 or larger) and returns closest orthogonal matrix with positive determinant. More...
 
template<::sophus::concepts::ScalarType TPoint>
auto zero () -> TPoint
 
template<::sophus::concepts::ScalarType TPoint>
auto eval (TPoint const &p)
 
template<::sophus::concepts::ScalarType TPoint>
auto allTrue (TPoint const &p) -> bool
 
template<::sophus::concepts::ScalarType TPoint>
auto anyTrue (TPoint const &p) -> bool
 
template<::sophus::concepts::ScalarType TPoint>
auto isFinite (TPoint const &p) -> bool
 
template<::sophus::concepts::ScalarType TPoint>
auto isNan (TPoint const &p) -> bool
 
template<::sophus::concepts::ScalarType TPoint>
auto square (TPoint const &v)
 
template<::sophus::concepts::ScalarType TPoint>
auto min (TPoint const &a, TPoint const &b) -> TPoint
 
template<::sophus::concepts::ScalarType TPoint>
auto max (TPoint const &a, TPoint const &b) -> TPoint
 
template<::sophus::concepts::PointType TPoint>
auto clamp (TPoint const &val, TPoint const &lo, TPoint const &hi) -> TPoint
 
template<::sophus::concepts::ScalarType TPoint>
auto floor (TPoint s)
 
template<::sophus::concepts::ScalarType TPoint>
auto ceil (TPoint s)
 
template<::sophus::concepts::ScalarType TPoint>
auto round (TPoint s)
 
template<::sophus::concepts::ScalarType TPoint>
auto plus (TPoint p, TPoint s)
 
template<::sophus::concepts::EigenDenseType TPoint>
auto plus (TPoint p, typename TPoint::Scalar s)
 
template<::sophus::concepts::ScalarType TPoint>
auto isLessEqual (TPoint const &lhs, TPoint const &rhs) -> bool
 
template<::sophus::concepts::ScalarType TPoint>
auto tryGetElem (TPoint const &p, size_t row, size_t col=0) -> Expected< TPoint >
 
template<::sophus::concepts::ScalarType TPoint>
auto trySetElem (TPoint &p, TPoint s, size_t row, size_t col=0) -> Expected< Success >
 
template<::sophus::concepts::EigenDenseType TPoint>
auto trySetElem (TPoint &p, typename TPoint::Scalar s, size_t row, size_t col=0) -> Expected< Success >
 
template<::sophus::concepts::ScalarType TPoint>
auto transpose (TPoint p)
 
template<class TScalar , int kDim>
auto pointExamples ()
 
template<int... Ds>
constexpr std::array< int, sizeof...(Ds)> cumulativeSum ()
 
auto createDefaultPinholeModel (ImageSize image_size) -> PinholeModel
 Creates default pinhole model from image_size. More...
 
auto createDefaultOrthoModel (ImageSize image_size) -> OrthographicModel
 Creates default orthographic model from image_size. More...
 
template<class TScalar >
auto subsampleDown (Eigen::Matrix< TScalar, 2, 1 > const &in) -> Eigen::Matrix< TScalar, 2, 1 >
 Subsamples pixel down, factor of 0.5. More...
 
template<class TScalar >
auto subsampleUp (Eigen::Matrix< TScalar, 2, 1 > const &in) -> Eigen::Matrix< TScalar, 2, 1 >
 Subsamples pixel up, factor of 2.0. More...
 
template<class TScalar >
auto binDown (Eigen::Matrix< TScalar, 2, 1 > const &in) -> Eigen::Matrix< TScalar, 2, 1 >
 Bins pixel down, factor of 0.5. More...
 
template<class TScalar >
auto binUp (Eigen::Matrix< TScalar, 2, 1 > const &in) -> Eigen::Matrix< TScalar, 2, 1 >
 Bins pixel up, factor of 2.0. More...
 
 SOPHUS_ENUM (CameraDistortionType,(pinhole, brown_conrady, kannala_brandt_k3, orthographic))
 Camera model projection type. More...
 
auto getModelFromType (GyroModelType model_type, Eigen::VectorXd const &params) -> GyroModelVariant
 
auto getModelFromType (AcceleroModelType model_type, Eigen::VectorXd const &params) -> AcceleroModelVariant
 
template<class TT >
auto nonOrthogonalityMatrix (Eigen::Matrix< TT, 3, 1 > const &non_orthogonality) -> Eigen::Matrix< TT, 3, 3 >
 
 SOPHUS_ENUM (GyroModelType,(scaling_non_orthogonality))
 
 SOPHUS_ENUM (AcceleroModelType,(scaling_non_orthogonality))
 
template<class TScalar >
auto orthoCamFromBoundingBox (Region2< TScalar > const &bounding_box, ImageSize image_size) -> OrthographicModelT< TScalar >
 Returns orthographic camera model given bounding box and image size. More...
 
template<class TScalar >
auto boundingBoxFromOrthoCam (OrthographicModelT< TScalar > const &ortho_cam) -> Region2< TScalar >
 Returns 2d bounding box corresponding the the given orthographic camera model. More...
 

Variables

template<class TScalar >
constexpr bool kIsMappableV = IsMappable<TScalar>::value
 
template<class TScalar >
const TScalar kEpsilon = TScalar(1e-10)
 
template<>
const float kEpsilon< float > = float(1e-5)
 
template<class TScalar >
const TScalar kEpsilonPlus
 
template<class TScalar >
const TScalar kEpsilonSqrt = TScalar(1e-5)
 
template<>
const float kEpsilonSqrt< float > = float(3.16227766e-3)
 
template<class TScalar >
const TScalar kPi = TScalar(3.141592653589793238462643383279502884)
 
const float kPiF32 = kPi<float>
 
const double kPiF64 = kPi<double>
 
template<class TGenerator >
constexpr bool kIsUniformRandomBitGeneratorV
 

Detailed Description

Image MutImage, owning images types.

ImageView and MutImageView, non owning images types.

Note that it is a conscious API decision to follow "shallow-compare" type semantic for ImageView, MutImageView, Image and MutImage. See image_view.h for details.

See image.h for Image and MutImage, owning images types.

Note that it is a conscious API decision to follow "shallow-compare" type semantic for ImageView, MutImageView, Image and MutImage. Similar "shallow-compare" types are: std::span (shallow-compare reference type), and std::unique_ptr (shallow compare unique ownership type). This is in contrast to regular types such as std::vector, std::string and reference types which mimic regular type semantic such as std::string_view. Also see https://abseil.io/blog/20180531-regular-types.

Typedef Documentation

◆ AcceleroModelVariant

using sophus::AcceleroModelVariant = typedef std::variant<ScalingNonOrthogonalityAcceleroModel<double> >

◆ AnyImage

template<class TAllocator = Eigen::aligned_allocator<uint8_t>>
using sophus::AnyImage = typedef DynImage<AnyImagePredicate, TAllocator>

Image representing any number of channels (>=1) and any floating and unsigned integral channel type.

◆ AnyImageView

using sophus::AnyImageView = typedef DynImageView<AnyImagePredicate>

◆ BrownConradyModel

using sophus::BrownConradyModel = typedef CameraModelT<double, BrownConradyTransform, ProjectionZ1>

Brown Conrady camera model.

◆ CameraDistortionVariant

using sophus::CameraDistortionVariant = typedef std::variant< PinholeModel, BrownConradyModel, KannalaBrandtK3Model, OrthographicModel>

Variant of camera models.

◆ GyroModelVariant

using sophus::GyroModelVariant = typedef std::variant<ScalingNonOrthogonalityGyroModel<double> >

◆ Identity2

template<class TScalar >
using sophus::Identity2 = typedef Identity<TScalar, 2>

◆ Identity3

template<class TScalar >
using sophus::Identity3 = typedef Identity<TScalar, 3>

◆ Image3

template<class TChannel >
using sophus::Image3 = typedef Image<Pixel3<TChannel> >

◆ Image3F32

using sophus::Image3F32 = typedef Image3<float>

◆ Image3U16

using sophus::Image3U16 = typedef Image3<uint16_t>

◆ Image3U8

using sophus::Image3U8 = typedef Image3<uint8_t>

◆ Image4

template<class TChannel >
using sophus::Image4 = typedef Image<Pixel4<TChannel> >

◆ Image4F32

using sophus::Image4F32 = typedef Image4<float>

◆ Image4U16

using sophus::Image4U16 = typedef Image4<uint16_t>

◆ Image4U8

using sophus::Image4U8 = typedef Image4<uint8_t>

◆ ImageBool

using sophus::ImageBool = typedef Image<bool>

◆ ImageF32

using sophus::ImageF32 = typedef Image<float>

◆ ImageU16

using sophus::ImageU16 = typedef Image<uint16_t>

◆ ImageU8

using sophus::ImageU8 = typedef Image<uint8_t>

◆ ImageView3

template<class TChannel >
using sophus::ImageView3 = typedef ImageView<Pixel3<TChannel> >

◆ ImageView3F32

using sophus::ImageView3F32 = typedef ImageView3<float>

◆ ImageView3U16

using sophus::ImageView3U16 = typedef ImageView3<uint16_t>

◆ ImageView3U8

using sophus::ImageView3U8 = typedef ImageView3<uint8_t>

◆ ImageView4

template<class TChannel >
using sophus::ImageView4 = typedef ImageView<Pixel4<TChannel> >

◆ ImageView4F32

using sophus::ImageView4F32 = typedef ImageView4<float>

◆ ImageView4U16

using sophus::ImageView4U16 = typedef ImageView4<uint16_t>

◆ ImageView4U8

using sophus::ImageView4U8 = typedef ImageView4<uint8_t>

◆ ImageViewBool

using sophus::ImageViewBool = typedef ImageView<bool>

◆ ImageViewF32

using sophus::ImageViewF32 = typedef ImageView<float>

◆ ImageViewU16

using sophus::ImageViewU16 = typedef ImageView<uint16_t>

◆ ImageViewU8

using sophus::ImageViewU8 = typedef ImageView<uint8_t>

◆ IntensityImage

template<class TAllocator = Eigen::aligned_allocator<uint8_t>>
using sophus::IntensityImage = typedef DynImage<IntensityImagePredicate, TAllocator>

Image to represent intensity image / texture as grayscale (=1 channel), RGB (=3 channel ) and RGBA (=4 channel), either uint8_t [0-255], uint16 [0-65535] or float [0.0-1.0] channel type.

◆ IntensityImageView

using sophus::IntensityImageView = typedef DynImageView<IntensityImagePredicate>

◆ InverseDepthPoint3F64

using sophus::InverseDepthPoint3F64 = typedef InverseDepthPoint3<double>

◆ IsMappable

template<class TScalar >
using sophus::IsMappable = typedef IsSpecialized<Eigen::internal::traits<std::decay_t<TScalar> >>

Type trait used to distinguish mappable vector types from scalars.

We use this class to distinguish Eigen::Vector<Scalar, kMatrixDim> from Scalar types in LieGroup<TScalar>::Tangent

Primary use is mapping LieGroup::Tangent over raw data, with 2 options:

  • LieGroup::Tangent is "scalar" (for Rotation2), then we just dereference pointer
  • LieGroup::Tangent is Eigen::Vector<...>, then we need to use Eigen::Map

Specialization of Eigen::internal::traits<TScalar> for TScalar is crucial for for constructing Eigen::Map<TScalar>, thus we use that property for distinguishing between those two options. At this moment there seem to be no option to check this using only "external" API of Eigen

◆ Isometry2F32

using sophus::Isometry2F32 = typedef Isometry2<float>

◆ Isometry2F64

using sophus::Isometry2F64 = typedef Isometry2<double>

◆ Isometry3F32

using sophus::Isometry3F32 = typedef Isometry3<float>

◆ Isometry3F64

using sophus::Isometry3F64 = typedef Isometry3<double>

◆ IsSpecialized

template<class TScalar >
using sophus::IsSpecialized = typedef decltype(complete(std::declval<TScalar*>()))

◆ KannalaBrandtK3Model

using sophus::KannalaBrandtK3Model = typedef CameraModelT<double, KannalaBrandtK3Transform, ProjectionZ1>

KannalaBrandt camera model with k0, k1, k2, k3.

◆ LeftPlus

template<concepts::LieGroup TGroup>
using sophus::LeftPlus = typedef GroupManifold<TGroup, ManifoldPlusType::left_plus>

◆ MutAnyImage

template<class TAllocator = Eigen::aligned_allocator<uint8_t>>
using sophus::MutAnyImage = typedef MutDynImage<AnyImagePredicate, TAllocator>

◆ MutAnyImageView

using sophus::MutAnyImageView = typedef MutDynImageView<AnyImagePredicate>

◆ MutImage3

template<class TChannel >
using sophus::MutImage3 = typedef MutImage<Pixel3<TChannel> >

◆ MutImage3F32

using sophus::MutImage3F32 = typedef MutImage3<float>

◆ MutImage3U16

using sophus::MutImage3U16 = typedef MutImage3<uint16_t>

◆ MutImage3U8

using sophus::MutImage3U8 = typedef MutImage3<uint8_t>

◆ MutImage4

template<class TChannel >
using sophus::MutImage4 = typedef MutImage<Pixel4<TChannel> >

◆ MutImage4F32

using sophus::MutImage4F32 = typedef MutImage4<float>

◆ MutImage4U16

using sophus::MutImage4U16 = typedef MutImage4<uint16_t>

◆ MutImage4U8

using sophus::MutImage4U8 = typedef MutImage4<uint8_t>

◆ MutImageBool

using sophus::MutImageBool = typedef MutImage<bool>

◆ MutImageF32

using sophus::MutImageF32 = typedef MutImage<float>

◆ MutImageU16

using sophus::MutImageU16 = typedef MutImage<uint16_t>

◆ MutImageU8

using sophus::MutImageU8 = typedef MutImage<uint8_t>

◆ MutImageView3

template<class TChannel >
using sophus::MutImageView3 = typedef MutImageView<Pixel3<TChannel> >

◆ MutImageView3F32

using sophus::MutImageView3F32 = typedef MutImageView3<float>

◆ MutImageView3U16

using sophus::MutImageView3U16 = typedef MutImageView3<uint16_t>

◆ MutImageView3U8

using sophus::MutImageView3U8 = typedef MutImageView3<uint8_t>

◆ MutImageView4

template<class TChannel >
using sophus::MutImageView4 = typedef MutImageView<Pixel4<TChannel> >

◆ MutImageView4F32

using sophus::MutImageView4F32 = typedef MutImageView4<float>

◆ MutImageView4U16

using sophus::MutImageView4U16 = typedef MutImageView4<uint16_t>

◆ MutImageView4U8

using sophus::MutImageView4U8 = typedef MutImageView4<uint8_t>

◆ MutImageViewBool

using sophus::MutImageViewBool = typedef MutImageView<bool>

◆ MutImageViewF32

using sophus::MutImageViewF32 = typedef MutImageView<float>

◆ MutImageViewU16

using sophus::MutImageViewU16 = typedef MutImageView<uint16_t>

◆ MutImageViewU8

using sophus::MutImageViewU8 = typedef MutImageView<uint8_t>

◆ MutIntensityImage

template<class TAllocator = Eigen::aligned_allocator<uint8_t>>
using sophus::MutIntensityImage = typedef MutDynImage<IntensityImagePredicate, TAllocator>

◆ MutIntensityImageView

using sophus::MutIntensityImageView = typedef MutDynImageView<IntensityImagePredicate>

◆ OrthographicModel

using sophus::OrthographicModel = typedef CameraModelT<double, AffineTransform, ProjectionOrtho>

◆ OrthographicModelT

template<class TScalar >
using sophus::OrthographicModelT = typedef CameraModelT<TScalar, AffineTransform, ProjectionOrtho>

◆ PinholeModel

using sophus::PinholeModel = typedef CameraModelT<double, AffineTransform, ProjectionZ1>

Pinhole camera model.

◆ Pixel2

template<class TChannel >
using sophus::Pixel2 = typedef Eigen::Matrix<TChannel, 2, 1>

◆ Pixel2F32

using sophus::Pixel2F32 = typedef Pixel2<float>

◆ Pixel2U16

using sophus::Pixel2U16 = typedef Pixel2<uint16_t>

◆ Pixel2U8

using sophus::Pixel2U8 = typedef Pixel2<uint8_t>

◆ Pixel3

template<class TChannel >
using sophus::Pixel3 = typedef Eigen::Matrix<TChannel, 3, 1>

◆ Pixel3F32

using sophus::Pixel3F32 = typedef Pixel3<float>

◆ Pixel3U16

using sophus::Pixel3U16 = typedef Pixel3<uint16_t>

◆ Pixel3U8

using sophus::Pixel3U8 = typedef Pixel3<uint8_t>

◆ Pixel4

template<class TChannel >
using sophus::Pixel4 = typedef Eigen::Matrix<TChannel, 4, 1>

◆ Pixel4F32

using sophus::Pixel4F32 = typedef Pixel4<float>

◆ Pixel4U16

using sophus::Pixel4U16 = typedef Pixel4<uint16_t>

◆ Pixel4U8

using sophus::Pixel4U8 = typedef Pixel4<uint8_t>

◆ Pose3F32

using sophus::Pose3F32 = typedef Pose3<float>

◆ Pose3F64

using sophus::Pose3F64 = typedef Pose3<double>

◆ QuaternionF64

using sophus::QuaternionF64 = typedef Quaternion<double>

◆ Ray2

template<class TScalar >
using sophus::Ray2 = typedef Ray<TScalar, 2>

◆ Ray2F64

using sophus::Ray2F64 = typedef Ray2<double>

◆ Ray3

template<class TScalar >
using sophus::Ray3 = typedef Ray<TScalar, 3>

◆ Ray3F64

using sophus::Ray3F64 = typedef Ray3<double>

◆ Region2

template<concepts::ScalarType TScalar>
using sophus::Region2 = typedef Region<Eigen::Array<TScalar, 2, 1> >

◆ Region2F32

using sophus::Region2F32 = typedef Region2<float>

◆ Region2F64

using sophus::Region2F64 = typedef Region2<double>

◆ Region2I

using sophus::Region2I = typedef Region2<int>

◆ Region3

template<concepts::ScalarType TScalar>
using sophus::Region3 = typedef Region<Eigen::Array<TScalar, 3, 1> >

◆ Region3F32

using sophus::Region3F32 = typedef Region3<float>

◆ Region3F64

using sophus::Region3F64 = typedef Region3<double>

◆ Region3I

using sophus::Region3I = typedef Region3<int>

◆ Region4

template<concepts::ScalarType TScalar>
using sophus::Region4 = typedef Region<Eigen::Array<TScalar, 4, 1> >

◆ Region4F32

using sophus::Region4F32 = typedef Region4<float>

◆ Region4F64

using sophus::Region4F64 = typedef Region4<double>

◆ Region4I

using sophus::Region4I = typedef Region4<int>

◆ RegionF32

using sophus::RegionF32 = typedef Region<float>

◆ RegionF64

using sophus::RegionF64 = typedef Region<double>

◆ RegionI

using sophus::RegionI = typedef Region<int>

◆ RightPlus

template<concepts::LieGroup TGroup>
using sophus::RightPlus = typedef GroupManifold<TGroup, ManifoldPlusType::right_plus>

◆ Rotation2F32

using sophus::Rotation2F32 = typedef Rotation2<float>

◆ Rotation2F64

using sophus::Rotation2F64 = typedef Rotation2<double>

◆ Rotation3F32

using sophus::Rotation3F32 = typedef Rotation3<float>

◆ Rotation3F64

using sophus::Rotation3F64 = typedef Rotation3<double>

◆ Scaling2

template<class TScalar >
using sophus::Scaling2 = typedef Scaling<TScalar, 2>

◆ Scaling3

template<class TScalar >
using sophus::Scaling3 = typedef Scaling<TScalar, 3>

◆ ScalingTranslation2

template<class TScalar >
using sophus::ScalingTranslation2 = typedef ScalingTranslation<TScalar, 2>

◆ ScalingTranslation2F64

using sophus::ScalingTranslation2F64 = typedef ScalingTranslation2<double>

◆ ScalingTranslation3

template<class TScalar >
using sophus::ScalingTranslation3 = typedef ScalingTranslation<TScalar, 3>

◆ ScalingTranslation3F64

using sophus::ScalingTranslation3F64 = typedef ScalingTranslation3<double>

◆ SE3

template<class TScalar >
using sophus::SE3 = typedef Isometry3<TScalar>

◆ SE3d

using sophus::SE3d = typedef Isometry3<double>

◆ SE3f

using sophus::SE3f = typedef Isometry3<float>

◆ Similarity2F32

using sophus::Similarity2F32 = typedef Similarity2<float>

◆ Similarity2F64

using sophus::Similarity2F64 = typedef Similarity2<double>

◆ Similarity3F32

using sophus::Similarity3F32 = typedef Similarity3<float>

◆ Similarity3F64

using sophus::Similarity3F64 = typedef Similarity3<double>

◆ SO3

template<class TScalar >
using sophus::SO3 = typedef Rotation3<TScalar>

◆ SO3d

using sophus::SO3d = typedef Rotation3<double>

◆ SO3f

using sophus::SO3f = typedef Rotation3<float>

◆ SpiralSimilarity2F32

using sophus::SpiralSimilarity2F32 = typedef SpiralSimilarity2<float>

◆ SpiralSimilarity2F64

using sophus::SpiralSimilarity2F64 = typedef SpiralSimilarity2<double>

◆ SpiralSimilarity3F32

using sophus::SpiralSimilarity3F32 = typedef SpiralSimilarity3<float>

◆ SpiralSimilarity3F64

using sophus::SpiralSimilarity3F64 = typedef SpiralSimilarity3<double>

◆ Translation2

template<class TScalar >
using sophus::Translation2 = typedef Translation<TScalar, 2>

◆ Translation2F32

using sophus::Translation2F32 = typedef Translation2<float>

◆ Translation2F64

using sophus::Translation2F64 = typedef Translation2<double>

◆ Translation3

template<class TScalar >
using sophus::Translation3 = typedef Translation<TScalar, 3>

◆ Translation3F32

using sophus::Translation3F32 = typedef Translation3<float>

◆ Translation3F64

using sophus::Translation3F64 = typedef Translation3<double>

◆ UniqueDataArea

template<class TAllocator >
using sophus::UniqueDataArea = typedef std::unique_ptr<uint8_t, MaybeLeakingUniqueDataAreaDeleter<TAllocator> >

◆ UnitVector2

template<class TScalar >
using sophus::UnitVector2 = typedef UnitVector<TScalar, 2>

◆ UnitVector2F64

using sophus::UnitVector2F64 = typedef UnitVector2<double>

◆ UnitVector3

template<class TScalar >
using sophus::UnitVector3 = typedef UnitVector<TScalar, 3>

◆ UnitVector3F64

using sophus::UnitVector3F64 = typedef UnitVector3<double>

Enumeration Type Documentation

◆ SegmentCase

enum sophus::SegmentCase
strong
Enumerator
first 
normal 
last 

Function Documentation

◆ allTrue()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::allTrue ( TPoint const &  p) -> bool

◆ anyTrue()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::anyTrue ( TPoint const &  p) -> bool

◆ average() [1/4]

template<concepts::Range TSequenceContainer, class TScalar = typename TSequenceContainer::value_type::Scalar>
auto sophus::average ( TSequenceContainer const &  foo_from_bar_transforms) -> std::enable_if_t< std::is_same< typename TSequenceContainer::value_type, Rotation2<TScalar> >::value, std::optional<typename TSequenceContainer::value_type> >

◆ average() [2/4]

template<concepts::Range TSequenceContainer, int kPointDim = TSequenceContainer::value_type::kDof, class TScalar = typename TSequenceContainer::value_type::Scalar>
auto sophus::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> >

◆ average() [3/4]

template<concepts::Range TSequenceContainer, class TScalar = typename TSequenceContainer::value_type::Scalar>
auto sophus::average ( TSequenceContainer const &  foo_from_bar_transforms,
int  max_num_iterations = 20 
) -> std::enable_if_t< std::is_same< typename TSequenceContainer::value_type, Isometry2<TScalar> >::value, std::optional<typename TSequenceContainer::value_type> >

◆ average() [4/4]

template<concepts::Range TSequenceContainer, int kPointDim = TSequenceContainer::value_type::kPointDim, class TScalar = typename TSequenceContainer::value_type::Scalar>
auto sophus::average ( TSequenceContainer const &  foo_from_bar_transforms,
int  max_num_iterations = 20 
) -> std::enable_if_t< std::is_same< typename TSequenceContainer::value_type, ScalingTranslation<TScalar, kPointDim> >::value, std::optional<typename TSequenceContainer::value_type> >

◆ binDown()

template<class TScalar >
auto sophus::binDown ( Eigen::Matrix< TScalar, 2, 1 > const &  in) -> Eigen::Matrix<TScalar, 2, 1>

Bins pixel down, factor of 0.5.

See for details: https://docs.google.com/document/d/1xmhCMWklP2UoQMGaMqFnsoPWoeMvBfXN7S8-ie9k0UA/edit#heading=h.elfm6123mecj

◆ binUp()

template<class TScalar >
auto sophus::binUp ( Eigen::Matrix< TScalar, 2, 1 > const &  in) -> Eigen::Matrix<TScalar, 2, 1>

Bins pixel up, factor of 2.0.

See for details: https://docs.google.com/document/d/1xmhCMWklP2UoQMGaMqFnsoPWoeMvBfXN7S8-ie9k0UA/edit#heading=h.elfm6123mecj

◆ boundingBoxFromOrthoCam()

template<class TScalar >
auto sophus::boundingBoxFromOrthoCam ( OrthographicModelT< TScalar > const &  ortho_cam) -> Region2<TScalar>

Returns 2d bounding box corresponding the the given orthographic camera model.

◆ cast()

template<class TTo , class TT >
auto sophus::cast ( const TT &  p)

◆ ceil()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::ceil ( TPoint  s)

◆ clamp()

template<::sophus::concepts::PointType TPoint>
auto sophus::clamp ( TPoint const &  val,
TPoint const &  lo,
TPoint const &  hi 
) -> TPoint

◆ closestApproach()

template<class TT >
auto sophus::closestApproach ( Ray3< TT > const &  line_0,
Ray3< TT > const &  line_1 
) -> std::optional<Eigen::Vector3<TT>>

For two lines line_0 and line_1 returns the mid-point of the line segment connecting one point from each of the lines which are closest to one another according to the l2 distance measure.

If line_0 and line_1 are parallel, returns nullopt as no unique solution exists

◆ closestApproachParameters()

template<class TT >
auto sophus::closestApproachParameters ( Ray3< TT > const &  line_0,
Ray3< TT > const &  line_1 
) -> std::optional<ClosestApproachResult<TT>>

For two parametric lines in lambda0 and lambda1 respectively,.

line_0: x(lambda0) = o0 + lambda0 * d0
line_1: y(lambda1) = o1 + lambda1 * d1

returns distances [lambda0, lambda1] along the respective rays, corresponding to the closest approach of x and y according to an l2 distance measure. lambda0 and lambda1 may be positive or negative. If line_0 and line_1 are parallel, returns nullopt as no unique solution exists

◆ complete() [1/2]

constexpr std::false_type sophus::complete (   ...)
constexpr

◆ complete() [2/2]

template<class TScalar , std::size_t = sizeof(TScalar)>
constexpr std::true_type sophus::complete ( TScalar *  )
constexpr

◆ count()

auto sophus::count ( ImageViewBool  mask,
bool  truth_value 
) -> int

Returns number of pixels equal truth_value in mask.

◆ countFalse()

auto sophus::countFalse ( ImageViewBool  mask) -> int

Returns number of false pixels in mask.

◆ countTrue()

auto sophus::countTrue ( ImageViewBool  mask) -> int

Returns number of true pixels in mask.

◆ createDefaultOrthoModel()

auto sophus::createDefaultOrthoModel ( ImageSize  image_size) -> OrthographicModel

Creates default orthographic model from image_size.

◆ createDefaultPinholeModel()

auto sophus::createDefaultPinholeModel ( ImageSize  image_size) -> PinholeModel

Creates default pinhole model from image_size.

◆ cumulativeSum()

template<int... Ds>
constexpr std::array<int, sizeof...(Ds)> sophus::cumulativeSum ( )
constexpr

◆ curveNumDiff()

template<class TScalar , class TFn >
auto sophus::curveNumDiff ( TFn  curve,
TScalar  t,
TScalar  h = kEpsilonSqrt<TScalar> 
) -> decltype(details::Curve<TScalar>::numDiff(std::move(curve), t, h))

Calculates the derivative of a curve at a point t.

Here, a curve is a function from a Scalar to a Euclidean space. Thus, it returns either a Scalar, a vector or a matrix.

◆ dxProjExpXPointAt0()

template<class TT >
auto sophus::dxProjExpXPointAt0 ( InverseDepthPoint3< TT > const &  inverse_depth_point) -> Eigen::Matrix<TT, 2, 6>

Returns pose derivative of inverse depth point projection at the identity:

Dx proj(exp(x) * y) at x=0

with y = (a,b,psi) being an inverse depth point.

◆ dxProjX()

template<class TT >
auto sophus::dxProjX ( InverseDepthPoint3< TT > const &  ) -> Eigen::Matrix<TT, 2, 3>

Returns point derivative of inverse depth point projection:

Dx proj(x) with x = (a,b,psi) being an inverse depth point.

◆ eval()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::eval ( TPoint const &  p)

◆ firstFalsePixel()

auto sophus::firstFalsePixel ( ImageViewBool  mask) -> std::optional< Eigen::Vector2i >

Returns first false pixel, nullopt otherwise.

◆ firstPixel()

auto sophus::firstPixel ( ImageViewBool  mask,
bool  truth_value 
) -> std::optional< Eigen::Vector2i >

Returns first pixel of mask which equals truth_value, nullopt otherwise.

◆ firstTruePixel()

auto sophus::firstTruePixel ( ImageViewBool  mask) -> std::optional< Eigen::Vector2i >

Returns first true pixel, nullopt otherwise.

◆ fitPlaneToPoints() [1/3]

auto sophus::fitPlaneToPoints ( Eigen::Matrix3Xd const &  points) -> Eigen::Hyperplane<double, 3>
inline

◆ fitPlaneToPoints() [2/3]

auto sophus::fitPlaneToPoints ( std::vector< Eigen::Vector3d > const &  points) -> Eigen::Hyperplane<double, 3>

◆ fitPlaneToPoints() [3/3]

auto sophus::fitPlaneToPoints ( std::vector< Eigen::Vector3f > const &  points) -> Eigen::Hyperplane<double, 3>

◆ floor()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::floor ( TPoint  s)

◆ getModelFromType() [1/2]

auto sophus::getModelFromType ( AcceleroModelType  model_type,
Eigen::VectorXd const &  params 
) -> AcceleroModelVariant

◆ getModelFromType() [2/2]

auto sophus::getModelFromType ( GyroModelType  model_type,
Eigen::VectorXd const &  params 
) -> GyroModelVariant

◆ half()

auto sophus::half ( ImageSize  image_size) -> ImageSize

If the original width [height] is odd, the new width [height] will be: (width+1)/2 [height+1)/2].

◆ imageCoordsInterval()

template<class TPixel >
auto sophus::imageCoordsInterval ( ImageSize  image_size,
int  border = 0 
) -> Region2I
inline

◆ interpolate() [1/2]

template<class TT >
auto sophus::interpolate ( sophus::ImageView< TT > const &  image,
Eigen::Vector2f  uv 
) -> TT

◆ interpolate() [2/2]

template<concepts::LieGroup TGroup, concepts::ConvertibleTo< typename TGroup::Scalar > TScalar>
auto sophus::interpolate ( TGroup const &  foo_from_bar,
TGroup const &  foo_from_daz,
TScalar  p = TScalar(0.5f) 
) -> TGroup

This function interpolates between two Lie group elements foo_from_bar and foo_from_daz with an interpolation factor of alpha in [0, 1].

It returns a pose foo_T_quiz with quiz being a frame between bar and baz. If alpha=0 it returns foo_from_bar. If it is 1, it returns foo_from_daz.

(Since interpolation on Lie groups is inverse-invariant, we can equivalently think of the input arguments as being bar_from_foo, baz_from_foo and the return value being quiz_T_foo.)

Precondition: p must be in [0, 1].

◆ isAllTrue()

auto sophus::isAllTrue ( ImageViewBool  mask) -> bool

Returns true if all pixels are true.

◆ isAnyTrue()

auto sophus::isAnyTrue ( ImageViewBool  mask) -> bool

Returns true if at least one pixel is true.

◆ isEqualMask()

template<class TPixel >
auto sophus::isEqualMask ( ImageView< TPixel >  lhs,
ImageView< TPixel >  rhs 
) -> MutImageBool

Returns boolean image with the result per pixel:

mask(..) = lhs(..) == rhs (..)

◆ isFinite()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::isFinite ( TPoint const &  p) -> bool

◆ isGreaterMask()

template<class TPixel >
auto sophus::isGreaterMask ( ImageView< TPixel >  lhs,
ImageView< TPixel >  rhs 
) -> MutImageBool

Returns boolean image with the result per pixel:

mask(..) = lhs(..) > rhs (..)

◆ isLessEqual()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::isLessEqual ( TPoint const &  lhs,
TPoint const &  rhs 
) -> bool

◆ isLessMask()

template<class TPixel >
auto sophus::isLessMask ( ImageView< TPixel >  lhs,
ImageView< TPixel >  rhs 
) -> MutImageBool

Returns boolean image with the result per pixel:

mask(..) = lhs(..) < rhs (..)

◆ isNan()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::isNan ( TPoint const &  p) -> bool

◆ isNearMask()

template<class TPixel >
auto sophus::isNearMask ( ImageView< TPixel >  lhs,
ImageView< TPixel >  rhs,
typename ImageTraits< TPixel >::ChannelT  thr 
) -> MutImageBool

Returns boolean image with the result per pixel:

mask(..) = ||lhs(..), rhs (..)|| <= thr

◆ isometryFromLine()

template<class TScalar >
auto sophus::isometryFromLine ( Eigen::Hyperplane< TScalar, 2 > const &  line_in_foo) -> Isometry2<TScalar>

Returns the pose T_foo_line, given a line in reference frame foo.

Note: The line is defined by X-axis of the frame line.

◆ isometryFromPlane()

template<class TScalar >
auto sophus::isometryFromPlane ( Eigen::Hyperplane< TScalar, 3 > const &  plane_in_foo) -> Isometry3<TScalar>

Returns the pose foo_from_plane, given a plane in reference frame foo.

Note: The plane is defined by XY-plane of the frame plane.

◆ isOrthogonal()

template<class TD >
auto sophus::isOrthogonal ( Eigen::MatrixBase< TD > const &  r) -> bool

Takes in arbitrary square matrix and returns true if it is orthogonal.

◆ isScaledOrthogonalAndPositive()

template<class TD >
auto sophus::isScaledOrthogonalAndPositive ( Eigen::MatrixBase< TD > const &  s_r) -> bool

Takes in arbitrary square matrix and returns true if it is "scaled-orthogonal" with positive determinant.

◆ iterativeMean()

template<concepts::Range TSequenceContainer>
auto sophus::iterativeMean ( TSequenceContainer const &  foo_from_bar_transforms,
int  max_num_iterations 
) -> std::optional<typename TSequenceContainer::value_type>

Calculates mean iteratively.

Returns nullopt if it does not converge.

◆ lineFromIsometry()

template<class TScalar >
auto sophus::lineFromIsometry ( Isometry2< TScalar > const &  foo_from_line) -> Eigen::Hyperplane<TScalar, 2>

Returns a line (wrt. to frame foo), given a pose of the line in reference frame foo.

Note: The plane is defined by X-axis of the line frame.

◆ makeHyperplaneUnique()

template<class TScalar , int kMatrixDim>
auto sophus::makeHyperplaneUnique ( Eigen::Hyperplane< TScalar, kMatrixDim > const &  plane) -> Eigen::Hyperplane<TScalar, kMatrixDim>

Takes in a hyperplane and returns unique representation by ensuring that the offset is not negative.

◆ makeRotationMatrix()

template<class TD >
auto sophus::makeRotationMatrix ( Eigen::MatrixBase< TD > const &  r) -> std::enable_if_t< std::is_floating_point<typename TD::Scalar>::value, Eigen::Matrix< typename TD::Scalar, TD::RowsAtCompileTime, TD::RowsAtCompileTime>>

Takes in arbitrary square matrix (2x2 or larger) and returns closest orthogonal matrix with positive determinant.

◆ max()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::max ( TPoint const &  a,
TPoint const &  b 
) -> TPoint

◆ min()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::min ( TPoint const &  a,
TPoint const &  b 
) -> TPoint

◆ neg()

auto sophus::neg ( ImageViewBool  mask) -> MutImageBool

Returns boolean image with the result per pixel:

out_mask(..) = !mask(..)

◆ nonOrthogonalityMatrix()

template<class TT >
auto sophus::nonOrthogonalityMatrix ( Eigen::Matrix< TT, 3, 1 > const &  non_orthogonality) -> Eigen::Matrix<TT, 3, 3>

◆ normalFromRotation2()

template<class TScalar >
auto sophus::normalFromRotation2 ( Rotation2< TScalar > const &  foo_rotation_line) -> Eigen::Vector2<TScalar>

Takes in a rotation foo_rotation_plane and returns the corresponding line normal along the y-axis (in reference frame foo).

◆ normalFromRotation3()

template<class TScalar >
auto sophus::normalFromRotation3 ( Rotation3< TScalar > const &  foo_rotation_plane) -> Eigen::Vector3<TScalar>

Takes in a rotation foo_rotation_plane and returns the corresponding plane normal along the z-axis (in reference frame foo).

◆ operator!=() [1/2]

auto sophus::operator!= ( ImageLayout const &  lhs,
ImageLayout const &  rhs 
) -> bool

◆ operator!=() [2/2]

auto sophus::operator!= ( ImageSize const &  lhs,
ImageSize const &  rhs 
) -> bool

◆ operator*() [1/5]

template<class TT >
auto sophus::operator* ( Isometry2< TT > const &  bar_from_foo,
Ray< TT, 2 > const &  ray_foo 
) -> Ray<TT, 2>
inline

◆ operator*() [2/5]

template<class TT >
auto sophus::operator* ( Isometry3< TT > const &  bar_from_foo,
Ray< TT, 3 > const &  ray_foo 
) -> Ray<TT, 3>
inline

◆ operator*() [3/5]

template<class TT >
auto sophus::operator* ( Isometry3< TT > const &  bar_from_foo,
UnitVector< TT, 3 > const &  v_foo 
) -> Ray<TT, 3>
inline

◆ operator*() [4/5]

template<class TT >
auto sophus::operator* ( Similarity2< TT > const &  b_from_a,
Ray2< TT > const &  ray_a 
) -> Ray2<TT>

◆ operator*() [5/5]

template<class TT >
auto sophus::operator* ( Similarity3< TT > const &  b_from_a,
Ray3< TT > const &  ray_a 
) -> Ray3<TT>

◆ operator<()

auto sophus::operator< ( ImageSize const &  lhs,
ImageSize const &  rhs 
) -> bool

Ordering operator, for keys in sets and maps.

◆ operator<<() [1/3]

auto sophus::operator<< ( std::ostream &  os,
ImageLayout const &  layout 
) -> std::ostream &

Ostream operator.

◆ operator<<() [2/3]

auto sophus::operator<< ( std::ostream &  os,
ImageSize const &  image_size 
) -> std::ostream &

Ostream operator.

◆ operator<<() [3/3]

auto sophus::operator<< ( std::ostream &  os,
PixelFormat const &  type 
) -> std::ostream &

Example: PixelFormat::fromTemplate<float>() outputs: "1F32"; PixelFormat::fromTemplate<Eigen::Matrix<uint8_t,4,1>>() outputs: "4U8";.

◆ operator==() [1/4]

auto sophus::operator== ( ImageLayout const &  lhs,
ImageLayout const &  rhs 
) -> bool

Equality operator.

◆ operator==() [2/4]

auto sophus::operator== ( ImageSize const &  lhs,
ImageSize const &  rhs 
) -> bool

Equality operator.

◆ operator==() [3/4]

auto sophus::operator== ( PixelFormat const &  lhs,
PixelFormat const &  rhs 
) -> bool

◆ operator==() [4/4]

template<class TT >
auto sophus::operator== ( Region< TT > const &  lhs,
Region< TT > const &  rhs 
) -> bool

◆ orthoCamFromBoundingBox()

template<class TScalar >
auto sophus::orthoCamFromBoundingBox ( Region2< TScalar > const &  bounding_box,
ImageSize  image_size 
) -> OrthographicModelT<TScalar>

Returns orthographic camera model given bounding box and image size.

◆ planeFromIsometry()

template<class TScalar >
auto sophus::planeFromIsometry ( Isometry3< TScalar > const &  foo_from_plane) -> Eigen::Hyperplane<TScalar, 3>

Returns a plane (wrt. to frame foo), given a pose of the plane in reference frame foo.

Note: The plane is defined by XY-plane of the frame plane.

◆ plus() [1/2]

template<::sophus::concepts::ScalarType TPoint>
auto sophus::plus ( TPoint  p,
TPoint  s 
)

◆ plus() [2/2]

template<::sophus::concepts::EigenDenseType TPoint>
auto sophus::plus ( TPoint  p,
typename TPoint::Scalar  s 
)

◆ pointExamples()

template<class TScalar , int kDim>
auto sophus::pointExamples ( )

◆ proj() [1/2]

template<class TPoint >
auto sophus::proj ( Eigen::MatrixBase< TPoint > const &  p) -> Eigen::Vector<typename TPoint::Scalar, TPoint::RowsAtCompileTime - 1>

Projects 3-point (x,y,z) through the origin (0,0,0) onto the plane z=1. Hence it returns (x/z, y/z).

Precondition: z must not be close to 0.

◆ proj() [2/2]

template<class TT >
auto sophus::proj ( InverseDepthPoint3< TT > const &  inverse_depth_point) -> Eigen::Matrix<TT, 2, 1>

Projects 3-point (a,b,psi) = (x/z,y/z,1/z) through the origin (0,0,0) onto the plane z=1. Hence it returns (a,b) = (x/z, y/z).

◆ projTransform()

template<class TT >
auto sophus::projTransform ( sophus::Isometry3< TT > const &  foo_from_bar,
InverseDepthPoint3< TT > const &  inverse_depth_point_in_bar 
) -> Eigen::Matrix<TT, 2, 1>

Transforms inverse_depth point from frame bar to frame foo followed by a projection.

If psi != 0, hence the point is not at +/- infinity, this function is equivalent to:

camProj(foo_from_bar * inverse_depth_point_in_bar.toEuclideanPoint3());

However, this function can also applied when 1/z==0, hence the point is at +/- infinity.

◆ rotation2FromNormal()

template<class TScalar >
auto sophus::rotation2FromNormal ( Eigen::Vector2< TScalar >  normal_in_foo) -> Rotation2<TScalar>

Takes in line normal in reference frame foo and constructs a corresponding rotation matrix foo_rotation_line.

Precondition: normal_in_foo must not be close to zero.

◆ rotation3FromNormal()

template<class TScalar >
auto sophus::rotation3FromNormal ( Eigen::Vector3< TScalar > const &  normal_in_foo,
Eigen::Vector3< TScalar >  x_dir_hint_foo = Eigen::Vector3<TScalar>(TScalar(1), TScalar(0), TScalar(0)),
Eigen::Vector3< TScalar >  y_dir_hint_foo = Eigen::Vector3<TScalar>(        TScalar(0), TScalar(1), TScalar(0)) 
) -> Eigen::Matrix3<TScalar>

Takes in plane normal in reference frame foo and constructs a corresponding rotation matrix foo_rotation_plane.

Note: The plane frame is defined as such that the normal points along the positive z-axis. One can specify hints for the x-axis and y-axis of the plane frame.

Preconditions:

  • normal_in_foo, xDirHint_foo, yDirHint_foo must not be close to zero.
  • xDirHint_foo and yDirHint_foo must be approx. perpendicular.

◆ rotation3FromPlane()

template<class TScalar >
auto sophus::rotation3FromPlane ( Eigen::Vector3< TScalar > const &  normal_in_foo) -> Rotation3<TScalar>

Takes in plane normal in reference frame foo and constructs a corresponding rotation matrix foo_rotation_plane.

See rotationFromNormal for details.

◆ rotThroughPoints() [1/2]

template<class TScalar >
auto sophus::rotThroughPoints ( Eigen::Vector< TScalar, 3 > const &  from,
Eigen::Vector< TScalar, 3 > const &  to 
) -> Rotation3<TScalar>

Construct rotation which would take direction vector from into to such that to \propto rotThroughPoints(from,to) * from. I.e. that the rotated point from is colinear with to (equal up to scale)

The axis of rotation is perpendicular to both from and to.

Precondition: Neither from nor to must be zero. This is

◆ rotThroughPoints() [2/2]

template<class TScalar >
auto sophus::rotThroughPoints ( UnitVector3< TScalar > const &  from,
UnitVector3< TScalar > const &  to 
) -> Rotation3<TScalar>

Construct rotation which would take unit direction vector from into to such that to = rotThroughPoints(from,to) * from. I.e. that the rotated point from is colinear with to (equal up to scale)

The axis of rotation is perpendicular to both from and to.

◆ round()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::round ( TPoint  s)

◆ scaledTransform()

template<class TT >
auto sophus::scaledTransform ( sophus::Isometry3< TT > const &  foo_from_bar,
InverseDepthPoint3< TT > const &  inverse_depth_point_in_bar 
) -> Eigen::Matrix<TT, 3, 1>

Transforms inverse_depth point in frame bar to a scaled inverse depth point in frame foo. Here the scale is psi, the input inverse depth.

Given (a,b,psi) being the inverse depth point in frame bar, it returns

psi * (foo_from_bar * inverse_depth_point_in_bar.toEuclideanPoint3())

for psi!=0.

◆ SOPHUS_ENUM() [1/5]

sophus::SOPHUS_ENUM ( AcceleroModelType  ,
(scaling_non_orthogonality)   
)

◆ SOPHUS_ENUM() [2/5]

sophus::SOPHUS_ENUM ( CameraDistortionType  ,
(pinhole, brown_conrady, kannala_brandt_k3, orthographic)   
)

Camera model projection type.

◆ SOPHUS_ENUM() [3/5]

sophus::SOPHUS_ENUM ( GyroModelType  ,
(scaling_non_orthogonality)   
)

◆ SOPHUS_ENUM() [4/5]

sophus::SOPHUS_ENUM ( ManifoldPlusType  ,
(left_plus, right_plus)   
)

◆ SOPHUS_ENUM() [5/5]

sophus::SOPHUS_ENUM ( NumberType  ,
(fixed_point, floating_point)   
)

◆ square()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::square ( TPoint const &  v)

◆ subsampleDown()

template<class TScalar >
auto sophus::subsampleDown ( Eigen::Matrix< TScalar, 2, 1 > const &  in) -> Eigen::Matrix<TScalar, 2, 1>

Subsamples pixel down, factor of 0.5.

See for details: https://docs.google.com/document/d/1xmhCMWklP2UoQMGaMqFnsoPWoeMvBfXN7S8-ie9k0UA/edit#heading=h.97r8rr8owwpc

◆ subsampleUp()

template<class TScalar >
auto sophus::subsampleUp ( Eigen::Matrix< TScalar, 2, 1 > const &  in) -> Eigen::Matrix<TScalar, 2, 1>

Subsamples pixel up, factor of 2.0.

See for details: https://docs.google.com/document/d/1xmhCMWklP2UoQMGaMqFnsoPWoeMvBfXN7S8-ie9k0UA/edit#heading=h.97r8rr8owwpc

◆ transpose()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::transpose ( TPoint  p)

◆ tryGetElem()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::tryGetElem ( TPoint const &  p,
size_t  row,
size_t  col = 0 
) -> Expected<TPoint>

◆ trySetElem() [1/2]

template<::sophus::concepts::ScalarType TPoint>
auto sophus::trySetElem ( TPoint &  p,
TPoint  s,
size_t  row,
size_t  col = 0 
) -> Expected<Success>

◆ trySetElem() [2/2]

template<::sophus::concepts::EigenDenseType TPoint>
auto sophus::trySetElem ( TPoint &  p,
typename TPoint::Scalar  s,
size_t  row,
size_t  col = 0 
) -> Expected<Success>

◆ unproj()

template<class TPoint >
auto sophus::unproj ( Eigen::MatrixBase< TPoint > const &  p,
const typename TPoint::Scalar &  z = 1.0 
) -> Eigen::Vector<typename TPoint::Scalar, TPoint::RowsAtCompileTime + 1>

Maps point on the z=1 plane (a,b) to homogeneous representation of the same point: (z*a, z*b, z). Z defaults to 1.

◆ vectorFieldNumDiff()

template<class TScalar , int kMatrixDim, int kM, class TScalarOrVector , class TFn >
auto sophus::vectorFieldNumDiff ( TFn  vector_field,
TScalarOrVector const &  a,
TScalar  eps = kEpsilonSqrt<TScalar> 
) -> Eigen::Matrix<TScalar, kMatrixDim, kM>

Calculates the derivative of a vector field at a point a.

Here, a vector field is a function from a vector space to another vector space.

◆ visitImage() [1/2]

template<typename TUserFunc , class TPredicate = IntensityImagePredicate, class TAllocator = Eigen::aligned_allocator<uint8_t>>
void sophus::visitImage ( TUserFunc &&  func,
DynImage< TPredicate, TAllocator > const &  image 
)

◆ visitImage() [2/2]

template<class TUserFunc , class TPredicate = IntensityImagePredicate>
void sophus::visitImage ( TUserFunc &&  func,
DynImageView< TPredicate > const &  image 
)

◆ zero()

template<::sophus::concepts::ScalarType TPoint>
auto sophus::zero ( ) -> TPoint

Variable Documentation

◆ kEpsilon

template<class TScalar >
const TScalar sophus::kEpsilon = TScalar(1e-10)

◆ kEpsilon< float >

template<>
const float sophus::kEpsilon< float > = float(1e-5)
inline

◆ kEpsilonPlus

template<class TScalar >
const TScalar sophus::kEpsilonPlus
Initial value:
=
kEpsilon<TScalar>*(TScalar(1.) + kEpsilon<TScalar>)

◆ kEpsilonSqrt

template<class TScalar >
const TScalar sophus::kEpsilonSqrt = TScalar(1e-5)

◆ kEpsilonSqrt< float >

template<>
const float sophus::kEpsilonSqrt< float > = float(3.16227766e-3)
inline

◆ kIsMappableV

template<class TScalar >
constexpr bool sophus::kIsMappableV = IsMappable<TScalar>::value
constexpr

◆ kIsUniformRandomBitGeneratorV

template<class TGenerator >
constexpr bool sophus::kIsUniformRandomBitGeneratorV
constexpr
Initial value:
=
IsUniformRandomBitGenerator<TGenerator>::kValue

◆ kPi

template<class TScalar >
const TScalar sophus::kPi = TScalar(3.141592653589793238462643383279502884)

◆ kPiF32

const float sophus::kPiF32 = kPi<float>

◆ kPiF64

const double sophus::kPiF64 = kPi<double>