31:T566,calcContoursForLayerSegment = (segments, segIdx) => { if (segments.length === 0) { return []; } let contours = []; // NOTE: define a contour as an ordered list of points let currContour = []; let unvisitedSegments = segments.slice(); let currSegment = unvisitedSegments[0]; let pointToPush = currSegment[0]; let pointForFindingNextSeg = currSegment[1]; while (unvisitedSegments.length > 0) { currContour.push(pointToPush); unvisitedSegments.splice(unvisitedSegments.indexOf(currSegment), 1); let foundNextSegment = unvisitedSegments.some((potentialSegment) => { if (potentialSegment[0].approxEqual(pointForFindingNextSeg)) { currSegment = potentialSegment; pointToPush = potentialSegment[0]; pointForFindingNextSeg = potentialSegment[1]; return true; } if (potentialSegment[1].approxEqual(pointForFindingNextSeg)) { currSegment = potentialSegment; pointToPush = potentialSegment[1]; pointForFindingNextSeg = potentialSegment[0]; return true; } }); if (!foundNextSegment) { contours.push(currContour.slice()); currContour = []; if (unvisitedSegments.length > 0) { currSegment = unvisitedSegments[0]; pointToPush = currSegment[0]; pointForFindingNextSeg = currSegment[1]; } } } return contours; }32:T1888,class Slicer { constructor(kvs) { this._layerHeight = kvs.layerHeight; this._infill = kvs.infill; } get layerHeight() { return this._layerHeight; } get infill() { return this.infill; } slice(mesh) { let nonBufferGeometry = mesh.geometry; let triangleOnPlane = (v0, v1, v2, plane) => { let tEps = 0.001; let v0_dist_to_plane = plane.distanceToPoint(v0); let v1_dist_to_plane = plane.distanceToPoint(v1); let v2_dist_to_plane = plane.distanceToPoint(v2); return ( v0_dist_to_plane < tEps && v1_dist_to_plane < tEps && v2_dist_to_plane < tEps ); }; let segmentOnPlane = (v0, v1, plane) => { let tEps = 0.00001; let v0_dist_to_plane = Math.abs(plane.distanceToPoint(v0)); let v1_dist_to_plane = Math.abs(plane.distanceToPoint(v1)); return v0_dist_to_plane < tEps && v1_dist_to_plane < tEps; }; /* Returns intersection point, two points, or undefined if no intersection */ let segmentPlaneIntersect = (v0, v1, plane) => { let tEps = 0.00001; let v0_dist_to_plane = plane.distanceToPoint(v0); let v1_dist_to_plane = plane.distanceToPoint(v1); let pointIntersect = v0_dist_to_plane * v1_dist_to_plane < 0; let segmentIntersect = v0_dist_to_plane < tEps && v1_dist_to_plane < tEps; if (false) { return [v0, v1]; } else if (pointIntersect) { // NOTE: isect = v0 + t * (v1 - v0) let denom = v0_dist_to_plane - v1_dist_to_plane; if (Math.abs(denom) < tEps) { return v0.clone(); } let t = v0_dist_to_plane / denom; let isect = new THREE.Vector3().copy(v0); let rest = new THREE.Vector3().copy(v1).sub(v0).multiplyScalar(t); return isect.add(rest); } }; let calcSegmentsForPlane = (plane) => { let isectSegments = []; let i = 0; let vCoords = nonBufferGeometry.attributes.position.array; if (vCoords.length % 9 !== 0) { throw Error( "The number of vertex coordinates should be a multiple of 9." ); } vCoords.forEach((_, i) => { if (i % 9 !== 0) { return; } let v0 = new THREE.Vector3( vCoords[i + 0], vCoords[i + 1], vCoords[i + 2] ); let v1 = new THREE.Vector3( vCoords[i + 3], vCoords[i + 4], vCoords[i + 5] ); let v2 = new THREE.Vector3( vCoords[i + 6], vCoords[i + 7], vCoords[i + 8] ); // First check if the entire triangle is on the plane. // If yes, ignore it for now. if (triangleOnPlane(v0, v1, v2, xzPlane)) { return; } // Then check if any of the segments are actually on the plane. // If a segment lies coplanar, but it's not the case that the // entire triangle be on the plane, we can just push the coplanar // segment and return. if (segmentOnPlane(v0, v1, xzPlane)) { isectSegments.push([v0, v1]); return; } else if (segmentOnPlane(v1, v2, xzPlane)) { isectSegments.push([v1, v2]); return; } else if (segmentOnPlane(v2, v0, xzPlane)) { isectSegments.push([v2, v0]); return; } // Otherwise, check for segment-plane intersections and push those. let isect01 = segmentPlaneIntersect(v0, v1, xzPlane); let isect12 = segmentPlaneIntersect(v1, v2, xzPlane); let isect20 = segmentPlaneIntersect(v2, v0, xzPlane); if (isect01 !== undefined && isect12 !== undefined) { isectSegments.push([isect01, isect12]); } else if (isect01 !== undefined && isect20 !== undefined) { isectSegments.push([isect01, isect20]); } else if (isect12 !== undefined && isect20 !== undefined) { isectSegments.push([isect12, isect20]); } }); return isectSegments; }; let calcContoursForLayerSegment = (segments, segIdx) => { if (segments.length === 0) { return []; } let contours = []; // NOTE: define a contour as an ordered list of points let currContour = []; let unvisitedSegments = segments.slice(); let currSegment = unvisitedSegments[0]; let pointToPush = currSegment[0]; let pointForFindingNextSeg = currSegment[1]; while (unvisitedSegments.length > 0) { currContour.push(pointToPush); unvisitedSegments.splice(unvisitedSegments.indexOf(currSegment), 1); let foundNextSegment = unvisitedSegments.some((potentialSegment) => { if (potentialSegment[0].approxEqual(pointForFindingNextSeg)) { currSegment = potentialSegment; pointToPush = potentialSegment[0]; pointForFindingNextSeg = potentialSegment[1]; return true; } if (potentialSegment[1].approxEqual(pointForFindingNextSeg)) { currSegment = potentialSegment; pointToPush = potentialSegment[1]; pointForFindingNextSeg = potentialSegment[0]; return true; } }); if (!foundNextSegment) { contours.push(currContour.slice()); currContour = []; if (unvisitedSegments.length > 0) { currSegment = unvisitedSegments[0]; pointToPush = currSegment[0]; pointForFindingNextSeg = currSegment[1]; } } } return contours; }; const eps = 0.001; nonBufferGeometry.computeBoundingBox(); let planeHeight = nonBufferGeometry.boundingBox.min.y + eps; let maxHeight = nonBufferGeometry.boundingBox.max.y - eps; let xzPlane, segments, layerContours; let contoursPerLayer = []; while (planeHeight <= maxHeight) { // NOTE: constant should be negative because plane -> origin distance // is downward xzPlane = new THREE.Plane(new THREE.Vector3(0, 1, 0), -planeHeight); segments = calcSegmentsForPlane(xzPlane); layerContours = calcContoursForLayerSegment(segments); contoursPerLayer.push(layerContours); planeHeight += this.layerHeight; } return contoursPerLayer; } }33:T477,- **`G1`**: The (operation) code, which in this case indicates a linear move. The following tokens are all arguments for this operation code. - **`X10 Y20 Z30`**: Each argument starts with a letter, in this case, the name of the axis, followed by a numerical value which here represents **_either_** the location at which the line ends if the coordinate system has been set to `absolute` by a previous instruction **_or_** the location relative to the starting point if the coordinate system has been set to `relative`. For the purposes of this article, we will use absolute coordinates for X, Y, and Z, but not for the following argument below. - **`E1.0`**: Means move the 1mm of filament through the nozzle, which is not a useful way of thinking about the amount of material to be extruded from the nozzle, but is an artifact of how G-Code works. We will assume relative coordinates for the E-axis. - **`F1000`**: Means perform this instruction at a rate of 1000 mm/sec, although the G-Code firmware on the printer could add acceleration and deceleration to the move that are controllable only by changing settings or at the hardware level.34:T57d,function sliceLayersToInsts(sliceLayers) { let round = (n) => Math.floor(n * 10000) / 10000; const extrusionMultiplier = 0.2; const defaultExtrusion = 1.5; const retractDefault = 0.2; const layerFeed = 1000; const filamentHeight = 0.4; return sliceLayers .map((layer) => { let contourInsts = layer.map((contour) => { let firstPt = contour[0]; let travelToStart = `G0 X${round(firstPt.x)} Y${round( firstPt.z )} Z${round(firstPt.y)} E0 F${layerFeed}`; let insts = []; contour.forEach((_, i) => { if (i === 0) { return; } let prevPt = contour[i - 1]; let currPt = contour[i]; let dist = Math.sqrt( (prevPt.x - currPt.x) ** 2 + (prevPt.y - currPt.y) ** 2 ); let extrusion = defaultExtrusion; let printMove = `G1 X${round(currPt.x)} Y${round(currPt.z)} Z${ currPt.y + filamentHeight } E${extrusion} F${layerFeed}`; insts.push(printMove); }); let returnToStart = `G1 X${round(firstPt.x)} Y${round( firstPt.z )} Z${round(firstPt.y)} E0`; let retract = `G1 E${-retractDefault}`; insts.push(returnToStart); insts.push(retract); insts.push("; end contour"); return insts; }); return contourInsts; }) .flat(); }35:T52d,function layerToZigZag(layer, nextLayer) { if (!nextLayer || nextLayer.length === 0) { return []; } const retractAmount = 0.2; const filamentHeight = 0.4; const pauseTime = 1500; const eVertical = 0.4; const eHypotenuse = 1.75; const fVertical = 250; const fHypotenuse = 1500; return layer .map((contour, contourIdx) => { return contour .map((pt, i) => { if (i < 2 || i > contour.length - 2) { return null; } let nextLayerPt = nextLayer[contourIdx][i]; let thisLayerNextPt = i + 2 < contour.length ? contour[i + 1] : contour[0]; let moveToPt = `G0 X${pt.x} Y${pt.y} Z${ pt.z + filamentHeight } E0 F${fVertical}`; let unretract = `G1 E${retractAmount}`; let retract = `G1 E${-retractAmount}`; let pause = `G4 P${pauseTime}`; let vertical = `G0 Z${ nextLayerPt.y + filamentHeight } E${eVertical} F${fVertical} ; vertical`; let hypotenuse = `G0 X${pt.x} Y${pt.z} Z${ pt.y + filamentHeight } E${eHypotenuse} F${fHypotenuse} ; hypotenuse`; return [unretract, vertical, retract, pause, unretract, hypotenuse]; }) .flat(); }) .flat() .filter((inst) => !!inst); }36:T5c44,testTp = [ "(TEST)", "(T3 D=10. CR=0. - ZMIN=-0.5 - FLAT END MILL)", "G0 G90 G94 G17", "G21", "G53 G0 Z0.", "", "(2D ADAPTIVE1)", "M5", "T3", "M3 S3000", "G55", "M8", "G0 X-74.247 Y-64.329", "Z15.", "Z5.", "Z2.5", "G1 Z1.5 F400.", "Z-0.5", "G3 X-72.698 Y-59.052 R11.083", "G1 Y-58.902 F800.", "G1 X-72.938 Y-57.724", "G1 X-73.122 Y-56.536", "G1 X-73.261 Y-55.342", "G1 X-73.367 Y-54.145", "G1 X-73.448 Y-52.945", "G1 X-73.509 Y-51.745", "G1 X-73.555 Y-50.543", "G1 X-73.59 Y-49.342", "G1 X-73.616 Y-48.14", "G1 X-73.636 Y-46.938", "G1 X-73.651 Y-45.736", "G1 X-73.663 Y-44.534", "G1 X-73.671 Y-43.332", "G1 X-73.678 Y-42.13", "G1 X-73.683 Y-40.928", "G1 X-73.689 Y-38.523", "G1 X-73.694 Y-34.917", "G1 X-73.697 Y-28.907", "G1 X-73.698 Y-8.471", "G1 Y42.018", "G1 Y49.23", "G1 X-73.659 Y49.528", "G1 X-73.505 Y50.109", "G1 X-72.938 Y51.169", "G1 X-72.095 Y52.026", "G1 X-71.101 Y52.703", "G1 X-70.021 Y53.231", "G1 X-68.891 Y53.64", "G1 X-67.731 Y53.955", "G1 X-66.553 Y54.196", "G1 X-65.365 Y54.38", "G1 X-64.171 Y54.52", "G1 X-62.974 Y54.627", "G1 X-61.775 Y54.708", "G1 X-60.574 Y54.769", "G1 X-59.373 Y54.815", "G1 X-58.171 Y54.85", "G1 X-56.969 Y54.877", "G1 X-55.768 Y54.897", "G1 X-54.566 Y54.912", "G1 X-53.363 Y54.923", "G1 X-52.161 Y54.932", "G1 X-50.959 Y54.938", "G1 X-49.757 Y54.943", "G1 X-47.353 Y54.95", "G1 X-43.747 Y54.955", "G1 X-37.736 Y54.957", "G1 X-32.928 Y54.958", "G1 X17.561", "G1 X68.049", "G1 X68.641 Y54.853", "G1 X69.737 Y54.36", "G1 X70.628 Y53.553", "G1 X71.335 Y52.58", "G1 X71.887 Y51.512", "G1 X72.315 Y50.389", "G1 X72.645 Y49.233", "G1 X72.898 Y48.058", "G1 X73.091 Y46.871", "G1 X73.238 Y45.678", "G1 X73.35 Y44.481", "G1 X73.434 Y43.282", "G1 X73.499 Y42.082", "G1 X73.547 Y40.881", "G1 X73.584 Y39.679", "G1 X73.612 Y38.478", "G1 X73.633 Y37.276", "G1 X73.649 Y36.074", "G1 X73.661 Y34.872", "G1 X73.67 Y33.67", "G1 X73.677 Y32.467", "G1 X73.682 Y31.265", "G1 X73.689 Y28.861", "G1 X73.694 Y25.255", "G1 X73.697 Y19.244", "G1 X73.698 Y6.021", "G1 Y-44.467", "G1 Y-49.276", "G1 X73.604 Y-49.869", "G1 X73.122 Y-50.971", "G1 X72.321 Y-51.867", "G1 X71.352 Y-52.578", "G1 X70.286 Y-53.134", "G1 X69.164 Y-53.566", "G1 X68.009 Y-53.898", "G1 X66.834 Y-54.152", "G1 X65.648 Y-54.347", "G1 X64.455 Y-54.495", "G1 X63.258 Y-54.608", "G1 X62.059 Y-54.693", "G1 X60.859 Y-54.758", "G1 X59.658 Y-54.807", "G1 X58.456 Y-54.844", "G1 X57.254 Y-54.872", "G1 X56.052 Y-54.893", "G1 X54.85 Y-54.909", "G1 X53.648 Y-54.921", "G1 X52.446 Y-54.93", "G1 X51.244 Y-54.937", "G1 X50.042 Y-54.942", "G1 X47.638 Y-54.949", "G1 X45.234 Y-54.953", "G1 X40.425 Y-54.957", "G1 X29.606 Y-54.958", "G1 X-20.882", "G1 X-64.158", "G1 X-65.295 Y-54.568", "G1 X-66.243 Y-53.829", "G1 X-67.007 Y-52.901", "G1 X-67.613 Y-51.863", "G1 X-68.089 Y-50.759", "G1 X-68.46 Y-49.616", "G1 X-68.748 Y-48.449", "G1 X-68.97 Y-47.267", "G1 X-69.141 Y-46.077", "G1 X-69.272 Y-44.882", "G1 X-69.373 Y-43.684", "G1 X-69.45 Y-42.485", "G1 X-69.509 Y-41.284", "G1 X-69.554 Y-40.083", "G1 X-69.588 Y-38.881", "G1 X-69.614 Y-37.679", "G1 X-69.634 Y-36.478", "G1 X-69.649 Y-35.276", "G1 X-69.661 Y-34.073", "G1 X-69.669 Y-32.871", "G1 X-69.676 Y-31.669", "G1 X-69.681 Y-30.467", "G1 X-69.688 Y-28.063", "G1 X-69.693 Y-24.457", "G1 X-69.696 Y-19.648", "G1 X-69.698 Y-5.223", "G1 Y0.788", "G1 Y44.063", "G1 X-69.483 Y45.246", "G1 X-68.93 Y46.313", "G1 X-68.147 Y47.226", "G1 X-67.214 Y47.984", "G1 X-66.183 Y48.603", "G1 X-65.089 Y49.101", "G1 X-63.955 Y49.5", "G1 X-62.796 Y49.816", "G1 X-61.62 Y50.066", "G1 X-60.434 Y50.263", "G1 X-59.242 Y50.417", "G1 X-58.046 Y50.538", "G1 X-56.847 Y50.632", "G1 X-55.647 Y50.706", "G1 X-54.447 Y50.763", "G1 X-53.245 Y50.807", "G1 X-52.044 Y50.841", "G1 X-50.842 Y50.868", "G1 X-49.64 Y50.889", "G1 X-48.438 Y50.904", "G1 X-47.236 Y50.917", "G1 X-46.034 Y50.926", "G1 X-44.832 Y50.934", "G1 X-43.63 Y50.939", "G1 X-42.428 Y50.944", "G1 X-40.024 Y50.95", "G1 X-36.417 Y50.954", "G1 X-30.407 Y50.957", "G1 X-14.779 Y50.958", "G1 X35.709", "G1 X63.358", "G1 X64.496 Y50.571", "G1 X65.493 Y49.9", "G1 X66.333 Y49.04", "G1 X67.024 Y48.056", "G1 X67.584 Y46.993", "G1 X68.034 Y45.878", "G1 X68.393 Y44.731", "G1 X68.677 Y43.563", "G1 X68.902 Y42.382", "G1 X69.078 Y41.193", "G1 X69.216 Y39.998", "G1 X69.323 Y38.801", "G1 X69.407 Y37.602", "G1 X69.473 Y36.402", "G1 X69.524 Y35.201", "G1 X69.563 Y33.999", "G1 X69.594 Y32.797", "G1 X69.617 Y31.596", "G1 X69.636 Y30.394", "G1 X69.65 Y29.192", "G1 X69.661 Y27.99", "G1 X69.669 Y26.787", "G1 X69.676 Y25.585", "G1 X69.681 Y24.383", "G1 X69.688 Y21.979", "G1 X69.693 Y18.373", "G1 X69.696 Y13.564", "G1 X69.698 Y0.341", "G1 Y-20.095", "G1 Y-44.137", "G1 X69.464 Y-45.316", "G1 X68.895 Y-46.375", "G1 X68.103 Y-47.279", "G1 X67.162 Y-48.028", "G1 X66.127 Y-48.638", "G1 X65.03 Y-49.13", "G1 X63.894 Y-49.523", "G1 X62.733 Y-49.835", "G1 X61.556 Y-50.081", "G1 X60.37 Y-50.274", "G1 X59.177 Y-50.426", "G1 X57.981 Y-50.545", "G1 X56.783 Y-50.638", "G1 X55.583 Y-50.71", "G1 X54.382 Y-50.766", "G1 X53.181 Y-50.81", "G1 X51.979 Y-50.843", "G1 X50.777 Y-50.869", "G1 X49.575 Y-50.89", "G1 X48.373 Y-50.905", "G1 X47.171 Y-50.917", "G1 X45.969 Y-50.927", "G1 X44.767 Y-50.934", "G1 X43.565 Y-50.94", "G1 X41.161 Y-50.947", "G1 X38.756 Y-50.952", "G1 X35.15 Y-50.955", "G1 X27.938 Y-50.958", "G1 X-4.519", "G1 X-55.008", "G1 X-58.614", "G1 X-59.802 Y-50.776", "G1 X-60.884 Y-50.251", "G1 X-61.815 Y-49.491", "G1 X-62.592 Y-48.574", "G1 X-63.229 Y-47.554", "G1 X-63.744 Y-46.468", "G1 X-64.158 Y-45.339", "G1 X-64.487 Y-44.183", "G1 X-64.749 Y-43.01", "G1 X-64.955 Y-41.826", "G1 X-65.118 Y-40.635", "G1 X-65.246 Y-39.439", "G1 X-65.346 Y-38.242", "G1 X-65.424 Y-37.042", "G1 X-65.485 Y-35.841", "G1 X-65.532 Y-34.64", "G1 X-65.569 Y-33.439", "G1 X-65.598 Y-32.237", "G1 X-65.621 Y-31.035", "G1 X-65.638 Y-29.833", "G1 X-65.651 Y-28.631", "G1 X-65.662 Y-27.429", "G1 X-65.67 Y-26.227", "G1 X-65.676 Y-25.025", "G1 X-65.681 Y-23.823", "G1 X-65.688 Y-21.418", "G1 X-65.693 Y-17.812", "G1 X-65.696 Y-13.004", "G1 X-65.697 Y-6.993", "G1 X-65.698 Y38.687", "G1 X-65.694 Y39.889", "G1 X-65.38 Y41.049", "G1 X-64.788 Y42.096", "G1 X-63.997 Y43.001", "G1 X-63.068 Y43.763", "G1 X-62.044 Y44.393", "G1 X-60.958 Y44.908", "G1 X-59.831 Y45.326", "G1 X-58.677 Y45.663", "G1 X-57.505 Y45.933", "G1 X-56.323 Y46.148", "G1 X-55.133 Y46.319", "G1 X-53.938 Y46.455", "G1 X-52.741 Y46.562", "G1 X-51.542 Y46.647", "G1 X-50.342 Y46.714", "G1 X-49.141 Y46.767", "G1 X-47.939 Y46.808", "G1 X-46.738 Y46.841", "G1 X-45.536 Y46.867", "G1 X-44.334 Y46.887", "G1 X-43.132 Y46.902", "G1 X-41.93 Y46.915", "G1 X-40.728 Y46.924", "G1 X-39.526 Y46.932", "G1 X-38.324 Y46.937", "G1 X-37.122 Y46.942", "G1 X-34.717 Y46.948", "G1 X-31.111 Y46.954", "G1 X-26.303 Y46.957", "G1 X-14.282 Y46.958", "G1 X36.207", "G1 X57.845", "G1 X59.043 Y46.865", "G1 X60.172 Y46.453", "G1 X61.172 Y45.785", "G1 X62.028 Y44.941", "G1 X62.742 Y43.974", "G1 X63.33 Y42.925", "G1 X63.809 Y41.823", "G1 X64.196 Y40.685", "G1 X64.507 Y39.524", "G1 X64.756 Y38.348", "G1 X64.955 Y37.162", "G1 X65.112 Y35.97", "G1 X65.237 Y34.775", "G1 X65.335 Y33.577", "G1 X65.413 Y32.377", "G1 X65.475 Y31.176", "G1 X65.523 Y29.975", "G1 X65.561 Y28.774", "G1 X65.591 Y27.572", "G1 X65.614 Y26.37", "G1 X65.632 Y25.168", "G1 X65.647 Y23.966", "G1 X65.658 Y22.764", "G1 X65.667 Y21.562", "G1 X65.673 Y20.36", "G1 X65.679 Y19.158", "G1 X65.686 Y16.754", "G1 X65.691 Y14.349", "G1 X65.694 Y10.743", "G1 X65.697 Y3.531", "G1 X65.698 Y-28.926", "G1 Y-39.745", "G1 X65.424 Y-40.916", "G1 X64.864 Y-41.98", "G1 X64.093 Y-42.902", "G1 X63.178 Y-43.681", "G1 X62.164 Y-44.327", "G1 X61.084 Y-44.855", "G1 X59.961 Y-45.283", "G1 X58.809 Y-45.629", "G1 X57.639 Y-45.905", "G1 X56.458 Y-46.126", "G1 X55.269 Y-46.302", "G1 X54.075 Y-46.441", "G1 X52.878 Y-46.552", "G1 X51.679 Y-46.639", "G1 X50.478 Y-46.708", "G1 X49.278 Y-46.762", "G1 X48.076 Y-46.804", "G1 X46.875 Y-46.838", "G1 X45.673 Y-46.864", "G1 X44.471 Y-46.885", "G1 X43.269 Y-46.901", "G1 X42.067 Y-46.913", "G1 X40.865 Y-46.923", "G1 X39.663 Y-46.931", "G1 X38.461 Y-46.937", "G1 X37.258 Y-46.942", "G1 X34.854 Y-46.948", "G1 X31.248 Y-46.953", "G1 X28.844 Y-46.955", "G1 X21.631 Y-46.958", "G1 X-21.645", "G1 X-54.102", "G1 X-55.29 Y-46.775", "G1 X-56.389 Y-46.289", "G1 X-57.354 Y-45.572", "G1 X-58.175 Y-44.694", "G1 X-58.86 Y-43.706", "G1 X-59.424 Y-42.644", "G1 X-59.882 Y-41.533", "G1 X-60.253 Y-40.39", "G1 X-60.551 Y-39.225", "G1 X-60.789 Y-38.047", "G1 X-60.98 Y-36.86", "G1 X-61.131 Y-35.667", "G1 X-61.251 Y-34.471", "G1 X-61.346 Y-33.273", "G1 X-61.421 Y-32.073", "G1 X-61.48 Y-30.872", "G1 X-61.527 Y-29.671", "G1 X-61.564 Y-28.47", "G1 X-61.593 Y-27.268", "G1 X-61.615 Y-26.066", "G1 X-61.633 Y-24.864", "G1 X-61.647 Y-23.662", "G1 X-61.658 Y-22.46", "G1 X-61.667 Y-21.258", "G1 X-61.674 Y-20.056", "G1 X-61.679 Y-18.854", "G1 X-61.686 Y-16.45", "G1 X-61.691 Y-14.045", "G1 X-61.694 Y-10.439", "G1 X-61.697 Y-3.226", "G1 X-61.698 Y18.412", "G1 X-61.697 Y35.241", "G1 X-61.482 Y36.424", "G1 X-60.985 Y37.518", "G1 X-60.269 Y38.484", "G1 X-59.395 Y39.309", "G1 X-58.412 Y40.002", "G1 X-57.355 Y40.575", "G1 X-56.249 Y41.044", "G1 X-55.109 Y41.426", "G1 X-53.947 Y41.735", "G1 X-52.771 Y41.984", "G1 X-51.586 Y42.184", "G1 X-50.394 Y42.343", "G1 X-49.199 Y42.47", "G1 X-48.001 Y42.572", "G1 X-46.802 Y42.653", "G1 X-45.601 Y42.717", "G1 X-44.4 Y42.767", "G1 X-43.199 Y42.808", "G1 X-41.997 Y42.839", "G1 X-40.795 Y42.865", "G1 X-39.593 Y42.884", "G1 X-38.391 Y42.9", "G1 X-37.189 Y42.913", "G1 X-35.987 Y42.922", "G1 X-34.785 Y42.93", "G1 X-33.583 Y42.936", "G1 X-32.381 Y42.941", "G1 X-31.179 Y42.945", "G1 X-28.775 Y42.95", "G1 X-25.168 Y42.954", "G1 X-19.158 Y42.957", "G1 X0.076 Y42.958", "G1 X19.309", "G1 X52.968", "G1 X54.171 Y42.954", "G1 X55.343 Y42.691", "G1 X56.419 Y42.154", "G1 X57.363 Y41.41", "G1 X58.167 Y40.516", "G1 X58.839 Y39.52", "G1 X59.395 Y38.453", "G1 X59.849 Y37.341", "G1 X60.219 Y36.197", "G1 X60.517 Y35.032", "G1 X60.758 Y33.854", "G1 X60.95 Y32.668", "G1 X61.104 Y31.476", "G1 X61.227 Y30.28", "G1 X61.325 Y29.082", "G1 X61.403 Y27.882", "G1 X61.465 Y26.682", "G1 X61.514 Y25.48", "G1 X61.552 Y24.279", "G1 X61.583 Y23.077", "G1 X61.607 Y21.875", "G1 X61.627 Y20.673", "G1 X61.642 Y19.471", "G1 X61.654 Y18.269", "G1 X61.663 Y17.067", "G1 X61.67 Y15.865", "G1 X61.676 Y14.663", "G1 X61.684 Y12.259", "G1 X61.69 Y9.855", "G1 X61.694 Y6.248", "G1 X61.696 Y0.238", "G1 X61.698 Y-20.198", "G1 Y-34.623", "G1 X61.63 Y-35.823", "G1 X61.272 Y-36.971", "G1 X60.66 Y-38.005", "G1 X59.861 Y-38.903", "G1 X58.929 Y-39.663", "G1 X57.906 Y-40.295", "G1 X56.823 Y-40.815", "G1 X55.698 Y-41.24", "G1 X54.546 Y-41.585", "G1 X53.377 Y-41.863", "G1 X52.196 Y-42.086", "G1 X51.007 Y-42.265", "G1 X49.814 Y-42.408", "G1 X48.617 Y-42.522", "G1 X47.418 Y-42.613", "G1 X46.218 Y-42.685", "G1 X45.017 Y-42.742", "G1 X43.816 Y-42.788", "G1 X42.615 Y-42.824", "G1 X41.413 Y-42.852", "G1 X40.211 Y-42.875", "G1 X39.009 Y-42.892", "G1 X37.807 Y-42.906", "G1 X36.605 Y-42.917", "G1 X35.403 Y-42.926", "G1 X34.201 Y-42.933", "G1 X32.999 Y-42.938", "G1 X30.594 Y-42.946", "G1 X29.392 Y-42.949", "G1 X25.786 Y-42.954", "G1 X19.776 Y-42.957", "G1 X2.946 Y-42.958", "G1 X-21.096", "G1 X-49.947", "G1 X-51.129 Y-42.742", "G1 X-52.225 Y-42.247", "G1 X-53.191 Y-41.532", "G1 X-54.019 Y-40.661", "G1 X-54.714 Y-39.68", "G1 X-55.29 Y-38.625", "G1 X-55.762 Y-37.52", "G1 X-56.147 Y-36.38", "G1 X-56.458 Y-35.219", "G1 X-56.709 Y-34.044", "G1 X-56.91 Y-32.859", "G1 X-57.071 Y-31.667", "G1 X-57.2 Y-30.472", "G1 X-57.303 Y-29.275", "G1 X-57.385 Y-28.075", "G1 X-57.45 Y-26.875", "G1 X-57.502 Y-25.674", "G1 X-57.543 Y-24.472", "G1 X-57.575 Y-23.271", "G1 X-57.601 Y-22.069", "G1 X-57.622 Y-20.867", "G1 X-57.638 Y-19.665", "G1 X-57.65 Y-18.463", "G1 X-57.66 Y-17.261", "G1 X-57.668 Y-16.059", "G1 X-57.675 Y-14.857", "G1 X-57.679 Y-13.655", "G1 X-57.686 Y-11.25", "G1 X-57.692 Y-7.644", "G1 X-57.696 Y-2.836", "G1 X-57.697 Y7.983", "G1 X-57.698 Y26.015", "G1 Y30.823", "G1 X-57.538 Y32.015", "G1 X-57.101 Y33.135", "G1 X-56.437 Y34.136", "G1 X-55.602 Y35.002", "G1 X-54.649 Y35.734", "G1 X-53.614 Y36.345", "G1 X-52.522 Y36.849", "G1 X-51.393 Y37.261", "G1 X-50.239 Y37.596", "G1 X-49.068 Y37.867", "G1 X-47.886 Y38.086", "G1 X-46.696 Y38.262", "G1 X-45.503 Y38.403", "G1 X-44.306 Y38.516", "G1 X-43.107 Y38.607", "G1 X-41.907 Y38.679", "G1 X-40.706 Y38.736", "G1 X-39.505 Y38.782", "G1 X-38.304 Y38.818", "G1 X-37.102 Y38.847", "G1 X-35.9 Y38.87", "G1 X-34.698 Y38.889", "G1 X-33.496 Y38.903", "G1 X-32.294 Y38.915", "G1 X-31.092 Y38.924", "G1 X-29.89 Y38.931", "G1 X-28.688 Y38.937", "G1 X-26.284 Y38.945", "G1 X-23.879 Y38.95", "G1 X-20.273 Y38.954", "G1 X-15.465 Y38.957", "G1 X-1.039 Y38.958", "G1 X35.024", "G1 X49.449", "G1 X50.644 Y38.829", "G1 X51.774 Y38.418", "G1 X52.788 Y37.773", "G1 X53.667 Y36.952", "G1 X54.411 Y36.008", "G1 X55.032 Y34.979", "G1 X55.545 Y33.892", "G1 X55.965 Y32.765", "G1 X56.306 Y31.613", "G1 X56.583 Y30.443", "G1 X56.807 Y29.262", "G1 X56.986 Y28.073", "G1 X57.131 Y26.88", "G1 X57.246 Y25.683", "G1 X57.338 Y24.485", "G1 X57.412 Y23.285", "G1 X57.471 Y22.084", "G1 X57.518 Y20.883", "G1 X57.555 Y19.681", "G1 X57.584 Y18.48", "G1 X57.608 Y17.278", "G1 X57.627 Y16.076", "G1 X57.641 Y14.874", "G1 X57.653 Y13.672", "G1 X57.662 Y12.47", "G1 X57.67 Y11.268", "G1 X57.676 Y10.066", "G1 X57.684 Y7.661", "G1 X57.687 Y6.459", "G1 X57.692 Y2.853", "G1 X57.696 Y-1.955", "G1 X57.697 Y-12.774", "G1 Y-30.806", "G1 X57.543 Y-31.998", "G1 X57.113 Y-33.121", "G1 X56.45 Y-34.123", "G1 X55.618 Y-34.991", "G1 X54.666 Y-35.725", "G1 X53.631 Y-36.337", "G1 X52.54 Y-36.842", "G1 X51.411 Y-37.254", "G1 X50.257 Y-37.59", "G1 X49.086 Y-37.863", "G1 X47.904 Y-38.082", "G1 X46.715 Y-38.259", "G1 X45.521 Y-38.4", "G1 X44.325 Y-38.514", "G1 X43.126 Y-38.605", "G1 X41.926 Y-38.677", "G1 X40.725 Y-38.735", "G1 X39.524 Y-38.781", "G1 X38.323 Y-38.818", "G1 X37.121 Y-38.847", "G1 X35.919 Y-38.87", "G1 X34.717 Y-38.888", "G1 X33.515 Y-38.903", "G1 X32.313 Y-38.914", "G1 X31.111 Y-38.924", "G1 X29.909 Y-38.931", "G1 X28.707 Y-38.937", "G1 X26.302 Y-38.945", "G1 X23.898 Y-38.95", "G1 X20.292 Y-38.954", "G1 X14.281 Y-38.957", "G1 X-2.548 Y-38.958", "G1 X-44.622", "G1 X-45.824 Y-38.957", "G1 X-47.005 Y-38.731", "G1 X-48.1 Y-38.236", "G1 X-49.07 Y-37.527", "G1 X-49.905 Y-36.662", "G1 X-50.61 Y-35.688", "G1 X-51.195 Y-34.638", "G1 X-51.677 Y-33.537", "G1 X-52.072 Y-32.401", "G1 X-52.392 Y-31.242", "G1 X-52.651 Y-30.069", "G1 X-52.861 Y-28.885", "G1 X-53.029 Y-27.695", "G1 X-53.164 Y-26.5", "G1 X-53.273 Y-25.303", "G1 X-53.359 Y-24.104", "G1 X-53.428 Y-22.904", "G1 X-53.484 Y-21.703", "G1 X-53.528 Y-20.502", "G1 X-53.563 Y-19.3", "G1 X-53.59 Y-18.098", "G1 X-53.613 Y-16.896", "G1 X-53.63 Y-15.694", "G1 X-53.644 Y-14.492", "G1 X-53.655 Y-13.29", "G1 X-53.664 Y-12.088", "G1 X-53.671 Y-10.886", "G1 X-53.677 Y-9.684", "G1 X-53.685 Y-7.28", "G1 X-53.689 Y-4.876", "G1 X-53.694 Y-1.269", "G1 X-53.696 Y4.741", "G1 X-53.697 Y15.56", "G1 X-53.698 Y26.379", "G1 X-53.607 Y27.578", "G1 X-53.249 Y28.725", "G1 X-52.649 Y29.767", "G1 X-51.863 Y30.677", "G1 X-50.946 Y31.453", "G1 X-49.935 Y32.105", "G1 X-48.862 Y32.645", "G1 X-47.745 Y33.09", "G1 X-46.599 Y33.453", "G1 X-45.434 Y33.749", "G1 X-44.256 Y33.988", "G1 X-43.069 Y34.181", "G1 X-41.877 Y34.336", "G1 X-40.681 Y34.461", "G1 X-39.484 Y34.561", "G1 X-38.284 Y34.641", "G1 X-37.084 Y34.706", "G1 X-35.883 Y34.757", "G1 X-34.681 Y34.798", "G1 X-33.48 Y34.831", "G1 X-32.278 Y34.857", "G1 X-31.076 Y34.877", "G1 X-29.874 Y34.894", "G1 X-28.672 Y34.907", "G1 X-27.47 Y34.918", "G1 X-26.268 Y34.926", "G1 X-25.066 Y34.933", "G1 X-23.864 Y34.938", "G1 X-21.459 Y34.945", "G1 X-19.055 Y34.95", "G1 X-17.853 Y34.952", "G1 X-13.045 Y34.956", "G1 X-3.428 Y34.958", "G1 X32.635", "G1 X44.656", "G1 X45.858 Y34.946", "G1 X47.033 Y34.69", "G1 X48.119 Y34.175", "G1 X49.081 Y33.454", "G1 X49.908 Y32.582", "G1 X50.606 Y31.603", "G1 X51.188 Y30.551", "G1 X51.667 Y29.448", "G1 X52.06 Y28.312", "G1 X52.38 Y27.154", "G1 X52.64 Y25.98", "G1 X52.849 Y24.796", "G1 X53.018 Y23.606", "G1 X53.155 Y22.412", "G1 X53.264 Y21.214", "G1 X53.351 Y20.016", "G1 X53.421 Y18.816", "G1 X53.477 Y17.615", "G1 X53.522 Y16.413", "G1 X53.558 Y15.212", "G1 X53.586 Y14.01", "G1 X53.609 Y12.808", "G1 X53.627 Y11.606", "G1 X53.642 Y10.404", "G1 X53.653 Y9.202", "G1 X53.662 Y8.", "G1 X53.67 Y6.798", "G1 X53.675 Y5.596", "G1 X53.684 Y3.192", "G1 X53.689 Y0.788", "G1 X53.693 Y-2.819", "G1 X53.696 Y-8.829", "G1 X53.698 Y-25.659", "G1 X53.695 Y-26.861", "G1 X53.5 Y-28.047", "G1 X53.039 Y-29.157", "G1 X52.356 Y-30.147", "G1 X51.512 Y-31.003", "G1 X50.554 Y-31.728", "G1 X49.515 Y-32.333", "G1 X48.422 Y-32.833", "G1 X47.292 Y-33.243", "G1 X46.137 Y-33.577", "G1 X44.966 Y-33.849", "G1 X43.784 Y-34.068", "G1 X42.595 Y-34.245", "G1 X41.402 Y-34.388", "G1 X40.205 Y-34.502", "G1 X39.006 Y-34.594", "G1 X37.807 Y-34.668", "G1 X36.606 Y-34.727", "G1 X35.405 Y-34.774", "G1 X34.203 Y-34.811", "G1 X33.001 Y-34.841", "G1 X31.8 Y-34.865", "G1 X30.598 Y-34.884", "G1 X29.396 Y-34.899", "G1 X28.194 Y-34.911", "G1 X26.991 Y-34.921", "G1 X25.789 Y-34.929", "G1 X24.587 Y-34.935", "G1 X22.183 Y-34.943", "G1 X19.779 Y-34.949", "G1 X16.173 Y-34.954", "G1 X10.162 Y-34.957", "G1 X-6.667 Y-34.958", "G1 X-16.284", "G1 X-41.528", "G1 X-42.717 Y-34.776", "G1 X-43.831 Y-34.326", "G1 X-44.829 Y-33.655", "G1 X-45.692 Y-32.818", "G1 X-46.424 Y-31.865", "G1 X-47.036 Y-30.83", "G1 X-47.542 Y-29.74", "G1 X-47.958 Y-28.612", "G1 X-48.296 Y-27.458", "G1 X-48.571 Y-26.288", "G1 X-48.794 Y-25.107", "G1 X-48.973 Y-23.918", "G1 X-49.118 Y-22.725", "G1 X-49.234 Y-21.528", "G1 X-49.327 Y-20.33", "G1 X-49.402 Y-19.13", "G1 X-49.462 Y-17.929", "G1 X-49.51 Y-16.728", "G1 X-49.548 Y-15.527", "G1 X-49.578 Y-14.325", "G1 X-49.603 Y-13.123", "G1 X-49.622 Y-11.921", "G1 X-49.637 Y-10.719", "G1 X-49.65 Y-9.517", "G1 X-49.66 Y-8.315", "G1 X-49.667 Y-7.113", "G1 X-49.674 Y-5.911", "G1 X-49.679 Y-4.709", "G1 X-49.686 Y-2.304", "G1 X-49.692 Y1.302", "G1 X-49.695 Y6.11", "G1 X-49.697 Y15.727", "G1 Y21.738", "G1 X-49.689 Y22.94", "G1 X-49.458 Y24.119", "G1 X-48.968 Y25.217", "G1 X-48.268 Y26.195", "G1 X-47.412 Y27.038", "G1 X-46.446 Y27.753", "G1 X-45.402 Y28.35", "G1 X-44.306 Y28.844", "G1 X-43.174 Y29.249", "G1 X-42.019 Y29.58", "G1 X-40.847 Y29.849", "G1 X-39.665 Y30.067", "G1 X-38.476 Y30.243", "G1 X-37.282 Y30.385", "G1 X-36.085 Y30.499", "G1 X-34.887 Y30.591", "G1 X-33.687 Y30.664", "G1 X-32.486 Y30.723", "G1 X-31.285 Y30.771", "G1 X-30.084 Y30.809", "G1 X-28.882 Y30.839", "G1 X-27.68 Y30.863", "G1 X-26.478 Y30.882", "G1 X-25.276 Y30.898", "G1 X-24.074 Y30.91", "G1 X-22.872 Y30.92", "G1 X-21.67 Y30.928", "G1 X-20.468 Y30.934", "G1 X-19.266 Y30.939", "G1 X-16.862 Y30.946", "G1 X-13.255 Y30.952", "G1 X-8.447 Y30.956", "G1 X1.17 Y30.958", "G1 X11.989", "G1 X40.84", "G1 X42.041 Y30.906", "G1 X43.202 Y30.595", "G1 X44.266 Y30.036", "G1 X45.203 Y29.283", "G1 X46.008 Y28.39", "G1 X46.686 Y27.397", "G1 X47.249 Y26.336", "G1 X47.715 Y25.227", "G1 X48.096 Y24.087", "G1 X48.407 Y22.926", "G1 X48.659 Y21.751", "G1 X48.863 Y20.566", "G1 X49.028 Y19.375", "G1 X49.161 Y18.18", "G1 X49.268 Y16.983", "G1 X49.354 Y15.784", "G1 X49.423 Y14.584", "G1 X49.478 Y13.383", "G1 X49.522 Y12.182", "G1 X49.558 Y10.98", "G1 X49.586 Y9.778", "G1 X49.608 Y8.577", "G1 X49.627 Y7.375", "G1 X49.641 Y6.173", "G1 X49.652 Y4.971", "G1 X49.662 Y3.768", "G1 X49.669 Y2.566", "G1 X49.675 Y1.364", "G1 X49.683 Y-1.04", "G1 X49.688 Y-3.444", "G1 X49.693 Y-7.05", "G1 X49.696 Y-13.061", "G1 X49.697 Y-22.678", "G1 X49.526 Y-23.868", "G1 X49.089 Y-24.988", "G1 X48.43 Y-25.993", "G1 X47.604 Y-26.866", "G1 X46.658 Y-27.608", "G1 X45.629 Y-28.23", "G1 X44.543 Y-28.745", "G1 X43.418 Y-29.168", "G1 X42.267 Y-29.514", "G1 X41.098 Y-29.795", "G1 X39.918 Y-30.023", "G1 X38.73 Y-30.208", "G1 X37.537 Y-30.356", "G1 X36.341 Y-30.476", "G1 X35.143 Y-30.572", "G1 X33.943 Y-30.649", "G1 X32.742 Y-30.711", "G1 X31.541 Y-30.761", "G1 X30.34 Y-30.801", "G1 X29.138 Y-30.832", "G1 X27.936 Y-30.858", "G1 X26.734 Y-30.878", "G1 X25.532 Y-30.894", "G1 X24.33 Y-30.907", "G1 X23.128 Y-30.918", "G1 X21.926 Y-30.926", "G1 X20.724 Y-30.933", "G1 X19.522 Y-30.938", "G1 X17.118 Y-30.945", "G1 X14.714 Y-30.95", "G1 X11.107 Y-30.954", "G1 X5.097 Y-30.957", "G1 X-11.733 Y-30.958", "G1 X-36.977", "G1 X-38.176 Y-30.877", "G1 X-39.329 Y-30.536", "G1 X-40.379 Y-29.95", "G1 X-41.301 Y-29.179", "G1 X-42.089 Y-28.271", "G1 X-42.753 Y-27.269", "G1 X-43.305 Y-26.201", "G1 X-43.76 Y-25.088", "G1 X-44.133 Y-23.946", "G1 X-44.436 Y-22.782", "G1 X-44.683 Y-21.606", "G1 X-44.883 Y-20.421", "G1 X-45.044 Y-19.229", "G1 X-45.174 Y-18.034", "G1 X-45.278 Y-16.837", "G1 X-45.362 Y-15.637", "G1 X-45.429 Y-14.437", "G1 X-45.483 Y-13.236", "G1 X-45.526 Y-12.035", "G1 X-45.561 Y-10.833", "G1 X-45.588 Y-9.632", "G1 X-45.61 Y-8.43", "G1 X-45.628 Y-7.228", "G1 X-45.642 Y-6.026", "G1 X-45.653 Y-4.824", "G1 X-45.662 Y-3.622", "G1 X-45.67 Y-2.419", "G1 X-45.675 Y-1.217", "G1 X-45.683 Y1.187", "G1 X-45.689 Y3.591", "G1 X-45.693 Y7.197", "G1 X-45.696 Y13.208", "G1 X-45.697 Y18.016", "G1 X-45.648 Y19.217", "G1 X-45.346 Y20.381", "G1 X-44.796 Y21.45", "G1 X-44.052 Y22.394", "G1 X-43.165 Y23.206", "G1 X-42.177 Y23.89", "G1 X-41.119 Y24.461", "G1 X-40.014 Y24.933", "G1 X-38.875 Y25.32", "G1 X-37.716 Y25.636", "G1 X-36.541 Y25.893", "G1 X-35.357 Y26.101", "G1 X-34.167 Y26.27", "G1 X-32.973 Y26.405", "G1 X-31.776 Y26.515", "G1 X-30.577 Y26.603", "G1 X-29.377 Y26.674", "G1 X-28.176 Y26.73", "G1 X-26.975 Y26.776", "G1 X-25.773 Y26.812", "G1 X-24.571 Y26.842", "G1 X-23.37 Y26.865", "G1 X-22.168 Y26.884", "G1 X-20.966 Y26.899", "G1 X-19.764 Y26.911", "G1 X-18.561 Y26.92", "G1 X-17.359 Y26.928", "G1 X-16.157 Y26.934", "G1 X-13.753 Y26.943", "G1 X-11.349 Y26.948" ]37:T1c95,VisualizationSpace = /** @class */ (function () { function VisualizationSpace(containerDom, stockDimensions) { this.containerDom = containerDom; this.scene = this.initScene(); this.envelopeGroup = this.createEnvelopeGroup(stockDimensions); this.vizGroupWrapper = new THREE.Group(); this.scene.add(this.envelopeGroup); this.scene.add(this.vizGroupWrapper); this.camera = this.initCamera( this.scene, this.envelopeGroup.position, true ); this.renderRequested = false; this.initPostDomLoadLogistics(); // For debugging window.vs = this; } VisualizationSpace.prototype.componentWillUnmount = function () { this.removeAllViz(); }; VisualizationSpace.prototype.cloneCamera = function () { return this.camera.clone(); }; VisualizationSpace.prototype.cloneScene = function () { return this.scene.clone(); }; Object.defineProperty(VisualizationSpace.prototype, "domElement", { get: function () { if (!this.threeRenderer) { return undefined; } return this.threeRenderer.domElement; }, enumerable: false, configurable: true }); VisualizationSpace.prototype.addVizWithName = function ( vizGroup, interpreterName ) { // if (this.vizGroupWrapper.children.length >= 1) { // console.error( // "Cannot add another vizGroup without clearing the" + " existing one." // ); // return; // } vizGroup.name = interpreterName; this.vizGroupWrapper.add(vizGroup); this.threeRenderScene(); }; VisualizationSpace.prototype.getCurrentVizNames = function () { return this.vizGroupWrapper.children.map(function (alsoCalledVizGroup) { return alsoCalledVizGroup.name; }); }; VisualizationSpace.prototype.removeAllViz = function () { // TODO: cast as THREE.Mesh and call dispose on geom and mat var wrappedVizGroup = this.vizGroupWrapper.children[0]; if (!wrappedVizGroup) { return; } wrappedVizGroup.children.forEach(function (child) { child.geometry.dispose(); child.material.dispose(); child.remove(); }); this.vizGroupWrapper.children = []; this.threeRenderScene(); }; VisualizationSpace.prototype.createExampleToolpath = function () { var line = new THREE.LineCurve3( new THREE.Vector3(0, 0, 0), new THREE.Vector3(100, 100, 40) ); var geom = new THREE.TubeBufferGeometry(line, 64, 1, 64, false); var material = new THREE.MeshToonMaterial({ color: 0xe44242, side: THREE.DoubleSide }); var mesh = new THREE.Mesh(geom, material); return mesh; }; VisualizationSpace.prototype.initPostDomLoadLogistics = function () { this.threeRenderer = this.initThreeRenderer(); this.controls = this.initControls(this.camera, this.threeRenderer); this.threeRenderScene(); // let animate = () => { // let maxFramerate = 20; // setTimeout(() => { // requestAnimationFrame(animate); // }, 1000 / maxFramerate); // this.threeRenderScene(); // }; // animate(); }; VisualizationSpace.prototype.initScene = function () { var scene = new THREE.Scene(); // scene.background = new THREE.Color(0x23241f); scene.background = new THREE.Color(0xffffff); var topDirectionalLight = new THREE.DirectionalLight(0xffffff, 0.25); var leftDirectionalLight = new THREE.DirectionalLight(0xffffff, 0.5); var rightDirectionalLight = new THREE.DirectionalLight(0xffffff, 0.75); var ambientLight = new THREE.AmbientLight(0x404040); topDirectionalLight.position.set(-1, 0, 0); leftDirectionalLight.position.set(1.0, 0.0, 0.0); rightDirectionalLight.position.set(0.0, 0.0, -1.0); scene.add(topDirectionalLight); scene.add(leftDirectionalLight); scene.add(rightDirectionalLight); scene.add(ambientLight); return scene; }; VisualizationSpace.prototype.initCamera = function ( scene, centerPoint, isOrtho ) { var camera; if (isOrtho) { camera = new THREE.OrthographicCamera( -720 / 2, 720 / 2, 480 / 2, -480 / 2, 1, 10000 ); // camera.up = new THREE.Vector3(0, -1, 0); camera.zoom = 4; camera.updateProjectionMatrix(); camera.position.set(-250, -250, -250); camera.lookAt(centerPoint); camera.updateProjectionMatrix(); } else { var fov = 50; camera = new THREE.PerspectiveCamera(fov, 720 / 480, 0.01, 30000); camera.lookAt(new THREE.Vector3(-125, 0, -125)); camera.position.set(-500, 500, 500); camera.updateProjectionMatrix(); } return camera; }; VisualizationSpace.prototype.initControls = function (camera, renderer) { var controls = new OrbitControls(camera, renderer.domElement); controls.rotateSpeed = 1.0; controls.zoomSpeed = 0.8; controls.panSpeed = 0.8; controls.addEventListener("change", this.requestRenderScene.bind(this)); controls.enableDamping = true; controls.dampingFactor = 0.5; return controls; }; VisualizationSpace.prototype.initThreeRenderer = function () { var renderer = new THREE.WebGLRenderer({ antialias: true }); renderer.setPixelRatio(window.devicePixelRatio); renderer.setSize(720, 480); if (this.containerDom) { this.containerDom.appendChild(renderer.domElement); } else { throw new Error("No container DOM element provided."); } return renderer; }; VisualizationSpace.prototype.requestRenderScene = function () { if (!this.renderRequested) { this.renderRequested = true; requestAnimationFrame(this.threeRenderScene.bind(this)); } }; VisualizationSpace.prototype.threeRenderScene = function () { // this.controls.update(); // let deltaSeconds = this.clock.getDelta(); // this.mixers.forEach((mixer) => { // mixer.update(deltaSeconds); // }); if (!this.controls || !this.threeRenderer) { return; } this.renderRequested = false; this.controls.update(); this.threeRenderer.render(this.scene, this.camera); }; VisualizationSpace.prototype.createEnvelopeGroup = function ( stockDimensions ) { // FIXME: eventually have work envelopes be a 3-vector var dimensions = { width: stockDimensions.width, height: stockDimensions.thickness, length: stockDimensions.height }; var whitesmoke = 0xf5f5f5; var boxGeom = new THREE.BoxBufferGeometry( dimensions.width, dimensions.height, dimensions.length, 2, 2, 2 ); var edgesGeom = new THREE.EdgesGeometry(boxGeom); var material = new THREE.LineDashedMaterial({ color: 0x111111, linewidth: 1, scale: 1, dashSize: 0.5, gapSize: 0.5 }); var mesh = new THREE.LineSegments(edgesGeom, material); mesh.computeLineDistances(); var envelopeGroup = new THREE.Group(); envelopeGroup.add(mesh); envelopeGroup.position.set( dimensions.width / 2, dimensions.height / 2, dimensions.length / 2 ); return envelopeGroup; }; VisualizationSpace.prototype.toString = function () { return ""); }; return VisualizationSpace; })()38:Td00,VisualizationInterpreters = /** @class */ (function () { function VisualizationInterpreters() {} VisualizationInterpreters.basicViz = function ( toolpath, materialParams, providedOrigin ) { let toolpathCurves = []; var moveCurves = []; var moveCurve2; const SCALE_FACTOR = 1; var curveMaterials = []; var Colors; (function (Colors) { Colors[(Colors["Red"] = 14959170)] = "Red"; Colors[(Colors["Green"] = 3066993)] = "Green"; })(Colors || (Colors = {})); var currentColor = Colors.Green; let currentPosition; if (providedOrigin) { currentPosition = new THREE.Vector3( providedOrigin.x, providedOrigin.y, providedOrigin.z ); } else { currentPosition = new THREE.Vector3(0, 0, 0); } let opcodeRe = /(G[0-9]+|M[0-9]+)/; let opXRe = /X(-?[0-9]+.?[0-9]+)/; let opYRe = /Y(-?[0-9]+.?[0-9]+)/; let opZRe = /Z(-?[0-9]+.?[0-9]+)/; let opFRe = /F(-?[0-9]+.?[0-9]+)/; let findOpcode = (instruction, argRe) => { let maybeArgResults = instruction.match(argRe); if (!maybeArgResults) { return ""; } return maybeArgResults[0]; }; let findArg = (instruction, argRe, fallback) => { let maybeArgResults = instruction.match(argRe); if (!maybeArgResults || maybeArgResults.length < 2) { return fallback; } return parseFloat(maybeArgResults[1]) * SCALE_FACTOR; }; var newPosition = currentPosition.clone(); var tokens, duration; var posChange; var materialColor = Colors.Green; let positions = [new THREE.Vector3()]; let opcode, opX, opY, opZ; toolpath.forEach((instruction, instIdx) => { mutable test = instIdx; opcode = findOpcode(instruction, opcodeRe); if (opcode === "G0" || opcode === "G1") { (opX = findArg(instruction, opXRe, currentPosition.x)), (opY = findArg(instruction, opYRe, currentPosition.y)), // Two negatives here because our coordinate basis is wonky (opZ = -findArg(instruction, opZRe, -currentPosition.z)); newPosition = new THREE.Vector3(opX, opY, opZ); moveCurve2 = new THREE.LineCurve3(currentPosition, newPosition); positions.push(newPosition); toolpathCurves.push(moveCurve2); currentPosition = newPosition; } }); let positionsFlat = positions.map((vec) => [vec.x, vec.y, vec.z]).flat(); let color = positions.map((_) => [255, 0, 0]).flat(); let lineGeom = new LineGeometry(); lineGeom.setPositions(positionsFlat); lineGeom.setColors(color); let material = new LineMaterial({ linewidth: lineThickness, vertexColors: true, //resolution: // to be set by renderer, eventually // Hmmm the below vector works? It was never set on its own and // crashed the browser resolution: new THREE.Vector2(640, 480), dashed: false }); let line = new Line2(lineGeom, material); line.scale.set(1, 1, 1); line.computeLineDistances(); let wrapperGroup = new THREE.Group(); const initialZDrop = 0.6996; // line.translateZ(-initialZDrop * SCALE_FACTOR); wrapperGroup.add(line); wrapperGroup.rotateX(Math.PI / 2); return wrapperGroup; }; return VisualizationInterpreters; })()39:T29c9,class TaxonScene { static modelBoxHelperColor = 0xe44242; constructor(container, animateContinuously) { this.scene = this.initScene(); this.camera = this.initCamera(this.scene, true); this.renderer = this.initRenderer(container); this.clock = new THREE.Clock(); this.mixers = []; this.controls = this.initControls(this.camera, this.renderer); this.instructionQueue = new InstructionQueue(); this.toolpathLookup = {}; this.renderRequested = false; if (animateContinuously) { let animate = () => { let maxFramerate = 20; requestAnimationFrame(animate); // setTimeout(() => { // if (true) { // requestAnimationFrame(animate); // } // }, 1000 / maxFramerate); this.renderScene(); }; animate(); } } initScene() { let scene = new THREE.Scene(); scene.background = new THREE.Color(0xf5f6f8); let topDirectionalLight = new THREE.DirectionalLight(0xffffff, 0.75); let leftDirectionalLight = new THREE.DirectionalLight(0xffffff, 0.5); let rightDirectionalLight = new THREE.DirectionalLight(0xffffff, 0.25); let ambientLight = new THREE.AmbientLight(0x404040); leftDirectionalLight.position.set(-1.0, 0.0, 0.0); rightDirectionalLight.position.set(0.0, 0.0, 1.0); scene.add(topDirectionalLight); scene.add(leftDirectionalLight); scene.add(rightDirectionalLight); scene.add(ambientLight); this.materialMarks = new THREE.Group(); this.materials = new THREE.Group(); this.toolpathsGroup = new THREE.Group(); scene.add(this.materialMarks); scene.add(this.materials); scene.add(this.toolpathsGroup); return scene; } initCamera(scene, isOrtho) { let camera; let aspect = 720 / 480; let viewSize = 50; if (isOrtho) { camera = new THREE.OrthographicCamera( -viewSize * aspect, viewSize * aspect, viewSize, -viewSize, -1000, 10000 ); camera.zoom = 0.35; camera.updateProjectionMatrix(); camera.frustumCulled = false; camera.position.set(-500, 500, 500); // I don't know why this works camera.lookAt(scene.position); camera.position.set(-400, 500, 800); // Pan away to move machine to left } else { let fov = 50; camera = new THREE.PerspectiveCamera(fov, aspect, 0.01, 30000); camera.lookAt(scene.position); camera.position.set(-500, 500, 500); camera.updateProjectionMatrix(); } return camera; } initRenderer(container) { let renderer = new THREE.WebGLRenderer({ antialias: true }); renderer.setPixelRatio(window.devicePixelRatio); renderer.setSize(720, 480); container.appendChild(renderer.domElement); return renderer; } initControls(camera, renderer) { var controls = new THREE.OrbitControls(camera, renderer.domElement); controls.rotateSpeed = 1.0; controls.zoomSpeed = 0.8; controls.panSpeed = 0.8; controls.addEventListener("change", this.requestRenderScene.bind(this)); controls.enableDamping = true; controls.dampingFactor = 0.5; return controls; } requestRenderScene() { if (!this.renderRequested) { this.renderRequested = true; requestAnimationFrame(this.renderScene.bind(this)); } } recompileMachine() { if (this.machine && this.lastCompiledMachineProg) { let compiler = new Compiler(); compiler.decompileIntoScene(this, this.lastCompiledMachineProg); } } addSceneObjectDirectly(sceneObj) { this.scene.add(sceneObj); } removeFromScene(sceneObj) { this.scene.remove(sceneObj); } addToolpath(toolpath) { this.toolpathLookup[toolpath.name] = toolpath; this.toolpathsGroup.add(toolpath.group); } removeToolpath(toolpath) { delete this.toolpathLookup[toolpath.name]; this.toolpathsGroup.remove(toolpath.group); } removeAllToolpaths() { this.scene.remove(this.toolpathsGroup); this.toolpathsGroup = new THREE.Group(); this.toolpathLookup = {}; } getToolpathWithName(toolpathName) { return this.toolpathLookup[toolpathName]; } removeMaterials() { let childrenRefCopy = this.materials.children.splice(0); childrenRefCopy.forEach((mark) => { this.materials.remove(mark); }); } removeMaterialMarks() { let childrenRefCopy = this.materialMarks.children.splice(0); childrenRefCopy.forEach((mark) => { this.materialMarks.remove(mark); }); } renderScene() { this.controls.update(); let deltaSeconds = this.clock.getDelta(); this.mixers.forEach((mixer) => { mixer.update(deltaSeconds); }); this.renderer.render(this.scene, this.camera); if (this.mixers.length > 0) { requestAnimationFrame(this.renderScene.bind(this)); } else { this.renderRequested = false; } } getClickedObjectsFromClickEvent(event) { if (this.machine === undefined) { return []; } let vector = new THREE.Vector3(); let raycaster = new THREE.Raycaster(); let dir = new THREE.Vector3(); let candidates = this.machine.blocks; let candidateMeshes = candidates.map((c) => c.meshGroup); vector.set( (event.clientX / window.innerWidth) * 2 - 1, -(event.clientY / window.innerHeight) * 2 + 1, -1 ); // z = - 1 important! vector.unproject(this.camera); dir.set(0, 0, -1).transformDirection(this.camera.matrixWorld); raycaster.set(vector, dir); let searchRecursively = true; let isectMeshes = raycaster.intersectObjects( candidateMeshes, searchRecursively ); if (isectMeshes.length === 0) { return []; } let meshGroupNames = isectMeshes.map((m) => m.object.parent.blockName); return meshGroupNames; } loadModel(filepath) { if (this.machine === undefined) { const e = "Please pick a machine before uploading a model."; window.taxonGui.writeErrorToJobLog(e); return Promise.reject(new Error("Need to pick machine first")); } if (this.model !== undefined) { this.clearModelFromScene(); } let loadPromise = new Promise((resolve) => { let loader = new THREE.STLLoader(); let stlMesh; return loader.load( filepath, (stlGeom) => { let material = new THREE.MeshLambertMaterial({ color: BuildEnvironment.color, // Do not cull triangles with inward-pointing normals side: THREE.DoubleSide }); stlMesh = new THREE.Mesh(stlGeom, material); stlMesh.isLoadedStl = true; stlMesh.scale.set(2, 2, 2); stlMesh.rotateX(-Math.PI / 2); this.model = stlMesh; this.modelGeom = stlGeom; this.modelBoxHelper = new THREE.BoxHelper( stlMesh, TaxonScene.modelBoxHelperColor ); this.modelBox3 = new THREE.Box3(); // NOTE: for some reason, we need to call Box3.setFromObject // before calling it after positioning the model in the // work envelope as well, otherwise we get an internal // threejs error this.modelBox3.setFromObject(this.model); this.scene.add(this.model); this.scene.add(this.modelBoxHelper); this.positionModelOnWorkEnvelope(); this.modelBox3.setFromObject(this.model); this.checkModelFitsInWorkEnvelope(); let modelStats = this.calculateModelStats(); let m = JSON.stringify(modelStats, undefined, 2); window.taxonGui.writeMessageToModelCheck(m); resolve(stlMesh); }, undefined, (errorMsg) => { console.log(errorMsg); } ); }); return loadPromise; } calculateModelStats() { let stats = { modelFileName: "", fitsInWorkEnvelope: false, materialMatches: false }; let modelFileInputDom = document.getElementById("new-model-input"); let fileNameTokens = modelFileInputDom.value.split("\\"); stats.modelFileName = fileNameTokens[fileNameTokens.length - 1]; stats.fitsInWorkEnvelope = this.checkModelFitsInWorkEnvelope(); return stats; } positionModelOnWorkEnvelope() { if (this.model === undefined) { return; } let wePos = this.metrics.workEnvelope.position.clone(); let xOff = (this.modelBox3.max.x - this.modelBox3.min.x) / 2; let yOff = this.modelBox3.max.y - this.modelBox3.min.y; let zOff = (this.modelBox3.max.z - this.modelBox3.min.z) / 2; // FIXME: the y axis is messed up, idk how to get the correct // number in practice let offVect = new THREE.Vector3(xOff, 0, zOff); wePos.sub(offVect); this.model.position.copy(wePos); this.modelBoxHelper.update(); } rotateModelOverAxis(axis) { // NOTE: doesn't rotate around center of model, but rather // the origin which is at a corner of the bounding box. This // is not ideal behavior, but I'm not sure what I can do to // fix this. if (this.machine === undefined || this.model === undefined) { const m = "Please pick a machine and model first."; window.taxonGui.writeMessageToModelCheck(m); return; } let rotQ = new THREE.Quaternion(); let eulerAngle; if (axis === "x") { eulerAngle = new THREE.Euler(Math.PI / 2, 0, 0); } else if (axis === "y") { eulerAngle = new THREE.Euler(0, 0, Math.PI / 2); } else if (axis === "z") { eulerAngle = new THREE.Euler(0, Math.PI / 2, 0); } else { console.error("Must specify rotation axis"); return; } rotQ.setFromEuler(eulerAngle); this.model.quaternion.multiply(rotQ); this.modelBoxHelper.update(); this.modelBox3.setFromObject(this.model); let modelStats = this.calculateModelStats(); let m = JSON.stringify(modelStats, undefined, 2); window.taxonGui.writeMessageToModelCheck(m); } checkModelFitsInWorkEnvelope() { console.assert(this.machine !== undefined, this); console.assert(this.model !== undefined, this); let origin = this.metrics.workEnvelope.position.clone(); let we = this.metrics.workEnvelope; let weSizeVect = new THREE.Vector3(we.width, we.height, we.length); let weBox = new THREE.Box3(); weBox.setFromCenterAndSize(origin, weSizeVect); let fitResult = weBox.containsBox(this.modelBox3); return fitResult; } clearModelFromScene() { this.scene.remove(this.model); this.scene.remove(this.modelBox3); this.scene.remove(this.modelBoxHelper); this.model = undefined; this.modelBox3 = undefined; this.modelBoxHelper = undefined; } }3a:T16af,class Machine { constructor(name, parentScene, isPreview = false) { this.name = name; this.parentScene = parentScene; this.isPreview = isPreview; this.rootMeshGroup = new THREE.Group(); this.parentScene.scene.add(this.rootMeshGroup); this.buildEnvironment = undefined; this.workEnvelope = undefined; this.blocks = []; this.connections = []; this.axisToDim = { x: "width", y: "height", z: "length" }; this.kinematics = new Kinematics(this.parentScene); if (this.isPreview) { parentScene.previewMachine = this; } else { parentScene.machine = this; this.parentScene.instructionQueue.kinematics = this.kinematics; } } get tools() { return this.blocks.filter((b) => b.componentType === "Tool"); } recolorAndMoveMachineForPreviewing(recolorName) { const color = recolorName === "green" ? 0x2ecc71 : 0xe44242; let previewMaterialWorkEnvelope = new THREE.MeshLambertMaterial({ color: color, transparent: true, opacity: 0.75 }); let previewMaterialWire = new THREE.LineBasicMaterial({ color: color }); this.rootMeshGroup.traverse((child) => { if (child.isWorkEnvelopeMesh) { child.material = previewMaterialWorkEnvelope; } else if (child instanceof THREE.LineSegments) { child.material = previewMaterialWire; } else if ( child instanceof THREE.Mesh || child instanceof THREE.ArrowHelper ) { child.visible = false; } }); } findParallelBlockGroups() { let blocksByAddId = {}; this.connections.forEach((connection) => { let addId = connection.addBlock.id; if (blocksByAddId[addId] === undefined) { blocksByAddId[addId] = [connection.baseBlock]; } else { blocksByAddId[addId].push(connection.baseBlock); } }); let parallelBlockGroups = []; Object.keys(blocksByAddId).forEach((addId) => { if (blocksByAddId[addId].length > 1) { parallelBlockGroups.push(blocksByAddId[addId]); } }); return parallelBlockGroups; } __calcBlockDimVectorFromAxis(block, axis) { if (axis === "center") { return new THREE.Vector3(0, 0, 0); } let sign = axis[0] === "+" ? 1 : -1; if (axis[1] === "x") { return new THREE.Vector3(sign * block.width, 0, 0); } if (axis[1] === "y") { return new THREE.Vector3(0, sign * block.height, 0); } if (axis[1] === "z") { return new THREE.Vector3(0, 0, sign * block.length); } else { console.error(`Invalid axis: ${axis}`); } } addBlock(block) { this.blocks.push(block); } findBlockWithName(name) { let block = this.blocks.find((block) => block.name === name); if (block === undefined) { console.trace(`Couldn't find block named: ${name}.`); } return block; } getTool(name) { let maybeTool; if (name !== undefined) { maybeTool = this.tools.find((t) => t.name === name); return maybeTool; } else { maybeTool = this.tools[0]; } if (!maybeTool) { console.error(`Couldn't find tool: ${name || "any tool at all"}`); } return maybeTool; } getEquippedTool() { return this.tools.find((t) => t.attributes.equipped); } getPlatform() { return this.blocks.find((b) => b.componentType === "Platform"); } hide() { this.rootMeshGroup.visible = false; } show() { this.rootMeshGroup.visible = true; } clearMachineFromScene() { if (this.buildEnvironment !== undefined) { this.buildEnvironment.removeMeshGroupFromScene(); this.buildEnvironment = undefined; } if (this.workEnvelope !== undefined) { this.workEnvelope.removeMeshGroupFromScene(); this.workEnvelope = undefined; } if (this.kinematics.zeroGrid) { this.parentScene.removeFromScene(this.kinematics.zeroGrid); } this.blocks.forEach((block, index) => { block.removeMeshGroupFromScene(); }); this.blocks = []; if (this.isPreview) { this.parentScene.previewMachine = undefined; } else { this.parentScene.machine = undefined; } } /** * Connects two components such that the center point on a face of some * addBlock becomes fixed to the center of the face of baseBlock. * For now, we only support center connections, but later will support * connections at either end. * * connectionObj should be of the form: * { * baseBlock: Component, * baseBlockFace: String in { '+x', '-x', '+y', ... , '-z' }, * addBlock: Component, * addBlockFace: String in { '+x', '-x', '+y', ... , '-z' } * } */ setConnection(parentBlock, connectionObj) { let childName = connectionObj.child; let childBlock = this.findBlockWithName(childName); console.assert(parentBlock !== undefined); console.assert(childBlock !== undefined); let offset = connectionObj.offset || new THREE.Vector3(); let isInert = !!connectionObj.isInert; let translationVector = parentBlock.position .clone() .sub(childBlock.position); let offsetVector = new THREE.Vector3(offset.x, offset.y, offset.z); let applyModificationsToBlock = (block) => { block.position.add(translationVector); block.position.sub(offsetVector); block.baseBlock = false; }; // Update the kinematic tree before gathering descendents and updating // positions this.connections.push(connectionObj); this.kinematics.addConnectionToTree(parentBlock, childBlock, isInert); let childBlockAndDescendents = [childBlock].concat(childBlock.descendents); childBlockAndDescendents.forEach((block) => applyModificationsToBlock(block) ); return this; } }3b:T4344,class Kinematics { constructor(taxonScene) { this.rootKNodes = []; this.taxonScene = taxonScene; this.taxonAnimator = new TaxonAnimator(taxonScene); } get machine() { return this.taxonScene.machine; } get metrics() { return this.taxonScene.metrics; } addBlockAsRootNode(block) { let kNode = new KNode(block, undefined); this.rootKNodes.push(kNode); this.redetermineRootKNodes(); } disconnectRootNodeForBlock(block) { let rootNodeBlockNames = this.rootKNodes.map((kn) => kn.block.name); console.assert(rootNodeBlockNames.includes(block.name)); let rootNode = this.findNodeWithBlockName(block.name); // There should only be one child... let toolChild; rootNode.childNodes.forEach((child) => { child.parentNode = undefined; this.rootKNodes.push(child); toolChild = child; }); rootNode.childNodes = []; return toolChild; } addNewBlockAsRoot(newBlock) { // note that "child" and "parent" here are the sense of connections // where this is reversed in the actual ktree implementation let childBlock = newBlock; // Assuming we only have one tool with a full kinematic chain behind // it and this is the "current" tool let currNode = this.rootKNodes.find((knode) => { return knode.childNodes.length > 0; }); let parentBlock = currNode.block; this.addConnectionToTree(parentBlock, childBlock, false); let cnIdx = this.rootKNodes.indexOf(currNode); this.rootKNodes.splice(cnIdx); } redetermineRootKNodes(possibleRootNode) { let maybeNodeToRemove; this.rootKNodes.forEach((rootKNode) => { if (rootKNode.parentNode !== undefined) { maybeNodeToRemove = rootKNode; } }); if (maybeNodeToRemove) { let removeIdx = this.rootKNodes.indexOf(maybeNodeToRemove); this.rootKNodes.splice(removeIdx, 1); } } zeroAtCurrentPosition() { this.zeroPosition = this.getWorldPosition(); // NOTE: we may want to move this to a UI class let we = this.taxonScene.metrics.workEnvelope; let sizeMultiplier = 1.0; let gridSize = sizeMultiplier * Math.max(we.width || 0, we.height || 0, we.length || 0); let divisions = Math.floor(gridSize / 10); let centerColor = 0xaaaaaa; let mainColor = 0xcccccc; if (this.zeroGrid) { this.taxonScene.removeFromScene(this.zeroGrid); } this.zeroGrid = new THREE.GridHelper( gridSize, divisions, centerColor, mainColor ); if (we.shape === "rectangle") { if (!we.width) { this.zeroGrid.rotateZ(Math.PI / 2); } else if (!we.length) { this.zeroGrid.rotateX(Math.PI / 2); } } this.taxonScene.addSceneObjectDirectly(this.zeroGrid); this.zeroGrid.position.copy(this.zeroPosition); } getWorldPosition() { // TODO: do for 2-axis machines let worldPosition = new THREE.Vector3(); let tool = this.machine.getTool(); let halfToolHeightVect = new THREE.Vector3(0, -tool.height / 2, 0); let bottomOfToolPoint = tool.position.clone().add(halfToolHeightVect); worldPosition.copy(bottomOfToolPoint); let maybePlatform = this.machine.getPlatform(); if (maybePlatform !== undefined && !maybePlatform.isImmobile) { // TODO: make a Platform method that has user set motionAxis let platformMotionAxis = "x"; worldPosition.setX(-maybePlatform.position.x); } return worldPosition; } coordsToWorldPosition(coords) { let pt = new THREE.Vector3(coords.x, coords.y, coords.z); return this.unzeroPoint(pt); } getZeroedPosition() { // World coordinates -> control coordinates let zeroedPosition = new THREE.Vector3(); if (this.zeroPosition === undefined) { console.warn("Getting tool position on an unzeroed machine."); return THREE.Vector3(); } zeroedPosition.copy(this.getWorldPosition()); return zeroedPosition.sub(this.zeroPosition); } unzeroPoint(point) { // Control coordinates -> world coordinates if (this.zeroPosition === undefined) { console.warn("Getting tool position on an unzeroed machine."); return THREE.Vector3(); } let unzeroedPoint = new THREE.Vector3(); unzeroedPoint.copy(point); return unzeroedPoint.add(this.zeroPosition); } addConnectionToTree(parentBlock, childBlock, isInert = false) { let cNode, pNode; cNode = this.findNodeWithBlockName(childBlock.name); pNode = this.findNodeWithBlockName(parentBlock.name); // NOTE: connections in the tree's implementation are BACKWARDS // in the a child points to its parent. However, orphans still // go with the parent if (isInert) { pNode.addOrphanNodes([cNode]); } else { cNode.childNodes.push(pNode); pNode.parentNode = cNode; this.redetermineRootKNodes(); } return cNode; } findNodeWithBlockName(blockName) { let dfs = (currNode, targetName) => { if (currNode.block.name === targetName) { return currNode; } let maybeMatchingOrphan = currNode.orphanNodes.find((oNode) => { return oNode.block.name === blockName; }); if (maybeMatchingOrphan !== undefined) { return maybeMatchingOrphan; } let maybeResults = currNode.childNodes.map((childNode) => { return dfs(childNode, targetName); }); return maybeResults.find((result) => result !== undefined); }; let rootResults = this.rootKNodes.map((rootKNode) => { return dfs(rootKNode, blockName); }); let result = rootResults.find((result) => result !== undefined); if (result === undefined) { console.warn(`Cannot find block in kinematic tree: ${blockName}`); } return result; } pathFromNodeToRoot(node) { let traverse = (currNode, pathSoFar) => { if (currNode.parentNode === undefined) { return pathSoFar.concat(currNode); } return traverse(currNode.parentNode, pathSoFar.concat(currNode)); }; return traverse(node, []); } pathsFromNodeToLeaves(node) { let traverse = (currNode, pathSoFarList) => { if (currNode.childNodes.length === 0) { let terminatedPaths = pathSoFarList.map((pathSoFar) => { return pathSoFar.concat(currNode); }); return terminatedPaths; } // Invariant: on the descent, PSFL.length === 1 ie one path let pathWithCurrNodeCopy = pathSoFarList[0].concat(currNode); let newPathSoFarList = currNode.childNodes .map((childNode) => { return traverse(childNode, [pathWithCurrNodeCopy]); }) .flat(); return newPathSoFarList; }; return traverse(node, [[]]); } determineMachineAxes() { let blocks = this.machine.blocks.filter( (b) => b.actuationAxes !== undefined ); let allAxes = blocks.map((b) => b.actuationAxes).flat(); let uniqueAxes = allAxes.filter((axis, idx) => { return allAxes.indexOf(axis) === idx; }); let axisToBlockLists = {}; uniqueAxes.forEach((axis) => { axisToBlockLists[axis] = blocks.filter((block) => { return block.actuationAxes.indexOf(axis) !== -1; }); }); return axisToBlockLists; } determineMovingBlocks() { // TODO: add rom info as calculated below return this.rootKNodes.map((kNode) => kNode.block); } verifyMoveInWorkEnvelope(axesToCoords) { let toolGoalPosition = new THREE.Vector3( axesToCoords["x"], axesToCoords["y"], axesToCoords["z"] ); let containResult = this.checkContainsPoint(toolGoalPosition); if (!containResult) { let e = `Move to ${axesToCoords.x} ${axesToCoords.y} ${axesToCoords.z} is outside work envelope.`; console.error(e); } return containResult; } checkContainsPoint(point) { // Hack to handle precision errors with work envelope sizes const eps = 0.25; let we = this.metrics.workEnvelope; let unzeroedPoint = this.unzeroPoint(point); let center = we.position; if (we.shape === "cylinder") { let magnitudeNormalized = Math.sqrt( (unzeroedPoint.x - we.position.x) ** 2 + (unzeroedPoint.z - we.position.z) ** 2 ); return ( unzeroedPoint.y >= we.position.y - we.height / 2 && unzeroedPoint.y <= we.position.y + we.height / 2 && magnitudeNormalized <= we.radius ); } else { let bbox = new THREE.Box3(); let size = new THREE.Vector3( we.width + eps, we.height + eps, we.length + eps ); // This region's bounding box if it's a rectangle is "infinite" on // the flat axis if (we.shape === "rectangle") { const largeNumber = 9000; if (!we.width) { size.x = largeNumber; } if (!we.height) { size.y = largeNumber; } if (!we.length) { size.z = largeNumber; } } bbox.setFromCenterAndSize(center, size); return bbox.containsPoint(unzeroedPoint); } } moveTool(axesToCoords, extrudeMM) { // NOTE: distinction between coords (zero applied) and position // matters here, as well is in verifyMoveInWorkEnvelope, but not // in the rest of moveToolRelative let validMove = this.verifyMoveInWorkEnvelope(axesToCoords); if (validMove) { let axesToCoordsAdjusted = {}; let currentPositionMachineCoords = this.getZeroedPosition(); let adjustedPoint = new THREE.Vector3( axesToCoords.x, axesToCoords.y, axesToCoords.z ); adjustedPoint.sub(currentPositionMachineCoords); axesToCoordsAdjusted = { x: adjustedPoint.x, y: adjustedPoint.y, z: adjustedPoint.z }; this.moveToolRelative(axesToCoordsAdjusted, extrudeMM); return true; } return false; } moveToolRelative(axesToCoords, extrudeMM) { let machine = this.taxonScene.machine; let blockNameToDisplacement = {}; machine.blocks.forEach((block) => { if (block.kinematics === "hBot" || block.kinematics === "coreXY") { let axisFirst = block.actuationAxes[0]; let axisSecond = block.actuationAxes[1]; let displacements = [axesToCoords[axisFirst], axesToCoords[axisSecond]]; blockNameToDisplacement[block.name] = displacements; } else if (block.kinematics === "directDrive") { let axis = block.actuationAxes[0]; let displacement = axesToCoords[axis]; blockNameToDisplacement[block.name] = displacement; } else if (block.kinematics === "deltaBot") { let axisFirst = block.actuationAxes[0]; let axisSecond = block.actuationAxes[1]; let axisThird = block.actuationAxes[2]; let displacements = [ axesToCoords[axisFirst], axesToCoords[axisSecond], axesToCoords[axisThird] ]; blockNameToDisplacement[block.name] = displacements; } else if (block.kinematics === "rotary") { // TODO } }); this.actuateAllBlocks(blockNameToDisplacement, extrudeMM); } __addDirectDriveIK(axesToCoords, motorNameToSteps) { let axisToStageLists = this.determineMachineAxes(); let directDriveStages = this.machine.blocks.filter((block) => { return block.kinematics === "directDrive"; }); directDriveStages.forEach((stage) => { console.assert(stage.actuationAxes.length === 1, stage); stage.drivingMotors.forEach((motor) => { let invert = motor.invertSteps ? -1 : 1; let axis = stage.actuationAxes[0]; let steps = axesToCoords[axis]; motorNameToSteps[motor.name] = steps * invert; }); }); } __addHBotIK(axesToCoords, motorNameToSteps) { let axisToStageLists = this.determineMachineAxes(); let crossStages = this.machine.blocks.filter((block) => { return block instanceof CrossStage; }); crossStages.forEach((crossStage) => { console.assert(crossStage.drivingMotors.length === 2, crossStage); let motorA = crossStage.drivingMotors[0]; let motorB = crossStage.drivingMotors[1]; let axisASteps = axesToCoords[crossStage.axes[0]]; let axisBSteps = axesToCoords[crossStage.axes[1]]; motorNameToSteps[motorA.name] = axisASteps + axisBSteps; motorNameToSteps[motorB.name] = axisASteps - axisBSteps; }); } actuateBlock(block, displacement) { let sign = block.invertDisplacement ? -1 : 1; let blockNode = this.findNodeWithBlockName(block.name); let path = this.pathFromNodeToRoot(blockNode).slice(1); let pathBlocks = path .map((node) => { let orphanBlocks = node.orphanNodes.map((node) => node.block); return [node.block].concat(orphanBlocks); }) .flat(); let pathBlockNames = pathBlocks.map((block) => block.name); if (block.kinematics === "hBot" || block.kinematics === "coreXY") { console.assert(displacement.length && displacement.length === 2); this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, block.actuationAxes[0], sign * displacement[0] ); this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, block.actuationAxes[1], sign * displacement[1] ); } else if (block.kinematics === "deltaBot") { console.assert(displacement.length && displacement.length === 3); this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, block.actuationAxes[0], sign * displacement[0] ); this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, block.actuationAxes[1], sign * displacement[1] ); this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, block.actuationAxes[2], sign * displacement[2] ); } else if (block.kinematics === "directDrive") { let axisName = block.actuationAxes[0]; this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, axisName, sign * displacement ); } else if (block.kinematics === "rotary") { // TODO } } actuateAllBlocks(blockNameToDisplacement, extrudeMM) { Object.keys(blockNameToDisplacement).forEach((blockName) => { let block = this.machine.findBlockWithName(blockName); let displacement = blockNameToDisplacement[blockName]; this.actuateBlock(block, displacement); }); this.taxonAnimator.animateToBlockEndPositions(extrudeMM); } turnMotors(motorNameToSteps) { Object.keys(motorNameToSteps).forEach((motorName) => { let motor = this.taxonScene.machine.findBlockWithName(motorName); let steps = motorNameToSteps[motorName]; this.__turnMotorSteps(motor, steps); }); this.taxonAnimator.animateToBlockEndPositions(); } __turnMotorSteps(motor, steps) { // TODO: have step -> displacement conversion assigned in motor, // for now assume 1-to-1 // Invariants: drivenStages.length === 1 let displacement = steps; let stage = motor.drivenStages[0]; let drivenStageNode = this.findNodeWithBlockName(stage.name); let path = this.pathFromNodeToRoot(drivenStageNode).slice(1); let pathBlocks = path .map((node) => { let orphanBlocks = node.orphanNodes.map((node) => node.block); return [node.block].concat(orphanBlocks); }) .flat(); let pathBlockNames = pathBlocks.map((block) => block.name); if (stage.kinematics === "hBot" || stage.kinematics === "coreXY") { // Invariants: stage.drivingMotors.length === 2, same with axes console.assert(stage.drivingMotors.length === 2, stage); console.assert(stage.axes.length === 2, stage); let motorIndexInPair = stage.drivingMotors.indexOf(motor); if (motorIndexInPair === 0) { let axis0displacement = 0.5 * displacement; let axis1displacement = 0.5 * displacement; this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, stage.axes[0], axis0displacement ); this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, stage.axes[1], axis1displacement ); } else { let axis0displacement = 0.5 * displacement; let axis1displacement = -0.5 * displacement; this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, stage.axes[0], axis0displacement ); this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, stage.axes[1], axis1displacement ); } } if (stage.kinematics === "directDrive") { // Invariants: axes.length === 1 let axisName = stage.axes[0]; // NOTE: we divide displacement by parallel stages by the number // of motors to stop the stage from actuating too far. This is a // bit of a kludge, but it is simpler than passing stage info // into the animator. if (stage instanceof ParallelStage) { displacement /= stage.drivingMotors.length; } this.taxonAnimator.setMoveBlocksOnAxisName( pathBlocks, axisName, displacement ); } } }3c:T44c,class KNode { constructor(block, parentNode) { this.block = block; this.parentNode = parentNode; this.childNodes = []; this.parallelNodes = []; this.orphanNodes = []; } addChildNodes(childNodes) { this.childNodes = this.childNodes.concat(childNodes); } addParallelNodes(parallelNodes) { this.parallelNodes = this.parallelNodes.concat(parallelNodes); } addOrphanNodes(orphanNodes) { this.orphanNodes = this.orphanNodes.concat(orphanNodes); } /** * Returns ROM unnormalized for position in the form: * { romAxis: x, rom: 200 } */ calcNodeRangeOfMotion(kinematics) { if (kinematics === undefined) { console.error("Please pass in kinematics."); return; } if (this.block.componentType !== "LinearStage") { return { romAxis: "center", rom: 0 }; } let romAxis, rom; let axisToDim = { x: "width", y: "height", z: "length" }; romAxis = kinematics.determineAxisNameForBlock(this.block); rom = this.block[axisToDim[romAxis]]; return { romAxis: romAxis, rom: rom }; } }3d:Tfc3,class InstructionQueue { // NOTE: instantiate only one InstructionQueue and do so as // TaxonScene.InstructionQueue constructor() { this.arr = []; this.unsetMotorsBusy(); this.currInstIdx = -1; } get length() { return this.arr.length; } get isEmpty() { return this.length === 0; } setMotorsBusy() { this.motorsBusy = true; } unsetMotorsBusy() { this.motorsBusy = false; } setKinematics(kinematics) { this.kinematics = kinematics; } setJobFile(jobFile) { this.jobFile = jobFile; } enqueueInstruction(instruction) { return this.arr.push(instruction); } setQueueFromArray(instArray) { this.arr = instArray.slice(); } peekNext() { return this.arr[0]; } instIsComment(inst) { return inst[0] === ";"; } instIsMCode(inst) { return inst[0] === "M"; } executeNextInstruction() { if (this.kinematics === undefined) { console.error("No kinematics set for instruction queue."); return; } if (this.jobFile === undefined) { // Moves that don't involve pre-loaded files return; } if (this.isEmpty) { let m = "No more instructions to execute."; window.taxonGui.writeMessageToJobLog(m); this.currInstIdx = -1; let zeroGrid = this.kinematics.zeroGrid; this.kinematics.taxonScene.removeFromScene(zeroGrid); // jobFile.removeDomHighlight(); return; } if (this.motorsBusy) { console.warn(`Motors are busy. Next instruction: ${this.peekNext()}.`); return; } this.currInstIdx += 1; let nextInst = this.arr.splice(0, 1)[0]; this.__executeInst(nextInst); } doDryRunInstructions() { return this.__dryExecuteInstWithIndex(0); } __executeInst(inst) { if (this.instIsComment(inst) || this.instIsMCode(inst)) { // Set timeout for next instruction after a comment because // we don't want to call the next instruction on this current // stack frame—let this frame return and call next EPS_MS later. let epsMs = 10; setTimeout(() => this.executeNextInstruction(), epsMs); return; } console.log(`Executing: ${inst}`); // jobFile.setDomHighlightToInstIdx(this.currInstIdx); this.setMotorsBusy(); let tokens = inst.split(" "); let opcode = tokens[0]; if (opcode === "G0" || opcode === "G1") { this.__handleG0(tokens); } if (opcode === "G92") { this.__handleG92(tokens); } } __dryExecuteInstWithIndex(instIdx) { // TODO: static checking recursively if (this.arr[instIdx] === undefined) { return; } let inst = this.arr[instIdx]; if (this.instIsComment(inst)) { // Assuming tail call optimization return this.__dryExecuteInstWithIndex(instIdx + 1); } console.log(`Checking: ${inst}`); let tokens = inst.split(" "); let opcode = tokens[0]; if (opcode === "G0" || opcode === "G1") { // Run absolute -> relative, then static check } if (opcode === "G92") { // Have to set zero actually and undo it later, or // save to a separate zero? } return this.__dryExecuteInstWithIndex(instIdx + 1); } __handleG0(tokens) { let xCoord = parseInt(tokens[1].substring(1)); let yCoord = parseInt(tokens[2].substring(1)); let zCoord = parseInt(tokens[3].substring(1)); let axesToCoords = { x: xCoord, y: yCoord, z: zCoord }; // This call eventually sets a callback that calls // executeInstruction in a THREE.js mixer in TaxonScene let moveSuccessResult = this.kinematics.moveTool(axesToCoords); if (!moveSuccessResult) { this.unsetMotorsBusy(); this.jobFile.highlightCurrInstAsError(); let zeroGrid = this.kinematics.zeroGrid; this.kinematics.taxonScene.removeFromScene(zeroGrid); this.currInstIdx = -1; } } __handleG92(tokens) { this.kinematics.zeroAtCurrentPosition(); this.unsetMotorsBusy(); this.executeNextInstruction(); } }3e:T2526,class TaxonAnimator { constructor(taxonScene) { // Number of seconds for animation for each move this.ANIM_SECONDS = 1.0; this.taxonScene = taxonScene; this.blockNameEndPositions = {}; // Note that mixers must stay in TaxonScene for rendering } isAnimatingAPlatform() { let maybePlatform = this.taxonScene.machine.getPlatform(); return maybePlatform && !maybePlatform.isImmobile; } calcPlatformTranslation() { let platform = this.taxonScene.machine.getPlatform(); let currPos = platform.position; let endPos = this.blockNameEndPositions[platform.name]; return endPos.clone().sub(currPos); } calcPlatformPos() { let platform = this.taxonScene.machine.getPlatform(); let currPos = platform.position.clone().setY(0); return currPos; } animateToBlockEndPositions(extrudeMM) { let actions = Object.keys(this.blockNameEndPositions) .map((blockName) => { let block = this.taxonScene.machine.findBlockWithName(blockName); let endPos = this.blockNameEndPositions[block.name]; let mixerClipPair = this.makeMoveMixerClipPair(block, endPos); let mixer = mixerClipPair[0]; this.taxonScene.mixers.push(mixer); let clip = mixerClipPair[1]; let action = mixer.clipAction(clip); action.loop = THREE.LoopOnce; action.clampWhenFinished = true; if ( block.componentType === "Tool" && extrudeMM && (block.attributes.toolType === "liquidDispenser" || block.attributes.toolType === "print3d") ) { let materialStartPos, materialEndPos; if (this.isAnimatingAPlatform()) { let platformT = this.calcPlatformTranslation(); let platformPos = this.calcPlatformPos(); materialStartPos = block.position.clone().sub(platformT); materialEndPos = endPos.clone().sub(platformT); } else { materialStartPos = block.position.clone(); materialEndPos = endPos.clone(); } let materialMCPair = this.makeMaterialMixerClipMair( block, materialStartPos, materialEndPos ); let mixer = materialMCPair[0]; let clip = materialMCPair[1]; this.taxonScene.mixers.push(mixer); let materialAction = mixer.clipAction(clip); materialAction.loop = THREE.LoopOnce; materialAction.clampWhenFinished = true; return [action, materialAction]; } if ( block.componentType === "Tool" && block.attributes.toolType === "wire" ) { let materialStartPos = block.position.clone(); let materialEndPos = endPos.clone(); let materialMCPair = this.makeCutPlaneMixerClipPair( block, materialStartPos, materialEndPos ); let mixer = materialMCPair[0]; let clip = materialMCPair[1]; this.taxonScene.mixers.push(mixer); let materialAction = mixer.clipAction(clip); materialAction.loop = THREE.LoopOnce; materialAction.clampWhenFinished = true; return [action, materialAction]; } if (block.componentType === "Platform" && !block.isImmobile) { // TODO: translate all material marks here in addition to the // platform movement action let matGroup = this.taxonScene.materialMarks; let platformT = this.calcPlatformTranslation(); let endPos = matGroup.position.clone().add(platformT); let mixerClipPair = this.makeMoveMixerClipPair(matGroup, endPos); let mixer = mixerClipPair[0]; this.taxonScene.mixers.push(mixer); let clip = mixerClipPair[1]; let matMoveAction = mixer.clipAction(clip); matMoveAction.loop = THREE.LoopOnce; matMoveAction.clampWhenFinished = true; return [action, matMoveAction]; } else { return action; } }) .flat(); actions.forEach((action) => { action.play(); }); this.blockNameEndPositions = {}; } setMoveBlocksOnAxisName(blocks, axisName, displacement) { console.assert(blocks.length > 0); let currEndPos; blocks.forEach((block) => { if (this.blockNameEndPositions[block.name] === undefined) { currEndPos = new THREE.Vector3().copy(block.position); } else { currEndPos = this.blockNameEndPositions[block.name]; } currEndPos[axisName] += displacement; this.blockNameEndPositions[block.name] = currEndPos; }); } makeMoveMixerClipPair(obj, newPos) { let mixer = new THREE.AnimationMixer(obj); mixer.addEventListener("finished", (event) => { mixer.stopAllAction(); let idx = this.taxonScene.mixers.indexOf(mixer); if (idx !== -1) { this.taxonScene.mixers.splice(idx, 1); } obj.position.set(newPos.x, newPos.y, newPos.z); if (this.taxonScene.mixers.length === 0) { this.taxonScene.instructionQueue.unsetMotorsBusy(); this.taxonScene.instructionQueue.executeNextInstruction(); } }); let currPos = obj.position; let positionKF = new THREE.VectorKeyframeTrack( ".position", [0, this.ANIM_SECONDS], [currPos.x, currPos.y, currPos.z, newPos.x, newPos.y, newPos.z], THREE.InterpolateSmooth ); let clip = new THREE.AnimationClip("Action", this.ANIM_SECONDS, [ positionKF ]); return [mixer, clip]; } makeMaterialMixerClipMair(obj, startPos, newPos) { const numTubeSegs = Math.floor(obj.position.distanceTo(newPos)); const radius = 1; const radialSegs = 4; const isClosed = false; // Make material mesh let heightOffset = new THREE.Vector3(0, obj.height / 2, 0); let points = [ obj.position.clone().sub(heightOffset), // startPos, newPos.clone().sub(heightOffset) ]; let path = new THREE.CatmullRomCurve3(points); let geom = new THREE.TubeBufferGeometry( path, numTubeSegs, radius, radialSegs, isClosed ); geom.setDrawRange(0, 0); let mat = new THREE.MeshLambertMaterial({ color: Tool.color }); let mesh = new THREE.Mesh(geom, mat); this.taxonScene.materialMarks.add(mesh); // Set up animation const nMax = 3 * radialSegs * numTubeSegs * 2; let mixer = new THREE.AnimationMixer(mesh); mixer.addEventListener("finished", (event) => { mixer.stopAllAction(); let idx = this.taxonScene.mixers.indexOf(mixer); if (idx !== -1) { this.taxonScene.mixers.splice(idx, 1); } geom.setDrawRange(0, nMax); if (this.taxonScene.mixers.length === 0) { this.taxonScene.instructionQueue.unsetMotorsBusy(); this.taxonScene.instructionQueue.executeNextInstruction(); } }); let positionKF = new THREE.NumberKeyframeTrack( ".geometry[drawRange].count", [0, this.ANIM_SECONDS], [0, nMax], THREE.InterpolateSmooth ); let clip = new THREE.AnimationClip("Action", this.ANIM_SECONDS, [ positionKF ]); return [mixer, clip]; } makeCutPlaneMixerClipPair(obj, startPos, newPos) { // TODO: make a cut plane, project on material bdding box or better yet // be really clever with calculating and setting draw range w // plane geometry const numTubeSegs = Math.floor(obj.position.distanceTo(newPos)); const radius = 1; const radialSegs = 4; const isClosed = false; // Epsilon-height rectangle to extrude along path const rectEps = 0.1; let rectLength = obj.length; console.assert(rectLength !== undefined); let thinRect = new THREE.Shape([ new THREE.Vector2(0, 0), new THREE.Vector2(rectLength / 2, 0), new THREE.Vector2(rectLength / 2, rectEps), new THREE.Vector2(-rectLength / 2, rectEps), new THREE.Vector2(-rectLength / 2, 0), new THREE.Vector2(0, 0) ]); // Make material mesh let points = [obj.position.clone(), newPos.clone()]; let extrudePath = new THREE.CatmullRomCurve3(points); const extrudeSettings = { extrudePath: extrudePath, bevelEnabled: false }; let geom = new THREE.ExtrudeBufferGeometry(thinRect, extrudeSettings); geom.setDrawRange(0, 0); let mat = new THREE.MeshLambertMaterial({ color: Tool.color, transparent: true, opacity: 0.15 }); let mesh = new THREE.Mesh(geom, mat); this.taxonScene.materialMarks.add(mesh); // Set up animation const nMax = 3 * radialSegs * numTubeSegs * 2; let mixer = new THREE.AnimationMixer(mesh); mixer.addEventListener("finished", (event) => { mixer.stopAllAction(); let idx = this.taxonScene.mixers.indexOf(mixer); if (idx !== -1) { this.taxonScene.mixers.splice(idx, 1); } geom.setDrawRange(0, nMax); if (this.taxonScene.mixers.length === 0) { this.taxonScene.instructionQueue.unsetMotorsBusy(); this.taxonScene.instructionQueue.executeNextInstruction(); } }); let positionKF = new THREE.NumberKeyframeTrack( ".geometry[drawRange].count", [0, this.ANIM_SECONDS], [0, 0], // Do not actually animate the draw range THREE.InterpolateSmooth ); let clip = new THREE.AnimationClip("Action", this.ANIM_SECONDS, [ positionKF ]); return [mixer, clip]; } }3f:T159c,class TaxonComponent { static geometryFactories = { stageCase: (d) => new THREE.BoxBufferGeometry(d.width, d.height, d.length, 2, 2, 2), stagePlatform: () => new THREE.BoxBufferGeometry(50, 25, 50, 2, 2, 2), rotaryStageCase: () => new THREE.BoxBufferGeometry(150, 50, 150, 2, 2, 2), rotaryStagePlatform: () => new THREE.CylinderBufferGeometry(50, 50, 80, 10), tool: (dimensions) => { let radius = dimensions.width / 2; let height = dimensions.height; let numSegments = 10; return new THREE.CylinderBufferGeometry( radius, radius, height, numSegments ); }, toolAssembly: (d) => new THREE.BoxBufferGeometry(d.width, d.height, d.length, 2, 2, 2), connectionHandle: () => new THREE.SphereBufferGeometry(25, 32, 32), buildEnvironment: (dimensions) => new THREE.BoxBufferGeometry( dimensions.width, dimensions.length, 25, 2, 2, 2 ), workEnvelope: (dimensions) => { if (dimensions.shape === undefined) { return new THREE.PlaneBufferGeometry(250, 250); } if (dimensions.shape === "rectangle") { return new THREE.PlaneBufferGeometry( dimensions.length, dimensions.width ); } if (dimensions.shape === "box") { return new THREE.BoxBufferGeometry( dimensions.width, dimensions.height, dimensions.length, 2, 2, 2 ); } if (dimensions.shape === "cylinder") { return new THREE.CylinderBufferGeometry( dimensions.radius, dimensions.radius, dimensions.height, 64 ); } } }; constructor(name, parentMachine, dimensions) { this.name = name; this._dimensions = dimensions; this.geometries = []; this.meshGroup = new THREE.Group(); this.rotatedToPlane = false; this.parentMachine = parentMachine; } get position() { return this.meshGroup.position; } get quaternion() { return this.meshGroup.quaternion; } set position(xyzObj) { this.meshGroup.position.set(xyzObj.x, xyzObj.y, xyzObj.z); } set quaternion(newQuat) { this.meshGroup.quaternion.set(newQuat.x, newQuat.y, newQuat.z, newQuat.w); } get dimensions() { return this._dimensions; } set dimensions(newDims) { this._dimensions = newDims; this.renderDimensions(); } get width() { return this._dimensions.width; } get height() { return this._dimensions.height; } get length() { return this._dimensions.length; } movePosition(deltaX, deltaY, deltaZ) { let currPos = this.position; currPos.setX(currPos.x + deltaX); currPos.setY(currPos.y + deltaY); currPos.setZ(currPos.z + deltaZ); } rotateToXYPlane() { let rotateQuaternion = new THREE.Quaternion(); rotateQuaternion.setFromAxisAngle(new THREE.Vector3(1, 0, 0), -Math.PI / 2); this.meshGroup.applyQuaternion(rotateQuaternion); // FIXME: remove this variable and just read the quaternion this.rotatedToPlane = true; } rotateOnXYPlane() { let rotateQuaternion = new THREE.Quaternion(); rotateQuaternion.setFromAxisAngle(new THREE.Vector3(0, 1, 0), -Math.PI / 2); this.meshGroup.applyQuaternion(rotateQuaternion); // FIXME: remove this variable and just read the quaternion this.rotatedToPlane = true; } rotateOverXYPlane() { let rotateQuaternion = new THREE.Quaternion(); rotateQuaternion.setFromAxisAngle(new THREE.Vector3(0, 0, 1), -Math.PI / 2); this.meshGroup.applyQuaternion(rotateQuaternion); // FIXME: remove this variable and just read the quaternion this.rotatedToPlane = true; } rotateOverAxis(axis, radians) { let rotateQuaternion = new THREE.Quaternion(); rotateQuaternion.setFromAxisAngle(axis, radians); this.meshGroup.applyQuaternion(rotateQuaternion); } hide() { this.meshGroup.visible = false; } unhide() { this.meshGroup.visible = true; } addMeshGroupToScene(asPreview = false) { this.parentMachine.rootMeshGroup.add(this.meshGroup); } removeMeshGroupFromScene() { if (this.parentMachine !== undefined) { this.parentMachine.rootMeshGroup.remove(this.meshGroup); } else if (this.parentScene !== undefined) { console.warn("Hm, we probably shouldn't be here..."); this.parentScene.removeFromScene(this.meshGroup); } } computeComponentBoundingBox() { let minPoint = new THREE.Vector3(); let maxPoint = new THREE.Vector3(); let minNormSoFar = 0; let maxNormSoFar = 0; this.geometries.forEach((geom, idx) => { if (geom.boundingBox === null) { geom.computeBoundingBox(); } if (geom.boundingBox.min.length() > minNormSoFar) { minPoint = geom.boundingBox.min; minNormSoFar = geom.boundingBox.min.length(); } if (geom.boundingBox.min.length() > maxNormSoFar) { maxPoint = geom.boundingBox.max; maxNormSoFar = geom.boundingBox.max.length(); } }); let box = new THREE.Box3(minPoint, maxPoint); this.boundingBox = box; return box; } placeOnComponent(component) { let newPos = new THREE.Vector3().copy(component.position); newPos.y += component.height / 2; if (this.height !== undefined) { newPos.y += this.height / 2; } let eps = 0.1; newPos.y += eps; this.position = newPos; return newPos; } }40:T40e,class BuildEnvironment extends TaxonComponent { static color = 0xfefefe; constructor(parentMachine, dimensions) { let name = "BuildEnvironment"; super(name, parentMachine, dimensions); this.componentType = "BuildEnvironment"; parentMachine.buildEnvironment = this; this.renderDimensions(); } get height() { return 25; } renderDimensions() { this.removeMeshGroupFromScene(); let geom = BuildEnvironment.geometryFactories.buildEnvironment( this.dimensions ); let material = new THREE.MeshLambertMaterial({ color: BuildEnvironment.color, transparent: true, opacity: 0.5 }); this.mesh = new THREE.Mesh(geom, material); this.mesh.isBuildEnvironmentMesh = true; this.meshGroup = new THREE.Group(); this.meshGroup.blockName = this.name; this.meshGroup.add(this.mesh); this.geometries = [geom]; this.rotateToXYPlane(); this.addMeshGroupToScene(); const beHeight = 25; this.meshGroup.position.setY((-1 * beHeight) / 2); } }41:Tc5e,class Block extends TaxonComponent { static caseColor = 0x222222; constructor(name, parentMachine, dimensions, attributes = {}) { super(name, parentMachine, dimensions); this.componentType = "Block"; this.connections = []; this.parentMachine.addBlock(this); this.parentMachine.kinematics.addBlockAsRootNode(this); this.attributes = attributes; this.renderDimensions(); } renderDimensions() { this.removeMeshGroupFromScene(); this.caseGeom = BuildEnvironment.geometryFactories.stageCase( this.dimensions ); this.edgesGeom = new THREE.EdgesGeometry(this.caseGeom); this.caseMaterial = new THREE.MeshLambertMaterial({ color: Block.caseColor, transparent: true, opacity: 0.05 }); this.edgesMaterial = new THREE.LineBasicMaterial({ color: 0x222222 }); this.caseMesh = new THREE.Mesh(this.caseGeom, this.caseMaterial); this.wireSegments = new THREE.LineSegments( this.edgesGeom, this.edgesMaterial ); this.meshGroup = new THREE.Group(); this.meshGroup.add(this.caseMesh); this.meshGroup.add(this.wireSegments); this.meshGroup.blockName = this.name; this.geometries = [this.caseGeom, this.edgesGeom]; this.addMeshGroupToScene(); } setVoid(voidDims) { const offsetEps = 0.5; this.void = voidDims; let offsetDims = { width: voidDims.width + offsetEps, height: voidDims.height + offsetEps, length: voidDims.length + offsetEps }; let geom = TaxonComponent.geometryFactories.stageCase(offsetDims); let meshMaterial = new THREE.MeshLambertMaterial({ color: 0xffed90, transparent: true, opacity: 0.1 }); let mesh = new THREE.Mesh(geom, meshMaterial); let edgesGeom = new THREE.EdgesGeometry(geom); let edgesMaterial = new THREE.LineDashedMaterial({ color: 0xccbd73, linewidth: 1, scale: 1, dashSize: 2, gapSize: 2 }); let wireSegments = new THREE.LineSegments(edgesGeom, edgesMaterial); wireSegments.computeLineDistances(); // FIXME: non y aligned blocks have voids rotated for some // reason if (this.actuationAxes && this.actuationAxes[0] !== "y") { mesh.rotateY(Math.PI / 2); wireSegments.rotateY(Math.PI / 2); } this.meshGroup.add(mesh); this.meshGroup.add(wireSegments); } get descendents() { // Convention: we are actually getting all ancestors let dfs = (kNode, listSoFar) => { listSoFar.push(kNode.block); if (!kNode.parentNode) { return listSoFar; } return dfs(kNode.parentNode, listSoFar); }; let thisKNode = this.parentMachine.kinematics.findNodeWithBlockName( this.name ); let parentKNode = thisKNode.parentNode; if (parentKNode === undefined) { return []; } let parentAncestors = dfs(thisKNode.parentNode, []); // Assume that orphans cannot have their own descendents let orphanAncestors = []; if (thisKNode.orphanNodes.length > 0) { orphanAncestors = thisKNode.orphanNodes.map((n) => n.block); } return parentAncestors.concat(orphanAncestors); } }42:T9ec,class Stage extends Block { static arrowPosColor = 0xe44242; static arrowNegColor = 0x4478ff; static caseColor = 0x222222; static validKinematicsNames = ["directDrive", "hBot", "coreXY"]; constructor(name, parentMachine, dimensions, attributes) { super(name, parentMachine, dimensions); this.axes = []; this.drivingMotors = []; this.baseBlock = true; } loadDriveMechanismStl() { let filepath; if (this.attributes.driveType === "leadscrew") { filepath = "./block_models/leadscrew.stl"; } else if (this.attributes.driveType === "timingBelt") { filepath = "./block_models/timing_belt.stl"; } else { return; } let loadPromise = new Promise((resolve) => { let loader = new THREE.STLLoader(); let stlMesh; return loader.load( filepath, (stlGeom) => { let material = new THREE.MeshLambertMaterial({ color: BuildEnvironment.color, // Do not cull triangles with inward-pointing normals side: THREE.DoubleSide }); stlGeom.center(); stlMesh = new THREE.Mesh(stlGeom, material); stlMesh.scale.set(2, 2, 2); stlMesh.isLoadedStl = true; if (this.axes[0] === "y") { stlMesh.rotateZ(Math.PI / 2); } else if (this.axes[0] === "z") { stlMesh.rotateY(Math.PI / 2); } this.meshGroup.add(stlMesh); resolve(stlMesh); }, undefined, (errorMsg) => { console.log(errorMsg); } ); }); return loadPromise; } setActuationAxes(actuationAxes) { this.actuationAxes = actuationAxes; } setKinematics(kinematicsName) { const childValidKinematicsNames = this.constructor.validKinematicsNames; if (childValidKinematicsNames.indexOf(kinematicsName) === -1) { console.error(`Invalid kinematics ${kinematicsName} for ${this.name}`); return; } this.kinematics = kinematicsName; } setDrivingMotors(motors) { this.drivingMotors = motors; motors.forEach((motor) => { motor.addDrivenStage(this); }); } setAttributes(newAttributes) { console.warn("This function will be deprecated"); let newDriveMechanism = newAttributes.driveType || ""; let newStepDisplacementRatio = newAttributes.stepDisplacementRatio || 0; this.attributes.driveType = newDriveMechanism; this.attributes.stepDisplacementRatio = newStepDisplacementRatio; this.loadDriveMechanismStl(); } }43:Td98,class Tool extends Block { static color = 0xe44242; static inactiveColor = 0xaaaaaa; static defaultPosition = new THREE.Vector3(0, 150, 0); constructor(name, parentMachine, dimensions, attributes) { super(name, parentMachine, dimensions); this.componentType = "Tool"; // NOTE: Tool objects are not base blocks because they are assumed // to be "floating" and machine-independent for simulation purposes this.baseBlock = false; this.endBlock = true; console.assert( attributes !== undefined, "attributes needed at Tool instantation." ); this.toolType = attributes.toolType; this.attributes = attributes; this.renderDimensions(); } activate() { if (!this.attributes.active) { this.attributes.active = true; let material = new THREE.MeshLambertMaterial({ color: Tool.color, transparent: true, opacity: 0.5 }); this.meshGroup.children[0].material = material; } } __loadToolStl() { let filepath; if (this.toolType === "print3dFDM") { filepath = "./block_models/hotend.stl"; } else { return new Promise((resolve) => { let geom = BuildEnvironment.geometryFactories.tool(this.dimensions); let material = new THREE.MeshLambertMaterial({ color: this.attributes.active ? Tool.color : Tool.inactiveColor }); let placeHolderMesh = new THREE.Mesh(geom, material); resolve(placeHolderMesh); }); } let loadPromise = new Promise((resolve) => { let loader = new THREE.STLLoader(); let stlMesh; return loader.load( filepath, (stlGeom) => { let material = new THREE.MeshLambertMaterial({ color: Tool.color, // Do not cull triangles with inward-pointing normals side: THREE.DoubleSide }); stlGeom.center(); stlMesh = new THREE.Mesh(stlGeom, material); stlMesh.scale.set(2, 2, 2); stlMesh.isLoadedStl = true; resolve(stlMesh); }, undefined, (errorMsg) => { console.log(errorMsg); } ); }); return loadPromise; } renderDimensions() { this.removeMeshGroupFromScene(); let bboxGeom = BuildEnvironment.geometryFactories.stageCase({ width: this.width, height: this.height, length: this.length }); let edgesGeom = new THREE.EdgesGeometry(bboxGeom); let activeDefinedFalse = this.attributes.active !== undefined && !this.attributes.active; let material = new THREE.MeshLambertMaterial({ color: activeDefinedFalse ? Tool.inactiveColor : Tool.color, transparent: true, opacity: 0.5 }); let edgesMaterial = new THREE.LineBasicMaterial({ color: 0x222222 }); this.mesh = new THREE.Mesh(bboxGeom, material); this.wireSegments = new THREE.LineSegments(edgesGeom, edgesMaterial); this.meshGroup = new THREE.Group(); this.meshGroup.add(this.mesh); this.meshGroup.add(this.wireSegments); this.meshGroup.blockName = this.name; this.geometries = [edgesGeom]; this.setPositionToDefault(); this.addMeshGroupToScene(); // this.__loadToolStl().then((toolMesh) => { // this.meshGroup.add(toolMesh); // }); } setPositionToDefault() { this.meshGroup.position.set( Tool.defaultPosition.x, Tool.defaultPosition.y, Tool.defaultPosition.z ); } }44:T560,class ToolAssembly extends Block { static color = 0xf36f6f; static defaultPosition = new THREE.Vector3(0, 150, 0); constructor(name, parentMachine, dimensions) { super(name, parentMachine, dimensions); this.componentType = "ToolAssembly"; this.baseBlock = true; parentMachine.addBlock(this); this.renderDimensions(); } renderDimensions() { this.removeMeshGroupFromScene(); this.geom = BuildEnvironment.geometryFactories.toolAssembly( this.dimensions ); this.edgesGeom = new THREE.EdgesGeometry(this.geom); this.material = new THREE.MeshLambertMaterial({ color: Tool.color, transparent: true, opacity: 0.25 }); this.edgesMaterial = new THREE.LineBasicMaterial({ color: 0x222222 }); this.mesh = new THREE.Mesh(this.geom, this.material); this.wireSegments = new THREE.LineSegments( this.edgesGeom, this.edgesMaterial ); this.meshGroup = new THREE.Group(); this.meshGroup.add(this.mesh); this.meshGroup.add(this.wireSegments); this.meshGroup.blockName = this.name; this.geometries = [this.geom, this.edgesGeom]; this.setPositionToDefault(); this.addMeshGroupToScene(); } setPositionToDefault() { this.meshGroup.position.set( Tool.defaultPosition.x, Tool.defaultPosition.y, Tool.defaultPosition.z ); } }45:T4cf,class Platform extends Block { static caseColor = 0x222222; constructor(name, parentMachine, dimensions, attributes) { dimensions["height"] = 10; super(name, parentMachine, dimensions); this.componentType = "Platform"; this.baseBlock = true; this.endBlock = true; // parentMachine.addBlock(this); this.renderDimensions(); this.isImmobile = attributes.isImmobile; } renderDimensions() { this.removeMeshGroupFromScene(); this.geom = BuildEnvironment.geometryFactories.stageCase(this.dimensions); this.edgesGeom = new THREE.EdgesGeometry(this.geom); this.material = new THREE.MeshLambertMaterial({ color: Platform.caseColor, transparent: true, opacity: 0.25 }); this.edgesMaterial = new THREE.LineBasicMaterial({ color: 0x222222 }); this.mesh = new THREE.Mesh(this.geom, this.material); this.wireSegments = new THREE.LineSegments( this.edgesGeom, this.edgesMaterial ); this.meshGroup = new THREE.Group(); this.meshGroup.add(this.mesh); this.meshGroup.add(this.wireSegments); this.meshGroup.blockName = this.name; this.geometries = [this.geom, this.edgesGeom]; this.addMeshGroupToScene(); } }46:T4bf,class LinearStage extends Stage { static validKinematicsNames = ["directDrive"]; constructor(name, parentMachine, dimensions, attributes = {}) { super(name, parentMachine, dimensions, attributes); this.componentType = "LinearStage"; this.kinematics = "directDrive"; this.renderDimensions(); } renderArrows() { if (this.axes.length === 1) { let axis = this.axes[0]; let axisToDim = { x: "width", y: "height", z: "length" }; let dim = axisToDim[axis]; let arrowLen = this.dimensions[dim] / 4; let dir; if (axis === "x") { dir = new THREE.Vector3(1, 0, 0); } if (axis === "y") { dir = new THREE.Vector3(0, 1, 0); } if (axis === "z") { dir = new THREE.Vector3(0, 0, 1); } let negDir = dir.clone().negate(); let posArrow = new THREE.ArrowHelper( dir, this.position, arrowLen, Stage.arrowPosColor ); let negArrow = new THREE.ArrowHelper( negDir, this.position, arrowLen, Stage.arrowNegColor ); this.meshGroup.add(posArrow); this.meshGroup.add(negArrow); } } }47:T498,class DeltaBotStage extends Stage { static caseColor = 0x222222; constructor(name, parentMachine, dimensions, attributes = {}) { super(name, parentMachine, dimensions, attributes); this.componentType = "DeltaBotStage"; this.kinematics = "deltaBot"; this.renderDimensions(); } renderDimensions() { this.removeMeshGroupFromScene(); this.caseGeom = BuildEnvironment.geometryFactories.stageCase( this.dimensions ); this.edgesGeom = new THREE.EdgesGeometry(this.caseGeom); this.caseMaterial = new THREE.MeshLambertMaterial({ color: DeltaBotStage.caseColor, transparent: true, opacity: 0.05 }); this.edgesMaterial = new THREE.LineBasicMaterial({ color: 0x222222 }); this.caseMesh = new THREE.Mesh(this.caseGeom, this.caseMaterial); this.wireSegments = new THREE.LineSegments( this.edgesGeom, this.edgesMaterial ); this.meshGroup = new THREE.Group(); this.meshGroup.add(this.caseMesh); this.meshGroup.add(this.wireSegments); this.meshGroup.blockName = this.name; this.geometries = [this.caseGeom, this.edgesGeom]; this.addMeshGroupToScene(); } }48:T83c,class CrossStage extends Stage { static caseColor = 0x222222; static validKinematicsNames = ["hBot", "coreXY"]; constructor(name, parentMachine, dimensions, attributes = {}) { super(name, parentMachine, dimensions, attributes); this.componentType = "CrossStage"; this.kinematics = "hBot"; this.renderDimensions(); } renderDimensions() { this.removeMeshGroupFromScene(); this.caseGeom = BuildEnvironment.geometryFactories.stageCase( this.dimensions ); this.edgesGeom = new THREE.EdgesGeometry(this.caseGeom); this.caseMaterial = new THREE.MeshLambertMaterial({ color: CrossStage.caseColor, transparent: true, opacity: 0.05 }); this.edgesMaterial = new THREE.LineBasicMaterial({ color: 0x222222 }); this.caseMesh = new THREE.Mesh(this.caseGeom, this.caseMaterial); this.wireSegments = new THREE.LineSegments( this.edgesGeom, this.edgesMaterial ); this.meshGroup = new THREE.Group(); this.meshGroup.add(this.caseMesh); this.meshGroup.add(this.wireSegments); this.meshGroup.blockName = this.name; this.geometries = [this.caseGeom, this.edgesGeom]; this.addMeshGroupToScene(); } renderArrows() { const arrowLen = 50; this.axes.forEach((axis) => { let axisToDim = { x: "width", y: "height", z: "length" }; let dim = axisToDim[axis]; let arrowLen = this.dimensions[dim] / 4; let dir; if (axis === "x") { dir = new THREE.Vector3(1, 0, 0); } if (axis === "y") { dir = new THREE.Vector3(0, 1, 0); } if (axis === "z") { dir = new THREE.Vector3(0, 0, 1); } let negDir = dir.clone().negate(); let posArrow = new THREE.ArrowHelper( dir, this.position, arrowLen, Stage.arrowPosColor ); let negArrow = new THREE.ArrowHelper( negDir, this.position, arrowLen, Stage.arrowNegColor ); this.meshGroup.add(posArrow); this.meshGroup.add(negArrow); }); } }49:T863,class ParallelStage extends Stage { static caseColor = 0x222222; static validKinematicsNames = ["directDrive"]; constructor(name, parentMachine, dimensions, attributes = {}) { super(name, parentMachine, dimensions, attributes); this.componentType = "ParallelStage"; this.kinematics = "directDrive"; this.renderDimensions(); } renderDimensions() { this.removeMeshGroupFromScene(); this.caseGeom = BuildEnvironment.geometryFactories.stageCase( this.dimensions ); this.edgesGeom = new THREE.EdgesGeometry(this.caseGeom); this.caseMaterial = new THREE.MeshLambertMaterial({ color: CrossStage.caseColor, transparent: true, opacity: 0.05 }); this.edgesMaterial = new THREE.LineBasicMaterial({ color: 0x222222 }); this.caseMesh = new THREE.Mesh(this.caseGeom, this.caseMaterial); this.wireSegments = new THREE.LineSegments( this.edgesGeom, this.edgesMaterial ); this.meshGroup = new THREE.Group(); this.meshGroup.add(this.caseMesh); this.meshGroup.add(this.wireSegments); this.meshGroup.blockName = this.name; this.geometries = [this.caseGeom, this.edgesGeom]; this.addMeshGroupToScene(); } renderArrows() { const arrowLen = 50; if (this.axes.length === 1) { let axis = this.axes[0]; let axisToDim = { x: "width", y: "height", z: "length" }; let dim = axisToDim[axis]; let arrowLen = this.dimensions[dim] / 4; let dir; if (axis === "x") { dir = new THREE.Vector3(1, 0, 0); } if (axis === "y") { dir = new THREE.Vector3(0, 1, 0); } if (axis === "z") { dir = new THREE.Vector3(0, 0, 1); } let negDir = dir.clone().negate(); let posArrow = new THREE.ArrowHelper( dir, this.position, arrowLen, Stage.arrowPosColor ); let negArrow = new THREE.ArrowHelper( negDir, this.position, arrowLen, Stage.arrowNegColor ); this.meshGroup.add(posArrow); this.meshGroup.add(negArrow); } } }4a:T19cd,class Compiler { constructor() {} compileMachine(machine) { let progObj = {}; let progBuildEnvironment = { shape: machine.buildEnvironment.shape, width: machine.buildEnvironment.width, length: machine.buildEnvironment.length }; let progBlocks = machine.blocks.map((block) => { let progBlock = { name: block.name, componentType: block.componentType, dimensions: block.dimensions }; if (block instanceof Stage) { progBlock.axes = block.axes; progBlock.drivingMotors = block.drivingMotors.map((motor) => { return motor.name; }); progBlock.setKinematics(block.kinematics); progBlock.setAttributes(block.attributes); } if (block.baseBlock) { progBlock.position = { x: block.position.x, y: block.position.y, z: block.position.z }; } return progBlock; }); let progMotors = machine.motors.map((motor) => { let progMotor = { name: motor.name, componentType: motor.componentType, dimensions: motor.dimensions, invertSteps: motor.invertSteps }; progMotor.drivenStages = motor.drivenStages.map((stage) => { return stage.name; }); if (motor.baseBlock) { progMotor.position = { x: motor.position.x, y: motor.position.y, z: motor.position.z }; } return progMotor; }); let progTools = machine.tools.map((tool) => { let progTool = { name: tool.name, componentType: tool.componentType, dimensions: tool.dimensions, toolType: tool.toolType, attributes: tool.attributes }; return progTool; }); let progConnections = machine.connections.map((connection) => { return { baseBlockName: connection.baseBlock.name, baseBlockFace: connection.baseBlockFace, baseBlockEnd: connection.baseBlockEnd, addBlockName: connection.addBlock.name, addBlockFace: connection.addBlockFace, addBlockEnd: connection.addBlockEnd }; }); progObj["name"] = machine["name"]; progObj["machineType"] = machine["machineType"]; progObj["price"] = machine["price"]; progObj["buildEnvironment"] = progBuildEnvironment; // progObj["workEnvelope"] = progWorkEnvelope; progObj["motors"] = progMotors; progObj["blocks"] = progBlocks; progObj["tools"] = progTools; progObj["connections"] = progConnections; let indentSpaces = 2; return JSON.stringify(progObj, undefined, indentSpaces); } decompileAsPreview(taxonScene, machineProg) { if (taxonScene.previewMachine !== undefined) { taxonScene.previewMachine.clearMachineFromScene(); } let machine = new Machine("", taxonScene, true); this.decompileIntoMachineObjFromProg(machine, machineProg); machine.recolorAndMoveMachineForPreviewing("green"); return machine; } decompileIntoScene(taxonScene, machineProg) { if (taxonScene.machine !== undefined) { taxonScene.machine.clearMachineFromScene(); taxonScene.metrics.clearFromScene(); } taxonScene.lastCompiledMachineProg = machineProg; let machine = new Machine("", taxonScene, false); this.decompileIntoMachineObjFromProg(machine, machineProg); return machine; } decompileIntoMachineObjFromProg(machine, machineProg) { let progObj = JSON.parse(machineProg); if (progObj._id !== undefined) { machine.dbId = progObj._id; } machine.name = progObj.name; machine.machineType = progObj.machineType; machine.price = progObj.price; const defaultBEdimension = 500; let beWidth, beLength; if (progObj.metrics.footprint) { beWidth = progObj.metrics.footprint.width; beLength = progObj.metrics.footprint.length; } else { beWidth = defaultBEdimension; beLength = defaultBEdimension; } let be = new BuildEnvironment(machine, { width: beWidth, length: beLength }); progObj.blocks.forEach((blockData) => { let CurrentBlockConstructor; if (blockData.blockType === "nonActuating") { if (blockData.isTool) { CurrentBlockConstructor = Tool; } else if (blockData.attributes.isToolAssembly) { CurrentBlockConstructor = ToolAssembly; } else if (blockData.attributes.isPlatform) { CurrentBlockConstructor = Platform; } else { CurrentBlockConstructor = Block; } } else if (blockData.blockType === "linear") { CurrentBlockConstructor = LinearStage; } else if ( blockData.blockType === "parallel" || blockData.blockType === "redundantLinear" ) { CurrentBlockConstructor = ParallelStage; } else if (blockData.blockType === "cross") { CurrentBlockConstructor = CrossStage; } else if (blockData.blockType === "deltaBot") { CurrentBlockConstructor = DeltaBotStage; } else { CurrentBlockConstructor = Block; } let block = new CurrentBlockConstructor( blockData.name, machine, { width: blockData.dimensions.width, height: blockData.dimensions.height, length: blockData.dimensions.length }, blockData.attributes ); if (block.connections !== undefined) { block.connections = blockData.connections; } if (blockData.position !== undefined) { let position = new THREE.Vector3( blockData.position.x, blockData.position.y, blockData.position.z ); block.position = position; } if (block instanceof Stage) { block.setActuationAxes(blockData.actuationAxes); block.invertDisplacement = !!blockData.invertDisplacement; } if (blockData.void !== undefined) { block.setVoid(blockData.void); } }); // Set connections after blocks are rendered progObj.blocks.forEach((progBlock) => { if (progBlock.connections !== undefined) { progBlock.connections.forEach((connection) => { let baseBlock = machine.findBlockWithName(progBlock.name); machine.setConnection(baseBlock, connection); }); } }); let metricsProg = JSON.stringify(progObj.metrics, undefined, 2); let metricsCompiler = new MetricsCompiler(); machine.parentScene.metrics = metricsCompiler.compile( metricsProg, machine.parentScene ); return machine; } }4b:T3880,class Workflow { static EndFunctionName = "END_FUNCTION"; constructor(parentGui, taxonScene) { this.parentGui = parentGui; this.taxonScene = taxonScene; this.dom = parentGui.getElementsByClassName("workflow-container")[0]; this.stepButtonDom = parentGui.getElementsByClassName("step-button")[0]; this.resetButtonDom = parentGui.getElementsByClassName("reset-button")[0]; this.consoleDom = parentGui.getElementsByClassName("workflow-console")[0]; // this.injectTestProgTextNodes(); this.progCurrFn = undefined; this.actionRotFns = []; this.__currLineNum = 0; this.rotStore = { foo: 42 }; this.stepButtonDom.onclick = this.step.bind(this); this.resetButtonDom.onclick = this.reset.bind(this); const consoleHandler = { apply: (target, thisArg, argList) => { let msg = argList[0]; this.consoleDom.innerText = msg; if (target.name === "error") { this.parentGui.setConsoleErrorColor(); } return target(msg); } }; } get kinematics() { return this.taxonScene.machine.kinematics; } get progText() { return this.dom.innerText.trim(); } get statements() { return this.__splitProgTextIntoStatements(this.progText); } grayStepButton() { this.stepButtonDom.classList.add("grayed"); } ungrayStepButton() { this.stepButtonDom.classList.remove("grayed"); } // setActionRotCodes(rotCodes) { // // Define ROT utility functions // let $machine = this.taxonScene.machine; // let $kinematics = this.taxonScene.machine.kinematics; // let $metrics = this.taxonScene.metrics; // let getConstructor = (line) => { // let stat = esprima.parse(line).body[0]; // return stat.expression.callee.object.callee.name; // }; // let getQuery = (line) => { // let stat = esprima.parse(line).body[0]; // let argObj = expression.callee.object.arguments[0]; // return argObj.value; // }; // let getMethodName = (line) => { // let stat = esprima.parse(line).body[0]; // return stat.expression.callee.property.name; // }; // let getMethodArgs = (line) => { // let stat = esprima.parse(line).body[0]; // let argObjs = stat.expression.arguments; // let argStrs = argObjs.map((ao) => escodegen.generate(ao)); // // Ugly but the only way to handle non-JSON object literals // let args = argStrs.map((as) => eval("(" + as + ")")); // return args; // }; // // Because eval defines the RoT functions in this context, RoTs have // // access to all the above functions // this.actionRotFns = rotCodes.map((code) => eval(code)); // } addLine(lineText) { let node = document.createElement("div"); node.innerText = lineText; this.dom.appendChild(node); } step() { // TODO: block step until animations are done if (!this.taxonScene.machine) { console.error("Please pick a machine first."); return; } if (this.progCurrFn === undefined) { this.progCurrFn = this.parseStatementsIntoCurriedFn(); } if (this.progCurrFn.name === Workflow.EndFunctionName) { console.warn("End of program."); return; } if (this.__currLineNum > 0) { // this.parentGui.removeConsoleErrorColor(); this.progCurrFn = this.progCurrFn(); } this.__stepHighlightLine(); } reset() { // TODO: reset on edited text const highlightId = "workflow-highlight"; this.progCurrFn = this.parseStatementsIntoCurriedFn(); this.__currLineNum = 0; let currHighlightedNode = document.getElementById(highlightId); if (currHighlightedNode !== null) { currHighlightedNode.id = ""; } this.ungrayStepButton(); // this.consoleDom.innerText = ""; // this.parentGui.removeConsoleErrorColor(); let zg = this.kinematics.zeroGrid; if (zg) { this.taxonScene.removeFromScene(zg); } this.taxonScene.removeMaterialMarks(); this.taxonScene.removeMaterials(); this.taxonScene.removeAllToolpaths(); this.taxonScene.recompileMachine(); this.rotStore = {}; this.taxonScene.requestRenderScene(); } __splitProgTextIntoStatements(progText) { let lines = progText .split(";") .map((line) => line.replace("
", "").trim()) .filter((line) => line.length > 0); return lines; } __stepHighlightLine() { const highlightId = "workflow-highlight"; let currHighlightedNode = document.getElementById(highlightId); if (currHighlightedNode !== null) { currHighlightedNode.id = ""; } let childNodes = this.dom.childNodes; if (this.__currLineNum < childNodes.length) { childNodes[this.__currLineNum].id = highlightId; this.__currLineNum += 1; } else { this.stepButtonDom.classList.add("grayed"); } } injectTestProgTextNodes() { // let statements = [ // 'loadChosenMachine();', // 'selectMaterial(\'PLA\');', // 'uploadModel();', // 'positionModel();', // 'sliceModel();', // 'run();' // ]; // let statements = [ // '$machine().zero();', // '$machine().moveTo(0, 0, 50);', // '$machine().moveTo(50, 0, 50);', // '$machine().moveTo(50, 0, 0);', // '$machine().moveTo(0, 0, 0);', // '$machine().moveTo(0, 2, 0);', // '$machine().moveTo(0, 2, 50);', // '$machine().moveTo(50, 2, 50);', // '$machine().moveTo(50, 2, 0);', // '$machine().moveTo(0, 2, 0);', // ]; let statements = [ "$material('foam').makeBox(100, 100, 100);", "$machine().zero();", "$machine().moveTo(-300, 25, 0);" ]; statements.forEach((stat, idx) => { this.addLine(statements[idx]); }); } parseStatementsIntoCurriedFn() { const CLASS_HIDDEN = "hidden"; const mUploadDom = document.getElementById("widget-upload-model"); const mPositionDom = document.getElementById("widget-position-model"); const runDom = document.getElementById("widget-run"); let curriedWorkflow = this.__generateCurriedWorkflow(); return curriedWorkflow; } __generateCurriedWorkflow() { const endFunction = () => {}; Reflect.defineProperty(endFunction, "name", { value: Workflow.EndFunctionName, writeable: false }); // Bindings! // let $m = this.generateMSelector(); let $b = this.generateBSelector(); let $t = this.generateTSelector(); let $machine = this.generateMachineSelector(); // let $model = this.generateModelSelector(); let $material = this.generateMaterialSelector(); let $path = this.generatePathSelector(); // Curry magic const lines = [...this.statements]; const generateInnerFn = (lineIdx) => { if (lineIdx === lines.length) { return endFunction; } else { let outerFn = () => { let innerFn = generateInnerFn(lineIdx + 1); let currLine = lines[lineIdx]; let checksPass = this.checkRotsForLine(currLine); if (!checksPass) { this.stepButtonDom.classList.add("grayed"); return endFunction; } else { try { eval(currLine); } catch (e) { console.error(e); return endFunction; } return innerFn; } }; return outerFn; } }; return generateInnerFn(0); } checkRotsForLine(line) { let failedRotCheck = false; // Expose this Workflow's KV store for rots to keep state const store = this.rotStore; this.actionRotFns.forEach((rotFn) => { let success = rotFn(line, store); if (!success) { failedRotCheck = true; } }); return !failedRotCheck; } testCurry() { const consoleHandler = { apply: (target, thisArg, argList) => { let msg = argList[0]; this.consoleDom.innerText = msg; return target(msg); } }; const endFunction = () => {}; Reflect.defineProperty(endFunction, "name", { value: Workflow.EndFunctionName, writeable: false }); const CLASS_HIDDEN = "hidden"; const mUploadDom = document.getElementById("widget-upload-model"); const mPositionDom = document.getElementById("widget-position-model"); const runDom = document.getElementById("widget-run"); // FIXME: cannot unbind this uh oh console.log = new Proxy(console.log, consoleHandler); let f0 = () => { let f1 = () => { let f2 = () => { let f3 = () => { let f4 = () => { let f5 = () => { runDom.classList.remove(CLASS_HIDDEN); window.jobFile.loadAndRunExample("box"); return endFunction; }; return f5; }; mPositionDom.classList.add(CLASS_HIDDEN); console.log("Sending to Cura for slicing..."); return f4; }; mUploadDom.classList.add(CLASS_HIDDEN); mPositionDom.classList.remove(CLASS_HIDDEN); this.parentGui.renderModelPane = this.parentGui.__inflateModelContainerDom(); this.parentGui.makeLoadStlPromise("./pikachu.stl"); this.parentGui.renderModelPane(); console.log("Position model in envelope."); return f3; }; let material = { name: "PLA", diameter: 0.7 }; console.log("Selected PLA."); console.log("Showing models for 3D printing."); mUploadDom.classList.remove(CLASS_HIDDEN); return f2; }; if (window.taxonScene.machine === undefined) { console.log("Please load a machine into the scene."); return endFunction; } let machine = window.taxonScene.machine; console.log(`Captured machine: ${machine.name}`); return f1; }; return f0; } // Lanaguage constructs generateMSelector() { // FIXME: do not use until we re-implement motors at the lowest level console.assert(false, "NYI"); const kinematics = this.kinematics; return (motorName) => { return { step: (numSteps) => { kinematics.turnMotors({ [motorName]: numSteps }); } }; }; } generateBSelector() { return (blockName) => { const kinematics = this.kinematics; let block = kinematics.machine.findBlockWithName(blockName); console.assert( block !== undefined, "Could not find a block with that name" ); let selector = { wiggle: () => { const wiggleSteps = 20; const epsSec = 0.01; const delay = (kinematics.taxonAnimator.ANIM_SECONDS + epsSec) * 1000; kinematics.actuateBlock(block, wiggleSteps); kinematics.taxonAnimator.animateToBlockEndPositions(0); setTimeout(() => { kinematics.actuateBlock(block, -wiggleSteps); kinematics.taxonAnimator.animateToBlockEndPositions(0); }, delay); return selector; }, actuate: (displacement) => { kinematics.actuateBlock(block, displacement); kinematics.taxonAnimator.animateToBlockEndPositions(0); } }; return selector; }; } generateTSelector() { return (toolName) => { const kinematics = this.kinematics; let tool = kinematics.machine.getTool(toolName); let selector = { activate: () => { tool.activate(); return selector; }, fanOn: () => { tool.attributes.fanOn = true; return selector; }, fanOff: () => { tool.attributes.fanOn = false; return selector; }, park: () => { tool.attributes.equipped = false; kinematics.disconnectRootNodeForBlock(tool); return selector; }, equip: () => { tool.attributes.equipped = true; kinematics.addNewBlockAsRoot(tool); return selector; } }; return selector; }; } generateMachineSelector() { return (toolName) => { const kinematics = this.taxonScene.machine.kinematics; let tool = kinematics.machine.getTool(toolName); let selector = { zero: () => { kinematics.zeroAtCurrentPosition(); return selector; }, stepMotors: (motorStepPairs) => { kinematics.turnMotors(motorStepPairs); return selector; }, moveTo: (pt, extrudeMM) => { let toolPos = kinematics.getZeroedPosition(); const axisToCoord = { x: pt.x !== undefined ? pt.x : toolPos.x, y: pt.y !== undefined ? pt.y : toolPos.y, z: pt.z !== undefined ? pt.z : toolPos.z }; kinematics.moveTool(axisToCoord, extrudeMM); return selector; }, run: () => { console.warn("Not yet implemented."); } }; return selector; }; } generateMaterialSelector() { const attributeDict = { wood: { materialClass: "subtractive" }, foam: { materialClass: "subtractive" } }; const defaultAttributes = { materialClass: "nonManufacturing" }; return (materialName) => { let scene = this.kinematics.taxonScene; let attributes = attributeDict[materialName] || defaultAttributes; // Note: we do not create a mesh right away because the // user must call .makeBox which provides dimensions return new Material(materialName, scene, attributes); }; } generatePathSelector() { return (pathName) => { const taxonScene = this.kinematics.taxonScene; let selector; let pathObj = taxonScene.getToolpathWithName(pathName); if (pathObj !== undefined) { // CASE: path has been loaded, so just pull it up. return pathObj; } else { // CASE: path isn't defined yet and needs to be loaded. This // can only be done asynchronously, so in this action cannot // evaluate to the path object during its call to load. selector = { loadFromFile: (fileName) => { new Toolpath(fileName, taxonScene, pathName); } }; } return selector; }; } }4c:T9d8,class Material { static additiveColor = 0xe44242; static subtractiveColor = 0x2ecc71; /** * Note that the dimensions of the material depends on attribute.materialClass. * This can be "additive", where the material represents a linear extrusion * of material, so dimensions contains a start and end point. For "subtractive," * the dimensions are of the material's bounding box. */ constructor(name, parentScene, attributes) { console.assert( attributes.materialClass === "additive" || attributes.materialClass === "subtractive", "Must specify material class: additive or subtractive" ); this.parentScene = parentScene; this.meshGroup = new THREE.Group(); this.attributes = attributes; parentScene.materials.add(this.meshGroup); this.meshGroup.name = "material"; } makeBox(width, height, length) { this.dimensions = { width, height, length }; this.render(); } get width() { if (this.attributes.materialClass === "additive") { console.warn("Additive material has no width"); } return this.dimensions.width; } get height() { if (this.attributes.materialClass === "additive") { console.warn("Additive material has no height"); } return this.dimensions.height; } get length() { if (this.attributes.materialClass === "additive") { console.warn("Additive material has no length"); } return this.dimensions.length; } derender() { this.parentScene.scene.remove(this.meshGroup); this.meshGroup = new THREE.Group(); this.meshGroup.name = "material"; } render() { if (this.attributes.materialClass === "additive") { // TODO console.error("NYI"); } else { this.__renderSubtractive(); } } __renderAdditive() {} __renderSubtractive() { // this.derender(); let geom = new THREE.BoxBufferGeometry( this.width, this.height, this.length, 2, 2, 2 ); let edgesGeom = new THREE.EdgesGeometry(geom); let material = new THREE.MeshLambertMaterial({ color: Material.subtractiveColor, transparent: true, opacity: 0.5 }); let edgesMaterial = new THREE.LineBasicMaterial({ color: 0x222222 }); let mesh = new THREE.Mesh(geom, material); let wires = new THREE.LineSegments(edgesGeom, edgesMaterial); this.meshGroup.add(mesh); this.meshGroup.add(wires); this.meshGroup.position.setY(this.height / 2); } }4d:T6c9,class Toolpath { constructor(fileName, scene, pathName) { this.name = pathName; this.group = new THREE.Group(); this.group.type = "toolpath"; this.__parsePathFromSVG(fileName, scene, pathName).then((path) => { this.__renderPathInScene(path, scene); }); } placeAt(maybeXyzObj) { // maybeXyzObj is either a raw obj, or a promise to fetch one. Because // we can't tell, wrap it in a new promise in any case. Once we do // have a value xyzObj, then go ahead and execute the logic for // placeAt itself. let promiseXyzObj = Promise.resolve(maybeXyzObj); promiseXyzObj.then((xyzObj) => { let pos = new THREE.Vector3(xyzObj.x, xyzObj.y, xyzObj.z); this.group.position.copy(pos); }); } __parsePathFromSVG(fileName, scene, pathName) { let loader = new THREE.SVGLoader(); let promise = new Promise((resolve, reject) => { loader.load( fileName, (data) => { resolve(data.paths); }, undefined, (error) => { console.error(error); } ); }); return promise; } __renderPathInScene(path, scene) { let material = new THREE.LineDashedMaterial({ color: 0xe44242, linewidth: 1, scale: 1, dashSize: 3, gapSize: 3 }); path.forEach((subpath) => { let shapes = THREE.SVGLoader.createShapes(subpath); shapes.forEach((shape) => { let geom = new THREE.ShapeBufferGeometry(shape); let edgesGeom = new THREE.EdgesGeometry(geom); let segments = new THREE.LineSegments(edgesGeom, material); this.group.add(segments); }); }); this.group.rotateX(Math.PI / 2); scene.addToolpath(this); } }4e:T680,function loadTextIntoWorkflowDom(text, workflowDom) { let textDom = workflowDom.getElementsByClassName("workflow-container")[0]; textDom.innerHTML = ""; let lines = text.split("\n"); lines.forEach((lineText, lineNum) => { let node = document.createElement("div"); node.innerText = lineText; // FIXME: won't work if there is a newline after "name" // if (resourceName === 'machines' && lineText.includes('"name"')) { // let blockName = lineText.split(':')[1] // .replace('"', '') // .replace('"', '') // .replace(',', '') // .trim(); // node.addEventListener('dblclick', (event) => { // let blockMeshGroup = this.taxonScene.machine // .findBlockWithName(blockName) // .meshGroup; // blockMeshGroup.children.forEach((maybeMesh) => { // const delay = 3000; // if (maybeMesh.material === undefined) { // return; // } // let origHex = maybeMesh.material.color.getHex(); // let origOpacity = maybeMesh.material.opacity; // maybeMesh.material.color.setHex(0x2ecc71); // maybeMesh.material.opacity = 0.75; // setTimeout(() => { // maybeMesh.material.color.setHex(origHex); // maybeMesh.material.opacity = origOpacity; // }, delay); // }); // }, false); // } textDom.appendChild(node); }); }4f:T46e,class Metrics { constructor(parentScene, metricsProg) { mutable test = parentScene; this.parentScene = parentScene; this.parentScene.metrics = this; this.workEnvelope = metricsProg.workEnvelope; this.manufacturingStrategies = metricsProg.manufacturingStrategies; this.materialCompatibility = metricsProg.materialCompatibility; this.rootMeshGroup = new THREE.Group(); this.workEnvelope = new WorkEnvelope(this, this.workEnvelope); if (metricsProg.envelopeRegions) { this.envelopeRegions = Object.entries(metricsProg.envelopeRegions).map( (kvPair) => { let erName = kvPair[0]; let erProg = kvPair[1]; let er = new EnvelopeRegion(this, erProg); er.name = erName; return er; } ); } this.parentScene.scene.add(this.rootMeshGroup); } clearFromScene() { if (this.workEnvelope) { this.parentScene.removeFromScene(this.workEnvelope.meshGroup); } if (this.envelopeRegions) { this.envelopeRegions.forEach((er) => { this.parentScene.removeFromScene(er.meshGroup); }); } } }50:Teb9,class Region { //static color = 0x9d8dff; static color = 0x4e467f; static shapes = ["rectangle", "box", "cylinder"]; constructor(parentMetrics, weProg) { this.parentMetrics = parentMetrics; this.dimensions = weProg.dimensions; this.shape = weProg.shape; this.name = "Region"; this.componentType = "Region"; this.meshGroup = new THREE.Group(); this.renderDimensions(); this.parentMetrics.parentScene.scene.add(this.meshGroup); this.position = new THREE.Vector3( weProg.position.x, weProg.position.y, weProg.position.z ); if (this.shape === "rectangle") { if (!this.width) { this.flatAxis = "x"; } if (!this.height) { this.flatAxis = "y"; } if (!this.length) { this.flatAxis = "z"; } } } get position() { return this.meshGroup.position; } set position(newPos) { this.position.copy(newPos); } get width() { return this.dimensions.width; } get height() { return this.dimensions.height; } get length() { return this.dimensions.length; } get radius() { return this.dimensions.radius; } containsPoint(pt) { let largeNumber = 9000; let center = this.position; let size = new THREE.Vector3(this.width, this.height, this.length); // This region's bounding box if it's a rectangle is "infinite" on // the flat axis if (this.shape === "rectangle") { size[this.flatAxis] = largeNumber; } let thisBox = new THREE.Box3().setFromCenterAndSize(center, size); return thisBox.containsPoint(pt); } intersectsBox(box) { let largeNumber = 9000; let center = this.position; let size = new THREE.Vector3(this.width, this.height, this.length); // This region's bounding box if it's a rectangle is "infinite" on // the flat axis if (this.shape === "rectangle") { size[this.flatAxis] = largeNumber; } let thisBox = new THREE.Box3().setFromCenterAndSize(center, size); return thisBox.intersectsBox(box); } renderDimensions() { let geom = this.calcGeometry(this.dimensions); let edgesGeom = new THREE.EdgesGeometry(geom); let material = new THREE.LineDashedMaterial({ color: Region.color, linewidth: 1, scale: 1, dashSize: 3, gapSize: 2 }); this.mesh = new THREE.LineSegments(edgesGeom, material); this.mesh.computeLineDistances(); this.mesh.isWorkEnvelopeMesh = true; this.meshGroup.blockName = this.name; this.meshGroup.add(this.mesh); this.geometries = [geom]; } clearFromScene() { this.parentMetrics.parentScene.scene.remove(this.meshGroup); this.meshGroup = new THREE.Group(); } calcGeometry(dimensions) { if (this.shape === "rectangle") { let geom; if (!this.height) { geom = new THREE.PlaneBufferGeometry( dimensions.width, dimensions.length ); geom.rotateX(Math.PI / 2); return geom; } else if (!this.width) { geom = new THREE.PlaneBufferGeometry( dimensions.height, dimensions.length ); geom.rotateY(Math.PI / 2); return geom; } else { geom = new THREE.PlaneBufferGeometry( dimensions.width, dimensions.height ); return geom; } } if (this.shape === "box") { return new THREE.BoxBufferGeometry( dimensions.width, dimensions.height, dimensions.length, 2, 2, 2 ); } if (this.shape === "cylinder") { return new THREE.CylinderBufferGeometry( dimensions.radius, dimensions.radius, dimensions.height, 64 ); } } }51:T5d6,LineGeometry = (function () { class LineGeometry extends LineSegmentsGeometry { constructor() { super(); this.isLineGeometry = true; this.type = "LineGeometry"; } setPositions(array) { // converts [ x1, y1, z1, x2, y2, z2, ... ] to pairs format const length = array.length - 3; const points = new Float32Array(2 * length); for (let i = 0; i < length; i += 3) { points[2 * i] = array[i]; points[2 * i + 1] = array[i + 1]; points[2 * i + 2] = array[i + 2]; points[2 * i + 3] = array[i + 3]; points[2 * i + 4] = array[i + 4]; points[2 * i + 5] = array[i + 5]; } super.setPositions(points); return this; } setColors(array) { // converts [ r1, g1, b1, r2, g2, b2, ... ] to pairs format const length = array.length - 3; const colors = new Float32Array(2 * length); for (let i = 0; i < length; i += 3) { colors[2 * i] = array[i]; colors[2 * i + 1] = array[i + 1]; colors[2 * i + 2] = array[i + 2]; colors[2 * i + 3] = array[i + 3]; colors[2 * i + 4] = array[i + 4]; colors[2 * i + 5] = array[i + 5]; } super.setColors(colors); return this; } fromLine(line) { const geometry = line.geometry; this.setPositions(geometry.attributes.position.array); // assumes non-indexed // set colors, maybe return this; } } return LineGeometry; })()52:T1425,LineSegmentsGeometry = (function () { const _box = new THREE.Box3(); const _vector = new THREE.Vector3(); class LineSegmentsGeometry extends THREE.InstancedBufferGeometry { constructor() { super(); this.isLineSegmentsGeometry = true; this.type = "LineSegmentsGeometry"; const positions = [ -1, 2, 0, 1, 2, 0, -1, 1, 0, 1, 1, 0, -1, 0, 0, 1, 0, 0, -1, -1, 0, 1, -1, 0 ]; const uvs = [-1, 2, 1, 2, -1, 1, 1, 1, -1, -1, 1, -1, -1, -2, 1, -2]; const index = [0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5]; this.setIndex(index); this.setAttribute( "position", new THREE.Float32BufferAttribute(positions, 3) ); this.setAttribute("uv", new THREE.Float32BufferAttribute(uvs, 2)); } applyMatrix4(matrix) { const start = this.attributes.instanceStart; const end = this.attributes.instanceEnd; if (start !== undefined) { start.applyMatrix4(matrix); end.applyMatrix4(matrix); start.needsUpdate = true; } if (this.boundingBox !== null) { this.computeBoundingBox(); } if (this.boundingSphere !== null) { this.computeBoundingSphere(); } return this; } setPositions(array) { let lineSegments; if (array instanceof Float32Array) { lineSegments = array; } else if (Array.isArray(array)) { lineSegments = new Float32Array(array); } const instanceBuffer = new THREE.InstancedInterleavedBuffer( lineSegments, 6, 1 ); // xyz, xyz this.setAttribute( "instanceStart", new THREE.InterleavedBufferAttribute(instanceBuffer, 3, 0) ); // xyz this.setAttribute( "instanceEnd", new THREE.InterleavedBufferAttribute(instanceBuffer, 3, 3) ); // xyz // this.computeBoundingBox(); this.computeBoundingSphere(); return this; } setColors(array) { let colors; if (array instanceof Float32Array) { colors = array; } else if (Array.isArray(array)) { colors = new Float32Array(array); } const instanceColorBuffer = new THREE.InstancedInterleavedBuffer( colors, 6, 1 ); // rgb, rgb this.setAttribute( "instanceColorStart", new THREE.InterleavedBufferAttribute(instanceColorBuffer, 3, 0) ); // rgb this.setAttribute( "instanceColorEnd", new THREE.InterleavedBufferAttribute(instanceColorBuffer, 3, 3) ); // rgb return this; } fromWireframeGeometry(geometry) { this.setPositions(geometry.attributes.position.array); return this; } fromEdgesGeometry(geometry) { this.setPositions(geometry.attributes.position.array); return this; } fromMesh(mesh) { this.fromWireframeGeometry(new THREE.WireframeGeometry(mesh.geometry)); // set colors, maybe return this; } fromLineSegments(lineSegments) { const geometry = lineSegments.geometry; this.setPositions(geometry.attributes.position.array); // assumes non-indexed // set colors, maybe return this; } computeBoundingBox() { if (this.boundingBox === null) { this.boundingBox = new THREE.Box3(); } const start = this.attributes.instanceStart; const end = this.attributes.instanceEnd; if (start !== undefined && end !== undefined) { this.boundingBox.setFromBufferAttribute(start); _box.setFromBufferAttribute(end); this.boundingBox.union(_box); } } computeBoundingSphere() { if (this.boundingSphere === null) { this.boundingSphere = new THREE.Sphere(); } if (this.boundingBox === null) { this.computeBoundingBox(); } const start = this.attributes.instanceStart; const end = this.attributes.instanceEnd; if (start !== undefined && end !== undefined) { const center = this.boundingSphere.center; this.boundingBox.getCenter(center); let maxRadiusSq = 0; for (let i = 0, il = start.count; i < il; i++) { _vector.fromBufferAttribute(start, i); maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared(_vector) ); _vector.fromBufferAttribute(end, i); maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared(_vector) ); } this.boundingSphere.radius = Math.sqrt(maxRadiusSq); if (isNaN(this.boundingSphere.radius)) { console.error( "THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.", this ); } } } toJSON() { // todo } applyMatrix(matrix) { console.warn( "THREE.LineSegmentsGeometry: applyMatrix() has been renamed to applyMatrix4()." ); return this.applyMatrix4(matrix); } } return LineSegmentsGeometry; })()53:T7137,OrbitControls = (function () { // Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default). // // Orbit - left mouse / touch: one-finger move // Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish // Pan - right mouse, or left mouse + ctrl/meta/shiftKey, or arrow keys / touch: two-finger move const _changeEvent = { type: "change" }; const _startEvent = { type: "start" }; const _endEvent = { type: "end" }; class OrbitControls extends THREE.EventDispatcher { constructor(object, domElement) { super(); if (domElement === undefined) console.warn( 'THREE.OrbitControls: The second parameter "domElement" is now mandatory.' ); if (domElement === document) console.error( 'THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.' ); this.object = object; this.domElement = domElement; this.domElement.style.touchAction = "none"; // disable touch scroll // Set to false to disable this control this.enabled = true; // "target" sets the location of focus, where the object orbits around this.target = new THREE.Vector3(); // How far you can dolly in and out ( PerspectiveCamera only ) this.minDistance = 0; this.maxDistance = Infinity; // How far you can zoom in and out ( OrthographicCamera only ) this.minZoom = 0; this.maxZoom = Infinity; // How far you can orbit vertically, upper and lower limits. // Range is 0 to Math.PI radians. this.minPolarAngle = 0; // radians this.maxPolarAngle = Math.PI; // radians // How far you can orbit horizontally, upper and lower limits. // If set, the interval [ min, max ] must be a sub-interval of [ - 2 PI, 2 PI ], with ( max - min < 2 PI ) this.minAzimuthAngle = -Infinity; // radians this.maxAzimuthAngle = Infinity; // radians // Set to true to enable damping (inertia) // If damping is enabled, you must call controls.update() in your animation loop this.enableDamping = false; this.dampingFactor = 0.05; // This option actually enables dollying in and out; left as "zoom" for backwards compatibility. // Set to false to disable zooming this.enableZoom = true; this.zoomSpeed = 1.0; // Set to false to disable rotating this.enableRotate = true; this.rotateSpeed = 1.0; // Set to false to disable panning this.enablePan = true; this.panSpeed = 1.0; this.screenSpacePanning = true; // if false, pan orthogonal to world-space direction camera.up this.keyPanSpeed = 7.0; // pixels moved per arrow key push // Set to true to automatically rotate around the target // If auto-rotate is enabled, you must call controls.update() in your animation loop this.autoRotate = false; this.autoRotateSpeed = 2.0; // 30 seconds per orbit when fps is 60 // The four arrow keys this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" }; // Mouse buttons this.mouseButtons = { LEFT: THREE.MOUSE.ROTATE, MIDDLE: THREE.MOUSE.DOLLY, RIGHT: THREE.MOUSE.PAN }; // Touch fingers this.touches = { ONE: THREE.TOUCH.ROTATE, TWO: THREE.TOUCH.DOLLY_PAN }; // for reset this.target0 = this.target.clone(); this.position0 = this.object.position.clone(); this.zoom0 = this.object.zoom; // the target DOM element for key events this._domElementKeyEvents = null; // // public methods // this.getPolarAngle = function () { return spherical.phi; }; this.getAzimuthalAngle = function () { return spherical.theta; }; this.getDistance = function () { return this.object.position.distanceTo(this.target); }; this.listenToKeyEvents = function (domElement) { domElement.addEventListener("keydown", onKeyDown); this._domElementKeyEvents = domElement; }; this.saveState = function () { scope.target0.copy(scope.target); scope.position0.copy(scope.object.position); scope.zoom0 = scope.object.zoom; }; this.reset = function () { scope.target.copy(scope.target0); scope.object.position.copy(scope.position0); scope.object.zoom = scope.zoom0; scope.object.updateProjectionMatrix(); scope.dispatchEvent(_changeEvent); scope.update(); state = STATE.NONE; }; // this method is exposed, but perhaps it would be better if we can make it private... this.update = (function () { const offset = new THREE.Vector3(); // so camera.up is the orbit axis const quat = new THREE.Quaternion().setFromUnitVectors( object.up, new THREE.Vector3(0, 1, 0) ); const quatInverse = quat.clone().invert(); const lastPosition = new THREE.Vector3(); const lastQuaternion = new THREE.Quaternion(); const twoPI = 2 * Math.PI; return function update() { const position = scope.object.position; offset.copy(position).sub(scope.target); // rotate offset to "y-axis-is-up" space offset.applyQuaternion(quat); // angle from z-axis around y-axis spherical.setFromVector3(offset); if (scope.autoRotate && state === STATE.NONE) { rotateLeft(getAutoRotationAngle()); } if (scope.enableDamping) { spherical.theta += sphericalDelta.theta * scope.dampingFactor; spherical.phi += sphericalDelta.phi * scope.dampingFactor; } else { spherical.theta += sphericalDelta.theta; spherical.phi += sphericalDelta.phi; } // restrict theta to be between desired limits let min = scope.minAzimuthAngle; let max = scope.maxAzimuthAngle; if (isFinite(min) && isFinite(max)) { if (min < -Math.PI) min += twoPI; else if (min > Math.PI) min -= twoPI; if (max < -Math.PI) max += twoPI; else if (max > Math.PI) max -= twoPI; if (min <= max) { spherical.theta = Math.max(min, Math.min(max, spherical.theta)); } else { spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta); } } // restrict phi to be between desired limits spherical.phi = Math.max( scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi) ); spherical.makeSafe(); spherical.radius *= scale; // restrict radius to be between desired limits spherical.radius = Math.max( scope.minDistance, Math.min(scope.maxDistance, spherical.radius) ); // move target to panned location if (scope.enableDamping === true) { scope.target.addScaledVector(panOffset, scope.dampingFactor); } else { scope.target.add(panOffset); } offset.setFromSpherical(spherical); // rotate offset back to "camera-up-vector-is-up" space offset.applyQuaternion(quatInverse); position.copy(scope.target).add(offset); scope.object.lookAt(scope.target); if (scope.enableDamping === true) { sphericalDelta.theta *= 1 - scope.dampingFactor; sphericalDelta.phi *= 1 - scope.dampingFactor; panOffset.multiplyScalar(1 - scope.dampingFactor); } else { sphericalDelta.set(0, 0, 0); panOffset.set(0, 0, 0); } scale = 1; // update condition is: // min(camera displacement, camera rotation in radians)^2 > EPS // using small-angle approximation cos(x/2) = 1 - x^2 / 8 if ( zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS ) { scope.dispatchEvent(_changeEvent); lastPosition.copy(scope.object.position); lastQuaternion.copy(scope.object.quaternion); zoomChanged = false; return true; } return false; }; })(); this.dispose = function () { scope.domElement.removeEventListener("contextmenu", onContextMenu); scope.domElement.removeEventListener("pointerdown", onPointerDown); scope.domElement.removeEventListener("pointercancel", onPointerCancel); scope.domElement.removeEventListener("wheel", onMouseWheel); scope.domElement.removeEventListener("pointermove", onPointerMove); scope.domElement.removeEventListener("pointerup", onPointerUp); if (scope._domElementKeyEvents !== null) { scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown); } //scope.dispatchEvent( { type: 'dispose' } ); // should this be added here? }; // // internals // const scope = this; const STATE = { NONE: -1, ROTATE: 0, DOLLY: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_PAN: 4, TOUCH_DOLLY_PAN: 5, TOUCH_DOLLY_ROTATE: 6 }; let state = STATE.NONE; const EPS = 0.000001; // current position in spherical coordinates const spherical = new THREE.Spherical(); const sphericalDelta = new THREE.Spherical(); let scale = 1; const panOffset = new THREE.Vector3(); let zoomChanged = false; const rotateStart = new THREE.Vector2(); const rotateEnd = new THREE.Vector2(); const rotateDelta = new THREE.Vector2(); const panStart = new THREE.Vector2(); const panEnd = new THREE.Vector2(); const panDelta = new THREE.Vector2(); const dollyStart = new THREE.Vector2(); const dollyEnd = new THREE.Vector2(); const dollyDelta = new THREE.Vector2(); const pointers = []; const pointerPositions = {}; function getAutoRotationAngle() { return ((2 * Math.PI) / 60 / 60) * scope.autoRotateSpeed; } function getZoomScale() { return Math.pow(0.95, scope.zoomSpeed); } function rotateLeft(angle) { sphericalDelta.theta -= angle; } function rotateUp(angle) { sphericalDelta.phi -= angle; } const panLeft = (function () { const v = new THREE.Vector3(); return function panLeft(distance, objectMatrix) { v.setFromMatrixColumn(objectMatrix, 0); // get X column of objectMatrix v.multiplyScalar(-distance); panOffset.add(v); }; })(); const panUp = (function () { const v = new THREE.Vector3(); return function panUp(distance, objectMatrix) { if (scope.screenSpacePanning === true) { v.setFromMatrixColumn(objectMatrix, 1); } else { v.setFromMatrixColumn(objectMatrix, 0); v.crossVectors(scope.object.up, v); } v.multiplyScalar(distance); panOffset.add(v); }; })(); // deltaX and deltaY are in pixels; right and down are positive const pan = (function () { const offset = new THREE.Vector3(); return function pan(deltaX, deltaY) { const element = scope.domElement; if (scope.object.isPerspectiveCamera) { // perspective const position = scope.object.position; offset.copy(position).sub(scope.target); let targetDistance = offset.length(); // half of the fov is center to top of screen targetDistance *= Math.tan( ((scope.object.fov / 2) * Math.PI) / 180.0 ); // we use only clientHeight here so aspect ratio does not distort speed panLeft( (2 * deltaX * targetDistance) / element.clientHeight, scope.object.matrix ); panUp( (2 * deltaY * targetDistance) / element.clientHeight, scope.object.matrix ); } else if (scope.object.isOrthographicCamera) { // orthographic panLeft( (deltaX * (scope.object.right - scope.object.left)) / scope.object.zoom / element.clientWidth, scope.object.matrix ); panUp( (deltaY * (scope.object.top - scope.object.bottom)) / scope.object.zoom / element.clientHeight, scope.object.matrix ); } else { // camera neither orthographic nor perspective console.warn( "WARNING: OrbitControls.js encountered an unknown camera type - pan disabled." ); scope.enablePan = false; } }; })(); function dollyOut(dollyScale) { if (scope.object.isPerspectiveCamera) { scale /= dollyScale; } else if (scope.object.isOrthographicCamera) { scope.object.zoom = Math.max( scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale) ); scope.object.updateProjectionMatrix(); zoomChanged = true; } else { console.warn( "WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled." ); scope.enableZoom = false; } } function dollyIn(dollyScale) { if (scope.object.isPerspectiveCamera) { scale *= dollyScale; } else if (scope.object.isOrthographicCamera) { scope.object.zoom = Math.max( scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale) ); scope.object.updateProjectionMatrix(); zoomChanged = true; } else { console.warn( "WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled." ); scope.enableZoom = false; } } // // event callbacks - update the object state // function handleMouseDownRotate(event) { rotateStart.set(event.clientX, event.clientY); } function handleMouseDownDolly(event) { dollyStart.set(event.clientX, event.clientY); } function handleMouseDownPan(event) { panStart.set(event.clientX, event.clientY); } function handleMouseMoveRotate(event) { rotateEnd.set(event.clientX, event.clientY); rotateDelta .subVectors(rotateEnd, rotateStart) .multiplyScalar(scope.rotateSpeed); const element = scope.domElement; rotateLeft((2 * Math.PI * rotateDelta.x) / element.clientHeight); // yes, height rotateUp((2 * Math.PI * rotateDelta.y) / element.clientHeight); rotateStart.copy(rotateEnd); scope.update(); } function handleMouseMoveDolly(event) { dollyEnd.set(event.clientX, event.clientY); dollyDelta.subVectors(dollyEnd, dollyStart); if (dollyDelta.y > 0) { dollyOut(getZoomScale()); } else if (dollyDelta.y < 0) { dollyIn(getZoomScale()); } dollyStart.copy(dollyEnd); scope.update(); } function handleMouseMovePan(event) { panEnd.set(event.clientX, event.clientY); panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed); pan(panDelta.x, panDelta.y); panStart.copy(panEnd); scope.update(); } function handleMouseWheel(event) { if (event.deltaY < 0) { dollyIn(getZoomScale()); } else if (event.deltaY > 0) { dollyOut(getZoomScale()); } scope.update(); } function handleKeyDown(event) { let needsUpdate = false; switch (event.code) { case scope.keys.UP: pan(0, scope.keyPanSpeed); needsUpdate = true; break; case scope.keys.BOTTOM: pan(0, -scope.keyPanSpeed); needsUpdate = true; break; case scope.keys.LEFT: pan(scope.keyPanSpeed, 0); needsUpdate = true; break; case scope.keys.RIGHT: pan(-scope.keyPanSpeed, 0); needsUpdate = true; break; } if (needsUpdate) { // prevent the browser from scrolling on cursor keys event.preventDefault(); scope.update(); } } function handleTouchStartRotate() { if (pointers.length === 1) { rotateStart.set(pointers[0].pageX, pointers[0].pageY); } else { const x = 0.5 * (pointers[0].pageX + pointers[1].pageX); const y = 0.5 * (pointers[0].pageY + pointers[1].pageY); rotateStart.set(x, y); } } function handleTouchStartPan() { if (pointers.length === 1) { panStart.set(pointers[0].pageX, pointers[0].pageY); } else { const x = 0.5 * (pointers[0].pageX + pointers[1].pageX); const y = 0.5 * (pointers[0].pageY + pointers[1].pageY); panStart.set(x, y); } } function handleTouchStartDolly() { const dx = pointers[0].pageX - pointers[1].pageX; const dy = pointers[0].pageY - pointers[1].pageY; const distance = Math.sqrt(dx * dx + dy * dy); dollyStart.set(0, distance); } function handleTouchStartDollyPan() { if (scope.enableZoom) handleTouchStartDolly(); if (scope.enablePan) handleTouchStartPan(); } function handleTouchStartDollyRotate() { if (scope.enableZoom) handleTouchStartDolly(); if (scope.enableRotate) handleTouchStartRotate(); } function handleTouchMoveRotate(event) { if (pointers.length == 1) { rotateEnd.set(event.pageX, event.pageY); } else { const position = getSecondPointerPosition(event); const x = 0.5 * (event.pageX + position.x); const y = 0.5 * (event.pageY + position.y); rotateEnd.set(x, y); } rotateDelta .subVectors(rotateEnd, rotateStart) .multiplyScalar(scope.rotateSpeed); const element = scope.domElement; rotateLeft((2 * Math.PI * rotateDelta.x) / element.clientHeight); // yes, height rotateUp((2 * Math.PI * rotateDelta.y) / element.clientHeight); rotateStart.copy(rotateEnd); } function handleTouchMovePan(event) { if (pointers.length === 1) { panEnd.set(event.pageX, event.pageY); } else { const position = getSecondPointerPosition(event); const x = 0.5 * (event.pageX + position.x); const y = 0.5 * (event.pageY + position.y); panEnd.set(x, y); } panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed); pan(panDelta.x, panDelta.y); panStart.copy(panEnd); } function handleTouchMoveDolly(event) { const position = getSecondPointerPosition(event); const dx = event.pageX - position.x; const dy = event.pageY - position.y; const distance = Math.sqrt(dx * dx + dy * dy); dollyEnd.set(0, distance); dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed)); dollyOut(dollyDelta.y); dollyStart.copy(dollyEnd); } function handleTouchMoveDollyPan(event) { if (scope.enableZoom) handleTouchMoveDolly(event); if (scope.enablePan) handleTouchMovePan(event); } function handleTouchMoveDollyRotate(event) { if (scope.enableZoom) handleTouchMoveDolly(event); if (scope.enableRotate) handleTouchMoveRotate(event); } // // event handlers - FSM: listen for events and reset state // function onPointerDown(event) { if (scope.enabled === false) return; if (pointers.length === 0) { scope.domElement.setPointerCapture(event.pointerId); scope.domElement.addEventListener("pointermove", onPointerMove); scope.domElement.addEventListener("pointerup", onPointerUp); } // addPointer(event); if (event.pointerType === "touch") { onTouchStart(event); } else { onMouseDown(event); } } function onPointerMove(event) { if (scope.enabled === false) return; if (event.pointerType === "touch") { onTouchMove(event); } else { onMouseMove(event); } } function onPointerUp(event) { removePointer(event); if (pointers.length === 0) { scope.domElement.releasePointerCapture(event.pointerId); scope.domElement.removeEventListener("pointermove", onPointerMove); scope.domElement.removeEventListener("pointerup", onPointerUp); } scope.dispatchEvent(_endEvent); state = STATE.NONE; } function onPointerCancel(event) { removePointer(event); } function onMouseDown(event) { let mouseAction; switch (event.button) { case 0: mouseAction = scope.mouseButtons.LEFT; break; case 1: mouseAction = scope.mouseButtons.MIDDLE; break; case 2: mouseAction = scope.mouseButtons.RIGHT; break; default: mouseAction = -1; } switch (mouseAction) { case THREE.MOUSE.DOLLY: if (scope.enableZoom === false) return; handleMouseDownDolly(event); state = STATE.DOLLY; break; case THREE.MOUSE.ROTATE: if (event.ctrlKey || event.metaKey || event.shiftKey) { if (scope.enablePan === false) return; handleMouseDownPan(event); state = STATE.PAN; } else { if (scope.enableRotate === false) return; handleMouseDownRotate(event); state = STATE.ROTATE; } break; case THREE.MOUSE.PAN: if (event.ctrlKey || event.metaKey || event.shiftKey) { if (scope.enableRotate === false) return; handleMouseDownRotate(event); state = STATE.ROTATE; } else { if (scope.enablePan === false) return; handleMouseDownPan(event); state = STATE.PAN; } break; default: state = STATE.NONE; } if (state !== STATE.NONE) { scope.dispatchEvent(_startEvent); } } function onMouseMove(event) { if (scope.enabled === false) return; switch (state) { case STATE.ROTATE: if (scope.enableRotate === false) return; handleMouseMoveRotate(event); break; case STATE.DOLLY: if (scope.enableZoom === false) return; handleMouseMoveDolly(event); break; case STATE.PAN: if (scope.enablePan === false) return; handleMouseMovePan(event); break; } } function onMouseWheel(event) { if ( scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE ) return; event.preventDefault(); scope.dispatchEvent(_startEvent); handleMouseWheel(event); scope.dispatchEvent(_endEvent); } function onKeyDown(event) { if (scope.enabled === false || scope.enablePan === false) return; handleKeyDown(event); } function onTouchStart(event) { trackPointer(event); switch (pointers.length) { case 1: switch (scope.touches.ONE) { case THREE.TOUCH.ROTATE: if (scope.enableRotate === false) return; handleTouchStartRotate(); state = STATE.TOUCH_ROTATE; break; case THREE.TOUCH.PAN: if (scope.enablePan === false) return; handleTouchStartPan(); state = STATE.TOUCH_PAN; break; default: state = STATE.NONE; } break; case 2: switch (scope.touches.TWO) { case THREE.TOUCH.DOLLY_PAN: if (scope.enableZoom === false && scope.enablePan === false) return; handleTouchStartDollyPan(); state = STATE.TOUCH_DOLLY_PAN; break; case THREE.TOUCH.DOLLY_ROTATE: if (scope.enableZoom === false && scope.enableRotate === false) return; handleTouchStartDollyRotate(); state = STATE.TOUCH_DOLLY_ROTATE; break; default: state = STATE.NONE; } break; default: state = STATE.NONE; } if (state !== STATE.NONE) { scope.dispatchEvent(_startEvent); } } function onTouchMove(event) { trackPointer(event); switch (state) { case STATE.TOUCH_ROTATE: if (scope.enableRotate === false) return; handleTouchMoveRotate(event); scope.update(); break; case STATE.TOUCH_PAN: if (scope.enablePan === false) return; handleTouchMovePan(event); scope.update(); break; case STATE.TOUCH_DOLLY_PAN: if (scope.enableZoom === false && scope.enablePan === false) return; handleTouchMoveDollyPan(event); scope.update(); break; case STATE.TOUCH_DOLLY_ROTATE: if (scope.enableZoom === false && scope.enableRotate === false) return; handleTouchMoveDollyRotate(event); scope.update(); break; default: state = STATE.NONE; } } function onContextMenu(event) { if (scope.enabled === false) return; event.preventDefault(); } function addPointer(event) { pointers.push(event); } function removePointer(event) { delete pointerPositions[event.pointerId]; for (let i = 0; i < pointers.length; i++) { if (pointers[i].pointerId == event.pointerId) { pointers.splice(i, 1); return; } } } function trackPointer(event) { let position = pointerPositions[event.pointerId]; if (position === undefined) { position = new THREE.Vector2(); pointerPositions[event.pointerId] = position; } position.set(event.pageX, event.pageY); } function getSecondPointerPosition(event) { const pointer = event.pointerId === pointers[0].pointerId ? pointers[1] : pointers[0]; return pointerPositions[pointer.pointerId]; } // scope.domElement.addEventListener("contextmenu", onContextMenu); scope.domElement.addEventListener("pointerdown", onPointerDown); scope.domElement.addEventListener("pointercancel", onPointerCancel); scope.domElement.addEventListener("wheel", onMouseWheel, { passive: false }); // force an update at start this.update(); } } // This set of controls performs orbiting, dollying (zooming), and panning. // Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default). // This is very similar to OrbitControls, another set of touch behavior // // Orbit - right mouse, or left mouse + ctrl/meta/shiftKey / touch: two-finger rotate // Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish // Pan - left mouse, or arrow keys / touch: one-finger move class MapControls extends OrbitControls { constructor(object, domElement) { super(object, domElement); this.screenSpacePanning = false; // pan orthogonal to world-space direction camera.up this.mouseButtons.LEFT = THREE.MOUSE.PAN; this.mouseButtons.RIGHT = THREE.MOUSE.ROTATE; this.touches.ONE = THREE.TOUCH.PAN; this.touches.TWO = THREE.TOUCH.DOLLY_ROTATE; } } return OrbitControls; })()54:Ta80,ParametricGeometry = (function () { /** * Parametric Surfaces Geometry * based on the brilliant article by @prideout https://prideout.net/blog/old/blog/index.html@p=44.html */ class ParametricGeometry extends THREE.BufferGeometry { constructor( func = (u, v, target) => target.set(u, v, Math.cos(u) * Math.sin(v)), slices = 8, stacks = 8 ) { super(); this.type = "ParametricGeometry"; this.parameters = { func: func, slices: slices, stacks: stacks }; // buffers const indices = []; const vertices = []; const normals = []; const uvs = []; const EPS = 0.00001; const normal = new THREE.Vector3(); const p0 = new THREE.Vector3(), p1 = new THREE.Vector3(); const pu = new THREE.Vector3(), pv = new THREE.Vector3(); // generate vertices, normals and uvs const sliceCount = slices + 1; for (let i = 0; i <= stacks; i++) { const v = i / stacks; for (let j = 0; j <= slices; j++) { const u = j / slices; // vertex func(u, v, p0); vertices.push(p0.x, p0.y, p0.z); // normal // approximate tangent vectors via finite differences if (u - EPS >= 0) { func(u - EPS, v, p1); pu.subVectors(p0, p1); } else { func(u + EPS, v, p1); pu.subVectors(p1, p0); } if (v - EPS >= 0) { func(u, v - EPS, p1); pv.subVectors(p0, p1); } else { func(u, v + EPS, p1); pv.subVectors(p1, p0); } // cross product of tangent vectors returns surface normal normal.crossVectors(pu, pv).normalize(); normals.push(normal.x, normal.y, normal.z); // uv uvs.push(u, v); } } // generate indices for (let i = 0; i < stacks; i++) { for (let j = 0; j < slices; j++) { const a = i * sliceCount + j; const b = i * sliceCount + j + 1; const c = (i + 1) * sliceCount + j + 1; const d = (i + 1) * sliceCount + j; // faces one and two indices.push(a, b, d); indices.push(b, c, d); } } // build geometry this.setIndex(indices); this.setAttribute( "position", new THREE.Float32BufferAttribute(vertices, 3) ); this.setAttribute("normal", new THREE.Float32BufferAttribute(normals, 3)); this.setAttribute("uv", new THREE.Float32BufferAttribute(uvs, 2)); } } return ParametricGeometry; })()55:T33a5,LineMaterial = (function () { /** * parameters = { * color: , * linewidth: , * dashed: , * dashScale: , * dashSize: , * dashOffset: , * gapSize: , * resolution: , // to be set by renderer * } */ THREE.UniformsLib.line = { worldUnits: { value: 1 }, linewidth: { value: 1 }, resolution: { value: new THREE.Vector2(1, 1) }, dashOffset: { value: 0 }, dashScale: { value: 1 }, dashSize: { value: 1 }, gapSize: { value: 1 } // todo FIX - maybe change to totalSize }; THREE.ShaderLib["line"] = { uniforms: THREE.UniformsUtils.merge([ THREE.UniformsLib.common, THREE.UniformsLib.fog, THREE.UniformsLib.line ]), vertexShader: /* glsl */ ` #include #include #include #include #include uniform float linewidth; uniform vec2 resolution; attribute vec3 instanceStart; attribute vec3 instanceEnd; attribute vec3 instanceColorStart; attribute vec3 instanceColorEnd; #ifdef WORLD_UNITS varying vec4 worldPos; varying vec3 worldStart; varying vec3 worldEnd; #ifdef USE_DASH varying vec2 vUv; #endif #else varying vec2 vUv; #endif #ifdef USE_DASH uniform float dashScale; attribute float instanceDistanceStart; attribute float instanceDistanceEnd; varying float vLineDistance; #endif void trimSegment( const in vec4 start, inout vec4 end ) { // trim end segment so it terminates between the camera plane and the near plane // conservative estimate of the near plane float a = projectionMatrix[ 2 ][ 2 ]; // 3nd entry in 3th column float b = projectionMatrix[ 3 ][ 2 ]; // 3nd entry in 4th column float nearEstimate = - 0.5 * b / a; float alpha = ( nearEstimate - start.z ) / ( end.z - start.z ); end.xyz = mix( start.xyz, end.xyz, alpha ); } void main() { #ifdef USE_COLOR vColor.xyz = ( position.y < 0.5 ) ? instanceColorStart : instanceColorEnd; #endif #ifdef USE_DASH vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd; vUv = uv; #endif float aspect = resolution.x / resolution.y; // camera space vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 ); vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 ); #ifdef WORLD_UNITS worldStart = start.xyz; worldEnd = end.xyz; #else vUv = uv; #endif // special case for perspective projection, and segments that terminate either in, or behind, the camera plane // clearly the gpu firmware has a way of addressing this issue when projecting into ndc space // but we need to perform ndc-space calculations in the shader, so we must address this issue directly // perhaps there is a more elegant solution -- WestLangley bool perspective = ( projectionMatrix[ 2 ][ 3 ] == - 1.0 ); // 4th entry in the 3rd column if ( perspective ) { if ( start.z < 0.0 && end.z >= 0.0 ) { trimSegment( start, end ); } else if ( end.z < 0.0 && start.z >= 0.0 ) { trimSegment( end, start ); } } // clip space vec4 clipStart = projectionMatrix * start; vec4 clipEnd = projectionMatrix * end; // ndc space vec3 ndcStart = clipStart.xyz / clipStart.w; vec3 ndcEnd = clipEnd.xyz / clipEnd.w; // direction vec2 dir = ndcEnd.xy - ndcStart.xy; // account for clip-space aspect ratio dir.x *= aspect; dir = normalize( dir ); #ifdef WORLD_UNITS // get the offset direction as perpendicular to the view vector vec3 worldDir = normalize( end.xyz - start.xyz ); vec3 offset; if ( position.y < 0.5 ) { offset = normalize( cross( start.xyz, worldDir ) ); } else { offset = normalize( cross( end.xyz, worldDir ) ); } // sign flip if ( position.x < 0.0 ) offset *= - 1.0; float forwardOffset = dot( worldDir, vec3( 0.0, 0.0, 1.0 ) ); // don't extend the line if we're rendering dashes because we // won't be rendering the endcaps #ifndef USE_DASH // extend the line bounds to encompass endcaps start.xyz += - worldDir * linewidth * 0.5; end.xyz += worldDir * linewidth * 0.5; // shift the position of the quad so it hugs the forward edge of the line offset.xy -= dir * forwardOffset; offset.z += 0.5; #endif // endcaps if ( position.y > 1.0 || position.y < 0.0 ) { offset.xy += dir * 2.0 * forwardOffset; } // adjust for linewidth offset *= linewidth * 0.5; // set the world position worldPos = ( position.y < 0.5 ) ? start : end; worldPos.xyz += offset; // project the worldpos vec4 clip = projectionMatrix * worldPos; // shift the depth of the projected points so the line // segments overlap neatly vec3 clipPose = ( position.y < 0.5 ) ? ndcStart : ndcEnd; clip.z = clipPose.z * clip.w; #else vec2 offset = vec2( dir.y, - dir.x ); // undo aspect ratio adjustment dir.x /= aspect; offset.x /= aspect; // sign flip if ( position.x < 0.0 ) offset *= - 1.0; // endcaps if ( position.y < 0.0 ) { offset += - dir; } else if ( position.y > 1.0 ) { offset += dir; } // adjust for linewidth offset *= linewidth; // adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ... offset /= resolution.y; // select end vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd; // back to clip space offset *= clip.w; clip.xy += offset; #endif gl_Position = clip; vec4 mvPosition = ( position.y < 0.5 ) ? start : end; // this is an approximation #include #include #include } `, fragmentShader: /* glsl */ ` uniform vec3 diffuse; uniform float opacity; uniform float linewidth; #ifdef USE_DASH uniform float dashOffset; uniform float dashSize; uniform float gapSize; #endif varying float vLineDistance; #ifdef WORLD_UNITS varying vec4 worldPos; varying vec3 worldStart; varying vec3 worldEnd; #ifdef USE_DASH varying vec2 vUv; #endif #else varying vec2 vUv; #endif #include #include #include #include #include vec2 closestLineToLine(vec3 p1, vec3 p2, vec3 p3, vec3 p4) { float mua; float mub; vec3 p13 = p1 - p3; vec3 p43 = p4 - p3; vec3 p21 = p2 - p1; float d1343 = dot( p13, p43 ); float d4321 = dot( p43, p21 ); float d1321 = dot( p13, p21 ); float d4343 = dot( p43, p43 ); float d2121 = dot( p21, p21 ); float denom = d2121 * d4343 - d4321 * d4321; float numer = d1343 * d4321 - d1321 * d4343; mua = numer / denom; mua = clamp( mua, 0.0, 1.0 ); mub = ( d1343 + d4321 * ( mua ) ) / d4343; mub = clamp( mub, 0.0, 1.0 ); return vec2( mua, mub ); } void main() { #include #ifdef USE_DASH if ( vUv.y < - 1.0 || vUv.y > 1.0 ) discard; // discard endcaps if ( mod( vLineDistance + dashOffset, dashSize + gapSize ) > dashSize ) discard; // todo - FIX #endif float alpha = opacity; #ifdef WORLD_UNITS // Find the closest points on the view ray and the line segment vec3 rayEnd = normalize( worldPos.xyz ) * 1e5; vec3 lineDir = worldEnd - worldStart; vec2 params = closestLineToLine( worldStart, worldEnd, vec3( 0.0, 0.0, 0.0 ), rayEnd ); vec3 p1 = worldStart + lineDir * params.x; vec3 p2 = rayEnd * params.y; vec3 delta = p1 - p2; float len = length( delta ); float norm = len / linewidth; #ifndef USE_DASH #ifdef USE_ALPHA_TO_COVERAGE float dnorm = fwidth( norm ); alpha = 1.0 - smoothstep( 0.5 - dnorm, 0.5 + dnorm, norm ); #else if ( norm > 0.5 ) { discard; } #endif #endif #else #ifdef USE_ALPHA_TO_COVERAGE // artifacts appear on some hardware if a derivative is taken within a conditional float a = vUv.x; float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0; float len2 = a * a + b * b; float dlen = fwidth( len2 ); if ( abs( vUv.y ) > 1.0 ) { alpha = 1.0 - smoothstep( 1.0 - dlen, 1.0 + dlen, len2 ); } #else if ( abs( vUv.y ) > 1.0 ) { float a = vUv.x; float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0; float len2 = a * a + b * b; if ( len2 > 1.0 ) discard; } #endif #endif vec4 diffuseColor = vec4( diffuse, alpha ); #include #include gl_FragColor = vec4( diffuseColor.rgb, alpha ); #include #include #include #include } ` }; class LineMaterial extends THREE.ShaderMaterial { constructor(parameters) { super({ type: "LineMaterial", uniforms: THREE.UniformsUtils.clone(THREE.ShaderLib["line"].uniforms), vertexShader: THREE.ShaderLib["line"].vertexShader, fragmentShader: THREE.ShaderLib["line"].fragmentShader, clipping: true // required for clipping support }); this.isLineMaterial = true; Object.defineProperties(this, { color: { enumerable: true, get: function () { return this.uniforms.diffuse.value; }, set: function (value) { this.uniforms.diffuse.value = value; } }, worldUnits: { enumerable: true, get: function () { return "WORLD_UNITS" in this.defines; }, set: function (value) { if (value === true) { this.defines.WORLD_UNITS = ""; } else { delete this.defines.WORLD_UNITS; } } }, linewidth: { enumerable: true, get: function () { return this.uniforms.linewidth.value; }, set: function (value) { this.uniforms.linewidth.value = value; } }, dashed: { enumerable: true, get: function () { return Boolean("USE_DASH" in this.defines); }, set(value) { if (Boolean(value) !== Boolean("USE_DASH" in this.defines)) { this.needsUpdate = true; } if (value === true) { this.defines.USE_DASH = ""; } else { delete this.defines.USE_DASH; } } }, dashScale: { enumerable: true, get: function () { return this.uniforms.dashScale.value; }, set: function (value) { this.uniforms.dashScale.value = value; } }, dashSize: { enumerable: true, get: function () { return this.uniforms.dashSize.value; }, set: function (value) { this.uniforms.dashSize.value = value; } }, dashOffset: { enumerable: true, get: function () { return this.uniforms.dashOffset.value; }, set: function (value) { this.uniforms.dashOffset.value = value; } }, gapSize: { enumerable: true, get: function () { return this.uniforms.gapSize.value; }, set: function (value) { this.uniforms.gapSize.value = value; } }, opacity: { enumerable: true, get: function () { return this.uniforms.opacity.value; }, set: function (value) { this.uniforms.opacity.value = value; } }, resolution: { enumerable: true, get: function () { return this.uniforms.resolution.value; }, set: function (value) { this.uniforms.resolution.value.copy(value); } }, alphaToCoverage: { enumerable: true, get: function () { return Boolean("USE_ALPHA_TO_COVERAGE" in this.defines); }, set: function (value) { if ( Boolean(value) !== Boolean("USE_ALPHA_TO_COVERAGE" in this.defines) ) { this.needsUpdate = true; } if (value === true) { this.defines.USE_ALPHA_TO_COVERAGE = ""; this.extensions.derivatives = true; } else { delete this.defines.USE_ALPHA_TO_COVERAGE; this.extensions.derivatives = false; } } } }); this.setValues(parameters); } } return LineMaterial; })()56:T2676,LineSegments2 = (function () { const _start = new THREE.Vector3(); const _end = new THREE.Vector3(); const _start4 = new THREE.Vector4(); const _end4 = new THREE.Vector4(); const _ssOrigin = new THREE.Vector4(); const _ssOrigin3 = new THREE.Vector3(); const _mvMatrix = new THREE.Matrix4(); const _line = new THREE.Line3(); const _closestPoint = new THREE.Vector3(); const _box = new THREE.Box3(); const _sphere = new THREE.Sphere(); const _clipToWorldVector = new THREE.Vector4(); let _ray, _instanceStart, _instanceEnd, _lineWidth; // Returns the margin required to expand by in world space given the distance from the camera, // line width, resolution, and camera projection function getWorldSpaceHalfWidth(camera, distance, resolution) { // transform into clip space, adjust the x and y values by the pixel width offset, then // transform back into world space to get world offset. Note clip space is [-1, 1] so full // width does not need to be halved. _clipToWorldVector .set(0, 0, -distance, 1.0) .applyMatrix4(camera.projectionMatrix); _clipToWorldVector.multiplyScalar(1.0 / _clipToWorldVector.w); _clipToWorldVector.x = _lineWidth / resolution.width; _clipToWorldVector.y = _lineWidth / resolution.height; _clipToWorldVector.applyMatrix4(camera.projectionMatrixInverse); _clipToWorldVector.multiplyScalar(1.0 / _clipToWorldVector.w); return Math.abs(Math.max(_clipToWorldVector.x, _clipToWorldVector.y)); } function raycastWorldUnits(lineSegments, intersects) { for (let i = 0, l = _instanceStart.count; i < l; i++) { _line.start.fromBufferAttribute(_instanceStart, i); _line.end.fromBufferAttribute(_instanceEnd, i); const pointOnLine = new THREE.Vector3(); const point = new THREE.Vector3(); _ray.distanceSqToSegment(_line.start, _line.end, point, pointOnLine); const isInside = point.distanceTo(pointOnLine) < _lineWidth * 0.5; if (isInside) { intersects.push({ point, pointOnLine, distance: _ray.origin.distanceTo(point), object: lineSegments, face: null, faceIndex: i, uv: null, uv2: null }); } } } function raycastScreenSpace(lineSegments, camera, intersects) { const projectionMatrix = camera.projectionMatrix; const material = lineSegments.material; const resolution = material.resolution; const matrixWorld = lineSegments.matrixWorld; const geometry = lineSegments.geometry; const instanceStart = geometry.attributes.instanceStart; const instanceEnd = geometry.attributes.instanceEnd; const near = -camera.near; // // pick a point 1 unit out along the ray to avoid the ray origin // sitting at the camera origin which will cause "w" to be 0 when // applying the projection matrix. _ray.at(1, _ssOrigin); // ndc space [ - 1.0, 1.0 ] _ssOrigin.w = 1; _ssOrigin.applyMatrix4(camera.matrixWorldInverse); _ssOrigin.applyMatrix4(projectionMatrix); _ssOrigin.multiplyScalar(1 / _ssOrigin.w); // screen space _ssOrigin.x *= resolution.x / 2; _ssOrigin.y *= resolution.y / 2; _ssOrigin.z = 0; _ssOrigin3.copy(_ssOrigin); _mvMatrix.multiplyMatrices(camera.matrixWorldInverse, matrixWorld); for (let i = 0, l = instanceStart.count; i < l; i++) { _start4.fromBufferAttribute(instanceStart, i); _end4.fromBufferAttribute(instanceEnd, i); _start4.w = 1; _end4.w = 1; // camera space _start4.applyMatrix4(_mvMatrix); _end4.applyMatrix4(_mvMatrix); // skip the segment if it's entirely behind the camera const isBehindCameraNear = _start4.z > near && _end4.z > near; if (isBehindCameraNear) { continue; } // trim the segment if it extends behind camera near if (_start4.z > near) { const deltaDist = _start4.z - _end4.z; const t = (_start4.z - near) / deltaDist; _start4.lerp(_end4, t); } else if (_end4.z > near) { const deltaDist = _end4.z - _start4.z; const t = (_end4.z - near) / deltaDist; _end4.lerp(_start4, t); } // clip space _start4.applyMatrix4(projectionMatrix); _end4.applyMatrix4(projectionMatrix); // ndc space [ - 1.0, 1.0 ] _start4.multiplyScalar(1 / _start4.w); _end4.multiplyScalar(1 / _end4.w); // screen space _start4.x *= resolution.x / 2; _start4.y *= resolution.y / 2; _end4.x *= resolution.x / 2; _end4.y *= resolution.y / 2; // create 2d segment _line.start.copy(_start4); _line.start.z = 0; _line.end.copy(_end4); _line.end.z = 0; // get closest point on ray to segment const param = _line.closestPointToPointParameter(_ssOrigin3, true); _line.at(param, _closestPoint); // check if the intersection point is within clip space const zPos = THREE.MathUtils.lerp(_start4.z, _end4.z, param); const isInClipSpace = zPos >= -1 && zPos <= 1; const isInside = _ssOrigin3.distanceTo(_closestPoint) < _lineWidth * 0.5; if (isInClipSpace && isInside) { _line.start.fromBufferAttribute(instanceStart, i); _line.end.fromBufferAttribute(instanceEnd, i); _line.start.applyMatrix4(matrixWorld); _line.end.applyMatrix4(matrixWorld); const pointOnLine = new THREE.Vector3(); const point = new THREE.Vector3(); _ray.distanceSqToSegment(_line.start, _line.end, point, pointOnLine); intersects.push({ point: point, pointOnLine: pointOnLine, distance: _ray.origin.distanceTo(point), object: lineSegments, face: null, faceIndex: i, uv: null, uv2: null }); } } } class LineSegments2 extends THREE.Mesh { constructor( geometry = new THREE.LineSegmentsGeometry(), material = new THREE.LineMaterial({ color: Math.random() * 0xffffff }) ) { super(geometry, material); this.isLineSegments2 = true; this.type = "LineSegments2"; } // for backwards-compatibility, but could be a method of THREE.LineSegmentsGeometry... computeLineDistances() { const geometry = this.geometry; const instanceStart = geometry.attributes.instanceStart; const instanceEnd = geometry.attributes.instanceEnd; const lineDistances = new Float32Array(2 * instanceStart.count); for (let i = 0, j = 0, l = instanceStart.count; i < l; i++, j += 2) { _start.fromBufferAttribute(instanceStart, i); _end.fromBufferAttribute(instanceEnd, i); lineDistances[j] = j === 0 ? 0 : lineDistances[j - 1]; lineDistances[j + 1] = lineDistances[j] + _start.distanceTo(_end); } const instanceDistanceBuffer = new THREE.InstancedInterleavedBuffer( lineDistances, 2, 1 ); // d0, d1 geometry.setAttribute( "instanceDistanceStart", new THREE.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 0) ); // d0 geometry.setAttribute( "instanceDistanceEnd", new THREE.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 1) ); // d1 return this; } raycast(raycaster, intersects) { const worldUnits = this.material.worldUnits; const camera = raycaster.camera; if (camera === null && !worldUnits) { console.error( 'LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2 while worldUnits is set to false.' ); } const threshold = raycaster.params.Line2 !== undefined ? raycaster.params.Line2.threshold || 0 : 0; _ray = raycaster.ray; const matrixWorld = this.matrixWorld; const geometry = this.geometry; const material = this.material; _lineWidth = material.linewidth + threshold; _instanceStart = geometry.attributes.instanceStart; _instanceEnd = geometry.attributes.instanceEnd; // check if we intersect the sphere bounds if (geometry.boundingSphere === null) { geometry.computeBoundingSphere(); } _sphere.copy(geometry.boundingSphere).applyMatrix4(matrixWorld); // increase the sphere bounds by the worst case line screen space width let sphereMargin; if (worldUnits) { sphereMargin = _lineWidth * 0.5; } else { const distanceToSphere = Math.max( camera.near, _sphere.distanceToPoint(_ray.origin) ); sphereMargin = getWorldSpaceHalfWidth( camera, distanceToSphere, material.resolution ); } _sphere.radius += sphereMargin; if (_ray.intersectsSphere(_sphere) === false) { return; } // check if we intersect the box bounds if (geometry.boundingBox === null) { geometry.computeBoundingBox(); } _box.copy(geometry.boundingBox).applyMatrix4(matrixWorld); // increase the box bounds by the worst case line width let boxMargin; if (worldUnits) { boxMargin = _lineWidth * 0.5; } else { const distanceToBox = Math.max( camera.near, _box.distanceToPoint(_ray.origin) ); boxMargin = getWorldSpaceHalfWidth( camera, distanceToBox, material.resolution ); } _box.expandByScalar(boxMargin); if (_ray.intersectsBox(_box) === false) { return; } if (worldUnits) { raycastWorldUnits(this, intersects); } else { raycastScreenSpace(this, camera, intersects); } } } return LineSegments2; })()57:T2154, class STLLoader extends THREE.Loader { constructor(manager) { super(manager); } load(url, onLoad, onProgress, onError) { const scope = this; const loader = new THREE.FileLoader(this.manager); loader.setPath(this.path); loader.setResponseType("arraybuffer"); loader.setRequestHeader(this.requestHeader); loader.setWithCredentials(this.withCredentials); loader.load( url, function (text) { try { onLoad(scope.parse(text)); } catch (e) { if (onError) { onError(e); } else { console.error(e); } scope.manager.itemError(url); } }, onProgress, onError ); } parse(data) { function isBinary(data) { const reader = new DataView(data); const face_size = (32 / 8) * 3 + (32 / 8) * 3 * 3 + 16 / 8; const n_faces = reader.getUint32(80, true); const expect = 80 + 32 / 8 + n_faces * face_size; if (expect === reader.byteLength) { return true; } // An ASCII STL data must begin with 'solid ' as the first six bytes. // However, ASCII STLs lacking the SPACE after the 'd' are known to be // plentiful. So, check the first 5 bytes for 'solid'. // Several encodings, such as UTF-8, precede the text with up to 5 bytes: // https://en.wikipedia.org/wiki/Byte_order_mark#Byte_order_marks_by_encoding // Search for "solid" to start anywhere after those prefixes. // US-ASCII ordinal values for 's', 'o', 'l', 'i', 'd' const solid = [115, 111, 108, 105, 100]; for (let off = 0; off < 5; off++) { // If "solid" text is matched to the current offset, declare it to be an ASCII STL. if (matchDataViewAt(solid, reader, off)) return false; } // Couldn't find "solid" text at the beginning; it is binary STL. return true; } function matchDataViewAt(query, reader, offset) { // Check if each byte in query matches the corresponding byte from the current offset for (let i = 0, il = query.length; i < il; i++) { if (query[i] !== reader.getUint8(offset + i)) return false; } return true; } function parseBinary(data) { const reader = new DataView(data); const faces = reader.getUint32(80, true); let r, g, b, hasColors = false, colors; let defaultR, defaultG, defaultB, alpha; // process STL header // check for default color in header ("COLOR=rgba" sequence). for (let index = 0; index < 80 - 10; index++) { if ( reader.getUint32(index, false) == 0x434f4c4f /*COLO*/ && reader.getUint8(index + 4) == 0x52 /*'R'*/ && reader.getUint8(index + 5) == 0x3d /*'='*/ ) { hasColors = true; colors = new Float32Array(faces * 3 * 3); defaultR = reader.getUint8(index + 6) / 255; defaultG = reader.getUint8(index + 7) / 255; defaultB = reader.getUint8(index + 8) / 255; alpha = reader.getUint8(index + 9) / 255; } } const dataOffset = 84; const faceLength = 12 * 4 + 2; const geometry = new THREE.BufferGeometry(); const vertices = new Float32Array(faces * 3 * 3); const normals = new Float32Array(faces * 3 * 3); for (let face = 0; face < faces; face++) { const start = dataOffset + face * faceLength; const normalX = reader.getFloat32(start, true); const normalY = reader.getFloat32(start + 4, true); const normalZ = reader.getFloat32(start + 8, true); if (hasColors) { const packedColor = reader.getUint16(start + 48, true); if ((packedColor & 0x8000) === 0) { // facet has its own unique color r = (packedColor & 0x1f) / 31; g = ((packedColor >> 5) & 0x1f) / 31; b = ((packedColor >> 10) & 0x1f) / 31; } else { r = defaultR; g = defaultG; b = defaultB; } } for (let i = 1; i <= 3; i++) { const vertexstart = start + i * 12; const componentIdx = face * 3 * 3 + (i - 1) * 3; vertices[componentIdx] = reader.getFloat32(vertexstart, true); vertices[componentIdx + 1] = reader.getFloat32(vertexstart + 4, true); vertices[componentIdx + 2] = reader.getFloat32(vertexstart + 8, true); normals[componentIdx] = normalX; normals[componentIdx + 1] = normalY; normals[componentIdx + 2] = normalZ; if (hasColors) { colors[componentIdx] = r; colors[componentIdx + 1] = g; colors[componentIdx + 2] = b; } } } geometry.setAttribute("position", new THREE.BufferAttribute(vertices, 3)); geometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3)); if (hasColors) { geometry.setAttribute("color", new THREE.BufferAttribute(colors, 3)); geometry.hasColors = true; geometry.alpha = alpha; } return geometry; } function parseASCII(data) { const geometry = new THREE.BufferGeometry(); const patternSolid = /solid([\s\S]*?)endsolid/g; const patternFace = /facet([\s\S]*?)endfacet/g; let faceCounter = 0; const patternFloat = /[\s]+([+-]?(?:\d*)(?:\.\d*)?(?:[eE][+-]?\d+)?)/ .source; const patternVertex = new RegExp( "vertex" + patternFloat + patternFloat + patternFloat, "g" ); const patternNormal = new RegExp( "normal" + patternFloat + patternFloat + patternFloat, "g" ); const vertices = []; const normals = []; const normal = new THREE.Vector3(); let result; let groupCount = 0; let startVertex = 0; let endVertex = 0; while ((result = patternSolid.exec(data)) !== null) { startVertex = endVertex; const solid = result[0]; while ((result = patternFace.exec(solid)) !== null) { let vertexCountPerFace = 0; let normalCountPerFace = 0; const text = result[0]; while ((result = patternNormal.exec(text)) !== null) { normal.x = parseFloat(result[1]); normal.y = parseFloat(result[2]); normal.z = parseFloat(result[3]); normalCountPerFace++; } while ((result = patternVertex.exec(text)) !== null) { vertices.push( parseFloat(result[1]), parseFloat(result[2]), parseFloat(result[3]) ); normals.push(normal.x, normal.y, normal.z); vertexCountPerFace++; endVertex++; } // every face have to own ONE valid normal if (normalCountPerFace !== 1) { console.error( "THREE.STLLoader: Something isn't right with the normal of face number " + faceCounter ); } // each face have to own THREE valid vertices if (vertexCountPerFace !== 3) { console.error( "THREE.STLLoader: Something isn't right with the vertices of face number " + faceCounter ); } faceCounter++; } const start = startVertex; const count = endVertex - startVertex; geometry.addGroup(start, count, groupCount); groupCount++; } geometry.setAttribute( "position", new THREE.Float32BufferAttribute(vertices, 3) ); geometry.setAttribute( "normal", new THREE.Float32BufferAttribute(normals, 3) ); return geometry; } function ensureString(buffer) { if (typeof buffer !== "string") { return THREE.LoaderUtils.decodeText(new Uint8Array(buffer)); } return buffer; } function ensureBinary(buffer) { if (typeof buffer === "string") { const array_buffer = new Uint8Array(buffer.length); for (let i = 0; i < buffer.length; i++) { array_buffer[i] = buffer.charCodeAt(i) & 0xff; // implicitly assumes little-endian } return array_buffer.buffer || array_buffer; } else { return buffer; } } // start const binData = ensureBinary(data); return isBinary(binData) ? parseBinary(binData) : parseASCII(ensureString(data)); } }58:[{"id":"fae91151993d52b574ba694c5b1360fad7876564ce38c39233b243db449c7a9e694b33201cab88bdcacba84def3950a4a203c00ad8ad6f89c5954bc60bbe556c","href":"https://static.observableusercontent.com/files/fae91151993d52b574ba694c5b1360fad7876564ce38c39233b243db449c7a9e694b33201cab88bdcacba84def3950a4a203c00ad8ad6f89c5954bc60bbe556c","name":"box@1.stl","type":"model/stl","lastModified":1669593464144.585,"size":1510},{"id":"87457dc05a7f87048251b931515c72d9794b9d6f7f4a92ea1bfdf804250245fea203e1ca45ecc20901c448fb671d0a39f31c987d7780df6720f8473c991721b5","href":"https://static.observableusercontent.com/files/87457dc05a7f87048251b931515c72d9794b9d6f7f4a92ea1bfdf804250245fea203e1ca45ecc20901c448fb671d0a39f31c987d7780df6720f8473c991721b5","name":"bottle@1.stl","type":"model/stl","lastModified":1669706435430.181,"size":565154},{"id":"872541e0c82db9181fdf4a9ad00f2ef73da4dfcc88a972c40b39e801175a62068db91e076787d83d0984592e0bc57cf29282cf20b5a35bdf9a8b55dceaf877ca","href":"https://static.observableusercontent.com/files/872541e0c82db9181fdf4a9ad00f2ef73da4dfcc88a972c40b39e801175a62068db91e076787d83d0984592e0bc57cf29282cf20b5a35bdf9a8b55dceaf877ca","name":"bowl@1.stl","type":"model/stl","lastModified":1669706273345.612,"size":365774},{"id":"e30a5d2232897d1d8bcaf7271330df2577cb026b284faff0ec25a1e7fa781e4dd5860d1bee005e26ceca825ee1403e7de01bf12af734a72e72c7c16e3e289482","href":"https://static.observableusercontent.com/files/e30a5d2232897d1d8bcaf7271330df2577cb026b284faff0ec25a1e7fa781e4dd5860d1bee005e26ceca825ee1403e7de01bf12af734a72e72c7c16e3e289482","name":"wireprint_cover.png","type":"image/png","lastModified":1670441145459.479,"size":344472},{"id":"68c8d9eff3672ebec3555f31d30a23b5c966eff40cff949586d5927e256f4ec95d65ad8b00185e5a315ce4dd3d4f6bf7e58405fbbceb9eeedc672db3d83e7f8b","href":"https://static.observableusercontent.com/files/68c8d9eff3672ebec3555f31d30a23b5c966eff40cff949586d5927e256f4ec95d65ad8b00185e5a315ce4dd3d4f6bf7e58405fbbceb9eeedc672db3d83e7f8b","name":"triangle-plane.jpg","type":"image/jpeg","lastModified":1670477779035.366,"size":114283},{"id":"40349188713e0dfe26412efe24243a56eab5766067a36b2937021c792c22ba846c5a579056462b31eb9081a74f11dffdfc0a406a5838163db878dadd996c4dc6","href":"https://static.observableusercontent.com/files/40349188713e0dfe26412efe24243a56eab5766067a36b2937021c792c22ba846c5a579056462b31eb9081a74f11dffdfc0a406a5838163db878dadd996c4dc6","name":"segment-plane.png","type":"image/png","lastModified":1670477864448.095,"size":53652},{"id":"a4f6c84d9cda01306c5f705915cc06bb11efb24b10b76ad5bba7c1738d4dfd3c16872e2ffd3c5fa584aa0b25b93642f67b18177ebd85df1b7433574495cefe05","href":"https://static.observableusercontent.com/files/a4f6c84d9cda01306c5f705915cc06bb11efb24b10b76ad5bba7c1738d4dfd3c16872e2ffd3c5fa584aa0b25b93642f67b18177ebd85df1b7433574495cefe05","name":"contour-generation.png","type":"image/png","lastModified":1670477879852.464,"size":44633},{"id":"ba62d702ddcf3a8039d0b0d9308be17a01618f93ca68c143407548f848f5dfabb350aecd1f3fca5919d8c3b4dd8693afe7634d6e362c1c346200847cc78cac9c","href":"https://static.observableusercontent.com/files/ba62d702ddcf3a8039d0b0d9308be17a01618f93ca68c143407548f848f5dfabb350aecd1f3fca5919d8c3b4dd8693afe7634d6e362c1c346200847cc78cac9c","name":"zigzag.png","type":"image/png","lastModified":1670477900387.321,"size":35437},{"id":"59ca0e482118663084279ee7c0be83bde6a6ccccd12da631a42b9969b375d29f8e2630f5d09912a498af0278f52725545546537cae2a12477821747ffad8f6db","href":"https://static.observableusercontent.com/files/59ca0e482118663084279ee7c0be83bde6a6ccccd12da631a42b9969b375d29f8e2630f5d09912a498af0278f52725545546537cae2a12477821747ffad8f6db","name":"test-prints.jpg","type":"image/jpeg","lastModified":1670479473308.143,"size":1433497},{"id":"c2994456b1ed38a3b43926caf64552ae4fe88fae0056784b7535fc8be4b257e07bdbc9e5c31a4742db1514771189202f6b628ac5d3fb8529032f014fcda097a3","href":"https://static.observableusercontent.com/files/c2994456b1ed38a3b43926caf64552ae4fe88fae0056784b7535fc8be4b257e07bdbc9e5c31a4742db1514771189202f6b628ac5d3fb8529032f014fcda097a3","name":"Screen Shot 2022-12-07 at 10.27.38 PM.png","type":"image/png","lastModified":1670481008036.414,"size":16499},{"id":"953873a6d7b549ca1549fc15488ed3a3a4b0f7ea8a6bca2ea50581a55009e4dee52ef0ecc7a711391af06e2b2543648f4578c31e86374d8c5a19f1e075b2f7d5","href":"https://static.observableusercontent.com/files/953873a6d7b549ca1549fc15488ed3a3a4b0f7ea8a6bca2ea50581a55009e4dee52ef0ecc7a711391af06e2b2543648f4578c31e86374d8c5a19f1e075b2f7d5","name":"Screen Shot 2022-12-07 at 10.27.44 PM.png","type":"image/png","lastModified":1670481017599.867,"size":14620},{"id":"7e9baaf7d7f1afa5040927ae2b563e2a7535ab4fbc15185b490accbb73c3f7f95668402bcee6a85cc7488ab63063cf8b9fc0005c0824fc4a0d35e823c3fe902e","href":"https://static.observableusercontent.com/files/7e9baaf7d7f1afa5040927ae2b563e2a7535ab4fbc15185b490accbb73c3f7f95668402bcee6a85cc7488ab63063cf8b9fc0005c0824fc4a0d35e823c3fe902e","name":"results.jpg","type":"image/jpeg","lastModified":1670481251555.319,"size":4333438},{"id":"331ae343febfb9dcac52cfb484a6573abf5d0b93ccca6d3ca0063368fb4ac0c27e68f66c1b27d19ee55eef7e6fd6dbe4a194d9c98acb3dc56e186bced7c9d347","href":"https://static.observableusercontent.com/files/331ae343febfb9dcac52cfb484a6573abf5d0b93ccca6d3ca0063368fb4ac0c27e68f66c1b27d19ee55eef7e6fd6dbe4a194d9c98acb3dc56e186bced7c9d347","name":"stabilize.jpg","type":"image/jpeg","lastModified":1670482487334.321,"size":3189916}] 2f:{"title":"Imprimer: Wireprint Example","cells":[{"id":0,"value":"# Imprimer: Wireprint Example","pinned":false,"hidden":false,"mode":"md"},{"id":805,"value":"**_Jasper Tran O'Leary_**","pinned":false,"hidden":false,"mode":"md"},{"id":1022,"value":"_This interactive article documents a novel 3D printing approach introduced in 2014 by Mueller et al. Step-by-step, I break down, visualize, and facilitate real-world testing and deployment of the WirePrint 3D printing pipeline which can be difficult to understand by reading a static paper alone. The article relates to the future of scholarly communication by proposing **a medium where research with 3D data and physical artifacts can be more effectively communicated.** Current examples of interactive articles tend to focus on digital-only domains like machine learning or articles where a visualization is the final project. Instead, this article uses visualization and interaction as a means to explore another problem: getting a 3D printer to work using an unconventional printing method._","pinned":false,"hidden":false,"mode":"md"},{"id":808,"value":"## Introduction","pinned":false,"hidden":false,"mode":"md"},{"id":815,"value":"This interactive article explores a 3D printing technique presented in [\"WirePrint: 3D Printed Previews for Fast Prototyping\"](https://hpi.de/baudisch/projects/wireprint.html) by Stefanie Mueller, Sangha Im, Serafima Gurevich, Alexander Teibrich, Lisa Pfisterer, François Guimbretière, and Patrick Baudisch. The technique is a quick way of 3D a printing a prototype of an object. Compared to a typical approach, which prints the entire object represented by a 3D model, WirePrint prints a only low-fidelity wireframe of the 3D model.","pinned":false,"hidden":false,"mode":"md"},{"id":975,"value":"wireprint_cover = FileAttachment(\"wireprint_cover.png\").image({ width: 600 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":983,"value":"

WirePrint cover photo from the project's website. Left to right: a specialized 3D printer printing a wireframe of a bottle, the bottle in a person's hand, and a conventional 2014-era printer printing a wireframe.

","pinned":false,"hidden":false,"mode":"html"},{"id":978,"value":"This paper was published in a conference within human-computer interaction (HCI) and computer science called the ACM Symposium on User Interface Software and Technology (UIST). It represented the expansion of HCI's focus to include matters of digital fabrication. In this case, the contribution is largely engineering-based and the actual \"human\" aspects of the paper are less apparent. In terms of research framing within HCI, WirePrint references the concepts of [personal fabrication]() and [interactive fabrication](). While both concepts have recently become widely cited, I would personally argue that what constitutes each is not well-defined and authors often shoehorn their contributions to fall under these categories.","pinned":false,"hidden":false,"mode":"md"},{"id":987,"value":"This article walks through how the WirePrint algorithm goes from a 3D model to a printed wireframe. I built this process in a notebook format by closely reading the paper, but also by visualizing and testing on a 3D printer at every step.","pinned":false,"hidden":false,"mode":"md"},{"id":748,"value":"## Creating a Mesh","pinned":false,"hidden":false,"mode":"md"},{"id":991,"value":"3D models can be represented in several ways, but one of the most common ways is as a _mesh_. A mesh is a set of triangles positioned in such a way that they resemble a 3D object. Using the THREE.js graphics library, we can create a mesh by first defining a `Geometry`, which represents the triangle configurations of a mesh, and a `Material` which represents how the surface of the mesh will appear when rendered.","pinned":false,"hidden":false,"mode":"md"},{"id":185,"value":"viewof modelVizSpace = new Promise((resolve) => {\n resolve(html`

`);\n}).then((domElement) => {\n let materialParams = {\n width: 250,\n height: 250,\n thickness: 1\n };\n let vizSpace = new VisualizationSpace(domElement, materialParams);\n invalidation.then(() => vizSpace.removeAllViz());\n domElement.value = vizSpace;\n return domElement;\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":429,"value":"viewof layerHeightBasic = Inputs.radio([0.2, 0.4, 0.8, 1.6, 3.2], {\n label: \"Distance between cutting planes (mm)\",\n value: 0.8\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1297,"value":"You can experiment with different layer heights above to see the results. Below I briefly detail the three steps in slicing.","pinned":false,"hidden":false,"mode":"md"},{"id":1006,"value":"### 1. Triangle-Plane Intersection","pinned":false,"hidden":false,"mode":"md"},{"id":1264,"value":"trianglePlane = FileAttachment(\"triangle-plane.jpg\").image({ width: 500 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":1314,"value":"Given our layer height (distance between cutting planes), we draw a plane ${tex`p`} and at each height and check every triangle in the mesh for intersections. A triangle-plane intersection is usually a segment ${tex`(i_1, i_2)`}, which means the plane intersects the triangle as above. The plane can also intersect the triangle at a point or at the entire triangle in the case of a coplanar triangle, which we ignore in this implementation.","pinned":false,"hidden":false,"mode":"md"},{"id":1387,"value":"_You can see the code for this in the `Slicer` class below, but be warned that it's messy._","pinned":false,"hidden":false,"mode":"md"},{"id":1009,"value":"### 2. Getting Segments from Cut Planes","pinned":false,"hidden":false,"mode":"md"},{"id":1271,"value":"segmentPlane = FileAttachment(\"segment-plane.png\").image({ width: 500 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":1031,"value":"Given a single side of the triangle bounded by ${tex`(v_1, v_2)`} which are vertices on the triangle, we can formulate the vertex as two rays e.g. ${tex`\\hat{r_1} = v_1 + t\\hat{j}`} where ${tex`\\hat{j}`} is a vector pointing from ${tex`v_1`} to the plane ${tex`p`} and ${tex`t`} can be determined as is done below.","pinned":false,"hidden":false,"mode":"md"},{"id":1322,"value":"segmentPlaneIntersect = (v0, v1, plane) => {\n let tEps = 0.00001;\n let v0_dist_to_plane = plane.distanceToPoint(v0);\n let v1_dist_to_plane = plane.distanceToPoint(v1);\n let pointIntersect = v0_dist_to_plane * v1_dist_to_plane < 0;\n let segmentIntersect = v0_dist_to_plane < tEps && v1_dist_to_plane < tEps;\n if (pointIntersect) {\n // NOTE: isect = v0 + t * (v1 - v0)\n let denom = v0_dist_to_plane - v1_dist_to_plane;\n if (Math.abs(denom) < tEps) {\n return v0.clone();\n }\n let t = v0_dist_to_plane / denom;\n let isect = new THREE.Vector3().copy(v0);\n let rest = new THREE.Vector3().copy(v1).sub(v0).multiplyScalar(t);\n return isect.add(rest);\n }\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":1011,"value":"### Joining Segments into Contours","pinned":false,"hidden":false,"mode":"md"},{"id":1274,"value":"contourGeneration = FileAttachment(\"contour-generation.png\").image({\n width: 500\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1375,"value":"Finally, we iterate through the segments and connect them into continuous contours by matching the end points.","pinned":false,"hidden":false,"mode":"md"},{"id":1384,"value":"$31","pinned":true,"hidden":false,"mode":"ojs"},{"id":1376,"value":"We also need to make sure our contours are all running in a consistent direction—let's pick clockwise.","pinned":false,"hidden":false,"mode":"md"},{"id":665,"value":"contourClockwise = (pts) => {\n // SOURCE: https://discourse.threejs.org/t/how-to-collect-the-clockwise-and-anticlock-wise-points-from-reference-points/39309/6\n // With modifications for use with THREE.Vector3\n const len = pts.length;\n let [minx, miny, mi] = [pts[0].x, pts[0].z, 0];\n for (let i = 1; i < len; i++) {\n const [pix, piy] = [pts[i].x, pts[i].z];\n if (pix < minx || (pix == minx && piy < miny))\n [minx, miny, mi] = [pix, piy, i];\n }\n const [mp, mn] = [mi != 0 ? mi - 1 : len - 1, mi != len - 1 ? mi + 1 : 0];\n const [a, b, c] = [pts[mp], pts[mi], pts[mn]];\n const det = (b.x - a.x) * (c.z - a.z) - (c.x - a.x) * (b.z - a.z);\n return det < 0;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":1310,"value":"I implemented the complete slicer as the class below, and it's a bit of a mess that I'd like to clean up in the future.","pinned":false,"hidden":false,"mode":"md"},{"id":122,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":762,"value":"### Downsampling","pinned":false,"hidden":false,"mode":"md"},{"id":1055,"value":"Because we want to subdivide each contour into multiple triangles that comprise the zigzag, we divide each contour using a fixed number of sample points. For the sake of convenience here, we interpolate each contour into a Catmull-Rom curve and use THREE.js's built-in functionality to draw a constant number of evenly spaced sample points along the curve. Exactly how the authors of Wireprint did this in their case is not clearly specified.","pinned":false,"hidden":false,"mode":"md"},{"id":555,"value":"function downsampleContour(contour) {\n if (contour.length < 2) {\n return [];\n }\n let curve = new THREE.CatmullRomCurve3(contour);\n let pts = curve.getSpacedPoints(Math.ceil(numDivisions));\n return [contour[0]].concat(pts).concat(contour[contour.length - 1]);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":891,"value":"One problem with downsampling is that you can \"cut corners\" or miss an important geometrical feature by naively downsampling the curve. This happens especially for geometries with sharp corners e.g. a box. In the interest of just getting to the printing, we will ignore this problem for now and just have slightly misshapen geometries like chamfered boxes. This wouldn't be acceptable in practice but this is a demo. Having some automatic means of preserving \"important\" corners is nontrivial.","pinned":false,"hidden":false,"mode":"md"},{"id":1308,"value":"For now, we choose a static number of divisions for every contour by eyeballing the visualization and trying to get nice looking triangles.","pinned":false,"hidden":false,"mode":"md"},{"id":544,"value":"numDivisions = 16","pinned":true,"hidden":false,"mode":"ojs"},{"id":768,"value":"## Generating Machine Instructions","pinned":false,"hidden":false,"mode":"md"},{"id":1089,"value":"Before we get into how to generate the zigzag, we consider how to generate the _toolpath_, that is, where the machine will actually move, by translating contour information into our machine instruction language. We then visualize the results.","pinned":false,"hidden":false,"mode":"md"},{"id":1209,"value":"3D printers are controlled by sending them instructions called G-Code, a language developed in the middle of the last century. G-Code instructions are low level, for example, moving the 3D print head in a single line at a given speed uses the form","pinned":false,"hidden":false,"mode":"md"},{"id":1210,"value":"**`G1 X10 Y20 Z30 E1.0 F1000 ; comments go after a semicolon`**","pinned":false,"hidden":false,"mode":"md"},{"id":1230,"value":"Which breaks down as follows","pinned":false,"hidden":false,"mode":"md"},{"id":1231,"value":"$33","pinned":false,"hidden":false,"mode":"md"},{"id":1352,"value":"We'll set a layer height of 5mm which I determined from my own printer's functionality, generate a fresh batch of contours for this layer height, and translate it into G-Code.","pinned":false,"hidden":false,"mode":"md"},{"id":517,"value":"layerHeightWireframe = 5","pinned":false,"hidden":false,"mode":"ojs"},{"id":511,"value":"sliceLayersWireframe = {\n let slicer = new Slicer({\n layerHeight: layerHeightWireframe,\n infill: null\n });\n return slicer.slice(testMesh);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":521,"value":"wireframeSliceTp = sliceLayersToInsts(sliceLayersWireframe).flat()","pinned":false,"hidden":false,"mode":"ojs"},{"id":1363,"value":"The contour-to-G-code function is as follows.","pinned":false,"hidden":false,"mode":"md"},{"id":283,"value":"$34","pinned":true,"hidden":false,"mode":"ojs"},{"id":766,"value":"## Generating the Zigzag","pinned":false,"hidden":false,"mode":"md"},{"id":1060,"value":"For each sliced layer, we generate a vertical side and a hypotenuse for each contour subdivision.","pinned":false,"hidden":false,"mode":"md"},{"id":1276,"value":"zigzag = FileAttachment(\"zigzag.png\").image({ width: 500 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":795,"value":"### Linking the Verticals Across Layers","pinned":false,"hidden":false,"mode":"md"},{"id":797,"value":"The paper offers the following passage about how to pick the start and end points of the verticals across layers:","pinned":false,"hidden":false,"mode":"md"},{"id":1041,"value":"_Simply using the points from the slice below does not work, because subsequent slices might: (1) have a different contour length, which can lead to insufficient space between two subsequent points (print head collision), and (2) slices might have different heights, which can lead to invalid printing angles. We therefore use a mixed approach: First we calculate the optimal even spacing of points for each contour. Then we calculate the minimum distance from a point on the bottom slice to the top slice. We then use the average of both, which leads to good stability and a comparably homogeneous spacing. In the case that two vertical lines are still too close to each other, we ignore one of them._","pinned":false,"hidden":false,"mode":"md"},{"id":1047,"value":"Unfortunately, I wasn't exactly sure what this meant given the that the paper did not describe how their algorithm picked different heights (besides using a constant spacing) or how they calculated optimal spacing. In my case, because the geometries are simple enough, I chose to just naively link the vertical between corresponding points on the current layer with the next, given that we are guaranteed to have clockwise orderings of points. However, this would not work for geometries that have sharp variations in contour sizes.","pinned":false,"hidden":false,"mode":"md"},{"id":1052,"value":"Ultimately, implementing the zigzag function, we get the following code and zigzags.","pinned":false,"hidden":false,"mode":"md"},{"id":621,"value":"$35","pinned":true,"hidden":false,"mode":"ojs"},{"id":1462,"value":"And we obtain the zigzag G-Code as follows.","pinned":false,"hidden":false,"mode":"md"},{"id":635,"value":"zigZags = downsampledContours.map((_, cIdx) => {\n let currLayer = downsampledContours[cIdx];\n let nextLayer =\n cIdx + 1 < downsampledContours.length ? downsampledContours[cIdx + 1] : [];\n return layerToZigZag(currLayer, nextLayer);\n})","pinned":true,"hidden":false,"mode":"ojs"},{"id":773,"value":"## Finding Feasible Instructions Parameters","pinned":false,"hidden":false,"mode":"md"},{"id":1367,"value":"The real challenge of this paper is finding the feasible parameters. I had originally intended this project to explore the parameter space until I realized the hard way **that almost no parameter combinations are feasible at all.** I could barely find a combination that produced a pretty poor result that at least stood up. Such is the life of an engineering challenge. The original WirePrint paper includes brief notes about the following considerations.","pinned":false,"hidden":false,"mode":"md"},{"id":1389,"value":"_We identified three potential approaches to improve the quality of a WirePrint:_\n\n1. _WirePrint reduces the overall speed with which the print head moves, allowing the filament to solidify as it’s being printed;_\n2. _WirePrint moves the print head quickly, but pauses at the end of each vertical edge to let the edge solidify;_\n3. _WirePrint prints full speed, but anticipates the deformation by extending the vertical movement of the print head (see Figure [below])._\n\n_Through experimentation, we discovered that the fastest way to print is to add a delay at the end of each floating edge. Although a pause at the end of each vertical edge initially seemed unattractive, it lead to the most accurate results because the edges solidify under tension. Anticipating the deformation during printing was attractive at first, but the extra traveling time of the print head quickly undermined the benefit of a faster printing speed, and in general the results where less appealing._","pinned":false,"hidden":false,"mode":"md"},{"id":1399,"value":"screenShot20221207At102738Pm = FileAttachment(\n \"Screen Shot 2022-12-07 at 10.27.38 PM.png\"\n).image({ width: 315 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":1400,"value":"screenShot20221207At102744Pm = FileAttachment(\n \"Screen Shot 2022-12-07 at 10.27.44 PM.png\"\n).image({ width: 315 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":1412,"value":"

Figures from the WirePrint paper illustrating physics problems addressed by parameter tuning.

","pinned":false,"hidden":false,"mode":"html"},{"id":778,"value":"## Deploying to a Real 3D Printer","pinned":false,"hidden":false,"mode":"md"},{"id":1434,"value":"Finally, we can zip the contours and zigzags together and translate them to G-Code.","pinned":false,"hidden":false,"mode":"md"},{"id":647,"value":"interleaved = downsampledTp\n // You can edit this line to show only layers or zigzags\n .map((layer, i) => [layer, zigZags[i]])\n .flat()\n .flat()","pinned":true,"hidden":false,"mode":"ojs"},{"id":1435,"value":"To this G-Code toolpath we must also add a _preamble_ that sets machine settings along with an _epilogue_ that does clean up.","pinned":false,"hidden":false,"mode":"md"},{"id":953,"value":"preamble = `\n; PREAMBLE\nM73 P0 R2\nM73 Q0 S2\nM201 X1000 Y1000 Z1000 E5000 ; sets maximum accelerations, mm/sec^2\nM203 X200 Y200 Z12 E120 ; sets maximum feedrates, mm/sec\nM204 P1250 R1250 T1250 ; sets acceleration (P, T) and retract acceleration (R), mm/sec^2\nM205 X8.00 Y8.00 Z0.40 E1.750 ; sets the jerk limits, mm/sec\nM205 S0 T0 ; sets the minimum extruding and travel feed rate, mm/sec\nM107\n; M115 U3.6.0 ; tell printer latest fw version\nM83 ; extruder relative mode\nM302 P1 ; CAREFUL - enable cold extrusion\nM104 S185 ; set extruder temp - set high for first layer only\nM140 S60 ; set bed temp\nM190 S60 ; wait for bed temp\nM109 S185 ; wait for extruder temp\nG28 W ; home all without mesh bed level\n; G80 ; mesh bed leveling\nG1 Y-3.0 F1000.0 ; go outside print area\nG92 E0.0\nG1 X60.0 E9.0 F1000.0 ; intro line\nM73 Q2 S2\nM73 P2 R2\nG1 X100.0 E12.5 F1000.0 ; intro line\nG92 E0.0\nM900 K30; Filament gcode\nG90 ; use absolute coordinates\nM83 ; use relative distances for extrusion\n\n; M106 S255 ; fan on max\n\n; END PREAMBLE\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1099,"value":"epilogue = `\n; EPILOGUE\n; Filament-specific end gcode\nG4 ; wait\nM221 S100\n;M104 S0 ; turn off temperature\n;M140 S0 ; turn off heatbed\n;M302 P0 ; disable cold extrusion\nM107 ; turn off fan\n;G1 Z31.55 ; Move print head up\nG1 X0 Y200 F2000; home X axis\nM84 ; disable motors\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1103,"value":"completeToolpath = {\n let mainTp = interleaved.join(\"\\n\");\n return preamble.concat(mainTp).concat(epilogue);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":1448,"value":"While I would like to deploy straight from the notebook, I didn't have the time to set this infrastructure up and so we can just download the G-code for now and use an SD card or printing interface to deploy.","pinned":false,"hidden":false,"mode":"md"},{"id":1146,"value":"downloadButton(completeToolpath)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1450,"value":"Now we can visualize the toolpath! Try moving the slider to see the animation.","pinned":false,"hidden":false,"mode":"md"},{"id":351,"value":"viewof tssVizSpace = new Promise((resolve) => {\n resolve(html`

A very small subset of prints testing different parameters.

","pinned":false,"hidden":false,"mode":"html"},{"id":781,"value":"Physics and visualizations aside, to actually determine the values that would work for fabricating the WirePrint pattern on my lab's printer, there is no substitution for manual testing. I used a 3-layer wall pattern as a test print. I repeatedly printed the test print while visually observing the results and changing one of the following parameters at a time, obtaining the final results in bold:","pinned":false,"hidden":false,"mode":"md"},{"id":1019,"value":"- Extruder temperature - **185 C**\n- Bed temperature - **60 C**\n- Vertical feed rate - **250 mm/s**\n- Vertical extrusion - **0.4 mm**\n- Hypotenuse feed rate - **1500 mm/s**\n- Hypotenuse extrusion - **1.75 mm**\n- Pause length - **1500 ms**\n- Post-vertical retraction amount - **0.4 mm**\n- Pre-hypotenuse unretraction amount **0.4 mm**","pinned":false,"hidden":false,"mode":"md"},{"id":929,"value":"After a ton of trials and tribulations, I was able to get the following two barely successful prints of the cylinder and the box. I was not able to print the bowl, likely due to the naïveté of my vertical generation algorithm.","pinned":false,"hidden":false,"mode":"md"},{"id":1416,"value":"results = FileAttachment(\"results.jpg\").image({ width: 600 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":1429,"value":"

The most successful prints.

","pinned":false,"hidden":false,"mode":"html"},{"id":1371,"value":"You can see parts of the box and cylinder where the hypotenuses buckle after the nozzle strikes the zigzag of the previous layer, which is unavoidable without modifying the printer's hardware like the authors did in the paper.","pinned":false,"hidden":false,"mode":"md"},{"id":820,"value":"## Discussion and Future Work","pinned":false,"hidden":false,"mode":"md"},{"id":896,"value":"An underlying assumption of this interactive article is that, rather than mathematize and simulate everything, we are more interested in visualizing and rapidly deploying test prints. I have once again convinced myself that just getting a weird digital fabrication job to work _at all_ first is the first step before we can do fancier things with exploring the parameter space or understanding the effects of changing parameters in a more structured way.","pinned":false,"hidden":false,"mode":"md"},{"id":1474,"value":"However, because we're working with physical artifacts, the parameter space can be theoretically infinite. Alongside the box fan hack I featured above, I also found that inserting small Allen keys could help stabilize the wireframe as the nozzle inevitably crashed into it.","pinned":false,"hidden":false,"mode":"md"},{"id":1481,"value":"stabilize = FileAttachment(\"stabilize.jpg\").image({ width: 600 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":1505,"value":"

Motivation for modular machines: a box fan and Allen key hold-downs.

","pinned":false,"hidden":false,"mode":"html"},{"id":1479,"value":"To me, this altogether shows the importance of documenting one's process when experimenting with a novel digital fabrication workflow. Readers can actually run my code and reproduce what I did on the progrmaming side, but there's always more understanding that could be conveyed in code or even in prose and diagrams alone. Instead, I plan on continuing to find ways to better document these processes—either those from published works or my own.","pinned":false,"hidden":false,"mode":"md"},{"id":746,"value":"# Unsorted Code Below (Readers Beware!)","pinned":false,"hidden":false,"mode":"md"},{"id":75,"value":"mutable test = 2","pinned":true,"hidden":false,"mode":"ojs"},{"id":170,"value":"boxStl = FileAttachment(\"box@1.stl\")","pinned":false,"hidden":false,"mode":"ojs"},{"id":174,"value":"bottleStl = FileAttachment(\"bottle@1.stl\")","pinned":false,"hidden":false,"mode":"ojs"},{"id":178,"value":"bowlStl = FileAttachment(\"bowl@1.stl\")","pinned":false,"hidden":false,"mode":"ojs"},{"id":196,"value":"function loadStl(stl) {\n let loader = new STLLoader();\n return new Promise((resolve, reject) => {\n let resolveMeshFromGeometry = (geometry) => {\n let material = new THREE.MeshPhongMaterial({\n color: 0xff0000,\n side: THREE.DoubleSide,\n transparent: true,\n opacity: 0.85\n });\n let mesh = new THREE.Mesh(geometry, material);\n resolve(mesh);\n };\n stl.url().then((stlUrl) => {\n loader.load(\n stlUrl.trim(),\n resolveMeshFromGeometry,\n () => {},\n (errorMsg) => {\n reject(errorMsg);\n }\n );\n });\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":254,"value":"{\n modelVizSpace.scene.add(testMesh);\n testMesh.setRotationFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI);\n // testMesh.position.set(25, 0, 25);\n // testMesh.scale.set(0.5, 0.5, 0.5);\n modelVizSpace.threeRenderScene();\n invalidation.then((_) => {\n modelVizSpace.scene.remove(testMesh);\n });\n return testMesh.position;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":113,"value":"## Toolpath Generation","pinned":false,"hidden":false,"mode":"md"},{"id":663,"value":"function forceLayerClockwise(layer) {\n return layer.map((contour) => {\n if (contour.length < 3) {\n return contour;\n }\n });\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":667,"value":"downsampledContours.map((layer) => contourClockwise(layer[0]))","pinned":true,"hidden":false,"mode":"ojs"},{"id":341,"value":"basicSliceTp = sliceLayersToInsts(sliceLayersBasic).flat()","pinned":true,"hidden":false,"mode":"ojs"},{"id":1106,"value":"function offsetLayersToBed(layers, mesh) {\n let offX = -mesh.geometry.boundingBox.min.x + 20;\n let offY = mesh.geometry.boundingBox.max.y + 0.2;\n let offZ = -mesh.geometry.boundingBox.min.z + 20;\n let off = new THREE.Vector3(offX, offY, offZ);\n // let offset = 0;\n return layers.map((layer) => {\n return layer.map((contour) => {\n return contour.map((point) => {\n return point.clone().add(off);\n });\n });\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":505,"value":"### Wireframe Generation","pinned":false,"hidden":false,"mode":"md"},{"id":539,"value":"crCurve = new THREE.CatmullRomCurve3(sliceLayersWireframe[0][0])","pinned":true,"hidden":false,"mode":"ojs"},{"id":553,"value":"crCurve.getSpacedPoints(Math.ceil(numDivisions))","pinned":true,"hidden":false,"mode":"ojs"},{"id":557,"value":"unpositionedDownsampledContours = sliceLayersWireframe.map((layer) => {\n return layer\n .map((contour) => downsampleContour(contour))\n .filter((c) => c.length > 0)\n .map((contour) =>\n !contourClockwise(contour) ? [...contour].reverse() : contour\n );\n})","pinned":true,"hidden":false,"mode":"ojs"},{"id":1123,"value":"downsampledContours = offsetLayersToBed(\n unpositionedDownsampledContours,\n testMesh\n)","pinned":true,"hidden":false,"mode":"ojs"},{"id":588,"value":"downsampledTp = sliceLayersToInsts(downsampledContours)","pinned":true,"hidden":false,"mode":"ojs"},{"id":625,"value":"sampleZigZag = layerToZigZag(downsampledContours[0], downsampledContours[1])","pinned":true,"hidden":false,"mode":"ojs"},{"id":443,"value":"viewof lineThickness = Inputs.range([0.25, 3], {\n label: \"line thickness\",\n step: 0.25,\n value: 1\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":403,"value":"slicedTp = interleaved.slice(0, sliceEnd)","pinned":true,"hidden":false,"mode":"ojs"},{"id":361,"value":"populateVizSpace(tssVizSpace, [slicedTp])","pinned":true,"hidden":false,"mode":"ojs"},{"id":1282,"value":"populateVizSpace(sliceVizSpace, [basicSliceTp])","pinned":false,"hidden":false,"mode":"ojs"},{"id":377,"value":"$36","pinned":false,"hidden":false,"mode":"ojs"},{"id":133,"value":"$37","pinned":false,"hidden":false,"mode":"ojs"},{"id":134,"value":"$38","pinned":false,"hidden":false,"mode":"ojs"},{"id":136,"value":"function populateVizSpace(vizSpace, toolpaths) {\n if (!vizSpace || !vizSpace.removeAllViz) {\n return htl.html`⛔️ Could not find Visualization Space.`;\n }\n vizSpace.removeAllViz();\n let materialParams = {\n width: 12,\n height: 12,\n thickness: 2\n };\n toolpaths.forEach((toolpath, index) => {\n let tpGroup = VisualizationInterpreters.basicViz(toolpath, materialParams);\n vizSpace.addVizWithName(tpGroup, `toolpath ${index}`);\n });\n return htl.html`✨ Populated Visualization Space at ${new Date().toLocaleString()}.`;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":951,"value":"## Dispatch","pinned":false,"hidden":false,"mode":"md"},{"id":1142,"value":"downloadButton = (data, filename = \"toolpath.gcode\") => {\n // SOURCE: https://observablehq.com/@jeremiak/download-data-button\n if (!data) throw new Error(\"Array of data required as first argument\");\n\n let downloadData = new Blob([data], {\n type: \"application/text\"\n });\n\n const size = (downloadData.size / 1024).toFixed(0);\n const button = DOM.download(\n downloadData,\n filename,\n `Download ${filename} (~${size} KB)`\n );\n return button;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":7,"value":"## Taxon","pinned":false,"hidden":false,"mode":"md"},{"id":10,"value":"$39","pinned":false,"hidden":false,"mode":"ojs"},{"id":13,"value":"$3a","pinned":false,"hidden":false,"mode":"ojs"},{"id":16,"value":"$3b","pinned":false,"hidden":false,"mode":"ojs"},{"id":18,"value":"$3c","pinned":false,"hidden":false,"mode":"ojs"},{"id":20,"value":"$3d","pinned":false,"hidden":false,"mode":"ojs"},{"id":22,"value":"$3e","pinned":false,"hidden":false,"mode":"ojs"},{"id":24,"value":"$3f","pinned":false,"hidden":false,"mode":"ojs"},{"id":26,"value":"$40","pinned":false,"hidden":false,"mode":"ojs"},{"id":28,"value":"$41","pinned":false,"hidden":false,"mode":"ojs"},{"id":30,"value":"$42","pinned":false,"hidden":false,"mode":"ojs"},{"id":32,"value":"$43","pinned":false,"hidden":false,"mode":"ojs"},{"id":34,"value":"$44","pinned":false,"hidden":false,"mode":"ojs"},{"id":36,"value":"$45","pinned":false,"hidden":false,"mode":"ojs"},{"id":38,"value":"$46","pinned":false,"hidden":false,"mode":"ojs"},{"id":40,"value":"class RotaryStage {\n // TODO\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":42,"value":"$47","pinned":false,"hidden":false,"mode":"ojs"},{"id":44,"value":"$48","pinned":false,"hidden":false,"mode":"ojs"},{"id":46,"value":"$49","pinned":false,"hidden":false,"mode":"ojs"},{"id":48,"value":"$4a","pinned":false,"hidden":false,"mode":"ojs"},{"id":50,"value":"$4b","pinned":false,"hidden":false,"mode":"ojs"},{"id":52,"value":"$4c","pinned":false,"hidden":false,"mode":"ojs"},{"id":54,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs"},{"id":56,"value":"function generateControlDom() {\n return htl.html`\n\n

\n \n

\n \n \n

\n\n`;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":58,"value":"$4e","pinned":false,"hidden":false,"mode":"ojs"},{"id":60,"value":"$4f","pinned":false,"hidden":false,"mode":"ojs"},{"id":62,"value":"$50","pinned":false,"hidden":false,"mode":"ojs"},{"id":64,"value":"class WorkEnvelope extends Region {\n constructor(parentMetrics, weProg) {\n super(parentMetrics, weProg);\n this.name = \"WorkEnvelope\";\n this.componentType = \"WorkEnvelope\";\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":66,"value":"class EnvelopeRegion extends Region {\n constructor(parentMetrics, weProg) {\n super(parentMetrics, weProg);\n this.name = \"EnvelopeRegion\";\n this.componentType = \"EnvelopeRegion\";\n }\n\n renderDimensions() {\n let geom = this.calcGeometry(this.dimensions);\n let edgesGeom = new THREE.EdgesGeometry(geom);\n let material = new THREE.LineDashedMaterial({\n color: WorkEnvelope.color,\n linewidth: 1,\n scale: 1,\n dashSize: 3,\n gapSize: 3\n });\n this.mesh = new THREE.LineSegments(edgesGeom, material);\n this.mesh.computeLineDistances();\n this.mesh.isWorkEnvelopeMesh = true;\n this.meshGroup.blockName = this.name;\n this.meshGroup.add(this.mesh);\n this.geometries = [geom];\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":68,"value":"class MetricsCompiler {\n constructor() {}\n\n compile(prog, taxonScene) {\n let mObj = JSON.parse(prog);\n let metrics = new Metrics(taxonScene, mObj);\n return metrics;\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":131,"value":"## Utilities","pinned":false,"hidden":false,"mode":"md"},{"id":8,"value":"THREE = {\n const THREE = (window.THREE = await require(\"three@0.146.0/build/three.js\"));\n return THREE;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":143,"value":"$51","pinned":false,"hidden":false,"mode":"ojs"},{"id":144,"value":"$52","pinned":false,"hidden":false,"mode":"ojs"},{"id":146,"value":"$53","pinned":false,"hidden":false,"mode":"ojs"},{"id":149,"value":"$54","pinned":false,"hidden":false,"mode":"ojs"},{"id":151,"value":"$55","pinned":false,"hidden":false,"mode":"ojs"},{"id":153,"value":"$56","pinned":false,"hidden":false,"mode":"ojs"},{"id":155,"value":"Line2 = (function () {\n class Line2 extends LineSegments2 {\n constructor(\n geometry = new THREE.LineGeometry(),\n material = new THREE.LineMaterial({\n color: Math.random() * 0xffffff\n })\n ) {\n super(geometry, material);\n this.isLine2 = true;\n this.type = \"Line2\";\n }\n }\n\n return Line2;\n})()","pinned":false,"hidden":false,"mode":"ojs"},{"id":206,"value":"$57","pinned":false,"hidden":false,"mode":"ojs"},{"id":306,"value":"(THREE.Vector3.prototype.approxEqual = function (v) {\n const EPSILON = 0.001;\n return (\n Math.abs(v.x - this.x) <= EPSILON &&\n Math.abs(v.y - this.y) <= EPSILON &&\n Math.abs(v.z - this.z) <= EPSILON\n );\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":70,"value":"","pinned":false,"hidden":false,"mode":"html"},{"id":1217,"value":"import { textcolor } from \"@observablehq/text-color-annotations-in-markdown\"","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W58","stdlib":"1","titling":"auto"}