/*Prog*/ Delphi-Neftalí /*finProg*/

Muchas veces nos encontramos en nuestros programas con que necesitamos imágenes o iconos para ilustrar acciones o elementos de nuestros menús o barras de botones. Personalmente utilizo alguno que tengo como “librería habitual”; Pero otras veces necesitamos algo diferente o las características del proyecto obligan a buscar algo nuevo.

Hay muchas librerías profesionales de iconos (de muy alta calidad), pero también hay lugares donde se pueden conseguir infinidad de iconos de forma gratuita.

He aquí un pequeño repaso de los que yo visito con mayor asiduidad.

ICONLET
(http://www.iconlet.com)

Uno de mis preferidos. Posee una gran cantidad de iconos. La visualización es clara y los inter-enlaces(*) entre iconos son buenos.
Me encanta su interficie mínima, casi libre de anuncios y cosas superfluas.
Uno de mis preferidos.

Inter-enlaces(*): Cuando se selecciona un icono, a partir de este se tiene un acceso a enlaces de los diferentes iconos relacionados con este; Mismo autor, mismo “icon-set” (pqeuete de iconos), iconos similares (según tags), iconos similares de la misma resolución en pantalla,…

_____________________________________________________________
ICONFINDER
(http://www.iconfinder.com)

Muy buena interface una vez realizada la búsqueda. La selección de tamaños, la visualización en pantalla,… se puede realizar una vez que se muestran los resultados y es muy ágil. La visualización de los iconos una vez seleccionados en muy buena y mustra diferentes tamaños del mismo icono junto al resultado.

_____________________________________________________________

VERYICON
(http://www.veryicon.com/)

Muestra menos resultados que los anteriores. La información cuando muestra el icono seleccionado es buena y prioriza mostrar iconos del mismo “icon-set” que el seleccionado.
_____________________________________________________________

ICONS-SEARCH
(http://icons-search.com/)

Personalmente encuentro que devuelve menos resultados que los primeros buscadores que he indicado. No es de los que tiene mejor interface, pero cumple bien su función.

_____________________________________________________________

ICONSPEDIA
(http://www.iconspedia.com/)

Uno de los últimos que he descubierto. Me resulta demasiado recargado el entorno y la búsqueda de iconos. La página está muy “espesa y el número de iconos que devuelve no está entre las páginas con más resultados retorna.
_____________________________________________________________

ICONSEEKER
(http://www.iconseeker.com)

Esta también se encuentra entre las páginas que devuelve más resultados. La página de respuesta es bastante limpia y permite algun filtro (por tamaño) una vez que los resultados ya se han mostrado. No me gusta mucho que los resultados salgan mezclados en cuanto al tamaño de las imágenes, pero como ya he dcho es fácil filtrarlas una vez que estamos en los resultados.
Una vez seleccionado el icono la pantalla es clara y de las más cuidadas. También está entre mis preferidas.
_____________________________________________________________

Mr. ICON
(http://www.mricons.com)

Es de las últimas que he descubierto y me da la sensación de que es de las más nuevas. No es de las que más resultados devuelve y la forma de mostrarlos tampoco es de las que más me agrade. Mezcla los resultados por tamaños y no permite filtrar entre ellos de forma fácil. La página de resultados es liosa, pero en cambio una vez seleccionado el icono la página que se muestra es más clara y hay acceso rápido a iconos relacionados (por tamaño y por “icon-set”).
_____________________________________________________________

ICONARCHIVE
(http://www.iconarchive.com)

Esta se encuentra también entre las últimas que he descubierto. No ses de las que más resultados muestra (de las que menos en realidad), pero posee los mejores filtros una vez que se accede a los resultados; La página está muy cuidada y la información se muestra de una forma muy clara.
_____________________________________________________________

FINDICONS
(http://findicons.com)

También es de los últimos que he encontrado, y aunque no es de los que devuelve más iconos, los filtros a posteriori una vez completada la búsqueda son los mejores junto con los de IconArchive. La página que muestra el icono seleccionado también es muy clara y da mucha información.
_____________________________________________________________

ICONZA
(http://iconza.com/)

Es web es algo diferente al resto, pero la he incluído aquí porque en algun caso también me ha servido. Se trata de una serie de 112 iconos (generales) que se pueden personalizar para obtener muchas combinaciones. A partir de los iconos base se puede seleccionar el tamaño, el color (tonalidad general del icono) y el fondo, de forma que se obtienen muchas combinaciones a partir de los 112 originales.
_____________________________________________________________

Una vez encontrados los iconos, hay que mostrar especial atención a la licencia de cada uno de ellos, porque hay variantes.

Recomiendo que si usáis las páginas no es quedéis con una (tal vez tampoco con todas), pero realizar una búsqueda en 3 o 4 de ellas y revisar los resultados combinados suele dar muy buenos resultados (al menos eso es lo que hago yo  ;-) ).

Espero que os se a útil.

AÑADO: Cualquier enlace que no se encuentre en la lista y que consideréis interesante será bienvenido.

Un saludo.

General Iconos, Imagenes, Search

A la sección de “Recopilatorio de las RxLib”, he subido una nueva versión (oficiosa como las últimas) que compila bien en la nueva versión de Dephi (RAD Studio XE). Los ficheros de INCLUDE están actualizados para la nueva versión y he añadido alguna directiva de compilación para evitar errores segun diferentes configuraciones.

He modificado algunas units en la demo principal (RxDemo) de forma que compile para las últimas versiones.

Un saludo y a disfrutarla.  ;-)

Componentes, Delphi, Programación Código, Componentes, RxLib

Haciendo pruebas con el componente TidHTTP me ha surgido este ejemplo y me parece interesante mostrar el proceso completo que he seguido para descargar contenido desde una web. En este caso he accedido a las imágenes en formato PNG, pero es extensible a cualquier otros contenidos.

En un primer paso se trata de obtener el contenido (source) desde una página web y a partir de ahí, extraer los links (en mi caso correspondientes a imágenes en formato PNG) y descargar los ficheros para almacenarlos en disco. Para ello utilizaremos el control TidHTTP de la Indy.

Para obtener el código fuente de la página podemos utilizar un código como este:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  // URL de la página
  StrURL := ... ;
  // Crear componente para acceder
  IdH := TIdHTTP.Create(nil);
  // proteccion para liberar
  try
    // proteccion por error
    try
      // Obtenemos la pagina
      Resp := IdH.Get(Trim(StrURL));
      // recuperamos la respuesta
      TSContent.Text  := Resp;
    except
      on E:Exception do begin
        MessageDlg('Error al acceder a la página. '+#13+#10+
                         'Mensaje: ' +
                         E.Message, mtError, [mbOK], 0);
      end;
    end;  // try
  finally
    IdH.Free;
  end;

Una vez que obtenemos la respuesta del componente almacenamos el contenido de la página en un TStrings. Si accedemos a la página: http://neftali.clubdelphi.com/temporal/ejemplo1.html

Obtendremos como resultado del Get el siguiente texto, que corresponde al código fuente de la página:

Lo siguiente que vamos a hacer es un simple “parseo” buscando los enlaces que nos interesen. En nuestro ejemplo queremos links a imágenes en formato png. Utilizando funciones de la clase SysUtils podemos obtener sin mayor problemas los links contenidos en el código; Si probáis con la página de ejemplo, deberíais obtener un único link:

http://neftali.clubdelphi.com/images/GLibWMI_paleta_1.8b.png

Por último, nos queda ver el código necesario para descargar la imagen y almacenarla en disco. Para ello podemos utilizar de nuevo el componente TidHTTP. En mi caso, y en previsión de que pueda haber varias imágenes a descargar, he creado una clase derivada de TThread para ello:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

  {: Clase para descargar una imagen y almacenarla en disco.}
  TDownImageThread = class(TThread)
  private
    FURLImage: string;
    FPathImage: string;
    FFileNameImage: string;
    // Internas
    ImageName: string;
    PathURL: string;
    // Componente
    idH:TidHTTP;
  public
    // redefinir métodos
    constructor  Create(AURL:string; AOutPathImages:string);
    destructor Destroy; override;
    procedure Execute; override;
    {: URL de la imagen a descargar. }
    property URLImage:string read FURLImage write FURLImage;
    {: Path de disco local donde voy a almacenar la imagen.}
    property PathImage:string read FPathImage;
    {: Nombre completa (path+Nombre) de la imagen almacenada en disco local}
    property FileNameImage:string read FFileNameImage;
  end;

Al crear el Thread (método Create) ya pasamos como parámetros, la URL de la imagen a descargar y el Directorio inicial donde se van a guardar las imágenes encontradas.
El método Execute creamos un componente TidHTTP (igual a como lo hemos hecho antes), pero en este caso utilizamos un TFileStream para recoger el fichero que descargamos y almacenarlo en disco.

Utilizamos el Path de la URL para generar diferentes directorios para las diferentes imágenes:

···················································································································
URL: http://neftali.clubdelphi.com/images/GLibWMI_paleta_1.8b.png
Path: images
FileName: GLibWMI_paleta_1.8b.png
···················································································································

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44

//: recupara la imagen y la guarda en disco
procedure TDownImageThread.Execute();
var
  Stream:TFileStream;
  IdH:TidHTTP;
  path:string;
  dir:string;
begin
  // Directorio de salida
  dir := AnsiReplaceText(PathURL, '/', STR_EMPTY);
  // Nombre vacío
  if (ImageName = STR_EMPTY) then begin
    Exit;
  end;
  // Path de salida
  path := IncludeTrailingBackslash(IncludeTrailingBackslash(PathImage)
          + dir) + ImageName;
  // Crearlo por si no existe
  ForceDirectories(ExtractFilePath(path));
  try
    // Stream para la imagfen
    Stream  := TFileStream.Create(path, fmCreate);
    try
      //recuperar la imagen
      IdH := TidHTTP.Create(nil);
      IdH.AllowCookies := True;
      // proteccion
      try
        IdH.Get(Trim( FURLImage), Stream);
      except
        // Error al descargar la imagen
        //..  Volcarlo al log
      end;
    finally
      // Liberar
      idH.Free;
      Stream.Free;
    end;
    // Path de salida
    FFileNameImage := path;
  except
    // error al crear el fichero
    //...  Log
  end;
end;

El resultado se puede ver en este ejemplo.

Una vez descargadas las imágenes se muestran en un componente en la misma aplicación, y desde ahí podemos acceder a la información de la imagen y realizar algunas acciones sobre ellas.

Para realizar pruebas podéis introducir, por ejemplo direcciones como:

• URL de una entrada de este mismo blog (Acceder a GRUB desde Windows)
• URL con la lista de Iconos de Google Maps.
• URL de prueba que hemos utilizado más arriba.
• …

Como siempre podéis descargar los fuentes y los binarios de ejemplos.

<DESCARGAR SOURCES>

<DESCARGAR BINARIO>

Un saludo.

Aplicación, Ejemplos, Programación Imagenes, Indy, Internet

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:

• Wiki GPX (GPS eXchange Format)
• Official GPX 1.1 Schema
• GPX 1.1 Schema Documentation
• Wikiloc; Página con track GPS
• cicloide; Página con track GPS
• Referencia del formato KML
• Esquema del formato KML

Ejemplos, Midas Ejemplos, GPS, KML, XML, XMLMapper