differt.scene.HybridPathTracer

class HybridPathTracer(num_rays=1000000, epsilon=None, hit_tol=None, min_len=None, smoothing_factor=None, confidence_threshold=0.5, batch_size=512, chunk_size=None)

Bases: AbstractPathTracer

Hybrid path tracer, combining ray launching for visibility and exhaustive tracing.

Uses ray launching to estimate object visibility, then performs exhaustive search on the reduced candidate set. This is a faster alternative to exhaustive search, but still grows exponentially with the number of bounces or the size of the scene.

Warning

This method is best used for a single transmitter and a single receiver, as the estimated visibility is merged across all transmitters and receivers, respectively.

Attributes

batch_size	Intersection check batch size.
chunk_size	If specified, iterates through chunks of path candidates, yielding an iterator over path chunks.
confidence_threshold	Confidence threshold for valid paths.
epsilon	Tolerance for checking ray / object intersections.
hit_tol	Tolerance for blockage checks.
min_len	Minimal (squared) length that each path segment must have for a path to be valid.
num_rays	The number of rays launched.
smoothing_factor	Parameters for slope of the smoothing function.

Methods

generate_path_candidates(scene, order[, ...])	Return a tuple of (path_candidates, interaction_types).
generate_path_candidates_chunks_iter(scene, ...)	Override to support native chunked generation from the graph.
trace_path_candidates(scene, ...)	Core logic to trace the exact paths from the proposed candidates.
trace_paths(scene, order[, chunk_size, ...])	Trace paths for the given scene and order(s).

Detailed documentation

batch_size: int | None = 512

Intersection check batch size.

chunk_size: int | None = None

If specified, iterates through chunks of path candidates, yielding an iterator over path chunks.

confidence_threshold: Float[ArrayLike, ''] = 0.5

Confidence threshold for valid paths.

epsilon: Float[ArrayLike, ''] | None = None

Tolerance for checking ray / object intersections.

generate_path_candidates(scene, order, specular_reflection=True, diffuse_scattering=False)

Return a tuple of (path_candidates, interaction_types).

path_candidates contains triangle indices. interaction_types classifies the bounce (e.g., 0 for specular). A value of -1 in either array indicates an “inactive” interaction or padded bounce (used when combining paths of different reflection orders).

Parameters:

• scene (TriangleScene) – The scene.

• order (int | Sequence[int]) – The path order (number of bounces), or a sequence of orders to combine.

• specular_reflection (bool) – Whether to include specular reflections.

• diffuse_scattering (bool) – Whether to include diffuse scattering (not yet implemented).

Return type:

tuple[Int[Array, 'num_candidates order'], Int[Array, 'num_candidates order']]

Returns:

A 2-tuple of (path_candidates, interaction_types).

generate_path_candidates_chunks_iter(scene, order, *args, chunk_size=None, pad_chunks=False, **kwargs)

Override to support native chunked generation from the graph.

Return type:

SizedIterator[tuple[ chunk_size order'], chunk_size order']]]

Returns:

An iterator over path candidates chunks.

hit_tol: Float[ArrayLike, ''] | None = None

Tolerance for blockage checks.

min_len: Float[ArrayLike, ''] | None = None

Minimal (squared) length that each path segment must have for a path to be valid.

num_rays: int = 1000000

The number of rays launched.

smoothing_factor: Float[ArrayLike, ''] | None = None

Parameters for slope of the smoothing function.

trace_path_candidates(scene, path_candidates, interaction_types)

Core logic to trace the exact paths from the proposed candidates.

Parameters:

• scene (TriangleScene) – The scene.

• path_candidates (Int[Array, 'num_candidates order']) – Triangle indices for each candidate.

• interaction_types (Int[Array, 'num_candidates order']) – Interaction type for each bounce.

Return type:

TracedPaths

Returns:

The traced paths.

trace_paths(scene, order, chunk_size=None, pad_chunks=False)

Trace paths for the given scene and order(s).

If chunk_size is provided, returns an iterator of TracedPaths (one per chunk); otherwise returns a single TracedPaths.

Parameters:

• scene (TriangleScene) – The scene.

• order (int | Sequence[int]) – The path order(s).

• chunk_size (int | None) – If not None, iterate through chunks of this size.

• pad_chunks (bool) – If True and chunk_size is set, pad the last chunk.

Return type:

TracedPaths | Iterator[TracedPaths]

Returns:

Traced paths, or an iterator thereof.