IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jan 26, 2009, 8:40:07 PM (17 years ago)
Author:
eugene
Message:

incorporating changes from 16bit mask upgrades (eam_branch_20081230)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r19304 r21183  
    1010 *  @author EAM, IfA
    1111 *
    12  *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2008-09-02 19:03:38 $
     12 *  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2009-01-27 06:39:38 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    307307    psPolynomial1D* myPoly,
    308308    const psVector *mask,
    309     psMaskType maskValue,
     309    psVectorMaskType maskValue,
    310310    const psVector* y,
    311311    const psVector* yErr,
    … …  
    326326    if (mask != NULL) {
    327327        PS_ASSERT_VECTORS_SIZE_EQUAL(y, mask, NULL);
    328         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     328        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, NULL);
    329329    }
    330330
    … …  
    354354    psF64 **matrix = A->data.F64;       // Least-squares matrix
    355355    psF64 *vector = B->data.F64;        // Least-squares vector
    356     psU8 *dataMask = NULL;              // Mask for data
     356    psVectorMaskType *dataMask = NULL;              // Mask for data
    357357    if (mask) {
    358         dataMask = mask->data.U8;
    359     }
    360     psU8 *coeffMask = myPoly->coeffMask;      // Mask for polynomial terms
     358        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
     359    }
     360    psMaskType *coeffMask = myPoly->coeffMask;      // Mask for polynomial terms
    361361    psF64 *yData = y->data.F64;         // Coordinate data
    362362    psF64 *yErrData = NULL;             // Errors in the coordinate
    … …  
    473473    psPolynomial1D* myPoly,
    474474    const psVector *mask,
    475     psMaskType maskValue,
     475    psVectorMaskType maskValue,
    476476    const psVector *f,
    477477    const psVector *fErr,
    … …  
    484484    if (mask) {
    485485        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    486         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     486        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    487487    }
    488488    if (x) {
    … …  
    529529
    530530    // Dereference some pointers for speed in the loop
    531     psU8 *dataMask = NULL;              // Dereferenced version of mask for data points
     531    psVectorMaskType *dataMask = NULL;              // Dereferenced version of mask for data points
    532532    if (mask) {
    533         dataMask = mask->data.U8;
    534     }
    535     psU8 *coeffMask = myPoly->coeffMask;      // Dereferenced version of mask for polynomial terms
     533        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
     534    }
     535    psMaskType *coeffMask = myPoly->coeffMask;      // Dereferenced version of mask for polynomial terms
    536536    psF64 *ordinates = NULL;            // Dereferenced version of ordinate data
    537537    if (x) {
    … …  
    698698    psPolynomial1D *poly,
    699699    const psVector *mask,
    700     psMaskType maskValue,
     700    psVectorMaskType maskValue,
    701701    const psVector *f,
    702702    const psVector *fErr,
    … …  
    711711    if (mask != NULL) {
    712712        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    713         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     713        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    714714    }
    715715    if (fErr != NULL) {
    … …  
    782782    psStats *stats,
    783783    const psVector *mask,
    784     psMaskType maskValue,
     784    psVectorMaskType maskValue,
    785785    const psVector *f,
    786786    const psVector *fErr,
    … …  
    794794    PS_ASSERT_VECTOR_NON_NULL(mask, false);
    795795    PS_ASSERT_VECTORS_SIZE_EQUAL(mask, f, false);
    796     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     796    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    797797
    798798    if (fErr != NULL) {
    … …  
    862862            if (mask != NULL) {
    863863                for (psS32 i = 0 ; i < mask->n ; i++) {
    864                     psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.U8[i]);
     864                    psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    865865                }
    866866            }
    … …  
    895895            if (mask != NULL) {
    896896                for (psS32 i = 0 ; i < mask->n ; i++) {
    897                     if (!((mask != NULL) && (mask->data.U8[i] & maskValue))) {
     897                    if (!((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue))) {
    898898                        psTrace("psLib.math", 6,  "(f, fit)[%d] is (%f, %f).  resid is (%f)\n",
    899899                                i, f->data.F32[i], fit->data.F32[i], resid->data.F64[i]);
    … …  
    922922        // recovery is not allowed with this scheme
    923923        for (psS32 i = 0; i < resid->n; i++) {
    924             if ((mask != NULL) && (mask->data.U8[i] & maskValue)) {
     924            if ((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    925925                continue;
    926926            }
    … …  
    936936
    937937                if (mask != NULL) {
    938                     mask->data.U8[i] |= 0x01;
     938                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    939939                }
    940940                continue;
    … …  
    979979    psPolynomial2D* myPoly,
    980980    const psVector* mask,
    981     psMaskType maskValue,
     981    psVectorMaskType maskValue,
    982982    const psVector *f,
    983983    const psVector *fErr,
    … …  
    10031003    if (mask != NULL) {
    10041004        PS_ASSERT_VECTORS_SIZE_EQUAL(y, mask, false);
    1005         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1005        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    10061006    }
    10071007
    … …  
    10261026    psF64 **matrix = A->data.F64;       // Dereference the least-squares matrix
    10271027    psF64 *vector = B->data.F64;        // Dereference the least-squares vector
    1028     psU8 **coeffMask = myPoly->coeffMask;     // Dereference mask for polynomial terms
    1029     psU8 *dataMask = NULL;              // Dereference mask for data
     1028    psMaskType **coeffMask = myPoly->coeffMask;     // Dereference mask for polynomial terms
     1029    psVectorMaskType *dataMask = NULL;              // Dereference mask for data
    10301030    if (mask) {
    1031         dataMask = mask->data.U8;
     1031        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
    10321032    }
    10331033    psF64 *xData = x->data.F64;         // Dereference x
    … …  
    11621162    psPolynomial2D *poly,
    11631163    const psVector *mask,
    1164     psMaskType maskValue,
     1164    psVectorMaskType maskValue,
    11651165    const psVector *f,
    11661166    const psVector *fErr,
    … …  
    11791179    if (mask != NULL) {
    11801180        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1181         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1181        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    11821182    }
    11831183    if (fErr != NULL) {
    … …  
    12311231    psStats *stats,
    12321232    const psVector *mask,
    1233     psMaskType maskValue,
     1233    psVectorMaskType maskValue,
    12341234    const psVector *f,
    12351235    const psVector *fErr,
    … …  
    12541254
    12551255    PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1256     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1256    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    12571257
    12581258    if (fErr != NULL) {
    … …  
    13001300            if (mask != NULL) {
    13011301                for (psS32 i = 0 ; i < mask->n ; i++) {
    1302                     psTrace("psLib.math", 7,  "mask[%d] is %d\n", i, mask->data.U8[i]);
     1302                    psTrace("psLib.math", 7,  "mask[%d] is %d\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    13031303                }
    13041304            }
    … …  
    13291329            if (mask != NULL) {
    13301330                for (psS32 i = 0 ; i < mask->n ; i++) {
    1331                     if (!((mask != NULL) && (mask->data.U8[i] & maskValue))) {
     1331                    if (!((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue))) {
    13321332                        psTrace("psLib.math", 7,  "point %d at %f %f : value, fit : %f  %f resid: %f\n",
    13331333                                i, x->data.F32[i], y->data.F32[i], f->data.F32[i], fit->data.F32[i], resid->data.F64[i]);
    … …  
    13561356        // recovery is not allowed with this scheme
    13571357        for (psS32 i = 0; i < resid->n; i++) {
    1358             if ((mask != NULL) && (mask->data.U8[i] & maskValue)) {
     1358            if ((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    13591359                continue;
    13601360            }
    … …  
    13701370
    13711371                if (mask != NULL) {
    1372                     mask->data.U8[i] |= 0x01;
     1372                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    13731373                }
    13741374                continue;
    … …  
    14031403    psPolynomial3D* myPoly,
    14041404    const psVector* mask,
    1405     psMaskType maskValue,
     1405    psVectorMaskType maskValue,
    14061406    const psVector *f,
    14071407    const psVector *fErr,
    … …  
    14331433    if (mask != NULL) {
    14341434        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1435         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1435        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    14361436    }
    14371437
    … …  
    14641464        fErrData = fErr->data.F64;
    14651465    }
    1466     psU8 *dataMask = NULL;              // Mask for data
     1466    psVectorMaskType *dataMask = NULL;              // Mask for data
    14671467    if (mask) {
    1468         dataMask = mask->data.U8;
    1469     }
    1470     psU8 ***coeffMask = myPoly->coeffMask;    // Mask for polynomial terms
     1468        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
     1469    }
     1470    psMaskType ***coeffMask = myPoly->coeffMask;    // Mask for polynomial terms
    14711471    int nYZterm = nYterm * nZterm;      // Multiplication of the numbers, to calculate the index
    14721472
    … …  
    16031603    psPolynomial3D *poly,
    16041604    const psVector *mask,
    1605     psMaskType maskValue,
     1605    psVectorMaskType maskValue,
    16061606    const psVector *f,
    16071607    const psVector *fErr,
    … …  
    16231623    if (mask != NULL) {
    16241624        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1625         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1625        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    16261626    }
    16271627    if (fErr != NULL) {
    … …  
    16771677    psStats *stats,
    16781678    const psVector *mask,
    1679     psMaskType maskValue,
     1679    psVectorMaskType maskValue,
    16801680    const psVector *f,
    16811681    const psVector *fErr,
    … …  
    17051705
    17061706    PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1707     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1707    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    17081708
    17091709    if (fErr != NULL) {
    … …  
    17511751            if (mask != NULL) {
    17521752                for (psS32 i = 0 ; i < mask->n ; i++) {
    1753                     psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.U8[i]);
     1753                    psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    17541754                }
    17551755            }
    … …  
    17781778            if (mask != NULL) {
    17791779                for (psS32 i = 0 ; i < mask->n ; i++) {
    1780                     if (!((mask != NULL) && (mask->data.U8[i] & maskValue))) {
     1780                    if (!((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue))) {
    17811781                        psTrace("psLib.math", 6,  "(f, fit)[%d] is (%f, %f).  resid is (%f)\n",
    17821782                                i, f->data.F32[i], fit->data.F32[i], resid->data.F64[i]);
    … …  
    18051805        // recovery is not allowed with this scheme
    18061806        for (psS32 i = 0; i < resid->n; i++) {
    1807             if ((mask != NULL) && (mask->data.U8[i] & maskValue)) {
     1807            if ((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    18081808                continue;
    18091809            }
    … …  
    18191819
    18201820                if (mask != NULL) {
    1821                     mask->data.U8[i] |= 0x01;
     1821                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    18221822                }
    18231823                continue;
    … …  
    18501850    psPolynomial4D* myPoly,
    18511851    const psVector* mask,
    1852     psMaskType maskValue,
     1852    psVectorMaskType maskValue,
    18531853    const psVector *f,
    18541854    const psVector *fErr,
    … …  
    18841884    if (mask) {
    18851885        PS_ASSERT_VECTORS_SIZE_EQUAL(y, mask, false);
    1886         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1886        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    18871887    }
    18881888
    … …  
    19181918        fErrData = fErr->data.F64;
    19191919    }
    1920     psU8 *dataMask = NULL;              // Mask for data
     1920    psVectorMaskType *dataMask = NULL;              // Mask for data
    19211921    if (mask) {
    1922         dataMask = mask->data.U8;
    1923     }
    1924     psU8 ****coeffMask = myPoly->coeffMask;    // Mask for polynomial terms
     1922        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
     1923    }
     1924    psMaskType ****coeffMask = myPoly->coeffMask;    // Mask for polynomial terms
    19251925    int nYZTterm = nYterm * nZterm * nTterm; // Multiplication of the numbers, for calculating the index
    19261926    int nZTterm = nZterm * nTterm;      // Multiplication of the numbers, for calculating the index
    … …  
    20682068    psPolynomial4D *poly,
    20692069    const psVector *mask,
    2070     psMaskType maskValue,
     2070    psVectorMaskType maskValue,
    20712071    const psVector *f,
    20722072    const psVector *fErr,
    … …  
    20912091    if (mask) {
    20922092        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    2093         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     2093        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    20942094    }
    20952095    if (fErr != NULL) {
    … …  
    21482148    psStats *stats,
    21492149    const psVector *mask,
    2150     psMaskType maskValue,
     2150    psVectorMaskType maskValue,
    21512151    const psVector *f,
    21522152    const psVector *fErr,
    … …  
    21812181
    21822182    PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    2183     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     2183    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    21842184
    21852185    if (fErr != NULL) {
    … …  
    22272227            if (mask != NULL) {
    22282228                for (psS32 i = 0 ; i < mask->n ; i++) {
    2229                     psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.U8[i]);
     2229                    psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    22302230                }
    22312231            }
    … …  
    22552255            if (mask != NULL) {
    22562256                for (psS32 i = 0 ; i < mask->n ; i++) {
    2257                     if (!((mask != NULL) && (mask->data.U8[i] & maskValue))) {
     2257                    if (!((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue))) {
    22582258                        psTrace("psLib.math", 6,  "(f, fit)[%d] is (%f, %f).  resid is (%f)\n",
    22592259                                i, f->data.F32[i], fit->data.F32[i], resid->data.F64[i]);
    … …  
    22822282        // recovery is not allowed with this scheme
    22832283        for (psS32 i = 0; i < resid->n; i++) {
    2284             if ((mask != NULL) && (mask->data.U8[i] & maskValue)) {
     2284            if ((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    22852285                continue;
    22862286            }
    … …  
    22962296
    22972297                if (mask != NULL) {
    2298                     mask->data.U8[i] |= 0x01;
     2298                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    22992299                }
    23002300                continue;
Note: See TracChangeset for help on using the changeset viewer.