automesh 0.3.9

Automatic mesh generation.
Documentation 
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

use super::{
    ErrorWrapper,
    input::read_finite_elements,
    mesh::{MeshBasis, mesh_print_info},
    output::{invalid_output, write_finite_elements, write_segmentation},
};
use automesh::{FiniteElementMethods, Tessellation, Voxels};
use clap::Subcommand;
use conspire::math::Tensor;
use std::{path::Path, time::Instant};

#[derive(Subcommand)]
pub enum SegmentSubcommand {
    /// Segments an all-hexahedral mesh
    Hex(SegmentArgs),
    /// Segments an all-tetrahedral mesh
    Tet(SegmentArgs),
    /// Segments an all-triangular mesh
    Tri(SegmentArgs),
}

#[derive(clap::Args)]
pub struct SegmentArgs {
    /// Mesh input file (exo | inp)
    #[arg(long, short, value_name = "FILE")]
    pub input: String,

    /// Segmentation (npy | spn) or mesh (exo | inp) output file
    #[arg(long, short, value_name = "FILE")]
    pub output: String,

    /// Grid length for sampling within each element
    #[arg(default_value_t = 1, long, short = 'g', value_name = "NUM")]
    pub grid: usize,

    /// Element size which is the side length
    #[arg(long, short = 's', value_name = "NUM")]
    pub size: f64,

    /// Block IDs to remove from the mesh
    #[arg(long, num_args = 1.., short, value_delimiter = ' ', value_name = "ID")]
    pub remove: Option<Vec<usize>>,

    /// Pass to quiet the terminal output
    #[arg(action, long, short)]
    pub quiet: bool,
}

pub fn segment<
    const M1: usize,
    const N1: usize,
    const O1: usize,
    T,
    const M2: usize,
    const N2: usize,
    const O2: usize,
    U,
>(
    input: String,
    output: String,
    grid: usize,
    size: f64,
    remove: Option<Vec<usize>>,
    quiet: bool,
) -> Result<(), ErrorWrapper>
where
    T: FiniteElementMethods<M1, N1, O1> + From<Tessellation>,
    U: FiniteElementMethods<M2, N2, O2> + From<Voxels>,
    Tessellation: From<U>,
{
    let finite_elements = read_finite_elements::<_, _, _, T>(&input, quiet, true)?;
    let mut time = Instant::now();
    if !quiet {
        println!("  \x1b[1;96mSegmenting\x1b[0m from finite elements")
    }
    let mut voxels = Voxels::from_finite_elements(finite_elements, grid, size);
    voxels.extend_removal(remove.into());
    if !quiet {
        println!("        \x1b[1;92mDone\x1b[0m {:?}", time.elapsed());
        time = Instant::now()
    }
    let extension = Path::new(&output).extension().and_then(|ext| ext.to_str());
    match extension {
        Some("exo") | Some("inp") => {
            if !quiet {
                print!("     \x1b[1;96mMeshing\x1b[0m voxels into hexahedra");
                mesh_print_info(
                    MeshBasis::Voxels,
                    voxels.get_scale(),
                    voxels.get_translate(),
                )
            }
            let finite_elements = U::from(voxels);
            if !quiet {
                let mut blocks = finite_elements.get_element_blocks().clone();
                let elements = blocks.len();
                blocks.sort();
                blocks.dedup();
                println!(
                    "        \x1b[1;92mDone\x1b[0m {:?} \x1b[2m[{} blocks, {} elements, {} nodes]\x1b[0m",
                    time.elapsed(),
                    blocks.len(),
                    elements,
                    finite_elements.get_nodal_coordinates().len()
                );
            }
            write_finite_elements(output, finite_elements, quiet)
        }
        Some("npy") | Some("spn") => write_segmentation(output, voxels, quiet),
        _ => Err(invalid_output(&output, extension)),
    }
}