Allow buffer geometry to be created from a ref

vidartf · vidartf · commit 0c05a9167240 · 2017-08-07T13:07:56.000+02:00
diff --git a/examples/BufferAttributes and BufferGeometry.ipynb b/examples/BufferAttributes and BufferGeometry.ipynb
@@ -19,7 +19,6 @@
    "source": [
     "#\n",
     "# BufferAttribute\n",
-    "# TODO: INCOMPLETE\n",
     "#"
    ]
   },
@@ -158,6 +157,62 @@
     "print(repr(geometry))"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# PlainBufferGeometry.from_geometry\n",
+    "#"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sphere = SphereBufferGeometry(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(repr(sphere))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plain = PlainBufferGeometry.from_geometry(sphere)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plain.attributes"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/js/scripts/prop-types.js b/js/scripts/prop-types.js
@@ -264,7 +264,7 @@ _.extend(ArrayType.prototype, BaseType.prototype, {
 function ArrayBufferType(arrayType, shape_constraint) {
     this.arrayType = arrayType;
     this.shape_constraint = shape_constraint;
-    this.defaultValue = [];
+    this.defaultValue = null;
 }
 _.extend(ArrayBufferType.prototype, BaseType.prototype, {
     getTraitlet: function() {
diff --git a/js/scripts/three-class-config.js b/js/scripts/three-class-config.js
@@ -274,7 +274,7 @@ module.exports = {
             MaxIndex:   new Types.Int(65535),
             //groups:     new Types.GeometryGroup(),
             //drawRange:  new Types.DrawRange(),
-            _ref_geometry: new Types.ThreeType('Geometry', {allowNull: false}),
+            _ref_geometry: new Types.ThreeType(['Geometry', 'BufferGeometry'], {allowNull: false}),
         },
     },
     InstancedBufferAttribute: {
diff --git a/js/src/core/BufferAttribute.js b/js/src/core/BufferAttribute.js
@@ -1,5 +1,6 @@
 var _ = require('underscore');
 var datawidgets = require('jupyter-datawidgets');
+var ndarray = require('ndarray');
 var BufferAttributeAutogen = require('./BufferAttribute.autogen').BufferAttributeModel;
 
 var BufferAttributeModel = BufferAttributeAutogen.extend({
@@ -48,7 +49,11 @@ var BufferAttributeModel = BufferAttributeAutogen.extend({
     mapBufferAttributeArrayThreeToModel: function() {
         var attributeData = this.obj.array;
         var modelNDArray = this.get('array');
-        modelNDArray.data.set(attributeData);
+        if (modelNDArray) {
+            modelNDArray.data.set(attributeData);
+        } else {
+            this.set('array', ndarray(attributeData, [this.obj.count, this.obj.itemSize]));
+        }
     },
 
 }, {
diff --git a/js/src/geometries/PlainBufferGeometry.js b/js/src/geometries/PlainBufferGeometry.js
@@ -1,6 +1,12 @@
 var _ = require('underscore');
+var createModel = require('../_base/utils').createModel;
+
 var AutogenPlainBufferGeometryModel = require('../geometries/PlainBufferGeometry.autogen').PlainBufferGeometryModel;
 
+var core = require('../core')
+var BufferGeometryModel = core.BufferGeometryModel;
+var BufferAttributeModel = core.BufferAttributeModel;
+
 
 var PlainBufferGeometryModel = AutogenPlainBufferGeometryModel.extend({
 
@@ -9,34 +15,80 @@ var PlainBufferGeometryModel = AutogenPlainBufferGeometryModel.extend({
         this.property_assigners['attributes'] = 'assignAttributesMap';
     },
 
-    constructThreeObject: function() {
-
+    constructFromRef: function(ref) {
         var result = new THREE.BufferGeometry();
-
-        var ref = this.get('_ref_geometry');
-        if (ref) {
-            return ref.initPromise.bind(this).then(function() {
+        // Copy ref. This will create new buffers!
+        result.copy(ref.obj);
+
+        var chain = ref.initPromise.bind(this);
+        var toSet = {};
+        if (ref instanceof PlainBufferGeometryModel) {
+            // TODO: Review this!
+            chain = chain.then(
+                // Wait for all attributes
+                Promise.all(_.map(_.values(ref.get('attributes')), attr => {
+                    return attr.initPromise;
+                }))
+            ).then(
+                // Wait for all morphAttributes
+                Promise.all(_.map(_.values(ref.get('morphAttributes')), attr => {
+                    return attr.initPromise;
+                }))
+            ).then(() => {
+                // Copy ref. This will create new buffers!
+                result.copy(ref.obj);
+            });
+        } else if (ref instanceof BufferGeometryModel) {
+            // We have a ref that is some other kind of buffergeometry
+            // This ref will then not have 'attributes' as models
+            // We need to:
+            // - Create models for each bufferattribute
+            // - Set attribute dicts on model
+            // Create models for all attributes:
+            chain = chain.then(function() {
+                // Copy ref. This will create new buffers!
                 result.copy(ref.obj);
 
-                // A bit of a hack:
-                // Sync out all copied properties before restoring
-                this.obj = result;
-                var old_three = this.props_created_by_three;
-                this.props_created_by_three = {};
-                [
-                    'name', 'attributes', 'morphAttributes',
-                    'boundingBox', 'boundingSphere'
-                ].forEach(key => {
-                    this.props_created_by_three[key] = true;
+                return Promise.all(_.map(_.pairs(result.attributes), kv => {
+                    return createModel(BufferAttributeModel, this.widget_manager, kv[1]).then(model => {
+                        return [kv[0], model];
+                    });
+                }));
+            }).then((attribModelKVs) => {
+                toSet.attributes = _.object(attribModelKVs);
+
+            // Then create models for all morphAttributes:
+            }).then(Promise.all(_.map(_.pairs(result.morphAttributes), kv => {
+                return createModel(BufferAttributeModel, this.widget_manager, kv[1]).then(model => {
+                    return [kv[0], model];
                 });
-                this.syncToModel();
-                this.props_created_by_three = old_three;
-                return result;
+            }))).then((attribModelKVs) => {
+                toSet.morphAttributes = _.object(attribModelKVs);
             });
+        } else {
+            // Assume ref is GeometryModel
+            throw new Error('Geometry -> PlainBufferGeometry not yet supported!');
         }
 
-        return Promise.resolve(result);
+        return chain.then(function() {
+
+            // Sync out all copied properties not yet dealt with
+            toSet.name = result.name;
+            this.set(toSet, 'pushFromThree');
+            this.save_changes();
 
+            return result;
+        });
+    },
+
+    constructThreeObject: function() {
+        var ref = this.get('_ref_geometry');
+        if (ref) {
+            return this.constructFromRef(ref);
+        }
+
+        var result = new THREE.BufferGeometry();
+        return Promise.resolve(result);
     },
 
     assignAttributesMap: function(obj, key, value) {
@@ -56,14 +108,10 @@ var PlainBufferGeometryModel = AutogenPlainBufferGeometryModel.extend({
             obj.addAttribute(key, value[key]);
         });
 
-        var current;
-        common.forEach(key => {
-            current = obj.getAttribute(key);
-            if (current !== value[key]) {
-                console.warn('Cannot reassign buffer geometry attribute:', key);
-                return;  // continue
-            }
-        });
+        var commonChanged = _.filter(common, key => { return obj.getAttribute(key) !== value[key]});
+        if (commonChanged.length > 0) {
+            console.warn('Cannot reassign buffer geometry attribute:', commonChanged);
+        }
 
     },
 
diff --git a/js/src/textures/DataTexture.js b/js/src/textures/DataTexture.js
@@ -65,9 +65,13 @@ var DataTextureModel = DataTextureBase.extend({
     },
 
     mapDataTextureDataThreeToModel: function() {
-        var textureData = this.obj.image.data;
+        var imageRecord = this.obj.image;
         var modelNDArray = this.get('data');
-        modelNDArray.data.set(textureData);
+        if (modelNDArray) {
+            modelNDArray.data.set(imageRecord.data);
+        } else {
+            this.set('data', ndarray(imageRecord.data, [imageRecord.width, imageRecord.height]));
+        }
     },
 
 }, {
diff --git a/pythreejs/core/BufferAttribute.py b/pythreejs/core/BufferAttribute.py
@@ -1,21 +1,30 @@
 import numpy as np
 from ipywidgets import register
-from traitlets import validate, TraitError
+from traitlets import validate, TraitError, Undefined
+from ipydatawidgets import NDArray, array_serialization, NDArrayWidget
 
 from .BufferAttribute_autogen import BufferAttribute as BaseBufferAttribute
 
 
 @register
 class BufferAttribute(BaseBufferAttribute):
 
+    def __init__(self, array=None, normalized=True, **kwargs):
+        if array is not None:
+            # If not supplied, leave as undefined.
+            # This is needed for remote initialization
+            kwargs['array'] = array
+        kwargs['normalized'] = normalized
+        super(BaseBufferAttribute, self).__init__(**kwargs)
+
     @validate('array')
     def _valid_array(self, proposal):
         # Validate shape
         if np.ndim(proposal) > 2:
             raise TraitError('Array needs to have at most two dimensions. Given shape was: %r'
                 % np.shape(proposal))
         value = proposal['value']
-        if value.dtype == np.float64:
+        if value is not Undefined and value.dtype == np.float64:
             # 64-bit not supported, coerce to 32-bit
             value = value.astype(np.float32)
         return value

Original file line number	Diff line number	Diff line change
`@@ -264,7 +264,7 @@ _.extend(ArrayType.prototype, BaseType.prototype, {`
`264`	`264`	`function ArrayBufferType(arrayType, shape_constraint) {`
`265`	`265`	`this.arrayType = arrayType;`
`266`	`266`	`this.shape_constraint = shape_constraint;`
`267`		`- this.defaultValue = [];`
	`267`	`+ this.defaultValue = null;`
`268`	`268`	`}`
`269`	`269`	`_.extend(ArrayBufferType.prototype, BaseType.prototype, {`
`270`	`270`	`getTraitlet: function() {`