Changeset 4770 for trunk/psModules/src

trunk/psModules/src/pmAstrometry.c

-              r4754
+              r4770
  *  @author GLG, MHPCC
+ *
  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-08-11 00:03:51 $
+ *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
 …
 #include "pmAstrometry.h"
-psDB wow;
 /*****************************************************************************
+checkValidImageCoords(): this is a private function which simply
+determines if the supplied x,y coordinates are in the range for the supplied
+psImage.
+checkValidImageCoords(): this is a private function which simply determines if
+the supplied x,y coordinates are in the range for the supplied psImage.
+XXX: What about col0 and row0
+XXX: This should return a psBool.
  *****************************************************************************/
-/*
 static psS32 checkValidImageCoords(double x,
                                    double y,
 …
+{
     PS_ASSERT_IMAGE_NON_NULL(tmpImage, 0);
     if ((x < 0.0) || (x > (double)tmpImage->numCols) ||
             (y < 0.0) || (y > (double)tmpImage->numRows)) {
         return (0);
+    }
     return (1);
+}
+*/
+/*
+static void FPAFree(psFPA* fpa)
+/******************************************************************************
+XXX: Is this the correct way to free metadata?
+XXX: Is this the correct way to free database structs?
+ *****************************************************************************/
+static void FPAFree(pmFPA *fpa)
+{
     if (fpa != NULL) {
-        psFree(fpa->chips);
-        psFree(fpa->grommit);
-        psFree(fpa->exposure);
-        psFree(fpa->metadata);
         psFree(fpa->fromTangentPlane);
         psFree(fpa->toTangentPlane);
-        psFree(fpa->pattern);
-        psFree(fpa->colorPlus);
-        psFree(fpa->colorMinus);
         psFree(fpa->projection);
+    }
+}
+*/
+/*
+static void chipFree(psChip* chip)
+        psFree(fpa->concepts);
+        psFree(fpa->analysis);
+        psFree(fpa->camera);
+        psFree(fpa->chips);
+        psFree(fpa->header);
+        psFree(fpa->db);
+    }
+}
+static void chipFree(pmChip* chip)
+{
     if (chip != NULL) {
-        psFree(chip->cells);
-        psFree(chip->metadata);
         psFree(chip->toFPA);
         psFree(chip->fromFPA);
+    }
+}
+*/
+/*
+static void cellFree(psCell* cell)
+        psFree(chip->concepts);
+        psFree(chip->analysis);
+        psFree(chip->cells);
+        psFree(chip->parent);
+        psFree(chip->extname);
+        psFree(chip->pixels);
+        psFree(chip->header);
+    }
+}
+static void cellFree(pmCell *cell)
+{
     if (cell != NULL) {
+        psFree(cell->toChip);
+        psFree(cell->toFPA);
+        psFree(cell->toSky);
+        psFree(cell->concepts);
+        psFree(cell->analysis);
         psFree(cell->readouts);
+        psFree(cell->metadata);
+        psFree(cell->toChip);
+        psFree(cell->fromChip);
+        psFree(cell->toFPA);
+        psFree(cell->toTP);
+        psFree(cell->toSky);
+    }
+}
+*/
+static void readoutFree(psReadout* readout)
+        psFree(cell->parent);
+        psFree(cell->extname);
+        psFree(cell->pixels);
+        psFree(cell->header);
+    }
+}
+static void readoutFree(pmReadout *readout)
+{
     if (readout != NULL) {
         psFree(readout->image);
         psFree(readout->mask);
+        psFree(readout->objects);
+        psFree(readout->metadata);
+    }
+}
+/*
+static void observatoryFree(psObservatory* obs)
+{
+    if (obs != NULL) {
+        psFree(obs->name);
+    }
+}
+*/
+/*
+static void exposureFree(psExposure* exp)
+{
+    if (exp != NULL) {
+        psFree(exp->time);
+        psFree(exp->observatory);
+        psFree(exp->cameraName);
+        psFree(exp->telescopeName);
+    }
+}
+*/
+/*
+static void fixedPatternFree(psFixedPattern* fp)
+{
+    if (fp != NULL) {
+        for (psS32 i = 0; i < fp->p_ps_xRows; i++) {
+            psFree(fp->x[i]);
+        }
+        for (psS32 j = 0; j < fp->p_ps_yRows; j++) {
+            psFree(fp->y[j]);
+        }
+        psFree(fp->x);
+        psFree(fp->y);
+    }
+}
+*/
+        psFree(readout->analysis);
+        psFree(readout->concepts);
+        psFree(readout->parent);
+    }
+}
+pmReadout *pmReadoutAlloc(pmCell *cell)
+{
+    pmReadout *tmpReadout = (pmReadout *) psAlloc(sizeof(pmReadout));
+    tmpReadout->col0 = -1;
+    tmpReadout->row0 = -1;
+    tmpReadout->colBins = -1;
+    tmpReadout->rowBins = -1;
+    tmpReadout->image = NULL;
+    tmpReadout->mask = NULL;
+    tmpReadout->analysis = psMetadataAlloc();
+    tmpReadout->concepts = psMetadataAlloc();
+    tmpReadout->parent = cell;
+    if (cell != NULL) {
+        cell->readouts = psArrayAdd(cell->readouts, 1, (psPtr) tmpReadout);
+    }
+    psMemSetDeallocator(tmpReadout, (psFreeFunc) readoutFree);
+    return(tmpReadout);
+}
+pmCell *pmCellAlloc(pmChip *chip)
+{
+    pmCell *tmpCell = (pmCell *) psAlloc(sizeof(pmCell));
+    tmpCell->col0 = -1;
+    tmpCell->row0 = -1;
+    tmpCell->toChip = NULL;
+    tmpCell->toFPA = NULL;
+    tmpCell->toSky = NULL;
+    tmpCell->analysis = psMetadataAlloc();
+    tmpCell->concepts = psMetadataAlloc();
+    tmpCell->readouts = psArrayAlloc(0);
+    tmpCell->parent = chip;
+    if (chip != NULL) {
+        chip->cells = psArrayAdd(chip->cells, 1, (psPtr) tmpCell);
+    }
+    tmpCell->valid = false;
+    tmpCell->extname = NULL;
+    tmpCell->pixels = NULL;
+    tmpCell->header = NULL;
+    psMemSetDeallocator(tmpCell, (psFreeFunc) cellFree);
+    return(tmpCell);
+}
+pmChip *pmChipAlloc(pmFPA *fpa)
+{
+    pmChip *tmpChip = (pmChip *) psAlloc(sizeof(pmChip));
+    tmpChip->col0 = -1;
+    tmpChip->row0 = -1;
+    tmpChip->toFPA = NULL;
+    tmpChip->fromFPA = NULL;
+    tmpChip->concepts = psMetadataAlloc();
+    tmpChip->analysis = psMetadataAlloc();
+    tmpChip->cells = psArrayAlloc(0);
+    tmpChip->parent = fpa;
+    if (fpa != NULL) {
+        fpa->chips = psArrayAdd(fpa->chips, 1, (psPtr) tmpChip);
+    }
+    tmpChip->valid = false;
+    tmpChip->extname = NULL;
+    tmpChip->pixels = NULL;
+    tmpChip->header = NULL;
+    psMemSetDeallocator(tmpChip, (psFreeFunc) chipFree);
+    return(tmpChip);
+}
+pmFPA *pmFPAAlloc(
+    const psMetadata *camera,
+    psDB *db)
+{
+    pmFPA *tmpFPA = (pmFPA *) psAlloc(sizeof(pmFPA));
+    tmpFPA->fromTangentPlane = NULL;
+    tmpFPA->toTangentPlane = NULL;
+    tmpFPA->projection = NULL;
+    tmpFPA->concepts = psMetadataAlloc();
+    tmpFPA->analysis = psMetadataAlloc();
+    tmpFPA->camera = camera;
+    tmpFPA->chips = psArrayAlloc(0);
+    tmpFPA->header = NULL;
+    tmpFPA->db = db;
+    psMemSetDeallocator(tmpFPA, (psFreeFunc) FPAFree);
+    return(tmpFPA);
+}
+bool cellCheckParents(pmCell *cell)
+{
+    if (cell == NULL) {
+        return(true);
+    }
+    psBool flag = true;
+    for (psS32 i = 0 ; i < cell->readouts->n ; i++) {
+        pmReadout *tmpReadout = (pmReadout *) cell->readouts->data[i];
+        PS_ASSERT_PTR_NON_NULL(tmpReadout, false);
+        if (tmpReadout->parent != cell) {
+            tmpReadout->parent = cell;
+            flag = false;
+        }
+    }
+    return(flag);
+}
+bool chipCheckParents(pmChip *chip)
+{
+    if (chip == NULL) {
+        return(true);
+    }
+    psBool flag = true;
+    for (psS32 i = 0 ; i < chip->cells->n ; i++) {
+        pmCell *tmpCell = (pmCell *) chip->cells->data[i];
+        PS_ASSERT_PTR_NON_NULL(tmpCell, false);
+        if (tmpCell->parent != chip) {
+            tmpCell->parent = chip;
+            flag = false;
+        }
+        flag &= cellCheckParents(tmpCell);
+    }
+    return(flag);
+}
+bool pmFPACheckParents(pmFPA *fpa)
+{
+    if (fpa == NULL) {
+        return(true);
+    }
+    psBool flag = true;
+    for (psS32 i = 0 ; i < fpa->chips->n ; i++) {
+        pmChip *tmpChip = (pmChip *) fpa->chips->data[i];
+        PS_ASSERT_PTR_NON_NULL(tmpChip, false);
+        if (tmpChip->parent != fpa) {
+            tmpChip->parent = fpa;
+            flag = false;
+        }
+        flag &= chipCheckParents(tmpChip);
+    }
+    return(flag);
+}
+// HEY
 /*****************************************************************************/
 /* FUNCTION IMPLEMENTATION - PUBLIC                                          */
 /*****************************************************************************/
+/*
+ * XXX: Verify that you interpreted the SDR correctly.
+ *
+ * XXX: This assumes that x,y must be of type F64
+ */
+/*
+psFixedPattern* psFixedPatternAlloc(double x0,
+                                   double y0,
+                                   double xScale,
+                                   double yScale,
+                                   const psImage *x,
+                                   const psImage *y)
+{
+   psFixedPattern *tmp;
+   psS32 i;
+   psS32 j;
+   PS_ASSERT_IMAGE_NON_NULL(x, NULL);
+   PS_ASSERT_IMAGE_NON_NULL(y, NULL);
+   PS_ASSERT_IMAGE_TYPE(x, PS_TYPE_F64, NULL);
+   PS_ASSERT_IMAGE_TYPE(y, PS_TYPE_F64, NULL);
+   tmp = (psFixedPattern *) psAlloc(sizeof(psFixedPattern));
+   // XXX: Is this correct?
+   tmp->nX = (x->numCols * x->numRows);
+   tmp->nY = (y->numCols * y->numRows);
+   tmp->x0 = x0;
+   tmp->y0 = y0;
+   tmp->xScale = xScale;
+   tmp->yScale = yScale;
+   tmp->p_ps_xRows = x->numRows;
+   tmp->p_ps_xCols = x->numCols;
+   tmp->p_ps_yRows = y->numRows;
+   tmp->p_ps_yCols = y->numCols;
+   tmp->x = (double **) psAlloc(x->numRows * sizeof(double *));
+   for (i=0;i<x->numRows;i++) {
+       (tmp->x)[i] = (double *) psAlloc(x->numCols * sizeof(double));
+   }
+   for (i=0;i<x->numRows;i++) {
+       for (j=0;j<x->numCols;j++) {
+           (tmp->x)[i][j] = x->data.F64[i][j];
+       }
+   }
+   tmp->y = (double **) psAlloc(y->numRows * sizeof(double *));
+   for (i=0;i<y->numRows;i++) {
+       (tmp->y)[i] = (double *) psAlloc(y->numCols * sizeof(double));
+   }
+   for (i=0;i<y->numRows;i++) {
+       for (j=0;j<y->numCols;j++) {
+           (tmp->y)[i][j] = y->data.F64[i][j];
+       }
+   }
+   psMemSetDeallocator(tmp,(psFreeFunc)fixedPatternFree);
+   return(tmp);
+}
+*/
+/*
+psExposure* psExposureAlloc(double ra,
+                            double dec,
+                            double hourAngle,
+                            double zenithDistance,
+                            double azimuth,
+                            const psTime* time,
+                            float rotAngle,
+                            float temperature,
+                            float pressure,
+                            float humidity,
+                            float exposureTime,
+                            float wavelength,
+                            const psObservatory* observatory)
+{
+    PS_ASSERT_PTR_NON_NULL(observatory, NULL);
+    psExposure* exp = psAlloc(sizeof(psExposure));
+    *(double *)&exp->ra = ra;
+    *(double *)&exp->dec = dec;
+    *(double *)&exp->hourAngle = hourAngle;
+    *(double *)&exp->zenithDistance = zenithDistance;
+    *(double *)&exp->azimuth = azimuth;
+    *(float *)&exp->rotAngle = rotAngle;
+    *(float *)&exp->temperature = temperature;
+    *(float *)&exp->pressure = pressure;
+    *(float *)&exp->humidity = humidity;
+    *(float *)&exp->exposureTime = exposureTime;
+    *(float *)&exp->wavelength = wavelength;
+    exp->time = psMemIncrRefCounter((psPtr)time);
+    exp->observatory = psMemIncrRefCounter((psPtr)observatory);
+    // XXX: how is this value derived?
+    *(double *)&exp->lst = psTimeToLMST((psTime*)time,observatory->longitude);
+    *(float *)&exp->positionAngle = 0.0f; // XXX: need input, see Bug #207
+    *(float *)&exp->parallacticAngle = 0.0f; // XXX: need input, see Bug #207
+    *(float *)&exp->airmass = 0.0f; // XXX: needs calculation!  = slaAirmas(zenithDistance);
+    *(float *)&exp->parallacticFactor = 0.0f;
+    exp->cameraName = NULL;
+    exp->telescopeName = NULL;
+    psMemSetDeallocator(exp,(psFreeFunc)exposureFree);
+    return exp;
+}
+*/
+/*
+psObservatory* psObservatoryAlloc(const char* name,
+                                  double latitude,
+                                  double longitude,
+                                  double height,
+                                  double tlr)
+{
+    psObservatory* obs = psAlloc(sizeof(psObservatory));
+    if (name == NULL) {
+        obs->name = NULL;
+    } else {
+        obs->name = psAlloc(strlen(name)+1);
+        strcpy((char*)obs->name, name);
+    }
+    *(double *)&obs->latitude = latitude;
+    *(double *)&obs->longitude = longitude;
+    *(double *)&obs->height = height;
+    *(double *)&obs->tlr = tlr;
+    psMemSetDeallocator(obs,(psFreeFunc)observatoryFree);
+    return obs;
+}
+*/
+/*
+psFPA* psFPAAlloc(psS32 nChips,
+                  const psExposure* exp)
+{
+    PS_ASSERT_INT_NONNEGATIVE(nChips, NULL);
+    psFPA* newFPA = psAlloc(sizeof(psFPA));
+    // create array of NULL chips of the size nChips
+    newFPA->chips = psArrayAlloc(nChips);
+    psPtr* chips = newFPA->chips->data;
+    for (psS32 i=0;i<nChips;i++) {
+        chips[i] = NULL;
+    }
+    newFPA->chips->n = 0; // per requirement
+    newFPA->metadata = NULL;
+    newFPA->fromTangentPlane = NULL;
+    newFPA->toTangentPlane = NULL;
+    newFPA->pattern = NULL;
+    if (exp != NULL) {
+        newFPA->exposure = psMemIncrRefCounter((psExposure*)exp);
+        newFPA->grommit = psGrommitAlloc(exp);
+    } else {
+        newFPA->exposure = NULL;
+        newFPA->grommit = NULL;
+    }
+    newFPA->colorPlus = NULL;
+    newFPA->colorMinus = NULL;
+    newFPA->projection = NULL;
+    newFPA->rmsX = 0.0f;
+    newFPA->rmsY = 0.0f;
+    newFPA->chi2 = 0.0f;
+    psMemSetDeallocator(newFPA,(psFreeFunc)FPAFree);
+    return newFPA;
+}
+*/
+/*
+ * psChip constructor
+ */
+/*
+psChip* psChipAlloc(psS32 nCells,
+                    psFPA *parentFPA)
+{
+    PS_ASSERT_INT_NONNEGATIVE(nCells, NULL);
+    psChip* chip = psAlloc(sizeof(psChip));
+    // create array of NULL psCells
+    int n = (nCells > 0) ? nCells : 1;
+    chip->cells = psArrayAlloc(n);
+    psPtr* cells = chip->cells->data;
+    for (psS32 i=0;i<n;i++) {
+        cells[i] = NULL;
+    }
+    chip->cells->n = 0; // per requirement
+    *(int*)&chip->row0 = 0;
+    *(int*)&chip->col0 = 0;
+    chip->metadata = NULL;
+    chip->toFPA = NULL;
+    chip->fromFPA = NULL;
+    chip->parent = parentFPA;
+    psMemSetDeallocator(chip,(psFreeFunc)chipFree);
+    return chip;
+}
+*/
+/*
+ * psCell constructor
+ */
+/*
+psCell* psCellAlloc(psS32 nReadouts,
+                    psChip* parentChip)
+{
+    PS_ASSERT_INT_NONNEGATIVE(nReadouts, NULL);
+    psCell* cell = psAlloc(sizeof(psCell));
+    // create array of NULL psReadouts
+    int n = (nReadouts > 0) ? nReadouts : 1;
+    cell->readouts = psArrayAlloc(n);
+    psPtr* readouts = cell->readouts->data;
+    for (psS32 i=0;i<n;i++) {
+        readouts[i] = NULL;
+    }
+    cell->readouts->n = 0; // per requirement
+    *(int*)&cell->row0 = 0;
+    *(int*)&cell->col0 = 0;
+    cell->metadata = NULL;
+    cell->toChip = NULL;
+    cell->fromChip = NULL;
+    cell->toFPA = NULL;
+    cell->toTP = NULL;
+    cell->toSky = NULL;
+    cell->parent = parentChip;
+    psMemSetDeallocator(cell,(psFreeFunc)cellFree);
+    return cell;
+}
+*/
+psReadout *pmReadoutAlloc(pmCell *cell)
+{
+    psReadout* readout = psAlloc(sizeof(psReadout));
+    *(psU32*)&readout->colBins = 1;
+    *(psU32*)&readout->rowBins = 1;
+    *(psU32*)&readout->rowParity = 0;
+    *(psU32*)&readout->colParity = 0;
+    *(psS32*)&readout->col0 = 0;
+    *(psS32*)&readout->row0 = 0;
+    readout->image = NULL;
+    readout->mask = NULL;
+    readout->objects = NULL;
+    readout->metadata = NULL;
+    psMemSetDeallocator(readout,(psFreeFunc)readoutFree);
+    return readout;
+}
+/*
+psGrommit* psGrommitAlloc(const psExposure* exp)
+{
+    PS_ASSERT_PTR_NON_NULL(exp, NULL);
+    psSphere* polarMotion = p_psTimeGetPoleCoords(exp->time);
+    psGrommit* grommit = (psGrommit* ) psAlloc(sizeof(psGrommit));
+    *(double*)&grommit->latitude = exp->observatory->latitude;
+    *(double*)&grommit->longitude = exp->observatory->longitude;
+    *(double*)&grommit->height = exp->observatory->height;
+    *(double*)&grommit->abberationMag = 0.0; // XXX: need to figure out what to set here.
+    *(double*)&grommit->temperature = exp->temperature;
+    *(double*)&grommit->pressure = exp->pressure;
+    *(double*)&grommit->humidity = exp->humidity;
+    *(double*)&grommit->wavelength = exp->wavelength;
+    *(double*)&grommit->lapseRate = exp->observatory->tlr;
+    *(double*)&grommit->refractA = polarMotion->r; // XXX: need to figure out what to set here too.
+    *(double*)&grommit->refractB = polarMotion->d; // XXX: need to figure out what to set here too.
+    *(double*)&grommit->siderealTime = psTimeToMJD(exp->time); // XXX: this is probably not correct
+    psFree(polarMotion);
+    return (grommit);
+}
+*/
+/*
+psCell* psCellInFPA(const psPlane* fpaCoord,
+                    const psFPA* FPA)
+pmCell* pmCellInFPA(const psPlane* fpaCoord,
+                    const pmFPA* FPA)
+{
     PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(FPA, NULL);
     psChip* tmpChip = NULL;
+    pmChip* tmpChip = NULL;
     psPlane chipCoord;
     psCell* outCell = NULL;
+    pmCell* outCell = NULL;
     // Determine which chip contains the fpaCoords.
     tmpChip = psChipInFPA(fpaCoord, FPA);
+    tmpChip = pmChipInFPA(fpaCoord, FPA);
     if (tmpChip == NULL) {
         return(NULL);
+    }
     // Convert to those chip coordinates.
     psCoordFPAToChip(&chipCoord, fpaCoord, tmpChip);
     // Determine which cell contains those chip coordinates.
     outCell = psCellInChip(&chipCoord, tmpChip);
+    outCell = pmCellInChip(&chipCoord, tmpChip);
     return (outCell);
+}
+*/
+/*
+psChip* psChipInFPA(const psPlane* fpaCoord,
+                    const psFPA* FPA)
+pmChip* pmChipInFPA(const psPlane* fpaCoord,
+                    const pmFPA* FPA)
+{
     PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(FPA, NULL);
     PS_ASSERT_PTR_NON_NULL(FPA->chips, NULL);
     psArray* chips = FPA->chips;
     psS32 nChips = chips->n;
     psPlane chipCoord;
     psCell *tmpCell = NULL;
+    pmCell *tmpCell = NULL;
     // Loop through every chip in this FPA.  Convert the original FPA
     // coordinates to chip coordinates for that chip.  Then, determine if any
     // cells in that chip contain those chip coordinates.
     for (psS32 i = 0; i < nChips; i++) {
         psChip* tmpChip = chips->data[i];
+        pmChip* tmpChip = chips->data[i];
         PS_ASSERT_PTR_NON_NULL(tmpChip, NULL);
         PS_ASSERT_PTR_NON_NULL(tmpChip->fromFPA, NULL);
         psPlaneTransformApply(&chipCoord, tmpChip->fromFPA, fpaCoord);
         tmpCell = psCellInChip(&chipCoord, tmpChip);
+        tmpCell = pmCellInChip(&chipCoord, tmpChip);
         if (tmpCell != NULL) {
             return(tmpChip);
+        }
+    }
     // XXX: Print warning here?
     return (NULL);
+}
+*/
+/*
 psCell* psCellInChip(const psPlane* chipCoord,
                      const psChip* chip)
+pmCell* pmCellInChip(const psPlane* chipCoord,
+                     const pmChip* chip)
+{
     PS_ASSERT_PTR_NON_NULL(chipCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(chip, NULL);
     psPlane cellCoord;
     psArray* cells;
     cells = chip->cells;
     if (cells == NULL) {
         return NULL;
+    }
     // We loop over each cell in the chip.  We transform the chipCoord into
     // a cellCoord for that cell and determine if that cellCoord is valid.
     // If so, then we return that cell.
     for (psS32 i = 0; i < cells->n; i++) {
         psCell* tmpCell = (psCell* ) cells->data[i];
+        pmCell* tmpCell = (pmCell* ) cells->data[i];
         PS_ASSERT_PTR_NON_NULL(tmpCell, NULL);
+        PS_ASSERT_PTR_NON_NULL(tmpCell->fromChip, NULL);
+        psPlaneTransform *chipToCell = NULL;
+        if (1 != p_psIsProjectionLinear(tmpCell->toChip)) {
+            // XXX: Generate warning message.
+            // XXX: Can we use the following function to derive a transform?
+            // chipToCell = psPlaneTransformInvert(NULL, tmpCell->toChip, NULL, -1);
+        } else {
+            chipToCell = p_psPlaneTransformLinearInvert(tmpCell->toChip);
+        }
+        PS_ASSERT_PTR_NON_NULL(chipToCell, NULL);
         psArray* readouts = tmpCell->readouts;
         if (readouts != NULL) {
             for (psS32 j = 0; j < readouts->n; j++) {
                 psReadout* tmpReadout = readouts->data[j];
+                pmReadout* tmpReadout = readouts->data[j];
                 PS_ASSERT_READOUT_NON_NULL(tmpReadout, NULL);
                 psPlaneTransformApply(&cellCoord,
                                       tmpCell->fromChip,
+                                      chipToCell,
                                       chipCoord);
                 if (checkValidImageCoords(cellCoord.x,
                                           cellCoord.y,
 …
+            }
+        }
+    }
+        psFree(chipToCell);
+    }
     return (NULL);
+}
+*/
+/*
 psPlane* psCoordCellToChip(psPlane* outCoord,
                            const psPlane* inCoord,
                            const psCell* cell)
+                           const pmCell* cell)
+{
     PS_ASSERT_PTR_NON_NULL(inCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(cell, NULL);
     return (psPlaneTransformApply(outCoord, cell->toChip, inCoord));
+}
+*/
+/*
 psPlane* psCoordChipToFPA(psPlane* outCoord,
                           const psPlane* inCoord,
                           const psChip* chip)
+                          const pmChip* chip)
+{
     PS_ASSERT_PTR_NON_NULL(inCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(chip, NULL);
     return (psPlaneTransformApply(outCoord, chip->toFPA, inCoord));
+}
+*/
+/*
 psPlane* psCoordFPAToTP(psPlane* outCoord,
                         const psPlane* inCoord,
                         double color,
                         double magnitude,
                         const psFPA* fpa)
+                        const pmFPA* fpa)
+{
     PS_ASSERT_PTR_NON_NULL(inCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(fpa, NULL);
     return(psPlaneDistortApply(outCoord, fpa->toTangentPlane, inCoord,
                                color, magnitude));
+}
+*/
 /*****************************************************************************
 XXX: What about units for the (x,y) coords?
  *****************************************************************************/
-/*
 psSphere* psCoordTPToSky(psSphere* outSphere,
                          const psPlane* tpCoord,
+                         const psGrommit* grommit)
+                         const psProjection *projection
+                        )
+{
     PS_ASSERT_PTR_NON_NULL(tpCoord, NULL);
+    PS_ASSERT_PTR_NON_NULL(grommit, NULL);
     if (outSphere == NULL) {
         outSphere = (psSphere* ) psAlloc(sizeof(psSphere));
+    }
     // XXX: this was done by a SLALIB call -- needs to be reimplemented
     psWarning("Warning!  psCoordTPToSky functionality is no longer implemented");
     // slaAopqk(tpCoord->x, tpCoord->y, (double*)grommit,
     //         &AOB, &ZOB, &HOB, &outSphere->r, &outSphere->d);
     return (outSphere);
+}
+*/
+/*
 psPlane* psCoordCellToFPA(psPlane* fpaCoord,
                           const psPlane* cellCoord,
                           const psCell* cell)
+                          const pmCell* cell)
+{
     PS_ASSERT_PTR_NON_NULL(cellCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(cell, NULL);
     return (psPlaneTransformApply(fpaCoord, cell->toFPA, cellCoord));
+}
+*/
+/*
 psSphere* psCoordCellToSky(psSphere* skyCoord,
                            const psPlane* cellCoord,
                            double color,
                            double magnitude,
                            const psCell* cell)
+                           const pmCell* cell)
+{
     PS_ASSERT_PTR_NON_NULL(cellCoord, NULL);
 …
     PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL);
     PS_ASSERT_PTR_NON_NULL(cell->parent->parent->toTangentPlane, NULL);
     PS_ASSERT_PTR_NON_NULL(cell->parent->parent->exposure, NULL);
+    //    PS_ASSERT_PTR_NON_NULL(cell->parent->parent->exposure, NULL);
     psPlane* fpaCoord = NULL;
     psPlane* tpCoord = NULL;
     psFPA* parFPA = (cell->parent)->parent;
     psGrommit* tmpGrommit = NULL;
+    pmFPA* parFPA = (cell->parent)->parent;
+    //    psGrommit* tmpGrommit = NULL;
     // Convert the input cell coordinates to FPA coordinates.
     fpaCoord = psPlaneTransformApply(fpaCoord, cell->toFPA, cellCoord);
     // Convert the FPA coordinates to tangent plane Coordinates.
     tpCoord = psPlaneDistortApply(tpCoord, parFPA->toTangentPlane,
                                   fpaCoord, color, magnitude);
     // Generate a grommit for this FPA.
     tmpGrommit = psGrommitAlloc(parFPA->exposure);
+    //    tmpGrommit = psGrommitAlloc(parFPA->exposure);
     // Convert the tangent plane Coordinates to sky coordinates.
     skyCoord = psCoordTPToSky(skyCoord, tpCoord, tmpGrommit);
+    //    skyCoord = psCoordTPToSky(skyCoord, tpCoord, tmpGrommit);
     psFree(fpaCoord);
     psFree(tpCoord);
     psFree(tmpGrommit);
+    //    psFree(tmpGrommit);
     return(skyCoord);
+}
+*/
+/*
 psSphere* psCoordCellToSkyQuick(psSphere* outSphere,
                                 const psPlane* cellCoord,
                                 const psCell* cell)
+                                const pmCell* cell)
+{
     PS_ASSERT_PTR_NON_NULL(cellCoord, NULL);
 …
     PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL);
     PS_ASSERT_PTR_NON_NULL(cell->parent->parent->projection, NULL);
+    if (cell->toSky) {
+        // XXX: Should we use toTP or toSky?
+        psLogMsg(__func__, PS_LOG_WARN,
+                 "WARNING: psCoordCellToSkyQuick(): The cell->toSky transform is ignored.  The cell->toTP transform is being used.");
+    }
+    psPlane *tpCoord = NULL;
+    psChip *chip = cell->parent;
+    psFPA *FPA = chip->parent;
+    psProjectionType oldProjectionType;
+    if (outSphere == NULL) {
+        outSphere = (psSphere* ) psAlloc(sizeof(psSphere));
+    }
+    // Determine the tangent plane coordinates.
+    tpCoord = psPlaneTransformApply(NULL, cell->toTP, cellCoord);
+    // Save the old projection type and set the new projection type to TAN.
+    oldProjectionType = FPA->projection->type;
+    FPA->projection->type = PS_PROJ_TAN;
+    // Deproject the tangent plane coordinates a sphere.
+    outSphere = psDeproject(tpCoord, FPA->projection);
+    // Restore old projection type.  Free memory.
+    FPA->projection->type = oldProjectionType;
+    psFree(tpCoord);
+    return (outSphere);
+}
+*/
+    psLogMsg(__func__, PS_LOG_WARN,
+             "WARNING: psCoordCellToSkyQuick(): This function is not fully specified in the SDRS.  Returning NULL.\n");
+    return(NULL);
+    /*
+        if (cell->toSky) {
+            // XXX: Should we use toTP or toSky?
+            psLogMsg(__func__, PS_LOG_WARN,
+                     "WARNING: psCoordCellToSkyQuick(): The cell->toSky transform is ignored.  The cell->toTP transform is being used.");
+        }
+        psPlane *tpCoord = NULL;
+        pmChip *chip = cell->parent;
+        pmFPA *FPA = chip->parent;
+        psProjectionType oldProjectionType;
+        if (outSphere == NULL) {
+            outSphere = (psSphere* ) psAlloc(sizeof(psSphere));
+        }
+        // Determine the tangent plane coordinates.
+        tpCoord = psPlaneTransformApply(NULL, cell->toTP, cellCoord);
+        // Save the old projection type and set the new projection type to TAN.
+        oldProjectionType = FPA->projection->type;
+        FPA->projection->type = PS_PROJ_TAN;
+        // Deproject the tangent plane coordinates a sphere.
+        outSphere = psDeproject(tpCoord, FPA->projection);
+        // Restore old projection type.  Free memory.
+        FPA->projection->type = oldProjectionType;
+        psFree(tpCoord);
+        return (outSphere);
+    */
+}
 /*****************************************************************************
 XXX: What about units for the (x,y) coords?
  *****************************************************************************/
-/*
 psPlane* psCoordSkyToTP(psPlane* tpCoord,
                         const psSphere* in,
                         const psGrommit* grommit)
+                        const psProjection *projection)
+{
     PS_ASSERT_PTR_NON_NULL(in, NULL);
     PS_ASSERT_PTR_NON_NULL(grommit, NULL);
+    //    PS_ASSERT_PTR_NON_NULL(grommit, NULL);
     // char* type = "RA";
     if (tpCoord == NULL) {
         tpCoord = (psPlane* ) psAlloc(sizeof(psPlane));
+    }
     // XXX: this was done by a SLALIB call -- needs to be reimplemented
     psWarning("Warning!  psCoordSkyToTP functionality is no longer implemented");
     // slaOapqk(type, in->r, in->d, (double*)grommit, &tpCoord->x, &tpCoord->y);
     return(tpCoord);
+}
+*/
+/*
 psPlane* psCoordTPToFPA(psPlane* fpaCoord,
                         const psPlane* tpCoord,
                         double color,
                         double magnitude,
                         const psFPA* fpa)
+                        const pmFPA* fpa)
+{
     PS_ASSERT_PTR_NON_NULL(tpCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(fpa, NULL);
     PS_ASSERT_PTR_NON_NULL(fpa->fromTangentPlane, NULL);
     return (psPlaneDistortApply(fpaCoord, fpa->fromTangentPlane,
                                 tpCoord, color, magnitude));
+}
+*/
+/*
 psPlane* psCoordFPAToChip(psPlane* chipCoord,
                           const psPlane* fpaCoord,
                           const psChip* chip)
+                          const pmChip* chip)
+{
     PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(chip, NULL);
     PS_ASSERT_PTR_NON_NULL(chip->fromFPA, NULL);
     chipCoord = psPlaneTransformApply(chipCoord, chip->fromFPA, fpaCoord);
     return(chipCoord);
+}
+*/
+/*
 psPlane* psCoordChipToCell(psPlane* cellCoord,
                            const psPlane* chipCoord,
                            const psCell* cell)
+                           const pmCell* cell)
+{
     PS_ASSERT_PTR_NON_NULL(chipCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(cell, NULL);
+    PS_ASSERT_PTR_NON_NULL(cell->fromChip, NULL);
+    cellCoord = psPlaneTransformApply(cellCoord, cell->fromChip, chipCoord);
+    PS_ASSERT_PTR_NON_NULL(cell->parent, NULL);
+    pmCell *tmpCell = pmCellInChip(chipCoord, cell->parent);
+    PS_ASSERT_PTR_NON_NULL(tmpCell->toChip, NULL);
+    psPlaneTransform *tmpChipToCell = p_psPlaneTransformLinearInvert(tmpCell->toChip);
+    PS_ASSERT_PTR_NON_NULL(tmpChipToCell, NULL);
+    cellCoord = psPlaneTransformApply(cellCoord, tmpChipToCell, chipCoord);
+    psFree(tmpChipToCell);
     return(cellCoord);
+}
+*/
+/*
 psPlane* psCoordSkyToCell(psPlane* cellCoord,
                           const psSphere* skyCoord,
                           double color,
                           double magnitude,
                           const psCell* cell)
+                          float color,
+                          float magnitude,
+                          const pmCell* cell)
+{
     PS_ASSERT_PTR_NON_NULL(skyCoord, NULL);
 …
     PS_ASSERT_PTR_NON_NULL(cell->parent, NULL);
     PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL);
+    PS_ASSERT_PTR_NON_NULL(cell->parent->parent->grommit, NULL);
+    psChip *parChip = cell->parent;
+    psFPA *parFPA = parChip->parent;
+    psGrommit* grommit = parFPA->grommit;
+    //    PS_ASSERT_PTR_NON_NULL(cell->parent->parent->grommit, NULL);
+    pmChip *parChip = cell->parent;
+    pmFPA *parFPA = parChip->parent;
     // Convert the skyCoords to tangent plane coords.
     psPlane *tpCoord = psCoordSkyToTP(tpCoord, skyCoord, grommit);
+    psPlane *tpCoord = psCoordSkyToTP(NULL, skyCoord, parFPA->projection);
     // Convert the tangent plane coords to FPA coords.
+    psPlane *fpaCoord = psCoordTPToFPA(fpaCoord, tpCoord, color,
+                                       magnitude, parFPA);
+    psPlane *fpaCoord = psCoordTPToFPA(NULL, tpCoord, color, magnitude, parFPA);
     // Convert the FPA coords to chip coords.
     psPlane *chipCoord = psCoordFPAToChip(chipCoord, fpaCoord, parChip);
+    psPlane *chipCoord = psCoordFPAToChip(NULL, fpaCoord, parChip);
     // Convert the chip coords to cell coords.
     cellCoord = psCoordChipToCell(cellCoord, chipCoord, cell);
     psFree(tpCoord);
     psFree(fpaCoord);
     psFree(chipCoord);
     return (cellCoord);
+}
+*/
+/*
 psPlane* psCoordSkyToCellQuick(psPlane* cellCoord,
                                const psSphere* skyCoord,
                                const psCell* cell)
+                               const pmCell* cell)
+{
     PS_ASSERT_PTR_NON_NULL(skyCoord, NULL);
 …
     PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL);
     PS_ASSERT_PTR_NON_NULL(cell->parent->parent->projection, NULL);
+    PS_ASSERT_PTR_NON_NULL(cell->toTP, NULL);
+    if (cell->toSky) {
+        // XXX: Should we use toTP or toSky?
+        psLogMsg(__func__, PS_LOG_WARN,
+                 "WARNING: psCoordSkyToCellQuick(): The cell->toSky transform is ignored.  The cell->toTP transform is being used.");
+    }
+    psPlane *tpCoord = NULL;
+    psChip *whichChip = cell->parent;
+    psFPA *whichFPA = whichChip->parent;
+    psProjectionType oldProjectionType;
+    psPlaneTransform *TPtoCell = NULL;
+    // Save the old projection type and set the new projection type to TAN.
+    oldProjectionType = whichFPA->projection->type;
+    whichFPA->projection->type = PS_PROJ_TAN;
+    if (cellCoord == NULL) {
+        cellCoord = (psPlane* ) psAlloc(sizeof(psPlane));
+    }
+    tpCoord = psProject(skyCoord, whichFPA->projection);
+    // generate an error if cell->toTP is not linear.
+    if (0 == p_psIsProjectionLinear(cell->toTP)) {
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psAstrometry_NONLINEAR_TRANSFORM,
+                "cell to tangent plane");
+    }
+    TPtoCell = p_psPlaneTransformLinearInvert(cell->toTP);
+    cellCoord = psPlaneTransformApply(cellCoord, TPtoCell, tpCoord);
+    // Restore old projection type.  Free memory.
+    whichFPA->projection->type = oldProjectionType;
+    psFree(tpCoord);
+    return (cellCoord);
+}
+*/
+    psLogMsg(__func__, PS_LOG_WARN,
+             "WARNING: psCoordSkyToCellQuick(): This function is not fully specified in the SDRS.  Returning NULL.\n");
+    return(NULL);
+    /*
+        if (cell->toSky) {
+            // XXX: Should we use toTP or toSky?
+            psLogMsg(__func__, PS_LOG_WARN,
+                     "WARNING: psCoordSkyToCellQuick: The cell->toSky transform is ignored.  The cell->toTP transform is being used.");
+        }
+        psPlane *tpCoord = NULL;
+        pmChip *whichChip = cell->parent;
+        pmFPA  *whichFPA = whichChip->parent;
+        psProjectionType oldProjectionType;
+        psPlaneTransform *TPtoCell = NULL;
+        // Save the old projection type and set the new projection type to TAN.
+        oldProjectionType = whichFPA->projection->type;
+        whichFPA->projection->type = PS_PROJ_TAN;
+        if (cellCoord == NULL) {
+            cellCoord = (psPlane* ) psAlloc(sizeof(psPlane));
+        }
+        tpCoord = psProject(skyCoord, whichFPA->projection);
+        // generate an error if cell->toTP is not linear.
+        if (0 == p_psIsProjectionLinear(cell->toTP)) {
+            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                    PS_ERRORTEXT_psAstrometry_NONLINEAR_TRANSFORM,
+                    "cell to tangent plane");
+        }
+        TPtoCell = p_psPlaneTransformLinearInvert(cell->toTP);
+        cellCoord = psPlaneTransformApply(cellCoord, TPtoCell, tpCoord);
+        // Restore old projection type.  Free memory.
+        whichFPA->projection->type = oldProjectionType;
+        psFree(tpCoord);
+        return (cellCoord);
+    */
+}

trunk/psModules/src/pmAstrometry.h

-              r4754
+              r4770
 *  @author GLG, MHPCC
+*
 *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
 *  @date $Date: 2005-08-11 00:03:51 $
+*  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-08-16 01:10:34 $
+*
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
 …
     // Information
     psImage *image;                     ///< Imaging area of readout
+    // XXX: The following mask was removed from the pmReadout struct in recent SDRS
+    // versions.  However, I'm keeping it here since al ot of modules still require
+    // it.
+    psImage *mask;                      ///< Mask of input image
     psMetadata *analysis;               ///< Readout-level analysis metadata
     psMetadata *concepts;               ///< Cache for PS Concepts
     pmCell *parent;                     ///< Parent cell
+}
+psReadout;
+/** Allocates a psReadout
+pmReadout;
+/** Allocates a pmReadout
+ *
  *  The constructor shall make an empty pmReadout. If the parent cell is not
 …
  *  other pointers in the structure shall be initialized to NULL.
+ *
  *  @return psReadout*    newly allocated psReadout with all internal pointers set to NULL
  */
 psReadout *pmReadoutAlloc(
+ *  @return pmReadout*    newly allocated pmReadout with all internal pointers set to NULL
+ */
+pmReadout *pmReadoutAlloc(
     pmCell *cell                        ///< Parent cell
 );
 /** Allocates a psCell
+/** Allocates a pmCell
+ *
  *  The constructor shall make an empty pmCell. If the parent chip is not NULL,
+ *  the parent link is made and the cell shall be placed in the parentThe
+ *  constructor shall make an empty psCell.s array of cells. The readouts
+ *  array shall be allocated with a zero size, and the metadata containers
+ *  constructed. All other pointers in the structure shall be initialized to
+ *  NULL.
+ *
+ *  @return psCell*    newly allocated psCell
+ *  the parent link is made and the cell shall be placed in the parents array of
+ *  cells. The readouts array shall be allocated with a zero size, and the
+ *  metadata containers constructed. All other pointers in the structure shall be
+ *  initialized to NULL.
+ *
+ *  @return pmCell*    newly allocated pmCell
  */
 pmCell *pmCellAlloc(
 …
  */
 pmFPA *pmFPAAlloc(
+    const psMetadata *camera           ///< Camera configuration
+    //    psDB *db                            ///< Database handle
+);
+    const psMetadata *camera,           ///< Camera configuration
+    psDB *db                            ///< Database handle
+);
+/** Verify parent links.
+ *
+ *  This function checks the validity of the parent links in the FPA hierarchy.
+ *  If a parent link is not set (or not set correctly), it is corrected, and the
+ *  function shall return false. If all the parent pointers were correct, the
+ *  function shall return true.
+ *
+ */
+bool pmFPACheckParents(
+    pmFPA *fpa
+);
+/** FUNC DESC
+ *
+ *
+ *
+ *
+ */
 …
-/** Wallace's Grommit
+ *
- *  SLALib requires several elements to perform the transformations between
- *  the tangent plane and the sky.  Pre-computing these quantities for each
- *  exposure means that subsequent transformations are faster.  For historical
- *  reasons, this structure is known colloquially as "Wallace's Grommit".
+ *
- */
-/*
-typedef struct
+{
-   const double latitude;           ///< geodetic latitude (radians)
-   const double longitude;          ///< longitude + ... (radians)
-   const double height;             ///< height (HM)
-   const double abberationMag;      ///< magnitude of diurnal aberration vector
-   const double temperature;        ///< ambient temperature (TDK)
-   const double pressure;           ///< pressure (PMB)
-   const double humidity;           ///< relative humidity (RH)
-   const double wavelength;         ///< wavelength (WL)
-   const double lapseRate;          ///< lapse rate (TLR)
-   const double refractA, refractB; ///< refraction constants A and B (radians)
-   const double siderealTime;       ///< local apparent sidereal time (radians)
+}
-psGrommit;
-*/
-/** Fixed Pattern Corrections
+ *
- *  The fixed pattern is a correction to the general astrometric solution
- *  formed by summing the residuals from many observations. The intent is to
- *  correct for higher-order distortions in the camera system on a coarse
- *  grid (larger than individual pixels, but smaller than a single cell).
- *  Hence, in addition to the offsets, we need to specify the size and scale
- *  of the grid in x and y as well as the origin of the grid.
- */
-/*
-typedef struct
+{
-    psS32 nX;                            ///< Number of elements in x direction
-    psS32 nY;                            ///< Number of elements in y direction
-    double x0;                         ///< X Position of 0,0 corner on focal plane
-    double y0;                         ///< Y Position of 0,0 corner on focal plane
-    double xScale;                     ///< Scale of the grid in x direction
-    double yScale;                     ///< Scale of the grid in x direction
-    /// XXX: I added the following memvers to facilitate the psFreeing of the x,y data structures.
-    psS32 p_ps_xRows;                    ///< Number of rows in the x member
-    psS32 p_ps_xCols;                    ///< Number of cols in the x member
-    psS32 p_ps_yRows;                    ///< Number of rows in the y member
-    psS32 p_ps_yCols;                    ///< Number of cols in the y member
-    double **x;                        ///< The grid of offsets in x
-    double **y;                        ///< The grid of offsets in y
+}
-psFixedPattern;
-*/
-/** Observatory Information
+ *
- *  A container for the observatory data that doesn't change per exposure.
+ *
- */
-/*typedef struct
+{
-    const char* name;                  ///< Name of observatory
-    const double latitude;             ///< Latitude of observatory, east positive (degrees?)
-    const double longitude;            ///< Longitude of observatory (degrees?)
-    const double height;               ///< Height of observatory in meters
-    const double tlr;                  ///< Tropospheric Lapse Rate
+}
-psObservatory;
-*/
-/** Exposure Information
+ *
- *  Several quantities from the telescope in order to make a first guess at
- *  the astrometric solution.  From these quantities, further quantities can
- *  be derivedand stored for later use.
+ *
- */
-/*typedef struct psExposure
+{
-    const double ra;                   ///< Telescope boresight, right ascention
-    const double dec;                  ///< Telescope boresight, declination
-    const double hourAngle;            ///< Hour angle
-    const double zenithDistance;       ///< Zenith distance
-    const double azimuth;              ///< Azimuth
-    const psTime* time;                ///< Time of observation
-    const float rotAngle;              ///< Rotator position angle in degrees? XXX: see bug#209
-    const float temperature;           ///< Air temperature in Kelvin
-    const float pressure;              ///< Air pressure in mB
-    const float humidity;              ///< Relative humidity, for refraction
-    const float exposureTime;          ///< Exposure time
-    const float wavelength;            ///< Wavelength in microns
-    const psObservatory* observatory;  ///< Observatory data
-    // Derived quantities
-    const double lst;                  ///< Local Sidereal Time
-    const float positionAngle;         ///< Position angle
-    const float parallacticAngle;      ///< Parallactic angle
-    const float airmass;               ///< Airmass, calculated from zenith distance
-    const float parallacticFactor;     ///< Parallactic factor
-    const char* cameraName;            ///< name of camera which provided exposure
-    const char* telescopeName;         ///< name of telescope which provided exposure
+}
-psExposure;
-*/
-/** Allocator for psFixedPattern struct
+ *
- *  Allocates a new psFixedPattern struct with the attributes coorsponding
- *  to the parameters set to the said input values.
+ *
- *  @return psFixedPattern*     New psFixedPattern struct.
- */
-/*psFixedPattern* psFixedPatternAlloc(
-    double x0,           ///< X Position of 0,0 corner on focal plane
-    double y0,           ///< Y Position of 0,0 corner on focal plane
-    double xScale,       ///< Scale of the grid in x direction
-    double yScale,       ///< Scale of the grid in x direction
-    const psImage *x,    ///< The grid of offsets in x
-    const psImage *y     ///< The grid of offsets in y
-);
-*/
-/** Allocator for psExposure
+ *
- *  We need several quantities from the telescope in order to make a first
- *  guess at the astrometric solution. From these quantities, further
- *  quantities can be derived and stored for later use.
+ *
- *  @return     psExposure*    New psExposure struct
- */
-/*psExposure* psExposureAlloc(
-    double ra,                         ///< Telescope boresight, right ascention
-    double dec,                        ///< Telescope boresight, declination
-    double hourAngle,                  ///< Hour angle
-    double zenithDistance,             ///< Zenith distance
-    double azimuth,                    ///< Azimuth
-    const psTime* time,                ///< time of observation
-    float rotAngle,                    ///< Rotator position angle
-    float temperature,                 ///< Temperature
-    float pressure,                    ///< Pressure
-    float humidity,                    ///< Relative humidity
-    float exposureTime,                ///< Exposure time
-    float wavelength,                  ///< wavelength
-    const psObservatory* observatory   ///< Observatory data
-);
-*/
-/** Allocator for psObservatory
+ *
- *  This function shall construct a new psObservatory with attributes
- *  cooresponding to the function parameters.
+ *
- *  @return psObservatory*    new psObservatory struct
- */
-/*psObservatory* psObservatoryAlloc(
-    const char* name,                  ///< Name of observatory
-    double latitude,                   ///< Latitude of observatory, east positive
-    double longitude,                  ///< Longitude of observatory
-    double height,                     ///< Height of observatory
-    double tlr                         ///< Tropospheric Lapse Rate
-);
-*/
-/** Allocates a Wallace's Grommit structure.
+ *
- *  The psGrommit is calculated from telescope information for the particular
- *  exposure.
+ *
- *  @return psGrommit* New grommit structure.
- */
-/*psGrommit* psGrommitAlloc(
-    const psExposure* exp              ///< the cooresponding exposure structure.
-);
-*/
 /** Find cooresponding cell for given FPA coordinate
+ *
  *  @return psCell*    the cell cooresponding to the coord in FPA
  */
 /*psCell* psCellInFPA(
+ *  @return pmCell*    the cell cooresponding to the coord in FPA
+ */
+pmCell* pmCellInFPA(
     const psPlane* coord,              ///< the coordinate in FPA plane
     const psFPA* FPA                   ///< the FPA to search for the cell
 );
+*/
+    const pmFPA* FPA                   ///< the FPA to search for the cell
+);
 /** Find cooresponding chip for given FPA coordinate
+ *
  *  @return psChip*    the chip cooresponding to coord
  */
 /*psChip* psChipInFPA(
+ *  @return pmChip*    the chip cooresponding to coord
+ */
+pmChip* pmChipInFPA(
     const psPlane* coord,              ///< the coordinate in FPA plane
     const psFPA* FPA                   ///< the FPA to search for the cell
 );
+*/
+    const pmFPA* FPA                   ///< the FPA to search for the cell
+);
 /** Find cooresponding cell for given Chip coordinate
+ *
  *  @return psCell*    the cell cooresponding to coord
  */
 /*psCell* psCellInChip(
+ *  @return pmCell*    the cell cooresponding to coord
+ */
+pmCell* pmCellInChip(
     const psPlane* coord,              ///< the coordinate in Chip plane
     const psChip* chip                 ///< the chip to search for the cell
 );
+*/
+    const pmChip* chip                 ///< the chip to search for the cell
+);
 /** Translate a cell coordinate into a chip coordinate
 …
  *  @return psPlane*    the resulting chip coordinate
  */
 /*psPlane* psCoordCellToChip(
+psPlane* psCoordCellToChip(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psPlane* in,                 ///< the coordinate within Cell
     const psCell* cell                 ///< the Cell in interest
 );
+*/
+    const pmCell* cell                 ///< the Cell in interest
+);
 /** Translate a chip coordinate into a FPA coordinate
 …
  *  @return psPlane*    the resulting FPA coordinate
  */
 /*psPlane* psCoordChipToFPA(
+psPlane* psCoordChipToFPA(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psPlane* in,                 ///< the coordinate within Chip
     const psChip* chip                 ///< the chip in interest
 );
+*/
+    const pmChip* chip                 ///< the chip in interest
+);
 /** Translate a FPA coordinate into a Tangent Plane coordinate
 …
  *  @return psPlane*    the resulting Tangent Plane coordinate
  */
 /*psPlane* psCoordFPAToTP(
+psPlane* psCoordFPAToTP(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psPlane* in,                 ///< the coordinate within FPA
     double color,                      ///< Color of source
     double magnitude,                  ///< Magnitude of source
     const psFPA* fpa                   ///< the FPA in interest
 );
+*/
+    const pmFPA* fpa                   ///< the FPA in interest
+);
 /** Translate a Tangent Plane coordinate into a Sky coordinate
 …
  *  @return psSphere*    the resulting Sky coordinate
  */
 /*psSphere* psCoordTPToSky(
+psSphere* psCoordTPToSky(
     psSphere* out,                     ///< a sphere struct to recycle. If NULL, a new struct is created
+    const psPlane* in,                 ///< the coordinate within Tangent Plane
+    const psGrommit* grommit           ///< the grommit of the tangent plane
+);
+*/
+    const psPlane* in,                ///< the coordinate within Tangent Plane
+    const psProjection *projection
+);
 /** Translate a cell coordinate into a FPA coordinate
 …
  *  @return psPlane*    the resulting FPA coordinate
  */
 /*psPlane* psCoordCellToFPA(
+psPlane* psCoordCellToFPA(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psPlane* in,                 ///< the coordinate within cell
     const psCell* cell                 ///< the cell in interest
 );
+*/
+    const pmCell* cell                 ///< the cell in interest
+);
 /** Translate a cell coordinate into a Sky coordinate
 …
  *  @return psSphere*    the resulting Sky coordinate
  */
 /*psSphere* psCoordCellToSky(
+psSphere* psCoordCellToSky(
     psSphere* out,                     ///< a sphere struct to recycle. If NULL, a new struct is created
     const psPlane* in,                 ///< the coordinate within cell
     double color,                      ///< Color of source
     double magnitude,                  ///< Magnitude of source
     const psCell* cell                 ///< the cell in interest
 );
+*/
+    const pmCell* cell                 ///< the cell in interest
+);
 /** Translate a cell coordinate into a Sky coordinate using a 'quick and
 …
  *  @return psSphere*    the resulting Sky coordinate
  */
 /*psSphere* psCoordCellToSkyQuick(
+psSphere* psCoordCellToSkyQuick(
     psSphere* out,                     ///< a sphere struct to recycle. If NULL, a new struct is created
     const psPlane* in,                 ///< the coordinate within cell
     const psCell* cell                 ///< the cell in interest
 );
+*/
+    const pmCell* cell                 ///< the cell in interest
+);
 /** Translate a Sky coordinate into a Tangent Plane coordinate
 …
  *  @return psPlane*    the resulting Tangent Plane coordinate
  */
 /*psPlane* psCoordSkyToTP(
+psPlane* psCoordSkyToTP(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psSphere* in,                ///< the sky coordinate
+    const psGrommit* grommit           ///< the grommit
+);
+*/
+    const psProjection *projection
+);
 /** Translate a Tangent Plane coordinate into a FPA coordinate
 …
  *  @return psPlane*    the resulting FPA coordinate
  */
 /*psPlane* psCoordTPToFPA(
+psPlane* psCoordTPToFPA(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psPlane* in,                 ///< the coordinate within tangent plane
     double color,                      ///< Color of source
     double magnitude,                  ///< Magnitude of source
     const psFPA* fpa                   ///< the FPA of interest
 );
+*/
+    const pmFPA* fpa                   ///< the FPA of interest
+);
 /** Translate a FPA coordinate into a chip coordinate
 …
  *  @return psPlane*    the resulting chip coordinate
  */
 /*psPlane* psCoordFPAToChip(
+psPlane* psCoordFPAToChip(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psPlane* in,                 ///< the FPA coordinate
     const psChip* chip                 ///< the chip of interest
 );
+*/
+    const pmChip* chip                 ///< the chip of interest
+);
 /** Translate a chip coordinate into a cell coordinate
 …
  *  @return psPlane*    the resulting cell coordinate
  */
 /*psPlane* psCoordChipToCell(
+psPlane* psCoordChipToCell(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psPlane* in,                 ///< the Chip coordinate
     const psCell* cell                 ///< the cell of interest
 );
+*/
+    const pmCell* cell                 ///< the cell of interest
+);
 /** Translate a sky coordinate into a cell coordinate
 …
  *  @return psPlane*    the resulting cell coordinate
  */
 /*psPlane* psCoordSkyToCell(
+psPlane* psCoordSkyToCell(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psSphere* in,                ///< the Sky coordinate
     double color,                      ///< Color of source
     double magnitude,                  ///< Magnitude of source
     const psCell* cell                 ///< the cell of interest
 );
+*/
+    float color,                       ///< Color of source
+    float magnitude,                   ///< Magnitude of source
+    const pmCell* cell                 ///< the cell of interest
+);
 /** Translate a sky coordinate into a cell coordinate using a 'quick and
 …
  *  @return psPlane*    the resulting cell coordinate
  */
 /*psPlane* psCoordSkyToCellQuick(
+psPlane* psCoordSkyToCellQuick(
     psPlane* out,                      ///< a plane struct to recycle. If NULL, a new struct is created
     const psSphere* in,                ///< the Sky coordinate
     const psCell* cell                 ///< the cell of interest
 );
+*/
+    const pmCell* cell                 ///< the cell of interest
+);
 #endif // #ifndef PS_ASTROMETRY_H

trunk/psModules/src/pmFlatField.c

-              r2299
+              r4770
  *  @author Ross Harman, MHPCC
+ *
  *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2004-11-06 02:42:03 $
+ *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 bool pmFlatField(psReadout *in, const psReadout *flat)
+bool pmFlatField(pmReadout *in, pmReadout *mask, const pmReadout *flat)
+{
+    // XXX: Not sure if this is correct.  Must consult with IfA.
+    PS_ASSERT_PTR_NON_NULL(mask, false);
     int i = 0;
     int j = 0;
 …
                  PS_ERRORTEXT_pmFlatField_NULL_FLAT_IMAGE);
         return false;
-    } else if(in->mask == NULL) {
-        in->mask = psImageAlloc(inImage->numCols, inImage->numRows, PS_TYPE_MASK);
-        memset(in->mask->data.V[0], 0, inImage->numCols*inImage->numRows*PSELEMTYPE_SIZEOF(PS_TYPE_MASK));
+    }
     inMask = in->mask;
+    inMask = mask->image;
     // Check input image and its mask are not larger than flat image
     if(inImage->numRows>flatImage->numRows || inImage->numCols>flatImage->numCols) {
         psError( PS_ERR_BAD_PARAMETER_SIZE, true,

trunk/psModules/src/pmFlatField.h

-              r4754
+              r4770
  *  @author Ross Harman, MHPCC
+ *
  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-08-11 00:03:51 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
  */
 bool pmFlatField(
+    psReadout *in,          ///< Redout with input image and mask
+    const psReadout *flat   ///< Readout with flat image
+    pmReadout *in,          ///< Readout with input image
+    pmReadout *mask,        ///< Input image mask
+    const pmReadout *flat   ///< Readout with flat image
 );

trunk/psModules/src/pmMaskBadPixels.c

-              r2275
+              r4770
  *  @author Ross Harman, MHPCC
+ *
  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2004-11-04 02:02:10 $
+ *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 #include "pmMaskBadPixelsErrors.h"
 bool pmMaskBadPixels(psReadout *in, const psImage *mask, unsigned int maskVal, float sat,
+bool pmMaskBadPixels(pmReadout *in, const psImage *mask, unsigned int maskVal, float sat,
                      unsigned int growVal, int grow)
+{

trunk/psModules/src/pmMaskBadPixels.h

-              r4754
+              r4770
  *  @author Ross Harman, MHPCC
+ *
  *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-08-11 00:03:51 $
+ *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
  */
 bool pmMaskBadPixels(
     psReadout *in,          ///< Readout containing input image data.
+    pmReadout *in,          ///< Readout containing input image data.
     const psImage *mask,    ///< Mask data to be added to readout mask data.
     unsigned int maskVal,   ///< Mask value to determine what to add to input mask.

trunk/psModules/src/pmNonLinear.c

-              r4030
+              r4770
  *  @author GLG, MHPCC
+ *
  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-05-25 20:28:32 $
+ *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 /******************************************************************************
 pmNonLinearityLookup(): This routine will take an psReadout image as input
+pmNonLinearityLookup(): This routine will take an pmReadout image as input
 and a 1-D polynomial.  For each pixel in the input image, the polynomial will
 be evaluated at that pixels value, and the image pixel will then be set to
 …
  *****************************************************************************/
 psReadout *pmNonLinearityPolynomial(psReadout *inputReadout,
+pmReadout *pmNonLinearityPolynomial(pmReadout *inputReadout,
                                     const psPolynomial1D *input1DPoly)
+{
 …
 /******************************************************************************
 pmNonLinearityLookup(): This routine will take an psReadout image as input
+pmNonLinearityLookup(): This routine will take an pmReadout image as input
 and two input vectors, which constitute a lookup table.  For each pixel in
 the input image, that pixels value will be determined in the input vector
 …
 be set to the value from outFlux.
  *****************************************************************************/
 psReadout *pmNonLinearityLookup(psReadout *inputReadout,
+pmReadout *pmNonLinearityLookup(pmReadout *inputReadout,
                                 const psVector *inFlux,
                                 const psVector *outFlux)

trunk/psModules/src/pmNonLinear.h

-              r4754
+              r4770
  *  @author GLG, MHPCC
+ *
  *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-08-11 00:03:51 $
+ *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 #include "pmAstrometry.h"
 psReadout *pmNonLinearityPolynomial(psReadout *in,
+pmReadout *pmNonLinearityPolynomial(pmReadout *in,
                                     const psPolynomial1D *coeff);
 psReadout *pmNonLinearityLookup(psReadout *in,
+pmReadout *pmNonLinearityLookup(pmReadout *in,
                                 const psVector *inFlux,
                                 const psVector *outFlux);

trunk/psModules/src/pmObjects.c

-              r4579
+              r4770
  *  @author EAM, IfA: significant modifications.
+ *
  *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-07-19 01:44:48 $
+ *  @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 /******************************************************************************
 pmPeakAlloc(): Allocate the psPeak data structure and set appropriate members.
 *****************************************************************************/
 psPeak *pmPeakAlloc(psS32 x,
+pmPeakAlloc(): Allocate the pmPeak data structure and set appropriate members.
+*****************************************************************************/
+pmPeak *pmPeakAlloc(psS32 x,
                     psS32 y,
                     psF32 counts,
                     psPeakType class)
+{
     psPeak *tmp = (psPeak *) psAlloc(sizeof(psPeak));
+                    pmPeakType class)
+{
+    pmPeak *tmp = (pmPeak *) psAlloc(sizeof(pmPeak));
     tmp->x = x;
     tmp->y = y;
 …
 /******************************************************************************
 pmMomentsAlloc(): Allocate the psMoments structure and initialize the members
+pmMomentsAlloc(): Allocate the pmMoments structure and initialize the members
 to zero.
 *****************************************************************************/
 psMoments *pmMomentsAlloc()
+{
     psMoments *tmp = (psMoments *) psAlloc(sizeof(psMoments));
+pmMoments *pmMomentsAlloc()
+{
+    pmMoments *tmp = (pmMoments *) psAlloc(sizeof(pmMoments));
     tmp->x = 0.0;
     tmp->y = 0.0;
 …
+}
 static void modelFree(psModel *tmp)
+static void modelFree(pmModel *tmp)
+{
     psFree(tmp->params);
 …
 /******************************************************************************
 pmModelAlloc(): Allocate the psModel structure, along with its parameters,
+pmModelAlloc(): Allocate the pmModel structure, along with its parameters,
 and initialize the type member.  Initialize the params to 0.0.
 XXX EAM: changing params and dparams to psVector
 *****************************************************************************/
 psModel *pmModelAlloc(psModelType type)
+{
     psModel *tmp = (psModel *) psAlloc(sizeof(psModel));
+pmModel *pmModelAlloc(pmModelType type)
+{
+    pmModel *tmp = (pmModel *) psAlloc(sizeof(pmModel));
     tmp->type = type;
 …
         break;
     default:
         psError(PS_ERR_UNKNOWN, true, "Undefined psModelType");
+        psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType");
         return(NULL);
+    }
 …
 We might need to increase the reference counter and decrease it here.
 *****************************************************************************/
 static void sourceFree(psSource *tmp)
+static void sourceFree(pmSource *tmp)
+{
     psFree(tmp->peak);
 …
     //    psFree(tmp->mask);
     psFree(tmp->moments);
+    psFree(tmp->models);
+}
+/******************************************************************************
+pmSourceAlloc(): Allocate the psSource structure and initialize its members
+    psFree(tmp->modelPSF);
+    psFree(tmp->modelFLT);
+}
+/******************************************************************************
+pmSourceAlloc(): Allocate the pmSource structure and initialize its members
 to NULL.
 *****************************************************************************/
 psSource *pmSourceAlloc()
+{
     psSource *tmp = (psSource *) psAlloc(sizeof(psSource));
+pmSource *pmSourceAlloc()
+{
+    pmSource *tmp = (pmSource *) psAlloc(sizeof(pmSource));
     tmp->peak = NULL;
     tmp->pixels = NULL;
     tmp->mask = NULL;
     tmp->moments = NULL;
+    tmp->models = NULL;
+    tmp->modelPSF = NULL;
+    tmp->modelFLT = NULL;
     tmp->type = 0;
     psMemSetDeallocator(tmp, (psFreeFunc) sourceFree);
 …
                               psS32 col,
                               psF32 counts,
                               psPeakType type)
+{
     psPeak *tmpPeak = pmPeakAlloc(col, row, counts, type);
+                              pmPeakType type)
+{
+    pmPeak *tmpPeak = pmPeakAlloc(col, row, counts, type);
     if (list == NULL) {
 …
         // Step through all local peaks in this row.
         for (psU32 i = 0 ; i < row1->n ; i++ ) {
             psPeakType myType = PM_PEAK_UNDEF;
+            pmPeakType myType = PM_PEAK_UNDEF;
             col = row1->data.U32[i];
 …
     //    printf("pmCullPeaks(): list size is %d\n", peaks->size);
     while (tmpListElem != NULL) {
         psPeak *tmpPeak = (psPeak *) tmpListElem->data;
+        pmPeak *tmpPeak = (pmPeak *) tmpListElem->data;
         if ((tmpPeak->counts > maxValue) ||
                 ((valid != NULL) &&
 …
     for (int i = 0; i < peaks->n; i++) {
         psPeak *tmpPeak = (psPeak *) peaks->data[i];
+        pmPeak *tmpPeak = (pmPeak *) peaks->data[i];
         if (tmpPeak->counts > maxValue)
             continue;
 …
 /******************************************************************************
 psSource *pmSourceLocalSky(image, peak, innerRadius, outerRadius): this
 routine creates a new psSource data structure and sets the following members:
     ->psPeak
     ->psMoments->sky
+pmSource *pmSourceLocalSky(image, peak, innerRadius, outerRadius): this
+routine creates a new pmSource data structure and sets the following members:
+    ->pmPeak
+    ->pmMoments->sky
 The sky value is set from the pixels in the square annulus surrounding the
 …
      or they use the image row/column offsets.
 XXX: Should we simply set psSource->peak = peak?  If so, should we increase
+XXX: Should we simply set pmSource->peak = peak?  If so, should we increase
 the reference counter?  Or, should we copy the data structure?
 …
      members.
 *****************************************************************************/
 psSource *pmSourceLocalSky(const psImage *image,
                            const psPeak *peak,
+pmSource *pmSourceLocalSky(const psImage *image,
+                           const pmPeak *peak,
                            psStatsOptions statsOptions,
                            psF32 innerRadius,
 …
     // Create the output mySource, and set appropriate members.
     //
     psSource *mySource = pmSourceAlloc();
     mySource->peak = (psPeak *) peak;
+    pmSource *mySource = pmSourceAlloc();
+    mySource->peak = (pmPeak *) peak;
     mySource->moments = pmMomentsAlloc();
     psF64 tmpF64;
 …
 XXX: macro this for performance.
 *****************************************************************************/
 static bool checkRadius(psPeak *peak,
+static bool checkRadius(pmPeak *peak,
                         psF32 radius,
                         psS32 x,
 …
 /******************************************************************************
 pmSourceMoments(source, radius): this function takes a subImage defined in the
 psSource data structure, along with the peak location, and determines the
+pmSource data structure, along with the peak location, and determines the
 various moments associated with that peak.
 Requires the following to have been created:
     psSource
     psSource->peak
     psSource->pixels
+    pmSource
+    pmSource->peak
+    pmSource->pixels
 XXX: The peak calculations are done in image coords, not subImage coords.
 …
 XXX: mask values?
 *****************************************************************************/
 psSource *pmSourceMoments(psSource *source,
+pmSource *pmSourceMoments(pmSource *source,
                           psF32 radius)
+{
 …
 int pmComparePeakAscend (const void **a, const void **b)
+{
     psPeak *A = *(psPeak **)a;
     psPeak *B = *(psPeak **)b;
+    pmPeak *A = *(pmPeak **)a;
+    pmPeak *B = *(pmPeak **)b;
     psF32 diff;
 …
 int pmComparePeakDescend (const void **a, const void **b)
+{
     psPeak *A = *(psPeak **)a;
     psPeak *B = *(psPeak **)b;
+    pmPeak *A = *(pmPeak **)a;
+    pmPeak *B = *(pmPeak **)b;
     psF32 diff;
 …
         for (psS32 i = 0 ; i < sources->n ; i++)
+        {
             psSource *tmpSrc = (psSource *) sources->data[i];
+            pmSource *tmpSrc = (pmSource *) sources->data[i];
             PS_ASSERT_PTR_NON_NULL(tmpSrc, false); // just skip this one?
             PS_ASSERT_PTR_NON_NULL(tmpSrc->moments, false); // just skip this one?
 …
     // measure statistics on Sx, Sy if Sx, Sy within range of clump
+    {
         psPeak *clump;
+        pmPeak *clump;
         psF32 minSx, maxSx;
         psF32 minSy, maxSy;
 …
         for (psS32 i = 0 ; i < sources->n ; i++)
+        {
             psSource *tmpSrc = (psSource *) sources->data[i];
+            pmSource *tmpSrc = (pmSource *) sources->data[i];
             if (tmpSrc->moments->Sx < minSx)
 …
     for (psS32 i = 0 ; i < sources->n ; i++) {
         psSource *tmpSrc = (psSource *) sources->data[i];
+        pmSource *tmpSrc = (pmSource *) sources->data[i];
         tmpSrc->peak->class = 0;
 …
      the pmSourceSetLocal() function.
 *****************************************************************************/
 bool pmSourceSetPixelsCircle(psSource *source,
+bool pmSourceSetPixelsCircle(pmSource *source,
                              const psImage *image,
                              psF32 radius)
 …
 /******************************************************************************
 pmSourceModelGuess(source, image, model): This function allocates a new
 psModel structure and stores it in the psSource data structure specified in
+pmModel structure and stores it in the pmSource data structure specified in
 the argument list.  The model type is specified in the argument list.  The
 params array in that psModel structure are allocated, and then set to the
+params array in that pmModel structure are allocated, and then set to the
 appropriate values.  This function returns true if everything was successful.
 …
 image, not subImage coords.  Therefore, the calls to the model evaluation
 functions will be in image, not subImage coords.  Remember this.
+*****************************************************************************/
+bool pmSourceModelGuess(psSource *source,
+XXX: The source->models member used to be allocated here.  Now I assume
+->modelPSF should be allocated
+*****************************************************************************/
+bool pmSourceModelGuess(pmSource *source,
                         const psImage *image,
                         psModelType model)
+                        pmModelType model)
+{
     PS_ASSERT_PTR_NON_NULL(source, false);
 …
     PS_ASSERT_IMAGE_NON_NULL(image, false);
     PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, false);
     if (source->models != NULL) {
         psLogMsg(__func__, PS_LOG_WARN, "WARNING: source->models was non-NULL; calling psFree(source->models).\n");
         psFree(source->models);
+    if (source->modelPSF != NULL) {
+        psLogMsg(__func__, PS_LOG_WARN, "WARNING: source->modelPSF was non-NULL; calling psFree(source->modelPSF).\n");
+        psFree(source->modelPSF);
+    }
     if (!((model == PS_MODEL_GAUSS) ||
 …
+    }
     source->models = pmModelAlloc(model);
     psVector *params = source->models->params;
+    source->modelPSF = pmModelAlloc(model);
+    psVector *params = source->modelPSF->params;
     switch (model) {
 …
         params->data.F32[6] = source->moments->Sxy;
         // XXX: What are these?
         // source->models->params[7] = B2;
         // source->models->params[8] = B3;
+        // source->modelPSF->params[7] = B2;
+        // source->modelPSF->params[8] = B3;
         return(true);
 …
 /******************************************************************************
 evalModel(source, level, row): a private function which evaluates the
 source->model function at the specified coords.  The coords are subImage, not
+source->modelPSF function at the specified coords.  The coords are subImage, not
 image coords.
 …
 the coords is in subImage or image space.
 XXX: This should probably be a public psModules function.
+XXX: This should probably be a public pmModules function.
 XXX: Use static vectors for x.
 …
 testing.  Try to reproduce that and debug.
 *****************************************************************************/
 static psF32 evalModel(psSource *src,
+static psF32 evalModel(pmSource *src,
                        psU32 row,
                        psU32 col)
+{
     PS_ASSERT_PTR_NON_NULL(src, false);
     PS_ASSERT_PTR_NON_NULL(src->models, false);
     PS_ASSERT_PTR_NON_NULL(src->models->params, false);
     // XXX: The following step will not be necessary if the models->params
+    PS_ASSERT_PTR_NON_NULL(src->modelPSF, false);
+    PS_ASSERT_PTR_NON_NULL(src->modelPSF->params, false);
+    // XXX: The following step will not be necessary if the modelPSF->params
     // member is a psVector.  Suggest to IfA.
     // XXX EAM: done: models->params is now a vector
     psVector *params = src->models->params;
+    // XXX EAM: done: modelPSF->params is now a vector
+    psVector *params = src->modelPSF->params;
     //
 …
     psF32 tmpF;
     switch (src->models->type) {
+    switch (src->modelPSF->type) {
     case PS_MODEL_GAUSS:
         tmpF = pmMinLM_Gauss2D(NULL, params, x);
 …
         break;
     default:
         psError(PS_ERR_UNKNOWN, true, "Undefined psModelType");
+        psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType");
         return(NAN);
+    }
 …
 XXX: The result is returned in image coords.
 *****************************************************************************/
 static psF32 findValue(psSource *source,
+static psF32 findValue(pmSource *source,
                        psF32 level,
                        psU32 row,
 …
 XXX: The top, bottom of the contour is not correctly determined.
 *****************************************************************************/
 psArray *pmSourceContour(psSource *source,
+psArray *pmSourceContour(pmSource *source,
                          const psImage *image,
                          psF32 level,
 …
     PS_ASSERT_PTR_NON_NULL(source->peak, false);
     PS_ASSERT_PTR_NON_NULL(source->pixels, false);
     PS_ASSERT_PTR_NON_NULL(source->models, false);
+    PS_ASSERT_PTR_NON_NULL(source->modelPSF, false);
     //
 …
 XXX: Probably should remove the "image" argument.
 *****************************************************************************/
 bool pmSourceFitModel(psSource *source,
+bool pmSourceFitModel(pmSource *source,
                       const psImage *image)
+{
 …
     PS_ASSERT_PTR_NON_NULL(source->peak, false);
     PS_ASSERT_PTR_NON_NULL(source->pixels, false);
     PS_ASSERT_PTR_NON_NULL(source->models, false);
+    PS_ASSERT_PTR_NON_NULL(source->modelPSF, false);
     PS_ASSERT_IMAGE_NON_NULL(image, false);
     PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, false);
 …
                             PM_SOURCE_FIT_MODEL_TOLERANCE);
     psVector *params = source->models->params;
     switch (source->models->type) {
+    psVector *params = source->modelPSF->params;
+    switch (source->modelPSF->type) {
     case PS_MODEL_GAUSS:
         rc = psMinimizeLMChi2(myMin, NULL, params, NULL, x, y, yErr, pmMinLM_Gauss2D);
 …
         break;
     default:
         psError(PS_ERR_UNKNOWN, true, "Undefined psModelType");
+        psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType");
         rc = false;
+    }
     // XXX EAM: we need to do something (give an error?) if rc is false
     // XXX EAM: save the resulting chisq, nDOF, nIter
     source->models->chisq = myMin->value;
     source->models->nDOF  = y->n - params->n;
     source->models->nIter = myMin->iter;
+    source->modelPSF->chisq = myMin->value;
+    source->modelPSF->nDOF  = y->n - params->n;
+    source->modelPSF->nIter = myMin->iter;
     psFree(x);
 …
 static bool sourceAddOrSubModel(psImage *image,
                                 psSource *src,
+                                pmSource *src,
                                 bool center,
                                 psS32 flag)
 …
     PS_ASSERT_PTR_NON_NULL(src->peak, false);
     PS_ASSERT_PTR_NON_NULL(src->pixels, false);
     PS_ASSERT_PTR_NON_NULL(src->models, false);
+    PS_ASSERT_PTR_NON_NULL(src->modelPSF, false);
     PS_ASSERT_IMAGE_NON_NULL(image, false);
     PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, false);
     psVector *x = psVectorAlloc(2, PS_TYPE_F32);
     psVector *params = src->models->params;
+    psVector *params = src->modelPSF->params;
     for (psS32 i = 0; i < src->pixels->numRows; i++) {
 …
             x->data.F32[0] = (float) imageCol;
             x->data.F32[1] = (float) imageRow;
             switch (src->models->type) {
+            switch (src->modelPSF->type) {
             case PS_MODEL_GAUSS:
                 pixelValue = pmMinLM_Gauss2D(NULL, params, x);
 …
                 break;
             default:
                 psError(PS_ERR_UNKNOWN, true, "Undefined psModelType");
+                psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType");
                 psFree(x);
                 return(false);
 …
  *****************************************************************************/
 bool pmSourceAddModel(psImage *image,
                       psSource *src,
+                      pmSource *src,
                       bool center)
+{
 …
  *****************************************************************************/
 bool pmSourceSubModel(psImage *image,
                       psSource *src,
+                      pmSource *src,
                       bool center)
+{

trunk/psModules/src/pmObjects.h

-              r4579
+              r4770
  *  @author GLG, MHPCC
+ *
  *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-07-19 01:44:48 $
+ *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 #include "pslib.h"
+/** pmPeakType
+ *
+ *  A peak pixel may have several features which may be determined when the
+ *  peak is found or measured. These are specified by the pmPeakType enum.
+ *  PM_PEAK_LONE represents a single pixel which is higher than its 8 immediate
+ *  neighbors.  The PM_PEAK_EDGE represents a peak pixel which touching the image
+ *  edge. The PM_PEAK_FLAT represents a peak pixel which has more than a specific
+ *  number of neighbors at the same value, within some tolarence:
+ *
+ */
 typedef enum {
+    PM_PEAK_LONE,           ///< Isolated peak.
+    PM_PEAK_EDGE,           ///< Peak on edge.
+    PM_PEAK_FLAT,           ///< Peak has equal-value neighbors.
+    PM_PEAK_UNDEF           ///< Undefined.
+} psPeakType;
+    PM_PEAK_LONE,                       ///< Isolated peak.
+    PM_PEAK_EDGE,                       ///< Peak on edge.
+    PM_PEAK_FLAT,                       ///< Peak has equal-value neighbors.
+    PM_PEAK_UNDEF                       ///< Undefined.
+} pmPeakType;
+/** pmPeak data structure
+ *
+ *
+ *
+ */
 typedef struct
+{
     psS32 x;                ///< X-coordinate of peak pixel.
     psS32 y;                ///< Y-coordinate of peak pixel.
     psF32 counts;           ///< Value of peak pixel (above sky?).
     psPeakType class;       ///< Description of peak.
+    int x;                              ///< X-coordinate of peak pixel.
+    int y;                              ///< Y-coordinate of peak pixel.
+    float counts;                       ///< Value of peak pixel (above sky?).
+    pmPeakType class;                   ///< Description of peak.
+}
+psPeak;
+pmPeak;
+/** pmMoments data structure
+ *
+ *
+ *
+ */
 typedef struct
+{
     psF32 x;                ///< X-coord of centroid.
     psF32 y;                ///< Y-coord of centroid.
     psF32 Sx;               ///< x-second moment.
     psF32 Sy;               ///< y-second moment.
     psF32 Sxy;              ///< xy cross moment.
     psF32 Sum;              ///< Pixel sum above sky (background).
     psF32 Peak;             ///< Peak counts above sky.
     psF32 Sky;              ///< Sky level (background).
     psS32 nPixels;          ///< Number of pixels used.
+    float x;                            ///< X-coord of centroid.
+    float y;                            ///< Y-coord of centroid.
+    float Sx;                           ///< x-second moment.
+    float Sy;                           ///< y-second moment.
+    float Sxy;                          ///< xy cross moment.
+    float Sum;                          ///< Pixel sum above sky (background).
+    float Peak;                         ///< Peak counts above sky.
+    float Sky;                          ///< Sky level (background).
+    int nPixels;                        ///< Number of pixels used.
+}
+psMoments;
+pmMoments;
+/** pmModelType enumeration
+ *
+ *
+ *
+ */
 typedef enum {
+    PS_MODEL_GAUSS,   ///< Regular 2-D Gaussian
+    PS_MODEL_PGAUSS,  ///< Psuedo 2-D Gaussian
+    PS_MODEL_TWIST_GAUSS, ///< 2-D Twisted Gaussian
+    PS_MODEL_WAUSS,  ///< 2-D Waussian
+    PS_MODEL_SERSIC,  ///< Sersic
+    PS_MODEL_SERSIC_CORE, ///< Sersic Core
+    PS_MODEL_UNDEFINED  ///< Undefined
+} psModelType;
+// XXX: It will be better if params, and dparams, were psVectors.
+    PS_MODEL_GAUSS,                     ///< Regular 2-D Gaussian
+    PS_MODEL_PGAUSS,                    ///< Psuedo 2-D Gaussian
+    PS_MODEL_TWIST_GAUSS,               ///< 2-D Twisted Gaussian
+    PS_MODEL_WAUSS,                     ///< 2-D Waussian
+    PS_MODEL_SERSIC,                    ///< Sersic
+    PS_MODEL_SERSIC_CORE,               ///< Sersic Core
+    PS_MODEL_UNDEFINED                  ///< Undefined
+} pmModelType;
+/** pmModel data structure
+ *
+ *
+ *
+ */
+// XXX: The SDRS has the "type" member of type psS32.
 typedef struct
+{
     psModelType type;       ///< Model to be used.
     psVector *params;       ///< Paramater values.
     psVector *dparams;      ///< Parameter errors.
     psF32 chisq;            ///< Fit chi-squared.
     psS32 nDOF;             ///< number of degrees of freedom
     psS32 nIter;            ///< number of iterations to reach min
+    pmModelType type;                   ///< Model to be used.
+    psVector *params;                   ///< Paramater values.
+    psVector *dparams;                  ///< Parameter errors.
+    float chisq;                        ///< Fit chi-squared.
+    int nDOF;                           ///< number of degrees of freedom
+    int nIter;                          ///< number of iterations to reach min
+}
+psModel;
+pmModel;
+/** pmSourceType enumeration
+ *
+ *
+ *
+ */
 typedef enum {
     PS_SOURCE_PSFSTAR,
 …
     PS_SOURCE_BRIGHTSTAR,
     PS_SOURCE_OTHER
+} psSourceType;
+} pmSourceType;
+/** pmSource data structure
+ *
+ *  This source has the capacity for several types of measurements. The
+ *  simplest measurement of a source is the location and flux of the peak pixel
+ *  associated with the source:
+ *
+ */
 typedef struct
+{
+    psPeak *peak;           ///< Description of peak pixel.
+    psImage *pixels;        ///< Rectangular region including object pixels.
+    psImage *mask;          ///< Mask which marks pixels associated with objects.
+    psMoments *moments;     ///< Basic moments measure for the object.
+    psModel *models;        ///< Model parameters and type.
+    psSourceType type;      ///< Best identification of object.
+    pmPeak *peak;                       ///< Description of peak pixel.
+    psImage *pixels;                    ///< Rectangular region including object pixels.
+    psImage *mask;                      ///< Mask which marks pixels associated with objects.
+    pmMoments *moments;                 ///< Basic moments measure for the object.
+    pmModel *modelPSF;                  ///< PSF model parameters and type
+    pmModel *modelFLT;                  ///< FLT model parameters and type
+    pmSourceType type;                  ///< Best identification of object.
+}
+psSource;
+psPeak *pmPeakAlloc(psS32 x,  ///< Row-coordinate in image space
+                    psS32 y,  ///< Col-coordinate in image space
+                    psF32 counts, ///< The value of the peak pixel
+                    psPeakType class ///< The type of peak pixel
+                   );
+psMoments *pmMomentsAlloc();
+psModel *pmModelAlloc(psModelType type);
+psSource *pmSourceAlloc();
+pmSource;
+/** pmPeak data structure
+ *
+ *
+ *
+ */
+typedef struct
+{
+    psS32 type;                         ///< PSF Model in use
+    psArray *params;                    ///< Model parameters (psPolynomial2D)
+    psF32 chisq;                        ///< PSF goodness statistic
+    psS32 nPSFstars;                    ///< number of stars used to measure PSF
+}
+pmPSF;
+pmPeak *pmPeakAlloc(
+    int x,                              ///< Row-coordinate in image space
+    int y,                              ///< Col-coordinate in image space
+    float counts,                       ///< The value of the peak pixel
+    pmPeakType class                    ///< The type of peak pixel
+);
+pmMoments *pmMomentsAlloc();
+pmModel *pmModelAlloc(pmModelType type);
+pmSource *pmSourceAlloc();
 /******************************************************************************
 …
 the location (x value) of all peaks.
  *****************************************************************************/
+psVector *pmFindVectorPeaks(const psVector *vector, ///< The input vector (psF32)
+                            psF32 threshold  ///< Threshold above which to find a peak
+                           );
+psVector *pmFindVectorPeaks(
+    const psVector *vector,             ///< The input vector (float)
+    float threshold                     ///< Threshold above which to find a peak
+);
 /******************************************************************************
 …
 value) of all peaks.
  *****************************************************************************/
+psArray *pmFindImagePeaks(const psImage *image, ///< The input image where peaks will be found (psF32)
+                          psF32 threshold ///< Threshold above which to find a peak
+                         );
+psArray *pmFindImagePeaks(
+    const psImage *image,               ///< The input image where peaks will be found (float)
+    float threshold                     ///< Threshold above which to find a peak
+);
 /******************************************************************************
 …
 a peak value above the given maximum, or fall outside the valid region.
  *****************************************************************************/
+psList *pmCullPeaks(psList *peaks,  ///< The psList of peaks to be culled
+                    psF32 maxValue,  ///< Cull peaks above this value
+                    const psRegion *valid ///< Cull peaks otside this psRegion
+                   );
+/******************************************************************************
+psSource *pmSourceLocalSky(image, peak, innerRadius, outerRadius):
+psList *pmCullPeaks(
+    psList *peaks,                      ///< The psList of peaks to be culled
+    float maxValue,                     ///< Cull peaks above this value
+    const psRegion *valid               ///< Cull peaks otside this psRegion
+);
+/******************************************************************************
+pmSource *pmSourceLocalSky(image, peak, innerRadius, outerRadius):
  *****************************************************************************/
+psSource *pmSourceLocalSky(const psImage *image, ///< The input image (psF32)
+                           const psPeak *peak,  ///< The peak for which the psSource struct is created.
+                           psStatsOptions statsOptions, ///< The statistic used in calculating the background sky
+                           psF32 innerRadius,  ///< The inner radius of the suqare annulus for calculating sky
+                           psF32 outerRadius  ///< The outer radius of the suqare annulus for calculating sky
+                          );
+/******************************************************************************
+ *****************************************************************************/
+psSource *pmSourceMoments(psSource *source, ///< The input psSource for which moments will be computed
+                          psF32 radius  ///< Use a circle of pixels around the peak
+                         );
+pmSource *pmSourceLocalSky(
+    const psImage *image,               ///< The input image (float)
+    const pmPeak *peak,                 ///< The peak for which the psSource struct is created.
+    psStatsOptions statsOptions,        ///< The statistic used in calculating the background sky
+    float innerRadius,                  ///< The inner radius of the suqare annulus for calculating sky
+    float outerRadius                   ///< The outer radius of the suqare annulus for calculating sky
+);
+/******************************************************************************
+ *****************************************************************************/
+pmSource *pmSourceMoments(
+    pmSource *source,                   ///< The input pmSource for which moments will be computed
+    float radius                        ///< Use a circle of pixels around the peak
+);
 /******************************************************************************
 …
 source classification.
  *****************************************************************************/
+bool pmSourceRoughClass(psArray *source, ///< The input psSource
+                        psMetadata *metadata ///< Contains classification parameters
+                       );
+bool pmSourceRoughClass(
+    psArray *source,                    ///< The input pmSource
+    psMetadata *metadata                ///< Contains classification parameters
+);
 /******************************************************************************
 pmSourceSetPixelCircle(source, image, radius)
  *****************************************************************************/
+bool pmSourceSetPixelsCircle(psSource *source,  ///< The input psSource
+                             const psImage *image, ///< The input image (psF32)
+                             psF32 radius  ///< The radius of the circle
+                            );
+/******************************************************************************
+ *****************************************************************************/
+bool pmSourceModelGuess(psSource *source, ///< The input psSource
+                        const psImage *image, ///< The input image (psF32)
+                        psModelType model ///< The type of model to be created.
+                       );
+bool pmSourceSetPixelsCircle(
+    pmSource *source,                   ///< The input pmSource
+    const psImage *image,               ///< The input image (float)
+    float radius                        ///< The radius of the circle
+);
+/******************************************************************************
+ *****************************************************************************/
+bool pmSourceModelGuess(
+    pmSource *source,                   ///< The input pmSource
+    const psImage *image,               ///< The input image (float)
+    pmModelType model                   ///< The type of model to be created.
+);
 /******************************************************************************
 …
 } pmContourType;
+psArray *pmSourceContour(psSource *source, ///< The input psSource
+                         const psImage *image, ///< The input image (psF32) (this arg should be removed)
+                         psF32 level,  ///< The level of the contour
+                         pmContourType mode ///< Currently this must be PS_CONTOUR_CRUDE
+                        );
+/******************************************************************************
+ *****************************************************************************/
+bool pmSourceFitModel(psSource *source,  ///< The input psSource
+                      const psImage *image ///< The input image (psF32)
+                     );
+/******************************************************************************
+ *****************************************************************************/
+bool pmSourceAddModel(psImage *image,  ///< The opuut image (psF32)
+                      psSource *source,  ///< The input psSource
+                      bool center  ///< A boolean flag that determines whether pixels are centered
+                     );
+/******************************************************************************
+ *****************************************************************************/
+bool pmSourceSubModel(psImage *image,  ///< The output image (psF32)
+                      psSource *source,  ///< The input psSource
+                      bool center  ///< A boolean flag that determines whether pixels are centered
+                     );
+psArray *pmSourceContour(
+    pmSource *source,                   ///< The input pmSource
+    const psImage *image,               ///< The input image (float) (this arg should be removed)
+    float level,                        ///< The level of the contour
+    pmContourType mode                  ///< Currently this must be PS_CONTOUR_CRUDE
+);
+/******************************************************************************
+ *****************************************************************************/
+bool pmSourceFitModel(
+    pmSource *source,                   ///< The input pmSource
+    const psImage *image                ///< The input image (float)
+);
+/******************************************************************************
+ *****************************************************************************/
+bool pmSourceAddModel(
+    psImage *image,                     ///< The opuut image (float)
+    pmSource *source,                   ///< The input pmSource
+    bool center                         ///< A boolean flag that determines whether pixels are centered
+);
+/******************************************************************************
+ *****************************************************************************/
+bool pmSourceSubModel(
+    psImage *image,                     ///< The output image (float)
+    pmSource *source,                   ///< The input pmSource
+    bool center                         ///< A boolean flag that determines whether pixels are centered
+);
 /******************************************************************************
 XXX: Why only *x argument?
 XXX EAM: psMinimizeLMChi2Func returns psF64, not psF32
+XXX EAM: psMinimizeLMChi2Func returns psF64, not float
  *****************************************************************************/
 float pmMinLM_Gauss2D(
     psVector *deriv,                   ///< A possibly-NULL structure for the output derivatives
     const psVector *params,            ///< A psVector which holds the parameters of this function
     const psVector *x                  ///< A psVector which holds the row/col coordinate
+    psVector *deriv,                    ///< A possibly-NULL structure for the output derivatives
+    const psVector *params,             ///< A psVector which holds the parameters of this function
+    const psVector *x                   ///< A psVector which holds the row/col coordinate
 );
 …
  *****************************************************************************/
 float pmMinLM_PsuedoGauss2D(
     psVector *deriv, ///< A possibly-NULL structure for the output derivatives
     const psVector *params, ///< A psVector which holds the parameters of this function
     const psVector *x  ///< A psVector which holds the row/col coordinate
+    psVector *deriv,                    ///< A possibly-NULL structure for the output derivatives
+    const psVector *params,             ///< A psVector which holds the parameters of this function
+    const psVector *x                   ///< A psVector which holds the row/col coordinate
 );
 …
  *****************************************************************************/
 float pmMinLM_Wauss2D(
     psVector *deriv,  ///< A possibly-NULL structure for the output derivatives
     const psVector *params,  ///< A psVector which holds the parameters of this function
     const psVector *x  ///< A psVector which holds the row/col coordinate
+    psVector *deriv,                    ///< A possibly-NULL structure for the output derivatives
+    const psVector *params,             ///< A psVector which holds the parameters of this function
+    const psVector *x                   ///< A psVector which holds the row/col coordinate
 );
 …
  *****************************************************************************/
 float pmMinLM_TwistGauss2D(
     psVector *deriv, ///< A possibly-NULL structure for the output derivatives
     const psVector *params, ///< A psVector which holds the parameters of this function
     const psVector *x  ///< A psVector which holds the row/col coordinate
+    psVector *deriv,                    ///< A possibly-NULL structure for the output derivatives
+    const psVector *params,             ///< A psVector which holds the parameters of this function
+    const psVector *x                   ///< A psVector which holds the row/col coordinate
 );
 …
  *****************************************************************************/
 float pmMinLM_Sersic(
     psVector *deriv,  ///< A possibly-NULL structure for the output derivatives
     const psVector *params,  ///< A psVector which holds the parameters of this function
     const psVector *x  ///< A psVector which holds the row/col coordinate
+    psVector *deriv,                    ///< A possibly-NULL structure for the output derivatives
+    const psVector *params,             ///< A psVector which holds the parameters of this function
+    const psVector *x                   ///< A psVector which holds the row/col coordinate
 );
 …
  *****************************************************************************/
 float pmMinLM_SersicCore(
     psVector *deriv, ///< A possibly-NULL structure for the output derivatives
     const psVector *params, ///< A psVector which holds the parameters of this function
     const psVector *x  ///< A psVector which holds the row/col coordinate
+    psVector *deriv,                    ///< A possibly-NULL structure for the output derivatives
+    const psVector *params,             ///< A psVector which holds the parameters of this function
+    const psVector *x                   ///< A psVector which holds the row/col coordinate
 );
 …
  *****************************************************************************/
 float pmMinLM_PsuedoSersic(
+    psVector *deriv, ///< A possibly-NULL structure for the output derivatives
+    const psVector *params, ///< A psVector which holds the parameters of this function
+    const psVector *x  ///< A psVector which holds the row/col coordinate
+);
+    psVector *deriv,                    ///< A possibly-NULL structure for the output derivatives
+    const psVector *params,             ///< A psVector which holds the parameters of this function
+    const psVector *x                   ///< A psVector which holds the row/col coordinate
+);
+/**
+ *
+ *  The object model functions are defined to allow for the flexible addition
+ *  of new object models. Every object model, with parameters represented by
+ *  pmModel, has an associated set of functions which provide necessary support
+ *  operations. A set of abstract functions allow the programmer to select the
+ *  approriate function or property for a specific named object model.
+ *
+ */
+/**
+ *
+ *  This function is the model chi-square minimization function for this model.
+ *
+ */
+typedef psMinimizeLMChi2Func pmModelFunc;
+/**
+ *
+ * This function returns the integrated flux for the given model parameters.
+ */
+typedef psF64 (*pmModelFlux)(const psVector *params);
+/**
+ *
+ *  This function provides the model guess parameters based on the details of
+ *   the given source.
+ *
+ */
+typedef bool (*pmModelGuessFunc)(pmModel *model, pmSource *source);
+/**
+ *
+ *  This function constructs the PSF model for the given source based on the
+ *  supplied psf and the FLT model for the object.
+ *
+ */
+typedef bool (*pmModelFromPSFFunc)(pmModel *modelPSF, pmModel *modelFLT, pmPSF *psf);
+/**
+ *
+ *  This function returns the radius at which the given model and parameters
+ *  achieves the given flux.
+ *
+ */
+typedef psF64 (*pmModelRadius)(const psVector *params, double flux);
+/**
+ *
+ *  Each of the function types above has a corresponding function which returns
+ *  the function given the model type:
+ *
+ */
+pmModelFunc pmModelFunc_GetFunction (pmModelType type);
+pmModelFlux pmModelFlux_GetFunction (pmModelType type);
+pmModelGuessFunc pmModelGuessFunc_GetFunction (pmModelType type);
+pmModelFromPSFFunc pmModelFromPSFFunc_GetFunction (pmModelType type);
+pmModelRadius pmModelRadius_GetFunction (pmModelType type);
 #endif

trunk/psModules/src/pmReadoutCombine.c

-              r4425
+              r4770
  *  @author GLG, MHPCC
+ *
  *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-06-29 01:39:10 $
+ *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
     psS32 minInputRows = PS_MAX_S32;
     psListElem *tmpInput = NULL;
     psReadout *tmpReadout = NULL;
+    pmReadout *tmpReadout = NULL;
     psS32 numInputs = 0;
     psS32 tmpI;
 …
     tmpInput = (psListElem *) inputs->head;
     while (NULL != tmpInput) {
         tmpReadout = (psReadout *) tmpInput->data;
+        tmpReadout = (pmReadout *) tmpInput->data;
         PS_ASSERT_READOUT_NON_NULL(tmpReadout, output);
         PS_ASSERT_READOUT_NON_EMPTY(tmpReadout, output);
 …
     psVector *outColLower = psVectorAlloc(numInputs, PS_TYPE_U32);
     psVector *outColUpper = psVectorAlloc(numInputs, PS_TYPE_U32);
     psReadout **tmpReadouts = (psReadout **) psAlloc(numInputs * sizeof(psReadout *));
+    pmReadout **tmpReadouts = (pmReadout **) psAlloc(numInputs * sizeof(pmReadout *));
     // For each input readout, we create a pointer to that readout in
 …
     tmpInput = (psListElem *) inputs->head;
     while (NULL != tmpInput) {
         tmpReadouts[i] = (psReadout *) tmpInput->data;
+        tmpReadouts[i] = (pmReadout *) tmpInput->data;
         outRowLower->data.U32[i] = tmpReadouts[i]->row0 + tmpReadouts[i]->image->row0;
         outColLower->data.U32[i] = tmpReadouts[i]->col0 + tmpReadouts[i]->image->col0;

trunk/psModules/src/pmSubtractBias.c

-              r4579
+              r4770
  *  @author GLG, MHPCC
+ *
  *  @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-07-19 01:44:48 $
+ *  @version $Revision: 1.36 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 place from the input image.
  *****************************************************************************/
 static psReadout *SubtractFrame(psReadout *in,
                                 const psReadout *bias)
+static pmReadout *SubtractFrame(pmReadout *in,
+                                const pmReadout *bias)
+{
     psS32 i;
 …
 XXX: The SDRS does not specify type support.  F32 is implemented here.
  *****************************************************************************/
 psReadout *pmSubtractBias(psReadout *in,
+pmReadout *pmSubtractBias(pmReadout *in,
                           void *fitSpec,
                           const psList *overscans,
 …
                           psS32 nBinOrig,
                           pmFit fit,
                           const psReadout *bias)
+                          const pmReadout *bias)
+{
     psTrace(".psModule.pmSubtracBias.pmSubtractBias", 4,

trunk/psModules/src/pmSubtractBias.h

-              r4754
+              r4770
  *  @author GLG, MHPCC
+ *
  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-08-11 00:03:51 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 } pmFit;
 psReadout *pmSubtractBias(psReadout *in,                ///< The input psReadout image
+pmReadout *pmSubtractBias(pmReadout *in,                ///< The input pmReadout image
                           void *fitSpec,                ///< A polynomial or spline, defining the fit type.
                           const psList *overscans,      ///< A psList of overscan images
 …
                           int nBin,                     ///< The amount of binning to be done image pixels.
                           pmFit fit,                    ///< PM_FIT_SPLINE, PM_FIT_POLYNOMIAL, or PM_FIT_NONE
                           const psReadout *bias);       ///< A possibly NULL bias psReadout which is to be subtracted
+                          const pmReadout *bias);       ///< A possibly NULL bias pmReadout which is to be subtracted
 #endif

trunk/psModules/src/pmSubtractSky.c

-              r4425
+              r4770
  *  @author GLG, MHPCC
+ *
  *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-06-29 01:39:10 $
+ *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 /******************************************************************************
 psReadout pmSubtractSky():
+pmReadout pmSubtractSky():
 XXX: use static vectors for myStats, and the binned image
 …
 XXX: Sync the psTrace message facilities.
  *****************************************************************************/
 psReadout *pmSubtractSky(psReadout *in,
+pmReadout *pmSubtractSky(pmReadout *in,
                          void *fitSpec,
                          psFit fit,

trunk/psModules/src/pmSubtractSky.h

-              r4754
+              r4770
  *  @author GLG, MHPCC
+ *
  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2005-08-11 00:03:51 $
+ *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-16 01:10:34 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 } psFit;
 psReadout *pmSubtractSky(psReadout *in,
+pmReadout *pmSubtractSky(pmReadout *in,
                          void *fitSpec,
                          psFit fit,

Context Navigation

Legend:

trunk/psModules/src/pmAstrometry.c

trunk/psModules/src/pmAstrometry.h

trunk/psModules/src/pmFlatField.c

trunk/psModules/src/pmFlatField.h

trunk/psModules/src/pmMaskBadPixels.c

trunk/psModules/src/pmMaskBadPixels.h

trunk/psModules/src/pmNonLinear.c

trunk/psModules/src/pmNonLinear.h

trunk/psModules/src/pmObjects.c

trunk/psModules/src/pmObjects.h

trunk/psModules/src/pmReadoutCombine.c

trunk/psModules/src/pmSubtractBias.c

trunk/psModules/src/pmSubtractBias.h

trunk/psModules/src/pmSubtractSky.c

trunk/psModules/src/pmSubtractSky.h

Download in other formats: