Add GCodeVector3 for convenience

Author: remcoder

src/GCodeVector3.ts

@@ -0,0 +1,25 @@
+import { Vector3 } from 'three';
+
+/**
+ * Represents a 3D vector in GCode coordinates that is easily convertible to Three.js Vector3.
+ * This is a convenience class. Care should be taken when many allocations are made.
+ */
+export class GCodeVector3 extends Vector3 {
+  constructor(x: number, y: number, z: number) {
+    super(x, y, z);
+  }
+
+  /**
+   * map from GCode coordinates to Three.js Vector3
+   * GCode uses (X, Y, Z) while Three.js uses (X, Z, Y)
+   * also the Y in GCode goes to the back, while in Three.js Z goes to the front
+   * @returns Vector3
+   */
+  toVector3(): Vector3 {
+    return new Vector3(this.x, this.z, -this.y);
+  }
+
+  static fromVector3(vector: Vector3): GCodeVector3 {
+    return new GCodeVector3(vector.x, -vector.z, vector.y);
+  }
+}

src/__tests__/GCodeVector3.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { GCodeVector3 } from '../types';
+import { Vector3 } from 'three';
+
+describe('GCodeVector3', () => {
+  it('should be the identity when converting to Vector3 and back', () => {
+    const original = new GCodeVector3(1, 2, 3);
+    const converted = GCodeVector3.fromVector3(original.toVector3());
+    expect(converted.x).toBe(original.x);
+    expect(converted.y).toBe(original.y);
+    expect(converted.z).toBe(original.z);
+  });
+
+  it('should be the identity when converting from Vector3 and back', () => {
+    const original = new Vector3(4, 5, 6);
+    const converted = GCodeVector3.fromVector3(original).toVector3();
+    expect(converted.x).toBe(original.x);
+    expect(converted.y).toBe(original.y);
+    expect(converted.z).toBe(original.z);
+  });
+});

src/__tests__/bounding-box.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { BoundingBox } from '../bounding-box';
+import { GCodeVector3 } from '../types';
+
+describe('BoundingBox', () => {
+  it('should return null for center if bounding box is not valid', () => {
+    const bbox = new BoundingBox();
+    expect(bbox.center).toBeNull();
+  });
+
+  it('should calculate the correct center coordinates', () => {
+    const bbox = new BoundingBox();
+    bbox.update(new GCodeVector3(0, 0, 0));
+    bbox.update(new GCodeVector3(10, 10, 10));
+
+    const center = bbox.center as GCodeVector3;
+    expect(center).toBeInstanceOf(GCodeVector3);
+    expect(center.x).toBe(5);
+    expect(center.y).toBe(5);
+    expect(center.z).toBe(5);
+
+    bbox.update(new GCodeVector3(-5, -5, -5));
+    const newCenter = bbox.center as GCodeVector3;
+    expect(newCenter.x).toBe(2.5);
+    expect(newCenter.y).toBe(2.5);
+    expect(newCenter.z).toBe(2.5);
+  });
+});

src/bounding-box.ts

@@ -1,14 +1,7 @@
+import { GCodeVector3 } from './GCodeVector3';
 export class BoundingBox {
-  private minX: number = Infinity;
-  private maxX: number = -Infinity;
-  private minY: number = Infinity;
-  private maxY: number = -Infinity;
-  private minZ: number = Infinity;
-  private maxZ: number = -Infinity;
-
-  constructor() {
-    // console.log('BoundingBox initialized');
-  }
+  private min: GCodeVector3 = new GCodeVector3(Infinity, Infinity, Infinity);
+  private max: GCodeVector3 = new GCodeVector3(-Infinity, -Infinity, -Infinity);
 
   /**
    * Updates the bounding box with the given coordinates.
@@ -17,12 +10,12 @@ export class BoundingBox {
    * @param z - The Z coordinate.
    */
   public update(x: number, y: number, z: number): void {
-    this.minX = Math.min(this.minX, x);
-    this.maxX = Math.max(this.maxX, x);
-    this.minY = Math.min(this.minY, y);
-    this.maxY = Math.max(this.maxY, y);
-    this.minZ = Math.min(this.minZ, z);
-    this.maxZ = Math.max(this.maxZ, z);
+    this.min.x = Math.min(this.min.x, x);
+    this.max.x = Math.max(this.max.x, x);
+    this.min.y = Math.min(this.min.y, y);
+    this.max.y = Math.max(this.max.y, y);
+    this.min.z = Math.min(this.min.z, z);
+    this.max.z = Math.max(this.max.z, z);
     // console.log(`Updated bounding box: minX=${this.minX}, maxX=${this.maxX}, minY=${this.minY}, maxY=${this.maxY}, minZ=${this.minZ}, maxZ=${this.maxZ}`);
   }
 
@@ -31,46 +24,38 @@ export class BoundingBox {
    * @returns True if at least one point has been added, false otherwise.
    */
   public get isValid(): boolean {
-    return this.minX !== Infinity;
+    return this.min.x !== Infinity;
   }
 
   /**
    * Gets the size of the bounding box.
    * @returns An object with x, y, and z dimensions, or null if the bounding box is not valid.
    */
-  public get size(): { x: number; y: number; z: number } | null {
+  public get size(): GCodeVector3 | null {
     if (!this.isValid) {
       return null;
     }
-    return {
-      x: this.maxX - this.minX,
-      y: this.maxY - this.minY,
-      z: this.maxZ - this.minZ
-    };
+    return this.max.clone().sub(this.min);
   }
 
   /**
    * Gets the center coordinates of the bounding box.
    * @returns An object with x, y, and z center coordinates, or null if the bounding box is not valid.
    */
-  public get center(): { x: number; y: number; z: number } | null {
+  public get center(): GCodeVector3 | null {
     if (!this.isValid) {
       return null;
     }
-    return {
-      x: this.minX + (this.maxX - this.minX) / 2,
-      y: this.minY + (this.maxY - this.minY) / 2,
-      z: this.minZ + (this.maxZ - this.minZ) / 2
-    };
+    return this.min.clone().add(this.max).multiplyScalar(0.5);
   }
 
-  public get corners(): { min: { x: number; y: number; z: number }; max: { x: number; y: number; z: number } } {
+  public get corners(): { min: GCodeVector3; max: GCodeVector3 } | null {
     if (!this.isValid) {
       return null;
     }
     return {
-      min: { x: this.minX, y: this.minY, z: this.minZ },
-      max: { x: this.maxX, y: this.maxY, z: this.maxZ }
+      min: this.min.clone(),
+      max: this.max.clone()
     };
   }
 }

src/webgl-preview.ts

@@ -842,8 +842,8 @@ export class WebGLPreview {
         // Three.js X position = G-code X center - (Build Volume X / 2)
         // Three.js Y position = G-code Z center (since Three.js Y is up, and LineBox handles its own Y-offset)
         // Three.js Z position = G-code Y center - (Build Volume Y / 2)
-        const pos = bb.corners.min;
-        this.boundingBoxMesh.position.set(pos.x, 0, -pos.y);
+        const pos = bb.corners.min.toVector3();
+        this.boundingBoxMesh.position.set(pos.x, pos.y, pos.z);
 
         this.scene.add(this.boundingBoxMesh);
       }