Backup_Repos/jsketcher
1
0
Fork 0
mirror of https://github.com/xibyte/jsketcher synced 2025-12-08 17:33:15 +01:00
Code Issues Projects Releases Wiki Activity
jsketcher/test/coreTests/testCases/legacy/brep-pip.js
Val Erastov (xibyte) 6d7d2648e3 replace old test framework with cypress, migrate the tests
2020-03-24 00:08:30 -07:00

686 lines
16 KiB
JavaScript
Raw Permalink Blame History

import * as test from '../../test'
export default {
/**
* o--------o
* | |
* *--> | |
* | |
* o--------o
*/
testPIPClassificationConvexOnlyEdgesOut: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500],
[100, 500]
]);
const result = classify(app, win, loop, [-300, 300]);
env.assertFalse(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* | *--> |
* | |
* o--------o
*/
testPIPClassificationConvexOnlyEdgesIn: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500],
[100, 500]
]);
const result = classify(app, win, loop, [300, 300]);
env.assertTrue(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* *--> o |
* | |
* o--------o
*/
testPIPClassificationConvexPointAndEdgeOut: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500],
[100, 500],
[100, 300]
]);
const result = classify(app, win, loop, [-300, 300]);
env.assertFalse(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* o *--> |
* | |
* o--------o
*/
testPIPClassificationConvexPointAndEdgeIn: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500],
[100, 500],
[100, 300]
]);
const result = classify(app, win, loop, [300, 300]);
env.assertTrue(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* *--> o o
* | |
* o--------o
*/
testPIPClassificationConvexPointAndPointOut: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 300],
[500, 500],
[100, 500],
[100, 300]
]);
const result = classify(app, win, loop, [-300, 300]);
env.assertFalse(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* o *--> o
* | |
* o--------o
*/
testPIPClassificationConvexPointAndPointIn: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 300],
[500, 500],
[100, 500],
[100, 300]
]);
const result = classify(app, win, loop, [300, 300]);
env.assertTrue(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* *--> o-----o |
* | |
* o--------------o
*/
testPIPClassificationCollinearOut: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500],
[200, 500],
[200, 300],
[100, 300]
]);
const result = classify(app, win, loop, [-300, 300]);
env.assertFalse(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* o-----o *--> |
* | |
* o--------------o
*/
testPIPClassificationCollinearIn: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500],
[200, 500],
[200, 300],
[100, 300]
]);
const result = classify(app, win, loop, [300, 300]);
env.assertTrue(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* *--> o-----o o-----o
* | |
* o--------------------o
*/
testPIPClassificationCollinear2Out: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 300],
[400, 300],
[400, 500],
[200, 500],
[200, 300],
[100, 300]
]);
const result = classify(app, win, loop, [-300, 300]);
env.assertFalse(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* o-----o *--> o-----o
* | |
* o--------------------o
*/
testPIPClassificationCollinear2In: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 300],
[400, 300],
[400, 500],
[200, 500],
[200, 300],
[100, 300]
]);
const result = classify(app, win, loop, [300, 300]);
env.assertTrue(result.inside);
env.done();
}));
},
/**
* *--> o
* / \
* / \
* / \
* / \
* o---------o
*/
testPIPClassificationKissingVertexOut: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[300, 300],
]);
const result = classify(app, win, loop, [- 300, 300]);
env.assertFalse(result.inside);
env.done();
}));
},
/**
* *--> o-----o
* / \
* / \
* / \
* / \
* o---------------o
*/
testPIPClassificationKissingVertexAndCollinearOut: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[400, 300],
[200, 300],
]);
const result = classify(app, win, loop, [- 300, 300]);
env.assertFalse(result.inside);
env.done();
}));
},
/**
* *--> o o
* / \ / \
* / \ / \
* / \ / \
* / o \
* o-----------------o
*/
testPIPClassificationKissing2VerticesOut: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[400, 300],
[300, 200],
[200, 300],
]);
const result = classify(app, win, loop, [- 300, 300]);
env.assertFalse(result.inside);
env.done();
}));
},
/**
* o o
* / \ / \
* / \ / \
* / \ / \
* / *--> o \
* o-----------------o
*/
testPIPClassificationKissingVertexIn: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[400, 300],
[300, 200],
[200, 300],
]);
const result = classify(app, win, loop, [200, 200]);
env.assertTrue(result.inside);
env.done();
}));
},
/**
* o o
* / \ |\
* / \ | \
* / \ | \
* / *--> o---o \
* o-----------------o
*/
testPIPClassificationKissingVertexCollinearIn: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[400, 300],
[400, 200],
[300, 200],
[200, 300],
]);
const result = classify(app, win, loop, [200, 200]);
env.assertTrue(result.inside);
env.done();
}));
},
/**
* o o
* / \ |\
* / \ o | \
* / \ / \ | \
* / *--> o o \
* o-----------------o
*/
testPIPClassificationKissing2VerticesIn: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[400, 300],
[400, 200],
[350, 300],
[300, 200],
[200, 300],
]);
const result = classify(app, win, loop, [200, 200]);
env.assertTrue(result.inside);
env.done();
}));
},
/**
* o--------o
* | |
* * |
* | |
* o--------o
*/
testPIPClassificationOnEdgesPerp: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500],
[100, 500]
]);
const result = classify(app, win, loop, [100, 300]);
env.assertTrue(result.inside);
env.assertTrue(result.edge[0] === loop[3]);
env.done();
}));
},
/**
* o
* /|
* * |
* / |
* o---o
*/
testPIPClassificationOnEdgesAngled: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500]
]);
const result = classify(app, win, loop, [300, 300]);
env.assertTrue(result.inside);
env.assertTrue(result.edge[0] === loop[2]);
env.done();
}));
},
/**
* o---*----o
* | |
* | |
* | |
* o--------o
*/
testPIPClassificationOnEdgesCollinear: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500],
[100, 500]
]);
const result = classify(app, win, loop, [300, 500]);
env.assertTrue(result.inside);
env.assertTrue(result.edge[0] === loop[2]);
env.done();
}));
},
/**
* o--------o
* | |
* o-*---o o-----o
* | |
* o--------------------o
*/
testPIPClassificationOnEdgesCollinearT1: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 300],
[400, 300],
[400, 500],
[200, 500],
[200, 300],
[100, 300]
]);
const result = classify(app, win, loop, [150, 300]);
env.assertTrue(result.inside);
env.assertTrue(result.edge[0] === loop[6]);
env.done();
}));
},
/**
* o--------o
* | |
* o-----o o---*-o
* | |
* o--------------------o
*/
testPIPClassificationOnEdgesCollinearT2: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 300],
[400, 300],
[400, 500],
[200, 500],
[200, 300],
[100, 300]
]);
const result = classify(app, win, loop, [450, 300]);
env.assertTrue(result.inside);
env.assertTrue(result.edge[0] === loop[2]);
env.done();
}));
},
/**
* o--------o
* | |
* | |
* | |
* (*)-------o
*/
testPIPClassificationOnVertex: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 500],
[100, 500]
]);
const result = classify(app, win, loop, [100, 100]);
env.assertTrue(result.inside);
env.assertTrue(result.vertex === loop[0]);
env.done();
}));
},
/**
* o--------o
* | |
* o----(*) o-----o
* | |
* o--------------------o
*/
testPIPClassificationOnVertexT1: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 300],
[400, 300],
[400, 500],
[200, 500],
[200, 300],
[100, 300]
]);
const result = classify(app, win, loop, [200, 300]);
env.assertTrue(result.inside);
env.assertTrue(result.vertex === loop[6]);
env.done();
}));
},
/**
* o--------o
* | |
* o-----o (*)----o
* | |
* o--------------------o
*/
testPIPClassificationOnVertexT2: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[500, 300],
[400, 300],
[400, 500],
[200, 500],
[200, 300],
[100, 300]
]);
const result = classify(app, win, loop, [400, 300]);
env.assertTrue(result.inside);
env.assertTrue(result.vertex === loop[3]);
env.done();
}));
},
/**
* o o
* / \ |\
* / \ * | \
* / \ / \ | \
* / o o \
* o-----------------o
*/
testPIPClassificationOnVertexNonConvex: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[100, 100],
[500, 100],
[400, 300],
[400, 200],
[350, 300],
[300, 200],
[200, 300],
]);
const result = classify(app, win, loop, [350, 300]);
env.assertTrue(result.inside);
env.assertTrue(result.vertex === loop[4]);
env.done();
}));
},
/**
* o--------o
* | |
* | *--> o
* | |
* o-o------o
*/
testPIPClassificationConvexPointAndPointInRound: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[173.69055445978523, -250],
[173.69055445978523, -40.45650878155794],
[173.69055445978523, 250],
[-17.236467236467238, 250],
[-17.236467236467238, -250],
[5.818373610536707, -250]
]);
const result = classify(app, win, loop, [5.818373610536707, -40.45650878155793]);
env.assertTrue(result.inside);
env.done();
}));
},
testPIPClassification_TR_OUT_TR_INNER: function (env) {
test.modeller(env.test((win, app) => {
const loop = createLoop(app.TPI,[
[322.13852864400235, -37.0295350874076],
[367.4746645834503, -15.906441503172019],
[251.791373147527, 232.3826363038744],
[245.2760702222779, 246.36631998769906],
[220.04289927805857, 300.5238449519503],
[174.70676333861064, 279.4007513677147],
[190.09822472107308, 246.36631998769903],
[251.82559013214498, 113.88192709797234],
]);
const result = classify(app, win, loop, [201.75255470018428, 221.3528300786975]);
env.assertTrue(result.inside);
env.done();
}));
},
}
function classify(app, win, loop, p) {
const n = loop.length;
for (let p = n - 1, q = 0; q < n; p = q ++) {
const a = loop[p];
const b = loop[q];
win.__DEBUG__.AddSegment(a, b, 0xffff00);
}
const pnt = new app.TPI.brep.geom.Point(p[0], p[1], 0);
const beam = pnt.copy();
beam.x += 1700;
win.__DEBUG__.AddLine(pnt, beam);
win.__DEBUG__.AddPoint(pnt, 0xffffff);
const result = app.TPI.brep.pip(loop)(pnt);
win.__DEBUG__.AddPoint(pnt, result.inside ? 0x00ff00 : 0xff0000);
if (result.edge) {
win.__DEBUG__.AddSegment(result.edge[0], result.edge[1], 0xffffff)
}
return result;
}
function createLoop(tpi, points) {
return points.map(([x, y]) => new tpi.brep.geom.Point(x, y, 0));
}
Reference in a new issue View git blame Copy permalink