rei-mirrors/Fornjot
1
0
Fork 0
mirror of https://github.com/hannobraun/Fornjot synced 2025-01-11 10:47:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2275 from hannobraun/geometry

Browse Source 
Read half-edge geometry from geometry layer in most places
This commit is contained in:
Hanno Braun 2024-03-20 14:41:39 +01:00 committed by GitHub
commit ee15b609a5
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
20 changed files with 117 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
crates/fj-core/src/algorithms/approx/cycle.rs
View File

@ -2,8 +2,6 @@
//!
//! See [`CycleApprox`].
use std::ops::Deref;
use fj_math::Segment;
use crate::{geometry::SurfaceGeometry, objects::Cycle, Core};
@ -30,8 +28,7 @@ impl Approx for (&Cycle, &SurfaceGeometry) {
.half_edges()
.iter()
.map(|half_edge| {
(half_edge.deref(), surface)
.approx_with_cache(tolerance, cache, core)
(half_edge, surface).approx_with_cache(tolerance, cache, core)
})
.collect();

16
crates/fj-core/src/algorithms/approx/edge.rs
View File

@ -5,14 +5,16 @@
//! approximations are usually used to build cycle approximations, and this way,
//! the caller doesn't have to deal with duplicate vertices.
use crate::{geometry::SurfaceGeometry, objects::HalfEdge, Core};
use crate::{
geometry::SurfaceGeometry, objects::HalfEdge, storage::Handle, Core,
};
use super::{
curve::CurveApproxCache, vertex::VertexApproxCache, Approx, ApproxPoint,
Tolerance,
};
impl Approx for (&HalfEdge, &SurfaceGeometry) {
impl Approx for (&Handle<HalfEdge>, &SurfaceGeometry) {
type Approximation = HalfEdgeApprox;
type Cache = HalfEdgeApproxCache;
@ -44,7 +46,7 @@ impl Approx for (&HalfEdge, &SurfaceGeometry) {
let rest = {
let approx = (
half_edge.curve(),
half_edge.path(),
core.layers.geometry.of_half_edge(half_edge).path,
surface,
half_edge.boundary(),
)
@ -55,8 +57,12 @@ impl Approx for (&HalfEdge, &SurfaceGeometry) {
);
approx.points.into_iter().map(|point| {
let point_surface =
half_edge.path().point_from_path_coords(point.local_form);
let point_surface = core
.layers
.geometry
.of_half_edge(half_edge)
.path
.point_from_path_coords(point.local_form);
ApproxPoint::new(point_surface, point.global_form)
})

2
crates/fj-core/src/algorithms/approx/face.rs
View File

@ -110,7 +110,7 @@ impl Approx for &Face {
exterior,
interiors,
color: self.region().get_color(core),
coord_handedness: self.coord_handedness(),
coord_handedness: self.coord_handedness(&core.layers.geometry),
}
}
}

12
crates/fj-core/src/algorithms/bounding_volume/edge.rs
View File

@ -3,11 +3,12 @@ use fj_math::{Aabb, Vector};
use crate::{
geometry::{Geometry, SurfacePath},
objects::HalfEdge,
storage::Handle,
};
impl super::BoundingVolume<2> for HalfEdge {
fn aabb(&self, _: &Geometry) -> Option<Aabb<2>> {
match self.path() {
impl super::BoundingVolume<2> for Handle<HalfEdge> {
fn aabb(&self, geometry: &Geometry) -> Option<Aabb<2>> {
match geometry.of_half_edge(self).path {
SurfacePath::Circle(circle) => {
// Just calculate the AABB of the whole circle. This is not the
// most precise, but it should do for now.
@ -22,7 +23,10 @@ impl super::BoundingVolume<2> for HalfEdge {
}
SurfacePath::Line(_) => {
let points = self.boundary().inner.map(|point_curve| {
self.path().point_from_path_coords(point_curve)
geometry
.of_half_edge(self)
.path
.point_from_path_coords(point_curve)
});
Some(Aabb::<2>::from_points(points))

6
crates/fj-core/src/objects/kinds/cycle.rs
View File

@ -1,7 +1,7 @@
use fj_math::{Scalar, Winding};
use crate::{
geometry::SurfacePath,
geometry::{Geometry, SurfacePath},
objects::{HalfEdge, ObjectSet},
storage::Handle,
};
@ -29,7 +29,7 @@ impl Cycle {
/// Please note that this is not *the* winding of the cycle, only one of the
/// two possible windings, depending on the direction you look at the
/// surface that the cycle is defined on from.
pub fn winding(&self) -> Winding {
pub fn winding(&self, geometry: &Geometry) -> Winding {
// The cycle could be made up of one or two circles. If that is the
// case, the winding of the cycle is determined by the winding of the
// first circle.
@ -43,7 +43,7 @@ impl Cycle {
let [a, b] = first.boundary().inner;
let edge_direction_positive = a < b;
let circle = match first.path() {
let circle = match geometry.of_half_edge(first).path {
SurfacePath::Circle(circle) => circle,
SurfacePath::Line(_) => unreachable!(
"Invalid cycle: less than 3 edges, but not all are circles"

5
crates/fj-core/src/objects/kinds/face.rs
View File

@ -1,6 +1,7 @@
use fj_math::Winding;
use crate::{
geometry::Geometry,
objects::{Region, Surface},
storage::{Handle, HandleWrapper},
};
@ -64,8 +65,8 @@ impl Face {
/// Faces *do* have an orientation, meaning they have definite front and
/// back sides. The front side is the side, where the face's exterior cycle
/// is wound counter-clockwise.
pub fn coord_handedness(&self) -> Handedness {
match self.region.exterior().winding() {
pub fn coord_handedness(&self, geometry: &Geometry) -> Handedness {
match self.region.exterior().winding(geometry) {
Winding::Ccw => Handedness::RightHanded,
Winding::Cw => Handedness::LeftHanded,
}

4
crates/fj-core/src/operations/build/half_edge.rs
View File

@ -34,7 +34,7 @@ pub trait BuildHalfEdge {
core: &mut Core,
) -> Handle<HalfEdge> {
let half_edge = HalfEdge::new(
sibling.path(),
core.layers.geometry.of_half_edge(sibling).path,
sibling.boundary().reverse(),
sibling.curve().clone(),
start_vertex,
@ -44,7 +44,7 @@ pub trait BuildHalfEdge {
core.layers.geometry.define_half_edge(
half_edge.clone(),
HalfEdgeGeometry {
path: sibling.path(),
path: core.layers.geometry.of_half_edge(sibling).path,
},
);

4
crates/fj-core/src/operations/geometry/half_edge.rs
View File

@ -50,7 +50,7 @@ impl UpdateHalfEdgeGeometry for Handle<HalfEdge> {
update: impl FnOnce(SurfacePath) -> SurfacePath,
core: &mut Core,
) -> Self {
let path = update(self.path());
let path = update(core.layers.geometry.of_half_edge(self).path);
let half_edge = HalfEdge::new(
path,
@ -73,7 +73,7 @@ impl UpdateHalfEdgeGeometry for Handle<HalfEdge> {
core: &mut Core,
) -> Self {
HalfEdge::new(
self.path(),
core.layers.geometry.of_half_edge(self).path,
update(self.boundary()),
self.curve().clone(),
self.start_vertex().clone(),

19
crates/fj-core/src/operations/holes.rs
View File

@ -68,7 +68,10 @@ impl AddHole for Shell {
[Cycle::empty().add_joined_edges(
[(
entry.clone(),
entry.path(),
core.layers
.geometry
.of_half_edge(&entry)
.path,
entry.boundary(),
)],
core,
@ -139,7 +142,10 @@ impl AddHole for Shell {
[Cycle::empty().add_joined_edges(
[(
entry.clone(),
entry.path(),
core.layers
.geometry
.of_half_edge(&entry)
.path,
entry.boundary(),
)],
core,
@ -159,7 +165,14 @@ impl AddHole for Shell {
|region, core| {
region.add_interiors(
[Cycle::empty().add_joined_edges(
[(exit.clone(), exit.path(), exit.boundary())],
[(
exit.clone(),
core.layers
.geometry
.of_half_edge(exit)
.path,
exit.boundary(),
)],
core,
)],
core,

4
crates/fj-core/src/operations/reverse/cycle.rs
View File

@ -14,7 +14,7 @@ impl Reverse for Cycle {
.pairs()
.map(|(current, next)| {
let half_edge = HalfEdge::new(
current.path(),
core.layers.geometry.of_half_edge(current).path,
current.boundary().reverse(),
current.curve().clone(),
next.start_vertex().clone(),
@ -25,7 +25,7 @@ impl Reverse for Cycle {
core.layers.geometry.define_half_edge(
half_edge.clone(),
HalfEdgeGeometry {
path: current.path(),
path: core.layers.geometry.of_half_edge(current).path,
},
);

2
crates/fj-core/src/operations/reverse/edge.rs
View File

@ -10,7 +10,7 @@ use super::ReverseCurveCoordinateSystems;
impl ReverseCurveCoordinateSystems for Handle<HalfEdge> {
fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self {
let path = self.path().reverse();
let path = core.layers.geometry.of_half_edge(self).path.reverse();
let boundary = self.boundary().reverse();
let half_edge = HalfEdge::new(

14
crates/fj-core/src/operations/split/half_edge.rs
View File

@ -33,7 +33,7 @@ pub trait SplitHalfEdge {
) -> [Handle<HalfEdge>; 2];
}
impl SplitHalfEdge for HalfEdge {
impl SplitHalfEdge for Handle<HalfEdge> {
fn split_half_edge(
&self,
point: impl Into<Point<1>>,
@ -44,14 +44,14 @@ impl SplitHalfEdge for HalfEdge {
let [start, end] = self.boundary().inner;
let a = HalfEdge::new(
self.path(),
core.layers.geometry.of_half_edge(self).path,
[start, point],
self.curve().clone(),
self.start_vertex().clone(),
)
.insert(core);
let b = HalfEdge::new(
self.path(),
core.layers.geometry.of_half_edge(self).path,
[point, end],
self.curve().clone(),
Vertex::new().insert(core),
@ -60,11 +60,15 @@ impl SplitHalfEdge for HalfEdge {
core.layers.geometry.define_half_edge(
a.clone(),
HalfEdgeGeometry { path: self.path() },
HalfEdgeGeometry {
path: core.layers.geometry.of_half_edge(self).path,
},
);
core.layers.geometry.define_half_edge(
b.clone(),
HalfEdgeGeometry { path: self.path() },
HalfEdgeGeometry {
path: core.layers.geometry.of_half_edge(self).path,
},
);
[a, b]

2
crates/fj-core/src/operations/sweep/cycle.rs
View File

@ -77,7 +77,7 @@ impl SweepCycle for Cycle {
top_edges.push((
top_edge,
bottom_half_edge.path(),
core.layers.geometry.of_half_edge(bottom_half_edge).path,
bottom_half_edge.boundary(),
));
}

9
crates/fj-core/src/operations/sweep/half_edge.rs
View File

@ -47,7 +47,7 @@ pub trait SweepHalfEdge {
) -> (Face, Handle<HalfEdge>);
}
impl SweepHalfEdge for HalfEdge {
impl SweepHalfEdge for Handle<HalfEdge> {
fn sweep_half_edge(
&self,
end_vertex: Handle<Vertex>,
@ -59,7 +59,12 @@ impl SweepHalfEdge for HalfEdge {
) -> (Face, Handle<HalfEdge>) {
let path = path.into();
let surface = self.path().sweep_surface_path(surface, path, core);
let surface = core
.layers
.geometry
.of_half_edge(self)
.path
.sweep_surface_path(surface, path, core);
// Next, we need to define the boundaries of the face. Let's start with
// the global vertices and edges.

5
crates/fj-core/src/operations/sweep/sketch.rs
View File

@ -40,7 +40,10 @@ impl SweepSketch for Sketch {
let region = {
// The following code assumes that the sketch is winded counter-
// clockwise. Let's check that real quick.
assert!(region.exterior().winding().is_ccw());
assert!(region
.exterior()
.winding(&core.layers.geometry)
.is_ccw());
let is_negative_sweep = {
let u = match core.layers.geometry.of_surface(&surface).u {

2
crates/fj-core/src/operations/transform/edge.rs
View File

@ -16,7 +16,7 @@ impl TransformObject for Handle<HalfEdge> {
) -> Self {
// Don't need to transform the path, as that's defined in surface
// coordinates.
let path = self.path();
let path = core.layers.geometry.of_half_edge(self).path;
let boundary = self.boundary();
let curve = self
.curve()

14
crates/fj-core/src/validate/face.rs
View File

@ -13,10 +13,10 @@ impl Validate for Face {
&self,
_: &ValidationConfig,
errors: &mut Vec<ValidationError>,
_: &Geometry,
geometry: &Geometry,
) {
FaceValidationError::check_boundary(self, errors);
FaceValidationError::check_interior_winding(self, errors);
FaceValidationError::check_interior_winding(self, geometry, errors);
}
}
@ -56,14 +56,18 @@ impl FaceValidationError {
// checks for `Cycle` to make sure that the cycle is closed properly.
}
fn check_interior_winding(face: &Face, errors: &mut Vec<ValidationError>) {
fn check_interior_winding(
face: &Face,
geometry: &Geometry,
errors: &mut Vec<ValidationError>,
) {
if face.region().exterior().half_edges().is_empty() {
// Can't determine winding, if the cycle has no edges. Sounds like a
// job for a different validation check.
return;
}
let exterior_winding = face.region().exterior().winding();
let exterior_winding = face.region().exterior().winding(geometry);
for interior in face.region().interiors() {
if interior.half_edges().is_empty() {
@ -71,7 +75,7 @@ impl FaceValidationError {
// like a job for a different validation check.
continue;
}
let interior_winding = interior.winding();
let interior_winding = interior.winding(geometry);
if exterior_winding == interior_winding {
errors.push(

27
crates/fj-core/src/validate/shell.rs
View File

@ -104,6 +104,7 @@ impl ShellValidationError {
surface_a: &SurfaceGeometry,
edge_b: &Handle<HalfEdge>,
surface_b: &SurfaceGeometry,
geometry: &Geometry,
config: &ValidationConfig,
mismatches: &mut Vec<CurveCoordinateSystemMismatch>,
) {
@ -116,10 +117,14 @@ impl ShellValidationError {
let c = a + (d - a) * 2. / 3.;
for point_curve in [a, b, c, d] {
let a_surface =
edge_a.path().point_from_path_coords(point_curve);
let b_surface =
edge_b.path().point_from_path_coords(point_curve);
let a_surface = geometry
.of_half_edge(edge_a)
.path
.point_from_path_coords(point_curve);
let b_surface = geometry
.of_half_edge(edge_b)
.path
.point_from_path_coords(point_curve);
let a_global =
surface_a.point_from_surface_coords(a_surface);
@ -148,6 +153,7 @@ impl ShellValidationError {
&geometry.of_surface(surface_a),
edge_b,
&geometry.of_surface(surface_b),
geometry,
config,
&mut mismatches,
);
@ -156,6 +162,7 @@ impl ShellValidationError {
&geometry.of_surface(surface_b),
edge_a,
&geometry.of_surface(surface_a),
geometry,
config,
&mut mismatches,
);
@ -245,6 +252,7 @@ impl ShellValidationError {
&geometry.of_surface(surface_a),
half_edge_b.clone(),
&geometry.of_surface(surface_b),
geometry,
)
.all(|d| d < config.distinct_min_distance)
{
@ -369,14 +377,19 @@ fn distances(
surface_a: &SurfaceGeometry,
edge_b: Handle<HalfEdge>,
surface_b: &SurfaceGeometry,
geometry: &Geometry,
) -> impl Iterator<Item = Scalar> {
fn sample(
percent: f64,
(edge, surface): (&Handle<HalfEdge>, &SurfaceGeometry),
geometry: &Geometry,
) -> Point<3> {
let [start, end] = edge.boundary().inner;
let path_coords = start + (end - start) * percent;
let surface_coords = edge.path().point_from_path_coords(path_coords);
let surface_coords = geometry
.of_half_edge(edge)
.path
.point_from_path_coords(path_coords);
surface.point_from_surface_coords(surface_coords)
}
@ -389,8 +402,8 @@ fn distances(
let mut distances = Vec::new();
for i in 0..sample_count {
let percent = i as f64 * step;
let sample1 = sample(percent, (&edge_a, surface_a));
let sample2 = sample(1.0 - percent, (&edge_b, surface_b));
let sample1 = sample(percent, (&edge_a, surface_a), geometry);
let sample2 = sample(1.0 - percent, (&edge_b, surface_b), geometry);
distances.push(sample1.distance_to(&sample2))
}
distances.into_iter()

16
crates/fj-core/src/validate/sketch.rs
View File

@ -13,11 +13,15 @@ impl Validate for Sketch {
&self,
config: &ValidationConfig,
errors: &mut Vec<ValidationError>,
_: &Geometry,
geometry: &Geometry,
) {
SketchValidationError::check_object_references(self, config, errors);
SketchValidationError::check_exterior_cycles(self, config, errors);
SketchValidationError::check_interior_cycles(self, config, errors);
SketchValidationError::check_exterior_cycles(
self, geometry, config, errors,
);
SketchValidationError::check_interior_cycles(
self, geometry, config, errors,
);
}
}
@ -74,12 +78,13 @@ impl SketchValidationError {
fn check_exterior_cycles(
sketch: &Sketch,
geometry: &Geometry,
_config: &ValidationConfig,
errors: &mut Vec<ValidationError>,
) {
sketch.regions().iter().for_each(|region| {
let cycle = region.exterior();
if cycle.winding() == Winding::Cw {
if cycle.winding(geometry) == Winding::Cw {
errors.push(ValidationError::Sketch(
SketchValidationError::ClockwiseExteriorCycle {
cycle: cycle.clone(),
@ -91,6 +96,7 @@ impl SketchValidationError {
fn check_interior_cycles(
sketch: &Sketch,
geometry: &Geometry,
_config: &ValidationConfig,
errors: &mut Vec<ValidationError>,
) {
@ -98,7 +104,7 @@ impl SketchValidationError {
region
.interiors()
.iter()
.filter(|interior| interior.winding() == Winding::Ccw)
.filter(|interior| interior.winding(geometry) == Winding::Ccw)
.for_each(|cycle| {
errors.push(ValidationError::Sketch(
SketchValidationError::CounterClockwiseInteriorCycle {

7
crates/fj-core/src/validation/checks/half_edge_connection.rs
View File

@ -41,13 +41,16 @@ pub struct AdjacentHalfEdgesNotConnected {
impl ValidationCheck<Cycle> for AdjacentHalfEdgesNotConnected {
fn check(
object: &Cycle,
_: &Geometry,
geometry: &Geometry,
config: &ValidationConfig,
) -> impl Iterator<Item = Self> {
object.half_edges().pairs().filter_map(|(first, second)| {
let end_pos_of_first_half_edge = {
let [_, end] = first.boundary().inner;
first.path().point_from_path_coords(end)
geometry
.of_half_edge(first)
.path
.point_from_path_coords(end)
};
let start_pos_of_second_half_edge = second.start_position();