provide memory workspace for computing the Jacobians More...

#include <jacobian_workspace.h>

Public Types
using	WorkspaceVector = std::vector< VectorX >

Public Member Functions
	JacobianWorkspace ()

	~JacobianWorkspace ()

bool	allocate ()

void	updateSize (const HyperGraph::Edge *e, bool reset)

void	updateSize (const HyperGraph::Edge *e)

void	updateSize (const OptimizableGraph &graph, bool reset=false)

void	updateSize (int numVertices, int dimension, bool reset=false)

void	setZero ()

double *	workspaceForVertex (int vertexIndex)

Protected Attributes
WorkspaceVector	_workspace
	the memory pre-allocated for computing the Jacobians

int	_maxNumVertices

int	_maxDimension

Detailed Description

provide memory workspace for computing the Jacobians

The workspace is used by an OptimizableGraph to provide temporary memory for computing the Jacobian of the error functions. Before calling linearizeOplus on an edge, the workspace needs to be allocated by calling allocate().

By default, the sizes are updated incrementally with each call. If the reset flag is set to true, the counts are set back to

Definition at line 53 of file jacobian_workspace.h.

Member Typedef Documentation

◆ WorkspaceVector

using g2o::JacobianWorkspace::WorkspaceVector = std::vector<VectorX>

Definition at line 55 of file jacobian_workspace.h.

Constructor & Destructor Documentation

◆ JacobianWorkspace()

g2o::JacobianWorkspace::JacobianWorkspace ( )

Definition at line 38 of file jacobian_workspace.cpp.

39 : _maxNumVertices(-1), _maxDimension(-1) {}

g2o::JacobianWorkspace::_maxNumVertices

int _maxNumVertices

Definition jacobian_workspace.h:104

g2o::JacobianWorkspace::_maxDimension

int _maxDimension

Definition jacobian_workspace.h:106

◆ ~JacobianWorkspace()

g2o::JacobianWorkspace::~JacobianWorkspace ( )

Definition at line 41 of file jacobian_workspace.cpp.

41{}

Member Function Documentation

◆ allocate()

bool g2o::JacobianWorkspace::allocate ( )

allocate the workspace

Definition at line 43 of file jacobian_workspace.cpp.

                                 {
  if (_maxNumVertices <= 0 || _maxDimension <= 0) return false;
  _workspace.resize(_maxNumVertices);
  for (WorkspaceVector::iterator it = _workspace.begin();
       it != _workspace.end(); ++it) {
    it->resize(_maxDimension);
    it->setZero();
  }
  return true;
}

References _maxDimension, _maxNumVertices, and _workspace.

Referenced by g2o::G2oSlamInterface::addEdge(), g2o::StructureOnlySolver< PointDoF >::calc(), g2o::SparseOptimizer::initializeOptimization(), and g2o::SparseOptimizer::initializeOptimization().

◆ setZero()

void g2o::JacobianWorkspace::setZero ( )

set the full workspace to zero

Definition at line 54 of file jacobian_workspace.cpp.

                                {
  for (auto& wp : _workspace) wp.setZero();
}

References _workspace.

◆ updateSize() [1/4]

void g2o::JacobianWorkspace::updateSize ( const HyperGraph::Edge * e )

update the maximum required workspace needed by taking into account this edge

Definition at line 66 of file jacobian_workspace.cpp.

                                                           {
  const OptimizableGraph::Edge* e =
      static_cast<const OptimizableGraph::Edge*>(e_);
  int errorDimension = e->dimension();
  int numVertices = e->vertices().size();
  int maxDimensionForEdge = -1;
 
  for (const auto& vv : e->vertices()) {
    const OptimizableGraph::Vertex* v =
        static_cast<const OptimizableGraph::Vertex*>(vv);
    assert(v && "Edge has no vertex assigned");
    maxDimensionForEdge =
        max(v->dimension() * errorDimension, maxDimensionForEdge);
  }
  _maxNumVertices = max(numVertices, _maxNumVertices);
  _maxDimension = max(maxDimensionForEdge, _maxDimension);
}

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

◆ updateSize() [2/4]

void g2o::JacobianWorkspace::updateSize	(	const HyperGraph::Edge *	e,
		bool	reset
	)

update the maximum required workspace needed by taking into account this edge

Definition at line 58 of file jacobian_workspace.cpp.

                                                                       {
  if (reset) {
    _maxNumVertices = -1;
    _maxDimension = -1;
  }
  updateSize(e_);
}

References _maxDimension, _maxNumVertices, and updateSize().

Referenced by g2o::OptimizableGraph::addEdge(), g2o::StructureOnlySolver< PointDoF >::calc(), g2o::BaseDynamicVertex< T >::setDimension(), g2o::OptimizableGraph::setEdgeVertex(), updateSize(), and updateSize().

◆ updateSize() [3/4]

void g2o::JacobianWorkspace::updateSize	(	const OptimizableGraph &	graph,
		bool	reset = `false`
	)

update the required workspace by looking at a full graph

Definition at line 84 of file jacobian_workspace.cpp.

                                                                            {
  if (reset) {
    _maxNumVertices = -1;
    _maxDimension = -1;
  }
 
  for (OptimizableGraph::EdgeSet::const_iterator it = graph.edges().begin();
       it != graph.edges().end(); ++it) {
    const OptimizableGraph::Edge* e =
        static_cast<const OptimizableGraph::Edge*>(*it);
    updateSize(e);
  }
}

References _maxDimension, _maxNumVertices, g2o::HyperGraph::edges(), and updateSize().

◆ updateSize() [4/4]

void g2o::JacobianWorkspace::updateSize	(	int	numVertices,
		int	dimension,
		bool	reset = `false`
	)

manually update with the given parameters

Definition at line 98 of file jacobian_workspace.cpp.

                                                                             {
  if (reset) {
    _maxNumVertices = -1;
    _maxDimension = -1;
  }
 
  _maxNumVertices = max(numVertices, _maxNumVertices);
  _maxDimension = max(dimension, _maxDimension);
}

References _maxDimension, and _maxNumVertices.

◆ workspaceForVertex()

double * g2o::JacobianWorkspace::workspaceForVertex ( int vertexIndex )

inline

return the workspace for a vertex in an edge

Definition at line 95 of file jacobian_workspace.h.

                                              {
    assert(vertexIndex >= 0 && (size_t)vertexIndex < _workspace.size() &&
           "Index out of bounds");
    return _workspace[vertexIndex].data();
  }

Referenced by g2o::BlockSolver< Traits >::buildSystem(), g2o::BaseVariableSizedEdge< D, E >::linearizeOplus(), and g2o::BaseFixedSizedEdge< D, E, VertexTypes >::linearizeOplus_allocate().

Member Data Documentation

◆ _maxDimension

int g2o::JacobianWorkspace::_maxDimension

protected

the maximum dimension (number of elements) for a Jacobian

Definition at line 106 of file jacobian_workspace.h.

Referenced by allocate(), updateSize(), updateSize(), updateSize(), and updateSize().

◆ _maxNumVertices

int g2o::JacobianWorkspace::_maxNumVertices

protected

the maximum number of vertices connected by a hyper-edge

Definition at line 104 of file jacobian_workspace.h.

Referenced by allocate(), updateSize(), updateSize(), updateSize(), and updateSize().

◆ _workspace

WorkspaceVector g2o::JacobianWorkspace::_workspace

protected

the memory pre-allocated for computing the Jacobians

Definition at line 103 of file jacobian_workspace.h.

Referenced by allocate(), and setZero().

The documentation for this class was generated from the following files:

/build/reproducible-path/g2o-0~20230806/g2o/core/jacobian_workspace.h
/build/reproducible-path/g2o-0~20230806/g2o/core/jacobian_workspace.cpp

Public Types

Public Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ WorkspaceVector

Constructor & Destructor Documentation

◆ JacobianWorkspace()

◆ ~JacobianWorkspace()

Member Function Documentation

◆ allocate()

◆ setZero()

◆ updateSize() [1/4]

◆ updateSize() [2/4]

◆ updateSize() [3/4]

◆ updateSize() [4/4]

◆ workspaceForVertex()

Member Data Documentation

◆ _maxDimension

◆ _maxNumVertices

◆ _workspace