lithop 0.2.0 → 0.4.0

data/ext/lithop_native/src/column_mesh.rs

@@ -0,0 +1,388 @@
+use crate::mesh::{index_mesh_vertex, MeshBuilder, MeshData, VertexKey};
+use crate::COMPONENTS;
+use magnus::{Error, Ruby};
+
+struct ColumnMeshInput<'a> {
+    columns: usize,
+    rows: usize,
+    x_boundaries: &'a [f64],
+    y_boundaries: &'a [f64],
+    z_boundaries: &'a [f64],
+    intervals: Vec<Option<(usize, usize)>>,
+    group_ids: &'a [usize],
+    group_count: usize,
+}
+
+impl ColumnMeshInput<'_> {
+    fn interval_at(&self, row: isize, column: isize) -> Option<(usize, usize)> {
+        if row < 0 || column < 0 || row as usize >= self.rows || column as usize >= self.columns {
+            return None;
+        }
+        self.intervals[row as usize * self.columns + column as usize]
+    }
+
+    fn group_at(&self, row: isize, column: isize) -> usize {
+        if row < 0 || column < 0 || row as usize >= self.rows || column as usize >= self.columns {
+            return 0;
+        }
+        self.group_ids[row as usize * self.columns + column as usize]
+    }
+
+    fn grouped_interval(
+        &self,
+        row: usize,
+        column: usize,
+        neighbour_row: isize,
+        neighbour_column: isize,
+    ) -> Option<(usize, usize)> {
+        if self.group_at(row as isize, column as isize)
+            != self.group_at(neighbour_row, neighbour_column)
+        {
+            return None;
+        }
+        self.interval_at(neighbour_row, neighbour_column)
+    }
+
+    fn occupied(&self, layer: isize, row: isize, column: isize, group: usize) -> bool {
+        if layer < 0 || self.group_at(row, column) != group {
+            return false;
+        }
+        self.interval_at(row, column)
+            .is_some_and(|(bottom, top)| layer as usize >= bottom && (layer as usize) < top)
+    }
+}
+
+pub(crate) fn column_mesh(
+    ruby: &Ruby,
+    columns: usize,
+    rows: usize,
+    x_boundaries: Vec<f64>,
+    y_boundaries: Vec<f64>,
+    z_boundaries: Vec<f64>,
+    raw_intervals: Vec<i64>,
+    group_ids: Vec<usize>,
+    group_count: usize,
+) -> Result<MeshBuilder, Error> {
+    let expected_cells = columns.saturating_mul(rows);
+    let valid = columns > 0
+        && rows > 0
+        && x_boundaries.len() == columns + 1
+        && y_boundaries.len() == rows + 1
+        && z_boundaries.len() >= 2
+        && raw_intervals.len() == expected_cells * 2
+        && group_ids.len() == expected_cells
+        && group_count > 0
+        && x_boundaries.iter().all(|value| value.is_finite())
+        && y_boundaries.iter().all(|value| value.is_finite())
+        && z_boundaries.iter().all(|value| value.is_finite());
+    if !valid {
+        return Err(Error::new(
+            ruby.exception_arg_error(),
+            "invalid native column mesh input",
+        ));
+    }
+    let maximum_vertices_per_cell =
+        8_usize.saturating_add(16_usize.saturating_mul(z_boundaries.len().saturating_sub(1)));
+    if expected_cells.saturating_mul(maximum_vertices_per_cell) > u32::MAX as usize {
+        return Err(Error::new(
+            ruby.exception_arg_error(),
+            "native column mesh contains too many vertices",
+        ));
+    }
+
+    let intervals = raw_intervals
+        .chunks_exact(2)
+        .map(|pair| match pair {
+            [-1, -1] => Ok(None),
+            [bottom, top] if *bottom >= 0 && *top > *bottom && *top < z_boundaries.len() as i64 => {
+                Ok(Some((*bottom as usize, *top as usize)))
+            }
+            _ => Err(Error::new(
+                ruby.exception_arg_error(),
+                "invalid native column interval",
+            )),
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let input = ColumnMeshInput {
+        columns,
+        rows,
+        x_boundaries: &x_boundaries,
+        y_boundaries: &y_boundaries,
+        z_boundaries: &z_boundaries,
+        intervals,
+        group_ids: &group_ids,
+        group_count,
+    };
+    let mut data = MeshData::default();
+    data.triangles.reserve_exact(column_triangle_count(&input));
+    for row in 0..rows {
+        for column in 0..columns {
+            let Some(current) = input.interval_at(row as isize, column as isize) else {
+                continue;
+            };
+            emit_column_caps(&mut data, &input, row, column, current);
+            emit_column_sides(&mut data, &input, row, column, current);
+        }
+    }
+    Ok(MeshBuilder::from_data(data))
+}
+
+type ColumnOwner = (usize, usize, usize);
+
+fn column_triangle_count(input: &ColumnMeshInput<'_>) -> usize {
+    let mut count = 0;
+    for row in 0..input.rows {
+        for column in 0..input.columns {
+            let Some(current) = input.interval_at(row as isize, column as isize) else {
+                continue;
+            };
+            count += 4;
+            count += 2 * [
+                (row as isize, column as isize - 1),
+                (row as isize, column as isize + 1),
+                (row as isize + 1, column as isize),
+                (row as isize - 1, column as isize),
+            ]
+            .into_iter()
+            .map(|(neighbour_row, neighbour_column)| {
+                exposed_layer_count(
+                    current,
+                    input.grouped_interval(row, column, neighbour_row, neighbour_column),
+                )
+            })
+            .sum::<usize>();
+        }
+    }
+    count
+}
+
+fn emit_column_caps(
+    data: &mut MeshData,
+    input: &ColumnMeshInput<'_>,
+    row: usize,
+    column: usize,
+    current: (usize, usize),
+) {
+    let (bottom, top) = current;
+    let bottom_owner = (bottom, row, column);
+    let top_owner = (top - 1, row, column);
+    emit_column_quad(
+        data,
+        [
+            column_vertex(input, column, row + 1, bottom, bottom_owner),
+            column_vertex(input, column, row, bottom, bottom_owner),
+            column_vertex(input, column + 1, row, bottom, bottom_owner),
+            column_vertex(input, column + 1, row + 1, bottom, bottom_owner),
+        ],
+    );
+    emit_column_quad(
+        data,
+        [
+            column_vertex(input, column, row + 1, top, top_owner),
+            column_vertex(input, column + 1, row + 1, top, top_owner),
+            column_vertex(input, column + 1, row, top, top_owner),
+            column_vertex(input, column, row, top, top_owner),
+        ],
+    );
+}
+
+fn emit_column_sides(
+    data: &mut MeshData,
+    input: &ColumnMeshInput<'_>,
+    row: usize,
+    column: usize,
+    current: (usize, usize),
+) {
+    for layer in exposed_layers(
+        current,
+        input.grouped_interval(row, column, row as isize, column as isize - 1),
+    ) {
+        let owner = (layer, row, column);
+        emit_column_quad(
+            data,
+            [
+                column_vertex(input, column, row + 1, layer, owner),
+                column_vertex(input, column, row + 1, layer + 1, owner),
+                column_vertex(input, column, row, layer + 1, owner),
+                column_vertex(input, column, row, layer, owner),
+            ],
+        );
+    }
+    for layer in exposed_layers(
+        current,
+        input.grouped_interval(row, column, row as isize, column as isize + 1),
+    ) {
+        let owner = (layer, row, column);
+        emit_column_quad(
+            data,
+            [
+                column_vertex(input, column + 1, row + 1, layer, owner),
+                column_vertex(input, column + 1, row, layer, owner),
+                column_vertex(input, column + 1, row, layer + 1, owner),
+                column_vertex(input, column + 1, row + 1, layer + 1, owner),
+            ],
+        );
+    }
+    for layer in exposed_layers(
+        current,
+        input.grouped_interval(row, column, row as isize + 1, column as isize),
+    ) {
+        let owner = (layer, row, column);
+        emit_column_quad(
+            data,
+            [
+                column_vertex(input, column, row + 1, layer, owner),
+                column_vertex(input, column + 1, row + 1, layer, owner),
+                column_vertex(input, column + 1, row + 1, layer + 1, owner),
+                column_vertex(input, column, row + 1, layer + 1, owner),
+            ],
+        );
+    }
+    for layer in exposed_layers(
+        current,
+        input.grouped_interval(row, column, row as isize - 1, column as isize),
+    ) {
+        let owner = (layer, row, column);
+        emit_column_quad(
+            data,
+            [
+                column_vertex(input, column, row, layer, owner),
+                column_vertex(input, column, row, layer + 1, owner),
+                column_vertex(input, column + 1, row, layer + 1, owner),
+                column_vertex(input, column + 1, row, layer, owner),
+            ],
+        );
+    }
+}
+
+fn exposed_layers(current: (usize, usize), neighbour: Option<(usize, usize)>) -> Vec<usize> {
+    let (bottom, top) = current;
+    let Some((neighbour_bottom, neighbour_top)) = neighbour else {
+        return (bottom..top).collect();
+    };
+    if neighbour_top <= bottom || neighbour_bottom >= top {
+        return (bottom..top).collect();
+    }
+    let mut layers = Vec::new();
+    if neighbour_bottom > bottom {
+        layers.extend(bottom..top.min(neighbour_bottom));
+    }
+    if neighbour_top < top {
+        layers.extend(bottom.max(neighbour_top)..top);
+    }
+    layers
+}
+
+fn exposed_layer_count(current: (usize, usize), neighbour: Option<(usize, usize)>) -> usize {
+    let (bottom, top) = current;
+    let Some((neighbour_bottom, neighbour_top)) = neighbour else {
+        return top - bottom;
+    };
+    if neighbour_top <= bottom || neighbour_bottom >= top {
+        return top - bottom;
+    }
+    neighbour_bottom.saturating_sub(bottom).min(top - bottom)
+        + top.saturating_sub(neighbour_top).min(top - bottom)
+}
+
+fn column_vertex(
+    input: &ColumnMeshInput<'_>,
+    x_index: usize,
+    row_boundary: usize,
+    z_index: usize,
+    owner: ColumnOwner,
+) -> ([f64; COMPONENTS], VertexKey) {
+    let (_, owner_row, owner_column) = owner;
+    let group = input.group_at(owner_row as isize, owner_column as isize);
+    let coordinate_key =
+        ((x_index * (input.rows + 1) + row_boundary) * input.z_boundaries.len()) + z_index;
+    let cache_key = coordinate_key * input.group_count + group;
+    let mask = occupancy_mask(input, x_index, row_boundary, z_index, group);
+    let owner_bit = owner_bit(owner, x_index, row_boundary, z_index);
+    let component = component_root(mask, owner_bit);
+    let topology = cache_key * 8 + component;
+    let point = [
+        input.x_boundaries[x_index],
+        input.y_boundaries[input.y_boundaries.len() - 1] - input.y_boundaries[row_boundary],
+        input.z_boundaries[z_index],
+    ];
+    (point, VertexKey::Topology(topology as i64))
+}
+
+fn occupancy_mask(
+    input: &ColumnMeshInput<'_>,
+    x_index: usize,
+    row_boundary: usize,
+    z_index: usize,
+    group: usize,
+) -> u8 {
+    let mut mask = 0;
+    for layer_offset in 0..2 {
+        for row_offset in 0..2 {
+            for column_offset in 0..2 {
+                let bit = layer_offset * 4 + row_offset * 2 + column_offset;
+                if input.occupied(
+                    z_index as isize - 1 + layer_offset as isize,
+                    row_boundary as isize - 1 + row_offset as isize,
+                    x_index as isize - 1 + column_offset as isize,
+                    group,
+                ) {
+                    mask |= 1 << bit;
+                }
+            }
+        }
+    }
+    mask
+}
+
+fn owner_bit(owner: ColumnOwner, x_index: usize, row_boundary: usize, z_index: usize) -> usize {
+    let (layer, row, column) = owner;
+    ((layer as isize - z_index as isize + 1) * 4
+        + (row as isize - row_boundary as isize + 1) * 2
+        + column as isize
+        - x_index as isize
+        + 1) as usize
+}
+
+fn component_root(mask: u8, start: usize) -> usize {
+    let mut visited = [false; 8];
+    let mut pending = [0; 8];
+    pending[0] = start;
+    let mut pending_count = 1;
+    visited[start] = true;
+    let mut root = start;
+    while pending_count > 0 {
+        pending_count -= 1;
+        let current = pending[pending_count];
+        root = root.min(current);
+        for candidate in 0..8 {
+            let difference = current ^ candidate;
+            if !visited[candidate]
+                && mask & (1 << candidate) != 0
+                && matches!(difference, 1 | 2 | 4)
+            {
+                visited[candidate] = true;
+                pending[pending_count] = candidate;
+                pending_count += 1;
+            }
+        }
+    }
+    root
+}
+
+fn emit_column_quad(data: &mut MeshData, vertices: [([f64; COMPONENTS], VertexKey); 4]) {
+    let indices = vertices.map(|(point, key)| index_mesh_vertex(data, point, key));
+    data.triangles.push([indices[0], indices[1], indices[2]]);
+    data.triangles.push([indices[0], indices[2], indices[3]]);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::component_root;
+
+    #[test]
+    fn finds_face_connected_voxel_components_without_joining_diagonals() {
+        assert_eq!(component_root(0b0000_0011, 1), 0);
+        assert_eq!(component_root(0b1000_0001, 7), 7);
+    }
+}

data/ext/lithop_native/src/lib.rs

@@ -0,0 +1,37 @@
+mod column_mesh;
+mod mesh;
+mod palette;
+mod xml;
+
+use column_mesh::column_mesh;
+use magnus::{function, method, prelude::*, Error, Ruby};
+use mesh::MeshBuilder;
+use palette::palette_indices;
+use xml::{triangle_xml, vertex_xml};
+
+pub(crate) const COMPONENTS: usize = 3;
+
+fn extension_version() -> &'static str {
+    env!("CARGO_PKG_VERSION")
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let lithop = ruby.define_module("Lithop")?;
+    let native = lithop.define_module("Native")?;
+    native.define_singleton_method("palette_indices", function!(palette_indices, 2))?;
+    native.define_singleton_method("vertex_xml", function!(vertex_xml, 2))?;
+    native.define_singleton_method("triangle_xml", function!(triangle_xml, 1))?;
+    native.define_singleton_method("extension_version", function!(extension_version, 0))?;
+    native.define_singleton_method("column_mesh", function!(column_mesh, 8))?;
+    let mesh_builder = native.define_class("MeshBuilder", ruby.class_object())?;
+    mesh_builder.define_singleton_method("new", function!(MeshBuilder::new, 0))?;
+    mesh_builder.define_method("add_batch", method!(MeshBuilder::add_batch, 2))?;
+    mesh_builder.define_method("vertex_count", method!(MeshBuilder::vertex_count, 0))?;
+    mesh_builder.define_method("triangle_count", method!(MeshBuilder::triangle_count, 0))?;
+    mesh_builder.define_method("center", method!(MeshBuilder::center, 0))?;
+    mesh_builder.define_method("vertex_xml", method!(MeshBuilder::vertex_xml, 3))?;
+    mesh_builder.define_method("triangle_xml", method!(MeshBuilder::triangle_xml, 2))?;
+    mesh_builder.define_method("memory_bytes", method!(MeshBuilder::memory_bytes, 0))?;
+    Ok(())
+}

data/ext/lithop_native/src/mesh.rs

@@ -0,0 +1,187 @@
+use crate::xml::{build_triangle_records, build_vertex_records};
+use crate::COMPONENTS;
+use magnus::{Error, Ruby};
+use std::cell::RefCell;
+use std::collections::HashMap;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) enum VertexKey {
+    Coordinates([u64; COMPONENTS]),
+    Topology(i64),
+}
+
+#[derive(Default)]
+pub(crate) struct MeshData {
+    pub(crate) vertices: Vec<[f64; COMPONENTS]>,
+    pub(crate) triangles: Vec<[u32; COMPONENTS]>,
+    coordinate_indices: HashMap<[u64; COMPONENTS], u32>,
+    topology_indices: HashMap<i64, u32>,
+}
+
+#[magnus::wrap(class = "Lithop::Native::MeshBuilder", free_immediately, size)]
+pub(crate) struct MeshBuilder(RefCell<MeshData>);
+
+impl MeshBuilder {
+    pub(crate) fn new() -> Self {
+        Self(RefCell::new(MeshData::default()))
+    }
+
+    pub(crate) fn from_data(data: MeshData) -> Self {
+        Self(RefCell::new(data))
+    }
+
+    pub(crate) fn add_batch(
+        ruby: &Ruby,
+        rb_self: &Self,
+        coordinates: Vec<f64>,
+        topology_keys: Vec<i64>,
+    ) -> Result<usize, Error> {
+        if coordinates.len() % (COMPONENTS * COMPONENTS) != 0 {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF mesh coordinates must contain complete triangles",
+            ));
+        }
+        if topology_keys.len() * COMPONENTS != coordinates.len() {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF mesh topology key count must match its vertices",
+            ));
+        }
+        if coordinates.iter().any(|value| !value.is_finite()) {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF coordinates must be finite",
+            ));
+        }
+
+        let mut data = rb_self.0.borrow_mut();
+        let maximum_vertex_count = data.vertices.len().checked_add(topology_keys.len());
+        if maximum_vertex_count.is_none_or(|count| count > u32::MAX as usize) {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF mesh contains too many vertices",
+            ));
+        }
+        for (triangle_coordinates, triangle_keys) in coordinates
+            .chunks_exact(COMPONENTS * COMPONENTS)
+            .zip(topology_keys.chunks_exact(COMPONENTS))
+        {
+            let mut triangle = [0; COMPONENTS];
+            for vertex_offset in 0..COMPONENTS {
+                let start = vertex_offset * COMPONENTS;
+                let point = [
+                    triangle_coordinates[start],
+                    triangle_coordinates[start + 1],
+                    triangle_coordinates[start + 2],
+                ];
+                let key = vertex_key(point, triangle_keys[vertex_offset]);
+                triangle[vertex_offset] = index_mesh_vertex(&mut data, point, key);
+            }
+            data.triangles.push(triangle);
+        }
+        Ok(data.triangles.len())
+    }
+
+    pub(crate) fn vertex_count(&self) -> usize {
+        self.0.borrow().vertices.len()
+    }
+    pub(crate) fn triangle_count(&self) -> usize {
+        self.0.borrow().triangles.len()
+    }
+
+    pub(crate) fn center(&self) -> Vec<f64> {
+        let data = self.0.borrow();
+        let mut minimum = [f64::INFINITY; COMPONENTS];
+        let mut maximum = [f64::NEG_INFINITY; COMPONENTS];
+        for vertex in &data.vertices {
+            for axis in 0..COMPONENTS {
+                minimum[axis] = minimum[axis].min(vertex[axis]);
+                maximum[axis] = maximum[axis].max(vertex[axis]);
+            }
+        }
+        (0..COMPONENTS)
+            .map(|axis| (minimum[axis] + maximum[axis]) / 2.0)
+            .collect()
+    }
+
+    pub(crate) fn vertex_xml(
+        ruby: &Ruby,
+        rb_self: &Self,
+        offset: usize,
+        count: usize,
+        origin: Vec<f64>,
+    ) -> Result<String, Error> {
+        let data = rb_self.0.borrow();
+        let end = offset.saturating_add(count).min(data.vertices.len());
+        if offset > end {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF vertex offset is out of range",
+            ));
+        }
+        build_vertex_records(&data.vertices[offset..end], &origin)
+            .map_err(|message| Error::new(ruby.exception_arg_error(), message))
+    }
+
+    pub(crate) fn triangle_xml(
+        ruby: &Ruby,
+        rb_self: &Self,
+        offset: usize,
+        count: usize,
+    ) -> Result<String, Error> {
+        let data = rb_self.0.borrow();
+        let end = offset.saturating_add(count).min(data.triangles.len());
+        if offset > end {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF triangle offset is out of range",
+            ));
+        }
+        build_triangle_records(&data.triangles[offset..end])
+            .map_err(|message| Error::new(ruby.exception_arg_error(), message))
+    }
+
+    pub(crate) fn memory_bytes(&self) -> usize {
+        let data = self.0.borrow();
+        data.vertices.capacity() * std::mem::size_of::<[f64; COMPONENTS]>()
+            + data.triangles.capacity() * std::mem::size_of::<[u32; COMPONENTS]>()
+            + data.coordinate_indices.capacity()
+                * (std::mem::size_of::<[u64; COMPONENTS]>() + std::mem::size_of::<u32>())
+            + data.topology_indices.capacity()
+                * (std::mem::size_of::<i64>() + std::mem::size_of::<u32>())
+    }
+}
+
+fn vertex_key(point: [f64; COMPONENTS], topology_key: i64) -> VertexKey {
+    if topology_key >= 0 {
+        VertexKey::Topology(topology_key)
+    } else {
+        VertexKey::Coordinates(point.map(|value| if value == 0.0 { 0 } else { value.to_bits() }))
+    }
+}
+
+pub(crate) fn index_mesh_vertex(
+    data: &mut MeshData,
+    point: [f64; COMPONENTS],
+    key: VertexKey,
+) -> u32 {
+    let existing = match key {
+        VertexKey::Coordinates(coordinates) => data.coordinate_indices.get(&coordinates),
+        VertexKey::Topology(topology) => data.topology_indices.get(&topology),
+    };
+    if let Some(index) = existing {
+        return *index;
+    }
+    let index = data.vertices.len() as u32;
+    data.vertices.push(point);
+    match key {
+        VertexKey::Coordinates(coordinates) => {
+            data.coordinate_indices.insert(coordinates, index);
+        }
+        VertexKey::Topology(topology) => {
+            data.topology_indices.insert(topology, index);
+        }
+    }
+    index
+}

data/ext/lithop_native/src/palette.rs

@@ -0,0 +1,67 @@
+use crate::COMPONENTS;
+use magnus::{Error, Ruby};
+
+fn select_palette_indices(cmys: &[f64], coverages: &[f64]) -> Result<Vec<usize>, &'static str> {
+    if cmys.len() % COMPONENTS != 0 {
+        return Err("CMY values must contain triples");
+    }
+    if coverages.is_empty() || coverages.len() % COMPONENTS != 0 {
+        return Err("recipe coverage must contain triples");
+    }
+    if cmys
+        .iter()
+        .any(|value| !value.is_finite() || !(0.0..=1.0).contains(value))
+    {
+        return Err("CMY values must be finite values between zero and one");
+    }
+
+    let recipes: Vec<&[f64]> = coverages.chunks_exact(COMPONENTS).collect();
+    let mut indices = Vec::with_capacity(cmys.len() / COMPONENTS);
+    for target in cmys.chunks_exact(COMPONENTS) {
+        let mut best_index = 0;
+        let mut best_distance = f64::INFINITY;
+        for (index, coverage) in recipes.iter().enumerate() {
+            let cyan = coverage[0] - target[0];
+            let magenta = coverage[1] - target[1];
+            let yellow = coverage[2] - target[2];
+            let distance = (cyan * cyan) + (magenta * magenta) + (yellow * yellow);
+            if distance < best_distance {
+                best_index = index;
+                best_distance = distance;
+            }
+        }
+        indices.push(best_index);
+    }
+    Ok(indices)
+}
+
+pub(crate) fn palette_indices(
+    ruby: &Ruby,
+    cmys: Vec<f64>,
+    coverages: Vec<f64>,
+) -> Result<Vec<usize>, Error> {
+    select_palette_indices(&cmys, &coverages)
+        .map_err(|message| Error::new(ruby.exception_arg_error(), message))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::select_palette_indices;
+
+    #[test]
+    fn selects_the_first_recipe_at_equal_distance() {
+        let indices =
+            select_palette_indices(&[0.5, 0.0, 0.0], &[0.0, 0.0, 0.0, 1.0, 0.0, 0.0]).unwrap();
+        assert_eq!(indices, vec![0]);
+    }
+
+    #[test]
+    fn selects_multiple_samples_in_one_call() {
+        let indices = select_palette_indices(
+            &[0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+            &[0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+        )
+        .unwrap();
+        assert_eq!(indices, vec![0, 1]);
+    }
+}