Package 'sp'

Description

constructs SpatialXxxDataFrame from geometry and attributes

Usage

addAttrToGeom(x, y, match.ID, ...)

Arguments

Value

an object of class XxxDataFrame, where Xxx is the class of x

Methods

x = "SpatialPoints", y = "data.frame"

x = "SpatialPixels", y = "data.frame"

x = "SpatialGrid", y = "data.frame"

x = "SpatialLines", y = "data.frame"

x = "SpatialPolygons", y = "data.frame"

Author(s)

Edzer Pebesma, [email protected]

See Also

over

Description

spatial aggregation of thematic information in spatial objects

Usage

## S3 method for class 'Spatial'
aggregate(x, by = list(ID = rep(1, length(x))),
	FUN, ..., dissolve = TRUE, areaWeighted = FALSE)

Arguments

Details

For as far as these functions use package rgeos, (lines, polygons, dissolve = TRUE), they are deprecated as rgeos will retire; try using sf::aggregate instead.

FUN should be a function that takes as first argument a vector, and that returns a single number. The canonical examples are mean and sum. Counting features is obtained when summing an attribute variable that has the value 1 everywhere.

Value

The aggregation of attribute values of x either over the geometry of by by using over for spatial matching, or by attribute values, using aggregation function FUN.

If areaWeighted is TRUE, FUN is ignored and the area weighted mean is computed for numerical variables, or if all attributes are factors, the area dominant factor level (area mode) is returned. This computes the intersection of x and by; see examples below. As this uses code from package rgeos, it is deprecated as package rgeos will retire.

If by is missing, aggregates over all features.

Note

uses over to find spatial match if by is a Spatial object

Author(s)

Edzer Pebesma, [email protected]

Examples

data("meuse")
coordinates(meuse) <- ~x+y
data("meuse.grid")
coordinates(meuse.grid) <- ~x+y
gridded(meuse.grid) <- TRUE
i = cut(meuse.grid$dist, c(0,.25,.5,.75,1), include.lowest = TRUE)
j = sample(1:2, 3103,replace=TRUE)

x = aggregate(meuse.grid["dist"], list(i=i,j=j), mean, dissolve = FALSE)
spplot(x["j"], col.regions=bpy.colors())

Description

Converts grids of regular rectangles into a SpatialPolygons object, which can be transformed to a different projection or datum with spTransform in package rgdal. The function is not suitable for high-resolution grids. The ordering of the grid cells is as in coordinates() of the same object, and is reported by IDvaluesGridTopology.

Usage

as.SpatialPolygons.GridTopology(grd, proj4string = CRS(as.character(NA)))
IDvaluesGridTopology(obj)
as.SpatialPolygons.SpatialPixels(obj)
IDvaluesSpatialPixels(obj)
HexPoints2SpatialPolygons(hex, dx)

Arguments

Value

as.SpatialPolygons.GridTopology and as.SpatialPolygons.SpatialPixels return a SpatialPolygons object; IDvaluesGridTopology and IDvaluesSpatialPixels return a character vector with the object grid indices.

See Also

GridTopology, SpatialPixels, SpatialPolygons spTransform in package rgdal

Examples

library(lattice)
grd <- GridTopology(cellcentre.offset=c(-175,55), cellsize=c(10,10), cells.dim=c(4,4))
SpP_grd <- as.SpatialPolygons.GridTopology(grd)
plot(SpP_grd)
text(coordinates(SpP_grd), sapply(slot(SpP_grd, "polygons"), function(i) slot(i, "ID")), cex=0.5)
trdata <- data.frame(A=rep(c(1,2,3,4), 4), B=rep(c(1,2,3,4), each=4),
 row.names=sapply(slot(SpP_grd, "polygons"), function(i) slot(i, "ID")))
SpPDF <- SpatialPolygonsDataFrame(SpP_grd, trdata)
spplot(SpPDF)

data(meuse.grid)
gridded(meuse.grid)=~x+y
xx = spsample(meuse.grid,  type="hexagonal", cellsize=200)
xxpl = HexPoints2SpatialPolygons(xx)
image(meuse.grid["dist"])
plot(xxpl, add = TRUE)
points(xx, cex = .5)
## Not run: 
spplot(aggregate(as(meuse.grid[,1:3], "SpatialPolygonsDataFrame"), xxpl,
 areaWeighted=TRUE), main = "aggregated meuse.grid")

## End(Not run)

Description

This function is used in making SpatialPolygons objects from other formats.

Usage

as.SpatialPolygons.PolygonsList(Srl, proj4string=CRS(as.character(NA)))

Arguments

Value

The functions return a SpatialPolygons object

Author(s)

Roger Bivand

Examples

grd <- GridTopology(c(1,1), c(1,1), c(10,10))
polys <- as.SpatialPolygons.GridTopology(grd)
plot(polys)
text(coordinates(polys), labels=sapply(slot(polys, "polygons"), function(i) slot(i, "ID")), cex=0.6)

Description

retrieves spatial bounding box from spatial data

Usage

bbox(obj)

Arguments

Value

two-column matrix; the first column has the minimum, the second the maximum values; rows represent the spatial dimensions

Methods

obj = "Spatial"

object deriving from class "Spatial"

obj = "ANY"

an array with at least two columns

obj = "Line"

object deriving from class "Line"

obj = "Lines"

object deriving from class "Lines"

obj = "Polygon"

object deriving from class "Polygon"

obj = "Polygons"

object deriving from class "Polygons"

Examples

# just 9 points on a grid:
x <- c(1,1,1,2,2,2,3,3,3)
y <- c(1,2,3,1,2,3,1,2,3)
xy <- cbind(x,y)
S <- SpatialPoints(xy)
bbox(S)

# data.frame
data(meuse.grid)
coordinates(meuse.grid) <- ~x+y
gridded(meuse.grid) <- TRUE
bbox(meuse.grid)

Description

Create a vector of ‘n’ “contiguous” colors.

Usage

bpy.colors(n = 100, cutoff.tails = 0.1, alpha = 1.0)

Arguments

Value

A character vector, ‘cv’, of color names. This can be used either to create a user-defined color palette for subsequent graphics by ‘palette(cv)’, a ‘col=’ specification in graphics functions or in ‘par’.

Note

This color map prints well on black-and-white printers.

Author(s)

unknown; the pallette was posted to gnuplot-info a few decades ago; R implementation Edzer Pebesma, [email protected]

See Also

rainbow, cm.colors

Examples

bpy.colors(10)
p <- expand.grid(x=1:30,y=1:30)
p$z <- p$x + p$y
coordinates(p) <- c("x", "y")
gridded(p) <- TRUE
image(p, col = bpy.colors(100), asp = 1)
# require(lattice)
# trellis.par.set("regions", list(col=bpy.colors())) # make this default pallette

Description

Create a bubble plot of spatial data, with options for bicolour residual plots (xyplot wrapper)

Usage

bubble(obj, zcol = 1, ..., fill = TRUE, maxsize = 3, do.sqrt = TRUE, pch, 
	col = c("#d01c8b", "#4dac26"), key.entries = quantile(data[,zcol]), main, 
	identify = FALSE, labels = row.names(data.frame(obj)), key.space = "right",
	scales = list(draw = FALSE), xlab = NULL, ylab = NULL, panel = panel.bubble,
	sp.layout = NULL, 
	xlim = bbexpand(bbox(obj)[1,], 0.04), 
	ylim = bbexpand(bbox(obj)[2,], 0.04))

Arguments

Value

returns (or plots) the bubble plot; if identify is TRUE, returns the indexes (row numbers) of identified points.

Author(s)

Edzer Pebesma

See Also

xyplot, mapasp, identify

Examples

data(meuse)
coordinates(meuse) <- c("x", "y") # promote to SpatialPointsDataFrame
bubble(meuse, "cadmium", maxsize = 2.5, main = "cadmium concentrations (ppm)", 
    key.entries = 2^(-1:4))
bubble(meuse, "zinc", main = "zinc concentrations (ppm)",
    key.entries =  100 * 2^(0:4))

Description

These two helper functions convert character vectors and decimal degree vectors to the DMS-class representation of degrees, minutes, and decimal seconds. "DMS" objects cannot contain NAs.

Usage

char2dms(from, chd = "d", chm = "'", chs = "\"")
dd2dms(dd, NS = FALSE)

Arguments

Details

In char2dms, the input data vector should use a regular format, such as that used in the PROJ.4 library, with a trailing capital (NSWE) indicating compass direction.

Value

Both functions return a "DMS" object.

Methods

from = "DMS", to = "numeric"

coerce a "DMS" object to a "numeric" vector

from = "DMS", to = "character"

coerce a "DMS" object to a "character" vector (the as.character.DMS S3 method is also available)

Author(s)

Roger Bivand [email protected]

See Also

DMS-class

Examples

data(state)
str(state.center$y)
stateN <- dd2dms(state.center$y, NS=TRUE)
str(attributes(stateN))
ch.stateN <- as.character(stateN)
str(ch.stateN)
stateNa <- char2dms(ch.stateN)
str(attributes(stateNa))
ch.stateN <- as(stateN, "character")
str(ch.stateN)
stateNa <- char2dms(ch.stateN)
str(attributes(stateNa))

Description

Displays a basic compass rose, usually to orient a map.

Usage

compassRose(x,y,rot=0,cex=1)

Arguments

Details

‘⁠compassRose⁠’ displays a conventional compass rose at the position requested. The size of the compass rose is determined by the character expansion, as the central "rose" is calculated relative to the character size. Rotation is in degrees counterclockwise.

Value

nil

Author(s)

Jim Lemon

Description

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

Usage

coordinates(obj, ...)
	coordinates(object) <- value

Arguments

Value

usually an object of class SpatialPointsDataFrame; if the coordinates set cover the full set of variables in object, an object of class SpatialPoints is returned

Examples

# data.frame
data(meuse.grid)
coordinates(meuse.grid) <- ~x+y
gridded(meuse.grid) <- TRUE
class(meuse.grid)
bbox(meuse.grid)

data(meuse)
meuse.xy = meuse[c("x", "y")]
coordinates(meuse.xy) <- ~x+y
class(meuse.xy)

Description

retrieve (or set) spatial coordinates from (for) spatial data

Methods

obj = "list"

list with (at least) two numeric components of equal length

obj = "data.frame"

data.frame with at least two numeric components

obj = "matrix"

numeric matrix with at least two columns

obj = "SpatialPoints"

object of, or deriving from, SpatialPoints

obj = "SpatialPointsDataFrame"

object of, or deriving from, SpatialPointsDataFrame

obj = "SpatialPolygons"

object of, or deriving from, SpatialPolygons

obj = "SpatialPolygonsDataFrame"

object of, or deriving from, SpatialPolygonsDataFrame

obj = "Line"

object of class Line; returned value is matrix

obj = "Lines"

object of class Lines; returned value is list of matrices

obj = "SpatialLines"

object of, or deriving from, SpatialLines; returned value is list of lists of matrices

obj = "GridTopology"

object of, or deriving from, GridTopology

obj = "GridTopology"

object of, or deriving from, GridTopology

obj = "SpatialPixels"

object of, or deriving from, SpatialPixels

obj = "SpatialPixelsDataFrame"

object of, or deriving from, SpatialPixelsDataFrame

obj = "SpatialGrid"

object of, or deriving from, SpatialGrid

obj = "SpatialGridDataFrame"

object of, or deriving from, SpatialGridDataFrame

Methods for "coordinates<-"

object = "data.frame", value="ANY"

promote data.frame to object of class SpatialPointsDataFrame-class, by specifying coordinates; see coordinates

Description

retrieve or assign coordinate names for classes in sp

Methods for coordnames

x = "SpatialPoints"

retrieves coordinate names

x = "SpatialLines"

retrieves coordinate names

x = "Lines"

retrieves coordinate names

x = "Line"

retrieves coordinate names

x = "SpatialPolygons"

retrieves coordinate names

x = "Polygons"

retrieves coordinate names

x = "Polygon"

retrieves coordinate names

Methods for "coordnames<-"

x = "SpatialPoints", value = "character"

replace coordinate names

x = "SpatialLines", value = "character"

replace coordinate names

x = "Lines", value = "character"

replace coordinate names

x = "Line", value = "character"

replace coordinate names

x = "SpatialPolygons", value = "character"

replace coordinate names

x = "GridTopology", value = "character"

replace coordinate names

x = "SpatialGrid", value = "character"

replace coordinate names

x = "SpatialPixels", value = "character"

replace coordinate names

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

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")
}

Description

draw axes on a plot using degree symbols in numbers

Usage

degAxis(side, at, labels, ...)

Arguments

Value

axis is plotted on current graph

Note

decimal degrees are used if variation is small, instead of minutes and seconds

Examples

xy = cbind(x = 2 * runif(100) - 1, y = 2 * runif(100) - 1)
plot(SpatialPoints(xy, proj4string = CRS("+proj=longlat +ellps=WGS84")),xlim=c(-1,1),ylim=c(-1,1))
degAxis(1)
degAxis(2, at = c(-1,-0.5,0,0.5,1))
#

Description

retrieves spatial dimensions box from spatial data

Usage

dimensions(obj)

Arguments

Value

two-column matrix; the first column has the minimum, the second the maximum values; rows represent the spatial dimensions

Methods

obj = "Spatial"

object deriving from class "Spatial"

Examples

# just 9 points on a grid:
x <- c(1,1,1,2,2,2,3,3,3)
y <- c(1,2,3,1,2,3,1,2,3)
xy <- cbind(x,y)
S <- SpatialPoints(xy)
dimensions(S)

# data.frame
data(meuse.grid)
coordinates(meuse.grid) <- ~x+y
gridded(meuse.grid) <- TRUE
dimensions(meuse.grid)

Description

disaggregate SpatialLines, SpatialLinesDataFrame, SpatialPolygons, or SpatialPolygonsDataFrame objects, using functions from rgeos to handle polygon hole nesting

Usage

disaggregate(x, ...)

Arguments

Value

object of class SpatialLines or SpatialPolygons, where groups of Line or Polygon are disaggregated to one Line per Lines, or one Polygon per Polygons, respectively.

Author(s)

Robert Hijmans, Edzer Pebesma

Description

The class provides a container for coordinates stored as degree, minute, decimal second values.

Objects from the Class

Objects can be created by calls of the form new("DMS", ...), converted from decimal degrees using dd2dms(), or converted from character strings using char2dms().

Slots

WS:

Object of class "logical" TRUE if input value negative

deg:

Object of class "numeric" degrees

min:

Object of class "numeric" minutes

sec:

Object of class "numeric" decimal seconds

NS:

Object of class "logical" TRUE if input value is a Northing

Methods

coerce

signature(from = "DMS", to = "numeric"): convert to decimal degrees

show

signature(object = "DMS"): print data values

Author(s)

Roger Bivand [email protected]

See Also

char2dms, dd2dms

Examples

data(state)
dd2dms(state.center$x)
dd2dms(state.center$y, NS=TRUE)
as.numeric(dd2dms(state.center$y))
as(dd2dms(state.center$y, NS=TRUE), "numeric")
as.numeric.DMS(dd2dms(state.center$y))
state.center$y

Description

Methods for function elide to translate and disguise coordinate placing in the real world.

Usage

elide(obj, ...)

Arguments

Value

The methods return objects of the input class object with elided coordinates; the coordinate reference system is not set. Note that if the input coordinates or centroids are in the data slot data.frame of the input object, they should be removed before the use of these methods, otherwise they will betray the input positions.

Methods

obj = "SpatialPoints"

elides object

obj = "SpatialPointsDataFrame"

elides object

obj = "SpatialLines"

elides object

obj = "SpatialLinesDataFrame"

elides object

obj = "SpatialPolygons"

elides object

obj = "SpatialPolygonsDataFrame"

elides object

Note

Rotation code kindly contributed by Don MacQueen

Examples

data(meuse)
coordinates(meuse) <- c("x", "y")
proj4string(meuse) <- CRS("+init=epsg:28992")
data(meuse.riv)
river_polygon <- Polygons(list(Polygon(meuse.riv)), ID="meuse")
rivers <- SpatialPolygons(list(river_polygon))
proj4string(rivers) <- CRS("+init=epsg:28992")
rivers1 <- elide(rivers, reflect=c(TRUE, TRUE), scale=TRUE)
meuse1 <- elide(meuse, bb=bbox(rivers), reflect=c(TRUE, TRUE), scale=TRUE)
opar <- par(mfrow=c(1,2))
plot(rivers, axes=TRUE)
plot(meuse, add=TRUE)
plot(rivers1, axes=TRUE)
plot(meuse1, add=TRUE)
par(opar)
meuse1 <- elide(meuse, shift=c(10000, -10000))
bbox(meuse)
bbox(meuse1)
rivers1 <- elide(rivers, shift=c(10000, -10000))
bbox(rivers)
bbox(rivers1)
meuse1 <- elide(meuse, rotate=-30, center=apply(bbox(meuse), 1, mean))
bbox(meuse)
bbox(meuse1)
plot(meuse1, axes=TRUE)

Description

rearrange SpatialPointsDataFrame for plotting with spplot or levelplot

Usage

flipHorizontal(x)
flipVertical(x)

Arguments

Value

object of class SpatialGridDataFrame, with pixels flipped horizontally or vertically. Note that the spatial structure is destroyed (or at least: drastically changed).

Author(s)

Michael Sumner

Examples

data(meuse.grid) # data frame
gridded(meuse.grid) = c("x", "y") # promotes to 
fullgrid(meuse.grid) = TRUE
d = meuse.grid["dist"]
image(d, axes=TRUE)
image(flipHorizontal(d), axes=TRUE)
image(flipVertical(d), axes=TRUE)

Description

geometry retrieves the SpatialXxx object from a SpatialXxxDataFrame object, with Xxx Lines, Points, Polygons, Grid, or Pixels. geometry<- converts a data.frame into a Spatial object.

Usage

geometry(obj) 
geometry(obj) <- value

Arguments

Methods

obj = "Spatial"

obj = "SpatialPointsDataFrame"

obj = "SpatialMultiPointsDataFrame"

obj = "SpatialPolygonsDataFrame"

obj = "SpatialPixelsDataFrame"

obj = "SpatialGridDataFrame"

obj = "SpatialLinesDataFrame"

Author(s)

Edzer Pebesma, [email protected]

Examples

data(meuse)
m = meuse
coordinates(m) = meuse[, c("x", "y")]
pts = geometry(m)
class(pts)
geometry(meuse) = pts
class(meuse)
identical(m, meuse) # TRUE

Description

returns logical (TRUE or FALSE) telling whether the object is gridded or not; in assignment promotes a non-gridded structure to a gridded one, or demotes a gridded structure back to a non-structured one.

Usage

gridded(obj)
	gridded(obj) <- value
	fullgrid(obj)
	fullgrid(obj) <- value
	gridparameters(obj)

Arguments

Value

if obj derives from class Spatial, gridded(object) will tell whether it is has topology on a regular grid; if assigned TRUE, if the object derives from SpatialPoints and has gridded topology, grid topology will be added to object, and the class of the object will be promoted to SpatialGrid-class or SpatialGridDataFrame-class

fullgrid returns a logical, telling whether the grid is full and ordered (i.e., in full matrix form), or whether it is not full or unordered (i.e. a list of points that happen to lie on a grid. If assigned, the way the points are stored may be changed. Changing a set of points to full matrix form and back may change the original order of the points, and will remove duplicate points if they were present.

gridparameters returns, if obj inherits from SpatialGridDataFrame its grid parameters, else it returns numeric(0). The returned value is a data.frame with three columns, named cellcentre.offset ("lower left cell centre coordinates"), cellsize, and cells.dim (cell dimension); the rows correspond to the spatial dimensions.

Methods

obj = "Spatial"

object deriving from class "Spatial"

Examples

# just 9 points on a grid:
x <- c(1,1,1,2,2,2,3,3,3)
y <- c(1,2,3,1,2,3,1,2,3)
xy <- cbind(x,y)
S <- SpatialPoints(xy)
class(S)
plot(S)
gridded(S) <- TRUE
gridded(S)
class(S)
summary(S)
plot(S)
gridded(S) <- FALSE
gridded(S)
class(S)

# data.frame
data(meuse.grid)
coordinates(meuse.grid) <- ~x+y
gridded(meuse.grid) <- TRUE
plot(meuse.grid) # not much good
summary(meuse.grid)

Description

create neighbourhood (nb) object from grid geometry

Usage

gridIndex2nb(obj, maxdist = sqrt(2), fullMat = TRUE, ...)

Arguments

Value

Object of class nb, which is a list.

The nb object follows the convention of nb objects in package spdep; it is a list with each list element corresponding to a grid cell or pixel; the list element contains the indices of neighbours defined as cells less than maxdist away, measured in cell unit (N/S/E/W neighbour has distance 1).

Note

Unequal grid cell size is ignored; grid cell row/col indices are taken to be the coordinates from which distances are computed.

Author(s)

Edzer Pebesma, [email protected]

See Also

plot.nb in package spdep

Description

Create N-S and E-W grid lines over a geographic region; create and plot corresponding labels

Usage

gridlines(x, easts = pretty(bbox(x)[1,]), norths = pretty(bbox(x)[2,]),
 ndiscr = 100) 
gridat(x, easts = pretty(bbox(x)[1,]), norths = pretty(bbox(x)[2,]),
 offset = 0.5, side = "WS")
## S3 method for class 'SpatialLines'
labels(object, labelCRS, side = 1:2, ...)
## S3 method for class 'SpatialPointsDataFrame'
text(x, ...)

Arguments

Value

gridlines returns an object of class SpatialLines-class, with lines as specified; the return object inherits the projection information of x; gridat returns a SpatialPointsDataFrame with points at the west and south ends of the grid lines created by gridlines, with degree labels.

The labels method for SpatialLines objects returns a SpatialPointsDataFrame-class object with the parameters needed to print labels below and left of the gridlines. The locations for the labels are those of proj4string(object) the labels also unless labelCRS is given, in which case they are in that CRS. This object is prepared to be plotted with text:

The text method for SpatialPointsDataFrame puts text labels on its coordinates, and takes care of attributes pos, labels, srt and offset; see text.

Author(s)

Edzer Pebesma, [email protected], using example code of Roger Bivand.

See Also

spTransform

Examples

run <- FALSE
if (requireNamespace("sf", quietly=TRUE)) run <- TRUE

data(meuse)
coordinates(meuse) = ~x+y
plot(meuse)
plot(gridlines(meuse), add = TRUE)
text(labels(gridlines(meuse)))
title("default gridlines within Meuse bounding box")

if (run) {
proj4string(meuse) <- CRS("+init=epsg:28992")
crs.longlat <- CRS("+init=epsg:4326")
meuse_ll <- spTransform(meuse, crs.longlat)
grd <- gridlines(meuse_ll)
grd_x <- spTransform(grd, CRS("+init=epsg:28992"))

# labels South and West:
plot(meuse)
plot(grd_x, add=TRUE, lty=2)
grdat_ll <- gridat(meuse_ll)
grdat_x <- spTransform(grdat_ll, CRS("+init=epsg:28992"))
text(grdat_x)
}
if (run) {
# labels North and East:
plot(meuse)
plot(grd_x, add=TRUE, lty=2)
grdat_ll <- gridat(meuse_ll, side="EN")
grdat_x <- spTransform(grdat_ll, CRS("+init=epsg:28992"))
text(grdat_x)
}
if (run) {
# now using labels:
plot(meuse)
plot(grd_x, add=TRUE, lty=2)
text(labels(grd_x, crs.longlat))
}
if (run) {
# demonstrate axis labels with angle, both sides:
sp = SpatialPoints(rbind(c(-101,9), c(-101,55), c(-19,9), c(-19,55)), crs.longlat)
laea = CRS("+proj=laea +lat_0=30 +lon_0=-40")
sp.l = spTransform(sp, laea)
plot(sp.l, expandBB = c(0, 0.05, 0, .05))
gl = spTransform(gridlines(sp), laea)
plot(gl, add = TRUE)
text(labels(gl, crs.longlat))
text(labels(gl, crs.longlat, side = 3:4), col = 'red')
title("curved text label demo")
}
if (run) {
# polar:
pts=SpatialPoints(rbind(c(-180,-70),c(0,-70),c(180,-89),c(180,-70)), crs.longlat)
polar = CRS("+init=epsg:3031")
gl = spTransform(gridlines(pts, easts = seq(-180,180,20), ndiscr = 100), polar)
plot(spTransform(pts, polar), expandBB = c(.05,0,.05,0))
lines(gl)
l = labels(gl, crs.longlat, side = 3)
l$pos = NULL # pos is too simple, use adj:
text(l, adj = c(0.5, -0.5)) 
l = labels(gl, crs.longlat, side = 4)
l$srt = 0 # otherwise they end up upside-down
text(l)
title("grid line labels on polar projection, epsg 3031")
}
## Not run: 
if (require(maps)) demo(polar) # adds the map of the antarctic

## End(Not run)

Description

A data.frame of years and months of Grids & Datums column publications by country and country code.

Usage

data("GridsDatums")

Format

A data frame with 241 observations on the following 4 variables.

country

name of PE&RS column

month

issue month

year

publication year

ISO

ISO code for country

Details

The journal Photogrammetric Engineering & Remote Sensing, run by the American Society for Photogrammetry and Remote Sensing (ASPRS), began publishing a more-or-less monthly column on the spatial reference systems used in different countries, including their datums. The column first appeared in September 1997, and continued until March 2016; subsequent columns are updated reprints of previous ones. Some also cover other topics, such as world and Martian spatial reference systems. They are written by Clifford J. Mugnier, Louisiana State University, Fellow Emeritus ASPRS. To access the columns, visit https://www.asprs.org/asprs-publications/grids-and-datums.

Source

https://www.asprs.org/asprs-publications/grids-and-datums

Examples

data(GridsDatums)
GridsDatums[grep("Norway", GridsDatums$country),]
GridsDatums[grep("Google", GridsDatums$country),]
GridsDatums[grep("^Mars$", GridsDatums$country),]

Description

class for defining a rectangular grid of arbitrary dimension

Objects from the Class

Objects are created by using e.g.

GridTopology(c(0,0), c(1,1), c(5,5))

see SpatialGrid

Slots

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

Methods

coordinates

signature(x = "SpatialGrid"): calculates coordinates for each point on the grid

summary

signature(object = "SpatialGrid"): summarize object

coerce

signature(from = "GridTopology", to = "data.frame"): convert to data.frame with columns cellcentre.offset, cellsize and cells.dim

Author(s)

Edzer Pebesma, [email protected]

See Also

SpatialGridDataFrame-class, SpatialGrid-class

Examples

x = GridTopology(c(0,0), c(1,1), c(5,5))
class(x)
x
summary(x)
coordinates(x)
y = SpatialGrid(grid = x)
class(y)
y

Description

Create image for gridded data in SpatialGridDataFrame or SpatialPixelsDataFrame objects.

Usage

## S3 method for class 'SpatialGridDataFrame'
image(x, attr = 1, xcol = 1, ycol = 2, 
	col = heat.colors(12), red=NULL, green=NULL, blue=NULL,
        axes = FALSE, xlim = NULL,
	ylim = NULL, add = FALSE, ..., asp = NA, setParUsrBB=FALSE,
        interpolate = FALSE, angle = 0, 
	useRasterImage = !(.Platform$GUI[1] == "Rgui" &&
        getIdentification() == "R Console") && missing(breaks), breaks,
	zlim = range(as.numeric(x[[attr]])[is.finite(x[[attr]])]))
## S3 method for class 'SpatialPixelsDataFrame'
image(x, ...) 
## S3 method for class 'SpatialPixels'
image(x, ...) 
## S3 method for class 'SpatialGridDataFrame'
contour(x, attr = 1, xcol = 1, ycol = 2,
	col = 1, add = FALSE, xlim = NULL, ylim = NULL, axes = FALSE,
         ..., setParUsrBB = FALSE)
## S3 method for class 'SpatialPixelsDataFrame'
contour(x, ...) 
as.image.SpatialGridDataFrame(x, xcol = 1, ycol = 2, attr = 1)
image2Grid(im, p4 = as.character(NA), digits=10)

Arguments

Value

as.image.SpatialGridDataFrame returns the list with elements x and y, containing the coordinates of the cell centres of a matrix z, containing the attribute values in matrix form as needed by image.

Note

Providing xcol and ycol attributes seems obsolete, and it is for 2D data, but it may provide opportunities for plotting certain slices in 3D data. I haven't given this much thought yet.

filled.contour seems to misinterpret the coordinate values, if we take the image.default manual page as the reference.

Author(s)

Edzer Pebesma

See Also

image.default, SpatialGridDataFrame-class, levelplot in package lattice. Function image.plot in package fields can be used to make a legend for an image, see an example in https://stat.ethz.ch/pipermail/r-sig-geo/2007-June/002143.html

Examples

data(meuse.grid)
coordinates(meuse.grid) = c("x", "y") # promote to SpatialPointsDataFrame
gridded(meuse.grid) = TRUE            # promote to SpatialGridDataFrame
data(meuse)
coordinates(meuse) = c("x", "y")
image(meuse.grid["dist"], main = "Distance to river Meuse")
points(coordinates(meuse), pch = "+")
image(meuse.grid["dist"], main = "Distance to river Meuse",
 useRasterImage=TRUE)
points(coordinates(meuse), pch = "+")

# color scale:
layout(cbind(1,2), c(4,1),1)
image(meuse.grid["dist"])
imageScale(meuse.grid$dist, axis.pos=4, add.axis=FALSE)
axis(4,at=c(0,.2,.4,.8), las=2)

data(Rlogo)
d = dim(Rlogo)
cellsize = abs(c(gt[2],gt[6]))
cells.dim = c(d[1], d[2]) # c(d[2],d[1])
cellcentre.offset = c(x = gt[1] + 0.5 * cellsize[1], y = gt[4] - (d[2] - 0.5) * abs(cellsize[2]))
grid = GridTopology(cellcentre.offset, cellsize, cells.dim)
df = as.vector(Rlogo[,,1])
for (band in 2:d[3]) df = cbind(df, as.vector(Rlogo[,,band]))
df = as.data.frame(df)
names(df) = paste("band", 1:d[3], sep="")
Rlogo <- SpatialGridDataFrame(grid = grid, data = df)
summary(Rlogo)
image(Rlogo, red="band1", green="band2", blue="band3")
image(Rlogo, red="band1", green="band2", blue="band3",
 useRasterImage=FALSE)
is.na(Rlogo$band1) <- Rlogo$band1 == 255
is.na(Rlogo$band2) <- Rlogo$band2 == 255
is.na(Rlogo$band3) <- Rlogo$band3 == 255
Rlogo$i7 <- 7
image(Rlogo, "i7")
image(Rlogo, red="band1", green="band2", blue="band3", add=TRUE)

Description

Sets or retrieves projection attributes on classes extending SpatialData; set or retrieve option value for error or warning on exceedance of geographical coordinate range, set or retrieve option value for exceedance tolerance of geographical coordinate range. 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 library, and should be set to an appropriate value.

From release 6 of the PROJ library, when used in building rgdal 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, rgdal 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 rgdal is available and built with PROJ >= 6 and GDAL >=3. The wkt() accessor function returns the WKT2 (2019) string comment belonging to the "CRS" object.

Usage

is.projected(obj)
proj4string(obj)
proj4string(obj) <- value
wkt(obj)
get_ll_warn()
get_ll_TOL()
get_ReplCRS_warn()
set_ll_warn(value)
set_ll_TOL(value)
set_ReplCRS_warn(value)

Arguments

Details

proj4 strings are operative through CRAN package rgdal. For strings defined as “longlat”, the minimum longitude should be -180, the maximum longitude 360, the minimum latitude -90, and the maximum latitude 90. Note that the proj4string replacement method does not project spatial data - for this use spTransform methods in the rgdal package.

Value

is.projected returns a logical that may be NA; proj4string returns a character vector of length 1.

Author(s)

Edzer Pebesma, [email protected]

See Also

CRS

Examples

o <- new("Spatial")
proj4string(o) <- CRS("+init=epsg:27700")
if (!is.null(comment(slot(o, "proj4string")))) {
  cat(strsplit(wkt(o), "\n")[[1]], sep="\n")
  cat(strsplit(wkt(slot(o, "proj4string")), "\n")[[1]], sep="\n")
}
is.projected(CRS("+proj=longlat"))
is.projected(CRS("+proj=geocent"))
is.projected(CRS("+proj=geocent +units=km"))

Description

create objects of class Line or Lines from coordinates

Usage

Line(coords)
Lines(slinelist, ID)

Arguments

Value

Line returns an object of class Line-class; Lines returns an object of class Lines-class

See Also

SpatialLines-class

Examples

# from the sp vignette:
l1 = cbind(c(1,2,3),c(3,2,2))
l1a = cbind(l1[,1]+.05,l1[,2]+.05)
l2 = cbind(c(1,2,3),c(1,1.5,1))
Sl1 = Line(l1)
Sl1a = Line(l1a)
Sl2 = Line(l2)
S1 = Lines(list(Sl1, Sl1a), ID="a")
S2 = Lines(list(Sl2), ID="b")

Description

class for line objects

Objects from the Class

Objects can be created by calls of the form new("Line", ...), or (preferred) by calls to the function Line

Slots

coords:

Object of class "matrix", containing the line coordinates

Methods

coordinates

signature(obj = "Line"): retrieve coordinates from line

lines

signature(x = "Line"): add lines to a plot

Author(s)

Roger Bivand, Edzer Pebesma

See Also

Lines-class, SpatialLines-class

Description

class for sets of line objects

Arguments

Objects from the Class

Objects can be created by calls to the function Line

Slots

Lines:

Object of class "list", containing elements of class Line-class

ID:

"character" vector of length one, with unique identifier string

Methods

coordinates

signature(obj = "Line"): retrieve coordinates from lines; returns list with matrices

lines

signature(x = "Line"): add lines to a plot

Author(s)

Roger Bivand, Edzer Pebesma

See Also

Lines-class, SpatialLines-class

Description

deprecated function to load the Meuse data set

Usage

loadMeuse()

Value

none; it prints a warning to run demo(meuse)

See Also

meuse, meuse.grid

Examples

demo(meuse)

Description

Calculate aspect ratio for plotting geographic maps; create nice degree axis labels

Usage

mapasp(data, xlim, ylim)
degreeLabelsEW(x)
degreeLabelsNS(x)

Arguments

Value

mapasp is used for the aspect argument in lattice plots and spplot;

let x = dy/dx, with dy and dx the y- and x-size of the map.

let s = 1/cos((My * pi)/180) with My the y coordinate of the middle of the map (the mean of ylim)

for latlong (longlat) data, mapasp returns s * x. for other data, mapasp returns "iso".

Note

the values for x are typically obtained from axTicks

See Also

levelplot in package lattice

Description

Merge a Spatial object having a data.frame (i.e. merging of non-spatial attributes).

Usage

## S4 method for signature 'Spatial,data.frame'
merge(x, y, by = intersect(names(x), names(y)),
 by.x = by, by.y = by, all.x = TRUE, suffixes = c(".x",".y"),
 incomparables = NULL, duplicateGeoms = FALSE, ...)

Arguments

Value

a Spatial* object

Author(s)

Robert J. Hijmans

See Also

merge

Description

This data set gives locations and topsoil heavy metal concentrations, along with a number of soil and landscape variables at the observation locations, collected in a flood plain of the river Meuse, near the village of Stein (NL). Heavy metal concentrations are from composite samples of an area of approximately 15 m x 15 m.

Usage

data(meuse)

Format

This data frame contains the following columns:

x

a numeric vector; Easting (m) in Rijksdriehoek (RDH) (Netherlands topographical) map coordinates

y

a numeric vector; Northing (m) in RDH coordinates

cadmium

topsoil cadmium concentration, mg kg-1 soil ("ppm"); zero cadmium values in the original data set have been shifted to 0.2 (half the lowest non-zero value)

copper

topsoil copper concentration, mg kg-1 soil ("ppm")

lead

topsoil lead concentration, mg kg-1 soil ("ppm")

zinc

topsoil zinc concentration, mg kg-1 soil ("ppm")

elev

relative elevation above local river bed, m

dist

distance to the Meuse; obtained from the nearest cell in meuse.grid, which in turn was derived by a spread (spatial distance) GIS operation, horizontal precision 20 metres; then normalized to $[0,1]$

om

organic matter, kg (100 kg)-1 soil (percent)

ffreq

flooding frequency class: 1 = once in two years; 2 = once in ten years; 3 = one in 50 years

soil

soil type according to the 1:50 000 soil map of the Netherlands. 1 = Rd10A (Calcareous weakly-developed meadow soils, light sandy clay); 2 = Rd90C/VII (Non-calcareous weakly-developed meadow soils, heavy sandy clay to light clay); 3 = Bkd26/VII (Red Brick soil, fine-sandy, silty light clay)

lime

lime class: 0 = absent, 1 = present by field test with 5% HCl

landuse

landuse class: Aa Agriculture/unspecified = , Ab = Agr/sugar beetsm, Ag = Agr/small grains, Ah = Agr/??, Am = Agr/maize, B = woods, Bw = trees in pasture, DEN = ??, Fh = tall fruit trees, Fl = low fruit trees; Fw = fruit trees in pasture, Ga = home gardens, SPO = sport field, STA = stable yard, Tv = ?? , W = pasture

dist.m

distance to river Meuse in metres, as obtained during the field survey

Note

row.names refer to the original sample number.

Soil units were mapped with a minimum delination width of 150 m, and so somewhat generalize the landscape.

Approximate equivalent World Reference Base 2002 for Soil Resources names are: Rd10A Gleyic Fluvisols; Rd90C Haplic Fluvisols; Bkd26 Haplic Luvisols. Units Rd90C and Bkd26 have winter groundwater > 80cm, summer > 120cm depth.

Author(s)

Field data were collected by Ruud van Rijn and Mathieu Rikken; compiled for R by Edzer Pebesma; description extended by David Rossiter

References

M G J Rikken and R P G Van Rijn, 1993. Soil pollution with heavy metals - an inquiry into spatial variation, cost of mapping and the risk evaluation of copper, cadmium, lead and zinc in the floodplains of the Meuse west of Stein, the Netherlands. Doctoraalveldwerkverslag, Dept. of Physical Geography, Utrecht University

P.A. Burrough, R.A. McDonnell, 1998. Principles of Geographical Information Systems. Oxford University Press.

Stichting voor Bodemkartering (STIBOKA), 1970. Bodemkaart van Nederland : Blad 59 Peer, Blad 60 West en 60 Oost Sittard: schaal 1 : 50 000. Wageningen, STIBOKA.

http://www.gstat.org/

Examples

data(meuse)
summary(meuse)
coordinates(meuse) <- ~x+y
proj4string(meuse) <- CRS("+init=epsg:28992")

Description

The meuse.grid data frame has 3103 rows and 7 columns; a grid with 40 m x 40 m spacing that covers the Meuse study area (see meuse)

Usage

data(meuse.grid)

Format

This data frame contains the following columns:

x

a numeric vector; x-coordinate (see meuse)

y

a numeric vector; y-coordinate (see meuse)

dist

distance to the Meuse river; obtained by a spread (spatial distance) GIS operation, from border of river; normalized to $[0,1]$

ffreq

flooding frequency class, for definitions see this item in meuse; it is not known how this map was generated

part.a

arbitrary division of the area in two areas, a and b

part.b

see part.a

soil

soil type, for definitions see this item in meuse; it is questionable whether these data come from a real soil map, they do not match the published 1:50 000 map

Details

x and y are in RD New, the Dutch topographical map coordinate system. Roger Bivand projected this to UTM in the R-Grass interface package.

Source

http://www.gstat.org/

References

See the meuse documentation

Examples

data(meuse.grid)
coordinates(meuse.grid) = ~x+y
proj4string(meuse.grid) <- CRS("+init=epsg:28992")
gridded(meuse.grid) = TRUE
spplot(meuse.grid)

Description

The object contains the meuse.grid data as a SpatialPointsDataFrame after transformation to WGS84 and geographical coordinates.

Usage

data(meuse.grid_ll)

Format

The format is: Formal class 'SpatialPointsDataFrame' [package "sp"].

Source

See the meuse documentation

Examples

data(meuse.grid_ll)

Description

The meuse.riv data consists of an outline of the Meuse river in the area a few kilometers around the meuse data set.

The meuse.area polygon has an outline of meuse.grid. See example below how it can be created from meuse.grid.

Usage

data(meuse.riv)
data(meuse.area)

Format

meuse.riv: two-column data.frame containing 176 coordinates.

meuse.area: two-column matrix with coordinates of outline.

Details

x and y are in RDM, the Dutch topographical map coordinate system. See examples of spTransform for projection parameters.

References

See the meuse documentation

Examples

data(meuse.riv)
plot(meuse.riv, type = "l", asp = 1)
data(meuse.grid)
coordinates(meuse.grid) = c("x", "y")
gridded(meuse.grid) = TRUE
image(meuse.grid, "dist", add = TRUE)
data(meuse)
coordinates(meuse) = c("x", "y")
meuse.sr = SpatialPolygons(list(Polygons(list(Polygon(meuse.riv)),"meuse.riv")))
spplot(meuse.grid, col.regions=bpy.colors(), main = "meuse.grid",
  sp.layout=list(
	list("sp.polygons", meuse.sr),
	list("sp.points", meuse, pch="+", col="black")
  )
)
spplot(meuse, "zinc", col.regions=bpy.colors(),  main = "zinc, ppm",
  cuts = c(100,200,400,700,1200,2000), key.space = "right",
  sp.layout= list("sp.polygons", meuse.sr, fill = "lightblue")
)

Description

consistent spatial overlay for points, grids and polygons: at the spatial locations of object x retrieves the indexes or attributes from spatial object y

Usage

over(x, y, returnList = FALSE, fn = NULL, ...)
x %over% y

Arguments

Value

If y is only geometry an object of length length(x). If returnList is FALSE, a vector with the (first) index of y for each geometry (point, grid cell centre, polygon or lines) matching x. if returnList is TRUE, a list of length length(x), with list element i the vector of all indices of the geometries in y that correspond to the $i$-th geometry in x.

If y has attribute data, attribute data are returned. returnList is FALSE, a data.frame with number of rows equal to length(x) is returned, if it is TRUE a list with length(x) elements is returned, with a list element the data.frame elements of all geometries in y that correspond to that element of x.

Methods

x = "SpatialPoints", y = "SpatialPolygons"

returns a numeric vector of length equal to the number of points; the number is the index (number) of the polygon of y in which a point falls; NA denotes the point does not fall in a polygon; if a point falls in multiple polygons, the last polygon is recorded.

x = "SpatialPointsDataFrame", y = "SpatialPolygons"

equal to the previous method, except that an argument fn=xxx is allowed, e.g. fn = mean which will then report a data.frame with the mean attribute values of the x points falling in each polygon (set) of y

x = "SpatialPoints", y = "SpatialPolygonsDataFrame"

returns a data.frame of the second argument with row entries corresponding to the first argument

x = "SpatialPolygons", y = "SpatialPoints"

returns the polygon index of points in y; if x is a SpatialPolygonsDataFrame, a data.frame with rows from x corresponding to points in y is returned.

x = "SpatialGridDataFrame", y = "SpatialPoints"

returns object of class SpatialPointsDataFrame with grid attribute values x at spatial point locations y; NA for NA grid cells or points outside grid, and NA values on NA grid cells.

x = "SpatialGrid", y = "SpatialPoints"

returns grid values x at spatial point locations y; NA for NA grid cells or points outside the grid

x = "SpatialPixelsDataFrame", y = "SpatialPoints"

returns grid values x at spatial point locations y; NA for NA grid cells or points outside the grid

x = "SpatialPixels", y = "SpatialPoints"

returns grid values x at spatial point locations y; NA for NA grid cells or points outside the grid

x = "SpatialPoints", y = "SpatialGrid"

xx

x = "SpatialPoints", y = "SpatialGridDataFrame"

xx

x = "SpatialPoints", y = "SpatialPixels"

xx

x = "SpatialPoints", y = "SpatialPixelsDataFrame"

xx

x = "SpatialPolygons", y = "SpatialGridDataFrame"

xx

Note

over can be seen as a left outer join in SQL; the match is a spatial intersection.

points on a polygon boundary and points corresponding to a polygon vertex are considered to be inside the polygon.

These methods assume that pixels and grid cells are never overlapping; for objects of class SpatialPixels this is not guaranteed.

Author(s)

Edzer Pebesma, [email protected]

See Also

vignette("over") for examples and figures

Description

panel functions for spplot functions, and functions that can be useful within these panel functions

Usage

spplot.key(sp.layout, rows = 1, cols = 1)
SpatialPolygonsRescale(obj, offset, scale = 1, fill = "black", col = "black",
	plot.grid = TRUE, ...)
sp.lines(obj, col = 1, ...)
sp.points(obj, pch = 3, ...)
sp.polygons(obj, col = 1, fill = "transparent", ...)
sp.grid(obj, col = 1, alpha = 1,..., at = pretty(obj[[1]]), col.regions = col)
sp.text(loc, txt, ...)
sp.panel.layout(lst, p.number, ...)
bbexpand(x, fraction)

Arguments

Note

The panel functions of spplot, panel.gridplot for grids, panel.pointsplot for points, or panel.polygonsplot for lines or polygons can be called with arguments (x,y,...). Customizing spplot plots can be done by extending the panel function, or by supplying an sp.layout argument; see the documentation for spplot. Inside these panel functions, sp.panel.layout is called to deal with plotting the items in a sp.layout object.

SpatialPolygonsRescale scales and shifts an object of class SpatialPolygons-class; this is useful e.g. for scale bars, or other layout items.

sp.lines, sp.points, sp.polygons and sp.text plot lines, points, polygons or text in a panel.

spplot.key draws the sp.layout object at given rows/cols.

sp.pagefn can be passed as a page argument, and will call function spplot.key for the last panel drawn on a page.

Author(s)

Edzer Pebesma, [email protected]

References

https://edzer.github.io/sp/ has a graph gallery with examples with R code.

See Also

spplot, spplot-methods

Description

verifies for one or more points whether they fall in a given polygon

Usage

point.in.polygon(point.x, point.y, pol.x, pol.y, mode.checked=FALSE)

Arguments

Value

integer array; values are: 0: point is strictly exterior to pol; 1: point is strictly interior to pol; 2: point lies on the relative interior of an edge of pol; 3: point is a vertex of pol.

References

Uses the C function InPoly(). InPoly is Copyright (c) 1998 by Joseph O'Rourke. It may be freely redistributed in its entirety provided that this copyright notice is not removed.

Examples

# open polygon:
point.in.polygon(1:10,1:10,c(3,5,5,3),c(3,3,5,5))
# closed polygon:
point.in.polygon(1:10,rep(4,10),c(3,5,5,3,3),c(3,3,5,5,3))

Description

class for spatial polygon

Objects from the Class

Objects can be created by calls to the function Polygon

Slots

ringDir:

Object of class "integer"; the ring direction of the ring (polygon) coordinates, holes are expected to be anti-clockwise

labpt:

Object of class "numeric"; an x, y coordinate pair forming the label point of the polygon

area:

Object of class "numeric"; the planar area of the polygon, does not respect projection as objects of this class have no projection defined

hole:

Object of class "logical"; does the polygon seem to be a hole

coords:

Object of class "matrix"; coordinates of the polygon; first point should equal the last point

Extends

Class "Line", directly.

Methods

No methods defined with class "Polygon" in the signature.

Author(s)

Roger Bivand

See Also

Polygons-class, SpatialPolygons-class

Description

sets spatial coordinates to create spatial data, or retrieves spatial coordinates

Usage

polygons(obj)
	polygons(object) <- value

Arguments

Value

polygons returns the SpatialPolygons of obj; polygons<- promotes a data.frame to a SpatialPolygonsDataFrame object

Examples

grd <- GridTopology(c(1,1), c(1,1), c(10,10))
polys <- as.SpatialPolygons.GridTopology(grd)
centroids <- coordinates(polys)
x <- centroids[,1]
y <- centroids[,2]
z <- 1.4 + 0.1*x + 0.2*y + 0.002*x*x
df <- data.frame(x=x, y=y, z=z, row.names=row.names(polys))
polygons(df) <- polys
class(df)
summary(df)

Description

Collection of objects of class "Polygon"

Objects from the Class

Objects can be created by calls to the function Polygons

Slots

Polygons:

Object of class "list"; list with objects of class Polygon-class

plotOrder:

Object of class "integer"; order in which the Polygon objects should be plotted, currently by order of decreasing size

labpt:

Object of class "numeric"; pair of x, y coordinates giving a label point, the label point of the largest polygon component

ID:

Object of class "character"; unique identifier string

area:

Object of class "numeric"; the gross total planar area of the Polygon list but not double-counting holes (changed from 0.9-58 - islands are summed, holes are ignored rather than subtracted); these values are used to make sure that polygons of a smaller area are plotted after polygons of a larger area, does not respect projection as objects of this class have no projection defined

Methods

No methods defined with class "Polygons" in the signature.

Note

By default, single polygons (where Polygons is a list of length one) are not expected to be holes, but in multiple polygons, hole definitions for member polygons can be set. Polygon objects belonging to an Polygons object should either not overlap one-other, or should be fully included (as lakes or islands in lakes). They should not be self-intersecting. Checking of hole FALSE/TRUE status for Polygons objects is now handled by round-trip coercion to sf and back to sp.

Author(s)

Roger Bivand

Description

Retrieve polygons from SpatialPolygonsDataFrame object

Methods for polygons

obj = "SpatialPolygons"

object of, or deriving from, SpatialPolygons

obj = "SpatialPolygonsDataFrame"

object of, or deriving from, SpatialPolygonsDataFrame

Methods for "polygons<-"

object = "data.frame", value="SpatialPolygons"

promote data.frame to object of class SpatialPolygonsDataFrame-class, by specifying polygons

Description

read/write to/from ESRI asciigrid format

Usage

read.asciigrid(fname, as.image = FALSE, plot.image = FALSE, colname = fname,
 proj4string = CRS(as.character(NA)))
write.asciigrid(x, fname, attr = 1, na.value = -9999, ...)

Arguments

Value

read.asciigrid returns the grid map read; either as an object of class SpatialGridDataFrame-class or, if as.image is TRUE, as list with components x, y and z.

Author(s)

Edzer Pebesma

See Also

as.image.SpatialGridDataFrame, image

Examples

x <- read.asciigrid(system.file("external/test.ag", package="sp")[1])
class(x)
image(x)

Description

Methods for function recenter in package sp to shift or re-center geographical coordinates for a Pacific view. All longitudes < 0 are added to 360, to avoid for instance parts of Alaska being represented on the far left and right of a plot because they have values straddling 180 degrees. In general, using a projected coordinate reference system is to be preferred, but this method permits a geographical coordinate reference system to be used. This idea was suggested by Greg Snow, and corresponds to the two world representations in the maps package.

Methods

obj = "SpatialPolygons"

recenter a SpatialPolygons object

obj = "Polygons"

recenter a Polygons object

obj = "Polygon"

recenter an Polygon object

obj = "SpatialLines"

recenter a SpatialLines object

obj = "Lines"

recenter a Lines object

obj = "Line"

recenter an Line object

Examples

crds <- matrix(c(179, -179, -179, 179, 50, 50, 52, 52), ncol=2)
SL <- SpatialLines(list(Lines(list(Line(crds)), "1")),
 CRS("+proj=longlat +ellps=WGS84"))
bbox(SL)
SLr <- recenter(SL)
bbox(SLr)
rcrds <- rbind(crds, crds[1,])
SpP <- SpatialPolygons(list(Polygons(list(Polygon(rcrds)), ID="r1")),
 proj4string=CRS("+proj=longlat +ellps=WGS84"))
bbox(SpP)
SpPr <- recenter(SpP)
bbox(SpPr)
opar <- par(mfrow=c(1,2))
plot(SpP)
plot(SpPr)
par(opar)
crds <- matrix(c(-1, 1, 1, -1, 50, 50, 52, 52), ncol=2)
SL <- SpatialLines(list(Lines(list(Line(crds)), "1")),
 CRS("+proj=longlat +ellps=WGS84"))
bbox(SL)
SLr <- recenter(SL)
bbox(SLr)
rcrds <- rbind(crds, crds[1,])
SpP <- SpatialPolygons(list(Polygons(list(Polygon(rcrds)), ID="r1")),
 proj4string=CRS("+proj=longlat +ellps=WGS84"))
bbox(SpP)
SpPr <- recenter(SpP)
bbox(SpPr)
opar <- par(mfrow=c(1,2))
plot(SpP)
plot(SpPr)
par(opar)

Description

Rlogo jpeg image data as imported by getRasterData in the rgdal package

Usage

data(Rlogo)

Format

The format is: int [1:101, 1:77, 1:3] 255 255 255 255 255 255 255 255 255 255 ...

Examples

data(Rlogo)
d = dim(Rlogo)
cellsize = abs(c(gt[2],gt[6]))
cells.dim = c(d[1], d[2]) # c(d[2],d[1])
cellcentre.offset = c(x = gt[1] + 0.5 * cellsize[1], y = gt[4] - (d[2] - 0.5) * abs(cellsize[2]))
grid = GridTopology(cellcentre.offset, cellsize, cells.dim)
df = as.vector(Rlogo[,,1])
for (band in 2:d[3]) df = cbind(df, as.vector(Rlogo[,,band]))
df = as.data.frame(df)
names(df) = paste("band", 1:d[3], sep="")
Rlogo <- SpatialGridDataFrame(grid = grid, data = df)
summary(Rlogo)
spplot(Rlogo, zcol=1:3, names.attr=c("red","green","blue"), 
	col.regions=grey(0:100/100),
	main="example of three-layer (RGB) raster image", as.table=TRUE)

Description

select a number of points by digitizing the area they fall in

Usage

select.spatial(data, digitize = TRUE, pch = "+", rownames = FALSE)

Arguments

Value

if rownames == FALSE, array with either indexes (row numbers) of points inside the digitized polygon; if rownames == TRUE, character array with corresponding row names in the data.frame part

See Also

point.in.polygon, locator, SpatialPoints-class, SpatialPointsDataFrame-class

Examples

data(meuse)
## the following command requires user interaction: left mouse
## selects points, right mouse ends digitizing
data(meuse)
coordinates(meuse) = c("x", "y")
# select.spatial(meuse)

Description

This package provides S4 classes for importing, manipulating and exporting spatial data in R, and for methods including print/show, plot, subset, [, [[, \$, names, dim, summary, and a number of methods specific to spatial data handling.

Introduction

Several spatial statistical packages have been around for a long while, but no organized set of classes for spatial data has yet been devised. Many of the spatial packages make their own assumptions, or use their own class definitions for spatial data, making it inconvenient to move from one package to another. This package tries to provide a solid set of classes for many different types of spatial data. The idea is that spatial statistical packages will either support these classes (i.e., directly read and write them) or will provide conversion to them, so that we have a base class set with which any package can exchange. This way, many-to-many conversions can be replace with one-to-many conversions, provided either in this package or the spatial packages. Wherever possible conversion (coercion) functions are automatic, or provided by sp.

External packages that depend on sp will provide importing and exporting from and to external GIS formats, e.g. through GDAL, OGR or shapelib.

In addition, this package tries to provide convenient methods to print, summarize and plot such spatial data.

Dimensions

In principal, geographical data are two-dimensional, on a flat surface (a map) or on a sphere (the earth). This package provides space for dealing with higher dimensional data where possible; this is e.g. very simple for points and grids, but hard to do for polygons. Plotting functions are devised primarily for two-dimensional data, or two-dimensional projections of higher dimensional data.

Coordinate reference systems

Central to spatial data is that they have a coordinate reference system, which is coded in object of CRS class. Central to operations on different spatial data sets is that their coordinate reference system is compatible (i.e., identical).

This CRS can be a character string describing a reference system in a way understood by the PROJ.4 projection library, or a (character) missing value. An interface to the PROJ.4 library is available only if the R package rgdal is present.

Class structure

All spatial classes derive from a basic class Spatial, which only provides a bounding box and a CRS. This class has no useful instances, but useful derived classes.

SpatialPoints extends Spatial and has coordinates. The method coordinates extracts the numeric matrix with coordinates from an object of class SpatialPoints, or from other (possibly derived) classes that have points.

Objects of class SpatialGrid points on a regular grid. Either a full grid is stored or a partial grid (i.e., only the non-missing valued cells); calling coordinates on them will give the coordinates for the grid cells.

SpatialPoints, SpatialPixels and SpatialGrid can be of arbitrary dimension, although most of the effort is in making them work for two dimensional data.

SpatialLines provides lines, and SpatialPolygons provides polygons, i.e., lines that end where they start and do not intersect with itself. SpatialLines and SpatialPolygons only have two-dimensional data.

SpatialPointsDataFrame extends SpatialPoints with a data slot, having a data.frame with attribute data. Similarly, SpatialPixelsDataFrame, SpatialLinesDataFrame, SpatialPolygonsDataFrame extend the primary spatial information with attribute data.

References

PROJ.4: https://github.com/OSGeo/PROJ

GDAL and OGR: https://gdal.org/.

Authors

sp is a collaborative effort of Edzer Pebesma, Roger Bivand, Barry Rowlingson and Virgilo G\'omez-Rubio.

Description

Deprecated functions is sp: getSpP*, getPolygon*, getLines* getSL*

Usage

set_evolution_status(value)
get_evolution_status()

Arguments

Note

For overlay the new implementation is found in the over method; this works slightly different and more consistent.

Description

The function outputs a SpatialPolygonsDataFrame object to be used by Mondrian

Usage

sp2Mondrian(SP, file, new_format=TRUE)

Arguments

Note

At this release, the function writes out a text file with both data and polygon(s) identified as belonging to each row of data.

Author(s)

Patrick Hausmann and Roger Bivand

References

https://www.theusrus.de/Mondrian/, Ihaka Lecture 1: 28 September 2023, Interactive Graphics and Data Analysis, Antony Unwin https://www.auckland.ac.nz/en/science/about-the-faculty/department-of-statistics/ihaka-lecture-series.html

Examples

if (require("sf", quietly=TRUE)) {
td <- tempdir()
xx <- as(sf::st_read(system.file("shape/nc.shp", package="sf")[1], quiet=TRUE), "Spatial")
sp2Mondrian(xx, file=file.path(td, "sids1.txt"))
}

Description

An abstract class from which useful spatial classes are derived

Usage

Spatial(bbox, proj4string = CRS(as.character(NA)))
## S3 method for class 'Spatial'
subset(x, subset, select, drop = FALSE, ...)

Arguments

Objects from the Class

are never to be generated; only derived classes can be meaningful

Slots

bbox:

Object of class "matrix"; 2-column matrix holding the minimum in first and maximum in second column for the x-coordinate (first row), y-coordinate (second row) and optionally, for points and grids only, further coordinates. The constructed Spatial object will be invalid if any bbox values are NA or infinite. The column names must be c("min", "max")

proj4string:

Object of class "CRS". The name of this slot was chosen to reflect the use of Proj.4 strings to represent coordinate reference systems (CRS). The slot name will continue to be used, but as PROJ >= 6 and GDAL >= 3 are taken into use for reading files and for projection and transformation, the Proj.4 string CRS representation is being supplemented by a WKT2 (2019) representation. The reason for the modification is that important keys in the Proj.4 string representation are being deprecated in PROJ >= 6 and GDAL >= 3. Legacy "CRS" objects hold only a valid Proj.4 string, which can be used for unprojecting or reprojecting coordinates; it is initialised to NA. If the "CRS" object is instantiated using CRS() with rgdal using PROJ >= 6 and GDAL >= 3, the object may also have a WKT2 (2019) string carried as a comment. Non-NA strings may be checked for validity in the rgdal package, but attempts to assign a string containing "longlat" to data extending beyond longitude [-180, 360] or lattitude [-90, 90] will be stopped or warned, use set_ll_warn to warn rather than stop, and set_ll_TOL to change the default tolerance for the range exceedance tests.

Methods

bbox

signature(obj = "Spatial"): retrieves the bbox element

dimensions

signature(obj = "Spatial"): retrieves the number of spatial dimensions spanned

gridded

signature(obj = "Spatial"): logical, tells whether the data is on a regular spatial grid

plot

signature(x = "Spatial", y = "missing"): plot method for spatial objects; does nothing but setting up a plotting region choosing a suitable aspect if not given(see below), colouring the plot background using either a bg= argument or par("bg"), and possibly drawing axes.

summary

signature(object = "Spatial"): summarize object

$

retrieves attribute column

$<-

sets or replaces attribute column, or promote a geometry-only object to an object having an attribute

rebuild_CRS

rebuild a CRS object, usually used to add a WKT comment with PROJ >= 6 and GDAL >= 3

plot method arguments

The plot method for “Spatial” objects takes the following arguments:

x

object of class Spatial

xlim

default NULL; the x limits (x1, x2) of the plot

ylim

default NULL; the y limits of the plot

asp

default NA; the y/x aspect ratio

axes

default FALSE; a logical value indicating whether both axes should be drawn

bg

default par("bg"); colour to be used for the background of the device region

xaxs

The style of axis interval calculation to be used for the x-axis

yaxs

The style of axis interval calculation to be used for the y-axis

lab

A numerical vector of the form c(x, y, len) which modifies the default way that axes are annotated

setParUsrBB

default FALSE; set the par “usr” bounding box; see below

bgMap

object of class ggmap, or returned by function RgoogleMaps::GetMap

expandBB

numeric; factor to expand the plotting region default: bbox(x) with on each side (1=below, 2=left, 3=above and 4=right); defaults to c(0,0,0,0); setting xlim or ylim overrides this.

...

passed through

Warning

this class is not useful in itself, but all spatial classes in this package derive from it

Note

The default aspect for map plots is 1; if however data are not projected (coordinates are longlat), the aspect is by default set to 1/cos(My * pi)/180) with My the y coordinate of the middle of the map (the mean of ylim, which defaults to the y range of bounding box).

The argument setParUsrBB may be used to pass the logical value TRUE to functions within plot.Spatial. When set to TRUE, par(“usr”) will be overwritten with c(xlim, ylim), which defaults to the bounding box of the spatial object. This is only needed in the particular context of graphic output to a specified device with given width and height, to be matched to the spatial object, when using par(“xaxs”) and par(“yaxs”) in addition to par(mar=c(0,0,0,0)).

Author(s)

r-spatial team; Edzer Pebesma, [email protected] Roger Bivand, Barry Rowlingson, Virgilio G\'omez-Rubio

See Also

SpatialPoints-class, SpatialGrid-class, SpatialPointsDataFrame-class, SpatialGridDataFrame-class

Examples

o <- new("Spatial")
proj4string(o) <- CRS("+init=epsg:27700")
if (!is.null(comment(slot(o, "proj4string")))) {
  cat(strsplit(wkt(o), "\n")[[1]], sep="\n")
  cat(strsplit(wkt(slot(o, "proj4string")), "\n")[[1]], sep="\n")
}

Description

class for defining a full, rectangular grid of arbitrary dimension

Objects from the Class

Objects are created by using e.g.

SpatialGrid(grid)

with grid of class GridTopology-class

Slots

grid

object of class GridTopology-class, defining the grid topology (offset, cellsize, dim)

bbox:

Object of class "matrix"; bounding box

proj4string:

Object of class "CRS"; projection

Extends

Class "SpatialPoints" directly; Class "Spatial", by class "SpatialPoints".

Methods

coordinates

signature(x = "SpatialGrid"): calculates coordinates for each point on the grid; coordinates are not stored in objects of class SpatialGrid

summary

signature(object = "SpatialGrid"): summarize object

plot

signature(x = "SpatialGrid"): plots cell centers

"["

signature(x = "SpatialGrid"): select rows and columns

Author(s)

Edzer Pebesma, [email protected]

See Also

SpatialGridDataFrame-class, SpatialGrid

Examples

x = GridTopology(c(0,0), c(1,1), c(5,5))
class(x)
x
summary(x)
coordinates(x)
y = SpatialGrid(grid = x)
class(y)
y

Description

Class for spatial attributes that have spatial locations on a (full) regular grid.

Objects from the Class

Objects can be created by calls of the form as(x, "SpatialGridDataFrame"), where x is of class SpatialPixelsDataFrame-class, or by importing through rgdal. Ordered full grids are stored instead or unordered non-NA cells;

Slots

grid:

see GridTopology-class; grid parameters

bbox:

Object of class "matrix"; bounding box

proj4string:

Object of class "CRS"; projection

data:

Object of class data.frame, containing attribute data

Extends

Class "SpatialGrid", directly. Class "Spatial", by class "SpatialGrid".

Methods

coordinates

signature(x = "SpatialGridDataFrame"): retrieves (and calculates!) coordinates

[

signature(x = "SpatialGridDataFrame"): selects rows, columns, and attributes; returns an object of class SpatialGridDataFrame

as.matrix

signature(x = "SpatialGridDataFrame"): coerce to matrix; increasing col index corresponds to decreasing y coordinate, row index increases with coordinate index

as.array

signature(x = "SpatialGridDataFrame"): coerce to array; increasing array index for the second dimension corresponds to decreasing coordinates, all other coordinate dimensions increase with array index

cbind

signature(...): if arguments have identical topology, combine their attribute values

Plot method arguments

The plot methods for “SpatialPixelsDataFrame” or “SpatialGridDataFrame” objects take the following arguments:

x

object of class SpatialPixelsDataFrame or SpatialGridDataFrame

...

arguments passed on to image.SpatialGridDataFrame

attr

integer or character, indicating the attribute variable to be plotted; default 1

col

color ramp to be used; default bpy.colors(100) for continuous, or RColorBrewer::brewer.pal(nlevels(x[[1]]), "Set2") for factor variables

breaks

for continuous attributes: values at which color breaks should take place

zlim

for continuous attributes: numeric of length 2, specifying the range of attribute values to be plotted; default to data range range(as.numeric(x[[attr]])[is.finite(x[[attr]])])

axes

logical: draw x and y axes? default FALSE

xaxs

character, default "i", see par

yaxs

character, default equal to xaxs, see par

at

numeric or NULL, values at which axis tics and labels should be drawn; default NULL (use pretty)

border

color, to be used for drawing grid lines; default NA (don't draw grid lines)

axis.pos

integer, 1-4; default 4, see axis

add.axis

logical: draw axis along scale? default TRUE

what

what to draw: "image", "scale", or "both"; default "both"

scale.size

size for the scale bar; use lcm to specify in absolute size, or a numeric value such as 1/6 to specify relative size; default lcm(2.8)

scale.shrink

non-negative numeric indicating the amount to shrink the scale length, default 0

scale.frac

for categorical attributes: numeric between 0 and 1, indicating the scale width, default 0.3

scale.n

for categorical attributes: integer, indicating how many scale categories should fill a complete width; default 15

Author(s)

Edzer Pebesma, [email protected]

See Also

SpatialGrid-class, which does not contain the attribute data, and SpatialPixelsDataFrame-class which holds possibly incomplete grids

Plotting gridded data with sp: https://r-spatial.org/r/2016/03/08/plotting-spatial-grids.html

Examples

data(meuse.grid) # only the non-missing valued cells
coordinates(meuse.grid) = c("x", "y") # promote to SpatialPointsDataFrame
gridded(meuse.grid) <- TRUE # promote to SpatialPixelsDataFrame
x = as(meuse.grid, "SpatialGridDataFrame") # creates the full grid
x[["idist"]] = 1 - x[["dist"]] # assigns new attribute
image(x["idist"]) # note the single [ for attribute selection

# toy example:
df = data.frame(z = c(1:6,NA,8,9),
    xc = c(1,1,1,2,2,2,3,3,3),
    yc = c(rep(c(0, 1.5, 3),3)))
coordinates(df) = ~xc+yc
gridded(df) = TRUE
df = as(df, "SpatialGridDataFrame") # to full grid
image(df["z"])
# draw labels to verify:
cc = coordinates(df)
z=df[["z"]]
zc=as.character(z)
zc[is.na(zc)]="NA"
text(cc[,1],cc[,2],zc)

# the following is weird, but illustrates the concept of row/col selection:
fullgrid(meuse.grid) = TRUE
image(meuse.grid)
image(meuse.grid[20:70, 10:70, "dist"], add = TRUE, col = bpy.colors())

# as.matrix, as.array
sgdim = c(3,4)
SG = SpatialGrid(GridTopology(rep(0,2), rep(10,2), sgdim))
SGDF = SpatialGridDataFrame(SG, data.frame(val = 1:12))
as.array(SGDF)
as.matrix(SGDF)
as(SGDF, "array")

Description

create objects of class SpatialLines or SpatialLinesDataFrame from lists of Lines objects and data.frames; extract list od Lines from a SpatialLines object

Usage

SpatialLines(LinesList, proj4string = CRS(as.character(NA)))
SpatialLinesDataFrame(sl, data, match.ID = TRUE)
as.SpatialLines.SLDF(SLDF)
getSpatialLinesMidPoints(SL)
LineLength(cc, longlat = FALSE, sum = TRUE)
LinesLength(Ls, longlat = FALSE)
SpatialLinesLengths(SL, longlat)

Arguments

Value

SpatialLines returns object of class SpatialLines; SpatialLinesDataFrame returns object of class SpatialLinesDataFrame getSpatialLinesMidPoints returns an object of class SpatialPoints,each point containing the (weighted) mean of the lines elements; weighted in the sense that mean is called twice.

See Also

SpatialLines-class

Description

a class that holds spatial lines

Objects from the Class

hold a list of Lines objects; each Lines object holds a list of Line (line) objects.

Slots

lines:

Object of class "list"; list members are all of class Lines-class

bbox:

Object of class "matrix"; see Spatial-class

proj4string:

Object of class "CRS"; see CRS-class

Extends

Class "Spatial", directly.

Methods

[

signature(obj = "SpatialLines"): select subset of (sets of) lines; NAs are not permitted in the row index

coordinates

value is a list of lists with matrices

plot

signature(x = "SpatialLines", y = "missing"): plot lines in SpatialLines object

lines

signature(x = "SpatialLines"): add lines in SpatialLines object to a plot

rbind

signature(object = "SpatialLines"): rbind-like method, see notes

summary

signature(object = "SpatialLines"): summarize object

plot method arguments

The plot method for “SpatialLines” objects takes the following arguments:

x

object of class SpatialLines

xlim

default NULL; the x limits (x1, x2) of the plot

ylim

default NULL; the y limits of the plot

col

default 1; default plotting color

lwd

default 1; line width

lty

default 1; line type

add

default FALSE; add to existing plot

axes

default FALSE; a logical value indicating whether both axes should be drawn

lend

default 0; line end style

ljoin

default 0; line join style

lmitre

default 10; line mitre limit

...

passed through

setParUsrBB

set the par “usr” bounding box, see note in Spatial-class

Note

rbind calls the function SpatialLines, where it is checked that all IDs are unique. If rbind-ing SpatialLines without unique IDs, it is possible to set the argument makeUniqueIDs = TRUE, although it is preferred to change these explicitly with spChFIDs.

Author(s)

Roger Bivand, Edzer Pebesma

See Also

Line-class, Lines-class

Examples

# from the sp vignette:
l1 = cbind(c(1,2,3),c(3,2,2))
rownames(l1) = letters[1:3]
l1a = cbind(l1[,1]+.05,l1[,2]+.05)
rownames(l1a) = letters[1:3]
l2 = cbind(c(1,2,3),c(1,1.5,1))
rownames(l2) = letters[1:3]
Sl1 = Line(l1)
Sl1a = Line(l1a)
Sl2 = Line(l2)
S1 = Lines(list(Sl1, Sl1a), ID="a")
S2 = Lines(list(Sl2), ID="b")
Sl = SpatialLines(list(S1,S2))
summary(Sl)
plot(Sl, col = c("red", "blue"))

Description

this class holds data consisting of (sets of lines), where each set of lines relates to an attribute row in a data.frame

Objects from the Class

can be created by the function SpatialLinesDataFrame

Slots

data:

Object of class data.frame containing the attribute table

lines:

Object of class "list"; see SpatialLines-class

bbox:

Object of class "matrix"; see Spatial-class

proj4string:

Object of class "CRS"; see CRS-class

Extends

Class "SpatialLines", directly. Class "Spatial", by class "SpatialLines".

Methods

Methods defined with class "SpatialLinesDataFrame" in the signature:

[

signature(x = "SpatialLinesDataFrame"): subset rows or columns; in case of row subsetting, the line sets are also subsetted; NAs are not permitted in the row index

coordinates

signature(obj = "SpatialLinesDataFrame"): retrieves a list with lists of coordinate matrices

show

signature(object = "SpatialLinesDataFrame"): print method

plot

signature(x = "SpatialLinesDataFrame"): plot points

lines

signature(object = "SpatialLinesDataFrame"): add lines to plot

rbind

signature(object = "SpatialLinesDataFrame"): rbind-like method

Note

rbind for SpatialLinesDataFrame is only possible for objects with unique IDs. If you want to rbind objects with duplicated IDs, seespChFIDs.

Author(s)

Roger Bivand; Edzer Pebesma

See Also

SpatialLines-class

Description

create objects of class SpatialMultiPoints-class or SpatialMultiPointsDataFrame-class from coordinates, and from coordinates and data.frames

Usage

SpatialMultiPoints(coords, proj4string=CRS(as.character(NA)), bbox = NULL)
SpatialMultiPointsDataFrame(coords, data,
      proj4string = CRS(as.character(NA)), match.ID, bbox = NULL)

Arguments

Value

SpatialMultiPoints returns an object of class SpatialMultiPoints; SpatialMultiPointsDataFrame returns an object of class SpatialMultiPointsDataFrame;

See Also

coordinates, SpatialMultiPoints-class, SpatialMultiPointsDataFrame-class

Examples

cl1 = cbind(rnorm(3, 10), rnorm(3, 10))
cl2 = cbind(rnorm(5, 10), rnorm(5,  0))
cl3 = cbind(rnorm(7,  0), rnorm(7, 10))

mp = SpatialMultiPoints(list(cl1, cl2, cl3))
mpx = rbind(mp, mp) # rbind method
plot(mp, col = 2, cex = 1, pch = 1:3)
mp
mp[1:2]

print(mp, asWKT=TRUE, digits=3)

mpdf = SpatialMultiPointsDataFrame(list(cl1, cl2, cl3), data.frame(a = 1:3))
mpdf
mpdfx = rbind(mpdf, mpdf) # rbind method

plot(mpdf, col = mpdf$a, cex = 1:3)
as(mpdf, "data.frame")
mpdf[1:2,]