IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2067 for trunk/psLib/src/image


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/src/image
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • 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).
Note: See TracChangeset for help on using the changeset viewer.