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 +); /// @}