Closed hannobraun closed 7 months ago
Blocked on #97.
Now that fj::Union
has been renamed to fj::Group
, which explicitly is only intended for disjoint bodies, this can no longer be classified as a bug. I've updated the issue accordingly.
This is no longer blocked on #97!
I'm back to working on this issue directly. I'm not aware of any blockers, but of course some new ones may show up, as I'm getting into this.
My attention is currently diverted to #568. While not strictly a blocker, addressing that issue will make the implementation of the union operation easier, as help as circumvent #567, which would otherwise affect the implementation.
All known hurdles are out of the way now. I'm back to working on this issue directly.
I'm still actively working on this. I made some slow progress over the last few weeks, implementing building blocks that the union algorithm is going to need. Over the last few days I've been stumbling a bit, as it became increasingly unclear what the next step is, and a few things I've tried didn't work out.
So I sat down, did some hard thinking (not easy in this heat :smile:), and came up with a plan for what's missing to take the next step with implementing the union algorithm.
So here's what I'm likely going to be working on for the next weeks/months(/years? :scream:):
Face
/Point
containment test (#941)
triangulation
that can be reused.robust-predicates
, specifically orient3d
.Shell
from Solid
(https://github.com/hannobraun/Fornjot/pull/983)
To make sense of the ray/face intersection result, I'm going to need APIs for determining the neighbors of a face, or the faces connected by an edge. I think Shell
would be the right place for this kind of thing.Shell
/Point
intersection
Shell
/Face
intersection
Shell
/Shell
intersection
Shell
/Face
intersection, by checking each shells faces against the other shell.Solid
/Solid
intersection
Shell
/Shell
intersection.This list is subject to change, as I figure more things out, but I think it'll at least serve as a good guide going forward.
I've been making some progress this week. I implemented face/point intersection (the first item on the list) and am now extending it, to provide the information required for ray/face intersection (the second item on the list).
I've made some progress this week, but I've hit another blocker: The shell/point intersection algorithm requires edges to be compared with one another, and this isn't currently possible (which was a bit of a surprise). See #993 for full context.
This is now blocked on #993.
I've made some good progress on the Shell
/Point
intersection test since yesterday, but have hit on another hurdle. #1162 is explaining the problem.
Labeling this issue as blocked again, until #1162 is addressed.
I'll be dealing with other priorities before I can pick this back up (namely #1589). Un-assigning myself from this issue.
This issue has been sidelined for a long time now, but with both #1162 and #1589 addressed, I'm finally ready to get back to it!
That this work has been sitting for so long is unfortunate, but it's also given me some perspective. I now believe that the approach I was following previously was not optimal, and ultimately rooted in a naive view of the problem. Basically, I approach this with the thought of "let's just implement the algorithm", then realizing that a lot of intersection tests had to exist for the algorithm to even know what to do, then going off and implementing those.
However, even when all the intersection tests are in place and the "knowing what to do" problem is solved, the other (maybe even bigger) problem still exists: actually doing the thing. Basically, once the algorithm knows where to remove/split/add vertices/edges/faces, it needs to then do those things.
Initially, I didn't realize how hard of a problem that was. But over the last few months that became painfully clear, mostly when I needed to construct geometry to write test cases, and that always turned into a huge pain. Since then, I've done a lot to ease the problem, namely the cleanup work in #1589 (and a lot of what came before). Those cleanups will directly benefit the work required for this issue.
However, there remain two problems:
Since I don't want to write more code that will be useless until the very end, I think it would be better to start with the geometry construction/manipulation APIs first. This has the following advantages:
So given all that, I've decided to build up this geometry construction/manipulation API until it has become powerful enough to support the union operation. When it has, it's time to revisit the intersection testing side of it.
Another thing to think about is whether we can even represent the model created from our union. Say we create a union of two identical cylinders in a "cross" shape:
(Screenshot from blender)
In order to represent this shape we would have (4 times at 90 degress)
From my understanding we cannot represent this yet, as we only have circles and lines.
You are right about that, @A-Walrus. It's a fact that the way we represent geometry is pretty limited, and won't serve us much longer. As far as this issue is concerned, this problem is out of scope though. Please note that the milestone this issue is assigned to only plans for straight edges and flat faces. There's also this older blog post which provides some more context.
I've been thinking about this in the back of my mind for a while, but I don't know what the solution is. A possible feature-based milestone after "straight edges, flat faces" could be "square things with round holes", which would essentially mean the stable subset of Fornjot (see https://github.com/hannobraun/Fornjot/issues/431) would be restricted to combining a straight/flat part with a round part, side-stepping the problem you mentioned to some degree.
After that, I don't know what the best path is. Maybe there are some more tricks we can pull (i.e. enable more useful features with specific, targeted changes), or maybe we're going to need a better geometry representation (I don't currently know what that would look like) or maybe we would need to go for full NURBS at that point.
I've decided to add boolean operations to the feature wishlist and close this issue. There are just too many moving parts (some of which I've implemented, many of which are still missing) to make this actionable. I wrote about why that is a while ago.
This doesn't mean that I don't think this is a desirable feature, but I want issues to be actionable work items, and this one definitely isn't.
It should be possible to create the union of two shapes, using constructive solid geometry (CSG). This is currently not supported, except for the simplest case, disjoint bodies, which is supported in the form of
fj::Group
.Implementing this requires more solid infrastructure in the host application for storing and querying shapes. Also see #43 and #44.