does that, and adds a scale factor to that transformation (instead
of just mirroring, as before), but also:
* Replace the "import mirrored" mechanism with a scale factor,
which if negative corresponds to a reflection as well.
* Fix self-intersection checker to report a meaningful point
when edges are collinear.
* Don't blow an assertion on some types of invalid file;
instead provide a nice error message to the user.
* Clear the naked edges before each regen.
* Don't create zero-length line segments by snapping a line
segment's end to its beginning.
[git-p4: depot-paths = "//depot/solvespace/": change = 2086]
and parametric entities. Also consolidate the text screen functions
to change group options into a single function for everything.
[git-p4: depot-paths = "//depot/solvespace/": change = 2051]
surface's domain of u, v in [0, 1]. Cache the starting guess when
projecting a point into a ratpoly surface, to avoid brute force
searching for a good one every time. Split edges even if they
aren't quite inside the trim curve, since the trim boundaries are
pwl, not exact; unnecessary splits won't hurt, but failure to split
when necessary will. Make the triangulation code use a better (but
not perfect) epsilon, to avoid "can't find ear" failures on very
fine meshes.
And turn on compiler optimization! I had somehow forgotten about
that, and it's a ~2x improvement.
[git-p4: depot-paths = "//depot/solvespace/": change = 2026]
uv points. This is inconsistent, unless the surface happens to be a
plane square with side length one.
So modify the SBspUv tests to take a surface, and measure distance
linearized in that surface. That fixes at least one
mis-classification bug, and doesn't seem to break anything.
[git-p4: depot-paths = "//depot/solvespace/": change = 2005]
contour, except at the ends of the chain), and classify the entire
chain. That's much faster than going edge by edge.
[git-p4: depot-paths = "//depot/solvespace/": change = 2002]
the arbitrary-magnitude dot product, to classify regions (inside,
outside, coincident) of surfaces against each other.
That lets me always perturb the point for the normals (inside and
outside the edge) by just a chord tolerance, and nothing bad
happens as that distance varies over a few orders of magnitude.
[git-p4: depot-paths = "//depot/solvespace/": change = 1996]
boundary points, at least. That required some changes to what gets
passed around (for example because to project a point onto this
inexact curve, we need to know which two surfaces it trims so that
we can do a Newton's method on them).
And fix stupidity in the way that I calculated edge normals; I just
did normal in uv space, and there's no particular reason why that
would be normal in xyz. So edges in long skinny surfaces failed,
for example.
[git-p4: depot-paths = "//depot/solvespace/": change = 1990]
xyz point that I subtracted off had been refined to lie exactly on
our edge's curve, and the uv point that I started with had not. So
normals got randomly screwed up.
[git-p4: depot-paths = "//depot/solvespace/": change = 1978]
of revolution, and put them in the same form as if they had been
draw by an extrusion (so that we can use all the same special case
intersection curves).
And add code to merge coincident faces into one. That turns out to
be more than a cosmetic/efficiency thing, since edge splitting
fails at the join between two coincident faces.
[git-p4: depot-paths = "//depot/solvespace/": change = 1965]
separate polygon of coincident (with same or opposite normal)
faces; I instead test all the edges against the other shell, and
have extended the classify-against-shell stuff to handle those
cases.
And the normals are now perturbed a bit numerically, to either side
of the edge, to distinguish tangency from a coincident surface.
This seems to work fairly well, although things still tend to fail
when the piecewise linear tolerance is too coarse.
[git-p4: depot-paths = "//depot/solvespace/": change = 1964]
window screen, and remind the user that they could 'fix' the
problem by working with meshes instead.
[git-p4: depot-paths = "//depot/solvespace/": change = 1962]
parallel axis (which are always lines parallel to that axis).
Remove short pwl segments when possible, to avoid short edges that
get misclassified.
[git-p4: depot-paths = "//depot/solvespace/": change = 1952]
closed form. This is a fairly good speedup, and handles tangency
well.
But that shows that tangency has other problems; need to classify
edges correctly (whether they point to a coincident surface) in
curved surfaces too. I need to tweak SShell::ClassifyPoint().
[git-p4: depot-paths = "//depot/solvespace/": change = 1933]
* Rewrite surface handles in curves, so that Booleans beyond
the first don't screw up.
* If an intersection curve is identical to an existing curve
(as happens when faces are coincident), take the piecewise
linearization of the existing curve; this stops us from
screwing up when different shells are pwl'd at different
chord tols.
* Hook up the plane faces again.
* Remove coincident (parallel or anti-parallel) edges from the
coincident-face edge lists when doing Booleans; those may
happen if two faces are coincident with ours.
* Miscellaneous bugfixes.
It doesn't seem to screw up very much now, although tangent edges
(and insufficient pwl resolution) may still cause problems.
[git-p4: depot-paths = "//depot/solvespace/": change = 1929]
trimmed line), and plane-line intersection. Terminate the Bezier
surface subdivision on a chord tolerance, and that seems okay now.
And print info about the graphics adapter in the text window, could
be useful.
Also have a cylinder-detection routine that works; should special
case those surfaces in closed form since they are common, but not
doing it yet.
[git-p4: depot-paths = "//depot/solvespace/": change = 1928]
use that for surface-line intersections. That has major problems
with the heuristic on when to stop and do Newton polishing.
There's also an issue with all the Newton stuff when surfaces join
tangent.
And update the wishlist to reflect current needs.
[git-p4: depot-paths = "//depot/solvespace/": change = 1925]
point, and to intersect three surfaces at a point. So now when we
split an edge, we can refine the split point to lie exactly on the
trim curve, so I can do certain Booleans on curved surfaces.
But surface-line intersection is globally broken, since I don't
correctly detect the number of intersections or provide a good
first guess. I maybe should test by bounding boxes and subdivision.
[git-p4: depot-paths = "//depot/solvespace/": change = 1920]
will do for real; now handling the special cases of plane against a
surface of extrusion. Still need to fix up line-surface
intersection to work for curved things, but then some simple curved
cases should work (as well as plane-plane).
[git-p4: depot-paths = "//depot/solvespace/": change = 1919]
way to think about the cases; I'm classifying the regions to the
left and right of each edge, and keeping the edges if those regions
(2d, surfaces) classify different.
Still screws up with edge-on-edge intersections; but if I make the
surface intersection stuff handle that, then might be more
straightforward to use that info.
[git-p4: depot-paths = "//depot/solvespace/": change = 1914]
segments in Boolean against the shell, not the intersection
polygon. (We just cast a ray, and use the surface-line intersection
function that already existed.) That's slow, but can be
accelerated later.
[git-p4: depot-paths = "//depot/solvespace/": change = 1911]
non-coincident faces. There's also a problem when I don't generate
the full intersection polygon of shell B against a given surface in
shell A; I need to modify the code to not require that.
[git-p4: depot-paths = "//depot/solvespace/": change = 1910]
trim curves for all surfaces lie between 0 and 1. And add routines
to merge the curves and surfaces from two shells into one, and to
split the trim curves into their piecewise linear segments and then
reassemble them into trim curves.
[git-p4: depot-paths = "//depot/solvespace/": change = 1905]
Add stubs for functions to perform Booleans, and get rid of mesh
stuff, including the kd tree accelerated snap to vertex (which
should not be required if the shell triangulation performs as it
should).
Also check that a sketch is not self-intersecting before extruding
it or whatever. This is dead slow, needs n*log(n) implementation.
[git-p4: depot-paths = "//depot/solvespace/": change = 1902]
Jonathan Westhues