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

932 lines
34 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;
Add point-face distance constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1778]
2008-06-06 08:46:55 +00:00
case PT_FACE_DISTANCE: s = "pt-face-distance"; break;
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
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;
Add two more exotic constraints: equal point-line distances, and point-line distance equal to line segment length. These are available in both normal and projected versions, with fancy display for all of these. [git-p4: depot-paths = "//depot/solvespace/": change = 1793]
2008-06-14 11:16:14 +00:00
case EQ_LEN_PT_LINE_D: s = "eq-length-and-pt-ln-dist"; break;
case EQ_PT_LN_DISTANCES:s = "eq-pt-line-distances"; break;
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
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;
Add a special constraint type for comments; no equations, just user-visible text. And make points hoverable/selectable even when GW.showPoints is false, and zoom to fit before regenerating on file open, because then we're at the right zoom level (and will use the right pwl tolerance). [git-p4: depot-paths = "//depot/solvespace/": change = 1788]
2008-06-12 08:58:58 +00:00
case COMMENT: s = "comment"; break;
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
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) {
Add undo/redo. This saves the param guesses, constraints, groups, and requests to a separate list. It's messy, because I have to make a deep copy (e.g. of the remap list for the groups, or Expr * stuff) of some things. Others (e.g. the polygon or mesh) will be regenerated, so they should be discarded, but they must not get double-freed. In any case, works superficially. And fix a few memory leaks unrelated to this, and remove some dead code. [git-p4: depot-paths = "//depot/solvespace/": change = 1775]
2008-06-04 10:22:30 +00:00
AddConstraint(c, true);
}
void Constraint::AddConstraint(Constraint *c, bool rememberForUndo) {
if(rememberForUndo) SS.UndoRemember();
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
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 11:43:27 +00:00
SS.MarkGroupDirty(c->group);
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
SS.later.generateAll = true;
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;
Add undo/redo. This saves the param guesses, constraints, groups, and requests to a separate list. It's messy, because I have to make a deep copy (e.g. of the remap list for the groups, or Expr * stuff) of some things. Others (e.g. the polygon or mesh) will be regenerated, so they should be discarded, but they must not get double-freed. In any case, works superficially. And fix a few memory leaks unrelated to this, and remove some dead code. [git-p4: depot-paths = "//depot/solvespace/": change = 1775]
2008-06-04 10:22:30 +00:00
AddConstraint(&c, false);
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 point-face distance constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1778]
2008-06-06 08:46:55 +00:00
} else if(gs.faces == 1 && gs.points == 1 && gs.n == 2) {
c.type = PT_FACE_DISTANCE;
c.ptA = gs.point[0];
c.entityA = gs.face[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
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
c.valA = 0;
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 two more exotic constraints: equal point-line distances, and point-line distance equal to line segment length. These are available in both normal and projected versions, with fancy display for all of these. [git-p4: depot-paths = "//depot/solvespace/": change = 1793]
2008-06-14 11:16:14 +00:00
} else if(gs.lineSegments == 2 && gs.points == 2 && gs.n == 4) {
c.type = EQ_PT_LN_DISTANCES;
c.entityA = gs.entity[0];
c.ptA = gs.point[0];
c.entityB = gs.entity[1];
c.ptB = gs.point[1];
} else if(gs.lineSegments == 1 && gs.points == 2 && gs.n == 3) {
// The same line segment for the distances, but different
// points.
c.type = EQ_PT_LN_DISTANCES;
c.entityA = gs.entity[0];
c.ptA = gs.point[0];
c.entityB = gs.entity[0];
c.ptB = gs.point[1];
} else if(gs.lineSegments == 2 && gs.points == 1 && gs.n == 3) {
c.type = EQ_LEN_PT_LINE_D;
c.entityA = gs.entity[0];
c.entityB = gs.entity[1];
c.ptA = gs.point[0];
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;
}
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
c.valA = 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
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;
}
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
if(gs.lineSegments == 1) {
// If this line segment is already constrained horiz or
// vert, then auto-remove that redundant constraint.
SS.constraint.ClearTags();
for(int i = 0; i < SS.constraint.n; i++) {
Constraint *ct = &(SS.constraint.elem[i]);
if(ct->type != HORIZONTAL && ct->type != VERTICAL) {
continue;
}
if(ct->entityA.v != (gs.entity[0]).v) continue;
ct->tag = 1;
}
SS.constraint.RemoveTagged();
// And no need to do anything special, since nothing
// ever depends on a constraint.
}
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 {
// 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;
}
Force the numerical guess for a normal to be exactly correct when a same orientation constraint is applied; this makes convergence easy. And don't hover faces or constraints while dragging something. [git-p4: depot-paths = "//depot/solvespace/": change = 1798]
2008-06-18 09:18:51 +00:00
case GraphicsWindow::MNU_ORIENTED_SAME: {
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
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;
}
Force the numerical guess for a normal to be exactly correct when a same orientation constraint is applied; this makes convergence easy. And don't hover faces or constraints while dragging something. [git-p4: depot-paths = "//depot/solvespace/": change = 1798]
2008-06-18 09:18:51 +00:00
SS.UndoRemember();
Entity *nfree = SS.GetEntity(c.entityA);
Entity *nref = SS.GetEntity(c.entityB);
if(nref->group.v == SS.GW.activeGroup.v) {
SWAP(Entity *, nref, nfree);
}
if(nfree->group.v == SS.GW.activeGroup.v &&
nref ->group.v != SS.GW.activeGroup.v)
{
// nfree is free, and nref is locked (since it came from a
// previous group); so let's force nfree aligned to nref,
// and make convergence easy
Vector ru = nref ->NormalU(), rv = nref ->NormalV();
Vector fu = nfree->NormalU(), fv = nfree->NormalV();
if(fabs(fu.Dot(ru)) < fabs(fu.Dot(rv))) {
// There might be an odd*90 degree rotation about the
// normal vector; allow that, since the numerical
// constraint does
SWAP(Vector, ru, rv);
}
fu = fu.Dot(ru) > 0 ? ru : ru.ScaledBy(-1);
fv = fv.Dot(rv) > 0 ? rv : rv.ScaledBy(-1);
nfree->NormalForceTo(Quaternion::From(fu, fv));
}
AddConstraint(&c, false);
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;
Force the numerical guess for a normal to be exactly correct when a same orientation constraint is applied; this makes convergence easy. And don't hover faces or constraints while dragging something. [git-p4: depot-paths = "//depot/solvespace/": change = 1798]
2008-06-18 09:18:51 +00:00
}
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
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.");
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
return;
case GraphicsWindow::MNU_REFERENCE:
if(gs.constraints == 1 && gs.n == 0) {
Constraint *c = SS.GetConstraint(gs.constraint[0]);
Add a special constraint type for comments; no equations, just user-visible text. And make points hoverable/selectable even when GW.showPoints is false, and zoom to fit before regenerating on file open, because then we're at the right zoom level (and will use the right pwl tolerance). [git-p4: depot-paths = "//depot/solvespace/": change = 1788]
2008-06-12 08:58:58 +00:00
if(c->HasLabel() && c->type != COMMENT) {
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
(c->reference) = !(c->reference);
SS.GetGroup(c->group)->clean = false;
SS.GenerateAll();
break;
}
}
Error("Must select a constraint with associated label.");
return;
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_ANGLE:
if(gs.vectors == 2 && gs.n == 2) {
c.type = ANGLE;
c.entityA = gs.vector[0];
c.entityB = gs.vector[1];
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
c.valA = 0;
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;
Add a special constraint type for comments; no equations, just user-visible text. And make points hoverable/selectable even when GW.showPoints is false, and zoom to fit before regenerating on file open, because then we're at the right zoom level (and will use the right pwl tolerance). [git-p4: depot-paths = "//depot/solvespace/": change = 1788]
2008-06-12 08:58:58 +00:00
case GraphicsWindow::MNU_COMMENT:
c.type = COMMENT;
c.comment.strcpy("NEW COMMENT -- DOUBLE-CLICK TO EDIT");
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
c.disp.offset = SS.GW.offset.ScaledBy(-1);
Add a special constraint type for comments; no equations, just user-visible text. And make points hoverable/selectable even when GW.showPoints is false, and zoom to fit before regenerating on file open, because then we're at the right zoom level (and will use the right pwl tolerance). [git-p4: depot-paths = "//depot/solvespace/": change = 1788]
2008-06-12 08:58:58 +00:00
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:
Add undo/redo. This saves the param guesses, constraints, groups, and requests to a separate list. It's messy, because I have to make a deep copy (e.g. of the remap list for the groups, or Expr * stuff) of some things. Others (e.g. the polygon or mesh) will be regenerated, so they should be discarded, but they must not get double-freed. In any case, works superficially. And fix a few memory leaks unrelated to this, and remove some dead code. [git-p4: depot-paths = "//depot/solvespace/": change = 1775]
2008-06-04 10:22:30 +00:00
SS.ReloadAllImported();
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
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
// know, so let's pivot on the initial numerical guess. Our caller
// has ensured that if one of our input vectors is already known (e.g.
// it's from a previous group), then that one's in a; so that one's
// not going to move, and we should pivot on that one.
double mx = fabs((a.x)->Eval());
double my = fabs((a.y)->Eval());
double mz = fabs((a.z)->Eval());
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
// 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());
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
valA = acos(c)*180/PI;
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.
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
ZERO(&l);
// Generate the equations even if this is a reference dimension
GenerateReal(&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
if(l.n != 1) oops();
// These equations are written in the form f(...) - d = 0, where
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
// d is the value of the valA.
valA += (l.elem[0].e)->Eval();
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 reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
if(!reference) {
GenerateReal(l);
}
}
void Constraint::GenerateReal(IdList<Equation,hEquation> *l) {
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
Expr *exA = Expr::From(valA);
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
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 point-face distance constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1778]
2008-06-06 08:46:55 +00:00
case PT_FACE_DISTANCE: {
ExprVector pt = SS.GetEntity(ptA)->PointGetExprs();
Entity *f = SS.GetEntity(entityA);
ExprVector p0 = f->FaceGetPointExprs();
ExprVector n = f->FaceGetNormalExprs();
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
AddEq(l, (pt.Minus(p0)).Dot(n)->Minus(exA), 0);
Add point-face distance constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1778]
2008-06-06 08:46:55 +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;
}
Add two more exotic constraints: equal point-line distances, and point-line distance equal to line segment length. These are available in both normal and projected versions, with fancy display for all of these. [git-p4: depot-paths = "//depot/solvespace/": change = 1793]
2008-06-14 11:16:14 +00:00
// These work on distance squared, since the pt-line distances are
// signed, and we want the absolute value.
case EQ_LEN_PT_LINE_D: {
Entity *forLen = SS.GetEntity(entityA);
Expr *d1 = Distance(workplane, forLen->point[0], forLen->point[1]);
Expr *d2 = PointLineDistance(workplane, ptA, entityB);
AddEq(l, (d1->Square())->Minus(d2->Square()), 0);
break;
}
case EQ_PT_LN_DISTANCES: {
Expr *d1 = PointLineDistance(workplane, ptA, entityA);
Expr *d2 = PointLineDistance(workplane, ptB, entityB);
AddEq(l, (d1->Square())->Minus(d2->Square()), 0);
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 an interference check for assembled parts. That's easy once the BSP stuff works. The failures are reported with red stripes and no depth buffering, and in a message in the text window. Also improve convergence of point-on-line constraints, and don't write triangles to export files with limited precision, because that was making the coplanar tests fail. [git-p4: depot-paths = "//depot/solvespace/": change = 1774]
2008-06-04 06:39:32 +00:00
// Construct a vector from the point to either endpoint of
// the line segment, and choose the longer of these.
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);
Add an interference check for assembled parts. That's easy once the BSP stuff works. The failures are reported with red stripes and no depth buffering, and in a message in the text window. Also improve convergence of point-on-line constraints, and don't write triangles to export files with limited precision, because that was making the coplanar tests fail. [git-p4: depot-paths = "//depot/solvespace/": change = 1774]
2008-06-04 06:39:32 +00:00
ExprVector ebp = eb.Minus(ep);
ExprVector elp =
(ebp.Magnitude()->Eval() > eap.Magnitude()->Eval()) ?
ebp : eap;
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
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
if(p->group.v == group.v) {
Add an interference check for assembled parts. That's easy once the BSP stuff works. The failures are reported with red stripes and no depth buffering, and in a message in the text window. Also improve convergence of point-on-line constraints, and don't write triangles to export files with limited precision, because that was making the coplanar tests fail. [git-p4: depot-paths = "//depot/solvespace/": change = 1774]
2008-06-04 06:39:32 +00:00
AddEq(l, VectorsParallel(0, eab, elp), 0);
AddEq(l, VectorsParallel(1, eab, elp), 1);
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
} else {
Add an interference check for assembled parts. That's easy once the BSP stuff works. The failures are reported with red stripes and no depth buffering, and in a message in the text window. Also improve convergence of point-on-line constraints, and don't write triangles to export files with limited precision, because that was making the coplanar tests fail. [git-p4: depot-paths = "//depot/solvespace/": change = 1774]
2008-06-04 06:39:32 +00:00
AddEq(l, VectorsParallel(0, elp, eab), 0);
AddEq(l, VectorsParallel(1, elp, eab), 1);
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
}
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);
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
AddEq(l, au->Minus(bu), 1);
AddEq(l, av->Minus(bv), 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
} 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);
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
AddEq(l, au->Plus(bu), 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 {
AddEq(l, au->Minus(bu), 0);
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
AddEq(l, av->Plus(bv), 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
}
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);
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
if(b->group.v != group.v) {
SWAP(Entity *, a, b);
}
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
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: {
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
Entity *ea = SS.GetEntity(entityA), *eb = SS.GetEntity(entityB);
if(eb->group.v != group.v) {
SWAP(Entity *, ea, eb);
}
ExprVector a = ea->VectorGetExprs();
ExprVector b = eb->VectorGetExprs();
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
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;
}
Add a special constraint type for comments; no equations, just user-visible text. And make points hoverable/selectable even when GW.showPoints is false, and zoom to fit before regenerating on file open, because then we're at the right zoom level (and will use the right pwl tolerance). [git-p4: depot-paths = "//depot/solvespace/": change = 1788]
2008-06-12 08:58:58 +00:00
case COMMENT:
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();
}
}