initial (broken) support for binary synchronization of PlainGeometry info.

Author: jasongrout

js/package.json

@@ -20,8 +20,9 @@
     "webpack": "^1.12.14"
   },
   "dependencies": {
-    "jupyter-js-widgets": "^2.1.4",
     "@jupyterlab/nbwidgets": "^0.6.15",
+    "jupyter-js-widgets": "^2.1.4",
+    "ndarray": "^1.0.18",
     "three": "^0.75.0",
     "underscore": "^1.8.3"
   }

js/src/jupyter-threejs.js

@@ -1,4 +1,4 @@
-define(["jupyter-js-widgets", "underscore", "three"],
+define(["jupyter-js-widgets", "underscore", "three", "ndarray"],
        function(widgets, _, THREE) {
 
     window.THREE = THREE;
@@ -588,7 +588,6 @@ define(["jupyter-js-widgets", "underscore", "three"],
         },
     });
 
-    
 
     var PlainGeometryView = ThreeView.extend({
         update: function() {
@@ -1657,18 +1656,79 @@ define(["jupyter-js-widgets", "underscore", "three"],
         })
     });
 
+
+
+    var typesToArray = {
+        int8: Int8Array,
+        int16: Int16Array,
+        int32: Int32Array,
+        int64: Int64Array,
+        uint8: UInt8Array,
+        uint16: UInt16Array,
+        uint32: UInt32Array,
+        uint64: UInt64Array,
+        float32: Float32Array,
+        float64: Float64Array
+    }
+
+    var arrayToTypes = {
+        'Int8Array': 'int8',
+        'Int16Array': 'int16',
+        'Int32Array': 'int32',
+        'Int64Array': 'int64',
+        'UInt8Array': 'uint8',
+        'UInt16Array': 'uint16',
+        'UInt32Array': 'uint32',
+        'UInt64Array': 'uint64',
+        'Float32Array': 'float32',
+        'Float64Array': 'float64'
+    }
+
+    var makearray = function(buffer, dtype) {
+        var types = {
+            int8: Int8Array,
+            int16: Int16Array,
+            int32: Int32Array,
+            int64: Int64Array,
+            uint8: UInt8Array,
+            uint16: UInt16Array,
+            uint32: UInt32Array,
+            uint64: UInt64Array,
+            float32: Float32Array,
+            float64: Float64Array
+        }
+        return types[dtype](buffer);
+    }
+
+    var JSONToArray = function(obj, manager) {
+        // obj is {shape: list, dtype: string, array: buffer}
+        // return an ndarray object
+        return ndarray(typesToArray[obj.dtype](obj.buffer), obj.shape);
+    }
+
+    var arrayToJSON = function(obj, manager) {
+        // serialize to {shape: list, dtype: string, array: buffer}
+        return {shape: obj.shape, dtype: obj.dtype, buffer: obj.data}
+    }
+
     var PlainGeometryModel = GeometryModel.extend({
         defaults: _.extend({}, GeometryModel.prototype.defaults, {
             _model_name: 'PlainGeometryModel',
             _view_name: 'PlainGeometryView',
 
-            vertices: [],
+            vertices: ndarray(new Float32Array(), [0,3]),
             colors: [],
-            faces: [],
-            faceColors: [],
+            faces: ndarray(new UInt64Array(), [0, 3]),
+            faceColors: ndarray(new UInt64(), [0,3,3]),
             faceNormals: []
             // todo: faceVertexUvs
         })
+    }, {
+        serializers: _.extend({
+            vertices:  { deserialize: json_to_array, serialize: array_to_json },
+            faces:  { deserialize: json_to_array, serialize: array_to_json },
+            faceColors:  { deserialize: json_to_array, serialize: array_to_json },
+        }, GeometryModel.serializers)
     });
 
     var SphereGeometryModel = GeometryModel.extend({

pythreejs/pythreejs.py

@@ -17,6 +17,8 @@
                        CFloat, Bool)
 from ._package import npm_pkg_name
 from math import pi, sqrt
+from .traits_numpy import array_serialization, shape_constraints
+from traittypes import Array
 
 def vector3(trait_type=CFloat, default=None, **kwargs):
     if default is None:
@@ -268,11 +270,16 @@ class PlainGeometry(Geometry):
     _view_name = Unicode('PlainGeometryView').tag(sync=True)
     _model_name = Unicode('PlainGeometryModel').tag(sync=True)
 
-    vertices = List(vector3(CFloat)).tag(sync=True)
+    # TODO: vertices: numpy shape (*, 3), dtype float32
+    vertices = Array(dtype='float32').tag(sync=True).valid(shape_constraints(None,3))
+    faces = Array(dtype='uint32').tag(sync=True).valid(shape_constraints(None,3))
+    # list of [[v1_r,v1_g,v1_b], [v2_r,v2_g,v2_b], [v3_r,v3_g,v3_b]] for each face
+    faceColors = Array(dtype='uint8').tag(sync=True).valid(shape_constraints(None,3,3))
+    #vertices = List(vector3(CFloat)).tag(sync=True)
     colors = List(Color).tag(sync=True)
-    faces = List(List(CFloat)).tag(sync=True)
+    #faces = List(List(CFloat)).tag(sync=True)
     # TODO: type this better. Can handle lists of string colors, or lists of lists of string colors.
-    faceColors = Tuple().tag(sync=True)
+    #faceColors = Tuple().tag(sync=True)
     # TODO: type this better. Can handle lists of vector3(CFloat), or lists of lists of vector3(CFloat).
     faceNormals = Tuple().tag(sync=True)
     # todo: faceVertexUvs = List(vector3(vector2(CFloat))).tag(sync=True)

setup.py

@@ -135,7 +135,7 @@ def run(self):
             'pythreejs/staticlab/jupyter-threejs.bundle.js.manifest',
         ]),
     ],
-    'install_requires': ['ipywidgets>=6.0.0'],
+    'install_requires': ['ipywidgets>=6.0.0', 'traittypes'],
     'packages': find_packages(),
     'zip_safe': False,
     'cmdclass': {