Index: /branches/pap/psModules/src/camera/pmReadoutFake.c
===================================================================
--- /branches/pap/psModules/src/camera/pmReadoutFake.c	(revision 25027)
+++ /branches/pap/psModules/src/camera/pmReadoutFake.c	(revision 25028)
@@ -50,13 +50,23 @@
 }
 
-bool pmReadoutFakeFromSources(pmReadout *readout, int numCols, int numRows, const psArray *sources,
-                              const psVector *xOffset, const psVector *yOffset, const pmPSF *psf,
-                              float minFlux, int radius, bool circularise, bool normalisePeak)
+
+bool pmReadoutFakeFromVectors(pmReadout *readout, int numCols, int numRows,
+                              const psVector *x, const psVector *y, const psVector *mag,
+                              const psVector *xOffset, const psVector *yOffset,
+                              const pmPSF *psf, float minFlux, int radius,
+                              bool circularise, bool normalisePeak)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
     PS_ASSERT_INT_LARGER_THAN(numCols, 0, false);
     PS_ASSERT_INT_LARGER_THAN(numRows, 0, false);
-    PS_ASSERT_ARRAY_NON_NULL(sources, false);
-
+    PS_ASSERT_VECTOR_NON_NULL(x, false);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, false);
+    PS_ASSERT_VECTOR_NON_NULL(y, false);
+    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, false);
+    PS_ASSERT_VECTORS_SIZE_EQUAL(y, x, false);
+    PS_ASSERT_VECTOR_NON_NULL(mag, false);
+    PS_ASSERT_VECTOR_TYPE(mag, PS_TYPE_F32, false);
+    PS_ASSERT_VECTORS_SIZE_EQUAL(mag, x, false);
+    long numSources = x->n;              // Number of sources
     if (xOffset || yOffset) {
         PS_ASSERT_VECTOR_NON_NULL(xOffset, false);
@@ -64,9 +74,9 @@
         PS_ASSERT_VECTORS_SIZE_EQUAL(xOffset, yOffset, false);
         PS_ASSERT_VECTOR_TYPE(xOffset, PS_TYPE_S32, false);
-        PS_ASSERT_VECTOR_TYPE_EQUAL(xOffset, yOffset, false);
-        if (xOffset->n != sources->n) {
+        PS_ASSERT_VECTOR_TYPE(yOffset, PS_TYPE_S32, false);
+        if (xOffset->n != numSources) {
             psError(PS_ERR_BAD_PARAMETER_SIZE, true,
                     "Number of offset vectors (%ld) and sources (%ld) doesn't match",
-                    xOffset->n, sources->n);
+                    xOffset->n, numSources);
             return false;
         }
@@ -81,26 +91,7 @@
     psImageInit(readout->image, 0);
 
-    int numSources = sources->n;          // Number of stars
-    for (int i = 0; i < numSources; i++) {
-        pmSource *source = sources->data[i]; // Source of interest
-        if (!source) {
-            continue;
-        }
-        if (source->mode & SOURCE_MASK) {
-            continue;
-        }
-        if (!isfinite(source->psfMag)) {
-            continue;
-        }
-        float x, y;                     // Coordinates of source
-        if (source->modelPSF) {
-            x = source->modelPSF->params->data.F32[PM_PAR_XPOS];
-            y = source->modelPSF->params->data.F32[PM_PAR_YPOS];
-        } else {
-            x = source->peak->xf;
-            y = source->peak->yf;
-        }
-
-        float flux = powf(10.0, -0.4 * source->psfMag); // Flux of source
+    for (long i = 0; i < numSources; i++) {
+        float flux = powf(10.0, -0.4 * mag->data.F32[i]); // Flux of source
+        float xSrc = x->data.F32[i], ySrc = y->data.F32[i]; // Coordinates of source
 
         if (normalisePeak) {
@@ -126,4 +117,5 @@
             continue;
         }
+
         if (circularise && !circulariseModel(fakeModel)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to circularise PSF model.");
@@ -137,11 +129,11 @@
 
         pmSource *fakeSource = pmSourceAlloc(); // Fake source to generate
-        fakeSource->peak = pmPeakAlloc(x, y, fakeModel->params->data.F32[PM_PAR_I0], PM_PEAK_LONE);
+        fakeSource->peak = pmPeakAlloc(xSrc, ySrc, fakeModel->params->data.F32[PM_PAR_I0], PM_PEAK_LONE);
         float fakeRadius = radius > 0 ? radius :
             PS_MAX(1.0, fakeModel->modelRadius(fakeModel->params, minFlux)); // Radius of fake source
 
         if (xOffset) {
-            if (!pmSourceDefinePixels(fakeSource, readout, x + xOffset->data.S32[i],
-                                      y + yOffset->data.S32[i], fakeRadius)) {
+            if (!pmSourceDefinePixels(fakeSource, readout, xSrc + xOffset->data.S32[i],
+                                      ySrc + yOffset->data.S32[i], fakeRadius)) {
                 psErrorClear();
                 continue;
@@ -153,5 +145,5 @@
             }
         } else {
-            if (!pmSourceDefinePixels(fakeSource, readout, x, y, fakeRadius)) {
+            if (!pmSourceDefinePixels(fakeSource, readout, xSrc, ySrc, fakeRadius)) {
                 psErrorClear();
                 continue;
@@ -168,2 +160,59 @@
     return true;
 }
+
+
+
+
+
+
+
+
+bool pmReadoutFakeFromSources(pmReadout *readout, int numCols, int numRows, const psArray *sources,
+                              const psVector *xOffset, const psVector *yOffset, const pmPSF *psf,
+                              float minFlux, int radius, bool circularise, bool normalisePeak)
+{
+    PS_ASSERT_ARRAY_NON_NULL(sources, false);
+
+    int numSources = sources->n;          // Number of stars
+    psVector *x = psVectorAllocEmpty(numSources, PS_TYPE_F32);
+    psVector *y = psVectorAllocEmpty(numSources, PS_TYPE_F32);
+    psVector *mag = psVectorAllocEmpty(numSources, PS_TYPE_F32);
+
+    int numGood = 0;                    // Number of good sources
+    for (int i = 0; i < numSources; i++) {
+        pmSource *source = sources->data[i]; // Source of interest
+        if (!source) {
+            continue;
+        }
+        if (source->mode & SOURCE_MASK) {
+            continue;
+        }
+        if (!isfinite(source->psfMag)) {
+            continue;
+        }
+        float xSrc, ySrc;                     // Coordinates of source
+        if (source->modelPSF) {
+            xSrc = source->modelPSF->params->data.F32[PM_PAR_XPOS];
+            ySrc = source->modelPSF->params->data.F32[PM_PAR_YPOS];
+        } else {
+            xSrc = source->peak->xf;
+            ySrc = source->peak->yf;
+        }
+
+        x->data.F32[numGood] = xSrc;
+        y->data.F32[numGood] = ySrc;
+        mag->data.F32[numGood] = source->psfMag;
+        numGood++;
+    }
+    x->n = numGood;
+    y->n = numGood;
+    mag->n = numGood;
+
+    bool status = pmReadoutFakeFromVectors(readout, numCols, numRows, x, y, mag, xOffset, yOffset, psf,
+                                           minFlux, radius, circularise, normalisePeak);
+    psFree(x);
+    psFree(y);
+    psFree(mag);
+
+    return status;
+}
Index: /branches/pap/psModules/src/camera/pmReadoutFake.h
===================================================================
--- /branches/pap/psModules/src/camera/pmReadoutFake.h	(revision 25027)
+++ /branches/pap/psModules/src/camera/pmReadoutFake.h	(revision 25028)
@@ -12,15 +12,32 @@
 #include <pmPSF.h>
 
+/// Generate a fake readout from vectors of position and magnitude
+bool pmReadoutFakeFromVectors(
+    pmReadout *readout,                   ///< Output readout, or NULL
+    int numCols, int numRows,             ///< Dimension of image
+    const psVector *x, const psVector *y, ///< Coordinates of sources
+    const psVector *mag,                  ///< Magnitudes of sources
+    const psVector *xOffset,              ///< x offsets for sources (source -> img), or NULL
+    const psVector *yOffset,              ///< y offsets for sources (source -> img), or NULL
+    const pmPSF *psf,                     ///< PSF for sources
+    float minFlux,                        ///< Minimum flux to bother about; for setting source radius
+    int radius,                           ///< Fixed radius for sources
+    bool circularise,                     ///< Circularise PSF model?
+    bool normalise                        ///< Normalise the peak value?
+    );
+
+
 /// Generate a fake readout from an array of sources
-bool pmReadoutFakeFromSources(pmReadout *readout, ///< Output readout, or NULL
-                              int numCols, int numRows, ///< Dimension of image
-                              const psArray *sources, ///< Array of pmSource
-                              const psVector *xOffset, ///< x offsets for sources (source -> img), or NULL
-                              const psVector *yOffset, ///< y offsets for sources (source -> img), or NULL
-                              const pmPSF *psf, ///< PSF for sources
-                              float minFlux, ///< Minimum flux to bother about; for setting source radius
-                              int radius, ///< Fixed radius for sources
-                              bool circularise, ///< Circularise PSF model?
-                              bool normalise ///< Normalise the peak value?
+bool pmReadoutFakeFromSources(
+    pmReadout *readout,                 ///< Output readout, or NULL
+    int numCols, int numRows,           ///< Dimension of image
+    const psArray *sources,             ///< Array of pmSource
+    const psVector *xOffset,            ///< x offsets for sources (source -> img), or NULL
+    const psVector *yOffset,            ///< y offsets for sources (source -> img), or NULL
+    const pmPSF *psf,                   ///< PSF for sources
+    float minFlux,                      ///< Minimum flux to bother about; for setting source radius
+    int radius,                         ///< Fixed radius for sources
+    bool circularise,                   ///< Circularise PSF model?
+    bool normalise                      ///< Normalise the peak value?
     );