matrix man page on Plan9

```MATRIX(2)							     MATRIX(2)

NAME
ident,  matmul,	matmulr,  determinant, adjoint, invertmat, xformpoint,
xformpointd, xformplane,	 pushmat,  popmat,  rot,  qrot,	 scale,	 move,
xform, ixform, persp, look, viewport - Geometric transformations

SYNOPSIS
#include <draw.h>

#include <geometry.h>

void ident(Matrix m)

void matmul(Matrix a, Matrix b)

void matmulr(Matrix a, Matrix b)

double determinant(Matrix m)

double invertmat(Matrix m, Matrix inv)

Point3 xformpoint(Point3 p, Space *to, Space *from)

Point3 xformpointd(Point3 p, Space *to, Space *from)

Point3 xformplane(Point3 p, Space *to, Space *from)

Space *pushmat(Space *t)

Space *popmat(Space *t)

void rot(Space *t, double theta, int axis)

void qrot(Space *t, Quaternion q)

void scale(Space *t, double x, double y, double z)

void move(Space *t, double x, double y, double z)

void xform(Space *t, Matrix m)

void ixform(Space *t, Matrix m, Matrix inv)

int persp(Space *t, double fov, double n, double f)

void look(Space *t, Point3 eye, Point3 look, Point3 up)

void viewport(Space *t, Rectangle r, double aspect)

DESCRIPTION
These  routines	manipulate  3-space  affine and projective transforma‐
tions, represented as 4×4 matrices, thus:

typedef double Matrix;

Ident stores an identity matrix in its argument.	 Matmul stores a×b  in
a.   Matmulr  stores  b×a in b.	Determinant returns the determinant of
matrix m.  Adjoint stores the adjoint (matrix of	 cofactors)  of	 m  in
madj.   Invertmat stores the inverse of matrix m in minv, returning m's
determinant.  Should m be singular (determinant zero), invertmat stores

The rest of the routines described here manipulate Spaces and transform
Point3s.	 A Point3 is a point in three-space, represented by its	 homo‐
geneous coordinates:

typedef struct Point3 Point3;
struct Point3{
double x, y, z, w;
};

The  homogeneous coordinates (x, y, z, w) represent the Euclidean point
(x/w, y/w, z/w) if w≠0, and a ``point at infinity'' if w=0.

A Space is just a data structure describing a coordinate system:

typedef struct Space Space;
struct Space{
Matrix t;
Matrix tinv;
Space *next;
};

It contains a pair of transformation matrices  and  a  pointer  to  the
Space's	parent.	  The matrices transform points to and from the ``root
coordinate system,'' which is represented by a null Space pointer.

Pushmat creates a new Space.  Its argument is a pointer to  the	parent
space.	Its  result  is a newly allocated copy of the parent, but with
its next pointer pointing at the parent.	  Popmat  discards  the	 Space
that  is	 its  argument,	 returning a pointer to the stack.  Nominally,
these two functions define a stack of transformations, but pushmat  can
be  called  multiple times on the same Space multiple times, creating a
transformation tree.

Xformpoint and Xformpointd both transform points from the Space pointed
to  by from to the space pointed to by to.  Either pointer may be null,
indicating the root coordinate system.  The difference between the  two
functions is that xformpointd divides x, y, z, and w by w, if w≠0, mak‐
ing (x, y, z) the Euclidean coordinates of the point.

Xformplane transforms planes or normal vectors.	A plane	 is  specified
by the coefficients (a, b, c, d) of its implicit equation ax+by+cz+d=0.
Since this representation is dual to the homogeneous representation  of
points, libgeometry represents planes by Point3 structures, with (a, b,
c, d) stored in (x, y, z, w).

The remaining functions transform the coordinate system represented  by
a  Space.   Their  Space * argument must be non-null — you can't modify
the root Space.	Rot rotates by angle  theta  (in  radians)  about  the
given  axis,  which  must be one of XAXIS, YAXIS or ZAXIS.  Qrot trans‐
forms by a rotation about an arbitrary axis, specified by Quaternion q.

Scale scales the coordinate system by the given scale  factors  in  the
directions  of  the three axes.	Move translates by the given displace‐
ment in the three axial directions.

Xform transforms the coordinate system by the  given  Matrix.   If  the
matrix's	 inverse  is known a priori, calling ixform will save the work
of recomputing it.

Persp does a perspective transformation.	 The transformation  maps  the
frustum with apex at the origin, central axis down the positive y axis,
and apex angle fov and clipping planes y=n and y=f into the double-unit
cube.  The plane y=n maps to y'=-1, y=f maps to y'=1.

Look  does  a  view-pointing transformation.  The eye point is moved to
the origin.  The line through the eye and look points is	 aligned  with
the  y  axis,  and  the plane containing the eye, look and up points is
rotated into the x-y plane.

Viewport maps the unit-cube window into the given screen viewport.  The
viewport	 rectangle  r has r.min at the top left-hand corner, and r.max
just outside the lower  right-hand  corner.   Argument  aspect  is  the
aspect  ratio  (dx/dy) of the viewport's pixels (not of the whole view‐
port).  The whole window is transformed	to  fit	 centered  inside  the
viewport	 with  equal  slop on either top and bottom or left and right,
depending on the viewport's aspect ratio.  The window  is  viewed  down
the y axis, with x to the left and z up.	 The viewport has x increasing
to the right and y increasing down.  The	 window's  y  coordinates  are
mapped, unchanged, into the viewport's z coordinates.

SOURCE
/sys/src/libgeometry/matrix.c

arith3(2)

MATRIX(2)
```
[top]
```                             _         _         _
| |       | |       | |
| |       | |       | |
__ | | __ __ | | __ __ | | __
\ \| |/ / \ \| |/ / \ \| |/ /
\ \ / /   \ \ / /   \ \ / /
\   /     \   /     \   /
\_/       \_/       \_/ ```

List of man pages available for Plan9

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

 Vote for polarhome  