High-level interface for LiDAR point cloud operations. More...

Detailed Description

High-level interface for LiDAR point cloud operations.

Supports synthetic scanning, point cloud filtering, triangulation, and leaf area density calculations.

Example: >>> from pyhelios import LiDARCloud >>> from pyhelios.types import vec3 >>> >>> with LiDARCloud() as lidar: ... # Add a scan ... scan_id = lidar.addScan( ... origin=vec3(0, 0, 1), ... Ntheta=100, theta_range=(0, 1.57), ... Nphi=100, phi_range=(-3.14, 3.14), ... exit_diameter=0.01, beam_divergence=0.001 ... ) ... ... # Add hit points ... lidar.addHitPoint(scan_id, vec3(1, 0, 0), vec3(1, 0, 0)) ... ... # Export point cloud ... lidar.exportPointCloud("output.xyz")

Definition at line 152 of file LiDARCloud.py.

Public Member Functions
	__init__ (self)
	Initialize LiDARCloud.

	__enter__ (self)
	Context manager entry.

	__exit__ (self, exc_type, exc_val, exc_tb)
	Context manager exit - cleanup resources.

	__del__ (self)
	Fallback destructor for cleanup without context manage.

int	addScan (self, Union[vec3, List[float], Tuple[float, float, float]] origin, int Ntheta, Tuple[float, float] theta_range, int Nphi, Tuple[float, float] phi_range, float exit_diameter, float beam_divergence, Optional[List[str]] column_format=None, float range_noise_stddev=0.0, float angle_noise_stddev=0.0, float scan_tilt_roll=0.0, float scan_tilt_pitch=0.0, float scan_azimuth_offset=0.0)
	Add a LiDAR scan to the point cloud.

int	addScanMoving (self, int Ntheta, Tuple[float, float] theta_range, int Nphi, Tuple[float, float] phi_range, float exit_diameter, float beam_divergence, List[float] traj_t, List[Union[vec3, List[float], Tuple[float, float, float]]] traj_pos, List[List[float]] traj_rot, float pulse_rate_hz, bool rot_is_quaternion=True, Optional[Union[vec3, List[float], Tuple[float, float, float]]] lever_arm=None, Optional[Union[vec3, List[float], Tuple[float, float, float]]] boresight_rpy=None, Optional[List[str]] column_format=None, float range_noise_stddev=0.0, float angle_noise_stddev=0.0, float t0=0.0)
	Add a moving-platform (mobile/airborne) raster LiDAR scan driven by a 6-DOF pose trajectory.

int	addScanSpinning (self, List[float] beam_elevation_angles, float azimuth_step, float pulse_rate_hz, List[float] traj_t, List[Union[vec3, List[float], Tuple[float, float, float]]] traj_pos, List[List[float]] traj_rot, bool rot_is_quaternion=True, float exit_diameter=0.0, float beam_divergence=0.0, Optional[Union[vec3, List[float], Tuple[float, float, float]]] lever_arm=None, Optional[Union[vec3, List[float], Tuple[float, float, float]]] boresight_rpy=None, Optional[List[str]] column_format=None, float range_noise_stddev=0.0, float angle_noise_stddev=0.0, float t0=0.0)
	Add a continuously-spinning multibeam scan from physical instrument parameters.

int	addScanMovingRaster (self, int Ntheta, Tuple[float, float] theta_range, int Nphi, Tuple[float, float] phi_range, float pulse_rate_hz, List[float] traj_t, List[Union[vec3, List[float], Tuple[float, float, float]]] traj_pos, List[List[float]] traj_quat, float exit_diameter=0.0, float beam_divergence=0.0, Optional[Union[vec3, List[float], Tuple[float, float, float]]] lever_arm=None, Optional[Union[vec3, List[float], Tuple[float, float, float]]] boresight_rpy=None, Optional[List[str]] column_format=None, float range_noise_stddev=0.0, float angle_noise_stddev=0.0, float t0=0.0)
	Add a moving-platform raster scan: a fixed angular fan swept along a quaternion trajectory.

int	addScanRisley (self, List[Union['RisleyPrism', List[float], Tuple[float,...]]] prisms, float refractive_index_air, float pulse_rate_hz, List[float] traj_t, List[Union[vec3, List[float], Tuple[float, float, float]]] traj_pos, List[List[float]] traj_rot, bool rot_is_quaternion=True, float exit_diameter=0.0, float beam_divergence=0.0, Optional[Union[vec3, List[float], Tuple[float, float, float]]] lever_arm=None, Optional[Union[vec3, List[float], Tuple[float, float, float]]] boresight_rpy=None, Optional[List[str]] column_format=None, float range_noise_stddev=0.0, float angle_noise_stddev=0.0, float t0=0.0)
	Add a rotating-Risley-prism (Livox-style rosette) scan from physical instrument parameters.

int	getScanCount (self)
	Get total number of scans in the cloud.

vec3	getScanOrigin (self, int scanID)
	Get origin of a specific scan.

int	getScanSizeTheta (self, int scanID)
	Get number of zenith scan points for a scan.

int	getScanSizePhi (self, int scanID)
	Get number of azimuthal scan points for a scan.

float	getScanRangeNoiseStdDev (self, int scanID)
	Get the range (along-beam) measurement noise standard deviation for a scan (meters).

float	getScanAngleNoiseStdDev (self, int scanID)
	Get the angular (beam-pointing) jitter standard deviation for a scan (radians).

float	getScanTiltRoll (self, int scanID)
	Get the global scanner tilt roll angle for a scan (radians; 0.0 if level).

float	getScanTiltPitch (self, int scanID)
	Get the global scanner tilt pitch angle for a scan (radians; 0.0 if level).

float	getScanAzimuthOffset (self, int scanID)
	Get the global scanner azimuth (heading) offset for a scan (radians; 0.0 if none).

int	getScanPattern (self, int scanID)
	Get the scan pattern for a scan.

List[float]	getScanBeamZenithAngles (self, int scanID)
	Get the per-channel beam zenith angles (radians) for a multibeam scan.

ScanMode	getScanMode (self, int scanID)
	Get the high-level acquisition mode of a scan as a :class:`ScanMode`.

int	getScanStepsPerRev (self, int scanID)
	Get the number of azimuth firing steps per revolution (spinning scans; 0 otherwise).

float	getScanRotationRate (self, int scanID)
	Get the sensor-head rotation rate in revolutions/second (spinning scans; 0 otherwise).

float	getScanRevolutions (self, int scanID)
	Get the number of revolutions the sensor head made (spinning scans; 0 otherwise).

List[RisleyPrism]	getScanRisleyPrisms (self, int scanID)
	Get the rotating wedge prisms of a Risley-prism scan as a list of :class:`RisleyPrism`.

float	getScanRisleyRefractiveIndexAir (self, int scanID)
	Get the refractive index of the medium surrounding a Risley scan's prisms (1.0 for non-Risley).

ReturnMode	getScanReturnMode (self, int scanID)
	Get the return-reporting mode of a scan as a :class:`ReturnMode` (MULTI or SINGLE).

	setScanReturnMode (self, int scanID, Union[ReturnMode, int] return_mode)
	Set the return-reporting mode of a scan (ReturnMode.MULTI or ReturnMode.SINGLE).

SingleReturnSelection	getScanSingleReturnSelection (self, int scanID)
	Get the single/limited-return selection policy as a :class:`SingleReturnSelection`.

	setScanSingleReturnSelection (self, int scanID, Union[SingleReturnSelection, int] selection)
	Set the single/limited-return selection policy (STRONGEST, FIRST, LAST, or STRONGEST_PLUS_LAST).

int	getScanMaxReturns (self, int scanID)
	Get the maximum returns per pulse used in single/limited-return mode (1 = single, N = N-return).

	setScanMaxReturns (self, int scanID, int max_returns)
	Set the maximum returns per pulse used in single/limited-return mode (must be >= 1).

	setSyntheticScanMemoryBudget (self, int bytes)
	Set the soft memory budget (bytes) for :meth:`syntheticScan`'s transient buffers.

int	getSyntheticScanMemoryBudget (self)
	Get the soft memory budget (bytes) for :meth:`syntheticScan`'s transient buffers.

float	getScanPulseWidth (self, int scanID)
	Get the pulse width / range resolution (meters) of a scan (0 = use syntheticScan argument).

	setScanPulseWidth (self, int scanID, float pulse_width)
	Set the pulse width / range resolution (meters) of a scan (0 = use syntheticScan argument).

float	getScanDetectionThreshold (self, int scanID)
	Get the detection threshold (energy fraction, noise floor) of a scan.

	setScanDetectionThreshold (self, int scanID, float detection_threshold)
	Set the detection threshold (energy fraction, noise floor) of a scan.

	addHitPoint (self, int scanID, Union[vec3, List[float], Tuple[float, float, float]] xyz, Union[vec3, SphericalCoord, List[float], Tuple[float, float]] direction, Optional[Union[RGBcolor, List[float], Tuple[float, float, float]]] color=None)
	Add a hit point to the point cloud.

	addHitPoints (self, int scanID, xyz_array, direction_array, color_array=None)
	Add many hit points to the point cloud in a single bulk call.

	addHitPointsWithData (self, int scanID, xyz_array, direction_array, data_labels=None, data_values=None, color_array=None)
	Add many hit points carrying a per-hit data map in a single bulk call.

int	getHitCount (self)
	Get total number of hit points in cloud.

vec3	getHitXYZ (self, int index)
	Get coordinates of a hit point.

vec3	getHitOrigin (self, int index)
	Get the (x,y,z) beam-emission origin of a hit point.

SphericalCoord	getHitRaydir (self, int index)
	Get ray direction of a hit point.

RGBcolor	getHitColor (self, int index)
	Get color of a hit point.

int	getHitScanID (self, int index)
	Get the scan ID a hit point belongs to.

bool	doesHitDataExist (self, int index, str label)
	Check whether a named scalar data value exists for a hit point.

float	getHitData (self, int index, str label)
	Get a named scalar data value for a hit point.

List[float]	getHitDataAll (self, str label)
	Bulk-export a named scalar data value for all hits in a single FFI call.

Tuple[List[vec3], List[RGBcolor]]	getHitsXYZRGB (self)
	Bulk-export coordinates and colors for all hits in a single FFI call.

	getHitsXYZRGBArrays (self)
	Bulk-export hit coordinates + colors as numpy arrays.

	getHitDataArray (self, str label)
	Bulk-export a named scalar field as an (getHitCount(),) float32 array, NaN where the label is absent for a hit.

List[float]	getHitDataColumn (self, str label, float absent_value=-9999.0)
	Bulk-export a named scalar column via the native cache-linear columnar path.

int	getHitDataColumnIndex (self, str label)
	Get the internal column slot index for a hit-data label.

	getHitDataColumnArray (self, str label, float absent_value=-9999.0)
	Bulk-export a named scalar column as an (getHitCount(),) float64 numpy array via the columnar path (`absent_value` where the label is absent for a hit).

	getHitScanIDArray (self)
	Bulk-export the scan ID of every hit as an (getHitCount(),) int32 array.

	getHitMissArray (self)
	Bulk-export the miss flag of every hit as an (getHitCount(),) int32 array (1 == sky/miss, 0 == real surface return).

	deleteHitPoint (self, int index)
	Delete a hit point from the cloud.

bool	isHitMiss (self, int index)
	Return True if a hit is a "miss" (a fired pulse that returned nothing).

bool	hasMisses (self)
	Return True if the cloud contains at least one miss.

	coordinateShift (self, Union[vec3, List[float], Tuple[float, float, float]] shift)
	Translate all hit points by a shift vector.

	coordinateRotation (self, Union[SphericalCoord, List[float], Tuple[float, float]] rotation)
	Rotate all hit points by spherical rotation angles.

	triangulateHitPoints (self, float Lmax, float max_aspect_ratio=4.0)
	Generate triangle mesh from hit points using Delaunay triangulation.

int	getTriangleCount (self)
	Get number of triangles in the mesh.

dict	getTriangulationStats (self)
	Filter diagnostics from the most recent triangulateHitPoints() call.

	getTriangleVerticesAll (self)
	Bulk-export every triangle's vertices and source scan in one call.

	setExternalTriangulation (self, vertices, scan_ids)
	Replace the internal triangulation with an externally-supplied mesh.

	distanceFilter (self, float maxdistance)
	Filter hit points by maximum distance from scanne.

	reflectanceFilter (self, float minreflectance)
	Filter hit points by minimum reflectance value.

	firstHitFilter (self)
	Keep only first return hit points.

	lastHitFilter (self)
	Keep only last return hit points.

	exportPointCloud (self, str filename, bool write_header=True)
	Export point cloud to ASCII file.

	exportLeafAreaUncertainty (self, str filename)
	Export per-voxel leaf-area sampling uncertainty to a self-describing ASCII file.

	exportScans (self, str filename)
	Export all scans to an XML metadata file plus one ASCII data file per scan.

	loadXML (self, str filename)
	Load scan metadata from XML file.

	disableMessages (self)
	Disable console output messages.

	enableMessages (self)
	Enable console output messages.

	addGrid (self, Union[vec3, List[float], Tuple[float, float, float]] center, Union[vec3, List[float], Tuple[float, float, float]] size, Union[List[int], Tuple[int, int, int]] ndiv, float rotation=0.0, Optional[Union[List[float], Tuple[float,...]]] column_z_offsets=None)
	Add a rectangular grid of voxel cells.

	addGridCell (self, Union[vec3, List[float], Tuple[float, float, float]] center, Union[vec3, List[float], Tuple[float, float, float]] size, float rotation=0.0)
	Add a single grid cell.

int	getGridCellCount (self)
	Get total number of grid cells.

vec3	getCellCenter (self, int index)
	Get the true world-space center position of a grid cell.

vec3	getCellSize (self, int index)
	Get size of a grid cell.

float	getCellRotation (self, int index)
	Get the azimuthal rotation of a grid cell about the z-axis, in degrees.

float	getCellLeafArea (self, int index)
	Get leaf area of a grid cell (m²)

float	getCellLeafAreaDensity (self, int index)
	Get leaf area density of a grid cell (m²/m³)

int	getCellBeamCount (self, int index)
	Get the beam count N that entered a grid cell during the leaf-area inversion.

float	getCellRelativeDensityIndex (self, int index)
	Get the relative density index (I_rdi) for a grid cell.

float	getCellMeanPathLength (self, int index)
	Get the mean beam path length (m) through a grid cell.

float	getCellLADVariance (self, int index)
	Get the per-voxel LAD sampling variance for a grid cell.

	getCellLeafAreaConfidenceInterval (self, int index, float confidence_level=0.95)
	Get the leaf-area confidence interval for a single grid cell.

	getGroupLADConfidenceInterval (self, List[int] indices, float confidence_level=0.95)
	Get the group-scale LAD confidence interval over a set of grid cells (recommended).

float	getCellGtheta (self, int index)
	Get G(theta) value for a grid cell.

	setCellGtheta (self, float Gtheta, int index)
	Set G(theta) value for a grid cell.

	calculateHitGridCell (self)
	Calculate hit point grid cell assignments.

	gapfillMisses (self)
	Gapfill sky/miss points where rays didn't hit geometry.

	syntheticScan (self, Context context, Optional[int] rays_per_pulse=None, Optional[float] pulse_distance_threshold=None, bool scan_grid_only=False, bool record_misses=True, bool append=False, Optional[Union[ReturnMode, int]] return_mode=None, cancel_flag=None)
	Perform synthetic LiDAR scan of geometry in Context.

	calculateLeafArea (self, Context context, Optional[int] min_voxel_hits=None, Optional[float] element_width=None, Optional[float] Gtheta=None)
	Calculate leaf area for each grid cell.

	calculateSyntheticLeafArea (self, Context context)
	Calculate synthetic leaf area (for validation of synthetic scans).

	calculateSyntheticGtheta (self, Context context)
	Calculate synthetic G(theta) (for validation of synthetic scans).

	exportTriangleNormals (self, str filename)
	Export triangle normal vectors to file.

	exportTriangleAreas (self, str filename)
	Export triangle areas to file.

	exportLeafAreas (self, str filename)
	Export leaf areas for each grid cell to file.

	exportLeafAreaDensities (self, str filename)
	Export leaf area densities for each grid cell to file.

	exportGtheta (self, str filename)
	Export G(theta) values for each grid cell to file.

	addTrianglesToContext (self, Context context)
	Add triangulated mesh to Context as triangle primitives.

	initializeCollisionDetection (self, Context context)
	Initialize CollisionDetection plugin for ray tracing.

	enableCDGPUAcceleration (self)
	Enable GPU acceleration for collision detection ray tracing.

	disableCDGPUAcceleration (self)
	Disable GPU acceleration (use CPU ray tracing)

bool	isGPUAvailable (self)
	Return True if a CUDA-capable GPU is available for collision-detection ray tracing.

bool	isGPUAccelerationEnabled (self)
	Return True if GPU acceleration is currently enabled for collision-detection ray tracing.

	setSyntheticScanProgressPointer (self, ptr)
	Register an external per-scan progress counter polled during :meth:`syntheticScan`.

	setProgressCallback (self, callback)
	Register a progress callback fired with `(progress_fraction, message)` during :meth:`syntheticScan`.

bool	is_available (self)
	Check if LiDAR is available in current build.

Static Public Member Functions
float	getMissDistance ()
	Return the LIDAR_MISS_DISTANCE constant (meters): the distance at which a miss point is placed along its beam.

Protected Member Functions
	_dispatch_synthetic_scan (self, context_ptr, rays_per_pulse, pulse_distance_threshold, scan_grid_only, record_misses, append, return_mode)

	_check_cd_context_alive (self)
	Raise if the Context bound to collision detection has been destroyed.

Static Protected Member Functions
	_validate_trajectory (traj_t, traj_pos, traj_rot, rot_stride, method)
	Shared trajectory validation/marshalling for moving/spinning scans.

Protected Attributes
	_cloud_ptr = lidar_wrapper.createLiDARcloud()

	_progress_callback_ref = None

	_cd_context = context

Constructor & Destructor Documentation

◆ init()

pyhelios.LiDARCloud.LiDARCloud.__init__ ( self )

Initialize LiDARCloud.

Exceptions

LiDARError	If plugin not available in current build
RuntimeError	If cloud initialization fails

Definition at line 161 of file LiDARCloud.py.

◆ del()

pyhelios.LiDARCloud.LiDARCloud.__del__ ( self )

Fallback destructor for cleanup without context manage.

Definition at line 193 of file LiDARCloud.py.

Member Function Documentation

◆ enter()

pyhelios.LiDARCloud.LiDARCloud.__enter__ ( self )

Context manager entry.

Definition at line 183 of file LiDARCloud.py.

◆ exit()

pyhelios.LiDARCloud.LiDARCloud.__exit__	(	self,
		exc_type,
		exc_val,
		exc_tb )

Context manager exit - cleanup resources.

Definition at line 187 of file LiDARCloud.py.

◆ _check_cd_context_alive()

pyhelios.LiDARCloud.LiDARCloud._check_cd_context_alive ( self )

protected

Raise if the Context bound to collision detection has been destroyed.

Definition at line 1969 of file LiDARCloud.py.

◆ _dispatch_synthetic_scan()

pyhelios.LiDARCloud.LiDARCloud._dispatch_synthetic_scan	(	self,
		context_ptr,
		rays_per_pulse,
		pulse_distance_threshold,
		scan_grid_only,
		record_misses,
		append,
		return_mode )

protected

Definition at line 1751 of file LiDARCloud.py.

◆ _validate_trajectory()

pyhelios.LiDARCloud.LiDARCloud._validate_trajectory	(	traj_t,
		traj_pos,
		traj_rot,
		rot_stride,
		method )

staticprotected

Shared trajectory validation/marshalling for moving/spinning scans.

   Returns (t_list, pos_list, rot_list) of plain Python floats. rot_stride is 4 for
   quaternions or 3 for Euler triples; pass rot_stride=None to skip rotation validation.

Definition at line 391 of file LiDARCloud.py.

◆ addGrid()

pyhelios.LiDARCloud.LiDARCloud.addGrid	(		self,
		Union[vec3, List[float], Tuple[float, float, float]]	center,
		Union[vec3, List[float], Tuple[float, float, float]]	size,
		Union[List[int], Tuple[int, int, int]]	ndiv,
		float	rotation = 0.0,
		Optional[Union[List[float], Tuple[float, ...]]]	column_z_offsets = None )

Add a rectangular grid of voxel cells.

Parameters

center	Grid center position (vec3 or 3-element list)
size	Grid dimensions [x, y, z] (vec3 or 3-element list)
ndiv	Number of divisions [nx, ny, nz] (3-element list)
rotation	Azimuthal rotation angle (degrees, default 0.0)
column_z_offsets	Optional per-(x,y)-column vertical offset for terrain following, row-major as `[jndiv[0] + i]` with length `ndiv[0]ndiv[1]`. Each vertical column of voxels is shifted in z by its column's offset so the grid can track an external terrain surface (e.g. a DEM). `None` (the default) builds an axis-regular grid.

Note: rotation is in degrees here, matching the native addGrid(). :meth:addGridCell takes its rotation in radians — the two native entry points genuinely differ, and PyHelios passes each through unchanged. :meth:getCellRotation reports degrees.

Example: >>> lidar.addGrid( ... center=vec3(0, 0, 0.5), ... size=vec3(10, 10, 1), ... ndiv=[10, 10, 5], ... rotation=0.0 ... )

: Terrain-following grid over a 2x2 column layout:

: >>> lidar.addGrid( ... center=vec3(0, 0, 0.5), ... size=vec3(10, 10, 1), ... ndiv=[2, 2, 5], ... column_z_offsets=[0.0, 0.1, 0.2, 0.3] ... )

Definition at line 1460 of file LiDARCloud.py.

◆ addGridCell()

pyhelios.LiDARCloud.LiDARCloud.addGridCell	(		self,
		Union[vec3, List[float], Tuple[float, float, float]]	center,
		Union[vec3, List[float], Tuple[float, float, float]]	size,
		float	rotation = 0.0 )

Add a single grid cell.

Parameters

center	Cell center position (vec3 or 3-element list)
size	Cell dimensions [x, y, z] (vec3 or 3-element list)
rotation	Azimuthal rotation angle (radians, default 0.0)

Note: rotation is in radians here, whereas :meth:addGrid takes degrees. This asymmetry is inherited from the native API — the native addGridCell() stores the angle directly in the cell's radian field while addGrid() converts from degrees. :meth:getCellRotation reports degrees.

Definition at line 1525 of file LiDARCloud.py.

◆ addHitPoint()

pyhelios.LiDARCloud.LiDARCloud.addHitPoint	(		self,
		int	scanID,
		Union[vec3, List[float], Tuple[float, float, float]]	xyz,
		Union[vec3, SphericalCoord, List[float], Tuple[float, float]]	direction,
		Optional[Union[RGBcolor, List[float], Tuple[float, float, float]]]	color = None )

Add a hit point to the point cloud.

Parameters

scanID	Scan ID this hit belongs to
xyz	Hit point coordinates (vec3 or 3-element list)
direction	Ray direction (vec3/SphericalCoord or 2-3 element list)
color	Optional RGB color (RGBcolor or 3-element list)

Definition at line 906 of file LiDARCloud.py.

◆ addHitPoints()

pyhelios.LiDARCloud.LiDARCloud.addHitPoints	(		self,
		int	scanID,
			xyz_array,
			direction_array,
			color_array = None )

Add many hit points to the point cloud in a single bulk call.

   This skips the per-point Python loop by passing contiguous buffers
   straight to the native library in one FFI call.

Parameters

scanID	Scan ID these hits belong to
xyz_array	Hit point coordinates, shape (N, 3) [x, y, z]
direction_array	Ray directions, shape (N, 3) [radius, elevation, azimuth] (azimuth is currently ignored, matching addHitPoint)
color_array	Optional RGB colors, shape (N, 3) [r, g, b]

Definition at line 960 of file LiDARCloud.py.

◆ addHitPointsWithData()

pyhelios.LiDARCloud.LiDARCloud.addHitPointsWithData	(		self,
		int	scanID,
			xyz_array,
			direction_array,
			data_labels = None,
			data_values = None,
			color_array = None )

Add many hit points carrying a per-hit data map in a single bulk call.

   Like addHitPoints, but also populates each hit's named-scalar data map —
   the in-memory equivalent of what the ASCII loader does for non-standard
   columns. This is the path multi-return LAD needs (timestamp/target_index/
   target_count land in the map so gapfillMisses() can group beams by pulse).

Parameters

scanID	Scan ID these hits belong to (the scan must already exist)
xyz_array	Hit point coordinates, shape (N, 3) [x, y, z]
direction_array	Ray directions, shape (N, 3) [radius, elevation, azimuth].
Pass	origin) to match loadASCIIFile; the full SphericalCoord (incl. radius) is used.
data_labels	Optional list of data-map key names (length k)
data_values	Optional (N, k) values for those keys (float64)
color_array	Optional RGB colors, shape (N, 3) [r, g, b]

Definition at line 1003 of file LiDARCloud.py.

◆ addScan()

int pyhelios.LiDARCloud.LiDARCloud.addScan	(		self,
		Union[vec3, List[float], Tuple[float, float, float]]	origin,
		int	Ntheta,
		Tuple[float, float]	theta_range,
		int	Nphi,
		Tuple[float, float]	phi_range,
		float	exit_diameter,
		float	beam_divergence,
		Optional[List[str]]	column_format = None,
		float	range_noise_stddev = 0.0,
		float	angle_noise_stddev = 0.0,
		float	scan_tilt_roll = 0.0,
		float	scan_tilt_pitch = 0.0,
		float	scan_azimuth_offset = 0.0 )

Add a LiDAR scan to the point cloud.

Parameters

origin	Scanner position (vec3 or 3-element list/tuple)
Ntheta	Number of scan points in zenith direction
theta_range	Zenith angle range (min, max) in radians
Nphi	Number of scan points in azimuthal direction
phi_range	Azimuthal angle range (min, max) in radians
exit_diameter	Laser beam exit diameter (meters)
beam_divergence	Beam divergence angle (radians)
column_format	Optional list of column-format labels. Non-standard labels (anything other than geometry/standard tokens like x/y/z/r/g/b/raydir) cause syntheticScan to sample that named primitive data from the struck primitive onto each hit's data map, retrievable via getHitData(). Defaults to None (empty format).

One label is special: "reflectivity_lidar" modulates each hit's "intensity" (intensity *= reflectivity) rather than being stored as its own hit-data key, so getHitData(i, "reflectivity_lidar") will NOT return it.

Parameters

range_noise_stddev	Standard deviation of Gaussian range (along-beam) measurement noise in meters. Only affects synthetic-scan generation. Defaults to 0.0 (noise disabled).
angle_noise_stddev	Standard deviation of Gaussian angular (beam-pointing) jitter in radians. Only affects synthetic-scan generation. Defaults to 0.0 (jitter disabled).
scan_tilt_roll	Global scanner tilt roll angle in radians, modeling residual tilt of the scanner spin axis away from plumb (right-hand rotation about the body lateral axis). Only affects synthetic-scan generation. Defaults to 0.0 (level).
scan_tilt_pitch	Global scanner tilt pitch angle in radians (right-hand rotation about the body forward/azimuth-zero axis). Only affects synthetic-scan generation. Defaults to 0.0 (level).
scan_azimuth_offset	Global scanner azimuth (heading) offset in radians, a right-hand rotation about the world +z axis applied on top of the azimuth sweep. Only affects synthetic-scan generation. Defaults to 0.0 (no offset).

Returns: Scan ID for referencing this scan

Example: >>> scan_id = lidar.addScan( ... origin=vec3(0, 0, 1), ... Ntheta=100, theta_range=(0, 1.57), ... Nphi=100, phi_range=(-3.14, 3.14), ... exit_diameter=0.01, beam_divergence=0.001, ... column_format=["my_scalar"] ... )

Definition at line 250 of file LiDARCloud.py.

◆ addScanMoving()

int pyhelios.LiDARCloud.LiDARCloud.addScanMoving	(		self,
		int	Ntheta,
		Tuple[float, float]	theta_range,
		int	Nphi,
		Tuple[float, float]	phi_range,
		float	exit_diameter,
		float	beam_divergence,
		List[float]	traj_t,
		List[Union[vec3, List[float], Tuple[float, float, float]]]	traj_pos,
		List[List[float]]	traj_rot,
		float	pulse_rate_hz,
		bool	rot_is_quaternion = True,
		Optional[Union[vec3, List[float], Tuple[float, float, float]]]	lever_arm = None,
		Optional[Union[vec3, List[float], Tuple[float, float, float]]]	boresight_rpy = None,
		Optional[List[str]]	column_format = None,
		float	range_noise_stddev = 0.0,
		float	angle_noise_stddev = 0.0,
		float	t0 = 0.0 )

Add a moving-platform (mobile/airborne) raster LiDAR scan driven by a 6-DOF pose trajectory.

   Unlike :meth:`addScan`, the scanner pose changes during the sweep. For each pulse the synthetic-scan
   generator computes its acquisition time ``t = t0 + ordinal / pulse_rate_hz``, interpolates the platform
   pose at that time (linear position, SLERP orientation), and emits a per-pulse origin
   ``o = pos + R(q) * lever_arm`` and direction ``d = R(q) * R(boresight) * d_body``. Every resulting hit
   and miss stores its own origin (hit-data "origin_x"/"origin_y"/"origin_z", retrievable via
   :meth:`getHitOrigin`), timestamp ("timestamp"), and firing index ("pulse_id").

   The static tilt roll/pitch/azimuth fields are NOT applied in this mode; attitude comes entirely
   from the trajectory and the boresight misalignment. Because the pulses do not lie on a fixed
   theta-phi grid they cannot be triangulated, so leaf-area inversion must use
   :meth:`calculateLeafArea` with an explicit ``Gtheta``.

Parameters

Ntheta	Number of scan points in zenith direction (raster grid rows)
theta_range	Zenith angle range (min, max) in radians
Nphi	Number of scan points in azimuthal direction (raster grid columns)
phi_range	Azimuthal angle range (min, max) in radians
exit_diameter	Laser beam exit diameter (meters)
beam_divergence	Beam divergence angle (radians)
traj_t	Monotonically increasing trajectory sample times in seconds (length M)
traj_pos	Platform positions in world coordinates, one [x, y, z] (or vec3) per traj_t entry
traj_rot	Platform orientations, one entry per traj_t entry. Each entry is a length-4 quaternion (qx, qy, qz, qw, Hamilton body->world) when `rot_is_quaternion` is True, otherwise a length-3 roll/pitch/yaw Euler triple in radians (intrinsic Z-Y-X).
pulse_rate_hz	Pulse repetition rate in Hz (must be > 0)
rot_is_quaternion	Whether traj_rot holds quaternions (default True) or Euler angles
lever_arm	Sensor optical center in the platform body frame [x, y, z] meters (default origin)
boresight_rpy	Fixed sensor rotational misalignment [roll, pitch, yaw] radians (default 0)
column_format	Optional list of column-format labels (see addScan)
range_noise_stddev	Std. dev. of Gaussian range noise in meters (default 0)
angle_noise_stddev	Std. dev. of Gaussian angular jitter in radians (default 0)
t0	Time of the first pulse in seconds (relative time; default 0)

Returns: Scan ID for referencing this scan

Definition at line 334 of file LiDARCloud.py.

◆ addScanMovingRaster()

int pyhelios.LiDARCloud.LiDARCloud.addScanMovingRaster	(		self,
		int	Ntheta,
		Tuple[float, float]	theta_range,
		int	Nphi,
		Tuple[float, float]	phi_range,
		float	pulse_rate_hz,
		List[float]	traj_t,
		List[Union[vec3, List[float], Tuple[float, float, float]]]	traj_pos,
		List[List[float]]	traj_quat,
		float	exit_diameter = 0.0,
		float	beam_divergence = 0.0,
		Optional[Union[vec3, List[float], Tuple[float, float, float]]]	lever_arm = None,
		Optional[Union[vec3, List[float], Tuple[float, float, float]]]	boresight_rpy = None,
		Optional[List[str]]	column_format = None,
		float	range_noise_stddev = 0.0,
		float	angle_noise_stddev = 0.0,
		float	t0 = 0.0 )

Add a moving-platform raster scan: a fixed angular fan swept along a quaternion trajectory.

   High-level wrapper around :meth:`addScanMoving` for a non-spinning sensor on a moving platform.
   Specify the per-frame angular fan resolution plus the trajectory and PRF; Helios derives the
   per-pulse time sampling along the trajectory. Sets the scan's :class:`ScanMode` to ``MOVING_RASTER``.

Parameters

Ntheta	Number of zenith samples in the angular fan
theta_range	Zenith angle range (min, max) in radians
Nphi	Number of azimuth samples in the angular fan
phi_range	Azimuthal angle range (min, max) in radians
pulse_rate_hz	Pulse repetition rate (PRF) in Hz (must be > 0)
traj_t	Monotonically increasing trajectory sample times in seconds (length M)
traj_pos	Platform positions in world coordinates, one [x, y, z] (or vec3) per traj_t entry
traj_quat	Platform orientation quaternions (qx, qy, qz, qw, Hamilton body->world), one per traj_t entry
exit_diameter	Laser beam exit diameter (meters, default 0)
beam_divergence	Beam divergence angle (radians, default 0)
lever_arm	Sensor optical center in the platform body frame [x, y, z] meters (default origin)
boresight_rpy	Fixed sensor rotational misalignment [roll, pitch, yaw] radians (default 0)
column_format	Optional list of column-format labels (default ["x", "y", "z"])
range_noise_stddev	Std. dev. of Gaussian range noise in meters (default 0)
angle_noise_stddev	Std. dev. of Gaussian angular jitter in radians (default 0)
t0	Time of the first pulse in seconds (relative time; default 0)

Returns: Scan ID for referencing this scan

Definition at line 534 of file LiDARCloud.py.

◆ addScanRisley()

int pyhelios.LiDARCloud.LiDARCloud.addScanRisley	(		self,
		List[Union['RisleyPrism', List[float], Tuple[float, ...]]]	prisms,
		float	refractive_index_air,
		float	pulse_rate_hz,
		List[float]	traj_t,
		List[Union[vec3, List[float], Tuple[float, float, float]]]	traj_pos,
		List[List[float]]	traj_rot,
		bool	rot_is_quaternion = True,
		float	exit_diameter = 0.0,
		float	beam_divergence = 0.0,
		Optional[Union[vec3, List[float], Tuple[float, float, float]]]	lever_arm = None,
		Optional[Union[vec3, List[float], Tuple[float, float, float]]]	boresight_rpy = None,
		Optional[List[str]]	column_format = None,
		float	range_noise_stddev = 0.0,
		float	angle_noise_stddev = 0.0,
		float	t0 = 0.0 )

Add a rotating-Risley-prism (Livox-style rosette) scan from physical instrument parameters.

   High-level entry point for a Livox rosette-pattern sensor (Mid-40/Mid-70/Avia). A single beam is
   refracted through a stack of continuously rotating wedge prisms, tracing a non-repetitive rosette
   that fills a circular field of view. The scan is stored as an Ntheta=1, Nphi=Npulses table, where
   Npulses = round(pulse_rate_hz * trajectory_duration). Sets the scan's :class:`ScanMode` to
   ``RISLEY_PRISM`` and :class:`ScanPattern` to ``RISLEY_PRISM``. Like a spinning scan it is always
   trajectory-driven; a stationary tripod capture is two coincident poses (same position and
   orientation) separated in time by the acquisition duration.

Parameters

prisms	Rotating wedge prisms in beam-traversal order (at least one; a Livox sensor uses two counter-rotating prisms). Each entry is a :class:`RisleyPrism` or a 4-element [wedge_angle, refractive_index, rotor_rate, phase] list/tuple (radians / unitless / rad-per-s / radians).
refractive_index_air	Refractive index of the medium surrounding the prisms (typically 1.0)
pulse_rate_hz	Pulse repetition rate (PRF) in Hz (must be > 0)
traj_t	Monotonically increasing trajectory sample times in seconds (length M)
traj_pos	Platform positions in world coordinates, one [x, y, z] (or vec3) per traj_t entry
traj_rot	Platform orientations, one per traj_t entry. Length-4 quaternion (qx, qy, qz, qw, Hamilton body->world) when `rot_is_quaternion` is True, otherwise length-3 roll/pitch/yaw Euler triple in radians (intrinsic Z-Y-X).
rot_is_quaternion	Whether traj_rot holds quaternions (default True) or Euler angles
exit_diameter	Laser beam exit diameter (meters, default 0)
beam_divergence	Beam divergence angle (radians, default 0)
lever_arm	Sensor optical center in the platform body frame [x, y, z] meters (default origin)
boresight_rpy	Fixed sensor rotational misalignment [roll, pitch, yaw] radians (default 0)
column_format	Optional list of column-format labels (default ["x", "y", "z"])
range_noise_stddev	Std. dev. of Gaussian range noise in meters (default 0)
angle_noise_stddev	Std. dev. of Gaussian angular jitter in radians (default 0)
t0	Time of the first pulse in seconds (relative time; default 0)

Returns: Scan ID for referencing this scan

Definition at line 617 of file LiDARCloud.py.

◆ addScanSpinning()

int pyhelios.LiDARCloud.LiDARCloud.addScanSpinning	(		self,
		List[float]	beam_elevation_angles,
		float	azimuth_step,
		float	pulse_rate_hz,
		List[float]	traj_t,
		List[Union[vec3, List[float], Tuple[float, float, float]]]	traj_pos,
		List[List[float]]	traj_rot,
		bool	rot_is_quaternion = True,
		float	exit_diameter = 0.0,
		float	beam_divergence = 0.0,
		Optional[Union[vec3, List[float], Tuple[float, float, float]]]	lever_arm = None,
		Optional[Union[vec3, List[float], Tuple[float, float, float]]]	boresight_rpy = None,
		Optional[List[str]]	column_format = None,
		float	range_noise_stddev = 0.0,
		float	angle_noise_stddev = 0.0,
		float	t0 = 0.0 )

Add a continuously-spinning multibeam scan from physical instrument parameters.

   High-level entry point for a rotating multi-channel sensor (Velodyne/Ouster/Hesai) on a moving
   (or stationary) platform. The azimuth grid, rotation rate, and revolution count are derived
   internally from the azimuth resolution, PRF, and trajectory duration; you never specify an
   azimuth range or step count. Sets the scan's :class:`ScanMode` to ``SPINNING``. For a stationary
   "spin in place" capture (a tripod), supply two coincident poses (same position and orientation)
   separated in time by the acquisition duration.

Parameters

beam_elevation_angles	Per-channel beam ELEVATION angles above the horizon, in radians (NOT zenith — elevation above the horizon, where zenith = pi/2 - elevation; this matches manufacturer spec sheets)
azimuth_step	Azimuth angular resolution in radians per firing step (must be > 0)
pulse_rate_hz	Pulse repetition rate (PRF) in Hz (must be > 0)
traj_t	Monotonically increasing trajectory sample times in seconds (length M)
traj_pos	Platform positions in world coordinates, one [x, y, z] (or vec3) per traj_t entry
traj_rot	Platform orientations, one per traj_t entry. Length-4 quaternion (qx, qy, qz, qw, Hamilton body->world) when `rot_is_quaternion` is True, otherwise length-3 roll/pitch/yaw Euler triple in radians (intrinsic Z-Y-X).
rot_is_quaternion	Whether traj_rot holds quaternions (default True) or Euler angles
exit_diameter	Laser beam exit diameter (meters, default 0)
beam_divergence	Beam divergence angle (radians, default 0)
lever_arm	Sensor optical center in the platform body frame [x, y, z] meters (default origin)
boresight_rpy	Fixed sensor rotational misalignment [roll, pitch, yaw] radians (default 0)
column_format	Optional list of column-format labels (default ["x", "y", "z"])
range_noise_stddev	Std. dev. of Gaussian range noise in meters (default 0)
angle_noise_stddev	Std. dev. of Gaussian angular jitter in radians (default 0)
t0	Time of the first pulse in seconds (relative time; default 0)

Returns: Scan ID for referencing this scan

Definition at line 458 of file LiDARCloud.py.

◆ addTrianglesToContext()

pyhelios.LiDARCloud.LiDARCloud.addTrianglesToContext	(		self,
		Context	context )

Add triangulated mesh to Context as triangle primitives.

   Converts the triangulated point cloud mesh into Context triangle
   primitives that can be used for further analysis or visualization.

Parameters

context Helios Context instance

Example: >>> with Context() as context: ... with LiDARCloud() as lidar: ... lidar.loadXML("scan.xml") ... lidar.triangulateHitPoints(Lmax=0.5, max_aspect_ratio=5) ... lidar.addTrianglesToContext(context) ... print(f"Added {context.getPrimitiveCount()} triangles to context")

Definition at line 1930 of file LiDARCloud.py.

◆ calculateHitGridCell()

pyhelios.LiDARCloud.LiDARCloud.calculateHitGridCell ( self )

Calculate hit point grid cell assignments.

Definition at line 1667 of file LiDARCloud.py.

◆ calculateLeafArea()

pyhelios.LiDARCloud.LiDARCloud.calculateLeafArea	(		self,
		Context	context,
		Optional[int]	min_voxel_hits = None,
		Optional[float]	element_width = None,
		Optional[float]	Gtheta = None )

Calculate leaf area for each grid cell.

   Requires triangulation to have been performed first, UNLESS a ``Gtheta`` is supplied
   (see below).

   .. note::
       The cloud must contain misses (transmitted beams that returned nothing) — the
       inversion fails fast without them. Misses are produced by
       ``syntheticScan(..., record_misses=True)`` (the default) or by
       :meth:`gapfillMisses`. Use :meth:`hasMisses` to check.

Parameters

context	Helios Context instance
min_voxel_hits	Optional minimum number of hits required per voxel
element_width	Optional characteristic vegetation element width (meters). When provided, per-voxel sampling uncertainty (Pimont et al. 2018) is computed alongside the leaf-area estimate and becomes available via :meth:`getCellLADVariance`, :meth:`getCellLeafAreaConfidenceInterval`, and :meth:`getGroupLADConfidenceInterval`. `element_width <= 0` yields a sampling-only variance.
Gtheta	Optional caller-supplied mean leaf-projection coefficient G(theta), in (0,1] (0.5 = spherical/random leaf-angle distribution). When provided, leaf area is computed via a beam-based inversion that uses each hit's per-pulse beam origin and does NOT require triangulation — the only supported path for moving-platform scans (see :meth:`addScanMoving`). Requires both `min_voxel_hits` and `element_width` to also be specified.

Example: >>> from pyhelios import Context, LiDARCloud >>> with Context() as context: ... with LiDARCloud() as lidar: ... # ... load data, add grid, triangulate ... ... lidar.calculateLeafArea(context)

Definition at line 1820 of file LiDARCloud.py.

◆ calculateSyntheticGtheta()

pyhelios.LiDARCloud.LiDARCloud.calculateSyntheticGtheta	(		self,
		Context	context )

Calculate synthetic G(theta) (for validation of synthetic scans).

   Uses exact primitive geometry to calculate G(theta), useful for
   validating synthetic scan accuracy.

Parameters

context Helios Context instance containing primitive geometry

Definition at line 1877 of file LiDARCloud.py.

◆ calculateSyntheticLeafArea()

pyhelios.LiDARCloud.LiDARCloud.calculateSyntheticLeafArea	(		self,
		Context	context )

Calculate synthetic leaf area (for validation of synthetic scans).

   Uses exact primitive geometry to calculate leaf area, useful for
   validating synthetic scan accuracy.

Parameters

context Helios Context instance containing primitive geometry

Definition at line 1862 of file LiDARCloud.py.

◆ coordinateRotation()

pyhelios.LiDARCloud.LiDARCloud.coordinateRotation	(		self,
		Union[SphericalCoord, List[float], Tuple[float, float]]	rotation )

Rotate all hit points by spherical rotation angles.

Parameters

rotation Rotation angles (SphericalCoord or 2-3 element list)

Definition at line 1262 of file LiDARCloud.py.

◆ coordinateShift()

pyhelios.LiDARCloud.LiDARCloud.coordinateShift	(		self,
		Union[vec3, List[float], Tuple[float, float, float]]	shift )

Translate all hit points by a shift vector.

Parameters

shift Translation vector (vec3 or 3-element list)

Definition at line 1244 of file LiDARCloud.py.

◆ deleteHitPoint()

pyhelios.LiDARCloud.LiDARCloud.deleteHitPoint	(		self,
		int	index )

Delete a hit point from the cloud.

Definition at line 1209 of file LiDARCloud.py.

◆ disableCDGPUAcceleration()

pyhelios.LiDARCloud.LiDARCloud.disableCDGPUAcceleration ( self )

Disable GPU acceleration (use CPU ray tracing)

Definition at line 1979 of file LiDARCloud.py.

◆ disableMessages()

pyhelios.LiDARCloud.LiDARCloud.disableMessages ( self )

Disable console output messages.

Definition at line 1416 of file LiDARCloud.py.

◆ distanceFilter()

pyhelios.LiDARCloud.LiDARCloud.distanceFilter	(		self,
		float	maxdistance )

Filter hit points by maximum distance from scanne.

Definition at line 1354 of file LiDARCloud.py.

◆ doesHitDataExist()

bool pyhelios.LiDARCloud.LiDARCloud.doesHitDataExist	(		self,
		int	index,
		str	label )

Check whether a named scalar data value exists for a hit point.

   Per-hit data computed by syntheticScan includes 'intensity', 'distance',
   'timestamp', 'target_index', 'target_count', 'deviation', 'nRaysHit', plus any
   primitive-data labels listed in the scan's column_format.

Definition at line 1087 of file LiDARCloud.py.

◆ enableCDGPUAcceleration()

pyhelios.LiDARCloud.LiDARCloud.enableCDGPUAcceleration ( self )

Enable GPU acceleration for collision detection ray tracing.

Definition at line 1974 of file LiDARCloud.py.

◆ enableMessages()

pyhelios.LiDARCloud.LiDARCloud.enableMessages ( self )

Enable console output messages.

Definition at line 1420 of file LiDARCloud.py.

◆ exportGtheta()

pyhelios.LiDARCloud.LiDARCloud.exportGtheta	(		self,
		str	filename )

Export G(theta) values for each grid cell to file.

Definition at line 1908 of file LiDARCloud.py.

◆ exportLeafAreaDensities()

pyhelios.LiDARCloud.LiDARCloud.exportLeafAreaDensities	(		self,
		str	filename )

Export leaf area densities for each grid cell to file.

Definition at line 1902 of file LiDARCloud.py.

◆ exportLeafAreas()

pyhelios.LiDARCloud.LiDARCloud.exportLeafAreas	(		self,
		str	filename )

Export leaf areas for each grid cell to file.

Definition at line 1896 of file LiDARCloud.py.

◆ exportLeafAreaUncertainty()

pyhelios.LiDARCloud.LiDARCloud.exportLeafAreaUncertainty	(		self,
		str	filename )

Export per-voxel leaf-area sampling uncertainty to a self-describing ASCII file.

   The file has a ``#``-prefixed header and one row per grid cell:
   ``cell_index leaf_area beam_count I_rdi LAD_std_error ci_valid``. Requires that
   :meth:`calculateLeafArea` has been run with an ``element_width`` (the uncertainty
   overload).

Definition at line 1391 of file LiDARCloud.py.

◆ exportPointCloud()

pyhelios.LiDARCloud.LiDARCloud.exportPointCloud	(		self,
		str	filename,
		bool	write_header = True )

Export point cloud to ASCII file.

Parameters

filename	Output file path.
write_header	If True (default), prepend a `#`-prefixed comment line listing the column field names (CloudCompare convention). The loader skips `#`-prefixed lines, so headered files round-trip through `loadXML()`. Set False for a bare data file.

Definition at line 1379 of file LiDARCloud.py.

◆ exportScans()

pyhelios.LiDARCloud.LiDARCloud.exportScans	(		self,
		str	filename )

Export all scans to an XML metadata file plus one ASCII data file per scan.

Parameters

filename Path of the XML metadata file to write (e.g. "output/scans.xml"). One ASCII data file is auto-generated per scan, named by stripping the XML extension and appending "_<scanID>.xyz" (e.g. "output/scans_0.xyz"). The resulting XML can be re-loaded with loadXML() from the same working directory.

Definition at line 1404 of file LiDARCloud.py.

◆ exportTriangleAreas()

pyhelios.LiDARCloud.LiDARCloud.exportTriangleAreas	(		self,
		str	filename )

Export triangle areas to file.

Definition at line 1890 of file LiDARCloud.py.

◆ exportTriangleNormals()

pyhelios.LiDARCloud.LiDARCloud.exportTriangleNormals	(		self,
		str	filename )

Export triangle normal vectors to file.

Definition at line 1884 of file LiDARCloud.py.

◆ firstHitFilter()

pyhelios.LiDARCloud.LiDARCloud.firstHitFilter ( self )

Keep only first return hit points.

Definition at line 1363 of file LiDARCloud.py.

◆ gapfillMisses()

pyhelios.LiDARCloud.LiDARCloud.gapfillMisses ( self )

Gapfill sky/miss points where rays didn't hit geometry.

   Important for accurate leaf area calculations with real LiDAR data.
   Should be called before triangulation when processing real data.

Definition at line 1676 of file LiDARCloud.py.

◆ getCellBeamCount()

int pyhelios.LiDARCloud.LiDARCloud.getCellBeamCount	(		self,
		int	index )

Get the beam count N that entered a grid cell during the leaf-area inversion.

   Returns -1 if :meth:`calculateLeafArea` has not been run for this cell.

Definition at line 1600 of file LiDARCloud.py.

◆ getCellCenter()

vec3 pyhelios.LiDARCloud.LiDARCloud.getCellCenter	(		self,
		int	index )

Get the true world-space center position of a grid cell.

   For a grid created with a non-zero azimuthal ``rotation``, this is the lattice
   center rotated about the grid anchor (about +z), so it lies in the same rotated
   world frame as the hit points, scan origins, and grid bounding box. For an
   un-rotated grid it is simply the lattice center.

Definition at line 1561 of file LiDARCloud.py.

◆ getCellGtheta()

float pyhelios.LiDARCloud.LiDARCloud.getCellGtheta	(		self,
		int	index )

Get G(theta) value for a grid cell.

Definition at line 1655 of file LiDARCloud.py.

◆ getCellLADVariance()

float pyhelios.LiDARCloud.LiDARCloud.getCellLADVariance	(		self,
		int	index )

Get the per-voxel LAD sampling variance for a grid cell.

   Returns -1 if uncertainty has not been computed (call :meth:`calculateLeafArea`
   with an ``element_width``).

Definition at line 1622 of file LiDARCloud.py.

◆ getCellLeafArea()

float pyhelios.LiDARCloud.LiDARCloud.getCellLeafArea	(		self,
		int	index )

Get leaf area of a grid cell (m²)

Definition at line 1585 of file LiDARCloud.py.

◆ getCellLeafAreaConfidenceInterval()

pyhelios.LiDARCloud.LiDARCloud.getCellLeafAreaConfidenceInterval	(		self,
		int	index,
		float	confidence_level = 0.95 )

Get the leaf-area confidence interval for a single grid cell.

   Returns a ``(valid, lower, upper)`` tuple. ``valid`` is False when the interval is
   gated out by the Pimont validity envelope (single-voxel intervals are often
   untrustworthy; prefer :meth:`getGroupLADConfidenceInterval`). Requires
   :meth:`calculateLeafArea` to have been run with an ``element_width``.

Definition at line 1634 of file LiDARCloud.py.

◆ getCellLeafAreaDensity()

float pyhelios.LiDARCloud.LiDARCloud.getCellLeafAreaDensity	(		self,
		int	index )

Get leaf area density of a grid cell (m²/m³)

Definition at line 1591 of file LiDARCloud.py.

◆ getCellMeanPathLength()

float pyhelios.LiDARCloud.LiDARCloud.getCellMeanPathLength	(		self,
		int	index )

Get the mean beam path length (m) through a grid cell.

Definition at line 1612 of file LiDARCloud.py.

◆ getCellRelativeDensityIndex()

float pyhelios.LiDARCloud.LiDARCloud.getCellRelativeDensityIndex	(		self,
		int	index )

Get the relative density index (I_rdi) for a grid cell.

Definition at line 1606 of file LiDARCloud.py.

◆ getCellRotation()

float pyhelios.LiDARCloud.LiDARCloud.getCellRotation	(		self,
		int	index )

Get the azimuthal rotation of a grid cell about the z-axis, in degrees.

   The units match the ``rotation`` argument of :meth:`addGrid`. Note that
   :meth:`addGridCell` takes its rotation in radians.

Definition at line 1579 of file LiDARCloud.py.

◆ getCellSize()

vec3 pyhelios.LiDARCloud.LiDARCloud.getCellSize	(		self,
		int	index )

Get size of a grid cell.

Definition at line 1568 of file LiDARCloud.py.

◆ getGridCellCount()

int pyhelios.LiDARCloud.LiDARCloud.getGridCellCount ( self )

Get total number of grid cells.

Definition at line 1551 of file LiDARCloud.py.

◆ getGroupLADConfidenceInterval()

pyhelios.LiDARCloud.LiDARCloud.getGroupLADConfidenceInterval	(		self,
		List[int]	indices,
		float	confidence_level = 0.95 )

Get the group-scale LAD confidence interval over a set of grid cells (recommended).

   Returns a ``(valid, mean_lad, lower, upper)`` tuple (Pimont et al. 2018, Eq. 39,
   assuming voxel independence). Requires :meth:`calculateLeafArea` to have been run
   with an ``element_width``.

Definition at line 1646 of file LiDARCloud.py.

◆ getHitColor()

RGBcolor pyhelios.LiDARCloud.LiDARCloud.getHitColor	(		self,
		int	index )

Get color of a hit point.

Definition at line 1069 of file LiDARCloud.py.

◆ getHitCount()

int pyhelios.LiDARCloud.LiDARCloud.getHitCount ( self )

Get total number of hit points in cloud.

Definition at line 1039 of file LiDARCloud.py.

◆ getHitData()

float pyhelios.LiDARCloud.LiDARCloud.getHitData	(		self,
		int	index,
		str	label )

Get a named scalar data value for a hit point.

   Raises HeliosError if the label does not exist for this hit; guard with
   doesHitDataExist() when unsure.

Definition at line 1097 of file LiDARCloud.py.

◆ getHitDataAll()

List[float] pyhelios.LiDARCloud.LiDARCloud.getHitDataAll	(		self,
		str	label )

Bulk-export a named scalar data value for all hits in a single FFI call.

   Returns a list of length getHitCount(); entries are NaN where the label is
   absent for that hit. Much faster than looping getHitData() for large clouds.

Note: values are returned at float32 precision (vs. getHitData(), which returns full float64). Use getHitData() per-hit if full precision is required.

Definition at line 1110 of file LiDARCloud.py.

◆ getHitDataArray()

pyhelios.LiDARCloud.LiDARCloud.getHitDataArray	(		self,
		str	label )

Bulk-export a named scalar field as an (getHitCount(),) float32 array, NaN where the label is absent for a hit.

Definition at line 1151 of file LiDARCloud.py.

◆ getHitDataColumn()

List[float] pyhelios.LiDARCloud.LiDARCloud.getHitDataColumn	(		self,
		str	label,
		float	absent_value = -9999.0 )

Bulk-export a named scalar column via the native cache-linear columnar path.

   Faster than :meth:`getHitDataAll` for whole-field reads (a single cache-linear pass over
   the contiguous native column rather than per-hit tree lookups), and returns full float64
   precision. Entries are ``absent_value`` where the label is absent for a hit. Returns a list
   of length getHitCount().

Definition at line 1165 of file LiDARCloud.py.

◆ getHitDataColumnArray()

pyhelios.LiDARCloud.LiDARCloud.getHitDataColumnArray	(		self,
		str	label,
		float	absent_value = -9999.0 )

Bulk-export a named scalar column as an (getHitCount(),) float64 numpy array via the columnar path (absent_value where the label is absent for a hit).

Definition at line 1184 of file LiDARCloud.py.

◆ getHitDataColumnIndex()

int pyhelios.LiDARCloud.LiDARCloud.getHitDataColumnIndex	(		self,
		str	label )

Get the internal column slot index for a hit-data label.

   Per-hit scalar data is stored column-wise; this resolves a label to its column slot for
   repeated bulk access without re-resolving the label by string. Returns -1 if the label has
   never been set on any hit.

Definition at line 1177 of file LiDARCloud.py.

◆ getHitMissArray()

pyhelios.LiDARCloud.LiDARCloud.getHitMissArray ( self )

Bulk-export the miss flag of every hit as an (getHitCount(),) int32 array (1 == sky/miss, 0 == real surface return).

Definition at line 1201 of file LiDARCloud.py.

◆ getHitOrigin()

vec3 pyhelios.LiDARCloud.LiDARCloud.getHitOrigin	(		self,
		int	index )

Get the (x,y,z) beam-emission origin of a hit point.

   For moving-platform scans (see :meth:`addScanMoving`) this is the per-pulse emission origin
   recorded on the hit; for static scans it falls back to the single scan origin of the hit's scan.

Definition at line 1054 of file LiDARCloud.py.

◆ getHitRaydir()

SphericalCoord pyhelios.LiDARCloud.LiDARCloud.getHitRaydir	(		self,
		int	index )

Get ray direction of a hit point.

Definition at line 1061 of file LiDARCloud.py.

◆ getHitScanID()

int pyhelios.LiDARCloud.LiDARCloud.getHitScanID	(		self,
		int	index )

Get the scan ID a hit point belongs to.

Definition at line 1076 of file LiDARCloud.py.

◆ getHitScanIDArray()

pyhelios.LiDARCloud.LiDARCloud.getHitScanIDArray ( self )

Bulk-export the scan ID of every hit as an (getHitCount(),) int32 array.

Definition at line 1192 of file LiDARCloud.py.

◆ getHitsXYZRGB()

Tuple[List[vec3], List[RGBcolor]] pyhelios.LiDARCloud.LiDARCloud.getHitsXYZRGB ( self )

Bulk-export coordinates and colors for all hits in a single FFI call.

   Returns (positions, colors) where positions is a list of vec3 and colors a list
   of RGBcolor, each of length getHitCount(). Much faster than looping
   getHitXYZ()/getHitColor() for large clouds.

Definition at line 1122 of file LiDARCloud.py.

◆ getHitsXYZRGBArrays()

pyhelios.LiDARCloud.LiDARCloud.getHitsXYZRGBArrays ( self )

Bulk-export hit coordinates + colors as numpy arrays.

   Returns (xyz, rgb), each (getHitCount(), 3) float32. Empty (0,3) arrays
   when there are no hits.

Definition at line 1142 of file LiDARCloud.py.

◆ getHitXYZ()

vec3 pyhelios.LiDARCloud.LiDARCloud.getHitXYZ	(		self,
		int	index )

Get coordinates of a hit point.

Definition at line 1043 of file LiDARCloud.py.

◆ getMissDistance()

float pyhelios.LiDARCloud.LiDARCloud.getMissDistance ( )

static

Return the LIDAR_MISS_DISTANCE constant (meters): the distance at which a miss point is placed along its beam.

Definition at line 1235 of file LiDARCloud.py.

◆ getScanAngleNoiseStdDev()

float pyhelios.LiDARCloud.LiDARCloud.getScanAngleNoiseStdDev	(		self,
		int	scanID )

Get the angular (beam-pointing) jitter standard deviation for a scan (radians).

   Returns the value supplied to addScan() as ``angle_noise_stddev`` (0.0 if disabled).

Definition at line 707 of file LiDARCloud.py.

◆ getScanAzimuthOffset()

float pyhelios.LiDARCloud.LiDARCloud.getScanAzimuthOffset	(		self,
		int	scanID )

Get the global scanner azimuth (heading) offset for a scan (radians; 0.0 if none).

Definition at line 725 of file LiDARCloud.py.

◆ getScanBeamZenithAngles()

List[float] pyhelios.LiDARCloud.LiDARCloud.getScanBeamZenithAngles	(		self,
		int	scanID )

Get the per-channel beam zenith angles (radians) for a multibeam scan.

   Returns an empty list for a raster scan.

Definition at line 745 of file LiDARCloud.py.

◆ getScanCount()

int pyhelios.LiDARCloud.LiDARCloud.getScanCount ( self )

Get total number of scans in the cloud.

Definition at line 672 of file LiDARCloud.py.

◆ getScanDetectionThreshold()

float pyhelios.LiDARCloud.LiDARCloud.getScanDetectionThreshold	(		self,
		int	scanID )

Get the detection threshold (energy fraction, noise floor) of a scan.

Definition at line 884 of file LiDARCloud.py.

◆ getScanMaxReturns()

int pyhelios.LiDARCloud.LiDARCloud.getScanMaxReturns	(		self,
		int	scanID )

Get the maximum returns per pulse used in single/limited-return mode (1 = single, N = N-return).

Definition at line 828 of file LiDARCloud.py.

◆ getScanMode()

ScanMode pyhelios.LiDARCloud.LiDARCloud.getScanMode	(		self,
		int	scanID )

Get the high-level acquisition mode of a scan as a :class:ScanMode.

   STATIC_RASTER (fixed-origin grid), MOVING_RASTER (fan swept along a trajectory),
   SPINNING (continuously-rotating multi-channel sensor), or RISLEY_PRISM (Livox-style rosette).

Definition at line 755 of file LiDARCloud.py.

◆ getScanOrigin()

vec3 pyhelios.LiDARCloud.LiDARCloud.getScanOrigin	(		self,
		int	scanID )

Get origin of a specific scan.

Definition at line 676 of file LiDARCloud.py.

◆ getScanPattern()

int pyhelios.LiDARCloud.LiDARCloud.getScanPattern	(		self,
		int	scanID )

Get the scan pattern for a scan.

   Returns an integer: 0 = raster (uniform angular grid), 1 = spinning multibeam
   (rotating multi-channel sensor), 2 = Risley-prism (Livox-style rosette). Compare against
   ``ScanPattern.RASTER`` / ``ScanPattern.SPINNING_MULTIBEAM`` / ``ScanPattern.RISLEY_PRISM``.

Definition at line 736 of file LiDARCloud.py.

◆ getScanPulseWidth()

float pyhelios.LiDARCloud.LiDARCloud.getScanPulseWidth	(		self,
		int	scanID )

Get the pulse width / range resolution (meters) of a scan (0 = use syntheticScan argument).

Definition at line 870 of file LiDARCloud.py.

◆ getScanRangeNoiseStdDev()

float pyhelios.LiDARCloud.LiDARCloud.getScanRangeNoiseStdDev	(		self,
		int	scanID )

Get the range (along-beam) measurement noise standard deviation for a scan (meters).

   Returns the value supplied to addScan() as ``range_noise_stddev`` (0.0 if disabled).

Definition at line 698 of file LiDARCloud.py.

◆ getScanReturnMode()

ReturnMode pyhelios.LiDARCloud.LiDARCloud.getScanReturnMode	(		self,
		int	scanID )

Get the return-reporting mode of a scan as a :class:ReturnMode (MULTI or SINGLE).

Definition at line 795 of file LiDARCloud.py.

◆ getScanRevolutions()

float pyhelios.LiDARCloud.LiDARCloud.getScanRevolutions	(		self,
		int	scanID )

Get the number of revolutions the sensor head made (spinning scans; 0 otherwise).

Definition at line 773 of file LiDARCloud.py.

◆ getScanRisleyPrisms()

List[RisleyPrism] pyhelios.LiDARCloud.LiDARCloud.getScanRisleyPrisms	(		self,
		int	scanID )

Get the rotating wedge prisms of a Risley-prism scan as a list of :class:RisleyPrism.

   Returns the prism stack in beam-traversal order (empty for non-Risley scans).

Definition at line 782 of file LiDARCloud.py.

◆ getScanRisleyRefractiveIndexAir()

float pyhelios.LiDARCloud.LiDARCloud.getScanRisleyRefractiveIndexAir	(		self,
		int	scanID )

Get the refractive index of the medium surrounding a Risley scan's prisms (1.0 for non-Risley).

Definition at line 789 of file LiDARCloud.py.

◆ getScanRotationRate()

float pyhelios.LiDARCloud.LiDARCloud.getScanRotationRate	(		self,
		int	scanID )

Get the sensor-head rotation rate in revolutions/second (spinning scans; 0 otherwise).

Definition at line 767 of file LiDARCloud.py.

◆ getScanSingleReturnSelection()

SingleReturnSelection pyhelios.LiDARCloud.LiDARCloud.getScanSingleReturnSelection	(		self,
		int	scanID )

Get the single/limited-return selection policy as a :class:SingleReturnSelection.

Definition at line 810 of file LiDARCloud.py.

◆ getScanSizePhi()

int pyhelios.LiDARCloud.LiDARCloud.getScanSizePhi	(		self,
		int	scanID )

Get number of azimuthal scan points for a scan.

Definition at line 689 of file LiDARCloud.py.

◆ getScanSizeTheta()

int pyhelios.LiDARCloud.LiDARCloud.getScanSizeTheta	(		self,
		int	scanID )

Get number of zenith scan points for a scan.

Definition at line 683 of file LiDARCloud.py.

◆ getScanStepsPerRev()

int pyhelios.LiDARCloud.LiDARCloud.getScanStepsPerRev	(		self,
		int	scanID )

Get the number of azimuth firing steps per revolution (spinning scans; 0 otherwise).

Definition at line 761 of file LiDARCloud.py.

◆ getScanTiltPitch()

float pyhelios.LiDARCloud.LiDARCloud.getScanTiltPitch	(		self,
		int	scanID )

Get the global scanner tilt pitch angle for a scan (radians; 0.0 if level).

Definition at line 719 of file LiDARCloud.py.

◆ getScanTiltRoll()

float pyhelios.LiDARCloud.LiDARCloud.getScanTiltRoll	(		self,
		int	scanID )

Get the global scanner tilt roll angle for a scan (radians; 0.0 if level).

Definition at line 713 of file LiDARCloud.py.

◆ getSyntheticScanMemoryBudget()

int pyhelios.LiDARCloud.LiDARCloud.getSyntheticScanMemoryBudget ( self )

Get the soft memory budget (bytes) for :meth:syntheticScan's transient buffers.

   Returns the explicitly configured budget set via :meth:`setSyntheticScanMemoryBudget`, or
   0 if using the automatic path-dependent default (8 GiB on a GPU build, 4 GiB otherwise).

Definition at line 866 of file LiDARCloud.py.

◆ getTriangleCount()

int pyhelios.LiDARCloud.LiDARCloud.getTriangleCount ( self )

Get number of triangles in the mesh.

Definition at line 1287 of file LiDARCloud.py.

◆ getTriangleVerticesAll()

pyhelios.LiDARCloud.LiDARCloud.getTriangleVerticesAll ( self )

Bulk-export every triangle's vertices and source scan in one call.

   Returns (xyz_flat, scan_ids): xyz_flat is a (T*9,) float32 array laid out
   [v0x,v0y,v0z, v1x,v1y,v1z, v2x,v2y,v2z] per triangle, scan_ids is a (T,)
   int32 array. Avoids the Context round-trip and the per-triangle
   getPrimitiveVertices loop.

Definition at line 1313 of file LiDARCloud.py.

◆ getTriangulationStats()

dict pyhelios.LiDARCloud.LiDARCloud.getTriangulationStats ( self )

Filter diagnostics from the most recent triangulateHitPoints() call.

   Returns a dict::

       {"candidates", "dropped_lmax", "dropped_aspect", "dropped_degenerate"}

   Each dropped triangle is attributed to one primary reason (Lmax, then
   aspect, then degenerate), so ``candidates == getTriangleCount() +
   dropped_lmax + dropped_aspect + dropped_degenerate``. All zero if
   triangulation has not been run. Use this to tell whether an empty or
   sparse mesh is data-limited (few candidates) or filter-limited (many
   candidates dropped by Lmax/aspect).

Definition at line 1303 of file LiDARCloud.py.

◆ hasMisses()

bool pyhelios.LiDARCloud.LiDARCloud.hasMisses ( self )

Return True if the cloud contains at least one miss.

   :meth:`calculateLeafArea` requires misses and fails fast without them.

Definition at line 1229 of file LiDARCloud.py.

◆ initializeCollisionDetection()

pyhelios.LiDARCloud.LiDARCloud.initializeCollisionDetection	(		self,
		Context	context )

Initialize CollisionDetection plugin for ray tracing.

   Required before performing synthetic scans.

Parameters

context Helios Context instance containing geometry

Definition at line 1943 of file LiDARCloud.py.

◆ is_available()

bool pyhelios.LiDARCloud.LiDARCloud.is_available ( self )

Check if LiDAR is available in current build.

Returns: True if plugin is available, False otherwise

Definition at line 2038 of file LiDARCloud.py.

◆ isGPUAccelerationEnabled()

bool pyhelios.LiDARCloud.LiDARCloud.isGPUAccelerationEnabled ( self )

Return True if GPU acceleration is currently enabled for collision-detection ray tracing.

Definition at line 1992 of file LiDARCloud.py.

◆ isGPUAvailable()

bool pyhelios.LiDARCloud.LiDARCloud.isGPUAvailable ( self )

Return True if a CUDA-capable GPU is available for collision-detection ray tracing.

   Reports capability (compiled with CUDA, a device present, and HELIOS_NO_GPU not set); use
   :meth:`isGPUAccelerationEnabled` to query whether GPU acceleration is currently toggled on.

Definition at line 1988 of file LiDARCloud.py.

◆ isHitMiss()

bool pyhelios.LiDARCloud.LiDARCloud.isHitMiss	(		self,
		int	index )

Return True if a hit is a "miss" (a fired pulse that returned nothing).

   Misses are the transmitted beams that form the denominator of the per-voxel
   transmission probability used by :meth:`calculateLeafArea`. They are produced by
   ``syntheticScan(..., record_misses=True)`` and by :meth:`gapfillMisses`.

Definition at line 1220 of file LiDARCloud.py.

◆ lastHitFilter()

pyhelios.LiDARCloud.LiDARCloud.lastHitFilter ( self )

Keep only last return hit points.

Definition at line 1367 of file LiDARCloud.py.

◆ loadXML()

pyhelios.LiDARCloud.LiDARCloud.loadXML	(		self,
		str	filename )

Load scan metadata from XML file.

Definition at line 1410 of file LiDARCloud.py.

◆ reflectanceFilter()

pyhelios.LiDARCloud.LiDARCloud.reflectanceFilter	(		self,
		float	minreflectance )

Filter hit points by minimum reflectance value.

Definition at line 1359 of file LiDARCloud.py.

◆ setCellGtheta()

pyhelios.LiDARCloud.LiDARCloud.setCellGtheta	(		self,
		float	Gtheta,
		int	index )

Set G(theta) value for a grid cell.

Definition at line 1661 of file LiDARCloud.py.

◆ setExternalTriangulation()

pyhelios.LiDARCloud.LiDARCloud.setExternalTriangulation	(	self,
		vertices,
		scan_ids )

Replace the internal triangulation with an externally-supplied mesh.

   Bypasses the internal Delaunay triangulation so a mesh produced elsewhere
   (a re-used Helios triangulation, or a per-scan open3d Ball-Pivot mesh) can
   drive leaf-area inversion without a recompute. After this call,
   ``calculateLeafArea()`` runs unchanged.

Parameters

vertices	Triangle vertices in world coordinates, accepted as a (T, 9) array laid out [v0x,v0y,v0z, v1x,v1y,v1z, v2x,v2y,v2z] per triangle, a (T, 3, 3) array, or a flat (T*9,) array – the same layout :meth:`getTriangleVerticesAll` exports, so a Helios mesh round-trips directly.
scan_ids	Source scan index for each triangle, shape (T,). Required; every entry must be a valid scan index (see :meth:`addScan`), since the leaf-angle G(theta) term needs each triangle's ray direction. A merged mesh with no scan association is not valid.

A grid must already be defined (see :meth:addGrid).

Definition at line 1337 of file LiDARCloud.py.

◆ setProgressCallback()

pyhelios.LiDARCloud.LiDARCloud.setProgressCallback	(		self,
			callback )

Register a progress callback fired with (progress_fraction, message) during :meth:syntheticScan.

   ``progress_fraction`` is a float in [0, 1]; ``message`` is a ``str`` describing the current
   phase. Pass ``None`` to clear the callback. The callback bridge is kept alive on this
   :class:`LiDARCloud` for as long as it is registered.

Definition at line 2014 of file LiDARCloud.py.

◆ setScanDetectionThreshold()

pyhelios.LiDARCloud.LiDARCloud.setScanDetectionThreshold	(		self,
		int	scanID,
		float	detection_threshold )

Set the detection threshold (energy fraction, noise floor) of a scan.

Definition at line 890 of file LiDARCloud.py.

◆ setScanMaxReturns()

pyhelios.LiDARCloud.LiDARCloud.setScanMaxReturns	(		self,
		int	scanID,
		int	max_returns )

Set the maximum returns per pulse used in single/limited-return mode (must be >= 1).

Definition at line 834 of file LiDARCloud.py.

◆ setScanPulseWidth()

pyhelios.LiDARCloud.LiDARCloud.setScanPulseWidth	(		self,
		int	scanID,
		float	pulse_width )

Set the pulse width / range resolution (meters) of a scan (0 = use syntheticScan argument).

Definition at line 876 of file LiDARCloud.py.

◆ setScanReturnMode()

pyhelios.LiDARCloud.LiDARCloud.setScanReturnMode	(		self,
		int	scanID,
		Union[ReturnMode, int]	return_mode )

Set the return-reporting mode of a scan (ReturnMode.MULTI or ReturnMode.SINGLE).

   Only affects analytic-waveform synthetic scans (more than one ray per pulse).

Definition at line 804 of file LiDARCloud.py.

◆ setScanSingleReturnSelection()

pyhelios.LiDARCloud.LiDARCloud.setScanSingleReturnSelection	(		self,
		int	scanID,
		Union[SingleReturnSelection, int]	selection )

Set the single/limited-return selection policy (STRONGEST, FIRST, LAST, or STRONGEST_PLUS_LAST).

   Used when the scan's return mode is SINGLE and a pulse resolves more returns than maxReturns.
   STRONGEST_PLUS_LAST is a dual-return mode that intrinsically yields 1 or 2 returns and
   ignores maxReturns.

Definition at line 822 of file LiDARCloud.py.

◆ setSyntheticScanMemoryBudget()

pyhelios.LiDARCloud.LiDARCloud.setSyntheticScanMemoryBudget	(		self,
		int	bytes )

Set the soft memory budget (bytes) for :meth:syntheticScan's transient buffers.

   :meth:`syntheticScan` fans each pulse into ``rays_per_pulse`` sub-rays; for a
   large scan the simultaneously-traced sub-rays can demand many gigabytes if
   traced in one batch. This caps the live trace scratch buffers, so the per-scan
   beam fan-out is processed in chunks sized to stay near this budget regardless of
   scan resolution. It bounds only the transient buffers, not the output cloud.

   If never called, the budget is automatic and path-dependent (8 GiB on a GPU
   build, 4 GiB otherwise). Call this to override that with a fixed cap, typically
   to lower peak memory on a constrained host.

Parameters

bytes Soft cap in bytes on the live ray-tracing scratch buffers. Must be > 0.

Definition at line 856 of file LiDARCloud.py.

◆ setSyntheticScanProgressPointer()

pyhelios.LiDARCloud.LiDARCloud.setSyntheticScanProgressPointer	(		self,
			ptr )

Register an external per-scan progress counter polled during :meth:syntheticScan.

   ``ptr`` is a ``ctypes.c_int`` into which syntheticScan writes the 0-based index of the scan
   currently being ray-traced (set to :meth:`getScanCount` when the batch finishes), letting a
   host thread poll progress while the blocking scan runs. The counter is owned by the caller and
   must outlive the scan. Pass ``None`` to clear.

Definition at line 2002 of file LiDARCloud.py.

◆ syntheticScan()

pyhelios.LiDARCloud.LiDARCloud.syntheticScan	(		self,
		Context	context,
		Optional[int]	rays_per_pulse = None,
		Optional[float]	pulse_distance_threshold = None,
		bool	scan_grid_only = False,
		bool	record_misses = True,
		bool	append = False,
		Optional[Union[ReturnMode, int]]	return_mode = None,
			cancel_flag = None )

Perform synthetic LiDAR scan of geometry in Context.

   Requires scan metadata to be defined first via addScan() or loadXML().
   Uses ray tracing to simulate LiDAR instrument measurements.

Parameters

context	Helios Context containing geometry to scan
rays_per_pulse	Number of rays per pulse (None=discrete-return, typical: 100)
pulse_distance_threshold	Distance threshold for aggregating hits (meters, required for waveform)
scan_grid_only	If True, only scan within defined grid cells
record_misses	If True, record miss/sky points where rays don't hit geometry
append	If True, append to existing hits; if False, clear existing hits
return_mode	Optional :class:`ReturnMode` (MULTI or SINGLE) for analytic-waveform scans. Overrides each scan's stored return mode for this call only. Only valid when rays_per_pulse is set (waveform mode); raises ValueError otherwise. In SINGLE mode up to each scan's getScanMaxReturns() returns per pulse are reported, selected by the scan's single-return selection policy.

Example (Discrete-return): >>> from pyhelios import Context, LiDARCloud >>> from pyhelios.types import vec3 >>> with Context() as context: ... # Add geometry ... context.addPatch(center=vec3(0, 0, 0.5), size=vec2(1, 1))

Parameters

...	... with LiDARCloud() as lidar: ... # Define scan parameters ... scan_id = lidar.addScan( ... origin=vec3(0, 0, 2), ... Ntheta=100, theta_range=(0, 1.57), ... Nphi=100, phi_range=(0, 6.28), ... exit_diameter=0, beam_divergence=0 ... )
...	... # Perform discrete-return scan ... lidar.syntheticScan(context)

Example (Full-waveform): >>> lidar.syntheticScan( ... context, ... rays_per_pulse=100, ... pulse_distance_threshold=0.02, ... record_misses=True ... )

Definition at line 1725 of file LiDARCloud.py.

◆ triangulateHitPoints()

pyhelios.LiDARCloud.LiDARCloud.triangulateHitPoints	(		self,
		float	Lmax,
		float	max_aspect_ratio = 4.0 )

Generate triangle mesh from hit points using Delaunay triangulation.

Parameters

Lmax	Maximum triangle edge length
max_aspect_ratio	Maximum triangle aspect ratio (default 4.0)

Definition at line 1281 of file LiDARCloud.py.

Member Data Documentation

◆ _cd_context

pyhelios.LiDARCloud.LiDARCloud._cd_context = context

protected

Definition at line 1962 of file LiDARCloud.py.

◆ _cloud_ptr

pyhelios.LiDARCloud.LiDARCloud._cloud_ptr = lidar_wrapper.createLiDARcloud()

protected

Definition at line 174 of file LiDARCloud.py.

◆ _progress_callback_ref

pyhelios.LiDARCloud.LiDARCloud._progress_callback_ref = None

protected

Definition at line 180 of file LiDARCloud.py.

The documentation for this class was generated from the following file:

pyhelios/LiDARCloud.py

Detailed Description

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

◆ __init__()

◆ __del__()

Member Function Documentation

◆ __enter__()

◆ __exit__()

◆ _check_cd_context_alive()

◆ _dispatch_synthetic_scan()

◆ _validate_trajectory()

◆ addGrid()

◆ addGridCell()

◆ addHitPoint()

◆ addHitPoints()

◆ addHitPointsWithData()

◆ addScan()

◆ addScanMoving()

◆ addScanMovingRaster()

◆ addScanRisley()

◆ addScanSpinning()

◆ addTrianglesToContext()

◆ calculateHitGridCell()

◆ calculateLeafArea()

◆ calculateSyntheticGtheta()

◆ calculateSyntheticLeafArea()

◆ coordinateRotation()

◆ coordinateShift()

◆ deleteHitPoint()

◆ disableCDGPUAcceleration()

◆ disableMessages()

◆ distanceFilter()

◆ doesHitDataExist()

◆ enableCDGPUAcceleration()

◆ enableMessages()

◆ exportGtheta()

◆ exportLeafAreaDensities()

◆ exportLeafAreas()

◆ exportLeafAreaUncertainty()

◆ exportPointCloud()

◆ exportScans()

◆ exportTriangleAreas()

◆ exportTriangleNormals()

◆ firstHitFilter()

◆ gapfillMisses()

◆ getCellBeamCount()

◆ getCellCenter()

◆ getCellGtheta()

◆ getCellLADVariance()

◆ getCellLeafArea()

◆ getCellLeafAreaConfidenceInterval()

◆ getCellLeafAreaDensity()

◆ getCellMeanPathLength()

◆ getCellRelativeDensityIndex()

◆ getCellRotation()

◆ getCellSize()

◆ getGridCellCount()

◆ getGroupLADConfidenceInterval()

◆ getHitColor()

◆ getHitCount()

◆ getHitData()

◆ getHitDataAll()

◆ getHitDataArray()

◆ getHitDataColumn()

◆ getHitDataColumnArray()

◆ getHitDataColumnIndex()

◆ getHitMissArray()

◆ getHitOrigin()

◆ getHitRaydir()

◆ getHitScanID()

◆ getHitScanIDArray()

◆ getHitsXYZRGB()

◆ getHitsXYZRGBArrays()

◆ getHitXYZ()

◆ getMissDistance()

◆ getScanAngleNoiseStdDev()

◆ init()

◆ del()

◆ enter()

◆ exit()