cesium 0.13.0

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

@@ -0,0 +1,352 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/JulianDate',
+        '../Core/TimeInterval',
+        '../Core/TimeIntervalCollection',
+        '../Core/Iso8601',
+        '../Core/binarySearch',
+        '../Core/HermitePolynomialApproximation',
+        '../Core/LinearApproximation',
+        '../Core/LagrangePolynomialApproximation'
+    ], function(
+        DeveloperError,
+        JulianDate,
+        TimeInterval,
+        TimeIntervalCollection,
+        Iso8601,
+        binarySearch,
+        HermitePolynomialApproximation,
+        LinearApproximation,
+        LagrangePolynomialApproximation) {
+    "use strict";
+
+
+    //CZML_TODO This is more of an idea than a to-do, but currently DynamicProperty requires
+    //you know the type of data being loaded up-front by passing valueType.  We could take
+    //a similar approach to DynamicMaterialProperty and have a list of potential valueTypes
+    //that we check for when we encounter data.  This would make it possible to support
+    //properties that are defined in a CZML document but not part of the official spec.  This
+    //would be helpful in cases where a CZML document has $ or # links to other properties,
+    //but that property itself is not part of another to-spec CZML object.  We could still
+    //allow the user to pass a default valueType if they want to make sure the data
+    //being processed is only the data of the expected type.
+
+    //Map CZML interval types to their implementation.
+    var interpolators = {
+        HERMITE : HermitePolynomialApproximation,
+        LAGRANGE : LagrangePolynomialApproximation,
+        LINEAR : LinearApproximation
+    };
+
+    //The data associated with each DynamicProperty interval.
+    function IntervalData() {
+        this.interpolationAlgorithm = LinearApproximation;
+        this.numberOfPoints = LinearApproximation.getRequiredDataPoints(1);
+        this.interpolationDegree = 1;
+        this.times = undefined;
+        this.values = undefined;
+        this.isSampled = false;
+        this.xTable = undefined;
+        this.yTable = undefined;
+    }
+
+    //Converts a CZML defined data into a JulianDate, regardless of whether it was
+    //specified in epoch seconds or as an ISO8601 string.
+    function czmlDateToJulianDate(date, epoch) {
+        if (typeof date === 'string') {
+            return JulianDate.fromIso8601(date);
+        }
+        return epoch.addSeconds(date);
+    }
+
+    /**
+     * <p>
+     * DynamicProperty represents a single value that changes over time.
+     * Rather than creating instances of this object directly, it's typically
+     * created and managed via loading CZML data into a DynamicObjectCollection.
+     * Instances of this type are exposed via DynamicObject and it's sub-objects
+     * and are responsible for interpreting and interpolating the data for visualization.
+     * </p>
+     * <p>
+     * The type of value exposed by this property must be provided during construction
+     * by passing in an object which performs all the necessary operations needed to
+     * properly store, retrieve, and interpolate the data.  For more specialized needs
+     * other types of dynamic properties exist, such as DynamicMaterialProperty,
+     * which as the name implies, handles materials.
+     * </p>
+     *
+     * @alias DynamicProperty
+     * @constructor
+     *
+     * @param {Object} valueType A CZML type object which contains the methods needed to interpret and interpolate CZML data of the same type.
+     *
+     * @see CzmlBoolean
+     * @see CzmlCartesian2
+     * @see CzmlCartesian3
+     * @see CzmlCartographic
+     * @see CzmlColor
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitCartesian3
+     * @see CzmlUnitQuaternion
+     * @see CzmlUnitSpherical
+     * @see CzmlVerticalOrigin
+     * @see DynamicObject
+     * @see ReferenceProperty
+     * @see DynamicMaterialProperty
+     * @see DynamicPositionProperty
+     * @see DynamicDirectionsProperty
+     * @see DynamicVertexPositionsProperty
+     */
+    var DynamicProperty = function(valueType) {
+        if (typeof valueType === 'undefined') {
+            throw new DeveloperError('valueType is required.');
+        }
+        this.valueType = valueType;
+        this._intervals = new TimeIntervalCollection();
+        this._cachedDate = undefined;
+        this._cachedInterval = undefined;
+    };
+
+    /**
+     * Processes the provided CZML interval or intervals into this property.
+     *
+     * @memberof DynamicProperty
+     *
+     * @param {Object} czmlIntervals The CZML data to process.
+     * @param {TimeInterval} [constrainedInterval] Constrains the processing so that any times outside of this interval are ignored.
+     * @param {String} [sourceUri] The originating url of the CZML being processed.
+     */
+    DynamicProperty.prototype.processCzmlIntervals = function(czmlIntervals, constrainedInterval, sourceUri) {
+        if (Array.isArray(czmlIntervals)) {
+            for ( var i = 0, len = czmlIntervals.length; i < len; i++) {
+                this._addCzmlInterval(czmlIntervals[i], constrainedInterval, sourceUri);
+            }
+        } else {
+            this._addCzmlInterval(czmlIntervals, constrainedInterval, sourceUri);
+        }
+    };
+
+    /**
+     * Returns the value of the property at the specified time.
+     * @memberof DynamicProperty
+     *
+     * @param {JulianDate} time The time for which to retrieve the value.
+     * @param {Object} [result] The object to store the value into, if omitted, a new instance is created and returned.
+     * @returns The modified result parameter or a new instance if the result parameter was not supplied.
+     */
+    DynamicProperty.prototype.getValue = function(time, result) {
+        var interval = this._cachedInterval;
+        var thisValueType = this.valueType;
+        var doublesPerValue = thisValueType.doublesPerValue;
+
+        if (this._cachedDate !== time) {
+            this._cachedDate = time;
+            if (typeof interval === 'undefined' || !interval.contains(time)) {
+                interval = this._intervals.findIntervalContainingDate(time);
+                this._cachedInterval = interval;
+            }
+        }
+
+        if (typeof interval === 'undefined') {
+            return undefined;
+        }
+
+        var intervalData = interval.data;
+        var times = intervalData.times;
+        var values = intervalData.values;
+        if (intervalData.isSampled && times.length >= 0 && values.length > 0) {
+            var index = binarySearch(times, time, JulianDate.compare);
+            if (index < 0) {
+                if (intervalData.numberOfPoints < 2) {
+                    return undefined;
+                }
+                index = ~index;
+
+                if (index >= times.length) {
+                    index = times.length - 1;
+                }
+
+                var firstIndex = 0;
+                var lastIndex = times.length - 1;
+
+                var degree = intervalData.numberOfPoints - 1;
+                var pointsInCollection = lastIndex - firstIndex + 1;
+
+                if (pointsInCollection < degree + 1) {
+                    // Use the entire range.
+                } else {
+                    var computedFirstIndex = index - ((degree / 2) | 0) - 1;
+                    if (computedFirstIndex < firstIndex) {
+                        computedFirstIndex = firstIndex;
+                    }
+                    var computedLastIndex = computedFirstIndex + degree;
+                    if (computedLastIndex > lastIndex) {
+                        computedLastIndex = lastIndex;
+                        computedFirstIndex = computedLastIndex - degree;
+                        if (computedFirstIndex < firstIndex) {
+                            computedFirstIndex = firstIndex;
+                        }
+                    }
+
+                    firstIndex = computedFirstIndex;
+                    lastIndex = computedLastIndex;
+                }
+
+                var length = lastIndex - firstIndex + 1;
+
+                var doublesPerInterpolationValue = thisValueType.doublesPerInterpolationValue;
+                var xTable = intervalData.xTable;
+                var yTable = intervalData.yTable;
+
+                if (typeof xTable === 'undefined') {
+                    xTable = intervalData.xTable = new Array(intervalData.numberOfPoints);
+                    yTable = intervalData.yTable = new Array(intervalData.numberOfPoints * doublesPerInterpolationValue);
+                }
+
+                // Build the tables
+                for ( var i = 0; i < length; ++i) {
+                    xTable[i] = times[lastIndex].getSecondsDifference(times[firstIndex + i]);
+                }
+                var specializedPackFunction = thisValueType.packValuesForInterpolation;
+                if (typeof specializedPackFunction === 'undefined') {
+                    var destinationIndex = 0;
+                    var sourceIndex = firstIndex * doublesPerValue;
+                    var stop = (lastIndex + 1) * doublesPerValue;
+
+                    while (sourceIndex < stop) {
+                        yTable[destinationIndex] = values[sourceIndex];
+                        sourceIndex++;
+                        destinationIndex++;
+                    }
+                } else {
+                    specializedPackFunction(values, yTable, firstIndex, lastIndex);
+                }
+
+                // Interpolate!
+                var x = times[lastIndex].getSecondsDifference(time);
+                var interpolationResult = intervalData.interpolationAlgorithm.interpolateOrderZero(x, xTable, yTable, doublesPerInterpolationValue);
+
+                var specializedGetFunction = thisValueType.getValueFromInterpolationResult;
+                if (typeof specializedGetFunction === 'undefined') {
+                    return thisValueType.getValueFromArray(interpolationResult, 0, result);
+                }
+                return specializedGetFunction(interpolationResult, result, values, firstIndex, lastIndex);
+            }
+            return thisValueType.getValueFromArray(intervalData.values, index * doublesPerValue, result);
+        }
+        return thisValueType.getValue(intervalData.values, result);
+    };
+
+    DynamicProperty._mergeNewSamples = function(epoch, times, values, newData, doublesPerValue, valueType) {
+        var newDataIndex = 0, i, prevItem, timesInsertionPoint, valuesInsertionPoint, timesSpliceArgs, valuesSpliceArgs, currentTime, nextTime;
+        while (newDataIndex < newData.length) {
+            currentTime = czmlDateToJulianDate(newData[newDataIndex], epoch);
+            timesInsertionPoint = binarySearch(times, currentTime, JulianDate.compare);
+
+            if (timesInsertionPoint < 0) {
+                //Doesn't exist, insert as many additional values as we can.
+                timesInsertionPoint = ~timesInsertionPoint;
+                timesSpliceArgs = [timesInsertionPoint, 0];
+
+                valuesInsertionPoint = timesInsertionPoint * doublesPerValue;
+                valuesSpliceArgs = [valuesInsertionPoint, 0];
+                prevItem = undefined;
+                nextTime = times[timesInsertionPoint + 1];
+                while (newDataIndex < newData.length) {
+                    currentTime = czmlDateToJulianDate(newData[newDataIndex], epoch);
+                    if ((typeof prevItem !== 'undefined' && JulianDate.compare(prevItem, currentTime) >= 0) ||
+                        (typeof nextTime !== 'undefined' && JulianDate.compare(currentTime, nextTime) >= 0)) {
+                        break;
+                    }
+                    timesSpliceArgs.push(currentTime);
+                    newDataIndex = newDataIndex + 1;
+                    for (i = 0; i < doublesPerValue; i++) {
+                        valuesSpliceArgs.push(newData[newDataIndex]);
+                        newDataIndex = newDataIndex + 1;
+                    }
+                    prevItem = currentTime;
+                }
+
+                Array.prototype.splice.apply(values, valuesSpliceArgs);
+                Array.prototype.splice.apply(times, timesSpliceArgs);
+            } else {
+                //Found an exact match
+                for (i = 0; i < doublesPerValue; i++) {
+                    newDataIndex++;
+                    values[(timesInsertionPoint * doublesPerValue) + i] = newData[newDataIndex];
+                }
+                newDataIndex++;
+            }
+        }
+    };
+
+    DynamicProperty.prototype._addCzmlInterval = function(czmlInterval, constrainedInterval, sourceUri) {
+        var iso8601Interval = czmlInterval.interval;
+        if (typeof iso8601Interval === 'undefined') {
+            iso8601Interval = Iso8601.MAXIMUM_INTERVAL;
+        } else {
+            iso8601Interval = TimeInterval.fromIso8601(iso8601Interval);
+        }
+
+        if (typeof constrainedInterval !== 'undefined') {
+            iso8601Interval = iso8601Interval.intersect(constrainedInterval);
+        }
+
+        var unwrappedInterval = this.valueType.unwrapInterval(czmlInterval, sourceUri);
+        if (typeof unwrappedInterval !== 'undefined') {
+            this._addCzmlIntervalUnwrapped(iso8601Interval.start, iso8601Interval.stop, unwrappedInterval, czmlInterval.epoch, czmlInterval.interpolationAlgorithm, czmlInterval.interpolationDegree);
+        }
+    };
+
+    DynamicProperty.prototype._addCzmlIntervalUnwrapped = function(start, stop, unwrappedInterval, epoch, interpolationAlgorithmType, interpolationDegree) {
+        var thisIntervals = this._intervals;
+        var existingInterval = thisIntervals.findInterval(start, stop);
+        this._cachedDate = undefined;
+        this._cachedInterval = undefined;
+
+        var intervalData;
+        if (typeof existingInterval === 'undefined') {
+            intervalData = new IntervalData();
+            existingInterval = new TimeInterval(start, stop, true, true, intervalData);
+            thisIntervals.addInterval(existingInterval);
+        } else {
+            intervalData = existingInterval.data;
+        }
+
+        var thisValueType = this.valueType;
+        if (thisValueType.isSampled(unwrappedInterval)) {
+            var interpolationAlgorithm;
+            if (typeof interpolationAlgorithmType !== 'undefined') {
+                interpolationAlgorithm = interpolators[interpolationAlgorithmType];
+                intervalData.interpolationAlgorithm = interpolationAlgorithm;
+            }
+            if (typeof interpolationAlgorithm !== 'undefined' && typeof interpolationDegree !== 'undefined') {
+                intervalData.interpolationDegree = interpolationDegree;
+                intervalData.xTable = undefined;
+                intervalData.yTable = undefined;
+            }
+
+            if (!intervalData.isSampled) {
+                intervalData.times = [];
+                intervalData.values = [];
+                intervalData.isSampled = true;
+            }
+            if (typeof epoch !== 'undefined') {
+                epoch = JulianDate.fromIso8601(epoch);
+            }
+            DynamicProperty._mergeNewSamples(epoch, intervalData.times, intervalData.values, unwrappedInterval, thisValueType.doublesPerValue, thisValueType);
+            intervalData.numberOfPoints = Math.min(intervalData.interpolationAlgorithm.getRequiredDataPoints(intervalData.interpolationDegree), intervalData.times.length);
+        } else {
+            //Packet itself is a constant value
+            intervalData.times = undefined;
+            intervalData.values = unwrappedInterval;
+            intervalData.isSampled = false;
+        }
+    };
+
+    return DynamicProperty;
+});

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

@@ -0,0 +1,204 @@
+/*global define*/
+define([
+        '../Core/TimeInterval',
+        '../Core/defaultValue',
+        './CzmlBoolean',
+        './CzmlNumber',
+        './CzmlColor',
+        './DynamicProperty',
+        './DynamicDirectionsProperty',
+        './DynamicMaterialProperty'
+    ], function(
+        TimeInterval,
+        defaultValue,
+        CzmlBoolean,
+        CzmlNumber,
+        CzmlColor,
+        DynamicProperty,
+        DynamicDirectionsProperty,
+        DynamicMaterialProperty) {
+    "use strict";
+
+    /**
+     * Represents a time-dynamic pyramid, typically used in conjunction with DynamicPyramidVisualizer and
+     * DynamicObjectCollection to visualize CZML.
+     *
+     * @alias DynamicPyramid
+     * @constructor
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see DynamicPyramidVisualizer
+     * @see VisualizerCollection
+     * @see CustomSensor
+     * @see CzmlDefaults
+     */
+    var DynamicPyramid = function() {
+        /**
+         * A DynamicProperty of type CzmlBoolean which determines the pyramid's visibility.
+         * @type DynamicProperty
+         */
+        this.show = undefined;
+        /**
+         * A DynamicDirectionsProperty which determines the projection of the pyramid.
+         * @type DynamicDirectionsProperty
+         */
+        this.directions = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the pyramid's radius.
+         * @type DynamicProperty
+         */
+        this.radius = undefined;
+        /**
+         * A DynamicProperty of type CzmlBoolean which determines the pyramid's intersection visibility.
+         * @type DynamicProperty
+         */
+        this.showIntersection = undefined;
+        /**
+         * A DynamicProperty of type CzmlColor which determines the color of the line formed by the intersection of the pyramid and other central bodies.
+         * @type DynamicProperty
+         */
+        this.intersectionColor = undefined;
+        /**
+         * A DynamicMaterialProperty which determines the material.
+         * @type DynamicMaterialProperty
+         */
+        this.material = undefined;
+    };
+
+    /**
+     * Processes a single CZML packet and merges its data into the provided DynamicObject's pyramid.
+     * If the DynamicObject does not have a pyramid, one is created.  This method is not
+     * normally called directly, but is part of the array of CZML processing functions that is
+     * passed into the DynamicObjectCollection constructor.
+     *
+     * @param {DynamicObject} dynamicObject The DynamicObject which will contain the pyramid data.
+     * @param {Object} packet The CZML packet to process.
+     * @param {DynamicObject} dynamicObjectCollection The DynamicObjectCollection to which the DynamicObject belongs.
+     *
+     * @returns {Boolean} true if any new properties were created while processing the packet, false otherwise.
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see CzmlDefaults#updaters
+     */
+    DynamicPyramid.processCzmlPacket = function(dynamicObject, packet, dynamicObjectCollection) {
+        var pyramidData = packet.pyramid;
+        if (typeof pyramidData === 'undefined') {
+            return false;
+        }
+
+        var pyramidUpdated = false;
+        var pyramid = dynamicObject.pyramid;
+        pyramidUpdated = typeof pyramid === 'undefined';
+        if (pyramidUpdated) {
+            dynamicObject.pyramid = pyramid = new DynamicPyramid();
+        }
+
+        var interval = pyramidData.interval;
+        if (typeof interval !== 'undefined') {
+            interval = TimeInterval.fromIso8601(interval);
+        }
+
+        if (typeof pyramidData.show !== 'undefined') {
+            var show = pyramid.show;
+            if (typeof show === 'undefined') {
+                pyramid.show = show = new DynamicProperty(CzmlBoolean);
+                pyramidUpdated = true;
+            }
+            show.processCzmlIntervals(pyramidData.show, interval);
+        }
+
+        if (typeof pyramidData.radius !== 'undefined') {
+            var radius = pyramid.radius;
+            if (typeof radius === 'undefined') {
+                pyramid.radius = radius = new DynamicProperty(CzmlNumber);
+                pyramidUpdated = true;
+            }
+            radius.processCzmlIntervals(pyramidData.radius, interval);
+        }
+
+        if (typeof pyramidData.showIntersection !== 'undefined') {
+            var showIntersection = pyramid.showIntersection;
+            if (typeof showIntersection === 'undefined') {
+                pyramid.showIntersection = showIntersection = new DynamicProperty(CzmlBoolean);
+                pyramidUpdated = true;
+            }
+            showIntersection.processCzmlIntervals(pyramidData.showIntersection, interval);
+        }
+
+        if (typeof pyramidData.intersectionColor !== 'undefined') {
+            var intersectionColor = pyramid.intersectionColor;
+            if (typeof intersectionColor === 'undefined') {
+                pyramid.intersectionColor = intersectionColor = new DynamicProperty(CzmlColor);
+                pyramidUpdated = true;
+            }
+            intersectionColor.processCzmlIntervals(pyramidData.intersectionColor, interval);
+        }
+
+        if (typeof pyramidData.material !== 'undefined') {
+            var material = pyramid.material;
+            if (typeof material === 'undefined') {
+                pyramid.material = material = new DynamicMaterialProperty();
+                pyramidUpdated = true;
+            }
+            material.processCzmlIntervals(pyramidData.material, interval);
+        }
+
+        if (typeof pyramidData.directions !== 'undefined') {
+            var directions = pyramid.directions;
+            if (typeof directions === 'undefined') {
+                pyramid.directions = directions = new DynamicDirectionsProperty();
+                pyramidUpdated = true;
+            }
+            directions.processCzmlIntervals(pyramidData.directions, interval);
+        }
+        return pyramidUpdated;
+    };
+
+    /**
+     * Given two DynamicObjects, takes the pyramid properties from the second
+     * and assigns them to the first, assuming such a property did not already exist.
+     * This method is not normally called directly, but is part of the array of CZML processing
+     * functions that is passed into the CompositeDynamicObjectCollection constructor.
+     *
+     * @param {DynamicObject} targetObject The DynamicObject which will have properties merged onto it.
+     * @param {DynamicObject} objectToMerge The DynamicObject containing properties to be merged.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicPyramid.mergeProperties = function(targetObject, objectToMerge) {
+        var pyramidToMerge = objectToMerge.pyramid;
+        if (typeof pyramidToMerge !== 'undefined') {
+
+            var targetPyramid = targetObject.pyramid;
+            if (typeof targetPyramid === 'undefined') {
+                targetObject.pyramid = targetPyramid = new DynamicPyramid();
+            }
+
+            targetPyramid.show = defaultValue(targetPyramid.show, pyramidToMerge.show);
+            targetPyramid.directions = defaultValue(targetPyramid.directions, pyramidToMerge.directions);
+            targetPyramid.radius = defaultValue(targetPyramid.radius, pyramidToMerge.radius);
+            targetPyramid.showIntersection = defaultValue(targetPyramid.showIntersection, pyramidToMerge.showIntersection);
+            targetPyramid.intersectionColor = defaultValue(targetPyramid.intersectionColor, pyramidToMerge.intersectionColor);
+            targetPyramid.material = defaultValue(targetPyramid.material, pyramidToMerge.material);
+        }
+    };
+
+    /**
+     * Given a DynamicObject, undefines the pyramid associated with it.
+     * This method is not normally called directly, but is part of the array of CZML processing
+     * functions that is passed into the CompositeDynamicObjectCollection constructor.
+     *
+     * @param {DynamicObject} dynamicObject The DynamicObject to remove the pyramid from.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicPyramid.undefineProperties = function(dynamicObject) {
+        dynamicObject.pyramid = undefined;
+    };
+
+    return DynamicPyramid;
+});