working line coincidence
howard
parent
cf69fee366
commit
84466424aa
File diff suppressed because one or more lines are too long
Binary file not shown.
|
|
@ -148,12 +148,13 @@ export class Sketcher extends THREE.Group {
|
|||
|
||||
moveLinePt(ptIdx, absPos) {
|
||||
this.ptsArr[ptIdx].geometry.attributes.position.set(absPos);
|
||||
this.ptsArr[ptIdx].geometry.attributes.position.needsUpdate = true;
|
||||
this.solve()
|
||||
// this.ptsArr[ptIdx].geometry.attributes.position.needsUpdate = true;
|
||||
|
||||
const lineIdx = Math.floor(ptIdx / 2)
|
||||
const endPtIdx = (ptIdx % 2) * 3
|
||||
this.linesArr[lineIdx].geometry.attributes.position.set(absPos, endPtIdx)
|
||||
this.linesArr[lineIdx].geometry.attributes.position.needsUpdate = true;
|
||||
// const lineIdx = Math.floor(ptIdx / 2)
|
||||
// const endPtIdx = (ptIdx % 2) * 3
|
||||
// this.linesArr[lineIdx].geometry.attributes.position.set(absPos, endPtIdx)
|
||||
// this.linesArr[lineIdx].geometry.attributes.position.needsUpdate = true;
|
||||
}
|
||||
|
||||
grabEnd() {
|
||||
|
|
@ -242,6 +243,7 @@ export class Sketcher extends THREE.Group {
|
|||
move(e) {
|
||||
const mouseLoc = this.getLocation(e);
|
||||
this.lineGeom.attributes.position.set(mouseLoc, 3)
|
||||
|
||||
this.lineGeom.attributes.position.needsUpdate = true;
|
||||
this.p2Geom.attributes.position.set(mouseLoc);
|
||||
this.p2Geom.attributes.position.needsUpdate = true;
|
||||
|
|
@ -259,29 +261,48 @@ export class Sketcher extends THREE.Group {
|
|||
}
|
||||
|
||||
solve() {
|
||||
// const linesBuf = new Float32Array(this.linesArr.length * 4)
|
||||
// const xyOnly = [0,1,3,4];
|
||||
// let p = 0
|
||||
// for (let i = 0; i < this.linesArr.length; i++) {
|
||||
// for (let j of xyOnly) {
|
||||
// linesBuf[p++] = this.linesArr[i].geometry.attributes.position.array[j]
|
||||
// }
|
||||
// }
|
||||
|
||||
let ptsBuf = new Float32Array(this.ptsArr.length * 2)
|
||||
for (let i = 0, p = 0; i < this.ptsArr.length; i++) {
|
||||
for (let j = 0; j < 2; j++) {
|
||||
ptsBuf[p++] = this.ptsArr[i].geometry.attributes.position.array[j]
|
||||
}
|
||||
ptsBuf[p++] = this.ptsArr[i].geometry.attributes.position.array[0]
|
||||
ptsBuf[p++] = this.ptsArr[i].geometry.attributes.position.array[1]
|
||||
}
|
||||
|
||||
|
||||
buffer = Module._malloc(ptsBuf.length * ptsBuf.BYTES_PER_ELEMENT)
|
||||
Module.HEAPF32.set(ptsBuf, buffer >> 2)
|
||||
Module["_solver"](this.ptsArr.length / 2, buffer)
|
||||
|
||||
Module["_solver"](this.ptsArr.length/2, buffer)
|
||||
|
||||
let ptr = buffer >> 2;
|
||||
|
||||
|
||||
for (let i = 0; i < ptsBuf.length; i += 4) {
|
||||
const pt1_pos = this.ptsArr[i >> 1].geometry.attributes.position;
|
||||
const pt2_pos = this.ptsArr[(i >> 1) + 1].geometry.attributes.position;
|
||||
const line_pos = this.linesArr[i >> 2].geometry.attributes.position;
|
||||
|
||||
pt1_pos.array[0] = Module.HEAPF32[ptr]
|
||||
line_pos.array[0] = Module.HEAPF32[ptr++]
|
||||
|
||||
pt1_pos.array[1] = Module.HEAPF32[ptr]
|
||||
line_pos.array[1] = Module.HEAPF32[ptr++]
|
||||
|
||||
pt2_pos.array[0] = Module.HEAPF32[ptr]
|
||||
line_pos.array[3] = Module.HEAPF32[ptr++]
|
||||
|
||||
pt2_pos.array[1] = Module.HEAPF32[ptr]
|
||||
line_pos.array[4] = Module.HEAPF32[ptr++]
|
||||
|
||||
pt1_pos.needsUpdate = true;
|
||||
pt2_pos.needsUpdate = true;
|
||||
line_pos.needsUpdate = true;
|
||||
}
|
||||
|
||||
this.dispatchEvent({ type: 'change' })
|
||||
|
||||
Module._free(buffer)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -135,4 +135,10 @@ int solver(int nLines, float *ptr)
|
|||
}
|
||||
sys.params = sys.constraints = sys.entities = 0;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
288
wasm/solver.c
288
wasm/solver.c
|
|
@ -32,239 +32,10 @@ static void *CheckMalloc(size_t n)
|
|||
* An example of a constraint in 3d. We create a single group, with some
|
||||
* entities and constraints.
|
||||
*---------------------------------------------------------------------------*/
|
||||
void Example3d()
|
||||
{
|
||||
/* This will contain a single group, which will arbitrarily number 1. */
|
||||
Slvs_hGroup g = 1;
|
||||
|
||||
/* A point, initially at (x y z) = (10 10 10) */
|
||||
sys.param[sys.params++] = Slvs_MakeParam(1, g, 10.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(2, g, 10.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(3, g, 10.0);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint3d(101, g, 1, 2, 3);
|
||||
/* and a second point at (20 20 20) */
|
||||
sys.param[sys.params++] = Slvs_MakeParam(4, g, 20.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(5, g, 20.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(6, g, 20.0);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint3d(102, g, 4, 5, 6);
|
||||
/* and a line segment connecting them. */
|
||||
sys.entity[sys.entities++] = Slvs_MakeLineSegment(200, g,
|
||||
SLVS_FREE_IN_3D, 101, 102);
|
||||
|
||||
/* The distance between the points should be 30.0 units. */
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
1, g,
|
||||
SLVS_C_PT_PT_DISTANCE,
|
||||
SLVS_FREE_IN_3D,
|
||||
30.0,
|
||||
101, 102, 0, 0);
|
||||
|
||||
/* Let's tell the solver to keep the second point as close to constant
|
||||
* as possible, instead moving the first point. */
|
||||
// sys.dragged[0] = 4;
|
||||
// sys.dragged[1] = 5;
|
||||
// sys.dragged[2] = 6;
|
||||
|
||||
/* Now that we have written our system, we solve. */
|
||||
Slvs_Solve(&sys, g);
|
||||
|
||||
if (sys.result == SLVS_RESULT_OKAY)
|
||||
{
|
||||
printf("okay; now at (%.3f %.3f %.3f)\n"
|
||||
" (%.3f %.3f %.3f)\n",
|
||||
sys.param[0].val, sys.param[1].val, sys.param[2].val,
|
||||
sys.param[3].val, sys.param[4].val, sys.param[5].val);
|
||||
printf("%d DOF\n", sys.dof);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("solve failed");
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* An example of a constraint in 2d. In our first group, we create a workplane
|
||||
* along the reference frame's xy plane. In a second group, we create some
|
||||
* entities in that group and dimension them.
|
||||
*---------------------------------------------------------------------------*/
|
||||
void Example2d(float xx)
|
||||
{
|
||||
Slvs_hGroup g;
|
||||
double qw, qx, qy, qz;
|
||||
|
||||
g = 1;
|
||||
/* First, we create our workplane. Its origin corresponds to the origin
|
||||
* of our base frame (x y z) = (0 0 0) */
|
||||
sys.param[sys.params++] = Slvs_MakeParam(1, g, 0.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(2, g, 0.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(3, g, 0.0);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint3d(101, g, 1, 2, 3);
|
||||
/* and it is parallel to the xy plane, so it has basis vectors (1 0 0)
|
||||
* and (0 1 0). */
|
||||
Slvs_MakeQuaternion(1, 0, 0,
|
||||
0, 1, 0, &qw, &qx, &qy, &qz);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(4, g, qw);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(5, g, qx);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(6, g, qy);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(7, g, qz);
|
||||
sys.entity[sys.entities++] = Slvs_MakeNormal3d(102, g, 4, 5, 6, 7);
|
||||
|
||||
sys.entity[sys.entities++] = Slvs_MakeWorkplane(200, g, 101, 102);
|
||||
|
||||
/* Now create a second group. We'll solve group 2, while leaving group 1
|
||||
* constant; so the workplane that we've created will be locked down,
|
||||
* and the solver can't move it. */
|
||||
g = 2;
|
||||
/* These points are represented by their coordinates (u v) within the
|
||||
* workplane, so they need only two parameters each. */
|
||||
sys.param[sys.params++] = Slvs_MakeParam(11, g, 10.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(12, g, 20.0);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(301, g, 200, 11, 12);
|
||||
|
||||
sys.param[sys.params++] = Slvs_MakeParam(13, g, 20.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(14, g, 10.0);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(302, g, 200, 13, 14);
|
||||
|
||||
/* And we create a line segment with those endpoints. */
|
||||
sys.entity[sys.entities++] = Slvs_MakeLineSegment(400, g,
|
||||
200, 301, 302);
|
||||
|
||||
/* Now three more points. */
|
||||
|
||||
sys.param[sys.params++] = Slvs_MakeParam(15, g, 110.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(16, g, 120.0);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(303, g, 200, 15, 16);
|
||||
|
||||
sys.param[sys.params++] = Slvs_MakeParam(17, g, 120.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(18, g, 110.0);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(304, g, 200, 17, 18);
|
||||
|
||||
sys.param[sys.params++] = Slvs_MakeParam(19, g, 115.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(20, g, xx);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(305, g, 200, 19, 20);
|
||||
|
||||
/* And arc, centered at point 303, starting at point 304, ending at
|
||||
* point 305. */
|
||||
sys.entity[sys.entities++] = Slvs_MakeArcOfCircle(401, g, 200, 102,
|
||||
303, 304, 305);
|
||||
|
||||
/* Now one more point, and a distance */
|
||||
sys.param[sys.params++] = Slvs_MakeParam(21, g, 200.0);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(22, g, 200.0);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(306, g, 200, 21, 22);
|
||||
|
||||
sys.param[sys.params++] = Slvs_MakeParam(23, g, 30.0);
|
||||
sys.entity[sys.entities++] = Slvs_MakeDistance(307, g, 200, 23);
|
||||
|
||||
/* And a complete circle, centered at point 306 with radius equal to
|
||||
* distance 307. The normal is 102, the same as our workplane. */
|
||||
sys.entity[sys.entities++] = Slvs_MakeCircle(402, g, 200,
|
||||
306, 102, 307);
|
||||
|
||||
/* The length of our line segment is 30.0 units. */
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
1, g,
|
||||
SLVS_C_PT_PT_DISTANCE,
|
||||
200,
|
||||
30.0,
|
||||
301, 302, 0, 0);
|
||||
|
||||
/* And the distance from our line segment to the origin is 10.0 units. */
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
2, g,
|
||||
SLVS_C_PT_LINE_DISTANCE,
|
||||
200,
|
||||
10.0,
|
||||
101, 0, 400, 0);
|
||||
/* And the line segment is vertical. */
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
3, g,
|
||||
SLVS_C_VERTICAL,
|
||||
200,
|
||||
0.0,
|
||||
0, 0, 400, 0);
|
||||
/* And the distance from one endpoint to the origin is 15.0 units. */
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
4, g,
|
||||
SLVS_C_PT_PT_DISTANCE,
|
||||
200,
|
||||
15.0,
|
||||
301, 101, 0, 0);
|
||||
#if 0
|
||||
/* And same for the other endpoint; so if you add this constraint then
|
||||
* the sketch is overconstrained and will signal an error. */
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
5, g,
|
||||
SLVS_C_PT_PT_DISTANCE,
|
||||
200,
|
||||
18.0,
|
||||
302, 101, 0, 0);
|
||||
#endif /* 0 */
|
||||
|
||||
/* The arc and the circle have equal radius. */
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
6, g,
|
||||
SLVS_C_EQUAL_RADIUS,
|
||||
200,
|
||||
0.0,
|
||||
0, 0, 401, 402);
|
||||
/* The arc has radius 17.0 units. */
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
7, g,
|
||||
SLVS_C_DIAMETER,
|
||||
200,
|
||||
17.0 * 2,
|
||||
0, 0, 401, 0);
|
||||
|
||||
/* If the solver fails, then ask it to report which constraints caused
|
||||
* the problem. */
|
||||
sys.calculateFaileds = 1;
|
||||
|
||||
/* And solve. */
|
||||
Slvs_Solve(&sys, g);
|
||||
|
||||
if (sys.result == SLVS_RESULT_OKAY)
|
||||
{
|
||||
printf("solved okay\n");
|
||||
printf("line from (%.3f %.3f) to (%.3f %.3f)\n",
|
||||
sys.param[7].val, sys.param[8].val,
|
||||
sys.param[9].val, sys.param[10].val);
|
||||
|
||||
printf("arc center (%.3f %.3f) start (%.3f %.3f) finish (%.3f %.3f)\n",
|
||||
sys.param[11].val, sys.param[12].val,
|
||||
sys.param[13].val, sys.param[14].val,
|
||||
sys.param[15].val, sys.param[16].val);
|
||||
|
||||
printf("circle center (%.3f %.3f) radius %.3f\n",
|
||||
sys.param[17].val, sys.param[18].val,
|
||||
sys.param[19].val);
|
||||
printf("%d DOF\n", sys.dof);
|
||||
}
|
||||
else
|
||||
{
|
||||
int i;
|
||||
printf("solve failed: problematic constraints are:");
|
||||
for (i = 0; i < sys.faileds; i++)
|
||||
{
|
||||
printf(" %d", sys.failed[i]);
|
||||
}
|
||||
printf("\n");
|
||||
if (sys.result == SLVS_RESULT_INCONSISTENT)
|
||||
{
|
||||
printf("system inconsistent\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("system nonconvergent\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int solver(int nLines, float *ptr)
|
||||
{
|
||||
// for (int i=0; i<nLines ;i++) {
|
||||
// printf("%f\n",*ptr++);
|
||||
// }
|
||||
|
||||
float *buf_pt_start = ptr;
|
||||
|
||||
Slvs_hGroup g;
|
||||
|
|
@ -296,50 +67,47 @@ int solver(int nLines, float *ptr)
|
|||
/* These points are represented by their coordinates (u v) within the
|
||||
* workplane, so they need only two parameters each. */
|
||||
|
||||
int ptStart = sys.params;
|
||||
int p_start = sys.params;
|
||||
|
||||
sys.param[sys.params++] = Slvs_MakeParam(11, g, (float)*ptr++);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(12, g, (float)*ptr++);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(301, g, 200, 11, 12);
|
||||
Slvs_hParam ph = 11, ph_s = 11;
|
||||
Slvs_hParam vh = 301, vh_s = 301;
|
||||
Slvs_hParam lh = 400, lh_s = 400;
|
||||
|
||||
sys.param[sys.params++] = Slvs_MakeParam(13, g, (float)*ptr++);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(14, g, (float)*ptr++);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(302, g, 200, 13, 14);
|
||||
Slvs_hParam con_id = 1;
|
||||
|
||||
/* And we create a line segment with those endpoints. */
|
||||
sys.entity[sys.entities++] = Slvs_MakeLineSegment(400, g,
|
||||
200, 301, 302);
|
||||
for (int i = 0; i < nLines * 2; i++)
|
||||
{
|
||||
|
||||
sys.param[sys.params++] = Slvs_MakeParam(15, g, (float)*ptr++);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(16, g, (float)*ptr++);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(303, g, 200, 15, 16);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(ph++, g, (float)*ptr++);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(ph++, g, (float)*ptr++);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(vh++, g, 200, ph - 1, ph - 2);
|
||||
|
||||
sys.param[sys.params++] = Slvs_MakeParam(17, g, (float)*ptr++);
|
||||
sys.param[sys.params++] = Slvs_MakeParam(18, g, (float)*ptr++);
|
||||
sys.entity[sys.entities++] = Slvs_MakePoint2d(304, g, 200, 17, 18);
|
||||
|
||||
sys.entity[sys.entities++] = Slvs_MakeLineSegment(401, g,
|
||||
200, 303, 304);
|
||||
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
421, g,
|
||||
SLVS_C_POINTS_COINCIDENT,
|
||||
200,
|
||||
0.0,
|
||||
302, 303, 0, 0);
|
||||
if (i % 2 == 1)
|
||||
{
|
||||
sys.entity[sys.entities++] = Slvs_MakeLineSegment(lh++, g,
|
||||
200, vh - 1, vh - 2);
|
||||
}
|
||||
else if (i > 0)
|
||||
{
|
||||
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
|
||||
con_id++, g,
|
||||
SLVS_C_POINTS_COINCIDENT,
|
||||
200,
|
||||
0.0,
|
||||
vh - 1, vh - 2, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/* And solve. */
|
||||
Slvs_Solve(&sys, g);
|
||||
|
||||
// printf("%i,wtf\n", sys.result);
|
||||
if (sys.result == SLVS_RESULT_OKAY)
|
||||
{
|
||||
printf("solved okay\n");
|
||||
// printf("solved okay\n");
|
||||
|
||||
for (int i = 0; i < nLines * 4; i++)
|
||||
{
|
||||
// *buf_pt_start++ = (float)sys.param[ptStart++].val;
|
||||
printf("%f\n", sys.param[ptStart++].val);
|
||||
*buf_pt_start++ = (float)sys.param[p_start++].val;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
|
|||
Loading…
Reference in New Issue