zcy
/
solvespace
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
solvespace/src/lib.cpp

255 lines
8.8 KiB
C++
Raw Normal View History

Clean up SolveSpace makefile, and add forgotten copyright notice. [git-p4: depot-paths = "//depot/solvespace/": change = 2213]
2013-07-28 22:53:30 +00:00
//-----------------------------------------------------------------------------
// A library wrapper around SolveSpace, to permit someone to use its constraint
// solver without coupling their program too much to SolveSpace's internals.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
#include "solvespace.h"
Build the demo version of the solver library as a DLL, not a static library. If I understand correctly, that will avoid all the compiler version issues with different required versions of libc. [git-p4: depot-paths = "//depot/solvespace/": change = 2167]
2010-07-10 18:53:30 +00:00
#define EXPORT_DLL
Move library header to include/ directory
2015-03-02 18:06:59 +00:00
#include <slvs.h>
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Sketch SolveSpace::SK = {};
Added the exposed/ library and demo program to the Autotools build The libslvs library and CDemo program can now be built by Autotools. A few code changes were needed for this: C++ comments in C code had to be converted, constraint.cpp required some massaging, and fltkutil.cpp needed a stub for InitHeaps().
2013-11-18 07:31:23 +00:00
static System SYS;
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
Make some arguments const/const references, where possible. NFC. Found and suggested by clang-tidy.May help performance by reducing copies, depending on frequency of call, etc.
2019-11-23 14:07:31 +00:00
void SolveSpace::Platform::FatalError(const std::string &message) {
macOS: put assertion message into crash reporter dialog. This commit makes FatalError a GUI-dependent function.
2018-07-17 12:32:58 +00:00
fprintf(stderr, "%s", message.c_str());
abort();
}
Enable -Wall -Wextra -Wno-unused-parameter on GCC/Clang. This is good practice and helps to catch bugs. Several changes were made to accomodate the newly enabled warnings: * -Wunused-function: * in exposed/, static functions that were supposed to be inlined were explicitly marked as inline; * some actually unused functions were removed; * -Wsign-compare: explicit conversions were added, and in the future we should find a nicer way than aux* fields; * -Wmissing-field-initializers: added initializers; * -Wreorder: reordered properly; * -Wunused-but-set-variable: remove variable. -Wunused-parameter was turned off as enabling it would result in massive amount of churn in UI code. Despite that, we should enable it at some point as it has a fairly high SNR otherwise.
2016-05-07 23:34:21 +00:00
void Group::GenerateEquations(IdList<Equation,hEquation> *) {
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
// Nothing to do for now.
}
extern "C" {
void Slvs_QuaternionU(double qw, double qx, double qy, double qz,
double *x, double *y, double *z)
{
Quaternion q = Quaternion::From(qw, qx, qy, qz);
Vector v = q.RotationU();
*x = v.x;
*y = v.y;
*z = v.z;
}
void Slvs_QuaternionV(double qw, double qx, double qy, double qz,
double *x, double *y, double *z)
{
Quaternion q = Quaternion::From(qw, qx, qy, qz);
Vector v = q.RotationV();
*x = v.x;
*y = v.y;
*z = v.z;
}
void Slvs_QuaternionN(double qw, double qx, double qy, double qz,
double *x, double *y, double *z)
{
Quaternion q = Quaternion::From(qw, qx, qy, qz);
Vector v = q.RotationN();
*x = v.x;
*y = v.y;
*z = v.z;
}
void Slvs_MakeQuaternion(double ux, double uy, double uz,
double vx, double vy, double vz,
double *qw, double *qx, double *qy, double *qz)
{
Vector u = Vector::From(ux, uy, uz),
v = Vector::From(vx, vy, vz);
Quaternion q = Quaternion::From(u, v);
*qw = q.w;
*qx = q.vx;
*qy = q.vy;
*qz = q.vz;
}
void Slvs_Solve(Slvs_System *ssys, Slvs_hGroup shg)
{
int i;
for(i = 0; i < ssys->params; i++) {
Slvs_Param *sp = &(ssys->param[i]);
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Param p = {};
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
p.h.v = sp->h;
p.val = sp->val;
SK.param.Add(&p);
if(sp->group == shg) {
SYS.param.Add(&p);
}
}
for(i = 0; i < ssys->entities; i++) {
Slvs_Entity *se = &(ssys->entity[i]);
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
EntityBase e = {};
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
switch(se->type) {
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 08:31:20 +00:00
case SLVS_E_POINT_IN_3D: e.type = Entity::Type::POINT_IN_3D; break;
case SLVS_E_POINT_IN_2D: e.type = Entity::Type::POINT_IN_2D; break;
case SLVS_E_NORMAL_IN_3D: e.type = Entity::Type::NORMAL_IN_3D; break;
case SLVS_E_NORMAL_IN_2D: e.type = Entity::Type::NORMAL_IN_2D; break;
case SLVS_E_DISTANCE: e.type = Entity::Type::DISTANCE; break;
case SLVS_E_WORKPLANE: e.type = Entity::Type::WORKPLANE; break;
case SLVS_E_LINE_SEGMENT: e.type = Entity::Type::LINE_SEGMENT; break;
case SLVS_E_CUBIC: e.type = Entity::Type::CUBIC; break;
case SLVS_E_CIRCLE: e.type = Entity::Type::CIRCLE; break;
case SLVS_E_ARC_OF_CIRCLE: e.type = Entity::Type::ARC_OF_CIRCLE; break;
Add locked-where-dragged constraint to library interface, and update some copyright dates and bad grammar in comments. [git-p4: depot-paths = "//depot/solvespace/": change = 2137]
2010-05-07 02:13:57 +00:00
default: dbp("bad entity type %d", se->type); return;
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
}
e.h.v = se->h;
e.group.v = se->group;
e.workplane.v = se->wrkpl;
e.point[0].v = se->point[0];
e.point[1].v = se->point[1];
e.point[2].v = se->point[2];
e.point[3].v = se->point[3];
e.normal.v = se->normal;
e.distance.v = se->distance;
e.param[0].v = se->param[0];
e.param[1].v = se->param[1];
e.param[2].v = se->param[2];
e.param[3].v = se->param[3];
SK.entity.Add(&e);
}
Explicitly represent the parameter used in constraints. Commit f5485cb and its ancestors add a parameter to some constraints. This parameter must be materialized and assigned a non-zero value via ModifyToSatisfy for the solver library to not make unnecessary changes to the sketch during the initial generation. For this, we represent it explicitly instead of using hc.param(0), such that the materialized constraint does not conflict with any user-defined ones.
2017-01-25 16:39:26 +00:00
IdList<Param, hParam> params = {};
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
for(i = 0; i < ssys->constraints; i++) {
Slvs_Constraint *sc = &(ssys->constraint[i]);
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
ConstraintBase c = {};
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00: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 08:31:20 +00:00
Constraint::Type t;
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
switch(sc->type) {
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 08:31:20 +00:00
case SLVS_C_POINTS_COINCIDENT: t = Constraint::Type::POINTS_COINCIDENT; break;
case SLVS_C_PT_PT_DISTANCE: t = Constraint::Type::PT_PT_DISTANCE; break;
case SLVS_C_PT_PLANE_DISTANCE: t = Constraint::Type::PT_PLANE_DISTANCE; break;
case SLVS_C_PT_LINE_DISTANCE: t = Constraint::Type::PT_LINE_DISTANCE; break;
case SLVS_C_PT_FACE_DISTANCE: t = Constraint::Type::PT_FACE_DISTANCE; break;
case SLVS_C_PT_IN_PLANE: t = Constraint::Type::PT_IN_PLANE; break;
case SLVS_C_PT_ON_LINE: t = Constraint::Type::PT_ON_LINE; break;
case SLVS_C_PT_ON_FACE: t = Constraint::Type::PT_ON_FACE; break;
case SLVS_C_EQUAL_LENGTH_LINES: t = Constraint::Type::EQUAL_LENGTH_LINES; break;
case SLVS_C_LENGTH_RATIO: t = Constraint::Type::LENGTH_RATIO; break;
case SLVS_C_EQ_LEN_PT_LINE_D: t = Constraint::Type::EQ_LEN_PT_LINE_D; break;
case SLVS_C_EQ_PT_LN_DISTANCES: t = Constraint::Type::EQ_PT_LN_DISTANCES; break;
case SLVS_C_EQUAL_ANGLE: t = Constraint::Type::EQUAL_ANGLE; break;
case SLVS_C_EQUAL_LINE_ARC_LEN: t = Constraint::Type::EQUAL_LINE_ARC_LEN; break;
case SLVS_C_LENGTH_DIFFERENCE: t = Constraint::Type::LENGTH_DIFFERENCE; break;
case SLVS_C_SYMMETRIC: t = Constraint::Type::SYMMETRIC; break;
case SLVS_C_SYMMETRIC_HORIZ: t = Constraint::Type::SYMMETRIC_HORIZ; break;
case SLVS_C_SYMMETRIC_VERT: t = Constraint::Type::SYMMETRIC_VERT; break;
case SLVS_C_SYMMETRIC_LINE: t = Constraint::Type::SYMMETRIC_LINE; break;
case SLVS_C_AT_MIDPOINT: t = Constraint::Type::AT_MIDPOINT; break;
case SLVS_C_HORIZONTAL: t = Constraint::Type::HORIZONTAL; break;
case SLVS_C_VERTICAL: t = Constraint::Type::VERTICAL; break;
case SLVS_C_DIAMETER: t = Constraint::Type::DIAMETER; break;
case SLVS_C_PT_ON_CIRCLE: t = Constraint::Type::PT_ON_CIRCLE; break;
case SLVS_C_SAME_ORIENTATION: t = Constraint::Type::SAME_ORIENTATION; break;
case SLVS_C_ANGLE: t = Constraint::Type::ANGLE; break;
case SLVS_C_PARALLEL: t = Constraint::Type::PARALLEL; break;
case SLVS_C_PERPENDICULAR: t = Constraint::Type::PERPENDICULAR; break;
case SLVS_C_ARC_LINE_TANGENT: t = Constraint::Type::ARC_LINE_TANGENT; break;
case SLVS_C_CUBIC_LINE_TANGENT: t = Constraint::Type::CUBIC_LINE_TANGENT; break;
case SLVS_C_EQUAL_RADIUS: t = Constraint::Type::EQUAL_RADIUS; break;
case SLVS_C_PROJ_PT_DISTANCE: t = Constraint::Type::PROJ_PT_DISTANCE; break;
case SLVS_C_WHERE_DRAGGED: t = Constraint::Type::WHERE_DRAGGED; break;
case SLVS_C_CURVE_CURVE_TANGENT:t = Constraint::Type::CURVE_CURVE_TANGENT; break;
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
default: dbp("bad constraint type %d", sc->type); return;
}
c.type = t;
c.h.v = sc->h;
c.group.v = sc->group;
c.workplane.v = sc->wrkpl;
c.valA = sc->valA;
c.ptA.v = sc->ptA;
c.ptB.v = sc->ptB;
c.entityA.v = sc->entityA;
c.entityB.v = sc->entityB;
c.entityC.v = sc->entityC;
c.entityD.v = sc->entityD;
c.other = (sc->other) ? true : false;
Add a constraint for tangency between any combination of arcs and cubics. Also add that to the library interface. It might have been better to use a single constraint for that, plus all the line-curve or line-line cases, but it would break backwards compatibility if I did that now, and perhaps be confusing with the 'other' member (which is meaningless for lines) anyways. [git-p4: depot-paths = "//depot/solvespace/": change = 2141]
2010-05-10 04:14:06 +00:00
c.other2 = (sc->other2) ? true : false;
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
Explicitly represent the parameter used in constraints. Commit f5485cb and its ancestors add a parameter to some constraints. This parameter must be materialized and assigned a non-zero value via ModifyToSatisfy for the solver library to not make unnecessary changes to the sketch during the initial generation. For this, we represent it explicitly instead of using hc.param(0), such that the materialized constraint does not conflict with any user-defined ones.
2017-01-25 16:39:26 +00:00
c.Generate(&params);
Add and use IdList::IsEmpty. NFC. Removes consuming code from the implementation details, easing swap of the underlying container, etc.
2018-01-03 21:10:18 +00:00
if(!params.IsEmpty()) {
Explicitly represent the parameter used in constraints. Commit f5485cb and its ancestors add a parameter to some constraints. This parameter must be materialized and assigned a non-zero value via ModifyToSatisfy for the solver library to not make unnecessary changes to the sketch during the initial generation. For this, we represent it explicitly instead of using hc.param(0), such that the materialized constraint does not conflict with any user-defined ones.
2017-01-25 16:39:26 +00:00
for(Param &p : params) {
p.h = SK.param.AddAndAssignId(&p);
c.valP = p.h;
SYS.param.Add(&p);
}
params.Clear();
c.ModifyToSatisfy();
}
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
SK.constraint.Add(&c);
}
Added the exposed/ library and demo program to the Autotools build The libslvs library and CDemo program can now be built by Autotools. A few code changes were needed for this: C++ comments in C code had to be converted, constraint.cpp required some massaging, and fltkutil.cpp needed a stub for InitHeaps().
2013-11-18 07:31:23 +00:00
for(i = 0; i < (int)arraylen(ssys->dragged); i++) {
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
if(ssys->dragged[i]) {
hParam hp = { ssys->dragged[i] };
SYS.dragged.Add(&hp);
}
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
}
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Group g = {};
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
g.h.v = shg;
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
List<hConstraint> bad = {};
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
// Now we're finally ready to solve!
Add a solver option to not calculate the failing constraints if we're inconsistent (singular Jacobian). That's slow, so we should provide a library interface to disable it. [git-p4: depot-paths = "//depot/solvespace/": change = 1946]
2009-04-21 07:56:17 +00:00
bool andFindBad = ssys->calculateFaileds ? true : false;
Commit missing parts of cf2f0e5d.
2019-05-24 16:02:01 +00:00
SolveResult how = SYS.Solve(&g, NULL, &(ssys->dof), &bad, andFindBad, /*andFindFree=*/false);
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
switch(how) {
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 08:31:20 +00:00
case SolveResult::OKAY:
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
ssys->result = SLVS_RESULT_OKAY;
break;
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 08:31:20 +00:00
case SolveResult::DIDNT_CONVERGE:
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
ssys->result = SLVS_RESULT_DIDNT_CONVERGE;
break;
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 08:31:20 +00:00
case SolveResult::REDUNDANT_DIDNT_CONVERGE:
case SolveResult::REDUNDANT_OKAY:
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
ssys->result = SLVS_RESULT_INCONSISTENT;
break;
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 08:31:20 +00:00
case SolveResult::TOO_MANY_UNKNOWNS:
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
ssys->result = SLVS_RESULT_TOO_MANY_UNKNOWNS;
break;
}
// Write the new parameter values back to our caller.
for(i = 0; i < ssys->params; i++) {
Slvs_Param *sp = &(ssys->param[i]);
hParam hp = { sp->h };
sp->val = SK.GetParam(hp)->val;
}
if(ssys->failed) {
// Copy over any the list of problematic constraints.
for(i = 0; i < ssys->faileds && i < bad.n; i++) {
Improve implementation hiding in IdList/List. NFC. Allows distancing users from the internal "elem" member. Add Get() and operator[]. Replace direct references to elem. Make elem and elemsAllocated private in IdList/List.
2019-05-23 17:09:47 +00:00
ssys->failed[i] = bad[i].v;
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
}
ssys->faileds = bad.n;
}
bad.Clear();
SYS.param.Clear();
Oops, forgot to clear out the equations (and the entities, though I don't use them) in the System. [git-p4: depot-paths = "//depot/solvespace/": change = 1949]
2009-04-25 01:27:45 +00:00
SYS.entity.Clear();
SYS.eq.Clear();
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
SYS.dragged.Clear();
Oops, forgot to clear out the equations (and the entities, though I don't use them) in the System. [git-p4: depot-paths = "//depot/solvespace/": change = 1949]
2009-04-25 01:27:45 +00:00
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
SK.param.Clear();
SK.entity.Clear();
SK.constraint.Clear();
Oops, fix gross memory leak in SolveSpace library due to failure to destroy temporary heap. [git-p4: depot-paths = "//depot/solvespace/": change = 2210]
2013-03-15 16:43:35 +00:00
FreeAllTemporary();
The constraint solver now compiles as a library, and I have a little test app that links against it. I still need to polish a few things, but this is more or less as it should be. [git-p4: depot-paths = "//depot/solvespace/": change = 1944]
2009-04-20 07:30:09 +00:00
}
Added the exposed/ library and demo program to the Autotools build The libslvs library and CDemo program can now be built by Autotools. A few code changes were needed for this: C++ comments in C code had to be converted, constraint.cpp required some massaging, and fltkutil.cpp needed a stub for InitHeaps().
2013-11-18 07:31:23 +00:00
} /* extern "C" */