Index: trunk/psLib/src/image/psImage.c
===================================================================
--- trunk/psLib/src/image/psImage.c	(revision 1426)
+++ trunk/psLib/src/image/psImage.c	(revision 1440)
@@ -10,6 +10,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-07 00:06:06 $
+ *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-09 23:34:58 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -32,5 +32,5 @@
 #include "psImage.h"
 
-static void imageFree(psImage * image);
+static void imageFree(psImage* image);
 
 /*****************************************************************************/
@@ -40,5 +40,5 @@
 /*****************************************************************************/
 
-psImage *psImageAlloc(unsigned int numCols, unsigned int numRows, const psElemType type)
+psImage* psImageAlloc(unsigned int numCols, unsigned int numRows, const psElemType type)
 {
     int area = 0;
@@ -61,5 +61,5 @@
     }
 
-    psImage *image = (psImage *) psAlloc(sizeof(psImage));
+    psImage* image = (psImage* ) psAlloc(sizeof(psImage));
 
     if (image == NULL) {
@@ -87,6 +87,6 @@
     *(unsigned int *)&image->numCols = numCols;
     *(unsigned int *)&image->numRows = numRows;
-    *(psDimen *) & image->type.dimen = PS_DIMEN_IMAGE;
-    *(psElemType *) & image->type.type = type;
+    *(psDimen* ) & image->type.dimen = PS_DIMEN_IMAGE;
+    *(psElemType* ) & image->type.type = type;
     image->parent = NULL;
     image->nChildren = 0;
@@ -96,5 +96,5 @@
 }
 
-static void imageFree(psImage * image)
+static void imageFree(psImage* image)
 {
     if (image == NULL) {
@@ -107,5 +107,5 @@
         unsigned int oldNumRows = image->numRows;
         unsigned int oldNumCols = image->numCols;
-        psPTR *rowPtr;
+        psPTR* rowPtr;
 
         for (unsigned int row = 0; row < oldNumRows; row++) {
@@ -124,5 +124,5 @@
 }
 
-psImage *psImageRecycle(psImage * old, unsigned int numCols, unsigned int numRows, const psElemType type)
+psImage* psImageRecycle(psImage* old, unsigned int numCols, unsigned int numRows, const psElemType type)
 {
     int elementSize = PSELEMTYPE_SIZEOF(type);  // element
@@ -151,5 +151,5 @@
         unsigned int oldNumRows = old->numRows;
         unsigned int oldNumCols = old->numCols;
-        psPTR *rowPtr;
+        psPTR* rowPtr;
 
         for (unsigned int row = 0; row < oldNumRows; row++) {
@@ -177,14 +177,14 @@
     *(unsigned int *)&old->numCols = numCols;
     *(unsigned int *)&old->numRows = numRows;
-    *(psElemType *) & old->type.type = type;
+    *(psElemType* ) & old->type.type = type;
 
     return old;
 }
 
-int psImageFreeChildren(psImage * image)
+int psImageFreeChildren(psImage* image)
 {
     int i = 0;
     int nChildren = 0;
-    psImage **children = NULL;
+    psImage* *children = NULL;
     int numFreed = 0;
 
@@ -216,5 +216,5 @@
 linear interpolation is performed on the image.
  *****************************************************************************/
-psF32 psImagePixelInterpolate(const psImage * input,
+psF32 psImagePixelInterpolate(const psImage* input,
                               float x, float y, psF32 unexposedValue, psImageInterpolateMode mode)
 {
@@ -259,5 +259,5 @@
 
 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \
-inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
+inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \
         float x, \
         float y, \
@@ -280,5 +280,5 @@
 
 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \
-inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
+inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \
         float x, \
         float y, \
@@ -313,5 +313,5 @@
 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64)
 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \
-inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
+inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \
         float x, \
         float y, \
@@ -368,5 +368,5 @@
 }
 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \
-inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
+inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \
         float x, \
         float y, \
Index: trunk/psLib/src/image/psImage.h
===================================================================
--- trunk/psLib/src/image/psImage.h	(revision 1426)
+++ trunk/psLib/src/image/psImage.h	(revision 1440)
@@ -12,6 +12,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-09 22:44:25 $
+ *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-09 23:34:58 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -50,22 +50,22 @@
 
     union {
-        psU8 **U8;              ///< Unsigned 8-bit integer data.
-        psU16 **U16;            ///< Unsigned 16-bit integer data.
-        psU32 **U32;            ///< Unsigned 32-bit integer data.
-        psU64 **U64;            ///< Unsigned 64-bit integer data.
-        psS8 **S8;              ///< Signed 8-bit integer data.
-        psS16 **S16;            ///< Signed 16-bit integer data.
-        psS32 **S32;            ///< Signed 32-bit integer data.
-        psS64 **S64;            ///< Signed 64-bit integer data.
-        psF32 **F32;            ///< Single-precision float data.
-        psF64 **F64;            ///< Double-precision float data.
-        psC32 **C32;            ///< Single-precision complex data.
-        psC64 **C64;            ///< Double-precision complex data.
-        psPTR **PTR;            ///< Void pointers.
-        psPTR *V;               ///< Pointer to data.
+        psU8* *U8;              ///< Unsigned 8-bit integer data.
+        psU16* *U16;            ///< Unsigned 16-bit integer data.
+        psU32* *U32;            ///< Unsigned 32-bit integer data.
+        psU64* *U64;            ///< Unsigned 64-bit integer data.
+        psS8* *S8;              ///< Signed 8-bit integer data.
+        psS16* *S16;            ///< Signed 16-bit integer data.
+        psS32* *S32;            ///< Signed 32-bit integer data.
+        psS64* *S64;            ///< Signed 64-bit integer data.
+        psF32* *F32;            ///< Single-precision float data.
+        psF64* *F64;            ///< Double-precision float data.
+        psC32* *C32;            ///< Single-precision complex data.
+        psC64* *C64;            ///< Double-precision complex data.
+        psPTR* *PTR;            ///< Void pointers.
+        psPTR* V;               ///< Pointer to data.
     } data;                     ///< Union for data types.
-    const struct psImage *parent;       ///< Parent, if a subimage.
+    const struct psImage* parent;       ///< Parent, if a subimage.
     int nChildren;              ///< Number of subimages.
-    struct psImage **children;  ///< Children of this region.
+    struct psImage* *children;  ///< Children of this region.
 }
 psImage;
@@ -82,8 +82,8 @@
  * specified size and type.
  *
- * @return psImage*: Pointer to psImage.
+ * @return psImage* : Pointer to psImage.
  *
  */
-psImage *psImageAlloc(unsigned int numCols,     ///< Number of rows in image.
+psImage* psImageAlloc(unsigned int numCols,     ///< Number of rows in image.
                       unsigned int numRows,     ///< Number of columns in image.
                       const psElemType type     ///< Type of data for image.
@@ -95,5 +95,5 @@
  *
  */
-psImage *psImageRecycle(psImage * old,  ///< the psImage to recycle by resizing image buffer
+psImage* psImageRecycle(psImage* old,  ///< the psImage to recycle by resizing image buffer
                         unsigned int numCols,   ///< the desired number of columns in image
                         unsigned int numRows,   ///< the desired number of rows in image
@@ -106,15 +106,15 @@
  *
  */
-int psImageFreeChildren(psImage * image
+int psImageFreeChildren(psImage* image
 
                         /**< psImage in which all children shall be deallocated */
                        );
 
-psF32 psImagePixelInterpolate(const psImage * input,
+psF32 psImagePixelInterpolate(const psImage* input,
                               float x, float y, psF32 unexposedValue, psImageInterpolateMode mode);
 
 #    define p_psImagePixelInterpolateFcns(TYPE) \
 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \
-        const psImage *input, \
+        const psImage* input, \
         float x, \
         float y, \
@@ -122,5 +122,5 @@
                                                  ); \
 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
-        const psImage *input, \
+        const psImage* input, \
         float x, \
         float y, \
@@ -130,5 +130,5 @@
 #    define p_psImagePixelInterpolateComplexFcns(TYPE) \
 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \
-        const psImage *input, \
+        const psImage* input, \
         float x, \
         float y, \
@@ -136,5 +136,5 @@
                                                  ); \
 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
-        const psImage *input, \
+        const psImage* input, \
         float x, \
         float y, \
Index: trunk/psLib/src/image/psImageExtraction.c
===================================================================
--- trunk/psLib/src/image/psImageExtraction.c	(revision 1426)
+++ trunk/psLib/src/image/psImageExtraction.c	(revision 1440)
@@ -10,6 +10,6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-07 00:06:06 $
+*  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-09 23:34:58 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -23,6 +23,6 @@
 #include "psError.h"
 
-psImage *psImageSubset(psImage * out,
-                       psImage * image,
+psImage* psImageSubset(psImage* out,
+                       psImage* image,
                        unsigned int numCols, unsigned int numRows, unsigned int col0, unsigned int row0)
 {
@@ -83,10 +83,10 @@
     *(int *)&out->row0 = row0;
     *(int *)&out->col0 = col0;
-    *(psImage **) & out->parent = (psImage *) image;
+    *(psImage* *) & out->parent = (psImage* ) image;
 
     // add output image as a child of the input
     // image.
     image->nChildren++;
-    image->children = (psImage **) psRealloc(image->children, image->nChildren * sizeof(psImage *));
+    image->children = (psImage* *) psRealloc(image->children, image->nChildren * sizeof(psImage* ));
     image->children[image->nChildren - 1] = out;
 
@@ -101,5 +101,5 @@
 }
 
-psImage *psImageCopy(psImage * restrict output, const psImage * input, psElemType type)
+psImage* psImageCopy(psImage* restrict output, const psImage* input, psElemType type)
 {
     psElemType inDatatype;
@@ -242,21 +242,21 @@
 }
 
-psVector *psImageSlice(psVector * out,
-                       psVector * slicePositions,
-                       const psImage * restrict in,
-                       const psImage * restrict mask,
+psVector* psImageSlice(psVector* out,
+                       psVector* slicePositions,
+                       const psImage* restrict in,
+                       const psImage* restrict mask,
                        unsigned int maskVal,
                        unsigned int col,
                        unsigned int row,
                        unsigned int numCols,
-                       unsigned int numRows, psImageCutDirection direction, const psStats * stats)
+                       unsigned int numRows, psImageCutDirection direction, const psStats* stats)
 {
     double statVal;
-    psStats *myStats;
+    psStats* myStats;
     psElemType type;
     int inRows;
     int inCols;
     int delta = 1;
-    psF64 *outData;
+    psF64* outData;
 
     if (in == NULL || in->data.V == NULL) {
@@ -328,8 +328,8 @@
 
     if (direction == PS_CUT_X_POS || direction == PS_CUT_X_NEG) {
-        psVector *imgVec = psVectorAlloc(numRows, type);
-        psVector *maskVec = NULL;
-        psMaskType *maskData = NULL;
-        psU32 *outPosition = NULL;
+        psVector* imgVec = psVectorAlloc(numRows, type);
+        psVector* maskVec = NULL;
+        psMaskType* maskData = NULL;
+        psU32* outPosition = NULL;
 
         // recycle output to make a proper
@@ -362,5 +362,5 @@
                 if (maskVec != NULL) { \
                     maskVecData = maskVec->data.V; \
-                    maskData = (psMaskType*)(mask->data.V[row]) + col + c; \
+                    maskData = (psMaskType* )(mask->data.V[row]) + col + c; \
                 } \
                 for (int r=0;r<numRows;r++) { \
@@ -417,8 +417,8 @@
         // Y
         // direction
-        psVector *imgVec = NULL;
-        psVector *maskVec = NULL;
+        psVector* imgVec = NULL;
+        psVector* maskVec = NULL;
         int elementSize = PSELEMTYPE_SIZEOF(type);
-        psU32 *outPosition = NULL;
+        psU32* outPosition = NULL;
 
         // fill in psVectors to fake out the
Index: trunk/psLib/src/image/psImageExtraction.h
===================================================================
--- trunk/psLib/src/image/psImageExtraction.h	(revision 1426)
+++ trunk/psLib/src/image/psImageExtraction.h	(revision 1440)
@@ -10,6 +10,6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-09 22:44:25 $
+*  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-09 23:34:58 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -40,5 +40,5 @@
  * one.
  *
- * @return psImage*: Pointer to psImage.
+ * @return psImage* : Pointer to psImage.
  *
  */
@@ -54,5 +54,5 @@
 /** Makes a copy of a psImage
  *
- * @return psImage*  Copy of the input psImage.  This may not be equal to the
+ * @return psImage* Copy of the input psImage.  This may not be equal to the
  * output parameter
  *
@@ -78,5 +78,5 @@
  * @return psVector    the resulting vector
  */
-psVector *psImageSlice(
+psVector* psImageSlice(
     psVector* out,                     ///< psVector to recycle, or NULL.
     psVector* slicePositions,
@@ -111,5 +111,5 @@
  *  @return psVector    resulting vector
  */
-psVector *psImageCut(
+psVector* psImageCut(
     psVector* out,                     ///< psVector to recycle, or NULL.
     const psImage* input,              ///< the input image in which to perform the cut
Index: trunk/psLib/src/image/psImageIO.c
===================================================================
--- trunk/psLib/src/image/psImageIO.c	(revision 1426)
+++ trunk/psLib/src/image/psImageIO.c	(revision 1440)
@@ -8,6 +8,6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-07 00:06:06 $
+ *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-09 23:34:58 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -22,5 +22,5 @@
 #include "psMemory.h"
 
-psImage *psImageReadSection(psImage * output,
+psImage* psImageReadSection(psImage* output,
                             int col,
                             int row,
@@ -199,5 +199,5 @@
 }
 
-bool psImageWriteSection(psImage * input, int col0, int row0, int z, char *extname, int extnum,
+bool psImageWriteSection(psImage* input, int col0, int row0, int z, char *extname, int extnum,
                          char *filename)
 {
Index: trunk/psLib/src/image/psImageIO.h
===================================================================
--- trunk/psLib/src/image/psImageIO.h	(revision 1426)
+++ trunk/psLib/src/image/psImageIO.h	(revision 1440)
@@ -10,6 +10,6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-07 00:06:06 $
+ *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-09 23:34:58 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -27,8 +27,8 @@
 /** Read an image or subimage from a FITS file specified by a filename.
  *
- *  return psImage*         The image read from the specified file.  NULL
+ *  return psImage* The image read from the specified file.  NULL
  *                          signifies that a problem had occured.
  */
-psImage *psImageReadSection(psImage * output,
+psImage* psImageReadSection(psImage* output,
 
                             /**< the output psImage to recycle, or NULL if new psImage desired */
@@ -67,5 +67,5 @@
  *  return bool         TRUE is successful, otherwise FALSE.
  */
-bool psImageWriteSection(psImage * input,
+bool psImageWriteSection(psImage* input,
 
                          /**< the psImage to write */
Index: trunk/psLib/src/image/psImageManip.c
===================================================================
--- trunk/psLib/src/image/psImageManip.c	(revision 1426)
+++ trunk/psLib/src/image/psImageManip.c	(revision 1440)
@@ -11,6 +11,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-07 00:06:06 $
+ *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-09 23:34:58 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -31,5 +31,5 @@
 #include "psImageExtraction.h"
 
-int psImageClip(psImage * input, psF64 min, psF64 vmin, psF64 max, psF64 vmax)
+int psImageClip(psImage* input, psF64 min, psF64 vmin, psF64 max, psF64 vmax)
 {
     int numClipped = 0;
@@ -125,5 +125,5 @@
 }
 
-int psImageClipNaN(psImage * input, psF64 value)
+int psImageClipNaN(psImage* input, psF64 value)
 {
     int numClipped = 0;
@@ -164,5 +164,5 @@
 }
 
-int psImageOverlaySection(psImage * image, const psImage * overlay, int col0, int row0, const char *op)
+int psImageOverlaySection(psImage* image, const psImage* overlay, int col0, int row0, const char *op)
 {
     unsigned int imageNumRows;
@@ -267,5 +267,5 @@
 }
 
-int psImageClipComplexRegion(psImage * input, psC64 min, psC64 vmin, psC64 max, psC64 vmax)
+int psImageClipComplexRegion(psImage* input, psC64 min, psC64 vmin, psC64 max, psC64 vmax)
 {
     int numClipped = 0;
@@ -340,5 +340,5 @@
 }
 
-psImage *psImageRebin(psImage * out, const psImage * in, unsigned int scale, const psStats * stats)
+psImage* psImageRebin(psImage* out, const psImage* in, unsigned int scale, const psStats* stats)
 {
     int inRows;
@@ -346,9 +346,9 @@
     int outRows;
     int outCols;
-    psVector *vec;              // vector to hold
+    psVector* vec;              // vector to hold
 
     // the values of
     // a single bin.
-    psStats *myStats;
+    psStats* myStats;
     double statVal;
 
@@ -444,5 +444,5 @@
 }
 
-psImage *psImageResample(psImage * out, const psImage * in, int scale, psImageInterpolateMode mode)
+psImage* psImageResample(psImage* out, const psImage* in, int scale, psImageInterpolateMode mode)
 {
     int outRows;
@@ -496,5 +496,5 @@
 }
 
-psImage *psImageRoll(psImage * out, const psImage * in, int dx, int dy)
+psImage* psImageRoll(psImage* out, const psImage* in, int dx, int dy)
 {
     int outRows;
@@ -534,5 +534,5 @@
             inRowNumber -= outRows;
         }
-        psU8 *inRow = in->data.U8[inRowNumber]; // to
+        psU8* inRow = in->data.U8[inRowNumber]; // to
 
         // allow
@@ -542,5 +542,5 @@
 
         // but for all types
-        psU8 *outRow = out->data.U8[row];
+        psU8* outRow = out->data.U8[row];
 
         memcpy(outRow, inRow + segment2Size, segment1Size);
@@ -551,6 +551,6 @@
 }
 
-psImage *psImageRotate(psImage * out,
-                       const psImage * in, float angle, float unexposedValue, psImageInterpolateMode mode)
+psImage* psImageRotate(psImage* out,
+                       const psImage* in, float angle, float unexposedValue, psImageInterpolateMode mode)
 {
     if (in == NULL) {
@@ -803,6 +803,6 @@
 }
 
-psImage *psImageShift(psImage * out,
-                      const psImage * in,
+psImage* psImageShift(psImage* out,
+                      const psImage* in,
                       float dx, float dy, psF64 unexposedValue, psImageInterpolateMode mode)
 {
Index: trunk/psLib/src/image/psImageManip.h
===================================================================
--- trunk/psLib/src/image/psImageManip.h	(revision 1426)
+++ trunk/psLib/src/image/psImageManip.h	(revision 1440)
@@ -11,6 +11,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-09 22:44:25 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-09 23:34:58 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -32,5 +32,5 @@
  *  @return int     The number of clipped pixels
  */
-int psImageClip(psImage * input,        ///< the image to clip
+int psImageClip(psImage* input,        ///< the image to clip
                 psF64 min,      ///< the minimum image value allowed
                 psF64 vmin,     ///< the value pixels < min are set to
@@ -48,5 +48,5 @@
  *  @return int     The number of clipped pixels
  */
-int psImageClipComplexRegion(psImage * input,   ///< the image to clip
+int psImageClipComplexRegion(psImage* input,   ///< the image to clip
                              psC64 min, ///< the minimum image value allowed
                              psC64 vmin,        ///< the value pixels < min are set to
@@ -62,5 +62,5 @@
  *  @return int     The number of clipped pixels
  */
-int psImageClipNaN(psImage * input,     ///< the image to clip
+int psImageClipNaN(psImage* input,     ///< the image to clip
                    psF64 value  ///< the value to set all NaN/Inf values to
                   );
@@ -77,6 +77,6 @@
  *  @return int         0 if success, non-zero if failed.
  */
-int psImageOverlaySection(psImage * image,      ///< target image
-                          const psImage * overlay,      ///< the overlay image
+int psImageOverlaySection(psImage* image,      ///< target image
+                          const psImage* overlay,      ///< the overlay image
                           int col0,     ///< the column to start overlay
                           int row0,     ///< the row to start overlay
@@ -94,21 +94,21 @@
  *  @return psImage    new image formed by rebinning input image.
  */
-psImage *psImageRebin(psImage * out,    ///< an psImage to recycle.  If NULL, a new image is created
-                      const psImage * in,       ///< input image
+psImage* psImageRebin(psImage* out,    ///< an psImage to recycle.  If NULL, a new image is created
+                      const psImage* in,       ///< input image
                       unsigned int scale,       ///< the scale to rebin for each dimension
-                      const psStats * stats     ///< the statistic to perform when rebinning.  Only one
+                      const psStats* stats     ///< the statistic to perform when rebinning.  Only one
                       // method should be set.
                      );
 
-psImage *psImageResample(psImage * out, ///< an psImage to recycle.  If NULL, a new image is created
-                         const psImage * in,    ///< input image
+psImage* psImageResample(psImage* out, ///< an psImage to recycle.  If NULL, a new image is created
+                         const psImage* in,    ///< input image
                          int scale, psImageInterpolateMode mode);
 
-psImage *psImageRotate(psImage * out,   ///< an psImage to recycle.  If NULL, a new image is created
-                       const psImage * in,      ///< input image
+psImage* psImageRotate(psImage* out,   ///< an psImage to recycle.  If NULL, a new image is created
+                       const psImage* in,      ///< input image
                        float angle, float unexposedValue, psImageInterpolateMode mode);
 
-psImage *psImageShift(psImage * out,    ///< an psImage to recycle.  If NULL, a new image is created
-                      const psImage * in,       ///< input image
+psImage* psImageShift(psImage* out,    ///< an psImage to recycle.  If NULL, a new image is created
+                      const psImage* in,       ///< input image
                       float dx, float dy, float unexposedValue, psImageInterpolateMode mode);
 
@@ -119,8 +119,8 @@
  *  defined for psU8, psS8, psS16, psF32, psF64, psC32, and psC64.
  *
- *  @return psImage*    the rolled version of the input image.
+ *  @return psImage* the rolled version of the input image.
  */
-psImage *psImageRoll(psImage * out,     ///< an psImage to recycle.  If NULL, a new image is created
-                     const psImage * in,        ///< input image
+psImage* psImageRoll(psImage* out,     ///< an psImage to recycle.  If NULL, a new image is created
+                     const psImage* in,        ///< input image
                      int dx,    ///< number of pixels to roll in the x-dimension
                      int dy     ///< number of pixels to roll in the y-dimension
Index: trunk/psLib/src/image/psImageStats.c
===================================================================
--- trunk/psLib/src/image/psImageStats.c	(revision 1426)
+++ trunk/psLib/src/image/psImageStats.c	(revision 1440)
@@ -10,6 +10,6 @@
 *  @author George Gusciora, MHPCC
 *
-*  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-07 00:06:06 $
+*  @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-09 23:34:58 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -37,8 +37,8 @@
     NOTE: verify that image/mask have the correct types, and sizes.
  *****************************************************************************/
-psStats *psImageStats(psStats * stats, psImage * in, psImage * mask, int maskVal)
-{
-    psVector *junkData = NULL;
-    psVector *junkMask = NULL;
+psStats* psImageStats(psStats* stats, psImage* in, psImage* mask, int maskVal)
+{
+    psVector* junkData = NULL;
+    psVector* junkMask = NULL;
 
     if (stats == NULL) {
@@ -95,8 +95,8 @@
     NOTE: verify that image/mask have the, correct types and  sizes.
  *****************************************************************************/
-psHistogram *psImageHistogram(psHistogram * out, psImage * in, psImage * mask, unsigned int maskVal)
-{
-    psVector *junkData = NULL;
-    psVector *junkMask = NULL;
+psHistogram* psImageHistogram(psHistogram* out, psImage* in, psImage* mask, unsigned int maskVal)
+{
+    psVector* junkData = NULL;
+    psVector* junkMask = NULL;
 
     // NOTE: Verify this action.
@@ -183,11 +183,11 @@
 }
 
-psPolynomial1D **p_psCreateChebyshevPolys(int maxChebyPoly)
-{
-    psPolynomial1D **chebPolys = NULL;
+psPolynomial1D* *p_psCreateChebyshevPolys(int maxChebyPoly)
+{
+    psPolynomial1D* *chebPolys = NULL;
     int i = 0;
     int j = 0;
 
-    chebPolys = (psPolynomial1D **) psAlloc(maxChebyPoly * sizeof(psPolynomial1D *));
+    chebPolys = (psPolynomial1D* *) psAlloc(maxChebyPoly * sizeof(psPolynomial1D* ));
     for (i = 0; i < maxChebyPoly; i++) {
         chebPolys[i] = psPolynomial1DAlloc(i + 1);
@@ -224,5 +224,5 @@
         over all pixels (x,y) in the image.
  *****************************************************************************/
-psPolynomial2D *psImageFitPolynomial(const psImage * input, psPolynomial2D * coeffs)
+psPolynomial2D* psImageFitPolynomial(const psImage* input, psPolynomial2D* coeffs)
 {
     int x = 0;
@@ -231,5 +231,5 @@
     int j = 0;
     float **sums = NULL;
-    psPolynomial1D **chebPolys = NULL;
+    psPolynomial1D* *chebPolys = NULL;
     int maxChebyPoly = 0;
     float *cScalingFactors = NULL;
@@ -327,5 +327,5 @@
  
  *****************************************************************************/
-int psImageEvalPolynomial(const psImage * input, const psPolynomial2D * coeffs)
+int psImageEvalPolynomial(const psImage* input, const psPolynomial2D* coeffs)
 {
     int x = 0;
@@ -334,5 +334,5 @@
     int j = 0;
     float **sums = NULL;
-    psPolynomial1D **chebPolys = NULL;
+    psPolynomial1D* *chebPolys = NULL;
     int maxChebyPoly = 0;
     float *cScalingFactors = NULL;
Index: trunk/psLib/src/image/psImageStats.h
===================================================================
--- trunk/psLib/src/image/psImageStats.h	(revision 1426)
+++ trunk/psLib/src/image/psImageStats.h	(revision 1440)
@@ -10,6 +10,6 @@
 *  @author George Gusciora, MHPCC
 *
-*  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-09 22:44:25 $
+*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-09 23:34:58 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -28,23 +28,23 @@
 
 /// This routine must determine the various statistics for the image.
-psStats *psImageStats(psStats * stats,  ///< defines statistics to be calculated
-                      psImage * in,     ///< image (or subimage) to calculate stats
-                      psImage * mask,   ///< mask data for image (NULL ok)
+psStats* psImageStats(psStats* stats,  ///< defines statistics to be calculated
+                      psImage* in,     ///< image (or subimage) to calculate stats
+                      psImage* mask,   ///< mask data for image (NULL ok)
                       int maskVal);     ///< mask Mask for mask
 
-psHistogram *psImageHistogram(psHistogram * out,        ///< input histogram description & target
-                              psImage * in,     ///< Image data to be histogramed.
-                              psImage * mask,   ///< mask data for image (NULL ok)
+psHistogram* psImageHistogram(psHistogram* out,        ///< input histogram description & target
+                              psImage* in,     ///< Image data to be histogramed.
+                              psImage* mask,   ///< mask data for image (NULL ok)
                               unsigned int maskVal);    ///< mask Mask for mask
 
 /// Fit a 2-D polynomial surface to an image.
-psPolynomial2D *psImageFitPolynomial(const psImage * input,     ///< image to fit
-                                     psPolynomial2D * coeffs    ///< coefficient structure carries in
+psPolynomial2D* psImageFitPolynomial(const psImage* input,     ///< image to fit
+                                     psPolynomial2D* coeffs    ///< coefficient structure carries in
                                      // desired terms & target
                                     );
 
 /// Evaluate a 2-D polynomial surface to image pixels.
-int psImageEvalPolynomial(const psImage * input,        ///< image to fit
-                          const psPolynomial2D * coeffs ///< coefficient structure carries in desired terms
+int psImageEvalPolynomial(const psImage* input,        ///< image to fit
+                          const psPolynomial2D* coeffs ///< coefficient structure carries in desired terms
                          );