Patent Application
20250137778
The present invention enables subtractive fabrication machines, such as laser cutters milling machines, water jet cutters, knife-based cutters, etc. to calibrate “themselves”, i.e., to determine certain parameters the device needs to know in order to produce precise, high-quality results and to apply these parameters.
Embodiments include an integrated subtractive fabrication device, such as a laser cutter, that produce high-quality results while requiring little or no user interaction apart from sending a model. Resembling the user experience of a (kitchen) appliance (“an instrument or device designed for a particular use or function” [https://en.wikipedia.org/wiki/Home_appliance] we sometime refer to these embodiments as laser cutter appliances. This makes the present invention easier to maintain, thus also allowing operation/maintenance without an expert technician, but by non-experts, such as teachers, students, librarians, etc.
The presented appliance achieves like so: (1) The device contains sensors. They sense various aspects that may impact the quality of the fabrication, such as relevant aspects of the current state of the device, the material located in the device, and/or the effect of the device onto the material. (2) The device operates the necessary sensors, e.g., while test cutting the material. (3) The device automatically applies the results of these measurements to itself and/or the model it receives for fabrication. (4) To allow for a wider range of such factors to be applied (in a self-contained matter, i.e., without having to delegate back to the application program), the device may optionally receive the model to be fabricated in a file format that allows a wider range of adjustments to be made.
Laser cutters are fabrication machines that allow processing physical materials, such as cutting and/or engraving them. Work pieces tend to include sheets of material. Materials tend to include wood, plywood, particleboard, acrylic, etc. and in some cases a wider range of materials, such as metal.
In order to produce precise and thus useful output, laser cutters (and to a certain extent other subtractive fabrication machines) require precise calibration, i.e., several parameters either have be entered/loaded into the machine or the model sent to the machine for cutting or engraving has to be adjusted accordingly. The list of such parameters includes (1) how wide a line of material the laser removes when cutting a line (aka kerf), (2) how thick the material actually is. (3) size and shape of the material to be cut from, (4) the number-of-passes, power, and speed (e.g., as the number-of-passes×power/speed=energy per length of cut or engraving, in the interest of brevity we will sometimes “power” for short) required to engrave a certain depth when raster engraving, to darken the material when raster engraving, when line engraving, to cut material to a certain depth, to cut through a subset of layers of a given sandwich material, and so on. Parameters tend to depend on the machine and the material at hand and they also tend to vary over time, e.g., as the laser source and/or the optical components are subjected to wear. But, most of all, these values depend on the material at hand.
As a consequence, some process that determines these parameters (the “calibration process”) may have to be repeated from time to time-often on a per-job basis.
Different users may have their respective take on calibration process ranging from satisficing with reusing previous settings and hoping that they continue to apply (despite changes in wear, potentially changes in material, etc.), guessing settings, a series of trail-and-error, to the use of calibration aids, such as by fabricating simple dedicated models that allow reading one or multiple of the desired settings.
This process, however, not only tends to consume material and time, thus creating cost, but may also prevent non-experts from operating such machines in the first place. Out of the typical fabrication process (modeling & export to cutter, setup & calibration, fabrication, assembly) set-up & calibration can easily become the most time-consuming part: As all other steps have experienced substantial speed-ups in recent years: modeling, by means of special-purpose modeling systems, such as flatFitFab [McCrae et al. 2014. FlatFitFab. In Proc. UIST '14], kyub [Baudisch, P. WO2018017626 SYSTEM AND METHOD FOR EDITING 3D MODELS] [Baudisch et al. Kyub. In Proc. CHI '19. 556,1-12]), cutting has essentially always been fast, and assembly by means of assembly-friendly layouts, such as roadkill [Abdullah et al. Roadkill: Nesting Laser-Cut Objects for Fast Assembly. In Proc. UIST '21, 972-984]). Set-up/calibration, in contrast, has largely been ignored so far, easily making it the bottle neck in this process.
Arguably even more important, calibration is not only time-consuming, but requires expertise. This either consumes substantial money for an expert technician (the salary of whom commonly vastly exceeds the cost of the actual machinery) or/and simply excludes non-experts from using these types of machinery.
This present invention aims at overcoming this hurdle. It makes laser cutters and similar machines easier to maintain, thus allows operating these machines without the help of an expert technician. This has the potential to making the field of subtractive fabrication accessible to non-experts, such as teachers, students, librarians, and for home use etc.
While many manufacturers offer only very limited help calibrating their machines, some manufacturer, such as Glowforge ([glowforge.com], [Shapiro et al. Moving Material During Laser Fabrication. U.S. Pat. No. 10,496,070]) and so a much lesser extent others, such as Trotec and Epilog) have added additional hardware to their machines, such as (1) one or more cameras facing downwards from the top of the casing, facing downwards from the laser head, or both. (2) These machines may thus be capable of recognizing the material placed into the cutter by equipping materials with a bar code that can be read using the/one of the camera(s) to then look up of its material properties from a database. (3) That same camera may also allow users to obtain a photograph of the material located in the cutter, e.g., to allow users to position the geometry to be cut on it.
Furthermore, some manufacturers, such as the ones listed above, have made attempts to reduce the necessity for calibration by limiting their ecosystems to standardized elements. (4) Their software may, for example, be running only on a certain type or a small number of types of proprietary machines. By knowing additional specifics about these machines, such as the type of laser source it employs, there is less to calibrate. (5) They may use materials that are particularly planar and of homogeneous hardness (commonly MDF, thinly coated with vernier, as well as other man-made materials, such as acrylic, etc.). (6) Models in the Glowforge universe are largely limited to models not containing press-fit joints (thus largely to 2D models) thereby bypassing the difficulties revolving around press-fits, such as kerf, fit, and repeatability (see below).
Finally. (since the methods discussed above are not quite sufficient to produce high-quality calibration) some manufacturers discourage or try to eliminate design elements that require a precise calibration. (6) When cutting 3D models, i.e., models that can be assembled from multiple parts, these manufacturers may encourage the use of cantilever snap-fit joints (e.g., building on [Thijs Roumen, et al. 2019. SpringFit: Joints and Mounts that Fabricate on Any Laser Cutter. In Proc. UIST '19. 727-738]), which are more tolerant to variations in the amount of material removed by the cutter (aka kerf) than the press-fit box joints used normally.
In the world of research, an exploration has started aiming to produce sensors that allow automating a few isolated sensing activities involved in laser cutters: Sensicut [Mustafa Doga Dogan et al. 2021. SensiCut. In Proc. UIST '21. 24-38], for example, automatically classifies materials located inside the cutter. PacCAM [Daniel Saakes et al. 2013. PacCAM. In Proc. UIST '13. 441-446] and Packaide [Ticha Sethapakdi et al. 2021. In Proc. CHI '21. 1-12] (semi-) automatic distribute parts to be cut across a sheet of material (aka nesting).
While this is a promising start, there still is no automation for the vast majority of sensor activities required for end-to-end calibration (see list above). Furthermore, obtaining sensor readings is not enough-sensor readings also need to be applied, i.e., the settings of laser cutters etc. have to be adjusted and/or models need to be adjusted. We tackle both with the present invention.
At the lowest level, subtractive (and other) fabrication machines tend to be operated using a machine-specific file format called GCODE, i.e., a file that contains instructions which actuator in the device to operate using which parameters and in what order [International Organization for Standardization, ISO 6983-1:2009]. In the case of a (2- or 3-axis) laser cutters, the parts to be cut largely form a 2D tool path, which allowed them to also be expressed in the form of a 2D drawing, which can be encoded, for example, in the Scalable Vector Graphics (SVG) file format [W3C. 2001. Scalable Vector Graphics], which can then automatically be converted to GCODE. While SVG, at first glance, appears to be machine-independent, it is not, as it does not allow representing kerf, limiting its portability when it comes to models containing press fit mechanisms, such as the two halves 101 and 102 forming a box joint to be assembled in the 3D shape on an angle (as illustrated by
One approach to overcoming the kerf-dependence of SVG is to eliminate all model elements that form a press fit (springFit) and to replace bearings with kerf-invariant bearings (kerf-canceling mechanisms [Thijs Roumen, et al. Kerf-Canceling Mechanisms. In Proc. UIST '20, 293-303]). Another approach to overcoming the kerf-dependence of SVG is to use a file format that allows adjusting kerf after the fact (LaserSVG (Florian Heller, 2022, LaserSVG, https://github.com/florianheller/lasersvg) and metaSVG [Nur Yildirim, et al. MetaSVG: A Portable Exchange Format for Adaptable Laser Cutting Plans. In Proc. Graphics Interface 2022]. However, the specific way in which they handle the geometry adjustments require either detailed knowledge about the specific joint types and their behavior or cannot reproduce the modeled joint geometry in detail. We overcome this in the present invention.
In the context of 3D printing, McGatha [Jesse McGatha, et al. 2014. 3D printing method and computing device using arbitrary printers and arbitrary software applications (WO 2014/210394 A1)] envisioned a system capable of abstracting the details of 3D printers behind an operating system level layer. Laser cutting faces some similar challenges, such as how to monitor and account for wear, as well as some additional challenges, such as how to determine and calibrate for non-standardized materials.
As mentioned above, one of the aspects that make laser cutting complex is the fact that not just the laser cutter has to be considered, but also the material. Materials add a lot of complexity, as the material used in laser cutting commonly contain not only a number of material types (acrylic vs. plywood vs. MDF, etc.) but also a variety of sizes, aspect ratios, as well es cutouts, when material is re-used from previous projects. In addition, material not only comes in different thicknesses and numbers of layers, but also varies in the actual thickness (“4 mm” plywood commonly is only 3.8 mm thick) and may contain a wide range of glues between layers, as well as knotholes (even in the invisible middle layer). This makes laser cutting different from print (and Glowforge ecosystem), where materials tend to be standardized to a small number of formats.
Several laser cutter manufacturers (such as Trotec's Job control [https://www.troteclaser.com/en/laser-machines/jobcontrol], Universal laser's Control Panel [https://www.ulsinc.com/discover-uls-innovations/laser-system-user-interfaces]) tackle the issue by offering lists that map material classes to the power/speed settings suggested to cut these. This approach is of course a vast oversimplification, as it considers neither the actual laser cutter at hand (wear of the laser tube, the lens, etc.) nor of the actual material at hand (actual thickness, glue used, and so on).
Thus, ultimately, cutter and material need to considered on the actual cutter and with the actual material-which is what users do today, when they cut a simple calibration aid (aka “kerf strip”) from the material they are about to use on the machine they are about to use. This, of course, is a major time commitment, which is why we demonstrate how to automate this process in this invention.
Throughout this disclosure, we largely use the term “laser cutter” when speaking about the machine to calibrate. We are doing so in the interest of simplicity and readability. Nonetheless, even when we write “laser cutter” we generally refer to any machine out of a broader set of fabrication machines, including laser cutters, milling machines, water jet cutters, knife-based cutters, etc.
While we at times refer to a specific fabrication device (e.g., Trotec Speedy 360), sometimes with an associated API (e.g., Trotec Ruby) the present invention applies to any subtractive fabrication device by any manufacturer (such as, just to use laser cutters once more as example, devices by Epilog, Universal, Trumpf, Mr Beum, Glowforge, Aeon, Snapmaker, etc., as well as the wide range of cutters produced, for example, by Chinese manufacturers, etc.) and their APIs.
While we at times refer to a specific piece of application software (or application subsystem), such as kyub, the present invention applies to any such system (such as, FlatFitFab [McCrae et al. In Proc. UIST '14, 13-22], the suite of programs created by Autodesk, such as AutoCAD, Fusion360, TinkerCAD, etc.), as well as any of a wide range of open source or shareware tools, such as boxes.py, maker case, and so on.
We also often refer to “the material”, “the sheet”, or “the workpiece”, as if referring to single piece of piece, e.g., located in the laser cutter. However, the present invention generally equally applies to situations where multiple such pieces are being handled. In which this case, the respective embodiments simply (1) detect the presence of multiple pieces (e.g., using a camera performing segmentation and a “connected components” algorithm) and then (2) perform the respective process on each detected work piece.
While we at times make reference to a laser cutter with a horizontal cutting bed that one (or more) work pieces are being placed onto, staying in place based on gravity or suction of the ventilation system, different embodiments may employ different form factors, including devices the cutting bed of which is not horizontal, devices that hold the work piece is place using various fixtures, devices featuring pass-through mechanisms, or that actuate the work piece by means of (one or more) automated material feeders, material cartridges, robotic arms, lathe-like rotary setups, as well as devices offering fewer or more than 3 degrees of freedom.
The computing device interpreting the contents of this model may be contained in the same enclosure as fabrication device or may be connected to it.
Some elements disclosed in this document teach adding additional hardware to the head of a laser cutter. These additional elements should generally be designed for minimal mass, so as to keep the interference with the actuation of the laser head (such as a gantry, pantograph mechanism, robot arm, etc.) to a minimum. Someone skilled in the art will know that they can easily be achieved by replacing large motors with small motors with appropriate (in some cases back-driveable, low slack) transmissions, such as gear boxes, etc. At the same time, the actuation mechanism should be adjusted to properly deal with the additional load.
The fabrication device, aka the laser cutter, may be physically connected any of the following but not limited to: a direct cable connection, a network, a wireless network, a physical data storage device, such as a USB stick or similar, a mobile print
Instead of transmitting to a laser cutter subsystem, could also save output, such as cutplan, to a storage medium such as a disk, SSD, memory stick, network drive, cloud storage, etc.
Instead of running on a general-purpose computing hardware, such as an IBM compatible personal computer (built into a laser cutter or separate from it), the software described in this disclosure may be run on a micro controller, a mobile device, etc.
In contrast, the present invention is designed to tackle the calibration challenge without limiting the eco system and without eliminating design elements. In particular, the present invention aims to allow (1) working with arbitrary materials on (2) arbitrary laser cutters with arbitrary wear while (3) still allowing users to use calibration-sensitive design elements.
In addition, (4) we tackle several additional features, such as calibration of cutting power, true material thickness, engraving depth, etc. (5) We automate all these.
And finally, (6) we integrate this process. In particular, we propose an integrated laser cutter device capable of performing the necessary calibration steps in a way transparent to the user, thereby allowing non-expert users, i.e., users without calibration experience to produce well-fabricated objects. A key element to achieving this is a file format and process that allows the device to do so.
In one possible embodiment, i.e., an integrated system consisting of an application talking to the present invention subsystem (we will sometimes refer to this embodiment as a laser cutter appliance) a user session may go like this: (a) The user has created or loaded a model into a design application for laser cutting (such as kyub). (b) The user triggers the export of the model to the laser cutter. (c) Here the user also picks a laser cutter and one or more material sheets to use—this, however, is optional at this point in time. (c) The design application now converts the 3D model into a 2D format (as disclosed in [WO2019075278—SYSTEM AND METHOD FOR HANDLING ASSETS FOR FABRICATION]). It then invokes an encoder that is part of the present invention; it encodes the 2D plates as well as additional information extracted from the original 3D format into the resulting file; this additional information will allow making additional adjustments to the file later on. In the remainder of this disclosure we refer to the format as a cutplan (and tend to identify files by giving them the extension “.cut”). The user picks a cutter to send the file to. (d) The user inserts one or more sheets of material and, either triggered by the using pressing some “start” button or triggered by closing the device, the laser cutter starts. (e) It now extracts what features are contained in the model that may require calibration and performs its calibration routine accordingly. (f) It then, typically without further user interaction, fabricates the parts for the model, (g) which the user removes from the cutter and assembles. As a result of the calibration, the parts and the assembled model are of high quality.
This system may be operated in various orders. While the above use case started with the model, usage may also start without the model: (1) The user (or some mechanism) places (one or more pieces of) material into the cutter. (2) The system locates the material pieces, e.g., using a camera. (3) In order to speed things up later, the system may now already perform a range of calibration steps on this material, i.e., if the system deems calibration necessary, it performs the respective calibration routine on one or multiple of the material pieces in the cutter. (5) When the user now sends one or more models to the laser cutter, e.g., from a repository or from a modeling software, such as Kyub, of FlatFitFab, or AutoCAD, slicer, etc. (6) the system positions the parts of the model onto the material pieces (aka nesting) and (7) cuts/engraves the model. (8) When done, the user (or some automated mechanism) removes the parts from the laser cutter and, if necessary, assembles the model.
Note that different models require different subsets of parameters to be calibrated. Information about required parameters may be included in the model file, handed down by the modeling software, or inferred by the present invention. Only if a model encompasses, for example, engravings, then the system may want to invoke the respective calibration routine. Users may thus prevent the system from calibrating until the model has been received send the (e.g., by configuring the system so as to wait for the model(s) or my simply sending the model(s) before placing material in the cutter), as this allows the present invention to limit calibration to the routines actually required by the model(s) to be fabricated.
While the above figure shows the calibration of one specific aspect, namely kerf, objects may contain elements that require additional or different types of calibration. The process may thus cover the calibration of a different set of features, including, but not limited to cutting speed and power, number of passes, detection of burning or burn marks, engraving depth, intensity of marking, depth of partial cuts (e.g., for HingeCore [Muhammad Abdullah, et al. HingeCore: Laser-Cut Foamcore for Fast Assembly. In Proc. UIST '22. 10, 1-13]), and so on.
A key benefit of the system design disclosed here is to allow for a (partially, largely, or fully) automated calibration process, which means to minimize the necessity for user interaction. We achieve this by (1) automating the measurement of calibration-relevant information, (2) applying these sensor readings to the settings of the laser cutter device and/or the model and, optionally (3) running independent of the user-facing application that generated the model. The latter, in the most consequent embodiment, means that it is running within the laser cutting device (while other “less-integrated” embodiments use a separate computer) allowing users to send or upload their model to the device in order to see it being fabricated automatically and in a well-calibrated manner.
After determining which gauges should be run, the gauge manager 402 runs all selected gauges by either invoking them directly or by 403 being invoked by another component of the laser cutter subsystem once the value calibration should be performed.
Each gauge contains information about (optionally, what actuator has to be run and how and) what sensor has to be read in order to calibrate its respective feature. This information can, for example, be encoded in the form of program code, similar to how “drivers” in common computer systems encode how to run peripherals. Example: for a model file containing the feature “line engraving”, the gauge manager would invoke the “line engraving gauge” which in turn would 404 start running an actuator specific to the gauge, in this case causing one or more short line engraving to be created in the actual material sheet currently located in the laser cutter. The gauge would 405 observe the result using one or more sensors and 406 as a result determine (some of) the mapping from cutting speed and power to the depth and darkness of the line engraving. The resulting calibration values are then applied 408 either to the settings of the laser cutter, 407 to the model or both. One possible mechanism for doing so is to store the calibration results in variables such “$thickness(0)”, as we discuss later in this disclosure.
To expand on how the result are to be applied: Ideally, all relevant features could be applied by writing some (global) laser cutter settings and some laser cutters support may support this for some features, such as a global cutting for cutting speed. Some features, however, are hard to express “globally” as they make reference to specific locations in the design to be cut. Compensating for kerf, for example, requires moving or deforming lines, which are geometric objects inside a 2D layout to be cut (aka cutting plan). The direction in which a line has to be moved in response to kerf, for example, depends on the local geometry of the model (lines tend to divide up space into a halfplane that forms a “part” and a halfplane that forms “scrap”; to express a larger kerf, lines need to be moved towards the scrap halfplane). It is thus difficult to achieve this using a global transformation. Features that make reference to such “local” features are therefore often better handled by updating the model. If that is not the case, the apply to model (407) in
Finally, some values, could in theory be handled using (global) laser cutter setting, but the specific device at hand lacks that ability, i.e., does not expose this type of functionality. The mapping from brightness values in a bitmap to engraving depth, for example, may require calibration, as the user creating the bitmap might expect that mapping to be linear, when the result by the machine is not linear (meaning: sending a bitmap with one area of pixels representing a certain gray value and another area of pixels representing a gray value twice as dark may not produce an engraving that is twice as deep; also: some gray values may produce no visible engraving at all, and so on). Sending a bitmap with engraving information encoded as a bitmap may thus lack discernable detail in at least some brightness intervals. An ideal laser cutter would allow updating the way the device maps grayscale values to engraving power, e.g., by allowing users to create and upload such a map, e.g., in the form of a table, by sending a mathematical function, and so on, or by creating such a map automatically (see below). Other laser cutters, however, may lack such a feature. In this case, we may choose to handle a feature, here engraving depth, using the second route, i.e., to update contents in the model file in order to reflect the calibration information (e.g., applying an appropriate brightness adjustment to all bitmaps in the model intended to produce engravings). As discussed below, updating can be accomplished by reading or receiving a model, modifying up, and writing/sending the model; it can also mean to read a model containing variables and evaluating these in the context of the sensor readings.
Finally, we can still handle some spatial features using global settings.
As a result, different embodiments require different subsets of software/hardware components. In the simplest case, there is:
If the decoder/adjuster is to apply adjustments not just to (global) settings of the laser cutter, but also to geometric aspects of the model sent to the cutter, the system needs to use a file format that encodes models in an “adjustable” format (see the cutplan format we disclose below).
Different embodiments feature different subsets of sensors allowing them to handle different subsets of model features. Some embodiments may therefore opt for an extensible architecture that wraps hardware and software into a component or object, offering a unified API that allows easy integration of new hardware components or gauges.
Multiple gauges can now be managed in a single data structure using this style of gauge manager:
Running the gauges can now be accomplished by (registering all gauges and) calling the methods findRequirements, runRequiredGauges and adjustModel on the gaugeManager. While the individual gauges can each individually implement their decision process, they share access to the sensors and actuators over the gaugeContext. The gaugeManager provides this context to all gauges on registration.
Different embodiments may invoke calibration based on different trigger events. Possible triggers include, but are not limited to:
As discussed earlier, some measurements made by gauges are best applied by storing them in the settings of the laser cutter itself or the settings associated with the current job, such as power and speed settings. Others, in contrast, make reference to elements of the model-thus applying those may require adjusting the model according to the gauge readings or at least (re) interpreting the model in the context of the gauge readings.
6.3 Alternative System Architectures: Application Vs. Laser Cutter Subsystem
Zooming the architecture shown in
Different embodiments may follow different strategies of where exactly to place the cut between the two subsystems.
The architecture shown in
On a higher level, alternative embodiments may draw the line between application subsystem and laser cutter subsystem differently, such as:
By enabling the laser cutter to do the 3D to 2D conversion, the laser cutter can operate entirely independently from the modeling software. While this allows users to share their model, it shifts the governance for adapting the model to changes in material to the laser cutter. This requires the laser cutter to adapt to changes on a volumetric level (e.g., by changes in the material thickness). Also, tasks like nesting that require user interaction would now be done at the laser cutter, a device we want to be an appliance rather than interacting with for high precision and fidelity tasks. Furthermore, it strips a designer of the authority to create a layout if this is to be redone by the laser cutter as part of the 3d to 2d conversion.
An example session proceeds here as follows: the application extracts from the model the features the model contains. In the case of our example cajon, this might be “cutting 8 mm birch”, “1 mm-depth engraving into birch”, and “cutting 3 mm okume wood”. “box joints between 8 mm birch”, and “box joints between 8 mm birch and 3 mm okume”. The application now asks the laser cutter for the settings required to produce these features, which the laser cutter determines by running gauges and sends the information back to the application. The application now applies the settings and finally exports the model to the laser cutter-which at this point can be accomplished using a much wider range of file formats, such as SVG or even by lower-lever commends, such as move_head_top( ) or even geode. The main limitation of this approach is that it requires applications to know about all available laser cutters and their inner workings.
Different embodiments may use different file formats. File formats include, but are not limited to the following options and combinations thereof:
1. Point-based format: A point-based format, such as the aforementioned LaserSVG, contains individual plates described by the control points that make their outlines. Point can then be complemented with an additional vector that offsets the point once the calibration information is known. The vectors may therefore contain parameters, in particular those making reference to calibration information, such as, for instance “(10, 20)+ (1, 0)*kerf)”, where “kerf” makes reference to the width of kerf as determined by a calibration process. This approach is limited in that does not allow encoding cases in which changes in material thickness lead to changes in geometry.
2. Plate-and-joint-based format: In a joint-based format, such as the aforementioned metaSVG, the file format describes the individual plates the model consists of. In the description, these plates are simplified in that the joints have been removed, so that the edges that would normally contain joints appear to be straight. Each of their edges is annotated with the type of joint (and parameters, such as widths, etc.) that the exporter should create for this edge, such as box joint, T joint, cross joint—and a much richer set for milling machines (dove tails etc.). This class of embodiments is viable, yet subject to certain limitations: (1) The exporter is limited to a finite set of joints. Therefore, introducing a new joint type requires an update of the laser cutter component. (2) The adjustment of the joints and coordination at corners requires full 3d information (e.g., which edges meet at what angle at a corner) to allow for the correct offsetting on corners where more than three plates meet. Limitation: this class of formats requires the decoder side to know all possible joint types in advance, which can lead to maintenance issues (i.e., updating the decoders in every machine using it), when a new joint type is introduced. Otherwise, they cannot reproduce the modeled joint geometry in detail as they resolve corner coordination on a 2D level
3. Shape-based formats. In this format, each of the plates the model is represented as more or more shapes, such as polygons, circles, ellipses, etc., as well as corresponding types of cut-outs. The key to this approach is that it allows all shapes belonging to one plate to be processed separately during calibration; they will then be merged back into a single plate (i.e., “positive” shapes united and cut-outs removed) before fabrication starts with the help of a polygon clipping function, such as [Francisco Martínez et. al. 2009. In Proc. Computers & Geosciences, 1177-1185]. Shape-based formats offer the most “expressive” results as it is not subject to the limitations of the two formats listed above.>
Thus, all three types of formats work to some extent. In the following we focus on shape-based format, as this allows us to explain the entire spectrum of features. Other embodiments may use point- or joint-based formats, albeit with a reduced feature set.
We will refer to this particular file format as “cutplan”. Unlike a standard Scalable Vector Graphics (aka SVG) file format, in cutplans (1) the individual shapes contained in a file are tagged as either material or cutout. This clearly distinguishes parts from serap and also indicates the direction in which offsets need to be applied in order to compensate for kerf (i.e., edges will be offset away from material and towards scrap). (2) the control points of shapes are represented as arithmetic expressions. These are allowed to contain variables, making reference to, among others, the particular parameters the value of which will be determined at calibration time, such as the actual material thickness of the material and kerf.
Here, “acrylic opaque” is an example of a “class of materials”. We discuss this concept and its distinction from actual sheets of material later in this disclosure, but, as a preview such a “class of materials” will be translated into an actual sheet before fabrication starts and there are a number of ways this “mapping” from “class of materials” to actual sheets can take place, such as (1) by the application subsystem asking users to map it to an actual sheet, (2) By the user having scanned one or more actual sheets and the system then mapping these to the materials in the model based on similarity, (3) by automatically detecting material(s) located in the cutter and mapping these to the material(s) in the file based on similarity, (4) by the laser cutter subsystem asking the user to place a matching sheet into the cutter, etc. Alternatively, the ID tag may also be used to pass the ID of an actual sheet of material, in which case no mapping to actual sheets is necessary anymore (even though embodiments might allow for remapping the different sheets in order to allow replacing sheets that turn out to be broken, lost, or just to give users the design choice).
Each plate in the plates section represents a 2D component in its own local coordinate system, which allows arranging parts on a sheet (aka nesting) without having to re-write all coordinates. (Alternative embodiments may still follow the traditional approach of using a single global coordinate system, as used, for example, by SVG). Each plate is described by a set of shapes, such as polygons. Each shape can be material (“cutout=false”) or a cutout (“cutout=true”). The sole polygon in this file forms a single 25 mm square centered around the origin. (This particular format uses commas to group numbers into coordinate pairs and spaces to separate points; different embodiments may choose different ways of encoding this).
This specific file does not contain any variables. In particular, it thus does not make reference to any of the parameters to be determined at calibration time. After adding vectors moving plates to their positions on the material sheet (aka “nesting”), the coordinates in this file are thus the final coordinates.
That said, some embodiments may choose to simplify the handling of kerf, i.e., instead of adding kerf to essentially everything, they may use a global rule saying that kerf be applied to all shapes by default. In the shown example, the square would thus be dilated by kerf, i.e., all point coordinates would be pushed outwards by kerf. Generally, the system dilates (shapes or) plates in the aforementioned direction from material to scrap.
The file shown in
There are multiple reasons why the material thickness in a model may have to be adjusted. It is not uncommon that the thickness of actual material sheets is not the one specified by the manufacturer; a 4 mm sheet of plywood, for example, may by only 3.8 mm thick. Furthermore, users may instantiate a “class of materials” late or replace the “actual material sheet” assigned to a model after the model was encoded in a cutplan. Some embodiments may therefore offer ways to adjust material thickness after the fact.
Adjusting material thickness is a non-trivial endeavor, because the correct action to take, in particular in which “direction” to adjust the thickness of a plate depends on the application scenario at hand. The cup depicted in
The plate shown in
For some types of joints, the required joint length requires scaling the thickness or incorporate additional information such as the joint angle for non-90-degree box joints. In similar fashion, we can encode variations in fit so as to allow for an easier fit for longer joints, for non-90-degree joints, for joints that do not allow the use of tools, such as a hammer, and so on. In the cutplan format such more complex variations can be encoded as expressions in the polygon sections: <polygon cutout=“true” points=“−12.5. {12.5 8.333 $fit(50)+−}−12.5, {12.5 16.667 $fit(50)−−} {−12.5 sin(60) $thickness(1)*+}, {12.5 16.667 $fit(50)−−} {−12.5 sin(60) $thickness(1)*+}, {12.5 8.333 $fit(50)+−}”/>.
The cutplan format allows encoding a wide range of additional geometric manipulations. In order to distinguish “presentation models”, which users might want to polish so as to eliminate the burnt edges from working models, which users might leave as is, the file may leverage an additional variable called, for example, “polish”. By encoding the lengths of the “fingers” in
Different embodiments may support different sets of variables. The list of useful variables includes kerf (measured using e.g., Kerfmeter, used e.g., for press-fits), thickness (measured using e.g., level sensor, depth camera, used for accurate model dimensions), sanding (user entered, elongates edges of the model), or the scaling of cutouts for external parts (either user entered, by automatically identifying them or by automatically measuring them) (we refer to these as assets). In addition, cutplan file formats may contain any number of other variables deemed useful. Different embodiments may choose different names for these variables and they may be written in different formats. The shown embodiment expresses these in the form resembling a function call; other embodiments may use any other type of arithmetic notation, such as postfix, prefix, infix, object-oriented method calls, or any other such format.
In order to avoid values being measured multiple times, embodiments may first collect a list of all of these variables, optimize the list, e.g., by removing redundancies, group similar measurements, optimize the order in which to evaluate the variables, pass them on to the respective subsystem in order to invoking the necessary calibration steps. Other embodiments may decide for each value whether they should measure it or rely on the already measured values. Alternative embodiments of the file format contain the list of necessary calibration steps, potentially with fallback values.
The workflow described above decodes the cutplan and applies the calibration information in a single integrated process. Different embodiments may separate the two steps into a decoder followed by a separate adjuster, which then produces a model description containing the actual dimensions. The process described above achieves this adjustment by evaluating the expressions contained in a cutplan in the context of the values determined by calibration.
Other embodiments based on different file formats, perform the adjustment step differently. When using a point-based format, the adjuster works quite similar to the algorithms described above, i.e., it moves points by evaluating variable determined during calibration; unlike the process for shape-based formats described above, there is no merging of shapes into plates. When using a plate-and-joint-based format, in contrast, the adjuster now generates joints based on the variable determined during calibration and merges them into the model.
While the file formats shown above essentially encode data, other embodiments encode models as files containing program code. Historical examples for doing so include Postscript™. Someone skilled in the art would know how to apply the same approach to the encoding and decoding of files for subtractive fabrication.
Many embodiments of laser cutter subsystems will feature decoders for multiple file formats, allowing application to choose. The choice of file format has a range of implications, including digital rights management. (1) The most comprehensive way of sharing a model is in its 3D format, such as kyub or flatFab, allows making all types of changes to the model and at least conceptually allows fabricating on any laser cutter. These formats are enabled by simple adding the decoder for the respective format also to the laser cutter subsystem. (2) Sharing in an adjustable file format, such as cutplans, still allows fabricating on any laser cutter. (3) Sharing in a reduced adjustable file format, such as cutplans with some variables instantiated, allows fabricating on many laser cutters. (4) Sharing a model in SVG format is most specific and thus further reduces the opportunity of further sharing, as the model would produce less well on other machines. A way of producing such an SVG format worth mentioning is users uploading the parameters of a specific (e.g., their) laser cutter calibration information and material to a platform (e.g., the application program) running a cutplan decoder. The platform then runs the decoder in the context of the uploaded calibration and material information and responds by sending the resulting SVG etc. back. This model is now calibrated for the particular machine and material, making it useful for the user, but less useful for others. A sharing site may offer multiple options and charge more for the more comprehensive file formats, e.g., pricing (1)>(2)>(3)>(4) (e.g., combined with a more comprehensive license).
7.5 Determining the Features that Require Calibration
The encoder then 1504 iterates over all effects on plates in the model. These are, including but not limited to, markings, engravings, cutouts, and/or living hinges. For each of these effects the system 1505 creates a calibration requirement and 1506 stores it. Afterwards, 1507 the system stores the model file with the calibration requirements.
In other embodiments, the system uses a different order in which to collect these features, extracts the features while it collects the geometry information, and/or stores the result of the feature extraction in a separate section of the model file or in a separate file. In other embodiments the feature extraction step includes deduplication of the found features or orders them. In different embodiments, the feature extraction happens in the decoder, using the information from the file format. In a different embodiment the feature extraction takes place in a standalone component.
In order to send a model to be fabricated to a laser cutter subsystem, applications encode their models in a file format. Different applications may support one or more such formats. For models the quality of which does not rely on much calibration (such as a simple 2D piece key chain), applications may continue to use traditional formats, such as SVG or similar. However, especially for models the quality of which does depend on calibration of kerf and fit (such as a 3D model of a chair, where plates are connected by various types of press-fit joints), information about the 3D arrangement of plates might be necessary in order to determine how calibrated values affect plate outlines. Therefore, applications might export a 3D model format that preserves those information or a 2D format that encodes how calibrated values affect cut paths, such as cutplan.
The “base shape” of a plate is a representation of that plate before the joints have been added, so that all edges to bear joints later are still straight. In the case of a plate featuring box joints, for example, the “fingers” along each edge are not there yet, making the plate at that edge shorter, or the cutouts are not cut yet, making the plate at that edge longer.
For 1508 Surface modifiers such as raster or line engravings, markings or cutouts for assets (including but not limited to motors, bolts, switch mounts, speakers, etc.) that may require mounting holes on one or multiple surfaces, the encoder may create additional shape definitions or may modify existing shape definitions of the affected surfaces.
As described above, in some embodiments the encoder May 1509 derive information about calibration values that the whole model or parts of it depend on from the generated shapes, including but not limited to thicknesses of specific plates, fit of a specific material or marking darkness calibration. Such calibration requirements may be saved in the output file by including relevant spatial model data such as plate arrangement or asset information from which a decoder would later derive the resulting shape modifications or as variables in parameterized expressions, that describe how a specific calibration value alters the shape.
The encoder 1510 groups all shape definitions from a surface and creates a plate definition that may include additional information such as the material on which the plate should be cut. The encoder 1511 might include additional model information such as a model identifier for fetching additional information about the model at a later time, a material list that may include material information such as material class or expected material thickness or nesting information. Finally, the encoder 1512 stores the model along with the aforementioned additional information in an adjustable file format for subtractive fabrication such cutplan.
Some embodiments may use adjustable files, such as cutplans solely for the purpose of transferring a model to a laser cutter. Other embodiments may store or share adjustable files, such as cutplans, for later use, such as to store them or share them in a repository.
As mentioned above, the system of the present invention contains one or more components we call gauges. The purpose of each gauge is to obtain information about the current calibration state of the laser cutter. The purpose of most gauges is to examine the effect that applying some cutting action does to a material sample located inside the cutter.
While we will present gauges primarily in the context of the overall system of the present invention, all gauges can generally also be made and used in stand-alone usage.
The core functions of a laser cutter tend to be to cut, to engrave, and to mark and, less common so, to bend (e.g., [Stefanie Mueller et. al. LaserOrigami: Laser-Cutting 3D Objects. In Proc. CHI'13, pp. 2585-2592]), to weld (e.g., [Udayan Umapathi et. al. LaserStacker: Fabricating 3D Objects by Laser Cutting and Welding. In Proc. UIST '15. 575-582]).
However, the different settings tend to produce different results. For example, even when two sets of setting both succeed at cutting the material, the outcome may vary in terms of (1) the amount of time required for cutting, (2) the risk/amount of burn marks on the material (e.g., as the result of fumes igniting), (3) the quality of the resulting edge, (and to a lesser extent (4) the resulting kerf, (5) the slant of the kerf). Many gauges therefore sample a number of different settings (we will refer to a fabricated sample representing one sample of settings as a “swatch”), observe the outcome, and report back the settings that produced the best results.
As illustrated by
Gauges may sample the space of settings using various algorithms, ranging from exhaustive search (i.e., the gauge fabricates all requested samples) to search algorithms that try to find the global optimum with fewer samples and thus faster and with less material consumption. Such algorithms include the entire gamut of sampling algorithms, including binary search (in order to optimize a single factor), gradient descent (the gauge fabricates a pair of samples, evaluates them, determines the difference between the two, and extrapolates this “gradient” towards a point where the function is expected to become optimal), Newton iteration, beam search (the gauge fabricates a smaller subset of samples, assesses them, identifies a subset of samples that did well, and varies these to determine the set of samples for the next round), and so on.
If gauges are invoked as part of the fabrication process for a specific model, many embodiments will speed up the calibration process by identifying only those settings that produce outcomes actually required by the model at hand. If a model only contains marking with 30% and 100% darkness, then only these would commonly be calibrated for, rather than the entire grayscale range.
Algorithms may also deploy various strategies designed to further reduce the search space, e.g., by first identifying one setting that barely cuts through (e.g., using binary search between full power and zero power) and then exploring settings of similar energy/cut length, e.g., by decreasing power and speed simultaneously and to a comparable extent or by switching from a single pass to k passes, while simultaneously reducing the cutting power by a factor close to k.
For laser cutters enforcing a minimum round-trip time (e.g., those made by Trotec) it may be more efficient to cut multiple swatches each time, than a strict “binary” search.
Other gauges do not require sampling a space of settings, but are given a single setting for which they determine the consequences. For example, a gauge may, given a specific cutting setting, test cut using these settings and observe and report back the resulting kerf.
As mentioned, most gauges sample the material in the laser cutter by cutting one or more swatches. This means that these swatches consume some of the material in the cutter-material that could otherwise be used to cut models. Gauges may minimize material consumption, by using any subset of the following strategies: (1) use very small swatches (even though some gauges may make them large enough to make them visible to the cameras or large enough to give them sufficient mass to drop reliably, etc.) (2) Pack swatches closely (even though some gauges may imply additional layout constraints, such as positioning over an opening), (3) minimize the number of swatches cut by using an optimizes search strategy, (4) using part of the material sheet that is located along the edge or even better in an area considered scrap.
Since gauges compete and model access the same resource, i.e., the material sheet(s), many embodiments coordinate the layout of the swatches and of the layout of the model (aka nesting), e.g., by the nester reserving (an estimate of the) space for the swatches or by running calibration first and then nesting on the remaining material.
As mentioned above, one of the aspects of utility functions is burn marks, which are often considered undesirable. Burn marks can be caused by a range of situations, such as fumes igniting, local overheating, and so on. Some gauges will sense burn marks after the fact, e.g., by observing the result of a cutting/engraving/marking process with a camera, and using camera vision technique to identify burn marks, e.g., by taking an image before cutting/marking/engraving, an image after cutting, subtract the latter from the former, mask out areas where cutting/marking/engraving took place—and sum up the darkness of the remainder). Other gauges will instead or in addition sense burning during cutting/marking/engraving, e.g., using a camera, a heat camera, a heat sensor etc.
If burn marks are assigned a negative utility in a gauges' utility function, gauges will identify settings that avoid burning, such as using multiple passes of lower “power” (i.e., energy per length) or adjusting the cutting order of individual features so as to prevent heat from building up locally, e.g., by alternating between locations, e.g., when cutting pattern, such as living hinges.
In addition, some gauges may deploy additional processes, such as dispensing moisture during cutting, increasing ventilation, activating (additional) ventilation at the laser head, the release of non-burning gas, or trigger fire extinguishing mechanism [https://www.ulsinc.com/discover-uls-innovations/fire-suppression] and so on.
Finally, gauges may escalate the presence of burning to the user, requesting the user cover the material foil, paper, masking tape, moisture, etc.
Gauges obtain their raw information from at least one sensor. The individual gauges that are part of the present invention may make use of one or more of the following hardware elements, shown in
In addition, the present invention may also feature a moveable camera that traverses the laser cutter recording multiple images or footage, and stitching these into one or more images that covers a larger field of view, such as the entire cutting volume. One way of eliminating motion blur is to add substantial lighting to the cutting volume. Another is to pause the actuation while taking the relevant images. One way of implementing this is by sending a “model” to the laser cutter that places cuts with 0% power at the intended the positions where photos need to be taken. These images can later be identified in footage by identifying the frames where optical flow is close to zero, or where acceleration is between a deceleration and an acceleration (measured using an accelerometer attached to the moving head), or my synchronizing with the actuation system.
Many additional sensors may be used, such as (4) Speckle sensors. (5) Depth cameras, such as structured light, time-of-flight depth camera or similar, Lidar, etc. (6) 3D scanner, e.g., by processing any of the above of similar using a 3D reconstruction software. Additional sensors may include, but are not limited to encoders, laser barriers, switches, sensors that sense the speed and or direction of air movement, smoke detectors, etc.
As mentioned above, laser cutters offer multiple options for cutting material, such as cutting power (e.g., specified as a percentage of the maximum power the built-in laser source is capable of producing or in Watts, etc.), speed (e.g., specified as a percentage of the maximum speed the built-in gantry is capable of moving or in m/s, etc.), and number of passes (i.e., how many times the cutting laser will move along the same path; optionally, passes could differ). Additional factors include the laser's pulse frequency and/or focus length (e.g., relative to the top of the material sheet), and ventilation intensity etc.
By sampling different (cutting power, speed, number of passes, pulse frequency, focal length, ventilation) vectors, a power gauge may identify settings that perform better than others, such as: they still cut through the material, while avoiding burn marks and minimizing cutting time.
One approach to sampling a setting is to cut a shape and the to test whether it has cut all the way through. We will refer to this shape as a swatch. If the swatch is to be evaluated using an optical method (see below) the swatch may have any shape, such as short line. If the swatch is to be evaluated by moving the inset (see below) any closed shape will do, such as a square or a circle.
Different embodiments may use different approaches to verifying successful cutting. Some may observe the swatch's outline using one or more cameras observing the material (e.g., illuminated from the backside in order to highlight the cut), and run computer vision algorithms to extract the cut from the image. e.g., such as a connected components algorithm. If the algorithm identifies more than one component in the area of the swatch (i.e., the perimeter and a separate inset=the swatch), then the swatch has been separated successfully. Other embodiments may observe the cut using a depth sensor from above looking at the cut perpendicular to the workpiece. Yet other embodiment may observe the backside of the material and look for a closed curve there. Yet other embodiments may observe (a small segment of) a cut from the side to see whether the cut extends all the way through).
Another line of embodiments may apply a force to the swatch and observe whether it can be moved separately or removed from the surrounding material. There are multiple ways to apply a force, e.g., by blowing an air jet (or water jet) at it, by pushing or gripping it with a prong, or using gravity, etc.
The setup shown in
Here a dropped swatch 2005 suggests a successful cut, and thus settings of sufficient “power” (as in energy/length). In order to locate swatches over openings, a gauge initially may identify openings in the first place. Some embodiments may do so using manual help from the user (e.g., by users entered coordinates) or in an automated fashion, e.g., by taking a photo of the cutting space while no material is present, optionally correcting for illumination differences, e.g., by subtracting a blurred version of the image, and using a segmentation algorithm (e.g., correct components algorithm) to identify openings, which tend to appear dark in the image.
Gauges may then verify that a swatch has dropped, e.g., by observing the swatch using one or more cameras (e.g., optionally illuminated from the backside in order to highlight the opening or from the front, in order to highlight the material), and run computer vision algorithms to extract the cut from the image, such as a connected components algorithm. If the algorithm identifies a (swatch-size) component in the area of the swatch, then the swatch has dropped. Other embodiments may use different sensors, such as microphones, range finders, etc.
The algorithm starts by positioning (1) When material is present in the cutter, the system locates a piece of material. (2) The system 2101 positions a closed shape, such as a rectangle or circle (aka “swatch”), etc. onto the material over one of the holes in the grid. The shape must be smaller than a hole in the grid, yet ideally large enough to have enough mass to fall in step 4, below. (3) The system 2102 runs the cutter, so as to cut the swatch, and 2103 subtracts the swatch from its model of the material piece. (4) If the laser power is sufficient, the swatch is now separate from the rest of the material and can fall into the hole in the grid. Some embodiments design the swatch to be large and thus heavy enough to drop based on gravity; other embodiments may apply an additional force to make the swatch drop, such as depress the swatch using suction from below, air pressure from above, a prong mounted to the gantry, etc.
2104: The system reads the swatch using one of the sensors listed above (one of the cameras, a range finger, some mechanical prong, etc.) and, as discussed above, 2105 now determines based on the sensor reading whether there still is a surface (suggesting the laser was too weak) or an opening now (suggesting the laser was powerful enough).
Based on this reading the system now adjusts laser power: If the swatch did not drop, the system 2107 increases laser power by step rate (or decreases speed, if already at maximum power), reduces the power step rate (e.g., by a constant factor) and restarts the process by jumping to 2101.
If the swatch did drop, 2108 the system checks whether power step rate is already below margin of power error. If so, the process terminates. Otherwise, it 2107 decreases laser power by the power step rate (or alternatively increases cutting speed by the corresponding amount, unless already at maximum speed) and restarts the process by jumping to 2101.
If the fabrication device is not a laser cutter, the settings to be calibrated tend to be different. For a milling machine, for example, a gauge may need to calibrate (1) the speed at which the milling head is moving through the workpiece (“cutter head speed”) and (2) the rate at which the milling head spins, and (3) the depth. The gauge may thus observe whether a swatch is fully separated from the material surrounding it/whether it drops, judge the quality of the resulting cut (e.g., by observing it using cameras and processing the camera images with a high-pass filter to classify shredded edges), and, in extreme cases, whether the tool head breaks.
Some laser cut models and/or materials require the material to be cut partially, i.e., only to a certain depth. For example, some models fabricated from a sandwich material, such as foamcore, may require cuts where only the top layer, the top two layers, etc. be cut.
The process for calibrating such partial cuts is largely the same as for regular (all-the-way-through) cutting, except the methods for evaluating the outcome of each swatch have to be adapted. In particular, the approach of letting a swatch drop under gravity does not apply here. Instead, the success of partial cutting may be verified by a number of alternative methods including, but not limited to: (1) observing the incision, e.g., using a depth camera or 3D camera or similar type of device largely perpendicular to the incision. (2) Observing an incision placed so as to reach or cross the edge of a part, e.g., using a camera or similar pointed at the edge of the material from the side. Then extract the depth of the cut, which here appears as a length, using computer vision techniques (such as segmentation, e.g., based on corrected components, then obtain length). (3) Observing the incision, e.g., using a camera or similar device largely perpendicular to the incision, while illuminating the material from the backside and measuring the brightness at the incision. This set-up would typically be calibrated by measuring samples with a known incision depth first. (4) Mechanically, by applying a force (as discussed above) or torque or sweep of force or torque. One possible setup features a “tab” (e.g., one partial incision completed into a shape, such as a square by all-the-way-cuts) with an actuated lever trying to break it. The amount of force/torque applied indicates the thickness of the material left. This set-up would typically be calibrated by measuring samples with a known incision depth first.
Laser marking refers to placing visual elements onto the surface of a part with little or no penetration (making it different from laser engraving, which refers to affecting the surface of a part with evident penetration below the surface of the material). Depending on the material, marking may make a surface lighter or darker. (Raster) markings can be produced by traversing a surface (e.g., line by line) with the laser.
Marking gauges sample a subset of the space of {power, speed, number-of-passes, pulse frequency, focus length, etc.} settings in order to identify settings that produce visually distinct results on the material at hand. As discussed earlier, utility functions will typically be a subset or combination to (1) the visual quality of the result, (2) risk of (unintentional) burn marks, (3) completion time, etc.
Accordingly, the swatches of marking gauges tend to be patches that are marked by the laser. These can have any shape. In order to optimize completion time, they may, for example be rectangular. Marking gauges then typically deploy a camera or similar optical sensor as sensor to assess the visual quality of the result, e.g., by taking an image of one (or more) swatches, (optionally, segmenting the swatch from the unprocessed material), and computing the brightness/darkness of the swatches surface in the image or the contrast compared to unprocessed material (captured in an earlier shot or in the same shot in an adjacent area, etc.).
Depending on the markings contained in a model at hand, the gauge manager may deploy different types of marking gauges. Black-and-white marking gauges determine how to obtain a single “color” (i.e., brightness or darkness) distinct from the regular material color, such as the most distinct color. These can be used for models containing black-and-white marking or to render gray-scale by first passing the images through a process that turns it into a black-and-white image, such as dithering or half-toning. Color images will typically first be desaturated and then treated like gray-scale images. Black-and-white marking gages sample a space of settings with a utility function that assigns high utility to visually distinct outcomes.
Grayscale marking gages, in contrast, determine how to obtain a range of “color” (i.e., brightness or darkness) distinct from the regular material color that form a linear brightness gradient. These can be used for models containing gray-scale images (without first passing the images through a process that turns it into a black-and-white image).
One way of implementing grayscale marking gages is to sample a space of settings once for every desired brightness value, with a utility function that assigns high utility to representing that specific brightness value. For performance reasons, however, embodiments more commonly perform the process only once and record the settings producing brightness values along the way until an array of all brightness values required by the model has been filled. To improve performance further, one would typically sample only a few key outcomes, such as settings that produces the most distinct color, settings that produces the lightest color different from regular material (and settings resulting in a few brightness values in between), and fill the rest of the mapping resulting function by means of interpolation. To improve performance further, some embodiments may choose to create multiple swatches or even a gradient at a time.
As mentioned above, laser engraving refers to affecting the surface of a part with evident penetration below the surface of the material.
Engravings gauges are largely identical to marking gauges except for the following differences: (1) Unlike marking, where the outcome was the visual appearance, the outcome of an engraving is the depth of the engraving. (2) Consequently, gauges will deploy sensors capable to sensing depth. A wide range of sensors are capable of doing so, including depth cameras, range finders, physical probes (such as touchprobe [ Antclabs]; to measure. e.g., raise the table holding the workpiece in small intervals until the touch probe makes contact which triggers an interrupt and retracts the probing), and so on. Different embodiments sense depth by placing a swatch at the very edge of a piece of material (e.g., by first engraving and then cutting a cutout across) and then observing the cut using a camera or similar from the side and running the aforementioned segmentation and measuring of the engraving. (3) For models that use engraving for decorative purposes, such as to create a relief, a utility function may satisfy with calibrating relative depth. For models that require a specific depth (such as 2.3 mm), e.g., to mount a technical component into the resulting opening or to remove layers from a piece of sandwich material, such as foamcore, the utility function for these gauges will refer to a specific depth, e.g., expressed in physical units, such as millimeters.
Apart from that, the processes for engravings gauges are largely identical to marking gauges.
In analogy to (raster) markings and engravings that are produced by traversing a surface (e.g., by “scanning” it line-by-line) with the laser, line engravings and line markings are produced by traversing a line with the laser, thus forming vector “graphics”. Line markings and engravings have a range of applications, including, but not limited to (1) fast rendering of information, (2) giving additional contrast to raster markings or engravings by tracing the outlines of key elements.
Line markings and engravings gauges proceed in direct analogy to their raster counterparts, except that the focus length of the laser plays a particular role here. In particular, the line engravings and markings contained in a model may have a particular width associated with them and one way of producing wider lines is by defocusing the laser (e.g., by moving the cutting volume or the laser head up/down). Accordingly, line markings and engravings will commonly also consider line width as an additional part of their utility function. A line markings gauge may evaluate the width of a line in various ways, such as by sensing it using a camera, segmenting (e.g., thresholding and connected components algorithm), and then compute width either by divide surface by length of the line and by determining by how much a line can be erode until the surface turns below some epsilon, etc.
Sensing material thickness is highly useful, as it is not uncommon for materials (especially natural materials such as plywood) to not match their specified thickness. The present invention therefore generally determines the actual thickness of the sheet of material at hand before cutting, applies this to be model (e.g., represented as a cutplan), and then produces the model, which now comes out in higher quality, as finger lengths etc. match up with the materials.
Different embodiments use different approaches to sensing the material thickness. One class of embodiments senses the distance from “above”, such as from the laser head or from the top of the cutting volume, and by subtracting this distance from the distance to the inset in the cutting volume obtains the material thickness. This class of embodiments is thus similar to the engraving gauges in that these gauges deploy sensors capable to sensing depth (see above). Another class of embodiments (cuts the material) and observes it largely from the side, e.g., using a camera or similar, allowing it to observe thickness directly (e.g., with directional lighting to produce contrast, take image, threshold image, segment image, e.g., using connected components, measure thickness directly or surface of component divided by width, or increase erosion until remaining surface drops below some threshold epsilon).
Materials may be of inhomogeneous thickness. Some material thickness gauges may therefor take multiple samples. The placement of these samples may be placed where they impact the model less, e.g., along the edge of the material, or fit into natural gaps in the cutting plan, as placed by the nester.
Material gauges are different from the gauges listed above in that many gauges do not cut the material, but often simply observe it.
Most embodiments consider material recognition a classification problem. While some embodiments may try to classify a material in the void, most embodiments will obtain better results by narrowing down the set of candidates, i.e., by answering the question “out of this given set of candidate materials, which candidate material resembles the observed material most.”
The classification generally consists of two main steps: (1) feature extraction and (2) classification.
For feature extraction some embodiments employ optical sensors (e.g., mounted to the laser head or mounted stationary in the cutter), such as cameras, then extract one of more aspects of color (e.g., hue, saturation, and/or value or similar) as well as texture features, such as image frequencies, visual features, etc. Alternatively, speckle sensing can be used to produce additional features (sensi-cut [Mustafa Doga Dogan et al. SensiCut: Material-Aware Laser Cutting Using Speckle Sensing and Deep Learning, In Proc. UIST '21. 24-38]). Other sources of features include, but are not limited to microphones combinations listening to the material's response to a frequency sweep by a speaker attached the material or by a prong tapping the material, and so on.
Based on the features extracted above, classification can be performed. While it is possible to do so by hand, most embodiments will choose to perform this using one of many applicable machine learning techniques, ranging from k-nearest neighbor to deep neural networks and anything in between.
Multi-layer material gauges classify multi-layer/sandwich materials, such as foamcore. One way of doing so is by observing the material from the side (as discussed above) or by cutting dips or depth gradients into the material, and then observe the individual layers from above.
When laser cutting 3D models, precision plays a central role. The reason is that 3D models consist of multiple parts, held together by joints-most commonly intersecting slits called cross joints or interlocking fingers called box joints. To allow joints to hold without glue, parts are designed to overlap by a tiny amount, such as 100 μm for certain types of wood. This allows users to assemble such press fits by forcing parts into each other, which causes the natural springiness of the material to hold the parts together. This is what requires precision, i.e., if dimensions are not precise within 100 μm, the resulting model, such as the lamp shown in
However, reaching this precision is complicated by the fact that all dimensions are impacted by a second factor: laser cutters burn off a certain amount of material during cutting, the width of the removed material being known as kerf. In order to achieve a functional press fit, the dimensions of parts sent to the cutter thus need to first be made wider (or “dilated”) by the expected kerf in order to achieve the desired dimensions after kerf. This requires users to figure out kerf prior to cutting.
Unfortunately, determining kerf turns out to be a challenging process. Today's technology enthusiasts (aka makers) commonly determine kerf using the following four-step process: (a) They cut a specifically designed “kerf strip”, (b) remove the kerf strip from the cutter and insert a separate part of it into a number of matching openings, thereby identifying the opening that fits best. Users then read the kerf value from the associated scale (e.g., 50 μm steps) and enter it into the system. (c) Users then dilate the cutting plan by kerf, e.g., using a vector editing program or using specialized laser cutter modeling software, e.g., FlatFitFab [James McCrae, et. al. 2014. FlatFitFab: interactive modeling with planar sections. In Proc. UIST '14, 13-22] or Kyub [Patrick Baudisch, et. al. Kyub: A 3D Editor for Modeling Sturdy Laser-Cut Objects. In Proc. CHI '19. 1-12]) and, finally, (d) cut the actual model.
This process is rather imprecise with 50 μm steps in order to keep the size of the kerf strip feasible, time-consuming (about 5 min for 4 mm MDF on a Trotec Speedy 360 [https://www.troteclaser.com] using FlatFab [http://flatfab.com), and rather laborious in that it requires users to run the laser cutter twice instead of once. This user effort is compounded by the fact that the procedure must be repeated periodically, potentially for every single model, to account for variations in material, power, and speed settings, as well as for the wear of laser, air compressor, and lens [Uslan, I. CO2 laser cutting: Kerf width variation during cutting, In Proc. of the Institution of Mechanical Engineers, Part B: Journal of Engineering Manufacture, 219 (8), 571-577] [https://hackaday.io/project/164156-lp3d-a-fully-lasercut-kit-3d-printer] (see Section 6). Furthermore, worse than that, this 4-step process requires expertise, which raises the bar and commonly excludes non-expert users from laser cutting.
The present invention alleviates this problem by providing automated kerf gauges.
9.1 Kerf Gauges that Measure Kerf without Applying a Load
Some embodiments of kerf gauges assess kerf in the absence of a force. These can, for example, be useful when calibrating for parts that will not be subjected to forces during operation. One class of embodiments achieves this by cutting an appropriate swatch, which could be as simple as a line, and then observe and measure the resulting cut.
The sensor equipment and process for doing is very similar to the equipment and process used by cutting gauges and line engraving gages. Different embodiments may use different approaches to measure kerf. Some may observe the swatch's outline using one or more cameras observing the material (e.g., illuminated from the backside in order to highlight the cut), and run computer vision algorithms to extract the cut from the image, e.g., such as a connected components algorithm, then measure the thickness of that component as debated earlier. Yet other embodiment may observe the backside of the material (e.g., my propping the material up), process using computer vision algorithm, e.g., binarize image by thresholding, run connected components, read smaller dimension=width of segment that is the line. Yet other embodiments may observe (a small segment of) a cut from the measure the width of the cut.
Kerf commonly features a tapered shape (wider on top, narrower towards the bottom). Yet, it is most commonly handled as a single dimension. Consequently, a kerf gauge may have to condense the observed taper into a single dimension. Different embodiments may employ different approaches, each one expressing a different interpretation of kerf, such as measuring the narrowest passage, measuring at a specific height, such as the bottom, using statistical means, such as computing the mean or median width, and/or applying various offsets or an offset proportionally to the compliance of the material (e.g., to simulate deformation a load might cause, as would be the case when assembling parts using press-fit joints).
Other embodiments of the instant invention aim at measuring kerf while a certain force is being applied, ideally the amount of force that reflects the intended use case. If, for example, two parts are supposed to be forced together in the form of press fit finger joints with the help of a rubber hammer, then a kerf gauge might want to measure kerf while a corresponding amount fore is being applied.
Kerfmeter attaches to the head of a laser cutter. (a) When the user sends a model to the laser cutter. Kerfmeter intercepts the job, injects an automated calibration routine that starts by cutting what we call a spiral gauge, (b) inserts its pair of prongs into the spiral gauge, and rotates it until it jams. Kerfmeter reads the angle θ at which this takes place using an encoder. This angle indicates how much material the laser has removed, i.e., the laser's kerf. (c) Kerfmeter triggers the dilation of the model by kerf, and (d) proceeds to fabricate the model. (e) Its kerf-calibrated joints make the model loose enough to allow for comfortable assembly, yet can also tight enough to resist tension, such as when suspending the model.
Kerfmeter consists of two components: first, a hardware component built into the laser cutter, which measures kerf, and second a software component, which acts as a server, controls the laser cutter, and dilates the cutting plan. Kerfmeter starts by the user sending a model to the cutter. This triggers the following automated seven-step process.
We now explain the engineering requirements, the underlying technology, the geometry, and the math.
The microcontroller communicates with Kerfmeter server through a serial connection over USB.
Error! Reference source not found. Error! Reference source not found, illustrates the space of alternative embodiments. While this disclosure, for consistency reasons, focuses on the specific embodiment shown at the very right (which we refer to as Kerfmeter in this disclosure), all of these embodiments are kerf gauges and considered part of the invention.
(a) Embodiments that do not apply a load can be implemented using a contactless sensor, such as a camera, a range finger, etc. (b) We achieve embodiments that measure in the presence of a force (e.g., the amount of force exchanged at the interface of a joint) by applying a force of appropriate magnitude during measurement. This can be accomplished using a range of devices, such as devices targeting a compressed gas or liquid at the contact surface or push a solid against it, etc. (c) We can do so using a device that applies a compression between or tension largely perpendicular to 2901 the involved surfaces, e.g., using 2902 a micrometer or calipers or similar. (d) Alternatively, we may apply a force largely tangential to the involved surfaces, e.g., as a way to more adequately represent the type of movement and force exchanged when assembling certain types of joints, such as box joints. (e) Some embodiments produce one single type of swatch simulating some sort of joint, such as 2903 a box joint of finger joint and measure the force required in order to assemble this one. In contrast, (f) other embodiments use parts at least one of which features a wedge shape, so that sweeping a range of forces, allows measuring the mapping between force and displacement. This approach helps extract the forces emerging at cross joints, at box joints, after the fact.
(g) Some embodiments insert a 2904 (e.g., reusable) wedge (e.g., made from a piece of the material, but more commonly from a hard material, such as steep or ceramics, etc.) into a cutout from above. Some of these require placing the 2906 opening in the material over an 2907 opening in the grating, so as to allow 2905 the wedge to be inserted more deeply. This approach is particularly useful when for calibrating the insertion of objects, such as motors, rods, etc. into the material (in which case, fidelity can be increased by making the wedge from the material of that object to be inserted—or the wedge may simple be (a copy of) the object to be inserted; for objects with a specific insertion mechanism, such as screws or bolts, 2908 a corresponding insertion mechanism may be used). (h) Other embodiments fabricate both halves of a joint, which is achieved most easily by fabricating 2909 both halves “in-plane”. This approach allows measuring the relationship between two pieces of the material, which is one approach to representing joints (such as box joint and cross joints etc.) in high fidelity. Fabricating in plane also reduced the risk of accidentally pulling the material sheet upwards upon release.
(i) Within the plane, different embodiment may employ different types of movement so as to insert one part into the other, such as a “cartesian approach” of sliding one part linearly into the other. Such a force can be produced using a range of mechanisms, including (assuming strong enough) the gantry of the laser cutter itself. (j) Other embodiments use a rotary movement, which can be produced, e.g., using (geared) motors.
(k) The 2910 resulting design is subject to a horizontal net force upon release. (l) Some embodiments may cancel this force out by using a 2911 second (or more) mechanisms that operate in opposite directions. (m) Some embodiments may opt for an 2910 incline/wedge shape, which allows obtaining a mapping by means of performing a sweep; it also offers a mechanical advantage. (n) Some embodiments may choose to produce an interface between the two parts that forms an edge, which can be accomplished with a wide range of shapes (o) Other embodiments, may choose to produce a surface as interface, e.g., so as to resemble the spatial relationship between the parts of a box joint or cross joint. For the spiral design, for example, this can be accomplished using an 3001 Archimedean spiral.
When operated stand-alone, the Kerfmeter server software, which is running on a computer connected to the laser cutter via serial over USB, talks to the modeling software (in the case of our prototype, this is kyub [Patrick Baudisch, et. al. Kyub: A 3D Editor for Modeling Sturdy Laser-Cut Objects. In Proc. CHI '19. 1-12]), and the laser cutter driver (in the case of our prototype Trotec Ruby [https://www.troteclaser.com/en/laser-machines/laser-software]), as illustrated by
When the user exports a model in the modeling software (in our case kyub [Patrick Baudisch, et. al. Kyub: A 3D Editor for Modeling Sturdy Laser-Cut Objects. In Proc. CHI '19. 1-12]), the modeling software sends information about the material thickness and the desired assembly force to the Kerfmeter server via a WebSocket connection. The Kerfmeter server responds by sending the material information to the laser cutter's REST API. It then sends a vector drawing of the spiral gauge to the laser cutter, which starts fabricating it.
As discussed earlier, when the spiral and holes have been cut, the Kerfmeter server positions the laser head over the spiral shape and programmatically raises the cutting table by sending the according move commands to the laser cutter REST API to insert the prongs into the holes in the spiral inset. It then sends the start command with the specified force and finger length to the Kerfmeter device via the serial connection.
The Kerfmeter device continuously reads the encoder, adjusts the target torque, and finally reports force and rotation angle pairs back to the Kerfmeter server, allowing it to calculate kerf, which it sends back to the modeling software through the WebSocket connection, which in turn triggers the dilation of the cutting plan. Finally, this cutting plan gets sent to the Kerfmeter server, which forwards it to the laser cutter, where it gets fabricated.
Kerfmeter provides this functionality by means of an application-independent API that offers three calls: run_kerfmeter( ) actuates the spiral gauge, get_kerf_value( ) retrieves the measured kerf value, and reset_kerfmeter( ) resets kerfmeter to its zero position. All functions are implemented as python scripts using the simple_rpc library [https://github.com/jfjlaros/arduino-simple-rpc]. These three API calls allow integrating Kerfmeter into arbitrary laser cutting design systems, such as flatFab or Onshape, as well as kyub.
As mentioned earlier, the spiral type that archives the desired self-similarity is an Archimedean spiral [Archimedean spiral. https://en.wikipedia.org/wiki/Archimedean_spiral. Accessed September 2022]. Its curve is described by the polar equation r=b·φ+a where r is the radius of the spiral, b is the distance between loops, and a is the distance from the center to the start of the spiral. φ defines the angle of rotation for each point on the curve. We represent all angles in degrees throughout this disclosure. Rotating the spiral inset causes it to “grow” based on the formula kerf=b·θ where θ is the rotation angle, as measured by Kerfmeter's encoder. We determine the spiral parameter b as b=maxKerf/maxRotation Using a manual kerf gauge, we empirically determined kerf values on our cutter to lay well below maxKerf=430 μm in wood and MDF materials (in our Trotec 360). Note that proper maxKerf highly depends on the lens, and laser power of given laser cutters. Once maxKerf is known, any laser cutter can use this spiral gauge by changing the parameter b. The inset of the spiral geometrically disengages like
The two holes on the spiral gauge are also subject to kerf, allowing the motor and encoder to rotate before engaging the spiral inset.
Our Kerfmeter software compensates for this error by solving the following recurrence:
where a is the spiral constant, and kerf′ is the result of the previously calculated kerf value.
Finally, the Kerfmeter workflow from Section 2 requires translating back and forth between the motor torque t applied to the spiral gauge and the force F required to assemble box joints. This conversion is governed by F=μPEAJ [https://www.meadinfo.org/2009/07/press-fit-pressure-calculator-optimize.html], where μ is the coefficient of friction of the given material and PE is the pressure between joint and joint, which depends on the material's Young's modulus and strain, as well as the sum of the contact areas of the box joints AJ.
The torque τ is defined as τ=μPE (2π−2θ)r2·L, where θ is the angle of rotation, r is the radius of the spiral gauge, and L is the material thickness, as illustrated by
This model requires Kerfmeter to apply a well-controlled torque, which we produce by varying the length of the pulse-width modulation duty cycle. As illustrated in
The Kerfmeter device, as described above gives us a kerf value. However, kerf is just a means to an end—and that end is to calibrate engineering fit or simply “fit”. To apply Kerfmeter, we need to have a sense of what fit values we should be aiming for. In order to find out, we conducted a simple user study in which we had participants assemble box joints by forcing one part of the joint into its counterpart, which we had attached to a digital force gauge. We then measured how much force they were willing to apply. We found that all participant managed to assemble all box joints requiring about 100N of compression force. At the same time, someone skilled in the art would know that users are capable to applying much higher forces when hey use tools, such as a rubber hammer to drive parts together.
When picking what force to aim for, we need to consider that mechanical devices, including the gantry inside the laser cutter, support only a limited precision. This is also known as positioning accuracy or repeatability and it typically stated by the manufacturer. The Trotec Speedy 360 laser cutter, for example, offers a repeatability of +15 μm. Consumer devices, such as the laser cutters made by Glowforge offer repeatability substantially worse than this. On the other hand, there are specialized laser cutters that offer repeatability of around ±1 μm.
Some types of cutting tasks incur repeatability multiple times. When cutting a square, for example, the width of that square is subject of up to 2× repeatability: one for the left and one for the right edge, thus ±(15 sqrt(2) μm=±21.2 μm for the 95% confidence interval (assuming the repeatability of each edge to be statistically independent). When cutting box joints, repeatability can come into play up to four times. This gives the overlap, i.e., the aforementioned interference, ±30 μm for 95% confidence interval.
In the case the example of the Trotec laser cutter: (1) the repeatability of the gantry introduces a standard deviation of 10.6 μm as we measured the width of the rectangle. (2) This compounded with variability caused by the cutting location, i.e., an additional standard deviation of 13 μm (on the Trotec cutter; substantially worse on the two other cutters). (3) We now have a sense of the variation resulting from the machine alone (i.e., without any kerf strip or Kerfmeter): the machine produces a standard deviation of sqrt(10.62+132)=16.7 μm.
This number is non-trivial, as it is not too far from, for example, the 50 μm steps that form the basis of the kerf strip's scale [https://elplatt.com/laser-cutter-kerf-gauge]. This sets our expectations for kerf calibration: a highly precise laser cutter (for example, ExactCut 430 Coherent advertises repeatability of 1 μm) would allow us to aim for a specific fit; we might, for example, aim for maximum stability by setting the intended assembly force close to the human limit determined above.
However, the use of less specialized machines produces data that tells us that we need to be more conservative. Our primary objective has to be to stay within the interval of acceptable fit values in either direction: we neither want to run the risk of making a model impossible to assemble, nor do we want to run the risk of joints falling apart.
Some we should therefore aim for the center of the assembly force interval.
Note that this observation and the resulting strategy is only based on our analysis of laser cutter hardware. These insights therefore apply to any kerf strip to the same extent they apply to Kerfmeter.
Now that we have defined our strategy for picking a fit, we are ready to evaluate the performance of Kerfmeter.
While specialized machines that offer one-micron repeatability are available, the more affordable machines used in fablabs, makerspaces, and most work places in industry, do not offer the repeatability required for making joints fit reliably.
Automated kerf measurement, however, can help.
Kerfmeter performs its task in fully automated fashion while also consuming substantially less material than the traditional kerf strips. This lowers the bar for performing multiple measurements. Some embodiments may choose to exploit this in order to increase the precision of the device further so as to surpass the precision of manual kerf measurement substantially, as repeated measuring allows us to counteract the limited repeatability of the cutter.
The fact that we can increase precision by measuring multiple times is based on the observation that limited repeatability hits precision twice: During calibration and during fabrication. In the worst case, repeatability errors in one direction during calibration and in the opposite direction during fabrication, allowing both errors to accumulate. We can reduce repeatability issues during calibration by running the calibration device multiple times.
Running Kerfmeter (or any kerf calibration tool for that matter) twice lowers the effect of limited repeatability by a factor of sqrt(2), i.e., from ±15.5 μm to ±11 μm. Sampling 3 times increase precision further to ±8.9 μm. Given that limited repeatability turned out to be the main limitation of kerf calibration, we feel multiple measurement are worth pursuing.
We hereby disclose another approach to reducing the negative effects of limited repeatability: cutting multiple times.
Cutting in multiple passes is a known technique in the laser cutting domain, but not for this purpose: Architectural model shops tend to laser cut cardboard in multiple (lower power) cuts in order to reduce the risk of burn marks. They also tend to laser cut polystyrene foamcore in multiple passes in order to reduce shrinkage of the foam layer. In the domain of optics and laser physics, double-pass cutting was found to produce higher-quality cut surfaces and less burning than single-pass cutting in glass-fiber-reinforced polymer material [Choudhury, I. A., and P. C. Chuan. “Experimental evaluation of laser cut quality of glass fibre reinforced plastic composite.” Optics and Lasers in Engineering 51.10 (2013): 1125-1132.]
We disclose a different process and use case: we found laser cutting in multiple passes, while widening kerf, to reduce the variance of kerf, thus combatting the effects of limited repeatability.
Even better results can be obtained using a closed-loop approach. In this approach, the 2601 system retrieves only the initial settings to 2602 produce the first set of samples and 2603 measures the kerf for these samples, calculates the variance between them and aggregates them. Until the 2605 variance is lower than a given threshold, the 2604 system derives settings for the next set of samples from the previously retrieved values. Once the set variance is met, 2606 the system outputs the settings with the lowest variance.
With the same reasoning, Kerfmeter makes it more feasible to measure kerf across cutting locations in the laser cutter. This allows us to compensate for variations in kerf across locations inside the cutter.
So far, we have been describing calibration processes based on samples of the actual material in the actual laser cutter, which one would generally expect to produce the most realistic results. However, some embodiments may also support calibration based on information obtained with different materials and/or on a different laser cutter.
In order to make use of calibration information obtained with different materials and/or on a different laser cutter, we apply a function that translates this information to the material and machine actually to be cut. Approaches include, but are not limited to: (a) translate the found sensor values into the sensor values one would have found had one tested with the actual material and then translate these to the adjustments of laser cutter settings and/or model adjustments necessary. Or (b) translate the found sensor values into adjustments of laser cutter settings and/or model adjustments necessary, or (c) translate the found sensor values and the properties of the material measured and the properties of the material actually to be cut directly into the adjustments of laser cutter settings and/or model adjustments necessary.
Some embodiments may perform these translations by hand and may compute the “similarity” between two sheets of material in various ways, such as, such as by computing the similarity between the feature vectors of each material (Error! Reference source not found), e.g., using the cosine measure [https://en.wikipedia.org/wiki/Cosine_similarity]).
Based on such a similarity metric, we can now predict calibration information by aggregating calibration information from one or more samples considered similar, typically weighted by their degree of similarity.
Some embodiments extend this approach further by also including a feature vector describing the laser cutter on which the sample was assessed. The resulting system, may now aggregate calibration information from similar materials on the current cutter with very similar materials on a somewhat similar cutter, etc. (e.g., by means of a centralized server or decentralized architecture, such as blockchain). The approach of considering calibration information obtained on other machines and thus likely by other users also helps bootstrap calibration.
Most embodiments, however, will instead perform the translation of calibration information using one of many applicable machine learning techniques, ranging from k-nearest neighbor to deep neural networks (DNN) and anything in between. To apply these methods, we train a system, with the calibration data obtained previously, such as in the form of the aforementioned feature vectors of each material, the features of the machine it was obtained on, and with the calibration data this configuration produced. We then query the system with the feature vector of the material at hand and the laser cutter at hand.
If a prediction made by any of the methods described above is well supported (e.g., large number of samples considered, small variance between samples) a calibration system (e.g., the gauge manager) may decide to forego an actual calibration with physical material and instead run with the predicted information. If a prediction is less well supported, systems may decide to still run a physical calibration process, albeit limiting it to a smaller set of settings centered around the predicted values.
Finally, as fallback some embodiments may support even less fortunate configurations, such as:
Ultimately, i.e., upon fabrication, a model has to be mapped to an actual “sheet of material” (see “nesting”).
We use the following nomenclature. Sheet: a specific physical piece of material. Commonly rectangular, but could be any shape. Commonly flat, but, e.g., in the case of a 5-axis or 7-axis fabrication machine could be any 3D shape. Sheets may be unused in which case they bear their original shape or they may be partially used, in which case they bear one or more cutouts, e.g., from where parts for earlier models have been fabricated. Batch: sheets may have been acquired individually or as part of a batch. Material: all sheets of the same formal specification by the same manufacturer, such as “8 mm, 5-layer birch, manufactured by vendor X”. Class of materials: all sheets of the same formal specification.
In some cases, users may assign an actual piece of material already while designing a model. This makes sense, for example for artists, who might consider the specific texture of the material as essential for their art piece. They may also pick the actual portion and orientation of a piece of material for that matter.
Some embodiments may allow users to pick such as a piece of material in the physical world and then make it show up in the application subsystem (e.g., by scanning it, see below) and/or allow users to pick out a piece of material in the virtual world and then help them locate it in the physical world (using markers, see below).
11.2 Replace Actual Sheets of Material with Other Sheets of Material
When another copy of this object is being fabricated, by the same user or by a different user. e.g., by sharing, e.g., on the Internet, the original piece may have been used up, so a different piece has to be picked.
Some embodiments may therefore offer substitutes, typically a close match according to some similarity metric, such as (a) another section of the same sheet of material, (b) another sheet from the same batch, (c) a sheet from another batch of the same type by the same vendor, (d) a batch of the same type from a similar vendor, or (e) a sheet from a similar batch from the same vendor, (f) a sheet from a similar batch from a different vendor, and so on . . . up to (g) a completely different material.
Systems may compute the “similarity” between two sheets of material in various ways, such as, such as by computing the similarity between the feature vectors of each material, e.g., using the cosine measure [https://en.wikipedia.org/wiki/Cosine_similarity]). This matching can be further improved by assigning each feature a weight reflecting the importance of that feature in the context of use in the model at hand.
Other embodiments may compute similarity between material sheets in two steps: First replace actual sheets with “classes of materials” (see below) that express the purpose performed by the sheet in its context in this model. And then, e.g., upon fabrication, translate that “class of materials” back into (different) actual sheets.
In other scenarios, users may just want to give their models or individual parts of their models some specific functionality (which could then be fulfilled later by a range of different actual sheets). Application programs may therefore allow users to assign a “class of materials”. A class of materials is essentially a query that different actual sheets match to different extents. Examples for classes of materials include “birch”, “birch 8 mm”, “8 mm”, “plywood”, “3 layer”, and so on and/or may also describe qualities material are supposed to offer, such as (a) a specific optical quality, e.g., clear acrylic to form cover of a box the contents of which is supposed to be visible from the outside or frosted acrylic covering a set of LEDs in order to form a diffuser, (b) a specific acoustic quality, e.g., by picking solid spruce for the soundboard of their guitar or Okume plywood for the tapa of their cajon, or (c) a specific structural quality, e.g., by picking 8 mm marine plywood for the seat of a chair, (d) specific weight, e.g., by picking foamcore for an airplane model. (e) compliance, e.g., to make a make a unicorn model with rounded surfaces, (f) foldability, e.g., to form hinges for a compliant mechanism, (g) water resistance, e.g., acrylic for a boat, (g) heat conductivity, (h) electric conductivity, (i) a specific look, such as to create a red plastic box, (j) price, and so on.
Classes of materials are a way for the designer of a model to express that not only one specific material or sheet is acceptable, but that a number of materials sharing some attributes might be suitable. One might thus say that picking a class of materials conveys (1) information about (some aspects of) the desired material as well as (2) a rudimentary “weight function” describing the intended purpose in that a criterion, such as “5-layer” may either be in the class definition, making it relevant, or outside of it.
Specifying a less specific class of materials declares more actual materials as appropriate, thus makes it easier for the system or users to locate appropriate materials when fabricating the model. This tends to be appreciated especially when sharing models. Also, since the (class of) material names are inherently shorter, it allows for a simpler and “friendlier” user interface, especially suitable for non-expert users.
Actual materials may either by picked by users who then have to inform the system about their choice (so the system can map the model to it), or by the system, which may then want to inform the user about its choice (so that the user can place the correct sheet into cutter).
Different embodiments may employ different workflows to allow users to pick materials:
(1) Early physical possession: before starting the fabrication process, users may gain physical possession of (a superset of) the sheets they consider using. The workflow shown in
Users start by reserving one or more sheets 5201. Users may do so by taking physical possession, (e.g., taking these sheets to a dedicated location), by marking the sheets (e.g., by applying a sticker, a post-it note, etc.), by simply informing others that they have reserved these sheets, or, in cases where there is no ambiguity in the first place, by doing nothing.
At some point in time, users may then register the reserved sheets with the system 5202. They may do so by scanning the sheets using a device capable of registering information, e.g., by using a specialized app or website on a mobile phone. Information gathered in this process is transferred to the system as described in 5203.
Alternatively, users may scan using a generic scanner, such as a generic QR code scanner or camera app on a mobile device. This may trigger an action (e.g., opening a specialized website or app, invoking an API call etc.), processing and transferring the given information as described in 5203. Alternatively, the user may enter the information decoded by the generic scanner, or information gained in any other way (e.g., a sheet ID contained on an attached marker as exemplified 5101 manually into the system (e.g., by using a search interface or by filling out a form, etc.).
In all embodiments in which the user is not already logged in when the sheet ID is provided to the system, users may provide their user identity retroactively or during the scanning process by, e.g., logging in during or after scanning, selecting their identity from a list of users, using a code with potential temporal validity retrieved on a device where they are already logged in, or allowing logged-in users to attach their identity to sheets reserved for an unknown user. The system may also be able to identify the user without additional interaction, e.g., by utilizing device identifying information (e.g., MAC address) to match the scanning device with a device previously attached to a specific user.
The scanning system now transmits the sheet IDs to the application subsystem 5203, directly or by means of the laser cutter subsystem or any piece of other information processing software capable of forwarding information. Any system may include additional information including, but not limited to, the location, the time, or the IP address of the device. If the user ID was known at scanning time it may or may not be transmitted together with the sheet IDs.
The application subsystem processes the received information 5204. It may mark the sheets identified as being reserved, possibly adding additional information such as the reserving user if it is present. Alternatively, the incoming data may be processed with or without storing it prior or after additional processing steps. Additional processing may include but is not limited to modifications to other data in the system (e.g., updating the sheets' location based on location data included in the received metadata), or determining a potentially unknown user's identity utilizing the metadata.
(2) Scan in the laser cutter: in this embodiment, the sheets used during fabrication remain vague including the moment when the fabrication job reaches the laser cutter. Users may take possession of one or more actual sheets of material and place them into the cutter (before or after sending the model to the laser cutter). The laser cutter subsystem then identifies the sheets as described below.
If the model lists this particular sheet as its material the system may proceed to cut. If the model lists a class of materials that matches the actual material at hand, the system may replace the class of materials in the model with the actual sheet hand and then proceed to cut. If the material lists a different actual sheet of material or a class of materials that does not match closely enough, the laser cutter subsystem may alert the user.
The system may identify sheets of materials using various methods, including, but not limited to the following:
If a model listing a particular sheet as its material is sent to the laser cutter the laser cutter subsystem may request the user to provide this particular sheet. To simplify the user's job of locating the sheet, the system may provide the user with a description of the desired sheet, such as “birch 8 mm 5-layer”. This information may be sent to the user by the application subsystem, by the laser cutter subsystem directly on build-in or connected displays or leveraging the user's computing infrastructure, e.g., by sending a text message to the user. Once the user inserts the correct sheet(s) into the laser cutter the fabrication process may start (automatically or after manual confirmation).
Similarly, when sending a model using a class of materials off to a laser cutter subsystem, the system may map classes of materials to actual sheets, in which case users will again then be asked to locate these sheets as described above.
As an alternative to letting the system map the classes of materials in a model to actual sheets, users may manually map classes of materials to actuals sheets of material. Manual mapping can be useful, especially when mapping part that perform a specific function in the model at hand. A piece of frosted acrylic, may, for example, act as an optical diffuser or as a soundboard or tapa in a cajon. In the first case, it may best be replaced with paper, in the second with clear acrylic. Since an automated system may be oblivious to this hidden logic, manual mapping might be useful.
Some embodiments may provide additional ways of selecting actual sheets for display, such as by promoting sheets of material to the top of the list when the actual physical sheet gets scanned.
Once a model has been mapped to one or more actual sheets of material, the actual size and shape of the sheets has been defined. Next, the user and/or the system may want to arrange the parts that form the model onto these sheets. Different embodiments may optimally apply a layout strategy (such as roadkill [Abdullah et al. Roadkill: Nesting Laser-Cut Objects for Fast Assembly. In Proc. UIST '21, 972-984]). Users may then choose to nest automatically (e.g., using SVGnest). Or manually, such as using a direct manipulation as shown in
While the calibration apparatus presented so far used two distinct phases (calibration und then fabrication of the model) some embodiments may choose to perform calibration while fabricating the model.
The main idea is to at least initially produce all effects using a multi-pass process that starts with too weak an effect (cutting does not go all the way through, engraving too shallow, marking too faint, cutouts too small, and so on) but then obtain the desired effect size by means of additional passes that wither pile onto what is already there (cut on top of a cut already there, engrave on top of the already existing engraving, mark on top of the already existing mark) or replace with a larger version (place a dilated cut out onto the cutout already there).
In order not to avoid damaging the model in the process, such a calibration real-time calibration procedure will generally want to act in a risk-averse fashion (1) initialization of parameters based on risk-averse estimate, i.e., one that might produce “too little” of an effect, but does not produce “too much” of an effect. (2) fabricate an element that is part of the model. (3) sense: Use sensors, e.g., built into the machine, to verify whether the effect size falls into the acceptable range for this parameter. (4) Decide: If the value is below the acceptable range for this parameter, (5) Increment: Based on the size of the sensed effect, compute the increment as conservatively estimate the correct value minus the value already performed-so that the combined effect is expected to land in or below the target range, and go back to step (2). (6) Replacement: if the algorithm ever accidentally overshot, the algorithm discards that part (it may optionally indicate this visibly to users, e.g., by marking the part or cutting it up), locate a previously unused area of material and create a new copy with lower settings.
Another embodiment of this approach is to start by performing a regular calibration phase as presented earlier, but still monitor the fabrication progress as it unfolds using one or more sensors and respond when necessary for closed-loop control. The response may include (a) an immediate repair or replacement and (b) an adjustment of settings so as to reduce the risk of the issue repeating itself.
Different embodiments may monitor different aspects, such as (1) a system may respond to detecting burning by replacing burnt parts or by taking measures to stop burning before it exceeds the threshold for acceptable burn marks, such as by pausing the cutting process to allow the material to cool down, dispensing moisture. The system may then switch to a process less prone to burning, such as multi-pass cutting, adjust ventilation, etc. (2) A system may respond to detecting material not being cut through by repairing the incomplete cut with an additional pass, then increase power, lower speed, or increase the number of passes, etc. (3) Similarly, a system may respond to detecting engravings that are too deep or not deep enough, markings that are too dark or not dark enough, and so on.
This application is a Patent Cooperation Treaty (PC) International Application claiming the benefit of U.S. provisional patent application Ser. No. 63/306,035 filed on Feb. 2, 2022 and U.S. provisional patent application Ser. No. 63/362,657 filed Apr. 7, 2022, which are incorporated by reference herein in their entirety.
| Filing Document | Filing Date | Country | Kind |
|---|---|---|---|
| PCT/US2023/012244 | 2/2/2023 | WO |
| Number | Date | Country | |
|---|---|---|---|
| 63306035 | Feb 2022 | US | |
| 63362657 | Apr 2022 | US |
