Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
MATRIX(3)		   Library Functions Manual		     MATRIX(3)

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)

       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)

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

	      typedef double Matrix[4][4];

       Ident stores an identity	matrix in its argument.	 Matmul	stores axb  in
       a.   Matmulr  stores  bxa 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 wa 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 wa 0,
       making (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 ma-
       trix'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 ro-
       tated 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  as-
       pect  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
       /usr/local/plan9/src/libgeometry/matrix.c

SEE ALSO
       arith3(3)

								     MATRIX(3)

NAME | SYNOPSIS | DESCRIPTION | SOURCE | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=matrix&sektion=3&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help