@jscad/modeling 2.9.3 → 2.9.4

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.9.4](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/modeling@2.9.3...@jscad/modeling@2.9.4) (2022-05-15)
+
+
+### Performance Improvements
+
+* **maths:** reworked mat4 isMirror to use pure math, eliminating vec3 creation ([#1088](https://github.com/jscad/OpenJSCAD.org/issues/1088)) ([db4f220](https://github.com/jscad/OpenJSCAD.org/commit/db4f220d000fd08c7e3adab16401a8ea3b06478a))
+* **modeling:** improved performance of reTesselateCoplanarPolygons by using maps or sets ([#1085](https://github.com/jscad/OpenJSCAD.org/issues/1085)) ([fc57103](https://github.com/jscad/OpenJSCAD.org/commit/fc57103f3183781dd3cf97600e9a33386da9a514))
+* **modeling:** use Map instead of {} for slice.repair ([#1083](https://github.com/jscad/OpenJSCAD.org/issues/1083)) ([05d2984](https://github.com/jscad/OpenJSCAD.org/commit/05d29849404193f2e4ed6e945a058aec2b124e3d))
+
+
+
+
+
 ## [2.9.3](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/modeling@2.9.2...@jscad/modeling@2.9.3) (2022-04-24)
 
 

package/dist/jscad-modeling.min.js

@@ -425,9 +425,9 @@ const invert=(t,e)=>{const n=e[0],r=e[1],l=e[2],o=e[3],s=e[4],u=e[5],c=e[6],i=e[
 const isIdentity=t=>1===t[0]&&0===t[1]&&0===t[2]&&0===t[3]&&0===t[4]&&1===t[5]&&0===t[6]&&0===t[7]&&0===t[8]&&0===t[9]&&1===t[10]&&0===t[11]&&0===t[12]&&0===t[13]&&0===t[14]&&1===t[15];module.exports=isIdentity;
 
 },{}],143:[function(require,module,exports){
-const cross=require("../vec3/cross"),dot=require("../vec3/dot"),fromValues=require("../vec3/fromValues"),isMirroring=r=>{const e=fromValues(r[0],r[4],r[8]),o=fromValues(r[1],r[5],r[9]),s=fromValues(r[2],r[6],r[10]);return dot(cross(e,e,o),s)<0};module.exports=isMirroring;
+const isMirroring=r=>{const i=r[4]*r[9]-r[8]*r[5],o=r[8]*r[1]-r[0]*r[9],n=r[0]*r[5]-r[4]*r[1];return i*r[2]+o*r[6]+n*r[10]<0};module.exports=isMirroring;
 
-},{"../vec3/cross":209,"../vec3/dot":212,"../vec3/fromValues":215}],144:[function(require,module,exports){
+},{}],144:[function(require,module,exports){
 const isOnlyTransformScale=s=>isZero(s[1])&&isZero(s[2])&&isZero(s[3])&&isZero(s[4])&&isZero(s[6])&&isZero(s[7])&&isZero(s[8])&&isZero(s[9])&&isZero(s[11])&&1===s[15],isZero=s=>Math.abs(s)<Number.EPSILON;module.exports=isOnlyTransformScale;
 
 },{}],145:[function(require,module,exports){
@@ -905,9 +905,9 @@ const geom2=require("../../../geometries/geom2"),plane=require("../../../maths/p
 const pointInTriangle=(n,a,e,r,i,o,t,x)=>(i-t)*(a-x)-(n-t)*(o-x)>=0&&(n-t)*(r-x)-(e-t)*(a-x)>=0&&(e-t)*(o-x)-(i-t)*(r-x)>=0,area=(n,a,e)=>(a.y-n.y)*(e.x-a.x)-(a.x-n.x)*(e.y-a.y);module.exports={area:area,pointInTriangle:pointInTriangle};
 
 },{}],303:[function(require,module,exports){
-const mat4=require("../../maths/mat4"),geom2=require("../../geometries/geom2"),geom3=require("../../geometries/geom3"),poly3=require("../../geometries/poly3"),slice=require("./slice"),repairSlice=require("./slice/repairSlice"),extrudeWalls=require("./extrudeWalls"),defaultCallback=(e,r,l)=>{let t=null;return geom2.isA(l)&&(t=slice.fromSides(geom2.toSides(l))),poly3.isA(l)&&(t=slice.fromPoints(poly3.toPoints(l))),0===e||1===e?slice.transform(mat4.fromTranslation(mat4.create(),[0,0,e]),t):null},extrudeFromSlices=(e,r)=>{const l={numberOfSlices:2,capStart:!0,capEnd:!0,close:!1,repair:!0,callback:defaultCallback},{numberOfSlices:t,capStart:o,capEnd:c,close:s,repair:i,callback:a}=Object.assign({},l,e);if(t<2)throw new Error("numberOfSlices must be 2 or more");i&&repairSlice(r);const n=t-1;let u=null,m=null,f=null,g=[];for(let e=0;e<t;e++){const l=a(e/n,e,r);if(l){if(!slice.isA(l))throw new Error("the callback function must return slice objects");if(0===slice.toEdges(l).length)throw new Error("the callback function must return slices with one or more edges");f&&(g=g.concat(extrudeWalls(f,l))),0===e&&(u=l),e===t-1&&(m=l),f=l}}if(c){const e=slice.toPolygons(m);g=g.concat(e)}if(o){const e=slice.toPolygons(u).map(poly3.invert);g=g.concat(e)}return o||c||s&&!slice.equals(m,u)&&(g=g.concat(extrudeWalls(m,u))),geom3.create(g)};module.exports=extrudeFromSlices;
+const mat4=require("../../maths/mat4"),geom2=require("../../geometries/geom2"),geom3=require("../../geometries/geom3"),poly3=require("../../geometries/poly3"),slice=require("./slice"),repairSlice=require("./slice/repair"),extrudeWalls=require("./extrudeWalls"),defaultCallback=(e,r,l)=>{let t=null;return geom2.isA(l)&&(t=slice.fromSides(geom2.toSides(l))),poly3.isA(l)&&(t=slice.fromPoints(poly3.toPoints(l))),0===e||1===e?slice.transform(mat4.fromTranslation(mat4.create(),[0,0,e]),t):null},extrudeFromSlices=(e,r)=>{const l={numberOfSlices:2,capStart:!0,capEnd:!0,close:!1,repair:!0,callback:defaultCallback},{numberOfSlices:t,capStart:o,capEnd:c,close:s,repair:i,callback:a}=Object.assign({},l,e);if(t<2)throw new Error("numberOfSlices must be 2 or more");i&&(r=repairSlice(r));const n=t-1;let u=null,m=null,f=null,g=[];for(let e=0;e<t;e++){const l=a(e/n,e,r);if(l){if(!slice.isA(l))throw new Error("the callback function must return slice objects");if(0===slice.toEdges(l).length)throw new Error("the callback function must return slices with one or more edges");f&&(g=g.concat(extrudeWalls(f,l))),0===e&&(u=l),e===t-1&&(m=l),f=l}}if(c){const e=slice.toPolygons(m);g=g.concat(e)}if(o){const e=slice.toPolygons(u).map(poly3.invert);g=g.concat(e)}return o||c||s&&!slice.equals(m,u)&&(g=g.concat(extrudeWalls(m,u))),geom3.create(g)};module.exports=extrudeFromSlices;
 
-},{"../../geometries/geom2":22,"../../geometries/geom3":37,"../../geometries/poly3":75,"../../maths/mat4":140,"./extrudeWalls":311,"./slice":320,"./slice/repairSlice":322}],304:[function(require,module,exports){
+},{"../../geometries/geom2":22,"../../geometries/geom3":37,"../../geometries/poly3":75,"../../maths/mat4":140,"./extrudeWalls":311,"./slice":320,"./slice/repair":322}],304:[function(require,module,exports){
 const flatten=require("../../utils/flatten"),geom2=require("../../geometries/geom2"),path2=require("../../geometries/path2"),extrudeLinearGeom2=require("./extrudeLinearGeom2"),extrudeLinearPath2=require("./extrudeLinearPath2"),extrudeLinear=(e,...t)=>{const{height:r,twistAngle:i,twistSteps:n,repair:a}=Object.assign({},{height:1,twistAngle:0,twistSteps:1,repair:!0},e);if(0===(t=flatten(t)).length)throw new Error("wrong number of arguments");e={offset:[0,0,r],twistAngle:i,twistSteps:n,repair:a};const s=t.map(t=>path2.isA(t)?extrudeLinearPath2(e,t):geom2.isA(t)?extrudeLinearGeom2(e,t):t);return 1===s.length?s[0]:s};module.exports=extrudeLinear;
 
 },{"../../geometries/geom2":22,"../../geometries/path2":58,"../../utils/flatten":391,"./extrudeLinearGeom2":305,"./extrudeLinearPath2":306}],305:[function(require,module,exports){
@@ -962,9 +962,9 @@ module.exports={calculatePlane:require("./calculatePlane"),clone:require("./clon
 const isA=e=>!!(e&&"object"==typeof e&&"edges"in e&&Array.isArray(e.edges));module.exports=isA;
 
 },{}],322:[function(require,module,exports){
-const vec3=require("../../../maths/vec3"),repairSlice=e=>{if(!e.edges)return e;const t={},r={};e.edges.forEach(e=>{const c=e[0].toString(),o=e[1].toString();t[c]=e[0],t[o]=e[1],r[c]=(r[c]||0)+1,r[o]=(r[o]||0)-1});const c=Object.keys(r).filter(e=>r[e]<0),o=Object.keys(r).filter(e=>r[e]>0);return c.forEach(r=>{const c=t[r];let i,s=1/0;o.forEach(e=>{const r=t[e],o=Math.hypot(c[0]-r[0],c[1]-r[1]);o<s&&(s=o,i=r)}),console.warn(`repairSlice: repairing vertex gap ${c} to ${i} distance ${s}`),e.edges.forEach(e=>{e[0].toString()===r&&(e[0]=i),e[1].toString()===r&&(e[1]=i)})}),e.edges=e.edges.filter(e=>!vec3.equals(e[0],e[1])),e};module.exports=repairSlice;
+const vec3=require("../../../maths/vec3"),create=require("./create"),repair=e=>{if(!e.edges)return e;let t=e.edges;const r=new Map,a=new Map;(t=t.filter(e=>!vec3.equals(e[0],e[1]))).forEach(e=>{const t=e[0].toString(),o=e[1].toString();r.set(t,e[0]),r.set(o,e[1]),a.set(t,(a.get(t)||0)+1),a.set(o,(a.get(o)||0)-1)});const o=[],s=[];return a.forEach((e,t)=>{e<0&&o.push(t),e>0&&s.push(t)}),o.forEach(e=>{const a=r.get(e);let o,c=1/0;s.forEach(e=>{const t=r.get(e),s=Math.hypot(a[0]-t[0],a[1]-t[1]);s<c&&(c=s,o=t)}),console.warn(`slice.repair: repairing vertex gap ${a} to ${o} distance ${c}`),t=t.map(t=>t[0].toString()===e?[o,t[1]]:t[1].toString()===e?[t[0],o]:t)}),create(t)};module.exports=repair;
 
-},{"../../../maths/vec3":217}],323:[function(require,module,exports){
+},{"../../../maths/vec3":217,"./create":316}],323:[function(require,module,exports){
 const create=require("./create"),reverse=(...e)=>{let r,t;return 1===e.length?(r=create(),t=e[0]):(r=e[0],t=e[1]),r.edges=t.edges.map(e=>[e[1],e[0]]),r};module.exports=reverse;
 
 },{"./create":316}],324:[function(require,module,exports){
@@ -1040,7 +1040,7 @@ const constants=require("../../maths/constants"),vec3=require("../../maths/vec3"
 const aboutEqualNormals=require("../../maths/utils/aboutEqualNormals"),vec3=require("../../maths/vec3"),poly3=require("../../geometries/poly3"),createEdges=e=>{const n=poly3.toPoints(e),t=[];for(let e=0;e<n.length;e++){const l=(e+1)%n.length,r={v1:n[e],v2:n[l]};t.push(r)}for(let e=0;e<t.length;e++){const l=(e+1)%n.length;t[e].next=t[l],t[l].prev=t[e]}return t},insertEdge=(e,n)=>{const t=`${n.v1}:${n.v2}`;e.set(t,n)},deleteEdge=(e,n)=>{const t=`${n.v1}:${n.v2}`;e.delete(t)},findOppositeEdge=(e,n)=>{const t=`${n.v2}:${n.v1}`;return e.get(t)},calculateAnglesBetween=(e,n,t)=>{let l=e.prev.v1,r=e.prev.v2,o=n.next.v2;const v=calculateAngle(l,r,o,t);return l=n.prev.v1,r=n.prev.v2,o=e.next.v2,[v,calculateAngle(l,r,o,t)]},v1=vec3.create(),v2=vec3.create(),calculateAngle=(e,n,t,l)=>{const r=vec3.subtract(v1,n,e),o=vec3.subtract(v2,t,n);return vec3.cross(r,r,o),vec3.dot(r,l)},createPolygonAnd=e=>{let n;const t=[];for(;e.next;){const n=e.next;t.push(e.v1),e.v1=null,e.v2=null,e.next=null,e.prev=null,e=n}return t.length>0&&(n=poly3.create(t)),n},mergeCoplanarPolygons=e=>{if(e.length<2)return e;const n=e[0].plane,t=e.slice(),l=new Map;for(;t.length>0;){const e=t.shift(),r=createEdges(e);for(let e=0;e<r.length;e++){const t=r[e],o=findOppositeEdge(l,t);if(o){const e=calculateAnglesBetween(t,o,n);if(e[0]>=0&&e[1]>=0){const n=o.next,r=t.next;t.prev.next=o.next,t.next.prev=o.prev,o.prev.next=t.next,o.next.prev=t.prev,t.v1=null,t.v2=null,t.next=null,t.prev=null,deleteEdge(l,o),o.v1=null,o.v2=null,o.next=null,o.prev=null;const v=(e,n,t)=>{const l={v1:t.v1,v2:n.v2,next:n.next,prev:t.prev};t.prev.next=l,n.next.prev=l,deleteEdge(e,n),n.v1=null,n.v2=null,n.next=null,n.prev=null,deleteEdge(e,t),t.v1=null,t.v2=null,t.next=null,t.prev=null};0===e[0]&&v(l,n,n.prev),0===e[1]&&v(l,r,r.prev)}}else t.next&&insertEdge(l,t)}}const r=[];return l.forEach(e=>{const n=createPolygonAnd(e);n&&r.push(n)}),l.clear(),r},coplanar=(e,n)=>Math.abs(e[3]-n[3])<1.5e-7&&aboutEqualNormals(e,n),mergePolygons=(e,n)=>{const t=[];n.forEach(e=>{const n=t.find(n=>coplanar(n[0],poly3.plane(e)));if(n){n[1].push(e)}else t.push([poly3.plane(e),[e]])});let l=[];return t.forEach(e=>{const n=e[1],t=mergeCoplanarPolygons(n);l=l.concat(t)}),l};module.exports=mergePolygons;
 
 },{"../../geometries/poly3":75,"../../maths/utils/aboutEqualNormals":163,"../../maths/vec3":217}],348:[function(require,module,exports){
-const{EPS:EPS}=require("../../maths/constants"),line2=require("../../maths/line2"),vec2=require("../../maths/vec2"),OrthoNormalBasis=require("../../maths/OrthoNormalBasis"),interpolateBetween2DPointsForY=require("../../maths/utils/interpolateBetween2DPointsForY"),{insertSorted:insertSorted,fnNumberSort:fnNumberSort}=require("../../utils"),poly3=require("../../geometries/poly3"),reTesselateCoplanarPolygons=t=>{if(t.length<2)return t;const e=[],o=t.length,n=poly3.plane(t[0]),l=new OrthoNormalBasis(n),i=[],r=[],s={},f={},p={},h=10/EPS;for(let e=0;e<o;e++){const o=t[e];let n=[],c=o.vertices.length,g=-1;if(c>0){let t,i;for(let r=0;r<c;r++){let s=l.to2D(o.vertices[r]);const c=Math.floor(s[1]*h);let a;c in p?a=p[c]:c+1 in p?a=p[c+1]:c-1 in p?a=p[c-1]:(a=s[1],p[c]=s[1]),s=vec2.fromValues(s[0],a),n.push(s);const u=s[1];(0===r||u<t)&&(t=u,g=r),(0===r||u>i)&&(i=u),u in f||(f[u]={}),f[u][e]=!0}t>=i?(n=[],c=0,g=-1):(t in s||(s[t]=[]),s[t].push(e))}n.reverse(),g=c-g-1,i.push(n),r.push(g)}const c=[];for(const t in f)c.push(t);c.sort(fnNumberSort);let g=[],a=[];for(let t=0;t<c.length;t++){const o=[],p=c[t],h=Number(p),u=f[p];for(let t=0;t<g.length;++t){const e=g[t],o=e.polygonindex;if(u[o]){const n=i[o],l=n.length;let r=e.leftvertexindex,s=e.rightvertexindex;for(;;){let t=r+1;if(t>=l&&(t=0),n[t][1]!==h)break;r=t}let f=s-1;if(f<0&&(f=l-1),n[f][1]===h&&(s=f),r!==e.leftvertexindex&&r===s)g.splice(t,1),--t;else{e.leftvertexindex=r,e.rightvertexindex=s,e.topleft=n[r],e.topright=n[s];let t=r+1;t>=l&&(t=0),e.bottomleft=n[t];let o=s-1;o<0&&(o=l-1),e.bottomright=n[o]}}}let m;if(t>=c.length-1)g=[],m=null;else{const e=.5*(h+(m=Number(c[t+1]))),o=s[p];for(const t in o){const n=o[t],l=i[n],s=l.length,f=r[n];let p=f;for(;;){let t=p+1;if(t>=s&&(t=0),l[t][1]!==h)break;if(t===f)break;p=t}let c=f;for(;;){let t=c-1;if(t<0&&(t=s-1),l[t][1]!==h)break;if(t===p)break;c=t}let a=p+1;a>=s&&(a=0);let u=c-1;u<0&&(u=s-1);const m={polygonindex:n,leftvertexindex:p,rightvertexindex:c,topleft:l[p],topright:l[c],bottomleft:l[a],bottomright:l[u]};insertSorted(g,m,(t,o)=>{const n=interpolateBetween2DPointsForY(t.topleft,t.bottomleft,e),l=interpolateBetween2DPointsForY(o.topleft,o.bottomleft,e);return n>l?1:n<l?-1:0})}}for(const t in g){const e=g[t];let n=interpolateBetween2DPointsForY(e.topleft,e.bottomleft,h);const l=vec2.fromValues(n,h);n=interpolateBetween2DPointsForY(e.topright,e.bottomright,h);const i=vec2.fromValues(n,h);n=interpolateBetween2DPointsForY(e.topleft,e.bottomleft,m);const r=vec2.fromValues(n,m);n=interpolateBetween2DPointsForY(e.topright,e.bottomright,m);const s=vec2.fromValues(n,m),f={topleft:l,topright:i,bottomleft:r,bottomright:s,leftline:line2.fromPoints(line2.create(),l,r),rightline:line2.fromPoints(line2.create(),s,i)};if(o.length>0){const t=o[o.length-1],e=vec2.distance(f.topleft,t.topright),n=vec2.distance(f.bottomleft,t.bottomright);e<EPS&&n<EPS&&(f.topleft=t.topleft,f.leftline=t.leftline,f.bottomleft=t.bottomleft,o.splice(o.length-1,1))}o.push(f)}if(t>0){const t={},i={};for(let e=0;e<o.length;e++){const n=o[e];for(let e=0;e<a.length;e++)if(!i[e]){const o=a[e];if(vec2.distance(o.bottomleft,n.topleft)<EPS&&vec2.distance(o.bottomright,n.topright)<EPS){i[e]=!0;const l=line2.direction(n.leftline),r=line2.direction(o.leftline),s=l[0]-r[0],f=line2.direction(n.rightline),p=line2.direction(o.rightline),h=f[0]-p[0],c=Math.abs(s)<EPS,g=Math.abs(h)<EPS,a=g||h>=0;(c||s>=0)&&a&&(n.outpolygon=o.outpolygon,n.leftlinecontinues=c,n.rightlinecontinues=g,t[e]=!0);break}}}for(let o=0;o<a.length;o++)if(!t[o]){const t=a[o];t.outpolygon.rightpoints.push(t.bottomright),vec2.distance(t.bottomright,t.bottomleft)>EPS&&t.outpolygon.leftpoints.push(t.bottomleft),t.outpolygon.leftpoints.reverse();const i=t.outpolygon.rightpoints.concat(t.outpolygon.leftpoints).map(t=>l.to3D(t)),r=poly3.fromPointsAndPlane(i,n);r.vertices.length&&e.push(r)}}for(let t=0;t<o.length;t++){const e=o[t];e.outpolygon?(e.leftlinecontinues||e.outpolygon.leftpoints.push(e.topleft),e.rightlinecontinues||e.outpolygon.rightpoints.push(e.topright)):(e.outpolygon={leftpoints:[],rightpoints:[]},e.outpolygon.leftpoints.push(e.topleft),vec2.distance(e.topleft,e.topright)>EPS&&e.outpolygon.rightpoints.push(e.topright))}a=o}return e};module.exports=reTesselateCoplanarPolygons;
+const{EPS:EPS}=require("../../maths/constants"),line2=require("../../maths/line2"),vec2=require("../../maths/vec2"),OrthoNormalBasis=require("../../maths/OrthoNormalBasis"),interpolateBetween2DPointsForY=require("../../maths/utils/interpolateBetween2DPointsForY"),{insertSorted:insertSorted,fnNumberSort:fnNumberSort}=require("../../utils"),poly3=require("../../geometries/poly3"),reTesselateCoplanarPolygons=t=>{if(t.length<2)return t;const e=[],o=t.length,n=poly3.plane(t[0]),l=new OrthoNormalBasis(n),i=[],r=[],s=new Map,f=new Map,p=new Map,h=10/EPS;for(let e=0;e<o;e++){const o=t[e];let n=[],g=o.vertices.length,c=-1;if(g>0){let t,i;for(let r=0;r<g;r++){let s=l.to2D(o.vertices[r]);const g=Math.floor(s[1]*h);let a;p.has(g)?a=p.get(g):p.has(g+1)?a=p.get(g+1):p.has(g-1)?a=p.get(g-1):(a=s[1],p.set(g,s[1])),s=vec2.fromValues(s[0],a),n.push(s);const u=s[1];(0===r||u<t)&&(t=u,c=r),(0===r||u>i)&&(i=u);let m=f.get(u);m||(m={},f.set(u,m)),m[e]=!0}if(t>=i)n=[],g=0,c=-1;else{let o=s.get(t);o||(o=[],s.set(t,o)),o.push(e)}}n.reverse(),c=g-c-1,i.push(n),r.push(c)}const g=[];f.forEach((t,e)=>g.push(e)),g.sort(fnNumberSort);let c=[],a=[];for(let t=0;t<g.length;t++){const o=[],p=g[t],h=f.get(p);for(let t=0;t<c.length;++t){const e=c[t],o=e.polygonindex;if(h[o]){const n=i[o],l=n.length;let r=e.leftvertexindex,s=e.rightvertexindex;for(;;){let t=r+1;if(t>=l&&(t=0),n[t][1]!==p)break;r=t}let f=s-1;if(f<0&&(f=l-1),n[f][1]===p&&(s=f),r!==e.leftvertexindex&&r===s)c.splice(t,1),--t;else{e.leftvertexindex=r,e.rightvertexindex=s,e.topleft=n[r],e.topright=n[s];let t=r+1;t>=l&&(t=0),e.bottomleft=n[t];let o=s-1;o<0&&(o=l-1),e.bottomright=n[o]}}}let u;if(t>=g.length-1)c=[],u=null;else{const e=.5*(p+(u=Number(g[t+1]))),o=s.get(p);for(const t in o){const n=o[t],l=i[n],s=l.length,f=r[n];let h=f;for(;;){let t=h+1;if(t>=s&&(t=0),l[t][1]!==p)break;if(t===f)break;h=t}let g=f;for(;;){let t=g-1;if(t<0&&(t=s-1),l[t][1]!==p)break;if(t===h)break;g=t}let a=h+1;a>=s&&(a=0);let u=g-1;u<0&&(u=s-1);const m={polygonindex:n,leftvertexindex:h,rightvertexindex:g,topleft:l[h],topright:l[g],bottomleft:l[a],bottomright:l[u]};insertSorted(c,m,(t,o)=>{const n=interpolateBetween2DPointsForY(t.topleft,t.bottomleft,e),l=interpolateBetween2DPointsForY(o.topleft,o.bottomleft,e);return n>l?1:n<l?-1:0})}}for(const t in c){const e=c[t];let n=interpolateBetween2DPointsForY(e.topleft,e.bottomleft,p);const l=vec2.fromValues(n,p);n=interpolateBetween2DPointsForY(e.topright,e.bottomright,p);const i=vec2.fromValues(n,p);n=interpolateBetween2DPointsForY(e.topleft,e.bottomleft,u);const r=vec2.fromValues(n,u);n=interpolateBetween2DPointsForY(e.topright,e.bottomright,u);const s=vec2.fromValues(n,u),f={topleft:l,topright:i,bottomleft:r,bottomright:s,leftline:line2.fromPoints(line2.create(),l,r),rightline:line2.fromPoints(line2.create(),s,i)};if(o.length>0){const t=o[o.length-1],e=vec2.distance(f.topleft,t.topright),n=vec2.distance(f.bottomleft,t.bottomright);e<EPS&&n<EPS&&(f.topleft=t.topleft,f.leftline=t.leftline,f.bottomleft=t.bottomleft,o.splice(o.length-1,1))}o.push(f)}if(t>0){const t=new Set,i=new Set;for(let e=0;e<o.length;e++){const n=o[e];for(let e=0;e<a.length;e++)if(!i.has(e)){const o=a[e];if(vec2.distance(o.bottomleft,n.topleft)<EPS&&vec2.distance(o.bottomright,n.topright)<EPS){i.add(e);const l=line2.direction(n.leftline),r=line2.direction(o.leftline),s=l[0]-r[0],f=line2.direction(n.rightline),p=line2.direction(o.rightline),h=f[0]-p[0],g=Math.abs(s)<EPS,c=Math.abs(h)<EPS,a=c||h>=0;(g||s>=0)&&a&&(n.outpolygon=o.outpolygon,n.leftlinecontinues=g,n.rightlinecontinues=c,t.add(e));break}}}for(let o=0;o<a.length;o++)if(!t.has(o)){const t=a[o];t.outpolygon.rightpoints.push(t.bottomright),vec2.distance(t.bottomright,t.bottomleft)>EPS&&t.outpolygon.leftpoints.push(t.bottomleft),t.outpolygon.leftpoints.reverse();const i=t.outpolygon.rightpoints.concat(t.outpolygon.leftpoints).map(t=>l.to3D(t)),r=poly3.fromPointsAndPlane(i,n);r.vertices.length&&e.push(r)}}for(let t=0;t<o.length;t++){const e=o[t];e.outpolygon?(e.leftlinecontinues||e.outpolygon.leftpoints.push(e.topleft),e.rightlinecontinues||e.outpolygon.rightpoints.push(e.topright)):(e.outpolygon={leftpoints:[],rightpoints:[]},e.outpolygon.leftpoints.push(e.topleft),vec2.distance(e.topleft,e.topright)>EPS&&e.outpolygon.rightpoints.push(e.topright))}a=o}return e};module.exports=reTesselateCoplanarPolygons;
 
 },{"../../geometries/poly3":75,"../../maths/OrthoNormalBasis":89,"../../maths/constants":90,"../../maths/line2":101,"../../maths/utils/interpolateBetween2DPointsForY":166,"../../maths/vec2":186,"../../utils":393}],349:[function(require,module,exports){
 const geom3=require("../../geometries/geom3"),poly3=require("../../geometries/poly3"),aboutEqualNormals=require("../../maths/utils/aboutEqualNormals"),reTesselateCoplanarPolygons=require("./reTesselateCoplanarPolygons"),coplanar=(e,o)=>Math.abs(e[3]-o[3])<1.5e-7&&aboutEqualNormals(e,o),retessellate=e=>{if(e.isRetesselated)return e;const o=geom3.toPolygons(e),s=[];o.forEach(e=>{const o=s.find(o=>coplanar(o[0],poly3.plane(e)));if(o){o[1].push(e)}else s.push([poly3.plane(e),[e]])});let a=[];s.forEach(e=>{const o=e[1],s=reTesselateCoplanarPolygons(o);a=a.concat(s)});const l=geom3.create(a);return l.isRetesselated=!0,l};module.exports=retessellate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.9.3",
+  "version": "2.9.4",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -61,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "85fa1fcdfb2d516a201ecf31da242e64b5b3274e"
+  "gitHead": "662965f40a1ce628aa97f30b814586e72a3acb36"
 }

package/src/geometries/geom3/applyTransforms.js

@@ -14,9 +14,8 @@ const applyTransforms = (geometry) => {
   if (mat4.isIdentity(geometry.transforms)) return geometry
 
   // apply transforms to each polygon
-  // const isMirror = mat4.isMirroring(geometry.transforms)
-  // TBD if (isMirror) newvertices.reverse()
   geometry.polygons = geometry.polygons.map((polygon) => poly3.transform(geometry.transforms, polygon))
+  // reset transforms
   geometry.transforms = mat4.create()
   return geometry
 }

package/src/maths/mat4/isMirroring.js

@@ -1,7 +1,3 @@
-const cross = require('../vec3/cross')
-const dot = require('../vec3/dot')
-const fromValues = require('../vec3/fromValues')
-
 /**
  * Determine whether the given matrix is a mirroring transformation.
  *
@@ -10,15 +6,19 @@ const fromValues = require('../vec3/fromValues')
  * @alias module:modeling/maths/mat4.isMirroring
  */
 const isMirroring = (matrix) => {
-  const u = fromValues(matrix[0], matrix[4], matrix[8])
-  const v = fromValues(matrix[1], matrix[5], matrix[9])
-  const w = fromValues(matrix[2], matrix[6], matrix[10])
+  // const xVector = [matrix[0], matrix[4], matrix[8]]
+  // const yVector = [matrix[1], matrix[5], matrix[9]]
+  // const zVector = [matrix[2], matrix[6], matrix[10]]
 
-  // for a true orthogonal, non-mirrored base, u.cross(v) == w
+  // for a true orthogonal, non-mirrored base, xVector.cross(yVector) == zVector
   // If they have an opposite direction then we are mirroring
-  const mirrorvalue = dot(cross(u, u, v), w)
-  const ismirror = (mirrorvalue < 0)
-  return ismirror
+  // calcuate xVector.cross(yVector)
+  const x = matrix[4] * matrix[9] - matrix[8] * matrix[5]
+  const y = matrix[8] * matrix[1] - matrix[0] * matrix[9]
+  const z = matrix[0] * matrix[5] - matrix[4] * matrix[1]
+  // calcualte dot(cross, zVector)
+  const d = x * matrix[2] + y * matrix[6] + z * matrix[10]
+  return (d < 0)
 }
 
 module.exports = isMirroring

package/src/operations/booleans/intersectGeom2.test.js

@@ -0,0 +1,69 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { intersect } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('intersect: intersect of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // intersect of one object
+  const result1 = intersect(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // intersect of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = intersect(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  t.notThrows(() => geom2.validate(result2))
+  t.is(obs.length, 0)
+
+  // intersect of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = intersect(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [9, 9], [8, 9], [8, 8], [9, 8]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.is(obs.length, 4)
+  t.true(comparePoints(obs, exp))
+
+  // intersect of two completely overlapping objects
+  const result4 = intersect(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+})

package/src/operations/booleans/{intersect.test.js → intersectGeom3.test.js}

@@ -1,83 +1,15 @@
 const test = require('ava')
 
-const { comparePolygonsAsPoints, comparePoints } = require('../../../test/helpers')
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
 
-const { geom2, geom3 } = require('../../geometries')
+const { geom3 } = require('../../geometries')
 
-const { circle, rectangle, sphere, cuboid } = require('../../primitives')
+const { sphere, cuboid } = require('../../primitives')
 
 const { intersect } = require('./index')
 
 const { center } = require('../transforms/center')
 
-//  test('intersect: intersect of a path produces expected changes to points', (t) => {
-//    let geometry = path.fromPoints({}, [[0, 1, 0], [1, 0, 0]])
-//
-//    geometry = intersect({normal: [1, 0, 0]}, geometry)
-//    let obs = path.toPoints(geometry)
-//    let exp = []
-//
-//    t.deepEqual(obs, exp)
-//  })
-
-test('intersect: intersect of one or more geom2 objects produces expected geometry', (t) => {
-  const geometry1 = circle({ radius: 2, segments: 8 })
-
-  // intersect of one object
-  const result1 = intersect(geometry1)
-  let obs = geom2.toPoints(result1)
-  let exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result1))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // intersect of two non-overlapping objects
-  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
-
-  const result2 = intersect(geometry1, geometry2)
-  obs = geom2.toPoints(result2)
-  t.notThrows(() => geom2.validate(result2))
-  t.is(obs.length, 0)
-
-  // intersect of two partially overlapping objects
-  const geometry3 = rectangle({ size: [18, 18] })
-
-  const result3 = intersect(geometry2, geometry3)
-  obs = geom2.toPoints(result3)
-  exp = [
-    [9, 9], [8, 9], [8, 8], [9, 8]
-  ]
-  t.notThrows(() => geom2.validate(result3))
-  t.is(obs.length, 4)
-  t.true(comparePoints(obs, exp))
-
-  // intersect of two completely overlapping objects
-  const result4 = intersect(geometry1, geometry3)
-  obs = geom2.toPoints(result4)
-  exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result4))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-})
-
 test('intersect: intersect of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
 

package/src/operations/booleans/subtractGeom2.test.js

@@ -0,0 +1,72 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { subtract } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('subtract: subtract of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // subtract of one object
+  const result1 = subtract(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = subtract(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result2))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = subtract(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [12, 12], [9, 9], [8, 9], [8, 12], [9, 8], [12, 8]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.is(obs.length, 6)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two completely overlapping objects
+  const result4 = subtract(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.is(obs.length, 0)
+  t.deepEqual(obs, exp)
+})

package/src/operations/booleans/{subtract.test.js → subtractGeom3.test.js}

@@ -1,86 +1,15 @@
 const test = require('ava')
 
-const { comparePolygonsAsPoints, comparePoints } = require('../../../test/helpers')
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
 
-const { geom2, geom3 } = require('../../geometries')
+const { geom3 } = require('../../geometries')
 
-const { circle, rectangle, sphere, cuboid } = require('../../primitives')
+const { sphere, cuboid } = require('../../primitives')
 
 const { subtract } = require('./index')
 
 const { center } = require('../transforms/center')
 
-// test('subtract: subtract of a path produces expected changes to points', (t) => {
-//   let geometry = path.fromPoints({}, [[0, 1, 0], [1, 0, 0]])
-//
-//   geometry = subtract({normal: [1, 0, 0]}, geometry)
-//   let obs = path.toPoints(geometry)
-//   let exp = []
-//
-//   t.deepEqual(obs, exp)
-// })
-
-test('subtract: subtract of one or more geom2 objects produces expected geometry', (t) => {
-  const geometry1 = circle({ radius: 2, segments: 8 })
-
-  // subtract of one object
-  const result1 = subtract(geometry1)
-  let obs = geom2.toPoints(result1)
-  let exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result1))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // subtract of two non-overlapping objects
-  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
-
-  const result2 = subtract(geometry1, geometry2)
-  obs = geom2.toPoints(result2)
-  exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result2))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // subtract of two partially overlapping objects
-  const geometry3 = rectangle({ size: [18, 18] })
-
-  const result3 = subtract(geometry2, geometry3)
-  obs = geom2.toPoints(result3)
-  exp = [
-    [12, 12], [9, 9], [8, 9], [8, 12], [9, 8], [12, 8]
-  ]
-  t.notThrows(() => geom2.validate(result3))
-  t.is(obs.length, 6)
-  t.true(comparePoints(obs, exp))
-
-  // subtract of two completely overlapping objects
-  const result4 = subtract(geometry1, geometry3)
-  obs = geom2.toPoints(result4)
-  exp = [
-  ]
-  t.notThrows(() => geom2.validate(result4))
-  t.is(obs.length, 0)
-  t.deepEqual(obs, exp)
-})
-
 test('subtract: subtract of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
 

package/src/operations/booleans/unionGeom2.test.js

@@ -0,0 +1,166 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { union } = require('./index')
+
+const { center } = require('../transforms/center')
+const { translate } = require('../transforms/translate')
+
+test('union of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // union of one object
+  const result1 = union(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.true(comparePoints(obs, exp))
+
+  // union of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = union(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [8, 12],
+    [8, 8],
+    [12, 8],
+    [12, 12],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result2))
+  t.true(comparePoints(obs, exp))
+
+  // union of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = union(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [11.999973333333333, 11.999973333333333],
+    [7.999933333333333, 11.999973333333333],
+    [9.000053333333334, 7.999933333333333],
+    [-9.000053333333334, 9.000053333333334],
+    [-9.000053333333334, -9.000053333333334],
+    [9.000053333333334, -9.000053333333334],
+    [7.999933333333333, 9.000053333333334],
+    [11.999973333333333, 7.999933333333333]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.true(comparePoints(obs, exp))
+
+  // union of two completely overlapping objects
+  const result4 = union(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+    [-9.000046666666666, -9.000046666666666],
+    [9.000046666666666, -9.000046666666666],
+    [9.000046666666666, 9.000046666666666],
+    [-9.000046666666666, 9.000046666666666]
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.true(comparePoints(obs, exp))
+
+  // union of unions of non-overlapping objects (BSP gap from #907)
+  const circ = circle({ radius: 1, segments: 32 })
+  const result5 = union(
+    union(
+      translate([17, 21], circ),
+      translate([7, 0], circ)
+    ),
+    union(
+      translate([3, 21], circ),
+      translate([17, 21], circ)
+    )
+  )
+  obs = geom2.toPoints(result5)
+  t.notThrows.skip(() => geom2.validate(result5))
+  t.is(obs.length, 112)
+})
+
+test('union of geom2 with closing issues #15', (t) => {
+  const c = geom2.create([
+    [[-45.82118740347841168159, -16.85726810555620147625], [-49.30331715865012398581, -14.68093629710870118288]],
+    [[-49.10586702080816223770, -15.27604177352110781385], [-48.16645938811709015681, -15.86317173589183227023]],
+    [[-49.60419521731581937729, -14.89550781504266296906], [-49.42407001323204696064, -15.67605088949303393520]],
+    [[-49.05727291218684626983, -15.48661638542171203881], [-49.10586702080816223770, -15.27604177352110781385]],
+    [[-49.30706235399220815907, -15.81529674600091794900], [-46.00505780290426827150, -17.21108547999804727624]],
+    [[-46.00505780290426827150, -17.21108547999804727624], [-45.85939703723252591772, -17.21502856394236857795]],
+    [[-45.85939703723252591772, -17.21502856394236857795], [-45.74972032664388166268, -17.11909303495791334626]],
+    [[-45.74972032664388166268, -17.11909303495791334626], [-45.73424573227583067592, -16.97420292661295349035]],
+    [[-45.73424573227583067592, -16.97420292661295349035], [-45.82118740347841168159, -16.85726810555620147625]],
+    [[-49.30331715865012398581, -14.68093629710870118288], [-49.45428884427643367871, -14.65565769658912387285]],
+    [[-49.45428884427643367871, -14.65565769658912387285], [-49.57891661679624917269, -14.74453612941635327616]],
+    [[-49.57891661679624917269, -14.74453612941635327616], [-49.60419521731581937729, -14.89550781504266296906]],
+    [[-49.42407001323204696064, -15.67605088949303393520], [-49.30706235399220815907, -15.81529674600091794900]],
+    [[-48.16645938811709015681, -15.86317173589183227023], [-49.05727291218684626983, -15.48661638542171203881]]
+  ])
+  const d = geom2.create([
+    [[-49.03431352173912216585, -15.58610714407888764299], [-49.21443872582289458251, -14.80556406962851667686]],
+    [[-68.31614651314507113966, -3.10790373951434872879], [-49.34036769611472550423, -15.79733157434056778357]],
+    [[-49.58572929483430868913, -14.97552686612213790340], [-49.53755741140093959984, -15.18427183431472826669]],
+    [[-49.53755741140093959984, -15.18427183431472826669], [-54.61235529924312714911, -11.79066769321313756791]],
+    [[-49.30227466841120076424, -14.68159232649114187552], [-68.09792828135776687759, -2.77270756611528668145]],
+    [[-49.21443872582289458251, -14.80556406962851667686], [-49.30227466841120076424, -14.68159232649114187552]],
+    [[-49.34036769611472550423, -15.79733157434056778357], [-49.18823337756091262918, -15.82684012194931710837]],
+    [[-49.18823337756091262918, -15.82684012194931710837], [-49.06069007212390431505, -15.73881563386780157998]],
+    [[-49.06069007212390431505, -15.73881563386780157998], [-49.03431352173912216585, -15.58610714407888764299]],
+    [[-68.09792828135776687759, -2.77270756611528668145], [-68.24753735887460948106, -2.74623350179570024920]],
+    [[-68.24753735887460948106, -2.74623350179570024920], [-68.37258141465594007968, -2.83253376987636329432]],
+    [[-68.37258141465594007968, -2.83253376987636329432], [-68.40089829889257089235, -2.98180502037078554167]],
+    [[-68.40089829889257089235, -2.98180502037078554167], [-68.31614651314507113966, -3.10790373951434872879]],
+    [[-54.61235529924312714911, -11.79066769321313756791], [-49.58572929483430868913, -14.97552686612213790340]]
+  ])
+  // geom2.toOutlines(c)
+  // geom2.toOutlines(d)
+
+  const obs = union(c, d)
+  // const outlines = geom2.toOutlines(obs)
+  const pts = geom2.toPoints(obs)
+  const exp = [
+    [-49.10585516965137, -15.276000175919414],
+    [-49.0573272145917, -15.486679335654257],
+    [-49.307011370463215, -15.815286644243773],
+    [-46.00502320253235, -17.211117609669667],
+    [-45.85943933735334, -17.215031154432545],
+    [-45.74972963250071, -17.119149307742074],
+    [-45.734205904941305, -16.974217700023555],
+    [-48.166473975068946, -15.86316234184296],
+    [-49.318621553259746, -15.801589237573706],
+    [-49.585786209072104, -14.975570389622606],
+    [-68.31614189569036, -3.1078763476921982],
+    [-49.53751915699663, -15.184292776976012],
+    [-68.09789654941396, -2.7727464644978874],
+    [-68.24752441084793, -2.7462648116024244],
+    [-68.37262739176788, -2.8324932478777995],
+    [-68.40093536555268, -2.98186020632758],
+    [-54.61234310251047, -11.79072766159384],
+    [-49.30335872868453, -14.680880468978017],
+    [-49.34040695243976, -15.797284338334542],
+    [-45.82121705016925, -16.857333163105647]
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 20) // number of sides in union
+  t.true(comparePoints(pts, exp))
+})

package/src/operations/booleans/{union.test.js → unionGeom3.test.js}

@@ -1,113 +1,14 @@
 const test = require('ava')
 
-const { comparePolygonsAsPoints, comparePoints } = require('../../../test/helpers')
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
 
-const { geom2, geom3 } = require('../../geometries')
+const { geom3 } = require('../../geometries')
 
-const { circle, rectangle, sphere, cuboid } = require('../../primitives')
+const { sphere, cuboid } = require('../../primitives')
 
 const { union } = require('./index')
 
 const { center } = require('../transforms/center')
-const { translate } = require('../transforms/translate')
-
-// test('union: union of a path produces expected changes to points', (t) => {
-//   let geometry = path.fromPoints({}, [[0, 1, 0], [1, 0, 0]])
-//
-//   geometry = union({normal: [1, 0, 0]}, geometry)
-//   let obs = path.toPoints(geometry)
-//   let exp = []
-//
-//   t.deepEqual(obs, exp)
-// })
-
-test('union of one or more geom2 objects produces expected geometry', (t) => {
-  const geometry1 = circle({ radius: 2, segments: 8 })
-
-  // union of one object
-  const result1 = union(geometry1)
-  let obs = geom2.toPoints(result1)
-  let exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result1))
-  t.true(comparePoints(obs, exp))
-
-  // union of two non-overlapping objects
-  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
-
-  const result2 = union(geometry1, geometry2)
-  obs = geom2.toPoints(result2)
-  exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [8, 12],
-    [8, 8],
-    [12, 8],
-    [12, 12],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result2))
-  t.true(comparePoints(obs, exp))
-
-  // union of two partially overlapping objects
-  const geometry3 = rectangle({ size: [18, 18] })
-
-  const result3 = union(geometry2, geometry3)
-  obs = geom2.toPoints(result3)
-  exp = [
-    [11.999973333333333, 11.999973333333333],
-    [7.999933333333333, 11.999973333333333],
-    [9.000053333333334, 7.999933333333333],
-    [-9.000053333333334, 9.000053333333334],
-    [-9.000053333333334, -9.000053333333334],
-    [9.000053333333334, -9.000053333333334],
-    [7.999933333333333, 9.000053333333334],
-    [11.999973333333333, 7.999933333333333]
-  ]
-  t.notThrows(() => geom2.validate(result3))
-  t.true(comparePoints(obs, exp))
-
-  // union of two completely overlapping objects
-  const result4 = union(geometry1, geometry3)
-  obs = geom2.toPoints(result4)
-  exp = [
-    [-9.000046666666666, -9.000046666666666],
-    [9.000046666666666, -9.000046666666666],
-    [9.000046666666666, 9.000046666666666],
-    [-9.000046666666666, 9.000046666666666]
-  ]
-  t.notThrows(() => geom2.validate(result4))
-  t.true(comparePoints(obs, exp))
-
-  // union of unions of non-overlapping objects (BSP gap from #907)
-  const circ = circle({ radius: 1, segments: 32 })
-  const result5 = union(
-    union(
-      translate([17, 21], circ),
-      translate([7, 0], circ),
-    ),
-    union(
-      translate([3, 21], circ),
-      translate([17, 21], circ),
-    )
-  )
-  obs = geom2.toPoints(result5)
-  t.notThrows.skip(() => geom2.validate(result5))
-  t.is(obs.length, 112)
-})
 
 test('union of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
@@ -230,69 +131,3 @@ test('union of geom3 with rounding issues #137', (t) => {
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6) // number of polygons in union
 })
-
-test('union of geom2 with closing issues #15', (t) => {
-  const c = geom2.create([
-    [[-45.82118740347841168159, -16.85726810555620147625], [-49.30331715865012398581, -14.68093629710870118288]],
-    [[-49.10586702080816223770, -15.27604177352110781385], [-48.16645938811709015681, -15.86317173589183227023]],
-    [[-49.60419521731581937729, -14.89550781504266296906], [-49.42407001323204696064, -15.67605088949303393520]],
-    [[-49.05727291218684626983, -15.48661638542171203881], [-49.10586702080816223770, -15.27604177352110781385]],
-    [[-49.30706235399220815907, -15.81529674600091794900], [-46.00505780290426827150, -17.21108547999804727624]],
-    [[-46.00505780290426827150, -17.21108547999804727624], [-45.85939703723252591772, -17.21502856394236857795]],
-    [[-45.85939703723252591772, -17.21502856394236857795], [-45.74972032664388166268, -17.11909303495791334626]],
-    [[-45.74972032664388166268, -17.11909303495791334626], [-45.73424573227583067592, -16.97420292661295349035]],
-    [[-45.73424573227583067592, -16.97420292661295349035], [-45.82118740347841168159, -16.85726810555620147625]],
-    [[-49.30331715865012398581, -14.68093629710870118288], [-49.45428884427643367871, -14.65565769658912387285]],
-    [[-49.45428884427643367871, -14.65565769658912387285], [-49.57891661679624917269, -14.74453612941635327616]],
-    [[-49.57891661679624917269, -14.74453612941635327616], [-49.60419521731581937729, -14.89550781504266296906]],
-    [[-49.42407001323204696064, -15.67605088949303393520], [-49.30706235399220815907, -15.81529674600091794900]],
-    [[-48.16645938811709015681, -15.86317173589183227023], [-49.05727291218684626983, -15.48661638542171203881]]
-  ])
-  const d = geom2.create([
-    [[-49.03431352173912216585, -15.58610714407888764299], [-49.21443872582289458251, -14.80556406962851667686]],
-    [[-68.31614651314507113966, -3.10790373951434872879], [-49.34036769611472550423, -15.79733157434056778357]],
-    [[-49.58572929483430868913, -14.97552686612213790340], [-49.53755741140093959984, -15.18427183431472826669]],
-    [[-49.53755741140093959984, -15.18427183431472826669], [-54.61235529924312714911, -11.79066769321313756791]],
-    [[-49.30227466841120076424, -14.68159232649114187552], [-68.09792828135776687759, -2.77270756611528668145]],
-    [[-49.21443872582289458251, -14.80556406962851667686], [-49.30227466841120076424, -14.68159232649114187552]],
-    [[-49.34036769611472550423, -15.79733157434056778357], [-49.18823337756091262918, -15.82684012194931710837]],
-    [[-49.18823337756091262918, -15.82684012194931710837], [-49.06069007212390431505, -15.73881563386780157998]],
-    [[-49.06069007212390431505, -15.73881563386780157998], [-49.03431352173912216585, -15.58610714407888764299]],
-    [[-68.09792828135776687759, -2.77270756611528668145], [-68.24753735887460948106, -2.74623350179570024920]],
-    [[-68.24753735887460948106, -2.74623350179570024920], [-68.37258141465594007968, -2.83253376987636329432]],
-    [[-68.37258141465594007968, -2.83253376987636329432], [-68.40089829889257089235, -2.98180502037078554167]],
-    [[-68.40089829889257089235, -2.98180502037078554167], [-68.31614651314507113966, -3.10790373951434872879]],
-    [[-54.61235529924312714911, -11.79066769321313756791], [-49.58572929483430868913, -14.97552686612213790340]]
-  ])
-  // geom2.toOutlines(c)
-  // geom2.toOutlines(d)
-
-  const obs = union(c, d)
-  // const outlines = geom2.toOutlines(obs)
-  const pts = geom2.toPoints(obs)
-  const exp = [
-    [-49.10585516965137, -15.276000175919414],
-    [-49.0573272145917, -15.486679335654257],
-    [-49.307011370463215, -15.815286644243773],
-    [-46.00502320253235, -17.211117609669667],
-    [-45.85943933735334, -17.215031154432545],
-    [-45.74972963250071, -17.119149307742074],
-    [-45.734205904941305, -16.974217700023555],
-    [-48.166473975068946, -15.86316234184296],
-    [-49.318621553259746, -15.801589237573706],
-    [-49.585786209072104, -14.975570389622606],
-    [-68.31614189569036, -3.1078763476921982],
-    [-49.53751915699663, -15.184292776976012],
-    [-68.09789654941396, -2.7727464644978874],
-    [-68.24752441084793, -2.7462648116024244],
-    [-68.37262739176788, -2.8324932478777995],
-    [-68.40093536555268, -2.98186020632758],
-    [-54.61234310251047, -11.79072766159384],
-    [-49.30335872868453, -14.680880468978017],
-    [-49.34040695243976, -15.797284338334542],
-    [-45.82121705016925, -16.857333163105647]
-  ]
-  t.notThrows(() => geom2.validate(obs))
-  t.is(pts.length, 20) // number of sides in union
-  t.true(comparePoints(pts, exp))
-})

package/src/operations/extrusions/extrudeFromSlices.js

@@ -5,7 +5,7 @@ const geom3 = require('../../geometries/geom3')
 const poly3 = require('../../geometries/poly3')
 
 const slice = require('./slice')
-const repairSlice = require('./slice/repairSlice')
+const repairSlice = require('./slice/repair')
 
 const extrudeWalls = require('./extrudeWalls')
 
@@ -59,7 +59,8 @@ const extrudeFromSlices = (options, base) => {
 
   // Repair gaps in the base slice
   if (repair) {
-    repairSlice(base)
+    // note: base must be a slice, if base is geom2 this doesn't repair
+    base = repairSlice(base)
   }
 
   const sMax = numberOfSlices - 1

package/src/operations/extrusions/slice/repair.js

@@ -0,0 +1,62 @@
+const vec3 = require('../../../maths/vec3')
+const create = require('./create')
+
+/*
+ * Mend gaps in a 2D slice to make it a closed polygon
+ */
+const repair = (slice) => {
+  if (!slice.edges) return slice
+  let edges = slice.edges
+  const vertexMap = new Map() // string key to vertex map
+  const edgeCount = new Map() // count of (in - out) edges
+
+  // Remove self-edges
+  edges = edges.filter((e) => !vec3.equals(e[0], e[1]))
+
+  // build vertex and edge count maps
+  edges.forEach((edge) => {
+    const inKey = edge[0].toString()
+    const outKey = edge[1].toString()
+    vertexMap.set(inKey, edge[0])
+    vertexMap.set(outKey, edge[1])
+    edgeCount.set(inKey, (edgeCount.get(inKey) || 0) + 1) // in
+    edgeCount.set(outKey, (edgeCount.get(outKey) || 0) - 1) // out
+  })
+
+  // find vertices which are missing in or out edges
+  const missingIn = []
+  const missingOut = []
+  edgeCount.forEach((count, vertex) => {
+    if (count < 0) missingIn.push(vertex)
+    if (count > 0) missingOut.push(vertex)
+  })
+
+  // pairwise distance of bad vertices
+  missingIn.forEach((key1) => {
+    const v1 = vertexMap.get(key1)
+
+    // find the closest vertex that is missing an out edge
+    let bestDistance = Infinity
+    let bestReplacement
+    missingOut.forEach((key2) => {
+      const v2 = vertexMap.get(key2)
+      const distance = Math.hypot(v1[0] - v2[0], v1[1] - v2[1])
+      if (distance < bestDistance) {
+        bestDistance = distance
+        bestReplacement = v2
+      }
+    })
+    console.warn(`slice.repair: repairing vertex gap ${v1} to ${bestReplacement} distance ${bestDistance}`)
+
+    // merge broken vertices
+    edges = edges.map((edge) => {
+      if (edge[0].toString() === key1) return [bestReplacement, edge[1]]
+      if (edge[1].toString() === key1) return [edge[0], bestReplacement]
+      return edge
+    })
+  })
+
+  return create(edges)
+}
+
+module.exports = repair

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -23,14 +23,13 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
   const orthobasis = new OrthoNormalBasis(plane)
   const polygonvertices2d = [] // array of array of Vector2D
   const polygontopvertexindexes = [] // array of indexes of topmost vertex per polygon
-  const topy2polygonindexes = {}
-  const ycoordinatetopolygonindexes = {}
-
-  const ycoordinatebins = {}
+  const topy2polygonindexes = new Map()
+  const ycoordinatetopolygonindexes = new Map()
 
   // convert all polygon vertices to 2D
   // Make a list of all encountered y coordinates
   // And build a map of all polygons that have a vertex at a certain y coordinate:
+  const ycoordinatebins = new Map()
   const ycoordinateBinningFactor = 10 / EPS
   for (let polygonindex = 0; polygonindex < numpolygons; polygonindex++) {
     const poly3d = sourcepolygons[polygonindex]
@@ -46,15 +45,15 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         // close to each other, give them the same y coordinate:
         const ycoordinatebin = Math.floor(pos2d[1] * ycoordinateBinningFactor)
         let newy
-        if (ycoordinatebin in ycoordinatebins) {
-          newy = ycoordinatebins[ycoordinatebin]
-        } else if (ycoordinatebin + 1 in ycoordinatebins) {
-          newy = ycoordinatebins[ycoordinatebin + 1]
-        } else if (ycoordinatebin - 1 in ycoordinatebins) {
-          newy = ycoordinatebins[ycoordinatebin - 1]
+        if (ycoordinatebins.has(ycoordinatebin)) {
+          newy = ycoordinatebins.get(ycoordinatebin)
+        } else if (ycoordinatebins.has(ycoordinatebin + 1)) {
+          newy = ycoordinatebins.get(ycoordinatebin + 1)
+        } else if (ycoordinatebins.has(ycoordinatebin - 1)) {
+          newy = ycoordinatebins.get(ycoordinatebin - 1)
         } else {
           newy = pos2d[1]
-          ycoordinatebins[ycoordinatebin] = pos2d[1]
+          ycoordinatebins.set(ycoordinatebin, pos2d[1])
         }
         pos2d = vec2.fromValues(pos2d[0], newy)
         vertices2d.push(pos2d)
@@ -66,10 +65,12 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         if ((i === 0) || (y > maxy)) {
           maxy = y
         }
-        if (!(y in ycoordinatetopolygonindexes)) {
-          ycoordinatetopolygonindexes[y] = {}
+        let polygonindexes = ycoordinatetopolygonindexes.get(y)
+        if (!polygonindexes) {
+          polygonindexes = {} // PERF
+          ycoordinatetopolygonindexes.set(y, polygonindexes)
         }
-        ycoordinatetopolygonindexes[y][polygonindex] = true
+        polygonindexes[polygonindex] = true
       }
       if (miny >= maxy) {
         // degenerate polygon, all vertices have same y coordinate. Just ignore it from now:
@@ -77,10 +78,12 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         numvertices = 0
         minindex = -1
       } else {
-        if (!(miny in topy2polygonindexes)) {
-          topy2polygonindexes[miny] = []
+        let polygonindexes = topy2polygonindexes.get(miny)
+        if (!polygonindexes) {
+          polygonindexes = []
+          topy2polygonindexes.set(miny, polygonindexes)
         }
-        topy2polygonindexes[miny].push(polygonindex)
+        polygonindexes.push(polygonindex)
       }
     } // if(numvertices > 0)
     // reverse the vertex order:
@@ -89,8 +92,9 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
     polygonvertices2d.push(vertices2d)
     polygontopvertexindexes.push(minindex)
   }
+
   const ycoordinates = []
-  for (const ycoordinate in ycoordinatetopolygonindexes) ycoordinates.push(ycoordinate)
+  ycoordinatetopolygonindexes.forEach((polylist, y) => ycoordinates.push(y))
   ycoordinates.sort(fnNumberSort)
 
   // Now we will iterate over all y coordinates, from lowest to highest y coordinate
@@ -108,15 +112,14 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
   let prevoutpolygonrow = []
   for (let yindex = 0; yindex < ycoordinates.length; yindex++) {
     const newoutpolygonrow = []
-    const ycoordinateasstring = ycoordinates[yindex]
-    const ycoordinate = Number(ycoordinateasstring)
+    const ycoordinate = ycoordinates[yindex]
 
     // update activepolygons for this y coordinate:
     // - Remove any polygons that end at this y coordinate
     // - update leftvertexindex and rightvertexindex (which point to the current vertex index
     //   at the the left and right side of the polygon
     // Iterate over all polygons that have a corner at this y coordinate:
-    const polygonindexeswithcorner = ycoordinatetopolygonindexes[ycoordinateasstring]
+    const polygonindexeswithcorner = ycoordinatetopolygonindexes.get(ycoordinate)
     for (let activepolygonindex = 0; activepolygonindex < activepolygons.length; ++activepolygonindex) {
       const activepolygon = activepolygons[activepolygonindex]
       const polygonindex = activepolygon.polygonindex
@@ -166,7 +169,7 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
       nextycoordinate = Number(ycoordinates[yindex + 1])
       const middleycoordinate = 0.5 * (ycoordinate + nextycoordinate)
       // update activepolygons by adding any polygons that start here:
-      const startingpolygonindexes = topy2polygonindexes[ycoordinateasstring]
+      const startingpolygonindexes = topy2polygonindexes.get(ycoordinate)
       for (const polygonindexKey in startingpolygonindexes) {
         const polygonindex = startingpolygonindexes[polygonindexKey]
         const vertices2d = polygonvertices2d[polygonindex]
@@ -212,8 +215,6 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         })
       } // for(let polygonindex in startingpolygonindexes)
     } //  yindex < ycoordinates.length-1
-    // if( (yindex === ycoordinates.length-1) || (nextycoordinate - ycoordinate > EPS) )
-    // FIXME : what ???
 
     // Now activepolygons is up to date
     // Build the output polygons for the next row in newoutpolygonrow:
@@ -252,19 +253,19 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
     } // for(activepolygon in activepolygons)
     if (yindex > 0) {
       // try to match the new polygons against the previous row:
-      const prevcontinuedindexes = {}
-      const matchedindexes = {}
+      const prevcontinuedindexes = new Set()
+      const matchedindexes = new Set()
       for (let i = 0; i < newoutpolygonrow.length; i++) {
         const thispolygon = newoutpolygonrow[i]
         for (let ii = 0; ii < prevoutpolygonrow.length; ii++) {
-          if (!matchedindexes[ii]) { // not already processed?
+          if (!matchedindexes.has(ii)) { // not already processed?
             // We have a match if the sidelines are equal or if the top coordinates
             // are on the sidelines of the previous polygon
             const prevpolygon = prevoutpolygonrow[ii]
             if (vec2.distance(prevpolygon.bottomleft, thispolygon.topleft) < EPS) {
               if (vec2.distance(prevpolygon.bottomright, thispolygon.topright) < EPS) {
                 // Yes, the top of this polygon matches the bottom of the previous:
-                matchedindexes[ii] = true
+                matchedindexes.add(ii)
                 // Now check if the joined polygon would remain convex:
                 const v1 = line2.direction(thispolygon.leftline)
                 const v2 = line2.direction(prevpolygon.leftline)
@@ -284,16 +285,16 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
                   thispolygon.outpolygon = prevpolygon.outpolygon
                   thispolygon.leftlinecontinues = leftlinecontinues
                   thispolygon.rightlinecontinues = rightlinecontinues
-                  prevcontinuedindexes[ii] = true
+                  prevcontinuedindexes.add(ii)
                 }
                 break
               }
             }
-          } // if(!prevcontinuedindexes[ii])
+          } // if(!prevcontinuedindexes.has(ii))
         } // for ii
       } // for i
       for (let ii = 0; ii < prevoutpolygonrow.length; ii++) {
-        if (!prevcontinuedindexes[ii]) {
+        if (!prevcontinuedindexes.has(ii)) {
           // polygon ends here
           // Finish the polygon with the last point(s):
           const prevpolygon = prevoutpolygonrow[ii]

package/src/operations/extrusions/slice/repairSlice.js

@@ -1,47 +0,0 @@
-const vec3 = require('../../../maths/vec3')
-
-/*
- * Mend gaps in a 2D slice to make it a closed polygon
- */
-const repairSlice = (slice) => {
-  if (!slice.edges) return slice
-  const vertexMap = {} // string key to vertex map
-  const edgeCount = {} // count of (in - out) edges
-  slice.edges.forEach((edge) => {
-    const inKey = edge[0].toString()
-    const outKey = edge[1].toString()
-    vertexMap[inKey] = edge[0]
-    vertexMap[outKey] = edge[1]
-    edgeCount[inKey] = (edgeCount[inKey] || 0) + 1 // in
-    edgeCount[outKey] = (edgeCount[outKey] || 0) - 1 // out
-  })
-  // find vertices which are missing in or out edges
-  const missingIn = Object.keys(edgeCount).filter((e) => edgeCount[e] < 0)
-  const missingOut = Object.keys(edgeCount).filter((e) => edgeCount[e] > 0)
-  // pairwise distance of bad vertices
-  missingIn.forEach((key1) => {
-    const v1 = vertexMap[key1]
-    // find the closest vertex that is missing an out edge
-    let bestDistance = Infinity
-    let bestReplacement
-    missingOut.forEach((key2) => {
-      const v2 = vertexMap[key2]
-      const distance = Math.hypot(v1[0] - v2[0], v1[1] - v2[1])
-      if (distance < bestDistance) {
-        bestDistance = distance
-        bestReplacement = v2
-      }
-    })
-    console.warn(`repairSlice: repairing vertex gap ${v1} to ${bestReplacement} distance ${bestDistance}`)
-    // merge broken vertices
-    slice.edges.forEach((edge) => {
-      if (edge[0].toString() === key1) edge[0] = bestReplacement
-      if (edge[1].toString() === key1) edge[1] = bestReplacement
-    })
-  })
-  // Remove self-edges
-  slice.edges = slice.edges.filter((e) => !vec3.equals(e[0], e[1]))
-  return slice
-}
-
-module.exports = repairSlice