[LinuxFocus-icon]
Hogar  |  Mapa  |  Indice  |  Busqueda
Noticias | Arca | Enlaces | Sobre LF
Este artículo está disponible en los siguientes idiomas: English  Castellano  Deutsch  Francais  Turkce  

convert to palmConvert to GutenPalm
or to PalmDoc

[bayboraseckin]
por Baybora Baran and Seckin Gokaltun
<baybora(at)be.itu.edu.tr, gokaltun(at)itu.edu.tr>

Sobre el autor:

Somos dos ayudantes de investigación en el Instituto de informática de ITU. Trabajamos con aplicaciones de ingeniería con ordenadores y empleamos Linux para ello... La página de Seckin está en www.be.itu.edu.tr/~seckin



Taducido al español por:
Miguel Alfageme Sánchez <malfageme(at)terra.es>

Contenidos:

 

Utilizando PGPLOT para gráficos interactivos bajo Linux

[PgPlot for Linux]

Resumen:

En este artículo aprenderemos cómo contruir programas con gráficos interactivos escritos en Fortran. PGPLOT es la lista de subrutinas que necesitamos utilizar con nuestro código Fortran. Describiremos la instalación y algunas aplicaciones de las subrutinas PGPLOT. Se van a mostrar dos ejemplos, con el código Fortran incluído, que nos dará una idea de las posibles aplicaciones que podemos hacer con PgPlot.

_________________ _________________ _________________

 

Introducción

 

¿Qué es PGPLOT?

La librería gráfica PGPLOT es un paquete gráfico para la realización de gráficas científicas simples, independiente del dispositivo y que se puede utilizar desde Fortran o C. Su objetivo consiste en la creación de imágenes gráficas con calidad para publicarse y todo con un mínimo esfuerzo. Para la mayoría de las aplicaciones, el programa puede ser independiente del dispositivo, y la salida puede redirigirse al dispositivo adecuado en el momento de la ejecución.

La librería PGPLOT consiste en dos partes principales: una parte independiente del dispositivo y un conjunto de subrutinas controladoras dependientes del dispositivo para la salida en varios tipos de terminales, displays, impresoras matriciales, impresoras láser, y plotters. Están soportados formatos de ficheros comunes, incluyendo PostScript y GIF. PGPLOT, en sí mismo está escrito en su mayor parte en Fortran-77 estándar.

Las subrutinas PGPLOT se pueden llamar directamente desde un programa Fortran-77 o Fortran-90. Se proporciona una librería C de enlace (cpgplot) y un fichero de cabecera (cpgplot.h) para permitir que el PGPLOT pueda ser invocado desde un programa C o C++; la librería de enlace maneja la conversión entre C y Fortran. PGPLOT ha sido probado con sistemas operativos UNIX (la mayoría de sus variantes, incluyendo Linux, SunOS, Solaris, HPUX, AIX, e Irix) y OpenVMS.

PGPLOT no es un software de dominio público. Sin embargo, está disponible gratuitamente para uso no comercial. El código fuente y la documentación tienen el copyright del California Institute of Technology con unas pocas subrutinas no estándar y dependientes del sistema. Para conseguir el fichero de instalación e instrucciones simplemente hay que pinchar aquí.

 

Algunos ejemplos

A continuación se presentan algunos ejemplos sencillos de aplicaciones PGPLOT para demostrar las posibilidades del PGPLOT.

Example 1) Scatter Plots:
[Example1]

Example 2) Function Plots:
[Example2]

Example 3) Contour Maps:
[Example3]

Example 4) Images:
[Example4]

Example 5) Histograms:
[Example5]

 

Instalación para sistemas Unix

Nota: Las siguientes instrucciones hacen referencia a dos directorios, el directorio de distribución (fuentes) que contendrá el código fuente del PGPLOT, y el directorio destino en el que se crearán las librerías dependientes de la máquina, los ficheros de datos, y los programas de demostración. Es recomendable que se creen estos directorios, de forma que sean nuevos y estén vacíos. Además, éstos dos no deberían ser el mismo directorio. En los ejemplos de más abajo, estos directorios se denominan

/usr/local/src/pgplot (directorio de distribución)
/usr/local/pgplot (directorio destino)

pero se puede utilizar cualquier nombre. No se requieren privilegios inusuales (root) para instalar PGPLOT, asumiendo eso sí que tenemos permisos de escritura en estos directorios. Se puede utilizar un único directorio de distribución para instalar versiones del PGPLOT para diferentes arquitecturas en diferentes directorios destino.

Aquí se presenta brevemente la instalación de las subrutinas PGPLOT para Linux, para otras cuestiones se puede mandar un correo electrónico a tjp(At)astro.caltech.edu  

Obteniendo el fichero de distribución

Cópiese el fichero de distribución mediante un ftp anónimo al ftp de Caltech. Utilizar para ello el ftp anónimo (usuario: anonymous, password: tu@email) a ftp.astro.caltech.edu. El fichero de distribución es un fichero tar de UNIX comprimido con gzip. Introducir los siguientes comandos para obtener el fichero:

cd pub/pgplot
binary
hash
get pgplot5.2.tar.gz

Los ficheros de texto de este directorio también están incluidos en el fichero tar.

El fichero de distribución también se puede obtener de la URL ftp://ftp.astro.caltech.edu/pub/pgplot/pgplot5.2.tar.gz.  

Descomprimiendo los ficheros

Utilizar gunzip y tar para descomprimir el fichero y extraer su contenido. Esto creará el directorio pgplot (y subdirectorios) en el directorio actual. Es conveniente asegurarse que el directorio actual es donde se quiere crear el árbol de directorios de la ``distribución PGPLOT''.

cd /usr/local/src
gunzip -c pgplot5.2.tar.gz | tar xvof -

Este ejemplo creará /usr/local/src/pgplot y sus subdirectorios.  

Crear el directorio destino

Crear un directorio que tenga permisos de escritura, que será en el cual se crearán las librerías y los ficheros asociados al PGPLOT. Se necesita un directorio para cada una de las combinaciones compilador y sistema operativo (``target system'') que queramos soportar, p.e.,

mkdir /usr/local/pgplot

No se debe intentar crear la librería PGPLOT en el directorio de distribución.  

Seleccionar los controladores de dispositivo

Configurar el PGPLOT seleccionando los controladores de dispositivo de la lista de controladores disponibles. Primero se copiará el fichero drivers.list del directorio de distribución al directorio destino, y entonces emplear un editor de textos para seleccionar los controladores de dispositivo. Este fichero contiene una línea por cada controlador disponible: borraremos la exclamación (!) del comienzo de la línea para incluir el controlador, o nos aseguraremos de que existe la exclamación si queremos excluir el controlador. Muchos de los controladores pueden ser utilizador únicamente en ciertos sistemas operativos (ver las notas en drivers.list), por lo que incluiremos sólo los controladores que tenemos planeado utilizar. PGPLOT se puede reconfigurar posteriormente recomenzando la instalación en este punto. La mayoría de las instalaciones deberían incluir: el dispositivo null (/NULL), impresoras PostScript (/PS, /VPS, /CPS, y /VCPS), terminales Tektronix (/TEK, /XTERM, y posiblemente otras variantes), y, si el sistema X window está disponible en el destino, los controladores X window (/XWINDOW, /XSERVE). También podríamos querer incluir los controladores para ficheros GIF (/GIF, /VGIF) o alguno de las otras impresoras. 
    cd /usr/local/pgplot
    cp /usr/local/src/pgplot/drivers.list .
    vi drivers.list         (o nuestro editor preferido)
 

Crear el makefile

El procedimiento de instalación del PGPLOT para UNIX utiliza un script, denominado makemake, para generar un makefile UNIX estándar para nuestro sistema operativo, compiladores, y la lista de los controladores de dispositivo PGPLOT seleccionados. La información del Sistema operativo y compilador se obtiene de un fichero de configuración. Los ficheros de configuración están disponibles para los sistemas enumerados a continuación. Si nuestra configuración no es una de las que aparecen en la lista, o si tenemos problemas utilizando el makefile generado, más abajo podemos encontrar información acerca de la creación de nuestro propio fichero de configuración.

Nótese que los ficheros de configuración son para compiladores particulares en sistemas operativos particulares. Si, por ejemplo, hemos configurado nuestro sistema de forma que el comando f77 invoca el compilador GNU g77, entonces no podemos utilizar un fichero de configuración diseñado para, digamos, un compilador SPARC f77. Tendremos que crear un fichero de configuración especial. En la siguiente tabla, Arg#2 es un código para el sistema operativo, y Arg#3 es un código para los compiladores de Fortran y C. Para más información acerca de los sistemas soportados, podemos ver el fichero pgplot/sys_*/aaaread.me, donde * es una de las opciones para Arg#2. 
    Arg#2   Arg#3
    ------  ------
    aix     xlf_cc
    alliant fortran_cc
    bsd     g77_gcc
    convex  fc_cc
    cray    cf77_cc
    epix2   f77_cc         (Control Data EP/IX 2.x)
    freebsd f77_cc
    fujitsu uxpm_frt_cc
    fujitsu uxpv_frt_cc
    hp      fort77_c89
    hp      fort77_gcc
    irix    f77_cc
    linux   absoft_gcc
    linux   f77_gcc
    linux   g77_elf
    linux   g77_gcc
    next    af77_cc
    next    f2c_cc
    next    g77_cc
    next    gf77_cc
    osf1    f77_cc
    osf1    f77_cc_shared
    sol2    f77_cc         (Solaris 2.x, SunOs 5.x)
    sol2    f77_gcc
    sol2    f90_cc
    sol2    g77_gcc
    sun4    f77_acc        (SunOS 4.x)
    sun4    f77_cc
    sun4    f77_gcc
    ultrix  f77_cc
Si nuestro sistema es uno de los enumerados, procederemos de la siguiente manera: Estableceremos el directorio destino como nuestro directorio actual por defecto, p.e., 
    cd /usr/local/pgplot
Ejecutaremos el script makemake desde el directorio de distribución: p.e., 
    /usr/local/src/pgplot/makemake  /usr/local/src/pgplot  linux
El primer argumento proporcionado al makemake es el nombre del directorio de la distribución. Nótese que cuando ejecutamos makemake, nuestro directorio actual debería ser el directorio destino, i.e., el directorio en el que queremos dejar la librería compilada.

El segundo argumento es el nombre del sistema operativo (Arg#2 de la tabla anterior); si omitimos o proporcionamos un nombre no reconocido, makemake indicará los valores permitidos. En algunos sistemas operativos, donde están disponibles más de un compilador de Fortran o C, se requiere un tercer argumento (Arg#3 de la tabla anterior); normalmente éste se compone de los dos nombres de los compiladores separados por un guión bajo. Si lo omitimos, makemake indicará los valores permitidos.

Una vez que hayamos proporcionado argumentos válidos, makemake se puede quejar de que no puede encontrar el fichero drivers.list. ¡Regresaremos entonces al paso 4!

Ejemplo

baybora@bilgi>../pgplot/makemake ../pgplot linux g77_gcc
For additional information, read file ../pgplot/sys_linux/aaaread.me
Reading configuration file: ../pgplot/sys_linux/g77_gcc.conf
Selecting uncommented drivers from ./drivers.list
Found drivers NUDRIV PSDRIV XWDRIV
Creating make file: makefile
Determining object file dependencies.

El script makemake genera un fichero makefile para su uso posterior, un fichero Fortran grexec.f que llama a los controladores de dispositivo seleccionados, y un fichero de texto rgb.txt que contiene definiciones de color para ser utilizadas por la PGSCRN. (Si ya tenemos un fichero rgb.txt, posiblemente modificado con nuestras propias definiciones a medida, makemake no lo modifica.) También copia dos ficheros include de Fortran que se necesitarán durante la compilación. Por tanto en este punto tendremos al menos los siguientes ficheros:

drivers.list
grexec.f
grpckg1.inc
makefile
pgplot.inc
rgb.txt

Deberímos comprobar que estos ficheros han sido creados, y también que la lista de controladores que makemake dice que encontró se corresponde con aquellos que seleccionamos en drivers.list. Si nuestro sistema UNIX no es uno de los soportados listados anteriormente, crearemos nuestro propio fichero de configuración en el directorio destino, con el nombre local.conf. Lo mejor es copiar uno de los ficheros de configuración proporcionados (de pgplot/sys_*/*.conf), y entonces editarlo siguiendo los comentarios en el fichero. El procedimiento makemake utilizará local.conf si existe en el directorio actual, y si no especificamos Arg#3. Nótese que todavía debemos especificar Arg#2 (sistema operativo).  

Utilizar `make' para compilar el código

Ahora utilizaremos el comando de UNIX make para compilar la librería PGPLOT siguiendo las instrucciones del makefile:

make

Por defecto, make generará: una librería objeto, libpgplot.a; una librería compartida (si es posible para el sistema operativo seleccionado), el fichero de fuente binario PGPLOT grfont.dat, los programas de demostración pgdemo*, y un fichero de documentación pgplot.doc. Además, si el controlador /XWINDOW y/o /XSERVE fue seleccionado en el paso 4, generará un programa pgxwin_server, y si fue seleccionado el controlador /XDISP, generará un programa pgdisp. Si este paso se ejecuta correctamente, podemos teclear

make clean

para eliminar los ficheros intermedios no necesarios. Entonces tendremos los siguiente ficheros en el directorio actual:

drivers.list
grexec.f
grfont.dat (fichero de fuente binario)*
libpgplot.a (librería PGPLOT)*
libpgplot.so (librería compartida, opcional)*
makefile
pgdemo1 ... pgdemo16 (programas de demostración)
pgdisp (requerido por el controlador /XDISP)*
pgplot.doc (fichero ASCII de documentación)
pgxwin_server (requerido por el controlador /XWINDOW)*
rgb.txt (base de datos de colores)*

Si pedimos XMDRIV o TKDRIV, también tendremos algunos de los siguientes ficheros:

pgmdemo (progama ejecutable de demostración)
libXmPgplot.a (librería objeto requerida por las aplicaciones PGPLOT/Motif)*
XmPgplot.h (fichero de cabecera requerido por las aplicaciones PGPLOT/Motif)*
libtkpgplot.a (librería objeto requerida por las aplicaciones PGPLOT/Tk)*
pgtkdemo (programa ejecutable de demostración)
pgtkdemo.tcl (script utilizado por el programa de demostración)
tkpgplot.h (fichero de cabecera requerido por las aplicaciones PGPLOT/Tk)*

Si queremos copiar la versión compilada de PGPLOT a otro directorio, debemos copiar al menos los ficheros marcados con un asterisco (*). El fichero de documentación contiene las descripciones de subrutinas PGPLOT, estando también disponibles en el manual.  

Ejecutar los programas de demostración

Ejecutamos los programas de demostración en nuestros dispositivos seleccionados y verificaremos que se ejecutan correctamente. Antes de lanzar cualquier programa PGPLOT, debemos asegurarnos de que la variable de entorno PGPLOT_DIR está correctamente definida. Este es el nombre del directorio en el cual el PGPLOT buscará los ficheros grfont.dat y rgb.txt (a no ser que las variables de entorno PGPLOT_FONT y PGPLOT_RGB estén definidas para ignorar este comportamiento por defecto), y, si fuese necesario, el programa servidor de X-window pgxwin_server:

UNIX csh o tcsh: setenv PGPLOT_DIR /usr/local/pgplot/
UNIX sh o bash: PGPLOT_DIR="/usr/local/pgplot/"; export PGPLOT_DIR

También es conveniente, pero no esencial, definir un dispositivo PGPLOT por defecto con la variable de entorno PGPLOT_DEV, e.g.

UNIX csh o tcsh: setenv PGPLOT_DEV /xwindow

Cuando se utilice una librería UNIX compartida (p.e., en Solaris 2.x), también se puede necesitar poner el directorio PGPLOT en la ruta de búsqueda del cargador, definida en la variable de entorno LD_LIBRARY_PATH. Para ejecutar un programa, teclearemos su nombre (con su directorio si el directorio actual no está en el path):

./pgdemo1

Todos los programas de demostración piden un nombre y un tipo de dispositivo. Se puede teclear un símbolo de interrogación para ver una lista de los tipos de dispositivos disponibles y verificar que el PGPLOT ha sido adecuadamente configurado. Los puntos que hay que comprobar son: el programa PGPLOT lee correctamente el fichero de fuente y muestra subíndices, superíndices y caracteres especiales (pgdemo2); el programa PGPLOT puede leer la base de datos de colores (pgdemo10); en dispositivos interactivos, el cursor funciona correctamente (pgdemo5, pgdemo6).  

Cómo compilar nuestro código

Tras haber instalado la librería de subrutinas de PGPLOT en nuestro sistema, podemos utilizar las subrutinas PGPLOT en nuestro código Fortran, como en el ejemplo siguiente: 
      PROGRAM EX1
      INTEGER PGOPEN, I
      REAL XS(9), YS(9), XR(101), YR(101)

C Calcular los numeros a representar.

      DO 10 I=1,101
          XR(I) = 0.1*(I-1)
          YR(I) = XR(I)**2*EXP(-XR(I))
 10   CONTINUE
      DO 20 I=1,9
          XS(I) = I
          YS(I) = XS(I)**2*EXP(-XS(I))
 20   CONTINUE

C Abrir el dispositivo de graficos.

      IF (PGOPEN(¿') .LT. 1) STOP

C Definir el rango de coordenadas del grafico (0 < x < 10, 0 < y < 0.65),
C y dibujar los ejes.

      CALL PGENV(0., 10., 0., 0.65,  0,  0)

C Etiquetar los ejes (se usa \u y \d para el exponenete).

      CALL PGLAB('x', 'y', 'PGPLOT Graph: y = x\u2\dexp(-x)')

C Se Dibuja la linea de la grafica.

      CALL PGLINE(101, XR, YR)

C Se dibujan los simbolos en los puntos seleccionados.

      CALL PGPT(9, XS, YS, 18)

C Se cierra el dispositivo de graficos.

      CALL PGCLOS

      END

Esto dibuja el siguiente gráfico:

[example]

Para ejecutar el código anterior con éxito, necesitamos enlazar la librería PGPLOT y las librerías X11 con nuestro código. El script siguiente hace eso:

g77 nombre_del_codigo.f -L/directorioX11/ -lX11 -L/directorioPGPLOT/ -lpgplot

Necesitamos incluir los siguientes ficheros en el directorio donde estamos ejecutando nuestro código:

grfont.dat
rgb.txt
pgwin server
simplemente copiaremos estos ficheros del directorio del PGPLOT al directorio donde estamos ejecutando nuestro código.  

Aplicación 1: Pasar un círculo por 3 puntos

En esta aplicación, nuestro objetivo era marcar tres puntos en la pantalla pinchando con el ratón y dejar que el código Fortran dibuje un círculo que pase por estos tres puntos. Este problema fue un ejercicio de nuestra clase de Geometría Computacional, conducida por Dr.Serdar Celebi (mscelebi(at)itu.edu.tr).

Las siguientes rutinas definen el fondo y configuración del área en la que se va a pintar el gráfico. Un uso detallado de estas subrutinas viene explicado en el manual del PGPLOT. (ver el enlace a la página del PGPLOT al final del artículo)

..
...
call PGSCR(0,1.0,1.0,1.0) !establece la representacion del color
call PGENV(-50.0,50.0,-50.0,50.0,1,1) !establece la ventana y la vista y dibuja un marco
call PGSCI(1) !establece el indice del color
call PGSFS(2) !establece el tipo de llenado de area
...
..

Utilizamos la siguiente rutina, PGPT1, para dibujar un puntero en el punto que queremos marcar con el ratón.

..
...
WRITE (*,*) 'Modo cursor:', MODE
             GOTO 10
          END IF
           CALL PGPT1(X, Y, 3)  !dibuja una marca
        ic=ic+1
        xp(i)=x
        yp(i)=y

Después de marcar tres puntos diferentes en la pantalla, el código Fortran calcula el centro y entonces dibuja el círculo pasando por estos 3 puntos.




    ..
    ...
    c-----encuentra el radio----------------
     r=(xcenter-xp(1))**2+(ycenter-yp(1))**2
     r=r**0.5
    c-----dibuja el circulo-------------------
     call PGCIRC(xcenter,ycenter,r) !dibuja un circulo
     goto 1
    ...
    ..

Dibujamos el círculo con la rutina mostrada anteriormente, "PGCIRC". Podemos limpiar el círculo predibujado y asignar los puntos desde el principio para dibujar otro círculo en el mismo área de dibujado. El código completo está incluído en las referencias (ver Ref. circle.f).

 

Aplicación 2: Dibujando líneas "porcupines" en una curva de aproximación

En esta aplicación, nuestro objetivo consistía en dibujar una curva de aproximación a través de varios puntos discretos marcados con el ratón en la pantalla y, entonces, dibujar las líneas "porcupine" en esta curva.

Las porcupines son las líneas que se utilizan para detectar puntos de inflexión no deseados, partes planas de una curva, y discontinuidades en su curvatura. Es por esto que son un concepto importante en la Geometría computacional.

Nosotros desarrollamos un código que utiliza la aproximación del mínimo cuadrado para dibujar una curva del orden deseado (1~4) a través de un conjunto de puntos que pueden ser generados aleatoriamente por el usuario a través de una interfaz gráfica utilizando el ratón. Tiene la capacidad de dibujar porcupines en la curva (cuya frecuencia se puede ajustar por el usuario) que son un indicador de la curvatura de la curva.

Saltándonos los detalles del código Fortran que hemos escrito, aquí presentamos los resultados gráficos (Podemos encontrar el código al final del artículo).

Primero introducimos los puntos discretos en la pantalla con el ratón y el código Fortran toma las coordenadas de estos puntos y las almacena en un array. Entonces aproxima la curva pasando por estos puntos según el grado indicado por el usuario.(1-4)



Entonces se dibujan las líneas porcupine en la curva. El número de líneas puede ser modificado por el usuario, y sin cambiar el fondo o los puntos el nuevo conjunto de porcupines puede ser dibujado en la misma curva.




La frecuencia de las porcupines también puede incrementarse tal y como vemos a continuación. Además el programa puede dibujar una nueva curva en el mismo conjunto de datos.



 

Conclusión

En este texto, quisimos mostrar cómo un programa de dibujado interactivo, PGPLOT, puede ser instalado bajo Linux y cuán amplias pueden llegar a ser las áreas de aplicación. Con esta lista de subrutinas somos totalmente independentes y realmente ahorramos tiempo si necesitamos ver frecuentemente una salida gráfica a cada ejecución de nuestro código. Añadiendo estas rutinas en nuestro código, el postprocesado se vuelve muy rápido y robusto.  

Referencias

 

Formulario de "talkback" para este artículo

Cada artículo tiene su propia página de "talkback". A través de esa página puedes enviar un comentario o consultar los comentarios de otros lectores
 Ir a la página de "talkback" 
Contactar con el equipo de LinuFocus
© Baybora Baran and Seckin Gokaltun, FDL
LinuxFocus.org 		Información sobre la traducción:
en --> -- : Baybora Baran and Seckin Gokaltun <baybora(at)be.itu.edu.tr, gokaltun(at)itu.edu.tr>
en --> es: Miguel Alfageme Sánchez <malfageme(at)terra.es>

2003-01-28, generated by lfparser version 2.34