# Class

ClassDescription:
A class which implements a scrollable image


ClassDescription:
A memory resident image class.  Numerous image handling functions


ClassDescription:
A Structure which is part of a motionPath object


ClassDescription:
Describes a 3D motion path as a set of motion nodes which contain position and orientation information


ClassDescription:
An object that contains operational settings and options, mostly having to do with where images and files should be read from or written to


ClassDescription:
A class that encapsulates device dependent drawing operations


ClassDescription:
A list containing a list of models to be rendered


ClassDescription:
The dialog box class that accepts scene preview inputs


ClassDescription:
A class that stores and manipulates 2D and 3D shapes as a list of vertices


ClassDescription:
A 4 x 4 perspective matrix manipulation class


ClassDescription:
A dialog box that accepts warp parameters


# FileName

Description:
Contains a set of blending related functions


Description:
Depth sorting member functions of class SceneList


Description:
Implements a scrollable image viewing window


Description:
Inverse mapping and forward mapping image warp functions


Description:
A general purpose image processing class.


Description:
Continuation of SceneList, Scene and SceneElement member functions.


Description:
Implementation of classes sceneList, scene, and sceneElement


Description:
Implements a 4 x 4 matrix manipulation class


Description:
Code to generate a variety of 3D surfaces represented as quadrilateral mesh models


Description:
Descendent of Windows MDI class to support ICT


Description:
Defines ICT document classes (text file and image)


Description:
Implements the document portion of the document/view metaphor.


Description:
Implements the view portion of the document/view metaphor


Description:
A collection of miscellaneous functions.


Description:
Code to generate a variety of texture images


Description:
A class which maintains a list of intervals.  Numbers can be added or removed from the list and the interval list member functions automatically adjusts the interval list


Description:
Source code implementation of interpolative and Gouraud shaders.


Description:
Functions supporting tween and morph capabilities


# Function

functionDescription:
Reads and parses a VRML world file (.wrl suffix).

returnDescription:
Returns NULL if the operation was successful.  Else a non-zero error code is returned and an informative message is posted to the log.


prototype:
int renderVRML(char *inWorldPath, char *outImagePath);

shortPrototype:
int renderVRML(char *inWorldPath, char *outImagePath);

functionDescription:
Renders the contents of the VRML world file indicated in by the inWorldPath.  The rendered image is stored in the pathname outImagePath.


functionDescription:
Handler responding to selection of the open ICT log menu item.


functionDescription:
Handler responding to selection of the file open menu item.


functionDescription:
Handler responding to selection of the effect preview menu item.


functionDescription:
Handler responding to selection of the sequence preview menu item.


functionDescription:
Handler responding to selection of the render|depth sort menu item.


functionDescription:
Handler responding to selection of the effect render menu item.


functionDescription:
Handler responding to selection of the sequence|render menu item.


functionDescription:
Handler responding to selection of the Tools|Create Alpha Image menu item.


functionDescription:
Handler responding to selection of the Tools | Create a scene list menu item.  Scene files can be opened with this function and subsequently previewed, and rendered.


functionDescription:
Handler responding to selection of the Tools|Create Cutout menu item.  Enables an image to be rotoscoped by hand tracing a border around the visual element using the mouse.


functionDescription:
Handler responding to selection of the Tools | Create Morph Sequencer menu item.


functionDescription:
Handler responding to selection of the Tools | Warp Image menu item.  This menu item provides a demonstration of one of three texture mapping methods discussed in the book.


functionDescription:
Returns the view matrix containing the composite graphic transformation corresponding to the present viewpoint (camera) location and orientation.


functionDescription:
The ICT mainframe window is an MDI parent window.  This function finds all open MDI child windows associated with this parent window and closes them.


functionDescription:
Handler that checks or unchecks the Tools | Create Cutout menu item.


functionDescription:
Handler that enables or disables the Effect | Preview menu item.


functionDescription:
Handler that enables or disables the Sequence | Preview menu item.


functionDescription:
Handler that enables or disables the Effect | Render menu item.


functionDescription:
Handler that enables or disables the Sequence | Render menu item.


functionDescription:
Handler that checks or unchecks the Render | Depth Sorting menu item.


functionDescription:
Handler responding to selection of the Tools | Test menu item.


functionDescription:
Handler responding to selection of the Render | Z Buffer menu item.


functionDescription:
Handler that checks or unchecks the Render | Z Buffer menu item.


functionDescription:
Handler that checks or unchecks the Tools | Sample Image menu item.


functionDescription:
Handler that responds to selection of the Tools | Sample Image menu item.


functionDescription:
Handler that responds to selection of the Tools | Remove Sampled Colors menu item.


functionDescription:
Handler that checks or unchecks the Tools | Remove Sample Colors menu item.


functionDescription:
Handler that checks or unchecks the Render | Anti-alias menu item.


functionDescription:
Handler that responds to selection of the Tools | Create Mesh menu item.


functionDescription:
Handler that responds to selection of the Tools | Create Texture image menu item.


functionDescription:
Handler that responds to selection of the Tools | Motion Blur menu item.


functionDescription:
Handler that responds to selection of the Render | Anti-alias menu item.


functionDescription:
Handler that responds to selection of the Tools | Render VRML file menu item.


prototype:
void renderObject::drawSequence(HDC theDC, char *modelName, int screenHeight, int screenWidth,int frameCounter);

shortPrototype:
void renderObject::drawSequence(HDC theDC, char *modelName, int screenHeight, int screenWidth,int frameCounter);

functionDescription:
Draws a wireframe version of a sequence special effect


prototype:
void renderObject::drawStill(HWND theWindow, char *modelName,int screenHeight,int screenWidth);

shortPrototype:
void renderObject::drawStill(HWND theWindow, char *modelName,int screenHeight,int screenWidth);

functionDescription:
Draws a wireframe version of a still (single image) special effect


prototype:
void insertionSort(int theItems[], int numItems);

shortPrototype:
void insertionSort(int theItems[], int numItems);

functionDescription:
Sorts theItems array into descending order.


prototype:
void removeDuplicates(int theList[], int *listLength);

shortPrototype:
void removeDuplicates(int theList[], int *listLength);

functionDescription:
Removes duplicate entries in theList.  Assumes theList is already sorted.


prototype:
int prepareCutout(shape3d *aShape, HWND HWindow, char *imageFileName,char *cutoutName, int imageWidth,int imageHeight);

shortPrototype:
int prepareCutout(shape3d *aShape, HWND HWindow, char *imageFileName,char *cutoutName, int imageWidth,int imageHeight);

functionDescription:
Called after an image has been rotoscoped on an ICT image window by tracing around it with the mouse.  This function creates an image file that contains only the rotoscoped area of the image (whatever is inside the traced boundary).  A mask image is also prepared.


functionDescription:
Returns TRUE if the renderObject is valid, else returns FALSE

returnDescription:
Returns TRUE if the renderObject is valid, else returns FALSE


prototype:
void assembleName(char *inputName, char theSuffix, char *outputName);

shortPrototype:
void assembleName(char *inputName, char theSuffix, char *outputName);

functionDescription:
Creates a Pathname by appending a suffix to an existing pathname.


prototype:
void renderObject::previewMesh(HDC theDC, char *modelName,float xOff, float yOff,int screenHeight, int screenWidth);

shortPrototype:
void renderObject::previewMesh(HDC theDC, char *modelName,float xOff, float yOff,int screenHeight, int screenWidth);

functionDescription:
Draw a wireframe version of a quadrilateral mesh model.


prototype:
int renderObject::renderMesh(memImage *outputImage, memImage *inputImage,int blendIndicator);

shortPrototype:
int renderObject::renderMesh(memImage *outputImage, memImage *inputImage,int blendIndicator);


prototype:
int renderObject::renderMeshz(memImage *outputImage, memImage *maskImage,memImage *inputImage, memImage *zBuffer, float vx, float vy, float vz);

shortPrototype:
int renderObject::renderMeshz(memImage *outputImage, memImage *maskImage,memImage *inputImage, memImage *zBuffer, float vx, float vy, float vz);

functionDescription:
Render a quadrilateral mesh model using a Z buffer.


prototype:
void renderObject::transformAndProject (tMatrix *aMatrix, int outHeight, int outWidth,int externalCentroid,float centroidX, float centroidY, float centroidZ);

shortPrototype:
void renderObject::transformAndProject (tMatrix *aMatrix, int outHeight, int outWidth,int externalCentroid,float centroidX, float centroidY, float centroidZ);

functionDescription:
Transforms and projects the renderObject's currentShape object coordinates using the indicated perspective matrix and reference point.


prototype:
void transformAndProjectPoint2(tMatrix *aMatrix, float x, float y, float z, int *sx,int *sy, float refX, float refY, float refZ, int outHeight,int outWidth);

shortPrototype:
void transformAndProjectPoint2(tMatrix *aMatrix, float x, float y, float z, int *sx,int *sy, float refX, float refY, float refZ, int outHeight,int outWidth);

functionDescription:
Transforms the world point (x, y, z) using aMatrix and projects the transformed point to the viewscreen.  The point is translated to the reference point before the graphic transform is applied.


prototype:
void drawBox(HDC theDC, HPEN hPointPen, HPEN hBlackPen, int x, int y);

shortPrototype:
void drawBox(HDC theDC, HPEN hPointPen, HPEN hBlackPen, int x, int y);

functionDescription:
Draws a small box around the screen coordinate x, y.


prototype:
int renderObject::renderShape(memImage *outputImage, int blendIndicator);

shortPrototype:
int renderObject::renderShape(memImage *outputImage, int blendIndicator);

functionDescription:
Render a shape object.  If the shape object has faces, they are flat shaded and rendered into the output image.  The rendered image is then optionally blended into the output image.  If the shape object has not defined faces, no rendering occurs.


prototype:
int renderObject::renderShapez(memImage *outputImage,memImage *alphaImage, memImage *zBuffer,float vx, float vy, float vz);

shortPrototype:
int renderObject::renderShapez(memImage *outputImage,memImage *alphaImage, memImage *zBuffer,float vx, float vy, float vz);

functionDescription:
Render a shape object using a Z Buffer.  If the shape object has faces, they are flat shaded and rendered into the output image.  The rendered image is then optionally blended into the output image.  If the shape object has not defined faces, no rendering occurs.


prototype:
int iwarpz(memImage *inImage, memImage *outImage, memImage *zImage,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int iwarpz(memImage *inImage, memImage *outImage, memImage *zImage,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);

functionDescription:
Warps an image using the transformation indicated.  The warped image is placed in the outImage. The inverse mapping warp is limited to angular rotations of approximately 30 degrees before some distortion occurs.  This texture mapping method is significantly faster than the forward mapping warp implemented in fwarpz.


prototype:
void getLineEquation(int x1,int y1, int x2, int y2, float *m,float *b, BOOL *horzFlag, BOOL *vertFlag);

shortPrototype:
void getLineEquation(int x1,int y1, int x2, int y2, float *m,float *b, BOOL *horzFlag, BOOL *vertFlag);

functionDescription:
Returns the slope and y intercept of the input line segment.


prototype:
void getFLineEquation(float x1,float y1, float x2, float y2, float *m,float *b, BOOL *horzFlag, BOOL *vertFlag);

shortPrototype:
void getFLineEquation(float x1,float y1, float x2, float y2, float *m,float *b, BOOL *horzFlag, BOOL *vertFlag);


prototype:
int getIntervals (shape3d *theShape, int y, int *numCoords,int numAllocatedXCoords, int *screenXCoords,float *tXCoords, float *tYCoords, float *tZCoords);

shortPrototype:
int getIntervals (shape3d *theShape, int y, int *numCoords,int numAllocatedXCoords, int *screenXCoords,float *tXCoords, float *tYCoords, float *tZCoords);

functionDescription:
Perform a scan conversion operation on the boundary supplied in the shape3d object.  Return all intervals on the horizontal scan line y that cross the indicated boundary.  Lists of screen coordinates and corresponding world coordinates are returned.  This is not a general purpose scan conversion procedure.  It was designed to support convex 4 sided polygons resulting from projecting rectangles onto a viewscreen.


prototype:
void insertionSort(int theItems[], float itemData1[], float itemData2[],float itemData3[], int numItems);

shortPrototype:
void insertionSort(int theItems[], float itemData1[], float itemData2[],float itemData3[], int numItems);

functionDescription:
Sorts the array theItems into ascending order and carrys along three arrays of floating oint data.


prototype:
int removeDuplicates(int theList[], float theItemData1[],float theItemData2[], float theItemData3[], int *listLength);

shortPrototype:
int removeDuplicates(int theList[], float theItemData1[],float theItemData2[], float theItemData3[], int *listLength);

functionDescription:
Removes duplicates in theList.  Assumes theList has already been sorted.


prototype:
int iRender(memImage *outImage, memImage *maskImage, memImage *inImage,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, tMatrix *viewMatrix,int warpIndicator, int blendIndicator, float alphaScale,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int iRender(memImage *outImage, memImage *maskImage, memImage *inImage,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, tMatrix *viewMatrix,int warpIndicator, int blendIndicator, float alphaScale,float refPointX, fl

functionDescription:
Renders a texture corresponding to a model.  The result is placed in an output image.  Blending occurs if desired.


prototype:
int iRenderz(memImage *outImage, memImage *matteImage, memImage *inImage,memImage *zImage, memImage *zBuffer,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, float vx, float vy, float vz,tMatrix *viewMatrix,int warpIndicator, int blendIndicator, float alphaScale,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int iRenderz(memImage *outImage, memImage *matteImage, memImage *inImage,memImage *zImage, memImage *zBuffer,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, float vx, float vy, float vz,tMatrix *viewMatrix,int warp

functionDescription:
Renders a texture corresponding to a model.  The result is placed in an output image.  Blending occurs if desired.  The Z Buffer is used if desired.


prototype:
int antiAlias(memImage *inImage, memImage *outImage);

shortPrototype:
int antiAlias(memImage *inImage, memImage *outImage);

functionDescription:
Applies an anti-alias convolution filter to the input image.  The result is placed in the outImage.


functionDescription:
Convolves the image with a modified 3 x 3 pixel averaging convolution window.  The effect of this operation is to soften the edges of the alpha image.


functionDescription:
Convolves the image with a modified 5 x 5 pixel averaging convolution window.  The effect of this operation is to soften the edges of the alpha image.


functionDescription:
Convolves the image with a modified 7 x 7 pixel averaging convolution window.  The effect of this operation is to soften the edges of the alpha image.


prototype:
int fWarp1(memImage *inImage, memImage *outImage,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int fWarp1(memImage *inImage, memImage *outImage,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);

functionDescription:
Performs a forward mapping warp on the input image and places it in the supplied output image.  No polygon shading is performed using this method.  This function was used to produce a figure in the book and is not recommended for general use.This method is slower than the inverse mapping method but provides a correct result regardless of the rotation angles.  The inverse mapping warp is limited to angular rotations of approximately 30 degrees before some distortion occurs.


prototype:
int fwarpz(memImage *inImage, memImage *outImage, memImage *zImage,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int fwarpz(memImage *inImage, memImage *outImage, memImage *zImage,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);

functionDescription:
Performs a forward mapping warp on the input image and places it in the supplied output image.  A Z Buffer can be used optionally.  If the Zbuffer image pointer is set to NULL, the Zbuffer is not used.  This method is slower than the inverse mapping method but provides a correct result regardless of the rotation angles.  The inverse mapping warp is limited to angular rotations of approximately 30 degrees before some distortion occurs.


prototype:
int fwarpz2(memImage *inputImage, memImage *outputImage, memImage *zBuffer,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refpointZ);

shortPrototype:
int fwarpz2(memImage *inputImage, memImage *outputImage, memImage *zBuffer,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refp

functionDescription:
Performs a forward mapping warp on the input image and places it in the supplied output image.  This method is slower than the inverse mapping method but provides a correct result regardless of the rotation angles.  The inverse mapping warp is limited to angular rotations of approximately 30 degrees before some distortion occurs. This version is different from fwarpz in that it contains optimizations that reduce the number of matrix multiplications by a factor of 4.


functionDescription:
Creates a new shape object by reading a shape file.


prototype:
shape3d :: shape3d(point3d *UL, point3d *UR, point3d *LR, point3d *LL);

shortPrototype:
shape3d :: shape3d(point3d *UL, point3d *UR, point3d *LR, point3d *LL);

functionDescription:
Creates a new rectangular shape object from the indicated vertices.


prototype:
int shape3d :: readShape(char *pathName);

shortPrototype:
int shape3d :: readShape(char *pathName);

functionDescription:
Creates a shape object by reading a shape file.


prototype:
int shape3d :: getShapeFileInfo(char *pathName,  int *fileType, int *numVertices, int *numFaces);

shortPrototype:
int shape3d :: getShapeFileInfo(char *pathName,  int *fileType, int *numVertices, int *numFaces);


prototype:
int shape3d :: shapeFromBMP(char *imageFileName);

shortPrototype:
int shape3d :: shapeFromBMP(char *imageFileName);

functionDescription:
Creates a shape object from a matte image or alpha image by automatically tracing around the boundary of the image.


functionDescription:
Saves a shape object to the indicated file.


functionDescription:
Displays the contents of the shape object to the ICT log.


functionDescription:
Calculates the bounding box of the shape object's screen coordinates.


functionDescription:
Initializes the current vertex pointer to point to the first vertex.


functionDescription:
Initializes the current face pointer to point to the first face.


functionDescription:
Returns the number of faces defined in the shape object

returnDescription:
Returns the number of faces defined in the shape object


functionDescription:
Sets the number of vertices in a shape object.


functionDescription:
Calculate the bounding box of the shape's world coordinates.


functionDescription:
Calculate the bounding box of the shape's transformed coordinates.


functionDescription:
Invert the Y axis of  the shape's screen coordinates.  This function is used to transform screen coordinates into world coordinates and vice versa.


prototype:
int shape3d::addWorldVertex(float x, float y, float z);

shortPrototype:
int shape3d::addWorldVertex(float x, float y, float z);

functionDescription:
Adds a world coordinate vertex to a shape3d object.

returnDescription:
Returns NULL if successful, else an error message is posted to the log.


prototype:
int shape3d::addTransformedVertex(float x, float y, float z);

shortPrototype:
int shape3d::addTransformedVertex(float x, float y, float z);

functionDescription:
Adds a transformed coordinate vertex to a shape3d object.


functionDescription:
Deletes the last vertex in a shape object.

returnDescription:
NULL is returned if the operation was successful, else an informative message is posted to the log.


prototype:
int shape3d::getLastWorldVertex(float *x, float *y, float *z);

shortPrototype:
int shape3d::getLastWorldVertex(float *x, float *y, float *z);

functionDescription:
Retrieves the vertex located one position behind the current vertex pointer.


prototype:
int shape3d::getPreviousWorldVertex(float *x, float *y, float *z);

shortPrototype:
int shape3d::getPreviousWorldVertex(float *x, float *y, float *z);

functionDescription:
Retrieves the vertex located two positions behind the current vertex pointer.


functionDescription:
Returns the average x coordinate of the shape3d object.

returnDescription:
The average x coordinate of the shape3d object.


functionDescription:
Returns the average y coordinate of the shape object.

returnDescription:
Returns the average y coordinate of the shape object.


prototype:
void shape3d::getWCentroid(float *centroidX, float *centroidY, float *centroidZ);

shortPrototype:
void shape3d::getWCentroid(float *centroidX, float *centroidY, float *centroidZ);


prototype:
void shape3d::translateW(float offsetX, float offsetY, float offsetZ);

shortPrototype:
void shape3d::translateW(float offsetX, float offsetY, float offsetZ);

functionDescription:
Translate a shape's world coordinates the indicated amount.


prototype:
void shape3d::translateT(float offsetX, float offsetY, float offsetZ);

shortPrototype:
void shape3d::translateT(float offsetX, float offsetY, float offsetZ);

functionDescription:
Translate a shape's transformed coordinates the indicated amount.


prototype:
void shape3d::translateS(int offsetX, int offsetY);

shortPrototype:
void shape3d::translateS(int offsetX, int offsetY);

functionDescription:
Translate a shape's screen coordinates the indicated amount.


prototype:
char *getNextLine(char *theText, int *lineNumber, ifstream *filein,int minLineLength);

shortPrototype:
char *getNextLine(char *theText, int *lineNumber, ifstream *filein,int minLineLength);

functionDescription:
Returns the next line of text in a shape file.  Comment lines (those beginning with //) are ignored.


prototype:
void getShapePath(char *modelPath, char *shapeDir, char *shapePath);

shortPrototype:
void getShapePath(char *modelPath, char *shapeDir, char *shapePath);

functionDescription:
Constructs a pathname from the model pathname and directory in which to store shape files.


functionDescription:
Returns TRUE if the shape object is valid, else FALSE is returned.


prototype:
int getBoundaryPoint (shape3d *theShape,float rayCentroidX, float rayCentroidY,float rayX2, float rayY2,float *outX, float *outY,float lastX, float lastY);

shortPrototype:
int getBoundaryPoint (shape3d *theShape,float rayCentroidX, float rayCentroidY,float rayX2, float rayY2,float *outX, float *outY,float lastX, float lastY);


functionDescription:
Add the vertices of the child shape to this shape.


prototype:
void shape3d::getReferencePoint(float *centroidX, float *centroidY, float *centroidZ);

shortPrototype:
void shape3d::getReferencePoint(float *centroidX, float *centroidY, float *centroidZ);


prototype:
void shape3d::setReferencePoint(float centroidX, float centroidY, float centroidZ);

shortPrototype:
void shape3d::setReferencePoint(float centroidX, float centroidY, float centroidZ);


prototype:
int shape3d::getScreenVertex(int index, int *sx, int *sy);

shortPrototype:
int shape3d::getScreenVertex(int index, int *sx, int *sy);


prototype:
int shape3d::getTransformedVertex(int index, float *tx, float *ty, float *tz);

shortPrototype:
int shape3d::getTransformedVertex(int index, float *tx, float *ty, float *tz);

functionDescription:
Returns the index-th transformed vertex.


functionDescription:
Returns the sum of distances of the first vertexNumber line segments in a shape.  VertexNumber is 1 relative.  If vertexNumber is zero, the total shape boundary distance is returned.

returnDescription:
Returns the sum of distances of the first vertexNumber line segments in a shape.  VertexNumber is 1 relative.  If vertexNumber is zero, the total shape boundary distance is returned.


functionDescription:
Not Used.     A distance fraction is an arc distance divided by the total length of the boundary. Calculate the distance fraction for each vertex in the shape the fractions are stored in the transformed coordinate list within the shape object.


prototype:
int shape3d::getWorldVertex(float distanceFraction, int *vertex, float *x,float *y, float *z);

shortPrototype:
int shape3d::getWorldVertex(float distanceFraction, int *vertex, float *x,float *y, float *z);

functionDescription:
Not used.  Determine the world coordinate that corresponds to the supplied distance fraction. The resulting coordinate is interpolated linearly from the two vertices that are located between the corresponding distanceFraction.  vertex is the 0 relative index after which the vertex is to be added.


prototype:
void memImage::allocate(int height, int widthInPixels);

shortPrototype:
void memImage::allocate(int height, int widthInPixels);

functionDescription:
Allocates memory for a memImage Object.  If the needed amount of memory is not available, the object's valid data member is set to zero.


functionDescription:
Erases a memImage object's pixels by setting them to zero.


prototype:
int memImage::clearRGB(BYTE red, BYTE green, BYTE blue);

shortPrototype:
int memImage::clearRGB(BYTE red, BYTE green, BYTE blue);

functionDescription:
Erases all pixels in an image having the indicated RGB color by setting them to zero.

returnDescription:
0 if successful, non-zero if an error occured.  Message posted to log.


prototype:
int memImage::clearRGBRange(BYTE redLow, BYTE redHigh,BYTE greenLow, BYTE greenHigh,BYTE blueLow, BYTE blueHigh);

shortPrototype:
int memImage::clearRGBRange(BYTE redLow, BYTE redHigh,BYTE greenLow, BYTE greenHigh,BYTE blueLow, BYTE blueHigh);

functionDescription:
Erases all pixels in an image within the indicated RGB color range.  All pixels within the indicated range are erased by setting them to zero.

returnDescription:
0 if successful, non-zero if an error occured.  Message posted to log if the operation was not successful.


functionDescription:
Initializes the pixels of a 32 bit memImage to the indicated value.


functionDescription:
Scales the intensities of the 32 bit image down to 255 greyscales.  The result is placed in the scaledImage.  This function is used in ICT to scale down the 32 bit Z-buffer image so that it is viewable on the screen.  The scaling operation ignores the Z-Buffer maximum value.


prototype:
void memImage::display(HDC dc, int outWidth, int outHeight);

shortPrototype:
void memImage::display(HDC dc, int outWidth, int outHeight);

functionDescription:
Displays a memImage object in the indicated device context. If the image to be displayed is smaller that the area available to the device context, then the image is displayed in the lower left corner of the dc.


prototype:
int memImage::drawMask(HDC dc, POINT far *thePoints, int numVertices);

shortPrototype:
int memImage::drawMask(HDC dc, POINT far *thePoints, int numVertices);

functionDescription:
Draws a binary mask into the memImage object.  The mask is described as a list of vertices.  The interior of the polygon is occupied with  pixels whose values are 255, all pixels external to the mask are set to zero.

returnDescription:
0 of the operation was successful. else a message is posted to the log.


prototype:
int memImage::copy(memImage *outImage, int xoffset, int yoffset);

shortPrototype:
int memImage::copy(memImage *outImage, int xoffset, int yoffset);

functionDescription:
Copies the image to an indicated output image.  The input image is offset  in the output image by the indicated amount.


prototype:
int memImage::fastCopy(memImage *outImage, int xOffset, int yOffset);

shortPrototype:
int memImage::fastCopy(memImage *outImage, int xOffset, int yOffset);

functionDescription:
Copies the image into another memImage (outImage) offsetting the image by the indicated amount.


prototype:
BYTE memImage::getMPixel (int x, int y, char aColor);

shortPrototype:
BYTE memImage::getMPixel (int x, int y, char aColor);

functionDescription:
Returns an 8 bit color component pixel from a 24 bit memImage.

returnDescription:
The value of the requested color component.


prototype:
int memImage::getMPixelRGB(int x, int y, BYTE *red, BYTE *green, BYTE *blue);

shortPrototype:
int memImage::getMPixelRGB(int x, int y, BYTE *red, BYTE *green, BYTE *blue);

functionDescription:
Retrieves an RGB color from the specified location in a 24 bit memImage.

returnDescription:
0 if operation successful, -1 if clipping occured.


prototype:
int memImage::setMPixelRGB(int x, int y, BYTE red, BYTE green, BYTE blue);

shortPrototype:
int memImage::setMPixelRGB(int x, int y, BYTE red, BYTE green, BYTE blue);

functionDescription:
Sets a pixel in a 24 bit memImage file to the indicated color.

returnDescription:
0 if the operation was successful, -1 if clipping occured.


prototype:
int memImage::setMPixel (int x, int y, BYTE value);

shortPrototype:
int memImage::setMPixel (int x, int y, BYTE value);

functionDescription:
Sets the pixel to the indicated value at the desired location.

returnDescription:
0 if the operation was successful, else a message is posted to the log.


prototype:
int memImage::setMPixelA (float x, float y, BYTE value);

shortPrototype:
int memImage::setMPixelA (float x, float y, BYTE value);


prototype:
BYTE memImage::getMPixelA (float x, float y);

shortPrototype:
BYTE memImage::getMPixelA (float x, float y);


prototype:
BYTE memImage::getMPixel (int x, int y);

shortPrototype:
BYTE memImage::getMPixel (int x, int y);


prototype:
int memImage::setMPixel32 (int x, int y, float aValue);

shortPrototype:
int memImage::setMPixel32 (int x, int y, float aValue);

functionDescription:
Sets the pixel at the x,y location in a 32 bit image to the indicated value.


prototype:
float memImage::getMPixel32 (int x, int y);

shortPrototype:
float memImage::getMPixel32 (int x, int y);

functionDescription:
Returns the indicated floating point pixel in a 32 bit memImage.

returnDescription:
The indicated floating point pixel in a 32 bit memImage.


functionDescription:
Returns the image height (Y dimension) in pixels.

returnDescription:
The image height (Y dimension) in pixels.


functionDescription:
Returns the image width (X dimension) in pixels.


functionDescription:
Returns the access mode of the image: SEQUENTIAL or RANDOM.

returnDescription:
The returned value is either SEQUENTIAL or RANDOM


functionDescription:
Returns the colorSpec of a memImage object.  The colorSpec has one of the following values: REDCOLOR, GREENCOLOR, BLUECOLOR, MONOCHROME, RGBCOLOR


functionDescription:
Returns the pixel depth of a memImage.  Typical values returned are 8, 24, or 32.


functionDescription:
Returns a pointer to the image data itself.

returnDescription:
Returns a pointer to the image data itself.


functionDescription:
Determines whether the object is valid.  If a NULL is returned, possible implications are: not enough memory was available to create the memImage, or a .bmp file could not be found.

returnDescription:
Returns TRUE (1) if the object is valid, else NULL is returned.


functionDescription:
Saves the memImage object to disk in the form of a .bmp file.  If the .bmp file already exists, it is overwritten without asking for confirmation.

returnDescription:
NULL if the operation is successful, else a message is posted to the log.


prototype:
int memImage::readBMP(char *fileName, int colorSpec);

shortPrototype:
int memImage::readBMP(char *fileName, int colorSpec);

functionDescription:
Reads a bmp image file.  The image is assumed to be true color (24 bits per pixel).  The indicated color plane is read into memory.  This protected function is used only by memImage constructors.

returnDescription:
NULL if the operation is successful, else -1 is returned and a message is posted to the log.


functionDescription:
If an image is opened for sequential access, this function reads the next row of the image from a .bmp file.


functionDescription:
Closes a memImage object and also closes the .bmp file that may have been opened during the life of this memImage object.


functionDescription:
If an image is opened for sequential access, this function saves the next row to a .bmp file.


prototype:
int readBMPHeader(char *fileName, int *height, int *width,int *bitsPerPixel);

shortPrototype:
int readBMPHeader(char *fileName, int *height, int *width,int *bitsPerPixel);

functionDescription:
Reads the header of a Windows bitmap image file and returns image attributes.


prototype:
int makeRGBimage(char *redImage, char *greenImage, char *blueImage,char *outFileName);

shortPrototype:
int makeRGBimage(char *redImage, char *greenImage, char *blueImage,char *outFileName);

functionDescription:
Constructs a 24 bit color image file from three 8 bit images.


functionDescription:
Converts a color specification to its corresponding bits per pixel.  This is basically a look up table.


functionDescription:
Converts bits per pixel to a corresponding color specification.  This is basically a look up table.


functionDescription:
Scales a 32 bit memImage to 8 bits.  The scaling operation is performed in such a way that maxValue pixels are ignored.


functionDescription:
Calculates a histogram of the image.  The histogram is displayed in the lCT log file.  The image must be an 8 bit image.

returnDescription:
Returns 0 if the operation was successful.


prototype:
int memImage::adjustColor(BYTE desiredRed, BYTE desiredGreen, BYTE desiredBlue,BYTE *midRed, BYTE *midGreen, BYTE *midBlue, memImage *outImage,char *adjustmentType, int inputImageColor);

shortPrototype:
int memImage::adjustColor(BYTE desiredRed, BYTE desiredGreen, BYTE desiredBlue,BYTE *midRed, BYTE *midGreen, BYTE *midBlue, memImage *outImage,char *adjustmentType, int inputImageColor);

functionDescription:
Performs one of two types of true color adjustment to the image.  If the adjustment type is 'Relative', the desired color (desiredRed, desiredGreen, desiredBlue) is added to all image intensities.  If the color adjustment type is 'Target', the average color is calculated and the image intensities are 'moved' so that the new average color is equal to the desired color supplied by the user.


functionDescription:
Displays on the log and in the message box, the color, intensity, or 32 bit value at the indicated location.  This function supports 8, 24, and 32 bit per pixel images.


functionDescription:
Sets the memImage objects internal fileName variable.  This variable is used optionally to associate a file name with an image in memory.


prototype:
int memImage::clearRectangle(int startX, int startY, int endX, int endY);

shortPrototype:
int memImage::clearRectangle(int startX, int startY, int endX, int endY);

functionDescription:
Clears (sets to zero) the indicated rectangular area.


functionDescription:
Allocates memory for the indicated number of motionNodes.


prototype:
void motionPath::getFirstLastFrame(int *firstFrame, int *lastFrame);

shortPrototype:
void motionPath::getFirstLastFrame(int *firstFrame, int *lastFrame);

functionDescription:
Returns the first and last frame numbers in a motion path.


functionDescription:
Copies the motion node to the motionNode mn.


prototype:
int motionPath::getNode(int frameNumber, motionNode *mn);

shortPrototype:
int motionPath::getNode(int frameNumber, motionNode *mn);

functionDescription:
Retrieves a motion node comparable to the indicated frame number.  The frame number can be from 1 to the max frame in the motion path.  This function returns the interpolated motion node if frameNumber lies between keyframes.  If the framenumber is greater than the number of frames in the sequence, the information in the last keyframe is returned.


prototype:
int motionPath :: readMotion(char *pathName);

shortPrototype:
int motionPath :: readMotion(char *pathName);

functionDescription:
Reads a motion path from the indicated file.


functionDescription:
Reads a motionNode from the pathname indicated in buffer.


prototype:
char *getNextMotionLine(char *theText, int *lineNumber, ifstream *filein);

shortPrototype:
char *getNextMotionLine(char *theText, int *lineNumber, ifstream *filein);

functionDescription:
Returns the next line of text in a motion file.  Comment lines (those beginning with //) are ignored.


prototype:
int motionBlur(char *firstImagePath, char *outputDir, int numFrames,int blurDepth);

shortPrototype:
int motionBlur(char *firstImagePath, char *outputDir, int numFrames,int blurDepth);

functionDescription:
Produces a blurred image sequence from an input image sequence.  The amount of blurring applied is controlled by the blurDepth setting.


prototype:
void sceneList::setCurrentModelTransform(float rx, float ry, float rz,float sx, float sy, float sz, float tx, float ty, float tz);

shortPrototype:
void sceneList::setCurrentModelTransform(float rx, float ry, float rz,float sx, float sy, float sz, float tx, float ty, float tz);

functionDescription:
Set the current model's location and orientation using the indicated rotation, scale and translations.


prototype:
void sceneList::getCurrentModelTransform(float *rx, float *ry, float *rz,float *sx, float *sy, float *sz, float *tx, float *ty, float *tz);

shortPrototype:
void sceneList::getCurrentModelTransform(float *rx, float *ry, float *rz,float *sx, float *sy, float *sz, float *tx, float *ty, float *tz);

functionDescription:
Retrieve the current model's location and orientation


prototype:
int sceneList::readList(char *errorText, char *pathName);

shortPrototype:
int sceneList::readList(char *errorText, char *pathName);

functionDescription:
Read a scene list, parse it, and create a corresponding sceneList linked list.


functionDescription:
Displays the list of model names in a scene list in the indicated combo box.


functionDescription:
Returns the number of models in the scene list.

returnDescription:
Returns the number of models in the scene list.


prototype:
int sceneList::getSceneInfo(char *name, int *type,int *cMode, int *outRows, int *outCols);

shortPrototype:
int sceneList::getSceneInfo(char *name, int *type,int *cMode, int *outRows, int *outCols);

functionDescription:
Returns information about the effect described in the scene list.

returnDescription:
Returns information about the effect described in the scene list.


prototype:
int sceneList::setSceneOutImageSize(int outRows, int outCols);

shortPrototype:
int sceneList::setSceneOutImageSize(int outRows, int outCols);

functionDescription:
Sets the size of the image or images to be produced.


prototype:
int sceneList::getViewTransform(float *viewX, float *viewY, float *viewZ,float *rotateX, float *rotateY, float *rotateZ);

shortPrototype:
int sceneList::getViewTransform(float *viewX, float *viewY, float *viewZ,float *rotateX, float *rotateY, float *rotateZ);

functionDescription:
Retrieves the viewpoint (camera) relative location and orientation.


prototype:
int sceneList::setViewTransform(float viewX, float viewY, float viewZ,float rotateX, float rotateY, float rotateZ);

shortPrototype:
int sceneList::setViewTransform(float viewX, float viewY, float viewZ,float rotateX, float rotateY, float rotateZ);

functionDescription:
Sets the viewpoint (camera) relative location and orientation.


prototype:
int sceneList::getViewPoint(float *viewX, float *viewY, float *viewZ,float *rotateX, float *rotateY, float *rotateZ);

shortPrototype:
int sceneList::getViewPoint(float *viewX, float *viewY, float *viewZ,float *rotateX, float *rotateY, float *rotateZ);

functionDescription:
Retrieves the current viewpoint (camera) location and orientation.  This is determined by adding the viewpoint relative location and orientation to the default camera location of (0,0, 512).


prototype:
int sceneList::writeList(char *errorText, char *fileName);

shortPrototype:
int sceneList::writeList(char *errorText, char *fileName);

functionDescription:
Saves the contents of the scene List to a scene file.


prototype:
int sceneList::preview(HWND theWindow, tMatrix *modelMatrix, tMatrix *viewMatrix);

shortPrototype:
int sceneList::preview(HWND theWindow, tMatrix *modelMatrix, tMatrix *viewMatrix);

functionDescription:
Previews the contents of a scene list by drawing wireframes of each model in the scene list.


prototype:
int sceneList::previewStill(HWND theWindow, tMatrix *modelMatrix,tMatrix *viewMatrix);

shortPrototype:
int sceneList::previewStill(HWND theWindow, tMatrix *modelMatrix,tMatrix *viewMatrix);

functionDescription:
Previews the contents of a scene list by drawing wireframes of each model in the scene list.  This version previews still image effects.  It is slightly different from member function preview in that it does not use a memory dc (used to produce smooth animation of previewed sequences) and the model names are drawn in red, not black.


prototype:
int sceneList::render(imageView *displayWindow, tMatrix *viewMatrix,int depthSortingEnabled, int zBufferEnabled, int antiAliasEnabled,int hazeFogEnabled);

shortPrototype:
int sceneList::render(imageView *displayWindow, tMatrix *viewMatrix,int depthSortingEnabled, int zBufferEnabled, int antiAliasEnabled,int hazeFogEnabled);

functionDescription:
Render an effect by rendering all the models in the scene list.


prototype:
void getSequenceFileName(char *theInputPath, int frameCounter);

shortPrototype:
void getSequenceFileName(char *theInputPath, int frameCounter);

functionDescription:
Constructs a sequence file name from the input image pathname and the current frame counter.  The new filename is returned in theInputPath.


prototype:
void getFileName(char *outputFileName, char *prefix, int counter,int theColor);

shortPrototype:
void getFileName(char *outputFileName, char *prefix, int counter,int theColor);

functionDescription:
Constructs a filename from a pathname prefix, a frame counter, and a color indicator.


prototype:
void appendFileName(char *outputFileName, char *prefix,char *suffix);

shortPrototype:
void appendFileName(char *outputFileName, char *prefix,char *suffix);

functionDescription:
Constructs a pathname by concatenating the prefix and suffix strings.


prototype:
void constructPathName(char *outPath, char *inPath, char lastLetter);

shortPrototype:
void constructPathName(char *outPath, char *inPath, char lastLetter);

functionDescription:
The output pathname is constructed by appending the lasLetter character to the inPath.


prototype:
void sceneList::adjustTransforms(int effectType, sceneElement *theModel,motionNode *aMotion, bundle *xfrm);

shortPrototype:
void sceneList::adjustTransforms(int effectType, sceneElement *theModel,motionNode *aMotion, bundle *xfrm);

functionDescription:
Model locations and orientations can come from two potential sources.  If the model is moving, the location and orientation information come from the motion file.  If the model is not moving, its location and orientation come from the scene file.  Function adjustTransforms determines where a model's location and orientation information reside and copies them into the bundle object xfrm.


prototype:
void sceneList::getViewMatrix(tMatrix *viewMatrix, int frameCounter, scene *theScene);

shortPrototype:
void sceneList::getViewMatrix(tMatrix *viewMatrix, int frameCounter, scene *theScene);

functionDescription:
Returns the scene list view matrix.  This is the perspective transformation corresponding to the camera's current location and orientation.  If the camera moves during the effect, this function retrieves the camera location and orientation for the current frame from the appropriate motion file.


functionDescription:
Used during parsing of a scene file.  Checks for three integers or floating point numbers separated by spaces. Returns True if the test is successful.  False is returned if the test is not successful.

returnDescription:
Returns True if the test is successful.  False is returned if the test is not successful.


prototype:
int sceneList::calcCompoundModelRefPoint(sceneElement *theModel, int outputRows, int outputColumns,float *cmCentroidX, float *cmCentroidY, float *cmCentroidZ);

shortPrototype:
int sceneList::calcCompoundModelRefPoint(sceneElement *theModel, int outputRows, int outputColumns,float *cmCentroidX, float *cmCentroidY, float *cmCentroidZ);


prototype:
void tMatrix::multiply(tMatrix *matrix1, tMatrix *matrix2);

shortPrototype:
void tMatrix::multiply(tMatrix *matrix1, tMatrix *matrix2);


functionDescription:
Initializes a tMatrix to the 4 x 4 identity matrix.


prototype:
void tMatrix::scale(float sx, float sy, float sz);

shortPrototype:
void tMatrix::scale(float sx, float sy, float sz);

functionDescription:
Composite a scaling operation into the tMatrix


prototype:
void tMatrix::translate(float tx, float ty, float tz);

shortPrototype:
void tMatrix::translate(float tx, float ty, float tz);

functionDescription:
Composite a translation into the tMatrix


prototype:
void tMatrix::rotate(float rx,float ry,float rz);

shortPrototype:
void tMatrix::rotate(float rx,float ry,float rz);


prototype:
void matmult(float result[4][4],float mat1[4][4],float mat2[4][4]);

shortPrototype:
void matmult(float result[4][4],float mat1[4][4],float mat2[4][4]);


functionDescription:
Copies the source matrix into the destination matrix.


prototype:
void tMatrix::transformPoint(float xIn, float yIn, float zIn, float *xOut,float *yOut, float *zOut);

shortPrototype:
void tMatrix::transformPoint(float xIn, float yIn, float zIn, float *xOut,float *yOut, float *zOut);

functionDescription:
Apply the tMatrix transform to the input coordinate to produce a transformed coordinate.


prototype:
void tMatrix::transformPoint1(point3d *in, point3d *out);

shortPrototype:
void tMatrix::transformPoint1(point3d *in, point3d *out);


functionDescription:
Inverts a tMatrix object using Gaussian elimination with partial pivoting.  The significance of the resulting inverse matrix is that it can be used to map transformed coordinates back to the original (untransformed) surface coordinates.


prototype:
void tMatrix::transformAndProjectPoint(float x, float y, float z, int *sx,int *sy, float refX, float refY, float refZ,int outHeight, int outWidth,float *tx, float *ty, float *tz);

shortPrototype:
void tMatrix::transformAndProjectPoint(float x, float y, float z, int *sx,int *sy, float refX, float refY, float refZ,int outHeight, int outWidth,float *tx, float *ty, float *tz);

functionDescription:
Transforms and projects the input point to the view screen.  The point is translated to the reference point before the transformation is applied.


prototype:
void tMatrix::transformAndProjectPoint1(point3d *p, point2d *s, point3d *ref,int outHeight, int outWidth, point3d *t);

shortPrototype:
void tMatrix::transformAndProjectPoint1(point3d *p, point2d *s, point3d *ref,int outHeight, int outWidth, point3d *t);


prototype:
void tMatrix::transformAndProject (shape3d *aShape, int outHeight,int outWidth, int useExternalCentroid,float centroidX, float centroidY, float centroidZ);

shortPrototype:
void tMatrix::transformAndProject (shape3d *aShape, int outHeight,int outWidth, int useExternalCentroid,float centroidX, float centroidY, float centroidZ);

functionDescription:
Transforms and projects the coordinates of the indicated shape object to the view screen.  The shape vertices are translated to the reference point before the transformation is applied.


functionDescription:
Returns a pointer to the image document.  In this case, the memimage object.

returnDescription:
Returns a pointer to the image document.  In this case, the memimage object.


functionDescription:
The Windows document/view metaphor separates document properties/functions from viewing properties/functions.  This function associates the memImage object passed in with the image document object.


functionDescription:
Checks to make certain the object is valid


functionDescription:
Sets the caption on the image viewing window.


prototype:
void imageView::getScrollPos(int *xPixels, int *yPixels);

shortPrototype:
void imageView::getScrollPos(int *xPixels, int *yPixels);

functionDescription:
Returns the number of pixels the image has been scrolled in the x and y screen directions.


functionDescription:
Member function executes each time the image viewing window is updated.  See  MFC manual for more information.


prototype:
void imageView::OnLButtonDown(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnLButtonDown(UINT nFlags, CPoint point);

functionDescription:
Handler for the button down event that is part of a left mouse click event.  The left mouse button has been clicked at the location indicated in the Cpoint variable.


prototype:
void imageView::OnLButtonUp(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnLButtonUp(UINT nFlags, CPoint point);

functionDescription:
Handler for the button up event that is part of a left mouse click event.  The left mouse button has been clicked at the location indicated in the Cpoint variable.


prototype:
void imageView::OnLButtonDblClk(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnLButtonDblClk(UINT nFlags, CPoint point);

functionDescription:
Handler for the left mouse button double click event.  The left mouse button has been double clicked at the location indicated in the Cpoint variable.


prototype:
void imageView::OnRButtonDown(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnRButtonDown(UINT nFlags, CPoint point);

functionDescription:
Handler for the right mouse button  click event.  The right mouse button has been clicked at the location indicated in the Cpoint variable.


prototype:
void imageView::OnRButtonUp(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnRButtonUp(UINT nFlags, CPoint point);

functionDescription:
Handler for the right mouse button click event.  The right mouse button has been clicked at the location indicated in the Cpoint variable.


prototype:
void imageView::OnMouseMove(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnMouseMove(UINT nFlags, CPoint point);

functionDescription:
Handler for the mouse move event.  The mouse has moved to the location indicated in the Cpoint variable.


prototype:
int getSampleRange(memImage *theImage, int x, int y,int *redLow, int *redHigh, int *greenLow, int *greenHigh,int *blueLow, int *blueHigh);

shortPrototype:
int getSampleRange(memImage *theImage, int x, int y,int *redLow, int *redHigh, int *greenLow, int *greenHigh,int *blueLow, int *blueHigh);

functionDescription:
Returns the range of colors found in a 1 x 1 pixel neighborhood surrounding the indicated x,y location in the image.


prototype:
int blend(memImage *inImage, memImage *maskImage, memImage *outImage,float alphaScale);

shortPrototype:
int blend(memImage *inImage, memImage *maskImage, memImage *outImage,float alphaScale);

functionDescription:
Blends or composites two images together based on a third image called an alpha image.

returnDescription:
Returns 0 if no error encountered.  Else a message is posted to the log.


prototype:
int blendz(memImage *inImage, memImage *matteImage,memImage *zImage, memImage *zBuffer,memImage *outImage,float alphaScale);

shortPrototype:
int blendz(memImage *inImage, memImage *matteImage,memImage *zImage, memImage *zBuffer,memImage *outImage,float alphaScale);

functionDescription:
Blends or composites two images together using the contribution of an alpha image.  This variant of the blend function uses a z-buffer to provide a realistic rendering of 3D model surfaces.

returnDescription:
NULL is returned if no errors are encountered, else a message is posted to the log.


prototype:
int createCutout(memImage *originalImage, memImage *maskImage,char *cutoutName, shape3d *aShape);

shortPrototype:
int createCutout(memImage *originalImage, memImage *maskImage,char *cutoutName, shape3d *aShape);

functionDescription:
Create the cutout image and translate the shape to coincide with the cutout. Assumes the mask image is an unpacked (8 bit) mask image opened RANDOM.
The original must be opened for sequential access.

returnDescription:
NULL is returned if the operation is successful, else a message is posted to the log.


functionDescription:
Assumes the image has been rotoscoped.  Creates an unsmoothed alpha image (also called a mask image in various places in the code) by setting each non-zero pixel in the image to 255.


functionDescription:
Unpacks the image object into the indicated image.  The input image must have 1 bit pixels.  Each 1 bit pixel in the input image will correspond to an 8 bit pixel having the value 255 in the unpacked image.

returnDescription:
Returns NULL  if operation is successful, else a message is posted to the log.


functionDescription:
Usually applied to rotoscoped images.  Calculates the bounding box of all non-zero pixels in the image.  Adjusts the output image size so that it is equal to the bounding box.  In other words, the dimensions of the output image are as small as possible.  Any extra transparent border pixels are removed by this function.


prototype:
int in_boundary(memImage *anImage, int x, int y);

shortPrototype:
int in_boundary(memImage *anImage, int x, int y);

functionDescription:
Determines whether the intensity at 'x, y' is within the boundary being outlined. Points outside of the array of intensities are not in the boundary.

Returns 0 if the point is not in the boundary.
Returns 1 if the point is     in the boundary.

returnDescription:
Returns 0 if the point is not in the boundary.
Returns 1 if the point is     in the boundary.


prototype:
int probe(memImage *anImage, int x, int y, int dir, int *new_x, int *new_y);

shortPrototype:
int probe(memImage *anImage, int x, int y, int dir, int *new_x, int *new_y);

functionDescription:
Checks a sample neighboring 'x, y' to see if it is in the boundary being outlined.  'dir' specifies which neighboring sample to check.  'new_x, new_y' always get the coordinates of the neighbor.

Returns 0 if the neighbor is not in the boundary.
Returns 1 if the neighbor is     in the boundary.

returnDescription:
Returns 0 if the neighbor is not in the boundary.
Returns 1 if the neighbor is     in the boundary.


prototype:
int neighbor(memImage *anImage, int x, int y, int last_dir, int *new_x, int *new_y);

shortPrototype:
int neighbor(memImage *anImage, int x, int y, int last_dir, int *new_x, int *new_y);

functionDescription:
Finds a neighbor of the sample at 'x, y' that is in the same boundary.  Always follows the boundary in a clockwise direction. 'last_dir' is the direction that was used to get to 'x, y' when it was found.  'new_x, new_y' always get the coordinates of the neighbor. This procedure should only be called for a sample that has at least one neighbor in the same boundary. Returns the direction to the neighbor


prototype:
int shapeFromImage(memImage *anImage, shape3d *aShape);

shortPrototype:
int shapeFromImage(memImage *anImage, shape3d *aShape);

functionDescription:
Author:  Tim Feldman, Island Graphics Corporation . (The original code was published in Graphics Gems III without restrictions and is in the public domain.  Tim, if you are reading this....thanks!). Modified: Tim Wittenburg May 1996 The original procedure found contours in a grayscale image. This procedure finds the boundary of a single blob in a binary image. Populates a shape3d object with vertices from a blob in a binary image. The number of vertices produced is reduced substantially by saving only points in which the direction changes from the previous point.


functionDescription:
Handler that responds to the OK button press event.


prototype:
int createQMeshModel(char *inputImagePath, char *destinationDir, int modelType);

shortPrototype:
int createQMeshModel(char *inputImagePath, char *destinationDir, int modelType);

functionDescription:
Generates a quadrilateral mesh model of the type indicated. This means that a 3D surface is generated and registered with a supplied texture image.

returnDescription:
NULL is returned if the model is created successfully, else an informative message is posted to the log.


prototype:
int getMeshCentroid(memImage *xImage, memImage *yImage, memImage *zImage,float *centroidX, float *centroidY, float *centroidZ);

shortPrototype:
int getMeshCentroid(memImage *xImage, memImage *yImage, memImage *zImage,float *centroidX, float *centroidY, float *centroidZ);

functionDescription:
Calculates the world coordinate centroid of the mesh model.


prototype:
int translateMesh(memImage *xImage, memImage *yImage, memImage *zImage,float offsetX, float offsetY, float offsetZ);

shortPrototype:
int translateMesh(memImage *xImage, memImage *yImage, memImage *zImage,float offsetX, float offsetY, float offsetZ);

functionDescription:
Translates the mesh model coordinates by the indicated x, y, and z axis offsets.


prototype:
int createTexture(char *texturePath, char *outDirectory, int textureType,int imageType, int foreColor, int backColor, int numRows, int numColumns);

shortPrototype:
int createTexture(char *texturePath, char *outDirectory, int textureType,int imageType, int foreColor, int backColor, int numRows, int numColumns);

functionDescription:
Creates a texture image of the indicated type and size.


prototype:
void plasma(memImage *anImage, int x, int y, int x1, int y1);

shortPrototype:
void plasma(memImage *anImage, int x, int y, int x1, int y1);


prototype:
void createPlasma(memImage *anImage, int numRows, int numColumns);

shortPrototype:
void createPlasma(memImage *anImage, int numRows, int numColumns);


functionDescription:
Returns a random number between 0 and maxVal.

returnDescription:
Returns a random number between 0 and maxVal.


functionDescription:
Handler that responds to the Locate Texture Image button press event.


functionDescription:
Handler that responds to the locate destination directory button press event.


prototype:
void insertionSort2(float theItems[], DWORD itemData[], int numItems);

shortPrototype:
void insertionSort2(float theItems[], DWORD itemData[], int numItems);

functionDescription:
Sorts the list of items into desscending order for depth sorting.


prototype:
int sceneList::depthSort(sceneElement *models[], float distances[],int *numModels, int depthSortingEnabled);

shortPrototype:
int sceneList::depthSort(sceneElement *models[], float distances[],int *numModels, int depthSortingEnabled);

functionDescription:
Sorts the models included in a visual effect based on their distance from the viewer.  Themodel distances are sorted into descending order.


prototype:
float getDistance2d(float x1, float y1, float x2, float y2);

shortPrototype:
float getDistance2d(float x1, float y1, float x2, float y2);

functionDescription:
Returns the two dimensional Cartesian distance between two points

returnDescription:
The two dimensional Cartesian distance between two points


prototype:
float getDistance3d(float x1, float y1, float z1, float x2, float y2, float z2);

shortPrototype:
float getDistance3d(float x1, float y1, float z1, float x2, float y2, float z2);

functionDescription:
Returns the three dimensional Cartesian distance between two points

returnDescription:
The three dimensional Cartesian distance between two points


prototype:
void shape3d::getTCentroid(float *centroidX, float *centroidY, float *centroidZ);

shortPrototype:
void shape3d::getTCentroid(float *centroidX, float *centroidY, float *centroidZ);

functionDescription:
Return the transformed coordinate centroid.


prototype:
void vectorAdd(point3d *result, point3d *p1, point3d *p2);

shortPrototype:
void vectorAdd(point3d *result, point3d *p1, point3d *p2);


prototype:
void vectorSubtract(point3d *result, point3d *p1, point3d *p2);

shortPrototype:
void vectorSubtract(point3d *result, point3d *p1, point3d *p2);


prototype:
float vectorMagnitude2(point3d *p1, point3d *p2);

shortPrototype:
float vectorMagnitude2(point3d *p1, point3d *p2);

functionDescription:
Determines the vector magnitude from two points.


functionDescription:
Determines the vector magnitude from the input vector.


functionDescription:
Normalizes the input vector such that its magnitude is unity.


prototype:
void crossProduct(point3d *result, point3d *p1, point3d *p2, point3d *p3);

shortPrototype:
void crossProduct(point3d *result, point3d *p1, point3d *p2, point3d *p3);

functionDescription:
Calculates the vector cross product from the three input points.


prototype:
float dotProduct(point3d *p1, point3d *p2);

shortPrototype:
float dotProduct(point3d *p1, point3d *p2);

functionDescription:
Calculates the dot product of 2 vectors.


prototype:
void getNormal1(float x0, float y0, float z0, float x1, float y1, float z1, float x2, float y2, float z2, float *xN, float *yN, float *zN);

shortPrototype:
void getNormal1(float x0, float y0, float z0, float x1, float y1, float z1,		  float x2, float y2, float z2, float *xN, float *yN, float *zN);

functionDescription:
Returns the vector normal from three input points.


prototype:
void getNormal2(point3d *result, point3d *p0, point3d *p1, point3d *p2);

shortPrototype:
void getNormal2(point3d *result, point3d *p0, point3d *p1, point3d *p2);

functionDescription:
Calculates the normal vector from 3 input points.


prototype:
float lightModel(float kd, int Ip, int Ia, point3d *N, point3d *L, float d);

shortPrototype:
float lightModel(float kd, int Ip, int Ia, point3d *N, point3d *L, float d);

functionDescription:
Determines a lighting value based on a Lambertian lighting model.

returnDescription:
The light intensity based on the input parameters.


functionDescription:
Display the indicated message along with the point3d data members.


functionDescription:
Returns TRUE if the sceneElement (model) object is valid, else returns FALSE.

returnDescription:
Returns TRUE if the sceneElement (model) object is valid, else returns FALSE.


functionDescription:
Returns TRUE if the scene object is valid, else returns FALSE.  One implication of an invalid scene object is that the constructor was not able to allocate memory for it.

returnDescription:
Returns TRUE if the scene object is valid, else returns FALSE.  One implication of an invalid scene object is that the constructor was not able to allocate memory for it.


functionDescription:
Writes the contents of a sceneElement (model) object to the indicated output file stream.


functionDescription:
Writes the contents of a scene object to the indicated output file stream.


prototype:
int sceneList::addScene(char *theSceneName,int theType, int outImCols,int outImRows,  int theColorMode, point3d *rt, point3d *tr, char *thePath);

shortPrototype:
int sceneList::addScene(char *theSceneName,int theType, int outImCols,int outImRows,  int theColorMode, point3d *rt, point3d *tr, char *thePath);

functionDescription:
Adds a scene node to a scene list object.  Only one scene node may be created in a scene list.


prototype:
int sceneList::addSceneElement(char *mdName, char * fName, int blendI,int theType, int warpI, float aScale,point3d *rt,point3d *sc, point3d *tr, char *motionPath, char *theAlphaPath,int theSortLayer, RGBTRIPLE anAdjustment, char *adjustmentType, char *colorAdjustedPath,int definedRefPt, point3d *refPoint);

shortPrototype:
int sceneList::addSceneElement(char *mdName, char * fName, int blendI,int theType, int warpI, float aScale,point3d *rt,point3d *sc, point3d *tr, char *motionPath, char *theAlphaPath,int theSortLayer, RGBTRIPLE anAdjustment, char *adjustmentType, char *col

functionDescription:
Adds a scene element (also called a model) to a scene list.  This function is called once for each model in the scene file.


functionDescription:
Prints the contents of the scene list to the ICT log.


functionDescription:
Clears the scene list of all models and the scene descriptor.


prototype:
int sceneList::setModelReferencePoint(char *modelName, float centroidX, float centroidY,float centroidZ);

shortPrototype:
int sceneList::setModelReferencePoint(char *modelName, float centroidX, float centroidY,float centroidZ);


functionDescription:
Copy model reference points to each model's render object.


functionDescription:
Re initializes the graphic pipeline by re-initializing the Z Buffer and clearing the output image.


functionDescription:
Opens the Z Buffer and output images.  Initializes the Z Buffer.  Performs other graphic pipeline initialization steps.


prototype:
int gPipe::addFace(point3d *p1, point3d *p2, point3d *c1, point3d *c2);

shortPrototype:
int gPipe::addFace(point3d *p1, point3d *p2, point3d *c1, point3d *c2);

functionDescription:
Render a flat shaded 4 sided polygon by adding it to the graphic pipeline.  Each of the 4 points are expressed in world coordinates.

returnDescription:
Returns NULL if the render was successfull, otherwise a negative error code is returned and a message is posted to the log.


prototype:
void gPipe::setPenScale(float scaleX, float scaleY, float scaleZ);

shortPrototype:
void gPipe::setPenScale(float scaleX, float scaleY, float scaleZ);


prototype:
void gPipe::setPenTranslation(float tranX, float tranY, float tranZ);

shortPrototype:
void gPipe::setPenTranslation(float tranX, float tranY, float tranZ);

functionDescription:
Sets the VRML pen  X, Y, and Z translations.


functionDescription:
Creates the composite graphic transformation from the VRML pen rotation, scale, and translations.


functionDescription:
Creates the VRML view matrix from the viewpoint (camera) translations and rotations.


functionDescription:
Applies the viewpoint matrix to the VRML pen.


functionDescription:
Initializes the VRML pen matrix to its initial location at the origin.


functionDescription:
Saves the gPipe Z Buffer image to the pathname specified.  The image is a 32 bit .bmp image.


functionDescription:
Saves the gPipe output image to the pathname indicated.


functionDescription:
Activates or deactivates the lighting model.


prototype:
void gPipe::addCube(float width, float height, float depth);

shortPrototype:
void gPipe::addCube(float width, float height, float depth);

functionDescription:
Render a VRML Cube shape by adding it to the graphic pipeline.  The cube is rendered at the current VRML pen location and orientation.


functionDescription:
Render a VRML sphere shape by adding it to the graphic pipeline.  The sphere is rendered at the current VRML pen location and orientation.


prototype:
void gPipe::addCylTop(float height, float radius);

shortPrototype:
void gPipe::addCylTop(float height, float radius);

functionDescription:
Render the top part of a VRML Cylinder shape by adding it to the graphic pipeline


prototype:
void gPipe::addCylBottom(float height, float radius);

shortPrototype:
void gPipe::addCylBottom(float height, float radius);

functionDescription:
Render the bottom part of a VRML Cylinder shape by adding it to the graphic pipeline


prototype:
void gPipe::addCylSides(float height, float radius);

shortPrototype:
void gPipe::addCylSides(float height, float radius);

functionDescription:
Render the side part of a VRML Cylinder shape by adding it to the graphic pipeline


prototype:
void gPipe::addConeBottom(float height, float bottomRadius);

shortPrototype:
void gPipe::addConeBottom(float height, float bottomRadius);

functionDescription:
Render the bottom part of the VRML Cone shape by adding it to the graphic pipeline


prototype:
void gPipe::addConeSides(float height, float bottomRadius);

shortPrototype:
void gPipe::addConeSides(float height, float bottomRadius);

functionDescription:
Render the side part of the VRML Cone shape by adding it to the graphic pipeline


functionDescription:
Update the bounding box subtended by the location and orientation of all models in the VRML world by considering the point indicated.


functionDescription:
Returns True if the viewpoint is inside the bounding box created by the locations of all the models that have been placed in the pipeline, if the viewpoint is outside this bounding box, False is returned.

returnDescription:
Returns True if the viewpoint is inside the bounding box created by the locations of all the models that have been placed in the pipeline, if the viewpoint is outside this bounding box, False is returned.


functionDescription:
Sets the location of a light source to the location passed.


functionDescription:
Parses the indicated VRML world file, then calls the traverse function which traverses the VRML tree rendering portions of the tree.


functionDescription:
Handler for the Locate Destination Directory button press event.


functionDescription:
Displays a message on the status window located at the lower left portion of the screen.  The message is also saved in the ICT log file.


functionDescription:
The preference object holds a number of default locations for the various types of files that are either produced by ICT or are used by ICT.  Paths can be retrieved from the preference object by calling this function with the name of the path desired.  The Utils.h file has a complete list of the types of paths that can be requested.


prototype:
void preference::setPath(int pathIndicator, char *thePath);

shortPrototype:
void preference::setPath(int pathIndicator, char *thePath);

functionDescription:
Sets the indicated pathname to a new location.


functionDescription:
Returns TRUE if the indicated file exists.  Returns FALSE if the file does not exist.

returnDescription:
Returns TRUE if the indicated file exists.  Returns FALSE if the file does not exist.


prototype:
float interpolate(float desired1, float desired2, float reference1, float reference2,float referenceCurrent);

shortPrototype:
float interpolate(float desired1, float desired2, float reference1, float reference2,float referenceCurrent);

functionDescription:
Returns an interpolated value between the range desired1 and desired2 based on the reference range and a value that is some percentage between reference 1 and reference 2.

returnDescription:
Returns an interpolated value between the range desired1 and desired2 based on the reference range and a value that is some percentage between reference 1 and reference 2.


functionDescription:
Returns an angle between 0 and 360 degrees.

returnDescription:
Returns an angle between 0 and 360 degrees.


functionDescription:
Returns the polar angle (between 0 and 360) of the indicated line segment

returnDescription:
Returns the polar angle (between 0 and 360) of the indicated line segment


prototype:
float bound(float value, float minValue, float maxValue);

shortPrototype:
float bound(float value, float minValue, float maxValue);

functionDescription:
Returns a value bounded by minValue and maxValue.

returnDescription:
Returns a value bounded by minValue and maxValue.


prototype:
void makePath(char *currentPath, char *inPath, char *prefix, int frameCounter, char *inSuffix);

shortPrototype:
void makePath(char *currentPath, char *inPath, char *prefix, int frameCounter, char *inSuffix);

functionDescription:
Creates an output image name by concatenating the input pathname, the prefix, the frame number and the suffix.


prototype:
int getPathPieces(char *firstImagePath, char *directory, char *fileName,char *prefix, int *frameNum, char *inSuffix);

shortPrototype:
int getPathPieces(char *firstImagePath, char *directory, char *fileName,char *prefix, int *frameNum, char *inSuffix);

functionDescription:
Splits an input pathname into its component parts.


functionDescription:
Handler that responds to the selection of a model from the effect preview dialog combo box.


functionDescription:
Handler that checks or unchecks the move viewpoint check box.


functionDescription:
Handler that responds to the Minus button press event.


functionDescription:
Handler that responds to the plus button press event.


functionDescription:
Handler that responds to the reset button press event.


functionDescription:
Fills the scene preview dialog box fields with the rotation, scale, and translation of the currently selected model.


functionDescription:
Fills the scene preview dialog box fields with the rotation, scale, and translation of the viewpoint.


prototype:
void CScenePreviewDlg::OnMove(int x, int y);

shortPrototype:
void CScenePreviewDlg::OnMove(int x, int y);


prototype:
int fillRect(int x1, int y1, float i1,int x2, int y2, float i2,int x3, int y3, float i3,int x4, int y4, float i4,memImage *theImage);

shortPrototype:
int fillRect(int x1, int y1, float i1,int x2, int y2, float i2,int x3, int y3, float i3,int x4, int y4, float i4,memImage *theImage);

functionDescription:
Smooth shades a rectangular polygon.  The rendered result is saved to the indicated image.


prototype:
int memImage::fillPolyz(int I1x, int I1y, float I1p, float I1d,int I2x, int I2y, float I2p, float I2d,int I3x, int I3y, float I3p, float I3d,int I4x, int I4y, float I4p, float I4d,memImage *zBuffer);

shortPrototype:
int memImage::fillPolyz(int I1x, int I1y, float I1p, float I1d,int I2x, int I2y, float I2p, float I2d,int I3x, int I3y, float I3p, float I3d,int I4x, int I4y, float I4p, float I4d,memImage *zBuffer);

functionDescription:
Smooth shades (Gouraud) the four sided, two dimensional polygon whose vertices are supplied.  The distance between each vertex and the viewpoint must be supplied in order for the Z-Buffer to operate correctly.  This function can be used without the Z-Buffer by setting the zBuffer image pointer to NULL.


prototype:
int fillTrianglez(int x1, int y1, float i1, float d1,int x2, int y2, float i2, float d2,int x3, int y3, float i3, float d3,memImage *outImage, memImage *zImage);

shortPrototype:
int fillTrianglez(int x1, int y1, float i1, float d1,int x2, int y2, float i2, float d2,int x3, int y3, float i3, float d3,memImage *outImage, memImage *zImage);

functionDescription:
Smooth shades a triangular polygon optionally using a Z Buffer.


prototype:
BYTE getLight(point3d *p1, point3d *p2, point3d *c1, point3d *c2);

shortPrototype:
BYTE getLight(point3d *p1, point3d *p2, point3d *c1, point3d *c2);

functionDescription:
Returns the light value produced by the Lambertian lighting model based on the orientation of the indicated planar surface.

returnDescription:
Returns the light value produced by the Lambertian lighting model based on the orientation of the indicated planar surface.


prototype:
int createTweenableShapes(shape3d *inShape1, shape3d *inShape2,shape3d **outShapeA, shape3d **outShapeB);

shortPrototype:
int createTweenableShapes(shape3d *inShape1, shape3d *inShape2,shape3d **outShapeA, shape3d **outShapeB);

functionDescription:
Construct boundaries equivalent to inShape1 and inShape2 such that the number of vertices in outShapeA is equal to the number of vertices in outShapeB.


prototype:
int tweenShape(float fraction, shape3d **outShape, shape3d *shape1, shape3d *shape2);

shortPrototype:
int tweenShape(float fraction, shape3d **outShape, shape3d *shape1, shape3d *shape2);

functionDescription:
Construct a new boundary that is a fractional combination of shape1 and shape2.


prototype:
int shape3d::insertVertexAfter(int index, float x, float y, float z);

shortPrototype:
int shape3d::insertVertexAfter(int index, float x, float y, float z);

functionDescription:
Insert a world vertex after the index-th vertex. This function assumes that there is enough room in the existing shape to accomodate a new world vertex.  If there is not enough room in the shape to accomodate the new vertex, an error results. index is a zero relative location after which the new vertex is to be added.


functionDescription:
Creates a new shape object that has an expanded number of vertices.

returnDescription:
Returns a new shape object with the expanded number of vertices.


prototype:
int tweenImage(float aFraction,memImage *inImageA, memImage *inImageB,char *imagePath, char *shapePath);

shortPrototype:
int tweenImage(float aFraction,memImage *inImageA, memImage *inImageB,char *imagePath, char *shapePath);

functionDescription:
Morph two images.  The morphed output image is a fractional blending of the boundary of images A and B and the image intensities of image A and image B.


prototype:
int tweenMesh(float aFraction,memImage *aTexture, memImage *aX, memImage *aY,memImage * aZ,memImage *bTexture, memImage *bX, memImage *bY,memImage * bZ,memImage *oTexture, memImage *oX, memImage *oY,memImage * oZ);

shortPrototype:
int tweenMesh(float aFraction,memImage *aTexture, memImage *aX, memImage *aY,memImage * aZ,memImage *bTexture, memImage *bX, memImage *bY,memImage * bZ,memImage *oTexture, memImage *oX, memImage *oY,memImage * oZ);

functionDescription:
Morph two quad meshes together.  Both meshes must have the same number of rows and columns.


functionDescription:
Add a vertex to a shape object by finding the longest line segment and subdividing it.


prototype:
int getRowIntervals(memImage *anImage, int row, int *intervalList, int *numIntervals);

shortPrototype:
int getRowIntervals(memImage *anImage, int row, int *intervalList, int *numIntervals);

functionDescription:
Examine the indicated row in the image and detect the intervals of non zero pixels.


prototype:
int getTotalIntervalLength(int *intervalList, int numIntervals);

shortPrototype:
int getTotalIntervalLength(int *intervalList, int numIntervals);

functionDescription:
Returns the sum of the lengths of each interval in the interval list.

returnDescription:
Returns the sum of the lengths of each interval in the interval list.


prototype:
int indexToCoord(int index, int *intervalList, int numIntervals);

shortPrototype:
int indexToCoord(int index, int *intervalList, int numIntervals);

functionDescription:
Returns the coordinate corresponding to the index th location in the interval list.

returnDescription:
Returns the coordinate corresponding to the index th location in the interval list.


functionDescription:
Handler for the locate destination directory button press event.


functionDescription:
Handler that responds to selection of the locate destination directory button press event.


functionDescription:
Handler that responds to selection of the 2D morph radio button press event.


functionDescription:
Handler that responds to selection of the 3D morph radio button press event.


prototype:
int maskFromShape(shape3d *inShape, memImage *maskImage);

functionDescription:
Creates a mask image from the two dimensional boundary described in the shape object.  This function is used by the tweenImage procedure to create morph sequences.

returnDescription:
Returns NULL if the operation was successful.  Otherwise a message is posted to the log.


prototype:
int memImage::getBoundingBox(int *xBeg, int *xEnd, int *yBeg, int *yEnd);

functionDescription:
Returns the bounding box of the contents of an image.  Used with rotoscoped images to find the bounding box and subsequently the centroid of what remains of the image after rotoscoping.


prototype:
int renderMesh(char *outputImagePath, memImage *textureImage,memImage *xImage, memImage *yImage, memImage *zImage, tMatrix *aMatrix);


functionDescription:
Copies an 8 bit image to a monochrome 24 bit image


# FunctionArgument

argumentDescription:
The location of the VRML world file to read


argumentDescription:
The pathname of the VRML world file to render


argumentDescription:
The pathname in which to store the rendered image.  The output image is a Windows bitmap (.bmp).


argumentDescription:
The matrix containing the viewer location and orientation


argumentDescription:
Handle to the GDI device context to draw to.


argumentDescription:
The number of rows or y dimension of the display screen


argumentDescription:
The number of columns or x dimension of the display screen


argumentDescription:
The array of model distances to be sorted.  This array contains the key.


argumentDescription:
Pointer to a shape object containing the screen vertices that were traced out by the user.


argumentDescription:
Handle to the window in which the image resides.


argumentDescription:
The image file name in which to store a mask image.


argumentDescription:
The pathname of the rotoscoped image (also called a cutout)


argumentDescription:
The image height in pixels (y dimension)


argumentDescription:
The x axis offset to add to output drawing coordinates


argumentDescription:
The y axis offset to add to output drawing coordinates


argumentDescription:
The input texture image.  The names of the x, y, and z images are derived from the name of the texture image.


argumentDescription:
blend indicator.  TRUE if the model image is to be blended into the background plate


argumentDescription:
An 8 bit alpha image corresponding to the input image.


argumentDescription:
The height of the output image in pixels


argumentDescription:
Default: FALSE, in this case the object is transformed relative to its centroid.  If TRUE, the object is transformed relative to the 3D point point.


argumentDescription:
x coordinate of point.  Used only if useExternalCentroid is TRUE.


argumentDescription:
y coordinate of point.  Used only if useExternalCentroid is TRUE.


argumentDescription:
z coordinate of point.  Used only if useExternalCentroid is TRUE.


argumentDescription:
x axis reference point (world coord. system)


argumentDescription:
y axis reference point (world coord. system)


argumentDescription:
z axis reference point (world coord. system)


argumentDescription:
x coordinate around which to draw the box.


argumentDescription:
y coordinate around which to draw the box.


argumentDescription:
TRUE if the model image is to be blended into the background plate


argumentDescription:
The transformed x coordinate (world coord system)


argumentDescription:
The transformed y coordinate (world coord system)


argumentDescription:
The transformed z coordinate (world coord system)


argumentDescription:
TRUE if the line segment is horizontal, else FALSE


argumentDescription:
TRUE if the line segment is vertical, else FALSE


argumentDescription:
The 3D object boundary upon which scan conversion will occur.


argumentDescription:
y coordinate of the horizontal scan line that crosses the boundary.


argumentDescription:
The number of screen coordinates found during scan conversion.


argumentDescription:
The maximum lenth of the screenXCoords array.  No more than numAllocatedX Coordinates can be generated during scan conversion without enlarging the array.


argumentDescription:
The array containing the x coordinates that cross the scan line y.  These are sorted in ascending order and duplicates are removed.


argumentDescription:
A list of world x coordinates corresponding to the array of screen X coordinates


argumentDescription:
A list of world y coordinates corresponding to the array of screen X coordinates


argumentDescription:
A list of world z coordinates corresponding to the array of screen X coordinates


argumentDescription:
A model attribute to be moved along with the sorted key values.


argumentDescription:
An array of data to carry along with the sorted keys.


argumentDescription:
The number of items in the list after duplicates were removed.


argumentDescription:
The texture image to be used if the model is to be texture mapped.


argumentDescription:
TRUE if the model image is to be warped into the background plate


argumentDescription:
The output image. Contains the background plate if one is being used.


argumentDescription:
Pointer to Z-buffer image.  If NULL, rendering occurs without a Z Buffer.


argumentDescription:
Pointer to Z-buffer image.  The Z Buffer is ignored as are the transformed coordinates if zImage is set to NULL.


argumentDescription:
The upper left corner of the rectangle as viewed from the positive Z axis, looking toward the origin.


argumentDescription:
The upper right corner of the rectangle.


argumentDescription:
The lower right corner of the rectangle.


argumentDescription:
The type of shape file: WITHFACES, WITHOUTFACES


argumentDescription:
The number of vertices in the shape object.


argumentDescription:
The location of the shape file to create.


argumentDescription:
The number of pixels to offset the image in the x direction


argumentDescription:
The number of pixels to offset the image in the y direction


argumentDescription:
The number of pixels to offset the image in the z direction


argumentDescription:
A character string containing the line retrieved from the shape file.


argumentDescription:
The line number.  The first line is 1,  The returned line number counts blank lines and comments.


argumentDescription:
The minimum line length in characters.  Lines shorter than minLineLength are ignored.


argumentDescription:
A directory in which to store shape files.


argumentDescription:
The vertices of this shape are added to the shape object's vertices.


argumentDescription:
The number of world distance line segments to sum.  VertexNumber is 1 relative.  If vertexNumber is zero, the total shape boundary distance is returned.


argumentDescription:
The 0 relative index after which the vertex is to be subsequently added.


argumentDescription:
A floating point value to which all pixels in the image are set.


argumentDescription:
The image that receives the scaled image intensities.


argumentDescription:
The device context into which a memImage object is displayed.


argumentDescription:
A device context into which to draw the polygon.


argumentDescription:
Number of pixels in the x direction to offset the copied image.


argumentDescription:
Number of pixels in the y direction to offset the copied image.


argumentDescription:
The x axis offset.  (Use 0 of no offset is desired).


argumentDescription:
The y axis offset.  (Use 0 of no offset is desired).


argumentDescription:
x coordinate of the pixel to be retrieved.


argumentDescription:
y coordinate of the pixel to be retrieved.


argumentDescription:
The color component of the pixel to be retrieved.  Examples: 'r', 'g', 'b'.


argumentDescription:
The x coordinate of the pixel to be returned.


argumentDescription:
The y coordinate of the pixel to be returned.


argumentDescription:
The name of the .bmp file in which to save the memImage object.


argumentDescription:
The name of the 24 bit .bmp file to read.


argumentDescription:
The color of the image to read into memory.


argumentDescription:
Image file name whose header is to be read.


argumentDescription:
Example values of myBitsPerPixel are: 1, 8, 24, 32.


argumentDescription:
A pathname pointing to an 8 bit per pixel image containing a red image.


argumentDescription:
A pathname pointing to an 8 bit per pixel image containing a green image.


argumentDescription:
A pathname pointing to an 8 bit per pixel image containing a blue image.


argumentDescription:
A pathname pointing to the 24 bit per pixel image that will be created.


argumentDescription:
A color specification.  Examples are: REDCOLOR, RGBCOLOR.


argumentDescription:
The name of the .bmp file into which the 8 bit scaled image is to be stored.


argumentDescription:
desired red color (a value between 0-255)


argumentDescription:
desired green color (a value between 0-255)


argumentDescription:
desired blue color (a value between 0-255)


argumentDescription:
The average red intensity in the unadjusted image.


argumentDescription:
The average green intensity in the unadjusted image.


argumentDescription:
The average blue intensity in the unadjusted image.


argumentDescription:
The adjusted image is storeed in this output image


argumentDescription:
Type of desired color adjustment: 'Target' or 'Relative'.


argumentDescription:
Used only if the input image is 8 bits per pixel (monochrome).  One of 3 possible values is expected: REDCOLOR, GREENCOLOR,or BLUECOLOR. This variable tells the code which of the desired red, green, or blue colors to use to perform the color adjustment.


argumentDescription:
Image file name.  This fileName is copied to the memImage objects fileName data member.


argumentDescription:
The number of motion nodes for which to allocate memory.


argumentDescription:
The first frame number defined in a motion path.


argumentDescription:
The last frame number defined in a motion path.


argumentDescription:
A motion node structure to receive the copy.


argumentDescription:
A motion node.  The motion node  returned is interpolated if the frameNumber lies between keyframes.


argumentDescription:
The location of the motion path file to read


argumentDescription:
Pathname to the first image in the sequence to be blurred.  This path is assumed to be the first image in a series of images that use the ICT sequence file naming convention described in the text.


argumentDescription:
The directory to contain the output blurred sequence


argumentDescription:
The number of blurred image frames to produce.


argumentDescription:
The number of frames on either side (in time) of the current frame that contribute to each blurred output image.


argumentDescription:
A message indicating the result of the parse.


argumentDescription:
The type of effect to be created (Examples: STILL, SEQUENCE)


argumentDescription:
The height of the output image (y dimension)


argumentDescription:
The width of the output image (x dimension)


argumentDescription:
Contains a status message resulting from the save operation.


argumentDescription:
Handle to the GDI window in which to draw the preview.


argumentDescription:
A perspective matrix containing the model location and orientation


argumentDescription:
The image in which to display the rendered output


argumentDescription:
TRUE if depth sorting is enabled during effect rendering, else FALSE. If FALSE, models are rendered in the order in which they appear in the scene file.


argumentDescription:
TRUE if Z buffer is enabled, otherwise FALSE


argumentDescription:
True if anti-aliasing is to be applied to each output image.


argumentDescription:
Contains both the input path and the returned output pathname.


argumentDescription:
The filename prefix.  This can be an absolute pathname.


argumentDescription:
The returned filename.  Prefix and suffix are concatenated to produce the result.


argumentDescription:
The filename suffix. Example: A single letter such as 'a' for alpha image.


argumentDescription:
The output pathname.  LastLetter is appended to the inPath.


argumentDescription:
The type of effect being produced.  Example values: STILL, SEQUENCE


argumentDescription:
Contains the adjusted model location and orientation


argumentDescription:
Pointer to the scene object containing the present viewpoint location and orientation.


argumentDescription:
A character string containing the set of 3 numbers to be checked.


argumentDescription:
The number of columns in the output image


argumentDescription:
The tMatrix object that receives the data from the this object.


argumentDescription:
Message to be displayed prior to display of tMatrix contents.


argumentDescription:
A shape object whose coordinates are to be transformed


argumentDescription:
The memImage object associated with the image document.


argumentDescription:
A device context to dump image document information to.


argumentDescription:
The caption to display on the image viewing window.


argumentDescription:
Number of pixels scrolled in the screen x direction.


argumentDescription:
Number of pixels scrolled in the screen y direction.


argumentDescription:
The location of the mouse when the left mouse button was clicked.


argumentDescription:
The location of the mouse when the mouse button was clicked.


argumentDescription:
x coordinate center of the neighborhood to be sampled.


argumentDescription:
y coordinate center of the neighborhood to be sampled.


argumentDescription:
Input image.  This image must be 8 bits per pixel.


argumentDescription:
The input image is blended into the output image based on the contents of the alpha image.


argumentDescription:
A scale factor applied to the input image contribution.  A negative alpha scale factor will create a shadow because it causes a percentage of the inimage to be subtracted from the output image.  Values between 0 and 1 will vary the translucency.


argumentDescription:
The z-image corresponding to the input image.


argumentDescription:
The image to contain the rendered result.


argumentDescription:
A scale factor applied to the input image and its alpha image.


argumentDescription:
Input image.  Must be opened for sequential access.


argumentDescription:
The name of the rotoscoped cutout image and the shape file. This is the filename without the suffix.


argumentDescription:
Pointer to a shape object containing the screen vertices that were collected by the user during the operation of tracing around the object of interest.


argumentDescription:
The output image, containing the alpha image.


argumentDescription:
memImage object to contain the unpacked image.


argumentDescription:
The output Image pathname.  The output image has been reduced as necessary to correspond to the non-zero pixels in the image.


argumentDescription:
specifies which neighboring sample to check


argumentDescription:
The x coordinate of the neighbor pixel located in the indicated direction


argumentDescription:
The y coordinate of the neighbor pixel located in the indicated direction


argumentDescription:
the direction that was used to get to 'x, y'


argumentDescription:
The x coordinate after applying the new direction to the current coordinate.


argumentDescription:
Pointer to an opened image.  The image is assumed to be binary.  That is, 8 bits per pixel with intensities of either 0 indicating off or 255 indicating on.


argumentDescription:
Pointer to a shape object that will contain the boundary of the binary image.


argumentDescription:
The texture image to be used in the creation of a QuadMesh model.


argumentDescription:
The directory into which will be placed the x, y, and z coordinate images of the resulting quadrilateral mesh.


argumentDescription:
The type of Quad mesh model to generate.


argumentDescription:
The number of units to translate the image in the x direction


argumentDescription:
The number of units to translate the image in the y direction


argumentDescription:
The number of units to translate the image in the z direction


argumentDescription:
1 = 8 bits per pixel, 2=24 bpp, 3 = 32 bpp


argumentDescription:
CONSTANT, CHECKERBOARD,HORZRAMP etc.  ICT20.h has the complete list of types.


argumentDescription:
foreground color.  Used for the checkerboard.


argumentDescription:
backcround color.  Used for the checkerboard.


argumentDescription:
The number of rows (height, or y dimension) in the output image


argumentDescription:
The number of columns (x dimension or width) in the output image


argumentDescription:
The number of rows (height, or y dimension of the image)


argumentDescription:
The number of columns (x dimension or width) in the imag


argumentDescription:
An array of model distances to the viewpoint.


argumentDescription:
TRUE if depth sorting is enabled during effect rendering, else FALSE


argumentDescription:
The coefficient of reflection or reflectivity of the surface material. highly reflective = 1, highly absorptive = 0


argumentDescription:
Direction of the light source (unit vector)


argumentDescription:
Distance between the surface and the viewpoint


argumentDescription:
The type of effect to be created. Values: STILL, or SEQUENCE


argumentDescription:
The width (x dimension) of the output image


argumentDescription:
The height (y dimension) of the output image


argumentDescription:
The color mode. Values: COLOR or MONOCHROME


argumentDescription:
Relative camera orientation consisting of three rotation angles in degrees


argumentDescription:
Relative camera location consisting of three translations.


argumentDescription:
If effect is a SEQUENCE, this is a motion path file that describes the motion of the viewpoint (camera) during the effect. If the effect is a STILL, thePath is 'None'.


argumentDescription:
The image file or shape file associated with this model.


argumentDescription:
modelType.  See ict20.h for a complete list of model types.


argumentDescription:
If the model is to move in the effect being created, the location of the motion path file. If the model does not move, set motionPath to NULL.


argumentDescription:
If a custom alpha image or matte is to be used during rendering, the path of the matt image, else NULL.


argumentDescription:
Type of desired color adjustment: RELATIVE or ABSOLUTE


argumentDescription:
The path to which to save the color adjusted image.


argumentDescription:
True if the model's reference point has been defined in the scene file, else FALSE


argumentDescription:
The point around which rotation and scaling are applied. Default value is the model's centroid.


argumentDescription:
A world coordinate system x axis scale factor


argumentDescription:
A world coordinate system y axis scale factor


argumentDescription:
A world coordinate system z axis scale factor


argumentDescription:
The output pathname in which the Z buffer is saved.


argumentDescription:
If True, the Z-Buffer is activated.  If False, the Z-Buffer is deactivated.


argumentDescription:
f True, lighting is activated.  If False, lighting is deactivated.


argumentDescription:
The radius of the bottom of the cone in VRML units


argumentDescription:
The point used to update the bounding box calculation.


argumentDescription:
The world coordinate of the light source location


argumentDescription:
The location of the VRML .wrl file to read


argumentDescription:
Message to be displayed and saved to the log.


argumentDescription:
The name of the standard path being requested.


argumentDescription:
The name of the path to set.  See utils.h for a complete list.


argumentDescription:
A value between reference1 and reference2


argumentDescription:
A suffix.  c implies a true color image.  g implies the green portion of a true color image.


argumentDescription:
Pointer to Z-buffer image.  If zBuffer is NULL, the zBuffer is not used and the vertex distances are ignored.


argumentDescription:
distance between the coord and the viewpoint


argumentDescription:
Z-buffer image.  If NULL, the Z Buffer is ignored.  If zImage is NULL, the distances are ignored as well.


argumentDescription:
The tweened boundary of rotoscoped image A


argumentDescription:
Boundary 2.  Must have the same number of vertices as boundary 1


argumentDescription:
A zero relative location after which the new vertex is to be added


argumentDescription:
Number of vertices to expand the shape by.


argumentDescription:
A list of scan line intervals (an interval is a starting coordinate and an ending coordinate).


argumentDescription:
A number between 1 and the total length of the intervals in the interval list


argumentDescription:
A shape object containing the two dimensional world coordinate boundary to be converted.


argumentDescription:
An 8 bit per pixel memImage object to contain the mask image.


argumentDescription:
The transformation matrix to apply to the mesh prior to rendering


# parseFunction

prototype:
int renderVRML(char *inWorldPath, char *outImagePath);

shortPrototype:
int renderVRML(char *inWorldPath, char *outImagePath);


prototype:
void renderObject::drawSequence(HDC theDC, char *modelName, int screenHeight, int screenWidth,int frameCounter);

shortPrototype:
void renderObject::drawSequence(HDC theDC, char *modelName, int screenHeight, int screenWidth,int frameCounter);


prototype:
void renderObject::drawStill(HWND theWindow, char *modelName,int screenHeight,int screenWidth);

shortPrototype:
void renderObject::drawStill(HWND theWindow, char *modelName,int screenHeight,int screenWidth);


prototype:
void insertionSort(int theItems[], int numItems);

shortPrototype:
void insertionSort(int theItems[], int numItems);


prototype:
void removeDuplicates(int theList[], int *listLength);

shortPrototype:
void removeDuplicates(int theList[], int *listLength);


prototype:
int prepareCutout(shape3d *aShape, HWND HWindow, char *imageFileName,char *cutoutName, int imageWidth,int imageHeight);

shortPrototype:
int prepareCutout(shape3d *aShape, HWND HWindow, char *imageFileName,char *cutoutName, int imageWidth,int imageHeight);


prototype:
void assembleName(char *inputName, char theSuffix, char *outputName);

shortPrototype:
void assembleName(char *inputName, char theSuffix, char *outputName);

functionDescription:
Creates a Pathname by appending a suffix to an existing pathname.


prototype:
void renderObject::previewMesh(HDC theDC, char *modelName,float xOff, float yOff,int screenHeight, int screenWidth);

shortPrototype:
void renderObject::previewMesh(HDC theDC, char *modelName,float xOff, float yOff,int screenHeight, int screenWidth);


prototype:
int renderObject::renderMesh(memImage *outputImage, memImage *inputImage,int blendIndicator);

shortPrototype:
int renderObject::renderMesh(memImage *outputImage, memImage *inputImage,int blendIndicator);


prototype:
int renderObject::renderMeshz(memImage *outputImage, memImage *maskImage,memImage *inputImage, memImage *zBuffer, float vx, float vy, float vz);

shortPrototype:
int renderObject::renderMeshz(memImage *outputImage, memImage *maskImage,memImage *inputImage, memImage *zBuffer, float vx, float vy, float vz);


prototype:
void renderObject::transformAndProject (tMatrix *aMatrix, int outHeight, int outWidth,int externalCentroid,float centroidX, float centroidY, float centroidZ);

shortPrototype:
void renderObject::transformAndProject (tMatrix *aMatrix, int outHeight, int outWidth,int externalCentroid,float centroidX, float centroidY, float centroidZ);


prototype:
void transformAndProjectPoint2(tMatrix *aMatrix, float x, float y, float z, int *sx,int *sy, float refX, float refY, float refZ, int outHeight,int outWidth);

shortPrototype:
void transformAndProjectPoint2(tMatrix *aMatrix, float x, float y, float z, int *sx,int *sy, float refX, float refY, float refZ, int outHeight,int outWidth);


prototype:
void drawBox(HDC theDC, HPEN hPointPen, HPEN hBlackPen, int x, int y);

shortPrototype:
void drawBox(HDC theDC, HPEN hPointPen, HPEN hBlackPen, int x, int y);


prototype:
int renderObject::renderShape(memImage *outputImage, int blendIndicator);

shortPrototype:
int renderObject::renderShape(memImage *outputImage, int blendIndicator);


prototype:
int renderObject::renderShapez(memImage *outputImage,memImage *alphaImage, memImage *zBuffer,float vx, float vy, float vz);

shortPrototype:
int renderObject::renderShapez(memImage *outputImage,memImage *alphaImage, memImage *zBuffer,float vx, float vy, float vz);


prototype:
int iwarpz(memImage *inImage, memImage *outImage, memImage *zImage,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int iwarpz(memImage *inImage, memImage *outImage, memImage *zImage,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);


prototype:
void getLineEquation(int x1,int y1, int x2, int y2, float *m,float *b, BOOL *horzFlag, BOOL *vertFlag);

shortPrototype:
void getLineEquation(int x1,int y1, int x2, int y2, float *m,float *b, BOOL *horzFlag, BOOL *vertFlag);


prototype:
void getFLineEquation(float x1,float y1, float x2, float y2, float *m,float *b, BOOL *horzFlag, BOOL *vertFlag);

shortPrototype:
void getFLineEquation(float x1,float y1, float x2, float y2, float *m,float *b, BOOL *horzFlag, BOOL *vertFlag);


prototype:
int getIntervals (shape3d *theShape, int y, int *numCoords,int numAllocatedXCoords, int *screenXCoords,float *tXCoords, float *tYCoords, float *tZCoords);

shortPrototype:
int getIntervals (shape3d *theShape, int y, int *numCoords,int numAllocatedXCoords, int *screenXCoords,float *tXCoords, float *tYCoords, float *tZCoords);


prototype:
void insertionSort(int theItems[], float itemData1[], float itemData2[],float itemData3[], int numItems);

shortPrototype:
void insertionSort(int theItems[], float itemData1[], float itemData2[],float itemData3[], int numItems);


prototype:
int removeDuplicates(int theList[], float theItemData1[],float theItemData2[], float theItemData3[], int *listLength);

shortPrototype:
int removeDuplicates(int theList[], float theItemData1[],float theItemData2[], float theItemData3[], int *listLength);


prototype:
int iRender(memImage *outImage, memImage *maskImage, memImage *inImage,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, tMatrix *viewMatrix,int warpIndicator, int blendIndicator, float alphaScale,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int iRender(memImage *outImage, memImage *maskImage, memImage *inImage,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, tMatrix *viewMatrix,int warpIndicator, int blendIndicator, float alphaScale,float refPointX, fl


prototype:
int iRenderz(memImage *outImage, memImage *matteImage, memImage *inImage,memImage *zImage, memImage *zBuffer,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, float vx, float vy, float vz,tMatrix *viewMatrix,int warpIndicator, int blendIndicator, float alphaScale,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int iRenderz(memImage *outImage, memImage *matteImage, memImage *inImage,memImage *zImage, memImage *zBuffer,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, float vx, float vy, float vz,tMatrix *viewMatrix,int warp


prototype:
int antiAlias(memImage *inImage, memImage *outImage);

shortPrototype:
int antiAlias(memImage *inImage, memImage *outImage);


prototype:
int fWarp1(memImage *inImage, memImage *outImage,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int fWarp1(memImage *inImage, memImage *outImage,float rx, float ry, float rz, float sx, float sy, float sz,float tx, float ty, float tz, tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);


prototype:
int fwarpz(memImage *inImage, memImage *outImage, memImage *zImage,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);

shortPrototype:
int fwarpz(memImage *inImage, memImage *outImage, memImage *zImage,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refPointZ);


prototype:
int fwarpz2(memImage *inputImage, memImage *outputImage, memImage *zBuffer,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refpointZ);

shortPrototype:
int fwarpz2(memImage *inputImage, memImage *outputImage, memImage *zBuffer,float rx, float ry, float rz,float sx, float sy, float sz,float tx, float ty, float tz,float vx, float vy, float vz,tMatrix *viewMatrix,float refPointX, float refPointY, float refp


functionDescription:
Creates a new shape object from an existing shape object.


prototype:
shape3d :: shape3d(point3d *UL, point3d *UR, point3d *LR, point3d *LL);

shortPrototype:
shape3d :: shape3d(point3d *UL, point3d *UR, point3d *LR, point3d *LL);


prototype:
int shape3d :: readShape(char *pathName);

shortPrototype:
int shape3d :: readShape(char *pathName);


prototype:
int shape3d :: getShapeFileInfo(char *pathName,  int *fileType, int *numVertices, int *numFaces);

shortPrototype:
int shape3d :: getShapeFileInfo(char *pathName,  int *fileType, int *numVertices, int *numFaces);


prototype:
int shape3d :: shapeFromBMP(char *imageFileName);

shortPrototype:
int shape3d :: shapeFromBMP(char *imageFileName);


prototype:
int shape3d::addWorldVertex(float x, float y, float z);

shortPrototype:
int shape3d::addWorldVertex(float x, float y, float z);

functionDescription:
Adds a world coordinate vertex to a shape3d object.

returnDescription:
Returns NULL if successful, else an error message is posted to the log.


prototype:
int shape3d::addTransformedVertex(float x, float y, float z);

shortPrototype:
int shape3d::addTransformedVertex(float x, float y, float z);


functionDescription:
Deletes the last vertex in a shape object.

returnDescription:
NULL is returned if the operation was successful, else an informative message is posted to the log.


prototype:
int shape3d::getLastWorldVertex(float *x, float *y, float *z);

shortPrototype:
int shape3d::getLastWorldVertex(float *x, float *y, float *z);


prototype:
int shape3d::getPreviousWorldVertex(float *x, float *y, float *z);

shortPrototype:
int shape3d::getPreviousWorldVertex(float *x, float *y, float *z);


functionDescription:
Returns the average x coordinate of the shape3d object.

returnDescription:
The average x coordinate of the shape3d object.


functionDescription:
Returns the average y coordinate of the shape object.

returnDescription:
Returns the average y coordinate of the shape object.


prototype:
void shape3d::getWCentroid(float *centroidX, float *centroidY, float *centroidZ);

shortPrototype:
void shape3d::getWCentroid(float *centroidX, float *centroidY, float *centroidZ);


prototype:
void shape3d::translateW(float offsetX, float offsetY, float offsetZ);

shortPrototype:
void shape3d::translateW(float offsetX, float offsetY, float offsetZ);


prototype:
void shape3d::translateT(float offsetX, float offsetY, float offsetZ);

shortPrototype:
void shape3d::translateT(float offsetX, float offsetY, float offsetZ);


prototype:
void shape3d::translateS(int offsetX, int offsetY);

shortPrototype:
void shape3d::translateS(int offsetX, int offsetY);


prototype:
char *getNextLine(char *theText, int *lineNumber, ifstream *filein,int minLineLength);

shortPrototype:
char *getNextLine(char *theText, int *lineNumber, ifstream *filein,int minLineLength);


prototype:
void getShapePath(char *modelPath, char *shapeDir, char *shapePath);

shortPrototype:
void getShapePath(char *modelPath, char *shapeDir, char *shapePath);


prototype:
int getBoundaryPoint (shape3d *theShape,float rayCentroidX, float rayCentroidY,float rayX2, float rayY2,float *outX, float *outY,float lastX, float lastY);

shortPrototype:
int getBoundaryPoint (shape3d *theShape,float rayCentroidX, float rayCentroidY,float rayX2, float rayY2,float *outX, float *outY,float lastX, float lastY);


prototype:
void shape3d::getReferencePoint(float *centroidX, float *centroidY, float *centroidZ);

shortPrototype:
void shape3d::getReferencePoint(float *centroidX, float *centroidY, float *centroidZ);


prototype:
void shape3d::setReferencePoint(float centroidX, float centroidY, float centroidZ);

shortPrototype:
void shape3d::setReferencePoint(float centroidX, float centroidY, float centroidZ);


prototype:
int shape3d::getScreenVertex(int index, int *sx, int *sy);

shortPrototype:
int shape3d::getScreenVertex(int index, int *sx, int *sy);


prototype:
int shape3d::getTransformedVertex(int index, float *tx, float *ty, float *tz);

shortPrototype:
int shape3d::getTransformedVertex(int index, float *tx, float *ty, float *tz);


prototype:
int shape3d::getWorldVertex(float distanceFraction, int *vertex, float *x,float *y, float *z);

shortPrototype:
int shape3d::getWorldVertex(float distanceFraction, int *vertex, float *x,float *y, float *z);


prototype:
void memImage::allocate(int height, int widthInPixels);

shortPrototype:
void memImage::allocate(int height, int widthInPixels);

functionDescription:
Allocates memory for a memImage Object.  If the needed amount of memory is not available, the object's valid data member is set to zero.


functionDescription:
Erases a memImage object's pixels by setting them to zero.


prototype:
int memImage::clearRGB(BYTE red, BYTE green, BYTE blue);

shortPrototype:
int memImage::clearRGB(BYTE red, BYTE green, BYTE blue);

functionDescription:
Erases all pixels in an image having the indicated RGB color by setting them to zero.

returnDescription:
0 if successful, non-zero if an error occured.  Message posted to log.


prototype:
int memImage::clearRGBRange(BYTE redLow, BYTE redHigh,BYTE greenLow, BYTE greenHigh,BYTE blueLow, BYTE blueHigh);

shortPrototype:
int memImage::clearRGBRange(BYTE redLow, BYTE redHigh,BYTE greenLow, BYTE greenHigh,BYTE blueLow, BYTE blueHigh);

functionDescription:
Erases all pixels in an image within the indicated RGB color range.  All pixels within the indicated range are erased by setting them to zero.


functionDescription:
Initializes the pixels of a 32 bit memImage to the indicated value.


prototype:
void memImage::display(HDC dc, int outWidth, int outHeight);

shortPrototype:
void memImage::display(HDC dc, int outWidth, int outHeight);

functionDescription:
Displays a memImage object in the indicated device context. If the image to be displayed is smaller that the area available to the device context, then the image is displayed in the lower left corner of the dc.


prototype:
int memImage::drawMask(HDC dc, POINT far *thePoints, int numVertices);

shortPrototype:
int memImage::drawMask(HDC dc, POINT far *thePoints, int numVertices);

functionDescription:
Draws a binary mask into the memImage object.  The mask is described as a list of vertices.  The interior of the polygon is occupied with  pixels whose values are 255, all pixels external to the mask are set to zero.

returnDescription:
0 of the operation was successful. else a message is posted to the log.


prototype:
int memImage::copy(memImage *outImage, int xoffset, int yoffset);

shortPrototype:
int memImage::copy(memImage *outImage, int xoffset, int yoffset);

functionDescription:
Copies the image to an indicated output image.  The input image is offset  in the output image by the indicated amount.


prototype:
int memImage::fastCopy(memImage *outImage, int xOffset, int yOffset);

shortPrototype:
int memImage::fastCopy(memImage *outImage, int xOffset, int yOffset);


prototype:
BYTE memImage::getMPixel (int x, int y, char aColor);

shortPrototype:
BYTE memImage::getMPixel (int x, int y, char aColor);

functionDescription:
Returns an 8 bit color component pixel from a 24 bit memImage.

returnDescription:
The value of the requested color component.


prototype:
int memImage::getMPixelRGB(int x, int y, BYTE *red, BYTE *green, BYTE *blue);

shortPrototype:
int memImage::getMPixelRGB(int x, int y, BYTE *red, BYTE *green, BYTE *blue);

functionDescription:
Retrieves an RGB color from the specified location in a 24 bit memImage.

returnDescription:
0 if operation successful, -1 if clipping occured.


prototype:
int memImage::setMPixelRGB(int x, int y, BYTE red, BYTE green, BYTE blue);

shortPrototype:
int memImage::setMPixelRGB(int x, int y, BYTE red, BYTE green, BYTE blue);

functionDescription:
Sets a pixel in a 24 bit memImage file to the indicated color.

returnDescription:
0 if the operation was successful, -1 if clipping occured.


prototype:
int memImage::setMPixel (int x, int y, BYTE value);

shortPrototype:
int memImage::setMPixel (int x, int y, BYTE value);

functionDescription:
Sets the pixel to the indicated value at the desired location.

returnDescription:
0 if the operation was successful, else a message is posted to the log.


prototype:
int memImage::setMPixelA (float x, float y, BYTE value);

shortPrototype:
int memImage::setMPixelA (float x, float y, BYTE value);


prototype:
BYTE memImage::getMPixelA (float x, float y);

shortPrototype:
BYTE memImage::getMPixelA (float x, float y);


prototype:
BYTE memImage::getMPixel (int x, int y);

shortPrototype:
BYTE memImage::getMPixel (int x, int y);


prototype:
int memImage::setMPixel32 (int x, int y, float aValue);

shortPrototype:
int memImage::setMPixel32 (int x, int y, float aValue);

functionDescription:
Sets the pixel at the x,y location in a 32 bit image to the indicated value.


prototype:
float memImage::getMPixel32 (int x, int y);

shortPrototype:
float memImage::getMPixel32 (int x, int y);

functionDescription:
Returns the indicated floating point pixel in a 32 bit memImage.

returnDescription:
The indicated floating point pixel in a 32 bit memImage.


functionDescription:
Returns the image height (Y dimension) in pixels.

returnDescription:
The image height (Y dimension) in pixels.


functionDescription:
Returns the image width (X dimension) in pixels.


functionDescription:
Returns the access mode of the image: SEQUENTIAL or RANDOM.

returnDescription:
The returned value is either SEQUENTIAL or RANDOM


functionDescription:
Returns the colorSpec of a memImage object.  The colorSpec has one of the following values: REDCOLOR, GREENCOLOR, BLUECOLOR, MONOCHROME, RGBCOLOR


functionDescription:
Determines whether the object is valid.  If a NULL is returned, possible implications are: not enough memory was available to create the memImage, or a .bmp file could not be found.

returnDescription:
Returns TRUE (1) if the object is valid, else NULL is returned.


functionDescription:
Saves the memImage object to disk in the form of a .bmp file.  If the .bmp file already exists, it is overwritten without asking for confirmation.

returnDescription:
0 if the operation is successful, else a message is posted to the log.


prototype:
int memImage::readBMP(char *fileName, int colorSpec);

shortPrototype:
int memImage::readBMP(char *fileName, int colorSpec);

functionDescription:
Reads a bmp image file.  The image is assumed to be true color (24 bits per pixel).  The indicated color plane is read into memory.  This protected function is used only by memImage constructors.

returnDescription:
0 if the operation is successful, else -1 is returned and a message is posted to the log.


functionDescription:
If an image is opened for sequential access, this function reads the next row of the image from a .bmp file.


functionDescription:
Closes a memImage object and also closes the .bmp file that may have been opened during the life of this memImage object.


functionDescription:
If an image is opened for sequential access, this function saves the next row to a .bmp file.


prototype:
int readBMPHeader(char *fileName, int *height, int *width,int *bitsPerPixel);

shortPrototype:
int readBMPHeader(char *fileName, int *height, int *width,int *bitsPerPixel);


prototype:
int makeRGBimage(char *redImage, char *greenImage, char *blueImage,char *outFileName);

shortPrototype:
int makeRGBimage(char *redImage, char *greenImage, char *blueImage,char *outFileName);


functionDescription:
Scales a 32 bit memImage to 8 bits.  The scaling operation is performed in such a way that maxValue pixels are ignored.


functionDescription:
Calculates a histogram of the image.  The histogram is displayed in the lCT log file.  The image must be an 8 bit image.

returnDescription:
Returns 0 if the operation was successful.


prototype:
int memImage::adjustColor(BYTE desiredRed, BYTE desiredGreen, BYTE desiredBlue,BYTE *midRed, BYTE *midGreen, BYTE *midBlue, memImage *outImage,char *adjustmentType, int inputImageColor);

shortPrototype:
int memImage::adjustColor(BYTE desiredRed, BYTE desiredGreen, BYTE desiredBlue,BYTE *midRed, BYTE *midGreen, BYTE *midBlue, memImage *outImage,char *adjustmentType, int inputImageColor);


prototype:
int memImage::clearRectangle(int startX, int startY, int endX, int endY);

shortPrototype:
int memImage::clearRectangle(int startX, int startY, int endX, int endY);


prototype:
void motionPath::getFirstLastFrame(int *firstFrame, int *lastFrame);

shortPrototype:
void motionPath::getFirstLastFrame(int *firstFrame, int *lastFrame);

functionDescription:
Returns the first and last frame numbers in a motion path.


prototype:
int motionPath::getNode(int frameNumber, motionNode *mn);

shortPrototype:
int motionPath::getNode(int frameNumber, motionNode *mn);


prototype:
int motionPath :: readMotion(char *pathName);

shortPrototype:
int motionPath :: readMotion(char *pathName);


prototype:
char *getNextMotionLine(char *theText, int *lineNumber, ifstream *filein);

shortPrototype:
char *getNextMotionLine(char *theText, int *lineNumber, ifstream *filein);


prototype:
int motionBlur(char *firstImagePath, char *outputDir, int numFrames,int blurDepth);

shortPrototype:
int motionBlur(char *firstImagePath, char *outputDir, int numFrames,int blurDepth);


prototype:
void sceneList::setCurrentModelTransform(float rx, float ry, float rz,float sx, float sy, float sz, float tx, float ty, float tz);

shortPrototype:
void sceneList::setCurrentModelTransform(float rx, float ry, float rz,float sx, float sy, float sz, float tx, float ty, float tz);


prototype:
void sceneList::getCurrentModelTransform(float *rx, float *ry, float *rz,float *sx, float *sy, float *sz, float *tx, float *ty, float *tz);

shortPrototype:
void sceneList::getCurrentModelTransform(float *rx, float *ry, float *rz,float *sx, float *sy, float *sz, float *tx, float *ty, float *tz);


prototype:
int sceneList::readList(char *errorText, char *pathName);

shortPrototype:
int sceneList::readList(char *errorText, char *pathName);


functionDescription:
Displays the list of model names in a scene list in the indicated combo box.


prototype:
int sceneList::getSceneInfo(char *name, int *type,int *cMode, int *outRows, int *outCols);

shortPrototype:
int sceneList::getSceneInfo(char *name, int *type,int *cMode, int *outRows, int *outCols);


prototype:
int sceneList::setSceneOutImageSize(int outRows, int outCols);

shortPrototype:
int sceneList::setSceneOutImageSize(int outRows, int outCols);


prototype:
int sceneList::getViewTransform(float *viewX, float *viewY, float *viewZ,float *rotateX, float *rotateY, float *rotateZ);

shortPrototype:
int sceneList::getViewTransform(float *viewX, float *viewY, float *viewZ,float *rotateX, float *rotateY, float *rotateZ);


prototype:
int sceneList::setViewTransform(float viewX, float viewY, float viewZ,float rotateX, float rotateY, float rotateZ);

shortPrototype:
int sceneList::setViewTransform(float viewX, float viewY, float viewZ,float rotateX, float rotateY, float rotateZ);


prototype:
int sceneList::getViewPoint(float *viewX, float *viewY, float *viewZ,float *rotateX, float *rotateY, float *rotateZ);

shortPrototype:
int sceneList::getViewPoint(float *viewX, float *viewY, float *viewZ,float *rotateX, float *rotateY, float *rotateZ);


prototype:
int sceneList::writeList(char *errorText, char *fileName);

shortPrototype:
int sceneList::writeList(char *errorText, char *fileName);


prototype:
int sceneList::preview(HWND theWindow, tMatrix *modelMatrix, tMatrix *viewMatrix);

shortPrototype:
int sceneList::preview(HWND theWindow, tMatrix *modelMatrix, tMatrix *viewMatrix);


prototype:
int sceneList::previewStill(HWND theWindow, tMatrix *modelMatrix,tMatrix *viewMatrix);

shortPrototype:
int sceneList::previewStill(HWND theWindow, tMatrix *modelMatrix,tMatrix *viewMatrix);


prototype:
int sceneList::render(imageView *displayWindow, tMatrix *viewMatrix,int depthSortingEnabled, int zBufferEnabled, int antiAliasEnabled,int hazeFogEnabled);

shortPrototype:
int sceneList::render(imageView *displayWindow, tMatrix *viewMatrix,int depthSortingEnabled, int zBufferEnabled, int antiAliasEnabled,int hazeFogEnabled);


prototype:
void getSequenceFileName(char *theInputPath, int frameCounter);

shortPrototype:
void getSequenceFileName(char *theInputPath, int frameCounter);


prototype:
void getFileName(char *outputFileName, char *prefix, int counter,int theColor);

shortPrototype:
void getFileName(char *outputFileName, char *prefix, int counter,int theColor);


prototype:
void appendFileName(char *outputFileName, char *prefix,char *suffix);

shortPrototype:
void appendFileName(char *outputFileName, char *prefix,char *suffix);


prototype:
void constructPathName(char *outPath, char *inPath, char lastLetter);

shortPrototype:
void constructPathName(char *outPath, char *inPath, char lastLetter);


prototype:
void sceneList::adjustTransforms(int effectType, sceneElement *theModel,motionNode *aMotion, bundle *xfrm);

shortPrototype:
void sceneList::adjustTransforms(int effectType, sceneElement *theModel,motionNode *aMotion, bundle *xfrm);


prototype:
void sceneList::getViewMatrix(tMatrix *viewMatrix, int frameCounter, scene *theScene);

shortPrototype:
void sceneList::getViewMatrix(tMatrix *viewMatrix, int frameCounter, scene *theScene);


prototype:
int sceneList::calcCompoundModelRefPoint(sceneElement *theModel, int outputRows, int outputColumns,float *cmCentroidX, float *cmCentroidY, float *cmCentroidZ);

shortPrototype:
int sceneList::calcCompoundModelRefPoint(sceneElement *theModel, int outputRows, int outputColumns,float *cmCentroidX, float *cmCentroidY, float *cmCentroidZ);


prototype:
void tMatrix::multiply(tMatrix *matrix1, tMatrix *matrix2);

shortPrototype:
void tMatrix::multiply(tMatrix *matrix1, tMatrix *matrix2);


prototype:
void tMatrix::scale(float sx, float sy, float sz);

shortPrototype:
void tMatrix::scale(float sx, float sy, float sz);


prototype:
void tMatrix::translate(float tx, float ty, float tz);

shortPrototype:
void tMatrix::translate(float tx, float ty, float tz);


prototype:
void tMatrix::rotate(float rx,float ry,float rz);

shortPrototype:
void tMatrix::rotate(float rx,float ry,float rz);


prototype:
void matmult(float result[4][4],float mat1[4][4],float mat2[4][4]);

shortPrototype:
void matmult(float result[4][4],float mat1[4][4],float mat2[4][4]);


prototype:
void tMatrix::transformPoint(float xIn, float yIn, float zIn, float *xOut,float *yOut, float *zOut);

shortPrototype:
void tMatrix::transformPoint(float xIn, float yIn, float zIn, float *xOut,float *yOut, float *zOut);


prototype:
void tMatrix::transformPoint1(point3d *in, point3d *out);

shortPrototype:
void tMatrix::transformPoint1(point3d *in, point3d *out);


prototype:
void tMatrix::transformAndProjectPoint(float x, float y, float z, int *sx,int *sy, float refX, float refY, float refZ,int outHeight, int outWidth,float *tx, float *ty, float *tz);

shortPrototype:
void tMatrix::transformAndProjectPoint(float x, float y, float z, int *sx,int *sy, float refX, float refY, float refZ,int outHeight, int outWidth,float *tx, float *ty, float *tz);


prototype:
void tMatrix::transformAndProjectPoint1(point3d *p, point2d *s, point3d *ref,int outHeight, int outWidth, point3d *t);

shortPrototype:
void tMatrix::transformAndProjectPoint1(point3d *p, point2d *s, point3d *ref,int outHeight, int outWidth, point3d *t);


prototype:
void tMatrix::transformAndProject (shape3d *aShape, int outHeight,int outWidth, int useExternalCentroid,float centroidX, float centroidY, float centroidZ);

shortPrototype:
void tMatrix::transformAndProject (shape3d *aShape, int outHeight,int outWidth, int useExternalCentroid,float centroidX, float centroidY, float centroidZ);


prototype:
void imageView::getScrollPos(int *xPixels, int *yPixels);

shortPrototype:
void imageView::getScrollPos(int *xPixels, int *yPixels);


prototype:
void imageView::OnLButtonDown(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnLButtonDown(UINT nFlags, CPoint point);


prototype:
void imageView::OnLButtonUp(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnLButtonUp(UINT nFlags, CPoint point);


prototype:
void imageView::OnLButtonDblClk(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnLButtonDblClk(UINT nFlags, CPoint point);


prototype:
void imageView::OnRButtonDown(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnRButtonDown(UINT nFlags, CPoint point);


prototype:
void imageView::OnRButtonUp(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnRButtonUp(UINT nFlags, CPoint point);


prototype:
void imageView::OnMouseMove(UINT nFlags, CPoint point);

shortPrototype:
void imageView::OnMouseMove(UINT nFlags, CPoint point);


prototype:
int getSampleRange(memImage *theImage, int x, int y,int *redLow, int *redHigh, int *greenLow, int *greenHigh,int *blueLow, int *blueHigh);

shortPrototype:
int getSampleRange(memImage *theImage, int x, int y,int *redLow, int *redHigh, int *greenLow, int *greenHigh,int *blueLow, int *blueHigh);


prototype:
int blend(memImage *inImage, memImage *maskImage, memImage *outImage,float alphaScale);

shortPrototype:
int blend(memImage *inImage, memImage *maskImage, memImage *outImage,float alphaScale);

functionDescription:
Blends or composites two images together based on a third image called an alpha image.

returnDescription:
Returns 0 if no error encountered.  Else a message is posted to the log.


prototype:
int blendz(memImage *inImage, memImage *matteImage,memImage *zImage, memImage *zBuffer,memImage *outImage,float alphaScale);

shortPrototype:
int blendz(memImage *inImage, memImage *matteImage,memImage *zImage, memImage *zBuffer,memImage *outImage,float alphaScale);

functionDescription:
Blends or composites two images together using the contribution of an alpha image.  This variant of the blend function uses a z-buffer to provide a robust means of rendering intertwined 3D surfaces.

returnDescription:
NULL is returned if no errors are encountered, else a message is posted to the log.


prototype:
int createCutout(memImage *originalImage, memImage *maskImage,char *cutoutName, shape3d *aShape);

shortPrototype:
int createCutout(memImage *originalImage, memImage *maskImage,char *cutoutName, shape3d *aShape);

functionDescription:
Creates a cutout image from an original image, a mask image and a shape object

returnDescription:
NULL is returned if the operation is successful, else a message is posted to the log.


functionDescription:
Unpacks the image object into the indicated image.  The input image must have 1 bit pixels.  Each 1 bit pixel in the input image will correspond to an 8 bit pixel having the value 255 in the unpacked image.

returnDescription:
0 if operation is successful, else a message is posted to the log.


prototype:
int in_boundary(memImage *anImage, int x, int y);

shortPrototype:
int in_boundary(memImage *anImage, int x, int y);


prototype:
int probe(memImage *anImage, int x, int y, int dir, int *new_x, int *new_y);

shortPrototype:
int probe(memImage *anImage, int x, int y, int dir, int *new_x, int *new_y);


prototype:
int neighbor(memImage *anImage, int x, int y, int last_dir, int *new_x, int *new_y);

shortPrototype:
int neighbor(memImage *anImage, int x, int y, int last_dir, int *new_x, int *new_y);


prototype:
int shapeFromImage(memImage *anImage, shape3d *aShape);

shortPrototype:
int shapeFromImage(memImage *anImage, shape3d *aShape);


prototype:
int createQMeshModel(char *inputImagePath, char *destinationDir, int modelType);

shortPrototype:
int createQMeshModel(char *inputImagePath, char *destinationDir, int modelType);

functionDescription:
Generates a quadrilateral mesh model of the type indicated and from the texture image.

returnDescription:
NULL is returned if the model is created successfully, else an informative message is posted to the log.


prototype:
int getMeshCentroid(memImage *xImage, memImage *yImage, memImage *zImage,float *centroidX, float *centroidY, float *centroidZ);

shortPrototype:
int getMeshCentroid(memImage *xImage, memImage *yImage, memImage *zImage,float *centroidX, float *centroidY, float *centroidZ);


prototype:
int translateMesh(memImage *xImage, memImage *yImage, memImage *zImage,float offsetX, float offsetY, float offsetZ);

shortPrototype:
int translateMesh(memImage *xImage, memImage *yImage, memImage *zImage,float offsetX, float offsetY, float offsetZ);


prototype:
int createTexture(char *texturePath, char *outDirectory, int textureType,int imageType, int foreColor, int backColor, int numRows, int numColumns);

shortPrototype:
int createTexture(char *texturePath, char *outDirectory, int textureType,int imageType, int foreColor, int backColor, int numRows, int numColumns);


prototype:
void plasma(memImage *anImage, int x, int y, int x1, int y1);

shortPrototype:
void plasma(memImage *anImage, int x, int y, int x1, int y1);


prototype:
void createPlasma(memImage *anImage, int numRows, int numColumns);

shortPrototype:
void createPlasma(memImage *anImage, int numRows, int numColumns);


prototype:
void insertionSort2(float theItems[], DWORD itemData[], int numItems);

shortPrototype:
void insertionSort2(float theItems[], DWORD itemData[], int numItems);


prototype:
int sceneList::depthSort(sceneElement *models[], float distances[],int *numModels, int depthSortingEnabled);

shortPrototype:
int sceneList::depthSort(sceneElement *models[], float distances[],int *numModels, int depthSortingEnabled);

functionDescription:
Sorts the models included in a visual effect based on their distance from the viewer.  Themodel distances are sorted into descending order.


prototype:
float getDistance2d(float x1, float y1, float x2, float y2);

shortPrototype:
float getDistance2d(float x1, float y1, float x2, float y2);

functionDescription:
Returns the two dimensional Cartesian distance between two points

returnDescription:
The two dimensional Cartesian distance between two points


prototype:
float getDistance3d(float x1, float y1, float z1, float x2, float y2, float z2);

shortPrototype:
float getDistance3d(float x1, float y1, float z1, float x2, float y2, float z2);

functionDescription:
Returns the three dimensional Cartesian distance between two points

returnDescription:
The three dimensional Cartesian distance between two points


prototype:
void shape3d::getTCentroid(float *centroidX, float *centroidY, float *centroidZ);

shortPrototype:
void shape3d::getTCentroid(float *centroidX, float *centroidY, float *centroidZ);


prototype:
void vectorAdd(point3d *result, point3d *p1, point3d *p2);

shortPrototype:
void vectorAdd(point3d *result, point3d *p1, point3d *p2);


prototype:
void vectorSubtract(point3d *result, point3d *p1, point3d *p2);

shortPrototype:
void vectorSubtract(point3d *result, point3d *p1, point3d *p2);


prototype:
float vectorMagnitude2(point3d *p1, point3d *p2);

shortPrototype:
float vectorMagnitude2(point3d *p1, point3d *p2);


prototype:
void crossProduct(point3d *result, point3d *p1, point3d *p2, point3d *p3);

shortPrototype:
void crossProduct(point3d *result, point3d *p1, point3d *p2, point3d *p3);


prototype:
float dotProduct(point3d *p1, point3d *p2);

shortPrototype:
float dotProduct(point3d *p1, point3d *p2);


prototype:
void getNormal1(float x0, float y0, float z0, float x1, float y1, float z1,		  float x2, float y2, float z2, float *xN, float *yN, float *zN);

shortPrototype:
void getNormal1(float x0, float y0, float z0, float x1, float y1, float z1,		  float x2, float y2, float z2, float *xN, float *yN, float *zN);


prototype:
void getNormal2(point3d *result, point3d *p0, point3d *p1, point3d *p2);

shortPrototype:
void getNormal2(point3d *result, point3d *p0, point3d *p1, point3d *p2);


prototype:
float lightModel(float kd, int Ip, int Ia, point3d *N, point3d *L, float d);

shortPrototype:
float lightModel(float kd, int Ip, int Ia, point3d *N, point3d *L, float d);


prototype:
int sceneList::addScene(char *theSceneName,int theType, int outImCols,int outImRows,  int theColorMode, point3d *rt, point3d *tr, char *thePath);

shortPrototype:
int sceneList::addScene(char *theSceneName,int theType, int outImCols,int outImRows,  int theColorMode, point3d *rt, point3d *tr, char *thePath);

functionDescription:
Adds a scene node to a scene list object.  Only one scene node may be created in a scene list.


prototype:
int sceneList::addSceneElement(char *mdName, char * fName, int blendI,int theType, int warpI, float aScale,point3d *rt,point3d *sc, point3d *tr, char *motionPath, char *theAlphaPath,int theSortLayer, RGBTRIPLE anAdjustment, char *adjustmentType, char *colorAdjustedPath,int definedRefPt, point3d *refPoint);

shortPrototype:
int sceneList::addSceneElement(char *mdName, char * fName, int blendI,int theType, int warpI, float aScale,point3d *rt,point3d *sc, point3d *tr, char *motionPath, char *theAlphaPath,int theSortLayer, RGBTRIPLE anAdjustment, char *adjustmentType, char *col

functionDescription:
Adds a scene element (also called a model) to a scene list.  This function must be called once for each model in the scene.


functionDescription:
Clears the scene list of all models and the scene descriptor.


prototype:
int sceneList::setModelReferencePoint(char *modelName, float centroidX, float centroidY,float centroidZ);

shortPrototype:
int sceneList::setModelReferencePoint(char *modelName, float centroidX, float centroidY,float centroidZ);


prototype:
int gPipe::addFace(point3d *p1, point3d *p2, point3d *c1, point3d *c2);

shortPrototype:
int gPipe::addFace(point3d *p1, point3d *p2, point3d *c1, point3d *c2);


prototype:
void gPipe::setPenScale(float scaleX, float scaleY, float scaleZ);

shortPrototype:
void gPipe::setPenScale(float scaleX, float scaleY, float scaleZ);


prototype:
void gPipe::setPenTranslation(float tranX, float tranY, float tranZ);

shortPrototype:
void gPipe::setPenTranslation(float tranX, float tranY, float tranZ);


prototype:
void gPipe::addCube(float width, float height, float depth);

shortPrototype:
void gPipe::addCube(float width, float height, float depth);


prototype:
void gPipe::addCylTop(float height, float radius);

shortPrototype:
void gPipe::addCylTop(float height, float radius);


prototype:
void gPipe::addCylBottom(float height, float radius);

shortPrototype:
void gPipe::addCylBottom(float height, float radius);


prototype:
void gPipe::addCylSides(float height, float radius);

shortPrototype:
void gPipe::addCylSides(float height, float radius);


prototype:
void gPipe::addConeBottom(float height, float bottomRadius);

shortPrototype:
void gPipe::addConeBottom(float height, float bottomRadius);


prototype:
void gPipe::addConeSides(float height, float bottomRadius);

shortPrototype:
void gPipe::addConeSides(float height, float bottomRadius);


prototype:
void preference::setPath(int pathIndicator, char *thePath);

shortPrototype:
void preference::setPath(int pathIndicator, char *thePath);


prototype:
float interpolate(float desired1, float desired2, float reference1, float reference2,float referenceCurrent);

shortPrototype:
float interpolate(float desired1, float desired2, float reference1, float reference2,float referenceCurrent);


prototype:
float bound(float value, float minValue, float maxValue);

shortPrototype:
float bound(float value, float minValue, float maxValue);


prototype:
void makePath(char *currentPath, char *inPath, char *prefix, int frameCounter, char *inSuffix);

shortPrototype:
void makePath(char *currentPath, char *inPath, char *prefix, int frameCounter, char *inSuffix);


prototype:
int getPathPieces(char *firstImagePath, char *directory, char *fileName,char *prefix, int *frameNum, char *inSuffix);

shortPrototype:
int getPathPieces(char *firstImagePath, char *directory, char *fileName,char *prefix, int *frameNum, char *inSuffix);


prototype:
void CScenePreviewDlg::OnMove(int x, int y);

shortPrototype:
void CScenePreviewDlg::OnMove(int x, int y);


prototype:
int fillRect(int x1, int y1, float i1,int x2, int y2, float i2,int x3, int y3, float i3,int x4, int y4, float i4,memImage *theImage);

shortPrototype:
int fillRect(int x1, int y1, float i1,int x2, int y2, float i2,int x3, int y3, float i3,int x4, int y4, float i4,memImage *theImage);


prototype:
int memImage::fillPolyz(int I1x, int I1y, float I1p, float I1d,int I2x, int I2y, float I2p, float I2d,int I3x, int I3y, float I3p, float I3d,int I4x, int I4y, float I4p, float I4d,memImage *zBuffer);

shortPrototype:
int memImage::fillPolyz(int I1x, int I1y, float I1p, float I1d,int I2x, int I2y, float I2p, float I2d,int I3x, int I3y, float I3p, float I3d,int I4x, int I4y, float I4p, float I4d,memImage *zBuffer);


prototype:
int fillTrianglez(int x1, int y1, float i1, float d1,int x2, int y2, float i2, float d2,int x3, int y3, float i3, float d3,memImage *outImage, memImage *zImage);

shortPrototype:
int fillTrianglez(int x1, int y1, float i1, float d1,int x2, int y2, float i2, float d2,int x3, int y3, float i3, float d3,memImage *outImage, memImage *zImage);


prototype:
BYTE getLight(point3d *p1, point3d *p2, point3d *c1, point3d *c2);

shortPrototype:
BYTE getLight(point3d *p1, point3d *p2, point3d *c1, point3d *c2);


prototype:
int createTweenableShapes(shape3d *inShape1, shape3d *inShape2,shape3d **outShapeA, shape3d **outShapeB);

shortPrototype:
int createTweenableShapes(shape3d *inShape1, shape3d *inShape2,shape3d **outShapeA, shape3d **outShapeB);


prototype:
int tweenShape(float fraction, shape3d **outShape, shape3d *shape1, shape3d *shape2);

shortPrototype:
int tweenShape(float fraction, shape3d **outShape, shape3d *shape1, shape3d *shape2);


prototype:
int shape3d::insertVertexAfter(int index, float x, float y, float z);

shortPrototype:
int shape3d::insertVertexAfter(int index, float x, float y, float z);


prototype:
int tweenImage(float aFraction,memImage *inImageA, memImage *inImageB,char *imagePath, char *shapePath);

shortPrototype:
int tweenImage(float aFraction,memImage *inImageA, memImage *inImageB,char *imagePath, char *shapePath);


prototype:
int tweenMesh(float aFraction,memImage *aTexture, memImage *aX, memImage *aY,memImage * aZ,memImage *bTexture, memImage *bX, memImage *bY,memImage * bZ,memImage *oTexture, memImage *oX, memImage *oY,memImage * oZ);

shortPrototype:
int tweenMesh(float aFraction,memImage *aTexture, memImage *aX, memImage *aY,memImage * aZ,memImage *bTexture, memImage *bX, memImage *bY,memImage * bZ,memImage *oTexture, memImage *oX, memImage *oY,memImage * oZ);


prototype:
int getRowIntervals(memImage *anImage, int row, int *intervalList, int *numIntervals);

shortPrototype:
int getRowIntervals(memImage *anImage, int row, int *intervalList, int *numIntervals);


prototype:
int getTotalIntervalLength(int *intervalList, int numIntervals);

shortPrototype:
int getTotalIntervalLength(int *intervalList, int numIntervals);


prototype:
int indexToCoord(int index, int *intervalList, int numIntervals);

shortPrototype:
int indexToCoord(int index, int *intervalList, int numIntervals);


prototype:
int editCoords(int *coordList, int *numCoords);

shortPrototype:
int editCoords(int *coordList, int *numCoords);


