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	ItemEditRecordManager

class	ItemFileDialog

class	ItemFileIO

class	ItemFileIoBase

class	ItemFileIoExtender

class	ItemFileIoExtenderBase

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	SceneWidgetEditable

class	SceneWidgetEvent

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< Collision >	CollisionArray

typedef std::vector< Collision >	CollisionList
	obsolete More...

typedef ref_ptr< CollisionDetector >	CollisionDetectorPtr

typedef ref_ptr< CoordinateFrame >	CoordinateFramePtr

typedef ref_ptr< CoordinateFrameList >	CoordinateFrameListPtr

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< FilePathVariableProcessor >	FilePathVariableProcessorPtr

typedef MeshFilter	MeshNormalGenerator

typedef ref_ptr< PositionTag >	PositionTagPtr

typedef ref_ptr< PositionTagGroup >	PositionTagGroupPtr

typedef ref_ptr< Referenced >	ReferencedPtr

typedef ref_ptr< SgCamera >	SgCameraPtr

typedef ref_ptr< SgPerspectiveCamera >	SgPerspectiveCameraPtr

typedef ref_ptr< SgOrthographicCamera >	SgOrthographicCameraPtr

typedef ref_ptr< SgMaterial >	SgMaterialPtr

typedef ref_ptr< SgImage >	SgImagePtr

typedef ref_ptr< SgTextureTransform >	SgTextureTransformPtr

typedef ref_ptr< SgTexture >	SgTexturePtr

typedef SgVectorArray< Vector3f >	SgVertexArray

typedef ref_ptr< SgVertexArray >	SgVertexArrayPtr

typedef SgVectorArray< Vector3f >	SgNormalArray

typedef ref_ptr< SgNormalArray >	SgNormalArrayPtr

typedef SgVectorArray< Vector3f >	SgColorArray

typedef ref_ptr< SgColorArray >	SgColorArrayPtr

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

typedef ref_ptr< SgTexCoordArray >	SgTexCoordArrayPtr

typedef std::vector< int >	SgIndexArray

typedef ref_ptr< SgMeshBase >	SgMeshBasePtr

typedef ref_ptr< SgMesh >	SgMeshPtr

typedef ref_ptr< SgPolygonMesh >	SgPolygonMeshPtr

typedef ref_ptr< SgShape >	SgShapePtr

typedef ref_ptr< SgPlot >	SgPlotPtr

typedef ref_ptr< SgPointSet >	SgPointSetPtr

typedef ref_ptr< SgLineSet >	SgLineSetPtr

typedef ref_ptr< SgOverlay >	SgOverlayPtr

typedef ref_ptr< SgViewportOverlay >	SgViewportOverlayPtr

typedef ref_ptr< SgPolygonDrawStyle >	SgPolygonDrawStylePtr

typedef ref_ptr< SgTransparentGroup >	SgTransparentGroupPtr

typedef ref_ptr< SgFog >	SgFogPtr

typedef ref_ptr< SgHighlight >	SgHighlightPtr

typedef ref_ptr< SgBoundingBox >	SgBoundingBoxPtr

typedef ref_ptr< SgOutline >	SgOutlinePtr

typedef ref_ptr< SgLightweightRenderingGroup >	SgLightweightRenderingGroupPtr

typedef std::vector< SgNode * >	SgNodePath

typedef ref_ptr< SgObject >	SgObjectPtr

typedef ref_ptr< SgNode >	SgNodePtr

typedef ref_ptr< SgGroup >	SgGroupPtr

typedef ref_ptr< SgInvariantGroup >	SgInvariantGroupPtr

typedef ref_ptr< SgTransform >	SgTransformPtr

typedef ref_ptr< SgPosTransform >	SgPosTransformPtr

typedef ref_ptr< SgScaleTransform >	SgScaleTransformPtr

typedef ref_ptr< SgAffineTransform >	SgAffineTransformPtr

typedef ref_ptr< SgFixedPixelSizeGroup >	SgFixedPixelSizeGroupPtr

typedef ref_ptr< SgSwitch >	SgSwitchPtr

typedef ref_ptr< SgSwitchableGroup >	SgSwitchableGroupPtr

typedef ref_ptr< SgUnpickableGroup >	SgUnpickableGroupPtr

typedef ref_ptr< SgPreprocessed >	SgPreprocessedPtr

typedef ref_ptr< SgLight >	SgLightPtr

typedef ref_ptr< SgDirectionalLight >	SgDirectionalLightPtr

typedef ref_ptr< SgPointLight >	SgPointLightPtr

typedef ref_ptr< SgSpotLight >	SgSpotLightPtr

typedef ref_ptr< SceneMarker >	SceneMarkerPtr

typedef ref_ptr< CrossMarker >	CrossMarkerPtr

typedef ref_ptr< SphereMarker >	SphereMarkerPtr

typedef ref_ptr< BoundingBoxMarker >	BoundingBoxMarkerPtr

typedef ref_ptr< SharedJoystick >	SharedJoystickPtr

typedef ref_ptr< Mapping >	MappingPtr

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

typedef ref_ptr< TaskToggleState >	TaskToggleStatePtr

typedef ref_ptr< TaskCommand >	TaskCommandPtr

typedef ref_ptr< TaskPhaseProxy >	TaskPhaseProxyPtr

typedef ref_ptr< TaskPhase >	TaskPhasePtr

typedef ref_ptr< Task >	TaskPtr

typedef ref_ptr< ValueNode >	ValueNodePtr

typedef ref_ptr< Listing >	ListingPtr

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< SFInt32 >	MFInt32

typedef std::vector< SFFloat >	MFFloat

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

typedef std::vector< SFVec2s >	MFVec2s

typedef std::vector< SFVec3f >	MFVec3f

typedef std::vector< SFVec3s >	MFVec3s

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

typedef std::vector< SFTime >	MFTime

typedef std::vector< SFColor >	MFColor

typedef std::vector< SFString >	MFString

typedef ref_ptr< VRMLNode >	VRMLNodePtr

typedef VRMLNodePtr	SFNode

typedef std::vector< SFNode >	MFNode

typedef ref_ptr< VRMLUnsupportedNode >	VRMLUnsupportedNodePtr

typedef ref_ptr< VRMLViewpoint >	VRMLViewpointPtr

typedef ref_ptr< VRMLNavigationInfo >	VRMLNavigationInfoPtr

typedef ref_ptr< VRMLBackground >	VRMLBackgroundPtr

typedef ref_ptr< AbstractVRMLGroup >	AbstractVRMLGroupPtr

typedef ref_ptr< VRMLGroup >	VRMLGroupPtr

typedef ref_ptr< VRMLTransform >	VRMLTransformPtr

typedef ref_ptr< VRMLInline >	VRMLInlinePtr

typedef ref_ptr< VRMLNonVrmlInline >	VRMLNonVrmlInlinePtr

typedef ref_ptr< VRMLAppearance >	VRMLAppearancePtr

typedef ref_ptr< VRMLGeometry >	VRMLGeometryPtr

typedef ref_ptr< VRMLShape >	VRMLShapePtr

typedef ref_ptr< VRMLMaterial >	VRMLMaterialPtr

typedef ref_ptr< VRMLTexture >	VRMLTexturePtr

typedef ref_ptr< VRMLTextureTransform >	VRMLTextureTransformPtr

typedef ref_ptr< VRMLImageTexture >	VRMLImageTexturePtr

typedef ref_ptr< VRMLBox >	VRMLBoxPtr

typedef ref_ptr< VRMLCone >	VRMLConePtr

typedef ref_ptr< VRMLCylinder >	VRMLCylinderPtr

typedef ref_ptr< VRMLSphere >	VRMLSpherePtr

typedef ref_ptr< VRMLFontStyle >	VRMLFontStylePtr

typedef ref_ptr< VRMLText >	VRMLTextPtr

typedef ref_ptr< VRMLColor >	VRMLColorPtr

typedef ref_ptr< VRMLCoordinate >	VRMLCoordinatePtr

typedef ref_ptr< VRMLIndexedLineSet >	VRMLIndexedLineSetPtr

typedef ref_ptr< VRMLNormal >	VRMLNormalPtr

typedef ref_ptr< VRMLTextureCoordinate >	VRMLTextureCoordinatePtr

typedef ref_ptr< VRMLIndexedFaceSet >	VRMLIndexedFaceSetPtr

typedef ref_ptr< VRMLCylinderSensor >	VRMLCylinderSensorPtr

typedef ref_ptr< VRMLPointSet >	VRMLPointSetPtr

typedef ref_ptr< VRMLPixelTexture >	VRMLPixelTexturePtr

typedef ref_ptr< VRMLMovieTexture >	VRMLMovieTexturePtr

typedef ref_ptr< VRMLElevationGrid >	VRMLElevationGridPtr

typedef ref_ptr< VRMLExtrusion >	VRMLExtrusionPtr

typedef ref_ptr< VRMLSwitch >	VRMLSwitchPtr

typedef ref_ptr< VRMLLOD >	VRMLLODPtr

typedef ref_ptr< VRMLCollision >	VRMLCollisionPtr

typedef ref_ptr< VRMLAnchor >	VRMLAnchorPtr

typedef ref_ptr< VRMLBillboard >	VRMLBillboardPtr

typedef ref_ptr< VRMLFog >	VRMLFogPtr

typedef ref_ptr< VRMLWorldInfo >	VRMLWorldInfoPtr

typedef ref_ptr< VRMLLight >	VRMLLightPtr

typedef ref_ptr< VRMLPointLight >	VRMLPointLightPtr

typedef ref_ptr< VRMLDirectionalLight >	VRMLDirectionalLightPtr

typedef ref_ptr< VRMLSpotLight >	VRMLSpotLightPtr

typedef stdx::variant< SFBool, SFInt32, SFFloat, SFVec2f, SFVec3f, SFRotation, SFColor, SFTime, SFString, SFNode, SFImage, MFInt32, MFFloat, MFVec2f, MFVec3f, MFRotation, MFColor, MFTime, MFString, MFNode >	VRMLVariantField

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

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

typedef ref_ptr< VRMLProto >	VRMLProtoPtr

typedef ref_ptr< VRMLProtoInstance >	VRMLProtoInstancePtr

typedef ref_ptr< AISTCollisionDetector >	AISTCollisionDetectorPtr

typedef ref_ptr< ColdetModel >	ColdetModelPtr

typedef ref_ptr< ColdetModelPair >	ColdetModelPairPtr

typedef std::shared_ptr< AbstractBodyLoader >	AbstractBodyLoaderPtr

typedef ref_ptr< AccelerationSensor >	AccelerationSensorPtr

typedef ref_ptr< AttachmentDevice >	AttachmentDevicePtr

typedef void *	BodyCustomizerHandle

typedef ref_ptr< Body >	BodyPtr

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< BodyHandler >	BodyHandlerPtr

typedef ref_ptr< Camera >	CameraPtr

typedef std::shared_ptr< CollisionLinkPair >	CollisionLinkPairPtr

typedef ref_ptr< ContactMaterial >	ContactMaterialPtr

typedef ref_ptr< CustomJointPathHandler >	CustomJointPathHandlerPtr

typedef ref_ptr< DeviceState >	DeviceStatePtr

typedef ref_ptr< Device >	DevicePtr

typedef ref_ptr< DigitalIoDevice >	DigitalIoDevicePtr

typedef ref_ptr< DyBody >	DyBodyPtr

typedef ref_ptr< DyLink >	DyLinkPtr

typedef ref_ptr< DySubBody >	DySubBodyPtr

typedef ref_ptr< ExtraBodyStateAccessor >	ExtraBodyStateAccessorPtr

typedef ref_ptr< ForceSensor >	ForceSensorPtr

typedef ref_ptr< HolderDevice >	HolderDevicePtr

typedef ref_ptr< DigitalIoConnection >	DigitalIoConnectionPtr

typedef ref_ptr< IoConnectionMap >	IoConnectionMapPtr

typedef ref_ptr< LeggedBodyHelper >	LeggedBodyHelperPtr

typedef ref_ptr< Light >	LightPtr

typedef ref_ptr< Link >	LinkPtr

typedef std::shared_ptr< LinkGroup >	LinkGroupPtr

typedef ref_ptr< LinkKinematicsKit >	LinkKinematicsKitPtr

typedef ref_ptr< MarkerDevice >	MarkerDevicePtr

typedef ref_ptr< Material >	MaterialPtr

typedef ref_ptr< MaterialTable >	MaterialTablePtr

typedef ref_ptr< PointLight >	PointLightPtr

typedef ref_ptr< RangeCamera >	RangeCameraPtr

typedef ref_ptr< RangeSensor >	RangeSensorPtr

typedef ref_ptr< RateGyroSensor >	RateGyroSensorPtr

typedef ref_ptr< SceneLink >	SceneLinkPtr

typedef ref_ptr< SceneBody >	SceneBodyPtr

typedef ref_ptr< SceneCollision >	SceneCollisionPtr

typedef ref_ptr< SceneDevice >	SceneDevicePtr

typedef ref_ptr< SpotLight >	SpotLightPtr

typedef ref_ptr< VRMLHumanoid >	VRMLHumanoidPtr

typedef ref_ptr< VRMLJoint >	VRMLJointPtr

typedef ref_ptr< VRMLSegment >	VRMLSegmentPtr

typedef ref_ptr< VRMLSurface >	VRMLSurfacePtr

typedef ref_ptr< VRMLVisionSensor >	VRMLVisionSensorPtr

typedef ref_ptr< VRMLForceSensor >	VRMLForceSensorPtr

typedef ref_ptr< VRMLGyro >	VRMLGyroPtr

typedef ref_ptr< VRMLAccelerationSensor >	VRMLAccelerationSensorPtr

typedef ref_ptr< VRMLRangeSensor >	VRMLRangeSensorPtr

typedef ref_ptr< AbstractSeqItem >	AbstractSeqItemPtr

typedef ref_ptr< AbstractMultiSeqItem >	AbstractMultiSeqItemPtr

typedef ref_ptr< AbstractTextItem >	AbstractTextItemPtr

typedef ref_ptr< Archive >	ArchivePtr

typedef ref_ptr< CoordinateFrameItem >	CoordinateFrameItemPtr

typedef ref_ptr< CoordinateFrameListItem >	CoordinateFrameListItemPtr

typedef ref_ptr< CoordinateFrameMarker >	CoordinateFrameMarkerPtr

typedef ref_ptr< EditRecord >	EditRecordPtr

typedef ref_ptr< EditRecordGroup >	EditRecordGroupPtr

typedef ref_ptr< ExtCommandItem >	ExtCommandItemPtr

typedef ref_ptr< FolderItem >	FolderItemPtr

typedef std::shared_ptr< GraphDataHandler >	GraphDataHandlerPtr

typedef ref_ptr< InteractiveCameraTransform >	InteractiveCameraTransformPtr

typedef ref_ptr< Item >	ItemPtr

typedef ref_ptr< ItemAddon >	ItemAddonPtr

typedef ref_ptr< ItemFileIO >	ItemFileIOPtr

typedef ref_ptr< LightingItem >	LightingItemPtr

typedef ref_ptr< LocationProxy >	LocationProxyPtr

typedef ref_ptr< MessageLogItem >	MessageLogItemPtr

typedef ref_ptr< MultiPointSetItem >	MultiPointSetItemPtr

typedef MultiSeqItem< MultiSE3MatrixSeq >	MultiSE3MatrixSeqItem

typedef MultiSE3MatrixSeqItem::Ptr	MultiSE3MatrixSeqItemPtr

typedef MultiSeqItem< MultiSE3Seq >	MultiSE3SeqItem

typedef MultiSE3SeqItem::Ptr	MultiSE3SeqItemPtr

typedef MultiSeqItem< MultiValueSeq >	MultiValueSeqItem

typedef MultiValueSeqItem::Ptr	MultiValueSeqItemPtr

typedef ref_ptr< PointSetItem >	PointSetItemPtr

typedef PolymorphicItemFunctionSet::Dispatcher	ItemFunctionDispatcher

typedef ref_ptr< PositionDragger >	PositionDraggerPtr

typedef ref_ptr< PositionTagGroupItem >	PositionTagGroupItemPtr

typedef ref_ptr< RectRegionMarker >	RectRegionMarkerPtr

typedef ref_ptr< ReferencedObjectSeqItem >	ReferencedObjectSeqItemPtr

typedef RenderableItem	SceneProvider

typedef ref_ptr< RootItem >	RootItemPtr

typedef ref_ptr< SceneItem >	SceneItemPtr

typedef ref_ptr< SceneWidgetRoot >	SceneWidgetRootPtr

typedef ref_ptr< ScriptItem >	ScriptItemPtr

typedef ref_ptr< SubProjectItem >	SubProjectItemPtr

typedef ref_ptr< TimeSyncItemEngine >	TimeSyncItemEnginePtr

typedef ref_ptr< Vector3SeqItem >	Vector3SeqItemPtr

typedef ref_ptr< AISTSimulatorItem >	AISTSimulatorItemPtr

typedef ref_ptr< BodyContactPointLoggerItem >	BodyContactPointLoggerItemPtr

typedef ref_ptr< BodyElementOverwriteItem >	BodyElementOverwriteItemPtr

typedef ref_ptr< BodyItem >	BodyItemPtr

typedef ref_ptr< BodyKinematicsEditRecord >	BodyKinematicsEditRecordPtr

typedef ref_ptr< BodyMotionControllerItem >	BodyMotionControllerItemPtr

typedef ref_ptr< BodyMotionEngine >	BodyMotionEnginePtr

typedef ref_ptr< BodyMotionItem >	BodyMotionItemPtr

typedef ref_ptr< BodySuperimposerAddon >	BodySuperimposerAddonPtr

typedef ref_ptr< BodyTrackingCameraItem >	BodyTrackingCameraItemPtr

typedef std::vector< CollisionLinkPairPtr >	CollisionLinkPairList

typedef ref_ptr< CollisionSeqEngine >	CollisionSeqEnginePtr

typedef ref_ptr< CollisionSeqItem >	CollisionSeqItemPtr

typedef ref_ptr< ControllerItem >	ControllerItemPtr

typedef ref_ptr< ControllerLogItem >	ControllerLogItemPtr

typedef ref_ptr< DeviceOverwriteMediator >	DeviceOverwriteMediatorPtr

typedef ref_ptr< DeviceOverwriteItem >	DeviceOverwriteItemPtr

typedef ref_ptr< EditableSceneLink >	EditableSceneLinkPtr

typedef ref_ptr< EditableSceneBody >	EditableSceneBodyPtr

typedef ref_ptr< GLVisionSimulatorItem >	GLVisionSimulatorItemPtr

typedef ref_ptr< IoConnectionMapItem >	IoConnectionMapItemPtr

typedef ref_ptr< KinematicSimulatorItem >	KinematicSimulatorItemPtr

typedef ref_ptr< LinkOffsetFrameListItem >	LinkOffsetFrameListItemPtr

typedef ref_ptr< LinkShapeOverwriteItem >	LinkShapeOverwriteItemPtr

typedef ref_ptr< MultiDeviceStateSeqItem >	MultiDeviceStateSeqItemPtr

typedef ref_ptr< SensorVisualizerItem >	SensorVisualizerItemPtr

typedef ref_ptr< SimpleControllerItem >	SimpleControllerItemPtr

typedef ref_ptr< SimulationScriptItem >	SimulationScriptItemPtr

typedef ref_ptr< SimulationBody >	SimulationBodyPtr

typedef ref_ptr< SimulatorItem >	SimulatorItemPtr

typedef ref_ptr< SubSimulatorItem >	SubSimulatorItemPtr

typedef ref_ptr< WorldItem >	WorldItemPtr

typedef ref_ptr< WorldLogFileItem >	WorldLogFileItemPtr

typedef ref_ptr< ZMPSeqItem >	ZMPSeqItemPtr

typedef ref_ptr< MprEmptyStatement >	MprEmptyStatementPtr

typedef ref_ptr< MprDummyStatement >	MprDummyStatementPtr

typedef ref_ptr< MprCommentStatement >	MprCommentStatementPtr

typedef ref_ptr< MprGroupStatement >	MprGroupStatementPtr

typedef ref_ptr< MprConditionStatement >	MprConditionStatementPtr

typedef ref_ptr< MprIfStatement >	MprIfStatementPtr

typedef ref_ptr< MprCallStatement >	MprCallStatementPtr

typedef ref_ptr< MprAssignStatement >	MprAssignStatementPtr

typedef ref_ptr< MprSignalStatement >	MprSignalStatementPtr

typedef ref_ptr< MprWaitStatement >	MprWaitStatementPtr

typedef ref_ptr< MprDelayStatement >	MprDelayStatementPtr

typedef ref_ptr< MprControllerItemBase >	MprControllerItemBasePtr

typedef ref_ptr< MprControllerLog >	MprControllerLogPtr

typedef ref_ptr< MprMultiVariableListItem >	MprMultiVariableListItemPtr

typedef ref_ptr< MprPosition >	MprPositionPtr

typedef ref_ptr< MprIkPosition >	MprIkPositionPtr

typedef ref_ptr< MprFkPosition >	MprFkPositionPtr

typedef ref_ptr< MprPositionList >	MprPositionListPtr

typedef ref_ptr< MprPositionStatement >	MprPositionStatementPtr

typedef ref_ptr< MprProgram >	MprProgramPtr

typedef ref_ptr< MprProgramItemBase >	MprProgramItemBasePtr

typedef ref_ptr< MprStatement >	MprStatementPtr

typedef PolymorphicMprStatementFunctionSet::Dispatcher	MprStatementFunctionDispatcher

typedef ref_ptr< MprStructuredStatement >	MprStructuredStatementPtr

typedef ref_ptr< MprTagTraceStatement >	MprTagTraceStatementPtr

typedef ref_ptr< MprVariable >	MprVariablePtr

typedef ref_ptr< MprVariableList >	MprVariableListPtr

typedef ref_ptr< AudioItem >	AudioItemPtr

typedef ref_ptr< MediaItem >	MediaItemPtr

typedef ref_ptr< PythonScriptItem >	PythonScriptItemPtr

typedef ref_ptr< PythonSimScriptItem >	PythonSimScriptItemPtr

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 EasyScanner &	operator>> (EasyScanner &scanner, double &value)

CNOID_EXPORT EasyScanner &	operator>> (EasyScanner &scanner, int &value)

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

CNOID_EXPORT EasyScanner &	operator>> (EasyScanner &scanner, char matchChar)

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

CNOID_EXPORT EasyScanner &	operator>> (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 >
Listing *	write (Mapping *mapping, const std::string &key, const Eigen::MatrixBase< Derived > &x)

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

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

template<typename Scalar , int Dim, int Mode>
Listing &	write (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 Listing *	writeDegreeAngleAxis (Mapping *mapping, const std::string &key, const Eigen::AngleAxisd &aa)

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

CNOID_EXPORT Listing *	writeRadianAngleAxis_ (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 Listing *	writeAngleAxis (Mapping *mapping, const std::string &key, const Eigen::AngleAxisd &aa)

CNOID_EXPORT Listing &	writeAngleAxis (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 Listing &	write (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 BodyCustomizerInterface *	findBodyCustomizer (std::string modelName)

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

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

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

BodyMotion::ConstFrame	operator>> (BodyMotion::ConstFrame frame, Body &body)

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

Body &	operator<< (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())

BodyState &	operator<< (BodyState &state, const Body &body)

const BodyState &	operator>> (const BodyState &state, Body &body)

Body &	operator<< (Body &body, const BodyState &state)

const Body &	operator>> (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< JointPath >	getCustomJointPath (Body body, Link baseLink, Link *endLink)

LeggedBodyHelper *	getLeggedBodyHelper (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< MultiDeviceStateSeq >	getMultiDeviceStateSeq (const BodyMotion &motion)

CNOID_EXPORT std::shared_ptr< MultiDeviceStateSeq >	getOrCreateMultiDeviceStateSeq (BodyMotion &motion)

CNOID_EXPORT void	clearMultiDeviceStateSeq (BodyMotion &motion)

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

CNOID_EXPORT std::shared_ptr< ZMPSeq >	getOrCreateZMPSeq (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=false)

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)

TimeSyncItemEngine *	createBodyMotionEngine (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

typedef std::shared_ptr<AbstractBodyLoader> cnoid::AbstractBodyLoaderPtr

◆ AbstractMultiSeqItemPtr

typedef ref_ptr<AbstractMultiSeqItem> cnoid::AbstractMultiSeqItemPtr

◆ AbstractSeqItemPtr

typedef ref_ptr<AbstractSeqItem> cnoid::AbstractSeqItemPtr

◆ AbstractTextItemPtr

typedef ref_ptr<AbstractTextItem> cnoid::AbstractTextItemPtr

◆ AbstractVRMLGroupPtr

typedef ref_ptr<AbstractVRMLGroup> cnoid::AbstractVRMLGroupPtr

◆ AccelerationSensorPtr

typedef ref_ptr<AccelerationSensor> cnoid::AccelerationSensorPtr

◆ Affine3

typedef Eigen::Affine3d cnoid::Affine3

◆ AISTCollisionDetectorPtr

typedef ref_ptr<AISTCollisionDetector> cnoid::AISTCollisionDetectorPtr

◆ AISTSimulatorItemPtr

typedef ref_ptr<AISTSimulatorItem> cnoid::AISTSimulatorItemPtr

◆ AngleAxis

typedef Eigen::AngleAxisd cnoid::AngleAxis

◆ ArchivePtr

typedef ref_ptr<Archive> cnoid::ArchivePtr

◆ AttachmentDevicePtr

typedef ref_ptr< AttachmentDevice > cnoid::AttachmentDevicePtr

◆ AudioItemPtr

typedef ref_ptr<AudioItem> cnoid::AudioItemPtr

◆ BodyContactPointLoggerItemPtr

typedef ref_ptr<BodyContactPointLoggerItem> cnoid::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

typedef void * cnoid::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

typedef ref_ptr<BodyElementOverwriteItem> cnoid::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

typedef ref_ptr<BodyHandler> cnoid::BodyHandlerPtr

◆ BodyItemPtr

typedef ref_ptr<BodyItem> cnoid::BodyItemPtr

◆ BodyKinematicsEditRecordPtr

typedef ref_ptr<BodyKinematicsEditRecord> cnoid::BodyKinematicsEditRecordPtr

◆ BodyMotionControllerItemPtr

typedef ref_ptr<BodyMotionControllerItem> cnoid::BodyMotionControllerItemPtr

◆ BodyMotionEnginePtr

typedef ref_ptr<BodyMotionEngine> cnoid::BodyMotionEnginePtr

◆ BodyMotionItemPtr

typedef ref_ptr<BodyMotionItem> cnoid::BodyMotionItemPtr

◆ BodyPtr

typedef ref_ptr<Body> cnoid::BodyPtr

◆ BodySuperimposerAddonPtr

typedef ref_ptr<BodySuperimposerAddon> cnoid::BodySuperimposerAddonPtr

◆ BodyTrackingCameraItemPtr

typedef ref_ptr<BodyTrackingCameraItem> cnoid::BodyTrackingCameraItemPtr

◆ BoundingBoxMarkerPtr

typedef ref_ptr<BoundingBoxMarker> cnoid::BoundingBoxMarkerPtr

◆ CameraPtr

typedef ref_ptr<Camera> cnoid::CameraPtr

◆ ColdetModelPairPtr

typedef ref_ptr<ColdetModelPair> cnoid::ColdetModelPairPtr

◆ ColdetModelPtr

typedef ref_ptr<ColdetModel> cnoid::ColdetModelPtr

◆ CollisionArray

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

◆ CollisionDetectorPtr

typedef ref_ptr<CollisionDetector> cnoid::CollisionDetectorPtr

◆ CollisionLinkPairList

typedef std::vector<CollisionLinkPairPtr> cnoid::CollisionLinkPairList

◆ CollisionLinkPairPtr

typedef std::shared_ptr<CollisionLinkPair> cnoid::CollisionLinkPairPtr

◆ CollisionList

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

obsolete

◆ CollisionSeqEnginePtr

typedef ref_ptr<CollisionSeqEngine> cnoid::CollisionSeqEnginePtr

◆ CollisionSeqItemPtr

typedef ref_ptr<CollisionSeqItem> cnoid::CollisionSeqItemPtr

◆ ContactMaterialPtr

typedef ref_ptr<ContactMaterial> cnoid::ContactMaterialPtr

◆ ControllerItemPtr

typedef ref_ptr<ControllerItem> cnoid::ControllerItemPtr

◆ ControllerLogItemPtr

typedef ref_ptr<ControllerLogItem> cnoid::ControllerLogItemPtr

◆ CoordinateFrameItemPtr

typedef ref_ptr<CoordinateFrameItem> cnoid::CoordinateFrameItemPtr

◆ CoordinateFrameListItemPtr

typedef ref_ptr<CoordinateFrameListItem> cnoid::CoordinateFrameListItemPtr

◆ CoordinateFrameListPtr

typedef ref_ptr<CoordinateFrameList> cnoid::CoordinateFrameListPtr

◆ CoordinateFrameMarkerPtr

typedef ref_ptr<CoordinateFrameMarker> cnoid::CoordinateFrameMarkerPtr

◆ CoordinateFramePtr

typedef ref_ptr<CoordinateFrame> cnoid::CoordinateFramePtr

◆ CrossMarkerPtr

typedef ref_ptr<CrossMarker> cnoid::CrossMarkerPtr

◆ CustomJointPathHandlerPtr

typedef ref_ptr<CustomJointPathHandler> cnoid::CustomJointPathHandlerPtr

◆ DeviceOverwriteItemPtr

typedef ref_ptr<DeviceOverwriteItem> cnoid::DeviceOverwriteItemPtr

◆ DeviceOverwriteMediatorPtr

typedef ref_ptr<DeviceOverwriteMediator> cnoid::DeviceOverwriteMediatorPtr

◆ DevicePtr

typedef ref_ptr<Device> cnoid::DevicePtr

◆ DeviceStatePtr

typedef ref_ptr<DeviceState> cnoid::DeviceStatePtr

◆ DigitalIoConnectionPtr

typedef ref_ptr<DigitalIoConnection> cnoid::DigitalIoConnectionPtr

◆ DigitalIoDevicePtr

typedef ref_ptr< DigitalIoDevice > cnoid::DigitalIoDevicePtr

◆ DyBodyPtr

typedef ref_ptr< DyBody > cnoid::DyBodyPtr

◆ DyLinkPtr

typedef ref_ptr<DyLink> cnoid::DyLinkPtr

◆ DySubBodyPtr

typedef ref_ptr< DySubBody > cnoid::DySubBodyPtr

◆ EditableSceneBodyPtr

typedef ref_ptr<EditableSceneBody> cnoid::EditableSceneBodyPtr

◆ EditableSceneLinkPtr

typedef ref_ptr<EditableSceneLink> cnoid::EditableSceneLinkPtr

◆ EditRecordGroupPtr

typedef ref_ptr<EditRecordGroup> cnoid::EditRecordGroupPtr

◆ EditRecordPtr

typedef ref_ptr< EditRecord > cnoid::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

typedef ref_ptr<ExtCommandItem> cnoid::ExtCommandItemPtr

◆ ExtraBodyStateAccessorPtr

typedef ref_ptr<ExtraBodyStateAccessor> cnoid::ExtraBodyStateAccessorPtr

◆ FilePathVariableProcessorPtr

typedef ref_ptr<FilePathVariableProcessor> cnoid::FilePathVariableProcessorPtr

◆ FolderItemPtr

typedef ref_ptr<FolderItem> cnoid::FolderItemPtr

◆ ForceSensorPtr

typedef ref_ptr<ForceSensor> cnoid::ForceSensorPtr

◆ GetBodyCustomizerInterfaceFunc

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

◆ GLVisionSimulatorItemPtr

typedef ref_ptr<GLVisionSimulatorItem> cnoid::GLVisionSimulatorItemPtr

◆ GraphDataHandlerPtr

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

◆ HolderDevicePtr

typedef ref_ptr<HolderDevice> cnoid::HolderDevicePtr

◆ InteractiveCameraTransformPtr

typedef ref_ptr<InteractiveCameraTransform> cnoid::InteractiveCameraTransformPtr

◆ IoConnectionMapItemPtr

typedef ref_ptr<IoConnectionMapItem> cnoid::IoConnectionMapItemPtr

◆ IoConnectionMapPtr

typedef ref_ptr<IoConnectionMap> cnoid::IoConnectionMapPtr

◆ Isometry3

typedef Eigen::Isometry3d cnoid::Isometry3

◆ ItemAddonPtr

typedef ref_ptr<ItemAddon> cnoid::ItemAddonPtr

◆ ItemFileIOPtr

typedef ref_ptr<ItemFileIO> cnoid::ItemFileIOPtr

◆ ItemFunctionDispatcher

typedef PolymorphicItemFunctionSet::Dispatcher cnoid::ItemFunctionDispatcher

◆ ItemPtr

typedef ref_ptr<Item> cnoid::ItemPtr

◆ KinematicSimulatorItemPtr

typedef ref_ptr<KinematicSimulatorItem> cnoid::KinematicSimulatorItemPtr

◆ LeggedBodyHelperPtr

typedef ref_ptr<LeggedBodyHelper> cnoid::LeggedBodyHelperPtr

◆ LightingItemPtr

typedef ref_ptr<LightingItem> cnoid::LightingItemPtr

◆ LightPtr

typedef ref_ptr<Light> cnoid::LightPtr

◆ LinkGroupPtr

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

◆ LinkKinematicsKitPtr

typedef ref_ptr<LinkKinematicsKit> cnoid::LinkKinematicsKitPtr

◆ LinkOffsetFrameListItemPtr

typedef ref_ptr<LinkOffsetFrameListItem> cnoid::LinkOffsetFrameListItemPtr

◆ LinkPtr

typedef ref_ptr<Link> cnoid::LinkPtr

◆ LinkShapeOverwriteItemPtr

typedef ref_ptr<LinkShapeOverwriteItem> cnoid::LinkShapeOverwriteItemPtr

◆ ListingPtr

typedef ref_ptr<Listing> cnoid::ListingPtr

◆ LocationProxyPtr

typedef ref_ptr<LocationProxy> cnoid::LocationProxyPtr

◆ MappingPtr

typedef ref_ptr< Mapping > cnoid::MappingPtr

◆ MarkerDevicePtr

typedef ref_ptr<MarkerDevice> cnoid::MarkerDevicePtr

◆ MaterialPtr

typedef ref_ptr<Material> cnoid::MaterialPtr

◆ MaterialTablePtr

typedef ref_ptr<MaterialTable> cnoid::MaterialTablePtr

◆ Matrix2

typedef Eigen::Matrix2d cnoid::Matrix2

◆ Matrix3

typedef Eigen::Matrix3d cnoid::Matrix3

◆ Matrix4

typedef Eigen::Matrix4d cnoid::Matrix4

◆ MediaItemPtr

typedef ref_ptr<MediaItem> cnoid::MediaItemPtr

◆ MeshNormalGenerator

typedef MeshFilter cnoid::MeshNormalGenerator

◆ MessageLogItemPtr

typedef ref_ptr<MessageLogItem> cnoid::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

typedef ref_ptr<MprAssignStatement> cnoid::MprAssignStatementPtr

◆ MprCallStatementPtr

typedef ref_ptr<MprCallStatement> cnoid::MprCallStatementPtr

◆ MprCommentStatementPtr

typedef ref_ptr<MprCommentStatement> cnoid::MprCommentStatementPtr

◆ MprConditionStatementPtr

typedef ref_ptr<MprConditionStatement> cnoid::MprConditionStatementPtr

◆ MprControllerItemBasePtr

typedef ref_ptr<MprControllerItemBase> cnoid::MprControllerItemBasePtr

◆ MprControllerLogPtr

typedef ref_ptr<MprControllerLog> cnoid::MprControllerLogPtr

◆ MprDelayStatementPtr

typedef ref_ptr<MprDelayStatement> cnoid::MprDelayStatementPtr

◆ MprDummyStatementPtr

typedef ref_ptr<MprDummyStatement> cnoid::MprDummyStatementPtr

◆ MprEmptyStatementPtr

typedef ref_ptr<MprEmptyStatement> cnoid::MprEmptyStatementPtr

◆ MprFkPositionPtr

typedef ref_ptr<MprFkPosition> cnoid::MprFkPositionPtr

◆ MprGroupStatementPtr

typedef ref_ptr<MprGroupStatement> cnoid::MprGroupStatementPtr

◆ MprIfStatementPtr

typedef ref_ptr< MprIfStatement > cnoid::MprIfStatementPtr

◆ MprIkPositionPtr

typedef ref_ptr<MprIkPosition> cnoid::MprIkPositionPtr

◆ MprMultiVariableListItemPtr

typedef ref_ptr<MprMultiVariableListItem> cnoid::MprMultiVariableListItemPtr

◆ MprPositionListPtr

typedef ref_ptr<MprPositionList> cnoid::MprPositionListPtr

◆ MprPositionPtr

typedef ref_ptr<MprPosition> cnoid::MprPositionPtr

◆ MprPositionStatementPtr

typedef ref_ptr<MprPositionStatement> cnoid::MprPositionStatementPtr

◆ MprProgramItemBasePtr

typedef ref_ptr<MprProgramItemBase> cnoid::MprProgramItemBasePtr

◆ MprProgramPtr

typedef ref_ptr<MprProgram> cnoid::MprProgramPtr

◆ MprSignalStatementPtr

typedef ref_ptr<MprSignalStatement> cnoid::MprSignalStatementPtr

◆ MprStatementFunctionDispatcher

typedef PolymorphicMprStatementFunctionSet::Dispatcher cnoid::MprStatementFunctionDispatcher

◆ MprStatementPtr

typedef ref_ptr<MprStatement> cnoid::MprStatementPtr

◆ MprStructuredStatementPtr

typedef ref_ptr<MprStructuredStatement> cnoid::MprStructuredStatementPtr

◆ MprTagTraceStatementPtr

typedef ref_ptr<MprTagTraceStatement> cnoid::MprTagTraceStatementPtr

◆ MprVariableListPtr

typedef ref_ptr<MprVariableList> cnoid::MprVariableListPtr

◆ MprVariablePtr

typedef ref_ptr<MprVariable> cnoid::MprVariablePtr

◆ MprWaitStatementPtr

typedef ref_ptr<MprWaitStatement> cnoid::MprWaitStatementPtr

◆ MultiDeviceStateSeqItemPtr

typedef ref_ptr<MultiDeviceStateSeqItem> cnoid::MultiDeviceStateSeqItemPtr

◆ MultiPointSetItemPtr

typedef ref_ptr<MultiPointSetItem> cnoid::MultiPointSetItemPtr

◆ MultiSE3MatrixSeqItem

typedef MultiSeqItem<MultiSE3MatrixSeq> cnoid::MultiSE3MatrixSeqItem

◆ MultiSE3MatrixSeqItemPtr

typedef MultiSE3MatrixSeqItem::Ptr cnoid::MultiSE3MatrixSeqItemPtr

◆ MultiSE3SeqItem

typedef MultiSeqItem<MultiSE3Seq> cnoid::MultiSE3SeqItem

◆ MultiSE3SeqItemPtr

typedef MultiSE3SeqItem::Ptr cnoid::MultiSE3SeqItemPtr

◆ MultiValueSeqItem

typedef MultiSeqItem<MultiValueSeq> cnoid::MultiValueSeqItem

◆ MultiValueSeqItemPtr

typedef MultiValueSeqItem::Ptr cnoid::MultiValueSeqItemPtr

◆ PointLightPtr

typedef ref_ptr<PointLight> cnoid::PointLightPtr

◆ PointSetItemPtr

typedef ref_ptr<PointSetItem> cnoid::PointSetItemPtr

◆ Position

typedef Isometry3 cnoid::Position

◆ PositionDraggerPtr

typedef ref_ptr<PositionDragger> cnoid::PositionDraggerPtr

◆ PositionTagGroupItemPtr

typedef ref_ptr<PositionTagGroupItem> cnoid::PositionTagGroupItemPtr

◆ PositionTagGroupPtr

typedef ref_ptr<PositionTagGroup> cnoid::PositionTagGroupPtr

◆ PositionTagPtr

typedef ref_ptr<PositionTag> cnoid::PositionTagPtr

◆ PythonScriptItemPtr

typedef ref_ptr<PythonScriptItem> cnoid::PythonScriptItemPtr

◆ PythonSimScriptItemPtr

typedef ref_ptr<PythonSimScriptItem> cnoid::PythonSimScriptItemPtr

◆ Quat

typedef Eigen::Quaterniond cnoid::Quat

◆ Quaternion

typedef Eigen::Quaterniond cnoid::Quaternion

◆ RangeCameraPtr

typedef ref_ptr<RangeCamera> cnoid::RangeCameraPtr

◆ RangeSensorPtr

typedef ref_ptr<RangeSensor> cnoid::RangeSensorPtr

◆ RateGyroSensorPtr

typedef ref_ptr<RateGyroSensor> cnoid::RateGyroSensorPtr

◆ RectRegionMarkerPtr

typedef ref_ptr<RectRegionMarker> cnoid::RectRegionMarkerPtr

◆ ReferencedObjectSeqItemPtr

typedef ref_ptr<ReferencedObjectSeqItem> cnoid::ReferencedObjectSeqItemPtr

◆ ReferencedPtr

typedef ref_ptr<Referenced> cnoid::ReferencedPtr

◆ RootItemPtr

typedef ref_ptr<RootItem> cnoid::RootItemPtr

◆ SceneBodyPtr

typedef ref_ptr<SceneBody> cnoid::SceneBodyPtr

◆ SceneCollisionPtr

typedef ref_ptr<SceneCollision> cnoid::SceneCollisionPtr

◆ SceneDevicePtr

typedef ref_ptr<SceneDevice> cnoid::SceneDevicePtr

◆ SceneItemPtr

typedef ref_ptr<SceneItem> cnoid::SceneItemPtr

◆ SceneLinkPtr

typedef ref_ptr<SceneLink> cnoid::SceneLinkPtr

◆ SceneMarkerPtr

typedef ref_ptr<SceneMarker> cnoid::SceneMarkerPtr

◆ SceneProvider

typedef RenderableItem cnoid::SceneProvider

◆ SceneWidgetRootPtr

typedef ref_ptr<SceneWidgetRoot> cnoid::SceneWidgetRootPtr

◆ ScriptItemPtr

typedef ref_ptr<ScriptItem> cnoid::ScriptItemPtr

◆ SensorVisualizerItemPtr

typedef ref_ptr<SensorVisualizerItem> cnoid::SensorVisualizerItemPtr

◆ SFBool

typedef bool cnoid::SFBool

◆ SFColor

typedef Eigen::Vector3f cnoid::SFColor

◆ SFFloat

typedef double cnoid::SFFloat

◆ SFInt32

typedef int cnoid::SFInt32

◆ SFNode

typedef VRMLNodePtr cnoid::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

typedef ref_ptr<SgAffineTransform> cnoid::SgAffineTransformPtr

◆ SgBoundingBoxPtr

typedef ref_ptr<SgBoundingBox> cnoid::SgBoundingBoxPtr

◆ SgCameraPtr

typedef ref_ptr<SgCamera> cnoid::SgCameraPtr

◆ SgColorArray

typedef SgVectorArray<Vector3f> cnoid::SgColorArray

◆ SgColorArrayPtr

typedef ref_ptr<SgColorArray> cnoid::SgColorArrayPtr

◆ SgDirectionalLightPtr

typedef ref_ptr<SgDirectionalLight> cnoid::SgDirectionalLightPtr

◆ SgFixedPixelSizeGroupPtr

typedef ref_ptr<SgFixedPixelSizeGroup> cnoid::SgFixedPixelSizeGroupPtr

◆ SgFogPtr

typedef ref_ptr<SgFog> cnoid::SgFogPtr

◆ SgGroupPtr

typedef ref_ptr<SgGroup> cnoid::SgGroupPtr

◆ SgHighlightPtr

typedef ref_ptr<SgHighlight> cnoid::SgHighlightPtr

◆ SgImagePtr

typedef ref_ptr<SgImage> cnoid::SgImagePtr

◆ SgIndexArray

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

◆ SgInvariantGroupPtr

typedef ref_ptr<SgInvariantGroup> cnoid::SgInvariantGroupPtr

◆ SgLightPtr

typedef ref_ptr<SgLight> cnoid::SgLightPtr

◆ SgLightweightRenderingGroupPtr

typedef ref_ptr<SgLightweightRenderingGroup> cnoid::SgLightweightRenderingGroupPtr

◆ SgLineSetPtr

typedef ref_ptr<SgLineSet> cnoid::SgLineSetPtr

◆ SgMaterialPtr

typedef ref_ptr<SgMaterial> cnoid::SgMaterialPtr

◆ SgMeshBasePtr

typedef ref_ptr<SgMeshBase> cnoid::SgMeshBasePtr

◆ SgMeshPtr

typedef ref_ptr<SgMesh> cnoid::SgMeshPtr

◆ SgNodePath

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

◆ SgNodePtr

typedef ref_ptr<SgNode> cnoid::SgNodePtr

◆ SgNormalArray

typedef SgVectorArray<Vector3f> cnoid::SgNormalArray

◆ SgNormalArrayPtr

typedef ref_ptr<SgNormalArray> cnoid::SgNormalArrayPtr

◆ SgObjectPtr

typedef ref_ptr<SgObject> cnoid::SgObjectPtr

◆ SgOrthographicCameraPtr

typedef ref_ptr<SgOrthographicCamera> cnoid::SgOrthographicCameraPtr

◆ SgOutlinePtr

typedef ref_ptr<SgOutline> cnoid::SgOutlinePtr

◆ SgOverlayPtr

typedef ref_ptr<SgOverlay> cnoid::SgOverlayPtr

◆ SgPerspectiveCameraPtr

typedef ref_ptr<SgPerspectiveCamera> cnoid::SgPerspectiveCameraPtr

◆ SgPlotPtr

typedef ref_ptr<SgPlot> cnoid::SgPlotPtr

◆ SgPointLightPtr

typedef ref_ptr<SgPointLight> cnoid::SgPointLightPtr

◆ SgPointSetPtr

typedef ref_ptr<SgPointSet> cnoid::SgPointSetPtr

◆ SgPolygonDrawStylePtr

typedef ref_ptr<SgPolygonDrawStyle> cnoid::SgPolygonDrawStylePtr

◆ SgPolygonMeshPtr

typedef ref_ptr<SgPolygonMesh> cnoid::SgPolygonMeshPtr

◆ SgPosTransformPtr

typedef ref_ptr<SgPosTransform> cnoid::SgPosTransformPtr

◆ SgPreprocessedPtr

typedef ref_ptr<SgPreprocessed> cnoid::SgPreprocessedPtr

◆ SgScaleTransformPtr

typedef ref_ptr<SgScaleTransform> cnoid::SgScaleTransformPtr

◆ SgShapePtr

typedef ref_ptr<SgShape> cnoid::SgShapePtr

◆ SgSpotLightPtr

typedef ref_ptr<SgSpotLight> cnoid::SgSpotLightPtr

◆ SgSwitchableGroupPtr

typedef ref_ptr<SgSwitchableGroup> cnoid::SgSwitchableGroupPtr

◆ SgSwitchPtr

typedef ref_ptr<SgSwitch> cnoid::SgSwitchPtr

◆ SgTexCoordArray

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

◆ SgTexCoordArrayPtr

typedef ref_ptr<SgTexCoordArray> cnoid::SgTexCoordArrayPtr

◆ SgTexturePtr

typedef ref_ptr<SgTexture> cnoid::SgTexturePtr

◆ SgTextureTransformPtr

typedef ref_ptr<SgTextureTransform> cnoid::SgTextureTransformPtr

◆ SgTransformPtr

typedef ref_ptr<SgTransform> cnoid::SgTransformPtr

◆ SgTransparentGroupPtr

typedef ref_ptr<SgTransparentGroup> cnoid::SgTransparentGroupPtr

◆ SgUnpickableGroupPtr

typedef ref_ptr<SgUnpickableGroup> cnoid::SgUnpickableGroupPtr

◆ SgVertexArray

typedef SgVectorArray<Vector3f> cnoid::SgVertexArray

◆ SgVertexArrayPtr

typedef ref_ptr<SgVertexArray> cnoid::SgVertexArrayPtr

◆ SgViewportOverlayPtr

typedef ref_ptr<SgViewportOverlay> cnoid::SgViewportOverlayPtr

◆ SharedJoystickPtr

typedef ref_ptr<SharedJoystick> cnoid::SharedJoystickPtr

◆ SimpleControllerItemPtr

typedef ref_ptr<SimpleControllerItem> cnoid::SimpleControllerItemPtr

◆ SimulationBodyPtr

typedef ref_ptr<SimulationBody> cnoid::SimulationBodyPtr

◆ SimulationScriptItemPtr

typedef ref_ptr<SimulationScriptItem> cnoid::SimulationScriptItemPtr

◆ SimulatorItemPtr

typedef ref_ptr<SimulatorItem> cnoid::SimulatorItemPtr

◆ SphereMarkerPtr

typedef ref_ptr<SphereMarker> cnoid::SphereMarkerPtr

◆ SpotLightPtr

typedef ref_ptr<SpotLight> cnoid::SpotLightPtr

◆ SubProjectItemPtr

typedef ref_ptr<SubProjectItem> cnoid::SubProjectItemPtr

◆ SubSimulatorItemPtr

typedef ref_ptr<SubSimulatorItem> cnoid::SubSimulatorItemPtr

◆ TaskCommandPtr

typedef ref_ptr<TaskCommand> cnoid::TaskCommandPtr

◆ TaskFunc

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

◆ TaskPhaseProxyPtr

typedef ref_ptr<TaskPhaseProxy> cnoid::TaskPhaseProxyPtr

◆ TaskPhasePtr

typedef ref_ptr<TaskPhase> cnoid::TaskPhasePtr

◆ TaskPtr

typedef ref_ptr<Task> cnoid::TaskPtr

◆ TaskToggleStatePtr

typedef ref_ptr<TaskToggleState> cnoid::TaskToggleStatePtr

◆ TimeSyncItemEnginePtr

typedef ref_ptr<TimeSyncItemEngine> cnoid::TimeSyncItemEnginePtr

◆ Translation3

typedef Eigen::Translation3d cnoid::Translation3

◆ ValueNodePtr

typedef ref_ptr<ValueNode> cnoid::ValueNodePtr

◆ Vector2

typedef Eigen::Vector2d cnoid::Vector2

◆ Vector3

typedef Eigen::Vector3d cnoid::Vector3

◆ Vector3SeqItemPtr

typedef ref_ptr<Vector3SeqItem> cnoid::Vector3SeqItemPtr

◆ Vector4

typedef Eigen::Vector4d cnoid::Vector4

◆ Vector6

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

◆ VectorX

typedef Eigen::VectorXd cnoid::VectorX

◆ VRMLAccelerationSensorPtr

typedef ref_ptr<VRMLAccelerationSensor> cnoid::VRMLAccelerationSensorPtr

◆ VRMLAnchorPtr

typedef ref_ptr<VRMLAnchor> cnoid::VRMLAnchorPtr

◆ VRMLAppearancePtr

typedef ref_ptr<VRMLAppearance> cnoid::VRMLAppearancePtr

◆ VRMLBackgroundPtr

typedef ref_ptr<VRMLBackground> cnoid::VRMLBackgroundPtr

◆ VRMLBillboardPtr

typedef ref_ptr<VRMLBillboard> cnoid::VRMLBillboardPtr

◆ VRMLBoxPtr

typedef ref_ptr<VRMLBox> cnoid::VRMLBoxPtr

◆ VRMLCollisionPtr

typedef ref_ptr<VRMLCollision> cnoid::VRMLCollisionPtr

◆ VRMLColorPtr

typedef ref_ptr<VRMLColor> cnoid::VRMLColorPtr

◆ VRMLConePtr

typedef ref_ptr<VRMLCone> cnoid::VRMLConePtr

◆ VRMLCoordinatePtr

typedef ref_ptr<VRMLCoordinate> cnoid::VRMLCoordinatePtr

◆ VRMLCylinderPtr

typedef ref_ptr<VRMLCylinder> cnoid::VRMLCylinderPtr

◆ VRMLCylinderSensorPtr

typedef ref_ptr<VRMLCylinderSensor> cnoid::VRMLCylinderSensorPtr

◆ VRMLDirectionalLightPtr

typedef ref_ptr<VRMLDirectionalLight> cnoid::VRMLDirectionalLightPtr

◆ VRMLElevationGridPtr

typedef ref_ptr<VRMLElevationGrid> cnoid::VRMLElevationGridPtr

◆ VRMLExtrusionPtr

typedef ref_ptr<VRMLExtrusion> cnoid::VRMLExtrusionPtr

◆ VRMLFogPtr

typedef ref_ptr<VRMLFog> cnoid::VRMLFogPtr

◆ VRMLFontStylePtr

typedef ref_ptr<VRMLFontStyle> cnoid::VRMLFontStylePtr

◆ VRMLForceSensorPtr

typedef ref_ptr<VRMLForceSensor> cnoid::VRMLForceSensorPtr

◆ VRMLGeometryPtr

typedef ref_ptr<VRMLGeometry> cnoid::VRMLGeometryPtr

◆ VRMLGroupPtr

typedef ref_ptr<VRMLGroup> cnoid::VRMLGroupPtr

◆ VRMLGyroPtr

typedef ref_ptr<VRMLGyro> cnoid::VRMLGyroPtr

◆ VRMLHumanoidPtr

typedef ref_ptr<VRMLHumanoid> cnoid::VRMLHumanoidPtr

◆ VRMLImageTexturePtr

typedef ref_ptr<VRMLImageTexture> cnoid::VRMLImageTexturePtr

◆ VRMLIndexedFaceSetPtr

typedef ref_ptr<VRMLIndexedFaceSet> cnoid::VRMLIndexedFaceSetPtr

◆ VRMLIndexedLineSetPtr

typedef ref_ptr<VRMLIndexedLineSet> cnoid::VRMLIndexedLineSetPtr

◆ VRMLInlinePtr

typedef ref_ptr<VRMLInline> cnoid::VRMLInlinePtr

◆ VRMLJointPtr

typedef ref_ptr<VRMLJoint> cnoid::VRMLJointPtr

◆ VRMLLightPtr

typedef ref_ptr<VRMLLight> cnoid::VRMLLightPtr

◆ VRMLLODPtr

typedef ref_ptr<VRMLLOD> cnoid::VRMLLODPtr

◆ VRMLMaterialPtr

typedef ref_ptr<VRMLMaterial> cnoid::VRMLMaterialPtr

◆ VRMLMovieTexturePtr

typedef ref_ptr<VRMLMovieTexture> cnoid::VRMLMovieTexturePtr

◆ VRMLNavigationInfoPtr

typedef ref_ptr<VRMLNavigationInfo> cnoid::VRMLNavigationInfoPtr

◆ VRMLNodePtr

typedef ref_ptr<VRMLNode> cnoid::VRMLNodePtr

◆ VRMLNonVrmlInlinePtr

typedef ref_ptr<VRMLNonVrmlInline> cnoid::VRMLNonVrmlInlinePtr

◆ VRMLNormalPtr

typedef ref_ptr<VRMLNormal> cnoid::VRMLNormalPtr

◆ VRMLPixelTexturePtr

typedef ref_ptr<VRMLPixelTexture> cnoid::VRMLPixelTexturePtr

◆ VRMLPointLightPtr

typedef ref_ptr<VRMLPointLight> cnoid::VRMLPointLightPtr

◆ VRMLPointSetPtr

typedef ref_ptr<VRMLPointSet> cnoid::VRMLPointSetPtr

◆ VRMLProtoFieldMap

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

◆ VRMLProtoFieldPair

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

◆ VRMLProtoInstancePtr

typedef ref_ptr<VRMLProtoInstance> cnoid::VRMLProtoInstancePtr

◆ VRMLProtoPtr

typedef ref_ptr<VRMLProto> cnoid::VRMLProtoPtr

◆ VRMLRangeSensorPtr

typedef ref_ptr<VRMLRangeSensor> cnoid::VRMLRangeSensorPtr

◆ VRMLSegmentPtr

typedef ref_ptr<VRMLSegment> cnoid::VRMLSegmentPtr

◆ VRMLShapePtr

typedef ref_ptr<VRMLShape> cnoid::VRMLShapePtr

◆ VRMLSpherePtr

typedef ref_ptr<VRMLSphere> cnoid::VRMLSpherePtr

◆ VRMLSpotLightPtr

typedef ref_ptr<VRMLSpotLight> cnoid::VRMLSpotLightPtr

◆ VRMLSurfacePtr

typedef ref_ptr<VRMLSurface> cnoid::VRMLSurfacePtr

◆ VRMLSwitchPtr

typedef ref_ptr<VRMLSwitch> cnoid::VRMLSwitchPtr

◆ VRMLTextPtr

typedef ref_ptr<VRMLText> cnoid::VRMLTextPtr

◆ VRMLTextureCoordinatePtr

typedef ref_ptr<VRMLTextureCoordinate> cnoid::VRMLTextureCoordinatePtr

◆ VRMLTexturePtr

typedef ref_ptr<VRMLTexture> cnoid::VRMLTexturePtr

◆ VRMLTextureTransformPtr

typedef ref_ptr<VRMLTextureTransform> cnoid::VRMLTextureTransformPtr

◆ VRMLTransformPtr

typedef ref_ptr<VRMLTransform> cnoid::VRMLTransformPtr

◆ VRMLUnsupportedNodePtr

typedef ref_ptr<VRMLUnsupportedNode> cnoid::VRMLUnsupportedNodePtr

◆ VRMLVariantField

typedef stdx::variant< SFBool, SFInt32, SFFloat, SFVec2f, SFVec3f, SFRotation, SFColor, SFTime, SFString, SFNode, SFImage, MFInt32, MFFloat, MFVec2f, MFVec3f, MFRotation, MFColor, MFTime, MFString, MFNode> cnoid::VRMLVariantField

◆ VRMLViewpointPtr

typedef ref_ptr<VRMLViewpoint> cnoid::VRMLViewpointPtr

◆ VRMLVisionSensorPtr

typedef ref_ptr<VRMLVisionSensor> cnoid::VRMLVisionSensorPtr

◆ VRMLWorldInfoPtr

typedef ref_ptr<VRMLWorldInfo> cnoid::VRMLWorldInfoPtr

◆ WorldItemPtr

typedef ref_ptr<WorldItem> cnoid::WorldItemPtr

◆ WorldLogFileItemPtr

typedef ref_ptr<WorldLogFileItem> cnoid::WorldLogFileItemPtr

◆ ZMPSeqItemPtr

typedef ref_ptr<ZMPSeqItem> cnoid::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

enum cnoid::EmptyTokenPolicy

Enumerator
DROP_EMPTY_TOKENS
KEEP_EMPTY_TOKENS

◆ StringStyle

enum cnoid::StringStyle

Enumerator
PLAIN_STRING
SINGLE_QUOTED
DOUBLE_QUOTED
LITERAL_STRING
FOLDED_STRING

◆ VRMLFieldTypeId

enum cnoid::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

enum cnoid::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,
		T	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

base	link fixed to the environment
H	Angular 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

base	link fixed to the environment
J	CoM 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

Deprecated:: Use JointPath::getCustomPath instead of this.

◆ 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

pathString the 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 = false )

◆ 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	(	T	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

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ AbstractBodyLoaderPtr

◆ AbstractMultiSeqItemPtr

◆ AbstractSeqItemPtr

◆ AbstractTextItemPtr

◆ AbstractVRMLGroupPtr

◆ AccelerationSensorPtr

◆ Affine3

◆ AISTCollisionDetectorPtr

◆ AISTSimulatorItemPtr

◆ AngleAxis

◆ ArchivePtr

◆ AttachmentDevicePtr

◆ AudioItemPtr

◆ BodyContactPointLoggerItemPtr

◆ BodyCustomizerCalcAnalyticIkFunc

◆ BodyCustomizerCreateFunc

◆ BodyCustomizerDestroyFunc

◆ BodyCustomizerHandle

◆ BodyCustomizerInitializeAnalyticIkFunc

◆ BodyCustomizerSetVirtualJointForces2Func

◆ BodyCustomizerSetVirtualJointForcesFunc

◆ BodyElementOverwriteItemPtr

◆ BodyGetLinkDoubleValuePtrFunc

◆ BodyGetLinkIndexFromNameFunc

◆ BodyHandle

◆ BodyHandlerPtr

◆ BodyItemPtr

◆ BodyKinematicsEditRecordPtr

◆ BodyMotionControllerItemPtr

◆ BodyMotionEnginePtr

◆ BodyMotionItemPtr

◆ BodyPtr

◆ BodySuperimposerAddonPtr

◆ BodyTrackingCameraItemPtr

◆ BoundingBoxMarkerPtr

◆ CameraPtr

◆ ColdetModelPairPtr

◆ ColdetModelPtr

◆ CollisionArray

◆ CollisionDetectorPtr

◆ CollisionLinkPairList

◆ CollisionLinkPairPtr

◆ CollisionList

◆ 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

◆ error_info_message

◆ ExtCommandItemPtr

◆ ExtraBodyStateAccessorPtr

◆ FilePathVariableProcessorPtr