@c English version 2016-01-26
@menu
* Introducción a draw::
* Funciones y variables para draw::
* Funciones y variables para picture::
* Funciones y variables para worldmap::
@end menu





@node Introducción a draw, Funciones y variables para draw, draw, draw
@section Introducción a draw


@code{draw} es un interfaz para comunicar Maxima con Gnuplot.

Tres son las funciones principales a utilizar a nivel de Maxima: 
@code{draw2d}, @code{draw3d} y @code{draw}.

Síganse estos enlaces para ver ejemplos más elaborados
de este paquete:

@url{http://tecnostats.net/Maxima/gnuplot}

y 

@url{http://tecnostats.net/Maxima/vtk}

Se necesita tener instalado Gnuplot 4.2 o superior para ejecutar este paquete.





@node Funciones y variables para draw, Funciones y variables para picture, Introducción a draw, draw
@section Funciones y variables para draw



@subsection Escenas



@deffn {Constructor de escena} gr2d (@var{Opción gráfica}, ..., @var{graphic_object}, ...)

La función @code{gr2d} construye un objeto que describe una escena 2d. Los
argumentos son @i{opciones gráficas} y @i{objetos gráficos}
o listas que contengan elementos de ambos tipos. Esta escena
se interpreta secuencialmente: las @i{opciones gráficas} afectan a aquellos
@i{objetos gráficos} colocados a su derecha. Algunas @i{opciones gráficas}
afectan al aspecto global de la escena.

La lista de @i{objetos gráficos} disponibles para escenas en dos
dimensiones: @code{bars}, @code{ellipse}, @code{explicit}, @code{image},
@code{implicit}, @code{label}, @code{parametric}, @code{points}, @code{polar},
@code{polygon}, @code{quadrilateral}, @code{rectangle}, @code{triangle},
@code{vector} y @code{geomap} (este último definido en el paquete @code{worldmap}).

Véanse también @code{draw} y @code{draw2d}.

Para utilizar este objecto, ejecútese primero @code{load(draw)}.
@end deffn


@deffn {Constructor de escena} gr3d (@var{Opción gráfica}, ..., @var{graphic_object}, ...)

La función @code{gr3d} construye un objeto que describe una escena 3d. Los
argumentos son @i{opciones gráficas} y @i{objetos gráficos}
o listas que contengan elementos de ambos tipos. Esta escena
se interpreta secuencialmente: las @i{opciones gráficas} afectan a aquellos
@i{objetos gráficos} colocados a su derecha. Algunas @i{opciones gráficas}
afectan al aspecto global de la escena.

La lista de @i{objetos gráficos} disponibles para escenas en tres
dimensiones: @code{cylindrical}, @code{elevation_grid}, @code{explicit}, 
@code{implicit}, @code{label}, @code{mesh}, @code{parametric}, 
@code{parametric_surface}, @code{points}, @code{quadrilateral}, 
@code{spherical}, @code{triangle}, @code{tube}, @code{vector}
y @code{geomap} (este último definido en el paquete @code{worldmap}).

Véanse también @code{draw} y @code{draw3d}.

Para utilizar este objeto, ejecútese primero @code{load(draw)}.
@end deffn





@subsection Funciones




@deffn {Función} draw (@var{gr2d}, ..., @var{gr3d}, ..., @var{options}, ...)

Representa gráficamente una serie de escenas; sus argumentos son objetos
@code{gr2d} y/o @code{gr3d}, junto con algunas opciones, o listas de escenas y opciones.
Por defecto, las escenas se representan en una columna.

La función @code{draw} acepta las siguientes opciones globales: @code{terminal},
@code{columns}, @code{dimensions}, @code{file_name} y @code{delay}.

Las funciones @code{draw2d} y @code{draw3d} son atajos a utilizar
cuando se quiere representar una única escena en dos o tres
dimensiones, respectivamente.

Véanse también @code{gr2d} y @code{gr3d}.

Para utilizar esta función, ejecútese primero @code{load(draw)}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) scene1: gr2d(title="Ellipse",
                   nticks=30,
                   parametric(2*cos(t),5*sin(t),t,0,2*%pi))$
(%i3) scene2: gr2d(title="Triangle",
                   polygon([4,5,7],[6,4,2]))$
(%i4) draw(scene1, scene2, columns = 2)$
@end example

Las dos sentencias gráficas siguientes son equivalentes:
@example
(%i1) load(draw)$
(%i2) draw(gr3d(explicit(x^2+y^2,x,-1,1,y,-1,1)));
(%o2)                          [gr3d(explicit)]
(%i3) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1));
(%o3)                          [gr3d(explicit)]
@end example

Un fichero gif animado:
@example
(%i1) load(draw)$
(%i2) draw(
        delay     = 100,
        file_name = "zzz",
        terminal  = 'animated_gif,
        gr2d(explicit(x^2,x,-1,1)),
        gr2d(explicit(x^3,x,-1,1)),
        gr2d(explicit(x^4,x,-1,1)));
End of animation sequence
(%o2)          [gr2d(explicit), gr2d(explicit), gr2d(explicit)]
@end example

Véanse también @code{gr2d}, @code{gr3d}, @code{draw2d} y @code{draw3d}.
@end deffn




@deffn {Función} draw2d (@var{option}, @var{graphic_object}, ...)

Esta función es un atajo para
@code{draw(gr2d(@var{options}, ..., @var{graphic_object}, ...))}.

Puede utilizarse para representar una única escena en 2d.

Para utilizar esta función, ejecútese primero @code{load(draw)}.

Véanse también @code{draw} y @code{gr2d}.
@end deffn


@deffn {Función} draw3d (@var{option}, @var{graphic_object}, ...)

Esta función es un atajo para
@code{draw(gr3d(@var{options}, ..., @var{graphic_object}, ...))}.

Puede utilizarse para representar una única escena en 3d.

Para utilizar esta función, ejecútese primero @code{load(draw)}.

Véanse también @code{draw} y @code{gr3d}.
@end deffn



@deffn {Función} draw_file (@var{Opción gráfica}, ..., @var{Opción gráfica}, ...)

Almacena el gráfico actual en un fichero. Las opciones gráficas que
acepta son: @code{terminal}, @code{dimensions} y@code{file_name}. 

Ejemplo:

@example
(%i1) load(draw)$
(%i2) /* dibujo en pantalla */
      draw(gr3d(explicit(x^2+y^2,x,-1,1,y,-1,1)))$
(%i3) /* same plot in eps format */
      draw_file(terminal  = eps,
                dimensions = [5,5]) $
@end example
@end deffn




@deffn {Función} multiplot_mode (@var{term})

Esta función permite a Maxima trabajar en modo de gráficos múltiples en
una sola ventana del terminal @var{term}; argumentos válidos para esta función 
son @code{screen}, @code{wxt}, @code{aquaterm} y @code{none}.

Cuando el modo de gráficos múltiples está activo, cada llamada a @code{draw}
envía un nuevo gr'afico a la misma ventana, sin borrar los anteriores.
Para desactivar el modo de gráficos múltiples escríbase
@code{multiplot_mode(none)}.

Cuando el modo de gráficos múltiples está activo, la opción global @code{terminal} 
se bloquea; para desbloquearla y cambiar de terminal es necesario desactivar 
previamente el modo de gráficos múltiples.

Este modo de trabajo no funciona en plataformas Windows.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) set_draw_defaults(
         xrange = [-1,1],
         yrange = [-1,1],
         grid   = true,
         title  = "Step by step plot" )$
(%i3) multiplot_mode(screen)$
(%i4) draw2d(color=blue,  explicit(x^2,x,-1,1))$
(%i5) draw2d(color=red,   explicit(x^3,x,-1,1))$
(%i6) draw2d(color=brown, explicit(x^4,x,-1,1))$
(%i7) multiplot_mode(none)$
@end example
@end deffn




@deffn {Función} set_draw_defaults (@var{Opción gráfica}, ..., @var{Opción gráfica}, ...)

Establece las opciones gráficas de usuario. Esta función es útil 
para dibujar varios gráficos con las mismas opciones. Llamando
a la función sin argumentos se borran las opciones de usuario por defecto.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) set_draw_defaults(
         xrange = [-10,10],
         yrange = [-2, 2],
         color  = blue,
         grid   = true)$
(%i3) /* dibujo con opciones de usuario */
      draw2d(explicit(((1+x)**2/(1+x*x))-1,x,-10,10))$
(%i4) set_draw_defaults()$
(%i5) /* dibujo con opciones por defecto */
      draw2d(explicit(((1+x)**2/(1+x*x))-1,x,-10,10))$
@end example

Para utilizar esta función, ejecútese primero @code{load(draw)}.
@end deffn





@subsection Opciones gráficas





@defvr {Opción gráfica} adapt_depth
Valor por defecto: 10

@code{adapt_depth} es el número máximo de particiones utilizadas por
la rutina gráfica adaptativa.

Esta opción sólo es relevante para funciones de tipo @code{explicit} en 2d.
@end defvr


@defvr {Opción gráfica} allocation
Valor por defecto: @code{false}

Con la opción @code{allocation} es posible colocar a voluntad una escena en la
ventana de salida, lo cual resulta de utilidad en el caso de gráficos 
múltiples. Cuando la opción toma el valor @code{false}, la escena se coloca
de forma automática, dependiendo del valor asignado a la opción @code{columns}.
En cualquier otro caso, a @code{allocation} se le debe asignar una lista con dos
pares de números; el primero se corresponde con la posición de la esquina
inferior izquierda del gráfico y el segundo par hace referencia al ancho y alto
de la escena. Todas las cantidades deben darse en coordenadas relativas, entre
0 y 1.

Ejemplos:

Gráficos internos.

@example
(%i1) load(draw)$
(%i2) draw(
        gr2d(
          explicit(x^2,x,-1,1)),
        gr2d(
          allocation = [[1/4, 1/4],[1/2, 1/2]],
          explicit(x^3,x,-1,1),
          grid = true) ) $
@end example

Multiplot con dimensiones establecidas por el usuario.

@example
(%i1) load(draw)$
(%i2) draw(
        terminal = wxt,
        gr2d(
          allocation = [[0, 0],[1, 1/4]],
          explicit(x^2,x,-1,1)),
        gr3d(
          allocation = [[0, 1/4],[1, 3/4]],
          explicit(x^2+y^2,x,-1,1,y,-1,1) ))$
@end example

Véase también la opción @code{columns}.
@end defvr



@defvr {Opción gráfica} axis_3d
Valor por defecto: @code{true}

Cuando @code{axis_3d} vale @code{true}, los ejes @var{x}, @var{y} y @var{z}
permanecen visibles en las escenas 3d.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(axis_3d = false,
             explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$
@end example

Véanse también @code{axis_bottom},  @code{axis_left}, @code{axis_top} y @code{axis_right} for axis in 2d.
@end defvr




@defvr {Opción gráfica} axis_bottom
Valor por defecto: @code{true}

Cuando @code{axis_bottom} vale @code{true}, el eje inferior permanece visible en las escenas 2d.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(axis_bottom = false,
             explicit(x^3,x,-1,1))$
@end example

Véanse también @code{axis_left},  @code{axis_top}, @code{axis_right} y @code{axis_3d}.
@end defvr




@defvr {Opción gráfica} axis_left
Valor por defecto: @code{true}

Cuando @code{axis_left} vale @code{true}, el eje izquierdo permanece visible en las escenas 2d.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(axis_left = false,
             explicit(x^3,x,-1,1))$
@end example

Véanse también @code{axis_bottom},  @code{axis_top}, @code{axis_right} y @code{axis_3d}.
@end defvr




@defvr {Opción gráfica} axis_right
Valor por defecto: @code{true}

Cuando @code{axis_right} vale @code{true}, el eje derecho permanece visible en las escenas 2d.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(axis_right = false,
             explicit(x^3,x,-1,1))$
@end example

Véanse también @code{axis_bottom},  @code{axis_left}, @code{axis_top} y @code{axis_3d}.
@end defvr




@defvr {Opción gráfica} axis_top
Valor por defecto: @code{true}

Cuando @code{axis_top} vale @code{true}, el eje superior permanece visible en las escenas 2d.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(axis_top = false,
             explicit(x^3,x,-1,1))$
@end example

Véanse también @code{axis_bottom},  @code{axis_left}, @code{axis_right} y @code{axis_3d}.
@end defvr




@defvr {Opción gráfica} background_color
Valor por defecto: @code{white}

Establece el color de fondo en los terminales @code{gif}, @code{png}, @code{jpg}
y @code{gif}. El color de fondo por defecto es blanco.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Esta opción no es compatible con los terminales @code{epslatex} y @code{epslatex_standalone}.

Véase también @code{color}.
@end defvr




@defvr {Opción gráfica} border
Valor por defecto: @code{true}

Cuando @code{border} vale @code{true}, los bordes de los
polígonos se dibujan de acuerdo con @code{line_type} y
@code{line_width}.

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr2d}: @code{polygon}, @code{rectangle} y @code{ellipse}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(color       = brown,
             line_width  = 8,
             polygon([[3,2],[7,2],[5,5]]),
             border      = false,
             fill_color  = blue,
             polygon([[5,2],[9,2],[7,5]]) )$
@end example
@end defvr




@defvr {Opción gráfica} capping
Valor por defecto: @code{[false, false]}

Una lista de dos elementos, @code{true} y @code{false},
indicando si los extremos de un objeto gráfico @code{tube}
permanece abiertos o si deben ser cerrados. Por defecto, ambos
extremos se dejan abiertos.

La asignación @code{capping = false} equivale a @code{capping = [false, false]}
y @code{capping = true} equivale a @code{capping = [true, true]}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(
        capping = [false, true],
        tube(0, 0, a, 1,
             a, 0, 8) )$
@end example

@end defvr



@defvr {Opción gráfica} cbrange
Valor por defecto: @code{auto}

Cuando @code{cbrange} vale @code{auto}, el rango de los valores que se
colorean cuando @code{enhanced3d} es diferente de @code{false} se calcula
automáticamente. Valores fuera del rango utilizan el color del valor
extremo más cercano.

Cuando @code{enhanced3d} o @code{colorbox} vale @code{false}, la 
opción @code{cbrange} no tiene efecto alguno.

Si el usuario quiere especificar un intervalo para los valores a colorear,
éste debe expresarse como una lista de Maxima, como en @code{cbrange=[-2, 3]}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d (
        enhanced3d     = true,
        color          = green,
        cbrange = [-3,10],
        explicit(x^2+y^2, x,-2,2,y,-2,2)) $
@end example

Véanse también @code{enhanced3d} y @code{cbtics}.
@end defvr



@defvr {Opción gráfica} cbtics
Valor por defecto: @code{auto}

Esta opción gráfica controla la forma en la que se dibujarán
las marcas en la escala de color cuando la opción @code{enhanced3d}
sea diferente de @code{false}.

Cuando @code{enhanced3d} o @code{colorbox} vale @code{false}, la 
opción @code{cbtics} no tiene efecto alguno.

Véase @code{xtics} para una descripción completa.

Ejemplo :

@example
(%i1) load(draw)$
(%i2) draw3d (
        enhanced3d = true,
        color      = green,
        cbtics  = @{["High",10],["Medium",05],["Low",0]@},
        cbrange = [0, 10],
        explicit(x^2+y^2, x,-2,2,y,-2,2)) $
@end example

See also @code{enhanced3d}, @code{colorbox} and @code{cbrange}.
@end defvr



@defvr {Opción gráfica} color
Valor por defecto: @code{blue}

@code{color} especifica el color para dibujar líneas,
puntos, bordes de polígonos y etiquetas.

Los colores se pueden dar a partir de sus nombres o en
código hexadecimal @i{rgb}.

Los nombres de colores disponibles son: 
@code{white}, @code{black}, @code{gray0}, @code{grey0}, @code{gray10},
@code{grey10}, @code{gray20}, @code{grey20}, @code{gray30}, @code{grey30},
@code{gray40}, @code{grey40}, @code{gray50}, @code{grey50}, @code{gray60},
@code{grey60}, @code{gray70}, @code{grey70}, @code{gray80}, @code{grey80},
@code{gray90}, @code{grey90}, @code{gray100}, @code{grey100}, @code{gray},
@code{grey}, @code{light_gray}, @code{light_grey}, @code{dark_gray},
@code{dark_grey}, @code{red}, @code{light_red}, @code{dark_red}, @code{yellow},
@code{light_yellow}, @code{dark_yellow}, @code{green}, @code{light_green},
@code{dark_green}, @code{spring_green}, @code{forest_green}, @code{sea_green},
@code{blue}, @code{light_blue}, @code{dark_blue}, @code{midnight_blue}, 
@code{navy}, @code{medium_blue}, @code{royalblue}, @code{skyblue}, 
@code{cyan}, @code{light_cyan}, @code{dark_cyan}, @code{magenta}, 
@code{light_magenta}, @code{dark_magenta}, @code{turquoise}, 
@code{light_turquoise}, @code{dark_turquoise}, @code{pink}, @code{light_pink},
@code{dark_pink}, @code{coral}, @code{light_coral}, @code{orange_red},
@code{salmon}, @code{light_salmon}, @code{dark_salmon}, @code{aquamarine},
@code{khaki}, @code{dark_khaki}, @code{goldenrod}, @code{light_goldenrod},
@code{dark_goldenrod}, @code{gold}, @code{beige}, @code{brown}, @code{orange},
@code{dark_orange}, @code{violet}, @code{dark_violet}, @code{plum} y @code{purple}.

Las componentes cromáticas en código hexadecimal se introducen 
en el formato @code{"#rrggbb"}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^2,x,-1,1), /* default is black */
             color = red,
             explicit(0.5 + x^2,x,-1,1),
             color = blue,
             explicit(1 + x^2,x,-1,1),
             color = light_blue,
             explicit(1.5 + x^2,x,-1,1),
             color = "#23ab0f",
             label(["This is a label",0,1.2])  )$
@end example

Véase también @code{fill_color}.
@end defvr



@defvr {Opción gráfica} colorbox
Valor por defecto: @code{true}

Cuando @code{colorbox} vale @code{true}, se dibuja una escala de colores sin
título al lado de los objetos @code{image} en 2D o de objetos
coloreados en 3D. Cuando @code{colorbox} vale @code{false}, no se presenta
la escala de colores. Cuando @code{colorbox} es una cadena de caracteres,
se mostrará la escala de colores con un título.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

Escala de colores e imágenes.

@example
(%i1) load(draw)$
(%i2) im: apply('matrix,
                 makelist(makelist(random(200),i,1,30),i,1,30))$
(%i3) draw2d(image(im,0,0,30,30))$
(%i4) draw2d(colorbox = false, image(im,0,0,30,30))$
@end example

Escala de colores y objeto 3D coloreado.

@example
(%i1) load(draw)$
(%i2) draw3d(
        colorbox   = "Magnitude",
        enhanced3d = true,
        explicit(x^2+y^2,x,-1,1,y,-1,1))$
@end example

Véase también @code{palette}.
@end defvr




@defvr {Opción gráfica} columns
Valor por defecto: 1

@code{columns} es el número de columnas en gráficos múltiples.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia. También puede
usarse como argumento de la función @code{draw}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) scene1: gr2d(title="Ellipse",
                   nticks=30,
                   parametric(2*cos(t),5*sin(t),t,0,2*%pi))$
(%i3) scene2: gr2d(title="Triangle",
                   polygon([4,5,7],[6,4,2]))$
(%i4) draw(scene1, scene2, columns = 2)$
@end example

@end defvr



@defvr {Opción gráfica} contour
Valor por defecto: @code{none}

La opción @code{contour} permite al usuario decidir dónde colocar
las líneas de nivel.
Valores posibles son:

@itemize @bullet

@item
@code{none}:
no se dibujan líneas de nivel.

@item
@code{base}:
las líneas de nivel se proyectan sobre el plano xy.

@item
@code{surface}:
las líneas de nivel se dibujan sobre la propia superficie.

@item
@code{both}:
se dibujan dos conjuntos de líneas de nivel: sobre
la superficie y las que se proyectan sobre el plano xy.

@item
@code{map}:
las líneas de nivel se proyectan sobre el plano xy
y el punto de vista del observador se coloca perpendicularmente a él.

@end itemize

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
             contour_levels = 15,
             contour        = both,
             surface_hide   = true) $
@end example

Véase también @code{contour_levels}.
@end defvr



@defvr {Opción gráfica} contour_levels
Valor por defecto: 5

Esta opción gráfica controla cómo se dibujarán las líneas
de nivel. A @code{contour_levels} se le puede asignar un número entero
positivo, una lista de tres números o un conjunto numérico arbitrario:

@itemize @bullet
@item
Si a @code{contour_levels} se le asigna un entero positivo @var{n},
entonces se dibujarán @var{n} líneas de nivel a intervalos
iguales. Por defecto, se dibujaán cinco isolíneas.

@item
Si a @code{contour_levels} se le asigna una lista de tres números de la
forma @code{[inf,p,sup]}, las isolíneas se dibujarán
desde @code{inf} hasta @code{sup} en pasos de amplitud @code{p}.

@item
Si a @code{contour_levels} se le asigna un conjunto de números de la
forma @code{@{n1, n2, ...@}}, entonces se dibujarán las
isolíneas correspondientes a los niveles @code{n1},
@code{n2}, ...
@end itemize

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia. 

Ejemplos:

Diez isolíneas igualmente espaciadas. El número
real puede ajustarse a fin de poder conseguir etiquetas más
sencillas.
@example
(%i1) load(draw)$
(%i2) draw3d(color = green,
             explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
             contour_levels = 10,
             contour        = both,
             surface_hide   = true) $
@end example


Desde -8 hasta 8 en pasos de amplitud 4.
@example
(%i1) load(draw)$
(%i2) draw3d(color = green,
             explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
             contour_levels = [-8,4,8],
             contour        = both,
             surface_hide   = true) $
@end example

Líneas correspondientes a los niveles -7, -6, 0.8 y 5.
@example
(%i1) load(draw)$
(%i2) draw3d(color = green,
             explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
             contour_levels = @{-7, -6, 0.8, 5@},
             contour        = both,
             surface_hide   = true) $
@end example

Véase también @code{contour}.
@end defvr




@defvr {Opción gráfica} data_file_name
Valor por defecto: @code{"data.gnuplot"}

@code{data_file_name} es el nombre del fichero que almacena
la información numérica que necesita Gnuplot para crear
el gráfico solicitado.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia. También puede
usarse como argumento de la función @code{draw}.

Véase ejemplo en @code{gnuplot_file_name}.

@end defvr



@defvr {Opción gráfica} delay
Valor por defecto: 5

Este es el retraso en centésimas de segundo entre imágenes
en los ficheros gif animados.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia. También puede
usarse como argumento de la función @code{draw}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw(
        delay     = 100,
        file_name = "zzz",
        terminal  = 'animated_gif,
        gr2d(explicit(x^2,x,-1,1)),
        gr2d(explicit(x^3,x,-1,1)),
        gr2d(explicit(x^4,x,-1,1)));
End of animation sequence
(%o2)          [gr2d(explicit), gr2d(explicit), gr2d(explicit)]
@end example

La opciób @code{delay} sólo se activa en caso de gifs animados; se ignora en
cualquier otro caso.

Véanse también @code{terminal}, @code{dimensions}.
@end defvr



@defvr {Opción gráfica} dimensions
Valor por defecto: @code{[600,500]}

Dimensiones del terminal de salida. Su valor es una lista formada
por el ancho y el alto. El significado de estos dos números
depende del terminal con el que se esté trabajando.

Con los terminales @code{gif}, @code{animated_gif}, @code{png}, @code{jpg},
@code{svg}, @code{screen}, @code{wxt} y @code{aquaterm}, los enteros
representan números de puntos en cada dirección. Si no son enteros
se redondean.

Con los terminales @code{eps}, @code{eps_color}, @code{pdf} y
@code{pdfcairo}, los números representan centésimas de cm,
lo que significa que, por defecto, las imágenes en estos
formatos tienen 6 cm de ancho por 5 cm de alto.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia. También puede
usarse como argumento de la función @code{draw}.

Ejemplos:

La opción @code{dimensions} aplicada a un fichero de salida y al
lienzo wxt.

@example
(%i1) load(draw)$
(%i2) draw2d(
        dimensions = [300,300],
        terminal   = 'png,
        explicit(x^4,x,-1,1)) $
(%i3) draw2d(
        dimensions = [300,300],
        terminal   = 'wxt,
        explicit(x^4,x,-1,1)) $
@end example

La opción @code{dimensions} aplicada a una salida eps.
En este caso queremos un fichero eps con dimensiones A4.

@example
(%i1) load(draw)$
(%i2) A4portrait: 100*[21, 29.7]$
(%i3) draw3d(
        dimensions = A4portrait,
        terminal   = 'eps,
        explicit(x^2-y^2,x,-2,2,y,-2,2)) $
@end example
@end defvr



@defvr {Opción gráfica} draw_realpart
Valor por defecto: @code{true}

Cuando vale @code{true}, las funciones a dibujar se consideran funciones complejas cuyas
partes reales se deben dibujar; cuando la opción vale @code{false}, no se dibujará
nada en caso de que la función no devuelve valores reales.

Esta opción afecta a los objetos @code{explicit} y @code{parametric} en 2D y 3D, y al
objeto @code{parametric_surface}.

Ejemplo:

La opción @code{draw_realpart} afecta a los objetos @code{explicit} y @code{parametric}.

@example
(%i1) load(draw)$
(%i2) draw2d(
        draw_realpart = false,
        explicit(sqrt(x^2  - 4*x) - x, x, -1, 5),
        color         = red,
        draw_realpart = true,
        parametric(x,sqrt(x^2  - 4*x) - x + 1, x, -1, 5) );
@end example

@end defvr



@defvr {Opción gráfica} enhanced3d
Valor por defecto: @code{none}

Cuando @code{enhanced3d} vale @code{none}, las superficies no se colorean en escenas 3D.
Para obtener una superficie coloreada se debe asignar una lista a la opción
@code{enhanced3d}, en la que el primer elemento es una expresión y el resto
son los nombres de las variables o parámetros utilizados en la expresión.
Una lista tal como @code{[f(x,y,z), x, y, z]} significa que al punto 
@code{[x,y,z]} de la superficie se le asigna el número @code{f(x,y,z)}, el
cual será coloreado de acuerdo con el valor actual de @code{palette}.
Para aquellos objetos gráficos 3D definidos en términos de parámetros,
es posible definir el número de color en términos de dichos parámetros,
como en @code{[f(u), u]}, para los objetos @code{parametric} y @code{tube},
o @code{[f(u,v), u, v]}, para el objeto @code{parametric_surface}.
Mientras que todos los objetos 3D admiten el modelo basado en coordenadas
absolutas, @code{[f(x,y,z), x, y, z]}, solamente dos de ellos, esto es
@code{explicit} y @code{elevation_grid}, aceptan también el modelo basado en las
coordenadas @code{[x,y]}, @code{[f(x,y), x, y]}. El objeto 3D @code{implicit}
acepta solamente el modelo @code{[f(x,y,z), x, y, z]}. El objeto @code{points} 
también acepta el modelo @code{[f(x,y,z), x, y, z]}, pero cuando los puntos
tienen naturaleza cronológica también admite el modelo @code{[f(k), k]},
siendo @code{k} un parámetro de orden.

Cuando a @code{enhanced3d} se le asigna algo diferente de @code{none}, se ignoran
las opciones @code{color} y @code{surface_hide}.

Los nombres de las variables definidas en las listas pueden ser diferentes
de aquellas utilizadas en las definiciones de los objetos gráficos.

A fin de mantener compatibilidad con versiones anteriores, @code{enhanced3d = false} 
es equivalente a @code{enhanced3d = none} y @code{enhanced3d = true} es
equivalente a @code{enhanced3d = [z, x, y, z]}. Si a @code{enhanced3d} se le
asigna una expresión, sus variables deben ser las mismas utilizadas en la
definición de la superficie. Esto no es necesario cuando se utilizan listas.

Sobre la definición de paletas, véase @code{palette}.

Ejemplos:

Objeto @code{explicit} con coloreado definido por el modelo @code{[f(x,y,z), x, y, z]}.

@example
(%i1) load(draw)$
(%i2) draw3d(
         enhanced3d = [x-z/10,x,y,z],
         palette    = gray,
         explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$
@end example

Objeto @code{explicit} con coloreado definido por el modelo @code{[f(x,y), x, y]}.
Los nombres de las variables definidas en las listas pueden ser diferentes
de aquellas utilizadas en las definiciones de los objetos gráficos 3D; en este
caso, @code{r} corresponde a @code{x} y @code{s} a @code{y}.

@example
(%i1) load(draw)$
(%i2) draw3d(
         enhanced3d = [sin(r*s),r,s],
         explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$
@end example

Objeto @code{parametric} con coloreado definido por el modelo @code{[f(x,y,z), x, y, z]}.

@example
(%i1) load(draw)$
(%i2) draw3d(
         nticks = 100,
         line_width = 2,
         enhanced3d = [if y>= 0 then 1 else 0, x, y, z],
         parametric(sin(u)^2,cos(u),u,u,0,4*%pi)) $
@end example

Objeto @code{parametric} con coloreado definido por el modelo @code{[f(u), u]}.
En este caso, @code{(u-1)^2} es una simplificación de @code{[(u-1)^2,u]}.

@example
(%i1) load(draw)$
(%i2) draw3d(
         nticks = 60,
         line_width = 3,
         enhanced3d = (u-1)^2,
         parametric(cos(5*u)^2,sin(7*u),u-2,u,0,2))$
@end example

Objeto @code{elevation_grid} con coloreado definido por el modelo @code{[f(x,y), x, y]}.

@example
(%i1) load(draw)$
(%i2) m: apply(
           matrix,
           makelist(makelist(cos(i^2/80-k/30),k,1,30),i,1,20)) $
(%i3) draw3d(
         enhanced3d = [cos(x*y*10),x,y],
         elevation_grid(m,-1,-1,2,2),
         xlabel = "x",
         ylabel = "y");
@end example

Objeto @code{tube} con coloreado definido por el modelo @code{[f(x,y,z), x, y, z]}.

@example
(%i1) load(draw)$
(%i2) draw3d(
         enhanced3d = [cos(x-y),x,y,z],
         palette = gray,
         xu_grid = 50,
         tube(cos(a), a, 0, 1, a, 0, 4*%pi) )$
@end example

Objeto @code{tube} con coloreado definido por el modelo @code{[f(u), u]}.
En este caso, @code{enhanced3d = -a} puede ser una simplificación de 
@code{enhanced3d = [-foo,foo]}.

@example
(%i1) load(draw)$
(%i2) draw3d(
         capping = [true, false],
         palette = [26,15,-2],
         enhanced3d = [-foo, foo],
         tube(a, a, a^2, 1, a, -2, 2) )$
@end example

Objetos @code{implicit} y @code{points} con coloreado definido por el
modelo @code{[f(x,y,z), x, y, z]}.

@example
(%i1) load(draw)$
(%i2) draw3d(
         enhanced3d = [x-y,x,y,z],
         implicit((x^2+y^2+z^2-1)*(x^2+(y-1.5)^2+z^2-0.5)=0.015,
                  x,-1,1,y,-1.2,2.3,z,-1,1)) $
(%i3) m: makelist([random(1.0),random(1.0),random(1.0)],k,1,2000)$
(%i4) draw3d(
         point_type = filled_circle,
         point_size = 2,
         enhanced3d = [u+v-w,u,v,w],
         points(m) ) $
@end example

cuando los puntos tienen naturaleza cronológica también se admite
el modelo @code{[f(k), k]}, siendo @code{k} un parámetro de orden.

@example
(%i1) load(draw)$
(%i2) m:makelist([random(1.0), random(1.0), random(1.0)],k,1,5)$
(%i3) draw3d(
         enhanced3d = [sin(j), j],
         point_size = 3,
         point_type = filled_circle,
         points_joined = true,
         points(m)) $
@end example
@end defvr



@defvr {Opción gráfica} error_type
Valor por defecto: @code{y}

Dependiendo de su valor, el cual puede ser @code{x}, @code{y} o @code{xy},
el objeto gráfico @code{errors} dibujará puntos con barras de error horizontales,
verticales, o ambas. Si @code{error_type=boxes}, se dibujarán cajas en lugar de cruces.

Véase también @code{errors}.
@end defvr



@defvr {Opción gráfica} file_name
Valor por defecto: @code{"maxima_out"}

@code{file_name} es el nombre del fichero en el que los terminales @code{png},
@code{jpg}, @code{gif}, @code{eps}, @code{eps_color}, @code{pdf}, @code{pdfcairo}
y @code{svg} guardarán el gráfico.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia. También puede
usarse como argumento de la función @code{draw}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(file_name = "myfile",
             explicit(x^2,x,-1,1),
             terminal  = 'png)$
@end example

Véanse también @code{terminal}, @code{dimensions}.
@end defvr



@defvr {Opción gráfica} fill_color
Valor por defecto: @code{"red"}

@code{fill_color} especifica el color para rellenar polígonos
y funciones explícitas bidimensionales.

Véase @code{color} para más información sobre cómo definir 
colores.
@end defvr




@defvr {Opción gráfica} fill_density
Valor por defecto: 0

@code{fill_density} es un número entre 0 y 1 que especifica
la intensidad del color de relleno (dado por @code{fill_color})
en los objetos @code{bars}.

Véase @code{bars} para ejemplos.
@end defvr




@defvr {Opción gráfica} filled_func
Valor por defecto: @code{false}

La opción @code{filled_func} establece cómo se van a rellenar las regiones
limitadas por funciones. Si @code{filled_func} vale @code{true}, la
región limitada por la función definida en el objeto @code{explicit}
y el borde inferior del la ventana gráfica se rellena con @code{fill_color}.
Si @code{filled_func} guarda la expresión de una función, entonces la
región limitada por esta función y la definida en el objeto @code{explicit}
será la que se rellene. Por defecto, las funciones explícitas
no se rellenan.

Un caso de especial utilidad es @code{filled_func=0}, con lo que se sombrea la
región limitada por el eje horizontal y la función explícita.

Esta opción sólo afecta al objeto gráfico bidimensional @code{explicit}.

Ejemplo:

Región limitada por un objeto @code{explicit} y el borde inferior
de la ventana gráfica.
@example
(%i1) load(draw)$
(%i2) draw2d(fill_color  = red,
             filled_func = true,
             explicit(sin(x),x,0,10) )$
@end example

Región limitada por un objeto @code{explicit} y la función
definida en la opción @code{filled_func}. Nótese que la 
variable en @code{filled_func} debe ser la misma que la utilizada en 
@code{explicit}.
@example
(%i1) load(draw)$
(%i2) draw2d(fill_color  = grey,
             filled_func = sin(x),
             explicit(-sin(x),x,0,%pi));
@end example

Véanse también @code{fill_color} y @code{explicit}.
@end defvr



@defvr {Opción gráfica} font
Valor por defecto: @code{""} (cadena vacía)

Esta opción permite seleccionar el tipo de fuente a utilizar por el
terminal. Sólo se puede utilizar un tipo de fuente y tamaño por
gráfico.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Véase también @code{font_size}.

Gnuplot no puede gestionar por sí mismo las fuentes,
dejando esta tarea a las librerías que dan soporte a los
diferentes terminales, cada uno con su propia manera de controlar
la tipografía. A continuación un breve resumen:

@itemize @bullet
@item
@i{x11}:
Utiliza el mecanismo habitual para suministrar las fuentes en x11.

Ejemplo:
@example
(%i1) load(draw)$
(%i2) draw2d(font      = "Arial", 
             font_size = 20,
             label(["Arial font, size 20",1,1]))$
@end example

@item
@i{windows}:
El terminal de windows no permite cambiar fuentes desde dentro
del gráfico. Una vez se ha creado el gráfico, se pueden cambiar las
fuentes haciendo clic derecho en el menú de la ventana gráfica.

@item
@i{png, jpeg, gif}:
La librería @i{libgd} utiliza la ruta a las fuentes
almacenada en la variable de entorno @code{GDFONTPATH}; en tal caso
sólo es necesario darle a la opción @code{font} el nombre de la
fuente. También es posible darle la ruta completa al fichero de la fuente.

Ejemplos:

A la opción @code{font} se le puede dar la ruta completa al fichero de la fuente:
@example
(%i1) load(draw)$
(%i2) path: "/usr/share/fonts/truetype/freefont/" $
(%i3) file: "FreeSerifBoldItalic.ttf" $
(%i4) draw2d(
        font      = concat(path, file), 
        font_size = 20,
        color     = red,
        label(["FreeSerifBoldItalic font, size 20",1,1]),
        terminal  = png)$
@end example

Si la variable de entorno @code{GDFONTPATH} almacena la ruta
a la carpeta donde se alojan las fuentes, es posible darle a la
opción @code{font} sólo el nombre de la fuente:
@example
(%i1) load(draw)$
(%i2) draw2d(
        font      = "FreeSerifBoldItalic", 
        font_size = 20,
        color     = red,
        label(["FreeSerifBoldItalic font, size 20",1,1]),
        terminal  = png)$
@end example

@item
@i{Postscript}:
Las fuentes estándar de Postscript son: @code{"Times-Roman"}, @code{"Times-Italic"}, @code{"Times-Bold"}, @code{"Times-BoldItalic"}, @code{"Helvetica"}, @code{"Helvetica-Oblique"}, @code{"Helvetica-Bold"}, @code{"Helvetic-BoldOblique"}, @code{"Courier"}, @code{"Courier-Oblique"}, @code{"Courier-Bold"} y @code{"Courier-BoldOblique"}.
  
Ejemplo:
@example
(%i1) load(draw)$
(%i2) draw2d(
        font      = "Courier-Oblique", 
        font_size = 15,
        label(["Courier-Oblique font, size 15",1,1]),
        terminal = eps)$
@end example

@item
@i{pdf}:
Utiliza las mismas fuentes que @i{Postscript}.

@item
@i{pdfcairo}:
Utiliza las mismas fuentes que @i{wxt}.

@item
@i{wxt}:
La librería @i{pango} encuentra las fuentes por medio de la utilidad @code{fontconfig}.

@item
@i{aqua}:
La fuente por defecto es @code{"Times-Roman"}.
@end itemize

La documentación de gnuplot es una importante fuente de información sobre terminales y fuentes.
@end defvr



@defvr {Opción gráfica} font_size
Valor por defecto: 10

Esta opción permite seleccionar el tamaño de la fuente a utilizar por el
terminal. Sólo se puede utilizar un tipo de fuente y tamaño por
gráfico. @code{font_size} sólo se activa cuando la opción @code{font}
tiene un valor diferente de la cadena vacía.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Véase también @code{font}.
@end defvr



@defvr {Opción gráfica} gnuplot_file_name
Valor por defecto: @code{"maxout.gnuplot"}

@code{gnuplot_file_name} es el nombre del fichero que 
almacena las instrucciones a ser procesadas por Gnuplot.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia. También puede
usarse como argumento de la función @code{draw}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
       file_name = "my_file",
       gnuplot_file_name = "my_commands_for_gnuplot",
       data_file_name    = "my_data_for_gnuplot",
       terminal          = png,
       explicit(x^2,x,-1,1)) $
@end example

Véase también @code{data_file_name}.

@end defvr



@defvr {Opción gráfica} grid
Valor por defecto: @code{false}

Cuando 

Cuando @code{grid} toma un valor distinto de @code{false}, se dibujará una rejilla
sobre el plano @var{xy}. Si a @code{grid} se le asigna el valor @code{true}, se dibujará
una línea de la rejilla por cada marca que haya sobre los ejes. Si a @code{grid} se le
asigna la lista @code{[nx,ny]}, con @var{[nx,ny] > [0,0]}, se dibujarán @code{nx} 
líneas por cada marca del eje-@var{x} y @var{ny} líneas por cada marca del eje-@var{y}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(grid = true,
             explicit(exp(u),u,-2,2))$
@end example
@end defvr




@defvr {Opción gráfica} head_angle
Valor por defecto: 45

@code{head_angle} indica el ángulo, en grados, entre la flecha y el
segmento del vector.

Esta opción sólo es relevante para objetos de tipo @code{vector}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange      = [0,10],
             yrange      = [0,9],
             head_length = 0.7,
             head_angle  = 10,
             vector([1,1],[0,6]),
             head_angle  = 20,
             vector([2,1],[0,6]),
             head_angle  = 30,
             vector([3,1],[0,6]),
             head_angle  = 40,
             vector([4,1],[0,6]),
             head_angle  = 60,
             vector([5,1],[0,6]),
             head_angle  = 90,
             vector([6,1],[0,6]),
             head_angle  = 120,
             vector([7,1],[0,6]),
             head_angle  = 160,
             vector([8,1],[0,6]),
             head_angle  = 180,
             vector([9,1],[0,6]) )$
@end example

Véanse también @code{head_both}, @code{head_length} y @code{head_type}. 
@end defvr




@defvr {Opción gráfica} head_both
Valor por defecto: @code{false}

Cuando @code{head_both} vale @code{true}, los vectores se dibujan bidireccionales.
Si vale @code{false}, se dibujan unidireccionales.

Esta opción sólo es relevante para objetos de tipo @code{vector}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange      = [0,8],
             yrange      = [0,8],
             head_length = 0.7,
             vector([1,1],[6,0]),
             head_both   = true,
             vector([1,7],[6,0]) )$
@end example

Véanse también @code{head_length}, @code{head_angle} y @code{head_type}. 
@end defvr




@defvr {Opción gráfica} head_length
Valor por defecto: 2

@code{head_length} indica, en las unidades del eje @var{x}, la
longitud de las flechas de los vectores.

Esta opción sólo es relevante para objetos de tipo @code{vector}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange      = [0,12],
             yrange      = [0,8],
             vector([0,1],[5,5]),
             head_length = 1,
             vector([2,1],[5,5]),
             head_length = 0.5,
             vector([4,1],[5,5]),
             head_length = 0.25,
             vector([6,1],[5,5]))$
@end example

Véanse también @code{head_both}, @code{head_angle} y @code{head_type}. 
@end defvr




@defvr {Opción gráfica} head_type
Valor por defecto: @code{filled}

@code{head_type} se utiliza para especificar cómo se habrán de
dibujar las flechas de los vectores. Los valores posibles para
esta opción son: @code{filled} (flechas cerradas y rellenas),
@code{empty} (flechas cerradas pero no rellenas) y @code{nofilled}
(flechas abiertas).

Esta opción sólo es relevante para objetos de tipo @code{vector}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange      = [0,12],
             yrange      = [0,10],
             head_length = 1,
             vector([0,1],[5,5]), /* default type */
             head_type = 'empty,
             vector([3,1],[5,5]),
             head_type = 'nofilled,
             vector([6,1],[5,5]))$
@end example

Véanse también @code{head_both}, @code{head_angle} y @code{head_length}. 
@end defvr



@defvr {Opción gráfica} interpolate_color
Valor por defecto: @code{false}

Esta opción solo es relevante si @code{enhanced3d} tiene un valor 
diferente de @code{false}.

Si @code{interpolate_color} vale @code{false}, las superficies se colorean con
cuadriláteros homogéneos. Si vale @code{true}, las transiciones de colores se
suavizan por interpolación.

La opción @code{interpolate_color} también acepta una lista de dos números, @code{[m,n]}.
Para @var{m} y @var{n} positivos, cada cuadrilátero o triángulo se interpola
@var{m} y @var{n} veces en la dirección respectiva. Para @var{m} y @var{n} negativos,
la frecuencia de interpolación se elige de forma que se dibujen al menos @var{abs(m)} y
@var{abs(n)} puntos, pudiéndose considerar esto como una función especial de enrejado.
Con valores nulos, esto es @code{interpolate_color=[0,0]}, se seleccionará un número 
óptimo de puntos interpolados en la superficie.

Además, @code{interpolate_color=true} es equivalente a @code{interpolate_color=[0,0]}.

La interpolación de colores en superficies paramétricas puede dar resultados
imprevisibles.

Ejemplos:

Interpolación de color con funciones explícitas.

@example
(%i1) load(draw)$
(%i2) draw3d(
        enhanced3d   = sin(x*y),
        explicit(20*exp(-x^2-y^2)-10, x ,-3, 3, y, -3, 3)) $
(%i3) draw3d(
        interpolate_color = true,
        enhanced3d   = sin(x*y),
        explicit(20*exp(-x^2-y^2)-10, x ,-3, 3, y, -3, 3)) $
(%i4) draw3d(
        interpolate_color = [-10,0],
        enhanced3d   = sin(x*y),
        explicit(20*exp(-x^2-y^2)-10, x ,-3, 3, y, -3, 3)) $
@end example

Interpolación de color con el objeto @code{mesh}.

@example
(%i1) load(draw)$
(%i2) draw3d( 
        enhanced3d = true,
        mesh([[1,1,3],   [7,3,1],[12,-2,4],[15,0,5]],
             [[2,7,8],   [4,3,1],[10,5,8], [12,7,1]],
             [[-2,11,10],[6,9,5],[6,15,1], [20,15,2]])) $
(%i3) draw3d( 
        enhanced3d        = true,
        interpolate_color = true,
        mesh([[1,1,3],   [7,3,1],[12,-2,4],[15,0,5]],
             [[2,7,8],   [4,3,1],[10,5,8], [12,7,1]],
             [[-2,11,10],[6,9,5],[6,15,1], [20,15,2]])) $
(%i4) draw3d( 
        enhanced3d        = true,
        interpolate_color = true,
        view=map,
        mesh([[1,1,3],   [7,3,1],[12,-2,4],[15,0,5]],
             [[2,7,8],   [4,3,1],[10,5,8], [12,7,1]],
             [[-2,11,10],[6,9,5],[6,15,1], [20,15,2]])) $
@end example

Véase también @code{enhanced3d}. 

@end defvr



@defvr {Opción gráfica} ip_grid
Valor por defecto: @code{[50, 50]}

@code{ip_grid} establece la rejilla del primer muestreo para los
gráficos de funciones implícitas.

Esta opción sólo es relevante para funciones de tipo @code{implicit}.
@end defvr



@defvr {Opción gráfica} ip_grid_in
Valor por defecto: @code{[5, 5]}

@code{ip_grid_in} establece la rejilla del segundo muestreo para los
gráficos de funciones implícitas.

Esta opción sólo es relevante para funciones de tipo @code{implicit}.
@end defvr




@defvr {Opción gráfica} key
Valor por defecto: @code{""} (cadena vacía)

@code{key} es la clave de una función en la leyenda. Si @code{key}
es una cadena vacía, las funciones no tendrán clave
asociada en la leyenda.

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr2d}: @code{points}, @code{polygon}, @code{rectangle},
@code{ellipse}, @code{vector}, @code{explicit}, @code{implicit},
@code{parametric} y @code{polar}.

@item
@code{gr3d}: @code{points}, @code{explicit}, @code{parametric},
y @code{parametric_surface}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(key   = "Sinus",
             explicit(sin(x),x,0,10),
             key   = "Cosinus",
             color = red,
             explicit(cos(x),x,0,10) )$
@end example
@end defvr



@defvr {Opción gráfica} key_pos
Valor por defecto: @code{""} (cadena vacía)

La opción @code{key_pos} establece en qué posición se colocará la leyenda.
Si @code{key} es una cadena vacía, entonces se utilizará por defecto la
posición @code{"top_right"}.
Los valores disponibles para esta opción son: @code{top_left}, @code{top_center},
@code{top_right}, @code{center_left}, @code{center}, @code{center_right},
@code{bottom_left}, @code{bottom_center} y @code{bottom_right}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplos:

@example
(%i1) load(draw)$
(%i2) draw2d(
        key_pos = top_left,
        key     = "x",
        explicit(x,  x,0,10),
        color   = red,
        key     = "x squared",
        explicit(x^2,x,0,10))$
(%i3) draw3d(
        key_pos = center,
        key     = "x",
        explicit(x+y,x,0,10,y,0,10),
        color= red,
        key     = "x squared",
        explicit(x^2+y^2,x,0,10,y,0,10))$
@end example

@end defvr



@defvr {Opción gráfica} label_alignment
Valor por defecto: @code{center}

@code{label_alignment} se utiliza para especificar dónde se escribirán
las etiquetas con respecto a las coordenadas de referencia. Los valores posibles para
esta opción son: @code{center}, @code{left} y @code{right}.

Esta opción sólo es relevante para objetos de tipo @code{label}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange          = [0,10],
             yrange          = [0,10],
             points_joined   = true,
             points([[5,0],[5,10]]),
             color           = blue,
             label(["Centered alignment (default)",5,2]),
             label_alignment = 'left,
             label(["Left alignment",5,5]),
             label_alignment = 'right,
             label(["Right alignment",5,8]))$
@end example

Véanse también @code{label_orientation} y @code{color}. 
@end defvr




@defvr {Opción gráfica} label_orientation
Valor por defecto: @code{horizontal}

@code{label_orientation} se utiliza para especificar la orientación
de las etiquetas. Los valores posibles para esta opción son:
@code{horizontal} y @code{vertical}.

Esta opción sólo es relevante para objetos de tipo @code{label}.

Ejemplo:

En este ejemplo, el punto ficticio que se añade sirve para obtener
la imagen, ya que el paquete @code{draw} necesita siempre de datos para
construir la escena.
@example
(%i1) load(draw)$
(%i2) draw2d(xrange     = [0,10],
             yrange     = [0,10],
             point_size = 0,
             points([[5,5]]),
             color      = navy,
             label(["Horizontal orientation (default)",5,2]),
             label_orientation = 'vertical,
             color             = "#654321",
             label(["Vertical orientation",1,5]))$
@end example

Véanse también @code{label_alignment} y @code{color}. 
@end defvr




@defvr {Opción gráfica} line_type
Valor por defecto: @code{solid}

@code{line_type} indica cómo se van a dibujar las líneas;
valores posibles son @code{solid} y @code{dots}, que están disponibles
en todos los terminales, y @code{dashes}, @code{short_dashes}, 
@code{short_long_dashes}, @code{short_short_long_dashes} y @code{dot_dash},
que no esán disponibles en los terminales @code{png}, @code{jpg} y @code{gif}.

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr2d}: @code{points}, @code{polygon}, @code{rectangle}, 
@code{ellipse}, @code{vector}, @code{explicit}, @code{implicit}, 
@code{parametric} y @code{polar}.

@item
@code{gr3d}: @code{points}, @code{explicit}, @code{parametric} y @code{parametric_surface}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(line_type = dots,
             explicit(1 + x^2,x,-1,1),
             line_type = solid, /* default */
             explicit(2 + x^2,x,-1,1))$
@end example

Véase también @code{line_width}.
@end defvr




@defvr {Opción gráfica} line_width
Valor por defecto: 1

@code{line_width} es el ancho de las líneas a dibujar.
Su valor debe ser un número positivo.

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr2d}: @code{points}, @code{polygon}, @code{rectangle}, 
@code{ellipse}, @code{vector}, @code{explicit}, @code{implicit}, 
@code{parametric} y @code{polar}.

@item
@code{gr3d}: @code{points} y @code{parametric}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^2,x,-1,1), /* default width */
             line_width = 5.5,
             explicit(1 + x^2,x,-1,1),
             line_width = 10,
             explicit(2 + x^2,x,-1,1))$
@end example

Véase también @code{line_type}.
@end defvr




@defvr {Opción gráfica} logcb
Valor por defecto: @code{false}

Cuando @code{logcb} vale @code{true}, la escala de colores se dibuja 
logarítmicamente.

Cuando @code{enhanced3d} o @code{colorbox} vale @code{false}, la 
opción @code{logcb} no tiene efecto alguno.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d (
        enhanced3d = true,
        color      = green,
        logcb = true,
        logz  = true,
        palette = [-15,24,-9],
        explicit(exp(x^2-y^2), x,-2,2,y,-2,2)) $
@end example

Véanse también @code{enhanced3d}, @code{colorbox} y @code{cbrange}.
@end defvr




@defvr {Opción gráfica} logx
Valor por defecto: @code{false}

Cuando @code{logx} vale @code{true}, el eje @var{x} se dibuja
en la escala logarítmica.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(log(x),x,0.01,5),
             logx = true)$
@end example

Véanse también @code{logy}, @code{logx_secondary}, @code{logy_secondary} y @code{logz}.

@end defvr



@defvr {Opción gráfica} logx_secondary
Valor por defecto: @code{false}

Si @code{logx_secondary} vale @code{true}, el eje secundario de @var{x} 
se dibuja en la escala logarítmica.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
        grid = true,
        key="x^2, linear scale",
        color=red,
        explicit(x^2,x,1,100),
        xaxis_secondary = true,
        xtics_secondary = true,
        logx_secondary  = true,
        key = "x^2, logarithmic x scale",
        color = blue,
        explicit(x^2,x,1,100) )$
@end example

Véanse también @code{logx}, @code{logy}, @code{logy_secondary} y @code{logz}.

@end defvr



@defvr {Opción gráfica} logy
Valor por defecto: @code{false}

Cuando @code{logy} vale @code{true}, el eje @var{y} se dibuja
en la escala logarítmica.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(logy = true,
             explicit(exp(x),x,0,5))$
@end example

Véanse también @code{logx}, @code{logx_secondary}, @code{logy_secondary} y @code{logz}.
@end defvr



@defvr {Opción gráfica} logy_secondary
Valor por defecto: @code{false}

Si @code{logy_secondary} vale @code{true}, el eje secundario de @var{y} 
se dibuja en la escala logarítmica.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
        grid = true,
        key="x^2, linear scale",
        color=red,
        explicit(x^2,x,1,100),
        yaxis_secondary = true,
        ytics_secondary = true,
        logy_secondary  = true,
        key = "x^2, logarithmic y scale",
        color = blue,
        explicit(x^2,x,1,100) )$
@end example

Véanse también @code{logx}, @code{logy}, @code{logx_secondary} y @code{logz}.

@end defvr



@defvr {Opción gráfica} logz
Valor por defecto: @code{false}

Cuando @code{logz} vale @code{true}, el eje @var{z} se dibuja
en la escala logarítmica.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(logz = true,
             explicit(exp(u^2+v^2),u,-2,2,v,-2,2))$
@end example

Véanse también @code{logx} and @code{logy}.
@end defvr




@defvr {Opción gráfica} nticks
Valor por defecto: 29

En 2d, @code{nticks} es el número de puntos a utilizar por el programa
adaptativo que genera las funciones explícitas. También es el número de
puntos que se representan en las curvas paramétricas y polares.

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr2d}: @code{ellipse}, @code{explicit}, @code{parametric} y @code{polar}.

@item
@code{gr3d}: @code{parametric}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(transparent = true,
             ellipse(0,0,4,2,0,180),
             nticks = 5,
             ellipse(0,0,4,2,180,180) )$
@end example
@end defvr





@defvr {Opción gráfica} palette
Valor por defecto: @code{color}

@code{palette} indica cómo transformar niveles de gris en componentes cromáticas.
Trabaja conjuntamente con la opción @code{enhanced3d} en gráficos 3D, la cual asocia cada punto
de una superficie con un número real o nivel de gris. También trabaja con imágenes grises.
Con @code{palette}, estos niveles se transforman en colores.

Hay dos formas de definir estas transformaciones.

En primer lugar, @code{palette} puede ser un vector de longitud tres con sus componentes tomando
valores enteros en el rango desde -36 a +36; cada valor es un 
índice para seleccionar una fórmula que transforma los niveles
numéricos en las componentes cromáticas rojo, verde y azul:
@example
 0: 0               1: 0.5           2: 1
 3: x               4: x^2           5: x^3
 6: x^4             7: sqrt(x)       8: sqrt(sqrt(x))
 9: sin(90x)       10: cos(90x)     11: |x-0.5|
12: (2x-1)^2       13: sin(180x)    14: |cos(180x)|
15: sin(360x)      16: cos(360x)    17: |sin(360x)|
18: |cos(360x)|    19: |sin(720x)|  20: |cos(720x)|
21: 3x             22: 3x-1         23: 3x-2
24: |3x-1|         25: |3x-2|       26: (3x-1)/2
27: (3x-2)/2       28: |(3x-1)/2|   29: |(3x-2)/2|
30: x/0.32-0.78125 31: 2*x-0.84     32: 4x;1;-2x+1.84;x/0.08-11.5
33: |2*x - 0.5|    34: 2*x          35: 2*x - 0.5
36: 2*x - 1
@end example
los números negativos se interpretan como colores invertidos
de las componentes cromáticas.
@code{palette = gray} y @code{palette = color} son atajos para
@code{palette = [3,3,3]} y @code{palette = [7,5,15]}, respectivamente.

En segundo lugar, @code{palette} puede ser una paleta de colores definida
por el usuario. En este caso, el formato para crear una paleta de longitud
@code{n} es @code{palette=[color_1, color_2, ..., color_n]}, 
donde @code{color_i} es un color correctamente definido (véase la opción
@code{color}), de tal manera que @code{color_1} se asigna al valor más bajo
del nivel y @code{color_n} al más alto. El resto de colores se interpolan.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplos:

Trabaja conjuntamente con la opción @code{enhanced3d} en gráficos 3D.

@example
(%i1) load(draw)$
(%i2) draw3d(
        enhanced3d = [z-x+2*y,x,y,z],
        palette = [32, -8, 17],
        explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$
@end example

También trabaja con imágenes grises.

@example
(%i1) load(draw)$
(%i2) im: apply(
           'matrix,
            makelist(makelist(random(200),i,1,30),i,1,30))$
(%i3) /* palette = color, default */
      draw2d(image(im,0,0,30,30))$
(%i4) draw2d(palette = gray, image(im,0,0,30,30))$
(%i5) draw2d(palette = [15,20,-4],
             colorbox=false,
             image(im,0,0,30,30))$
@end example

@code{palette} puede ser una paleta de colores definida
por el usuario. En este ejemplo, valores bajos de @code{x}
se colorean en rojo y altos en amarillo.

@example
(%i1) load(draw)$
(%i2) draw3d(
         palette = [red, blue, yellow],
         enhanced3d = x,
         explicit(x^2+y^2,x,-1,1,y,-1,1)) $
@end example

Véase también @code{colorbox} y @code{enhanced3d}.
@end defvr



@defvr {Opción gráfica} point_size
Valor por defecto: 1

@code{point_size} establece el tamaño de los puntos dibujados. Debe
ser un número no negativo.

Esta opción no tiene efecto alguno cuando a la opción gráfica
@code{point_type} se le ha dado el valor @code{dot}.

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr2d}: @code{points}.

@item
@code{gr3d}: @code{points}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
        points(makelist([random(20),random(50)],k,1,10)),
        point_size = 5,
        points(makelist(k,k,1,20),makelist(random(30),k,1,20)))$
@end example
@end defvr



@defvr {Opción gráfica} point_type
Valor por defecto: 1

@code{point_type} indica cómo se van a dibujar los puntos aislados. Los valores
para esta opción pueden ser índices enteros mayores o iguales que -1,
o también nombres de estilos: @code{$none} (-1), @code{dot} (0), @code{plus} (1),
@code{multiply} (2), @code{asterisk} (3), @code{square} (4), @code{filled_square} (5),
@code{circle} (6), @code{filled_circle} (7), @code{up_triangle} (8), 
@code{filled_up_triangle} (9), @code{down_triangle} (10), 
@code{filled_down_triangle} (11), @code{diamant} (12) y @code{filled_diamant} (13).

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr2d}: @code{points}.

@item
@code{gr3d}: @code{points}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange = [0,10],
             yrange = [0,10],
             point_size = 3,
             point_type = diamant,
             points([[1,1],[5,1],[9,1]]),
             point_type = filled_down_triangle,
             points([[1,2],[5,2],[9,2]]),
             point_type = asterisk,
             points([[1,3],[5,3],[9,3]]),
             point_type = filled_diamant,
             points([[1,4],[5,4],[9,4]]),
             point_type = 5,
             points([[1,5],[5,5],[9,5]]),
             point_type = 6,
             points([[1,6],[5,6],[9,6]]),
             point_type = filled_circle,
             points([[1,7],[5,7],[9,7]]),
             point_type = 8,
             points([[1,8],[5,8],[9,8]]),
             point_type = filled_diamant,
             points([[1,9],[5,9],[9,9]]) )$
@end example
@end defvr



@defvr {Opción gráfica} points_joined
Valor por defecto: @code{false}

Cuando @code{points_joined} vale @code{true}, los puntos se unen con segmentos;
si vale @code{false}, se dibujarán puntos aislados. Un tercer valor posible
para esta opción gráfica es @code{impulses}; en tal caso, se dibujarán
segmentos verticales desde los puntos hasta el eje-x (2D) o hasta el plano-xy (3D).

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr2d}: @code{points}.

@item
@code{gr3d}: @code{points}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange        = [0,10],
             yrange        = [0,4],
             point_size    = 3,
             point_type    = up_triangle,
             color         = blue,
             points([[1,1],[5,1],[9,1]]),
             points_joined = true,
             point_type    = square,
             line_type     = dots,
             points([[1,2],[5,2],[9,2]]),
             point_type    = circle,
             color         = red,
             line_width    = 7,
             points([[1,3],[5,3],[9,3]]) )$
@end example
@end defvr



@defvr {Opción gráfica} proportional_axes
Valor por defecto: @code{none}

Cuando @code{proportional_axes} es igual a @code{xy} o @code{xy}, una escena
2D o 3D se dibujará con los ejes proporcionales a sus longitudes relativas.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Esta opción sólo funciona con Gnuplot versión 4.2.6
o superior.

Ejemplos:

Gráfico en 2D.

@example
(%i1) load(draw)$
(%i2) draw2d(
        ellipse(0,0,1,1,0,360),
        transparent=true,
        color = blue,
        line_width = 4,
        ellipse(0,0,2,1/2,0,360),
        proportional_axes = xy) $
@end example

Multiplot.

@example
(%i1) load(draw)$
(%i2) draw(
        terminal = wxt,
        gr2d(proportional_axes = xy,
             explicit(x^2,x,0,1)),
        gr2d(explicit(x^2,x,0,1),
             xrange = [0,1],
             yrange = [0,2],
             proportional_axes=xy),
        gr2d(explicit(x^2,x,0,1)))$
@end example

@end defvr




@defvr {Opción gráfica} surface_hide
Valor por defecto: @code{false}

Cuando @code{surface_hide} vale @code{true}, las partes ocultas no
se muestran en las superficies de las escenas 3d.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw(columns=2,
           gr3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3)),
           gr3d(surface_hide = true,
                explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3)) )$
@end example
@end defvr




@defvr {Opción gráfica} terminal
Valor por defecto: @code{screen}

Selecciona el terminal a utilizar por Gnuplot; valores posibles son:
@code{screen} (por defecto), @code{png}, @code{pngcairo}, @code{jpg}, @code{gif}, 
@code{eps}, @code{eps_color}, @code{epslatex}, @code{epslatex_standalone}, 
@code{svg}, @code{dumb}, @code{dumb_file}, @code{pdf}, @code{pdfcairo}, 
@code{wxt}, @code{animated_gif}, @code{multipage_pdfcairo}, @code{multipage_pdf}, 
@code{multipage_eps}, @code{multipage_eps_color} y @code{aquaterm}.

Los terminales @code{screen}, @code{wxt} y @code{aquaterm} también se pueden 
definir como una lista de dos elementos: el propio nombre del terminal y un 
número entero no negativo. De esta forma se pueden abrir varias ventanas al
mismo tiempo, cada una de ellas con su número correspondiente. Esta modalidad
no funciona en plataformas Windows.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia. También puede
usarse como argumento de la función @code{draw}.

pdfcairo necesita Gnuplot 4.3. 
@code{pdf} necesita que Gnuplot haya sido compilado con la opción @code{--enable-pdf} y libpdf debe
estar instalado (@url{http://www.pdflib.com/en/download/pdflib-family/pdflib-lite/}).

Ejemplos:

@example
(%i1) load(draw)$
(%i2) /* screen terminal (default) */
      draw2d(explicit(x^2,x,-1,1))$
(%i3) /* png file */
      draw2d(terminal  = 'png,
             explicit(x^2,x,-1,1))$
(%i4) /* jpg file */
      draw2d(terminal   = 'jpg,
             dimensions = [300,300],
             explicit(x^2,x,-1,1))$
(%i5) /* eps file */
      draw2d(file_name = "myfile",
             explicit(x^2,x,-1,1),
             terminal  = 'eps)$
(%i6) /* pdf file */
      draw2d(file_name = "mypdf",
             dimensions = 100*[12.0,8.0],
             explicit(x^2,x,-1,1),
             terminal  = 'pdf)$
(%i7) /* wxwidgets window */
      draw2d(explicit(x^2,x,-1,1),
             terminal  = 'wxt)$
@end example

Ventanas múltiples.
@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^5,x,-2,2), terminal=[screen, 3])$
(%i3) draw2d(explicit(x^2,x,-2,2), terminal=[screen, 0])$
@end example

Un fichero gif animado.
@example
(%i1) load(draw)$
(%i2) draw(
        delay     = 100,
        file_name = "zzz",
        terminal  = 'animated_gif,
        gr2d(explicit(x^2,x,-1,1)),
        gr2d(explicit(x^3,x,-1,1)),
        gr2d(explicit(x^4,x,-1,1)));
End of animation sequence
(%o2)          [gr2d(explicit), gr2d(explicit), gr2d(explicit)]
@end example

La opción @code{delay} sólo se activa en caso de gifs animados; se ignora en
cualquier otro caso.

Salida multipágina en formato eps.
@example
(%i1) load(draw)$
(%i2) draw(
        file_name = "parabol",
        terminal  = multipage_eps,
        dimensions = 100*[10,10],
        gr2d(explicit(x^2,x,-1,1)),
        gr3d(explicit(x^2+y^2,x,-1,1,y,-1,1))) $
@end example

Véanse también @code{file_name}, @code{pic_width}, @code{pic_height} y @code{delay}.
@end defvr




@defvr {Opción gráfica} title
Valor por defecto: @code{""} (cadena vacía)

La opción @code{title} almacena una cadena con el 
título de la escena. Por defecto, no se escribe
título alguno.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(exp(u),u,-2,2),
             title = "Exponential function")$
@end example
@end defvr



@defvr {Opción gráfica} transform
Valor por defecto: @code{none}

Si @code{transform} vale @code{none}, el espacio no sufre transformación
alguna y los objetos gráficos se representan tal cual se definen. Si es
necesario transformar el espacio, se debe asignar una lista a la opción
@code{transform}. En caso de una escena 2D, la lista toma la forma
@code{[f1(x,y), f2(x,y), x, y]}.
En caso de una escena 3D, la lista debe ser de la forma
@code{[f1(x,y,z), f2(x,y,z), f3(x,y,z), x, y, z]}.

Los nombres de las variables definidas en las listas pueden ser diferentes
de aquellas utilizadas en las definiciones de los objetos gráficos.

Ejemplos:

Rotación en 2D.

@example
(%i1) load(draw)$
(%i2) th : %pi / 4$
(%i3) draw2d(
        color = "#e245f0",
        proportional_axes = 'xy,
        line_width = 8,
        triangle([3,2],[7,2],[5,5]),
        border     = false,
        fill_color = yellow,
        transform  = [cos(th)*x - sin(th)*y,
                      sin(th)*x + cos(th)*y, x, y],
        triangle([3,2],[7,2],[5,5]) )$
@end example

Traslación en 3D.

@example
(%i1) load(draw)$
(%i2) draw3d(
        color     = "#a02c00",
        explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3),
        transform = [x+10,y+10,z+10,x,y,z],
        color     = blue,
        explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3) )$
@end example
@end defvr



@defvr {Opción gráfica} transparent
Valor por defecto: @code{false}

Cuando @code{transparent} vale @code{false}, las regiones internas de 
los polígonos se rellenan de acuerdo con @code{fill_color}.

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr2d}: @code{polygon}, @code{rectangle} y @code{ellipse}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(polygon([[3,2],[7,2],[5,5]]),
             transparent = true,
             color       = blue,
             polygon([[5,2],[9,2],[7,5]]) )$
@end example
@end defvr



@defvr {Opción gráfica} unit_vectors
Valor por defecto: @code{false}

Cuando @code{unit_vectors} vale @code{true}, los vectores se dibujan con módulo unidad.
Esta opción es útil para representar campos vectoriales. Cuando @code{unit_vectors} vale @code{false},
los vectores se dibujan con su longitud original.

Esta opción sólo es relevante para objetos de tipo @code{vector}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange      = [-1,6],
             yrange      = [-1,6],
             head_length = 0.1,
             vector([0,0],[5,2]),
             unit_vectors = true,
             color        = red,
             vector([0,3],[5,2]))$
@end example
@end defvr




@defvr {Opción gráfica} user_preamble
Valor por defecto: @code{""} (cadena vacía)

Usuarios expertos en Gnuplot pueden hacer uso de esta opción para
afinar el comportamiento de Gnuplot escribiendo código que será
enviado justo antes de la instrucción @code{plot} o @code{splot}.

El valor dado a esta opción debe ser una cadena alfanumérica o
una lista de cadenas (una por línea).

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

Se le indica a Gnuplot que dibuje los ejes encima de todos los demás objetos,
@example
(%i1) load(draw)$
(%i2) draw2d(
        xaxis =true, xaxis_type=solid,
        yaxis =true, yaxis_type=solid,
        user_preamble="set grid front",
        region(x^2+y^2<1 ,x,-1.5,1.5,y,-1.5,1.5))$
@end example
@end defvr



@defvr {Opción gráfica} view
Valor por defecto: @code{[60,30]}

Un par de ángulos, medidos en grados, indicando la direcciÃ³n del 
observador en una escena 3D. El primer ángulo es la rotación 
vertical alrededor del eje @var{x}, dentro del intervalo @math{[0, 360]}.
El segundo es la rotación horizontal alrededor del eje @var{z}, dentro
del intervalo @math{[0, 360]}.

Dándole a la opción @code{view} el valor @code{map}, la dirección del 
observador se sitúa perpendicularmente al plano-xy.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(view = [170, 50],
             enhanced3d = true,
             explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$
(%i3) draw3d(view = map,
             enhanced3d = true,
             explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$
@end example
@end defvr




@defvr {Opción gráfica} wired_surface
Valor por defecto: @code{false}

Indica si las superficies en 3D en modo @code{enhanced3d} deben mostrar o no la malla que
unen los puntos.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(
        enhanced3d    = [sin(x),x,y],
        wired_surface = true,
        explicit(x^2+y^2,x,-1,1,y,-1,1)) $
@end example

@end defvr




@defvr {Opción gráfica} x_voxel
Valor por defecto: 10

@code{x_voxel} es el número de voxels en la dirección x a utilizar
por el algoritmo @i{marching cubes} implementado por el objeto 
@code{implicit} tridimensional. También se utiliza como opción
del objeto gráfico @code{region}.
@end defvr



@defvr {Opción gráfica} xaxis
Valor por defecto: @code{false}

Si @code{xaxis} vale @code{true}, se dibujará el eje @var{x}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^3,x,-1,1),
             xaxis       = true,
             xaxis_color = blue)$
@end example

Véanse también @code{xaxis_width}, @code{xaxis_type} y @code{xaxis_color}.
@end defvr




@defvr {Opción gráfica} xaxis_color
Valor por defecto: @code{"black"}

@code{xaxis_color} especifica el color para el eje @var{x}. Véase
@code{color} para ver cómo se definen los colores.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^3,x,-1,1),
             xaxis       = true,
             xaxis_color = red)$
@end example

Véanse también @code{xaxis}, @code{xaxis_width} y @code{xaxis_type}.
@end defvr




@defvr {Opción gráfica} xaxis_secondary
Valor por defecto: @code{false}

Si @code{xaxis_secondary} vale @code{true}, los valores de las funciones se pueden representar
respecto del eje @var{x} secundario, el cual se dibuja en la parte superior de la escena.

Nótese que esta es una opción gráfica local que sólo afecta a objetos 2d.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
         key   = "Bottom x-axis",
         explicit(x+1,x,1,2),
         color = red,
         key   = "Above x-axis",
         xtics_secondary = true,
         xaxis_secondary = true,
         explicit(x^2,x,-1,1)) $
@end example

Véanse también @code{xrange_secondary}, @code{xtics_secondary}, @code{xtics_rotate_secondary},
@code{xtics_axis_secondary} y @code{xaxis_secondary}.

@end defvr




@defvr {Opción gráfica} xaxis_type
Valor por defecto: @code{dots}

@code{xaxis_type} indica cómo se debe dibujar el eje @var{x}; 
valores admisibles son @code{solid} y @code{dots}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^3,x,-1,1),
             xaxis       = true,
             xaxis_type  = solid)$
@end example

Véanse también @code{xaxis}, @code{xaxis_width} y @code{xaxis_color}.
@end defvr




@defvr {Opción gráfica} xaxis_width
Valor por defecto: 1

@code{xaxis_width} es el ancho del eje @var{x}.
Su valor debe ser un número positivo.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^3,x,-1,1),
             xaxis       = true,
             xaxis_width = 3)$
@end example

Véanse también @code{xaxis}, @code{xaxis_type} y @code{xaxis_color}.
@end defvr




@defvr {Opción gráfica} xlabel
Valor por defecto: @code{""}

La opción @code{xlabel} almacena una cadena con la
etiqueta del eje @var{x}. Por defecto, el eje tiene etiqueta @code{"x"}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xlabel = "Time",
             explicit(exp(u),u,-2,2),
             ylabel = "Population")$
@end example

Véanse también @code{xlabel_secondary}, @code{ylabel}, @code{ylabel_secondary} y @code{zlabel}.
@end defvr



@defvr {Opción gráfica} xlabel_secondary
Valor por defecto: @code{""} (cadena vacía)

La opción @code{xlabel_secondary} almacena una cadena con la
etiqueta del eje @var{x} secundario. Por defecto, el eje no tiene etiqueta.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
         xaxis_secondary=true,yaxis_secondary=true,
         xtics_secondary=true,ytics_secondary=true,
         xlabel_secondary="t[s]",
         ylabel_secondary="U[V]",
         explicit(sin(t),t,0,10) )$
@end example

Véanse también @code{xlabel}, @code{ylabel}, @code{ylabel_secondary} y @code{zlabel}.

@end defvr



@defvr {Opción gráfica} xrange
Valor por defecto: @code{auto}

Cuando @code{xrange} vale @code{auto}, el rango de la coordenada @var{x}
se calcula de forma automática.

Si el usuario quiere especificar un intervalo para @var{x}, éste debe
expresarse como una lista de Maxima, como en @code{xrange=[-2, 3]}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange = [-3,5],
             explicit(x^2,x,-1,1))$
@end example

Véanse también @code{yrange} y @code{zrange}.
@end defvr




@defvr {Opción gráfica} xrange_secondary
Valor por defecto: @code{auto}

Cuando @code{xrange_secondary} vale @code{auto}, el rango del eje @var{x}
secundario se calcula de forma automática.

Si el usuario quiere especificar un intervalo para el eje @var{x} secundario, éste debe
expresarse como una lista de Maxima, como en @code{xrange_secondary=[-2, 3]}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Véanse también @code{xrange}, @code{yrange}, @code{zrange} y @code{yrange_secondary}.
@end defvr




@defvr {Opción gráfica} xtics
Valor por defecto: @code{true}

Esta opción gráfica controla la forma en la que se dibujarán las marcas
del eje @var{x}.

@itemize @bullet
@item
Cuando a @code{xtics} se le da el valor @var{true}, las marcas se dibujarán de
forma automática.

@item
Cuando a @code{xtics} se le da el valor @var{false}, no habrá marcas en los ejes.

@item
Cuando a @code{xtics} se le da un valor numérico positivo, se interpretará como la
distancia entre dos marcas consecutivas.

@item
Cuando a @code{xtics} se le da una lista de longitud tres de la forma 
@code{[start,incr,end]}, las marcas se dibujarán desde @code{start} 
hasta @code{end} a intervalos de longitud @code{incr}.

@item
Cuando a @code{xtics} se le da un conjunto de números de la forma
@code{@{n1, n2, ...@}}, las marcas se dibujarán exactamente en los valores
@code{n1}, @code{n2}, ...

@item
Cuando a @code{xtics} se le da un conjunto de pares de la forma
@code{@{["label1", n1], ["label2", n2], ...@}}, las marcas correspondientes a los valores
@code{n1}, @code{n2}, ... se etiquetarán con @code{"label1"}, @code{"label2"}, ..., respectivamente.
@end itemize

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplos:

Marcas desactivadas.
@example
(%i1) load(draw)$
(%i2) draw2d(xtics = 'false,
             explicit(x^3,x,-1,1)  )$
@end example

Marcas cada 1/4 unidades.
@example
(%i1) load(draw)$
(%i2) draw2d(xtics = 1/4,
             explicit(x^3,x,-1,1)  )$
@end example

Marcas desde -3/4 hasta 3/4 en saltos de 1/8.
@example
(%i1) load(draw)$
(%i2) draw2d(xtics = [-3/4,1/8,3/4],
             explicit(x^3,x,-1,1)  )$
@end example

Marcas en los puntos -1/2, -1/4 y 3/4.
@example
(%i1) load(draw)$
(%i2) draw2d(xtics = @{-1/2,-1/4,3/4@},
             explicit(x^3,x,-1,1)  )$
@end example

Marcas etiquetadas.
@example
(%i1) load(draw)$
(%i2) draw2d(xtics = @{["High",0.75],["Medium",0],["Low",-0.75]@},
             explicit(x^3,x,-1,1)  )$
@end example
@end defvr




@defvr {Opción gráfica} xtics_axis
Valor por defecto: @code{false}

Si @code{xtics_axis} vale @code{true}, las marcas y sus etiquetas se dibujan sobre
el propio eje @var{x}, si vale @code{false} las marcas se colocan a lo largo del borde
del gráfico.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr



@defvr {Opción gráfica} xtics_rotate
Valor por defecto: @code{false}

Si @code{xtics_rotate} vale @code{true}, las marcas del eje @var{x} se giran 
90 grados.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr



@defvr {Opción gráfica} xtics_rotate_secondary
Valor por defecto: @code{false}

Si @code{xtics_rotate_secondary} vale @code{true}, las marcas del eje @var{x} 
secundario se giran 90 grados.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr



@defvr {Opción gráfica} xtics_secondary
Valor por defecto: @code{auto}

Esta opción gráfica controla la forma en la que se dibujarán las marcas
del eje @var{x} secundario.

Véase @code{xtics} para una descripción completa.
@end defvr



@defvr {Opción gráfica} xtics_secondary_axis
Valor por defecto: @code{false}

Si @code{xtics_secondary_axis} vale @code{true}, las marcas y sus etiquetas se dibujan sobre
el propio eje @var{x} secundario, si vale @code{false} las marcas se colocan a lo largo del borde
del gráfico.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr



@defvr {Opción gráfica} xu_grid
Valor por defecto: 30

@code{xu_grid} es el número de coordenadas de la primera variable
(@code{x} en superficies explcítas y @code{u} en las
paramétricas) para formar la rejilla de puntos muestrales.

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr3d}: @code{explicit} y @code{parametric_surface}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(xu_grid = 10,
             yv_grid = 50,
             explicit(x^2+y^2,x,-3,3,y,-3,3) )$
@end example

Véase también @code{yv_grid}.
@end defvr




@defvr {Opción gráfica} xy_file
Valor por defecto: @code{""} (cadena vacía)

@code{xy_file} es el nombre del fichero donde se almacenarán las
coordenadas después de hacer clic con el botón del ratón en un
punto de la imagen y pulsado la tecla 'x'. Por defecto, las 
coordenadas no se almacenan.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr




@defvr {Graphic option} xyplane
Valor por defecto: @code{false}

Coloca el plano-xy en escenas 3D. Si @code{xyplane} vale @code{false},
el plano-xy se coloca automáticamente; en cambio, si toma un
valor real, el plano-xy intersectará con el eje @var{z} a ese nivel.
Esta opción no tiene efecto alguno en escenas 2D.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(xyplane = %e-2,
             explicit(x^2+y^2,x,-1,1,y,-1,1))$
@end example
@end defvr




@defvr {Opción gráfica} y_voxel
Valor por defecto: 10

@code{y_voxel} es el número de voxels en la dirección y a utilizar
por el algoritmo @i{marching cubes} implementado por el objeto 
@code{implicit} tridimensional. También se utiliza como opción
del objeto gráfico @code{region}.
@end defvr




@defvr {Opción gráfica} yaxis
Valor por defecto: @code{false}

Si @code{yaxis} vale @code{true}, se dibujará el eje @var{y}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^3,x,-1,1),
             yaxis       = true,
             yaxis_color = blue)$
@end example

Véanse también @code{yaxis_width}, @code{yaxis_type} y @code{yaxis_color}.
@end defvr



@defvr {Opción gráfica} yaxis_color
Valor por defecto: @code{"black"}

@code{yaxis_color} especifica el color para el eje @var{y}. Véase
@code{color} para ver cómo se definen los colores.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^3,x,-1,1),
             yaxis       = true,
             yaxis_color = red)$
@end example

Véanse también @code{yaxis}, @code{yaxis_width} y @code{yaxis_type}.
@end defvr




@defvr {Opción gráfica} yaxis_secondary
Valor por defecto: @code{false}

Si @code{yaxis_secondary} vale @code{true}, los valores de las funciones se pueden representar
respecto del eje @var{y} secundario, el cual se dibuja al lado derecho de la escena.

Nótese que esta es una opción gráfica local que sólo afecta a objetos 2d.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
         explicit(sin(x),x,0,10),
         yaxis_secondary = true,
         ytics_secondary = true,
         color = blue,
         explicit(100*sin(x+0.1)+2,x,0,10));
@end example

Véanse también @code{yrange_secondary}, @code{ytics_secondary}, @code{ytics_rotate_secondary}
y @code{ytics_axis_secondary}.

@end defvr




@defvr {Opción gráfica} yaxis_type
Valor por defecto: @code{dots}

@code{yaxis_type} indica cómo se debe dibujar el eje @var{y}; 
valores admisibles son @code{solid} y @code{dots}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^3,x,-1,1),
             yaxis       = true,
             yaxis_type  = solid)$
@end example

Véanse también @code{yaxis}, @code{yaxis_width} y @code{yaxis_color}.
@end defvr




@defvr {Opción gráfica} yaxis_width
Valor por defecto: 1

@code{yaxis_width} es el ancho del eje @var{y}.
Su valor debe ser un número positivo.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(x^3,x,-1,1),
             yaxis       = true,
             yaxis_width = 3)$
@end example

Véanse también @code{yaxis}, @code{yaxis_type} y @code{yaxis_color}.
@end defvr




@defvr {Opción gráfica} ylabel
Valor por defecto: @code{""}

La opción @code{ylabel} almacena una cadena con la
etiqueta del eje @var{y}. Por defecto, el eje tiene etiqueta @code{"y"}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xlabel = "Time",
             ylabel = "Population",
             explicit(exp(u),u,-2,2) )$
@end example

Véanse también @code{xlabel}, @code{xlabel_secondary}, @code{ylabel_secondary} y @code{zlabel}.
@end defvr







@defvr {Opción gráfica} ylabel_secondary
Valor por defecto: @code{""} (cadena vacía)


La opción @code{ylabel_secondary} almacena una cadena con la
etiqueta del eje @var{y} secundario. Por defecto, el eje no tiene etiqueta.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
        key="current",
        xlabel="t[s]",
        ylabel="I[A]",ylabel_secondary="P[W]",
        explicit(sin(t),t,0,10),
        yaxis_secondary=true,
        ytics_secondary=true,
        color=red,key="Power",
        explicit((sin(t))^2,t,0,10)
    )$
@end example

Véanse también @code{xlabel}, @code{xlabel_secondary}, @code{ylabel} and @code{zlabel}.

@end defvr



@defvr {Opción gráfica} yrange
Valor por defecto: @code{auto}

Cuando @code{yrange} vale @code{auto}, el rango de la coordenada @var{y}
se calcula de forma automática.

Si el usuario quiere especificar un intervalo para @var{y}, éste debe
expresarse como una lista de Maxima, como en @code{yrange=[-2, 3]}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(yrange = [-2,3],
             explicit(x^2,x,-1,1),
             xrange = [-3,3])$
@end example

Véanse también @code{xrange} y @code{zrange}.
@end defvr



@defvr {Opción gráfica} yrange_secondary
Valor por defecto: @code{auto}

Cuando @code{yrange_secondary} vale @code{auto}, el rango del eje @var{y}
secundario se calcula de forma automática.

Si el usuario quiere especificar un intervalo para el eje @var{y} secundario, éste debe
expresarse como una lista de Maxima, como en @code{yrange_secondary=[-2, 3]}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
         explicit(sin(x),x,0,10),
         yaxis_secondary = true,
         ytics_secondary = true,
         yrange = [-3, 3],
         yrange_secondary = [-20, 20],
         color = blue,
         explicit(100*sin(x+0.1)+2,x,0,10)) $
@end example

Véanse también @code{xrange}, @code{yrange} y @code{zrange}.
@end defvr




@defvr {Opción gráfica} ytics
Valor por defecto: @code{true}

Esta opción gráfica controla la forma en la que se dibujarán las marcas
del eje @var{y}.

Véase @code{xtics} para una descripción completa.
@end defvr




@defvr {Opción gráfica} ytics_axis
Valor por defecto: @code{false}

Si @code{ytics_axis} vale @code{true}, las marcas y sus etiquetas se dibujan sobre
el propio eje @var{y}, si vale @code{false} las marcas se colocan a lo largo del borde
del gráfico.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr




@defvr {Opción gráfica} ytics_rotate
Valor por defecto: @code{false}

Si @code{ytics_rotate} vale @code{true}, las marcas del eje @var{y} se giran 
90 grados.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr




@defvr {Opción gráfica} ytics_rotate_secondary
Valor por defecto: @code{false}

Si @code{ytics_rotate_secondary} vale @code{true}, las marcas del eje @var{y} 
secundario se giran 90 grados.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr




@defvr {Opción gráfica} ytics_secondary
Valor por defecto: @code{auto}

Esta opción gráfica controla la forma en la que se dibujarán las marcas
del eje @var{y} secundario.

Véase @code{xtics} para una descripción completa.
@end defvr




@defvr {Opción gráfica} ytics_secondary_axis
Valor por defecto: @code{false}

Si @code{ytics_secondary_axis} vale @code{true}, las marcas y sus etiquetas se dibujan sobre
el propio eje @var{y} secundario, si vale @code{false} las marcas se colocan a lo largo del borde
del gráfico.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr




@defvr {Opción gráfica} yv_grid
Valor por defecto: 30

@code{yv_grid} es el número de coordenadas de la segunda variable
(@code{y} en superficies explcítas y @code{v} en las
paramétricas) para formar la rejilla de puntos muestrales.

Esta opción afecta a los siguientes objetos gráficos:
@itemize @bullet
@item
@code{gr3d}: @code{explicit} y @code{parametric_surface}.
@end itemize

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(xu_grid = 10,
             yv_grid = 50,
             explicit(x^2+y^2,x,-3,3,y,-3,3) )$
@end example

Véase también @code{xu_grid}.
@end defvr




@defvr {Opción gráfica} z_voxel
Valor por defecto: 10

@code{z_voxel} es el número de voxels en la dirección z a utilizar
por el algoritmo @i{marching cubes} implementado por el objeto 
@code{implicit} tridimensional.
@end defvr




@defvr {Opción gráfica} zaxis
Valor por defecto: @code{false}

Si @code{zaxis} vale @code{true}, se dibujará el eje @var{z} en
escenas 3D. Esta opción no tiene efecto alguno en escenas 2D.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1),
             zaxis       = true,
             zaxis_type  = solid,
             zaxis_color = blue)$
@end example

Véanse también @code{zaxis_width}, @code{zaxis_type} y @code{zaxis_color}.
@end defvr





@defvr {Opción gráfica} zaxis_color
Valor por defecto: @code{"black"}

@code{zaxis_color} especifica el color para el eje @var{z}. Véase
@code{color} para ver cómo se definen los colores.
Esta opción no tiene efecto alguno en escenas 2D.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1),
             zaxis       = true,
             zaxis_type  = solid,
             zaxis_color = red)$
@end example

Véanse también @code{zaxis}, @code{zaxis_width} y @code{zaxis_type}.
@end defvr




@defvr {Opción gráfica} zaxis_type
Valor por defecto: @code{dots}

@code{zaxis_type} indica cómo se debe dibujar el eje @var{z}; 
valores admisibles son @code{solid} y @code{dots}.
Esta opción no tiene efecto alguno en escenas 2D.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1),
             zaxis       = true,
             zaxis_type  = solid)$
@end example

Véanse también @code{zaxis}, @code{zaxis_width} y @code{zaxis_color}.
@end defvr





@defvr {Opción gráfica} zaxis_width
Valor por defecto: 1

@code{zaxis_width} es el ancho del eje @var{z}.
Su valor debe ser un número positivo. Esta opción no tiene efecto alguno en escenas 2D.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1),
             zaxis       = true,
             zaxis_type  = solid,
             zaxis_width = 3)$
@end example

Véanse también @code{zaxis}, @code{zaxis_type} y @code{zaxis_color}.
@end defvr





@defvr {Opción gráfica} zlabel
Valor por defecto: @code{""}

La opción @code{zlabel} almacena una cadena con la
etiqueta del eje @var{z}. Por defecto, el eje tiene etiqueta @code{"z"}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(zlabel = "Z variable",
             ylabel = "Y variable",
             explicit(sin(x^2+y^2),x,-2,2,y,-2,2),
             xlabel = "X variable" )$
@end example

Véanse también @code{xlabel} y @code{ylabel}.
@end defvr





@defvr {Opción gráfica} zrange
Valor por defecto: @code{auto}

Cuando @code{zrange} vale @code{auto}, el rango de la coordenada @var{z}
se calcula de forma automática.

Si el usuario quiere especificar un intervalo para @var{z}, éste debe
expresarse como una lista de Maxima, como en @code{zrange=[-2, 3]}.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(yrange = [-3,3],
             zrange = [-2,5],
             explicit(x^2+y^2,x,-1,1,y,-1,1),
             xrange = [-3,3])$
@end example

Véanse también @code{xrange} y @code{yrange}.
@end defvr




@defvr {Opción gráfica} ztics
Valor por defecto: @code{true}

Esta opción gráfica controla la forma en la que se dibujarán las marcas
del eje @var{z}.

Véase @code{xtics} para una descripción completa.
@end defvr





@defvr {Opción gráfica} ztics_axis
Valor por defecto: @code{false}

Si @code{ztics_axis} vale @code{true}, las marcas y sus etiquetas se dibujan sobre
el propio eje @var{z}, si vale @code{false} las marcas se colocan a lo largo del borde
del gráfico.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr





@defvr {Opción gráfica} ztics_rotate
Valor por defecto: @code{false}

Si @code{ztics_rotate} vale @code{true}, las marcas del eje @var{z} se giran 
90 grados.

Puesto que ésta es una opción global, su posición dentro de la
descripción de la escena no reviste importancia.
@end defvr




@subsection Objetos gráficos



@deffn  {Objeto gráfico} bars ([@var{x1},@var{h1},@var{w1}], [@var{x2},@var{h2},@var{w2}, ...])
Dibuja barras verticales en 2D.

@b{2D}

@code{bars ([@var{x1},@var{h1},@var{w1}], [@var{x2},@var{h2},@var{w2}, ...])} 
dibuja barras centradas en los valores @var{x1}, @var{x2}, ... de alturas @var{h1}, @var{h2}, ...
y anchos @var{w1}, @var{w2}, ...

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{key}, 
@code{fill_color}, @code{fill_density} y @code{line_width}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
       key          = "Grupo A",
       fill_color   = blue,
       fill_density = 0.2,
       bars([0.8,5,0.4],[1.8,7,0.4],[2.8,-4,0.4]),
       key          = "Grupo B",
       fill_color   = red,
       fill_density = 0.6,
       line_width   = 4,
       bars([1.2,4,0.4],[2.2,-2,0.4],[3.2,5,0.4]),
       xaxis = true);
@end example
@end deffn






@deffn  {Objeto gráfico} cylindrical (@var{radius},@var{z},@var{minz},@var{maxz},@var{azi},@var{minazi},@var{maxazi})
Dibuja funciones 3D definidas en coordenadas cilíndricas.

@b{3D}

@code{cylindrical (@var{radius},@var{z},@var{minz},@var{maxz},@var{azi},@var{minazi},@var{maxazi})}
dibuja la función @code{@var{radius}(@var{z},@var{azi})} definida en coordenadas cilíndricas, con la variable
@var{z} tomando valores desde @var{minz} hasta @var{maxz} y el @i{azimut} @var{azi} tomando valores desde
@var{minazi} hasta @var{maxazi}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{xu_grid}, 
@code{yv_grid}, @code{line_type}, @code{key}, @code{wired_surface}, @code{enhanced3d} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(cylindrical(1,z,-2,2,az,0,2*%pi))$
@end example
@end deffn




@deffn  {Objeto gráfico} elevation_grid (@var{mat},@var{x0},@var{y0},@var{width},@var{height})
Dibuja la matriz @var{mat} en 3D. Los valores @var{z} se toman de @var{mat},
las abscisas van desde @var{x0} hasta @math{@var{x0} + @var{width}}
y las ordenadas desde @var{y0} hasta @math{@var{y0} + @var{height}}. El elemento @math{a(1,1)}
se proyecta sobre el punto @math{(x0,y0+height)}, @math{a(1,n)} sobre @math{(x0+width,y0+height)},
@math{a(m,1)} sobre @math{(x0,y0)} y @math{a(m,n)} sobre @math{(x0+width,y0)}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{line_type},
@code{line_width}, @code{key}, @code{wired_surface}, @code{enhanced3d} y @code{color}.

En versiones antiguas de Maxima, @code{elevation_grid} se llamaba @code{mesh}.
Véase también @code{mesh}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) m: apply(
            matrix,
            makelist(makelist(random(10.0),k,1,30),i,1,20)) $
(%i3) draw3d(
         color = blue,
         elevation_grid(m,0,0,3,2),
         xlabel = "x",
         ylabel = "y",
         surface_hide = true);
@end example

@end deffn





@deffn  {Objeto gráfico} ellipse (@var{xc}, @var{yc}, @var{a}, @var{b}, @var{ang1}, @var{ang2})
Dibuja elipses y círculos en 2D.


@b{2D}

@code{ellipse (@var{xc}, @var{yc}, @var{a}, @var{b}, @var{ang1}, @var{ang2})}
dibuja una elipse de centro @code{[@var{xc}, @var{yc}]} con semiejes horizontal y vertical
@var{a} y @var{b}, respectivamente, comenzando en el ángulo @var{ang1} y trazando un arco
de amplitud igual al ángulo @var{ang2}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{nticks}, 
@code{transparent}, @code{fill_color}, @code{border}, @code{line_width}, 
@code{line_type}, @code{key} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(transparent = false,
             fill_color  = red,
             color       = gray30,
             transparent = false,
             line_width  = 5,
             ellipse(0,6,3,2,270,-270),
             /* center (x,y), a, b, start & end in degrees */
             transparent = true,
             color       = blue,
             line_width  = 3,
             ellipse(2.5,6,2,3,30,-90),
             xrange      = [-3,6],
             yrange      = [2,9] )$
@end example
@end deffn



@deffn  {Objeto gráfico} errors ([@var{x1},@var{x2},...], [@var{y1},@var{y2},...])
Dibuja puntos con barras de error asociadas horizontales, verticales o de
ambos tipos, según sea el valor de la opción @code{error_type}.

@b{2D}

Si @code{error_type=x}, los argumentos a @code{errors} deben ser de la forma 
@code{[x,y,xdelta]} o @code{[x,y,xlow,xhigh]}. Si @code{error_type=y}, 
los argumentos deben ser del tipo @code{[x,y,ydelta]} o @code{[x,y,ylow,yhigh]}.
Si @code{error_type=xy} o @code{error_type=boxes}, los argumentos deben ser de la
forma @code{[x,y,xdelta,ydelta]} o @code{[x,y,xlow,xhigh,ylow,yhigh]}.

Véase también @code{error_type}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{error_type}, 
@code{points_joined}, @code{line_width}, @code{key}, @code{line_type}, 
@code{color}, @code{fill_density}, @code{xaxis_secondary} y @code{yaxis_secondary}.

La opción @code{fill_density} solo es relevante cuando @code{error_type=boxes}.

Ejemplos:

Barras de error horizontales.

@example
(%i1) load(draw)$
(%i2) draw2d(
        error_type = y,
        errors([[1,2,1], [3,5,3], [10,3,1], [17,6,2]]))$
@end example

Barras de error horizontales y verticales.

@example
(%i1) load(draw)$
(%i2) draw2d(
        error_type = xy,
        points_joined = true,
        color = blue,
        errors([[1,2,1,2], [3,5,2,1], [10,3,1,1], [17,6,1/2,2]])); 
@end example

@end deffn



@deffn  {Objeto gráfico} explicit (@var{fcn},@var{var},@var{minval},@var{maxval})
@deffnx {Objeto gráfico} explicit (@var{fcn},@var{var1},@var{minval1},@var{maxval1},@var{var2},@var{minval2},@var{maxval2})
Dibuja funciones explícitas en 2D y 3D.

@b{2D}

@code{explicit (@var{fcn},@var{var},@var{minval},@var{maxval})} dibuja la función explícita @var{fcn},
con la variable @var{var} tomando valores desde @var{minval} hasta @var{maxval}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{nticks}, 
@code{adapt_depth}, @code{draw_realpart}, @code{line_width}, @code{line_type}, @code{key}, 
@code{filled_func}, @code{fill_color} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(line_width = 3,
             color      = blue,
             explicit(x^2,x,-3,3) )$
(%i3) draw2d(fill_color  = brown,
             filled_func = true,
             explicit(x^2,x,-3,3) )$
@end example

@b{3D}

@code{explicit (@var{fcn},@var{var1},@var{minval1},@var{maxval1},@var{var2},@var{minval2},@var{maxval2})}
dibuja la función explícita @var{fcn}, con la variable 
@code{var1} tomando valores desde @var{minval1} hasta @var{maxval1} y 
la variable @var{var2} tomando valores desde @var{minval2} hasta @var{maxval2}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{draw_realpart}, @code{xu_grid}, 
@code{yv_grid}, @code{line_type}, @code{line_width}, @code{key}, @code{wired_surface}, @code{enhanced3d}
y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(key   = "Gauss",
             color = "#a02c00",
             explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3),
             yv_grid     = 10,
             color = blue,
             key   = "Plane",
             explicit(x+y,x,-5,5,y,-5,5),
             surface_hide = true)$
@end example

Véase también @code{filled_func} para el relleno de curvas.
@end deffn




@deffn  {Objeto gráfico} image (@var{im},@var{x0},@var{y0},@var{width},@var{height})
Reproduce una imagen en 2D.

@b{2D}

@code{image (@var{im},@var{x0},@var{y0},@var{width},@var{height})}:
dibuja la imagen @var{im} en la región rectangular desde el vértice @code{(@var{x0},@var{y0})}
hasta el @code{(x0+@var{width},y0+@var{height})} del plano real. El argumento @var{im} debe ser una
matriz de números reales, una matriz de vectores de longitud tres o un objeto
de tipo @code{picture}.

Si @var{im} es una matriz de números reales, los valores de los
píxeles se interpretan según indique la opción
gráfica @code{palette}, que es un vector de longitud tres con sus componentes tomando
valores enteros en el rango desde -36 a +36; cada valor es un 
índice para seleccionar una fórmula que transforma los niveles
numéricos en las componentes cromáticas rojo, verde y azul:
@example
 0: 0               1: 0.5           2: 1
 3: x               4: x^2           5: x^3
 6: x^4             7: sqrt(x)       8: sqrt(sqrt(x))
 9: sin(90x)       10: cos(90x)     11: |x-0.5|
12: (2x-1)^2       13: sin(180x)    14: |cos(180x)|
15: sin(360x)      16: cos(360x)    17: |sin(360x)|
18: |cos(360x)|    19: |sin(720x)|  20: |cos(720x)|
21: 3x             22: 3x-1         23: 3x-2
24: |3x-1|         25: |3x-2|       26: (3x-1)/2
27: (3x-2)/2       28: |(3x-1)/2|   29: |(3x-2)/2|
30: x/0.32-0.78125 31: 2*x-0.84
32: 4x;1;-2x+1.84;x/0.08-11.5
33: |2*x - 0.5|    34: 2*x          35: 2*x - 0.5
36: 2*x - 1
@end example
los números negativos se interpretan como colores invertidos
de las componentes cromáticas.

@code{palette = gray} y @code{palette = color} son atajos para
@code{palette = [3,3,3]} y @code{palette = [7,5,15]}, respectivamente.

Si @var{im} es una matriz de vectores de longitud tres, éstos se
interpretarán como las componentes cromáticas rojo, verde y azul.

Ejemplos:

Si @var{im} es una matriz de números reales, los valores de los
píxeles se interpretan según indique la opción
gráfica @code{palette}.
@example
(%i1) load(draw)$
(%i2) im: apply(
           'matrix,
            makelist(makelist(random(200),i,1,30),i,1,30))$
(%i3) /* palette = color, default */
      draw2d(image(im,0,0,30,30))$
(%i4) draw2d(palette = gray, image(im,0,0,30,30))$
(%i5) draw2d(palette = [15,20,-4],
             colorbox=false,
             image(im,0,0,30,30))$
@end example

Véase también @code{colorbox}.

Si @var{im} es una matriz de vectores de longitud tres, éstos se
interpretarán como las componentes cromáticas rojo, verde y azul.
@example
(%i1) load(draw)$
(%i2) im: apply(
            'matrix,
             makelist(
               makelist([random(300),
                         random(300),
                         random(300)],i,1,30),i,1,30))$
(%i3) draw2d(image(im,0,0,30,30))$
@end example

El paquete @code{draw} carga automáticamente el paquete @code{picture}. 
En este ejemplo, una imagen de niveles se define a mano, reproduciéndola
a continuación.
@example
(%i1) load(draw)$
(%i2) im: make_level_picture([45,87,2,134,204,16],3,2);
(%o2)       picture(level, 3, 2, @{Array:  #(45 87 2 134 204 16)@})
(%i3) /* default color palette */
      draw2d(image(im,0,0,30,30))$
(%i4) /* gray palette */
      draw2d(palette = gray,
             image(im,0,0,30,30))$
@end example

Se lee un fichero xpm y se reproduce.
@example
(%i1) load(draw)$
(%i2) im: read_xpm("myfile.xpm")$
(%i3) draw2d(image(im,0,0,10,7))$
@end example

Véanse también @code{make_level_picture}, @code{make_rgb_picture} y @code{read_xpm}.

En @url{http://www.telefonica.net/web2/biomates/maxima/gpdraw/image}
se encuentran ejemplos más elaborados.
@end deffn





@deffn  {Objeto gráfico} implicit (@var{fcn},@var{x},@var{xmin},@var{xmax},@var{y},@var{ymin},@var{ymax})
@deffnx {Objeto gráfico} implicit (@var{fcn},@var{x},@var{xmin},@var{xmax},@var{y},@var{ymin},@var{ymax},@var{z},@var{zmin},@var{zmax})
Dibuja funciones implícitas en 2D y 3D.

@b{2D}

@code{implicit (@var{fcn},@var{x},@var{xmin},@var{xmax},@var{y},@var{ymin},@var{ymax})}
dibuja la función implícita @var{fcn}, con la variable
@code{x} tomando valores desde @var{xmin} hasta @var{xmax},
y la variable @var{y} tomando valores desde @var{ymin} hasta @var{ymax}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{ip_grid}, 
@code{ip_grid_in}, @code{line_width}, @code{line_type}, @code{key} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(terminal  = eps,
             grid      = true,
             line_type = solid,
             key       = "y^2=x^3-2*x+1",
             implicit(y^2=x^3-2*x+1, x, -4,4, y, -4,4),
             line_type = dots,
             key       = "x^3+y^3 = 3*x*y^2-x-1",
             implicit(x^3+y^3 = 3*x*y^2-x-1, x,-4,4, y,-4,4),
             title     = "Two implicit functions" )$
@end example

@b{3D}

@code{implicit (@var{fcn},@var{x},@var{xmin},@var{xmax}, @var{y},@var{ymin},@var{ymax}, @var{z},@var{zmin},@var{zmax})}
dibuja la función implícita @var{fcn}, con la variable @var{x} 
tomando valores desde @var{xmin} hasta @var{xmax}, la variable @var{y} tomando 
valores desde @var{ymin} hasta @var{ymax} y la variable @var{z} tomando 
valores desde @var{zmin} hasta @var{zmax}. Este objeto está programado con el 
algoritmo @i{marching cubes}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{x_voxel}, 
@code{y_voxel}, @code{z_voxel}, @code{line_width}, @code{line_type}, @code{key}, 
@code{wired_surface}, @code{enhanced3d} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(
        color=blue,
        implicit((x^2+y^2+z^2-1)*(x^2+(y-1.5)^2+z^2-0.5)=0.015,
                 x,-1,1,y,-1.2,2.3,z,-1,1),
        surface_hide=true);
@end example
@end deffn





@deffn  {Objeto gráfico} label ([@var{string},@var{x},@var{y}],...)
@deffnx {Objeto gráfico} label ([@var{string},@var{x},@var{y},@var{z}],...)
Escribe etiquetas en 2D y 3D.

Las etiquetas coloreadas sólo trabajan con Gnuplot 4.3. Este es un fallo conocido del
paquete @code{draw}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{label_alignment}, 
@code{label_orientation} y @code{color}.

@b{2D}

@code{label([@var{string},@var{x},@var{y}])} escribe la cadena de caracteres @var{string} 
en el punto @code{[@var{x},@var{y}]}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(yrange = [0.1,1.4],
             color = red,
             label(["Label in red",0,0.3]),
             color = "#0000ff",
             label(["Label in blue",0,0.6]),
             color = light_blue,
             label(["Label in light-blue",0,0.9],
                   ["Another light-blue",0,1.2])  )$
@end example

@b{3D}

@code{label([@var{string},@var{x},@var{y},@var{z}])} escribe la cadena de caracteres @var{string}
en el punto @code{[@var{x},@var{y},@var{z}]}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3),
             color = red,
             label(["UP 1",-2,0,3], ["UP 2",1.5,0,4]),
             color = blue,
             label(["DOWN 1",2,0,-3]) )$
@end example
@end deffn



@deffn  {Objeto gráfico} mesh (@var{fila_1},@var{fila_2},...)
Dibuja un enrejado cuadrangular en 3D.

@b{3D}

El argumento @var{fila_i} es una lista de @var{n} puntos en 3D de la forma
@code{[[x_i1,y_i1,z_i1], ...,[x_in,y_in,z_in]]}, siendo todas las filas de
igual longitud. Todos estos puntos definen una superficie arbitraria en 3D.
En cierto sentido, se trata de una generalización del objeto @code{elevation_grid}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{line_type}, 
@code{line_width}, @code{color}, @code{key}, @code{wired_surface}, @code{enhanced3d} y @code{transform}.

Ejemplos:

Un sencillo ejemplo.

@example
(%i1) load(draw)$
(%i2) draw3d( 
         mesh([[1,1,3],   [7,3,1],[12,-2,4],[15,0,5]],
              [[2,7,8],   [4,3,1],[10,5,8], [12,7,1]],
              [[-2,11,10],[6,9,5],[6,15,1], [20,15,2]])) $
@end example

Dibujando un triángulo en 3D.

@example
(%i1) load(draw)$
(%i2) draw3d(
        line_width = 2,
        mesh([[1,0,0],[0,1,0]],
             [[0,0,1],[0,0,1]])) $
@end example

Dos cuadriláteros.

@example
(%i1) load(draw)$
(%i2) draw3d(
        surface_hide = true,
        line_width   = 3,
        color = red,
        mesh([[0,0,0], [0,1,0]],
             [[2,0,2], [2,2,2]]),
        color = blue,
        mesh([[0,0,2], [0,1,2]],
             [[2,0,4], [2,2,4]])) $
@end example
@end deffn



@deffn  {Objeto gráfico} parametric (@var{xfun},@var{yfun},@var{par},@var{parmin},@var{parmax})
@deffnx {Objeto gráfico} parametric (@var{xfun},@var{yfun},@var{zfun},@var{par},@var{parmin},@var{parmax})
Dibuja funciones paramétricas en 2D y 3D.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{nticks}, 
@code{line_width}, @code{line_type}, @code{key}, @code{color} y @code{enhanced3d}.

@b{2D}

@code{parametric (@var{xfun},@var{yfun},@var{par},@var{parmin},@var{parmax})} dibuja la función paramétrica 
@code{[@var{xfun},@var{yfun}]}, con el parámetro @var{par} tomando valores desde 
@var{parmin} hasta @var{parmax}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(explicit(exp(x),x,-1,3),
             color = red,
             key   = "This is the parametric one!!",
             parametric(2*cos(rrr),rrr^2,rrr,0,2*%pi))$
@end example

@b{3D}

@code{parametric (@var{xfun},@var{yfun},@var{zfun},@var{par},@var{parmin},@var{parmax})} 
dibuja la curva paramétrica @code{[@var{xfun},@var{yfun},@var{zfun}]}, con el parámetro
@var{par} tomando valores desde @var{parmin} hasta @var{parmax}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3),
             color = royalblue,
             parametric(cos(5*u)^2,sin(7*u),u-2,u,0,2),
             color      = turquoise,
             line_width = 2,
             parametric(t^2,sin(t),2+t,t,0,2),
             surface_hide = true,
             title = "Surface & curves" )$
@end example
@end deffn





@deffn  {Objeto gráfico} parametric_surface (@var{xfun},@var{yfun},@var{zfun},@var{par1},@var{par1min},@var{par1max},@var{par2},@var{par2min},@var{par2max})
Dibuja superficies paramétricas en 3D.

@b{3D}

@code{parametric_surface (@var{xfun},@var{yfun},@var{zfun},@var{par1},@var{par1min},@var{par1max},@var{par2},@var{par2min},@var{par2max})}
dibuja la superficie paramétrica @code{[@var{xfun},@var{yfun},@var{zfun}]}, 
con el parámetro @var{par1} tomando valores desde @var{par1min} hasta @var{par1max}
y el parámetro @var{par2} tomando valores desde @var{par2min} hasta @var{par2max}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{draw_realpart}, @code{xu_grid}, 
@code{yv_grid}, @code{line_type}, @code{line_width}, @code{key}, @code{wired_surface}, @code{enhanced3d}
y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(title          = "Sea shell",
             xu_grid        = 100,
             yv_grid        = 25,
             view           = [100,20],
             surface_hide   = true,
             parametric_surface(0.5*u*cos(u)*(cos(v)+1),
                           0.5*u*sin(u)*(cos(v)+1),
                           u*sin(v) - ((u+3)/8*%pi)^2 - 20,
                           u, 0, 13*%pi, v, -%pi, %pi) )$
@end example
@end deffn




@deffn  {Objeto gráfico} points ([[@var{x1},@var{y1}], [@var{x2},@var{y2}],...])
@deffnx {Objeto gráfico} points ([@var{x1},@var{x2},...], [@var{y1},@var{y2},...])
@deffnx {Objeto gráfico} points ([@var{y1},@var{y2},...])
@deffnx {Objeto gráfico} points ([[@var{x1},@var{y1},@var{z1}], [@var{x2},@var{y2},@var{z2}],...])
@deffnx {Objeto gráfico} points ([@var{x1},@var{x2},...], [@var{y1},@var{y2},...], [@var{z1},@var{z2},...])
@deffnx {Objeto gráfico} points (@var{matrix})
@deffnx {Objeto gráfico} points (@var{1d_y_array})
@deffnx {Objeto gráfico} points (@var{1d_x_array}, @var{1d_y_array})
@deffnx {Objeto gráfico} points (@var{1d_x_array}, @var{1d_y_array}, @var{1d_z_array})
@deffnx {Objeto gráfico} points (@var{2d_xy_array})
@deffnx {Objeto gráfico} points (@var{2d_xyz_array})

Dibuja puntos en 2D y 3D.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{point_size}, 
@code{point_type}, @code{points_joined}, @code{line_width}, @code{key},
@code{line_type} y @code{color}. En modo 3D también se ve afectado por @code{enhanced3d}.

@b{2D}

@code{points ([[@var{x1},@var{y1}], [@var{x2},@var{y2}],...])} o 
@code{points ([@var{x1},@var{x2},...], [@var{y1},@var{y2},...])}
dibuja los puntos @code{[@var{x1},@var{y1}]}, @code{[@var{x2},@var{y2}]}, etc. Si no se dan las abscisas,
éstas se asignan automáticamente a enteros positivos consecutivos, de forma que
@code{points([@var{y1},@var{y2},...])} dibuja los puntos @code{[1,@var{y1}]}, @code{[2,@var{y2}]}, etc.
Si @var{matrix} es una matriz de dos columnas o de dos filas, @code{points (@var{matrix})}
dibuja los puntos asociados.

Si @var{1d_y_array} es un array lisp de números en 1D, @code{points (@var{1d_y_array})}
los dibujará asignando las abscisas a números enteros consecutivos.
@code{points (@var{1d_x_array}, @var{1d_y_array})} dibuja los puntos cuyas coordenadas
se toman de los dos arrays pasados como argumentos. Si @var{2d_xy_array} es un array lisp
2D de dos filas, o de dos columnas, @code{points (@var{2d_xy_array})} dibuja los correspondientes
puntos del plano.

Ejemplos:

Dos tipos de argumentos para @code{points}, una lista de pares ordenados
y dos listas con las coordenadas separadas.
@example
(%i1) load(draw)$
(%i2) draw2d(
        key = "Small points",
        points(makelist([random(20),random(50)],k,1,10)),
        point_type    = circle,
        point_size    = 3,
        points_joined = true,
        key           = "Great points",
        points(makelist(k,k,1,20),makelist(random(30),k,1,20)),
        point_type    = filled_down_triangle,
        key           = "Automatic abscissas",
        color         = red,
        points([2,12,8]))$
@end example

Dibujando impulsos.
@example
(%i1) load(draw)$
(%i2) draw2d(
        points_joined = impulses,
        line_width    = 2,
        color         = red,
        points(makelist([random(20),random(50)],k,1,10)))$
@end example

Array con ordenadas.
@example
(%i1) load(draw)$
(%i2) a: make_array (flonum, 100) $
(%i3) for i:0 thru 99 do a[i]: random(1.0) $
(%i4) draw2d(points(a)) $
@end example

Dos arrays con coordenadas separadas.
@example
(%i1) load(draw)$
(%i2) x: make_array (flonum, 100) $
(%i3) y: make_array (fixnum, 100) $
(%i4) for i:0 thru 99 do (
        x[i]: float(i/100),
        y[i]: random(10) ) $
(%i5) draw2d(points(x, y)) $
@end example

Un array 2D de dos columnas.
@example
(%i1) load(draw)$
(%i2) xy: make_array(flonum, 100, 2) $
(%i3) for i:0 thru 99 do (
        xy[i, 0]: float(i/100),
        xy[i, 1]: random(10) ) $
(%i4) draw2d(points(xy)) $
@end example

Dibujando un array rellenado con la función @code{read_array}.
@example
(%i1) load(draw)$
(%i2) a: make_array(flonum,100) $
(%i3) read_array (file_search ("pidigits.data"), a) $
(%i4) draw2d(points(a)) $
@end example

@b{3D}

@code{points ([[@var{x1},@var{y1},@var{z1}], [@var{x2},@var{y2},@var{z2}],...])} o 
@code{points ([@var{x1},@var{x2},...], [@var{y1},@var{y2},...], [@var{z1},@var{z2},...])}
dibuja los puntos @code{[@var{x1},@var{y1},@var{z1}]}, @code{[@var{x2},@var{y2},@var{z2}]}, etc.
Si @var{matrix} es una matriz de tres columnas o de tres filas, @code{points (@var{matrix})}
dibuja los puntos asociados. Si @var{matrix} es una matriz columna o fila, las abscisas 
se asignan automáticamente. 

En caso de que los argumentos sean arrays lisp, @code{points (@var{1d_x_array}, @var{1d_y_array}, @var{1d_z_array})}
toma las coordenadas de los tres arrays unidimensionales. Si @var{2d_xyz_array} es un array 2D de tres columnas,
o de tres filas, entonces @code{points (@var{2d_xyz_array})} dibuja los puntos correspondientes.

Ejemplos:

Una muestra tridimensional,
@example
(%i1) load(draw)$
(%i2) load (numericalio)$
(%i3) s2 : read_matrix (file_search ("wind.data"))$
(%i4) draw3d(title = "Daily average wind speeds",
             point_size = 2,
             points(args(submatrix (s2, 4, 5))) )$
@end example

Dos muestras tridimensionales,
@example
(%i1) load(draw)$
(%i2) load (numericalio)$
(%i3) s2 : read_matrix (file_search ("wind.data"))$
(%i4) draw3d(
         title = "Daily average wind speeds. Two data sets",
         point_size = 2,
         key        = "Sample from stations 1, 2 and 3",
         points(args(submatrix (s2, 4, 5))),
         point_type = 4,
         key        = "Sample from stations 1, 4 and 5",
         points(args(submatrix (s2, 2, 3))) )$
@end example

Arrays unidimensionales,
@example
(%i1) load(draw)$
(%i2) x: make_array (fixnum, 10) $
(%i3) y: make_array (fixnum, 10) $
(%i4) z: make_array (fixnum, 10) $
(%i5) for i:0 thru 9 do (
        x[i]: random(10),
        y[i]: random(10),
        z[i]: random(10) ) $
(%i6) draw3d(points(x,y,z)) $
@end example

Array bidimensional coloreado,
@example
(%i1) load(draw)$
(%i2) xyz: make_array(fixnum, 10, 3) $
(%i3) for i:0 thru 9 do (
        xyz[i, 0]: random(10),
        xyz[i, 1]: random(10),
        xyz[i, 2]: random(10) ) $
(%i4) draw3d(
         enhanced3d = true,
         points_joined = true,
         points(xyz)) $
@end example

Números de colores especificados explícitamente
por el usuario.
@example
(%i1) load(draw)$
(%i2) pts: makelist([t,t^2,cos(t)], t, 0, 15)$
(%i3) col_num: makelist(k, k, 1, length(pts))$
(%i4) draw3d(
        enhanced3d = ['part(col_num,k),k],
        point_size = 3,
        point_type = filled_circle,
        points(pts))$
@end example
@end deffn




@deffn  {Objeto gráfico} polar (@var{radius},@var{ang},@var{minang},@var{maxang})
Dibuja funciones 2D definidas en coordenadas polares.

@b{2D}

@code{polar (@var{radius},@var{ang},@var{minang},@var{maxang})} dibuja la función
@code{@var{radius}(@var{ang})} definida en coordenadas polares, con la variable 
@var{ang} tomando valores desde @var{minang} hasta @var{maxang}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{nticks}, 
@code{line_width}, @code{line_type}, @code{key} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(user_preamble = "set grid polar",
             nticks        = 200,
             xrange        = [-5,5],
             yrange        = [-5,5],
             color         = blue,
             line_width    = 3,
             title         = "Hyperbolic Spiral",
             polar(10/theta,theta,1,10*%pi) )$
@end example
@end deffn





@deffn  {Objeto gráfico} polygon ([[@var{x1},@var{y1}], [@var{x2},@var{y2}],...])
@deffnx {Objeto gráfico} polygon ([@var{x1},@var{x2},...], [@var{y1},@var{y2},...])
Dibuja polígonos en 2D.

@b{2D}

@code{polygon ([[@var{x1},@var{y1}], [@var{x2},@var{y2}],...])} o 
@code{polygon ([@var{x1},@var{x2},...], [@var{y1},@var{y2},...])}:
dibuja en el plano un polígono de vértices 
@code{[@var{x1},@var{y1}]}, @code{[@var{x2},@var{y2}]}, etc..

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{transparent}, 
@code{fill_color}, @code{border}, @code{line_width}, @code{key},
 @code{line_type} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(color      = "#e245f0",
             line_width = 8,
             polygon([[3,2],[7,2],[5,5]]),
             border      = false,
             fill_color  = yellow,
             polygon([[5,2],[9,2],[7,5]]) )$
@end example
@end deffn



@deffn  {Objeto gráfico} quadrilateral (@var{point_1}, @var{point_2}, @var{point_3}, @var{point_4})
Dibuja un cuadrilátero.

@b{2D}

@code{quadrilateral ([@var{x1},@var{y1}], [@var{x2},@var{y2}], [@var{x3},@var{y3}], [@var{x4},@var{y4}])} dibuja un cuadrilátero de vértices @code{[@var{x1},@var{y1}]}, 
@code{[@var{x2},@var{y2}]}, @code{[@var{x3},@var{y3}]} y @code{[@var{x4},@var{y4}]}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{transparent}, 
@code{fill_color}, @code{border}, @code{line_width}, @code{key}, @code{xaxis_secondary}, 
@code{yaxis_secondary}, @code{line_type}, @code{transform} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
        quadrilateral([1,1],[2,2],[3,-1],[2,-2]))$
@end example

@b{3D}

@code{quadrilateral ([@var{x1},@var{y1},@var{z1}], [@var{x2},@var{y2},@var{z2}], [@var{x3},@var{y3},@var{z3}], [@var{x4},@var{y4},@var{z4}])} dibuja un cuadrilátero de vértices
@code{[@var{x1},@var{y1},@var{z1}]}, @code{[@var{x2},@var{y2},@var{z2}]},
@code{[@var{x3},@var{y3},@var{z3}]} y @code{[@var{x4},@var{y4},@var{z4}]}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{line_type}, 
@code{line_width}, @code{color}, @code{key}, @code{enhanced3d} y @code{transform}.
@end deffn



@deffn  {Objeto gráfico} rectangle ([@var{x1},@var{y1}], [@var{x2},@var{y2}])
Dibuja rectángulos en 2D.

@b{2D}

@code{rectangle ([@var{x1},@var{y1}], [@var{x2},@var{y2}])} dibuja un rectángulo de vértices opuestos
@code{[@var{x1},@var{y1}]} y @code{[@var{x2},@var{y2}]}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{transparent}, 
@code{fill_color}, @code{border}, @code{line_width}, @code{key},
@code{line_type} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(fill_color  = red,
             line_width  = 6,
             line_type   = dots,
             transparent = false,
             fill_color  = blue,
             rectangle([-2,-2],[8,-1]), /* opposite vertices */
             transparent = true,
             line_type   = solid,
             line_width  = 1,
             rectangle([9,4],[2,-1.5]),
             xrange      = [-3,10],
             yrange      = [-3,4.5] )$
@end example
@end deffn






@deffn  {Objeto gráfico} region (@var{expr},@var{var1},@var{minval1},@var{maxval1},@var{var2},@var{minval2},@var{maxval2})
Dibuja una región del plano definida por desigualdades.

@b{2D}
@var{expr} es una expresión formada por desigualdades y los operadores lógicos
@code{and}, @code{or} y @code{not}. La región está acotada por el rectángulo
definido por @math{[@var{minval1}, @var{maxval1}]} y
@math{[@var{minval2}, @var{maxval2}]}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{fill_color}, 
@code{key}, @code{x_voxel} y @code{y_voxel}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
        x_voxel = 30,
        y_voxel = 30,
        region(x^2+y^2<1 and x^2+y^2 > 1/2,
               x, -1.5, 1.5, y, -1.5, 1.5));
@end example
@end deffn





@deffn  {Objeto gráfico} spherical (@var{radius},@var{azi},@var{minazi},@var{maxazi},@var{zen},@var{minzen},@var{maxzen})
Dibuja funciones 3D definidas en coordenadas esféricas.

@b{3D}

@code{spherical (@var{radius},@var{azi},@var{minazi},@var{maxazi},@var{zen},@var{minzen},@var{maxzen})}
dibuja la función @code{@var{radius}(@var{azi},@var{zen})} definida en coordenadas esféricas, con el @i{azimut}
@var{azi} tomando valores desde @var{minazi} hasta @var{maxazi} y el @i{zenit} @var{zen} tomando valores desde
@var{minzen} hasta @var{maxzen}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{xu_grid}, 
@code{yv_grid}, @code{line_type}, @code{key}, @code{wired_surface}, @code{enhanced3d} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(spherical(1,a,0,2*%pi,z,0,%pi))$
@end example
@end deffn



@deffn  {Objeto gráfico} triangle (@var{punto_1}, @var{punto_2}, @var{punto_3})
Dibuja un triángulo.

@b{2D}

@code{triangle ([@var{x1},@var{y1}], [@var{x2},@var{y2}], [@var{x3},@var{y3}])} dibuja
un triángulo de vértices @code{[@var{x1},@var{y1}]}, @code{[@var{x2},@var{y2}]} y
@code{[@var{x3},@var{y3}]}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{transparent}, 
@code{fill_color}, @code{border}, @code{line_width}, @code{key}, @code{xaxis_secondary}, 
@code{yaxis_secondary}, @code{line_type}, @code{transform} y @code{color}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(
        triangle([1,1],[2,2],[3,-1]))$
@end example

@b{3D}

@code{triangle ([@var{x1},@var{y1},@var{z1}], [@var{x2},@var{y2},@var{z2}], [@var{x3},@var{y3},@var{z3}])} dibuja un triángulo de vértices @code{[@var{x1},@var{y1},@var{z1}]},
@code{[@var{x2},@var{y2},@var{z2}]} y @code{[@var{x3},@var{y3},@var{z3}]}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{line_type}, 
@code{line_width}, @code{color}, @code{key}, @code{enhanced3d} y @code{transform}.
@end deffn



@deffn  {Objeto gráfico} tube (@var{xfun},@var{yfun},@var{zfun},@var{rfun},@var{p},@var{pmin},@var{pmax})
Dibuja un tubo en 3D de diámetro variable.

@b{3D}

@code{[@var{xfun},@var{yfun},@var{zfun}]}
es la curva paramétrica de parámetro @var{p}, el cual toma valores entre
@var{pmin} y @var{pmax}. Se colocan círculos de radio @var{rfun}
con sus centros sobre la curva paramétrica y perpendiculares a ella.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{xu_grid}, 
@code{yv_grid}, @code{line_type}, @code{line_width}, @code{key}, @code{wired_surface}, @code{enhanced3d},
@code{color} y @code{capping}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(
        enhanced3d = true,
        xu_grid    = 50,
        tube(cos(a), a, 0, cos(a/10)^2,
             a, 0, 4*%pi) )$
@end example

@end deffn




@deffn  {Objeto gráfico} vector ([@var{x},@var{y}], [@var{dx},@var{dy}])
@deffnx {Objeto gráfico} vector ([@var{x},@var{y},@var{z}], [@var{dx},@var{dy},@var{dz}])
Dibuja vectores en 2D y 3D.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{head_both}, 
@code{head_length}, @code{head_angle}, @code{head_type}, @code{line_width}, 
@code{line_type}, @code{key} y @code{color}.

@b{2D}

@code{vector ([@var{x},@var{y}], [@var{dx},@var{dy}])} dibuja el vector 
@code{[@var{dx},@var{dy}]} con origen en @code{[@var{x},@var{y}]}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw2d(xrange      = [0,12],
             yrange      = [0,10],
             head_length = 1,
             vector([0,1],[5,5]), /* default type */
             head_type = 'empty,
             vector([3,1],[5,5]),
             head_both = true,
             head_type = 'nofilled,
             line_type = dots,
             vector([6,1],[5,5]))$
@end example

@b{3D}

@code{vector([@var{x},@var{y},@var{z}], [@var{dx},@var{dy},@var{dz}])}
dibuja el vector @code{[@var{dx},@var{dy},@var{dz}]} con 
origen en @code{[@var{x},@var{y},@var{z}]}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) draw3d(color = cyan,
             vector([0,0,0],[1,1,1]/sqrt(3)),
             vector([0,0,0],[1,-1,0]/sqrt(2)),
             vector([0,0,0],[1,1,-2]/sqrt(6)) )$
@end example
@end deffn










@node Funciones y variables para picture, Funciones y variables para worldmap, Funciones y variables para draw, draw
@section Funciones y variables para picture





@deffn  {Función} get_pixel (@var{pic},@var{x},@var{y})
Devuelve el pixel de la imagen @var{pic}. Las coordenadas @var{x} e @var{y}
van desde 0 hasta @code{ancho-1} y @code{alto-1}, respectivamente.
@end deffn




@deffn  {Función} make_level_picture (@var{data})
@deffnx {Función} make_level_picture (@var{data},@var{width},@var{height})
Devuelve un objeto @code{picture} consistente en una imagen de niveles.
@code{make_level_picture (@var{data})} construye el objeto @code{picture}
a partir de la matriz @var{data}.
@code{make_level_picture (@var{data},@var{width},@var{height})}
construye el objeto a partir de una lista de números, en cuyo
caso deben indicarse el ancho @var{width} y la altura @var{height}
en píxeles.

El objeto  @code{picture} devuelto contiene los siguientes cuatro
elemento:

@enumerate
@item el símbolo @code{level}
@item anchura de la imagen
@item altura de la imagen
@item un array de enteros con los valores de los píxeles
entre 0 y 255. El argumento @var{data} debe contener sólo números
entre 0 y 255; los cantidades negativas se transforman en ceros y las 
que son mayores de 255 se igualan a este número.
@end enumerate

Ejemplo:

Imagen de niveles a partir de una matriz.
@example
(%i1) load(draw)$
(%i2) make_level_picture(matrix([3,2,5],[7,-9,3000]));
(%o2)         picture(level, 3, 2, @{Array:  #(3 2 5 7 0 255)@})
@end example

Imagen de niveles a partir de una lista numérica.
@example
(%i1) load(draw)$
(%i2) make_level_picture([-2,0,54,%pi],2,2);
(%o2)            picture(level, 2, 2, @{Array:  #(0 0 54 3)@})
@end example
@end deffn




@deffn  {Función} make_rgb_picture (@var{redlevel},@var{greenlevel},@var{bluelevel})
Devuelve un objeto @var{picture} conteniendo una imagen en color (RGB).
Los tres argumentos deben ser imágenes de niveles, para el rojo (R),
verde (G) y azul (B).

El objeto  @var{picture} devuelto contiene los siguientes cuatro
elemento:

@enumerate
@item el símbolo @code{rgb}
@item anchura de la imagen
@item altura de la imagen
@item un array de enteros de @var{3*ancho*alto} con los valores de los píxeles
entre 0 y 255. Cada valor de pixel se representa en el array con tres números consecutivos
(rojo, verde, azul).
@end enumerate

Ejemplo:

@example
(%i1) load(draw)$
(%i2) red: make_level_picture(matrix([3,2],[7,260]));
(%o2)           picture(level, 2, 2, @{Array:  #(3 2 7 255)@})
(%i3) green: make_level_picture(matrix([54,23],[73,-9]));
(%o3)           picture(level, 2, 2, @{Array:  #(54 23 73 0)@})
(%i4) blue: make_level_picture(matrix([123,82],[45,32.5698]));
(%o4)          picture(level, 2, 2, @{Array:  #(123 82 45 33)@})
(%i5) make_rgb_picture(red,green,blue);
(%o5) picture(rgb, 2, 2, 
              @{Array:  #(3 54 123 2 23 82 7 73 45 255 0 33)@})
@end example
@end deffn





@deffn  {Función} negative_picture (@var{pic})
Devuelve el negativo de la imagen, sea ésta de tipo nivel (@var{level})
o color (@var{rgb}).
@end deffn




@deffn  {Función} picture_equalp (@var{x},@var{y})
Devuelve @code{true} si los dos argumentos son imágenes idénticas,
o @code{false} en caso contrario.
@end deffn




@deffn  {Función} picturep (@var{x})
Devuelve @code{true} si el argumento es una imagen bien formada,
o @code{false} en caso contrario.
@end deffn




@deffn  {Función} read_xpm (@var{xpm_file})
Lee el fichero gráfico en formato xpm y devuelve un objeto @code{picture}.
@end deffn




@deffn  {Función} rgb2level (@var{pic})
Transforma una imagen en color @var{rgb} a otra de niveles @var{level}
promediando los niveles.
@end deffn




@deffn  {Función} take_channel (@var{im},@var{color})
Si el argumento @var{color} es @code{red}, @code{green} o @code{blue},
la función @code{take_channel} devuelve el canal de color correspondiente
de la imagen @var{im}.

Ejemplo:

@example
(%i1) load(draw)$
(%i2) red: make_level_picture(matrix([3,2],[7,260]));
(%o2)           picture(level, 2, 2, @{Array:  #(3 2 7 255)@})
(%i3) green: make_level_picture(matrix([54,23],[73,-9]));
(%o3)           picture(level, 2, 2, @{Array:  #(54 23 73 0)@})
(%i4) blue: make_level_picture(matrix([123,82],[45,32.5698]));
(%o4)          picture(level, 2, 2, @{Array:  #(123 82 45 33)@})
(%i5) make_rgb_picture(red,green,blue);
(%o5) picture(rgb, 2, 2, 
              @{Array:  #(3 54 123 2 23 82 7 73 45 255 0 33)@})
(%i6) take_channel(%,'green);  /* simple quote!!! */
(%o6)           picture(level, 2, 2, @{Array:  #(54 23 73 0)@})
@end example
@end deffn



@node Funciones y variables para worldmap,  , Funciones y variables para picture, draw
@section Funciones y variables para worldmap


Este paquete carga automáticamente el paquete @code{draw}.


@subsection Variables y Funciones






@defvr {Global variable} boundaries_array
Valor por defecto: @code{false}

@code{boundaries_array} es donde el objeto gráfico @code{geomap} lee
las coordenadas de las líneas fronterizas.

Cada componente de @code{boundaries_array} es un array de números decimales
en coma flotante representando las coordenadas que definen un segmento
poligonal o línea fronteriza.

Véase también @code{geomap}.
@end defvr




@deffn  {Función} numbered_boundaries (@var{nlist})
Dibuja una lista de segmentos poligonales (líneas 
fronterizas), etiquetadas con sus números correspondientes
(coordenadas de @code{boundaries_array}). Esta función es
de mucha ayuda a la hora de definir nuevas entidades
geográficas.

Ejemplo:

Mapa de Europa con las fronteras y costas etiquetadas con
su componente numérica de @code{boundaries_array}.
@example
(%i1) load(worldmap)$
(%i2) european_borders: 
           region_boundaries(-31.81,74.92,49.84,32.06)$
(%i3) numbered_boundaries(european_borders)$
@end example
@end deffn




@deffn  {Función} make_poly_continent (@var{continent_name})
@deffnx  {Función} make_poly_continent (@var{country_list})
Construye los polígonos necesarios para dibujar
un continente o lista de países coloreados.

Ejemplo:

@example
(%i1) load(worldmap)$
(%i2) /* A continent */
      make_poly_continent(Africa)$
(%i3) apply(draw2d, %)$
(%i4) /* A list of countries */
      make_poly_continent([Germany,Denmark,Poland])$
(%i5) apply(draw2d, %)$
@end example
@end deffn





@deffn  {Función} make_poly_country (@var{country_name})
Construye los polígonos necesarios para dibujar
un país coloreado. En caso de contener islas,
un país tendrá asociados varios polígonos.

Ejemplo:

@example
(%i1) load(worldmap)$
(%i2) make_poly_country(India)$
(%i3) apply(draw2d, %)$
@end example
@end deffn




@deffn  {Función} make_polygon (@var{nlist})
Devuelve un objeto @code{polygon} a partie de una lista
de líneas fronterizas y de costas. El
argumento @var{nlist} debe ser una lista de componentes
de @code{boundaries_array}.

Ejemplo:

La variable Bhutan (Bután) está definida con los números
fronterizos 171, 173 y 1143, de manera que @code{make_polygon([171,173,1143])}
concatena los arrays @code{boundaries_array[171]}, @code{boundaries_array[173]} y
@code{boundaries_array[1143]} y devuelve un objeto @code{polygon}
apto para ser dibujado por @code{draw}. A fin de evitar mensajes
de errores, los arrays deben ser compatibles en el sentido de que dos
de ellos consecutivos deben tener dos coordenadas comunes en los
extremos. En este ejemplo, las dos primeras componentes de 
@code{boundaries_array[171]} son iguales a las dos últimas de
@code{boundaries_array[173]}, y las dos primeras de @code{boundaries_array[173]}
coinciden con las dos primeras de @code{boundaries_array[1143]};
en conclusión, los números de segmentos poligonales171, 173 y 1143
(en este orden) son compatibles y el polígono
coloreado se podrá dibujar.
@example
(%i1) load(worldmap)$
(%i2) Bhutan;
(%o2)                        [[171, 173, 1143]]
(%i3) boundaries_array[171];
(%o3) @{Array:  
       #(88.750549 27.14727 88.806351 27.25305 88.901367 27.282221
         88.917877 27.321039)@}
(%i4) boundaries_array[173];
(%o4) @{Array:
       #(91.659554 27.76511 91.6008 27.66666 91.598022 27.62499
         91.631348 27.536381 91.765533 27.45694 91.775253 27.4161 
         92.007751 27.471939 92.11441 27.28583 92.015259 27.168051
         92.015533 27.08083 92.083313 27.02277 92.112183 26.920271
         92.069977 26.86194 91.997192 26.85194 91.915253 26.893881
         91.916924 26.85416 91.8358 26.863331 91.712479 26.799999 
         91.542191 26.80444 91.492188 26.87472 91.418854 26.873329
         91.371353 26.800831 91.307457 26.778049 90.682457 26.77417
         90.392197 26.903601 90.344131 26.894159 90.143044 26.75333
         89.98996 26.73583 89.841919 26.70138 89.618301 26.72694 
         89.636093 26.771111 89.360786 26.859989 89.22081 26.81472
         89.110237 26.829161 88.921631 26.98777 88.873016 26.95499
         88.867737 27.080549 88.843307 27.108601 88.750549 
         27.14727)@}
(%i5) boundaries_array[1143];
(%o5) @{Array:  
       #(91.659554 27.76511 91.666924 27.88888 91.65831 27.94805 
         91.338028 28.05249 91.314972 28.096661 91.108856 27.971109
         91.015808 27.97777 90.896927 28.05055 90.382462 28.07972
         90.396088 28.23555 90.366074 28.257771 89.996353 28.32333
         89.83165 28.24888 89.58609 28.139999 89.35997 27.87166 
         89.225517 27.795 89.125793 27.56749 88.971077 27.47361
         88.917877 27.321039)@}
(%i6) Bhutan_polygon: make_polygon([171,173,1143])$
(%i7) draw2d(Bhutan_polygon)$
@end example
@end deffn




@deffn  {Función} region_boundaries (@var{x1},@var{y1},@var{x2},@var{y2})
Detecta los segmentos poligonales almacenados en la variable global
@code{boundaries_array} totalmente contenidos en el rectángulo de vértices
(@var{x1},@var{y1}) -superior izquierdo- y (@var{x2},@var{y2})
-inferior derecho-.

Ejemplo:

Devuelve los números de los segmentos necesarios para
dibujar el sur de Italia.
@example
(%i1) load(worldmap)$
(%i2) region_boundaries(10.4,41.5,20.7,35.4);
(%o2)                [1846, 1863, 1864, 1881, 1888, 1894]
(%i3) draw2d(geomap(%))$
@end example
@end deffn




@deffn  {Función} region_boundaries_plus (@var{x1},@var{y1},@var{x2},@var{y2})
Detecta los segmentos poligonales almacenados en la variable global
@code{boundaries_array} con al menos un vértice dentro del rectángulo 
definido por los extremos (@var{x1},@var{y1}) -superior izquierdo- y (@var{x2},@var{y2})
-inferior derecho-.

Ejemplo:

@example
(%i1) load(worldmap)$
(%i2) region_boundaries_plus(10.4,41.5,20.7,35.4);
(%o2) [1060, 1062, 1076, 1835, 1839, 1844, 1846, 1858,
       1861, 1863, 1864, 1871, 1881, 1888, 1894, 1897]
(%i3) draw2d(geomap(%))$
@end example
@end deffn



@subsection Objetos gráficos




@deffn  {Objeto gráfico} geomap (@var{numlist})
@deffnx {Objeto gráfico} geomap (@var{numlist},@var{3Dprojection})
Dibuja mapas cartográficos en 2D y 3D.

@b{2D}

Esta función trabaja junto con la variable global @code{boundaries_array}.

El argumento @var{numlist} es una lista de números o de listas de 
números. Todos estos números deben ser enteros mayores o iguales que cero,
representando las componentes del array global @code{boundaries_array}.

Cada componente de @code{boundaries_array} es un array de decimales en
coma flotante, las coordenadas de un segmento poligonal o línea
fronteriza.

@code{geomap (@var{numlist})} toma los enteros de sus argumentos y 
dibuja los segmentos poligonales asociados de @code{boundaries_array}.

Este objeto se ve afectado por las siguientes @i{opciones gráficas}: @code{line_width}, 
@code{line_type} y @code{color}.

Ejemplos:

Un sencillo mapa hecho a mano:
@example
(%i1) load(worldmap)$
(%i2) /* Vertices of boundary #0: @{(1,1),(2,5),(4,3)@} */
   ( bnd0: make_array(flonum,6),
     bnd0[0]:1.0, bnd0[1]:1.0, bnd0[2]:2.0,
     bnd0[3]:5.0, bnd0[4]:4.0, bnd0[5]:3.0 )$
(%i3) /* Vertices of boundary #1: @{(4,3),(5,4),(6,4),(5,1)@} */
   ( bnd1: make_array(flonum,8),
     bnd1[0]:4.0, bnd1[1]:3.0, bnd1[2]:5.0, bnd1[3]:4.0,
     bnd1[4]:6.0, bnd1[5]:4.0, bnd1[6]:5.0, bnd1[7]:1.0)$
(%i4) /* Vertices of boundary #2: @{(5,1), (3,0), (1,1)@} */
   ( bnd2: make_array(flonum,6),
     bnd2[0]:5.0, bnd2[1]:1.0, bnd2[2]:3.0,
     bnd2[3]:0.0, bnd2[4]:1.0, bnd2[5]:1.0 )$
(%i5) /* Vertices of boundary #3: @{(1,1), (4,3)@} */
   ( bnd3: make_array(flonum,4),
     bnd3[0]:1.0, bnd3[1]:1.0, bnd3[2]:4.0, bnd3[3]:3.0)$
(%i6) /* Vertices of boundary #4: @{(4,3), (5,1)@} */
   ( bnd4: make_array(flonum,4),
     bnd4[0]:4.0, bnd4[1]:3.0, bnd4[2]:5.0, bnd4[3]:1.0)$
(%i7) /* Pack all together in boundaries_array */
   ( boundaries_array: make_array(any,5),
     boundaries_array[0]: bnd0, boundaries_array[1]: bnd1,
     boundaries_array[2]: bnd2, boundaries_array[3]: bnd3,
     boundaries_array[4]: bnd4 )$
(%i8) draw2d(geomap([0,1,2,3,4]))$
@end example

El paquete auxiliar @code{worldmap} asigna al array global
@code{boundaries_array} líneas fronterizas
reales en coordenadas (longitud, latitud). Estos datos son
de dominio público y proceden de
@url{http://www-cger.nies.go.jp/grid-e/gridtxt/grid19.html}.
El paquete @code{worldmap} también define fronteras 
de países, continentes y líneas
costeras a partir de las
componentes de @code{boundaries_array} (véase el
fichero @code{share/draw/worldmap.mac} para más
información). El paquete @code{worldmap} carga
automáticamente el paquete @code{draw}.
@example
(%i1) load(worldmap)$
(%i2) c1: gr2d(geomap([Canada,United_States,
                       Mexico,Cuba]))$
(%i3) c2: gr2d(geomap(Africa))$
(%i4) c3: gr2d(geomap([Oceania,China,Japan]))$
(%i5) c4: gr2d(geomap([France,Portugal,Spain,
                       Morocco,Western_Sahara]))$
(%i6) draw(columns  = 2,
           c1,c2,c3,c4)$
@end example

@code{worldmap} se puede utilizar para dibujar países
como polígonos. En este caso, ya no será necesario
hacer uso del objeto gráfico @code{geomap}, pero sí de
@code{polygon}. Puesto que en este caso se utilizan listas en lugar de
arrays, los mapas se reproducirán de forma más lenta. Véanse
también @code{make_poly_country} y @code{make_poly_continent} para
comprender el siguiente código.
@example
(%i1) load(worldmap)$
(%i2) mymap: append(
   [color      = white],  /* borders are white */
   [fill_color = red],             make_poly_country(Bolivia),
   [fill_color = cyan],            make_poly_country(Paraguay),
   [fill_color = green],           make_poly_country(Colombia),
   [fill_color = blue],            make_poly_country(Chile),
   [fill_color = "#23ab0f"],       make_poly_country(Brazil),
   [fill_color = goldenrod],       make_poly_country(Argentina),
   [fill_color = "midnight-blue"], make_poly_country(Uruguay))$
(%i3) apply(draw2d, mymap)$
@end example

@b{3D}

@code{geomap (@var{numlist})} proyecta los mapas sobre la esfera de radio 1
y centro (0,0,0). Es posible cambiar la esfera o el tipo de proyección haciendo
uso de @code{geomap (@var{numlist},@var{3Dprojection})}.

Proyecciones 3D disponibles:

@itemize @bullet
@item
@code{[spherical_projection,@var{x},@var{y},@var{z},@var{r}]}: proyecta los mapas sobre la esfera de radio
@var{r} y centro (@var{x},@var{y},@var{z}).
@example
(%i1) load(worldmap)$
(%i2) draw3d(geomap(Australia), /* default projection */
             geomap(Australia,
                    [spherical_projection,2,2,2,3]))$
@end example

@item
@code{[cylindrical_projection,@var{x},@var{y},@var{z},@var{r},@var{rc}]}: re-proyecta mapas esféricos
sobre el cilindro de radio @var{rc} cuyo eje pasa a través de los polos del globo
de radio @var{r} y centro (@var{x},@var{y},@var{z}).
@example
(%i1) load(worldmap)$
(%i2) draw3d(geomap([America_coastlines,Eurasia_coastlines],
                    [cylindrical_projection,2,2,2,3,4]))$
@end example

@item
@code{[conic_projection,@var{x},@var{y},@var{z},@var{r},@var{alpha}]}: re-proyecta mapas esféricos sobre los
conos de ángulo @var{alpha}, cuyos ejes pasan a través de los polos del globo de radio @var{r} 
y centro (@var{x},@var{y},@var{z}). Ambos conos, norte y sur, son tangentes a la esfera.
@example
(%i1) load(worldmap)$
(%i2) draw3d(geomap(World_coastlines,
                    [conic_projection,0,0,0,1,90]))$
@end example
@end itemize

En @url{http://riotorto.users.sf.net/gnuplot/geomap}
hay ejemplos más elaborados.
@end deffn

