dedup_mesh 0.2.0

Deduplicates vertices in a 3d mesh
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

// SPDX-License-Identifier: MIT OR Apache-2.0
// Copyright (c) 2025 lacklustr@protonmail.com https://github.com/eadf

use crate::Auto;
use crate::threading::{CompatibleWith, ThreadingDispatch};
use crate::{
    CheckFinitePolicy, DeDupError, IndexType, MultiThreaded, PruneDegenerateEnum, PruneUnusedEnum,
    Scalar, SingleThreaded, ToleranceEnum, TopologyPolicy,
};
use num_traits::AsPrimitive;

impl ThreadingDispatch for Auto {
    /// this dispatch calls either SingleThreaded or MultiThreaded, depending on simple mesh heuristics.
    fn dedup_dispatch<T, Index, Vout, Topology>(
        vertices: &[impl Into<[T; 3]> + Clone + Sync],
        indices: &[Index],
        tolerance: T,
        prune_unused: PruneUnusedEnum,
        prune_degenerate: PruneDegenerateEnum,
        tolerance_policy: ToleranceEnum,
    ) -> Result<(Vec<Vout>, Vec<Index>), DeDupError>
    where
        T: Scalar,
        Index: IndexType,
        Vout: Into<[T; 3]> + From<[T; 3]> + Clone + Sync,
        Topology: TopologyPolicy,
        usize: AsPrimitive<T>,
    {
        if vertices.len() < 2000 {
            SingleThreaded::dedup_dispatch::<T, Index, Vout, Topology>(
                vertices,
                indices,
                tolerance,
                prune_unused,
                prune_degenerate,
                tolerance_policy,
            )
        } else {
            MultiThreaded::dedup_dispatch::<T, Index, Vout, Topology>(
                vertices,
                indices,
                tolerance,
                prune_unused,
                prune_degenerate,
                tolerance_policy,
            )
        }
    }

    fn dedup_exact_dispatch<T, Index: IndexType, Vout, Topology, CheckFinite>(
        vertices: &[impl Into<[T; 3]> + Clone + Sync],
        indices: &[Index],
        prune_unused: PruneUnusedEnum,
        prune_degenerate: PruneDegenerateEnum,
    ) -> Result<(Vec<Vout>, Vec<Index>), DeDupError>
    where
        T: Scalar,
        Topology: TopologyPolicy,
        Vout: Into<[T; 3]> + From<[T; 3]> + Clone + Sync,
        CheckFinite: CheckFinitePolicy,
    {
        SingleThreaded::dedup_exact_dispatch::<T, Index, Vout, Topology, CheckFinite>(
            vertices,
            indices,
            prune_unused,
            prune_degenerate,
        )
    }
}

impl<F: CheckFinitePolicy> CompatibleWith<F> for Auto {}