Index: trunk/archive/pslib/include/psImage.h
===================================================================
--- trunk/archive/pslib/include/psImage.h	(revision 617)
+++ trunk/archive/pslib/include/psImage.h	(revision 671)
@@ -26,5 +26,5 @@
     const struct psImage *parent;	///< parent, if a subimage 
     int Nchildren;			///< number of subimages 
-    struct psImage *children;		///< children of this region; array of Nchildren pointers
+    struct psImage **children;		///< children of this region; array of Nchildren pointers
 } psImage;
 
@@ -40,6 +40,6 @@
 psImageAlloc (int nx,			///< image width 
 	      int ny,			///< image height 
-	      psElemType type		///< image data type 
-    );
+	      psElemType type)		///< image data type 
+;
 
 /// Create a subimage of the specified area.
@@ -49,16 +49,16 @@
 	      int ny,			///< subimage width (<= image.ny - y0)  
 	      int x0,			///< subimage x-offset (0 <= x0 < nx)   
-	      int y0			///< subimage y-offset (0 <= y0 < ny)   
-    );
+	      int y0)			///< subimage y-offset (0 <= y0 < ny)   
+;
 
 /// Destroy the specified image (destroy children if they exist).
 void 
-psImageFree(psImage *restrict image	///< free this image
-    );
+psImageFree(psImage *restrict image)	///< free this image
+;
 
 /** Destroy the pixels of the specified image */
 psImage *
-psImageFreePixels(psImage *restrict image ///< Image whose pixels are to be freed
-    );
+psImageFreePixels(psImage *restrict image) ///< Image whose pixels are to be freed
+;
 
 /// Create a copy of the specified image.
@@ -66,12 +66,12 @@
 psImageCopy(psImage *output, 		///< target structure for output image data
 	    const psImage *input,	///< copy this image 
-	    psElemType type		///< element type of output image
-    );
+	    psElemType type)		///< element type of output image
+;
 
 /*** various image pixel extractions ***/
 
 /// Extract pixels from rectlinear region to a vector.
-psFloatArray *
-psImageSlice(psFloatArray *out,		///< Vector to output, or NULL
+psVector *
+psImageSlice(psVector *out,		///< Vector to output, or NULL
 	     const psImage *input,	///< extract slice from this image
 	     int x, 			///< starting x coord of region to slice
@@ -80,10 +80,10 @@
 	     int ny, 			///< width of region in y
 	     int direction,		///< direction of vector along slice
-	     const psStats *stats	///< defines statistics used to find output values
-    );
+	     const psStats *stats)	///< defines statistics used to find output values
+;
 
 /// Extract pixels along a line to a vector.
-psFloatArray *
-psImageCut(psFloatArray *out,		///< Vector to output, or NULL
+psVector *
+psImageCut(psVector *out,		///< Vector to output, or NULL
 	   const psImage *input,	///< extract cut from this image
 	   float xs, 			///< starting x coord of cut
@@ -92,16 +92,16 @@
 	   float ye, 			///< ending y coord of cut
 	   float dw, 			///< width of cut
-	   const psStats *stats		///< defines statistics used to find output values
-    );
+	   const psStats *stats)		///< defines statistics used to find output values
+;
 
 /// Extract radial annulii data to a vector.
-psFloatArray *
-psImageRadialCut(psFloatArray *out,	///< Vector to output, or NULL
+psVector *
+psImageRadialCut(psVector *out,		///< Vector to output, or NULL
 		 const psImage *input,	///< extract profile from this image
 		 float x, 		///< center x coord of annulii
 		 float y, 		///< center y coord of annulii
-		 const psFloatArray *radii, ///< Radii of the annuli
-		 const psStats *stats	///< defines statistics used to find output values
-    );
+		 const psVector *radii, ///< Radii of the annuli
+		 const psStats *stats)	///< defines statistics used to find output values
+;
 
 /*** various image geometry manipulation ***/
@@ -111,6 +111,6 @@
 	     const psImage *input,	///< rebin this image
 	     float scale, 		///< rebinning scale: doutput = scale*dinput
-	     const psStats *stats	///< defines statistics used to find output values
-    );
+	     const psStats *stats)	///< defines statistics used to find output values
+;
 
 /// Rotate image by given angle.
@@ -118,6 +118,6 @@
 psImageRotate(psImage *out,		///< Image to output, or NULL
 	      const psImage *input,	///< rotate this image
-	      float angle		///< rotate by this amount anti-clockwise (degrees)
-    );
+	      float angle)		///< rotate by this amount anti-clockwise (degrees)
+;
 
 /// Shift image by an arbitrary number of pixels in either direction.
@@ -128,6 +128,6 @@
 	     float dx,			///< shift by this amount in x
 	     float dy,			///< shift by this amount in y
-	     float exposed		///< set exposed pixels to this value
-    );
+	     float exposed)		///< set exposed pixels to this value
+;
 
 /// Roll image by an integer number of pixels in either direction.
@@ -137,30 +137,30 @@
 	    const psImage *input,	///< roll this image
 	    int dx, 			///< roll this amount in x
-	    int dy			///< roll this amount in y
-    );
+	    int dy)			///< roll this amount in y
+;
 
 /// Determine statistics for image (or subimage).
 psStats *
 psImageGetStats(psStats *stats,		///< defines statistics to be calculated & target
-		const psImage *input 	///< image (or subimage) to calculate stats
-		);
+		const psImage *input) 	///< image (or subimage) to calculate stats
+;
 
 /// Construct a histogram from an image (or subimage).
 psHistogram *
 psImageHistogram(psHistogram *hist,	///< input histogram description & target
-		 const psImage *input	///< determine histogram of this image
-    );
+		 const psImage *input)	///< determine histogram of this image
+;
 
 /// Fit a 2-D polynomial surface to an image.
 psPolynomial2D *
 psImageFitPolynomial(psPolynomial2D *coeffs, ///< coefficient structure carries in desired terms & target
-		     const psImage *input ///< image to fit
-    );
+		     const psImage *input) ///< image to fit
+;
 
 /// Evaluate a 2-D polynomial surface to image pixels.
 psImage *
 psImageEvalPolynomial(const psImage *input, ///< image to produce
-		      const psPolynomial2D *coeffs ///< coefficient structure carries in desired terms
-    );
+		      const psPolynomial2D *coeffs) ///< coefficient structure carries in desired terms
+;
 
 /*** image input/output routines ***/
@@ -175,6 +175,6 @@
 		   const char *extname,	///< MEF extension name ("PHU" for primary header)
 		   int extnum,		///< MEF extension number (-1 for "PHU", 0 : Nextend - 1)
-		   const char *filename	///< file to read data from
-    );
+		   const char *filename)	///< file to read data from
+;
 
 /// Read an image or subimage from file descriptor.
@@ -188,6 +188,6 @@
 		    const char *extname, ///< MEF extension name ("PHU" for primary header)
 		    int extnum, 	///< MEF extension number (-1 for "PHU", 0 : Nextend - 1)
-		    FILE *f		///< file descriptor to read data from		   
-    );
+		    FILE *f)		///< file descriptor to read data from		   
+;
 
 /// Write an image section to named file (which may exist).
@@ -199,6 +199,6 @@
 		    const char *extname, ///< MEF extension name ("PHU" for primary header)
 		    int extnum, 	///< MEF extension number (-1 for "PHU", 0 : Nextend - 1)
-		    const char *filename ///< file to write data to		   
-    );
+		    const char *filename) ///< file to write data to		   
+;
 
 /// Write an image section to named file (which may exist).
@@ -210,6 +210,6 @@
 		     const char *extname, ///< MEF extension name			   
 		     int extnum, 	///< MEF extension number (-1 for "PHU", 0 : Nextend - 1)
-		     FILE *f		///< file descriptor to write data to		   
-    );
+		     FILE *f)		///< file descriptor to write data to		   
+;
 
 /// Read only header from image file.
@@ -218,6 +218,6 @@
 		  const char *extname, 	///< MEF extension name ("PHU" for primary header)
 		  int extnum,		///< MEF extension number (-1 for "PHU", 0 : Nextend - 1)
-		  const char *filename	///< file to read from
-    );
+		  const char *filename)	///< file to read from
+;
 
 /// Read only header from image file descriptor.
@@ -226,6 +226,6 @@
 		   const char *extname,	///< MEF extension name ("PHU" for primary header)
 		   int extnum,		///< MEF extension number (-1 for "PHU", 0 : Nextend - 1)
-		   FILE *f		///< file descriptor to read from
-    );
+		   FILE *f)		///< file descriptor to read from
+;
 
 /*** basic pixel manipulations ***/
@@ -236,12 +236,12 @@
 	    float vmin, 		///< set min-clipped pixels to vmin
 	    float max,			///< clip pixels with values > max
-	    float vmax			///< set max-clipped pixels to vmax
-    );
+	    float vmax)			///< set max-clipped pixels to vmax
+;
 
 /// Clip NaN image pixels to given value.  Return number of clipped pixels.
 int
 psImageClipNaN(psImage *input,		///< clip this image & target
-	       float value		///< set nan pixels to this value
-    );
+	       float value)		///< set nan pixels to this value
+;
 
 /// Overlay subregion of image with another image.  Return number of pixels replaced.
@@ -251,6 +251,6 @@
 		      int x0,		///< x offset of overlay subimage 
 		      int y0,		///< y offset of overlay subimage 
-		      const char *op	///< overlay operation 
-    );
+		      const char *op)	///< overlay operation 
+;
 
 /* \} */ // End of AstroGroup Functions