automesh 0.4.0

Automatic mesh generation.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use super::{
    ErrorWrapper,
    io::{read_mesh, write_mesh},
};
use clap::Subcommand;
use conspire::geometry::mesh::{IsotropicSizing, Mesh, Remeshing, RemeshingMetric};
use std::time::Instant;

pub const REMESH_DEFAULT_ITERS: usize = 5;
pub const ADAPTIVE_DEFAULT_TOLERANCE: f64 = 0.1;
pub const ADAPTIVE_DEFAULT_GRADATION: f64 = 0.5;

#[derive(Subcommand, Debug)]
pub enum MeshRemeshSubcommand {
    /// Applies remeshing to the mesh before output [default mode: uniform]
    Remesh {
        /// Sizing mode [default: uniform]
        #[command(subcommand)]
        mode: Option<MeshRemeshCommands>,
    },
}

#[derive(Subcommand, Debug)]
pub enum MeshRemeshCommands {
    /// Uniform target edge length over the whole mesh
    Uniform {
        /// Number of remeshing iterations
        #[arg(default_value_t = REMESH_DEFAULT_ITERS, long, short = 'n', value_name = "NUM")]
        iterations: usize,

        /// Target edge length [default: mean edge length]
        #[arg(long, short = 's', value_name = "SIZE")]
        size: Option<f64>,
    },

    /// Curvature-adaptive target edge length
    Adaptive {
        /// Number of remeshing iterations
        #[arg(default_value_t = REMESH_DEFAULT_ITERS, long, short = 'n', value_name = "NUM")]
        iterations: usize,

        /// Minimum edge length
        #[arg(long, value_name = "MIN")]
        minimum: f64,

        /// Maximum edge length
        #[arg(long, value_name = "MAX")]
        maximum: f64,

        /// Curvature tolerance
        #[arg(default_value_t = ADAPTIVE_DEFAULT_TOLERANCE, long, short = 't', value_name = "TOL")]
        tolerance: f64,

        /// Size gradation factor
        #[arg(default_value_t = ADAPTIVE_DEFAULT_GRADATION, long, short = 'g', value_name = "GRAD")]
        gradation: f64,
    },
}

pub fn remesh(
    input: String,
    output: String,
    mode: Option<MeshRemeshCommands>,
    quiet: bool,
) -> Result<(), ErrorWrapper> {
    let mesh = read_mesh(&input, quiet, true)?;
    let mesh = apply_remeshing(mesh, mode_or_default(mode), quiet)?;
    write_mesh(&output, mesh, quiet)
}

fn mode_or_default(mode: Option<MeshRemeshCommands>) -> MeshRemeshCommands {
    mode.unwrap_or(MeshRemeshCommands::Uniform {
        iterations: REMESH_DEFAULT_ITERS,
        size: None,
    })
}

pub fn apply_remesh_subcommand(
    mesh: Mesh<3>,
    subcommand: MeshRemeshSubcommand,
    quiet: bool,
) -> Result<Mesh<3>, ErrorWrapper> {
    let MeshRemeshSubcommand::Remesh { mode } = subcommand;
    apply_remeshing(mesh, mode_or_default(mode), quiet)
}

pub fn apply_remeshing(
    mesh: Mesh<3>,
    mode: MeshRemeshCommands,
    quiet: bool,
) -> Result<Mesh<3>, ErrorWrapper> {
    let time = Instant::now();
    let remeshing = match mode {
        MeshRemeshCommands::Uniform { iterations, size } => {
            match size {
                Some(length) => crate::echo!(
                    quiet,
                    "   \x1b[1;96mRemeshing\x1b[0m with {iterations} iterations of uniform sizing \
                    (target edge length {length})"
                ),
                None => crate::echo!(
                    quiet,
                    "   \x1b[1;96mRemeshing\x1b[0m with {iterations} iterations of uniform sizing"
                ),
            }
            Remeshing {
                iterations,
                metric: RemeshingMetric::Isotropic(IsotropicSizing::Uniform { length: size }),
            }
        }
        MeshRemeshCommands::Adaptive {
            iterations,
            minimum,
            maximum,
            tolerance,
            gradation,
        } => {
            crate::echo!(
                quiet,
                "   \x1b[1;96mRemeshing\x1b[0m with {iterations} iterations of adaptive sizing \
                (edge length {minimum}\u{2013}{maximum}, tolerance {tolerance}, gradation {gradation})"
            );
            Remeshing {
                iterations,
                metric: RemeshingMetric::Isotropic(IsotropicSizing::Adaptive {
                    tolerance,
                    minimum,
                    maximum,
                    gradation,
                }),
            }
        }
    };
    let mesh = mesh.remesh(remeshing)?;
    crate::echo!(
        quiet,
        "        \x1b[1;92mDone\x1b[0m {:?} \x1b[2m[{} elements, {} nodes]\x1b[0m",
        time.elapsed(),
        mesh.number_of_elements(),
        mesh.number_of_nodes()
    );
    Ok(mesh)
}