spplot                  package:sp                  R Documentation

_P_l_o_t _m_e_t_h_o_d_s _f_o_r _s_p_a_t_i_a_l _d_a_t_a _w_i_t_h _a_t_t_r_i_b_u_t_e_s

_D_e_s_c_r_i_p_t_i_o_n:

     Lattice (trellis) plot methods for spatial data with attributes

_U_s_a_g_e:

     spplot(obj, ...)
     spplot.grid(obj, zcol = names(obj), ..., names.attr, 
             scales = list(draw = FALSE), xlab = NULL, ylab = NULL, aspect = mapasp(obj,xlim,ylim), 
             panel = panel.gridplot, sp.layout = NULL, formula, xlim = bbox(obj)[1, ], 
             ylim = bbox(obj)[2, ], checkEmptyRC = TRUE)
     spplot.polygons(obj, zcol = names(obj), ..., names.attr, 
             scales = list(draw = FALSE), xlab = NULL, ylab = NULL, aspect = mapasp(obj,xlim,ylim), 
             panel = panel.polygonsplot, sp.layout = NULL, formula, xlim = bbox(obj)[1, ], 
             ylim = bbox(obj)[2, ])
     spplot.points(obj, zcol = names(obj), ..., names.attr, 
             scales = list(draw = FALSE), xlab = NULL, ylab = NULL, aspect = mapasp(obj,xlim,ylim), 
             panel = panel.pointsplot, sp.layout = NULL, identify = FALSE, formula, 
             xlim = bbexpand(bbox(obj)[1, ], 0.04), ylim = bbexpand(bbox(obj)[2, ], 0.04))
     mapLegendGrob(obj, widths = unit(1, "cm"), heights = unit(1, "cm"),
             fill = "black", just = "right")
     sp.theme(set = FALSE, regions = list(col = bpy.colors(100)), ...)
     layout.north.arrow(type = 1)
     layout.scale.bar(height = 0.05)
     spplot.locator(n = 512, type = "n", ...)

_A_r_g_u_m_e_n_t_s:

     obj: object of class extending Spatial-class

    zcol: character; attribute name(s) or column number(s) in attribute
          table 

names.attr: names to use in panel, if different from zcol names 

  scales: scales argument to be passed to Lattice plots; use 'list(draw
          = TRUE)' to draw axes scales; see xyplot for full options 

     ...: other arguments passed to levelplot (grids, polygons) or 
          xyplot (points) 

    xlab: label for x-axis 

    ylab: label for y-axis 

  aspect: aspect ratio for spatial axes; defaults to "iso" (one unit on
          the x-axis equals one unit on the y-axis) but may be set to
          more suitable values if the data are e.g. if coordinates are
          latitude/longitude 

   panel: depending on the class of obj, panel.polygonsplot (for
          polygons or lines), panel.gridplot (grids) or
          panel.pointsplot (points) is used; for further control custom
          panel functions can be supplied that call one of these panel
          functions, but do read how the argument 'sp.layout' may help 

sp.layout: NULL or list; see notes below

identify: if not FALSE, identify plotted objects (currently only
          working for points plots). Labels for identification are the
          row.names of the attribute table
          'row.names(as.data.frame(obj))'. If TRUE, identify on panel
          '(1,1)'; for identifying on panel 'i,j', pass the value
          'c(i,j)'

 formula: optional; may be useful to plot a transformed value. Defaults
          to 'z~x+y' for single and 'z~x+y|name' for multiple
          attributes; use e.g. 'exp(x)~x+y|name' to plot the exponent
          of the z-variable

    xlim: numeric; x-axis limits 

    ylim: numeric; y-axis limits 

  widths: width of grob

 heights: heights of grob

    fill: fill color of grob

    just: grob placement justification

     set: logical; if TRUE, trellis.par.set is called, else a list is
          returned that can be passed to trellis.par.set() 

 regions: color ramp for the theme 

  height: height of scale bar; width is 1.0

       n: see locator

    type: see locator

checkEmptyRC: logical; if TRUE, a check is done to see if empty rows or
          columns are present, and need to be taken care of. Setting to
          FALSE may improve speed. 

_V_a_l_u_e:

     spplot returns a lattice plot of class "trellis", if you fail to
     "see" it, explicitly call 'print(spplot(...))'. If 'identify' is
     TRUE, the plot is plotted and the return value is a vector with
     row names of the selected points.

     'spplot.locator' returns a matrix with identified point locations;
     use 'trellis.focus' first to focus on a given panel.

_M_e_t_h_o_d_s:


     _o_b_j = "_S_p_a_t_i_a_l_P_i_x_e_l_s_D_a_t_a_F_r_a_m_e" see spplot 

     _o_b_j = "_S_p_a_t_i_a_l_G_r_i_d_D_a_t_a_F_r_a_m_e" see spplot 

     _o_b_j = "_S_p_a_t_i_a_l_P_o_l_y_g_o_n_s_D_a_t_a_F_r_a_m_e" see spplot 

     _o_b_j = "_S_p_a_t_i_a_l_L_i_n_e_s_D_a_t_a_F_r_a_m_e" see spplot 

     _o_b_j = "_S_p_a_t_i_a_l_P_o_i_n_t_s_D_a_t_a_F_r_a_m_e" see spplot 

_N_o_t_e:

     Missing values in the attributes are (currently) not allowed.

     'spplot.grid', 'spplot.polygons' and 'spplot.points' are S4
     methods for 'spplot'; see spplot-methods.

     Useful arguments that can be passed as '...' are: 

     '_l_a_y_o_u_t' for the layout of panels

     '_c_o_l._r_e_g_i_o_n_s' to specify fill colours; in case the variable to be
          plotted is a factor, this vector should have length equal to
          the number of factor levels; when plotting points it may also
          have length one, using symbol type to distinguish classes 

     '_p_r_e_t_t_y' for colour breaks at pretty numbers

     '_a_t' to specify at which values colours change

     '_a_s._t_a_b_l_e' to start drawing panels upper-left instead of
          lower-left

     '_p_a_g_e' to add marks to each plotted page

     for useful values see the appropriate documentation of xyplot and
     levelplot.

     If 'obj' is of SpatialPointsDataFrame, the following options are
     useful to pass:

     '_k_e_y._s_p_a_c_e' character: "bottom", "right", "left" or "right" to
          denote key location, or list: see argument key in the help
          for xyplot what the options are

     '_l_e_g_e_n_d_E_n_t_r_i_e_s' character; array with key legend (text) entries; 
          suitable defaults obtained from data 

     '_c_u_t_s' number of cuts or the actual cuts to use

     '_d_o._l_o_g' logical; if TRUE use log-linear scale to divide range in
          equal cuts, else use a linear scale if 'cuts' is only number
          of cuts 

     '_p_c_h' integer; plotting character to use; defaults to 16 if fill
          is TRUE, else 1 

     '_c_e_x' numeric; character expansion, proportional to default value
          of 1

     '_f_i_l_l' logical; use filled circles? 

     'layout.north.arrow' and 'layout.scale.bar' can be used to set a
     north arrow or scale bar.

     The 'sp.layout' argument is either a single layout item, or a list
     with a layout items. A layout item is a list with its first
     argument the name of the layout function to be called: 'sp.points'
     for SpatialPoints, 'sp.polygons' for SpatialPolygons object,
     'sp.lines' for a SpatialLines object, and 'sp.text' for text to
     place. The second argument contains the object (or text) to be
     plotted; remaining arguments are passed to the corresponding
     'panel.*' functions.

     A special layout list item is 'which' (integer), to control to
     which panel a layout item should be added. If 'which' is present
     in the main, top-level list it applies for all layout items; in
     sub-lists with layout items it denotes the (set of) panels in
     which the layout item should be drawn.  Without a 'which' item,
     layout items are drawn in each panel.

     The order of items in 'sp.layout' matters; objects are drawn in
     the order they appear. Plot order and prevalence of sp.layout
     items: for points and lines, sp.layout items are drawn before the
     points (to allow for grids and polygons); for grids and polygons
     sp.layout is drawn afterwards (so the item will not be overdrawn
     by the grid and/or polygon). Although a matter of taste,
     transparency may help when combining things.

     'sp.theme' returns a lattice theme; use
     'trellis.par.set(sp.theme())' after a device is opened or changed
     to make this work. Currently, this only sets the colors to
     bpy.colors.

     If the attributes to be plotted are of type factor, spplot tries
     to create a legend that reflects this. In this case, the color
     ramp passed needs to be of the same length as the number of factor
     levels. The factor levels are derived from the first map;
     subsequent factors with different factor levels result in an
     error.

_A_u_t_h_o_r(_s):

     Edzer J. Pebesma, edzer.pebesma@uni-muenster.de

_R_e_f_e_r_e_n_c_e_s:

     <URL: http://r-spatial.sourceforge.net/>

_S_e_e _A_l_s_o:

     xyplot, latticeplot

_E_x_a_m_p_l_e_s:

     library(lattice)
     trellis.par.set(sp.theme()) # sets bpy.colors() ramp
     data(meuse)
     coordinates(meuse) <- ~x+y
     l2 = list("SpatialPolygonsRescale", layout.north.arrow(), offset = c(181300,329800), 
             scale = 400)
     l3 = list("SpatialPolygonsRescale", layout.scale.bar(), offset = c(180500,329800), 
             scale = 500, fill=c("transparent","black"))
     l4 = list("sp.text", c(180500,329900), "0")
     l5 = list("sp.text", c(181000,329900), "500 m")

     spplot(meuse, c("ffreq"), sp.layout=list(l2,l3,l4,l5), col.regions= "black", 
             pch=c(1,2,3), key.space=list(x=0.1,y=.95,corner=c(0,1)))
     spplot(meuse, c("zinc", "lead"), sp.layout=list(l2,l3,l4,l5, which = 2),
             key.space=list(x=0.1,y=.95,corner=c(0,1)))
     # plotting factors:
     meuse$f = factor(sample(letters[6:10], 155, replace=TRUE),levels=letters[1:10])
     meuse$g = factor(sample(letters[1:5], 155, replace=TRUE),levels=letters[1:10])
     spplot(meuse, c("f","g"), col.regions=bpy.colors(10))

     if (require(RColorBrewer)) {
             spplot(meuse, c("ffreq"), sp.layout=list(l2,l3,l4,l5),
                     col.regions=brewer.pal(3, "Set1"))
     }

     data(meuse.grid)
     gridded(meuse.grid)=~x+y
     meuse.grid$g = factor(sample(letters[1:5], 3103, replace=TRUE),levels=letters[1:10])
     meuse.grid$f = factor(sample(letters[6:10], 3103, replace=TRUE),levels=letters[1:10])
     spplot(meuse.grid, c("f","g"))
     spplot(meuse.grid, c("f","g"), col.regions=bpy.colors(10))

