cesium 0.13.0

data/app/assets/javascripts/DynamicScene/CzmlCartesian2.js

@@ -0,0 +1,96 @@
+/*global define*/
+define([
+        '../Core/Cartesian2'
+       ], function(
+         Cartesian2) {
+    "use strict";
+
+    var doublesPerValue = 2;
+
+    /**
+     * Provides methods for working with a Cartesian2 defined in CZML.
+     *
+     * @exports CzmlCartesian2
+     *
+     * @see Cartesian2
+     * @see DynamicProperty
+     * @see CzmlBoolean
+     * @see CzmlCartesian3
+     * @see CzmlCartographic
+     * @see CzmlColor
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitCartesian3
+     * @see CzmlUnitQuaternion
+     * @see CzmlUnitSpherical
+     * @see CzmlVerticalOrigin
+     */
+    var CzmlCartesian2 = {
+        /**
+         * The number of doubles per packed Cartesian2 value.
+         */
+        doublesPerValue : doublesPerValue,
+
+        /**
+         * The number of doubles per packed value used for interpolation.
+         */
+        doublesPerInterpolationValue : doublesPerValue,
+
+        /**
+         * Returns the packed Cartesian2 representation contained within the provided CZML interval
+         * or undefined if the interval does not contain Cartesian2 data.
+         *
+         * @param {Object} czmlInterval The CZML interval to unwrap.
+         */
+        unwrapInterval : function(czmlInterval) {
+            return czmlInterval.cartesian2;
+        },
+
+        /**
+         * Returns true if this interval represents data that should be interpolated by the client
+         * or false if it's a single value.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlCartesian2.unwrapInterval.
+         */
+        isSampled : function(unwrappedInterval) {
+            return Array.isArray(unwrappedInterval) && unwrappedInterval.length > doublesPerValue;
+        },
+
+        /**
+         * Given a non-sampled unwrapped interval, returns a Cartesian2 instance of the data.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlCartesian2.unwrapInterval.
+         * @param {Cartesian2} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Cartesian2 instance if result was not defined.
+         */
+        getValue : function(unwrappedInterval, result) {
+            if (typeof result === 'undefined') {
+                result = new Cartesian2();
+            }
+            result.x = unwrappedInterval[0];
+            result.y = unwrappedInterval[1];
+            return result;
+        },
+
+        /**
+         * Given a packed array of x and y values, extracts a Cartesian2 instance.
+         *
+         * @param {Array} array A packed array of Cartesian2 values, where every two elements represents an x,y pair.
+         * @param {Number} startingIndex The index into the array that contains the x value of the Cartesian2 you would like.
+         * @param {Cartesian2} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Cartesian2 instance if result was not defined.
+         */
+        getValueFromArray : function(array, startingIndex, result) {
+            if (typeof result === 'undefined') {
+                result = new Cartesian2();
+            }
+            result.x = array[startingIndex];
+            result.y = array[startingIndex + 1];
+            return result;
+        }
+    };
+
+    return CzmlCartesian2;
+});

data/app/assets/javascripts/DynamicScene/CzmlCartesian3.js

@@ -0,0 +1,99 @@
+/*global define*/
+define([
+        '../Core/Cartesian3'
+       ], function(
+         Cartesian3) {
+    "use strict";
+
+    var doublesPerValue = 3;
+
+    /**
+     * Provides methods for working with a Cartesian3 defined in CZML.
+     *
+     * @exports CzmlCartesian3
+     *
+     * @see Cartesian3
+     * @see DynamicProperty
+     * @see DynamicPositionProperty
+     * @see CzmlBoolean
+     * @see CzmlCartesian2
+     * @see CzmlCartographic
+     * @see CzmlColor
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitCartesian3
+     * @see CzmlUnitQuaternion
+     * @see CzmlUnitSpherical
+     * @see CzmlVerticalOrigin
+     */
+    var CzmlCartesian3 = {
+         /**
+         * The number of doubles per packed Cartesian3 value.
+         */
+        doublesPerValue : doublesPerValue,
+
+        /**
+         * The number of doubles per packed value used for interpolation.
+         */
+        doublesPerInterpolationValue : doublesPerValue,
+
+        /**
+         * Returns the packed Cartesian3 representation contained within the provided CZML interval
+         * or undefined if the interval does not contain Cartesian3 data.
+         *
+         * @param {Object} czmlInterval The CZML interval to unwrap.
+         */
+        unwrapInterval : function(czmlInterval) {
+            return czmlInterval.cartesian;
+        },
+
+        /**
+         * Returns true if this interval represents data that should be interpolated by the client
+         * or false if it's a single value.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlCartesian3.unwrapInterval.
+         */
+        isSampled : function(unwrappedInterval) {
+            return Array.isArray(unwrappedInterval) && unwrappedInterval.length > doublesPerValue;
+        },
+
+        /**
+         * Given a non-sampled unwrapped interval, returns a Cartesian3 instance of the data.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlCartesian3.unwrapInterval.
+         * @param {Cartesian3} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Cartesian3 instance if result was not defined.
+         */
+        getValue : function(unwrappedInterval, result) {
+            if (typeof result === 'undefined') {
+                result = new Cartesian3();
+            }
+            result.x = unwrappedInterval[0];
+            result.y = unwrappedInterval[1];
+            result.z = unwrappedInterval[2];
+            return result;
+        },
+
+        /**
+         * Given a packed array of x, y, and z values, extracts a Cartesian3 instance.
+         *
+         * @param {Array} array A packed array of Cartesian3 values, where every three elements represents a Cartesian3.
+         * @param {Number} startingIndex The index into the array that contains the x value of the Cartesian3 you would like.
+         * @param {Cartesian3} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Cartesian3 instance if result was not defined.
+         */
+        getValueFromArray : function(array, startingIndex, result) {
+            if (typeof result === 'undefined') {
+                result = new Cartesian3();
+            }
+            result.x = array[startingIndex];
+            result.y = array[startingIndex + 1];
+            result.z = array[startingIndex + 2];
+            return result;
+        }
+    };
+
+    return CzmlCartesian3;
+});

data/app/assets/javascripts/DynamicScene/CzmlCartographic.js

@@ -0,0 +1,125 @@
+/*global define*/
+define([
+        '../Core/Cartographic',
+        '../Core/Math'
+       ], function(
+         Cartographic,
+         CesiumMath) {
+    "use strict";
+
+    var doublesPerValue = 3;
+
+    /**
+     * Provides methods for working with a Cartographic defined in CZML.
+     *
+     * @exports CzmlCartographic
+     *
+     * @see Cartographic
+     * @see DynamicProperty
+     * @see DynamicPositionProperty
+     * @see CzmlBoolean
+     * @see CzmlCartesian2
+     * @see CzmlCartesian3
+     * @see CzmlColor
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitCartesian3
+     * @see CzmlUnitQuaternion
+     * @see CzmlUnitSpherical
+     * @see CzmlVerticalOrigin
+     */
+    var CzmlCartographic = {
+        /**
+         * The number of doubles per packed Cartographic value.
+         */
+        doublesPerValue : doublesPerValue,
+
+        /**
+         * The number of doubles per packed value used for interpolation.
+         */
+        doublesPerInterpolationValue : doublesPerValue,
+
+        /**
+         * Returns the packed Cartographic representation contained within the provided CZML interval
+         * or undefined if the interval does not contain Cartographic data.
+         *
+         * @param {Object} czmlInterval The CZML interval to unwrap.
+         */
+        unwrapInterval : function(czmlInterval) {
+            var cartographic = czmlInterval.cartographicRadians;
+            if (typeof cartographic !== 'undefined') {
+                return cartographic;
+            }
+
+            var cartographicDegrees = czmlInterval.cartographicDegrees;
+            if (typeof cartographicDegrees === 'undefined') {
+                return undefined;
+            }
+
+            if (!this.isSampled(cartographicDegrees)) {
+                return [CesiumMath.toRadians(cartographicDegrees[0]),
+                        CesiumMath.toRadians(cartographicDegrees[1]),
+                        cartographicDegrees[2]];
+            }
+
+            var len = cartographicDegrees.length;
+            cartographic = new Array(len);
+            for ( var i = 0; i < len; i += 4) {
+                cartographic[i] = cartographicDegrees[i];
+                cartographic[i + 1] = CesiumMath.toRadians(cartographicDegrees[i + 1]);
+                cartographic[i + 2] = CesiumMath.toRadians(cartographicDegrees[i + 2]);
+                cartographic[i + 3] = cartographicDegrees[i + 3];
+            }
+            return cartographic;
+        },
+
+        /**
+         * Returns true if this interval represents data that should be interpolated by the client
+         * or false if it's a single value.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlCartographic.unwrapInterval.
+         */
+        isSampled : function(unwrappedInterval) {
+            return Array.isArray(unwrappedInterval) && unwrappedInterval.length > doublesPerValue;
+        },
+
+        /**
+         * Given a non-sampled unwrapped interval, returns a Cartographic instance of the data.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlCartographic.unwrapInterval.
+         * @param {Cartographic} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Cartographic instance if result was not defined.
+         */
+        getValue : function(unwrappedInterval, result) {
+            if (typeof result === 'undefined') {
+                result = new Cartographic();
+            }
+            result.longitude = unwrappedInterval[0];
+            result.latitude = unwrappedInterval[1];
+            result.height = unwrappedInterval[2];
+            return result;
+        },
+
+        /**
+         * Given a packed array of longitude, latitude, and height values, extracts a Cartographic instance.
+         *
+         * @param {Array} array A packed array of Cartographic values, where every three elements represents a Cartographic.
+         * @param {Number} startingIndex The index into the array that contains the longitude value of the Cartographic you would like.
+         * @param {Cartographic} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Cartographic instance if result was not defined.
+         */
+        getValueFromArray : function(array, startingIndex, result) {
+            if (typeof result === 'undefined') {
+                result = new Cartographic();
+            }
+            result.longitude = array[startingIndex];
+            result.latitude = array[startingIndex + 1];
+            result.height = array[startingIndex + 2];
+            return result;
+        }
+    };
+
+    return CzmlCartographic;
+});

data/app/assets/javascripts/DynamicScene/CzmlColor.js

@@ -0,0 +1,127 @@
+/*global define*/
+define([
+        '../Core/Color'
+       ], function(
+         Color) {
+    "use strict";
+
+    var doublesPerValue = 4;
+
+    /**
+     * Provides methods for working with a Color defined in CZML.
+     *
+     * @exports CzmlColor
+     *
+     * @see Color
+     * @see DynamicProperty
+     * @see DynamicPositionProperty
+     * @see CzmlBoolean
+     * @see CzmlCartesian2
+     * @see CzmlCartesian3
+     * @see CzmlCartographic
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitCartesian3
+     * @see CzmlUnitQuaternion
+     * @see CzmlUnitSpherical
+     * @see CzmlVerticalOrigin
+     */
+    var CzmlColor = {
+        /**
+         * The number of doubles per packed Color value.
+         */
+        doublesPerValue : doublesPerValue,
+
+        /**
+         * The number of doubles per packed value used for interpolation.
+         */
+        doublesPerInterpolationValue : doublesPerValue,
+
+        /**
+         * Returns the packed Color representation contained within the provided CZML interval
+         * or undefined if the interval does not contain Color data.
+         *
+         * @param {Object} czmlInterval The CZML interval to unwrap.
+         */
+        unwrapInterval : function(czmlInterval) {
+            var rgbaf = czmlInterval.rgbaf;
+            if (typeof rgbaf !== 'undefined') {
+                return rgbaf;
+            }
+
+            var rgba = czmlInterval.rgba;
+            if (typeof rgba === 'undefined') {
+                return undefined;
+            }
+
+            if (!this.isSampled(rgba)) {
+                return [Color.byteToFloat(rgba[0]),
+                        Color.byteToFloat(rgba[1]),
+                        Color.byteToFloat(rgba[2]),
+                        Color.byteToFloat(rgba[3])];
+            }
+
+            var len = rgba.length;
+            rgbaf = new Array(len);
+            for ( var i = 0; i < len; i += 5) {
+                rgbaf[i] = rgba[i];
+                rgbaf[i + 1] = Color.byteToFloat(rgba[i + 1]);
+                rgbaf[i + 2] = Color.byteToFloat(rgba[i + 2]);
+                rgbaf[i + 3] = Color.byteToFloat(rgba[i + 3]);
+                rgbaf[i + 4] = Color.byteToFloat(rgba[i + 4]);
+            }
+            return rgbaf;
+        },
+
+        /**
+         * Returns true if this interval represents data that should be interpolated by the client
+         * or false if it's a single value.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlColor.unwrapInterval.
+         */
+        isSampled : function(unwrappedInterval) {
+            return Array.isArray(unwrappedInterval) && unwrappedInterval.length > doublesPerValue;
+        },
+
+        /**
+         * Given a non-sampled unwrapped interval, returns a Color instance of the data.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlColor.unwrapInterval.
+         * @param {Color} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Color instance if result was not defined.
+         */
+        getValue : function(unwrappedInterval, result) {
+            if (typeof result === 'undefined') {
+                result = new Color();
+            }
+            result.red = unwrappedInterval[0];
+            result.green = unwrappedInterval[1];
+            result.blue = unwrappedInterval[2];
+            result.alpha = unwrappedInterval[3];
+            return result;
+        },
+
+
+        /**
+         * Given a packed array of red, green, blue, and alpha values, extracts a Color instance.
+         *
+         * @param {Array} array A packed array of Color values, where every four elements represents a Color.
+         * @param {Number} startingIndex The index into the array that contains the red value of the Color you would like.
+         * @param {Color} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Color instance if result was not defined.
+         */
+        getValueFromArray : function(array, startingIndex, result) {
+            if (typeof result === 'undefined') {
+                result = new Color();
+            }
+            result.red = array[startingIndex];
+            result.green = array[startingIndex + 1];
+            result.blue = array[startingIndex + 2];
+            result.alpha = array[startingIndex + 3];
+            return result;
+        }
+    };
+    return CzmlColor;
+});