fcs-core-viewer 0.2.0

package/fcs-core-viewer@types/Addins/CustomScript.d.ts

@@ -0,0 +1,11 @@
+import { TaskUtils } from "../TaskHandler/TaskUtils";
+/**
+ * Serves to host additional development functionalities.
+ */
+export declare namespace Addins {
+    /**
+     * By registering addins we hook up event listeners and path them to the correct
+     * method defined in this class.
+     */
+    function registerAddins(taskUtils: TaskUtils): void;
+}

package/fcs-core-viewer@types/Addins/Index.d.ts

@@ -0,0 +1 @@
+export * from './CustomScript';

package/fcs-core-viewer@types/Api.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Contains all usable exports to build custom frontend applications
+ * that leverage the FCS Cloud Viewer and Editor.
+ */
+export * from './Foundations/Index';
+export * from './ViewerEntities/Index';
+export * from './CloudViewer/Settings/Index';
+export * from './Model/Index';
+export * from './CloudViewer/Index';
+export * from './Common/Index';

package/fcs-core-viewer@types/BackendEvents/BackendEvents.d.ts

@@ -0,0 +1,218 @@
+import { MeshWrapper } from '../Model/MeshWrapper';
+import { SceneWrapper } from '../Model/SceneWrapper';
+import { Appearance } from '../TaskHandler/Context/Context';
+import { Loader } from '../Loader/Loader';
+import { TreeOperations } from '../TaskHandler/Tree/Tree';
+import { TreeView } from '../UserInterface/UIComponents/TreeView';
+import { TaskUtils } from '../TaskHandler/TaskUtils';
+import { CloudViewer } from '../CloudViewer/FcsViewer';
+import { Translate } from '../TaskHandler/Topbar/Tools/Transformation';
+import { Measurement } from '../TaskHandler/Topbar/Tools/Measurement';
+import { Options } from '../TaskHandler/Options/Options';
+import { TaskExecutionResponse } from './TaskExecutionResponse';
+import { IBackendEvents } from '../CloudViewer/CoreInterfaces';
+import { AddTreeItem } from '../TaskHandler/Tree/ResponseHandler/AddTreeItem';
+/**
+ * This is the format of the backend received data.
+ */
+interface BackendInstructions {
+    operation: string;
+    arguments: any;
+    finished?: boolean;
+    /**
+     * Task callback arguments
+     */
+    callback_guid_id?: string;
+    /**
+     * Optional addin arguments
+     */
+    addin_command?: string;
+    addin?: string;
+    on_finished_arguments?: {};
+}
+/**
+ * All events that were triggered by the backend.
+ * Normally, everything is first run by the backend to make sure if the
+ * changes can take affect in the model file. Once successful, it is returned
+ * back with sockets.
+ */
+export declare class BackendEvents implements IBackendEvents {
+    licenseToken: string;
+    meshWrapper: MeshWrapper;
+    sceneWrapper: SceneWrapper;
+    appearance: Appearance;
+    loader: Loader;
+    treeView: TreeView;
+    treeOps: TreeOperations;
+    taskUtils: TaskUtils;
+    options: Options;
+    translate: Translate;
+    measurement: Measurement;
+    addTreeItem: AddTreeItem;
+    name: string;
+    tName: string;
+    operation: string;
+    stlPath: string;
+    stlPathStatic: string;
+    t2gPathStatic: string;
+    scene: any;
+    controls: any;
+    renderer: any;
+    currentCamera: any;
+    grEntityLabel: any;
+    requestArray: any[];
+    requestIndex: number;
+    response: any;
+    status: string;
+    backendInstructionData: {};
+    components: {};
+    wereListenersRegistered: boolean;
+    readonly operationToFunction: {
+        show_progress_tracker: any;
+        finish_progress_tracker: any;
+        show_status_message: any;
+        translate_two_points: any;
+        measure_distance: any;
+        WhatIs: any;
+        hide: any;
+        show: any;
+        hide_all: any;
+        show_all: any;
+        set_transparency: any;
+        center_view: any;
+        set_object_color: any;
+        refresh_viewer: any;
+        clear_document: any;
+        commit_to_document: any;
+        remove_from_document: any;
+        add_new_container: any;
+        add_new_container_under: any;
+        add_to_document: any;
+        add_to_document_under: any;
+        export_STEP_for_selection: any;
+        generic_callback_middleware: any;
+    };
+    /**
+     * Contains guid to backend service mappings.
+     */
+    attachedServices: {
+        [key: string]: CloudViewer.BackendService;
+    };
+    /**
+     * Contains all approved guids
+     */
+    registeredAddinGuids: string[];
+    /**
+     * Callback function GUIDs
+     */
+    guidCallbackDictionary: {
+        [key: string]: Function;
+    };
+    /**
+     * Constructor.
+     */
+    constructor(licenseToken: string, sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper, loader: Loader, appearance: Appearance, treeView: TreeView, treeOperations: TreeOperations, taskUtilities: TaskUtils, options: Options, translate: Translate, measurement: Measurement, addTreeItem: AddTreeItem);
+    /**
+     * Saves the backend service and will be able to invoke the
+     * 'OnFinished' method on call back from backend service.
+     * @param service
+     * @param serviceMethod
+     */
+    attachService(service: CloudViewer.BackendService): void;
+    /**
+     * We pass in a function that will be called when the backend task finishes.
+     * We save this method in a dictionary where it will receive a GUID.
+     * When the method finishes it will search in the through the
+     * 'guidCallbackDictionary' to look if there are any methods that need to be run.
+     * @param callbackFn Method to be run after the task is finished
+     * @returns created Guid that will be used to identify the callback function
+     */
+    attachCallbackMethodToTask(callbackFn: Function): string;
+    /**
+     * Registers all available event listeners.
+     */
+    private _registerEventListeners;
+    /**
+     * Miutan egyszer elinditottuk a scheduler funkciot, while ciklussal menjunk vegig a array-en,
+     * melyet a backend-bol jovo request-ek folyamatosan toltenek fel feladatokkal.
+     * Ha i = N akkor kuldje a response-t.
+     * @returns Response from called backend method.
+     */
+    private scheduler;
+    /**
+     * Dummy placeholder method that serves as a generic middleware to all methods.
+     * @returns
+     */
+    private generic_callback_middleware;
+    /**
+     * Centers the view.
+     * @param data Does not matter, because it centers everything that's visible
+     */
+    private center_view;
+    /**
+     * Renders latest document (whatever was added/removed/modified)
+     */
+    private refresh_viewer;
+    /**
+     * Clears all entities in the document. Basically, a new empty document is open.
+     */
+    private clear_document;
+    /**
+     * This method is called both times when we are spawning the progress
+     * tracker or updating an existing one. To close down the progress tracker,
+     * we need to call a different method from the API, called `finish_progress_tracker`.
+     * @param data Contains 'progress_percentage' and 'current_process_name'
+     */
+    show_progress_tracker(instructions: BackendInstructions): Promise<TaskExecutionResponse>;
+    /**
+     * Stops the progress tracker and presents the exit status, unless
+     * immediate shutdown was requested.
+     * @param data Passes on an `exit_message`, `exit_status`, `immediate_shutdown`.
+     */
+    finish_progress_tracker(data: BackendInstructions): Promise<TaskExecutionResponse>;
+    /**
+     * If there was an already running progress dialog, it is reset.
+     * This is not ideal, but we really only want to keep a single instance
+     * of a pop-up status window.
+     * @param data
+     */
+    show_status_message(backendInstruction: BackendInstructions): Promise<TaskExecutionResponse>;
+    private remove_from_document;
+    /**
+     * Add empty file, folder or container to the viewer
+     * @param data
+     * @returns
+     */
+    private add_empty_item;
+    add_to_document(data: BackendInstructions): Promise<TaskExecutionResponse>;
+    set_object_color(data: BackendInstructions): Promise<TaskExecutionResponse>;
+    /**
+     * Sets the transparency of an object.
+     * @param instructions Contains ID and opacity
+     */
+    set_transparency(instructions: BackendInstructions): TaskExecutionResponse | "Finished: set_transparency";
+    /**
+     * Will set visibility toggle on for all passed in entity_ids.
+     * @param instructions Contains entity_ids only
+     */
+    private _show;
+    private _hide;
+    set_object_visibility(instructions: BackendInstructions): Promise<TaskExecutionResponse>;
+    /**
+     * Saves the currently active model's path, it will mark it as saveable.
+     * ToDo: For any other changes that were not committed to, we will need to
+     * disable the ability to export the model.
+     * @param instructions
+     * @returns 'Finished' message
+     */
+    commit_to_document(instructions: BackendInstructions): Promise<TaskExecutionResponse>;
+    /**
+     *
+     * @param instructions Contains exported STEP file path
+     */
+    private export_STEP_for_selection;
+    translate_two_points(data: BackendInstructions): Promise<TaskExecutionResponse>;
+    measure_distance(data: BackendInstructions): Promise<TaskExecutionResponse>;
+    WhatIs(data: BackendInstructions): Promise<TaskExecutionResponse>;
+}
+export {};

package/fcs-core-viewer@types/BackendEvents/TaskExecutionResponse.d.ts

@@ -0,0 +1,22 @@
+export declare enum TaskExecutionOutcome {
+    Successful = 0,
+    SuccessfulWithWarnings = 1,
+    FailureButCanContinue = 2,
+    CompleteFailure = 3
+}
+export declare class TaskExecutionResponse {
+    private _functionName;
+    private _executionOutcome;
+    private _errorMessage;
+    private _warningMessage;
+    constructor(functionName: string);
+    /**
+     * Uses the stack trace to create a default
+     * @returns A default execution response with successful outcome.
+     */
+    static ConstructDefaultResponse(): TaskExecutionResponse;
+    getOutcome(): TaskExecutionOutcome;
+    setOutcome(outcome: TaskExecutionOutcome): void;
+    setWarningMessage(_warningMessage: string): void;
+    setErrorMessage(errorMessages: string): void;
+}

package/fcs-core-viewer@types/CloudViewer/CoreInterfaces.d.ts

@@ -0,0 +1,12 @@
+import { BackendManager } from "../Common/CommsChannels/BackendClient";
+/**
+ * Core interfaces serve to declare types that are used in
+ * code that is not directly accessible via the API.
+ */
+export interface ITaskUtilities {
+    setBackendManager(backendManager: BackendManager): void;
+    getDataFromSelected(): any | null;
+}
+export interface IBackendEvents {
+    attachCallbackMethodToTask(callbackFn: Function): string;
+}

package/fcs-core-viewer@types/CloudViewer/FcsViewer.d.ts

@@ -0,0 +1,379 @@
+import { CameraOperationInput, SceneWrapper } from "./TypesFcs";
+import { StyleSettings } from "./Settings/StyleSettings";
+import { VisibilitySettings } from './Settings/VisibilitySettings';
+import { CameraSettings } from "./Settings/CameraSettings";
+import { AnnotationEntities } from "../ViewerEntities/VisibleEntities/AnnotationEntities";
+import { AbstractEntities } from '../ViewerEntities/AbstractEntities';
+import { ContainerEntities } from "../ViewerEntities/ContainerEntities";
+import { TemporaryEntities } from '../ViewerEntities/VisibleEntities/TemporaryEntities';
+/**
+ * Contains all control methods to the cloud viewer.
+ */
+export declare namespace CloudViewer {
+    /**
+     * Engulf all settings to initialise a viewer.
+     */
+    class ViewerSettings {
+        /**
+         * Contains settings that are responsible for styling of the viewer.
+         */
+        viewerStyleSettings: StyleSettings.ViewerStyleSettings;
+        /**
+         * Contains settings that position the camera.
+         */
+        cameraInitialSettings: CameraSettings.Camera;
+    }
+    /**
+     * Constructor for generic 3D viewer.
+     */
+    class Generic3DViewer {
+        private _container;
+        private _authToken;
+        private _canvas;
+        private _initSettings;
+        private _viewerWrapper;
+        private _registeredAddinApplications;
+        private _backendManager;
+        private _activeSelectionFilter;
+        private _onSelectionEvent;
+        private _scene;
+        private _currentCamera;
+        private _renderer;
+        /**
+         * Constructor to instantiate viewer.
+         */
+        constructor(container: HTMLDivElement, initSettings?: ViewerSettings, licenseToken?: string, disallowSocketCallbacks?: boolean);
+        /**
+         * Constructs a top level item with geometric definition.
+         * @param itemId Unique ID of the item.
+         * @param itemName Name of the item.
+         * @param stlFileUrl Public download URL for STL file.
+         * @param t2gFileUrl Public download URL for T2G file.
+         */
+        addToDocument(itemId: number, itemName: string, stlFileUrl: string, t2gFileUrl?: string): Promise<void>;
+        /**
+         * Places an item with geometric definition under a specified already existing item.
+         * @param itemId Unique ID of the item.
+         * @param parentId Unique ID of the item's parent.
+         * @param itemName Name of the item.
+         * @param stlFileUrl Public download URL for STL file.
+         * @param t2gFileUrl Public download URL for T2G file.
+         */
+        addToDocumentUnder(itemId: number, parentId: number, itemName: string, stlFileUrl: string, t2gFileUrl?: string): Promise<void>;
+        /**
+         * Generates a unique id in the viewer
+         */
+        createUID(): number;
+        /**
+         * Inserts an HTML element inside the canvas.
+         */
+        addHtmlElementToCanvas(htmlElement: HTMLElement, posX: number, posY: number, posZ: number): void;
+        /**
+         * Assigns event handler to when a specific item is selected.
+         * @param itemVID Unique VID of the item
+         * @param onClickFunction Function we want to run if we click/select the tree item
+         */
+        addOnClickItemEvent(itemUID: number, onClickFunction: Function): void;
+        /**
+         * Removes an item from the tree view based on its ID.
+         * @param itemUID Unique identifier of tree item
+         */
+        removeFile(itemUID: number): void;
+        /**
+         * Removes a thread under the collaboration container.
+         * @param threadId
+         */
+        removeThread(threadId: number): void;
+        /**
+         * Places an (empty) file under the parent element
+         * Meg nem írtam meg az 'assign item to file' fuggvenyt. Igy a file nem ures, hanem automatikusan beleteszi a component-et
+         * @param itemName
+         * @param parentVID
+         */
+        addFile(itemName: string, parentId: number, itemType: string): void;
+        /**
+         * Places an empty folder under the parent element
+         * @param itemName
+         * @param parentVID
+         */
+        addFolder(itemName: string, parentUID: number, folderUID?: number): void;
+        /**
+         * Places an empty container at top-level in the model tree
+         * @param itemName
+         */
+        addContainer(itemName: string): number;
+        /**
+         * Creates a thread to pushpin association in the tree view.
+         * @param itemName
+         * @param parentId
+         * @param itemVID
+         * @returns The unique ID of the thread.
+         */
+        addThread(itemName: string, parentId: number, itemVID: number): number;
+        /**
+         * Method for forwarding commands with args.
+         * @param service
+         */
+        forwardCommandForService(service: BackendService, commandName: string, commandArgs: any): Promise<void>;
+        /**
+         * Method for forwarding commands with args.
+         * @param service
+         */
+        forwardCommandForServiceBlob(service: BackendService, commandName: string, commandFile: File, commandArgs: any): Promise<void>;
+        /**
+         * A custom application that requires a specific backend implementation.
+         * @param backendService
+         */
+        registerApplication(backendService: BackendService): Promise<void>;
+        /**
+         * Use this method to startup the viewer. If no backend service is registered.
+         */
+        startViewer(): Promise<void>;
+        /**
+         * Call this method to disconnect channels of the viewer to ALL services.
+         * The viewer itself will continue to display the 3D data if the user decides
+         * to keep it visible.
+         */
+        stopViewer(): boolean;
+        /**
+         * Assign method binding to canvas interaction events.
+         * @param listenerType Specify what listener type of event we want to add.
+         * @param method Assignable method on the event
+         */
+        addEventListener(listenerType: string, method: Function): void;
+        /**
+         * A temporary objects group serves to store temporary object that
+         * do not live persistently inside the document. This means whenever,
+         * we reopen the model's document, these objects do not persist.
+         * @returns
+         */
+        createTemporaryObjectsGroup(): TemporaryEntities.TemporaryGroup;
+        /**
+          * Get all selected items
+          * Ha nyomjuk a shif-et, a .selected benne marad a tree-ben es kijelolve marad a segment.
+         */
+        getCurrentlySelectedItems(): NodeListOf<Element>;
+        /**
+         * Private implementation of selection highlight color overried.
+         * @param color
+         */
+        private _setSelectionColor;
+        /**
+         * Sets selection.
+         * @param itemUUIDs All item UUIDs
+         */
+        setSelection(itemUUIDs: number[]): void;
+        /**
+         * Rerenders the scene.
+         */
+        refreshViewer(): void;
+        /**
+         * @returns SceneWrapper that contains the complete scene.
+         */
+        getSceneWrapper(): SceneWrapper;
+        /**
+         * Adjust camera distance from all visible objects.
+         */
+        adaptCameraZ(): void;
+        /**
+         * Fits the viewer boundaries to all visible content.
+         */
+        fitToContent(): void;
+        /**
+         * Takes a screenshot of the currently setup view. Removes background image
+         * and returns the URL string of the created PNG image.
+         */
+        takeScreenshot(): Promise<string>;
+        /**
+         * Aligns camera to focus on a point.
+         * @param cameraOperationInput [x, y, z]
+         */
+        alignViewToPoint(cameraOperationInput: CameraOperationInput): void;
+        /**
+         * Loads a model file to the viewer. Currently STEP and CBF files are supported.
+         * @param modelFile: Model file
+         * @param quietly: If set to true, then no progress dialog will appear
+         * @param callbackFn: When the model file loads this method gets called
+         */
+        loadModelFile(modelFile: File, quietly?: boolean, callbackFn?: Function): boolean;
+        /**
+         * The currently active Document with all its entities will be erased.
+         */
+        clearDocument(force?: boolean): void;
+        /**
+         * Disconnects viewer from all backend services. If the viewer is kept open the user may
+         * continue reviewing the 3D model without any API costs, however, computational
+         * functionalities will be disabled.
+         */
+        disconnectViewer(): void;
+        /**
+         * Removes currently active selection.
+         */
+        removeActiveSelection(): void;
+        /**
+         * Toggles the visibility for the existing entity.
+         * @param topVisibility Visibility option for different topological entities.
+         */
+        toggleTopologicalVisibility(topVisibility: VisibilitySettings.TopologyVisibility): void;
+        /**
+         * Returns my current camera's position and all required information
+         * that are required to restore the same view.
+         */
+        getMyCameraPosition(): CameraSettings.Camera;
+        /**
+         * Adjusts the current camera position to the passed in position.
+         */
+        setMyCameraPosition(cameraPosition: CameraSettings.Camera): boolean;
+        /**
+         * Allows to control whether the user can
+         * @param enable If true, the user is allowed to select from the viewer, else selection is locked.
+         */
+        enableSelection(enable: boolean): void;
+        /**
+         * By setting a selection filter, we can restrict the user to only select
+         * entities that are
+         * @param filter Filter that contains the logic for selection.
+         */
+        setSelectionFilter(filter?: AbstractEntities.SelectionFilter): void;
+        /**
+         * Sets the callback function to be called when selection occurs.
+         * @param {function} onSelectionEvent - The function to be called on selection.
+         * @param {Array} onSelectionEvent.entities - The selected entities.
+         * @returns {void}
+         */
+        setOnSelectionEvent(onSelectionEvent: () => any): void;
+        /**
+         * Makes all existing objects visible in the 3D space.
+         */
+        showAll(): void;
+        /**
+         * Hides all existing objects that live in the 3D space.
+         */
+        hideAll(): void;
+        /**
+         * Toggles ON visibility for the item identified by its UUID.
+         * @param itemUUID UUIDs of items we want to show
+         */
+        showItems(itemUUIDs: number[]): void;
+        /**
+         * Toggles OFF visibility for the item identified by its UUID.
+         * @param itemUUIDs UUIDs of items we want to hide
+         */
+        hideItems(itemUUIDs: number[]): void;
+        /**
+         * Shows only selected items
+         */
+        showOnlySelectedItems(): void;
+        /**
+         * Makes a component visible based on its ID.
+         * @param componentID unique identifier of object in tree
+         */
+        showComponent(componentID: string): void;
+        /**
+         * Adds an AnnotationElement to the scene
+         * @param annotation Annotation element
+         * @param temoraryGroup Temporary group that will store the annotation
+         */
+        addAnnotation(annotation: AnnotationEntities.AnnotationElement, temoraryGroup: TemporaryEntities.TemporaryGroup): void;
+        /**
+         * Functions required for manipulating the model tree
+         */
+        getTreeCore(): ContainerEntities.ModelTreeStructure;
+        /**
+         * The returned JSON contains detailed hierarchical informations
+         * how the model is setup.
+         * @returns Objects listed in tree.
+         */
+        getModelTreeStructure(): any;
+        /**
+         * Getter for all geometric object definitions that were added to the model.
+         * @returns ALL geometric object definitions
+         */
+        getComponents(): {};
+        /**
+         * Kiszamolja a modell komponenseit alkoto face-ek midPointjait
+         * @returns List of unique face IDs.
+         */
+        getFaceUIDs(): any[];
+        /**
+         * Beszinezi a face-eket
+         */
+        setFaceColor(color: any[], faceUIDs: any[]): void;
+        /**
+         * Sets the transparency of an object available in the model tree.
+         * @param itemUUID Unique identifier.
+         * @param transparency Value defined between 0 and 1, where 1 means hidden completely.
+         */
+        setTransparency(itemUUID: number, transparency: number): void;
+        /**
+         * Sets the visible geometry color to a defined RGB color code.
+         * @param itemUUID Unique item identifier
+         * @param red Red component, between 0 and 255
+         * @param green Green component, between 0 and 255
+         * @param blue Blue component, between 0 and 255
+         */
+        setColor(itemUUID: number, red: number, green: number, blue: number): void;
+        /**
+         * Returns the VID number for the given UUID. VID numbers are important
+         * for the browser application only and are required for input selection
+         * in the background logic. Users and the backend, however, both only operate
+         * within the scope of UUIDs.
+         * @param uuid Unique identifier as assigned by the document.
+         */
+        private _getViewerIdFromDocId;
+        /**
+         * Method that is called when a different
+         */
+        private _onModifiedSelectionFilter;
+    }
+    /**
+     * This interface serves to enforce the format of creating a frontend checkpoints
+     * that requires the backend server.
+     */
+    abstract class BackendService {
+        /**
+         * Viewer instance associated with backend service.
+         */
+        viewerInstance: CloudViewer.Generic3DViewer;
+        /**
+         * Viewer instance setter
+         * @param viewerInstance Viewer instance we want our frontend app to attach to
+         */
+        setViewerInstance(viewerInstance: CloudViewer.Generic3DViewer): void;
+        /**
+         * Forward the command to the backend service.
+         * @param commandName
+         * @param args Custom arguments the backend service expects
+         */
+        protected forwardCommand(commandName: string, args: any): void;
+        /**
+         * Forward the command to the backend service with input file.
+         * @param commandName
+         * @param blob
+         * @param args
+         */
+        protected forwardCommandWithBlob(commandName: string, blob: File, args: any): void;
+        /**
+         * Returns array of functions that are called
+         * when backend service finishes.
+         */
+        abstract getOnFinishedEvents(): {
+            [key: string]: Function;
+        };
+        /**
+         * Getter for plugin GUID.
+         * The plugin Guid represents the entry point file's name.
+         * For example, if plugin guid is '1234-5678', then on the backend
+         * server a local copy of '1234-5678' folder will be created with a
+         * 1234-5678.py entry point file.
+         */
+        abstract getServiceGuid(): string;
+        /**
+         * Getter for plugin name.
+         * Based on the `getServiceGuid` example above, the entry point file that has
+         * the 'BackendService' is located. Inside this file the `BackendService's`
+         * implementation class has this name.
+         */
+        abstract getServiceClassName(): string;
+    }
+}

package/fcs-core-viewer@types/CloudViewer/Index.d.ts

@@ -0,0 +1 @@
+export * from './FcsViewer';