31:T542,Digital fabrication machines for makers have expanded access to manufacturing processes such as 3D printing, laser cutting, and milling. While digital models encode the data necessary for a machine to manufacture an object, understanding the trade-offs and limitations of the machines themselves is crucial for successful production. Yet, this knowledge is not codified and must be gained through experience, which limits both adoption of and creative exploration with digital fabrication tools. To formally represent machines, we present Taxon, a language that encodes a machine’s high-level characteristics, physical composition, and performable actions. With this programmatic foundation, makers can develop rules of thumb that filter for appropriate machines for a given job and verify that actions are feasible and safe. We integrate the language with a browser-based system for simulating and experimenting with machine workflows. The system lets makers engage with rules of thumb and enrich their understanding of machines. We evaluate Taxon by representing several machines from both common practice and digital fabrication research. We find that while Taxon does not exhaustively describe all machines, it provides a starting point for makers and HCI researchers to develop tools for reasoning about and making decisions with machines.32:T14c5,Digital fabrication machines, like 3D printers, laser cutters, CNC mills, drawing machines, and laboratory pipetting machines allow a broadening base of users to program machines to create and modify physical objects. An extensive infrastructure of software and machine tools along with increasing research in human-computer interaction have unlocked more possibilities for making. Research in digital fabrication has contributed novel machines and computational pipelines for creating objects with machines. Practitioners have also expanded the use of precision machines to new applications, such as ceramics, engineering education, and even fabricating personal protective equipment for hospitals in a crisis. In all of these contexts, understanding how a machine works, the high-level pros and cons of a machine, and how to integrate the machine with digital and physical materials are crucial for selecting and using a machine safely and appropriately. While most industrial and academic work focuses on new possibilities for making through digital fabrication, we still lack of common infrastructure for formally representing a machine and its capabilities. Knowing which machine is best-suited to a manufacturing task is often learned by trial and error. Many novice and would-be users of digital fabrication tools encounter a considerable learning curve when faced with fundamental questions that many expert users take for granted, namely: How does the machine work? Which machine is right for the job? How do we integrate a machine into a manufacturing process with digital and physical materials? The open challenge is how to empower a diverse set of fabrication machine users to achieve their manufacturing goals amidst a piecemeal ecosystem of fabrication software, hardware, and domain expertise. In recent years, desktop-class digital fabrication machines are gaining in popularity, with feature-heavy variants and sophisticated manufacturing workflows frequently introduced. Beyond increasing educational resources, we argue that digital fabrication needs a unifying formal representation of what a machine is. We argue that a programming language for machines would most effectively help makers adapt to an increasingly complex space of manufacturing workflows. Compared to one-off software tools, programming languages lend themselves to being extended as programmers develop libraries and share repositories of code. A common syntax and semantics let makers more readily understand features and trade-offs between different machines, as well as use program analysis techniques to enforce best practices. While it might seem tempting to create a simple how-to guide to selecting and using machines, one can never fully anticipate how a maker might want to chose machines based on their own. Instead, we aim to let makers author their own rules of thumb for selection and usage that can selectively be applied to machines-as-programs. As a first step towards a common enabling infrastructure, we present Taxon, a language for specifying a digital fabrication machine's composition, characteristics, and simulated use cases as programs. Taxon helps users to gather a large repository of machines in a common format, query and compare different machines, and script simulated interactions with machines, digital models, and physical materials. Taxon programs contain three parts: *blocks* and *metrics*, which together form the machine plan, and the *workflow* composed of a sequence of *actions*. Blocks are abstracted black boxes of machine parts that provide enough information to reason about the machine's kinematic and mechanical properties without being prohibitively low-level or verbose. Metrics describe innate characteristics of a machine that determine when it should and should not be used. Workflows comprise actions that simulate a machine's movements and interactions with material. Makers can also author and enforce *rules of thumb*, which are user-defined checks that Taxon enforces about machine selection and use. We integrate the Taxon language into a web-based user interface that lets users search for machines based on their needs, learn the machine's composition and kinematics, and experiment with using the machine in simulation before moving on to using a physical machine. Overall, Taxon is *descriptive*, i.e., characterizing existing machines and workflows, rather than prescriptive of a single fabrication pipeline. Through the language and web interface, we allow development of an interactive and extensible taxonomy of digital fabrication machines along with a foundation upon which future applications can reason precisely about a machine. This paper's contributions include: - **A domain-specific language** for formally representing digital fabrication machine plans and workflows - **A user interface** that lets users contribute to and browse a machine database and experiment with workflows - **Several examples of novel fabrication workflows** from research and practice expressed in Taxon While material choices and digital models are important parts of workflows, in this paper we focus primarily on representing machines and rules for their use, which in turn provides a foundation for future extensions for materials and models.33:T5c4,

System Architecture

The system we propose has the following design goals:

To represent a breadth of digital fabrication machines in one standardized format
To formalize a machine’s high-level characteristics and trade-offs and when/when not to use it
To formalize how a machine moves, how it works with models and materials, and how to incorporate this information into a desired workflow

To address these goals, we implement¹ the Taxon language to (1) represent high-level features, constraints, and composition of machines, and (2) help users compare and simulate basic machine tasks. A Taxon program consists of a machine-plan and a workflow :

Machine Plan: describes the composition of the machine from a functional level and contains two parts:

Metrics: a collection of various high-level properties (metrics) about a machine, such as which materials the machine can use and structural considerations of a machine for fabricating certain types of models
Blocks: a collection of abstracting bounding boxes for functional parts of a machine—each known as a block—where each block represents volumetric and kinematic properties the given region of the machine

34:T514,

The core of Taxon is its representation of machines as a group of bounding boxes called blocks. A block is an abstraction of subassemblies of physical machines. Each block encodes information about the machine’s physical size, kinematics, and tool functionality. The goal of the blocks part of a machine plan is to provide one standard representation for many different types of digital fabrication machines; this allows us to access a diverse range of machines in one programmatic representation.

Blocks are JSON objects that are rendered as block-shaped bounding boxes in the scene. Conceptually, a block represents one functional moving unit of a machine. For example, the Prusa i3 3D printer example shown in [fig:ui] is divided into three blocks each representing one axis of movement, and additional blocks for its build plate and extruder. The organization of a machine is hierarchical in that blocks have connections to their children, and connections are one-directional and parent-child. For example, in many 3D printers, the filament extruder is attached to a timing belt; in Taxon parlance, we say that the belt connects to the extruder, and the extruder is the belt’s child.

35:T63f,machinePlanDemo = JSON.stringify({ name: "block-demo", metrics: { workEnvelope: { shape: "rectangle", dimensions: { height: 110, length: 130 }, position: { x: -47.5, y: 102.6, z: 0 } } }, blocks: [ { name: "crossbarAssembly", blockType: "linear", actuationAxes: ["z"], dimensions: { width: 12.5, height: 25, length: 170 }, attributes: { driveType: "timingBelt", stepDisplacementRatio: 0.5 }, connections: [ { child: "extruder", isInert: false, offset: { x: 17.5, y: 0, z: 0 } } ] }, { name: "verticalDoubleLeadScrewFrame", blockType: "parallel", actuationAxes: ["y"], dimensions: { width: 20, height: 150, length: 170 }, position: { x: 0, y: 87.5, z: 0 }, attributes: { driveType: "leadscrew", stepDisplacementRatio: 0.5 }, connections: [ { child: "crossbarAssembly", isInert: false, offset: { x: 16.25, y: 27.5, z: 0 } } ] }, { name: "extruder", blockType: "nonActuating", isTool: true, dimensions: { width: 25, height: 25, length: 25 }, attributes: { toolType: "print3d", nozzleCount: 1 } } ] })36:Tcfa,

Block Syntax

Blocks both present information (e.g. the volume of various parts of the machine) and model how the machine moves in space. We define moving to mean that the position of a block changes; we define actuating to mean that an actuating block does not move, but all of its descendent blocks move on the actuating block’s actuatingAxes (see [fig:actuation]). Note that the y-axis is the “up” direction in our convention. All blocks contain a dimensions field denoting the size of its bounding box, while a block’s position is coordinates of the box’s centroid. A block’s position is defined explicitly through the position property or implicitly, where the block is a child to another block and its position snaps to its parent.

Each block has a blockType depending on the type of actuation it supports and the number of motors it contains. The bounding box of a block is assumed to contain the motors which e.g., step (turn a fixed angular amount) to drive its actuation. For example, the most common type of block is a linear block which is driven by one underlying stepper motor and has exactly one actuation axis; a linear block provides one degree of freedom of movement. Examples of linear blocks include each of the actuating blocks in the Prusa 3D printer machine plan. In contrast, a cross block represents a more complex assembly with parallel kinematics, where multiple underlying motors interdependently control multiple axes. Examples of cross blocks include the block representing the XZ axes in the Jubilee machine plan, which are driven by CoreXY kinematics . Redundant linear blocks are driven by more than one motor but move in a single degree of freedom; such blocks typically represent linear synchronous motion, for example, the two vertical lead screws on the Prusa 3D printer. Not all blocks actuate. An example of such a non-actuating block is the build plate of a 3D printer; while the build plate itself moves, it neither actuates nor provides additional movement to any other blocks. Finally, a tool is a special class of block whose movement can change the scene—for example, extruding 3D printer filament, carving material out of stock, or picking and placing an object. A block is designated as a tool by setting “isTool”: true.

Blocks may also have attributes, which contain block-specific information. Example attributes include driveType, which specifies the physical mechanism used to provide motion, e.g. rack and pinion or timing belt, stepDisplacementRatio, which states how much linear displacement along the actuation axes results from one step (the minimum amount of rotation) of the driving motor, and isPlatform, indicating that the block is a moving platform holds a model or workpiece. This field is useful particularly for tools because they may have different properties which may be difficult to generalize over all types of tools.

37:Te5a,

We already noted that a machine plan includes both functional blocks of a machine and the metrics that describe the machine’s high-level characteristics. In addition to representing the machines, Taxon helps users make the simulated machine do things by composing workflows. In digital fabrication, a workflow consists of a series of steps that progress from models, materials, and machine to finished product. In Taxon, these workflows are implemented programatically as a sequence of statements called actions, which let users simulate motion in the scene and load materials and digital models into the scene. Intuitively, an action is one “step” of the workflow, which could include anything from testing small perturbations to identify how the machine moves to programming a broad-strokes plan of the entire physical workflow from raw material to finished product. By expressing machine movements and model and material concerns in code, we expose opportunities for users to learn and error-check in simulation before they work with dangerous or expensive physical machines and materials.

Actions are a strict subset of Javascript, where programs are composed of multiple statements (also called actions) that are separated by semicolons. The action interpreter executes one statement at a time as programmers step through the workflow, and each action modifies the scene’s state, which consists of the machine’s blocks, their current positions, models and toolpaths uploaded by users, and any material extruded, placed, or cut. Each statement contains exactly one selector that is followed by any number of methods. The selector evaluates to an object that then supports a set of methods depending on the object’s type. Executing a method modifies the scene’s state, for example, by turning motors and moving blocks around, by transforming the model’s geometry, or by cutting or extruding material. For example, $machine() evaluates to a Machine object that supports methods like .moveTo(coordinates, extrusion), which actuates all machines blocks so the tool arrives at the desired (x,y,z) coordinate, possibly extruding material while moving; $t(’penAssembly’) evaluates to a Tool object that supports methods like .raisePen() and .lowerPen(). Before and during runtime, the machine action interpreter checks statements against the rules of thumb and highlights any rule violations, for example, moving a block past an acceptable value.

In addition to controlling the machine, actions let makers load materials and digital models into the scene. Like blocks, materials are represented by a bounding box that is placed in the scene (see Section Example: Hot Wire Cutter). Each material must have a material class, which can be additive, i.e., it is deposited in the scene by actions with additive machines, or subtractive, i.e., makers must place the material first and then process it using tool actions. Materials also have names, e.g., “wood” or “plastic,” which are typically listed in a machine’s materialCompatibility metric. This high-level description of materials suffices for high-level simulations. Actions also support uploading digital files (e.g., STL files) and placing them in the scene. Taxon’s modular design affords easy extensions to the language for slicing STL files into tool paths and processing geometry; we leave these for future work.

38:T6cd,

Hot wire cutters work by heating a suspended wire with an applied voltage and then moving the wire through a work piece of styrofoam, which cuts the material by melting it. In this example we model a typical CNC (Computer Numerical Controlled) hot wire cutter topology with two degrees of freedom, namely, vertical and horizontal wire movement. We observed that both redundant linear blocks consume significant space for their bounding boxes that, in reality, are empty space where the tool (the wire) and the workpiece would go. In the hot wire cutter’s implementation, blocks in this machine readily intersect with one another. Assume we want to create rules of thumb that distinguish between an intersection that is physically harmless versus an intersection where machine parts are actually crashing into one another. A “harmless” intersection in this case is how the foam work piece’s volume might intersect with the vertical machine block’s empty space. An unacceptable intersection occurs when the work piece intersects with the vertical block’s solid parts. To this end, we implemented the notion of a void, an optional property that can be added to a block’s attributes property. A void is a bounding box that fits in the block’s bounding box that represents empty space within the block. As a result, we can be confident that other blocks intersecting with a block in its void will not cause a collision. We implemented a rule of thumb to check that a machine does not collide with itself, referencing blocks and voids. Though this rule is not strictly necessary for the hot wire cutter, it would likely be useful for more complex machines and workflows where collisions are more likely to happen.

39:T694,machinePlanHwc = JSON.stringify({ name: "hot wire cutter (2dof)", metrics: { workEnvelope: { shape: "rectangle", dimensions: { width: 400, height: 175, length: 0 }, position: { x: 0, y: 112.5, z: 0 } }, manufacturingStrategies: ["subtractive"], materialCompatibility: { include: ["foam"], exclude: ["wood", "metal", "plastic", "paper"] } }, blocks: [ { name: "doubleLeadscrewPlatform", blockType: "redundantLinear", actuationAxes: ["x"], dimensions: { width: 400, height: 25, length: 300 }, void: { width: 200, height: 25, length: 400 }, position: { x: 0, y: 12.5, z: 0 }, connections: [ { child: "verticalWireHolder", offset: { x: -187.5, y: -112.5, z: 0 } } ] }, { name: "verticalWireHolder", blockType: "redundantLinear", actuationAxes: ["y"], dimensions: { width: 25, height: 200, length: 300 }, void: { width: 25, height: 200, length: 200 }, connections: [ { child: "wire", offset: { x: 0, y: 95, z: 0 } } ] }, { name: "wire", blockType: "nonActuating", isTool: true, dimensions: { width: 5, height: 5, length: 200 }, attributes: { toolType: "wire" } } ] })3a:T9ab,

We implemented a Delta Wasp 2040 Clay 3D printer and an example workflow for it that 3D prints a vase out of clay . This printer uses delta bot kinematics, which feature three levers connected with revolute joints to a rigid body. The end of each lever that is not fixed to the rigid body moves independently via a drive mechanism, and the position of the levers’ ends determines the location of the rigid body. As a result, the rigid body has three Degrees of Freedom (DOF) and depends on three or more motors to drive the levers, which exceeds the linear (1 DOF) and cross (2 DOF) blocks that we have thus far implemented. Therefore, we implemented a 3DOF DeltaBotBlock that encompasses the majority of the printer; in fact, the printer’s machine plan has only three blocks: the delta bot block, the tool, and an immobile platform. One feature of delta bot kinematics is a cylindrical work envelope as opposed to a box-shaped one, which we implemented as well.

In addition to the delta bot block and the cylindrical work envelope, we could not feasibly address other important features in the Wasp printer with the current level of abstraction in Taxon. In formative interviews with makers, we learned that a key challenge in 3D printing with clay comes from the material properties of clay itself. In all such 3D printers, the clay must be packed into a container tube and forced evenly through the nozzle. The Wasp printer uses an external compressed air source along with a rotating auger for this. Unlike the plug-and-play nature of plastic 3D printer filament, here the maker must mix their own clay and find the right consistency: too watery and the extruded material may collapse, or too thick and the clay will extrude unevenly. One ceramicist noted that she knew from her own experience with clay what an ideal consistency felt like, how to vary it based on the type of print she was attempting, and when and when not to manually intervene during a print to reshape features by hand. To codify this sort of tacit knowledge, Taxon would need to support materials with enough detail to do basic physics simulation, and, even then, such rules of thumb based on the material properties of clay would be “ballpark” estimates at best. We decided that this level of physics-based material representation is beyond the current scope of Taxon but would be fruitful future work.

3b:T77e,machinePlanClay = JSON.stringify({ name: "wasp 2040 clay 3D printer", metrics: { workEnvelope: { shape: "cylinder", dimensions: { radius: 100, height: 400 }, position: { x: 0, y: 205, z: 0 } }, manufacturingStrategies: ["additive"], materialCompatibility: { include: ["clay", "gres", "porcelain"], exclude: ["wood", "metal", "plastic", "paper"] }, metafeatures: { version: 2, machineType: "printer3d", vendorInfo: { price: 3000, website: "https://www.3dwasp.com/en/clay-3d-printer-delta-wasp-2040-clay/", numUsers: 1000 } } }, blocks: [ { name: "immobileClayBuildPlate", blockType: "nonActuating", dimensions: { width: 300, height: 25, length: 300 }, attributes: { isPlatform: true, isImmobile: true }, position: { x: 0, y: 5, z: 0 } }, { name: "railAndBearingVerticalDeltaBotAssembly", blockType: "deltaBot", actuationAxes: ["x", "y", "z"], dimensions: { width: 490, height: 870, length: 440 }, position: { x: 0, y: 435, z: 0 }, attributes: { driveType: "timingBelt", stepDisplacementRatio: "0.7" }, connections: [ { child: "augerAndExtruderAssembly", offset: { x: 0, y: 375, z: 0 } } ] }, { name: "augerAndExtruderAssembly", blockType: "nonActuating", isTool: true, dimensions: { width: 50, height: 100, length: 50 }, attributes: { toolType: "print3d", nozzleCount: 1, minCompressionKPa: 800 } } ] })3c:Td79,

We implemented the Liteplacer pick and place machine, an open source, do-it-yourself machine kit created by Juha Kuusama . This machine picks up SMD components for printed circuit boards and places them precisely within the components’ respective footprints on the PCB board itself. The machine receives as input locations of the footprints on the PCB and uses a camera-based localization routine to zero itself and calculate trajectories for moving components from the supply region to the footprints.

This is a relatively complex machine and workflow. For the machine plan, we implemented the machine to use two linear blocks for both the lower assembly, which moves along the x axis, and the crossbar assembly, which moves on the z axis. The tool assembly was more complicated to model, consisting of a linear block that moves on the y axis, a rotary block that rotates any PCBs that are currently picked up, and several suction-cup-tipped needles for actually picking up the SMD components. We chose not to implement rotary blocks for now because rotational motion complicates our model of machine motion; it would require us to solve general-case inverse kinematics rather than the simpler cases with only linear motion. Instead, we focused on the machine’s tool changing feature and on correct tool usage.

Given our definition of a tool block as the block that interfaces with material, we designated only the needles as tools; this means that needle blocks are marked as “isTool”: true and support tool-based methods when selected in actions. There are several sizes of needle for picking up different types of SMD components and we named each needle after the size of component it can pick up, i.e., 0402, 0603, and SOIC-8. These needles are parked in a needle holder in the work envelope, and the machine must perform a tool changing operation to attach the needle of the correct size before picking up components of that size. Typically, programmers must manually program these tool changing routines either in raw G-Code or in whatever convention the program controlling the pick and place machine’s control board uses, which is prone to errors.

In this light, a goal of Taxon is to codify best practices—here, ensuring that the correct needle is attached before attempting to pick up an SMD component. Enforcing this logic necessitated the creation of a new feature, envelope regions, which lets the programmer designate and label subspaces within the work envelope. Similar to a work envelope itself, an envelope region can be specified as a box that checks for inclusion within the region based on x, y, and z coordinates or as a rectangle that checks only two coordinates. We created a rectangle XZ region where each needle is parked, a region in which to place stock SMD components corresponding to each size of needle, and a region in which to place the PCB itself. An automated tool changing routine would involves traveling to the region for parking the current tool, having the machine deposit the current tool, traveling to the region to park the new tool, and then attaching it to the tool holding assembly. We then implemented an action rule of thumb stating that before a tool can enter a region for stock SMD components, it must have the correctly sized needle currently attached.

3d:T1209,machinePlanPnp = JSON.stringify({ name: "pcb pick and place", metrics: { workEnvelope: { shape: "rectangle", dimensions: { width: 570, height: 0, length: 370 }, position: { x: 0, y: 0, z: 0 } }, envelopeRegions: { "0402": { shape: "rectangle", dimensions: { width: 50, height: 0, length: 50 }, position: { x: 200, y: 0, z: -100 } }, "0603": { shape: "rectangle", dimensions: { width: 50, height: 0, length: 50 }, position: { x: 200, y: 0, z: 0 } }, SOIC: { shape: "rectangle", dimensions: { width: 50, height: 0, length: 50 }, position: { x: 200, y: 0, z: 100 } } }, footprint: { width: 1000, length: 650 }, manufacturingStrategies: ["nonManufacturing"], materialCompatibility: { include: ["pcb"], exclude: ["wood", "metal", "plastic", "clay", "paper"] }, metafeatures: { version: 2, machineType: "pickAndPlace", vendorInfo: { price: 1799, website: "https://liteplacer.com/", numUsers: 5000 } } }, blocks: [ { name: "doubleRailLowerWithAxle", blockType: "linear", actuationAxes: ["x"], dimensions: { width: 920, height: 180, length: 540 }, position: { x: 0, y: 90, z: 0 }, attributes: { driveType: "timingBelt", stepDisplacementRatio: 0.5 }, connections: [ { child: "crossbarAssembly", offset: { x: 0, y: -135, z: 0 } } ] }, { name: "crossbarAssembly", blockType: "linear", actuationAxes: ["z"], dimensions: { width: 90, height: 90, length: 540 }, attributes: { driveType: "timingBelt", stepDisplacementRatio: 0.5 }, connections: [ { child: "gantryAssembly", offset: { x: 22.5, y: -45, z: 0 } } ] }, { name: "gantryAssembly", blockType: "binary", actuationAxes: ["y"], dimensions: { width: 135, height: 180, length: 90 }, attributes: { driveType: "timingBelt", stepDisplacementRatio: 0.5 }, connections: [ { child: "pickAndPlaceHead", offset: { x: 90, y: 50, z: 0 } } ] }, { name: "pickAndPlaceHead", blockType: "nonActuating", dimensions: { width: 45, height: 135, length: 90 }, attributes: {}, connections: [ { child: "needleHolder", offset: { x: 0, y: 55, z: 0 } } ] }, { name: "needleHolder", isTool: true, blockType: "nonActuating", attributes: { toolType: "pnpHolder" }, dimensions: { width: 10, height: 135, length: 10 }, connections: [ { child: "needle0402", offset: { x: 0, y: 115, z: 0 } } ] }, { name: "needle0402", isTool: true, blockType: "nonActuating", attributes: { toolType: "needle", pcbSize: "0402", equipped: true }, dimensions: { width: 10, height: 100, length: 10 } }, { name: "needle0603", isTool: true, blockType: "nonActuating", attributes: { toolType: "needle", pcbSize: "0603" }, dimensions: { width: 10, height: 100, length: 10 }, position: { x: -200, y: 50, z: 0 } }, { name: "needleSOIC", isTool: true, blockType: "nonActuating", attributes: { toolType: "needle", pcbSize: "0603" }, dimensions: { width: 10, height: 100, length: 10 }, position: { x: -200, y: 50, z: 15 } } ] })3e:Tbf8,

Limitations

While implementing the six demonstration programs for the evaluation, we encountered several limitations. First, simulating a workflow often requires us to reason about how a material will react when acted upon by the machine. For example, in the case of the hot wire cutter, having the wire pass through a styrofoam workpiece put foam in the path of the wire. Or, for the clay 3D printer, the consistency of the clay greatly affects its behavior when deposited by the extruder. However, modeling the physical behavior of material—even in a greatly simplified setting—remains challenging. Because material properties always affect the semantics of actions, they must be implemented in the core Taxon language, as opposed to being added in a modular fashion using rules of thumb. The need to incorporate more physics into Taxon than we initially anticipated created a bottleneck that we must address before more workflows can be fully represented in code.

In addition, nontrivial geometry processing is not yet implemented in Taxon. For the evaluation, we attempted to replicate the workflow proposed in a paper by Teibrich et al., which features a machine that can patch existing 3D printed objects by removing material with a mill and then reprinting new material with an 3D printer extruder . These subroutines depend on access to the 3D model, the tool path, and robust software for detecting collisions. While it is possible to implement these subroutines as rules of thumb, such as “avoid collisions by milling material that blocks access” and “rotate the build plate to minimize milled material”, we would need to add substantial geometry processing to implement such collision detection and optimization programatically. Currently in Taxon, we can reason only about collision with bounding boxes, not with the precise geometry of the work piece. We defer such features to an extension in future work.

Finally, the codifiable space of possible concerns in digital fabrication is vast; Taxon can address only a small subspace of these concerns in its current form. In this initial implementation, we intended to codify concerns that would present the highest barrier to novices, namely, the capabilities of each machine from a high level, a machine’s composition, and its basic action, e.g., “extrude” versus “cut.” Many lower level concerns, such as software-supported bed leveling or smoother motor movement through microstepping, are difficult to represent. However, a key benefit of designing a new programming language is that we can organize these concerns into various levels of abstraction. For example, higher levels of abstraction could abstract away details like extrusion rate, whereas lower level ones could let programmers add detailed information about machine parts in the blocks. We envision creating this stack of abstractions to be a crucial next step for expanding the language going forward.

3f:Ta9b,machinePlanPrusa = JSON.stringify({ name: "prusa-i3-mk3", metrics: { workEnvelope: { shape: "box", dimensions: { width: 130, height: 110, length: 130 }, position: { x: 0, y: 102.6, z: 0 } }, manufacturingStrategies: ["additive"], materialCompatibility: { include: ["plastic"], exclude: ["wood", "metal"] }, metafeatures: { version: 2.0, machineType: "printer3d", vendorInfo: { price: 749, website: "https://www.prusa3d.com/", numUsers: 5000 } } }, blocks: [ { name: "build plate", blockType: "nonActuating", dimensions: { length: 130, width: 130, height: 10 }, attributes: { isPlatform: true } }, { name: "platform belt", blockType: "linear", invertDisplacement: true, actuationAxes: ["x"], dimensions: { width: 165, height: 25, length: 25 }, position: { x: 0, y: 25, z: 0 }, attributes: { driveType: "timingBelt", stepDisplacementRatio: 0.7 }, connections: [ { child: "build plate", offset: { x: 0, y: -17.5, z: 0 } } ] }, { name: "crossbarAssembly", blockType: "linear", actuationAxes: ["z"], dimensions: { width: 12.5, height: 25, length: 170 }, attributes: { driveType: "timingBelt", stepDisplacementRatio: 0.5 }, connections: [ { child: "extruder", isInert: false, offset: { x: 17.5, y: 0, z: 0 } } ] }, { name: "verticalDoubleLeadScrewFrame", blockType: "parallel", actuationAxes: ["y"], dimensions: { width: 20, height: 150, length: 170 }, position: { x: 0, y: 87.5, z: 0 }, attributes: { driveType: "leadscrew", stepDisplacementRatio: 0.5 }, connections: [ { child: "crossbarAssembly", isInert: false, offset: { x: 16.25, y: 27.5, z: 0 } } ] }, { name: "extruder", blockType: "nonActuating", isTool: true, dimensions: { width: 25, height: 25, length: 25 }, attributes: { toolType: "print3d", nozzleCount: 1 } } ] })40: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; } }41: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; } }42: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 ); } } }43: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 }; } }44: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(); } }45: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]; } }46: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; } }47: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); } }48: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); } }49: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(); } }4a: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 ); } }4b: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 ); } }4c: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(); } }4d: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); } } }4e: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(); } }4f: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); }); } }50: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); } } }51: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; } }52: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; }; } }53: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); } }54: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); } }55: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); }); }56: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); }); } } }57: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 ); } } }58:[{"id":"39533b2392f3e9a18733a50b7706bca63250fab5556bbbe504230cf0703cbc6b412495c0f8e59819b865f79c8ac81a95dce404f46629f7c04d9e4f445d47c12a","href":"https://static.observableusercontent.com/files/39533b2392f3e9a18733a50b7706bca63250fab5556bbbe504230cf0703cbc6b412495c0f8e59819b865f79c8ac81a95dce404f46629f7c04d9e4f445d47c12a","name":"aug-taxon-sysarch.png","type":"image/png","lastModified":1666053921634.02,"size":71130},{"id":"54893eb899ee512f47eb24992e783e494bf0330aabc463e46787105a97f6a5b7407c69fd544054b51ac286253127013452e5883cf129a0236a1b039cfa1bf18b","href":"https://static.observableusercontent.com/files/54893eb899ee512f47eb24992e783e494bf0330aabc463e46787105a97f6a5b7407c69fd544054b51ac286253127013452e5883cf129a0236a1b039cfa1bf18b","name":"wasp-printer.png","type":"image/png","lastModified":1666072628245.708,"size":211494},{"id":"6ebb991034a2208dd88cb4ba58e515a51b85c89ea1f282a297f421e7903a1e2234292b952ca28bd8f5b9171cc469baf416609bd8f8850548abb73a851205abe1","href":"https://static.observableusercontent.com/files/6ebb991034a2208dd88cb4ba58e515a51b85c89ea1f282a297f421e7903a1e2234292b952ca28bd8f5b9171cc469baf416609bd8f8850548abb73a851205abe1","name":"lightplacer.jpg","type":"image/jpeg","lastModified":1666074334902.492,"size":143104},{"id":"7cf4b35fad0952aee0f000b8ed23b4c2de595fca668848a02ef5322556dd329aafcc7d01ae40082fcb84b9a1777d77e8772661d511cdd12257ab0a23301264e6","href":"https://static.observableusercontent.com/files/7cf4b35fad0952aee0f000b8ed23b4c2de595fca668848a02ef5322556dd329aafcc7d01ae40082fcb84b9a1777d77e8772661d511cdd12257ab0a23301264e6","name":"aug-taxon-teaser.png","type":"image/png","lastModified":1666046440177.942,"size":230861}] 2f:{"title":"An Augmented Sample of Taxon: a Language for Formal Reasoning with Digital Fabrication Machines","cells":[{"id":0,"value":"# An Augmented Sample of _Taxon: a Language for Formal Reasoning with Digital Fabrication Machines_","pinned":false,"hidden":false,"mode":"md"},{"id":580,"value":"Jasper Tran O'Leary","pinned":false,"hidden":false,"mode":"md"},{"id":337,"value":"_This article represents a subset of the [original Taxon paper](https://www.semanticscholar.org/paper/Taxon%3A-a-Language-for-Formal-Reasoning-with-Digital-O'Leary-Nandi/8e40425eafbe662bab7f054433774500a12d8e68) with the parts of Taxon system **brought in to the paper** as much as possible._\n\n_Note: currently the Taxon cells leak memory when recomputed and I haven't had a chance to debug it yet. For now, if the notebook starts slowing down, copy the URL, close the tab, and re-open in another tab._","pinned":false,"hidden":false,"mode":"md"},{"id":314,"value":"augTaxonTeaser = FileAttachment(\"aug-taxon-teaser.png\").image({ width: 750 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":383,"value":"

Taxon Concept. The Taxon language can represent a breadth of digital fabrication machines as programs that compile to abstracted machine simulations. Shown are Taxon implementations of A. Prusa i3-mk3, B. Ultimaker S5, C. Makerbot Method, D. Delta WASP 2040 Clay printer, E. hot wire cutter, F. xPrint modular liquid printer, and G. LitePlacer pick and place machine.

","pinned":false,"hidden":false,"mode":"html"},{"id":6,"value":"## Abstract","pinned":false,"hidden":false,"mode":"md"},{"id":7,"value":"$31","pinned":false,"hidden":false,"mode":"md"},{"id":11,"value":"## Introduction","pinned":false,"hidden":false,"mode":"md"},{"id":13,"value":"$32","pinned":false,"hidden":false,"mode":"md"},{"id":390,"value":"augTaxonSysarch = FileAttachment(\"aug-taxon-sysarch.png\").image({ width: 700 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":388,"value":"

System Architecture. Makers represent a physical machine as a Taxon\nMachine Plan program. The program contains: blocks, which\nprovide an abstracted composition of the machine; and metrics,\nwhich describe high-level machine characteristics, such as the volume\nthat its tool can access (work envelope) and material compatibility.\nTaxon Machine Plans can be used in workflows containing\nactions, which simulate motion and fabrication. Rules of\nthumb are a database of community-contributed rules that can be\nused when analyzing machine plans and actions for appropriate machine\nchoice for a manufacturing task or safety of actions. Executing an\naction updates the machine in the simulation, here, actuating the blocks\nsuch that the print head (in red) moves to the directed position.

","pinned":false,"hidden":false,"mode":"html"},{"id":320,"value":"$33","pinned":false,"hidden":false,"mode":"html"},{"id":399,"value":"

Machine Workflow: composed of\nactions—statements that are executed by the Taxon interpreter\nwhich is specialized for the current machine plan.\nActions are valid Javascript statements and are a strict subset of\nJavascript. Actions simulate various tasks with part or all of the\nmachine, with materials, and with uploaded 2D and 3D models to both\nvisualize the machine and to check for potential errors using codified\nrules of thumb. Rules of thumb are user-selected static and\nrun-time checks that filter machines (filtering rules of thumb)\nand raise warnings for actions that are risky or incompatible with a\ngiven machine (action rules of thumb).

","pinned":false,"hidden":false,"mode":"html"},{"id":443,"value":"## Machine Plan: Blocks","pinned":false,"hidden":false,"mode":"md"},{"id":456,"value":"$34","pinned":false,"hidden":false,"mode":"html"},{"id":459,"value":"demoScene = generateTaxonScene(machinePlanDemo, false)","pinned":false,"hidden":false,"mode":"ojs"},{"id":471,"value":"$35","pinned":false,"hidden":false,"mode":"ojs"},{"id":585,"value":"

Demonstration of a simple machine plan above rendered in Taxon. Expand the cell above to see the full text of the machine plan.

","pinned":false,"hidden":false,"mode":"html"},{"id":463,"value":"$36","pinned":false,"hidden":false,"mode":"html"},{"id":446,"value":"## Machine Plan: Metrics\n\n_Omitted for now_","pinned":false,"hidden":false,"mode":"md"},{"id":448,"value":"## Workflows","pinned":false,"hidden":false,"mode":"md"},{"id":645,"value":"$37","pinned":false,"hidden":false,"mode":"html"},{"id":674,"value":"

Below: the same demo machine plan plus a workflow. Be sure to check \"Enable animation\" before stepping through the workflow and uncheck if after you you are finished to avoid unnecessary rendering.

","pinned":false,"hidden":false,"mode":"html"},{"id":656,"value":"viewof demoScene2 = generateTaxonScene(machinePlanDemo, enableAnimationDemo)","pinned":false,"hidden":false,"mode":"ojs"},{"id":666,"value":"viewof enableAnimationDemo = Inputs.toggle({\n label: \"Enable Animation\",\n value: false\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":662,"value":"viewof demoControl = {\n let dom = generateControlDom();\n loadTextIntoWorkflowDom(workflowDemoText, dom);\n let workflow = new Workflow(dom, demoScene2);\n dom.value = workflow;\n return dom;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":664,"value":"workflowDemoText = `\n$b('verticalDoubleLeadScrewFrame').actuate(20);\n$b('crossbarAssembly').actuate(20);\n$machine().zero();\n$machine().moveTo({y: 20, z: 20});`","pinned":false,"hidden":false,"mode":"ojs"},{"id":440,"value":"## Rules of Thumb\n\n_Omitted for now._","pinned":false,"hidden":false,"mode":"md"},{"id":565,"value":"## Example: Hot Wire Cutter","pinned":false,"hidden":false,"mode":"md"},{"id":563,"value":"","pinned":false,"hidden":false,"mode":"html"},{"id":567,"value":"

Demonstration of one of the authors using a hot wire cutter built of modular machine parts to cut a styrofoam airfoil.

","pinned":false,"hidden":false,"mode":"html"},{"id":350,"value":"$38","pinned":false,"hidden":false,"mode":"html"},{"id":508,"value":"viewof sceneHwc = generateTaxonScene(machinePlanHwc, enableAnimationHwc)","pinned":false,"hidden":false,"mode":"ojs"},{"id":533,"value":"viewof enableAnimationHwc = Inputs.toggle({\n label: \"Enable Animation\",\n value: false\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":521,"value":"viewof hwcControl = {\n let dom = generateControlDom();\n loadTextIntoWorkflowDom(workflowHwcText, dom);\n let workflowHwc = new Workflow(dom, sceneHwc);\n dom.value = workflowHwc;\n return dom;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":510,"value":"$39","pinned":false,"hidden":false,"mode":"ojs"},{"id":517,"value":"workflowHwcText = `\n$material('foam').makeBox(100, 100, 100);\n$machine().zero();\n$machine().moveTo({x: -300, y: 25, z: 0});\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":589,"value":"## Example: Printing with Clay","pinned":false,"hidden":false,"mode":"md"},{"id":571,"value":"waspPrinter = FileAttachment(\"wasp-printer.png\").image({ height: 400 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":614,"value":"

Photo of the real-life Delta Wasp Clay 3D printer implemented in Taxon.

","pinned":false,"hidden":false,"mode":"html"},{"id":352,"value":"$3a","pinned":false,"hidden":false,"mode":"html"},{"id":552,"value":"viewof sceneClay = generateTaxonScene(machinePlanClay, enableAnimationClay)","pinned":false,"hidden":false,"mode":"ojs"},{"id":554,"value":"viewof enableAnimationClay = Inputs.toggle({\n label: \"Enable Animation\",\n value: false\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":556,"value":"$3b","pinned":false,"hidden":false,"mode":"ojs"},{"id":592,"value":"viewof clayControl = {\n let dom = generateControlDom();\n loadTextIntoWorkflowDom(workflowClayText, dom);\n let workflow = new Workflow(dom, sceneClay);\n dom.value = workflow;\n return dom;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":601,"value":"workflowClayText = `\n$machine().zero();\n$machine().moveTo({x: 0, y: 0, z: 50}, 10);\n$machine().moveTo({x: 50, y: 0, z: 50}, 10);\n$machine().moveTo({x: 50, y: 0, z: 0}, 10);\n$machine().moveTo({x: 0, y: 0, z: 0}, 10);\n$machine().moveTo({x: 0, y: 2, z: 50});\n$machine().moveTo({x: 50, y: 2, z: 50}, 10);\n$machine().moveTo({x: 50, y: 2, z: 0}, 10);\n$machine().moveTo({x: 0, y: 2, z: 0}, 10);\n$machine().moveTo({x: 0, y: 2, z: 50}, 10);\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":619,"value":"## Example: Robotic Assembly of PCB Components","pinned":false,"hidden":false,"mode":"md"},{"id":621,"value":"lightplacer = FileAttachment(\"lightplacer.jpg\").image({ width: 700 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":624,"value":"

The Liteplacer Open Source Pick and Place Machine by Juha Kuusama. We implement a model of this machine in Taxon below.

","pinned":false,"hidden":false,"mode":"html"},{"id":358,"value":"$3c","pinned":false,"hidden":false,"mode":"html"},{"id":629,"value":"viewof scenePnp = generateTaxonScene(machinePlanPnp, enableAnimationPnp)","pinned":false,"hidden":false,"mode":"ojs"},{"id":631,"value":"viewof enableAnimationPnp = Inputs.toggle({\n label: \"Enable Animation\",\n value: false\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":642,"value":"viewof pnpControl = {\n let dom = generateControlDom();\n loadTextIntoWorkflowDom(workflowPnpText, dom);\n let workflow = new Workflow(dom, scenePnp);\n dom.value = workflow;\n return dom;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":633,"value":"$3d","pinned":false,"hidden":false,"mode":"ojs"},{"id":639,"value":"workflowPnpText = `\n$machine().zero();\n$machine().moveTo({x: -87.5, y: 0, z: -15});\n$t('needle0402').park();\n$machine().moveTo({x: -87.5, y: 0, z: 0});\n$t('needle0603').equip();\n$machine().moveTo({x: 300, y: 0, z: 0});\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":341,"value":"$3e","pinned":false,"hidden":false,"mode":"html"},{"id":343,"value":"

Conclusion

We contributed and described the design of Taxon, a grammar for\nformally specifying abstract machine properties that enables\ndescription, comparison, and simulation of physical machines. The\npromise of digital fabrication lies in how it might allow new\npractitioners to create objects that uniquely suit their own contexts.\nThe capabilities and limitations of machines will always be important\nfactors in both making and research on making, and they ought to be made\nexplicit. We aim for Taxon to become a useful standard in fabrication\nresearch and practice that lets researchers integrate machine-level\nconcerns into novel tools and provides makers with helpful\ninfrastructure to guide their manufacturing processes.

","pinned":false,"hidden":false,"mode":"html"},{"id":44,"value":"# Testing — Messy Things Follow","pinned":false,"hidden":false,"mode":"md"},{"id":148,"value":"$3f","pinned":false,"hidden":false,"mode":"ojs"},{"id":199,"value":"workflowDemoPrint = [\n \"$machine().zero();\",\n \"$machine().moveTo({x: 0, y: 0, z: 50}, 10);\",\n \"$machine().moveTo({x: 50, y: 0, z: 50}, 10);\",\n \"$machine().moveTo({x: 50, y: 0, z: 0}, 10);\",\n \"$machine().moveTo({x: 0, y: 0, z: 0}, 10);\",\n \"$machine().moveTo({x: 0, y: 2, z: 50});\",\n \"$machine().moveTo({x: 50, y: 2, z: 50}, 10);\",\n \"$machine().moveTo({x: 50, y: 2, z: 0}, 10);\",\n \"$machine().moveTo({x: 0, y: 2, z: 0}, 10);\",\n \"$machine().moveTo({x: 0, y: 2, z: 50}, 10);\"\n].join(\"\\n\")","pinned":false,"hidden":false,"mode":"ojs"},{"id":202,"value":"**TODO:**\n- workflow/animation\n- filtering rots","pinned":false,"hidden":false,"mode":"md"},{"id":48,"value":"mutable test = 0","pinned":false,"hidden":false,"mode":"ojs"},{"id":195,"value":"htl.html`${machinePlanPrusa}`","pinned":false,"hidden":false,"mode":"ojs"},{"id":185,"value":"function generateTaxonScene(machinePlan, enableAnimation) {\n return new Promise((resolve) => {\n resolve(html`

`);\n }).then((domElement) => {\n let ts = new TaxonScene(domElement, enableAnimation);\n let compiler = new Compiler();\n compiler.decompileIntoScene(ts, machinePlan);\n ts.renderScene();\n domElement.childNodes[0].style.border = \"1px solid black\";\n domElement.value = ts;\n return domElement;\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":482,"value":"// viewof enableAnimation = Inputs.toggle({\n// label: \"Enable Animation\",\n// value: true\n// })","pinned":false,"hidden":false,"mode":"ojs"},{"id":189,"value":"// viewof ts2 = generateTaxonScene(machinePlanPrusa, enableAnimation)","pinned":false,"hidden":false,"mode":"ojs"},{"id":233,"value":"// wf = new Workflow(controlDom, ts2)","pinned":true,"hidden":false,"mode":"ojs"},{"id":224,"value":"// controlDom = generateControlDom()","pinned":true,"hidden":false,"mode":"ojs"},{"id":240,"value":"// loadTextIntoWorkflowDom(workflowDemoPrint, controlDom)","pinned":true,"hidden":false,"mode":"ojs"},{"id":18,"value":"# Taxon Library and Utilities","pinned":false,"hidden":false,"mode":"md"},{"id":28,"value":"THREE = {\n const THREE = (window.THREE =\n await require(\"three@0.108.0/build/three.min.js\"));\n await require(\"three@0.108.0/examples/js/controls/OrbitControls.js\").catch(\n () => {}\n );\n return THREE;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":33,"value":"$40","pinned":false,"hidden":false,"mode":"ojs"},{"id":110,"value":"$41","pinned":false,"hidden":false,"mode":"ojs"},{"id":116,"value":"$42","pinned":false,"hidden":false,"mode":"ojs"},{"id":153,"value":"$43","pinned":false,"hidden":false,"mode":"ojs"},{"id":160,"value":"$44","pinned":false,"hidden":false,"mode":"ojs"},{"id":155,"value":"$45","pinned":false,"hidden":false,"mode":"ojs"},{"id":38,"value":"$46","pinned":false,"hidden":false,"mode":"ojs"},{"id":35,"value":"$47","pinned":false,"hidden":false,"mode":"ojs"},{"id":99,"value":"$48","pinned":false,"hidden":false,"mode":"ojs"},{"id":104,"value":"$49","pinned":false,"hidden":false,"mode":"ojs"},{"id":121,"value":"$4a","pinned":false,"hidden":false,"mode":"ojs"},{"id":125,"value":"$4b","pinned":false,"hidden":false,"mode":"ojs"},{"id":128,"value":"$4c","pinned":false,"hidden":false,"mode":"ojs"},{"id":131,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs"},{"id":134,"value":"class RotaryStage {\n // TODO\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":137,"value":"$4e","pinned":false,"hidden":false,"mode":"ojs"},{"id":143,"value":"$4f","pinned":false,"hidden":false,"mode":"ojs"},{"id":140,"value":"$50","pinned":false,"hidden":false,"mode":"ojs"},{"id":96,"value":"$51","pinned":false,"hidden":false,"mode":"ojs"},{"id":205,"value":"$52","pinned":false,"hidden":false,"mode":"ojs"},{"id":209,"value":"$53","pinned":false,"hidden":false,"mode":"ojs"},{"id":213,"value":"$54","pinned":false,"hidden":false,"mode":"ojs"},{"id":219,"value":"function generateControlDom() {\n return htl.html`\n\n

\n \n

\n \n \n

\n\n`;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":236,"value":"$55","pinned":false,"hidden":false,"mode":"ojs"},{"id":276,"value":"$56","pinned":false,"hidden":false,"mode":"ojs"},{"id":278,"value":"$57","pinned":false,"hidden":false,"mode":"ojs"},{"id":280,"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":284,"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":286,"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":306,"value":"","pinned":true,"hidden":false,"mode":"html"}],"files":"$W58","stdlib":"1","titling":"auto"}