.SEC(Introduction)
.index(Introduction)
PROC10, an interactive image processing system,
currently runs on the PDP10 at the National Institutes of
Health. It can manipulate picture, mask, boundary, boundary
transform and computing window data structures. PROC10
provides a wide range of operations on and between these data
structures. Images and boundaries may be displayed on several
different types of terminals including the DEC GT40, Tektronix
4012 and 4023 terminals, and ASR33. This document is oriented
toward describing the system from the point of view of a user.
PROC10 is written in PDP10 SAIl [VanL73].
.index(PROCES system)
.index(RTPP)
.index(DDTG)
It is an enhanced version of the PROCES interactive
image processing program [Lem75] which runs on the PDP8e part
of the Real Time Picture Processor (RTPP) ([Lem74], [Carm74],
[Lem76a]) at the Image Processing Unit, National Cancer
Institute. PROC10, written in SAIL [VanL73], includes all
of the RTPP PROCES operations. The philosophy of the
PROC10 system is that one brings image, mask or boundary DDTG
[Lem76b] data files into core, operates on them and then saves
them as DDTG formated data files (to be discussed).
Alternatively, data may be read into the program as Ascii
numbers (to be discussed) and converted to the format used by
PROC10. The final state of a PROC10 session may be saved
(including images, masks etc.) and reentered later.
.index(Display terminals)
PROC10 can display gray scale images and boundaries on
any of four terminals: ASR33 type terminal, Tektronix 4012
(see [Gor76]) or 4023, or DEC GT40 as well as printing images
on a lineprinter in various dump modes. Pictures, boundaries
and transforms may be written out as PDP10 files. Picrutures
and boundaries are in a format which can be read by the RTPP
for display on the DICOMED or video displays.
.index(DO - I/O)
.index(Command entry)
Commands are entered one per line from the display
terminal teletype. Alternatively, sequential commands may be
entered indirectly via a command file using the DO <file
specification> construction.
.index(User aids)
The system contains many user aids. Type HELP to get
further instructions. To get a list of all of the possible
commands, type CMD followed by the carriage return key. All
commands are terminated by typing the return key.
To find out the specific syntax and semantics of a
particular command, type
.index(HELP)
HELP <specific command>
Commands with the "TOGGLE" postfix act to reverse the
current sense of the switch associated with the command. For
example, TIMERTOGGLE turns the command execution time timer on
and off with successive invocations.
Commands may be entered as short forms with enough letters
(minimum of 3) for the system to guess it uniquely. Further
prompts are given if required. Commands are of two distinct
forms as expressed in the following BNF-like specifications
(where ' _ ' is the backarrow character):
.group
[1] <command> <arguments separated by spaces or commas>
or
<command> <name>
[2] <name>_<name><operator><name>,<opt. args>,<opt. mask>
or
<name>_<unary operator><name>,<opt. args>,<opt. mask>
Where: <name>::= <DSK: file> | <window> | <pix> | <mask> |
<boundary> | <boundary transform>
<window>::= W1 | W2 | .. | W32
<pix>::= P1 | P2 | .. | P32
<mask>::= M1 | M2 | ... | M32
<boundary>::= B1 | B2 | ... | B32 | <segment boundary>
<segment boundary>::= B33 | B34 | ... | B300
<boundary transform>::= T1 | T2 | ... | T32
.apart

.SS(Automatic data structure allocation)
.index(Automatic data structure allocation)
As is common in other interactive languages (such as
MLAB [Knott73], PRDL [Lem76c]) the use of a data structure name
as an output operand (such as P1 in P1_READ MAR001.PIX) will
cause computer storage to be allocated for that data structure
the first time it is used. This eliminates the need to either
allocate storage when the system is loaded or to have the user
request (via the program) storage explicitly. This implicit
storage allocation holds for pictures, masks, boundaries,
boundary transforms and computing windows. This storage is
automatically allocated using the LEAP 'ITEMS' with associated
integer array datums (For those who are interested in this
mechanism, see SAIL manual for discussion of items and datums
[VanL73].).
While data structures are automatically created when
the name of the structure is used as an output operand, they
must be explicitly deleted using the DELETE command. If a data
structure such as P3 contains an image which is no longer
needed and the user wishes to use P3 to hold the result of
another operation, then by just using it in that operation the
old contents of P3 are replaced with the new contents. Thus the
DELETE command should be used only when no further use of an
image or boundary structure is intended.

.SS(Image data structures)
.index(Image data structures)
Images are referenced by their picture name Pi (i in
the interval [1:32]) and are power of 2 size square integer
arrays of density values with the largest size being 256x256
pixels and the smallest 16x16. The pixels are packed 4
pixels/PDP10 36-bit word (so that a 256x256 (65K pixels)
occupies 16K PDP10 words.) Thus a pixel may have a maximum gray
value of 511 taking 9-bits.

.SS(Logical Coordinate System - LCS)
.index(Logical Coordinate System - LCS)
.index(LCS)
.index(SETLCS)
.index(RTPP)
.index(DDTG)
The Logical Coordinate System (LCS) of image
coordinates is that used by the RTPP and DDTG display systems.
The LCS is used to position an image on the display terminal.
The LCS has the origin (x,y) = (0,0) at the upper left-hand
corner and (x,y) = (1023,1023) at the lower right-hand corner
(as a maximum which only exists on certain devices - see
[Lem76a]). Positive X is to the right and positive Y is down.
There are no negative coordinates. The LCS is specified by
setting the upper-left hand corner of the image using the
SETLCS <x>, <y> command in PROC10. The default LCS value is
(0,0) for the ASR33, TK4023 and (256,256) for the DEC GT40 and
Tektronix 4012. The latter default is done to allow the user
room on the screen to type a few PROC10 command lines starting
at (0,0) after an image is displayed.
Not to be confused witht the full LCS just described is
a relative LCS of size [0:n-1,0:n-1] where n is the size of the
image. The relative LCS is used in seting the computing window
and in the SEGMENT operations as well as other operations.

.SS(Density values)
.index(Density values)
.index(SETDENSITY)
.index(SETSCALING)
.index(SLICE)
.index(AREA)
.index(DENSITY)
.index(PERIMETER)
.index(MSLICE)
Various operations use density threshold values as
inputs. These are supplied explicitly in the arguments of the
operation. A global threshold value is available for use by
some of the commands (SLICE, AREA, DENSITY, PERIMETER, MSLICE,
etc). It is set via the SETDENSITY command or in the EXTREMA
operation and used in for a command by specifying the
USETHReshold switch. SETDENSITY permits setting the
global density threshold.
.index(Maximum computing density)
.index(Threshold density)
.index(Display max and min densities)
.index(Display scaling)
.index(Display gamma correction)
The maximum computing density value is the largest
number (which is a power of 2 less 1, i.e. 1, 3, 7, 15, 31, 63,
127, 255, 511) to be allowed in a gray scale calculation. It
can not be larger than 9 bits (511). It is used in all gray
scale operations where a new gray scale value is computed such
that all computed gray values are clipped to this maximum
computing density value. It is specified using the SETDENSITY
command and has a default of 255.
Images as defined internally in PROC10 can store up to
9-bits of gray scale, while image files can store up to 8-bits
maximum. The density mapping is 0 (minimum density) is
white and 255 (maximum density) is black). Internally,
grayscale arithmetic operations are performed with clipping
such that if the resultant gray value is < 0 it is set to 0; if
it is > the maximum computing value it is set to the maximum
computing value.
The SHOW command uses two dynamic-range density values
(dmax,dmin) which are defined with the SETDENSITY command.
The default (dmax,dmin)=(255,0).
Gamma correction is performed using the scaling factor
(set using the SETSCALING command). The default scaling is 0.
No gamma correction is performed if the scaling is 0. That is,
for a display with N possible display gray levels (including
blank) the dynamic range of the data is adjusted so that for
display level d(x,y) and gray level g(x,y):
If scaling=0
Then d(x,y)=(N/(dmax-dmin))*(g(x,y)-dmin)
Else d(x,y)=N*scaling*(g(x,y)/(dmax-dmin))

.SS(Computation windows)
.index(Computation windows)
.index(SETWINDOW)
.index(GETWINDOW)
.index(SAVEWINDOW)
.index(FINDWINDOW)
.INDEX(SETSIZE)
.INDEX(ZOOM)
Operations are performed over a computation window
defined by the 4-tuple (firstrow, lastrow, firstcolumn,
lastcolumn). That is, the computation is performed only over
that rectangular region of the image upon which the window
covers. The computation window may be saved and restored
under the names Wi (i in [1:32]) using the SAVEWINDOW and
GETWINDOW commands. All image operations are performed over the
computation window. Initially, this window is set to the full
picture size (256x256) but may be changed by the SETWINDOW,
SETSIZE, or FINDWINDOW operations. If masks are used with
picture operations, the actual computation domain is the
logical AND of the two.
.index(RTPP)
.index(DDTG)
A default window of 256x256 pixels is used throughout
the PROC10, RTPP, and DDTG systems. When the image size is
changed in PROC10 to another size NxN using the SETSIZE <N>
operator, then the computing window is reset to the full window
(NxN) for the new image size. Note that N will be rounded up
to the first power of 2, such that N is less than or equal to
2**j. This window is the default computing window in PROC10.
To avoid confusion, it is noted here that when sampling is
mentioned in PROC10, it refers to the sampling for the display
but not for general computation, sampling is only done on
display operations and in the ZOOM operation.

.SS(Mask data structures)
.index(Mask data structures)
Masks are power of 2 size square arrays (as are images)
of 0's and 1's. Most picture operations may be performed under
a mask which is to say that only those parts of the images
lying within the mask will be operated upon. If a mask Mi is
mentioned in an image operation then the operation is performed
on only those pixels for which Mi(r,c)=1. An example of the
syntax is:
P2 _ GRAD8 P1,M7.
.INDEX(MCIRCLE)
.INDEX(SPHERE)
.INDEX(SQUARE)
.INDEX(MRECTANGLE)
.INDEX(MSLICE)
.INDEX(MSEGMENT)
Masks may be created using various mask generators some
such as MCIRCLE, SPHERE, SQUARE and MRECTANGLE are
parametrically specified while others such as MSLICE and
MSEGMENT create masks from performing operations on images.

.SS(Resultant images)
.index(Resultant images)
.index(SEGMENT)
.index(MSEGMENT)
The image resulting from an image operation is a
displayable gray scale image. The one exception is the SEGMENT
operator. This operator produces an image consisting of labeled
components which have connected region pixel values
corresponding to the component number. Component numbers are in
the range [1:253] whereas background pixels are defined by a 0
value. The mask MSEGMENT operator will generate a mask from
such a connected component image given the image and the number
of the connected component. That is, those portions of the
segmented image containing the desired component number will
cause a 1 to be placed in the corresponding mask position.
The resultant pixels of image and mask operations are a
subset of all possible pixel locations in the output image or
mask (i.e. of maximum image size). In the case of pictures,
this domain is restricted by the computing window and optional
masks. In the case of masks, the domain is restricted by the
computing window and the mask generator if used. Thus, if the
same output operand (such as P3 or M4 etc.) is used for several
different operations, then a composite image or mask is
created. This is possible since performing an operation on an
existing output operand does not zero it before doing that
operation.

.SS(Boundary and boundary transform data structures)
.index(Boundary and boundary transform data structures)
.INDEX(SEGMENT)
A boundary is a 2xN array defined by the user with name
Bi (i in [1:32] for user defined boundaries) or Bi (i in
[33:300]) defined by the SEGMENT operation where n is the
number of boundary pixels.
.INDEX(MAKPIX)
.INDEX(Fourier transform)
.INDEX(Walsh transform)
.INDEX(Circle transform)
The picture operator MAKPIX maps a one-dimensional
boundary Bi into a two-dimensional picture by coloring in
pixels in Pi. Boundaries may be operated on using either
boundary or boundary transform operators. The latter have
data structure names (T1, T2, ...). The transform operators
include the circle, complex and centroid Fourier, and centroid
Walsh transforms ([ShapB76a], [ShapB76b]) as well as their
inverses.

.SS(Display of Images and boundaries)
.index(Display of Images and boundaries)
.INDEX(SHOW)
.INDEX(Display sampling distance)
.INDEX(SETSAMPLE)
PROC10 offers two display modes (not to be confused
with types of display terminals). These are gray scale display
of images invoked by doing SHOW Pi, and line drawing displays
of boundaries (or parts of boundaries) invoked by doing SHOW
Bi. The parameter 'sampling distance' (set by SETSAMPLING) is
used to specify the picture sampling distance for doing a
grayscale image SHOW. For gray scale images, as was mentioned
before in the section on density values, linear or gamma
corrected density mapping is performed on the image gray values
to form the display density values.
.INDEX(PRINT)
The command PRINT Pi causes pictures within the
computing window to be printed on the lineprinter or teletype
as either 8 level gray scale, single character hexidecimal or
as (0-511) decimal numbers. Both SHOW Pi and PRINT Pi will do
output only from that part of Pi inside the computing window.
.SSS(Omni pictures)
.index(Omni pictures)
.index(OMNIGRAPH)
.index(PARAMETERS)
.index(Movies)
.index(Active Omni picture)
.index(AUTOOMNITOGGLE)
.INDEX(POSTOMNI)
.INDEX(UNPOSTOMNI)
.INDEX(KILLOMNI)
.INDEX(DOOMNI)
If either the GT40 or Tektronix 4012 display terminals
are used, it is possible to have more than one picture
displayed at a time. This mechanism is implemented using the
PDP10 OMNIGRAPH software [CCB76]. In OMNIGRAPH, pictures
correspond to data structures called 'display files'. In
PROC10, these display files are referenced by Pi or Bi data
structure names. The PARAMETERS command will list the names of
the active posted (displayed) and unposted display files which
have been taken off of the display.
The PROC10 default is to have only one active OMNI
picture at a time. To display multiple pictures (boundaries,
or histograms), the AUTOOMNITOGGLE command may be invoked.
When on, every displayable data structure picture, histogram or
boundary will be assigned a unique Omni picture display file
when that structure is requested to be displayed. Furthermore,
the image will remain on the display screen until a request is
made by the user to unpost or kill it (UNPOSTOMNI or KILLOMNI).
An unposted Omni picture may be restored to view by doing a
POSTOMNI on the previously unposted picture. In the case of
the Tektronix 4012 terminal, these display commands are not
activated until the DOOMNI command is invoked.
.SSS(PROC10 Movies)
.index(PROC10 Movies)
It is possible to construct a sequence of picture
frames which may be displayed in a particular order. This
structure is called a movie. Only one movie may be constructed
at a time. The movie can be shown on any terminal. However, if
a GT40 is used and Omni numbering is on, once pictures are sent
to the GT40, future showings of the movie will preceed at a
rapid rate. If on the otherhand the display is not setup like
this, then the pictures must be transmitted from the PDP10
frame by frame and no rapid frame change rate is possible.

.SS(State of PROC10)
.index(State of PROC10)
.index(ACTIVEDATA - STATE)
.index(Setting parameters with SET- commands)
.index(PARAMETERS - STATE)
The state of PROC10 in between picture operations may
be determined by the user. The command PARAMETERS may be used
to print the values of the density setting, active computing
and sampling windows; the display terminal type; lists of
posted, unposted and movie picture names; and state of the
automatic titling and OMNI switches.
The command ACTIVEDATA may be used to print the names,
titles, and associated parameters of the pictures, boundaries,
masks and saved computing windows defined in the system to
date.
Various other parameters may be set using one of the
SET- commands such as SETDENSITY, SETTITLE etc. Typing a SET-
command without arguments causes the old parameter values to be
typed followed by a request for the new values (if different).

.SS(Data File Format)
.index(Data File Format)
Pictures are (2**N)x(2**N) pixel 8-bit gray level
images. Masks are (2**N)x(2**N) pixel 1-bit images. Boundaries
are variable length arrays of (x,y) 8-bit bytes with a
(0,0),(0,0) at the end of the list to denote end of list.
Transforms are one-dimensional 36-bit arrays with every N words
of data constituting an entry depending on the type of
transform being represented.
.index(DDTG)
PROC10 is able to read PDP10 data files in both DDTG
format and as a list of Ascii numbers. The former mode
incorporates a file header which serves as a check on the
validity of the data (since data file typing is used) as well
as providing the data structure size (i.e. image size) and
title information. The NUMBER mode (used with the READ
command) allows access to PROC10 from scanners, etc., different
from those producing DDTG formated files. NUMBER input mode
accepts (2**Nx2**N) Ascii gray values specified in the file as
numbers separated by spaces or commas where carrage return/line
feeds are ignored. The size 2**N must be set previous to
executing the READ command by doing a SETSIZE command. PROC10
only writes DDTG formatted files.
Picture files are currenly being transmitted between
the RTPP and the PDP10 via PDP10 DECTAPE or MAG10/MAG8e
[Shap76c].
The Optronics rotary scanning densitometer produces
raster scan data with windows much larger than 256x256. A
program written by B. Trus and R. Gordon called OP.EXE[606,552]
with command file OP.CMD[606,552] is used to extract 256x256
pixel square windows for use as "NUMBER" formated files for
input to DDTG.
The DDTG format is described in the DDTG users manual
[Lem76b] as well as IO.SAI in a table listing the formats and
characteristics of the different data file types. It is
fairly easy to write conversion programs to take power of 2
size gray scale images in other formats and generate DDTG
compatible files using procedures in IO.SAI. Such files could
then be accessed by PROC10.

.group
.SS(Neighborhood definition)
.index(Neighborhood definition)
The current neighborhood of an image is a 3x3
rectangular array of image gray values which is tesselated
through the image according to the particular operation. The
pixels are labeled as follows for the PROC10 operations
which will be discussed:
3 2 1
4 8 0
5 6 7.
.apart

.SS(Border definition in neighborhood operations)
.index(Border definition in neighborhood operations)
In certain neighborhood operations which map
neighborhoods to pixels (such as GRAD4/8, LAPLACE8, EXPAND,
SHRINK, etc.) the border pixels of the computing window are not
defined. The system default is to set these pixels to zero. A
better default which may be used in the future is to set these
border pixels to adjacent values.

.SS(PROC10 command files)
.index(PROC10 command files)
.index(DO - I/O)
.index(ENTER2001)
.index(LEAVE2001)
All teletype command input to PROC10 may be specified
indirectly through a PDP10 command file. The DO <file
specification> command is used to direct PROC10 to accept input
from the specified file rather than from the teletype. Command
files are useful in applying a sequence of operations to an
image after the sequence has been interactively developed.
The ENTER2001 and LEAVE2001 commands allow the user to
go back and forth between PROC10 and the PDP10 monitor (via a
pseudo teletype) without detaching the PROC10 job. DO files can
then easily be created or modified with a text editor such as
TECO or SOS while in 2001 mode.

.SS(Addition of new operations and data structures to PROC10)
.index(Addition of new operations and data structures to PROC10)
Currently, new operations are added by editing the new
procedures and command information into the PROC10 parser and
interpreters as well as implementing the actual operation in a
'worker' package. The system must be recompiled, loaded and
saved.

.SEC(PROC10 Operators)
.index(PROC10 Operators)
The following four subsections list the special,
picture, mask and boundary operators. Note that some operators
such as READ, WRITE, DELETE, SHOW, etc. appear in several of
these operator lists. The particular command implied is
determined by the context in which the operator is used. Thus
DELETE W1 will delete window #1 while DELETE P2 will delete
image 2.

.SS(PROC10 Special Commands)
.index(PROC10 Special Commands)
PROC10 special commands operate across all data
structures or are generally data structure independent,
compared to the specific picture, mask and boundary operators
to be discussed in later sections.
.group
.SSS(HELP)
.index(HELP)
The HELP command is used to supply information about
the PROC10 system in general (no arguments used) or the syntax
and semantics of specific commands. In the latter case, the
HELP is followed by the command in question. The file
PROC10.HLP is searched for numbered paragraphs for the
specified command. If the command does not exist in PROC10 a
message to that effect is printed.
HELP <Opt. command name>
.apart
.group
.SSS(ACTIVEDATA - STATE)
.index(ACTIVEDATA - STATE)
Print the names and related parameters of the entire
data base, selected data structures, or of a particular data
structure (i.e. P3 or B6 etc). If a boundary was created using
the SEGMENT operation, then an association exists between the
resultant connected component image and each boundary
associated with a connected component. This association has a
property list consisting of (component number, first row of
boundary, first column of boundary, area, number of boundary
pixels, density, boundary name, touching computing window
predicate, component image name). The property list for each
associated boundary is printed with the connected component
image information.
ACTIVEDATA <opt. Pix, Mask, Boundary, Transform
or Window> --or--
<Opt. specific Pi, Mi, Bi, Ti, or Wi>
.apart
.group
.SSS(AUTOTITLETOGGLE)
.index(AUTOTITLETOGGLE)
AUTOTITLETOGGLE turns the automatic titling on or off
each time the command is executed. When on, auto-titling will
use as the title of the current output data structure the
command used to generate it. When it is off, the title is
requested from the user.
AUTOTITLETOGGLE
.apart
.group
.SSS(CMD - HELP)
.index(CMD - HELP)
CMD prints the lists of all the legal PROC10 commands
available. It may also be used with a modifier to print a
subset of these commands.
CMD <Opt. Commands or Picture or Mask or Boundary>
.apart
.GROUP
.SSS(DELETE)
.index(DELETE)
DELETE deletes from the data base the previously saved
computing window Wi. The saved window Wi was the 4-tuple
(first row, last row, first column, last column).
DELETE <Window Wi>
.APART
.GROUP
.SSS(ENDSESSION)
.index(ENDSESSION)
The ENDSESSION command exits PROC10 and return to the
PDP10 monitor. The core image may then be saved at PDP10
monitor level by doing a SAVE <session file name> or NSAVE
<session file name>. The session core image may be restarted at
a future time by doing a GET <session file name>, REENTER PDP10
monitor command sequence.
ENDSESSION
.APART
.GROUP
.SSS(GETWINDOW)
.index(GETWINDOW)
GETWINDOW is sued to restore a previously saved
computing window. It sets the current computing window
(first row, last rows, first column, last column) and image
size to that of the previously saved computing window Wi.
GETWINDOW <Window Wi>
.APART
.GROUP
.SSS(PARAMETERS)
.index(PARAMETERS)
The PARAMETERS command prints the values of various
parameters which comprise the state of the PROC10 system. These
include: WHITENOISE mean and standard deviation of the
generator densities; global threshold; SHOW min and max display
densities, display sampling distance, display terminal type,
gray scale scaling ratio (for display); computing window;
autotitling switch; autoOMNI numbering switch; pictures in the
post, unpost and movie lists.
PARAMETERS
.APART
.GROUP
.SSS(SAVEWINDOW)
.index(SAVEWINDOW)
SAVEWINDOW saves the current computing window
(first/last rows, first/last columns) and image size (a title
for this saved state will be requested) as a window data
structure.
SAVEWINDOW <Window Wi>
.APART
.GROUP
.SSS(SETDENSITY)
.index(SETDENSITY)
Various density related parameters are used in many
PROC10 operations. In particular, SETDENSITY may set the
global threshold (for use with SLICE, AREA, DENSITY, etc.) and
maximum black density in bits (i.e. 8 bits is 256 gray levels).
It also sets the min and max display densities used in the SHOW
operation.
SETDENSITY <thresold dens>, <compute density precision>,
<min display density>, <max display density>
.APART
.GROUP
.SSS(SETSAMPLING)
.index(SETSAMPLING)
The display sampling distance refers to the inter-pixel
distance used in image displays with the SHOW command. If it is
>0 then the sampling square with the sample pixel in the upper
left hand corner averaged and this average displayed. If the
sampling distance is <0 then the sample pixel is displayed
without averaging. Note that when sampling is done, thin edges
may not appear due to the position of the edge relative to the
sampled pixel.
SETSAMPLING <distance: (>0) to avg, (<0) to not avg display)
.APART
.GROUP
.SSS(SETSIZE)
.index(SETSIZE)
Image computations are performed on images of fixed
sizes. The current image size must be a power of 2. This size
is set using the SETSIZE command which sets the working image
size to the nearest power of 2 which will hold the image of the
size specified. The computing window is opened up to the full
window for this computed power of 2.
SETSIZE <Image size i.e. 16 through 256>
.APART
.GROUP
.SSS(SETTERMINAL)
.index(SETTERMINAL)
The SETTERMINAL command sets the current display device
to the type specified. Note that if your terminal is neither a
DEC GT40, Tektronix 4012 or 4023 then assign the ASR33 teletype
like terminal. The DEC GT40, Tektronix 4023 and ASR33 have 8
simulated density levels while the Tektronix 4012 has 17
simulated density levels.
SETTERMINAL <Terminal type ASR33, GT40, 4012, 4023>
.GROUP
.APART
.SSS(SETTITLE)
.index(SETTITLE)
Every data structure (picture, boundary, mask, boundary
transform, window) has an associated title which is used during
I/O, display (via SHOW), or during state interrogation
(ACTIVEDATA). The SETTITLE allows the user to change (or
specify) the title of the specified data structure.
SETTITLE <Picture, Mask, Boundary, Transform,
or Window name>
.APART
.GROUP
.SSS(SETWINDOW)
.index(SETWINDOW)
The computing window is a 4-tuple (first-row, last-row,
first-column, last-column) which is used in most image and mask
operations to specifiy the region of active computation. It may
be specified or changed using the SETWINDOW command.
SETWINDOW <First row, last row, first column,
last column>
.APART
.GROUP
.SSS(SETLCS)
.index(SETLCS)
The position of the display window upper left hand
corner is defined in the logical coordinate system (LCS).
Theupper left hand corner of the image is denoted by (Xp,Yp) in
PROC10. The LCS as was mentioned before has (0,0) as the upper
left hand corner and (1023,1023) as the lower right hand
corner. The SETLCS command changes the values of (Xp,Yp). The
Tektronix 4012 display has an active LCS region (0:779,0:779),
the DEC GT40 (0:769,0:769), and the Tektronix 4023 (0:80,0:24).
As the range of the LCS for the ASR33 and Tektronix 4023 is
very small it only makes sense to change the LCS for the DEC
GT40 or Tektronix 4012.
SETLCS <Display XP upper L.H.C.>,<YP upper L.H.C>
.APART
.GROUP
.SSS(TERSE)
.index(TERSE)
Two question and answer interaction modes are available
(verbose and terse). The TERSE command sets PROC10 to a terse
question and answer mode. Terse mode is the default.
TERSE
.APART
.GROUP
.SSS(TIMERTOGGLE)
.index(TIMERTOGGLE)
TIMERTOGGLE turns the timing switch on or off each time
it is executed. When on, it prints the CPU, RUN and
(CPU/RUN)*100% times taken for each user directed operation.
TIMERTOGGLE
.APART
.GROUP
.SSS(VERBOSE)
.index(VERBOSE)
Two question and answer interaction modes are available
(verbose and terse). The VERBOSE command sets PROC10 to a
verbose question and answer mode for more informative prompts.
Terse mode is the default.
VERBOSE
.APART
.GROUP
.SSS(DO - I/O)
.index(DO - I/O)
The DO command executes an Ascii command file which
contains a list of commands and expected responses to command
questions. It replaces the user commands and responses usually
entered from the teletype. The use of the Do files facilitates
the implementation of image processing procedures.
DO <Opt. Dev:><Command file><Opt. [Proj,Prog]>
.APART
.GROUP
.SSS(ENTER2001)
.index(ENTER2001)
It is sometimes useful to leave the PROC10 command
structure and enter the PDP10 monitor. This is done by issuing
the ENTER2001 command and having subsequent teletype I/O
communicate with the PDP10 monitor through a pseudo teletype.
Upon entering the pseudo teletype connection all output send to
you by the PDP10 is prefaced with a "<" and all input expected
of you is promted by a ">". Having set up the pseudo teletype
channel, you may log in again. This permits the interrogation
of directories, text editing, etc. without leaving the PROC10
core image. Typing LEAVE2001 returns you to PROC10. Don't
forget to logoff while talking to the PDP10 monitor before
returning to PROC10. Also, if you control/C out of 2001, the
2001 job you may have created will become detached.
ENTER2001 (type LEAVE2001 to return)
.APART
.GROUP
.SSS(AUTOOMNITOGGLE)
.index(AUTOOMNITOGGLE)
The AUTOOMNITOGGLE command turns the automatic Omni
'display file' generation switch on or off each time the
command is executed. When on and the DEC GT40 or Tektronix
4012 displays are being used, each picture is assigned a unique
OMNI display file. This permits having more than one picture
on the display at a time.
AUTOOMNITOGGLE
.APART
.GROUP
.SSS(KILLOMNI)
.index(KILLOMNI)
Omni pictures created when the AUTOOMNITOGGLE is on may
be deleted using the KILLOMNI command. This will delete the
omni picture specified. If the ALL switch is specified, then
delete all Omni pictures and clear the screen. It is primarily
used when the Tektronix 4012 or DEC GT40 display is active.
KILLOMNI <OMNI picture name>, <Opt. ALL switch>
.APART
.GROUP
.SSS(UNPOSTOMNI)
.index(UNPOSTOMNI)
The UNPOSTOMNI command temporarily removes the
specified Omni picture currently posted on the display (DEC
GT40 or Tektronix 4012 displays only).
UNPOSTOMNI <OMNI picture name>
.GROUP
.APART
.SSS(POSTOMNI)
.index(POSTOMNI)
The POSTOMNI command restores the Omni picture
specified which had previously been unposted with the
UNPOSTOMNI command.
POSTOMNI <OMNI picture name>
.APART
.GROUP
.SSS(DOOMNI)
.index(DOOMNI)
The DOOMNI command causes POSTOMNI and UNPOST omni
picture operations to be performed which were previously
stacked for use on a Tektronix 4012 terminal. This command only
makes sense for boundaries. Note that DOOMNI is not needed for
DEC GT40 operation for which it is a null operation.
DOOMNI <Opt. ERASE before doing Kill, Post
or Unpost commands>
.APART
.GROUP
.SSS(SETSCALING)
.index(SETSCALING)
The SETSCALING command sets the gray scale display
scaling ratio between max/min densities for nonlinear scaling.
If it is set to 0 then linear scaling is used. The default
value is 32. Note that if a display has N density levels, the
blank is included. Gamma correction is done when the scaling
value is non-zero. The correction is performed after averaging
(if averaging is used). The correction is as follows, for N
display density levels; dmax, dmin (display densities), for
display density d(x,y), and clipped pixel gray value g(x,y) (to
dmin:dmax):
If scaling=0
Then d(x,y)=(N/(dmax-dmin))*(g(x,y)-dmin)
Else d(x,y)=N*scaling**(g(x,y)/(dmax-dmin))
SETSCALING <Opt. scaling ratio between max/min,
0 for linear>
.APART
.GROUP
.SSS(NEWMOVIE)
.index(NEWMOVIE)
A movie consists of an ordered sequence of frames. To
clear this list in preparation for making a new movie, the
NEWMOVIE command is issued. It deletes the existing movie frame
list consisting of picture or boundary data structure names.
NEWMOVIE
.GROUP
.APART
.SSS(APPENDMOVIE)
.index(APPENDMOVIE)
The APPENDMOVIE command adds the list of OMNI picture
names to the end of movie list. The movie will show picture
frames in the order that they are appended. Non-Omni picture
names may be specified (i.e. Pi or Bi which were never shown
with AUTOOMNITOGGLE on) but a warning message will be printed.
APPENDMOVIE (List of OMNI picture names)
.GROUP
.APART
.SSS(RUNMOVIE)
.index(RUNMOVIE)
The RUNMOVIE command shows the list of frames on the
current display terminal. The frames may have been transmitted
previously for rapid motion (on the DEC GT40), otherwise (for
the ASR33, Tektronix 4023, Tektronix 4012 terminals) the
picture will be retransmitted each frame.
RUNMOVIE <Opt. n, (do every n'th frame)>
.GROUP
.APART
.SSS(SPLICEMOVIEFRAME)
.index(SPLICEMOVIEFRAME)
The SPLICEMOVIEFRAME command permits inserting a
specified Omni picture after another specified frame.
SPLICEMOVIEFRAME <(after) Frame #>,<Omni picture name>
.APART
.GROUP
.SSS(REMOVEMOVIEFRAME)
.index(REMOVEMOVIEFRAME)
TheREMOVEMOVIEFRAME permits removing a specified Omni
picture from the movie.
REMOVEMOVIEFRAME <Frame #>
.APART
.GROUP
.SSS(SETBOUNDARYSCALEFACTOR)
.index(SETBOUNDARYSCALEFACTOR)
The SETBOUNDARYSCALEFACTOR command permits the
expanding or shrinking of a boundary displayed on the tektronix
Tektronix 4012 or DEC GT40. The scale factor may be set from
0.1 to 10 times the size. The default display size is 1.
SETBOUNDARYSCALEFACTOR <0.1 to 10X default 1>
.next page

.SS(Picture Operators)
.index(Picture Operators)
The following operators have image data structures as
the domain of their major operands. The output image (if
required) may be a previously created image. Alternatively, it
may be a newly created image with default gray scale values of
zero.
Operations are performed inside of the computing window
and the logical AND of the computing window and mask if a mask
is specified. Output image pixels not operated on are not
changed. Thus, by using different computing windows and/or
masks, different parts of an output image may be created by
different image operators.
.group
.SSS(+)
.index(+)
Two images consisting of pixels Pj(r,c), Pk(r,c) may be
added pixel by pixel such that (r,c) is selected from the
computing window (and also in mask Mi if Mi is specified) and
the resulting (((Pj(r,c)+Pk(r,c)) Min maximum computing
density) stored in Pi(r,c).
<Pi> _ <Pj> + <Pk>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(MINUS)
.index(MINUS)
Two images consisting of pixels Pj(r,c), Pk(r,c) may be
subtracted pixel by pixel such that (r,c) is selected from the
computing window (and also in mask Mi if Mi is specified) and
the resulting ((0 Max ((Pj(r,c)-Pk(r,c))) Min maximum computing
density) stored in Pi(r,c).
<Pi> _ <Pj> MINUS <Pk>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(DIFFERENCE)
.index(DIFFERENCE)
The absolute pixel difference between two images
consisting of pixels Pj(r,c), Pk(r,c) may be computed such that
(r,c) is selected from the computing window (and also in mask
Mi if Mi is specified).The resulting ((0 Max
((|Pj(r,c)-Pk(r,c)|)) is tested agains the specified threshold.
If it is less than the threshold then 0 is stored otherwise the
absolute differnce just computed.
<Pi> _ <Pj> DIFFERENCE <Pk>, <threshold>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(*)
.index(*)
To images consisting of pixels Pj(r,c), Pk(r,c) may be
multiplied pixel by pixel such that (r,c) is selected from the
computing window (and also in mask Mi if Mi is specified) and
the resulting (((Pj(r,c)*Pk(r,c)) Min maximum computing
density) stored in Pi(r,c).
<Pi> _ <Pj> * <Pk>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(/)
.index(/)
Two images consisting of pixels Pj(r,c), Pk(r,c) may be
divided such that (r,c) is selected from the computing window
(and also in mask Mi if Mi is specified) and the resulting
((0 Max ((Pj(r,c)/Pk(r,c))) MIN maximum computing density)
value stored in Pi(r,c). If the divisor is 0 (i.e. Pj(r,c)/0),
then Pi(r,c) is set to the maximum density.
<Pi> _ <Pj> / <Pk>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(MAX)
.index(MAX)
A maximum picture Pi is created by taking the maximum
at each pixel in two image Pj and Pk. Each pixel at (r,c) is
selected from the computing window (and also in mask Mi if Mi
is specified) and the resulting [Pj(r,c) Max Pk(r,c)] stored in
Pi(r,c).
<Pi> _ <Pj> MAX <Pk>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(MIN)
.INDEX(MIN)
A minimum picture Pi is created by taking the minimum
at each pixel in two image Pj and Pk. Each pixel at (r,c) is
selected from the computing window (and also in mask Mi if Mi
is specified) and the resulting [Pj(r,c) Min Pk(r,c)] stored in
Pi(r,c).
<Pi> _ <Pj> MIN <Pk>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(SCALE)
.INDEX(SCALE)
An image Pj may be multiplied by a scaler using the
SCALE command. SCALE multiplies pixels in image Pj by the
positive scaler <value> and stores the resultant pixels in
image Pi such that the pixels operated on are inside the
computing window (and the mask Mi if mentioned). The resultant
pixel value Pj*scaler is clipped at the maximum computing
density.
<Pi> _ <Pj> SCALE <scalar value>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(ROTATE)
.INDEX(ROTATE)
ROTATE rotates pixels in the Pj image about (row
center, Col center) the specified angle and stores them in
Pi(r,c) such that (r,c) is inside the computing window (and
under mask Mi if specified). The transformation is:
dc = c - col center,
dr = r - row center,
r' = row cent + dc*COS(angle) + dr*SIN(angle),
c' = col cent + dr*COS(angle) - dc*SIN(angle),
r''= (image size Min r') Max 0,
c''= (image size Min c') Max 0,
then,
Pi(r'',c'') = Pj(r,c)
for all (r,c) inside of the computing window and mask Mi (if
specified). Thus pixels in (r,c) which would be outside of the
range [0:image size] are mapped to the corresponding extrema.
Such a transformation is sensitive to distortions
introduced by the use of a square image sampling function.
<Pi> _ <Pj> ROTATE <Row cent>,<Col cent>,<angle
in degrees>
.APART
.GROUP
.SSS(COPY)
.INDEX(COPY)
COPY copies image Pj into image Pi such that only those
pixels inside of the computing window (and inside of the mask
Mi if mentioned) are copied.
<Pi> _ COPY <Pj>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(AVG4)
.INDEX(AVG4)
AVG4 averages the four-neighbor pixels of Pj(r,c) and
stores the local average into Pi(r,c) for (r,c) in the
computing window (and in the mask Mi if mentioned). That is:
I8=(I0+I2+I4+I6)/4.
<Pi> _ AVG4 <Pj>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(AVG8)
.INDEX(AVG8)
AVG8 averages the eight-neighbor pixels of Pj(r,c) and
stores the local average into Pi(r,c) for (r,c) in the
computing window (and in the mask Mi if mentioned). That
is: I8=(I0+I1+I2+I3+I4+I5+I6+I7)/8.
<Pi> _ AVG8 <Pj>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(GRAD4)
.INDEX(GRAD4)
GRAD4 takes the four-direction 8-neighbor gradient for
pixels of Pj(r,c) and stores the local gradient into Pi(r,c)
for (r,c) in the computing window (and in the mask Mi if
mentioned). The GRAD4 computes the four direction vectors:
1 2 1 -1 0 1 0 1 2 2 1 0
0 0 0 -2 0 2 -1 0 1 1 0 -1
-1 -2 -1 -1 0 1 -2 -1 0 0 -1 -2
Dx Dy D45 D135
Then Pi(r,c)=Max(|Dx|,|Dy|,|D45|,|D135|). If the DIRECTION
option is used, then Pi(r,c) =1:4 where 1 is Dx, 2 is Dy, 3 is
D45, and 4 is D135.
<Pi> _ GRAD4 <Pj>, (Opt. DIRECTION switch),
<Opt. Mask Mi>
.APART
.GROUP
.SSS(GRAD8)
.INDEX(GRAD8)
GRAD8 takes the eight-neighbor gradient used by Kirsch
for pixels of Pj(r,c) and stores it into Pi(r,c) for (r,c) in
the computing window (and in the mask Mi if mentioned). If the
DIRECTION switch is used, the output image consists of the
direction of the gradient at each pixel. This is coded as a 0
where no gradient was taken, 1:8 being the chain code direction
(as specified in the paragraph defining the 'neighborhood')
plus 1. That is:
For j=[0:8],
Let Sj = 5*|I(j) + I(j+1) + I(j+2)| -
3*|I(j+3) + I(j+4) + I(j+5) + I(j+6) + I(j+7)|,
Then,
I8 = MAX(S0,S1,...,S7).
direction = index of maximum direction + 1;
The maximum GRAD8 value is computed as well. If after the
operation is completed, the maximum gradient value is > maximum
allowed gray value then the GRAD8 must be recomputed with each
GRAD8 value multiplied by a scale factor (max allowed gray
value/previous maximum GRAD8 value) before it is stored in the
output image.
<Pi> _ GRAD8 <Pj>, <Opt. DIRECTION>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(FILLPINHOLES)
.INDEX(FILLPINHOLES)
Often, an image will have salt and pepper (shot) noise.
This appears as pinholes in an image. The FILLPINHOLES
operations will remove all pinholes which deviate from their
4-neighbors by a specified density difference and replace that
pixel with its 8-neighbor average. Boundary points are not
checked. For a normal image a density difference of 20 would be
a good first approximation. The algorithm is approximated by:
density=If |I8-I0| > d Or |I8-I2| > d Or
|I8-I4| > d Or |I8-I6| > d
Then
(I0+I1+I2+I3+I4+I5+I6+I7)/8.
<Pi> _ FILLPINHOLES <Pj>, <Density difference>,
<Opt. Mask Mi>
.APART
.GROUP
.SSS(SLICE)
.INDEX(SLICE)
For all pixels Pj(r,c) such that the grayscale value
g(r,c) of Pj where [minimum density < g(r,c) leq maximum
density], set Pi(r,c) to Pj(r,c) otherwise set Pi(r,c) to zero
inside of the computing window (and mask Mi if used). If the
USETHReshold switch is used, then the current threshold set
with SETDENSITY or EXTREMA is used as the minimum density and
the maximum computing density is used as the upper bound.
<Pi> _ SLICE <Pj>,(USETHReshold switch
or <dens. min>,<dens max>), <Opt. Mask Mi>
.APART
.GROUP
.SSS(NOT)
.INDEX(NOT)
The NOT operator takes the grayscale complement of
image Pj into image Pi such that only those pixels inside of
the computing window (and inside of the mask Mi if mentioned)
are copied. That is:
Pi(r,c) = max density (black) - Pj(r,c).
<Pi> _ NOT <Pj>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(EXPAND)
.INDEX(EXPAND)
EXPAND expands the boundary border pixels of image Pi
(which by definition have a 0 value) a maximum of <number
pixels> out from the boundary. This is done, for each border
pixel, by replacing the 0 valued border pixel with the average
of the those other non-zero boundary pixels. This expansion is
performed only on that part of the image which is inside the
computing window (and mask Mi if specified).
<Pi> _ EXPAND <number pixels>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(SHRINK)
.INDEX(SHRINK)
SHRINK contracts border pixels of Pi inside the
computing window (and mask Mi if specified) and store the
result in Pi. The algorithm is taken from Rosenfeld's
8-neighbor thinning algorithm given in [Ros75].
<Pi> _ SHRINK <number pixels>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(SHIFT)
.INDEX(SHIFT)
It is possible to shift pixels Pj by a specified vector
into Pi if a resultant pixel is inside the computing window
(and mask Mi if specified). Pixels outside of the mask/window
area are ignored. That is:
If (r-delta y,c-delta x) in computing window ^ mask Mi
Then
Pi(r,c) = Pj(r-delta y, c-delta x)
<Pi> _ SHIFT <Pj>, <delta x>, <delta y>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(SEGMENT)
.INDEX(SEGMENT)
Find all of the connected components of image Pj such
that the background pixels of input image Pj have previously
been set to 0. The labeled components are stored in output
image Pi as pixels whose value is the component number (ranging
from 1 to 253) with new associated boundaries having sequential
names Bq (q > 32).
When a boundary is created an association is also
created between the resultant connected component's image and
each boundary associated with a connected component
(Pi*Bq=seglist). This association has a property list
consisting of (component number, first raster row, first raster
column, area, number of boundary pixels, density, boundary
name, touching computing window predicate, component image
name). This property list may be printed using the ACTIVEDATA
command.
If the NOBOUNDARIES switch is used, then the boundaries
(Bq) generated during the segmentation are not saved.
If the NOFILLHOLES switch is used, then do not fill in
the holes inside of connected components. The default is to
fill in such holes as the connected components will often be
used to generate masks (MSEGMENT command).
If sizing values (size!lower:size:upper) are specified
then only those boundaries whose number of boundary pixels is
within these limits are acquired. The algorithm is an
adaptation of the boundary follower given in Rosenfeld 'Picture
Processing by Computer', Academic Press, 1969, chapter 8.
<Pi> _ SEGMENT <Pj>,<Opt. size!lower, size!upper>,
<Opt. NOBOUNDARIES>,<Opt. NOFILLHOLES>,
<Opt. mask Mi>
.APART
.GROUP
.SSS(WHITENOISE - GENERATOR)
.INDEX(WHITENOISE - GENERATOR)
The WHITENOISE operator generates an image Pi inside
the computing window (and mask Mi if specified) such that the
gray scale values are normally distributed about the specified
mean with specified standard deviation.
<Pi> _ WHITENOISE <std dev>, <mean density>,
<Opt. Mask Mi>
.APART
.GROUP
.SSS(ZERO)
.INDEX(ZERO)
The ZERO command sets all pixels of Pi inside the
current computing window (and mask Mi if specified) to zero.
<Pi> _ ZERO <Opt. Mask Mi>
.APART
.GROUP
.SSS(DELSQPIX - SCALAR)
.INDEX(DELSQPIX - SCALAR)
The DELSQPIX command computes the scaler value of the
sum of the squares of the pixel gray value difference i.e.
|Pj(r,c)-Pk(r,c)|**2 for all (r,c) in the computing window (and
under mask Mi if specified).
DELSQPIX <Pj>, <Pk>. <Opt. Mask Mi>
.APART
.GROUP
.SSS(FINDWINDOW - SCALAR)
.INDEX(FINDWINDOW - SCALAR)
The FINDWINDOW command searches a picture Pi from the
current computing window for the minimum size rectangle window
within the computing window which contains border pixels above
the specified density threshold. It then asks if you would like
to (a) pass this new window to the RECTANGLE mask generator
parameters or to (b) pass the new window to the current
computing window. The density threshold may also be specified
using the SETDENSITY command.
FINDWINDOW <Pi>, (USETHReshold switch or <threshold>,
<Opt. Mask Mi>
.APART
.GROUP
.SSS(HISTOGRAMPIX)
.INDEX(HISTOGRAMPIX)
The histogram of Pj inside of the computing window and
mask (if specified) is displayed on the currently selected
display terminal. If the Omni mode is being used, it will
generate an omni picture with the name HIST!Pi. If the option
'avg # bins' value x is specified, then the histogram will
collapse every x bins of the histogram and thus give a coarser
histogram. If the R or C option is specified, Then the
histogram is the Row or Column gray scale profile of Pj. Such a
profile is computed by summing the gray values along each row
(R) or column (C).
If the Tektronix 4012 display is used with the
crosshairs option enabled, the crosshairs may be used to read
values from the display.
<Opt. Ti>_HISTOGRAMPIX <Pj>, <Opt. avg# bins>,
<Opt R or C>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(SHOW - I/O)
.INDEX(SHOW - I/O)
Display the gray scale image Pj inside of the computing
window and mask (if specified) on the currently selected
display terminal. If the NUMBER option is used, then print the
decimal gray values of the sampled image (with a maximum width
of 18 pixels) on the teletype and do not do the gray scale
display. If the Tektronix 4012 terminal was specified with the
crosshairs option selected, the cross hairs on the terminal may
be read repeatedly by PROC10 at the end of the SHOW. The cross
hairs option must be set (via SETTERMINAL). The cross hairs
will be read and the (row,column) reported to the user at the
typing of any character except Q which will return control back
to the PROC10 command input loop.
The image or boundary is displayed in a window whose
upper left hand corner (LCS (Xp,Yp)) is specified by the
SETLCS. The window is specified by the computing window which
may be set via either SETWINDOW or FINDWINDOW. SETSAMPLING sets
the sampling rate to be used inside of the computing window. If
the sampling rate is > 0 then corresponding sub regions between
sample points are averaged and the average called the sample
and displayed. If the sampling rate is < 0 then no averaging is
done.
SETDENSITY specifies the minimum and maximum gray
values to be used to define the dynamic range for the display.
The scaling factor is defined with the SETSCALING command for
use with linear scaling (if 0), or with gamma correction. This
is described in more detail in the previous section on Density
Values.
SHOW <Pj>, (Opt. NUMBER option), <Opt. Mask Mi>
.APART
.GROUP
.SSS(READ - I/O)
.INDEX(READ - I/O)
The READ command is used to read a picture from the
disk into PROC10. If the size of the image is different from
the current size, it gives you the option of reading in the
image anyway or cancelling the READ. If you desire to read the
image anyway, then the old Pi must be deleted so that a new Pi
of the correct size may be created. A question is asked: DELETE
Pi? to which you must respond YES.
If the NUMBER switch is used, then the input file is
assumed to be a sequential list of decimal numbers (in Ascii
format) corresponding to the sequential list of numbers in a
top down, left to right raster scan. This option facilitates
getting non-DDTG formats into PROC10.
<Pi> _ READ <Opt DEV:><Pix file><Opt. [Proj,Prog]>,
<Opt. NUMBER for Ascii data files>
.APART
.GROUP
.SSS(WRITE - I/O)
.INDEX(WRITE - I/O)
The WRITE command is used to write a picture from
PROC10 to the disk file specified. If no title is associated
with the image, then request a title before writing the file.
<Opt DEV:><Pix file><Opt. [Proj,Prog]> _ WRITE <Pj>,
<Opt. Mask Mi>
.APART
.GROUP
.SSS(DELETE)
.INDEX(DELETE)
The DELETE command deletes a picture and its associated
property list (but not the boundaries referenced in its
property list which must be deleted with a DELETE <Bi>) from
PROC10. This enables PROC10 storage to be recovered (which at
16K words for a full 256x256 pixel square images is
considerable).
<Pi> _ DELETE
.APART
.GROUP
.SSS(AREA - SCALAR)
.INDEX(AREA - SCALAR)
The AREA command computes the total area of Pj, in
pixels, of those pixels > the specified threshold and inside
the computing window and mask Mi if specified.
AREA <Pj>, (USETHReshold switch or <threshold>,
<Opt. Mask Mi>
.APART
.GROUP
.SSS(DENSITY - SCALAR)
.INDEX(DENSITY - SCALAR)
The DENSITY command computes the sum of the pixel gray
values of Pj for those pixels > the threshold and inside the
computing window and mask Mi if specified.
DENSITY <Pj>, (USETHReshold switch or <threshold>,
<Opt. Mask Mi>
.APART
.GROUP
.SSS(PERIMETER - SCALAR)
.INDEX(PERIMETER - SCALAR)
The PERIMETER command computes the total perimeter and
number of boundary pixels of image Pj for those pixels
constituting objects > the threshold and inside of the
computing window and mask Mi if specified. Perimeter is defined
to be the total number of pixels which are boundary transition
points. If a boundary transition is a diagonal then that point
is counted as sqrt(2) rather than 1.
PERIMETER <Pj>, (USETHReshold switch or <threshold>,
<Opt. Mask Mi>
.APART
.GROUP
.SSS(MOMENTS - SCALAR)
.INDEX(MOMENTS - SCALAR)
The MOMENTS command computes and prints all (x,y) 0'th
to 3'rd order moments of Pk inside the computing window (and
under mask Mi if specified) such that for gray value g(x,y) at
pixel Pk(x,y):
Mij = SUM(over x,y) g(y,x)*(x^i)*(y^j).
MOMENTS <Pk>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(LAPLACE8)
.INDEX(LAPLACE8)
The LAPLACE8 command computes the eight-neighbor
Laplacian for pixels of Pj(r,c) and stores it into Pi(r,c) for
(r,c) in the computing window (and in the mask Mi if
mentioned). That is:
I8 = |I8 - (I0+I1+I2+I3+I4+I5+I6+I7)/8|.
<Pi> _ LAPLACE8 <Pj>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(INSERT)
.INDEX(INSERT)
INSERT inserts a smaller image Pj into a larger one Pi
at a position specified by the computing window (and under mask
Mi if specified). This allows working on parts of a larger
image and then reconstructing the larger image with the INSERT
command when the operations on the smaller parts are finished.
INSERT may also be used to construct images from other
images. The size of the smaller image Pj is fixed because it
already exists. The size of the larger image is the current
image size and may be defined by setting the image size with
SETSIZE. Note that the mask Mi must be the same size as the
larger image.
<(larger) Pi> _ INSERT <(smaller) Pj>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(EXTRACT)
.INDEX(EXTRACT)
EXTRACT extracts a smaller image Pi from a part of a
larger one Pj such that the pixels of the extracted image are
inside of the computing window (and under mask Mi if
specified). Thus the computing window specifies the size of the
new smaller image Pi (if Pi does not exist previous to ding an
EXTRACT). This allows working on parts of a larger image and
then reconstructing the larger image when the operations on the
smaller parts of finished.
The size of the larger image Pj is fixed because it
already exists. The size of the smaller image Pi is the current
image size and may be defined by setting the image size with
SETSIZE and creating a zeroed image with (Pi_ZERO), or by
setting the size of the computing window. Note that the mask Mi
must be the same size as the larger image.
<(smaller) Pi> _ EXTRACT <(larger) Pj>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(EXTREMA - SCALAR)
.INDEX(EXTREMA - SCALAR)
The EXTREMA command computes the maxima and minima
modes of the gray scale histogram of Pj inside of the computing
window (and under the mask Mi if specified). The switches R
and C may be used to specify a Row or Column histogram. The
i'th histogram entry for R (C) is the sum of the row (column)
gray values in Pj. The i'th minimum may be requested to be
saved as the new density minimum (for use in automatic
slicing).
EXTREMA <Pj>, <opt. i: Min[i]==>threshold or USEMEAN>,
<optional R or C>, <optional Mask Mi>
.apart
.GROUP
.SSS(LINCOMB)
.index(LINCOMB)
.INDEX(LINCOMB)
The linear combination of two images may be computed
such that Pi(r,c)=(0 Max (Aj*Pj(r,c)+Bk*Pk(r,c) Min maximum
computing density)) inside of the computing window (and under
mask Mi if specified). Note that all images must be the same
size. If a constant is not defined, then it defaults to 0. Thus
if Aj is non-zero and Bk is zero the LINCOMB operation acts
like the SCALE operation.
<Pi> _ <Pj> LINCOMB <Pk>, <Real Aj>, <Real Bk>,
<Opt. Mask Mi>
.APART
.GROUP
.SSS(LISTSEGMENTS - STATE)
.INDEX(LISTSEGMENTS - STATE)
LISTSEGMENTS lists the ACTIVEDATA status of a
particular image Pj. This command is the same as doing an
ACTIVEDATA Pj.
LISTSEGMENTS <Pj>
.APART
.GROUP
.SSS(ZOOM)
.INDEX(ZOOM)
The ZOOM command is used to zoom up or down (increase
or decrease) the magnification of input image Pj and store the
resultant image in Pi. The source image is that available under
the computing window and optional mask Mi. The size of the
output image must be the same as that of the input image. If
the magnification is > 1 then the zoom is performed by
repeating pixels in a square tesselation. If the magnification
is < 1 then the zoom is performed by averaging areas between
sample points.
<Pi> _ ZOOM <Pj>, <Zoom magnification 1/256:256>,
<opt. Mask Mi>
.APART
.GROUP
.SSS(MAKEPIX)
.INDEX(MAKEPIX)
The MAKPIX command is used to create an image from a
boundary by setting Pi(r,c) to the maximum gray value for all
(r,c) in a boundary Bi such that (r,c) is inside the computing
window (and under the mask Mi if specified). If a gray value is
specified, then fill the inside of the boundary with this value
othersize don't fill it and use the maximum gray value for the
Pi(r,c). This allows one to write out boundaries in an image.
<Pi> _ MAKEPIX <Boundary Bi>, <Opt. gray value to fill
with>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(PRINT - I/O)
.INDEX(PRINT - I/O)
The PRINT command prints picture Pi on the line printer
(logical device LPT: which may be assigned as the disk by doing
an .ASSIGN DSK: LPT: at PDP10 monitor level, otherwise it
print immediately). The output file has the print name
PiXnnn.LPT. If '.ASSIGN TTY: LPT:' is requested at PDP10
monitor level, then the printout will go to the teletype
instead of the LPT:. The number nnn is incremented (starting
from 000) each time the PRINT command is used.
The Decimal mode prints out a maximum of 64 32x32
subwindows of Pi where the 3 digit gray value for each pixel is
printed. Each page has a heading consisting of the picture
file name, picture title and (first/last rows, first/last
columns) of the section of the image printed on the current
page. Only those pages falling within the computing window
will be printed. This is useful in cutting down the amount of
printout. If the TTY option is specified, the output will go
to the teletype instead of the logical lineprinter.
The single hexidecimal mode prints the hexidecimal
value of the top 4 bits of an 8-bit gray value for each pixel
as (0-9,A-F). The default mode prints the top 3-bits of the
8-bit gray scale pixel value as a pseudo gray scale using the
character set: (<space> . , : ! / & #).
PRINT <Pi>, <Opt. 'D'ecimal, 'S'ingle hexidecimal,
(default is 8 character grayscale)>,
<Opt. TTY for printing on the teletype>
.APART
.GROUP
.SSS(TEXTURE1 - SCALAR)
.INDEX(TEXTURE1 - SCALAR)
The TEXTURE1 command computes the texture measure 1 of
all Pi inside of the computing window (and mask Mi if
specified). Texture measure 1 is the histogram of the
horizontal run length sizes for pixels g(r,c) such that g >
the specified threshold.
TEXTURE1 <Picture Pi>, (USETHRhreshold switch or
<gray scale threshold>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(TEXTURE2 - SCALAR)
.INDEX(TEXTURE2 - SCALAR)
The TEXTURE2 command computes the texture measure 2 of
all Pi inside of the computing window (and mask Mi if
specified). For a given texture sample, a symmetric matrix is
constructed such that each element b(u,v) of this matrix
indicates the number of times an element of the sample with
gray value u has a right-hand neighbor with the gray value v
[Ros70]. The coarser the texture, the greater the tendency for
a point in the texture sample to be followed by a point with a
like or similar gray value. Thus the greater the coarseness,
the greater will be the tendency of the [b(u,v)] matrix to have
its high values concentrated near the main diagonal.
TEXTURE2 <Picture Pi>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(TEXTURE3 - SCALAR)
.INDEX(TEXTURE3 - SCALAR)
The TEXTURE3 command computes the texture measure 3 of
all Pi inside of the computing window (and mask Mi if
specified).
***TO BE ADDED***
TEXTURE3 <Picture Pi>, (USETHRhreshold switch or
<gray scale threshold>, <Opt. Mask Mi>
.APART
.GROUP
.SSS(FILTER)
.INDEX(FILTER)
The FILTER command computes the neighborhood product
between Pj and the specified real valued 9 element neighborhood
at each pixel of Pj in the computing window and under the mask
if specified. The neighborhood elements I0:I8 are defined
according to the ordering imposed by our definition of
neighborhood (see Neighborhood definition). Each neighborhood
pixel Pi(r,c) is computed as:
9
Pi(r,c)=Sum Pjk*dlist(k).
k=1
<Pi> _ FILTER <Pj>,<Opt. Mask Mi>, <9 Real values I0:I8>
.APART
.NEXT PAGE

.SS(Mask Operators)
.index(Mask Operators)
The following operators have mask data structures as
the domain of their major operands. The output mask (if
required) may be a previously created mask. Alternatively, it
may be a newly created mask with default gray scale values of
zero.
Operations are performed inside of the computing window
ANDed with a mask generator (such as MCIRCLE) if specified.
Output mask pixels not operated on are not changed. Thus, by
using different computing windows and/or mask generators,
different parts of an output mask may be created by different
mask operators.
.GROUP
.SSS(AND)
.INDEX(AND)
AND computes the conjunction of two masks Mj and Mk
such that Mi(r,c)=1 if both Mj(r,c)=1 and Mk(r,c)=1.
<Mi> _ <Mj> AND <Mk>
.APART
.GROUP
.SSS(OR)
.INDEX(OR)
OR computes the disjunction of two masks Mj and Mk such
that Mi(r,c)=1 if either Mj(r,c)=1 or Mk(r,c)=1.
<Mi> _ <Mj> OR <Mk>
.APART
.GROUP
.SSS(MINUS)
.INDEX(MINUS)
MINUS computes the logical difference of masks Mj and
Mk and stores it in Mi.
<Mi> _ <Mj> MINUS <Mk>
.APART
.GROUP
.SSS(COPY)
.INDEX(COPY)
COPY copies mask Mj into mask Mi.
<Mi> _ COPY <Mj>
.APART
.GROUP
.SSS(NOT)
.INDEX(NOT)
NOT computes complement of mask Mj such that Mi(r,c) =
If Mj(r,c)=1 Then 0 Else 1 and stores the result in Mi.
<Mi> _ NOT <Mj>
.APART
.GROUP
.SSS(ZERO)
.INDEX(ZERO)
ZERO sets all mask pixels to zero.
<Mi> _ ZERO
.APART
.GROUP
.SSS(READ - I/O)
.INDEX(READ - I/O)
The READ command reads a mask from the disk into
PROC10. If the size of the mask is different from the current
image size, it gives you the option of reading in the mask
anyway or cancelling the READ. If you desire to read the mask
anyway, then the old Mi must be deleted so that a new Mi of the
correct size may be created. A question is asked: DELETE Mi?
to which you must respond YES.
If the NUMBER switch is used, then the input file is
assumed to be a sequential list of decimal numbers (in Ascii
format) corresponding to the sequential list of numbers in a
top down, left to right raster scan. This option facilitates
getting non-DDTG formats into PROC10.
<Mi> _ READ <Opt DEV:><Mask file><Opt. [Proj,Prog]>,
<Opt. NUMBER for Ascii data files>
.APART
.GROUP
.SSS(WRITE - I/O)
.INDEX(WRITE - I/O)
The WRITE command writes a mask from PROC10 to the disk
file specified. If no title is associated with the mask, then
request a title before writing the file.
<Opt DEV:><Mask file><Opt. [Proj,Prog]> _ WRITE <Mj>
.APART
.GROUP
.SSS(DELETE)
.INDEX(DELETE)
The DELETE command deletes the mask Mi and returns the
freed storage to PROC10.
<Mi> _ DELETE
.APART
.GROUP
.SSS(MCIRCLE - GENERATOR)
.INDEX(MCIRCLE - GENERATOR)
The MCIRCLE command generates a circular mask (anded
with the computing window) of the specified radius and centered
at the row and column specified.
<Mi> _ MCIRCLE, <radius>, <row center>, <column center>
.APART
.GROUP
.SSS(RECTANGLE - GENERATOR)
.INDEX(RECTANGLE - GENERATOR)
The RECTANGLE command generates a rectangular mask
(anded with the computing window) of the specified size and
centered at the row and column specified.
<Mi> _ RECTANGLE <row side>, <col side>,
<row center>, <col center>
.APART
.GROUP
.SSS(SPHERE - GENERATOR)
.INDEX(SPHERE - GENERATOR)
The SPHERE command generates a circular mask (anded
with the computing window) which is the 2D slice of a sphere at
the z center with the specified radius and centered above or
below (+/- z) the row and column specified.
<Mi> _ SPHERE <z center>, <radius>,
<row center>, <column center>
.APART
.GROUP
.SSS(SQUARE - GENERATOR)
.INDEX(SQUARE - GENERATOR)
The SQUARE command generates a square mask (anded with
the computing window) of the specified size and centered at the
row and column specified.
<Mi> _ SQUARE <size>, <row center>, <col center>
.APART
.GROUP
.SSS(WHOLE - GENERATOR)
.INDEX(WHOLE - GENERATOR)
The WHOLE command generates a mask of all ones of the
current image size inside of the computing window.
<Mi> _ WHOLE
.APART
.GROUP
.SSS(MSLICE - GENERATOR)
.INDEX(MSLICE - GENERATOR)
Generate a threshold mask by setting mask pixels
Mi(r,c)=1 if image pixels Pj(r,c) are within the threshold
slice range [dmin < Pj(r,c) leq dmax] otherwise set Mi(r,c)=0.
If the USETHReshold switch is used, then the current threshold
set with SETDENSITY is used as the minimum density and the
maximum computing density is used as the upper bound.
<Mi> _ MSLICE <Picture Pi>, (USETHReshold switch or
<min dens>, <max dens>)
Various mask operations which are not explicitly available in
the mask domain but are in the picture domain (such as ROTATE,
SHIFT, EXPAND, SHRINK, etc.) may be performed by converting a
mask to a black and white picture, performing the operation on
the image and then using MSLICE to convert the picture back to
a mask.
[1] Create a picture from the mask,
Pi_ZERO
Pi _ NOT Pi,Mi
[2] Perform the picture operation (abreviated *),
Pj _ * Pi
[3] Convert the image back to a new mask,
Mj _ MSLICE Pj,0,255
.APART
.GROUP
.SSS(MSEGMENT - GENERATOR)
.INDEX(MSEGMENT - GENERATOR)
Generate a connected component mask by setting mask
pixels Mi(r,c)=1 if image pixels Pj(r,c) are within the
connected component specified by the segmented image Pj (output
of the SEGMENT command) and segment number referring to the
connected component. If the pixel is not in the connected
component, then set Mi(r,c)=0.
<Mi> _ MSEGMENT <Segmented Pix Pi>, <segment number>
.APART
.GROUP
.SSS(AREA - SCALAR)
.INDEX(AREA - SCALAR)
AREA computes the mask area in pixels by counting 1's.
AREA <Mi>
.APART
.GROUP
.SSS(PERIMETER - SCALAR)
.INDEX(PERIMETER - SCALAR)
PERIMETER computes the total perimeter of mask Mj.
Perimeter is defined to be the total number of pixels which are
boundary transition points (i.e. going from a 0's background
into a 1's solid object). If a boundary transition is a
diagonal arc than that point is counted as sqrt(2) rather than
1.
PERIMETER <Mi>
.APART
.next page

.SS(Boundary Operators)
.index(Boundary Operators)
The following operators have boundary data structures
as the domain of their major operands. The output boundary
or boundary transform (if required) may be a previously created
boundary or boundary transform. Alternatively, it may be a
newly created boundary or boundary transform which assumes the
size computed by the operation. Boundaries which were never
defined and are used as input boundaries have zero length.
domain.
.GROUP
.SSS(COPY)
.INDEX(COPY)
COPY copies boundary Bj into boundary Bi.
<Bi> _ COPY <Bj>
.APART
.GROUP
.SSS(ZERO)
.INDEX(ZERO)
ZERO Zeros boundary Bi.
<Bi> _ ZERO
.APART
.GROUP
.SSS(READ - I/O)
.INDEX(READ - I/O)
The READ command reads a boundary file into Bi or
transform file into Ti from the PDP10 disk. Check to make sure
it is a valid data structure file. Print the title after
reading the file.
If the NUMBER switch is used, sequential decimal Ascii
(x,y) pairs of numbers are read in until either a (0,0) is seen
or the end of file mark is seen.
<Bi or Ti>_READ <Opt DEV:><file name><Opt. [Proj,Prog]>,
<Opt. NUMBER for Ascii data files>
.APART
.GROUP
.SSS(WRITE - I/O)
.INDEX(WRITE - I/O)
The WRITE command writes a boundary or transform file
from PROC10 to the PDP10 file system. If no title is associated
with the data structure, request a title before writing the
file.
<Opt DEV:><file name><Opt. [Proj,Prog]>_WRITE <Bj or Tj>
.APART
.GROUP
.SSS(DELETE)
.INDEX(DELETE)
The DELETE command deletes the boundary Bi or transform
Ti and return storage to PROC10.
<Bi or Ti> _ DELETE
.APART
.GROUP
.SSS(SHOW - I/O)
.INDEX(SHOW - I/O)
Display boundary Bj inside of the computing window on
the currently selected display terminal with the computing
window positioned at the logical coordinate LCS(Xp,Yp). If the
DEC GT40 or Tektronix 4012 terminals are used, the
SETBOUNDARYSCALEFACTOR command may be used to shrink or expand
the drawing by a factor of 0.1 to 10 (X1 is the default). A
special line drawing mode is available on the Tektronix 4023
display which is considerably faster than using ASR33 line
drawing simulation mode (by filling in images).
SHOW <Bj>,<Optional FASTVECTOR switch for 4012 display>
.APART
.GROUP
.SSS(AREA )
.INDEX(AREA - SCALAR)
The AREA within a boundary is computed using an
algorithm which approximates the area with subtended polygons.
The area algorithm is taken from [Sham75].
AREA <Bj>
.APART
.GROUP
.SSS(PERIMETER - SCALAR)
.INDEX(PERIMETER - SCALAR)
PERIMETER computes the perimeter and length of a
boundary. The length is just the number of points which
comprise the boundary. The perimeter points which are diagonal
are counted sqrt(2) rather than 1.
PERIMETER <Bj>
.APART
.GROUP
.SSS(CIRCLETRANSFORM)
.INDEX(CIRCLETRANSFORM)
The Circle Transform of a boundary Bi ([Shap76a],
[Shap76b]) is computed given the sampling distance along the
boundary. The output of the transform consists of a list of
triples. The first component is a signed radius of curvature
for that segment. A positive sign indicates concavity while a
negative sign indicates convexity. The second component
indicates the angular deflection (in radians) between two
adjoining segments. The third component indicates the arc
length of the segment. If a Tektronix 4012 or DEC GT40 display
is available, then DISplaytheanalysis switch will cause the
sample points to be delimited with small circles and the
corresonding fitted circles (if the OSCulatingcircledisplay
switch is mentioned) to be displayed. The process may be stoped
after each fit for viewing by using the WAITaftereachfit
switch.
<Ti> _ CIRCLETRANSFORM <Bi>,<Sampling distance>,
<Opt DISplaytheanalysis>,
<Opt. WAItaftereachfit if DISplayanalysis>,
<Opt. OSCulatingcircledisplay if DISplayanalysis>
.APART
.GROUP
.SSS(ICIRCLETRANSFORM)
.INDEX(ICIRCLETRANSFORM)
ICIRCLETRANSFORM computes the inverse circle transform
starting at the specified angle from a list of triples produced
from a CIRCLETRANSFORM operation.
<Bi> _ ICIRCLETRANSFORM <Tj>, <Starting angle>
.APART
.GROUP
.SSS(SUBARCS)
.INDEX(SUBARCS)
Copy the specified sublist of ordered arcs from Tj into
a new transform Ti.
<Ti> _ SUBARCS <Tj>, <From arc p>, <To arc q>
.APART
.GROUP
.SSS(LISTTRANSFORM - I/O)
.INDEX(LISTTRANSFORM - I/O)
LISTTRANSFORM lists the type and parameters of the
specified transform as well as its specific values.
LISTTRANSFORM <Tj>
.APART
.GROUP
.SSS(FOURIERTRANSFORM)
.INDEX(FOURIERTRANSFORM)
FOURIERTRANSFORM takes the complex Fourier transform of
Bj over the spatial frequency range specified.
<Ti> _ FOURIERTRANSFORM <Bj>, <lower omega>,<upper omega>
.apart
.group
.SSS(IFOURIERTRANSFORM)
.index(IFOURIERTRANSFORM)
.INDEX(IFOURIERTRANSFORM)
IFOURIERTRANSFORM takes the complex inverse Fourier
transform of Tj over the spatial frequency range specified and
constructs a new boundary Bi.
<Bi> _ IFOURIERTRANSFORM <Tj>, <lower omega>,<upper omega>
.APART
.GROUP
.SSS(WALSHTRANSFORM)
.INDEX(WALSHTRANSFORM)
WALSHTRANSFORM takes the centroid WALSH transform of Bj
over the spatial frequency range specified by the number of
samples.
<Ti> _ WALSHTRANSFORM <Bj>, <number samples>
.APART
.GROUP
.SSS(IWALSHTRANSFORM)
.INDEX(IWALSHTRANSFORM)
IWALSHTRANSFORM takes the centroid inverse WALSH
transform of Tj over the spatial frequency range specified by
the number of samples and constructs a new Bi.
<Bi> _ IWALSHTRANSFORM <Tj>, <number samples>
.APART
.GROUP
.SSS(CENTFOURIERTRANSFORM)
.INDEX(CENTFOURIERTRANSFORM)
CENTFOURIERTRANSFORM takes the centroid FOURIER
transform of Bj over the spatial frequency range specified by
the number of coefficients.
<Ti> _ CENTFOURIERTRANSFORM <Bj>, <number coefficients>
.APART
.GROUP
.SSS(ICENTFOURIERTRANSFORM)
.INDEX(ICENTFOURIERTRANSFORM)
ICENTFOURIERTRANSFORM takes the centroid inverse
FOURIER transform of Tj over the spatial frequency range
specified by the number of coefficients and constructs a new
Bi.
<Bi> _ ICENTFOURIERTRANSFORM <Tj>
.APART
.GROUP
.SSS(LISTBOUNDARY - I/O)
.INDEX(LISTBOUNDARY - I/O)
LISTBOUNDARY lists the first and last boundary (x,y)
points of Bi to indicate closure. It then lists all of the
boundary points.
LISTBOUNDARY <Bi>
.APART