Tree — leaves 

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

Function(): Constructor for any empty function.

Function(const std::function<double(double x, double y, double z, double rho, double phic, double r, double theta, double phis)> &function, glm::vec3 min = glm::vec3(-10.0), glm::vec3 max = glm::vec3(10.0))

Constructs a Function node using a native C++ std::function callback.

Parameters:

function – The callback returning the scalar distance field value.
min – The minimum bounds of the geometry function.
max – The maximum bounds of the geometry function.

Function(const std::string &function, glm::vec3 min = glm::vec3(-10.0), glm::vec3 max = glm::vec3(10.0))

Constructor for string-based mathematical expressions.

Parameters:

function – The mathematical string expression to evaluate.
min – The minimum bounds of the geometry function.
max – The maximum bounds of the geometry function.

virtual void prepare(const glm::vec3 &voxel_size, double bandwidth) final: Validates & compiles the function, prepares parser.

Private Functions

virtual void prepare_bounding_box() override

void prepare_expression()

Private Members

std::shared_ptr<ExpressionEvaluator> m_evaluator

std::function<double(double x, double y, double z, double rho, double phic, double r, double theta, double phis)> m_function

double m_phic

double m_phis

bool m_prepared = false

double m_r

double m_rho

std::string m_string_function: The function to evaluate as a string.

double m_theta

bool m_use_string_evaluator = true

double m_x: The variables for each thread.

double m_y

double m_z

class Mesh : public Leaf 

#include <mesh.h>

A mesh geometry primitive/ leaf node.

The mesh is loaded from a file and converted into a signed distance field using OpenVDB.

Mesh files are loaded into triangles/ vertices using the Assimp library. Then, the triangles are converted into a signed distance field using OpenVDB. When querried though the evaluate() function, the distance to the mesh is returned. The material() function returns the material of the mesh as supplied. The OpenVDB grid used here differs from the one used in the Voxel class. The Voxel class uses a grid of material values, while the Mesh class uses a grid of signed distance values.

Note

The Mesh class is only available if the Assimp and OpenVDB libraries are available.

Note

This node can be evaluated in O(1) time.

Public Functions

virtual std::shared_ptr<Node> clone() final

See also

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

openvdb::FloatGrid::Ptr getGrid()

Returns the raw OpenVDB signed distance grid.

Returns:: The raw OpenVDB grid

Mesh() = default

Mesh(const std::string &path, bool center = false, bool disable_validation = false)

Constructor.

Parameters:

path – The path to the mesh file to load
center – If true, the mesh will be centered at the origin after loading
disable_validation – If true, the mesh will not be validated for errors. This is useful for meshes where we know its ok if the mesh is not watertight or has self-intersections.

Mesh(const std::string &path, const glm::vec3 &sample_size, bool center = false, bool disable_validation = false)

Mesh(const std::string &path, double override_voxel_size, bool disable_validation = false)

Constructor.

Parameters:

path – The path to the mesh file to load
override_voxel_size – The explicit voxel size to use when voxelizing the mesh into an SDF, bypassing the minimum bound heuristic
disable_validation – If true, the mesh will not be validated for errors

Mesh(double sdf_shim, std::string path)

Mesh(std::shared_ptr<SurfaceMesh> mesh)

Constructor.

Parameters:: mesh – The mesh to load

virtual void prepare(const glm::vec3 &voxel_size, double bandwidth) final: Loads the mesh from file into signed distance field once before evaluation.

Private Types

typedef openvdb::FloatGrid GridType: The type of grid used by OpenVDB.

Private Functions

void load_from_file(bool center = false, bool disable_validation = false)

Loads the mesh from file into memory.

Parameters:

center – If true, the mesh will be centered at the origin after loading
disable_validation – If true, the mesh will not be validated for errors

virtual void prepare_bounding_box() override

Private Members

std::shared_ptr<GridType::Accessor> m_accessor: The accessor for the grid.

std::string m_file_path: The path to the mesh file to load.

GridType::Ptr m_grid: The OpenVDB grid used to store the signed distance field.

bool m_is_loaded = false: Whether the mesh has been loaded into the signed distance field grid.

std::shared_ptr<SurfaceMesh> m_mesh

double m_override_voxel_size = 0.0: The explicit voxel size to use when voxelizing the mesh, bypassing the minimum bound heuristic.

glm::vec3 m_sample_size = glm::vec3(std::numeric_limits<float>::infinity())

openvdb::tools::GridSampler<GridType, openvdb::tools::BoxSampler>::Ptr m_sampler

double m_sdf_shim = 0.0

bool m_use_override_voxel_size = false: If true, use m_override_voxel_size instead of the heuristic minimum bound in prepare().

glm::vec3 m_voxel_size: The size of each voxel in the grid. This resolution does not need to match what you sample, and can be asymmetric.

class RectPrism : public Leaf 

#include <rect_prism.h>

A rectangular prism leaf node/ geometric primitive.

This node is a rectangular prism with a center point, size, and material id. The size is the side lengths in X, Y, and Z. The material id is the index of the material in the material list. The evaluate() and material() functions are compared against an equation.

Note

This node can be evaluated in O(1) time.

Note

This node is a leaf node, and therefore cannot have any children.

Public Functions

virtual std::shared_ptr<Node> clone() final

See also

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

Note

This node breaks the convention of returning the distance to the surface. Instead, it 1.0 if the point is outside the RectPrism, and 0.0 if the point is inside the RectPrism.

virtual void prepare_bounding_box() override: Prepares the bounding box for the rectangular prism.

RectPrism(): Default constructor. Creates a RectPrism with a center of (0, 0, 0), size of (1, 1, 1), and material id of 1.

RectPrism(glm::vec3 center, glm::vec3 size)

Constructor.

Creates a RectPrism with a center, size, and material id.

Parameters:

center – The center point of the RectPrism.
size – The side length of the RectPrism.
material – The material id of the RectPrism.

Public Static Functions

static std::shared_ptr<RectPrism> FromMinAndMax(glm::vec3 min, glm::vec3 max)

Factory method to create a rectangular prism from min and max points.

Parameters:

min – The minimum corner of the prism.
max – The maximum corner of the prism.

Returns:

A shared pointer to the newly created RectPrism.

Private Members

glm::vec3 m_center: The center point of the RectPrism.

glm::vec3 m_size: The side length of the RectPrism.

class Sphere : public Leaf 

#include <sphere.h>

A sphere leaf node/ geometric primitive.

This node is a sphere with a center point, radius, and material id. The material id is the index of the material in the material list. The evaluate() and material() functions are compared against an equation.

Note

This node can be evaluated in O(1) time.

Note

This node is a leaf node, and therefore cannot have any children.

Public Functions

virtual std::shared_ptr<Node> clone() final

See also

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

Sphere(): Default constructor. Creates a Sphere with a center of (0, 0, 0), radius of 1.

Sphere(double x, double y, double z, double radius)

Sphere(glm::vec3 center, double radius)

Constructor.

Creates a Sphere with a center and radius

Parameters:

center – The center point of the Sphere.
radius – The radius of the Sphere.

Private Functions

virtual void prepare_bounding_box() override

See also

Private Members

double m_radius: The radius of the Sphere.

double m_x: The center point x of the Sphere.

double m_y: The center point y of the Sphere.

double m_z: The center point z of the Sphere.

class Strut : public Leaf 

#include <strut.h>

A leaf node that represents a strut.

Public Functions

virtual std::shared_ptr<Node> clone() final

See also

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

Strut(glm::vec3 start, glm::vec3 end, double radius)

Constructor.

Parameters:

start – The start of the strut.
end – The end of the strut.
radius – The radius of the strut.
material – The material of the strut.

Private Functions

virtual void prepare_bounding_box() override

Private Members

glm::vec3 m_end: The end of the strut.

double m_radius: The radius of the strut.

glm::vec3 m_start: The start of the strut.

class CAD : public Leaf 

#include <cad.h>

A CAD geometry primitive/ leaf node.

The CAD is loaded from a file into memory for sampling.

Note

The node supports .STEP and .igs files.

Public Functions

CAD() = default

CAD(const std::string &path, bool use_fast_mode = true)

Constructor.

Parameters:

path – The path to the CAD file to load
material – The material of the CAD

virtual std::shared_ptr<Node> clone() override

See also

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

virtual void prepare(const glm::vec3 &voxel_size, double bandwidth) final

Prepares the CAD node by loading it from disk and building the internal bounding volume hierarchy.

Parameters:

voxel_size – The size of the voxels
bandwidth – The bandwidth of the tree

Private Functions

void load(double interior_bandwidth, double exterior_bandwidth): Loads the CAD from disk to memory.

virtual void prepare_bounding_box() override: Prepares the bounding box of the CAD.

Private Members

std::shared_ptr<CADPart> m_cad_part

std::string m_file_path

bool m_is_loaded = false

bool m_use_fast_mode = true

glm::vec3 m_voxel_size

class Cylinder : public Leaf 

#include <cylinder.h>

A cylinder leaf node/ geometric primitive.

This node is a cylinder with a center point, radius, height, and material id. The cylinder is aligned along the Z-axis, standing upright, and centered at (0,0,0). The evaluate() function returns the signed distance to the surface.

Note

This node can be evaluated in O(1) time.

Note

This node is a leaf node, and therefore cannot have any children.

Public Functions

virtual std::shared_ptr<Node> clone() override

See also

Cylinder(): Default constructor. Creates a Cylinder with a center of (0,0,0), radius of 1, height of 1, and material id of 1.

Cylinder(glm::vec3 center, double radius, double height)

Constructor.

Creates a Cylinder with a center, radius, height, and material id.

Parameters:

center – The center point of the Cylinder.
radius – The radius of the Cylinder.
height – The height of the Cylinder.
material – The material id of the Cylinder.

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

Private Functions

virtual void prepare_bounding_box() override

Private Members

glm::vec3 m_center: The center point of the Cylinder.

double m_half_height

double m_height: The height of the Cylinder.

double m_radius: The radius of the Cylinder.

class Cone : public Leaf 

#include <cone.h>

A cone leaf node/ geometric primitive.

Public Functions

virtual std::shared_ptr<Node> clone() final

See also

Cone() = default: Default constructor.

Cone(double angle, double height)

Constructor.

Creates a Cone with an angle and height.

Parameters:

angle – The aperture half-angle in radians.
height – The height of the cone.

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

Private Functions

virtual void prepare_bounding_box() override

See also

Private Members

double m_angle = 0.5

double m_height = 1.0

class Torus : public Leaf 

#include <torus.h>

A torus leaf node/ geometric primitive.

This node is a torus with a major and minor radius. See this for more information: https://wiki.povray.org/uploaded/2/29/RefImgMimxrtor.gif The major radius is the distance from the center of the torus to the center of the tube. The minor radius is the radius of the tube.

Public Functions

virtual std::shared_ptr<Node> clone() final

See also

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

Torus() = default: Default constructor.

Torus(double r1, double r2)

Constructor.

Creates a Torus with a major and minor radius.

Parameters:

r1 – The major radius.
r2 – The minor radius.

Private Functions

virtual void prepare_bounding_box() override

See also

Private Members

double m_r1 = 2

double m_r2 = 1

class GraphLattice : public Leaf 

#include <graph_lattice.h>

A leaf node representing a lattice structure constructed from a list of edges.

Struts are created for each edge and grouped into an internal bounding volume hierarchy.

Public Types

enum class LatticeType

Values:

enumerator BodyCenteredCubic

enumerator FaceCenteredCubic

enumerator Cubic

enumerator KelvinCell

Public Functions

virtual std::shared_ptr<Node> clone() final

See also

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

GraphLattice(const std::vector<std::pair<glm::vec3, glm::vec3>> &edges, double radius)

GraphLattice(LatticeType type, glm::vec3 size, double radius)

virtual void prepare(const glm::vec3 &voxel_size, double bandwidth) final

See also

Node::prepare()

Public Static Functions

static std::vector<std::pair<glm::vec3, glm::vec3>> BCC_GenerateEdges(glm::vec3 size)

Generates edge definitions for a Body Centered Cubic (BCC) lattice unit cell.

Parameters:: size – The dimensions of the unit cell in X, Y, and Z.
Returns:: A list of start and end point pairs defining the struts.

static std::vector<std::pair<glm::vec3, glm::vec3>> Cubic_GenerateEdges(glm::vec3 size)

Generates edge definitions for a simple Cubic lattice unit cell.

Parameters:: size – The dimensions of the unit cell in X, Y, and Z.
Returns:: A list of start and end point pairs defining the struts.

static std::vector<std::pair<glm::vec3, glm::vec3>> FCC_GenerateEdges(glm::vec3 size)

Generates edge definitions for a Face Centered Cubic (FCC) lattice unit cell.

Parameters:: size – The dimensions of the unit cell in X, Y, and Z.
Returns:: A list of start and end point pairs defining the struts.

static std::vector<std::pair<glm::vec3, glm::vec3>> KelvinCell_GenerateEdges(glm::vec3 size)

Generates edge definitions for a Kelvin Cell lattice unit cell.

Parameters:: size – The dimensions of the unit cell in X, Y, and Z.
Returns:: A list of start and end point pairs defining the struts.

Private Functions

void build_lattice()

virtual void prepare_bounding_box() override

Private Members

std::vector<std::pair<glm::vec3, glm::vec3>> m_edges

double m_radius

std::shared_ptr<Node> m_root

class Text : public Leaf 

#include <text.h>

A text leaf node which generates a 3D text object by extruding the text along the Z-axis.

Generates a 3D text object from a given string by creating a planar CAD outline and extruding it.

Note

Uses a default font (Arial). The CAD part is built during initialization.

Public Types

enum class FontAspect

Values:

enumerator Regular

enumerator Bold

enumerator Italic

enumerator BoldItalic

enum class HorizontalAlignment

Horizontal text alignment options.

Values:

enumerator Left: Text is aligned to the left of the anchor point.

enumerator Center: Text is centered horizontally at the anchor point.

enumerator Right: Text is aligned to the right of the anchor point.

enum class VerticalAlignment

Vertical text alignment options.

Values:

enumerator Bottom: The anchor lies on the last line of the text.

enumerator Center: The anchor lies on the center of the text.

enumerator Top: The anchor lies on the line preceding the first line of the text.

enumerator TopFirstLine: The anchor lies on the first line of the text.

Public Functions

virtual std::shared_ptr<Node> clone() override

See also

virtual std::optional<double> evaluate(double x, double y, double z) override

See also

Node::prepare_bounding_box

virtual void prepare(const glm::vec3 &voxel_size, double bandwidth) override

See also

Node::prepare()

Text() = default: Default constructor.

Text(std::string text, double height, double depth, FontAspect aspect = FontAspect::Regular, std::string font = "Consolas", HorizontalAlignment h_align = HorizontalAlignment::Center, VerticalAlignment v_align = VerticalAlignment::Center)

Constructor.

Creates a Text node with a given text, height, depth, and material id.

Parameters:

text – The text content used for generating the 3D object.
height – The height of the text.
depth – The extrusion depth of the text.
material – The material id of the text node (default is 1).
h_align – The horizontal alignment of the text (default is Left).
v_align – The vertical alignment of the text (default is Bottom).

Private Functions

void make_text_cad_part(const std::string &text, double height, double depth)

Builds the CAD part for the text node.

Parameters:

text – The text string.
height – The height of the text.
depth – The extrusion depth.

virtual void prepare_bounding_box() override

Private Members

FontAspect m_aspect

std::shared_ptr<CADPart> m_cad_part = nullptr

double m_depth

std::string m_font = "Consolas"

HorizontalAlignment m_h_align = HorizontalAlignment::Left 

double m_height

std::string m_string

VerticalAlignment m_v_align = VerticalAlignment::Bottom 

class SignedDistanceField : public Leaf 

#include <signed_distance_field.h>

Represents a signed distance field using OpenVDB.

This is

Public Functions

virtual std::shared_ptr<Node> clone() override

See also

Node::clone

virtual std::optional<double> evaluate(double x, double y, double z) override

See also

Node::evaluate

virtual void prepare(const glm::vec3 &voxel_size, double bandwidth) override

See also

Node::prepare

virtual void prepare_bounding_box() override

See also

void save_openvdb_grid(const std::string &file_path) const

Saves the underlying OpenVDB grid to a VDB file.

Parameters:: file_path – The path where the VDB file will be saved.

SignedDistanceField()

Create an empty SignedDistanceField.

This constructor initializes an empty SignedDistanceField.

SignedDistanceField(const openvdb::BoolGrid::Ptr &occupancy_grid)

Create a SignedDistanceField from an occupancy grid.

This constructor computes the signed distance field from a given occupancy grid. The occupancy grid is expected to be a BoolGrid where occupied voxels are set to true.

Parameters:: occupancy_grid – The occupancy grid from which to compute the signed distance field

SignedDistanceField(const openvdb::FloatGrid::Ptr &grid)

Create an SignedDistanceField from an OpenVDB FloatGrid.

This constructor initializes the SignedDistanceField with an existing OpenVDB FloatGrid. The FloatGrid is expected to represent a signed distance field where positive values indicate distances to the surface and negative values indicate distances inside the surface. Zero values indicate the surface itself.

Parameters:

grid – The OpenVDB FloatGrid to use as the signed distance field
material – The material of the SDF, default is 1

SignedDistanceField(const std::shared_ptr<FloatVDBVolume> &sdf_volume)

SignedDistanceField(const std::string &vdb_file_path, const std::string &grid_name = "occupancy")

Create a SignedDistanceField from a VDB file.

This constructor loads a signed distance field from a specified VDB file path. The VDB file is expected to contain either a BooleanGrid representing an occupancy grid or a FloatGrid representing the signed distance field. We auto-detect the grid type based the type of grid stored in the file. If the grid is a BooleanGrid, it will be converted to a signed distance field. If it’s already a FloatGrid, it will be used directly as the signed distance field. The grid name can be specified, and it defaults to “occupancy”.

Parameters:

vdb_file_path – The file path to the VDB file containing the grid
grid_name – The name of the grid to load from the VDB file, default is “occupancy”

Private Types

typedef openvdb::FloatGrid GridType

Private Functions

void init_from_bool_grid(const openvdb::BoolGrid::Ptr &occupancy_grid)

Initialize the grid from a BoolGrid (occupancy grid).

Converts the BoolGrid to a level set SDF and stores in m_grid.

Parameters:: occupancy_grid – The BoolGrid representing occupied voxels

void init_from_float_grid(const openvdb::FloatGrid::Ptr &grid)

Initialize the grid from a FloatGrid.

Sets m_grid from the provided FloatGrid, marks it as a level set, and names it “surface”.

Parameters:: grid – The FloatGrid to use as the signed distance field

void load_from_vdb_file(const std::string &vdb_file_path, const std::string &grid_name)

Load a grid from a VDB file and initialize appropriately.

Opens the VDB file, finds the named grid, determines if it’s a FloatGrid or BoolGrid, and calls the appropriate init function.

Parameters:

vdb_file_path – Path to the VDB file
grid_name – Name of the grid to load from the file

Private Members

std::shared_ptr<GridType::Accessor> m_accessor

openvdb::FloatGrid::Ptr m_grid

openvdb::tools::GridSampler<GridType, openvdb::tools::BoxSampler>::Ptr m_sampler

class PolygonExtrude : public Leaf 

#include <polygon_extrude.h>

An extruded polygon leaf node / geometric primitive.

This node takes a planar polygon defined by a series of 3D points and extrudes it along its computed normal (right-hand rule) by a given height. The polygon must be planar; the constructor validates this and throws if the points are not coplanar. The extrusion can be symmetric (half the height on each side of the polygon plane) or one-directional (full height in the normal direction). A negative height extrudes in the opposite direction of the normal.

Note

This node can be evaluated in O(n) time where n is the number of polygon vertices.

Note

This node is a leaf node, and therefore cannot have any children.

Public Functions

virtual std::shared_ptr<Node> clone() override

See also

virtual std::optional<double> evaluate(double x, double y, double z) final

See also

PolygonExtrude(): Default constructor. Creates a unit square in the XY plane, extruded 1 unit in +Z.

PolygonExtrude(const std::vector<glm::vec3> &vertices, double height, bool symmetric = false)

Constructor.

Creates an extruded polygon from a list of coplanar 3D vertices.

Parameters:

vertices – The vertices of the planar polygon (minimum 3, must be coplanar).
height – The extrusion distance along the polygon normal.
symmetric – If true, extrudes height/2 on each side of the polygon plane.

Throws:

std::runtime_error – if fewer than 3 vertices, points are collinear, or not coplanar.

virtual void prepare_bounding_box() override

See also