Generalize computeBoundingSphere / Box methods

Author: vidartf

js/src/_base/Preview.js

@@ -9,6 +9,7 @@ var Renderable = require('./Renderable');
 var RenderableView = Renderable.RenderableView;
 var RenderableModel = Renderable.RenderableModel;
 var OrbitControls = require("../examples/controls/OrbitControls.js").OrbitControls;
+var utils = require('./utils.js');
 
 
 var BLACK = new THREE.Color('black');
@@ -78,14 +79,6 @@ function lookAtSphere(camera, center, radius) {
 }
 
 // TODO: Make this available as a general utility somewhere?
-function computeSceneBoundingSphere(scene) {
-    // FIXME: The Box3.setFromObject implementation is not great,
-    // replace with something that reuses bounding box computations
-    // of the underlying objects
-    const box = new THREE.Box3();
-    box.setFromObject(scene);
-    return box.getBoundingSphere();
-}
 
 
 var PreviewView = RenderableView.extend({
@@ -208,7 +201,7 @@ var PreviewView = RenderableView.extend({
 
     resetCamera: function() {
         // Compute bounding sphere for entire scene
-        const sphere = computeSceneBoundingSphere(this.scene);
+        const sphere = utils.computeBoundingSphere(this.scene);
 
         // Update camera to include bounding sphere
         lookAtSphere(this.camera, sphere.center, sphere.radius);

js/src/_base/utils.js

@@ -1,7 +1,89 @@
 
 var widgets = require("@jupyter-widgets/base");
+var THREE = require('three');
 
 
+/**
+ * Compute the box bounding all objects in a scene graph.
+ *
+ * Returns a unity box if no relevant objects were found.
+ */
+var computeBoundingBox = function() {
+    var objectBoundingBox = new THREE.Box3();
+
+    return function computeBoundingBox(scene) {
+        var boundingBox = new THREE.Box3();
+        scene.traverseVisible(function (object) {
+            if (object.geometry) {
+                object.geometry.computeBoundingBox();
+                objectBoundingBox.copy(object.geometry.boundingBox);
+                objectBoundingBox.applyMatrix4(object.matrixWorld);
+                boundingBox.union(objectBoundingBox);
+            }
+        });
+        if (boundingBox.isEmpty()) {
+            boundingBox.min.set(-1, -1, -1);
+            boundingBox.max.set(1, 1, 1);
+        }
+        return boundingBox;
+    }
+}();
+
+
+/**
+ * Compute the sphere bounding all objects in a scene graph.
+ *
+ * Note: This is based on the bounding spheres of the individual objects
+ * in the scene, and not the set of all points in the scene, and will
+ * therefore not be optimal.
+ *
+ * Returns a unity sphere if no relevant objects were found.
+ */
+var computeBoundingSphere = function() {
+    var objectBoundingSphere = new THREE.Sphere();
+    var vAB = new THREE.Vector3();
+    var d, rmin, rmax, rA, rB;
+    return function computeBoundingSphere(scene) {
+        // Current bounding sphere:
+        var boundingSphere = null;
+        scene.traverseVisible(function (object) {
+            if (object.geometry) {
+                object.geometry.computeBoundingSphere();
+                if (boundingSphere === null) {
+                    // First sphere found, store it
+                    boundingSphere = object.geometry.boundingSphere.clone();
+                    boundingSphere.applyMatrix4(object.matrixWorld);
+                    return;  // continue traverse
+                }
+                objectBoundingSphere.copy(object.geometry.boundingSphere);
+                objectBoundingSphere.applyMatrix4(object.matrixWorld);
+
+                rA = boundingSphere.radius;
+                rB = objectBoundingSphere.radius;
+                rmin = Math.min(rA, rB);
+                rmax = Math.max(rA, rB);
+
+                vAB.subVectors(objectBoundingSphere.center, boundingSphere.center);
+                d = vAB.length();
+                if (d + rmin < rmax) {
+                    // Smallest sphere contained within largest
+                    if (rB > rA) {
+                        boundingSphere.copy(objectBoundingSphere);
+                    }
+                    return;  // continue traverse
+                }
+
+                // Calculate new bounding-sphere:
+                boundingSphere.radius = 0.5 * (rA + rB + d);
+                boundingSphere.center.addScaledVector(vAB, 0.5 + rB);
+            }
+        });
+        if (boundingSphere === null) {
+            return new THREE.Sphere(new THREE.Vector3(), 1);
+        }
+        return boundingSphere;
+    }
+}();
 
 /**
  * Work around for notebook issue #2730.
@@ -81,4 +163,6 @@ var createModel = function(constructor, widget_manager, obj) {
 
 module.exports = {
     createModel: createModel,
+    computeBoundingSphere: computeBoundingSphere,
+    computeBoundingBox: computeBoundingBox,
 }