IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2067


Ignore:
Timestamp:
Oct 12, 2004, 2:10:50 PM (22 years ago)
Author:
desonia
Message:

adjusted the reference count increment so that psFPA assumes ownership
of psChips, psChips assumes ownership of psCells, etc.

Location:
trunk/psLib
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/astronomy/psAstrometry.c

    r2061 r2067  
    88 *  @author George Gusciora, MHPCC
    99 *
    10  *  @version $Revision: 1.36 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2004-10-12 21:10:41 $
     10 *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2004-10-13 00:10:50 $
    1212 *
    1313 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    151151    if (chip != NULL) {
    152152        psFree(chip->cells);
    153         psFree(chip->parent);
    154153        psFree(chip->metadata);
    155154        psFree(chip->toFPA);
    … …  
    167166        psFree(cell->toFPA);
    168167        psFree(cell->toTP);
    169         psFree(cell->parent);
    170168    }
    171169}
    … …  
    174172{
    175173    if (readout != NULL) {
    176         psFree(readout->image);
    177174        psFree(readout->mask);
    178175        psFree(readout->objects);
    … …  
    407404    chip->fromFPA = NULL;
    408405
    409     chip->parent = psMemIncrRefCounter(parentFPA);
     406    chip->parent = parentFPA;
    410407
    411408    p_psMemSetDeallocator(chip,(psFreeFcn)chipFree);
    … …  
    437434    cell->toTP = NULL;
    438435
    439     cell->parent = psMemIncrRefCounter(parentChip);
     436    cell->parent = parentChip;
    440437
    441438    p_psMemSetDeallocator(cell,(psFreeFcn)cellFree);
    … …  
    457454    *(int*)&readout->row0 = row0;
    458455
    459     readout->image = psMemIncrRefCounter((psImage*)image);
     456    readout->image = (psImage*)image;
    460457    readout->mask = NULL;
    461458    readout->objects = NULL;

  • trunk/psLib/src/image/psImage.c

    r1933 r2067  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2004-09-30 18:54:42 $
     12 *  @version $Revision: 1.49 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2004-10-13 00:10:50 $
    1414 *
    1515 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    162162
    163163    return old;
     164}
     165
     166psImage* psImageCopy(psImage* restrict output,
     167                     const psImage* input,
     168                     psElemType type)
     169{
     170    psElemType inDatatype;
     171    int elementSize;
     172    int elements;
     173    int numRows;
     174    int numCols;
     175
     176    if (input == NULL || input->data.V == NULL) {
     177        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     178                   PS_ERR_BAD_PARAMETER_NULL, true,
     179                   PS_ERRORTEXT_psImage_IMAGE_NULL);
     180        psFree(output);
     181        return NULL;
     182    }
     183
     184    if (input == output) {
     185        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     186                   PS_ERR_BAD_PARAMETER_NULL, true,
     187                   PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
     188        psFree(output);
     189        return NULL;
     190    }
     191
     192    if (input->type.dimen != PS_DIMEN_IMAGE) {
     193        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     194                   PS_ERR_BAD_PARAMETER_TYPE, true,
     195                   PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
     196        psFree(output);
     197        return NULL;
     198    }
     199
     200    inDatatype = input->type.type;
     201    numRows = input->numRows;
     202    numCols = input->numCols;
     203    elements = numRows * numCols;
     204    elementSize = PSELEMTYPE_SIZEOF(inDatatype);
     205
     206    if (inDatatype == PS_TYPE_PTR || type == PS_TYPE_PTR) {
     207        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     208                   PS_ERR_BAD_PARAMETER_TYPE, true,
     209                   PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     210                   PS_TYPE_PTR_NAME);
     211        psFree(output);
     212        return NULL;
     213    }
     214
     215    output = psImageRecycle(output, numCols, numRows, type);
     216
     217    // cover the trival case of copy of the same
     218    // datatype.
     219    if (type == inDatatype) {
     220        for (int row=0;row<numRows;row++) {
     221            memcpy(output->data.V[row], input->data.V[row], elementSize * numCols);
     222        }
     223        return output;
     224    }
     225
     226    #define PSIMAGE_ELEMENT_COPY(IN,INTYPE,OUT,OUTTYPE,ELEMENTS) { \
     227        ps##INTYPE *in; \
     228        ps##OUTTYPE *out; \
     229        for(int row=0;row<numRows;row++) { \
     230            in = IN->data.INTYPE[row]; \
     231            out = OUT->data.OUTTYPE[row]; \
     232            for (int col=0;col<numCols;col++) { \
     233                *(out++) = *(in++); \
     234            } \
     235        } \
     236    }
     237
     238    #define PSIMAGE_COPY_CASE(OUT,OUTTYPE) { \
     239        switch (inDatatype) { \
     240        case PS_TYPE_S8: \
     241            PSIMAGE_ELEMENT_COPY(input,S8,OUT,OUTTYPE,elements); \
     242            break; \
     243        case PS_TYPE_S16: \
     244            PSIMAGE_ELEMENT_COPY(input,S16,OUT,OUTTYPE,elements); \
     245            break; \
     246        case PS_TYPE_S32: \
     247            PSIMAGE_ELEMENT_COPY(input,S32,OUT,OUTTYPE,elements); \
     248            break; \
     249        case PS_TYPE_S64: \
     250            PSIMAGE_ELEMENT_COPY(input,S64,OUT,OUTTYPE,elements); \
     251            break; \
     252        case PS_TYPE_U8: \
     253            PSIMAGE_ELEMENT_COPY(input,U8,OUT,OUTTYPE,elements); \
     254            break; \
     255        case PS_TYPE_U16: \
     256            PSIMAGE_ELEMENT_COPY(input,U16,OUT,OUTTYPE,elements); \
     257            break; \
     258        case PS_TYPE_U32: \
     259            PSIMAGE_ELEMENT_COPY(input,U32,OUT,OUTTYPE,elements); \
     260            break; \
     261        case PS_TYPE_U64: \
     262            PSIMAGE_ELEMENT_COPY(input,U64,OUT,OUTTYPE,elements); \
     263            break; \
     264        case PS_TYPE_F32: \
     265            PSIMAGE_ELEMENT_COPY(input,F32,OUT,OUTTYPE,elements); \
     266            break; \
     267        case PS_TYPE_F64: \
     268            PSIMAGE_ELEMENT_COPY(input,F64,OUT,OUTTYPE,elements); \
     269            break; \
     270        case PS_TYPE_C32: \
     271            PSIMAGE_ELEMENT_COPY(input,C32,OUT,OUTTYPE,elements); \
     272            break; \
     273        case PS_TYPE_C64: \
     274            PSIMAGE_ELEMENT_COPY(input,C64,OUT,OUTTYPE,elements); \
     275            break; \
     276        default: \
     277            break; \
     278        } \
     279    }
     280
     281    switch (type) {
     282    case PS_TYPE_S8:
     283        PSIMAGE_COPY_CASE(output, S8);
     284        break;
     285    case PS_TYPE_S16:
     286        PSIMAGE_COPY_CASE(output, S16);
     287        break;
     288    case PS_TYPE_S32:
     289        PSIMAGE_COPY_CASE(output, S32);
     290        break;
     291    case PS_TYPE_S64:
     292        PSIMAGE_COPY_CASE(output, S64);
     293        break;
     294    case PS_TYPE_U8:
     295        PSIMAGE_COPY_CASE(output, U8);
     296        break;
     297    case PS_TYPE_U16:
     298        PSIMAGE_COPY_CASE(output, U16);
     299        break;
     300    case PS_TYPE_U32:
     301        PSIMAGE_COPY_CASE(output, U32);
     302        break;
     303    case PS_TYPE_U64:
     304        PSIMAGE_COPY_CASE(output, U64);
     305        break;
     306    case PS_TYPE_F32:
     307        PSIMAGE_COPY_CASE(output, F32);
     308        break;
     309    case PS_TYPE_F64:
     310        PSIMAGE_COPY_CASE(output, F64);
     311        break;
     312    case PS_TYPE_C32:
     313        PSIMAGE_COPY_CASE(output, C32);
     314        break;
     315    case PS_TYPE_C64:
     316        PSIMAGE_COPY_CASE(output, C64);
     317        break;
     318    default: {
     319            char* typeStr;
     320            PS_TYPE_NAME(typeStr,type);
     321            psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     322                       PS_ERR_BAD_PARAMETER_TYPE, true,
     323                       PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     324                       typeStr);
     325            psFree(output);
     326
     327            break;
     328        }
     329    }
     330    return output;
    164331}
    165332

  • trunk/psLib/src/image/psImage.h

    r1936 r2067  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2004-09-30 21:01:09 $
     13 *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2004-10-13 00:10:50 $
    1515 *
    1616 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    100100);
    101101
     102/** Makes a copy of a psImage
     103 *
     104 * @return psImage* Copy of the input psImage.  This may not be equal to the
     105 * output parameter
     106 *
     107 */
     108psImage* psImageCopy(
     109    psImage* restrict output,          ///< if not NULL, a psImage that could be recycled.
     110    const psImage* input,              ///< the psImage to copy
     111    psElemType type                    ///< the desired datatype of the returned copy
     112);
     113
    102114/** Frees all children of a psImage.
    103115 *

  • trunk/psLib/src/image/psImageExtraction.c

    r1962 r2067  
    99 *  @author Robert DeSonia, MHPCC
    1010 *
    11  *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-10-05 22:23:04 $
     11 *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-10-13 00:10:50 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2323
    2424#include "psImageErrors.h"
    25 
    2625
    2726psImage* imageSubset(psImage* out,
    … …  
    236235
    237236    return (image);
    238 }
    239 
    240 psImage* psImageCopy(psImage* restrict output,
    241                      const psImage* input,
    242                      psElemType type)
    243 {
    244     psElemType inDatatype;
    245     int elementSize;
    246     int elements;
    247     int numRows;
    248     int numCols;
    249 
    250     if (input == NULL || input->data.V == NULL) {
    251         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    252                    PS_ERR_BAD_PARAMETER_NULL, true,
    253                    PS_ERRORTEXT_psImage_IMAGE_NULL);
    254         psFree(output);
    255         return NULL;
    256     }
    257 
    258     if (input == output) {
    259         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    260                    PS_ERR_BAD_PARAMETER_NULL, true,
    261                    PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
    262         psFree(output);
    263         return NULL;
    264     }
    265 
    266     if (input->type.dimen != PS_DIMEN_IMAGE) {
    267         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    268                    PS_ERR_BAD_PARAMETER_TYPE, true,
    269                    PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
    270         psFree(output);
    271         return NULL;
    272     }
    273 
    274     inDatatype = input->type.type;
    275     numRows = input->numRows;
    276     numCols = input->numCols;
    277     elements = numRows * numCols;
    278     elementSize = PSELEMTYPE_SIZEOF(inDatatype);
    279 
    280     if (inDatatype == PS_TYPE_PTR || type == PS_TYPE_PTR) {
    281         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    282                    PS_ERR_BAD_PARAMETER_TYPE, true,
    283                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    284                    PS_TYPE_PTR_NAME);
    285         psFree(output);
    286         return NULL;
    287     }
    288 
    289     output = psImageRecycle(output, numCols, numRows, type);
    290 
    291     // cover the trival case of copy of the same
    292     // datatype.
    293     if (type == inDatatype) {
    294         for (int row=0;row<numRows;row++) {
    295             memcpy(output->data.V[row], input->data.V[row], elementSize * numCols);
    296         }
    297         return output;
    298     }
    299 
    300     #define PSIMAGE_ELEMENT_COPY(IN,INTYPE,OUT,OUTTYPE,ELEMENTS) { \
    301         ps##INTYPE *in; \
    302         ps##OUTTYPE *out; \
    303         for(int row=0;row<numRows;row++) { \
    304             in = IN->data.INTYPE[row]; \
    305             out = OUT->data.OUTTYPE[row]; \
    306             for (int col=0;col<numCols;col++) { \
    307                 *(out++) = *(in++); \
    308             } \
    309         } \
    310     }
    311 
    312     #define PSIMAGE_COPY_CASE(OUT,OUTTYPE) { \
    313         switch (inDatatype) { \
    314         case PS_TYPE_S8: \
    315             PSIMAGE_ELEMENT_COPY(input,S8,OUT,OUTTYPE,elements); \
    316             break; \
    317         case PS_TYPE_S16: \
    318             PSIMAGE_ELEMENT_COPY(input,S16,OUT,OUTTYPE,elements); \
    319             break; \
    320         case PS_TYPE_S32: \
    321             PSIMAGE_ELEMENT_COPY(input,S32,OUT,OUTTYPE,elements); \
    322             break; \
    323         case PS_TYPE_S64: \
    324             PSIMAGE_ELEMENT_COPY(input,S64,OUT,OUTTYPE,elements); \
    325             break; \
    326         case PS_TYPE_U8: \
    327             PSIMAGE_ELEMENT_COPY(input,U8,OUT,OUTTYPE,elements); \
    328             break; \
    329         case PS_TYPE_U16: \
    330             PSIMAGE_ELEMENT_COPY(input,U16,OUT,OUTTYPE,elements); \
    331             break; \
    332         case PS_TYPE_U32: \
    333             PSIMAGE_ELEMENT_COPY(input,U32,OUT,OUTTYPE,elements); \
    334             break; \
    335         case PS_TYPE_U64: \
    336             PSIMAGE_ELEMENT_COPY(input,U64,OUT,OUTTYPE,elements); \
    337             break; \
    338         case PS_TYPE_F32: \
    339             PSIMAGE_ELEMENT_COPY(input,F32,OUT,OUTTYPE,elements); \
    340             break; \
    341         case PS_TYPE_F64: \
    342             PSIMAGE_ELEMENT_COPY(input,F64,OUT,OUTTYPE,elements); \
    343             break; \
    344         case PS_TYPE_C32: \
    345             PSIMAGE_ELEMENT_COPY(input,C32,OUT,OUTTYPE,elements); \
    346             break; \
    347         case PS_TYPE_C64: \
    348             PSIMAGE_ELEMENT_COPY(input,C64,OUT,OUTTYPE,elements); \
    349             break; \
    350         default: \
    351             break; \
    352         } \
    353     }
    354 
    355     switch (type) {
    356     case PS_TYPE_S8:
    357         PSIMAGE_COPY_CASE(output, S8);
    358         break;
    359     case PS_TYPE_S16:
    360         PSIMAGE_COPY_CASE(output, S16);
    361         break;
    362     case PS_TYPE_S32:
    363         PSIMAGE_COPY_CASE(output, S32);
    364         break;
    365     case PS_TYPE_S64:
    366         PSIMAGE_COPY_CASE(output, S64);
    367         break;
    368     case PS_TYPE_U8:
    369         PSIMAGE_COPY_CASE(output, U8);
    370         break;
    371     case PS_TYPE_U16:
    372         PSIMAGE_COPY_CASE(output, U16);
    373         break;
    374     case PS_TYPE_U32:
    375         PSIMAGE_COPY_CASE(output, U32);
    376         break;
    377     case PS_TYPE_U64:
    378         PSIMAGE_COPY_CASE(output, U64);
    379         break;
    380     case PS_TYPE_F32:
    381         PSIMAGE_COPY_CASE(output, F32);
    382         break;
    383     case PS_TYPE_F64:
    384         PSIMAGE_COPY_CASE(output, F64);
    385         break;
    386     case PS_TYPE_C32:
    387         PSIMAGE_COPY_CASE(output, C32);
    388         break;
    389     case PS_TYPE_C64:
    390         PSIMAGE_COPY_CASE(output, C64);
    391         break;
    392     default: {
    393             char* typeStr;
    394             PS_TYPE_NAME(typeStr,type);
    395             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    396                        PS_ERR_BAD_PARAMETER_TYPE, true,
    397                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    398                        typeStr);
    399             psFree(output);
    400 
    401             break;
    402         }
    403     }
    404     return output;
    405237}
    406238

  • trunk/psLib/src/image/psImageExtraction.h

    r1924 r2067  
    1010*  @author Robert DeSonia, MHPCC
    1111*
    12 *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2004-09-29 01:10:27 $
     12*  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2004-10-13 00:10:50 $
    1414*
    1515*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    9898    int row1                           ///< row of trim region's upper boundary
    9999);
    100 
    101 /** Makes a copy of a psImage
    102  *
    103  * @return psImage* Copy of the input psImage.  This may not be equal to the
    104  * output parameter
    105  *
    106  */
    107 psImage* psImageCopy(
    108     psImage* restrict output,          ///< if not NULL, a psImage that could be recycled.
    109     const psImage* input,              ///< the psImage to copy
    110     psElemType type                    ///< the desired datatype of the returned copy
    111 );
    112 
    113100
    114101/** Extract pixels from rectlinear region to a vector (array of floats).

  • trunk/psLib/src/mathtypes/psImage.c

    r1933 r2067  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2004-09-30 18:54:42 $
     12 *  @version $Revision: 1.49 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2004-10-13 00:10:50 $
    1414 *
    1515 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    162162
    163163    return old;
     164}
     165
     166psImage* psImageCopy(psImage* restrict output,
     167                     const psImage* input,
     168                     psElemType type)
     169{
     170    psElemType inDatatype;
     171    int elementSize;
     172    int elements;
     173    int numRows;
     174    int numCols;
     175
     176    if (input == NULL || input->data.V == NULL) {
     177        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     178                   PS_ERR_BAD_PARAMETER_NULL, true,
     179                   PS_ERRORTEXT_psImage_IMAGE_NULL);
     180        psFree(output);
     181        return NULL;
     182    }
     183
     184    if (input == output) {
     185        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     186                   PS_ERR_BAD_PARAMETER_NULL, true,
     187                   PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
     188        psFree(output);
     189        return NULL;
     190    }
     191
     192    if (input->type.dimen != PS_DIMEN_IMAGE) {
     193        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     194                   PS_ERR_BAD_PARAMETER_TYPE, true,
     195                   PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
     196        psFree(output);
     197        return NULL;
     198    }
     199
     200    inDatatype = input->type.type;
     201    numRows = input->numRows;
     202    numCols = input->numCols;
     203    elements = numRows * numCols;
     204    elementSize = PSELEMTYPE_SIZEOF(inDatatype);
     205
     206    if (inDatatype == PS_TYPE_PTR || type == PS_TYPE_PTR) {
     207        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     208                   PS_ERR_BAD_PARAMETER_TYPE, true,
     209                   PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     210                   PS_TYPE_PTR_NAME);
     211        psFree(output);
     212        return NULL;
     213    }
     214
     215    output = psImageRecycle(output, numCols, numRows, type);
     216
     217    // cover the trival case of copy of the same
     218    // datatype.
     219    if (type == inDatatype) {
     220        for (int row=0;row<numRows;row++) {
     221            memcpy(output->data.V[row], input->data.V[row], elementSize * numCols);
     222        }
     223        return output;
     224    }
     225
     226    #define PSIMAGE_ELEMENT_COPY(IN,INTYPE,OUT,OUTTYPE,ELEMENTS) { \
     227        ps##INTYPE *in; \
     228        ps##OUTTYPE *out; \
     229        for(int row=0;row<numRows;row++) { \
     230            in = IN->data.INTYPE[row]; \
     231            out = OUT->data.OUTTYPE[row]; \
     232            for (int col=0;col<numCols;col++) { \
     233                *(out++) = *(in++); \
     234            } \
     235        } \
     236    }
     237
     238    #define PSIMAGE_COPY_CASE(OUT,OUTTYPE) { \
     239        switch (inDatatype) { \
     240        case PS_TYPE_S8: \
     241            PSIMAGE_ELEMENT_COPY(input,S8,OUT,OUTTYPE,elements); \
     242            break; \
     243        case PS_TYPE_S16: \
     244            PSIMAGE_ELEMENT_COPY(input,S16,OUT,OUTTYPE,elements); \
     245            break; \
     246        case PS_TYPE_S32: \
     247            PSIMAGE_ELEMENT_COPY(input,S32,OUT,OUTTYPE,elements); \
     248            break; \
     249        case PS_TYPE_S64: \
     250            PSIMAGE_ELEMENT_COPY(input,S64,OUT,OUTTYPE,elements); \
     251            break; \
     252        case PS_TYPE_U8: \
     253            PSIMAGE_ELEMENT_COPY(input,U8,OUT,OUTTYPE,elements); \
     254            break; \
     255        case PS_TYPE_U16: \
     256            PSIMAGE_ELEMENT_COPY(input,U16,OUT,OUTTYPE,elements); \
     257            break; \
     258        case PS_TYPE_U32: \
     259            PSIMAGE_ELEMENT_COPY(input,U32,OUT,OUTTYPE,elements); \
     260            break; \
     261        case PS_TYPE_U64: \
     262            PSIMAGE_ELEMENT_COPY(input,U64,OUT,OUTTYPE,elements); \
     263            break; \
     264        case PS_TYPE_F32: \
     265            PSIMAGE_ELEMENT_COPY(input,F32,OUT,OUTTYPE,elements); \
     266            break; \
     267        case PS_TYPE_F64: \
     268            PSIMAGE_ELEMENT_COPY(input,F64,OUT,OUTTYPE,elements); \
     269            break; \
     270        case PS_TYPE_C32: \
     271            PSIMAGE_ELEMENT_COPY(input,C32,OUT,OUTTYPE,elements); \
     272            break; \
     273        case PS_TYPE_C64: \
     274            PSIMAGE_ELEMENT_COPY(input,C64,OUT,OUTTYPE,elements); \
     275            break; \
     276        default: \
     277            break; \
     278        } \
     279    }
     280
     281    switch (type) {
     282    case PS_TYPE_S8:
     283        PSIMAGE_COPY_CASE(output, S8);
     284        break;
     285    case PS_TYPE_S16:
     286        PSIMAGE_COPY_CASE(output, S16);
     287        break;
     288    case PS_TYPE_S32:
     289        PSIMAGE_COPY_CASE(output, S32);
     290        break;
     291    case PS_TYPE_S64:
     292        PSIMAGE_COPY_CASE(output, S64);
     293        break;
     294    case PS_TYPE_U8:
     295        PSIMAGE_COPY_CASE(output, U8);
     296        break;
     297    case PS_TYPE_U16:
     298        PSIMAGE_COPY_CASE(output, U16);
     299        break;
     300    case PS_TYPE_U32:
     301        PSIMAGE_COPY_CASE(output, U32);
     302        break;
     303    case PS_TYPE_U64:
     304        PSIMAGE_COPY_CASE(output, U64);
     305        break;
     306    case PS_TYPE_F32:
     307        PSIMAGE_COPY_CASE(output, F32);
     308        break;
     309    case PS_TYPE_F64:
     310        PSIMAGE_COPY_CASE(output, F64);
     311        break;
     312    case PS_TYPE_C32:
     313        PSIMAGE_COPY_CASE(output, C32);
     314        break;
     315    case PS_TYPE_C64:
     316        PSIMAGE_COPY_CASE(output, C64);
     317        break;
     318    default: {
     319            char* typeStr;
     320            PS_TYPE_NAME(typeStr,type);
     321            psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
     322                       PS_ERR_BAD_PARAMETER_TYPE, true,
     323                       PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     324                       typeStr);
     325            psFree(output);
     326
     327            break;
     328        }
     329    }
     330    return output;
    164331}
    165332

  • trunk/psLib/src/mathtypes/psImage.h

    r1936 r2067  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2004-09-30 21:01:09 $
     13 *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2004-10-13 00:10:50 $
    1515 *
    1616 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    100100);
    101101
     102/** Makes a copy of a psImage
     103 *
     104 * @return psImage* Copy of the input psImage.  This may not be equal to the
     105 * output parameter
     106 *
     107 */
     108psImage* psImageCopy(
     109    psImage* restrict output,          ///< if not NULL, a psImage that could be recycled.
     110    const psImage* input,              ///< the psImage to copy
     111    psElemType type                    ///< the desired datatype of the returned copy
     112);
     113
    102114/** Frees all children of a psImage.
    103115 *

  • trunk/psLib/test/astronomy/tst_psAstrometry.c

    r2056 r2067  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2004-10-12 19:51:53 $
     7 *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2004-10-13 00:10:50 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    387387    }
    388388
    389     if (psMemGetRefCounter(fpa) != 2) {
    390         psLogMsg(__func__,PS_LOG_ERROR,
    391                  "psChipAlloc did not increment reference counter for parent FPA.");
     389    if (psMemGetRefCounter(fpa) != 1) {
     390        psLogMsg(__func__,PS_LOG_ERROR,
     391                 "psChipAlloc incremented reference counter for parent FPA.");
    392392        return 5;
    393393    }
    … …  
    439439    }
    440440
    441     if (psMemGetRefCounter(fpa) != 3) {
    442         psLogMsg(__func__,PS_LOG_ERROR,
    443                  "psChipAlloc did not increment reference counter for parent FPA.");
     441    if (psMemGetRefCounter(fpa) != 1) {
     442        psLogMsg(__func__,PS_LOG_ERROR,
     443                 "psChipAlloc incremented reference counter for parent FPA.");
    444444        return 15;
    445445    }
    … …  
    537537    }
    538538
    539     if (psMemGetRefCounter(chip) != 2) {
    540         psLogMsg(__func__,PS_LOG_ERROR,
    541                  "psCellAlloc did not increment reference counter for parent.");
     539    if (psMemGetRefCounter(chip) != 1) {
     540        psLogMsg(__func__,PS_LOG_ERROR,
     541                 "psCellAlloc incremented reference counter for parent.");
    542542        return 5;
    543543    }
    … …  
    603603    }
    604604
    605     if (psMemGetRefCounter(chip) != 3) {
    606         psLogMsg(__func__,PS_LOG_ERROR,
    607                  "psCellAlloc did not increment reference counter for parent FPA.");
     605    if (psMemGetRefCounter(chip) != 1) {
     606        psLogMsg(__func__,PS_LOG_ERROR,
     607                 "psCellAlloc incremented reference counter for parent FPA.");
    608608        return 15;
    609609    }
    … …  
    677677    }
    678678
    679     if (psMemGetRefCounter(image) != 2) {
    680         psLogMsg(__func__,PS_LOG_ERROR,
    681                  "psReadoutAlloc did not increment reference counter for image.");
     679    if (psMemGetRefCounter(image) != 1) {
     680        psLogMsg(__func__,PS_LOG_ERROR,
     681                 "psReadoutAlloc incremented reference counter for image.");
    682682        return 5;
    683683    }

  • trunk/psLib/test/astronomy/tst_psAstrometry03.c

    r2066 r2067  
    2222    }
    2323
    24     for (i=0;i<NUM_CHIPS;i++) {
    25         psArrayElementFree(chips[i]->cells);
    26     }
    27     psArrayElementFree(myFPA->chips);
    2824    psFree(myFPA);
    2925

  • trunk/psLib/test/image/tst_psImageExtraction.c

    r2022 r2067  
    66*  @author Robert DeSonia, MHPCC
    77*
    8 *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2004-10-08 19:44:32 $
     8*  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2004-10-13 00:10:50 $
    1010*
    1111*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2121static int testImageSubset(void);
    2222static int testImageSubsection(void);
     23static int testImageTrim(void);
     24
    2325
    2426testDescription tests[] = {
    … …  
    2729                              {testImageSubsection,730,"psImageSubsection",0,false},
    2830                              {testImageSlice, 552, "psImageSlice", 0, false},
     31                              {testImageTrim, 744, "psImageTrim", 0, false},
    2932                              {NULL}
    3033                          };
    … …  
    743746    return 0;
    744747}
     748
     749static int testImageTrim(void)
     750{
     751    int r = 200;
     752    int c = 300;
     753    int quarterR = r/4;
     754    int quarterC = c/4;
     755    int halfR = r/2;
     756    psImage* image = psImageAlloc(c,r,PS_TYPE_F32);
     757    for (int row = 0; row < image->numRows; row++) {
     758        for (int col = 0; col < image->numCols; col++) {
     759            image->data.F32[row][col] = ((psF32)row+1.0f)/((psF32)col+1.0f);
     760        }
     761    }
     762
     763    psImage* image1 = psImageCopy(NULL,image,PS_TYPE_F32);
     764    psImage* image2 = psImageTrim(image1,c/4,r/4,c*3/4,r*3/4);
     765
     766
     767
     768    return 0;
     769}
Note: See TracChangeset for help on using the changeset viewer.