Index: trunk/psLib/src/image/psImage.h =================================================================== --- trunk/psLib/src/image/psImage.h (revision 1407) +++ trunk/psLib/src/image/psImage.h (revision 1426) @@ -12,22 +12,25 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.28 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-08-07 00:06:06 $ + * @version $Revision: 1.29 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 22:44:25 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii */ #ifndef PS_IMAGE_H -# define PS_IMAGE_H +#define PS_IMAGE_H -# include +#include -# include "psType.h" +#include "psType.h" /// @addtogroup Image /// @{ +/** enumeration of options in interpolation + * + */ typedef enum { - PS_INTERPOLATE_FLAT, - PS_INTERPOLATE_BILINEAR + PS_INTERPOLATE_FLAT, ///< 'flat' interpolation (nearest pixel) + PS_INTERPOLATE_BILINEAR ///< bi-linear interpolation } psImageInterpolateMode; @@ -40,29 +43,29 @@ typedef struct psImage { - const psType type; // /< Image data type and dimension. - const unsigned int numCols; // /< Number of columns in image - const unsigned int numRows; // /< Number of rows in image. - const int col0; // /< Column position relative to parent. - const int row0; // /< Row position relative to parent. + const psType type; ///< Image data type and dimension. + const unsigned int numCols; ///< Number of columns in image + const unsigned int numRows; ///< Number of rows in image. + const int col0; ///< Column position relative to parent. + const int row0; ///< Row position relative to parent. 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. - } data; // /< Union for data types. - const struct psImage *parent; // /< Parent, if a subimage. - int nChildren; // /< Number of subimages. - struct psImage **children; // /< Children of this region. + 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. + int nChildren; ///< Number of subimages. + struct psImage **children; ///< Children of this region. } psImage; @@ -82,7 +85,7 @@ * */ -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. +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. ); @@ -92,8 +95,8 @@ * */ -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 - const psElemType type // /< the desired datatype of the image +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 + const psElemType type ///< the desired datatype of the image ); Index: trunk/psLib/src/image/psImageExtraction.h =================================================================== --- trunk/psLib/src/image/psImageExtraction.h (revision 1407) +++ trunk/psLib/src/image/psImageExtraction.h (revision 1426) @@ -10,6 +10,6 @@ * @author Robert DeSonia, MHPCC * -* @version $Revision: 1.6 $ $Name: not supported by cvs2svn $ -* @date $Date: 2004-08-07 00:06:06 $ +* @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 22:44:25 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -26,26 +26,29 @@ /// @{ +/* Cut direction flag. Used with psImageCut function. + */ typedef enum { - PS_CUT_X_POS, - PS_CUT_X_NEG, - PS_CUT_Y_POS, - PS_CUT_Y_NEG, + PS_CUT_X_POS, ///< Cut in the x dimension from left to right + PS_CUT_X_NEG, ///< Cut in the x dimension from rigth to left + PS_CUT_Y_POS, ///< Cut in the y dimension from bottom up + PS_CUT_Y_NEG, ///< Cut in the y dimension from top down. } psImageCutDirection; /** Create a subimage of the specified area. -* -* Uses psLib memory allocation functions to create an image based on a larger -* one. -* -* @return psImage*: Pointer to psImage. -* -*/ -psImage *psImageSubset(psImage * out, // /< Subimage to return, or NULL. - psImage * image, // /< Parent image. - unsigned int numCols, // /< Subimage width (<= image.nCols - col0). - unsigned int numRows, // /< Subimage height (<= image.nRows - row0). - unsigned int col0, // /< Subimage col-offset (0 <= col0 < nCol). - unsigned int row0 // /< Subimage row-offset (0 <= row0 < nCol). - ); + * + * Uses psLib memory allocation functions to create an image based on a larger + * one. + * + * @return psImage*: Pointer to psImage. + * + */ +psImage* psImageSubset( + psImage* out, ///< image to recycle, or NULL. + psImage* image, ///< Parent image. + unsigned int numCols, ///< Subimage width (<= image.nCols - col0). + unsigned int numRows, ///< Subimage height (<= image.nRows - row0). + unsigned int col0, ///< Subimage col-offset (0 <= col0 < nCol). + unsigned int row0 ///< Subimage row-offset (0 <= row0 < nCol). +); /** Makes a copy of a psImage @@ -55,39 +58,93 @@ * */ -psImage *psImageCopy(psImage * restrict output, +psImage* psImageCopy( + psImage* restrict output, ///< if not NULL, a psImage that could be recycled. + const psImage* input, ///< the psImage to copy + psElemType type ///< the desired datatype of the returned copy +); - /**< if not NULL, a psImage that could be recycled. If it can not be used, - * it will be freed via psImageFree - */ - const psImage * input, - /**< the psImage to copy */ - psElemType type +/** Extract pixels from rectlinear region to a vector (array of floats). + * + * The output vector contains either nx or ny elements, based on the value of + * the direction: e.g., if direction is PS_CUT_X_POS, there are nx elements. + * The input region is collapsed in the perpendicular direction, and each + * element of the output vectors is derived from the statistics of the pixels + * at that direction coordinate. The statistic used to derive the output + * vector value is specified by stats. Only one of the statistics choices may + * be specified, otherwise the function must return an error. This function + * must be defined for the following types: psS8, psU16, psF32, psF64. + * + * @return psVector the resulting vector + */ +psVector *psImageSlice( + psVector* out, ///< psVector to recycle, or NULL. + psVector* slicePositions, + ///< If not NULL, it is populated with the coordinate in the slice dimension + ///< coorsponding to the output vector's value of the same position in the + ///< vector. This vector maybe resized and retyped as appropriate. + const psImage* restrict input, ///< the input image in which to perform the slice + const psImage* restrict mask, ///< the mask for the input image. + unsigned int maskVal, ///< the mask value to apply to the mask + unsigned int col, ///< the leftmost column of the slice region + unsigned int row, ///< the bottommost row of the slice region + unsigned int numCols, ///< the number of columns in the slice region + unsigned int numRows, ///< the number of rows in the slice region + psImageCutDirection direction, ///< the slice dimension and direction + const psStats* stats ///< the statistic to perform in slice operation +); - /**< the desired datatype of the returned copy */ - ); +/** Extract pixels from an image along a line to a vector (array of floats). + * + * The vector (xs,ys) - (xe,ye) forms the basis of the output vector. Pixels + * are considered in a rectangular region of width dw about this vector. The + * input region is collapsed in the perpendicular direction, and each element + * of the output vector represents pixel-sized boxes, where the value is + * derived from the statistics of the pixels interpolated along the + * perpendicular direction. The specific algorithm which must be used is + * described in the PSLib ADD (PSDC-430-006). The statistic used to derive + * the output vector value is specified by stats. Only one of the statistics + * choices may be specified, otherwise the function must return an error. + * This function must be defined for the following types: psS8, psU16, psF32, + * psF64. + * + * @return psVector resulting vector + */ +psVector *psImageCut( + psVector* out, ///< psVector to recycle, or NULL. + const psImage* input, ///< the input image in which to perform the cut + const psImage* restrict mask, ///< the mask for the input image. + unsigned int maskVal, ///< the mask value to apply to the mask + float startCol, ///< the column of the start of the cut line + float startRow, ///< the row of the start of the cut line + float endCol, ///< the column of the end of the cut line + float endRow, ///< the row of the end of the cut line + float width, ///< the distance about the line to perform the statistics + const psStats* stats ///< the statistic to perform in operation +); -psVector *psImageSlice(psVector * out, - psVector * slicePositions, - const psImage * restrict input, - const psImage * restrict mask, - unsigned int maskVal, - unsigned int col, - unsigned int row, - unsigned int numCols, - unsigned int numRows, psImageCutDirection direction, const psStats * stats); - -psVector *psImageCut(psVector * out, - const psImage * input, - const psImage * restrict mask, - unsigned int maskVal, - float startCol, - float startRow, float endCol, float endRow, float width, const psStats * stats); - -psVector *psImageRadialCut(psVector * out, - const psImage * input, - const psImage * restrict mask, - unsigned int maskVal, - float centerCol, float centerRow, const psVector * radii, const psStats * stats); +/** Extract radial region data to a vector. A vector is constructed where each + * vector elements is derived from the statistics of the pixels which land + * within one of a sequence of radii. The radii are centered on the image + * pixel coordinate x,y, and are defined by the sequence of values in the + * vector radii. The specific algorithm which must be used is described in + * the PSLib ADD (PSDC-430-006). The statistic used to derive the output + * vector value is specified by stats. Only one of the statistics choices + * may be specified, otherwise the function must return an error. This + * function must be defined for the following types: psS8, psU16, psF32, + * psF64. + * + * @return psVector resulting vector + */ +psVector* psImageRadialCut( + psVector* out, ///< psVector to recycle, or NULL. + const psImage* input, ///< the input image in which to perform the cut + const psImage* restrict mask, ///< the mask for the input image. + unsigned int maskVal, ///< the mask value to apply to the mask + float centerCol, ///< the column of the center of the cut circle + float centerRow, ///< the row of the center of the cut circle + const psVector* radii, ///< the radii of the cut circle + const psStats* stats ///< the statistic to perform in operation +); /// @} Index: trunk/psLib/src/image/psImageManip.h =================================================================== --- trunk/psLib/src/image/psImageManip.h (revision 1407) +++ trunk/psLib/src/image/psImageManip.h (revision 1426) @@ -11,6 +11,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-08-07 00:06:06 $ + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 22:44:25 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -32,9 +32,9 @@ * @return int The number of clipped pixels */ -int psImageClip(psImage * input, // /< the image to clip - psF64 min, // /< the minimum image value allowed - psF64 vmin, // /< the value pixels < min are set to - psF64 max, // /< the maximum image value allowed - psF64 vmax // /< the value pixels > max are set to +int psImageClip(psImage * input, ///< the image to clip + psF64 min, ///< the minimum image value allowed + psF64 vmin, ///< the value pixels < min are set to + psF64 max, ///< the maximum image value allowed + psF64 vmax ///< the value pixels > max are set to ); @@ -48,9 +48,9 @@ * @return int The number of clipped pixels */ -int psImageClipComplexRegion(psImage * input, // /< the image to clip - psC64 min, // /< the minimum image value allowed - psC64 vmin, // /< the value pixels < min are set to - psC64 max, // /< the maximum image value allowed - psC64 vmax // /< the value pixels > max are set to +int psImageClipComplexRegion(psImage * input, ///< the image to clip + psC64 min, ///< the minimum image value allowed + psC64 vmin, ///< the value pixels < min are set to + psC64 max, ///< the maximum image value allowed + psC64 vmax ///< the value pixels > max are set to ); @@ -62,6 +62,6 @@ * @return int The number of clipped pixels */ -int psImageClipNaN(psImage * input, // /< the image to clip - psF64 value // /< the value to set all NaN/Inf values to +int psImageClipNaN(psImage * input, ///< the image to clip + psF64 value ///< the value to set all NaN/Inf values to ); @@ -77,9 +77,9 @@ * @return int 0 if success, non-zero if failed. */ -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 - const char *op // /< the operation to perform for overlay +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 + const char *op ///< the operation to perform for 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 - unsigned int scale, // /< the scale to rebin for each dimension - const psStats * stats // /< the statistic to perform when rebinning. Only one +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 // 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); @@ -121,8 +121,8 @@ * @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 - int dx, // /< number of pixels to roll in the x-dimension - int dy // /< number of pixels to roll in the y-dimension +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.h =================================================================== --- trunk/psLib/src/image/psImageStats.h (revision 1407) +++ trunk/psLib/src/image/psImageStats.h (revision 1426) @@ -10,6 +10,6 @@ * @author George Gusciora, 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 22:44:25 $ * * 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) - int maskVal); // /< mask Mask for mask +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) - unsigned 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) + 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 );