IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 2, 2004, 1:29:39 PM (22 years ago)
Author:
harman
Message:

Changed psVector to be consistent with psImage

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r797 r831  
    8686
    8787    newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
    88     newHist->bounds = psVectorAlloc(PS_TYPE_FLOAT, n+1);
     88    newHist->bounds = psVectorAlloc(n+1, PS_TYPE_F32);
    8989    binSize = (upper - lower) / (float) n;
    9090    for (i=0;i<n+1;i++) {
    91         newHist->bounds->vec.f[i] = lower + (binSize * (float) i);
    92     }
    93     newHist->nums =  psVectorAlloc(PS_TYPE_INT32, n);
     91        newHist->bounds->data.F32[i] = lower + (binSize * (float) i);
     92    }
     93    newHist->nums =  psVectorAlloc(n, PS_TYPE_S32);
    9494    newHist->minNum = 0;
    9595    newHist->maxNum = 0;
    … …  
    106106
    107107    newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
    108     newHist->bounds = psVectorAlloc(PS_TYPE_FLOAT, bounds->n);
     108    newHist->bounds = psVectorAlloc(bounds->n, PS_TYPE_F32);
    109109    for (i=0;i<bounds->n;i++) {
    110         newHist->bounds->vec.f[i] = bounds->vec.f[i];
    111     }
    112     newHist->nums = psVectorAlloc(PS_TYPE_INT32, (bounds->n)-1);
     110        newHist->bounds->data.F32[i] = bounds->data.F32[i];
     111    }
     112    newHist->nums = psVectorAlloc((bounds->n)-1, PS_TYPE_S32);
    113113
    114114    newHist->minNum = 0;
    … …  
    152152    for (i=0;i<in->n;i++) {
    153153        // Check if this pixel is masked, and if so, skip it.
    154         if (!(mask->vec.i32[i] & maskVal)) {
     154        if (!(mask->data.S32[i] & maskVal)) {
    155155            // Check if this pixel is below the minimum value, and if so
    156156            // count it, then skip it.
    157             if (in->vec.f[i] < out->bounds->vec.f[0]) {
     157            if (in->data.F32[i] < out->bounds->data.F32[0]) {
    158158                out->minNum++;
    159159
    160160                // Check if this pixel is above the maximum value, and if so
    161161                // count it, then skip it.
    162             } else if (in->vec.f[i] > out->bounds->vec.f[numBins]) {
     162            } else if (in->data.F32[i] > out->bounds->data.F32[numBins]) {
    163163                out->maxNum++;
    164164            } else {
    … …  
    166166                // number is trivial.
    167167                if (out->uniform == true) {
    168                     binSize = out->bounds->vec.f[1] - out->bounds->vec.f[0];
    169 
    170                     binNum = (int) ((in->vec.f[i] - out->bounds->vec.f[0]) /
     168                    binSize = out->bounds->data.F32[1] - out->bounds->data.F32[0];
     169
     170                    binNum = (int) ((in->data.F32[i] - out->bounds->data.F32[0]) /
    171171                                    binSize);
    172                     (out->nums->vec.i32[binNum])++;
     172                    (out->nums->data.S32[binNum])++;
    173173                    // If this is a non-uniform histogram, determining the correct
    174174                    // bin number requires a bit more work.
    … …  
    177177                    // find the correct bin number (bin search, probably)
    178178                    for (j=0;j<(out->bounds->n)-1;j++) {
    179                         if ((out->bounds->vec.i32[j] <= in->vec.f[i]) &&
    180                                 (in->vec.f[i] <= out->bounds->vec.i32[j+1])) {
    181                             (out->nums->vec.i32[j])++;
     179                        if ((out->bounds->data.S32[j] <= in->data.F32[i]) &&
     180                                (in->data.F32[i] <= out->bounds->data.S32[j+1])) {
     181                            (out->nums->data.S32[j])++;
    182182                        }
    183183                    }
    … …  
    198198    for (i=0;i<myVector->n;i++) {
    199199        if (maskVector != NULL)
    200             printf("Element %d is %f (mask is %d)\n", i, myVector->vec.f[i], maskVector->vec.ui8[i]);
     200            printf("Element %d is %f (mask is %d)\n", i, myVector->data.F32[i], maskVector->data.U8[i]);
    201201        else
    202             printf("Element %d is %f\n", i, myVector->vec.f[i]);
     202            printf("Element %d is %f\n", i, myVector->data.F32[i]);
    203203    }
    204204}
    … …  
    234234        if (maskVector != NULL) {
    235235            for (i=0;i<myVector->n;i++) {
    236                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    237                         (rangeMin <= myVector->vec.f[i]) &&
    238                         (myVector->vec.f[i] <= rangeMax)) {
    239                     mean+= myVector->vec.f[i];
     236                if (!(maskVal & maskVector->data.U8[i]) &&
     237                        (rangeMin <= myVector->data.F32[i]) &&
     238                        (myVector->data.F32[i] <= rangeMax)) {
     239                    mean+= myVector->data.F32[i];
    240240                    count++;
    241241                }
    … …  
    244244        } else {
    245245            for (i=0;i<myVector->n;i++) {
    246                 if ((rangeMin <= myVector->vec.f[i]) &&
    247                         (myVector->vec.f[i] <= rangeMax)) {
    248                     mean+= myVector->vec.f[i];
     246                if ((rangeMin <= myVector->data.F32[i]) &&
     247                        (myVector->data.F32[i] <= rangeMax)) {
     248                    mean+= myVector->data.F32[i];
    249249                    count++;
    250250                }
    … …  
    255255        if (maskVector != NULL) {
    256256            for (i=0;i<myVector->n;i++) {
    257                 if (!(maskVal & maskVector->vec.ui8[i])) {
    258                     mean+= myVector->vec.f[i];
     257                if (!(maskVal & maskVector->data.U8[i])) {
     258                    mean+= myVector->data.F32[i];
    259259                    count++;
    260260                }
    … …  
    263263        } else {
    264264            for (i=0;i<myVector->n;i++) {
    265                 mean+= myVector->vec.f[i];
     265                mean+= myVector->data.F32[i];
    266266            }
    267267            mean/= (float) myVector->n;
    … …  
    287287        if (maskVector != NULL) {
    288288            for (i=0;i<myVector->n;i++) {
    289                 if (!(maskVal & maskVector->vec.ui8[i])) {
    290                     if ((myVector->vec.f[i] > max) &&
    291                             (rangeMin <= myVector->vec.f[i]) &&
    292                             (myVector->vec.f[i] <= rangeMax)) {
    293                         max = myVector->vec.f[i];
     289                if (!(maskVal & maskVector->data.U8[i])) {
     290                    if ((myVector->data.F32[i] > max) &&
     291                            (rangeMin <= myVector->data.F32[i]) &&
     292                            (myVector->data.F32[i] <= rangeMax)) {
     293                        max = myVector->data.F32[i];
    294294                    }
    295295                }
    … …  
    297297        } else {
    298298            for (i=0;i<myVector->n;i++) {
    299                 if ((myVector->vec.f[i] > max) &&
    300                         (rangeMin <= myVector->vec.f[i]) &&
    301                         (myVector->vec.f[i] <= rangeMax)) {
    302                     max = myVector->vec.f[i];
     299                if ((myVector->data.F32[i] > max) &&
     300                        (rangeMin <= myVector->data.F32[i]) &&
     301                        (myVector->data.F32[i] <= rangeMax)) {
     302                    max = myVector->data.F32[i];
    303303                }
    304304            }
    … …  
    307307        if (maskVector != NULL) {
    308308            for (i=0;i<myVector->n;i++) {
    309                 if (!(maskVal & maskVector->vec.ui8[i])) {
    310                     if (myVector->vec.f[i] > max) {
    311                         max = myVector->vec.f[i];
     309                if (!(maskVal & maskVector->data.U8[i])) {
     310                    if (myVector->data.F32[i] > max) {
     311                        max = myVector->data.F32[i];
    312312                    }
    313313                }
    … …  
    315315        } else {
    316316            for (i=0;i<myVector->n;i++) {
    317                 if (myVector->vec.f[i] > max) {
    318                     max = myVector->vec.f[i];
     317                if (myVector->data.F32[i] > max) {
     318                    max = myVector->data.F32[i];
    319319                }
    320320            }
    … …  
    340340        if (maskVector != NULL) {
    341341            for (i=0;i<myVector->n;i++) {
    342                 if (!(maskVal & maskVector->vec.ui8[i])) {
    343                     if ((myVector->vec.f[i] < min) &&
    344                             (rangeMin <= myVector->vec.f[i]) &&
    345                             (myVector->vec.f[i] <= rangeMax)) {
    346                         min = myVector->vec.f[i];
     342                if (!(maskVal & maskVector->data.U8[i])) {
     343                    if ((myVector->data.F32[i] < min) &&
     344                            (rangeMin <= myVector->data.F32[i]) &&
     345                            (myVector->data.F32[i] <= rangeMax)) {
     346                        min = myVector->data.F32[i];
    347347                    }
    348348                }
    … …  
    350350        } else {
    351351            for (i=0;i<myVector->n;i++) {
    352                 if ((myVector->vec.f[i] < min) &&
    353                         (rangeMin <= myVector->vec.f[i]) &&
    354                         (myVector->vec.f[i] <= rangeMax)) {
    355                     min = myVector->vec.f[i];
     352                if ((myVector->data.F32[i] < min) &&
     353                        (rangeMin <= myVector->data.F32[i]) &&
     354                        (myVector->data.F32[i] <= rangeMax)) {
     355                    min = myVector->data.F32[i];
    356356                }
    357357            }
    … …  
    360360        if (maskVector != NULL) {
    361361            for (i=0;i<myVector->n;i++) {
    362                 if (!(maskVal & maskVector->vec.ui8[i])) {
    363                     if (myVector->vec.f[i] < min) {
    364                         min = myVector->vec.f[i];
     362                if (!(maskVal & maskVector->data.U8[i])) {
     363                    if (myVector->data.F32[i] < min) {
     364                        min = myVector->data.F32[i];
    365365                    }
    366366                }
    … …  
    368368        } else {
    369369            for (i=0;i<myVector->n;i++) {
    370                 if (myVector->vec.f[i] < min) {
    371                     min = myVector->vec.f[i];
     370                if (myVector->data.F32[i] < min) {
     371                    min = myVector->data.F32[i];
    372372                }
    373373            }
    … …  
    397397        if (maskVector != NULL) {
    398398            for (i=0;i<myVector->n;i++) {
    399                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    400                         (rangeMin <= myVector->vec.f[i]) &&
    401                         (myVector->vec.f[i] <= rangeMax)) {
     399                if (!(maskVal & maskVector->data.U8[i]) &&
     400                        (rangeMin <= myVector->data.F32[i]) &&
     401                        (myVector->data.F32[i] <= rangeMax)) {
    402402                    numData++;
    403403                }
    … …  
    405405        } else {
    406406            for (i=0;i<myVector->n;i++) {
    407                 if ((rangeMin <= myVector->vec.f[i]) &&
    408                         (myVector->vec.f[i] <= rangeMax)) {
     407                if ((rangeMin <= myVector->data.F32[i]) &&
     408                        (myVector->data.F32[i] <= rangeMax)) {
    409409                    numData++;
    410410                }
    … …  
    416416        if (maskVector != NULL) {
    417417            for (i=0;i<myVector->n;i++) {
    418                 if (!(maskVal & maskVector->vec.ui8[i])) {
     418                if (!(maskVal & maskVector->data.U8[i])) {
    419419                    numData++;
    420420                }
    … …  
    469469
    470470    // Allocate temporary vectors for the data.
    471     unsortedVector = psVectorAlloc(PS_TYPE_FLOAT, nValues);
     471    unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32);
    472472    unsortedVector->n = unsortedVector->nalloc;
    473     sortedVector   = psVectorAlloc(PS_TYPE_FLOAT, nValues);
     473    sortedVector   = psVectorAlloc(nValues, PS_TYPE_F32);
    474474    sortedVector->n = sortedVector->nalloc;
    475475
    … …  
    484484        if (maskVector != NULL) {
    485485            for (i=0;i<myVector->n;i++) {
    486                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    487                         (rangeMin <= myVector->vec.f[i]) &&
    488                         (myVector->vec.f[i] <= rangeMax)) {
    489                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
    490                 }
    491             }
    492         } else {
    493             for (i=0;i<myVector->n;i++) {
    494                 if ((rangeMin <= myVector->vec.f[i]) &&
    495                         (myVector->vec.f[i] <= rangeMax)) {
    496                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
     486                if (!(maskVal & maskVector->data.U8[i]) &&
     487                        (rangeMin <= myVector->data.F32[i]) &&
     488                        (myVector->data.F32[i] <= rangeMax)) {
     489                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
     490                }
     491            }
     492        } else {
     493            for (i=0;i<myVector->n;i++) {
     494                if ((rangeMin <= myVector->data.F32[i]) &&
     495                        (myVector->data.F32[i] <= rangeMax)) {
     496                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
    497497                }
    498498            }
    … …  
    503503        if (maskVector != NULL) {
    504504            for (i=0;i<myVector->n;i++) {
    505                 if (!(maskVal & maskVector->vec.ui8[i])) {
    506                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
    507                 }
    508             }
    509         } else {
    510             for (i=0;i<myVector->n;i++) {
    511                 unsortedVector->vec.f[i] = maskVector->vec.f[i];
     505                if (!(maskVal & maskVector->data.U8[i])) {
     506                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
     507                }
     508            }
     509        } else {
     510            for (i=0;i<myVector->n;i++) {
     511                unsortedVector->data.F32[i] = maskVector->data.F32[i];
    512512            }
    513513        }
    … …  
    518518    // Calculate the median exactly.
    519519    if (0 == (nValues % 2)) {
    520         stats->sampleMedian = 0.5 * (sortedVector->vec.f[(nValues/2)-1] +
    521                                      sortedVector->vec.f[nValues/2]);
     520        stats->sampleMedian = 0.5 * (sortedVector->data.F32[(nValues/2)-1] +
     521                                     sortedVector->data.F32[nValues/2]);
    522522    } else {
    523         stats->sampleMedian = sortedVector->vec.f[nValues/2];
     523        stats->sampleMedian = sortedVector->data.F32[nValues/2];
    524524    }
    525525
    … …  
    569569        for (j=-GAUSS_WIDTH;j<=+GAUSS_WIDTH;j++) {
    570570            if (((j+i) >= 0) && ((j+i) < robustHistogram->nums->n)) {
    571                 robustHistogram->nums->vec.i32[j+i]+=
     571                robustHistogram->nums->data.S32[j+i]+=
    572572                    (gaussianCoefs[j+GAUSS_WIDTH] *
    573                      (float) robustHistogram->nums->vec.i32[j+i]);
     573                     (float) robustHistogram->nums->data.S32[j+i]);
    574574            }
    575575        }
    … …  
    623623
    624624    // Allocate temporary vectors for the data.
    625     unsortedVector = psVectorAlloc(PS_TYPE_FLOAT, nValues);
     625    unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32);
    626626    unsortedVector->n = unsortedVector->nalloc;
    627     sortedVector   = psVectorAlloc(PS_TYPE_FLOAT, nValues);
     627    sortedVector   = psVectorAlloc(nValues, PS_TYPE_F32);
    628628    sortedVector->n = sortedVector->nalloc;
    629629
    … …  
    637637        if (maskVector != NULL) {
    638638            for (i=0;i<myVector->n;i++) {
    639                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    640                         (rangeMin <= myVector->vec.f[i]) &&
    641                         (myVector->vec.f[i] <= rangeMax)) {
    642                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
    643                 }
    644             }
    645         } else {
    646             for (i=0;i<myVector->n;i++) {
    647                 if ((rangeMin <= myVector->vec.f[i]) &&
    648                         (myVector->vec.f[i] <= rangeMax)) {
    649                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
     639                if (!(maskVal & maskVector->data.U8[i]) &&
     640                        (rangeMin <= myVector->data.F32[i]) &&
     641                        (myVector->data.F32[i] <= rangeMax)) {
     642                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
     643                }
     644            }
     645        } else {
     646            for (i=0;i<myVector->n;i++) {
     647                if ((rangeMin <= myVector->data.F32[i]) &&
     648                        (myVector->data.F32[i] <= rangeMax)) {
     649                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
    650650                }
    651651            }
    … …  
    656656        if (maskVector != NULL) {
    657657            for (i=0;i<myVector->n;i++) {
    658                 if (!(maskVal & maskVector->vec.ui8[i])) {
    659                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
    660                 }
    661             }
    662         } else {
    663             for (i=0;i<myVector->n;i++) {
    664                 unsortedVector->vec.f[i] = maskVector->vec.f[i];
     658                if (!(maskVal & maskVector->data.U8[i])) {
     659                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
     660                }
     661            }
     662        } else {
     663            for (i=0;i<myVector->n;i++) {
     664                unsortedVector->data.F32[i] = maskVector->data.F32[i];
    665665            }
    666666        }
    … …  
    672672    // Calculate the quartile points exactly.
    673673    ind = 3 * (nValues / 4);
    674     stats->sampleUQ = sortedVector->vec.f[ind];
     674    stats->sampleUQ = sortedVector->data.F32[ind];
    675675    ind = (nValues / 4);
    676     stats->sampleLQ = sortedVector->vec.f[ind];
     676    stats->sampleLQ = sortedVector->data.F32[ind];
    677677
    678678    // Free the temporary data structures.
    … …  
    765765    UQBinNum = -1;
    766766    for (i=0;i<robustHistogram->nums->n;i++) {
    767         if ((robustHistogram->nums->vec.i32[i] <= stats->sampleLQ) &&
    768                 (stats->sampleLQ <= robustHistogram->nums->vec.i32[i])) {
     767        if ((robustHistogram->nums->data.S32[i] <= stats->sampleLQ) &&
     768                (stats->sampleLQ <= robustHistogram->nums->data.S32[i])) {
    769769            LQBinNum = i;
    770770        }
    771771
    772         if ((robustHistogram->nums->vec.i32[i] <= stats->sampleUQ) &&
    773                 (stats->sampleUQ <= robustHistogram->nums->vec.i32[i])) {
     772        if ((robustHistogram->nums->data.S32[i] <= stats->sampleUQ) &&
     773                (stats->sampleUQ <= robustHistogram->nums->data.S32[i])) {
    774774            UQBinNum = i;
    775775        }
    … …  
    778778    // Determine the bin with the peak value in the range LQ to UQ.
    779779    maxBinNum = LQBinNum;
    780     maxBinCount = robustHistogram->nums->vec.i32[maxBinNum];
     780    maxBinCount = robustHistogram->nums->data.S32[maxBinNum];
    781781    for (i=LQBinNum;i<=UQBinNum;i++) {
    782         if (robustHistogram->nums->vec.i32[i] > maxBinCount) {
     782        if (robustHistogram->nums->data.S32[i] > maxBinCount) {
    783783            maxBinNum = i;
    784             maxBinCount = robustHistogram->nums->vec.i32[i];
     784            maxBinCount = robustHistogram->nums->data.S32[i];
    785785        }
    786786    }
    … …  
    843843        if (maskVector != NULL) {
    844844            for (i=0;i<myVector->n;i++) {
    845                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    846                         (rangeMin <= myVector->vec.f[i]) &&
    847                         (myVector->vec.f[i] <= rangeMax)) {
    848                     diff = myVector->vec.f[i] - mean;
     845                if (!(maskVal & maskVector->data.U8[i]) &&
     846                        (rangeMin <= myVector->data.F32[i]) &&
     847                        (myVector->data.F32[i] <= rangeMax)) {
     848                    diff = myVector->data.F32[i] - mean;
    849849                    sumSquares+= (diff * diff);
    850850                    sumDiffs+= diff;
    … …  
    854854        } else {
    855855            for (i=0;i<myVector->n;i++) {
    856                 if ((rangeMin <= myVector->vec.f[i]) &&
    857                         (myVector->vec.f[i] <= rangeMax)) {
    858                     diff = myVector->vec.f[i] - mean;
     856                if ((rangeMin <= myVector->data.F32[i]) &&
     857                        (myVector->data.F32[i] <= rangeMax)) {
     858                    diff = myVector->data.F32[i] - mean;
    859859                    sumSquares+= (diff * diff);
    860860                    sumDiffs+= diff;
    … …  
    867867        if (maskVector != NULL) {
    868868            for (i=0;i<myVector->n;i++) {
    869                 if (!(maskVal & maskVector->vec.ui8[i])) {
    870                     diff = myVector->vec.f[i] - mean;
     869                if (!(maskVal & maskVector->data.U8[i])) {
     870                    diff = myVector->data.F32[i] - mean;
    871871                    sumSquares+= (diff * diff);
    872872                    sumDiffs+= diff;
    … …  
    876876        } else {
    877877            for (i=0;i<myVector->n;i++) {
    878                 diff = myVector->vec.f[i] - mean;
     878                diff = myVector->data.F32[i] - mean;
    879879                sumSquares+= (diff * diff);
    880880                sumDiffs+= diff;
    … …  
    920920    }
    921921
    922     tmpMask = psVectorAlloc(maskVector->type.type, myVector->nalloc);
     922    tmpMask = psVectorAlloc(myVector->nalloc, maskVector->type.type);
    923923
    924924    tmpMask->n = maskVector->n;
    925925    for (i=0;i<tmpMask->n;i++) {
    926         tmpMask->vec.ui8[i] = maskVector->vec.ui8[i];
     926        tmpMask->data.U8[i] = maskVector->data.U8[i];
    927927    }
    928928
    … …  
    944944        for (j=0;j<myVector->n;j++) {
    945945            // a) Exclude all values x_i for which |x_i - x| > K * stdev
    946             if ( fabs(myVector->vec.f[j] - clippedMean) >
     946            if ( fabs(myVector->data.F32[j] - clippedMean) >
    947947                    (stats->clipSigma * clippedStdev)) {
    948                 tmpMask->vec.ui8[i] = 0xff;
     948                tmpMask->data.U8[i] = 0xff;
    949949            }
    950950            // b) compute new mean and stdev
    … …  
    979979 
    980980    NOTE: The current strategy is to implement everything assuming that all
    981     input data is of type PS_TYPE_FLOAT.  Once the basic code is in place,
    982     we will macro-ize everything and add PS_TYPE_UINT16 and PS_TYPE_DOUBLE.
     981    input data is of type PS_TYPE_F32.  Once the basic code is in place,
     982    we will macro-ize everything and add PS_TYPE_U16 and PS_TYPE_F64.
    983983 
    984984 *****************************************************************************/
    … …  
    992992    }
    993993
    994     if (in->type.type != PS_TYPE_FLOAT) {
     994    if (in->type.type != PS_TYPE_F32) {
    995995        psAbort(__func__,
    996                 "Only data type PS_TYPE_FLOAT is currently supported.");
     996                "Only data type PS_TYPE_F32 is currently supported.");
    997997    }
    998998    if (mask != NULL) {
    … …  
    10011001                    "Vector data and vector mask are of different sizes.");
    10021002        }
    1003         if (mask->type.type != PS_TYPE_UINT8) {
     1003        if (mask->type.type != PS_TYPE_U8) {
    10041004            psAbort(__func__,
    1005                     "Vector mask must be type PS_TYPE_UINT8");
     1005                    "Vector mask must be type PS_TYPE_U8");
    10061006        }
    10071007    }
Note: See TracChangeset for help on using the changeset viewer.