Backup_Repos/jsketcher
1
0
Fork 0
mirror of https://github.com/xibyte/jsketcher synced 2025-12-07 08:53:25 +01:00
Code Issues Projects Releases Wiki Activity

no-var rule for javascript / autofix

Browse source
This commit is contained in:
Val Erastov 2022-08-15 19:15:56 -07:00
parent ffc1312da7
commit c2332870ce
23 changed files with 544 additions and 543 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.eslintrc.json
View file

@ -61,7 +61,8 @@
"no-unused-vars": "off",
"max-len": "off",
"no-console": "off",
"no-extra-boolean-cast": "off"
"no-extra-boolean-cast": "off",
"no-var": "error"
},
"ignorePatterns": [
"/modules/math/optim/*.js",

32
modules/scene/controls/CADTrackballControls.js
View file

@ -12,8 +12,8 @@
export function CADTrackballControls( object, domElement ) {
var _this = this;
var STATE = { NONE: - 1, ROTATE: 0, ZOOM: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_ZOOM_PAN: 4 };
let _this = this;
let STATE = { NONE: - 1, ROTATE: 0, ZOOM: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_ZOOM_PAN: 4 };
this.object = object;
this.domElement = ( domElement !== undefined ) ? domElement : document;
@ -47,11 +47,11 @@ export function CADTrackballControls( object, domElement ) {
this.projectionChanged = false;
this.projectionZoomSpeed = 0.5;
var EPS = 0.000001;
let EPS = 0.000001;
var lastPosition = new THREE.Vector3();
let lastPosition = new THREE.Vector3();
var _state = STATE.NONE,
let _state = STATE.NONE,
_prevState = STATE.NONE,
_eye = new THREE.Vector3(),
@ -79,8 +79,8 @@ export function CADTrackballControls( object, domElement ) {
// events
var startEvent = { type: 'start' };
var endEvent = { type: 'end' };
let startEvent = { type: 'start' };
let endEvent = { type: 'end' };
// methods
@ -96,9 +96,9 @@ export function CADTrackballControls( object, domElement ) {
} else {
var box = this.domElement.getBoundingClientRect();
let box = this.domElement.getBoundingClientRect();
// adjustments come from similar code in the jquery offset() function
var d = this.domElement.ownerDocument.documentElement;
let d = this.domElement.ownerDocument.documentElement;
this.screen.left = box.left + window.pageXOffset - d.clientLeft;
this.screen.top = box.top + window.pageYOffset - d.clientTop;
this.screen.width = box.width;
@ -118,9 +118,9 @@ export function CADTrackballControls( object, domElement ) {
};
var getMouseOnScreen = ( function () {
let getMouseOnScreen = ( function () {
var vector = new THREE.Vector2();
let vector = new THREE.Vector2();
return function getMouseOnScreen( pageX, pageY ) {
@ -135,9 +135,9 @@ export function CADTrackballControls( object, domElement ) {
}() );
var getMouseOnCircle = ( function () {
let getMouseOnCircle = ( function () {
var vector = new THREE.Vector2();
let vector = new THREE.Vector2();
return function getMouseOnCircle( pageX, pageY ) {
@ -154,7 +154,7 @@ export function CADTrackballControls( object, domElement ) {
this.rotateCamera = ( function() {
var axis = new THREE.Vector3(),
let axis = new THREE.Vector3(),
quaternion = new THREE.Quaternion(),
eyeDirection = new THREE.Vector3(),
objectUpDirection = new THREE.Vector3(),
@ -215,7 +215,7 @@ export function CADTrackballControls( object, domElement ) {
this.zoomCamera = function () {
var factor;
let factor;
if ( _state === STATE.TOUCH_ZOOM_PAN ) {
@ -249,7 +249,7 @@ export function CADTrackballControls( object, domElement ) {
this.panCamera = ( function() {
var mouseChange = new THREE.Vector2(),
let mouseChange = new THREE.Vector2(),
objectUp = new THREE.Vector3(),
pan = new THREE.Vector3();

122
web/app/cad/cad-utils.js
View file

@ -41,7 +41,7 @@ export function createPoint0(x, y, z) {
// var m = new THREE.MeshBasicMaterial({color: 0x0000ff, side: THREE.DoubleSide});
// return new THREE.Mesh(g, m);
var material = new THREE.ShaderMaterial({
let material = new THREE.ShaderMaterial({
// color: 0xff0000,
// linewidth: 5
vertexShader :
@ -71,15 +71,15 @@ export function createPoint0(x, y, z) {
// return line;
material = new THREE.SpriteMaterial( { color: 0xffffff, fog: false } );
var sprite = new THREE.Sprite( material );
let sprite = new THREE.Sprite( material );
sprite.position.set( x, y, z );
return sprite;
}
export function createPoint1(x, y, z) {
var geometry = new THREE.SphereGeometry( 5, 16, 16 );
var material = new THREE.MeshBasicMaterial( {color: 0xff0000} );
var sphere = new THREE.Mesh(geometry, material);
let geometry = new THREE.SphereGeometry( 5, 16, 16 );
let material = new THREE.MeshBasicMaterial( {color: 0xff0000} );
let sphere = new THREE.Mesh(geometry, material);
sphere.position.x = x;
sphere.position.y = y;
sphere.position.z = z;
@ -87,7 +87,7 @@ export function createPoint1(x, y, z) {
}
export function createLine(a, b, color) {
var material = new THREE.LineBasicMaterial({
let material = new THREE.LineBasicMaterial({
color: color,
linewidth: 1
});
@ -113,17 +113,17 @@ export function createSolidMaterial() {
}
export function intercept(obj, methodName, aspect) {
var originFunc = obj[methodName];
let originFunc = obj[methodName];
obj[methodName] = function() {
var $this = this;
let $this = this;
aspect(function() {originFunc.apply($this, arguments)}, arguments);
}
}
export function fixCCW(path, normal) {
var _2DTransformation = new Matrix3x4().setBasis(someBasis(path, normal)).invert();
var path2D = [];
for (var i = 0; i < path.length; ++i) {
let _2DTransformation = new Matrix3x4().setBasis(someBasis(path, normal)).invert();
let path2D = [];
for (let i = 0; i < path.length; ++i) {
path2D[i] = _2DTransformation.apply(path[i]);
}
@ -135,17 +135,17 @@ export function fixCCW(path, normal) {
}
export function someBasis2(normal) {
var x = normal.cross(normal.randomNonParallelVector());
var y = normal.cross(x).unit();
let x = normal.cross(normal.randomNonParallelVector());
let y = normal.cross(x).unit();
return [x, y, normal];
}
export function someBasis(twoPointsOnPlane, normal) {
var a = twoPointsOnPlane[0];
var b = twoPointsOnPlane[1];
let a = twoPointsOnPlane[0];
let b = twoPointsOnPlane[1];
var x = b.minus(a).normalize();
var y = normal.cross(x).normalize();
let x = b.minus(a).normalize();
let y = normal.cross(x).normalize();
return [x, y, normal];
}
@ -164,37 +164,37 @@ export function normalOfCCWSeq(ccwSequence) {
}
export function normalOfCCWSeqTHREE(ccwSequence) {
var a = ccwSequence[0];
var b = ccwSequence[1].clone();
var c = ccwSequence[2].clone();
let a = ccwSequence[0];
let b = ccwSequence[1].clone();
let c = ccwSequence[2].clone();
return b.sub(a).cross(c.sub(a)).normalize();
}
export function calculateExtrudedLid(sourcePolygon, normal, direction, expansionFactor) {
var lid = [];
var length = sourcePolygon.length;
var work;
var si;
let lid = [];
let length = sourcePolygon.length;
let work;
let si;
if (!!expansionFactor && expansionFactor != 1) {
if (expansionFactor < 0.001) expansionFactor = 0.0001;
var source2d = [];
let source2d = [];
work = [];
var _3dTr = new Matrix3x4().setBasis(someBasis2(new CSG.Vector3D(normal))); // use passed basis
var _2dTr = _3dTr.invert();
var sourceBBox = new BBox();
var workBBox = new BBox();
let _3dTr = new Matrix3x4().setBasis(someBasis2(new CSG.Vector3D(normal))); // use passed basis
let _2dTr = _3dTr.invert();
let sourceBBox = new BBox();
let workBBox = new BBox();
for (si = 0; si < length; ++si) {
var sourcePoint = _2dTr.apply(sourcePolygon[si]);
let sourcePoint = _2dTr.apply(sourcePolygon[si]);
source2d[si] = sourcePoint;
work[si] = sourcePoint.multiply(expansionFactor);
work[si].z = source2d[si].z = 0;
sourceBBox.checkBounds(sourcePoint.x, sourcePoint.y);
workBBox.checkBounds(work[si].x, work[si].y)
}
var alignVector = workBBox.center().minus(sourceBBox.center());
var depth = normal.dot(sourcePolygon[0]);
let alignVector = workBBox.center().minus(sourceBBox.center());
let depth = normal.dot(sourcePolygon[0]);
for (si = 0; si < length; ++si) {
work[si] = work[si].minus(alignVector);
work[si].z = depth;
@ -212,14 +212,14 @@ export function calculateExtrudedLid(sourcePolygon, normal, direction, expansion
}
export function triangulate(path, normal) {
var _3dTransformation = new Matrix3x4().setBasis(someBasis2(normal));
var _2dTransformation = _3dTransformation.invert();
var i;
var shell = [];
let _3dTransformation = new Matrix3x4().setBasis(someBasis2(normal));
let _2dTransformation = _3dTransformation.invert();
let i;
let shell = [];
for (i = 0; i < path.length; ++i) {
shell[i] = _2dTransformation.apply(path[i].pos);
}
var myTriangulator = new PNLTRI.Triangulator();
let myTriangulator = new PNLTRI.Triangulator();
return myTriangulator.triangulate_polygon( [ shell ] );
// return THREE.Shape.utils.triangulateShape( f2d.shell, f2d.holes );
}
@ -229,13 +229,13 @@ export function isCurveClass(className) {
}
var POLYGON_COUNTER = 0;
let POLYGON_COUNTER = 0;
export function Polygon(shell, holes, normal) {
this.id = POLYGON_COUNTER ++;
if (!holes) {
holes = [];
}
var h;
let h;
checkPolygon(shell);
for (h = 0; h < holes.length; ++h) {
checkPolygon(holes[h]);
@ -246,7 +246,7 @@ export function Polygon(shell, holes, normal) {
} else {
shell = fixCCW(shell, normal);
if (holes.length > 0) {
var neg = normal.negate();
let neg = normal.negate();
for (h = 0; h < holes.length; ++h) {
holes[h] = fixCCW(holes[h], neg);
}
@ -260,7 +260,7 @@ export function Polygon(shell, holes, normal) {
}
Polygon.prototype.reverse = function(triangle) {
var first = triangle[0];
let first = triangle[0];
triangle[0] = triangle[2];
triangle[2] = first;
};
@ -270,13 +270,13 @@ Polygon.prototype.flip = function() {
};
Polygon.prototype.shift = function(target) {
var shell = [];
var i;
let shell = [];
let i;
for (i = 0; i < this.shell.length; ++i) {
shell[i] = this.shell[i].plus(target);
}
var holes = [];
for (var h = 0; h < this.holes.length; ++h) {
let holes = [];
for (let h = 0; h < this.holes.length; ++h) {
holes[h] = [];
for (i = 0; i < this.holes[h].length; ++i) {
holes[h][i] = this.holes[h][i].plus(target);
@ -286,18 +286,18 @@ Polygon.prototype.shift = function(target) {
};
Polygon.prototype.get2DTransformation = function() {
var _3dTransformation = new Matrix3x4().setBasis(someBasis(this.shell, this.normal));
var _2dTransformation = _3dTransformation.invert();
let _3dTransformation = new Matrix3x4().setBasis(someBasis(this.shell, this.normal));
let _2dTransformation = _3dTransformation.invert();
return _2dTransformation;
};
Polygon.prototype.to2D = function() {
var _2dTransformation = this.get2DTransformation();
let _2dTransformation = this.get2DTransformation();
var i, h;
var shell = [];
var holes = [];
let i, h;
let shell = [];
let holes = [];
for (i = 0; i < this.shell.length; ++i) {
shell[i] = _2dTransformation.apply(this.shell[i]);
}
@ -318,12 +318,12 @@ Polygon.prototype.collectPaths = function(paths) {
Polygon.prototype.triangulate = function() {
function triangulateShape( contour, holes ) {
var myTriangulator = new PNLTRI.Triangulator();
let myTriangulator = new PNLTRI.Triangulator();
return myTriangulator.triangulate_polygon( [ contour ].concat(holes) );
}
var i, h;
var f2d = this.to2D();
let i, h;
let f2d = this.to2D();
for (i = 0; i < f2d.shell.length; ++i) {
f2d.shell[i] = f2d.shell[i].three();
@ -338,7 +338,7 @@ Polygon.prototype.triangulate = function() {
};
Polygon.prototype.eachVertex = function(handler) {
var i, h;
let i, h;
for (i = 0; i < this.shell.length; ++i) {
if (handler(this.shell, i) === true) return;
}
@ -355,10 +355,10 @@ export function Sketch() {
}
export function iteratePath(path, shift, callback) {
var p, q, n = path.length;
let p, q, n = path.length;
for (p = n - 1,q = 0;q < n; p = q++) {
var ai = (p + shift) % n;
var bi = (q + shift) % n;
let ai = (p + shift) % n;
let bi = (q + shift) % n;
if (!callback(path[ai], path[bi], ai, bi, q, path)) {
break
}
@ -366,14 +366,14 @@ export function iteratePath(path, shift, callback) {
}
export function addAll(arr, arrToAdd) {
for (var i = 0; i < arrToAdd.length; i++) {
for (let i = 0; i < arrToAdd.length; i++) {
arr.push(arrToAdd[i]);
}
}
export function arrFlatten1L(arr) {
var result = [];
for (var i = 0; i < arr.length; i++) {
let result = [];
for (let i = 0; i < arr.length; i++) {
addAll(result, arr[i]);
}
return result;

222
web/app/cad/legacy/mesh/workbench.js
View file

@ -51,20 +51,20 @@ export function sortPolygons(polygons) {
function _pointOnLine(p, a, b) {
var ab = a.minus(b);
var ap = a.minus(p);
let ab = a.minus(b);
let ap = a.minus(p);
var dp = ab.dot(ap);
let dp = ab.dot(ap);
var abLength = ab.length();
var apLength = ap.length();
let abLength = ab.length();
let apLength = ap.length();
return apLength > 0 && apLength < abLength && areEqual(abLength * apLength, dp, 1E-6);
}
export function polygonsToSegments(polygons) {
function selfIntersecting(a, b, c) {
var f = _pointOnLine;
let f = _pointOnLine;
return f(c, a, b) || f(a, b, c) || f(b, c, a);
}
//polygons.filter(function(p) {
@ -76,14 +76,14 @@ export function polygonsToSegments(polygons) {
//continue;
//}
var segmentsByPolygon = [];
for (var pi = 0; pi < polygons.length; pi++) {
var segments = [];
var poly = polygons[pi];
let segmentsByPolygon = [];
for (let pi = 0; pi < polygons.length; pi++) {
let segments = [];
let poly = polygons[pi];
var p, q, n = poly.vertices.length;
for(p = n - 1, q = 0; q < n; p = q ++) {
var a = poly.vertices[p];
var b = poly.vertices[q];
let a = poly.vertices[p];
let b = poly.vertices[q];
segments.push([a.pos, b.pos]);
}
segmentsByPolygon.push(segments);
@ -93,12 +93,12 @@ export function polygonsToSegments(polygons) {
export function reconstructSketchBounds(csg, face, strict) {
strict = strict || false;
var polygons = csg.toPolygons();
var plane = face.csgGroup.plane;
var outerEdges = [];
var planePolygons = [];
for (var pi = 0; pi < polygons.length; pi++) {
var poly = polygons[pi];
let polygons = csg.toPolygons();
let plane = face.csgGroup.plane;
let outerEdges = [];
let planePolygons = [];
for (let pi = 0; pi < polygons.length; pi++) {
let poly = polygons[pi];
if (equal(poly.plane.normal.dot(plane.normal), 1)) {
if (equal(plane.w, poly.plane.w) && (!strict || !!poly.shared.__tcad && poly.shared.__tcad.faceId === face.id)) {
planePolygons.push(poly);
@ -107,18 +107,18 @@ export function reconstructSketchBounds(csg, face, strict) {
}
var p, q, n = poly.vertices.length;
for(p = n - 1, q = 0; q < n; p = q ++) {
var a = poly.vertices[p];
var b = poly.vertices[q];
var pointAOnPlane = equal(plane.signedDistanceToPoint(a.pos), 0);
let a = poly.vertices[p];
let b = poly.vertices[q];
let pointAOnPlane = equal(plane.signedDistanceToPoint(a.pos), 0);
if (!pointAOnPlane) continue;
var pointBOnPlane = equal(plane.signedDistanceToPoint(b.pos), 0);
let pointBOnPlane = equal(plane.signedDistanceToPoint(b.pos), 0);
if (pointBOnPlane) {
outerEdges.push([a.pos, b.pos, poly]);
}
}
}
var outline = findOutline(planePolygons);
let outline = findOutline(planePolygons);
pickUpCraftInfo(outline, outerEdges);
@ -126,11 +126,11 @@ export function reconstructSketchBounds(csg, face, strict) {
}
function pickUpCraftInfo(outline, outerEdges) {
var eq = strictEqual;
for (var psi1 = 0; psi1 < outline.length; psi1++) {
var s1 = outline[psi1];
for (var psi2 = 0; psi2 < outerEdges.length; psi2++) {
var s2 = outerEdges[psi2];
let eq = strictEqual;
for (let psi1 = 0; psi1 < outline.length; psi1++) {
let s1 = outline[psi1];
for (let psi2 = 0; psi2 < outerEdges.length; psi2++) {
let s2 = outerEdges[psi2];
if (equal(Math.abs(s1[0].minus(s1[1]).unit().dot(s2[0].minus(s2[1]).unit())), 1) &&
(eq(s1[0], s2[0]) || eq(s1[1], s2[1]) || eq(s1[0], s2[1]) || eq(s1[1], s2[0]) ||
_pointOnLine(s1[0], s2[0], s2[1]) || _pointOnLine(s1[1], s2[0], s2[1]))) {
@ -141,12 +141,12 @@ function pickUpCraftInfo(outline, outerEdges) {
}
function getOutlineByCollision(segments, outerEdges) {
var eq = strictEqual;
var outline = [];
for (var psi1 = 0; psi1 < segments.length; psi1++) {
var s1 = segments[psi1];
for (var psi2 = 0; psi2 < outerEdges.length; psi2++) {
var s2 = outerEdges[psi2];
let eq = strictEqual;
let outline = [];
for (let psi1 = 0; psi1 < segments.length; psi1++) {
let s1 = segments[psi1];
for (let psi2 = 0; psi2 < outerEdges.length; psi2++) {
let s2 = outerEdges[psi2];
if (equal(Math.abs(s1[0].minus(s1[1]).unit().dot(s2[0].minus(s2[1]).unit())), 1) &&
(eq(s1[0], s2[0]) || eq(s1[1], s2[1]) || eq(s1[0], s2[1]) || eq(s1[1], s2[0]) ||
_pointOnLine(s1[0], s2[0], s2[1]) || _pointOnLine(s1[1], s2[0], s2[1]))) {
@ -158,9 +158,9 @@ function getOutlineByCollision(segments, outerEdges) {
}
export function findOutline (planePolygons) {
var segmentsByPolygon = polygonsToSegments(planePolygons);
let segmentsByPolygon = polygonsToSegments(planePolygons);
//simplifySegments(segmentsByPolygon);
var planeSegments = cad_utils.arrFlatten1L(segmentsByPolygon);
let planeSegments = cad_utils.arrFlatten1L(segmentsByPolygon);
//planeSegments = removeSharedEdges(planeSegments);
removeTJoints(planeSegments);
planeSegments = removeSharedEdges(planeSegments);
@ -169,13 +169,13 @@ export function findOutline (planePolygons) {
function removeSharedEdges(segments) {
segments = segments.slice();
var eq = strictEqual;
for (var psi1 = 0; psi1 < segments.length; psi1++) {
var s1 = segments[psi1];
let eq = strictEqual;
for (let psi1 = 0; psi1 < segments.length; psi1++) {
let s1 = segments[psi1];
if (s1 == null) continue;
for (var psi2 = 0; psi2 < segments.length; psi2++) {
for (let psi2 = 0; psi2 < segments.length; psi2++) {
if (psi1 === psi2) continue;
var s2 = segments[psi2];
let s2 = segments[psi2];
if (s2 == null) continue;
if ((eq(s1[0], s2[0]) && eq(s1[1], s2[1]) || (eq(s1[0], s2[1]) && eq(s1[1], s2[0])))) {
segments[psi1] = null;
@ -187,15 +187,15 @@ function removeSharedEdges(segments) {
}
function simplifySegments(polygonToSegments) {
for (var pi1 = 0; pi1 < polygonToSegments.length; ++pi1) {
for (var pi2 = 0; pi2 < polygonToSegments.length; ++pi2) {
for (let pi1 = 0; pi1 < polygonToSegments.length; ++pi1) {
for (let pi2 = 0; pi2 < polygonToSegments.length; ++pi2) {
if (pi1 === pi2) continue;
var polygon1 = polygonToSegments[pi1];
var polygon2 = polygonToSegments[pi2];
for (var si1 = 0; si1 < polygon1.length; ++si1) {
var seg1 = polygon1[si1];
for (var si2 = 0; si2 < polygon2.length; ++si2) {
var point = polygon2[si2][0];
let polygon1 = polygonToSegments[pi1];
let polygon2 = polygonToSegments[pi2];
for (let si1 = 0; si1 < polygon1.length; ++si1) {
let seg1 = polygon1[si1];
for (let si2 = 0; si2 < polygon2.length; ++si2) {
let point = polygon2[si2][0];
if (_pointOnLine(point, seg1[0], seg1[1])) {
polygon1.push([point, seg1[1]]);
seg1[1] = point;
@ -208,37 +208,37 @@ function simplifySegments(polygonToSegments) {
function _closeFactorToLine(p, seg1, seg2) {
var a = p.minus(seg1);
var b = seg2.minus(seg1);
var bn = b.unit();
let a = p.minus(seg1);
let b = seg2.minus(seg1);
let bn = b.unit();
var projLength = bn.dot(a);
var bx = bn.times(projLength);
let projLength = bn.dot(a);
let bx = bn.times(projLength);
if (!(projLength > 0 && projLength < b.length())) {
return -1;
}
var c = a.minus(bx);
let c = a.minus(bx);
return c.length();
}
function removeTJoints(segments) {
var pointIndex = HashTable.forVector3d();
let pointIndex = HashTable.forVector3d();
for (var i = 0; i < segments.length; ++i) {
for (let i = 0; i < segments.length; ++i) {
pointIndex.put(segments[i][0], 1);
pointIndex.put(segments[i][1], 1);
}
var points = pointIndex.getKeys();
var eq = strictEqual;
for (var pi1 = 0; pi1 < points.length; ++pi1) {
var point = points[pi1];
let points = pointIndex.getKeys();
let eq = strictEqual;
for (let pi1 = 0; pi1 < points.length; ++pi1) {
let point = points[pi1];
var best = null, bestFactor;
for (var pi2 = 0; pi2 < segments.length; ++pi2) {
var seg = segments[pi2];
for (let pi2 = 0; pi2 < segments.length; ++pi2) {
let seg = segments[pi2];
if (eq(seg[0], point) || eq(seg[1], point)) continue;
var factor = _closeFactorToLine(point, seg[0], seg[1]);
let factor = _closeFactorToLine(point, seg[0], seg[1]);
if (factor != -1 && factor < 1E-6 && (best == null || factor < bestFactor)) {
best = seg;
bestFactor = factor;
@ -252,16 +252,16 @@ function removeTJoints(segments) {
}
function deleteRedundantPoints(path) {
var cleanedPath = [];
let cleanedPath = [];
//Delete redundant point
var pathLength = path.length;
var skipMode = false;
for (var pi = 0; pi < pathLength; pi++) {
var bIdx = ((pi + 1) % pathLength);
var a = path[pi];
var b = path[bIdx];
var c = path[(pi + 2) % pathLength];
var eq = areEqual;
let pathLength = path.length;
let skipMode = false;
for (let pi = 0; pi < pathLength; pi++) {
let bIdx = ((pi + 1) % pathLength);
let a = path[pi];
let b = path[bIdx];
let c = path[(pi + 2) % pathLength];
let eq = areEqual;
if (!skipMode) cleanedPath.push(a);
skipMode = eq(a.minus(b).unit().dot(b.minus(c).unit()), 1, 1E-9);
}
@ -270,13 +270,13 @@ function deleteRedundantPoints(path) {
export function segmentsToPaths(segments) {
var veq = strictEqual;
var paths = [];
var index = HashTable.forVector3d();
var csgIndex = HashTable.forEdge();
let veq = strictEqual;
let paths = [];
let index = HashTable.forVector3d();
let csgIndex = HashTable.forEdge();
function indexPoint(p, edge) {
var edges = index.get(p);
let edges = index.get(p);
if (edges === null) {
edges = [];
index.put(p, edges);
@ -284,11 +284,11 @@ export function segmentsToPaths(segments) {
edges.push(edge);
}
for (var si = 0; si < segments.length; si++) {
var k = segments[si];
for (let si = 0; si < segments.length; si++) {
let k = segments[si];
indexPoint(k[0], k);
indexPoint(k[1], k);
var csgInfo = k[2];
let csgInfo = k[2];
if (csgInfo !== undefined && csgInfo !== null) {
csgIndex.put([k[0], k[1]], csgInfo);
}
@ -296,12 +296,12 @@ export function segmentsToPaths(segments) {
}
function nextPoint(p) {
var edges = index.get(p);
let edges = index.get(p);
if (edges === null) return null;
for (var i = 0; i < edges.length; i++) {
var edge = edges[i];
for (let i = 0; i < edges.length; i++) {
let edge = edges[i];
if (edge[3]) continue;
var res = null;
let res = null;
if (veq(p, edge[0])) res = edge[1];
if (veq(p, edge[1])) res = edge[0];
if (res != null) {
@ -312,16 +312,16 @@ export function segmentsToPaths(segments) {
return null;
}
var path;
for (var ei = 0; ei < segments.length; ei++) {
var edge = segments[ei];
let path;
for (let ei = 0; ei < segments.length; ei++) {
let edge = segments[ei];
if (edge[3]) {
continue;
}
edge[3] = true;
path = [edge[0], edge[1]];
paths.push(path);
var next = nextPoint(edge[1]);
let next = nextPoint(edge[1]);
while (next !== null) {
if (!veq(next, path[0])) {
path.push(next);
@ -332,13 +332,13 @@ export function segmentsToPaths(segments) {
}
}
var filteredPaths = [];
for (var i = 0; i < paths.length; i++) {
let filteredPaths = [];
for (let i = 0; i < paths.length; i++) {
path = paths[i];
//Set derived from object to be able to recunstruct
cad_utils.iteratePath(path, 0, function (a, b) {
var fromPolygon = csgIndex.get([a, b]);
let fromPolygon = csgIndex.get([a, b]);
if (fromPolygon !== null) {
if (fromPolygon.shared.__tcad.csgInfo) {
a.sketchConnectionObject = fromPolygon.shared.__tcad.csgInfo.derivedFrom;
@ -365,14 +365,14 @@ function _triangulateCSG(polygons) {
return [v.x, v.y, v.z];
}
var triangled = [];
let triangled = [];
for (let poly of polygons) {
let vertices = Triangulate([poly.vertices.map(v => data(v.pos))], data(poly.plane.normal));
for (let i = 0; i < vertices.length; i += 3 ) {
var a = csgVert(vertices[i]);
var b = csgVert(vertices[i + 1]);
var c = csgVert(vertices[i + 2]);
var csgPoly = new CSG.Polygon([a, b, c], poly.shared, poly.plane);
let a = csgVert(vertices[i]);
let b = csgVert(vertices[i + 1]);
let c = csgVert(vertices[i + 2]);
let csgPoly = new CSG.Polygon([a, b, c], poly.shared, poly.plane);
triangled.push(csgPoly);
}
}
@ -380,21 +380,21 @@ function _triangulateCSG(polygons) {
}
function splitTwoSegments(a, b) {
var da = a[1].minus(a[0]);
var db = b[1].minus(b[0]);
var dc = b[0].minus(a[0]);
let da = a[1].minus(a[0]);
let db = b[1].minus(b[0]);
let dc = b[0].minus(a[0]);
var daXdb = da.cross(db);
let daXdb = da.cross(db);
if (Math.abs(dc.dot(daXdb)) > 1e-6) {
// lines are not coplanar
return null;
}
var veq = strictEqual;
let veq = strictEqual;
if (veq(a[0], b[0]) || veq(a[0], b[1]) || veq(a[1], b[0]) || veq(a[1], b[1])) {
return null;
}
var dcXdb = dc.cross(db);
let dcXdb = dc.cross(db);
function _split(s, ip) {
if (s[0].equals(ip) || s[1].equals(ip)) {
@ -402,9 +402,9 @@ function splitTwoSegments(a, b) {
}
return [[s[0], ip, s[2]], [ip, s[1], s[2]]]
}
var s = dcXdb.dot(daXdb) / daXdb.lengthSquared();
let s = dcXdb.dot(daXdb) / daXdb.lengthSquared();
if (s > 0.0 && s < 1.0) {
var ip = a[0].plus(da.times(s));
let ip = a[0].plus(da.times(s));
return {
splitterParts : _split(a, ip),
residual : _split(b, ip)
@ -414,14 +414,14 @@ function splitTwoSegments(a, b) {
}
function attract(vectors, precision) {
var eq = areEqual();
var dist = distanceAB3;
let eq = areEqual();
let dist = distanceAB3;
vectors = vectors.slice();
for (var i = 0; i < vectors.length; i++) {
var v1 = vectors[i];
for (let i = 0; i < vectors.length; i++) {
let v1 = vectors[i];
if (v1 == null) continue;
for (var j = i + 1; j < vectors.length; j++) {
var v2 = vectors[j];
for (let j = i + 1; j < vectors.length; j++) {
let v2 = vectors[j];
if (v2 == null) continue;
if (dist(v1, v2) <= precision) {
Vector.prototype.setV.call(v2, v1);

4
web/app/cad/stl/stlAsciiReader.js
View file

@ -10,7 +10,7 @@ export function parse(buf) {
while (reader.hasNextLine()) {
let line = reader.nextLine();
lineNumber ++;
var parts = line
let parts = line
.trim()
.split(' ')
.filter(function(part) {
@ -56,7 +56,7 @@ function LinesReader(buf) {
let arr = new Uint8Array(buf);
this.nextLine = function() {
let str = "";
for (var i = mark; i < pos; i++) {
for (let i = mark; i < pos; i++) {
str += String.fromCharCode(arr[i]);
}
mark = pos;

16
web/app/cad/tess/triangulation.js
View file

@ -18,7 +18,7 @@ function initTesselator() {
// console.log('edge flag: ' + flag);
}
var tessy = new libtess.GluTesselator();
let tessy = new libtess.GluTesselator();
// tessy.gluTessProperty(libtess.gluEnum.GLU_TESS_WINDING_RULE, libtess.windingRule.GLU_TESS_WINDING_POSITIVE);
tessy.gluTessCallback(libtess.gluEnum.GLU_TESS_VERTEX_DATA, vertexCallback);
tessy.gluTessCallback(libtess.gluEnum.GLU_TESS_BEGIN, begincallback);
@ -75,9 +75,9 @@ export function TriangulatePolygons(polygons, normal, toArray, fromArray) {
let vertices = Triangulate(contours, toArray(normal));
for (let i = 0; i < vertices.length; i += 3 ) {
var a = fromArray(vertices[i]);
var b = fromArray(vertices[i + 1]);
var c = fromArray(vertices[i + 2]);
let a = fromArray(vertices[i]);
let b = fromArray(vertices[i + 1]);
let c = fromArray(vertices[i + 2]);
triangled.push([a, b, c]);
}
return triangled;
@ -97,7 +97,7 @@ export function TriangulateFace(face) {
function edgeCallback(flag) {
}
var tessy = new libtess.GluTesselator();
let tessy = new libtess.GluTesselator();
// tessy.gluTessProperty(libtess.gluEnum.GLU_TESS_WINDING_RULE, libtess.windingRule.GLU_TESS_WINDING_POSITIVE);
tessy.gluTessCallback(libtess.gluEnum.GLU_TESS_VERTEX_DATA, vertexCallback);
tessy.gluTessCallback(libtess.gluEnum.GLU_TESS_BEGIN, begincallback);
@ -135,9 +135,9 @@ export function TriangulateFace(face) {
const triangled = [];
for (let i = 0; i < vertices.length; i += 3 ) {
var a = vertices[i];
var b = vertices[i + 1];
var c = vertices[i + 2];
let a = vertices[i];
let b = vertices[i + 1];
let c = vertices[i + 2];
triangled.push([a, b, c]);
}
return triangled;

128
web/app/sketcher/constr/solver.js
View file

@ -10,10 +10,10 @@ import {fillArray} from "gems/iterables";
function System(constraints) {
this.constraints = constraints;
this.params = [];
for (var ci = 0; ci < constraints.length; ++ci) {
var c = constraints[ci];
for (var pi = 0; pi < c.params.length; ++pi) {
var p = c.params[pi];
for (let ci = 0; ci < constraints.length; ++ci) {
let c = constraints[ci];
for (let pi = 0; pi < c.params.length; ++pi) {
let p = c.params[pi];
if (p.j == -1) {
p.j = this.params.length;
this.params.push(p);
@ -24,9 +24,9 @@ function System(constraints) {
System.prototype.makeJacobian = function() {
var jacobi = [];
var i;
var j;
let jacobi = [];
let i;
let j;
for (i=0; i < this.constraints.length; i++) {
jacobi[i] = [];
for (j=0; j < this.params.length; j++) {
@ -34,15 +34,15 @@ System.prototype.makeJacobian = function() {
}
}
for (i=0; i < this.constraints.length; i++) {
var c = this.constraints[i];
let c = this.constraints[i];
var cParams = c.params;
var grad = [];
let cParams = c.params;
let grad = [];
fillArray(grad, 0, cParams.length, 0);
c.gradient(grad);
for (var p = 0; p < cParams.length; p++) {
var param = cParams[p];
for (let p = 0; p < cParams.length; p++) {
let param = cParams[p];
j = param.j;
jacobi[i][j] = grad[p];
}
@ -51,17 +51,17 @@ System.prototype.makeJacobian = function() {
};
System.prototype.fillJacobian = function(jacobi) {
for (var i=0; i < this.constraints.length; i++) {
var c = this.constraints[i];
for (let i=0; i < this.constraints.length; i++) {
let c = this.constraints[i];
var cParams = c.params;
var grad = [];
let cParams = c.params;
let grad = [];
fillArray(grad, 0, cParams.length, 0);
c.gradient(grad);
for (var p = 0; p < cParams.length; p++) {
var param = cParams[p];
var j = param.j;
for (let p = 0; p < cParams.length; p++) {
let param = cParams[p];
let j = param.j;
jacobi[i][j] = grad[p];
}
}
@ -70,11 +70,11 @@ System.prototype.fillJacobian = function(jacobi) {
System.prototype.calcResidual = function(r) {
var i=0;
var err = 0.;
let i=0;
let err = 0.;
for (i=0; i < this.constraints.length; i++) {
var c = this.constraints[i];
let c = this.constraints[i];
r[i] = c.error();
err += r[i]*r[i];
}
@ -84,94 +84,94 @@ System.prototype.calcResidual = function(r) {
};
System.prototype.calcGrad_ = function(out) {
var i;
let i;
for (i = 0; i < out.length || i < this.params.length; ++i) {
out[i][0] = 0;
}
for (i=0; i < this.constraints.length; i++) {
var c = this.constraints[i];
let c = this.constraints[i];
var cParams = c.params;
var grad = [];
let cParams = c.params;
let grad = [];
fillArray(grad, 0, cParams.length, 0);
c.gradient(grad);
for (var p = 0; p < cParams.length; p++) {
var param = cParams[p];
var j = param.j;
for (let p = 0; p < cParams.length; p++) {
let param = cParams[p];
let j = param.j;
out[j][0] += this.constraints[i].error() * grad[p]; // (10.4)
}
}
};
System.prototype.calcGrad = function(out) {
var i;
let i;
for (i = 0; i < out.length || i < this.params.length; ++i) {
out[i] = 0;
}
for (i=0; i < this.constraints.length; i++) {
var c = this.constraints[i];
let c = this.constraints[i];
var cParams = c.params;
var grad = [];
let cParams = c.params;
let grad = [];
fillArray(grad, 0, cParams.length, 0);
c.gradient(grad);
for (var p = 0; p < cParams.length; p++) {
var param = cParams[p];
var j = param.j;
for (let p = 0; p < cParams.length; p++) {
let param = cParams[p];
let j = param.j;
out[j] += this.constraints[i].error() * grad[p]; // (10.4)
}
}
};
System.prototype.fillParams = function(out) {
for (var p = 0; p < this.params.length; p++) {
for (let p = 0; p < this.params.length; p++) {
out[p] = this.params[p].get();
}
};
System.prototype.getParams = function() {
var out = [];
let out = [];
this.fillParams(out);
return out;
};
System.prototype.setParams = function(point) {
for (var p = 0; p < this.params.length; p++) {
for (let p = 0; p < this.params.length; p++) {
this.params[p].set(point[p]);
}
};
System.prototype.error = function() {
var error = 0;
for (var i=0; i < this.constraints.length; i++) {
let error = 0;
for (let i=0; i < this.constraints.length; i++) {
error += Math.abs(this.constraints[i].error());
}
return error;
};
System.prototype.errorSquare = function() {
var error = 0;
for (var i=0; i < this.constraints.length; i++) {
var t = this.constraints[i].error();
let error = 0;
for (let i=0; i < this.constraints.length; i++) {
let t = this.constraints[i].error();
error += t * t;
}
return error * 0.5;
};
System.prototype.getValues = function() {
var values = [];
for (var i=0; i < this.constraints.length; i++) {
let values = [];
for (let i=0; i < this.constraints.length; i++) {
values[i] = this.constraints[i].error();
}
return values;
};
System.prototype.rollback = function() {
for (var p = 0; p < this.params.length; p++) {
for (let p = 0; p < this.params.length; p++) {
this.params[p].rollback();
}
};
@ -198,50 +198,50 @@ function wrapConstants(constrs) {
return constrs;
}
var lock2Equals2 = function(constrs, locked) {
var _locked = [];
for (var i = 0; i < locked.length; ++i) {
let lock2Equals2 = function(constrs, locked) {
let _locked = [];
for (let i = 0; i < locked.length; ++i) {
_locked.push(new EqualsTo([locked[i]], locked[i].get()));
}
return _locked;
};
var diagnose = function(sys) {
let diagnose = function(sys) {
if (sys.constraints.length === 0 || sys.params.length === 0) {
return {
conflict : false,
dof : 0
}
}
var jacobian = sys.makeJacobian();
var qr = new QR(jacobian);
let jacobian = sys.makeJacobian();
let qr = new QR(jacobian);
return {
conflict : sys.constraints.length > qr.rank,
dof : sys.params.length - qr.rank
}
};
var prepare = function(constrs, locked) {
let prepare = function(constrs, locked) {
var simpleMode = true;
let simpleMode = true;
if (!simpleMode) {
var lockingConstrs = lock2Equals2(constrs, locked);
Array.prototype.push.apply( constrs, lockingConstrs );
}
constrs = wrapConstants(constrs);
var sys = new System(constrs);
let sys = new System(constrs);
var model = function(point) {
let model = function(point) {
sys.setParams(point);
return sys.getValues();
};
var jacobian = function(point) {
let jacobian = function(point) {
sys.setParams(point);
return sys.makeJacobian();
};
var nullResult = {
let nullResult = {
evalCount : 0,
error : 0,
returnCode : 1
@ -261,13 +261,13 @@ var prepare = function(constrs, locked) {
}
return result;
}
var systemSolver = {
let systemSolver = {
diagnose : function() {return diagnose(sys)},
error : function() {return sys.error()},
solveSystem : solve,
system : sys,
updateLock : function(values) {
for (var i = 0; i < values.length; ++i) {
for (let i = 0; i < values.length; ++i) {
if (simpleMode) {
locked[i].set(values[i]);
} else {
@ -280,11 +280,11 @@ var prepare = function(constrs, locked) {
};
var solve_lm = function(sys, model, jacobian, rough) {
var opt = new LMOptimizer(sys.getParams(), newVector(sys.constraints.length), model, jacobian);
let opt = new LMOptimizer(sys.getParams(), newVector(sys.constraints.length), model, jacobian);
opt.evalMaximalCount = 100000; //100 * sys.params.length;
var eps = rough ? 0.001 : 0.00000001;
let eps = rough ? 0.001 : 0.00000001;
opt.init0(eps, eps, eps);
var returnCode = 1;
let returnCode = 1;
try {
var res = opt.doOptimize();
} catch (e) {

310
web/app/sketcher/constr/solverConstraints.js
View file

@ -72,22 +72,22 @@ function MinLength(params, distance) {
this.params = params;
this.distance = distance;
var p1x = 0;
var p1y = 1;
var p2x = 2;
var p2y = 3;
let p1x = 0;
let p1y = 1;
let p2x = 2;
let p2y = 3;
this.error = function() {
var dx = params[p1x].get() - params[p2x].get();
var dy = params[p1y].get() - params[p2y].get();
var d = Math.sqrt(dx * dx + dy * dy);
let dx = params[p1x].get() - params[p2x].get();
let dy = params[p1y].get() - params[p2y].get();
let d = Math.sqrt(dx * dx + dy * dy);
return d < this.distance ? (d - this.distance) : 0;
};
this.gradient = function(out) {
var dx = params[p1x].get() - params[p2x].get();
var dy = params[p1y].get() - params[p2y].get();
var d = Math.sqrt(dx * dx + dy * dy);
let dx = params[p1x].get() - params[p2x].get();
let dy = params[p1y].get() - params[p2y].get();
let d = Math.sqrt(dx * dx + dy * dy);
if (d == 0) {
d = 0.000001;
}
@ -107,34 +107,34 @@ function MinLength(params, distance) {
function LockConvex(params) {
this.params = params;
var _pcx = 0;
var _pcy = 1;
var _pax = 2;
var _pay = 3;
var _ptx = 4;
var _pty = 5;
let _pcx = 0;
let _pcy = 1;
let _pax = 2;
let _pay = 3;
let _ptx = 4;
let _pty = 5;
this.error = function() {
var cx = params[_pcx].get();
var cy = params[_pcy].get();
var ax = params[_pax].get();
var ay = params[_pay].get();
var tx = params[_ptx].get();
var ty = params[_pty].get();
let cx = params[_pcx].get();
let cy = params[_pcy].get();
let ax = params[_pax].get();
let ay = params[_pay].get();
let tx = params[_ptx].get();
let ty = params[_pty].get();
var crossProductNorm = (cx - ax) * (ty - ay) - (cy - ay) * (tx - ax);
let crossProductNorm = (cx - ax) * (ty - ay) - (cy - ay) * (tx - ax);
var violate = crossProductNorm < 0;
let violate = crossProductNorm < 0;
return violate ? crossProductNorm : 0;
};
this.gradient = function(out) {
var cx = params[_pcx].get();
var cy = params[_pcy].get();
var ax = params[_pax].get();
var ay = params[_pay].get();
var tx = params[_ptx].get();
var ty = params[_pty].get();
let cx = params[_pcx].get();
let cy = params[_pcy].get();
let ax = params[_pax].get();
let ay = params[_pay].get();
let tx = params[_ptx].get();
let ty = params[_pty].get();
out[_pcx] = ty-ay;
out[_pcy] = ax-tx;
@ -164,7 +164,7 @@ function ConstantWrapper(constr, mask) {
this.gradient = function(out) {
fillArray(this.grad, 0, this.grad.length, 0);
constr.gradient(this.grad);
var jj = 0;
let jj = 0;
for (let j = 0; j < mask.length; j++) {
if (!mask[j]) {
out[jj ++] = this.grad[j];
@ -185,7 +185,7 @@ function Weighted(constr, weight) {
this.gradient = function(out) {
constr.gradient(out);
for (var i = 0; i < out.length; i++) {
for (let i = 0; i < out.length; i++) {
out[i] *= this.weight;
}
}
@ -248,38 +248,38 @@ function P2LDistance(params, distance) {
this.params = params;
this.distance = distance;
var TX = 0;
var TY = 1;
var LP1X = 2;
var LP1Y = 3;
var LP2X = 4;
var LP2Y = 5;
let TX = 0;
let TY = 1;
let LP1X = 2;
let LP1Y = 3;
let LP2X = 4;
let LP2Y = 5;
this.error = function() {
var x0 = params[TX].get(), x1 = params[LP1X].get(), x2 = params[LP2X].get();
var y0 = params[TY].get(), y1 = params[LP1Y].get(), y2 = params[LP2Y].get();
var dx = x2 - x1;
var dy = y2 - y1;
var d = Math.sqrt(dx * dx + dy * dy);
let x0 = params[TX].get(), x1 = params[LP1X].get(), x2 = params[LP2X].get();
let y0 = params[TY].get(), y1 = params[LP1Y].get(), y2 = params[LP2Y].get();
let dx = x2 - x1;
let dy = y2 - y1;
let d = Math.sqrt(dx * dx + dy * dy);
if (d == 0) {
return 0;
}
var A = -x0 * dy + y0 * dx + x1 * y2 - x2 * y1;
let A = -x0 * dy + y0 * dx + x1 * y2 - x2 * y1;
return Math.abs(A) / d - this.distance;
};
this.gradient = function(out) {
var x0 = params[TX].get(), x1 = params[LP1X].get(), x2 = params[LP2X].get();
var y0 = params[TY].get(), y1 = params[LP1Y].get(), y2 = params[LP2Y].get();
var dx = x2 - x1;
var dy = y2 - y1;
var d2 = dx * dx + dy * dy;
var d = Math.sqrt(d2);
var d3 = d * d2;
let x0 = params[TX].get(), x1 = params[LP1X].get(), x2 = params[LP2X].get();
let y0 = params[TY].get(), y1 = params[LP1Y].get(), y2 = params[LP2Y].get();
let dx = x2 - x1;
let dy = y2 - y1;
let d2 = dx * dx + dy * dy;
let d = Math.sqrt(d2);
let d3 = d * d2;
// var AA = -x0 * (y2 - y1) + y0 * (x2 - x1) + x1 * y2 - x2 * y1;
var A = -x0 * dy + y0 * dx + x1 * y2 - x2 * y1;
var AM = Math.abs(A);
var j = A < 0 ? -1 : 1;
let A = -x0 * dy + y0 * dx + x1 * y2 - x2 * y1;
let AM = Math.abs(A);
let j = A < 0 ? -1 : 1;
out[TX] = j * (y1 - y2) / d;
out[TY] = j * (x2 - x1) / d;
@ -297,40 +297,40 @@ function P2LDistanceV(params) {
this.params = params;//.slice(0, params.length -1);
var TX = 0;
var TY = 1;
var LP1X = 2;
var LP1Y = 3;
var LP2X = 4;
var LP2Y = 5;
var D = 6;
let TX = 0;
let TY = 1;
let LP1X = 2;
let LP1Y = 3;
let LP2X = 4;
let LP2Y = 5;
let D = 6;
this.error = function() {
var x0 = params[TX].get(), x1 = params[LP1X].get(), x2 = params[LP2X].get();
var y0 = params[TY].get(), y1 = params[LP1Y].get(), y2 = params[LP2Y].get();
var dist = this.params[D].get();
var dx = x2 - x1;
var dy = y2 - y1;
var d = Math.sqrt(dx * dx + dy * dy);
let x0 = params[TX].get(), x1 = params[LP1X].get(), x2 = params[LP2X].get();
let y0 = params[TY].get(), y1 = params[LP1Y].get(), y2 = params[LP2Y].get();
let dist = this.params[D].get();
let dx = x2 - x1;
let dy = y2 - y1;
let d = Math.sqrt(dx * dx + dy * dy);
if (d == 0) {
return 0;
}
var A = -x0 * dy + y0 * dx + x1 * y2 - x2 * y1;
let A = -x0 * dy + y0 * dx + x1 * y2 - x2 * y1;
return Math.abs(A) / d - dist;
};
this.gradient = function(out) {
var x0 = params[TX].get(), x1 = params[LP1X].get(), x2 = params[LP2X].get();
var y0 = params[TY].get(), y1 = params[LP1Y].get(), y2 = params[LP2Y].get();
var dx = x2 - x1;
var dy = y2 - y1;
var d2 = dx * dx + dy * dy;
var d = Math.sqrt(d2);
var d3 = d * d2;
let x0 = params[TX].get(), x1 = params[LP1X].get(), x2 = params[LP2X].get();
let y0 = params[TY].get(), y1 = params[LP1Y].get(), y2 = params[LP2Y].get();
let dx = x2 - x1;
let dy = y2 - y1;
let d2 = dx * dx + dy * dy;
let d = Math.sqrt(d2);
let d3 = d * d2;
// var AA = -x0 * (y2 - y1) + y0 * (x2 - x1) + x1 * y2 - x2 * y1;
var A = -x0 * dy + y0 * dx + x1 * y2 - x2 * y1;
var AM = Math.abs(A);
var j = A < 0 ? -1 : 1;
let A = -x0 * dy + y0 * dx + x1 * y2 - x2 * y1;
let AM = Math.abs(A);
let j = A < 0 ? -1 : 1;
out[TX] = j * (y1 - y2) / d;
out[TY] = j * (x2 - x1) / d;
@ -351,22 +351,22 @@ function P2PDistance(params, distance) {
this.params = params;
this.distance = distance;
var p1x = 0;
var p1y = 1;
var p2x = 2;
var p2y = 3;
let p1x = 0;
let p1y = 1;
let p2x = 2;
let p2y = 3;
this.error = function() {
var dx = params[p1x].get() - params[p2x].get();
var dy = params[p1y].get() - params[p2y].get();
var d = Math.sqrt(dx * dx + dy * dy);
let dx = params[p1x].get() - params[p2x].get();
let dy = params[p1y].get() - params[p2y].get();
let d = Math.sqrt(dx * dx + dy * dy);
return (d - this.distance);
};
this.gradient = function(out) {
var dx = params[p1x].get() - params[p2x].get();
var dy = params[p1y].get() - params[p2y].get();
var d = Math.sqrt(dx * dx + dy * dy);
let dx = params[p1x].get() - params[p2x].get();
let dy = params[p1y].get() - params[p2y].get();
let d = Math.sqrt(dx * dx + dy * dy);
if (d == 0) {
if (this.distance == 0) return;
d = 0.000001;
@ -383,23 +383,23 @@ function P2PDistanceV(params) {
this.params = params;
var p1x = 0;
var p1y = 1;
var p2x = 2;
var p2y = 3;
var D = 4;
let p1x = 0;
let p1y = 1;
let p2x = 2;
let p2y = 3;
let D = 4;
this.error = function() {
var dx = params[p1x].get() - params[p2x].get();
var dy = params[p1y].get() - params[p2y].get();
var d = Math.sqrt(dx * dx + dy * dy);
let dx = params[p1x].get() - params[p2x].get();
let dy = params[p1y].get() - params[p2y].get();
let d = Math.sqrt(dx * dx + dy * dy);
return (d - params[D].get());
};
this.gradient = function(out) {
var dx = params[p1x].get() - params[p2x].get();
var dy = params[p1y].get() - params[p2y].get();
var d = Math.sqrt(dx * dx + dy * dy);
let dx = params[p1x].get() - params[p2x].get();
let dy = params[p1y].get() - params[p2y].get();
let d = Math.sqrt(dx * dx + dy * dy);
if (d == 0) {
if (params[D].get() == 0) return;
d = 0.000001;
@ -487,20 +487,20 @@ function Parallel(params) {
this.params = params;
var l1p1x = 0;
var l1p1y = 1;
var l1p2x = 2;
var l1p2y = 3;
var l2p1x = 4;
var l2p1y = 5;
var l2p2x = 6;
var l2p2y = 7;
let l1p1x = 0;
let l1p1y = 1;
let l1p2x = 2;
let l1p2y = 3;
let l2p1x = 4;
let l2p1y = 5;
let l2p2x = 6;
let l2p2y = 7;
this.error = function() {
var dx1 = (params[l1p1x].get() - params[l1p2x].get());
var dy1 = (params[l1p1y].get() - params[l1p2y].get());
var dx2 = (params[l2p1x].get() - params[l2p2x].get());
var dy2 = (params[l2p1y].get() - params[l2p2y].get());
let dx1 = (params[l1p1x].get() - params[l1p2x].get());
let dy1 = (params[l1p1y].get() - params[l1p2y].get());
let dx2 = (params[l2p1x].get() - params[l2p2x].get());
let dy2 = (params[l2p1y].get() - params[l2p2y].get());
return (dx1*dy2 - dy1*dx2);
};
@ -520,20 +520,20 @@ function Perpendicular(params) {
this.params = params;
var l1p1x = 0;
var l1p1y = 1;
var l1p2x = 2;
var l1p2y = 3;
var l2p1x = 4;
var l2p1y = 5;
var l2p2x = 6;
var l2p2y = 7;
let l1p1x = 0;
let l1p1y = 1;
let l1p2x = 2;
let l1p2y = 3;
let l2p1x = 4;
let l2p1y = 5;
let l2p2x = 6;
let l2p2y = 7;
this.error = function() {
var dx1 = (params[l1p1x].get() - params[l1p2x].get());
var dy1 = (params[l1p1y].get() - params[l1p2y].get());
var dx2 = (params[l2p1x].get() - params[l2p2x].get());
var dy2 = (params[l2p1y].get() - params[l2p2y].get());
let dx1 = (params[l1p1x].get() - params[l1p2x].get());
let dy1 = (params[l1p1y].get() - params[l1p2y].get());
let dx2 = (params[l2p1x].get() - params[l2p2x].get());
let dy2 = (params[l2p1y].get() - params[l2p2y].get());
//dot product shows how the lines off to be perpendicular
return (dx1*dx2 + dy1*dy2);
};
@ -554,51 +554,51 @@ function Angle(params) {
this.params = params;
var l1p1x = 0;
var l1p1y = 1;
var l1p2x = 2;
var l1p2y = 3;
var l2p1x = 4;
var l2p1y = 5;
var l2p2x = 6;
var l2p2y = 7;
var angle = 8;
var scale = 1000; // we need scale to get same order of measure units(radians are to small)
let l1p1x = 0;
let l1p1y = 1;
let l1p2x = 2;
let l1p2y = 3;
let l2p1x = 4;
let l2p1y = 5;
let l2p2x = 6;
let l2p2y = 7;
let angle = 8;
let scale = 1000; // we need scale to get same order of measure units(radians are to small)
function p(ref) {
return params[ref].get();
}
this.error = function() {
var dx1 = (p(l1p2x) - p(l1p1x));
var dy1 = (p(l1p2y) - p(l1p1y));
var dx2 = (p(l2p2x) - p(l2p1x));
var dy2 = (p(l2p2y) - p(l2p1y));
var a = Math.atan2(dy1,dx1) + p(angle);
var ca = Math.cos(a);
var sa = Math.sin(a);
var x2 = dx2*ca + dy2*sa;
var y2 = -dx2*sa + dy2*ca;
let dx1 = (p(l1p2x) - p(l1p1x));
let dy1 = (p(l1p2y) - p(l1p1y));
let dx2 = (p(l2p2x) - p(l2p1x));
let dy2 = (p(l2p2y) - p(l2p1y));
let a = Math.atan2(dy1,dx1) + p(angle);
let ca = Math.cos(a);
let sa = Math.sin(a);
let x2 = dx2*ca + dy2*sa;
let y2 = -dx2*sa + dy2*ca;
return Math.atan2(y2,x2) * scale;
};
this.gradient = function (out) {
var dx1 = (p(l1p2x) - p(l1p1x));
var dy1 = (p(l1p2y) - p(l1p1y));
var r2 = dx1 * dx1 + dy1 * dy1;
let dx1 = (p(l1p2x) - p(l1p1x));
let dy1 = (p(l1p2y) - p(l1p1y));
let r2 = dx1 * dx1 + dy1 * dy1;
out[l1p1x] = -dy1 / r2;
out[l1p1y] = dx1 / r2;
out[l1p2x] = dy1 / r2;
out[l1p2y] = -dx1 / r2;
dx1 = (p(l1p2x) - p(l1p1x));
dy1 = (p(l1p2y) - p(l1p1y));
var dx2 = (p(l2p2x) - p(l2p1x));
var dy2 = (p(l2p2y) - p(l2p1y));
var a = Math.atan2(dy1, dx1) + p(angle);
var ca = Math.cos(a);
var sa = Math.sin(a);
var x2 = dx2 * ca + dy2 * sa;
var y2 = -dx2 * sa + dy2 * ca;
let dx2 = (p(l2p2x) - p(l2p1x));
let dy2 = (p(l2p2y) - p(l2p1y));
let a = Math.atan2(dy1, dx1) + p(angle);
let ca = Math.cos(a);
let sa = Math.sin(a);
let x2 = dx2 * ca + dy2 * sa;
let y2 = -dx2 * sa + dy2 * ca;
r2 = dx2 * dx2 + dy2 * dy2;
dx2 = -y2 / r2;
dy2 = x2 / r2;
@ -782,7 +782,7 @@ function GreaterThan(params, limit) {
this.error = function() {
let value = this.params[0].get();
var error = value <= limit ? limit - value : 0;
let error = value <= limit ? limit - value : 0;
console.log("GreaterThan: " + error + ", value: " +value);
return error;
};
@ -809,7 +809,7 @@ export function NumericGradient(out) {
}
function _fixNaN(grad) {
for (var i = 0; i < grad.length; i++) {
for (let i = 0; i < grad.length; i++) {
if (isNaN(grad[i])) {
grad[i] = 0;
}
@ -817,7 +817,7 @@ function _fixNaN(grad) {
}
function rescale(grad, factor) {
for (var i = 0; i < grad.length; i++) {
for (let i = 0; i < grad.length; i++) {
grad[i] *= factor;
}
}

48
web/app/sketcher/constraints.js
View file

@ -128,7 +128,7 @@ Constraints.Parallel.prototype.NAME = 'parallel';
Constraints.Parallel.prototype.UI_NAME = 'Parallel';
Constraints.Parallel.prototype.getSolveData = function() {
var params = [];
let params = [];
this.l1.collectParams(params);
this.l2.collectParams(params);
return [[this.NAME, params, []]];
@ -158,7 +158,7 @@ Constraints.Perpendicular.prototype.NAME = 'perpendicular';
Constraints.Perpendicular.prototype.UI_NAME = 'Perpendicular';
Constraints.Perpendicular.prototype.getSolveData = function() {
var params = [];
let params = [];
this.l1.collectParams(params);
this.l2.collectParams(params);
return [[this.NAME, params, []]];
@ -190,7 +190,7 @@ Constraints.P2LDistanceSigned.prototype.NAME = 'P2LDistanceSigned';
Constraints.P2LDistanceSigned.prototype.UI_NAME = 'Distance P & L';
Constraints.P2LDistanceSigned.prototype.getSolveData = function(resolver) {
var params = [];
let params = [];
this.p.collectParams(params);
this.a.collectParams(params);
this.b.collectParams(params);
@ -228,7 +228,7 @@ Constraints.P2LDistance.prototype.NAME = 'P2LDistance';
Constraints.P2LDistance.prototype.UI_NAME = 'Distance P & L';
Constraints.P2LDistance.prototype.getSolveData = function(resolver) {
var params = [];
let params = [];
this.p.collectParams(params);
this.l.collectParams(params);
return [[this.NAME, params, [resolver(this.d)]]];
@ -262,7 +262,7 @@ Constraints.MinLength.prototype.NAME = 'MinLength';
Constraints.MinLength.prototype.UI_NAME = 'MinLength';
Constraints.MinLength.prototype.getSolveData = function() {
var params = [];
let params = [];
this.a.collectParams(params);
this.b.collectParams(params);
return [[this.NAME, params, [this.min]]];
@ -282,7 +282,7 @@ Constraints.P2LDistanceV.prototype.NAME = 'P2LDistanceV';
Constraints.P2LDistanceV.prototype.UI_NAME = 'Distance P & L';
Constraints.P2LDistanceV.prototype.getSolveData = function() {
var params = [];
let params = [];
this.p.collectParams(params);
this.l.collectParams(params);
params.push(this.d);
@ -312,7 +312,7 @@ Constraints.P2PDistance.prototype.NAME = 'P2PDistance';
Constraints.P2PDistance.prototype.UI_NAME = 'Distance Points';
Constraints.P2PDistance.prototype.getSolveData = function(resolver) {
var params = [];
let params = [];
this.p1.collectParams(params);
this.p2.collectParams(params);
return [[this.NAME, params, [resolver(this.d)]]];
@ -346,7 +346,7 @@ Constraints.P2PDistanceV.prototype.NAME = 'P2PDistanceV';
Constraints.P2PDistanceV.prototype.UI_NAME = 'Distance Points';
Constraints.P2PDistanceV.prototype.getSolveData = function() {
var params = [];
let params = [];
this.p1.collectParams(params);
this.p2.collectParams(params);
params.push(this.d);
@ -451,8 +451,8 @@ Constraints.LL.prototype.NAME = 'LL';
Constraints.LL.prototype.UI_NAME = 'Lines Equality';
Constraints.LL.prototype.getSolveData = function() {
var params1 = [];
var params2 = [];
let params1 = [];
let params2 = [];
this.line1.collectParams(params1);
this.line2.collectParams(params2);
params1.push(this.length);
@ -541,7 +541,7 @@ Constraints.Tangent.prototype.NAME = 'Tangent';
Constraints.Tangent.prototype.UI_NAME = 'Tangent';
Constraints.Tangent.prototype.getSolveData = function() {
var params = [];
let params = [];
this.arc.c.collectParams(params);
this.line.collectParams(params);
params.push(this.arc.r);
@ -610,7 +610,7 @@ Constraints.PointOnLine.prototype.NAME = 'PointOnLine';
Constraints.PointOnLine.prototype.UI_NAME = 'Point On Line';
Constraints.PointOnLine.prototype.getSolveData = function() {
var params = [];
let params = [];
this.point.collectParams(params);
this.line.collectParams(params);
return [['P2LDistance', params, [0]]];
@ -640,7 +640,7 @@ Constraints.PointOnArc.prototype.NAME = 'PointOnArc';
Constraints.PointOnArc.prototype.UI_NAME = 'Point On Arc';
Constraints.PointOnArc.prototype.getSolveData = function() {
var params = [];
let params = [];
this.point.collectParams(params);
this.arc.c.collectParams(params);
params.push(this.arc.r);
@ -701,7 +701,7 @@ Constraints.PointOnEllipseInternal.prototype.UI_NAME = 'Point On Ellipse';
Constraints.PointOnEllipseInternal.prototype.aux = true;
Constraints.PointOnEllipseInternal.prototype.getSolveData = function() {
var params = [];
let params = [];
this.point.collectParams(params);
this.ellipse.ep1.collectParams(params);
this.ellipse.ep2.collectParams(params);
@ -817,8 +817,8 @@ Constraints.PointInMiddle.prototype.NAME = 'PointInMiddle';
Constraints.PointInMiddle.prototype.UI_NAME = 'Point In the Middle';
Constraints.PointInMiddle.prototype.getSolveData = function() {
var params1 = [];
var params2 = [];
let params1 = [];
let params2 = [];
this.line.a.collectParams(params1);
this.point.collectParams(params1);
@ -859,8 +859,8 @@ Constraints.Symmetry.prototype.NAME = 'Symmetry';
Constraints.Symmetry.prototype.UI_NAME = 'Symmetry';
Constraints.Symmetry.prototype.getSolveData = function(resolver) {
var pointInMiddleData = Constraints.PointInMiddle.prototype.getSolveData.call(this, [resolver]);
var pointOnLineData = Constraints.PointOnLine.prototype.getSolveData.call(this, [resolver]);
let pointInMiddleData = Constraints.PointInMiddle.prototype.getSolveData.call(this, [resolver]);
let pointOnLineData = Constraints.PointOnLine.prototype.getSolveData.call(this, [resolver]);
return pointInMiddleData.concat(pointOnLineData);
};
@ -893,7 +893,7 @@ Constraints.Angle.prototype.UI_NAME = 'Lines Angle';
Constraints.Angle.prototype.getSolveData = function(resolver) {
this._angle.set(resolver(this.angle) / 180 * Math.PI);
var params = [];
let params = [];
this.p1.collectParams(params);
this.p2.collectParams(params);
this.p3.collectParams(params);
@ -911,7 +911,7 @@ Constraints.Factory[Constraints.Angle.prototype.NAME] = function(refs, data) {
};
Constraints.Angle.prototype.getObjects = function() {
var collector = new Constraints.ParentsCollector();
let collector = new Constraints.ParentsCollector();
collector.check(this.p1);
collector.check(this.p2);
collector.check(this.p3);
@ -934,7 +934,7 @@ Constraints.LockConvex.prototype.NAME = 'LockConvex';
Constraints.LockConvex.prototype.UI_NAME = 'Lock Convexity';
Constraints.LockConvex.prototype.getSolveData = function() {
var params = [];
let params = [];
this.c.collectParams(params);
this.a.collectParams(params);
this.t.collectParams(params);
@ -950,7 +950,7 @@ Constraints.Factory[Constraints.LockConvex.prototype.NAME] = function(refs, data
};
Constraints.LockConvex.prototype.getObjects = function() {
var collector = new Constraints.ParentsCollector();
let collector = new Constraints.ParentsCollector();
collector.check(this.c);
collector.check(this.a);
collector.check(this.t);
@ -1114,8 +1114,8 @@ Constraints.Fillet.prototype.validate = function() {
Constraints.ParentsCollector = function() {
this.parents = [];
var parents = this.parents;
var index = {};
let parents = this.parents;
let index = {};
function add(obj) {
if (index[obj.id] === undefined) {
index[obj.id] = obj;

40
web/app/sketcher/fetchers.js
View file

@ -1,6 +1,6 @@
export function twoPoints(objs) {
var points = [];
for (var i = 0; i < objs.length; ++i) {
let points = [];
for (let i = 0; i < objs.length; ++i) {
if (objs[i]._class == 'TCAD.TWO.EndPoint') {
points.push(objs[i]);
} else if (objs[i]._class == 'TCAD.TWO.Segment') {
@ -15,8 +15,8 @@ export function twoPoints(objs) {
}
export function points(objs) {
var points = [];
for (var i = 0; i < objs.length; ++i) {
let points = [];
for (let i = 0; i < objs.length; ++i) {
objs[i].accept(function(o) {
if (o._class === 'TCAD.TWO.EndPoint') {
points.push(o);
@ -31,8 +31,8 @@ export function points(objs) {
}
export function arkCirc(objs, min) {
var arcs = [];
for (var i = 0; i < objs.length; ++i) {
let arcs = [];
for (let i = 0; i < objs.length; ++i) {
if (objs[i]._class === 'TCAD.TWO.Arc' || objs[i]._class === 'TCAD.TWO.Circle') {
arcs.push(objs[i]);
}
@ -44,8 +44,8 @@ export function arkCirc(objs, min) {
}
export function generic(objs, types, min) {
var result = [];
for (var i = 0; i < objs.length; ++i) {
let result = [];
for (let i = 0; i < objs.length; ++i) {
if (types.indexOf(objs[i]._class) > -1 ) {
result.push(objs[i]);
}
@ -58,10 +58,10 @@ export function generic(objs, types, min) {
export function pointAndLine(objs) {
var point = null;
var line = null;
let point = null;
let line = null;
for (var i = 0; i < objs.length; ++i) {
for (let i = 0; i < objs.length; ++i) {
if (objs[i]._class == 'TCAD.TWO.EndPoint') {
point = objs[i];
} else if (objs[i]._class == 'TCAD.TWO.Segment') {
@ -76,7 +76,7 @@ export function pointAndLine(objs) {
}
export function line(objs) {
for (var i = 0; i < objs.length; ++i) {
for (let i = 0; i < objs.length; ++i) {
if (objs[i]._class == 'TCAD.TWO.Segment') {
return objs[i];
}
@ -90,10 +90,10 @@ export function lines(objs) {
export function arcCircAndLine(objs) {
var arc = null;
var line = null;
let arc = null;
let line = null;
for (var i = 0; i < objs.length; ++i) {
for (let i = 0; i < objs.length; ++i) {
if (objs[i]._class === 'TCAD.TWO.Arc' || objs[i]._class === 'TCAD.TWO.Circle') {
arc = objs[i];
} else if (objs[i]._class == 'TCAD.TWO.Segment') {
@ -108,8 +108,8 @@ export function arcCircAndLine(objs) {
}
export function twoLines(objs) {
var lines = [];
for (var i = 0; i < objs.length; ++i) {
let lines = [];
for (let i = 0; i < objs.length; ++i) {
if (objs[i]._class == 'TCAD.TWO.Segment') {
lines.push(objs[i]);
}
@ -121,9 +121,9 @@ export function twoLines(objs) {
}
export function sketchObjects(objs, silent, matching) {
var fetched = [];
for (var i = 0; i < objs.length; ++i) {
for (var j = 0; j < matching.length; j++) {
let fetched = [];
for (let i = 0; i < objs.length; ++i) {
for (let j = 0; j < matching.length; j++) {
if (objs[i]._class == matching[j]) {
fetched[j] = objs[i];
matching[j] = null;

24
web/app/sketcher/history.js
View file

@ -14,17 +14,17 @@ HistoryManager.prototype.init = function(sketchData) {
};
HistoryManager.prototype.undo = function () {
var currentState = this.viewer.io.serializeSketch();
let currentState = this.viewer.io.serializeSketch();
if (currentState == this.lastCheckpoint) {
if (this.historyPointer != -1) {
var diff = this.diffs[this.historyPointer];
let diff = this.diffs[this.historyPointer];
this.lastCheckpoint = this.applyDiff(this.lastCheckpoint, diff);
this.viewer.io.loadSketch(this.lastCheckpoint);
this.viewer.fullHeavyUIRefresh();
this.historyPointer --;
}
} else {
var diffToCurr = this.getDiff(currentState, this.lastCheckpoint);
let diffToCurr = this.getDiff(currentState, this.lastCheckpoint);
if (this.historyPointer != this.diffs.length - 1) {
this.diffs.splice(this.historyPointer + 1, this.diffs.length - this.historyPointer + 1)
}
@ -51,11 +51,11 @@ HistoryManager.prototype.checkpoint = function () {
HistoryManager.prototype._checkpoint = function () {
this._counter = 0;
var currentState = this.viewer.io.serializeSketch();
let currentState = this.viewer.io.serializeSketch();
if (currentState == this.lastCheckpoint) {
return;
}
var diffToCurr = this.getDiff(currentState, this.lastCheckpoint);
let diffToCurr = this.getDiff(currentState, this.lastCheckpoint);
if (this.historyPointer != this.diffs.length - 1) {
this.diffs.splice(this.historyPointer + 1, this.diffs.length - this.historyPointer + 1)
}
@ -65,13 +65,13 @@ HistoryManager.prototype._checkpoint = function () {
};
HistoryManager.prototype.redo = function () {
var currentState = this.viewer.io.serializeSketch();
let currentState = this.viewer.io.serializeSketch();
if (currentState != this.lastCheckpoint) {
return;
}
if (this.historyPointer != this.diffs.length - 1 && this.diffs.length != 0) {
this.historyPointer ++;
var diff = this.diffs[this.historyPointer];
let diff = this.diffs[this.historyPointer];
this.lastCheckpoint = this.applyDiffInv(this.lastCheckpoint, diff);
this.viewer.io.loadSketch(this.lastCheckpoint);
this.viewer.fullHeavyUIRefresh();
@ -86,16 +86,16 @@ HistoryManager.prototype.applyDiff = function (text1, diff) {
HistoryManager.prototype.applyDiffInv = function (text1, diff) {
this.reversePatch(diff);
var result = this.applyDiff(text1, diff);
let result = this.applyDiff(text1, diff);
this.reversePatch(diff);
return result;
};
HistoryManager.prototype.reversePatch = function (plist) {
for (var i = 0; i < plist.length; i++) {
var patch = plist[i];
for (var j = 0; j < patch.diffs.length; j++) {
var diff = patch.diffs[j];
for (let i = 0; i < plist.length; i++) {
let patch = plist[i];
for (let j = 0; j < patch.diffs.length; j++) {
let diff = patch.diffs[j];
diff[0] *= -1;
}
}

4
web/app/sketcher/shapes/basis-origin.js
View file

@ -34,8 +34,8 @@ export class BasisOrigin extends Shape {
ctx.lineWidth = 1;
ctx.strokeStyle = this.yColor;
var headA = 1;
var headB = 10;
let headA = 1;
let headB = 10;
ctx.moveTo(0.5, 0);
ctx.lineTo(0.5, - this.lineWidth);

2
web/app/sketcher/shapes/cross-hair.js
View file

@ -11,7 +11,7 @@ export class CrossHair extends Shape {
draw(ctx, scale) {
ctx.beginPath();
var rad = this.rad / scale;
let rad = this.rad / scale;
ctx.moveTo(this.x - rad, this.y);
ctx.lineTo(this.x + rad, this.y);
ctx.closePath();

2
web/app/sketcher/shapes/dim.js
View file

@ -142,7 +142,7 @@ export class LinearDimension extends Dimension {
function drawRef(start, x, y) {
var vec = new Vector(x - start.x, y - start.y);
let vec = new Vector(x - start.x, y - start.y);
vec._normalize();
vec._multiply(EXT_LINEAR_WIDTH_PX * unscale);

2
web/app/sketcher/tools/arc.js
View file

@ -17,7 +17,7 @@ export class AddArcTool extends Tool {
}
mousemove(e) {
var p = this.viewer.screenToModel(e);
let p = this.viewer.screenToModel(e);
if (this.point != null) {
this.point.x = p.x;
this.point.y = p.y;

4
web/app/sketcher/tools/circle.js
View file

@ -17,9 +17,9 @@ export class EditCircleTool extends Tool {
}
mousemove(e) {
var p = this.viewer.screenToModel(e);
let p = this.viewer.screenToModel(e);
if (this.circle != null) {
var r = distance(p.x, p.y, this.circle.c.x, this.circle.c.y);
let r = distance(p.x, p.y, this.circle.c.x, this.circle.c.y);
this.circle.r.set(r);
if (!Tool.dumbMode(e)) {
this.solveRequest(true);

6
web/app/sketcher/tools/dim.js
View file

@ -26,7 +26,7 @@ export class AddDimTool extends Tool {
}
mousemove(e) {
var p = this.viewer.screenToModel(e);
let p = this.viewer.screenToModel(e);
this.viewer.snap(p.x, p.y, []);
if (this.dim != null) {
this.dim.b.x = p.x;
@ -100,8 +100,8 @@ export class AddCircleDimTool extends Tool {
}
mousemove(e) {
var p = this.viewer.screenToModel(e);
var objects = this.viewer.search(p.x, p.y, DEFAULT_SEARCH_BUFFER, true, false, []).filter(function (o) {
let p = this.viewer.screenToModel(e);
let objects = this.viewer.search(p.x, p.y, DEFAULT_SEARCH_BUFFER, true, false, []).filter(function (o) {
return o.TYPE === 'Circle' || o.TYPE === 'Arc';
});

6
web/app/sketcher/tools/fillet.js
View file

@ -95,7 +95,7 @@ export class FilletTool extends Tool {
}
mouseup(e) {
var candi = this.getCandidate(e);
let candi = this.getCandidate(e);
if (candi == null) return;
const point1 = candi[0];
const point2 = candi[1];
@ -157,12 +157,12 @@ export class FilletTool extends Tool {
}
mousemove(e) {
var needRefresh = false;
let needRefresh = false;
if (this.viewer.captured.tool.length !== 0) {
this.viewer.withdrawAll('tool');
needRefresh = true;
}
var candi = this.getCandidate(e);
let candi = this.getCandidate(e);
if (candi != null) {
this.viewer.capture('tool', [candi[0]], true);
needRefresh = true;

2
web/app/sketcher/tools/loop-pick.js
View file

@ -80,7 +80,7 @@ export class LoopPickTool extends Tool {
cleanLoop(loop) {
const points = [];
const edges = [];
for (var i = 0; i < loop.length; i++) {
for (let i = 0; i < loop.length; i++) {
const a = loop[i];
const b = loop[(i + 1) % loop.length];
if (a.parent == b.parent) {

2
web/app/sketcher/tools/origin.js
View file

@ -15,7 +15,7 @@ export class ReferencePointTool extends Tool {
}
mousemove(e) {
var p = this.viewer.screenToModel(e);
let p = this.viewer.screenToModel(e);
this.viewer.snap(p.x, p.y, []);
this.viewer.refresh();
}

48
web/app/utils/graph.js
View file

@ -18,10 +18,10 @@ function Graph(data) {
Graph.findAllLoops = function(graph, hashCode, equals) {
var loops = [];
var visited = new HashTable(hashCode, equals);
let loops = [];
let visited = new HashTable(hashCode, equals);
function step(vertex, comesFrom, path) {
var i;
let i;
visited.put(vertex, true);
for (i = path.length - 1; i >= 0; --i) {
if (equals(vertex, path[i])) {
@ -30,18 +30,18 @@ Graph.findAllLoops = function(graph, hashCode, equals) {
}
}
var next = graph.connections(vertex);
let next = graph.connections(vertex);
path.push(vertex);
var needClone = false;
let needClone = false;
for (i = 0; i < next.length; i++) {
var v = next[i];
let v = next[i];
if (equals(v, comesFrom)) {
continue;
}
var p = needClone ? path.slice(0) : path;
let p = needClone ? path.slice(0) : path;
needClone = true;
step(v, vertex, p);
}
@ -49,7 +49,7 @@ Graph.findAllLoops = function(graph, hashCode, equals) {
}
for (i = 0; i < graph.size(); i++) {
var vertex = graph.at(i);
let vertex = graph.at(i);
if (visited.get(vertex) !== true) {
step(vertex, -1, []);
}
@ -58,7 +58,7 @@ Graph.findAllLoops = function(graph, hashCode, equals) {
//filter duplicates
function sameLoop(a, b) {
var first = a[0];
let first = a[0];
for (var bShift = 0; bShift < a.length; bShift++) {
if (equals(b[bShift], first)) {
break;
@ -67,14 +67,14 @@ Graph.findAllLoops = function(graph, hashCode, equals) {
if (bShift == a.length) {
return false;
}
for (var i = 0; i < a.length; i++) {
var bUp = (bShift + i) % a.length;
var bDown = bShift - i;
for (let i = 0; i < a.length; i++) {
let bUp = (bShift + i) % a.length;
let bDown = bShift - i;
if (bDown < 0) {
bDown = a.length + bDown;
}
// console.log("up: " + bUp + "; down: " + bDown);
var curr = a[i];
let curr = a[i];
if ( !equals(curr, b[bUp]) && !equals(curr, b[bDown]) ) {
return false;
}
@ -82,12 +82,12 @@ Graph.findAllLoops = function(graph, hashCode, equals) {
return true;
}
var i, duplicates = 0;
let i, duplicates = 0;
for (i = 0; i < loops.length; i++) {
var a = loops[i];
let a = loops[i];
if (a == null) continue;
for (var j = i + 1; j < loops.length; j++) {
var b = loops[j];
for (let j = i + 1; j < loops.length; j++) {
let b = loops[j];
if (b == null || a.length !== b.length) {
continue;
}
@ -98,7 +98,7 @@ Graph.findAllLoops = function(graph, hashCode, equals) {
}
}
if (duplicates != 0) {
var filtered = [];
let filtered = [];
for (i = 0; i < loops.length; i++) {
if (loops[i] != null) filtered.push(loops[i]);
}
@ -109,8 +109,8 @@ Graph.findAllLoops = function(graph, hashCode, equals) {
};
var test = function() {
var data = [
let test = function() {
let data = [
[],
[2],
[1, 3, 9],
@ -123,12 +123,12 @@ var test = function() {
[2, 4]
];
var graph = new Graph(data);
let graph = new Graph(data);
console.log(Graph.findAllLoops(graph));
};
var test0 = function() {
var data = [
let test0 = function() {
let data = [
[3, 1],
[0, 2, 8],
[1, 3, 7, 5],
@ -140,7 +140,7 @@ var test0 = function() {
[1, 7]
];
var graph = new Graph(data);
let graph = new Graph(data);
console.log(Graph.findAllLoops(graph));
};

56
web/app/utils/hashmap.js
View file

@ -10,7 +10,7 @@ HashTable.prototype.hash = function(key) {
};
HashTable.prototype.get = function(key) {
var entry = this._findEntry(key, this._findBucket(key));
let entry = this._findEntry(key, this._findBucket(key));
if (entry == null) return null;
return entry[1];
};
@ -23,8 +23,8 @@ HashTable.prototype.put = function(key, value) {
};
HashTable.prototype._findBucket = function(key) {
var hash = this.hash(key);
var bucket = this.table[hash];
let hash = this.hash(key);
let bucket = this.table[hash];
if (bucket === null) {
bucket = [];
this.table[hash] = bucket;
@ -33,7 +33,7 @@ HashTable.prototype._findBucket = function(key) {
};
HashTable.prototype._findEntry = function(key, bucket) {
for (var i = 0; i < bucket.length; i++) {
for (let i = 0; i < bucket.length; i++) {
if (this.equalsF(bucket[i][0], key)) {
return bucket[i];
}
@ -42,8 +42,8 @@ HashTable.prototype._findEntry = function(key, bucket) {
};
HashTable.prototype._put = function(key, value) {
var bucket = this._findBucket(key);
var entry = this._findEntry(key, bucket);
let bucket = this._findBucket(key);
let entry = this._findEntry(key, bucket);
if (entry == null) {
bucket.push([key, value]);
} else {
@ -54,13 +54,13 @@ HashTable.prototype._put = function(key, value) {
HashTable.prototype.rebuild = function() {
this.size = 0;
var oldTable = this.table;
let oldTable = this.table;
this.setTableSize(this.table.length * 2);
for (var i = 0; i < oldTable.length; i++) {
var e = oldTable[i];
for (let i = 0; i < oldTable.length; i++) {
let e = oldTable[i];
if (e != null) {
for (var j = 0; j < e.length; j++) {
var bucket = e[j];
for (let j = 0; j < e.length; j++) {
let bucket = e[j];
this._put(bucket[0], bucket[1]);
}
}
@ -68,7 +68,7 @@ HashTable.prototype.rebuild = function() {
};
HashTable.prototype.getKeys = function() {
var keys = [];
let keys = [];
this.entries(function(k) {
keys.push(k)
});
@ -76,11 +76,11 @@ HashTable.prototype.getKeys = function() {
};
HashTable.prototype.entries = function(callback) {
for (var i = 0; i < this.table.length; i++) {
var e = this.table[i];
for (let i = 0; i < this.table.length; i++) {
let e = this.table[i];
if (e != null) {
for (var j = 0; j < e.length; j++) {
var bucket = e[j];
for (let j = 0; j < e.length; j++) {
let bucket = e[j];
callback(bucket[0], bucket[1]);
}
}
@ -89,7 +89,7 @@ HashTable.prototype.entries = function(callback) {
HashTable.prototype.setTableSize = function(newSize) {
this.table = [];
for (var i = 0; i < newSize; i++) {
for (let i = 0; i < newSize; i++) {
this.table[i] = null;
}
};
@ -104,7 +104,7 @@ DoubleHelper.prototype.hash = function(v) {
};
HashTable.forVector3d = function() {
var doubleHelper = new DoubleHelper();
let doubleHelper = new DoubleHelper();
function hash(v) {
return doubleHelper.hash(v.x) ^ doubleHelper.hash(v.y) ^ doubleHelper.hash(v.z);
}
@ -115,7 +115,7 @@ HashTable.forVector3d = function() {
};
HashTable.forEdge = function() {
var doubleHelper = new DoubleHelper();
let doubleHelper = new DoubleHelper();
function hash(v) {
return doubleHelper.hash(v[0].x) ^ doubleHelper.hash(v[0].y) ^ doubleHelper.hash(v[0].z)
^doubleHelper.hash(v[1].x) ^ doubleHelper.hash(v[1].y) ^ doubleHelper.hash(v[1].z);
@ -124,17 +124,17 @@ HashTable.forEdge = function() {
return a.x === b.x && a.y === b.y && a.z === b.z;
}
function eq(e1, e2) {
var a1 = e1[0];
var b1 = e1[1];
var a2 = e2[0];
var b2 = e2[1];
let a1 = e1[0];
let b1 = e1[1];
let a2 = e2[0];
let b2 = e2[1];
return (veq(a1, a2) && veq(b1, b2)) || (veq(a1, b2) && veq(b1, a2));
}
return new HashTable(hash, eq);
};
HashTable.forVector2d = function() {
var doubleHelper = new DoubleHelper();
let doubleHelper = new DoubleHelper();
function hash(v) {
return doubleHelper.hash(v.x) ^ doubleHelper.hash(v.y) ;
}
@ -145,16 +145,16 @@ HashTable.forVector2d = function() {
};
HashTable.forDoubleArray = function() {
var doubleHelper = new DoubleHelper();
let doubleHelper = new DoubleHelper();
function hash(v) {
var hash = 0;
for (var i = 0; i < v.length; i++) {
let hash = 0;
for (let i = 0; i < v.length; i++) {
hash ^= v[i];
}
return hash;
}
function eq(a, b) {
for (var i = 0; i < a.length; i++) {
for (let i = 0; i < a.length; i++) {
if (a[i] !== b[i]) return false;
}
return true;

4
web/app/utils/utils.js
View file

@ -1,8 +1,8 @@
export function askNumber(promptText, initValue, promptCallback, resolver) {
var promptValueStr = promptCallback(promptText, initValue);
let promptValueStr = promptCallback(promptText, initValue);
if (promptValueStr != null) {
var promptValue = Number(promptValueStr);
let promptValue = Number(promptValueStr);
if (promptValue == promptValue) { // check for NaN
return promptValue;
} else {