caiyu/solvespace
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
c0b6eaa935
solvespace/src/srf/surface.h

428 lines
15 KiB
C
Raw Normal View History

Changes in preparation for the release of SolveSpace under the GPL, to add that license, and change all copyright notices to me, not Useful Subset, LLC. [git-p4: depot-paths = "//depot/solvespace/": change = 2211]
2013-07-29 06:08:34 +08:00
//-----------------------------------------------------------------------------
// Functions relating to rational polynomial surfaces, which are trimmed by
// curves (either rational polynomial curves, or piecewise linear
// approximations to curves of intersection that can't be represented
// exactly in ratpoly form), and assembled into watertight shells.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
#ifndef __SURFACE_H
#define __SURFACE_H
Generate the group's polygon from the exact curves, not from edges; so now we've got the exact curve loops, with their direction standardized so that we can tell which direction is out. We still need the polygon in any case, since that's a convenient way to find each curve's winding number. And remove some more leftover code from mesh sweeps. [git-p4: depot-paths = "//depot/solvespace/": change = 1897]
2009-01-19 11:33:15 +08:00
// Utility functions, Bernstein polynomials of order 1-3 and their derivatives.
Entities now generate rational polynomial curves instead of piecwise linear segments. These are piecewise linear approximated for display, and currently for the mesh too, but that's the first step to replace the mesh with exact curved surfaces. [git-p4: depot-paths = "//depot/solvespace/": change = 1895]
2009-01-15 11:55:42 +08:00
double Bernstein(int k, int deg, double t);
Generate the group's polygon from the exact curves, not from edges; so now we've got the exact curve loops, with their direction standardized so that we can tell which direction is out. We still need the polygon in any case, since that's a convenient way to find each curve's winding number. And remove some more leftover code from mesh sweeps. [git-p4: depot-paths = "//depot/solvespace/": change = 1897]
2009-01-19 11:33:15 +08:00
double BernsteinDerivative(int k, int deg, double t);
Entities now generate rational polynomial curves instead of piecwise linear segments. These are piecewise linear approximated for display, and currently for the mesh too, but that's the first step to replace the mesh with exact curved surfaces. [git-p4: depot-paths = "//depot/solvespace/": change = 1895]
2009-01-15 11:55:42 +08:00
Add a new renderer that prepares geometry for 2d backends. SurfaceRenderer is a new renderer implementing the Canvas interface running entirely on the CPU; it projects strokes and triangles in the exact same way as OpenGL would, and it can be used for rendering into raster or vector 2d surfaces.
2016-07-22 04:27:53 +08:00
class SBezierList;
Add Newton iterations to intersect a line with a surface at a 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]
2009-02-27 21:04:36 +08:00
class SSurface;
Generate intersection curves for surfaces of extrusion along a 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]
2009-05-18 15:26:51 +08:00
class SCurvePt;
Add Newton iterations to intersect a line with a surface at a 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]
2009-02-27 21:04:36 +08:00
More work on Booleans. This works only for planes, and only for 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]
2009-02-01 13:13:43 +08:00
// Utility data structure, a two-dimensional BSP to accelerate polygon
// operations.
class SBspUv {
public:
Point2d a, b;
SBspUv *pos;
SBspUv *neg;
SBspUv *more;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
enum class Class : uint32_t {
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-10 03:50:32 +08:00
INSIDE = 100,
OUTSIDE = 200,
EDGE_PARALLEL = 300,
EDGE_ANTIPARALLEL = 400,
EDGE_OTHER = 500
};
More work on Booleans. This works only for planes, and only for 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]
2009-02-01 13:13:43 +08:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
static SBspUv *Alloc();
I had been using LENGTH_EPS as the tolerance on both xyz points and 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]
2009-07-02 11:32:17 +08:00
static SBspUv *From(SEdgeList *el, SSurface *srf);
More work on Booleans. This works only for planes, and only for 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]
2009-02-01 13:13:43 +08:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
void ScalePoints(Point2d *pt, Point2d *a, Point2d *b, SSurface *srf) const;
I had been using LENGTH_EPS as the tolerance on both xyz points and 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]
2009-07-02 11:32:17 +08:00
double ScaledSignedDistanceToLine(Point2d pt, Point2d a, Point2d b,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
SSurface *srf) const;
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 20:08:19 +08:00
double ScaledDistanceToLine(Point2d pt, Point2d a, Point2d b, bool asSegment,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
SSurface *srf) const;
I had been using LENGTH_EPS as the tolerance on both xyz points and 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]
2009-07-02 11:32:17 +08:00
Get rid of if(!this). According to the C++ standard, "this" is never NULL, so checks of the form "if(!this)" can be legally optimized out. This breaks SolveSpace on GCC 6, and probably on other compilers and configurations.
2016-03-25 22:16:58 +08:00
void InsertEdge(Point2d a, Point2d b, SSurface *srf);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
static SBspUv *InsertOrCreateEdge(SBspUv *where, Point2d ea, Point2d eb, SSurface *srf);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
Class ClassifyPoint(Point2d p, Point2d eb, SSurface *srf) const;
Class ClassifyEdge(Point2d ea, Point2d eb, SSurface *srf) const;
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
double MinimumDistanceToEdge(Point2d p, SSurface *srf) const;
More work on Booleans. This works only for planes, and only for 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]
2009-02-01 13:13:43 +08:00
};
// Now the data structures to represent a shell of trimmed rational polynomial
// surfaces.
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
class SShell;
Entities now generate rational polynomial curves instead of piecwise linear segments. These are piecewise linear approximated for display, and currently for the mesh too, but that's the first step to replace the mesh with exact curved surfaces. [git-p4: depot-paths = "//depot/solvespace/": change = 1895]
2009-01-15 11:55:42 +08:00
class hSSurface {
public:
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
uint32_t v;
Entities now generate rational polynomial curves instead of piecwise linear segments. These are piecewise linear approximated for display, and currently for the mesh too, but that's the first step to replace the mesh with exact curved surfaces. [git-p4: depot-paths = "//depot/solvespace/": change = 1895]
2009-01-15 11:55:42 +08:00
};
class hSCurve {
public:
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
uint32_t v;
Entities now generate rational polynomial curves instead of piecwise linear segments. These are piecewise linear approximated for display, and currently for the mesh too, but that's the first step to replace the mesh with exact curved surfaces. [git-p4: depot-paths = "//depot/solvespace/": change = 1895]
2009-01-15 11:55:42 +08:00
};
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
// Stuff for rational polynomial curves, of degree one to three. These are
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 12:19:23 +08:00
// our inputs, and are also calculated for certain exact surface-surface
// intersections.
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
class SBezier {
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
public:
Remove old sweep/helical sweep code for meshes, and add some untested stuff to start making exact surface shells. [git-p4: depot-paths = "//depot/solvespace/": change = 1896]
2009-01-17 13:28:49 +08:00
int tag;
Now actually export the line styles, for PDF, EPS, and SVG file formats, with the proper color and width. This may need a bit of cleanup for stuff like the hidden line removal, which currently loses the style. Also fix a bug in the test for arcs of a circle. A second-order Bezier with collinear control points really is an arc, but it's an arc with infinite radius so stuff tends to blow up. So return false for that one. [git-p4: depot-paths = "//depot/solvespace/": change = 2030]
2009-09-22 13:46:30 +08:00
int auxA, auxB;
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
int deg;
Vector ctrl[4];
double weight[4];
Generate primitives for lathe groups. The primitives that are generated are circles from points and faces from axis-perpendicular line segments.
2015-10-31 16:22:26 +08:00
uint32_t entity;
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
Vector PointAt(double t) const;
Vector TangentAt(double t) const;
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 20:08:19 +08:00
void ClosestPointTo(Vector p, double *t, bool mustConverge=true) const;
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
void SplitAt(double t, SBezier *bef, SBezier *aft) const;
bool PointOnThisAndCurve(const SBezier *sbb, Vector *p) const;
Vector Start() const;
Vector Finish() const;
bool Equals(SBezier *b) const;
void MakePwlInto(SEdgeList *sel, double chordTol=0) const;
void MakePwlInto(List<SCurvePt> *l, double chordTol=0) const;
void MakePwlInto(SContour *sc, double chordTol=0) const;
void MakePwlInto(List<Vector> *l, double chordTol=0) const;
void MakePwlWorker(List<Vector> *l, double ta, double tb, double chordTol) const;
void MakePwlInitialWorker(List<Vector> *l, double ta, double tb, double chordTol) const;
Add a new renderer that prepares geometry for 2d backends. SurfaceRenderer is a new renderer implementing the Canvas interface running entirely on the CPU; it projects strokes and triangles in the exact same way as OpenGL would, and it can be used for rendering into raster or vector 2d surfaces.
2016-07-22 04:27:53 +08:00
void MakeNonrationalCubicInto(SBezierList *bl, double tolerance, int depth = 0) const;
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
void AllIntersectionsWith(const SBezier *sbb, SPointList *spl) const;
void GetBoundingProjd(Vector u, Vector orig, double *umin, double *umax) const;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void Reverse();
Remove old sweep/helical sweep code for meshes, and add some untested stuff to start making exact surface shells. [git-p4: depot-paths = "//depot/solvespace/": change = 1896]
2009-01-17 13:28:49 +08:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
bool IsInPlane(Vector n, double d) const;
bool IsCircle(Vector axis, Vector *center, double *r) const;
bool IsRational() const;
Add exact export of arcs for EPS, DXF, SVG, and of nonrational polynomial curves for SVG. [git-p4: depot-paths = "//depot/solvespace/": change = 1937]
2009-04-15 10:55:18 +08:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
SBezier TransformedBy(Vector t, Quaternion q, double scale) const;
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 12:19:23 +08:00
SBezier InPerspective(Vector u, Vector v, Vector n,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
Vector origin, double cameraTan) const;
Make the export scale factor affect the surfaces in a STEP file, and lay groundwork for wireframe export. [git-p4: depot-paths = "//depot/solvespace/": change = 2052]
2009-10-12 17:28:34 +08:00
void ScaleSelfBy(double s);
Tear everything apart, moving away from meshes and toward shells. 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]
2009-01-23 11:30:30 +08:00
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
static SBezier From(Vector p0, Vector p1, Vector p2, Vector p3);
static SBezier From(Vector p0, Vector p1, Vector p2);
static SBezier From(Vector p0, Vector p1);
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 12:19:23 +08:00
static SBezier From(Vector4 p0, Vector4 p1, Vector4 p2, Vector4 p3);
static SBezier From(Vector4 p0, Vector4 p1, Vector4 p2);
static SBezier From(Vector4 p0, Vector4 p1);
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
};
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
class SBezierList {
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
public:
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
List<SBezier> l;
Entities now generate rational polynomial curves instead of piecwise linear segments. These are piecewise linear approximated for display, and currently for the mesh too, but that's the first step to replace the mesh with exact curved surfaces. [git-p4: depot-paths = "//depot/solvespace/": change = 1895]
2009-01-15 11:55:42 +08:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void Clear();
Make the export scale factor affect the surfaces in a STEP file, and lay groundwork for wireframe export. [git-p4: depot-paths = "//depot/solvespace/": change = 2052]
2009-10-12 17:28:34 +08:00
void ScaleSelfBy(double s);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void CullIdenticalBeziers();
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
void AllIntersectionsWith(SBezierList *sblb, SPointList *spl) const;
A monster change to add support for filled paths. This requires us to assemble Beziers into outer and inner loops, and find those loops made up of entities with filled styles. The open paths are maintained in a separate list, and we assemble as many closed paths as possible even when open paths exist. This changes many things. The coplanar check is now performed on the Beziers, not the resulting polygon. The way that the polygon is used to determine loop directions is also modified. Also fix the mouse behavior when dragging a point: drop it when the mouse is released, even if it is released outside the window, but don't drop it if the pointer is dragged out of and then back into our window. Also special-case SSurface::ClosestPointTo() for planes, for speed. [git-p4: depot-paths = "//depot/solvespace/": change = 2058]
2009-10-29 15:16:28 +08:00
bool GetPlaneContainingBeziers(Vector *p, Vector *u, Vector *v,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
Vector *notCoplanarAt) const;
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
};
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
class SBezierLoop {
Remove old sweep/helical sweep code for meshes, and add some untested stuff to start making exact surface shells. [git-p4: depot-paths = "//depot/solvespace/": change = 1896]
2009-01-17 13:28:49 +08:00
public:
When exporting STEP, identify the outer contours, and group them and their holes into their own advanced faces. So a single surface with multiple outer contours generates multiple advanced faces. Also turn the default chord tol down to 1.5 pixels, seems more likely to make the exact surface Booleans work. [git-p4: depot-paths = "//depot/solvespace/": change = 1975]
2009-06-09 00:21:33 +08:00
int tag;
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
List<SBezier> l;
Remove old sweep/helical sweep code for meshes, and add some untested stuff to start making exact surface shells. [git-p4: depot-paths = "//depot/solvespace/": change = 1896]
2009-01-17 13:28:49 +08:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
inline void Clear() { l.Clear(); }
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
bool IsClosed() const;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void Reverse();
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
void MakePwlInto(SContour *sc, double chordTol=0) const;
void GetBoundingProjd(Vector u, Vector orig, double *umin, double *umax) const;
Remove old sweep/helical sweep code for meshes, and add some untested stuff to start making exact surface shells. [git-p4: depot-paths = "//depot/solvespace/": change = 1896]
2009-01-17 13:28:49 +08:00
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
static SBezierLoop FromCurves(SBezierList *spcl,
bool *allClosed, SEdge *errorAt);
Remove old sweep/helical sweep code for meshes, and add some untested stuff to start making exact surface shells. [git-p4: depot-paths = "//depot/solvespace/": change = 1896]
2009-01-17 13:28:49 +08:00
};
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
class SBezierLoopSet {
Generate the group's polygon from the exact curves, not from edges; so now we've got the exact curve loops, with their direction standardized so that we can tell which direction is out. We still need the polygon in any case, since that's a convenient way to find each curve's winding number. And remove some more leftover code from mesh sweeps. [git-p4: depot-paths = "//depot/solvespace/": change = 1897]
2009-01-19 11:33:15 +08:00
public:
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
List<SBezierLoop> l;
Generate the group's polygon from the exact curves, not from edges; so now we've got the exact curve loops, with their direction standardized so that we can tell which direction is out. We still need the polygon in any case, since that's a convenient way to find each curve's winding number. And remove some more leftover code from mesh sweeps. [git-p4: depot-paths = "//depot/solvespace/": change = 1897]
2009-01-19 11:33:15 +08:00
Vector normal;
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
Vector point;
Generate the group's polygon from the exact curves, not from edges; so now we've got the exact curve loops, with their direction standardized so that we can tell which direction is out. We still need the polygon in any case, since that's a convenient way to find each curve's winding number. And remove some more leftover code from mesh sweeps. [git-p4: depot-paths = "//depot/solvespace/": change = 1897]
2009-01-19 11:33:15 +08:00
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
static SBezierLoopSet From(SBezierList *spcl, SPolygon *poly,
A monster change to add support for filled paths. This requires us to assemble Beziers into outer and inner loops, and find those loops made up of entities with filled styles. The open paths are maintained in a separate list, and we assemble as many closed paths as possible even when open paths exist. This changes many things. The coplanar check is now performed on the Beziers, not the resulting polygon. The way that the polygon is used to determine loop directions is also modified. Also fix the mouse behavior when dragging a point: drop it when the mouse is released, even if it is released outside the window, but don't drop it if the pointer is dragged out of and then back into our window. Also special-case SSurface::ClosestPointTo() for planes, for speed. [git-p4: depot-paths = "//depot/solvespace/": change = 2058]
2009-10-29 15:16:28 +08:00
double chordTol,
bool *allClosed, SEdge *errorAt,
SBezierList *openContours);
Generate the group's polygon from the exact curves, not from edges; so now we've got the exact curve loops, with their direction standardized so that we can tell which direction is out. We still need the polygon in any case, since that's a convenient way to find each curve's winding number. And remove some more leftover code from mesh sweeps. [git-p4: depot-paths = "//depot/solvespace/": change = 1897]
2009-01-19 11:33:15 +08:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
void GetBoundingProjd(Vector u, Vector orig, double *umin, double *umax) const;
void MakePwlInto(SPolygon *sp) const;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void Clear();
Generate the group's polygon from the exact curves, not from edges; so now we've got the exact curve loops, with their direction standardized so that we can tell which direction is out. We still need the polygon in any case, since that's a convenient way to find each curve's winding number. And remove some more leftover code from mesh sweeps. [git-p4: depot-paths = "//depot/solvespace/": change = 1897]
2009-01-19 11:33:15 +08:00
};
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
Move code to find outer and inner contours (and which inner contours go with which outer contour) out of exportstep.cpp, since I'll need that to do filled contour export for the 2d file formats. Also add user interface to specify fill color. [git-p4: depot-paths = "//depot/solvespace/": change = 2057]
2009-10-23 01:16:20 +08:00
class SBezierLoopSetSet {
public:
List<SBezierLoopSet> l;
A monster change to add support for filled paths. This requires us to assemble Beziers into outer and inner loops, and find those loops made up of entities with filled styles. The open paths are maintained in a separate list, and we assemble as many closed paths as possible even when open paths exist. This changes many things. The coplanar check is now performed on the Beziers, not the resulting polygon. The way that the polygon is used to determine loop directions is also modified. Also fix the mouse behavior when dragging a point: drop it when the mouse is released, even if it is released outside the window, but don't drop it if the pointer is dragged out of and then back into our window. Also special-case SSurface::ClosestPointTo() for planes, for speed. [git-p4: depot-paths = "//depot/solvespace/": change = 2058]
2009-10-29 15:16:28 +08:00
void FindOuterFacesFrom(SBezierList *sbl, SPolygon *spxyz, SSurface *srfuv,
double chordTol,
bool *allClosed, SEdge *notClosedAt,
bool *allCoplanar, Vector *notCoplanarAt,
SBezierList *openContours);
Make the EPS, PDF, and SVG targets output filled contours. This also means that closed contours will get output as a single path now, vs. one open path per Bezier segment before. I've simplified the 2d/3d wireframe export targets somewhat; they now support only Beziers, without an additional special case for line segments. The performance penalty for that should not be worth caring about, since that's infrequent. And fix a memory leak in FindOuterFacesFrom(), fix ugly output of filled triangles in PDF (because the line join style did bad things on long skinny triangles), fix non-zero Z coordinates for exported views or sections in DXF or STEP. [git-p4: depot-paths = "//depot/solvespace/": change = 2061]
2009-10-30 18:38:34 +08:00
void AddOpenPath(SBezier *sb);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void Clear();
Move code to find outer and inner contours (and which inner contours go with which outer contour) out of exportstep.cpp, since I'll need that to do filled contour export for the 2d file formats. Also add user interface to specify fill color. [git-p4: depot-paths = "//depot/solvespace/": change = 2057]
2009-10-23 01:16:20 +08:00
};
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
// Stuff for the surface trim curves: piecewise linear
Generate intersection curves for surfaces of extrusion along a 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]
2009-05-18 15:26:51 +08:00
class SCurvePt {
public:
int tag;
Vector p;
bool vertex;
};
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
class SCurve {
public:
hSCurve h;
Add Newton iterations to intersect a line with a surface at a 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]
2009-02-27 21:04:36 +08:00
// In a Boolean, C = A op B. The curves in A and B get copied into C, and
// therefore must get new hSCurves assigned. For the curves in A and B,
// we use newH to record their new handle in C.
hSCurve newH;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
enum class Source : uint32_t {
A = 100,
B = 200,
INTERSECTION = 300
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-10 03:50:32 +08:00
};
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
Source source;
Preparatory work for Boolean. Make the u and v coordinates of the 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]
2009-01-25 19:52:29 +08:00
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
bool isExact;
SBezier exact;
Generate intersection curves for surfaces of extrusion along a 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]
2009-05-18 15:26:51 +08:00
List<SCurvePt> pts;
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
More poking at Booleans; generate the unsplit intersection curves for planes against planes. [git-p4: depot-paths = "//depot/solvespace/": change = 1907]
2009-01-27 15:59:58 +08:00
hSSurface surfA;
hSSurface surfB;
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
static SCurve FromTransformationOf(SCurve *a, Vector t,
Quaternion q, double scale);
Add Newton iterations to intersect a line with a surface at a 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]
2009-02-27 21:04:36 +08:00
SCurve MakeCopySplitAgainst(SShell *agnstA, SShell *agnstB,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
SSurface *srfA, SSurface *srfB) const;
Generate intersection curves for surfaces of extrusion along a 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]
2009-05-18 15:26:51 +08:00
void RemoveShortSegments(SSurface *srfA, SSurface *srfB);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
SSurface *GetSurfaceA(SShell *a, SShell *b) const;
SSurface *GetSurfaceB(SShell *a, SShell *b) const;
Tear everything apart, moving away from meshes and toward shells. 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]
2009-01-23 11:30:30 +08:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void Clear();
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
};
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
// A segment of a curve by which a surface is trimmed: indicates which curve,
// by its handle, and the starting and ending points of our segment of it.
// The vector out points out of the surface; it, the surface outer normal,
// and a tangent to the beginning of the curve are all orthogonal.
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
class STrimBy {
public:
hSCurve curve;
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 17:19:59 +08:00
bool backwards;
// If a trim runs backwards, then start and finish still correspond to
// the actual start and finish, but they appear in reverse order in
// the referenced curve.
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
Vector start;
Vector finish;
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 20:08:19 +08:00
static STrimBy EntireCurve(SShell *shell, hSCurve hsc, bool backwards);
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
};
Fix stupidity in Point2d::DistanceToLine, and classify line 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]
2009-02-01 21:01:28 +08:00
// An intersection point between a line and a surface
class SInter {
public:
Add Newton iterations to intersect a line with a surface at a 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]
2009-02-27 21:04:36 +08:00
int tag;
Fix stupidity in Point2d::DistanceToLine, and classify line 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]
2009-02-01 21:01:28 +08:00
Vector p;
Add Newton iterations to intersect a line with a surface at a 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]
2009-02-27 21:04:36 +08:00
SSurface *srf;
Revamp the edge classification for Booleans. I no longer make a 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]
2009-06-04 11:59:40 +08:00
Point2d pinter;
Vector surfNormal; // of the intersecting surface, at pinter
bool onEdge; // pinter is on edge of trim poly
Fix stupidity in Point2d::DistanceToLine, and classify line 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]
2009-02-01 21:01:28 +08:00
};
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
// A rational polynomial surface in Bezier form.
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
class SSurface {
public:
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
enum class CombineAs : uint32_t {
UNION = 10,
DIFFERENCE = 11,
INTERSECT = 12
};
Add code to identify planes and cylindrical surfaces from a solid 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]
2009-06-05 13:38:41 +08:00
int tag;
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
hSSurface h;
Many changes: * 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]
2009-03-16 07:04:45 +08:00
// Same as newH for the curves; record what a surface gets renamed to
// when I copy things over.
hSSurface newH;
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
RgbaColor color;
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
uint32_t face;
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 17:19:59 +08:00
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
int degm, degn;
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
Vector ctrl[4][4];
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
double weight[4][4];
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
Entities now generate rational polynomial curves instead of piecwise linear segments. These are piecewise linear approximated for display, and currently for the mesh too, but that's the first step to replace the mesh with exact curved surfaces. [git-p4: depot-paths = "//depot/solvespace/": change = 1895]
2009-01-15 11:55:42 +08:00
List<STrimBy> trim;
Remove old sweep/helical sweep code for meshes, and add some untested stuff to start making exact surface shells. [git-p4: depot-paths = "//depot/solvespace/": change = 1896]
2009-01-17 13:28:49 +08:00
More work on Booleans. This works only for planes, and only for 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]
2009-02-01 13:13:43 +08:00
// For testing whether a point (u, v) on the surface lies inside the trim
SBspUv *bsp;
Revamp the edge classification for Booleans. I no longer make a 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]
2009-06-04 11:59:40 +08:00
SEdgeList edges;
More poking at Booleans; generate the unsplit intersection curves for planes against planes. [git-p4: depot-paths = "//depot/solvespace/": change = 1907]
2009-01-27 15:59:58 +08:00
Discard intersection curves that lie entirely outside of one 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]
2009-08-21 12:58:28 +08:00
// For caching our initial (u, v) when doing Newton iterations to project
// a point into our surface.
Point2d cached;
SPolyCurve (i.e., polynomial curve) vs. SPolygon got too confusing; let's call those Beziers instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1898]
2009-01-19 11:51:00 +08:00
static SSurface FromExtrusionOf(SBezier *spc, Vector t0, Vector t1);
Construct surfaces of revolution from lathe groups, although we're not triangulating them correctly yet. [git-p4: depot-paths = "//depot/solvespace/": change = 1950]
2009-04-29 10:42:44 +08:00
static SSurface FromRevolutionOf(SBezier *sb, Vector pt, Vector axis,
double thetas, double thetaf);
Preparatory work for Boolean. Make the u and v coordinates of the 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]
2009-01-25 19:52:29 +08:00
static SSurface FromPlane(Vector pt, Vector u, Vector v);
Add option to mirror imported geometry, including the shell, mesh, 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]
2009-10-09 20:57:10 +08:00
static SSurface FromTransformationOf(SSurface *a, Vector t, Quaternion q,
A big nasty change, originally just to add paste transformed. So it 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]
2009-12-15 20:26:22 +08:00
double scale,
Tear everything apart, moving away from meshes and toward shells. 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]
2009-01-23 11:30:30 +08:00
bool includingTrims);
Make the export scale factor affect the surfaces in a STEP file, and lay groundwork for wireframe export. [git-p4: depot-paths = "//depot/solvespace/": change = 2052]
2009-10-12 17:28:34 +08:00
void ScaleSelfBy(double s);
Remove old sweep/helical sweep code for meshes, and add some untested stuff to start making exact surface shells. [git-p4: depot-paths = "//depot/solvespace/": change = 1896]
2009-01-17 13:28:49 +08:00
Revamp the edge classification for Booleans. I no longer make a 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]
2009-06-04 11:59:40 +08:00
void EdgeNormalsWithinSurface(Point2d auv, Point2d buv,
Vector *pt, Vector *enin, Vector *enout,
Vector *surfn,
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
uint32_t auxA,
Add beginnings of marching surface intersection; I can find all the 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]
2009-06-19 15:56:33 +08:00
SShell *shell, SShell *sha, SShell *shb);
Group edges into chains (that don't intersect edges from the other 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]
2009-06-27 13:53:56 +08:00
void FindChainAvoiding(SEdgeList *src, SEdgeList *dest, SPointList *avoid);
Add beginnings of marching surface intersection; I can find all the 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]
2009-06-19 15:56:33 +08:00
SSurface MakeCopyTrimAgainst(SShell *parent, SShell *a, SShell *b,
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
SShell *into, SSurface::CombineAs type);
Add code to identify planes and cylindrical surfaces from a solid 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]
2009-06-05 13:38:41 +08:00
void TrimFromEdgeList(SEdgeList *el, bool asUv);
Trim trailing whitespace.
2015-03-29 08:30:52 +08:00
void IntersectAgainst(SSurface *b, SShell *agnstA, SShell *agnstB,
More work on Booleans. This works only for planes, and only for 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]
2009-02-01 13:13:43 +08:00
SShell *into);
Add Newton iterations to intersect a line with a surface at a 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]
2009-02-27 21:04:36 +08:00
void AddExactIntersectionCurve(SBezier *sb, SSurface *srfB,
Compute surface intersections in a way that is closer to what I 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]
2009-02-23 18:06:02 +08:00
SShell *agnstA, SShell *agnstB, SShell *into);
Add a special case for line-cylinder intersection, solving in 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]
2009-03-20 01:40:11 +08:00
Add code to subdivide (with de Castljau's algorithm) a surface, and 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]
2009-03-08 18:59:57 +08:00
typedef struct {
int tag;
Point2d p;
} Inter;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void WeightControlPoints();
void UnWeightControlPoints();
Add code to subdivide (with de Castljau's algorithm) a surface, and 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]
2009-03-08 18:59:57 +08:00
void CopyRowOrCol(bool row, int this_ij, SSurface *src, int src_ij);
void BlendRowOrCol(bool row, int this_ij, SSurface *a, int a_ij,
SSurface *b, int b_ij);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
double DepartureFromCoplanar() const;
Add code to subdivide (with de Castljau's algorithm) a surface, and 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]
2009-03-08 18:59:57 +08:00
void SplitInHalf(bool byU, SSurface *sa, SSurface *sb);
Compute surface intersections in a way that is closer to what I 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]
2009-02-23 18:06:02 +08:00
void AllPointsIntersecting(Vector a, Vector b,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
List<SInter> *l,
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 20:08:19 +08:00
bool asSegment, bool trimmed, bool inclTangent);
Add code to subdivide (with de Castljau's algorithm) a surface, and 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]
2009-03-08 18:59:57 +08:00
void AllPointsIntersectingUntrimmed(Vector a, Vector b,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
int *cnt, int *level,
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 20:08:19 +08:00
List<Inter> *l, bool asSegment,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
SSurface *sorig);
Preparatory work for Boolean. Make the u and v coordinates of the 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]
2009-01-25 19:52:29 +08:00
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 20:08:19 +08:00
void ClosestPointTo(Vector p, Point2d *puv, bool mustConverge=true);
void ClosestPointTo(Vector p, double *u, double *v, bool mustConverge=true);
bool ClosestPointNewton(Vector p, double *u, double *v, bool mustConverge=true) const;
Discard intersection curves that lie entirely outside of one 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]
2009-08-21 12:58:28 +08:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
bool PointIntersectingLine(Vector p0, Vector p1, double *u, double *v) const;
Revamp the edge classification for Booleans. I no longer make a 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]
2009-06-04 11:59:40 +08:00
Vector ClosestPointOnThisAndSurface(SSurface *srf2, Vector p);
Add Newton iterations to intersect a line with a surface at a 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]
2009-02-27 21:04:36 +08:00
void PointOnSurfaces(SSurface *s1, SSurface *s2, double *u, double *v);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
Vector PointAt(double u, double v) const;
Vector PointAt(Point2d puv) const;
void TangentsAt(double u, double v, Vector *tu, Vector *tv) const;
Vector NormalAt(Point2d puv) const;
Vector NormalAt(double u, double v) const;
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 20:08:19 +08:00
bool LineEntirelyOutsideBbox(Vector a, Vector b, bool asSegment) const;
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
void GetAxisAlignedBounding(Vector *ptMax, Vector *ptMin) const;
bool CoincidentWithPlane(Vector n, double d) const;
bool CoincidentWith(SSurface *ss, bool sameNormal) const;
bool IsExtrusion(SBezier *of, Vector *along) const;
Add exact export of arcs for EPS, DXF, SVG, and of nonrational polynomial curves for SVG. [git-p4: depot-paths = "//depot/solvespace/": change = 1937]
2009-04-15 10:55:18 +08:00
bool IsCylinder(Vector *axis, Vector *center, double *r,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
Vector *start, Vector *finish) const;
Generate the group's polygon from the exact curves, not from edges; so now we've got the exact curve loops, with their direction standardized so that we can tell which direction is out. We still need the polygon in any case, since that's a convenient way to find each curve's winding number. And remove some more leftover code from mesh sweeps. [git-p4: depot-paths = "//depot/solvespace/": change = 1897]
2009-01-19 11:33:15 +08:00
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
void TriangulateInto(SShell *shell, SMesh *sm);
Discard intersection curves that lie entirely outside of one 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]
2009-08-21 12:58:28 +08:00
// these are intended as bitmasks, even though there's just one now
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
enum class MakeAs : uint32_t {
UV = 0x01,
XYZ = 0x00
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-10 03:50:32 +08:00
};
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
void MakeTrimEdgesInto(SEdgeList *sel, MakeAs flags, SCurve *sc, STrimBy *stb);
void MakeEdgesInto(SShell *shell, SEdgeList *sel, MakeAs flags,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
SShell *useCurvesFrom=NULL);
Discard intersection curves that lie entirely outside of one 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]
2009-08-21 12:58:28 +08:00
Clean up the marching step size / chord tol stuff, and add code to export an inexact curve by approximating it with piecwise cubic segments (whose endpoints lie exactly on the curve, and with exact tangent directions at the endpoints). [git-p4: depot-paths = "//depot/solvespace/": change = 1995]
2009-06-22 10:54:09 +08:00
Vector ExactSurfaceTangentAt(Vector p, SSurface *srfA, SSurface *srfB,
Vector dir);
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 12:19:23 +08:00
void MakeSectionEdgesInto(SShell *shell, SEdgeList *sel, SBezierList *sbl);
Revamp the edge classification for Booleans. I no longer make a 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]
2009-06-04 11:59:40 +08:00
void MakeClassifyingBsp(SShell *shell, SShell *useCurvesFrom);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
double ChordToleranceForEdge(Vector a, Vector b) const;
Add triangulation of surfaces with compound curvature; I just build a grid of quads, with adaptive spacing. The quads that lie entirely within the trim polygon are triangulated and knocked out from the polygon, and then the polygon is triangulated. That works okay, though rather slow. But there are issues with surfaces of revolution that touch the axis, since they end up with a singularity. That will require some thought. [git-p4: depot-paths = "//depot/solvespace/": change = 1951]
2009-05-08 16:33:04 +08:00
void MakeTriangulationGridInto(List<double> *l, double vs, double vf,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
bool swapped) const;
Vector PointAtMaybeSwapped(double u, double v, bool swapped) const;
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void Reverse();
void Clear();
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
};
class SShell {
public:
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 13:10:42 +08:00
IdList<SCurve,hSCurve> curve;
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
IdList<SSurface,hSSurface> surface;
Remove old sweep/helical sweep code for meshes, and add some untested stuff to start making exact surface shells. [git-p4: depot-paths = "//depot/solvespace/": change = 1896]
2009-01-17 13:28:49 +08:00
If a Boolean fails, then make a note of it in the group's text 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]
2009-05-30 16:49:09 +08:00
bool booleanFailed;
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 17:19:59 +08:00
void MakeFromExtrusionOf(SBezierLoopSet *sbls, Vector t0, Vector t1,
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
RgbaColor color);
Construct surfaces of revolution from lathe groups, although we're not triangulating them correctly yet. [git-p4: depot-paths = "//depot/solvespace/": change = 1950]
2009-04-29 10:42:44 +08:00
void MakeFromRevolutionOf(SBezierLoopSet *sbls, Vector pt, Vector axis,
Generate primitives for lathe groups. The primitives that are generated are circles from points and faces from axis-perpendicular line segments.
2015-10-31 16:22:26 +08:00
RgbaColor color, Group *group);
Preparatory work for Boolean. Make the u and v coordinates of the 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]
2009-01-25 19:52:29 +08:00
Tear everything apart, moving away from meshes and toward shells. 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]
2009-01-23 11:30:30 +08:00
void MakeFromUnionOf(SShell *a, SShell *b);
void MakeFromDifferenceOf(SShell *a, SShell *b);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
void MakeFromBoolean(SShell *a, SShell *b, SSurface::CombineAs type);
Add Newton iterations to intersect a line with a surface at a 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]
2009-02-27 21:04:36 +08:00
void CopyCurvesSplitAgainst(bool opA, SShell *agnst, SShell *into);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
void CopySurfacesTrimAgainst(SShell *sha, SShell *shb, SShell *into, SSurface::CombineAs type);
More poking at Booleans; generate the unsplit intersection curves for planes against planes. [git-p4: depot-paths = "//depot/solvespace/": change = 1907]
2009-01-27 15:59:58 +08:00
void MakeIntersectionCurvesAgainst(SShell *against, SShell *into);
Revamp the edge classification for Booleans. I no longer make a 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]
2009-06-04 11:59:40 +08:00
void MakeClassifyingBsps(SShell *useCurvesFrom);
Compute surface intersections in a way that is closer to what I 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]
2009-02-23 18:06:02 +08:00
void AllPointsIntersecting(Vector a, Vector b, List<SInter> *il,
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 20:08:19 +08:00
bool asSegment, bool trimmed, bool inclTangent);
Make Boolean union work when the shells have coincident plane faces. Still on planes only, no curved surface intersections. [git-p4: depot-paths = "//depot/solvespace/": change = 1912]
2009-02-09 20:40:48 +08:00
void MakeCoincidentEdgesInto(SSurface *proto, bool sameNormal,
Many changes: * 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]
2009-03-16 07:04:45 +08:00
SEdgeList *el, SShell *useCurvesFrom);
Add code to assemble two shells into one, without checking for any intersections or otherwise trying to make the result not self-intersecting. [git-p4: depot-paths = "//depot/solvespace/": change = 1955]
2009-05-20 11:04:36 +08:00
void RewriteSurfaceHandlesForCurves(SShell *a, SShell *b);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void CleanupAfterBoolean();
Preparatory work for Boolean. Make the u and v coordinates of the 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]
2009-01-25 19:52:29 +08:00
Revamp the edge classification for Booleans. I no longer make a 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]
2009-06-04 11:59:40 +08:00
// Definitions when classifying regions of a surface; it is either inside,
// outside, or coincident (with parallel or antiparallel normal) with a
// shell.
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
enum class Class : uint32_t {
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-10 03:50:32 +08:00
INSIDE = 100,
OUTSIDE = 200,
COINC_SAME = 300,
COINC_OPP = 400
};
Revamp the edge classification for Booleans. I no longer make a 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]
2009-06-04 11:59:40 +08:00
static const double DOTP_TOL;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
Class ClassifyRegion(Vector edge_n, Vector inter_surf_n,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
Vector edge_surf_n) const;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 16:31:20 +08:00
bool ClassifyEdge(Class *indir, Class *outdir,
Revamp the edge classification for Booleans. I no longer make a 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]
2009-06-04 11:59:40 +08:00
Vector ea, Vector eb,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
Vector p, Vector edge_n_in,
Vector edge_n_out, Vector surf_n);
Fix stupidity in Point2d::DistanceToLine, and classify line 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]
2009-02-01 21:01:28 +08:00
Tear everything apart, moving away from meshes and toward shells. 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]
2009-01-23 11:30:30 +08:00
void MakeFromCopyOf(SShell *a);
A big nasty change, originally just to add paste transformed. So it 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]
2009-12-15 20:26:22 +08:00
void MakeFromTransformationOf(SShell *a,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
Vector trans, Quaternion q, double scale);
Add code to assemble two shells into one, without checking for any intersections or otherwise trying to make the result not self-intersecting. [git-p4: depot-paths = "//depot/solvespace/": change = 1955]
2009-05-20 11:04:36 +08:00
void MakeFromAssemblyOf(SShell *a, SShell *b);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void MergeCoincidentSurfaces();
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
void TriangulateInto(SMesh *sm);
Tear everything apart, moving away from meshes and toward shells. 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]
2009-01-23 11:30:30 +08:00
void MakeEdgesInto(SEdgeList *sel);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 13:18:00 +08:00
void MakeSectionEdgesInto(Vector n, double d, SEdgeList *sel, SBezierList *sbl);
bool IsEmpty() const;
Add ability to represent our surfaces as either a shell or a mesh, according to the user's preference. I templated the housekeeping stuff for Boolean operations and step and repeat, so it's relatively clean. Still need to add the stuff to make a mesh vertex-to-vertex, and to export sections of a mesh. [git-p4: depot-paths = "//depot/solvespace/": change = 1959]
2009-05-24 19:37:07 +08:00
void RemapFaces(Group *g, int remap);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 13:54:05 +08:00
void Clear();
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
};
#endif
Reference in New Issue Copy Permalink