LeafletGeomVisualizer.prototype._updatePolygon = function(entity, time, entityHash, entityDetails) {
    var featureGroup = this._featureGroup;
    var polygonGraphics = entity._polygon;

    var show = entity.isAvailable(time) && Property.getValueOrDefault(polygonGraphics._show, time, true);
    if (!show) {
        cleanPolygon(entity, featureGroup, entityDetails);
        return;
    }

    var details = entityDetails.polygon;
    if (!defined(details)) {
        details = entityDetails.polygon = {
            layer: undefined,
            lastHierarchy: undefined,
            lastFill: undefined,
            lastFillColor: new Color(),
            lastOutline: undefined,
            lastOutlineColor: new Color()
        };
    }

    var hierarchy = Property.getValueOrUndefined(polygonGraphics._hierarchy, time);
    if (!defined(hierarchy)) {
        cleanPolygon(entity, featureGroup, entityDetails);
        return;
    }

    var fill = Property.getValueOrDefault(polygonGraphics._fill, time, true);
    var outline = Property.getValueOrDefault(polygonGraphics._outline, time, true);
    var outlineColor = Property.getValueOrDefault(polygonGraphics._outlineColor, time, defaultOutlineColor);

    var material = Property.getValueOrUndefined(polygonGraphics._material, time);
    var fillColor;
    if (defined(material) && defined(material.color)) {
        fillColor = material.color;
    } else {
        fillColor = defaultColor;
    }

    var layer = details.layer;
    if (!defined(layer)) {
        var polygonOptions = {
            fill: fill,
            fillColor: fillColor.toCssColorString(),
            fillOpacity: fillColor.alpha,
            weight: outline ? 1.0 : 0.0,
            color: outlineColor.toCssColorString(),
            opacity: outlineColor.alpha
        };

        layer = details.layer = L.polygon(hierarchyToLatLngs(hierarchy), polygonOptions);
        layer.on('click', featureClicked.bind(undefined, this, entity));
        layer.on('mousedown', featureMousedown.bind(undefined, this, entity));
        featureGroup.addLayer(layer);

        details.lastHierarchy = hierarchy;
        details.lastFill = fill;
        details.lastOutline = outline;
        Color.clone(fillColor, details.lastFillColor);
        Color.clone(outlineColor, details.lastOutlineColor);

        return;
    }

    if (hierarchy !== details.lastHierachy) {
        layer.setLatLngs(hierarchyToLatLngs(hierarchy));
        details.lastHierachy = hierarchy;
    }

    var options = layer.options;
    var applyStyle = false;

    if (fill !== details.lastFill) {
        options.fill = fill;
        details.lastFill = fill;
        applyStyle = true;
    }

    if (outline !== details.lastOutline) {
        options.weight = outline ? 1.0 : 0.0;
        details.lastOutline = outline;
        applyStyle = true;
    }

    if (!Color.equals(fillColor, details.lastFillColor)) {
        options.fillColor = fillColor.toCssColorString();
        options.fillOpacity = fillColor.alpha;
        Color.clone(fillColor, details.lastFillColor);
        applyStyle = true;
    }

    if (!Color.equals(outlineColor, details.lastOutlineColor)) {
        options.color = outlineColor.toCssColorString();
        options.opacity = outlineColor.alpha;
        Color.clone(outlineColor, details.lastOutlineColor);
        applyStyle = true;
    }

    if (applyStyle) {
        layer.setStyle(options);
    }
};
LeafletGeomVisualizer.prototype._updatePoint = function(entity, time, entityHash, entityDetails) {
    var featureGroup = this._featureGroup;
    var pointGraphics = entity._point;

    var show = entity.isAvailable(time) && Property.getValueOrDefault(pointGraphics._show, time, true);
    if (!show) {
        cleanPoint(entity, featureGroup, entityDetails);
        return;
    }

    var details = entityDetails.point;
    if (!defined(details)) {
        details = entityDetails.point = {
            layer: undefined,
            lastPosition: new Cartesian3(),
            lastPixelSize: 1,
            lastColor: new Color(),
            lastOutlineColor: new Color(),
            lastOutlineWidth: 1
        };
    }

    var position = Property.getValueOrUndefined(entity._position, time);
    if (!defined(position)) {
        cleanPoint(entity, featureGroup, entityDetails);
        return;
    }

    var pixelSize = Property.getValueOrDefault(pointGraphics._pixelSize, time, defaultPixelSize);
    var color = Property.getValueOrDefault(pointGraphics._color, time, defaultColor);
    var outlineColor = Property.getValueOrDefault(pointGraphics._outlineColor, time, defaultOutlineColor);
    var outlineWidth = Property.getValueOrDefault(pointGraphics._outlineWidth, time, defaultOutlineWidth);

    var layer = details.layer;

    if (!defined(layer)){
        var pointOptions = {
            radius: pixelSize / 2.0,
            fillColor: color.toCssColorString(),
            fillOpacity: color.alpha,
            color: outlineColor.toCssColorString(),
            weight: outlineWidth,
            opacity: outlineColor.alpha
        };

        layer = details.layer = L.circleMarker(positionToLatLng(position), pointOptions);
        layer.on('click', featureClicked.bind(undefined, this, entity));
        layer.on('mousedown', featureMousedown.bind(undefined, this, entity));
        featureGroup.addLayer(layer);

        Cartesian3.clone(position, details.lastPosition);
        details.lastPixelSize = pixelSize;
        Color.clone(color, details.lastColor);
        Color.clone(outlineColor, details.lastOutlineColor);
        details.lastOutlineWidth = outlineWidth;

        return;
    }

    if (!Cartesian3.equals(position, details.lastPosition)) {
        layer.setLatLng(positionToLatLng(position));
        Cartesian3.clone(position, details.lastPosition);
    }

    if (pixelSize !== details.lastPixelSize) {
        layer.setRadius(pixelSize / 2.0);
        details.lastPixelSize = pixelSize;
    }

    var options = layer.options;
    var applyStyle = false;

    if (!Color.equals(color, details.lastColor)) {
        options.fillColor = color.toCssColorString();
        options.fillOpacity = color.alpha;
        Color.clone(color, details.lastColor);
        applyStyle = true;
    }

    if (!Color.equals(outlineColor, details.lastOutlineColor)) {
        options.color = outlineColor.toCssColorString();
        options.opacity = outlineColor.alpha;
        Color.clone(outlineColor, details.lastOutlineColor);
        applyStyle = true;
    }

    if (outlineWidth !== details.lastOutlineWidth) {
        options.weight = outlineWidth;
        details.lastOutlineWidth = outlineWidth;
        applyStyle = true;
    }

    if (applyStyle) {
        layer.setStyle(options);
    }
};