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

655 lines
27 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"
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;
Add symmetric about line constraint. This applies only when locked in a workplane, since it would otherwise be ambiguous. [git-p4: depot-paths = "//depot/solvespace/": change = 1817]
2008-07-02 06:59:49 +00:00
case SYMMETRIC_LINE: s = "symmetric-line"; 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 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;
Add tangency constraints, for line segments against arcs or cubics. These are just a convenience, since it would be possible to get the same result by drawing a construction line. [git-p4: depot-paths = "//depot/solvespace/": change = 1836]
2008-07-13 12:44:05 +00:00
case ARC_LINE_TANGENT: s = "arc-line-tangent"; break;
case CUBIC_LINE_TANGENT:s = "cubic-line-tangent"; break;
Add a perpendicular constraint; identical to constraining a ninety degree angle, but shows with a right angle symbol instead of a numerical angle you can edit. [git-p4: depot-paths = "//depot/solvespace/": change = 1819]
2008-07-02 09:21:29 +00:00
case PERPENDICULAR: s = "perpendicular"; 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 EQUAL_RADIUS: s = "eq-radius"; break;
Add equal-angle constraints. These are implemented by brute force, as the difference between the cosines of the two angles. All of the angle stuff generates huge expressions (Expr *), but doesn't seem noticeably slow. [git-p4: depot-paths = "//depot/solvespace/": change = 1847]
2008-07-20 12:24:43 +00:00
case EQUAL_ANGLE: s = "eq-angle"; break;
Add a constraint to make line length equal arc length. That's quite tricky; can't just use the dot product, since that blows up when you cross pi radians. A gear shift approach, use either sin or cos, same kind of thing as the 3d-parallel constraint. And report a NaN constraint as unconverged, of course. [git-p4: depot-paths = "//depot/solvespace/": change = 1890]
2009-01-08 17:22:59 +00:00
case EQUAL_LINE_ARC_LEN:s = "eq-line-len-arc-len"; 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;
}
Auto-remove point-on-line constraints when at-midpoint constraints are added. There was already precedent for that, since I auto-remove horiz/vert constraints when symmetry constraints are added. [git-p4: depot-paths = "//depot/solvespace/": change = 1875]
2008-09-06 21:36:31 +00:00
//-----------------------------------------------------------------------------
// Delete all constraints with the specified type, entityA, ptA. We use this
// when auto-removing constraints that would become redundant.
//-----------------------------------------------------------------------------
void Constraint::DeleteAllConstraintsFor(int type, hEntity entityA, hEntity ptA)
{
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
SK.constraint.ClearTags();
for(int i = 0; i < SK.constraint.n; i++) {
Constraint *ct = &(SK.constraint.elem[i]);
Auto-remove point-on-line constraints when at-midpoint constraints are added. There was already precedent for that, since I auto-remove horiz/vert constraints when symmetry constraints are added. [git-p4: depot-paths = "//depot/solvespace/": change = 1875]
2008-09-06 21:36:31 +00:00
if(ct->type != type) continue;
if(ct->entityA.v != entityA.v) continue;
if(ct->ptA.v != ptA.v) continue;
ct->tag = 1;
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
SK.constraint.RemoveTagged();
Auto-remove point-on-line constraints when at-midpoint constraints are added. There was already precedent for that, since I auto-remove horiz/vert constraints when symmetry constraints are added. [git-p4: depot-paths = "//depot/solvespace/": change = 1875]
2008-09-06 21:36:31 +00:00
// And no need to do anything special, since nothing
// ever depends on a constraint. But do clear the
// hover, in case the just-deleted constraint was
// hovered.
SS.GW.hover.Clear();
}
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();
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
SK.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 a command to create an arc that's tangent to two line segments. This was possible before (by drawing everything explicitly), but now it's easy. [git-p4: depot-paths = "//depot/solvespace/": change = 1838]
2008-07-14 02:45:11 +00:00
void Constraint::Constrain(int type, hEntity ptA, hEntity ptB,
hEntity entityA, hEntity entityB,
bool other)
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
{
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 a command to create an arc that's tangent to two line segments. This was possible before (by drawing everything explicitly), but now it's easy. [git-p4: depot-paths = "//depot/solvespace/": change = 1838]
2008-07-14 02:45:11 +00:00
c.entityB = entityB;
c.other = other;
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 a command to create an arc that's tangent to two line segments. This was possible before (by drawing everything explicitly), but now it's easy. [git-p4: depot-paths = "//depot/solvespace/": change = 1838]
2008-07-14 02:45:11 +00:00
void Constraint::Constrain(int type, hEntity ptA, hEntity ptB, hEntity entityA){
Constrain(type, ptA, ptB, entityA, Entity::NO_ENTITY, false);
}
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) {
Add a command to create an arc that's tangent to two line segments. This was possible before (by drawing everything explicitly), but now it's easy. [git-p4: depot-paths = "//depot/solvespace/": change = 1838]
2008-07-14 02:45:11 +00:00
Constrain(POINTS_COINCIDENT, ptA, ptB,
Entity::NO_ENTITY, Entity::NO_ENTITY, false);
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;
Add symmetric about line constraint. This applies only when locked in a workplane, since it would otherwise be ambiguous. [git-p4: depot-paths = "//depot/solvespace/": change = 1817]
2008-07-02 06:59:49 +00:00
ZERO(&c);
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
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;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *e = SK.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 {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for distance / diameter constraint. This "
"constraint can apply to:\r\n\r\n"
" * two points (distance between points)\r\n"
" * a line segment (length)\r\n"
" * a workplane and a point (minimum distance)\r\n"
" * a line segment and a point (minimum distance)\r\n"
" * a plane face and a point (minimum distance)\r\n"
" * a circle or an arc (diameter)\r\n");
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
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);
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector a = SK.GetEntity(c.ptA)->PointGetNum();
Vector b = SK.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 {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for on point / curve / plane constraint. "
"This constraint can apply to:\r\n\r\n"
" * two points (points coincident)\r\n"
" * a point and a workplane (point in plane)\r\n"
" * a point and a line segment (point on line)\r\n"
" * a point and a circle or arc (point on curve)\r\n"
" * a point and a plane face (point on face)\r\n");
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
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 equal-angle constraints. These are implemented by brute force, as the difference between the cosines of the two angles. All of the angle stuff generates huge expressions (Expr *), but doesn't seem noticeably slow. [git-p4: depot-paths = "//depot/solvespace/": change = 1847]
2008-07-20 12:24:43 +00:00
} else if(gs.vectors == 4 && gs.n == 4) {
c.type = EQUAL_ANGLE;
c.entityA = gs.vector[0];
c.entityB = gs.vector[1];
c.entityC = gs.vector[2];
c.entityD = gs.vector[3];
} else if(gs.vectors == 3 && gs.n == 3) {
c.type = EQUAL_ANGLE;
c.entityA = gs.vector[0];
c.entityB = gs.vector[1];
c.entityC = gs.vector[1];
c.entityD = gs.vector[2];
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 a constraint to make line length equal arc length. That's quite tricky; can't just use the dot product, since that blows up when you cross pi radians. A gear shift approach, use either sin or cos, same kind of thing as the 3d-parallel constraint. And report a NaN constraint as unconverged, of course. [git-p4: depot-paths = "//depot/solvespace/": change = 1890]
2009-01-08 17:22:59 +00:00
} else if(gs.arcs == 1 && gs.lineSegments == 1 && gs.n == 2) {
c.type = EQUAL_LINE_ARC_LEN;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
if(SK.GetEntity(gs.entity[0])->type == Entity::ARC_OF_CIRCLE) {
Add a constraint to make line length equal arc length. That's quite tricky; can't just use the dot product, since that blows up when you cross pi radians. A gear shift approach, use either sin or cos, same kind of thing as the 3d-parallel constraint. And report a NaN constraint as unconverged, of course. [git-p4: depot-paths = "//depot/solvespace/": change = 1890]
2009-01-08 17:22:59 +00:00
c.entityA = gs.entity[1];
c.entityB = gs.entity[0];
} else {
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 {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for equal length / radius constraint. "
"This constraint can apply to:\r\n\r\n"
" * two line segments (equal length)\r\n"
" * two line segments and two points "
"(equal point-line distances)\r\n"
" * a line segment and two points "
"(equal point-line distances)\r\n"
" * a line segment, and a point and line segment "
"(point-line distance equals length)\r\n"
Add equal-angle constraints. These are implemented by brute force, as the difference between the cosines of the two angles. All of the angle stuff generates huge expressions (Expr *), but doesn't seem noticeably slow. [git-p4: depot-paths = "//depot/solvespace/": change = 1847]
2008-07-20 12:24:43 +00:00
" * four line segments or normals "
"(equal angle between A,B and C,D)\r\n"
" * three line segments or normals "
"(equal angle between A,B and B,C)\r\n"
Add a constraint to make line length equal arc length. That's quite tricky; can't just use the dot product, since that blows up when you cross pi radians. A gear shift approach, use either sin or cos, same kind of thing as the 3d-parallel constraint. And report a NaN constraint as unconverged, of course. [git-p4: depot-paths = "//depot/solvespace/": change = 1890]
2009-01-08 17:22:59 +00:00
" * two circles or arcs (equal radius)\r\n"
" * a line segment and an arc "
"(line segment length equals arc length)\r\n");
Add an equal length constraint for line segments. [git-p4: depot-paths = "//depot/solvespace/": change = 1680]
2008-04-22 05:00:49 +00:00
return;
}
Infer the correct supplementary angle from the sketch. Equal angle applies to whichever is closer to original position, and angle constraint, if the two vectors are lines that share an endpoint, applies to vectors out from that shared point. [git-p4: depot-paths = "//depot/solvespace/": change = 1863]
2008-02-26 12:48:31 +00:00
if(c.type == EQUAL_ANGLE) {
// Infer the nearest supplementary angle from the sketch.
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector a1 = SK.GetEntity(c.entityA)->VectorGetNum(),
b1 = SK.GetEntity(c.entityB)->VectorGetNum(),
a2 = SK.GetEntity(c.entityC)->VectorGetNum(),
b2 = SK.GetEntity(c.entityD)->VectorGetNum();
Infer the correct supplementary angle from the sketch. Equal angle applies to whichever is closer to original position, and angle constraint, if the two vectors are lines that share an endpoint, applies to vectors out from that shared point. [git-p4: depot-paths = "//depot/solvespace/": change = 1863]
2008-02-26 12:48:31 +00:00
double d1 = a1.Dot(b1), d2 = a2.Dot(b2);
if(d1*d2 < 0) {
c.other = true;
}
}
Add an equal length constraint for line segments. [git-p4: depot-paths = "//depot/solvespace/": change = 1680]
2008-04-22 05:00:49 +00:00
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 {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for length ratio constraint. This "
"constraint can apply to:\r\n\r\n"
" * two line segments\r\n");
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
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];
Auto-remove point-on-line constraints when at-midpoint constraints are added. There was already precedent for that, since I auto-remove horiz/vert constraints when symmetry constraints are added. [git-p4: depot-paths = "//depot/solvespace/": change = 1875]
2008-09-06 21:36:31 +00:00
// If a point is at-midpoint, then no reason to also constrain
// it on-line; so auto-remove that.
DeleteAllConstraintsFor(PT_ON_LINE, c.entityA, c.ptA);
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;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
int i = SK.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 {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for at midpoint constraint. This "
"constraint can apply to:\r\n\r\n"
" * a line segment and a point "
"(point at midpoint)\r\n"
" * a line segment and a workplane "
"(line's midpoint on plane)\r\n");
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;
}
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)))
{
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
int i = SK.GetEntity(gs.entity[0])->IsWorkplane() ? 1 : 0;
Entity *line = SK.GetEntity(gs.entity[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
c.entityA = gs.entity[1-i];
c.ptA = line->point[0];
c.ptB = line->point[1];
Add symmetric about line constraint. This applies only when locked in a workplane, since it would otherwise be ambiguous. [git-p4: depot-paths = "//depot/solvespace/": change = 1817]
2008-07-02 06:59:49 +00:00
} else if(SS.GW.LockedInWorkplane()
&& gs.lineSegments == 2 && gs.n == 2)
{
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *l0 = SK.GetEntity(gs.entity[0]),
*l1 = SK.GetEntity(gs.entity[1]);
Add symmetric about line constraint. This applies only when locked in a workplane, since it would otherwise be ambiguous. [git-p4: depot-paths = "//depot/solvespace/": change = 1817]
2008-07-02 06:59:49 +00:00
if((l1->group.v != SS.GW.activeGroup.v) ||
(l1->construction && !(l0->construction)))
{
SWAP(Entity *, l0, l1);
}
c.ptA = l1->point[0];
c.ptB = l1->point[1];
c.entityA = l0->h;
c.type = SYMMETRIC_LINE;
} else if(SS.GW.LockedInWorkplane()
&& gs.lineSegments == 1 && gs.points == 2 && gs.n == 3)
{
c.ptA = gs.point[0];
c.ptB = gs.point[1];
c.entityA = gs.entity[0];
c.type = SYMMETRIC_LINE;
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 {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for symmetric constraint. This constraint "
"can apply to:\r\n\r\n"
" * two points or a line segment "
"(symmetric about workplane's coordinate axis)\r\n"
" * line segment, and two points or a line segment "
"(symmetric about line segment)\r\n"
" * workplane, and two points or a line segment "
"(symmetric about workplane)\r\n");
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;
}
Add symmetric about line constraint. This applies only when locked in a workplane, since it would otherwise be ambiguous. [git-p4: depot-paths = "//depot/solvespace/": change = 1817]
2008-07-02 06:59:49 +00:00
if(c.type != 0) {
// Already done, symmetry about a line segment in a workplane
} else if(c.entityA.v == Entity::NO_ENTITY.v) {
// Horizontal / vertical symmetry, implicit symmetry plane
// normal to the workplane
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.workplane.v == Entity::FREE_IN_3D.v) {
Error("Must be locked in to workplane when constraining "
"symmetric without an explicit symmetry plane.");
return;
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector pa = SK.GetEntity(c.ptA)->PointGetNum();
Vector pb = SK.GetEntity(c.ptB)->PointGetNum();
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
Vector dp = pa.Minus(pb);
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *norm = SK.GetEntity(c.workplane)->Normal();;
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
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.
Auto-remove point-on-line constraints when at-midpoint constraints are added. There was already precedent for that, since I auto-remove horiz/vert constraints when symmetry constraints are added. [git-p4: depot-paths = "//depot/solvespace/": change = 1875]
2008-09-06 21:36:31 +00:00
DeleteAllConstraintsFor(HORIZONTAL, (gs.entity[0]),
Entity::NO_ENTITY);
DeleteAllConstraintsFor(VERTICAL, (gs.entity[0]),
Entity::NO_ENTITY);
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
}
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];
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *e = SK.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 {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for horizontal / vertical constraint. "
"This constraint can apply to:\r\n\r\n"
" * two points\r\n"
" * a line segment\r\n");
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
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 {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for same orientation constraint. This "
"constraint can apply to:\r\n\r\n"
" * two normals\r\n");
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
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();
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *nfree = SK.GetEntity(c.entityA);
Entity *nref = SK.GetEntity(c.entityB);
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
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) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Constraint *c = SK.GetConstraint(gs.constraint[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
if(c->type == ANGLE) {
Add equal-angle constraints. These are implemented by brute force, as the difference between the cosines of the two angles. All of the angle stuff generates huge expressions (Expr *), but doesn't seem noticeably slow. [git-p4: depot-paths = "//depot/solvespace/": change = 1847]
2008-07-20 12:24:43 +00:00
SS.UndoRemember();
Add tangency constraints, for line segments against arcs or cubics. These are just a convenience, since it would be possible to get the same result by drawing a construction line. [git-p4: depot-paths = "//depot/solvespace/": change = 1836]
2008-07-13 12:44:05 +00:00
c->other = !(c->other);
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->ModifyToSatisfy();
break;
}
Add equal-angle constraints. These are implemented by brute force, as the difference between the cosines of the two angles. All of the angle stuff generates huge expressions (Expr *), but doesn't seem noticeably slow. [git-p4: depot-paths = "//depot/solvespace/": change = 1847]
2008-07-20 12:24:43 +00:00
if(c->type == EQUAL_ANGLE) {
SS.UndoRemember();
c->other = !(c->other);
SS.MarkGroupDirty(c->group);
SS.later.generateAll = true;
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
}
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) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Constraint *c = SK.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);
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
SK.GetGroup(c->group)->clean = false;
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
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
Infer the correct supplementary angle from the sketch. Equal angle applies to whichever is closer to original position, and angle constraint, if the two vectors are lines that share an endpoint, applies to vectors out from that shared point. [git-p4: depot-paths = "//depot/solvespace/": change = 1863]
2008-02-26 12:48:31 +00:00
case GraphicsWindow::MNU_ANGLE: {
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(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
} else {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for angle constraint. This constraint "
"can apply to:\r\n\r\n"
" * two line segments\r\n"
" * a line segment and a normal\r\n"
" * two normals\r\n");
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
return;
}
Infer the correct supplementary angle from the sketch. Equal angle applies to whichever is closer to original position, and angle constraint, if the two vectors are lines that share an endpoint, applies to vectors out from that shared point. [git-p4: depot-paths = "//depot/solvespace/": change = 1863]
2008-02-26 12:48:31 +00:00
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *ea = SK.GetEntity(c.entityA),
*eb = SK.GetEntity(c.entityB);
Infer the correct supplementary angle from the sketch. Equal angle applies to whichever is closer to original position, and angle constraint, if the two vectors are lines that share an endpoint, applies to vectors out from that shared point. [git-p4: depot-paths = "//depot/solvespace/": change = 1863]
2008-02-26 12:48:31 +00:00
if(ea->type == Entity::LINE_SEGMENT &&
eb->type == Entity::LINE_SEGMENT)
{
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector a0 = SK.GetEntity(ea->point[0])->PointGetNum(),
a1 = SK.GetEntity(ea->point[1])->PointGetNum(),
b0 = SK.GetEntity(eb->point[0])->PointGetNum(),
b1 = SK.GetEntity(eb->point[1])->PointGetNum();
Infer the correct supplementary angle from the sketch. Equal angle applies to whichever is closer to original position, and angle constraint, if the two vectors are lines that share an endpoint, applies to vectors out from that shared point. [git-p4: depot-paths = "//depot/solvespace/": change = 1863]
2008-02-26 12:48:31 +00:00
if(a0.Equals(b0) || a1.Equals(b1)) {
// okay, vectors should be drawn in same sense
} else if(a0.Equals(b1) || a1.Equals(b0)) {
// vectors are in opposite sense
c.other = true;
} else {
// no shared point; not clear which intersection to draw
}
}
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.ModifyToSatisfy();
AddConstraint(&c);
break;
Infer the correct supplementary angle from the sketch. Equal angle applies to whichever is closer to original position, and angle constraint, if the two vectors are lines that share an endpoint, applies to vectors out from that shared point. [git-p4: depot-paths = "//depot/solvespace/": change = 1863]
2008-02-26 12:48:31 +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
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];
Add tangency constraints, for line segments against arcs or cubics. These are just a convenience, since it would be possible to get the same result by drawing a construction line. [git-p4: depot-paths = "//depot/solvespace/": change = 1836]
2008-07-13 12:44:05 +00:00
} else if(gs.lineSegments == 1 && gs.arcs == 1 && gs.n == 2) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *line = SK.GetEntity(gs.entity[0]);
Entity *arc = SK.GetEntity(gs.entity[1]);
Add tangency constraints, for line segments against arcs or cubics. These are just a convenience, since it would be possible to get the same result by drawing a construction line. [git-p4: depot-paths = "//depot/solvespace/": change = 1836]
2008-07-13 12:44:05 +00:00
if(line->type == Entity::ARC_OF_CIRCLE) {
SWAP(Entity *, line, arc);
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector l0 = SK.GetEntity(line->point[0])->PointGetNum(),
l1 = SK.GetEntity(line->point[1])->PointGetNum();
Vector a1 = SK.GetEntity(arc->point[1])->PointGetNum(),
a2 = SK.GetEntity(arc->point[2])->PointGetNum();
Add tangency constraints, for line segments against arcs or cubics. These are just a convenience, since it would be possible to get the same result by drawing a construction line. [git-p4: depot-paths = "//depot/solvespace/": change = 1836]
2008-07-13 12:44:05 +00:00
if(l0.Equals(a1) || l1.Equals(a1)) {
c.other = false;
} else if(l0.Equals(a2) || l1.Equals(a2)) {
c.other = true;
} else {
Error("The tangent arc and line segment must share an "
"endpoint. Constrain them with Constrain -> "
"On Point before constraining tangent.");
return;
}
c.type = ARC_LINE_TANGENT;
c.entityA = arc->h;
c.entityB = line->h;
} else if(gs.lineSegments == 1 && gs.cubics == 1 && gs.n == 2) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *line = SK.GetEntity(gs.entity[0]);
Entity *cubic = SK.GetEntity(gs.entity[1]);
Add tangency constraints, for line segments against arcs or cubics. These are just a convenience, since it would be possible to get the same result by drawing a construction line. [git-p4: depot-paths = "//depot/solvespace/": change = 1836]
2008-07-13 12:44:05 +00:00
if(line->type == Entity::CUBIC) {
SWAP(Entity *, line, cubic);
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector l0 = SK.GetEntity(line->point[0])->PointGetNum(),
l1 = SK.GetEntity(line->point[1])->PointGetNum();
Vector a0 = SK.GetEntity(cubic->point[0])->PointGetNum(),
a3 = SK.GetEntity(cubic->point[3])->PointGetNum();
Add tangency constraints, for line segments against arcs or cubics. These are just a convenience, since it would be possible to get the same result by drawing a construction line. [git-p4: depot-paths = "//depot/solvespace/": change = 1836]
2008-07-13 12:44:05 +00:00
if(l0.Equals(a0) || l1.Equals(a0)) {
c.other = false;
} else if(l0.Equals(a3) || l1.Equals(a3)) {
c.other = true;
} else {
Error("The tangent cubic and line segment must share an "
"endpoint. Constrain them with Constrain -> "
"On Point before constraining tangent.");
return;
}
c.type = CUBIC_LINE_TANGENT;
c.entityA = cubic->h;
c.entityB = line->h;
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
} else {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for parallel / tangent constraint. This "
"constraint can apply to:\r\n\r\n"
" * two line segments (parallel)\r\n"
" * a line segment and a normal (parallel)\r\n"
" * two normals (parallel)\r\n"
" * a line segment and an arc, that share an endpoint "
"(tangent)\r\n"
" * a line segment and a cubic bezier, that share an "
"endpoint (tangent)\r\n");
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
return;
}
AddConstraint(&c);
break;
Add a perpendicular constraint; identical to constraining a ninety degree angle, but shows with a right angle symbol instead of a numerical angle you can edit. [git-p4: depot-paths = "//depot/solvespace/": change = 1819]
2008-07-02 09:21:29 +00:00
case GraphicsWindow::MNU_PERPENDICULAR:
if(gs.vectors == 2 && gs.n == 2) {
c.type = PERPENDICULAR;
c.entityA = gs.vector[0];
c.entityB = gs.vector[1];
} else {
Add better error messages when creating constraints, and add a link when creating requests to cancel operation (works same as Esc). [git-p4: depot-paths = "//depot/solvespace/": change = 1839]
2008-07-14 04:29:43 +00:00
Error("Bad selection for perpendicular constraint. This "
"constraint can apply to:\r\n\r\n"
" * two line segments\r\n"
" * a line segment and a normal\r\n"
" * two normals\r\n");
Add a perpendicular constraint; identical to constraining a ninety degree angle, but shows with a right angle symbol instead of a numerical angle you can edit. [git-p4: depot-paths = "//depot/solvespace/": change = 1819]
2008-07-02 09:21:29 +00:00
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;
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