matrix man page on Plan9

Man page or keyword search:  
man Server   549 pages
apropos Keyword Search (all sections)
Output format
Plan9 logo
[printable version]

MATRIX(2)							     MATRIX(2)

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

       #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)

       void adjoint(Matrix m, Matrix madj)

       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)

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

	      typedef double Matrix[4][4];

       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
       its adjoint in minv.

       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.



                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Plan9

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.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net