Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
// // create geometry
for(let i = 0; i < entity.vertices.length; i++) {
if(entity.vertices[i].bulge) {
//TODO: Figure out what to do with the bugle value
bulge = entity.vertices[i].bulge;
startPoint = entity.vertices[i];
endPoint = (i + 1 < entity.vertices.length) ? entity.vertices[i + 1] : geometry.vertices[0];
console.log("Start Point:", startPoint);
console.log("End Point:", endPoint);
} else {
let vertex = entity.vertices[i];
let nextvertex = entity.vertices[(i + 1 < entity.vertices.length) ? i + 1 : 0];
let point = new paper.Point(vertex.x * 1000, vertex.y * 1000); //Need to convert everything to microns
let nextpoint = new paper.Point(nextvertex.x * 1000, nextvertex.y * 1000);
// console.log("Vertex:", point, nextpoint);
let line = new paper.Path.Line(point, nextpoint);
path.addChild(line);
}
}
}
// After matrix mapping, we get u1 and v1. Let Θ be the angle between u1 and v1.
// Then the final scale we want is:
//
// Math.min(|u1|sin(Θ),|v1|sin(Θ)) = |u1||v1|sin(Θ) / Math.max(|u1|,|v1|)
//
// If Math.max(|u1|,|v1|) = 0, that means either x or y has a scale of 0.
//
// For the non-skew case, which is most of the cases, matrix scale is
// computing exactly the scale on x and y axis, and take the minimal of these two.
//
// For the skew case, an unit square will mapped to a parallelogram,
// and this function will return the minimal height of the 2 bases.
const { matrix } = paper.project.activeLayer;
const m = new paper.Matrix(matrix.a, matrix.b, matrix.c, matrix.d, 0, 0);
const u0 = new paper.Point(0, 1);
const v0 = new paper.Point(1, 0);
const u1 = u0.transform(m);
const v1 = v0.transform(m);
const sx = Math.hypot(u1.x, u1.y);
const sy = Math.hypot(v1.x, v1.y);
const dotProduct = u1.y * v1.x - u1.x * v1.y;
const maxScale = Math.max(sx, sy);
return maxScale > 0 ? Math.abs(dotProduct) / maxScale : 0;
}
__drawFlow(params){
let position = params["position"];
let gap = params["gap"];
let radius = params["valveRadius"];
let color = params["color"];
let orientation = params["orientation"];
let rotation = params["rotation"];
let center = new paper.Point(position[0], position[1]);
// let h0p0, h0p1, h0p2, h1p0, h1p1, h1p2;
let circ = new paper.Path.Circle(center, radius);
//circ.fillColor = color;
// if (String(color) == "3F51B5") {
let cutout = paper.Path.Rectangle({
from: new paper.Point(position[0] - radius, position[1] - gap / 2),
to: new paper.Point(position[0] + radius, position[1] + gap / 2)
});
//cutout.fillColor = "white";
let valve = circ.subtract(cutout);
valve.rotate(rotation, center);
valve.fillColor = color;
return valve;
}
let innercirc = new paper.Path.Circle(center, radius);
let outercirc = new paper.Path.Circle(center, radius + flowchannelwidth);
let rotary = outercirc.subtract(innercirc);
rotarymixer.addChild(rotary);
let point1 = new paper.Point(px, py - radius - flowchannelwidth);
let point2 = new paper.Point(px + channellength, py - radius);
let rectangle = new paper.Path.Rectangle(point1, point2);
rotarymixer.addChild(rectangle);
let point3 = new paper.Point(px-channellength, py + radius);
let point4 = new paper.Point(px, py + radius + flowchannelwidth);
let rectangle2 = new paper.Path.Rectangle(point3, point4);
rotarymixer.addChild(rectangle2);
let rotation = 0;
if (orientation == "V") {
rotation = 90;
}
else {
rotation = 0;
}
// cutout.fillColor = "white";
rotarymixer.fillColor = color;
return rotarymixer.rotate(rotation, px, py);
//Draw 2 leafs
//left leaf
let lstartx = px - 0.5 * (cw + spacing);
let lendx = lstartx + cw;
let lstarty = py + stagelength + cw;
let lendy = lstarty + stagelength;
// //right leaf
let rstartx = px + 0.5 * (spacing - cw);
let rendx = rstartx + cw;
let rstarty = py + stagelength + cw;
let rendy = rstarty + stagelength;
if(drawleafs){
startPoint = new paper.Point(lstartx, lstarty);
endPoint = new paper.Point(lendx, lendy);
rec = paper.Path.Rectangle({
from: startPoint,
to: endPoint,
radius: 0,
strokeWidth: 0
});
treepath.addChild(rec);
startPoint = new paper.Point(rstartx, rstarty);
endPoint = new paper.Point(rendx, rendy);
rec = paper.Path.Rectangle({
from: startPoint,
to: endPoint,
radius: 0,
strokeWidth: 0
let rstarty = py + stagelength + cw;
let rendy = rstarty + stagelength;
if(drawleafs){
startPoint = new paper.Point(lstartx, lstarty);
endPoint = new paper.Point(lendx, lendy);
rec = paper.Path.Rectangle({
from: startPoint,
to: endPoint,
radius: 0,
strokeWidth: 0
});
treepath.addChild(rec);
startPoint = new paper.Point(rstartx, rstarty);
endPoint = new paper.Point(rendx, rendy);
rec = paper.Path.Rectangle({
from: startPoint,
to: endPoint,
radius: 0,
strokeWidth: 0
});
treepath.addChild(rec);
}
//Horizontal bar
let hstartx = px - 0.5 * (cw + spacing);
let hendx = rendx;
let hstarty = py + stagelength;
let hendy = hstarty + cw;
function calculateBulgeThroughPoint(startpoint, endpoint, bulgevalue) {
let throughpoint = 0;
let start = new paper.Point(startpoint.x, startpoint.y);
let end = new paper.Point(endpoint.x, endpoint.y);
let angle = 4 * Math.atan(bulgevalue);
/*
https://math.stackexchange.com/questions/9365/endpoint-of-a-line-knowing-slope-start-and-distance
*/
let epsilon = angle/4;
let midpoint = new paper.Point(startpoint.x/2 + endpoint.x/2,
startpoint.y/2 + endpoint.y/2);
let p = new paper.Point(startpoint.x, startpoint.y).getDistance(midpoint) * bulgevalue;
let slope = (endpoint.y - startpoint.y)/(endpoint.x - startpoint.x);
let chordvector = end.subtract(start);
radius: 0
});
rendered.addChild(rec);
}
let topchannel = new paper.Path.Rectangle({
point: new paper.Point(px, py - w),
size:[ (numArray )*(w) + (numArray+1) * spacing, w],
});
rendered.addChild(topchannel);
let bottomchannel = new paper.Path.Rectangle({
point: new paper.Point(px, py + l),
size:[ (numArray )*(w) + (numArray+1) * spacing, w],
});
rendered.addChild(bottomchannel);
rendered.fillColor = color;
return rendered.rotate(rotation, px, py);
}
let rec;
for(let i = 0; i < numArray; i++){
rec = new paper.Path.Rectangle({
point: new paper.Point(px + (i+1)*spacing + i*w, py-1),
size: [w, l +2],
radius: 0
});
rendered.addChild(rec);
}
let topchannel = new paper.Path.Rectangle({
point: new paper.Point(px, py - w),
size:[ (numArray )*(w) + (numArray+1) * spacing, w],
});
rendered.addChild(topchannel);
let bottomchannel = new paper.Path.Rectangle({
point: new paper.Point(px, py + l),
size:[ (numArray )*(w) + (numArray+1) * spacing, w],
});
rendered.addChild(bottomchannel);
rendered.fillColor = color;
return rendered.rotate(rotation, px, py);
}
function calculateBulgeThroughPoint(startpoint, endpoint, bulgevalue) {
let throughpoint = 0;
let start = new paper.Point(startpoint.x, startpoint.y);
let end = new paper.Point(endpoint.x, endpoint.y);
let angle = 4 * Math.atan(bulgevalue);
/*
https://math.stackexchange.com/questions/9365/endpoint-of-a-line-knowing-slope-start-and-distance
*/
let epsilon = angle/4;
let midpoint = new paper.Point(startpoint.x/2 + endpoint.x/2,
startpoint.y/2 + endpoint.y/2);
let p = new paper.Point(startpoint.x, startpoint.y).getDistance(midpoint) * bulgevalue;
let slope = (endpoint.y - startpoint.y)/(endpoint.x - startpoint.x);