IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 17, 2005, 4:35:15 PM (21 years ago)
Author:
desonia
Message:

added BILINEAR_VARIANCE interpolation mode.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3442 r3446  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.60 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-03-17 19:02:01 $
     11 *  @version $Revision: 1.61 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-03-18 02:35:14 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2626
    2727#include "psImageErrors.h"
     28
     29#define SQUARE(x) ((x)*(x))
     30#define MIN(x,y) (((x) > (y)) ? (y) : (x))
     31#define MAX(x,y) (((x) > (y)) ? (x) : (y))
    2832
    2933static void imageFree(psImage* image)
    … …  
    116120}
    117121
    118 
    119 
    120122psRegion* psRegionFromString(char* region)
    121123{
    … …  
    165167    return psStringCopy(tmpText);
    166168}
    167 
    168169
    169170psImage* psImageRecycle(psImage* old,
    … …  
    428429    }
    429430
    430     #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE)                     \
     431    #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE)                             \
    431432case PS_TYPE_##TYPE:                                                 \
    432433    switch (mode) {                                                  \
    … …  
    449450                unexposedValue);                                     \
    450451        break;                                                       \
     452    case PS_INTERPOLATE_BILINEAR_VARIANCE:                           \
     453        return p_psImagePixelInterpolateBILINEAR_VARIANCE_##TYPE(    \
     454                input,                                               \
     455                x,                                                   \
     456                y,                                                   \
     457                mask,                                                \
     458                maskVal,                                             \
     459                unexposedValue);                                     \
     460        break;                                                       \
    451461    default:                                                         \
    452462        psError(PS_ERR_BAD_PARAMETER_VALUE,true,                     \
    … …  
    454464                mode);                                               \
    455465    }                                                                \
    456     break
     466    break;
    457467
    458468    switch (input->type.type) {
    … …  
    481491}
    482492
    483 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \
    484 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \
     493#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE,RETURNTYPE) \
     494inline RETURNTYPE p_psImagePixelInterpolateFLAT_##TYPE( \
     495        const psImage* input, \
    485496        float x, \
    486497        float y, \
    487498        const psImage* mask, \
    488499        psU32 maskVal, \
    489         psF64 unexposedValue) \
     500        RETURNTYPE unexposedValue) \
    490501{ \
    491502    psS32 intX = (psS32) round((psF64)(x) - 0.5 + FLT_EPSILON); \
    … …  
    506517}
    507518
    508 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \
    509 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \
     519PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8,psF64)
     520PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16,psF64)
     521PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32,psF64)
     522PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64,psF64)
     523PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8,psF64)
     524PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16,psF64)
     525PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32,psF64)
     526PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64,psF64)
     527PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32,psF64)
     528PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64,psF64)
     529PSIMAGE_PIXEL_INTERPOLATE_FLAT(C32,psC64)
     530PSIMAGE_PIXEL_INTERPOLATE_FLAT(C64,psC64)
     531
     532#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE, RETURNTYPE, SUFFIX, FRACFUNC) \
     533inline RETURNTYPE p_psImagePixelInterpolateBILINEAR_##SUFFIX( \
     534        const psImage* input, \
    510535        float x, \
    511536        float y, \
    512537        const psImage* mask, \
    513538        psU32 maskVal, \
    514         psC64 unexposedValue) \
    515 { \
    516     psS32 intX = (psS32) round((psF64)(x) - 0.5); \
    517     psS32 intY = (psS32) round((psF64)(y) - 0.5); \
    518     psS32 lastX = input->numCols - 1; \
    519     psS32 lastY = input->numRows - 1; \
    520     \
    521     if ((intX < 0) || \
    522             (intX > lastX) || \
    523             (intY < 0) || \
    524             (intY > lastY) || \
    525             ( (mask!=NULL) && \
    526               ((mask->data.PS_TYPE_MASK_DATA[intY][intX] & maskVal) != 0) ) ) { \
    527         return unexposedValue; \
    528     } \
    529     \
    530     return input->data.TYPE[intY][intX]; \
    531 }
    532 
    533 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8)
    534 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16)
    535 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32)
    536 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64)
    537 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8)
    538 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16)
    539 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32)
    540 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64)
    541 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32)
    542 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64)
    543 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32)
    544 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64)
    545 
    546 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \
    547 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \
    548         float x, \
    549         float y, \
    550         const psImage* mask, \
    551         psU32 maskVal, \
    552         psF64 unexposedValue) \
     539        RETURNTYPE unexposedValue) \
    553540{ \
    554541    double floorX = floor((psF64)(x) - 0.5); \
    … …  
    597584    if (valid00 && valid10 && valid01 && valid11) { \
    598585        /* formula from the ADD */ \
    599         psF64 rx = V00 + (V10-V00)*fracX; \
    600         return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \
     586        return V00*FRACFUNC((1.0-fracX)*(1.0-fracY)) + V10*FRACFUNC(fracX*(1.0-fracY)) + \
     587               V01*FRACFUNC(fracY*(1.0-fracX)) + V11*FRACFUNC(fracX*fracY); \
    601588    } \
    602589    \
    603590    /* OK, at least one pixel is not valid - need to do it piecemeal */ \
    604591    \
    605     psF64 V0 = 0.0; \
     592    RETURNTYPE V0 = 0.0; \
    606593    psBool valid0 = true; \
    607594    if (valid00 && valid10) { \
    608         V0 = V00*(1-fracX)+V10*fracX; \
     595        V0 = V00*FRACFUNC(1-fracX)+V10*FRACFUNC(fracX); \
    609596    } else if (valid00) { \
    610597        V0 = V00; \
    … …  
    615602    } \
    616603    \
    617     psF64 V1 = 0.0; \
     604    RETURNTYPE V1 = 0.0; \
    618605    psBool valid1 = true; \
    619606    if (valid01 && valid11) { \
    620         V1 = V01*(1-fracX)+V11*fracX; \
     607        V1 = V01*FRACFUNC(1-fracX)+V11*FRACFUNC(fracX); \
    621608    } else if (valid01) { \
    622609        V1 = V01; \
    … …  
    628615    \
    629616    if (valid0 && valid1) { \
    630         return ( V0*(1-fracY) + V1*fracY ); \
     617        return V0*FRACFUNC(1-fracY) + V1*FRACFUNC(fracY); \
    631618    } else if (valid0) { \
    632619        return V0; \
    … …  
    638625}
    639626
    640 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \
    641 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \
    642         float x, \
    643         float y, \
    644         const psImage* mask, \
    645         psU32 maskVal, \
    646         psC64 unexposedValue) \
    647 { \
    648     double floorX = floor((psF64)(x) - 0.5); \
    649     double floorY = floor((psF64)(y) - 0.5); \
    650     psF64 fracX = x - 0.5 - floorX; \
    651     psF64 fracY = y - 0.5 - floorY; \
    652     psS32 intFloorX = (psS32) floorX; \
    653     psS32 intFloorY = (psS32) floorY; \
    654     psS32 lastX = input->numCols - 1; \
    655     psS32 lastY = input->numRows - 1; \
    656     ps##TYPE V00 = 0; \
    657     ps##TYPE V01 = 0; \
    658     ps##TYPE V10 = 0; \
    659     ps##TYPE V11 = 0; \
    660     psBool valid00 = false; \
    661     psBool valid01 = false; \
    662     psBool valid10 = false; \
    663     psBool valid11 = false; \
    664     \
    665     if (intFloorY >= 0 && intFloorY <= lastY) { \
    666         if (intFloorX >= 0 && intFloorX <= lastX) { \
    667             V00 = input->data.TYPE[intFloorY][intFloorX]; \
    668             valid00 = (mask == NULL) || \
    669                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX] & maskVal) == 0); \
    670         } \
    671         if (intFloorX >= -1 && intFloorX < lastX) { \
    672             V10 = input->data.TYPE[intFloorY][intFloorX+1]; \
    673             valid10 = (mask == NULL) || \
    674                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX+1] & maskVal) == 0); \
    675         } \
    676     } \
    677     if (intFloorY >= -1 && intFloorY < lastY) { \
    678         if (intFloorX >= 0 && intFloorX <= lastX) { \
    679             V01 = input->data.TYPE[intFloorY+1][intFloorX]; \
    680             valid01 = (mask == NULL) || \
    681                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX] & maskVal) == 0); \
    682         } \
    683         if (intFloorX >= -1 && intFloorX < lastX) { \
    684             V11 = input->data.TYPE[intFloorY+1][intFloorX+1]; \
    685             valid11 = (mask == NULL) || \
    686                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX+1] & maskVal) == 0); \
    687         } \
    688     } \
    689     \
    690     /* cover likely case of all pixels being valid */  \
    691     if (valid00 && valid10 && valid01 && valid11) { \
    692         /* formula from the ADD */ \
    693         psC64 rx = V00 + (V10-V00)*fracX; \
    694         return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \
    695     } \
    696     \
    697     /* OK, at least one pixel is not valid - need to do it piecemeal */ \
    698     \
    699     psC64 V0 = 0; \
    700     psBool valid0 = true; \
    701     if (valid00 && valid10) { \
    702         V0 = V00*(1-fracX)+V10*fracX; \
    703     } else if (valid00) { \
    704         V0 = V00; \
    705     } else if (valid10) { \
    706         V0 = V10; \
    707     } else { \
    708         valid0 = false; \
    709     } \
    710     \
    711     psC64 V1 = 0; \
    712     psBool valid1 = true; \
    713     if (valid01 && valid11) { \
    714         V0 = V01*(1-fracX)+V11*fracX; \
    715     } else if (valid01) { \
    716         V0 = V01; \
    717     } else if (valid11) { \
    718         V0 = V11; \
    719     } else { \
    720         valid1 = false; \
    721     } \
    722     \
    723     if (valid0 && valid1) { \
    724         return ( V0*(1-fracY) + V1*fracY ); \
    725     } else if (valid0) { \
    726         return V0; \
    727     } else if (valid1) { \
    728         return V1; \
    729     } \
    730     \
    731     return unexposedValue; \
    732 }
    733 
    734 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8)
    735 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16)
    736 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32)
    737 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64)
    738 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8)
    739 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16)
    740 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32)
    741 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64)
    742 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32)
    743 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64)
    744 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32)
    745 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64)
     627PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,U8,)
     628PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,U16,)
     629PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,U32,)
     630PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,U64,)
     631PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,S8,)
     632PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,S16,)
     633PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,S32,)
     634PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,S64,)
     635PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,F32,)
     636PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,F64,)
     637PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,C32,)
     638PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,C64,)
     639
     640// Variance Version
     641PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,VARIANCE_U8,SQUARE)
     642PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,VARIANCE_U16,SQUARE)
     643PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,VARIANCE_U32,SQUARE)
     644PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,VARIANCE_U64,SQUARE)
     645PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,VARIANCE_S8,SQUARE)
     646PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,VARIANCE_S16,SQUARE)
     647PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,VARIANCE_S32,SQUARE)
     648PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,VARIANCE_S64,SQUARE)
     649PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,VARIANCE_F32,SQUARE)
     650PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,VARIANCE_F64,SQUARE)
     651PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,VARIANCE_C32,SQUARE)
     652PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,VARIANCE_C64,SQUARE)
Note: See TracChangeset for help on using the changeset viewer.