cesium 0.22.0 → 0.23.0

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

@@ -0,0 +1,396 @@
+/*global define*/
+define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartesian3', 'Core/Intersect', 'Core/Matrix3', 'Core/BoundingRectangle'], function(
+        defaultValue,
+        defined,
+        DeveloperError,
+        Cartesian3,
+        Intersect,
+        Matrix3,
+        BoundingRectangle) {
+    "use strict";
+
+    /**
+     * Creates an instance of an ObjectOrientedBoundingBox.
+     * An ObjectOrientedBoundingBox model of an object or set of objects, is a closed volume (a cuboid), which completely contains the object or the set of objects.
+     * It is oriented, so it can provide an optimum fit, it can bound more tightly.
+     * @alias ObjectOrientedBoundingBox
+     * @constructor
+     *
+     * @param {Matrix3} [rotation=Matrix3.IDENTITY] The transformation matrix, to rotate the box to the right position.
+     * @param {Cartesian3} [translation=Cartesian3.ZERO] The position of the box.
+     * @param {Cartesian3} [scale=Cartesian3.ZERO] The scale of the box.
+     *
+     * @example
+     * // Create an ObjectOrientedBoundingBox using a transformation matrix, a position where the box will be translated, and a scale.
+     * var rotation = Matrix3.clone(Matrix3.IDENTITY);
+     * var translation = new Cartesian3(1,0,0);
+     * var scale = new Cartesian3(0,5,0);
+     *
+     * var oobb = new ObjectOrientedBoundingBox(rotation, translation, scale);
+     *
+     * @see ObjectOrientedBoundingBox.fromPoints
+     * @see ObjectOrientedBoundingBox.fromBoundingRectangle
+     * @see BoundingSphere
+     */
+    var ObjectOrientedBoundingBox = function(rotation, translation, scale) {
+        /**
+         * The transformation matrix, to rotate the box to the right position.
+         * @type {Matrix3}
+         * @default {@link Matrix3.IDENTITY}
+         */
+        this.rotation = Matrix3.clone(defaultValue(rotation, Matrix3.IDENTITY));
+        /**
+         * The position of the box.
+         * @type {Cartesian3}
+         * @default {@link Cartesian3.ZERO}
+         */
+        this.translation = Cartesian3.clone(defaultValue(translation, Cartesian3.ZERO));
+        /**
+         * The scale of the box.
+         * @type {Cartesian3}
+         * @default {@link Cartesian3.ZERO}
+         */
+        this.scale = Cartesian3.clone(defaultValue(scale, Cartesian3.ZERO));
+    };
+
+    var scratchCartesian1 = new Cartesian3();
+    var scratchCartesian2 = new Cartesian3();
+    var scratchCartesian3 = new Cartesian3();
+    var scratchCartesian4 = new Cartesian3();
+    var scratchCartesian5 = new Cartesian3();
+    var scratchCartesian6 = new Cartesian3();
+    var scratchCovarianceResult = new Matrix3();
+    var scratchEigenResult = {
+        unitary : new Matrix3(),
+        diagonal : new Matrix3()
+    };
+
+    /**
+     * Computes an instance of an ObjectOrientedBoundingBox of the given positions.
+     * This is an implementation of Stefan Gottschalk's Collision Queries using Oriented Bounding Boxes solution (PHD thesis).
+     * Reference: http://gamma.cs.unc.edu/users/gottschalk/main.pdf
+     * @memberof ObjectOrientedBoundingBox
+     *
+     * @param {Array} positions List of {@link Cartesian3} points that the bounding box will enclose.
+     * @param {ObjectOrientedBoundingBox} [result] The object onto which to store the result.
+     * @return {ObjectOrientedBoundingBox} The modified result parameter or a new ObjectOrientedBoundingBox instance if one was not provided.
+     *
+     * @example
+     * // Compute an object oriented bounding box enclosing two points.
+     * var box = ObjectOrientedBoundingBox.fromPoints([new Cartesian3(2, 0, 0), new Cartesian3(-2, 0, 0)]);
+     */
+    ObjectOrientedBoundingBox.fromPoints = function(positions, result) {
+        if (!defined(result)) {
+            result = new ObjectOrientedBoundingBox();
+        }
+
+        if (!defined(positions) || positions.length === 0) {
+            result.tranformMatrix = Matrix3.IDENTITY;
+            result.translation = Cartesian3.ZERO;
+            result.scale = Cartesian3.ZERO;
+            return result;
+        }
+
+        var i;
+        var length = positions.length;
+
+        var meanPoint = Cartesian3.clone(positions[0], scratchCartesian1);
+        for (i = 1; i < length; i++) {
+            Cartesian3.add(meanPoint, positions[i], meanPoint);
+        }
+        var invLength = 1.0 / length;
+        Cartesian3.multiplyByScalar(meanPoint, invLength, meanPoint);
+
+        var exx = 0.0;
+        var exy = 0.0;
+        var exz = 0.0;
+        var eyy = 0.0;
+        var eyz = 0.0;
+        var ezz = 0.0;
+        var p;
+
+        for (i = 0; i < length; i++) {
+            p = Cartesian3.subtract(positions[i], meanPoint, scratchCartesian2);
+            exx += p.x * p.x;
+            exy += p.x * p.y;
+            exz += p.x * p.z;
+            eyy += p.y * p.y;
+            eyz += p.y * p.z;
+            ezz += p.z * p.z;
+        }
+
+        exx *= invLength;
+        exy *= invLength;
+        exz *= invLength;
+        eyy *= invLength;
+        eyz *= invLength;
+        ezz *= invLength;
+
+        var covarianceMatrix = scratchCovarianceResult;
+        covarianceMatrix[0] = exx;
+        covarianceMatrix[1] = exy;
+        covarianceMatrix[2] = exz;
+        covarianceMatrix[3] = exy;
+        covarianceMatrix[4] = eyy;
+        covarianceMatrix[5] = eyz;
+        covarianceMatrix[6] = exz;
+        covarianceMatrix[7] = eyz;
+        covarianceMatrix[8] = ezz;
+
+        var eigenDecomposition = Matrix3.getEigenDecomposition(covarianceMatrix, scratchEigenResult);
+        var rotation = Matrix3.transpose(eigenDecomposition.unitary, result.rotation);
+
+        p = Cartesian3.subtract(positions[0], meanPoint, scratchCartesian2);
+        var tempPoint = Matrix3.multiplyByVector(rotation, p, scratchCartesian3);
+        var maxPoint = Cartesian3.clone(tempPoint, scratchCartesian4);
+        var minPoint = Cartesian3.clone(tempPoint, scratchCartesian5);
+
+        for (i = 1; i < length; i++) {
+            p = Cartesian3.subtract(positions[i], meanPoint, p);
+            Matrix3.multiplyByVector(rotation, p, tempPoint);
+            Cartesian3.getMinimumByComponent(minPoint, tempPoint, minPoint);
+            Cartesian3.getMaximumByComponent(maxPoint, tempPoint, maxPoint);
+        }
+
+        var center = Cartesian3.add(minPoint, maxPoint, scratchCartesian3);
+        Cartesian3.multiplyByScalar(center, 0.5, center);
+        Matrix3.multiplyByVector(rotation, center, center);
+        Cartesian3.add(meanPoint, center, result.translation);
+
+        var scale = Cartesian3.subtract(maxPoint, minPoint, scratchCartesian3);
+        Cartesian3.multiplyByScalar(scale, 0.5, result.scale);
+
+        return result;
+    };
+
+    /**
+     * Computes an ObjectOrientedBoundingBox from a BoundingRectangle.
+     * The BoundingRectangle is placed on the XY plane.
+     * @memberof ObjectOrientedBoundingBox
+     *
+     * @param {BoundingRectangle} boundingRectangle A bounding rectangle.
+     * @param {Number} [rotation=0.0] The rotation of the bounding box in radians.
+     * @return {ObjectOrientedBoundingBox} The modified result parameter or a new ObjectOrientedBoundingBox instance if one was not provided.
+     *
+     * @exception {DeveloperError} boundingRectangle is required.
+     *
+     * @example
+     * // Compute an object oriented bounding box enclosing two points.
+     * var box = ObjectOrientedBoundingBox.fromBoundingRectangle(boundingRectangle, 0.0);
+     */
+    ObjectOrientedBoundingBox.fromBoundingRectangle = function(boundingRectangle, rotation, result) {
+        if (!defined(boundingRectangle)) {
+            throw new DeveloperError('boundingRectangle is required');
+        }
+
+        if (!defined(result)) {
+            result = new ObjectOrientedBoundingBox();
+        }
+
+        if (defined(rotation)) {
+            Matrix3.fromRotationZ(rotation, result.rotation);
+        } else {
+            Matrix3.clone(Matrix3.IDENTITY, result.rotation);
+        }
+
+        var scale = result.scale;
+        scale.x = boundingRectangle.width * 0.5;
+        scale.y = boundingRectangle.height * 0.5;
+        scale.z = 0.0;
+
+        var translation = Matrix3.multiplyByVector(result.rotation, scale, result.translation);
+        translation.x += boundingRectangle.x;
+        translation.y += boundingRectangle.y;
+
+        return result;
+    };
+
+    /**
+     * Duplicates a ObjectOrientedBoundingBox instance.
+     * @memberof ObjectOrientedBoundingBox
+     *
+     * @param {ObjectOrientedBoundingBox} box The bounding box to duplicate.
+     * @param {ObjectOrientedBoundingBox} [result] The object onto which to store the result.
+     * @return {ObjectOrientedBoundingBox} The modified result parameter or a new ObjectOrientedBoundingBox instance if none was provided. (Returns undefined if box is undefined)
+     */
+    ObjectOrientedBoundingBox.clone = function(box, result) {
+        if (!defined(box)) {
+            return undefined;
+        }
+
+        if (!defined(result)) {
+            return new ObjectOrientedBoundingBox(box.rotation, box.translation, box.scale);
+        }
+
+        Matrix3.clone(box.rotation, result.rotation);
+        Cartesian3.clone(box.translation, result.translation);
+        Cartesian3.clone(box.scale, result.scale);
+
+        return result;
+    };
+
+    var scratchIntersectMatrix1 = new Matrix3();
+    var scratchIntersectMatrix2 = new Matrix3();
+    var scratchTCartesian = new Cartesian3();
+    var scratchTArray = new Array(3);
+    var scratchAArray = new Array(3);
+    var scratchBArray = new Array(3);
+
+    function testCase1(k, a, b, B, T) {
+        var right = a[k] + b[0] * B[Matrix3.getElementIndex(0, k)] + b[1] * B[Matrix3.getElementIndex(1, k)] + b[2] * B[Matrix3.getElementIndex(2, k)];
+
+        if (Math.abs(T[k]) > right) {
+            return true;
+        }
+        return false;
+    }
+
+    function testCase2(k, a, b, B, T) {
+        var left = T[0] * B[Matrix3.getElementIndex(0, k)] + T[1] * B[Matrix3.getElementIndex(1, k)] + T[2] * B[Matrix3.getElementIndex(2, k)];
+        var right = b[k] + a[0] * B[Matrix3.getElementIndex(0, k)] + a[1] * B[Matrix3.getElementIndex(1, k)] + a[2] * B[Matrix3.getElementIndex(2, k)];
+
+        if (Math.abs(left) > right) {
+            return true;
+        }
+        return false;
+    }
+
+    function testCase3(i, j, a, b, B, T) {
+        var left = T[(i + 2) % 3] * B[Matrix3.getElementIndex((i + 1) % 3, j)] - T[(i + 1) % 3] * B[Matrix3.getElementIndex((i + 2) % 3, j)];
+        var right = a[(i + 1) % 3] * B[Matrix3.getElementIndex((i + 2) % 3, j)] + a[(i + 2) % 3] * B[Matrix3.getElementIndex((i + 1) % 3, j)];
+        right += b[(j + 1) % 3] * B[Matrix3.getElementIndex(i, (j + 2) % 3)] + b[(j + 2) % 3] * B[Matrix3.getElementIndex(i, (j + 1) % 3)];
+
+        if (Math.abs(left) > right) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Checks if two ObjectOrientedBoundingBoxes intersect.
+     * This is an implementation of Stefan Gottschalk's Collision Queries using Oriented Bounding Boxes solution (PHD thesis).
+     * @memberof ObjectOrientedBoundingBox
+     *
+     * @param {ObjectOrientedBoundingBox} left The first ObjectOrientedBoundingBox.
+     * @param {ObjectOrientedBoundingBox} right The second ObjectOrientedBoundingBox.
+     * @return {Boolean} <code>true</code> if they intersects each other <code>false</code> otherwise.
+     *
+     * @exception {DeveloperError} left is required.
+     * @exception {DeveloperError} right is required.
+     */
+    ObjectOrientedBoundingBox.intersect = function(left, right) {
+        if (!defined(left)) {
+            throw new DeveloperError('left is required');
+        }
+        if (!defined(right)) {
+            throw new DeveloperError('right is required');
+        }
+
+        var leftTransformTransposed = Matrix3.transpose(left.rotation, scratchIntersectMatrix1);
+        var B = Matrix3.multiply(leftTransformTransposed, right.rotation, scratchIntersectMatrix2);
+        Matrix3.abs(B, B);
+
+        var T = scratchTArray;
+        var a = scratchAArray;
+        var b = scratchBArray;
+
+        Cartesian3.subtract(left.translation, right.translation, scratchTCartesian);
+        Matrix3.multiplyByVector(leftTransformTransposed, scratchTCartesian, scratchTCartesian);
+        Cartesian3.pack(scratchTCartesian, T);
+        Cartesian3.pack(left.scale, a);
+        Cartesian3.pack(right.scale, b);
+
+        if (testCase1(0, a, b, B, T)) {
+            return false;
+        }
+        if (testCase1(1, a, b, B, T)) {
+            return false;
+        }
+        if (testCase1(2, a, b, B, T)) {
+            return false;
+        }
+
+        if (testCase2(0, a, b, B, T)) {
+            return false;
+        }
+        if (testCase2(1, a, b, B, T)) {
+            return false;
+        }
+        if (testCase2(2, a, b, B, T)) {
+            return false;
+        }
+
+        if (testCase3(0, 0, a, b, B, T)) {
+            return false;
+        }
+        if (testCase3(1, 0, a, b, B, T)) {
+            return false;
+        }
+        if (testCase3(2, 0, a, b, B, T)) {
+            return false;
+        }
+        if (testCase3(0, 1, a, b, B, T)) {
+            return false;
+        }
+        if (testCase3(1, 1, a, b, B, T)) {
+            return false;
+        }
+        if (testCase3(2, 1, a, b, B, T)) {
+            return false;
+        }
+        if (testCase3(0, 2, a, b, B, T)) {
+            return false;
+        }
+        if (testCase3(1, 2, a, b, B, T)) {
+            return false;
+        }
+        if (testCase3(2, 2, a, b, B, T)) {
+            return false;
+        }
+
+        return true;
+    };
+
+    /**
+     * Compares the provided ObjectOrientedBoundingBox componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof ObjectOrientedBoundingBox
+     *
+     * @param {ObjectOrientedBoundingBox} left The first ObjectOrientedBoundingBox.
+     * @param {ObjectOrientedBoundingBox} right The second ObjectOrientedBoundingBox.
+     * @return {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    ObjectOrientedBoundingBox.equals = function(left, right) {
+        return (left === right) ||
+                ((defined(left)) &&
+                 (defined(right)) &&
+                 Cartesian3.equals(left.transformedPosition, right.transformedPosition) &&
+                 Matrix3.equals(left.transformMatrix, right.transformMatrix) &&
+                 Cartesian3.equals(left.extent, right.extent));
+    };
+
+    /**
+     * Duplicates this ObjectOrientedBoundingBox instance.
+     * @memberof ObjectOrientedBoundingBox
+     *
+     * @param {ObjectOrientedBoundingBox} [result] The object onto which to store the result.
+     * @return {ObjectOrientedBoundingBox} The modified result parameter or a new ObjectOrientedBoundingBox instance if one was not provided.
+     */
+    ObjectOrientedBoundingBox.prototype.clone = function(result) {
+        return ObjectOrientedBoundingBox.clone(this, result);
+    };
+
+    /**
+     * Compares this ObjectOrientedBoundingBox against the provided ObjectOrientedBoundingBox componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof ObjectOrientedBoundingBox
+     *
+     * @param {ObjectOrientedBoundingBox} [right] The right hand side ObjectOrientedBoundingBox.
+     * @return {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+     */
+    ObjectOrientedBoundingBox.prototype.equals = function(right) {
+        return ObjectOrientedBoundingBox.equals(this, right);
+    };
+
+    return ObjectOrientedBoundingBox;
+});

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

@@ -65,7 +65,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
 
     var createGeometryFromPositionsPositions = [];
 
-    function createGeometryFromPositions(ellipsoid, positions, granularity) {
+    function createGeometryFromPositions(ellipsoid, positions, granularity, perPositionHeight) {
         var tangentPlane = EllipsoidTangentPlane.fromPoints(positions, ellipsoid);
         var positions2D = tangentPlane.projectPointsOntoPlane(positions, createGeometryFromPositionsPositions);
 
@@ -80,8 +80,35 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
         if (indices.length < 3) {
             indices = [0, 1, 2];
         }
+
+        var geo;
+        if (!perPositionHeight) {
+            geo = PolygonPipeline.computeSubdivision(positions, indices, granularity);
+        } else {
+            var length = positions.length;
+            var flattenedPositions = new Array(length * 3);
+            var index = 0;
+            for ( var i = 0; i < length; i++) {
+                var p = positions[i];
+                flattenedPositions[index++] = p.x;
+                flattenedPositions[index++] = p.y;
+                flattenedPositions[index++] = p.z;
+            }
+            geo = new Geometry({
+                attributes : {
+                    position : new GeometryAttribute({
+                        componentDatatype : ComponentDatatype.DOUBLE,
+                        componentsPerAttribute : 3,
+                        values : flattenedPositions
+                    })
+                },
+                indices : indices,
+                primitiveType : PrimitiveType.TRIANGLES
+            });
+        }
+
         return new GeometryInstance({
-            geometry : PolygonPipeline.computeSubdivision(positions, indices, granularity)
+            geometry : geo
         });
     }
 
@@ -137,7 +164,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
                 length /= 2;
             }
 
-            for (var i = 0; i < length; i += 3) {
+            for ( var i = 0; i < length; i += 3) {
                 var position = Cartesian3.fromArray(flatPositions, i, appendTextureCoordinatesCartesian3);
 
                 if (vertexFormat.st) {
@@ -145,7 +172,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
                     var st = tangentPlane.projectPointOntoPlane(p, appendTextureCoordinatesCartesian2);
                     Cartesian2.subtract(st, origin, st);
 
-                    if (bottom){
+                    if (bottom) {
                         textureCoordinates[textureCoordIndex + bottomOffset2] = st.x / boundingRectangle.width;
                         textureCoordinates[textureCoordIndex + 1 + bottomOffset2] = st.y / boundingRectangle.height;
                     }
@@ -161,7 +188,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
                     var attrIndex2 = attrIndex + 2;
 
                     if (wall) {
-                        if (i+3 < length) {
+                        if (i + 3 < length) {
                             var p1 = Cartesian3.fromArray(flatPositions, i + 3, p1Scratch);
 
                             if (recomputeNormal) {
@@ -277,7 +304,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
         return geometry;
     }
 
-    function computeWallIndices(positions, granularity){
+    function computeWallIndices(positions, granularity, perPositionHeight){
         var edgePositions = [];
         var subdividedEdge;
         var edgeIndex;
@@ -287,25 +314,33 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
         var length = positions.length;
         var p1;
         var p2;
-        for (i = 0; i < length; i++) {
-            p1 = positions[i];
-            p2 = positions[(i+1)%length];
-            subdividedEdge = PolygonGeometryLibrary.subdivideLine(p1, p2, granularity);
-            subdividedEdge.push(p2.x, p2.y, p2.z);
-            edgePositions = edgePositions.concat(subdividedEdge);
+        if (!perPositionHeight) {
+            for (i = 0; i < length; i++) {
+                p1 = positions[i];
+                p2 = positions[(i + 1) % length];
+                subdividedEdge = PolygonGeometryLibrary.subdivideLine(p1, p2, granularity);
+                subdividedEdge.push(p2.x, p2.y, p2.z);
+                edgePositions = edgePositions.concat(subdividedEdge);
+            }
+        } else {
+            for (i = 0; i < length; i++) {
+                p1 = positions[i];
+                p2 = positions[(i + 1) % length];
+                edgePositions.push(p1.x, p1.y, p1.z, p2.x, p2.y, p2.z);
+            }
         }
 
         edgePositions = edgePositions.concat(edgePositions);
         length = edgePositions.length;
-        var indices = IndexDatatype.createTypedArray(length/3, length - positions.length*6);
+        var indices = IndexDatatype.createTypedArray(length / 3, length - positions.length * 6);
         edgeIndex = 0;
         length /= 6;
 
-        for (i = 0 ; i < length; i++) {
+        for (i = 0; i < length; i++) {
             UL = i;
             UR = UL + 1;
-            p1 = Cartesian3.fromArray(edgePositions, UL*3, p1Scratch);
-            p2 = Cartesian3.fromArray(edgePositions, UR*3, p2Scratch);
+            p1 = Cartesian3.fromArray(edgePositions, UL * 3, p1Scratch);
+            p2 = Cartesian3.fromArray(edgePositions, UR * 3, p2Scratch);
             if (Cartesian3.equalsEpsilon(p1, p2, CesiumMath.EPSILON6)) {
                 continue;
             }
@@ -332,18 +367,18 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
         });
     }
 
-    function createGeometryFromPositionsExtruded(ellipsoid, positions, granularity, hierarchy) {
-        var topGeo = createGeometryFromPositions(ellipsoid, positions, granularity).geometry;
+    function createGeometryFromPositionsExtruded(ellipsoid, positions, granularity, hierarchy, perPositionHeight) {
+        var topGeo = createGeometryFromPositions(ellipsoid, positions, granularity, perPositionHeight).geometry;
         var edgePoints = topGeo.attributes.position.values;
         var indices = topGeo.indices;
         var topBottomPositions = edgePoints.concat(edgePoints);
-        var numPositions = topBottomPositions.length/3;
-        var newIndices = IndexDatatype.createTypedArray(numPositions, indices.length*2);
+        var numPositions = topBottomPositions.length / 3;
+        var newIndices = IndexDatatype.createTypedArray(numPositions, indices.length * 2);
         newIndices.set(indices);
         var ilength = indices.length;
         var i;
         var length = numPositions / 2;
-        for (i = 0 ; i < ilength; i += 3) {
+        for (i = 0; i < ilength; i += 3) {
             var i0 = newIndices[i] + length;
             var i1 = newIndices[i + 1] + length;
             var i2 = newIndices[i + 2] + length;
@@ -353,21 +388,21 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
             newIndices[i + 2 + ilength] = i0;
         }
         var topAndBottomGeo = new Geometry({
-            attributes: new GeometryAttributes({
-                position: new GeometryAttribute({
+            attributes : new GeometryAttributes({
+                position : new GeometryAttribute({
                     componentDatatype : ComponentDatatype.DOUBLE,
                     componentsPerAttribute : 3,
                     values : topBottomPositions
                 })
             }),
-            indices: newIndices,
-            primitiveType: topGeo.primitiveType
+            indices : newIndices,
+            primitiveType : topGeo.primitiveType
         });
 
         var geos = {
-                topAndBottom: new GeometryInstance({
-                    geometry : topAndBottomGeo
-                })
+            topAndBottom : new GeometryInstance({
+                geometry : topAndBottomGeo
+            })
         };
 
         geos.walls = [];
@@ -376,9 +411,9 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
         if (windingOrder === WindingOrder.CLOCKWISE) {
             outerRing = outerRing.reverse();
         }
-        var wallGeo = computeWallIndices(outerRing, granularity);
+        var wallGeo = computeWallIndices(outerRing, granularity, perPositionHeight);
         geos.walls.push(new GeometryInstance({
-            geometry: wallGeo
+            geometry : wallGeo
         }));
 
         var holes = hierarchy.holes;
@@ -390,7 +425,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
             }
             wallGeo = computeWallIndices(hole, granularity);
             geos.walls.push(new GeometryInstance({
-                geometry: wallGeo
+                geometry : wallGeo
             }));
         }
 
@@ -410,6 +445,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
      * @param {Number} [options.stRotation=0.0] The rotation of the texture coordinates, in radians. A positive rotation is counter-clockwise.
      * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
      * @param {Number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
+     * @param {Boolean} [options.perPositionHeight=false] Use the height of options.positions for each position instaed of using options.height to determine the height.
      *
      * @exception {DeveloperError} polygonHierarchy is required.
      *
@@ -489,9 +525,10 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
         var granularity = defaultValue(options.granularity, CesiumMath.RADIANS_PER_DEGREE);
         var stRotation = defaultValue(options.stRotation, 0.0);
         var height = defaultValue(options.height, 0.0);
+        var perPositionHeight = defaultValue(options.perPositionHeight, false);
 
-        var extrudedHeight = defaultValue(options.extrudedHeight, undefined);
-        var extrude = (defined(extrudedHeight) && !CesiumMath.equalsEpsilon(height, extrudedHeight, CesiumMath.EPSILON6));
+        var extrudedHeight = options.extrudedHeight;
+        var extrude = (defined(extrudedHeight) && (!CesiumMath.equalsEpsilon(height, extrudedHeight, CesiumMath.EPSILON6) || perPositionHeight));
         if (extrude) {
             var h = extrudedHeight;
             extrudedHeight = Math.min(h, height);
@@ -511,6 +548,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
         this._extrudedHeight = extrudedHeight;
         this._extrude = extrude;
         this._polygonHierarchy = polygonHierarchy;
+        this._perPositionHeight = perPositionHeight;
         this._workerName = 'createPolygonGeometry';
     };
 
@@ -526,6 +564,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
      * @param {Number} [options.stRotation=0.0] The rotation of the texture coordiantes, in radians. A positive rotation is counter-clockwise.
      * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
      * @param {Number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
+     * @param {Boolean} [options.perPositionHeight=false] Use the height of options.positions for each position instead of using options.height to determine the height.
      *
      * @exception {DeveloperError} options.positions is required.
      *
@@ -560,7 +599,8 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
             vertexFormat : options.vertexFormat,
             stRotation : options.stRotation,
             ellipsoid : options.ellipsoid,
-            granularity : options.granularity
+            granularity : options.granularity,
+            perPositionHeight : options.perPositionHeight
         };
         return new PolygonGeometry(newOptions);
     };
@@ -584,6 +624,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
         var extrudedHeight = polygonGeometry._extrudedHeight;
         var extrude = polygonGeometry._extrude;
         var polygonHierarchy = polygonGeometry._polygonHierarchy;
+        var perPositionHeight = polygonGeometry._perPositionHeight;
 
         var boundingSphere;
         var walls;
@@ -610,8 +651,8 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
             if (numChildren === 0) {
                 // The outer polygon is a simple polygon with no nested inner polygon.
                 polygonHierarchy.push({
-                    outerRing: outerRing,
-                    holes: []
+                    outerRing : outerRing,
+                    holes : []
                 });
                 polygons.push(outerRing);
             } else {
@@ -630,20 +671,20 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
                         numGrandchildren = hole.holes.length;
                     }
 
-                    for (var j = 0; j < numGrandchildren; j++) {
+                    for ( var j = 0; j < numGrandchildren; j++) {
                         queue.enqueue(hole.holes[j]);
                     }
                 }
                 polygonHierarchy.push({
-                    outerRing: outerRing,
-                    holes: polygonHoles
+                    outerRing : outerRing,
+                    holes : polygonHoles
                 });
                 var combinedPolygon = PolygonPipeline.eliminateHoles(outerRing, polygonHoles);
                 polygons.push(combinedPolygon);
             }
         }
 
-        outerPositions =  polygons[0];
+        outerPositions = polygons[0];
         // The bounding volume is just around the boundary points, so there could be cases for
         // contrived polygons on contrived ellipsoids - very oblate ones - where the bounding
         // volume doesn't cover the polygon.
@@ -654,17 +695,17 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
 
         if (extrude) {
             for (i = 0; i < polygons.length; i++) {
-                geometry = createGeometryFromPositionsExtruded(ellipsoid, polygons[i], granularity, polygonHierarchy[i]);
+                geometry = createGeometryFromPositionsExtruded(ellipsoid, polygons[i], granularity, polygonHierarchy[i], perPositionHeight);
                 if (defined(geometry)) {
                     topAndBottom = geometry.topAndBottom;
-                    topAndBottom.geometry = PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(topAndBottom.geometry, height, extrudedHeight, ellipsoid);
+                    topAndBottom.geometry = PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(topAndBottom.geometry, height, extrudedHeight, ellipsoid, perPositionHeight);
                     topAndBottom.geometry = computeAttributes(vertexFormat, topAndBottom.geometry, outerPositions, ellipsoid, stRotation, true, false);
                     geometries.push(topAndBottom);
 
                     walls = geometry.walls;
-                    for (var k = 0; k < walls.length; k++) {
+                    for ( var k = 0; k < walls.length; k++) {
                         var wall = walls[k];
-                        wall.geometry = PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(wall.geometry, height, extrudedHeight, ellipsoid);
+                        wall.geometry = PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(wall.geometry, height, extrudedHeight, ellipsoid, perPositionHeight);
                         wall.geometry = computeAttributes(vertexFormat, wall.geometry, outerPositions, ellipsoid, stRotation, true, true);
                         geometries.push(wall);
                     }
@@ -672,16 +713,15 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
             }
         } else {
             for (i = 0; i < polygons.length; i++) {
-                geometry = createGeometryFromPositions(ellipsoid, polygons[i], granularity);
+                geometry = createGeometryFromPositions(ellipsoid, polygons[i], granularity, perPositionHeight);
                 if (defined(geometry)) {
-                    geometry.geometry = PolygonPipeline.scaleToGeodeticHeight(geometry.geometry, height, ellipsoid);
+                    geometry.geometry = PolygonPipeline.scaleToGeodeticHeight(geometry.geometry, height, ellipsoid, !perPositionHeight);
                     geometry.geometry = computeAttributes(vertexFormat, geometry.geometry, outerPositions, ellipsoid, stRotation, false, false);
                     geometries.push(geometry);
                 }
             }
         }
 
-
         geometry = GeometryPipeline.combine(geometries);
 
         var center = boundingSphere.center;