The agxSensor namespace contains components to model real-time sensors connected to the physics of AGX Dynamics. More...

Classes
class	Accelerometer
	Accelerometer instance class defined by a frame/transform and a model. More...

class	AccelerometerModel
	Base accelerometer model describing the fundamental parameters, such as measurement range and zero bias, of an accelerometer. More...

class	AccelerometerOutputHandler
	Handler responsible for how the accelerometer readings are assembled and provided to the user. More...

class	BinaryOutputBuffer
	Buffer used for sensor output of a wide range of output element types. More...

class	BinaryOutputView
	View for reading sections of a binary packed buffer of the specified template parameter type. More...

class	Camera
	Camera instance class defined by a frame/transform and a model. More...

struct	CameraBackend

class	CameraCMOSSensor
	A rectangular CMOS sensor for common digital cameras. More...

struct	CameraCMOSSensorManualExposureFlag

struct	CameraCMOSSensorParameters

class	CameraColorOutput
	Color image, or frame-by-frame video, output specification for a camera. More...

struct	CameraColorOutputParameters

class	CameraLens
	Base type for a camera lens systems attached to a camera. More...

class	CameraLensSingleElement
	A standard (non-anamorphic) camera lens (system) approximated as a single lens element. More...

struct	CameraLensSingleElementManualFocusFlag

struct	CameraLensSingleElementParameters

class	CameraModel
	Base camera model describing the fundamental components, such as the lens and the sensor of the camera. More...

class	CameraOutputHandler
	Handler responsible for how the camera readings are assembled and provided to the user. More...

class	CameraPhotodetector
	Base type for a photodetector (digital sensor or film) attached to a camera. More...

class	ConstraintAttachedSensor
	Common base type for all sensors attached to a constraint between two bodies. More...

class	DipoleMagneticField
	A magnetic field as produced by a magnetic dipole. More...

class	Encoder
	Encoder instance class defined by an attachment constraint and a model. More...

class	EncoderModel
	Base encoder model describing the fundamental parameters, such as cycle range and accumulation mode, of rotary encoders, linear encoders and faux potentiometers. More...

class	EncoderOutput
	Encoder sensor output data where EncoderOutput::Field is used to define the data available. More...

class	EncoderOutputHandler
	Handler responsible for how the encoder readings are assembled and provided to the user. More...

class	Environment
	Sensor environment implementation where different sensors collects data given a set of added objects, such as rigid bodies, geometries, shapes, wires, cables, terrains, etc. More...

class	FrameAttachedSensor
	Common base type for all sensors attached to a frame of reference, such as that of a rigid body. More...

class	Gyroscope
	Gyroscope instance class defined by a frame/transform and a model. More...

class	GyroscopeLinearAccelerationEffects
	Applies an offset to the zero rate bias depending on the linear acceleration that the gyroscope is exposed to. More...

class	GyroscopeLinearAccelerationEffectsNode
	Instance proxy node for storing the state information need by the gyroscope linear acceleration effects. More...

class	GyroscopeModel
	Base gyroscope model describing the fundamental parameters, such as measurement range and zero bias, of a gyroscope. More...

class	GyroscopeOutputHandler
	Handler responsible for how the gyroscope readings are assembled and provided to the user. More...

class	ICameraOutput
	Common interface for camera outputs containing the basics that can be assumed about a frame-based camera output. More...

class	IMonoaxialSignalCarrier
	Interface for types carrying a monoaxial signal. More...

class	IMonoaxialSignalNoiseNode
	Interface for implementation details for monoaxial signal system nodes carrying a random noise generator. More...

class	IMonoaxialSignalSystemNode
	Interface for implementation details for system nodes carrying a monoaxial signal. More...

class	IMU
	Inertial measurement unit (IMU) instance class defined by a frame/transform and a model. More...

class	IMUModel
	IMU model describing which sensors are attached on this certain kind of IMU. More...

class	IMUModelAccelerometerAttachment
	Accelerometer sensor attachment onto an IMU model. More...

class	IMUModelGyroscopeAttachment
	Gyroscope sensor attachment onto an IMU model. More...

class	IMUModelMagnetometerAttachment
	Magnetometer sensor attachment onto an IMU model. More...

class	IMUModelSensorAttachment
	Base type for specifying sensor attachments onto an IMU model. More...

struct	IMUModelSensorAttachmentSensorAttachment
	Specification of a sensor attachment onto the IMU. More...

class	IMUOutput
	IMU sensor output data where IMUOutput::Field is used to define the data available. More...

class	IMUOutputHandler
	Handler responsible for how the IMU readings are assembled and provided to the user. More...

class	IRtSystemNode
	Interface as RtSystemNode for model specific implementations that is part of the system tree of lidar instances. More...

class	ISensorOutput
	Common interface for sensor output data. More...

class	ISensorOutputHandler
	Common interface for sensor output handlers. More...

class	ISystemNodeProxy
	Interface for system node behavioral implementations intended to have multiple states/instances (SystemNodeProxy/ies) in the system graph. More...

class	ITriaxialSignalCarrier
	Interface for types carrying a triaxial signal. More...

class	ITriaxialSignalNoiseNode
	Interface for implementation details for triaxial signal system nodes carrying a random noise generator. More...

class	ITriaxialSignalSystemNode
	Interface for implementation details for system nodes carrying a triaxial signal. More...

class	LazyTrigger
	Type for triggering effects at a later point in time. More...

class	LensDistortion
	Base type for a lens distortion model specification. More...

class	LensDistortionBrownConrady
	Specification for the five parameter (k1, k2, k3, p1, p2) Brown-Conrady lens distortion model. More...

struct	LensDistortionBrownConradyCoefficients

class	Lidar
	Lidar instance class defined by a frame/transform and a model. More...

class	LidarFrameNode
	Lidar rays to world transform node. More...

class	LidarModel
	Base lidar model describing the fundamentals, such as ray pattern, range and beam properties, of a lidar. More...

class	LidarModelGeneric360HorizontalSweep
	A simple 360 degree sweeping lidar model of a vertical field of view of +/- 50 degrees and a resolution of 0.5 degrees in both the vertical and horizontal axis. More...

class	LidarModelGeneric360HorizontalSweep10Hz
	A very simple short-hand for creating a basic 360 degree horizontally sweeping lidar locked at the common lidar scanning frequency of 10 Hz. More...

class	LidarModelHorizontalSweep
	A lidar model defining a rotational lidar, scanning its surroundings by emitting racks of laser beams in a circular pattern around the lidar, based on a horizontal field of view. More...

class	LidarModelLivoxAvia
	Livox Avia is a mid-range 70 by 77 degree fov lidar with non-repeating pattern. More...

class	LidarModelLivoxHap
	Livox HAP is a mid-range 120 by 25 degree fov lidar with non-repeating pattern for automotive applications. More...

class	LidarModelLivoxHorizon
	Livox Horizon is a mid-to-long-range 82 by 25 degree fov lidar with non-repeating pattern. More...

class	LidarModelLivoxMid360
	Livox Mid360 is a short range 360 by 59 degree fov lidar with non-repeating pattern. More...

class	LidarModelLivoxMid40
	Livox Mid40 is a short-to-mid-range circular 38 degree fov lidar with non-repeating pattern. More...

class	LidarModelLivoxMid70
	Livox Mid70 is a short-to-mid-range circular 70 degree fov lidar with non-repeating pattern. More...

class	LidarModelLivoxTele
	Livox Tele is a long range 14 by 16 degree fov lidar with non-repeating pattern. More...

class	LidarModelMechanicalRotation
	Model of lidar that rotates laser emitter / reciever assembly continuously, with a given rotational frequency, vertical range, lidar ray range and horizontal / vertical resolution. More...

class	LidarModelOusterOS
	Simulation implementation of the Ouster OSx lidar model series - OS0, OS1, OS2. More...

class	LidarModelOusterOS0
	Specialized class for the Ouster OS0 lidar model. More...

class	LidarModelOusterOS1
	Specialized class for the Ouster OS1 lidar model. More...

class	LidarModelOusterOS2
	Specialized class for the Ouster OS2 lidar model. More...

class	LidarModelReadFromFile
	Model of lidar where the ray pattern is read directly from a file. More...

class	LidarProperties
	Properties/parameters of a lidar model. More...

class	LidarRayAngleGaussianNoise
	Gaussian distributed perturbation of lidar ray emission and detection angle. More...

class	LidarRayDistortion
	Base type for distortions applied to the lidar rays before raytrace. More...

class	LidarRayDistortionHandler
	Ray noise handler is responsible for all distortion application to rays before raytrace. More...

class	LidarRayPatternFromFile
	Ray pattern that is read from an external file (.csv or compact binary file). More...

class	LidarRayPatternGenerator
	Base of lidar ray pattern implementations responsible of providing a set of ray transforms (ray along z) and an interval each tick indexing into the set of ray transforms. More...

class	LidarRayPatternHorizontalSweep
	Horizontal sweep pattern generating transforms in a sweeping pattern given field of view and resolution. More...

struct	LidarRayPatternInterval
	Ray pattern interval (index range) with a start index and size. More...

class	LidarRayPatternSingleRay
	Ray pattern with only one single ray along the local z-axis of the Lidar using it. More...

class	LidarRayRange
	Start and end range of each lidar ray, default [0, "infinity"). More...

class	MagneticField
	Base type for the specification of the magnetic field in a sensor environment. More...

class	Magnetometer
	Magnetometer instance class defined by a frame/transform and a model. More...

class	MagnetometerModel
	Base magnetometer model describing the fundamental parameters, such as measurement range and zero flux bias, of an magnetometer. More...

class	MagnetometerOutputHandler
	Handler responsible for how the magnetometer readings are assembled and provided to the user. More...

struct	Matrix4x4

class	MonoaxialGaussianNoise
	Applies a total Gaussian noise to the monoaxial signal based on a specified noise RMS. More...

class	MonoaxialSignalNoiseNode
	A system node in the sensor processing tree carrying a monoaxial signal, a random noise generator and an implementation for how to apply the noise. More...

class	MonoaxialSignalResolution
	Applies resolution binning to a monoaxial signal. More...

class	MonoaxialSignalScaling
	Applies a constant scaling to the monoaxial signal. More...

class	MonoaxialSignalSystemNode
	A system node in the sensor processing tree carrying a monoaxial signal and an implementation for how to process it. More...

class	Odometer
	Odometer instance class defined by an attachment constraint and a model. More...

class	OdometerModel
	Base odometer model describing the fundamental parameters, such as wheel radius, of wheel encoder based odometers. More...

class	OdometerOutput
	Odometer sensor output data where OdometerOutput::Field is used to define the data available. More...

class	OdometerOutputHandler
	Handler responsible for how the odometer readings are assembled and provided to the user. More...

struct	RayFileDefinition

class	RtAmbientMaterial
	Ambient homogeneous atmospheric material attenuating the light and producing stochastic returns in the atmosphere. More...

class	RtBrdfExplicitMaterial
	Opaque surface material reflecting the light according to an explicitly specified bidirectional reflectance distribution function (BRDF). More...

class	RtConfig
	Utility functions used for configuration of the lower level raytracing functionality of agxSensor. More...

class	RtDistanceGaussianNoise
	This node applies a distance noise with gaussian distribution to the Lidar output data. More...

class	RtGgxAndOrenNayarMaterial
	Opaque surface material reflecting light according to the combined two-layer model with a specular GGX microfacet top-layer and a second microfacet Oren-Nayar diffuse layer. More...

class	RtLambertianOpaqueMaterial
	Opaque surface material reflecting the light according to the Lambertian model of diffuse reflectance. More...

class	RtMaterial
	Base type for all surface, and transmission, materials used in raytracing. More...

struct	RtMaterialHandle
	Material handle of implicit type in the raytrace environment. More...

struct	RtMaterialInstance
	Material instance in the raytrace environment, containing handle and type. More...

struct	RtNode
	A node performs a single operation, e.g., raycast, gaussian blur, merging etc. More...

class	RtNodeGroupHandler
	This node doesn't have a representation in the raytrace graph but manages adding and removal of children when this nodes parent is varying/optional. More...

class	RtOutput
	Raytrace output data where RtOutput::Field defines the data available. More...

class	RtOutputHandler
	Raytrace result handler is resposible for when and how the raytracing starts and ends and collecting/fetching data. More...

class	RtOutputNoise
	Defines a noise that is applied to Lidar output data. More...

class	RtRegistry
	Registry allowing value storage mapped to raytrace entities. More...

class	RtRemoveRayMisses
	This node will remove data from rays that doesn't hit any target. More...

struct	RtScene
	Raytrace scene with handle and ambient/atmospheric material. More...

struct	RtSceneHandle
	A scene constitutes the raytrace environment and contains a number of raytrace instances. More...

struct	RtShape
	Handle and interface for shapes in the raytrace environment (alias RtShapeHandle). More...

class	RtShapeCollisionShapeSystem
	Raytrace system representing agxCollide::Shape instances as mesh(es) in the raytrace environment. More...

class	RtShapeDeformableObjectSystem
	Raytrace system representing agxModel::DeformableObject. More...

struct	RtShapeInstance
	Raytrace shape instance data with a handle to the dito on the GPU, data and shape (ref-counting so that it's released when no instances uses the shape). More...

struct	RtShapeInstanceHandle
	Handle to an instance in the raytrace environment. More...

class	RtShapeLinkedStructureSystem
	Raytrace system representing agxSDK::LinkedStructure (agxCable::Cable, agxVehicle::Track agxModel::Beam, ...) instances as shapes in the raytrace environment. More...

class	RtShapeTerrainPagerSystem
	Raytrace system handling paged agxTerrain::Terrain instances. More...

class	RtShapeTerrainSystem
	Raytrace system handling agxTerrain::Terrain instances. More...

class	RtShapeTerrainSystemBase
	Base raytrace system handling ordinary and paged agxTerrain::Terrain instances. More...

class	RtShapeWireSystem
	Raytrace system representing agxWire::Wire instances as meshes in the raytrace environment. More...

class	RtStorage
	Storage vector mapping entity ID:s to corresponding values of the specified template type. More...

class	RtSurfaceMaterial
	Surface material of shape instances in the raytrace environment. More...

class	RtSystemNode
	A system node focused on raytracing. More...

class	RtSystemNodeProxy
	Raytrace system node acting as a clone of model specific implementations. More...

class	Sensor
	Common base type for all sensors sharing the same general agxSensor layout. More...

class	SensorGroupStepStride
	A group of sensors that steps at a lower rate compared to the environment, specified by the stride value. More...

class	SystemNode
	System node is a separate step/operation in an execution tree representing a sensor (or such) in a sensor simulation environment. More...

class	SystemNodeProxy
	Proxy system node, representing an instance of an ISystemNodeProxy in the system graph. More...

class	TriaxialCrossSensitivity
	Specification of cross sensitivity between tree axis. More...

class	TriaxialGaussianNoise
	Applies a total Gaussian noise to the triaxial signal based on a specified noise RMS. More...

class	TriaxialOutput
	Triaxial sensor output data where TriaxialOutput::Field is used to define the data available. More...

class	TriaxialOutputHandler
	Common base type for triaxial sensor output handlers. More...

class	TriaxialRange
	Range specification along three axis. More...

class	TriaxialSignalNoiseNode
	A system node in the sensor processing tree carrying a triaxial signal, a random noise generator and an implementation for how to apply the noise. More...

class	TriaxialSignalScaling
	Applies a constant scaling to the triaxial signal. More...

class	TriaxialSignalSystemNode
	A system node in the sensor processing tree carrying a triaxial signal and an implementation for how to process it. More...

class	TriaxialSpectralGaussianNoise
	Applies Gaussian noise to the triaxial signal based on a specified noise spectral density and the sample frequency of the signal. More...

class	UniformMagneticField
	A magnetic field with equal direction and strength across the entire sensor environment. More...

Typedefs
typedef agx::observer_ptr< const Accelerometer >	AccelerometerConstObserver

typedef agx::ref_ptr< const Accelerometer >	AccelerometerConstRef

typedef agx::observer_ptr< const AccelerometerModel >	AccelerometerModelConstObserver

typedef agx::ref_ptr< const AccelerometerModel >	AccelerometerModelConstRef

typedef agx::observer_ptr< AccelerometerModel >	AccelerometerModelObserver

typedef agx::ref_ptr< AccelerometerModel >	AccelerometerModelRef

typedef agx::observer_ptr< Accelerometer >	AccelerometerObserver

typedef agx::Vector< AccelerometerObserver >	AccelerometerObserverVector

typedef agx::observer_ptr< const AccelerometerOutputHandler >	AccelerometerOutputHandlerConstObserver

typedef agx::ref_ptr< const AccelerometerOutputHandler >	AccelerometerOutputHandlerConstRef

typedef agx::observer_ptr< AccelerometerOutputHandler >	AccelerometerOutputHandlerObserver

typedef agx::ref_ptr< AccelerometerOutputHandler >	AccelerometerOutputHandlerRef

typedef agx::VectorPOD< Accelerometer * >	AccelerometerPtrVector

typedef agx::ref_ptr< Accelerometer >	AccelerometerRef

typedef agx::Vector< AccelerometerRef >	AccelerometerRefVector

typedef agx::observer_ptr< const CameraCMOSSensor >	CameraCMOSSensorConstObserver

typedef agx::ref_ptr< const CameraCMOSSensor >	CameraCMOSSensorConstRef

typedef agx::observer_ptr< CameraCMOSSensor >	CameraCMOSSensorObserver

typedef agx::ref_ptr< CameraCMOSSensor >	CameraCMOSSensorRef

typedef agx::observer_ptr< const CameraColorOutput >	CameraColorOutputConstObserver

typedef agx::ref_ptr< const CameraColorOutput >	CameraColorOutputConstRef

typedef agx::observer_ptr< CameraColorOutput >	CameraColorOutputObserver

typedef agx::ref_ptr< CameraColorOutput >	CameraColorOutputRef

typedef agx::observer_ptr< const Camera >	CameraConstObserver

typedef agx::ref_ptr< const Camera >	CameraConstRef

typedef agx::observer_ptr< const CameraLens >	CameraLensConstObserver

typedef agx::ref_ptr< const CameraLens >	CameraLensConstRef

typedef agx::observer_ptr< CameraLens >	CameraLensObserver

typedef agx::ref_ptr< CameraLens >	CameraLensRef

typedef agx::observer_ptr< const CameraLensSingleElement >	CameraLensSingleElementConstObserver

typedef agx::ref_ptr< const CameraLensSingleElement >	CameraLensSingleElementConstRef

typedef agx::observer_ptr< CameraLensSingleElement >	CameraLensSingleElementObserver

typedef agx::ref_ptr< CameraLensSingleElement >	CameraLensSingleElementRef

typedef agx::observer_ptr< const CameraModel >	CameraModelConstObserver

typedef agx::ref_ptr< const CameraModel >	CameraModelConstRef

typedef agx::observer_ptr< CameraModel >	CameraModelObserver

typedef agx::ref_ptr< CameraModel >	CameraModelRef

typedef agx::observer_ptr< Camera >	CameraObserver

typedef agx::Vector< CameraObserver >	CameraObserverVector

typedef agx::observer_ptr< const CameraOutputHandler >	CameraOutputHandlerConstObserver

typedef agx::ref_ptr< const CameraOutputHandler >	CameraOutputHandlerConstRef

typedef agx::observer_ptr< CameraOutputHandler >	CameraOutputHandlerObserver

typedef agx::ref_ptr< CameraOutputHandler >	CameraOutputHandlerRef

typedef agx::observer_ptr< const CameraPhotodetector >	CameraPhotodetectorConstObserver

typedef agx::ref_ptr< const CameraPhotodetector >	CameraPhotodetectorConstRef

typedef agx::observer_ptr< CameraPhotodetector >	CameraPhotodetectorObserver

typedef agx::ref_ptr< CameraPhotodetector >	CameraPhotodetectorRef

typedef agx::VectorPOD< Camera * >	CameraPtrVector

typedef agx::ref_ptr< Camera >	CameraRef

typedef agx::Vector< CameraRef >	CameraRefVector

typedef agx::observer_ptr< const ConstraintAttachedSensor >	ConstraintAttachedSensorConstObserver

typedef agx::ref_ptr< const ConstraintAttachedSensor >	ConstraintAttachedSensorConstRef

typedef agx::observer_ptr< ConstraintAttachedSensor >	ConstraintAttachedSensorObserver

typedef agx::Vector< ConstraintAttachedSensorObserver >	ConstraintAttachedSensorObserverVector

typedef agx::VectorPOD< ConstraintAttachedSensor * >	ConstraintAttachedSensorPtrVector

typedef agx::ref_ptr< ConstraintAttachedSensor >	ConstraintAttachedSensorRef

typedef agx::Vector< ConstraintAttachedSensorRef >	ConstraintAttachedSensorRefVector

typedef agx::observer_ptr< const DipoleMagneticField >	DipoleMagneticFieldConstObserver

typedef agx::ref_ptr< const DipoleMagneticField >	DipoleMagneticFieldConstRef

typedef agx::observer_ptr< DipoleMagneticField >	DipoleMagneticFieldObserver

typedef agx::ref_ptr< DipoleMagneticField >	DipoleMagneticFieldRef

typedef agx::observer_ptr< const Encoder >	EncoderConstObserver

typedef agx::ref_ptr< const Encoder >	EncoderConstRef

typedef agx::observer_ptr< const EncoderModel >	EncoderModelConstObserver

typedef agx::ref_ptr< const EncoderModel >	EncoderModelConstRef

typedef agx::observer_ptr< EncoderModel >	EncoderModelObserver

typedef agx::ref_ptr< EncoderModel >	EncoderModelRef

typedef agx::observer_ptr< Encoder >	EncoderObserver

typedef agx::Vector< EncoderObserver >	EncoderObserverVector

typedef agx::observer_ptr< const EncoderOutput >	EncoderOutputConstObserver

typedef agx::ref_ptr< const EncoderOutput >	EncoderOutputConstRef

typedef agx::observer_ptr< const EncoderOutputHandler >	EncoderOutputHandlerConstObserver

typedef agx::ref_ptr< const EncoderOutputHandler >	EncoderOutputHandlerConstRef

typedef agx::observer_ptr< EncoderOutputHandler >	EncoderOutputHandlerObserver

typedef agx::ref_ptr< EncoderOutputHandler >	EncoderOutputHandlerRef

typedef agx::observer_ptr< EncoderOutput >	EncoderOutputObserver

typedef agx::ref_ptr< EncoderOutput >	EncoderOutputRef

typedef agx::VectorPOD< Encoder * >	EncoderPtrVector

typedef agx::ref_ptr< Encoder >	EncoderRef

typedef agx::Vector< EncoderRef >	EncoderRefVector

typedef agx::observer_ptr< const Environment >	EnvironmentConstObserver

typedef agx::ref_ptr< const Environment >	EnvironmentConstRef

typedef agx::observer_ptr< Environment >	EnvironmentObserver

typedef agx::ref_ptr< Environment >	EnvironmentRef

typedef agx::observer_ptr< const FrameAttachedSensor >	FrameAttachedSensorConstObserver

typedef agx::ref_ptr< const FrameAttachedSensor >	FrameAttachedSensorConstRef

typedef agx::observer_ptr< FrameAttachedSensor >	FrameAttachedSensorObserver

typedef agx::Vector< FrameAttachedSensorObserver >	FrameAttachedSensorObserverVector

typedef agx::VectorPOD< FrameAttachedSensor * >	FrameAttachedSensorPtrVector

typedef agx::ref_ptr< FrameAttachedSensor >	FrameAttachedSensorRef

typedef agx::Vector< FrameAttachedSensorRef >	FrameAttachedSensorRefVector

typedef agx::observer_ptr< const Gyroscope >	GyroscopeConstObserver

typedef agx::ref_ptr< const Gyroscope >	GyroscopeConstRef

typedef agx::observer_ptr< const GyroscopeLinearAccelerationEffects >	GyroscopeLinearAccelerationEffectsConstObserver

typedef agx::ref_ptr< const GyroscopeLinearAccelerationEffects >	GyroscopeLinearAccelerationEffectsConstRef

typedef agx::observer_ptr< const GyroscopeLinearAccelerationEffectsNode >	GyroscopeLinearAccelerationEffectsNodeConstObserver

typedef agx::ref_ptr< const GyroscopeLinearAccelerationEffectsNode >	GyroscopeLinearAccelerationEffectsNodeConstRef

typedef agx::observer_ptr< GyroscopeLinearAccelerationEffectsNode >	GyroscopeLinearAccelerationEffectsNodeObserver

typedef agx::ref_ptr< GyroscopeLinearAccelerationEffectsNode >	GyroscopeLinearAccelerationEffectsNodeRef

typedef agx::observer_ptr< GyroscopeLinearAccelerationEffects >	GyroscopeLinearAccelerationEffectsObserver

typedef agx::ref_ptr< GyroscopeLinearAccelerationEffects >	GyroscopeLinearAccelerationEffectsRef

typedef agx::observer_ptr< const GyroscopeModel >	GyroscopeModelConstObserver

typedef agx::ref_ptr< const GyroscopeModel >	GyroscopeModelConstRef

typedef agx::observer_ptr< GyroscopeModel >	GyroscopeModelObserver

typedef agx::ref_ptr< GyroscopeModel >	GyroscopeModelRef

typedef agx::observer_ptr< Gyroscope >	GyroscopeObserver

typedef agx::Vector< GyroscopeObserver >	GyroscopeObserverVector

typedef agx::observer_ptr< const GyroscopeOutputHandler >	GyroscopeOutputHandlerConstObserver

typedef agx::ref_ptr< const GyroscopeOutputHandler >	GyroscopeOutputHandlerConstRef

typedef agx::observer_ptr< GyroscopeOutputHandler >	GyroscopeOutputHandlerObserver

typedef agx::ref_ptr< GyroscopeOutputHandler >	GyroscopeOutputHandlerRef

typedef agx::VectorPOD< Gyroscope * >	GyroscopePtrVector

typedef agx::ref_ptr< Gyroscope >	GyroscopeRef

typedef agx::Vector< GyroscopeRef >	GyroscopeRefVector

typedef agx::observer_ptr< const ICameraOutput >	ICameraOutputConstObserver

typedef agx::ref_ptr< const ICameraOutput >	ICameraOutputConstRef

typedef agx::observer_ptr< ICameraOutput >	ICameraOutputObserver

typedef agx::ref_ptr< ICameraOutput >	ICameraOutputRef

typedef agx::observer_ptr< const IMonoaxialSignalNoiseNode >	IMonoaxialSignalNoiseNodeConstObserver

typedef agx::ref_ptr< const IMonoaxialSignalNoiseNode >	IMonoaxialSignalNoiseNodeConstRef

typedef agx::observer_ptr< IMonoaxialSignalNoiseNode >	IMonoaxialSignalNoiseNodeObserver

typedef agx::ref_ptr< IMonoaxialSignalNoiseNode >	IMonoaxialSignalNoiseNodeRef

typedef agx::observer_ptr< const IMonoaxialSignalSystemNode >	IMonoaxialSignalSystemNodeConstObserver

typedef agx::ref_ptr< const IMonoaxialSignalSystemNode >	IMonoaxialSignalSystemNodeConstRef

typedef agx::observer_ptr< IMonoaxialSignalSystemNode >	IMonoaxialSignalSystemNodeObserver

typedef agx::Vector< IMonoaxialSignalSystemNodeObserver >	IMonoaxialSignalSystemNodeObserverVector

typedef agx::VectorPOD< IMonoaxialSignalSystemNode * >	IMonoaxialSignalSystemNodePtrVector

typedef agx::ref_ptr< IMonoaxialSignalSystemNode >	IMonoaxialSignalSystemNodeRef

typedef agx::Vector< IMonoaxialSignalSystemNodeRef >	IMonoaxialSignalSystemNodeRefVector

typedef agx::observer_ptr< const IMU >	IMUConstObserver

typedef agx::ref_ptr< const IMU >	IMUConstRef

typedef agx::observer_ptr< const IMUModelAccelerometerAttachment >	IMUModelAccelerometerAttachmentConstObserver

typedef agx::ref_ptr< const IMUModelAccelerometerAttachment >	IMUModelAccelerometerAttachmentConstRef

typedef agx::observer_ptr< IMUModelAccelerometerAttachment >	IMUModelAccelerometerAttachmentObserver

typedef agx::ref_ptr< IMUModelAccelerometerAttachment >	IMUModelAccelerometerAttachmentRef

typedef agx::observer_ptr< const IMUModel >	IMUModelConstObserver

typedef agx::ref_ptr< const IMUModel >	IMUModelConstRef

typedef agx::observer_ptr< const IMUModelGyroscopeAttachment >	IMUModelGyroscopeAttachmentConstObserver

typedef agx::ref_ptr< const IMUModelGyroscopeAttachment >	IMUModelGyroscopeAttachmentConstRef

typedef agx::observer_ptr< IMUModelGyroscopeAttachment >	IMUModelGyroscopeAttachmentObserver

typedef agx::ref_ptr< IMUModelGyroscopeAttachment >	IMUModelGyroscopeAttachmentRef

typedef agx::observer_ptr< const IMUModelMagnetometerAttachment >	IMUModelMagnetometerAttachmentConstObserver

typedef agx::ref_ptr< const IMUModelMagnetometerAttachment >	IMUModelMagnetometerAttachmentConstRef

typedef agx::observer_ptr< IMUModelMagnetometerAttachment >	IMUModelMagnetometerAttachmentObserver

typedef agx::ref_ptr< IMUModelMagnetometerAttachment >	IMUModelMagnetometerAttachmentRef

typedef agx::observer_ptr< IMUModel >	IMUModelObserver

typedef agx::ref_ptr< IMUModel >	IMUModelRef

typedef agx::observer_ptr< const IMUModelSensorAttachment >	IMUModelSensorAttachmentConstObserver

typedef agx::ref_ptr< const IMUModelSensorAttachment >	IMUModelSensorAttachmentConstRef

typedef agx::observer_ptr< IMUModelSensorAttachment >	IMUModelSensorAttachmentObserver

typedef agx::Vector< IMUModelSensorAttachmentObserver >	IMUModelSensorAttachmentObserverVector

typedef agx::VectorPOD< IMUModelSensorAttachment * >	IMUModelSensorAttachmentPtrVector

typedef agx::ref_ptr< IMUModelSensorAttachment >	IMUModelSensorAttachmentRef

typedef agx::Vector< IMUModelSensorAttachmentRef >	IMUModelSensorAttachmentRefVector

typedef agx::observer_ptr< IMU >	IMUObserver

typedef agx::Vector< IMUObserver >	IMUObserverVector

typedef agx::observer_ptr< const IMUOutput >	IMUOutputConstObserver

typedef agx::ref_ptr< const IMUOutput >	IMUOutputConstRef

typedef agx::observer_ptr< const IMUOutputHandler >	IMUOutputHandlerConstObserver

typedef agx::ref_ptr< const IMUOutputHandler >	IMUOutputHandlerConstRef

typedef agx::observer_ptr< IMUOutputHandler >	IMUOutputHandlerObserver

typedef agx::ref_ptr< IMUOutputHandler >	IMUOutputHandlerRef

typedef agx::observer_ptr< IMUOutput >	IMUOutputObserver

typedef agx::ref_ptr< IMUOutput >	IMUOutputRef

typedef agx::VectorPOD< IMU * >	IMUPtrVector

typedef agx::ref_ptr< IMU >	IMURef

typedef agx::Vector< IMURef >	IMURefVector

typedef agx::observer_ptr< const IRtSystemNode >	IRtSystemNodeConstObserver

typedef agx::ref_ptr< const IRtSystemNode >	IRtSystemNodeConstRef

typedef agx::observer_ptr< IRtSystemNode >	IRtSystemNodeObserver

typedef agx::ref_ptr< IRtSystemNode >	IRtSystemNodeRef

typedef agx::observer_ptr< const ISystemNodeProxy >	ISystemNodeProxyConstObserver

typedef agx::ref_ptr< const ISystemNodeProxy >	ISystemNodeProxyConstRef

typedef agx::observer_ptr< ISystemNodeProxy >	ISystemNodeProxyObserver

typedef agx::Vector< ISystemNodeProxyObserver >	ISystemNodeProxyObserverVector

typedef agx::VectorPOD< ISystemNodeProxy * >	ISystemNodeProxyPtrVector

typedef agx::ref_ptr< ISystemNodeProxy >	ISystemNodeProxyRef

typedef agx::Vector< ISystemNodeProxyRef >	ISystemNodeProxyRefVector

typedef agx::observer_ptr< const ITriaxialSignalNoiseNode >	ITriaxialSignalNoiseNodeConstObserver

typedef agx::ref_ptr< const ITriaxialSignalNoiseNode >	ITriaxialSignalNoiseNodeConstRef

typedef agx::observer_ptr< ITriaxialSignalNoiseNode >	ITriaxialSignalNoiseNodeObserver

typedef agx::ref_ptr< ITriaxialSignalNoiseNode >	ITriaxialSignalNoiseNodeRef

typedef agx::observer_ptr< const ITriaxialSignalSystemNode >	ITriaxialSignalSystemNodeConstObserver

typedef agx::ref_ptr< const ITriaxialSignalSystemNode >	ITriaxialSignalSystemNodeConstRef

typedef agx::observer_ptr< ITriaxialSignalSystemNode >	ITriaxialSignalSystemNodeObserver

typedef agx::Vector< ITriaxialSignalSystemNodeObserver >	ITriaxialSignalSystemNodeObserverVector

typedef agx::VectorPOD< ITriaxialSignalSystemNode * >	ITriaxialSignalSystemNodePtrVector

typedef agx::ref_ptr< ITriaxialSignalSystemNode >	ITriaxialSignalSystemNodeRef

typedef agx::Vector< ITriaxialSignalSystemNodeRef >	ITriaxialSignalSystemNodeRefVector

typedef agx::observer_ptr< const LensDistortionBrownConrady >	LensDistortionBrownConradyConstObserver

typedef agx::ref_ptr< const LensDistortionBrownConrady >	LensDistortionBrownConradyConstRef

typedef agx::observer_ptr< LensDistortionBrownConrady >	LensDistortionBrownConradyObserver

typedef agx::ref_ptr< LensDistortionBrownConrady >	LensDistortionBrownConradyRef

typedef agx::observer_ptr< const LensDistortion >	LensDistortionConstObserver

typedef agx::ref_ptr< const LensDistortion >	LensDistortionConstRef

typedef agx::observer_ptr< LensDistortion >	LensDistortionObserver

typedef agx::ref_ptr< LensDistortion >	LensDistortionRef

typedef agx::observer_ptr< const Lidar >	LidarConstObserver

typedef agx::ref_ptr< const Lidar >	LidarConstRef

typedef agx::observer_ptr< const LidarFrameNode >	LidarFrameNodeConstObserver

typedef agx::ref_ptr< const LidarFrameNode >	LidarFrameNodeConstRef

typedef agx::observer_ptr< LidarFrameNode >	LidarFrameNodeObserver

typedef agx::ref_ptr< LidarFrameNode >	LidarFrameNodeRef

typedef agx::observer_ptr< const LidarModel >	LidarModelConstObserver

typedef agx::ref_ptr< const LidarModel >	LidarModelConstRef

typedef agx::observer_ptr< const LidarModelGeneric360HorizontalSweep10Hz >	LidarModelGeneric360HorizontalSweep10HzConstObserver

typedef agx::ref_ptr< const LidarModelGeneric360HorizontalSweep10Hz >	LidarModelGeneric360HorizontalSweep10HzConstRef

typedef agx::observer_ptr< LidarModelGeneric360HorizontalSweep10Hz >	LidarModelGeneric360HorizontalSweep10HzObserver

typedef agx::ref_ptr< LidarModelGeneric360HorizontalSweep10Hz >	LidarModelGeneric360HorizontalSweep10HzRef

typedef agx::observer_ptr< const LidarModelHorizontalSweep >	LidarModelHorizontalSweepConstObserver

typedef agx::ref_ptr< const LidarModelHorizontalSweep >	LidarModelHorizontalSweepConstRef

typedef agx::observer_ptr< LidarModelHorizontalSweep >	LidarModelHorizontalSweepObserver

typedef agx::ref_ptr< LidarModelHorizontalSweep >	LidarModelHorizontalSweepRef

typedef agx::observer_ptr< const LidarModelMechanicalRotation >	LidarModelMechanicalRotationConstObserver

typedef agx::ref_ptr< const LidarModelMechanicalRotation >	LidarModelMechanicalRotationConstRef

typedef agx::observer_ptr< LidarModelMechanicalRotation >	LidarModelMechanicalRotationObserver

typedef agx::ref_ptr< LidarModelMechanicalRotation >	LidarModelMechanicalRotationRef

typedef agx::observer_ptr< LidarModel >	LidarModelObserver

typedef agx::observer_ptr< const LidarModelReadFromFile >	LidarModelReadFromFileConstObserver

typedef agx::ref_ptr< const LidarModelReadFromFile >	LidarModelReadFromFileConstRef

typedef agx::observer_ptr< LidarModelReadFromFile >	LidarModelReadFromFileObserver

typedef agx::ref_ptr< LidarModelReadFromFile >	LidarModelReadFromFileRef

typedef agx::ref_ptr< LidarModel >	LidarModelRef

typedef agx::observer_ptr< Lidar >	LidarObserver

typedef agx::Vector< LidarObserver >	LidarObserverVector

typedef agx::observer_ptr< const LidarProperties >	LidarPropertiesConstObserver

typedef agx::ref_ptr< const LidarProperties >	LidarPropertiesConstRef

typedef agx::observer_ptr< LidarProperties >	LidarPropertiesObserver

typedef agx::ref_ptr< LidarProperties >	LidarPropertiesRef

typedef agx::VectorPOD< Lidar * >	LidarPtrVector

typedef agx::observer_ptr< const LidarRayAngleGaussianNoise >	LidarRayAngleGaussianNoiseConstObserver

typedef agx::ref_ptr< const LidarRayAngleGaussianNoise >	LidarRayAngleGaussianNoiseConstRef

typedef agx::observer_ptr< LidarRayAngleGaussianNoise >	LidarRayAngleGaussianNoiseObserver

typedef agx::ref_ptr< LidarRayAngleGaussianNoise >	LidarRayAngleGaussianNoiseRef

typedef agx::observer_ptr< const LidarRayDistortion >	LidarRayDistortionConstObserver

typedef agx::ref_ptr< const LidarRayDistortion >	LidarRayDistortionConstRef

typedef agx::observer_ptr< const LidarRayDistortionHandler >	LidarRayDistortionHandlerConstObserver

typedef agx::ref_ptr< const LidarRayDistortionHandler >	LidarRayDistortionHandlerConstRef

typedef agx::observer_ptr< LidarRayDistortionHandler >	LidarRayDistortionHandlerObserver

typedef agx::ref_ptr< LidarRayDistortionHandler >	LidarRayDistortionHandlerRef

typedef agx::observer_ptr< LidarRayDistortion >	LidarRayDistortionObserver

typedef agx::Vector< LidarRayDistortionObserver >	LidarRayDistortionObserverVector

typedef agx::VectorPOD< LidarRayDistortion * >	LidarRayDistortionPtrVector

typedef agx::ref_ptr< LidarRayDistortion >	LidarRayDistortionRef

typedef agx::Vector< LidarRayDistortionRef >	LidarRayDistortionRefVector

typedef agx::observer_ptr< const LidarRayPatternFromFile >	LidarRayPatternFromFileConstObserver

typedef agx::ref_ptr< const LidarRayPatternFromFile >	LidarRayPatternFromFileConstRef

typedef agx::observer_ptr< LidarRayPatternFromFile >	LidarRayPatternFromFileObserver

typedef agx::ref_ptr< LidarRayPatternFromFile >	LidarRayPatternFromFileRef

typedef agx::observer_ptr< const LidarRayPatternGenerator >	LidarRayPatternGeneratorConstObserver

typedef agx::ref_ptr< const LidarRayPatternGenerator >	LidarRayPatternGeneratorConstRef

typedef agx::observer_ptr< LidarRayPatternGenerator >	LidarRayPatternGeneratorObserver

typedef agx::ref_ptr< LidarRayPatternGenerator >	LidarRayPatternGeneratorRef

typedef agx::observer_ptr< const LidarRayRange >	LidarRayRangeConstObserver

typedef agx::ref_ptr< const LidarRayRange >	LidarRayRangeConstRef

typedef agx::observer_ptr< LidarRayRange >	LidarRayRangeObserver

typedef agx::ref_ptr< LidarRayRange >	LidarRayRangeRef

typedef agx::ref_ptr< Lidar >	LidarRef

typedef agx::Vector< LidarRef >	LidarRefVector

typedef agx::observer_ptr< const MagneticField >	MagneticFieldConstObserver

typedef agx::ref_ptr< const MagneticField >	MagneticFieldConstRef

typedef agx::observer_ptr< MagneticField >	MagneticFieldObserver

typedef agx::ref_ptr< MagneticField >	MagneticFieldRef

typedef agx::observer_ptr< const Magnetometer >	MagnetometerConstObserver

typedef agx::ref_ptr< const Magnetometer >	MagnetometerConstRef

typedef agx::observer_ptr< const MagnetometerModel >	MagnetometerModelConstObserver

typedef agx::ref_ptr< const MagnetometerModel >	MagnetometerModelConstRef

typedef agx::observer_ptr< MagnetometerModel >	MagnetometerModelObserver

typedef agx::ref_ptr< MagnetometerModel >	MagnetometerModelRef

typedef agx::observer_ptr< Magnetometer >	MagnetometerObserver

typedef agx::Vector< MagnetometerObserver >	MagnetometerObserverVector

typedef agx::observer_ptr< const MagnetometerOutputHandler >	MagnetometerOutputHandlerConstObserver

typedef agx::ref_ptr< const MagnetometerOutputHandler >	MagnetometerOutputHandlerConstRef

typedef agx::observer_ptr< MagnetometerOutputHandler >	MagnetometerOutputHandlerObserver

typedef agx::ref_ptr< MagnetometerOutputHandler >	MagnetometerOutputHandlerRef

typedef agx::VectorPOD< Magnetometer * >	MagnetometerPtrVector

typedef agx::ref_ptr< Magnetometer >	MagnetometerRef

typedef agx::Vector< MagnetometerRef >	MagnetometerRefVector

typedef agx::observer_ptr< const MonoaxialGaussianNoise >	MonoaxialGaussianNoiseConstObserver

typedef agx::ref_ptr< const MonoaxialGaussianNoise >	MonoaxialGaussianNoiseConstRef

typedef agx::observer_ptr< MonoaxialGaussianNoise >	MonoaxialGaussianNoiseObserver

typedef agx::ref_ptr< MonoaxialGaussianNoise >	MonoaxialGaussianNoiseRef

typedef agx::observer_ptr< const MonoaxialSignalNoiseNode >	MonoaxialSignalNoiseNodeConstObserver

typedef agx::ref_ptr< const MonoaxialSignalNoiseNode >	MonoaxialSignalNoiseNodeConstRef

typedef agx::observer_ptr< MonoaxialSignalNoiseNode >	MonoaxialSignalNoiseNodeObserver

typedef agx::Vector< MonoaxialSignalNoiseNodeObserver >	MonoaxialSignalNoiseNodeObserverVector

typedef agx::VectorPOD< MonoaxialSignalNoiseNode * >	MonoaxialSignalNoiseNodePtrVector

typedef agx::ref_ptr< MonoaxialSignalNoiseNode >	MonoaxialSignalNoiseNodeRef

typedef agx::Vector< MonoaxialSignalNoiseNodeRef >	MonoaxialSignalNoiseNodeRefVector

typedef agx::observer_ptr< const MonoaxialSignalResolution >	MonoaxialSignalResolutionConstObserver

typedef agx::ref_ptr< const MonoaxialSignalResolution >	MonoaxialSignalResolutionConstRef

typedef agx::observer_ptr< MonoaxialSignalResolution >	MonoaxialSignalResolutionObserver

typedef agx::ref_ptr< MonoaxialSignalResolution >	MonoaxialSignalResolutionRef

typedef agx::observer_ptr< const MonoaxialSignalScaling >	MonoaxialSignalScalingConstObserver

typedef agx::ref_ptr< const MonoaxialSignalScaling >	MonoaxialSignalScalingConstRef

typedef agx::observer_ptr< MonoaxialSignalScaling >	MonoaxialSignalScalingObserver

typedef agx::ref_ptr< MonoaxialSignalScaling >	MonoaxialSignalScalingRef

typedef agx::observer_ptr< const MonoaxialSignalSystemNode >	MonoaxialSignalSystemNodeConstObserver

typedef agx::ref_ptr< const MonoaxialSignalSystemNode >	MonoaxialSignalSystemNodeConstRef

typedef agx::observer_ptr< MonoaxialSignalSystemNode >	MonoaxialSignalSystemNodeObserver

typedef agx::Vector< MonoaxialSignalSystemNodeObserver >	MonoaxialSignalSystemNodeObserverVector

typedef agx::VectorPOD< MonoaxialSignalSystemNode * >	MonoaxialSignalSystemNodePtrVector

typedef agx::ref_ptr< MonoaxialSignalSystemNode >	MonoaxialSignalSystemNodeRef

typedef agx::Vector< MonoaxialSignalSystemNodeRef >	MonoaxialSignalSystemNodeRefVector

typedef agx::observer_ptr< const Odometer >	OdometerConstObserver

typedef agx::ref_ptr< const Odometer >	OdometerConstRef

typedef agx::observer_ptr< const OdometerModel >	OdometerModelConstObserver

typedef agx::ref_ptr< const OdometerModel >	OdometerModelConstRef

typedef agx::observer_ptr< OdometerModel >	OdometerModelObserver

typedef agx::ref_ptr< OdometerModel >	OdometerModelRef

typedef agx::observer_ptr< Odometer >	OdometerObserver

typedef agx::Vector< OdometerObserver >	OdometerObserverVector

typedef agx::observer_ptr< const OdometerOutput >	OdometerOutputConstObserver

typedef agx::ref_ptr< const OdometerOutput >	OdometerOutputConstRef

typedef agx::observer_ptr< const OdometerOutputHandler >	OdometerOutputHandlerConstObserver

typedef agx::ref_ptr< const OdometerOutputHandler >	OdometerOutputHandlerConstRef

typedef agx::observer_ptr< OdometerOutputHandler >	OdometerOutputHandlerObserver

typedef agx::ref_ptr< OdometerOutputHandler >	OdometerOutputHandlerRef

typedef agx::observer_ptr< OdometerOutput >	OdometerOutputObserver

typedef agx::ref_ptr< OdometerOutput >	OdometerOutputRef

typedef agx::VectorPOD< Odometer * >	OdometerPtrVector

typedef agx::ref_ptr< Odometer >	OdometerRef

typedef agx::Vector< OdometerRef >	OdometerRefVector

using	OptionalDynamicRange = std::optional< agx::Real >

using	OptionalEncoderOutputMapping = std::optional< std::pair< size_t, EncoderOutput * > >

using	OptionalExposureCompensation = std::optional< agx::Real >

using	OptionalFocusDistance = std::optional< agx::Real >

using	OptionalFocusMinimumDistance = std::optional< agx::Real >

using	OptionalFramerate = std::optional< agx::Real >

using	OptionalIMUOutputMappnig = std::optional< std::pair< size_t, IMUOutput * > >

using	OptionalOdometerOutputMapping = std::optional< std::pair< size_t, OdometerOutput * > >

using	OptionalTriaxialOutputMapping = std::optional< std::pair< size_t, TriaxialOutput * > >

using	OptionalUniqueId = std::optional< size_t >

typedef agx::observer_ptr< const RtDistanceGaussianNoise >	RtDistanceGaussianNoiseConstObserver

typedef agx::ref_ptr< const RtDistanceGaussianNoise >	RtDistanceGaussianNoiseConstRef

typedef agx::observer_ptr< RtDistanceGaussianNoise >	RtDistanceGaussianNoiseObserver

typedef agx::ref_ptr< RtDistanceGaussianNoise >	RtDistanceGaussianNoiseRef

using	RtEntityIdIndex = std::underlying_type_t< RtEntityId >
	Index type of entity ids.

using	RtMaterialHandleRef = std::shared_ptr< RtMaterialHandle >

typedef agx::observer_ptr< const RtOutput >	RtOutputConstObserver

typedef agx::ref_ptr< const RtOutput >	RtOutputConstRef

typedef agx::observer_ptr< const RtOutputHandler >	RtOutputHandlerConstObserver

typedef agx::ref_ptr< const RtOutputHandler >	RtOutputHandlerConstRef

typedef agx::observer_ptr< RtOutputHandler >	RtOutputHandlerObserver

typedef agx::ref_ptr< RtOutputHandler >	RtOutputHandlerRef

typedef agx::observer_ptr< const RtOutputNoise >	RtOutputNoiseConstObserver

typedef agx::ref_ptr< const RtOutputNoise >	RtOutputNoiseConstRef

typedef agx::observer_ptr< RtOutputNoise >	RtOutputNoiseObserver

typedef agx::Vector< RtOutputNoiseObserver >	RtOutputNoiseObserverVector

typedef agx::VectorPOD< RtOutputNoise * >	RtOutputNoisePtrVector

typedef agx::ref_ptr< RtOutputNoise >	RtOutputNoiseRef

typedef agx::Vector< RtOutputNoiseRef >	RtOutputNoiseRefVector

typedef agx::observer_ptr< RtOutput >	RtOutputObserver

typedef agx::ref_ptr< RtOutput >	RtOutputRef

typedef agx::observer_ptr< const RtRemoveRayMisses >	RtRemoveRayMissesConstObserver

typedef agx::ref_ptr< const RtRemoveRayMisses >	RtRemoveRayMissesConstRef

typedef agx::observer_ptr< RtRemoveRayMisses >	RtRemoveRayMissesObserver

typedef agx::ref_ptr< RtRemoveRayMisses >	RtRemoveRayMissesRef

using	RtSceneHandleRef = std::shared_ptr< RtSceneHandle >

using	RtSceneRef = std::shared_ptr< RtScene >

using	RtShapeHandle = RtShape

using	RtShapeHandleRef = RtShapeRef

using	RtShapeInstanceHandleRef = std::shared_ptr< RtShapeInstanceHandle >

using	RtShapeRef = std::shared_ptr< RtShape >

typedef agx::observer_ptr< const RtSystemNode >	RtSystemNodeConstObserver

typedef agx::ref_ptr< const RtSystemNode >	RtSystemNodeConstRef

typedef agx::observer_ptr< RtSystemNode >	RtSystemNodeObserver

typedef agx::observer_ptr< const RtSystemNodeProxy >	RtSystemNodeProxyConstObserver

typedef agx::ref_ptr< const RtSystemNodeProxy >	RtSystemNodeProxyConstRef

typedef agx::observer_ptr< RtSystemNodeProxy >	RtSystemNodeProxyObserver

typedef agx::ref_ptr< RtSystemNodeProxy >	RtSystemNodeProxyRef

typedef agx::ref_ptr< RtSystemNode >	RtSystemNodeRef

typedef agx::observer_ptr< const Sensor >	SensorConstObserver

typedef agx::ref_ptr< const Sensor >	SensorConstRef

typedef agx::observer_ptr< const SensorGroupStepStride >	SensorGroupStepStrideConstObserver

typedef agx::ref_ptr< const SensorGroupStepStride >	SensorGroupStepStrideConstRef

typedef agx::observer_ptr< SensorGroupStepStride >	SensorGroupStepStrideObserver

typedef agx::Vector< SensorGroupStepStrideObserver >	SensorGroupStepStrideObserverVector

typedef agx::VectorPOD< SensorGroupStepStride * >	SensorGroupStepStridePtrVector

typedef agx::ref_ptr< SensorGroupStepStride >	SensorGroupStepStrideRef

typedef agx::Vector< SensorGroupStepStrideRef >	SensorGroupStepStrideRefVector

typedef agx::observer_ptr< Sensor >	SensorObserver

typedef agx::Vector< SensorObserver >	SensorObserverVector

typedef agx::VectorPOD< Sensor * >	SensorPtrVector

typedef agx::ref_ptr< Sensor >	SensorRef

typedef agx::Vector< SensorRef >	SensorRefVector

typedef agx::observer_ptr< const SystemNode >	SystemNodeConstObserver

typedef agx::ref_ptr< const SystemNode >	SystemNodeConstRef

typedef agx::observer_ptr< SystemNode >	SystemNodeObserver

typedef agx::Vector< SystemNodeObserver >	SystemNodeObserverVector

typedef agx::observer_ptr< const SystemNodeProxy >	SystemNodeProxyConstObserver

typedef agx::ref_ptr< const SystemNodeProxy >	SystemNodeProxyConstRef

typedef agx::observer_ptr< SystemNodeProxy >	SystemNodeProxyObserver

typedef agx::Vector< SystemNodeProxyObserver >	SystemNodeProxyObserverVector

typedef agx::VectorPOD< SystemNodeProxy * >	SystemNodeProxyPtrVector

typedef agx::ref_ptr< SystemNodeProxy >	SystemNodeProxyRef

typedef agx::Vector< SystemNodeProxyRef >	SystemNodeProxyRefVector

typedef agx::VectorPOD< SystemNode * >	SystemNodePtrVector

typedef agx::ref_ptr< SystemNode >	SystemNodeRef

typedef agx::Vector< SystemNodeRef >	SystemNodeRefVector

typedef agx::observer_ptr< const TriaxialGaussianNoise >	TriaxialGaussianNoiseConstObserver

typedef agx::ref_ptr< const TriaxialGaussianNoise >	TriaxialGaussianNoiseConstRef

typedef agx::observer_ptr< TriaxialGaussianNoise >	TriaxialGaussianNoiseObserver

typedef agx::ref_ptr< TriaxialGaussianNoise >	TriaxialGaussianNoiseRef

typedef agx::observer_ptr< const TriaxialOutput >	TriaxialOutputConstObserver

typedef agx::ref_ptr< const TriaxialOutput >	TriaxialOutputConstRef

typedef agx::observer_ptr< const TriaxialOutputHandler >	TriaxialOutputHandlerConstObserver

typedef agx::ref_ptr< const TriaxialOutputHandler >	TriaxialOutputHandlerConstRef

typedef agx::observer_ptr< TriaxialOutputHandler >	TriaxialOutputHandlerObserver

typedef agx::ref_ptr< TriaxialOutputHandler >	TriaxialOutputHandlerRef

typedef agx::observer_ptr< TriaxialOutput >	TriaxialOutputObserver

typedef agx::ref_ptr< TriaxialOutput >	TriaxialOutputRef

typedef agx::observer_ptr< const TriaxialSignalNoiseNode >	TriaxialSignalNoiseNodeConstObserver

typedef agx::ref_ptr< const TriaxialSignalNoiseNode >	TriaxialSignalNoiseNodeConstRef

typedef agx::observer_ptr< TriaxialSignalNoiseNode >	TriaxialSignalNoiseNodeObserver

typedef agx::Vector< TriaxialSignalNoiseNodeObserver >	TriaxialSignalNoiseNodeObserverVector

typedef agx::VectorPOD< TriaxialSignalNoiseNode * >	TriaxialSignalNoiseNodePtrVector

typedef agx::ref_ptr< TriaxialSignalNoiseNode >	TriaxialSignalNoiseNodeRef

typedef agx::Vector< TriaxialSignalNoiseNodeRef >	TriaxialSignalNoiseNodeRefVector

typedef agx::observer_ptr< const TriaxialSignalScaling >	TriaxialSignalScalingConstObserver

typedef agx::ref_ptr< const TriaxialSignalScaling >	TriaxialSignalScalingConstRef

typedef agx::observer_ptr< TriaxialSignalScaling >	TriaxialSignalScalingObserver

typedef agx::ref_ptr< TriaxialSignalScaling >	TriaxialSignalScalingRef

typedef agx::observer_ptr< const TriaxialSignalSystemNode >	TriaxialSignalSystemNodeConstObserver

typedef agx::ref_ptr< const TriaxialSignalSystemNode >	TriaxialSignalSystemNodeConstRef

typedef agx::observer_ptr< TriaxialSignalSystemNode >	TriaxialSignalSystemNodeObserver

typedef agx::Vector< TriaxialSignalSystemNodeObserver >	TriaxialSignalSystemNodeObserverVector

typedef agx::VectorPOD< TriaxialSignalSystemNode * >	TriaxialSignalSystemNodePtrVector

typedef agx::ref_ptr< TriaxialSignalSystemNode >	TriaxialSignalSystemNodeRef

typedef agx::Vector< TriaxialSignalSystemNodeRef >	TriaxialSignalSystemNodeRefVector

typedef agx::observer_ptr< const TriaxialSpectralGaussianNoise >	TriaxialSpectralGaussianNoiseConstObserver

typedef agx::ref_ptr< const TriaxialSpectralGaussianNoise >	TriaxialSpectralGaussianNoiseConstRef

typedef agx::observer_ptr< TriaxialSpectralGaussianNoise >	TriaxialSpectralGaussianNoiseObserver

typedef agx::ref_ptr< TriaxialSpectralGaussianNoise >	TriaxialSpectralGaussianNoiseRef

typedef agx::observer_ptr< const UniformMagneticField >	UniformMagneticFieldConstObserver

typedef agx::ref_ptr< const UniformMagneticField >	UniformMagneticFieldConstRef

typedef agx::observer_ptr< UniformMagneticField >	UniformMagneticFieldObserver

typedef agx::ref_ptr< UniformMagneticField >	UniformMagneticFieldRef

Enumerations
enum class	RtEntityId : int32_t
	Entity id > 0 to access user data given raytrace results including ENTITY_ID_I32. More...

Functions
std::string	agxRayPatternPath (const std::string &fileName)
	Simulation implementation of a selection of Livox lidars.

template<typename T >
RtSystemNode *	findChildProxyFor (const SystemNode *root)

RtEntityIdIndex	indexOf (RtEntityId entityId)

Variables
constexpr RtEntityId	MaxRtEntityId { (RtEntityId)( ( 1 << 28 ) - 1 ) }
	The maximum entity id.

constexpr RtEntityIdIndex	MaxRtEntityIdIndex { (RtEntityIdIndex)MaxRtEntityId }
	Index of the maximum entity id.

constexpr RtEntityId	NullRtEntityId { (RtEntityId)0 }
	Null entity id.