💻 computer science

PrintAnything: Learning an Intermediate Representation for 3D printing G-code Generation

PrintAnything is a novel framework that enables direct 3D printing G-code generation from unstructured point clouds by introducing a slice-wise projection strategy and a unified Geometric plan (G-plan) map, thereby eliminating the need for error-prone mesh reconstruction.

Original authors: Sangmin Hong, Daniel Sungho Jung, Heewon Kim, Kyoung Mu Lee

Published 2026-07-31

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Sangmin Hong, Daniel Sungho Jung, Heewon Kim, Kyoung Mu Lee

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a magical camera that can capture the shape of any object in the world, not as a solid block, but as a cloud of billions of tiny, floating dust motes. In the world of 3D science, this is called a point cloud. It's the raw, messy data that comes out of laser scanners and special cameras, showing you exactly where every surface point is located. Now, imagine you want to take that digital cloud and turn it into a real, physical object using a 3D printer. The problem is, 3D printers are like very literal chefs; they don't know how to cook with "dust motes." They only know how to work with a smooth, solid, watertight "mesh"—think of it as a digital balloon skin that completely encloses the shape.

For a long time, if you wanted to print a point cloud, you had to hire a digital sculptor (a computer algorithm) to stretch that balloon skin over your dust motes. But this is risky. If the sculptor makes a tiny hole or a weird wrinkle in the balloon skin, the printer gets confused, the object breaks, or the printing fails entirely. It's like trying to bake a cake using a recipe that has a missing page; the result is a disaster. The big question scientists have been asking is: Can we teach the printer to understand the raw dust motes directly, skipping the risky step of trying to stretch a balloon skin over them?

Enter PrintAnything, a new framework that says, "Yes, we can!" Instead of forcing the messy point cloud into a perfect mesh first, this system learns to look at the floating points and immediately figure out how to print them layer by layer. It acts like a super-smart translator that speaks two languages: the language of "floating dots" and the language of "printer instructions."

Here is how it works, using a simple analogy. Imagine you are building a sandcastle, but instead of looking at the whole castle at once, you only look at it one horizontal slice at a time, like cutting a loaf of bread. PrintAnything takes the 3D cloud of points and projects them onto these 2D slices. But it doesn't just see "sand" or "no sand." It creates a special map for each slice called a G-plan map. Think of this map as a three-layered instruction sheet for the printer:

The Occupancy Map: This is the "Where?" layer. It tells the printer exactly which spots on the slice need sand (material) and which are empty air.
The Region Map: This is the "What?" layer. It distinguishes between the outer walls of the castle (which need to be strong and smooth) and the inside filling (which can be a pattern).
The Flow Map: This is the "How much?" layer. It tells the printer how fast to squeeze out the sand (or plastic) as it moves, ensuring the lines are thick enough to hold together but not too thick to melt.

By creating these maps directly from the raw points, PrintAnything skips the "balloon skin" step entirely. It then uses a smart helper to decide the best pattern to fill the inside of the object, balancing strength with how much plastic is used. Finally, it turns these maps into G-code, which is the actual list of moves the printer's nozzle must make to build the object.

The researchers tested this on a massive dataset of 3D shapes and found that their method was much better than the old way. When they compared it to the traditional method of turning points into a mesh first, the old way often made mistakes, like smoothing out thin details or creating holes that caused the print to fail. PrintAnything, however, produced shapes that were much closer to the original design, with a "Chamfer Distance" (a measure of how close the shape is to the target) of just 0.047, compared to 0.088 for the next best method.

Even more impressively, the system is tough. The researchers tested it with "broken" point clouds that had missing pieces (like a cloud with a chunk of dust blown away) or "noisy" clouds (where the points were jiggled around randomly). Even with these imperfections, PrintAnything managed to figure out the missing parts and print a complete, stable object. They even took the instructions generated by the computer and printed them on a real machine, a Bambu Lab X1-Carbon. The resulting objects, including complex gears and delicate structures, held together and looked great, proving that you can go from a messy cloud of points straight to a solid, working object without ever needing to build a perfect mesh in between.

Technical Summary: PrintAnything

Problem Statement

Point clouds are a fundamental and widely used 3D representation, serving as the native output of modern sensors (LiDAR, RGB-D cameras) and generative models. However, existing 3D printing pipelines are fundamentally incompatible with point clouds. Standard fabrication workflows require a watertight mesh as input for slicing software to generate G-code. Consequently, point clouds must undergo mesh reconstruction before printing.

This reliance on mesh reconstruction introduces two critical limitations:

Incompatibility: Standard slicing tools cannot accept raw point clouds directly.
Error Propagation: Reconstructing meshes from sparse, noisy, or unoriented point clouds is an ill-posed problem. It frequently results in geometric artifacts (incorrect faces, holes, topological inconsistencies) that are difficult to repair. These defects propagate into the slicing stage, leading to invalid toolpaths, unstable extrusion, and ultimately, printing failures.

Methodology

The authors propose PrintAnything, a novel framework that learns to generate executable 3D printing G-code directly from unoriented 3D point clouds, bypassing the mesh reconstruction step entirely. The pipeline consists of three primary stages:

1. Slice-wise Point Projection

To align unstructured 3D point clouds with the layer-by-layer nature of Fused Deposition Modeling (FDM), the authors introduce a slice-wise point projection strategy.

Multi-Slice Conditioning (MSC): For a given slice height, points are projected onto the printer's XY grid. To provide local geometric context, the system selects points within the target slice height ( $\Delta z/2$ ) as well as adjacent bins above and below.
Input Representation: These projected points are rasterized into a 2D grid ( $H \times W$ ), generating channels for occupancy masks, density maps, and height-offset maps.
Conditioning: The normalized slice height is embedded via an MLP and concatenated with global features extracted from the entire point cloud (using a Point Transformer V3 encoder) to form a slice conditioning vector.

2. Geometric Plan (G-plan) Map Prediction

Instead of predicting a mesh, the model predicts a compact, unified 2D representation called the G-plan map for each slice. This map bridges the gap between point clouds and G-code by encoding three distinct channels:

Occupancy Map ( $M$ ): Specifies spatial locations corresponding to printed material.
Region Map ( $R$ ): Encodes structural categories required for toolpath synthesis (e.g., wall, infill, support, skirt).
Flow Map ( $Q$ ): Represents extrusion-related properties (normalized extrusion length) for material deposition.

The prediction is performed by GPNet, a U-Net architecture where the conditioning vector is injected into the bottleneck using FiLM (Feature-wise Linear Modulation).

3. Infill Pattern Generation and G-code Synthesis

Infill Recommendation: Rather than learning infill geometry from scratch, the system uses a lightweight recommender trained on a bootstrap dataset. This recommender selects an infill pattern (e.g., grid, gyroid, honeycomb) and a scale factor by optimizing a trade-off between a strength proxy (infill ratio, connectivity, directional balance) and a cost proxy (material usage, path complexity).
G-code Compilation: The predicted G-plan maps are converted into ordered toolpaths. The occupancy map defines the print area, the region map dictates the structural role (wall vs. infill), and the flow map controls extrusion volume. These are translated into physical coordinates and extrusion lengths to produce standard G-code instructions.

Key Contributions

Mesh-Free Pipeline: Introduction of PrintAnything, the first framework to generate executable 3D printing G-code directly from point clouds without intermediate mesh reconstruction.
Slice-wise Point Projection: A strategy to convert unstructured 3D points into slice-aligned 2D representations that preserve local geometric context for layer-wise reasoning.
G-plan Map: A unified representation (Occupancy, Region, Flow) that encodes both geometric and extrusion properties, effectively bridging point clouds and G-code.
Robustness: The method demonstrates the ability to handle unoriented, incomplete, and noisy point clouds, producing stable toolpaths where mesh-based methods fail.

Experimental Results

The method was evaluated on the Slice-100K dataset, comparing against state-of-the-art mesh reconstruction baselines (Poisson, DWG, MeshAnything) followed by standard slicing.

Quantitative Performance: PrintAnything achieved superior performance across all metrics:
- Chamfer Distance (CD): 0.047 (vs. 0.088 for Poisson).
- 3D F1 Score: 0.7414 (vs. 0.682 for Poisson).
- 2D Slice F1 Score: 0.677 (vs. 0.587 for Poisson).
- The results indicate that mesh-based pipelines accumulate errors during reconstruction, which are amplified during slicing, whereas the direct G-plan approach maintains higher fidelity.
Ablation Studies:
- Multi-Slice Conditioning: Enabling MSC reduced CD by 20.3% and improved 3D F1 by 5.6%, confirming the value of inter-slice continuity.
- G-plan Components: The inclusion of the Region map ( $R$ ) improved geometric fidelity, while the Flow map ( $Q$ ) significantly reduced extrusion smoothness errors ( $\Delta\rho$ -smooth decreased by 56.8%) and variability.
- Infill Recommender: The learned recommender achieved the best combined strength-cost score (0.937) compared to random or fixed-scale baselines.
Real-World Validation: The generated G-code was successfully printed on a Bambu Lab X1-Carbon printer. The physical prints demonstrated structural integrity, with successful fabrication of mechanical parts (cogwheels) and delicate structures, confirming the pipeline's practical viability.

Significance

The paper claims that PrintAnything addresses a critical bottleneck in the integration of 3D sensing and 3D manufacturing. By eliminating the dependency on error-prone mesh reconstruction, the framework enables a practical, fully mesh-free pipeline for 3D printing. This allows users with 3D-scanned data (often in point cloud format) to directly obtain fabrication-ready toolpaths, overcoming the limitations of current workflows that struggle with unoriented and noisy inputs. The work demonstrates that learning-based approaches can effectively synthesize complex manufacturing instructions (G-code) directly from raw geometric data.