Struct Manifold

pub struct Manifold(/* private fields */);

Manifold rust wrapper for C++ manifold object.

Implementations

impl Manifold

pub fn slice(&self, height: f64) -> Polygons

Slice the manifold into a set of polygons.

pub fn project(&self) -> Polygons

Project the manifold onto a plane and return the resulting polygons.

pub fn trim_by_plane(&self, x: f64, y: f64, z: f64, offset: f64) -> Self

Trim by a plane.

Examples found in repository

examples/write_stl.rs (line 91)

fn main() -> std::io::Result<()> {
    // Write sphere to an STL file
    manifold_rs::Manifold::sphere(4.0, 128).write_stl_to_file("sphere.stl")?;

    // Write cylinder to an STL file
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 4.0, 3.0, 32);

        // Convert the manifold to a mesh and back to a manifold, just for testing
        let mesh = manifold.to_mesh();
        let manifold = mesh.to_manifold();

        manifold.write_stl_to_file("cylinder.stl")?;
    }

    // Generate torus with `revolve` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let circle = generate_circle(2.0, (4.0, 0.0), 32);

        // Revolve the circle 360° around the z-axis
        let manifold = manifold_rs::Manifold::revolve(&[circle.as_slice()], 32, 360.0);

        manifold.write_stl_to_file("torus.stl")?;
    }

    // Generate a tube via `extrude` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let inner_circle = generate_circle(0.3, (0.0, 0.0), 32);
        let outer_circle = generate_circle(1.0, (0.0, 0.0), 32);

        // CCW winding order to create a hole in the tube
        let inner_circle = inner_circle
            .into_iter()
            .enumerate()
            .map(|(i, x)| if i % 2 == 0 { x } else { -x })
            .collect::<Vec<_>>();

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[outer_circle.as_slice(), inner_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );

        manifold.write_stl_to_file("tube.stl")?;
    }

    // Convex hull of two circles
    {
        let left_circle = generate_circle(1.0, (-1.0, 0.0), 32);
        let right_circle = generate_circle(1.0, (1.0, 0.0), 32);

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[left_circle.as_slice(), right_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );
        let manifold = manifold.hull();

        manifold.write_stl_to_file("hull.stl")?;
    }

    // Trim a cylinder by a plane
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 1.0, 3.0, 32);
        let manifold = manifold.trim_by_plane(0.5, 0.5, 0.5, 0.0);

        manifold.write_stl_to_file("cylinder_trimmed.stl")?;
    }
    Ok(())
}

pub fn hull(&self) -> Self

Convex hull.

Examples found in repository

examples/write_stl.rs (line 83)

fn main() -> std::io::Result<()> {
    // Write sphere to an STL file
    manifold_rs::Manifold::sphere(4.0, 128).write_stl_to_file("sphere.stl")?;

    // Write cylinder to an STL file
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 4.0, 3.0, 32);

        // Convert the manifold to a mesh and back to a manifold, just for testing
        let mesh = manifold.to_mesh();
        let manifold = mesh.to_manifold();

        manifold.write_stl_to_file("cylinder.stl")?;
    }

    // Generate torus with `revolve` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let circle = generate_circle(2.0, (4.0, 0.0), 32);

        // Revolve the circle 360° around the z-axis
        let manifold = manifold_rs::Manifold::revolve(&[circle.as_slice()], 32, 360.0);

        manifold.write_stl_to_file("torus.stl")?;
    }

    // Generate a tube via `extrude` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let inner_circle = generate_circle(0.3, (0.0, 0.0), 32);
        let outer_circle = generate_circle(1.0, (0.0, 0.0), 32);

        // CCW winding order to create a hole in the tube
        let inner_circle = inner_circle
            .into_iter()
            .enumerate()
            .map(|(i, x)| if i % 2 == 0 { x } else { -x })
            .collect::<Vec<_>>();

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[outer_circle.as_slice(), inner_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );

        manifold.write_stl_to_file("tube.stl")?;
    }

    // Convex hull of two circles
    {
        let left_circle = generate_circle(1.0, (-1.0, 0.0), 32);
        let right_circle = generate_circle(1.0, (1.0, 0.0), 32);

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[left_circle.as_slice(), right_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );
        let manifold = manifold.hull();

        manifold.write_stl_to_file("hull.stl")?;
    }

    // Trim a cylinder by a plane
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 1.0, 3.0, 32);
        let manifold = manifold.trim_by_plane(0.5, 0.5, 0.5, 0.0);

        manifold.write_stl_to_file("cylinder_trimmed.stl")?;
    }
    Ok(())
}

pub fn translate(&self, x: f64, y: f64, z: f64) -> Self

Translate the manifold.

Examples found in repository

examples/bevy.rs (line 18)

    fn setup(
        mut commands: Commands,
        mut meshes: ResMut<Assets<Mesh>>,
        mut materials: ResMut<Assets<StandardMaterial>>,
    ) {
        let tube = Self::cylinder_manifold(1.0, 3.0)
            .boolean_op(
                &Self::cylinder_manifold(0.5, 4.0),
                manifold_rs::BooleanOp::Difference,
            )
            .translate(-1.5, -1.5, 0.0);

        Self::add_manifold(&mut commands, &mut meshes, &mut materials, tube);

        let tube_with_normals = Self::cylinder_manifold(1.0, 3.0)
            .boolean_op(
                &Self::cylinder_manifold(0.5, 4.0),
                manifold_rs::BooleanOp::Difference,
            )
            .calculate_normals(0, 50.0)
            .translate(1.5, 1.5, 0.0);

        Self::add_manifold(
            &mut commands,
            &mut meshes,
            &mut materials,
            tube_with_normals,
        );
    }

examples/write_ply.rs (line 25)

fn main() -> std::io::Result<()> {
    // Generate a cube
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size);
        manifold.write_ply_to_file("cube.ply")?;
    }

    // Generate a cube with normals
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size).calculate_normals(0, 30.0);
        manifold.write_ply_to_file("cube_normals.ply")?;
    }

    // Generate a dice and smooth it
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size)
            .translate(-size / 2.0, -size / 2.0, -size / 2.0)
            .intersection(&Manifold::sphere(size / 2.0_f64.sqrt(), 64));

        let manifold = manifold
            .calculate_normals(0, 40.0)
            .refine_to_length(0.2)
            .smooth_out(40.0, 1.0);

        manifold.write_ply_to_file("dice.ply")?;
    }

    // Generate tube with normals
    {
        let inner_radius = 0.3;
        let outer_radius = 1.0;
        let height = 2.0;

        let manifold = Manifold::cylinder(outer_radius, outer_radius, height, 32)
            .difference(&Manifold::cylinder(inner_radius, inner_radius, height, 32));
        let manifold = manifold.calculate_normals(0, 40.0);

        manifold.write_ply_to_file("tube_normals.ply")?;
    }

    Ok(())
}

pub fn scale(&self, x: f64, y: f64, z: f64) -> Self

Scale the manifold.

pub fn rotate(&self, x: f64, y: f64, z: f64) -> Self

Rotate the manifold.

pub fn sphere(radius: f64, segments: u32) -> Self

Create a sphere manifold.

Examples found in repository

examples/write_ply.rs (line 26)

fn main() -> std::io::Result<()> {
    // Generate a cube
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size);
        manifold.write_ply_to_file("cube.ply")?;
    }

    // Generate a cube with normals
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size).calculate_normals(0, 30.0);
        manifold.write_ply_to_file("cube_normals.ply")?;
    }

    // Generate a dice and smooth it
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size)
            .translate(-size / 2.0, -size / 2.0, -size / 2.0)
            .intersection(&Manifold::sphere(size / 2.0_f64.sqrt(), 64));

        let manifold = manifold
            .calculate_normals(0, 40.0)
            .refine_to_length(0.2)
            .smooth_out(40.0, 1.0);

        manifold.write_ply_to_file("dice.ply")?;
    }

    // Generate tube with normals
    {
        let inner_radius = 0.3;
        let outer_radius = 1.0;
        let height = 2.0;

        let manifold = Manifold::cylinder(outer_radius, outer_radius, height, 32)
            .difference(&Manifold::cylinder(inner_radius, inner_radius, height, 32));
        let manifold = manifold.calculate_normals(0, 40.0);

        manifold.write_ply_to_file("tube_normals.ply")?;
    }

    Ok(())
}

examples/write_stl.rs (line 19)

fn main() -> std::io::Result<()> {
    // Write sphere to an STL file
    manifold_rs::Manifold::sphere(4.0, 128).write_stl_to_file("sphere.stl")?;

    // Write cylinder to an STL file
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 4.0, 3.0, 32);

        // Convert the manifold to a mesh and back to a manifold, just for testing
        let mesh = manifold.to_mesh();
        let manifold = mesh.to_manifold();

        manifold.write_stl_to_file("cylinder.stl")?;
    }

    // Generate torus with `revolve` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let circle = generate_circle(2.0, (4.0, 0.0), 32);

        // Revolve the circle 360° around the z-axis
        let manifold = manifold_rs::Manifold::revolve(&[circle.as_slice()], 32, 360.0);

        manifold.write_stl_to_file("torus.stl")?;
    }

    // Generate a tube via `extrude` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let inner_circle = generate_circle(0.3, (0.0, 0.0), 32);
        let outer_circle = generate_circle(1.0, (0.0, 0.0), 32);

        // CCW winding order to create a hole in the tube
        let inner_circle = inner_circle
            .into_iter()
            .enumerate()
            .map(|(i, x)| if i % 2 == 0 { x } else { -x })
            .collect::<Vec<_>>();

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[outer_circle.as_slice(), inner_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );

        manifold.write_stl_to_file("tube.stl")?;
    }

    // Convex hull of two circles
    {
        let left_circle = generate_circle(1.0, (-1.0, 0.0), 32);
        let right_circle = generate_circle(1.0, (1.0, 0.0), 32);

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[left_circle.as_slice(), right_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );
        let manifold = manifold.hull();

        manifold.write_stl_to_file("hull.stl")?;
    }

    // Trim a cylinder by a plane
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 1.0, 3.0, 32);
        let manifold = manifold.trim_by_plane(0.5, 0.5, 0.5, 0.0);

        manifold.write_stl_to_file("cylinder_trimmed.stl")?;
    }
    Ok(())
}

pub fn cube(x_size: f64, y_size: f64, z_size: f64) -> Self

Create a cube manifold.

Examples found in repository

examples/write_ply.rs (line 10)

fn main() -> std::io::Result<()> {
    // Generate a cube
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size);
        manifold.write_ply_to_file("cube.ply")?;
    }

    // Generate a cube with normals
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size).calculate_normals(0, 30.0);
        manifold.write_ply_to_file("cube_normals.ply")?;
    }

    // Generate a dice and smooth it
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size)
            .translate(-size / 2.0, -size / 2.0, -size / 2.0)
            .intersection(&Manifold::sphere(size / 2.0_f64.sqrt(), 64));

        let manifold = manifold
            .calculate_normals(0, 40.0)
            .refine_to_length(0.2)
            .smooth_out(40.0, 1.0);

        manifold.write_ply_to_file("dice.ply")?;
    }

    // Generate tube with normals
    {
        let inner_radius = 0.3;
        let outer_radius = 1.0;
        let height = 2.0;

        let manifold = Manifold::cylinder(outer_radius, outer_radius, height, 32)
            .difference(&Manifold::cylinder(inner_radius, inner_radius, height, 32));
        let manifold = manifold.calculate_normals(0, 40.0);

        manifold.write_ply_to_file("tube_normals.ply")?;
    }

    Ok(())
}

pub fn cylinder( radius_low: f64, radius_high: f64, height: f64, segments: u32, ) -> Self

Create a cylinder manifold.

Examples found in repository

examples/bevy.rs (line 70)

    fn cylinder_manifold(d: f64, h: f64) -> manifold_rs::Manifold {
        manifold_rs::Manifold::cylinder(d, d, h, (d * 32.0) as u32)
    }

examples/write_ply.rs (line 42)

fn main() -> std::io::Result<()> {
    // Generate a cube
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size);
        manifold.write_ply_to_file("cube.ply")?;
    }

    // Generate a cube with normals
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size).calculate_normals(0, 30.0);
        manifold.write_ply_to_file("cube_normals.ply")?;
    }

    // Generate a dice and smooth it
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size)
            .translate(-size / 2.0, -size / 2.0, -size / 2.0)
            .intersection(&Manifold::sphere(size / 2.0_f64.sqrt(), 64));

        let manifold = manifold
            .calculate_normals(0, 40.0)
            .refine_to_length(0.2)
            .smooth_out(40.0, 1.0);

        manifold.write_ply_to_file("dice.ply")?;
    }

    // Generate tube with normals
    {
        let inner_radius = 0.3;
        let outer_radius = 1.0;
        let height = 2.0;

        let manifold = Manifold::cylinder(outer_radius, outer_radius, height, 32)
            .difference(&Manifold::cylinder(inner_radius, inner_radius, height, 32));
        let manifold = manifold.calculate_normals(0, 40.0);

        manifold.write_ply_to_file("tube_normals.ply")?;
    }

    Ok(())
}

examples/write_stl.rs (line 23)

fn main() -> std::io::Result<()> {
    // Write sphere to an STL file
    manifold_rs::Manifold::sphere(4.0, 128).write_stl_to_file("sphere.stl")?;

    // Write cylinder to an STL file
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 4.0, 3.0, 32);

        // Convert the manifold to a mesh and back to a manifold, just for testing
        let mesh = manifold.to_mesh();
        let manifold = mesh.to_manifold();

        manifold.write_stl_to_file("cylinder.stl")?;
    }

    // Generate torus with `revolve` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let circle = generate_circle(2.0, (4.0, 0.0), 32);

        // Revolve the circle 360° around the z-axis
        let manifold = manifold_rs::Manifold::revolve(&[circle.as_slice()], 32, 360.0);

        manifold.write_stl_to_file("torus.stl")?;
    }

    // Generate a tube via `extrude` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let inner_circle = generate_circle(0.3, (0.0, 0.0), 32);
        let outer_circle = generate_circle(1.0, (0.0, 0.0), 32);

        // CCW winding order to create a hole in the tube
        let inner_circle = inner_circle
            .into_iter()
            .enumerate()
            .map(|(i, x)| if i % 2 == 0 { x } else { -x })
            .collect::<Vec<_>>();

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[outer_circle.as_slice(), inner_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );

        manifold.write_stl_to_file("tube.stl")?;
    }

    // Convex hull of two circles
    {
        let left_circle = generate_circle(1.0, (-1.0, 0.0), 32);
        let right_circle = generate_circle(1.0, (1.0, 0.0), 32);

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[left_circle.as_slice(), right_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );
        let manifold = manifold.hull();

        manifold.write_stl_to_file("hull.stl")?;
    }

    // Trim a cylinder by a plane
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 1.0, 3.0, 32);
        let manifold = manifold.trim_by_plane(0.5, 0.5, 0.5, 0.0);

        manifold.write_stl_to_file("cylinder_trimmed.stl")?;
    }
    Ok(())
}

pub fn union(&self, b: &Self) -> Self

Get the union of two manifolds.

pub fn intersection(&self, b: &Self) -> Self

Get the intersection of two manifolds.

Examples found in repository

examples/write_ply.rs (line 26)

fn main() -> std::io::Result<()> {
    // Generate a cube
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size);
        manifold.write_ply_to_file("cube.ply")?;
    }

    // Generate a cube with normals
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size).calculate_normals(0, 30.0);
        manifold.write_ply_to_file("cube_normals.ply")?;
    }

    // Generate a dice and smooth it
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size)
            .translate(-size / 2.0, -size / 2.0, -size / 2.0)
            .intersection(&Manifold::sphere(size / 2.0_f64.sqrt(), 64));

        let manifold = manifold
            .calculate_normals(0, 40.0)
            .refine_to_length(0.2)
            .smooth_out(40.0, 1.0);

        manifold.write_ply_to_file("dice.ply")?;
    }

    // Generate tube with normals
    {
        let inner_radius = 0.3;
        let outer_radius = 1.0;
        let height = 2.0;

        let manifold = Manifold::cylinder(outer_radius, outer_radius, height, 32)
            .difference(&Manifold::cylinder(inner_radius, inner_radius, height, 32));
        let manifold = manifold.calculate_normals(0, 40.0);

        manifold.write_ply_to_file("tube_normals.ply")?;
    }

    Ok(())
}

pub fn difference(&self, b: &Self) -> Self

Get the difference of two manifolds.

Examples found in repository

examples/write_ply.rs (line 43)

fn main() -> std::io::Result<()> {
    // Generate a cube
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size);
        manifold.write_ply_to_file("cube.ply")?;
    }

    // Generate a cube with normals
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size).calculate_normals(0, 30.0);
        manifold.write_ply_to_file("cube_normals.ply")?;
    }

    // Generate a dice and smooth it
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size)
            .translate(-size / 2.0, -size / 2.0, -size / 2.0)
            .intersection(&Manifold::sphere(size / 2.0_f64.sqrt(), 64));

        let manifold = manifold
            .calculate_normals(0, 40.0)
            .refine_to_length(0.2)
            .smooth_out(40.0, 1.0);

        manifold.write_ply_to_file("dice.ply")?;
    }

    // Generate tube with normals
    {
        let inner_radius = 0.3;
        let outer_radius = 1.0;
        let height = 2.0;

        let manifold = Manifold::cylinder(outer_radius, outer_radius, height, 32)
            .difference(&Manifold::cylinder(inner_radius, inner_radius, height, 32));
        let manifold = manifold.calculate_normals(0, 40.0);

        manifold.write_ply_to_file("tube_normals.ply")?;
    }

    Ok(())
}

pub fn boolean_op(&self, b: &Self, op: BooleanOp) -> Self

Boolean operation on manifolds.

Examples found in repository

examples/bevy.rs (lines 14-17)

    fn setup(
        mut commands: Commands,
        mut meshes: ResMut<Assets<Mesh>>,
        mut materials: ResMut<Assets<StandardMaterial>>,
    ) {
        let tube = Self::cylinder_manifold(1.0, 3.0)
            .boolean_op(
                &Self::cylinder_manifold(0.5, 4.0),
                manifold_rs::BooleanOp::Difference,
            )
            .translate(-1.5, -1.5, 0.0);

        Self::add_manifold(&mut commands, &mut meshes, &mut materials, tube);

        let tube_with_normals = Self::cylinder_manifold(1.0, 3.0)
            .boolean_op(
                &Self::cylinder_manifold(0.5, 4.0),
                manifold_rs::BooleanOp::Difference,
            )
            .calculate_normals(0, 50.0)
            .translate(1.5, 1.5, 0.0);

        Self::add_manifold(
            &mut commands,
            &mut meshes,
            &mut materials,
            tube_with_normals,
        );
    }

pub fn extrude( multi_polygon_data: &[&[f64]], height: f64, n_divisions: u32, twist_degrees: f64, scale_top_x: f64, scale_top_y: f64, ) -> Self

Extrude a polygon to create a manifold.

Examples found in repository

examples/write_stl.rs (lines 57-64)

fn main() -> std::io::Result<()> {
    // Write sphere to an STL file
    manifold_rs::Manifold::sphere(4.0, 128).write_stl_to_file("sphere.stl")?;

    // Write cylinder to an STL file
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 4.0, 3.0, 32);

        // Convert the manifold to a mesh and back to a manifold, just for testing
        let mesh = manifold.to_mesh();
        let manifold = mesh.to_manifold();

        manifold.write_stl_to_file("cylinder.stl")?;
    }

    // Generate torus with `revolve` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let circle = generate_circle(2.0, (4.0, 0.0), 32);

        // Revolve the circle 360° around the z-axis
        let manifold = manifold_rs::Manifold::revolve(&[circle.as_slice()], 32, 360.0);

        manifold.write_stl_to_file("torus.stl")?;
    }

    // Generate a tube via `extrude` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let inner_circle = generate_circle(0.3, (0.0, 0.0), 32);
        let outer_circle = generate_circle(1.0, (0.0, 0.0), 32);

        // CCW winding order to create a hole in the tube
        let inner_circle = inner_circle
            .into_iter()
            .enumerate()
            .map(|(i, x)| if i % 2 == 0 { x } else { -x })
            .collect::<Vec<_>>();

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[outer_circle.as_slice(), inner_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );

        manifold.write_stl_to_file("tube.stl")?;
    }

    // Convex hull of two circles
    {
        let left_circle = generate_circle(1.0, (-1.0, 0.0), 32);
        let right_circle = generate_circle(1.0, (1.0, 0.0), 32);

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[left_circle.as_slice(), right_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );
        let manifold = manifold.hull();

        manifold.write_stl_to_file("hull.stl")?;
    }

    // Trim a cylinder by a plane
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 1.0, 3.0, 32);
        let manifold = manifold.trim_by_plane(0.5, 0.5, 0.5, 0.0);

        manifold.write_stl_to_file("cylinder_trimmed.stl")?;
    }
    Ok(())
}

pub fn revolve( multi_polygon_data: &[&[f64]], circular_segments: u32, revolve_degrees: f64, ) -> Self

Revolve a polygon to create a manifold.

Examples found in repository

examples/write_stl.rs (line 38)

fn main() -> std::io::Result<()> {
    // Write sphere to an STL file
    manifold_rs::Manifold::sphere(4.0, 128).write_stl_to_file("sphere.stl")?;

    // Write cylinder to an STL file
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 4.0, 3.0, 32);

        // Convert the manifold to a mesh and back to a manifold, just for testing
        let mesh = manifold.to_mesh();
        let manifold = mesh.to_manifold();

        manifold.write_stl_to_file("cylinder.stl")?;
    }

    // Generate torus with `revolve` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let circle = generate_circle(2.0, (4.0, 0.0), 32);

        // Revolve the circle 360° around the z-axis
        let manifold = manifold_rs::Manifold::revolve(&[circle.as_slice()], 32, 360.0);

        manifold.write_stl_to_file("torus.stl")?;
    }

    // Generate a tube via `extrude` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let inner_circle = generate_circle(0.3, (0.0, 0.0), 32);
        let outer_circle = generate_circle(1.0, (0.0, 0.0), 32);

        // CCW winding order to create a hole in the tube
        let inner_circle = inner_circle
            .into_iter()
            .enumerate()
            .map(|(i, x)| if i % 2 == 0 { x } else { -x })
            .collect::<Vec<_>>();

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[outer_circle.as_slice(), inner_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );

        manifold.write_stl_to_file("tube.stl")?;
    }

    // Convex hull of two circles
    {
        let left_circle = generate_circle(1.0, (-1.0, 0.0), 32);
        let right_circle = generate_circle(1.0, (1.0, 0.0), 32);

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[left_circle.as_slice(), right_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );
        let manifold = manifold.hull();

        manifold.write_stl_to_file("hull.stl")?;
    }

    // Trim a cylinder by a plane
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 1.0, 3.0, 32);
        let manifold = manifold.trim_by_plane(0.5, 0.5, 0.5, 0.0);

        manifold.write_stl_to_file("cylinder_trimmed.stl")?;
    }
    Ok(())
}

pub fn refine(self: &Manifold, n: i32) -> Self

Refine manifold.

pub fn refine_to_length(self: &Manifold, t: f64) -> Self

Refine manifold to Length.

Examples found in repository

examples/write_ply.rs (line 30)

fn main() -> std::io::Result<()> {
    // Generate a cube
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size);
        manifold.write_ply_to_file("cube.ply")?;
    }

    // Generate a cube with normals
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size).calculate_normals(0, 30.0);
        manifold.write_ply_to_file("cube_normals.ply")?;
    }

    // Generate a dice and smooth it
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size)
            .translate(-size / 2.0, -size / 2.0, -size / 2.0)
            .intersection(&Manifold::sphere(size / 2.0_f64.sqrt(), 64));

        let manifold = manifold
            .calculate_normals(0, 40.0)
            .refine_to_length(0.2)
            .smooth_out(40.0, 1.0);

        manifold.write_ply_to_file("dice.ply")?;
    }

    // Generate tube with normals
    {
        let inner_radius = 0.3;
        let outer_radius = 1.0;
        let height = 2.0;

        let manifold = Manifold::cylinder(outer_radius, outer_radius, height, 32)
            .difference(&Manifold::cylinder(inner_radius, inner_radius, height, 32));
        let manifold = manifold.calculate_normals(0, 40.0);

        manifold.write_ply_to_file("tube_normals.ply")?;
    }

    Ok(())
}

pub fn refine_to_tolerance(self: &Manifold, t: f64) -> Self

Refine to tolerance.

pub fn smooth_by_normals(self: &Manifold, normal_idx: i32) -> Self

Smooth by normals.

pub fn smooth_out( self: &Manifold, min_sharp_angle: f64, min_smoothness: f64, ) -> Self

Smooth out.

Examples found in repository

examples/write_ply.rs (line 31)

fn main() -> std::io::Result<()> {
    // Generate a cube
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size);
        manifold.write_ply_to_file("cube.ply")?;
    }

    // Generate a cube with normals
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size).calculate_normals(0, 30.0);
        manifold.write_ply_to_file("cube_normals.ply")?;
    }

    // Generate a dice and smooth it
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size)
            .translate(-size / 2.0, -size / 2.0, -size / 2.0)
            .intersection(&Manifold::sphere(size / 2.0_f64.sqrt(), 64));

        let manifold = manifold
            .calculate_normals(0, 40.0)
            .refine_to_length(0.2)
            .smooth_out(40.0, 1.0);

        manifold.write_ply_to_file("dice.ply")?;
    }

    // Generate tube with normals
    {
        let inner_radius = 0.3;
        let outer_radius = 1.0;
        let height = 2.0;

        let manifold = Manifold::cylinder(outer_radius, outer_radius, height, 32)
            .difference(&Manifold::cylinder(inner_radius, inner_radius, height, 32));
        let manifold = manifold.calculate_normals(0, 40.0);

        manifold.write_ply_to_file("tube_normals.ply")?;
    }

    Ok(())
}

pub fn calculate_normals( self: &Manifold, normal_idx: i32, min_sharp_angle: f64, ) -> Self

Calculate normals for the manifold and return a new one.

Examples found in repository

examples/bevy.rs (line 27)

    fn setup(
        mut commands: Commands,
        mut meshes: ResMut<Assets<Mesh>>,
        mut materials: ResMut<Assets<StandardMaterial>>,
    ) {
        let tube = Self::cylinder_manifold(1.0, 3.0)
            .boolean_op(
                &Self::cylinder_manifold(0.5, 4.0),
                manifold_rs::BooleanOp::Difference,
            )
            .translate(-1.5, -1.5, 0.0);

        Self::add_manifold(&mut commands, &mut meshes, &mut materials, tube);

        let tube_with_normals = Self::cylinder_manifold(1.0, 3.0)
            .boolean_op(
                &Self::cylinder_manifold(0.5, 4.0),
                manifold_rs::BooleanOp::Difference,
            )
            .calculate_normals(0, 50.0)
            .translate(1.5, 1.5, 0.0);

        Self::add_manifold(
            &mut commands,
            &mut meshes,
            &mut materials,
            tube_with_normals,
        );
    }

examples/write_ply.rs (line 17)

fn main() -> std::io::Result<()> {
    // Generate a cube
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size);
        manifold.write_ply_to_file("cube.ply")?;
    }

    // Generate a cube with normals
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size).calculate_normals(0, 30.0);
        manifold.write_ply_to_file("cube_normals.ply")?;
    }

    // Generate a dice and smooth it
    {
        let size = 10.0;
        let manifold = Manifold::cube(size, size, size)
            .translate(-size / 2.0, -size / 2.0, -size / 2.0)
            .intersection(&Manifold::sphere(size / 2.0_f64.sqrt(), 64));

        let manifold = manifold
            .calculate_normals(0, 40.0)
            .refine_to_length(0.2)
            .smooth_out(40.0, 1.0);

        manifold.write_ply_to_file("dice.ply")?;
    }

    // Generate tube with normals
    {
        let inner_radius = 0.3;
        let outer_radius = 1.0;
        let height = 2.0;

        let manifold = Manifold::cylinder(outer_radius, outer_radius, height, 32)
            .difference(&Manifold::cylinder(inner_radius, inner_radius, height, 32));
        let manifold = manifold.calculate_normals(0, 40.0);

        manifold.write_ply_to_file("tube_normals.ply")?;
    }

    Ok(())
}

pub fn to_mesh(&self) -> Mesh

Get the mesh representation of the manifold.

Examples found in repository

examples/bevy.rs (line 89)

    fn manifold_to_bevy_mesh(manifold: manifold_rs::Manifold) -> Mesh {
        let mesh = manifold.to_mesh();

        let vertices = mesh.vertices();
        let indices = mesh.indices();

        match mesh.num_props() {
            // Vertex without normals
            3 => {
                let vertices = vertices
                    .chunks(3)
                    .map(|c| -> [f32; 3] { c.try_into().expect("Chunk size should be 3") })
                    .collect::<Vec<[f32; 3]>>();

                Mesh::new(
                    bevy::render::mesh::PrimitiveTopology::TriangleList,
                    bevy::asset::RenderAssetUsages::MAIN_WORLD
                        | bevy::asset::RenderAssetUsages::RENDER_WORLD,
                )
                .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, vertices)
                .with_inserted_indices(bevy::render::mesh::Indices::U32(indices))
                .with_duplicated_vertices()
                .with_computed_flat_normals()
            }
            // Vertex with normals
            6 => {
                let normals = vertices
                    .chunks(6)
                    .map(|c| -> [f32; 3] { [c[3], c[4], c[5]] })
                    .collect::<Vec<[f32; 3]>>();

                let vertices = vertices
                    .chunks(6)
                    .map(|c| -> [f32; 3] { [c[0], c[1], c[2]] })
                    .collect::<Vec<[f32; 3]>>();

                Mesh::new(
                    bevy::render::mesh::PrimitiveTopology::TriangleList,
                    bevy::asset::RenderAssetUsages::MAIN_WORLD
                        | bevy::asset::RenderAssetUsages::RENDER_WORLD,
                )
                .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, vertices)
                .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)
                .with_inserted_indices(bevy::render::mesh::Indices::U32(indices))
            }
            num_props => panic!("Invalid property count {num_props}"),
        }
    }

examples/write_stl.rs (line 26)

fn main() -> std::io::Result<()> {
    // Write sphere to an STL file
    manifold_rs::Manifold::sphere(4.0, 128).write_stl_to_file("sphere.stl")?;

    // Write cylinder to an STL file
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 4.0, 3.0, 32);

        // Convert the manifold to a mesh and back to a manifold, just for testing
        let mesh = manifold.to_mesh();
        let manifold = mesh.to_manifold();

        manifold.write_stl_to_file("cylinder.stl")?;
    }

    // Generate torus with `revolve` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let circle = generate_circle(2.0, (4.0, 0.0), 32);

        // Revolve the circle 360° around the z-axis
        let manifold = manifold_rs::Manifold::revolve(&[circle.as_slice()], 32, 360.0);

        manifold.write_stl_to_file("torus.stl")?;
    }

    // Generate a tube via `extrude` and write resulting mesh to an STL file
    {
        // Generate circle with 32 vertices
        let inner_circle = generate_circle(0.3, (0.0, 0.0), 32);
        let outer_circle = generate_circle(1.0, (0.0, 0.0), 32);

        // CCW winding order to create a hole in the tube
        let inner_circle = inner_circle
            .into_iter()
            .enumerate()
            .map(|(i, x)| if i % 2 == 0 { x } else { -x })
            .collect::<Vec<_>>();

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[outer_circle.as_slice(), inner_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );

        manifold.write_stl_to_file("tube.stl")?;
    }

    // Convex hull of two circles
    {
        let left_circle = generate_circle(1.0, (-1.0, 0.0), 32);
        let right_circle = generate_circle(1.0, (1.0, 0.0), 32);

        // Extrude the circle along the z-axis
        let manifold = manifold_rs::Manifold::extrude(
            &[left_circle.as_slice(), right_circle.as_slice()],
            4.0,
            16,
            0.0,
            1.0,
            1.0,
        );
        let manifold = manifold.hull();

        manifold.write_stl_to_file("hull.stl")?;
    }

    // Trim a cylinder by a plane
    {
        let manifold = manifold_rs::Manifold::cylinder(1.0, 1.0, 3.0, 32);
        let manifold = manifold.trim_by_plane(0.5, 0.5, 0.5, 0.0);

        manifold.write_stl_to_file("cylinder_trimmed.stl")?;
    }
    Ok(())
}

pub fn from_mesh(mesh: Mesh) -> Self

Create a manifold from a mesh.

Trait Implementations

impl From<Manifold> for Mesh

Convert Manifold to Mesh struct

fn from(manifold: Manifold) -> Self

Converts to this type from the input type.

impl From<Mesh> for Manifold

Convert Mesh to Manifold struct

fn from(mesh: Mesh) -> Self

Converts to this type from the input type.

impl WritePly for Manifold

fn write_ply(&self, writer: &mut impl Write) -> Result<()>

fn write_ply_to_file(&self, filename: impl AsRef<Path>) -> Result<()>

impl WriteStl for Manifold

fn write_stl(&self, writer: &mut impl Write) -> Result<()>

fn write_stl_to_file(&self, filename: impl AsRef<Path>) -> Result<()>