neco-geometry 0.2.3

exact shape declarations and evaluation over real algebraic coordinates
Documentation
use alloc::vec::Vec;

use neco_calculus::SurfacePolynomial;

use crate::encoding_scalar::ScalarEncoder;
use crate::{
    ChartPatch, EncodingBounds, EncodingFailure, EncodingLocation, EncodingPrecision,
    SurfaceOrientation, SurfaceTrimLoop2,
};

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct EncodedSurfaceTerm {
    pub coefficient: f32,
    pub exponent_u: u32,
    pub exponent_v: u32,
}

#[derive(Clone, Debug, PartialEq)]
pub struct EncodedCoefficients {
    polynomials: [Vec<EncodedSurfaceTerm>; 4],
}

impl EncodedCoefficients {
    pub fn polynomials(&self) -> &[Vec<EncodedSurfaceTerm>; 4] {
        &self.polynomials
    }
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct EncodedDomain {
    endpoints: [[f32; 2]; 2],
    closed: [[bool; 2]; 2],
}

impl EncodedDomain {
    pub fn endpoints(self) -> [[f32; 2]; 2] {
        self.endpoints
    }
    pub fn closed(self) -> [[bool; 2]; 2] {
        self.closed
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct EncodedDiskConstraint;

#[derive(Clone, Debug, PartialEq)]
pub struct EncodedTrimRestriction {
    outer: Vec<[f32; 2]>,
    holes: Vec<Vec<[f32; 2]>>,
}

impl EncodedTrimRestriction {
    pub fn outer(&self) -> &[[f32; 2]] {
        &self.outer
    }
    pub fn holes(&self) -> &[Vec<[f32; 2]>] {
        &self.holes
    }
}

#[derive(Clone, Debug, PartialEq)]
pub enum EncodedSurfacePatch {
    Full {
        coefficients: EncodedCoefficients,
        domain: EncodedDomain,
        disk: Option<EncodedDiskConstraint>,
        orientation: SurfaceOrientation,
    },
    Trimmed {
        coefficients: EncodedCoefficients,
        domain: EncodedDomain,
        restriction: EncodedTrimRestriction,
        orientation: SurfaceOrientation,
    },
}

pub fn encode_chart_patch(
    patch: &ChartPatch,
    precision: EncodingPrecision,
) -> Result<(EncodedSurfacePatch, EncodingBounds), EncodingFailure> {
    let mut encoder = ScalarEncoder::new(precision);
    let source = patch.chart().surface();
    let coefficients = EncodedCoefficients {
        polynomials: [
            encoder.polynomial(&source.x, 0)?,
            encoder.polynomial(&source.y, 1)?,
            encoder.polynomial(&source.z, 2)?,
            encoder.polynomial(&source.denominator, 3)?,
        ],
    };
    let mut endpoints = [[0.0; 2]; 2];
    let mut closed = [[false; 2]; 2];
    for (axis, interval) in [patch.domain().u(), patch.domain().v()]
        .into_iter()
        .enumerate()
    {
        for (endpoint, value) in [interval.lower(), interval.upper()].into_iter().enumerate() {
            endpoints[axis][endpoint] = encoder.algebraic(
                value,
                EncodingLocation::DomainEndpoint {
                    axis,
                    upper: endpoint == 1,
                },
            )?;
        }
        closed[axis] = [interval.lower_closed(), interval.upper_closed()];
    }
    let domain = EncodedDomain { endpoints, closed };
    let orientation = patch.chart().orientation();
    let encoded = match patch {
        ChartPatch::Full { disk, .. } => EncodedSurfacePatch::Full {
            coefficients,
            domain,
            disk: disk.map(|_| EncodedDiskConstraint),
            orientation,
        },
        ChartPatch::Trimmed { declaration } => {
            let outer = encoder.trim_loop(declaration.outer(), None)?;
            let mut holes = Vec::with_capacity(declaration.holes().len());
            for (hole, source) in declaration.holes().iter().enumerate() {
                holes.push(encoder.trim_loop(source, Some(hole))?);
            }
            EncodedSurfacePatch::Trimmed {
                coefficients,
                domain,
                restriction: EncodedTrimRestriction { outer, holes },
                orientation,
            }
        }
    };
    Ok((encoded, encoder.bounds()))
}

impl ScalarEncoder {
    fn polynomial(
        &mut self,
        polynomial: &SurfacePolynomial,
        index: usize,
    ) -> Result<Vec<EncodedSurfaceTerm>, EncodingFailure> {
        polynomial
            .terms()
            .iter()
            .enumerate()
            .map(|(term, source)| {
                Ok(EncodedSurfaceTerm {
                    coefficient: self.rational(
                        &source.coefficient,
                        EncodingLocation::Coefficient {
                            polynomial: index,
                            term,
                        },
                    )?,
                    exponent_u: source.exponent_u,
                    exponent_v: source.exponent_v,
                })
            })
            .collect()
    }

    fn trim_loop(
        &mut self,
        source: &SurfaceTrimLoop2,
        hole: Option<usize>,
    ) -> Result<Vec<[f32; 2]>, EncodingFailure> {
        source
            .vertices()
            .iter()
            .enumerate()
            .map(|(vertex, point)| {
                Ok([
                    self.algebraic(
                        point.u(),
                        EncodingLocation::TrimVertex {
                            hole,
                            vertex,
                            axis: 0,
                        },
                    )?,
                    self.algebraic(
                        point.v(),
                        EncodingLocation::TrimVertex {
                            hole,
                            vertex,
                            axis: 1,
                        },
                    )?,
                ])
            })
            .collect()
    }
}