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
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::{
    super::{
        HexahedralFiniteElements, Remove, Scale, TetrahedralFiniteElements, Translate,
        TriangularFiniteElements,
    },
    ErrorWrapper,
    input::{read_finite_elements, read_segmentation},
    output::{write_finite_elements, write_segmentation},
};
use clap::Subcommand;

#[derive(Subcommand)]
pub enum ConvertSubcommand {
    /// Converts mesh file types (exo | inp | stl) -> (exo | mesh | stl | vtk)
    Mesh(ConvertMeshArgs),
    /// Converts segmentation file types (npy | spn) -> (npy | spn)
    Segmentation(ConvertSegmentationArgs),
}

#[derive(clap::Args)]
pub struct ConvertMeshArgs {
    #[command(subcommand)]
    pub subcommand: ConvertMeshSubcommand,
}

#[derive(Subcommand)]
pub enum ConvertMeshSubcommand {
    /// Converts an all-hexahedral mesh
    Hex(ConvertMeshSubcommandArgs),
    /// Converts an all-tetrahedral mesh
    Tet(ConvertMeshSubcommandArgs),
    /// Converts an all-triangular mesh
    Tri(ConvertMeshSubcommandArgs),
}

impl ConvertMeshSubcommand {
    pub fn is_quiet(&self) -> bool {
        match self {
            ConvertMeshSubcommand::Hex(args) => args.quiet,
            ConvertMeshSubcommand::Tet(args) => args.quiet,
            ConvertMeshSubcommand::Tri(args) => args.quiet,
        }
    }
}

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

    /// Mesh output file (exo | mesh | stl | vtk)
    #[arg(long, short, value_name = "FILE")]
    output: String,

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

#[derive(clap::Args)]
pub struct ConvertSegmentationArgs {
    /// Segmentation input file (npy | spn)
    #[arg(long, short, value_name = "FILE")]
    pub input: String,

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

    /// Number of voxels in the x-direction (spn)
    #[arg(long, short = 'x', value_name = "NEL")]
    pub nelx: Option<usize>,

    /// Number of voxels in the y-direction (spn)
    #[arg(long, short = 'y', value_name = "NEL")]
    pub nely: Option<usize>,

    /// Number of voxels in the z-direction (spn)
    #[arg(long, short = 'z', value_name = "NEL")]
    pub nelz: Option<usize>,

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

pub fn convert_mesh(subcommand: ConvertMeshSubcommand) -> Result<(), ErrorWrapper> {
    match subcommand {
        ConvertMeshSubcommand::Hex(args) => write_finite_elements(
            args.output,
            read_finite_elements::<_, _, _, HexahedralFiniteElements>(
                &args.input,
                args.quiet,
                true,
            )?,
            args.quiet,
        ),
        ConvertMeshSubcommand::Tet(args) => write_finite_elements(
            args.output,
            read_finite_elements::<_, _, _, TetrahedralFiniteElements>(
                &args.input,
                args.quiet,
                true,
            )?,
            args.quiet,
        ),
        ConvertMeshSubcommand::Tri(args) => write_finite_elements(
            args.output,
            read_finite_elements::<_, _, _, TriangularFiniteElements>(
                &args.input,
                args.quiet,
                true,
            )?,
            args.quiet,
        ),
    }
}

pub fn convert_segmentation(
    input: String,
    output: String,
    nelx: Option<usize>,
    nely: Option<usize>,
    nelz: Option<usize>,
    quiet: bool,
) -> Result<(), ErrorWrapper> {
    write_segmentation(
        output,
        read_segmentation(
            input,
            nelx,
            nely,
            nelz,
            Remove::default(),
            Scale::default(),
            Translate::default(),
            quiet,
            true,
        )?,
        quiet,
    )
}