dedup_mesh 0.2.0

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

use dedup_mesh::prelude::*;
mod test_common;
use crate::test_common::generate_test_data;

#[test]
fn test_simple_deduplication() {
    let vertices: Vec<[f32; 3]> = vec![
        [0.0, 0.0, 0.0],
        [0.001, 0.0, 0.0], // Within tolerance
        [1.0, 0.0, 0.0],
        [1.001, 0.0, 0.0], // Within tolerance
    ];
    let indices: Vec<usize> = vec![3, 1, 2, 0];
    let (vertices, indices) = dedup::<f32, usize, [f32; 3], SingleThreaded, PointCloud>(
        &vertices,
        &indices,
        0.01,
        PruneUnused,
        PruneDegenerate,
        CheckTolerance,
    )
    .unwrap();

    assert_eq!(vertices.len(), 2);
    assert_eq!(indices[0], 1);
    assert_eq!(indices[1], 0);
}

#[test]
fn test_no_duplicates() {
    use crate::{PointCloud, SingleThreaded};

    let vertices: Vec<[f32; 3]> = vec![[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [2.0, 0.0, 0.0]];
    let indices: Vec<usize> = vec![0, 1, 2];
    let (vertices, indices) = dedup::<f32, usize, [f32; 3], SingleThreaded, PointCloud>(
        &vertices,
        &indices,
        0.01,
        PruneUnused,
        PruneDegenerate,
        CheckTolerance,
    )
    .unwrap();

    assert_eq!(vertices.len(), 3);
    assert_eq!(indices, vec![0, 1, 2]);
}

#[test]
fn test_dedup_single_threaded() {
    let vertices = vec![
        [1.0, 2.0, 3.0],
        [1.0, 2.0, 3.0],       // Exact duplicate
        [1.0000001, 2.0, 3.0], // Near duplicate (within tolerance)
        [4.0, 5.0, 6.0],
    ];
    let indices: [usize; 0] = [];
    let tolerance = 0.001;

    let result = dedup::<f32, usize, [f32; 3], SingleThreaded, PointCloud>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        PruneDegenerate,
        CheckTolerance,
    )
    .unwrap();
    assert_eq!(result.0.len(), 2); // Should have 2 unique vertices
}

#[cfg(feature = "parallel")]
#[test]
fn test_dedup_multi_threaded_1() {
    let vertices = vec![
        [1.0, 2.0, 3.0],
        [1.0, 2.0, 3.0],       // Exact duplicate
        [1.0000001, 2.0, 3.0], // Near duplicate (within tolerance)
        [4.0, 5.0, 6.0],
    ];

    let indices: [usize; 0] = [];
    let tolerance = 0.001;

    let result = dedup::<f32, usize, [f32; 3], MultiThreaded, PointCloud>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        PruneDegenerate,
        CheckTolerance,
    )
    .unwrap();
    assert_eq!(result.0.len(), 2); // Should have 2 unique vertices
    assert_eq!(result.1.len(), 0); // Should have 0 indices
}

#[cfg(feature = "parallel")]
#[test]
fn test_dedup_multi_threaded_2() {
    let vertices = generate_test_data(1000);
    assert_eq!(vertices.len(), 1000);
    let indices: Vec<usize> = (0..800).collect();
    let tolerance = 0.001;

    let result = dedup::<f32, usize, [f32; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        PruneUnused,
        PruneDegenerate,
        CheckTolerance,
    )
    .unwrap();

    assert_eq!(result.0.len(), 800);
    assert_eq!(result.1.len(), 798);
}

#[cfg(feature = "parallel")]
#[should_panic]
#[test]
fn test_dedup_multi_threaded_4() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, f32::NAN, 0.0]);
    let tolerance = 0.001;

    let _ = dedup::<f32, usize, [f32; 3], MultiThreaded, Triangulated>(
        &vertices,
        &[],
        tolerance,
        KeepUnused,
        PruneDegenerate,
        CheckTolerance,
    )
    .unwrap();
}

#[test]
fn test_dedup_multi_threaded_6() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 1000.0, 0.0]);
    let tolerance = 0.001;

    let result = dedup::<f32, usize, [f32; 3], MultiThreaded, Triangulated>(
        &vertices,
        &[],
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();

    assert_eq!(result.0.len(), 11);
    assert_eq!(result.1.len(), 0);
}

#[test]
fn test_dedup_multi_threaded_7() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 0.0, 1000.0]);
    let tolerance = 0.001;

    let result = dedup::<f32, usize, [f32; 3], MultiThreaded, Triangulated>(
        &vertices,
        &[],
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();

    assert_eq!(result.0.len(), 11);
    assert_eq!(result.1.len(), 0);
}

#[should_panic]
#[test]
fn test_dedup_multi_threaded_5() {
    let mut vertices = generate_test_data(100);
    let indices: Vec<usize> = (0..101).collect();
    vertices.push([0.0, f32::NAN, 0.0]);
    let tolerance = 0.001;

    let result = dedup::<f32, usize, [f32; 3], MultiThreaded, PointCloud>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        PruneDegenerate,
        CheckTolerance,
    );
    if let Err(error) = result {
        println!("{error}");
        panic!("should panic");
    }
}

#[test]
fn test_dedup_multi_threaded_8() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 1000.0, 0.0]);
    let mut indices: Vec<usize> = (0..10).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    let result = dedup::<f32, usize, [f32; 3], MultiThreaded, Edges>(
        &vertices,
        &indices,
        tolerance,
        PruneUnused,
        PruneDegenerate,
        CheckTolerance,
    )
    .unwrap();

    assert_eq!(result.0.len(), 10);
    assert_eq!(result.1.len(), 14);
}

#[test]
fn test_dedup_multi_threaded_9() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 1000.0, 0.0]);
    let mut indices: Vec<usize> = (0..10).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    let result = dedup::<f64, usize, [f64; 3], MultiThreaded, Edges>(
        &vertices,
        &indices,
        tolerance,
        PruneUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();

    assert_eq!(result.0.len(), 10);
    assert_eq!(result.1.len(), 14);
}

#[test]
fn test_dedup_multi_threaded_10() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 1000.0, 0.0]);
    let mut indices: Vec<usize> = (0..10).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    let result = dedup::<f64, usize, [f64; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        PruneUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();

    assert_eq!(result.0.len(), 10);
    assert_eq!(result.1.len(), 12);
}

#[test]
fn test_dedup_multi_threaded_11() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);

    let mut indices: Vec<usize> = (0..2).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    let result = dedup::<f64, usize, [f64; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        PruneUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();

    assert_eq!(result.0.len(), 4);
    assert_eq!(result.1.len(), 6);
}

#[should_panic]
#[test]
fn test_dedup_multi_threaded_12() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices[0] = [0.0, f64::NAN, 0.0];
    let mut indices: Vec<usize> = (0..2).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    dedup::<f64, usize, [f64; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        PruneUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
}

#[should_panic]
#[test]
fn test_dedup_multi_threaded_3() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices[0] = [0.0, f64::NAN, 0.0];
    let mut indices: Vec<usize> = (0..2).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    dedup::<f64, usize, [f64; 3], SingleThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
}

#[should_panic]
#[test]
fn test_dedup_multi_threaded_13() {
    let mut vertices = generate_test_data::<f64>(10);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices[0] = [0.0, 18014398509481984.0, 0.0];
    let mut indices: Vec<usize> = (0..2).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    dedup::<f64, usize, [f64; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
}

#[test]
fn test_dedup_multi_threaded_14() {
    let mut vertices = generate_test_data::<f64>(1);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, -180143985094818.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices[0] = [0.0, 180143985094818.0, 0.0];
    vertices[1] = [0.0, 180143985094818.009, 0.0];
    vertices[2] = [0.0, 180143985094718.1, 0.0];
    vertices.push([0.0, 0.0, 10.0]);

    let mut indices: Vec<usize> = (0..2).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.01;

    let (vertices, indices) = dedup::<f64, usize, [f64; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
    assert_eq!(vertices.len(), 4);
    assert_eq!(indices.len(), 6);
}

#[should_panic]
#[test]
fn test_dedup_multi_threaded_15() {
    let vertices = generate_test_data::<f64>(10);
    let mut indices: Vec<usize> = (0..2).collect();
    indices.push(100);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    dedup::<f64, usize, [f64; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        PruneUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
}

#[should_panic]
#[test]
fn test_dedup_multi_threaded_16() {
    let mut vertices = generate_test_data::<f32>(10);
    vertices.push([0.0, -335545.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices[0] = [0.0, 335545.0, 0.0];
    let mut indices: Vec<usize> = (0..2).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    dedup::<f32, usize, [f32; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
}

#[test]
fn test_dedup_multi_threaded_17() {
    let mut vertices = generate_test_data::<f32>(1);
    vertices.push([0.0, 0.0, 0.0]);
    vertices.push([0.0, 10000.001, 10.0]);
    vertices.push([0.0, -335543.0, 10.0]);
    vertices[0] = [0.0, 335544.0, 0.0];
    vertices[1] = [0.0, 335544.009, 0.0];
    vertices[2] = [0.0, 335544.1, 0.0];
    vertices.push([0.0, 0.0, 10.0]);

    let mut indices: Vec<usize> = (0..2).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.01;

    let (vertices, indices) = dedup::<f32, usize, [f32; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
    assert_eq!(vertices.len(), 4);
    assert_eq!(indices.len(), 6);
}

#[test]
fn test_dedup_too_little_data_1() {
    let mut vertices: Vec<[f64; 3]> = vec![[1.0, 10000.0, 10.0]];
    vertices.push([2.0, 10000.0, 10.0]);
    vertices.push([3.0, 10000.0, 10.0]);
    let indices: Vec<usize> = vec![0, 1];
    let tolerance = 0.001;

    let result = dedup::<f64, usize, [f64; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        PruneUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
    assert_eq!(result.0.len(), 0);
    assert_eq!(result.1.len(), 0);
}

#[test]
fn test_dedup_too_little_data_2() {
    let mut vertices: Vec<[f64; 3]> = vec![[1.0, 10000.0, 10.0]];
    vertices.push([2.0, 10000.0, 10.0]);
    vertices.push([3.0, 10000.0, 10.0]);
    let indices: Vec<usize> = vec![0, 1];
    let tolerance = 0.001;

    let result = dedup::<f64, usize, [f64; 3], MultiThreaded, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
    assert_eq!(result.0.len(), 3);
    assert_eq!(result.1.len(), 0);
}

#[test]
fn test_dedup_too_little_data_3() {
    let mut vertices: Vec<[f64; 3]> = vec![[1.0, 10000.0, 10.0]];
    vertices.push([2.0, 10000.0, 10.0]);
    vertices.push([3.0, 10000.0, 10.0]);
    let indices: Vec<usize> = vec![0];
    let tolerance = 0.001;

    let result = dedup::<f64, usize, [f64; 3], MultiThreaded, Edges>(
        &vertices,
        &indices,
        tolerance,
        PruneUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
    assert_eq!(result.0.len(), 0);
    assert_eq!(result.1.len(), 0);
}

#[test]
fn test_dedup_too_little_data_4() {
    let mut vertices: Vec<[f64; 3]> = vec![[1.0, 10000.0, 10.0]];
    vertices.push([2.0, 10000.0, 10.0]);
    vertices.push([3.0, 10000.0, 10.0]);
    let indices: Vec<usize> = vec![0];
    let tolerance = 0.001;

    let result = dedup::<f64, usize, [f64; 3], MultiThreaded, Edges>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
    assert_eq!(result.0.len(), 3);
    assert_eq!(result.1.len(), 0);
}

#[test]
fn test_dedup_auto_threaded_1() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    let mut indices: Vec<u32> = (0..2).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    dedup::<f64, u32, [f64; 3], Auto, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
}

#[test]
fn test_dedup_auto_threaded_2() {
    let mut vertices = generate_test_data(10);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    vertices.push([0.0, 10000.0, 10.0]);
    let mut indices: Vec<u16> = (0..2).collect();
    indices.push(0);
    indices.push(1);
    indices.push(2);
    indices.push(3);
    let tolerance = 0.001;

    dedup::<f64, u16, [f64; 3], Auto, Triangulated>(
        &vertices,
        &indices,
        tolerance,
        KeepUnused,
        KeepDegenerate,
        CheckTolerance,
    )
    .unwrap();
}