Patent ID: 12217402

Reference will now be made to implementations, examples of which are illustrated in the accompanying drawings. In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present invention. However, it will be apparent to one of ordinary skill in the art that the present invention may be practiced without requiring these specific details.

DESCRIPTION OF IMPLEMENTATIONS

FIG.1is a block diagram of a system100for in-situ inspection of additive manufacturing processes, in accordance with some implementations. Additive manufacturing equipment102is monitored by one or more camera devices104, each device104including one or more image sensors106and one or more image processors108. Data collected by the camera devices is communicated to an in-situ inspection server112using a communication network110. The additive manufacturing equipment102uses a set of additive manufacturing parameters118, which can be updated dynamically by the in-situ inspection server112. The manufacturing parameters can include detailed process flows that define both the materials used, and how the processes are performed.

The in-situ inspection server112uses some standard computer vision processing algorithms114, as well as some machine/deep learning data models116.

The process captures images in-situ, during the additive manufacturing operation and applies standard image processing techniques to accentuate features (e.g., Gaussian blur, edge detection of electrode and weld pool, signal to noise filtering, and angle correction). The process uses temporal cross-correlations to align image stack or video frames to geometry. In some implementations, this information is fed to one or more mounted robotic cameras for accurate image capture. The system converts temporal image trends to stationary signals by taking the temporal derivative of the images. The system trains a convolutional neural network on sequential, lagged image batches with 3-D convolutions (e.g., pixel position, intensity, and color/spectral band). In some implementations, the machine/deep learning data models116output the probability of certain events (e.g., either yes/no or type of defect).

FIG.2Ais a block diagram of a system200for training a Generative Adversarial Network (GAN) for enhancing image resolution for sequences of 2-D images of additively manufactured products, in accordance with some implementations. Raw input images202(e.g., NIR images or CT data) are obtained from in-situ monitoring of additive manufacturing processes. Some implementations acquire initial data (the raw input images202) by capturing NIR images (while building products) at a predetermined resolution (e.g., 60 μm (micro-meter) resolution). Some implementations perform micro-CT scan of printed parts or products at a second predetermined resolution (e.g., 20 μm resolution). The micro-CT scans are typically generated after a product is fully constructed. In some implementations, each NIR image corresponds to an X-Y cross-section (e.g., a layer) of a product. The input images are cropped and aligned to obtain NIR and CT data204, which is subsequently tiled (e.g., random x-y, y-z, or x-z tiles) with warp transforms to obtain intermediate tiled inputs206. These tile stacks (each representing a portion of the overall image) are used to train a Generative Adversarial Network208. For example, each NIR image corresponds to a X-Y cross-section or layer of a product, and the CT image stack includes a scan of layers of the product bottom-up (i.e., bottom-most layer first, followed by a subsequent layer, all the way to the top-most layer). Aligning the NIR images and the CT scan images includes matching the images layer-by-layer, bottom-most to the top-most layer. Some implementations augment the input data (data used to train neural networks) by modifying the input data to increase the amount of data available for training. Some implementations rotate, adjust position, and/or scale the input data to obtain further data for training. In some instances, these operations do not actually provide additional data. For example, when the input data or image contains circles or hexagons, rotation does not provide additional data or information. Some implementations augment the data by warping the data. In some instances, warping produces additional information (e.g., an H-shape) that is used to train the neural networks. Warping is used to augment the training dataset to increase diversity in training data. Warping (sometimes called perspective warping) includes affine transformation(s) of the input data. Some implementations warp the NIR images (or tiles obtained from the NIR images), and the CT images (or tiles obtained from the CT images), to produce corresponding warped images (or tiles) for training. The warp operation takes a 2-D image and projects it into a 3-D space, which makes the image appear as if it is being viewed at an angle. Since the final image is projected back into two dimensions, warping produces images which appear stretched, twisted, bent, or otherwise deformed. Some implementations perform the warp operation identically on both CT and NIR input data, creating paired ground-truth for geometries or features that are unseen in the original data.

Some implementations pair data sources by assembling NIR images into a 3-D volume, align NIR and micro-CT volumes, and/or upscale NIR images to CT resolution (e.g., using basic interpolation). Some implementations extract training sets by randomly selecting tiles from the paired 3-D volumes described above, randomly manipulating data to augment the dataset, and/or dividing the dataset into training, testing, and validation sets of data. Some implementations subsequently use the training sets to train the GAN208.

FIG.2Bis a block diagram of the Generative Adversarial Network (GAN)208shown inFIG.2A, in accordance with some implementations. A Generative Adversarial Network, or GAN, is an advanced method of training a Deep Convolutional Neural Network (CNN). Instead of using a single network, two separate networks (a generator212and a discriminator216) are trained. The generator212is the network that will ultimately be used after training. The generator212takes input data210(e.g., Near-Infrared or NIR images), processes the input data210, and generates samples218(e.g., fake or artificial CT data). The results218are considered “fake” data because it is generated (not an actual CT scan). The discriminator216takes in an original “real” sample214or a “fake” generated sample218(or both simultaneously), and attempts to determine if the data is “real” or “fake”. The two networks are trained simultaneously. The generator212is trained based on its ability to “trick” the discriminator216into believing its data is “real”, while the discriminator216is trained on its ability to discern “real” from “fake”. This results in both models or networks becoming increasingly accurate. The model is considered “Converged” or “Fully trained” (state shown by block220) when the accuracy of both networks has stabilized (e.g., the accuracy does not change for several iterations). In some cases, convergence occurs when the discriminator is correct about 50% of the time. Until the networks converge, the state shown in block220provides fine-tuned feedback222to the generator212and the discriminator216. In some implementations, a human developer validates the quality of the “fake” data results. During the GAN training process, the network utilizes the training dataset (described above) to train the network, and the independent validation dataset (also described above) to measure accuracy. The training model produces statistics (e.g., accuracy and/or loss) for each input. In some implementations, once the training has reached a point where a developer believes the output quality is good, testing is performed using a completely separate dataset. This dataset is essentially a dry run of the production model, testing not only the neural net itself but the full image processing and assembly pipeline.

FIG.2Cis a block diagram of a system224for using the Generative Adversarial Network (GAN)208for enhancing image resolution for sequences of 2-D images of additively manufactured products, in accordance with some implementations. Raw input images226(e.g., NIR images) are obtained from in-situ monitoring of an additive manufacturing process of a product. Some implementations capture layer images for a product during an additive manufacturing process. Some implementations resize the images (e.g., increase the size by 3 times). The input images are cropped to obtain cropped NIR images228. Some implementations segment the cropped images228into numbered tiles (e.g., as 256×256 pixel tiles), extracting a tile for each predetermined number of pixels (e.g., every 128 pixels). In some implementations, the tiles overlap (e.g., 4 tiles overlap) to eliminate edge effects. Subsequently, the cropped NIR images are ordered and/or tiled to obtain ordered tiles230. The ordered tiles230are input to the trained GAN generator208(which is run in an inference mode) to obtain ordered tiles output232. The ordered tiles output232are stitched and blended to obtain output234, which is used to reconstruct a digital twin model236(e.g., the stitched images are appended to form a 3-D volume). Details of the tiling, and image stitching algorithm are described below in reference toFIGS.4and5, according to some implementations. In some implementations, each tile is input to the GAN separately. The input images are sliced into tiles, each tile is processed by the GAN, and then the output tiles are reassembled into a final image. This is done for each image in the image stack (of tiles), and then finally the stack of output images is combined into a 3-D volume.

FIG.3is a block diagram illustrating a computing device300in accordance with some implementations. Various examples of the computing device300include high-performance clusters (HPC) of servers, supercomputers, desktop computers, cloud servers, and other computing devices. The computing device300typically includes one or more processing units/cores (CPUs and/or GPUs)302for executing modules, programs, and/or instructions stored in the memory314and thereby performing processing operations; one or more network or other communications interfaces304; memory314; and one or more communication buses312for interconnecting these components. The communication buses312may include circuitry that interconnects and controls communications between system components.

The computing device300may include a user interface306comprising a display device308and one or more input devices or mechanisms310. In some implementations, the input device/mechanism includes a keyboard. In some implementations, the input device/mechanism includes a “soft” keyboard, which is displayed as needed on the display device308, enabling a user to “press keys” that appear on the display308. In some implementations, the display308and input device/mechanism310comprise a touch screen display (also called a touch sensitive display).

In some implementations, the memory314includes high-speed random access memory, such as DRAM, SRAM, DDR RAM or other random access solid state memory devices. In some implementations, the memory314includes non-volatile memory, such as one or more magnetic disk storage devices, optical disk storage devices, flash memory devices, or other non-volatile solid state storage devices. In some implementations, the memory314includes one or more storage devices remotely located from the GPU(s)/CPU(s)302. The memory314, or alternatively the non-volatile memory device(s) within the memory314, comprises a non-transitory computer readable storage medium. In some implementations, the memory314, or the computer-readable storage medium of the memory314, stores the following programs, modules, and data structures, or a subset thereof:an operating system316, which includes procedures for handling various basic system services and for performing hardware dependent tasks;a communications module318, which is used for connecting the computing device300to other computers and devices via the one or more communication network interfaces304(wired or wireless) and one or more communication networks, such as the Internet, other wide area networks, local area networks, metropolitan area networks, and so on;an optional data visualization application or module320for displaying visualizations of additive manufacturing defects for in-situ inspection;an input/output user interface processing module346, which allows a user to specify parameters or control variables;an in-situ inspection engine112(sometimes called inline monitoring engine, described above in reference toFIG.1). In some implementations, the inspection engine112includes an image processing module322and/or an additive manufacturing control module330, as described below with respect toFIG.10. In some implementations, the image processing module322includes an image tiling module324, an image stitching module326, and/or an image conversion module328, as described in more detail below;tiling maps332, as used by the image tiling module324, for subdividing low-resolution 2-D images to obtain low-resolution (LR) tiles, and/or for subdividing high-resolution 2-D images to obtain high-resolution (HR) tiles;machine/deep learning/regression models334(e.g., the models116inFIG.1, and as further described below) that includes weights and input vectors;additive manufacturing processes336;sequenced low-resolution 2-D images338;high-resolution 3-D images340that includes slices of high-resolution 2-D images;optionally, post-build effect models342; and/or an interpolation module344.

Each of the above identified executable modules, applications, or sets of procedures may be stored in one or more of the previously mentioned memory devices, and corresponds to a set of instructions for performing a function described above. The above identified modules or programs (i.e., sets of instructions) need not be implemented as separate software programs, procedures, or modules, and thus various subsets of these modules may be combined or otherwise re-arranged in various implementations. In some implementations, the memory314stores a subset of the modules and data structures identified above. Furthermore, the memory314may store additional modules or data structures not described above. The operations of each of the modules and properties of the data structures shown inFIG.3are further described below, according to some implementations.

AlthoughFIG.3shows a computing device300,FIG.3is intended more as a functional description of the various features that may be present rather than as a structural schematic of the implementations described herein. In practice, and as recognized by those of ordinary skill in the art, items shown separately could be combined and some items could be separated.

In some implementations, although not shown, the memory314also includes modules to train and execute models described above in reference toFIGS.1and2A-2C. Specifically, in some implementations, the memory314also includes a stochastic sampling module, a coding framework, one or more convolutional neural networks, a statistical support package, and/or other images, signals, or associated data.

FIG.4is an illustration of example tiles of images of layers of additive manufacturing processes, according to some implementations. The images400,402,404, and406may correspond to different layers of the same product (or a different product built using the same additive manufacturing process or different additive manufacturing processes), according to some implementations. Each image is tiled according to a tile size that is a fraction of an image size (e.g., one-fourth or one-eighth of an image size), according to some implementations. Some implementations use the same tile size for tiling all images. Some implementations use different tile sizes for different products, and/or different additive manufacturing processes. InFIG.4, the images400,402,404, and406, correspond to separate sets of tiles from the same image. Some implementations combine these sets of tiles to create a set of tiles which overlap in each direction. For example, high-resolution images generally include 10 or more total tiles on each axis, for a total of 400 tiles (4*100). Since the tiles are offset, there are tiles on the edge which have half thickness in one or more directions. In some implementations, the GAN requires the tiles to be of uniform size, so these tiles are either not included in the calculation (e.g., the cropped portions are filled with zeros), or the cropped portion is mirrored from the non-cropped portion.

FIG.5is an illustration of stitching of tiles of images of layers of additive manufacturing processes, according to some implementations. Some implementations use an image stitching algorithm that provides superior blending of tiled images compared to conventional methods with no loss of detail. Each pixel in the output image is generated by a weighted sum of its value in each of four or more overlapping tiles. The weight for each tile is linearly proportional to the distance from the center of the tile to eliminate edge effects.FIG.5shows an initial tiled image502that can be processed by the stitching algorithm500to produce a stitched tiled image, according to some implementations. InFIG.5, the image500shows overlapped tiles, with the edge from each overlapping tile appearing in the image. Some implementations generate the image500by stitching the 4 overlapping tile configurations and blending them together by taking the average or mean of the 4 images (each image correspond to an overlapping tile).FIG.5also shows a second image502that is generated using an improved blending method. In some implementations, prior to stitching each set of tiles, the tiles are multiplied by a “blending tile” generated by a mathematical formula, an example of which is shown below:

BlendTile⁢⁢[x,y]=(1-abs⁡(1-2*xwidth))*(1-abs⁡(1-2*yheight))(1)

In the equation (1) shown above, x and y are x, y coordinates (of a pixel of an image), and width and height are width and height (sizes of dimensions) of a tile that corresponds to the pixel. In some implementations, the equation (1) produces a weighting image with a scale from 0 to 1 determined by x and y distance from the center of the image. In some implementations, the images produced by these 4 configurations are added together, so that the total weight for each pixel is 1.

FIGS.6A and6Bshow results of testing the output of the trained neural network (e.g., the GAN208), according to some implementations. The test results are based on caliper measurements for NIR, CT, and fake CT (artificial images created by the generator of a GAN208), according to some implementations. The test results are from a geometric comparison test that included calibrating pixel sizes by measuring the full width of parts in pixels, measuring thickness of thin walls (the smallest possible feature) using calipers, and comparing the measurements for the output of the system to wall thicknesses measured for NIR and micro-CT scan, according to some implementations.FIG.6Ashows a cross section of an additively manufactured part which was measured width-wise using calipers, according to some implementations. The width-wise measurement is divided into the mean pixel width of this region in each image to determine a voxel size. By utilizing the whole width of the part, the measurement error ratio due to a +/−1 pixel edge definition uncertainty is minimized to a fractional +/−2/(total number of pixels). InFIG.6A, the first image600is an NIR image (an input image with low-resolution, and includes a minimum of 427 pixels, 228 mean number of pixels, and 431 maximum number of pixels). The second image602corresponds to a CT scan image (sometimes called a CT image, which is a higher resolution image that includes a minimum of 1,367 pixels, a maximum of 1,373 pixels, and a mean of 1,369 pixels). The third image604corresponds to the output generated by the system (a fake CT image, which includes a minimum of 1,294 pixels, a maximum of 1,301 pixels, and a mean of 1,297 pixels). The resolution is shown on the y-axis of each of the images600,602, and604. The input image600has a caliper measurement of 660 μm, and the fake CT image604has a caliper measurement of 626 μm±40 μm. As illustrated, the resolution of the NIR image is low (0-100 units), whereas the resolution of the fake CT image (close to 300 units) is similar to that of the CT image602. The x-axis in the images600,602, and604corresponds to a linear dimension of a layer of a product or a part built by additive manufacturing.

FIG.6Bshows a table606of measurements of a face (“Face 1”) of the product or part whose cross-section is shown inFIG.6A, according to some implementations. The table606shows a caliper value of 26.14 units, the number of CT pixels is 1,369, the number of NIR pixels is 428, the number of fake CT pixels is 1,297, the CT voxel size is 19.0 μm, the NIR voxel size is 61 μm, and the fake CT voxel size is 20.15 μm. The Table606shows the numbers used to calculate the voxel size of the imagery shown inFIG.6A, according to some implementations.

FIG.7shows example thickness measurements700using NIR, CT, and fake CT data for a same location for the part inFIGS.6A and6B, according to some implementations. InFIG.7, graph702corresponds to the input NIR image600, graph704corresponds to the CT image602, and graph706corresponds to the fake CT image604, according to some implementations. Each graph or image includes the maximum, minimum, and mean thickness measurement over the region. The measurement was compared to caliper measurements from the same location to determine accuracy, as described above in reference toFIGS.6A and6B.

FIGS.8A and8Bshow examples of artificial high resolution images, according to some implementations.FIG.8Ashows an NIR image804, which is input into a trained network that is trained on CT data from earlier builds, which generates a fake CT image806(an artificial image that matches a CT image). The resolution and/or quality of the fake CT image matches that of a real CT image, when the network converges.FIG.8Bshows output of the network that is trained as described in reference toFIG.8A, when tested on different geometries (i.e., the network is tested on multiple geometries not included in the training set). For example, the input image808generates the image810, and the input image812generates the image814, using the network trained as described inFIG.8A.

FIG.9is a schematic diagram of a system900for Z-axis upscaling (interpolation), according to some implementations. Some implementations use a separate neural network (e.g., a neural network other than the GAN208described above). Some implementations train and use the GAN208for Z-axis upscaling. In some implementations, the separate network is trained to not only increase resolution on the X and Y axes, but also to interpolate between print layers on the Z axis. In experiments, the results show continued GD&T accuracy, and in some instances improved pore definition. In some implementations, the interpolation operations are performed by the interpolation module344described above in reference toFIG.3. In some implementations, three channel inputs (e.g., 3×1-channel inputs, including a first input channel902at 0 μm, a second input channel904at 25 μm, and a third input channel906at 50 μm) are combined to form a 3-channel input908. Some implementations use one input channel for each layer of a product that is additively manufactured. Some implementations use a respective input channel for each layer at a respective distance from a predetermined location of a product that is additively manufactured. In some implementations, each input channel corresponds to a layer that is at a predetermined distance (e.g., 25 μm) with respect to another layer of a product that is additively manufactured. The 3-channel input is input to a neural network (similar to the GAN208) that is trained to interpolate (similar to producing a higher-resolution image) between print layers in the Z axis, and output a 3-channel output910that is split into 3×1-channel output (images912,914, and916, at 0 μm, 25 μm, and 50 μm, respectively).

FIG.10is a block diagram illustrating a system1000that trains a generative adversarial network for enhancing image resolution for sequences of 2-D images of additively manufactured products, according to some implementations. In some implementations, the system1000(e.g., the computing device300) performs a method for enhancing image resolution for temporal sequences of 2-D images of additively manufactured products. The method includes performing a sequence of steps for each of a plurality of additive manufacturing processes1002. The sequence of steps includes obtaining (1016) a respective plurality of sequenced low-resolution 2-D images1004(e.g., the low-resolution 2-D images338using near-infrared (NIR) images) of a respective product during the respective additive manufacturing process. The sequence of steps also includes obtaining (1018) a respective high-resolution 3-D image1008(e.g., a high-resolution 3-D image342) of the respective product after completion of the respective additive manufacturing process. The high-resolution 3-D image comprises a plurality of high-resolution 2-D images corresponding to the low resolution 2-D images. The sequence of steps also includes selecting (1006) one or more tiling maps that subdivides each of the low-resolution 2-D images into a plurality of LR tiles and subdivide each of the corresponding high-resolution 2-D images into a plurality of corresponding HR tiles. InFIG.10, the plurality of LR tiles and the plurality of HR tiles are indicated by tiles1010. In some implementations, the LR and HR tiles are stored separately. Some implementations compute and store ordered pairs of LR and HR tiles. The sequence of steps also includes building (1012) an image enhancement generator1014iteratively in a generative adversarial network using (1020) training input comprising ordered pairs of corresponding LR tiles and HR tiles. In some implementations, the sequence of steps also includes storing (1022) the image enhancement generator for subsequent use to enhance sequences of low-resolution 2-D images captured for products during additive manufacturing.

In some implementations, the generative adversarial network (e.g., the GAN208) includes a first neural network comprising the image enhancement generator (e.g., the generator212) and a second neural network comprising a discriminator (e.g., the discriminator216). In some implementations, building the image enhancement generator iteratively includes: training the image enhancement generator to produce candidate high-resolution 2-D images (e.g., fake CT data) based on low-resolution 2-D images; and training the discriminator to distinguish between the candidate high-resolution 2-D images and 2-D slices of the obtained high-resolution 3-D images (real high-resolution images). Examples of the training, the low-resolution 2-D images, and the high-resolution 2-D images, are described above in reference toFIGS.2A-2C,6,8A and8B, according to some implementations. In some implementations, building the image enhancement generator ceases when output of the image enhancement generator is classified by the discriminator as a real high-resolution 3-D image for 50 percent of the candidate high-resolution 2-D images during multiple successive training iterations. For example, both models become increasingly accurate. The model is considered “converged” or “fully trained” when the accuracy of both networks has stabilized. In some implementations, a human developer accepts the quality of the “fake” data results.

In some implementations, each of the plurality of sequenced low-resolution 2-D images1004is a near-infrared (NIR) image of the respective product during the respective additive manufacturing process.

In some implementations, each of the high-resolution 3-D images1008is generated based on performing a micro-CT scan of the respective product after the respective additive manufacturing process is complete (e.g., 20 μm resolution).

In some implementations, the method further includes cropping and aligning the low-resolution 2-D images with the high-resolution 2-D images prior to subdividing into tiles. In some implementations, the method further includes, augmenting the LR tiles and HR tiles in the training input by performing a warp transformation on some of the 2-D images. In some implementations, the one or more tiling maps comprise a plurality of tiling maps, each subdividing according to a different pattern. In some implementations, the selecting tiling maps and subdividing (sometimes called tiling) are performed by the image processing module322(e.g., using the image tiling module324). Examples of tiled images and tiling operations are described above in reference toFIGS.3and4, according to some implementations.

FIG.11is a block diagram illustrating a system1100that uses the generator from a trained generative adversarial network (e.g., the GAN trained via the process described above in reference toFIG.10) for enhancing image resolution for sequence of 2-D images of additively manufactured products, according to some implementations. The system1100performs a method provided for enhancing image resolution for sequences of 2-D images of additively manufactured products. The method is performed at the computing device300having one or more processors and memory storing one or more programs configured for execution by the one or more processors.

The method includes obtaining (1118) a plurality of sequenced low-resolution 2-D images1104(e.g., Near-Infrared (NIR) imagery) of a product during an in-progress additive manufacturing process1102(e.g., the additive manufacturing process336). The method also includes obtaining (1120) an image enhancement generator1014previously trained (e.g., trained as described above in reference toFIG.10) as part of a generative adversarial network. The image enhancement generator is configured to accept input images of a fixed 2-dimensional size. The method also includes, selecting (1106) one or more tiling maps (e.g., using the image tiling module324) that subdivide each of the low-resolution 2-D images into a plurality of LR tiles1108. Spatially corresponding tiles from the low resolution 2-D images form a plurality of tile stacks. The method also includes, for each of the LR tiles, applying (1110) the image enhancement generator1014to generate a high-resolution 2-D artificial image tile1112of the product. The method also includes stitching (e.g., using the image stitching module326) together the high-resolution 2-D artificial image tiles to form a set of high-resolution 2-D artificial layers corresponding to the low-resolution images, and stacking together the high-resolution 2-D artificial layers to form a 3-D artificial volume of the product.

In some implementations, the method further includes using the 3-D artificial volume to identify (1114) post-build effects and/or defects1116in the product (e.g., feature detection, such as cracks/pores, predict post-layer effects, such as re-melting, expansion, shrinkage, based on previous builds).

In some implementations, the generative adversarial network (as described above in reference toFIG.2B) includes a first neural network comprising an image enhancement generator and a second neural network comprising a discriminator.

In some implementations, during training (examples of which are described above in reference toFIG.10), the image enhancement generator1014is trained to generate candidate high-resolution 2-D images (e.g., fake or artificial CT data) based on low-resolution 2-D images (e.g., NIR images); and the discriminator is trained to discriminate between the candidate high-resolution 2-D images and slices of real high-resolution 3-D images captured after additive manufacturing processes are complete.

In some implementations, obtaining the plurality of sequenced low-resolution 2-D images1104includes capturing a respective low-resolution 2-D image (e.g., images shown inFIGS.4,5,6,8A,8B, and9) for each layer of the product during the in-progress additive manufacturing process.

In some implementations, the method further includes resizing (e.g., using the image conversion module328) the plurality of sequenced low-resolution 2-D images.

In some implementations, each tiling map subdivides each of the low-resolution 2-D images into non-overlapping tiles. In some implementations, the one or more tiling maps include a plurality of tiling maps, each subdividing the low-resolution 2-D images according to a different pattern. In some implementations, the stitching includes: for each pixel included in two or more overlapping regions of the tiling map, generating a respective output image for the respective pixel by computing a respective weighted sum of values in the corresponding high-resolution 2-D artificial image tiles. In some implementations, computing the respective weighted sum includes: associating, for each tile's contribution to the respective weighted sum, a respective weight that is linearly proportional to a distance from a center of the respective tile.

In some implementations, the method further includes converting (e.g., using the image conversion module328) the high-resolution 3-D artificial volume of the product into a native CT-scan format (e.g., a format that is usable by off-the-shelf CT analysis tools).

In some implementations, the method further includes interpolating (e.g., using the interpolation module344, and as described above in reference toFIG.9), using a trained neural network, between print layers of the in-progress additive manufacturing process (e.g., the GAN network also does interpolation between print layers in the Z-axis in addition to increasing resolution on the X and Y axes).

Some implementations iterate the processes described in reference toFIG.11to subsequently label and/or reject defective parts. For example, some systems identify and/or discard products that are predicted to have beyond a predetermined threshold of porosity, or a layer that does not meet a predetermined geometric standard.

The terminology used in the description of the invention herein is for the purpose of describing particular implementations only and is not intended to be limiting of the invention. As used in the description of the invention and the appended claims, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will also be understood that the term “and/or” as used herein refers to and encompasses any and all possible combinations of one or more of the associated listed items. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, steps, operations, elements, components, and/or groups thereof.

The foregoing description, for purpose of explanation, has been described with reference to specific implementations. However, the illustrative discussions above are not intended to be exhaustive or to limit the invention to the precise forms disclosed. Many modifications and variations are possible in view of the above teachings. The implementations were chosen and described in order to best explain the principles of the invention and its practical applications, to thereby enable others skilled in the art to best utilize the invention and various implementations with various modifications as are suited to the particular use contemplated.