►CAbstractBeamDeflector | Base abstract class for beam deflectors |
CConicBeamDeflector | Class representing a conic beam deflector |
CFiberArrayBeamDeflector | Class representing a fiber array beam deflector |
COscillatingMirrorBeamDeflector | Class representing an oscillating mirror beam deflector |
CPolygonMirrorBeamDeflector | Class representing a polygon mirror beam deflector |
CRisleyBeamDeflector | Class representing a risley prisms beam deflector |
►Cfluxionum::AbstractDesignMatrix< T > | The abstract class which represents the fundamentals of any design matrix |
Cfluxionum::DesignMatrix< T > | This class represents a DesignMatrix \(X \in \mathbb{R}^{m \times n}\) |
►Cfluxionum::AbstractDesignMatrix< VarType > | |
►Cfluxionum::DesignMatrix< VarType > | |
Cfluxionum::IndexedDesignMatrix< IndexType, VarType > | |
Cfluxionum::TemporalDesignMatrix< TimeType, VarType > | This class represents a DesignMatrix where each row satisfy that its elements can be placed into a continuous succession order representation (i.e. continuous time domain). For a discrete succession order representation see fluxionum::IndexedDesignMatrix better |
Cfluxionum::DiffDesignMatrix< TimeType, VarType > | The heart of a differential design matrix is the idea that the columns are defining the values of variables differentiated over time. The \(m-1\) rows are samples of the differential behavior of the function \(x_j(t_i)\) for the \(j\)-th column as variable. For then, it is possible to interpolate the following vector of derivatives |
►CAbstractDetector | Base abstract class for detectors |
CFullWaveformPulseDetector | Concrete implementation of abstract detector to compute full waveform pulses |
►CAbstractGeometryFilter | Abstract class defining asset loading filters common behavior |
CDetailedVoxelLoader | Loader for deatiled voxel geometries |
CGeoTiffFileLoader | Loader for tiff files |
CRotateFilter | Rotate transform filter |
CScaleFilter | Scale transform filter |
CTranslateFilter | Translate transform filter |
CWavefrontObjFileLoader | OBJ file loader filter |
CXYZPointCloudFileLoader | Import point cloud files abstracting them to a set of voxels |
CArgumentsParser | Parser for helios-plusplus invocation arguments |
►CAsset | Base class for all assets |
►CEggAsset< InterpolatedMovingPlatform, SimulationStepLoop & > | |
CInterpolatedMovingPlatformEgg | Egg class that can hatch to a full InterpolatedMovingPlatform class |
CEggAsset< FullClass, HatchArgs > | An EggAsset is an asset that can hatch to its full class |
CFWFSettings | Full Waveform settings |
►CPlatform | Class representing a platform asset |
►CMovingPlatform | Class representing a moving platform |
CInterpolatedMovingPlatform | Class representing a MovingPlatform which position is defined by a function interpolated from a DesignMatrix |
CInterpolatedMovingPlatformEgg | Egg class that can hatch to a full InterpolatedMovingPlatform class |
CLinearPathPlatform | Class representing a linear path platform |
►CSimplePhysicsPlatform | Class representing a simple phyiscs platform |
CGroundVehiclePlatform | Class representing a ground vehicle platform |
CHelicopterPlatform | Class representing a helicopter platform |
CPlatformSettings | Class representing platform settings |
►CScanner | Class representing a scanner asset |
CMultiScanner | Class representing a multi scanner. It is, a scanner that can emit more than one pulse per time instant |
CSingleScanner | Class representing a single scanner. It is, a scanner that can only emit one pulse per time instant |
CScannerSettings | Scanner settings class |
CScanningDevice | Class representing a scanning device. Any scanner needs to be composed of at least one scanning device to be computable |
►CScene | Class representing a scene asset |
►CStaticScene | Static scene basic implementation |
CDynScene | Dynamic scene base implementation |
CSerialSceneWrapper | Wrapper for scenes which assists read and write serialization operations depending on the type of scene (Scene, StaticScene, DynScene) |
CSurvey | Class representing a Helios++ survey |
CTrajectorySettings | Class representing trajectory settings |
►CHeliosDemos::BaseDemo | BaseDemo class |
CHeliosDemos::SimplePrimitivesDemo | Simple primitives demo |
►CHeliosDemos::SurveyDemo | SurveyDemo class |
►CHeliosDemos::DynamicSceneDemo | Dynamic scene demo |
CHeliosDemos::RaycastingDemo | Raycasting demo |
►CHeliosTests::BaseTest | BaseTest class |
CHeliosTests::AssetLoadingTest | Asset loading tests |
CHeliosTests::DiscreteTimeTest | Test discrete time handling |
CHeliosTests::EnergyModelsTest | Energy models test |
CHeliosTests::ExprTreeTest | Expression tree test |
CHeliosTests::FluxionumTest | Fluxionum test |
CHeliosTests::FunctionalPlatformTest | Functional platform test |
CHeliosTests::GroveTest | Test for grove of trees |
CHeliosTests::HPCTest | High performance computing components test |
CHeliosTests::LadLutTest | Test look-up table for leaf angle distribution |
CHeliosTests::NoiseTest | Test for noise generation |
CHeliosTests::PlaneFitterTest | Test plane fitter operations |
CHeliosTests::PlatformPhysicsTest | Platform physics test |
CHeliosTests::RandomTest | Test for randomness generation |
CHeliosTests::RayIntersectionTest | Test for ray intersection and corresponding handling (if any) |
CHeliosTests::RigidMotionTest | Rigid motion test |
CHeliosTests::ScenePartSplitTest | Scene part split test |
CHeliosTests::SerializationTest | Test serialization |
CHeliosTests::SurveyCopyTest | Test survey copy |
CHeliosTests::VoxelParsingTest | Test for voxel parsing |
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 > | |
►CKDGroveSubject | Interface defining the behaviors that must be supported by any object that can notify to a KDGrove |
►CDynMovingObject | Implementation of a dynamic object which supports dynamic motions (extended rigid motions) |
CDynSequentiableMovingObject | Implementation of a dynamic object which supports sequentiable dynamic motions |
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 > | |
CLightKDTreeNodeBlockAllocator | Block allocator for LightKDTreeNode instances |
CColor4f | Class representing a color with 4 float components: RGBA |
CDateTimeUtils | Class providing util static methods for dealing with date and time operations |
CHeliosDemos::DemoSelector | Simple class to handle demo selection |
Chelios::filems::DesignMatrixReader< VarType > | Class to read design matrices |
CDirections | Coordinate system convention |
CDiscreteTime | Class 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 |
►CBasicDynGrove< GroveKDTreeRaycaster, DynMovingObject > | |
CKDGrove | Grove of KDTrees. It supports both static and dynamic KDTrees, handling each accordingly |
CBasicDynGrove< Tree, Subject > | Basic implementation of a DynGrove which extends BasicStaticGrove to provided dynamic funcionalities |
CDynMotionEngine | Adapter 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 > | |
CEnergyMaths | Some common mathematical operations concerning energy |
Cenum_hasher | |
►Cstd::exception | |
►CHeliosException | Base class for Helios exceptions |
Chelios::filems::EndOfReadingException | Class representing the end of reading exception for FMS readers |
Cpyhelios::PyHeliosException | |
►Chelios::filems::FileReader< ReadType > | Abstract class defining the fundamentals of any file reader |
►Chelios::filems::SimpleFileReader< int > | |
Chelios::filems::BinaryFileReader | Class for byte by byte reading of binary files |
►Chelios::filems::SimpleFileReader< string > | |
►Chelios::filems::LineFileReader | Class supporting line by line reading of text files |
Chelios::filems::BufferedLineFileReader | |
►Chelios::filems::SimpleFileReader< char > | |
Chelios::filems::CharFileReader | Class for char by char reading of files |
►Chelios::filems::FileReader< ReadArg > | |
Chelios::filems::SimpleFileReader< ReadArg > | Abstract class defining the fundamental of any file reader that uses standard file input stream as reading mechanism |
CFileUtils | Class 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::FMSFacade | The main facade for file management system |
Chelios::filems::FMSFacadeFactory | Factory to build FMS facades |
Chelios::filems::FMSFactoryFacade | The facade for FMS factories |
Chelios::filems::FMSReadFacade | The facade for FMS reading |
Chelios::filems::FMSSerializationFacade | The facade for FMS serialization |
Chelios::filems::FMSWriteFacade | The facade for FMS writing |
CFullWaveform | Class representing a full waveform |
►Cfluxionum::Function< A, B > | Abstract class representing a function |
Cfluxionum::ClosestLesserSampleFunction< A, B > | Closest lesser sample function |
►Cfluxionum::IterativeEulerMethod< A, B > | Iterative Euler method |
Cfluxionum::FixedIterativeEulerMethod< A, B > | Fixed iterative Euler method |
Cfluxionum::LinearPiecesFunction< A, B > | Linear pieces function |
Cfluxionum::SimpleLinearFunction< A, B > | Simple linear function |
►Cfluxionum::Function< A, arma::Col< B > > | |
Cfluxionum::ParametricClosestLesserSampleFunction< A, B > | |
►Cfluxionum::ParametricIterativeEulerMethod< A, B > | Parametric iterative Euler method |
Cfluxionum::FixedParametricIterativeEulerMethod< double, double > | |
Cfluxionum::FixedParametricIterativeEulerMethod< A, B > | Fixed parametric iterative Euler method |
Cfluxionum::ParametricLinearPiecesFunction< A, B > | Parametric linear pieces function |
►Cfluxionum::Function< double, arma::Col< double > > | |
Cfluxionum::ParametricClosestLesserSampleFunction< double, double > | |
►CTrajectoryFunction | Abstract class representing a trajectory function \(f: \mathbb{R} \to \mathbb{R}^{n}\) |
CDesignTrajectoryFunction | Class representing a trajectory function that comes from interpolating a TemporalDesignMatrix using its corresponding DiffDesignMatrix |
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::TrajectoryWriter | Class to handle writing of trajectories to generate HELIOS++ output virtual trajectories |
►Chelios::filems::HeliosWriter< WriteArgs ... > | |
►Chelios::filems::BaseFullWaveformWriter< FullWaveform const & > | |
Chelios::filems::FullWaveformWriter | Class to handle writing of full waveform to generate HELIOS++ output virtual full waveform |
►Chelios::filems::BaseFullWaveformWriter< vector< FullWaveform > const & > | |
Chelios::filems::VectorialFullWaveformWriter | Common implementation for any vectorial full waveform writer |
►Chelios::filems::BaseMeasurementWriter< Measurement const &, glm::dvec3 const & > | |
Chelios::filems::MeasurementWriter | Class to handle writing of measurements to generate HELIOS++ output virtual point clouds |
►Chelios::filems::BaseMeasurementWriter< vector< Measurement > const &, glm::dvec3 const & > | |
►Chelios::filems::VectorialMeasurementWriter | Common implementation for any vectorial measurement writer |
Chelios::filems::MultiVectorialMeasurementWriter | Common implementation for any vectorial measurement writer that supports concurrent multiple output streams of the same time |
Chelios::filems::BaseFullWaveformWriter< WriteArgs > | |
Chelios::filems::BaseMeasurementWriter< WriteArgs > | Class to handle writing of measurements to generate HELIOS++ output virtual point clouds. It provides the basis for the implementation of any measurement writer |
CHeliosTests::HPCTest_DoubleComparator | |
CHeliosTests::HPCTest_FloatComparator | |
CHeliosTests::HPCTest_IntComparator | |
►CIBinaryTreeNode | Binary tree node interface that must be implemented by any class providing binary tree node based functionalities |
►CIExprTreeNode< NumericType, NumericType > | |
CUnivarExprTreeNode< NumericType > | Class implementing a Univariate Expression Tree Node |
CIExprTreeNode< InputType, OutputType > | Interface extending the Binary Tree node definition to become a Expression Tree node. Any class providing expression tree node based functionalities must implement the IExprTreeNode, which implies it must also implement the IBinaryTreeNode interface |
►CLightKDTreeNode | Class representing a light KDTree node. It is, the basic representation of a KDTree node with uses least possible data |
►CKDTreeNode | Class representing a KDTree node |
CKDTreeNodeRoot | Class representing the root node of a KDTree |
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 > | |
CUnivarExprTreeStringFactory< NumericType > | Class implementing a factory that makes univariate expression trees from expressions given as strings |
CIntersectionHandlingResult | Output 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 > > | |
CBinaryTreeBreadthIterator< NodeType > | Like fast breadth first iterator but wrapping tree nodes inside a IterableTreeNode instance |
CBinaryTreeDepthIterator< NodeType > | Like fast depth first iterator but wrapping tree nodes inside a IterableTreeNode instance |
►CITreeIterator< NodeType * > | |
CBinaryTreeFastBreadthIterator< NodeType > | Fast breadth first iterator for binary tree like nodes |
CBinaryTreeFastDepthIterator< NodeType > | Fast depth first iterator for binary tree like nodes |
CKDGroveFactory | |
CKDGroveStats | Data structure class containing statistics for KDGrove |
CKDTreeBuildType | Build type to wrap data required for recursive building of KDTree nodes when using a KDTreeFactory based thread pool |
►CKDTreeFactory | Class that must be extended by any class which provides factory methods for k-dimensional trees. Notice all KDTrees should be instantiated through corresponding factories |
►CSimpleKDTreeFactory | Class providing building methods for simple k-dimensional trees |
►CMultiThreadKDTreeFactory | Decorator for any KDTree factory which provides support for multi thread KDTree building |
CMultiThreadSAHKDTreeFactory | Decorator for any SAH KDTree which provides support for multi thread KDTree building |
►CSAHKDTreeFactory | Class providing building methods for k-dimensional trees with surface area heuristic (SAH) |
CAxisSAHKDTreeFactory | Class providing building methods for k-dimensional trees with surface area heuristic and greedy selection of best partition axis |
CFastSAHKDTreeFactory | Class providing building methods for k-dimensional trees with a fast strategy to approximate Surface Area Heuristic (SAH) |
CKDTreeFactoryMaker | Collection of static methods to simplify making of different KDTree factories |
CKDTreePrimitiveComparator | KDTree primitive comparator |
CKDTreeRaycaster::KDTreeRaycasterSearch | Data for search operations of KDTree raycaster |
CLadLut | Leaf Angle Distribution Look-Up Table |
CLadLutLoader | Loader for Leaf Angle Distribution Look Up Tables |
CLasSpecification | Class representing LAS specification Classes from 0 to 63 are defined by the specification Classes from 64 to 255 are user definable |
Chelios::filems::LasWriterSpec | Class representing the specification defining a LasWriter (not the writer itself) |
CLeg | Class representing a survey leg |
Chelios::main::LidarSim | Lidar simulation class |
►Clogger | Class providing the base for any logger |
►Cfile_logger | Class representing a logger capable of writing to files |
Cfull_logger | Class representing a logger capable of writing to files and, at the same time, to standard out |
Cstd_out_logger | Class representing a logger capable of writing to standard out stream |
Clogger_factory | Logger factory class can be used to build loggers |
CMarquardtFitter | Class to compute Marquardt fitter |
CMaterial | Class representing a material specification |
CMaterialsFileReader | Class to read materials files |
CMathConverter | |
CMeasurement | Class representing a measurement |
►Cfluxionum::Minimizer< IT, OT > | Base abstract class providing basic structure for minimization optimization of a given function |
►Cfluxionum::DiffMinimizer< IT, OT > | Base abstract class providing basic structure for minimization optimization of a given function based on its derivatives |
Cfluxionum::UnivariateNewtonRaphsonMinimizer< IT, OT > | Implementation of univariate Newton-Raphson minimizer |
►CNoiseSource< RealType > | Class to handle a noise source |
►CRandomNoiseSource< RealType > | Abstract class for random noise handling |
CUniformNoiseSource< double > | |
CNormalNoiseSource< RealType > | Class for normal noise handling |
CUniformNoiseSource< RealType > | Class for uniform noise handling |
CNoiseSource< double > | |
►CObject | |
►CSurfaceInspector::maths::functions::IMathFunction< T, T > | |
CSurfaceInspector::maths::functions::GaussianFunction< T > | Implementation of a gaussian function |
►CSurfaceInspector::util::Object | Class representing an object. All surface inspector classes must extend Object |
►CSurfaceInspector::util::draggers::IDragger< E, vector< E > > | |
►CSurfaceInspector::util::draggers::OptimizationDragger< E > | Optimization dragger interface provide methods expanding dragger definition to become a optimization dragger which operates over a vector data structure |
►CSurfaceInspector::util::draggers::MinDragger< E > | Min dragger drags the minimum element. The first time next is called the minimum element is returned, the second time the second minimum element is returned and so on |
CSurfaceInspector::util::draggers::MaxDragger< E > | Max dragger drags the maximum element. The first time next is called the maximum element is returned, the second time the second maximum element is returned and so on |
CSurfaceInspector::maths::Distances | Class providing common distance computations |
CSurfaceInspector::maths::Histogram< T > | Class for representation and handling of 1D histograms |
►CSurfaceInspector::maths::Plane< T > | Class representing a plane |
CSurfaceInspector::maths::DetailedPlane< T > | |
CSurfaceInspector::maths::PlaneFitter | Handle plane fitting operations |
CSurfaceInspector::maths::Scalar< T > | Class providing common operations to work with scalars |
CSurfaceInspector::maths::SingularContextComputer< T > | Handle singular context descriptors computation |
CSurfaceInspector::maths::SingularContextDescriptors< T > | Class representing singular context descriptors |
CSurfaceInspector::maths::Statistics | Class providing common statistics operations |
CSurfaceInspector::maths::Vector< T > | Class providing vector operations |
CSurfaceInspector::maths::functions::IMathFunction< Tin, Tout > | Interface defining math function core mechanics |
►CSurfaceInspector::maths::permuters::IPermuter< T > | Permuter interface provides methods to iterate over different permutation configurations. It is an interface, which means it cannot be directly instantiated. It must be implemented by concrete classes which implement its functions depending on the type of desired permutations |
CSurfaceInspector::maths::permuters::CNRIndexPermuter< T > | Permuter of Combinations with No Repetition (CNR) for indices |
CSurfaceInspector::util::SurfaceInspectorException | Base class for surface inspector exceptions |
CSurfaceInspector::util::draggers::IDragger< E, C > | Dragger interface provide methods to drag elements from a given collection following a certain order. It is an interface, which means it cannot be directly instantiated. It must be implemented by concrete classes which implement its functions depending on the type of desired dragging |
CPlaneFitter | Handle plane fitting operations |
CPointerVector< T > | Wrapper to have a vector of pointers such that when it is destroyed, all the pointers are deleted |
►CPrimitive | Abstract class defining the common behavior for all primitives |
CAABB | Class representing an Axis Aligned Bounding Box (AABB) |
CTriangle | Class representing triangle primitive |
►CVoxel | Class representing a voxel primitive |
CDetailedVoxel | Class which extends Voxel to support AMAPVox format with extra features |
►CPulse | Class representing a laser pulse |
►CTimedPulse | Class representing a time aware laser pulse |
CSimulatedPulse | Class representing a simulated laser pulse |
►CPulseTask | Pulse task interface |
►CAbstractPulseRunnable | Base abstract class for pulse runnables |
►CFullWaveformPulseRunnable | Concrete implementation of abstract pulse runnable to compute full waveform pulses |
CDynFullWaveformPulseRunnable | Derived class extending FullWaveFormPulseRunnable to handle dynamic moving objects |
CPulseTaskFactory | Factory to make the adequate pulse task depending on the simulation |
CPulseThreadPoolFactory | Factory to build different types of pulse thread pools |
►CPulseThreadPoolInterface | Interface for thread pools supporting pulse tasks |
CPulseThreadPool | Class implementing a thread pool to deal with pulse tasks |
CPulseWarehouseThreadPool | Class implementing a warehouse thread pool to deal with pulse tasks |
Cpyhelios::PyAABBWrapper | Wrapper for AABB class |
Cpyhelios::PyBeamDeflectorWrapper | Wrapper for AbstractBeamDeflector class |
Cpyhelios::PyDetectorWrapper | Wrapper for AbstractDetector class |
Cpyhelios::PyDoubleVector | Wrapper for std::vector<double> class |
Cpyhelios::PyHeliosOutputWrapper | Python wrapper for helios output |
Cpyhelios::PyHeliosSimulation | |
Cpyhelios::PyHeliosUtils | |
Cpyhelios::PyIntegerList | Wrapper for std::list<int> class |
Cpyhelios::PyMeasurementVectorWrapper | Wrapper for std::vector<Measurement> class |
Cpyhelios::PyMeasurementWrapper | Wrapper for Measurement class |
Cpyhelios::PyNoiseSourceWrapper | Wrapper for NoiseSource abstract class |
Cpyhelios::PyPlatformWrapper | Wrapper for Platform class |
►Cpyhelios::PyPrimitiveWrapper | Wrapper for Primitive class |
Cpyhelios::PyDetailedVoxelWrapper | Wrapper for DetailedVoxel class |
Cpyhelios::PyTriangleWrapper | Wrapper for Triangle class |
Cpyhelios::PyRandomnessGeneratorWrapper | Wrapper for RandomnessGenerator class |
Cpyhelios::PyRaySceneIntersectionWrapper | Wrapper for RaySceneIntersection |
Cpyhelios::PyScannerWrapper | Wrapper for Scanner class |
Cpyhelios::PyScanningStripWrapper | Wrapper for ScanningStrip class |
Cpyhelios::PyScenePartWrapper | Wrapper for ScenePart class |
Cpyhelios::PySceneWrapper | Wrapper for Scene |
Cpyhelios::PyStringVector | |
Cpyhelios::PythonDVec3 | Wrapper to communicate glm::dvec3 with python |
Cpyhelios::PyTrajectoryVectorWrapper | Python wrapper for helios trajectory |
Cpyhelios::PyTrajectoryWrapper | Wrapper for Trajectory class |
Cpyhelios::PyVertexWrapper | Wrapper for Vertex class |
CRandomnessGenerator< RealType > | Class to generate random numbers |
CRandomnessGenerator< double > | |
►CRaycaster | Raycaster interface declaring raycasting operations |
►CRaycasterGroveTree< DynObject > | |
CGroveKDTreeRaycaster | Grove KDTree Raycaster extends KDTreeRaycaster to make it compatible with groves by implementing the RaycasterGroveTree interface |
CKDGroveRaycaster | Class representing a KDGrove ray caster |
►CKDTreeRaycaster | Class representing a KDTree ray caster |
CGroveKDTreeRaycaster | Grove KDTree Raycaster extends KDTreeRaycaster to make it compatible with groves by implementing the RaycasterGroveTree interface |
CRaycasterGroveTree< Subject > | Define a Raycaster derived interface to make it compatible with groves |
CRaySceneIntersection | Class representing a the intersection of a ray over a scene made of primitives |
CRayUtils | Class with util functions to work with rays |
►Chelios::filems::ReadingStrategy< ReadType > | Abstract class defining the fundamentals of any file reading strategy |
►Chelios::filems::SimpleReadingStrategy< int > | |
Chelios::filems::BinaryReadingStrategy | Class defining the strategy to read byte by byte from a file input stream |
►Chelios::filems::SimpleReadingStrategy< string > | |
Chelios::filems::LineReadingStrategy | Class defining the strategy to read line by line from a file input stream |
►Chelios::filems::SimpleReadingStrategy< char > | |
Chelios::filems::CharReadingStrategy | Class defining the strategy to read char by char from a file input stream |
►Chelios::filems::ReadingStrategy< ReadArg > | |
Chelios::filems::BufferedReadingStrategy< ReadArg > | Class defining a strategy that provides support for buffering of consecutive readings |
Chelios::filems::SimpleReadingStrategy< ReadArg > | Class defining the strategy to read from a simple file input stream |
►Crigidmotion::RigidMotion | Interface that must be implemented by any class which represents a specific rigid motions |
CDynMotion | Class which wraps the RigidMotion class to implement extra features such as the self mode control mechanism and computation of normal counterparts |
Crigidmotion::RigidMotionEngine | Class to handle operations with rigid motions |
►Crigidmotion::RigidMotionFactory | Class that must be extended by any class which provides factory methods for rigid motions. Notice all rigid motions should be instantiated through corresponding factories |
Crigidmotion::RigidMotionR2Factory | Class providing building methods for rigid motions in \(\mathbb{R}^{2}\) |
Crigidmotion::RigidMotionR3Factory | Class providing building methods for rigid motions in \(\mathbb{R}^{3}\) |
CRotation | |
CRotationOrder | |
CScannerHead | |
►CScanningPulseProcess | Class defining the scanning pulse process interface |
CBuddingScanningPulseProcess | Class implementing a scanning pulse process which works with a pulse task dropper based on budding task dropper and a pulse thread pool based on an asynchronous resource thread pool |
CWarehouseScanningPulseProcess | Class implementing a scanning pulse process which works with a pulse task dropper based on budding task dropper and a pulse warehouse thread pool based on an asynchronous warehouse thread pool |
CScanningStrip | A scanning strip is a set of legs which belong to the same strip. Thus, it is an abstract group of legs |
CSceneLoadingSpecification | Manually specify scene transformation filters to apply when loading a scene |
►CScenePart | Class representing a scene part |
►CDynObject | Dynamic object base implementation |
CDynMovingObject | Implementation of a dynamic object which supports dynamic motions (extended rigid motions) |
CSerialIO | Utils for Input/Output operations of serializable objects |
►CSharedSubTask | A 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 |
CFastSAHKDTreeRecountSubTask | |
CSAHKDTreeComputeLossNodesSubTask | Shared sub-task to compute loss nodes when finding the split position during SAH KDTree building. It is meant to be used at geometry-level parallelization context and only for right child nodes |
CSimpleKDTreeBuildChildrenNodesSubTask | Shared sub-task to build children nodes when building a Simple KDTree on all geometry-level depths except for the last one |
CSimpleKDTreeComputeRootNodeBoundariesSubTask | Shared sub-task to compute root node boundaries when building a Simple KDTree. It is meant to be used at geometry-level parallelization context and only for root node |
CSimpleKDTreePopulateSplitsSubTask | Shared sub-task to populate splits when building a Simple KDTree. It is meant to be used at geometry-level parallelization context and only for right child nodes |
Chelios::hpc::SM_ParallelMergeSortSubTask< RandomAccessIterator, Comparator > | Shared sub-task to sort a sequence using a parallel mergesort like algorithm for shared memory contexts |
►CSharedSubTaskCompletionHandler | Interface declaring behaviors that must be implemented by any class capable of handling completion of shared sub-tasks |
CSharedTaskSequencer | Class providing core implementation of a shared task sequencer. It is a sequencer which launches shared sub-tasks belonging to the same shared task |
►CSimpleKDTreeGeometricStrategy | Class 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 |
►CSAHKDTreeGeometricStrategy | Class providing a strategy for geometry-level parallelization of SAH 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 |
CAxisSAHKDTreeGeometricStrategy | Class providing a strategy for geometry-level parallelization of Axis SAH 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 |
CFastSAHKDTreeGeometricStrategy | Class providing a strategy for geometry-level parallelization of Fast SAH 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 |
►CSimulation | Class representing a simulation |
CSurveyPlayback | Survey playback class, used to extend simulation functionalities so it can be controlled |
►CSimulationCycleCallback | Abstract class to handle simulation cycle callbacks |
Cpyhelios::PySimulationCycleCallback | Python callback for each simulation cycle that has been completed |
CSimulationReporter | Class 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 |
CSpectralLibrary | Class representing the spectral library |
►Cboost::static_visitor | |
CstringVisitor | StringVisitor defines a different string building behavior for different printable objects |
►CStaticGrove< Tree > | A StaticGrove is an abstract class which declares methods to handle a set of trees |
►CBasicStaticGrove< Tree > | Basic implementation of a StaticGrove |
CBasicDynGrove< GroveKDTreeRaycaster, DynMovingObject > | |
CBasicDynGrove< Tree, Subject > | Basic implementation of a DynGrove which extends BasicStaticGrove to provided dynamic funcionalities |
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 ... > | |
CNonVoidStepLoop< bool > | |
►CVoidStepLoop< StepInput ... > | |
►CLinearVoidStepLoop<> | |
CSimulationStepLoop | Class extending LinearVoidStepLoop to support main simulation loop |
CLinearVoidStepLoop< StepInput > | Class extending VoidStepLoop to support a continous linear step loop without cyclic behavior |
CNonVoidStepLoop< StepOutput, StepInput > | Class extending StepLoop to support functions with non void return |
CVoidStepLoop< StepInput > | Class extending StepLoop to support functions with no return |
CUnivarExprTreeStringFactory< NumericType >::Symbol | UnivarExprTreeStringFactory sub-class used to represent symbols during recursive building |
Chelios::filems::SyncFileMeasurementWriterFactory | SyncFileMeasurementWriter 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 ... > | |
►Chelios::filems::MultiSyncFileWriter< WriteArgs ... > | |
►Chelios::filems::MultiLasSyncFileWriter< vector< Measurement > const &, glm::dvec3 const & > | |
►Chelios::filems::LasMultiVectorialSyncFileMeasurementWriter | Concrete class specializing MultiLasSyncFileWriter to write vectors of measurements to LAS files supporting concurrent multiple output streams |
Chelios::filems::Las14MultiVectorialSyncFileMeasurementWriter | Concrete class specializing MultiLasSyncFileWriter to write vectors of measurements to LAS-1.4 files supporting concurrent multiple output streams |
►Chelios::filems::SimpleMultiSyncFileWriter< WriteArgs... > | |
►Chelios::filems::ZipMultiSyncFileWriter< vector< Measurement > const &, glm::dvec3 const & > | |
Chelios::filems::ZipMultiVectorialSyncFileMeasurementWriter | Concrete class specializing ZipMultiSyncFileWriter to write a vector of measurements to multiple zip files |
Chelios::filems::ZipMultiSyncFileWriter< WriteArgs > | Abstract child of SimpleMultiSyncFileWriter which provides support for zipped output |
►Chelios::filems::SimpleMultiSyncFileWriter< vector< Measurement > const &, glm::dvec3 const & > | |
Chelios::filems::SimpleMultiVectorialSyncFileMeasurementWriter | Concrete class specializing a SimpleMultiSyncFileWriter to write vectors of measurements directly to files with support for concurrent multiple output streams |
Chelios::filems::MultiLasSyncFileWriter< WriteArgs > | Abstract specialization of MultiSyncFileWriter to write output in LAS format |
Chelios::filems::SimpleMultiSyncFileWriter< WriteArgs > | Abstract specialization of MultiSyncFileWriter to write output to many files. Each writing operation will be written to one file or another depending on the WriteArgs |
►Chelios::filems::SingleSyncFileWriter< WriteArgs ... > | |
►Chelios::filems::LasSyncFileWriter< Measurement const &, glm::dvec3 const & > | |
►Chelios::filems::LasSyncFileMeasurementWriter | SyncFileWriter implementation to write measurements in LAS format |
Chelios::filems::Las14SyncFileMeasurementWriter | LasSyncFileWriter implementation for LAS v1.4 format |
►Chelios::filems::LasSyncFileWriter< vector< Measurement > const &, glm::dvec3 const & > | |
Chelios::filems::Las14VectorialSyncFileMeasurementWriter | Concrete class specializing LasSyncFileWriter to write a vector of measurements to a LAS14 file |
Chelios::filems::LasVectorialSyncFileMeasurementWriter | Concrete class specializing LasSyncFileWriter to write a vector of measurements to a LAS file |
►Chelios::filems::SimpleSyncFileWriter< Measurement const &, glm::dvec3 const & > | |
Chelios::filems::SimpleSyncFileMeasurementWriter | Concrete class specializing SimpleSyncFileWriter to write measurements directly to a file |
►Chelios::filems::SimpleSyncFileWriter< FullWaveform const & > | |
Chelios::filems::SimpleSyncFileFullWaveformWriter | Concrete class specializing SimpleSyncFileWriter to write full waveform data directly to a file |
►Chelios::filems::SimpleSyncFileWriter< std::string const & > | |
Chelios::filems::SimpleSyncFileStringWriter | Concrete class specializing SimpleSyncFileWriter to write measurements directly to a file |
►Chelios::filems::SimpleSyncFileWriter< WriteArgs... > | |
►Chelios::filems::ZipSyncFileWriter< Measurement const &, glm::dvec3 const & > | |
Chelios::filems::ZipSyncFileMeasurementWriter | Concrete class specializing ZipSyncFileWriter to write compressed measurements to a file |
►Chelios::filems::ZipSyncFileWriter< FullWaveform const & > | |
Chelios::filems::ZipSyncFileFullWaveformWriter | Concrete class specializing ZipSyncFileWriter to write compressed full waveform data to a file |
►Chelios::filems::ZipSyncFileWriter< vector< Measurement > const &, glm::dvec3 const & > | |
Chelios::filems::ZipVectorialSyncFileMeasurementWriter | Concrete class specializing ZipSyncFileWriter to write a vector of measurements to a zip file |
►Chelios::filems::ZipSyncFileWriter< Trajectory const & > | |
Chelios::filems::ZipSyncFileTrajectoryWriter | Concrete class specializing ZipSyncFileWriter to write compressed trajectory to a file |
►Chelios::filems::ZipSyncFileWriter< vector< FullWaveform > const & > | |
Chelios::filems::ZipVectorialSyncFileFullWaveformWriter | Concrete class specializing ZipSyncFileWriter to write a vector of full waveform to a zip file |
Chelios::filems::ZipSyncFileWriter< WriteArgs > | Abstract child of SimpleSyncFileWriter which provides support for zipped output |
►Chelios::filems::SimpleSyncFileWriter< vector< Measurement > const &, glm::dvec3 const & > | |
Chelios::filems::SimpleVectorialSyncFileMeasurementWriter | Concrete class specializing SimpleSyncFileWriter to write a vector of measurements directly to a file |
►Chelios::filems::SimpleSyncFileWriter< Trajectory const & > | |
Chelios::filems::SimpleSyncFileTrajectoryWriter | Concrete class specializing SimpleSyncFileWriter to write trajectory directly to a file |
►Chelios::filems::SimpleSyncFileWriter< vector< FullWaveform > const & > | |
Chelios::filems::SimpleVectorialSyncFileFullWaveformWriter | Concrete class specializing SimpleSyncFileWriter to write a vector of full waveforms directly to a file |
Chelios::filems::LasSyncFileWriter< WriteArgs > | Abstract specialization of SingleSyncFileWriter to write output in LAS format |
Chelios::filems::SimpleSyncFileWriter< WriteArgs > | Abstract specialization of SingleSyncFileWriter to write output directly to a file |
Chelios::filems::MultiSyncFileWriter< WriteArgs > | Abstract class defining common behavior for all synchronous writers that work with multiple files at a time |
Chelios::filems::SingleSyncFileWriter< WriteArgs > | Abstract class defining common behavior for all synchronous writers that work with a single file at a time |
►CTaskDropper< TaskType, ThreadPoolType, TaskArgs > | Class which handles tasks dropping. It is, executing and then removing each task when dropping |
►CBuddingTaskDropper< PulseTaskDropper, PulseTask, PulseThreadPoolInterface, std::vector< std::vector< double > > &, RandomnessGenerator< double > &, RandomnessGenerator< double > &, NoiseSource< double > & > | |
CPulseTaskDropper | Class implementing a task dropper to deal with pulse tasks |
►CTaskDropper< TaskType, ThreadPoolType, TaskArgs... > | |
CBuddingTaskDropper< BudType, TaskType, ThreadPoolType, TaskArgs > | The budding task dropper is a task dropper which implements the logic for its own reproduction so buds (children) are modified depending on the difference between last idle time length and current idle time length |
CTaskWarehouse< Task > | Class implementing a warehouse to store and retrieve tasks in a thread safe fashion |
CTest | |
►CThreadPool | Base class providing core implementation of a thread pool to deal with multi threading tasks |
►CSimpleThreadPool< TaskArgs ... > | |
►CMDThreadPool< KDTreeBuildType, KDTreeNode *, bool const, vector< Primitive * > &, int const, int const > | |
CKDTreeFactoryThreadPool | Class implementing a thread pool to deal with multi thread KDTree building process |
►CResThreadPool< std::vector< std::vector< double > > &, RandomnessGenerator< double > &, RandomnessGenerator< double > &, NoiseSource< double > & > | |
CPulseThreadPool | Class implementing a thread pool to deal with pulse tasks |
CMDThreadPool< MDType, TaskArgs > | Abstract class extending basic thread pool implementation to provide a basis layer to handle tasks with associated data |
CResThreadPool< TaskArgs > | Abstract class extending basic thread pool implementation to provide a basis layer to handle thread associated resources |
►CWarehouseThreadPool< PulseTaskDropper > | |
CPulseWarehouseThreadPool | Class implementing a warehouse thread pool to deal with pulse tasks |
CSimpleThreadPool< TaskArgs > | Abstract class providing implementation of a simple thread pool which assigns tasks to threads |
CWarehouseThreadPool< Task > | Thread pool which starts thread so they are always waiting for new tasks to be posted to the warehouse to compute them |
CTimeWatcher | A time watcher can be used to perform and report time measures |
CTrajectory | Class representing a concrete trajectory definition |
CVectorial | Class to perform util vector operations |
CVertex | Class representing a vertex |
CVertexKeyEqual | Struct to compare vertex when using unordered set |
CVertexKeyHash | Struct to obtain vertex hash when using unordered set |
►Cvisualhelios::VHCanvas | Visual Helios Canvas is a class which provides the base mechanisms to implement Helios visualizations |
►Cvisualhelios::VHDynCanvas | Visual Helios Dynamic Canvas is a class which provides the basis layer to deal with dynamic objects rendering in a general purpose fashion |
►Cvisualhelios::VHNormalsCanvas | Abstract class providing some behaviors and defining the interface for all canvas which deal with normals |
►Cvisualhelios::VHSceneCanvas | Visual Helios Scene Canvas is a class which supports rendering a dynamic scene |
Cvisualhelios::VHRaycastingCanvas | Visual Helios Ray casting Canvas is a class which supports rendering a dynamic scene together with the rays emitted by the scanner |
Cvisualhelios::VHSimpleCanvas | Visual Helios Simple Canvas is a class which supports rendering polygon meshes which are updated over time |
Cvisualhelios::VHDynSceneAdapter< ST, DT > | Class defining core mechanisms to adapt dynamic scenes to the visual Helios context based on PCL and VTK libraries |
Cvisualhelios::VHScannerAdapter | Abstract class defining core mechanism to adapt scanners to the visual Helios context based on PCL and VTK libraries |
►Cvisualhelios::VHStaticObjectAdapter | Abstract class defining core mechanisms to adapt static objects to the visual Helios context based on PCL and VTK libraries |
►Cvisualhelios::VHDynObjectAdapter | Abstract class defining core mechanisms to adapt dynamic objects to the visual Helios context based on PCL and VTK libraries |
Cvisualhelios::VHDynObjectXYZAdapter | Class providing concrete implementation of a VHDynObjectAdapter for a simple XYZ visualization with no color nor intensity |
Cvisualhelios::VHDynObjectXYZRGBAdapter | Class providing concrete implementation of a VHDynObjectAdapter for a simple XYZ visualization with RGB color |
►Cvisualhelios::VHStaticObjectXYZAdapter | Class providing concrete implementation of a VHStaticObjectAdapter for a simple XYZ visualization with no color nor intensity |
Cvisualhelios::VHDynObjectXYZAdapter | Class providing concrete implementation of a VHDynObjectAdapter for a simple XYZ visualization with no color nor intensity |
►Cvisualhelios::VHStaticObjectXYZRGBAdapter | |
Cvisualhelios::VHDynObjectXYZRGBAdapter | Class providing concrete implementation of a VHDynObjectAdapter for a simple XYZ visualization with RGB color |
CVoxelFileParser | Class for parsing voxel files |
CVoxelGridCell | VoxelGridCell is used to build and fill all necessary voxels to represent input point cloud |
CWavefrontObj | Class representing a .obj loaded file |
CWavefrontObjCache | |
CWaveMaths | Some 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::DirectFullWaveformWriteStrategy | Concrete class specializing WriteStrategy to directly write full waveform data to a file |
Chelios::filems::ZipFullWaveformWriteStrategy | Like DirectFullWaveformWriteStrategy but zipping the output |
►Chelios::filems::WriteStrategy< Measurement const &, glm::dvec3 const & > | |
►Chelios::filems::DirectMeasurementWriteStrategy | Concrete class specializing WriteStrategy to directly write measurements to a file |
Chelios::filems::ZipMeasurementWriteStrategy | Like DirectMeasurementWriteStrategy but zipping the output |
Chelios::filems::LasMeasurementWriteStrategy | Concrete class specializing WriteStrategy to directly write measurements to a file with LAS format |
►Chelios::filems::WriteStrategy< std::string const & > | |
Chelios::filems::DirectStringWriteStrategy | Concrete class specializing WriteStrategy to directly write strings to a file |
►Chelios::filems::WriteStrategy< Trajectory const & > | |
►Chelios::filems::DirectTrajectoryWriteStrategy | Concrete class specializing WriteStrategy to directly write trajectory to a file |
Chelios::filems::ZipTrajectoryWriteStrategy | Like DirectTrajectoryWriteStrategy but zipping the output |
►Chelios::filems::WriteStrategy< vector< WriteArg > const &, BiasType ... > | |
Chelios::filems::VectorialWriteStrategy< WriteArg, BiasType > | Concrete class specializing WriteStrategy to make any other write strategy operate over a vector |
Chelios::filems::WriteStrategy< WriteArg const &, BiasType ... > | |
►CXmlAssetsLoader | Class for asset loading from XML file |
CXmlSurveyLoader | Survey loader from XML |
CXmlSceneLoader | Class for scene loading from XML file |
CXmlUtils | Common 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 |
►CWriteYielder< Measurement > | |
CPointcloudYielder | Yield a point cloud from measurements so it is written when buffer size has been reached or, alternatively, when yielder is directly forced to yield |
►CWriteYielder< FullWaveform > | |
CFullWaveformYielder | Yield a set of full waveforms from single full waveform data so it is written when buffer size has been reached or, alternatively, when yielder is directly forced to yield |
CWriteYielder< T > | Abstract class representing a write yielder. It is, a yielder which can use the FMSWriteFacade to write its output |
►Cruntime_error | |
CSurfaceInspector::util::SurfaceInspectorException | Base class for surface inspector exceptions |
Cfluxionum::FluxionumException | Base class for fluxionum exceptions |
Crigidmotion::RigidMotionException | Base class for rigid motion exceptions |