### Install pySplashsurf

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/README.md

Install the pySplashsurf package using pip. For meshio support, use the optional dependency.

```bash
pip install pysplashsurf
```

```bash
pip install pysplashsurf[meshio]
```

--------------------------------

### Reconstruct Surface from VTK using CLI

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/README.md

Example of using the pySplashsurf CLI to reconstruct a surface from a VTK particle file with specified smoothing and normal computation parameters.

```bash
pysplashsurf reconstruct particles.vtk -r=0.025 -l=2.0 -c=0.5 -t=0.6 --mesh-smoothing-weights=on --mesh-smoothing-iters=15 --normals=on --normals-smoothing-iters=10
```

--------------------------------

### Install SplashSurf via Cargo

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Installs the SplashSurf command-line tool using Cargo, the Rust package manager. Requires a Rust toolchain to be installed.

```bash
cargo install splashsurf
```

--------------------------------

### Install SplashSurf Python Bindings via Pip

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/splashsurf/README.md

Install the Python bindings for SplashSurf using pip. Refer to the Python bindings' README for more details.

```bash
pip install pysplashsurf
```

--------------------------------

### Reconstruct Surface using Python Library

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/README.md

Example of using the pySplashsurf library in a Python script to load particle data, reconstruct a surface with post-processing, and write the resulting mesh to a file.

```python
import meshio
import numpy as np
import pysplashsurf

# Load particles from mesh file
mesh = meshio.read("input.vtk")
particles = np.array(mesh.points, dtype=np.float64)

# Reconstruct the points/particles with some post-processing
mesh_with_data, reconstruction = pysplashsurf.reconstruction_pipeline(
    particles,
    particle_radius=0.025,
    rest_density=1000.0,
    smoothing_length=2.0,
    cube_size=0.5,
    iso_surface_threshold=0.6,
    mesh_smoothing_weights=True,
    mesh_smoothing_weights_normalization=13.0,
    mesh_smoothing_iters=25,
    normals_smoothing_iters=10,
    mesh_cleanup=True,
    compute_normals=True,
    subdomain_grid=True,
    subdomain_num_cubes_per_dim=64,
    output_mesh_smoothing_weights=True
)

# Write the mesh with attributes to file using meshio
mesh_with_data.write_to_file("surface.vtk")
```

--------------------------------

### Benchmark Reconstruction with Large Particle Count

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Example invocation for reconstructing a large particle dataset, demonstrating fast processing times on modern hardware. Includes typical parameters for particle radius, smoothing length, surface threshold, and cube size.

```bash
splashsurf reconstruct canyon_13353401_particles.xyz -r=0.011 -c=1.5 -l=2.0 -t=0.6
```

--------------------------------

### Build Splashsurf Extension

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/splashsurf_studio/README.md

Command to package the Splashsurf extension for the Blender extension repository. Use the --split-platforms flag to reduce size for individual platforms.

```bash
blender --command extension build
```

```bash
blender --command extension build --source-dir src --split-platforms
```

```bash
/Applications/Blender.app/Contents/MacOS/Blender --command extension build --source-dir src --split-platforms
```

--------------------------------

### Show pySplashsurf CLI Help

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/README.md

Display the help message for the pySplashsurf command-line interface to understand available commands and options.

```bash
pysplashsurf --help
```

--------------------------------

### Build pySplashsurf from Source

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/README.md

Instructions for building the pySplashsurf package from source code using conda and maturin.

```bash
conda env create --prefix ./env -f python_environment.yaml
conda activate ./env
maturin develop
```

--------------------------------

### Load VTK Legacy File

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Loads legacy VTK files (.vtk) as big endian binary. Requires an Unstructured Grid with f32 or f64 vertex coordinates. Other data is ignored unless specified with --interpolate-attributes.

```rust
use splashsurf::io::vtkio;

let mesh = vtkio::load("mesh.vtk")?;
```

--------------------------------

### Apply Weighted Surface Smoothing

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Use these flags to enable and configure weighted smoothing for surface reconstruction. Adjust iterations for balance between detail and smoothness. Cleanup options prevent artifacts.

```bash
splashsurf reconstruct particles.vtk -r=0.025 -l=2.0 -c=0.5 -t=0.6 --mesh-smoothing-weights=on --mesh-smoothing-iters=15 --normals=on --normals-smoothing-iters=10
```

--------------------------------

### Load BGEO File

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Loads BGEO files (.bgeo) using a custom parser, supporting the old BGEOV format (Partio compatible). Handles uncompressed and gzip compressed files. Only points and their implicit position vector attributes are loaded.

```rust
use splashsurf::io::bgeo;

let points = bgeo::load("mesh.bgeo")?;
```

--------------------------------

### Load VTU File

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Loads VTK XML files (.vtu) using vtkio. Supports ASCII or encoded binary formats. Raw binary sections are not currently supported.

```rust
use splashsurf::io::vtkio;

let mesh = vtkio::load("mesh.vtu")?;
```

--------------------------------

### Benchmark Reconstruction Log Output

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Log output from a benchmark reconstruction of a large particle dataset, showing the command line used, processing steps, and final mesh statistics. This log indicates successful reconstruction in under 3 seconds.

```log
[17:34:31.034][INFO] target/release/splashsurf v0.14.0 (splashsurf)
[17:34:31.034][INFO] Called with command line: target/release/splashsurf reconstruct /Users/floeschner/Downloads/canyon_13353401_particles.xyz -r=0.011 -c=1.5 -l=2.0 -t=0.6 --output-dir=out
[17:34:31.034][INFO] Using single precision (f32) for surface reconstruction.
[17:34:31.034][INFO] Reading particle dataset from "/Users/floeschner/Downloads/canyon_13353401_particles.xyz"...
[17:34:31.093][INFO] Successfully read dataset with 13353401 particle positions.
[17:34:31.093][INFO] Vectorization enabled with support detected for NEON instructions.
[17:34:31.098][INFO] Bounding box of particles with margin for levelset evaluation: [-25.006098, -5.014629, -40.06346] to [24.499493, 18.30621, 39.775795]
[17:34:31.098][INFO] The ghost margin volume per subdomain is 42.38% of the subdomain volume
[17:34:31.098][INFO] The ghost margin per subdomain is 3.03 MC cells or 0.05 subdomains wide
[17:34:31.098][INFO] Number of subdomains: 82156 (47x23x76)
[17:34:31.098][INFO] Number of MC cells per subdomain: 262144 (64x64x64)
[17:34:31.098][INFO] Number of MC cells globally: 21536702464 (3008x1472x4864)
[17:34:31.098][INFO] Starting classification of particles into subdomains.
[17:34:31.180][INFO] Starting computation of global density vector.
[17:34:32.645][INFO] Largest subdomain has 167861 particles.
[17:34:32.645][INFO] Subdomains with 8393 or less particles will be considered sparse.
[17:34:32.645][INFO] Starting reconstruction (level-set evaluation and local triangulation).
[17:34:33.259][INFO] Starting stitching of subdomain meshes to global mesh.
[17:34:33.316][INFO] Global mesh has 3037970 vertices and 6069264 triangles.
[17:34:33.400][INFO] Writing mesh with 3037970 vertices and 6069264 cells to "out/canyon_13353401_particles_surface.vtk"...

```

--------------------------------

### SplashSurf Reconstruct Command Usage

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

This is the main usage string for the `splashsurf reconstruct` command. It outlines the basic structure and required parameters for reconstructing a surface from particle data.

```bash
splashsurf-reconstruct (v0.14.0) - Reconstruct a surface from particle data

Usage: splashsurf reconstruct [OPTIONS] --particle-radius <PARTICLE_RADIUS> --smoothing-length <SMOOTHING_LENGTH> --cube-size <CUBE_SIZE> <INPUT_FILE_OR_SEQUENCE>

Options:
  -q, --quiet    Enable quiet mode (no output except for severe panic messages), overrides verbosity level
  -v...          Print more verbose output, use multiple "v"s for even more verbose output (-v, -vv)
  -h, --help     Print help
  -V, --version  Print version

Input/output:
  -o, --output-file <OUTPUT_FILE>  Filename for writing the reconstructed surface to disk (supported formats: VTK, PLY, OBJ, default: "{original_filename}_surface.vtk")
      --output-dir <OUTPUT_DIR>    Optional base directory for all output files (default: current working directory)
  -s, --start-index <START_INDEX>  Index of the first input file to process when processing a sequence of files (default: lowest index of the sequence)
  -e, --end-index <END_INDEX>      Index of the last input file to process when processing a sequence of files (default: highest index of the sequence)
  <INPUT_FILE_OR_SEQUENCE>         Path to the input file where the particle positions are stored (supported formats: VTK 4.2, VTU, binary f32 XYZ, PLY, BGEO), use "{}" in the filename to indicate a placeholder for a sequence

Numerical reconstruction parameters:
  -r, --particle-radius <PARTICLE_RADIUS>
          The particle radius of the input data
      --rest-density <REST_DENSITY>
          The rest density of the fluid [default: 1000.0]
  -l, --smoothing-length <SMOOTHING_LENGTH>
          The smoothing length radius used for the SPH kernel, the kernel compact support radius will be twice the smoothing length (in multiples of the particle radius)
  -c, --cube-size <CUBE_SIZE>
          The cube edge length used for marching cubes in multiples of the particle radius, corresponds to the cell size of the implicit background grid
  -t, --surface-threshold <SURFACE_THRESHOLD>
          The iso-surface threshold used for the marching cubes algorithm, this is the value of the implicit surface function (here the color field) at which the surface is reconstructed [default: 0.6]
      --particle-aabb-min <X_MIN> <Y_MIN> <Z_MIN>
          Lower corner of the domain where surface reconstruction should be performed (requires domain-max to be specified)
      --particle-aabb-max <X_MIN> <Y_MIN> <Z_MIN>
          Upper corner of the domain where surface reconstruction should be performed (requires domain-min to be specified)

Advanced parameters:
  -d, --double-precision=<off|on>  Enable the use of double precision for all computations [default: off] [possible values: off, on]
      --mt-files=<off|on>          Enable multithreading to process multiple input files in parallel (NOTE: Currently, the subdomain-grid domain decomposition approach and some post-processing functions including interpolation do not have sequential versions and therefore do not work well with this option enabled) [default: off] [possible values: off, on]
      --mt-particles=<off|on>      Enable multithreading for a single input file by processing chunks of particles in parallel [default: on] [possible values: off, on]
  -n, --num-threads <NUM_THREADS>  Set the number of threads for the worker thread pool
      --simd=<off|on>              Enable vectorization of some computations using SIMD instructions (requires CPU with AVX2 or NEON support). Note that vectorization is currently only available in single precision (f32) mode [default: on] [possible values: off, on]

Domain decomposition parameters:
      --subdomain-grid=<off|on>
          Enable automatic spatial decomposition using a regular grid-based approach (for efficient multithreading) if the domain is large enough [default: on] [possible values: off, on]
      --subdomain-grid-auto-disable=<off|on>
          Whether to automatically disable the spatial decomposition if the domain is too small [default: on] [possible values: off, on]
      --subdomain-cubes <SUBDOMAIN_CUBES>
          Each subdomain will be a cube consisting of this number of MC grid cells along each coordinate axis [default: 64]

```

--------------------------------

### Load XYZ File

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Interprets XYZ files (.xyz) as raw bytes of f32 values in native endianness. Three consecutive f32s form a (x,y,z) coordinate triplet.

```rust
use splashsurf::io::xyz;

let points = xyz::load("points.xyz")?;
```

--------------------------------

### reconstruction_pipeline

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/api.rst

Implements all features of the splashsurf CLI, including particle-based surface reconstruction and optional post-processing.

```APIDOC
## reconstruct_surface

### Description
Performs the surface reconstruction from particles.

### Parameters
This function accepts Python ``float`` for scalar parameters and Numpy arrays of data-type ``np.float32`` or ``np.float64`` for array inputs (e.g. particle positions). Array-like inputs must be contiguous (C-order) and use the same float data-type for all array-like and object type inputs.

### Returns
Outputs will be of the same float precision as the input arrays.
```

--------------------------------

### SplashSurf Convert Subcommand Usage

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

This is the general usage information for the splashsurf convert subcommand. It outlines the available options for converting particle and mesh files.

```bash
splashsurf convert (v0.13.0) - Convert particle or mesh files between different file formats

Usage: splashsurf convert [OPTIONS] -o <OUTPUT_FILE>

Options:
      --particles <INPUT_PARTICLES>
          Path to the input file with particles to read (supported formats: .vtk, .vtu, .bgeo, .ply, .xyz, .json)
  -q, --quiet
          Enable quiet mode (no output except for severe panic messages), overrides verbosity level
      --mesh <INPUT_MESH>
          Path to the input file with a surface to read (supported formats: .vtk, .ply)
  -v...
          Print more verbose output, use multiple "v"s for even more verbose output (-v, -vv)
  -o <OUTPUT_FILE>
          Path to the output file (supported formats for particles: .vtk, .bgeo, .json, for meshes: .obj, .vtk)
      --overwrite
          Whether to overwrite existing files without asking
      --domain-min <X_MIN> <Y_MIN> <Z_MIN>
          Lower corner of the domain of particles to keep (requires domain-max to be specified)
      --domain-max <X_MIN> <Y_MIN> <Z_MIN>
          Lower corner of the domain of particles to keep (requires domain-min to be specified)
  -h, --help
          Print help
  -V, --version
          Print version
```

--------------------------------

### Generate Stub File

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/README.md

Command to automatically generate a stub file for the pySplashsurf package using cargo.

```bash
cargo run --bin stub_gen --no-default-features
```

--------------------------------

### Load PLY File

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Loads PLY files (.ply) using ply-rs. Requires an element named 'vertex' with 'x', 'y', and 'z' properties of type f32. Other properties or elements are ignored.

```rust
use splashsurf::io::ply;

let mesh = ply::load("mesh.ply")?;
```

--------------------------------

### reconstruction_pipeline

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Executes a complete pipeline for surface reconstruction, likely involving multiple steps.

```APIDOC
## reconstruction_pipeline

### Description
Executes a comprehensive pipeline for surface reconstruction, integrating various processing steps.

### Function Signature
pysplashsurf.reconstruction_pipeline(input_data)

### Parameters
* **input_data** (Input data) - The initial data for the reconstruction pipeline.

### Returns
* **output_mesh** (Mesh object) - The final mesh produced by the reconstruction pipeline.
```

--------------------------------

### Splashsurf Citation BibTeX Entry

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Use this BibTeX entry to cite the splashsurf project in academic publications. It includes details about the associated paper.

```bibtex
@inproceedings {LBJB23,
  booktitle = {Vision, Modeling, and Visualization},
  title = {{Weighted Laplacian Smoothing for Surface Reconstruction of Particle-based Fluids}},
  author = {Löschner, Fabian and Böttcher, Timna and Rhys Jeske, Stefan and Bender, Jan},
  year = {2023},
  publisher = {The Eurographics Association},
  DOI = {10.2312/vmv.20231245}
}
```

--------------------------------

### Load JSON Point Data

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/README.md

Interprets JSON files (.json) as serializations of a Vec<[f32; 3]>, where each array represents a particle position.

```json
[
    [1.0, 2.0, 3.0],
    [1.0, 2.0, 3.0]
]
```

--------------------------------

### marching_cubes

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Generates a surface mesh from volumetric data using the Marching Cubes algorithm.

```APIDOC
## marching_cubes

### Description
Generates a surface mesh from volumetric data using the Marching Cubes algorithm.

### Function Signature
pysplashsurf.marching_cubes(volume, level)

### Parameters
* **volume** (Volume data) - The input volumetric data.
* **level** (float) - The iso-level at which to extract the surface.

### Returns
* **mesh** (Mesh object) - The generated surface mesh.
```

--------------------------------

### Surface Reconstruction Function Signature

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/splashsurf_lib/README.md

This is the signature for the top-level `reconstruct_surface` function. It takes particle positions and parameters to perform surface reconstruction.

```rust
pub fn reconstruct_surface<I: Index, R: Real>(
    particle_positions: &[Vector3<R>],
    parameters: &Parameters<R>,
) -> Result<SurfaceReconstruction<I, R>, ReconstructionError<I, R>>
```

--------------------------------

### neighborhood_search_spatial_hashing_parallel

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Efficiently searches for neighboring points or elements in a dataset using spatial hashing, optimized for parallel execution.

```APIDOC
## neighborhood_search_spatial_hashing_parallel

### Description
Performs neighborhood searches using a spatial hashing technique, optimized for parallel processing.

### Function Signature
pysplashsurf.neighborhood_search_spatial_hashing_parallel(points, radius)

### Parameters
* **points** (List of points) - The dataset of points to search within.
* **radius** (float) - The search radius for finding neighbors.

### Returns
* **neighborhood_data** (Data structure) - Information about the neighborhoods found.
```

--------------------------------

### MeshType

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

An enumeration representing different types of meshes supported by the library.

```APIDOC
## MeshType

### Description
An enumeration representing different types of meshes supported by the library.
```

--------------------------------

### UniformGrid

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

Represents a uniform grid structure, often used for spatial partitioning or simulation grids.

```APIDOC
## UniformGrid

### Description
Represents a uniform grid structure, often used for spatial partitioning or simulation grids.

See `UniformGrid <https://docs.rs/splashsurf_lib/latest/splashsurf_lib/uniform_grid/type.UniformGrid.html>`_ for more information.
```

--------------------------------

### laplacian_smoothing_normals_parallel

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Applies Laplacian smoothing to a mesh, considering surface normals for a more accurate smoothing process, optimized for parallel processing.

```APIDOC
## laplacian_smoothing_normals_parallel

### Description
Applies Laplacian smoothing to a mesh using surface normals, optimized for parallel execution.

### Function Signature
pysplashsurf.laplacian_smoothing_normals_parallel(mesh, iterations=1, lambda_smooth=0.5)

### Parameters
* **mesh** (Mesh object) - The input mesh to smooth.
* **iterations** (int, optional) - The number of smoothing iterations. Defaults to 1.
* **lambda_smooth** (float, optional) - Controls the smoothing factor. Defaults to 0.5.

### Returns
* **smoothed_mesh** (Mesh object) - The mesh after Laplacian smoothing with normal consideration.
```

--------------------------------

### reconstruct_surface

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Reconstructs a surface from a given set of points or data.

```APIDOC
## reconstruct_surface

### Description
Reconstructs a surface mesh from input data, such as point clouds.

### Function Signature
pysplashsurf.reconstruct_surface(data)

### Parameters
* **data** (Input data) - The data from which to reconstruct the surface (e.g., point cloud).

### Returns
* **mesh** (Mesh object) - The reconstructed surface mesh.
```

--------------------------------

### marching_cubes_cleanup

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Performs cleanup operations on a mesh generated by the Marching Cubes algorithm.

```APIDOC
## marching_cubes_cleanup

### Description
Cleans up a mesh that was generated using the Marching Cubes algorithm, potentially removing artifacts or improving quality.

### Function Signature
pysplashsurf.marching_cubes_cleanup(mesh)

### Parameters
* **mesh** (Mesh object) - The mesh generated by Marching Cubes to be cleaned.

### Returns
* **cleaned_mesh** (Mesh object) - The mesh after cleanup operations.
```

--------------------------------

### VertexVertexConnectivity

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

Stores connectivity information between vertices in a mesh.

```APIDOC
## VertexVertexConnectivity

### Description
Stores connectivity information between vertices in a mesh.
```

--------------------------------

### laplacian_smoothing_parallel

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Applies standard Laplacian smoothing to a mesh, optimized for parallel processing.

```APIDOC
## laplacian_smoothing_parallel

### Description
Applies Laplacian smoothing to a mesh, optimized for parallel execution.

### Function Signature
pysplashsurf.laplacian_smoothing_parallel(mesh, iterations=1, lambda_smooth=0.5)

### Parameters
* **mesh** (Mesh object) - The input mesh to smooth.
* **iterations** (int, optional) - The number of smoothing iterations. Defaults to 1.
* **lambda_smooth** (float, optional) - Controls the smoothing factor. Defaults to 0.5.

### Returns
* **smoothed_mesh** (Mesh object) - The mesh after Laplacian smoothing.
```

--------------------------------

### TriMesh3d

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

Represents a 3D triangular mesh. This is a fundamental data structure for representing surfaces composed of triangles.

```APIDOC
## TriMesh3d

### Description
Represents a 3D triangular mesh. This is a fundamental data structure for representing surfaces composed of triangles.

See `TriMesh3d <https://docs.rs/splashsurf_lib/latest/splashsurf_lib/mesh/struct.TriMesh3d.html>`_ for more information.
```

--------------------------------

### SurfaceReconstruction

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

Represents the result of a surface reconstruction process. Contains the generated surface data.

```APIDOC
## SurfaceReconstruction

### Description
Represents the result of a surface reconstruction process. Contains the generated surface data.

See `SurfaceReconstruction <https://docs.rs/splashsurf_lib/latest/splashsurf_lib/struct.SurfaceReconstruction.html>`_ for more information.
```

--------------------------------

### Aabb3d

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

Represents an Axis-Aligned Bounding Box in 3D space. Used for spatial queries and optimizations.

```APIDOC
## Aabb3d

### Description
Represents an Axis-Aligned Bounding Box in 3D space. Used for spatial queries and optimizations.

See `Aabb3d <https://docs.rs/splashsurf_lib/latest/splashsurf_lib/type.Aabb3d.html>`_ for more information.
```

--------------------------------

### NeighborhoodLists

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

A data structure for storing neighborhood information, likely used in mesh processing and simulations.

```APIDOC
## NeighborhoodLists

### Description
A data structure for storing neighborhood information, likely used in mesh processing and simulations.
```

--------------------------------

### convert_tris_to_quads

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Converts a triangular mesh into a quadrilateral mesh.

```APIDOC
## convert_tris_to_quads

### Description
Converts a mesh composed of triangles into a mesh composed of quadrilaterals.

### Function Signature
pysplashsurf.convert_tris_to_quads(mesh)

### Parameters
* **mesh** (Mesh object) - The input triangular mesh.

### Returns
* **quad_mesh** (Mesh object) - The resulting quadrilateral mesh.
```

--------------------------------

### check_mesh_consistency

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Validates the structural integrity and consistency of a given mesh.

```APIDOC
## check_mesh_consistency

### Description
Checks if a mesh is consistent, ensuring that its topological and geometric properties are valid.

### Function Signature
pysplashsurf.check_mesh_consistency(mesh)

### Parameters
* **mesh** (Mesh object) - The mesh to check for consistency.

### Returns
* **is_consistent** (bool) - True if the mesh is consistent, False otherwise.
```

--------------------------------

### MeshWithData

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

Represents a mesh structure that includes associated data. This is useful for meshes where additional information needs to be stored per vertex or face.

```APIDOC
## MeshWithData

### Description
Represents a mesh structure that includes associated data. This is useful for meshes where additional information needs to be stored per vertex or face.

See `MeshWithData <https://docs.rs/splashsurf_lib/latest/splashsurf_lib/mesh/struct.MeshWithData.html>`_ for more information.
```

--------------------------------

### MixedTriQuadMesh3d

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

Represents a 3D mesh composed of both triangular and quadrilateral elements. This class allows for more complex mesh structures.

```APIDOC
## MixedTriQuadMesh3d

### Description
Represents a 3D mesh composed of both triangular and quadrilateral elements. This class allows for more complex mesh structures.

See `MixedTriQuadMesh3d <https://docs.rs/splashsurf_lib/latest/splashsurf_lib/mesh/struct.MixedTriQuadMesh3d.html>`_ for more information.
```

--------------------------------

### barnacle_decimation

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/functions.rst

Performs decimation on a mesh, likely for reducing polygon count while preserving important features, potentially related to barnacle-like structures.

```APIDOC
## barnacle_decimation

### Description
Performs decimation on a mesh. This function is useful for reducing the complexity of a mesh while aiming to preserve its essential geometric features.

### Function Signature
pysplashsurf.barnacle_decimation(mesh)

### Parameters
* **mesh** (Mesh object) - The input mesh to be decimated.

### Returns
* **decimated_mesh** (Mesh object) - The mesh after decimation has been applied.
```

--------------------------------

### SphInterpolator

Source: https://github.com/interactivecomputergraphics/splashsurf/blob/main/pysplashsurf/pysplashsurf/docs/source/classes.rst

Represents a Spherical Interpolator used for surface reconstruction. It handles the interpolation logic for generating surfaces from point data.

```APIDOC
## SphInterpolator

### Description
Represents a Spherical Interpolator used for surface reconstruction. It handles the interpolation logic for generating surfaces from point data.

See `SphInterpolator <https://docs.rs/splashsurf_lib/latest/splashsurf_lib/sph_interpolation/struct.SphInterpolator.html>`_ for more information.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.