IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 1261


Ignore:
Timestamp:
Jul 22, 2004, 10:09:04 AM (22 years ago)
Author:
desonia
Message:

moved image pixel interpolation from the psImageStats.[ch] to psImage.[ch] (logical reclassification)

Location:
trunk/psLib/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r1205 r1261  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-07-09 21:48:07 $
     11 *  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-07-22 20:09:04 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    400400}
    401401
     402/*****************************************************************************
     403p_psImagePixelInterpolation(image, x, y): this routine takes as input an
     404image and coordinates (x, y) and produces as output the corresponding pixel
     405value at the those coordinates.  For fractional corrdinates (x, y), 2-D
     406linear interpolation is performed on the image.
     407 *****************************************************************************/
     408psF32 psImagePixelInterpolate(
     409    const psImage *input,
     410    float x,
     411    float y,
     412    psF32 unexposedValue,
     413    psImageInterpolateMode mode)
     414{
     415
     416    if (input == NULL) {
     417        psError(__func__,"Image can not be NULL.");
     418        return unexposedValue;
     419    }
     420
     421    #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \
     422case PS_TYPE_##TYPE: \
     423    switch (mode) { \
     424    case PS_INTERPOLATE_FLAT: \
     425        return p_psImagePixelInterpolateFLAT_##TYPE(input,x,y,unexposedValue); \
     426        break; \
     427    case PS_INTERPOLATE_BILINEAR: \
     428        return p_psImagePixelInterpolateBILINEAR_##TYPE(input,x,y,unexposedValue); \
     429        break; \
     430    default: \
     431        psError(__func__,"Unsupported interpolation mode (#%d)",mode); \
     432    } \
     433    break
     434
     435    switch (input->type.type) {
     436        PSIMAGE_PIXEL_INTERPOLATE_CASE(U8);
     437        PSIMAGE_PIXEL_INTERPOLATE_CASE(U16);
     438        PSIMAGE_PIXEL_INTERPOLATE_CASE(U32);
     439        PSIMAGE_PIXEL_INTERPOLATE_CASE(U64);
     440        PSIMAGE_PIXEL_INTERPOLATE_CASE(S8);
     441        PSIMAGE_PIXEL_INTERPOLATE_CASE(S16);
     442        PSIMAGE_PIXEL_INTERPOLATE_CASE(S32);
     443        PSIMAGE_PIXEL_INTERPOLATE_CASE(S64);
     444        PSIMAGE_PIXEL_INTERPOLATE_CASE(F32);
     445        PSIMAGE_PIXEL_INTERPOLATE_CASE(F64);
     446        PSIMAGE_PIXEL_INTERPOLATE_CASE(C32);
     447        PSIMAGE_PIXEL_INTERPOLATE_CASE(C64);
     448    default:
     449        psError(__func__,"Unsupported image datatype (%d)",input->type.type);
     450    }
     451
     452    return unexposedValue;
     453}
     454
     455#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \
     456inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
     457        float x, \
     458        float y, \
     459        psF64 unexposedValue) \
     460{ \
     461    int intX = (int) round((psF64)(x) - 0.5); \
     462    int intY = (int) round((psF64)(y) - 0.5); \
     463    int lastX = input->numCols - 1; \
     464    int lastY = input->numRows - 1; \
     465    \
     466    if ((intX < 0) || \
     467            (intX > lastX) || \
     468            (intY < 0) || \
     469            (intY > lastY)) { \
     470        return unexposedValue; \
     471    } \
     472    \
     473    return input->data.TYPE[intY][intX]; \
     474}
     475
     476#define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \
     477inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
     478        float x, \
     479        float y, \
     480        psC64 unexposedValue) \
     481{ \
     482    int intX = (int) round((psF64)(x) - 0.5); \
     483    int intY = (int) round((psF64)(y) - 0.5); \
     484    int lastX = input->numCols - 1; \
     485    int lastY = input->numRows - 1; \
     486    \
     487    if ((intX < 0) || \
     488            (intX > lastX) || \
     489            (intY < 0) || \
     490            (intY > lastY)) { \
     491        return unexposedValue; \
     492    } \
     493    \
     494    return input->data.TYPE[intY][intX]; \
     495}
     496
     497PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8)
     498PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16)
     499PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32)
     500PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64)
     501PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8)
     502PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16)
     503PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32)
     504PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64)
     505PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32)
     506PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64)
     507PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32)
     508PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64)
     509
     510#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \
     511inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
     512        float x, \
     513        float y, \
     514        psF64 unexposedValue) \
     515{ \
     516    double floorX = floor((psF64)(x) - 0.5); \
     517    double floorY = floor((psF64)(y) - 0.5); \
     518    double fracX = x - 0.5 - floorX; \
     519    double fracY = y - 0.5 - floorY; \
     520    int intFloorX = (int) floorX; \
     521    int intFloorY = (int) floorY; \
     522    int lastX = input->numCols - 1; \
     523    int lastY = input->numRows - 1; \
     524    double rx = 0.0; \
     525    psF64 pixel = 0.0; \
     526    ps##TYPE* currentRow; \
     527    ps##TYPE* nextRow; \
     528    \
     529    if ((intFloorX < 0) || \
     530            (intFloorX > lastX) || \
     531            (intFloorY < 0) || \
     532            (intFloorY > lastY)) { \
     533        return unexposedValue; \
     534    } \
     535    \
     536    currentRow = input->data.TYPE[intFloorY]; \
     537    if (intFloorY == lastY) { \
     538        pixel = currentRow[intFloorX]; \
     539        if (intFloorX < lastX) { \
     540            pixel+= fracY * ((psF64)currentRow[intFloorX+1] - \
     541                             (psF64)currentRow[intFloorX]); \
     542        } \
     543        return(pixel); \
     544    } \
     545    nextRow = input->data.TYPE[intFloorY+1]; \
     546    if (intFloorX == lastX) { \
     547        pixel = currentRow[intFloorX]; \
     548        if (intFloorY < lastY) { \
     549            pixel+= fracX * ((psF64)nextRow[intFloorX] - \
     550                             (psF64)currentRow[intFloorX]); \
     551        } \
     552        return(pixel); \
     553    } \
     554    \
     555    rx = currentRow[intFloorX] + \
     556         fracX * ((psF64)currentRow[intFloorX+1] - \
     557                  (psF64)currentRow[intFloorX]); \
     558    \
     559    pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
     560                          fracX * ((psF64)nextRow[intFloorX+1] - \
     561                                   (psF64)nextRow[intFloorX]) - rx); \
     562    \
     563    return(pixel); \
     564}
     565
     566#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \
     567inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
     568        float x, \
     569        float y, \
     570        psC64 unexposedValue) \
     571{ \
     572    double floorX = floor((psF64)(x) - 0.5); \
     573    double floorY = floor((psF64)(y) - 0.5); \
     574    double fracX = x - 0.5 - floorX; \
     575    double fracY = y - 0.5 - floorY; \
     576    int intFloorX = (int) floorX; \
     577    int intFloorY = (int) floorY; \
     578    int lastX = input->numCols - 1; \
     579    int lastY = input->numRows - 1; \
     580    double rx = 0.0; \
     581    psC64 pixel = 0.0; \
     582    ps##TYPE* currentRow; \
     583    ps##TYPE* nextRow; \
     584    \
     585    if ((intFloorX < 0) || \
     586            (intFloorX > lastX) || \
     587            (intFloorY < 0) || \
     588            (intFloorY > lastY)) { \
     589        return unexposedValue; \
     590    } \
     591    \
     592    currentRow = input->data.TYPE[intFloorY]; \
     593    if (intFloorY == lastY) { \
     594        pixel = currentRow[intFloorX]; \
     595        if (intFloorX < lastX) { \
     596            pixel+= fracY * (currentRow[intFloorX+1] - \
     597                             currentRow[intFloorX]); \
     598        } \
     599        return(pixel); \
     600    } \
     601    nextRow = input->data.TYPE[intFloorY+1]; \
     602    if (intFloorX == lastX) { \
     603        pixel = currentRow[intFloorX]; \
     604        if (intFloorY < lastY) { \
     605            pixel+= fracX * (nextRow[intFloorX] - \
     606                             currentRow[intFloorX]); \
     607        } \
     608        return(pixel); \
     609    } \
     610    \
     611    rx = currentRow[intFloorX] + \
     612         fracX * (currentRow[intFloorX+1] - \
     613                  currentRow[intFloorX]); \
     614    \
     615    pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
     616                          fracX * (nextRow[intFloorX+1] - \
     617                                   nextRow[intFloorX]) - rx); \
     618    \
     619    return(pixel); \
     620}
     621
     622PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8)
     623PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16)
     624PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32)
     625PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64)
     626PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8)
     627PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16)
     628PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32)
     629PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64)
     630PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32)
     631PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64)
     632PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32)
     633PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64)
     634
     635

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

    r1205 r1261  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2004-07-09 21:48:07 $
     13 *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2004-07-22 20:09:04 $
    1515 *
    1616 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2525/// @addtogroup Image
    2626/// @{
     27
     28typedef enum {
     29    PS_INTERPOLATE_FLAT,
     30    PS_INTERPOLATE_BILINEAR
     31} psImageInterpolateMode;
    2732
    2833/** Basic image data structure.
    … …  
    137142);
    138143
     144psF32 psImagePixelInterpolate(
     145    const psImage *input,
     146    float x,
     147    float y,
     148    psF32 unexposedValue,
     149    psImageInterpolateMode mode
     150);
     151
     152#define p_psImagePixelInterpolateFcns(TYPE) \
     153inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \
     154        const psImage *input, \
     155        float x, \
     156        float y, \
     157        psF64 unexposedValue \
     158                                                 ); \
     159inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
     160        const psImage *input, \
     161        float x, \
     162        float y, \
     163        psF64 unexposedValue \
     164                                                     );
     165
     166#define p_psImagePixelInterpolateComplexFcns(TYPE) \
     167inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \
     168        const psImage *input, \
     169        float x, \
     170        float y, \
     171        psC64 unexposedValue \
     172                                                 ); \
     173inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
     174        const psImage *input, \
     175        float x, \
     176        float y, \
     177        psC64 unexposedValue \
     178                                                     );
     179
     180p_psImagePixelInterpolateFcns(U8)
     181p_psImagePixelInterpolateFcns(U16)
     182p_psImagePixelInterpolateFcns(U32)
     183p_psImagePixelInterpolateFcns(U64)
     184p_psImagePixelInterpolateFcns(S8)
     185p_psImagePixelInterpolateFcns(S16)
     186p_psImagePixelInterpolateFcns(S32)
     187p_psImagePixelInterpolateFcns(S64)
     188p_psImagePixelInterpolateFcns(F32)
     189p_psImagePixelInterpolateFcns(F64)
     190p_psImagePixelInterpolateComplexFcns(C32)
     191p_psImagePixelInterpolateComplexFcns(C64)
     192
    139193/// @}
    140194

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

    r1260 r1261  
    369369    return(0);
    370370}
    371 
    372 /*****************************************************************************
    373 p_psImagePixelInterpolation(image, x, y): this routine takes as input an
    374 image and coordinates (x, y) and produces as output the corresponding pixel
    375 value at the those coordinates.  For fractional corrdinates (x, y), 2-D
    376 linear interpolation is performed on the image.
    377  *****************************************************************************/
    378 psF32 psImagePixelInterpolate(
    379     const psImage *input,
    380     float x,
    381     float y,
    382     psF32 unexposedValue,
    383     psImageInterpolateMode mode)
    384 {
    385 
    386     if (input == NULL) {
    387         psError(__func__,"Image can not be NULL.");
    388         return unexposedValue;
    389     }
    390 
    391     #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \
    392 case PS_TYPE_##TYPE: \
    393     switch (mode) { \
    394     case PS_INTERPOLATE_FLAT: \
    395         return p_psImagePixelInterpolateFLAT_##TYPE(input,x,y,unexposedValue); \
    396         break; \
    397     case PS_INTERPOLATE_BILINEAR: \
    398         return p_psImagePixelInterpolateBILINEAR_##TYPE(input,x,y,unexposedValue); \
    399         break; \
    400     default: \
    401         psError(__func__,"Unsupported interpolation mode (#%d)",mode); \
    402     } \
    403     break
    404 
    405     switch (input->type.type) {
    406         PSIMAGE_PIXEL_INTERPOLATE_CASE(U8);
    407         PSIMAGE_PIXEL_INTERPOLATE_CASE(U16);
    408         PSIMAGE_PIXEL_INTERPOLATE_CASE(U32);
    409         PSIMAGE_PIXEL_INTERPOLATE_CASE(U64);
    410         PSIMAGE_PIXEL_INTERPOLATE_CASE(S8);
    411         PSIMAGE_PIXEL_INTERPOLATE_CASE(S16);
    412         PSIMAGE_PIXEL_INTERPOLATE_CASE(S32);
    413         PSIMAGE_PIXEL_INTERPOLATE_CASE(S64);
    414         PSIMAGE_PIXEL_INTERPOLATE_CASE(F32);
    415         PSIMAGE_PIXEL_INTERPOLATE_CASE(F64);
    416         PSIMAGE_PIXEL_INTERPOLATE_CASE(C32);
    417         PSIMAGE_PIXEL_INTERPOLATE_CASE(C64);
    418     default:
    419         psError(__func__,"Unsupported image datatype (%d)",input->type.type);
    420     }
    421 
    422     return unexposedValue;
    423 }
    424 
    425 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \
    426 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
    427         float x, \
    428         float y, \
    429         psF64 unexposedValue) \
    430 { \
    431     int intX = (int) round((psF64)(x) - 0.5); \
    432     int intY = (int) round((psF64)(y) - 0.5); \
    433     int lastX = input->numCols - 1; \
    434     int lastY = input->numRows - 1; \
    435     \
    436     if ((intX < 0) || \
    437             (intX > lastX) || \
    438             (intY < 0) || \
    439             (intY > lastY)) { \
    440         return unexposedValue; \
    441     } \
    442     \
    443     return input->data.TYPE[intY][intX]; \
    444 }
    445 
    446 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \
    447 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
    448         float x, \
    449         float y, \
    450         psC64 unexposedValue) \
    451 { \
    452     int intX = (int) round((psF64)(x) - 0.5); \
    453     int intY = (int) round((psF64)(y) - 0.5); \
    454     int lastX = input->numCols - 1; \
    455     int lastY = input->numRows - 1; \
    456     \
    457     if ((intX < 0) || \
    458             (intX > lastX) || \
    459             (intY < 0) || \
    460             (intY > lastY)) { \
    461         return unexposedValue; \
    462     } \
    463     \
    464     return input->data.TYPE[intY][intX]; \
    465 }
    466 
    467 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8)
    468 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16)
    469 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32)
    470 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64)
    471 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8)
    472 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16)
    473 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32)
    474 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64)
    475 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32)
    476 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64)
    477 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32)
    478 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64)
    479 
    480 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \
    481 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
    482         float x, \
    483         float y, \
    484         psF64 unexposedValue) \
    485 { \
    486     double floorX = floor((psF64)(x) - 0.5); \
    487     double floorY = floor((psF64)(y) - 0.5); \
    488     double fracX = x - 0.5 - floorX; \
    489     double fracY = y - 0.5 - floorY; \
    490     int intFloorX = (int) floorX; \
    491     int intFloorY = (int) floorY; \
    492     int lastX = input->numCols - 1; \
    493     int lastY = input->numRows - 1; \
    494     double rx = 0.0; \
    495     psF64 pixel = 0.0; \
    496     ps##TYPE* currentRow; \
    497     ps##TYPE* nextRow; \
    498     \
    499     if ((intFloorX < 0) || \
    500             (intFloorX > lastX) || \
    501             (intFloorY < 0) || \
    502             (intFloorY > lastY)) { \
    503         return unexposedValue; \
    504     } \
    505     \
    506     currentRow = input->data.TYPE[intFloorY]; \
    507     if (intFloorY == lastY) { \
    508         pixel = currentRow[intFloorX]; \
    509         if (intFloorX < lastX) { \
    510             pixel+= fracY * ((psF64)currentRow[intFloorX+1] - \
    511                              (psF64)currentRow[intFloorX]); \
    512         } \
    513         return(pixel); \
    514     } \
    515     nextRow = input->data.TYPE[intFloorY+1]; \
    516     if (intFloorX == lastX) { \
    517         pixel = currentRow[intFloorX]; \
    518         if (intFloorY < lastY) { \
    519             pixel+= fracX * ((psF64)nextRow[intFloorX] - \
    520                              (psF64)currentRow[intFloorX]); \
    521         } \
    522         return(pixel); \
    523     } \
    524     \
    525     rx = currentRow[intFloorX] + \
    526          fracX * ((psF64)currentRow[intFloorX+1] - \
    527                   (psF64)currentRow[intFloorX]); \
    528     \
    529     pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
    530                           fracX * ((psF64)nextRow[intFloorX+1] - \
    531                                    (psF64)nextRow[intFloorX]) - rx); \
    532     \
    533     return(pixel); \
    534 }
    535 
    536 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \
    537 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
    538         float x, \
    539         float y, \
    540         psC64 unexposedValue) \
    541 { \
    542     double floorX = floor((psF64)(x) - 0.5); \
    543     double floorY = floor((psF64)(y) - 0.5); \
    544     double fracX = x - 0.5 - floorX; \
    545     double fracY = y - 0.5 - floorY; \
    546     int intFloorX = (int) floorX; \
    547     int intFloorY = (int) floorY; \
    548     int lastX = input->numCols - 1; \
    549     int lastY = input->numRows - 1; \
    550     double rx = 0.0; \
    551     psC64 pixel = 0.0; \
    552     ps##TYPE* currentRow; \
    553     ps##TYPE* nextRow; \
    554     \
    555     if ((intFloorX < 0) || \
    556             (intFloorX > lastX) || \
    557             (intFloorY < 0) || \
    558             (intFloorY > lastY)) { \
    559         return unexposedValue; \
    560     } \
    561     \
    562     currentRow = input->data.TYPE[intFloorY]; \
    563     if (intFloorY == lastY) { \
    564         pixel = currentRow[intFloorX]; \
    565         if (intFloorX < lastX) { \
    566             pixel+= fracY * (currentRow[intFloorX+1] - \
    567                              currentRow[intFloorX]); \
    568         } \
    569         return(pixel); \
    570     } \
    571     nextRow = input->data.TYPE[intFloorY+1]; \
    572     if (intFloorX == lastX) { \
    573         pixel = currentRow[intFloorX]; \
    574         if (intFloorY < lastY) { \
    575             pixel+= fracX * (nextRow[intFloorX] - \
    576                              currentRow[intFloorX]); \
    577         } \
    578         return(pixel); \
    579     } \
    580     \
    581     rx = currentRow[intFloorX] + \
    582          fracX * (currentRow[intFloorX+1] - \
    583                   currentRow[intFloorX]); \
    584     \
    585     pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
    586                           fracX * (nextRow[intFloorX+1] - \
    587                                    nextRow[intFloorX]) - rx); \
    588     \
    589     return(pixel); \
    590 }
    591 
    592 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8)
    593 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16)
    594 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32)
    595 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64)
    596 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8)
    597 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16)
    598 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32)
    599 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64)
    600 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32)
    601 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64)
    602 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32)
    603 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64)
    604 

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

    r1260 r1261  
    1010 *  @author George Gusciora, MHPCC
    1111 *
    12  *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2004-07-22 20:02:57 $
     12 *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2004-07-22 20:09:04 $
    1414 *
    1515 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424#include "psStats.h"
    2525#include "psFunctions.h"
    26 
    27 typedef enum {
    28     PS_INTERPOLATE_FLAT,
    29     PS_INTERPOLATE_BILINEAR
    30 } psImageInterpolateMode;
    3126
    3227/// This routine must determine the various statistics for the image.
    … …  
    5651
    5752
    58 psF32 psImagePixelInterpolate(
    59     const psImage *input,
    60     float x,
    61     float y,
    62     psF32 unexposedValue,
    63     psImageInterpolateMode mode
    64 );
    65 
    66 #define p_psImagePixelInterpolateFcns(TYPE) \
    67 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \
    68         const psImage *input, \
    69         float x, \
    70         float y, \
    71         psF64 unexposedValue \
    72                                                  ); \
    73 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
    74         const psImage *input, \
    75         float x, \
    76         float y, \
    77         psF64 unexposedValue \
    78                                                      );
    79 
    80 #define p_psImagePixelInterpolateComplexFcns(TYPE) \
    81 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \
    82         const psImage *input, \
    83         float x, \
    84         float y, \
    85         psC64 unexposedValue \
    86                                                  ); \
    87 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
    88         const psImage *input, \
    89         float x, \
    90         float y, \
    91         psC64 unexposedValue \
    92                                                      );
    93 
    94 p_psImagePixelInterpolateFcns(U8)
    95 p_psImagePixelInterpolateFcns(U16)
    96 p_psImagePixelInterpolateFcns(U32)
    97 p_psImagePixelInterpolateFcns(U64)
    98 p_psImagePixelInterpolateFcns(S8)
    99 p_psImagePixelInterpolateFcns(S16)
    100 p_psImagePixelInterpolateFcns(S32)
    101 p_psImagePixelInterpolateFcns(S64)
    102 p_psImagePixelInterpolateFcns(F32)
    103 p_psImagePixelInterpolateFcns(F64)
    104 p_psImagePixelInterpolateComplexFcns(C32)
    105 p_psImagePixelInterpolateComplexFcns(C64)
    10653
    10754#endif

  • trunk/psLib/src/imageops/psImageStats.c

    r1260 r1261  
    369369    return(0);
    370370}
    371 
    372 /*****************************************************************************
    373 p_psImagePixelInterpolation(image, x, y): this routine takes as input an
    374 image and coordinates (x, y) and produces as output the corresponding pixel
    375 value at the those coordinates.  For fractional corrdinates (x, y), 2-D
    376 linear interpolation is performed on the image.
    377  *****************************************************************************/
    378 psF32 psImagePixelInterpolate(
    379     const psImage *input,
    380     float x,
    381     float y,
    382     psF32 unexposedValue,
    383     psImageInterpolateMode mode)
    384 {
    385 
    386     if (input == NULL) {
    387         psError(__func__,"Image can not be NULL.");
    388         return unexposedValue;
    389     }
    390 
    391     #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \
    392 case PS_TYPE_##TYPE: \
    393     switch (mode) { \
    394     case PS_INTERPOLATE_FLAT: \
    395         return p_psImagePixelInterpolateFLAT_##TYPE(input,x,y,unexposedValue); \
    396         break; \
    397     case PS_INTERPOLATE_BILINEAR: \
    398         return p_psImagePixelInterpolateBILINEAR_##TYPE(input,x,y,unexposedValue); \
    399         break; \
    400     default: \
    401         psError(__func__,"Unsupported interpolation mode (#%d)",mode); \
    402     } \
    403     break
    404 
    405     switch (input->type.type) {
    406         PSIMAGE_PIXEL_INTERPOLATE_CASE(U8);
    407         PSIMAGE_PIXEL_INTERPOLATE_CASE(U16);
    408         PSIMAGE_PIXEL_INTERPOLATE_CASE(U32);
    409         PSIMAGE_PIXEL_INTERPOLATE_CASE(U64);
    410         PSIMAGE_PIXEL_INTERPOLATE_CASE(S8);
    411         PSIMAGE_PIXEL_INTERPOLATE_CASE(S16);
    412         PSIMAGE_PIXEL_INTERPOLATE_CASE(S32);
    413         PSIMAGE_PIXEL_INTERPOLATE_CASE(S64);
    414         PSIMAGE_PIXEL_INTERPOLATE_CASE(F32);
    415         PSIMAGE_PIXEL_INTERPOLATE_CASE(F64);
    416         PSIMAGE_PIXEL_INTERPOLATE_CASE(C32);
    417         PSIMAGE_PIXEL_INTERPOLATE_CASE(C64);
    418     default:
    419         psError(__func__,"Unsupported image datatype (%d)",input->type.type);
    420     }
    421 
    422     return unexposedValue;
    423 }
    424 
    425 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \
    426 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
    427         float x, \
    428         float y, \
    429         psF64 unexposedValue) \
    430 { \
    431     int intX = (int) round((psF64)(x) - 0.5); \
    432     int intY = (int) round((psF64)(y) - 0.5); \
    433     int lastX = input->numCols - 1; \
    434     int lastY = input->numRows - 1; \
    435     \
    436     if ((intX < 0) || \
    437             (intX > lastX) || \
    438             (intY < 0) || \
    439             (intY > lastY)) { \
    440         return unexposedValue; \
    441     } \
    442     \
    443     return input->data.TYPE[intY][intX]; \
    444 }
    445 
    446 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \
    447 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
    448         float x, \
    449         float y, \
    450         psC64 unexposedValue) \
    451 { \
    452     int intX = (int) round((psF64)(x) - 0.5); \
    453     int intY = (int) round((psF64)(y) - 0.5); \
    454     int lastX = input->numCols - 1; \
    455     int lastY = input->numRows - 1; \
    456     \
    457     if ((intX < 0) || \
    458             (intX > lastX) || \
    459             (intY < 0) || \
    460             (intY > lastY)) { \
    461         return unexposedValue; \
    462     } \
    463     \
    464     return input->data.TYPE[intY][intX]; \
    465 }
    466 
    467 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8)
    468 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16)
    469 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32)
    470 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64)
    471 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8)
    472 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16)
    473 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32)
    474 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64)
    475 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32)
    476 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64)
    477 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32)
    478 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64)
    479 
    480 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \
    481 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
    482         float x, \
    483         float y, \
    484         psF64 unexposedValue) \
    485 { \
    486     double floorX = floor((psF64)(x) - 0.5); \
    487     double floorY = floor((psF64)(y) - 0.5); \
    488     double fracX = x - 0.5 - floorX; \
    489     double fracY = y - 0.5 - floorY; \
    490     int intFloorX = (int) floorX; \
    491     int intFloorY = (int) floorY; \
    492     int lastX = input->numCols - 1; \
    493     int lastY = input->numRows - 1; \
    494     double rx = 0.0; \
    495     psF64 pixel = 0.0; \
    496     ps##TYPE* currentRow; \
    497     ps##TYPE* nextRow; \
    498     \
    499     if ((intFloorX < 0) || \
    500             (intFloorX > lastX) || \
    501             (intFloorY < 0) || \
    502             (intFloorY > lastY)) { \
    503         return unexposedValue; \
    504     } \
    505     \
    506     currentRow = input->data.TYPE[intFloorY]; \
    507     if (intFloorY == lastY) { \
    508         pixel = currentRow[intFloorX]; \
    509         if (intFloorX < lastX) { \
    510             pixel+= fracY * ((psF64)currentRow[intFloorX+1] - \
    511                              (psF64)currentRow[intFloorX]); \
    512         } \
    513         return(pixel); \
    514     } \
    515     nextRow = input->data.TYPE[intFloorY+1]; \
    516     if (intFloorX == lastX) { \
    517         pixel = currentRow[intFloorX]; \
    518         if (intFloorY < lastY) { \
    519             pixel+= fracX * ((psF64)nextRow[intFloorX] - \
    520                              (psF64)currentRow[intFloorX]); \
    521         } \
    522         return(pixel); \
    523     } \
    524     \
    525     rx = currentRow[intFloorX] + \
    526          fracX * ((psF64)currentRow[intFloorX+1] - \
    527                   (psF64)currentRow[intFloorX]); \
    528     \
    529     pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
    530                           fracX * ((psF64)nextRow[intFloorX+1] - \
    531                                    (psF64)nextRow[intFloorX]) - rx); \
    532     \
    533     return(pixel); \
    534 }
    535 
    536 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \
    537 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
    538         float x, \
    539         float y, \
    540         psC64 unexposedValue) \
    541 { \
    542     double floorX = floor((psF64)(x) - 0.5); \
    543     double floorY = floor((psF64)(y) - 0.5); \
    544     double fracX = x - 0.5 - floorX; \
    545     double fracY = y - 0.5 - floorY; \
    546     int intFloorX = (int) floorX; \
    547     int intFloorY = (int) floorY; \
    548     int lastX = input->numCols - 1; \
    549     int lastY = input->numRows - 1; \
    550     double rx = 0.0; \
    551     psC64 pixel = 0.0; \
    552     ps##TYPE* currentRow; \
    553     ps##TYPE* nextRow; \
    554     \
    555     if ((intFloorX < 0) || \
    556             (intFloorX > lastX) || \
    557             (intFloorY < 0) || \
    558             (intFloorY > lastY)) { \
    559         return unexposedValue; \
    560     } \
    561     \
    562     currentRow = input->data.TYPE[intFloorY]; \
    563     if (intFloorY == lastY) { \
    564         pixel = currentRow[intFloorX]; \
    565         if (intFloorX < lastX) { \
    566             pixel+= fracY * (currentRow[intFloorX+1] - \
    567                              currentRow[intFloorX]); \
    568         } \
    569         return(pixel); \
    570     } \
    571     nextRow = input->data.TYPE[intFloorY+1]; \
    572     if (intFloorX == lastX) { \
    573         pixel = currentRow[intFloorX]; \
    574         if (intFloorY < lastY) { \
    575             pixel+= fracX * (nextRow[intFloorX] - \
    576                              currentRow[intFloorX]); \
    577         } \
    578         return(pixel); \
    579     } \
    580     \
    581     rx = currentRow[intFloorX] + \
    582          fracX * (currentRow[intFloorX+1] - \
    583                   currentRow[intFloorX]); \
    584     \
    585     pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
    586                           fracX * (nextRow[intFloorX+1] - \
    587                                    nextRow[intFloorX]) - rx); \
    588     \
    589     return(pixel); \
    590 }
    591 
    592 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8)
    593 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16)
    594 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32)
    595 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64)
    596 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8)
    597 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16)
    598 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32)
    599 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64)
    600 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32)
    601 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64)
    602 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32)
    603 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64)
    604 

  • trunk/psLib/src/imageops/psImageStats.h

    r1260 r1261  
    1010 *  @author George Gusciora, MHPCC
    1111 *
    12  *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2004-07-22 20:02:57 $
     12 *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2004-07-22 20:09:04 $
    1414 *
    1515 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424#include "psStats.h"
    2525#include "psFunctions.h"
    26 
    27 typedef enum {
    28     PS_INTERPOLATE_FLAT,
    29     PS_INTERPOLATE_BILINEAR
    30 } psImageInterpolateMode;
    3126
    3227/// This routine must determine the various statistics for the image.
    … …  
    5651
    5752
    58 psF32 psImagePixelInterpolate(
    59     const psImage *input,
    60     float x,
    61     float y,
    62     psF32 unexposedValue,
    63     psImageInterpolateMode mode
    64 );
    65 
    66 #define p_psImagePixelInterpolateFcns(TYPE) \
    67 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \
    68         const psImage *input, \
    69         float x, \
    70         float y, \
    71         psF64 unexposedValue \
    72                                                  ); \
    73 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
    74         const psImage *input, \
    75         float x, \
    76         float y, \
    77         psF64 unexposedValue \
    78                                                      );
    79 
    80 #define p_psImagePixelInterpolateComplexFcns(TYPE) \
    81 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \
    82         const psImage *input, \
    83         float x, \
    84         float y, \
    85         psC64 unexposedValue \
    86                                                  ); \
    87 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
    88         const psImage *input, \
    89         float x, \
    90         float y, \
    91         psC64 unexposedValue \
    92                                                      );
    93 
    94 p_psImagePixelInterpolateFcns(U8)
    95 p_psImagePixelInterpolateFcns(U16)
    96 p_psImagePixelInterpolateFcns(U32)
    97 p_psImagePixelInterpolateFcns(U64)
    98 p_psImagePixelInterpolateFcns(S8)
    99 p_psImagePixelInterpolateFcns(S16)
    100 p_psImagePixelInterpolateFcns(S32)
    101 p_psImagePixelInterpolateFcns(S64)
    102 p_psImagePixelInterpolateFcns(F32)
    103 p_psImagePixelInterpolateFcns(F64)
    104 p_psImagePixelInterpolateComplexFcns(C32)
    105 p_psImagePixelInterpolateComplexFcns(C64)
    10653
    10754#endif

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

    r1205 r1261  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-07-09 21:48:07 $
     11 *  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-07-22 20:09:04 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    400400}
    401401
     402/*****************************************************************************
     403p_psImagePixelInterpolation(image, x, y): this routine takes as input an
     404image and coordinates (x, y) and produces as output the corresponding pixel
     405value at the those coordinates.  For fractional corrdinates (x, y), 2-D
     406linear interpolation is performed on the image.
     407 *****************************************************************************/
     408psF32 psImagePixelInterpolate(
     409    const psImage *input,
     410    float x,
     411    float y,
     412    psF32 unexposedValue,
     413    psImageInterpolateMode mode)
     414{
     415
     416    if (input == NULL) {
     417        psError(__func__,"Image can not be NULL.");
     418        return unexposedValue;
     419    }
     420
     421    #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \
     422case PS_TYPE_##TYPE: \
     423    switch (mode) { \
     424    case PS_INTERPOLATE_FLAT: \
     425        return p_psImagePixelInterpolateFLAT_##TYPE(input,x,y,unexposedValue); \
     426        break; \
     427    case PS_INTERPOLATE_BILINEAR: \
     428        return p_psImagePixelInterpolateBILINEAR_##TYPE(input,x,y,unexposedValue); \
     429        break; \
     430    default: \
     431        psError(__func__,"Unsupported interpolation mode (#%d)",mode); \
     432    } \
     433    break
     434
     435    switch (input->type.type) {
     436        PSIMAGE_PIXEL_INTERPOLATE_CASE(U8);
     437        PSIMAGE_PIXEL_INTERPOLATE_CASE(U16);
     438        PSIMAGE_PIXEL_INTERPOLATE_CASE(U32);
     439        PSIMAGE_PIXEL_INTERPOLATE_CASE(U64);
     440        PSIMAGE_PIXEL_INTERPOLATE_CASE(S8);
     441        PSIMAGE_PIXEL_INTERPOLATE_CASE(S16);
     442        PSIMAGE_PIXEL_INTERPOLATE_CASE(S32);
     443        PSIMAGE_PIXEL_INTERPOLATE_CASE(S64);
     444        PSIMAGE_PIXEL_INTERPOLATE_CASE(F32);
     445        PSIMAGE_PIXEL_INTERPOLATE_CASE(F64);
     446        PSIMAGE_PIXEL_INTERPOLATE_CASE(C32);
     447        PSIMAGE_PIXEL_INTERPOLATE_CASE(C64);
     448    default:
     449        psError(__func__,"Unsupported image datatype (%d)",input->type.type);
     450    }
     451
     452    return unexposedValue;
     453}
     454
     455#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \
     456inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
     457        float x, \
     458        float y, \
     459        psF64 unexposedValue) \
     460{ \
     461    int intX = (int) round((psF64)(x) - 0.5); \
     462    int intY = (int) round((psF64)(y) - 0.5); \
     463    int lastX = input->numCols - 1; \
     464    int lastY = input->numRows - 1; \
     465    \
     466    if ((intX < 0) || \
     467            (intX > lastX) || \
     468            (intY < 0) || \
     469            (intY > lastY)) { \
     470        return unexposedValue; \
     471    } \
     472    \
     473    return input->data.TYPE[intY][intX]; \
     474}
     475
     476#define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \
     477inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage *input, \
     478        float x, \
     479        float y, \
     480        psC64 unexposedValue) \
     481{ \
     482    int intX = (int) round((psF64)(x) - 0.5); \
     483    int intY = (int) round((psF64)(y) - 0.5); \
     484    int lastX = input->numCols - 1; \
     485    int lastY = input->numRows - 1; \
     486    \
     487    if ((intX < 0) || \
     488            (intX > lastX) || \
     489            (intY < 0) || \
     490            (intY > lastY)) { \
     491        return unexposedValue; \
     492    } \
     493    \
     494    return input->data.TYPE[intY][intX]; \
     495}
     496
     497PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8)
     498PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16)
     499PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32)
     500PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64)
     501PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8)
     502PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16)
     503PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32)
     504PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64)
     505PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32)
     506PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64)
     507PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32)
     508PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64)
     509
     510#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \
     511inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
     512        float x, \
     513        float y, \
     514        psF64 unexposedValue) \
     515{ \
     516    double floorX = floor((psF64)(x) - 0.5); \
     517    double floorY = floor((psF64)(y) - 0.5); \
     518    double fracX = x - 0.5 - floorX; \
     519    double fracY = y - 0.5 - floorY; \
     520    int intFloorX = (int) floorX; \
     521    int intFloorY = (int) floorY; \
     522    int lastX = input->numCols - 1; \
     523    int lastY = input->numRows - 1; \
     524    double rx = 0.0; \
     525    psF64 pixel = 0.0; \
     526    ps##TYPE* currentRow; \
     527    ps##TYPE* nextRow; \
     528    \
     529    if ((intFloorX < 0) || \
     530            (intFloorX > lastX) || \
     531            (intFloorY < 0) || \
     532            (intFloorY > lastY)) { \
     533        return unexposedValue; \
     534    } \
     535    \
     536    currentRow = input->data.TYPE[intFloorY]; \
     537    if (intFloorY == lastY) { \
     538        pixel = currentRow[intFloorX]; \
     539        if (intFloorX < lastX) { \
     540            pixel+= fracY * ((psF64)currentRow[intFloorX+1] - \
     541                             (psF64)currentRow[intFloorX]); \
     542        } \
     543        return(pixel); \
     544    } \
     545    nextRow = input->data.TYPE[intFloorY+1]; \
     546    if (intFloorX == lastX) { \
     547        pixel = currentRow[intFloorX]; \
     548        if (intFloorY < lastY) { \
     549            pixel+= fracX * ((psF64)nextRow[intFloorX] - \
     550                             (psF64)currentRow[intFloorX]); \
     551        } \
     552        return(pixel); \
     553    } \
     554    \
     555    rx = currentRow[intFloorX] + \
     556         fracX * ((psF64)currentRow[intFloorX+1] - \
     557                  (psF64)currentRow[intFloorX]); \
     558    \
     559    pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
     560                          fracX * ((psF64)nextRow[intFloorX+1] - \
     561                                   (psF64)nextRow[intFloorX]) - rx); \
     562    \
     563    return(pixel); \
     564}
     565
     566#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \
     567inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage *input, \
     568        float x, \
     569        float y, \
     570        psC64 unexposedValue) \
     571{ \
     572    double floorX = floor((psF64)(x) - 0.5); \
     573    double floorY = floor((psF64)(y) - 0.5); \
     574    double fracX = x - 0.5 - floorX; \
     575    double fracY = y - 0.5 - floorY; \
     576    int intFloorX = (int) floorX; \
     577    int intFloorY = (int) floorY; \
     578    int lastX = input->numCols - 1; \
     579    int lastY = input->numRows - 1; \
     580    double rx = 0.0; \
     581    psC64 pixel = 0.0; \
     582    ps##TYPE* currentRow; \
     583    ps##TYPE* nextRow; \
     584    \
     585    if ((intFloorX < 0) || \
     586            (intFloorX > lastX) || \
     587            (intFloorY < 0) || \
     588            (intFloorY > lastY)) { \
     589        return unexposedValue; \
     590    } \
     591    \
     592    currentRow = input->data.TYPE[intFloorY]; \
     593    if (intFloorY == lastY) { \
     594        pixel = currentRow[intFloorX]; \
     595        if (intFloorX < lastX) { \
     596            pixel+= fracY * (currentRow[intFloorX+1] - \
     597                             currentRow[intFloorX]); \
     598        } \
     599        return(pixel); \
     600    } \
     601    nextRow = input->data.TYPE[intFloorY+1]; \
     602    if (intFloorX == lastX) { \
     603        pixel = currentRow[intFloorX]; \
     604        if (intFloorY < lastY) { \
     605            pixel+= fracX * (nextRow[intFloorX] - \
     606                             currentRow[intFloorX]); \
     607        } \
     608        return(pixel); \
     609    } \
     610    \
     611    rx = currentRow[intFloorX] + \
     612         fracX * (currentRow[intFloorX+1] - \
     613                  currentRow[intFloorX]); \
     614    \
     615    pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
     616                          fracX * (nextRow[intFloorX+1] - \
     617                                   nextRow[intFloorX]) - rx); \
     618    \
     619    return(pixel); \
     620}
     621
     622PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8)
     623PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16)
     624PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32)
     625PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64)
     626PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8)
     627PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16)
     628PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32)
     629PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64)
     630PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32)
     631PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64)
     632PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32)
     633PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64)
     634
     635

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

    r1205 r1261  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2004-07-09 21:48:07 $
     13 *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2004-07-22 20:09:04 $
    1515 *
    1616 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2525/// @addtogroup Image
    2626/// @{
     27
     28typedef enum {
     29    PS_INTERPOLATE_FLAT,
     30    PS_INTERPOLATE_BILINEAR
     31} psImageInterpolateMode;
    2732
    2833/** Basic image data structure.
    … …  
    137142);
    138143
     144psF32 psImagePixelInterpolate(
     145    const psImage *input,
     146    float x,
     147    float y,
     148    psF32 unexposedValue,
     149    psImageInterpolateMode mode
     150);
     151
     152#define p_psImagePixelInterpolateFcns(TYPE) \
     153inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \
     154        const psImage *input, \
     155        float x, \
     156        float y, \
     157        psF64 unexposedValue \
     158                                                 ); \
     159inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
     160        const psImage *input, \
     161        float x, \
     162        float y, \
     163        psF64 unexposedValue \
     164                                                     );
     165
     166#define p_psImagePixelInterpolateComplexFcns(TYPE) \
     167inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \
     168        const psImage *input, \
     169        float x, \
     170        float y, \
     171        psC64 unexposedValue \
     172                                                 ); \
     173inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
     174        const psImage *input, \
     175        float x, \
     176        float y, \
     177        psC64 unexposedValue \
     178                                                     );
     179
     180p_psImagePixelInterpolateFcns(U8)
     181p_psImagePixelInterpolateFcns(U16)
     182p_psImagePixelInterpolateFcns(U32)
     183p_psImagePixelInterpolateFcns(U64)
     184p_psImagePixelInterpolateFcns(S8)
     185p_psImagePixelInterpolateFcns(S16)
     186p_psImagePixelInterpolateFcns(S32)
     187p_psImagePixelInterpolateFcns(S64)
     188p_psImagePixelInterpolateFcns(F32)
     189p_psImagePixelInterpolateFcns(F64)
     190p_psImagePixelInterpolateComplexFcns(C32)
     191p_psImagePixelInterpolateComplexFcns(C64)
     192
    139193/// @}
    140194
Note: See TracChangeset for help on using the changeset viewer.