Support for opening STL files (#246)

* STL support

* Draft

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Update opencascade build

* Update ydoc

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Duc Trung Le <[email protected]>

Author: 3 people

.prettierignore

@@ -7,3 +7,4 @@ jupytercad
 packages/opencascade/build.yml
 yarn.lock
 *.jcad
+playwright.config.js

package.json

@@ -39,8 +39,8 @@
     "clean:all": "lerna run clean:all",
     "eslint": "eslint . --ext .ts,.tsx --cache --fix",
     "eslint:check": "eslint . --ext .ts,.tsx",
-    "prettier": "prettier --write \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
-    "prettier:check": "prettier --list-different \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
+    "prettier": "prettier --write \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md,.yml}\"",
+    "prettier:check": "prettier --list-different \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md,.yml}\"",
     "lint:check": "jlpm run prettier:check && jlpm run eslint:check",
     "lint": "jlpm run prettier && jlpm run eslint",
     "test": "lerna run test",

packages/occ-worker/src/occapi/loadObjectFile.ts

@@ -3,6 +3,7 @@ import { IAny } from '@jupytercad/schema';
 
 import { _loadBrepFile } from './brepIO';
 import { _loadStepFile } from './stepIO';
+import { _loadStlFile } from './stlIO';
 
 export function _loadObjectFile(arg: {
   content: string;
@@ -13,6 +14,8 @@ export function _loadObjectFile(arg: {
       return _loadBrepFile(arg.content);
     case 'step':
       return _loadStepFile(arg.content);
+    case 'stl':
+      return _loadStlFile(arg.content);
     default:
       throw `${arg.type} file not supported`;
   }

packages/schema/src/model.ts

@@ -575,6 +575,74 @@ export class JupyterCadStepDoc extends JupyterCadDoc {
   );
 }
 
+export class JupyterCadStlDoc extends JupyterCadDoc {
+  constructor() {
+    super();
+
+    this._source = this.ydoc.getText('source');
+
+    this._source.observeDeep(this._sourceObserver);
+  }
+
+  get version(): string {
+    return '0.1.0';
+  }
+
+  get objectsChanged(): ISignal<IJupyterCadDoc, IJcadObjectDocChange> {
+    return this._objectChanged;
+  }
+
+  get objects(): Array<IJCadObject> {
+    const source = this._source.toJSON();
+
+    if (!source) {
+      return [];
+    }
+
+    return [
+      {
+        name: 'Stl File', // TODO get file name?
+        visible: true,
+        shape: 'Part::Any',
+        parameters: {
+          Content: this._source.toJSON(),
+          Type: 'STL'
+        }
+      }
+    ];
+  }
+
+  static create(): JupyterCadStlDoc {
+    return new JupyterCadStlDoc();
+  }
+
+  editable = false;
+
+  private _sourceObserver = (events: Y.YEvent<any>[]): void => {
+    const changes: Array<{
+      name: string;
+      key: keyof IJCadObject;
+      newValue: IJCadObject;
+    }> = [];
+    events.forEach(event => {
+      event.keys.forEach((change, key) => {
+        changes.push({
+          name: 'Stl File',
+          key: key as any,
+          newValue: JSONExt.deepCopy(event.target.toJSON())
+        });
+      });
+    });
+    this._objectChanged.emit({ objectChange: changes });
+    this._changed.emit({ objectChange: changes });
+  };
+
+  private _source: Y.Text;
+  private _objectChanged = new Signal<IJupyterCadDoc, IJcadObjectDocChange>(
+    this
+  );
+}
+
 export namespace JupyterCadModel {
   export interface IOptions
     extends DocumentRegistry.IModelOptions<IJupyterCadDoc> {

packages/schema/src/schema/any.json

@@ -11,7 +11,7 @@
     },
     "Type": {
       "type": "string",
-      "enum": ["brep", "step"]
+      "enum": ["brep", "step", "stl"]
     },
     "Placement": {
       "$ref": "./placement.json"

python/jupytercad_core/jupytercad_core/stl_ydoc.py

@@ -0,0 +1,37 @@
+import json
+from typing import Any, Callable
+from functools import partial
+
+from pycrdt import Text
+from jupyter_ydoc.ybasedoc import YBaseDoc
+
+
+class YSTL(YBaseDoc):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._ydoc["source"] = self._ysource = Text()
+
+    def version(self) -> str:
+        return "0.1.0"
+
+    def get(self) -> str:
+        """
+        Returns the content of the document.
+        :return: Document's content.
+        :rtype: Any
+        """
+        return json.dumps(self._ysource.to_py())
+
+    def set(self, value: str) -> None:
+        """
+        Sets the content of the document.
+        :param value: The content of the document.
+        :type value: Any
+        """
+        self._ysource[:] = value
+
+    def observe(self, callback: Callable[[str, Any], None]):
+        self.unobserve()
+        self._subscriptions[self._ysource] = self._ysource.observe(
+            partial(callback, "source")
+        )

python/jupytercad_core/pyproject.toml

@@ -32,6 +32,7 @@ requires-python = ">=3.8"
 [project.entry-points.jupyter_ydoc]
 jcad = "jupytercad_core.jcad_ydoc:YJCad"
 step = "jupytercad_core.step_ydoc:YSTEP"
+stl = "jupytercad_core.stl_ydoc:YSTL"
 
 [tool.hatch.version]
 source = "nodejs"

python/jupytercad_core/src/index.ts

@@ -1,5 +1,6 @@
 import jcadPlugin from './jcadplugin/plugins';
 import stepPlugin from './stepplugin/plugins';
+import stlPlugin from './stlplugin/plugins';
 import {
   annotationPlugin,
   externalCommandRegistryPlugin,
@@ -16,6 +17,7 @@ export default [
   workerRegistryPlugin,
   jcadPlugin,
   stepPlugin,
+  stlPlugin,
   formSchemaRegistryPlugin,
   externalCommandRegistryPlugin
 ];

python/jupytercad_core/src/stlplugin/modelfactory.ts

@@ -0,0 +1,85 @@
+import { IJupyterCadDoc, JupyterCadModel } from '@jupytercad/schema';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { Contents } from '@jupyterlab/services';
+
+/**
+ * A Model factory to create new instances of JupyterCadModel.
+ */
+export class JupyterCadStlModelFactory
+  implements DocumentRegistry.IModelFactory<JupyterCadModel>
+{
+  /**
+   * Whether the model is collaborative or not.
+   */
+  readonly collaborative = true;
+
+  /**
+   * The name of the model.
+   *
+   * @returns The name
+   */
+  get name(): string {
+    return 'jupytercad-stlmodel';
+  }
+
+  /**
+   * The content type of the file.
+   *
+   * @returns The content type
+   */
+  get contentType(): Contents.ContentType {
+    return 'stl';
+  }
+
+  /**
+   * The format of the file.
+   *
+   * @returns the file format
+   */
+  get fileFormat(): Contents.FileFormat {
+    return 'text';
+  }
+
+  /**
+   * Get whether the model factory has been disposed.
+   *
+   * @returns disposed status
+   */
+  get isDisposed(): boolean {
+    return this._disposed;
+  }
+
+  /**
+   * Dispose the model factory.
+   */
+  dispose(): void {
+    this._disposed = true;
+  }
+
+  /**
+   * Get the preferred language given the path on the file.
+   *
+   * @param path path of the file represented by this document model
+   * @returns The preferred language
+   */
+  preferredLanguage(path: string): string {
+    return '';
+  }
+
+  /**
+   * Create a new instance of JupyterCadModel.
+   *
+   * @returns The model
+   */
+  createNew(
+    options: DocumentRegistry.IModelOptions<IJupyterCadDoc>
+  ): JupyterCadModel {
+    const model = new JupyterCadModel({
+      sharedModel: options.sharedModel,
+      languagePreference: options.languagePreference
+    });
+    return model;
+  }
+
+  private _disposed = false;
+}

python/jupytercad_core/src/stlplugin/plugins.ts

@@ -0,0 +1,93 @@
+import {
+  ICollaborativeDrive,
+  SharedDocumentFactory
+} from '@jupyter/docprovider';
+import {
+  IJCadWorkerRegistry,
+  IJCadWorkerRegistryToken,
+  IJupyterCadDocTracker,
+  IJupyterCadWidget,
+  JupyterCadStlDoc,
+  IJCadExternalCommandRegistry,
+  IJCadExternalCommandRegistryToken
+} from '@jupytercad/schema';
+import {
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+import { IThemeManager, WidgetTracker } from '@jupyterlab/apputils';
+
+import { JupyterCadStlModelFactory } from './modelfactory';
+import { JupyterCadWidgetFactory } from '../factory';
+
+const FACTORY = 'JupyterCAD STL Viewer';
+
+const activate = (
+  app: JupyterFrontEnd,
+  tracker: WidgetTracker<IJupyterCadWidget>,
+  themeManager: IThemeManager,
+  drive: ICollaborativeDrive,
+  workerRegistry: IJCadWorkerRegistry,
+  externalCommandRegistry: IJCadExternalCommandRegistry
+): void => {
+  const widgetFactory = new JupyterCadWidgetFactory({
+    name: FACTORY,
+    modelName: 'jupytercad-stlmodel',
+    fileTypes: ['stl'],
+    defaultFor: ['stl'],
+    tracker,
+    commands: app.commands,
+    workerRegistry,
+    externalCommandRegistry
+  });
+  // Registering the widget factory
+  app.docRegistry.addWidgetFactory(widgetFactory);
+
+  // Creating and registering the model factory for our custom DocumentModel
+  const modelFactory = new JupyterCadStlModelFactory();
+  app.docRegistry.addModelFactory(modelFactory);
+  // register the filetype
+  app.docRegistry.addFileType({
+    name: 'stl',
+    displayName: 'STL',
+    mimeTypes: ['text/json'],
+    extensions: ['.stl', '.STL'],
+    fileFormat: 'text',
+    contentType: 'stl'
+  });
+
+  const stlSharedModelFactory: SharedDocumentFactory = () => {
+    return new JupyterCadStlDoc();
+  };
+  drive.sharedModelFactory.registerDocumentFactory(
+    'stl',
+    stlSharedModelFactory
+  );
+
+  widgetFactory.widgetCreated.connect((sender, widget) => {
+    widget.context.pathChanged.connect(() => {
+      tracker.save(widget);
+    });
+    themeManager.themeChanged.connect((_, changes) =>
+      widget.context.model.themeChanged.emit(changes)
+    );
+    tracker.add(widget);
+    app.shell.activateById('jupytercad::leftControlPanel');
+    app.shell.activateById('jupytercad::rightControlPanel');
+  });
+};
+
+const stlPlugin: JupyterFrontEndPlugin<void> = {
+  id: 'jupytercad:stlplugin',
+  requires: [
+    IJupyterCadDocTracker,
+    IThemeManager,
+    ICollaborativeDrive,
+    IJCadWorkerRegistryToken,
+    IJCadExternalCommandRegistryToken
+  ],
+  autoStart: true,
+  activate
+};
+
+export default stlPlugin;