Implement importBrep and vtkPolyData export (#735)

* Implement importBrep

* Implement rw to/from stream

* Implement toVtkPolyData

* Implemented VTP export

* Added normals calculation

* use VTK for rendering in jupyter

* Added orientation marker

* Assy rendering in notebooks

* Implement export to vtkjs

* Store the env in the cqgi result

* VTK-based cq directive

* Support show_object and assy

* assy vrml export via vtk

* Use vtk in the docs

* Add slot dxf file

* Add vtk.js to the static files

* Use single renderer

* Ignore cq_directive code coverage

* Ignore missing docutils stubs

* Implement select

* Disable interaction dynamically

* Mention VTP in the docs

* Add path to the test reqs

Author: adam-urbanczyk

.coveragerc

@@ -1,6 +1,8 @@
 [run]
 branch = True
-omit = cadquery/utils.py
+omit = 
+    cadquery/utils.py
+    cadquery/cq_directive.py
 
 [report]
 exclude_lines =

build-docs.sh

@@ -1,2 +1,2 @@
 #!/bin/sh
-sphinx-build -b html doc target/docs
+(cd doc && sphinx-build -b html . ../target/docs)

cadquery/assembly.py

@@ -519,3 +519,12 @@ def toCompound(self) -> Compound:
         shapes.extend((child.toCompound() for child in self.children))
 
         return Compound.makeCompound(shapes).locate(self.loc)
+
+    def _repr_javascript_(self):
+        """
+        Jupyter 3D representation support
+        """
+
+        from .occ_impl.jupyter_tools import display
+
+        return display(self)._repr_javascript_()

cadquery/cq.py

@@ -4024,15 +4024,17 @@ def offset2D(
 
         return self.newObject(rv)
 
-    def _repr_html_(self) -> Any:
+    def _repr_javascript_(self) -> Any:
         """
         Special method for rendering current object in a jupyter notebook
         """
 
         if type(self.val()) is Vector:
             return "&lt {} &gt".format(self.__repr__()[1:-1])
         else:
-            return Compound.makeCompound(_selectShapes(self.objects))._repr_html_()
+            return Compound.makeCompound(
+                _selectShapes(self.objects)
+            )._repr_javascript_()
 
 
 # alias for backward compatibility

cadquery/cq_directive.py

@@ -4,8 +4,19 @@
 """
 
 import traceback
-from cadquery import exporters
+
+from pathlib import Path
+from uuid import uuid1 as uuid
+from textwrap import indent
+
+from cadquery import exporters, Assembly, Compound, Color
 from cadquery import cqgi
+from cadquery.occ_impl.jupyter_tools import (
+    toJSON,
+    dumps,
+    TEMPLATE_RENDER,
+    DEFAULT_COLOR,
+)
 from docutils.parsers.rst import directives, Directive
 
 template = """
@@ -21,6 +32,181 @@
 """
 template_content_indent = "      "
 
+rendering_code = """
+const RENDERERS = {};
+var ID =  0;
+
+const renderWindow = vtk.Rendering.Core.vtkRenderWindow.newInstance();
+const openglRenderWindow = vtk.Rendering.OpenGL.vtkRenderWindow.newInstance();
+renderWindow.addView(openglRenderWindow);
+
+const rootContainer = document.createElement('div');
+rootContainer.style.position = 'fixed';
+//rootContainer.style.zIndex = -1;
+rootContainer.style.left = 0;
+rootContainer.style.top = 0;
+rootContainer.style.pointerEvents = 'none';
+rootContainer.style.width = '100%';
+rootContainer.style.height = '100%';
+
+openglRenderWindow.setContainer(rootContainer);
+
+const interact_style = vtk.Interaction.Style.vtkInteractorStyleManipulator.newInstance();
+
+const manips = {
+    rot: vtk.Interaction.Manipulators.vtkMouseCameraTrackballRotateManipulator.newInstance(),
+    pan: vtk.Interaction.Manipulators.vtkMouseCameraTrackballPanManipulator.newInstance(),
+    zoom1: vtk.Interaction.Manipulators.vtkMouseCameraTrackballZoomManipulator.newInstance(),
+    zoom2: vtk.Interaction.Manipulators.vtkMouseCameraTrackballZoomManipulator.newInstance(),
+    roll: vtk.Interaction.Manipulators.vtkMouseCameraTrackballRollManipulator.newInstance(),
+};
+
+manips.zoom1.setControl(true);
+manips.zoom2.setButton(3);
+manips.roll.setShift(true);
+manips.pan.setButton(2);
+
+for (var k in manips){{
+    interact_style.addMouseManipulator(manips[k]);
+}};
+
+const interactor = vtk.Rendering.Core.vtkRenderWindowInteractor.newInstance();
+interactor.setView(openglRenderWindow);
+interactor.initialize();
+interactor.setInteractorStyle(interact_style);
+
+document.addEventListener('DOMContentLoaded', function () {
+    document.body.appendChild(rootContainer);
+    interactor.bindEvents(document.body);
+});
+
+function updateViewPort(element, renderer) {
+  const { innerHeight, innerWidth } = window;
+  const { x, y, width, height } = element.getBoundingClientRect();
+  const viewport = [
+    x / innerWidth,
+    1 - (y + height) / innerHeight,
+    (x + width) / innerWidth,
+    1 - y / innerHeight,
+  ];
+  renderer.setViewport(...viewport);
+}
+
+function recomputeViewports() {
+  const rendererElems = document.querySelectorAll('.renderer');
+  for (let i = 0; i < rendererElems.length; i++) {
+    const elem = rendererElems[i];
+    const { id } = elem;
+    const renderer = RENDERERS[id];
+    updateViewPort(elem, renderer);
+  }
+  renderWindow.render();
+}
+
+function resize() {
+  rootContainer.style.width = `${window.innerWidth}px`;
+  openglRenderWindow.setSize(window.innerWidth, window.innerHeight);
+  recomputeViewports();
+}
+
+window.addEventListener('resize', resize);
+document.addEventListener('scroll', recomputeViewports);
+
+
+function enterCurrentRenderer(e) {
+  interact_style.setEnabled(true);
+  interactor.setCurrentRenderer(RENDERERS[e.target.id]);
+}
+
+function exitCurrentRenderer(e) {
+  interactor.setCurrentRenderer(null);
+  interact_style.setEnabled(false);
+}
+
+
+function applyStyle(element) {
+  element.classList.add('renderer');
+  element.style.width = '100%';
+  element.style.height = '100%';
+  element.style.display = 'inline-block';
+  element.style.boxSizing = 'border';
+  return element;
+}
+
+window.addEventListener('load', resize);
+
+function render(data, parent_element, ratio){
+    
+    // Initial setup
+    const renderer = vtk.Rendering.Core.vtkRenderer.newInstance({ background: [1, 1, 1 ] });
+        
+    // iterate over all children children
+    for (var el of data){
+        var trans = el.position;
+        var rot = el.orientation;
+        var rgba = el.color;
+        var shape = el.shape;
+        
+        // load the inline data
+        var reader = vtk.IO.XML.vtkXMLPolyDataReader.newInstance();
+        const textEncoder = new TextEncoder();
+        reader.parseAsArrayBuffer(textEncoder.encode(shape));
+
+        // setup actor,mapper and add
+        const mapper = vtk.Rendering.Core.vtkMapper.newInstance();
+        mapper.setInputConnection(reader.getOutputPort());
+
+        const actor = vtk.Rendering.Core.vtkActor.newInstance();
+        actor.setMapper(mapper);
+
+        // set color and position
+        actor.getProperty().setColor(rgba.slice(0,3));
+        actor.getProperty().setOpacity(rgba[3]);
+        
+        actor.rotateZ(rot[2]*180/Math.PI);
+        actor.rotateY(rot[1]*180/Math.PI);
+        actor.rotateX(rot[0]*180/Math.PI);
+        
+        actor.setPosition(trans);
+
+        renderer.addActor(actor);
+
+    };
+    
+    //add the container
+    const container = applyStyle(document.createElement("div"));
+    parent_element.appendChild(container);
+    container.addEventListener('mouseenter', enterCurrentRenderer);
+    container.addEventListener('mouseleave', exitCurrentRenderer);
+    container.id = ID;
+    
+    renderWindow.addRenderer(renderer);
+    updateViewPort(container, renderer);
+    renderer.resetCamera();
+    
+    RENDERERS[ID] = renderer;
+    ID++;   
+};
+"""
+
+
+template_vtk = """
+
+.. raw:: html
+
+    <div class="cq-vtk"
+     style="text-align:{txt_align}s;float:left;border: 1px solid #ddd; width:{width}; height:{height}"">
+       <script>
+       var parent_element = {element};
+       var data = {data};
+       render(data, parent_element);
+       </script>
+    </div>
+    <div style="clear:both;">
+    </div>
+
+"""
+
 
 class cq_directive(Directive):
 
@@ -84,9 +270,91 @@ def run(self):
         return []
 
 
+class cq_directive_vtk(Directive):
+
+    has_content = True
+    required_arguments = 0
+    optional_arguments = 2
+    option_spec = {
+        "height": directives.length_or_unitless,
+        "width": directives.length_or_percentage_or_unitless,
+        "align": directives.unchanged,
+        "select": directives.unchanged,
+    }
+
+    def run(self):
+
+        options = self.options
+        content = self.content
+        state_machine = self.state_machine
+        env = self.state.document.settings.env
+        build_path = Path(env.app.builder.outdir)
+        out_path = build_path / "_static"
+
+        # only consider inline snippets
+        plot_code = "\n".join(content)
+
+        # collect the result
+        try:
+            result = cqgi.parse(plot_code).build()
+
+            if result.success:
+                if result.first_result:
+                    shape = result.first_result.shape
+                else:
+                    shape = result.env[options.get("select", "result")]
+
+                if isinstance(shape, Assembly):
+                    assy = shape
+                else:
+                    assy = Assembly(shape, color=Color(*DEFAULT_COLOR))
+            else:
+                raise result.exception
+
+        except Exception:
+            traceback.print_exc()
+            assy = Assembly(Compound.makeText("CQGI error", 10, 5))
+
+        # save vtkjs to static
+        fname = Path(str(uuid()))
+        exporters.assembly.exportVTKJS(assy, out_path / fname)
+        fname = str(fname) + ".zip"
+
+        # add the output
+        lines = []
+
+        data = dumps(toJSON(assy))
+
+        lines.extend(
+            template_vtk.format(
+                code=indent(TEMPLATE_RENDER.format(), "    "),
+                data=data,
+                ratio="null",
+                element="document.currentScript.parentNode",
+                txt_align=options.get("align", "left"),
+                width=options.get("width", "100%"),
+                height=options.get("height", "500px"),
+            ).splitlines()
+        )
+
+        lines.extend(["::", ""])
+        lines.extend(["    %s" % row.rstrip() for row in plot_code.split("\n")])
+        lines.append("")
+
+        if len(lines):
+            state_machine.insert_input(lines, state_machine.input_lines.source(0))
+
+        return []
+
+
 def setup(app):
     setup.app = app
     setup.config = app.config
     setup.confdir = app.confdir
 
     app.add_directive("cq_plot", cq_directive)
+    app.add_directive("cadquery", cq_directive_vtk)
+
+    # add vtk.js
+    app.add_js_file("vtk.js")
+    app.add_js_file(None, body=rendering_code)

cadquery/cqgi.py

@@ -117,12 +117,14 @@ def build(self, build_parameters=None, build_options=None):
             exec(c, env)
             result.set_debug(collector.debugObjects)
             result.set_success_result(collector.outputObjects)
+            result.env = env
 
         except Exception as ex:
             result.set_failure_result(ex)
 
         end = time.perf_counter()
         result.buildTime = end - start
+
         return result
 
     def set_param_values(self, params):
@@ -322,12 +324,14 @@ def __init__(self):
         self.outputObjects = []
         self.debugObjects = []
 
-    def show_object(self, shape, options={}):
+    def show_object(self, shape, options={}, **kwargs):
         """
         return an object to the executing environment, with options
         :param shape: a cadquery object
         :param options: a dictionary of options that will be made available to the executing environment
         """
+        options.update(kwargs)
+
         o = ShapeResult()
         o.options = options
         o.shape = shape