AM Technology Principles and Classification - 3D Printing Technology Framework
After completing this chapter, you will be able to explain the following:
Additive Manufacturing (AM) is "a process that builds objects by adding material layer upon layer from 3D CAD data," as defined in the ISO/ASTM 52900:2021 standard. In contrast to conventional machining (subtractive processing), material is added only where needed, giving it the following innovative characteristics:
The AM market is growing rapidly. According to the Wohlers Report 2023:
Additive manufacturing technology has about 40 years of history, reaching its present state through the following milestones:
flowchart LR
A[1986
SLA invented
Chuck Hull] --> B[1988
SLS introduced
Carl Deckard]
B --> C[1992
FDM patent
Stratasys]
C --> D[2005
RepRap
open-sourced]
D --> E[2012
Metal AM adoption
EBM/SLM]
E --> F[2023
Industrialization
larger and faster]
style A fill:#e3f2fd
style B fill:#fff3e0
style C fill:#e8f5e9
style D fill:#f3e5f5
style E fill:#fce4ec
style F fill:#fff9c4
The first major use of AM, rapidly producing prototypes for design verification, functional testing, and market evaluation:
Applications where jigs, tools, and molds used on the manufacturing floor are produced with AM:
Applications that produce final products directly with AM have surged in recent years:
AM is not a cure-all and has the following constraints:
The ISO/ASTM 52900:2021 standard classifies all AM technologies into seven process categories based on energy source and material supply method. Each process has its own strengths and weaknesses, and the optimal technology must be selected according to the application.
flowchart TD
AM[Additive Manufacturing
7 processes] --> MEX[Material Extrusion]
AM --> VPP[Vat Photopolymerization]
AM --> PBF[Powder Bed Fusion]
AM --> MJ[Material Jetting]
AM --> BJ[Binder Jetting]
AM --> SL[Sheet Lamination]
AM --> DED[Directed Energy Deposition]
MEX --> MEX_EX[FDM/FFF
low-cost, widespread]
VPP --> VPP_EX[SLA/DLP
high precision, fine surface]
PBF --> PBF_EX[SLS/SLM/EBM
high strength, metal-capable]
style AM fill:#f093fb
style MEX fill:#e3f2fd
style VPP fill:#fff3e0
style PBF fill:#e8f5e9
style MJ fill:#f3e5f5
style BJ fill:#fce4ec
style SL fill:#fff9c4
style DED fill:#fce4ec
Principle: A thermoplastic filament is heated and melted, then extruded through a nozzle and stacked. The most widespread technology (also called FDM/FFF).
Characteristics:
Application examples:
Principle: A liquid photocurable resin (photopolymer) is selectively cured and stacked by irradiating it with a UV laser or projector.
The two main VPP methods:
Characteristics:
Application examples:
Principle: A thin layer of powder material is spread, selectively melted or sintered by a laser or electron beam, then cooled and solidified and stacked. Compatible with metals, polymers, and ceramics.
The three main PBF methods:
Characteristics:
Application examples:
Principle: Similar to an inkjet printer, droplets of material (photocurable resin or wax) are jetted from a head and immediately cured by UV irradiation, then stacked.
Characteristics:
Application examples: Medical anatomical models (soft and hard tissue reproduced with different materials), full-color architectural models, design verification models
Principle: A liquid binder (adhesive) is jetted inkjet-style onto a powder bed to bond the powder particles. After building, strength is increased by sintering or infiltration.
Characteristics:
Application examples: Sand-casting molds (large castings such as engine blocks), metal parts (Desktop Metal, HP Metal Jet), full-color figures (souvenirs, educational models)
Principle: Sheet materials (paper, metal foil, plastic film) are stacked and bonded by adhesion or welding. Each layer is contour-cut by laser or blade.
Representative technologies:
Characteristics: Large builds possible, inexpensive material, moderate precision, limited applications (mainly visual models; embedded sensors, etc. for metals)
Principle: Metal powder or wire is fed while being melted by laser, electron beam, or arc and deposited onto a substrate. Used for large parts and repair of existing parts.
Characteristics:
Application examples: Turbine blade repair, large aerospace parts, wear-resistant coatings for tools
The optimal AM process differs by application requirement:
STL (STereoLithography) is the most widely used 3D model file format in AM, developed by 3D Systems in 1987. An STL file represents an object's surface as a set of triangle meshes (Triangle Mesh).
Example of the ASCII STL format:
solid cube
facet normal 0 0 1
outer loop
vertex 0 0 10
vertex 10 0 10
vertex 10 10 10
endloop
endfacet
facet normal 0 0 1
outer loop
vertex 0 0 10
vertex 10 10 10
vertex 0 10 10
endloop
endfacet
...
endsolid cube
The two kinds of STL format:
Each triangle face has a defined normal vector (outward direction) that distinguishes the "inside" and "outside" of the object. The normal direction is determined by the right-hand rule:
Vertex ordering rule: Vertices v1, v2, v3 are arranged counter-clockwise (CCW: Counter-ClockWise); viewed from outside in counter-clockwise order, the normal points outward.
For an STL mesh to be 3D-printable, it must be manifold (Manifold):
A non-manifold mesh (Non-Manifold Mesh) is not 3D-printable. Typical problems:
These problems cause errors in slicer software and lead to build failures.
STL mesh quality is evaluated by the following metrics:
The resolution (triangle count) of an STL mesh is a trade-off between accuracy and file size:
When exporting STL from CAD software, resolution is controlled by Chordal Tolerance or Angle Tolerance. Recommended values: chordal tolerance 0.01–0.1 mm, angle tolerance 5–15 degrees.
The main libraries for handling STL files in Python:
Basic usage of numpy-stl:
from stl import mesh
import numpy as np
# Load the STL file
your_mesh = mesh.Mesh.from_file('model.stl')
# Basic geometric information
volume, cog, inertia = your_mesh.get_mass_properties()
print(f"Volume: {volume:.2f} mm³")
print(f"Center of Gravity: {cog}")
print(f"Surface Area: {your_mesh.areas.sum():.2f} mm²")
# Number of triangles
print(f"Number of Triangles: {len(your_mesh.vectors)}")
The process of converting an STL file into commands (G-code) that a 3D printer can understand is called slicing (Slicing). In this section we learn the basic principles of slicing, toolpath strategies, and the fundamentals of G-code.
Slicing horizontally cuts a 3D model at a fixed height (layer height) and extracts the contour of each layer:
flowchart TD
A[3D model
STL file] --> B[Slice into layers
along Z-axis]
B --> C[Contour detection
per layer]
C --> D[Shell generation
perimeter path]
D --> E[Infill generation
infill path]
E --> F[Add supports
support structure]
F --> G[Toolpath optimization
retraction/travel]
G --> H[G-code output]
style A fill:#e3f2fd
style H fill:#e8f5e9
Layer height is the most important parameter determining the trade-off between build quality and build time:
| Layer height | Build quality | Build time | Typical use |
|---|---|---|---|
| 0.1 mm (very fine) | Very high (layer lines nearly invisible) | Very long (×2–3) | Figures, medical models, end-use parts |
| 0.2 mm (standard) | Good (layer lines visible but acceptable) | Standard | General prototypes, functional parts |
| 0.3 mm (coarse) | Low (clear layer lines) | Short (×0.5) | Early prototypes, internal structural parts |
Layer height must be set to 25–80% of the nozzle diameter. For example, with a 0.4 mm nozzle the recommended layer-height range is 0.1–0.32 mm. Exceeding this causes insufficient resin extrusion or the nozzle dragging over the previous layer.
The shell (Shell/Perimeter) is the path forming the outer perimeter of each layer:
Infill forms the internal structure and controls strength and material usage:
| Pattern | Strength | Print speed | Material usage | Characteristics |
|---|---|---|---|---|
| Grid | Medium | Fast | Medium | Simple, isotropic, the standard choice |
| Honeycomb | High | Slow | Medium | High strength, excellent strength-to-weight, aerospace use |
| Gyroid | Very high | Medium | Medium | 3D isotropic, curved, the latest recommendation |
| Concentric | Low | Fast | Low | Flexibility-oriented, follows the shell |
| Lines | Low (anisotropic) | Very fast | Low | Fast printing, directional strength |
Areas where the overhang angle exceeds 45 degrees require a Support Structure:
| Parameter | Recommended value | Effect |
|---|---|---|
| Overhang Angle | 45–60° | Supports generated at or above this angle |
| Support Density | 10–20% | Higher density is more stable but harder to remove |
| Support Z Distance | 0.2–0.3 mm | Gap between support and part (ease of removal) |
| Interface Layers | 2–4 layers | Number of interface layers (balance of surface quality and removability) |
G-code is the standard numerical control language for controlling 3D printers and CNC machines. Each line represents one command:
| Command | Category | Function | Example |
|---|---|---|---|
| G0 | Motion | Rapid move (no extrusion) | G0 X100 Y50 Z10 F6000 |
| G1 | Motion | Linear move (with extrusion) | G1 X120 Y60 E0.5 F1200 |
| G28 | Init | Return to home position | G28 (all axes), G28 Z (Z only) |
| M104 | Temperature | Set nozzle temperature (no wait) | M104 S200 |
| M109 | Temperature | Set nozzle temperature (wait) | M109 S210 |
| M140 | Temperature | Set bed temperature (no wait) | M140 S60 |
| M190 | Temperature | Set bed temperature (wait) | M190 S60 |
; === Start G-code ===
M140 S60 ; Start heating bed to 60°C (no wait)
M104 S210 ; Start heating nozzle to 210°C (no wait)
G28 ; Home all axes
G29 ; Auto bed leveling (bed mesh measurement)
M190 S60 ; Wait for bed temperature
M109 S210 ; Wait for nozzle temperature
G92 E0 ; Reset extrusion amount to zero
G1 Z2.0 F3000 ; Raise Z-axis by 2 mm (safety)
G1 X10 Y10 F5000 ; Move to prime position
G1 Z0.3 F3000 ; Lower Z-axis to 0.3 mm (first-layer height)
G1 X100 E10 F1500 ; Draw prime line (clear nozzle clog)
G92 E0 ; Reset extrusion amount to zero again
; === Build start ===
| Software | License | Characteristics | Recommended use |
|---|---|---|---|
| Cura | Open source | Easy to use, rich presets, Tree Support built in | Beginner to intermediate, general FDM |
| PrusaSlicer | Open source | Advanced settings, variable layer height, custom supports | Intermediate to advanced, optimization-focused |
| Slic3r | Open source | The origin of PrusaSlicer, lightweight | Legacy systems, research use |
| Simplify3D | Commercial ($150) | Fast slicing, multi-process, detailed control | Professional, industrial use |
| IdeaMaker | Free | Raise3D-oriented but versatile, intuitive UI | Raise3D users, beginners |
Efficient toolpaths improve build time, quality, and material usage:
# ===================================
# Example 1: Loading an STL file and obtaining basic information
# ===================================
import numpy as np
from stl import mesh
# Load the STL file
your_mesh = mesh.Mesh.from_file('model.stl')
# Obtain basic geometric information
volume, cog, inertia = your_mesh.get_mass_properties()
print("=== STL File Basic Information ===")
print(f"Volume: {volume:.2f} mm³")
print(f"Surface Area: {your_mesh.areas.sum():.2f} mm²")
print(f"Center of Gravity: [{cog[0]:.2f}, {cog[1]:.2f}, {cog[2]:.2f}] mm")
print(f"Number of Triangles: {len(your_mesh.vectors)}")
# Compute the bounding box (minimum enclosing box)
min_coords = your_mesh.vectors.min(axis=(0, 1))
max_coords = your_mesh.vectors.max(axis=(0, 1))
dimensions = max_coords - min_coords
print(f"\n=== Bounding Box ===")
print(f"X: {min_coords[0]:.2f} to {max_coords[0]:.2f} mm (width: {dimensions[0]:.2f} mm)")
print(f"Y: {min_coords[1]:.2f} to {max_coords[1]:.2f} mm (depth: {dimensions[1]:.2f} mm)")
print(f"Z: {min_coords[2]:.2f} to {max_coords[2]:.2f} mm (height: {dimensions[2]:.2f} mm)")
# Rough estimate of build time (assuming 0.2 mm layer height, 50 mm/s speed)
layer_height = 0.2 # mm
print_speed = 50 # mm/s
num_layers = int(dimensions[2] / layer_height)
# Simple calculation: estimate based on surface area
estimated_path_length = your_mesh.areas.sum() / layer_height # mm
estimated_time_seconds = estimated_path_length / print_speed
estimated_time_minutes = estimated_time_seconds / 60
print(f"\n=== Build Estimate ===")
print(f"Number of layers (0.2 mm/layer): {num_layers} layers")
print(f"Estimated build time: {estimated_time_minutes:.1f} min ({estimated_time_minutes/60:.2f} hours)")
# Example output:
# === STL File Basic Information ===
# Volume: 12450.75 mm³
# Surface Area: 5832.42 mm²
# Center of Gravity: [25.34, 18.92, 15.67] mm
# Number of Triangles: 2456
#
# === Bounding Box ===
# X: 0.00 to 50.00 mm (width: 50.00 mm)
# Y: 0.00 to 40.00 mm (depth: 40.00 mm)
# Z: 0.00 to 30.00 mm (height: 30.00 mm)
#
# === Build Estimate ===
# Number of layers (0.2 mm/layer): 150 layers
# Estimated build time: 97.2 min (1.62 hours)
# ===================================
# Example 2: Verifying mesh normal vectors
# ===================================
import numpy as np
from stl import mesh
def check_normals(mesh_data):
"""Check the consistency of an STL mesh's normal vectors
Args:
mesh_data: numpy-stl Mesh object
Returns:
tuple: (flipped_count, total_count, percentage)
"""
# Check normal direction with the right-hand rule
flipped_count = 0
total_count = len(mesh_data.vectors)
for i, facet in enumerate(mesh_data.vectors):
v0, v1, v2 = facet
# Compute edge vectors
edge1 = v1 - v0
edge2 = v2 - v0
# Compute the normal via cross product (right-handed)
calculated_normal = np.cross(edge1, edge2)
# Normalize
norm = np.linalg.norm(calculated_normal)
if norm > 1e-10: # Confirm it is not the zero vector
calculated_normal = calculated_normal / norm
else:
continue # Skip degenerate triangles
# Compare with the normal stored in the file
stored_normal = mesh_data.normals[i]
stored_norm = np.linalg.norm(stored_normal)
if stored_norm > 1e-10:
stored_normal = stored_normal / stored_norm
# Check direction agreement via dot product
dot_product = np.dot(calculated_normal, stored_normal)
# A negative dot product means the direction is reversed
if dot_product < 0:
flipped_count += 1
percentage = (flipped_count / total_count) * 100 if total_count > 0 else 0
return flipped_count, total_count, percentage
# Load the STL file
your_mesh = mesh.Mesh.from_file('model.stl')
# Run the normal check
flipped, total, percent = check_normals(your_mesh)
print("=== Normal Vector Verification Result ===")
print(f"Total triangles: {total}")
print(f"Flipped normals: {flipped}")
print(f"Flip rate: {percent:.2f}%")
if flipped == 0:
print("\n✅ All normals point in the correct direction")
print(" This mesh is 3D-printable")
elif percent < 5:
print("\n⚠️ Some normals are flipped (minor)")
print(" The slicer is likely to correct them automatically")
else:
print("\n❌ Many normals are flipped (serious)")
print(" Repair with a mesh tool (Meshmixer, netfabb) is recommended")
# Example output:
# === Normal Vector Verification Result ===
# Total triangles: 2456
# Flipped normals: 0
# Flip rate: 0.00%
#
# ✅ All normals point in the correct direction
# This mesh is 3D-printable
# ===================================
# Example 3: Checking manifoldness (Watertight)
# ===================================
import trimesh
# Load the STL file (trimesh attempts automatic repair)
mesh = trimesh.load('model.stl')
print("=== Mesh Quality Diagnosis ===")
# Basic information
print(f"Vertex count: {len(mesh.vertices)}")
print(f"Face count: {len(mesh.faces)}")
print(f"Volume: {mesh.volume:.2f} mm³")
# Check manifoldness
print(f"\n=== 3D Print Suitability Check ===")
print(f"Is watertight: {mesh.is_watertight}")
print(f"Is winding consistent: {mesh.is_winding_consistent}")
print(f"Is valid (geometric validity): {mesh.is_valid}")
# Diagnose problems in detail
if not mesh.is_watertight:
# Detect the number of holes
try:
edges = mesh.edges_unique
edges_sorted = mesh.edges_sorted
duplicate_edges = len(edges_sorted) - len(edges)
print(f"\n⚠️ Problem detected:")
print(f" - The mesh has holes")
print(f" - Duplicate edge count: {duplicate_edges}")
except:
print(f"\n⚠️ There is a problem with the mesh structure")
# Attempt repair
if not mesh.is_watertight or not mesh.is_winding_consistent:
print(f"\n🔧 Running automatic repair...")
# Fix normals
trimesh.repair.fix_normals(mesh)
print(" ✓ Fixed normal vectors")
# Fill holes
trimesh.repair.fill_holes(mesh)
print(" ✓ Filled holes")
# Remove degenerate triangles
mesh.remove_degenerate_faces()
print(" ✓ Removed degenerate faces")
# Merge duplicate vertices
mesh.merge_vertices()
print(" ✓ Merged duplicate vertices")
# Check the state after repair
print(f"\n=== State After Repair ===")
print(f"Is watertight: {mesh.is_watertight}")
print(f"Is winding consistent: {mesh.is_winding_consistent}")
# Save the repaired mesh
if mesh.is_watertight:
mesh.export('model_repaired.stl')
print(f"\n✅ Repair complete! Saved as model_repaired.stl")
else:
print(f"\n❌ Automatic repair failed. A dedicated tool such as Meshmixer is recommended")
else:
print(f"\n✅ This mesh is 3D-printable")
# Example output:
# === Mesh Quality Diagnosis ===
# Vertex count: 1534
# Face count: 2456
# Volume: 12450.75 mm³
#
# === 3D Print Suitability Check ===
# Is watertight: True
# Is winding consistent: True
# Is valid (geometric validity): True
#
# ✅ This mesh is 3D-printable
Confirm through this chapter that you can now explain the following.
Which is the correct statement about the ASCII and Binary forms of the STL file?
a) The ASCII form has a smaller file size
b) The Binary form is a human-readable text format
c) The Binary form is typically 5–10 times smaller in file size than the ASCII form
d) The Binary form has lower precision than the ASCII form
Correct: c) The Binary form is typically 5–10 times smaller in file size than the ASCII form
Explanation:
Concrete example: A 10,000-triangle model → ASCII: about 7 MB, Binary: about 0.5 MB
You build a part of volume 12,000 mm³ and height 30 mm with a layer height of 0.2 mm and a print speed of 50 mm/s. Approximately what is the build time? (Assume 20% infill and 2 wall layers.)
a) 30 minutes
b) 60 minutes
c) 90 minutes
d) 120 minutes
Correct: c) 90 minutes (about 1.5 hours)
Calculation steps:
Key point: The estimate provided by slicer software includes acceleration/deceleration, travel, and temperature stabilization, so it is roughly 4–6× the simple calculation.
Choose the optimal AM process for the following application: "A titanium-alloy fuel injection nozzle for an aircraft engine, with complex internal flow channels and requirements for high strength and high heat resistance."
a) FDM (Fused Deposition Modeling)
b) SLA (Stereolithography)
c) SLM (Selective Laser Melting)
d) Binder Jetting
Correct: c) SLM (Selective Laser Melting / Powder Bed Fusion for Metal)
Reason:
Concrete example: GE Aviation's LEAP fuel nozzle (made by SLM) consolidated 20 previously welded parts into one, achieving a 25% weight reduction and 5× durability improvement.
Complete the following Python code to verify the manifoldness (watertight) of an STL file.
import trimesh
mesh = trimesh.load('model.stl')
# Add code here: check manifoldness, perform automatic
# repair if there are problems, and save the repaired mesh
# as 'model_fixed.stl'
Example answer:
import trimesh
mesh = trimesh.load('model.stl')
# Check manifoldness
print(f"Is watertight: {mesh.is_watertight}")
print(f"Is winding consistent: {mesh.is_winding_consistent}")
# Repair if there are problems
if not mesh.is_watertight or not mesh.is_winding_consistent:
print("Running mesh repair...")
# Fix normals
trimesh.repair.fix_normals(mesh)
# Fill holes
trimesh.repair.fill_holes(mesh)
# Remove degenerate triangles
mesh.remove_degenerate_faces()
# Merge duplicate vertices
mesh.merge_vertices()
# Check the repair result
print(f"After repair, watertight: {mesh.is_watertight}")
# Save the repaired mesh
if mesh.is_watertight:
mesh.export('model_fixed.stl')
print("Repair complete: saved as model_fixed.stl")
else:
print("⚠️ Automatic repair failed. Please use a tool such as Meshmixer")
else:
print("✓ The mesh is 3D-printable")
Explanation:
trimesh.repair.fix_normals(): Unify the direction of normal vectorstrimesh.repair.fill_holes(): Fill holes in the meshremove_degenerate_faces(): Remove degenerate triangles with zero areamerge_vertices(): Merge duplicate verticesPractical point: Complex problems that even trimesh cannot repair require dedicated tools such as Meshmixer, Netfabb, or MeshLab.
A cylinder of diameter 40 mm and height 30 mm is built tilted at 45 degrees from the base. Assuming a support density of 15% and a layer height of 0.2 mm, estimate the approximate support material volume.
Solution process:
Answer: about 1,000 mm³ (990 mm³)
Practical considerations:
You build a part of height 60 mm, balancing quality and time. Given the three choices of layer height 0.1 mm, 0.2 mm, and 0.3 mm, explain the build-time ratio and recommended use of each.
Answer:
| Layer height | Number of layers | Time ratio | Quality | Recommended use |
|---|---|---|---|---|
| 0.1 mm | 600 layers | ×3.0 | Very high | Display figures, medical models, end-use parts |
| 0.2 mm | 300 layers | ×1.0 (baseline) | Good | General prototypes, functional parts |
| 0.3 mm | 200 layers | ×0.67 | Low | Early prototypes, strength-priority internal parts |
Basis for the time ratio:
Practical selection criteria:
Variable layer height (Advanced):
Using the variable layer-height feature of PrusaSlicer or Cura, you can mix 0.3 mm on flat areas and 0.1 mm on curved areas to achieve both quality and time.
Select the optimal AM process for manufacturing an aerospace lightweight bracket (aluminum alloy, topology-optimized complex shape, requirements for high strength and light weight), and give three reasons. Also, list two post-processes to consider.
Optimal process: LPBF (Laser Powder Bed Fusion) - SLM for Aluminum
Reasons for selection (three):
Required post-processes (two):
Additional considerations:
Concrete example: Airbus A350 titanium bracket
A bracket previously assembled from 32 parts was consolidated into one, achieving a 55% weight reduction, 65% lead-time reduction, and 35% cost reduction.
In Chapter 1, as the fundamentals of additive manufacturing (AM), we learned the seven process categories per ISO/ASTM 52900, the structure of the STL file format, and the basics of slicing and G-code. In the next Chapter 2, we will learn the detailed build process, material properties, and process-parameter optimization of Material Extrusion (FDM/FFF).