llines                package:lattice                R Documentation

_R_e_p_l_a_c_e_m_e_n_t_s _o_f _t_r_a_d_i_t_i_o_n_a_l _g_r_a_p_h_i_c_s _f_u_n_c_t_i_o_n_s

_D_e_s_c_r_i_p_t_i_o_n:

     These functions are intended to replace common low level
     traditional graphics functions, primarily for use in panel
     functions.  The originals can not be used (at least not easily)
     because lattice panel functions need to use grid graphics.  Low
     level drawing functions in grid can be used directly as well, and
     is often more flexible.  These functions are provided for
     convenience and portability.

_U_s_a_g_e:

     lplot.xy(xy, type, pch, lty, col, cex, lwd,
              font, fontfamily, fontface,
              col.line, alpha, fill,
              origin = 0, ...)

     llines(x, ...)
     lpoints(x, ...)
     ltext(x, ...)

     ## Default S3 method:
     llines(x, y = NULL, type = "l",
            col, alpha, lty, lwd, ...)
     ## Default S3 method:
     lpoints(x, y = NULL, type = "p", col, pch, alpha, fill,
             font, fontfamily, fontface, cex, ...)  
     ## Default S3 method:
     ltext(x, y = NULL, labels = seq_along(x),
           col, alpha, cex, srt = 0,
           lineheight, font, fontfamily, fontface,
           adj = c(0.5, 0.5), pos = NULL, offset = 0.5, ...)  

     lsegments(x0, y0, x1, y1, x2, y2,
               col, alpha, lty, lwd, ...)
     lrect(xleft, ybottom, xright, ytop,
           x = (xleft + xright) / 2,
           y = (ybottom + ytop) / 2,
           width = xright - xleft,
           height = ytop - ybottom,
           col = "transparent",
           border = "black",
           lty = 1, lwd = 1, alpha = 1,
           just = "center",
           hjust = NULL, vjust = NULL,
           ...)
     larrows(x0 = NULL, y0 = NULL, x1, y1, x2 = NULL, y2 = NULL,
             angle = 30, code = 2, length = 0.25, unit = "inches",
             ends = switch(code, "first", "last", "both"),
             type = "open",
             col = add.line$col,
             alpha = add.line$alpha,
             lty = add.line$lty,
             lwd = add.line$lwd,
             fill = NULL, ...)
     lpolygon(x, y = NULL,
              border = "black", col = "transparent",
              font, fontface, ...)

     panel.lines(...)
     panel.points(...)
     panel.segments(...)
     panel.text(...)
     panel.rect(...)
     panel.arrows(...)
     panel.polygon(...)

_A_r_g_u_m_e_n_t_s:

 x, y, x0, y0, x1, y1, x2, y2, xy: locations. 'x2' and 'y2' are
          available for for S compatibility.  

length, unit: determines extent of arrow head.  'length' specifies the
          length in terms of 'unit', which can be any valid grid unit
          as long as it doesn't need a 'data' argument.  'unit'
          defaults to inches, which is the only option in the base
          version of the function, 'arrows'.  

angle, code, type, labels, srt, adj, pos, offset: arguments controlling
          behaviour.  See respective base functions for details. For
          'larrows' and 'panel.larrows', 'type' is either '"open"' or
          '"closed"', indicating the type of arrowhead. 

    ends: serves the same function as 'code', using descriptive names
          rather than integer codes.  If specified, this overrides
          'code'

col, alpha, lty, lwd, fill, pch, cex, lineheight, font,
fontfamily, fontface, col.line, border: 
          graphical parameters. 'fill' applies to points when 'pch' is
          in '21:25' and specifies the fill color, similar to the 'bg'
          argument in the base graphics function 'points'. For devices
          that support alpha-transparency, a numeric argument 'alpha'
          between 0 and 1 can controls transparency.  Be careful with
          this, since for devices that do not support
          alpha-transparency, nothing will be drawn at all if this is
          set to anything other than 0.  'font' and 'fontface' are
          included in 'lpolygon' only to ensure that they are not
          passed down (as 'gpar' doesn't like them). 

  origin: for 'type="h"' or 'type="H"', the value to which lines drop
          down. 

xleft, ybottom, xright, ytop: see 'rect'

width, height, just, hjust, vjust: finer control over rectangles, see
          'grid.rect' 

     ...: extra arguments, passed on to lower level functions as
          appropriate.  

_D_e_t_a_i_l_s:

     These functions are meant to be grid replacements of the
     corresponding base R graphics functions, to allow existing Trellis
     code to be used with minimal modification.  The functions
     'panel.*' are essentally identical to the 'l*' versions, are
     recommended for use in new code (as opposed to ported code) as
     they have more readable names.

     See the documentation of the base functions for usage. Not all
     arguments are always supported. All these correspond to the
     default methods only.

_N_o_t_e:

     There is a new 'type="H"' option wherever appropriate, which is
     similar to 'type="h"', but with horizontal lines.

_A_u_t_h_o_r(_s):

     Deepayan Sarkar Deepayan.Sarkar@R-project.org

_S_e_e _A_l_s_o:

     'points', 'lines', 'rect', 'text', 'segments', 'arrows', 'Lattice'

