cesium 0.13.0

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

@@ -0,0 +1,99 @@
+/*global define*/
+define([
+        '../Core/Cartesian3'
+       ], function(
+         Cartesian3) {
+    "use strict";
+
+    var doublesPerValue = 3;
+
+    /**
+     * Provides methods for working with a unit Cartesian3 defined in CZML.
+     *
+     * @exports CzmlUnitCartesian3
+     *
+     * @see Cartesian3
+     * @see DynamicProperty
+     * @see DynamicPositionProperty
+     * @see CzmlBoolean
+     * @see CzmlCartesian2
+     * @see CzmlCartesian3
+     * @see CzmlCartographic
+     * @see CzmlColor
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitQuaternion
+     * @see CzmlUnitSpherical
+     * @see CzmlVerticalOrigin
+     */
+    var CzmlUnitCartesian3 = {
+         /**
+         * 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.unitCartesian;
+        },
+
+        /**
+         * 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 CzmlUnitCartesian3.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 CzmlUnitCartesian3.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.normalize(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.normalize(result);
+        }
+    };
+
+    return CzmlUnitCartesian3;
+});

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

@@ -0,0 +1,172 @@
+/*global define*/
+define([
+        '../Core/Quaternion',
+        '../Core/Cartesian3'
+    ], function(
+        Quaternion,
+        Cartesian3) {
+    "use strict";
+
+    var doublesPerCartesian = 3;
+    var doublesPerQuaternion = 4;
+    var axis = new Cartesian3();
+    var rotationVector = new Cartesian3();
+    var tmpQuaternion = new Quaternion();
+    var quaternion0 = new Quaternion();
+    var quaternion0Conjugate = new Quaternion();
+
+    /**
+     * Provides methods for working with a unit Quaternion defined in CZML.
+     *
+     * @exports CzmlUnitQuaternion
+     *
+     * @see Quaternion
+     * @see DynamicProperty
+     * @see CzmlBoolean
+     * @see CzmlCartesian2
+     * @see CzmlCartesian3
+     * @see CzmlCartographic
+     * @see CzmlColor
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitCartesian3
+     * @see CzmlUnitSpherical
+     * @see CzmlVerticalOrigin
+     */
+    var CzmlUnitQuaternion = {
+        /**
+         * The number of doubles per packed Quaternion value.
+         */
+        doublesPerValue : doublesPerQuaternion,
+
+        /**
+         * The number of doubles per packed value used for interpolation.
+         */
+        doublesPerInterpolationValue : doublesPerCartesian,
+
+        /**
+         * Returns the packed Quaternion representation contained within the provided CZML interval
+         * or undefined if the interval does not contain Quaternion data.
+         *
+         * @param {Object} czmlInterval The CZML interval to unwrap.
+         */
+        unwrapInterval : function(czmlInterval) {
+            return czmlInterval.unitQuaternion;
+        },
+
+        /**
+         * 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 CzmlUnitQuaternion.unwrapInterval.
+         */
+        isSampled : function(unwrappedInterval) {
+            return Array.isArray(unwrappedInterval) && unwrappedInterval.length > doublesPerQuaternion;
+        },
+
+        /**
+         * Given a packed array of x, y, z, and w values, creates a packed array of
+         * Cartesian3 axis-angle rotations suitable for interpolation.
+         *
+         * @param {Array} sourceArray The packed array of quaternion values.
+         * @param {Array} destinationArray The array to store the packed axis-angle rotations.
+         * @param {Number} firstIndex The index of the first element to be packed.
+         * @param {Number} lastIndex The index of the last element to be packed.
+         */
+        packValuesForInterpolation : function(sourceArray, destinationArray, firstIndex, lastIndex) {
+            CzmlUnitQuaternion.getValueFromArray(sourceArray, lastIndex * doublesPerQuaternion, quaternion0Conjugate);
+            quaternion0Conjugate.conjugate(quaternion0Conjugate);
+
+            for ( var i = 0, len = lastIndex - firstIndex + 1; i < len; i++) {
+                var offset = i * doublesPerCartesian;
+                CzmlUnitQuaternion.getValueFromArray(sourceArray, (firstIndex + i) * doublesPerQuaternion, tmpQuaternion);
+
+                tmpQuaternion.multiply(quaternion0Conjugate, tmpQuaternion);
+
+                if (tmpQuaternion.w < 0) {
+                    tmpQuaternion.negate(tmpQuaternion);
+                }
+
+                tmpQuaternion.getAxis(axis);
+                var angle = tmpQuaternion.getAngle();
+                destinationArray[offset] = axis.x * angle;
+                destinationArray[offset + 1] = axis.y * angle;
+                destinationArray[offset + 2] = axis.z * angle;
+            }
+        },
+
+        /**
+         * Given a non-sampled unwrapped interval, returns a Quaternion instance of the data.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlUnitQuaternion.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 Quaternion instance if result was not defined.
+         */
+        getValue : function(unwrappedInterval, result) {
+            if (typeof result === 'undefined') {
+                result = new Quaternion();
+            }
+            result.x = unwrappedInterval[0];
+            result.y = unwrappedInterval[1];
+            result.z = unwrappedInterval[2];
+            result.w = unwrappedInterval[3];
+            return result.normalize(result);
+        },
+
+        /**
+         * Given a packed array of x, y, z, and w values, extracts a Quaternion instance.
+         *
+         * @param {Array} array A packed array of Quaternion values, where every four elements represents a Cartesian3.
+         * @param {Number} startingIndex The index into the array that contains the x value of the Quaternion 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 Quaternion instance if result was not defined.
+         */
+        getValueFromArray : function(array, startingIndex, result) {
+            if (typeof result === 'undefined') {
+                result = new Quaternion();
+            }
+            result.x = array[startingIndex];
+            result.y = array[startingIndex + 1];
+            result.z = array[startingIndex + 2];
+            result.w = array[startingIndex + 3];
+            return result.normalize(result);
+        },
+
+        /**
+         * Given a packed array of axis-angle rotations returned from CzmlUnitQuaternion.packValuesForInterpolation,
+         * converts the desired index into a unit Quaternion.
+         *
+         * @param {Array} array The array containing the packed axis-angle rotations.
+         * @param {Quaternion} result The object to store the result in, if undefined a new instance will be created.
+         * @param {Array} sourceArray The source array of the original Quaternion values previously passed to CzmlUnitQuaternion.packValuesForInterpolation.
+         * @param {Number} firstIndex The index previously passed to CzmlUnitQuaternion.packValuesForInterpolation.
+         * @param {Number} lastIndex The index previously passed to CzmlUnitQuaternion.packValuesForInterpolation
+         * @returns The modified result parameter or a new Quaternion instance if result was not defined.
+         */
+        getValueFromInterpolationResult : function(array, result, sourceArray, firstIndex, lastIndex) {
+            if (typeof result === 'undefined') {
+                result = new Quaternion();
+            }
+            rotationVector.x = array[0];
+            rotationVector.y = array[1];
+            rotationVector.z = array[2];
+            var magnitude = rotationVector.magnitude();
+
+            CzmlUnitQuaternion.getValueFromArray(sourceArray, lastIndex * doublesPerQuaternion, quaternion0);
+
+            if (magnitude === 0) {
+                //Can't just use Quaternion.IDENTITY here because tmpQuaternion may be modified in the future.
+                tmpQuaternion.x = tmpQuaternion.y = tmpQuaternion.z = 0.0;
+                tmpQuaternion.w = 1.0;
+            } else {
+                Quaternion.fromAxisAngle(rotationVector, magnitude, tmpQuaternion);
+            }
+
+            return result.normalize(tmpQuaternion.multiply(quaternion0, result), result);
+        }
+    };
+
+    return CzmlUnitQuaternion;
+});

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

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

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

@@ -0,0 +1,59 @@
+/*global define*/
+define([
+        '../Scene/VerticalOrigin'
+       ], function(
+         VerticalOrigin) {
+    "use strict";
+
+    /**
+     * Provides methods for working with a vertical origin defined in CZML.
+     *
+     * @exports CzmlVerticalOrigin
+     *
+     * @see VerticalOrigin
+     * @see DynamicProperty
+     * @see CzmlBoolean
+     * @see CzmlCartesian2
+     * @see CzmlCartesian3
+     * @see CzmlCartographic
+     * @see CzmlColor
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitCartesian3
+     * @see CzmlUnitQuaternion
+     * @see CzmlUnitSpherical
+     */
+    var CzmlVerticalOrigin = {
+        /**
+         * Returns the packed enum representation contained within the provided CZML interval
+         * or undefined if the interval does not contain enum data.
+         *
+         * @param {Object} czmlInterval The CZML interval to unwrap.
+         */
+        unwrapInterval : function(czmlInterval) {
+            var result = czmlInterval.verticalOrigin;
+            return typeof result === 'undefined' ? czmlInterval : result;
+        },
+
+        /**
+         * Since enums can not be sampled, this method always returns false.
+         */
+        isSampled : function() {
+            return false;
+        },
+
+        /**
+         * Returns the VerticalOrigin contained within the unwrappedInterval.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlVerticalOrigin.unwrapInterval.
+         * @returns The VerticalOrigin value.
+         */
+        getValue : function(unwrappedInterval) {
+            return VerticalOrigin[unwrappedInterval];
+        }
+    };
+
+    return CzmlVerticalOrigin;
+});

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

@@ -0,0 +1,245 @@
+/*global define*/
+define([
+        '../Core/TimeInterval',
+        '../Core/defaultValue',
+        './CzmlBoolean',
+        './CzmlCartesian2',
+        './CzmlCartesian3',
+        './CzmlNumber',
+        './CzmlImage',
+        './CzmlHorizontalOrigin',
+        './CzmlVerticalOrigin',
+        './CzmlColor',
+        './DynamicProperty'
+    ], function(
+        TimeInterval,
+        defaultValue,
+        CzmlBoolean,
+        CzmlCartesian2,
+        CzmlCartesian3,
+        CzmlNumber,
+        CzmlImage,
+        CzmlHorizontalOrigin,
+        CzmlVerticalOrigin,
+        CzmlColor,
+        DynamicProperty) {
+    "use strict";
+
+    /**
+     * Represents a time-dynamic billboard, typically used in conjunction with DynamicBillboardVisualizer and
+     * DynamicObjectCollection to visualize CZML.
+     *
+     * @alias DynamicBillboard
+     * @constructor
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see DynamicBillboardVisualizer
+     * @see VisualizerCollection
+     * @see Billboard
+     * @see BillboardCollection
+     * @see CzmlDefaults
+     */
+    var DynamicBillboard = function() {
+        /**
+         * A DynamicProperty of type CzmlImage which determines the billboard's texture.
+         * @type DynamicProperty
+         */
+        this.image = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the billboard's scale.
+         * @type DynamicProperty
+         */
+        this.scale = undefined;
+        /**
+         * A DynamicProperty of type CzmlHorizontalOrigin which determines the billboard's horizontal origin.
+         * @type DynamicProperty
+         */
+        this.horizontalOrigin = undefined;
+        /**
+         * A DynamicProperty of type CzmlVerticalHorigin which determines the billboard's vertical origin.
+         * @type DynamicProperty
+         */
+        this.verticalOrigin = undefined;
+        /**
+         * A DynamicProperty of type CzmlColor which determines the billboard's color.
+         * @type DynamicProperty
+         */
+        this.color = undefined;
+        /**
+         * A DynamicProperty of type CzmlCartesian3 which determines the billboard's eye offset.
+         * @type DynamicProperty
+         */
+        this.eyeOffset = undefined;
+        /**
+         * A DynamicProperty of type CzmlCartesian2 which determines the billboard's pixel offset.
+         * @type DynamicProperty
+         */
+        this.pixelOffset = undefined;
+        /**
+         * A DynamicProperty of type CzmlBoolean which determines the billboard's visibility.
+         * @type DynamicProperty
+         */
+        this.show = undefined;
+    };
+
+    /**
+     * Processes a single CZML packet and merges its data into the provided DynamicObject's billboard.
+     * If the DynamicObject does not have a billboard, 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.
+     * @memberof DynamicBillboard
+     *
+     * @param {DynamicObject} dynamicObject The DynamicObject which will contain the billboard data.
+     * @param {Object} packet The CZML packet to process.
+     * @param {DynamicObjectCollection} [dynamicObjectCollection] The collection into which objects are being loaded.
+     * @param {String} [sourceUri] The originating url of the CZML being processed.
+     * @returns {Boolean} true if any new properties were created while processing the packet, false otherwise.
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see CzmlDefaults#updaters
+     */
+    DynamicBillboard.processCzmlPacket = function(dynamicObject, packet, dynamicObjectCollection, sourceUri) {
+        var billboardData = packet.billboard;
+        if (typeof billboardData === 'undefined') {
+            return false;
+        }
+
+        var billboardUpdated = false;
+        var billboard = dynamicObject.billboard;
+        billboardUpdated = typeof billboard === 'undefined';
+        if (billboardUpdated) {
+            dynamicObject.billboard = billboard = new DynamicBillboard();
+        }
+
+        var interval = billboardData.interval;
+        if (typeof interval !== 'undefined') {
+            interval = TimeInterval.fromIso8601(interval);
+        }
+
+        if (typeof billboardData.color !== 'undefined') {
+            var color = billboard.color;
+            if (typeof color === 'undefined') {
+                billboard.color = color = new DynamicProperty(CzmlColor);
+                billboardUpdated = true;
+            }
+            color.processCzmlIntervals(billboardData.color, interval);
+        }
+
+        if (typeof billboardData.eyeOffset !== 'undefined') {
+            var eyeOffset = billboard.eyeOffset;
+            if (typeof eyeOffset === 'undefined') {
+                billboard.eyeOffset = eyeOffset = new DynamicProperty(CzmlCartesian3);
+                billboardUpdated = true;
+            }
+            eyeOffset.processCzmlIntervals(billboardData.eyeOffset, interval);
+        }
+
+        if (typeof billboardData.horizontalOrigin !== 'undefined') {
+            var horizontalOrigin = billboard.horizontalOrigin;
+            if (typeof horizontalOrigin === 'undefined') {
+                billboard.horizontalOrigin = horizontalOrigin = new DynamicProperty(CzmlHorizontalOrigin);
+                billboardUpdated = true;
+            }
+            horizontalOrigin.processCzmlIntervals(billboardData.horizontalOrigin, interval);
+        }
+
+        if (typeof billboardData.image !== 'undefined') {
+            var image = billboard.image;
+            if (typeof image === 'undefined') {
+                billboard.image = image = new DynamicProperty(CzmlImage);
+                billboardUpdated = true;
+            }
+            image.processCzmlIntervals(billboardData.image, interval, sourceUri);
+        }
+
+        if (typeof billboardData.pixelOffset !== 'undefined') {
+            var pixelOffset = billboard.pixelOffset;
+            if (typeof pixelOffset === 'undefined') {
+                billboard.pixelOffset = pixelOffset = new DynamicProperty(CzmlCartesian2);
+                billboardUpdated = true;
+            }
+            pixelOffset.processCzmlIntervals(billboardData.pixelOffset, interval);
+        }
+
+        if (typeof billboardData.scale !== 'undefined') {
+            var scale = billboard.scale;
+            if (typeof scale === 'undefined') {
+                billboard.scale = scale = new DynamicProperty(CzmlNumber);
+                billboardUpdated = true;
+            }
+            scale.processCzmlIntervals(billboardData.scale, interval);
+        }
+
+        if (typeof billboardData.show !== 'undefined') {
+            var show = billboard.show;
+            if (typeof show === 'undefined') {
+                billboard.show = show = new DynamicProperty(CzmlBoolean);
+                billboardUpdated = true;
+            }
+            show.processCzmlIntervals(billboardData.show, interval);
+        }
+
+        if (typeof billboardData.verticalOrigin !== 'undefined') {
+            var verticalOrigin = billboard.verticalOrigin;
+            if (typeof verticalOrigin === 'undefined') {
+                billboard.verticalOrigin = verticalOrigin = new DynamicProperty(CzmlVerticalOrigin);
+                billboardUpdated = true;
+            }
+            verticalOrigin.processCzmlIntervals(billboardData.verticalOrigin, interval);
+        }
+
+        return billboardUpdated;
+    };
+
+    /**
+     * Given two DynamicObjects, takes the billboard 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.
+     * @memberof DynamicBillboard
+     *
+     * @param {DynamicObject} targetObject The DynamicObject which will have properties merged onto it.
+     * @param {DynamicObject} objectToMerge The DynamicObject containing properties to be merged.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicBillboard.mergeProperties = function(targetObject, objectToMerge) {
+        var billboardToMerge = objectToMerge.billboard;
+        if (typeof billboardToMerge !== 'undefined') {
+
+            var targetBillboard = targetObject.billboard;
+            if (typeof targetBillboard === 'undefined') {
+                targetObject.billboard = targetBillboard = new DynamicBillboard();
+            }
+
+            targetBillboard.color = defaultValue(targetBillboard.color, billboardToMerge.color);
+            targetBillboard.eyeOffset = defaultValue(targetBillboard.eyeOffset, billboardToMerge.eyeOffset);
+            targetBillboard.horizontalOrigin = defaultValue(targetBillboard.horizontalOrigin, billboardToMerge.horizontalOrigin);
+            targetBillboard.image = defaultValue(targetBillboard.image, billboardToMerge.image);
+            targetBillboard.pixelOffset = defaultValue(targetBillboard.pixelOffset, billboardToMerge.pixelOffset);
+            targetBillboard.scale = defaultValue(targetBillboard.scale, billboardToMerge.scale);
+            targetBillboard.show = defaultValue(targetBillboard.show, billboardToMerge.show);
+            targetBillboard.verticalOrigin = defaultValue(targetBillboard.verticalOrigin, billboardToMerge.verticalOrigin);
+        }
+    };
+
+    /**
+     * Given a DynamicObject, undefines the billboard 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.
+     * @memberof DynamicBillboard
+     *
+     * @param {DynamicObject} dynamicObject The DynamicObject to remove the billboard from.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicBillboard.undefineProperties = function(dynamicObject) {
+        dynamicObject.billboard = undefined;
+    };
+
+    return DynamicBillboard;
+});