Helios++
Helios software for LiDAR simulations
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 CAbstractBeamDeflectorBase abstract class for beam deflectors
 Cfluxionum::AbstractDesignMatrix< T >The abstract class which represents the fundamentals of any design matrix
 Cfluxionum::AbstractDesignMatrix< VarType >
 CAbstractDetectorBase abstract class for detectors
 CAbstractGeometryFilterAbstract class defining asset loading filters common behavior
 CArgumentsParserParser for helios-plusplus invocation arguments
 CAssetBase class for all assets
 CHeliosDemos::BaseDemoBaseDemo class
 CHeliosTests::BaseTestBaseTest class
 CBasicDynGroveSubject< Tree, Subject >Interface defining the behaviors that must be supported by any object that can notify to a basic dynamic grove
 CBasicDynGroveSubject< GroveKDTreeRaycaster, DynMovingObject >
 CBlockAllocator< Class >Class to handle allocation of multiple instances of the same class by blocks. It is useful to reduce the number of new calls that, when too high, might cause a performance bottleneck
 CBlockAllocator< LightKDTreeNode >
 CColor4fClass representing a color with 4 float components: RGBA
 CDateTimeUtilsClass providing util static methods for dealing with date and time operations
 CHeliosDemos::DemoSelectorSimple class to handle demo selection
 Chelios::filems::DesignMatrixReader< VarType >Class to read design matrices
 CDirectionsCoordinate system convention
 CDiscreteTimeClass to handle discrete time. It supports transforming from continuous time to discrete time and also transforming from discrete time to continuous time. It also supports cyclic (normalized period) and periodic (for any given period scale, which matches normalized when it is \(1\)) transforms
 CDynGrove< Subject >A DynGrove is an interface which declares observer-like functionality so dynamic subjects can notify to the grove their updates, which acts like a proxy for observer trees
 CDynMotionEngineAdapter which wraps a rigid motion engine to make it fit the dynamic Helios context
 CDynSequence< T >Dynamic sequence is a set of elements that must be applied during dynamic simulations to provide dynamic behavior to dynamic objects
 CDynSequencer< T >Dynamic sequencer handles dynamic sequences in a sequential fashion
 CDynSequencer< DynMotion >
 CEnergyMathsSome common mathematical operations concerning energy
 Cenum_hasher
 Cstd::exception
 Chelios::filems::FileReader< ReadType >Abstract class defining the fundamentals of any file reader
 Chelios::filems::FileReader< ReadArg >
 CFileUtilsClass with util functions to work with files
 Chelios::filems::FileWriter< WriteArgs >Abstract class declaring the methods that any file writer must implement ( FileWriter::write ) and allowing for an optional redefinition of the method that handles the end of life of the writer ( FileWriter::finish )
 Chelios::filems::FMSFacadeThe main facade for file management system
 Chelios::filems::FMSFacadeFactoryFactory to build FMS facades
 Chelios::filems::FMSFactoryFacadeThe facade for FMS factories
 Chelios::filems::FMSReadFacadeThe facade for FMS reading
 Chelios::filems::FMSSerializationFacadeThe facade for FMS serialization
 Chelios::filems::FMSWriteFacadeThe facade for FMS writing
 CFullWaveformClass representing a full waveform
 Cfluxionum::Function< A, B >Abstract class representing a function
 Cfluxionum::Function< A, arma::Col< B > >
 Cfluxionum::Function< double, arma::Col< double > >
 CGroveTreeWrapper< Tree >Wrapper for trees belonging to a StaticGrove so for-each loop can be used
 Chelios::filems::HeliosWriter< WriteArgs >Alberto M. Esmoris Pena
 Chelios::filems::HeliosWriter< Trajectory const & >
 Chelios::filems::HeliosWriter< WriteArgs ... >
 CHeliosTests::HPCTest_DoubleComparator
 CHeliosTests::HPCTest_FloatComparator
 CHeliosTests::HPCTest_IntComparator
 CIBinaryTreeNodeBinary tree node interface that must be implemented by any class providing binary tree node based functionalities
 CIExprTreeNodeStringFactory< InputType, OutputType >Interface defining the functions that must be provided by any concrete implementation of a factory that builds expression trees from a given string
 CIExprTreeNodeStringFactory< NumericType, NumericType >
 CIntersectionHandlingResultOutput class for intersection handling methods
 CIterableTreeNode< NodeType >Class representing an iterable tree node. It is a wrapper for a given tree node type which handles some extra features that can be useful during iteration such as depth level
 Cfluxionum::IterativeMethodHandler< IT, ET >Base implementation of an iterative method
 Cfluxionum::IterativeMethodHandler< IT, OT >
 CITreeIterator< NodeType >Interface defining core mechanisms that must be provided by any tree iterator
 CITreeIterator< IterableTreeNode< IBinaryTreeNode > >
 CITreeIterator< NodeType * >
 CKDGroveFactory
 CKDGroveStatsData structure class containing statistics for KDGrove
 CKDTreeBuildTypeBuild type to wrap data required for recursive building of KDTree nodes when using a KDTreeFactory based thread pool
 CKDTreeFactoryClass that must be extended by any class which provides factory methods for k-dimensional trees. Notice all KDTrees should be instantiated through corresponding factories
 CKDTreeFactoryMakerCollection of static methods to simplify making of different KDTree factories
 CKDTreePrimitiveComparatorKDTree primitive comparator
 CKDTreeRaycaster::KDTreeRaycasterSearchData for search operations of KDTree raycaster
 CLadLutLeaf Angle Distribution Look-Up Table
 CLadLutLoaderLoader for Leaf Angle Distribution Look Up Tables
 CLasSpecificationClass representing LAS specification Classes from 0 to 63 are defined by the specification Classes from 64 to 255 are user definable
 Chelios::filems::LasWriterSpecClass representing the specification defining a LasWriter (not the writer itself)
 CLegClass representing a survey leg
 Chelios::main::LidarSimLidar simulation class
 CloggerClass providing the base for any logger
 Clogger_factoryLogger factory class can be used to build loggers
 CMarquardtFitterClass to compute Marquardt fitter
 CMaterialClass representing a material specification
 CMaterialsFileReaderClass to read materials files
 CMathConverter
 CMeasurementClass representing a measurement
 Cfluxionum::Minimizer< IT, OT >Base abstract class providing basic structure for minimization optimization of a given function
 CNoiseSource< RealType >Class to handle a noise source
 CNoiseSource< double >
 CObject
 CSurfaceInspector::util::ObjectClass representing an object. All surface inspector classes must extend Object
 CPlaneFitterHandle plane fitting operations
 CPointerVector< T >Wrapper to have a vector of pointers such that when it is destroyed, all the pointers are deleted
 CPrimitiveAbstract class defining the common behavior for all primitives
 CPulseClass representing a laser pulse
 CPulseTaskPulse task interface
 CPulseTaskFactoryFactory to make the adequate pulse task depending on the simulation
 CPulseThreadPoolFactoryFactory to build different types of pulse thread pools
 CPulseThreadPoolInterfaceInterface for thread pools supporting pulse tasks
 Cpyhelios::PyAABBWrapperWrapper for AABB class
 Cpyhelios::PyBeamDeflectorWrapperWrapper for AbstractBeamDeflector class
 Cpyhelios::PyDetectorWrapperWrapper for AbstractDetector class
 Cpyhelios::PyDoubleVectorWrapper for std::vector<double> class
 Cpyhelios::PyHeliosOutputWrapperPython wrapper for helios output
 Cpyhelios::PyHeliosSimulation
 Cpyhelios::PyHeliosUtils
 Cpyhelios::PyIntegerListWrapper for std::list<int> class
 Cpyhelios::PyMeasurementVectorWrapperWrapper for std::vector<Measurement> class
 Cpyhelios::PyMeasurementWrapperWrapper for Measurement class
 Cpyhelios::PyNoiseSourceWrapperWrapper for NoiseSource abstract class
 Cpyhelios::PyPlatformWrapperWrapper for Platform class
 Cpyhelios::PyPrimitiveWrapperWrapper for Primitive class
 Cpyhelios::PyRandomnessGeneratorWrapperWrapper for RandomnessGenerator class
 Cpyhelios::PyRaySceneIntersectionWrapperWrapper for RaySceneIntersection
 Cpyhelios::PyScannerWrapperWrapper for Scanner class
 Cpyhelios::PyScanningStripWrapperWrapper for ScanningStrip class
 Cpyhelios::PyScenePartWrapperWrapper for ScenePart class
 Cpyhelios::PySceneWrapperWrapper for Scene
 Cpyhelios::PyStringVector
 Cpyhelios::PythonDVec3Wrapper to communicate glm::dvec3 with python
 Cpyhelios::PyTrajectoryVectorWrapperPython wrapper for helios trajectory
 Cpyhelios::PyTrajectoryWrapperWrapper for Trajectory class
 Cpyhelios::PyVertexWrapperWrapper for Vertex class
 CRandomnessGenerator< RealType >Class to generate random numbers
 CRandomnessGenerator< double >
 CRaycasterRaycaster interface declaring raycasting operations
 CRaySceneIntersectionClass representing a the intersection of a ray over a scene made of primitives
 CRayUtilsClass with util functions to work with rays
 Chelios::filems::ReadingStrategy< ReadType >Abstract class defining the fundamentals of any file reading strategy
 Chelios::filems::ReadingStrategy< ReadArg >
 Crigidmotion::RigidMotionInterface that must be implemented by any class which represents a specific rigid motions
 Crigidmotion::RigidMotionEngineClass to handle operations with rigid motions
 Crigidmotion::RigidMotionFactoryClass that must be extended by any class which provides factory methods for rigid motions. Notice all rigid motions should be instantiated through corresponding factories
 CRotation
 CRotationOrder
 CScannerHead
 CScanningPulseProcessClass defining the scanning pulse process interface
 CScanningStripA scanning strip is a set of legs which belong to the same strip. Thus, it is an abstract group of legs
 CSceneLoadingSpecificationManually specify scene transformation filters to apply when loading a scene
 CScenePartClass representing a scene part
 CSerialIOUtils for Input/Output operations of serializable objects
 CSharedSubTaskA shared task is said to be a collection of shared sub-tasks. Each shared sub-task can be computed in parallel with respect to its siblings
 CSharedSubTaskCompletionHandlerInterface declaring behaviors that must be implemented by any class capable of handling completion of shared sub-tasks
 CSimpleKDTreeGeometricStrategyClass providing a strategy for geometry-level parallelization of Simple KDTree building. The geometry-level parallelization is the one to be applied on upper tree nodes, where multiple threads work on the building of the same node
 CSimulationClass representing a simulation
 CSimulationCycleCallbackAbstract class to handle simulation cycle callbacks
 CSimulationReporterClass to handle reports related to simulation
 Chelios::hpc::SM_ParallelMergeSort< RandomAccessIterator, Comparator >Class providing a shared memory sorting algorithm based on merge sort
 CSmartSharedFunctorContainer< T >Functor container can be used to wrap any element so its functor () is called while having a shared pointer to the contained element
 CSpectralLibraryClass representing the spectral library
 Cboost::static_visitor
 CStaticGrove< Tree >A StaticGrove is an abstract class which declares methods to handle a set of trees
 CStepLoop< StepInput >Abstract class providing the basics to handle loops inside simulation time, which is discrete because it is based on simulation steps
 CStepLoop< StepInput ... >
 CUnivarExprTreeStringFactory< NumericType >::SymbolUnivarExprTreeStringFactory sub-class used to represent symbols during recursive building
 Chelios::filems::SyncFileMeasurementWriterFactorySyncFileMeasurementWriter Factory class. Used to create the appropriate measurement writers based on input flags
 Chelios::filems::SyncFileWriter< WriteArgs >Abstract class defining common behavior for all synchronous file writers
 Chelios::filems::SyncFileWriter< WriteArgs ... >
 CTaskDropper< TaskType, ThreadPoolType, TaskArgs >Class which handles tasks dropping. It is, executing and then removing each task when dropping
 CTaskDropper< TaskType, ThreadPoolType, TaskArgs... >
 CTaskWarehouse< Task >Class implementing a warehouse to store and retrieve tasks in a thread safe fashion
 CTest
 CThreadPoolBase class providing core implementation of a thread pool to deal with multi threading tasks
 CTimeWatcherA time watcher can be used to perform and report time measures
 CTrajectoryClass representing a concrete trajectory definition
 CVectorialClass to perform util vector operations
 CVertexClass representing a vertex
 CVertexKeyEqualStruct to compare vertex when using unordered set
 CVertexKeyHashStruct to obtain vertex hash when using unordered set
 Cvisualhelios::VHCanvasVisual Helios Canvas is a class which provides the base mechanisms to implement Helios visualizations
 Cvisualhelios::VHDynSceneAdapter< ST, DT >Class defining core mechanisms to adapt dynamic scenes to the visual Helios context based on PCL and VTK libraries
 Cvisualhelios::VHScannerAdapterAbstract class defining core mechanism to adapt scanners to the visual Helios context based on PCL and VTK libraries
 Cvisualhelios::VHStaticObjectAdapterAbstract class defining core mechanisms to adapt static objects to the visual Helios context based on PCL and VTK libraries
 CVoxelFileParserClass for parsing voxel files
 CVoxelGridCellVoxelGridCell is used to build and fill all necessary voxels to represent input point cloud
 CWavefrontObjClass representing a .obj loaded file
 CWavefrontObjCache
 CWaveMathsSome common mathematical operatiosn concerning the full waveform
 Chelios::filems::WriteStrategy< WriteArgs >Interface that must be implemented by any class which supports write implementations for file writers
 Chelios::filems::WriteStrategy< FullWaveform const & >
 Chelios::filems::WriteStrategy< Measurement const &, glm::dvec3 const & >
 Chelios::filems::WriteStrategy< std::string const & >
 Chelios::filems::WriteStrategy< Trajectory const & >
 Chelios::filems::WriteStrategy< vector< WriteArg > const &, BiasType ... >
 Chelios::filems::WriteStrategy< WriteArg const &, BiasType ... >
 CXmlAssetsLoaderClass for asset loading from XML file
 CXmlSceneLoaderClass for scene loading from XML file
 CXmlUtilsCommon utils for XML handling
 CYielder< T >Abstract class representing a yielder. It is, an object which can be used to accumulate inputs until either a yield is explicitly deleted or the yield condition is triggered, probably after a push request
 Cruntime_error