Chapter 3: Fundamentals of Additive Manufacturing

AM Technology Principles and Classification - Technical Framework of 3D Printing

📖 Reading Time: 35-40 minutes 📊 Difficulty: Beginner to Intermediate 💻 Code Examples: 0 📝 Exercises: 0

AI Terakoya Home:Materials Science:3D Printing Introduction:Chapter 3

🌐 EN | 日本語 (準備中) Last sync: 2025-11-16

Learning Objectives

Upon completing this chapter, you will be able to explain:

Basic Understanding (Level 1)

Practical Skills (Level 2)

Application Capability (Level 3)

1.1 What is Additive Manufacturing (AM)?

1.1.1 Definition of Additive Manufacturing

Additive Manufacturing (AM) is defined by ISO/ASTM 52900:2021 as “a process of joining materials to make objects from 3D model data, usually layer upon layer”. In contrast to traditional subtractive manufacturing (machining), AM adds material only where needed, offering revolutionary characteristics:

Industrial Significance

The AM market is experiencing rapid growth. According to Wohlers Report 2023:

1.1.2 History and Development of AM

Additive manufacturing technology has approximately 40 years of history, reaching the present through the following milestones:

flowchart LR
    A[1986  
SLA Invention  
Chuck Hull] --> B[1988  
SLS Launch  
Carl Deckard]
    B --> C[1992  
FDM Patent  
Stratasys]
    C --> D[2005  
RepRap  
Open Source]
    D --> E[2012  
Metal AM Adoption  
EBM/SLM]
    E --> F[2023  
Industrial Scale  
Large-Scale & High-Speed]

    style A fill:#e3f2fd
    style B fill:#fff3e0
    style C fill:#e8f5e9
    style D fill:#f3e5f5
    style E fill:#fce4ec
    style F fill:#fff9c4
  1. 1986: Stereolithography (SLA) Invention - Dr. Chuck Hull (3D Systems founder) invented the first AM technology using layer-by-layer curing of photopolymer resin (US Patent 4,575,330). The term “3D Printing” also originated during this period.
  2. 1988: Selective Laser Sintering (SLS) Launch - Dr. Carl Deckard (University of Texas) developed technology to sinter powder materials with a laser, opening possibilities for metals and ceramics.
  3. 1992: Fused Deposition Modeling (FDM) Patent - Stratasys commercialized FDM technology, establishing the foundation for currently the most widespread 3D printing method.
  4. 2005: RepRap Project - Professor Adrian Bowyer announced the open-source 3D printer “RepRap”. Combined with patent expiration, this accelerated cost reduction and democratization.
  5. 2012 onwards: Industrial Adoption of Metal AM - Electron Beam Melting (EBM) and Selective Laser Melting (SLM) found practical use in aerospace and medical fields. GE Aviation began mass production of LEAP fuel injection nozzles.
  6. 2023 Present: Era of Scale-up and High-Speed - New technologies such as Binder Jetting, continuous fiber composite AM, and multi-material AM entering industrial implementation stage.

1.1.3 Major Application Areas of AM

Application 1: Rapid Prototyping

The first major use of AM, rapidly manufacturing prototypes for design verification, functional testing, and market evaluation:

Application 2: Tooling & Fixtures

Application of AM for manufacturing jigs, tools, and molds used in production facilities:

Application 3: End-Use Parts

Direct manufacturing of final products with AM has increased rapidly in recent years:

AM Constraints and Challenges

AM is not universal and has the following constraints:

1.2 Seven AM Process Categories by ISO/ASTM 52900

1.2.1 Overview of AM Process Classification

ISO/ASTM 52900:2021 standard classifies all AM technologies into 7 process categories based on energy source and material feed method. Each process has unique advantages and disadvantages, requiring selection of optimal technology based on application.

flowchart TD
    AM[Additive Manufacturing  
7 Process Categories] --> MEX[Material Extrusion  
MEX]
    AM --> VPP[Vat Photopolymerization  
VPP]
    AM --> PBF[Powder Bed Fusion  
PBF]
    AM --> MJ[Material Jetting  
MJ]
    AM --> BJ[Binder Jetting  
BJ]
    AM --> SL[Sheet Lamination  
SL]
    AM --> DED[Directed Energy Deposition  
DED]

    MEX --> MEX_EX[FDM/FFF  
Low Cost & Widespread]
    VPP --> VPP_EX[SLA/DLP  
High Precision & Surface Quality]
    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

1.2.2 Material Extrusion (MEX)

Principle : Thermoplastic filament is heated, melted, extruded through a nozzle and deposited layer-by-layer. The most widespread technology (also called FDM/FFF).

Process: Filament → Heated Nozzle (190-260°C) → Melt Extrusion → Cooling Solidification → Next Layer Deposition

Features:

Applications:

Representative FDM Equipment

1.2.3 Vat Photopolymerization (VPP)

Principle : Liquid photopolymer resin is selectively cured layer-by-layer using UV laser or projector light, then stacked.

Process: UV Irradiation → Photopolymerization Reaction → Solidification → Build Platform Raises → Next Layer Irradiation

Two main VPP methods:

  1. SLA (Stereolithography) : UV laser (355 nm) scanned by galvanometer mirrors, point-by-point curing. High precision but slow.
  2. DLP (Digital Light Processing) : Entire layer exposed at once with projector. Fast but resolution dependent on projector pixels (Full HD: 1920x1080).
  3. LCD-MSLA (Masked SLA) : Uses LCD mask, similar to DLP but lower cost ($200-$1,000 desktop systems numerous).

Features:

Applications:

1.2.4 Powder Bed Fusion (PBF)

Principle : Powder material is spread thin, selectively melted/sintered with laser or electron beam, cooled and solidified, then stacked. Applicable to metals, polymers, and ceramics.

Process: Powder Spreading → Laser/Electron Beam Scanning → Melting/Sintering → Solidification → Next Layer Powder Spreading

Three main PBF methods:

  1. SLS (Selective Laser Sintering) : Laser sintering of polymer powder (PA12 nylon etc.). No support needed (surrounding powder provides support).
  2. SLM (Selective Laser Melting) : Complete melting of metal powder (Ti-6Al-4V, AlSi10Mg, Inconel 718 etc.). Enables high-density parts (relative density >99%).
  3. EBM (Electron Beam Melting) : Metal powder melting with electron beam. High-temperature preheating (650-1000°C) reduces residual stress, faster build speed.

Features:

Applications:

1.2.5 Material Jetting (MJ)

Principle : Similar to inkjet printing, droplets of material (photopolymer resin or wax) are jetted from print heads, immediately cured with UV, then stacked.

Features:

Applications: Medical anatomical models (reproducing soft/hard tissue with different materials), full-color architectural models, design verification models

1.2.6 Binder Jetting (BJ)

Principle : Liquid binder (adhesive) jetted onto powder bed using inkjet method, bonding powder particles. After building, sintering or infiltration treatment improves strength.

Features:

Applications: Sand casting molds (large castings like engine blocks), metal parts (Desktop Metal, HP Metal Jet), full-color figurines (memorial items, educational models)

1.2.7 Sheet Lamination (SL)

Principle : Sheet materials (paper, metal foil, plastic film) are laminated and bonded by adhesive or welding. Each layer is contour-cut with laser or blade.

Representative Technologies:

Features: Large builds possible, low material cost, medium precision, limited applications (mainly visual models, embedded sensors in metal)

1.2.8 Directed Energy Deposition (DED)

Principle : While feeding metal powder or wire, melting with laser/electron beam/arc and depositing on substrate. Used for large parts or repair of existing parts.

Features:

Applications: Turbine blade repair, large aerospace parts, tool wear-resistant coating

Guidelines for Process Selection

Optimal AM process varies by application requirements:

1.3 STL File Format and Data Processing

1.3.1 Structure of STL Files

STL (STereoLithography) is the most widely used 3D model file format in AM , developed by 3D Systems in 1987. STL files represent object surfaces as a collection of triangle meshes.

Basic Structure of STL Files

STL File = Normal Vector (n) + 3 Vertex Coordinates (v1, v2, v3) × Number of Triangles

Example of 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

Two types of STL format:

  1. ASCII STL : Human-readable text format. Large file size (10-20x Binary for same model). Useful for debugging and verification.
  2. Binary STL : Binary format, smaller file size, faster processing. Standard for industrial use. Structure: 80-byte header + 4-byte (triangle count) + 50 bytes per triangle (12B normal + 36B vertices + 2B attribute).

1.3.2 Key Concepts of STL Files

1. Normal Vector

Each triangle face has a defined normal vector (outward direction) distinguishing object “inside” from “outside”. Normal direction is determined by right-hand rule :

Normal n = (v2 - v1) × (v3 - v1) / |(v2 - v1) × (v3 - v1)|

Vertex Order Rule: Vertices v1, v2, v3 are arranged counter-clockwise (CCW), and when viewed from outside, the counter-clockwise ordering makes normals point outward.

2. Manifold Condition

For an STL mesh to be 3D printable, it must be manifold :

Non-Manifold Mesh Issues

Non-manifold meshes are not 3D printable. Typical problems:

These problems cause slicer software errors and lead to build failures.

1.3.3 Quality Metrics for STL Files

STL mesh quality is evaluated by the following metrics:

  1. Triangle Count : Typically 10,000-500,000. Avoid too few (coarse model) or too many (large file size & processing delay).
  2. Edge Length Uniformity : Extreme mix of large and small triangles reduces build quality. Ideally 0.1-1.0 mm range.
  3. Aspect Ratio : Elongated triangles (high aspect ratio) cause numerical errors. Ideally aspect ratio < 10.
  4. Normal Consistency : All normals pointing outward. Mixed inverted normals cause inside/outside determination errors.

STL File Resolution Trade-offs

STL mesh resolution (triangle count) is a trade-off between precision and file size:

When exporting STL from CAD software, control resolution with Chordal Tolerance or Angle Tolerance. Recommended values: chordal tolerance 0.01-0.1 mm, angle tolerance 5-15 degrees.

1.3.4 STL Processing with Python

Major Python libraries for handling STL files:

  1. numpy-stl : Fast STL read/write, volume & surface area calculation, normal vector operations. Simple and lightweight.
  2. trimesh : Comprehensive 3D mesh processing library. Mesh repair, Boolean operations, raycasting, collision detection. Feature-rich but many dependencies.
  3. PyMesh : Advanced mesh processing (remeshing, subdivision, feature extraction). Installation somewhat complex.

Basic numpy-stl usage:

# Requirements:
# - Python 3.9+
# - numpy>=1.24.0, <2.0.0

"""
Example: Basic numpy-stl usage:

Purpose: Demonstrate core concepts and implementation patterns
Target: Beginner to Intermediate
Execution time: ~5 seconds
Dependencies: None
"""

from stl import mesh
import numpy as np

# Load 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)}")

1.4 Slicing and Toolpath Generation

The process of converting STL files into commands (G-code) that 3D printers understand is called Slicing. This section covers the basic principles of slicing, toolpath strategies, and G-code fundamentals.

1.4.1 Basic Principles of Slicing

Slicing is the process of horizontally cutting a 3D model at constant height (layer height) and extracting the contour of each layer:

flowchart TD
    A[3D Model  
STL File] --> B[Slice in Z-axis  
Layer-by-Layer]
    B --> C[Extract Layer Contours  
Contour Detection]
    C --> D[Generate Shells  
Perimeter Path]
    D --> E[Generate Infill  
Infill Path]
    E --> F[Add Supports  
Support Structure]
    F --> G[Optimize Toolpath  
Retraction/Travel]
    G --> H[G-code Output]

    style A fill:#e3f2fd
    style H fill:#e8f5e9

Layer Height Selection

Layer height is the most critical parameter determining the trade-off between build quality and build time:

Layer HeightBuild QualityBuild TimeTypical Applications
0.1 mm (Ultra-fine)Very high (layer lines barely visible)Very long (2-3x)Figurines, medical models, end-use products
0.2 mm (Standard)Good (layer lines visible but acceptable)StandardGeneral prototypes, functional parts
0.3 mm (Coarse)Low (layer lines prominent)Short (0.5x)Initial prototypes, internal structure parts

Layer Height Constraints

Layer height must be set to 25-80% of nozzle diameter. For example, with 0.4mm nozzle, layer height of 0.1-0.32mm is the recommended range. Exceeding this causes insufficient extrusion or nozzle dragging on previous layers.

1.4.2 Shell and Infill Strategies

Shell (Perimeter) Generation

Shell (Shell/Perimeter) is the path forming the outer perimeter of each layer:

Infill Patterns

Infill forms internal structure, controlling strength and material usage:

PatternStrengthPrint SpeedMaterial UsageFeatures
GridMediumFastMediumSimple, isotropic, standard choice
HoneycombHighSlowMediumHigh strength, excellent weight ratio, aerospace use
GyroidVery HighMediumMedium3D isotropic, curved, latest recommendation
ConcentricLowFastLowFlexibility priority, follows shells
LinesLow (anisotropic)Very FastLowHigh-speed printing, directional strength

Infill Density Guidelines

1.4.3 Support Structure Generation

Parts with overhang angles exceeding 45 degrees require Support Structures :

Support Types

Critical Support Parameters

ParameterRecommended ValueEffect
Overhang Angle45-60°Supports generated above this angle
Support Density10-20%Higher density more stable but difficult to remove
Support Z Distance0.2-0.3 mmGap between support and part (removability)
Interface Layers2-4 layersNumber of interface layers (balance of surface quality and removability)

1.4.4 G-code Fundamentals

G-code is the standard numerical control language for controlling 3D printers and CNC machines. Each line represents one command:

Major G-code Commands

CommandCategoryFunctionExample
G0MovementRapid movement (no extrusion)G0 X100 Y50 Z10 F6000
G1MovementLinear movement (with extrusion)G1 X120 Y60 E0.5 F1200
G28InitializationReturn to home positionG28 (all axes), G28 Z (Z-axis only)
M104TemperatureSet nozzle temperature (non-blocking)M104 S200
M109TemperatureSet nozzle temperature (blocking)M109 S210
M140TemperatureSet bed temperature (non-blocking)M140 S60
M190TemperatureSet bed temperature (blocking)M190 S60

G-code Example (Build Start Section)

; === Start G-code ===
M140 S60       ; Start heating bed to 60°C (non-blocking)
M104 S210      ; Start heating nozzle to 210°C (non-blocking)
G28            ; Home all axes
G29            ; Auto bed leveling (bed mesh measurement)
M190 S60       ; Wait for bed temperature to reach target
M109 S210      ; Wait for nozzle temperature to reach target
G92 E0         ; Reset extrusion distance to zero
G1 Z2.0 F3000  ; Raise Z-axis 2mm (safety clearance)
G1 X10 Y10 F5000  ; Move to priming position
G1 Z0.3 F3000  ; Lower Z-axis to 0.3mm (first layer height)
G1 X100 E10 F1500 ; Draw prime line (clear nozzle clogs)
G92 E0         ; Reset extrusion distance to zero again
; === Build Start ===

1.4.5 Major Slicing Software

SoftwareLicenseFeaturesRecommended Use
CuraOpen SourceEasy to use, abundant presets, standard Tree SupportBeginners to intermediate, FDM general purpose
PrusaSlicerOpen SourceAdvanced settings, variable layer height, custom supportsIntermediate to advanced, optimization focus
Slic3rOpen SourcePrusaSlicer predecessor, lightweightLegacy systems, research use
Simplify3DCommercial ($150)Fast slicing, multi-process, detailed controlProfessional, industrial use
IdeaMakerFreeRaise3D dedicated but versatile, intuitive UIRaise3D users, beginners

1.4.6 Toolpath Optimization Strategies

Efficient toolpaths improve build time, quality, and material usage:

Python Examples

Example 1: Loading STL File and Retrieving Basic Information

# Requirements:
# - Python 3.9+
# - numpy>=1.24.0, <2.0.0

"""
Example: Example 1: Loading STL File and Retrieving Basic Information

Purpose: Demonstrate neural network implementation
Target: Beginner to Intermediate
Execution time: 5-10 seconds
Dependencies: None
"""

# ===================================
# Example 1: Loading STL File and Retrieving Basic Information
# ===================================

import numpy as np
from stl import mesh

# Load STL file
your_mesh = mesh.Mesh.from_file('model.stl')

# Retrieve 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)}")

# Calculate bounding box (minimum enclosing cuboid)
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)")

# Simple build time estimation (assuming 0.2mm layer height, 50mm/s speed)
layer_height = 0.2  # mm
print_speed = 50    # mm/s
num_layers = int(dimensions[2] / layer_height)
# Simple calculation: estimation 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 Estimation ===")
print(f"Number of Layers (0.2mm/layer): {num_layers} layers")
print(f"Estimated Build Time: {estimated_time_minutes:.1f} minutes ({estimated_time_minutes/60:.2f} hours)")

# Output example:
# === 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 Estimation ===
# Number of Layers (0.2mm/layer): 150 layers
# Estimated Build Time: 97.2 minutes (1.62 hours)

Example 2: Mesh Normal Vector Verification

# Requirements:
# - Python 3.9+
# - numpy>=1.24.0, <2.0.0

# ===================================
# Example 2: Mesh Normal Vector Verification
# ===================================

import numpy as np
from stl import mesh

def check_normals(mesh_data):
    """Check STL mesh normal vector consistency

    Args:
        mesh_data: numpy-stl Mesh object

    Returns:
        tuple: (flipped_count, total_count, percentage)
    """
    # Check normal direction using right-hand rule
    flipped_count = 0
    total_count = len(mesh_data.vectors)

    for i, facet in enumerate(mesh_data.vectors):
        v0, v1, v2 = facet

        # Calculate edge vectors
        edge1 = v1 - v0
        edge2 = v2 - v0

        # Calculate normal with cross product (right-hand system)
        calculated_normal = np.cross(edge1, edge2)

        # Normalize
        norm = np.linalg.norm(calculated_normal)
        if norm > 1e-10:  # Verify not zero vector
            calculated_normal = calculated_normal / norm
        else:
            continue  # Skip degenerate triangles

        # Compare with stored normal in 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 alignment with dot product
        dot_product = np.dot(calculated_normal, stored_normal)

        # If dot product is negative, directions are opposite
        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 STL file
your_mesh = mesh.Mesh.from_file('model.stl')

# Execute normal check
flipped, total, percent = check_normals(your_mesh)

print("=== Normal Vector Verification Results ===")
print(f"Total Triangles: {total}")
print(f"Flipped Normals: {flipped}")
print(f"Flipped Ratio: {percent:.2f}%")

if flipped == 0:
    print("\nAll normals point in correct direction")
    print("   This mesh is 3D printable")
elif percent < 5:
    print("\nSome normals are flipped (minor)")
    print("   Slicer likely to auto-correct")
else:
    print("\nMany normals are flipped (critical)")
    print("   Recommend repair with tools (Meshmixer, netfabb)")

# Output example:
# === Normal Vector Verification Results ===
# Total Triangles: 2456
# Flipped Normals: 0
# Flipped Ratio: 0.00%
#
# All normals point in correct direction
#    This mesh is 3D printable

Example 3: Manifold Check

# ===================================
# Example 3: Manifold (Watertight) Check
# ===================================

import trimesh

# Load STL file (trimesh automatically attempts 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 manifold properties
print(f"\n=== 3D Printability Check ===")
print(f"Is watertight (closure): {mesh.is_watertight}")
print(f"Is winding consistent (normal consistency): {mesh.is_winding_consistent}")
print(f"Is valid (geometric validity): {mesh.is_valid}")

# Diagnose problem details
if not mesh.is_watertight:
    # Detect number of holes
    try:
        edges = mesh.edges_unique
        edges_sorted = mesh.edges_sorted
        duplicate_edges = len(edges_sorted) - len(edges)
        print(f"\nProblems detected:")
        print(f"   - Mesh has holes")
        print(f"   - Duplicate edges: {duplicate_edges}")
    except:
        print(f"\nMesh structure has problems")

# Attempt repair
if not mesh.is_watertight or not mesh.is_winding_consistent:
    print(f"\nExecuting automatic repair...")

    # Fix normals
    trimesh.repair.fix_normals(mesh)
    print("   Normal vectors corrected")

    # Fill holes
    trimesh.repair.fill_holes(mesh)
    print("   Holes filled")

    # Remove degenerate faces
    mesh.remove_degenerate_faces()
    print("   Degenerate faces removed")

    # Merge duplicate vertices
    mesh.merge_vertices()
    print("   Duplicate vertices merged")

    # Check post-repair state
    print(f"\n=== Post-Repair State ===")
    print(f"Is watertight: {mesh.is_watertight}")
    print(f"Is winding consistent: {mesh.is_winding_consistent}")

    # Save repaired mesh
    if mesh.is_watertight:
        mesh.export('model_repaired.stl')
        print(f"\nRepair complete! Saved as model_repaired.stl")
    else:
        print(f"\nAutomatic repair failed. Recommend dedicated tools like Meshmixer")
else:
    print(f"\nThis mesh is 3D printable")

# Output example:
# === Mesh Quality Diagnosis ===
# Vertex count: 1534
# Face count: 2456
# Volume: 12450.75 mm³
#
# === 3D Printability Check ===
# Is watertight (closure): True
# Is winding consistent (normal consistency): True
# Is valid (geometric validity): True
#
# This mesh is 3D printable

Chapter Exercises

Exercise 1: AM Process Selection

For the following applications, select the most appropriate AM process and explain your reasoning:

  1. Dental crown model (accuracy ±50μm)
  2. Prototype smartphone case (low cost, quick iteration)
  3. Titanium artificial hip joint (high strength, patient-specific)
  4. Architectural model with multiple colors
  5. Automotive jig for assembly line

Answer Hints

  1. VPP (SLA/DLP) - Highest precision, excellent surface finish
  2. MEX (FDM) - Lowest cost, fastest iteration
  3. PBF (SLM) - Metal capability, high strength, customizable geometry
  4. MJ or BJ - Multi-material/color capability
  5. MEX or PBF(SLS) - Cost-effective for tooling

Exercise 2: STL File Analysis

Write a Python script that:

  1. Loads an STL file and calculates its volume and surface area
  2. Determines if it fits within a 200x200x200mm build volume
  3. Estimates material cost (assuming PLA at $20/kg, density 1.24 g/cm³)
  4. Checks for manifold errors and reports any issues

Implementation Hint

Use numpy-stl for basic info and trimesh for manifold checking. Calculate material mass from volume and density, then multiply by cost per kg.

Exercise 3: Slicing Parameter Optimization

For a mechanical part requiring both strength and surface quality:

  1. Determine optimal layer height (nozzle = 0.4mm)
  2. Select appropriate infill pattern and density
  3. Choose shell count
  4. Estimate build time difference between 0.1mm and 0.3mm layer heights

Answer Approach

Exercise 4: G-code Analysis

Analyze the following G-code snippet and explain what it does:

G28
M190 S60
M109 S200
G92 E0
G1 X50 Y50 Z0.2 F3000
G1 X100 Y50 E5 F1500
G1 X100 Y100 E10 F1500

Answer

  1. G28: Home all axes
  2. M190 S60: Heat bed to 60°C and wait
  3. M109 S200: Heat nozzle to 200°C and wait
  4. G92 E0: Reset extruder position
  5. G1 X50 Y50 Z0.2 F3000: Move to start position at 0.2mm height
  6. G1 X100 Y50 E5 F1500: Draw line while extruding (prime nozzle)
  7. G1 X100 Y100 E10 F1500: Continue drawing perpendicular line

Exercise 5: Material Comparison

Compare PLA, ABS, and PETG for FDM printing across:

  1. Printing temperature range
  2. Strength and flexibility
  3. Ease of printing
  4. Best applications
Comparison Table MaterialTemp RangePropertiesEaseApplications
PLA190-220°CModerate strength, brittleEasyPrototypes, visual models
ABS220-250°CStrong, impact resistantModerateFunctional parts, enclosures
PETG220-250°CStrong, flexible, chemical resistantModerateFunctional parts, outdoor use

Exercise 6: Support Structure Design

For a part with a 60-degree overhang:

  1. Determine if support is needed (support angle threshold = 45°)
  2. Calculate approximate support material percentage
  3. Choose between linear and tree supports and justify
  4. Suggest optimal interface layer settings

Analysis

  1. Yes, support needed (60° > 45° threshold)
  2. Support volume depends on geometry, typically 10-30% of part volume
  3. Tree support recommended: 30-50% less material, easier removal
  4. Interface layers: 3-4 layers at 0.2mm Z-distance for good surface and easy removal

Chapter Summary

This chapter covered the fundamentals of Additive Manufacturing:

References

  1. ISO/ASTM 52900:2021 - Additive manufacturing - General principles - Fundamentals and vocabulary
  2. Wohlers Report 2023 - 3D Printing and Additive Manufacturing Global State of the Industry
  3. Gibson, I., Rosen, D., & Stucker, B. (2021). Additive Manufacturing Technologies (3rd ed.). Springer
  4. Chua, C. K., & Leong, K. F. (2017). 3D Printing and Additive Manufacturing: Principles and Applications (5th ed.). World Scientific
  5. numpy-stl Documentation: https://numpy-stl.readthedocs.io/
  6. trimesh Documentation: https://trimsh.org/
  7. Ultimaker Cura Documentation: https://github.com/Ultimaker/Cura
  8. PrusaSlicer Documentation: https://github.com/prusa3d/PrusaSlicer

Preview of Next Chapter

Chapter 4 will explore advanced topics in additive manufacturing:

← Chapter 2 Chapter 4 →

Disclaimer

← Previous Chapter Back to Series Index Next Chapter →