# 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
***
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.dietrichs.com/tutorials/tutorials-en/learning-the-basics/exploration-journey/fundamental-operations/timber-coordinate-systems.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.