@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/services/WorkflowService.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowService = void 0;
+const api_1 = require("../constants/api");
+const RocosError_1 = require("../models/RocosError");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class WorkflowService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`WorkflowService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.WORKFLOW_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Create workflow
+     *
+     * @param projectId - Project Id
+     * @param model - Payload
+     */
+    // TODO: map the request model
+    // TODO: map the response object
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async createOne(projectId, model) {
+        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_WORKFLOW_URL, { url: this.config.url, projectId }, this.config.insecure), model, `Failed to create workflow for ${projectId}.`);
+    }
+    /**
+     * Get workflows for project
+     *
+     * @param projectId - Project Id
+     * @param includeRocosGraph - Include Rocos graph
+     * @param includeStats - Include stats
+     * @param opsId - Ops Id
+     * @param workflowIds - Workflow Id's
+     */
+    // TODO: map the response object
+    async getAll(projectId, includeRocosGraph = false, includeStats = false, opsId, workflowIds) {
+        const params = {
+            includeRocosGraph: includeRocosGraph ? 1 : 0,
+            includeStats: includeStats ? 1 : 0,
+        };
+        if (opsId) {
+            params.opsId = opsId;
+        }
+        if (workflowIds) {
+            params.workflowIds = workflowIds.join(',');
+        }
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_WORKFLOW_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get workflows for ${projectId}.`, params);
+    }
+    /**
+     * Get a workflow
+     *
+     * @param projectId - Project Id
+     * @param workflowId - Workflow Id
+     * @param includeInstances - Include instances
+     */
+    // TODO: map the response object
+    async getOne(projectId, workflowId, includeInstances = false) {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_WORKFLOW_ID_URL, { url: this.config.url, projectId, workflowId }, this.config.insecure), `Failed to get workflow for ${projectId}, workflowId ${workflowId}.`, { includeInstances: includeInstances ? 1 : 0 });
+    }
+    /**
+     * Update a workflow
+     *
+     * @param projectId - Project Id
+     * @param workflowId - Workflow Id
+     * @param model - Payload
+     */
+    // TODO: map the request model
+    // TODO: map the response object
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async updateOne(projectId, workflowId, model) {
+        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_WORKFLOW_ID_URL, { url: this.config.url, projectId, workflowId }, this.config.insecure), model, `Failed to update workflow for ${projectId}, workflowId ${workflowId}.`);
+    }
+    /**
+     * Delete a workflow
+     *
+     * @param projectId - Project Id
+     * @param workflowId - Workflow Id
+     */
+    // TODO: map the response object
+    async deleteOne(projectId, workflowId) {
+        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_WORKFLOW_ID_URL, { url: this.config.url, projectId, workflowId }, this.config.insecure), `Failed to delete workflow for ${projectId}, workflowId ${workflowId}.`);
+    }
+    /**
+     * Get all workflows for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     */
+    // TODO: map the response object
+    async getAllOfRobot(projectId, callsign) {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_CALLSIGN_WORKFLOW_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed to get workflows for ${projectId}, callsign ${callsign}.`);
+    }
+    /**
+     * Update workflows for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @param model - Payload
+     */
+    // TODO: map the request model
+    // TODO: map the response object
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async updateAllForRobot(projectId, callsign, model) {
+        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_CALLSIGN_WORKFLOW_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), model, `Failed to update workflows for ${projectId}, callsign ${callsign}.`);
+    }
+    /**
+     * Get deployed workflows on robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     */
+    async getDeployedOnRobot(projectId, callsign) {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_ROBOT_DEPLOYED_WORKFLOW_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed to update workflows for ${projectId}, callsign ${callsign}.`);
+    }
+}
+exports.WorkflowService = WorkflowService;

package/services/index.d.ts

@@ -0,0 +1,26 @@
+export * from './AssetStorageService';
+export * from './AuthService';
+export * from './CallerService';
+export * from './CommandService';
+export * from './ConfigGroupService';
+export * from './ControlService';
+export * from './DashboardService';
+export * from './EventService';
+export * from './FileAccessorService';
+export * from './FunctionService';
+export * from './IntegrationService';
+export * from './ProfileService';
+export * from './ProjectService';
+export * from './RobotService';
+export * from './SearchService';
+export * from './StreamService';
+export * from './TelemetryService';
+export * from './UserService';
+export * from './WebRTCSignallingService';
+export * from './WorkflowService';
+export * from './ScheduleService';
+export * from './TimeSyncerService';
+export * from './PlatformTimeService';
+export * from './SpotProvisioningService';
+export * from './SpotProvisioningServiceNode';
+export * from './MapService';

package/services/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AssetStorageService"), exports);
+__exportStar(require("./AuthService"), exports);
+__exportStar(require("./CallerService"), exports);
+__exportStar(require("./CommandService"), exports);
+__exportStar(require("./ConfigGroupService"), exports);
+__exportStar(require("./ControlService"), exports);
+__exportStar(require("./DashboardService"), exports);
+__exportStar(require("./EventService"), exports);
+__exportStar(require("./FileAccessorService"), exports);
+__exportStar(require("./FunctionService"), exports);
+__exportStar(require("./IntegrationService"), exports);
+__exportStar(require("./ProfileService"), exports);
+__exportStar(require("./ProjectService"), exports);
+__exportStar(require("./RobotService"), exports);
+__exportStar(require("./SearchService"), exports);
+__exportStar(require("./StreamService"), exports);
+__exportStar(require("./TelemetryService"), exports);
+__exportStar(require("./UserService"), exports);
+__exportStar(require("./WebRTCSignallingService"), exports);
+__exportStar(require("./WorkflowService"), exports);
+__exportStar(require("./ScheduleService"), exports);
+__exportStar(require("./TimeSyncerService"), exports);
+__exportStar(require("./PlatformTimeService"), exports);
+__exportStar(require("./SpotProvisioningService"), exports);
+__exportStar(require("./SpotProvisioningServiceNode"), exports);
+__exportStar(require("./MapService"), exports);

package/store/RocosStore.d.ts

@@ -0,0 +1,31 @@
+import { IRocosChangeMessage } from '../models/message/IRocosChangeMessage';
+import { IRocosSDK } from '../IRocosSDK';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { Subject } from 'rxjs';
+export declare class RocosStore {
+    private static changeSubject$?;
+    protected static instances: Record<string, IRocosSDK>;
+    /**
+     * A static method to get the change subject.
+     */
+    static getChangeSubject(): Subject<IRocosChangeMessage>;
+    /**
+     * A static method to get the SDK instance from instance register.
+     *
+     * @param config - SDK config {@link IRocosSDKConfig}
+     */
+    static getSDKInstance(config: IRocosSDKConfig): IRocosSDK;
+    /**
+     * A static method to put the SDK instance from instance register.
+     *
+     * @param config - SDK config {@link IRocosSDKConfig}
+     * @param instance - SDK instance {@link IRocosSDK}
+     */
+    static putSDKInstance(config: IRocosSDKConfig, instance: IRocosSDK): void;
+    /**
+     * A static method to remove the SDK instance from instance register.
+     *
+     * @param config - SDK config {@link IRocosSDKConfig}
+     */
+    static removeSDKInstance(config: IRocosSDKConfig): void;
+}

package/store/RocosStore.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RocosStore = void 0;
+const rxjs_1 = require("rxjs");
+const getUniqueConfigKey_1 = require("../helpers/getUniqueConfigKey");
+class RocosStore {
+    /**
+     * A static method to get the change subject.
+     */
+    static getChangeSubject() {
+        if (!RocosStore.changeSubject$) {
+            RocosStore.changeSubject$ = new rxjs_1.Subject();
+        }
+        return RocosStore.changeSubject$;
+    }
+    /**
+     * A static method to get the SDK instance from instance register.
+     *
+     * @param config - SDK config {@link IRocosSDKConfig}
+     */
+    static getSDKInstance(config) {
+        const uniqueConfigKey = getUniqueConfigKey_1.getUniqueConfigKey(config);
+        return RocosStore.instances[uniqueConfigKey];
+    }
+    /**
+     * A static method to put the SDK instance from instance register.
+     *
+     * @param config - SDK config {@link IRocosSDKConfig}
+     * @param instance - SDK instance {@link IRocosSDK}
+     */
+    static putSDKInstance(config, instance) {
+        var _a;
+        const uniqueConfigKey = getUniqueConfigKey_1.getUniqueConfigKey(config);
+        if (!((_a = RocosStore.instances) === null || _a === void 0 ? void 0 : _a[uniqueConfigKey])) {
+            RocosStore.instances[uniqueConfigKey] = instance;
+        }
+    }
+    /**
+     * A static method to remove the SDK instance from instance register.
+     *
+     * @param config - SDK config {@link IRocosSDKConfig}
+     */
+    static removeSDKInstance(config) {
+        var _a;
+        const uniqueConfigKey = getUniqueConfigKey_1.getUniqueConfigKey(config);
+        if ((_a = RocosStore.instances) === null || _a === void 0 ? void 0 : _a[uniqueConfigKey]) {
+            delete RocosStore.instances[uniqueConfigKey];
+        }
+    }
+}
+exports.RocosStore = RocosStore;
+// TODO(matej): migrate to non static instance registry
+RocosStore.instances = {};

package/utils/axisangle.d.ts

@@ -0,0 +1,18 @@
+import { FrameID } from './misc';
+import { LocalTransformTree } from './localtransformtree';
+import { PositionVector } from './positionvector';
+import { RotationMatrix } from './rotationmatrix';
+import { EulerAngles } from './eulerangles';
+import { Quaternion } from './quaternion';
+export declare class AxisAngle {
+    axis: PositionVector;
+    angle: number;
+    constructor(axis: PositionVector, angle: number);
+    Axis(): PositionVector;
+    Angle(): number;
+    ToRotm(): RotationMatrix;
+    ToEul(): EulerAngles;
+    ToQuat(): Quaternion;
+    ToAxAng(): AxisAngle;
+    ToFrame(tree: LocalTransformTree, thisID: FrameID, thatID: FrameID): AxisAngle;
+}

package/utils/axisangle.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxisAngle = void 0;
+const rotationmatrix_1 = require("./rotationmatrix");
+const mathjs_1 = require("mathjs");
+// AxisAngle contains an axis and angle of rotation about that axis
+class AxisAngle {
+    constructor(axis, angle) {
+        this.axis = axis;
+        this.angle = angle; // radians
+    }
+    Axis() { return this.axis; }
+    Angle() { return this.angle; }
+    // ToRotm returns the RotationMatrix representation of the rotation
+    ToRotm() {
+        var u = this.axis.unitVector();
+        var x = u.X();
+        var y = u.Y();
+        var z = u.Z();
+        var t = this.Angle(); // theta angle
+        return new rotationmatrix_1.RotationMatrix([
+            [mathjs_1.cos(t) + x ** 2 * (1 - mathjs_1.cos(t)), x * y * (1 - mathjs_1.cos(t)) - z * mathjs_1.sin(t), x * z * (1 - mathjs_1.cos(t)) + y * mathjs_1.sin(t)],
+            [y * x * (1 - mathjs_1.cos(t)) + z * mathjs_1.sin(t), mathjs_1.cos(t) + y ** 2 * (1 - mathjs_1.cos(t)), y * z * (1 - mathjs_1.cos(t)) - x * mathjs_1.sin(t)],
+            [z * x * (1 - mathjs_1.cos(t)) - y * mathjs_1.sin(t), z * y * (1 - mathjs_1.cos(t)) + x * mathjs_1.sin(t), mathjs_1.cos(t) + z ** 2 * (1 - mathjs_1.cos(t))]
+        ]);
+    }
+    // ToEul returns the EulerAngles representation of the rotation
+    ToEul() {
+        var rotm = this.ToRotm();
+        return rotm.ToEul();
+    }
+    // ToQuat returns the Quaternion representation of the rotation
+    ToQuat() {
+        var rotm = this.ToRotm();
+        return rotm.ToQuat();
+    }
+    // ToAxAng returns the AxisAngle representation of the rotation
+    ToAxAng() {
+        return this;
+    }
+    // ToFrame returns the rotation relative to the new specified frame
+    ToFrame(tree, thisID, thatID) {
+        var rotm = this.ToRotm();
+        var newRotm = rotm.ToFrame(tree, thisID, thatID);
+        return newRotm.ToAxAng();
+    }
+}
+exports.AxisAngle = AxisAngle;

package/utils/eulerangles.d.ts

@@ -0,0 +1,22 @@
+import { FrameID, Seq } from './misc';
+import { LocalTransformTree } from './localtransformtree';
+import { RotationMatrix } from './rotationmatrix';
+import { Quaternion } from './quaternion';
+import { AxisAngle } from './axisangle';
+export declare class EulerAngles {
+    alpha: number;
+    beta: number;
+    gamma: number;
+    seq: Seq;
+    constructor(alpha: number, beta: number, gamma: number, seq: Seq);
+    Alpha(): number;
+    Beta(): number;
+    Gamma(): number;
+    Seq(): Seq;
+    ToRotm(): RotationMatrix;
+    ToEul(): EulerAngles;
+    ToQuat(): Quaternion;
+    ToAxAng(): AxisAngle;
+    ToFrame(tree: LocalTransformTree, thisID: FrameID, thatID: FrameID): EulerAngles;
+    ToZYX(): EulerAngles;
+}

package/utils/eulerangles.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EulerAngles = void 0;
+const misc_1 = require("./misc");
+const rotationmatrix_1 = require("./rotationmatrix");
+const quaternion_1 = require("./quaternion");
+const mathjs_1 = require("mathjs");
+// EulerAngles contains the euler angles with specified convention
+class EulerAngles {
+    constructor(alpha, beta, gamma, seq) {
+        this.alpha = alpha; // X
+        this.beta = beta; // Y
+        this.gamma = gamma; // Z
+        this.seq = seq;
+    }
+    Alpha() { return this.alpha; }
+    Beta() { return this.beta; }
+    Gamma() { return this.gamma; }
+    Seq() { return this.seq; }
+    // ToRotm returns the RotationMatrix representation of the rotation
+    ToRotm() {
+        var sinB = mathjs_1.sin(this.beta);
+        var cosB = mathjs_1.cos(this.beta);
+        var sinA = mathjs_1.sin(this.alpha);
+        var cosA = mathjs_1.cos(this.alpha);
+        var sinG = mathjs_1.sin(this.gamma);
+        var cosG = mathjs_1.cos(this.gamma);
+        switch (this.Seq()) {
+            // Proper Euler angles
+            case misc_1.Seq.XZX:
+                return new rotationmatrix_1.RotationMatrix([[cosB, -cosG * sinB, sinB * sinG],
+                    [cosA * sinB, cosA * cosB * cosG - sinA * sinG, -cosG * sinA - cosA * cosB * sinG],
+                    [sinA * sinB, cosA * sinG + cosB * cosG * sinA, cosA * cosG - cosB * sinA * sinG]]);
+            case misc_1.Seq.XYX:
+                return new rotationmatrix_1.RotationMatrix([[cosB, sinB * sinG, cosG * sinB],
+                    [sinA * sinB, cosA * cosG - cosB * sinA * sinG, -cosA * sinG - cosB * cosG * sinA],
+                    [-cosA * sinB, cosG * sinA + cosA * cosB * sinG, cosA * cosB * cosG - sinA * sinG]]);
+            case misc_1.Seq.YXY:
+                return new rotationmatrix_1.RotationMatrix([[cosA * cosG - cosB * sinA * sinG, sinA * sinB, cosA * sinG + cosB * cosG * sinA],
+                    [sinB * sinG, cosB, -cosG * sinB],
+                    [-cosG * sinA - cosA * cosB * sinG, cosA * sinB, cosA * cosB * cosG - sinA * sinG]]);
+            case misc_1.Seq.YZY:
+                return new rotationmatrix_1.RotationMatrix([[cosA * cosB * cosG - sinA * sinG, -cosA * sinB, cosG * sinA + cosA * cosB * sinG],
+                    [cosG * sinB, cosB, sinB * sinG],
+                    [-cosA * sinG - cosB * cosG * sinA, sinA * sinB, cosA * cosG - cosB * sinA * sinG]]);
+            case misc_1.Seq.ZYZ:
+                return new rotationmatrix_1.RotationMatrix([[cosA * cosB * cosG - sinA * sinG, -cosG * sinA - cosA * cosB * sinG, cosA * sinB],
+                    [cosA * sinG + cosB * cosG * sinA, cosA * cosG - cosB * sinA * sinG, -cosA * sinB],
+                    [-cosG * sinB, sinB * sinG, cosB]]);
+            case misc_1.Seq.ZXZ:
+                return new rotationmatrix_1.RotationMatrix([[cosA * cosG - cosB * sinA * sinG, -cosA * sinG - cosB * cosG * sinA, sinA * sinB],
+                    [cosG * sinA + cosA * cosB * sinG, cosA * cosB * cosG - sinA * sinG, -cosA * sinB],
+                    [sinB * sinG, cosG * sinB, cosB]]);
+            // Tait-Bryan angles
+            case misc_1.Seq.XZY:
+                return new rotationmatrix_1.RotationMatrix([[cosB * cosG, -sinB, cosB * sinG],
+                    [sinA * sinG + cosA * cosG * sinB, cosA * cosB, cosA * sinB * sinG - cosG * sinA],
+                    [cosG * sinA * sinB - cosA * sinG, cosB * sinA, cosA * cosG + sinA * sinB * sinG]]);
+            case misc_1.Seq.XYZ:
+                return new rotationmatrix_1.RotationMatrix([[cosB * cosG, -cosB * sinG, sinB],
+                    [cosA * sinG + cosG * sinA * sinB, cosA * cosG - sinA * sinB * sinG, -cosB * sinA],
+                    [sinA * sinG - cosA * cosG * sinB, cosG * sinA + cosA * sinB * sinG, cosA * cosB]]);
+            case misc_1.Seq.YXZ:
+                return new rotationmatrix_1.RotationMatrix([[cosA * cosG + sinA * sinB * sinG, cosG * sinA * sinB - cosA * sinG, cosB * sinA],
+                    [cosB * sinG, cosB * cosG, -sinB],
+                    [cosA * sinB * sinG - cosG * sinA, cosA * cosG * sinB + sinA * sinG, cosA * cosB]]);
+            case misc_1.Seq.YZX:
+                return new rotationmatrix_1.RotationMatrix([[cosA * cosB, sinA * sinG - cosA * cosG * sinB, cosG * sinA + cosA * sinB * sinG],
+                    [sinB, cosB * cosG, -cosB * sinG],
+                    [-cosB * sinA, cosA * sinG + cosG * sinA * sinB, cosA * cosG - sinA * sinB * sinG]]);
+            case misc_1.Seq.ZYX:
+                return new rotationmatrix_1.RotationMatrix([[cosA * cosB, cosA * sinB * sinG - cosG * sinA, sinA * sinG + cosA * cosG * sinB],
+                    [cosB * sinA, cosA * cosG + sinA * sinB * sinG, cosG * sinA * sinB - cosA * sinG],
+                    [-sinB, cosB * sinG, cosB * cosG]]);
+            case misc_1.Seq.ZXY:
+                return new rotationmatrix_1.RotationMatrix([[cosA * cosG - sinA * sinB * sinG, -cosB * sinA, cosA * sinG + cosG * sinA * sinB],
+                    [cosG * sinA + cosA * sinB * sinG, cosA * cosB, sinA * sinG - cosA * cosG * sinB],
+                    [-cosB * sinG, sinB, cosB * cosG]]);
+            default:
+                throw "Invalid sequence!";
+        }
+    }
+    // ToEul returns the EulerAngles representation of the rotation
+    ToEul() {
+        return this;
+    }
+    // ToQuat returns the Quaternion representation of the rotation
+    ToQuat() {
+        var yaw = this.alpha;
+        var pitch = this.beta;
+        var gamma = this.gamma;
+        // Abbreviations for the various angular functions
+        var cy = mathjs_1.cos(yaw * 0.5);
+        var sy = mathjs_1.sin(yaw * 0.5);
+        var cp = mathjs_1.cos(pitch * 0.5);
+        var sp = mathjs_1.sin(pitch * 0.5);
+        var cr = mathjs_1.cos(gamma * 0.5);
+        var sr = mathjs_1.sin(gamma * 0.5);
+        var q = new quaternion_1.Quaternion(0, 0, 0, 0);
+        q.w = cr * cp * cy + sr * sp * sy;
+        q.x = sr * cp * cy - cr * sp * sy;
+        q.y = cr * sp * cy + sr * cp * sy;
+        q.z = cr * cp * sy - sr * sp * cy;
+        return q;
+    }
+    // ToAxAng returns the AxisAngle representation of the rotation
+    ToAxAng() {
+        var rotm = this.ToRotm();
+        return rotm.ToAxAng();
+    }
+    // ToFrame returns the euler angles relative to the new specified frame
+    ToFrame(tree, thisID, thatID) {
+        var eul;
+        if (this.seq != misc_1.Seq.ZYX) {
+            eul = this.ToZYX();
+        }
+        else {
+            eul = this;
+        }
+        var rotm = eul.ToRotm();
+        var newRotm = rotm.ToFrame(tree, thisID, thatID);
+        return newRotm.ToEul();
+    }
+    // ToZYX converts euler angles of any sequence to ZYX euler angles
+    ToZYX() {
+        if (this.Seq() == misc_1.Seq.ZYX) {
+            return this;
+        }
+        var rotm = this.ToRotm();
+        return rotm.ToEul();
+    }
+}
+exports.EulerAngles = EulerAngles;

package/utils/helperfunctions.d.ts

@@ -0,0 +1,5 @@
+import { FrameID } from './misc';
+import { LocalTransformTree } from './localtransformtree';
+import { TransformationMatrix } from './transformationmatrix';
+export declare function frameToFrameTransformationMatrixSeq(tree: LocalTransformTree, seq: FrameID[], isInverse: Boolean): TransformationMatrix;
+export declare function copysign(num1: number, num2: number): number;

package/utils/helperfunctions.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copysign = exports.frameToFrameTransformationMatrixSeq = void 0;
+const transformationmatrix_1 = require("./transformationmatrix");
+const mathjs_1 = require("mathjs");
+// Calculate the total transformation matrix between the start and end of a branch sequence 
+function frameToFrameTransformationMatrixSeq(tree, seq, isInverse) {
+    // Set variables in preperation for iteration down tree
+    var currentFrame = tree.getFrame(seq[0]);
+    var currentTransformationMatrix = currentFrame.GetTransformationMatrix();
+    var totalTransformationMatrix = currentTransformationMatrix;
+    // Iterate through sequence and apply transformations
+    // This is under the assumption that the root node is an identity transformation matrix
+    for (var i = 1; i < seq.length - 1; i++) {
+        // Set transformation variables for multiplication
+        var currentFrame = tree.getFrame(seq[i]);
+        currentTransformationMatrix = currentFrame.GetTransformationMatrix();
+        // Multiply current transformation matrix with total transformation matrix
+        var temp = currentTransformationMatrix.Multiply(totalTransformationMatrix);
+        if (temp instanceof transformationmatrix_1.TransformationMatrix) {
+            totalTransformationMatrix = temp;
+        }
+        else {
+            throw "Something is terribly wrong";
+        }
+    }
+    if (isInverse) {
+        // The inverse of a (totalTransformation) matrix that has been created by multiplying several (currentTransformation) matrices together
+        // is equivalent to multiplying the inverse of each matrix in the reverse order: inv(T1*T2) = inv(T2)*inv(T1)
+        // Therefore the sequence is always be DOWN the branch (no sequence reversal needed for UP tree transformations)
+        return new transformationmatrix_1.TransformationMatrix(mathjs_1.inv(totalTransformationMatrix.elements));
+    }
+    else {
+        return totalTransformationMatrix;
+    }
+}
+exports.frameToFrameTransformationMatrixSeq = frameToFrameTransformationMatrixSeq;
+// copy the sign (+ or -) of num2 for num1
+function copysign(num1, num2) {
+    if (mathjs_1.sign(num2) == -1) {
+        return mathjs_1.abs(num1) * -1;
+    }
+    else if (mathjs_1.sign(num2) == 0) {
+        return num1;
+    }
+    else {
+        return mathjs_1.abs(num1);
+    }
+}
+exports.copysign = copysign;

package/utils/localtransform.d.ts

@@ -0,0 +1,17 @@
+import { FrameID } from './misc';
+import { LocalTransformTree } from './localtransformtree';
+import { PositionVector } from './positionvector';
+import { RotationMatrix } from './rotationmatrix';
+import { TransformationMatrix } from './transformationmatrix';
+export declare class LocalTransform {
+    origin: PositionVector;
+    basis: RotationMatrix;
+    frameID: FrameID;
+    constructor(origin: PositionVector, basis: RotationMatrix, frameID: FrameID);
+    ID(): FrameID;
+    ParentID(tree: LocalTransformTree): FrameID;
+    GetRotation(): RotationMatrix;
+    GetPosition(): PositionVector;
+    GetTransformationMatrix(): TransformationMatrix;
+    ToFrame(tree: LocalTransformTree, resultFrameID: FrameID): TransformationMatrix;
+}

package/utils/localtransform.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalTransform = void 0;
+const transformationmatrix_1 = require("./transformationmatrix");
+const helperfunctions_1 = require("./helperfunctions");
+// LocalTransform is the implementation of Transform locally within the script
+class LocalTransform {
+    constructor(origin, basis, frameID) {
+        this.origin = origin;
+        this.basis = basis;
+        this.frameID = frameID;
+    }
+    ID() { return this.frameID; }
+    ParentID(tree) { return tree.getParent(this.ID()); }
+    GetRotation() { return this.basis; }
+    GetPosition() { return this.origin; }
+    GetTransformationMatrix() {
+        return new transformationmatrix_1.TransformationMatrix([[this.basis.elements[0][0], this.basis.elements[0][1], this.basis.elements[0][2], this.origin.elements[0][0]],
+            [this.basis.elements[1][0], this.basis.elements[1][1], this.basis.elements[1][2], this.origin.elements[1][0]],
+            [this.basis.elements[2][0], this.basis.elements[2][1], this.basis.elements[2][2], this.origin.elements[2][0]],
+            [0, 0, 0, 1]]);
+    }
+    // ToFrame returns the transformation matrix relative to the new specified frame
+    ToFrame(tree, resultFrameID) {
+        var originalFrameID = this.ID();
+        if (originalFrameID == resultFrameID) {
+            return this.GetTransformationMatrix();
+        }
+        else if (tree.isDescendant(originalFrameID, resultFrameID)) {
+            return helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(originalFrameID, resultFrameID), false);
+        }
+        else if (tree.isAncestor(originalFrameID, resultFrameID)) {
+            return helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(resultFrameID, originalFrameID), true);
+        }
+        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_1.TransformationMatrix) {
+                return new transformationmatrix_1.TransformationMatrix(totalTM.elements);
+            }
+            else {
+                throw "Erorr occurred";
+            }
+        }
+    }
+}
+exports.LocalTransform = LocalTransform;

package/utils/localtransformtree.d.ts

@@ -0,0 +1,17 @@
+import { FrameID } from './misc';
+import { LocalTransform } from './localtransform';
+export declare class LocalTransformTree {
+    frames: Map<FrameID, LocalTransform>;
+    parents: Map<FrameID, FrameID>;
+    children: Map<FrameID, FrameID[]>;
+    constructor(frames: Map<FrameID, LocalTransform>, parents: Map<FrameID, FrameID>, children: Map<FrameID, FrameID[]>);
+    getFrame(searchID: FrameID): LocalTransform;
+    getSeqDown(start: FrameID, end: FrameID): FrameID[];
+    getCommonFrameID(frame1ID: FrameID, frame2ID: FrameID): FrameID;
+    getParent(searchID: FrameID): FrameID;
+    getChildren(searchID: FrameID): FrameID[];
+    isChild(originalFrameID: FrameID, resultFrameID: FrameID): boolean;
+    isParent(originalFrameID: FrameID, resultFrameID: FrameID): boolean;
+    isAncestor(originalFrameID: FrameID, resultFrameID: FrameID): boolean;
+    isDescendant(originalFrameID: FrameID, resultFrameID: FrameID): boolean;
+}