Classes
struct	Accumulator

struct	Accumulator< bool >

struct	Accumulator< char >

struct	Accumulator< int >

struct	Accumulator< short >

struct	Accumulator< unsigned char >

struct	Accumulator< unsigned int >

struct	Accumulator< unsigned short >

class	AlphaCompositer

struct	BoundingBox

struct	BoxStats

class	CachedImage

struct	CameraMatrices

class	CmdLine

class	ColorHarmonizationEngineGlobal
	The ColorHarmonizationEngineGlobal class. More...

class	Compositer

class	CoordinatesMap

struct	Element

struct	Element< Mat >

struct	Element< Mat2X >

struct	Element< Mat3X >

struct	Element< std::vector< Vec2 > >

struct	EstimationStatus

class	GaussianPyramidNoMask

class	GaussianWarper

class	GraphcutSeams

class	HardwareContext

class	HierarchicalGraphcutSeams

struct	hstack_return

struct	IdValue

struct	ImageParams

class	LaplacianCompositer

class	LaplacianPyramid

struct	LMFunctor

class	MathTrait

class	Matrix3x3

class	Matrix3x4

class	MaxFlow_AdjList
	Maxflow computation based on a standard Adjacency List graph representation. More...

struct	mv2DTriangle

struct	NViewDataSet
	A N-view metric dataset. All points are seen by all cameras. More...

struct	NViewDatasetConfigurator

struct	OrientedPoint

class	PanoramaMap

struct	Pixel

class	Point2d

class	Point3d

struct	Point3dHash

class	Point4d

struct	Range

struct	rgb

struct	ROI

struct	SortedId

struct	Stat3d

class	StaticVector

struct	translations_Triplet_Solver
	Solve the translations and the structure of a view-triplet that have known rotations. More...

struct	uni_elt

class	Universe
	Allows to perform labelling by creating node and connecting them. More...

class	Version

struct	Voxel

struct	vstack_return

class	Warper

class	WTASeams

Typedefs
using	StaticVectorBool = StaticVector< char >

typedef uint32_t	IndexT

using	EigenDoubleTraits = Eigen::NumTraits< double >

using	Vec3 = Eigen::Vector3d

using	Vec3i = Eigen::Vector3i

using	Vec3f = Eigen::Vector3f

using	Vec2i = Eigen::Vector2i

using	Vec2f = Eigen::Vector2f

using	Vec9 = Eigen::Matrix< double, 9, 1 >

using	Quaternion = Eigen::Quaternion< double >

using	Mat3 = Eigen::Matrix< double, 3, 3 >

using	Mat23 = Eigen::Matrix< double, 2, 3 >

using	Mat34 = Eigen::Matrix< double, 3, 4 >

using	Vec2 = Eigen::Vector2d

using	Vec4 = Eigen::Vector4d

using	Vec6 = Eigen::Matrix< double, 6, 1 >

using	Mat4 = Eigen::Matrix< double, 4, 4 >

using	Matu = Eigen::Matrix< unsigned int, Eigen::Dynamic, Eigen::Dynamic >

using	RMat3 = Eigen::Matrix< double, 3, 3, Eigen::RowMajor >

using	Mat = Eigen::MatrixXd

using	Vec = Eigen::VectorXd

using	Vecu = Eigen::Matrix< unsigned int, Eigen::Dynamic, 1 >

using	Matf = Eigen::MatrixXf

using	Vecf = Eigen::VectorXf

using	Vecb = Eigen::Matrix< bool, Eigen::Dynamic, 1 >

using	Mat2X = Eigen::Matrix< double, 2, Eigen::Dynamic >

using	Mat3X = Eigen::Matrix< double, 3, Eigen::Dynamic >

using	Mat4X = Eigen::Matrix< double, 4, Eigen::Dynamic >

using	MatX9 = Eigen::Matrix< double, Eigen::Dynamic, 9 >

using	Mat9 = Eigen::Matrix< double, 9, 9 >

using	sMat = Eigen::SparseMatrix< double >

using	sRMat = Eigen::SparseMatrix< double, Eigen::RowMajor >

typedef std::pair< IndexT, IndexT >	Pair

typedef std::set< Pair >	PairSet

typedef std::vector< Pair >	PairVec

typedef feature::PointFeature	FeatureT

typedef std::vector< FeatureT >	featsT

Enumerations
enum	EEstimatorParameterState : std::uint8_t { REFINED = 0, CONSTANT = 1, IGNORED = 2 }
	Defines the state of a parameter for an estimator.

enum	EHistogramSelectionMethod { eHistogramHarmonizeFullFrame = 0, eHistogramHarmonizeMatchedPoints, eHistogramHarmonizeVLDSegment }

Functions
template<class T >
std::function< void(T)>	optInRange (T min, T max, const char *opt_name)

std::vector< boost::json::value >	readJsons (std::istream &is, boost::system::error_code &ec)

template<class K , class T >
stl::flat_map< K, T >	flat_map_value_to (const boost::json::value &jv)

template<class K , class T >
std::unordered_map< K, T >	unordered_map_value_to (const boost::json::value &jv)

template<class K , class T >
std::map< K, T >	map_value_to (const boost::json::value &jv)

image::RGBfColor	getColorFromJetColorMap (float value)
	Get the float color from the jet colormap for the given value. More...

rgb	getRGBFromJetColorMap (float value)
	Get the RGB color from the jet colormap for the given value. More...

void	getKVLDMask (image::Image< unsigned char > maskL, image::Image< unsigned char > maskR, const std::vector< feature::PointFeature > &vec_F1, const std::vector< feature::PointFeature > &vec_F2, const std::vector< Pair > &vec_matches, const std::vector< bool > &vec_valide, const aliceVision::Mat &mat_E)

PairSet	exhaustivePairs (const std::set< IndexT > &viewIds)
	Generate all the (I,J) pairs of the upper diagonal of the NxN matrix. More...

void	essentialFromFundamental (const Mat3 &F, const Mat3 &K1, const Mat3 &K2, Mat3 *E)
	Given F, Left/Right K matrix it compute the Essential matrix.

void	fundamentalFromEssential (const Mat3 &E, const Mat3 &K1, const Mat3 &K2, Mat3 *F)
	Given E, Left/Right K matrix it compute the Fundamental matrix.

void	relativeCameraMotion (const Mat3 &R1, const Vec3 &t1, const Mat3 &R2, const Vec3 &t2, Mat3 R, Vec3 t)
	Compute the relative camera motion between two cameras. Given the motion parameters of two cameras, computes the motion parameters of the second one assuming the first one to be at the origin. If T1 and T2 are the camera motions, the computed relative motion is. More...

void	essentialFromRt (const Mat3 &R1, const Vec3 &t1, const Mat3 &R2, const Vec3 &t2, Mat3 *E)
	Compute E as E = [t12]x R12.

void	motionFromEssential (const Mat3 &E, std::vector< Mat3 > Rs, std::vector< Vec3 > ts)
	HZ 9.7 page 259 (Result 9.19)

void	motionFromEssential (const Mat3 &E, std::vector< Mat4 > &Ts)
	HZ 9.7 page 259 (Result 9.19)

int	motionFromEssentialChooseSolution (const std::vector< Mat3 > &Rs, const std::vector< Vec3 > &ts, const Mat3 &K1, const Vec2 &x1, const Mat3 &K2, const Vec2 &x2)
	Choose one of the four possible motion solutions from an essential matrix. Decides the right solution by checking that the triangulation of a match x1–x2 lies in front of the cameras. Return the index of the right solution or -1 if no solution.

bool	motionFromEssentialAndCorrespondence (const Mat3 &E, const Mat3 &K1, const Vec2 &x1, const Mat3 &K2, const Vec2 &x2, Mat3 R, Vec3 t)
	Test the possible R\|t configuration to have point in front of the cameras Return false if no possible configuration.

bool	estimateTransformStructureFromEssential (Mat4 &T, std::vector< Vec3 > &structure, std::vector< size_t > &newVecInliers, const Mat3 &E, const std::vector< size_t > &vecInliers, const camera::IntrinsicBase &cam1, const camera::IntrinsicBase &cam2, const std::vector< Vec2 > &x1, const std::vector< Vec2 > &x2)
	Estimate the relative transformation of the camera and the associated 3d structure of the observed points using an essential matrix as input prior. More...

NViewDataSet	NRealisticCamerasRing (size_t nviews, size_t npoints, const NViewDatasetConfigurator &config)

NViewDataSet	NRealisticCamerasCardioid (size_t nviews, size_t npoints, const NViewDatasetConfigurator &config)

NViewDataSet	NRealisticCamerasRing (std::size_t nviews, std::size_t npoints, const NViewDatasetConfigurator &config=NViewDatasetConfigurator())
	Place cameras on a circle with point in the center.

NViewDataSet	NRealisticCamerasCardioid (std::size_t nviews, std::size_t npoints, const NViewDatasetConfigurator &config=NViewDatasetConfigurator())
	Place cameras on cardiod shape with point in the center.

double	pointLineDistance3D (const Point3d &point, const Point3d &linePoint, const Point3d &lineVectNormalized)

Point3d	closestPointToLine3D (const Point3d point, const Point3d linePoint, const Point3d *lineVectNormalized)

double	pointPlaneDistance (const Point3d &point, const Point3d &planePoint, const Point3d &planeNormal)

double	orientedPointPlaneDistance (const Point3d &point, const Point3d &planePoint, const Point3d &planeNormal)

void	computeRotCS (Point3d xax, Point3d yax, const Point3d *n)

bool	lineLineIntersect (double k, double l, Point3d llis, Point3d lli1, Point3d *lli2, const Point3d &p1, const Point3d &p2, const Point3d &p3, const Point3d &p4)

bool	lineLineIntersect (Point3d &out, const Point3d &p1, const Point3d &v1, const Point3d &p2, const Point3d &v2)

Point3d	linePlaneIntersect (const Point3d &linePoint, const Point3d &lineVect, const Point3d &planePoint, const Point3d &planeNormal)

void	linePlaneIntersect (Point3d out, const Point3d linePoint, const Point3d lineVect, const Point3d planePoint, const Point3d *planeNormal)

double	angleBetwV1andV2 (const Point3d &iV1, const Point3d &iV2)

double	angleBetwABandAC (const Point3d &A, const Point3d &B, const Point3d &C)

void	rotPointAroundVect (double out, const double X, const double *vect, const double angle)

void	rotPointAroundVect (Point3d out, const Point3d X, const Point3d *vect, const double angle)

Point2d	getLineTriangleIntersectBarycCoords (Point3d P, const Point3d A, const Point3d B, const Point3d C, const Point3d linePoint, const Point3d lineVect)

bool	isLineInTriangle (Point3d P, const Point3d A, const Point3d B, const Point3d C, const Point3d linePoint, const Point3d lineVect)

bool	isLineSegmentInTriangle (Point3d &lpi, const Point3d &A, const Point3d &B, const Point3d &C, const Point3d &linePoint1, const Point3d &linePoint2)

Point2d	computeBarycentricCoordinates (const Point2d &A, const Point2d &B, const Point2d &C, const Point2d &P)

bool	isPointInTriangle (const Point2d &barycUv)

bool	isPointInTriangle (const Point2d &A, const Point2d &B, const Point2d &C, const Point2d &P)

bool	lineSegmentsIntersect2DTest (const Point2d &A, const Point2d &B, const Point2d &C, const Point2d &D)

bool	lineSegmentsIntersect2DTest (Point2d &S, const Point2d &A, const Point2d &B, const Point2d &C, const Point2d &D)

bool	ccw_tri_tri_intersection_2d (const Point2d &p1, const Point2d &q1, const Point2d &r1, const Point2d &p2, const Point2d &q2, const Point2d &r2)

bool	TrianglesOverlap (const Point2d t1, const Point2d t2)

bool	interectsTriangleTriangle (const Point3d tri1, const Point3d tri2)

bool	lineLineIntersectLeft (Point3d &out, const Point3d &p1, const Point3d &p2, const Point3d &p3, const Point3d &p4)

int	coplanar_tri_tri (const double N[3], const double V0[3], const double V1[3], const double V2[3], const double U0[3], const double U1[3], const double U2[3])

int	tri_tri_intersect (const double V0[3], const double V1[3], const double V2[3], const double U0[3], const double U1[3], const double U2[3])

void	isect2 (const double VTX0[3], const double VTX1[3], const double VTX2[3], double VV0, double VV1, double VV2, double D0, double D1, double D2, double isect0, double isect1, double isectpoint0[3], double isectpoint1[3])

int	compute_intervals_isectline (const double VERT0[3], const double VERT1[3], const double VERT2[3], double VV0, double VV1, double VV2, double D0, double D1, double D2, double D0D1, double D0D2, double isect0, double isect1, double isectpoint0[3], double isectpoint1[3])

int	tri_tri_intersect_with_isectline (const double V0[3], const double V1[3], const double V2[3], const double U0[3], const double U1[3], const double U2[3], int *coplanar, double isectpt1[3], double isectpt2[3])

Matrix3x3	diag3x3 (double d1, double d2, double d3)

Matrix3x4	operator* (const Matrix3x3 &M1, const Matrix3x4 &M2)

Matrix3x4	operator\| (const Matrix3x3 &M, const Point3d &p)

double	dot (const Point2d &p1, const Point2d &p2)

std::ostream &	operator<< (std::ostream &stream, const Point2d &p)

double	dist (const Point3d &p1, const Point3d &p2)

double	dot (const Point3d &p1, const Point3d &p2)

Point3d	cross (const Point3d &a, const Point3d &b)

Point3d	proj (const Point3d &e, const Point3d &a)

double	tripleProduct (const Point3d &a, const Point3d &b, const Point3d &c)

double	tetrahedronSolidAngle (const Point3d &oa, const Point3d &ob, const Point3d &oc)
	Solid angle of a tetrahedron. It takes 3 vectors OA, OB, AC to define the solid angle define by the triangle ABC around the point O. More...

std::ostream &	operator<< (std::ostream &stream, const Point3d &p)

Eigen::Matrix< double, 3, 1 >	toEigen (const Point3d &v)

std::ostream &	operator<< (std::ostream &stream, const Point4d &p)

Range	intersect (const Range &a, const Range &b)

CUDA_HOST bool	checkImageROI (const ROI &roi, int width, int height)
	check if a given ROI is valid and can be contained in a given image More...

CUDA_HOST Range	downscaleRange (const Range &range, float downscale)
	Downscale the given Range with the given downscale factor. More...

CUDA_HOST Range	upscaleRange (const Range &range, float upscale)
	Upscale the given Range with the given upscale factor. More...

CUDA_HOST Range	inflateRange (const Range &range, float factor)
	Inflate the given Range with the given factor. More...

CUDA_HOST ROI	downscaleROI (const ROI &roi, float downscale)
	Downscale the given ROI with the given downscale factor. More...

CUDA_HOST ROI	upscaleROI (const ROI &roi, float upscale)
	Upscale the given ROI with the given upscale factor. More...

CUDA_HOST ROI	inflateROI (const ROI &roi, float factor)
	Inflate the given ROI with the given factor. More...

ROI	intersect (const ROI &a, const ROI &b)

std::ostream &	operator<< (std::ostream &os, const Range &range)

std::ostream &	operator<< (std::ostream &os, const ROI &roi)

double	hypot2 (double x, double y)

void	tred2 (double V0[], double V1[], double V2[], double d[], double e[])

void	tql2 (double V0[], double V1[], double V2[], double d[], double e[])

int	getArrayLengthFromFile (const std::string &fileName)

template<class T >
int	sizeOfStaticVector (const StaticVector< T > *a)

template<class T >
int	sizeOfStaticVector (const StaticVector< T > &a)

template<class T >
int	indexOf (T *arr, int n, const T &what)

template<class T >
void	saveArrayOfArraysToFile (const std::string &fileName, StaticVector< StaticVector< T > * > *aa)

template<class T >
void	saveArrayOfArraysToFile (const std::string fileName, StaticVector< StaticVector< T >> &aa)

template<class T >
StaticVector< StaticVector< T > * > *	loadArrayOfArraysFromFile (const std::string &fileName)

template<class T >
void	loadArrayOfArraysFromFile (StaticVector< StaticVector< T >> &out_aa, const std::string &fileName)

template<class T >
void	saveArrayToFile (const std::string &fileName, const StaticVector< T > &a, bool docompress=true)

template<class T >
void	saveArrayToFile (const std::string &fileName, const StaticVector< T > *a, bool docompress=true)

template<class T >
StaticVector< T > *	loadArrayFromFile (const std::string &fileName, bool printfWarning=false)

template<class T >
bool	loadArrayFromFile (StaticVector< T > &out, const std::string &fileName, bool printfWarning=false)

template<class T >
void	loadArrayFromFileIntoArray (StaticVector< T > *a, const std::string &fileName, bool printfWarning=false)

template<class T >
void	deleteAllPointers (StaticVector< T * > &vec)

template<class T >
void	deleteArrayOfArrays (StaticVector< StaticVector< T > * > **aa)

template<class T >
void	deleteArrayOfArrays (StaticVector< StaticVector< T > * > &aa)

template<class T >
StaticVector< StaticVector< T > * > *	cloneArrayOfArrays (StaticVector< StaticVector< T > * > *inAOA)

int	qSortCompareFloatAsc (const void ia, const void ib)

int	qSortCompareIntAsc (const void ia, const void ib)

int	qsortCompareSortedIdDesc (const void ia, const void ib)

int	qsortCompareSortedIdAsc (const void ia, const void ib)

int	qSortCompareVoxelByXAsc (const void ia, const void ib)

int	qSortCompareVoxelByYAsc (const void ia, const void ib)

int	qSortCompareVoxelByZAsc (const void ia, const void ib)

int	qSortComparePixelByXDesc (const void ia, const void ib)

int	qSortComparePixelByXAsc (const void ia, const void ib)

int	indexOfSortedVoxelArrByX (int val, StaticVector< Voxel > &values, int startId, int stopId)

std::ostream &	operator<< (std::ostream &out, const Voxel &v)

template<typename TMat , typename TVec >
double	Nullspace (const TMat &A, TVec &nullspace)

template<typename TMat , typename TVec1 , typename TVec2 >
double	Nullspace2 (const TMat &A, TVec1 &x1, TVec2 &x2)

template<size_t M, size_t N>
Eigen::Matrix< double, M N, M N >	getJacobian_At_wrt_A ()

template<size_t M, size_t N, size_t K>
Eigen::Matrix< double, M K, M N >	getJacobian_AB_wrt_A (const Eigen::Matrix< double, M, N > &A, const Eigen::Matrix< double, N, K > &B)

template<size_t M, size_t N, size_t K>
Eigen::Matrix< double, M K, M N >	getJacobian_AtB_wrt_A (const Eigen::Matrix< double, M, N > &A, const Eigen::Matrix< double, M, K > &B)

template<size_t M, size_t N, size_t K>
Eigen::Matrix< double, M K, N K >	getJacobian_AB_wrt_B (const Eigen::Matrix< double, M, N > &A, const Eigen::Matrix< double, N, K > &B)

template<typename Type >
std::ostream &	operator<< (std::ostream &os, const BoxStats< Type > obj)

template<>
size_t	CountElements< Mat2X > (const Mat2X &A)

template<>
size_t	CountElements< Mat3X > (const Mat3X &A)

template<>
size_t	CountElements< Mat > (const Mat &A)

template<>
size_t	CountElements< std::vector< Vec2 > > (const std::vector< Vec2 > &A)

template<>
size_t	ElementSize< Mat2X > (const Mat2X &A)

template<>
size_t	ElementSize< Mat3X > (const Mat3X &A)

template<>
size_t	ElementSize< Mat > (const Mat &A)

template<>
size_t	ElementSize< std::vector< Vec2 > > (const std::vector< Vec2 > &A)

template<>
Element< Mat2X >::const_type	getElement< Mat2X > (const Mat2X &A, size_t index)

template<>
Element< Mat2X >::type	getElement< Mat2X > (Mat2X &A, size_t index)

template<>
Element< Mat3X >::const_type	getElement< Mat3X > (const Mat3X &A, size_t index)

template<>
Element< Mat3X >::type	getElement< Mat3X > (Mat3X &A, size_t index)

template<>
Element< Mat >::const_type	getElement< Mat > (const Mat &A, size_t index)

template<>
Element< Mat >::type	getElement< Mat > (Mat &A, size_t index)

template<>
Element< std::vector< Vec2 > >::const_type	getElement< std::vector< Vec2 > > (const std::vector< Vec2 > &A, size_t index)

template<>
Element< std::vector< Vec2 > >::type	getElement< std::vector< Vec2 > > (std::vector< Vec2 > &A, size_t index)

template<typename TMat >
size_t	CountElements (const TMat &A)

template<typename TMat >
size_t	ElementSize (const TMat &A)

template<typename TMat >
Element< TMat >::const_type	getElement (const TMat &A, size_t index)

template<typename TMat >
Element< TMat >::type	getElement (TMat &A, size_t index)

template<typename TMat , typename TCols >
TMat	buildSubsetMatrix (const TMat &A, const TCols &columns)
	It extracts the columns of given indices from the given matrix. More...

Vec3	WGS84ToCartesian (const Vec3 &gps)
	Convert the position expressed in WGS84 reference frame (latitude, longitude, altitude) to the cartesian coordinates x, y, z. More...

double	parseAltitudeFromString (const std::string &alt, const std::string &altRef)
	Convert the string representation of the altitude in gps representation to a numeric value. More...

double	parseGPSFromString (const std::string &gpsDegrees, const std::string &gpsRef)
	Convert the string representation of the gps position (latitude or longitude) to a numeric value. More...

Mat23	SkewMatMinimal (const Vec2 &x)
	Create a minimal skew matrix from a 2d vector. More...

Mat3	CrossProductMatrix (const Vec3 &x)
	Create a cross product matrix from a 3d vector. More...

Mat3	RotationAroundX (double angle)

Mat3	RotationAroundY (double angle)

Mat3	RotationAroundZ (double angle)

Mat3	rotationXYZ (double angleX, double angleY, double angleZ)

double	getRotationMagnitude (const Mat3 &R2)

double	rotationDifference (const Mat3 &R1, const Mat3 &R2)
	Compute the angle between two rotation matrices. More...

Mat3	LookAt (const Vec3 &center, const Vec3 &up)

Mat3	LookAt2 (const Vec3 &eyePosition3D, const Vec3 &center3D, const Vec3 &upVector3D)

void	MeanAndVarianceAlongRows (const Mat &A, Vec mean_pointer, Vec variance_pointer)

bool	exportMatToTextFile (const Mat &mat, const std::string &filename, const std::string &sPrefix)

void	makeRandomOperationsReproducible ()

template<typename T >
T	Square (T x)
	Return the square of a number.

template<typename T >
T	clamp (const T &val, const T &min, const T &max)
	Clamp return the number if inside range, else min or max range.

bool	isSimilar (double a, double b)

bool	isSimilar (float a, float b)

template<typename T >
T	degreeToRadian (T degree)

template<typename T >
T	radianToDegree (T radian)

double	SIGN (double x)

template<typename TVec >
double	NormL1 (const TVec &x)

template<typename TVec >
double	NormL2 (const TVec &x)

template<typename TVec >
double	NormLInfinity (const TVec &x)

template<typename TVec >
double	DistanceL1 (const TVec &x, const TVec &y)

template<typename TVec >
double	DistanceL2 (const TVec &x, const TVec &y)

template<typename TVec >
double	DistanceLInfinity (const TVec &x, const TVec &y)

template<typename TVec >
bool	AreVecNearEqual (const TVec &x, const TVec &y, const double epsilon)

template<typename TMat >
bool	AreMatNearEqual (const TMat &X, const TMat &Y, const double epsilon)

template<typename Derived1 , typename Derived2 >
hstack_return< Derived1, Derived2 >::type	HStack (const Eigen::MatrixBase< Derived1 > &lhs, const Eigen::MatrixBase< Derived2 > &rhs)

template<typename Derived1 , typename Derived2 >
vstack_return< Derived1, Derived2 >::type	VStack (const Eigen::MatrixBase< Derived1 > &lhs, const Eigen::MatrixBase< Derived2 > &rhs)

template<typename TMat >
double	FrobeniusNorm (const TMat &A)

template<typename TMat >
double	FrobeniusDistance (const TMat &A, const TMat &B)

template<class TMat >
double	CosinusBetweenMatrices (const TMat &a, const TMat &b)

template<typename T >
void	pick (std::vector< T > &result, const std::vector< T > &input, const std::vector< typename std::vector< T >::size_type > &selection)
	Given a vector of element and a vector containing a selection of its indices, it returns a new vector containing only the selected elements of the original vector. More...

int	is_finite (const double val)

template<typename T >
void	SplitRange (const T range_start, const T range_end, const int nb_split, std::vector< T > &d_range)

template<class T >
constexpr T	divideRoundUp (T x, T y)

template<typename Real >
int	SolveCubicPolynomial (Real a, Real b, Real c, Real x0, Real x1, Real *x2)

template<typename Real >
int	SolveCubicPolynomial (const Real coeffs, Real solutions)

void	P_from_KRt (const Mat3 &K, const Mat3 &R, const Vec3 &t, Mat34 &P)
	Compute P = K[R\|t].

Mat34	P_from_KRt (const Mat3 &K, const Mat3 &R, const Vec3 &t)
	Compute P = K[R\|t]. More...

void	KRt_from_P (const Mat34 &P, Mat3 &Kp, Mat3 &Rp, Vec3 &tp)
	Decompose using the RQ decomposition HZ A4.1.1 pag.579.

Mat3	F_from_P (const Mat34 &P1, const Mat34 &P2)
	Compute a fundamental matrix from projection matrices.

Vec2	project (const Mat34 &P, const Vec3 &X)
	Compute P*[X\|1.0]. Transformed from homogeneous to euclidean coordinates.

void	project (const Mat34 &P, const Mat3X &X, Mat2X &x)
	Compute P*[X\|1.0] for the X list of point (3D point).

void	project (const Mat34 &P, const Mat4X &X, Mat2X &x)
	Compute P*[X\|1.0] for the X list of point (4D point).

Mat2X	project (const Mat34 &P, const Mat3X &X)
	Return P*[X\|1.0] for the X list of point (3D point).

Mat2X	project (const Mat34 &P, const Mat4X &X)
	Return P*[X\|1.0] for the X list of point (4D point).

void	homogeneousToEuclidean (const Vec4 &H, Vec3 &X)
	Change homogeneous coordinates to euclidean.

void	euclideanToHomogeneous (const Mat &X, Mat &H)
	Change euclidean coordinates to homogeneous.

double	Depth (const Mat3 &R, const Vec3 &t, const Vec3 &X)
	Compute the depth of the X point. R*X[2]+t[2].

Vecb	cheiralityTest (const Mat3 &R, const Vec3 &t, const Mat3X &X)
	Test whether the given points are in front of the camera. More...

bool	cheiralityTestAll (const Mat3 &R, const Vec3 &t, const Mat3X &X)
	Test whether all the given points are in front of the camera. More...

Vec3	euclideanToHomogeneous (const Vec2 &x)
	Change euclidean coordinates to homogeneous.

void	homogeneousToEuclidean (const Mat &H, Mat &X)
	Change homogeneous coordinates to euclidean.

Mat3X	euclideanToHomogeneous (const Mat2X &x)
	Change euclidean coordinates to homogeneous.

void	euclideanToHomogeneous (const Mat2X &x, Mat3X &h)
	Change euclidean coordinates to homogeneous.

void	homogeneousToEuclidean (const Mat3X &h, Mat2X &e)
	Change homogeneous coordinates to euclidean.

void	euclideanToNormalizedCamera (const Mat2X &x, const Mat3 &K, Mat2X &n)
	Project x point in camera coordinates.

void	homogeneousToNormalizedCamera (const Mat3X &x, const Mat3 &K, Mat2X &n)
	Project x point in camera coordinates.

double	reprojectionErrorRMSE (const Mat2X &x_image, const Mat4X &X_world, const Mat34 &P)
	Estimates the root mean square error (2D)

double	reprojectionErrorRMSE (const Mat2X &x_image, const Mat3X &X_world, const Mat3 &K, const Mat3 &R, const Vec3 &t)
	Estimates the root mean square error (2D)

std::ostream &	operator<< (std::ostream &os, const BoundingBox &in)

bool	distanceToCenter (aliceVision::image::Image< float > &_weights, const CoordinatesMap &map, int width, int height)

bool	computeDistanceMap (image::Image< int > &distance, const image::Image< unsigned char > &mask)
	Code adapted from VFLib: https://github.com/vinniefalco/VFLib (Licence MIT)

bool	feathering (aliceVision::image::Image< image::RGBfColor > &output, const aliceVision::image::Image< image::RGBfColor > &color, const aliceVision::image::Image< unsigned char > &inputMask)

bool	feathering (CachedImage< image::RGBfColor > &input_output, CachedImage< unsigned char > &inputMask)

template<class T >
void	convolveRow (typename image::Image< T >::RowXpr output_row, typename image::Image< T >::ConstRowXpr input_row, const Eigen::Matrix< float, 5, 1 > &kernel, bool loop)

template<class T >
void	convolveColumns (typename image::Image< T >::RowXpr output_row, const image::Image< T > &input_rows, const Eigen::Matrix< float, 5, 1 > &kernel)

template<class T >
bool	convolveGaussian5x5 (image::Image< T > &output, const image::Image< T > &input, bool loop=false)

bool	computeSeamsMap (image::Image< unsigned char > &seams, const image::Image< IndexT > &labels)

void	removeNegativeValues (image::Image< image::RGBfColor > &img)

template<class T >
bool	downscale (aliceVision::image::Image< T > &outputColor, const aliceVision::image::Image< T > &inputColor)

template<class T >
bool	upscale (aliceVision::image::Image< T > &outputColor, const aliceVision::image::Image< T > &inputColor)

template<class T >
bool	substract (aliceVision::image::Image< T > &AminusB, const aliceVision::image::Image< T > &A, const aliceVision::image::Image< T > &B)

template<class T >
bool	addition (aliceVision::image::Image< T > &AplusB, const aliceVision::image::Image< T > &A, const aliceVision::image::Image< T > &B)

template<class T >
bool	loopyImageAssign (image::Image< T > &output, const aliceVision::image::Image< T > &input, const BoundingBox &assignedOutputBb, const BoundingBox &assignedInputBb)

template<class T >
bool	loopyCachedImageAssign (CachedImage< T > &output, const aliceVision::image::Image< T > &input, const BoundingBox &assignedOutputBb, const BoundingBox &assignedInputBb)

template<class T >
bool	loopyImageExtract (image::Image< T > &output, const image::Image< T > &input, const BoundingBox &extractedInputBb)

template<class T >
bool	loopyCachedImageExtract (aliceVision::image::Image< T > &output, CachedImage< T > &input, const BoundingBox &extractedInputBb)

template<class T >
bool	makeImagePyramidCompatible (image::Image< T > &output, int &outOffsetX, int &outOffsetY, const image::Image< T > &input, int offsetX, int offsetY, size_t borderSize, size_t num_levels)

bool	isPoleInTriangle (const Vec3 &pt1, const Vec3 &pt2, const Vec3 &pt3)

bool	crossHorizontalLoop (const Vec3 &pt1, const Vec3 &pt2)

Vec3	getExtremaY (const Vec3 &pt1, const Vec3 &pt2)

bool	computeCoarseBB_Equidistant (BoundingBox &coarse_bbox, const std::pair< int, int > &panoramaSize, const geometry::Pose3 &pose, const aliceVision::camera::IntrinsicBase &intrinsics)

bool	computeCoarseBB_Pinhole (BoundingBox &coarse_bbox, const std::pair< int, int > &panoramaSize, const geometry::Pose3 &pose, const aliceVision::camera::IntrinsicBase &intrinsics)

bool	computeCoarseBB (BoundingBox &coarse_bbox, const std::pair< int, int > &panoramaSize, const geometry::Pose3 &pose, const aliceVision::camera::IntrinsicBase &intrinsics)

void	drawBorders (aliceVision::image::Image< image::RGBAfColor > &inout, aliceVision::image::Image< unsigned char > &mask, int offset_x, int offset_y)

void	drawSeams (aliceVision::image::Image< image::RGBAfColor > &inout, aliceVision::image::Image< IndexT > &labels, int offset_x, int offset_y)

bool	getMaskFromLabels (aliceVision::image::Image< float > &mask, image::Image< IndexT > &labels, IndexT index, int offset_x, int offset_y)

template<typename Map >
const Map::mapped_type &	map_get_with_default (const Map &m, const typename Map::key_type &key, const typename Map::mapped_type &defval)

template<typename Map >
bool	map_has_non_empty_value (const Map &m, const typename Map::key_type &key)

std::regex	simpleFilterToRegex (const std::string &simpleFilter)

std::regex	simpleFilterToRegex_noThrow (const std::string &simpleFilter)

bool	rangeComputation (int &rangeStart, int &rangeEnd, int rangeIteration, int rangeBlocksCount, int itemsCount)

bool	computeSimilarity (const std::vector< Vec3 > &vec_camPosGT, const std::vector< Vec3 > &vec_camPosComputed, std::mt19937 &randomNumberGenerator, std::vector< Vec3 > &vec_camPosComputed_T, double Sout, Mat3 Rout, Vec3 *tout)
	Compute a 5DOF rigid transform between the two camera trajectories.

bool	exportToPly (const std::vector< Vec3 > &vec_camPosGT, const std::vector< Vec3 > &vec_camPosComputed, const std::string &sFileName)
	Export to PLY two camera trajectories.

void	EvaluteToGT (const std::vector< Vec3 > &vec_camCenterGT, const std::vector< Vec3 > &vec_camCenterComputed, const std::vector< Mat3 > &vec_camRotGT, const std::vector< Mat3 > &vec_camRotComputed, const std::string &sOutPath, std::mt19937 &randomNumberGenerator, htmlDocument::htmlDocumentStream *htmlDocStream)

int	findIdGT (const std::string &file, const std::vector< std::string > &filelist)

EHistogramSelectionMethod	EHistogramSelectionMethod_stringToEnum (const std::string &histogramSelectionMethod)

std::string	EHistogramSelectionMethod_enumToString (const EHistogramSelectionMethod histogramSelectionMethod)

std::ostream &	operator<< (std::ostream &os, EHistogramSelectionMethod p)

std::istream &	operator>> (std::istream &in, EHistogramSelectionMethod &p)

std::string	EHistogramSelectionMethod_description ()

EHistogramSelectionMethod	EEHistogramSelectionMethod_stringToEnum (const std::string &histogramSelectionMethod)

Detailed Description

Collection of function related to the classic Projection matrix used in computer vision. P = K[R|t] with [t]=[-RC] Cf HZ

Function Documentation

◆ buildSubsetMatrix()

template<typename TMat , typename TCols >

TMat aliceVision::buildSubsetMatrix	(	const TMat &	A,
		const TCols &	columns
	)

It extracts the columns of given indices from the given matrix.

Parameters

[in]	A	The NxM input matrix
[in]	columns	The list of K indices to extract

Returns: A NxK matrix

◆ checkImageROI()

CUDA_HOST bool aliceVision::checkImageROI	(	const ROI &	roi,
		int	width,
		int	height
	)

inline

check if a given ROI is valid and can be contained in a given image

Parameters

[in]	roi	the given ROI
[in]	width	the given image width
[in]	height	the given image height

Returns: true if valid

◆ cheiralityTest()

Vecb aliceVision::cheiralityTest	(	const Mat3 &	R,
		const Vec3 &	t,
		const Mat3X &	X
	)

Test whether the given points are in front of the camera.

Parameters

[in]	R	the camera rotation.
[in]	t	the camera translation.
[in]	X	the 3D points to test.

Returns: A vector of boolean of the same size as the number of points. The corresponding value is true if the point is in front of the camera, false otherwise.

◆ cheiralityTestAll()

bool aliceVision::cheiralityTestAll	(	const Mat3 &	R,
		const Vec3 &	t,
		const Mat3X &	X
	)

Test whether all the given points are in front of the camera.

Parameters

[in]	R	the camera rotation.
[in]	t	the camera translation.
[in]	X	the 3D points to test.

Returns: true if all the points is in front of the camera, false otherwise.

◆ computeCoarseBB_Equidistant()

bool aliceVision::computeCoarseBB_Equidistant	(	BoundingBox &	coarse_bbox,
		const std::pair< int, int > &	panoramaSize,
		const geometry::Pose3 &	pose,
		const aliceVision::camera::IntrinsicBase &	intrinsics
	)

Check that this ray should be visible. This test is camera type dependent

Project this ray to camera pixel coordinates

Ignore invalid coordinates

Check that this ray should be visible. This test is camera type dependent

Project this ray to camera pixel coordinates

Ignore invalid coordinates

Check that this ray should be visible. This test is camera type dependent

Project this ray to camera pixel coordinates

Ignore invalid coordinates

◆ convolveGaussian5x5()

template<class T >

bool aliceVision::convolveGaussian5x5	(	image::Image< T > &	output,
		const image::Image< T > &	input,
		bool	loop = `false`
	)

current row : -5 -4 -3 -2 -1 next 1 : -4 -3 -2 -1 -2 next 2 : -3 -2 -1 -2 -3

◆ CrossProductMatrix()

Mat3 aliceVision::CrossProductMatrix ( const Vec3 & x )

Create a cross product matrix from a 3d vector.

Parameters

x	A 3d vector.

Returns: the cross matrix representation of the input vector.

◆ downscaleRange()

CUDA_HOST Range aliceVision::downscaleRange	(	const Range &	range,
		float	downscale
	)

inline

Downscale the given Range with the given downscale factor.

Parameters

[in]	range	the given Range
[in]	downscale	the downscale factor to apply

Returns: the downscaled Range

◆ downscaleROI()

CUDA_HOST ROI aliceVision::downscaleROI	(	const ROI &	roi,
		float	downscale
	)

inline

Downscale the given ROI with the given downscale factor.

Parameters

[in]	roi	the given ROI
[in]	downscale	the downscale factor to apply

Returns: the downscaled ROI

◆ estimateTransformStructureFromEssential()

bool aliceVision::estimateTransformStructureFromEssential	(	Mat4 &	T,
		std::vector< Vec3 > &	structure,
		std::vector< size_t > &	newVecInliers,
		const Mat3 &	E,
		const std::vector< size_t > &	vecInliers,
		const camera::IntrinsicBase &	cam1,
		const camera::IntrinsicBase &	cam2,
		const std::vector< Vec2 > &	x1,
		const std::vector< Vec2 > &	x2
	)

Estimate the relative transformation of the camera and the associated 3d structure of the observed points using an essential matrix as input prior.

Parameters

T	the output estimated pose
structure	the output estimated structure
newVecInliers	the updated inliers list (set of indices in the coordinates vectors)
E	the input Essential matrix prior
vecInliers	the input list of inliers (set of indices in the coordinates vectors)
cam1	the first camera intrinsic object
cam2	the second camera intrinsic object
x1	the observed points coordinates in the first camera
x2	the observed points coordinates in the second camera

Returns: true if estimation succeeded

◆ EvaluteToGT()

void aliceVision::EvaluteToGT	(	const std::vector< Vec3 > &	vec_camCenterGT,
		const std::vector< Vec3 > &	vec_camCenterComputed,
		const std::vector< Mat3 > &	vec_camRotGT,
		const std::vector< Mat3 > &	vec_camRotComputed,
		const std::string &	sOutPath,
		std::mt19937 &	randomNumberGenerator,
		htmlDocument::htmlDocumentStream *	htmlDocStream
	)

inline

Compare two camera path (translation and rotation residual after a 5DOF rigid registration) Export computed statistics to a HTLM stream

◆ exhaustivePairs()

PairSet aliceVision::exhaustivePairs ( const std::set< IndexT > & viewIds )

Generate all the (I,J) pairs of the upper diagonal of the NxN matrix.

Parameters

views the sfmData views indices list

Returns: a generated set of pairs

◆ getColorFromJetColorMap()

image::RGBfColor aliceVision::getColorFromJetColorMap ( float value )

Get the float color from the jet colormap for the given value.

Parameters

[in] value from range 0.0 1.0

Returns

float color value :

0.0f > 'value' > 1.0f: color from jet colormap
'value' <= 0.0f: black
'value' >= 1.0f: white

◆ getJacobian_AB_wrt_A()

template<size_t M, size_t N, size_t K>

Eigen::Matrix<double, M * K, M * N> aliceVision::getJacobian_AB_wrt_A	(	const Eigen::Matrix< double, M, N > &	A,
		const Eigen::Matrix< double, N, K > &	B
	)

vec(M1*M2*M3) = kron(M3.t, M1) * vec(M2)

vec(IAB) = kron(B.t, I) * vec(A)

dvec(IAB)/dA = kron(B.t, I) * dvec(A)/dA

dvec(IAB)/dA = kron(B.t, I)

◆ getJacobian_AB_wrt_B()

template<size_t M, size_t N, size_t K>

Eigen::Matrix<double, M * K, N * K> aliceVision::getJacobian_AB_wrt_B	(	const Eigen::Matrix< double, M, N > &	A,
		const Eigen::Matrix< double, N, K > &	B
	)

vec(M1*M2*M3) = kron(M3.t, M1) * vec(M2)

vec(ABI) = kron(I, A) * vec(B)

dvec(ABI)/dB = kron(I, A) * dvec(B)/dB

dvec(ABI)/dB = kron(I, A)

◆ getJacobian_At_wrt_A()

template<size_t M, size_t N>

Eigen::Matrix<double, M * N, M * N> aliceVision::getJacobian_At_wrt_A ( )

vec(M1*M2*M3) = kron(M3.t, M1) * vec(M2)

vec(IAtB) = kron(B.t, I) * vec(A)

dvec(IAtB)/dA = kron(B.t, I) * dvec(At)/dA

◆ getRGBFromJetColorMap()

rgb aliceVision::getRGBFromJetColorMap ( float value )

Get the RGB color from the jet colormap for the given value.

Parameters

[in] value from range 0.0 1.0

Returns

RGB value :

0.0f > 'value' > 1.0f: color from jet colormap
'value' <= 0.0f: black
'value' >= 1.0f: white

◆ getRotationMagnitude()

double aliceVision::getRotationMagnitude ( const Mat3 & R2 )

Return in radian the mean rotation amplitude of the given rotation matrix Computed as the mean of matrix column dot products to an Identity matrix

◆ inflateRange()

CUDA_HOST Range aliceVision::inflateRange	(	const Range &	range,
		float	factor
	)

inline

Inflate the given Range with the given factor.

Parameters

[in]	range	the given Range
[in]	factor	the inflate factor to apply

Returns: the inflated Range

◆ inflateROI()

CUDA_HOST ROI aliceVision::inflateROI	(	const ROI &	roi,
		float	factor
	)

inline

Inflate the given ROI with the given factor.

Parameters

[in]	roi	the given ROI
[in]	factor	the inflate factor to apply

Returns: the Inflated ROI

◆ makeRandomOperationsReproducible()

void aliceVision::makeRandomOperationsReproducible ( )

This function initializes the global state of random number generators that e.g. our tests depend on. This makes it possible to have exactly reproducible program runtime behavior without random changes. In order to introduce variation in execution, ALICEVISION_RANDOM_SEED environment variable can be set to an integer value.

This function is especially useful in tests where it allows to prevent random failures.

◆ Nullspace2()

template<typename TMat , typename TVec1 , typename TVec2 >

double aliceVision::Nullspace2	(	const TMat &	A,
		TVec1 &	x1,
		TVec2 &	x2
	)

inline

Solve the linear system Ax = 0 via SVD. Finds two solutions, x1 and x2, such that x1 is the best solution and x2 is the next best solution (in the L2 norm sense). Store the solution in x1 and x2, such that ||x|| = 1.0. Return the singular value corresponding to the solution x1. Destroys A and resizes x if necessary.

◆ P_from_KRt()

Mat34 aliceVision::P_from_KRt	(	const Mat3 &	K,
		const Mat3 &	R,
		const Vec3 &	t
	)

Compute P = K[R|t].

Returns: P

◆ parseAltitudeFromString()

double aliceVision::parseAltitudeFromString	(	const std::string &	alt,
		const std::string &	altRef
	)

Convert the string representation of the altitude in gps representation to a numeric value.

Parameters

[in]	alt	String containing the altitude.
[in]	altRef	String containing the reference for the altitude, if 1 the altitude will be interpreted as below the sea level. (https://www.awaresystems.be/imaging/tiff/tifftags/privateifd/gps/gpsaltituderef.html)

Returns: the altitude in meters over the sea level.

Exceptions

std::invalid_argument() if the data is not valid.

◆ parseGPSFromString()

double aliceVision::parseGPSFromString	(	const std::string &	gpsDegrees,
		const std::string &	gpsRef
	)

Convert the string representation of the gps position (latitude or longitude) to a numeric value.

Parameters

[in]	gpsDegrees	The string representation of the latitude or longitude in degrees.
[in]	gpsRef	A string giving the reference for the latitude or longitude (i.e. "N" or "S" for latitude, "E" or "W" for longitude). https://www.awaresystems.be/imaging/tiff/tifftags/privateifd/gps/gpslatituderef.html

Returns: The decimal degree representation of the position.

Exceptions

std::invalid_argument() if the data is not valid.

◆ pick()

template<typename T >

void aliceVision::pick	(	std::vector< T > &	result,
		const std::vector< T > &	input,
		const std::vector< typename std::vector< T >::size_type > &	selection
	)

Given a vector of element and a vector containing a selection of its indices, it returns a new vector containing only the selected elements of the original vector.

Template Parameters

T	The type of data contained in the vector.

Parameters

[out]	result	The output vector containing only the selected original elements.
[in]	input	The input vector.
[in]	selection	The vector containing the selection of elements of `input` through the indices specified in `selection`.

◆ rangeComputation()

bool aliceVision::rangeComputation	(	int &	rangeStart,
		int &	rangeEnd,
		int	rangeIteration,
		int	rangeBlocksCount,
		int	itemsCount
	)

Utility function to compute range of values to process Assuming we have itemsCount items in a container.

Parameters

[out]	rangeStart	is the first element index to process
[out]	rangeEnd	is the last element index to process (non included)
	rangeIteration	is the iteration number
	rangeBlocksCount	is the number of iterations launched in parallel

Returns: false if nothing has to be processed in this iteration

◆ relativeCameraMotion()

void aliceVision::relativeCameraMotion	(	const Mat3 &	R1,
		const Vec3 &	t1,
		const Mat3 &	R2,
		const Vec3 &	t2,
		Mat3 *	R,
		Vec3 *	t
	)

Compute the relative camera motion between two cameras. Given the motion parameters of two cameras, computes the motion parameters of the second one assuming the first one to be at the origin. If T1 and T2 are the camera motions, the computed relative motion is.

T = T2 T1^{-1}

◆ rotationDifference()

double aliceVision::rotationDifference	(	const Mat3 &	R1,
		const Mat3 &	R2
	)

Compute the angle between two rotation matrices.

Parameters

[in]	R1	The first rotation matrix.
[in]	R2	The second rotation matrix.

Returns: The angle between the two rotations as the angle of the rotation matrix R1*R2.transpose().

◆ SkewMatMinimal()

Mat23 aliceVision::SkewMatMinimal ( const Vec2 & x )

Create a minimal skew matrix from a 2d vector.

Parameters

[in] x A 2d vector whose 3rd coordinate is supposed to be 1.

Returns: The minimal ske matrix: [0, -1, x(1); 1, 0, -x(0);]

◆ SplitRange()

template<typename T >

void aliceVision::SplitRange	(	const T	range_start,
		const T	range_end,
		const int	nb_split,
		std::vector< T > &	d_range
	)

Split a range [ a ; b [ into a set of n ranges : [ a ; c1 [ U [ c1 ; c2 [ U ... U [ c(n-1) ; b [

Output range vector only store [ a , c1 , c2 , ... , b ]

if input range can't be split (range [a;b[ size is less than nb_split, only return [a;b[ range

Parameters

range_start	Start of range to split
range_end	End of range to split
nb_split	Number of desired split
d_range	Output splitted range

◆ tetrahedronSolidAngle()

double aliceVision::tetrahedronSolidAngle	(	const Point3d &	oa,
		const Point3d &	ob,
		const Point3d &	oc
	)

inline

Solid angle of a tetrahedron. It takes 3 vectors OA, OB, AC to define the solid angle define by the triangle ABC around the point O.

See also: The Solid Angle of a Plane Triangle, A. Van Oosterom, J. Strackee, 1983. DOI: 10.1109/TBME.1983.325207

◆ upscaleRange()

CUDA_HOST Range aliceVision::upscaleRange	(	const Range &	range,
		float	upscale
	)

inline

Upscale the given Range with the given upscale factor.

Parameters

[in]	range	the given Range
[in]	upscale	the upscale factor to apply

Returns: the upscaled Range

◆ upscaleROI()

CUDA_HOST ROI aliceVision::upscaleROI	(	const ROI &	roi,
		float	upscale
	)

inline

Upscale the given ROI with the given upscale factor.

Parameters

[in]	roi	the given ROI
[in]	upscale	the upscale factor to apply

Returns: the upscaled ROI

◆ WGS84ToCartesian()

Vec3 aliceVision::WGS84ToCartesian ( const Vec3 & gps )

Convert the position expressed in WGS84 reference frame (latitude, longitude, altitude) to the cartesian coordinates x, y, z.

Parameters

[in] gps A three dimensional vector containing the WGS84 coordinates latitude, longitude, altitude

Returns: A three dimensional vector containing the x, y and z coordinates.

Classes

Typedefs

Enumerations

Functions

Detailed Description

Function Documentation

◆ buildSubsetMatrix()

◆ checkImageROI()

◆ cheiralityTest()

◆ cheiralityTestAll()

◆ computeCoarseBB_Equidistant()

◆ convolveGaussian5x5()

◆ CrossProductMatrix()

◆ downscaleRange()

◆ downscaleROI()

◆ estimateTransformStructureFromEssential()

◆ EvaluteToGT()

◆ exhaustivePairs()

◆ getColorFromJetColorMap()

◆ getJacobian_AB_wrt_A()

◆ getJacobian_AB_wrt_B()

◆ getJacobian_At_wrt_A()

◆ getRGBFromJetColorMap()

◆ getRotationMagnitude()

◆ inflateRange()

◆ inflateROI()

◆ makeRandomOperationsReproducible()

◆ Nullspace2()

◆ P_from_KRt()

◆ parseAltitudeFromString()

◆ parseGPSFromString()

◆ pick()

◆ rangeComputation()

◆ relativeCameraMotion()

◆ rotationDifference()

◆ SkewMatMinimal()

◆ SplitRange()

◆ tetrahedronSolidAngle()

◆ upscaleRange()

◆ upscaleROI()

◆ WGS84ToCartesian()