g2o Namespace Reference

Namespaces
namespace	bal
namespace	ceres
namespace	cholmod
namespace	csparse
namespace	csparse_extension
namespace	internal
namespace	logging
namespace	opengl
namespace	tutorial
namespace	types_icp

Classes
class	AbstractHyperGraphElementCreator
	Abstract interface for allocating HyperGraphElement. More...
class	AbstractOptimizationAlgorithmCreator
	base for allocating an optimization algorithm More...
class	AbstractRobustKernelCreator
	Abstract interface for allocating a robust kernel. More...
struct	aligned_deleter
class	AutoDifferentiation
	Implementation of Automatic Differentiation for edges in g2o. More...
struct	BackBoneTreeAction
class	BaseBinaryEdge
class	BaseDynamicVertex
class	BaseEdge
class	BaseFixedSizedEdge
class	BaseProperty
class	BaseRobot
class	BaseSensor
class	BaseUnaryEdge
class	BaseVariableSizedEdge
	base class to represent an edge connecting an arbitrary number of nodes More...
class	BaseVertex
	Templatized BaseVertex. More...
class	BaseWorldObject
class	BinarySensor
class	BlockSolver
	Implementation of a solver operating on the blocks of the Hessian. More...
class	BlockSolverBase
	base for the block solvers with some basic function interfaces More...
struct	BlockSolverTraits
	traits to summarize the properties of the fixed size optimization problem More...
struct	BlockSolverTraits< Eigen::Dynamic, Eigen::Dynamic >
	traits to summarize the properties of the dynamic size optimization problem More...
class	Cache
class	CacheCamera
class	CacheContainer
class	CacheSE2Offset
	caching the offset related to a vertex More...
class	CacheSE3Offset
	caching the offset related to a vertex More...
class	CameraParameters
class	CholmodSolverCreator
class	ClosedFormCalibration
	Simultaneous calibration of the laser offset and the parameters of a differential drive. More...
struct	CmpPairFirst
struct	ColSort
class	CommandArgs
	Command line parsing of argc and argv. More...
class	CSparseSolverCreator
class	DataQueue
	a simple queue to store data and retrieve based on a timestamp More...
class	DenseSolverCreator
class	DlWrapper
	Loading libraries during run-time. More...
class	DrawAction
	draw actions More...
struct	dynamic_aligned_buffer
class	Edge_V_V_GICP
class	Edge_XYZ_VSC
	Point vertex, XYZ, is in types_sba. More...
struct	EdgeCreator
class	EdgeGICP
class	EdgeInverseSim3ProjectXYZ
struct	EdgeLabeler
class	EdgeLine2D
class	EdgeLine2DPointXY
class	EdgePlane
class	EdgePointXY
class	EdgePointXYZ
class	EdgeProjectP2MC
class	EdgeProjectP2SC
class	EdgeProjectPSI2UV
class	EdgeProjectXYZ2UV
class	EdgeProjectXYZ2UVU
class	EdgeSBACam
	3D edge between two SBAcam More...
class	EdgeSBAScale
	edge between two SBAcam that specifies the distance between them More...
class	EdgeSE2
	2D edge between two Vertex2 More...
class	EdgeSE2Line2D
class	EdgeSE2LotsOfXY
class	EdgeSE2OdomDifferentialCalib
class	EdgeSE2Offset
	Offset edge. More...
class	EdgeSE2PointXY
class	EdgeSE2PointXYBearing
class	EdgeSE2PointXYBearingWriteGnuplotAction
class	EdgeSE2PointXYCalib
	Landmark measurement that also calibrates an offset for the landmark measurement. More...
class	EdgeSE2PointXYOffset
	g2o edge from a track to a point node More...
class	EdgeSE2PointXYWriteGnuplotAction
class	EdgeSE2Prior
	Prior for a two D pose. More...
class	EdgeSE2PureCalib
	calibrate odometry and laser based on a set of measurements More...
class	EdgeSE2Segment2D
class	EdgeSE2Segment2DLine
class	EdgeSE2Segment2DPointLine
class	EdgeSE2SensorCalib
	scanmatch measurement that also calibrates an offset for the laser More...
class	EdgeSE2TwoPointsXY
class	EdgeSE2WriteGnuplotAction
class	EdgeSE2XYPrior
	Prior for a two D pose with constraints only in xy direction (like gps) More...
class	EdgeSE3
	Edge between two 3D pose vertices. More...
class	EdgeSE3Calib
	Landmark measurement that also calibrates an offset for the landmark measurement. More...
class	EdgeSE3Euler
	3D edge between two VertexSE3, uses the euler angle parameterization for the read/write functions only. More...
class	EdgeSE3Expmap
	6D edge between two Vertex6 More...
class	EdgeSE3Line3D
class	EdgeSE3LotsOfXYZ
class	EdgeSE3Offset
	Offset edge. More...
class	EdgeSE3PlaneSensorCalib
	plane measurement that also calibrates an offset for the sensor More...
class	EdgeSE3PointXYZ
	g2o edge from a track to a point node More...
class	EdgeSE3PointXYZDepth
class	EdgeSE3PointXYZDisparity
	edge from a track to a depth camera node using a disparity measurement More...
class	EdgeSE3Prior
	prior for an SE3 element More...
class	EdgeSE3ProjectXYZ
class	EdgeSE3ProjectXYZOnlyPose
class	EdgeSE3WriteGnuplotAction
	Output the pose-pose constraint to Gnuplot data file. More...
class	EdgeSE3XYZPrior
	Prior for a 3D pose with constraints only in xyz direction. More...
class	EdgeSim3
	7D edge between two Vertex7 More...
class	EdgeSim3ProjectXYZ
class	EdgeStereoSE3ProjectXYZ
class	EdgeStereoSE3ProjectXYZOnlyPose
struct	EdgeTypesCostFunction
class	EdgeXYPrior
class	EdgeXYZPrior
	prior for an XYZ vertex (VertexPointXYZ) More...
class	EigenSolverCreator
struct	EstimateAccessor
class	EstimateAccessorGet
class	EstimatePropagator
	propagation of an initial guess More...
class	EstimatePropagatorCost
	cost for traversing along active edges in the optimizer More...
class	EstimatePropagatorCostOdometry
	cost for traversing only odometry edges. More...
class	Factory
	create vertices and edges based on TAGs in, for example, a file More...
struct	ForceLinker
struct	G2OBatchStatistics
	statistics about the optimization More...
class	G2oQGLViewer
	OpenGL based viewer for the graph. More...
class	G2oSlamInterface
class	GaussianSampler
class	Gm2dlIO
	read / write gm2dl file into / out of a SparseOptimizer More...
class	GuiHyperGraphAction
	action which calls an GUI update after each iteration More...
struct	HyperDijkstra
class	HyperGraph
class	HyperGraphAction
	Abstract action that operates on an entire graph. More...
class	HyperGraphActionLibrary
	library of actions, indexed by the action name; More...
class	HyperGraphElementAction
	Abstract action that operates on a graph entity. More...
class	HyperGraphElementActionCollection
	collection of actions More...
class	HyperGraphElementCreator
	templatized creator class which creates graph elements More...
class	JacobianWorkspace
	provide memory workspace for computing the Jacobians More...
struct	LaserParameters
	parameters for a 2D range finder More...
struct	Line2D
class	Line3D
class	LinearSolver
	basic solver for Ax = b More...
class	LinearSolverCCS
	Solver with faster iterating structure for the linear matrix. More...
class	LinearSolverCholmod
	basic solver for Ax = b which has to reimplemented for different linear algebra libraries More...
class	LinearSolverCholmodOnline
	linear solver which allows to update the cholesky factor More...
class	LinearSolverCholmodOnlineInterface
	generic interface for the online solver More...
class	LinearSolverCSparse
	linear solver which uses CSparse More...
class	LinearSolverDense
	linear solver using dense cholesky decomposition More...
class	LinearSolverEigen
	linear solver which uses the sparse Cholesky solver from Eigen More...
class	LinearSolverPCG
	linear solver using PCG, pre-conditioner is block Jacobi More...
class	MarginalCovarianceCholesky
	computing the marginal covariance given a cholesky factor (lower triangle of the factor) More...
struct	MatrixElem
class	MatrixStructure
	representing the structure of a matrix in column compressed structure (only the upper triangular part of the matrix) More...
struct	MotionInformation
class	MotionMeasurement
	A 2D odometry measurement expressed as a transformation. More...
struct	OdomAndLaserMotion
class	OdomConvert
	convert between the different types of odometry measurements More...
class	OnlineEdgeSE2
class	OnlineEdgeSE3
class	OnlineVertexSE2
class	OnlineVertexSE3
class	OpenMPMutex
struct	OptimizableGraph
class	OptimizationAlgorithm
	Generic interface for a non-linear solver operating on a graph. More...
class	OptimizationAlgorithmDogleg
	Implementation of Powell's Dogleg Algorithm. More...
class	OptimizationAlgorithmFactory
	create solvers based on their short name More...
class	OptimizationAlgorithmGaussNewton
	Implementation of the Gauss Newton Algorithm. More...
class	OptimizationAlgorithmLevenberg
	Implementation of the Levenberg Algorithm. More...
struct	OptimizationAlgorithmProperty
	describe the properties of a solver More...
class	OptimizationAlgorithmWithHessian
	Base for solvers operating on the approximated Hessian, e.g., Gauss-Newton, Levenberg. More...
struct	OrthonormalLine3D
class	Parameter
class	ParameterCamera
	parameters for a camera More...
class	ParameterContainer
	map id to parameters More...
class	ParameterSE2Offset
	offset for an SE2 More...
class	ParameterSE3Offset
	offset for an SE3 More...
class	ParameterStereoCamera
	parameters for a camera More...
class	PCGSolverCreator
class	Plane3D
class	PointSensorParameters
class	Property
class	PropertyMap
	a collection of properties mapping from name to the property itself More...
class	RawLaser
	Raw laser measuerement. More...
class	RegisterActionProxy
class	RegisterOptimizationAlgorithmProxy
class	RegisterRobustKernelProxy
class	RegisterTypeProxy
class	Robot
class	RobotData
	data recorded by the robot More...
class	RobotLaser
	laser measurement obtained by a robot More...
class	RobustKernel
	base for all robust cost functions More...
class	RobustKernelCauchy
	Cauchy cost function. More...
class	RobustKernelCreator
	templatized creator class which creates graph elements More...
class	RobustKernelDCS
	Dynamic covariance scaling - DCS. More...
class	RobustKernelFactory
	create robust kernels based on their human readable name More...
class	RobustKernelFair
	Fair cost function. More...
class	RobustKernelGemanMcClure
	Geman-McClure cost function. More...
class	RobustKernelHuber
	Huber Cost Function. More...
class	RobustKernelPseudoHuber
	Pseudo Huber Cost Function. More...
class	RobustKernelSaturated
	Saturated cost function. More...
class	RobustKernelScaleDelta
	scale a robust kernel to another delta (window size) More...
class	RobustKernelTukey
	Tukey Cost Function. More...
class	RobustKernelWelsch
	Welsch cost function. More...
class	RunG2OViewer
	wrapper for running the g2o viewer More...
class	Sampler
class	SBACam
class	ScopedOpenMPMutex
	lock a mutex within a scope More...
class	ScopedTictoc
	Simplify calls to tictoc() for a whole scope. More...
class	ScopeTime
	Class to measure the time spent in a scope. More...
class	SE2
	represent SE2 More...
class	SE3Quat
class	SensorOdometry
class	SensorOdometry2D
class	SensorOdometry3D
class	SensorPointLine3D
class	SensorPointXY
class	SensorPointXYBearing
class	SensorPointXYOffset
class	SensorPointXYZ
class	SensorPointXYZDepth
class	SensorPointXYZDisparity
class	SensorPose2D
class	SensorPose3D
class	SensorPose3DOffset
class	SensorSE3Prior
class	SensorSegment2D
class	SensorSegment2DLine
class	SensorSegment2DPointLine
struct	SigmaPoint
struct	Sim3
class	SLAM2DLinearSolverCreator
class	Slam2DViewer
class	SleepThread
	helper for calling usleep on any system using Qt More...
class	Solver
	Generic interface for a sparse solver operating on a graph which solves one iteration of the linearized objective function. More...
class	SolverSLAM2DLinear
	Implementation of a linear approximation for 2D pose graph SLAM. More...
class	SparseBlockMatrix
	Sparse matrix which uses blocks. More...
class	SparseBlockMatrixCCS
	Sparse matrix which uses blocks. More...
class	SparseBlockMatrixDiagonal
	Sparse matrix which uses blocks on the diagonal. More...
class	SparseBlockMatrixHashMap
	Sparse matrix which uses blocks based on hash structures. More...
class	SparseOptimizer
class	SparseOptimizerIncremental
class	SparseOptimizerOnline
class	SparseOptimizerTerminateAction
	stop iterating based on the gain which is (oldChi - currentChi) / currentChi. More...
struct	Star
class	StructureOnlyCreator
class	StructureOnlySolver
	This is a solver for "structure-only" optimization". More...
class	ThetaTreeAction
	compute the initial guess of theta while traveling along the MST More...
struct	TicTocElement
	Internal structure of the tictoc profiling. More...
struct	TicTocInitializer
	helper for printing the struct at the end of the lifetime of the program More...
struct	TripletColSort
struct	TripletEntry
class	UnarySensor
struct	UniformCostFunction
class	VelocityMeasurement
	velocity measurement of a differential robot More...
class	VertexCam
	SBACam Vertex, (x,y,z,qw,qx,qy,qz) the parameterization for the increments constructed is a 6d vector (x,y,z,qx,qy,qz) (note that we leave out the w part of the quaternion. qw is assumed to be positive, otherwise there is an ambiguity in qx,qy,qz as a rotation. More...
class	VertexEllipse
	string ellipse to be attached to a vertex More...
class	VertexIntrinsics
	Vertex encoding the intrinsics of the camera fx, fy, cx, xy, baseline;. More...
class	VertexLine2D
class	VertexLine3D
class	VertexOdomDifferentialParams
class	VertexPlane
class	VertexPointXY
class	VertexPointXYWriteGnuplotAction
class	VertexPointXYZ
	Vertex for a tracked point in space. More...
class	VertexPointXYZWriteGnuplotAction
class	VertexSCam
	Stereo camera vertex, derived from SE3 class. Note that we use the actual pose of the vertex as its parameterization, rather than the transform from RW to camera coords. Uses static vars for camera params, so there is a single camera setup. More...
class	VertexSE2
	2D pose Vertex, (x,y,theta) More...
class	VertexSE2WriteGnuplotAction
class	VertexSE3
	3D pose Vertex, represented as an Isometry3 More...
class	VertexSE3Euler
	3D pose Vertex, (x,y,z,roll,pitch,yaw) the internal parameterization is the same as veretx_se3_quat. Only the read/write operations are rewritten to input/output euler angles. More...
class	VertexSE3Expmap
	SE3 Vertex parameterized internally with a transformation matrix and externally with its exponential map. More...
class	VertexSE3WriteGnuplotAction
	write the vertex to some Gnuplot data file More...
class	VertexSegment2D
class	VertexSegment2DWriteGnuplotAction
class	VertexSim3Expmap
	Sim3 Vertex, (x,y,z,qw,qx,qy,qz) the parameterization for the increments constructed is a 7d vector (x,y,z,qx,qy,qz) (note that we leave out the w part of the quaternion. More...
class	VertexTag
	string tag to be attached to a vertex More...
class	World
class	WorldObject
class	WriteGnuplotAction

Typedefs
typedef WorldObject< VertexSE2 >	WorldObjectSE2
typedef WorldObject< VertexPointXY >	WorldObjectPointXY
typedef WorldObject< VertexSegment2D >	WorldObjectSegment2D
typedef Robot< WorldObjectSE2 >	Robot2D
typedef WorldObject< VertexSE3 >	WorldObjectSE3
typedef WorldObject< VertexPointXYZ >	WorldObjectTrackXYZ
typedef WorldObject< VertexLine3D >	WorldObjectLine3D
typedef Robot< WorldObjectSE3 >	Robot3D
template<int D, typename E >
using	BaseMultiEdge = BaseVariableSizedEdge< D, E >
typedef std::vector< G2OBatchStatistics >	BatchStatisticsContainer
template<int p, int l>
using	BlockSolverPL = BlockSolver< BlockSolverTraits< p, l > >
using	BlockSolverX = BlockSolverPL< Eigen::Dynamic, Eigen::Dynamic >
using	BlockSolver_6_3 = BlockSolverPL< 6, 3 >
using	BlockSolver_7_3 = BlockSolverPL< 7, 3 >
using	BlockSolver_3_2 = BlockSolverPL< 3, 2 >
using	number_t = double
using	Vector2I = Eigen::Matrix< int, 2, 1, Eigen::ColMajor >
using	Vector3I = Eigen::Matrix< int, 3, 1, Eigen::ColMajor >
using	Vector4I = Eigen::Matrix< int, 4, 1, Eigen::ColMajor >
using	VectorXI = Eigen::Matrix< int, Eigen::Dynamic, 1, Eigen::ColMajor >
using	Vector2F = Eigen::Matrix< float, 2, 1, Eigen::ColMajor >
using	Vector3F = Eigen::Matrix< float, 3, 1, Eigen::ColMajor >
using	Vector4F = Eigen::Matrix< float, 4, 1, Eigen::ColMajor >
using	VectorXF = Eigen::Matrix< float, Eigen::Dynamic, 1, Eigen::ColMajor >
template<int N, typename T = double>
using	VectorN = Eigen::Matrix< T, N, 1, Eigen::ColMajor >
using	Vector2 = VectorN< 2 >
using	Vector3 = VectorN< 3 >
using	Vector4 = VectorN< 4 >
using	Vector6 = VectorN< 6 >
using	Vector7 = VectorN< 7 >
using	VectorX = VectorN< Eigen::Dynamic >
using	Matrix2I = Eigen::Matrix< int, 2, 2, Eigen::ColMajor >
using	Matrix3I = Eigen::Matrix< int, 3, 3, Eigen::ColMajor >
using	Matrix4I = Eigen::Matrix< int, 4, 4, Eigen::ColMajor >
using	MatrixXI = Eigen::Matrix< int, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor >
using	Matrix2F = Eigen::Matrix< float, 2, 2, Eigen::ColMajor >
using	Matrix3F = Eigen::Matrix< float, 3, 3, Eigen::ColMajor >
using	Matrix4F = Eigen::Matrix< float, 4, 4, Eigen::ColMajor >
using	MatrixXF = Eigen::Matrix< float, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor >
template<int N, typename T = double>
using	MatrixN = Eigen::Matrix< T, N, N, Eigen::ColMajor >
using	Matrix2 = MatrixN< 2 >
using	Matrix3 = MatrixN< 3 >
using	Matrix4 = MatrixN< 4 >
using	MatrixX = MatrixN< Eigen::Dynamic >
using	Isometry2 = Eigen::Transform< double, 2, Eigen::Isometry, Eigen::ColMajor >
using	Isometry3 = Eigen::Transform< double, 3, Eigen::Isometry, Eigen::ColMajor >
using	Affine2 = Eigen::Transform< double, 2, Eigen::Affine, Eigen::ColMajor >
using	Affine3 = Eigen::Transform< double, 3, Eigen::Affine, Eigen::ColMajor >
using	Rotation2D = Eigen::Rotation2D< double >
using	Quaternion = Eigen::Quaternion< double >
using	AngleAxis = Eigen::AngleAxis< double >
typedef std::vector< Parameter * >	ParameterVector
typedef std::shared_ptr< RobustKernel >	RobustKernelPtr
typedef SparseBlockMatrix< MatrixX >	SparseBlockMatrixX
using	MotionInformationVector = std::vector< MotionInformation >
typedef SigmaPoint< VectorXd >	MySigmaPoint
typedef std::multimap< OptimizableGraph::Vertex *, Star * >	VertexStarMultimap
typedef std::map< OptimizableGraph::Vertex *, Star * >	VertexStarMap
typedef std::set< Star * >	StarSet
typedef std::map< HyperGraph::Edge *, Star * >	EdgeStarMap
typedef void(*	ForceLinkFunction) (void)
typedef Property< int >	IntProperty
typedef Property< bool >	BoolProperty
typedef Property< float >	FloatProperty
typedef Property< double >	DoubleProperty
typedef Property< std::string >	StringProperty
typedef std::map< std::string, TicTocElement >	TicTocMap
using	seconds = std::chrono::duration< double >
typedef Eigen::Matrix< double, 6, 6 >	Matrix6
typedef Eigen::Matrix< double, 6, 4 >	Matrix6x4
typedef struct OrthonormalLine3D	OrthonormalLine3D

Enumerations
enum	CommandArgumentType {   CAT_DOUBLE , CAT_FLOAT , CAT_INT , CAT_STRING ,   CAT_BOOL , CAT_VECTOR_INT , CAT_VECTOR_DOUBLE }

Functions
void	findArguments (const std::string &option, vector< string > &args, int argc, char **argv)
void	loadStandardTypes (DlWrapper &dlTypesWrapper, int argc, char **argv)
void	loadStandardSolver (DlWrapper &dlSolverWrapper, int argc, char **argv)
bool	edgeAllVertsSameDim (OptimizableGraph::Edge *e, int dim)
bool	saveGnuplot (const std::string &gnudump, const OptimizableGraph &optimizer)
bool	saveGnuplot (const std::string &gnudump, const HyperGraph::VertexSet &vertices, const HyperGraph::EdgeSet &edges)
bool	dumpEdges (std::ostream &os, const OptimizableGraph &optimizer)
int	clipSegmentCircle (Eigen::Vector2d &p1, Eigen::Vector2d &p2, double r)
int	clipSegmentLine (Eigen::Vector2d &p1, Eigen::Vector2d &p2, double a, double b, double c)
int	clipSegmentFov (Eigen::Vector2d &p1, Eigen::Vector2d &p2, double min, double max)
Eigen::Vector2d	computeLineParameters (const Eigen::Vector2d &p1, const Eigen::Vector2d &p2)
std::ostream &	operator<< (std::ostream &os, const G2OBatchStatistics &st)
template<typename Type >
Type *	allocate_aligned (size_t n)
template<typename Type >
Type *	reallocate_aligned (Type *ptr, size_t newSize, size_t oldSize)
template<typename Type >
void	free_aligned (Type *block)
bool	operator< (const HyperDijkstra::AdjacencyMapEntry &a, const HyperDijkstra::AdjacencyMapEntry &b)
void	applyAction (HyperGraph *graph, HyperGraphElementAction *action, HyperGraphElementAction::Parameters *params, const std::string &typeName)
template<typename T >
void	release (T *obj)
template<class MatrixType >
std::ostream &	operator<< (std::ostream &, const SparseBlockMatrix< MatrixType > &m)
void	addOdometryCalibLinksDifferential (SparseOptimizer &optimizer, const DataQueue &odomData)
void	allocateSolverForSclam (SparseOptimizer &optimizer, bool levenberg)
double	activeVertexChi (const OptimizableGraph::Vertex *v)
void	constructEdgeStarMap (EdgeStarMap &esmap, StarSet &stars, bool low)
size_t	vertexEdgesInStar (HyperGraph::EdgeSet &eset, HyperGraph::Vertex *v, Star *s, EdgeStarMap &esmap)
void	starsInVertex (StarSet &stars, HyperGraph::Vertex *v, EdgeStarMap &esmap)
void	starsInEdge (StarSet &stars, HyperGraph::Edge *e, EdgeStarMap &esmap, HyperGraph::VertexSet &gauge)
void	assignHierarchicalEdges (StarSet &stars, EdgeStarMap &esmap, EdgeLabeler *labeler, EdgeCreator *creator, SparseOptimizer *optimizer, int minNumEdges, int maxIterations)
void	computeBorder (StarSet &stars, EdgeStarMap &hesmap)
void	computeSimpleStars (StarSet &stars, SparseOptimizer *optimizer, EdgeLabeler *labeler, EdgeCreator *creator, OptimizableGraph::Vertex *gauge_, std::string edgeTag, std::string vertexTag, int level, int step, int backboneIterations, int starIterations, double rejectionThreshold, bool debug)
void	findConnectedEdgesWithCostLimit (HyperGraph::EdgeSet &selected, HyperGraph::EdgeSet &border, HyperGraph::Edge *start, HyperDijkstra::CostFunction *cost, double maxEdgeCost, double comparisonConditioner)
static OptimizationAlgorithm *	createSolver (const std::string &solverName)
	G2O_USE_OPTIMIZATION_LIBRARY (cholmod)
	G2O_REGISTER_TYPE_GROUP (online)
	G2O_REGISTER_TYPE (ONLINE_EDGE_SE2, OnlineEdgeSE2)
	G2O_REGISTER_TYPE (ONLINE_VERTEX_SE2, OnlineVertexSE2)
	G2O_REGISTER_TYPE (ONLINE_VERTEX_SE3:QUAT, OnlineVertexSE3)
	G2O_REGISTER_TYPE (ONLINE_EDGE_SE3:QUAT, OnlineEdgeSE3)
static OptimizationAlgorithm *	createSolver (const std::string &fullSolverName)
	G2O_REGISTER_OPTIMIZATION_LIBRARY (cholmod)
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_var_cholmod, new CholmodSolverCreator(OptimizationAlgorithmProperty("gn_var_cholmod", "Gauss-Newton: Cholesky solver using CHOLMOD (variable blocksize)", "CHOLMOD", false, Eigen::Dynamic, Eigen::Dynamic)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_fix3_2_cholmod, new CholmodSolverCreator(OptimizationAlgorithmProperty("gn_fix3_2_cholmod", "Gauss-Newton: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_fix6_3_cholmod, new CholmodSolverCreator(OptimizationAlgorithmProperty("gn_fix6_3_cholmod", "Gauss-Newton: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_fix7_3_cholmod, new CholmodSolverCreator(OptimizationAlgorithmProperty("gn_fix7_3_cholmod", "Gauss-Newton: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 7, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_var_cholmod, new CholmodSolverCreator(OptimizationAlgorithmProperty("lm_var_cholmod", "Levenberg: Cholesky solver using CHOLMOD (variable blocksize)", "CHOLMOD", false, Eigen::Dynamic, Eigen::Dynamic)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_fix3_2_cholmod, new CholmodSolverCreator(OptimizationAlgorithmProperty("lm_fix3_2_cholmod", "Levenberg: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_fix6_3_cholmod, new CholmodSolverCreator(OptimizationAlgorithmProperty("lm_fix6_3_cholmod", "Levenberg: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_fix7_3_cholmod, new CholmodSolverCreator(OptimizationAlgorithmProperty("lm_fix7_3_cholmod", "Levenberg: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 7, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (dl_var_cholmod, new CholmodSolverCreator(OptimizationAlgorithmProperty("dl_var_cholmod", "Dogleg: Cholesky solver using CHOLMOD (variable blocksize)", "CHOLMOD", false, Eigen::Dynamic, Eigen::Dynamic)))
static OptimizationAlgorithm *	createSolver (const std::string &fullSolverName)
	G2O_REGISTER_OPTIMIZATION_LIBRARY (csparse)
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_var_csparse, new CSparseSolverCreator(OptimizationAlgorithmProperty("gn_var_csparse", "Gauss-Newton: Cholesky solver using CSparse (variable blocksize)", "CSparse", false, Eigen::Dynamic, Eigen::Dynamic)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_fix3_2_csparse, new CSparseSolverCreator(OptimizationAlgorithmProperty("gn_fix3_2_csparse", "Gauss-Newton: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_fix6_3_csparse, new CSparseSolverCreator(OptimizationAlgorithmProperty("gn_fix6_3_csparse", "Gauss-Newton: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_fix7_3_csparse, new CSparseSolverCreator(OptimizationAlgorithmProperty("gn_fix7_3_csparse", "Gauss-Newton: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 7, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_var_csparse, new CSparseSolverCreator(OptimizationAlgorithmProperty("lm_var_csparse", "Levenberg: Cholesky solver using CSparse (variable blocksize)", "CSparse", false, Eigen::Dynamic, Eigen::Dynamic)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_fix3_2_csparse, new CSparseSolverCreator(OptimizationAlgorithmProperty("lm_fix3_2_csparse", "Levenberg: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_fix6_3_csparse, new CSparseSolverCreator(OptimizationAlgorithmProperty("lm_fix6_3_csparse", "Levenberg: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_fix7_3_csparse, new CSparseSolverCreator(OptimizationAlgorithmProperty("lm_fix7_3_csparse", "Levenberg: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 7, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (dl_var_csparse, new CSparseSolverCreator(OptimizationAlgorithmProperty("dl_var_csparse", "Dogleg: Cholesky solver using CSparse (variable blocksize)", "CSparse", false, Eigen::Dynamic, Eigen::Dynamic)))
static OptimizationAlgorithm *	createSolver (const std::string &fullSolverName)
	G2O_REGISTER_OPTIMIZATION_LIBRARY (dense)
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_dense, new DenseSolverCreator(OptimizationAlgorithmProperty("gn_dense", "Gauss-Newton: Dense solver (variable blocksize)", "Dense", false, Eigen::Dynamic, Eigen::Dynamic)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_dense3_2, new DenseSolverCreator(OptimizationAlgorithmProperty("gn_dense3_2", "Gauss-Newton: Dense solver (fixed blocksize)", "Dense", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_dense6_3, new DenseSolverCreator(OptimizationAlgorithmProperty("gn_dense6_3", "Gauss-Newton: Dense solver (fixed blocksize)", "Dense", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_dense7_3, new DenseSolverCreator(OptimizationAlgorithmProperty("gn_dense7_3", "Gauss-Newton: Dense solver (fixed blocksize)", "Dense", true, 7, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_dense, new DenseSolverCreator(OptimizationAlgorithmProperty("lm_dense", "Levenberg: Dense solver (variable blocksize)", "Dense", false, -1, -1)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_dense3_2, new DenseSolverCreator(OptimizationAlgorithmProperty("lm_dense3_2", "Levenberg: Dense solver (fixed blocksize)", "Dense", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_dense6_3, new DenseSolverCreator(OptimizationAlgorithmProperty("lm_dense6_3", "Levenberg: Dense solver (fixed blocksize)", "Dense", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_dense7_3, new DenseSolverCreator(OptimizationAlgorithmProperty("lm_dense7_3", "Levenberg: Dense solver (fixed blocksize)", "Dense", true, 7, 3)))
static OptimizationAlgorithm *	createSolver (const std::string &fullSolverName)
	G2O_REGISTER_OPTIMIZATION_LIBRARY (eigen)
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_var, new EigenSolverCreator(OptimizationAlgorithmProperty("gn_var", "Gauss-Newton: Cholesky solver using Eigen's Sparse Cholesky methods (variable blocksize)", "Eigen", false, Eigen::Dynamic, Eigen::Dynamic)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_fix3_2, new EigenSolverCreator(OptimizationAlgorithmProperty("gn_fix3_2", "Gauss-Newton: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_fix6_3, new EigenSolverCreator(OptimizationAlgorithmProperty("gn_fix6_3", "Gauss-Newton: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_fix7_3, new EigenSolverCreator(OptimizationAlgorithmProperty("gn_fix7_3", "Gauss-Newton: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 7, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_var, new EigenSolverCreator(OptimizationAlgorithmProperty("lm_var", "Levenberg: Cholesky solver using Eigen's Sparse Cholesky methods (variable blocksize)", "Eigen", false, Eigen::Dynamic, Eigen::Dynamic)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_fix3_2, new EigenSolverCreator(OptimizationAlgorithmProperty("lm_fix3_2", "Levenberg: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_fix6_3, new EigenSolverCreator(OptimizationAlgorithmProperty("lm_fix6_3", "Levenberg: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_fix7_3, new EigenSolverCreator(OptimizationAlgorithmProperty("lm_fix7_3", "Levenberg: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 7, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (dl_var, new EigenSolverCreator(OptimizationAlgorithmProperty("dl_var", "Dogleg: Cholesky solver using Eigen's Sparse Cholesky methods (variable blocksize)", "Eigen", false, Eigen::Dynamic, Eigen::Dynamic)))
static OptimizationAlgorithm *	createSolver (const std::string &fullSolverName)
	G2O_REGISTER_OPTIMIZATION_LIBRARY (pcg)
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_pcg, new PCGSolverCreator(OptimizationAlgorithmProperty("gn_pcg", "Gauss-Newton: PCG solver using block-Jacobi pre-conditioner " "(variable blocksize)", "PCG", false, Eigen::Dynamic, Eigen::Dynamic)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_pcg3_2, new PCGSolverCreator(OptimizationAlgorithmProperty("gn_pcg3_2", "Gauss-Newton: PCG solver using block-Jacobi " "pre-conditioner (fixed blocksize)", "PCG", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_pcg6_3, new PCGSolverCreator(OptimizationAlgorithmProperty("gn_pcg6_3", "Gauss-Newton: PCG solver using block-Jacobi " "pre-conditioner (fixed blocksize)", "PCG", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (gn_pcg7_3, new PCGSolverCreator(OptimizationAlgorithmProperty("gn_pcg7_3", "Gauss-Newton: PCG solver using block-Jacobi " "pre-conditioner (fixed blocksize)", "PCG", true, 7, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_pcg, new PCGSolverCreator(OptimizationAlgorithmProperty("lm_pcg", "Levenberg: PCG solver using block-Jacobi pre-conditioner " "(variable blocksize)", "PCG", false, Eigen::Dynamic, Eigen::Dynamic)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_pcg3_2, new PCGSolverCreator(OptimizationAlgorithmProperty("lm_pcg3_2", "Levenberg: PCG solver using block-Jacobi pre-conditioner " "(fixed blocksize)", "PCG", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_pcg6_3, new PCGSolverCreator(OptimizationAlgorithmProperty("lm_pcg6_3", "Levenberg: PCG solver using block-Jacobi pre-conditioner " "(fixed blocksize)", "PCG", true, 6, 3)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (lm_pcg7_3, new PCGSolverCreator(OptimizationAlgorithmProperty("lm_pcg7_3", "Levenberg: PCG solver using block-Jacobi pre-conditioner " "(fixed blocksize)", "PCG", true, 7, 3)))
static OptimizationAlgorithm *	createSolver (const std::string &fullSolverName)
	G2O_REGISTER_OPTIMIZATION_LIBRARY (slam2d_linear)
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (2dlinear, new SLAM2DLinearSolverCreator(OptimizationAlgorithmProperty("2dlinear", "Solve Orientation + Gauss-Newton: Works only on 2D pose graphs!!", "Eigen", false, 3, 3)))
static OptimizationAlgorithm *	createSolver (const std::string &fullSolverName)
	G2O_REGISTER_OPTIMIZATION_LIBRARY (structure_only)
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (structure_only_2, new StructureOnlyCreator(OptimizationAlgorithmProperty("structure_only_2", "Optimize the landmark poses (2D)", "Eigen", true, 3, 2)))
	G2O_REGISTER_OPTIMIZATION_ALGORITHM (structure_only_3, new StructureOnlyCreator(OptimizationAlgorithmProperty("structure_only_3", "Optimize the landmark poses (3D)", "Eigen", true, 6, 3)))
std::string	getFileExtension (const std::string &filename)
std::string	getPureFilename (const std::string &filename)
std::string	getBasename (const std::string &filename)
std::string	getDirname (const std::string &filename)
std::string	changeFileExtension (const std::string &filename, const std::string &newExt, bool stripDot)
bool	fileExists (const char *filename)
std::vector< std::string >	getFilesByPattern (const char *pattern)
constexpr double	cst (long double v)
constexpr double	const_pi ()
template<typename T >
T	square (T x)
template<typename T >
T	hypot (T x, T y)
template<typename T >
T	hypot_sqr (T x, T y)
double	deg2rad (double degree)
double	rad2deg (double rad)
double	normalize_theta (double theta)
double	inverse_theta (double th)
double	average_angle (double theta1, double theta2)
template<typename T >
int	sign (T x)
template<typename T >
T	clamp (T l, T x, T u)
template<typename T >
T	wrap (T l, T x, T u)
bool	arrayHasNaN (const double *array, int size, int *nanIndex=0)
static std::normal_distribution< double >	_univariateSampler (0., 1.)
double	sampleUniform (double min, double max, std::mt19937 *generator)
double	sampleGaussian (std::mt19937 *generator)
static bool	writeTripletEntries (const std::string &filename, int rows, int cols, const std::vector< TripletEntry > &triplets)
bool	writeVector (const string &filename, const double *v, int n)
bool	writeCCSMatrix (const string &filename, int rows, int cols, const int *Ap, const int *Ai, const double *Ax, bool upperTriangleSymmetric)
bool	writeTripletMatrix (const std::string &filename, int nz, int rows, int cols, const int *Ai, const int *Aj, const double *Ax, bool upperTriangleSymmetric)
G2O_STUFF_API bool	writeVector (const std::string &filename, const double *v, int n)
G2O_STUFF_API bool	writeCCSMatrix (const std::string &filename, int rows, int cols, const int *p, const int *i, const double *v, bool upperTriangleSymmetric=true)
std::string	trim (const std::string &s)
std::string	trimLeft (const std::string &s)
std::string	trimRight (const std::string &s)
std::string	strToLower (const std::string &s)
std::string	strToUpper (const std::string &s)
std::string	formatString (const char *fmt,...)
int	strPrintf (std::string &str, const char *fmt,...)
std::string	strExpandFilename (const std::string &filename)
std::vector< std::string >	strSplit (const std::string &str, const std::string &delimiters)
bool	strStartsWith (const std::string &s, const std::string &start)
bool	strEndsWith (const std::string &s, const std::string &end)
int	readLine (std::istream &is, std::stringstream &currentLine)
void	skipLine (std::istream &is)
template<typename OutputIterator >
OutputIterator	readInts (const char *str, OutputIterator out)
template<typename OutputIterator >
OutputIterator	readFloats (const char *str, OutputIterator out)
template<typename T >
bool	convertString (const std::string &s, T &x, bool failIfLeftoverChars=true)
template<typename T >
T	stringToType (const std::string &s, bool failIfLeftoverChars=true)
double	tictoc (const char *algorithmPart)
	Profile the timing of certain parts of your algorithm.
double	get_monotonic_time ()
double	get_time ()
template<typename F , typename T , std::size_t... I>
void	tuple_apply_i_ (F &&f, T &t, int i, std::index_sequence< I... >)
template<typename F , typename T >
void	tuple_apply_i (F &&f, T &t, int i)
template<class SampleType , class CovarianceType >
bool	sampleUnscented (std::vector< SigmaPoint< SampleType > > &sigmaPoints, const SampleType &mean, const CovarianceType &covariance)
template<class SampleType , class CovarianceType >
void	reconstructGaussian (SampleType &mean, CovarianceType &covariance, const std::vector< SigmaPoint< SampleType > > &sigmaPoints)
	G2O_REGISTER_TYPE_GROUP (data)
	G2O_REGISTER_TYPE (VERTEX_TAG, VertexTag)
	G2O_REGISTER_TYPE (ROBOTLASER1, RobotLaser)
	G2O_REGISTER_TYPE (VERTEX_ELLIPSE, VertexEllipse)
	G2O_REGISTER_TYPE_GROUP (icp)
	G2O_REGISTER_TYPE (EDGE_V_V_GICP, Edge_V_V_GICP)
	G2O_ATTRIBUTE_CONSTRUCTOR (init_icp_types)
std::ostream &	operator<< (std::ostream &out_str, const SBACam &cam)
	G2O_REGISTER_TYPE_GROUP (sba)
	G2O_REGISTER_TYPE (VERTEX_CAM, VertexCam)
	G2O_REGISTER_TYPE (VERTEX_INTRINSICS, VertexIntrinsics)
	G2O_REGISTER_TYPE (EDGE_PROJECT_P2MC, EdgeProjectP2MC)
	G2O_REGISTER_TYPE (EDGE_PROJECT_P2SC, EdgeProjectP2SC)
	G2O_REGISTER_TYPE (EDGE_CAM, EdgeSBACam)
	G2O_REGISTER_TYPE (EDGE_SCALE, EdgeSBAScale)
	G2O_REGISTER_TYPE_GROUP (expmap)
	G2O_REGISTER_TYPE (VERTEX_SE3:EXPMAP, VertexSE3Expmap)
	G2O_REGISTER_TYPE (EDGE_SE3:EXPMAP, EdgeSE3Expmap)
	G2O_REGISTER_TYPE (EDGE_PROJECT_XYZ2UV:EXPMAP, EdgeProjectXYZ2UV)
	G2O_REGISTER_TYPE (EDGE_PROJECT_XYZ2UVU:EXPMAP, EdgeProjectXYZ2UVU)
	G2O_REGISTER_TYPE (EDGE_SE3_PROJECT_XYZ:EXPMAP, EdgeSE3ProjectXYZ)
	G2O_REGISTER_TYPE (EDGE_SE3_PROJECT_XYZONLYPOSE:EXPMAP, EdgeSE3ProjectXYZOnlyPose)
	G2O_REGISTER_TYPE (EDGE_STEREO_SE3_PROJECT_XYZ:EXPMAP, EdgeStereoSE3ProjectXYZ)
	G2O_REGISTER_TYPE (EDGE_STEREO_SE3_PROJECT_XYZONLYPOSE:EXPMAP, EdgeStereoSE3ProjectXYZOnlyPose)
	G2O_REGISTER_TYPE (PARAMS_CAMERAPARAMETERS, CameraParameters)
	G2O_USE_TYPE_GROUP (slam2d)
	G2O_REGISTER_TYPE_GROUP (sclam)
	G2O_REGISTER_TYPE (VERTEX_ODOM_DIFFERENTIAL, VertexOdomDifferentialParams)
	G2O_REGISTER_TYPE (EDGE_SE2_CALIB, EdgeSE2SensorCalib)
	G2O_REGISTER_TYPE (EDGE_SE2_ODOM_DIFFERENTIAL_CALIB, EdgeSE2OdomDifferentialCalib)
std::ostream &	operator<< (std::ostream &out_str, const Sim3 &sim3)
	G2O_USE_TYPE_GROUP (sba)
	G2O_REGISTER_TYPE_GROUP (sim3)
	G2O_REGISTER_TYPE (VERTEX_SIM3 :EXPMAP, VertexSim3Expmap)
	G2O_REGISTER_TYPE (EDGE_SIM3 :EXPMAP, EdgeSim3)
	G2O_REGISTER_TYPE (EDGE_PROJECT_SIM3_XYZ :EXPMAP, EdgeSim3ProjectXYZ)
	G2O_REGISTER_TYPE (EDGE_PROJECT_INVERSE_SIM3_XYZ :EXPMAP, EdgeInverseSim3ProjectXYZ)
	G2O_REGISTER_TYPE_GROUP (slam2d)
	G2O_REGISTER_TYPE (VERTEX_SE2, VertexSE2)
	G2O_REGISTER_TYPE (VERTEX_XY, VertexPointXY)
	G2O_REGISTER_TYPE (PARAMS_SE2OFFSET, ParameterSE2Offset)
	G2O_REGISTER_TYPE (CACHE_SE2_OFFSET, CacheSE2Offset)
	G2O_REGISTER_TYPE (EDGE_PRIOR_SE2, EdgeSE2Prior)
	G2O_REGISTER_TYPE (EDGE_PRIOR_SE2_XY, EdgeSE2XYPrior)
	G2O_REGISTER_TYPE (EDGE_SE2, EdgeSE2)
	G2O_REGISTER_TYPE (EDGE_SE2_XY, EdgeSE2PointXY)
	G2O_REGISTER_TYPE (EDGE_BEARING_SE2_XY, EdgeSE2PointXYBearing)
	G2O_REGISTER_TYPE (EDGE_SE2_XY_CALIB, EdgeSE2PointXYCalib)
	G2O_REGISTER_TYPE (EDGE_SE2_OFFSET, EdgeSE2Offset)
	G2O_REGISTER_TYPE (EDGE_SE2_POINTXY_OFFSET, EdgeSE2PointXYOffset)
	G2O_REGISTER_TYPE (EDGE_POINTXY, EdgePointXY)
	G2O_REGISTER_TYPE (EDGE_SE2_TWOPOINTSXY, EdgeSE2TwoPointsXY)
	G2O_REGISTER_TYPE (EDGE_SE2_LOTSOFXY, EdgeSE2LotsOfXY)
	G2O_REGISTER_TYPE (EDGE_PRIOR_XY, EdgeXYPrior)
	G2O_REGISTER_ACTION (VertexSE2WriteGnuplotAction)
	G2O_REGISTER_ACTION (VertexPointXYWriteGnuplotAction)
	G2O_REGISTER_ACTION (EdgeSE2WriteGnuplotAction)
	G2O_REGISTER_ACTION (EdgeSE2PointXYWriteGnuplotAction)
	G2O_REGISTER_ACTION (EdgeSE2PointXYBearingWriteGnuplotAction)
Line2D	operator* (const SE2 &t, const Line2D &l)
	G2O_REGISTER_TYPE_GROUP (slam2d_segment)
	G2O_REGISTER_TYPE (VERTEX_SEGMENT2D, VertexSegment2D)
	G2O_REGISTER_TYPE (VERTEX_LINE2D, VertexLine2D)
	G2O_REGISTER_TYPE (EDGE_SE2_SEGMENT2D, EdgeSE2Segment2D)
	G2O_REGISTER_TYPE (EDGE_SE2_SEGMENT2D_LINE, EdgeSE2Segment2DLine)
	G2O_REGISTER_TYPE (EDGE_SE2_SEGMENT2D_POINTLINE, EdgeSE2Segment2DPointLine)
	G2O_REGISTER_TYPE (EDGE_SE2_LINE2D, EdgeSE2Line2D)
	G2O_REGISTER_TYPE (EDGE_LINE2D, EdgeLine2D)
	G2O_REGISTER_TYPE (EDGE_LINE2D_POINTXY, EdgeLine2DPointXY)
G2O_TYPES_SLAM3D_API Matrix3	skew (const Vector3 &v)
G2O_TYPES_SLAM3D_API Vector3	deltaR (const Matrix3 &R)
G2O_TYPES_SLAM3D_API Vector2	project (const Vector3 &)
G2O_TYPES_SLAM3D_API Vector3	project (const Vector4 &)
G2O_TYPES_SLAM3D_API Vector3	unproject (const Vector2 &)
G2O_TYPES_SLAM3D_API Vector4	unproject (const Vector3 &)
std::ostream &	operator<< (std::ostream &out_str, const SE3Quat &se3)
	G2O_REGISTER_TYPE_GROUP (slam3d)
	G2O_REGISTER_TYPE (VERTEX_SE3:QUAT, VertexSE3)
	G2O_REGISTER_TYPE (EDGE_SE3:QUAT, EdgeSE3)
	G2O_REGISTER_TYPE (VERTEX_TRACKXYZ, VertexPointXYZ)
	G2O_REGISTER_TYPE (PARAMS_SE3OFFSET, ParameterSE3Offset)
	G2O_REGISTER_TYPE (EDGE_SE3_TRACKXYZ, EdgeSE3PointXYZ)
	G2O_REGISTER_TYPE (EDGE_SE3_PRIOR, EdgeSE3Prior)
	G2O_REGISTER_TYPE (EDGE_SE3_XYZ_PRIOR, EdgeSE3XYZPrior)
	G2O_REGISTER_TYPE (CACHE_SE3_OFFSET, CacheSE3Offset)
	G2O_REGISTER_TYPE (EDGE_SE3_OFFSET, EdgeSE3Offset)
	G2O_REGISTER_TYPE (PARAMS_CAMERACALIB, ParameterCamera)
	G2O_REGISTER_TYPE (PARAMS_STEREOCAMERACALIB, ParameterStereoCamera)
	G2O_REGISTER_TYPE (CACHE_CAMERA, CacheCamera)
	G2O_REGISTER_TYPE (EDGE_PROJECT_DISPARITY, EdgeSE3PointXYZDisparity)
	G2O_REGISTER_TYPE (EDGE_PROJECT_DEPTH, EdgeSE3PointXYZDepth)
	G2O_REGISTER_TYPE (EDGE_POINTXYZ, EdgePointXYZ)
	G2O_REGISTER_TYPE (EDGE_POINTXYZ_PRIOR, EdgeXYZPrior)
	G2O_REGISTER_ACTION (VertexSE3WriteGnuplotAction)
	G2O_REGISTER_ACTION (VertexPointXYZWriteGnuplotAction)
	G2O_REGISTER_ACTION (EdgeSE3WriteGnuplotAction)
static void	jac_quat3_euler3 (Eigen::Matrix< double, 6, 6, Eigen::ColMajor > &J, const Isometry3 &t)
static Matrix3	_skew (const Vector3 &t)
Line3D	operator* (const Isometry3 &t, const Line3D &line)
Plane3D	operator* (const Isometry3 &t, const Plane3D &plane)
	G2O_REGISTER_TYPE_GROUP (slam3d_addons)
	G2O_REGISTER_TYPE (VERTEX3, VertexSE3Euler)
	G2O_REGISTER_TYPE (EDGE3, EdgeSE3Euler)
	G2O_REGISTER_TYPE (VERTEX_PLANE, VertexPlane)
	G2O_REGISTER_TYPE (EDGE_SE3_PLANE_CALIB, EdgeSE3PlaneSensorCalib)
	G2O_REGISTER_TYPE (VERTEX_LINE3D, VertexLine3D)
	G2O_REGISTER_TYPE (EDGE_SE3_LINE3D, EdgeSE3Line3D)
	G2O_REGISTER_TYPE (EDGE_PLANE, EdgePlane)
	G2O_REGISTER_TYPE (EDGE_SE3_CALIB, EdgeSE3Calib)
	G2O_ATTRIBUTE_CONSTRUCTOR (init_slam3d_addons_types)

Variables
class G2O_CORE_API	OptimizationAlgorithm
static const double	INFORMATION_SCALING_ODOMETRY = 100
static std::uniform_real_distribution< double >	_uniformReal
static std::mt19937	_gen_real

Detailed Description

Basic types definitions for SBA translation to HChol

Camera nodes use camera pose in real world v3 position normalized quaternion rotation

Point nodes: v3 position

Typedef Documentation

Affine2

using g2o::Affine2 = typedef Eigen::Transform<double, 2, Eigen::Affine, Eigen::ColMajor>

Definition at line 78 of file eigen_types.h.

Affine3

using g2o::Affine3 = typedef Eigen::Transform<double, 3, Eigen::Affine, Eigen::ColMajor>

Definition at line 79 of file eigen_types.h.

AngleAxis

using g2o::AngleAxis = typedef Eigen::AngleAxis<double>

Definition at line 82 of file eigen_types.h.

BaseMultiEdge

template<int D, typename E >

using g2o::BaseMultiEdge = typedef BaseVariableSizedEdge<D, E>

Definition at line 35 of file base_multi_edge.h.

BatchStatisticsContainer

typedef std::vector<G2OBatchStatistics> g2o::BatchStatisticsContainer

Definition at line 86 of file batch_stats.h.

BlockSolver_3_2

using g2o::BlockSolver_3_2 = typedef BlockSolverPL<3, 2>

Definition at line 200 of file block_solver.h.

BlockSolver_6_3

using g2o::BlockSolver_6_3 = typedef BlockSolverPL<6, 3>

Definition at line 194 of file block_solver.h.

BlockSolver_7_3

using g2o::BlockSolver_7_3 = typedef BlockSolverPL<7, 3>

Definition at line 197 of file block_solver.h.

BlockSolverPL

template<int p, int l>

using g2o::BlockSolverPL = typedef BlockSolver<BlockSolverTraits<p, l> >

Definition at line 188 of file block_solver.h.

BlockSolverX

using g2o::BlockSolverX = typedef BlockSolverPL<Eigen::Dynamic, Eigen::Dynamic>

Definition at line 191 of file block_solver.h.

BoolProperty

typedef Property<bool> g2o::BoolProperty

Definition at line 149 of file property.h.

DoubleProperty

typedef Property<double> g2o::DoubleProperty

Definition at line 151 of file property.h.

EdgeStarMap

typedef std::map<HyperGraph::Edge*, Star*> g2o::EdgeStarMap

Definition at line 101 of file star.h.

FloatProperty

typedef Property<float> g2o::FloatProperty

Definition at line 150 of file property.h.

ForceLinkFunction

typedef void(* g2o::ForceLinkFunction) (void)

The following two functions are used to force linkage with static libraries.

Definition at line 181 of file misc.h.

IntProperty

typedef Property<int> g2o::IntProperty

Definition at line 148 of file property.h.

Isometry2

using g2o::Isometry2 = typedef Eigen::Transform<double, 2, Eigen::Isometry, Eigen::ColMajor>

Definition at line 76 of file eigen_types.h.

Isometry3

using g2o::Isometry3 = typedef Eigen::Transform<double, 3, Eigen::Isometry, Eigen::ColMajor>

Definition at line 77 of file eigen_types.h.

Matrix2

using g2o::Matrix2 = typedef MatrixN<2>

Definition at line 71 of file eigen_types.h.

Matrix2F

using g2o::Matrix2F = typedef Eigen::Matrix<float, 2, 2, Eigen::ColMajor>

Definition at line 63 of file eigen_types.h.

Matrix2I

using g2o::Matrix2I = typedef Eigen::Matrix<int, 2, 2, Eigen::ColMajor>

Definition at line 57 of file eigen_types.h.

Matrix3

using g2o::Matrix3 = typedef MatrixN<3>

Definition at line 72 of file eigen_types.h.

Matrix3F

using g2o::Matrix3F = typedef Eigen::Matrix<float, 3, 3, Eigen::ColMajor>

Definition at line 64 of file eigen_types.h.

Matrix3I

using g2o::Matrix3I = typedef Eigen::Matrix<int, 3, 3, Eigen::ColMajor>

Definition at line 58 of file eigen_types.h.

Matrix4

using g2o::Matrix4 = typedef MatrixN<4>

Definition at line 73 of file eigen_types.h.

Matrix4F

using g2o::Matrix4F = typedef Eigen::Matrix<float, 4, 4, Eigen::ColMajor>

Definition at line 65 of file eigen_types.h.

Matrix4I

using g2o::Matrix4I = typedef Eigen::Matrix<int, 4, 4, Eigen::ColMajor>

Definition at line 59 of file eigen_types.h.

Matrix6

typedef Eigen::Matrix<double, 6, 6> g2o::Matrix6

Definition at line 38 of file line3d.h.

Matrix6x4

typedef Eigen::Matrix<double, 6, 4> g2o::Matrix6x4

Definition at line 39 of file line3d.h.

MatrixN

template<int N, typename T = double>

using g2o::MatrixN = typedef Eigen::Matrix<T, N, N, Eigen::ColMajor>

Definition at line 70 of file eigen_types.h.

MatrixX

using g2o::MatrixX = typedef MatrixN<Eigen::Dynamic>

Definition at line 74 of file eigen_types.h.

MatrixXF

using g2o::MatrixXF = typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>

Definition at line 66 of file eigen_types.h.

MatrixXI

using g2o::MatrixXI = typedef Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>

Definition at line 60 of file eigen_types.h.

MotionInformationVector

using g2o::MotionInformationVector = typedef std::vector<MotionInformation>

Definition at line 44 of file motion_information.h.

MySigmaPoint

typedef SigmaPoint<VectorXd> g2o::MySigmaPoint

Definition at line 39 of file edge_labeler.cpp.

number_t

using g2o::number_t = typedef double

Definition at line 36 of file eigen_types.h.

OrthonormalLine3D

typedef struct OrthonormalLine3D g2o::OrthonormalLine3D

Definition at line 51 of file line3d.h.

ParameterVector

typedef std::vector<Parameter*> g2o::ParameterVector

Definition at line 54 of file parameter.h.

Quaternion

using g2o::Quaternion = typedef Eigen::Quaternion<double>

Definition at line 81 of file eigen_types.h.

Robot2D

typedef Robot<WorldObjectSE2> g2o::Robot2D

Definition at line 42 of file simulator2d_base.h.

Robot3D

typedef Robot<WorldObjectSE3> g2o::Robot3D

Definition at line 42 of file simulator3d_base.h.

RobustKernelPtr

typedef std::shared_ptr<RobustKernel> g2o::RobustKernelPtr

Definition at line 73 of file robust_kernel.h.

Rotation2D

using g2o::Rotation2D = typedef Eigen::Rotation2D<double>

Definition at line 80 of file eigen_types.h.

seconds

using g2o::seconds = typedef std::chrono::duration<double>

Definition at line 77 of file timeutil.h.

SparseBlockMatrixX

typedef SparseBlockMatrix<MatrixX> g2o::SparseBlockMatrixX

Definition at line 270 of file sparse_block_matrix.h.

StarSet

typedef std::set<Star*> g2o::StarSet

Definition at line 100 of file star.h.

StringProperty

typedef Property<std::string> g2o::StringProperty

Definition at line 152 of file property.h.

TicTocMap

typedef std::map<std::string, TicTocElement> g2o::TicTocMap

Definition at line 66 of file tictoc.cpp.

Vector2

using g2o::Vector2 = typedef VectorN<2>

Definition at line 50 of file eigen_types.h.

Vector2F

using g2o::Vector2F = typedef Eigen::Matrix<float, 2, 1, Eigen::ColMajor>

Definition at line 43 of file eigen_types.h.

Vector2I

using g2o::Vector2I = typedef Eigen::Matrix<int, 2, 1, Eigen::ColMajor>

Definition at line 38 of file eigen_types.h.

Vector3

using g2o::Vector3 = typedef VectorN<3>

Definition at line 51 of file eigen_types.h.

Vector3F

using g2o::Vector3F = typedef Eigen::Matrix<float, 3, 1, Eigen::ColMajor>

Definition at line 44 of file eigen_types.h.

Vector3I

using g2o::Vector3I = typedef Eigen::Matrix<int, 3, 1, Eigen::ColMajor>

Definition at line 39 of file eigen_types.h.

Vector4

using g2o::Vector4 = typedef VectorN<4>

Definition at line 52 of file eigen_types.h.

Vector4F

using g2o::Vector4F = typedef Eigen::Matrix<float, 4, 1, Eigen::ColMajor>

Definition at line 45 of file eigen_types.h.

Vector4I

using g2o::Vector4I = typedef Eigen::Matrix<int, 4, 1, Eigen::ColMajor>

Definition at line 40 of file eigen_types.h.

Vector6

typedef Eigen::Matrix< double, 6, 1 > g2o::Vector6

Definition at line 53 of file eigen_types.h.

Vector7

using g2o::Vector7 = typedef VectorN<7>

Definition at line 54 of file eigen_types.h.

VectorN

template<int N, typename T = double>

using g2o::VectorN = typedef Eigen::Matrix<T, N, 1, Eigen::ColMajor>

Definition at line 49 of file eigen_types.h.

VectorX

using g2o::VectorX = typedef VectorN<Eigen::Dynamic>

Definition at line 55 of file eigen_types.h.

VectorXF

using g2o::VectorXF = typedef Eigen::Matrix<float, Eigen::Dynamic, 1, Eigen::ColMajor>

Definition at line 46 of file eigen_types.h.

VectorXI

using g2o::VectorXI = typedef Eigen::Matrix<int, Eigen::Dynamic, 1, Eigen::ColMajor>

Definition at line 41 of file eigen_types.h.

VertexStarMap

typedef std::map<OptimizableGraph::Vertex*, Star*> g2o::VertexStarMap

Definition at line 99 of file star.h.

VertexStarMultimap

typedef std::multimap<OptimizableGraph::Vertex*, Star*> g2o::VertexStarMultimap

Definition at line 98 of file star.h.

WorldObjectLine3D

typedef WorldObject<VertexLine3D> g2o::WorldObjectLine3D

Definition at line 40 of file simulator3d_base.h.

WorldObjectPointXY

typedef WorldObject<VertexPointXY> g2o::WorldObjectPointXY

Definition at line 38 of file simulator2d_base.h.

WorldObjectSE2

typedef WorldObject<VertexSE2> g2o::WorldObjectSE2

Definition at line 36 of file simulator2d_base.h.

WorldObjectSE3

typedef WorldObject<VertexSE3> g2o::WorldObjectSE3

Definition at line 36 of file simulator3d_base.h.

WorldObjectSegment2D

typedef WorldObject<VertexSegment2D> g2o::WorldObjectSegment2D

Definition at line 40 of file simulator2d_base.h.

WorldObjectTrackXYZ

typedef WorldObject<VertexPointXYZ> g2o::WorldObjectTrackXYZ

Definition at line 38 of file simulator3d_base.h.

Enumeration Type Documentation

CommandArgumentType

enum g2o::CommandArgumentType

Enumerator
CAT_DOUBLE
CAT_FLOAT
CAT_INT
CAT_STRING
CAT_BOOL
CAT_VECTOR_INT
CAT_VECTOR_DOUBLE

Definition at line 94 of file command_args.cpp.

                         {
  CAT_DOUBLE,
  CAT_FLOAT,
  CAT_INT,
  CAT_STRING,
  CAT_BOOL,
  CAT_VECTOR_INT,
  CAT_VECTOR_DOUBLE
};

Function Documentation

_skew()

static Matrix3 g2o::_skew ( const Vector3 &  t )

inlinestatic

Definition at line 35 of file line3d.cpp.

                                              {
  Matrix3 S;
  S << 0, -t.z(), t.y(), t.z(), 0, -t.x(), -t.y(), t.x(), 0;
  return S;
}

Referenced by g2o::Line3D::toCartesian().

_univariateSampler()

static std::normal_distribution< double > g2o::_univariateSampler ( 0.  , 1.    )

static

Referenced by sampleGaussian().

activeVertexChi()

double g2o::activeVertexChi

(

const OptimizableGraph::Vertex *

v

)

Definition at line 44 of file simple_star_ops.cpp.

                                                        {
  const SparseOptimizer* s = dynamic_cast<const SparseOptimizer*>(v->graph());
  const OptimizableGraph::EdgeContainer& av = s->activeEdges();
  double chi = 0;
  int ne = 0;
  for (HyperGraph::EdgeSet::iterator it = v->edges().begin();
       it != v->edges().end(); ++it) {
    OptimizableGraph::Edge* e = dynamic_cast<OptimizableGraph::Edge*>(*it);
    if (!e) continue;
    if (s->findActiveEdge(e) != av.end()) {
      chi += e->chi2();
      ne++;
    }
  }
  if (!ne) return -1;
  return chi / ne;
}

References g2o::SparseOptimizer::activeEdges(), g2o::OptimizableGraph::Edge::chi2(), g2o::HyperGraph::Vertex::edges(), g2o::SparseOptimizer::findActiveEdge(), and g2o::OptimizableGraph::Vertex::graph().

addOdometryCalibLinksDifferential()

G2O_CALIBRATION_ODOM_LASER_API void g2o::addOdometryCalibLinksDifferential	(	SparseOptimizer &	optimizer,
		const DataQueue &	odomData
	)

Definition at line 50 of file sclam_helpers.cpp.

                                                                  {
  SparseOptimizer::Vertex* odomParamsVertex = 0;
  odomParamsVertex = new VertexOdomDifferentialParams;
  odomParamsVertex->setToOrigin();
  odomParamsVertex->setId(Gm2dlIO::ID_ODOMCALIB);
  optimizer.addVertex(odomParamsVertex);
 
  SparseOptimizer::EdgeSet odomCalibEdges;
  for (SparseOptimizer::EdgeSet::const_iterator it = optimizer.edges().begin();
       it != optimizer.edges().end(); ++it) {
    EdgeSE2SensorCalib* scanmatchEdge = dynamic_cast<EdgeSE2SensorCalib*>(*it);
    if (!scanmatchEdge) continue;
 
    VertexSE2* r1 = dynamic_cast<VertexSE2*>(scanmatchEdge->vertices()[0]);
    VertexSE2* r2 = dynamic_cast<VertexSE2*>(scanmatchEdge->vertices()[1]);
    if (r2->id() - r1->id() != 1) {  // ignore non-incremental edges
      continue;
    }
 
    RobotLaser* rl1 = dynamic_cast<RobotLaser*>(r1->userData());
    RobotLaser* rl2 = dynamic_cast<RobotLaser*>(r2->userData());
    RobotLaser* odom1 =
        dynamic_cast<RobotLaser*>(odomData.findClosestData(rl1->timestamp()));
    RobotLaser* odom2 =
        dynamic_cast<RobotLaser*>(odomData.findClosestData(rl2->timestamp()));
 
    if (fabs(rl1->timestamp() - rl2->timestamp()) < 1e-7) {
      cerr << "strange edge " << r1->id() << " <-> " << r2->id() << endl;
      cerr << FIXED(PVAR(rl1->timestamp()) << "\t " << PVAR(rl2->timestamp()))
           << endl;
      cerr << FIXED(PVAR(odom1->timestamp())
                    << "\t " << PVAR(odom2->timestamp()))
           << endl;
    }
 
    // cerr << PVAR(odom1->odomPose().toVector().transpose()) << endl;
 
    SE2 odomMotion = odom1->odomPose().inverse() * odom2->odomPose();
    // cerr << PVAR(odomMotion.toVector().transpose()) << endl;
    // cerr << PVAR(scanmatchEdge->measurement().toVector().transpose()) <<
    // endl;
 
    EdgeSE2OdomDifferentialCalib* e = new EdgeSE2OdomDifferentialCalib;
    e->vertices()[0] = r1;
    e->vertices()[1] = r2;
    e->vertices()[2] = odomParamsVertex;
 
    MotionMeasurement mm(
        odomMotion.translation().x(), odomMotion.translation().y(),
        odomMotion.rotation().angle(), odom2->timestamp() - odom1->timestamp());
    e->setMeasurement(OdomConvert::convertToVelocity(mm));
    // cerr << PVAR(e->measurement()) << endl;
 
    e->information() = Matrix3d::Identity() * INFORMATION_SCALING_ODOMETRY;
    odomCalibEdges.insert(e);
  }
 
  for (SparseOptimizer::EdgeSet::iterator it = odomCalibEdges.begin();
       it != odomCalibEdges.end(); ++it)
    optimizer.addEdge(dynamic_cast<OptimizableGraph::Edge*>(*it));
}

References g2o::OptimizableGraph::addEdge(), g2o::OptimizableGraph::addVertex(), g2o::OdomConvert::convertToVelocity(), g2o::HyperGraph::edges(), g2o::DataQueue::findClosestData(), g2o::HyperGraph::Vertex::id(), g2o::Gm2dlIO::ID_ODOMCALIB, g2o::BaseEdge< D, E >::information(), INFORMATION_SCALING_ODOMETRY, g2o::SE2::inverse(), g2o::RobotLaser::odomPose(), g2o::SE2::rotation(), g2o::HyperGraph::Vertex::setId(), g2o::BaseEdge< D, E >::setMeasurement(), g2o::RobotData::timestamp(), g2o::SE2::translation(), g2o::HyperGraph::DataContainer::userData(), and g2o::HyperGraph::Edge::vertices().

Referenced by main().

allocate_aligned()

template<typename Type >

Type * g2o::allocate_aligned

(

size_t

n

)

Definition at line 10 of file dynamic_aligned_buffer.hpp.

                                 {
  return (Type*)Eigen::internal::aligned_malloc(n * sizeof(Type));
}

allocateSolverForSclam()

G2O_CALIBRATION_ODOM_LASER_API void g2o::allocateSolverForSclam	(	SparseOptimizer &	optimizer,
		bool	levenberg
	)

Definition at line 113 of file sclam_helpers.cpp.

                                                                        {
  typedef BlockSolver<BlockSolverTraits<-1, -1> > SclamBlockSolver;
  typedef LinearSolverEigen<SclamBlockSolver::PoseMatrixType> SclamLinearSolver;
 
  std::unique_ptr<SclamLinearSolver> linearSolver =
      std::make_unique<SclamLinearSolver>();
  linearSolver->setBlockOrdering(false);
  OptimizationAlgorithm* solver = 0;
  if (levenberg) {
    solver = new OptimizationAlgorithmLevenberg(
        std::make_unique<SclamBlockSolver>(std::move(linearSolver)));
  } else {
    solver = new OptimizationAlgorithmGaussNewton(
        std::make_unique<SclamBlockSolver>(std::move(linearSolver)));
  }
  optimizer.setAlgorithm(solver);
}

References g2o::SparseOptimizer::setAlgorithm().

Referenced by main().

applyAction()

void G2O_CORE_API g2o::applyAction	(	HyperGraph *	graph,
		HyperGraphElementAction *	action,
		HyperGraphElementAction::Parameters *	parameters = 0,
		const std::string &	typeName = ""
	)

apply an action to all the elements of the graph.

Definition at line 261 of file hyper_graph_action.cpp.

                                            {
  for (HyperGraph::VertexIDMap::iterator it = graph->vertices().begin();
       it != graph->vertices().end(); ++it) {
    auto& aux = *it->second;
    if (typeName.empty() || typeid(aux).name() == typeName) {
      (*action)(it->second, params);
    }
  }
  for (HyperGraph::EdgeSet::iterator it = graph->edges().begin();
       it != graph->edges().end(); ++it) {
    auto& aux = **it;
    if (typeName.empty() || typeid(aux).name() == typeName)
      (*action)(*it, params);
  }
}

References g2o::HyperGraph::edges(), and g2o::HyperGraph::vertices().

Referenced by g2o::G2oQGLViewer::draw().

arrayHasNaN()

bool g2o::arrayHasNaN ( const double *  array, int  size, int *  nanIndex = 0  )

inline

tests whether there is a NaN in the array

Definition at line 168 of file misc.h.

                                                                          {
  for (int i = 0; i < size; ++i)
    if (g2o_isnan(array[i])) {
      if (nanIndex) *nanIndex = i;
      return true;
    }
  return false;
}

References g2o_isnan.

Referenced by g2o::BlockSolver< Traits >::buildSystem(), g2o::SparseOptimizer::computeActiveErrors(), g2o::SparseOptimizer::initializeOptimization(), and g2o::SparseOptimizer::update().

assignHierarchicalEdges()

void g2o::assignHierarchicalEdges	(	StarSet &	stars,
		EdgeStarMap &	esmap,
		EdgeLabeler *	labeler,
		EdgeCreator *	creator,
		SparseOptimizer *	optimizer,
		int	minNumEdges,
		int	maxIterations
	)

Definition at line 111 of file simple_star_ops.cpp.

                                                {
  // now construct the hierarchical edges for all the stars
  for (StarSet::iterator it = stars.begin(); it != stars.end(); ++it) {
    Star* s = *it;
    std::vector<OptimizableGraph::Vertex*> vertices(2);
    vertices[0] = (OptimizableGraph::Vertex*)*s->_gauge.begin();
    HyperGraph::VertexSet vNew = s->lowLevelVertices();
    for (HyperGraph::VertexSet::iterator vit = s->_lowLevelVertices.begin();
         vit != s->_lowLevelVertices.end(); ++vit) {
      OptimizableGraph::Vertex* v = (OptimizableGraph::Vertex*)*vit;
      vertices[1] = v;
      if (v == vertices[0]) continue;
      HyperGraph::EdgeSet eInSt;
      int numEdges = vertexEdgesInStar(eInSt, v, s, esmap);
      if (Factory::instance()->tag(v) ==
              Factory::instance()->tag(vertices[0]) ||
          numEdges > minNumEdges) {
        OptimizableGraph::Edge* e = creator->createEdge(vertices);
        // cerr << "creating edge" << e << endl;
        if (e) {
          e->setLevel(1);
          optimizer->addEdge(e);
          s->_starEdges.insert(e);
        }
      } else {
        vNew.erase(v);
        // remove from the star all edges that are not sufficiently connected
        for (HyperGraph::EdgeSet::iterator it = eInSt.begin();
             it != eInSt.end(); ++it) {
          HyperGraph::Edge* e = *it;
          s->lowLevelEdges().erase(e);
        }
      }
    }
    s->lowLevelVertices() = vNew;
 
    bool labelOk = s->labelStarEdges(maxIterations, labeler);
    assert(labelOk);
    (void)labelOk;
  }
}

References g2o::Star::_gauge, g2o::Star::_lowLevelVertices, g2o::Star::_starEdges, g2o::OptimizableGraph::addEdge(), g2o::EdgeCreator::createEdge(), g2o::Factory::instance(), g2o::Star::labelStarEdges(), g2o::Star::lowLevelEdges(), g2o::Star::lowLevelVertices(), g2o::OptimizableGraph::Edge::setLevel(), and vertexEdgesInStar().

average_angle()

double g2o::average_angle ( double  theta1, double  theta2  )

inline

average two angles

Definition at line 119 of file misc.h.

                                                          {
  double x, y;
 
  x = std::cos(theta1) + std::cos(theta2);
  y = std::sin(theta1) + std::sin(theta2);
  if (x == 0 && y == 0)
    return 0;
  else
    return std::atan2(y, x);
}

changeFileExtension()

G2O_STUFF_API std::string g2o::changeFileExtension	(	const std::string &	filename,
		const std::string &	newExt,
		bool	stripDot = false
	)

change the fileextension of a given filename. Only if filename contains an extension, otherwise filename is returned.

Definition at line 102 of file filesys_tools.cpp.

                                                                        {
  std::string::size_type lastDot = filename.find_last_of('.');
  if (lastDot != std::string::npos) {
    if (stripDot)
      return filename.substr(0, lastDot) + newExt;
    else
      return filename.substr(0, lastDot + 1) + newExt;
  } else
    return filename;
}

clamp()

template<typename T >

T g2o::clamp ( T  l, T  x, T  u  )

inline

clamp x to the interval [l, u]

Definition at line 148 of file misc.h.

                              {
  if (x < l) return l;
  if (x > u) return u;
  return x;
}

clipSegmentCircle()

G2O_SIMULATOR_API int g2o::clipSegmentCircle	(	Eigen::Vector2d &	p1,
		Eigen::Vector2d &	p2,
		double	r
	)

Definition at line 37 of file simutils.cpp.

                                                                      {
  double r2 = r * r;
  Eigen::Vector2d pBase = p1;
  Eigen::Vector2d dp = p2 - p1;
  double length = dp.norm();
  dp.normalize();
  double p = 2 * dp.dot(p1);
  double q = p1.squaredNorm() - r2;
  double disc = p * p - 4 * q;
 
  if (disc <= 0) {  // no intersection or single point intersection
    return -1;
  }
  disc = sqrt(disc);
 
  double t1 = .5 * (-p - disc);
  double t2 = .5 * (-p + disc);
 
  if (t1 > length || t2 < 0) return -1;  // no intersection
  bool clip1 = false;
  bool clip2 = false;
  if (t1 > 0) {
    p1 = pBase + dp * t1;
    clip1 = true;
  }
  if (t2 < length) {
    p2 = pBase + dp * t1;
    clip2 = true;
  }
  if (clip1)
    if (clip2)
      return 3;
    else
      return 0;
  else if (clip2)
    return 1;
  return 2;
}

Referenced by g2o::SensorSegment2D::isVisible(), g2o::SensorSegment2DLine::isVisible(), and g2o::SensorSegment2DPointLine::isVisible().

clipSegmentFov()

G2O_SIMULATOR_API int g2o::clipSegmentFov	(	Eigen::Vector2d &	p1,
		Eigen::Vector2d &	p2,
		double	min,
		double	max
	)

Definition at line 107 of file simutils.cpp.

                               {
  bool clip1 = false, clip2 = false;
  // normal to the first line
  double amin = sin(min), bmin = -cos(min);
  int minClip = clipSegmentLine(p1, p2, amin, bmin, 0);
  switch (minClip) {
    case -1:
      return -1;
    case 0:
      clip1 = true;
      break;
    case 1:
      clip2 = true;
      break;
    default:;
  }
  // normal to the second line
  double amax = -sin(max), bmax = cos(max);
  int maxClip = clipSegmentLine(p1, p2, amax, bmax, 0);
  switch (maxClip) {
    case -1:
      return -1;
    case 0:
      clip1 = true;
      break;
    case 1:
      clip2 = true;
      break;
    default:;
  }
  if (clip1)
    if (clip2)
      return 3;
    else
      return 0;
  else if (clip2)
    return 1;
  return 2;
}

References clipSegmentLine().

Referenced by g2o::SensorSegment2D::isVisible(), g2o::SensorSegment2DLine::isVisible(), and g2o::SensorSegment2DPointLine::isVisible().

clipSegmentLine()

G2O_SIMULATOR_API int g2o::clipSegmentLine	(	Eigen::Vector2d &	p1,
		Eigen::Vector2d &	p2,
		double	a,
		double	b,
		double	c
	)

Definition at line 81 of file simutils.cpp.

                                        {
  bool p1inside = true;
  bool p2inside = true;
  if (a * p1.x() + b * p1.y() + c < 0) {
    p1inside = false;
  }
  if (a * p2.x() + b * p2.y() + c < 0) {
    p2inside = false;
  }
  if (p1inside && p2inside) return 2;
  if (!p1inside && !p2inside) return -1;
 
  Eigen::Vector2d dp = p2 - p1;
  double den = a * dp.x() + b * dp.y();
  if (den == 0) return -1;
  double num = c + a * p1.x() + b * p1.y();
  double t = -num / den;
  if (p1inside) {
    p2 = p1 + dp * t;
    return 1;
  }
  p1 = p1 + dp * t;
  return 0;
}

Referenced by clipSegmentFov().

computeBorder()

G2O_HIERARCHICAL_API void g2o::computeBorder	(	StarSet &	stars,
		EdgeStarMap &	hesmap
	)

Definition at line 156 of file simple_star_ops.cpp.

                                                        {
  for (StarSet::iterator it = stars.begin(); it != stars.end(); ++it) {
    Star* s = *it;
    for (HyperGraph::EdgeSet::iterator iit = s->_starEdges.begin();
         iit != s->_starEdges.end(); ++iit) {
      OptimizableGraph::Edge* e = (OptimizableGraph::Edge*)*iit;
      StarSet sset;
      starsInEdge(sset, e, hesmap, s->gauge());
      // cerr << "e: " << e << " l:" << e->level() << " sset.size()=" <<
      // sset.size() << endl;
      if (sset.size() > 1) {
        s->starFrontierEdges().insert(e);
      }
    }
  }
}

References g2o::Star::_starEdges, g2o::Star::gauge(), g2o::Star::starFrontierEdges(), and starsInEdge().

Referenced by main().

computeLineParameters()

G2O_SIMULATOR_API Eigen::Vector2d g2o::computeLineParameters	(	const Eigen::Vector2d &	p1,
		const Eigen::Vector2d &	p2
	)

Definition at line 148 of file simutils.cpp.

                                                               {
  Eigen::Vector2d lp;
  Eigen::Vector2d dp = p2 - p1;
  lp[0] = atan2(-dp.x(), dp.y());
  Eigen::Vector2d n(cos(lp[0]), sin(lp[0]));
  lp[1] = n.dot(p1 + p2) * .5;
  return lp;
}

Referenced by LineInfo::LineInfo(), and main().

computeSimpleStars()

G2O_HIERARCHICAL_API void g2o::computeSimpleStars	(	StarSet &	stars,
		SparseOptimizer *	optimizer,
		EdgeLabeler *	labeler,
		EdgeCreator *	creator,
		OptimizableGraph::Vertex *	gauge_,
		std::string	edgeTag,
		std::string	vertexTag,
		int	level,
		int	step,
		int	backboneIterations,
		int	starIterations,
		double	rejectionThreshold,
		bool	debug
	)

Definition at line 173 of file simple_star_ops.cpp.

                                                               {
  HyperDijkstra d(optimizer);
  // compute a spanning tree based on the types of edges and vertices in the
  // pool
  EdgeTypesCostFunction f(edgeTag, vertexTag, level);
  d.shortestPaths(gauge_, &f, std::numeric_limits<double>::max(), 1e-6, false,
                  std::numeric_limits<double>::max() / 2);
 
  HyperDijkstra::computeTree(d.adjacencyMap());
  // constructs the stars on the backbone
 
  BackBoneTreeAction bact(optimizer, vertexTag, level, step);
  bact.init();
 
  // perform breadth-first visit of the visit tree and create the stars on the
  // backbone
  d.visitAdjacencyMap(d.adjacencyMap(), &bact, true);
  stars.clear();
 
  for (VertexStarMultimap::iterator it = bact.vertexStarMultiMap().begin();
       it != bact.vertexStarMultiMap().end(); ++it) {
    stars.insert(it->second);
  }
 
  //  for each star
 
  //    for all vertices in the backbone, select all edges leading/leaving from
  //    that vertex that are contained in freeEdges.
 
  //      mark the corresponding "open" vertices and add them to a multimap
  //      (vertex->star)
 
  //    select a gauge in the backbone
 
  //    push all vertices on the backbone
 
  //    compute an initial guess on the backbone
 
  //    one round of optimization backbone
 
  //    lock all vertices in the backbone
 
  //    push all "open" vertices
 
  //    for each open vertex,
  //      compute an initial guess given the backbone
  //      do some rounds of solveDirect
  //      if (fail)
  //        - remove the vertex and the edges in that vertex from the star
  //   - make the structures consistent
 
  //    pop all "open" vertices
  //    pop all "vertices" in the backbone
  //    unfix the vertices in the backbone
 
  int starNum = 0;
  for (StarSet::iterator it = stars.begin(); it != stars.end(); ++it) {
    Star* s = *it;
    HyperGraph::VertexSet backboneVertices = s->_lowLevelVertices;
    HyperGraph::EdgeSet backboneEdges = s->_lowLevelEdges;
    if (backboneEdges.empty()) continue;
 
    // cerr << "optimizing backbone" << endl;
    // one of these  should be the gauge, to be simple we select the first one
    // in the backbone
    OptimizableGraph::VertexSet gauge;
    gauge.insert(*backboneVertices.begin());
    s->gauge() = gauge;
    s->optimizer()->push(backboneVertices);
    s->optimizer()->setFixed(gauge, true);
    s->optimizer()->initializeOptimization(backboneEdges);
    s->optimizer()->computeInitialGuess();
    s->optimizer()->optimize(backboneIterations);
    s->optimizer()->setFixed(backboneVertices, true);
 
    // cerr << "assignind edges.vertices not in bbone" << endl;
    HyperGraph::EdgeSet otherEdges;
    HyperGraph::VertexSet otherVertices;
    std::multimap<HyperGraph::Vertex*, HyperGraph::Edge*> vemap;
    for (HyperGraph::VertexSet::iterator bit = backboneVertices.begin();
         bit != backboneVertices.end(); ++bit) {
      HyperGraph::Vertex* v = *bit;
      for (HyperGraph::EdgeSet::iterator eit = v->edges().begin();
           eit != v->edges().end(); ++eit) {
        OptimizableGraph::Edge* e = (OptimizableGraph::Edge*)*eit;
        HyperGraph::EdgeSet::iterator feit = bact.freeEdges().find(e);
        if (feit != bact.freeEdges().end()) {  // edge is admissible
          otherEdges.insert(e);
          bact.freeEdges().erase(feit);
          for (size_t i = 0; i < e->vertices().size(); i++) {
            OptimizableGraph::Vertex* ve =
                (OptimizableGraph::Vertex*)e->vertices()[i];
            if (backboneVertices.find(ve) == backboneVertices.end()) {
              otherVertices.insert(ve);
              vemap.insert(make_pair(ve, e));
            }
          }
        }
      }
    }
 
    // RAINER TODO maybe need a better solution than dynamic casting here??
    OptimizationAlgorithmWithHessian* solverWithHessian =
        dynamic_cast<OptimizationAlgorithmWithHessian*>(
            s->optimizer()->solver());
    if (solverWithHessian) {
      s->optimizer()->push(otherVertices);
      // cerr << "optimizing vertices out of bbone" << endl;
      // cerr << "push" << endl;
      // cerr << "init" << endl;
      s->optimizer()->initializeOptimization(otherEdges);
      // cerr << "guess" << endl;
      s->optimizer()->computeInitialGuess();
      // cerr << "solver init" << endl;
      s->optimizer()->solver()->init();
      // cerr << "structure" << endl;
      if (!solverWithHessian->buildLinearStructure())
        cerr << "FATAL: failure while building linear structure" << endl;
      // cerr << "errors" << endl;
      s->optimizer()->computeActiveErrors();
      // cerr << "system" << endl;
      solverWithHessian->updateLinearSystem();
      // cerr << "directSolove" << endl;
    } else {
      cerr << "FATAL: hierarchical thing cannot be used with a solver that "
              "does not support the system structure "
              "construction"
           << endl;
    }
 
    // // then optimize the vertices one at a time to check if a solution is
    // good
    for (HyperGraph::VertexSet::iterator vit = otherVertices.begin();
         vit != otherVertices.end(); ++vit) {
      OptimizableGraph::Vertex* v = (OptimizableGraph::Vertex*)(*vit);
      v->solveDirect();
      // cerr << " " << d;
      // if  a solution is found, add a vertex and all the edges in
      // othervertices that are pointing to that edge to the star
      s->_lowLevelVertices.insert(v);
      for (HyperGraph::EdgeSet::iterator eit = v->edges().begin();
           eit != v->edges().end(); ++eit) {
        OptimizableGraph::Edge* e = (OptimizableGraph::Edge*)*eit;
        if (otherEdges.find(e) != otherEdges.end()) s->_lowLevelEdges.insert(e);
      }
    }
    // cerr <<  endl;
 
    // relax the backbone and optimize it all
    // cerr << "relax bbone" << endl;
    s->optimizer()->setFixed(backboneVertices, false);
    // cerr << "fox gauge bbone" << endl;
    s->optimizer()->setFixed(s->gauge(), true);
 
    // cerr << "opt init" << endl;
    s->optimizer()->initializeOptimization(s->_lowLevelEdges);
    optimizer->computeActiveErrors();
    int starOptResult = s->optimizer()->optimize(starIterations);
    // cerr << starOptResult << "(" << starIterations << ")  " << endl;
 
    if (!starIterations || starOptResult > 0) {
      optimizer->computeActiveErrors();
 
#if 1
 
      s->optimizer()->computeActiveErrors();
      // cerr << "system" << endl;
      if (solverWithHessian) solverWithHessian->updateLinearSystem();
      HyperGraph::EdgeSet prunedStarEdges = backboneEdges;
      HyperGraph::VertexSet prunedStarVertices = backboneVertices;
      for (HyperGraph::VertexSet::iterator vit = otherVertices.begin();
           vit != otherVertices.end(); ++vit) {
        // discard the vertices whose error is too big
 
        OptimizableGraph::Vertex* v = (OptimizableGraph::Vertex*)(*vit);
        MatrixXd h(v->dimension(), v->dimension());
        for (int i = 0; i < v->dimension(); i++) {
          for (int j = 0; j < v->dimension(); j++) h(i, j) = v->hessian(i, j);
        }
        EigenSolver<Eigen::MatrixXd> esolver;
        esolver.compute(h);
        VectorXcd ev = esolver.eigenvalues();
        double emin = std::numeric_limits<double>::max();
        double emax = -std::numeric_limits<double>::max();
        for (int i = 0; i < ev.size(); i++) {
          emin = ev(i).real() > emin ? emin : ev(i).real();
          emax = ev(i).real() < emax ? emax : ev(i).real();
        }
 
        double d = emin / emax;
 
        // cerr << " " << d;
        if (d > rejectionThreshold) {
          // if  a solution is found, add a vertex and all the edges in
          // othervertices that are pointing to that edge to the star
          prunedStarVertices.insert(v);
          for (HyperGraph::EdgeSet::iterator eit = v->edges().begin();
               eit != v->edges().end(); ++eit) {
            OptimizableGraph::Edge* e = (OptimizableGraph::Edge*)*eit;
            if (otherEdges.find(e) != otherEdges.end())
              prunedStarEdges.insert(e);
          }
          // cerr << "K( " << v->id() << "," << d << ")" ;
        }
      }
      s->_lowLevelEdges = prunedStarEdges;
      s->_lowLevelVertices = prunedStarVertices;
 
#endif
      // cerr << "addHedges" << endl;
      // now add to the star the hierarchical edges
      std::vector<OptimizableGraph::Vertex*> vertices(2);
      vertices[0] = (OptimizableGraph::Vertex*)*s->_gauge.begin();
 
      for (HyperGraph::VertexSet::iterator vit = s->_lowLevelVertices.begin();
           vit != s->_lowLevelVertices.end(); ++vit) {
        OptimizableGraph::Vertex* v = (OptimizableGraph::Vertex*)*vit;
        vertices[1] = v;
        if (v == vertices[0]) continue;
        OptimizableGraph::Edge* e = creator->createEdge(vertices);
        // rr << "creating edge" << e <<  Factory::instance()->tag(vertices[0])
        // << "->" <<  Factory::instance()->tag(v) <endl;
        if (e) {
          e->setLevel(level + 1);
          optimizer->addEdge(e);
          s->_starEdges.insert(e);
        }
      }
    }
 
    if (debug) {
      char starLowName[100];
      snprintf(starLowName, 99, "star-%04d-low.g2o", starNum);
      ofstream starLowStream(starLowName);
      optimizer->saveSubset(starLowStream, s->_lowLevelEdges);
    }
    bool labelOk = false;
    if (!starIterations || starOptResult > 0)
      labelOk = s->labelStarEdges(0, labeler);
    if (labelOk) {
      if (debug) {
        char starHighName[100];
        snprintf(starHighName, 99, "star-%04d-high.g2o", starNum);
        ofstream starHighStream(starHighName);
        optimizer->saveSubset(starHighStream, s->_starEdges);
      }
    }
    starNum++;
 
    // label each hierarchical edge
    s->optimizer()->pop(otherVertices);
    s->optimizer()->pop(backboneVertices);
    s->optimizer()->setFixed(s->gauge(), false);
  }
 
  StarSet stars2;
  // now erase the stars that have 0 edges. They r useless
  for (StarSet::iterator it = stars.begin(); it != stars.end(); ++it) {
    Star* s = *it;
    if (s->lowLevelEdges().size() == 0) {
      delete s;
    } else
      stars2.insert(s);
  }
  stars = stars2;
}

References g2o::Star::_gauge, g2o::Star::_lowLevelEdges, g2o::Star::_lowLevelVertices, g2o::Star::_starEdges, g2o::OptimizableGraph::addEdge(), g2o::HyperDijkstra::adjacencyMap(), g2o::OptimizationAlgorithmWithHessian::buildLinearStructure(), g2o::SparseOptimizer::computeActiveErrors(), g2o::SparseOptimizer::computeInitialGuess(), g2o::HyperDijkstra::computeTree(), g2o::EdgeCreator::createEdge(), g2o::OptimizableGraph::Vertex::dimension(), g2o::HyperGraph::Vertex::edges(), g2o::BackBoneTreeAction::freeEdges(), g2o::Star::gauge(), g2o::OptimizableGraph::Vertex::hessian(), g2o::BackBoneTreeAction::init(), g2o::OptimizationAlgorithm::init(), g2o::SparseOptimizer::initializeOptimization(), g2o::Star::labelStarEdges(), g2o::Star::lowLevelEdges(), g2o::SparseOptimizer::optimize(), g2o::Star::optimizer(), g2o::SparseOptimizer::pop(), g2o::SparseOptimizer::push(), g2o::OptimizableGraph::saveSubset(), g2o::OptimizableGraph::setFixed(), g2o::OptimizableGraph::Edge::setLevel(), g2o::HyperDijkstra::shortestPaths(), g2o::OptimizableGraph::Vertex::solveDirect(), g2o::SparseOptimizer::solver(), step(), g2o::OptimizationAlgorithmWithHessian::updateLinearSystem(), g2o::BackBoneTreeAction::vertexStarMultiMap(), g2o::HyperGraph::Edge::vertices(), and g2o::HyperDijkstra::visitAdjacencyMap().

Referenced by main().

const_pi()

constexpr double g2o::const_pi ( )

constexpr

Definition at line 62 of file misc.h.

{ return cst(3.14159265358979323846); }

References cst().

Referenced by inverse_theta(), and normalize_theta().

constructEdgeStarMap()

G2O_HIERARCHICAL_API void g2o::constructEdgeStarMap	(	EdgeStarMap &	esmap,
		StarSet &	stars,
		bool	low
	)

Definition at line 62 of file simple_star_ops.cpp.

                                                                        {
  esmap.clear();
  for (StarSet::iterator it = stars.begin(); it != stars.end(); ++it) {
    Star* s = *it;
    if (low) {
      for (HyperGraph::EdgeSet::iterator it = s->lowLevelEdges().begin();
           it != s->lowLevelEdges().end(); ++it) {
        HyperGraph::Edge* e = *it;
        esmap.insert(make_pair(e, s));
      }
    } else {
      for (HyperGraph::EdgeSet::iterator it = s->starEdges().begin();
           it != s->starEdges().end(); ++it) {
        HyperGraph::Edge* e = *it;
        esmap.insert(make_pair(e, s));
      }
    }
  }
}

References g2o::Star::lowLevelEdges(), and g2o::Star::starEdges().

Referenced by main().

convertString()

template<typename T >

bool g2o::convertString	(	const std::string &	s,
		T &	x,
		bool	failIfLeftoverChars = true
	)

convert a string into an other type.

Definition at line 123 of file string_tools.h.

                                                    {
  std::istringstream i(s);
  char c;
  if (!(i >> x) || (failIfLeftoverChars && i.get(c))) return false;
  return true;
}

Referenced by g2o::Property< T >::fromString(), and stringToType().

createSolver() [1/8]

static OptimizationAlgorithm * g2o::createSolver ( const std::string &  fullSolverName )

static

Definition at line 54 of file solver_cholmod.cpp.

                                                                            {
  static const std::map<std::string,
                        std::function<std::unique_ptr<BlockSolverBase>()>>
      solver_factories{
          {"var_cholmod", &AllocateSolver<-1, -1, true>},
          {"fix3_2_cholmod", &AllocateSolver<3, 2, true>},
          {"fix6_3_cholmod", &AllocateSolver<6, 3, true>},
          {"fix7_3_cholmod", &AllocateSolver<7, 3, true>},
#ifdef ADD_SCALAR_ORDERING
          {"fix3_2_cholmod_scalar", &AllocateSolver<3, 2, false>},
          {"fix6_3_cholmod_scalar", &AllocateSolver<6, 3, false>},
          {"fix7_3_cholmod_scalar", &AllocateSolver<7, 3, false>},
#endif
      };
 
  string solverName = fullSolverName.substr(3);
  auto solverf = solver_factories.find(solverName);
  if (solverf == solver_factories.end()) return nullptr;
 
  string methodName = fullSolverName.substr(0, 2);
 
  if (methodName == "gn") {
    return new OptimizationAlgorithmGaussNewton(solverf->second());
  } else if (methodName == "lm") {
    return new OptimizationAlgorithmLevenberg(solverf->second());
  } else if (methodName == "dl") {
    return new OptimizationAlgorithmDogleg(solverf->second());
  }
 
  return nullptr;
}

createSolver() [2/8]

static OptimizationAlgorithm * g2o::createSolver ( const std::string &  fullSolverName )

static

helper function for allocating

Definition at line 47 of file solver_csparse.cpp.

                                                                            {
  static const std::map<std::string,
                        std::function<std::unique_ptr<BlockSolverBase>()>>
      solver_factories{
          {"var_csparse", &AllocateSolver<-1, -1, true>},
          {"fix3_2_csparse", &AllocateSolver<3, 2, true>},
          {"fix6_3_csparse", &AllocateSolver<6, 3, true>},
          {"fix7_3_csparse", &AllocateSolver<7, 3, true>},
          {"fix3_2_scalar_csparse", &AllocateSolver<3, 2, false>},
          {"fix6_3_scalar_csparse", &AllocateSolver<6, 3, false>},
          {"fix7_3_scalar_csparse", &AllocateSolver<7, 3, false>},
      };
 
  string solverName = fullSolverName.substr(3);
  auto solverf = solver_factories.find(solverName);
  if (solverf == solver_factories.end()) return nullptr;
 
  string methodName = fullSolverName.substr(0, 2);
 
  if (methodName == "gn") {
    return new OptimizationAlgorithmGaussNewton(solverf->second());
  } else if (methodName == "lm") {
    return new OptimizationAlgorithmLevenberg(solverf->second());
  } else if (methodName == "dl") {
    return new OptimizationAlgorithmDogleg(solverf->second());
  }
 
  return nullptr;
}

createSolver() [3/8]

static OptimizationAlgorithm * g2o::createSolver ( const std::string &  fullSolverName )

static

Definition at line 49 of file solver_dense.cpp.

                                                                            {
  static const std::map<std::string,
                        std::function<std::unique_ptr<g2o::Solver>()>>
      solver_factories{
          {"dense", &AllocateSolver<-1, -1>},
          {"dense3_2", &AllocateSolver<3, 2>},
          {"dense6_3", &AllocateSolver<6, 3>},
          {"dense7_3", &AllocateSolver<7, 3>},
      };
 
  string solverName = fullSolverName.substr(3);
  auto solverf = solver_factories.find(solverName);
  if (solverf == solver_factories.end()) return nullptr;
 
  string methodName = fullSolverName.substr(0, 2);
 
  if (methodName == "gn") {
    return new OptimizationAlgorithmGaussNewton(solverf->second());
  } else if (methodName == "lm") {
    return new OptimizationAlgorithmLevenberg(solverf->second());
  }
 
  return nullptr;
}

createSolver() [4/8]

static OptimizationAlgorithm * g2o::createSolver ( const std::string &  fullSolverName )

static

helper function for allocating

Definition at line 58 of file solver_eigen.cpp.

                                                                            {
  static const std::map<std::string,
                        std::function<std::unique_ptr<BlockSolverBase>()>>
      solver_factories{
          {"var", &AllocateSolver<-1, -1, true>},
          {"fix3_2", &AllocateSolver<3, 2, true>},
          {"fix6_3", &AllocateSolver<6, 3, true>},
          {"fix7_3", &AllocateSolver<7, 3, true>},
          {"fix3_2_scalar", &AllocateSolver<3, 2, false>},
          {"fix6_3_scalar", &AllocateSolver<6, 3, false>},
          {"fix7_3_scalar", &AllocateSolver<7, 3, false>},
      };
 
  string solverName = fullSolverName.substr(3);
  auto solverf = solver_factories.find(solverName);
  if (solverf == solver_factories.end()) return nullptr;
 
  string methodName = fullSolverName.substr(0, 2);
 
  if (methodName == "gn") {
    return new OptimizationAlgorithmGaussNewton(solverf->second());
  } else if (methodName == "lm") {
    return new OptimizationAlgorithmLevenberg(solverf->second());
  } else if (methodName == "dl") {
    return new OptimizationAlgorithmDogleg(solverf->second());
  }
 
  return nullptr;
}

createSolver() [5/8]

static OptimizationAlgorithm * g2o::createSolver ( const std::string &  fullSolverName )

static

Definition at line 49 of file solver_pcg.cpp.

                                                                            {
  static const std::map<std::string,
                        std::function<std::unique_ptr<g2o::Solver>()>>
      solver_factories{
          {"pcg", &AllocateSolver<-1, -1>},
          {"pcg3_2", &AllocateSolver<3, 2>},
          {"pcg6_3", &AllocateSolver<6, 3>},
          {"pcg7_3", &AllocateSolver<7, 3>},
      };
 
  string solverName = fullSolverName.substr(3);
  auto solverf = solver_factories.find(solverName);
  if (solverf == solver_factories.end()) return nullptr;
 
  string methodName = fullSolverName.substr(0, 2);
 
  if (methodName == "gn") {
    return new OptimizationAlgorithmGaussNewton(solverf->second());
  } else if (methodName == "lm") {
    return new OptimizationAlgorithmLevenberg(solverf->second());
  }
 
  return nullptr;
}

createSolver() [6/8]

static OptimizationAlgorithm * g2o::createSolver ( const std::string &  fullSolverName )

static

helper function for allocating

Definition at line 54 of file slam2d_linear.cpp.

                                                                            {
  if (fullSolverName != "2dlinear") return nullptr;
 
  return new SolverSLAM2DLinear{AllocateSolver<3, 2, true>()};
}

createSolver() [7/8]

static OptimizationAlgorithm * g2o::createSolver ( const std::string &  fullSolverName )

static

helper function for allocating

Definition at line 37 of file structure_only.cpp.

                                                                            {
  if (fullSolverName == "structure_only_2") {
    OptimizationAlgorithm* optimizationAlgo = new StructureOnlySolver<2>;
    return optimizationAlgo;
  } else if (fullSolverName == "structure_only_3") {
    OptimizationAlgorithm* optimizationAlgo = new StructureOnlySolver<3>;
    return optimizationAlgo;
  } else
    return nullptr;
}

createSolver() [8/8]

static OptimizationAlgorithm * g2o::createSolver ( const std::string &  solverName )

static

Definition at line 471 of file graph_optimizer_sparse_incremental.cpp.

                                                                        {
  std::unique_ptr<g2o::Solver> s;
 
  if (solverName == "fix3_2_cholmod") {
    s = AllocateCholmodSolver<3, 2>();
  } else if (solverName == "fix6_3_cholmod") {
    s = AllocateCholmodSolver<6, 3>();
  }
 
  OptimizationAlgorithmGaussNewton* gaussNewton =
      new OptimizationAlgorithmGaussNewton(std::move(s));
  return gaussNewton;
}

Referenced by g2o::CholmodSolverCreator::construct(), g2o::CSparseSolverCreator::construct(), g2o::DenseSolverCreator::construct(), g2o::EigenSolverCreator::construct(), g2o::PCGSolverCreator::construct(), g2o::SLAM2DLinearSolverCreator::construct(), g2o::StructureOnlyCreator::construct(), and g2o::SparseOptimizerIncremental::initSolver().

cst()

constexpr double g2o::cst ( long double  v )

inlineconstexpr

converts a number constant to a double constant at compile time to avoid having to cast everything to avoid warnings.

Definition at line 60 of file misc.h.

{ return (double)v; }

Referenced by g2o::StructureOnlySolver< PointDoF >::calc(), g2o::EdgeProjectP2SC::computeError(), const_pi(), deg2rad(), g2o::SE3Quat::exp(), g2o::internal::fromEuler(), g2o::SE3Quat::fromMinimalVector(), g2o::EdgeSBACam::initialEstimatePossible(), g2o::EdgeSBAScale::initialEstimatePossible(), g2o::SE3Quat::inverse(), jac_quat3_euler3(), g2o::BaseVariableSizedEdge< D, E >::linearizeOplus(), g2o::EdgeSE2::linearizeOplus(), g2o::BaseFixedSizedEdge< D, E, VertexTypes >::linearizeOplusN(), g2o::LinearSolverPCG< MatrixType >::LinearSolverPCG(), g2o::Sim3::log(), g2o::SE3Quat::log(), g2o::VertexSCam::mapPoint(), rad2deg(), g2o::Edge_V_V_GICP::read(), g2o::VertexCam::read(), sampleUnscented(), g2o::SBACam::SBACam(), g2o::SE3Quat::SE3Quat(), g2o::SBACam::setDr(), g2o::SBACam::setKcam(), g2o::VertexIntrinsics::setToOriginImpl(), g2o::Sim3::Sim3(), g2o::OptimizationAlgorithmDogleg::solve(), g2o::OptimizationAlgorithmLevenberg::solve(), tictoc(), g2o::Line3D::toCartesian(), g2o::SBACam::update(), g2o::VertexIntrinsics::VertexIntrinsics(), and g2o::VertexPlane::VertexPlane().

deg2rad()

double g2o::deg2rad ( double  degree )

inline

convert from degree to radian

Definition at line 91 of file misc.h.

                                     {
  return degree * cst(0.01745329251994329576);
}

References cst().

deltaR()

G2O_TYPES_SLAM3D_API Vector3 g2o::deltaR ( const Matrix3 &  R )

inline

Referenced by g2o::Sim3::log().

dumpEdges()

G2O_CLI_API bool g2o::dumpEdges	(	std::ostream &	os,
		const OptimizableGraph &	optimizer
	)

dump the edges to a stream, e.g., cout and redirect to gnuplot

Definition at line 185 of file output_helper.cpp.

                                                                  {
  // seek for an action whose name is writeGnuplot in the library
  HyperGraphElementAction* saveGnuplot =
      HyperGraphActionLibrary::instance()->actionByName("writeGnuplot");
  if (!saveGnuplot) {
    cerr << __PRETTY_FUNCTION__ << ": no action \"writeGnuplot\" registered"
         << endl;
    return false;
  }
  WriteGnuplotAction::Parameters params;
  params.os = &os;
 
  // writing all edges
  os << "set terminal x11 noraise" << endl;
  os << "set size ratio -1" << endl;
  os << "plot \"-\" w l" << endl;
  for (HyperGraph::EdgeSet::const_iterator it = optimizer.edges().begin();
       it != optimizer.edges().end(); ++it) {
    OptimizableGraph::Edge* e = static_cast<OptimizableGraph::Edge*>(*it);
    (*saveGnuplot)(e, &params);
  }
  os << "e" << endl;
 
  return true;
}

References __PRETTY_FUNCTION__, g2o::HyperGraphActionLibrary::actionByName(), g2o::HyperGraph::edges(), g2o::HyperGraphActionLibrary::instance(), g2o::WriteGnuplotAction::Parameters::os, and saveGnuplot().

Referenced by gnudump_edges(), and main().

edgeAllVertsSameDim()

bool g2o::edgeAllVertsSameDim	(	OptimizableGraph::Edge *	e,
		int	dim
	)

Definition at line 41 of file output_helper.cpp.

                                                           {
  for (size_t i = 0; i < e->vertices().size(); ++i) {
    OptimizableGraph::Vertex* v =
        static_cast<OptimizableGraph::Vertex*>(e->vertices()[i]);
    if (v->dimension() != dim) return false;
  }
  return true;
}

References g2o::OptimizableGraph::Vertex::dimension(), and g2o::HyperGraph::Edge::vertices().

Referenced by saveGnuplot().

fileExists()

G2O_STUFF_API bool g2o::fileExists

(

const char *

filename

)

check if file exists (note a directory is also a file)

Definition at line 114 of file filesys_tools.cpp.

                                      {
  struct stat statInfo;
  return (stat(filename, &statInfo) == 0);
}

findArguments()

void g2o::findArguments	(	const std::string &	option,
		vector< string > &	args,
		int	argc,
		char **	argv
	)

Definition at line 89 of file g2o_common.cpp.

                                {
  args.clear();
  for (int i = 0; i < argc; ++i) {
    if (argv[i] == option && i + 1 < argc) {
      args.push_back(argv[i + 1]);
    }
  }
}

Referenced by loadStandardSolver(), and loadStandardTypes().

findConnectedEdgesWithCostLimit()

void g2o::findConnectedEdgesWithCostLimit	(	HyperGraph::EdgeSet &	selected,
		HyperGraph::EdgeSet &	border,
		HyperGraph::Edge *	start,
		HyperDijkstra::CostFunction *	cost,
		double	maxEdgeCost,
		double	comparisonConditioner
	)

Definition at line 41 of file tools.cpp.

                                                                   {
  (void)comparisonConditioner;  // no warning (unused)
  typedef std::queue<HyperGraph::Edge*> EdgeDeque;
  EdgeDeque frontier;
  frontier.push(start);
 
  selected.clear();
  border.clear();
 
  while (!frontier.empty()) {
    HyperGraph::Edge* e = frontier.front();
    frontier.pop();
 
    const VertexSE2* from = dynamic_cast<const VertexSE2*>(e->vertices()[0]);
    const VertexSE2* to = dynamic_cast<const VertexSE2*>(e->vertices()[1]);
 
    if (!(from && to)) continue;
 
    double edgecost = (*cost)(e, e->vertices()[0], e->vertices()[1]);
    if (edgecost != std::numeric_limits<double>::max()) {
      if (edgecost > maxEdgeCost) {  // + comparisonConditioner) {
        border.insert(e);
      } else /*if (edgecost <= maxEdgeCost)*/ {
        selected.insert(e);
        for (auto it = e->vertices()[0]->edges().begin();
             it != e->vertices()[0]->edges().end(); ++it) {
          if (selected.find(*it) == selected.end())
            frontier.push(dynamic_cast<HyperGraph::Edge*>(*it));
        }
        for (auto it = e->vertices()[1]->edges().begin();
             it != e->vertices()[1]->edges().end(); ++it) {
          if (selected.find(*it) == selected.end())
            frontier.push(dynamic_cast<HyperGraph::Edge*>(*it));
        }
      }
    }
  }
}

References g2o::BaseVertex< D, T >::push(), and g2o::HyperGraph::Edge::vertices().

Referenced by main().

formatString()

G2O_STUFF_API std::string g2o::formatString	(	const char *	fmt,
			...
	)

format a string and return a std::string. Format is just like printf, see man 3 printf

Definition at line 90 of file string_tools.cpp.

                                             {
  char* auxPtr = NULL;
  va_list arg_list;
  va_start(arg_list, fmt);
  int numChar = vasprintf(&auxPtr, fmt, arg_list);
  va_end(arg_list);
  string retString;
  if (numChar != -1)
    retString = auxPtr;
  else {
    G2O_ERROR("{}: Error while allocating memory", __PRETTY_FUNCTION__);
  }
  free(auxPtr);
  return retString;
}

References __PRETTY_FUNCTION__, and G2O_ERROR.

Referenced by gnudump_edges(), and gnudump_features().

free_aligned()

template<typename Type >

void g2o::free_aligned

(

Type *

block

)

Definition at line 21 of file dynamic_aligned_buffer.hpp.

                               {
  Eigen::internal::aligned_free(block);
}

Referenced by g2o::aligned_deleter< T >::operator()(), g2o::Solver::resizeVector(), and g2o::Solver::~Solver().

G2O_ATTRIBUTE_CONSTRUCTOR() [1/2]

g2o::G2O_ATTRIBUTE_CONSTRUCTOR

(

init_icp_types

)

Definition at line 70 of file types_icp.cpp.

{ types_icp::init(); }

References g2o::types_icp::init().

G2O_ATTRIBUTE_CONSTRUCTOR() [2/2]

g2o::G2O_ATTRIBUTE_CONSTRUCTOR

(

init_slam3d_addons_types

)

Definition at line 57 of file types_slam3d_addons.cpp.

                                                    {
  static bool initialized = false;
  if (initialized) return;
  initialized = true;
 
#ifdef G2O_HAVE_OPENGL
  HyperGraphActionLibrary* actionLib = HyperGraphActionLibrary::instance();
  HyperGraphElementAction::HyperGraphElementActionPtr vertexse3eulerdraw(
      new g2o::VertexSE3DrawAction);
  vertexse3eulerdraw->setTypeName(typeid(VertexSE3Euler).name());
  actionLib->registerAction(vertexse3eulerdraw);
 
  HyperGraphElementAction::HyperGraphElementActionPtr edgese3eulerdraw(
      new g2o::EdgeSE3DrawAction);
  edgese3eulerdraw->setTypeName(typeid(EdgeSE3Euler).name());
  actionLib->registerAction(edgese3eulerdraw);
#endif
}

References g2o::HyperGraphActionLibrary::instance(), and g2o::HyperGraphActionLibrary::registerAction().

G2O_REGISTER_ACTION() [1/8]

g2o::G2O_REGISTER_ACTION

(

EdgeSE2PointXYBearingWriteGnuplotAction

)

G2O_REGISTER_ACTION() [2/8]

g2o::G2O_REGISTER_ACTION

(

EdgeSE2PointXYWriteGnuplotAction

)

G2O_REGISTER_ACTION() [3/8]

g2o::G2O_REGISTER_ACTION

(

EdgeSE2WriteGnuplotAction

)

G2O_REGISTER_ACTION() [4/8]

g2o::G2O_REGISTER_ACTION

(

EdgeSE3WriteGnuplotAction

)

G2O_REGISTER_ACTION() [5/8]

g2o::G2O_REGISTER_ACTION

(

VertexPointXYWriteGnuplotAction

)

G2O_REGISTER_ACTION() [6/8]

g2o::G2O_REGISTER_ACTION

(

VertexPointXYZWriteGnuplotAction

)

G2O_REGISTER_ACTION() [7/8]

g2o::G2O_REGISTER_ACTION

(

VertexSE2WriteGnuplotAction

)

G2O_REGISTER_ACTION() [8/8]

g2o::G2O_REGISTER_ACTION

(

VertexSE3WriteGnuplotAction

)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [1/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	2dlinear	,
		new	SLAM2DLinearSolverCreatorOptimizationAlgorithmProperty("2dlinear", "Solve Orientation + Gauss-Newton: Works only on 2D pose graphs!!", "Eigen", false, 3, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [2/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	dl_var	,
		new	EigenSolverCreatorOptimizationAlgorithmProperty("dl_var", "Dogleg: Cholesky solver using Eigen's Sparse Cholesky methods (variable blocksize)", "Eigen", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [3/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	dl_var_cholmod	,
		new	CholmodSolverCreatorOptimizationAlgorithmProperty("dl_var_cholmod", "Dogleg: Cholesky solver using CHOLMOD (variable blocksize)", "CHOLMOD", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [4/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	dl_var_csparse	,
		new	CSparseSolverCreatorOptimizationAlgorithmProperty("dl_var_csparse", "Dogleg: Cholesky solver using CSparse (variable blocksize)", "CSparse", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [5/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_dense	,
		new	DenseSolverCreatorOptimizationAlgorithmProperty("gn_dense", "Gauss-Newton: Dense solver (variable blocksize)", "Dense", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [6/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_dense3_2	,
		new	DenseSolverCreatorOptimizationAlgorithmProperty("gn_dense3_2", "Gauss-Newton: Dense solver (fixed blocksize)", "Dense", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [7/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_dense6_3	,
		new	DenseSolverCreatorOptimizationAlgorithmProperty("gn_dense6_3", "Gauss-Newton: Dense solver (fixed blocksize)", "Dense", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [8/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_dense7_3	,
		new	DenseSolverCreatorOptimizationAlgorithmProperty("gn_dense7_3", "Gauss-Newton: Dense solver (fixed blocksize)", "Dense", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [9/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_fix3_2	,
		new	EigenSolverCreatorOptimizationAlgorithmProperty("gn_fix3_2", "Gauss-Newton: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [10/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_fix3_2_cholmod	,
		new	CholmodSolverCreatorOptimizationAlgorithmProperty("gn_fix3_2_cholmod", "Gauss-Newton: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [11/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_fix3_2_csparse	,
		new	CSparseSolverCreatorOptimizationAlgorithmProperty("gn_fix3_2_csparse", "Gauss-Newton: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [12/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_fix6_3	,
		new	EigenSolverCreatorOptimizationAlgorithmProperty("gn_fix6_3", "Gauss-Newton: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [13/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_fix6_3_cholmod	,
		new	CholmodSolverCreatorOptimizationAlgorithmProperty("gn_fix6_3_cholmod", "Gauss-Newton: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [14/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_fix6_3_csparse	,
		new	CSparseSolverCreatorOptimizationAlgorithmProperty("gn_fix6_3_csparse", "Gauss-Newton: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [15/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_fix7_3	,
		new	EigenSolverCreatorOptimizationAlgorithmProperty("gn_fix7_3", "Gauss-Newton: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [16/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_fix7_3_cholmod	,
		new	CholmodSolverCreatorOptimizationAlgorithmProperty("gn_fix7_3_cholmod", "Gauss-Newton: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [17/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_fix7_3_csparse	,
		new	CSparseSolverCreatorOptimizationAlgorithmProperty("gn_fix7_3_csparse", "Gauss-Newton: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [18/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_pcg	,
		new	PCGSolverCreatorOptimizationAlgorithmProperty("gn_pcg", "Gauss-Newton: PCG solver using block-Jacobi pre-conditioner " "(variable blocksize)", "PCG", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [19/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_pcg3_2	,
		new	PCGSolverCreatorOptimizationAlgorithmProperty("gn_pcg3_2", "Gauss-Newton: PCG solver using block-Jacobi " "pre-conditioner (fixed blocksize)", "PCG", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [20/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_pcg6_3	,
		new	PCGSolverCreatorOptimizationAlgorithmProperty("gn_pcg6_3", "Gauss-Newton: PCG solver using block-Jacobi " "pre-conditioner (fixed blocksize)", "PCG", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [21/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_pcg7_3	,
		new	PCGSolverCreatorOptimizationAlgorithmProperty("gn_pcg7_3", "Gauss-Newton: PCG solver using block-Jacobi " "pre-conditioner (fixed blocksize)", "PCG", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [22/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_var	,
		new	EigenSolverCreatorOptimizationAlgorithmProperty("gn_var", "Gauss-Newton: Cholesky solver using Eigen's Sparse Cholesky methods (variable blocksize)", "Eigen", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [23/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_var_cholmod	,
		new	CholmodSolverCreatorOptimizationAlgorithmProperty("gn_var_cholmod", "Gauss-Newton: Cholesky solver using CHOLMOD (variable blocksize)", "CHOLMOD", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [24/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	gn_var_csparse	,
		new	CSparseSolverCreatorOptimizationAlgorithmProperty("gn_var_csparse", "Gauss-Newton: Cholesky solver using CSparse (variable blocksize)", "CSparse", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [25/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_dense	,
		new	DenseSolverCreatorOptimizationAlgorithmProperty("lm_dense", "Levenberg: Dense solver (variable blocksize)", "Dense", false, -1, -1)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [26/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_dense3_2	,
		new	DenseSolverCreatorOptimizationAlgorithmProperty("lm_dense3_2", "Levenberg: Dense solver (fixed blocksize)", "Dense", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [27/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_dense6_3	,
		new	DenseSolverCreatorOptimizationAlgorithmProperty("lm_dense6_3", "Levenberg: Dense solver (fixed blocksize)", "Dense", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [28/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_dense7_3	,
		new	DenseSolverCreatorOptimizationAlgorithmProperty("lm_dense7_3", "Levenberg: Dense solver (fixed blocksize)", "Dense", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [29/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_fix3_2	,
		new	EigenSolverCreatorOptimizationAlgorithmProperty("lm_fix3_2", "Levenberg: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [30/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_fix3_2_cholmod	,
		new	CholmodSolverCreatorOptimizationAlgorithmProperty("lm_fix3_2_cholmod", "Levenberg: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [31/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_fix3_2_csparse	,
		new	CSparseSolverCreatorOptimizationAlgorithmProperty("lm_fix3_2_csparse", "Levenberg: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [32/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_fix6_3	,
		new	EigenSolverCreatorOptimizationAlgorithmProperty("lm_fix6_3", "Levenberg: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [33/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_fix6_3_cholmod	,
		new	CholmodSolverCreatorOptimizationAlgorithmProperty("lm_fix6_3_cholmod", "Levenberg: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [34/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_fix6_3_csparse	,
		new	CSparseSolverCreatorOptimizationAlgorithmProperty("lm_fix6_3_csparse", "Levenberg: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [35/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_fix7_3	,
		new	EigenSolverCreatorOptimizationAlgorithmProperty("lm_fix7_3", "Levenberg: Cholesky solver using Eigen's Sparse Cholesky (fixed blocksize)", "Eigen", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [36/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_fix7_3_cholmod	,
		new	CholmodSolverCreatorOptimizationAlgorithmProperty("lm_fix7_3_cholmod", "Levenberg: Cholesky solver using CHOLMOD (fixed blocksize)", "CHOLMOD", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [37/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_fix7_3_csparse	,
		new	CSparseSolverCreatorOptimizationAlgorithmProperty("lm_fix7_3_csparse", "Levenberg: Cholesky solver using CSparse (fixed blocksize)", "CSparse", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [38/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_pcg	,
		new	PCGSolverCreatorOptimizationAlgorithmProperty("lm_pcg", "Levenberg: PCG solver using block-Jacobi pre-conditioner " "(variable blocksize)", "PCG", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [39/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_pcg3_2	,
		new	PCGSolverCreatorOptimizationAlgorithmProperty("lm_pcg3_2", "Levenberg: PCG solver using block-Jacobi pre-conditioner " "(fixed blocksize)", "PCG", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [40/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_pcg6_3	,
		new	PCGSolverCreatorOptimizationAlgorithmProperty("lm_pcg6_3", "Levenberg: PCG solver using block-Jacobi pre-conditioner " "(fixed blocksize)", "PCG", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [41/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_pcg7_3	,
		new	PCGSolverCreatorOptimizationAlgorithmProperty("lm_pcg7_3", "Levenberg: PCG solver using block-Jacobi pre-conditioner " "(fixed blocksize)", "PCG", true, 7, 3)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [42/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_var	,
		new	EigenSolverCreatorOptimizationAlgorithmProperty("lm_var", "Levenberg: Cholesky solver using Eigen's Sparse Cholesky methods (variable blocksize)", "Eigen", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [43/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_var_cholmod	,
		new	CholmodSolverCreatorOptimizationAlgorithmProperty("lm_var_cholmod", "Levenberg: Cholesky solver using CHOLMOD (variable blocksize)", "CHOLMOD", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [44/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	lm_var_csparse	,
		new	CSparseSolverCreatorOptimizationAlgorithmProperty("lm_var_csparse", "Levenberg: Cholesky solver using CSparse (variable blocksize)", "CSparse", false, Eigen::Dynamic, Eigen::Dynamic)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [45/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	structure_only_2	,
		new	StructureOnlyCreatorOptimizationAlgorithmProperty("structure_only_2", "Optimize the landmark poses (2D)", "Eigen", true, 3, 2)
	)

G2O_REGISTER_OPTIMIZATION_ALGORITHM() [46/46]

g2o::G2O_REGISTER_OPTIMIZATION_ALGORITHM	(	structure_only_3	,
		new	StructureOnlyCreatorOptimizationAlgorithmProperty("structure_only_3", "Optimize the landmark poses (3D)", "Eigen", true, 6, 3)
	)

G2O_REGISTER_OPTIMIZATION_LIBRARY() [1/7]

g2o::G2O_REGISTER_OPTIMIZATION_LIBRARY

(

cholmod

)

G2O_REGISTER_OPTIMIZATION_LIBRARY() [2/7]

g2o::G2O_REGISTER_OPTIMIZATION_LIBRARY

(

csparse

)

G2O_REGISTER_OPTIMIZATION_LIBRARY() [3/7]

g2o::G2O_REGISTER_OPTIMIZATION_LIBRARY

(

dense

)

G2O_REGISTER_OPTIMIZATION_LIBRARY() [4/7]

g2o::G2O_REGISTER_OPTIMIZATION_LIBRARY

(

eigen

)

G2O_REGISTER_OPTIMIZATION_LIBRARY() [5/7]

g2o::G2O_REGISTER_OPTIMIZATION_LIBRARY

(

pcg

)

G2O_REGISTER_OPTIMIZATION_LIBRARY() [6/7]

g2o::G2O_REGISTER_OPTIMIZATION_LIBRARY

(

slam2d_linear

)

G2O_REGISTER_OPTIMIZATION_LIBRARY() [7/7]

g2o::G2O_REGISTER_OPTIMIZATION_LIBRARY

(

structure_only

)

G2O_REGISTER_TYPE() [1/78]

g2o::G2O_REGISTER_TYPE	(	CACHE_CAMERA	,
		CacheCamera
	)

G2O_REGISTER_TYPE() [2/78]

g2o::G2O_REGISTER_TYPE	(	CACHE_SE2_OFFSET	,
		CacheSE2Offset
	)

G2O_REGISTER_TYPE() [3/78]

g2o::G2O_REGISTER_TYPE	(	CACHE_SE3_OFFSET	,
		CacheSE3Offset
	)

G2O_REGISTER_TYPE() [4/78]

g2o::G2O_REGISTER_TYPE	(	EDGE3	,
		EdgeSE3Euler
	)

G2O_REGISTER_TYPE() [5/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_BEARING_SE2_XY	,
		EdgeSE2PointXYBearing
	)

G2O_REGISTER_TYPE() [6/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_CAM	,
		EdgeSBACam
	)

G2O_REGISTER_TYPE() [7/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_LINE2D	,
		EdgeLine2D
	)

G2O_REGISTER_TYPE() [8/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_LINE2D_POINTXY	,
		EdgeLine2DPointXY
	)

G2O_REGISTER_TYPE() [9/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PLANE	,
		EdgePlane
	)

G2O_REGISTER_TYPE() [10/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_POINTXY	,
		EdgePointXY
	)

G2O_REGISTER_TYPE() [11/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_POINTXYZ	,
		EdgePointXYZ
	)

G2O_REGISTER_TYPE() [12/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_POINTXYZ_PRIOR	,
		EdgeXYZPrior
	)

G2O_REGISTER_TYPE() [13/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PRIOR_SE2	,
		EdgeSE2Prior
	)

G2O_REGISTER_TYPE() [14/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PRIOR_SE2_XY	,
		EdgeSE2XYPrior
	)

G2O_REGISTER_TYPE() [15/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PRIOR_XY	,
		EdgeXYPrior
	)

G2O_REGISTER_TYPE() [16/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PROJECT_DEPTH	,
		EdgeSE3PointXYZDepth
	)

G2O_REGISTER_TYPE() [17/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PROJECT_DISPARITY	,
		EdgeSE3PointXYZDisparity
	)

G2O_REGISTER_TYPE() [18/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PROJECT_INVERSE_SIM3_XYZ :EXPMAP	,
		EdgeInverseSim3ProjectXYZ
	)

G2O_REGISTER_TYPE() [19/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PROJECT_P2MC	,
		EdgeProjectP2MC
	)

G2O_REGISTER_TYPE() [20/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PROJECT_P2SC	,
		EdgeProjectP2SC
	)

G2O_REGISTER_TYPE() [21/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PROJECT_SIM3_XYZ :EXPMAP	,
		EdgeSim3ProjectXYZ
	)

G2O_REGISTER_TYPE() [22/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PROJECT_XYZ2UV:EXPMAP	,
		EdgeProjectXYZ2UV
	)

G2O_REGISTER_TYPE() [23/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_PROJECT_XYZ2UVU:EXPMAP	,
		EdgeProjectXYZ2UVU
	)

G2O_REGISTER_TYPE() [24/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SCALE	,
		EdgeSBAScale
	)

G2O_REGISTER_TYPE() [25/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2	,
		EdgeSE2
	)

G2O_REGISTER_TYPE() [26/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_CALIB	,
		EdgeSE2SensorCalib
	)

G2O_REGISTER_TYPE() [27/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_LINE2D	,
		EdgeSE2Line2D
	)

G2O_REGISTER_TYPE() [28/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_LOTSOFXY	,
		EdgeSE2LotsOfXY
	)

G2O_REGISTER_TYPE() [29/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_ODOM_DIFFERENTIAL_CALIB	,
		EdgeSE2OdomDifferentialCalib
	)

G2O_REGISTER_TYPE() [30/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_OFFSET	,
		EdgeSE2Offset
	)

G2O_REGISTER_TYPE() [31/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_POINTXY_OFFSET	,
		EdgeSE2PointXYOffset
	)

G2O_REGISTER_TYPE() [32/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_SEGMENT2D	,
		EdgeSE2Segment2D
	)

G2O_REGISTER_TYPE() [33/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_SEGMENT2D_LINE	,
		EdgeSE2Segment2DLine
	)

G2O_REGISTER_TYPE() [34/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_SEGMENT2D_POINTLINE	,
		EdgeSE2Segment2DPointLine
	)

G2O_REGISTER_TYPE() [35/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_TWOPOINTSXY	,
		EdgeSE2TwoPointsXY
	)

G2O_REGISTER_TYPE() [36/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_XY	,
		EdgeSE2PointXY
	)

G2O_REGISTER_TYPE() [37/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE2_XY_CALIB	,
		EdgeSE2PointXYCalib
	)

G2O_REGISTER_TYPE() [38/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3:EXPMAP	,
		EdgeSE3Expmap
	)

G2O_REGISTER_TYPE() [39/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3:QUAT	,
		EdgeSE3
	)

G2O_REGISTER_TYPE() [40/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3_CALIB	,
		EdgeSE3Calib
	)

G2O_REGISTER_TYPE() [41/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3_LINE3D	,
		EdgeSE3Line3D
	)

G2O_REGISTER_TYPE() [42/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3_OFFSET	,
		EdgeSE3Offset
	)

G2O_REGISTER_TYPE() [43/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3_PLANE_CALIB	,
		EdgeSE3PlaneSensorCalib
	)

G2O_REGISTER_TYPE() [44/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3_PRIOR	,
		EdgeSE3Prior
	)

G2O_REGISTER_TYPE() [45/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3_PROJECT_XYZ:EXPMAP	,
		EdgeSE3ProjectXYZ
	)

G2O_REGISTER_TYPE() [46/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3_PROJECT_XYZONLYPOSE:EXPMAP	,
		EdgeSE3ProjectXYZOnlyPose
	)

G2O_REGISTER_TYPE() [47/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3_TRACKXYZ	,
		EdgeSE3PointXYZ
	)

G2O_REGISTER_TYPE() [48/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SE3_XYZ_PRIOR	,
		EdgeSE3XYZPrior
	)

G2O_REGISTER_TYPE() [49/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_SIM3 :EXPMAP	,
		EdgeSim3
	)

G2O_REGISTER_TYPE() [50/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_STEREO_SE3_PROJECT_XYZ:EXPMAP	,
		EdgeStereoSE3ProjectXYZ
	)

G2O_REGISTER_TYPE() [51/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_STEREO_SE3_PROJECT_XYZONLYPOSE:EXPMAP	,
		EdgeStereoSE3ProjectXYZOnlyPose
	)

G2O_REGISTER_TYPE() [52/78]

g2o::G2O_REGISTER_TYPE	(	EDGE_V_V_GICP	,
		Edge_V_V_GICP
	)

G2O_REGISTER_TYPE() [53/78]

g2o::G2O_REGISTER_TYPE	(	ONLINE_EDGE_SE2	,
		OnlineEdgeSE2
	)

G2O_REGISTER_TYPE() [54/78]

g2o::G2O_REGISTER_TYPE	(	ONLINE_EDGE_SE3:QUAT	,
		OnlineEdgeSE3
	)

G2O_REGISTER_TYPE() [55/78]

g2o::G2O_REGISTER_TYPE	(	ONLINE_VERTEX_SE2	,
		OnlineVertexSE2
	)

G2O_REGISTER_TYPE() [56/78]

g2o::G2O_REGISTER_TYPE	(	ONLINE_VERTEX_SE3:QUAT	,
		OnlineVertexSE3
	)

G2O_REGISTER_TYPE() [57/78]

g2o::G2O_REGISTER_TYPE	(	PARAMS_CAMERACALIB	,
		ParameterCamera
	)

G2O_REGISTER_TYPE() [58/78]

g2o::G2O_REGISTER_TYPE	(	PARAMS_CAMERAPARAMETERS	,
		CameraParameters
	)

G2O_REGISTER_TYPE() [59/78]

g2o::G2O_REGISTER_TYPE	(	PARAMS_SE2OFFSET	,
		ParameterSE2Offset
	)

G2O_REGISTER_TYPE() [60/78]

g2o::G2O_REGISTER_TYPE	(	PARAMS_SE3OFFSET	,
		ParameterSE3Offset
	)

G2O_REGISTER_TYPE() [61/78]

g2o::G2O_REGISTER_TYPE	(	PARAMS_STEREOCAMERACALIB	,
		ParameterStereoCamera
	)

G2O_REGISTER_TYPE() [62/78]

g2o::G2O_REGISTER_TYPE	(	ROBOTLASER1	,
		RobotLaser
	)

G2O_REGISTER_TYPE() [63/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX3	,
		VertexSE3Euler
	)

G2O_REGISTER_TYPE() [64/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_CAM	,
		VertexCam
	)

G2O_REGISTER_TYPE() [65/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_ELLIPSE	,
		VertexEllipse
	)

G2O_REGISTER_TYPE() [66/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_INTRINSICS	,
		VertexIntrinsics
	)

G2O_REGISTER_TYPE() [67/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_LINE2D	,
		VertexLine2D
	)

G2O_REGISTER_TYPE() [68/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_LINE3D	,
		VertexLine3D
	)

G2O_REGISTER_TYPE() [69/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_ODOM_DIFFERENTIAL	,
		VertexOdomDifferentialParams
	)

G2O_REGISTER_TYPE() [70/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_PLANE	,
		VertexPlane
	)

G2O_REGISTER_TYPE() [71/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_SE2	,
		VertexSE2
	)

G2O_REGISTER_TYPE() [72/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_SE3:EXPMAP	,
		VertexSE3Expmap
	)

G2O_REGISTER_TYPE() [73/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_SE3:QUAT	,
		VertexSE3
	)

G2O_REGISTER_TYPE() [74/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_SEGMENT2D	,
		VertexSegment2D
	)

G2O_REGISTER_TYPE() [75/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_SIM3 :EXPMAP	,
		VertexSim3Expmap
	)

G2O_REGISTER_TYPE() [76/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_TAG	,
		VertexTag
	)

G2O_REGISTER_TYPE() [77/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_TRACKXYZ	,
		VertexPointXYZ
	)

G2O_REGISTER_TYPE() [78/78]

g2o::G2O_REGISTER_TYPE	(	VERTEX_XY	,
		VertexPointXY
	)

G2O_REGISTER_TYPE_GROUP() [1/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

data

)

G2O_REGISTER_TYPE_GROUP() [2/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

expmap

)

G2O_REGISTER_TYPE_GROUP() [3/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

icp

)

G2O_REGISTER_TYPE_GROUP() [4/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

online

)

G2O_REGISTER_TYPE_GROUP() [5/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

sba

)

G2O_REGISTER_TYPE_GROUP() [6/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

sclam

)

G2O_REGISTER_TYPE_GROUP() [7/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

sim3

)

G2O_REGISTER_TYPE_GROUP() [8/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

slam2d

)

G2O_REGISTER_TYPE_GROUP() [9/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

slam2d_segment

)

G2O_REGISTER_TYPE_GROUP() [10/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

slam3d

)

G2O_REGISTER_TYPE_GROUP() [11/11]

g2o::G2O_REGISTER_TYPE_GROUP

(

slam3d_addons

)

G2O_USE_OPTIMIZATION_LIBRARY()

g2o::G2O_USE_OPTIMIZATION_LIBRARY

(

cholmod

)

G2O_USE_TYPE_GROUP() [1/2]

g2o::G2O_USE_TYPE_GROUP

(

sba

)

G2O_USE_TYPE_GROUP() [2/2]

g2o::G2O_USE_TYPE_GROUP

(

slam2d

)

get_monotonic_time()

G2O_STUFF_API double g2o::get_monotonic_time

(

)

return a monotonic increasing time which basically does not need to have a reference point. Consider this for measuring how long some code fragments required to execute.

Definition at line 43 of file timeutil.cpp.

                            {
  return seconds{std::chrono::steady_clock::now().time_since_epoch()}.count();
}

Referenced by g2o::LinearSolverEigen< MatrixType >::computeCholesky(), g2o::LinearSolverCholmod< MatrixType >::computeCholmodFactor(), g2o::BlockSolver< Traits >::computeMarginals(), g2o::LinearSolverCholmodOnline< MatrixType >::computeSymbolicDecomposition(), g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition(), g2o::LinearSolverCSparse< MatrixType >::computeSymbolicDecomposition(), g2o::LinearSolverEigen< MatrixType >::computeSymbolicDecomposition(), main(), g2o::SparseOptimizer::optimize(), g2o::BlockSolver< Traits >::solve(), g2o::LinearSolverCholmodOnline< MatrixType >::solve(), g2o::LinearSolverCholmod< MatrixType >::solve(), g2o::LinearSolverCSparse< MatrixType >::solve(), g2o::LinearSolverEigen< MatrixType >::solve(), g2o::OptimizationAlgorithmDogleg::solve(), g2o::OptimizationAlgorithmGaussNewton::solve(), g2o::OptimizationAlgorithmLevenberg::solve(), tictoc(), and g2o::ScopeTime::~ScopeTime().

get_time()

double g2o::get_time ( )

inline

return the current time in seconds since 1. Jan 1970

Definition at line 82 of file timeutil.h.

                         {
  return seconds{std::chrono::system_clock::now().time_since_epoch()}.count();
}

getBasename()

G2O_STUFF_API std::string g2o::getBasename

(

const std::string &

filename

)

return the basename of the given filename /etc/fstab -> fstab

Definition at line 78 of file filesys_tools.cpp.

                                                 {
#ifdef WINDOWS
  std::string::size_type lastSlash = filename.find_last_of('\\');
#else
  std::string::size_type lastSlash = filename.find_last_of('/');
#endif
  if (lastSlash != std::string::npos)
    return filename.substr(lastSlash + 1);
  else
    return filename;
}

getDirname()

G2O_STUFF_API std::string g2o::getDirname

(

const std::string &

filename

)

return the directory of a given filename /etc/fstab -> /etc

Definition at line 90 of file filesys_tools.cpp.

                                                {
#ifdef WINDOWS
  std::string::size_type lastSlash = filename.find_last_of('\\');
#else
  std::string::size_type lastSlash = filename.find_last_of('/');
#endif
  if (lastSlash != std::string::npos)
    return filename.substr(0, lastSlash);
  else
    return "";
}

Referenced by loadStandardSolver(), and loadStandardTypes().

getFileExtension()

G2O_STUFF_API std::string g2o::getFileExtension

(

const std::string &

filename

)

get filename extension (the part after the last .), e.g. the extension of file.txt is txt

Definition at line 62 of file filesys_tools.cpp.

                                                      {
  std::string::size_type lastDot = filename.find_last_of('.');
  if (lastDot != std::string::npos)
    return filename.substr(lastDot + 1);
  else
    return "";
}

Referenced by gnudump_edges(), gnudump_features(), and saveGnuplot().

getFilesByPattern()

G2O_STUFF_API std::vector< std::string > g2o::getFilesByPattern

(

const char *

pattern

)

return all files that match a given pattern, e.g., ~/blaa*.txt, /tmp/a*

Definition at line 119 of file filesys_tools.cpp.

                                                            {
  std::vector<std::string> result;
 
#ifdef WINDOWS
 
  HANDLE hFind;
  WIN32_FIND_DATA FData;
  if ((hFind = FindFirstFile(pattern, &FData)) != INVALID_HANDLE_VALUE) {
    do {
      result.push_back(FData.cFileName);
    } while (FindNextFile(hFind, &FData));
    FindClose(hFind);
  }
 
#elif (defined(UNIX) || defined(CYGWIN)) && !defined(ANDROID)
 
  wordexp_t p;
  wordexp(pattern, &p, 0);
 
  // For some reason, wordexp sometimes fails on an APPLE machine to
  // return anything; therefore, run it several times until we do find
  // something - or give up
#ifdef __APPLE__
  for (int k = 0; (k < 100) && (p.we_wordc == 0); k++) {
    // chrono::milliseconds duration(20);
    // this_thread::sleep_for(duration);
    wordexp(pattern, &p, WRDE_APPEND);
  }
#endif
 
  result.reserve(p.we_wordc);
  for (size_t i = 0; i < p.we_wordc; ++i) result.push_back(p.we_wordv[i]);
 
  wordfree(&p);
 
#endif
 
  return result;
}

Referenced by g2o::DlWrapper::openLibraries().

getPureFilename()

G2O_STUFF_API std::string g2o::getPureFilename

(

const std::string &

filename

)

get the filename without the extension. file.txt -> file

Definition at line 70 of file filesys_tools.cpp.

                                                     {
  std::string::size_type lastDot = filename.find_last_of('.');
  if (lastDot != std::string::npos)
    return filename.substr(0, lastDot);
  else
    return filename;
}

Referenced by gnudump_edges(), gnudump_features(), and saveGnuplot().

hypot()

template<typename T >

T g2o::hypot ( T  x, T  y  )

inline

return the hypot of x and y

Definition at line 76 of file misc.h.

                         {
  return (T)(std::sqrt(x * x + y * y));
}

hypot_sqr()

template<typename T >

T g2o::hypot_sqr ( T  x, T  y  )

inline

return the squared hypot of x and y

Definition at line 84 of file misc.h.

                             {
  return x * x + y * y;
}

Referenced by g2o::tutorial::Simulator::simulate().

inverse_theta()

double g2o::inverse_theta ( double  th )

inline

inverse of an angle, i.e., +180 degree

Definition at line 112 of file misc.h.

                                       {
  return normalize_theta(th + const_pi());
}

References const_pi(), and normalize_theta().

jac_quat3_euler3()

static void g2o::jac_quat3_euler3 ( Eigen::Matrix< double, 6, 6, Eigen::ColMajor > &  J, const Isometry3 &  t  )

static

conversion code from Euler angles

Definition at line 38 of file edge_se3_euler.cpp.

                                                 {
  Vector7 t0 = g2o::internal::toVectorQT(t);
 
  double delta = cst(1e-6);
  double idelta = 1 / (2 * delta);
 
  Vector7 ta;
  Vector7 tb;
  for (int i = 0; i < 6; i++) {
    ta = tb = t0;
    ta[i] -= delta;
    tb[i] += delta;
    Vector6 ea = g2o::internal::toVectorET(g2o::internal::fromVectorQT(ta));
    Vector6 eb = g2o::internal::toVectorET(g2o::internal::fromVectorQT(tb));
    J.col(i) = (eb - ea) * idelta;
  }
}

References cst(), g2o::internal::fromVectorQT(), g2o::internal::toVectorET(), and g2o::internal::toVectorQT().

Referenced by g2o::G2oSlamInterface::addEdge(), g2o::EdgeSE3Euler::read(), and g2o::EdgeSE3Euler::write().

loadStandardSolver()

G2O_CLI_API void g2o::loadStandardSolver	(	DlWrapper &	dlSolverWrapper,
		int	argc = 0,
		char **	argv = 0
	)

will also look for -solverlib in (argc, argv) and load that solver

Definition at line 135 of file g2o_common.cpp.

                                                                           {
  char* envSolversPath = getenv("G2O_SOLVERS_DIR");
  string solversPath = G2O_DEFAULT_SOLVERS_DIR_;
 
  if (envSolversPath != NULL) {
    solversPath = envSolversPath;
  } else {
#if (defined UNIX)
    if (dladdr(&info, &info) != 0) {
      solversPath = getDirname(info.dli_fname);
    }
#elif (defined WINDOWS)
    char libFilename[MAX_PATH + 1];
    HMODULE instance = getMyInstance();
    if (instance && GetModuleFileName(instance, libFilename, MAX_PATH) > 0) {
      solversPath = getDirname(libFilename);
    }
#endif
  }
 
  vector<string> paths = strSplit(solversPath, PATH_SEPARATOR);
  for (vector<string>::const_iterator it = paths.begin(); it != paths.end();
       ++it) {
    if (it->size() > 0) dlSolverWrapper.openLibraries(*it, SOLVERS_PATTERN);
  }
 
  vector<string> libs;
  if (argc > 0 && argv != 0) findArguments("-solverlib", libs, argc, argv);
  for (vector<string>::const_iterator it = libs.begin(); it != libs.end();
       ++it) {
    cerr << "Loading solver " << *it << endl;
    dlSolverWrapper.openLibrary(*it);
  }
}

References findArguments(), getDirname(), getMyInstance(), g2o::DlWrapper::openLibraries(), g2o::DlWrapper::openLibrary(), PATH_SEPARATOR, SOLVERS_PATTERN, and strSplit().

Referenced by main().

loadStandardTypes()

G2O_CLI_API void g2o::loadStandardTypes	(	DlWrapper &	dlWrapper,
		int	argc = 0,
		char **	argv = 0
	)

will also look for -typeslib in (argc, argv) and load that types

Definition at line 99 of file g2o_common.cpp.

                                                                         {
  char* envTypesPath = getenv("G2O_TYPES_DIR");
  string typesPath;
 
  if (envTypesPath != NULL) {
    typesPath = envTypesPath;
  } else {
    typesPath = G2O_DEFAULT_TYPES_DIR_;
#if (defined UNIX)
    if (dladdr(&info, &info) != 0) {
      typesPath = getDirname(info.dli_fname);
    }
#elif (defined WINDOWS)
    char libFilename[MAX_PATH + 1];
    HMODULE instance = getMyInstance();
    if (instance && GetModuleFileName(instance, libFilename, MAX_PATH) > 0) {
      typesPath = getDirname(libFilename);
    }
#endif
  }
 
  vector<string> paths = strSplit(typesPath, PATH_SEPARATOR);
  for (vector<string>::const_iterator it = paths.begin(); it != paths.end();
       ++it) {
    if (it->size() > 0) dlTypesWrapper.openLibraries(*it, TYPES_PATTERN);
  }
 
  vector<string> libs;
  if (argc > 0 && argv != 0) findArguments("-typeslib", libs, argc, argv);
  for (vector<string>::const_iterator it = libs.begin(); it != libs.end();
       ++it) {
    cerr << "Loading types " << *it << endl;
    dlTypesWrapper.openLibrary(*it);
  }
}

References findArguments(), getDirname(), getMyInstance(), g2o::DlWrapper::openLibraries(), g2o::DlWrapper::openLibrary(), PATH_SEPARATOR, strSplit(), and TYPES_PATTERN.

Referenced by main().

normalize_theta()

double g2o::normalize_theta ( double  theta )

inline

normalize the angle

Definition at line 103 of file misc.h.

                                            {
  const double result = fmod(theta + const_pi(), 2.0 * const_pi());
  if (result <= 0.0) return result + const_pi();
  return result - const_pi();
}

References const_pi().

Referenced by g2o::EdgeSE2PointXYBearing::computeError(), g2o::EdgeSE2Line2D::computeError(), g2o::EdgeSE2Segment2DLine::computeError(), g2o::EdgeSE2Segment2DPointLine::computeError(), g2o::EdgeSE2Line2D::initialEstimate(), g2o::tutorial::SE2::inverse(), g2o::SE2::inverse(), inverse_theta(), operator*(), g2o::tutorial::SE2::operator*(), g2o::tutorial::SE2::operator*=(), g2o::SE2::operator*=(), g2o::VertexSE2::oplusImpl(), g2o::VertexLine2D::oplusImpl(), g2o::OnlineVertexSE2::oplusUpdatedEstimate(), g2o::EdgeSE2Line2D::setMeasurementFromState(), and g2o::SolverSLAM2DLinear::solveOrientation().

operator*() [1/3]

G2O_TYPES_SLAM3D_ADDONS_API Line3D g2o::operator*	(	const Isometry3 &	t,
		const Line3D &	line
	)

Definition at line 51 of file line3d.cpp.

                                                         {
  Matrix6 A = Matrix6::Zero();
  A.block<3, 3>(0, 0) = t.linear();
  A.block<3, 3>(0, 3) = _skew(t.translation()) * t.linear();
  A.block<3, 3>(3, 3) = t.linear();
  Vector6 v = (Vector6)line;
  return Line3D(A * v);
}

operator*() [2/3]

Plane3D g2o::operator* ( const Isometry3 &  t, const Plane3D &  plane  )

inline

Definition at line 107 of file plane3d.h.

                                                                   {
  Vector4 v = plane._coeffs;
  Vector4 v2;
  Matrix3 R = t.rotation();
  v2.head<3>() = R * v.head<3>();
  v2(3) = v(3) - t.translation().dot(v2.head<3>());
  return Plane3D(v2);
};

operator*() [3/3]

Line2D g2o::operator* ( const SE2 &  t, const Line2D &  l  )

inline

Definition at line 47 of file line_2d.h.

                                                       {
  Line2D est = l;
  est[0] += t.rotation().angle();
  est[0] = normalize_theta(est[0]);
  Vector2 n(std::cos(est[0]), std::sin(est[0]));
  est[1] += n.dot(t.translation());
  return est;
}

References normalize_theta(), g2o::SE2::rotation(), and g2o::SE2::translation().

operator<()

bool g2o::operator<	(	const HyperDijkstra::AdjacencyMapEntry &	a,
		const HyperDijkstra::AdjacencyMapEntry &	b
	)

Definition at line 85 of file hyper_dijkstra.cpp.

                                                        {
  return a.distance() > b.distance();
}

References g2o::HyperDijkstra::AdjacencyMapEntry::distance().

operator<<() [1/5]

template<class MatrixType >

std::ostream & g2o::operator<<	(	std::ostream &	os,
		const SparseBlockMatrix< MatrixType > &	m
	)

Definition at line 428 of file sparse_block_matrix.hpp.

                                                                 {
  os << "RBI: " << m.rowBlockIndices().size();
  for (size_t i = 0; i < m.rowBlockIndices().size(); ++i)
    os << " " << m.rowBlockIndices()[i];
  os << std::endl;
  os << "CBI: " << m.colBlockIndices().size();
  for (size_t i = 0; i < m.colBlockIndices().size(); ++i)
    os << " " << m.colBlockIndices()[i];
  os << std::endl;
 
  for (size_t i = 0; i < m.blockCols().size(); ++i) {
    for (typename SparseBlockMatrix<MatrixType>::IntBlockMap::const_iterator
             it = m.blockCols()[i].begin();
         it != m.blockCols()[i].end(); ++it) {
      const typename SparseBlockMatrix<MatrixType>::SparseMatrixBlock* b =
          it->second;
      os << "BLOCK: " << it->first << " " << i << std::endl;
      os << *b << std::endl;
    }
  }
  return os;
}

References g2o::SparseBlockMatrix< MatrixType >::blockCols(), g2o::SparseBlockMatrix< MatrixType >::colBlockIndices(), and g2o::SparseBlockMatrix< MatrixType >::rowBlockIndices().

operator<<() [2/5]

G2O_CORE_API std::ostream & g2o::operator<<	(	std::ostream &	os,
		const G2OBatchStatistics &	st
	)

timings

Definition at line 48 of file batch_stats.cpp.

                                                                     {
  os << PTHING(iteration);
 
  os << PTHING(numVertices);  // how many vertices are involved
  os << PTHING(numEdges);     // hoe many edges
  os << PTHING(chi2);         // total chi2
 
  // nonlinear part
  os << PTHING(timeResiduals);
  os << PTHING(timeLinearize);      // jacobians
  os << PTHING(timeQuadraticForm);  // construct the quadratic form in the graph
 
  // block_solver (constructs Ax=b, plus maybe schur);
  os << PTHING(
      timeSchurComplement);  // compute schur complement (0 if not done);
 
  // linear solver (computes Ax=b); );
  os << PTHING(
      timeSymbolicDecomposition);  // symbolic decomposition (0 if not done);
  os << PTHING(
      timeNumericDecomposition);     // numeric decomposition  (0 if not done);
  os << PTHING(timeLinearSolution);  // total time for solving Ax=b
  os << PTHING(iterationsLinearSolver);  // iterations of PCG
  os << PTHING(timeUpdate);              // oplus
  os << PTHING(timeIteration);           // total time );
 
  os << PTHING(levenbergIterations);
  os << PTHING(timeLinearSolver);
 
  os << PTHING(hessianDimension);
  os << PTHING(hessianPoseDimension);
  os << PTHING(hessianLandmarkDimension);
  os << PTHING(choleskyNNZ);
  os << PTHING(timeMarginals);
 
  return os;
};

References PTHING.

operator<<() [3/5]

std::ostream & g2o::operator<<	(	std::ostream &	out_str,
		const SBACam &	cam
	)

Definition at line 125 of file sbacam.cpp.

                                                               {
  out_str << cam.translation().transpose() << std::endl;
  out_str << cam.rotation().coeffs().transpose() << std::endl << std::endl;
  out_str << cam.Kcam << std::endl << std::endl;
  out_str << cam.w2n << std::endl << std::endl;
  out_str << cam.w2i << std::endl << std::endl;
  return out_str;
}

References g2o::SBACam::Kcam, g2o::SE3Quat::rotation(), g2o::SE3Quat::translation(), g2o::SBACam::w2i, and g2o::SBACam::w2n.

operator<<() [4/5]

std::ostream & g2o::operator<< ( std::ostream &  out_str, const SE3Quat &  se3  )

inline

Definition at line 268 of file se3quat.h.

                                                                       {
  out_str << se3.to_homogeneous_matrix() << std::endl;
  return out_str;
}

References g2o::SE3Quat::to_homogeneous_matrix().

operator<<() [5/5]

std::ostream & g2o::operator<< ( std::ostream &  out_str, const Sim3 &  sim3  )

inline

Definition at line 258 of file sim3.h.

                                                                     {
  out_str << sim3.rotation().coeffs() << std::endl;
  out_str << sim3.translation() << std::endl;
  out_str << sim3.scale() << std::endl;
 
  return out_str;
}

References g2o::Sim3::rotation(), g2o::Sim3::scale(), and g2o::Sim3::translation().

project() [1/2]

G2O_TYPES_SLAM3D_API Vector2 g2o::project ( const Vector3 &  )

inline

Referenced by g2o::CameraParameters::cam_map(), g2o::EdgeSE3ProjectXYZ::cam_project(), and g2o::EdgeSE3ProjectXYZOnlyPose::cam_project().

project() [2/2]

G2O_TYPES_SLAM3D_API Vector3 g2o::project ( const Vector4 &  )

inline

rad2deg()

double g2o::rad2deg ( double  rad )

inline

convert from radian to degree

Definition at line 98 of file misc.h.

{ return rad * cst(57.29577951308232087721); }

References cst().

readFloats()

template<typename OutputIterator >

OutputIterator g2o::readFloats	(	const char *	str,
		OutputIterator	out
	)

read float values (separated by spaces) from a string and store them in the given OutputIterator.

Definition at line 94 of file string_tools.h.

                                                               {
  char* cl = (char*)str;
  char* cle = cl;
  while (1) {
    double val = strtod(cl, &cle);
    if (cl == cle) break;
    *out++ = val;
    cl = cle;
  }
  return out;
}

References out.

readInts()

template<typename OutputIterator >

OutputIterator g2o::readInts	(	const char *	str,
		OutputIterator	out
	)

read integer values (separated by spaces) from a string and store them in the given OutputIterator.

Definition at line 77 of file string_tools.h.

                                                             {
  char* cl = (char*)str;
  char* cle = cl;
  while (1) {
    long int id = strtol(cl, &cle, 10);
    if (cl == cle) break;
    *out++ = id;
    cl = cle;
  }
  return out;
}

References out.

readLine()

G2O_STUFF_API int g2o::readLine	(	std::istream &	is,
		std::stringstream &	currentLine
	)

read a line from is into currentLine.

Returns

the number of characters read into currentLine (excluding newline), -1 on eof()

Definition at line 161 of file string_tools.cpp.

                                                           {
  if (is.eof()) return -1;
  currentLine.str("");
  currentLine.clear();
  is.get(*currentLine.rdbuf());
  if (is.fail())  // fail is set on empty lines
    is.clear();
  skipLine(is);  // read \n not read by get()
  if (currentLine.str().empty() && is.eof()) {
    return -1;
  }
  return static_cast<int>(currentLine.str().size());
}

References skipLine().

Referenced by main(), g2o::ParameterContainer::read(), g2o::Gm2dlIO::readGm2dl(), and g2o::Gm2dlIO::readRobotLaser().

reallocate_aligned()

template<typename Type >

Type * g2o::reallocate_aligned	(	Type *	ptr,
		size_t	newSize,
		size_t	oldSize
	)

Definition at line 15 of file dynamic_aligned_buffer.hpp.

                                                                    {
  return (Type*)Eigen::internal::aligned_realloc(ptr, newSize * sizeof(Type),
                                                 oldSize * sizeof(Type));
}

reconstructGaussian()

template<class SampleType , class CovarianceType >

void g2o::reconstructGaussian	(	SampleType &	mean,
		CovarianceType &	covariance,
		const std::vector< SigmaPoint< SampleType > > &	sigmaPoints
	)

Definition at line 77 of file unscented.h.

                                                          {
  mean.fill(0);
  covariance.fill(0);
  for (size_t i = 0; i < sigmaPoints.size(); i++) {
    mean += sigmaPoints[i]._wi * sigmaPoints[i]._sample;
  }
  for (size_t i = 0; i < sigmaPoints.size(); i++) {
    SampleType delta = sigmaPoints[i]._sample - mean;
    covariance += sigmaPoints[i]._wp * (delta * delta.transpose());
  }
}

Referenced by g2o::EdgeLabeler::labelEdge(), testMarginals(), and unscentedTest().

release()

template<typename T >

void g2o::release

(

T *

obj

)

Definition at line 8 of file ownership.h.

                     {
  (void)obj;
#if G2O_DELETE_IMPLICITLY_OWNED_OBJECTS
  delete obj;
#endif
}

Referenced by g2o::HyperGraph::removeEdge(), g2o::HyperGraph::removeVertex(), g2o::SparseOptimizer::setAlgorithm(), g2o::OptimizableGraph::Edge::setRobustKernel(), g2o::OptimizableGraph::Edge::~Edge(), and g2o::SparseOptimizer::~SparseOptimizer().

sampleGaussian()

double G2O_STUFF_API g2o::sampleGaussian

(

std::mt19937 *

generator

)

Definition at line 40 of file sampler.cpp.

                                             {
  if (generator) return _univariateSampler(*generator);
  return _univariateSampler(_gen_real);
}

References _gen_real, and _univariateSampler().

Referenced by g2o::GaussianSampler< SampleType, CovarianceType >::generateSample(), main(), and main().

sampleUniform()

double G2O_STUFF_API g2o::sampleUniform	(	double	min,
		double	max,
		std::mt19937 *	generator
	)

Definition at line 35 of file sampler.cpp.

                                                                    {
  if (generator) return _uniformReal(*generator) * (max - min) + min;
  return _uniformReal(_gen_real) * (max - min) + min;
}

References _gen_real, and _uniformReal.

Referenced by main(), main(), and main().

sampleUnscented()

template<class SampleType , class CovarianceType >

bool g2o::sampleUnscented	(	std::vector< SigmaPoint< SampleType > > &	sigmaPoints,
		const SampleType &	mean,
		const CovarianceType &	covariance
	)

Definition at line 48 of file unscented.h.

                                                                               {
  const int dim = mean.size();
  const int numPoints = 2 * dim + 1;
  assert(covariance.rows() == covariance.cols() &&
         covariance.cols() == mean.size() && "Dimension Mismatch");
  const double alpha = cst(1e-3);
  const double beta = 2;
  const double lambda = alpha * alpha * dim;
  const double wi = cst(1) / (2 * (dim + lambda));
 
  sigmaPoints.resize(numPoints);
  sigmaPoints[0] = SigmaPoint<SampleType>(
      mean, lambda / (dim + lambda),
      lambda / (dim + lambda) + (1. - alpha * alpha + beta));
  Eigen::LLT<CovarianceType> cholDecomp;
  cholDecomp.compute(covariance * (dim + lambda));
  if (cholDecomp.info() == Eigen::NumericalIssue) return false;
  const CovarianceType& L = cholDecomp.matrixL();
  int k = 1;
  for (int i = 0; i < dim; i++) {
    SampleType s(L.col(i));
    sigmaPoints[k++] = SigmaPoint<SampleType>(mean + s, wi, wi);
    sigmaPoints[k++] = SigmaPoint<SampleType>(mean - s, wi, wi);
  }
  return true;
}

References cst().

Referenced by g2o::EdgeLabeler::labelEdge(), testMarginals(), and unscentedTest().

saveGnuplot() [1/2]

G2O_CLI_API bool g2o::saveGnuplot	(	const std::string &	gnudump,
		const HyperGraph::VertexSet &	vertices,
		const HyperGraph::EdgeSet &	edges
	)

Definition at line 61 of file output_helper.cpp.

                                                 {
  // seek for an action whose name is writeGnuplot in the library
  HyperGraphElementAction* saveGnuplot =
      HyperGraphActionLibrary::instance()->actionByName("writeGnuplot");
  if (!saveGnuplot) {
    cerr << __PRETTY_FUNCTION__ << ": no action \"writeGnuplot\" registered"
         << endl;
    return false;
  }
  WriteGnuplotAction::Parameters params;
 
  int maxDim = -1;
  int minDim = numeric_limits<int>::max();
  for (HyperGraph::VertexSet::const_iterator it = vertices.begin();
       it != vertices.end(); ++it) {
    OptimizableGraph::Vertex* v = static_cast<OptimizableGraph::Vertex*>(*it);
    int vdim = v->dimension();
    maxDim = (std::max)(vdim, maxDim);
    minDim = (std::min)(vdim, minDim);
  }
 
  string extension = getFileExtension(gnudump);
  if (extension.size() == 0) extension = "dat";
  string baseFilename = getPureFilename(gnudump);
 
  // check for odometry edges
  bool hasOdomEdge = false;
  bool hasLandmarkEdge = false;
  for (HyperGraph::EdgeSet::const_iterator it = edges.begin();
       it != edges.end(); ++it) {
    OptimizableGraph::Edge* e = static_cast<OptimizableGraph::Edge*>(*it);
    if (e->vertices().size() == 2) {
      if (edgeAllVertsSameDim(e, maxDim))
        hasOdomEdge = true;
      else
        hasLandmarkEdge = true;
    }
    if (hasOdomEdge && hasLandmarkEdge) break;
  }
 
  bool fileStatus = true;
  if (hasOdomEdge) {
    string odomFilename = baseFilename + "_odom_edges." + extension;
    cerr << "# saving " << odomFilename << " ... ";
    ofstream fout(odomFilename.c_str());
    if (!fout) {
      cerr << "Unable to open file" << endl;
      return false;
    }
    params.os = &fout;
 
    // writing odometry edges
    for (HyperGraph::EdgeSet::const_iterator it = edges.begin();
         it != edges.end(); ++it) {
      OptimizableGraph::Edge* e = static_cast<OptimizableGraph::Edge*>(*it);
      if (e->vertices().size() != 2 || !edgeAllVertsSameDim(e, maxDim))
        continue;
      (*saveGnuplot)(e, &params);
    }
    cerr << "done." << endl;
  }
 
  if (hasLandmarkEdge) {
    string filename = baseFilename + "_landmarks_edges." + extension;
    cerr << "# saving " << filename << " ... ";
    ofstream fout(filename.c_str());
    if (!fout) {
      cerr << "Unable to open file" << endl;
      return false;
    }
    params.os = &fout;
 
    // writing landmark edges
    for (HyperGraph::EdgeSet::const_iterator it = edges.begin();
         it != edges.end(); ++it) {
      OptimizableGraph::Edge* e = static_cast<OptimizableGraph::Edge*>(*it);
      if (e->vertices().size() != 2 || edgeAllVertsSameDim(e, maxDim)) continue;
      (*saveGnuplot)(e, &params);
    }
    cerr << "done." << endl;
  }
 
  if (1) {
    string filename = baseFilename + "_edges." + extension;
    cerr << "# saving " << filename << " ... ";
    ofstream fout(filename.c_str());
    if (!fout) {
      cerr << "Unable to open file" << endl;
      return false;
    }
    params.os = &fout;
 
    // writing all edges
    for (HyperGraph::EdgeSet::const_iterator it = edges.begin();
         it != edges.end(); ++it) {
      OptimizableGraph::Edge* e = static_cast<OptimizableGraph::Edge*>(*it);
      (*saveGnuplot)(e, &params);
    }
    cerr << "done." << endl;
  }
 
  if (1) {
    string filename = baseFilename + "_vertices." + extension;
    cerr << "# saving " << filename << " ... ";
    ofstream fout(filename.c_str());
    if (!fout) {
      cerr << "Unable to open file" << endl;
      return false;
    }
    params.os = &fout;
 
    for (HyperGraph::VertexSet::const_iterator it = vertices.begin();
         it != vertices.end(); ++it) {
      OptimizableGraph::Vertex* v = static_cast<OptimizableGraph::Vertex*>(*it);
      (*saveGnuplot)(v, &params);
    }
    cerr << "done." << endl;
  }
 
  return fileStatus;
}

References __PRETTY_FUNCTION__, g2o::HyperGraphActionLibrary::actionByName(), g2o::OptimizableGraph::Vertex::dimension(), edgeAllVertsSameDim(), getFileExtension(), getPureFilename(), g2o::HyperGraphActionLibrary::instance(), g2o::WriteGnuplotAction::Parameters::os, saveGnuplot(), and g2o::HyperGraph::Edge::vertices().

saveGnuplot() [2/2]

G2O_CLI_API bool g2o::saveGnuplot	(	const std::string &	gnudump,
		const OptimizableGraph &	optimizer
	)

save the state of the optimizer into files for visualizing using Gnuplot

Definition at line 50 of file output_helper.cpp.

                                                    {
  HyperGraph::VertexSet vset;
  for (HyperGraph::VertexIDMap::const_iterator it =
           optimizer.vertices().begin();
       it != optimizer.vertices().end(); ++it) {
    vset.insert(it->second);
  }
  return saveGnuplot(gnudump, vset, optimizer.edges());
}

References g2o::HyperGraph::edges(), saveGnuplot(), and g2o::HyperGraph::vertices().

Referenced by dumpEdges(), main(), saveGnuplot(), and saveGnuplot().

sign()

template<typename T >

int g2o::sign ( T  x )

inline

sign function.

Returns

the sign of x. +1 for x > 0, -1 for x < 0, 0 for x == 0

Definition at line 135 of file misc.h.

                     {
  if (x > 0)
    return 1;
  else if (x < 0)
    return -1;
  else
    return 0;
}

skew()

G2O_TYPES_SLAM3D_API Matrix3 g2o::skew ( const Vector3 &  v )

inline

Referenced by g2o::Sim3::log(), and g2o::Sim3::Sim3().

skipLine()

G2O_STUFF_API void g2o::skipLine

(

std::istream &

is

)

read from string until the end of a line is reached.

Definition at line 175 of file string_tools.cpp.

                              {
  char c = ' ';
  while (c != '\n' && is.good() && !is.eof()) is.get(c);
}

Referenced by readLine().

square()

template<typename T >

T g2o::square ( T  x )

inline

return the square value

Definition at line 68 of file misc.h.

                     {
  return x * x;
}

starsInEdge()

void g2o::starsInEdge	(	StarSet &	stars,
		HyperGraph::Edge *	e,
		EdgeStarMap &	esmap,
		HyperGraph::VertexSet &	gauge
	)

Definition at line 103 of file simple_star_ops.cpp.

                                             {
  for (size_t i = 0; i < e->vertices().size(); i++) {
    OptimizableGraph::Vertex* v = (OptimizableGraph::Vertex*)e->vertices()[i];
    if (gauge.find(v) == gauge.end()) starsInVertex(stars, v, esmap);
  }
}

References starsInVertex(), and g2o::HyperGraph::Edge::vertices().

Referenced by computeBorder().

starsInVertex()

void g2o::starsInVertex	(	StarSet &	stars,
		HyperGraph::Vertex *	v,
		EdgeStarMap &	esmap
	)

Definition at line 94 of file simple_star_ops.cpp.

                                                                            {
  for (HyperGraph::EdgeSet::iterator it = v->edges().begin();
       it != v->edges().end(); ++it) {
    HyperGraph::Edge* e = *it;
    EdgeStarMap::iterator eit = esmap.find(e);
    if (eit != esmap.end()) stars.insert(eit->second);
  }
}

References g2o::HyperGraph::Vertex::edges().

Referenced by starsInEdge().

strEndsWith()

G2O_STUFF_API bool g2o::strEndsWith	(	const std::string &	str,
		const std::string &	substr
	)

return true, if str ends with substr

Definition at line 156 of file string_tools.cpp.

                                                           {
  if (s.size() < end.size()) return false;
  return equal(end.rbegin(), end.rend(), s.rbegin());
}

Referenced by str2solver().

strExpandFilename()

G2O_STUFF_API std::string g2o::strExpandFilename

(

const std::string &

filename

)

expand the given filename like a posix shell, e.g., ~ $CARMEN_HOME and other will get expanded. Also command substitution, e.g. pwd will give the current directory.

Definition at line 117 of file string_tools.cpp.

                                                       {
#if (defined(UNIX) || defined(CYGWIN)) && !defined(ANDROID)
  string result = filename;
  wordexp_t p;
 
  wordexp(filename.c_str(), &p, 0);
  if (p.we_wordc > 0) {
    result = p.we_wordv[0];
  }
  wordfree(&p);
  return result;
#else
  (void)filename;
  G2O_WARN("{} not implemented", __PRETTY_FUNCTION__);
  return std::string();
#endif
}

References __PRETTY_FUNCTION__, and G2O_WARN.

stringToType()

template<typename T >

T g2o::stringToType	(	const std::string &	s,
		bool	failIfLeftoverChars = true
	)

convert a string into an other type. Return the converted value. Throw error if parsing is wrong.

Definition at line 136 of file string_tools.h.

                                                                    {
  T x;
  convertString(s, x, failIfLeftoverChars);
  return x;
}

References convertString().

strPrintf()

G2O_STUFF_API int g2o::strPrintf	(	std::string &	str,
		const char *	fmt,
			...
	)

replacement function for sprintf which fills a std::string instead of a char*

Definition at line 106 of file string_tools.cpp.

                                                    {
  char* auxPtr = NULL;
  va_list arg_list;
  va_start(arg_list, fmt);
  int numChars = vasprintf(&auxPtr, fmt, arg_list);
  va_end(arg_list);
  str = auxPtr;
  free(auxPtr);
  return numChars;
}

strSplit()

G2O_STUFF_API std::vector< std::string > g2o::strSplit	(	const std::string &	s,
		const std::string &	delim
	)

split a string into token based on the characters given in delim

Definition at line 135 of file string_tools.cpp.

                                                               {
  std::vector<std::string> tokens;
  if (str.empty()) return tokens;
  string::size_type lastPos = 0;
  string::size_type pos = 0;
 
  do {
    pos = str.find_first_of(delimiters, lastPos);
    tokens.push_back(str.substr(lastPos, pos - lastPos));
    lastPos = pos + 1;
  } while (string::npos != pos);
 
  return tokens;
}

Referenced by loadStandardSolver(), loadStandardTypes(), g2o::OptimizableGraph::setRenamedTypesFromString(), and g2o::PropertyMap::updateMapFromString().

strStartsWith()

G2O_STUFF_API bool g2o::strStartsWith	(	const std::string &	str,
		const std::string &	substr
	)

return true, if str starts with substr

Definition at line 151 of file string_tools.cpp.

                                                               {
  if (s.size() < start.size()) return false;
  return equal(start.begin(), start.end(), s.begin());
}

Referenced by str2solver().

strToLower()

G2O_STUFF_API std::string g2o::strToLower

(

const std::string &

s

)

convert the string to lower case

Definition at line 74 of file string_tools.cpp.

                                         {
  string ret;
  ret.reserve(s.size());
  std::transform(s.begin(), s.end(), back_inserter(ret),
                 [](unsigned char c) { return std::tolower(c); });
  return ret;
}

strToUpper()

G2O_STUFF_API std::string g2o::strToUpper

(

const std::string &

s

)

convert a string to upper case

Definition at line 82 of file string_tools.cpp.

                                         {
  string ret;
  ret.reserve(s.size());
  std::transform(s.begin(), s.end(), back_inserter(ret),
                 [](unsigned char c) { return std::toupper(c); });
  return ret;
}

tictoc()

G2O_STUFF_API double g2o::tictoc

(

const char *

algorithmPart

)

Profile the timing of certain parts of your algorithm.

Profile the timing of certain parts of your algorithm. A typical use-case is as follows:

tictoc("doSomething"); // place the code here. tictoc("doSomething");

This will calculate statistics for the operations within the two calls to tictoc()

If the environment variable G2O_ENABLE_TICTOC is defined, the timing will be performed.

Definition at line 118 of file tictoc.cpp.

                                         {
  static TicTocInitializer initializer;
  if (!initializer.enabled) return 0.;
 
  TicTocMap& tictocElements = initializer.tictocElements;
  static double alpha = cst(0.01);
  double now = get_monotonic_time();
 
  double dt = 0.;
  TicTocMap::iterator foundIt = tictocElements.find(algorithmPart);
  if (foundIt == tictocElements.end()) {
    // insert element
    TicTocElement e;
    e.ticTime = now;
    e.algorithmPart = algorithmPart;
    tictocElements[e.algorithmPart] = e;
  } else {
    if (foundIt->second.clockIsRunning) {
      dt = now - foundIt->second.ticTime;
      foundIt->second.totalTime += dt;
      foundIt->second.minTime = std::min(foundIt->second.minTime, dt);
      foundIt->second.maxTime = std::max(foundIt->second.maxTime, dt);
      if (foundIt->second.numCalls == 0)
        foundIt->second.exponentialMovingAverage = dt;
      else
        foundIt->second.exponentialMovingAverage =
            (1. - alpha) * foundIt->second.exponentialMovingAverage +
            alpha * dt;
      foundIt->second.numCalls++;
    } else {
      foundIt->second.ticTime = now;
    }
    foundIt->second.clockIsRunning = !foundIt->second.clockIsRunning;
  }
  return dt;
}

References g2o::TicTocElement::algorithmPart, cst(), g2o::TicTocInitializer::enabled, get_monotonic_time(), g2o::TicTocElement::ticTime, and g2o::TicTocInitializer::tictocElements.

Referenced by main(), g2o::ScopedTictoc::ScopedTictoc(), and g2o::ScopedTictoc::~ScopedTictoc().

trim()

G2O_STUFF_API std::string g2o::trim

(

const std::string &

s

)

remove whitespaces from the start/end of a string

Definition at line 50 of file string_tools.cpp.

                                   {
  if (s.length() == 0) return s;
  string::size_type b = s.find_first_not_of(" \t\n");
  string::size_type e = s.find_last_not_of(" \t\n");
  if (b == string::npos) return "";
  return std::string(s, b, e - b + 1);
}

Referenced by g2o::OptimizableGraph::setRenamedTypesFromString(), and g2o::PropertyMap::updateMapFromString().

trimLeft()

G2O_STUFF_API std::string g2o::trimLeft

(

const std::string &

s

)

remove whitespaces from the left side of the string

Definition at line 58 of file string_tools.cpp.

                                       {
  if (s.length() == 0) return s;
  string::size_type b = s.find_first_not_of(" \t\n");
  string::size_type e = s.length() - 1;
  if (b == string::npos) return "";
  return std::string(s, b, e - b + 1);
}

trimRight()

G2O_STUFF_API std::string g2o::trimRight

(

const std::string &

s

)

remove whitespaced from the right side of the string

Definition at line 66 of file string_tools.cpp.

                                        {
  if (s.length() == 0) return s;
  string::size_type b = 0;
  string::size_type e = s.find_last_not_of(" \t\n");
  if (e == string::npos) return "";
  return std::string(s, b, e - b + 1);
}

tuple_apply_i()

template<typename F , typename T >

void g2o::tuple_apply_i	(	F &&	f,
		T &	t,
		int	i
	)

Definition at line 39 of file tuple_tools.h.

                                       {
  tuple_apply_i_(
      f, t, i, std::make_index_sequence<std::tuple_size_v<std::decay_t<T>>>());
}

References tuple_apply_i_().

Referenced by g2o::BaseFixedSizedEdge< D, OdomAndLaserMotion, VertexSE2, VertexBaseline >::linearizeOplus(), and g2o::BaseFixedSizedEdge< D, OdomAndLaserMotion, VertexSE2, VertexBaseline >::linearizeOplus().

tuple_apply_i_()

template<typename F , typename T , std::size_t... I>

void g2o::tuple_apply_i_	(	F &&	f,
		T &	t,
		int	i,
		std::index_sequence< I... >
	)

Definition at line 34 of file tuple_tools.h.

                                                                 {
  (..., (I == i ? f(std::get<I>(t)) : void()));
}

Referenced by tuple_apply_i().

unproject() [1/2]

G2O_TYPES_SLAM3D_API Vector3 g2o::unproject ( const Vector2 &  )

inline

Referenced by g2o::internal::invert_depth().

unproject() [2/2]

G2O_TYPES_SLAM3D_API Vector4 g2o::unproject ( const Vector3 &  )

inline

vertexEdgesInStar()

size_t g2o::vertexEdgesInStar	(	HyperGraph::EdgeSet &	eset,
		HyperGraph::Vertex *	v,
		Star *	s,
		EdgeStarMap &	esmap
	)

Definition at line 82 of file simple_star_ops.cpp.

                                                      {
  eset.clear();
  for (HyperGraph::EdgeSet::iterator it = v->edges().begin();
       it != v->edges().end(); ++it) {
    HyperGraph::Edge* e = *it;
    EdgeStarMap::iterator eit = esmap.find(e);
    if (eit != esmap.end() && eit->second == s) eset.insert(e);
  }
  return eset.size();
}

References g2o::HyperGraph::Vertex::edges().

Referenced by assignHierarchicalEdges().

wrap()

template<typename T >

T g2o::wrap ( T  l, T  x, T  u  )

inline

wrap x to be in the interval [l, u]

Definition at line 158 of file misc.h.

                             {
  T intervalWidth = u - l;
  while (x < l) x += intervalWidth;
  while (x > u) x -= intervalWidth;
  return x;
}

writeCCSMatrix() [1/2]

G2O_STUFF_API bool g2o::writeCCSMatrix	(	const std::string &	filename,
		int	rows,
		int	cols,
		const int *	p,
		const int *	i,
		const double *	v,
		bool	upperTriangleSymmetric = true
	)

write a CCS matrix given by pointer to column, row, and values

writeCCSMatrix() [2/2]

bool g2o::writeCCSMatrix	(	const string &	filename,
		int	rows,
		int	cols,
		const int *	Ap,
		const int *	Ai,
		const double *	Ax,
		bool	upperTriangleSymmetric
	)

Definition at line 68 of file sparse_helper.cpp.

                                                 {
  vector<TripletEntry> entries;
  entries.reserve((size_t)Ap[cols]);
  for (int i = 0; i < cols; i++) {
    const int& rbeg = Ap[i];
    const int& rend = Ap[i + 1];
    for (int j = rbeg; j < rend; j++) {
      entries.emplace_back(TripletEntry(Ai[j], i, Ax[j]));
      if (upperTriangleSymmetric && Ai[j] != i)
        entries.emplace_back(TripletEntry(i, Ai[j], Ax[j]));
    }
  }
  sort(entries.begin(), entries.end(), TripletColSort());
  return writeTripletEntries(filename, rows, cols, entries);
}

References writeTripletEntries().

Referenced by g2o::LinearSolverCholmodOnline< MatrixType >::choleskyUpdate(), g2o::LinearSolverCholmod< MatrixType >::saveMatrix(), g2o::LinearSolverCholmodOnline< MatrixType >::solve(), and g2o::csparse_extension::writeCs2Octave().

writeTripletEntries()

static bool g2o::writeTripletEntries ( const std::string &  filename, int  rows, int  cols, const std::vector< TripletEntry > &  triplets  )

static

Definition at line 39 of file sparse_helper.cpp.

                                                                         {
  const string name = [&filename]() {
    const std::string::size_type lastDot = filename.find_last_of('.');
    if (lastDot != std::string::npos) return filename.substr(0, lastDot);
    return filename;
  }();
 
  std::ofstream fout(filename.c_str());
  fout << "# name: " << name << std::endl;
  fout << "# type: sparse matrix" << std::endl;
  fout << "# nnz: " << triplets.size() << std::endl;
  fout << "# rows: " << rows << std::endl;
  fout << "# columns: " << cols << std::endl;
  // fout << fixed;
  fout << setprecision(9) << endl;
  for (const TripletEntry& entry : triplets) {
    fout << entry.r + 1 << " " << entry.c + 1 << " " << entry.x << std::endl;
  }
  return fout.good();
}

Referenced by writeCCSMatrix(), and writeTripletMatrix().

writeTripletMatrix()

G2O_STUFF_API bool g2o::writeTripletMatrix	(	const std::string &	filename,
		int	nz,
		int	rows,
		int	cols,
		const int *	Ai,
		const int *	Aj,
		const double *	Ax,
		bool	upperTriangleSymmetric = true
	)

write a triplet matrix given by pointers

Parameters

filename	filename to write to
nz	number of elements
rows	number of rows of the matrix
cols	number of colmuns of the matrix
Ai	pointer to the row index (nz elements)
Aj	pointer to the column index (nz elements)
Ax	pointer to the values index (nz elements)

Definition at line 86 of file sparse_helper.cpp.

                                                     {
  vector<TripletEntry> entries;
  entries.reserve(nz);
  for (int i = 0; i < nz; ++i) {
    entries.emplace_back(TripletEntry(Ai[i], Aj[i], Ax[i]));
    if (upperTriangleSymmetric && Ai[i] != Aj[i])
      entries.emplace_back(TripletEntry(Aj[i], Ai[i], Ax[i]));
  }
  sort(entries.begin(), entries.end(), TripletColSort());
  return writeTripletEntries(filename, rows, cols, entries);
}

References writeTripletEntries().

Referenced by g2o::csparse_extension::writeCs2Octave().

writeVector() [1/2]

G2O_STUFF_API bool g2o::writeVector	(	const std::string &	filename,
		const double *	v,
		int	n
	)

write an array to a file, debugging

writeVector() [2/2]

bool g2o::writeVector	(	const string &	filename,
		const double *	v,
		int	n
	)

Definition at line 61 of file sparse_helper.cpp.

                                                                 {
  ofstream os(filename.c_str());
  os << fixed;
  for (int i = 0; i < n; i++) os << *v++ << endl;
  return os.good();
}

Variable Documentation

_gen_real

std::mt19937 g2o::_gen_real

static

Definition at line 33 of file sampler.cpp.

Referenced by sampleGaussian(), and sampleUniform().

_uniformReal

std::uniform_real_distribution<double> g2o::_uniformReal

static

Definition at line 32 of file sampler.cpp.

Referenced by sampleUniform().

INFORMATION_SCALING_ODOMETRY

const double g2o::INFORMATION_SCALING_ODOMETRY = 100

static

Definition at line 48 of file sclam_helpers.cpp.

Referenced by addOdometryCalibLinksDifferential().

OptimizationAlgorithm

class G2O_CORE_API g2o::OptimizationAlgorithm

Definition at line 45 of file optimization_algorithm_factory.h.