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

use super::ErrorWrapper;
use automesh::{FiniteElementMethods, Tessellation, Voxels};
use std::{path::Path, time::Instant};

pub fn invalid_output(file: &str, extension: Option<&str>) -> ErrorWrapper {
    ErrorWrapper {
        message: format!(
            "Invalid extension .{} from output file {}",
            extension.unwrap_or("UNDEFINED"),
            file
        ),
    }
}

pub fn validate_output(command: &str, file: &str) -> Result<(), ErrorWrapper> {
    let extension = Path::new(file).extension().and_then(|ext| ext.to_str());
    match command {
        "mesh" => match extension {
            Some("inp") | Some("exo") | Some("mesh") | Some("stl") | Some("vtk") => Ok(()),
            _ => Err(invalid_output(file, extension)),
        },
        _ => panic!(),
    }
}

pub fn write_finite_elements<const M: usize, const N: usize, const O: usize, T>(
    file: String,
    finite_elements: T,
    quiet: bool,
) -> Result<(), ErrorWrapper>
where
    T: FiniteElementMethods<M, N, O>,
    Tessellation: From<T>,
{
    let time = Instant::now();
    if !quiet {
        println!("     \x1b[1;96mWriting\x1b[0m {file}");
    }
    let extension = Path::new(&file).extension().and_then(|ext| ext.to_str());
    match extension {
        Some("inp") => finite_elements.write_inp(&file)?,
        Some("exo") => finite_elements.write_exo(&file)?,
        Some("mesh") => finite_elements.write_mesh(&file)?,
        Some("stl") => Tessellation::from(finite_elements).write_stl(&file)?,
        Some("vtk") => finite_elements.write_vtk(&file)?,
        _ => return Err(invalid_output(&file, extension)),
    }
    if !quiet {
        println!("        \x1b[1;92mDone\x1b[0m {:?}", time.elapsed());
    }
    Ok(())
}

pub fn write_metrics<const M: usize, const N: usize, const O: usize, T>(
    fem: &T,
    output: String,
    quiet: bool,
) -> Result<(), ErrorWrapper>
where
    T: FiniteElementMethods<M, N, O>,
{
    let time = Instant::now();
    if !quiet {
        println!("     \x1b[1;96mMetrics\x1b[0m {output}");
    }
    fem.write_metrics(&output)?;
    if !quiet {
        println!("        \x1b[1;92mDone\x1b[0m {:?}", time.elapsed());
    }
    Ok(())
}

pub fn write_segmentation(file: String, voxels: Voxels, quiet: bool) -> Result<(), ErrorWrapper> {
    let time = Instant::now();
    if !quiet {
        println!("     \x1b[1;96mWriting\x1b[0m {file}");
    }
    let extension = Path::new(&file).extension().and_then(|ext| ext.to_str());
    match extension {
        Some("npy") => voxels.write_npy(&file)?,
        Some("spn") => voxels.write_spn(&file)?,
        _ => return Err(invalid_output(&file, extension)),
    }
    if !quiet {
        println!("        \x1b[1;92mDone\x1b[0m {:?}", time.elapsed());
    }
    Ok(())
}