Additive manufacturing using build process with inert local slicing

Abstract

A computer-implemented system and method is provided for generating an additive manufacturing (AM) build program that is used to build an object having a manifold boundary. A manufacturing definition module merges build information for manufacturing definition and AM machine mode information. The build information includes a specification of building parameters based on the region, and the machine pattern information includes AM machine-specific parameters associated with layer-by-layer material build. The slice generation module executes a direct slicing algorithm of a 3D CAD model defining a geometry of the object, where slices of the model are defined according to a layer thickness in a slice direction. The region-based recipe module is configured to generate annotated slices, where each slice is annotated with information based on a manufacturing definition. The annotated slice is sent to an edge computing device that controls the AM machine to convert it into a final build file with a tool path and process parameters.

Description

Technical Field

[0001] This application relates to computer-aided manufacturing (CAM). More specifically, this application relates to a CAM-based process that generates a sliced build plan for additive manufacturing. Background Art

[0002] Additive manufacturing (AM) processes enable the co-design and fabrication of complex geometries and heterogeneous materials. Currently, these geometries based on large-scale complex heterogeneous materials are faceted, sliced, and converted into build files that contain the parameters and instructions required for the AM device to build the material layer by layer. The processing of complex geometries and the transmission of build files have become a memory burden for design applications, manufacturing process planning applications, and manufacturing hardware in finally producing these complex designs. The problem is that the current modes and file requirements of AM build processors are too strict, and the geometries and manufacturing parameters must be explicitly represented.

[0003] In AM design, the use of lattices of different types of unit cells and / or lattices defined by implicit functions helps to reduce material usage while maintaining key strength / stiffness. As the number of unit cells increases or the overall geometric complexity rises, the generated polyhedral models become difficult to handle because they may contain trillions or even more faces. Such a large number of faces results in extremely large file sizes (exceeding 4GB), making the files difficult to send, store, or process. In addition, before creating tool path commands in the build file, these polyhedral models can be sliced and stored as intermediate polyhedral model files. Then, extremely large build files (about 100GB) are sent to the AM machine. Due to the very large file sizes, they may be split into multiple parts for multiple builds / runs on the AM machine, which leads to alignment errors and cumbersome work. Some research has proposed directly slicing CAD geometries without an intermediate polyhedral model file. However, these CAD geometries are not highly complex (e.g., in the case of containing billions of lattice unit cells), and their main purpose is to reduce the inaccuracies generated when creating polyhedral model files. Summary of the Invention

[0004] To overcome the limitations of existing build file generation, a method and system are disclosed that provide a flexible build processor for AM of highly complex geometries, which uses a lazy, local slicing and building method without creating intermediate polyhedral files.

[0005] According to a first aspect, there is provided a computer-implemented system for generating an additive manufacturing (AM) build program for building an object conforming to a manifold boundary volume. The system includes a processor and a memory having modules stored thereon with instructions to be executed by the processor. A manufacturing definition module is configured to merge build information for manufacturing definition and AM machine mode information. The build information includes a specification of region-based build parameters, and the machine mode information includes AM machine-specific parameters related to layer-by-layer material build (e.g., deposition). A slice generation module is configured to perform a direct slicing algorithm on a 3D CAD model that defines the geometry of the object, where slices of the model are defined according to the layer thickness along the slicing direction. A region-based recipe module is configured to generate annotated slices, where each slice is annotated with information based on the manufacturing definition. The annotated slices are sent to an edge computing device that controls the AM machine to be converted into a final build file with tool paths and process parameters.

[0006] According to another aspect, there is provided a computer-implemented method for generating an additive manufacturing (AM) build program for building an object conforming to a manifold boundary volume. Merge build information for manufacturing definition and AM machine mode information. The build information includes a specification of region-based build parameters, and the machine mode information includes AM machine-specific parameters related to layer-by-layer material build (e.g., deposition). Perform a direct slicing algorithm on a 3D CAD model that defines the geometry of the object, where slices of the model are defined according to the layer thickness along the slicing direction. Generate annotated slices, where each slice is annotated with information based on the manufacturing definition. The annotated slices are sent to an edge computing device that controls the AM machine to be converted into a final build file with tool paths and process parameters. BRIEF DESCRIPTION OF THE DRAWINGS

[0007] Non-limiting and non-exhaustive embodiments of the present disclosure are described with reference to the following drawings, where like reference numerals refer to like elements unless otherwise specified.

[0008] Figure 1A An example of a complex structure for layer-by-layer additive manufacturing (AM) according to an embodiment of the present disclosure is shown.

[0009] Figure 1B An example of an inner layer of a structure for profile analysis is shown.

[0010] Figure 1C An example of a layer region defined within a model for a manufacturing recipe according to an embodiment of the present disclosure is shown.

[0011] Figure 2It is a flowchart showing an example of an AM build program generation process according to an embodiment of the present disclosure.

[0012] Figure 3 It shows an example of ray casting according to an embodiment of the present disclosure.

[0013] Figure 4 It shows an example of a computing environment in which an embodiment of the present disclosure can operate. Detailed Description

[0014] Methods and systems are disclosed for solving the technical problem of inefficiency in additive manufacturing (AM) regarding converting a 3D polyhedron model file into a build file executable by an AM machine to build a material layer of a manifold object. The region-based manufacturing mode is processed so that object designs with different heterogeneous material regions, physical properties, and / or build specifications can be modeled and built without overloading the processing resources of the AM machine.

[0015] Figure 1A It shows an example of a complex structure for layer-by-layer additive manufacturing (AM) according to an embodiment of the present disclosure. In this illustrative example, the target design for AM has a 3D geometry 101 based on the Stanford Bunny model, which is a well-known standard model in the CAD industry for challenging tests of modeling techniques applied to curved, non-prismatic shapes. The internal material has gyroid properties (i.e., a triply periodic minimal surface), which have applications in industry (e.g., heat exchangers). Thus, embodiments of the present disclosure are capable of modeling a gyroid structure that can be trimmed to a boundary with complex curves and has a manifold boundary.

[0016] Figure 1B It shows an example of the inner layer 102 of the structure 101 for contour analysis. The structure 101 is divided into multiple layers, where these layers are arranged as stackable slices of the structure 101, and each layer is defined by a given build direction and layer thickness. In this example, the white areas show where the material should be built, while the black areas show the blank spaces. The layer 102 includes an outer contour and two inner contours. There is material inside the outer contour and outside the inner contours.

[0017] Figure 1CAn example of a layer region of a manufacturing recipe defined within a model according to an embodiment of the present disclosure is shown. In an embodiment, different regions may be defined within each layer to specify region-based manufacturing recipes for specifying fill patterns or process parameters. Examples of regions include an upper skin region, a lower skin region, an internal region, etc. The upper skin region is defined as the portion of the layer where there is no material in the layer above but there is material in the layer below. The lower skin region is defined as the portion of the layer where there is material in the layer above but no material in the layer below. There may be support structures (e.g., temporary support materials used only during the build process to support the layers, which can be removed after the AM build is completed) below the lower skin region, but these support structures can have different build parameter specifications if needed. The internal region is defined as the portion of the layer where there is material in both the layer above and the layer below. As an example of actual AM applying laser powder bed fusion, different scan speeds or laser powers may be specified for the upper skin, lower skin, and internal regions. Additionally, additional regions may be defined to segment fill pattern types or build parameters, such as those illustrated by regions 111, 112, 113 in FIG. 10.

[0018] Figure 2 FIG. 4 is a flowchart showing an example of a process for generating an AM build program according to an embodiment of the present disclosure. Process 200 controls the data flow of a proposed manufacturing mode that involves build slices and region-based manufacturing recipes sent to one or more edge devices 231, which operate one or more AM machines 241. Process 200 includes the following manufacturing mode activity modules: creating a manufacturing definition 211, creating a region-based manufacturing recipe 214, and slice build plan verification / simulation 217. These processes may be executed by a graphics processing unit (GPU) or a separate processing unit. The manufacturing mode is processed by blocks 211, 214, 217 in such a way that during the execution of an AM object build, one or more AM edge devices 231 do not experience data overload. Compared with traditional AM build file generation that obtains build information 201 and generates an AM build file to be sliced to allow the AM machine to process the data in the slice, process 200 further refines the build file generation process for more efficient AM build execution, including region-based geometric lattice definition for implementing variable material build (e.g., deposition) features within 3D geometries.

[0019] Given a CAD model 203 of an object, the slicing generation component 212 performs a slicing algorithm, which is a method of discretizing the AM model according to the layer thickness of the material construction along the slicing direction. A cutting plane parallel to the 2D plane is used to cut the 3D model, and the layer profile position information of each layer is obtained. This converts the 3D construction into layer-by-layer manufacturing in the 2D plane, thus simplifying the manufacturing process. For the generation of the build program based on the manufacturing mode of process 200, various slicing algorithms are available and compatible with the process, including the slicing algorithm based on the Standard Template Library (STL) and the direct slicing algorithm based on the CAD model. In an implementation, the STL method is applied, where a series of triangular patches are used to approximate the surface contour of the CAD model 203. The slice 213 is generated by the computer-based slicing generation component 212, which in this example is executed by a GPU that may be located in a computing device such as a user terminal.

[0020] Alternatively, a direct slicing algorithm can be implemented, which can avoid the problems of data redundancy, large file size, and long slicing time compared to slicing using an STL file. The execution of the direct slicing algorithm does not require the creation of an intermediate faceted model file, and the CAD model 203 can be directly sliced using different layer thicknesses. Another option for the direct slicing algorithm is based on the Product Model Data Exchange (STEP) model, which uses a geometric intersection algorithm between the cutting plane and the basic curves or surfaces and obtains the intersection line of the parametric surface and the cutting plane.

[0021] In an implementation, a novel direct slicing method is performed as follows. Given a CAD model 203 and a lattice definition 204 (e.g., the geometry of the lattice cells), the faces 222 of the CAD model are loaded, and a lattice 223 is created using a signed distance field (SDF) according to the ray casting lattice representation. Figure 3 An example of ray casting according to this implementation is shown. The slicing generation component 212 uses a fragment shader for ray casting, thus applying parallel computing to each pixel. Each pixel corresponds to a ray that shoots from the virtual camera position 312 to the world coordinate 315 of the pixel. In this example, pixel 5 is being propagated, and boundary volumes 321 and 322 are detected. As the ray propagates, the SDF of the object in space determines the next point to query on the ray, such as query points 323 and 324, which can also prevent the ray from missing the object. If the query point is close enough to the object, it is considered that the ray hits an object at that point. Then, the corresponding pixel color can be calculated according to the characteristics and illumination of the object. Therefore, in order to obtain the entire image, the input of the fragment shader is always the coordinates of all the pixels on the screen.

[0022] The advantage of applying the above SDF method is that the complexity mainly depends on the number of pixels rather than the complexity of representing the entire model with a triangular mesh. Therefore, large lattices can be visualized. Although large lattices cannot be represented by triangles due to memory limitations, the lattice construction performed in this method only requires local reconstruction of the SDF or implicit function around a small number of checkpoints. Since the lattice is periodic, it is easy to find the local SDF at a certain point. This method is called lazy local reconstruction of periodic patterns and can be applied to any type of cell-based lattice.

[0023] Meanwhile, due to the nature of the fragment shader, the truncated boundary information should be available for each pixel because the final SDF should be the lattice SDF combined with the SDF of the truncated boundary. This poses two challenges: the SDF of some boundary shapes may be difficult to find, and the boundary may be as complex as a combination of hundreds of primitives. To solve this problem, the vertex shader passes the boundary information of the triangles from the boundary STL model to the relevant pixels. Specifically, the depth buffer of the vertex shader can handle the boundary triangle mesh and provide information about whether the far end is inside or outside for the points on the boundary volume (i.e., the pixels with depth).

[0024] The fragment shader is responsible for finding the correct texture for a certain pixel from the previous step, and the pixel itself carries depth and normal to indicate the local inside / outside boundary information. Thus, there are three types of input pixels for the fragment shader. First, there are pixels on the back of the boundary volume, which can only be seen when there is no lattice in front. Second, there are pixels on the front, which are located on the cross-section between the boundary volume and the filled lattice. From this perspective, the truncated lattice shares the same face with the boundary volume. Third, there are pixels on the front, but these pixels are not on the surface of the truncated lattice. From this perspective, the lattice surface inside the boundary volume or the back of the boundary volume can be seen. The ray casting point is farther than the front point.

[0025] Converting the input pixels to a lattice volume requires aligning the views of the virtual projection boundary volume camera 311 and the virtual raycasting lattice camera 312 of the fragment shader. The alignment of the virtual cameras 311, 312 enables the boundary volume 320 and the lattice to be realized as a whole. The virtual cameras 311, 312 are related to the geometry. The virtual projection camera 311 shows the boundary volume 320, while the virtual raycasting camera 312 shows the raycasting / raymarching performed on, inside, and behind the boundary volume 320. The virtual projection camera 311 provides a trigger to the virtual raycasting lattice camera 312 to start raymarching based on the information of pixel illumination from the virtual projection camera 311 on the boundary volume 320. The projection camera 311 converts world coordinates to screen coordinates (camera coordinates) with depth information and then passes it to the fragment shader as input. By recovering the world coordinates from the camera coordinates, the boundary information along the corresponding ray is successfully obtained in the fragment shader. The camera can be an orthographic camera or a perspective camera.

[0026] Using the above lattice construction method, only several corresponding points are passed to each ray instead of the entire boundary volume. Therefore, this algorithm can handle more complex boundary volumes. Compared with existing traditional methods (e.g., primitive truncation in the fragment shader), this algorithm can handle any manifold boundary volume that can be approximately represented by STL, such as non-uniform rational B-spline curves (NURBS), rather than just a simple combination of primitives.

[0027] The lattice SDF 223 has been created, and the SDF trimming operation 225 is performed to determine the slice start position, slice end position, and number of slices by projecting the bounding box of the geometry along the specified construction direction. Next, the SDF query algorithm 224 queries the SDF based on the manufacturing definition 211 on each slice plane respectively to create slices 213. As an illustrative example, the lattice material in slice 102 is Figure 1B shown as the white area in, and the area of the blank space is shown as the black area, generated by the graphics pipeline.

[0028] The raycasting algorithm 226 generates a visualization 215 on the user interface to monitor the stages of direct slicing. Combined with defect monitoring 234, the visualization 215 provides backward traceability from manufacturing to design. In the case of a build failure or non-compliance in the currently monitored layer, the process can be adjusted, including AM machine commands for slice construction 233 for the next layer, the manufacturing definition 211 (for future builds), or all the way back to the design. Such reversibility traceability has been lacking in the traditional AM design to manufacturing pipeline.

[0029] In an embodiment, a manufacturing definition 211 is created by merging build information 201 and a manufacturing mode 202. The build information 201 is user-provided input that includes specific requirements for regions within an object, which type of slicing algorithm to apply, and how to orient the object. The manufacturing mode 202 includes information related to design specification parameters and AM machine-specific details (e.g., laser power, material build or deposition rate, material melting), which will be used by a specific AM machine 341 on how to divide the geometry into a set of build information. Manufacturing specifications can be programmatically associated with local normals, profile thickness, surface finish, etc. Any change in the geometry, design, or manufacturing specification triggers an update of the affected slices or local regions within each slice, causing a modification of the manufacturing recipe and build plan (fill pattern, laser power, speed, etc.). The manufacturing definition 211 helps generate an SDF query 224 on the SDF design for slicing.

[0030] In an embodiment, a region-based recipe 214 is created based on the manufacturing definition 211, which can be used to instantaneously create a build plan for each layer and specific regions within each layer. Each slice 213 is annotated with the region-based recipe 214 to create an annotated slice 216. Region-based identifiers can be configured during the SDF query 224 process. The recipe 214 contains information about the fill pattern type and build parameters for the specified regions. The annotated slice 216 can be compressed (e.g., file size compression for faster transmission) and exported separately to an edge device 231 along with the manufacturing recipe, or can be sent to a slice build simulation and / or verification algorithm 217. The slice build is simulated to verify the manufacturing procedure.

[0031] The annotated slice 216 is received by the edge device 231 for processing 232 to create a region-based pattern fill and process parameter specifications to perform a slice build 233 as a layer build. The edge-based processor receives the region definition and the manufacturing recipe and converts the information into a build file that has tool paths and process parameters for producing the part. The regions are derived from functional aspects of design and manufacturing optimization. Then, the final build file is sent from the edge device 231 to the AM machine 241 to perform a layer build. Online sensors (e.g., cameras) are positioned at one or more AM machines 241 to monitor for defects in real time as each layer is applied. For example, in a build by material deposition, under-deposition or over-deposition can be detected and reported as defect data for improving the region-based manufacturing recipe generation 214 for the next slice or region. This can be further extended to improve the manufacturing recipe 211 for the current object build or subsequent object builds. These adjustments are effective error mitigation measures.

[0032] In an embodiment, the manufacturing mode of process 200 is an XML-based extensible schema. It includes various identifiers for SDF design, trimmed bodies, regions, manufacturing definitions, and recipes with AM build qualifiers, as well as other information. Different schema extensions can be defined for different types of AM processes (e.g., binder jetting, material jetting, powder bed fusion, material extrusion, stereolithography, sheet lamination, directed energy deposition) to include process-specific information in the recipe. The schema relies on complementary queries that need to be written in the GLSL programming language. These queries identify slices, slice regions, and help create manufacturing recipes for the build plan. Any change in the design is translated via the queries to the relevant regions and build plan. Any change in the build plan is connected to the design via region-based queries.

[0033] Advantages of process 200 based on the manufacturing mode include reducing the data required to communicate with the AM machine 241. The information is partitioned but still remains connected to the design and build plan. Any change in the design is propagated to the build plan and vice versa. The amount of intermediate activities, conversions, and data transfers from multiple software and hardware components is reduced. The following aspects provide these advantages: the manufacturing mode connects the design to the manufacturing recipe, uses the manufacturing recipe from the design to generate a query basis for slices and regions on demand, and delegates toolpath creation and process parameter specification to the edge device of the AM machine via the recipe.

[0034] Figure 4 An example of a computing environment in which embodiments of the present disclosure may be operated is shown. The computer system 410 may be implemented as, for example but not limited to, a computing device for processing the manufacturing mode and AM build files of edge computing devices. As Figure 4 shown, the computing device 410 is communicatively linked to an edge device 431 that controls the AM machine 441.

[0035] The processor 415 may include one or more GPUs and one or more central processing units (CPUs). The system memory 416 stores information and instructions executed by the processor 415 and may be used to store temporary variables or other intermediate information during the execution of instructions by the processor 415. The system memory 416 may contain data and / or program modules that the processor 415 can access immediately and / or is currently operating on, such as the manufacturing definition module 411, the slice generation module 412, the region-based recipe module 414, and the verification / simulation module 417, the operating system 418, and other program modules 419. For this example, the manufacturing definition module 411, the slice generation module 412, the region-based recipe module 414, and the verification / simulation module 417 are configured to perform the functionality of the model manufacturing definition module 211, the slice generation component 212, the region-based recipe module 214, and the verification / simulation module 217, respectively, as described above with reference to Figure 2 described.

[0036] The computing system 410 may also include a user interface module 423 for communicating with the graphical user interface 424, which includes a display device for presenting information to a computer user and one or more input devices (such as a keyboard or a pointing device) for interacting with the computer user and providing information to the processor 415. The display device may provide a touch screen interface that allows input to supplement or replace the conveyance of orientation information and command selection.

[0037] The computing system 410 may perform part or all of the processing steps of the embodiments of the present disclosure in response to one or more sequences of one or more instructions contained in a memory (such as the system memory 416) executed by the processor 415. Such instructions may be read into the system memory 416 from another computer-readable storage medium implemented as a magnetic hard disk or a removable media drive (such as the local storage device 422). The local storage device 422 may contain one or more data stores and data files used by the embodiments of the present disclosure. The data store content and data files may be encrypted to enhance security. The processor 415 may also employ a multiprocessing arrangement to execute one or more sequences of instructions contained in the system memory 416. In alternative embodiments, hardwired circuitry may be used in place of or in combination with software instructions. Accordingly, embodiments are not limited to any specific combination of hardware circuitry and software.

[0038] The computing system 410 may include at least one computer-readable storage medium or memory, such as a local storage device 422, for holding instructions programmed in accordance with embodiments of the present disclosure and for containing the data structures, tables, records, or other data described herein. As used herein, the term "computer-readable storage medium" refers to any medium that participates in providing instructions to a processor 415 for execution. Computer-readable storage media can take many forms, including but not limited to non-transitory, non-volatile media, volatile media, and transmission media. Non-limiting examples of non-volatile media include optical discs, solid state drives, magnetic disks, and magneto-optical discs, such as magnetic hard disks or removable media drives. Non-limiting examples of volatile media include dynamic memory, such as system memory 416. Non-limiting examples of transmission media include coaxial cables, copper wire, and fiber optics. Transmission media can also take the form of acoustic or light waves, such as those generated during radio wave and infrared data communications. The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to a corresponding computing / processing device via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network), or to an external computer or external storage device.

[0039] The network 450 can be any network or system commonly known in the art, including the Internet, an intranet, a local area network (LAN), a wide area network (WAN), a metropolitan area network (MAN), a direct connection, or a series of connections, a cellular phone network, or any other network or medium capable of facilitating communication between the computing system 410 and other computers such as an edge computing device 431. The network 450 can be wired, wireless, or a combination thereof. The wired connection can be implemented using Ethernet, a universal serial bus (USB), RJ-6, or any other wired connection commonly known in the art. The wireless connection can be implemented using Wi-Fi, WiMAX, and Bluetooth, infrared, cellular networks, satellites, or any other wireless connection method commonly known in the art. Additionally, several networks can work alone or communicate with each other to facilitate communication in the network 450.

[0040] Embodiments of the present invention can be implemented in any combination of hardware and software. Additionally, embodiments of the present disclosure can be included in an article of manufacture (e.g., one or more computer program products) having, for example, a non-transitory computer-readable storage medium. The computer-readable storage medium contains, for example, computer-readable program instructions for providing and facilitating the mechanisms of embodiments of the present disclosure. The article of manufacture can be included as part of a computer system or sold separately.

[0041] Computer-readable medium instructions for performing the operations of the present disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state-setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages (such as Smalltalk, C++, etc.) and conventional procedural programming languages (such as the "C" programming language or similar programming languages). The computer-readable program instructions may be executed entirely on the computing device, partly on the computing device, as a stand-alone software package, partly on the computing device and partly on a remote computer, or entirely on the computing device or server. In the latter case, the remote computer may be connected to the computing device through any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., through the Internet using an Internet service provider). In some embodiments, an electronic circuit, including, for example, a programmable logic circuit, a field-programmable gate array (FPGA), or a programmable logic array (PLA), may execute the computer-readable program instructions by utilizing state information of the computer-readable program instructions to personalize the electronic circuit in order to perform aspects of the present disclosure.

[0042] Aspects of the present disclosure are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the present disclosure. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable medium instructions.

[0043] In Figure 4The program modules, applications, computer-executable instructions, code, etc. depicted as stored in the system memory 416 are merely exemplary and not exhaustive, and the processing described as being supported by any particular module can alternatively be distributed across multiple modules or performed by different modules. Additionally, various program modules, scripts, plug-ins, application programming interfaces (APIs), or any other suitable computer-executable code locally hosted on the computing system 410 and / or hosted on one or more other computing devices accessible via a network can be provided to support the functionality provided by the program modules, applications, or computer-executable code and / or additional or alternative functionality. Additionally, the functionality can be modularized differently such that the processing described as being jointly supported by a set of program modules 411, 412, 414, 417 can be performed by fewer or more modules, or the functionality described as being supported by any particular module can be at least partially supported by another module. Furthermore, the program modules that support the functionality described herein can form part of one or more applications that can be executed across any number of systems or devices according to any suitable computing model (such as, for example, a client-server model, a peer-to-peer model, etc.). Additionally, any functionality depicted as being supported by Figure 4 any of the program modules described in Figure 4 can be at least partially implemented in hardware and / or firmware on any number of devices.

[0044] It should be further understood that the computing system 410 can include alternative and / or additional hardware, software, or firmware components beyond those described or depicted without departing from the scope of the present disclosure. More specifically, it should be understood that the software, firmware, or hardware components depicted as forming part of the computing system 410 are merely exemplary, and in various embodiments some components may be absent or additional components may be provided. Although various exemplary program modules have been depicted and described as software modules stored in the system memory 416, it should be understood that the functionality described as being supported by the program modules can be implemented by any combination of hardware, software, and / or firmware. It should be further understood that in various embodiments, each of the above-described modules can represent a logical partitioning of the supported functionality. This logical partitioning is depicted for ease of explaining the functionality and may not represent the structure of the software, hardware, and / or firmware used to implement the functionality. Thus, it should be understood that in various embodiments, the functionality described as being provided by a particular module can be at least partially provided by one or more other modules. Additionally, in certain embodiments, one or more of the depicted modules may be absent, while in other embodiments, additional modules not depicted may be present, and such additional modules can support at least a portion of the functionality described and / or additional functionality. Furthermore, although certain modules may be depicted and described as sub-modules of another module, in certain embodiments, such modules may be provided as independent modules or sub-modules of other modules.

[0045] Although specific embodiments of the present disclosure have been described, those of ordinary skill in the art will recognize many other modifications and alternative embodiments are within the scope of the present disclosure. For example, any functionality and / or processing capabilities described with respect to a particular device or component may be performed by any other device or component. Additionally, although various exemplary implementations and patterns have been described in accordance with embodiments of the present disclosure, those of ordinary skill in the art will understand that many other modifications to the exemplary implementations and patterns described herein are also within the scope of the present disclosure. Further, it should be understood that any operation, element, component, data, etc. described herein as being based on another operation, element, component, data, etc. may alternatively be based on one or more other operations, elements, components, data, etc. Accordingly, the phrase "based on" or variations thereof should be construed as "at least partially based on".

[0046] The flowcharts and block diagrams in the figures illustrate the patterns, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagram may represent a module, segment, or portion of instructions, which includes one or more executable instructions for implementing the specified logical function. In some alternative embodiments, the functions noted in the blocks may occur out of the order noted in the figures. For example, in fact, two blocks shown in succession may be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented by special purpose hardware-based systems that perform a particular function or action or implement a combination of special purpose hardware and computer instructions.

Claims

1. A computer-implemented system for generating an additive manufacturing (AM) build program for building an object that conforms to a manifold boundary volume, the system comprising: A processor; And A memory having modules stored thereon, the modules having instructions to be executed by the processor, the modules including: A manufacturing definition module configured to merge build information for manufacturing definition and AM machine mode information, wherein the build information includes a specification of region-based build parameters, and the machine mode information includes AM machine-specific parameters related to layer-by-layer material build; A slice generation module configured to perform a direct slicing algorithm on a 3D CAD model that defines the geometry of the object, wherein slices of the model are defined according to a layer thickness along a slicing direction; and A region-based recipe module configured to generate annotated slices, wherein each slice is annotated with information based on the manufacturing definition; Wherein the annotated slices are sent to an edge computing device that controls the AM machine to be converted into a final build file with tool paths and process parameters.

2. The system according to claim 1, wherein The information of the annotated slices includes the fill pattern type and build parameters of a specified region.

3. The system according to claim 1, wherein The module further includes: a verification / simulation module configured to simulate the slice build to verify the manufacturing program.

4. The system according to claim 1, wherein, The slice generation module is further configured to: Load the faces of the 3D CAD model; and Create a lattice using a signed distance field (SDF) according to a ray casting lattice representation using a fragment shader.

5. The system according to claim 4, wherein The fragment shader receives input pixels, the input pixels including: Pixels on the back face of the boundary volume; Pixels on the front face of the boundary volume that are on a cross-section between the boundary volume and the fill lattice; And Pixels on the front face but not on the surface of the truncated lattice.

6. The system according to claim 4, wherein, The slice generation module is further configured to: perform an SDF trimming operation to determine a slice start position, a slice end position, and a number of slices by projecting a bounding box of the geometry along a specified build direction.

7. The system according to claim 4, wherein The slice generation module is further configured to: query the SDF individually based on the manufacturing definition on each slice plane to create the slice.

8. The system according to claim 1, wherein The manufacturing definition module is further configured to receive feedback from an in-line sensor located at the AM machine to monitor defects in real time as each layer is applied.

9. A computer-implemented method for generating an additive manufacturing (AM) build program for building an object that conforms to a manifold boundary volume, the method comprising: Merging build information for manufacturing definition and AM machine mode information, wherein the build information includes a specification of region-based build parameters, and the machine mode information includes AM machine-specific parameters related to layer-by-layer material build; Performing a direct slicing algorithm on a 3D CAD model that defines the geometry of the object, wherein slices of the model are defined according to a layer thickness along a slicing direction; Generate annotated slices, where each slice is annotated with information based on the manufacturing definition; and The annotated slices are sent to an edge computing device that controls the AM machine to be converted into a final build file with tool paths and process parameters.

10. The method according to claim 9, wherein, The information of the annotated slices includes the fill pattern type of the specified area and build parameters.

11. The method according to claim 9 further comprises: Simulate the slice build to verify the manufacturing program.

12. The method according to claim 9, further comprising: Load the faces of the 3D CAD model; And Create a lattice using a signed distance field (SDF) according to a ray casting lattice representation using a fragment shader.

13. The method according to claim 12, wherein, The fragment shader receives input pixels, and the input pixels include: Pixels on the back face of the bounding volume; Pixels on the front face of the bounding volume that are on the section between the bounding volume and the filled lattice; And Pixels on the front face but not on the surface of the truncated lattice.

14. The method according to claim 12, further comprising: Perform an SDF trimming operation to determine the slice start position, slice end position, and number of slices by projecting the bounding box of the geometry along the specified build direction.

15. The method according to claim 12 further comprises: Query the SDF individually based on the manufacturing definition on each slice plane to create the slices.

Images