@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/utils/transformationmatrix.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformationMatrix = void 0;
+const positionvector_1 = require("./positionvector");
+const rotationmatrix_1 = require("./rotationmatrix");
+const helperfunctions_1 = require("./helperfunctions");
+// TransformationMatrix is 4x4 transformation matrix
+class TransformationMatrix {
+    constructor(elements) {
+        this.elements = elements;
+    }
+    // getRotation returns the local transform's rotation matrix
+    getRotation() {
+        var e = this.elements;
+        return new rotationmatrix_1.RotationMatrix([[e[0][0], e[0][1], e[0][2]],
+            [e[1][0], e[1][1], e[1][2]],
+            [e[2][0], e[2][1], e[2][2]]]);
+    }
+    // getPosition returns the local transform's position vector
+    getPosition() {
+        var e = this.elements;
+        return new positionvector_1.PositionVector([[e[0][3]], [e[1][3]], [e[2][3]]]);
+    }
+    // Multiply multipies with a given matrix
+    Multiply(mB) {
+        var matrixA = this.elements;
+        if (mB instanceof positionvector_1.PositionVector) {
+            var e = mB.elements;
+            var matrixB = [[e[0][0]], [e[1][0]], [e[2][0]], [1]];
+        }
+        else if (mB instanceof rotationmatrix_1.RotationMatrix) {
+            var ele = mB.elements;
+            var matrixB = [
+                [ele[0][0], ele[0][1], ele[0][2]],
+                [ele[1][0], ele[1][1], ele[1][2]],
+                [ele[2][0], ele[2][1], ele[2][2]],
+                [0, 0, 1]
+            ];
+        }
+        else if (mB instanceof TransformationMatrix) {
+            var matrixB = mB.elements;
+        }
+        else {
+            throw "Error occurred";
+        }
+        var aNumRows = matrixA.length, aNumCols = matrixA[0].length, bNumCols = matrixB[0].length, m = new Array(aNumRows);
+        for (var r = 0; r < aNumRows; ++r) {
+            m[r] = new Array(bNumCols);
+            for (var c = 0; c < bNumCols; ++c) {
+                m[r][c] = 0;
+                for (var i = 0; i < aNumCols; ++i) {
+                    m[r][c] += matrixA[r][i] * matrixB[i][c];
+                }
+            }
+        }
+        var rows = m.length;
+        var cols = m[0].length;
+        if (rows == 4 && cols == 4) {
+            return new TransformationMatrix(m);
+        }
+        else if (rows == 4 && cols == 3) {
+            var result = [
+                [m[0][0], m[0][1], m[0][2]],
+                [m[1][0], m[1][1], m[1][2]],
+                [m[2][0], m[2][1], m[2][2]]
+            ];
+            return new rotationmatrix_1.RotationMatrix(result);
+        }
+        else if (rows == 4 && cols == 1) {
+            return new positionvector_1.PositionVector([[m[0][0]], [m[1][0]], [m[2][0]]]);
+        }
+        else {
+            throw "Error occurred";
+        }
+    }
+    // ToFrame returns the transformation matrix relative to the new specified frame
+    ToFrame(tree, originalFrameID, resultFrameID) {
+        if (originalFrameID == resultFrameID) {
+            return this;
+        }
+        else if (tree.isDescendant(originalFrameID, resultFrameID)) {
+            var trans = helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(originalFrameID, resultFrameID), false);
+            var totalTM = trans.Multiply(this);
+            if (totalTM instanceof TransformationMatrix) {
+                return totalTM;
+            }
+            else {
+                throw "Error occurred";
+            }
+        }
+        else if (tree.isAncestor(originalFrameID, resultFrameID)) {
+            var trans = helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(resultFrameID, originalFrameID), true);
+            var totalTM = trans.Multiply(this);
+            if (totalTM instanceof TransformationMatrix) {
+                return totalTM;
+            }
+            else {
+                throw "Error occurred";
+            }
+        }
+        else { // Frames are on different branches
+            var commonNode = tree.getCommonFrameID(originalFrameID, resultFrameID);
+            // Calculate the transformation matrix of each frame relative to the common node
+            var totalTM1 = helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(originalFrameID, commonNode), false); // calculate down tree matrix
+            var totalTM2 = helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(resultFrameID, commonNode), true); // calculate up the tree (inverses)
+            var totalTM = totalTM2.Multiply(totalTM1);
+            if (totalTM instanceof TransformationMatrix) {
+                // Apply the transformation
+                var total = totalTM.Multiply(this);
+                if (total instanceof TransformationMatrix) {
+                    return total;
+                }
+                else {
+                    throw "Erorr occurred";
+                }
+            }
+            else {
+                throw "Error occurred";
+            }
+        }
+    }
+}
+exports.TransformationMatrix = TransformationMatrix;

package/utils/vector3.d.ts

@@ -0,0 +1,11 @@
+import { PositionVector } from './positionvector';
+export declare class Vector3 {
+    elements: number[][];
+    constructor(elements: number[][]);
+    X(): number;
+    Y(): number;
+    Z(): number;
+    magnitude(): number;
+    unitVector(): Vector3;
+    Multiply(mB: Vector3 | PositionVector): Vector3 | PositionVector;
+}

package/utils/vector3.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector3 = void 0;
+const positionvector_1 = require("./positionvector");
+// Vector3 is a 3X1 matrix that contains a vector
+class Vector3 {
+    constructor(elements) {
+        this.elements = elements;
+    }
+    X() { return this.elements[0][0]; }
+    Y() { return this.elements[1][0]; }
+    Z() { return this.elements[2][0]; }
+    // magnitude returns the magnitude of the vector
+    magnitude() {
+        var vec = this.elements;
+        var sum = 0;
+        for (var i = 0; i < vec.length; i++) {
+            sum += vec[i][0] ** 2;
+        }
+        return sum ** 0.5;
+    }
+    // unitVector returns the unit vector of the vector
+    unitVector() {
+        var mag = this.magnitude();
+        var e = this.elements;
+        return new Vector3([[e[0][0] / mag], [e[1][0] / mag], [e[2][0] / mag]]);
+    }
+    // Multiply multipies with a given matrix
+    Multiply(mB) {
+        var matrixA = this.elements;
+        if (mB instanceof positionvector_1.PositionVector) {
+            var e = mB.elements;
+            var matrixB = [[e[0][0]], [e[1][0]], [e[2][0]], [1]];
+        }
+        else {
+            throw "Error occurred";
+        }
+        var aNumRows = matrixA.length, aNumCols = matrixA[0].length, bNumCols = matrixB[0].length, m = new Array(aNumRows);
+        for (var r = 0; r < aNumRows; ++r) {
+            m[r] = new Array(bNumCols);
+            for (var c = 0; c < bNumCols; ++c) {
+                m[r][c] = 0;
+                for (var i = 0; i < aNumCols; ++i) {
+                    m[r][c] += matrixA[r][i] * matrixB[i][c];
+                }
+            }
+        }
+        var rows = m.length;
+        var cols = m[0].length;
+        if (rows == 3 && cols == 1 && mB instanceof positionvector_1.PositionVector) {
+            return new positionvector_1.PositionVector([[m[0][0]], [m[1][0]], [m[2][0]]]);
+        }
+        else if (rows == 3 && cols == 1 && mB instanceof Vector3) {
+            return new positionvector_1.PositionVector([[m[0][0]], [m[1][0]], [m[2][0]]]);
+        }
+        else {
+            throw "Error occurred";
+        }
+    }
+}
+exports.Vector3 = Vector3;