Choreonoid  1.8
Classes | Typedefs | Enumerations | Functions | Variables
cnoid Namespace Reference

Classes

class  AbstractBodyLoader
 
class  AbstractMultiSeq
 
class  AbstractMultiSeqItem
 
class  AbstractSceneLoader
 
class  AbstractSceneWriter
 
class  AbstractSeq
 
class  AbstractSeqItem
 
class  AbstractTaskSequencer
 
class  AbstractTextItem
 
class  AbstractVRMLGroup
 
class  AccelerationSensor
 
class  Action
 
class  ActionGroup
 
class  AISTCollisionDetector
 
class  AISTSimulatorItem
 
class  App
 
class  AppConfig
 
class  Archive
 
class  ArchiveSession
 
class  Array2D
 
class  AttachmentDevice
 
class  AudioItem
 
class  BasicLightingProgram
 
class  BasicSensorSimulationHelper
 
class  Body
 
class  BodyBar
 
class  BodyCollisionDetector
 
class  BodyContactPointLoggerItem
 
struct  BodyCustomizerInterface
 
class  BodyElementOverwriteItem
 
class  BodyHandler
 
class  BodyHandlerManager
 
struct  BodyInterface
 
class  BodyItem
 
class  BodyItemBodyFileIO
 
class  BodyItemFileIoBase
 
class  BodyKinematicsEditRecord
 
class  BodyLinkView
 
class  BodyLoader
 
class  BodyMarkerItem
 
class  BodyMotion
 
class  BodyMotionControllerItem
 
class  BodyMotionEngine
 
class  BodyMotionItem
 
class  BodyMotionPoseProvider
 
class  BodyOverwriteAddon
 
class  BodySelectionManager
 
class  BodyState
 
class  BodyStateView
 
class  BodySuperimposerAddon
 
class  BodyTrackingCameraItem
 
class  BoundingBox
 
class  BoundingBoxf
 
class  BoundingBoxMarker
 
class  ButtonGroup
 
class  Camera
 
class  CaptureBar
 
class  ChangeProperty
 
class  ChangeProperty< Selection >
 
class  CharSeparator
 
class  CheckBox
 
class  CheckBoxAction
 
class  ClonableReferenced
 
class  CloneMap
 
class  ColdetModel
 
class  ColdetModelInternalModel
 
class  ColdetModelPair
 
struct  Collision
 
class  collision_data
 
class  CollisionDetector
 
class  CollisionDetectorDistanceAPI
 
struct  CollisionLinkPair
 
class  CollisionPair
 
class  CollisionSeq
 
class  CollisionSeqEngine
 
class  CollisionSeqItem
 
class  ComboBox
 
class  CompositeBodyIK
 
class  CompositeIK
 
class  Connection
 
class  ConnectionSet
 
class  ConnectionSetBase
 
class  ConstraintForceSolver
 
class  ContactMaterial
 
class  ControllerIO
 
class  ControllerItem
 
class  ControllerLogItem
 
class  CoordinateAxesOverlay
 
class  CoordinateFrame
 
class  CoordinateFrameItem
 
class  CoordinateFrameList
 
class  CoordinateFrameListItem
 
class  CoordinateFrameListView
 
class  CoordinateFrameMarker
 
class  CrossMarker
 
class  CustomJointPathBase
 
class  CustomJointPathHandler
 
class  DataMap
 
class  DataMapBase
 
class  DefaultItemCreationPanel
 
class  Deque2D
 
class  DescriptionDialog
 
class  Device
 
class  DeviceList
 
class  DeviceOverwriteItem
 
class  DeviceOverwriteMediator
 
class  DeviceState
 
class  Dial
 
class  Dialog
 
class  DigitalIoConnection
 
class  DigitalIoDevice
 
class  DigitalIoDeviceView
 
class  DisplayedValueFormatManager
 
class  DoubleScrollBar
 
class  DoubleSpinBox
 
class  DSMediaView
 
class  DyBody
 
class  DyLink
 
class  DySubBody
 
class  DyWorld
 
class  DyWorldBase
 
class  EasyScanner
 
class  EditableSceneBody
 
class  EditableSceneLink
 
class  EditRecord
 
class  EditRecordGroup
 
struct  empty_data_error
 
struct  escaped_list_error
 
class  EscapedListSeparator
 
struct  exception_base
 
class  ExtCommandItem
 
class  ExtensionManager
 
class  ExtJoystick
 
class  ExtraBodyStateAccessor
 
class  ExtraJoint
 
struct  file_read_error
 
class  FileBar
 
class  FileDialog
 
class  FilePathProperty
 
class  FilePathVariableProcessor
 
class  FisheyeLensConverter
 
class  FloatingNumberBox
 
class  FloatingNumberString
 
class  FolderItem
 
class  ForceSensor
 
class  ForwardDynamics
 
class  ForwardDynamicsABM
 
class  ForwardDynamicsCBM
 
class  FullLightingProgram
 
class  GeneralId
 
class  GeneralSceneFileImporterBase
 
class  GeneralSeqReader
 
class  GeneralSliderView
 
class  GettextDomainBinder
 
class  GL1SceneRenderer
 
class  GLSceneRenderer
 
class  GLSLProgram
 
class  GLSLSceneRenderer
 
class  GLSLUniformBlockBuffer
 
class  GLVisionSimulatorItem
 
class  GraphBar
 
class  GraphDataHandler
 
class  GraphViewBase
 
class  GraphWidget
 
class  GSMediaView
 
class  HierarchicalClassRegistry
 
class  HierarchicalClassRegistryBase
 
class  HolderDevice
 
class  HSeparator
 
class  HSeparatorBox
 
class  IdPair
 
class  Image
 
class  ImageableItem
 
class  ImageConverter
 
class  ImageIO
 
class  ImageView
 
class  ImageViewBar
 
class  ImageWidget
 
class  InfoBar
 
class  InteractiveCameraTransform
 
class  InverseKinematics
 
class  IoConnectionMap
 
class  IoConnectionMapItem
 
class  IoConnectionView
 
class  Item
 
class  ItemAddon
 
class  ItemClassRegistry
 
class  ItemCreationPanel
 
class  ItemCreationPanelBase
 
class  ItemEditRecordManager
 
class  ItemFileDialog
 
class  ItemFileIO
 
class  ItemFileIoBase
 
class  ItemList
 
class  ItemListBase
 
class  ItemManager
 
class  ItemPath
 
class  ItemPropertyView
 
class  ItemPropertyWidget
 
class  ItemSelectionModel
 
class  ItemTreeArchiver
 
class  ItemTreePanel
 
class  ItemTreePanelBase
 
class  ItemTreePanelDialog
 
class  ItemTreeView
 
class  ItemTreeWidget
 
class  JointDisplacementView
 
class  JointDisplacementWidget
 
class  JointGraphView
 
class  JointPath
 
class  JointSpaceConfigurationHandler
 
class  JointStateView
 
class  Joystick
 
class  JoystickCapture
 
class  JoystickInterface
 
class  KinematicFaultChecker
 
class  KinematicsBar
 
class  KinematicSimulatorItem
 
class  LazyCaller
 
class  LazySignal
 
class  LazySignalBase
 
class  LeggedBodyBar
 
class  LeggedBodyHelper
 
class  Light
 
class  LightingItem
 
class  LightingProgram
 
class  LineEdit
 
class  Link
 
class  LinkDeviceListView
 
class  LinkDeviceTreeItem
 
class  LinkDeviceTreeWidget
 
class  LinkGraphView
 
class  LinkGroup
 
class  LinkKinematicsKit
 
class  LinkKinematicsKitManager
 
class  LinkOffsetFrameListItem
 
class  LinkPath
 
class  LinkPositionView
 
class  LinkPositionWidget
 
class  LinkPropertyView
 
class  LinkShapeOverwriteItem
 
class  LinkTraverse
 
class  Listing
 
class  LocatableItem
 
class  LocationProxy
 
class  LocationView
 
class  LogicalProduct
 
class  LogicalSum
 
class  MainWindow
 
class  Mapping
 
class  MarkerDevice
 
class  Material
 
class  MaterialLightingProgram
 
class  MaterialTable
 
class  MaterialTableItem
 
class  MediaItem
 
class  Menu
 
class  MenuManager
 
class  MeshExtractor
 
class  MeshFilter
 
class  MeshGenerator
 
class  MessageLogItem
 
class  MessageView
 
class  MinimumLightingProgram
 
class  MovieRecorder
 
class  MprAssignStatement
 
class  MprCallStatement
 
class  MprCommentStatement
 
class  MprConditionStatement
 
class  MprControllerItemBase
 
class  MprControllerLog
 
class  MprDelayStatement
 
class  MprDummyStatement
 
class  MprElseStatement
 
class  MprEmptyStatement
 
class  MprFkPosition
 
class  MprGroupStatement
 
class  MprIfStatement
 
class  MprIkPosition
 
class  MprMultiVariableListItem
 
class  MprPosition
 
class  MprPositionList
 
class  MprPositionListView
 
class  MprPositionStatement
 
class  MprPositionStatementPanel
 
class  MprProgram
 
class  MprProgramItemBase
 
class  MprProgramViewBase
 
class  MprSignalStatement
 
class  MprStatement
 
class  MprStatementClassRegistry
 
class  MprStatementPanel
 
class  MprStatementRegistration
 
class  MprStatementViewBase
 
class  MprStructuredStatement
 
class  MprTagTraceStatement
 
class  MprTagTraceStatementPanel
 
class  MprVariable
 
class  MprVariableList
 
class  MprVariableListView
 
class  MprWaitStatement
 
class  MprWhileStatement
 
class  MultiDeviceStateSeq
 
class  MultiDeviceStateSeqItem
 
class  MultiPointSetItem
 
class  MultiSE3MatrixSeq
 
class  MultiSE3Seq
 
class  MultiSE3SeqGraphView
 
class  MultiSeq
 
class  MultiSeqItem
 
class  MultiSeqItemCreationPanel
 
class  MultiValueSeq
 
class  MultiValueSeqGraphView
 
class  MultiVector3Seq
 
class  NolightingProgram
 
struct  nonexistent_key_error
 
class  ObjSceneLoader
 
class  ObjSceneWriter
 
class  OptionManager
 
class  OutlineProgram
 
class  PathVariableEditor
 
class  PenetrationBlocker
 
class  PinDragIK
 
class  PlainSeqFileLoader
 
class  PlainTextEdit
 
class  Plugin
 
class  PluginManager
 
class  PointLight
 
class  PointSetItem
 
class  PolygonMeshTriangulator
 
class  PolyhedralRegion
 
class  PolymorphicFunctionSet
 
class  PolymorphicItemFunctionSet
 
class  PolymorphicMprStatementFunctionSet
 
class  PolymorphicPointerArray
 
class  PolymorphicPointerArrayBase
 
class  PolymorphicReferencedArray
 
class  PolymorphicReferencedArrayBase
 
class  PolymorphicSceneNodeFunctionSet
 
class  PoseProvider
 
class  PoseProviderToBodyMotionConverter
 
class  PositionDragger
 
class  PositionTag
 
class  PositionTagGroup
 
class  PositionTagGroupItem
 
class  PositionTagListWidget
 
class  PositionWidget
 
class  Process
 
class  ProjectManager
 
class  PulseAudioManager
 
class  PushButton
 
class  PutPropertyFunction
 
class  PythonConsoleView
 
class  PythonExecutor
 
class  PythonPlugin
 
class  PythonScriptItem
 
class  PythonScriptItemImpl
 
class  PythonSimScriptItem
 
class  QueuedCaller
 
class  RadioButton
 
class  RangeCamera
 
class  RangeLimiter
 
class  RangeSensor
 
class  RateGyroSensor
 
class  RectRegionMarker
 
class  ref_ptr
 
class  Referenced
 
class  ReferencedObjectSeq
 
class  ReferencedObjectSeqItem
 
class  RenderableItem
 
class  RootItem
 
class  ScalarNode
 
class  SceneBar
 
class  SceneBody
 
class  SceneCollision
 
class  SceneCylinderProjector
 
class  SceneDevice
 
class  SceneDragProjector
 
class  SceneGraphOptimizer
 
class  SceneItem
 
class  SceneItemStdSceneFileExporter
 
class  SceneLink
 
class  SceneLoader
 
class  SceneMarker
 
class  SceneNodeClassRegistry
 
class  SceneNodeExtractor
 
class  ScenePlaneProjector
 
class  ScenePointSelectionMode
 
class  SceneProjector
 
class  SceneRenderer
 
class  SceneView
 
class  SceneWidget
 
class  SceneWidgetEvent
 
class  SceneWidgetEventHandler
 
class  SceneWidgetRoot
 
class  ScopedConnection
 
class  ScopedConnectionSet
 
class  ScriptBar
 
class  ScriptItem
 
class  ScrollBar
 
class  SE3
 
class  Selection
 
class  SensorVisualizerItem
 
class  Seq
 
struct  SFImage
 
struct  SFTime
 
class  SgAffineTransform
 
class  SgBoundingBox
 
class  SgCamera
 
class  SgDirectionalLight
 
class  SgFixedPixelSizeGroup
 
class  SgFog
 
class  SgGroup
 
class  SgHighlight
 
class  SgImage
 
class  SgInvariantGroup
 
class  SgLight
 
class  SgLightweightRenderingGroup
 
class  SgLineSet
 
class  SgMaterial
 
class  SgMesh
 
class  SgMeshBase
 
class  SgNode
 
class  SgObject
 
class  SgOrthographicCamera
 
class  SgOutline
 
class  SgOverlay
 
class  SgPerspectiveCamera
 
class  SgPlot
 
class  SgPointLight
 
class  SgPointSet
 
class  SgPolygonDrawStyle
 
class  SgPolygonMesh
 
class  SgPosTransform
 
class  SgPreprocessed
 
class  SgScaleTransform
 
class  SgShape
 
class  SgSpotLight
 
class  SgSwitch
 
class  SgSwitchableGroup
 
class  SgTexture
 
class  SgTextureTransform
 
class  SgTmpUpdate
 
class  SgTransform
 
class  SgTransparentGroup
 
class  SgUnpickableGroup
 
class  SgUpdate
 
class  SgUpdateRef
 
class  SgVectorArray
 
class  SgViewportOverlay
 
class  ShaderProgram
 
class  ShadowMapProgram
 
class  SharedJoystick
 
class  Signal
 
class  Signal< R(Args...), Combiner >
 
class  SignalProxy
 
class  SimpleController
 
class  SimpleControllerConfig
 
class  SimpleControllerIO
 
class  SimpleControllerItem
 
class  SimpleScanner
 
class  SimulationBar
 
class  SimulationBody
 
class  SimulationScriptItem
 
class  SimulationSimpleControllerIO
 
class  SimulatorItem
 
class  Slider
 
class  SocketNotifier
 
class  SolidColorExProgram
 
class  SolidColorProgram
 
class  SolidPointProgram
 
class  SphereMarker
 
class  SpinBox
 
class  Splitter
 
class  SpotLight
 
struct  StdBodyFileDeviceTypeRegistration
 
class  StdBodyLoader
 
class  StdBodyWriter
 
class  StdSceneLoader
 
class  StdSceneReader
 
class  StdSceneWriter
 
class  STLSceneLoader
 
class  StringListComboBox
 
class  SubProjectItem
 
class  SubSimulatorItem
 
class  TargetItemPicker
 
class  TargetItemPickerBase
 
class  Task
 
class  TaskCommand
 
class  TaskMenu
 
class  TaskPhase
 
class  TaskPhaseProxy
 
class  TaskProc
 
class  TaskToggleState
 
class  TaskView
 
class  TextEdit
 
class  TextEditView
 
class  ThickLineProgram
 
class  ThreadPool
 
class  TimeBar
 
class  TimeMeasure
 
class  Timer
 
class  TimeSyncItemEngine
 
class  TimeSyncItemEngineManager
 
class  Timeval
 
class  ToggleButton
 
class  ToggleToolButton
 
class  TokenIterator
 
class  TokenIteratorGenerator
 
class  Tokenizer
 
class  ToolBar
 
class  ToolBarArea
 
class  ToolButton
 
class  TreeView
 
class  TreeWidget
 
class  Triangulator
 
class  TruncatedSVD
 
struct  type_mismatch_error
 
class  UnifiedEditHistory
 
class  UnifiedEditHistoryView
 
class  UniformCubicBSpline
 
class  UniformCubicBSplineBase
 
class  UniformCubicBSplineVector
 
class  Uuid
 
class  ValueNode
 
class  Vector3Seq
 
class  Vector3SeqItem
 
class  View
 
class  ViewArea
 
class  ViewClass
 
class  ViewManager
 
class  VirtualJoystickView
 
class  VRMLAccelerationSensor
 
class  VRMLAnchor
 
class  VRMLAppearance
 VRML Appearance node. More...
 
class  VRMLBackground
 VRML Background node. More...
 
class  VRMLBillboard
 
class  VRMLBodyLoader
 
class  VRMLBox
 VRML Box node. More...
 
class  VRMLCollision
 
class  VRMLColor
 VRML Color node. More...
 
class  VRMLCone
 VRML Cone node. More...
 
class  VRMLCoordinate
 VRML Coordinate node. More...
 
class  VRMLCylinder
 VRML Cylinder node. More...
 
class  VRMLCylinderSensor
 VRML CylinderSensor node. More...
 
class  VRMLDirectionalLight
 
class  VRMLElevationGrid
 VRML ElevationGrid node. More...
 
class  VRMLExtrusion
 VRML Extrusion node. More...
 
class  VRMLFog
 
class  VRMLFontStyle
 VRML FontStyle node. More...
 
class  VRMLForceSensor
 
class  VRMLGeometry
 Base class of VRML geometry nodes. More...
 
class  VRMLGroup
 VRML Group node. More...
 
class  VRMLGyro
 
class  VRMLHumanoid
 
class  VRMLImageTexture
 VRML ImageTexture node. More...
 
class  VRMLIndexedFaceSet
 VRML IndexedFaseSet node. More...
 
class  VRMLIndexedLineSet
 VRML IndexedLineSet node. More...
 
class  VRMLInline
 VRML Inline node. More...
 
class  VRMLJoint
 
class  VRMLLight
 
class  VRMLLOD
 
class  VRMLMaterial
 VRML Material node. More...
 
class  VRMLMovieTexture
 VRML MovieTexture node. More...
 
class  VRMLNavigationInfo
 VRML NavigationInfo node. More...
 
class  VRMLNode
 Abstract base class of all vrml nodes. More...
 
class  VRMLNonVrmlInline
 
class  VRMLNormal
 VRML Normal node. More...
 
class  VRMLParser
 Parser for VRML97 format. More...
 
class  VRMLPixelTexture
 VRML PixelTexture node. More...
 
class  VRMLPointLight
 
class  VRMLPointSet
 VRML PointSet node. More...
 
class  VRMLProto
 VRML Proto definition. More...
 
class  VRMLProtoInstance
 VRML node which is instance of VRML Prototype. More...
 
class  VRMLRangeSensor
 
class  VRMLSceneLoader
 
class  VRMLSegment
 
class  VRMLShape
 VRML Shape node. More...
 
class  VRMLSphere
 VRML Sphere node. More...
 
class  VRMLSpotLight
 
class  VRMLSurface
 
class  VRMLSwitch
 
class  VRMLText
 VRML Text node. More...
 
class  VRMLTexture
 Base class of VRML Texture nodes. More...
 
class  VRMLTextureCoordinate
 VRML TextureCoordinate node. More...
 
class  VRMLTextureTransform
 VRML TextureTransform node. More...
 
class  VRMLToSGConverter
 
class  VRMLTransform
 VRML Transform node. More...
 
class  VRMLUnsupportedNode
 
class  VRMLViewpoint
 VRML Viewpoint node. More...
 
class  VRMLVisionSensor
 
class  VRMLWorldInfo
 
class  VRMLWriter
 
class  VSeparator
 
class  weak_ref_ptr
 
class  WeakCounter
 
class  Widget
 
class  WorldItem
 
class  WorldLogFileItem
 
class  YAMLReader
 
class  YAMLWriter
 
class  ZMPSeq
 
class  ZMPSeqItem
 

Typedefs

typedef std::vector< CollisionCollisionArray
 
typedef std::vector< CollisionCollisionList
 obsolete More...
 
typedef ref_ptr< CollisionDetectorCollisionDetectorPtr
 
typedef ref_ptr< CoordinateFrameCoordinateFramePtr
 
typedef ref_ptr< CoordinateFrameListCoordinateFrameListPtr
 
typedef Eigen::Matrix2d Matrix2
 
typedef Eigen::Vector2d Vector2
 
typedef Eigen::Matrix3d Matrix3
 
typedef Eigen::Vector3d Vector3
 
typedef Eigen::Matrix4d Matrix4
 
typedef Eigen::Vector4d Vector4
 
typedef Eigen::VectorXd VectorX
 
typedef Eigen::Matrix< double, 6, 1 > Vector6
 
typedef Eigen::Affine3d Affine3
 
typedef Eigen::Translation3d Translation3
 
typedef Eigen::AngleAxisd AngleAxis
 
typedef Eigen::Quaterniond Quaternion
 
typedef Eigen::Quaterniond Quat
 
typedef Eigen::Isometry3d Isometry3
 
typedef Isometry3 Position
 
typedef boost::error_info< struct tag_error_info_message, std::string > error_info_message
 
typedef boost::error_info< struct tag_error_info_key, std::string > error_info_key
 
typedef ref_ptr< FilePathVariableProcessorFilePathVariableProcessorPtr
 
typedef MeshFilter MeshNormalGenerator
 
typedef ref_ptr< PositionTagPositionTagPtr
 
typedef ref_ptr< PositionTagGroupPositionTagGroupPtr
 
typedef ref_ptr< ReferencedReferencedPtr
 
typedef ref_ptr< SgCameraSgCameraPtr
 
typedef ref_ptr< SgPerspectiveCameraSgPerspectiveCameraPtr
 
typedef ref_ptr< SgOrthographicCameraSgOrthographicCameraPtr
 
typedef ref_ptr< SgMaterialSgMaterialPtr
 
typedef ref_ptr< SgImageSgImagePtr
 
typedef ref_ptr< SgTextureTransformSgTextureTransformPtr
 
typedef ref_ptr< SgTextureSgTexturePtr
 
typedef SgVectorArray< Vector3f > SgVertexArray
 
typedef ref_ptr< SgVertexArraySgVertexArrayPtr
 
typedef SgVectorArray< Vector3f > SgNormalArray
 
typedef ref_ptr< SgNormalArraySgNormalArrayPtr
 
typedef SgVectorArray< Vector3f > SgColorArray
 
typedef ref_ptr< SgColorArraySgColorArrayPtr
 
typedef SgVectorArray< Vector2f, Eigen::aligned_allocator< Vector2f > > SgTexCoordArray
 
typedef ref_ptr< SgTexCoordArraySgTexCoordArrayPtr
 
typedef std::vector< int > SgIndexArray
 
typedef ref_ptr< SgMeshBaseSgMeshBasePtr
 
typedef ref_ptr< SgMeshSgMeshPtr
 
typedef ref_ptr< SgPolygonMeshSgPolygonMeshPtr
 
typedef ref_ptr< SgShapeSgShapePtr
 
typedef ref_ptr< SgPlotSgPlotPtr
 
typedef ref_ptr< SgPointSetSgPointSetPtr
 
typedef ref_ptr< SgLineSetSgLineSetPtr
 
typedef ref_ptr< SgOverlaySgOverlayPtr
 
typedef ref_ptr< SgViewportOverlaySgViewportOverlayPtr
 
typedef ref_ptr< SgPolygonDrawStyleSgPolygonDrawStylePtr
 
typedef ref_ptr< SgTransparentGroupSgTransparentGroupPtr
 
typedef ref_ptr< SgFogSgFogPtr
 
typedef ref_ptr< SgHighlightSgHighlightPtr
 
typedef ref_ptr< SgBoundingBoxSgBoundingBoxPtr
 
typedef ref_ptr< SgOutlineSgOutlinePtr
 
typedef ref_ptr< SgLightweightRenderingGroupSgLightweightRenderingGroupPtr
 
typedef std::vector< SgNode * > SgNodePath
 
typedef ref_ptr< SgObjectSgObjectPtr
 
typedef ref_ptr< SgNodeSgNodePtr
 
typedef ref_ptr< SgGroupSgGroupPtr
 
typedef ref_ptr< SgInvariantGroupSgInvariantGroupPtr
 
typedef ref_ptr< SgTransformSgTransformPtr
 
typedef ref_ptr< SgPosTransformSgPosTransformPtr
 
typedef ref_ptr< SgScaleTransformSgScaleTransformPtr
 
typedef ref_ptr< SgAffineTransformSgAffineTransformPtr
 
typedef ref_ptr< SgFixedPixelSizeGroupSgFixedPixelSizeGroupPtr
 
typedef ref_ptr< SgSwitchSgSwitchPtr
 
typedef ref_ptr< SgSwitchableGroupSgSwitchableGroupPtr
 
typedef ref_ptr< SgUnpickableGroupSgUnpickableGroupPtr
 
typedef ref_ptr< SgPreprocessedSgPreprocessedPtr
 
typedef ref_ptr< SgLightSgLightPtr
 
typedef ref_ptr< SgDirectionalLightSgDirectionalLightPtr
 
typedef ref_ptr< SgPointLightSgPointLightPtr
 
typedef ref_ptr< SgSpotLightSgSpotLightPtr
 
typedef ref_ptr< SceneMarkerSceneMarkerPtr
 
typedef ref_ptr< CrossMarkerCrossMarkerPtr
 
typedef ref_ptr< SphereMarkerSphereMarkerPtr
 
typedef ref_ptr< BoundingBoxMarkerBoundingBoxMarkerPtr
 
typedef ref_ptr< SharedJoystickSharedJoystickPtr
 
typedef ref_ptr< MappingMappingPtr
 
typedef std::function< void(TaskProc *proc)> TaskFunc
 
typedef ref_ptr< TaskToggleStateTaskToggleStatePtr
 
typedef ref_ptr< TaskCommandTaskCommandPtr
 
typedef ref_ptr< TaskPhaseProxyTaskPhaseProxyPtr
 
typedef ref_ptr< TaskPhaseTaskPhasePtr
 
typedef ref_ptr< TaskTaskPtr
 
typedef ref_ptr< ValueNodeValueNodePtr
 
typedef ref_ptr< ScalarNodeScalarNodePtr
 
typedef ref_ptr< ListingListingPtr
 
typedef bool SFBool
 
typedef int SFInt32
 
typedef double SFFloat
 
typedef std::string SFString
 
typedef Eigen::Vector2d SFVec2f
 
typedef Eigen::Vector2f SFVec2s
 
typedef Eigen::Vector3d SFVec3f
 
typedef Eigen::Vector3f SFVec3s
 
typedef Eigen::Vector3f SFColor
 
typedef Eigen::AngleAxisd SFRotation
 
typedef std::vector< SFInt32MFInt32
 
typedef std::vector< SFFloatMFFloat
 
typedef std::vector< SFVec2f, Eigen::aligned_allocator< SFVec2f > > MFVec2f
 
typedef std::vector< SFVec2sMFVec2s
 
typedef std::vector< SFVec3fMFVec3f
 
typedef std::vector< SFVec3sMFVec3s
 
typedef std::vector< SFRotation, Eigen::aligned_allocator< SFRotation > > MFRotation
 
typedef std::vector< SFTimeMFTime
 
typedef std::vector< SFColorMFColor
 
typedef std::vector< SFStringMFString
 
typedef ref_ptr< VRMLNodeVRMLNodePtr
 
typedef VRMLNodePtr SFNode
 
typedef std::vector< SFNodeMFNode
 
typedef ref_ptr< VRMLUnsupportedNodeVRMLUnsupportedNodePtr
 
typedef ref_ptr< VRMLViewpointVRMLViewpointPtr
 
typedef ref_ptr< VRMLNavigationInfoVRMLNavigationInfoPtr
 
typedef ref_ptr< VRMLBackgroundVRMLBackgroundPtr
 
typedef ref_ptr< AbstractVRMLGroupAbstractVRMLGroupPtr
 
typedef ref_ptr< VRMLGroupVRMLGroupPtr
 
typedef ref_ptr< VRMLTransformVRMLTransformPtr
 
typedef ref_ptr< VRMLInlineVRMLInlinePtr
 
typedef ref_ptr< VRMLNonVrmlInlineVRMLNonVrmlInlinePtr
 
typedef ref_ptr< VRMLAppearanceVRMLAppearancePtr
 
typedef ref_ptr< VRMLGeometryVRMLGeometryPtr
 
typedef ref_ptr< VRMLShapeVRMLShapePtr
 
typedef ref_ptr< VRMLMaterialVRMLMaterialPtr
 
typedef ref_ptr< VRMLTextureVRMLTexturePtr
 
typedef ref_ptr< VRMLTextureTransformVRMLTextureTransformPtr
 
typedef ref_ptr< VRMLImageTextureVRMLImageTexturePtr
 
typedef ref_ptr< VRMLBoxVRMLBoxPtr
 
typedef ref_ptr< VRMLConeVRMLConePtr
 
typedef ref_ptr< VRMLCylinderVRMLCylinderPtr
 
typedef ref_ptr< VRMLSphereVRMLSpherePtr
 
typedef ref_ptr< VRMLFontStyleVRMLFontStylePtr
 
typedef ref_ptr< VRMLTextVRMLTextPtr
 
typedef ref_ptr< VRMLColorVRMLColorPtr
 
typedef ref_ptr< VRMLCoordinateVRMLCoordinatePtr
 
typedef ref_ptr< VRMLIndexedLineSetVRMLIndexedLineSetPtr
 
typedef ref_ptr< VRMLNormalVRMLNormalPtr
 
typedef ref_ptr< VRMLTextureCoordinateVRMLTextureCoordinatePtr
 
typedef ref_ptr< VRMLIndexedFaceSetVRMLIndexedFaceSetPtr
 
typedef ref_ptr< VRMLCylinderSensorVRMLCylinderSensorPtr
 
typedef ref_ptr< VRMLPointSetVRMLPointSetPtr
 
typedef ref_ptr< VRMLPixelTextureVRMLPixelTexturePtr
 
typedef ref_ptr< VRMLMovieTextureVRMLMovieTexturePtr
 
typedef ref_ptr< VRMLElevationGridVRMLElevationGridPtr
 
typedef ref_ptr< VRMLExtrusionVRMLExtrusionPtr
 
typedef ref_ptr< VRMLSwitchVRMLSwitchPtr
 
typedef ref_ptr< VRMLLODVRMLLODPtr
 
typedef ref_ptr< VRMLCollisionVRMLCollisionPtr
 
typedef ref_ptr< VRMLAnchorVRMLAnchorPtr
 
typedef ref_ptr< VRMLBillboardVRMLBillboardPtr
 
typedef ref_ptr< VRMLFogVRMLFogPtr
 
typedef ref_ptr< VRMLWorldInfoVRMLWorldInfoPtr
 
typedef ref_ptr< VRMLLightVRMLLightPtr
 
typedef ref_ptr< VRMLPointLightVRMLPointLightPtr
 
typedef ref_ptr< VRMLDirectionalLightVRMLDirectionalLightPtr
 
typedef ref_ptr< VRMLSpotLightVRMLSpotLightPtr
 
typedef stdx::variant< SFBool, SFInt32, SFFloat, SFVec2f, SFVec3f, SFRotation, SFColor, SFTime, SFString, SFNode, SFImage, MFInt32, MFFloat, MFVec2f, MFVec3f, MFRotation, MFColor, MFTime, MFString, MFNodeVRMLVariantField
 
typedef std::map< std::string, VRMLVariantFieldVRMLProtoFieldMap
 
typedef std::pair< std::string, VRMLVariantFieldVRMLProtoFieldPair
 
typedef ref_ptr< VRMLProtoVRMLProtoPtr
 
typedef ref_ptr< VRMLProtoInstanceVRMLProtoInstancePtr
 
typedef ref_ptr< AISTCollisionDetectorAISTCollisionDetectorPtr
 
typedef ref_ptr< ColdetModelColdetModelPtr
 
typedef ref_ptr< ColdetModelPairColdetModelPairPtr
 
typedef std::shared_ptr< AbstractBodyLoaderAbstractBodyLoaderPtr
 
typedef ref_ptr< AccelerationSensorAccelerationSensorPtr
 
typedef ref_ptr< AttachmentDeviceAttachmentDevicePtr
 
typedef void * BodyCustomizerHandle
 
typedef ref_ptr< BodyBodyPtr
 
typedef void * BodyHandle
 
typedef int(* BodyGetLinkIndexFromNameFunc) (BodyHandle bodyHandle, const char *linkName)
 
typedef double *(* BodyGetLinkDoubleValuePtrFunc) (BodyHandle bodyHandle, int linkIndex)
 
typedef BodyCustomizerHandle(* BodyCustomizerCreateFunc) (BodyHandle bodyHandle, const char *modelName)
 
typedef void(* BodyCustomizerDestroyFunc) (BodyCustomizerHandle customizerHandle)
 
typedef int(* BodyCustomizerInitializeAnalyticIkFunc) (BodyCustomizerHandle customizerHandle, int baseLinkIndex, int targetLinkIndex)
 
typedef bool(* BodyCustomizerCalcAnalyticIkFunc) (BodyCustomizerHandle customizerHandle, int ikPathId, const Vector3 &p, const Matrix3 &R)
 
typedef void(* BodyCustomizerSetVirtualJointForcesFunc) (BodyCustomizerHandle customizerHandle)
 
typedef void(* BodyCustomizerSetVirtualJointForces2Func) (BodyCustomizerHandle customizerHandle, double timeStep)
 
typedef BodyCustomizerInterface *(* GetBodyCustomizerInterfaceFunc) (BodyInterface *bodyInterface)
 
typedef ref_ptr< BodyHandlerBodyHandlerPtr
 
typedef ref_ptr< CameraCameraPtr
 
typedef std::shared_ptr< CollisionLinkPairCollisionLinkPairPtr
 
typedef ref_ptr< ContactMaterialContactMaterialPtr
 
typedef ref_ptr< CustomJointPathHandlerCustomJointPathHandlerPtr
 
typedef ref_ptr< DeviceStateDeviceStatePtr
 
typedef ref_ptr< DeviceDevicePtr
 
typedef ref_ptr< DigitalIoDeviceDigitalIoDevicePtr
 
typedef ref_ptr< DyBodyDyBodyPtr
 
typedef ref_ptr< DyLinkDyLinkPtr
 
typedef ref_ptr< DySubBodyDySubBodyPtr
 
typedef ref_ptr< ExtraBodyStateAccessorExtraBodyStateAccessorPtr
 
typedef ref_ptr< ForceSensorForceSensorPtr
 
typedef ref_ptr< HolderDeviceHolderDevicePtr
 
typedef ref_ptr< DigitalIoConnectionDigitalIoConnectionPtr
 
typedef ref_ptr< IoConnectionMapIoConnectionMapPtr
 
typedef ref_ptr< LeggedBodyHelperLeggedBodyHelperPtr
 
typedef ref_ptr< LightLightPtr
 
typedef ref_ptr< LinkLinkPtr
 
typedef std::shared_ptr< LinkGroupLinkGroupPtr
 
typedef ref_ptr< LinkKinematicsKitLinkKinematicsKitPtr
 
typedef ref_ptr< MarkerDeviceMarkerDevicePtr
 
typedef ref_ptr< MaterialMaterialPtr
 
typedef ref_ptr< MaterialTableMaterialTablePtr
 
typedef ref_ptr< PointLightPointLightPtr
 
typedef ref_ptr< RangeCameraRangeCameraPtr
 
typedef ref_ptr< RangeSensorRangeSensorPtr
 
typedef ref_ptr< RateGyroSensorRateGyroSensorPtr
 
typedef ref_ptr< SceneLinkSceneLinkPtr
 
typedef ref_ptr< SceneBodySceneBodyPtr
 
typedef ref_ptr< SceneCollisionSceneCollisionPtr
 
typedef ref_ptr< SceneDeviceSceneDevicePtr
 
typedef ref_ptr< SpotLightSpotLightPtr
 
typedef ref_ptr< VRMLHumanoidVRMLHumanoidPtr
 
typedef ref_ptr< VRMLJointVRMLJointPtr
 
typedef ref_ptr< VRMLSegmentVRMLSegmentPtr
 
typedef ref_ptr< VRMLSurfaceVRMLSurfacePtr
 
typedef ref_ptr< VRMLVisionSensorVRMLVisionSensorPtr
 
typedef ref_ptr< VRMLForceSensorVRMLForceSensorPtr
 
typedef ref_ptr< VRMLGyroVRMLGyroPtr
 
typedef ref_ptr< VRMLAccelerationSensorVRMLAccelerationSensorPtr
 
typedef ref_ptr< VRMLRangeSensorVRMLRangeSensorPtr
 
typedef ref_ptr< AbstractSeqItemAbstractSeqItemPtr
 
typedef ref_ptr< AbstractMultiSeqItemAbstractMultiSeqItemPtr
 
typedef ref_ptr< AbstractTextItemAbstractTextItemPtr
 
typedef ref_ptr< ArchiveArchivePtr
 
typedef ref_ptr< CoordinateFrameItemCoordinateFrameItemPtr
 
typedef ref_ptr< CoordinateFrameListItemCoordinateFrameListItemPtr
 
typedef ref_ptr< CoordinateFrameMarkerCoordinateFrameMarkerPtr
 
typedef ref_ptr< EditRecordEditRecordPtr
 
typedef ref_ptr< EditRecordGroupEditRecordGroupPtr
 
typedef ref_ptr< ExtCommandItemExtCommandItemPtr
 
typedef ref_ptr< FolderItemFolderItemPtr
 
typedef std::shared_ptr< GraphDataHandlerGraphDataHandlerPtr
 
typedef ref_ptr< InteractiveCameraTransformInteractiveCameraTransformPtr
 
typedef ref_ptr< ItemItemPtr
 
typedef ref_ptr< ItemAddonItemAddonPtr
 
typedef ref_ptr< ItemFileIOItemFileIOPtr
 
typedef ref_ptr< LightingItemLightingItemPtr
 
typedef ref_ptr< LocationProxyLocationProxyPtr
 
typedef ref_ptr< MessageLogItemMessageLogItemPtr
 
typedef ref_ptr< MultiPointSetItemMultiPointSetItemPtr
 
typedef MultiSeqItem< MultiSE3MatrixSeqMultiSE3MatrixSeqItem
 
typedef MultiSE3MatrixSeqItem::Ptr MultiSE3MatrixSeqItemPtr
 
typedef MultiSeqItem< MultiSE3SeqMultiSE3SeqItem
 
typedef MultiSE3SeqItem::Ptr MultiSE3SeqItemPtr
 
typedef MultiSeqItem< MultiValueSeqMultiValueSeqItem
 
typedef MultiValueSeqItem::Ptr MultiValueSeqItemPtr
 
typedef ref_ptr< PointSetItemPointSetItemPtr
 
typedef PolymorphicItemFunctionSet::Dispatcher ItemFunctionDispatcher
 
typedef ref_ptr< PositionDraggerPositionDraggerPtr
 
typedef ref_ptr< PositionTagGroupItemPositionTagGroupItemPtr
 
typedef ref_ptr< RectRegionMarkerRectRegionMarkerPtr
 
typedef ref_ptr< ReferencedObjectSeqItemReferencedObjectSeqItemPtr
 
typedef RenderableItem SceneProvider
 
typedef ref_ptr< RootItemRootItemPtr
 
typedef ref_ptr< SceneItemSceneItemPtr
 
typedef ref_ptr< SceneWidgetRootSceneWidgetRootPtr
 
typedef SceneWidgetEventHandler SceneWidgetEditable
 
typedef ref_ptr< ScriptItemScriptItemPtr
 
typedef ref_ptr< SubProjectItemSubProjectItemPtr
 
typedef ref_ptr< TimeSyncItemEngineTimeSyncItemEnginePtr
 
typedef ref_ptr< Vector3SeqItemVector3SeqItemPtr
 
typedef ref_ptr< AISTSimulatorItemAISTSimulatorItemPtr
 
typedef ref_ptr< BodyContactPointLoggerItemBodyContactPointLoggerItemPtr
 
typedef ref_ptr< BodyElementOverwriteItemBodyElementOverwriteItemPtr
 
typedef ref_ptr< BodyItemBodyItemPtr
 
typedef ref_ptr< BodyKinematicsEditRecordBodyKinematicsEditRecordPtr
 
typedef ref_ptr< BodyMotionControllerItemBodyMotionControllerItemPtr
 
typedef ref_ptr< BodyMotionEngineBodyMotionEnginePtr
 
typedef ref_ptr< BodyMotionItemBodyMotionItemPtr
 
typedef ref_ptr< BodySuperimposerAddonBodySuperimposerAddonPtr
 
typedef ref_ptr< BodyTrackingCameraItemBodyTrackingCameraItemPtr
 
typedef std::vector< CollisionLinkPairPtrCollisionLinkPairList
 
typedef ref_ptr< CollisionSeqEngineCollisionSeqEnginePtr
 
typedef ref_ptr< CollisionSeqItemCollisionSeqItemPtr
 
typedef ref_ptr< ControllerItemControllerItemPtr
 
typedef ref_ptr< ControllerLogItemControllerLogItemPtr
 
typedef ref_ptr< DeviceOverwriteMediatorDeviceOverwriteMediatorPtr
 
typedef ref_ptr< DeviceOverwriteItemDeviceOverwriteItemPtr
 
typedef ref_ptr< EditableSceneLinkEditableSceneLinkPtr
 
typedef ref_ptr< EditableSceneBodyEditableSceneBodyPtr
 
typedef ref_ptr< GLVisionSimulatorItemGLVisionSimulatorItemPtr
 
typedef ref_ptr< IoConnectionMapItemIoConnectionMapItemPtr
 
typedef ref_ptr< KinematicSimulatorItemKinematicSimulatorItemPtr
 
typedef ref_ptr< LinkOffsetFrameListItemLinkOffsetFrameListItemPtr
 
typedef ref_ptr< LinkShapeOverwriteItemLinkShapeOverwriteItemPtr
 
typedef ref_ptr< MultiDeviceStateSeqItemMultiDeviceStateSeqItemPtr
 
typedef ref_ptr< SensorVisualizerItemSensorVisualizerItemPtr
 
typedef ref_ptr< SimpleControllerItemSimpleControllerItemPtr
 
typedef ref_ptr< SimulationScriptItemSimulationScriptItemPtr
 
typedef ref_ptr< SimulationBodySimulationBodyPtr
 
typedef ref_ptr< SimulatorItemSimulatorItemPtr
 
typedef ref_ptr< SubSimulatorItemSubSimulatorItemPtr
 
typedef ref_ptr< WorldItemWorldItemPtr
 
typedef ref_ptr< WorldLogFileItemWorldLogFileItemPtr
 
typedef ref_ptr< ZMPSeqItemZMPSeqItemPtr
 
typedef ref_ptr< MprEmptyStatementMprEmptyStatementPtr
 
typedef ref_ptr< MprDummyStatementMprDummyStatementPtr
 
typedef ref_ptr< MprCommentStatementMprCommentStatementPtr
 
typedef ref_ptr< MprGroupStatementMprGroupStatementPtr
 
typedef ref_ptr< MprConditionStatementMprConditionStatementPtr
 
typedef ref_ptr< MprIfStatementMprIfStatementPtr
 
typedef ref_ptr< MprCallStatementMprCallStatementPtr
 
typedef ref_ptr< MprAssignStatementMprAssignStatementPtr
 
typedef ref_ptr< MprSignalStatementMprSignalStatementPtr
 
typedef ref_ptr< MprWaitStatementMprWaitStatementPtr
 
typedef ref_ptr< MprDelayStatementMprDelayStatementPtr
 
typedef ref_ptr< MprControllerItemBaseMprControllerItemBasePtr
 
typedef ref_ptr< MprControllerLogMprControllerLogPtr
 
typedef ref_ptr< MprMultiVariableListItemMprMultiVariableListItemPtr
 
typedef ref_ptr< MprPositionMprPositionPtr
 
typedef ref_ptr< MprIkPositionMprIkPositionPtr
 
typedef ref_ptr< MprFkPositionMprFkPositionPtr
 
typedef ref_ptr< MprPositionListMprPositionListPtr
 
typedef ref_ptr< MprPositionStatementMprPositionStatementPtr
 
typedef ref_ptr< MprProgramMprProgramPtr
 
typedef ref_ptr< MprProgramItemBaseMprProgramItemBasePtr
 
typedef ref_ptr< MprStatementMprStatementPtr
 
typedef PolymorphicMprStatementFunctionSet::Dispatcher MprStatementFunctionDispatcher
 
typedef ref_ptr< MprStructuredStatementMprStructuredStatementPtr
 
typedef ref_ptr< MprTagTraceStatementMprTagTraceStatementPtr
 
typedef ref_ptr< MprVariableMprVariablePtr
 
typedef ref_ptr< MprVariableListMprVariableListPtr
 
typedef ref_ptr< AudioItemAudioItemPtr
 
typedef ref_ptr< MediaItemMediaItemPtr
 
typedef ref_ptr< PythonScriptItemPythonScriptItemPtr
 
typedef ref_ptr< PythonSimScriptItemPythonSimScriptItemPtr
 

Enumerations

enum  EmptyTokenPolicy { DROP_EMPTY_TOKENS, KEEP_EMPTY_TOKENS }
 
enum  StringStyle {
  PLAIN_STRING, SINGLE_QUOTED, DOUBLE_QUOTED, LITERAL_STRING,
  FOLDED_STRING
}
 
enum  VRMLNodeCategory {
  ANY_NODE = -1, PROTO_DEF_NODE = 0, PROTO_INSTANCE_NODE, TOP_NODE,
  BINDABLE_NODE, GROUPING_NODE, CHILD_NODE, APPEARANCE_NODE,
  MATERIAL_NODE, TEXTURE_NODE, TEXTURE_TRANSFORM_NODE, SHAPE_NODE,
  GEOMETRY_NODE, COORDINATE_NODE, COLOR_NODE, NORMAL_NODE,
  TEXTURE_COORDINATE_NODE, LIGHT_NODE, FONT_STYLE_NODE, SENSOR_NODE,
  INLINE_NODE, NUM_VRML_NODE_CATEGORIES
}
 
enum  VRMLFieldTypeId {
  SFBOOL, SFINT32, SFFLOAT, SFVEC2F,
  SFVEC3F, SFROTATION, SFCOLOR, SFTIME,
  SFSTRING, SFNODE, SFIMAGE, MFINT32,
  MFFLOAT, MFVEC2F, MFVEC3F, MFROTATION,
  MFCOLOR, MFTIME, MFSTRING, MFNODE,
  UNKNOWN_VRML_FIELD_TYPE
}
 
enum  { TOP, MAPPING, LISTING }
 
enum  { IDLE_PRIORITY_HIGH = LazyCaller::PRIORITY_HIGH, IDLE_PRIORITY_NORMAL = LazyCaller::PRIORITY_NORMAL, IDLE_PRIORITY_LOW = LazyCaller::PRIORITY_LOW }
 deprecated More...
 

Functions

CNOID_EXPORT std::ostream & operator<< (std::ostream &os, const BoundingBox &bb)
 
CNOID_EXPORT std::ostream & operator<< (std::ostream &os, const BoundingBoxf &bb)
 
CNOID_EXPORT void setCnoidUtilTextDomainCodeset ()
 
unsigned int getVersion ()
 
unsigned int getInternalVersion ()
 
CNOID_EXPORT EasyScanneroperator>> (EasyScanner &scanner, double &value)
 
CNOID_EXPORT EasyScanneroperator>> (EasyScanner &scanner, int &value)
 
CNOID_EXPORT EasyScanneroperator>> (EasyScanner &scanner, const char *matchString)
 
CNOID_EXPORT EasyScanneroperator>> (EasyScanner &scanner, char matchChar)
 
CNOID_EXPORT EasyScanneroperator>> (EasyScanner &scanner, std::string &str)
 
CNOID_EXPORT EasyScanneroperator>> (EasyScanner &scanner, EasyScanner::Endl endl)
 
template<typename Derived >
void readEx (const Listing *listing, Eigen::MatrixBase< Derived > &x)
 
template<typename Derived >
void readEx (const Listing &listing, Eigen::MatrixBase< Derived > &x)
 
template<typename Derived >
bool read (const Mapping *mapping, const std::string &key, Eigen::MatrixBase< Derived > &x)
 
template<typename Derived >
bool read (const Mapping *mapping, std::initializer_list< const char * > keys, Eigen::MatrixBase< Derived > &x)
 
template<typename Derived >
bool read (const Mapping &mapping, const std::string &key, Eigen::MatrixBase< Derived > &x)
 
template<typename Derived >
bool read (const Mapping &mapping, std::initializer_list< const char * > keys, Eigen::MatrixBase< Derived > &x)
 
template<typename Scalar , int Dim, int Mode>
bool read (const Mapping *mapping, const std::string &key, Eigen::Transform< Scalar, Dim, Mode > &T)
 
template<typename Scalar , int Dim, int Mode>
bool read (const Mapping *mapping, std::initializer_list< const char * > keys, Eigen::Transform< Scalar, Dim, Mode > &T)
 
template<typename Scalar , int Dim, int Mode>
bool read (const Mapping &mapping, const std::string &key, Eigen::Transform< Scalar, Dim, Mode > &T)
 
template<typename Scalar , int Dim, int Mode>
bool read (const Mapping &mapping, std::initializer_list< const char * > keys, Eigen::Transform< Scalar, Dim, Mode > &T)
 
template<typename Derived >
void readEx (const Mapping *mapping, const std::string &key, Eigen::MatrixBase< Derived > &x)
 
template<typename Derived >
void readEx (const Mapping *mapping, std::initializer_list< const char * > keys, Eigen::MatrixBase< Derived > &x)
 
template<typename Derived >
void readEx (const Mapping &mapping, const std::string &key, Eigen::MatrixBase< Derived > &x)
 
template<typename Derived >
Listingwrite (Mapping *mapping, const std::string &key, const Eigen::MatrixBase< Derived > &x)
 
template<typename Derived >
Listingwrite (Mapping &mapping, const std::string &key, const Eigen::MatrixBase< Derived > &x)
 
template<typename Scalar , int Dim, int Mode>
Listingwrite (Mapping *mapping, const std::string &key, const Eigen::Transform< Scalar, Dim, Mode > &T)
 
template<typename Scalar , int Dim, int Mode>
Listingwrite (Mapping &mapping, const std::string &key, const Eigen::Transform< Scalar, Dim, Mode > &T)
 
CNOID_EXPORT bool readAngleAxis (const Mapping *mapping, const std::string &key, Eigen::AngleAxisd &aa)
 
CNOID_EXPORT bool readAngleAxis (const Mapping *mapping, std::initializer_list< const char * > keys, Eigen::AngleAxisd &aa)
 
CNOID_EXPORT bool readAngleAxis (const Mapping &mapping, const std::string &key, Eigen::AngleAxisd &aa)
 
CNOID_EXPORT bool readDegreeAngleAxis (const Mapping &mapping, const std::string &key, Eigen::AngleAxisd &aa)
 
CNOID_EXPORT bool readRadianAngleAxis (const Mapping &mapping, const std::string &key, Eigen::AngleAxisd &aa)
 
CNOID_EXPORT ListingwriteDegreeAngleAxis (Mapping *mapping, const std::string &key, const Eigen::AngleAxisd &aa)
 
CNOID_EXPORT ListingwriteDegreeAngleAxis (Mapping &mapping, const std::string &key, const Eigen::AngleAxisd &aa)
 
CNOID_EXPORT ListingwriteRadianAngleAxis_ (Mapping *mapping, const std::string &key, const Eigen::AngleAxisd &aa)
 
CNOID_EXPORT bool read (const Mapping &mapping, const std::string &key, std::function< void(const Eigen::Vector3d &value)> setterFunc)
 
CNOID_EXPORT ListingwriteAngleAxis (Mapping *mapping, const std::string &key, const Eigen::AngleAxisd &aa)
 
CNOID_EXPORT ListingwriteAngleAxis (Mapping &mapping, const std::string &key, const Eigen::AngleAxisd &aa)
 
CNOID_EXPORT bool read (const Mapping &mapping, const std::string &key, Eigen::AngleAxisd &aa)
 
CNOID_EXPORT Listingwrite (Mapping &mapping, const std::string &key, const Eigen::AngleAxisd &aa)
 
Matrix3 rotFromRpy (double r, double p, double y)
 
Vector3 rpyFromRot (const Matrix3 &R)
 
Vector3 rpyFromRot (const Matrix3 &R, const Vector3 &prev)
 
Vector3 omegaFromRot (const Matrix3 &R)
 
std::string str (const Vector3 &v)
 
std::string str (const Vector3f &v)
 
std::string str (const Vector2 &v)
 
std::string str (const AngleAxis &a)
 
bool toVector3 (const std::string &s, Vector3 &out_v)
 
bool toVector3 (const std::string &s, Vector3f &out_v)
 
bool toVector6 (const std::string &s, Vector6 &out_v)
 
void normalizeRotation (Matrix3 &R)
 
void normalizeRotation (Affine3 &T)
 
void normalizeRotation (Isometry3 &T)
 
Vector3 degree (const Vector3 &v)
 
Vector3 radian (const Vector3 &v)
 
Matrix3 rotFromRpy (const Vector3 &rpy)
 
Matrix3 hat (const Vector3 &x)
 
Isometry3 convertToIsometryWithOrthonormalization (const Affine3 &A)
 
template<class T , typename... Args>
std::shared_ptr< T > make_shared_aligned (Args &&... args)
 
void detectExecutableFile ()
 
const std::string & executableFile ()
 
const std::string & executableBasename ()
 
const std::string & executableDir ()
 
const std::string & executableTopDir ()
 
stdx::filesystem::path executableTopDirPath ()
 
const std::string & pluginDir ()
 
stdx::filesystem::path pluginDirPath ()
 
const std::string & shareDir ()
 
stdx::filesystem::path shareDirPath ()
 
const std::string & executablePath ()
 
const std::string & executableDirectory ()
 
const std::string & executableTopDirectory ()
 
const std::string & pluginDirectory ()
 
const std::string & shareDirectory ()
 
filesystem::path getCompactPath (const filesystem::path &path)
 
void makePathCompact (filesystem::path &io_path)
 
int findSubDirectory (const filesystem::path &directory, const filesystem::path &path, filesystem::path &out_subdirectory)
 
bool findRelativePath (const filesystem::path &from_, const filesystem::path &to, filesystem::path &out_relativePath)
 
std::string getExtension (const stdx::filesystem::path &path)
 
std::string getGenericPathString (const stdx::filesystem::path &path)
 
bool checkAbsolute (const stdx::filesystem::path &path)
 
stdx::filesystem::path getAbsolutePath (const stdx::filesystem::path &path)
 
std::string getAbsolutePathString (const stdx::filesystem::path &path)
 
std::string getFilename (const stdx::filesystem::path &path)
 
std::string getFilename (const std::string &pathString)
 
std::string getBasename (const stdx::filesystem::path &path)
 
std::string getPathString (const stdx::filesystem::path &path)
 
std::string getNativePathString (const stdx::filesystem::path &path)
 
std::string toActualPathName (const std::string &path)
 
CNOID_EXPORT stdx::filesystem::path getCompactPath (const stdx::filesystem::path &path)
 
CNOID_EXPORT void makePathCompact (stdx::filesystem::path &io_path)
 
CNOID_EXPORT int findSubDirectory (const stdx::filesystem::path &directory, const stdx::filesystem::path &path, stdx::filesystem::path &out_subdirectory)
 
CNOID_EXPORT bool findRelativePath (const stdx::filesystem::path &from, const stdx::filesystem::path &to, stdx::filesystem::path &out_relativePath)
 
template<class T >
void setGaussWindow (T sigma, int range, std::vector< T > &out_window)
 
template<class RESULTVECTOR , class SRCVECTOR , class ELEMENT , class T >
void applyGaussianFilter (RESULTVECTOR &result, const SRCVECTOR &src, std::vector< T > &gwin, ELEMENT zero)
 
template<class RESULTVECTOR , class SRCVECTOR , class ELEMENT , class T >
void applyGaussianFilter (RESULTVECTOR &result, const SRCVECTOR &src, T sigma, int range, ELEMENT zero)
 
void bindGettextDomain (const char *domainname)
 
const char * bindtextdomain (const char *domainname, const char *dirname)
 
const char * dgettext (const char *domainname, const char *msgid)
 
const char * getText (const char *domainname, const char *msgid)
 
double degree (double rad)
 
double radian (double deg)
 
float degree (float rad)
 
float radian (float deg)
 
double radian (int deg)
 
template<int precision>
double reducePrecision (double x)
 
std::ostream & nullout ()
 
CNOID_EXPORT void loadPCD (SgPointSet *out_pointSet, const std::string &filename)
 
CNOID_EXPORT void savePCD (SgPointSet *pointSet, const std::string &filename, const Isometry3 &viewpoint=Isometry3::Identity())
 
template<class T , class U >
bool operator== (ref_ptr< T > const &a, ref_ptr< U > const &b)
 
template<class T , class U >
bool operator!= (ref_ptr< T > const &a, ref_ptr< U > const &b)
 
template<class T , class U >
bool operator== (ref_ptr< T > const &a, U *b)
 
template<class T , class U >
bool operator!= (ref_ptr< T > const &a, U *b)
 
template<class T , class U >
bool operator== (T *a, ref_ptr< U > const &b)
 
template<class T , class U >
bool operator!= (T *a, ref_ptr< U > const &b)
 
template<class T >
bool operator< (ref_ptr< T > const &a, ref_ptr< T > const &b)
 
template<class T >
void swap (ref_ptr< T > &lhs, ref_ptr< T > &rhs)
 
template<class T , class U >
ref_ptr< T > static_pointer_cast (ref_ptr< U > const &p)
 
template<class T , class U >
ref_ptr< T > const_pointer_cast (ref_ptr< U > const &p)
 
template<class T , class U >
ref_ptr< T > dynamic_pointer_cast (ref_ptr< U > const &p)
 
template<class Y >
std::ostream & operator<< (std::ostream &os, ref_ptr< Y > const &p)
 
template<class T , class U >
bool operator== (weak_ref_ptr< T > const &a, weak_ref_ptr< U > const &b)
 
template<class T , class U >
bool operator< (weak_ref_ptr< T > const &a, weak_ref_ptr< U > const &b)
 
template<class T >
void swap (weak_ref_ptr< T > &a, weak_ref_ptr< T > &b)
 
CNOID_EXPORT Affine3 calcTotalTransform (const SgNodePath &path)
 
CNOID_EXPORT Affine3 calcTotalTransform (const SgNodePath &path, const SgNode *targetNode)
 
CNOID_EXPORT Affine3 calcTotalTransform (SgNodePath::const_iterator begin, SgNodePath::const_iterator end)
 
CNOID_EXPORT Isometry3 calcRelativePosition (const SgNodePath &path, const SgNode *targetNode)
 
CNOID_EXPORT Isometry3 calcRelativePosition (SgNodePath::const_iterator begin, SgNodePath::const_iterator end)
 
CNOID_EXPORT int makeTransparent (SgNode *topNode, float transparency, CloneMap &cloneMap, bool doKeepOrgTransparency=true)
 
void msleep (int msec)
 
void usleep (int usec)
 
void trim (std::string &s)
 
std::string trimmed (const std::string &s)
 
float strtof (const char *nptr, char **endptr)
 
double strtod (const char *nptr, char **endptr)
 
template<class Type , class Iterator , class TokenizerFunc >
TokenIteratorGenerator< TokenizerFunc, Iterator, Type >::type make_token_iterator (Iterator begin, Iterator end, const TokenizerFunc &fun)
 
const std::string & toUTF8 (const std::string &text)
 
const std::string & fromUTF8 (const std::string &text)
 
const std::string toUTF8 (const char *text)
 
const std::string fromUTF8 (const char *text)
 
template<class Container >
bool writeElements (Mapping &mapping, const std::string &key, const Container &elements, bool isFlowStyle=false)
 
template<class Container >
bool readElements (const Mapping &mapping, const std::string &key, Container &elements)
 
const CNOID_EXPORT char * labelOfVRMLfieldTypeId (const std::type_info &fieldType)
 
template<typename TValue >
const char * labelOfVRMLfieldType ()
 
template<class VRMLNodeType >
ref_ptr< VRMLNodeType > dynamic_node_cast (VRMLNodePtr node)
 
std::ostream & operator<< (std::ostream &out, const SFVec2f &v)
 
std::ostream & operator<< (std::ostream &out, const SFVec3f &v)
 
std::ostream & operator<< (std::ostream &out, const SFColor &v)
 
std::ostream & operator<< (std::ostream &out, const cnoid::SFRotation &v)
 
CNOID_EXPORT int addBodyToCollisionDetector (Body &body, CollisionDetector &detector, bool enableSelfCollisions=true)
 
CNOID_EXPORT int loadDefaultBodyCustomizers (std::ostream &os)
 
CNOID_EXPORT int loadBodyCustomizers (const std::string pathString, std::ostream &os)
 
CNOID_EXPORT BodyCustomizerInterfacefindBodyCustomizer (std::string modelName)
 
BodyMotion::Frame operator<< (BodyMotion::Frame frame, const Body &body)
 
const Bodyoperator>> (const Body &body, BodyMotion::Frame frame)
 
BodyMotion::Frame operator>> (BodyMotion::Frame frame, const Body &body)
 
BodyMotion::ConstFrame operator>> (BodyMotion::ConstFrame frame, Body &body)
 
Bodyoperator<< (Body &body, BodyMotion::Frame frame)
 
Bodyoperator<< (Body &body, BodyMotion::ConstFrame frame)
 
CNOID_EXPORT bool loadHrpsysSeqFileSet (BodyMotion &motion, const std::string &filename, std::ostream &os)
 
CNOID_EXPORT bool saveHrpsysSeqFileSet (BodyMotion &motion, Body *body, const std::string &filename, std::ostream &os)
 
CNOID_EXPORT void calcLinkAccSeq (MultiSE3Seq &linkPosSeq, AccelerationSensor *gsens, int frameBegin, int numFrames, Vector3Seq &out_accSeq)
 
CNOID_EXPORT bool applyVelocityLimitFilter (MultiValueSeq &seq, Body *body, std::ostream &os=nullout())
 
CNOID_EXPORT bool applyVelocityLimitFilter2 (MultiValueSeq &seq, int part, double absLimit)
 
CNOID_EXPORT bool applyVelocityLimitFilterDummy ()
 
CNOID_EXPORT bool applyPollardVelocityLimitFilter (MultiValueSeq &seq, Body *body, double ks, std::ostream &os=nullout())
 
CNOID_EXPORT void applyGaussianFilter (MultiValueSeq &seq, double sigma, int range, std::ostream &os=nullout())
 
CNOID_EXPORT void applyRangeLimitFilter (MultiValueSeq &seq, Body *body, double limitGrad, double edgeGradRatio, double margin, std::ostream &os=nullout())
 
BodyStateoperator<< (BodyState &state, const Body &body)
 
const BodyStateoperator>> (const BodyState &state, Body &body)
 
Bodyoperator<< (Body &body, const BodyState &state)
 
const Bodyoperator>> (const Body &body, BodyState &state)
 
CNOID_EXPORT void setCnoidBodyTextDomainCodeset ()
 
Vector6 calcInverseDynamics (Link *link)
 
void calcCMJacobian (Body *body, Link *base, Eigen::MatrixXd &J)
 compute CoM Jacobian More...
 
void calcAngularMomentumJacobian (Body *body, Link *base, Eigen::MatrixXd &H)
 compute Angular Momentum Jacobian More...
 
template<int elementMask, int rowOffset, int colOffset, bool useTargetLinkLocalPos>
void setJacobian (const JointPath &path, Link *targetLink, const Vector3 &targetLinkLocalPos, MatrixXd &out_J)
 
template<int elementMask, int rowOffset, int colOffset>
void setJacobian (const JointPath &path, Link *targetLink, MatrixXd &out_J)
 
std::shared_ptr< JointPathgetCustomJointPath (Body *body, Link *baseLink, Link *endLink)
 
LeggedBodyHelpergetLeggedBodyHelper (Body *body)
 
void calcMassMatrix (Body *body, const Vector3 &g, Eigen::MatrixXd &out_M, VectorXd &out_b)
 
void calcMassMatrix (Body *body, MatrixXd &out_M)
 
CNOID_EXPORT void calcMassMatrix (Body *body, const Vector3 &g, MatrixXd &out_M, VectorXd &out_b)
 
CNOID_EXPORT std::shared_ptr< MultiDeviceStateSeqgetMultiDeviceStateSeq (const BodyMotion &motion)
 
CNOID_EXPORT std::shared_ptr< MultiDeviceStateSeqgetOrCreateMultiDeviceStateSeq (BodyMotion &motion)
 
CNOID_EXPORT void clearMultiDeviceStateSeq (BodyMotion &motion)
 
CNOID_EXPORT std::shared_ptr< ZMPSeqgetZMPSeq (const BodyMotion &motion)
 
CNOID_EXPORT std::shared_ptr< ZMPSeqgetOrCreateZMPSeq (BodyMotion &motion)
 
CNOID_EXPORT void clearZMPSeq (BodyMotion &motion)
 
CNOID_EXPORT bool makeRootRelative (ZMPSeq &zmpseq, BodyMotion &motion, bool on)
 
CNOID_EXPORT SignalProxy< void()> sigAboutToQuit ()
 
CNOID_EXPORT void updateGui ()
 
CNOID_EXPORT std::ostream & mvout (bool doFlush=true)
 
string getOpenFileName (const string &caption, const string &extensions)
 
vector< string > getOpenFileNames (const string &caption, const string &extensions)
 
CNOID_EXPORT void callLater (const std::function< void()> &function, int priority=LazyCaller::NormalPriority)
 
CNOID_EXPORT void callFromMainThread (const std::function< void()> &function, int priority=LazyCaller::NormalPriority)
 
CNOID_EXPORT bool callSynchronously (const std::function< void()> &function, int priority=LazyCaller::NormalPriority)
 
CNOID_EXPORT bool isRunningInMainThread ()
 
const char * LGPLtext ()
 
const char * MITLicenseText ()
 
CNOID_EXPORT void showMessageBox (const std::string &message)
 
CNOID_EXPORT void showMessageBox (const char *message)
 
CNOID_EXPORT void showMessageBox (const QString &message)
 
CNOID_EXPORT void showWarningDialog (const std::string &message)
 
CNOID_EXPORT void showWarningDialog (const char *message)
 
CNOID_EXPORT void showWarningDialog (const QString &message)
 
CNOID_EXPORT bool showConfirmDialog (const char *caption, const char *message)
 
CNOID_EXPORT bool showConfirmDialog (const std::string &caption, const std::string &message)
 
CNOID_EXPORT bool showConfirmDialog (const QString &caption, const QString &message)
 
template<class ValueType >
ChangeProperty< ValueType > changeProperty (ValueType &variable)
 
TimeSyncItemEnginecreateBodyMotionEngine (BodyMotionItem *motionItem, BodyMotionEngine *engine0)
 
void initializeHrpsysFileIO (ExtensionManager *ext)
 
void initializeSplineFilterDialog (ExtensionManager *ext)
 
CNOID_EXPORT void registerTagTraceStatementTagGroupResolver ()
 
CNOID_EXPORT bool playAudioFile (const std::string &filename, double volumeRatio=-1.0)
 

Variables

const typedef char *(* BodyGetLinkNameFunc )(BodyHandle bodyHandle, int linkIndex)
 
const typedef char **(* BodyCustomizerGetTargetModelNamesFunc )()
 
const char * DLL_PREFIX = "lib"
 
const char * DLL_SUFFIX = ".so"
 
const char * DLL_EXTENSION = "so"
 
const char * EXEC_SUFFIX = ""
 
const char * EXEC_EXTENSION = ""
 
const char * PATH_DELIMITER = ":"
 
constexpr double PI = 3.141592653589793238462643383279502884
 
constexpr double PI_2 = 1.570796326794896619231321691639751442
 
constexpr double TO_DEGREE = 180.0 / PI
 
constexpr double TO_RADIAN = PI / 180.0
 

Detailed Description

Author
Shin'ichiro Nakaoka
Shizuko Hattori
Shin'ichiro Nakaoka
Shin'ichiro Nakaoka
Shin'ichiro NAKAOKA
Shizuko Hattori
Shizuko Hattori
Shin'ichiro Nakaoka

Typedef Documentation

◆ AbstractBodyLoaderPtr

◆ AbstractMultiSeqItemPtr

◆ AbstractSeqItemPtr

◆ AbstractTextItemPtr

◆ AbstractVRMLGroupPtr

◆ AccelerationSensorPtr

◆ Affine3

typedef Eigen::Affine3d cnoid::Affine3

◆ AISTCollisionDetectorPtr

◆ AISTSimulatorItemPtr

◆ AngleAxis

typedef Eigen::AngleAxisd cnoid::AngleAxis

◆ ArchivePtr

◆ AttachmentDevicePtr

◆ AudioItemPtr

◆ BodyContactPointLoggerItemPtr

◆ BodyCustomizerCalcAnalyticIkFunc

typedef bool(* cnoid::BodyCustomizerCalcAnalyticIkFunc) (BodyCustomizerHandle customizerHandle, int ikPathId, const Vector3 &p, const Matrix3 &R)

◆ BodyCustomizerCreateFunc

typedef BodyCustomizerHandle(* cnoid::BodyCustomizerCreateFunc) (BodyHandle bodyHandle, const char *modelName)

◆ BodyCustomizerDestroyFunc

typedef void(* cnoid::BodyCustomizerDestroyFunc) (BodyCustomizerHandle customizerHandle)

◆ BodyCustomizerHandle

◆ BodyCustomizerInitializeAnalyticIkFunc

typedef int(* cnoid::BodyCustomizerInitializeAnalyticIkFunc) (BodyCustomizerHandle customizerHandle, int baseLinkIndex, int targetLinkIndex)

◆ BodyCustomizerSetVirtualJointForces2Func

typedef void(* cnoid::BodyCustomizerSetVirtualJointForces2Func) (BodyCustomizerHandle customizerHandle, double timeStep)

◆ BodyCustomizerSetVirtualJointForcesFunc

typedef void(* cnoid::BodyCustomizerSetVirtualJointForcesFunc) (BodyCustomizerHandle customizerHandle)

◆ BodyElementOverwriteItemPtr

◆ BodyGetLinkDoubleValuePtrFunc

typedef double*(* cnoid::BodyGetLinkDoubleValuePtrFunc) (BodyHandle bodyHandle, int linkIndex)

◆ BodyGetLinkIndexFromNameFunc

typedef int(* cnoid::BodyGetLinkIndexFromNameFunc) (BodyHandle bodyHandle, const char *linkName)

◆ BodyHandle

typedef void* cnoid::BodyHandle

◆ BodyHandlerPtr

◆ BodyItemPtr

◆ BodyKinematicsEditRecordPtr

◆ BodyMotionControllerItemPtr

◆ BodyMotionEnginePtr

◆ BodyMotionItemPtr

◆ BodyPtr

◆ BodySuperimposerAddonPtr

◆ BodyTrackingCameraItemPtr

◆ BoundingBoxMarkerPtr

◆ CameraPtr

◆ ColdetModelPairPtr

◆ ColdetModelPtr

◆ CollisionArray

typedef std::vector<Collision> cnoid::CollisionArray

◆ CollisionDetectorPtr

◆ CollisionLinkPairList

◆ CollisionLinkPairPtr

◆ CollisionList

typedef std::vector<Collision> cnoid::CollisionList

obsolete

◆ CollisionSeqEnginePtr

◆ CollisionSeqItemPtr

◆ ContactMaterialPtr

◆ ControllerItemPtr

◆ ControllerLogItemPtr

◆ CoordinateFrameItemPtr

◆ CoordinateFrameListItemPtr

◆ CoordinateFrameListPtr

◆ CoordinateFrameMarkerPtr

◆ CoordinateFramePtr

◆ CrossMarkerPtr

◆ CustomJointPathHandlerPtr

◆ DeviceOverwriteItemPtr

◆ DeviceOverwriteMediatorPtr

◆ DevicePtr

◆ DeviceStatePtr

◆ DigitalIoConnectionPtr

◆ DigitalIoDevicePtr

◆ DyBodyPtr

◆ DyLinkPtr

◆ DySubBodyPtr

◆ EditableSceneBodyPtr

◆ EditableSceneLinkPtr

◆ EditRecordGroupPtr

◆ EditRecordPtr

◆ error_info_key

typedef boost::error_info<struct tag_error_info_key, std::string> cnoid::error_info_key

◆ error_info_message

typedef boost::error_info<struct tag_error_info_message, std::string> cnoid::error_info_message

◆ ExtCommandItemPtr

◆ ExtraBodyStateAccessorPtr

◆ FilePathVariableProcessorPtr

◆ FolderItemPtr

◆ ForceSensorPtr

◆ GetBodyCustomizerInterfaceFunc

typedef BodyCustomizerInterface*(* cnoid::GetBodyCustomizerInterfaceFunc) (BodyInterface *bodyInterface)

◆ GLVisionSimulatorItemPtr

◆ GraphDataHandlerPtr

typedef std::shared_ptr<GraphDataHandler> cnoid::GraphDataHandlerPtr

◆ HolderDevicePtr

◆ InteractiveCameraTransformPtr

◆ IoConnectionMapItemPtr

◆ IoConnectionMapPtr

◆ Isometry3

typedef Eigen::Isometry3d cnoid::Isometry3

◆ ItemAddonPtr

◆ ItemFileIOPtr

◆ ItemFunctionDispatcher

typedef PolymorphicItemFunctionSet::Dispatcher cnoid::ItemFunctionDispatcher

◆ ItemPtr

◆ KinematicSimulatorItemPtr

◆ LeggedBodyHelperPtr

◆ LightingItemPtr

◆ LightPtr

◆ LinkGroupPtr

typedef std::shared_ptr<LinkGroup> cnoid::LinkGroupPtr

◆ LinkKinematicsKitPtr

◆ LinkOffsetFrameListItemPtr

◆ LinkPtr

◆ LinkShapeOverwriteItemPtr

◆ ListingPtr

◆ LocationProxyPtr

◆ MappingPtr

◆ MarkerDevicePtr

◆ MaterialPtr

◆ MaterialTablePtr

◆ Matrix2

typedef Eigen::Matrix2d cnoid::Matrix2

◆ Matrix3

typedef Eigen::Matrix3d cnoid::Matrix3

◆ Matrix4

typedef Eigen::Matrix4d cnoid::Matrix4

◆ MediaItemPtr

◆ MeshNormalGenerator

◆ MessageLogItemPtr

◆ MFColor

typedef std::vector<SFColor> cnoid::MFColor

◆ MFFloat

typedef std::vector<SFFloat> cnoid::MFFloat

◆ MFInt32

typedef std::vector<SFInt32> cnoid::MFInt32

◆ MFNode

typedef std::vector<SFNode> cnoid::MFNode

◆ MFRotation

typedef std::vector<SFRotation, Eigen::aligned_allocator<SFRotation> > cnoid::MFRotation

◆ MFString

typedef std::vector<SFString> cnoid::MFString

◆ MFTime

typedef std::vector<SFTime> cnoid::MFTime

◆ MFVec2f

typedef std::vector<SFVec2f, Eigen::aligned_allocator<SFVec2f> > cnoid::MFVec2f

◆ MFVec2s

typedef std::vector<SFVec2s> cnoid::MFVec2s

◆ MFVec3f

typedef std::vector<SFVec3f> cnoid::MFVec3f

◆ MFVec3s

typedef std::vector<SFVec3s> cnoid::MFVec3s

◆ MprAssignStatementPtr

◆ MprCallStatementPtr

◆ MprCommentStatementPtr

◆ MprConditionStatementPtr

◆ MprControllerItemBasePtr

◆ MprControllerLogPtr

◆ MprDelayStatementPtr

◆ MprDummyStatementPtr

◆ MprEmptyStatementPtr

◆ MprFkPositionPtr

◆ MprGroupStatementPtr

◆ MprIfStatementPtr

◆ MprIkPositionPtr

◆ MprMultiVariableListItemPtr

◆ MprPositionListPtr

◆ MprPositionPtr

◆ MprPositionStatementPtr

◆ MprProgramItemBasePtr

◆ MprProgramPtr

◆ MprSignalStatementPtr

◆ MprStatementFunctionDispatcher

typedef PolymorphicMprStatementFunctionSet::Dispatcher cnoid::MprStatementFunctionDispatcher

◆ MprStatementPtr

◆ MprStructuredStatementPtr

◆ MprTagTraceStatementPtr

◆ MprVariableListPtr

◆ MprVariablePtr

◆ MprWaitStatementPtr

◆ MultiDeviceStateSeqItemPtr

◆ MultiPointSetItemPtr

◆ MultiSE3MatrixSeqItem

◆ MultiSE3MatrixSeqItemPtr

◆ MultiSE3SeqItem

◆ MultiSE3SeqItemPtr

◆ MultiValueSeqItem

◆ MultiValueSeqItemPtr

◆ PointLightPtr

◆ PointSetItemPtr

◆ Position

◆ PositionDraggerPtr

◆ PositionTagGroupItemPtr

◆ PositionTagGroupPtr

◆ PositionTagPtr

◆ PythonScriptItemPtr

◆ PythonSimScriptItemPtr

◆ Quat

typedef Eigen::Quaterniond cnoid::Quat

◆ Quaternion

typedef Eigen::Quaterniond cnoid::Quaternion

◆ RangeCameraPtr

◆ RangeSensorPtr

◆ RateGyroSensorPtr

◆ RectRegionMarkerPtr

◆ ReferencedObjectSeqItemPtr

◆ ReferencedPtr

◆ RootItemPtr

◆ ScalarNodePtr

◆ SceneBodyPtr

◆ SceneCollisionPtr

◆ SceneDevicePtr

◆ SceneItemPtr

◆ SceneLinkPtr

◆ SceneMarkerPtr

◆ SceneProvider

◆ SceneWidgetEditable

◆ SceneWidgetRootPtr

◆ ScriptItemPtr

◆ SensorVisualizerItemPtr

◆ SFBool

typedef bool cnoid::SFBool

◆ SFColor

typedef Eigen::Vector3f cnoid::SFColor

◆ SFFloat

typedef double cnoid::SFFloat

◆ SFInt32

typedef int cnoid::SFInt32

◆ SFNode

◆ SFRotation

typedef Eigen::AngleAxisd cnoid::SFRotation

◆ SFString

typedef std::string cnoid::SFString

◆ SFVec2f

typedef Eigen::Vector2d cnoid::SFVec2f

◆ SFVec2s

typedef Eigen::Vector2f cnoid::SFVec2s

◆ SFVec3f

typedef Eigen::Vector3d cnoid::SFVec3f

◆ SFVec3s

typedef Eigen::Vector3f cnoid::SFVec3s

◆ SgAffineTransformPtr

◆ SgBoundingBoxPtr

◆ SgCameraPtr

◆ SgColorArray

◆ SgColorArrayPtr

◆ SgDirectionalLightPtr

◆ SgFixedPixelSizeGroupPtr

◆ SgFogPtr

◆ SgGroupPtr

◆ SgHighlightPtr

◆ SgImagePtr

◆ SgIndexArray

typedef std::vector<int> cnoid::SgIndexArray

◆ SgInvariantGroupPtr

◆ SgLightPtr

◆ SgLightweightRenderingGroupPtr

◆ SgLineSetPtr

◆ SgMaterialPtr

◆ SgMeshBasePtr

◆ SgMeshPtr

◆ SgNodePath

typedef std::vector<SgNode*> cnoid::SgNodePath

◆ SgNodePtr

◆ SgNormalArray

◆ SgNormalArrayPtr

◆ SgObjectPtr

◆ SgOrthographicCameraPtr

◆ SgOutlinePtr

◆ SgOverlayPtr

◆ SgPerspectiveCameraPtr

◆ SgPlotPtr

◆ SgPointLightPtr

◆ SgPointSetPtr

◆ SgPolygonDrawStylePtr

◆ SgPolygonMeshPtr

◆ SgPosTransformPtr

◆ SgPreprocessedPtr

◆ SgScaleTransformPtr

◆ SgShapePtr

◆ SgSpotLightPtr

◆ SgSwitchableGroupPtr

◆ SgSwitchPtr

◆ SgTexCoordArray

typedef SgVectorArray<Vector2f, Eigen::aligned_allocator<Vector2f> > cnoid::SgTexCoordArray

◆ SgTexCoordArrayPtr

◆ SgTexturePtr

◆ SgTextureTransformPtr

◆ SgTransformPtr

◆ SgTransparentGroupPtr

◆ SgUnpickableGroupPtr

◆ SgVertexArray

◆ SgVertexArrayPtr

◆ SgViewportOverlayPtr

◆ SharedJoystickPtr

◆ SimpleControllerItemPtr

◆ SimulationBodyPtr

◆ SimulationScriptItemPtr

◆ SimulatorItemPtr

◆ SphereMarkerPtr

◆ SpotLightPtr

◆ SubProjectItemPtr

◆ SubSimulatorItemPtr

◆ TaskCommandPtr

◆ TaskFunc

typedef std::function<void(TaskProc* proc)> cnoid::TaskFunc

◆ TaskPhaseProxyPtr

◆ TaskPhasePtr

◆ TaskPtr

◆ TaskToggleStatePtr

◆ TimeSyncItemEnginePtr

◆ Translation3

typedef Eigen::Translation3d cnoid::Translation3

◆ ValueNodePtr

◆ Vector2

typedef Eigen::Vector2d cnoid::Vector2

◆ Vector3

typedef Eigen::Vector3d cnoid::Vector3

◆ Vector3SeqItemPtr

◆ Vector4

typedef Eigen::Vector4d cnoid::Vector4

◆ Vector6

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

◆ VectorX

typedef Eigen::VectorXd cnoid::VectorX

◆ VRMLAccelerationSensorPtr

◆ VRMLAnchorPtr

◆ VRMLAppearancePtr

◆ VRMLBackgroundPtr

◆ VRMLBillboardPtr

◆ VRMLBoxPtr

◆ VRMLCollisionPtr

◆ VRMLColorPtr

◆ VRMLConePtr

◆ VRMLCoordinatePtr

◆ VRMLCylinderPtr

◆ VRMLCylinderSensorPtr

◆ VRMLDirectionalLightPtr

◆ VRMLElevationGridPtr

◆ VRMLExtrusionPtr

◆ VRMLFogPtr

◆ VRMLFontStylePtr

◆ VRMLForceSensorPtr

◆ VRMLGeometryPtr

◆ VRMLGroupPtr

◆ VRMLGyroPtr

◆ VRMLHumanoidPtr

◆ VRMLImageTexturePtr

◆ VRMLIndexedFaceSetPtr

◆ VRMLIndexedLineSetPtr

◆ VRMLInlinePtr

◆ VRMLJointPtr

◆ VRMLLightPtr

◆ VRMLLODPtr

◆ VRMLMaterialPtr

◆ VRMLMovieTexturePtr

◆ VRMLNavigationInfoPtr

◆ VRMLNodePtr

◆ VRMLNonVrmlInlinePtr

◆ VRMLNormalPtr

◆ VRMLPixelTexturePtr

◆ VRMLPointLightPtr

◆ VRMLPointSetPtr

◆ VRMLProtoFieldMap

typedef std::map<std::string, VRMLVariantField> cnoid::VRMLProtoFieldMap

◆ VRMLProtoFieldPair

typedef std::pair<std::string, VRMLVariantField> cnoid::VRMLProtoFieldPair

◆ VRMLProtoInstancePtr

◆ VRMLProtoPtr

◆ VRMLRangeSensorPtr

◆ VRMLSegmentPtr

◆ VRMLShapePtr

◆ VRMLSpherePtr

◆ VRMLSpotLightPtr

◆ VRMLSurfacePtr

◆ VRMLSwitchPtr

◆ VRMLTextPtr

◆ VRMLTextureCoordinatePtr

◆ VRMLTexturePtr

◆ VRMLTextureTransformPtr

◆ VRMLTransformPtr

◆ VRMLUnsupportedNodePtr

◆ VRMLVariantField

◆ VRMLViewpointPtr

◆ VRMLVisionSensorPtr

◆ VRMLWorldInfoPtr

◆ WorldItemPtr

◆ WorldLogFileItemPtr

◆ ZMPSeqItemPtr

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

deprecated

Enumerator
IDLE_PRIORITY_HIGH 
IDLE_PRIORITY_NORMAL 
IDLE_PRIORITY_LOW 

◆ anonymous enum

anonymous enum
Enumerator
TOP 
MAPPING 
LISTING 

◆ EmptyTokenPolicy

Enumerator
DROP_EMPTY_TOKENS 
KEEP_EMPTY_TOKENS 

◆ StringStyle

Enumerator
PLAIN_STRING 
SINGLE_QUOTED 
DOUBLE_QUOTED 
LITERAL_STRING 
FOLDED_STRING 

◆ VRMLFieldTypeId

Enumerator
SFBOOL 
SFINT32 
SFFLOAT 
SFVEC2F 
SFVEC3F 
SFROTATION 
SFCOLOR 
SFTIME 
SFSTRING 
SFNODE 
SFIMAGE 
MFINT32 
MFFLOAT 
MFVEC2F 
MFVEC3F 
MFROTATION 
MFCOLOR 
MFTIME 
MFSTRING 
MFNODE 
UNKNOWN_VRML_FIELD_TYPE 

◆ VRMLNodeCategory

Enumerator
ANY_NODE 
PROTO_DEF_NODE 
PROTO_INSTANCE_NODE 
TOP_NODE 
BINDABLE_NODE 
GROUPING_NODE 
CHILD_NODE 
APPEARANCE_NODE 
MATERIAL_NODE 
TEXTURE_NODE 
TEXTURE_TRANSFORM_NODE 
SHAPE_NODE 
GEOMETRY_NODE 
COORDINATE_NODE 
COLOR_NODE 
NORMAL_NODE 
TEXTURE_COORDINATE_NODE 
LIGHT_NODE 
FONT_STYLE_NODE 
SENSOR_NODE 
INLINE_NODE 
NUM_VRML_NODE_CATEGORIES 

Function Documentation

◆ addBodyToCollisionDetector()

int cnoid::addBodyToCollisionDetector ( Body body,
CollisionDetector detector,
bool  enableSelfCollisions = true 
)
Returns
top of the geometry indices assigned to the body. The geometry id corresponding to a link is [the top index] + [link->index()].

◆ applyGaussianFilter() [1/3]

void cnoid::applyGaussianFilter ( MultiValueSeq seq,
double  sigma,
int  range,
std::ostream &  os = nullout() 
)

◆ applyGaussianFilter() [2/3]

template<class RESULTVECTOR , class SRCVECTOR , class ELEMENT , class T >
void cnoid::applyGaussianFilter ( RESULTVECTOR &  result,
const SRCVECTOR &  src,
std::vector< T > &  gwin,
ELEMENT  zero 
)

◆ applyGaussianFilter() [3/3]

template<class RESULTVECTOR , class SRCVECTOR , class ELEMENT , class T >
void cnoid::applyGaussianFilter ( RESULTVECTOR &  result,
const SRCVECTOR &  src,
sigma,
int  range,
ELEMENT  zero 
)

◆ applyPollardVelocityLimitFilter()

bool cnoid::applyPollardVelocityLimitFilter ( MultiValueSeq seq,
Body body,
double  ks,
std::ostream &  os = nullout() 
)

◆ applyRangeLimitFilter()

void cnoid::applyRangeLimitFilter ( MultiValueSeq seq,
Body body,
double  limitGrad,
double  edgeGradRatio,
double  margin,
std::ostream &  os = nullout() 
)

◆ applyVelocityLimitFilter()

bool cnoid::applyVelocityLimitFilter ( MultiValueSeq seq,
Body body,
std::ostream &  os = nullout() 
)

◆ applyVelocityLimitFilter2()

bool cnoid::applyVelocityLimitFilter2 ( MultiValueSeq seq,
int  part,
double  absLimit 
)

◆ applyVelocityLimitFilterDummy()

bool cnoid::applyVelocityLimitFilterDummy ( )

◆ bindGettextDomain()

CNOID_EXPORT void cnoid::bindGettextDomain ( const char *  domainname)

◆ bindtextdomain()

const char* cnoid::bindtextdomain ( const char *  domainname,
const char *  dirname 
)
inline

◆ calcAngularMomentumJacobian()

CNOID_EXPORT void cnoid::calcAngularMomentumJacobian ( Body body,
Link base,
Eigen::MatrixXd &  H 
)

compute Angular Momentum Jacobian

Parameters
baselink fixed to the environment
HAngular Momentum Jacobian
Note
Link::wc must be computed by calcCM() before calling

◆ calcCMJacobian()

CNOID_EXPORT void cnoid::calcCMJacobian ( Body body,
Link base,
Eigen::MatrixXd &  J 
)

compute CoM Jacobian

Parameters
baselink fixed to the environment
JCoM Jacobian
Note
Link::wc must be computed by calcCM() before calling

◆ calcInverseDynamics()

CNOID_EXPORT Vector6 cnoid::calcInverseDynamics ( Link link)
Returns
force being applied to the root link

◆ calcLinkAccSeq()

void cnoid::calcLinkAccSeq ( MultiSE3Seq linkPosSeq,
AccelerationSensor gsens,
int  frameBegin,
int  numFrames,
Vector3Seq out_accSeq 
)

◆ calcMassMatrix() [1/3]

void cnoid::calcMassMatrix ( Body body,
const Vector3 g,
Eigen::MatrixXd &  out_M,
VectorXd &  out_b 
)

calculate the mass matrix using the unit vector method

The motion equation (dv != dvo) | | | dv | | | | fext | | out_M | * | dw | + | b | = | tauext | | | | ddq | | | | u |

◆ calcMassMatrix() [2/3]

CNOID_EXPORT void cnoid::calcMassMatrix ( Body body,
const Vector3 g,
MatrixXd &  out_M,
VectorXd &  out_b 
)

◆ calcMassMatrix() [3/3]

CNOID_EXPORT void cnoid::calcMassMatrix ( Body body,
MatrixXd &  out_M 
)

◆ calcRelativePosition() [1/2]

Isometry3 cnoid::calcRelativePosition ( const SgNodePath path,
const SgNode targetNode 
)

◆ calcRelativePosition() [2/2]

Isometry3 cnoid::calcRelativePosition ( SgNodePath::const_iterator  begin,
SgNodePath::const_iterator  end 
)

◆ calcTotalTransform() [1/3]

Affine3 cnoid::calcTotalTransform ( const SgNodePath path)

◆ calcTotalTransform() [2/3]

Affine3 cnoid::calcTotalTransform ( const SgNodePath path,
const SgNode targetNode 
)

◆ calcTotalTransform() [3/3]

Affine3 cnoid::calcTotalTransform ( SgNodePath::const_iterator  begin,
SgNodePath::const_iterator  end 
)

◆ callFromMainThread()

CNOID_EXPORT void cnoid::callFromMainThread ( const std::function< void()> &  function,
int  priority = LazyCaller::NormalPriority 
)

◆ callLater()

CNOID_EXPORT void cnoid::callLater ( const std::function< void()> &  function,
int  priority = LazyCaller::NormalPriority 
)

◆ callSynchronously()

CNOID_EXPORT bool cnoid::callSynchronously ( const std::function< void()> &  function,
int  priority = LazyCaller::NormalPriority 
)

◆ changeProperty()

template<class ValueType >
ChangeProperty<ValueType> cnoid::changeProperty ( ValueType &  variable)

◆ checkAbsolute()

CNOID_EXPORT bool cnoid::checkAbsolute ( const stdx::filesystem::path &  path)

◆ clearMultiDeviceStateSeq()

void cnoid::clearMultiDeviceStateSeq ( BodyMotion motion)

◆ clearZMPSeq()

void cnoid::clearZMPSeq ( BodyMotion motion)

◆ const_pointer_cast()

template<class T , class U >
ref_ptr<T> cnoid::const_pointer_cast ( ref_ptr< U > const &  p)

◆ convertToIsometryWithOrthonormalization()

Isometry3 cnoid::convertToIsometryWithOrthonormalization ( const Affine3 A)
inline

◆ createBodyMotionEngine()

TimeSyncItemEngine* cnoid::createBodyMotionEngine ( BodyMotionItem motionItem,
BodyMotionEngine engine0 
)

◆ degree() [1/3]

Vector3 cnoid::degree ( const Vector3 v)
inline

◆ degree() [2/3]

double cnoid::degree ( double  rad)
inline

◆ degree() [3/3]

float cnoid::degree ( float  rad)
inline

◆ detectExecutableFile()

void cnoid::detectExecutableFile ( )

◆ dgettext()

const char* cnoid::dgettext ( const char *  domainname,
const char *  msgid 
)
inline

◆ dynamic_node_cast()

template<class VRMLNodeType >
ref_ptr<VRMLNodeType> cnoid::dynamic_node_cast ( VRMLNodePtr  node)
inline

The upper cast operation that supports the situation where the original pointer is VRMLProtoInstance and you want to get the actual node, the node replaced with the pre-defined node type written in the PROTO definition.

◆ dynamic_pointer_cast()

template<class T , class U >
ref_ptr<T> cnoid::dynamic_pointer_cast ( ref_ptr< U > const &  p)

◆ executableBasename()

const CNOID_EXPORT std::string & cnoid::executableBasename ( )

◆ executableDir()

const CNOID_EXPORT std::string & cnoid::executableDir ( )

◆ executableDirectory()

const std::string& cnoid::executableDirectory ( )
inline

◆ executableFile()

const CNOID_EXPORT std::string & cnoid::executableFile ( )

◆ executablePath()

const std::string& cnoid::executablePath ( )
inline

◆ executableTopDir()

const CNOID_EXPORT std::string & cnoid::executableTopDir ( )

◆ executableTopDirectory()

const std::string& cnoid::executableTopDirectory ( )
inline

◆ executableTopDirPath()

CNOID_EXPORT stdx::filesystem::path cnoid::executableTopDirPath ( )

◆ findBodyCustomizer()

BodyCustomizerInterface * cnoid::findBodyCustomizer ( std::string  modelName)

◆ findRelativePath() [1/2]

bool cnoid::findRelativePath ( const filesystem::path &  from_,
const filesystem::path &  to,
filesystem::path &  out_relativePath 
)

◆ findRelativePath() [2/2]

CNOID_EXPORT bool cnoid::findRelativePath ( const stdx::filesystem::path &  from,
const stdx::filesystem::path &  to,
stdx::filesystem::path &  out_relativePath 
)

◆ findSubDirectory() [1/2]

int cnoid::findSubDirectory ( const filesystem::path &  directory,
const filesystem::path &  path,
filesystem::path &  out_subdirectory 
)

◆ findSubDirectory() [2/2]

CNOID_EXPORT int cnoid::findSubDirectory ( const stdx::filesystem::path &  directory,
const stdx::filesystem::path &  path,
stdx::filesystem::path &  out_subdirectory 
)

◆ fromUTF8() [1/2]

const std::string cnoid::fromUTF8 ( const char *  text)
inline

◆ fromUTF8() [2/2]

const std::string& cnoid::fromUTF8 ( const std::string &  text)
inline

◆ getAbsolutePath()

CNOID_EXPORT stdx::filesystem::path cnoid::getAbsolutePath ( const stdx::filesystem::path &  path)

◆ getAbsolutePathString()

CNOID_EXPORT std::string cnoid::getAbsolutePathString ( const stdx::filesystem::path &  path)

◆ getBasename()

CNOID_EXPORT std::string cnoid::getBasename ( const stdx::filesystem::path &  path)

◆ getCompactPath() [1/2]

filesystem::path cnoid::getCompactPath ( const filesystem::path &  path)

◆ getCompactPath() [2/2]

CNOID_EXPORT stdx::filesystem::path cnoid::getCompactPath ( const stdx::filesystem::path &  path)

◆ getCustomJointPath()

std::shared_ptr<JointPath> cnoid::getCustomJointPath ( Body body,
Link baseLink,
Link endLink 
)
inline

◆ getExtension()

CNOID_EXPORT std::string cnoid::getExtension ( const stdx::filesystem::path &  path)

This function returs the extension without dot.

◆ getFilename() [1/2]

CNOID_EXPORT std::string cnoid::getFilename ( const std::string &  pathString)

◆ getFilename() [2/2]

CNOID_EXPORT std::string cnoid::getFilename ( const stdx::filesystem::path &  path)

◆ getGenericPathString()

CNOID_EXPORT std::string cnoid::getGenericPathString ( const stdx::filesystem::path &  path)

◆ getInternalVersion()

unsigned int cnoid::getInternalVersion ( )

◆ getLeggedBodyHelper()

CNOID_EXPORT LeggedBodyHelper * cnoid::getLeggedBodyHelper ( Body body)

◆ getMultiDeviceStateSeq()

std::shared_ptr< MultiDeviceStateSeq > cnoid::getMultiDeviceStateSeq ( const BodyMotion motion)

◆ getNativePathString()

CNOID_EXPORT std::string cnoid::getNativePathString ( const stdx::filesystem::path &  path)

◆ getOpenFileName()

CNOID_EXPORT std::string cnoid::getOpenFileName ( const string &  caption,
const string &  extensions 
)

◆ getOpenFileNames()

CNOID_EXPORT std::vector< std::string > cnoid::getOpenFileNames ( const string &  caption,
const string &  extensions 
)

◆ getOrCreateMultiDeviceStateSeq()

std::shared_ptr< MultiDeviceStateSeq > cnoid::getOrCreateMultiDeviceStateSeq ( BodyMotion motion)

◆ getOrCreateZMPSeq()

std::shared_ptr< ZMPSeq > cnoid::getOrCreateZMPSeq ( BodyMotion motion)

◆ getPathString()

CNOID_EXPORT std::string cnoid::getPathString ( const stdx::filesystem::path &  path)

◆ getText()

const char* cnoid::getText ( const char *  domainname,
const char *  msgid 
)
inline

◆ getVersion()

unsigned int cnoid::getVersion ( )

◆ getZMPSeq()

std::shared_ptr< ZMPSeq > cnoid::getZMPSeq ( const BodyMotion motion)

◆ hat()

Matrix3 cnoid::hat ( const Vector3 x)
inline

◆ initializeHrpsysFileIO()

void cnoid::initializeHrpsysFileIO ( ExtensionManager ext)

◆ initializeSplineFilterDialog()

void cnoid::initializeSplineFilterDialog ( ExtensionManager ext)

◆ isRunningInMainThread()

bool cnoid::isRunningInMainThread ( )

◆ labelOfVRMLfieldType()

template<typename TValue >
const char* cnoid::labelOfVRMLfieldType ( )
inline

◆ labelOfVRMLfieldTypeId()

const char * cnoid::labelOfVRMLfieldTypeId ( const std::type_info &  fieldType)

◆ LGPLtext()

const char * cnoid::LGPLtext ( )

◆ loadBodyCustomizers()

int cnoid::loadBodyCustomizers ( const std::string  pathString,
std::ostream &  os 
)

DLLs of body customizer in the path are loaded and they are registered to the customizer repository.

The loaded customizers can be obtained by using findBodyCustomizer() function.

Parameters
pathStringthe path to a DLL file or a directory that contains DLLs

◆ loadDefaultBodyCustomizers()

int cnoid::loadDefaultBodyCustomizers ( std::ostream &  os)

The function loads the customizers in the directories specified by the environmental variable CNOID_CUSTOMIZER_PATH

◆ loadHrpsysSeqFileSet()

bool cnoid::loadHrpsysSeqFileSet ( BodyMotion motion,
const std::string &  filename,
std::ostream &  os 
)

◆ loadPCD()

void cnoid::loadPCD ( SgPointSet out_pointSet,
const std::string &  filename 
)

◆ make_shared_aligned()

template<class T , typename... Args>
std::shared_ptr<T> cnoid::make_shared_aligned ( Args &&...  args)

◆ make_token_iterator()

template<class Type , class Iterator , class TokenizerFunc >
TokenIteratorGenerator<TokenizerFunc,Iterator,Type>::type cnoid::make_token_iterator ( Iterator  begin,
Iterator  end,
const TokenizerFunc &  fun 
)

◆ makePathCompact() [1/2]

void cnoid::makePathCompact ( filesystem::path &  io_path)

◆ makePathCompact() [2/2]

CNOID_EXPORT void cnoid::makePathCompact ( stdx::filesystem::path &  io_path)

◆ makeRootRelative()

bool cnoid::makeRootRelative ( ZMPSeq zmpseq,
BodyMotion motion,
bool  on 
)

◆ makeTransparent()

int cnoid::makeTransparent ( SgNode topNode,
float  transparency,
CloneMap cloneMap,
bool  doKeepOrgTransparency = true 
)

◆ MITLicenseText()

const char * cnoid::MITLicenseText ( )

◆ msleep()

void cnoid::msleep ( int  msec)
inline

◆ mvout()

CNOID_EXPORT std::ostream & cnoid::mvout ( bool  doFlush = true)

◆ normalizeRotation() [1/3]

CNOID_EXPORT void cnoid::normalizeRotation ( Affine3 T)

◆ normalizeRotation() [2/3]

CNOID_EXPORT void cnoid::normalizeRotation ( Isometry3 T)

◆ normalizeRotation() [3/3]

CNOID_EXPORT void cnoid::normalizeRotation ( Matrix3 R)

◆ nullout()

CNOID_EXPORT std::ostream & cnoid::nullout ( )

◆ omegaFromRot()

CNOID_EXPORT Vector3 cnoid::omegaFromRot ( const Matrix3 R)

◆ operator!=() [1/3]

template<class T , class U >
bool cnoid::operator!= ( ref_ptr< T > const &  a,
ref_ptr< U > const &  b 
)
inline

◆ operator!=() [2/3]

template<class T , class U >
bool cnoid::operator!= ( ref_ptr< T > const &  a,
U *  b 
)
inline

◆ operator!=() [3/3]

template<class T , class U >
bool cnoid::operator!= ( T *  a,
ref_ptr< U > const &  b 
)
inline

◆ operator<() [1/2]

template<class T >
bool cnoid::operator< ( ref_ptr< T > const &  a,
ref_ptr< T > const &  b 
)
inline

◆ operator<() [2/2]

template<class T , class U >
bool cnoid::operator< ( weak_ref_ptr< T > const &  a,
weak_ref_ptr< U > const &  b 
)
inline

◆ operator<<() [1/12]

CNOID_EXPORT Body & cnoid::operator<< ( Body body,
BodyMotion::ConstFrame  frame 
)

◆ operator<<() [2/12]

CNOID_EXPORT Body & cnoid::operator<< ( Body body,
BodyMotion::Frame  frame 
)

◆ operator<<() [3/12]

CNOID_EXPORT Body & cnoid::operator<< ( Body body,
const BodyState state 
)

◆ operator<<() [4/12]

CNOID_EXPORT BodyMotion::Frame cnoid::operator<< ( BodyMotion::Frame  frame,
const Body body 
)

◆ operator<<() [5/12]

CNOID_EXPORT BodyState & cnoid::operator<< ( BodyState state,
const Body body 
)

◆ operator<<() [6/12]

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

◆ operator<<() [7/12]

std::ostream & cnoid::operator<< ( std::ostream &  os,
const BoundingBoxf bb 
)

◆ operator<<() [8/12]

template<class Y >
std::ostream& cnoid::operator<< ( std::ostream &  os,
ref_ptr< Y > const &  p 
)

◆ operator<<() [9/12]

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

◆ operator<<() [10/12]

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

◆ operator<<() [11/12]

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

◆ operator<<() [12/12]

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

◆ operator==() [1/4]

template<class T , class U >
bool cnoid::operator== ( ref_ptr< T > const &  a,
ref_ptr< U > const &  b 
)
inline

◆ operator==() [2/4]

template<class T , class U >
bool cnoid::operator== ( ref_ptr< T > const &  a,
U *  b 
)
inline

◆ operator==() [3/4]

template<class T , class U >
bool cnoid::operator== ( T *  a,
ref_ptr< U > const &  b 
)
inline

◆ operator==() [4/4]

template<class T , class U >
bool cnoid::operator== ( weak_ref_ptr< T > const &  a,
weak_ref_ptr< U > const &  b 
)
inline

◆ operator>>() [1/11]

CNOID_EXPORT BodyMotion::ConstFrame cnoid::operator>> ( BodyMotion::ConstFrame  frame,
Body body 
)

◆ operator>>() [2/11]

CNOID_EXPORT BodyMotion::Frame cnoid::operator>> ( BodyMotion::Frame  frame,
const Body body 
)

◆ operator>>() [3/11]

const CNOID_EXPORT Body & cnoid::operator>> ( const Body body,
BodyMotion::Frame  frame 
)

◆ operator>>() [4/11]

const CNOID_EXPORT Body & cnoid::operator>> ( const Body body,
BodyState state 
)

◆ operator>>() [5/11]

const CNOID_EXPORT BodyState & cnoid::operator>> ( const BodyState state,
Body body 
)

◆ operator>>() [6/11]

EasyScanner & cnoid::operator>> ( EasyScanner scanner,
char  matchChar 
)

◆ operator>>() [7/11]

EasyScanner & cnoid::operator>> ( EasyScanner scanner,
const char *  matchString 
)

◆ operator>>() [8/11]

EasyScanner & cnoid::operator>> ( EasyScanner scanner,
double &  value 
)

◆ operator>>() [9/11]

EasyScanner & cnoid::operator>> ( EasyScanner scanner,
EasyScanner::Endl  endl 
)

◆ operator>>() [10/11]

EasyScanner & cnoid::operator>> ( EasyScanner scanner,
int &  value 
)

◆ operator>>() [11/11]

EasyScanner & cnoid::operator>> ( EasyScanner scanner,
std::string &  str 
)

◆ playAudioFile()

bool cnoid::playAudioFile ( const std::string &  filename,
double  volumeRatio = -1.0 
)

◆ pluginDir()

const CNOID_EXPORT std::string & cnoid::pluginDir ( )

◆ pluginDirectory()

const std::string& cnoid::pluginDirectory ( )
inline

◆ pluginDirPath()

CNOID_EXPORT stdx::filesystem::path cnoid::pluginDirPath ( )

◆ radian() [1/4]

Vector3 cnoid::radian ( const Vector3 v)
inline

◆ radian() [2/4]

double cnoid::radian ( double  deg)
inline

◆ radian() [3/4]

float cnoid::radian ( float  deg)
inline

◆ radian() [4/4]

double cnoid::radian ( int  deg)
inline

◆ read() [1/10]

bool cnoid::read ( const Mapping mapping,
const std::string &  key,
Eigen::AngleAxisd &  aa 
)

◆ read() [2/10]

template<typename Derived >
bool cnoid::read ( const Mapping mapping,
const std::string &  key,
Eigen::MatrixBase< Derived > &  x 
)

◆ read() [3/10]

template<typename Scalar , int Dim, int Mode>
bool cnoid::read ( const Mapping mapping,
const std::string &  key,
Eigen::Transform< Scalar, Dim, Mode > &  T 
)

◆ read() [4/10]

bool cnoid::read ( const Mapping mapping,
const std::string &  key,
std::function< void(const Eigen::Vector3d &value)>  setterFunc 
)

◆ read() [5/10]

template<typename Derived >
bool cnoid::read ( const Mapping mapping,
std::initializer_list< const char * >  keys,
Eigen::MatrixBase< Derived > &  x 
)

◆ read() [6/10]

template<typename Scalar , int Dim, int Mode>
bool cnoid::read ( const Mapping mapping,
std::initializer_list< const char * >  keys,
Eigen::Transform< Scalar, Dim, Mode > &  T 
)

◆ read() [7/10]

template<typename Derived >
bool cnoid::read ( const Mapping mapping,
const std::string &  key,
Eigen::MatrixBase< Derived > &  x 
)

◆ read() [8/10]

template<typename Scalar , int Dim, int Mode>
bool cnoid::read ( const Mapping mapping,
const std::string &  key,
Eigen::Transform< Scalar, Dim, Mode > &  T 
)

◆ read() [9/10]

template<typename Derived >
bool cnoid::read ( const Mapping mapping,
std::initializer_list< const char * >  keys,
Eigen::MatrixBase< Derived > &  x 
)

◆ read() [10/10]

template<typename Scalar , int Dim, int Mode>
bool cnoid::read ( const Mapping mapping,
std::initializer_list< const char * >  keys,
Eigen::Transform< Scalar, Dim, Mode > &  T 
)

◆ readAngleAxis() [1/3]

bool cnoid::readAngleAxis ( const Mapping mapping,
const std::string &  key,
Eigen::AngleAxisd &  aa 
)

◆ readAngleAxis() [2/3]

bool cnoid::readAngleAxis ( const Mapping mapping,
const std::string &  key,
Eigen::AngleAxisd &  aa 
)

◆ readAngleAxis() [3/3]

bool cnoid::readAngleAxis ( const Mapping mapping,
std::initializer_list< const char * >  keys,
Eigen::AngleAxisd &  aa 
)

◆ readDegreeAngleAxis()

bool cnoid::readDegreeAngleAxis ( const Mapping mapping,
const std::string &  key,
Eigen::AngleAxisd &  aa 
)

◆ readElements()

template<class Container >
bool cnoid::readElements ( const Mapping mapping,
const std::string &  key,
Container &  elements 
)

◆ readEx() [1/5]

template<typename Derived >
void cnoid::readEx ( const Listing listing,
Eigen::MatrixBase< Derived > &  x 
)

◆ readEx() [2/5]

template<typename Derived >
void cnoid::readEx ( const Listing listing,
Eigen::MatrixBase< Derived > &  x 
)

◆ readEx() [3/5]

template<typename Derived >
void cnoid::readEx ( const Mapping mapping,
const std::string &  key,
Eigen::MatrixBase< Derived > &  x 
)

◆ readEx() [4/5]

template<typename Derived >
void cnoid::readEx ( const Mapping mapping,
const std::string &  key,
Eigen::MatrixBase< Derived > &  x 
)

◆ readEx() [5/5]

template<typename Derived >
void cnoid::readEx ( const Mapping mapping,
std::initializer_list< const char * >  keys,
Eigen::MatrixBase< Derived > &  x 
)

◆ readRadianAngleAxis()

bool cnoid::readRadianAngleAxis ( const Mapping mapping,
const std::string &  key,
Eigen::AngleAxisd &  aa 
)

◆ reducePrecision()

template<int precision>
double cnoid::reducePrecision ( double  x)

◆ registerTagTraceStatementTagGroupResolver()

void cnoid::registerTagTraceStatementTagGroupResolver ( )

◆ rotFromRpy() [1/2]

Matrix3 cnoid::rotFromRpy ( const Vector3 rpy)
inline

◆ rotFromRpy() [2/2]

CNOID_EXPORT Matrix3 cnoid::rotFromRpy ( double  r,
double  p,
double  y 
)

◆ rpyFromRot() [1/2]

CNOID_EXPORT Vector3 cnoid::rpyFromRot ( const Matrix3 R)

◆ rpyFromRot() [2/2]

CNOID_EXPORT Vector3 cnoid::rpyFromRot ( const Matrix3 R,
const Vector3 prev 
)

◆ saveHrpsysSeqFileSet()

bool cnoid::saveHrpsysSeqFileSet ( BodyMotion motion,
Body body,
const std::string &  filename,
std::ostream &  os 
)

◆ savePCD()

void cnoid::savePCD ( SgPointSet pointSet,
const std::string &  filename,
const Isometry3 viewpoint = Isometry3::Identity() 
)

◆ setCnoidBodyTextDomainCodeset()

void cnoid::setCnoidBodyTextDomainCodeset ( )

◆ setCnoidUtilTextDomainCodeset()

void cnoid::setCnoidUtilTextDomainCodeset ( )

◆ setGaussWindow()

template<class T >
void cnoid::setGaussWindow ( sigma,
int  range,
std::vector< T > &  out_window 
)

◆ setJacobian() [1/2]

template<int elementMask, int rowOffset, int colOffset, bool useTargetLinkLocalPos>
void cnoid::setJacobian ( const JointPath path,
Link targetLink,
const Vector3 targetLinkLocalPos,
MatrixXd &  out_J 
)

◆ setJacobian() [2/2]

template<int elementMask, int rowOffset, int colOffset>
void cnoid::setJacobian ( const JointPath path,
Link targetLink,
MatrixXd &  out_J 
)

◆ shareDir()

const CNOID_EXPORT std::string & cnoid::shareDir ( )

◆ shareDirectory()

const std::string& cnoid::shareDirectory ( )
inline

◆ shareDirPath()

CNOID_EXPORT stdx::filesystem::path cnoid::shareDirPath ( )

◆ showConfirmDialog() [1/3]

bool cnoid::showConfirmDialog ( const char *  caption,
const char *  message 
)

◆ showConfirmDialog() [2/3]

bool cnoid::showConfirmDialog ( const QString &  caption,
const QString &  message 
)

◆ showConfirmDialog() [3/3]

bool cnoid::showConfirmDialog ( const std::string &  caption,
const std::string &  message 
)

◆ showMessageBox() [1/3]

void cnoid::showMessageBox ( const char *  message)

◆ showMessageBox() [2/3]

void cnoid::showMessageBox ( const QString &  message)

◆ showMessageBox() [3/3]

void cnoid::showMessageBox ( const std::string &  message)

◆ showWarningDialog() [1/3]

void cnoid::showWarningDialog ( const char *  message)

◆ showWarningDialog() [2/3]

void cnoid::showWarningDialog ( const QString &  message)

◆ showWarningDialog() [3/3]

void cnoid::showWarningDialog ( const std::string &  message)

◆ sigAboutToQuit()

SignalProxy< void()> cnoid::sigAboutToQuit ( )

◆ static_pointer_cast()

template<class T , class U >
ref_ptr<T> cnoid::static_pointer_cast ( ref_ptr< U > const &  p)

◆ str() [1/4]

CNOID_EXPORT std::string cnoid::str ( const AngleAxis a)

◆ str() [2/4]

CNOID_EXPORT std::string cnoid::str ( const Vector2 v)

◆ str() [3/4]

CNOID_EXPORT std::string cnoid::str ( const Vector3 v)

◆ str() [4/4]

CNOID_EXPORT std::string cnoid::str ( const Vector3f &  v)

◆ strtod()

double cnoid::strtod ( const char *  nptr,
char **  endptr 
)
inline

◆ strtof()

float cnoid::strtof ( const char *  nptr,
char **  endptr 
)
inline

◆ swap() [1/2]

template<class T >
void cnoid::swap ( ref_ptr< T > &  lhs,
ref_ptr< T > &  rhs 
)

◆ swap() [2/2]

template<class T >
void cnoid::swap ( weak_ref_ptr< T > &  a,
weak_ref_ptr< T > &  b 
)

◆ toActualPathName()

CNOID_EXPORT std::string cnoid::toActualPathName ( const std::string &  path)

◆ toUTF8() [1/2]

const std::string cnoid::toUTF8 ( const char *  text)
inline

◆ toUTF8() [2/2]

const std::string& cnoid::toUTF8 ( const std::string &  text)
inline

◆ toVector3() [1/2]

CNOID_EXPORT bool cnoid::toVector3 ( const std::string &  s,
Vector3 out_v 
)

◆ toVector3() [2/2]

CNOID_EXPORT bool cnoid::toVector3 ( const std::string &  s,
Vector3f &  out_v 
)

◆ toVector6()

CNOID_EXPORT bool cnoid::toVector6 ( const std::string &  s,
Vector6 out_v 
)

◆ trim()

CNOID_EXPORT void cnoid::trim ( std::string &  s)

◆ trimmed()

CNOID_EXPORT std::string cnoid::trimmed ( const std::string &  s)

◆ updateGui()

void cnoid::updateGui ( )

◆ usleep()

void cnoid::usleep ( int  usec)
inline

◆ write() [1/5]

Listing & cnoid::write ( Mapping mapping,
const std::string &  key,
const Eigen::AngleAxisd &  aa 
)

◆ write() [2/5]

template<typename Derived >
Listing& cnoid::write ( Mapping mapping,
const std::string &  key,
const Eigen::MatrixBase< Derived > &  x 
)

◆ write() [3/5]

template<typename Scalar , int Dim, int Mode>
Listing& cnoid::write ( Mapping mapping,
const std::string &  key,
const Eigen::Transform< Scalar, Dim, Mode > &  T 
)

◆ write() [4/5]

template<typename Derived >
Listing* cnoid::write ( Mapping mapping,
const std::string &  key,
const Eigen::MatrixBase< Derived > &  x 
)

◆ write() [5/5]

template<typename Scalar , int Dim, int Mode>
Listing* cnoid::write ( Mapping mapping,
const std::string &  key,
const Eigen::Transform< Scalar, Dim, Mode > &  T 
)

◆ writeAngleAxis() [1/2]

Listing & cnoid::writeAngleAxis ( Mapping mapping,
const std::string &  key,
const Eigen::AngleAxisd &  aa 
)

◆ writeAngleAxis() [2/2]

Listing * cnoid::writeAngleAxis ( Mapping mapping,
const std::string &  key,
const Eigen::AngleAxisd &  aa 
)

◆ writeDegreeAngleAxis() [1/2]

Listing & cnoid::writeDegreeAngleAxis ( Mapping mapping,
const std::string &  key,
const Eigen::AngleAxisd &  aa 
)

◆ writeDegreeAngleAxis() [2/2]

Listing * cnoid::writeDegreeAngleAxis ( Mapping mapping,
const std::string &  key,
const Eigen::AngleAxisd &  aa 
)

◆ writeElements()

template<class Container >
bool cnoid::writeElements ( Mapping mapping,
const std::string &  key,
const Container &  elements,
bool  isFlowStyle = false 
)

◆ writeRadianAngleAxis_()

Listing * cnoid::writeRadianAngleAxis_ ( Mapping mapping,
const std::string &  key,
const Eigen::AngleAxisd &  aa 
)

Variable Documentation

◆ BodyCustomizerGetTargetModelNamesFunc

const typedef char**(* cnoid::BodyCustomizerGetTargetModelNamesFunc) ()

◆ BodyGetLinkNameFunc

const typedef char*(* cnoid::BodyGetLinkNameFunc) (BodyHandle bodyHandle, int linkIndex)

◆ DLL_EXTENSION

const CNOID_EXPORT char * cnoid::DLL_EXTENSION = "so"

◆ DLL_PREFIX

const CNOID_EXPORT char * cnoid::DLL_PREFIX = "lib"

◆ DLL_SUFFIX

const CNOID_EXPORT char * cnoid::DLL_SUFFIX = ".so"

◆ EXEC_EXTENSION

const CNOID_EXPORT char * cnoid::EXEC_EXTENSION = ""

◆ EXEC_SUFFIX

const CNOID_EXPORT char * cnoid::EXEC_SUFFIX = ""

◆ PATH_DELIMITER

const CNOID_EXPORT char * cnoid::PATH_DELIMITER = ":"

◆ PI

constexpr double cnoid::PI = 3.141592653589793238462643383279502884
constexpr

◆ PI_2

constexpr double cnoid::PI_2 = 1.570796326794896619231321691639751442
constexpr

◆ TO_DEGREE

constexpr double cnoid::TO_DEGREE = 180.0 / PI
constexpr

◆ TO_RADIAN

constexpr double cnoid::TO_RADIAN = PI / 180.0
constexpr