Extracción de la profundidad de los terremotos de la fuente GeoJson del USGS para su uso con Openlayers

Question

Tengo un poco de GeoJson del USGS como sigue:

{"type":"Feature","properties":{"mag":4.3,"place":"30km ESE of Jarm, Afghanistan","time":1382069641720,"updated":1382071013039,"tz":270,"url":"http://earthquake.usgs.gov/earthquakes/eventpage/usb000kg6q","detail":"http://earthquake.usgs.gov/earthquakes/feed/v1.0/detail/usb000kg6q.geojson","felt":0,"cdi":1,"mmi":null,"alert":null,"status":"reviewed","tsunami":null,"sig":284,"net":"us","code":"b000kg6q","ids":",usb000kg6q,","sources":",us,","types":",cap,dyfi,general-link,geoserve,nearby-cities,origin,phase-data,tectonic-summary,","nst":null,"dmin":2.372,"rms":0.49,"gap":112,"magType":"mb","type":"earthquake","title":"M 4.3 - 30km ESE of Jarm, Afghanistan"},"geometry":{"type":"Point","coordinates":[71.1215,36.7111,215.63]},"id":"usb000kg6q"},

La geometría contiene datos tridimensionales, en los que es necesario establecer el GeoJSON.ignoreExtraDims a true para ignorar esa tercera dimensión para cargar el Geojson en una capa vectorial

Esta tercera dimensión parece ser la profundidad del terremoto. ¿Cómo puedo acceder a ella si no aparece en los datos de la capa vectorial (no aparece, lo he comprobado, simplemente se ignora)?

Answer 1

Creo que es posible procesar los datos en el propio lado del cliente. En su pregunta anterior, ha indicado que está utilizando un manejador para la solicitud de obtención. En el manejador, usted podría procesar los datos recibidos, y añadir el valor de la profundidad como un atributo en las propiedades de cada característica.

Yo usaría algo así:

function handler(request) {

var geojson_format = new OpenLayers.Format.GeoJSON({
    'internalProjection': map.baseLayer.projection,
    'externalProjection': new OpenLayers.Projection("EPSG:4326")
});
geojson_format.ignoreExtraDims=true;
var processedData=ExtractZvalue(request.responseText) //this is the addition
vectorLayer.addFeatures(geojson_format.read(processedData));
}

function ExtractZvalue(ob){
    var features=ob["features"];
    var featCount=features.length;

    //iterate over each feature
    for(var i=0;i<featCount;i++){
        var f=features[i];
        var geom=f["geometry"];
        var coordinates=geom["coordinates"];
        var dep=coordinates[2]; //third coordinate
        var prop=f["properties"];
        prop["depth"]=dep;
    }

    return ob;
}

Otra alternativa es que usted podría editar el parseFeature Función del OpenLayers.Format.GeoJSON para hacer algo similar.

Answer 2

Ok, el reto fue planteado por @Devdatta Tengshe (gracias por el puntero en la dirección correcta) y estoy feliz de informar que el problema está resuelto. En total tengo 5 días invertidos en esto, así que para ayudar a otros, aquí hay un conjunto completo de código de trabajo que otros pueden utilizar / modificar.

Este es el resultado final, he añadido capas con las placas tectónicas, las zanjas y las crestas para que los terremotos puedan superponerse a ellas como referencia.

Aquí está el código:

            //======================================================================================================================
            // EARTH QUAKE STYLE MAP
            // Displays diferent Circles Radius depending on Magnitude and also colours them depending on Magnitude
            //======================================================================================================================

                        var context = {
                            getColor: function(feature) {
                                if (feature.attributes["mag"] > 5.5 )
                                    {
                                        return "red";
                                    }
                                if (feature.attributes["mag"] < 5.6 && feature.attributes["mag"] > 3.5 )
                                    {
                                        return "orange";
                                    }
                                 if (feature.attributes["mag"] < 3.6 )
                                    {
                                        return "green";
                                    }

                            },
                            getSize: function(feature) {
                                var zoom=map.getZoom();
                                var mag = feature.attributes["mag"];
                                var size = (4 + (6 * mag )) + (zoom * 4);

                                return size;
                            },
                            getLabel: function(feature) {
                                var zoom=map.getZoom();
                                var txt;

                                //debugger;

                                if (zoom < 10)
                                {
                                    txt = feature.attributes["mag"];                    
                                }
                                if ( zoom > 9 && zoom < 15)
                                {
                                    txt = 'Magnitude: ' + feature.attributes["mag"] + "\n" + "Depth: "  + feature.attributes["depth"] + "km" ;                  
                                }
                                if ( zoom > 14 )
                                {
                                    txt = 'Magnitude: ' + feature.attributes["mag"] + "\n" + "Depth: " + feature.attributes["depth"] + "km";                    
                                }

                                return txt;
                            },
                            getFont: function(feature) {
                                var zoom=map.getZoom();
                                var txt;

                                //debugger;

                                if (zoom < 10)
                                {
                                    txt = '10px';                   
                                }
                                if ( zoom > 9 && zoom < 15)
                                {
                                    txt = '14px';                   
                                }
                                if ( zoom > 14 )
                                {
                                    txt = '18px';                   
                                }

                                return txt;
                            },
                            getFontColor: function(feature) {
                                var zoom=map.getZoom();
                                var txt;

                                //debugger;

                                if (zoom < 10)
                                {
                                    txt = 'white';                  
                                }
                                if ( zoom > 9 && zoom < 15)
                                {
                                    txt = 'black';                  
                                }
                                if ( zoom > 14 )
                                {
                                    txt = 'black';                  
                                }

                                return txt;
                            },
                            getOutlineColor: function(feature) {
                                var zoom=map.getZoom();
                                var txt;

                                //debugger;

                                if (zoom < 11)
                                {
                                    txt = 'black';                  
                                }
                                if ( zoom > 10 )
                                {
                                    txt = 'white';                  
                                }

                                return txt;
                            }

                        };
                        var template = {
                            pointRadius: "${getSize}", // using context.getSize(feature)
                            fillColor: "${getColor}", // using context.getColor(feature)
                            strokeColor: "${getColor}", // using context.getColor(feature)
                            strokeWidth: 0,
                            label : "${getLabel}",
                            fillOpacity: 0.5,
                            fontColor: "${getFontColor}",
                            fontSize: "${getFont}",
                            fontFamily: "Verdana, Geneva, Arial, sans-serif",
                            fontWeight: "normal",
                            labelAlign: "cm",
                            labelXOffset: "0",
                            labelYOffset: "0",
                            labelOutlineColor: "${getOutlineColor}",
                            labelOutlineWidth: 1

                        };
                        var eqStyle = new OpenLayers.Style(template, {context: context});

            //===========================================================================================================================================
            // Set JSON format variables 
            //===========================================================================================================================================

            // Note, projections are required or data will not display on te map
                    var geojson_format = new OpenLayers.Format.GeoJSON({

                                    'internalProjection': map.baseLayer.projection,
                                    'externalProjection': wgs84,
                                    ignoreExtraDims:true

                                    });

                    var json_format = new OpenLayers.Format.JSON({
                                //    ignoreExtraDims:true
                                    });

            //===========================================================================================================================================
            // Extract Earthquake Thrid Dimensions - Depth
            //===========================================================================================================================================

                    function ExtractDepthValue(featureList)
                    {

            // Parse the geoJson data as JSON data and dig out the Z Dimension which is the Depth
            // Parse the GeoJson Data so we can add the Depth back into the array
            // Assumes that the arrays of JSOn and GeoJson are parallel, which is a reasonable assumption as they are from the same 
            // data passed into the function

                        var orgFeatures=json_format.read(featureList);
                        var modFeatures=geojson_format.read(featureList);

                        //iterate over each feature and dig out the depth from the third dimension
                        for(var i=0; i < orgFeatures.features.length; i++ )
                        {
                            modFeatures[i].attributes.depth = orgFeatures.features[i].geometry.coordinates[2]; //third coordinate
                         }
            // Return object with modified features, reprojected into the map projection from wgs84
                        return modFeatures;
                    }

            //===========================================================================================================================================
            // Load an Earthquake Layer
            //===========================================================================================================================================

                                var newlayer = new OpenLayers.Layer.Vector(
                                            layername, 
                                            {
                                            styleMap: new OpenLayers.StyleMap(styletouse),
                                            projection: wgs84,                          

            //It does not like teh Fixed Strategy, but layer seems to work quite well without it
            //                              strategies: [new OpenLayers.Strategy.Fixed()],

                                            eventListeners: {
                                                        "loadstart": layerLoadStart,
                                                        "loadend": layerLoadEnd
                                                        }

                                            }
                                    );

                                map.addLayers([newlayer]);
                                map.setLayerIndex(newlayer,map.getNumLayers());
                                saveLayers();

            // Get the data from the server, append a random string to ensure we do not get a cached copy
                                var request = OpenLayers.Request.GET({
                                    url: urlstring + '?' + forcedownload,

            // After data loaded, go and oarse out teh Z Depth
                                    callback: function(request) {
                                                                var processedData=ExtractDepthValue(request.responseText);

            // Note geojson_format.read not needed as data is returned already parsed and reprojected
                                                                newlayer.addFeatures(processedData);
                                                                }
                                });

Answer 3

Bueno, me he pasado el día mirando esto en profundidad. La única manera de lograr esto por lo que puedo decir es la siguiente:

1. Cargar el USGS Feed en un servidor a intervalos regulares
2. Postproceso de la alimentación y extracción de la profundidad del componente Z
3. Añadir la profundidad como un campo adicional en kml o Geojson
4. Escribir la alimentación modificada en la aplicación

La desventaja es que el servidor tiene que pasar los datos al cliente, en lugar de que el cliente los obtenga directamente del USGS, lo que añade una sobrecarga de ancho de banda en el lado del servidor.

Esto es posible, pero sería bueno que OpenLayers arreglara el problema para que los valores Z puedan ser leídos desde los datos GeoJson.

Si alguien tiene una forma mejor, le encantaría escucharla.