IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 21474


Ignore:
Timestamp:
Feb 13, 2009, 12:47:32 PM (17 years ago)
Author:
giebink
Message:

Account for weight(s) to variance(s) change

Location:
trunk/psModules/test
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/test/camera/tap_pmFPA.c

    r21220 r21474  
    4646    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    4747    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    48     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     48    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    4949    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    5050        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    183183        pmFPA* fpa = generateSimpleFPA(NULL);
    184184        fpa->hdu->images = psArrayAlloc(10);
    185         fpa->hdu->weights = psArrayAlloc(10);
     185        fpa->hdu->variances = psArrayAlloc(10);
    186186        fpa->hdu->masks = psArrayAlloc(10);
    187187        pmFPAFreeData(fpa);
    188188        ok(fpa->hdu->images == NULL, "pmFPAFreeData() correctly set fpa->hdu->images to NULL");
    189         ok(fpa->hdu->weights == NULL, "pmFPAFreeData() correctly set fpa->hdu->weights to NULL");
     189        ok(fpa->hdu->variances == NULL, "pmFPAFreeData() correctly set fpa->hdu->weights to NULL");
    190190        ok(fpa->hdu->masks == NULL, "pmFPAFreeData() correctly set fpa->hdu->masks to NULL");
    191191        psFree(fpa);
    … …  
    262262        pmChip* chip = generateSimpleChip(NULL);
    263263        chip->hdu->images = psArrayAlloc(10);
    264         chip->hdu->weights = psArrayAlloc(10);
     264        chip->hdu->variances = psArrayAlloc(10);
    265265        chip->hdu->masks = psArrayAlloc(10);
    266266        pmChipFreeData(chip);
    267267        ok(chip->hdu->images == NULL, "pmChipFreeData() correctly set chip->hdu->images to NULL");
    268         ok(chip->hdu->weights == NULL, "pmChipFreeData() correctly set chip->hdu->weights to NULL");
     268        ok(chip->hdu->variances == NULL, "pmChipFreeData() correctly set chip->hdu->weights to NULL");
    269269        ok(chip->hdu->masks == NULL, "pmChipFreeData() correctly set chip->hdu->masks to NULL");
    270270        psFree(chip);
    … …  
    367367        pmCell *cell = generateSimpleCell(NULL);
    368368        cell->hdu->images = psArrayAlloc(10);
    369         cell->hdu->weights = psArrayAlloc(10);
     369        cell->hdu->variances = psArrayAlloc(10);
    370370        cell->hdu->masks = psArrayAlloc(10);
    371371        pmCellFreeData(cell);
    372372        ok(cell->hdu->images == NULL, "pmCellFreeData() correctly set cell->hdu->images to NULL");
    373         ok(cell->hdu->weights == NULL, "pmCellFreeData() correctly set cell->hdu->weights to NULL");
     373        ok(cell->hdu->variances == NULL, "pmCellFreeData() correctly set cell->hdu->weights to NULL");
    374374        ok(cell->hdu->masks == NULL, "pmCellFreeData() correctly set cell->hdu->masks to NULL");
    375375        psFree(cell);
    … …  
    415415        ok(readout->image == NULL, "pmReadoutAlloc() set ->image correctly");
    416416        ok(readout->mask == NULL, "pmReadoutAlloc() set ->mask correctly");
    417         ok(readout->weight == NULL, "pmReadoutAlloc() set ->weight correctly");
     417        ok(readout->variance == NULL, "pmReadoutAlloc() set ->weight correctly");
    418418        ok(readout->bias != NULL &&
    419419           psMemCheckList(readout->bias), "pmReadoutAlloc() set ->bias correctly");
    … …  
    460460        pmReadoutFreeData(readout);
    461461        ok(readout->image == NULL, "pmReadoutFreeData() correctly set readout->image to NULL");
    462         ok(readout->weight == NULL, "pmReadoutFreeData() correctly set readout->weight to NULL");
     462        ok(readout->variance == NULL, "pmReadoutFreeData() correctly set readout->weight to NULL");
    463463        ok(readout->mask == NULL, "pmReadoutFreeData() correctly set readout->mask to NULL");
    464464        psFree(readout);

  • trunk/psModules/test/camera/tap_pmFPACellSquish.c

    r21220 r21474  
    5858    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5959    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    60     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     60    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    6161    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    6262        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    9696    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    9797    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    98     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     98    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    9999    for (int k = 0 ; k < NUM_HDUS ; k++) {
    100100        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    101101        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    102         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     102        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    103103        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    104104        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    105         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     105        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    106106    }
    107107

  • trunk/psModules/test/camera/tap_pmFPACopy.c

    r21220 r21474  
    5151    readout->image = psImageAlloc(SOURCE_NUM_COLS, SOURCE_NUM_ROWS, PS_TYPE_F32);
    5252    readout->mask = psImageAlloc(SOURCE_NUM_COLS, SOURCE_NUM_ROWS, PS_TYPE_U8);
    53     readout->weight = psImageAlloc(SOURCE_NUM_COLS, SOURCE_NUM_ROWS, PS_TYPE_F32);
     53    readout->variance = psImageAlloc(SOURCE_NUM_COLS, SOURCE_NUM_ROWS, PS_TYPE_F32);
    5454    for (int i = 0 ; i < SOURCE_NUM_ROWS ; i++) {
    5555        for (int j = 0 ; j < SOURCE_NUM_COLS ; j++) {
    5656            readout->image->data.F32[i][j] = (float) (i + j + SOURCE_BASE);
    5757            readout->mask->data.U8[i][j] = (psU8) (i + j + SOURCE_BASE);
    58             readout->weight->data.F32[i][j] = (float) (i + j + SOURCE_BASE);
     58            readout->variance->data.F32[i][j] = (float) (i + j + SOURCE_BASE);
    5959        }
    6060    }
    … …  
    144144    readout->image = psImageAlloc(TARGET_NUM_COLS, TARGET_NUM_ROWS, PS_TYPE_F32);
    145145    readout->mask = psImageAlloc(TARGET_NUM_COLS, TARGET_NUM_ROWS, PS_TYPE_U8);
    146     readout->weight = psImageAlloc(TARGET_NUM_COLS, TARGET_NUM_ROWS, PS_TYPE_F32);
     146    readout->variance = psImageAlloc(TARGET_NUM_COLS, TARGET_NUM_ROWS, PS_TYPE_F32);
    147147    for (int i = 0 ; i < TARGET_NUM_ROWS ; i++) {
    148148        for (int j = 0 ; j < TARGET_NUM_COLS ; j++) {
    149149            readout->image->data.F32[i][j] = (float) (i + j + TARGET_BASE);
    150150            readout->mask->data.U8[i][j] = (psU8) (i + j + TARGET_BASE);
    151             readout->weight->data.F32[i][j] = (float) (i + j + TARGET_BASE);
     151            readout->variance->data.F32[i][j] = (float) (i + j + TARGET_BASE);
    152152        }
    153153    }
    … …  
    260260        }
    261261
    262         psImage *weightTarget = readoutTarget->weight;
    263         psImage *weightSource = readoutSource->weight;
     262        psImage *varianceTarget = readoutTarget->variance;
     263        psImage *varianceSource = readoutSource->variance;
    264264        for (int i = 0 ; i < SOURCE_NUM_ROWS ; i++) {
    265265            for (int j = 0 ; j < SOURCE_NUM_COLS ; j++) {
    266                 if (weightTarget->data.F32[i][j] != weightSource->data.F32[i][j]) {
    267                     diag("ERROR: target readout[%d] weight[%d][%d] is %.2f, should be %.2f",
    268                           readoutID, i, j, weightTarget->data.F32[i][j], weightSource->data.F32[i][j]);
     266                if (varianceTarget->data.F32[i][j] != varianceSource->data.F32[i][j]) {
     267                    diag("ERROR: target readout[%d] variance[%d][%d] is %.2f, should be %.2f",
     268                          readoutID, i, j, varianceTarget->data.F32[i][j], varianceSource->data.F32[i][j]);
    269269                    errorFlag = true;
    270270                }
    … …  
    272272        }
    273273        if (errorFlag) {
    274             diag("ERROR: pmCellCopy() did not set the data for readout %d, weight correctly", readoutID);
     274            diag("ERROR: pmCellCopy() did not set the data for readout %d, variance correctly", readoutID);
    275275        }
    276276    }
    … …  
    317317            errorFlag = true;
    318318        }
    319         if (readoutTarget->weight->numRows != SOURCE_NUM_ROWS ||
    320             readoutTarget->weight->numCols != SOURCE_NUM_COLS) {
    321             diag("ERROR: readoutTarget->weight size is (%d by %d)\n", readoutTarget->weight->numRows,
    322                   readoutTarget->weight    ->numCols);
     319        if (readoutTarget->variance->numRows != SOURCE_NUM_ROWS ||
     320            readoutTarget->variance->numCols != SOURCE_NUM_COLS) {
     321            diag("ERROR: readoutTarget->variance size is (%d by %d)\n", readoutTarget->variance->numRows,
     322                  readoutTarget->variance->numCols);
    323323            errorFlag = true;
    324324        }

  • trunk/psModules/test/camera/tap_pmFPAExtent.c

    r21220 r21474  
    5656    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5757    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    58     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     58    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5959    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    6060        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    9393    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    9494    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    95     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     95    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    9696    for (int k = 0 ; k < NUM_HDUS ; k++) {
    9797        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    9898        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    99         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     99        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    100100        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    101101        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    102         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     102        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    103103    }
    104104

  • trunk/psModules/test/camera/tap_pmFPAFlags.c

    r21220 r21474  
    7979    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    8080    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    81     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     81    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    8282    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    8383        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    116116    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    117117    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    118     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     118    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    119119    for (int k = 0 ; k < NUM_HDUS ; k++) {
    120120        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    121121        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    122         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     122        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    123123        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    124124        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    125         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     125        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    126126    }
    127127

  • trunk/psModules/test/camera/tap_pmFPAHeader.c

    r21220 r21474  
    5353    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5454    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    55     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     55    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5656    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    5757        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    9393    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    9494    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    95     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     95    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    9696    for (int k = 0 ; k < NUM_HDUS ; k++) {
    9797        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    9898        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    99         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     99        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    100100        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    101101        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    102         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     102        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    103103    }
    104104

  • trunk/psModules/test/camera/tap_pmFPAMaskW.c

    r21220 r21474  
    6262    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    6363    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    64     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     64    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    6565    for (int i = 0 ; i < TEST_NUM_ROWS ; i++) {
    6666        for (int j = 0 ; j < TEST_NUM_COLS ; j++) {
    6767            readout->image->data.F32[i][j] = 32.0;
    6868            readout->mask->data.U8[i][j] = 0;
    69             readout->weight->data.F32[i][j] = 1.0;
     69            readout->variance->data.F32[i][j] = 1.0;
    7070        }
    7171    }
    … …  
    108108    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    109109    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    110     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     110    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    111111    for (int k = 0 ; k < NUM_HDUS ; k++) {
    112112        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    113113        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    114         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     114        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    115115        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    116116        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    117         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     117        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    118118    }
    119119
    … …  
    355355
    356356    // ----------------------------------------------------------------------
    357     // pmReadoutSetWeight() tests: NULL inputs
    358     // bool pmReadoutSetWeight(pmReadout *readout, bool poisson)
     357    // pmReadoutSetVariance() tests: NULL inputs
     358    // bool pmReadoutSetVariance(pmReadout *readout, bool poisson)
    359359    if (1) {
    360360        psMemId id = psMemGetId();
    … …  
    366366        bool rc;
    367367
    368         // Set readout == NULL, ensure pmReadoutSetWeight() returnes FALSE, with no seg faults, memory leaks
    369         rc = pmReadoutSetWeight(NULL, false);
    370         ok(!rc, "pmReadoutSetWeight(NULL, false) returned FALSE with null pmReadout input");
     368        // Set readout == NULL, ensure pmReadoutSetVariance() returnes FALSE, with no seg faults, memory leaks
     369        rc = pmReadoutSetVariance(NULL, false);
     370        ok(!rc, "pmReadoutSetVariance(NULL, false) returned FALSE with null pmReadout input");
    371371
    372372
    … …  
    376376        ok(rc, "Set GAIN and READNOISE in cell->concepts successfully");
    377377
    378         // Call pmReadoutSetWeight() and then verify that the mask data was set correctly
    379         rc = pmReadoutSetWeight(readout, false);
    380         ok(rc, "pmReadoutSetWeight(readout, false) returned TRUE with acceptable input data");
     378        // Call pmReadoutSetVariance() and then verify that the mask data was set correctly
     379        rc = pmReadoutSetVariance(readout, false);
     380        ok(rc, "pmReadoutSetVariance(readout, false) returned TRUE with acceptable input data");
    381381        bool errorFlag = false;
    382         for (int i = 0 ; i < readout->weight->numRows ; i++) {
    383             for (int j = 0 ; j < readout->weight->numCols ; j++) {
     382        for (int i = 0 ; i < readout->variance->numRows ; i++) {
     383            for (int j = 0 ; j < readout->variance->numCols ; j++) {
    384384                psF32 exp = CELL_READNOISE * CELL_READNOISE / CELL_GAIN / CELL_GAIN;
    385                 if(abs(readout->weight->data.F32[i][j] - exp) > 1e-4) {
     385                if(abs(readout->variance->data.F32[i][j] - exp) > 1e-4) {
    386386                    if (VERBOSE) {
    387387                        diag("TEST ERROR: weight[%d][%d] is %.2f, should be %.2f\n",
    388                               i, j, readout->weight->data.F32[i][j], exp);
     388                              i, j, readout->variance->data.F32[i][j], exp);
    389389                    }
    390390                    errorFlag = true;
    … …  
    392392            }
    393393        }
    394         ok(!errorFlag, "pmReadoutSetWeight() set the weight values correctly (non-Poisson)");
     394        ok(!errorFlag, "pmReadoutSetVariance() set the weight values correctly (non-Poisson)");
    395395
    396396        for (int i = 0 ; i < readout->image->numRows ; i++) {
    … …  
    399399            }
    400400        }
    401         // Call pmReadoutSetWeight() and then verify that the mask data was set correctly
    402         rc = pmReadoutSetWeight(readout, true);
    403         ok(rc, "pmReadoutSetWeight(readout, true) returned TRUE with acceptable input data");
     401        // Call pmReadoutSetVariance() and then verify that the mask data was set correctly
     402        rc = pmReadoutSetVariance(readout, true);
     403        ok(rc, "pmReadoutSetVariance(readout, true) returned TRUE with acceptable input data");
    404404        errorFlag = false;
    405         for (int i = 0 ; i < readout->weight->numRows ; i++) {
    406             for (int j = 0 ; j < readout->weight->numCols ; j++) {
     405        for (int i = 0 ; i < readout->variance->numRows ; i++) {
     406            for (int j = 0 ; j < readout->variance->numCols ; j++) {
    407407                psF32 exp = abs(readout->image->data.F32[i][j] / CELL_GAIN);
    408408                if (exp < 1.0) exp = 1.0;
    409409                exp+= CELL_READNOISE * CELL_READNOISE / CELL_GAIN / CELL_GAIN;
    410                 if(abs(readout->weight->data.F32[i][j] - exp) > 1e-4) {
     410                if(abs(readout->variance->data.F32[i][j] - exp) > 1e-4) {
    411411                    if (VERBOSE) {
    412412                        diag("TEST ERROR: weight[%d][%d] is %.2f, should be %.2f\n",
    413                               i, j, readout->weight->data.F32[i][j], exp);
     413                              i, j, readout->variance->data.F32[i][j], exp);
    414414                    }
    415415                    errorFlag = true;

  • trunk/psModules/test/camera/tap_pmFPAReadWrite.c

    r21221 r21474  
    5656    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5757    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    58     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     58    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5959    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    6060        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    9494    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    9595    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    96     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     96    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    9797    for (int k = 0 ; k < NUM_HDUS ; k++) {
    9898        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    9999        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    100         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     100        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    101101        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    102102        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    103         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     103        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    104104    }
    105105
    … …  
    298298    // ----------------------------------------------------------------------
    299299    // ----------------------------------------------------------------------
    300     // pmCellWriteWeight(): tests
    301     // Verify pmCellWriteWeight() with NULL pmCell arg
     300    // pmCellWriteVariance(): tests
     301    // Verify pmCellWriteVariance() with NULL pmCell arg
    302302    {
    303303        psMemId id = psMemGetId();
    304304        psFits* fitsFileW = psFitsOpen(".tmp00", "w");
    305         ok(!pmCellWriteWeight(NULL, fitsFileW, NULL, false), "pmCellWriteWeight() returned FALSE with NULL pmCell input");
    306         psFitsClose(fitsFileW);
    307         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    308     }
    309 
    310 
    311     // Verify pmCellWriteWeight() with NULL pmFits arg
     305        ok(!pmCellWriteVariance(NULL, fitsFileW, NULL, false), "pmCellWriteVariance() returned FALSE with NULL pmCell input");
     306        psFitsClose(fitsFileW);
     307        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     308    }
     309
     310
     311    // Verify pmCellWriteVariance() with NULL pmFits arg
    312312    {
    313313        psMemId id = psMemGetId();
    … …  
    317317        pmCell *cell = chip->cells->data[0];
    318318        ok(cell != NULL, "Allocated a pmCell successfully");
    319         ok(!pmCellWriteWeight(cell, NULL, NULL, false), "pmCellWriteWeight() returned FALSE with NULL psFits param");
    320         psFree(fpa);
    321         psFree(camera);
    322         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    323     }
    324 
    325 
    326     // Verify pmCellWriteWeight() with acceptable input params
    327     // We first write a FITS file with the pmCellWriteWeight(), then we read it and verify.
    328     // First call pmCellWriteWeight()
     319        ok(!pmCellWriteVariance(cell, NULL, NULL, false), "pmCellWriteVariance() returned FALSE with NULL psFits param");
     320        psFree(fpa);
     321        psFree(camera);
     322        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     323    }
     324
     325
     326    // Verify pmCellWriteVariance() with acceptable input params
     327    // We first write a FITS file with the pmCellWriteVariance(), then we read it and verify.
     328    // First call pmCellWriteVariance()
    329329    {
    330330        psMemId id = psMemGetId();
    … …  
    337337        ok(cell != NULL, "Allocated a pmCell successfully");
    338338
    339         //  Use pmCellWriteWeight() to write weight data to the FITS file
    340         bool rc = pmCellWriteWeight(cell, fitsFileW, NULL, false);
    341         ok(rc, "pmCellWriteWeight() returned TRUE");
     339        //  Use pmCellWriteVariance() to write weight data to the FITS file
     340        bool rc = pmCellWriteVariance(cell, fitsFileW, NULL, false);
     341        ok(rc, "pmCellWriteVariance() returned TRUE");
    342342
    343343        //  Close the FITS file, free memory
    … …  
    350350
    351351    // ----------------------------------------------------------------------
    352     // pmCellReadWeight() tests
    353     // Verify pmCellReadWeight() with NULL pmCell param
    354     {
    355         psMemId id = psMemGetId();
    356         psFits* fitsFileR = psFitsOpen(".tmp00", "r");
    357         ok(!pmCellReadWeight(NULL, fitsFileR, NULL), "pmCellReadWeight() returned FALSE with NULL pmCell param");
    358         psFitsClose(fitsFileR);
    359         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    360     }
    361 
    362 
    363     // Verify pmCellReadWeight() with NULL pmFits param
     352    // pmCellReadVariance() tests
     353    // Verify pmCellReadVariance() with NULL pmCell param
     354    {
     355        psMemId id = psMemGetId();
     356        psFits* fitsFileR = psFitsOpen(".tmp00", "r");
     357        ok(!pmCellReadVariance(NULL, fitsFileR, NULL), "pmCellReadVariance() returned FALSE with NULL pmCell param");
     358        psFitsClose(fitsFileR);
     359        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     360    }
     361
     362
     363    // Verify pmCellReadVariance() with NULL pmFits param
    364364    {
    365365        psMemId id = psMemGetId();
    … …  
    368368        pmChip *chip = fpa->chips->data[0];
    369369        pmCell *cell = chip->cells->data[0];
    370         ok(!pmCellReadWeight(cell, NULL, NULL), "pmCellReadWeight() returned FALSE with NULL pmFits param");
    371         psFree(fpa);
    372         psFree(camera);
    373         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    374     }
    375 
    376 
    377     // Verify pmCellReadWeight() with acceptable data (using the FITS file created above)
     370        ok(!pmCellReadVariance(cell, NULL, NULL), "pmCellReadVariance() returned FALSE with NULL pmFits param");
     371        psFree(fpa);
     372        psFree(camera);
     373        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     374    }
     375
     376
     377    // Verify pmCellReadVariance() with acceptable data (using the FITS file created above)
    378378    {
    379379        psMemId id = psMemGetId();
    … …  
    385385        pmCell *cell = chip->cells->data[0];
    386386        // Free the existing cell hdu weight data (so we can verify that pmCellReadWeight() actually reads the data
    387         psFree(cell->hdu->weights);
    388         cell->hdu->weights = NULL;
    389         psFits* fitsFileR = psFitsOpen(".tmp00", "r");
    390 
    391         rc = pmCellReadWeight(cell, fitsFileR, NULL);
    392         ok(rc, "pmCellReadWeight() returned TRUE");
    393         for (int k = 0 ; k < cell->hdu->weights->n ; k++) {
     387        psFree(cell->hdu->variances);
     388        cell->hdu->variances = NULL;
     389        psFits* fitsFileR = psFitsOpen(".tmp00", "r");
     390
     391        rc = pmCellReadVariance(cell, fitsFileR, NULL);
     392        ok(rc, "pmCellReadVariance() returned TRUE");
     393        for (int k = 0 ; k < cell->hdu->variances->n ; k++) {
    394394            bool errorFlag = false;
    395             psImage *msk = cell->hdu->weights->data[k];
     395            psImage *msk = cell->hdu->variances->data[k];
    396396            for (int i = 0 ; i < msk->numRows ; i++) {
    397397                for (int j = 0 ; j < msk->numCols ; j++) {
    … …  
    403403                }
    404404            }
    405             ok(!errorFlag, "pmCellWriteWeight()/pmCellReadWeight() properly set the weight data (image %d)", k);
     405            ok(!errorFlag, "pmCellWriteVariance()/pmCellReadVariance() properly set the weight data (image %d)", k);
    406406        }
    407407        psFitsClose(fitsFileR);
    … …  
    661661
    662662    // ----------------------------------------------------------------------
    663     // pmChipWriteWeight() tests
    664     // Verify pmChipWriteWeight() with NULL pmChip param
     663    // pmChipWriteVariance() tests
     664    // Verify pmChipWriteVariance() with NULL pmChip param
    665665    {
    666666        psMemId id = psMemGetId();
    667667        psFits* fitsFileW = psFitsOpen(".tmp01", "w");
    668         ok(!pmChipWriteWeight(NULL, fitsFileW, NULL, false, true), "pmChipWriteWeight() returned NULL with NULL pmChip param");
    669         psFitsClose(fitsFileW);
    670         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    671     }
    672 
    673 
    674     // Verify pmChipWriteWeight() with NULL pmFits param
     668        ok(!pmChipWriteVariance(NULL, fitsFileW, NULL, false, true), "pmChipWriteVariance() returned NULL with NULL pmChip param");
     669        psFitsClose(fitsFileW);
     670        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     671    }
     672
     673
     674    // Verify pmChipWriteVariance() with NULL pmFits param
    675675    {
    676676        psMemId id = psMemGetId();
    … …  
    680680        pmChip *chip = fpa->chips->data[0];
    681681        ok(chip != NULL, "Allocated a pmChip successfully");
    682         ok(!pmChipWriteWeight(chip, NULL, NULL, false, true), "pmChipWriteWeight() returned NULL with NULL pmFits param");
    683         psFree(fpa);
    684         psFree(camera);
    685         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    686     }
    687 
    688 
    689     // Verify pmChipWriteWeight() with acceptable data
     682        ok(!pmChipWriteVariance(chip, NULL, NULL, false, true), "pmChipWriteVariance() returned NULL with NULL pmFits param");
     683        psFree(fpa);
     684        psFree(camera);
     685        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     686    }
     687
     688
     689    // Verify pmChipWriteVariance() with acceptable data
    690690    {
    691691        psMemId id = psMemGetId();
    … …  
    697697        ok(chip != NULL, "Allocated a pmChip successfully");
    698698
    699         //  Use pmChipWriteWeight() to write image data to the FITS file
    700         bool rc = pmChipWriteWeight(chip, fitsFileW, NULL, false, true);
    701         ok(rc, "pmChipWriteWeight() returned TRUE");
     699        //  Use pmChipWriteVariance() to write image data to the FITS file
     700        bool rc = pmChipWriteVariance(chip, fitsFileW, NULL, false, true);
     701        ok(rc, "pmChipWriteVariance() returned TRUE");
    702702
    703703        //  Close the FITS file, free memory
    … …  
    757757            if (VERBOSE) diag("Reading cell %d\n", chipID);
    758758            pmCell *cell = (pmCell *) chip->cells->data[chipID];
    759             for (int k = 0 ; k < cell->hdu->weights->n ; k++) {
     759            for (int k = 0 ; k < cell->hdu->variances->n ; k++) {
    760760                if (VERBOSE) diag("NOTE: image %d\n", k);
    761                 psImage *wgt = cell->hdu->weights->data[k];
     761                psImage *wgt = cell->hdu->variances->data[k];
    762762                for (int i = 0 ; i < wgt->numRows ; i++) {
    763763                    for (int j = 0 ; j < wgt->numCols ; j++) {
    … …  
    770770                }
    771771            }
    772             ok(!errorFlag, "pmChipWriteWeight()/pmChipReadWeight() properly set the weight data (cell %d)", chipID);
     772            ok(!errorFlag, "pmChipWriteVariance()/pmChipReadVariance() properly set the variance data (cell %d)", chipID);
    773773        }
    774774
    … …  
    975975    // ----------------------------------------------------------------------
    976976    // ----------------------------------------------------------------------
    977     // pmFPAWriteWeight() tests
    978     // pmFPAWriteWeight(pmFPA *fpa, psFits *fits, psDB *db, bool blank, bool recurse)
    979     // Verify pmFPAWriteWeight() with NULL pmFPA param
     977    // pmFPAWriteVariance() tests
     978    // pmFPAWriteVariance(pmFPA *fpa, psFits *fits, psDB *db, bool blank, bool recurse)
     979    // Verify pmFPAWriteVariance() with NULL pmFPA param
    980980    {
    981981        psMemId id = psMemGetId();
    982982        psFits* fitsFileW = psFitsOpen(".tmp01", "w");
    983         ok(!pmFPAWriteWeight(NULL, fitsFileW, NULL, false, true), "pmFPAWriteWeight() returned NULL with NULL pmFPA param");
    984         psFitsClose(fitsFileW);
    985         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    986     }
    987 
    988 
    989     // Verify pmFPAWriteWeight() with NULL pmFits param
     983        ok(!pmFPAWriteVariance(NULL, fitsFileW, NULL, false, true), "pmFPAWriteVariance() returned NULL with NULL pmFPA param");
     984        psFitsClose(fitsFileW);
     985        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     986    }
     987
     988
     989    // Verify pmFPAWriteVariance() with NULL pmFits param
    990990    {
    991991        psMemId id = psMemGetId();
    … …  
    994994        pmFPA* fpa = generateSimpleFPA(camera);
    995995        ok(fpa != NULL, "Allocated a pmFPA successfully");
    996         ok(!pmFPAWriteWeight(fpa, NULL, NULL, false, true), "pmFPAWriteWeight() returned NULL with NULL pmFits param");
    997         psFree(fpa);
    998         psFree(camera);
    999         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    1000     }
    1001 
    1002 
    1003     // Verify pmFPAWriteWeight() with acceptable data
     996        ok(!pmFPAWriteVariance(fpa, NULL, NULL, false, true), "pmFPAWriteVariance() returned NULL with NULL pmFits param");
     997        psFree(fpa);
     998        psFree(camera);
     999        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     1000    }
     1001
     1002
     1003    // Verify pmFPAWriteVariance() with acceptable data
    10041004    {
    10051005        psMemId id = psMemGetId();
    … …  
    10091009        pmFPA* fpa = generateSimpleFPA(camera);
    10101010        ok(fpa != NULL, "Allocated a pmFPA successfully");
    1011         bool rc = pmFPAWriteWeight(fpa, fitsFileW, NULL, false, true);
    1012         ok(rc, "pmFPAWriteWeight() returned TRUE");
     1011        bool rc = pmFPAWriteVariance(fpa, fitsFileW, NULL, false, true);
     1012        ok(rc, "pmFPAWriteVariance() returned TRUE");
    10131013        //  Close the FITS file, free memory
    10141014        psFitsClose(fitsFileW);
    … …  
    10201020
    10211021    // ----------------------------------------------------------------------
    1022     // pmFPAReadWeight() tests
     1022    // pmFPAReadVariance() tests
    10231023    // Verify pmFPAReadWeight() with NULL pmFPA param
    10241024    {
    10251025        psMemId id = psMemGetId();
    10261026        psFits* fitsFileR = psFitsOpen(".tmp00", "r");
    1027         ok(!pmFPARead(NULL, fitsFileR, NULL), "pmFPAReadWeight() returned NULL with NULL pmFPA param");
    1028         psFitsClose(fitsFileR);
    1029         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    1030     }
    1031 
    1032 
    1033     // Verify pmFPAReadWeight() with NULL pmFits param
    1034     {
    1035         psMemId id = psMemGetId();
    1036         psMetadata *camera = psMetadataAlloc();
    1037         pmFPA* fpa = generateSimpleFPA(camera);
    1038         ok(!pmFPARead(fpa, NULL, NULL), "pmFPAReadWeight() returned NULL with NULL pmFits param");
    1039         psFree(fpa);
    1040         psFree(camera);
    1041         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    1042     }
    1043 
    1044 
    1045     // Verify pmFPAReadWeight() with acceptable input data
     1027        ok(!pmFPARead(NULL, fitsFileR, NULL), "pmFPAReadVariance() returned NULL with NULL pmFPA param");
     1028        psFitsClose(fitsFileR);
     1029        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     1030    }
     1031
     1032
     1033    // Verify pmFPAReadVariance() with NULL pmFits param
     1034    {
     1035        psMemId id = psMemGetId();
     1036        psMetadata *camera = psMetadataAlloc();
     1037        pmFPA* fpa = generateSimpleFPA(camera);
     1038        ok(!pmFPARead(fpa, NULL, NULL), "pmFPAReadVariance() returned NULL with NULL pmFits param");
     1039        psFree(fpa);
     1040        psFree(camera);
     1041        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     1042    }
     1043
     1044
     1045    // Verify pmFPAReadVariance() with acceptable input data
    10461046    {
    10471047        psMemId id = psMemGetId();
    … …  
    10511051        pmFPA* fpa = generateSimpleFPA(camera);
    10521052        pmChip *chip = fpa->chips->data[0];
    1053         // Free the cells for chip 0 so we can verify that pmFPAReadWeight() actually reads the data from file
     1053        // Free the cells for chip 0 so we can verify that pmFPAReadVariance() actually reads the data from file
    10541054        if (0) {
    10551055            for (int chipID = 0 ; chipID < chip->cells->n ; chipID++) {
    … …  
    10621062        psFits* fitsFileR = psFitsOpen(".tmp00", "r");
    10631063        rc = pmFPARead(fpa, fitsFileR, NULL);
    1064         ok(rc, "pmFPAReadWeight() returned TRUE");
     1064        ok(rc, "pmFPAReadVariance() returned TRUE");
    10651065        bool errorFlag = false;
    10661066        // XXX: fpaID should be chipID
    … …  
    10711071                if (VERBOSE) diag("Reading cell %d\n", chipID);
    10721072                pmCell *cell = (pmCell *) chip->cells->data[chipID];
    1073                 for (int k = 0 ; k < cell->hdu->weights->n ; k++) {
     1073                for (int k = 0 ; k < cell->hdu->variances->n ; k++) {
    10741074                    if (VERBOSE) diag("NOTE: image %d\n", k);
    1075                     psImage *wgt = cell->hdu->weights->data[k];
     1075                    psImage *wgt = cell->hdu->variances->data[k];
    10761076                    for (int i = 0 ; i < wgt->numRows ; i++) {
    10771077                        for (int j = 0 ; j < wgt->numCols ; j++) {
    … …  
    10841084                        }
    10851085                    }
    1086                 ok(!errorFlag, "pmFPAWriteWeight()/pmFPAReadWeight() properly set the image data (chip %d, cell %d)", fpaID, chipID);
     1086                ok(!errorFlag, "pmFPAWriteVariance()/pmFPAReadVariance() properly set the image data (chip %d, cell %d)", fpaID, chipID);
    10871087            }
    10881088        }

  • trunk/psModules/test/camera/tap_pmFPAUtils.c

    r21220 r21474  
    5252    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5353    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    54     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     54    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5555    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    5656        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    9090    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    9191    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    92     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     92    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    9393    for (int k = 0 ; k < NUM_HDUS ; k++) {
    9494        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    9595        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    96         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     96        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    9797        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    9898        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    99         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     99        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    100100    }
    101101

  • trunk/psModules/test/camera/tap_pmFPAView.c

    r21220 r21474  
    5252    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5353    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    54     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     54    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5555    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    5656        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    9090    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    9191    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    92     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     92    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    9393    for (int k = 0 ; k < NUM_HDUS ; k++) {
    9494        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    9595        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    96         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     96        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    9797        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    9898        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    99         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     99        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    100100    }
    101101    cell->hdu->blankPHU = true;

  • trunk/psModules/test/camera/tap_pmHDUUtils.c

    r21220 r21474  
    5252    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5353    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    54     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     54    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5555    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    5656        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    9090    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    9191    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    92     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     92    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    9393    for (int k = 0 ; k < NUM_HDUS ; k++) {
    9494        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    9595        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    96         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     96        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    9797        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    9898        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    99         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     99        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    100100    }
    101101

  • trunk/psModules/test/concepts/tap_pmConceptsAverage.c

    r21223 r21474  
    5858    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5959    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    60     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     60    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    6161    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    6262        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    9696    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    9797    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    98     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     98    cell->hdu->variances = psArrayAlloc(NUM_HDUS);
    9999    for (int k = 0 ; k < NUM_HDUS ; k++) {
    100100        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    101101        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    102         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     102        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    103103        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    104104        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    105         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     105        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    106106    }
    107107

  • trunk/psModules/test/concepts/tap_pmConceptsUpdate.c

    r21223 r21474  
    5757    readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    5858    readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8);
    59     readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     59    readout->variance = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    6060    for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) {
    6161        psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    … …  
    9595    cell->hdu->images = psArrayAlloc(NUM_HDUS);
    9696    cell->hdu->masks = psArrayAlloc(NUM_HDUS);
    97     cell->hdu->weights = psArrayAlloc(NUM_HDUS);
     97    cell->hdu->variances= psArrayAlloc(NUM_HDUS);
    9898    for (int k = 0 ; k < NUM_HDUS ; k++) {
    9999        cell->hdu->images->data[k]  = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    100100        cell->hdu->masks->data[k]   = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK);
    101         cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
     101        cell->hdu->variances->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32);
    102102        psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k));
    103103        psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k));
    104         psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k));
     104        psImageInit(cell->hdu->variances->data[k], (float) (BASE_WEIGHT+k));
    105105    }
    106106
Note: See TracChangeset for help on using the changeset viewer.