Chapter 4: Fundamentals of Additive Manufacturing

flowchart LR
    A[1986
SLA Invented
Chuck Hull] --> B[1988
SLS Introduced
Carl Deckard]
    B --> C[1992
FDM Patent
Stratasys Inc.]
    C --> D[2005
RepRap
Open Source]
    D --> E[2012
Metal AM Adoption
EBM/SLM]
    E --> F[2023
Industrial Acceleration
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
        

flowchart TD
    AM[productlayersbuild
7つprocess] --> MEX[Material Extrusion
Material Extrusion]
    AM --> VPP[Vat Photopolymerization
液槽光重合]
    AM --> PBF[Powder Bed Fusion
粉末床溶融結合]
    AM --> MJ[Material Jetting
材料噴射]
    AM --> BJ[Binder Jetting
結合剤噴射]
    AM --> SL[Sheet Lamination
シートproductlayers]
    AM --> DED[Directed Energy Deposition
指向性エネルギー堆product]

    MEX --> MEX_EX[FDM/FFF
Low Cost& Widespread]
    VPP --> VPP_EX[SLA/DLP
HighAccuracy・HighSurface Quality]
    PBF --> PBF_EX[SLS/SLM/EBM
High Strength・metal対応]

    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.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

ASCII STL形equation/formulaExample：

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-20 times Binary for same model). Useful for debugging and verification.
2. Binary STL: Binary format, small file size, fast processing. Standard for industrial use. Structure: 80-byte header + 4 bytes (triangle count) + 50 bytes per triangle (normal 12B + vertices 36B + attributes 2B).

1.3.2 Important Concepts of STL Files

1. Normal Vector

Each triangular face has a normal vector (outward direction) defined to distinguish between "inside" and "outside" of the object.Normal direction is determined by the right-hand rule:

Vertex Ordering Rule: Vertices v1, v2, v3 are arranged counter-clockwise (CCW), so that the normal points outward when viewed from outside.

2. Manifold Conditions

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

• Edge Sharing: Every edge is shared by exactly two triangles
• Vertex Sharing: Every vertex belongs to a continuous triangle fan
• Closed Surface: 穴and開口部なく、完全Closed Surface形成
• No Self-intersection: Triangles do not intersect or penetrate each other

1.3.3 STL File Quality Metrics

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 delays).
2. Edge Length Uniformity: Quality degrades with extreme variation in triangle sizes. Ideally in 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 consistently outward. Mixed inverted normals cause inside/outside determination errors.

1.3.4 STL Processing with Python Libraries

Major Python libraries for handling STL files:

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

numpy-stl基number of的な使用法：

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

"""
Example: numpy-stl基number of的な使用法：

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

# STL File読み込み
your_mesh = mesh.Mesh.from_file('model.stl')

# 基number of的な幾何情報
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²")

# triangle数
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 can understand is called slicing.こセクションat/in/with、スライシング基number ofPrinciple、ツールパス戦略、そしてG-code基礎学びます。

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[In Z-axis direction
Layer-wise slicing]
    B --> C[Contour extraction for each layer
Contour Detection]
    C --> D[Shell generation
Perimeter Path]
    D --> E[Infill generation
Infill Path]
    E --> F[Add support
Support Structure]
    F --> G[Toolpath optimization
Retraction/Travel]
    G --> H[G-code output]

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

Layer Height Selection

Layer height is the most important parameter determining the tradeoff between build quality and build time:

1.4.2 Shell and Infill Strategies

Shell (Perimeter) Generation

Shell/Perimeter is the path forming the outer periphery of each layer:

• Perimeter Count: Typically 2-4. Affects external quality and strength.
  • 1: Very weak, high transparency, decorative only
  • 2number of: Standard（good balance）
  • 3-4number of: High Strength、Surface Qualityimprovement、気密性improvement
• Shell Order: 内側→outside（Inside-Out）一般的。outside→内側Surface Quality重視時使用。

Infill (Internal Fill) Patterns

Infill forms internal structure and controls strength and material usage:

1.4.3 Support Structure Generation

Parts with overhang angles exceeding 45 degrees require support structures:

Support Types

• Linear Support: 垂直な柱状support。シンプルat/in/with除去しandす、Material Usage多。
• Tree Support: 樹木状minutes岐するsupport。Material Usage30-50%reduction、除去しandす。CuraandPrusaSlicerat/in/withStandardsupport。
• Interface Layers: support上面薄接合layers設ける。除去しandすく、Surface Qualityimprovement。typically2-4 layers。

Important Support Parameters

1.4.4 G-code Fundamentals

G-code、3DプリンタandCNCマシン制御するStandard的な数値制御言語at/in/withす。各行1つCommand表します：

Major G-code Commands

G-codeExample（build開始部minutes）

; === Start G-code ===
M140 S60       ; Start bed heating to 60°C (non-blocking)
M104 S210      ; Start nozzle heating to 210°C (non-blocking)
G28            ; Home all axes
G29            ; Auto-leveling (bed mesh measurement)
M190 S60       ; bedTemperature到達wait
M109 S210      ; nozzleTemperature到達wait
G92 E0         ; Reset extrusion to zero
G1 Z2.0 F3000  ; Raise Z-axis 2mm (safety)
G1 X10 Y10 F5000  ; プライム位置へMovement
G1 Z0.3 F3000  ; Z軸0.3mmへ降下（初layersHigh）
G1 X100 E10 F1500 ; Draw prime line (clear nozzle)
G92 E0         ; Reset extrusion again to zero
; === Build start ===

1.4.5 Major Slicing Software

1.4.6 Toolpath Optimization Strategies

効率的なツールパス、Build Time・品質・Material Usage改善します：

• Retraction: Movement時フィラメント引き戻してストリング（糸引き）防止。
  • Distance: 1-6mm (Bowden 4-6mm, direct 1-2mm)
  • Speed: 25-45 mm/s
  • Excessive retraction causes nozzle clogging
• Z-hop: Movement時nozzle上昇せてbuild物衝突times/iterations避。0.2-0.5mm上昇。Build Time微増だSurface Qualityimprovement。
• Combing: Movement経路インフィル上制限し、表面へMovement痕Lowreduction。外観重視時有効。
• Seam Position: Strategy for aligning layer start/end points.
  • Random: Random placement (inconspicuous)
  • Aligned: Aligned in line (easy to remove seam in post-processing)
  • Sharpest Corner: Place at sharpest corner (less noticeable)

Example 1: STL File読み込み基number of情報取得

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

"""
Example: Example 1: STL File読み込み基number of情報取得

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

# ===================================
# Example 1: STL File読み込み基number of情報取得
# ===================================

import numpy as np
from stl import mesh

# STL File読み込む
your_mesh = mesh.Mesh.from_file('model.stl')

# Get basic geometric information
volume, cog, inertia = your_mesh.get_mass_properties()

print("=== STL File基number of情報 ===")
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 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 (High: {dimensions[2]:.2f} mm)")

# Build Time簡易estimation（Layer Height0.2mm、speed度50mm/s仮定）
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 Estimation ===")
print(f"Number of layers (0.2mm/layer): {num_layers} layers")
print(f"estimationBuild Time: {estimated_time_minutes:.1f} minutes ({estimated_time_minutes/60:.2f} hours)")

# outputExample:
# === STL File基number of情報 ===
# 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 (High: 30.00 mm)
#
# === Build Estimation ===
# Number of layers (0.2mm/layer): 150 layers
# estimationBuild 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 consistency of normal vectors in STL mesh

    Args:
        mesh_data: numpy-stl Mesh object

    Returns:
        tuple: (flipped_count, total_count, percentage)
    """
    # Check normal direction with 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)
        calculated_normal = np.cross(edge1, edge2)

        # Normalize
        norm = np.linalg.norm(calculated_normal)
        if norm > 1e-10:  # Confirm 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 match with dot product
        dot_product = np.dot(calculated_normal, stored_normal)

        # If dot product negative, opposite direction
        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

# 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"Flip rate: {percent:.2f}%")

if flipped == 0:
    print("\n✅ All normals point in correct direction")
    print("   This mesh is 3D printable")
elif percent < 5:
    print("\n⚠️ Some normals are flipped (minor)")
    print("   スライサー自動修正するpossibilityHigh")
else:
    print("\n❌ Many normals are flipped (critical)")
    print("   Recommend repair with mesh repair tools (Meshmixer, netfabb)")

# outputExample:
# === Normal Vector Verification Results ===
# Total triangles: 2456
# Flipped normals: 0
# Flip rate: 0.00%
#
# ✅ All normals point in correct direction
#    This mesh is 3D printable

Example 3: Manifold Check

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

import trimesh

# STL File読み込み（trimesh自動at/in/with修復試みる）
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 property
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: {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"\n⚠️ Problem detected:")
        print(f"   - Mesh has holes")
        print(f"   - Duplicate edges: {duplicate_edges}")
    except:
        print(f"\n⚠️ Mesh structure has problems")

# Attempt repair
if not mesh.is_watertight or not mesh.is_winding_consistent:
    print(f"\n🔧 自動修復actual行Medium...")

    # Fix normals
    trimesh.repair.fix_normals(mesh)
    print("   ✓ Fixed normal vectors")

    # Fill holes
    trimesh.repair.fill_holes(mesh)
    print("   ✓ Filled holes")

    # Remove degenerate faces
    mesh.remove_degenerate_faces()
    print("   ✓ Removed degenerate faces")

    # Merge duplicate vertices
    mesh.merge_vertices()
    print("   ✓ Merged duplicate vertices")

    # Check post-repair status
    print(f"\n=== Post-repair Status ===")
    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"\n✅ Repair complete! Saved as model_repaired.stl")
    else:
        print(f"\n❌ Automatic repair failed. Recommend dedicated tools like Meshmixer")
else:
    print(f"\n✅ This mesh is 3D printable")

# outputExample:
# === 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: True
#
# ✅ This mesh is 3D printable

Example 4: Basic Slicing Algorithm

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

# ===================================
# Example 4: Basic Slicing Algorithm
# ===================================

import numpy as np
from stl import mesh

def slice_mesh_at_height(mesh_data, z_height):
    """Temperatureprofile生成

    Args:
        t (array): hoursarray [min]
        T_target (float): holdingTemperature [°C]
        heating_rate (float): heating rate [°C/min]
        hold_time (float): holdinghours [min]
        cooling_rate (float): cooling rate [°C/min]

    Returns:
        array: Temperatureprofile [°C]
    """
    T_room = 25  # room temperature
    T = np.zeros_like(t)

    # heatinghours
    t_heat = (T_target - T_room) / heating_rate

    # 冷却開始時刻
    t_cool_start = t_heat + hold_time

    for i, time in enumerate(t):
        if time <= t_heat:
            # heatingフェーズ
            T[i] = T_room + heating_rate * time
        elif time <= t_cool_start:
            # holdingフェーズ
            T[i] = T_target
        else:
            # 冷却フェーズ
            T[i] = T_target - cooling_rate * (time - t_cool_start)
            T[i] = max(T[i], T_room)  # room temperature以下ならな

    return T

def simulate_reaction_progress(T, t, Ea, D0, r0):
    """Temperatureprofile基づくreaction progress計算

    Args:
        T (array): Temperatureprofile [°C]
        t (array): hoursarray [min]
        Ea (float): activation energy [J/mol]
        D0 (float): frequency factor [m²/s]
        r0 (float): particle radius [m]

    Returns:
        array: conversion rate
    """
    R = 8.314
    C0 = 10000
    alpha = np.zeros_like(t)

    for i in range(1, len(t)):
        T_k = T[i] + 273.15
        D = D0 * np.exp(-Ea / (R * T_k))
        k = D * C0 / r0**2

        dt = (t[i] - t[i-1]) * 60  # min → s

        # 簡易productminutes（微小hoursat/in/withreaction progress）
        if alpha[i-1] < 0.99:
            dalpha = k * dt / (2 * (1 - (1-alpha[i-1])**(1/3)))
            alpha[i] = min(alpha[i-1] + dalpha, 1.0)
        else:
            alpha[i] = alpha[i-1]

    return alpha

# パラメータsetting
T_target = 1200  # °C
hold_time = 240  # min (4 hours)
Ea = 300e3  # J/mol
D0 = 5e-4  # m²/s
r0 = 5e-6  # m

# 異なるheating rateat/in/withcomparison
heating_rates = [2, 5, 10, 20]  # °C/min
cooling_rate = 3  # °C/min

# hoursarray
t_max = 800  # min
t = np.linspace(0, t_max, 2000)

# plot
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))

# Temperatureprofile
for hr in heating_rates:
    T_profile = temperature_profile(t, T_target, hr, hold_time, cooling_rate)
    ax1.plot(t/60, T_profile, linewidth=2, label=f'{hr}°C/min')

ax1.set_xlabel('Time (hours)', fontsize=12)
ax1.set_ylabel('Temperature (°C)', fontsize=12)
ax1.set_title('Temperature Profiles', fontsize=14, fontweight='bold')
ax1.legend(fontsize=10)
ax1.grid(True, alpha=0.3)
ax1.set_xlim([0, t_max/60])

# reaction progress
for hr in heating_rates:
    T_profile = temperature_profile(t, T_target, hr, hold_time, cooling_rate)
    alpha = simulate_reaction_progress(T_profile, t, Ea, D0, r0)
    ax2.plot(t/60, alpha, linewidth=2, label=f'{hr}°C/min')

ax2.axhline(y=0.95, color='red', linestyle='--', linewidth=1, label='Target (95%)')
ax2.set_xlabel('Time (hours)', fontsize=12)
ax2.set_ylabel('Conversion', fontsize=12)
ax2.set_title('Reaction Progress', fontsize=14, fontweight='bold')
ax2.legend(fontsize=10)
ax2.grid(True, alpha=0.3)
ax2.set_xlim([0, t_max/60])
ax2.set_ylim([0, 1])

plt.tight_layout()
plt.savefig('temperature_profile_optimization.png', dpi=300, bbox_inches='tight')
plt.show()

# 各heating rateat/in/with95%reaction attainmenthours計算
print("\n95%reaction attainmenthourscomparison:")
print("=" * 60)
for hr in heating_rates:
    T_profile = temperature_profile(t, T_target, hr, hold_time, cooling_rate)
    alpha = simulate_reaction_progress(T_profile, t, Ea, D0, r0)

    # 95%到達時刻
    idx_95 = np.where(alpha >= 0.95)[0]
    if len(idx_95) > 0:
        t_95 = t[idx_95[0]] / 60
        print(f"heating rate {hr:2d}°C/min: t₉₅ = {t_95:.1f} hours")
    else:
        print(f"heating rate {hr:2d}°C/min: 反応不完全")

# outputExample:
# 95%reaction attainmenthourscomparison:
# ============================================================
# heating rate  2°C/min: t₉₅ = 7.8 hours
# heating rate  5°C/min: t₉₅ = 7.2 hours
# heating rate 10°C/min: t₉₅ = 6.9 hours
# heating rate 20°C/min: t₉₅ = 6.7 hours

Exercises

1.5.1 pycalphad

pycalphad、CALPHAD（CALculation of PHAse Diagrams）法基づく相図計算ためPythonライブラリat/in/withす。熱力学データベースから平衡相計算し、反応経路設計有用at/in/withす。

1.5.2 二元system相図計算Example

# ===================================
# Example 5: pycalphadat/in/with相図計算
# ===================================

# 注意: pycalphadインストール必要
# pip install pycalphad

from pycalphad import Database, equilibrium, variables as v
import matplotlib.pyplot as plt
import numpy as np

# TDBデータベース読み込み（ここat/in/with簡易的なExample）
# actual際適切なTDBファイル必要
# Example: BaO-TiO2system

# 簡易的なTDB文字列（actual際より複雑）
tdb_string = """
$ BaO-TiO2 system (simplified)
ELEMENT BA   BCC_A2  137.327   !
ELEMENT TI   HCP_A3   47.867   !
ELEMENT O    GAS      15.999   !

FUNCTION GBCCBA   298.15  +GHSERBA;   6000 N !
FUNCTION GHCPTI   298.15  +GHSERTI;   6000 N !
FUNCTION GGASO    298.15  +GHSERO;    6000 N !

PHASE LIQUID:L %  1  1.0  !
PHASE BAO_CUBIC %  2  1 1  !
PHASE TIO2_RUTILE %  2  1 2  !
PHASE BATIO3 %  3  1 1 3  !
"""

# 注: actual際計算正equation/formulaなTDBファイル必要
# ここat/in/with概念的な説明留める

print("pycalphadよる相図計算概念:")
print("=" * 60)
print("1. TDBデータベース（熱力学データ）読み込む")
print("2. Temperature・組成範囲setting")
print("3. 平衡計算actual行")
print("4. 安定相可視化")
print()
print("actual際適用Example:")
print("- BaO-TiO2system: BaTiO3形成Temperature・組成範囲")
print("- Si-Nsystem: Si3N4安定領域")
print("- 多元systemセラミックス相関係")

# 概念的なplot（actualデータ基づくイメージ）
fig, ax = plt.subplots(figsize=(10, 7))

# Temperature範囲
T = np.linspace(800, 1600, 100)

# 各相安定領域（概念図）
# BaO + TiO2 → BaTiO3 反応
BaO_region = np.ones_like(T) * 0.3
TiO2_region = np.ones_like(T) * 0.7
BaTiO3_region = np.where((T > 1100) & (T < 1400), 0.5, np.nan)

ax.fill_between(T, 0, BaO_region, alpha=0.3, color='blue', label='BaO + TiO2')
ax.fill_between(T, BaO_region, TiO2_region, alpha=0.3, color='green',
                label='BaTiO3 stable')
ax.fill_between(T, TiO2_region, 1, alpha=0.3, color='red', label='Liquid')

ax.axhline(y=0.5, color='black', linestyle='--', linewidth=2,
           label='BaTiO3 composition')
ax.axvline(x=1100, color='gray', linestyle=':', linewidth=1, alpha=0.5)
ax.axvline(x=1400, color='gray', linestyle=':', linewidth=1, alpha=0.5)

ax.set_xlabel('Temperature (°C)', fontsize=12)
ax.set_ylabel('Composition (BaO mole fraction)', fontsize=12)
ax.set_title('Conceptual Phase Diagram: BaO-TiO2', fontsize=14, fontweight='bold')
ax.legend(fontsize=10, loc='upper right')
ax.grid(True, alpha=0.3)
ax.set_xlim([800, 1600])
ax.set_ylim([0, 1])

# テキスト注釈
ax.text(1250, 0.5, 'BaTiO₃\nformation\nregion',
        fontsize=11, ha='center', va='center',
        bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.7))

plt.tight_layout()
plt.savefig('phase_diagram_concept.png', dpi=300, bbox_inches='tight')
plt.show()

# actual際使用Example（コメントアウト）
"""
# actual際pycalphad使用Example
db = Database('BaO-TiO2.tdb')  # TDBファイル読み込み

# 平衡計算
eq = equilibrium(db, ['BA', 'TI', 'O'], ['LIQUID', 'BATIO3'],
                 {v.X('BA'): (0, 1, 0.01),
                  v.T: (1000, 1600, 50),
                  v.P: 101325})

# 結果plot
eq.plot()
"""

1.6 Design of Experiments（DOE）よる条件最適化

1.6.1 DOE

Design of Experiments（Design of Experiments, DOE）、複数パラメータ相互作用するsystemat/in/with、最小actual験times/iterations数at/in/with最適条件見つける統計手法at/in/withす。

固相反応at/in/with最適化すべき主要パラメータ：

• 反応Temperature（T）
• holdinghours（t）
• 粒子サイズ（r）
• 原料比（モル比）
• 雰囲気（空気、窒素、真空など）

1.6.2 応答曲面法（Response Surface Methodology）

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

# ===================================
# Example 6: DOEよる条件最適化
# ===================================

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from scipy.optimize import minimize

# 仮想的なconversion rateモデル（Temperaturehours関数）
def reaction_yield(T, t, noise=0):
    """Temperaturehoursからconversion rate計算（仮想モデル）

    Args:
        T (float): Temperature [°C]
        t (float): hours [hours]
        noise (float): ノイズレベル

    Returns:
        float: conversion rate [%]
    """
    # 最適値: T=1200°C, t=6 hours
    T_opt = 1200
    t_opt = 6

    # 二next/orderモデル（ガウス型）
    yield_val = 100 * np.exp(-((T-T_opt)/150)**2 - ((t-t_opt)/3)**2)

    # ノイズ追加
    if noise > 0:
        yield_val += np.random.normal(0, noise)

    return np.clip(yield_val, 0, 100)

# actual験点配置（Medium心複合計画法）
T_levels = [1000, 1100, 1200, 1300, 1400]  # °C
t_levels = [2, 4, 6, 8, 10]  # hours

# グリッドat/in/withactual験点配置
T_grid, t_grid = np.meshgrid(T_levels, t_levels)
yield_grid = np.zeros_like(T_grid, dtype=float)

# 各actual験点at/in/withconversion rate測定（シミュレーション）
for i in range(len(t_levels)):
    for j in range(len(T_levels)):
        yield_grid[i, j] = reaction_yield(T_grid[i, j], t_grid[i, j], noise=2)

# 結果表示
print("Design of Experimentsよる反応条件最適化")
print("=" * 70)
print(f"{'Temperature (°C)':<20} {'Time (hours)':<20} {'Yield (%)':<20}")
print("-" * 70)
for i in range(len(t_levels)):
    for j in range(len(T_levels)):
        print(f"{T_grid[i, j]:<20} {t_grid[i, j]:<20} {yield_grid[i, j]:<20.1f}")

# 最大conversion rate条件探す
max_idx = np.unravel_index(np.argmax(yield_grid), yield_grid.shape)
T_best = T_grid[max_idx]
t_best = t_grid[max_idx]
yield_best = yield_grid[max_idx]

print("-" * 70)
print(f"最適条件: T = {T_best}°C, t = {t_best} hours")
print(f"最大conversion rate: {yield_best:.1f}%")

# 3Dplot
fig = plt.figure(figsize=(14, 6))

# 3D表面plot
ax1 = fig.add_subplot(121, projection='3d')
T_fine = np.linspace(1000, 1400, 50)
t_fine = np.linspace(2, 10, 50)
T_mesh, t_mesh = np.meshgrid(T_fine, t_fine)
yield_mesh = np.zeros_like(T_mesh)

for i in range(len(t_fine)):
    for j in range(len(T_fine)):
        yield_mesh[i, j] = reaction_yield(T_mesh[i, j], t_mesh[i, j])

surf = ax1.plot_surface(T_mesh, t_mesh, yield_mesh, cmap='viridis',
                        alpha=0.8, edgecolor='none')
ax1.scatter(T_grid, t_grid, yield_grid, color='red', s=50,
            label='Experimental points')

ax1.set_xlabel('Temperature (°C)', fontsize=10)
ax1.set_ylabel('Time (hours)', fontsize=10)
ax1.set_zlabel('Yield (%)', fontsize=10)
ax1.set_title('Response Surface', fontsize=12, fontweight='bold')
ax1.view_init(elev=25, azim=45)
fig.colorbar(surf, ax=ax1, shrink=0.5, aspect=5)

# 等High線plot
ax2 = fig.add_subplot(122)
contour = ax2.contourf(T_mesh, t_mesh, yield_mesh, levels=20, cmap='viridis')
ax2.contour(T_mesh, t_mesh, yield_mesh, levels=10, colors='black',
            alpha=0.3, linewidths=0.5)
ax2.scatter(T_grid, t_grid, c=yield_grid, s=100, edgecolors='red',
            linewidths=2, cmap='viridis')
ax2.scatter(T_best, t_best, color='red', s=300, marker='*',
            edgecolors='white', linewidths=2, label='Optimum')

ax2.set_xlabel('Temperature (°C)', fontsize=11)
ax2.set_ylabel('Time (hours)', fontsize=11)
ax2.set_title('Contour Map', fontsize=12, fontweight='bold')
ax2.legend(fontsize=10)
fig.colorbar(contour, ax=ax2, label='Yield (%)')

plt.tight_layout()
plt.savefig('doe_optimization.png', dpi=300, bbox_inches='tight')
plt.show()

1.6.3 actual験計画actual践的アプローチ

actual際固相反応at/in/with、以下手順at/in/withDOE適用します：

1. スクリーニングactual験（2水準要因計画法）: 影響大きパラメータ特定
2. 応答曲面法（Medium心複合計画法）: 最適条件探索
3. 確認actual験: 予測れた最適条件at/in/withactual験し、モデル検証

1.7 反応speed度曲線フィッティング

1.7.1 actual験データからrate constant決定

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

"""
Example: 1.7.1 actual験データからrate constant決定

Purpose: Demonstrate data visualization techniques
Target: Intermediate
Execution time: 10-30 seconds
Dependencies: None
"""

# ===================================
# Example 7: 反応speed度曲線フィッティング
# ===================================

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# actual験データ（hours vs conversion rate）
# Example: BaTiO3合成 @ 1200°C
time_exp = np.array([0, 1, 2, 3, 4, 6, 8, 10, 12, 15, 20])  # hours
conversion_exp = np.array([0, 0.15, 0.28, 0.38, 0.47, 0.60,
                          0.70, 0.78, 0.84, 0.90, 0.95])

# Janderequation/formulaモデル
def jander_model(t, k):
    """Janderequation/formulaよるconversion rate計算

    Args:
        t (array): hours [hours]
        k (float): rate constant

    Returns:
        array: conversion rate
    """
    # [1 - (1-α)^(1/3)]² = kt  α つて解く
    kt = k * t
    alpha = 1 - (1 - np.sqrt(kt))**3
    alpha = np.clip(alpha, 0, 1)  # 0-1範囲制限
    return alpha

# Ginstling-Brounshteinequation/formula（別拡散モデル）
def gb_model(t, k):
    """Ginstling-Brounshteinequation/formula

    Args:
        t (array): hours
        k (float): rate constant

    Returns:
        array: conversion rate
    """
    # 1 - 2α/3 - (1-α)^(2/3) = kt
    # 数値的解く必要ある、ここat/in/with近似equation/formula使用
    kt = k * t
    alpha = 1 - (1 - kt/2)**(3/2)
    alpha = np.clip(alpha, 0, 1)
    return alpha

# Power law (経験equation/formula)
def power_law_model(t, k, n):
    """べき乗則モデル

    Args:
        t (array): hours
        k (float): rate constant
        n (float): 指数

    Returns:
        array: conversion rate
    """
    alpha = k * t**n
    alpha = np.clip(alpha, 0, 1)
    return alpha

# 各モデルat/in/withフィッティング
# Janderequation/formula
popt_jander, _ = curve_fit(jander_model, time_exp, conversion_exp, p0=[0.01])
k_jander = popt_jander[0]

# Ginstling-Brounshteinequation/formula
popt_gb, _ = curve_fit(gb_model, time_exp, conversion_exp, p0=[0.01])
k_gb = popt_gb[0]

# Power law
popt_power, _ = curve_fit(power_law_model, time_exp, conversion_exp, p0=[0.1, 0.5])
k_power, n_power = popt_power

# 予測曲線生成
t_fit = np.linspace(0, 20, 200)
alpha_jander = jander_model(t_fit, k_jander)
alpha_gb = gb_model(t_fit, k_gb)
alpha_power = power_law_model(t_fit, k_power, n_power)

# 残差計算
residuals_jander = conversion_exp - jander_model(time_exp, k_jander)
residuals_gb = conversion_exp - gb_model(time_exp, k_gb)
residuals_power = conversion_exp - power_law_model(time_exp, k_power, n_power)

# R²計算
def r_squared(y_true, y_pred):
    ss_res = np.sum((y_true - y_pred)**2)
    ss_tot = np.sum((y_true - np.mean(y_true))**2)
    return 1 - (ss_res / ss_tot)

r2_jander = r_squared(conversion_exp, jander_model(time_exp, k_jander))
r2_gb = r_squared(conversion_exp, gb_model(time_exp, k_gb))
r2_power = r_squared(conversion_exp, power_law_model(time_exp, k_power, n_power))

# plot
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))

# フィッティング結果
ax1.plot(time_exp, conversion_exp, 'ko', markersize=8, label='Experimental data')
ax1.plot(t_fit, alpha_jander, 'b-', linewidth=2,
         label=f'Jander (R²={r2_jander:.4f})')
ax1.plot(t_fit, alpha_gb, 'r-', linewidth=2,
         label=f'Ginstling-Brounshtein (R²={r2_gb:.4f})')
ax1.plot(t_fit, alpha_power, 'g-', linewidth=2,
         label=f'Power law (R²={r2_power:.4f})')

ax1.set_xlabel('Time (hours)', fontsize=12)
ax1.set_ylabel('Conversion', fontsize=12)
ax1.set_title('Kinetic Model Fitting', fontsize=14, fontweight='bold')
ax1.legend(fontsize=10)
ax1.grid(True, alpha=0.3)
ax1.set_xlim([0, 20])
ax1.set_ylim([0, 1])

# 残差plot
ax2.plot(time_exp, residuals_jander, 'bo-', label='Jander')
ax2.plot(time_exp, residuals_gb, 'ro-', label='Ginstling-Brounshtein')
ax2.plot(time_exp, residuals_power, 'go-', label='Power law')
ax2.axhline(y=0, color='black', linestyle='--', linewidth=1)

ax2.set_xlabel('Time (hours)', fontsize=12)
ax2.set_ylabel('Residuals', fontsize=12)
ax2.set_title('Residual Plot', fontsize=14, fontweight='bold')
ax2.legend(fontsize=10)
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('kinetic_fitting.png', dpi=300, bbox_inches='tight')
plt.show()

# 結果サマリー
print("\n反応speed度モデルフィッティング結果:")
print("=" * 70)
print(f"{'Model':<25} {'Parameter':<30} {'R²':<10}")
print("-" * 70)
print(f"{'Jander':<25} {'k = ' + f'{k_jander:.4f} h⁻¹':<30} {r2_jander:.4f}")
print(f"{'Ginstling-Brounshtein':<25} {'k = ' + f'{k_gb:.4f} h⁻¹':<30} {r2_gb:.4f}")
print(f"{'Power law':<25} {'k = ' + f'{k_power:.4f}, n = {n_power:.4f}':<30} {r2_power:.4f}")
print("=" * 70)
print(f"\n最適モデル: {'Jander' if r2_jander == max(r2_jander, r2_gb, r2_power) else 'GB' if r2_gb == max(r2_jander, r2_gb, r2_power) else 'Power law'}")

# outputExample:
# 反応speed度モデルフィッティング結果:
# ======================================================================
# Model                     Parameter                      R²
# ----------------------------------------------------------------------
# Jander                    k = 0.0289 h⁻¹                 0.9953
# Ginstling-Brounshtein     k = 0.0412 h⁻¹                 0.9867
# Power law                 k = 0.2156, n = 0.5234         0.9982
# ======================================================================
#
# 最適モデル: Power law

1.8 High度なトピック: 微細構造制御

1.8.1 粒成長抑制

固相反応at/in/with、Hightemperature・長hoursholdingより望ましくな粒成長起こります。これ抑制する戦略：

• Two-step sintering: Hightemperatureat/in/with短hoursholding後、Lowtemperatureat/in/with長hoursholding
• 添加剤使用: 粒成長抑制剤（Example: MgO, Al₂O₃）微量添加
• Spark Plasma Sintering (SPS): 急speedheating・短hours焼結

1.8.2 反応機械化学的活性化

メカノケミカル法（Highエネルギーボールミル）より、固相反応room temperature付近at/in/with進行せるこも可能at/in/withす：

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

# ===================================
# Example 8: 粒成長シミュレーション
# ===================================

import numpy as np
import matplotlib.pyplot as plt

def grain_growth(t, T, D0, Ea, G0, n):
    """粒成長hours発展

    Burke-Turnbullequation/formula: G^n - G0^n = k*t

    Args:
        t (array): hours [hours]
        T (float): Temperature [K]
        D0 (float): frequency factor
        Ea (float): activation energy [J/mol]
        G0 (float): 初期粒径 [μm]
        n (float): 粒成長指数（typically2-4）

    Returns:
        array: 粒径 [μm]
    """
    R = 8.314
    k = D0 * np.exp(-Ea / (R * T))
    G = (G0**n + k * t * 3600)**(1/n)  # hours → seconds
    return G

# パラメータsetting
D0_grain = 1e8  # μm^n/s
Ea_grain = 400e3  # J/mol
G0 = 0.5  # μm
n = 3

# Temperature影響
temps_celsius = [1100, 1200, 1300]
t_range = np.linspace(0, 12, 100)  # 0-12 hours

plt.figure(figsize=(12, 5))

# Temperature依存性
plt.subplot(1, 2, 1)
for T_c in temps_celsius:
    T_k = T_c + 273.15
    G = grain_growth(t_range, T_k, D0_grain, Ea_grain, G0, n)
    plt.plot(t_range, G, linewidth=2, label=f'{T_c}°C')

plt.axhline(y=1.0, color='red', linestyle='--', linewidth=1,
            label='Target grain size')
plt.xlabel('Time (hours)', fontsize=12)
plt.ylabel('Grain Size (μm)', fontsize=12)
plt.title('Grain Growth at Different Temperatures', fontsize=14, fontweight='bold')
plt.legend(fontsize=10)
plt.grid(True, alpha=0.3)
plt.ylim([0, 5])

# Two-step sintering効果
plt.subplot(1, 2, 2)

# Conventional sintering: 1300°C, 6 hours
t_conv = np.linspace(0, 6, 100)
T_conv = 1300 + 273.15
G_conv = grain_growth(t_conv, T_conv, D0_grain, Ea_grain, G0, n)

# Two-step: 1300°C 1h → 1200°C 5h
t1 = np.linspace(0, 1, 20)
G1 = grain_growth(t1, 1300+273.15, D0_grain, Ea_grain, G0, n)
G_intermediate = G1[-1]

t2 = np.linspace(0, 5, 80)
G2 = grain_growth(t2, 1200+273.15, D0_grain, Ea_grain, G_intermediate, n)

t_two_step = np.concatenate([t1, t2 + 1])
G_two_step = np.concatenate([G1, G2])

plt.plot(t_conv, G_conv, 'r-', linewidth=2, label='Conventional (1300°C)')
plt.plot(t_two_step, G_two_step, 'b-', linewidth=2, label='Two-step (1300°C→1200°C)')
plt.axvline(x=1, color='gray', linestyle=':', linewidth=1, alpha=0.5)

plt.xlabel('Time (hours)', fontsize=12)
plt.ylabel('Grain Size (μm)', fontsize=12)
plt.title('Two-Step Sintering Strategy', fontsize=14, fontweight='bold')
plt.legend(fontsize=10)
plt.grid(True, alpha=0.3)
plt.ylim([0, 5])

plt.tight_layout()
plt.savefig('grain_growth_control.png', dpi=300, bbox_inches='tight')
plt.show()

# 最終粒径comparison
G_final_conv = grain_growth(6, 1300+273.15, D0_grain, Ea_grain, G0, n)
G_final_two_step = G_two_step[-1]

print("\n粒成長comparison:")
print("=" * 50)
print(f"Conventional (1300°C, 6h): {G_final_conv:.2f} μm")
print(f"Two-step (1300°C 1h + 1200°C 5h): {G_final_two_step:.2f} μm")
print(f"粒径抑制効果: {(1 - G_final_two_step/G_final_conv)*100:.1f}%")

# outputExample:
# 粒成長comparison:
# ==================================================
# Conventional (1300°C, 6h): 4.23 μm
# Two-step (1300°C 1h + 1200°C 5h): 2.87 μm
# 粒径抑制効果: 32.2%

Learning Objectives確認

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

基number of理解

• ✅ 固相反応3つ律speed段階（核生成・界面反応・拡散）説明at/in/withきる
• ✅ Arrheniusequation/formula物理的意味Temperature依存性理解してる
• ✅ Janderequation/formulaGinstling-Brounshteinequation/formula違説明at/in/withきる
• ✅ Temperatureprofile3要素（heating rate・holdinghours・cooling rate）重要性理解してる

Practical Skills

• ✅ Pythonat/in/with拡散係数Temperature依存性シミュレートat/in/withきる
• ✅ Janderequation/formula用てreaction progress予測at/in/withきる
• ✅ Kissinger法at/in/withDSC/TGデータからactivation energy計算at/in/withきる
• ✅ DOE（Design of Experiments）at/in/with反応条件最適化at/in/withきる
• ✅ pycalphad用た相図計算基礎理解してる

応用力

• ✅ 新規セラミックス材料合成process設計at/in/withきる
• ✅ actual験データから反応機構estimationし、適切なspeed度equation/formula選択at/in/withきる
• ✅ 産業processat/in/with条件最適化戦略立案at/in/withきる
• ✅ 粒成長制御戦略（Two-step sintering等）提案at/in/withきる

Exercises

Easy（基礎確認）

Medium（応用）

import trimesh

mesh = trimesh.load('model.stl')

# ここコード追加: マニフォールド性チェックし、
# 問題あれば自動修復行、修復後メッシュ
# 'model_fixed.stl'して保存してくだ

import trimesh

mesh = trimesh.load('model.stl')

# Check manifold property
print(f"Is watertight: {mesh.is_watertight}")
print(f"Is winding consistent: {mesh.is_winding_consistent}")

# 問題ある場合修復
if not mesh.is_watertight or not mesh.is_winding_consistent:
    print("メッシュ修復actual行Medium...")

    # Fix normals
    trimesh.repair.fix_normals(mesh)

    # Fill holes
    trimesh.repair.fill_holes(mesh)

    # Remove degenerate faces
    mesh.remove_degenerate_faces()

    # Merge duplicate vertices
    mesh.merge_vertices()

    # 修復結果確認
    print(f"修復後 watertight: {mesh.is_watertight}")

    # Save repaired mesh
    if mesh.is_watertight:
        mesh.export('model_fixed.stl')
        print("修復完了: model_fixed.stl して保存")
    else:
        print("⚠️ 自動修復失敗。Meshmixer等使用してくだ")
else:
    print("✓ メッシュ3Dプリント可能at/in/withす")

DOE利点（conventional methodcomparison）:

1. 交互作用検出可能
   • conventional method: Temperature影響、hours影響個別評価
   • DOE: 「Hightemperatureat/in/withhours短くat/in/withきる」った交互作用定量化
   • Example: 1300°Cat/in/with4hoursat/in/with十minutesだ、1100°Cat/in/with8hours必要、など
2. actual験times/iterations数reduction
   • conventional method（OFAT: One Factor At a Time）:
     • Temperature検討: 3times/iterations（hours固定）
     • hours検討: 3times/iterations（Temperature固定）
     • 確認actual験: 複数times/iterations
     • 合計: 10times/iterations以上
   • DOE: 9times/iterationsat/in/with完了（全条件網羅＋交互作用解析）
   • らMedium心複合計画法使えば7times/iterationsreduction可能

追加利点:

• 統計的有意な結論得られる（誤差評価可能）
• 応答曲面構築at/in/withき、未actual施条件予測可能
• 最適条件actual験範囲外ある場合at/in/withも検出at/in/withきる

Hard（発展）

next/orderstep

第4章at/in/withproductlayersbuild（AM）基礎して、ISO/ASTM 52900よる7つprocessCategory、STL File形equation/formula構造、スライシングG-code基number of学びました。next/order第2章at/in/with、Material Extrusion（FDM/FFF）詳細なbuildprocess、材料特性、processパラメータ最適化つて学びます。

参考文献

1. Gibson, I., Rosen, D., & Stucker, B. (2015). Additive Manufacturing Technologies: 3D Printing, Rapid Prototyping, and Direct Digital Manufacturing (2nd ed.). Springer. pp. 1-35, 89-145, 287-334. - AM技術包括的教科書、7つprocessカテゴリSTLデータ処理詳細解説
2. ISO/ASTM 52900:2021. Additive manufacturing — General principles — Fundamentals and vocabulary. International Organization for Standardization. - AM用語processCategory国際Standard規格、産業界at/in/with広く参照れる
3. Kruth, J.P., Leu, M.C., & Nakagawa, T. (1998). "Progress in Additive Manufacturing and Rapid Prototyping." CIRP Annals - Manufacturing Technology, 47(2), 525-540. - 選択的laser焼結バインディング機構理論的基礎
4. Hull, C.W. (1986). Apparatus for production of three-dimensional objects by stereolithography. US Patent 4,575,330. - 世界初AM技術（SLA）特許、AM産業起源なる重要文献
5. Wohlers, T. (2023). Wohlers Report 2023: 3D Printing and Additive Manufacturing Global State of the Industry. Wohlers Associates, Inc. pp. 15-89, 156-234. - AM市場動向産業応用最新統計レポート、yearnext/order更新れる業界Standard資料
6. 3D Systems, Inc. (1988). StereoLithography Interface Specification. - STL File形equation/formula公equation/formula仕様書、ASCII/Binary STL構造定義
7. numpy-stl Documentation. (2024). Python library for working with STL files. https://numpy-stl.readthedocs.io/ - STL File読込・体product計算ためPythonライブラリ
8. trimesh Documentation. (2024). Python library for loading and using triangular meshes. https://trimsh.org/ - メッシュ修復・ブーリアン演算・品質評価包括的ライブラリ

使用ツールライブラリ

• NumPy (v1.24+): 数値計算ライブラリ - https://numpy.org/
• numpy-stl (v3.0+): STL File処理ライブラリ - https://numpy-stl.readthedocs.io/
• trimesh (v4.0+): 3Dメッシュ処理ライブラリ（修復、検証、ブーリアン演算） - https://trimsh.org/
• Matplotlib (v3.7+): データ可視化ライブラリ - https://matplotlib.org/
• SciPy (v1.10+): 科学技術計算ライブラリ（最適化、補間） - https://scipy.org/