 |
NDEVR
API Documentation
|
|
NDEVR
API Documentation
|
| C_GRD< t_point_type > | 3D grid data structure holding scalar field values and node data for marching cubes isosurface extraction |
| CAboutDialog | Shows information about the current software version |
| CAbstractHyperGraphElementCreator | Abstract interface for allocating HyperGraphElement |
| CActiveGPSSensor | Describes an active GPS sensor with its connection details and sensor pointer |
| CAdaptiveTCPClient | TCP client that implements the NDEVR communication protocol over a QTcpSocket |
| CAdaptiveTCPServer | TCP server implementation of NDEVRCommunicationLogic using Qt's QTcpServer for NDEVR protocol |
| CAdaptiveWebClient | WebSocket client that implements the NDEVR communication protocol over a QWebSocket |
| CAdaptiveWebServer | WebSocket server implementation of NDEVRCommunicationLogic with optional SSL/TLS support |
| CAerialImageRequest | Contains the information for requesting a 2D top-down view of a geographic location to be used with a AerialImage service such as google earth |
| CAerialImageSettings | Dialog for showing an AerialImage or top down view rendered with a service like google earth with user controls for adjusting view |
| CAlignmentDeterminator< t_type > | Determines the optimal memory alignment for a given type based on its size |
| CAndroidHelperFunctions | Dummy class for API inclusion |
| CAngle< t_type > | Stores an angle in an optimized internal format with support for efficient trigonometric operations |
| CAngleDefinitions | Logic for converting between Euler angles and basic rotations or normals |
| CAPIDirectoryManager | Collects headers, libraries, DLLs, and resources from source and output directories and assembles them into an API distribution folder |
| CAPIResource | Describes a single file resource to be included in the API directory, along with its relative path within the output structure |
| CApplicationLauncherButtonManager | Creates a button for launching a 3rd party application |
| CApplicationOptionBase | The core of the default object to store data of any type that should persist through sessions of the application |
| CApplicationOptions | The container for storing N-number of ApplicationOption for the program |
| CApplicationResource | High-Level functions for communicating with the operating system or getting general information about the application |
| CArialColorTheme | Allows the user to specify a color theme for a Aerial image request |
| CAsciiIODataBlock | Represents a rectangular block of data within an ASCII table page, providing a callback to retrieve typed cell values by row/column index |
| CAsciiOptions | Storage class for all IO options related to an Ascii file output used by an IOFactory services that write to Ascii |
| CAsciiTableIOData | Holds the data and file paths needed for ASCII table-based import/export operations, including one or more data blocks and template/output file locations |
| CAssimpSceneMemory | Stores all of the objects needed for an aiScene in a way that is efficient and uses native containers |
| CAtlas | Manages a collection of maps for the ORB-SLAM system |
| CAutomatedTest | Base class for performing a test for easily testing certain software functionality |
| CAutoZoomFocus | Logic for automatically zooming a Camera or Viewport to a certain location or having certain objects in focus of the frame |
| CAxisAngle< t_angle_type, t_axis_type > | An angle about a particular, defined 3D axis |
| CBackgroundandLightingEditor | A dialog for allowing the user to specify a background or sun position of a particular camera or viewport |
| CBandMatrix< t_type > | Band Matrix solver |
| CBase64Encoder | Functions for converting to and from Base64 https://en.wikipedia.org/wiki/Base64 |
| CBaseMultiEdge< t_dims, E >::HessianHelper | Helper for mapping the Hessian memory of the upper triangular block |
| CBaseValues | Dummy class to ensure creation of an include file around core root values |
| CBatteryAlertWatcher | Listens for changes to a Battery and reports an error to the user when thresholds are crossed |
| CBatteryCapacityInfo | For a given BatteryCapacityType, the limits that define the state of the battery |
| CBCrypt | Provides bcrypt password hashing and validation functions |
| CBinaryCompressionObject | A container for storing compressed data, typically used for File IO operations |
| CBinaryFile | Logic for reading or writing to a binary file including logic for compressing or decompressing the file |
| CBinaryHeap< t_comp_type, t_value_type, t_is_min > | A heap data structure that takes the form of a binary tree which is a common way of implementing priority queues |
| CBiRadialObject< t_dims, t_type, t_vertex > | An ellipse like shape (such as an oval or egg) with two points, where all points on the shape are equal distance between the two points (distanceTo(A) + distanceTo(B) = radius) |
| CBitAlignedBuffer | A buffer that stores elements using a configurable number of bits per element |
| CBitFlag | A bitset that stores 8 bits (elements with only two possible values: 0 or 1, true or false, ...) |
| CBitIterator | Simple bit iterator, typically used for parsing Buffer of bools in loops |
| CBitReference | A convenience class used with Buffers or Vectors of bools for referencing or acting on a single bit |
| CBlockLookupNode< t_size, t_index_type > | A fixed-size 3D lookup table mapping spatial indices to flat array positions in a block model |
| CBlockLookupNode< t_size, uint04 > | |
| CBlockModelCache< t_point_type, t_weight_type > | Cache for collecting block model vertex positions, colors, and weights during batch updates |
| CBlockModelFactory | Reads block model data from .grd files into a Model's geometry |
| CBlockModelFilteringCache< t_point_type, t_weight_type > | Abstract cache interface for filtering block model raster data based on spatial criteria |
| CBlockModelFilteringCache< t_point_type, uint04 > | |
| CBlockSolve< t_type > | Convenience typedefs for commonly used BlockSolver configurations |
| CBlockSolverTraits< t_solver, _PoseDim, _LandmarkDim > | Traits to summarize the properties of the fixed size optimization problem |
| CBoilerMaker | Reads a boilerplate copyright/license header template and applies file-specific substitutions, producing the standard header block for generated source files |
| CBounds< 1, Angle< fltp08 > > | |
| CBounds< 2, Angle< fltp08 > > | |
| CBubbleLevelWidget | A widget that displays a 2D bubble level visualization based on tilt angles from an OrientationSensor, providing visual feedback for device leveling |
| CBufferAllocator< t_type, t_aligned_size, t_is_primitive, t_index_type, t_null_term, t_allow_reference > | Specific logic for reserving memory for a Buffer |
| CBufferAllocator< bool, 0, true, t_index_type, false > | Specific logic for allocating booleans in a Buffer |
| CBufferBase | A dummy class for easy tracking of inheritance with templated Buffers |
| CBufferFunctions | A dummy class to include complex Buffer insert and sort functions Functions that enhance the functionality of the Buffer class |
| CBufferInsertIterator< t_type, t_buffer > | Used by stl library to insert objects into the buffer |
| CBuildActionDefines | Provides static constants, option group builders, and metadata queries for the build action system, including icons, categories, descriptions, and supported actions |
| CBuildActionUIDefinition | Describes how a build action should be presented in the application UI, including ribbon and tree placement |
| CBulgeConverter | Converts CAD Bulge objects into arc shapes that can be used by the NDEVR API |
| CButton | A core widget that allows the user to click one of many button types |
| CButtonDialog | Typically used for dialogs which have any number of buttons associated with it that are toggled on when the dialog is visible, and off when the widget is invisible |
| CCachedTile | Stores a cached GeoTIFF tile with precomputed layout information for fast elevation sampling |
| CCADColorInfo | Stores color information for interfacing with CAD |
| CCADDictionaryObject | A container for information pointing to a CAD dictionary in CAD memory |
| CCADEntityStreamer | A base-class for streaming out CAD entities from a file or CAD program memory |
| CCADGeometryWriter | Streams NDEVR Geometry entities as CAD objects |
| CCADHandleManager | Handles converting NDEVR API UUID objects into CAD HANDLE IDs |
| CCADHelperFunctions | Useful functions for interfacing with the standard CAD environment |
| CCADImageData | Logic for storing a image data in a CAD-friendly way for exporting and importing |
| CCADVariable | A variable shared between NDEVR and CAD |
| CCADWriteModifier | An interface that can handle writing certain entities in a special way to the CAD environment |
| CCalibrationPosition | Represents a physical position and orientation used during IMU calibration, along with the sensor readings collected at that position |
| CCalibrationReading | Represents a location used for calibrating an IMU |
| CCalibratorWidget | A widget that allows the user to interact with an IMUCalibrator object and perform an IMU calibration |
| CCameraActionCombo | Allows user to adjust the primary behavior of the mouse in the 3D view, such as enabling panning, orbit, lookat etc |
| CCameraAnimation | A container for information relating to a Camera 3D animation such as zooming or rotating around a target |
| CCameraBackground | Logic for rendering the background to a 3D user view |
| CCameraManager | Forward declaration of the skybox environment rendering class |
| CCameraOptions | Camera intrinsic and distortion parameters |
| CCameraRulerMenu | A menu that provides options for configuring ruler visibility, grid display, and camera locking for a viewport |
| CCameraToolbar | Typically shown under a virtual camera view, allows the user to input various settings for a camera or viewport |
| CCameraUniformObject | A structure containing common information pushed to the video card for NDEVR Rendering Engine operations |
| CCaptureInfo | Information relating to capturing a 3D view into a 2D raster image |
| CCAverageSignalQuality | A widget that displays the average signal quality across all tracked satellites as a single animated indicator |
| CCAzimuthElevationWidget | A skyplot widget that renders satellite positions in an azimuth-elevation polar diagram, showing their relative positions and signal strengths |
| CCheckForUpdatesDialog | A dialog designed to show whether or not the application needs to be updated or the state of the update |
| CCheckoutCode | Provides static helper methods that create and display build action workflows for common source checkout and generation operations |
| CCheckoutLock | Used by Viewports to signal they are rendering and we should not be performing an Update |
| CCheckSumGenerator< t_hash_type > | Logic for generating checksums based on initial value and a type |
| CCloth | The data and operations for performing bare earth using Cloth simulation |
| CCloudtoCloudDistance | A filter which removes objects that are too far away from a given cloud and a Cloth |
| CCodeStatistics | Scans source files and collects statistics such as line counts, class counts, comment density, indentation metrics, and other code-quality indicators |
| CCollimatorSettings | Logic for handling Images in the NDEVR space, including dialogs and imports |
| CColor | The core Color class in the NDEVR API |
| CColorByValueWidget | Allows the user to select a property and range to color a Model or Scene |
| CColorChannelCombo | Allows the user to select a method to color a particular channel |
| CColorOptions | Provides default color resources used throughout the NDEVR API |
| CColorPalettes | Provides predefined color palettes for use with materials and data visualization |
| CColorPositionShaderLogic | GPU compute shader that converts depth and color raster frames into 3D colored point positions |
| CColorPositionShaderLogic::UBO | Uniform buffer object layout for the color-position compute shader |
| CColorThemeButton | A button for adjusting the color theme used by the NDEVR engine (Typically light or dark color palettes) |
| CColumnDetails | Stores the data for AsciiModelFileDialog user specified columns |
| CCommandInformation | Stores long-term statistics for commands executed using HardwareCommandQueue |
| CCommandLineRepresentation | Represents a parsed command-line invocation with a command name and its arguments |
| CCommandLockObject | Used with DesignObjectLookups to lock the application for a critical process |
| CCommandPacket | Packet payload for text commands between client and server |
| CCompressedStringInfo | Contains information for referencing compressed strings |
| CCompressor | A series of static methods designed to compress objects and reduce their memory consumption or file size |
| CConcavePolygon< t_type, t_vertex > | Stores convenience functions for a concavec polygon Works on a Polygon object to decompose it into triangles or sub-polygons |
| CConcurrentOperation | Contains thread-safe operations for inter-thread logic Increment and Decrement can be used to safely add to a shared uint04 value |
| CConfigType | Stores String variables reprenting the type of compile configuration that will be supported by a particular Module or resource (debug vs release) |
| CConnectionBackend | Provides the unseen backend logic for setting up, tearing down, and sending data over a specific type of connection |
| CConnectionCategory | A category represents the type of connection |
| CConnectionDialog | A virtual dialog that provides an interface that allows the user to adjust certain parameters for a Connection |
| CConnectionForwardingDialog | A table that allows the user to specify any number of ConnectionForwarding objects |
| CConnectionInfo | A structure designed to store information about a specific Connection |
| CConnectionPipeStream::CommonMessageFormats | Common formats for sending messages over the pipe using setMessageSendFormat Default progress format is message_line |
| CConnectionPipeStream::CommonProgressFormats | Common formats for sending messages over the pipe using setMessageProgressFormat Default progress format is percent |
| CConnectionSearchParameters | Describes settings for performing a Connection search |
| CConnectionWidget | A small widget that can be shown that allows the user to attempt a connection, disconnect, or even define a connection |
| CConstant< t_type > | Defines for a given type (such as sint04, fltp08, UUID, etc) a maximum, minimum, and reserved 'invalid' value |
| CConstant< Matrix< t_type, t_row_dims, t_col_dims > > | |
| CConstant< Model > | Provides the canonical invalid constant for the Model type |
| CConstant< Plane< t_dims, t_type > > | |
| CConstant< Quaternion< t_type > > | |
| CConstBitIterator | Simple bit iterator, typically used for parsing Buffer of bools in loops |
| CConstraint | Constains two particles for use in the CSF filter |
| CConstraintPoseImu | Stores a prior constraint on an IMU pose with its information matrix |
| CControllerInterface::ControllerInput | Base structure for all controller input types |
| CConverter | Utility class for converting between OpenCV, Eigen, Sophus, and NDEVR matrix types |
| CCoordinateConverter | Forward declaration of the File class |
| CCoordinateConverterDialog | A dialog that allows the user to set a Coordinate projection for the current project |
| CCoordinateOptions | Stores ApplicationOptions related to coordinates |
| CCoordinateProjection | Basic data about a particular coordinate projection |
| CCoordinateProjectionChooser | Allows the user to select a coordinate projection from a list of ones available |
| CCoordinateProjectionManager | Stores Coordinate Projections See https://ndevr.org/coordinate-projection/ |
| CCopyOperations | A collection of buffer copy steps for batched copy operations |
| CCopyStep | A single step in a buffer copy operation, tracking the copy regions and direction |
| CCorrespondance | Stores a correspondence between a reference point and a point to register |
| CCPositionStatusWnd | A widget that displays the current GPS position status information including coordinates, fix quality, and satellite count |
| CCreateAccountDialog | Dialog for creating a new user account on an OWL server |
| CCredentials | Stores user authentication credentials including username, password, and validation state |
| CCSFParams | Contains parameters for performing a Cloth surfacing operation |
| CCSignalQuality | A bar chart widget that displays per-satellite signal quality (SNR) with animated transitions and constellation-based coloring |
| CCustomDesignChartDialog | A chart that allows the user to select data from a model to plot as a scatter plot |
| CCustomModelBuilder | Generates boilerplate header and source files for a custom Model subclass, optionally including a companion CustomModelLogic behavior class |
| CCustomModelLogic | An easy interface for adding common SoftwareInterfaces relating to a Model to the program logic |
| CCustomUnit | A program-defined unit that can be used for some specific task different from a program-wide unit |
| CDatabase | Provides access to a set of named database tables |
| CDatabaseFilesEditor | Widget for browsing and editing files stored in the NDEVR database |
| CDatabaseStatus | Widget that displays the current status of the NDEVR database server |
| CDatabaseUsersEditor | Widget for managing users registered in the NDEVR database |
| CDataPacketHeader | Packet header for compressed point cloud data |
| CDataset | Forward declaration of the Model class |
| CDatasetManager | Used to group datasets (DEPRECIATED) |
| CDBFParser | Logic for reading or writing to a database file that uses the .dbf file extension |
| CDefaultMaterials | Provides default materials that can be used within the NDEVR API |
| CDefaultSetter< t_type > | Helper struct that copies the default value from one TableColumn to another |
| CDefaultSetter< Buffer< t_buffer_type > > | Specialization of DefaultSetter for Buffer types |
| CDefaultSetter< String > | Specialization of DefaultSetter for String types |
| CDeferredImageIconEngine | Used to render any icons when they are needed |
| CDelimiterIterator | A class that quickly allows iteration through text |
| CDeploymentInfo | Parameters describing a deployment session for a DistanceEncoder and its associated sensor |
| CDeploymentOptions | Stores ApplicationOptions related to Deployments |
| CDeploymentUnit | A CustomUnit that is used to define the length of a Deployment |
| CDeploymentWidget | A widget used for allowing the user to quickly setup an OrientationSensor for a Deployment |
| CDepthAISmoother | A ViewportPointSmoother specialized for DepthAI cameras, converting between pixel coordinates and 3D points using the camera's intrinsic matrix |
| CDepthConsistencyPushConstants | Push constants for depth consistency shader |
| CDepthEstimateResult | Result from a single depth estimation pass |
| CDesignCommand | Forward declaration of the central design object registry |
| CDesignCommandManager | Stores logic for performing, undoing, or redoing DesignCommands |
| CDesignInfo | Base information class for all design objects in the NDEVR property database |
| CDesignObjectBase | Provides the underlying data storage for the NDEVR Scene Model hierarchy |
| CDesignObjectChooser | Provides a screen of buttons that allow the user to pick a Model for an action |
| CDesignObjectDialogLookup | Manages the creation and lookup of DesignObjectDialog instances for design objects |
| CDesignObjectInterface | Base level class providing convenience functions for interfacing with one or more DesignObjects |
| CDesignObjectLookup | A core class where all Design Objects including models, materials, and geometries are stored |
| CDesignObjectResourceCache | A cache for reusing Model and Geometry objects to avoid repeated allocation |
| CDesignObjectUpdateTarget | An object that will be called to update each time the lookup is updated |
| CDesignObjectWidgetInterface | A base class for interacting with one or more DesignObjects |
| CDesignParameter | A definition of data that is logically stored in the Model hierarchy |
| CDesignPropertyTable | A base class for tables wishing to show columns of DesignObject properties |
| CDesignPropertyTableView | A QTableView for showing Model or DesignObject properties |
| CDesignSelection | A simple structure for storing a collection of data |
| CDesignSortFilterProxyModel | Provides the ability to pull data from a DesignObjectLookup for display in tables within the NDEVR API and filter and sort it |
| CDesignTableEditorWidget | A widget that pairs a DesignPropertyTable with a stacked editor panel, allowing the user to select a row and edit its details in an adjacent editor created by a callback |
| CDesignTableModel | Provides the ability to pull data from a DesignObjectLookup for display in tables within the NDEVR API |
| CDesignTask | A task which is to be executed by a DesignObjectLookup |
| CDesignTaskManager | Manages all active and inactive tasks for a DesignObjectLookup |
| CDesignWidget | A widget showing key properties of a DesignObject selection, used primarily in a SelectionWidget |
| CDesignWidget::PropertiesStruct | Aggregated rendering properties of the current selection, used to update UI controls |
| CDesignWidgetCache | Cached computed values for a DesignWidget, avoiding recalculation when the selection has not changed |
| CDeveloperSettingsDialog | A settings dialog widget that exposes developer-related application options such as paths to build tools, source directories, and licenses |
| CDeveloperVariables | Stores application-level developer options and environmental variable references used throughout the build and development tool system |
| CDeviceFinder | Base class for finding devices connected to the system |
| CDeviceManager | Container for all active Devices connected to the software |
| CDeviceUpdateThread | A class that updates a device by repeatedly calling update() until stop() is called |
| CDeviceWatcher | Watches and alerts the program when a USB device is plugged in or unplugged |
| CDeviCounterSettingsDialog | Settings dialog widget for configuring and monitoring a DeviCounter distance encoder |
| CDialIcon | An icon along with defined behavior describing how that icon should interact with a parent QCustomDial object |
| CDictionaryBase | A dummy base class for all Dictionary templates Used to more easily track inheritance for the templated Dictionary class |
| CDimensionOptions | Options for CAD dimension objects |
| CDistance | Dummy class for including distance functions |
| CDockInit | Provides a way to optionally lazily initialize widgets when needed but still pass them to container docks |
| CDockItem | The root class that allows interface with the NDEVR API Widget Docking system |
| CDownloadDatasetWidget | A popup that is shown when a remote project is being downloaded |
| CDrawCommandsWidget | A widget for interfacing with GeometryMaker to allow the user to draw 3D objects or shapes |
| CDropOverlay | Paints a translucent rectangle over another widget |
| CDropOverlayCross | Shows a cross with 5 different drop area possibilities |
| CDS5W::_AnalogStick | Analog stick |
| CDS5W::_Color | RGB Color |
| CDS5W::_DeviceContext | Device context |
| CDS5W::_DeviceEnumInfo | Struckt for storing device enum info while device discovery |
| CDS5W::_DS5InputState | Input state of the controler |
| CDS5W::_PlayerLeds | Player leds values |
| CDS5W::_Touch | Touchpad state |
| CDS5W::_TriggerEffect | Trigger effect |
| CDS5W::_Vec3 | 3 Component vector |
| CDualSenseFactory | Factory class that discovers and registers connected DualSense controllers |
| CDXFAttributes | DXF Style attributes that can be applied to CAD Entity objects |
| CDXFReader | Logic for reading from a DXF stream of data |
| CDXFValueManager | DXF streams store data in a large numbered index structure |
| CDXFWriter | Handles writing data to a CAD entity stream |
| CEditor | A base class for displaying options for editing a single DesignObject, typically a Model |
| Ceint04< t_enum_type > | Allows enum class variables to operate as 32 bit uint04 values |
| CElevationRequest | Stores options and receives data for determining the elevation at given coordinates |
| CEnclosedModelInfo | Forward declaration for geometry vertex data |
| CEncodedMessage | Represents an encoded message associated with a resource version, including header and body |
| CEncoderSettings | Configuration settings for a DeviCounter rotary encoder device |
| CEPSG4326TileHelper | Provides coordinate conversion utilities between EPSG:4326 (WGS84) and tile coordinates |
| CEquation< t_type > | A solvable mathematical formula composed of variables, numbers, and operations |
| CEquation< t_type >::EquationPart | Represents a single element in the equation stack, consisting of an operator and a value |
| CEvent | Base class for user-driven events which are typically KeyEvent or MouseEvent |
| CException | Provides consistent interface to handle errors through the throw expression |
| CExecutableManager | Provides static methods for building executable projects, resource files, and platform-specific build artifacts from a module list |
| CEXIFInfo | Stores and parses EXIF and XMP metadata extracted from a JPEG image stream |
| CEXIFInfo::Calibration_t | Camera calibration information derived from EXIF metadata |
| CEXIFInfo::Geolocation_t | GPS and flight telemetry information embedded in the image file |
| CEXIFInfo::Geolocation_t::Coord_t | Geographic coordinate expressed in degrees, minutes, and seconds |
| CEXIFInfo::GPano_t | Google Photo Sphere (GPano) spherical metadata |
| CEXIFInfo::LensInfo_t | Lens information extracted from EXIF metadata |
| CEXIFInfo::MicroVideo_t | Google camera micro-video metadata embedded in the image file |
| CEXIFStream | Abstract interface for providing a stream of bytes to the EXIF parser |
| CExportChooserDialog | Allows the user to choose a specific Export format for use with IOFactory exporting |
| CExportRequest | Stores information related to exporting specific data from the software |
| CExternalApplicationManager | Manages an external application |
| CExtractorNode | A quadtree node used for distributing ORB keypoints across the image |
| CExtruder | Provides static functions to extrude 2D/3D shapes along polyline paths, generating triangulated solid geometry |
| CExtrusion | Logic for storing a extrusion data in a CAD-friendly way for exporting and importing |
| CExtrusionData | Data for extruding an object onto a plane in CAD |
| CFactoryFeatures | Allows IOFactories to report what features they support to make the import/export dialogs easier to setup and layout |
| CFactoryModelFilters | Provides easy filtering tools for factories that are only able to export certain types of models or geometries |
| CFactoryParameters | A container of input information that is to be filled with output information by an IOFactory |
| CFeatureExtractionResult | Output from feature extraction, consumed by matching and SfM stages |
| CFeatureOptions | Logic for checking or enabling software features |
| CFFTLogic< t_type > | Provides Fast Fourier Transform logic for converting signals between the time and frequency domains |
| CFieldChooser | A Widget for setting up and choosing a Field used for importing and exporting data |
| CFileAndFolderOptions | Stores ApplicationOptions related to user preferences for paths and program behavior relating to directories |
| CFileAndFolderSettingsDialog | Allows the user to adjust default folders or whether or not the software uses project folders or project files |
| CFileCachedData | Data that is cached from a file into program memory to limit expensive file lookups |
| CFileDropFrame | A simple frame that allows the user to drag and drop a file into it |
| CFileFactoryWarning | Allows the software to display a warning to the end user about a problem encountered during an IOFactory read/write operation |
| CFileFormat | Data that describes a particular file format and how to use the format with the program |
| CFileHanderExtension | A description of the type of file a Module or resource can handle |
| CFileHandlerVerb | Stores variables needed to perform a file action for a particular Module or resource |
| CFileOptions | Stores program-wide variables for controlling how the software works with file systems |
| CFileRequest | A FileRequest bundles format data as well as a particular file |
| CFileResource | Contains methods for getting information about particular OS directories or static program file directories |
| CFileSearch | Logic for searching for files based on some criteria |
| CFileServerSettingsDialog | Settings dialog for configuring and managing the NDEVR file server |
| CFilterSettings | Settings that control spatial and density filtering of scanned point data |
| CFindFileFunction | Represents a request for the user to locate a missing file needed by an IOFactory operation |
| CFloatingWidget | Used with the NDEVR API Widget Docking system for widgets that are floating |
| CFont | Information for how to display text data |
| CFontEditor | A series of widgets that allow the user to adjust a font |
| CFontEngine | Stores many different types of font |
| CForceLinker | Helper struct that forces linkage with a static library by calling a function at construction time |
| CFormula | Logic for storing the definition of a formula, that can be displayed to the end-user |
| CFormulaDialog | Allows the user to see and edit a formula |
| CFormulaTree | Logic that saves formulas into a tree-like dependency structure |
| CFragUniformObject | Items to send to the OpenGL Fragmentation shader |
| CFrame | Represents a single image frame with extracted features and pose information |
| CFrameInfo | Shared camera intrinsic and image metadata for frames |
| CFrameView | Holds per-view (left or right) keypoint data for a frame |
| CGaussianRN< ia, im, iq, ir, ntab > | Used to generate a random number over a Gaussian distribution with templated setup parameters for very quick speed |
| CGDirection | Represents the gravity direction as a rotation for optimization |
| CGenericOption | Stores a generic option of any type as well as some information about how the user might interact with that type |
| CGenericOptionGroup | Stores a groups of GenericOptions that can be used to group them |
| CGenericOptionsGroup | Creates a clean formatted dialog for any number of GenericOptions within a GenericOptionGroup Each option is labelled |
| CGenericOptionsWidget | Automatically creates a widget based on a GenericOption |
| CGeometricCamera | Abstract interface for geometric camera models (pinhole, fisheye, etc.) |
| CGeometricConsistencyPushConstants | Push constants for geometric consistency shader |
| CGeometricTools | Utility class for geometric computations between keyframes |
| CGeometry::OptimizedPrimitiveDef | Pre-computed offsets and references for fast primitive index access without repeated lookups |
| CGeometry::SmoothingParameters | Parameters controlling mesh smoothing operations |
| CGeometryMaker::GeoStructure | Holds the structural definition points used during interactive geometry creation, including center, normal, edge, corner, and plane constraint points |
| CGeometryPositionModRestore | Class to easily restore calculated data in a Geometry after a location altering process |
| CGeometrySelectionOptimizer | Interface for processing and optimizing geometry selections |
| CGeometryVertices | A container for storing vertex data associated with geometry, including positions, normals, colors, timestamps, and a spatial index (RTree) for efficient spatial queries |
| CGeoTiffInfo | Stores parsed GeoTIFF metadata including projection, tiepoints, and raster dimensions |
| CGettingStartedDialog | This dialog is shown front and center before the user has loaded any data or created a project In touch mode large buttons are shown, while the company logo is shown as a backdrop in Desktop mode |
| CGLCapabilities | Capabilities provided by a GLESGraphicsDevice |
| CGLESImageManager | Manages all images within the Vulkan space |
| CGLESMaterialManager | Structure responsible for handling the OpenGL data surrounding a particular Material object |
| CGLESRenderObject | A root render Object for OpenGL, which consists of a set Material, Model, and Geometry that is used together to optimally create a 3D render |
| CGLESShader | A Shader for rendering default OpenGL logic to the graphics card |
| CGLESShader::Definition | Defines the set of features a shader must support, used to select or compile the correct variant |
| CGLESShaderManager | Manages all shaders used with OpenGL and the NDEVR API |
| CGLESVertexManager | Manages vertex buffers for the OpenGL engine |
| CGLESVertexUniformObject | Stores items to send to the OpenGL Vertex Shader |
| CGNSSConfigCallback | Callback descriptor for GNSS configuration options displayed in the GPS dialog |
| CGNSSQualityOptionsWidget | A widget that allows the user to edit quality-dependent GNSS reading settings such as sample count, sample time, color, and take-reading permission |
| CGNSSQualitySettings | Configures quality-dependent settings for GNSS readings, including sample counts, timing, display color, and whether reading is permitted |
| CGNSSRole | A GNSS role describes how the user wants to use a particular GNSS Device |
| CGNSSSatelliteInfo | Information about a single GNSS satellite as reported by a receiver |
| CGNSSSettingsDialog | A settings dialog for configuring GNSS roles and quality-level thresholds for both position and orientation readings |
| CGNSSStatusWidget | A compact widget displaying the current GNSS connection status, accuracy, and an LED indicator for quick visual assessment |
| CGoogleEarthApplicationManager | Manages the integration with Google Earth Pro, exporting project data as KML and launching the external application for visualization and data collection |
| CGPSAlignmentResult | Result of a GPS-based similarity transform (SfM -> ENU) |
| CGPSDialog | The main GPS configuration dialog providing connection management, satellite status display, quality indicators, and file-based GPS input |
| CGPSPoint | A geographic coordinate point produced by a GNSS receiver |
| CGPSWidget | A composite GPS widget that combines a settings button, status display, and take-reading functionality for collecting GNSS position and orientation data |
| CGraphicsCameraManager | A structure for managing Viewport interactions with an NDEVR Rendering Engine |
| CGraphicsDevice | A physical or virtual device used with the NDEVR Rendering Engine |
| CGraphicsPipeline | A GraphicsPipeline is a set of resources that are chained together to correctly render something |
| CGraphicsSession::GeometryUpdateObject | Tracks a geometry and its last modification time for incremental updates |
| CGraphicsUpdateArguments | Options that are used for performing an update on a Graphics Engine call |
| CGravityIntersection | Computes gravity-based intersection transforms by casting rays along a gravity vector and finding where they intersect scene geometry |
| CGridIndexing< t_dims > | Converts 1 dimensional index into N dimensional index based on size of each dimension |
| CGStreamerVulkanWriter | Captures Vulkan framebuffer images and encodes them to an MP4 video file via GStreamer |
| CHandleData | A handle used to reference an object in CAD |
| CHardwareCommandQueue< t_type > | A base class for communicating with Hardware, typically firmware by the software |
| CHardwareCommandQueue< t_type >::CommandQueueItem | An item in the command queue containing the command, arguments, and validation regex |
| CHardwareCommandQueue< t_type >::CommandRecord | A record of a command execution with timing information |
| CHardwareInformation | Contains information about a computer or device that is capable of running software typically with a CPU and memory |
| CHardwareSearchParameters | Options for finding active hardware connections |
| CHardwareSearchPathParameters | A series of paths to use for finding potential hardware connections |
| CHashMaker | Computes hash values from arbitrary data using an FNV-like combining algorithm |
| CHatchData | Logic for storing a hatch-data in a CAD-friendly way for exporting and importing |
| CHatchEdgeData | Stores information about the edge of a CAD hatch pattern |
| CHatchLoopData | Provides loops of data for the CAD hatch pattern |
| CHSBColor | A color defined by hue, saturation, and brightness components |
| CHyperDijkstra | Dijkstra's shortest-path algorithm on a HyperGraph |
| CHyperDijkstra::AdjacencyMapEntry | Entry in the adjacency map storing parent, child, edge, distance, and children set |
| CHyperDijkstra::CostFunction | Abstract cost function for weighting edges during traversal |
| CHyperDijkstra::TreeAction | Action interface executed when visiting the shortest-path tree |
| CHyperGraph | Class that models a directed Hyper-Graph |
| CHyperGraph::HGEdge | Abstract Edge class |
| CHyperGraph::HGVertex | Abstract Vertex, your types must derive from that one |
| CIcoFile | Logic for handling files with the .ico extension |
| CIcoFile::BitmapInfoHeader | Windows BITMAPINFOHEADER structure used to describe the bitmap data within an ICO file |
| CIcoFile::IconDir | Represents the ICO file directory header, containing metadata and an array of icon entries |
| CIcoFile::IconDirEntry | Represents a single entry in the ICO file directory, describing one icon image |
| CIconCacheWidget | A placeholder widget for Files displayed with FileChooserDialog until the actual icon can be loaded from the disk, which may be a slow operation for large directories |
| CIconDefinition | Information for displaying a particular icon |
| CIconEngineItem | Stores a specific renderer and transform for SVG rendering |
| CIconManager | Stores information about many different icons |
| CIconThemeDisplaySettings | Stores display information for how to draw icons, when supported |
| CIconThemeSettings | Stores information for how to draw icons, when supported |
| CImage | A root class that stores an an array of pixel data that can be displayed as an Image |
| CImageCacheData | Holds cached image data including compressed and decompressed pixel buffers, file references, metadata, and dimension information |
| CImageData | A container for Images managed by the ImageFactory |
| CImageDefData | Stores the definition of an Image for easy interface with CAD |
| CImageEditApplicationManager | Finds any acceptable Image editors (MS Paint, GIMP Photoshop, etc) and allows them to be used as editors |
| CImageFactory | The core class for reading/writing and storing images in an optimized way |
| CImageFormatHandler | Can be used to add functionality to the ImageFactory |
| CImageMetaData | Stores metadata associated with an image, such as geolocation, orientation, and creation time |
| CImageVectorizationEngine | Contains services that can turn a 2D rastered image into linework |
| CImageView | A widget that shows a raster image or icon |
| CIMUCalibrationSpreadsheet | Creates and writes data from a distance encoder to a set excel page |
| CIMUCalibrationSpreadsheet::Data | Input data for generating an IMU calibration spreadsheet |
| CImuCamPose | Represents a combined IMU and camera pose for graph optimization |
| CIMUData | Holds IMU calibration and bias data for a frame |
| CIMUNoiseSimulator | This class generates random bias and noise for modeling a 9-DoF IMU |
| CIncidentReportSetup | Widget providing the initial setup interface for a transit incident report |
| CIncludeFolderCreator | Generates convenience include-redirect files (e.g |
| CIncrementVersion | Increments the version number in a module's header file, supporting major, minor, and patch version bumps |
| CIndexMatchQueue< t_a, t_b, t_index > | A queue-based index matcher that pairs elements from two asynchronous streams by their index |
| CIndexMatchQueue< t_a, t_b, t_index >::NodeA | Internal node storing an A-stream element and its associated index |
| CIndexMatchQueue< t_a, t_b, t_index >::NodeB | Internal node storing a B-stream element and its associated index |
| CIndexScratch | Scratch buffers for block index assignments during structure building |
| CInfoPacketHeader | Packet header for scanner metadata (ID, matrix, timing) |
| CInfoPipe | A light-weight base class for Log that allows processes to update, without the need for additional include overheads |
| CINIFactory | Contains methods for easily reading and writing to an INI file including efficient casting, callback, and variable storage methods |
| CINIInterface | Contains methods for easily reading and writing to an INI file including efficient casting, callback, and variable storage methods |
| CINIOption | A class used with INIFactory to store a reference to an object in the program that can be inherited to provide read and write functionality to the factory |
| CInitialSetupDialog | Shown after a new installation on a device, allowing the user to familiarize themselves with the environment and to setup any needed settings, such as language, and performing registration |
| CInMemoryMatchesProvider | An in-memory implementation of openMVG::sfm::Matches_Provider |
| CInMemoryRegionsProvider | An in-memory implementation of openMVG::sfm::Regions_Provider |
| CInterfaceOrientationController | This class is responsible for notifying and providing default layout logic when the orientation of the widget changes, such as for a screen rotaton |
| CIntersection | Dummy class for including intersection functions |
| CInvDepthPoint | Represents a 3D point parameterized by inverse depth in the host frame |
| CIOFactoryBuilder | Generates boilerplate header and source files for a new IOFactory subclass, enabling file format read/write support in the NDEVR IO system |
| CIPWidget | A simple widget for entering in an IP address |
| CJacobianWorkspace | Provide memory workspace for computing the Jacobians |
| CJoystick | A joystick that allows the user to move around, reporting the vector of the stick, relative to the center of the joystick |
| CJoystickSettingsDialog | A dialog which allows the user to set sensitivity and other properties of a Joystick object |
| CJSONNode | JavaScript Object Notation or JSON is an open - standard file format that uses human - readable text to transmit data objects consisting of attribute–value pairs and array data types(or any other serializable value) |
| CJSONToStringHelper< t_type > | Helper template for converting a JSON string value to a specific type |
| CJSONToStringHelper< Angle< t_type > > | Template specialization of JSONToStringHelper for Angle types, converting from degrees |
| CJSONToStringHelper< String > | Template specialization of JSONToStringHelper for String, returning a StringView directly |
| CJSONToStringHelper< Time > | Template specialization of JSONToStringHelper for Time, supporting multiple JSON time formats |
| CKeyFrame::KeyFrameScore | Stores place-recognition query scores for a keyframe |
| CKeyFrameDatabase | Database of keyframes for place recognition and relocalization |
| CKeyOption | An action that can be tied to a specific KeyPress within the software |
| CKeypad | A popup for showing a virtual keyboard or keypad |
| CKeypadSettings | Generic Settings for keypad including scales and when to show the keypad |
| CLanguageEditor | Allows the user to adjust translation values for a given language |
| CLanguageHighlighter | Syntactically highlights translations |
| CLatLonUnit | A specific unit that can convert between coordinate projections |
| CLayerCacheObject | Stores cached information for the LayerModel |
| CLayerModel | Used for showing Layers in a table using the QAbstractItemModel interface |
| CLayerWidget | A widget that allows the user to set or interface with the current layer |
| CLEDLightWidget | Displays a simple light widget that can be set to blink or change colors |
| CLibAssert | The default way to make Assert statements within the NDEVR API |
| CLibraryManager | Manages loading Models from a group that is stored either on a remote server or locally on the disk in a compressed or uncompressed folder |
| CLibraryWidget | Allows the user to select Models or Materials from a list to add to the scene |
| CLinearSolverCCS< MatrixType > | Basic solver for Ax = b |
| CLinearSolverDense< MatrixType > | Linear solver using dense cholesky decomposition |
| CLinearSolverEigen< MatrixType > | Linear solver which uses the sparse Cholesky solver from Eigen |
| CLinearSolverEigen< MatrixType >::CholeskyDecomposition | Sub-classing Eigen's SimplicialLDLT to perform ordering with a given ordering |
| CLineEditResourceSetter< t_type, is_number > | A basic class for helping convert a Value into a resource |
| CLineEditResourceSetter< Angle< fltp08 >, ObjectInfo< Angle< fltp08 > >::Number > | Specialization of LineEditResourceSetter for Angle<fltp08>, converting via internal angle representation |
| CLineEditResourceSetter< Angle< sint04 >, ObjectInfo< Angle< sint04 > >::Number > | Specialization of LineEditResourceSetter for Angle<sint04>, converting via internal angle representation |
| CLineEditResourceSetter< t_type, true > | Specialization of LineEditResourceSetter for numeric types, performing direct casts |
| CLineEditResourceSetter< TimeSpan, ObjectInfo< TimeSpan >::Number > | Specialization of LineEditResourceSetter for TimeSpan, converting via elapsed seconds |
| CLineElevationRequest | Used with ElevationService to request elevations over a polyline at set intervals |
| CLineIterator< t_dims, t_type > | A class to easily iterate each line segment over a Geometry of lines |
| CLineOfSight | A Model which represents everything that is visible from a certain vantage point |
| CLineOfSightArgs | Configuration parameters used to set up a LineOfSight analysis Model |
| CLineTypeData | Information for a type of line in CAD |
| CLocalApplicationLauncher | Forward declaration for pipe-based inter-process communication |
| CLocalBattery | Allows the software to get information about local system batteries |
| CLocalCameraSettingsDialog | A dialog widget for configuring local camera settings such as resolution and format |
| CLocalMapping | Manages local map building, keyframe processing, and local bundle adjustment |
| CLocalVideoRenderer | A QGraphicsVideoItem subclass that provides custom rendering for local camera video streams |
| CLogManagerDialog | A dialog which shows multiple log views, where each log is a tab |
| CLogMessage | A class that allows for specific log information to be conveyed to a InfoPipe object including information about severity and timestamp information |
| CLogStream | A listener that receives and processes log messages and progress updates from an InfoPipe |
| CLogViewTable | A model for creating a table that displays logged records |
| CLoopClosing | Detects and corrects loop closures and map merges |
| CLUDecomposition< t_type, t_m, t_n > | Logic for performing LU Decomposition https://en.wikipedia.org/wiki/LU_decomposition |
| CMachineID | Logic for retrieving specific details about the machine this software is running on |
| CMadgwickOptions | Configuration options for the Madgwick orientation filter simulation |
| CMadgwickSimulationSettings | A widget providing settings and controls for configuring and running a Madgwick filter simulation |
| CMadgwickSimulatorCharts | Manages chart visualizations for Madgwick sensor fusion simulator data, displaying accelerometer, gyroscope, and absolute orientation over time |
| CMagicDiv< D > | Precomputes a magic multiplier for fast compile-time division by the constant D, avoiding expensive runtime division instructions |
| CMagneticCalibrationSpreadsheet | IOFactory interface for reading and writing data from magnetometer calibration checks to excel files |
| CMagneticDeclinationDialog | Dialog which allows user to set or calculate the magnetic declination |
| CMagneticDeclinationDialogFactory | Allows program-wide registration of a magnetic dialog to display when user should adjust magnetic declination |
| CMagnetometerWidget | Widget for displaying the live state of a magnetometer object |
| CMainWindowPopupWidget | A popup widget within the NDEVR API often used to show confirmation dialogs |
| CMap | Represents a single SLAM map containing keyframes and map points |
| CMapPoint | A 3D point in the SLAM map observed by multiple keyframes |
| CMapPointProjection | Projects a map point into a frame and checks frustum visibility |
| CMarchingCubesTriangulation | GeometrySurfacing implementation using the Marching Cubes algorithm for isosurface extraction |
| CMarginalCovarianceCholesky | Computing the marginal covariance given a cholesky factor (lower triangle of the factor) |
| CMaterialRasterBase | Base class for painting pixels at a time into a 2D texture |
| CMaterialRasterFactory | Creates rasters for converting points and directions into 2D images |
| CMaterialUVOptions | UVOptions used for interfacing with CAD, similar to those used by a Material object |
| CMaterialWidget | A simple widget showing some visual properties of a Material or Model |
| CMatrixDefinitions< t_type > | Provides common projection, view, and rotation matrix construction functions |
| CMatrixEditor | A simple widget that shows a modifiable 4x4 matrix and corresponding widgets for editing a 4x4 matrix |
| CMatrixFunctions | Provides static utility functions for solving best-fit and affine matrix transformations |
| CMatrixFunctions::TransformSolveOptions | Options controlling which degrees of freedom are solved when computing a best-fit transform |
| CMatrixInverter< t_cols, t_rows > | Templated logic for inverting a matrix based on the number of rows and columns |
| CMatrixStructure | Representing the structure of a matrix in column compressed structure (only the upper triangular part of the matrix) |
| CMD5 | Logic for creating an MD5 hash |
| CMD5_CTX | Struct for storing md5 information |
| CMeasurementOptions | Stores ApplicationOptions related to user preferences for measurements |
| CMeasurePointTypeCombo | Provides a static utility to configure a QCustomComboBox with measurement point symbol types such as square, round, arrow, and various crosshair combinations |
| CMediaDeviceInfo | Stores information about a media capture device (camera) |
| CMedian | A dummy class for including optimized median functions |
| CMedianFilterPushConstants | Push constants for median filter shader |
| CMercatorImage | Information output from a specific Aerial Tile request |
| CMercatorImageRequest | Contains the information for requesting a 2D top-down view of a geographic location to be used with a AerialImage service such as google earth |
| CMLPnPsolver | Solves the Perspective-n-Point problem using the MLPnP algorithm with RANSAC |
| CModelFileDialog | Shows options related to an import or export that utilizes the IOFactory methods to write or read properties |
| CModelFunction | A Model function allows a user to interact with the program to perform a task on models |
| CModelIterator | A base class for easily traversing a model hierarchy, applying an overridden function at each level or for each object |
| CModelSelectionTree | A tree view widget for displaying and selecting Models from the scene |
| CModelTableColumnSpec | Provides the ability to pull specific data from a DesignObjectLookup for display in a column of a table |
| CModelTableColumnSpec::RelativePathObject | Describes a single step in a relative path traversal, optionally filtering by type |
| CModelTableDelegate | A QItemDelegate for showing model properties in a QTableView |
| CModuleBuilder | Scaffolds a complete NDEVR module from scratch, generating DLLInfo, module header, module source, Visual Studio project, and filters files |
| CModuleConfiguration | Stores all information relating to a particular feature or resource included by a Module |
| CModuleFeatureBase | Describes the Module or feature to the end user |
| CModuleResourceManager | Stores all dependencies for a combination of modules that make up a complete software package |
| CModuleResources | Manages module resources for building installers, including file offloading and icon retrieval |
| CModulesDialog | Allows the user to see which Modules are available and toggle them on or off, when Modules are toggleable |
| CMotorDeploymentWidget | Provides an interface for controlling a motor involved with a particular Deployment |
| CMouseController::MouseActions | Holds the configurable action bindings and settings for a single mouse button |
| CMouseControllerEvent | A wrapper for a mouse event that is used by MouseControllerBase |
| CMouseEditorWidget | Allows the end user to set default mouse buttons and behavior for navigating in a Viewport |
| CMovementPath | Logic for moving an object across a path of both position, and optionally, orientation |
| CMTextData | Stores text data that may have an attachment point and direction for interfacing with CAD |
| CMultiRLock | Acquires read locks on multiple RWLocks simultaneously in a deadlock-safe order |
| CMultiWLock | Acquires write locks on multiple RWLocks simultaneously in a deadlock-safe order |
| CNCCustomReport | A customizable NCReport subclass that applies NDEVR ReportOptions and provides metadata (name, icon, description) for report selection UI |
| CNDEVRApplication | The root class of the NDEVR Application |
| CNDEVRChart | Default base chart for 2D line or scatter plots within the NDEVR API |
| CNDEVRChartModel::BackgroundAppearance | Defines the visual appearance of the chart background, including grid lines, axis labels, and title |
| CNDEVRChartModel::CursorAppearance | Defines the visual appearance of a chart cursor overlay |
| CNDEVRChartModel::SeriesAppearance | Defines the visual appearance of a data series within the chart |
| CNDEVRConnectionData | Holds the state of a single NDEVR network connection, including transmit and receive packets |
| CNDEVRCorrespondenceEstimation< PointSource, PointTarget, NormalT, Scalar > | CorrespondenceEstimationBackprojection computes correspondences as points in the target cloud which have minimum |
| CNDEVRPacketHeader | Fixed-size header prepended to every NDEVR data packet for framing and integrity checking |
| CNDEVRRibbon::NDEVRRibbonWidget | Internal widget used for custom size hint calculations in the ribbon layout |
| CNDEVRRibbonOptions | |
| CNDEVRServerInfo | Contains the address, credentials, and security flag needed to connect to an NDEVR server |
| CNDEVRWindow | A top-level widget |
| CNDVArchiveManager | Manages file archives which are compressed NDV files merged for convenience |
| CNDVHeader | Header structure for the NDV binary file format |
| CNetworkRequest | A request for data or information from a network |
| CNMEAErrorInfo | Holds position error statistics extracted from GST and related NMEA sentences |
| CNMEAInfo | The complete accumulated NMEA data state including satellite info, error data, INS data, position, and timing |
| CNMEAINSInfo | Holds INS (Inertial Navigation System) orientation data extracted from proprietary NMEA sentences |
| CNMEAReader | Parses raw NMEA data streams, splitting them into individual sentences and dispatching them to registered NMEASentenceReader instances |
| CNMEASentenceReader | Abstract base class for parsing specific NMEA sentence types (e.g |
| CNMEAUpdateInfo | Describes what was updated after processing an NMEA sentence, including which data categories changed and any error status |
| CNtpAuthenticationInfo | Optional authentication extension of an NTP packet |
| CNtpFullPacket | Full NTP packet combining mandatory fields and optional authentication |
| CNtpPacket | Mandatory part of an NTP packet, containing all required fields |
| CNtpPacketFlags | NTP packet flags stored in the first byte of the packet |
| CNtpReply | Represents a parsed NTP reply received from an NTP server |
| CNtpTimestamp | A 64-bit NTP timestamp with seconds and fractional parts since Jan 1, 1900 |
| CNumberWriter | Logic for writing to a number |
| CObjectAllocator< t_type, t_is_primitive, t_index_type > | Allows for specific, custom logic for allocating an object |
| CObjectAllocatorT< t_index_type, is_primitive > | Allows for specific, custom logic for allocating an object |
| CObjectAllocatorT< t_index_type, false > | The default object allocator for Buffers of non-primitive types that have destructors or memory on the heap |
| CObjectAllocatorT< t_index_type, true > | The default object allocator for Buffers of primitive types such as doubles or ints, where a constructor/destructor does not need to be called |
| CObjectChecker< t_type > | Used with QTDesignObject to check the type of an object |
| CObjectChecker< Camera > | Specialization that checks if a UUID corresponds to a Camera |
| CObjectChecker< DesignObject > | Specialization that checks if a UUID corresponds to any valid DesignObject |
| CObjectChecker< DesignSelection > | Specialization that checks if a UUID corresponds to a DesignSelection |
| CObjectChecker< Geometry > | Specialization that checks if a UUID corresponds to a Geometry |
| CObjectChecker< Material > | Specialization that checks if a UUID corresponds to a Material |
| CObjectChecker< Model > | Specialization that checks if a UUID corresponds to a Model |
| CObjectInfo< t_type, is_vector, is_buffer > | Information about the object |
| CObjectInfo< Angle< fltp04 >, false, false > | Information about an Angle object backed by a 4 byte floating point number |
| CObjectInfo< Angle< fltp08 >, false, false > | Information about an Angle object backed by a 8 byte floating point number |
| CObjectInfo< Angle< sint04 >, false, false > | Information about an Angle object backed by a signed 4 byte integer |
| CObjectInfo< bool, false, false > | ObjectInfo specialization for the bool type |
| CObjectInfo< char, false, false > | ObjectInfo specialization for the char type |
| CObjectInfo< DesignObject, false, false > | Type trait specialization providing compile-time type information about DesignObject |
| CObjectInfo< Effect, false, false > | Type trait specialization providing metadata about the Effect type |
| CObjectInfo< Geometry, false, false > | Type trait specialization providing compile-time type information for Geometry objects |
| CObjectInfo< Material, false, false > | Type trait specialization providing compile-time metadata about the Material type |
| CObjectInfo< Model, false, false > | Type trait information for the Model class, indicating it is a primitive non-numeric type |
| CObjectInfo< PasswordString, false, false > | Type trait specialization providing compile-time metadata for PasswordString |
| CObjectInfo< RGBColor, true, false > | Type trait specialization providing compile-time metadata for RGBColor |
| CObjectInfo< Scene, false, false > | Type trait specialization providing metadata about the Scene type for the NDEVR type system |
| CObjectInfo< StringView, false, false > | ObjectInfo specialization for StringView, providing compile-time type trait information |
| CObjectInfo< t_type, false, false > | Information about the object |
| CObjectInfo< t_type, false, true > | ObjectInfo specialization for buffer types derived from BufferBase |
| CObjectInfo< t_type, true, false > | Information about the object |
| CObjectInfo< Time, false, false > | |
| CObjectInfo< TimeSpan, false, false > | |
| CObjectInfo< UUID, true, false > | Type trait specialization providing metadata about the UUID type, identifying it as a 16-dimensional primitive vector with string-like properties |
| COfficersEditor | Editor widget for managing officers involved in a transit incident |
| COpenMP | Dummy class for including OpenMP macros https://www.openmp.org/ |
| COpenMPMutex | Dummy mutex for non-OpenMP builds |
| COptechScannerFactory | A ScannerFactory that discovers and connects to Optech laser scanners on the network |
| COptimizableGraph::Data | Data packet for a vertex |
| COptimizableGraph::EdgeIDCompare | Order edges based on the internal ID, which is assigned to the edge in addEdge() |
| COptimizableGraph::VertexIDCompare | Order vertices based on their ID |
| COptimizationAlgorithm | Generic interface for a non-linear solver operating on a graph |
| COptimizationAlgorithmProperty | Describe the properties of a solver |
| COptimizedSelection | Stores the state and results of an indexed geometry selection operation |
| COptimizer | Provides graph optimization routines for the ORB-SLAM system |
| COptionalFeature | Describes an optional software feature that can be enabled or disabled at runtime |
| CORBextractor | Extracts ORB features from images using an octree-based distribution |
| CORBmatcher | Matches ORB features between frames, keyframes, and map points |
| COrbOptions | Application options for ORB-SLAM image preprocessing |
| COrbSLAM | Main entry point for the ORB-SLAM3 system |
| COrbTrackingInfo | Aggregates input and output data for a single tracking frame |
| COrientationEditor | A dialog where the user can set a 3D orientation of an object |
| COrientationOperationsWidget::GNSSCallback | Abstract callback interface for creating GNSS orientation widgets |
| COrientationReading | A single reading, typically used by a MadgwickOrientationSensor consisiting of input from all IMU sensors |
| COSInformation | Contains information about an Operating System including versions and types |
| COSType | Stores String variables reprenting the type of OS that will be supported by a particular module or resource |
| COverrideMatrixValue | A timestamped camera matrix override value |
| COWLActionPage | Main action page widget for OWL server interactions |
| COWLCredentialsDialog | Dialog for entering OWL server login credentials |
| COWLDuplicateResolver | Dialog for resolving duplicate file conflicts during OWL upload |
| COWLExportDialog | Dialog for exporting projects and files to an OWL server |
| COWLFileManager | File management widget for browsing, opening, and managing files on an OWL server |
| COWLLinkDisplay | Widget that displays an OWL share link and allows saving the linked file |
| COwlServerSettingsDialog | Dialog for managing OWL server connections |
| CPacketListener | Interface for objects that wish to receive NDEVR packet events and connection state changes |
| CPaperSpace | Stores CAD details about PaperSpace or 2D document space |
| CParameter | Abstract base class for graph parameters that can be serialized |
| CPasswordString | When passwords are used inside the NDEVR engine, we don't want them logged or visible |
| CPatchMatchCamera | GPU-accelerated PatchMatch depth estimation using Vulkan compute shaders |
| CPatchMatchGpuCache | GPU buffer cache for reuse across multiple estimateDepthMap calls |
| CPatchMatchPushConstants | Push constant layout (must match GLSL layout exactly) |
| CPath | A monotone cubic Hermite spline path that interpolates values over time |
| CPCLFunctions | Utility class providing conversions between NDEVR and PCL data types, plus normal and keypoint calculations |
| CPCLFunctions::KeyPointArgs | Arguments for keypoint detection in point cloud data |
| CPCLRTreeWrapper< PointT > | Adapts the NDEVR RTree spatial index to the PCL search interface for nearest-neighbor queries |
| CPendingAction | Represents a server request that has been sent and is awaiting a response |
| CPermission | Information about a requested OS-permission typically requested at install time |
| CPermissionHandler | Abstract interface for platform-specific permission handling |
| CPermissionManager | Centralized manager for checking and requesting application permissions |
| CPerspectiveListNormalFlipper | A class that flips a surface generated normals from point clouds or lines given based around a path of a perspective |
| CPhotoDrapingSettings | A widget for configuring photo draping (texture projection) settings during scanning, including raster resolution and aspect ratio |
| CPhotogrammetryDialog | Two-page dialog for configuring and running a drone photogrammetry session |
| CPhotogrammetryFeatures | Handles feature extraction (SIFT/AKAZE) and feature matching (cascade hashing / brute force) |
| CPhotogrammetryGPSAlign | Computes a GPS-based similarity transform from EXIF GPS positions and SfM camera centres |
| CPhotogrammetryPointColor | RGB color for a reconstructed point |
| CPhotogrammetryResult | Holds the raw output of a completed photogrammetry run before it is committed to the scene |
| CPhotogrammetryRunner | Drives the OpenMVG + OpenMVS photogrammetry pipeline entirely in memory |
| CPhotogrammetrySfM | Runs sequential Structure-from-Motion with GPS-aware initial pair selection |
| CPhysicalCameraView | A Viewport that represents a physical camera stream, or real world camera view |
| CPhysicalCameraView::OutputCodec | Describes a video output codec with an identifier and display name |
| CPhysicalCameraView::OutputMux | Describes a video output muxer/container format with an identifier and display name |
| CPhysicalCameraView::ToolButtonSettings | Configuration flags controlling which tool buttons are visible in the camera toolbar |
| CPhysicalCameraViewSettings | Settings for saving or displaying camera data |
| CPixelFormat | Describes the pixel format of a VNC remote framebuffer, including color depth, endianness, and per-channel bit layout |
| CPlane< t_dims, t_type > | Logic for a given plane or N-dimensions |
| CPlatformType | Stores String variables reprenting the type of platform CPU configuration that will be supported by a particular Module or resource (x64, x86, arm etc) |
| CPointContainer< t_point_type > | A templated container for 3D point cloud data with per-point positions, typed attributes, and integer weights |
| CPointer< t_type > | Provides shared ownership of a dynamically allocated object |
| CPointer< ImageCacheData > | |
| CPointer< BinaryCompressionObject > | |
| CPointer< CADHandleManager > | |
| CPointer< Camera > | |
| CPointer< CaptureInfo > | |
| CPointer< CaptureRequest > | |
| CPointer< CustomUnit > | |
| CPointer< DesignCommand > | |
| CPointer< FindFileFunction > | |
| CPointer< GLESGraphicsDevice > | |
| CPointer< GLESImageData > | |
| CPointer< GLESImageManager > | |
| CPointer< GLESMaterialManager > | |
| CPointer< GLESShaderManager > | |
| CPointer< GLESVertexManager > | |
| CPointer< GraphicsBuffer > | |
| CPointer< GraphicsDevice > | |
| CPointer< GraphicsPipeline > | |
| CPointer< GraphicsSession > | |
| CPointer< IconThemeDisplaySettings > | |
| CPointer< LibraryManager > | |
| CPointer< LocalApplicationLauncher > | |
| CPointer< ModelEditController > | |
| CPointer< ModelFunction > | |
| CPointer< MouseController > | |
| CPointer< OpenGLBuffer > | |
| CPointer< QCaptureManager > | |
| CPointer< QTDesignObject > | |
| CPointer< Renderer > | |
| CPointer< Scanner > | |
| CPointer< Set< UUID > > | |
| CPointer< SnapController > | |
| CPointer< SnapsManager > | |
| CPointer< Unit > | |
| CPointer< UnitOption > | |
| CPointer< VulkanBuffer > | |
| CPointer< VulkanComputeBuffer > | |
| CPointer< VulkanComputeDevice > | |
| CPointer< VulkanComputePipeline > | |
| CPointer< VulkanDevice > | |
| CPointer< VulkanImageData > | |
| CPointer< VulkanImageManager > | |
| CPointer< VulkanImageView > | |
| CPointer< VulkanInstance > | |
| CPointer< VulkanMaterialManager > | |
| CPointer< VulkanRenderDefinition > | |
| CPointer< VulkanRenderPipeline::SwapChainSupportDetails > | |
| CPointer< VulkanShader > | |
| CPointer< VulkanShaderManager > | |
| CPointer< VulkanVertexManager > | |
| CPointer< VulkanXRDevice > | |
| CPointer< WebMercatorTileService > | |
| CPointer< WidgetIterator > | |
| CPointer< XRVulkanPipeline > | |
| CPointerCore | Used by Pointer to store the reference count of the pointer |
| CPointPipeline | A ring buffer of RasterFrames used to pipeline raster point processing across multiple stages |
| CPointWidget | Allows the user to input an N-dimensional point (up to 4 dimensions) with an optional unit |
| CPointWidget::GNSSCallback | Abstract callback interface for creating GNSS take-reading widgets |
| CPointWidget::PreTransform | Abstract interface for applying a custom transform to point values before display and after editing |
| CPolygon< t_type, t_vertex > | An N-sided polygon |
| CPolyline< t_dims, t_type, t_vertex > | A sequence of connected line segments defined by ordered vertices along a path |
| CPolylineMaker | Given random line segments, constructs a polyline when the vertices match |
| CPolylineSliceCache | Internal cache for storing intermediate data during a polyline slice operation, including collected triangles, points, spatial indices, and progress state |
| CPolylineSliceIterator | Abstract interface for generating slice planes from a bounding region |
| CPolylineSlicer | Logic for slicing one or more Model/Geometry objects into polyline cross-section Model/Geometry objects based on configured slice criteria |
| CPopupInfo | Class which is used to pass arguments and requests for creating a popup dialog or widget |
| CPositionReading | A single position reading from the RealSense T265 tracking camera |
| CPrimitiveLineSegmentEditor | Shown when user is editing lines, to assist them in adjusting the line in 3D space |
| CPrimitiveVertexEditor | Allows the user to adjust properties for a particular Geometry Vertex node |
| CPrintPreview | A dialog that shows a PrintPreview of a given widgets, reports, or images |
| CProgressSource | Represents a named progress source with an identifier and completion percentage |
| CProgressWidgetDemo | Provides a demonstration of the ProgressWidget with animated previews and configurable options |
| CProjectFileManager | Manages writing to the NDV file and any folder operations for projects |
| CPropertyChangeListener | Listens for a change of a particular property to a given target (DEPRECIATED) |
| CPropertyChangeManager | Used to listen for changes to properties (DEPRECIATED) |
| CPropertyColumnInterface< t_property_enum > | Provides access to the TableColumn and row index for a given property enum value |
| CPropertyColumnInterface< NDPG > | Provides column access for NDPG geometry properties within the design database |
| CPropertyColumnInterface< NDPM > | Provides column access for NDPM material properties within the design table system |
| CPropertyColumnInterface< NDPN > | Provides column-level access to NDPN model properties in the design database |
| CPropertyColumnInterface< NDPOC > | Specialization of PropertyColumnInterface for the NDPOC calculated property enum |
| CPropertyInterface< t_property_enum > | Typed interface for getting and setting design object properties by enum |
| CPropertyInterface< NDPE > | Provides typed access to NDPE effect properties on a DesignObject |
| CPropertyInterface< NDPN > | Provides typed access to NDPN model properties via get/set on DesignInfo |
| CPropertyInterface< NDPO > | Specialization of PropertyInterface for the NDPO property enum |
| CPropertyInterface< PaperViewProperty > | Provides a compile-time property interface for reading and writing PaperViewProperty values on a DesignInfo object |
| CPropertySpec< t_property > | Maps a compile-time property enum value to its corresponding C++ storage type |
| CPropertySpec< NDPE::destroy_when_finished > | Type mapping for destroy_when_finished property |
| CPropertySpec< NDPE::end_time > | Type mapping for end_time property |
| CPropertySpec< NDPE::extra_transform > | Type mapping for extra_transform property |
| CPropertySpec< NDPE::frequency > | Type mapping for frequency property |
| CPropertySpec< NDPE::is_active > | Type mapping for is_active property |
| CPropertySpec< NDPE::start_time > | Type mapping for start_time property |
| CPropertySpec< NDPE::target_value_a > | Type mapping for target_value_a property |
| CPropertySpec< NDPE::target_value_b > | Type mapping for target_value_b property |
| CPropertySpec< NDPN::calculation_ignored > | PropertySpec specialization mapping NDPN::calculation_ignored to bool |
| CPropertySpec< NDPN::can_select_children > | PropertySpec specialization mapping NDPN::can_select_children to bool |
| CPropertySpec< NDPN::child_base_ptr > | PropertySpec specialization mapping NDPN::child_base_ptr to DesignObjectBase* |
| CPropertySpec< NDPN::complete_transform > | PropertySpec specialization mapping NDPN::complete_transform to Matrix<fltp08> |
| CPropertySpec< NDPN::export_ignored > | PropertySpec specialization mapping NDPN::export_ignored to bool |
| CPropertySpec< NDPN::fixed_bounding_box > | PropertySpec specialization mapping NDPN::fixed_bounding_box to Bounds<3, fltp08> |
| CPropertySpec< NDPN::geometry_base_ptr > | PropertySpec specialization mapping NDPN::geometry_base_ptr to DesignObjectBase* |
| CPropertySpec< NDPN::global_bounds > | PropertySpec specialization mapping NDPN::global_bounds to Bounds<3, fltp08> |
| CPropertySpec< NDPN::global_selection_bounds > | PropertySpec specialization mapping NDPN::global_selection_bounds to Bounds<3, fltp08> |
| CPropertySpec< NDPN::inherited_flags > | PropertySpec specialization mapping NDPN::inherited_flags to Vector<32, bool> |
| CPropertySpec< NDPN::material_base_ptr > | PropertySpec specialization mapping NDPN::material_base_ptr to DesignObjectBase* |
| CPropertySpec< NDPN::material_mode > | PropertySpec specialization mapping NDPN::material_mode to uint01 |
| CPropertySpec< NDPN::model_color > | PropertySpec specialization mapping NDPN::model_color to RGBColor |
| CPropertySpec< NDPN::parent_base_ptr > | PropertySpec specialization mapping NDPN::parent_base_ptr to DesignObjectBase* |
| CPropertySpec< NDPN::parent_matrix_flags > | PropertySpec specialization mapping NDPN::parent_matrix_flags to BitFlag |
| CPropertySpec< NDPN::personal_inherited_flags > | PropertySpec specialization mapping NDPN::personal_inherited_flags to Vector<32, bool> |
| CPropertySpec< NDPN::type > | PropertySpec specialization mapping NDPN::type to StringView |
| CPropertySpec< NDPN::visible_box > | PropertySpec specialization mapping NDPN::visible_box to Bounds<3, fltp08> |
| CPropertySpec< NDPO::allow_interactions > | PropertySpec: allow_interactions is stored as bool |
| CPropertySpec< NDPO::application_locked > | PropertySpec: application_locked is stored as bool |
| CPropertySpec< NDPO::applied_filters > | PropertySpec: applied_filters is stored as StringView |
| CPropertySpec< NDPO::asc_modified_time > | PropertySpec: asc_modified_time is stored as Time |
| CPropertySpec< NDPO::author > | PropertySpec: author is stored as StringView |
| CPropertySpec< NDPO::bounding_box > | PropertySpec: bounding_box is stored as Bounds<3, fltp08> |
| CPropertySpec< NDPO::bounds_ignored > | PropertySpec: bounds_ignored is stored as bool |
| CPropertySpec< NDPO::category > | PropertySpec: category is stored as StringView |
| CPropertySpec< NDPO::compressed_data > | PropertySpec: compressed_data is stored as StringView |
| CPropertySpec< NDPO::creation_software > | PropertySpec: creation_software is stored as StringView |
| CPropertySpec< NDPO::creation_time > | PropertySpec: creation_time is stored as Time |
| CPropertySpec< NDPO::deletion_allowed > | PropertySpec: deletion_allowed is stored as bool |
| CPropertySpec< NDPO::desc_modified_time > | PropertySpec: desc_modified_time is stored as Time |
| CPropertySpec< NDPO::description > | PropertySpec: description is stored as StringView |
| CPropertySpec< NDPO::design_type > | PropertySpec: design_type is stored as uint01 bitflag |
| CPropertySpec< NDPO::editable_description > | PropertySpec: editable_description is stored as bool |
| CPropertySpec< NDPO::file > | PropertySpec: file is stored as StringView |
| CPropertySpec< NDPO::geometry_modified_time > | PropertySpec: geometry_modified_time is stored as Time |
| CPropertySpec< NDPO::guid > | PropertySpec: guid is stored as UUID |
| CPropertySpec< NDPO::icon > | PropertySpec: icon is stored as StringView |
| CPropertySpec< NDPO::is_application_owned > | PropertySpec: is_application_owned is stored as bool |
| CPropertySpec< NDPO::is_deleted > | PropertySpec: is_deleted is stored as bool |
| CPropertySpec< NDPO::is_focused > | PropertySpec: is_focused is stored as bool |
| CPropertySpec< NDPO::is_frozen > | PropertySpec: is_frozen is stored as bool |
| CPropertySpec< NDPO::is_selected > | PropertySpec: is_selected is stored as bool |
| CPropertySpec< NDPO::library_id > | PropertySpec: library_id is stored as UUID |
| CPropertySpec< NDPO::meta_data > | PropertySpec: meta_data is stored as StringView |
| CPropertySpec< NDPO::modified_time > | PropertySpec: modified_time is stored as Time |
| CPropertySpec< NDPO::name > | PropertySpec: name is stored as StringView |
| CPropertySpec< NDPO::search_terms > | PropertySpec: search_terms is stored as StringView |
| CPropertySpec< NDPO::selection_ignored > | PropertySpec: selection_ignored is stored as bool |
| CPropertySpec< NDPO::spacial_visible > | PropertySpec: spacial_visible is stored as bool |
| CPropertySpec< NDPO::transform > | PropertySpec: transform is stored as Matrix<fltp08> |
| CPropertySpec< NDPO::translated_string_data > | PropertySpec: translated_string_data is stored as TranslatedString |
| CPropertySpec< NDPO::tree_visible > | PropertySpec: tree_visible is stored as bool |
| CPropertySpec< NDPO::uncompressed_data > | PropertySpec: uncompressed_data is stored as StringView |
| CPropertySpec< NDPO::untranslated_string_data > | PropertySpec: untranslated_string_data is stored as StringView |
| CPropertySpec< NDPOC::author > | PropertySpec: calculated author is stored as TranslatedString |
| CPropertySpec< NDPOC::category > | PropertySpec: calculated category is stored as TranslatedString |
| CPropertySpec< NDPOC::creation_software > | PropertySpec: calculated creation_software is stored as TranslatedString |
| CPropertySpec< NDPOC::description > | PropertySpec: calculated description is stored as TranslatedString |
| CPropertySpec< NDPOC::name > | PropertySpec: calculated name is stored as TranslatedString |
| CPropertySpec< NDPOC::search_terms > | PropertySpec: calculated search_terms is stored as TranslatedString |
| CPropertySpec< PaperViewProperty::e_dots_per_meter > | Property type specification: e_dots_per_meter maps to fltp04 |
| CPropertySpec< PaperViewProperty::e_margins > | Property type specification: e_margins maps to Vector<4, fltp04> |
| CPropertySpec< PaperViewProperty::e_page_size > | Property type specification: e_page_size maps to Vector<2, fltp04> |
| CPropertySpec< PaperViewProperty::e_world_bounds > | Property type specification: e_world_bounds maps to Bounds<3, fltp08> |
| CProxyModelViewFilter | Filters and sorts Models from a ModelManager for views such as in a table or in a tree view |
| CPublicPrivateKey | Manages an elliptic curve public/private key pair for asymmetric encryption and decryption |
| CQCaptureManager | An interface used to manage multiple CaptureRequests and scedule their completion |
| CQCustomColorDialog | A dialog devoted to allowing the user to select a custom color |
| CQCustomComboBox | A compact way to present a list of options to the user |
| CQCustomDial | Provides a rounded range control (like a speedometer or potentiometer) |
| CQCustomLabel | Displays translated text |
| CQCustomLineEdit | A line edit allows users to enter and edit a single line of plain text with useful editing functions, including undo and redo, cut and paste, and drag and drop |
| CQCustomProgressBar | Allows for showing of progress bar in horizontal format |
| CQCustomScrollArea | A scroll area is used to display the contents of a child widget within a frame |
| CQCustomSlider | The slider is the classic widget for controlling a bounded value |
| CQCustomSplitter | A splitter lets the user control the size of 2 child widgets by dragging the boundary between them |
| CQCustomStackedWidgetBase | A base class for a series of widgets where all widgets occupy the same same and only one widget is shown at a time |
| CQCustomTableWidget | Provides a standard way to show table data within the application |
| CQCustomTextEdit | A widget that is used to edit and display both plain and rich text in a multi-lined format |
| CQCustomTooltip | Provides tool tips (balloon help) for any widget that usually shows up when a mouse is hovered over a widget for a set amount of time |
| CQCustomTranslator | Allows QT to call into the native application translator when needed to translate UI auto-generated items |
| CQCustomTreeNode | Represents a single node in a tree structure, containing a title, ID, icon, and any child nodes |
| CQCustomTreeWidget | A wrapper around QTreeWidget with native NDEVR objects |
| CQCustomValidator | Responsible on most user input fields for correcting the input when possible or allerting the user that the input is incorrect |
| CQCustomValidator::InvalidProperties | Contains the result of a validation check, including the validity state, a suggested fix-up message, and an optional character range |
| CQDeviceChangeEvent | The event that is triggered when a USB device is plugged in or unplugged |
| CQMediaDeviceManager | Singleton manager that tracks available camera devices on the system |
| CQrCode | A QR Code symbol, which is a type of two-dimensional barcode |
| CQrSegment | A segment of character, binary, or control data in a QR Code symbol |
| CQrSegment::Mode | Describes how a segment's data bits are interpreted |
| CQTDesignObject | A pointer to a DesignObject within a QTModelManager that receives and emits update signals based on the state of the object |
| CQTErrorDialog | A dialog typically shown as a tab that displays an exception to the user |
| CQTIconManager | Manages all Icons and Pixmaps used by the UI in the NDEVR Engine |
| CQTImageEditor | A full-featured image editor widget with drawing tools, undo/redo, and image manipulation |
| CQTImageEditorView | A widget that provides a canvas for viewing and editing images with drawing tools |
| CQTModelManagerView | A Qt compatible ItemModel for interfacing with a DesignObjectLookup |
| CQTModelManagerView::ModelCache | Cached data for a single model entry in the tree view, storing display properties to avoid repeated lookups |
| CQtProjectManager | Provides static methods for building Qt project files and Android manifests from module lists |
| CQTTools | Manages static logic dealing with Qt and relating to the application |
| CQTVertexManagerView | A Qt compatible AbstractTableModel for showing properties around a series of Geometry Vertex objects |
| CQTVibrationManager | When supported, such as on Android/IOS, will vibrate the device |
| CQTWidgetImage | A Qt compatible wrapper for an image for use with QWidgetModel |
| CQuickVisualization | Allows for the creation of Models that represent points or linework quickly and efficiently |
| CQuickVisualization::VertexVisualizationOptions | Options controlling how a set of 3D vertices is visualized as coordinate markers or connected linework within a Model |
| CRadialObject< t_dims, t_type, t_vertex > | A radial object |
| CRandom | Dummy class for including random number generator functions |
| CRandomColorGenerator | Generates random colors based on configurable hue and luminosity settings |
| CRandomColorOptions | Options for configuring random color generation with custom hue and brightness constraints |
| CRandomMessageGenerator | Stores a collection of translated messages and provides random selection from them |
| CRasterCameraRenderer | An OpenGL window that renders raster camera video frames with rotation, zoom, and infrared support |
| CRasterFrame | A single frame of raster depth/color data along with processing state and metadata |
| CRasterization | Creates a raster of the terrain using the Cloth simulation |
| CRasterPacketInfo | Packet of colored point data sent from the raster scanner for live and inactive display |
| CRasterScannerSettingsDialog | A settings dialog widget for configuring raster point scanner options such as SLAM, IMU parameters, display, and post-processing settings |
| CRateLimiter | Throttles the frequency of an action by enforcing a minimum time interval between firings |
| CRDesignLock | Used to lock a particular model for editing (DEPRECIATED) |
| CRealSenseClient | Client that receives point cloud data from a remote RealSense server |
| CRealSenseIOSettings | Aggregated IO settings for all RealSense streams and laser configuration |
| CRealSenseOptions | Application options for configuring the RealSense interface module |
| CRealsensePacketChecksum | Checksum union for identifying valid RealSense network packets |
| CRealsensePacketHeader | Top-level packet header with checksum, type, and sequence number |
| CRealSensePointSmoother | Point smoother specialized for RealSense camera intrinsics |
| CRealSenseScanner | 3D scanner implementation for Intel RealSense depth cameras |
| CRealSenseScannerFactory | Factory for discovering and connecting to RealSense 3D scanners |
| CRealSenseServer | Server that streams RealSense point cloud data to remote clients over UDP |
| CRealSenseServer::WorkerThread | Background thread for the server update loop |
| CRealSenseStreamSettings | Settings for a single RealSense data stream (IR, color, depth, IMU) |
| CRegexFunctions | Logic for creating regular expressions for certain situations |
| CRegistryEntry | Provides read and write access to a single Windows registry entry identified by hive, path, and variable name |
| CRenderer | An object that renders a specific Camera object, typically run on a different thread than the main UI thread |
| CReplyTimeout | Handles timing out certain operations such as downloads |
| CReportJSONMaker | Creates a JSON data structure that can be used for generating a report in MSWord |
| CReportOptions | Encapsulates the options needed to generate a report, including the report template path, the design objects to include, and the design object lookup context |
| CReportTemplate | A simple Template for a report |
| CResizeVisibleAnimation | Responsible for animating widgets by having them grown as they become visible, or shrink as they become invisible |
| CResolveableLocation | A named location that can be resolved to an index within a shader program |
| CResourceBase | A base class for templated resources |
| CResourceID | Identifies a resource on the server by name, ID, owner, and version |
| CResourceListener | A class that can subscribe to any number of Resources which will get updates when the Resource(s) have been modified |
| CRibbonGroup | Represents the "Tab" of a widget |
| CRibbonSubGroup | Represents a sub-section of "Tab" of a ribbon representing a grouping of buttons or widgets within a tab that provide similar functions |
| CRLock | Used to lock a particular variable for reading |
| CRobustKernel | Base for all robust cost functions |
| CRockWorksSetup | Setup parameters for RockWorks solid model generation |
| CRockworksSolidModInfo | Stores cell and value information for a RockWorks solid (.mod) block model |
| CRuler | A widget meant to be placed beside a camera view showing either directional or measurement markings depending on whether or not a camera is orthographic |
| CRW5FileOptions | Options for reading an RW5 file, including the parsed data, file path, and incremental read state |
| CRW5Info | Contains all parsed data from a Carlson RW5 file including the scale point, all survey points, unit information, and rover height |
| CRWLock | A readers-writer lock allowing concurrent reads or exclusive writes |
| CSaveOptions | Options for saving an NDEVR project |
| CScanner | Contains methods for easily reading objects in an ascii stream using set deliminators and line logic |
| CSceneIterator | Allows quick iteration of all scene objects |
| CScenePaintDevice | A QPaintDevice that 'paints' the widgets by turning them into 3D Model objects inside a model hierarchy |
| CScenePaintEngine | A QPaintEngine that 'paints' the widgets by turning them into 3D Model objects |
| CSceneTree | Shows all objects in a QTModelManager in a tree hierarchy view that allows for user interaction |
| CSceneTreeWidget | A container widget that wraps a SceneTree with an optional ribbon toolbar for buttons |
| CScopedOpenMPMutex | Lock a mutex within a scope |
| CScreenshotRequest | Encapsulates a request to capture a screenshot, along with a callback to receive the resulting image identifier |
| CScrollGesture | Handles scrolling or flicking within the application |
| CSE3mat | SE(3) rigid body transformation represented by a rotation matrix and translation vector |
| CSE3Quat | SE(3) rigid body transformation represented by a unit quaternion and translation vector |
| CSectionTab | Provides a tab that is used for either a tab if the section content is attached to a Container, or as the drag bar if the content is floating |
| CSectionWidget | SectionWidget manages multiple instances of SectionContent |
| CSectionWidgetTabsScrollArea | Custom scrollable implementation for docked tabs using the NDEVR API Widget Docking system |
| CSegmentedBlockModelBase< t_point_type, t_depth, t_size, t_weight_type > | Hierarchical spatial index for block model rasters using a multi-level lookup tree |
| CSelectionArea< t_dims, t_type > | An area of N-dimensional space that is considered selected |
| CSelectionButtonFactory | A factory for creating custom buttons that appear when objects are selected |
| CSelectionEffect | Applies certain effects to a model that has been selected |
| CSelectionHighlightBar | Provides a highlighted animation for selecting docked tabs using the NDEVR API Widget Docking system |
| CSelectionInfo::ClosestModelInfo | Stores information about the closest model element found during a selection operation, tracking the nearest geometry, model, material, and layer for a given primitive type |
| CSelectionTreeManager | Manages selection trees, which optimize the process of selecting data within large Geometry objects |
| CSensor | Describes the input sensor type and IMU usage |
| CSerialConnectionDialog::Settings | Stores the current serial port configuration parameters |
| CSerialPortInfo | A structure containing information needed to establish a SerialPortConnection |
| CServerActions | Abstract interface for all server-side CRUD operations on users, resources, and permissions |
| CServerCommandReturn | Encapsulates a server command's return status, including a code and optional message |
| CServerCredentials | Stores user credentials for server authentication, including username, password hash, and IP |
| CServerMainInfo | Holds general information about an NDEVR server instance |
| CSetBase | A dummy base class for all Set templates |
| CSetPropertiesCommand::PropertyValue | Holds a single property assignment: a target object UUID, the property to change, and the new value serialized as a string |
| CSettingsDialog | The main Settings dialog for the application |
| CSGMPushConstants | Push constants for SGM directional cost aggregation shader |
| CShaderDefinition | Base definition for a shader program, holding source data and uniform bindings |
| CShaderManager | Registry that stores all available vertex and fragment shader definitions keyed by UUID |
| CShaderTools | Utility class for compiling GLSL shader source files into SPIR-V binaries using the Vulkan SDK glslangValidator tool |
| CShaderUniform | Describes the set of attribute locations associated with a single shader uniform block |
| CShapeConstructors | Logic for writing various basic shapes to a Geometry object |
| CSheetOptions | Options for configuring the form sheet window's customer type and tree filter |
| CShiftCount< t_value > | Compile-time helper that counts the number of trailing zero bits in a value, used for computing shift amounts when dividing by powers of two |
| CShiftCount< 0 > | Base case specialization of ShiftCount for zero |
| CShowPropertiesSettings | Stores settings for setting up and displaying a DesignObjectDialog such as whether the dialog is part of a larger workflow or used for Model creation |
| CSim3 | Similarity transformation in 3D (rotation + translation + scale) |
| CSim3Solver | Computes a Sim3 transformation between two keyframes using RANSAC |
| CSimulationDataPoint | A single data point captured during Madgwick simulation, containing raw sensor data and the computed orientation |
| CSLAMEngine | Provides logic to perform SLAM on an object |
| CSLAMFrame | A frame of data that can be processed by a SLAM engine to determine relative location |
| CSLAMParameters | Configuration parameters for the ORB-SLAM system |
| CSlicePlane | Represents a single plane used to slice geometry, along with the resulting slice data (polyline segments, points, colors, and properties) |
| CSlicerArgs | Arguments for performing a Geometry slice operation |
| CSlicerOutputOptions | Output options for the Slicer/Dicer export operation |
| CSliceVertex< t_type, t_vertex_type > | Stores an index to a particular vertex used with ConcaveToConvexPolygon |
| CSmoothing | Forward declaration of InfoPipe for progress/logging support |
| CSnapController::EditDimensionLockInformation | Holds information about a user-initiated dimension lock edit, including per-axis text and the currently active dimension and cursor position |
| CSnapPoint | Contains information about a particular point of interest created from a user mouse interaction |
| CSnapsManager | Forward declaration for the NDEVR string type |
| CSocketIO | Provides the ability to communicate over a network using SocketIO (https://socket.io/docs/v4/) |
| CSocketIOChannel | A specific channel of communication within the SocketIO framework |
| CSoftwareService | Base interface for services that extend or modify software behavior through modules |
| CSoftwareServiceManager | Software Service Managers take a Software service to modify the behavior of the software |
| CSolver | Generic interface for a sparse solver operating on a graph which solves one iteration of the linearized objective function |
| CSound | Contains the definition for a sound resource |
| CSparseBlockMatrix< MatrixType > | Sparse matrix which uses blocks |
| CSparseBlockMatrixCCS< MatrixType > | Sparse matrix which uses blocks |
| CSparseBlockMatrixCCS< MatrixType >::RowBlock | A block within a column |
| CSparseBlockMatrixDiagonal< MatrixType > | Sparse matrix which uses blocks on the diagonal |
| CSparseBlockMatrixHashMap< MatrixType > | Sparse matrix which uses blocks based on hash structures |
| CSpline< t_point_type > | A spline is a function used to interpolate or smooth data |
| CStatementParser | Turns a particular string into an Equation The String should not contain invalid characters |
| CStationOptions | Stores ApplicationOptions related to user preferences for Stations |
| CStepsRecorder | If available, records user interactions using Windows Steps Recorder |
| CStringEnum | Empty tag class used as a base for string-convertible enumerations defined via macros |
| CStringSplitter | Logic for splitting a string into two |
| CStringStream< t_type > | Logic for reading or writing to a string or a user friendly, TranslatedString |
| CStringStream< Bounds< t_dims, t_type > > | StringStream specialization for Bounds types, serializing min and max vectors separated by '^' |
| CStringStream< Buffer< t_type, t_memory_manager > > | StringStream specialization for Buffer types, serializing elements as comma-separated values |
| CStringStream< DesignParameter > | Template specialization of StringStream for DesignParameter |
| CStringStream< Matrix< t_type, t_row_dims, t_col_dims > > | StringStream specialization for Matrix types, serializing elements with ',' between rows and ';' between columns |
| CStringStream< Ray< t_dims, t_type, t_vector_type > > | StringStream specialization for Ray types, delegating to the underlying vector type |
| CStringStream< String > | StringStream specialization for String types, providing identity-like conversion |
| CStringStream< StringAllocatingView > | StringStream specialization for StringAllocatingView types, providing owning string conversion |
| CStringStream< StringView > | StringStream specialization for StringView types, providing non-owning string conversion |
| CStringStream< Vector< t_dims, t_type > > | StringStream specialization for Vector types, serializing components as comma-separated values |
| CStringStream< Vertex< t_dims, t_type, t_vector_type > > | StringStream specialization for Vertex types, delegating to the underlying vector type |
| CStringValidator | Logic for validating a string given a specific regex pattern |
| CStringView | The core String View class for the NDEVR API |
| CStyleData | Logic for storing a style data in a CAD-friendly way for exporting and importing |
| CSubtitleFileReader | Class which can be used to read a subtitle file and return the subtitle that should be played at a specific time |
| CSubtitleFileWriter | Class which can be used to write a subtitle in real time to a file, which can be played back alongside a video being recorded concurrently |
| CSunDial | A decorated dial class that allows the user to set the lighting direction |
| CSVD | Performs the singular value decomposition of a general matrix, taken and adapted from Numerical Recipes Third Edition svd.h |
| CTableChange | Records changes to a table or column noting the bounds of the data adjusted |
| CTableColumn | A virtual storage type that is used with Table class to store data where the actual mechanism for storage can be abstracted away |
| CTakeReadingData | Holds accumulated data during a take-reading operation, including sample counts, averaged position, and quality metrics |
| CTAR | Provides utilities for reading and extracting TAR and TAR.GZ archives |
| CTAR::Reader | Abstract base class for sequential byte stream reading |
| CTAR::TarHdr | Represents the raw 512-byte POSIX TAR header structure (USTAR format) |
| CTcpServer | A TcpServer allows the software to receive socket connections from external sources |
| CTemporaryIOFileLocker | Manages temporary file paths during an IOFactory write operation, ensuring safe writes by writing to temporary files first and then moving them to the final destination |
| CTextBlock | Text that is formatted the same way, typically part of a bigger group of text |
| CTextCommands | A placeholder grouping class for text-related design commands |
| CTextToSpeechRequest | Allows the user to make a request for text-to-speech |
| CThemeChanger | An animation that slowly changes the color over the entire UI |
| CThirdPartyLibsDialog | A dialog widget for configuring paths to third-party library dependencies used by the build system |
| CThread | The default thread class for executing concurrent sequences in the NDEVR API |
| CThreadedRTree< t_dims, t_type > | An RTree extension that supports multi-threaded tree construction and bounding box computation |
| CThreadFunctions | Forward declaration of LogPtr for log access |
| CTightDecoder | Decodes a VNC stream from TightVNC |
| CTileKey | A key identifying a geographic tile by integer latitude and longitude |
| CTime | Represents a timestamp with utilities for manipulation and conversion |
| CTimeRequest | A request to get the time from the network |
| CTimeSpan | Stores a time span, or difference between two times, with an optional start time |
| CTimeSpanSelector | A widget that allows the user to select a time span by choosing a start date/time and either an end date/time or a duration in hours and minutes |
| CTimeZone | Simple struct for storing timezone definition data |
| CToolbar | Class which displays progress and the current action being performed |
| CTooltipTextManager | Provides common tooltips for usage with the software |
| CTouchDesktopThemeButton | A button for allowing the user to switch between Desktop/Touch mode which affects the size of all of the widgets and text |
| CTouchScrollManager | Provides behavior for flicking and other scroll behavior common to the NDEVR API |
| CTracking | Main tracking thread that processes each frame and estimates camera pose |
| CTransformationEstimationPointToPlaneLLS< t_type > | Estimates a rigid transformation using point-to-plane linear least squares minimization |
| CTransitIncidentManager | Central manager for transit incident data, including buses, drivers, witnesses, officers, and vehicles |
| CTransitIncidentPedestrianEditor | Editor widget for managing pedestrians involved in a transit incident |
| CTransitIncidentVehiclesEditor | Editor widget for managing vehicles involved in a transit incident |
| CTranslatedString | Any text displayed to the user should be defined as a TranslatedString which allows the program to look up a translation, if available |
| CTranslationDefinition | Contains logic for translating a string into a defined language |
| CTranslationTools | Scans source code for translation macros (_t, _td, etc.) and generates .tr translation files for all supported languages |
| CTreeSorterBase< t_dims, t_type > | Base class for tree sorters that maintain pre-sorted index arrays for efficient spatial partitioning |
| CTriangleBase | Base class for N-dimensional triangles |
| CTriangleIterator< t_dims, t_type > | A class to easily iterate each triangle over a Geometry of triangles or meshes |
| CTwoSidedCSFFilter | Filters data into a top and bottom half based on the CSF surfacing logic |
| CTwoViewReconstruction | Reconstructs 3D structure from two views using homography and fundamental matrix |
| CTypeInfo | Stores information about a type, relevant for certain templated functions |
| CTypeInfoRegex | Logic for creating a regex for a given type of data |
| CUnit | Defines a unit of measurement for converting and displaying data values |
| CUnitDefinitions | Provides static accessors for common and uncommon unit definitions used by the software |
| CUnitOption | A definition of how to describe a particular set of data to a custom category of unit |
| CUnitsDialog | A dialog which can be used to set various units for different unit categories, such as selecting the various properties by which to show angles |
| CURDFFactoryOptions | Options and output data for a URDF file parsing operation |
| CUTF8Iterator | Iterates over a UTF8 encoded string and returns the values as UTF16 |
| CUVChannelEditWidget | A widget allowing the user to set the properties for a single channel of UVType for a Material |
| CVariableCreatorWidget | A widget for creating and configuring user-defined variables based on GenericOption settings |
| CVariableDefinition | Describes a build variable with its internal name, display title, and description |
| CVariableReference | An optimized class for storing a reference to a variable of some type up to 8 bytes in size without ownership or allocations on the stack |
| CVector< t_dims, t_type > | A fixed-size array with N dimensions used as the basis for geometric and mathematical types |
| CVector< 16, uint01 > | |
| CVector< 2, t_vertex > | |
| CVector< 2, Vertex< 2, fltp04 > > | |
| CVector< 2, Vertex< 2, fltp08 > > | |
| CVector< 2, Vertex< 2, t_type > > | |
| CVector< 2, Vertex< t_dims, fltp08 > > | |
| CVector< 2, Vertex< t_dims, t_type > > | |
| CVector< 3, t_vector > | |
| CVector< 3, uint01 > | |
| CVector< 4, fltp04 > | |
| CVector< 4, fltp08 > | |
| CVector< 4, g_type > | |
| CVector< 4, t_type > | |
| CVector< 4, uint01 > | |
| CVector< 4, Vector< 4, fltp04 > > | |
| CVector< 4, Vector< 4, t_type > > | |
| CVector< 6, uint01 > | |
| CVector< 9, uint01 > | |
| CVector< t_dims, bool > | An boolean specifc Vector which stores vectors of bools in optimal space |
| CVector< t_row_dims, Vector< t_col_dims, fltp04 > > | |
| CVector< t_row_dims, Vector< t_col_dims, fltp08 > > | |
| CVector< t_row_dims, Vector< t_col_dims, t_type > > | |
| CVectorFunctions | Provides free functions for vector arithmetic and geometric operations |
| CVectorizeImageParams | Arguments used for creating vectorizations of an image |
| CVehicleDatabase | A database of vehicle specifications (make, model, year, dimensions, weight) loaded from DBF files and INI-based search term mappings, used for vehicle selection and placement |
| CVehicleRecord | A read-only accessor for a single vehicle record within a VehicleDatabase, providing make, model, year, weight, dimensions, and associated 3D model file |
| CVehicleSelector | A widget that allows the user to browse, search, and select vehicles from the VehicleDatabase and place them into the design scene |
| CVehicleTableFilterProxyModel | A sort/filter proxy model that filters VehicleTableModel rows by make, model, and year search criteria, and supports a selection callback |
| CVehicleTableModel | Qt table model that exposes VehicleDatabase records as rows for display in a QTableView |
| CVehicleTableView | A QTableView subclass that displays vehicle database records with sort and filter support |
| CVertex< t_dims, t_type, t_vector_type > | |
| CVertexColorIterator | Allows for the calculation of colors for any vertex given a Material and Geometry |
| CVertexLookup | A class to easily iterate each vertex of a Geometry |
| CVertexOffsetWidget | A widget allowing the user to offset a vertex |
| CVertexTable | A table showing a list of vertices in a Geometry objects |
| CVertexTableDelegate | A Qt compatible ItemDelegate for showing properties around a Geometry Vertex object |
| CVerticalDatum | Data about a vertical coordinate reference system (e.g |
| CVerticalDatumChooser | A dialog that allows the user to select a vertical datum (geoid model) for elevation reference |
| CVideoCardInformation | Contains information about a video card, including manufacturer and some level of capabilities |
| CVideoFrameDetails | Describes the pixel format and dimensions of a video frame from a raster camera |
| CViewportFactory | A service which can generate Viewports based on Camera data |
| CViewportFormat | Stores information for how to construct a viewport, including camera identity, field of view, zoom focus, and animation settings |
| CViewportManager | Logic for placing Viewports or Camera Views into widgets |
| CViewportOptions | Stores the options, added to the user settings, that control Viewport and camera options in the application |
| CViewPortSmoothShaderLogic | GPU compute shader that performs viewport-space point smoothing and filtering |
| CViewPortSmoothShaderLogic::UBO | Uniform buffer object layout for the viewport smooth compute shader |
| CViewToPrimitiveObjects | Used to convert a view and a DesignObjectLookup of data into a 2D map of primitive data types |
| CVirtualCameraView | A Viewport for rendering 3D objects in the scene with the NDEVR Graphics Engine |
| CVirtualTree< t_dims, t_type > | A polymorphic spatial tree that can instantiate either a KDTree or RTree at runtime based on configuration |
| CVncClientWidget | A QWidget that renders the remote VNC framebuffer and forwards user input events (mouse, keyboard) to the VncDevice for transmission to the remote server |
| CVncScreen | Describes a single screen reported by a VNC server, including its ID, bounds, and flags |
| CVulkanBitflagObject | Stores bools to be sent to both the Vertex and Fragment shaders in the Vulkan space |
| CVulkanCameraSettingsDialog | Dialog widget for adjusting local camera settings such as resolution, exposure, and focus |
| CVulkanComputeBuffer | A GPU storage buffer (SSBO) for compute shader use, with a separate staging buffer for host-visible upload/download transfers |
| CVulkanComputeDevice | Wraps a VulkanDevice with compute-specific queue discovery and command pool management |
| CVulkanComputePipeline | A generic, reusable Vulkan compute pipeline wrapper |
| CVulkanImageManager | Manages all images within the Vulkan space |
| CVulkanImageResources | Data for pointing to a specific Image target within the Vulkan Graphics space |
| CVulkanImageView | Manages a view within the Vulkan logic space |
| CVulkanInstance | The connection between the NDEVR API and the Vulkan library |
| CVulkanMaterialManager | Logic for creating the data in Vulkan for a specific Material |
| CVulkanQueue | A wrapper around a VulkanQueueCore that allows for thread-safe access to a specific queue |
| CVulkanQueueCore | A queue of commands or actions to be executed in order by the Vulkan engine |
| CVulkanRenderDefinition | Creates specific information for performing a render pass within Vulkan |
| CVulkanRenderObject | A root render Object for Vulkan, which consists of a set Material, Model, and Geometry that is used together to optimally create a 3D render |
| CVulkanRenderObject::GeoProperties | Cached properties of a Geometry instance within this render object |
| CVulkanRenderObject::ModelProperties | Cached properties of a parent Model for a rendered geometry instance |
| CVulkanRenderPipeline::PipelineSemaphore | A semaphore paired with an active flag for pipeline synchronization |
| CVulkanRenderPipeline::PipelineSemaphores | Paired acquire and finish semaphores for a single frame in the render pipeline |
| CVulkanRenderPipeline::SwapChainSupportDetails | Details about swap chain support on a physical device |
| CVulkanShader | A shader program used to render data in Vulkan |
| CVulkanShaderCreator | Parses GLSL shader source to extract vertex input layout and uniform definitions for creating Vulkan shader pipeline configurations |
| CVulkanShaderManager | Manages all active shaders in a VulkanSession |
| CVulkanStagingRing | A ring buffer for staging GPU uploads |
| CVulkanVertexManager | Manages all vertices in a specific Scene object for interfacing with Vulkan |
| CVulkanVertexUniformObject | Information sent to the Vertex shader as a Uniform object |
| CWDesignLock | Used to lock a particular model for editing (DEPRECIATED) |
| CWebMercatorTile | A Web Mercator map tile descriptor containing coordinates, zoom level, and display settings |
| CWebMercatorTileReply | Contains the reply data from a Web Mercator tile fetch request |
| CWebMercatorTileRequest | Encapsulates a request for a single Web Mercator map tile |
| CWebMercatorTileService | A wrapper for logic that uses a web engine to provide an Image Tile service |
| CWebTarget | A url target and optional username and password for a network request |
| CWidgetFactoryBuilder | Generates boilerplate header, source, and UI files for a new Qt widget class |
| CWidgetInit | Provides a way to lazily initialize widgets when needed but still pass them to container dialogs |
| CWidgetInitialization | The primary logic for initializing an application within the NDEVR engine by calling module functions in the appropriate order and initializing any common resources or services |
| CWidgetIterator | Provides a way to iterate over a series of widgets, useful for printing dialogs or turning Widgets into reports or PDF files |
| CWidgetOptions | Stores the options, added to the user settings, that control Widgets and low level UI options in the application |
| CWifiConnectDialog | A dialog widget for selecting and connecting to a Wi-Fi network |
| CWinchDeploymentDialog | Dialog providing detailed winch deployment controls and distance encoder feedback |
| CWindowContainer | A (hacky) class for storing a window into a container |
| CWindowInstance | Contains core information about a Viewport |
| CWindowOptions | Stores the options, added to the user settings, that control Window and high level UI options in the application |
| CWitnessEditor | Editor widget for managing witnesses of a transit incident |
| CWixDirectory | Represents a directory tree structure within a WiX installer project |
| CWixFragment | Collects all data for a WiX installer fragment including directories, features, and files |
| CWixInstallerFeature | Describes a feature within a WiX installer, including its files and components |
| CWixInstallerFile | Represents a WiX installer XML file being written, with indentation tracking |
| CWixInstallerManager | Manages the creation of WiX-based Windows installer projects from NDEVR module definitions |
| CWLock | Used to lock a particular variable for writing |
| CXInputFactory | Factory class for discovering and registering Xbox controllers via XInput |
| CXLSXKeyPointMagneticAngleReading | The structure used by the library for storing key points of data used to write to a MagneticCalibrationSpreadsheet |
| CXLSXMagneticAngleAverageReading | The structure used by the library for storing averaged points of data used to write to a MagneticCalibrationSpreadsheet |
| CXLSXMagneticAngleReading | The structure used for storing data to write to a MagneticCalibrationSpreadsheet |
| CXRFunctions | Common helper functions for easier interfacing with the OpenXR engine |
| CXRInputManager | Translates input from the OpenXR interface into NDEVR API actions and events |
| CXRManager | Manages the OpenXR engine at a high level |
| CXRPose | A matrix-like class storing both offset and orientation |
| CXRSide | OpenXR uses two viewports, one for the left eye and one for the right eye |
| CZippedRadialMeshOptions | Logic for setting up a mesh that is broken apart by latitude and longitude lines with a set angle difference between them |
| CZlibInStream | A zlib decompression stream wrapper used by TightDecoder to inflate compressed VNC data |
| Cstd::exception | STL class |