Trailing-Edge
-
PDP-10 Archives
-
decuslib10-06
-
43,50416/define.req
There are 2 other files named define.req in the archive. Click here to see a list.
COMMENT
.SEC(DEFINE.REQ - MACRO DEFINITIONS)
.INDEX(DEFINE.REQ - MACRO DEFINITIONS)
.;
"File: DEFINE.REQ"
COMMENT
.<< Peter Lemkin, Richard Gordon, Bruce Shapiro
. Image Processing Unit
. National Cancer Institute
. National Institutes of Health
. Building 36 Room 4D28
. Bethesda, Maryland 20014 USA
.
. Phone 301-496-2394
.
.May 24, 1976- Lemkin added additional DEBUG macros
. April 8, 1976- Shapiro- added DEBUG macros
. Feb 2, 1976 - Lemkin, added packed mask macros, to be debugged
. Feb 5, 1976 - Lemkin, debugging PACK2D
. Feb 8, 1976 - Lemkin, fixed mask macro addressing
. Feb 9, 1976 - Lemkin, Shapiro added boundary macros
. Feb 12, 1976 - Lemkin, Shapiro fixed boundary macros
. Feb 17, 1976 - Lemkin, added FETCH1D and PACK2D
. Feb 27, 1976 - Lemkin, added TICTACI1, TICTACI2, TICTACI3
. March 8, 1976 - Gordon and Lemkin, fixed PACK1D
.March 10,1976 - Shapiro, Lemkin changed macros so arguments
. expand correctly, added PUB stuff
.>>
DEFINE.REQ is a set of SAIL macro definitions used by
most of the programs in PROC10 and other IPU group programs. It
contains macros to fetch and store 1 and 2-D images, masks and
boundaries in addition to commonly used values
COMMENT
.ss(Delimiters used in DEFINE.REQ)
.index(Delimiters used in DEFINE.REQ)
.;
Require "{}{}" Delimiters;
COMMENT
.SS(Commonly used macro constants)
.index(Commonly used macro constants)
.;
Define crlf={('15&'12)};
Define pi={(3.14159265)};
Define twopi={(6.28318530)};
Define maxreal={(1.7@38)};
Define minreal={(-1.7@38)};
Define maxinteger={(34359738367)};
Define mininteger={(-34359738367)};
Define #={comment};
Define DEBUGR(X)={Outstr("(X)= "&cvf((X))&crlf)};
Define DEBUGI(X)={Outstr("(X)= "&CVS((X))&crlf)};
Define DEBUGO(X)={Outstr("(X)= "&CVOS((X))&crlf)};
Define DEBUGS(X)={Outstr("(X)= "&X&crlf)};
COMMENT
.SS(PPAK macros)
.index(PPAK macros)
.;
Comment variables for image macros;
Integer
m!l!a,
n!l!a,
l!s!a;
Comment Variables for new 1D macros;
Integer
word!with!pixel,
linear!address,
leftshift!in!word,
pixel!mod,
octal!digit,rotation;
COMMENT
.SSS(I!LOC)
.index(I!LOC)
.;
" The following macro returns word of the array (r,c)"
Define I!LOC(image,r,c) =
{(image[(n!l!a_((r) Lsh imshift)+(c)) Lsh -2])};
COMMENT
.SSS(L!MASK!OUT!BYTE)
.index(L!MASK!OUT!BYTE)
.;
" The following macro returns the word of the array(r,c) with
the selected byte zeroed"
Define L!MASK!OUT!BYTE =
{('777777777777 - ('777 Lsh
(l!s!a_(27-9*(m!l!a Land 3))) ))};
COMMENT
.SSS(FETCH2D)
.index(FETCH2D)
.;
" The following macro fetches a 9-bit byte from an image
specified by (r,c)"
Define FETCH2D(image,r,c) =
{('777 Land (I!LOC(image,(r),(c)) Lsh (-27+(9*(n!l!a Land '3))) ) )};
COMMENT
.SSS(FETCH1D)
.index(FETCH1D)
.;
Define FETCH1D(image,p) =
{('777 Land (image[(p) Lsh -2] Lsh (-27+(9*((p) Land '3))) ) )};
COMMENT
.SSS(PACK2D)
.index(PACK2D)
.;
" The following macro packs a 9-bit byte into an image
specified by (r,c). Note that it will eval the left (sink) subcript
first so that that computation can be used on the fetch."
Define PACK2D(image,r,c,data) =
{image[(((r) Lsh imshift)+(c)) Lsh -2]_
((image[(m!l!a_((r) Lsh imshift)+(c)) Lsh -2] Land
L!MASK!OUT!BYTE) Lor
(('777 Land data) Lsh l!s!a) )};
COMMENT
.SSS(TICTACI1)
.index(TICTACI1)
.;
" OUTSTR a tic tac toe image of I1"
Define TICTACI1 = "Outstr(
CVS(I13)&"" ""&CVS(I12)&"" ""&CVS(I11)&crlf&
CVS(I14)&"" ""&CVS(I18)&"" ""&CVS(I10)&crlf&
CVS(I15)&"" ""&CVS(I16)&"" ""&CVS(I17)&crlf&crlf)";
COMMENT
.SSS(TICTACI2)
.index(TICTACI2)
.;
" OUTSTR a tic tac toe image of I2"
Define TICTACI2 = "Outstr(
CVS(I23)&"" ""&CVS(I22)&"" ""&CVS(I21)&crlf&
CVS(I24)&"" ""&CVS(I28)&"" ""&CVS(I20)&crlf&
CVS(I25)&"" ""&CVS(I26)&"" ""&CVS(I27)&crlf&crlf)";
COMMENT
.SSS(TICTACI2)
.index(TICTACI2)
.;
" OUTSTR a tic tac toe image of I3"
Define TICTACI3 = "Outstr(
CVS(I33)&"" ""&CVS(I32)&"" ""&CVS(I31)&crlf&
CVS(I34)&"" ""&CVS(I38)&"" ""&CVS(I30)&crlf&
CVS(I35)&"" ""&CVS(I36)&"" ""&CVS(I37)&crlf&crlf)";
Comment New versions of 1D macros:
COMMENT
.SSS(PACK1D)
.index(PACK1D)
.;
Comment PACK1D is not protected against data outside of 0 leq data
leq 255;
Define PACK1D(image,pixel!1D!address,data)=
{image[word!with!pixel_
(pixel!1D!address) Lsh -2]_(image[word!with!pixel]
Land ( '777777777777-('777 Lsh
(leftshift!in!word_9*((pixel!1D!address)
Land 3)-27)))) Lor ((data) Lsh
leftshift!in!word))};
COMMENT
.SSS(PRFTCH)
.index(PRFTCH)
.;
comment PRPACK and PRFTCH are very fast one dimensional packing
and unpacking routines. The order of the 9 bit bytes is
reversed from that of the other macros. Consecutive bytes,
according to one dimensional addressing, are #'s 3, 2, 1, and 0
instead of 0, 1, 2, 3 (assuming bits are numbered from right to
left). To prepare a picture for use of these macros, call
PREVERSE. To restore a picture to the usual order, call
PREVERSE again. PRPACK and PRFTCH avoid a multiplication of the
byte position by 9 by noting that 0, 9, 18, and 27 = '00, '11,
'22, and '33.;
Define PRFTCH(image,pixel!1D!address)=
{('777 Land (image[(pixel!1D!address) Lsh -2] rot
-((octal!digit_(pixel!1D!address) Land 3) Lor
(octal!digit Lsh 3))))};
COMMENT
.SSS(PRPACK)
.index(PRPACK)
.;
Define PRPACK(image,pixel!1D!address,data)=
{image[word!with!pixel_ (pixel!1D!address) Lsh -2] _
image[word!with!pixel] Land ((
'777777777000 rot (rotation_((octal!digit_
(pixel!1D!address) Land 3) lor (octal!digit Lsh
3)))) lor ((data) rot rotation))};
COMMENT
.SS(Mask macros)
.index(Mask macros)
.;
Integer
ms!word!addr,
ms!linear!addr,
ms!shift;
COMMENT
.SSS(MSK!LOC)
.index(MSK!LOC)
.;
" The following macro returns word of the mask array (r,c)"
Define MSK!LOC(mask!image,r,c) =
{mask!image[(ms!word!addr_((ms!linear!addr_
((r) Lsh imshift)+(c)) %36))]};
COMMENT
.SSS(L!MASK!OUT!BIT)
.index(L!MASK!OUT!BIT)
.;
" The following macro returns the word of the array(r,c)
with the selected bit zeroed"
Define L!MASK!OUT!BIT =
{('777777777777 - (1 Lsh (ms!shift_35-
(ms!linear!addr-36*ms!word!addr))))};
COMMENT
.SSS(MSK!FETCH2D)
.index(MSK!FETCH2D)
.;
" The following macro fetches a 1-bit byte from a mask
image specified by (r,c)"
Define MSK!FETCH2D(mask!image,r,c) =
{(1 Land (MSK!LOC(mask!image,(r),(c)) Lsh
(-35+(ms!linear!addr-36*ms!word!addr))) )};
COMMENT
.SSS(MSK!PACK2D)
.index(MSK!PACK2D)
.;
" The following macro packs a 1-bit byte into a mask image
specified by (r,c)."
Define MSK!PACK2D(mask!image,r,c,data!bit) =
{MSK!LOC(mask!image,(r),(c))_
(MSK!LOC(mask!image,(r),(c)) Land
L!MASK!OUT!BIT)
Lor ((data!bit) Lsh ms!shift) };
COMMENT
.SSS(MSK!BOOL)
.index(MSK!BOOL)
.;
" The following macro boolean is used to determine
if a pixel is inside of a legal mask by returning true if
it is and false if it isn't"
Define MSK!BOOL(r,c) = {(If usemask
Then
MSK!FETCH2D({Datum(mskimage)},(r),(c))
Else true)};
COMMENT
.SS(Boundary macros)
.index(Boundary macros)
.;
Integer
bs!word!addr,
bs!linear!addr,
bs!shift;
COMMENT
.SSS(BND!LOC)
.index(BND!LOC)
.;
" The following macro returns word of the boundary array (r,c)"
Define BND!LOC(boundary,point) =
{boundary[(bs!word!addr_((point) Lsh -1))]};
COMMENT
.SSS(BND!MASK!OUT!BYTE)
.index(BND!MASK!OUT!BYTE)
.;
" The following macro returns the mask of the array(point)
with the selected 9-bits zeroed. note x!or!y is 1 for x, 0 for y"
Define BND!MASK!OUT!BYTE(point,x!or!y) =
{('777777777777 - ('777 Lsh (bs!shift_
(27-9*((((point) Lsh 1) Land '2)+
(x!or!y))) )))};
COMMENT
.SSS(X!BND!FETCH)
.index(X!BND!FETCH)
.;
" The following macro fetches a 9-bit X-byte from a boundary
image specified by (point)"
Define X!BND!FETCH(boundary,point) =
{('777 Land (BND!LOC(boundary,(point)) Lsh (-27+9*(
(((point) Lsh 1) Land '2) +
0) )))};
COMMENT
.SSS(Y!BND!FETCH)
.index(Y!BND!FETCH)
.;
Define Y!BND!FETCH(boundary,point) =
{('777 Land (BND!LOC(boundary,(point)) Lsh (-27+9*(
(((point) Lsh 1) Land '2) +
1) )))};
COMMENT
.SSS(X!BND!PACK)
.index(X!BND!PACK)
.;
" The following macro packs a 9-bit byte into a boundary image
specified by (point)."
Define X!BND!PACK(boundary,point,data!byte) =
{BND!LOC(boundary,(point))_
(BND!LOC(boundary,(point)) Land
BND!MASK!OUT!BYTE((point),0)) Lor
(('777 Land (data!byte)) Lsh bs!shift) };
COMMENT
.SSS(Y!BND!PACK)
.index(Y!BND!PACK)
.;
Define Y!BND!PACK(boundary,point,data!byte) =
{BND!LOC(boundary,(point))_
(BND!LOC(boundary,(point)) Land
BND!MASK!OUT!BYTE((point),1)) Lor
(('777 Land (data!byte)) Lsh bs!shift) };