Simox  2.3.74.0
Namespaces | Data Structures | Typedefs | Functions | Variables
VirtualRobot Namespace Reference

Namespaces

 FileIO
 
 MathTools
 
 Primitive
 

Data Structures

class  AdvancedIKSolver
 
class  BaseIO
 
class  BasicGraspQualityMeasure
 An interface class for grasp quality algorithms. A basic quality score, relying on the number of contacts, is served by this implementation. More...
 
class  BoundingBox
 
class  CameraSensor
 
class  CameraSensorFactory
 
class  CDManager
 
class  ChainedGrasp
 
struct  Circle
 
class  CoinVisualization
 
class  CoinVisualizationFactory
 
class  CoinVisualizationNode
 
class  CollisionChecker
 
class  CollisionCheckerDummy
 
class  CollisionCheckerImplementation
 
class  CollisionCheckerPQP
 
class  CollisionModel
 
class  CollisionModelDummy
 
class  CollisionModelImplementation
 
class  CollisionModelPQP
 
class  ColorMap
 
class  CoMIK
 
class  ConstrainedHierarchicalIK
 
class  ConstrainedIK
 
class  ConstrainedOptimizationIK
 
class  ConstrainedStackedIK
 
class  Constraint
 
class  ContactSensor
 
class  ContactSensorFactory
 
struct  DepthRenderData
 Used for a Coin3d callback to store the zBuffer. More...
 
class  DHParameter
 
class  DifferentialIK
 Encapsulates a differential inverse kinematics for the virtual robot. More...
 
class  EndEffector
 
class  EndEffectorActor
 
class  FeetPosture
 
class  ForceTorqueSensor
 
class  ForceTorqueSensorFactory
 
class  GazeIK
 
class  GenericIKSolver
 
class  Grasp
 
class  GraspableSensorizedObject
 
class  GraspSet
 
class  HierarchicalIK
 
class  IKSolver
 
class  JacobiProvider
 
class  JointLimitAvoidanceJacobi
 
class  KinematicChain
 
class  LinkedCoordinate
 This class provides intelligent coordinates for the virtual robot. More...
 
class  LocalRobot
 
class  Manipulability
 
class  ManipulationObject
 
struct  MultiCollisionResult
 
class  NaturalPosture
 
struct  NodeMappingElement
 
class  ObjectIO
 
class  Obstacle
 
class  OptimizationFunctionSetup
 
class  PoseQualityExtendedManipulability
 
class  PoseQualityManipulability
 
class  PoseQualityMeasurement
 
class  PositionSensor
 
class  PositionSensorFactory
 
class  Reachability
 
class  Robot
 
class  RobotConfig
 
class  RobotFactory
 
class  RobotIO
 
class  RobotNode
 
class  RobotNodeActuator
 
struct  robotNodeDef
 
class  RobotNodeFactory
 
class  RobotNodeFixed
 
class  RobotNodeFixedFactory
 
class  RobotNodeHemisphere
 
class  RobotNodeHemisphereFactory
 
class  RobotNodePrismatic
 
class  RobotNodePrismaticFactory
 
class  RobotNodeRevolute
 
class  RobotNodeRevoluteFactory
 
class  RobotNodeSet
 
struct  robotStructureDef
 
class  RuntimeEnvironment
 
class  Scene
 
class  SceneIO
 
class  SceneObject
 
class  SceneObjectSet
 
class  Sensor
 
class  SensorFactory
 
struct  SingleCollisionPair
 
class  SphereApproximator
 
class  StackedIK
 
class  SupportPolygon
 
class  Trajectory
 
class  TriMeshModel
 
class  TriMeshUtils
 
struct  TriTriIntersection
 
class  Units
 
class  VirtualRobotCheckException
 Exception class thrown by VR_CHECK_* macros. More...
 
class  VirtualRobotException
 
class  Visualization
 
class  VisualizationFactory
 
class  VisualizationNode
 
class  VoxelTree6D
 
class  VoxelTree6DElement
 
class  VoxelTreeND
 
class  VoxelTreeNDElement
 
class  WorkspaceData
 
class  WorkspaceDataArray
 
class  WorkspaceGrid
 
class  WorkspaceRepresentation
 

Typedefs

typedef CollisionModelPQP InternalCollisionModel
 
typedef std::shared_ptr< InternalCollisionModel > InternalCollisionModelPtr
 
typedef std::shared_ptr< AdvancedIKSolver > AdvancedIKSolverPtr
 
typedef std::shared_ptr< CoMIK > CoMIKPtr
 
typedef std::shared_ptr< ConstrainedHierarchicalIK > ConstrainedHierarchicalIKPtr
 
typedef std::shared_ptr< ConstrainedIK > ConstrainedIKPtr
 
typedef std::shared_ptr< nlopt::opt > OptimizerPtr
 
typedef std::shared_ptr< ConstrainedOptimizationIK > ConstrainedOptimizationIKPtr
 
typedef std::shared_ptr< ConstrainedStackedIK > ConstrainedStackedIKPtr
 
typedef double(* OptimizationFunction) (std::vector< double > &gradient)
 
typedef std::shared_ptr< Constraint > ConstraintPtr
 
typedef std::shared_ptr< DifferentialIK > DifferentialIKPtr
 
typedef std::shared_ptr< FeetPosture > FeetPosturePtr
 
typedef std::shared_ptr< GazeIK > GazeIKPtr
 
typedef std::shared_ptr< GenericIKSolver > GenericIKSolverPtr
 
typedef std::shared_ptr< HierarchicalIK > HierarchicalIKPtr
 
typedef std::shared_ptr< IKSolver > IKSolverPtr
 
typedef std::shared_ptr< JacobiProvider > JacobiProviderPtr
 
typedef std::shared_ptr< JointLimitAvoidanceJacobi > JointLimitAvoidanceJacobiPtr
 
typedef std::shared_ptr< PoseQualityExtendedManipulability > PoseQualityExtendedManipulabilityPtr
 
typedef std::shared_ptr< RobotPoseDifferentialIK > RobotPoseDifferentialIKPtr
 
typedef std::shared_ptr< StackedIK > StackedIKPtr
 
typedef std::shared_ptr< SupportPolygon > SupportPolygonPtr
 
typedef std::shared_ptr< CameraSensor > CameraSensorPtr
 
typedef std::shared_ptr< ContactSensor > ContactSensorPtr
 
typedef std::shared_ptr< ForceTorqueSensor > ForceTorqueSensorPtr
 
typedef std::shared_ptr< PositionSensor > PositionSensorPtr
 
typedef std::shared_ptr< RobotNodeActuator > RobotNodeActuatorPtr
 
using RobotNodeHemispherePtr = std::shared_ptr< class RobotNodeHemisphere >
 
typedef std::shared_ptr< RobotNodePrismatic > RobotNodePrismaticPtr
 
typedef std::shared_ptr< RobotNodeRevolute > RobotNodeRevolutePtr
 
typedef std::shared_ptr< Sensor > SensorPtr
 
typedef std::shared_ptr< SensorFactory > SensorFactoryPtr
 
typedef std::shared_ptr< VisualizationFactory::Color > ColorPtr
 
typedef std::shared_ptr< Manipulability > ManipulabilityPtr
 
typedef std::shared_ptr< GraspableSensorizedObject > GraspableSensorizedObjectPtr
 
using NodeMapping = std::unordered_map< std::string, NodeMappingElement >
 
typedef std::shared_ptr< TSRConstraint > TSRConstraintPtr
 
typedef std::shared_ptr< BalanceConstraint > BalanceConstraintPtr
 
typedef std::shared_ptr< PoseConstraint > PoseConstraintPtr
 
typedef std::shared_ptr< PositionConstraint > PositionConstraintPtr
 
typedef std::shared_ptr< OrientationConstraint > OrientationConstraintPtr
 
typedef std::shared_ptr< RobotNode > RobotNodePtr
 
typedef std::shared_ptr< RobotNodeSet > RobotNodeSetPtr
 
typedef std::shared_ptr< KinematicChain > KinematicChainPtr
 
typedef std::weak_ptr< RobotNode > RobotNodeWeakPtr
 
typedef std::shared_ptr< RobotNodeFactory > RobotNodeFactoryPtr
 
typedef std::shared_ptr< Robot > RobotPtr
 
typedef std::weak_ptr< Robot > RobotWeakPtr
 
typedef std::shared_ptr< EndEffector > EndEffectorPtr
 
typedef std::shared_ptr< EndEffectorActor > EndEffectorActorPtr
 
typedef std::shared_ptr< CollisionModel > CollisionModelPtr
 
typedef std::shared_ptr< CollisionChecker > CollisionCheckerPtr
 
typedef std::shared_ptr< SceneObjectSet > SceneObjectSetPtr
 
typedef std::shared_ptr< TriMeshModel > TriMeshModelPtr
 
typedef std::shared_ptr< SceneObject > SceneObjectPtr
 
typedef std::weak_ptr< SceneObject > SceneObjectWeakPtr
 
typedef std::shared_ptr< Obstacle > ObstaclePtr
 
typedef std::shared_ptr< Visualization > VisualizationPtr
 
typedef std::shared_ptr< VisualizationNode > VisualizationNodePtr
 
typedef std::shared_ptr< VisualizationFactory > VisualizationFactoryPtr
 
typedef std::shared_ptr< WorkspaceData > WorkspaceDataPtr
 
typedef std::shared_ptr< WorkspaceDataArray > WorkspaceDataArrayPtr
 
typedef std::shared_ptr< WorkspaceRepresentation > WorkspaceRepresentationPtr
 
typedef std::shared_ptr< Reachability > ReachabilityPtr
 
typedef std::shared_ptr< Scene > ScenePtr
 
typedef std::shared_ptr< RobotConfig > RobotConfigPtr
 
typedef std::shared_ptr< Grasp > GraspPtr
 
typedef std::shared_ptr< ChainedGrasp > ChainedGraspPtr
 
typedef std::shared_ptr< GraspSet > GraspSetPtr
 
typedef std::weak_ptr< GraspableSensorizedObject > GraspableSensorizedObjectWeakPtr
 
typedef std::shared_ptr< ManipulationObject > ManipulationObjectPtr
 
typedef std::shared_ptr< CDManager > CDManagerPtr
 
typedef std::shared_ptr< PoseQualityMeasurement > PoseQualityMeasurementPtr
 
typedef std::shared_ptr< PoseQualityManipulability > PoseQualityManipulabilityPtr
 
typedef std::shared_ptr< Trajectory > TrajectoryPtr
 
typedef std::shared_ptr< SphereApproximator > SphereApproximatorPtr
 
typedef std::shared_ptr< BasicGraspQualityMeasure > BasicGraspQualityMeasurePtr
 
typedef std::shared_ptr< WorkspaceGrid > WorkspaceGridPtr
 
typedef std::shared_ptr< LocalRobot > LocalRobotPtr
 
typedef std::shared_ptr< CoinVisualization > CoinVisualizationPtr
 
typedef std::shared_ptr< CoinVisualizationFactory > CoinVisualizationFactoryPtr
 
typedef std::map< const SoPrimitiveVertex *, int > CoinVertexIndexMap
 
typedef std::shared_ptr< CoinVisualizationNode > CoinVisualizationNodePtr
 

Functions

static TriTriIntersection intersectTriangles (Eigen::Vector3f const &U0, Eigen::Vector3f const &U1, Eigen::Vector3f const &U2, Eigen::Vector3f const &V0, Eigen::Vector3f const &V1, Eigen::Vector3f const &V2)
 
class deprecated ("MMMTools_LegacyConverter")]] VIRTUAL_ROBOT_IMPORT_EXPORT RobotPoseDifferentialIK
 
double uniformDeviate (int seed)
 
bool toBool (const std::string &strRepr) noexcept
 
Eigen::Matrix3f VIRTUAL_ROBOT_IMPORT_EXPORT quat2eigen3f (float qx, float qy, float qz, float qw)
 
std::mt19937_64 & PRNG64Bit ()
 
std::mt19937_64::result_type RandomNumber ()
 
float RandomFloat ()
 
float RandomFloat (float min, float max)
 
static boost::program_options::options_description RuntimeEnvironment_makeOptionsDescription ()
 Make the options description based on the added keys and flags. More...
 
static void RuntimeEnvironment_processParsedOptions (const boost::program_options::parsed_options &parsed)
 
static std::size_t getMaxLength (const std::vector< std::pair< std::string, std::string >> &items)
 
static std::string padding (std::size_t current, std::size_t target, char c=' ')
 
Circle projectedBoundingCircle (const Robot &robot)
 
void init (const std::string &appName)
 
void init (int &argc, char *argv[], const std::string &appName)
 
std::ifstream::pos_type getFilesize (const char *filename)
 
void getZBuffer (void *userdata)
 Used for a Coin3d callback to store the zBuffer. More...
 

Variables

static const float limit = 1.0
 
const simox::meta::EnumNames< RobotNodeHemisphere::Role > RoleNames
 
constexpr int INVALID_VALUE = -1
 
static bool RuntimeEnvironment_pathInitialized = false
 
static std::string RuntimeEnvironment_caption = "Simox runtime options"
 
static std::vector< std::pair< std::string, std::string > > RuntimeEnvironment_processKeys
 Pairs of (key, description). If not given, description is empty. More...
 
static std::vector< std::pair< std::string, std::string > > RuntimeEnvironment_processFlags
 Pairs of (flag, description). If not given, description is empty. More...
 
static std::vector< std::string > RuntimeEnvironment_dataPaths
 
static std::vector< std::string > RuntimeEnvironment_unrecognizedOptions
 
static std::map< std::string, std::string > RuntimeEnvironment_keyValues
 
static std::set< std::string > RuntimeEnvironment_flags
 
static bool RuntimeEnvironment_helpFlag = false
 
std::string globalAppName
 

Detailed Description

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Date
2011-02-24
Author
Nikolaus Vahrenkamp
Copyright
2011 Nikolaus Vahrenkamp GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Nikolaus Vahrenkamp
Copyright
2011 Nikolaus Vahrenkamp GNU Lesser General Public License
Author
Manfred Kroehnert , Nikolaus Vahrenkamp
Copyright
2011 Manfred Kroehnert, Nikolaus Vahrenkamp

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Manfred Kroehnert, Nikolaus Vahrenkamp
Copyright
2010, 2011 Manfred Kroehnert, Nikolaus Vahrenkamp GNU Lesser General Public License
Author
Nikolaus Vahrenkamp
Manfred Kroehnert
Copyright
2011 Manfred Kroehnert

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Manfred Kroehnert, Nikolaus Vahrenkamp
Copyright
2011 Manfred Kroehnert, Nikolaus Vahrenkamp GNU Lesser General Public License
Author
Nikolaus Vahrenkamp
Copyright
2012 Nikolaus Vahrenkamp

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Nikolaus Vahrenkamp
Copyright
2012 Nikolaus Vahrenkamp GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Andre Meixner
Copyright
2020 Andre Meixner GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Peter Kaiser, Nikolaus Vahrenkamp
Copyright
2011 Peter Kaiser, Nikolaus Vahrenkamp GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Peter Kaiser
Copyright
2015 Peter Kaiser GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Peter Kaiser
Matthias Hadlich
Copyright
2016 Peter Kaiser GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Stefan Ulbrich, Nikolaus Vahrenkamp
Copyright
2011 Stefan Ulbrich, Nikolaus Vahrenkamp GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Nikolaus Vahrenkamp
Copyright
2013 Nikolaus Vahrenkamp GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Nikolaus Vahrenkamp
Copyright
2014 Nikolaus Vahrenkamp GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Nikolaus Vahrenkamp <vahrenkamp at="" users="" dot="" sf="" dot="" net>="">
Copyright
2012 Nikolaus Vahrenkamp http://www.gnu.org/licenses/gpl.txt GNU General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Patrick Niklaus
Copyright
2014 Patrick Niklaus GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Manfred Kroehnert, Nikolaus Vahrenkamp
Copyright
2010,2011 Manfred Kroehnert, Nikolaus Vahrenkamp GNU Lesser General Public License
Author
Manfred Kroehnert
Copyright
2010 Manfred Kroehnert

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Rainer Kartmann
Copyright
2022 Rainer Kartmann GNU Lesser General Public License
Author
Rainer Kartmann
Copyright
2022 Rainer Kartmann
Author
David Gonzales, Nikolaus Vahrenkamp
Copyright
2011 David Gonzales, Nikolaus Vahrenkamp

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
David Gonzales, Nikolaus Vahrenkamp
Copyright
2011 David Gonzales, Nikolaus Vahrenkamp GNU Lesser General Public License
Author
Manfred Kroehnert
Nikolaus Vahrenkamp
Copyright
2010 Manfred Kroehnert

This file is part of Simox.

Simox is free software = 0; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation = 0; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY = 0; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Peter Kaiser, Nikolaus Vahrenkamp
Copyright
2011 Peter Kaiser, Nikolaus Vahrenkamp GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Stefan Ulbrich
Copyright
2011 Stefan Ulbrich license http://www.gnu.org/licenses/gpl.txt GNU General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Raphael Grimm
Copyright
2018 Nikolaus Vahrenkamp GNU Lesser General Public License

This file is part of Simox.

Simox is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Simox is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Kai Welke, Nikolaus Vahrenkamp
Copyright
2011 Kai Welke, Nikolaus Vahrenkamp GNU Lesser General Public License
Author
Manfred Kroehnert <mkroehnert _at_="" users="" dot="" sourceforge="" dot="" net>="">
Copyright
2011 Manfred Kroehnert

The macros VR_CHECK_*() defined in this file can be used as "soft" assertions. That is, they can be used to check some condition and, if this condition fails, throw an exception (of type VirtualRobotCheckException). Thrown exceptions give information about where they were thrown and what condition failed.

All macros are defined in two versions, one taking a "hint", explaining what is checked, and one taking no hint.

Hints hould be formulated "positively", i.e. what condition is tested and what must be true, not what went wrong otherwise. For example:

VR_CHECK_EQUAL_HINT(vector.size(), 3, "Vector must have exactly 3 elements.");
VR_CHECK_HINT(pointer, "Pointer must not be null.");
*not:* VR_CHECK_HINT(pointer, "Pointer is null.");
Author
Nikolaus Vahrenkamp
Manfred Kroehnert
Copyright
2010,2011 Nikolaus Vahrenkamp, Manfred Kroehnert
Author
Manfred Kroehnert, Nikolaus Vahrenkamp
Copyright
2010 Manfred Kroehnert, Nikolaus Vahrenkamp

Typedef Documentation

◆ AdvancedIKSolverPtr

typedef std::shared_ptr<AdvancedIKSolver> VirtualRobot::AdvancedIKSolverPtr

◆ BalanceConstraintPtr

typedef std::shared_ptr<BalanceConstraint> VirtualRobot::BalanceConstraintPtr

◆ BasicGraspQualityMeasurePtr

typedef std::shared_ptr<BasicGraspQualityMeasure> VirtualRobot::BasicGraspQualityMeasurePtr

◆ CameraSensorPtr

typedef std::shared_ptr<CameraSensor> VirtualRobot::CameraSensorPtr

◆ CDManagerPtr

typedef std::shared_ptr<CDManager> VirtualRobot::CDManagerPtr

◆ ChainedGraspPtr

typedef std::shared_ptr<ChainedGrasp> VirtualRobot::ChainedGraspPtr

◆ CoinVertexIndexMap

typedef std::map<const SoPrimitiveVertex*, int> VirtualRobot::CoinVertexIndexMap

◆ CoinVisualizationFactoryPtr

typedef std::shared_ptr<CoinVisualizationFactory> VirtualRobot::CoinVisualizationFactoryPtr

◆ CoinVisualizationNodePtr

typedef std::shared_ptr<CoinVisualizationNode> VirtualRobot::CoinVisualizationNodePtr

◆ CoinVisualizationPtr

typedef std::shared_ptr<CoinVisualization> VirtualRobot::CoinVisualizationPtr

◆ CollisionCheckerPtr

typedef std::shared_ptr<CollisionChecker> VirtualRobot::CollisionCheckerPtr

◆ CollisionModelPtr

typedef std::shared_ptr<CollisionModel> VirtualRobot::CollisionModelPtr

◆ ColorPtr

typedef std::shared_ptr<VisualizationFactory::Color> VirtualRobot::ColorPtr

◆ CoMIKPtr

typedef std::shared_ptr< CoMIK > VirtualRobot::CoMIKPtr

◆ ConstrainedHierarchicalIKPtr

typedef std::shared_ptr<ConstrainedHierarchicalIK> VirtualRobot::ConstrainedHierarchicalIKPtr

◆ ConstrainedIKPtr

typedef std::shared_ptr<ConstrainedIK> VirtualRobot::ConstrainedIKPtr

◆ ConstrainedOptimizationIKPtr

typedef std::shared_ptr<ConstrainedOptimizationIK> VirtualRobot::ConstrainedOptimizationIKPtr

◆ ConstrainedStackedIKPtr

typedef std::shared_ptr<ConstrainedStackedIK> VirtualRobot::ConstrainedStackedIKPtr

◆ ConstraintPtr

typedef std::shared_ptr< Constraint > VirtualRobot::ConstraintPtr

◆ ContactSensorPtr

typedef std::shared_ptr< ContactSensor > VirtualRobot::ContactSensorPtr

◆ DifferentialIKPtr

typedef std::shared_ptr< DifferentialIK > VirtualRobot::DifferentialIKPtr

◆ EndEffectorActorPtr

typedef std::shared_ptr<EndEffectorActor> VirtualRobot::EndEffectorActorPtr

◆ EndEffectorPtr

typedef std::shared_ptr<EndEffector> VirtualRobot::EndEffectorPtr

◆ FeetPosturePtr

typedef std::shared_ptr<FeetPosture> VirtualRobot::FeetPosturePtr

◆ ForceTorqueSensorPtr

typedef std::shared_ptr< ForceTorqueSensor > VirtualRobot::ForceTorqueSensorPtr

◆ GazeIKPtr

typedef std::shared_ptr<GazeIK> VirtualRobot::GazeIKPtr

◆ GenericIKSolverPtr

typedef std::shared_ptr<GenericIKSolver> VirtualRobot::GenericIKSolverPtr

◆ GraspableSensorizedObjectPtr

typedef std::shared_ptr< GraspableSensorizedObject > VirtualRobot::GraspableSensorizedObjectPtr

◆ GraspableSensorizedObjectWeakPtr

typedef std::weak_ptr<GraspableSensorizedObject> VirtualRobot::GraspableSensorizedObjectWeakPtr

◆ GraspPtr

typedef std::shared_ptr<Grasp> VirtualRobot::GraspPtr

◆ GraspSetPtr

typedef std::shared_ptr<GraspSet> VirtualRobot::GraspSetPtr

◆ HierarchicalIKPtr

typedef std::shared_ptr< HierarchicalIK > VirtualRobot::HierarchicalIKPtr

◆ IKSolverPtr

typedef std::shared_ptr<IKSolver> VirtualRobot::IKSolverPtr

◆ InternalCollisionModel

typedef CollisionModelPQP VirtualRobot::InternalCollisionModel

◆ InternalCollisionModelPtr

typedef std::shared_ptr< InternalCollisionModel > VirtualRobot::InternalCollisionModelPtr

◆ JacobiProviderPtr

typedef std::shared_ptr<JacobiProvider> VirtualRobot::JacobiProviderPtr

◆ JointLimitAvoidanceJacobiPtr

typedef std::shared_ptr<JointLimitAvoidanceJacobi> VirtualRobot::JointLimitAvoidanceJacobiPtr

◆ KinematicChainPtr

typedef std::shared_ptr<KinematicChain> VirtualRobot::KinematicChainPtr

◆ LocalRobotPtr

typedef std::shared_ptr<LocalRobot> VirtualRobot::LocalRobotPtr

◆ ManipulabilityPtr

typedef std::shared_ptr<Manipulability> VirtualRobot::ManipulabilityPtr

◆ ManipulationObjectPtr

typedef std::shared_ptr<ManipulationObject> VirtualRobot::ManipulationObjectPtr

◆ NodeMapping

using VirtualRobot::NodeMapping = typedef std::unordered_map<std::string, NodeMappingElement>

◆ ObstaclePtr

typedef std::shared_ptr<Obstacle> VirtualRobot::ObstaclePtr

◆ OptimizationFunction

typedef double(* VirtualRobot::OptimizationFunction) (std::vector< double > &gradient)

◆ OptimizerPtr

typedef std::shared_ptr<nlopt::opt> VirtualRobot::OptimizerPtr

◆ OrientationConstraintPtr

typedef std::shared_ptr<OrientationConstraint> VirtualRobot::OrientationConstraintPtr

◆ PoseConstraintPtr

typedef std::shared_ptr<PoseConstraint> VirtualRobot::PoseConstraintPtr

◆ PoseQualityExtendedManipulabilityPtr

typedef std::shared_ptr<PoseQualityExtendedManipulability> VirtualRobot::PoseQualityExtendedManipulabilityPtr

◆ PoseQualityManipulabilityPtr

typedef std::shared_ptr<PoseQualityManipulability> VirtualRobot::PoseQualityManipulabilityPtr

◆ PoseQualityMeasurementPtr

typedef std::shared_ptr<PoseQualityMeasurement> VirtualRobot::PoseQualityMeasurementPtr

◆ PositionConstraintPtr

typedef std::shared_ptr<PositionConstraint> VirtualRobot::PositionConstraintPtr

◆ PositionSensorPtr

typedef std::shared_ptr< PositionSensor > VirtualRobot::PositionSensorPtr

◆ ReachabilityPtr

typedef std::shared_ptr<Reachability> VirtualRobot::ReachabilityPtr

◆ RobotConfigPtr

typedef std::shared_ptr<RobotConfig> VirtualRobot::RobotConfigPtr

◆ RobotNodeActuatorPtr

typedef std::shared_ptr<RobotNodeActuator> VirtualRobot::RobotNodeActuatorPtr

◆ RobotNodeFactoryPtr

typedef std::shared_ptr<RobotNodeFactory> VirtualRobot::RobotNodeFactoryPtr

◆ RobotNodeHemispherePtr

using VirtualRobot::RobotNodeHemispherePtr = typedef std::shared_ptr<class RobotNodeHemisphere>

◆ RobotNodePrismaticPtr

typedef std::shared_ptr<RobotNodePrismatic> VirtualRobot::RobotNodePrismaticPtr

◆ RobotNodePtr

typedef std::shared_ptr<RobotNode> VirtualRobot::RobotNodePtr

◆ RobotNodeRevolutePtr

typedef std::shared_ptr< RobotNodeRevolute > VirtualRobot::RobotNodeRevolutePtr

◆ RobotNodeSetPtr

typedef std::shared_ptr<RobotNodeSet> VirtualRobot::RobotNodeSetPtr

◆ RobotNodeWeakPtr

typedef std::weak_ptr<RobotNode> VirtualRobot::RobotNodeWeakPtr

◆ RobotPoseDifferentialIKPtr

typedef std::shared_ptr<RobotPoseDifferentialIK> VirtualRobot::RobotPoseDifferentialIKPtr

◆ RobotPtr

typedef std::shared_ptr<Robot> VirtualRobot::RobotPtr

◆ RobotWeakPtr

typedef std::weak_ptr<Robot> VirtualRobot::RobotWeakPtr

◆ SceneObjectPtr

typedef std::shared_ptr<SceneObject> VirtualRobot::SceneObjectPtr

◆ SceneObjectSetPtr

typedef std::shared_ptr<SceneObjectSet> VirtualRobot::SceneObjectSetPtr

◆ SceneObjectWeakPtr

typedef std::weak_ptr<SceneObject> VirtualRobot::SceneObjectWeakPtr

◆ ScenePtr

typedef std::shared_ptr<Scene> VirtualRobot::ScenePtr

◆ SensorFactoryPtr

typedef std::shared_ptr<SensorFactory> VirtualRobot::SensorFactoryPtr

◆ SensorPtr

typedef std::shared_ptr< Sensor > VirtualRobot::SensorPtr

◆ SphereApproximatorPtr

typedef std::shared_ptr<SphereApproximator> VirtualRobot::SphereApproximatorPtr

◆ StackedIKPtr

typedef std::shared_ptr<StackedIK> VirtualRobot::StackedIKPtr

◆ SupportPolygonPtr

typedef std::shared_ptr< SupportPolygon > VirtualRobot::SupportPolygonPtr

◆ TrajectoryPtr

typedef std::shared_ptr<Trajectory> VirtualRobot::TrajectoryPtr

◆ TriMeshModelPtr

typedef std::shared_ptr<TriMeshModel> VirtualRobot::TriMeshModelPtr

◆ TSRConstraintPtr

typedef std::shared_ptr<TSRConstraint> VirtualRobot::TSRConstraintPtr

◆ VisualizationFactoryPtr

typedef std::shared_ptr<VisualizationFactory> VirtualRobot::VisualizationFactoryPtr

◆ VisualizationNodePtr

typedef std::shared_ptr<VisualizationNode> VirtualRobot::VisualizationNodePtr

◆ VisualizationPtr

typedef std::shared_ptr<Visualization> VirtualRobot::VisualizationPtr

◆ WorkspaceDataArrayPtr

typedef std::shared_ptr<WorkspaceDataArray> VirtualRobot::WorkspaceDataArrayPtr

◆ WorkspaceDataPtr

typedef std::shared_ptr<WorkspaceData> VirtualRobot::WorkspaceDataPtr

◆ WorkspaceGridPtr

typedef std::shared_ptr<WorkspaceGrid> VirtualRobot::WorkspaceGridPtr

◆ WorkspaceRepresentationPtr

typedef std::shared_ptr<WorkspaceRepresentation> VirtualRobot::WorkspaceRepresentationPtr

Function Documentation

◆ deprecated()

class VirtualRobot::deprecated ( "MMMTools_LegacyConverter"  )

Initialize a Jacobian object.

Parameters
rnsThe robotNodes (i.e., joints) for which the Jacobians should be calculated.
coordSystemThe coordinate system in which the Jacobians are defined. By default the global coordinate system is used.

Compute a single IK step.

Parameters
stepSizeControls the amount of error to be reduced in each step: $ 0 < \beta \leq 1 $
Returns
The changes $\Delta \theta$ in the joint angles.
Note
{Note} This does not affect the joints values of the robot.

Computes the complete inverse kinematics.

Parameters
stepSizeControls the amount of error to be reduced in each step: $ 0 < \beta \leq 1 $
maxStepsMaximal numbers of steps.
minChangeThe minimal change in joint angles (euclidean distance in radians)
performMinOneStepIf set, at least one step is performed (helps escaping local minima, but may also cause pose jittering)
Note
{Note} Sets the node's joint angles automatically.

If enabled (standard), joint limits are considered via box constraints.

◆ getFilesize()

std::ifstream::pos_type VirtualRobot::getFilesize ( const char *  filename)

◆ getMaxLength()

static std::size_t VirtualRobot::getMaxLength ( const std::vector< std::pair< std::string, std::string >> &  items)
static

◆ getZBuffer()

void VirtualRobot::getZBuffer ( void *  userdata)

Used for a Coin3d callback to store the zBuffer.

Parameters
userdataThe datastructure to store the data to.
See also
renderOffscreenRgbDepthPointcloud

◆ init() [1/2]

void VIRTUAL_ROBOT_IMPORT_EXPORT VirtualRobot::init ( const std::string &  appName)

◆ init() [2/2]

void VIRTUAL_ROBOT_IMPORT_EXPORT VirtualRobot::init ( int &  argc,
char *  argv[],
const std::string &  appName 
)

Initialize the runtime envionment. This method calls VisualizationFactory::init().

◆ intersectTriangles()

static TriTriIntersection VirtualRobot::intersectTriangles ( Eigen::Vector3f const &  U0,
Eigen::Vector3f const &  U1,
Eigen::Vector3f const &  U2,
Eigen::Vector3f const &  V0,
Eigen::Vector3f const &  V1,
Eigen::Vector3f const &  V2 
)
static

◆ padding()

static std::string VirtualRobot::padding ( std::size_t  current,
std::size_t  target,
char  c = ' ' 
)
static

◆ PRNG64Bit()

std::mt19937_64 VIRTUAL_ROBOT_IMPORT_EXPORT & VirtualRobot::PRNG64Bit ( )

◆ projectedBoundingCircle()

Circle VirtualRobot::projectedBoundingCircle ( const Robot &  robot)
inline

◆ quat2eigen3f()

Eigen::Matrix3f VIRTUAL_ROBOT_IMPORT_EXPORT VirtualRobot::quat2eigen3f ( float  qx,
float  qy,
float  qz,
float  qw 
)

◆ RandomFloat() [1/2]

float VirtualRobot::RandomFloat ( )
inline

◆ RandomFloat() [2/2]

float VirtualRobot::RandomFloat ( float  min,
float  max 
)
inline

◆ RandomNumber()

std::mt19937_64::result_type VirtualRobot::RandomNumber ( )
inline

◆ RuntimeEnvironment_makeOptionsDescription()

static boost::program_options::options_description VirtualRobot::RuntimeEnvironment_makeOptionsDescription ( )
static

Make the options description based on the added keys and flags.

◆ RuntimeEnvironment_processParsedOptions()

static void VirtualRobot::RuntimeEnvironment_processParsedOptions ( const boost::program_options::parsed_options &  parsed)
static

◆ toBool()

bool VirtualRobot::toBool ( const std::string &  strRepr)
inlinenoexcept

◆ uniformDeviate()

double VirtualRobot::uniformDeviate ( int  seed)
inline

Variable Documentation

◆ globalAppName

VIRTUAL_ROBOT_IMPORT_EXPORT std::string VirtualRobot::globalAppName

◆ INVALID_VALUE

constexpr int VirtualRobot::INVALID_VALUE = -1

◆ limit

const float VirtualRobot::limit = 1.0
static

◆ RoleNames

const simox::meta::EnumNames<RobotNodeHemisphere::Role> VirtualRobot::RoleNames
Initial value:
=
{
{ RobotNodeHemisphere::Role::FIRST, "first" },
{ RobotNodeHemisphere::Role::SECOND, "second" },
}

◆ RuntimeEnvironment_caption

std::string VirtualRobot::RuntimeEnvironment_caption = "Simox runtime options"
static

◆ RuntimeEnvironment_dataPaths

std::vector< std::string > VirtualRobot::RuntimeEnvironment_dataPaths
static

◆ RuntimeEnvironment_flags

std::set< std::string > VirtualRobot::RuntimeEnvironment_flags
static

◆ RuntimeEnvironment_helpFlag

bool VirtualRobot::RuntimeEnvironment_helpFlag = false
static

◆ RuntimeEnvironment_keyValues

std::map< std::string, std::string > VirtualRobot::RuntimeEnvironment_keyValues
static

◆ RuntimeEnvironment_pathInitialized

bool VirtualRobot::RuntimeEnvironment_pathInitialized = false
static

◆ RuntimeEnvironment_processFlags

std::vector< std::pair<std::string, std::string> > VirtualRobot::RuntimeEnvironment_processFlags
static

Pairs of (flag, description). If not given, description is empty.

◆ RuntimeEnvironment_processKeys

std::vector< std::pair<std::string, std::string> > VirtualRobot::RuntimeEnvironment_processKeys
static

Pairs of (key, description). If not given, description is empty.

◆ RuntimeEnvironment_unrecognizedOptions

std::vector< std::string > VirtualRobot::RuntimeEnvironment_unrecognizedOptions
static