use std::collections::HashMap;
use crate::brep::{ssi, SsiResult, SurfaceTable};
use crate::core::BufferGeometry;
use crate::nurbs::v3;
use super::V3;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Decision {
Skip,
SameSurface,
Refine,
Numeric,
}
pub(crate) struct Analytic<'a> {
a: Option<&'a SurfaceTable>,
b: Option<&'a SurfaceTable>,
cache: HashMap<(u32, u32), SsiResult>,
pub skipped: usize,
pub same_surface: usize,
pub numeric_hits: usize,
pub sharpened: usize,
pub max_sharpen: f64,
}
impl<'a> Analytic<'a> {
pub fn new(a: Option<&'a SurfaceTable>, b: Option<&'a SurfaceTable>) -> Self {
Self {
a,
b,
cache: HashMap::new(),
skipped: 0,
same_surface: 0,
numeric_hits: 0,
sharpened: 0,
max_sharpen: 0.0,
}
}
pub fn active(&self) -> bool {
self.a.is_some() && self.b.is_some()
}
fn lookup(&mut self, i: usize, j: usize) -> Option<&SsiResult> {
let (ta, tb) = (self.a?, self.b?);
let si = ta.surface_index_of(i)? as u32;
let sj = tb.surface_index_of(j)? as u32;
Some(
self.cache
.entry((si, sj))
.or_insert_with(|| ssi(&ta.surfaces()[si as usize], &tb.surfaces()[sj as usize])),
)
}
pub fn surfaces_of(
&self,
i: usize,
j: usize,
) -> Option<(&crate::brep::Surface, &crate::brep::Surface)> {
let (ta, tb) = (self.a?, self.b?);
Some((ta.surface_of(i)?, tb.surface_of(j)?))
}
pub fn decide(&mut self, i: usize, j: usize) -> Decision {
match self.lookup(i, j) {
Some(SsiResult::Disjoint) => {
self.skipped += 1;
Decision::Skip
}
Some(SsiResult::Coincident { .. }) => {
self.same_surface += 1;
Decision::SameSurface
}
Some(SsiResult::Curves(_)) => Decision::Refine,
_ => Decision::Numeric,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct AnalyticReport {
pub candidates: usize,
pub skipped: usize,
pub same_surface: usize,
pub curves: usize,
pub numeric: usize,
pub active: bool,
}
pub fn analytic_report(a: &BufferGeometry, b: &BufferGeometry) -> AnalyticReport {
let ta = super::triangles(a);
let tb = super::triangles(b);
let bvh_b = super::bvh::Bvh::build(&tb);
let mut an = Analytic::new(a.surface_table(), b.surface_table());
let mut out = AnalyticReport {
active: an.active(),
..Default::default()
};
let mut cand = Vec::new();
for (i, t) in ta.iter().enumerate() {
bvh_b.overlaps(super::aabb(t), &mut cand);
for &j in &cand {
out.candidates += 1;
match an.decide(i, j) {
Decision::Skip => out.skipped += 1,
Decision::SameSurface => out.same_surface += 1,
Decision::Refine => out.curves += 1,
Decision::Numeric => out.numeric += 1,
}
}
}
out
}
pub(crate) fn surfaces_coincide(a: &crate::brep::Surface, b: &crate::brep::Surface) -> bool {
matches!(ssi(a, b), SsiResult::Coincident { .. })
}
pub(crate) fn exact_on_edge(
p: V3,
a: &[V3; 3],
b: &[V3; 3],
sa: &crate::brep::Surface,
sb: &crate::brep::Surface,
max_move: f64,
) -> V3 {
let mut best: Option<(f64, V3)> = None;
for (tri, other) in [(a, sb), (b, sa)] {
for k in 0..3 {
let (e0, e1) = (tri[k], tri[(k + 1) % 3]);
if point_to_segment(p, e0, e1) > max_move {
continue;
}
let Some(q) = other.edge_crossing(e0, e1, p) else {
continue;
};
let d = v3::dist(p, q);
if d <= max_move && best.is_none_or(|(bd, _)| d < bd) {
best = Some((d, q));
}
}
}
best.map_or(p, |(_, q)| q)
}
fn point_to_segment(p: V3, a: V3, b: V3) -> f64 {
let ab = v3::sub(b, a);
let len2 = v3::dot(ab, ab);
if len2 < 1e-300 {
return v3::dist(p, a);
}
let t = (v3::dot(v3::sub(p, a), ab) / len2).clamp(0.0, 1.0);
v3::dist(p, v3::add(a, v3::scale(ab, t)))
}