Index: /branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/ReadStarsFITS.c
===================================================================
--- /branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/ReadStarsFITS.c	(revision 38529)
+++ /branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/ReadStarsFITS.c	(revision 38530)
@@ -69,16 +69,15 @@
 
   Catalog *catalog = NULL;
-# if (0)
   if (!strcmp (type, "SMPDATA")) {
-    stars = Convert_SMPDATA (&table, &Nstars);
+    catalog = Convert_SMPDATA (&table);
   }
   if (!strcmp (type, "PS1_DEV_0")) {
-    stars = Convert_PS1_DEV_0 (&table, &Nstars);
+    catalog = Convert_PS1_DEV_0 (&table);
   }
   if (!strcmp (type, "PS1_DEV_1")) {
-    stars = Convert_PS1_DEV_1 (&table, &Nstars);
+    catalog = Convert_PS1_DEV_1 (&table);
   }
   if (!strcmp (type, "PS1_V1")) {
-    stars = Convert_PS1_V1 (&table, &Nstars);
+    catalog = Convert_PS1_V1 (&table);
   }
   if (!strcmp (type, "PS1_V2")) {
@@ -87,57 +86,52 @@
       return (NULL);
     }
-    stars = Convert_PS1_V2 (&table, &Nstars);
+    catalog = Convert_PS1_V2 (&table);
   }
   if (!strcmp (type, "PS1_V3")) {
-    stars = Convert_PS1_V3 (&table, &Nstars);
+    catalog = Convert_PS1_V3 (&table);
   }
   if (!strcmp (type, "PS1_V4")) {
-    stars = Convert_PS1_V4 (&table, &Nstars);
-  }
-# endif
+    catalog = Convert_PS1_V4 (&table);
+  }
   if (!strcmp (type, "PS1_V5")) {
     switch (table.header[0].Naxis[0]) {
       case 232:
-	catalog = Convert_PS1_V5 (&table);
-	break;
-# if (0)
+        catalog = Convert_PS1_V5 (&table);
+        break;
       case 312:
-	stars = Convert_PS1_V5_R0_Lensing (&table, &Nstars);
-	break;
+        catalog = Convert_PS1_V5_R0_Lensing (&table);
+        break;
       case 320:
-	stars = Convert_PS1_V5_R1_Lensing (&table, &Nstars);
-	break;
+        catalog = Convert_PS1_V5_R1_Lensing (&table);
+        break;
       case 328:
-	stars = Convert_PS1_V5_R2_Lensing (&table, &Nstars);
-	break;
-# endif
+        catalog = Convert_PS1_V5_R2_Lensing (&table);
+        break;
       default:
-	fprintf (stderr, "invalid PS1_V5 table size %d\n", (int) table.header[0].Naxis[0]);
-	return NULL;
-    }
-  }
-# if (0)
+        fprintf (stderr, "invalid PS1_V5 table size %d\n", (int) table.header[0].Naxis[0]);
+        return NULL;
+    }
+  }
   if (!strcmp (type, "PS1_SV1")) {
-    stars = Convert_PS1_SV1 (&table, &Nstars);
+    catalog = Convert_PS1_SV1 (&table);
   }
   if (!strcmp (type, "PS1_SV2")) {
-    stars = Convert_PS1_SV2 (&table, &Nstars);
+    catalog = Convert_PS1_SV2 (&table);
   }
   if (!strcmp (type, "PS1_SV3")) {
-    stars = Convert_PS1_SV3 (&table, &Nstars);
+    catalog = Convert_PS1_SV3 (&table);
   }
   if (!strcmp (type, "PS1_SV4")) {
-    stars = Convert_PS1_SV4 (&table, &Nstars);
+    catalog = Convert_PS1_SV4 (&table);
   }
   if (!strcmp (type, "PS1_DV3")) {
-    stars = Convert_PS1_DV3 (&table, &Nstars);
+    catalog = Convert_PS1_DV3 (&table);
   }
   if (!strcmp (type, "PS1_DV4")) {
-    stars = Convert_PS1_DV4 (&table, &Nstars);
+    catalog = Convert_PS1_DV4 (&table);
   }
   if (!strcmp (type, "PS1_DV5")) {
-    stars = Convert_PS1_DV5 (&table, &Nstars);
-  }
-# endif
+    catalog = Convert_PS1_DV5 (&table);
+  }
   if (catalog == NULL) {
     fprintf (stderr, "invalid table type %s\n", type);
@@ -166,12 +160,9 @@
 }
 
-# if (0)
-
-Stars *Convert_SMPDATA (FTable *table, unsigned int *nstars) {
+Catalog *Convert_SMPDATA (FTable *table) {
 
   off_t Nstars;
   unsigned int i;
   double ZeroPt;
-  Stars *stars = NULL;
   SMPData *smpdata = NULL;
 
@@ -183,65 +174,62 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-
-    stars[i].measure.Xccd       = smpdata[i].X;
-    stars[i].measure.Yccd       = smpdata[i].Y;
-    stars[i].measure.dXccd    	= NAN_S_SHORT; // not provided by SMPDATA:
-    stars[i].measure.dYccd    	= NAN_S_SHORT; // not provided by SMPDATA:
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = smpdata[i].X;
+    catalog->measure[i].Yccd       = smpdata[i].Y;
+    catalog->measure[i].dXccd      = NAN_S_SHORT; // not provided by SMPDATA:
+    catalog->measure[i].dYccd      = NAN_S_SHORT; // not provided by SMPDATA:
    
-    stars[i].measure.posangle 	= NAN_S_SHORT; // not provided by SMPDATA:
-    stars[i].measure.pltscale 	= NAN;         // not provided by SMPDATA:
+    catalog->measure[i].posangle   = NAN_S_SHORT; // not provided by SMPDATA:
+    catalog->measure[i].pltscale   = NAN;         // not provided by SMPDATA:
 
     if ((smpdata[i].M >= ZeroPt) || isnan(smpdata[i].M)) {
-      stars[i].measure.M        = NAN;
-      stars[i].measure.Map      = NAN;
-      stars[i].measure.FluxPSF  = NAN;
-      stars[i].measure.dFluxPSF = NAN;
-    } else {
-      stars[i].measure.M        = smpdata[i].M;
-      stars[i].measure.Map      = smpdata[i].M;
-      stars[i].measure.FluxPSF  = pow(10.0, -0.4*smpdata[i].M);
-      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * smpdata[i].dM;
-    }
-    stars[i].measure.dM         = smpdata[i].dM*0.001;
-    stars[i].measure.dMcal    	= NAN; // not provided by SMPDATA:
-
-    stars[i].measure.Mkron    	= NAN; // not provided by SMPDATA:
-    stars[i].measure.dMkron   	= NAN; // not provided by SMPDATA:
-    stars[i].measure.FluxKron   = NAN; // not provided by SMPDATA:
-    stars[i].measure.dFluxKron  = NAN; // not provided by SMPDATA:
-
-    stars[i].measure.Sky      	= NAN; // not provided by SMPDATA:
-    stars[i].measure.dSky     	= NAN; // not provided by SMPDATA:
-
-    stars[i].measure.psfChisq 	= NAN;	     // not provided by SMPDATA:
-    stars[i].measure.psfQF  	= NAN;	     // not provided by SMPDATA:
-    stars[i].measure.psfNdof    = NAN_S_INT; // not provided by SMPDATA:
-    stars[i].measure.psfNpix    = NAN_S_INT; // not provided by SMPDATA:
-    stars[i].measure.extNsigma  = NAN;	     // not provided by SMPDATA:
-
-    stars[i].measure.FWx        = ToShortPixels (smpdata[i].fx);
-    stars[i].measure.FWy        = ToShortPixels (smpdata[i].fy);
-    stars[i].measure.theta      = ToShortDegrees (smpdata[i].df);
-
-    stars[i].measure.Mxx        = NAN_S_SHORT; // not provided by SMPDATA:
-    stars[i].measure.Mxy        = NAN_S_SHORT; // not provided by SMPDATA:
-    stars[i].measure.Myy        = NAN_S_SHORT; // not provided by SMPDATA:
+      catalog->measure[i].M        = NAN;
+      catalog->measure[i].Map      = NAN;
+      catalog->measure[i].FluxPSF  = NAN;
+      catalog->measure[i].dFluxPSF = NAN;
+    } else {
+      catalog->measure[i].M        = smpdata[i].M;
+      catalog->measure[i].Map      = smpdata[i].M;
+      catalog->measure[i].FluxPSF  = pow(10.0, -0.4*smpdata[i].M);
+      catalog->measure[i].dFluxPSF = catalog->measure[i].FluxPSF * smpdata[i].dM;
+    }
+    catalog->measure[i].dM         = smpdata[i].dM*0.001;
+    catalog->measure[i].dMcal      = NAN; // not provided by SMPDATA:
+
+    catalog->measure[i].Mkron      = NAN; // not provided by SMPDATA:
+    catalog->measure[i].dMkron     = NAN; // not provided by SMPDATA:
+    catalog->measure[i].FluxKron   = NAN; // not provided by SMPDATA:
+    catalog->measure[i].dFluxKron  = NAN; // not provided by SMPDATA:
+
+    catalog->measure[i].Sky        = NAN; // not provided by SMPDATA:
+    catalog->measure[i].dSky       = NAN; // not provided by SMPDATA:
+
+    catalog->measure[i].psfChisq   = NAN;       // not provided by SMPDATA:
+    catalog->measure[i].psfQF      = NAN;       // not provided by SMPDATA:
+    catalog->measure[i].psfNdof    = NAN_S_INT; // not provided by SMPDATA:
+    catalog->measure[i].psfNpix    = NAN_S_INT; // not provided by SMPDATA:
+    catalog->measure[i].extNsigma  = NAN;       // not provided by SMPDATA:
+
+    catalog->measure[i].FWx        = ToShortPixels (smpdata[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels (smpdata[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees (smpdata[i].df);
+
+    catalog->measure[i].Mxx        = NAN_S_SHORT; // not provided by SMPDATA:
+    catalog->measure[i].Mxy        = NAN_S_SHORT; // not provided by SMPDATA:
+    catalog->measure[i].Myy        = NAN_S_SHORT; // not provided by SMPDATA:
                         
     // the dophot type information gets pushed into the upper 2 bytes of photFlags
-    stars[i].measure.photFlags  = (smpdata[i].dophot << 16);
-  }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_DEV_0 (FTable *table, unsigned int *nstars) {
+    catalog->measure[i].photFlags  = (smpdata[i].dophot << 16);
+  }    
+  return catalog;
+}
+
+Catalog *Convert_PS1_DEV_0 (FTable *table) {
 
   off_t Nstars;
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   PS1_DEV_0 *ps1data;
 
@@ -253,66 +241,64 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd     	= ps1data[i].X;
-    stars[i].measure.Yccd     	= ps1data[i].Y;
-    stars[i].measure.dXccd    	= ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd    	= ToShortPixels(ps1data[i].dY);
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
    
-    stars[i].measure.posangle 	= NAN_S_SHORT; // not provided by PS1_DEV_0:
-    stars[i].measure.pltscale 	= NAN;         // not provided by PS1_DEV_0:
+    catalog->measure[i].posangle   = NAN_S_SHORT; // not provided by PS1_DEV_0:
+    catalog->measure[i].pltscale   = NAN;         // not provided by PS1_DEV_0:
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      	= NAN;
-      stars[i].measure.FluxPSF  = NAN;
-      stars[i].measure.dFluxPSF = NAN;
-    } else {
-      stars[i].measure.M      	= ps1data[i].M + ZeroPt;
-      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
-      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
-    }
-    stars[i].measure.dM       	= ps1data[i].dM;
-    stars[i].measure.dMcal    	= NAN; // not provided by PS1_DEV_0:
-    stars[i].measure.Map      	= NAN; // not provided by PS1_DEV_0:
-
-    stars[i].measure.Mkron    	= NAN; // not provided by PS1_DEV_0:
-    stars[i].measure.dMkron   	= NAN; // not provided by PS1_DEV_0:
-    stars[i].measure.FluxKron   = NAN; // not provided by PS1_DEV_0:
-    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_DEV_0:
-
-    stars[i].measure.Sky      	= ps1data[i].sky;
-    stars[i].measure.dSky     	= ps1data[i].dSky;
-
-    stars[i].measure.psfChisq 	= ps1data[i].psfChisq;
-    stars[i].measure.psfQF  	= ps1data[i].psfQF;
-    stars[i].measure.psfNdof    = NAN_S_INT; // not provided by PS1_DEV_0:
-    stars[i].measure.psfNpix    = NAN_S_INT; // not provided by PS1_DEV_0:
-    stars[i].measure.extNsigma  = NAN;        // not provided by PS1_DEV_0:
-
-    stars[i].measure.FWx      	= ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy      	= ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta    	= ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = NAN_S_SHORT; // not provided by PS1_DEV_0:
-    stars[i].measure.Mxy        = NAN_S_SHORT; // not provided by PS1_DEV_0:
-    stars[i].measure.Myy        = NAN_S_SHORT; // not provided by PS1_DEV_0:
-                        
-    stars[i].measure.photFlags  = 0; // not provided by PS1_DEV_0:
-
-    stars[i].measure.detID      = ps1data[i].detID;
-  }    
-  *nstars = Nstars;
-  return (stars);
+      catalog->measure[i].M        = NAN;
+      catalog->measure[i].FluxPSF  = NAN;
+      catalog->measure[i].dFluxPSF = NAN;
+    } else {
+      catalog->measure[i].M        = ps1data[i].M + ZeroPt;
+      catalog->measure[i].FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
+      catalog->measure[i].dFluxPSF = catalog->measure[i].FluxPSF * ps1data[i].dM;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = NAN; // not provided by PS1_DEV_0:
+    catalog->measure[i].Map        = NAN; // not provided by PS1_DEV_0:
+
+    catalog->measure[i].Mkron      = NAN; // not provided by PS1_DEV_0:
+    catalog->measure[i].dMkron     = NAN; // not provided by PS1_DEV_0:
+    catalog->measure[i].FluxKron   = NAN; // not provided by PS1_DEV_0:
+    catalog->measure[i].dFluxKron  = NAN; // not provided by PS1_DEV_0:
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfNdof    = NAN_S_INT; // not provided by PS1_DEV_0:
+    catalog->measure[i].psfNpix    = NAN_S_INT; // not provided by PS1_DEV_0:
+    catalog->measure[i].extNsigma  = NAN;        // not provided by PS1_DEV_0:
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = NAN_S_SHORT; // not provided by PS1_DEV_0:
+    catalog->measure[i].Mxy        = NAN_S_SHORT; // not provided by PS1_DEV_0:
+    catalog->measure[i].Myy        = NAN_S_SHORT; // not provided by PS1_DEV_0:
+                        
+    catalog->measure[i].photFlags  = 0; // not provided by PS1_DEV_0:
+
+    catalog->measure[i].detID      = ps1data[i].detID;
+  }    
+  return catalog;
 }
 
 // XXX I need to make the IPP I/O functions and these functions
 // consistent wrt ZERO_POINT....
-Stars *Convert_PS1_DEV_1 (FTable *table, unsigned int *nstars) {
+Catalog *Convert_PS1_DEV_1 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   PS1_DEV_1 *ps1data;
 
@@ -324,65 +310,63 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = NAN_S_SHORT; // not provided by PS1_DEV_1:
-    stars[i].measure.pltscale   = NAN;         // not provided by PS1_DEV_1:
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = NAN_S_SHORT; // not provided by PS1_DEV_1:
+    catalog->measure[i].pltscale   = NAN;         // not provided by PS1_DEV_1:
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-      stars[i].measure.FluxPSF  = NAN;
-      stars[i].measure.dFluxPSF = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
-      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = NAN; // not provided by PS1_DEV_1:
-    stars[i].measure.Map        = NAN; // not provided by PS1_DEV_1:
-
-    stars[i].measure.Mkron      = NAN; // not provided by PS1_DEV_1:
-    stars[i].measure.dMkron     = NAN; // not provided by PS1_DEV_1:
-    stars[i].measure.FluxKron   = NAN; // not provided by PS1_DEV_1:
-    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_DEV_1:
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfNdof    = NAN_S_INT; // not provided by PS1_DEV_1:
-    stars[i].measure.psfNpix    = NAN_S_INT; // not provided by PS1_DEV_1:
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = NAN_S_SHORT; // not provided by PS1_DEV_1:
-    stars[i].measure.Mxy        = NAN_S_SHORT; // not provided by PS1_DEV_1:
-    stars[i].measure.Myy        = NAN_S_SHORT; // not provided by PS1_DEV_1:
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID;
-  }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_V1 (FTable *table, unsigned int *nstars) {
+      catalog->measure[i].M      = NAN;
+      catalog->measure[i].FluxPSF  = NAN;
+      catalog->measure[i].dFluxPSF = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+      catalog->measure[i].FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
+      catalog->measure[i].dFluxPSF = catalog->measure[i].FluxPSF * ps1data[i].dM;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = NAN; // not provided by PS1_DEV_1:
+    catalog->measure[i].Map        = NAN; // not provided by PS1_DEV_1:
+
+    catalog->measure[i].Mkron      = NAN; // not provided by PS1_DEV_1:
+    catalog->measure[i].dMkron     = NAN; // not provided by PS1_DEV_1:
+    catalog->measure[i].FluxKron   = NAN; // not provided by PS1_DEV_1:
+    catalog->measure[i].dFluxKron  = NAN; // not provided by PS1_DEV_1:
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfNdof    = NAN_S_INT; // not provided by PS1_DEV_1:
+    catalog->measure[i].psfNpix    = NAN_S_INT; // not provided by PS1_DEV_1:
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = NAN_S_SHORT; // not provided by PS1_DEV_1:
+    catalog->measure[i].Mxy        = NAN_S_SHORT; // not provided by PS1_DEV_1:
+    catalog->measure[i].Myy        = NAN_S_SHORT; // not provided by PS1_DEV_1:
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID;
+  }    
+  return catalog;
+}
+
+Catalog *Convert_PS1_V1 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_V1 *ps1data;
 
@@ -396,6 +380,6 @@
 
   if (table[0].header[0].Naxis[0] == 136) {
-    stars = Convert_PS1_V1_Alt (table, nstars);
-    return (stars);
+    Catalog *catalog = Convert_PS1_V1_Alt (table);
+    return catalog;
   }
 
@@ -407,55 +391,55 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-      stars[i].measure.FluxPSF  = NAN;
-      stars[i].measure.dFluxPSF = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
-      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = ps1data[i].dM; // a proxy measure
-                        
-    stars[i].measure.Mkron      = NAN; // not provided by PS1_V1:
-    stars[i].measure.dMkron     = NAN; // not provided by PS1_V1:
-    stars[i].measure.FluxKron   = NAN; // not provided by PS1_V1:
-    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_V1:
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+      catalog->measure[i].M      = NAN;
+      catalog->measure[i].FluxPSF  = NAN;
+      catalog->measure[i].dFluxPSF = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+      catalog->measure[i].FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
+      catalog->measure[i].dFluxPSF = catalog->measure[i].FluxPSF * ps1data[i].dM;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = ps1data[i].dM; // a proxy measure
+                        
+    catalog->measure[i].Mkron      = NAN; // not provided by PS1_V1:
+    catalog->measure[i].dMkron     = NAN; // not provided by PS1_V1:
+    catalog->measure[i].FluxKron   = NAN; // not provided by PS1_V1:
+    catalog->measure[i].dFluxKron  = NAN; // not provided by PS1_V1:
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -465,14 +449,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_V1_Alt (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_V1_Alt (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_V2 *ps1data;
 
@@ -485,5 +467,5 @@
   // call a special conversion function if it is found.
 
-  ps1data = gfits_table_get_CMF_PS1_V1_Alt (table, &Nstars, NULL);
+  ps1data = gfits_table_get_CMF_PS1_V1_Alt (table, &Nstars, NULL); 
   if (!ps1data) {
     fprintf (stderr, "skipping inconsistent entry\n");
@@ -492,55 +474,55 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-      stars[i].measure.FluxPSF  = NAN;
-      stars[i].measure.dFluxPSF = NAN;
-    } else {
-      stars[i].measure.M        = ps1data[i].M + ZeroPt;
-      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
-      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = ps1data[i].dM; // a proxy measure
-                        
-    stars[i].measure.Mkron      = NAN; // not provided by PS1_V1_Alt:
-    stars[i].measure.dMkron     = NAN; // not provided by PS1_V1_Alt:
-    stars[i].measure.FluxKron   = NAN; // not provided by PS1_V1_Alt:
-    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_V1_Alt:
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+      catalog->measure[i].M      = NAN;
+      catalog->measure[i].FluxPSF  = NAN;
+      catalog->measure[i].dFluxPSF = NAN;
+    } else {
+      catalog->measure[i].M        = ps1data[i].M + ZeroPt;
+      catalog->measure[i].FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
+      catalog->measure[i].dFluxPSF = catalog->measure[i].FluxPSF * ps1data[i].dM;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = ps1data[i].dM; // a proxy measure
+                        
+    catalog->measure[i].Mkron      = NAN; // not provided by PS1_V1_Alt:
+    catalog->measure[i].dMkron     = NAN; // not provided by PS1_V1_Alt:
+    catalog->measure[i].FluxKron   = NAN; // not provided by PS1_V1_Alt:
+    catalog->measure[i].dFluxKron  = NAN; // not provided by PS1_V1_Alt:
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -550,14 +532,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_V2 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_V2 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_V2 *ps1data;
 
@@ -569,55 +549,55 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M        = NAN;
-      stars[i].measure.FluxPSF  = NAN;
-      stars[i].measure.dFluxPSF = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
-      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = ps1data[i].dM; // a proxy measure
-                        
-    stars[i].measure.Mkron      = NAN; // not provided by PS1_V2:
-    stars[i].measure.dMkron     = NAN; // not provided by PS1_V2:
-    stars[i].measure.FluxKron   = NAN; // not provided by PS1_V2:
-    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_V2:
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+      catalog->measure[i].M        = NAN;
+      catalog->measure[i].FluxPSF  = NAN;
+      catalog->measure[i].dFluxPSF = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+      catalog->measure[i].FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
+      catalog->measure[i].dFluxPSF = catalog->measure[i].FluxPSF * ps1data[i].dM;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = ps1data[i].dM; // a proxy measure
+                        
+    catalog->measure[i].Mkron      = NAN; // not provided by PS1_V2:
+    catalog->measure[i].dMkron     = NAN; // not provided by PS1_V2:
+    catalog->measure[i].FluxKron   = NAN; // not provided by PS1_V2:
+    catalog->measure[i].dFluxKron  = NAN; // not provided by PS1_V2:
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -627,14 +607,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_V3 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_V3 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_V3 *ps1data;
 
@@ -646,59 +624,59 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = ps1data[i].dM; // a proxy measure
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = ps1data[i].dM; // a proxy measure
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
                         
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (NAN, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (NAN, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (NAN, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (NAN, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -711,103 +689,15 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_V4 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_V4 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_V4 *ps1data;
 
   ps1data = gfits_table_get_CMF_PS1_V4 (table, &Nstars, NULL, NULL);
-  if (!ps1data) {
-    fprintf (stderr, "skipping inconsistent entry\n");
-    return (NULL);
-  }
-  ZeroPt = GetZeroPoint();
-
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
-
-    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
-                        
-    // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
-
-    // the Average fields and the following Measure fields are set in FilterStars after
-    // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID.
-
-    // averef is set in find_matches
-
-    // dbFlags is zero on ingest.
-
-    // the following fields are currently not being set anywhere: t_msec
-  }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-# endif
-
-Catalog *Convert_PS1_V5 (FTable *table) {
-
-  off_t Nstars; 
-  unsigned int i;
-  double ZeroPt;
-  CMF_PS1_V5 *ps1data;
-
-  ps1data = gfits_table_get_CMF_PS1_V5 (table, &Nstars, NULL);
   if (!ps1data) {
     fprintf (stderr, "skipping inconsistent entry\n");
@@ -882,15 +772,95 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  return (catalog);
-}
-
-# if (0)
-
-Stars *Convert_PS1_V5_R0_Lensing (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_V5 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
+  CMF_PS1_V5 *ps1data;
+
+  ps1data = gfits_table_get_CMF_PS1_V5 (table, &Nstars, NULL);
+  if (!ps1data) {
+    fprintf (stderr, "skipping inconsistent entry\n");
+    return (NULL);
+  }
+  ZeroPt = GetZeroPoint();
+
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
+
+    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+                        
+    // these fluxes are converted from counts to counts/sec in FilterStars.c
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
+
+    // the Average fields and the following Measure fields are set in FilterStars after
+    // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID.
+
+    // averef is set in find_matches
+
+    // dbFlags is zero on ingest.
+
+    // the following fields are currently not being set anywhere: t_msec
+  }    
+  return catalog;
+}
+
+Catalog *Convert_PS1_V5_R0_Lensing (FTable *table) {
+
+  off_t Nstars; 
+  unsigned int i;
+  double ZeroPt;
   CMF_PS1_V5_R0_Lensing *ps1data;
 
@@ -902,100 +872,100 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+  ALLOCATE (catalog->lensing, Lensing, Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
                         
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
-
-    ALLOCATE (stars[i].lensing, Lensing, 1);
-    dvo_lensing_init (stars[i].lensing);
-
-    stars[i].lensing->X11_sm_obj  = ps1data[i].X11_sm_obj;
-    stars[i].lensing->X12_sm_obj  = ps1data[i].X12_sm_obj;
-    stars[i].lensing->X22_sm_obj  = ps1data[i].X22_sm_obj;
-    stars[i].lensing->E1_sm_obj   = ps1data[i].E1_sm_obj;
-    stars[i].lensing->E2_sm_obj   = ps1data[i].E2_sm_obj;
-
-    stars[i].lensing->X11_sh_obj  = ps1data[i].X11_sh_obj;
-    stars[i].lensing->X12_sh_obj  = ps1data[i].X12_sh_obj;
-    stars[i].lensing->X22_sh_obj  = ps1data[i].X22_sh_obj;
-    stars[i].lensing->E1_sh_obj   = ps1data[i].E1_sh_obj;
-    stars[i].lensing->E2_sh_obj   = ps1data[i].E2_sh_obj;
-
-    stars[i].lensing->X11_sm_psf  = ps1data[i].X11_sm_psf;
-    stars[i].lensing->X12_sm_psf  = ps1data[i].X12_sm_psf;
-    stars[i].lensing->X22_sm_psf  = ps1data[i].X22_sm_psf;
-    stars[i].lensing->E1_sm_psf   = ps1data[i].E1_sm_psf;
-    stars[i].lensing->E2_sm_psf   = ps1data[i].E2_sm_psf;
-
-    stars[i].lensing->X11_sh_psf  = ps1data[i].X11_sh_psf;
-    stars[i].lensing->X12_sh_psf  = ps1data[i].X12_sh_psf;
-    stars[i].lensing->X22_sh_psf  = ps1data[i].X22_sh_psf;
-    stars[i].lensing->E1_sh_psf   = ps1data[i].E1_sh_psf;
-    stars[i].lensing->E2_sh_psf   = ps1data[i].E2_sh_psf;
-
-    // stars[i].lensing->F_ApR5    = ps1data[i].F_ApR5;
-    // stars[i].lensing->dF_ApR5   = ps1data[i].dF_ApR5;
-    // stars[i].lensing->sF_ApR5   = ps1data[i].sF_ApR5;
-    // stars[i].lensing->fF_ApR5   = ps1data[i].fF_ApR5;
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
+
+    dvo_lensing_init (&catalog->lensing[i]);
+
+    catalog->lensing[i].X11_sm_obj  = ps1data[i].X11_sm_obj;
+    catalog->lensing[i].X12_sm_obj  = ps1data[i].X12_sm_obj;
+    catalog->lensing[i].X22_sm_obj  = ps1data[i].X22_sm_obj;
+    catalog->lensing[i].E1_sm_obj   = ps1data[i].E1_sm_obj;
+    catalog->lensing[i].E2_sm_obj   = ps1data[i].E2_sm_obj;
+
+    catalog->lensing[i].X11_sh_obj  = ps1data[i].X11_sh_obj;
+    catalog->lensing[i].X12_sh_obj  = ps1data[i].X12_sh_obj;
+    catalog->lensing[i].X22_sh_obj  = ps1data[i].X22_sh_obj;
+    catalog->lensing[i].E1_sh_obj   = ps1data[i].E1_sh_obj;
+    catalog->lensing[i].E2_sh_obj   = ps1data[i].E2_sh_obj;
+
+    catalog->lensing[i].X11_sm_psf  = ps1data[i].X11_sm_psf;
+    catalog->lensing[i].X12_sm_psf  = ps1data[i].X12_sm_psf;
+    catalog->lensing[i].X22_sm_psf  = ps1data[i].X22_sm_psf;
+    catalog->lensing[i].E1_sm_psf   = ps1data[i].E1_sm_psf;
+    catalog->lensing[i].E2_sm_psf   = ps1data[i].E2_sm_psf;
+
+    catalog->lensing[i].X11_sh_psf  = ps1data[i].X11_sh_psf;
+    catalog->lensing[i].X12_sh_psf  = ps1data[i].X12_sh_psf;
+    catalog->lensing[i].X22_sh_psf  = ps1data[i].X22_sh_psf;
+    catalog->lensing[i].E1_sh_psf   = ps1data[i].E1_sh_psf;
+    catalog->lensing[i].E2_sh_psf   = ps1data[i].E2_sh_psf;
+
+    // catalog->lensing[i].F_ApR5    = ps1data[i].F_ApR5;
+    // catalog->lensing[i].dF_ApR5   = ps1data[i].dF_ApR5;
+    // catalog->lensing[i].sF_ApR5   = ps1data[i].sF_ApR5;
+    // catalog->lensing[i].fF_ApR5   = ps1data[i].fF_ApR5;
     // 
-    // stars[i].lensing->F_ApR6    = ps1data[i].F_ApR6;
-    // stars[i].lensing->dF_ApR6   = ps1data[i].dF_ApR6;
-    // stars[i].lensing->sF_ApR6   = ps1data[i].sF_ApR6;
-    // stars[i].lensing->fF_ApR6   = ps1data[i].fF_ApR6;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].lensing->detID      = ps1data[i].detID; 
+    // catalog->lensing[i].F_ApR6    = ps1data[i].F_ApR6;
+    // catalog->lensing[i].dF_ApR6   = ps1data[i].dF_ApR6;
+    // catalog->lensing[i].sF_ApR6   = ps1data[i].sF_ApR6;
+    // catalog->lensing[i].fF_ApR6   = ps1data[i].fF_ApR6;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->lensing[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1008,14 +978,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_V5_R1_Lensing (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_V5_R1_Lensing (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_V5_R1_Lensing *ps1data;
 
@@ -1027,100 +995,100 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+  ALLOCATE (catalog->lensing, Lensing, Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
                         
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
-
-    ALLOCATE (stars[i].lensing, Lensing, 1);
-    dvo_lensing_init (stars[i].lensing);
-
-    stars[i].lensing->X11_sm_obj  = ps1data[i].X11_sm_obj;
-    stars[i].lensing->X12_sm_obj  = ps1data[i].X12_sm_obj;
-    stars[i].lensing->X22_sm_obj  = ps1data[i].X22_sm_obj;
-    stars[i].lensing->E1_sm_obj   = ps1data[i].E1_sm_obj;
-    stars[i].lensing->E2_sm_obj   = ps1data[i].E2_sm_obj;
-
-    stars[i].lensing->X11_sh_obj  = ps1data[i].X11_sh_obj;
-    stars[i].lensing->X12_sh_obj  = ps1data[i].X12_sh_obj;
-    stars[i].lensing->X22_sh_obj  = ps1data[i].X22_sh_obj;
-    stars[i].lensing->E1_sh_obj   = ps1data[i].E1_sh_obj;
-    stars[i].lensing->E2_sh_obj   = ps1data[i].E2_sh_obj;
-
-    stars[i].lensing->X11_sm_psf  = ps1data[i].X11_sm_psf;
-    stars[i].lensing->X12_sm_psf  = ps1data[i].X12_sm_psf;
-    stars[i].lensing->X22_sm_psf  = ps1data[i].X22_sm_psf;
-    stars[i].lensing->E1_sm_psf   = ps1data[i].E1_sm_psf;
-    stars[i].lensing->E2_sm_psf   = ps1data[i].E2_sm_psf;
-
-    stars[i].lensing->X11_sh_psf  = ps1data[i].X11_sh_psf;
-    stars[i].lensing->X12_sh_psf  = ps1data[i].X12_sh_psf;
-    stars[i].lensing->X22_sh_psf  = ps1data[i].X22_sh_psf;
-    stars[i].lensing->E1_sh_psf   = ps1data[i].E1_sh_psf;
-    stars[i].lensing->E2_sh_psf   = ps1data[i].E2_sh_psf;
-
-    // stars[i].lensing->F_ApR5    = ps1data[i].F_ApR5;
-    // stars[i].lensing->dF_ApR5   = ps1data[i].dF_ApR5;
-    // stars[i].lensing->sF_ApR5   = ps1data[i].sF_ApR5;
-    // stars[i].lensing->fF_ApR5   = ps1data[i].fF_ApR5;
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
+
+    dvo_lensing_init (&catalog->lensing[i]);
+
+    catalog->lensing[i].X11_sm_obj  = ps1data[i].X11_sm_obj;
+    catalog->lensing[i].X12_sm_obj  = ps1data[i].X12_sm_obj;
+    catalog->lensing[i].X22_sm_obj  = ps1data[i].X22_sm_obj;
+    catalog->lensing[i].E1_sm_obj   = ps1data[i].E1_sm_obj;
+    catalog->lensing[i].E2_sm_obj   = ps1data[i].E2_sm_obj;
+
+    catalog->lensing[i].X11_sh_obj  = ps1data[i].X11_sh_obj;
+    catalog->lensing[i].X12_sh_obj  = ps1data[i].X12_sh_obj;
+    catalog->lensing[i].X22_sh_obj  = ps1data[i].X22_sh_obj;
+    catalog->lensing[i].E1_sh_obj   = ps1data[i].E1_sh_obj;
+    catalog->lensing[i].E2_sh_obj   = ps1data[i].E2_sh_obj;
+
+    catalog->lensing[i].X11_sm_psf  = ps1data[i].X11_sm_psf;
+    catalog->lensing[i].X12_sm_psf  = ps1data[i].X12_sm_psf;
+    catalog->lensing[i].X22_sm_psf  = ps1data[i].X22_sm_psf;
+    catalog->lensing[i].E1_sm_psf   = ps1data[i].E1_sm_psf;
+    catalog->lensing[i].E2_sm_psf   = ps1data[i].E2_sm_psf;
+
+    catalog->lensing[i].X11_sh_psf  = ps1data[i].X11_sh_psf;
+    catalog->lensing[i].X12_sh_psf  = ps1data[i].X12_sh_psf;
+    catalog->lensing[i].X22_sh_psf  = ps1data[i].X22_sh_psf;
+    catalog->lensing[i].E1_sh_psf   = ps1data[i].E1_sh_psf;
+    catalog->lensing[i].E2_sh_psf   = ps1data[i].E2_sh_psf;
+
+    // catalog->lensing[i].F_ApR5    = ps1data[i].F_ApR5;
+    // catalog->lensing[i].dF_ApR5   = ps1data[i].dF_ApR5;
+    // catalog->lensing[i].sF_ApR5   = ps1data[i].sF_ApR5;
+    // catalog->lensing[i].fF_ApR5   = ps1data[i].fF_ApR5;
     // 
-    // stars[i].lensing->F_ApR6    = ps1data[i].F_ApR6;
-    // stars[i].lensing->dF_ApR6   = ps1data[i].dF_ApR6;
-    // stars[i].lensing->sF_ApR6   = ps1data[i].sF_ApR6;
-    // stars[i].lensing->fF_ApR6   = ps1data[i].fF_ApR6;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].lensing->detID      = ps1data[i].detID; 
+    // catalog->lensing[i].F_ApR6    = ps1data[i].F_ApR6;
+    // catalog->lensing[i].dF_ApR6   = ps1data[i].dF_ApR6;
+    // catalog->lensing[i].sF_ApR6   = ps1data[i].sF_ApR6;
+    // catalog->lensing[i].fF_ApR6   = ps1data[i].fF_ApR6;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->lensing[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1133,14 +1101,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_V5_R2_Lensing (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_V5_R2_Lensing (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_V5_R2_Lensing *ps1data;
 
@@ -1152,103 +1118,103 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+  ALLOCATE (catalog->lensing, Lensing, Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
                         
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
-
-    ALLOCATE (stars[i].lensing, Lensing, 1);
-    dvo_lensing_init (stars[i].lensing);
-
-    stars[i].lensing->X11_sm_obj  = ps1data[i].X11_sm_obj;
-    stars[i].lensing->X12_sm_obj  = ps1data[i].X12_sm_obj;
-    stars[i].lensing->X22_sm_obj  = ps1data[i].X22_sm_obj;
-    stars[i].lensing->E1_sm_obj   = ps1data[i].E1_sm_obj;
-    stars[i].lensing->E2_sm_obj   = ps1data[i].E2_sm_obj;
-
-    stars[i].lensing->X11_sh_obj  = ps1data[i].X11_sh_obj;
-    stars[i].lensing->X12_sh_obj  = ps1data[i].X12_sh_obj;
-    stars[i].lensing->X22_sh_obj  = ps1data[i].X22_sh_obj;
-    stars[i].lensing->E1_sh_obj   = ps1data[i].E1_sh_obj;
-    stars[i].lensing->E2_sh_obj   = ps1data[i].E2_sh_obj;
-
-    stars[i].lensing->X11_sm_psf  = ps1data[i].X11_sm_psf;
-    stars[i].lensing->X12_sm_psf  = ps1data[i].X12_sm_psf;
-    stars[i].lensing->X22_sm_psf  = ps1data[i].X22_sm_psf;
-    stars[i].lensing->E1_sm_psf   = ps1data[i].E1_sm_psf;
-    stars[i].lensing->E2_sm_psf   = ps1data[i].E2_sm_psf;
-
-    stars[i].lensing->X11_sh_psf  = ps1data[i].X11_sh_psf;
-    stars[i].lensing->X12_sh_psf  = ps1data[i].X12_sh_psf;
-    stars[i].lensing->X22_sh_psf  = ps1data[i].X22_sh_psf;
-    stars[i].lensing->E1_sh_psf   = ps1data[i].E1_sh_psf;
-    stars[i].lensing->E2_sh_psf   = ps1data[i].E2_sh_psf;
-
-    stars[i].lensing->E1_psf      = ps1data[i].E1_psf;
-    stars[i].lensing->E2_psf      = ps1data[i].E2_psf;
-
-    // stars[i].lensing->F_ApR5    = ps1data[i].F_ApR5;
-    // stars[i].lensing->dF_ApR5   = ps1data[i].dF_ApR5;
-    // stars[i].lensing->sF_ApR5   = ps1data[i].sF_ApR5;
-    // stars[i].lensing->fF_ApR5   = ps1data[i].fF_ApR5;
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
+
+    dvo_lensing_init (&catalog->lensing[i]);
+
+    catalog->lensing[i].X11_sm_obj  = ps1data[i].X11_sm_obj;
+    catalog->lensing[i].X12_sm_obj  = ps1data[i].X12_sm_obj;
+    catalog->lensing[i].X22_sm_obj  = ps1data[i].X22_sm_obj;
+    catalog->lensing[i].E1_sm_obj   = ps1data[i].E1_sm_obj;
+    catalog->lensing[i].E2_sm_obj   = ps1data[i].E2_sm_obj;
+
+    catalog->lensing[i].X11_sh_obj  = ps1data[i].X11_sh_obj;
+    catalog->lensing[i].X12_sh_obj  = ps1data[i].X12_sh_obj;
+    catalog->lensing[i].X22_sh_obj  = ps1data[i].X22_sh_obj;
+    catalog->lensing[i].E1_sh_obj   = ps1data[i].E1_sh_obj;
+    catalog->lensing[i].E2_sh_obj   = ps1data[i].E2_sh_obj;
+
+    catalog->lensing[i].X11_sm_psf  = ps1data[i].X11_sm_psf;
+    catalog->lensing[i].X12_sm_psf  = ps1data[i].X12_sm_psf;
+    catalog->lensing[i].X22_sm_psf  = ps1data[i].X22_sm_psf;
+    catalog->lensing[i].E1_sm_psf   = ps1data[i].E1_sm_psf;
+    catalog->lensing[i].E2_sm_psf   = ps1data[i].E2_sm_psf;
+
+    catalog->lensing[i].X11_sh_psf  = ps1data[i].X11_sh_psf;
+    catalog->lensing[i].X12_sh_psf  = ps1data[i].X12_sh_psf;
+    catalog->lensing[i].X22_sh_psf  = ps1data[i].X22_sh_psf;
+    catalog->lensing[i].E1_sh_psf   = ps1data[i].E1_sh_psf;
+    catalog->lensing[i].E2_sh_psf   = ps1data[i].E2_sh_psf;
+
+    catalog->lensing[i].E1_psf      = ps1data[i].E1_psf;
+    catalog->lensing[i].E2_psf      = ps1data[i].E2_psf;
+
+    // catalog->lensing[i].F_ApR5    = ps1data[i].F_ApR5;
+    // catalog->lensing[i].dF_ApR5   = ps1data[i].dF_ApR5;
+    // catalog->lensing[i].sF_ApR5   = ps1data[i].sF_ApR5;
+    // catalog->lensing[i].fF_ApR5   = ps1data[i].fF_ApR5;
     // 
-    // stars[i].lensing->F_ApR6    = ps1data[i].F_ApR6;
-    // stars[i].lensing->dF_ApR6   = ps1data[i].dF_ApR6;
-    // stars[i].lensing->sF_ApR6   = ps1data[i].sF_ApR6;
-    // stars[i].lensing->fF_ApR6   = ps1data[i].fF_ApR6;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].lensing->detID      = ps1data[i].detID; 
+    // catalog->lensing[i].F_ApR6    = ps1data[i].F_ApR6;
+    // catalog->lensing[i].dF_ApR6   = ps1data[i].dF_ApR6;
+    // catalog->lensing[i].sF_ApR6   = ps1data[i].sF_ApR6;
+    // catalog->lensing[i].fF_ApR6   = ps1data[i].fF_ApR6;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->lensing[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1261,19 +1227,17 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_SV1 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_SV1 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_SV1 *ps1data;
 
   if (table[0].header[0].Naxis[0] == 196) {
-    stars = Convert_PS1_SV1_Alt (table, nstars);
-    return (stars);
+    Catalog *catalog = Convert_PS1_SV1_Alt (table);
+    return catalog;
   }
 
@@ -1285,60 +1249,60 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = ps1data[i].dM; // a proxy measure
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = ps1data[i].dM; // a proxy measure
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
 
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (NAN, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (NAN, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (NAN, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (NAN, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1348,18 +1312,15 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_SV1_Alt (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_SV1_Alt (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_SV1 *ps1data;
 
   // some test output files were produced called CMF_PS1_SV1 but with mismatch byte boundaries
-
   ps1data = gfits_table_get_CMF_PS1_SV1_Alt (table, &Nstars, NULL);
   if (!ps1data) {
@@ -1369,58 +1330,58 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = ps1data[i].dM; // a proxy measure
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = ps1data[i].dM; // a proxy measure
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
 
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (NAN, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (NAN, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (NAN, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (NAN, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1430,14 +1391,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_SV2 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_SV2 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_SV2 *ps1data;
 
@@ -1449,60 +1408,60 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
 
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1512,14 +1471,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_SV3 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_SV3 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_SV3 *ps1data;
 
@@ -1531,60 +1488,60 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
 
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1594,14 +1551,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_SV4 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_SV4 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_SV4 *ps1data;
 
@@ -1613,60 +1568,60 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
 
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1676,14 +1631,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_DV3 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_DV3 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_DV3 *ps1data;
 
@@ -1695,59 +1648,59 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
                         
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1760,14 +1713,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_DV4 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_DV4 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_DV4 *ps1data;
 
@@ -1781,59 +1732,59 @@
   fprintf (stderr, "WARNING: Convert_PS1_DV4 not yet updated to match real format\n");
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
                         
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1846,14 +1797,12 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-
-Stars *Convert_PS1_DV5 (FTable *table, unsigned int *nstars) {
+  return catalog;
+}
+
+Catalog *Convert_PS1_DV5 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_DV5 *ps1data;
 
@@ -1865,59 +1814,59 @@
   ZeroPt = GetZeroPoint();
 
-  ALLOCATE (stars, Stars, Nstars);
-  for (i = 0; i < Nstars; i++) {
-    InitStar (&stars[i]);
-    stars[i].measure.Xccd       = ps1data[i].X;
-    stars[i].measure.Yccd       = ps1data[i].Y;
-    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
-    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
-
-    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
-    stars[i].measure.pltscale   = ps1data[i].pltscale;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
-    } else {
-      stars[i].measure.M      = ps1data[i].M + ZeroPt;
-    }
-    stars[i].measure.dM         = ps1data[i].dM;
-    stars[i].measure.dMcal      = ps1data[i].dMcal;
-    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
-    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
-                        
-    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
-    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+      catalog->measure[i].M      = NAN;
+    } else {
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
                         
     // these fluxes are converted from counts to counts/sec in FilterStars.c
-    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
-    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
-    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
-    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
-
-    stars[i].measure.Sky        = ps1data[i].sky;
-    stars[i].measure.dSky       = ps1data[i].dSky;
-                        
-    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
-    stars[i].measure.psfQF      = ps1data[i].psfQF;
-    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
-    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
-    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
-
-    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
-    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
-    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
-
-    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
-    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
-    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
-                        
-    stars[i].measure.photFlags  = ps1data[i].flags;
-    stars[i].measure.photFlags2 = ps1data[i].flags2;
-
-    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
-    stars[i].measure.detID      = ps1data[i].detID; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -1930,8 +1879,4 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
-# endif
-
-
+  return catalog;
+}
