perm filename GEOMOD[6,BGB] blob sn#083863 filedate 1974-01-29 generic text, type C, neo UTF8
```COMMENT ⊗   VALID 00008 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002
C00005 00003	PRIMER
C00011 00004	PRIMER - EXAMPLE 1
C00013 00005	EUCLIDEAN TRANSFORMATIONS:
C00016 00006	CONTROL - SUBROUTINE CALLS.
C00025 00007	CONTROL -
C00028 00008	CONTROL -
C00033 ENDMK
C⊗;

This chapter explains  a package of subroutines,  GEOMOD, for
doing  geometric modeling  in SAIL or  LISP. Using  GEOMOD, arbitrary
polyhedra can be  contructed; moved about  and viewed in  perspective
with hidden lines  eliminated.  In addition to  polyhedra; camera and
image  models are  provided so  that simulators relevant  to computer
vision, problem solving,  and animation can be constructed.
PRIMER

This  first explaination  presents  a  subset of  GEOMES  for
construction  and animation  using  bricks. The  following discussion
refers to the sample program, TEST1.SAI  shown on the next page.   In
the  example,   GEOMES  is  declared  by  requiring the  source  file
GEOMES.HDR[GEM,HE];  GEM stands for Geometric Modeling; HE stands for
Hand/Eye.   When executed,  TEST1 displays one  cubic brick  tumbling
around another.

In GEOMES worlds,  windows, camera, bodies, faces,  edges and
vertices  are referred to  by integer pointers.  A world is  a set of
bodies; a camera is  a camera model; a  window ties pairs of  cameras
and worlds together;  and a body is a model  of a polyhedron composed
of faces,  edges and vertices. For this introduction, all bodies will
be rectangular right  prisms. To get the data structure  initialized,
write the following instruction:

GEONIT;

1st - POLYHEDRON OPERATIONS:

BODY ← MKCUBE(XSIDE,YSIDE,ZSIDE);	make cubic solid.
BODY ← MKCOPY(BODY);			make a copy.

The  routine  MKCUBE generates a rectangular right prism with
sides of length XSIDE, YSIDE and ZSIDE. The center of  the  prism  is
initially  at  the  world  origin,  (0,0,0).   The arguments are real
numbers representing feet. The initial camera is located sixteen feet
above  the X-Y plane and is looking down with a 12.5 millimeter lens,
which means that any block with sides less than 20 feet  will  be  in
view.  The routine MKCOPY will return a copy of its argument, the new
body will have the same location and orientation as the old one,  and
must be moved before doing a hidden line elimination.

WHOLE ← BATT(PART,WHOLE);	body attach.
PART  ← BDET(PART);		body detach.

The BATT routine attachs one body to  another  so  that  when
something  is  moved  or copied all its parts will be moved or copied
too. Naturally, parts may have subparts and so on. A  body  is  freed
from its role as a part of something by the BDET routine.
COMMENT PRIMER - EXAMPLE 1;
BEGIN "TEST1"
DEFINE α="COMMENT";
DEFINE π="3.1415927";
REQUIRE "GEOMES.HDR[GEM,HE]" SOURCE_FILE;
INTEGER B1,B2,F,E,V,V0,T;
INTEGER WORLD,WINDOW,CAMERA;

α UNIVERSE CREATION;

GEONIT;

α BODY CREATION;

B1 ← MKCUBE(4.0,1.0,2.0);      α MAKE RECTANGULAR PRISM;
B2 ← MKCOPY(B1);	       α COPY THE PRISM;

α ACTION;

FOR T←1 STEP 1 UNTIL 30 DO
OUTSTR(13&10);		α FLUSH THE PAGE PRINTER;
TRANSLATE(B1,0,0,4);		α 4 FEET +Z TOWARDS CAMERA;
ROTATE(B2,π/8,π/8,0);		α ROTATION ABOUT X & Y AXES;
WHILE TRUE DO
BEGIN
ROTATE(B1,0,-π/17,0);	α ROTATION CW ABOUT Y-AXIS;
FOR T←1 STEP 1 UNTIL 40 DO
BEGIN
ROTATE(B1,π/20,0,0);	α ROTATION CCW ABOUT X-AXIS;
ROTATE(B2,0,π/16,0);	α ROTATION CCW ABOUT Y-AXIS;
SHOW2(0,1);		α DISPLAY A SIMULATED IMAGE;
IF INCHRS≥1 THEN DONE;	α EXIT ON TYPE-ANY-KEY;
END;
END;

END "TEST1"; BGB 19 MARCH 1973.
EUCLIDEAN TRANSFORMATIONS:

TRANSLATE(OBJECT,DELTAX,DELTAY,DELTAZ);

The   TRANSLATE  routine  takes  four  arguments,  the  first
argument is the integer pointing at the thing to be  translated,  the
next  three  arguments  are real numbers indicating a displacement in
feet parallel to the X, Y and Z world axes respectively.   The  world
frame of reference is right handed and orthogonal.

The  ROTATE  routine takes four arguments, the first argument
is the integer pointing at the thing to  be  rotated,  and  the  next
three arguments are real numbers indicating a angular displacement in
radians about the X, Y and Z world axes  respectively.  The  positive
direction  of  rotation  is  counterclockwise; which is the so called
right hand rule convention.

IMAGE OPERATIONS:

INTEGER PROCEDURE SHOW1 (INTEGER WINDOW,GLASS);
INTEGER PROCEDURE SHOW2 (INTEGER WINDOW,GLASS);

There are  two simple  display operations:  SHOW1 and  SHOW2.
The  SHOW1 routine displays  all the  edges appearing in  the window.
The SHOW2  routine performs a  hidden line  elimination and  displays
only the  portions of edges that  are not hidden. Both  routines take
two  arguments, the first argument is the  window to be displayed and
the second  argument is  the number,  0 to 15,  of the  III piece  of
glass to which  the display buffer is sent.  When the Window argument
is zero the "now" window is used.

EXERCISES:

1. Make the tower shown in the figure using 1,2,4 bricks.
2. Make a table with four chairs. (use the BATT and MKCOPY).
3. Make a simulation of a small bouncing cube.
CONTROL - SUBROUTINE CALLS.

SHORT EXPLAINATION OF EACH SUBROUTINE.

Unless  otherwise  noted,   all  arguments  and   values  are
integers; subroutines  executed for effect return integer value zero.
The numeral  from [1] to  [7] indicate  the level  relevance of  each
subroutine to the user:

[1] very basic routines.
[2] routines important to the user.
[3] useful.
[4] frills.
[5] basic to the GEM system.
[6] arcane.
[7] under development.

[1] GEONIT;

Initializes the GEM node space; each call  on GEONIT begins a
brand new universe containing one world, camera and window.

[1] GEOMED;

Pass control  to the geometric editor,  GEOMED; which has its
own arcane jump table command scanner, display modes, I/O and  so on;
see the  GEOMED.BGB[S,DOC] operating  note for further  details. When
the  exit command "εE" is given, GEOMED  returns the node which is at
the top of its stack.

[1] GEODPY;

Default GEOMED display. Refresh the "now" display of GEOMED.

[2] SHOW1(WINDOW,GLASS);

Display all the edges of all the objects of  the world of the
given window (or  the "now" window if the window  argument is 0). The
GLASS is  an integer  between 0  and '17;  GLASS corresponds  to  the
system's pieces of glass; use GLASS set to 1  if you do not know what
a  piece of glass  is. The command  SHOW1(0,1) is the  fastest way to
display the "now" world.

SHOW2(WINDOW,GLASS);

Display all the visible edges of all the objects of the world
of the given window (or the "now" window if the window argument is 0).
SHOW2 calls the hidden line eliminator OCCULT.

SHOW3(WINDOW,GLASS);

Display all the faces that are towards the camera. SHOW3 is about
as fast as SHOW1, but with the back sides of everything being hidden.

BODY ← IGEM(STRING FILENAME);
OGEM(STRING FILENAME; BODY);

Input and output routines for GEM file format polyhedra.
If the file isn't found then IGEM returns a zero.

FRAME ← TRANSLATE(ENTITY; REAL DELTAX,DELTAY,DELTAZ);
FRAME ←    SHRINK(ENTITY; REAL SCALEX,SCALEY,SCALEZ);

When  the  ENTITY argument  is  non-zero,  these  subroutines
perform   the   indicated   Euclidean  Transformation:   translation,
rotation, dilation and reflection. When the ENTITY argument  is ZERO,
then  a  FRAME  node   representing  the  desired  transformation  is
returned.
CONTROL -

FRAME ← APTRAN(ENTITY,FRAME);

Apply a  Euclidean Transformation  to an  ENTITY; the  entity
may be a Body, Face, Edge, Vertex, Camera or Frame.

FRAME ← INTRAN(FRAME);

Invert a  Euclidean Transformation; the invert of a Euclidean
Transformation will undo the given transformation.

REAL_DEL ← DISTAN(V1,V2);

Given to vertices, return the distance between them.

NODE ← MKNODE(TYPE);

Make (that is allocate)  a 12 word GEM node  with the integer
TYPE in it word 0.

KLNODE(NODE);

Kill node (that is release) a 12 word GEM node.

WORLD ← MKWORLD;

Make world,  adds  a new  world at  the end  of the  universe
node's  world  ring. The  first  world of  the  universe  is accessed
W1←PWRLD(UNIVERSE); the remaining  worlds are accessed  W2←PWRLD(W1);
W3←PWRLD(W2); until  the ring  points to the  first world  again. The
world ring is never empty.

CAMERA ← MKCAMERA(WORLD);

Make a camera in a given world; if the world argument is zero
the default world is the "now" world.

NEW_WINDOW ← MKWINDOW(CAMERA,OLD_WINDOW);

CAMERA  argument may  be  zero  (uses "now"  camera);  WINDOW
argument may be  zero to create a new display ring; otherwise the new
window is  placed into  the display  ring of  the  given window.  The
universe has a ring of displays;  only the "now" display is refreshed
by  the subroutine  GEODPY; a  display is  a ring  of windows;  and a
window merely points to a camera, which points at a world.
CONTROL -

INVERT(EDGE);

An edge is a directed vector with a positive and a negative
vertex; INVERT flip the orientation of an edge vector and returns the
same edge.

EVERT(BODY);

Evert  turns  a  body  inside  out,  or  vice  versa.  A  GEM
polyhedral  surface  has an  inside  and an  outside;  the  inside is
defined by the orientation of  the four wing pointers in edge  nodes;
the evert primitives  changes the order of these pointers  in all the
edges of the given body.

VNEW ← MKEV(FACE,VERTEX);

Make a new edge and a new vertex in the given FACE from the
given VERTEX; the new vertex is return, VNEW; the new edge can be
accessed by taking PED(VNEW).

ENEW ← MKFE(V1,FACE,V2);

Make a new face and a new edge by joining V1 and V2 of FACE.
The new edge is returned, ENEW; the new face may always be obtained
by taking NFACE(ENEW).

VNEW ← ESPLIT(EDGE);

Make a new edge and a new vertex, VNEW; the new edge may
be obtained by taking PED(VNEW); the new edge is place between
VNEW and PVT(EDGE).

```