IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4367


Ignore:
Timestamp:
Jun 22, 2005, 5:50:29 PM (21 years ago)
Author:
drobbin
Message:

changed files according to requested revisions outlined in apidelta-report-cycle6

Location:
trunk/psLib
Files:
29 edited

Legend:

Unmodified
Added
Removed
  • trunk/psLib/pslib.kdevelop

    r3476 r4367  
    1212    </keywords>
    1313    <ignoreparts>
     14      <part>KDevClearCase</part>
     15      <part>KDevcopyto</part>
    1416      <part>KDevCTags</part>
     17      <part>CvsService</part>
     18      <part>KDevFileGroups</part>
     19      <part>KDevPerforce</part>
    1520      <part>KDevsubversion</part>
    16       <part>KDevcopyto</part>
    17       <part>KDevClearCase</part>
    18       <part>KDevFileGroups</part>
    19       <part>CvsService</part>
    20       <part>KDevPerforce</part>
    2121    </ignoreparts>
     22    <projectdirectory>./src/</projectdirectory>
     23    <absoluteprojectpath>false</absoluteprojectpath>
     24    <description/>
     25    <secondaryLanguages/>
    2226  </general>
    2327  <kdevautoproject>
     
    156160    </codecompletion>
    157161  </kdevcppsupport>
     162  <cppsupportpart>
     163    <filetemplates>
     164      <interfacesuffix>.h</interfacesuffix>
     165      <implementationsuffix>.cpp</implementationsuffix>
     166    </filetemplates>
     167  </cppsupportpart>
     168  <kdevdebugger>
     169    <general>
     170      <programargs/>
     171      <gdbpath/>
     172      <dbgshell>libtool</dbgshell>
     173      <configGdbScript/>
     174      <runShellScript/>
     175      <runGdbScript/>
     176      <breakonloadinglibs>true</breakonloadinglibs>
     177      <separatetty>false</separatetty>
     178      <floatingtoolbar>false</floatingtoolbar>
     179    </general>
     180    <display>
     181      <staticmembers>false</staticmembers>
     182      <demanglenames>true</demanglenames>
     183      <outputradix>10</outputradix>
     184    </display>
     185  </kdevdebugger>
    158186</kdevelop>
  • trunk/psLib/pslib.kdevses

    r4342 r4367  
    22<!DOCTYPE KDevPrjSession>
    33<KDevPrjSession>
    4  <DocsAndViews NumberOfDocuments="2" >
    5   <Doc0 NumberOfViews="1" URL="file:/home/drobbin/panstarrs/psLib/src/collections/psVector.h" >
    6    <View0 line="103" Type="Source" />
    7   </Doc0>
    8   <Doc1 NumberOfViews="1" URL="file:/home/drobbin/panstarrs/psLib/src/collections/psVector.c" >
    9    <View0 line="130" Type="Source" />
    10   </Doc1>
    11  </DocsAndViews>
     4 <DocsAndViews NumberOfDocuments="0" />
    125 <pluginList>
    136  <kdevbookmarks>
  • trunk/psLib/src/collections/psArray.c

    r4342 r4367  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-06-22 02:05:41 $
     11 *  @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-06-23 03:50:29 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    147147}
    148148
    149 psArray* psArraySort(psArray* array, psComparePtrFcn func)
     149psArray* psArraySort(psArray* array, psComparePtrFunc func)
    150150{
    151151    if (array == NULL) {
  • trunk/psLib/src/collections/psArray.h

    r4342 r4367  
    1212 *  @author Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-06-22 02:05:41 $
     14 *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2005-06-23 03:50:29 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    123123psArray* psArraySort(
    124124    psArray* array,                       ///< input array to sort.
    125     psComparePtrFcn func                  ///< the compare function
     125    psComparePtrFunc func                 ///< the compare function
    126126);
    127127
  • trunk/psLib/src/collections/psCompare.h

    r4162 r4367  
    66 *  @ingroup Compare
    77 *
    8  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-06-08 23:40:45 $
     8 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-06-23 03:50:29 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    2828 *                   than, equal to, or greater than the second.
    2929 */
    30 typedef int (*psComparePtrFcn) (
     30typedef int (*psComparePtrFunc) (
    3131    const void **a,                    ///< first comparison target
    3232    const void **b                     ///< second comparison target
  • trunk/psLib/src/collections/psList.c

    r4316 r4367  
    66 *  @author Robert Daniel DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-06-18 03:13:01 $
     8 *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-06-23 03:50:29 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    610610}
    611611
    612 psList* psListSort(psList* list, psComparePtrFcn compare)
     612psList* psListSort(psList* list, psComparePtrFunc func)
    613613{
    614614    psArray* arr;
     
    622622    psFree(list);
    623623
    624     arr = psArraySort(arr, compare);
     624    arr = psArraySort(arr, func);
    625625
    626626    // convert back to linked list
  • trunk/psLib/src/collections/psList.h

    r4330 r4367  
    77 *  @ingroup LinkedList
    88 *
    9  *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-06-21 03:01:37 $
     9 *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2005-06-23 03:50:29 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    9999psListIterator* psListIteratorAlloc(
    100100    psList* list,                      ///< the psList to iterate with
    101     long location,                      ///< the initial starting point.
     101    long location,                     ///< the initial starting point.
    102102    ///<  This can be a numeric index, PS_LIST_HEAD, or PS_LIST_TAIL.
    103103    bool mutable                       ///< Is it permissible to modify list?
     
    221221psList* psListSort(
    222222    psList* list,                      ///< the list to sort
    223     psComparePtrFcn compare            ///< the comparison function
     223    psComparePtrFunc func              ///< the comparison function
    224224);
    225225
  • trunk/psLib/src/image/psImageGeomManip.c

    r4316 r4367  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-06-18 03:13:02 $
     12 *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-06-23 03:50:29 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    3636                      const psImage* restrict mask,
    3737                      psMaskType maskVal,
    38                       psU32 scale,
     38                      int scale,
    3939                      const psStats* stats)
    4040{
     
    303303
    304304psImage* psImageRotate(psImage* out,
    305                        const psImage* in,
     305                       const psImage* input,
    306306                       float angle,
    307                        psC64 unexposedValue,
     307                       _Complex exposed,
    308308                       psImageInterpolateMode mode)
    309309{
    310     if (in == NULL) {
     310    if (input == NULL) {
    311311        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    312312                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    319319    if (fabsf(angle - M_PI_2) < FLT_EPSILON) {
    320320        // perform 1/4 rotate counter-clockwise
    321         psS32 numRows = in->numCols;
    322         psS32 numCols = in->numRows;
     321        psS32 numRows = input->numCols;
     322        psS32 numCols = input->numRows;
    323323        psS32 lastCol = numCols - 1;
    324         psElemType type = in->type.type;
     324        psElemType type = input->type.type;
    325325
    326326        out = psImageRecycle(out, numCols, numRows, type);
     
    328328        #define PSIMAGE_ROTATE_LEFT_90(TYPE) \
    329329    case PS_TYPE_##TYPE: { \
    330             ps##TYPE** inData = in->data.TYPE; \
     330            ps##TYPE** inData = input->data.TYPE; \
    331331            for (psS32 row=0;row<numRows;row++) { \
    332332                ps##TYPE* outRow = out->data.TYPE[row]; \
     
    364364    } else if (fabsf(angle - M_PI) < FLT_EPSILON) {
    365365        // perform 1/2 rotate
    366         psS32 numRows = in->numRows;
     366        psS32 numRows = input->numRows;
    367367        psS32 lastRow = numRows - 1;
    368         psS32 numCols = in->numCols;
     368        psS32 numCols = input->numCols;
    369369        psS32 lastCol = numCols - 1;
    370         psElemType type = in->type.type;
     370        psElemType type = input->type.type;
    371371
    372372        out = psImageRecycle(out, numCols, numRows, type);
     
    376376            for (psS32 row=0;row<numRows;row++) { \
    377377                ps##TYPE* outRow = out->data.TYPE[row]; \
    378                 ps##TYPE* inRow = in->data.TYPE[lastRow-row]; \
     378                ps##TYPE* inRow = input->data.TYPE[lastRow-row]; \
    379379                for (psS32 col=0;col<numCols;col++) { \
    380380                    outRow[col] = inRow[lastCol - col]; \
     
    410410    } else if (fabsf(angle - (M_PI+M_PI_2)) < FLT_EPSILON) {
    411411        // perform 1/4 rotate clockwise
    412         psS32 numRows = in->numCols;
     412        psS32 numRows = input->numCols;
    413413        psS32 lastRow = numRows - 1;
    414         psS32 numCols = in->numRows;
    415         psElemType type = in->type.type;
     414        psS32 numCols = input->numRows;
     415        psElemType type = input->type.type;
    416416
    417417        out = psImageRecycle(out, numCols, numRows, type);
     
    419419        #define PSIMAGE_ROTATE_RIGHT_90(TYPE) \
    420420    case PS_TYPE_##TYPE: { \
    421             ps##TYPE** inData = in->data.TYPE; \
     421            ps##TYPE** inData = input->data.TYPE; \
    422422            for (psS32 row=0;row<numRows;row++) { \
    423423                ps##TYPE* outRow = out->data.TYPE[row]; \
     
    454454        }
    455455    } else if (fabsf(angle) < FLT_EPSILON) {
    456         out = psImageCopy(out, in, in->type.type);
     456        out = psImageCopy(out, input, input->type.type);
    457457    } else {
    458         psElemType type = in->type.type;
    459         psS32 numRows = in->numRows;
    460         psS32 numCols = in->numCols;
     458        psElemType type = input->type.type;
     459        psS32 numRows = input->numRows;
     460        psS32 numCols = input->numCols;
    461461        float centerX = (float)(numCols) / 2.0f;
    462462        float centerY = (float)(numRows) / 2.0f;
     
    497497
    498498        #define PSIMAGE_ROTATE_ARBITRARY_LOOP(TYPE,MODE) { \
    499             if (creal(unexposedValue) < PS_MIN_##TYPE || \
    500                     creal(unexposedValue) > PS_MAX_##TYPE || \
    501                     cimag(unexposedValue) < PS_MIN_##TYPE || \
    502                     cimag(unexposedValue) > PS_MAX_##TYPE) { \
     499            if (creal(exposed) < PS_MIN_##TYPE || \
     500                    creal(exposed) > PS_MAX_##TYPE || \
     501                    cimag(exposed) < PS_MIN_##TYPE || \
     502                    cimag(exposed) > PS_MAX_##TYPE) { \
    503503                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    504504                        PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
    505                         "unexposedValue", \
    506                         creal(unexposedValue),cimag(unexposedValue), \
     505                        "exposed", \
     506                        creal(exposed),cimag(exposed), \
    507507                        PS_TYPE_##TYPE##_NAME,  \
    508508                        (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
     
    519519                outRow = out->data.TYPE[y]; \
    520520                for (psS32 x = 0; x < outCols; x++) { \
    521                     outRow[x] = p_psImagePixelInterpolate##MODE##_##TYPE(in,inX,inY,NULL,0,unexposedValue); \
     521                    outRow[x] = p_psImagePixelInterpolate##MODE##_##TYPE(input,inX,inY,NULL,0,exposed); \
    522522                    inX += cosT; \
    523523                    inY -= sinT; \
     
    594594
    595595psImage* psImageShift(psImage* out,
    596                       const psImage* in,
     596                      const psImage* input,
    597597                      float dx,
    598598                      float dy,
    599                       psC64 unexposedValue,
     599                      _Complex exposed,
    600600                      psImageInterpolateMode mode)
    601601{
     
    605605    psElemType type;
    606606
    607     if (in == NULL) {
     607    if (input == NULL) {
    608608        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    609609                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    613613    // create an output image of the same size
    614614    // and type
    615     outRows = in->numRows;
    616     outCols = in->numCols;
    617     type = in->type.type;
     615    outRows = input->numRows;
     616    outCols = input->numCols;
     617    type = input->type.type;
    618618    elementSize = PSELEMTYPE_SIZEOF(type);
    619619    out = psImageRecycle(out, outCols, outRows, type);
     
    621621    #define PSIMAGE_SHIFT_CASE(MODE,TYPE) \
    622622case PS_TYPE_##TYPE: \
    623     if (creal(unexposedValue) < PS_MIN_##TYPE || \
    624             creal(unexposedValue) > PS_MAX_##TYPE || \
    625             cimag(unexposedValue) < PS_MIN_##TYPE || \
    626             cimag(unexposedValue) > PS_MAX_##TYPE) { \
     623    if (creal(exposed) < PS_MIN_##TYPE || \
     624            creal(exposed) > PS_MAX_##TYPE || \
     625            cimag(exposed) < PS_MIN_##TYPE || \
     626            cimag(exposed) > PS_MAX_##TYPE) { \
    627627        psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    628628                PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
    629                 "unexposedValue", \
    630                 creal(unexposedValue),cimag(unexposedValue), \
     629                "exposed", \
     630                creal(exposed),cimag(exposed), \
    631631                PS_TYPE_##TYPE##_NAME,  \
    632632                (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
     
    640640        for (psS32 col=0;col<outCols;col++) { \
    641641            outRow[col] = p_psImagePixelInterpolate##MODE##_##TYPE( \
    642                           in,dx+(float)col,y,NULL,0,unexposedValue); \
     642                          input,dx+(float)col,y,NULL,0,exposed); \
    643643        } \
    644644    } \
     
    647647    #define PSIMAGE_SHIFT_ARBITRARY_CASE(MODE) \
    648648case PS_INTERPOLATE_##MODE: \
    649     switch (in->type.type) { \
     649    switch (input->type.type) { \
    650650        PSIMAGE_SHIFT_CASE(MODE,U8);  \
    651651        PSIMAGE_SHIFT_CASE(MODE,U16); \
     
    694694                          int inputMaskVal,
    695695                          const psPlaneTransform *outToIn,
    696                           const psRegion region,
     696                          psRegion region,
    697697                          const psPixels* pixels,
    698698                          psImageInterpolateMode mode,
    699                           int exposedValue)
     699                          double exposedValue)
    700700{
    701701    if (input == NULL) {
  • trunk/psLib/src/image/psImageGeomManip.h

    r4316 r4367  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-06-18 03:13:02 $
     10 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-06-23 03:50:29 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    3939    const psImage* mask,               ///< mask for input image.  If NULL, no masking is done.
    4040    psMaskType maskVal,                ///< the bits to check in mask.
    41     psU32 scale,                       ///< the scale to rebin for each dimension
     41    int scale,                         ///< the scale to rebin for each dimension
    4242    const psStats* stats
    4343    ///< the statistic to perform when rebinning.  Only one method should be set.
     
    7575psImage* psImageRotate(
    7676    psImage* out,                      ///< an psImage to recycle.  If NULL, a new image is created
    77     const psImage* in,                 ///< input image
     77    const psImage* input,              ///< input image
    7878    float angle,                       ///< the rotation angle in radians.
    79     psC64 unexposedValue,              ///< the output image pixel values for non-imagery areas
     79    _Complex exposed,                  ///< the output image pixel values for non-imagery areas
    8080    psImageInterpolateMode mode        ///< the interpolation mode used
    8181);
     
    9494psImage* psImageShift(
    9595    psImage* out,                      ///< an psImage to recycle.  If NULL, a new image is created
    96     const psImage* in,                 ///< input image
     96    const psImage* input,              ///< input image
    9797    float dx,                          ///< the shift in x direction.
    9898    float dy,                          ///< the shift in y direction.
    99     psC64 unexposedValue,              ///< the output image pixel values for non-imagery areas
     99    _Complex exposed,                  ///< the output image pixel values for non-imagery areas
    100100    psImageInterpolateMode mode        ///< the interpolation mode to use
    101101);
     
    149149    int inputMaskVal,                  ///< masking value for inputMask
    150150    const psPlaneTransform *outToIn,   ///< the transform to apply
    151     const psRegion region,             ///< the size of the transformed image
     151    psRegion region,                   ///< the size of the transformed image
    152152    const psPixels* pixels,            /**< if not NULL, consists of psPixelCoords and specifies which pixels in
    153                                                      *  output image shall be transformed; otherwise, entire image generated*/
     153                                                         *  output image shall be transformed; otherwise, entire image generated*/
    154154    psImageInterpolateMode mode,       ///< the interpolation scheme to be used
    155     int exposedValue                   ///< Exposed value to which non-corresponding pixels are set
     155    double exposedValue                   ///< Exposed value to which non-corresponding pixels are set
    156156);
    157157
  • trunk/psLib/src/image/psImagePixelExtract.c

    r4206 r4367  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-06-10 02:30:47 $
     10 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-06-23 03:50:29 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    2424
    2525psVector* psImageSlice(psVector* out,
    26                        psVector* slicePositions,
    27                        const psImage* restrict in,
     26                       psVector* coords,
     27                       const psImage* restrict input,
    2828                       const psImage* restrict mask,
    2929                       psU32 maskVal,
     
    4444    psS32 col1 = region.x1;
    4545
    46     if (in == NULL || in->data.V == NULL) {
     46    if (input == NULL || input->data.V == NULL) {
    4747        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    4848                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    5252
    5353    if (col1 < 1) {
    54         col1 += in->numCols;
     54        col1 += input->numCols;
    5555    }
    5656
    5757    if (row1 < 1) {
    58         row1 += in->numRows;
     58        row1 += input->numRows;
    5959    }
    6060
    6161    if (    col0 < 0 ||
    6262            row0 < 0 ||
    63             col1 > in->numCols ||
    64             row1 > in->numRows ||
     63            col1 > input->numCols ||
     64            row1 > input->numRows ||
    6565            col0 >= col1 ||
    6666            row0 >= row1) {
     
    6868                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
    6969                col0, col1, row0, row1,
    70                 in->numCols, in->numRows);
    71         psFree(out);
    72         return NULL;
    73     }
    74 
    75     type = in->type.type;
    76     inRows = in->numRows;
    77     inCols = in->numCols;
     70                input->numCols, input->numRows);
     71        psFree(out);
     72        return NULL;
     73    }
     74
     75    type = input->type.type;
     76    inRows = input->numRows;
     77    inCols = input->numCols;
    7878
    7979    if (direction == PS_CUT_X_NEG || direction == PS_CUT_Y_NEG) {
     
    134134        // psStats.
    135135        out = psVectorRecycle(out, numCols, PS_TYPE_F64);
    136         if (slicePositions != NULL) {
    137             slicePositions = psVectorRecycle(slicePositions, numCols, PS_TYPE_U32);
    138             outPosition = slicePositions->data.U32;
     136        if (coords != NULL) {
     137            coords = psVectorRecycle(coords, numCols, PS_TYPE_U32);
     138            outPosition = coords->data.U32;
    139139        }
    140140        outData = out->data.F64;
     
    153153            psMaskType* maskVecData = NULL; \
    154154            for (psS32 c=col0;c<col1;c++) { \
    155                 ps##TYPE *imgData = in->data.TYPE[row0] + c; \
     155                ps##TYPE *imgData = input->data.TYPE[row0] + c; \
    156156                ps##TYPE *imgVecData = imgVec->data.TYPE; \
    157157                if (maskVec != NULL) { \
     
    213213        // fill in psVector to fake out the statistics functions.
    214214        imgVec = psAlloc(sizeof(psVector));
    215         imgVec->type = in->type;
     215        imgVec->type = input->type;
    216216        imgVec->n = *(int*)&imgVec->nalloc = numCols;
    217217        if (mask != NULL) {
     
    224224        // psStats.
    225225        out = psVectorRecycle(out, numRows, PS_TYPE_F64);
    226         if (slicePositions != NULL) {
    227             slicePositions = psVectorRecycle(slicePositions, numRows, PS_TYPE_U32);
    228             outPosition = slicePositions->data.U32;
     226        if (coords != NULL) {
     227            coords = psVectorRecycle(coords, numRows, PS_TYPE_U32);
     228            outPosition = coords->data.U32;
    229229        }
    230230        outData = out->data.F64;
     
    239239            // point the vector struct to the
    240240            // data to calculate the stats
    241             imgVec->data.U8 = (psPtr )(in->data.U8[r] + col0 * elementSize);
     241            imgVec->data.U8 = (psPtr )(input->data.U8[r] + col0 * elementSize);
    242242            if (maskVec != NULL) {
    243243                maskVec->data.U8 = (psPtr )(mask->data.U8[r] + col0 * sizeof(psMaskType));
     
    271271                     psVector* cutCols,
    272272                     psVector* cutRows,
    273                      const psImage* in,
     273                     const psImage* input,
    274274                     const psImage* mask,
    275275                     psU32 maskVal,
    276276                     psRegion region,
    277                      psU32 nSamples,
     277                     unsigned int nSamples,
    278278                     psImageInterpolateMode mode)
    279279{
    280280
    281     if (in == NULL || in->data.V == NULL) {
     281    if (input == NULL || input->data.V == NULL) {
    282282        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    283283                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    285285        return NULL;
    286286    }
    287     psS32 numCols = in->numCols;
    288     psS32 numRows = in->numRows;
     287    psS32 numCols = input->numCols;
     288    psS32 numRows = input->numRows;
    289289
    290290    if (nSamples < 2) {
     
    352352    }
    353353
    354     out = psVectorRecycle(out, nSamples, in->type.type);
     354    out = psVectorRecycle(out, nSamples, input->type.type);
    355355
    356356    float dX = (endCol - startCol) / (float)(nSamples-1);
     
    370370                cutRowsData[i] = y; \
    371371            } \
    372             outData[i] = psImagePixelInterpolate(in,x,y,mask,maskVal,0,mode); \
     372            outData[i] = psImagePixelInterpolate(input,x,y,mask,maskVal,0,mode); \
    373373        } \
    374374    } \
     
    376376
    377377
    378     switch (in->type.type) {
     378    switch (input->type.type) {
    379379        LINEAR_CUT_CASE(U8);
    380380        LINEAR_CUT_CASE(U16);
     
    392392    default: {
    393393            char* typeStr;
    394             PS_TYPE_NAME(typeStr,in->type.type);
     394            PS_TYPE_NAME(typeStr,input->type.type);
    395395            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    396396                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     
    405405
    406406psVector* psImageRadialCut(psVector* out,
    407                            const psImage* in,
     407                           const psImage* input,
    408408                           const psImage* restrict mask,
    409409                           psU32 maskVal,
    410                            float centerCol,
    411                            float centerRow,
     410                           float x,
     411                           float y,
    412412                           const psVector* radii,
    413413                           const psStats* stats)
     
    417417    /* check the parameters */
    418418
    419     if (in == NULL || in->data.V == NULL) {
     419    if (input == NULL || input->data.V == NULL) {
    420420        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    421421                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    423423        return NULL;
    424424    }
    425     psS32 numCols = in->numCols;
    426     psS32 numRows = in->numRows;
     425    psS32 numCols = input->numCols;
     426    psS32 numRows = input->numRows;
    427427
    428428    if (mask != NULL) {
     
    446446    }
    447447
    448     if (centerCol < 0 || centerCol >= numCols ||
    449             centerRow < 0 || centerRow >= numRows) {
     448    if (x < 0 || x >= numCols ||
     449            y < 0 || y >= numRows) {
    450450        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    451451                PS_ERRORTEXT_psImage_CENTER_NOT_IN_IMAGE,
    452                 centerCol, centerRow,
     452                x, y,
    453453                numCols-1, numRows-1);
    454454        psFree(out);
     
    498498    psF32* rSq = rSqVec->data.F32;
    499499
    500     psS32 startRow = centerRow - rSq[numOut];
    501     psS32 endRow = centerRow + rSq[numOut];
    502     psS32 startCol = centerCol - rSq[numOut];
    503     psS32 endCol = centerCol + rSq[numOut];
     500    psS32 startRow = y - rSq[numOut];
     501    psS32 endRow = y + rSq[numOut];
     502    psS32 startCol = x - rSq[numOut];
     503    psS32 endCol = x + rSq[numOut];
    504504
    505505    if (startRow < 0) {
     
    531531        // than the area of the region of interest.
    532532        buffer[lcv] = psVectorAlloc(1+4*(rSq[lcv+1]-rSq[lcv]),
    533                                     in->type.type);
     533                                    input->type.type);
    534534        buffer[lcv]->n = 0;
    535535
     
    546546    float dist;
    547547    for (psS32 row=startRow; row <= endRow; row++) {
    548         psF32* inRow = in->data.F32[row];
     548        psF32* inRow = input->data.F32[row];
    549549        psMaskType* maskRow = NULL;
    550550        if (mask != NULL) {
     
    552552        }
    553553        for (psS32 col=startCol; col <= endCol; col++) {
    554             dX = centerCol - (float)col - 0.5f;
    555             dY = centerRow - (float)row - 0.5f;
     554            dX = x - (float)col - 0.5f;
     555            dY = y - (float)row - 0.5f;
    556556            dist = dX*dX+dY*dY;
    557557            for (psS32 r = 0; r < numOut; r++) {
  • trunk/psLib/src/image/psImagePixelExtract.h

    r4206 r4367  
    88*  @author Robert DeSonia, MHPCC
    99*
    10 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2005-06-10 02:30:47 $
     10*  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2005-06-23 03:50:29 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    5858psVector* psImageSlice(
    5959    psVector* out,                     ///< psVector to recycle, or NULL.
    60     psVector* slicePositions,
     60    psVector* coords,
    6161    ///< If not NULL, it is populated with the coordinate in the slice dimension
    6262    ///< coorsponding to the output vector's value of the same position in the
     
    9494    psU32 maskVal,                     ///< the mask value to apply to the mask
    9595    psRegion region,                   ///< the start and end points to cut along
    96     psU32 nSamples,                    ///< the number of samples along the cut
     96    unsigned int nSamples,             ///< the number of samples along the cut
    9797    psImageInterpolateMode mode        ///< the interpolation method to use
    9898);
     
    116116    const psImage* mask,               ///< the mask for the input image.
    117117    psU32 maskVal,                     ///< the mask value to apply to the mask
    118     float centerCol,                   ///< the column of the center of the cut circle
    119     float centerRow,                   ///< the row of the center of the cut circle
     118    float x,                           ///< the column of the center of the cut circle
     119    float y,                           ///< the row of the center of the cut circle
    120120    const psVector* radii,             ///< the radii of the cut circle
    121121    const psStats* stats               ///< the statistic to perform in operation
  • trunk/psLib/src/image/psImagePixelManip.c

    r4315 r4367  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-06-18 02:30:49 $
     12 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-06-23 03:50:29 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    311311
    312312int psImageClipComplexRegion(psImage* input,
    313                              psC64 min,
    314                              psC64 vmin,
    315                              psC64 max,
    316                              psC64 vmax)
     313                             _Complex min,
     314                             _Complex vmin,
     315                             _Complex max,
     316                             _Complex vmax)
    317317{
    318318    psS32 numClipped = 0;
  • trunk/psLib/src/image/psImagePixelManip.h

    r4330 r4367  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-06-21 03:01:37 $
     10 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-06-23 03:50:29 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    4747 *  This function is defined for psC32, and psC64 imagery only.
    4848 *
    49  *  @return psS32     The number of clipped pixels
     49 *  @return int     The number of clipped pixels
    5050 */
    5151int psImageClipComplexRegion(
    5252    psImage* input,                    ///< the image to clip
    53     psC64 min,                         ///< the minimum image value allowed
    54     psC64 vmin,                        ///< the value pixels < min are set to
    55     psC64 max,                         ///< the maximum image value allowed
    56     psC64 vmax                         ///< the value pixels > max are set to
     53    _Complex min,                      ///< the minimum image value allowed
     54    _Complex vmin,                     ///< the value pixels < min are set to
     55    _Complex max,                      ///< the maximum image value allowed
     56    _Complex vmax                      ///< the value pixels > max are set to
    5757);
    5858
  • trunk/psLib/src/imageops/psImageGeomManip.c

    r4316 r4367  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-06-18 03:13:02 $
     12 *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-06-23 03:50:29 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    3636                      const psImage* restrict mask,
    3737                      psMaskType maskVal,
    38                       psU32 scale,
     38                      int scale,
    3939                      const psStats* stats)
    4040{
     
    303303
    304304psImage* psImageRotate(psImage* out,
    305                        const psImage* in,
     305                       const psImage* input,
    306306                       float angle,
    307                        psC64 unexposedValue,
     307                       _Complex exposed,
    308308                       psImageInterpolateMode mode)
    309309{
    310     if (in == NULL) {
     310    if (input == NULL) {
    311311        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    312312                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    319319    if (fabsf(angle - M_PI_2) < FLT_EPSILON) {
    320320        // perform 1/4 rotate counter-clockwise
    321         psS32 numRows = in->numCols;
    322         psS32 numCols = in->numRows;
     321        psS32 numRows = input->numCols;
     322        psS32 numCols = input->numRows;
    323323        psS32 lastCol = numCols - 1;
    324         psElemType type = in->type.type;
     324        psElemType type = input->type.type;
    325325
    326326        out = psImageRecycle(out, numCols, numRows, type);
     
    328328        #define PSIMAGE_ROTATE_LEFT_90(TYPE) \
    329329    case PS_TYPE_##TYPE: { \
    330             ps##TYPE** inData = in->data.TYPE; \
     330            ps##TYPE** inData = input->data.TYPE; \
    331331            for (psS32 row=0;row<numRows;row++) { \
    332332                ps##TYPE* outRow = out->data.TYPE[row]; \
     
    364364    } else if (fabsf(angle - M_PI) < FLT_EPSILON) {
    365365        // perform 1/2 rotate
    366         psS32 numRows = in->numRows;
     366        psS32 numRows = input->numRows;
    367367        psS32 lastRow = numRows - 1;
    368         psS32 numCols = in->numCols;
     368        psS32 numCols = input->numCols;
    369369        psS32 lastCol = numCols - 1;
    370         psElemType type = in->type.type;
     370        psElemType type = input->type.type;
    371371
    372372        out = psImageRecycle(out, numCols, numRows, type);
     
    376376            for (psS32 row=0;row<numRows;row++) { \
    377377                ps##TYPE* outRow = out->data.TYPE[row]; \
    378                 ps##TYPE* inRow = in->data.TYPE[lastRow-row]; \
     378                ps##TYPE* inRow = input->data.TYPE[lastRow-row]; \
    379379                for (psS32 col=0;col<numCols;col++) { \
    380380                    outRow[col] = inRow[lastCol - col]; \
     
    410410    } else if (fabsf(angle - (M_PI+M_PI_2)) < FLT_EPSILON) {
    411411        // perform 1/4 rotate clockwise
    412         psS32 numRows = in->numCols;
     412        psS32 numRows = input->numCols;
    413413        psS32 lastRow = numRows - 1;
    414         psS32 numCols = in->numRows;
    415         psElemType type = in->type.type;
     414        psS32 numCols = input->numRows;
     415        psElemType type = input->type.type;
    416416
    417417        out = psImageRecycle(out, numCols, numRows, type);
     
    419419        #define PSIMAGE_ROTATE_RIGHT_90(TYPE) \
    420420    case PS_TYPE_##TYPE: { \
    421             ps##TYPE** inData = in->data.TYPE; \
     421            ps##TYPE** inData = input->data.TYPE; \
    422422            for (psS32 row=0;row<numRows;row++) { \
    423423                ps##TYPE* outRow = out->data.TYPE[row]; \
     
    454454        }
    455455    } else if (fabsf(angle) < FLT_EPSILON) {
    456         out = psImageCopy(out, in, in->type.type);
     456        out = psImageCopy(out, input, input->type.type);
    457457    } else {
    458         psElemType type = in->type.type;
    459         psS32 numRows = in->numRows;
    460         psS32 numCols = in->numCols;
     458        psElemType type = input->type.type;
     459        psS32 numRows = input->numRows;
     460        psS32 numCols = input->numCols;
    461461        float centerX = (float)(numCols) / 2.0f;
    462462        float centerY = (float)(numRows) / 2.0f;
     
    497497
    498498        #define PSIMAGE_ROTATE_ARBITRARY_LOOP(TYPE,MODE) { \
    499             if (creal(unexposedValue) < PS_MIN_##TYPE || \
    500                     creal(unexposedValue) > PS_MAX_##TYPE || \
    501                     cimag(unexposedValue) < PS_MIN_##TYPE || \
    502                     cimag(unexposedValue) > PS_MAX_##TYPE) { \
     499            if (creal(exposed) < PS_MIN_##TYPE || \
     500                    creal(exposed) > PS_MAX_##TYPE || \
     501                    cimag(exposed) < PS_MIN_##TYPE || \
     502                    cimag(exposed) > PS_MAX_##TYPE) { \
    503503                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    504504                        PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
    505                         "unexposedValue", \
    506                         creal(unexposedValue),cimag(unexposedValue), \
     505                        "exposed", \
     506                        creal(exposed),cimag(exposed), \
    507507                        PS_TYPE_##TYPE##_NAME,  \
    508508                        (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
     
    519519                outRow = out->data.TYPE[y]; \
    520520                for (psS32 x = 0; x < outCols; x++) { \
    521                     outRow[x] = p_psImagePixelInterpolate##MODE##_##TYPE(in,inX,inY,NULL,0,unexposedValue); \
     521                    outRow[x] = p_psImagePixelInterpolate##MODE##_##TYPE(input,inX,inY,NULL,0,exposed); \
    522522                    inX += cosT; \
    523523                    inY -= sinT; \
     
    594594
    595595psImage* psImageShift(psImage* out,
    596                       const psImage* in,
     596                      const psImage* input,
    597597                      float dx,
    598598                      float dy,
    599                       psC64 unexposedValue,
     599                      _Complex exposed,
    600600                      psImageInterpolateMode mode)
    601601{
     
    605605    psElemType type;
    606606
    607     if (in == NULL) {
     607    if (input == NULL) {
    608608        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    609609                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    613613    // create an output image of the same size
    614614    // and type
    615     outRows = in->numRows;
    616     outCols = in->numCols;
    617     type = in->type.type;
     615    outRows = input->numRows;
     616    outCols = input->numCols;
     617    type = input->type.type;
    618618    elementSize = PSELEMTYPE_SIZEOF(type);
    619619    out = psImageRecycle(out, outCols, outRows, type);
     
    621621    #define PSIMAGE_SHIFT_CASE(MODE,TYPE) \
    622622case PS_TYPE_##TYPE: \
    623     if (creal(unexposedValue) < PS_MIN_##TYPE || \
    624             creal(unexposedValue) > PS_MAX_##TYPE || \
    625             cimag(unexposedValue) < PS_MIN_##TYPE || \
    626             cimag(unexposedValue) > PS_MAX_##TYPE) { \
     623    if (creal(exposed) < PS_MIN_##TYPE || \
     624            creal(exposed) > PS_MAX_##TYPE || \
     625            cimag(exposed) < PS_MIN_##TYPE || \
     626            cimag(exposed) > PS_MAX_##TYPE) { \
    627627        psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    628628                PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
    629                 "unexposedValue", \
    630                 creal(unexposedValue),cimag(unexposedValue), \
     629                "exposed", \
     630                creal(exposed),cimag(exposed), \
    631631                PS_TYPE_##TYPE##_NAME,  \
    632632                (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
     
    640640        for (psS32 col=0;col<outCols;col++) { \
    641641            outRow[col] = p_psImagePixelInterpolate##MODE##_##TYPE( \
    642                           in,dx+(float)col,y,NULL,0,unexposedValue); \
     642                          input,dx+(float)col,y,NULL,0,exposed); \
    643643        } \
    644644    } \
     
    647647    #define PSIMAGE_SHIFT_ARBITRARY_CASE(MODE) \
    648648case PS_INTERPOLATE_##MODE: \
    649     switch (in->type.type) { \
     649    switch (input->type.type) { \
    650650        PSIMAGE_SHIFT_CASE(MODE,U8);  \
    651651        PSIMAGE_SHIFT_CASE(MODE,U16); \
     
    694694                          int inputMaskVal,
    695695                          const psPlaneTransform *outToIn,
    696                           const psRegion region,
     696                          psRegion region,
    697697                          const psPixels* pixels,
    698698                          psImageInterpolateMode mode,
    699                           int exposedValue)
     699                          double exposedValue)
    700700{
    701701    if (input == NULL) {
  • trunk/psLib/src/imageops/psImageGeomManip.h

    r4316 r4367  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-06-18 03:13:02 $
     10 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-06-23 03:50:29 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    3939    const psImage* mask,               ///< mask for input image.  If NULL, no masking is done.
    4040    psMaskType maskVal,                ///< the bits to check in mask.
    41     psU32 scale,                       ///< the scale to rebin for each dimension
     41    int scale,                         ///< the scale to rebin for each dimension
    4242    const psStats* stats
    4343    ///< the statistic to perform when rebinning.  Only one method should be set.
     
    7575psImage* psImageRotate(
    7676    psImage* out,                      ///< an psImage to recycle.  If NULL, a new image is created
    77     const psImage* in,                 ///< input image
     77    const psImage* input,              ///< input image
    7878    float angle,                       ///< the rotation angle in radians.
    79     psC64 unexposedValue,              ///< the output image pixel values for non-imagery areas
     79    _Complex exposed,                  ///< the output image pixel values for non-imagery areas
    8080    psImageInterpolateMode mode        ///< the interpolation mode used
    8181);
     
    9494psImage* psImageShift(
    9595    psImage* out,                      ///< an psImage to recycle.  If NULL, a new image is created
    96     const psImage* in,                 ///< input image
     96    const psImage* input,              ///< input image
    9797    float dx,                          ///< the shift in x direction.
    9898    float dy,                          ///< the shift in y direction.
    99     psC64 unexposedValue,              ///< the output image pixel values for non-imagery areas
     99    _Complex exposed,                  ///< the output image pixel values for non-imagery areas
    100100    psImageInterpolateMode mode        ///< the interpolation mode to use
    101101);
     
    149149    int inputMaskVal,                  ///< masking value for inputMask
    150150    const psPlaneTransform *outToIn,   ///< the transform to apply
    151     const psRegion region,             ///< the size of the transformed image
     151    psRegion region,                   ///< the size of the transformed image
    152152    const psPixels* pixels,            /**< if not NULL, consists of psPixelCoords and specifies which pixels in
    153                                                      *  output image shall be transformed; otherwise, entire image generated*/
     153                                                         *  output image shall be transformed; otherwise, entire image generated*/
    154154    psImageInterpolateMode mode,       ///< the interpolation scheme to be used
    155     int exposedValue                   ///< Exposed value to which non-corresponding pixels are set
     155    double exposedValue                   ///< Exposed value to which non-corresponding pixels are set
    156156);
    157157
  • trunk/psLib/src/imageops/psImagePixelExtract.c

    r4206 r4367  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-06-10 02:30:47 $
     10 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-06-23 03:50:29 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    2424
    2525psVector* psImageSlice(psVector* out,
    26                        psVector* slicePositions,
    27                        const psImage* restrict in,
     26                       psVector* coords,
     27                       const psImage* restrict input,
    2828                       const psImage* restrict mask,
    2929                       psU32 maskVal,
     
    4444    psS32 col1 = region.x1;
    4545
    46     if (in == NULL || in->data.V == NULL) {
     46    if (input == NULL || input->data.V == NULL) {
    4747        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    4848                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    5252
    5353    if (col1 < 1) {
    54         col1 += in->numCols;
     54        col1 += input->numCols;
    5555    }
    5656
    5757    if (row1 < 1) {
    58         row1 += in->numRows;
     58        row1 += input->numRows;
    5959    }
    6060
    6161    if (    col0 < 0 ||
    6262            row0 < 0 ||
    63             col1 > in->numCols ||
    64             row1 > in->numRows ||
     63            col1 > input->numCols ||
     64            row1 > input->numRows ||
    6565            col0 >= col1 ||
    6666            row0 >= row1) {
     
    6868                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
    6969                col0, col1, row0, row1,
    70                 in->numCols, in->numRows);
    71         psFree(out);
    72         return NULL;
    73     }
    74 
    75     type = in->type.type;
    76     inRows = in->numRows;
    77     inCols = in->numCols;
     70                input->numCols, input->numRows);
     71        psFree(out);
     72        return NULL;
     73    }
     74
     75    type = input->type.type;
     76    inRows = input->numRows;
     77    inCols = input->numCols;
    7878
    7979    if (direction == PS_CUT_X_NEG || direction == PS_CUT_Y_NEG) {
     
    134134        // psStats.
    135135        out = psVectorRecycle(out, numCols, PS_TYPE_F64);
    136         if (slicePositions != NULL) {
    137             slicePositions = psVectorRecycle(slicePositions, numCols, PS_TYPE_U32);
    138             outPosition = slicePositions->data.U32;
     136        if (coords != NULL) {
     137            coords = psVectorRecycle(coords, numCols, PS_TYPE_U32);
     138            outPosition = coords->data.U32;
    139139        }
    140140        outData = out->data.F64;
     
    153153            psMaskType* maskVecData = NULL; \
    154154            for (psS32 c=col0;c<col1;c++) { \
    155                 ps##TYPE *imgData = in->data.TYPE[row0] + c; \
     155                ps##TYPE *imgData = input->data.TYPE[row0] + c; \
    156156                ps##TYPE *imgVecData = imgVec->data.TYPE; \
    157157                if (maskVec != NULL) { \
     
    213213        // fill in psVector to fake out the statistics functions.
    214214        imgVec = psAlloc(sizeof(psVector));
    215         imgVec->type = in->type;
     215        imgVec->type = input->type;
    216216        imgVec->n = *(int*)&imgVec->nalloc = numCols;
    217217        if (mask != NULL) {
     
    224224        // psStats.
    225225        out = psVectorRecycle(out, numRows, PS_TYPE_F64);
    226         if (slicePositions != NULL) {
    227             slicePositions = psVectorRecycle(slicePositions, numRows, PS_TYPE_U32);
    228             outPosition = slicePositions->data.U32;
     226        if (coords != NULL) {
     227            coords = psVectorRecycle(coords, numRows, PS_TYPE_U32);
     228            outPosition = coords->data.U32;
    229229        }
    230230        outData = out->data.F64;
     
    239239            // point the vector struct to the
    240240            // data to calculate the stats
    241             imgVec->data.U8 = (psPtr )(in->data.U8[r] + col0 * elementSize);
     241            imgVec->data.U8 = (psPtr )(input->data.U8[r] + col0 * elementSize);
    242242            if (maskVec != NULL) {
    243243                maskVec->data.U8 = (psPtr )(mask->data.U8[r] + col0 * sizeof(psMaskType));
     
    271271                     psVector* cutCols,
    272272                     psVector* cutRows,
    273                      const psImage* in,
     273                     const psImage* input,
    274274                     const psImage* mask,
    275275                     psU32 maskVal,
    276276                     psRegion region,
    277                      psU32 nSamples,
     277                     unsigned int nSamples,
    278278                     psImageInterpolateMode mode)
    279279{
    280280
    281     if (in == NULL || in->data.V == NULL) {
     281    if (input == NULL || input->data.V == NULL) {
    282282        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    283283                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    285285        return NULL;
    286286    }
    287     psS32 numCols = in->numCols;
    288     psS32 numRows = in->numRows;
     287    psS32 numCols = input->numCols;
     288    psS32 numRows = input->numRows;
    289289
    290290    if (nSamples < 2) {
     
    352352    }
    353353
    354     out = psVectorRecycle(out, nSamples, in->type.type);
     354    out = psVectorRecycle(out, nSamples, input->type.type);
    355355
    356356    float dX = (endCol - startCol) / (float)(nSamples-1);
     
    370370                cutRowsData[i] = y; \
    371371            } \
    372             outData[i] = psImagePixelInterpolate(in,x,y,mask,maskVal,0,mode); \
     372            outData[i] = psImagePixelInterpolate(input,x,y,mask,maskVal,0,mode); \
    373373        } \
    374374    } \
     
    376376
    377377
    378     switch (in->type.type) {
     378    switch (input->type.type) {
    379379        LINEAR_CUT_CASE(U8);
    380380        LINEAR_CUT_CASE(U16);
     
    392392    default: {
    393393            char* typeStr;
    394             PS_TYPE_NAME(typeStr,in->type.type);
     394            PS_TYPE_NAME(typeStr,input->type.type);
    395395            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    396396                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     
    405405
    406406psVector* psImageRadialCut(psVector* out,
    407                            const psImage* in,
     407                           const psImage* input,
    408408                           const psImage* restrict mask,
    409409                           psU32 maskVal,
    410                            float centerCol,
    411                            float centerRow,
     410                           float x,
     411                           float y,
    412412                           const psVector* radii,
    413413                           const psStats* stats)
     
    417417    /* check the parameters */
    418418
    419     if (in == NULL || in->data.V == NULL) {
     419    if (input == NULL || input->data.V == NULL) {
    420420        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    421421                PS_ERRORTEXT_psImage_IMAGE_NULL);
     
    423423        return NULL;
    424424    }
    425     psS32 numCols = in->numCols;
    426     psS32 numRows = in->numRows;
     425    psS32 numCols = input->numCols;
     426    psS32 numRows = input->numRows;
    427427
    428428    if (mask != NULL) {
     
    446446    }
    447447
    448     if (centerCol < 0 || centerCol >= numCols ||
    449             centerRow < 0 || centerRow >= numRows) {
     448    if (x < 0 || x >= numCols ||
     449            y < 0 || y >= numRows) {
    450450        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    451451                PS_ERRORTEXT_psImage_CENTER_NOT_IN_IMAGE,
    452                 centerCol, centerRow,
     452                x, y,
    453453                numCols-1, numRows-1);
    454454        psFree(out);
     
    498498    psF32* rSq = rSqVec->data.F32;
    499499
    500     psS32 startRow = centerRow - rSq[numOut];
    501     psS32 endRow = centerRow + rSq[numOut];
    502     psS32 startCol = centerCol - rSq[numOut];
    503     psS32 endCol = centerCol + rSq[numOut];
     500    psS32 startRow = y - rSq[numOut];
     501    psS32 endRow = y + rSq[numOut];
     502    psS32 startCol = x - rSq[numOut];
     503    psS32 endCol = x + rSq[numOut];
    504504
    505505    if (startRow < 0) {
     
    531531        // than the area of the region of interest.
    532532        buffer[lcv] = psVectorAlloc(1+4*(rSq[lcv+1]-rSq[lcv]),
    533                                     in->type.type);
     533                                    input->type.type);
    534534        buffer[lcv]->n = 0;
    535535
     
    546546    float dist;
    547547    for (psS32 row=startRow; row <= endRow; row++) {
    548         psF32* inRow = in->data.F32[row];
     548        psF32* inRow = input->data.F32[row];
    549549        psMaskType* maskRow = NULL;
    550550        if (mask != NULL) {
     
    552552        }
    553553        for (psS32 col=startCol; col <= endCol; col++) {
    554             dX = centerCol - (float)col - 0.5f;
    555             dY = centerRow - (float)row - 0.5f;
     554            dX = x - (float)col - 0.5f;
     555            dY = y - (float)row - 0.5f;
    556556            dist = dX*dX+dY*dY;
    557557            for (psS32 r = 0; r < numOut; r++) {
  • trunk/psLib/src/imageops/psImagePixelExtract.h

    r4206 r4367  
    88*  @author Robert DeSonia, MHPCC
    99*
    10 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2005-06-10 02:30:47 $
     10*  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2005-06-23 03:50:29 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    5858psVector* psImageSlice(
    5959    psVector* out,                     ///< psVector to recycle, or NULL.
    60     psVector* slicePositions,
     60    psVector* coords,
    6161    ///< If not NULL, it is populated with the coordinate in the slice dimension
    6262    ///< coorsponding to the output vector's value of the same position in the
     
    9494    psU32 maskVal,                     ///< the mask value to apply to the mask
    9595    psRegion region,                   ///< the start and end points to cut along
    96     psU32 nSamples,                    ///< the number of samples along the cut
     96    unsigned int nSamples,             ///< the number of samples along the cut
    9797    psImageInterpolateMode mode        ///< the interpolation method to use
    9898);
     
    116116    const psImage* mask,               ///< the mask for the input image.
    117117    psU32 maskVal,                     ///< the mask value to apply to the mask
    118     float centerCol,                   ///< the column of the center of the cut circle
    119     float centerRow,                   ///< the row of the center of the cut circle
     118    float x,                           ///< the column of the center of the cut circle
     119    float y,                           ///< the row of the center of the cut circle
    120120    const psVector* radii,             ///< the radii of the cut circle
    121121    const psStats* stats               ///< the statistic to perform in operation
  • trunk/psLib/src/imageops/psImagePixelManip.c

    r4315 r4367  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-06-18 02:30:49 $
     12 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-06-23 03:50:29 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    311311
    312312int psImageClipComplexRegion(psImage* input,
    313                              psC64 min,
    314                              psC64 vmin,
    315                              psC64 max,
    316                              psC64 vmax)
     313                             _Complex min,
     314                             _Complex vmin,
     315                             _Complex max,
     316                             _Complex vmax)
    317317{
    318318    psS32 numClipped = 0;
  • trunk/psLib/src/imageops/psImagePixelManip.h

    r4330 r4367  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-06-21 03:01:37 $
     10 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-06-23 03:50:29 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    4747 *  This function is defined for psC32, and psC64 imagery only.
    4848 *
    49  *  @return psS32     The number of clipped pixels
     49 *  @return int     The number of clipped pixels
    5050 */
    5151int psImageClipComplexRegion(
    5252    psImage* input,                    ///< the image to clip
    53     psC64 min,                         ///< the minimum image value allowed
    54     psC64 vmin,                        ///< the value pixels < min are set to
    55     psC64 max,                         ///< the maximum image value allowed
    56     psC64 vmax                         ///< the value pixels > max are set to
     53    _Complex min,                      ///< the minimum image value allowed
     54    _Complex vmin,                     ///< the value pixels < min are set to
     55    _Complex max,                      ///< the maximum image value allowed
     56    _Complex vmax                      ///< the value pixels > max are set to
    5757);
    5858
  • trunk/psLib/src/math/psCompare.h

    r4162 r4367  
    66 *  @ingroup Compare
    77 *
    8  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-06-08 23:40:45 $
     8 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-06-23 03:50:29 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    2828 *                   than, equal to, or greater than the second.
    2929 */
    30 typedef int (*psComparePtrFcn) (
     30typedef int (*psComparePtrFunc) (
    3131    const void **a,                    ///< first comparison target
    3232    const void **b                     ///< second comparison target
  • trunk/psLib/src/sys/psLogMsg.c

    r4321 r4367  
    1212 *  @author GLG, MHPCC
    1313 *
    14  *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-06-20 22:42:30 $
     14 *  @version $Revision: 1.47 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2005-06-23 03:50:29 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    8787 An psBool: TRUE if successful.
    8888 *****************************************************************************/
    89 psBool psLogSetDestination(const char *dest)
     89bool psLogSetDestination(const char *dest)
    9090{
    9191    char protocol[5];
     
    163163    NULL.
    164164 *****************************************************************************/
    165 void psLogSetFormat(const char *fmt)
     165void psLogSetFormat(const char *format)
    166166{
    167167    // assume none.
     
    173173
    174174    // if fmt is NULL, no logging is desired.
    175     if (fmt == NULL) {
     175    if (format == NULL) {
    176176        return;
    177177    }
    178178
    179179    // XXX: What is the purpose of this conditional.
    180     if (strlen(fmt) == 0) {
    181         fmt = "THLNM";
     180    if (strlen(format) == 0) {
     181        format = "THLNM";
    182182    }
    183183    // Step through each character in the format string.  For each letter
    184184    // in that string, set the appropriate logging.
    185185
    186     for (const char *ptr = fmt; *ptr != '\0'; ptr++) {
     186    for (const char *ptr = format; *ptr != '\0'; ptr++) {
    187187        switch (*ptr) {
    188188        case 'H':
     
    215215    // XXX: If one must at least log error messages, why don't we set logMsg = true here?
    216216    if (!logMsg) {
    217         psTrace("utils.logMsg", 1, "You must at least log error messages (You chose \"%s\")", fmt);
     217        psTrace("utils.logMsg", 1, "You must at least log error messages (You chose \"%s\")", format);
    218218    }
    219219}
  • trunk/psLib/src/sys/psLogMsg.h

    r4330 r4367  
    1111 *  @author GLG, MHPCC
    1212 *
    13  *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2005-06-21 03:01:37 $
     13 *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2005-06-23 03:50:29 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    3030 *  argument which can specify general log destinations.
    3131 *
    32  *  @return psS32     true if set successfully, otherwise false.
     32 *  @return bool     true if set successfully, otherwise false.
    3333 */
    34 psBool psLogSetDestination(
     34bool psLogSetDestination(
    3535    const char *dest                   ///< Specifies where to send messages.
    3636);
     
    5656 */
    5757void psLogSetFormat(
    58     const char *fmt                    ///< Specifies the system log format
     58    const char *format                 ///< Specifies the system log format
    5959);
    6060
  • trunk/psLib/src/sysUtils/psLogMsg.c

    r4321 r4367  
    1212 *  @author GLG, MHPCC
    1313 *
    14  *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-06-20 22:42:30 $
     14 *  @version $Revision: 1.47 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2005-06-23 03:50:29 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    8787 An psBool: TRUE if successful.
    8888 *****************************************************************************/
    89 psBool psLogSetDestination(const char *dest)
     89bool psLogSetDestination(const char *dest)
    9090{
    9191    char protocol[5];
     
    163163    NULL.
    164164 *****************************************************************************/
    165 void psLogSetFormat(const char *fmt)
     165void psLogSetFormat(const char *format)
    166166{
    167167    // assume none.
     
    173173
    174174    // if fmt is NULL, no logging is desired.
    175     if (fmt == NULL) {
     175    if (format == NULL) {
    176176        return;
    177177    }
    178178
    179179    // XXX: What is the purpose of this conditional.
    180     if (strlen(fmt) == 0) {
    181         fmt = "THLNM";
     180    if (strlen(format) == 0) {
     181        format = "THLNM";
    182182    }
    183183    // Step through each character in the format string.  For each letter
    184184    // in that string, set the appropriate logging.
    185185
    186     for (const char *ptr = fmt; *ptr != '\0'; ptr++) {
     186    for (const char *ptr = format; *ptr != '\0'; ptr++) {
    187187        switch (*ptr) {
    188188        case 'H':
     
    215215    // XXX: If one must at least log error messages, why don't we set logMsg = true here?
    216216    if (!logMsg) {
    217         psTrace("utils.logMsg", 1, "You must at least log error messages (You chose \"%s\")", fmt);
     217        psTrace("utils.logMsg", 1, "You must at least log error messages (You chose \"%s\")", format);
    218218    }
    219219}
  • trunk/psLib/src/sysUtils/psLogMsg.h

    r4330 r4367  
    1111 *  @author GLG, MHPCC
    1212 *
    13  *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2005-06-21 03:01:37 $
     13 *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2005-06-23 03:50:29 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    3030 *  argument which can specify general log destinations.
    3131 *
    32  *  @return psS32     true if set successfully, otherwise false.
     32 *  @return bool     true if set successfully, otherwise false.
    3333 */
    34 psBool psLogSetDestination(
     34bool psLogSetDestination(
    3535    const char *dest                   ///< Specifies where to send messages.
    3636);
     
    5656 */
    5757void psLogSetFormat(
    58     const char *fmt                    ///< Specifies the system log format
     58    const char *format                 ///< Specifies the system log format
    5959);
    6060
  • trunk/psLib/src/types/psArray.c

    r4342 r4367  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-06-22 02:05:41 $
     11 *  @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-06-23 03:50:29 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    147147}
    148148
    149 psArray* psArraySort(psArray* array, psComparePtrFcn func)
     149psArray* psArraySort(psArray* array, psComparePtrFunc func)
    150150{
    151151    if (array == NULL) {
  • trunk/psLib/src/types/psArray.h

    r4342 r4367  
    1212 *  @author Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-06-22 02:05:41 $
     14 *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2005-06-23 03:50:29 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    123123psArray* psArraySort(
    124124    psArray* array,                       ///< input array to sort.
    125     psComparePtrFcn func                  ///< the compare function
     125    psComparePtrFunc func                 ///< the compare function
    126126);
    127127
  • trunk/psLib/src/types/psList.c

    r4316 r4367  
    66 *  @author Robert Daniel DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-06-18 03:13:01 $
     8 *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-06-23 03:50:29 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    610610}
    611611
    612 psList* psListSort(psList* list, psComparePtrFcn compare)
     612psList* psListSort(psList* list, psComparePtrFunc func)
    613613{
    614614    psArray* arr;
     
    622622    psFree(list);
    623623
    624     arr = psArraySort(arr, compare);
     624    arr = psArraySort(arr, func);
    625625
    626626    // convert back to linked list
  • trunk/psLib/src/types/psList.h

    r4330 r4367  
    77 *  @ingroup LinkedList
    88 *
    9  *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-06-21 03:01:37 $
     9 *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2005-06-23 03:50:29 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    9999psListIterator* psListIteratorAlloc(
    100100    psList* list,                      ///< the psList to iterate with
    101     long location,                      ///< the initial starting point.
     101    long location,                     ///< the initial starting point.
    102102    ///<  This can be a numeric index, PS_LIST_HEAD, or PS_LIST_TAIL.
    103103    bool mutable                       ///< Is it permissible to modify list?
     
    221221psList* psListSort(
    222222    psList* list,                      ///< the list to sort
    223     psComparePtrFcn compare            ///< the comparison function
     223    psComparePtrFunc func              ///< the comparison function
    224224);
    225225
Note: See TracChangeset for help on using the changeset viewer.