fix(Camera): add support for getFrustumPlanes

Author: daker

Sources/Common/Core/Math/index.d.ts

@@ -203,7 +203,7 @@ export function getSeed(): number;
 export function random(minValue: number, maxValue: number): number;
 
 /**
- * Addition of two 3-vectors.
+ * Add two 3-vectors.
  * @param {Vector3} a The first 3D vector.
  * @param {Vector3} b The second 3D vector.
  * @param {Vector3} out The output 3D vector.
@@ -215,7 +215,7 @@ export function random(minValue: number, maxValue: number): number;
 export function add(a: Vector3, b: Vector3, out: Vector3): Vector3;
 
 /**
- * Subtraction of two 3-vectors.
+ * Substract two 3-vectors.
  * @param {Vector3} a The first 3D vector.
  * @param {Vector3} b The second 3D vector.
  * @param {Vector3} out The output 3D vector.
@@ -227,7 +227,7 @@ export function add(a: Vector3, b: Vector3, out: Vector3): Vector3;
 export function subtract(a: Vector3, b: Vector3, out: Vector3): Vector3;
 
 /**
- *
+ * Multiply a 3-vector by a scalar.
  * @param {Vector3} vec
  * @param {Number} scalar
  * @example
@@ -238,7 +238,7 @@ export function subtract(a: Vector3, b: Vector3, out: Vector3): Vector3;
 export function multiplyScalar(vec: Vector3, scalar: number): Vector3;
 
 /**
- *
+ * Multiply a 3-vector by a scalar.
  * @param {Vector2} vec
  * @param {Number} scalar
  * @example
@@ -249,7 +249,7 @@ export function multiplyScalar(vec: Vector3, scalar: number): Vector3;
 export function multiplyScalar2D(vec: Vector2, scalar: number): Vector2;
 
 /**
- *
+ * Multiply two 3-vectors.
  * @param {Vector3} a
  * @param {Vector3} b
  * @param {Number} scalar
@@ -267,7 +267,7 @@ export function multiplyAccumulate(
 ): Vector3;
 
 /**
- *
+ * Multiply two 2-vectors.
  * @param {Vector2} a
  * @param {Vector2} b
  * @param {Number} scalar
@@ -285,7 +285,7 @@ export function multiplyAccumulate2D(
 ): Vector2;
 
 /**
- *
+ * Dot product of two 3-vectors.
  * @param {Vector3} x
  * @param {Vector3} y
  * @example
@@ -312,17 +312,23 @@ export function outer(x: Vector3, y: Vector3, out_3x3: Matrix3x3): void;
 export function cross(x: Vector3, y: Vector3, out: Vector3): Vector3;
 
 /**
- *
- * @param {Number[]} x
- * @param {Number} n
+ * Compute the norm of a vector.
+ * @param {Number[]} x The vector to compute the norm of.
+ * @param {Number} [n] The number of components to consider (default is 3).
  */
-export function norm(x: number[], n: number): number;
+export function norm(x: number[], n?: number): number;
 
 /**
  * Normalize in place. Returns norm.
- * @param {Vector3} x The vector to normlize.
+ * @param {Number[]} x The vector to normalize.
  */
-export function normalize(x: Vector3): number;
+export function normalize(x: number[]): number;
+
+/**
+ * Normalize in place. Returns norm.
+ * @param {Number[]} x The vector to normalize.
+ */
+export function normalize4D(x: number[]): number;
 
 /**
  * Given a unit vector v1, find two unit vectors v2 and v3 such that v1 cross v2 = v3
@@ -339,10 +345,10 @@ export function perpendiculars(
 ): void;
 
 /**
- *
- * @param {Vector3} a
- * @param {Vector3} b
- * @param {Vector3} projection
+ * Project vector `a` onto vector `b` and returns the result in projection vector.
+ * @param {Vector3} a The first 3D vector.
+ * @param {Vector3} b The second 3D vector.
+ * @param {Vector3} projection The projection 3D vector.
  */
 export function projectVector(
   a: Vector3,
@@ -351,7 +357,7 @@ export function projectVector(
 ): boolean;
 
 /**
- *
+ * Compute the dot product of two 2D vectors.
  * @param {Vector2} x
  * @param {Vector2} y
  */

Sources/Common/Core/Math/index.js

@@ -275,6 +275,17 @@ export function normalize(x) {
   return den;
 }
 
+export function normalize4D(x) {
+  const den = norm(x, 3);
+  if (den !== 0.0) {
+    x[0] /= den;
+    x[1] /= den;
+    x[2] /= den;
+    x[3] /= den;
+  }
+  return den;
+}
+
 export function perpendiculars(x, y, z, theta) {
   const x2 = x[0] * x[0];
   const y2 = x[1] * x[1];

Sources/Common/Core/Math/test/testMath.js

@@ -195,6 +195,27 @@ test('Test transpose3x3', (t) => {
   t.end();
 });
 
+test('Test normalize', (t) => {
+  const x = [1, 2, 3];
+  const res1 = vtkMath.normalize(x);
+  t.ok(res1 === Math.sqrt(14), 'normalize x');
+  t.ok(x[0] === 1 / Math.sqrt(14), 'normalize x[0]');
+  t.ok(x[1] === 2 / Math.sqrt(14), 'normalize x[1]');
+  t.ok(x[2] === 3 / Math.sqrt(14), 'normalize x[2]');
+  t.end();
+});
+
+test('Test normalize4D', (t) => {
+  const x = [2, 3, 4, 5];
+  const res1 = vtkMath.normalize4D(x);
+  t.ok(res1 === Math.sqrt(29), 'normalize x');
+  t.ok(x[0] === 2 / Math.sqrt(29), 'normalize4D x[0]');
+  t.ok(x[1] === 3 / Math.sqrt(29), 'normalize4D x[1]');
+  t.ok(x[2] === 4 / Math.sqrt(29), 'normalize4D x[2]');
+  t.ok(x[3] === 5 / Math.sqrt(29), 'normalize4D x[3]');
+  t.end();
+});
+
 test('Test Multiply Matrix', (t) => {
   const nullMatrix = [0, 0, 0, 0];
   const m2x2 = [1, 1, 2, 4];

Sources/Rendering/Core/Camera/index.d.ts

@@ -156,11 +156,11 @@ export interface vtkCamera extends vtkObject {
   getFreezeFocalPoint(): boolean;
 
   /**
-   * Not implemented yet
    * Get the plane equations that bound the view frustum.
-   * @param {Number} aspect Camera frustum aspect ratio.
+   * @param {Number} [aspect] Camera frustum aspect ratio (default: 1.0).
+   * @param {Float64Array} [planes] Optional array to fill with the plane equations.
    */
-  getFrustumPlanes(aspect: number): void;
+  getFrustumPlanes(aspect?: number, planes?: Float64Array): Float64Array;
 
   /**
    * Not implemented yet

Sources/Rendering/Core/Camera/index.js

@@ -343,9 +343,44 @@ function vtkCamera(publicAPI, model) {
   publicAPI.setObliqueAngles = (alpha, beta) => {};
   publicAPI.getOrientation = () => {};
   publicAPI.getOrientationWXYZ = () => {};
-  publicAPI.getFrustumPlanes = (aspect) => {
-    // Return array of 24 params (4 params for each of 6 plane equations)
+
+  publicAPI.getFrustumPlanes = (
+    aspect = 1.0,
+    planes = new Float64Array(24)
+  ) => {
+    const normals = [
+      // Left
+      [1, 0, 0, 1],
+      // Right
+      [-1, 0, 0, 1],
+      // Bottom
+      [0, 1, 0, 1],
+      // Top
+      [0, -1, 0, 1],
+      // Near
+      [0, 0, 1, 1],
+      // Far
+      [0, 0, -1, 1],
+    ];
+
+    // Get the composite projection matrix
+    const matrix = publicAPI.getCompositeProjectionMatrix(aspect, -1, 1);
+
+    // Transform the normals to world coordinates
+    for (let i = 0; i < 6; i++) {
+      vec4.transformMat4(normals[i], normals[i], matrix);
+
+      // Normalize the plane normal
+      vtkMath.normalize4D(normals[i]);
+
+      planes[4 * i + 0] = normals[i][0];
+      planes[4 * i + 1] = normals[i][1];
+      planes[4 * i + 2] = normals[i][2];
+      planes[4 * i + 3] = normals[i][3];
+    }
+    return planes;
   };
+
   publicAPI.getCameraLightTransformMatrix = (matrix) => {
     mat4.copy(matrix, model.cameraLightTransform);
     return matrix;