IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 15253


Ignore:
Timestamp:
Oct 9, 2007, 9:24:46 AM (19 years ago)
Author:
eugene
Message:

changed mask to coeffMask, define PS_POLY_MASK_FIT,SET

Location:
trunk/psLib/src/math
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/math/psPolynomial.c

    r10999 r15253  
    77*  polynomials.  It also contains a Gaussian functions.
    88*
    9 *  @version $Revision: 1.157 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2007-01-09 22:38:53 $
     9*  @version $Revision: 1.158 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2007-10-09 19:24:46 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    9595    psFree(poly->coeff);
    9696    psFree(poly->coeffErr);
    97     psFree(poly->mask);
     97    psFree(poly->coeffMask);
    9898}
    9999
    … …  
    105105        psFree(poly->coeff[x]);
    106106        psFree(poly->coeffErr[x]);
    107         psFree(poly->mask[x]);
     107        psFree(poly->coeffMask[x]);
    108108    }
    109109    psFree(poly->coeff);
    110110    psFree(poly->coeffErr);
    111     psFree(poly->mask);
     111    psFree(poly->coeffMask);
    112112}
    113113
    … …  
    121121            psFree(poly->coeff[x][y]);
    122122            psFree(poly->coeffErr[x][y]);
    123             psFree(poly->mask[x][y]);
     123            psFree(poly->coeffMask[x][y]);
    124124        }
    125125        psFree(poly->coeff[x]);
    126126        psFree(poly->coeffErr[x]);
    127         psFree(poly->mask[x]);
     127        psFree(poly->coeffMask[x]);
    128128    }
    129129
    130130    psFree(poly->coeff);
    131131    psFree(poly->coeffErr);
    132     psFree(poly->mask);
     132    psFree(poly->coeffMask);
    133133}
    134134
    … …  
    144144                psFree(poly->coeff[x][y][z]);
    145145                psFree(poly->coeffErr[x][y][z]);
    146                 psFree(poly->mask[x][y][z]);
     146                psFree(poly->coeffMask[x][y][z]);
    147147            }
    148148            psFree(poly->coeff[x][y]);
    149149            psFree(poly->coeffErr[x][y]);
    150             psFree(poly->mask[x][y]);
     150            psFree(poly->coeffMask[x][y]);
    151151        }
    152152        psFree(poly->coeff[x]);
    153153        psFree(poly->coeffErr[x]);
    154         psFree(poly->mask[x]);
     154        psFree(poly->coeffMask[x]);
    155155    }
    156156
    157157    psFree(poly->coeff);
    158158    psFree(poly->coeffErr);
    159     psFree(poly->mask);
     159    psFree(poly->coeffMask);
    160160}
    161161
    … …  
    221221
    222222    for (loop_x = 0; loop_x < poly->nX+1; loop_x++) {
    223         if (poly->mask[loop_x] == 0) {
     223        if (!(poly->coeffMask[loop_x] & PS_POLY_MASK_SET)) {
    224224            psTrace("psLib.math", 8,
    225225                    "polysum+= sum*coeff [%lf+= (%lf * %lf)\n", polySum, xSum, poly->coeff[loop_x]);
    … …  
    251251    // Special case where the Chebyshev poly is constant.
    252252    if (nTerms == 1) {
    253         if (poly->mask[0] == 0) {
     253        if (!(poly->coeffMask[0] & PS_POLY_MASK_SET)) {
    254254            tmp += poly->coeff[0];
    255255        }
    … …  
    259259    // Special case where the Chebyshev poly is linear.
    260260    if (nTerms == 2) {
    261         if (poly->mask[0] == 0) {
     261        if (!(poly->coeffMask[0] & PS_POLY_MASK_SET)) {
    262262            tmp+= poly->coeff[0];
    263263        }
    264         if (poly->mask[1] == 0) {
     264        if (!(poly->coeffMask[1] & PS_POLY_MASK_SET)) {
    265265            tmp+= poly->coeff[1] * x;
    266266        }
    … …  
    271271        // General case where the Chebyshev poly has 2 or more terms.
    272272        d = psVectorAlloc(nTerms, PS_TYPE_F64);
    273         if(poly->mask[nTerms-1] == 0) {
     273        if (!(poly->coeffMask[nTerms-1] & PS_POLY_MASK_SET)) {
    274274            d->data.F64[nTerms-1] = poly->coeff[nTerms-1];
    275275        } else {
    … …  
    278278
    279279        d->data.F64[nTerms-2] = (2.0 * x * d->data.F64[nTerms-1]);
    280         if(poly->mask[nTerms-2] == 0) {
     280        if (!(poly->coeffMask[nTerms-2] & PS_POLY_MASK_SET)) {
    281281            d->data.F64[nTerms-2] += poly->coeff[nTerms-2];
    282282        }
    … …  
    284284        for (i=nTerms-3;i>=1;i--) {
    285285            d->data.F64[i] = (2.0 * x * d->data.F64[i+1]) - (d->data.F64[i+2]);
    286             if(poly->mask[i] == 0) {
     286            if (!(poly->coeffMask[i] & PS_POLY_MASK_SET)) {
    287287                d->data.F64[i] += poly->coeff[i];
    288288            }
    … …  
    290290
    291291        tmp = (x * d->data.F64[1]) - (d->data.F64[2]);
    292         if(poly->mask[0] == 0) {
     292        if (!(poly->coeffMask[0] & PS_POLY_MASK_SET)) {
    293293            tmp += (0.5 * poly->coeff[0]);
    294294        }
    … …  
    328328        ySum = xSum;
    329329        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
    330             if (poly->mask[loop_x][loop_y] == 0) {
     330            if (!(poly->coeffMask[loop_x][loop_y] & PS_POLY_MASK_SET)) {
    331331                polySum += ySum * poly->coeff[loop_x][loop_y];
    332332            }
    … …  
    364364    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
    365365        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
    366             if (poly->mask[loop_x][loop_y] == 0) {
     366            if (!(poly->coeffMask[loop_x][loop_y] & PS_POLY_MASK_SET)) {
    367367                polySum += poly->coeff[loop_x][loop_y] *
    368368                           psPolynomial1DEval(chebPolys[loop_x], x) *
    … …  
    396396            zSum = ySum;
    397397            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
    398                 if (poly->mask[loop_x][loop_y][loop_z] == 0) {
     398                if (!(poly->coeffMask[loop_x][loop_y][loop_z] & PS_POLY_MASK_SET)) {
    399399                    polySum += zSum * poly->coeff[loop_x][loop_y][loop_z];
    400400                }
    … …  
    439439        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
    440440            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
    441                 if (poly->mask[loop_x][loop_y][loop_z] == 0) {
     441                if (!(poly->coeffMask[loop_x][loop_y][loop_z] & PS_POLY_MASK_SET)) {
    442442                    polySum += poly->coeff[loop_x][loop_y][loop_z] *
    443443                               psPolynomial1DEval(chebPolys[loop_x], x) *
    … …  
    479479                tSum = zSum;
    480480                for (loop_t = 0; loop_t < (1 + poly->nT); loop_t++) {
    481                     if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
     481                    if (!(poly->coeffMask[loop_x][loop_y][loop_z][loop_t] & PS_POLY_MASK_SET)) {
    482482                        polySum += tSum * poly->coeff[loop_x][loop_y][loop_z][loop_t];
    483483                    }
    … …  
    532532            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
    533533                for (loop_t = 0; loop_t < (1 + poly->nT); loop_t++) {
    534                     if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
     534                    if (!(poly->coeffMask[loop_x][loop_y][loop_z][loop_t] & PS_POLY_MASK_SET)) {
    535535                        polySum += poly->coeff[loop_x][loop_y][loop_z][loop_t] *
    536536                                   psPolynomial1DEval(chebPolys[loop_x], x) *
    … …  
    596596    newPoly->coeff = psAlloc((nOrder + 1) * sizeof(psF64));
    597597    newPoly->coeffErr = psAlloc((nOrder + 1) * sizeof(psF64));
    598     newPoly->mask = (psMaskType *)psAlloc((nOrder + 1) * sizeof(psMaskType));
     598    newPoly->coeffMask = (psMaskType *)psAlloc((nOrder + 1) * sizeof(psMaskType));
    599599    for (psU32 i = 0; i < (nOrder + 1); i++) {
    600600        newPoly->coeff[i] = 0.0;
    601601        newPoly->coeffErr[i] = 0.0;
    602         newPoly->mask[i] = 0;
     602        newPoly->coeffMask[i] = PS_POLY_MASK_NONE;
    603603    }
    604604
    … …  
    626626    newPoly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
    627627    newPoly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
    628     newPoly->mask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
     628    newPoly->coeffMask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
    629629    for (x = 0; x < (1 + nX); x++) {
    630630        newPoly->coeff[x] = psAlloc((1 + nY) * sizeof(psF64));
    631631        newPoly->coeffErr[x] = psAlloc((1 + nY) * sizeof(psF64));
    632         newPoly->mask[x] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
     632        newPoly->coeffMask[x] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
    633633    }
    634634    for (x = 0; x < (1 + nX); x++) {
    … …  
    636636            newPoly->coeff[x][y] = 0.0;
    637637            newPoly->coeffErr[x][y] = 0.0;
    638             newPoly->mask[x][y] = 0;
     638            newPoly->coeffMask[x][y] = PS_POLY_MASK_NONE;
    639639        }
    640640    }
    … …  
    661661            psFree (poly->coeff[i]);
    662662            psFree (poly->coeffErr[i]);
    663             psFree (poly->mask[i]);
     663            psFree (poly->coeffMask[i]);
    664664        }
    665665        psFree (poly->coeff);
    666666        psFree (poly->coeffErr);
    667         psFree (poly->mask);
     667        psFree (poly->coeffMask);
    668668
    669669        poly->type = type;
    … …  
    673673        poly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
    674674        poly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
    675         poly->mask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
     675        poly->coeffMask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
    676676        for (int i = 0; i < (1 + nX); i++) {
    677677            poly->coeff[i] = psAlloc((1 + nY) * sizeof(psF64));
    678678            poly->coeffErr[i] = psAlloc((1 + nY) * sizeof(psF64));
    679             poly->mask[i] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
     679            poly->coeffMask[i] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
    680680        }
    681681    }
    … …  
    684684            poly->coeff[i][j] = 0.0;
    685685            poly->coeffErr[i][j] = 0.0;
    686             poly->mask[i][j] = 0;
     686            poly->coeffMask[i][j] = PS_POLY_MASK_NONE;
    687687        }
    688688    }
    … …  
    704704            out->coeff[i][j] = poly->coeff[i][j];
    705705            out->coeffErr[i][j] = poly->coeffErr[i][j];
    706             out->mask[i][j] = poly->mask[i][j];
     706            out->coeffMask[i][j] = poly->coeffMask[i][j];
    707707        }
    708708    }
    … …  
    737737    newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 **));
    738738    newPoly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 **));
    739     newPoly->mask = (psMaskType ***)psAlloc((nX + 1) * sizeof(psMaskType **));
     739    newPoly->coeffMask = (psMaskType ***)psAlloc((nX + 1) * sizeof(psMaskType **));
    740740    for (x = 0; x < (1 + nX); x++) {
    741741        newPoly->coeff[x] = psAlloc((nY + 1) * sizeof(psF64 *));
    742742        newPoly->coeffErr[x] = psAlloc((nY + 1) * sizeof(psF64 *));
    743         newPoly->mask[x] = (psMaskType **)psAlloc((nY + 1) * sizeof(psMaskType *));
     743        newPoly->coeffMask[x] = (psMaskType **)psAlloc((nY + 1) * sizeof(psMaskType *));
    744744        for (y = 0; y < (nY + 1); y++) {
    745745            newPoly->coeff[x][y] = psAlloc((nZ + 1) * sizeof(psF64));
    746746            newPoly->coeffErr[x][y] = psAlloc((nZ + 1) * sizeof(psF64));
    747             newPoly->mask[x][y] = (psMaskType *)psAlloc((nZ + 1) * sizeof(psMaskType));
     747            newPoly->coeffMask[x][y] = (psMaskType *)psAlloc((nZ + 1) * sizeof(psMaskType));
    748748        }
    749749    }
    … …  
    753753                newPoly->coeff[x][y][z] = 0.0;
    754754                newPoly->coeffErr[x][y][z] = 0.0;
    755                 newPoly->mask[x][y][z] = 0;
     755                newPoly->coeffMask[x][y][z] = PS_POLY_MASK_NONE;
    756756            }
    757757        }
    … …  
    792792    newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 ***));
    793793    newPoly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 ***));
    794     newPoly->mask = (psMaskType ****)psAlloc((nX + 1) * sizeof(psMaskType ***));
     794    newPoly->coeffMask = (psMaskType ****)psAlloc((nX + 1) * sizeof(psMaskType ***));
    795795    for (x = 0; x < (nX + 1); x++) {
    796796        newPoly->coeff[x] = psAlloc((nY + 1) * sizeof(psF64 **));
    797797        newPoly->coeffErr[x] = psAlloc((nY + 1) * sizeof(psF64 **));
    798         newPoly->mask[x] = (psMaskType ***)psAlloc((nY + 1) * sizeof(psMaskType **));
     798        newPoly->coeffMask[x] = (psMaskType ***)psAlloc((nY + 1) * sizeof(psMaskType **));
    799799        for (y = 0; y < (nY + 1); y++) {
    800800            newPoly->coeff[x][y] = psAlloc((nZ + 1) * sizeof(psF64 *));
    801801            newPoly->coeffErr[x][y] = psAlloc((nZ + 1) * sizeof(psF64 *));
    802             newPoly->mask[x][y] = (psMaskType **)psAlloc((nZ + 1) * sizeof(psMaskType *));
     802            newPoly->coeffMask[x][y] = (psMaskType **)psAlloc((nZ + 1) * sizeof(psMaskType *));
    803803            for (z = 0; z < (nZ + 1); z++) {
    804804                newPoly->coeff[x][y][z] = psAlloc((nT + 1) * sizeof(psF64));
    805805                newPoly->coeffErr[x][y][z] = psAlloc((nT + 1) * sizeof(psF64));
    806                 newPoly->mask[x][y][z] = (psMaskType *)psAlloc((nT + 1) * sizeof(psMaskType));
     806                newPoly->coeffMask[x][y][z] = (psMaskType *)psAlloc((nT + 1) * sizeof(psMaskType));
    807807            }
    808808        }
    … …  
    814814                    newPoly->coeff[x][y][z][t] = 0.0;
    815815                    newPoly->coeffErr[x][y][z][t] = 0.0;
    816                     newPoly->mask[x][y][z][t] = 0;
     816                    newPoly->coeffMask[x][y][z][t] = PS_POLY_MASK_NONE;
    817817                }
    818818            }

  • trunk/psLib/src/math/psPolynomial.h

    r14452 r15253  
    88 * @author GLG, MHPCC
    99 *
    10  * @version $Revision: 1.68 $ $Name: not supported by cvs2svn $
    11  * @date $Date: 2007-08-09 01:40:07 $
     10 * @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
     11 * @date $Date: 2007-10-09 19:24:46 $
    1212 *
    1313 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2727#include "psVector.h"
    2828#include "psScalar.h"
     29
     30typedef enum {
     31    PS_POLY_MASK_NONE = 0,
     32    PS_POLY_MASK_SET  = 1, // the coefficient should not be used (implies MASK_FIT)
     33    PS_POLY_MASK_FIT  = 2, // the coefficient should not be fitted
     34    PS_POLY_MASK_BOTH = 3, // the coefficient should not be fitted
     35} psPolynomialMaskValues;
    2936
    3037/** Evaluate a non-normalized Gaussian with the given mean and sigma at the
    … …  
    6067    psF64 *coeff;                       ///< Coefficients
    6168    psF64 *coeffErr;                    ///< Error in coefficients
    62     psMaskType *mask;                   ///< Coefficient mask
     69    psMaskType *coeffMask;              ///< Coefficient mask
    6370}
    6471psPolynomial1D;
    … …  
    7279    psF64 **coeff;                      ///< Coefficients
    7380    psF64 **coeffErr;                   ///< Error in coefficients
    74     psMaskType **mask;                  ///< Coefficients mask
     81    psMaskType **coeffMask;                  ///< Coefficients mask
    7582}
    7683psPolynomial2D;
    … …  
    8592    psF64 ***coeff;                     ///< Coefficients
    8693    psF64 ***coeffErr;                  ///< Error in coefficients
    87     psMaskType ***mask;                 ///< Coefficients mask
     94    psMaskType ***coeffMask;                 ///< Coefficients mask
    8895}
    8996psPolynomial3D;
    … …  
    93100{
    94101    psPolynomialType type;              ///< Polynomial type
    95     unsigned int nX;            ///< Polynomial order in x
    96     unsigned int nY;            ///< Polynomial order in y
    97     unsigned int nZ;            ///< Polynomial order in z
    98     unsigned int nT;            ///< Polynomial order in t
     102    unsigned int nX;                    ///< Polynomial order in x
     103    unsigned int nY;                    ///< Polynomial order in y
     104    unsigned int nZ;                    ///< Polynomial order in z
     105    unsigned int nT;                    ///< Polynomial order in t
    99106    psF64 ****coeff;                    ///< Coefficients
    100107    psF64 ****coeffErr;                 ///< Error in coefficients
    101     psMaskType ****mask;                ///< Coefficients mask
     108    psMaskType ****coeffMask;           ///< Coefficients mask
    102109}
    103110psPolynomial4D;
Note: See TracChangeset for help on using the changeset viewer.