R: Work with homogeneous coordinates

matrices {rgl} | R Documentation

## Work with homogeneous coordinates

### Description

These functions construct 4x4 matrices for transformations in the homogeneous coordinate system used by OpenGL, and translate vectors between homogeneous and Euclidean coordinates.

### Usage

    identityMatrix()
    scaleMatrix(x, y, z)
    translationMatrix(x, y, z)
    rotationMatrix(angle, x, y, z, matrix)
    asHomogeneous(x)
    asEuclidean(x)

    scale3d(obj, x, y, z, ...)
    translate3d(obj, x, y, z, ...)
    rotate3d(obj, angle, x, y, z, matrix, ...)

    transform3d(obj, matrix, ...)

### Arguments

`x, y, z, angle, matrix` | See details
`obj` | An object to be transformed
`...` | Additional parameters to be passed to methods

### Details

OpenGL uses homogeneous coordinates to handle perspective and affine transformations. The homogeneous point `(x, y, z, w)` corresponds to the Euclidean point `(x/w, y/w, z/w)`. The matrices produced by the functions `scaleMatrix`, `translationMatrix`, and `rotationMatrix` are to be left-multiplied by a row vector of homogeneous coordinates; alternatively, the transpose of the result can be right-multiplied by a column vector. The generic functions `scale3d`, `translate3d` and `rotate3d` apply these transformations to the `obj` argument. The `transform3d` function is a synonym for `rotate3d(obj, matrix = matrix)`.

By default, it is assumed that `obj` is a row vector (or a matrix of row vectors) which will be multiplied on the right by the corresponding matrix, but users may write methods for these generics which operate differently. Methods are supplied for `mesh3d` objects.

To compose transformations, use matrix multiplication. The effect is to apply the matrix on the left first, followed by the one on the right.

`identityMatrix` returns an identity matrix.

`scaleMatrix` scales each coordinate by the given factor. In Euclidean coordinates, `(u, v, w)` is transformed to `(x*u, y*v, z*w)`.

`translationMatrix` translates each coordinate by the given translation, i.e. `(u, v, w)` is transformed to `(u + x, v + y, w + z)`.

`rotationMatrix` can be called in three ways. With arguments `angle, x, y, z` it represents a rotation of `angle` radians about the axis `x, y, z`. If `matrix` is a 3x3 rotation matrix, it will be converted into the corresponding matrix in 4x4 homogeneous coordinates. Finally, if a 4x4 matrix is given, it will be returned unchanged. (The latter behaviour is used to allow `transform3d` to act like a generic function, even though it is not.)

Use `asHomogeneous(x)` to convert the Euclidean vector `x` to homogeneous coordinates, and `asEuclidean(x)` for the reverse transformation.

### Value

`identityMatrix`, `scaleMatrix`, `translationMatrix`, and `rotationMatrix` produce a 4x4 matrix representing the requested transformation in homogeneous coordinates.

`scale3d`, `translate3d` and `rotate3d` transform the object and produce a new object of the same class.

### Author(s)

Duncan Murdoch

### See Also

`par3d` for a description of how rgl uses matrices in rendering.

### Examples

    # A 90 degree rotation about the x axis:

    rotationMatrix(pi/2, 1, 0, 0)

    # Find what happens when you rotate (2, 0, 0) by 45 degrees about the y axis:

    x <- asHomogeneous(c(2, 0, 0))
    y <- x
    asEuclidean(y)

    # or more simply...

    rotate3d(c(2, 0, 0), pi/4, 0, 1, 0)

[Package rgl version 0.99.9 Index]