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

784 lines
28 KiB
C++
Raw Normal View History

Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
#include "solvespace.h"
Many user interface additions. Now I report when the solver fails, and in the case of a singular Jacobian, report which constraints can be removed to fix it. Also a mechanism to hover and select entities and constraints from the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1746]
2008-05-26 09:56:50 +00:00
const hConstraint Constraint::NO_CONSTRAINT = { 0 };
Add the first `derived' group, that generates entities based on other entities. This requires a new point type, for a point that's defined as a transformation of some other point. All works nicely, I think. There's ugliness because entities are no longer guaranteed to have a parent request. Also speed up display of the text window, by caching brushes instead of recreating for each character (!), and add a bit more user interface in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1692]
2008-04-27 09:03:01 +00:00
char *Constraint::DescriptionString(void) {
static char ret[1024];
Start to describe the selected entities in the text window. Also more starting work on the selectable faces, and fiddling in an attempt to remove dependencies when stuff gets deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 1760]
2008-06-01 00:26:41 +00:00
char *s;
switch(type) {
case POINTS_COINCIDENT: s = "pts-coincident"; break;
case PT_PT_DISTANCE: s = "pt-pt-distance"; break;
case PT_LINE_DISTANCE: s = "pt-line-distance"; break;
case PT_PLANE_DISTANCE: s = "pt-plane-distance"; break;
case PT_IN_PLANE: s = "pt-in-plane"; break;
case PT_ON_LINE: s = "pt-on-line"; break;
case PT_ON_FACE: s = "pt-on-face"; break;
case EQUAL_LENGTH_LINES:s = "eq-length"; break;
case LENGTH_RATIO: s = "length-ratio"; break;
case SYMMETRIC: s = "symmetric"; break;
case SYMMETRIC_HORIZ: s = "symmetric-h"; break;
case SYMMETRIC_VERT: s = "symmetric-v"; break;
case AT_MIDPOINT: s = "at-midpoint"; break;
case HORIZONTAL: s = "horizontal"; break;
case VERTICAL: s = "vertical"; break;
case DIAMETER: s = "diameter"; break;
case PT_ON_CIRCLE: s = "pt-on-circle"; break;
case SAME_ORIENTATION: s = "same-orientation"; break;
case ANGLE: s = "angle"; break;
case PARALLEL: s = "parallel"; break;
case EQUAL_RADIUS: s = "eq-radius"; break;
default: s = "???"; break;
}
sprintf(ret, "c%03x-%s", h.v, s);
Add the first `derived' group, that generates entities based on other entities. This requires a new point type, for a point that's defined as a transformation of some other point. All works nicely, I think. There's ugliness because entities are no longer guaranteed to have a parent request. Also speed up display of the text window, by caching brushes instead of recreating for each character (!), and add a bit more user interface in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1692]
2008-04-27 09:03:01 +00:00
return ret;
}
Fix a crash; it was possible to attempt to draw in a workplane that's in a group that solves after the current group. This means that the constraint/request gets deleted instantly, and stuff like auto-constraints on the just-created entities blow up. I now check that the active workplane comes from the active group or one solved before it. [git-p4: depot-paths = "//depot/solvespace/": change = 1729]
2008-05-17 23:48:58 +00:00
void Constraint::AddConstraint(Constraint *c) {
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
SS.constraint.AddAndAssignId(c);
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
Consolidate the code that determines whether an entity is visible in one place. And remove the ability to disable the solver, since that's unlikely to be anything but confusing (and in any case, was badly implemented). This is in preparation for selective solving, of only the dirty groups. [git-p4: depot-paths = "//depot/solvespace/": change = 1769]
2008-06-02 09:31:26 +00:00
SS.GenerateAll();
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
}
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
void Constraint::Constrain(int type, hEntity ptA, hEntity ptB, hEntity entityA)
{
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
Constraint c;
memset(&c, 0, sizeof(c));
c.group = SS.GW.activeGroup;
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
c.workplane = SS.GW.ActiveWorkplane();
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
c.type = type;
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
c.ptA = ptA;
c.ptB = ptB;
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
c.entityA = entityA;
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
AddConstraint(&c);
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
}
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
void Constraint::ConstrainCoincident(hEntity ptA, hEntity ptB) {
Constrain(POINTS_COINCIDENT, ptA, ptB, Entity::NO_ENTITY);
Add a convenience command to draw a rectangle (as four line segments), add the toggle construction command, and color the lines differently depending on what group you're in. Also change dynamic memory stuff to use a Win32 heap for everything (no malloc), and validate that often. I think I've seen it crash, though I can't reproduce it. [git-p4: depot-paths = "//depot/solvespace/": change = 1708]
2008-05-07 04:17:29 +00:00
}
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
void Constraint::MenuConstrain(int id) {
Constraint c;
memset(&c, 0, sizeof(c));
c.group = SS.GW.activeGroup;
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
c.workplane = SS.GW.ActiveWorkplane();
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
SS.GW.GroupSelection();
#define gs (SS.GW.gs)
switch(id) {
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
case GraphicsWindow::MNU_DISTANCE_DIA: {
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
if(gs.points == 2 && gs.n == 2) {
c.type = PT_PT_DISTANCE;
c.ptA = gs.point[0];
c.ptB = gs.point[1];
} else if(gs.lineSegments == 1 && gs.n == 1) {
c.type = PT_PT_DISTANCE;
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 11:09:47 +00:00
Entity *e = SS.GetEntity(gs.entity[0]);
A great renaming. 2d coordinate systems are now called workplanes, and the associated entities are now just points. [git-p4: depot-paths = "//depot/solvespace/": change = 1690]
2008-04-27 03:26:27 +00:00
c.ptA = e->point[0];
c.ptB = e->point[1];
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
} else if(gs.workplanes == 1 && gs.points == 1 && gs.n == 2) {
c.type = PT_PLANE_DISTANCE;
c.ptA = gs.point[0];
c.entityA = gs.entity[0];
} else if(gs.lineSegments == 1 && gs.points == 1 && gs.n == 2) {
c.type = PT_LINE_DISTANCE;
c.ptA = gs.point[0];
c.entityA = gs.entity[0];
Add a diameter constraint, and add a `distance' entity that I can remap when I copy circle entities, in order to make the radius numerical somehow (analogy with the POINT_ and NORMAL_XFRMD) thing. [git-p4: depot-paths = "//depot/solvespace/": change = 1710]
2008-05-07 08:19:37 +00:00
} else if(gs.circlesOrArcs == 1 && gs.n == 1) {
c.type = DIAMETER;
c.entityA = gs.entity[0];
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
} else {
Error("Bad selection for distance / diameter constraint.");
return;
}
Add a diameter constraint, and add a `distance' entity that I can remap when I copy circle entities, in order to make the radius numerical somehow (analogy with the POINT_ and NORMAL_XFRMD) thing. [git-p4: depot-paths = "//depot/solvespace/": change = 1710]
2008-05-07 08:19:37 +00:00
if(c.type == PT_PT_DISTANCE) {
Vector n = SS.GW.projRight.Cross(SS.GW.projUp);
Vector a = SS.GetEntity(c.ptA)->PointGetNum();
Vector b = SS.GetEntity(c.ptB)->PointGetNum();
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
c.disp.offset = n.Cross(a.Minus(b));
c.disp.offset = (c.disp.offset).WithMagnitude(50/SS.GW.scale);
Add a diameter constraint, and add a `distance' entity that I can remap when I copy circle entities, in order to make the radius numerical somehow (analogy with the POINT_ and NORMAL_XFRMD) thing. [git-p4: depot-paths = "//depot/solvespace/": change = 1710]
2008-05-07 08:19:37 +00:00
} else {
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
c.disp.offset = Vector::From(0, 0, 0);
Add a diameter constraint, and add a `distance' entity that I can remap when I copy circle entities, in order to make the radius numerical somehow (analogy with the POINT_ and NORMAL_XFRMD) thing. [git-p4: depot-paths = "//depot/solvespace/": change = 1710]
2008-05-07 08:19:37 +00:00
}
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
c.exprA = Expr::From("0")->DeepCopyKeep();
Some graphics tweaks, to the order in which stuff gets drawn, to determine what goes in front (e.g. put a drawn line in front of the reference plane, even if the z order would want the opposite), and some tweaks to the mouse behaviour, and a function to modify constraints like dimensions so that the are initially satisfied. [git-p4: depot-paths = "//depot/solvespace/": change = 1681]
2008-04-22 10:53:42 +00:00
c.ModifyToSatisfy();
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
AddConstraint(&c);
break;
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
}
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
Start to add some constraint stuff. I now have point-coincident, and point-in-plane. These work, but the equation is still stupid, solving everything at once and not substituting trivial equations. [git-p4: depot-paths = "//depot/solvespace/": change = 1677]
2008-04-21 08:16:38 +00:00
case GraphicsWindow::MNU_ON_ENTITY:
if(gs.points == 2 && gs.n == 2) {
c.type = POINTS_COINCIDENT;
c.ptA = gs.point[0];
c.ptB = gs.point[1];
Now we can add new workplanes. So fix all the mistakes that I hadn't previously noticed, because I didn't use to have workplanes with non-zero offsets. And clean up the interface to normals a bit. [git-p4: depot-paths = "//depot/solvespace/": change = 1707]
2008-05-05 11:17:00 +00:00
} else if(gs.points == 1 && gs.workplanes == 1 && gs.n == 2) {
Start to add some constraint stuff. I now have point-coincident, and point-in-plane. These work, but the equation is still stupid, solving everything at once and not substituting trivial equations. [git-p4: depot-paths = "//depot/solvespace/": change = 1677]
2008-04-21 08:16:38 +00:00
c.type = PT_IN_PLANE;
c.ptA = gs.point[0];
c.entityA = gs.entity[0];
Add point on line constraints, in 2d and 3d. The 3d equations do not have much motivation behind them, but they seem to work. And make sure that we don't solve multiple times without repainting in between, and tweak the text window a bit more. [git-p4: depot-paths = "//depot/solvespace/": change = 1696]
2008-04-28 09:40:02 +00:00
} else if(gs.points == 1 && gs.lineSegments == 1 && gs.n == 2) {
c.type = PT_ON_LINE;
c.ptA = gs.point[0];
c.entityA = gs.entity[0];
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
} else if(gs.points == 1 && gs.circlesOrArcs == 1 && gs.n == 2) {
c.type = PT_ON_CIRCLE;
c.ptA = gs.point[0];
c.entityA = gs.entity[0];
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
} else if(gs.points == 1 && gs.faces == 1 && gs.n == 2) {
c.type = PT_ON_FACE;
c.ptA = gs.point[0];
c.entityA = gs.face[0];
Start to add some constraint stuff. I now have point-coincident, and point-in-plane. These work, but the equation is still stupid, solving everything at once and not substituting trivial equations. [git-p4: depot-paths = "//depot/solvespace/": change = 1677]
2008-04-21 08:16:38 +00:00
} else {
Error("Bad selection for on point / curve / plane constraint.");
return;
}
AddConstraint(&c);
break;
Add an equal length constraint for line segments. [git-p4: depot-paths = "//depot/solvespace/": change = 1680]
2008-04-22 05:00:49 +00:00
case GraphicsWindow::MNU_EQUAL:
if(gs.lineSegments == 2 && gs.n == 2) {
c.type = EQUAL_LENGTH_LINES;
c.entityA = gs.entity[0];
c.entityB = gs.entity[1];
Add an arc entity. That's not allowed to exist in free space (since we need something to force the points into plane, and the workplane supplies that), but otherwise straightforward. And add diameter and equal radius constraints for the arc. [git-p4: depot-paths = "//depot/solvespace/": change = 1718]
2008-05-12 10:01:44 +00:00
} else if(gs.circlesOrArcs == 2 && gs.n == 2) {
c.type = EQUAL_RADIUS;
c.entityA = gs.entity[0];
c.entityB = gs.entity[1];
Add an equal length constraint for line segments. [git-p4: depot-paths = "//depot/solvespace/": change = 1680]
2008-04-22 05:00:49 +00:00
} else {
Error("Bad selection for equal length / radius constraint.");
return;
}
AddConstraint(&c);
break;
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
case GraphicsWindow::MNU_RATIO:
if(gs.lineSegments == 2 && gs.n == 2) {
c.type = LENGTH_RATIO;
c.entityA = gs.entity[0];
c.entityB = gs.entity[1];
} else {
Error("Bad selection for length ratio constraint.");
return;
}
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
c.exprA = Expr::From("0")->DeepCopyKeep();
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
c.ModifyToSatisfy();
AddConstraint(&c);
break;
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
case GraphicsWindow::MNU_AT_MIDPOINT:
if(gs.lineSegments == 1 && gs.points == 1 && gs.n == 2) {
c.type = AT_MIDPOINT;
c.entityA = gs.entity[0];
c.ptA = gs.point[0];
Now we can add new workplanes. So fix all the mistakes that I hadn't previously noticed, because I didn't use to have workplanes with non-zero offsets. And clean up the interface to normals a bit. [git-p4: depot-paths = "//depot/solvespace/": change = 1707]
2008-05-05 11:17:00 +00:00
} else if(gs.lineSegments == 1 && gs.workplanes == 1 && gs.n == 2) {
Make at-midpoint constraint also work to constrain midpoint of a line segment on a plane. And simplify that code a bit, and improve display. [git-p4: depot-paths = "//depot/solvespace/": change = 1702]
2008-05-01 06:53:50 +00:00
c.type = AT_MIDPOINT;
Now we can add new workplanes. So fix all the mistakes that I hadn't previously noticed, because I didn't use to have workplanes with non-zero offsets. And clean up the interface to normals a bit. [git-p4: depot-paths = "//depot/solvespace/": change = 1707]
2008-05-05 11:17:00 +00:00
int i = SS.GetEntity(gs.entity[0])->IsWorkplane() ? 1 : 0;
Make at-midpoint constraint also work to constrain midpoint of a line segment on a plane. And simplify that code a bit, and improve display. [git-p4: depot-paths = "//depot/solvespace/": change = 1702]
2008-05-01 06:53:50 +00:00
c.entityA = gs.entity[i];
c.entityB = gs.entity[1-i];
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
} else {
Error("Bad selection for at midpoint constraint.");
return;
}
AddConstraint(&c);
break;
case GraphicsWindow::MNU_SYMMETRIC:
Add symmetry constraints without an explicit symmetry plane; these use the horizontal or vertical axes of the active workplane. The equations that we write from these are very fast (of the form u + v = 0, or u - v = 0). [git-p4: depot-paths = "//depot/solvespace/": change = 1720]
2008-05-13 10:38:21 +00:00
if(gs.points == 2 &&
((gs.workplanes == 1 && gs.n == 3) ||
(gs.n == 2)))
{
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
c.entityA = gs.entity[0];
c.ptA = gs.point[0];
c.ptB = gs.point[1];
Add symmetry constraints without an explicit symmetry plane; these use the horizontal or vertical axes of the active workplane. The equations that we write from these are very fast (of the form u + v = 0, or u - v = 0). [git-p4: depot-paths = "//depot/solvespace/": change = 1720]
2008-05-13 10:38:21 +00:00
} else if(gs.lineSegments == 1 &&
((gs.workplanes == 1 && gs.n == 2) ||
(gs.n == 1)))
{
Now we can add new workplanes. So fix all the mistakes that I hadn't previously noticed, because I didn't use to have workplanes with non-zero offsets. And clean up the interface to normals a bit. [git-p4: depot-paths = "//depot/solvespace/": change = 1707]
2008-05-05 11:17:00 +00:00
int i = SS.GetEntity(gs.entity[0])->IsWorkplane() ? 1 : 0;
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
Entity *line = SS.GetEntity(gs.entity[i]);
c.entityA = gs.entity[1-i];
c.ptA = line->point[0];
c.ptB = line->point[1];
} else {
Error("Bad selection for symmetric constraint.");
return;
}
Add symmetry constraints without an explicit symmetry plane; these use the horizontal or vertical axes of the active workplane. The equations that we write from these are very fast (of the form u + v = 0, or u - v = 0). [git-p4: depot-paths = "//depot/solvespace/": change = 1720]
2008-05-13 10:38:21 +00:00
if(c.entityA.v == Entity::NO_ENTITY.v) {
if(c.workplane.v == Entity::FREE_IN_3D.v) {
Error("Must be locked in to workplane when constraining "
"symmetric without an explicit symmetry plane.");
return;
}
Vector pa = SS.GetEntity(c.ptA)->PointGetNum();
Vector pb = SS.GetEntity(c.ptB)->PointGetNum();
Vector dp = pa.Minus(pb);
Entity *norm = SS.GetEntity(c.workplane)->Normal();;
Vector u = norm->NormalU(), v = norm->NormalV();
if(fabs(dp.Dot(u)) > fabs(dp.Dot(v))) {
c.type = SYMMETRIC_HORIZ;
} else {
c.type = SYMMETRIC_VERT;
}
} else {
// Symmetry with a symmetry plane specified explicitly.
c.type = SYMMETRIC;
}
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
AddConstraint(&c);
break;
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
case GraphicsWindow::MNU_VERTICAL:
case GraphicsWindow::MNU_HORIZONTAL: {
hEntity ha, hb;
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
if(c.workplane.v == Entity::FREE_IN_3D.v) {
Error("Select workplane before constraining horiz/vert.");
return;
}
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
if(gs.lineSegments == 1 && gs.n == 1) {
c.entityA = gs.entity[0];
Entity *e = SS.GetEntity(c.entityA);
A great renaming. 2d coordinate systems are now called workplanes, and the associated entities are now just points. [git-p4: depot-paths = "//depot/solvespace/": change = 1690]
2008-04-27 03:26:27 +00:00
ha = e->point[0];
hb = e->point[1];
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
} else if(gs.points == 2 && gs.n == 2) {
ha = c.ptA = gs.point[0];
hb = c.ptB = gs.point[1];
} else {
Error("Bad selection for horizontal / vertical constraint.");
return;
}
if(id == GraphicsWindow::MNU_HORIZONTAL) {
c.type = HORIZONTAL;
} else {
c.type = VERTICAL;
}
AddConstraint(&c);
break;
}
Add parallel and same orientation constraints, that work on line segments and normals. [git-p4: depot-paths = "//depot/solvespace/": change = 1713]
2008-05-09 05:33:23 +00:00
case GraphicsWindow::MNU_ORIENTED_SAME:
if(gs.anyNormals == 2 && gs.n == 2) {
c.type = SAME_ORIENTATION;
c.entityA = gs.anyNormal[0];
c.entityB = gs.anyNormal[1];
} else {
Error("Bad selection for same orientation constraint.");
return;
}
AddConstraint(&c);
break;
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
case GraphicsWindow::MNU_OTHER_ANGLE:
if(gs.constraints == 1 && gs.n == 0) {
Constraint *c = SS.GetConstraint(gs.constraint[0]);
if(c->type == ANGLE) {
c->otherAngle = !(c->otherAngle);
c->ModifyToSatisfy();
break;
}
}
Error("Must select an angle constraint.");
break;
case GraphicsWindow::MNU_ANGLE:
if(gs.vectors == 2 && gs.n == 2) {
c.type = ANGLE;
c.entityA = gs.vector[0];
c.entityB = gs.vector[1];
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
c.exprA = Expr::From(0.0)->DeepCopyKeep();
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
c.otherAngle = true;
} else {
Error("Bad selection for angle constraint.");
return;
}
c.ModifyToSatisfy();
AddConstraint(&c);
break;
Add parallel and same orientation constraints, that work on line segments and normals. [git-p4: depot-paths = "//depot/solvespace/": change = 1713]
2008-05-09 05:33:23 +00:00
case GraphicsWindow::MNU_PARALLEL:
if(gs.vectors == 2 && gs.n == 2) {
c.type = PARALLEL;
c.entityA = gs.vector[0];
c.entityB = gs.vector[1];
} else {
Error("Bad selection for parallel constraint.");
return;
}
AddConstraint(&c);
break;
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
case GraphicsWindow::MNU_SOLVE_NOW:
Consolidate the code that determines whether an entity is visible in one place. And remove the ability to disable the solver, since that's unlikely to be anything but confusing (and in any case, was badly implemented). This is in preparation for selective solving, of only the dirty groups. [git-p4: depot-paths = "//depot/solvespace/": change = 1769]
2008-06-02 09:31:26 +00:00
SS.GenerateAll(0, INT_MAX);
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
return;
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
default: oops();
}
SS.GW.ClearSelection();
InvalidateGraphics();
}
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
Expr *Constraint::VectorsParallel(int eq, ExprVector a, ExprVector b) {
ExprVector r = a.Cross(b);
// Hairy ball theorem screws me here. There's no clean solution that I
// know, so let's pivot on the initial numerical guess.
double mx = fabs((a.x)->Eval()) + fabs((b.x)->Eval());
double my = fabs((a.y)->Eval()) + fabs((b.y)->Eval());
double mz = fabs((a.z)->Eval()) + fabs((b.z)->Eval());
// The basis vector in which the vectors have the LEAST energy is the
// one that we should look at most (e.g. if both vectors lie in the xy
// plane, then the z component of the cross product is most important).
// So find the strongest component of a and b, and that's the component
// of the cross product to ignore.
double m = max(mx, max(my, mz));
Expr *e0, *e1;
if(m == mx) { e0 = r.y; e1 = r.z; }
else if(m == my) { e0 = r.z; e1 = r.x; }
else if(m == mz) { e0 = r.x; e1 = r.y; }
else oops();
if(eq == 0) return e0;
if(eq == 1) return e1;
oops();
}
Add point on line constraints, in 2d and 3d. The 3d equations do not have much motivation behind them, but they seem to work. And make sure that we don't solve multiple times without repainting in between, and tweak the text window a bit more. [git-p4: depot-paths = "//depot/solvespace/": change = 1696]
2008-04-28 09:40:02 +00:00
Expr *Constraint::PointLineDistance(hEntity wrkpl, hEntity hpt, hEntity hln) {
Entity *ln = SS.GetEntity(hln);
Entity *a = SS.GetEntity(ln->point[0]);
Entity *b = SS.GetEntity(ln->point[1]);
Entity *p = SS.GetEntity(hpt);
if(wrkpl.v == Entity::FREE_IN_3D.v) {
ExprVector ep = p->PointGetExprs();
ExprVector ea = a->PointGetExprs();
ExprVector eb = b->PointGetExprs();
ExprVector eab = ea.Minus(eb);
Expr *m = eab.Magnitude();
return ((eab.Cross(ea.Minus(ep))).Magnitude())->Div(m);
} else {
Expr *ua, *va, *ub, *vb;
a->PointGetExprsInWorkplane(wrkpl, &ua, &va);
b->PointGetExprsInWorkplane(wrkpl, &ub, &vb);
Expr *du = ua->Minus(ub);
Expr *dv = va->Minus(vb);
Expr *u, *v;
p->PointGetExprsInWorkplane(wrkpl, &u, &v);
Expr *m = ((du->Square())->Plus(dv->Square()))->Sqrt();
Expr *proj = (dv->Times(ua->Minus(u)))->Minus(
(du->Times(va->Minus(v))));
return proj->Div(m);
}
}
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
Expr *Constraint::PointPlaneDistance(ExprVector p, hEntity hpl) {
ExprVector n;
Expr *d;
Now we can add new workplanes. So fix all the mistakes that I hadn't previously noticed, because I didn't use to have workplanes with non-zero offsets. And clean up the interface to normals a bit. [git-p4: depot-paths = "//depot/solvespace/": change = 1707]
2008-05-05 11:17:00 +00:00
SS.GetEntity(hpl)->WorkplaneGetPlaneExprs(&n, &d);
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
return (p.Dot(n))->Minus(d);
}
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
Expr *Constraint::Distance(hEntity wrkpl, hEntity hpa, hEntity hpb) {
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
Entity *pa = SS.GetEntity(hpa);
Entity *pb = SS.GetEntity(hpb);
if(!(pa->IsPoint() && pb->IsPoint())) oops();
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
if(wrkpl.v == Entity::FREE_IN_3D.v) {
// This is true distance
ExprVector ea, eb, eab;
ea = pa->PointGetExprs();
eb = pb->PointGetExprs();
eab = ea.Minus(eb);
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
return eab.Magnitude();
} else {
// This is projected distance, in the given workplane.
Expr *au, *av, *bu, *bv;
pa->PointGetExprsInWorkplane(wrkpl, &au, &av);
pb->PointGetExprsInWorkplane(wrkpl, &bu, &bv);
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
Expr *du = au->Minus(bu);
Expr *dv = av->Minus(bv);
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
return ((du->Square())->Plus(dv->Square()))->Sqrt();
}
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
}
Make at-midpoint constraint also work to constrain midpoint of a line segment on a plane. And simplify that code a bit, and improve display. [git-p4: depot-paths = "//depot/solvespace/": change = 1702]
2008-05-01 06:53:50 +00:00
ExprVector Constraint::PointInThreeSpace(hEntity workplane, Expr *u, Expr *v) {
Entity *w = SS.GetEntity(workplane);
Now we can add new workplanes. So fix all the mistakes that I hadn't previously noticed, because I didn't use to have workplanes with non-zero offsets. And clean up the interface to normals a bit. [git-p4: depot-paths = "//depot/solvespace/": change = 1707]
2008-05-05 11:17:00 +00:00
ExprVector ub = w->Normal()->NormalExprsU();
ExprVector vb = w->Normal()->NormalExprsV();
ExprVector ob = w->WorkplaneGetOffsetExprs();
Make at-midpoint constraint also work to constrain midpoint of a line segment on a plane. And simplify that code a bit, and improve display. [git-p4: depot-paths = "//depot/solvespace/": change = 1702]
2008-05-01 06:53:50 +00:00
return (ub.ScaledBy(u)).Plus(vb.ScaledBy(v)).Plus(ob);
}
Some graphics tweaks, to the order in which stuff gets drawn, to determine what goes in front (e.g. put a drawn line in front of the reference plane, even if the z order would want the opposite), and some tweaks to the mouse behaviour, and a function to modify constraints like dimensions so that the are initially satisfied. [git-p4: depot-paths = "//depot/solvespace/": change = 1681]
2008-04-22 10:53:42 +00:00
void Constraint::ModifyToSatisfy(void) {
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
if(type == ANGLE) {
Vector a = SS.GetEntity(entityA)->VectorGetNum();
Vector b = SS.GetEntity(entityB)->VectorGetNum();
if(otherAngle) a = a.ScaledBy(-1);
if(workplane.v != Entity::FREE_IN_3D.v) {
a = a.ProjectVectorInto(workplane);
b = b.ProjectVectorInto(workplane);
}
double c = (a.Dot(b))/(a.Magnitude() * b.Magnitude());
double theta = acos(c)*180/PI;
Expr::FreeKeep(&exprA);
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
exprA = Expr::From(theta)->DeepCopyKeep();
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
} else {
// We'll fix these ones up by looking at their symbolic equation;
// that means no extra work.
IdList<Equation,hEquation> l;
// An uninit IdList could lead us to free some random address, bad.
memset(&l, 0, sizeof(l));
Generate(&l);
if(l.n != 1) oops();
// These equations are written in the form f(...) - d = 0, where
// d is the value of the exprA.
double v = (l.elem[0].e)->Eval();
double nd = exprA->Eval() + v;
Expr::FreeKeep(&exprA);
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
exprA = Expr::From(nd)->DeepCopyKeep();
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
l.Clear();
}
Some graphics tweaks, to the order in which stuff gets drawn, to determine what goes in front (e.g. put a drawn line in front of the reference plane, even if the z order would want the opposite), and some tweaks to the mouse behaviour, and a function to modify constraints like dimensions so that the are initially satisfied. [git-p4: depot-paths = "//depot/solvespace/": change = 1681]
2008-04-22 10:53:42 +00:00
}
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
void Constraint::AddEq(IdList<Equation,hEquation> *l, Expr *expr, int index) {
Equation eq;
eq.e = expr;
eq.h = h.equation(index);
l->Add(&eq);
}
void Constraint::Generate(IdList<Equation,hEquation> *l) {
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
Expr *exA = NULL;
if(exprA) exA = exprA->DeepCopy();
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
switch(type) {
case PT_PT_DISTANCE:
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
AddEq(l, Distance(workplane, ptA, ptB)->Minus(exA), 0);
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
break;
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
case PT_LINE_DISTANCE:
AddEq(l,
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
PointLineDistance(workplane, ptA, entityA)->Minus(exA), 0);
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
break;
case PT_PLANE_DISTANCE: {
ExprVector pt = SS.GetEntity(ptA)->PointGetExprs();
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
AddEq(l, (PointPlaneDistance(pt, entityA))->Minus(exA), 0);
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
break;
}
Add an equal length constraint for line segments. [git-p4: depot-paths = "//depot/solvespace/": change = 1680]
2008-04-22 05:00:49 +00:00
case EQUAL_LENGTH_LINES: {
Entity *a = SS.GetEntity(entityA);
Entity *b = SS.GetEntity(entityB);
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
AddEq(l, Distance(workplane, a->point[0], a->point[1])->Minus(
Distance(workplane, b->point[0], b->point[1])), 0);
Add an equal length constraint for line segments. [git-p4: depot-paths = "//depot/solvespace/": change = 1680]
2008-04-22 05:00:49 +00:00
break;
}
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
case LENGTH_RATIO: {
Entity *a = SS.GetEntity(entityA);
Entity *b = SS.GetEntity(entityB);
Expr *la = Distance(workplane, a->point[0], a->point[1]);
Expr *lb = Distance(workplane, b->point[0], b->point[1]);
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
AddEq(l, (la->Div(lb))->Minus(exA), 0);
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
break;
}
Add a diameter constraint, and add a `distance' entity that I can remap when I copy circle entities, in order to make the radius numerical somehow (analogy with the POINT_ and NORMAL_XFRMD) thing. [git-p4: depot-paths = "//depot/solvespace/": change = 1710]
2008-05-07 08:19:37 +00:00
case DIAMETER: {
Entity *circle = SS.GetEntity(entityA);
Add an arc entity. That's not allowed to exist in free space (since we need something to force the points into plane, and the workplane supplies that), but otherwise straightforward. And add diameter and equal radius constraints for the arc. [git-p4: depot-paths = "//depot/solvespace/": change = 1718]
2008-05-12 10:01:44 +00:00
Expr *r = circle->CircleGetRadiusExpr();
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
AddEq(l, (r->Times(Expr::From(2)))->Minus(exA), 0);
Add a diameter constraint, and add a `distance' entity that I can remap when I copy circle entities, in order to make the radius numerical somehow (analogy with the POINT_ and NORMAL_XFRMD) thing. [git-p4: depot-paths = "//depot/solvespace/": change = 1710]
2008-05-07 08:19:37 +00:00
break;
}
Add an arc entity. That's not allowed to exist in free space (since we need something to force the points into plane, and the workplane supplies that), but otherwise straightforward. And add diameter and equal radius constraints for the arc. [git-p4: depot-paths = "//depot/solvespace/": change = 1718]
2008-05-12 10:01:44 +00:00
case EQUAL_RADIUS: {
Entity *c1 = SS.GetEntity(entityA);
Entity *c2 = SS.GetEntity(entityB);
AddEq(l, (c1->CircleGetRadiusExpr())->Minus(
c2->CircleGetRadiusExpr()), 0);
break;
}
Start to add some constraint stuff. I now have point-coincident, and point-in-plane. These work, but the equation is still stupid, solving everything at once and not substituting trivial equations. [git-p4: depot-paths = "//depot/solvespace/": change = 1677]
2008-04-21 08:16:38 +00:00
case POINTS_COINCIDENT: {
Add an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +00:00
Entity *a = SS.GetEntity(ptA);
Entity *b = SS.GetEntity(ptB);
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
if(workplane.v == Entity::FREE_IN_3D.v) {
ExprVector pa = a->PointGetExprs();
ExprVector pb = b->PointGetExprs();
AddEq(l, pa.x->Minus(pb.x), 0);
AddEq(l, pa.y->Minus(pb.y), 1);
AddEq(l, pa.z->Minus(pb.z), 2);
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
} else {
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
Expr *au, *av;
Expr *bu, *bv;
a->PointGetExprsInWorkplane(workplane, &au, &av);
b->PointGetExprsInWorkplane(workplane, &bu, &bv);
AddEq(l, au->Minus(bu), 0);
AddEq(l, av->Minus(bv), 1);
Add an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +00:00
}
Start to add some constraint stuff. I now have point-coincident, and point-in-plane. These work, but the equation is still stupid, solving everything at once and not substituting trivial equations. [git-p4: depot-paths = "//depot/solvespace/": change = 1677]
2008-04-21 08:16:38 +00:00
break;
}
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
case PT_IN_PLANE:
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
// This one works the same, whether projected or not.
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
AddEq(l, PointPlaneDistance(
SS.GetEntity(ptA)->PointGetExprs(), entityA), 0);
Start to add some constraint stuff. I now have point-coincident, and point-in-plane. These work, but the equation is still stupid, solving everything at once and not substituting trivial equations. [git-p4: depot-paths = "//depot/solvespace/": change = 1677]
2008-04-21 08:16:38 +00:00
break;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
case PT_ON_FACE: {
// a plane, n dot (p - p0) = 0
ExprVector p = SS.GetEntity(ptA)->PointGetExprs();
Entity *f = SS.GetEntity(entityA);
ExprVector p0 = f->FaceGetPointExprs();
ExprVector n = f->FaceGetNormalExprs();
AddEq(l, (p.Minus(p0)).Dot(n), 0);
break;
}
Add point on line constraints, in 2d and 3d. The 3d equations do not have much motivation behind them, but they seem to work. And make sure that we don't solve multiple times without repainting in between, and tweak the text window a bit more. [git-p4: depot-paths = "//depot/solvespace/": change = 1696]
2008-04-28 09:40:02 +00:00
case PT_ON_LINE:
if(workplane.v == Entity::FREE_IN_3D.v) {
Entity *ln = SS.GetEntity(entityA);
Entity *a = SS.GetEntity(ln->point[0]);
Entity *b = SS.GetEntity(ln->point[1]);
Entity *p = SS.GetEntity(ptA);
ExprVector ep = p->PointGetExprs();
ExprVector ea = a->PointGetExprs();
ExprVector eb = b->PointGetExprs();
ExprVector eab = ea.Minus(eb);
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
ExprVector eap = ea.Minus(ep);
AddEq(l, VectorsParallel(0, eab, eap), 0);
AddEq(l, VectorsParallel(1, eab, eap), 1);
Add point on line constraints, in 2d and 3d. The 3d equations do not have much motivation behind them, but they seem to work. And make sure that we don't solve multiple times without repainting in between, and tweak the text window a bit more. [git-p4: depot-paths = "//depot/solvespace/": change = 1696]
2008-04-28 09:40:02 +00:00
} else {
AddEq(l, PointLineDistance(workplane, ptA, entityA), 0);
}
break;
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
case PT_ON_CIRCLE: {
Entity *circle = SS.GetEntity(entityA);
hEntity center = circle->point[0];
Fix point-on-circle constraints to work with arcs too, and lock extrudes normal to workplane if a workplane is active when the extrusion is created. [git-p4: depot-paths = "//depot/solvespace/": change = 1724]
2008-05-16 06:34:06 +00:00
Expr *radius = circle->CircleGetRadiusExpr();
Add point-line distance, point-plane distance, and point-on-circle constraints. And generate the constraint equations for entities (e.g., that our unit quaternions have magnitude one). Numerical troubles there, but it sort of works. Also some stuff to draw projection lines with projected constraints, and to auto-insert more constraints as you draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1711]
2008-05-08 07:30:30 +00:00
AddEq(l, Distance(workplane, ptA, center)->Minus(radius), 0);
break;
}
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
case AT_MIDPOINT:
if(workplane.v == Entity::FREE_IN_3D.v) {
Entity *ln = SS.GetEntity(entityA);
ExprVector a = SS.GetEntity(ln->point[0])->PointGetExprs();
ExprVector b = SS.GetEntity(ln->point[1])->PointGetExprs();
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
ExprVector m = (a.Plus(b)).ScaledBy(Expr::From(0.5));
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
Make at-midpoint constraint also work to constrain midpoint of a line segment on a plane. And simplify that code a bit, and improve display. [git-p4: depot-paths = "//depot/solvespace/": change = 1702]
2008-05-01 06:53:50 +00:00
if(ptA.v) {
ExprVector p = SS.GetEntity(ptA)->PointGetExprs();
AddEq(l, (m.x)->Minus(p.x), 0);
AddEq(l, (m.y)->Minus(p.y), 1);
AddEq(l, (m.z)->Minus(p.z), 2);
} else {
AddEq(l, PointPlaneDistance(m, entityB), 0);
}
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
} else {
Entity *ln = SS.GetEntity(entityA);
Entity *a = SS.GetEntity(ln->point[0]);
Entity *b = SS.GetEntity(ln->point[1]);
Expr *au, *av, *bu, *bv;
a->PointGetExprsInWorkplane(workplane, &au, &av);
b->PointGetExprsInWorkplane(workplane, &bu, &bv);
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
Expr *mu = Expr::From(0.5)->Times(au->Plus(bu));
Expr *mv = Expr::From(0.5)->Times(av->Plus(bv));
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
Make at-midpoint constraint also work to constrain midpoint of a line segment on a plane. And simplify that code a bit, and improve display. [git-p4: depot-paths = "//depot/solvespace/": change = 1702]
2008-05-01 06:53:50 +00:00
if(ptA.v) {
Entity *p = SS.GetEntity(ptA);
Expr *pu, *pv;
p->PointGetExprsInWorkplane(workplane, &pu, &pv);
AddEq(l, pu->Minus(mu), 0);
AddEq(l, pv->Minus(mv), 1);
} else {
ExprVector m = PointInThreeSpace(workplane, mu, mv);
AddEq(l, PointPlaneDistance(m, entityB), 0);
}
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
}
break;
case SYMMETRIC:
if(workplane.v == Entity::FREE_IN_3D.v) {
Entity *plane = SS.GetEntity(entityA);
Entity *ea = SS.GetEntity(ptA);
Entity *eb = SS.GetEntity(ptB);
ExprVector a = ea->PointGetExprs();
ExprVector b = eb->PointGetExprs();
// The midpoint of the line connecting the symmetric points
// lies on the plane of the symmetry.
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
ExprVector m = (a.Plus(b)).ScaledBy(Expr::From(0.5));
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
AddEq(l, PointPlaneDistance(m, plane->h), 0);
// And projected into the plane of symmetry, the points are
// coincident.
Expr *au, *av, *bu, *bv;
ea->PointGetExprsInWorkplane(plane->h, &au, &av);
eb->PointGetExprsInWorkplane(plane->h, &bu, &bv);
AddEq(l, au->Minus(bu), 0);
AddEq(l, av->Minus(bv), 1);
} else {
Entity *plane = SS.GetEntity(entityA);
Entity *a = SS.GetEntity(ptA);
Entity *b = SS.GetEntity(ptB);
Expr *au, *av, *bu, *bv;
a->PointGetExprsInWorkplane(workplane, &au, &av);
b->PointGetExprsInWorkplane(workplane, &bu, &bv);
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
Expr *mu = Expr::From(0.5)->Times(au->Plus(bu));
Expr *mv = Expr::From(0.5)->Times(av->Plus(bv));
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
Make at-midpoint constraint also work to constrain midpoint of a line segment on a plane. And simplify that code a bit, and improve display. [git-p4: depot-paths = "//depot/solvespace/": change = 1702]
2008-05-01 06:53:50 +00:00
ExprVector m = PointInThreeSpace(workplane, mu, mv);
AddEq(l, PointPlaneDistance(m, plane->h), 0);
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
// Construct a vector within the workplane that is normal
// to the symmetry pane's normal (i.e., that lies in the
// plane of symmetry). The line connecting the points is
// perpendicular to that constructed vector.
Make at-midpoint constraint also work to constrain midpoint of a line segment on a plane. And simplify that code a bit, and improve display. [git-p4: depot-paths = "//depot/solvespace/": change = 1702]
2008-05-01 06:53:50 +00:00
Entity *w = SS.GetEntity(workplane);
Now we can add new workplanes. So fix all the mistakes that I hadn't previously noticed, because I didn't use to have workplanes with non-zero offsets. And clean up the interface to normals a bit. [git-p4: depot-paths = "//depot/solvespace/": change = 1707]
2008-05-05 11:17:00 +00:00
ExprVector u = w->Normal()->NormalExprsU();
ExprVector v = w->Normal()->NormalExprsV();
Make at-midpoint constraint also work to constrain midpoint of a line segment on a plane. And simplify that code a bit, and improve display. [git-p4: depot-paths = "//depot/solvespace/": change = 1702]
2008-05-01 06:53:50 +00:00
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
ExprVector pa = a->PointGetExprs();
ExprVector pb = b->PointGetExprs();
ExprVector n;
Expr *d;
Now we can add new workplanes. So fix all the mistakes that I hadn't previously noticed, because I didn't use to have workplanes with non-zero offsets. And clean up the interface to normals a bit. [git-p4: depot-paths = "//depot/solvespace/": change = 1707]
2008-05-05 11:17:00 +00:00
plane->WorkplaneGetPlaneExprs(&n, &d);
Add symmetric and at midpoint constraints. The symmetry constraint turned out straightforward, in great part because the planes are workplanes (6 DOF, represented by a unit quaternion and a point), and therefore make it easy to get a vector in the plane, as well as a normal. And on that subject, replace the previous hack for parallel vector constraints with a better hack: pivot on the initial numerical guess, to choose which components of the cross product to drive to zero. Ugly, but I think that will be as robust as I can get. [git-p4: depot-paths = "//depot/solvespace/": change = 1699]
2008-04-30 08:14:32 +00:00
AddEq(l, (n.Cross(u.Cross(v))).Dot(pa.Minus(pb)), 1);
}
break;
Add symmetry constraints without an explicit symmetry plane; these use the horizontal or vertical axes of the active workplane. The equations that we write from these are very fast (of the form u + v = 0, or u - v = 0). [git-p4: depot-paths = "//depot/solvespace/": change = 1720]
2008-05-13 10:38:21 +00:00
case SYMMETRIC_HORIZ:
case SYMMETRIC_VERT: {
Entity *a = SS.GetEntity(ptA);
Entity *b = SS.GetEntity(ptB);
Expr *au, *av, *bu, *bv;
a->PointGetExprsInWorkplane(workplane, &au, &av);
b->PointGetExprsInWorkplane(workplane, &bu, &bv);
if(type == SYMMETRIC_HORIZ) {
AddEq(l, av->Minus(bv), 0);
AddEq(l, au->Plus(bu), 0);
} else {
AddEq(l, au->Minus(bu), 0);
AddEq(l, av->Plus(bv), 0);
}
break;
}
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
case HORIZONTAL:
case VERTICAL: {
hEntity ha, hb;
if(entityA.v) {
Entity *e = SS.GetEntity(entityA);
A great renaming. 2d coordinate systems are now called workplanes, and the associated entities are now just points. [git-p4: depot-paths = "//depot/solvespace/": change = 1690]
2008-04-27 03:26:27 +00:00
ha = e->point[0];
hb = e->point[1];
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
} else {
ha = ptA;
hb = ptB;
}
Entity *a = SS.GetEntity(ha);
Entity *b = SS.GetEntity(hb);
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
Expr *au, *av, *bu, *bv;
a->PointGetExprsInWorkplane(workplane, &au, &av);
b->PointGetExprsInWorkplane(workplane, &bu, &bv);
AddEq(l, (type == HORIZONTAL) ? av->Minus(bv) : au->Minus(bu), 0);
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
break;
}
Add parallel and same orientation constraints, that work on line segments and normals. [git-p4: depot-paths = "//depot/solvespace/": change = 1713]
2008-05-09 05:33:23 +00:00
case SAME_ORIENTATION: {
Entity *a = SS.GetEntity(entityA);
Entity *b = SS.GetEntity(entityB);
ExprVector au = a->NormalExprsU(),
av = a->NormalExprsV(),
an = a->NormalExprsN();
ExprVector bu = b->NormalExprsU(),
bv = b->NormalExprsV(),
bn = b->NormalExprsN();
AddEq(l, VectorsParallel(0, an, bn), 0);
AddEq(l, VectorsParallel(1, an, bn), 1);
Little changes, more pwls in a circle, and make "same orientation" constraints work mod 180 degrees, so that it snaps to however the workplane was drawn (more vertical vs. more horizontal). [git-p4: depot-paths = "//depot/solvespace/": change = 1714]
2008-05-11 02:57:47 +00:00
Expr *d1 = au.Dot(bv);
Expr *d2 = au.Dot(bu);
// Allow either orientation for the coordinate system, depending
// on how it was drawn.
if(fabs(d1->Eval()) < fabs(d2->Eval())) {
AddEq(l, d1, 2);
} else {
AddEq(l, d2, 2);
}
Add parallel and same orientation constraints, that work on line segments and normals. [git-p4: depot-paths = "//depot/solvespace/": change = 1713]
2008-05-09 05:33:23 +00:00
break;
}
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
case ANGLE: {
Entity *a = SS.GetEntity(entityA);
Entity *b = SS.GetEntity(entityB);
ExprVector ae = a->VectorGetExprs();
ExprVector be = b->VectorGetExprs();
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
if(otherAngle) ae = ae.ScaledBy(Expr::From(-1));
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
Expr *c;
if(workplane.v == Entity::FREE_IN_3D.v) {
Expr *mags = (ae.Magnitude())->Times(be.Magnitude());
c = (ae.Dot(be))->Div(mags);
} else {
Entity *w = SS.GetEntity(workplane);
ExprVector u = w->Normal()->NormalExprsU();
ExprVector v = w->Normal()->NormalExprsV();
Expr *ua = u.Dot(ae);
Expr *va = v.Dot(ae);
Expr *ub = u.Dot(be);
Expr *vb = v.Dot(be);
Expr *maga = (ua->Square()->Plus(va->Square()))->Sqrt();
Expr *magb = (ub->Square()->Plus(vb->Square()))->Sqrt();
Expr *dot = (ua->Times(ub))->Plus(va->Times(vb));
c = dot->Div(maga->Times(magb));
}
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
Expr *rads = exA->Times(Expr::From(PI/180));
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
AddEq(l, c->Minus(rads->Cos()), 0);
break;
}
Add parallel and same orientation constraints, that work on line segments and normals. [git-p4: depot-paths = "//depot/solvespace/": change = 1713]
2008-05-09 05:33:23 +00:00
case PARALLEL: {
ExprVector a = SS.GetEntity(entityA)->VectorGetExprs();
ExprVector b = SS.GetEntity(entityB)->VectorGetExprs();
if(workplane.v == Entity::FREE_IN_3D.v) {
AddEq(l, VectorsParallel(0, a, b), 0);
AddEq(l, VectorsParallel(1, a, b), 1);
} else {
Entity *w = SS.GetEntity(workplane);
ExprVector wn = w->Normal()->NormalExprsN();
AddEq(l, (a.Cross(b)).Dot(wn), 0);
}
break;
}
Ultra-rough beginnings of a solver. Write the constraint equations, take the partial derivatives, and run the Newton's method. This seems to sort of work with a single distance constraint. [git-p4: depot-paths = "//depot/solvespace/": change = 1675]
2008-04-20 11:35:10 +00:00
default: oops();
}
}