Index: trunk/psModules/src/psAstrometry.c
===================================================================
--- trunk/psModules/src/psAstrometry.c	(revision 4577)
+++ trunk/psModules/src/psAstrometry.c	(revision 4579)
@@ -8,6 +8,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-18 18:48:29 $
+ *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-07-19 01:44:48 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -25,8 +25,9 @@
 #include "psError.h"
 #include "psConstants.h"
-#include "psAstronomyErrors.h"
+//#include "psAstronomyErrors.h"
 #include "psMatrix.h"
 #include "psTrace.h"
 #include "psLogMsg.h"
+
 
 /*****************************************************************************
@@ -35,4 +36,5 @@
 psImage.
  *****************************************************************************/
+/*
 static psS32 checkValidImageCoords(double x,
                                    double y,
@@ -40,14 +42,14 @@
 {
     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)
 {
@@ -65,5 +67,7 @@
     }
 }
-
+*/
+
+/*
 static void chipFree(psChip* chip)
 {
@@ -75,5 +79,7 @@
     }
 }
-
+*/
+
+/*
 static void cellFree(psCell* cell)
 {
@@ -88,4 +94,5 @@
     }
 }
+*/
 
 static void readoutFree(psReadout* readout)
@@ -99,4 +106,5 @@
 }
 
+/*
 static void observatoryFree(psObservatory* obs)
 {
@@ -105,5 +113,6 @@
     }
 }
-
+*/
+/*
 static void exposureFree(psExposure* exp)
 {
@@ -115,5 +124,6 @@
     }
 }
-
+*/
+/*
 static void fixedPatternFree(psFixedPattern* fp)
 {
@@ -122,14 +132,14 @@
             psFree(fp->x[i]);
         }
-
+ 
         for (psS32 j = 0; j < fp->p_ps_yRows; j++) {
             psFree(fp->y[j]);
         }
-
+ 
         psFree(fp->x);
         psFree(fp->y);
     }
 }
-
+*/
 /*****************************************************************************/
 /* FUNCTION IMPLEMENTATION - PUBLIC                                          */
@@ -141,58 +151,59 @@
  * 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);
-}
-
-
+                                   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,
@@ -210,5 +221,5 @@
 {
     PS_ASSERT_PTR_NON_NULL(observatory, NULL);
-
+ 
     psExposure* exp = psAlloc(sizeof(psExposure));
     *(double *)&exp->ra = ra;
@@ -223,8 +234,8 @@
     *(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);
@@ -235,10 +246,11 @@
     exp->cameraName = NULL;
     exp->telescopeName = NULL;
-
+ 
     psMemSetDeallocator(exp,(psFreeFunc)exposureFree);
-
+ 
     return exp;
 }
-
+*/
+/*
 psObservatory* psObservatoryAlloc(const char* name,
                                   double latitude,
@@ -248,5 +260,5 @@
 {
     psObservatory* obs = psAlloc(sizeof(psObservatory));
-
+ 
     if (name == NULL) {
         obs->name = NULL;
@@ -255,22 +267,23 @@
         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);
@@ -280,10 +293,10 @@
     }
     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);
@@ -293,28 +306,29 @@
         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;
@@ -325,31 +339,32 @@
     }
     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;
@@ -360,10 +375,10 @@
     }
     cell->readouts->n = 0; // per requirement
-
+ 
     *(int*)&cell->row0 = 0;
     *(int*)&cell->col0 = 0;
-
+ 
     cell->metadata = NULL;
-
+ 
     cell->toChip = NULL;
     cell->fromChip = NULL;
@@ -371,14 +386,14 @@
     cell->toTP = NULL;
     cell->toSky = NULL;
-
+ 
     cell->parent = parentChip;
-
+ 
     psMemSetDeallocator(cell,(psFreeFunc)cellFree);
-
+ 
     return cell;
-
-
-}
-
+ 
+ 
+}
+*/
 psReadout* psReadoutAlloc()
 {
@@ -402,12 +417,13 @@
 }
 
+/*
 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;
@@ -422,10 +438,11 @@
     *(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)
@@ -433,9 +450,9 @@
     PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL);
     PS_ASSERT_PTR_NON_NULL(FPA, NULL);
-
+ 
     psChip* tmpChip = NULL;
     psPlane chipCoord;
     psCell* outCell = NULL;
-
+ 
     // Determine which chip contains the fpaCoords.
     tmpChip = psChipInFPA(fpaCoord, FPA);
@@ -443,14 +460,15 @@
         return(NULL);
     }
-
+ 
     // Convert to those chip coordinates.
     psCoordFPAToChip(&chipCoord, fpaCoord, tmpChip);
-
+ 
     // Determine which cell contains those chip coordinates.
     outCell = psCellInChip(&chipCoord, tmpChip);
-
+ 
     return (outCell);
 }
-
+*/
+/*
 psChip* psChipInFPA(const psPlane* fpaCoord,
                     const psFPA* FPA)
@@ -459,21 +477,21 @@
     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;
-
+ 
     // 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];
         PS_ASSERT_PTR_NON_NULL(tmpChip, NULL);
         PS_ASSERT_PTR_NON_NULL(tmpChip->fromFPA, NULL);
-
+ 
         psPlaneTransformApply(&chipCoord, tmpChip->fromFPA, fpaCoord);
-
+ 
         tmpCell = psCellInChip(&chipCoord, tmpChip);
         if (tmpCell != NULL) {
@@ -481,9 +499,10 @@
         }
     }
-
+ 
     // XXX: Print warning here?
     return (NULL);
 }
-
+*/
+/*
 psCell* psCellInChip(const psPlane* chipCoord,
                      const psChip* chip)
@@ -491,17 +510,17 @@
     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];
@@ -509,14 +528,14 @@
         PS_ASSERT_PTR_NON_NULL(tmpCell->fromChip, NULL);
         psArray* readouts = tmpCell->readouts;
-
+ 
         if (readouts != NULL) {
             for (psS32 j = 0; j < readouts->n; j++) {
                 psReadout* tmpReadout = readouts->data[j];
                 PS_ASSERT_READOUT_NON_NULL(tmpReadout, NULL);
-
+ 
                 psPlaneTransformApply(&cellCoord,
                                       tmpCell->fromChip,
                                       chipCoord);
-
+ 
                 if (checkValidImageCoords(cellCoord.x,
                                           cellCoord.y,
@@ -527,8 +546,9 @@
         }
     }
-
+ 
     return (NULL);
 }
-
+*/
+/*
 psPlane* psCoordCellToChip(psPlane* outCoord,
                            const psPlane* inCoord,
@@ -537,8 +557,9 @@
     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,
@@ -547,8 +568,9 @@
     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,
@@ -559,12 +581,13 @@
     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,
@@ -573,17 +596,18 @@
     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); */
-
+    // slaAopqk(tpCoord->x, tpCoord->y, (double*)grommit,
+    //         &AOB, &ZOB, &HOB, &outSphere->r, &outSphere->d);
+ 
     return (outSphere);
 }
-
+*/
+/*
 psPlane* psCoordCellToFPA(psPlane* fpaCoord,
                           const psPlane* cellCoord,
@@ -592,8 +616,9 @@
     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,
@@ -609,30 +634,32 @@
     PS_ASSERT_PTR_NON_NULL(cell->parent->parent->toTangentPlane, 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;
-
+ 
     // 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);
-
+ 
     // Convert the tangent plane Coordinates to sky coordinates.
     skyCoord = psCoordTPToSky(skyCoord, tpCoord, tmpGrommit);
-
+ 
     psFree(fpaCoord);
     psFree(tpCoord);
     psFree(tmpGrommit);
-
+ 
     return(skyCoord);
 }
-
+ 
+*/
+/*
 psSphere* psCoordCellToSkyQuick(psSphere* outSphere,
                                 const psPlane* cellCoord,
@@ -650,34 +677,36 @@
                  "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);
 }
+*/
 
 /*****************************************************************************
 XXX: What about units for the (x,y) coords?
  *****************************************************************************/
+/*
 psPlane* psCoordSkyToTP(psPlane* tpCoord,
                         const psSphere* in,
@@ -686,19 +715,19 @@
     PS_ASSERT_PTR_NON_NULL(in, 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); */
-
+    // slaOapqk(type, in->r, in->d, (double*)grommit, &tpCoord->x, &tpCoord->y);
+ 
     return(tpCoord);
 }
-
-
+*/
+/*
 psPlane* psCoordTPToFPA(psPlane* fpaCoord,
                         const psPlane* tpCoord,
@@ -710,9 +739,10 @@
     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,
@@ -722,9 +752,10 @@
     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,
@@ -734,9 +765,10 @@
     PS_ASSERT_PTR_NON_NULL(cell, NULL);
     PS_ASSERT_PTR_NON_NULL(cell->fromChip, NULL);
-
+ 
     cellCoord = psPlaneTransformApply(cellCoord, cell->fromChip, chipCoord);
     return(cellCoord);
 }
-
+*/
+/*
 psPlane* psCoordSkyToCell(psPlane* cellCoord,
                           const psSphere* skyCoord,
@@ -750,29 +782,30 @@
     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;
-
+ 
     // Convert the skyCoords to tangent plane coords.
     psPlane *tpCoord = psCoordSkyToTP(tpCoord, skyCoord, grommit);
-
+ 
     // Convert the tangent plane coords to FPA coords.
     psPlane *fpaCoord = psCoordTPToFPA(fpaCoord, tpCoord, color,
                                        magnitude, parFPA);
-
+ 
     // Convert the FPA coords to chip coords.
     psPlane *chipCoord = psCoordFPAToChip(chipCoord, 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,
@@ -790,5 +823,5 @@
                  "WARNING: psCoordSkyToCellQuick(): The cell->toSky transform is ignored.  The cell->toTP transform is being used.");
     }
-
+ 
     psPlane *tpCoord = NULL;
     psChip *whichChip = cell->parent;
@@ -796,15 +829,15 @@
     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)) {
@@ -813,8 +846,8 @@
                 "cell to tangent plane");
     }
-
+ 
     TPtoCell = p_psPlaneTransformLinearInvert(cell->toTP);
     cellCoord = psPlaneTransformApply(cellCoord, TPtoCell, tpCoord);
-
+ 
     // Restore old projection type.  Free memory.
     whichFPA->projection->type = oldProjectionType;
@@ -822,5 +855,5 @@
     return (cellCoord);
 }
-
-
-
+*/
+
+