> For the complete documentation index, see [llms.txt](https://docs.dietrichs.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.dietrichs.com/tutorials/tutorials-en/learning-the-basics/exploration-journey/fundamental-operations/timber-coordinate-systems.md).
# Timber Coordinate Systems
## Coordinate Systems in Timber Fabrication: Project vs. Component Reference Frames
### Executive Summary
In timber fabrication workflows, there exists a fundamental distinction between **project coordinate systems** (used for building placement) and **component coordinate systems** (used for manufacturing). Understanding this distinction is critical for successful CAD-to-CAM data exchange, particularly when exporting to machine-readable formats like BTLx.
This document explains the difference between these coordinate systems, how various CAD platforms handle them, and best practices for timber fabrication workflows.
***
### The Two Coordinate Systems
#### Project/Building Coordinate System (Global)
The project coordinate system is a **global reference frame** for the entire building:
* **Purpose**: Describes where components are located and oriented in the building
* **Typical axes**:
* X = East-West
* Y = North-South
* Z = Vertical (Up)
* **Used by**: Architects, structural engineers, BIM coordinators
* **Software context**: Revit, ArchiCAD, Tekla Structures, AutoCAD
**Example**: "This beam runs from coordinates (10', 20', 8') to (30', 20', 8') in the building."
#### Component/Manufacturing Coordinate System (Local)
The component coordinate system is a **local reference frame** intrinsic to each timber member:
* **Purpose**: Describes the material geometry and where to machine it
* **Standard axes**:
* **X = Length** (grain direction, primary span)
* **Y = Width** (cross-grain, secondary dimension)
* **Z = Thickness** (through-thickness, lamination buildup)
* **Used by**: Fabricators, CNC programmers, shop floor
* **Software context**: Dietrich's, Cadwork, Hundegger, BTLx files, CNC control systems
**Example**: "This is an 8' × 4' × 7" CLT panel. Machine a 2" diameter hole at X=24", Y=18", Z=0 on Reference Side 1."
***
### Why Dimension Order Matters
#### Standard Notation: Length × Width × Thickness
For CLT and glulam feedstock, fabricators expect dimensions in a specific order:
```
Correct: 8' × 4' × 7"
(Length × Width × Thickness)
Incorrect: 8' × 7" × 4'
(This suggests a 4-foot thick panel, which is nonsensical)
```
#### The Physics of Timber Products
**CLT (Cross-Laminated Timber)**:
* Thickness = buildup of laminations (typically 3.5", 5.5", 7", 9.5" for 3, 5, 7, 9-ply)
* Length & Width = panel dimensions (can be large)
* Major strength direction = grain direction of outer layers (typically the length)
**Glulam**:
* Depth = buildup of laminations (multiples of 1-3/8" or 1-1/2" lamination thickness)
* Width = face dimension (standardized: 3-1/8", 5-1/8", 6-3/4", etc.)
* Length = along grain (can be up to 60m with finger joints)
#### Rotating a Component ≠ Changing Its Dimensions
**Critical concept**: When you rotate a panel 90° in the building (project coordinates), its intrinsic dimensions don't change (component coordinates).
**Building placement** (project coords):
* Panel oriented North-South → Panel oriented East-West
**Manufacturing reality** (component coords):
* Still an 8' × 4' × 7" panel
* Grain still runs the 8-foot direction
* Machining operations still reference the same faces
***
### Standards and Conventions
#### ANSI/APA PRG 320 (CLT Standard)
The PRG 320 standard defines:
* **CLT Width**: Dimension measured perpendicular to the major strength direction
* **Major strength direction**: Primary span direction (grain of outer layers), uses subscript '0' in notation
* **Minor strength direction**: Perpendicular direction, uses subscript '90' in notation
This establishes:
* Major strength direction = Length (X-axis in component coords)
* Width = Perpendicular to major strength (Y-axis)
* Thickness = Through-thickness (Z-axis)
#### ANSI A190.1 (Glulam Standard)
For glulam:
* Width and depth shall be agreed upon between buyer and seller
* Depth = multiples of lamination thickness
* Standard convention: Length (grain) × Width × Depth (laminations)
#### BTLx File Format
BTLx (Building Timber Link XML) explicitly defines component coordinates:
* **X-axis**: Direction of the part axis (grain direction)
* **Y-axis**: Orthogonal to X, lying in the reference side plane
* **Z-axis**: Cross-product of X and Y (through-thickness)
Each part has **four reference sides** (RS1-4) corresponding to the longitudinal faces, plus two end faces (RS5-6). All machining operations are positioned relative to these reference sides using the component coordinate system.
***
### Height vs. Thickness vs. Z-Axis: Terminology Clarity
#### The Terminology Problem
**"Height" is context-dependent** and **Z is NOT always thickness**. This creates significant confusion in timber fabrication workflows.
#### In Building/Project Coordinates (Global)
* **Z = Vertical** (up/down in the building)
* **"Height"** typically means vertical dimension in the building
#### In Component Coordinates (Local)
* **Z = Thickness** (through-thickness of the material)
* **"Height"** is ambiguous and should be avoided
#### Height ≠ Thickness (Usually)
**Example 1: Floor Panel (Horizontal)**
**Component coordinates:**
```
X = 8' (length, span direction)
Y = 4' (width)
Z = 7" (thickness)
```
**Installed in building (project coordinates):**
```
Building X = 8' (North-South span)
Building Y = 4' (East-West width)
Building Z = 7" (vertical, height above floor below)
```
In this case: **Height (building Z) = Thickness (component Z)** ✓
**Example 2: Wall Panel (Vertical)**
**Component coordinates (when manufactured):**
```
X = 10' (length, grain direction of outer layers)
Y = 8' (width)
Z = 5.5" (thickness)
```
**Installed in building (project coordinates):**
```
Building X = 10' (horizontal run along wall)
Building Y = 5.5" (wall thickness, horizontal)
Building Z = 8' (height, vertical)
```
In this case: **Height (building Z) ≠ Thickness (component Z)** ✗
The wall's **height in the building** is the panel's **width in component coordinates**!
#### Is Z Always Thickness? NO.
**Component Coordinate System (Manufacturing):**
* X = Length (grain direction, longest dimension)
* Y = Width (cross-grain)
* Z = Thickness (smallest dimension, lamination buildup)
This is **consistent** for the component itself.
**Building Coordinate System (Installation):**
* Z = Vertical (elevation)
* The component's Z-axis may align with building X, Y, or Z depending on orientation
#### Summary Table: Height vs. Thickness by Element Type
| Element Type | Component Z | Building Z (when installed) | Height = Thickness? |
| ------------------------ | ----------- | --------------------------- | ------------------------- |
| Floor panel (horizontal) | Thickness | Vertical (thickness) | **YES** ✓ |
| Wall panel (vertical) | Thickness | Vertical (**width**) | **NO** ✗ |
| Horizontal beam | Depth | Vertical (depth) | YES (if "height" = depth) |
| Vertical column | Depth/Width | Vertical (**length**) | **NO** ✗ |
| Roof panel (sloped) | Thickness | Not aligned with Z | **NO** ✗ |
#### The Glulam Terminology
Glulam uses slightly different terminology than CLT:
* **Length** = along grain
* **Width** = face dimension
* **Depth** = lamination buildup (analogous to CLT "thickness")
When installed:
* As a horizontal beam: Building height = Depth (component Z)
* As a vertical column: Building height = Length (component X)
#### Best Practice: Avoid "Height"
In timber fabrication documentation, **avoid using "height"** because it's ambiguous.
**✅ Good (Unambiguous):**
* "8' length × 4' width × 7" thickness"
* "Panel thickness: 7""
* "Span direction: 8'"
* "Component Z-axis: 5.5""
**❌ Bad (Ambiguous):**
* "Panel height: 8'" (which dimension? vertical in building? or component dimension?)
* "Height of wall panel" (installed height? or component dimension?)
**Use Instead:**
* **For components**: Length, Width, Thickness (or Depth for glulam)
* **For installed elements**: "Vertical dimension", "Installed height", "Elevation"
* **Always specify**: "In component coordinates" vs. "In building coordinates"
#### Note on BTLx "Height" Parameter
BTLx uses the term "Height" for the thickness dimension in its XML schema:
```xml
8000
4000
178
```
This is **standardized in the format** but conceptually means **thickness** (component Z), not building height. This naming choice in BTLx adds to the confusion but is maintained for backward compatibility.
#### Implications for Data Models
When storing timber components in ERP/MES systems:
**Store component dimensions as L×W×T:**
```python
class TimberComponent:
length_mm: float # X-axis, grain direction
width_mm: float # Y-axis, cross-grain
thickness_mm: float # Z-axis, lamination buildup
# Don't use "height" - it's ambiguous!
```
**Store orientation separately:**
```python
element_type: str # "floor", "wall", "beam", "column"
installation_orientation: str # "horizontal", "vertical", "sloped"
```
**Calculate installed dimensions when needed:**
```python
@property
def installed_vertical_dimension(self):
"""Building Z dimension - may be length, width, OR thickness"""
if self.element_type == "floor":
return self.thickness_mm
elif self.element_type == "wall":
return self.width_mm # Width becomes vertical!
elif self.element_type == "column":
return self.length_mm # Length becomes vertical!
```
***
### Reference Sides: The Bridge Between Geometry and Manufacturing
#### What Are Reference Sides?
Reference Sides (RS) are **numbered faces** of a prismatic timber component used to define where machining operations occur. They are fundamental to BTLx and timber CNC programming.
Every rectangular timber component has **six faces**:
* **RS1, RS2, RS3, RS4**: Four longitudinal faces (parallel to grain/length)
* **RS5, RS6**: Two end faces (perpendicular to grain)
```
RS6 (end)
↓
┌───────────────┐
│ │
RS1 │ │ RS3
│ │
│ │
└───────────────┘
RS2
RS5 (end)
↑
```
Looking at the component from the end:
```
Y-axis →
RS4 (top)
┌─────────┐ ↓
RS1 │ │ RS3 Z-axis
│ ●────→ (down into page)
└─────────┘
RS2 (bottom)
```
#### How Reference Sides Map to X, Y, Z
The four longitudinal sides are numbered **counter-clockwise** when looking from the **start** (RS5 end) toward the **finish** (RS6 end):
```
Looking from start (RS5) toward finish (RS6):
+Y (width)
↑
│ RS4
│ ┌─────┐
-Z ──┼──│ │──┼── +Z (thickness)
(RS1) │ │ ● │ │ (RS3)
│ └─────┘ │
│ RS2 │
│ │
└───────────┴─── +X (length) →
```
**Standard numbering:**
* **RS1** = -Z face (left side when looking along +X)
* **RS2** = -Y face (bottom when looking along +X)
* **RS3** = +Z face (right side when looking along +X)
* **RS4** = +Y face (top when looking along +X)
* **RS5** = -X face (start/origin end)
* **RS6** = +X face (finish end)
#### Each Reference Side Has Its Own Coordinate System
For each RS, there is a **local 2D coordinate system** for positioning machining operations:
* **Xrs** = along the part length (parallel to component X-axis)
* **Yrs** = across the face (perpendicular to X, in the plane of the face)
* **Zrs** = perpendicular to the face (depth of cut into material)
**Example: Drilling on RS1 (the -Z face)**
```
Component in space:
Y
↑
│ RS4
│ ┌─────┐
────┼───│ │───┼── Z
│ │ ● │ │
│ └─────┘ │
│ RS2 │
└──────────────── X →
Drilling on RS1 (-Z face):
Looking at RS1 from outside:
Yrs ↑ (parallel to component Y)
│
│ ● Hole at (Xrs=24", Yrs=12", Zrs=2")
│
│
└────────→ Xrs (parallel to component X)
Zrs = depth into material (parallel to component +Z)
```
**Translation**: Hole positioned 24" along the length from RS5 end, 12" up from the bottom edge (RS2), drilled 2" deep into the component.
#### Relationship to Component Dimensions
For an **8' × 4' × 7"** component:
| Reference Side | Dimensions | Bounded by | Position |
| -------------- | --------------- | ---------- | -------- |
| **RS1** | 8' (X) × 4' (Y) | Y-X plane | Z = 0 |
| **RS2** | 8' (X) × 7" (Z) | Z-X plane | Y = 0 |
| **RS3** | 8' (X) × 4' (Y) | Y-X plane | Z = 7" |
| **RS4** | 8' (X) × 7" (Z) | Z-X plane | Y = 4' |
| **RS5** | 4' (Y) × 7" (Z) | Y-Z plane | X = 0 |
| **RS6** | 4' (Y) × 7" (Z) | Y-Z plane | X = 8' |
#### Why Can't Machining Operations Be Defined in Pure XYZ?
Machining operations **could** be defined purely in component XYZ coordinates, but Reference Sides exist for critical **manufacturing and CNC programming reasons**:
**Problem 1: Tool Access and Setup**
CNC machines need to know **which face to present to the cutting tool**.
**Pure XYZ approach (ambiguous):**
```xml
2000
1000
50
25
```
**Questions the CNC operator cannot answer:**
* Which face do I place up on the machine bed?
* Is this cutting DOWN into the material or UP from below?
* Do I need to flip the part?
* Which direction does the spindle approach from?
**With Reference Side (unambiguous):**
```xml
4
2000
1000
0
25
```
**Immediately clear:** Place component with RS4 facing up, spindle approaches from above, cut 25mm down into the material.
**Problem 2: Depth Ambiguity**
Consider an 8' × 4' × 7" CLT panel with a hole specification.
**Pure XYZ (ambiguous):**
```xml
24"
12"
2"
1"
```
**Problems:**
* Is Z=2" the **position** (2" from one face) or the **depth** (2" into material)?
* If it's a position, which face is Z=0? Bottom or top?
* If the panel is 7" thick, is this drilling from bottom (Z=0 to Z=2") or top (Z=7" to Z=5")?
**With Reference Side (unambiguous):**
```xml
4
24"
12"
0
2"
1"
```
**Completely clear:** Drill from the top face (RS4) at position (24", 12") on that face, go 2" deep into the material, final hole ends at component coordinate Z = 5" (7" - 2").
**Problem 3: Through-Holes and Direction**
**Scenario:** Drill completely through a 7" thick panel.
**Pure XYZ (which direction?):**
```xml
24"
12"
???
7"
```
**With Reference Side:**
```xml
4
24"
12"
0
7"
true
```
**Manufacturing difference:**
* **From top (RS4)**: Drill enters top face (clean entry), exits bottom (may have tear-out)
* **From bottom (RS2)**: Opposite tear-out pattern
* **Matters for:** Visible faces, bearing surfaces, architectural finishes
**Problem 4: Machine Setup and Work Holding**
**Real 5-axis CNC workflow:**
1. Load component onto machine bed
2. Clamp it down (certain faces must be accessible)
3. Machine all operations on accessible faces
4. Flip/rotate component
5. Machine other faces
**With Reference Sides, the CNC software can group operations:**
```
Setup 1: RS4 facing up, RS2 on bed
- All operations on RS4 (top)
- All operations on RS1 and RS3 (sides, reachable)
Setup 2: Flip component, RS2 facing up
- All operations on RS2 (bottom)
- Any remaining side operations
Setup 3 (if needed): Stand on end for RS5/RS6
- End cuts, tenons, dovetails
```
**Pure XYZ**: Software would have to infer which operations can be grouped by analyzing geometry and tool approach angles—complex, error-prone, and inefficient.
**Problem 5: Different Faces Have Different Properties**
**CLT Panels:**
* **Top face (RS4)**: May be sanded, architectural grade, for interior exposure
* **Bottom face (RS2)**: May be industrial grade, hidden in assembly
**Operations must respect this:**
```xml
architectural
```
**Glulam Beams:**
* **Outer layers (RS1-4)**: Higher grade lumber, better appearance, higher strength in outer fibers
* **End faces (RS5-6)**: Cross-grain, different drilling characteristics, may have finger joints
**Problem 6: Human Communication**
**With Reference Sides (clear):**
```
"Drill four holes on RS4 at these locations."
"Route a dado on RS2, 500mm from the end."
"Cut a 45° angle on RS6."
```
Clear to operators who can physically see and touch the faces.
**Pure XYZ (abstract):**
```
"Drill at (X, Y, Z) in global coordinates."
```
Operator must do mental math to determine which physical face this corresponds to.
#### BTLx Example with Reference Sides
BTLx stores component dimensions but references machining to RS:
```xml
CLT_Panel_01
8000
4000
178
4
2000
1000
0
25
1
4000
2000
0
50
25
```
#### Common Machining Operations by Reference Side
**Longitudinal Faces (RS1-4):**
* Typical operations: Pockets (dados, recesses), drilling (bolt holes, electrical), grooves (running along length), surface planing
* Why: These are the large faces with the most area
**End Faces (RS5-6):**
* Typical operations: Angle cuts (bevels, miters), tenons, dovetails, end drilling
* Why: These define how components connect end-to-end
#### Summary: Why Reference Sides Exist
| Reason | Pure XYZ Problem | RS Solution |
| ---------------------------- | ------------------------------- | ----------------------------------- |
| **Tool access** | Ambiguous which face to machine | Explicit face identification |
| **Depth direction** | Is Z a position or depth? | Z=0 at face surface, depth is clear |
| **Setup planning** | Must infer from geometry | Group by RS automatically |
| **Through-holes** | Which direction? | Start face is explicit |
| **Face properties** | Must track separately | RS inherently identifies face |
| **Human communication** | "Position X Y Z" (abstract) | "RS4 at X Y" (physical) |
| **CAM integration** | Complex geometric analysis | Direct mapping to setups |
| **Historical compatibility** | New paradigm | Matches CNC controller logic |
**Key takeaway:** Reference Sides are the **bridge** between component geometry (L×W×T, X/Y/Z axes), machining operations (where to cut, drill, route), and CNC programming (which face to present to the tool).
***
### CAD Software Comparison
#### Revit: Project-Centric (❌ Problematic for Timber)
**Coordinate System Approach**:
* Primarily uses project coordinates
* Family instances have local coordinates, but these are for geometry definition, not manufacturing semantics
* No native concept of "grain direction" or material orientation
**What Revit Has:**
* ✅ Family geometry with faces
* ✅ Reference planes for modeling
* ✅ Instance parameters (length, width, height)
* ✅ Solid geometry that can be exported to IFC, DWG
**What Revit Lacks:**
* ❌ No Reference Side numbering (RS1-6)
* ❌ No "grain direction" or "major axis" concept
* ❌ No manufacturing face hierarchy
* ❌ No tool approach direction
* ❌ No machining operation framework
**Critical Problems:**
1. **No intrinsic material axes**: A beam placed from A to B doesn't inherently know which dimension is "width" vs. "depth" in material terms
2. **Arbitrary dimension assignment**: Nothing enforces "thickness is smallest dimension"
3. **Rotation ambiguity**: Rotating a component 90° doesn't maintain manufacturing context
4. **No Reference Side concept**: Can't natively map to BTLx Reference Sides
**The Reference Side Failure**
**Problem 1: Ambiguous Face Identification**
In BTLx/Timber world:
```xml
4
2000
1000
```
In Revit, you have a rectangular solid with 6 faces, but:
* No standard numbering
* No way to say "this is RS4"
* Face IDs are internal database references that change if geometry is modified
* No persistent face naming
The exporter must guess:
```python
# Revit exporter's nightmare
def which_reference_side(face):
# Face normal points up? Maybe RS4?
# But what if component is rotated?
# What if it's a wall panel (vertical)?
# No reliable way to determine!
```
**Problem 2: Operations Defined in Project Space, Not Face Space**
Revit approach:
```
Void extrusion:
- Work plane: Some arbitrary reference plane
- Extrusion direction: Normal to plane
- Position: Related to family origin
```
BTLx needs:
```xml
4
2000
1000
0
50
```
Conversion is fragile—the exporter must analyze void geometry, determine which face it intersects, calculate position relative to that face, and hope the user modeled it "correctly."
**Problem 3: Wall Panels (Vertical Elements) - Worst Case**
Component coordinates:
```
Length = 10' (horizontal run in wall)
Width = 8' (vertical height)
Thickness = 5.5"
```
Installed in building:
```
Building X = 10' (along wall)
Building Z = 8' (vertical)
Building Y = 5.5" (wall thickness)
```
Revit family might have:
```
Height parameter = 8' (building vertical)
Length parameter = 10' (building horizontal)
Width parameter = 5.5" (wall thickness)
```
Mapping confusion leads to catastrophically wrong BTLx:
```xml
2438
3048
140
1200
1500
```
Result: **CNC machines the wrong face!**
**Real-World Failure Modes**
**Failure Mode 1: Silent Dimension Swap**
```
Designer models: 8' × 4' × 7" panel
Revit parameters: Length=8', Width=4', Thickness=7"
Export interprets: Width=8', Length=4', Thickness=7"
BTLx file says: 4' × 8' × 7"
Fabricator builds: Wrong aspect ratio
```
Only catches if someone checks BTLx file or fabricator questions it.
**Failure Mode 2: Operations on Wrong Face**
```
Designer: "Pocket on top face"
Revit: Void extrusion from "Top" reference plane
Export: Can't determine which RS is "top"
BTLx: Assigns RS2 (bottom) instead of RS4 (top)
CNC: Machines wrong face
```
Catches during trial run, or after part is ruined.
**Failure Mode 3: Inverted Depth**
```
Designer: 2" pocket from top surface
Revit: Void goes "down" in family space
Panel flipped in building: "Down" is now up?
Export: Confused about direction
BTLx: Depth might be from wrong face
```
**Workarounds (Incomplete Solutions):**
1. **Custom Parameters** (Bandaid):
* Add "GrainDirection", "ManufacturingTop", "RS4", "RS2" parameters
* User must manually set on every family
* Easy to forget or set wrong
* Not enforced by Revit
2. **Naming Conventions** (Fragile):
* Reference plane names: "RS4\_Top", "RS2\_Bottom", "RS1\_Left"
* Exporter looks for these names
* Breaks if planes renamed
* Doesn't handle rotated instances well
3. **Family Templates** (Rigid):
* Pre-defined reference planes, locked parameters
* Users must use specific templates
* Hard to customize
* Breaks if users "improve" the family
4. **Manual Mapping UI** (Tedious):
* Export dialog: "For family 'CLT\_Panel\_8x4x7': Top face is \[dropdown: RS4]"
* Must be done for every family type
* Easy to make mistakes
* Doesn't persist between exports
**Best Use Case**: Building coordination with architects; not ideal as primary timber fabrication tool
**Risk Assessment for Timber Fabrication:**
* ⚠️ **High complexity** - requires extensive workarounds
* ⚠️ **High error rate** - especially initially
* ⚠️ **Requires expert supervision** - not suitable for novice users
* ⚠️ **Manual validation essential** - check every BTLx export before production
***
#### SolidWorks: Part-Centric (✅ Better, But Not Purpose-Built)
**Coordinate System Approach**:
* Every part has its own coordinate system defined at creation
* Multiple coordinate systems can be defined within a single part
* Weldments module has explicit path (grain) and profile (cross-section) concepts
**Advantages**:
1. **Structural members follow a path**: Explicit length/grain direction
2. **Profile orientation maintained**: Clear definition of width vs. thickness
3. **Manufacturing context**: Built for machining from day one
4. **Coordinate system manager**: Easy to define custom manufacturing datums
**Challenges**:
1. **No native BTLx export**: Requires custom macros or add-ins
2. **No timber-specific joinery**: Would need to build library of dovetails, laps, mortise-tenon
3. **Assembly complexity**: Not optimized for stick-framing or whole buildings
4. **No timber material intelligence**: Doesn't understand CLT layup, grain strength, etc.
**Best Use Case**:
* Custom connection hardware design
* Complex 3D components requiring detailed machining
* Parametric component families
* Integration with general CNC/CAM workflows
***
#### Component-First (✅✅ Purpose-Built)
**Coordinate System Approach**:
* **Start with component coordinates**: You define a timber member with L×W×T
* **Grain direction is intrinsic** to the object type
* **Dual coordinate system**: Maintains both component and project coordinates simultaneously
* **Reference faces built into object model**
**Advantages**:
1. **Direct BTLx export**: Component coordinates map directly to file format
2. **Timber-specific operations**: Pre-defined dovetails, laps, bird's mouths, scarf joints
3. **Material intelligence**: Understands CLT layup, glulam lamination, grain direction
4. **Auto-framing**: Can automatically generate wall/floor framing from architectural plans
5. **Nesting optimization**: Built-in tools for sheet goods optimization
**Challenges**:
1. **Steeper learning curve** for users coming from general CAD
2. **Less common** in North American market (though growing)
3. **Cost**: Professional licenses can be expensive
4. **Limited non-timber capabilities**: Not a general-purpose mechanical CAD tool
**Best Use Case**:
* Primary design tool for timber fabrication shops
* Pre-engineered timber building kits
* Repetitive housing projects
* Direct-to-CNC workflows
####
***
### The Coordinate Transformation Problem
#### What Happens During Export
When you export from CAD to BTLx, the software must:
1. **Transform** from project coordinates to component coordinates
2. **Reorient** all machining operations to reference the component's local axes
3. **Map geometry** to BTLx Reference Sides (1, 2, 3, 4, 5, 6)
4. **Preserve manufacturing intent** regardless of building placement
#### Common Export Errors
**Symptom**: CNC receives wrong dimensions or machining on wrong face
**Root causes**:
* Designer modeled panel with wrong aspect ratio (4' × 8' × 7" instead of 8' × 4' × 7")
* Export software couldn't determine which dimension is "length" vs. "width"
* Reference sides mapped incorrectly
* Rotation in building space confused with material orientation
**Example failure**:
```
Intended: 8' long × 4' wide × 7" thick CLT panel
Pocket on top face, 2' from left end
Exported: 4' long × 8' wide × 7" thick (wrong!)
Pocket position now references wrong axis
May be on wrong face entirely
```
***
### Best Practices
#### For Design Teams
1. **Establish component coordinate system first**
* Define L×W×T before placing in project
* Clearly mark grain direction
* Use consistent family/component templates
2. **Use dimension parameters correctly**
* Length = longest dimension, grain direction
* Width = perpendicular to grain
* Thickness = smallest dimension, lamination buildup
3. **Document orientation**
* Add visual indicators for grain direction
* Label reference faces
* Include manufacturing notes
4. **Validate exports**
* Review BTLx files in viewer before sending to production
* Check that dimensions make sense for the material
* Verify machining operations are on correct faces
#### For BTLx Import (ERP/MES Systems)
When building systems like your manufacturing module:
1. **Trust BTLx component coordinates**
* The file already contains correct manufacturing coordinates
* Don't try to recalculate from building placement
2. **Validate dimension ratios**
* Thickness should be smallest dimension
* Flag suspicious values (thickness > 12", etc.)
3. **Reference side mapping**
* Maintain BTLx RS1-4 numbering
* Map to your internal face identification
4. **Preserve grain direction**
* X-axis = length/grain
* Critical for strength calculations, material ordering
***
***
### Conclusion
The distinction between project and component coordinate systems is fundamental to timber fabrication. While general-purpose CAD tools like Revit and SolidWorks can be adapted for timber work, purpose-built solutions like Dietrich's and Cadwork handle this complexity natively.
For a cooperative focused on pre-engineered timber kits and standardized components, investing in timber-specific CAD tools will:
* Reduce coordinate system errors
* Simplify BTLx export workflows
* Accelerate member training
* Improve integration with CNC machinery
The key principle: **Think in material coordinates first, building placement second.**
***
### References
#### Standards
* **ANSI/APA PRG 320**: Standard for Performance-Rated Cross-Laminated Timber
* Defines CLT width as dimension perpendicular to major strength direction
* Establishes subscript notation ('0' for major, '90' for minor)
* **ANSI A190.1**: Standard for Structural Glued Laminated Timber
* Permits any width or depth agreed between buyer and seller
* Defines standard finished widths and depth calculations
* **BTLx Format Specification** (design2machine.com)
* XML-based format for timber fabrication data exchange
* Defines component coordinate system and reference sides
#### Industry Resources
* design2machine.com - BTL/BTLx documentation and viewer
* APA - The Engineered Wood Association - CLT technical resources
* WoodWorks - Mass timber design guides
* Think Wood - Cross-laminated timber design + construction resources
***