IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Sep 24, 2004, 4:06:12 PM (22 years ago)
Author:
desonia
Message:

added psImageRadialCut. Untested, but compiles.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1841 r1897  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2004-09-21 23:15:04 $
     12 *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2004-09-25 02:06:12 $
    1414 *
    1515 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    199199                              float x,
    200200                              float y,
     201                              const psImage* mask,
     202                              unsigned int maskVal,
    201203                              psC64 unexposedValue,
    202204                              psImageInterpolateMode mode)
    … …  
    214216    switch (mode) {                                                  \
    215217    case PS_INTERPOLATE_FLAT:                                        \
    216         return p_psImagePixelInterpolateFLAT_##TYPE(input, x, y,     \
     218        return p_psImagePixelInterpolateFLAT_##TYPE(                 \
     219                input,                                               \
     220                x,                                                   \
     221                y,                                                   \
     222                mask,                                                \
     223                maskVal,                                             \
    217224                unexposedValue);                                     \
    218225        break;                                                       \
    219226    case PS_INTERPOLATE_BILINEAR:                                    \
    220         return p_psImagePixelInterpolateBILINEAR_##TYPE(input,x,y,   \
     227        return p_psImagePixelInterpolateBILINEAR_##TYPE(             \
     228                input,                                               \
     229                x,                                                   \
     230                y,                                                   \
     231                mask,                                                \
     232                maskVal,                                             \
    221233                unexposedValue);                                     \
    222234        break;                                                       \
    … …  
    259271        float x, \
    260272        float y, \
     273        const psImage* mask, \
     274        unsigned int maskVal, \
    261275        psF64 unexposedValue) \
    262276{ \
    … …  
    269283            (intX > lastX) || \
    270284            (intY < 0) || \
    271             (intY > lastY)) { \
     285            (intY > lastY) || \
     286            ( (mask!=NULL) && \
     287              ((mask->data.PS_TYPE_MASK_DATA[intY][intX] & maskVal) != 0) ) ) { \
    272288        return unexposedValue; \
    273289    } \
    … …  
    280296        float x, \
    281297        float y, \
     298        const psImage* mask, \
     299        unsigned int maskVal, \
    282300        psC64 unexposedValue) \
    283301{ \
    … …  
    290308            (intX > lastX) || \
    291309            (intY < 0) || \
    292             (intY > lastY)) { \
     310            (intY > lastY) || \
     311            ( (mask!=NULL) && \
     312              ((mask->data.PS_TYPE_MASK_DATA[intY][intX] & maskVal) != 0) ) ) { \
    293313        return unexposedValue; \
    294314    } \
    … …  
    314334        float x, \
    315335        float y, \
     336        const psImage* mask, \
     337        unsigned int maskVal, \
    316338        psF64 unexposedValue) \
    317339{ \
    318340    double floorX = floor((psF64)(x) - 0.5); \
    319341    double floorY = floor((psF64)(y) - 0.5); \
    320     double fracX = x - 0.5 - floorX; \
    321     double fracY = y - 0.5 - floorY; \
     342    psF64 fracX = x - 0.5 - floorX; \
     343    psF64 fracY = y - 0.5 - floorY; \
    322344    int intFloorX = (int) floorX; \
    323345    int intFloorY = (int) floorY; \
    324346    int lastX = input->numCols - 1; \
    325347    int lastY = input->numRows - 1; \
    326     double rx = 0.0; \
    327     psF64 pixel = 0.0; \
    328     ps##TYPE* currentRow; \
    329     ps##TYPE* nextRow; \
    330     \
    331     if ((intFloorX < 0) || \
    332             (intFloorX > lastX) || \
    333             (intFloorY < 0) || \
    334             (intFloorY > lastY)) { \
    335         return unexposedValue; \
    336     } \
    337     \
    338     currentRow = input->data.TYPE[intFloorY]; \
    339     if (intFloorY == lastY) { \
    340         pixel = currentRow[intFloorX]; \
    341         if (intFloorX < lastX) { \
    342             pixel+= fracY * ((psF64)currentRow[intFloorX+1] - \
    343                              (psF64)currentRow[intFloorX]); \
    344         } \
    345         return(pixel); \
    346     } \
    347     nextRow = input->data.TYPE[intFloorY+1]; \
    348     if (intFloorX == lastX) { \
    349         pixel = currentRow[intFloorX]; \
    350         if (intFloorY < lastY) { \
    351             pixel+= fracX * ((psF64)nextRow[intFloorX] - \
    352                              (psF64)currentRow[intFloorX]); \
    353         } \
    354         return(pixel); \
    355     } \
    356     \
    357     rx = currentRow[intFloorX] + \
    358          fracX * ((psF64)currentRow[intFloorX+1] - \
    359                   (psF64)currentRow[intFloorX]); \
    360     \
    361     pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
    362                           fracX * ((psF64)nextRow[intFloorX+1] - \
    363                                    (psF64)nextRow[intFloorX]) - rx); \
    364     \
    365     return(pixel); \
    366 }
     348    ps##TYPE V00; \
     349    ps##TYPE V01; \
     350    ps##TYPE V10; \
     351    ps##TYPE V11; \
     352    bool valid00 = false; \
     353    bool valid01 = false; \
     354    bool valid10 = false; \
     355    bool valid11 = false; \
     356    \
     357    if (intFloorY >= 0 && intFloorY <= lastY) { \
     358        if (intFloorX >= 0 && intFloorX <= lastX) { \
     359            V00 = input->data.TYPE[intFloorY][intFloorX]; \
     360            valid00 = (mask == NULL) || \
     361                      ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX] & maskVal) == 0); \
     362        } \
     363        if (intFloorX >= -1 && intFloorX < lastX) { \
     364            V10 = input->data.TYPE[intFloorY][intFloorX+1]; \
     365            valid10 = (mask == NULL) || \
     366                      ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX+1] & maskVal) == 0); \
     367        } \
     368    } \
     369    if (intFloorY >= -1 && intFloorY < lastY) { \
     370        if (intFloorX >= 0 && intFloorX <= lastX) { \
     371            V01 = input->data.TYPE[intFloorY+1][intFloorX]; \
     372            valid01 = (mask == NULL) || \
     373                      ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX] & maskVal) == 0); \
     374        } \
     375        if (intFloorX >= -1 && intFloorX < lastX) { \
     376            V11 = input->data.TYPE[intFloorY+1][intFloorX+1]; \
     377            valid11 = (mask == NULL) || \
     378                      ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX+1] & maskVal) == 0); \
     379        } \
     380    } \
     381    \
     382    /* cover likely case of all pixels being valid more efficiently */  \
     383    if (valid00 && valid10 && valid01 && valid11) { \
     384        /* formula from the ADD */ \
     385        psF64 rx = V00 + (V10-V00)*fracX; \
     386        return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \
     387    } \
     388    \
     389    /* OK, at least one pixel is not valid - need to do it piecemeal */ \
     390    \
     391    psF64 V0; \
     392    bool valid0 = true; \
     393    if (valid00 && valid10) { \
     394        V0 = V00*(1-fracX)+V10*fracX; \
     395    } else if (valid00) { \
     396        V0 = V00; \
     397    } else if (valid10) { \
     398        V0 = V10; \
     399    } else { \
     400        valid0 = false; \
     401    } \
     402    \
     403    psF64 V1; \
     404    bool valid1 = true; \
     405    if (valid01 && valid11) { \
     406        V0 = V01*(1-fracX)+V11*fracX; \
     407    } else if (valid01) { \
     408        V0 = V01; \
     409    } else if (valid11) { \
     410        V0 = V11; \
     411    } else { \
     412        valid1 = false; \
     413    } \
     414    \
     415    if (valid0 && valid1) { \
     416        return ( V0*(1-fracY) + V1*fracY ); \
     417    } else if (valid0) { \
     418        return V0; \
     419    } else if (valid1) { \
     420        return V1; \
     421    } \
     422    \
     423    return unexposedValue; \
     424}
     425
    367426#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \
    368427inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \
    369428        float x, \
    370429        float y, \
     430        const psImage* mask, \
     431        unsigned int maskVal, \
    371432        psC64 unexposedValue) \
    372433{ \
    373434    double floorX = floor((psF64)(x) - 0.5); \
    374435    double floorY = floor((psF64)(y) - 0.5); \
    375     double fracX = x - 0.5 - floorX; \
    376     double fracY = y - 0.5 - floorY; \
     436    psF64 fracX = x - 0.5 - floorX; \
     437    psF64 fracY = y - 0.5 - floorY; \
    377438    int intFloorX = (int) floorX; \
    378439    int intFloorY = (int) floorY; \
    379440    int lastX = input->numCols - 1; \
    380441    int lastY = input->numRows - 1; \
    381     double rx = 0.0; \
    382     psC64 pixel = 0.0; \
    383     ps##TYPE* currentRow; \
    384     ps##TYPE* nextRow; \
    385     \
    386     if ((intFloorX < 0) || \
    387             (intFloorX > lastX) || \
    388             (intFloorY < 0) || \
    389             (intFloorY > lastY)) { \
    390         return unexposedValue; \
    391     } \
    392     \
    393     currentRow = input->data.TYPE[intFloorY]; \
    394     if (intFloorY == lastY) { \
    395         pixel = currentRow[intFloorX]; \
    396         if (intFloorX < lastX) { \
    397             pixel+= fracY * (currentRow[intFloorX+1] - \
    398                              currentRow[intFloorX]); \
    399         } \
    400         return(pixel); \
    401     } \
    402     nextRow = input->data.TYPE[intFloorY+1]; \
    403     if (intFloorX == lastX) { \
    404         pixel = currentRow[intFloorX]; \
    405         if (intFloorY < lastY) { \
    406             pixel+= fracX * (nextRow[intFloorX] - \
    407                              currentRow[intFloorX]); \
    408         } \
    409         return(pixel); \
    410     } \
    411     \
    412     rx = currentRow[intFloorX] + \
    413          fracX * (currentRow[intFloorX+1] - \
    414                   currentRow[intFloorX]); \
    415     \
    416     pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \
    417                           fracX * (nextRow[intFloorX+1] - \
    418                                    nextRow[intFloorX]) - rx); \
    419     \
    420     return(pixel); \
     442    ps##TYPE V00; \
     443    ps##TYPE V01; \
     444    ps##TYPE V10; \
     445    ps##TYPE V11; \
     446    bool valid00 = false; \
     447    bool valid01 = false; \
     448    bool valid10 = false; \
     449    bool valid11 = false; \
     450    \
     451    if (intFloorY >= 0 && intFloorY <= lastY) { \
     452        if (intFloorX >= 0 && intFloorX <= lastX) { \
     453            V00 = input->data.TYPE[intFloorY][intFloorX]; \
     454            valid00 = (mask == NULL) || \
     455                      ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX] & maskVal) == 0); \
     456        } \
     457        if (intFloorX >= -1 && intFloorX < lastX) { \
     458            V10 = input->data.TYPE[intFloorY][intFloorX+1]; \
     459            valid10 = (mask == NULL) || \
     460                      ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX+1] & maskVal) == 0); \
     461        } \
     462    } \
     463    if (intFloorY >= -1 && intFloorY < lastY) { \
     464        if (intFloorX >= 0 && intFloorX <= lastX) { \
     465            V01 = input->data.TYPE[intFloorY+1][intFloorX]; \
     466            valid01 = (mask == NULL) || \
     467                      ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX] & maskVal) == 0); \
     468        } \
     469        if (intFloorX >= -1 && intFloorX < lastX) { \
     470            V11 = input->data.TYPE[intFloorY+1][intFloorX+1]; \
     471            valid11 = (mask == NULL) || \
     472                      ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX+1] & maskVal) == 0); \
     473        } \
     474    } \
     475    \
     476    /* cover likely case of all pixels being valid */  \
     477    if (valid00 && valid10 && valid01 && valid11) { \
     478        /* formula from the ADD */ \
     479        psC64 rx = V00 + (V10-V00)*fracX; \
     480        return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \
     481    } \
     482    \
     483    /* OK, at least one pixel is not valid - need to do it piecemeal */ \
     484    \
     485    psC64 V0; \
     486    bool valid0 = true; \
     487    if (valid00 && valid10) { \
     488        V0 = V00*(1-fracX)+V10*fracX; \
     489    } else if (valid00) { \
     490        V0 = V00; \
     491    } else if (valid10) { \
     492        V0 = V10; \
     493    } else { \
     494        valid0 = false; \
     495    } \
     496    \
     497    psC64 V1; \
     498    bool valid1 = true; \
     499    if (valid01 && valid11) { \
     500        V0 = V01*(1-fracX)+V11*fracX; \
     501    } else if (valid01) { \
     502        V0 = V01; \
     503    } else if (valid11) { \
     504        V0 = V11; \
     505    } else { \
     506        valid1 = false; \
     507    } \
     508    \
     509    if (valid0 && valid1) { \
     510        return ( V0*(1-fracY) + V1*fracY ); \
     511    } else if (valid0) { \
     512        return V0; \
     513    } else if (valid1) { \
     514        return V1; \
     515    } \
     516    \
     517    return unexposedValue; \
    421518}
    422519
Note: See TracChangeset for help on using the changeset viewer.