Package 'sp' reference manual

Title:	Classes and Methods for Spatial Data
Description:	Classes and methods for spatial data; the classes document where the spatial location information resides, for 2D or 3D data. Utility functions are provided, e.g. for plotting data as maps, spatial selection, as well as methods for retrieving coordinates, for subsetting, print, summary, etc. From this version, 'rgdal', 'maptools', and 'rgeos' are no longer used at all, see <https://r-spatial.org/r/2023/05/15/evolution4.html> for details.
Authors:	Edzer Pebesma [aut, cre], Roger Bivand [aut], Barry Rowlingson [ctb], Virgilio Gomez-Rubio [ctb], Robert Hijmans [ctb], Michael Sumner [ctb], Don MacQueen [ctb], Jim Lemon [ctb], Finn Lindgren [ctb], Josh O'Brien [ctb], Joseph O'Rourke [ctb], Patrick Hausmann [ctb]
Maintainer:	Edzer Pebesma <[email protected]>
License:	GPL (>= 2)
Version:	2.1-4
Built:	2024-05-07 11:24:42 UTC
Source:	https://github.com/edzer/sp

Class "CRS" of coordinate reference system arguments

Description

Interface class to the PROJ projection and transformation system. The class is defined as an empty stub accepting value NA in the sp package. The initiation function may call the PROJ library through sf to verify the argument set against those known in the library, returning error messages where necessary. If the "CRS" object is instantiated using CRS() with sf using PROJ >= 6 and GDAL >= 3, the object may also have a WKT2 (2019) string carried as a comment. The arguments for a Proj.4 string must be entered exactly as in the Proj.4 documentation, in particular there cannot be any white space in +<key>=<value> strings, and successive such strings can only be separated by blanks. Note that only “+proj=longlat +ellps=WGS84” is accepted for geographical coordinates, which must be ordered (eastings, northings); the “+ellps=” definition must be given (or expanded internally from a given “+datum=” value) for recent versions of the Proj.4 library, and should be set to an appropriate value.

Usage

CRS(projargs, doCheckCRSArgs=TRUE, SRS_string=NULL, get_source_if_boundcrs=TRUE,
 use_cache=TRUE)
identicalCRS(x,y)

Arguments

`projargs`	A character string of projection arguments; the arguments must be entered exactly as in the PROJ.4 documentation; if the projection is unknown, use `as.character(NA)`, it may be missing or an empty string of zero length and will then set to the missing value. With sf built with PROJ >= 6 and GDAL >= 3, the `+init=` key may only be used with value `epsg:<code>`. From sp version 1.4-4, the string associated with the SRS_string argument may be entered as-is and will be set as SRS_string if the projargs argument does not begin with a `+` (suggested by Mikko Vihtakari).
`doCheckCRSArgs`	default TRUE
`SRS_string`	default NULL, only used when sf is built with PROJ >= 6 and GDAL >= 3; a valid WKT string or SRS definition such as `"EPSG:4326"` or `"ESRI:102761"`
`get_source_if_boundcrs`	(from rgdal 1.5-17, default TRUE) The presence of the `+towgs84=` key in a Proj4 string `projargs=` argument value may promote the output WKT2 CRS to BOUNDCRS for PROJ >= 6 and GDAL >= 3, which is a coordinate operation from the input datum to WGS84. This is often unfortunate, so a PROJ function is called through rgdal to retrieve the underlying source definition.
`use_cache`	default TRUE, if FALSE ignore cached lookup values
`x`	object having a proj4string method, or if `y` is missing, list with objects that have a `proj4string` method
`y`	object of class Spatial, or having a proj4string method

Value

CRS returns on success an object of class CRS. identicalCRS returns a logical, indicating whether x and y have identical CRS, or if y is missing whether all objects in list x have identical CRS.

Objects from the Class

Objects can be created by calls of the form CRS("projargs"), where "projargs" is a valid string of PROJ.4 arguments. If the argument is a zero-length string or a character NA, the object records NA. If the "CRS" object is instantiated using CRS() with sf using PROJ >= 6 and GDAL >= 3, the object may also have a WKT2 (2019) string carried as a comment. The initiation function may call the PROJ library through sf to verify the argument set against those known in the library, returning error messages where necessary.

Slots

projargs:: Object of class "character": projection arguments; the arguments must be entered exactly as in the PROJ.4 documentation, in particular there cannot be any white space in +<arg>=<value> strings, and successive such strings can only be separated by blanks.

Methods

show: signature(object = "CRS"): print deprecated Proj.4 projection arguments and WKT2 2019 representation if available
wkt: signature(object = "CRS"): return WKT comment on object
rebuild_CRS: rebuild a CRS object, usually used to add a WKT comment with PROJ >= 6 and GDAL >= 3

Note

Lists of projections may be seen by using the programs installed with the PROJ.4 library, in particular proj and cs2cs; with the latter, -lp lists projections, -le ellipsoids, -lu units, and -ld datum(s) known to the installed software (available in sf using sf_proj_info). These are added to in successive releases, so tracking the website or compiling and installing the most recent revisions will give the greatest choice. Finding the very important datum transformation parameters to be given with the +towgs84 tag is a further challenge, and is essential when the datums used in data to be used together differ. Tracing projection arguments is easier now than before the mass ownership of GPS receivers raised the issue of matching coordinates from different argument sets (GPS output and paper map, for example). See GridsDatums, sf_proj_info for help in finding CRS definitions.

The 4.9.1 release of the PROJ library omitted a small file of defaults, leading to reports of “major axis or radius = 0 or not given” errors. From 0.9-3, rgdal checks for the presence of this file (proj_def.dat), and if not found, and under similar conditions to those used by PROJ.4, adds “+ellps=WGS84” to the input string being checked by checkCRSArgs The “+no_defs” tag ignores the file of defaults, and the default work-around implemented to get around this problem; strings including “init” and “datum” tags also trigger the avoidance of the work-around. Now messages are issued when a candidate CRS is checked; they may be suppressed using suppressMessages.

From release 6 of the PROJ library, when used in building sf with GDAL >= 3, the +datum= key in the Proj.4 string CRS representation is deprecated, and the +towgs84= and +nadgrids= keys may be deprecated soon. For this reason, sp and sf are starting to use WKT2 (2019) string representations. In sp, the "CRS" object in itself remains unchanged, but the content of its "projargs" slot may be degraded. To work around the degradation, a comment is added around the "CRS" object containing a WKT2 (2019) string when sf is available and built with PROJ >= 6 and GDAL >=3.

Author(s)

Roger Bivand [email protected]

References

https://github.com/OSGeo/PROJ

Examples

CRS()
CRS("")
CRS(as.character(NA))
CRS("+proj=longlat +datum=WGS84")
run <- FALSE
run <- require(sf) 
if (run) {
  print((CRS("+proj=longlat +datum=NAD27")))
}
if (run) {
  print((CRS("+init=epsg:4267")))
}
if (run) {
  print((CRS("+init=epsg:26978")))
}
if (run) {
  print((CRS(paste("+proj=sterea +lat_0=52.15616055555555",
 "+lon_0=5.38763888888889 +k=0.999908 +x_0=155000 +y_0=463000 +ellps=bessel",
 " +towgs84=565.237,50.0087,465.658,-0.406857,0.350733,-1.87035,4.0812 +units=m"))))
}
if (run) {
  print((CRS("+init=epsg:28992")))
}
if (run) {
  print((CRS("EPSG:28992")))
}
if (run) {
  print((CRS(SRS_string="EPSG:28992")))
}
if (run) {
  o <- try(CRS(SRS_string="ESRI:102760"))
  if (!inherits(o, "try-error")) print((o))
}
if (run) {
  o <- try(CRS("EPSG:4326"))
  if (!inherits(o, "try-error")) print((o))
}
if (run) {
  o <- try(CRS("ESRI:102760"))
  if (!inherits(o, "try-error")) print((o))
}
if (run) {
o <- new("Spatial")
proj4string(o) <- CRS("+init=epsg:27700")
}
if (run && !is.null(comment(slot(o, "proj4string")))) {
  cat(wkt(o), sep="\n")
  cat(wkt(slot(o, "proj4string")), sep="\n")
}

Plot methods for spatial data with attributes

Description

Lattice (trellis) plot methods for spatial data with attributes

Usage

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, col.regions = get_col_regions())
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, ], col.regions = get_col_regions())
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),
 edge.col = "transparent", colorkey = FALSE, col.regions = get_col_regions())
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", ...)
set_col_regions(value)
get_col_regions()

Arguments

`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 below 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
`edge.col`	color of symbol edge
`colorkey`	if FALSE, use symbol key; if TRUE, use continuous, levelplot-like colorkey; if list, follow syntax of argument `colorkey` in levelplot (see below for an example)
`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.
`col.regions`	vector with fill colours; in case the variable to be plotted is a factor, this vector should have length equal to the number of factor levels
`value`	vector with color values, default for `col.regions`

Value

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.

get_col_regions returns the default value for col.regions

Methods

obj = "SpatialPixelsDataFrame": see spplot
obj = "SpatialGridDataFrame": see spplot
obj = "SpatialPolygonsDataFrame": see spplot
obj = "SpatialLinesDataFrame": see spplot
obj = "SpatialPointsDataFrame": see spplot

Note

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:

layout: integer; for the layout of panels (cols,rows)
pretty: logical; choose colour breaks at pretty numbers?
at: specify at which values colours change
as.table: logical; start drawing panels upper-left instead of lower-left
page: to add marks to each plotted page

for useful values see the appropriate documentation of xyplot (in case of points), and levelplot (otherwise).

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

key.space: character: "bottom", "right", "left" or "right" to denote key location, or list: see argument key in the help for xyplot what the options are
legendEntries: character; array with key legend (text) entries; suitable defaults obtained from data
cuts: number of cuts, or, for objects of class SpatialPointsDataFrame only, the actual cuts to use
do.log: 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
pch: integer; plotting character to use; defaults to 16 if fill is TRUE, else 1
cex: numeric; character expansion, proportional to default value of 1
fill: 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 one or more layout items. A layout item is one of

a list with one or more Spatial* objects, along with style arguments like col, lty, pch, fill etc.
a list with its first argument the layout function or 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.

The order of items in sp.layout matters; objects are drawn in the order they appear. With respect to obj, default plot order and precedence of sp.layout items is as follows: for points and lines, sp.layout items are drawn over (after) obj; for grids and polygons, sp.layout items are drawn behind (before) obj. Transparency may further help making multiple things visible. Adding a first argument to a layout item overrides its default plotting order with respect to obj:

Special control elements of sp.layout items:

first: logical; should the layout item be drawn before the obj (TRUE), or after (FALSE)? This overrides the default order (points and lines in front, polygons and grids behind).
which: integer; controls to which panel a layout item should be added. If which is present in the main, top-level list it applies to all layout items; in sub-lists with layout items it denotes the (set of) panel(s) in which the layout item should be drawn. Without a which item, layout items are drawn in each panel.

sp.theme returns a lattice theme; use, after loading package lattice, the command 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.

Author(s)

Edzer Pebesma, [email protected]

References

https://edzer.github.io/sp/

Examples

library(lattice)
trellis.par.set(sp.theme()) # sets bpy.colors() ramp
demo(meuse, ask = FALSE, echo = FALSE)
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"))
}

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"), col.regions=bpy.colors(10))

# example modifying colorkey for points:
spplot(meuse["dist"], colorkey = list(
	right = list( # see ?levelplot in package trellis, argument colorkey:
		fun = draw.colorkey, 
		args = list(
			key = list(
				at = seq(0, 1, .1), # colour breaks
				col = bpy.colors(11), # colours
				labels = list(
					at = c(0, .2, .4, .6, .8, 1), 
					labels = c("0x", "20x", "40x", "60x", "80x", "100x")
				)
			)
		)
	)
))
l6 = list(meuse.grid["dist"], col = grey(seq(.5,.9,length.out=10)))
spplot(meuse, c("zinc", "lead"), sp.layout = l6)
spplot(meuse, c("zinc", "lead"), 
	sp.layout = list(meuse.grid, meuse.riv, col = 'grey'))

#  Custom legend placement, taken from 
# http://stackoverflow.com/questions/29344692/custom-placement-of-spplot-legend-in-the-map
s <- spplot(meuse.grid[,'dist'], colorkey = list(space = "left", height = 0.4))

args <- s$legend$left$args$key

## Prepare list of arguments needed by `legend=` argument (as described in ?xyplot)
library(lattice) # draw.colorkey
legendArgs <- list(fun = draw.colorkey,
                   args = list(key = args),
                   corner = c(0.05,.75))

## Call spplot() again, this time passing in to legend the arguments
## needed to print a color key
spplot(meuse.grid[,'dist'], colorkey = FALSE,
       legend = list(inside = legendArgs))

`x`	geometry (locations) of the queries
`y`	data.frame object with attributes
`match.ID`	logical; if TRUE, the IDs of the geometry and of the data.frame are matched (possibly swapping records), and an error occurs when some IDs do not match
`...`	(optional) arguments passed to the constructor functions

`x`	object deriving from Spatial, with attributes
`by`	aggregation predicate; if `by` is a Spatial object, the geometry by which attributes in `x` are aggregated; if `by` is a list, aggregation by attribute(s), see aggregate.data.frame
`FUN`	aggregation function, e.g. mean; see details
`...`	arguments passed on to function `FUN`, unless `minDimension` is specified, which is passed on to function over
`dissolve`	logical; should, when aggregating based on attributes, the resulting geometries be dissolved? Note that if `x` has class `SpatialPointsDataFrame`, this returns an object of class `SpatialMultiPointsDataFrame`; deprecated
`areaWeighted`	logical; should the aggregation of `x` be weighted by the areas it intersects with each feature of `by`? See value; deprecated.

`grd`	`GridTopology` object
`proj4string`	object of class CRS-class
`obj`	`SpatialPixels` object
`hex`	`SpatialPoints` object with points that are generated by hexagonal sampling; see spsample
`dx`	spacing of two horizontally adjacent points; if missing, this will be computed from the points

`Srl`	A list of Polygons objects
`proj4string`	Object of class `"CRS"`; holding a valid proj4 string

`n`	number of colors (>= 1) to be in the palette
`cutoff.tails`	tail fraction to be cut off on each side. If 0, this palette runs from black to white; by cutting off the tails, it runs from blue to yellow, which looks nicer.
`alpha`	numeric; alpha transparency, 0 is fully transparent, 1 is opaque.

`obj`	object of, or extending, class SpatialPointsDataFrame or SpatialGridDataFrame, see coordinates or SpatialPointsDataFrame; the object knows about its spatial coordinates
`zcol`	z-variable column name, or column number after removing spatial coordinates from x@data: 1 refers to the first non-coordinate column
`fill`	logical; if TRUE, filled circles are plotted (pch = 16), else open circles (pch = 1); the pch argument overrides this
`maxsize`	`cex` value for largest circle
`do.sqrt`	logical; if TRUE the plotting symbol area (sqrt(diameter)) is proportional to the value of the z-variable; if FALSE, the symbol size (diameter) is proportional to the z-variable
`pch`	plotting character
`col`	colours to be used; numeric vector of size two: first value is for negative values, second for positive values. Default colors: 5-class PiYG from colorbrewer.org.
`key.entries`	the values that will be plotted in the key; by default the five quantiles min, q.25, median q.75, max
`main`	main plotting title
`identify`	logical; if true, regular `plot` is called instead of `xyplot`, and followed by a call to `identify()`.
`labels`	labels argument passed to `plot` if `identify` is TRUE
`...`	arguments, passed to `xyplot`, or `plot` if identification is required.
`key.space`	location of the key
`scales`	scales argument as passed to xyplot
`xlab`	x-axis label
`ylab`	y-axis label
`panel`	panel function used
`sp.layout`	possible layout items; see spplot
`xlim`	x axis limit
`ylim`	y axis limit

`from`	character vector of degree, minute, decimal second data
`chd`	degree character terminator
`chm`	minute character terminator
`chs`	second character terminator
`dd`	numeric vector of decimal degrees
`NS`	logical, TRUE for north/south decimal degrees, FALSE for east/west decimal degrees

`x`, `y`	The position of the center of the compass rose in user units.
`rot`	Rotation for the compass rose in degrees. See Details.
`cex`	The character expansion to use in the display.

`obj`	object deriving from class "Spatial"
`object`	object of class "data.frame"
`value`	spatial coordinates; either a matrix, list, or data frame with numeric data, or column names, column number or a reference: a formula (in the form of e.g. `~x+y`), column numbers (e.g. `c(1,2)`) or column names (e.g. `c("x","y")`) specifying which columns in `object` are the spatial coordinates. If the coordinates are part of object, giving the reference does not duplicate them, giving their value does duplicate them in the resulting structure.
`...`	additional arguments that may be used by particular methods

`side`	integer; see axis
`at`	numeric; if missing, axTicks is called for nice values; see axis
`labels`	character; if omitted labels are constructed with degree symbols, ending in N/S/E/W; in case of negative degrees, sign is reversed and S or W is added; see axis
`...`	passed to the actual axis call

`x`	object of class SpatialLines or SpatialPolygons
`...`	ignored

`obj`	in case of assignment, a data.frame, else an object of class Spatial
`value`	object of class Spatial

`obj`	object deriving from class "Spatial" (for gridded), or object of class SpatialGridDataFrame-class (for fullgrid and gridparameters)
`value`	logical replacement values, TRUE or FALSE

`obj`	object of class SpatialGrid or SpatialPixels
`maxdist`	maximum distance to be considered (inclusive), expressed in number of grid cell (sqrt(2) results in queen neighbours)
`fullMat`	use dist to compute distances from grid (row/col) indices; FALSE avoids forming the full distance matrix, at a large performance cost
`...`	arguments passed on to dist

`x`	object deriving from class Spatial-class
`easts`	numeric; east-west values for vertical lines
`norths`	numeric; north-south values for horizontal lines
`ndiscr`	integer; number of points used to discretize the line, could be set to 2, unless the grid is (re)projected
`offset`	offset value to be returned, see text
`object`	SpatialLines-class object, as returned by `gridlines`
`labelCRS`	the CRS in which the grid lines were drawn and labels should be printed; if missing, the CRS from `object` is taken
`side`	for `labels`: integer, indicating side(s) at which gridlines labels will be drawn: 1=below (S), 2=left (W), 3=above (N), and 4=right (E); for `gridat`: default “WS”, if “EN” labels placed on the top and right borders
`...`	for `labels`: ignored; for `text`: arguments passed on to text, see below for example use of `adj`

`point.x`	numerical array of x-coordinates of points
`point.y`	numerical array of y-coordinates of points
`pol.x`	numerical array of x-coordinates of polygon
`pol.y`	numerical array of y-coordinates of polygon
`mode.checked`	default FALSE, used internally to save time when all the other argument are known to be of storage mode double

`SP`	a SpatialPolygonsDataFrame object
`file`	file where output is written
`new_format`	default TRUE, creates a text data file and a separate map file; the old format put both data sets in a single file - the map file is named by inserting "MAP_" into the file= argument after the rightmost directory separator (if any)

`x`, `from`, `obj`, `object`	`SpatialMultiPointsDataFrame` object
`to`	class to which to coerce
`strict`	see `as`
`i`	row indices
`j`	column indices
`drop`	see `Extract`
`...`	indices passed through

`x`	object of class SpatialGridDataFrame
`attr`	column of attribute variable; this may be the column name in the data.frame of `data` (as.data.frame(data)), or a column number
`xcol`	column number of x-coordinate, in the coordinate matrix
`ycol`	column number of y-coordinate, in the coordinate matrix
`col`	a vector of colors
`red`, `green`, `blue`	columns names or numbers given instead of the `attr` argument when the data represent an image encoded in three colour bands on the 0-255 integer scale; all three columns must be given in this case, and the attribute values will be constructed using function `rgb`
`axes`	logical; should coordinate axes be drawn?
`xlim`	x-axis limits
`ylim`	y-axis limits
`zlim`	data limits for plotting the (raster, attribute) values
`add`	logical; if FALSE, the image is added to the plot layout setup by `plot(as(x, "Spatial"),axes=axes,xlim=xlim,ylim=ylim,asp=asp)` which sets up axes and plotting region; if TRUE, the image is added to the existing plot.
`...`	arguments passed to image, see examples
`asp`	aspect ratio to be used for plot
`setParUsrBB`	default FALSE, see `Spatial-class` for further details
`useRasterImage`	if TRUE, use `rasterImage` to render the image if available; for legacy rendering set FALSE; should be FALSE on Windows SDI installations
`breaks`	class breaks for coloured values
`interpolate`	default FALSE, a logical vector (or scalar) indicating whether to apply linear interpolation to the image when drawing, see `rasterImage`
`angle`	default 0, angle of rotation (in degrees, anti-clockwise from positive x-axis, about the bottom-left corner), see `rasterImage`
`im`	list with components named x, y, and z, as used for `image`
`p4`	CRS object, proj4 string
`digits`	default 10, number of significant digits to use for checking equal row/column spacing

`coords`	2-column numeric matrix with coordinates for a single line
`slinelist`	list with elements of class Line-class
`ID`	a single word unique character identifier, character vector of length one

`data`	object of class or extending `Spatial`
`xlim`	the xlim argument passed (or derived from bounding box)
`ylim`	the ylim argument passed (or derived from bounding box)
`x`	numeric; values at which tics and marks will be generated

`x`	object deriving from Spatial
`y`	object of class `data.frame`, or any other class that can be coerced to a data.frame with `as.data.frame`
`by`, `by.x`, `by.y`	specifications of the common columns. See 'Details' in (base) `merge`.
`all.x`	logical; if TRUE, then the returned object will have all rows of x, even those that has no matching row in y. These rows will have NAs in those columns that are usually filled with values from y
`suffixes`	character(2) specifying the suffixes to be used for making non-by names() unique.
`incomparables`	values which cannot be matched. See `match`.
`duplicateGeoms`	logical; if `TRUE` geometries in `x` are duplicated if there are multiple matches between records in `x` and `y`
`...`	arguments to be passed to or from methods.

`x`	geometry (locations) of the queries
`y`	layer from which the geometries or attributes are queried
`returnList`	logical; see value
`fn`	(optional) a function; see value
`...`	arguments passed on to function `fn`, except for the special argument `minDimension`: minimal dimension for an intersection to be counted; -1 takes any intersection, and does not order; 0 takes any intersection but will order according to dimensionality of the intersections (if returnList is TRUE, 1 (2) selects intersections with dimension 1, meaning lines (2, meaning areas); see `vignette("over")` for details

`sp.layout`	list; see spplot for definition
`rows`	integer; panel row(s) for which the layout should be drawn
`cols`	integer; panel column(s) for which the layout should be drawn
`obj`	object of class SpatialPolygons-class for `SpatialPolygonsRescale`; of class SpatialLines-class, Lines-class or Line-class for `sp.lines` of a class that has a coordinates-methods for `sp.points`; of class SpatialPolygons-class for `sp.polygons`. When obj is character, the actual object is retrieved by `get(obj)` before its class is evaluated.
`offset`	offset for shifting a Polygons object
`scale`	scale for rescaling
`fill`	fill color
`col`	line color
`plot.grid`	logical; plot through grid functions (TRUE), or through traditional graphics functions (FALSE)
`pch`	plotting character
`at`	numeric; values at which colour breaks should occur
`col.regions`	colours to fill the grid cells, defaults to col
`loc`	numeric vector of two elements
`txt`	text to be plotted
`alpha`	alpha (transparency) level
`lst`	sp.layout argument, see spplot
`p.number`	panel number; in a panel, panel.number() should be passed to this argument
`x`	length two numeric vector, containing a range
`fraction`	fraction to expand the range by
`...`	arguments passed to the underlying panel, lattice or grid functions

`obj`	object of class "SpatialPolygons" or "SpatialPolygonsDataFrame"
`object`	object of class "data.frame"
`value`	object of class "SpatialPolygons"

`fname`	file name
`as.image`	logical; if FALSE, a list is returned, ready to be shown with the `image` command; if FALSE an object of class SpatialGridDataFrame-class is returned
`plot.image`	logical; if TRUE, an image of the map is plotted
`colname`	alternative name for data column if not file name
`proj4string`	A CRS object setting the projection arguments of the Spatial Grid returned
`x`	object of class SpatialGridDataFrame
`attr`	attribute column; if missing, the first column is taken; a name or a column number may be given
`na.value`	numeric; value given to missing valued cells in the resulting map
`...`	arguments passed to write.table, which is used to write the numeric data

`data`	data object of class, or extending `SpatialPoints`; this object knows about its x and y coordinate
`digitize`	logical; if TRUE, points in a digitized polygon are selected; if FALSE, points identified by mouse clicks are selected
`pch`	plotting character used for points
`rownames`	logical; if FALSE, row (coordinate) numbers are returned; if TRUE and data contains a data.frame part, row.names for selected points in the data.frame are returned.

`bbox`	a bounding box matrix
`proj4string`	a CRS object
`x`	object of class Spatial
`subset`	see subset.data.frame
`select`	see subset.data.frame
`drop`	see subset.data.frame
`...`	passed through

Package 'sp'

Help Index

constructs SpatialXxxDataFrame from geometry and attributes

Description

Usage

Arguments

Value

Methods

Author(s)

See Also

aggregation of spatial objects

Description

Usage

Arguments

Details

Value

Note

Author(s)

Examples

Make SpatialPolygons object from GridTopology object

Description

Usage

Arguments

Value

See Also

Examples

Making SpatialPolygons objects

Description

Usage

Arguments

Value

Author(s)

Examples

retrieve bbox from spatial data

Description

Usage

Arguments

Value

Methods

Examples

blue-pink-yellow color scheme, which also prints well on black/white printers

Description

Usage

Arguments

Value

Note

Author(s)

See Also

Examples

Create a bubble plot of spatial data

Description

Usage

Arguments

Value

Author(s)

See Also

Examples

Convert character vector to DMS-class object

Description

Usage

Arguments

Details

Value

Methods

Author(s)

See Also

Examples

Display a compass rose.

Description

Usage

Arguments

Details

Value

Author(s)

set spatial coordinates to create a Spatial object, or retrieve spatial coordinates from a Spatial object

Description

Usage

Arguments

Value

Examples

`LinesList`	list with objects of class Lines-class
`proj4string`	Object of class `"CRS"`; holding a valid proj4 string
`sl`, `SL`	object of class SpatialLines-class
`data`	object of class `data.frame`; the number of rows in `data` should equal the number of `Lines` elements in `sl`
`match.ID`	logical: (default TRUE): match SpatialLines member Lines ID slot values with data.frame row names, and re-order the data frame rows if necessary; if character: indicates the column in `data` with Lines IDs to match
`SLDF`	SpatialLinesDataFrame object
`Ls`	Object of class `Lines`
`cc`	Object of class `Line`, or two-column matrix with points
`longlat`	if FALSE, Euclidean distance, if TRUE Great Circle distance in kilometers
`sum`	logical; if `TRUE` return scalar length of sum of segments in Line, if `FALSE` return vector with segment lengths

`coords`	list with in each element a numeric matrix or data.frame with coordinates (each row representing a point); in case of SpatialMultiPointsDataFrame an object of class SpatialMultiPoints-class is also allowed
`proj4string`	projection string of class CRS-class
`bbox`	bounding box matrix, usually NULL and constructed from the data, but may be passed through for coercion purposes if clearly needed
`data`	object of class `data.frame`; the number of rows in `data` should equal the number of points in the `coords` object
`match.ID`	logical or character; if missing, and `coords` and `data` both have row names, and their order does not correspond, matching is done by these row names and a warning is issued; this warning can be suppressed by setting `match.ID` to TRUE. If TRUE AND coords has non-automatic rownames (i.e., coerced to a matrix by `as.matrix`, `dimnames(coords)[[1]]` is not `NULL`), AND `data` has row.names (i.e. is a data.frame), then the `SpatialMultiPointsDataFrame` object is formed by matching the row names of both components, leaving the order of the coordinates in tact. Checks are done to see whether both row names are sufficiently unique, and all data are matched. If FALSE, coordinates and data are simply "glued" together, ignoring row names. If character: indicates the column in `data` with coordinates IDs to use for matching records. See examples below.

`cellcentre.offset`	numeric; vector with the smallest centroid coordinates for each dimension; coordinates refer to the cell centre
`cellsize`	numeric; vector with the cell size in each dimension
`cells.dim`	integer; vector with number of cells in each dimension
`points`	coordinates, object of class SpatialPoints-class
`grid`	grid topology; object of class GridTopology-class; for calls to `SpatialPixels`, a value of NULL implies that this will be derived from the point coordinates
`tolerance`	precision, used to which extent points are exactly on a grid
`round`	default NULL, otherwise a value passed to as the digits argument to `round` for setting cell size
`proj4string`	object of class CRS-class
`obj`	object of class or deriving from SpatialGrid-class
`cc`	numeric matrix with coordinates
`all.inside`	logical; if TRUE and `cc` points fall outside the grid area, an error message is generated; if FALSE, NA values are generated for such points

`points`	coordinates, either as numeric matrix or as object of class SpatialPoints-class
`grid`	grid topology; object of class GridTopology-class; for calls to `SpatialPixelsDataFrame` a value of NULL implies that this will be derived from the point coordinates
`data`	data.frame; contains the attribute (actual grid) data
`tolerance`	precision up to which extent points should be exactly on a grid
`round`	default NULL, otherwise a value passed to as the digits argument to `round` for setting cell size
`proj4string`	object of class CRS-class in the first form only used when `points` does not inherit from Spatial-class

`coords`	numeric matrix or data.frame with coordinates (each row is a point); in case of SpatialPointsDataFrame an object of class SpatialPoints-class is also allowed
`proj4string`	projection string of class CRS-class
`bbox`	bounding box matrix, usually NULL and constructed from the data, but may be passed through for coercion purposes if clearly needed
`data`	object of class `data.frame`; the number of rows in `data` should equal the number of points in the `coords` object
`coords.nrs`	numeric; if present, records the column positions where in `data` the coordinates were taken from (used by coordinates<-)
`match.ID`	logical or character; if missing, and `coords` and `data` both have row names, and their order does not correspond, matching is done by these row names and a warning is issued; this warning can be suppressed by setting `match.ID` to TRUE. If TRUE AND coords has non-automatic rownames (i.e., coerced to a matrix by `as.matrix`, `dimnames(coords)[[1]]` is not `NULL`), AND `data` has row.names (i.e. is a data.frame), then the `SpatialPointsDataFrame` object is formed by matching the row names of both components, leaving the order of the coordinates in tact. Checks are done to see whether both row names are sufficiently unique, and all data are matched. If FALSE, coordinates and data are simply "glued" together, ignoring row names. If character: indicates the column in `data` with coordinates IDs to use for matching records. See examples below.

`x`, `from`, `obj`, `object`	`SpatialPointsDataFrame` object
`to`	class to which to coerce
`strict`	see `as`
`i`	row indices
`j`	column indices
`drop`	see `Extract`
`...`	indices passed through

`coords`	2-column numeric matrix with coordinates; first point (row) should equal last coordinates (row); if the hole argument is not given, the status of the polygon as a hole or an island will be taken from the ring direction, with clockwise meaning island, and counter-clockwise meaning hole
`hole`	logical value for setting polygon as hole or not; if the hole argument is not given, the status of the polygon as a hole or an island will be taken from the ring direction, with clockwise meaning island, and counter-clockwise meaning hole
`proj4string`	projection string of class CRS-class
`srl`	list with Polygon-class objects
`ID`	character vector of length one with identifier
`Srl`	list with objects of class Polygons-class
`pO`	integer vector; plotting order; if missing in reverse order of Polygons area
`Sr`	object of class SpatialPolygons-class
`data`	object of class `data.frame`; the number of rows in `data` should equal the number of Polygons-class objects in `Sr`
`match.ID`	logical: (default TRUE): match SpatialPolygons member Polygons ID slot values with data frame row names, and re-order the data frame rows if necessary. If character: indicates the column in `data` with Polygons IDs to match
`SP`	object of class SpatialPolygons-class

`pts`	A matrix of 2D points, first column x/longitude, second column y/latitude, or a SpatialPoints or SpatialPointsDataFrame object
`pt`	A single 2D point, first value x/longitude, second value y/latitude, or a SpatialPoints or SpatialPointsDataFrame object with one point only
`x`	A matrix of n-D points with row denoting points, first column x/longitude, second column y/latitude, or a Spatial object that has a coordinates method
`y`	A matrix of n-D points with row denoting points, first column x/longitude, second column y/latitude, or a Spatial object that has a coordinates method
`longlat`	logical; if FALSE, Euclidean distance, if TRUE Great Circle (WGS84 ellipsoid) distance; if `x` is a Spatial object, longlat should not be specified but will be derived from is.projected`(x)`
`segments`	logical; if `TRUE`, `y` must be missing; the vector of distances between consecutive points in `x` is returned.
`diagonal`	logical; if `TRUE`, `y` must be given and have the same number of points as `x`; the vector with distances between points with identical index is returned.

`x`	Spatial object; `spsample(x,...)` is a generic method for the existing `sample.Xxx` functions
`...`	optional arguments, passed to the appropriate `sample.Xxx` functions; see NOTES for `nclusters` and `iter`
`n`	(approximate) sample size
`type`	character; `"random"` for completely spatial random; `"regular"` for regular (systematically aligned) sampling; `"stratified"` for stratified random (one single random location in each "cell"); `"nonaligned"` for nonaligned systematic sampling (nx random y coordinates, ny random x coordinates); `"hexagonal"` for sampling on a hexagonal lattice; `"clustered"` for clustered sampling; `"Fibonacci"` for Fibonacci sampling on the sphere (see references).
`bb`	bounding box of the sampled domain; setting this to a smaller value leads to sub-region sampling
`offset`	for square cell-based sampling types (regular, stratified, nonaligned, hexagonal): the offset (position) of the regular grid; the default for `spsample` methods is a random location in the unit cell [0,1] x [0,1], leading to a different grid after each call; if this is set to `c(0.5,0.5)`, the returned grid is not random (but, in Ripley's wording, "centric systematic"). For line objects, a single offset value is taken, where the value varies within the [0, 1] interval, and 0 is the beginning of each Line object, and 1 its end
`cellsize`	if missing, a cell size is derived from the sample size `n`; otherwise, this cell size is used for all sampling methods except `"random"`
`nsig`	for "pretty" cell size; `spsample` does not result in pretty grids
`pretty`	logical; if `TRUE`, choose pretty (rounded) coordinates

`x`	object to be transformed
`CRSobj`	object of class CRS, or of class `character` in which case it is converted to CRS
`...`	further arguments (ignored)