Archivo

Entradas Etiquetadas ‘KML’

Visualizar un fichero KML en Delphi II

lunes, 14 de marzo de 2011 4 comentarios
Share Button

Esta entrada se podría considerar como una “ampliación” de la última publicada relacionada con los ficheros KML, Generar ficheros KML de rutas; Tracks en Google Maps. A partir de un tema surgido en los foros del Clubdelphi de cómo visualizar estos ficheros directamente sobre Google Maps dentro de una aplicación Delphi, he modificado el programa anterior (que incluía la conversión desde GPX) para poder visualizarlos directamente.

En un ejemplo más simplificado, y enfocado a los ficheros KML. Como ya dije anteriormente, este tipo de ficheros pueden almacenar otros tipos de información y en este ejemplo se leen los datos directamente desde este tipo de ficheros (en este caso sólo la ruta).

Además el mapa está optimizado para visualizarse a tamaño completo, y no según el tamaño de la ventana como estaba anteriormente (esto implica la optimización de que no se recarga la página al cambiar el tamaño).

También se ha modificado el recurso de la página Web, para que automáticamente se calcule en “centrado” y el “zoom” del mapa a partir del Track que se va a visualizar. Para ello se utiliza el siguiente código:

0
1
2
var polylineBounds = polyline.getBounds();
var ZoomLevel = map.getBoundsZoomLevel(polylineBounds) - 1;
map.setCenter(polylineBounds.getCenter(), ZoomLevel);

Se puede descargar el ejemplo desde aquí (incluye los fuentes).

<Descargar fuentes>

AÑADO: compilación en Delphi XE2.

Debido a un cambio en la definición de la función EnumResourceModules, que pasa de usar LongInt a NativeInt, hay que realizar un cambio en el procedimiento que se le pasa como parámetro, modificando este dato.
La definición del procedimiento, ahora queda así:

0
1
2
function _MyEnumResourceModules (
Instance:{$IFDEF VER230}NativeInt{$ELSE}Pointer{$ENDIF};
Data:Pointer):Boolean;
Share Button

Generar ficheros KML de rutas; Tracks en Google Maps

miércoles, 2 de marzo de 2011 10 comentarios
Share Button

En esta entrada mostraré el código nesario para generar ficheros KML (Keyhole Markup Language) a partir de datos que provienen de un DataSet o de un fichero GPX (GPX eXchage Format).
Los ficheros KML se utilizan para representar datos geográficos en 3 dimensiones (además de la longitud y la Latitud incluyen también la altura) y fue desarrollado para ser utilizado por un programa que a posteriori se convertiría en Google Earth.

En una entrada anterior ya vimos como importar un fichero GPX, con posiciones geográficas a un Dataset para posteriormente poder tratar y manejar estas posiciones (Cargar fichero GPX (XML) y acceder a los datos). Partiendo de lo visto en esa entrada como base, debe ser sencillo generar un fichero KML con los puntos que forma la ruta.

Hay que decir que los ficheros KML permiten muchas más cosas de las vistas en esta entrada, y para ver todas las posibilidades podemos revisar los ejemplos que se muestran aquí (Tutorial KML en Google); En este entrada me voy a centrar en la creación de rutas (lista de puntos) aunque las posibilidades van mucho más allá.

La estructura de nuestro fichero se compone por una cabecera, donde se almacenan datos genéricos de la ruta, y el bloque central donde añadimos los diferentes puntos geográficos que la componen.
Un ejemplo sencillo de fichero KML podría ser este:

<?xml version=”1.0″ encoding=”UTF-8″?>
<Placemark>
<name>Camino de ejemplo</name>
<description>Puntos de ejemplo sobre Collserola.</description>
<Style><LineStyle><color>ff0000FF</color><width>3</width></LineStyle></Style>
<LineString>
<coordinates>
2.12578324,41.4157072,275.5550537109375
2.12559993,41.4156055,275.074462890625
2.12537404,41.4152729,275.074462890625
2.12531452,41.4151532,274.59375
2.12518930,41.4149554,275.074462890625
2.12525032,41.4145536,274.113037109375
2.12553421,41.4141423,275.5550537109375
2.12541938,41.4139779,275.5550537109375
2.12537412,41.4139778,275.5550537109375
2.12492954,41.4139116,274.59375
2.12441666,41.4137039,273.6324462890625
2.12425304,41.4136318,274.113037109375
2.12396864,41.4136072,273.6324462890625
2.12380528,41.4136296,273.15185546875
2.12357947,41.4136973,273.15185546875
2.12343120,41.4137774,273.15185546875
2.12328091,41.4139091,272.671142578125
2.12321687,41.4140272,273.15185546875
2.12320983,41.4141903,273.15185546875
</coordinates>
</LineString>
</Placemark>

Como vemos en la parte superior añadimos datos de la ruta y algunas opciones de visualización. En este caso un nombre y una descripción y porteriormente se definen opciones de estilo para el track (LineStyle); Definimos que usaremos una línea para representar esos puntos con color Rojo y un a anchura de 3.

Este archivo podemos abrirlo directamente con Google Earth o importarlo a “Mis Mapas” desde Google Maps y la visualización ser algo así;

En Google Maps al importar la ruta tendríamos esto:

Y al Abrir el fichero con Google Earth obtendríamos esto:

Podemos ver que como la ruta está definida como <LineString>, esta se pinta como una línea siguiendo los parámetros definidos en el fichero (color rojo y ancho 3).

Para generar el fichero con una ruta, partiremos de que los datos han sido imprtados a un Dataset y que ya disponemos de ellos en ese formato.

Primero generaremos la cabecera del fichero con los datos genéricos de la ruta; Nombre, Descripción, y las características de estilo para la línea:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
const
  CAB_XML         = '<!--?xml version="1.0" encoding="UTF-8"?-->';
  CAB_KLM         = '';
  CAB_PLACEMARK   = '';
  CAB_NAME        = '%s';
  STR_STYLE       = '<!--
<LineStyle>
<color>%s</color>' +
                    '<width>%d</width></LineStyle>
-->';
  CAB_LINE        = '';
begin
  // Limpiar
  TSTrack.Clear;
  // Añadir cabeceras
  TSTrack.Add(CAB_XML);
  TSTrack.Add(CAB_KLM);
  TSTrack.Add(CAB_PLACEMARK);
  // Datos de la ruta
  TSTrack.Add(Format(CAB_NAME,[AtrackName]));
  // color
  {$IFDEF VER220}
  // transparencia + color
  Str := 'ff' + RGBToWebColorStr(ATrackColor);
  {$ELSE}
  Str := 'ff' + uProcedures.RGBToWebColorStr(ATrackColor);
  {$ENDIF}
  Str := AnsiReplaceText(Str, '#', '');
  // TrackColor en HEXA
  TSTrack.Add(Format(STR_STYLE,[Str, ATrackWidth]));
  TSTrack.Add(CAB_LINE);

Con este código generamos la cabecera del fichero. En mi caso he usado una directiva condicional, para la función RGBToWebColorStr, que no está definida en versiones antiguas de la VCL.

Lo siguiente es realizar el recorrido por los puntos, añadiendo información de cada uno de ellos.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
dsPoints.First;
// recorrido
while not (dsPoints.Eof) do begin
  // Info. de punto
  StrLine :=
     Copy(dsPoints.FieldByName(lonFName).AsString,1,10) + ',';
  StrLine := StrLine +
      Copy(dsPoints.FieldByName(latFName).AsString, 1,10) +  ',';
  StrLine := StrLine +
      dsPoints.FieldByName(eleFName).AsString + ' ';
  // Añadir la linea
  TSTrack.Add(StrLine);
  // Next
  dsPoints.Next;
end;

Sólo queda finalmente completar el fichero añadiendo los TAG’s de las diferentes secciones que hemos ido creando.

Para facilitar el trabajo he encapsulado la conversión en el procedimiento siguiente:

0
1
2
3
4
5
6
7
8
9
procedure ConvertTrackToKLM(
   ATrackName:string;  // Nombre
   ATrackDesc:string;  //descripción
   dsPoints:TDataSet;   //  Dataset que contiene los datos de los puntos
   {Nombres de los campos en el Dataset que contienen
    Latitud, Longitud, Elevación y Time}
   latFieldName, lonFieldName, eleFieldName, timeFieldName:string;
   var TSTrack:TStrings;   // Estructura de salida con el track
   ATrackColor:TColor=clBlue;  // Color para la linea del track
   ATrackWidth:integer=2   // Anchura de la línea);

Y una llamada de ejemplo a este procedimiento podrías ser la siguiente:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
  TS := TStringList.Create();
  try
    // convertir a KML
    ConvertTrackToKLM(
           FormData.cdsTrack.FieldByName('name').AsString,    // trackName
           'Descripción del track',      // descripción
           FormData.cdsPoints,        // Dataset con los puntos
           'lat', 'lon','ele','time',        // Nombre de los campos
           TS);
    // Fichero de salida
    newName := ChangeFileExt(Self.TrackPath, '.KML');
    TS.SaveToFile(newName);
  finally
    FreeAndNil(TS);
  end;

Partiendo de la aplicación que sirvió de ejemplo en la entrada <Google Maps en Delphi>, he generado otro ejemplo que nos permitirá integrar la carga de un fichero GPX (utilizando el XML Mapper de Delphi), la conversión del fichero GPX a formato KML y la visualización de la ruta creada utilizando Google Maps integrado en nuestra aplicación, como prometí en la última entrada sobre el tema.

He probado a generar un video del ejemplo para ver el funcionamiento.

[youtube DLoX_KVSJ7c nolink]

Para las pruebas podeís descargar las rutas de ejemplo de la última entrada o buscar por internet en la infinidad de páginas que hay que las publican

<Rutas de ejemplo (GPX)>

Podéis descargar tanto el ejecutable del proyecto (con alguna ruta de ejemplo) como los fuentes:

<Sources del proyecto>
<Ejecutable del proyecto>

CORRECCIÓN: He añadido un fichero que faltaba al ejecutable de ejemplo.

Un saludo.

Share Button

Cargar fichero GPX (XML) y acceder a los datos

viernes, 4 de febrero de 2011 12 comentarios
Share Button

Desde hace un tiempo estoy trabajando con ficheros de rutas o “Tracks” que provienen de dispositivos GPS (Global Positioning System). Un track o una ruta, no es más que una sucesión de coordenadas de Latitud y Longitud. Adicionalmente esos puntos pueden contener más información como Elevación, Fecha y hora,…

Existen infinidad de formatos para almacenar “Tracks” muchos de ellos provenientes de marcas concretas de receptores GPS (Garmin, DeLorme, Holux, Magellan, Tomtom…) y otros provenientes de programas de software conocidos como OziExplorer, CompeGPS o los relacionados con Google Maps.

Además existe también un formato genérico y bastante aceptado como estandard, que almacena puntos con estructura XML. Es el formato GPX (GPS eXchange Format).

La idea de esta entrada es generar código para trabajar desde delphi con un track en formato genérico GPX. Poder abrirlo y cargar los valores sin problemas y posteriormente exportarlo a KML. Aunque una vez recuperados los datos desde Delphi, la exportación a otros formatos será muy similar.

Leer un archivo GPX

Lo primero que vamos a hacer para poder leer un archivo de tipo GPX es generar una pieza intermedia que nos permita fácilmente trasladar los datos desde un XML (con una estructura determinada) a un Dataset (en nuestro caso un TClientDataset).

NOTA: Para utilizar como ejempos, en la web podéis encontrar infinidad de archivos de este tipo; Yo para las pruebas utilizaré un par de archivos de rutas distintos que podeís descargar aquí.

Para ello utilizaremos la herramienta XML Mapper de Delphi, accesible desde el menú de Tools (o también desde el Menu de programa, en el mismo grupo donde está instalado Delphi).

PASO1: Abrir fichero GPX; Aunque la extensión no es XML, sí lo es la estructura del fichero, así que la herramienta reconocerá los campos y en la parte izquierda del programa podremos ver la estructura del fichero con los diferentes campos disponibles. En este caso vemos que el fichero contiene una serie de campos correspondientes al track, como creator, versión,… y luego un “Nested Dataset”; Un Dataset “anidado”, que contiene todos los puntos del track con los campos Lat (latitud), Lon (longitud), Ele (altura o elevación) y time (fecha/hora).

PASO2: Generar un Datapacket; Una vez que la estructura se ha leído correctamente podemos generar lo que XML Mapper llama un DataPacket; Que viene a ser algo así como los datos que tenemos en el XML, pero en formato de Dataset y además nos permitirá guardar el archivo de transformación (que es realmente lo importante).
Este archivo de transformación nos permitirá posteriormente leer cualquier fichero XML con la misma estructura que este y realizar la traducción a “formato dataset” de forma automática.

Para ello Desde el menú contextual seleccionamos todos los campos (Select All) y en el menú de Create escogemos Datapacket from XML (Ctrl+D). Con ello habremos generado nuestro fichero de transformación y el Dataset final.

En la parte derecha de la pantalla podemos ver la misma estructura que teníamos en el XML pero en “formato datapacket”. Podemos comprobar cómo se ha realizado la transformación y que los datos se leen correctamente utilizando un botón que hay en la parte inferior de la pantalla llamado “Create and Test Transformation“.

Esto nos abre un Grid y nos muestra los datos provenientes del Dataset que se ha generado utilizando el fichero de transformación. Esto es lo que posteriormente nosotros queremos repetir en nuestro programa. Además como la estructura XML posee un “DataSet anidado”, si pulsamos doble click sobre el campo trkpt, se abre un segundo Dataset que contiene todos los registros de los puntos que hay en la ruta.

En este ejemplo hemos realizado una traducción directa, pero el programa (antes de generar la transformación) nos permite modificar los campos que queremos “mapear” entre el origen (el XML) y el destino (Datapacket/Dataset), de forma que podemos aplicar determinados cambios, variaciones o filtros a los datos de entrada.

PASO3: Guardar el fichero de transformación; Una vez realizado esto sólo nos queda (lo más importante) guardar el fichero de transformación, que nos asegura que a partir de este momento podremos repetir esta misma transformación (con cualquier otro fichero de entrada que sea del mismo formato que este). Desde el Menú de File seleccionamos Save Transformation. Asignaremos anuestro fichero el nombre de GPX_To_DP.xtr (GPX to DataPacket).

Utilizar un fichero de transformación

Una vez que hemos generado nuestro fichero de tranformación GPX_To_DP.xtr, vamos a ver cómo nos puede ser útil en un programa delphi para tratar ficheros de rutas guardaos en formato GPX. Para ello utilizaremos 2 TClientDataset, no para la ruta y otro para los puntos de la ruta (a modo de Master-Detail).

Creamos un un nuevo proyecto y un formulario con los siguientes componentes:

  • Un DBGrid, un TDatasource y un TClientDataset para los puntos
  • Un DBGrid, un TDatasource, un TClientDataset y un TXMLTransformProvider para los datos del track.

Cada uno de los DBGrid va ligado al TDataset y cada uno de estos al TClientDataset.

En el XMLTransformProvider deberemos colorcar en la propiedad TransformRead, el fichero de transformación que hemos generador mediante la herramienta XML Mapper.

Como hemos visto, el campo trkpt del TClientDataset asociado al track es un campo de tipo TDataset (en concreto un TDatasetField). Para mostrarlo utilizaremos el segundo TClientDataset que hemos colocado en el formulario (cdsPoints).

En la propiedad DatasetField del TClientDataset cdsPoints asignamos el campos del primer Dataset (en este caso trkpt). Con esto visualizaremos en el segundo DBGrid los puntos que contiene el track.

Una vez hecho esto, bastará con las siguentes líneas de código para conseguir leer el contenido de cualquier fichero con formato GPX. Únicamente hay que asignar el fichero de transformación y el fichero fuente XML.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var
  b:Boolean;
  path:string;
begin
  // Abrir el diálogo
  b := OpenDialog1.Execute;
  if (b) then begin
    // Asignar fichero de transformación
    path := ExtractFilePath(Application.ExeName) + 'GPX_To_DP.xtr';
    XMLTransformProvider.TransformRead.TransformationFile := path;
    // Fichero XML (GPX) de ruta
    XMLTransformProvider.XMLDataFile := OpenDialog1.FileName;
    // Abrir el Dataset
    cdsTrack.Open;
  end;
end;

El resultado son los 2 DBGrid con los datos del Track:

Podéis descargar los ficheros de ejemplo de las rutas y el código fuente y binarios en los siguientes enlaces:

<Rutas de ejemplo>
<SOURCES DEL EJEMPLO>
<BINARIOS DEL EJEMPLO>

Una vez que tenemos los datos en formato accesible (fácil) para nosotros, lo siguiente que vamos a proponer es exportarlos a un formato KML (Google Maps) y visualizar la ruta/track sobre un Mapa de Google Maps.

Algo como lo que se ve a continuación, aunque eso lo dejo para la próxima entrada:

Un saludo.

Os adjunto algunas direcciones de interés…

_____________________________________________________________________
Referencias:

http://en.wikipedia.org/wiki/GPS_eXchange_Format
Share Button
Categories: Ejemplos, Midas Tags: , , , ,