La biblioteca de funciones de dibujo libplot

libplot es una biblioteca de GNU que proporciona para los entornos UNIX funciones para dibujar gráficos vectoriales bidimensionales, entre los que se incluyen caminos, que son una secuencia de líneas y arcos, círculos, elipses, puntos y cadenas de texto justificadas.
El plotter es un concepto fundamental en esta biblioteca. Corresponde a la abstracción del medio sobre el que se dibuja, que puede ser un fichero gráfico en diferentes formatos o una ventana gráfica, por ejemplo.

Las rutinas

Creación de plotters en C

Cuando se usa esta biblioteca desde un programa C hay que incluir la biblioteca plot.h. Hay que tener en cuenta además que debe añadirse el prefijo pl_ al nombre de las rutinas.
El primer paso para poder dibujar en un plotter es crearlo con la rutina pl_newpl. Esta rutina devuelve un entero (el manejador), que sirve para referirse al plotter. Antes de usarlo es necesario seleccionar el plotter, ya que puede haber varios a la vez en la aplicación, con la rutina pl_selectpl. La rutina pl_deletepl se encarga de borrar el plotter y liberar sus recursos.
int parampl (const char parametro[], void *value);
Esta rutina establece el valor de un parámetro. El parámetro se identifica mediante su nombre que se le pasa como una cadena de caracteres y el valor que se le da depende del tipo de parámetro. Por ejemplo, en un plotter X, se puede establecer el tamaño con pl_parampl ("BITMAPSIZE", "150x100");
int newpl (const char tipo[], FILE *fich_ent, FILE *fich_sal, FILE *fich_err);
Esta rutina crea un plotter del tipo que se le indique en el primer parámetro. El tipo "X" crea una ventana X donde se dibujarán los gráficos. En este caso, los dos primeros parámetros de ficheros se ignoran. De hecho, podemos trabajar pasando NULL en los tres últimos parámetros. En caso de error devuelve un valor negativo.
int selectpl (int manejador);
Esta rutina selecciona el plotter sobre el que se ejecutan las acciones de dibujo. El parámetro es el valor devuelto por la operación de creación. Si el plotter seleccionado tiene algún problema el valor devuelto es negativo.
int deletepl (int handle);
pl_deletepl deletes a Plotter, referred to by its handle. The Plotter must not be selected at the time it is deleted. A negative return value indicates the Plotter could not be deleted.

Creación de plotters en C++

En C++ los plotters se definen como una clase con subclases, que corresponden a los diferentes tipos de plotters. Para crear un plotter basta con declarar un objeto de la clase adecuada. Por ejemplo: XPlotter p(cin, cout, cerr). Los parámetros son los flujos de entrada, salida y error. En el caso concreto de los XPlotter, los dos primeros se ignoran.
Para darle valor a los parámetros se usa el método de clase int Plotter::parampl (const char parameter[], void *value); con un significado similar a la función parampl explicada anteriormente.
Para efectuar cualquier operación sobre un plotter no es necesario seleccionarlo previamente, como en el caso de C, sino que basta con ejecutar el método apropiado sobre el objeto plotter que se quiera.

Rutinas de inicialización y finalización

Las operaciones de dibujo en un plotter se deben hacer tras abrirlo, con la rutina pl_openpl y antes de cerrarlo, con la rutina pl_closepl. Un plotter se puede abrir y cerrar tantas veces como se quiera.
Generalmente, el usuario prefiere especificar las coordenadas en un sistema de referencia que dependa de la aplicación y no del tamaño del plotter de dibujo. La rutina space se encarga de relacionar las coordenadas de la ventana de dibujo con las del usuario, por lo que debería llamarse antes de dibujar. Las coordenadas que se pasan como parámetros en las rutinas de dibujo se refieren al sistema de coordenadas del usuario.
int pl_openpl ();
Esta rutina abre el plotter que esté seleccionado. Si hay algún problema devuelve un valor negativo. Si el plotter es de tipo "X" se abre una nueva ventana.
int bgcolor (int rojo, int verde, int azul);int bgcolorname (const char name[]);
La rutina bgcolor establece un nuevo color de fondo, que es el que se usa, por ejemplo, para borrar un plotter cuando se llama a la función erase. Los tres parámetros indican los tonos de rojo, verde y azul, respectivamente, en un rango de 0 a 65535. La rutina bgcolorname identifica el color mediante un nombre.
int erase ();
Esta rutina borra los objetos dibujados en el plotter rellenándolo del color de fondo.
int space (int x0, int y0, int x1, int y1);
int fspace (double x0, double y0, double x1, double y1);
Esta rutina establece la relación entre el sistema de coordenadas del plotter y la del usuario.
int pl_closepl ();
Esta rutina cierra un plotter y acaba una página de gráficos.

Rutinas de dibujo

La mayoría de las rutinas de dibujo de figuras geométricas tienen varias versiones en las que las coordenadas que se les pasan pueden ser valores enteros o reales y ser valores absolutos respecto al origen de coordenadas o relativos a la posición actual de escritura.
int alabel (int justif_horiz, int justif_vert, const char cad[]);
Esta rutina escribe una cadena en pantalla con las justificaciones horizontal y vertical que se le indican. Los valores para la justificación horizontal son 'l', 'c', o 'r', y 'b', 'x', 'c', o 't' para la vertical.
int arc (int xc, int yc, int x0, int y0, int x1, int y1);
Esta rutina dibuja un arco que empieza en (x0, y0), tiene el centro en (xc, yc) y acaba en (x1, y1).
int box (int x1, int y1, int x2, int y2);
Esta rutina dibuja un rectángulo cuya esquina inferior izquierda está en (x1, y1) y la superior derecha en (x2, y2).
int circle (int xc, int yc, int r);
Esta rutina dibuja un círculo con el centro en la posición (xc, yc) y de radio r.
int ellipse (int xc, int yc, int rx, int ry, int ang);
Esta rutina dibuja una elipse con centro en (xc, yc), radios rx y ry y una inclinación del primer semieje.
int line (int x1, int y1, int x2, int y2);
Esta rutina dibuja una línea que empieza en (x1,y1) y acaba en (x2,y2).
int point (int x, int y);
Esta función dibuja un punto en la coordenada (x, y).

Rutinas de actualización de atributos

int fillcolor (int red, int green, int blue);
Esta rutina establece el color de relleno en base a los tonos de rojo, verde y azul, respectivamente. Los tonos oscilan entre 0 (negro) y 65535 (blanco).
int fontsize (int size);
Esta rutina establece el tamaño del texto que se escribe.
int linewidth (int size);
Esta rutina establece el ancho de las líneas que se dibujan.
int move (int x, int y);
Esta rutina mueve el cursor a la posición (x,y).
int pencolor (int red, int green, int blue);
Esta rutina establece el color de dibujo en base a los tonos de rojo, verde y azul, respectivamente. Los tonos oscilan entre 0 (negro) y 65535 (blanco).

Algunos enlaces con más información

1  Ejemplos

1.1  Ejemplo en C

Para compilar es necesario incluir la biblioteca plot.h. Para linkar es necesario añadir los flags: -lplot -lXaw -lXmu -lXt -lXext -lX11 -lm.
Este programa dibuja la curva C de Bill Gosper, cuya forma cambia en función del valor de MAXORDER. 
 #include <stdio.h>
 #include <plot.h>
 #define MAXORDER 12

 void draw_c_curve (double dx, double dy, int order) {
  if (order >= MAXORDER)
    pl_fcontrel (dx, dy);     /* continue path along (dx, dy) */
  else
    {
      draw_c_curve (0.5 * (dx - dy), 0.5 * (dx + dy), order + 1);
      draw_c_curve (0.5 * (dx + dy), 0.5 * (dy - dx), order + 1);
    }
 }

 int main () {
  int handle;

  /* establece el par\'{a}metro del tama\~{n}o del plotter */
  pl_parampl ("BITMAPSIZE", "500x500");

  /* crear el ploter */
  if ((handle = pl_newpl ("X", stdin, stdout, stderr)) < 0)
    {
      fprintf (stderr, "Error al crear el plotter\n");
      return 1;
    }
  pl_selectpl (handle);            /* seleccionar el plotter */

  if (pl_openpl () < 0)            /* abrir el plotter */
    {
      fprintf (stderr, "Error al abrir el plotter\n");
      return 1;
    }
  pl_space (0.0, 0.0, 1000, 1000); /* especifica el sist. de coords. del usuario */
  pl_flinewidth (0.25);            /* ancho de las lineas */
  pl_pencolorname (65535, 0, 0);   /* color de dibujo rojo */
  pl_erase ();                     /* borrar el plotter */
  pl_move (600, 300);              /* coloca el cursor */
  draw_c_curve (0.0, 400.0, 0);
  if (pl_closepl () < 0)           /* cerrar Plotter */
    {
      fprintf (stderr, "Error al cerrar el plotter\n");
      return 1;
    }

  pl_selectpl (0);                 /* seleccionar el plotter por defecto */
  if (pl_deletepl (handle) < 0)    /* borrar el plotter que hemos usado */
    {
      fprintf (stderr, "Error al borrar el plotter\n");
      return 1;
    }
  return 0;
 }

1.2  Ejemplo en C++

Para compilar es necesario incluir la biblioteca plotter.h. Para linkar es necesario añadir los flags: -lplotter -lXaw -lXmu -lXt -lXext -lX11 -lm.
Este es el mismo programa, pero en C++. 
 #include <plotter.h>
 #define MAXORDER 12

 void draw_c_curve (Plotter& plotter, double dx, double dy, int order) {
  if (order >= MAXORDER)
    plotter.fcontrel (dx, dy);  // continue path along (dx, dy)
  else
    {
      draw_c_curve (plotter,
                    0.5 * (dx - dy), 0.5 * (dx + dy), order + 1);
      draw_c_curve (plotter,
                    0.5 * (dx + dy), 0.5 * (dy - dx), order + 1);
    }
 }

 int main () {
  // set a Plotter parameter
  Plotter::parampl ("BITMAPSIZE", "500x500");

  XPlotter plotter(cin, cout, cerr); // declara Plotter
  if (plotter.openpl () < 0)          // abre Plotter
    {
      cerr << "Error al abrir el plotter\n";
      return 1;
    }

  plotter.fspace (0.0, 0.0, 1000.0, 1000.0); // especifica sis. de coordenadas del usuario
  plotter.flinewidth (0.25);       // ancho de las lineas en coords. de usuario
  plotter.pencolor (65535,0,0);    // color de dibujo rojo
  plotter.erase ();                // borrar la ventana
  plotter.fmove (600.0, 300.0);    // colocar el cursor grafico
  draw_c_curve (plotter, 0.0, 400.0, 0);
  if (plotter.closepl () < 0)      // close Plotter
    {
      cerr << "Error al cerrar el plotter\n";
      return 1;
    }
  return 0;
 }


File translated from TEX by TTH, version 3.59.
On 06 May 2004, 19:29.