cesium 0.13.0

data/app/assets/javascripts/Core/AxisAlignedBoundingBox.js

@@ -0,0 +1,243 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError',
+        './Cartesian3',
+        './Intersect'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        Cartesian3,
+        Intersect) {
+    "use strict";
+
+    /**
+     * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes.
+     * @alias AxisAlignedBoundingBox
+     * @constructor
+     *
+     * @param {Cartesian3} [minimum=Cartesian3.ZERO] The minimum point along the x, y, and z axes.
+     * @param {Cartesian3} [maximum=Cartesian3.ZERO] The maximum point along the x, y, and z axes.
+     * @param {Cartesian3} [center] The center of the box; automatically computed if not supplied.
+     *
+     * @see BoundingSphere
+     */
+    var AxisAlignedBoundingBox = function(minimum, maximum, center) {
+        /**
+         * The minimum point defining the bounding box.
+         * @type {Cartesian3}
+         */
+        this.minimum = Cartesian3.clone(defaultValue(minimum, Cartesian3.ZERO));
+
+        /**
+         * The maximum point defining the bounding box.
+         * @type {Cartesian3}
+         */
+        this.maximum = Cartesian3.clone(defaultValue(maximum, Cartesian3.ZERO));
+
+        //If center was not defined, compute it.
+        if (typeof center === 'undefined') {
+            center = Cartesian3.add(this.minimum, this.maximum);
+            Cartesian3.multiplyByScalar(center, 0.5, center);
+        } else {
+            center = Cartesian3.clone(center);
+        }
+
+        /**
+         * The center point of the bounding box.
+         * @type {Cartesian3}
+         */
+        this.center = center;
+    };
+
+    /**
+     * Computes an instance of an AxisAlignedBoundingBox. The box is determined by
+     * finding the points spaced the farthest apart on the x, y, and z axes.
+     * @memberof AxisAlignedBoundingBox
+     *
+     * @param {Array} positions List of points that the bounding box will enclose.  Each point must have a <code>x</code>, <code>y</code>, and <code>z</code> properties.
+     * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
+     * @return {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if one was not provided.
+     *
+     * @example
+     * // Compute an axis aligned bounding box enclosing two points.
+     * var box = AxisAlignedBoundingBox.fromPoints([new Cartesian3(2, 0, 0), new Cartesian3(-2, 0, 0)]);
+     */
+    AxisAlignedBoundingBox.fromPoints = function(positions, result) {
+        if (typeof result === 'undefined') {
+            result = new AxisAlignedBoundingBox();
+        }
+
+        if (typeof positions === 'undefined' || positions.length === 0) {
+            result.minimum = Cartesian3.clone(Cartesian3.ZERO, result.minimum);
+            result.maximum = Cartesian3.clone(Cartesian3.ZERO, result.maximum);
+            result.center = Cartesian3.clone(Cartesian3.ZERO, result.center);
+            return result;
+        }
+
+        var minimumX = positions[0].x;
+        var minimumY = positions[0].y;
+        var minimumZ = positions[0].z;
+
+        var maximumX = positions[0].x;
+        var maximumY = positions[0].y;
+        var maximumZ = positions[0].z;
+
+        var length = positions.length;
+        for ( var i = 1; i < length; i++) {
+            var p = positions[i];
+            var x = p.x;
+            var y = p.y;
+            var z = p.z;
+
+            minimumX = Math.min(x, minimumX);
+            maximumX = Math.max(x, maximumX);
+            minimumY = Math.min(y, minimumY);
+            maximumY = Math.max(y, maximumY);
+            minimumZ = Math.min(z, minimumZ);
+            maximumZ = Math.max(z, maximumZ);
+        }
+
+        var minimum = result.minimum;
+        minimum.x = minimumX;
+        minimum.y = minimumY;
+        minimum.z = minimumZ;
+
+        var maximum = result.maximum;
+        maximum.x = maximumX;
+        maximum.y = maximumY;
+        maximum.z = maximumZ;
+
+        var center = Cartesian3.add(minimum, maximum, result.center);
+        Cartesian3.multiplyByScalar(center, 0.5, center);
+
+        return result;
+    };
+
+    /**
+     * Duplicates a AxisAlignedBoundingBox instance.
+     * @memberof AxisAlignedBoundingBox
+     *
+     * @param {AxisAlignedBoundingBox} box The bounding box to duplicate.
+     * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
+     * @return {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if none was provided.
+     *
+     * @exception {DeveloperError} box is required.
+     */
+    AxisAlignedBoundingBox.clone = function(box, result) {
+        if (typeof box === 'undefined') {
+            throw new DeveloperError('box is required');
+        }
+
+        if (typeof result === 'undefined') {
+            return new AxisAlignedBoundingBox(box.minimum, box.maximum);
+        }
+
+        result.minimum = Cartesian3.clone(box.minimum, result.minimum);
+        result.maximum = Cartesian3.clone(box.maximum, result.maximum);
+        result.center = Cartesian3.clone(box.center, result.center);
+        return result;
+    };
+
+    /**
+     * Compares the provided AxisAlignedBoundingBox componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof AxisAlignedBoundingBox
+     *
+     * @param {AxisAlignedBoundingBox} [left] The first AxisAlignedBoundingBox.
+     * @param {AxisAlignedBoundingBox} [right] The second AxisAlignedBoundingBox.
+     * @return {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    AxisAlignedBoundingBox.equals = function(left, right) {
+        return (left === right) ||
+               ((typeof left !== 'undefined') &&
+                (typeof right !== 'undefined') &&
+                Cartesian3.equals(left.center, right.center) &&
+                Cartesian3.equals(left.minimum, right.minimum) &&
+                Cartesian3.equals(left.maximum, right.maximum));
+    };
+
+    var intersectScratch = new Cartesian3();
+    /**
+     * Determines which side of a plane a box is located.
+     * @memberof AxisAlignedBoundingBox
+     *
+     * @param {AxisAlignedBoundingBox} box The bounding box to test.
+     * @param {Cartesian4} plane The coefficients of the plane in the form <code>ax + by + cz + d = 0</code>
+     *                           where the coefficients a, b, c, and d are the components x, y, z, and w
+     *                           of the {Cartesian4}, respectively.
+     * @return {Intersect} {Intersect.INSIDE} if the entire box is on the side of the plane the normal is pointing,
+     *                     {Intersect.OUTSIDE} if the entire box is on the opposite side, and {Intersect.INTERSETING}
+     *                     if the box intersects the plane.
+     *
+     * @exception {DeveloperError} box is required.
+     * @exception {DeveloperError} plane is required.
+     */
+    AxisAlignedBoundingBox.intersect = function(box, plane) {
+        if (typeof box === 'undefined') {
+            throw new DeveloperError('box is required.');
+        }
+
+        if (typeof plane === 'undefined') {
+            throw new DeveloperError('plane is required.');
+        }
+
+        intersectScratch = Cartesian3.subtract(box.maximum, box.minimum, intersectScratch);
+        var h = Cartesian3.multiplyByScalar(intersectScratch, 0.5, intersectScratch); //The positive half diagonal
+        var e = h.x * Math.abs(plane.x) + h.y * Math.abs(plane.y) + h.z * Math.abs(plane.z);
+        var s = Cartesian3.dot(box.center, plane) + plane.w; //signed distance from center
+
+        if (s - e > 0) {
+            return Intersect.INSIDE;
+        }
+
+        if (s + e < 0) {
+            //Not in front because normals point inward
+            return Intersect.OUTSIDE;
+        }
+
+        return Intersect.INTERSECTING;
+    };
+
+    /**
+     * Duplicates this AxisAlignedBoundingBox instance.
+     * @memberof AxisAlignedBoundingBox
+     *
+     * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
+     * @return {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if one was not provided.
+     */
+    AxisAlignedBoundingBox.prototype.clone = function(result) {
+        return AxisAlignedBoundingBox.clone(this, result);
+    };
+
+    /**
+     * Determines which side of a plane this box is located.
+     * @memberof AxisAlignedBoundingBox
+     *
+     * @param {Cartesian4} plane The coefficients of the plane in the form <code>ax + by + cz + d = 0</code>
+     *                           where the coefficients a, b, c, and d are the components x, y, z, and w
+     *                           of the {Cartesian4}, respectively.
+     * @return {Intersect} {Intersect.INSIDE} if the entire box is on the side of the plane the normal is pointing,
+     *                     {Intersect.OUTSIDE} if the entire box is on the opposite side, and {Intersect.INTERSETING}
+     *                     if the box intersects the plane.
+     *
+     * @exception {DeveloperError} plane is required.
+     */
+    AxisAlignedBoundingBox.prototype.intersect = function(plane) {
+        return AxisAlignedBoundingBox.intersect(this, plane);
+    };
+
+    /**
+     * Compares this AxisAlignedBoundingBox against the provided AxisAlignedBoundingBox componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof AxisAlignedBoundingBox
+     *
+     * @param {AxisAlignedBoundingBox} [right] The right hand side AxisAlignedBoundingBox.
+     * @return {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+     */
+    AxisAlignedBoundingBox.prototype.equals = function(right) {
+        return AxisAlignedBoundingBox.equals(this, right);
+    };
+
+    return AxisAlignedBoundingBox;
+});

data/app/assets/javascripts/Core/BoundingRectangle.js

@@ -0,0 +1,364 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError',
+        './Cartographic',
+        './GeographicProjection',
+        './Intersect'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        Cartographic,
+        GeographicProjection,
+        Intersect) {
+    "use strict";
+
+    /**
+     * A bounding rectangle given by a corner, width and height.
+     * @alias BoundingRectangle
+     * @constructor
+     *
+     * @param {Number} [x=0.0] The x coordinate of the rectangle.
+     * @param {Number} [y=0.0] The y coordinate of the rectangle.
+     * @param {Number} [width=0.0] The width of the rectangle.
+     * @param {Number} [height=0.0] The height of the rectangle.
+     *
+     * @see BoundingSphere
+     */
+    var BoundingRectangle = function(x, y, width, height) {
+        /**
+         * The x coordinate of the rectangle.
+         * @type Number
+         */
+        this.x = defaultValue(x, 0.0);
+
+        /**
+         * The y coordinate of the rectangle.
+         * @type Number
+         */
+        this.y = defaultValue(y, 0.0);
+
+        /**
+         * The width of the rectangle.
+         * @type Number
+         */
+        this.width = defaultValue(width, 0.0);
+
+        /**
+         * The height of the rectangle.
+         * @type Number
+         */
+        this.height = defaultValue(height, 0.0);
+    };
+
+    /**
+     * Computes a bounding rectangle enclosing the list of 2D points.
+     * The rectangle is oriented with the corner at the bottom left.
+     * @memberof BoundingRectangle
+     *
+     * @param {Array} positions List of points that the bounding rectangle will enclose.  Each point must have <code>x</code> and <code>y</code> properties.
+     * @param {BoundingRectangle} [result] The object onto which to store the result.
+     * @return {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+     */
+    BoundingRectangle.fromPoints = function(positions, result) {
+        if (typeof result === 'undefined') {
+            result = new BoundingRectangle();
+        }
+
+        if (typeof positions === 'undefined' || positions.length === 0) {
+            result.x = 0;
+            result.y = 0;
+            result.width = 0;
+            result.height = 0;
+            return result;
+        }
+
+        var length = positions.length;
+
+        var minimumX = positions[0].x;
+        var minimumY = positions[0].y;
+
+        var maximumX = positions[0].x;
+        var maximumY = positions[0].y;
+
+        for ( var i = 1; i < length; i++) {
+            var p = positions[i];
+            var x = p.x;
+            var y = p.y;
+
+            minimumX = Math.min(x, minimumX);
+            maximumX = Math.max(x, maximumX);
+            minimumY = Math.min(y, minimumY);
+            maximumY = Math.max(y, maximumY);
+        }
+
+        result.x = minimumX;
+        result.y = minimumY;
+        result.width = maximumX - minimumX;
+        result.height = maximumY - minimumY;
+        return result;
+    };
+
+    var defaultProjection = new GeographicProjection();
+    var fromExtentLowerLeft = new Cartographic();
+    var fromExtentUpperRight = new Cartographic();
+    /**
+     * Computes a bounding rectangle from an extent.
+     * @memberof BoundingRectangle
+     *
+     * @param {Extent} extent The valid extent used to create a bounding rectangle.
+     * @param {Object} [projection=GeographicProjection] The projection used to project the extent into 2D.
+     * @param {BoundingRectangle} [result] The object onto which to store the result.
+     * @return {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+     */
+    BoundingRectangle.fromExtent = function(extent, projection, result) {
+        if (typeof result === 'undefined') {
+            result = new BoundingRectangle();
+        }
+
+        if (typeof extent === 'undefined') {
+            result.x = 0;
+            result.y = 0;
+            result.width = 0;
+            result.height = 0;
+            return result;
+        }
+
+        projection = (typeof projection !== 'undefined') ? projection : defaultProjection;
+
+        var lowerLeft = projection.project(extent.getSouthwest(fromExtentLowerLeft));
+        var upperRight = projection.project(extent.getNortheast(fromExtentUpperRight));
+
+        upperRight.subtract(lowerLeft, upperRight);
+
+        result.x = lowerLeft.x;
+        result.y = lowerLeft.y;
+        result.width = upperRight.x;
+        result.height = upperRight.y;
+        return result;
+    };
+
+    /**
+     * Duplicates a BoundingRectangle instance.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} rectangle The bounding rectangle to duplicate.
+     * @param {BoundingRectangle} [result] The object onto which to store the result.
+     * @return {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+     *
+     * @exception {DeveloperError} rectangle is required.
+     */
+    BoundingRectangle.clone = function(rectangle, result) {
+        if (typeof rectangle === 'undefined') {
+            throw new DeveloperError('rectangle is required');
+        }
+
+        if (typeof result === 'undefined') {
+            return new BoundingRectangle(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
+        }
+
+        result.x = rectangle.x;
+        result.y = rectangle.y;
+        result.width = rectangle.width;
+        result.height = rectangle.height;
+        return result;
+    };
+
+    /**
+     * Computes a bounding rectangle that is the union of the left and right bounding rectangles.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} left A rectangle to enclose in bounding rectangle.
+     * @param {BoundingRectangle} right A rectangle to enclose in a bounding rectangle.
+     * @param {BoundingRectangle} [result] The object onto which to store the result.
+     * @return {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+     *
+     * @exception {DeveloperError} left is required.
+     * @exception {DeveloperError} right is required.
+     */
+    BoundingRectangle.union = function(left, right, result) {
+        if (typeof left === 'undefined') {
+            throw new DeveloperError('left is required.');
+        }
+
+        if (typeof right === 'undefined') {
+            throw new DeveloperError('right is required.');
+        }
+
+        if (typeof result === 'undefined') {
+            result = new BoundingRectangle();
+        }
+
+        var lowerLeftX = Math.min(left.x, right.x);
+        var lowerLeftY = Math.min(left.y, right.y);
+        var upperRightX = Math.max(left.x + left.width, right.x + right.width);
+        var upperRightY = Math.max(left.y + left.height, right.y + right.height);
+
+        result.x = lowerLeftX;
+        result.y = lowerLeftY;
+        result.width = upperRightX - lowerLeftX;
+        result.height = upperRightY - lowerLeftY;
+        return result;
+    };
+
+    /**
+     * Computes a bounding rectangle by enlarging the provided rectangle until it contains the provided point.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} rectangle A rectangle to expand.
+     * @param {Cartesian2} point A point to enclose in a bounding rectangle.
+     * @param {BoundingRectangle} [result] The object onto which to store the result.
+     * @return {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+     *
+     * @exception {DeveloperError} rectangle is required.
+     * @exception {DeveloperError} point is required.
+     */
+    BoundingRectangle.expand = function(rectangle, point, result) {
+        if (typeof rectangle === 'undefined') {
+            throw new DeveloperError('rectangle is required.');
+        }
+
+        if (typeof point === 'undefined') {
+            throw new DeveloperError('point is required.');
+        }
+
+        result = BoundingRectangle.clone(rectangle, result);
+
+        var width = point.x - result.x;
+        var height = point.y - result.y;
+
+        if (width > result.width) {
+            result.width = width;
+        } else if (width < 0) {
+            result.width -= width;
+            result.x = point.x;
+        }
+
+        if (height > result.height) {
+            result.height = height;
+        } else if (height < 0) {
+            result.height -= height;
+            result.y = point.y;
+        }
+
+        return result;
+    };
+
+    /**
+     * Determines if two rectangles intersect.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} left A rectangle to check for intersection.
+     * @param {BoundingRectangle} right The other rectangle to check for intersection.
+     * @return {Intersect} <code>Intersect.INTESECTING</code> if the rectangles intersect, <code>Intersect.OUTSIDE</code> otherwise.
+     *
+     * @exception {DeveloperError} left is required.
+     * @exception {DeveloperError} right is required.
+     */
+    BoundingRectangle.intersect = function(left, right) {
+        if (typeof left === 'undefined') {
+            throw new DeveloperError('left is required.');
+        }
+
+        if (typeof right === 'undefined') {
+            throw new DeveloperError('right is required.');
+        }
+
+        var leftX = left.x;
+        var leftY = left.y;
+        var rightX = right.x;
+        var rightY = right.y;
+        if (!(leftX > rightX + right.width ||
+              leftX + left.width < rightX ||
+              leftY + left.height < rightY ||
+              leftY > rightY + right.height)) {
+            return Intersect.INTERSECTING;
+        }
+
+        return Intersect.OUTSIDE;
+    };
+
+    /**
+     * Compares the provided BoundingRectangles componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} [left] The first BoundingRectangle.
+     * @param {BoundingRectangle} [right] The second BoundingRectangle.
+     * @return {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    BoundingRectangle.equals = function(left, right) {
+        return (left === right) ||
+               ((typeof left !== 'undefined') &&
+                (typeof right !== 'undefined') &&
+                (left.x === right.x) &&
+                (left.y === right.y) &&
+                (left.width === right.width) &&
+                (left.height === right.height));
+    };
+
+    /**
+     * Duplicates this BoundingRectangle instance.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} [result] The object onto which to store the result.
+     * @return {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+     */
+    BoundingRectangle.prototype.clone = function(result) {
+        return BoundingRectangle.clone(this, result);
+    };
+
+    /**
+     * Computes a bounding rectangle that contains both this bounding rectangle and the argument rectangle.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} right The rectangle to enclose in this bounding rectangle.
+     * @param {BoundingRectangle} [result] The object onto which to store the result.
+     * @return {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+     *
+     * @exception {DeveloperError} right is required.
+     */
+    BoundingRectangle.prototype.union = function(right, result) {
+        return BoundingRectangle.union(this, right, result);
+    };
+
+    /**
+     * Computes a bounding rectangle that is rectangle expanded to contain point.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} point A point to enclose in a bounding rectangle.
+     * @return {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+     *
+     * @exception {DeveloperError} point is required.
+     */
+    BoundingRectangle.prototype.expand = function(point, result) {
+        return BoundingRectangle.expand(this, point, result);
+    };
+
+    /**
+     * Determines if this rectangle intersects with another.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} right A rectangle to check for intersection.
+     * @return {Intersect} <code>Intersect.INTESECTING</code> if the rectangles intersect, <code>Intersect.OUTSIDE</code> otherwise.
+     *
+     * @exception {DeveloperError} right is required.
+     */
+    BoundingRectangle.prototype.intersect = function(right) {
+        return BoundingRectangle.intersect(this, right);
+    };
+
+    /**
+     * Compares this BoundingRectangle against the provided BoundingRectangle componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof BoundingRectangle
+     *
+     * @param {BoundingRectangle} [right] The right hand side BoundingRectangle.
+     * @return {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+     */
+    BoundingRectangle.prototype.equals = function(right) {
+        return BoundingRectangle.equals(this, right);
+    };
+
+    return BoundingRectangle;
+});