Index: trunk/psModules/test/objects/tap_pmSource.c =================================================================== --- trunk/psModules/test/objects/tap_pmSource.c (revision 15726) +++ trunk/psModules/test/objects/tap_pmSource.c (revision 15985) @@ -7,23 +7,24 @@ /* Tested: - pmSourceAlloc() - psMemCheckSource() - pmSourceCopy() - pmSourceDefinePixels() - pmSourceRedefinePixels() - pmSourcePSFClump() - pmSourceGetModel() -Must Test: - pmSourceFreePixels() - pmSourceTest() - pmSourceRoughClass() - pmSourceMoments() - pmSourceAdd() - pmSourceSub() - pmSourceAddWithOffset() - pmSourceSubWithOffset() - pmSourceOp() - pmSourceCacheModel() - pmSourceCachePSF() + Tested + pmSourceAlloc() + pmSourceCopy() + pmSourceDefinePixels() + pmSourceRedefinePixels() + pmSourcePSFClump() + pmSourceGetModel() + pmSourceAdd() + pmSourceSub() + pmSourceAddWithOffset() + pmSourceSubWithOffset() + pmSourceOp() + pmSourceCacheModel() + pmSourceCachePSF() + pmSourceSortBySN() (COMPILER ERRORS) + pmSourceSortByY() (COMPILER ERRORS) + Must test + pmSourceMoments() + pmSourceRoughClass() + */ @@ -32,8 +33,9 @@ #define MISC_NAME "META00" #define NUM_BIAS_DATA 10 -#define TEST_NUM_ROWS (8+1) -#define TEST_NUM_COLS (8+1) +#define TEST_NUM_ROWS (4+1) +#define TEST_NUM_COLS (4+1) #define VERBOSE 0 #define ERR_TRACE_LEVEL 0 +#define TEST_FLOATS_EQUAL(X, Y) (abs(X - Y) < 0.01) /****************************************************************************** @@ -63,5 +65,5 @@ psLogSetLevel(PS_LOG_INFO); psTraceSetLevel("err", ERR_TRACE_LEVEL); - plan_tests(1); + plan_tests(128); // ---------------------------------------------------------------------- @@ -494,6 +496,6 @@ psFree(src); ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } // Call pmSourceGetModel() with acceptable input parameters @@ -534,5 +536,4 @@ ok(false == isPDF, "pmSourceGetModel() set isPDF to FALSE"); - src->modelPSF = NULL; src->modelConv = NULL; @@ -558,3 +559,280 @@ } + + // call pmSourceOp() with acceptable parameters + // We only test with a single Gaussian model, with no residuals or masks. + // For completeness, additional tests should be added. + // We should also set mode &= PM_MODEL_OP_NOISE to test that the src->weights are added. + { + psMemId id = psMemGetId(); + pmSource *src = pmSourceAlloc(); + src->pixels = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (int i = 0 ; i < TEST_NUM_ROWS ; i++) { + for (int j = 0 ; j < TEST_NUM_COLS ; j++) { + src->pixels->data.F32[i][j] = 0.0; + } + } + src->peak = pmPeakAlloc(TEST_NUM_COLS/2, TEST_NUM_ROWS/2, 5.0, PM_PEAK_LONE); + src->type = PM_SOURCE_TYPE_STAR; + src->modelPSF = pmModelAlloc(pmModelClassGetType("PS_MODEL_GAUSS")); + psF32 *PAR = src->modelPSF->params->data.F32; + PAR[PM_PAR_I0] = 5.0; + PAR[PM_PAR_XPOS] = 0.0; + PAR[PM_PAR_YPOS] = 0.0; + PAR[PM_PAR_XPOS] = (float) (TEST_NUM_COLS/2); + PAR[PM_PAR_YPOS] = (float) (TEST_NUM_ROWS/2); + PAR[PM_PAR_SXX] = 10.0; + PAR[PM_PAR_SYY] = 10.0; + + bool rc = pmSourceOp(src, PM_SOURCE_MODE_PSFMODEL, true, 0, 0, 0); + ok(rc == true, "pmSourceOp() returned TRUE with acceptable input parameters"); + psVector *x = psVectorAlloc(2, PS_TYPE_F32); + bool errorFlag = false; + for (int i = 0 ; i < TEST_NUM_ROWS ; i++) { + for (int j = 0 ; j < TEST_NUM_COLS ; j++) { + x->data.F32[0] = (float) j; + x->data.F32[1] = (float) i; + psF32 modF = src->modelPSF->modelFunc (NULL, src->modelPSF->params, x); + psF32 imgF = src->pixels->data.F32[i][j]; + if (!TEST_FLOATS_EQUAL(modF, imgF)) { + diag("ERROR: src->pixels[%d][%d] is %.2f, should be %.2f", i, j, src->pixels->data.F32[i][j], modF); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmSourceOp() set the image pixels correctly (PSF function)"); + psFree(x); + psFree(src); + pmModelClassCleanup(); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // call pmSourceOp() with acceptable parameters + // Test source->modelFlux + // We should also set mode &= PM_MODEL_OP_NOISE to test that the src->weights are added. + { + psMemId id = psMemGetId(); + pmSource *src = pmSourceAlloc(); + src->pixels = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + src->modelFlux = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (int i = 0 ; i < TEST_NUM_ROWS ; i++) { + for (int j = 0 ; j < TEST_NUM_COLS ; j++) { + src->pixels->data.F32[i][j] = 0.0; + src->modelFlux->data.F32[i][j] = (float) (i + j); + } + } + src->peak = pmPeakAlloc(TEST_NUM_COLS/2, TEST_NUM_ROWS/2, 5.0, PM_PEAK_LONE); + src->type = PM_SOURCE_TYPE_STAR; + src->modelPSF = pmModelAlloc(pmModelClassGetType("PS_MODEL_GAUSS")); + psF32 *PAR = src->modelPSF->params->data.F32; + PAR[PM_PAR_I0] = 1.0; + PAR[PM_PAR_XPOS] = 0.0; + PAR[PM_PAR_YPOS] = 0.0; + PAR[PM_PAR_XPOS] = (float) (TEST_NUM_COLS/2); + PAR[PM_PAR_YPOS] = (float) (TEST_NUM_ROWS/2); + PAR[PM_PAR_SXX] = 10.0; + PAR[PM_PAR_SYY] = 10.0; + + bool rc = pmSourceOp(src, PM_SOURCE_MODE_PSFMODEL, true, 0, 0, 0); + ok(rc == true, "pmSourceOp() returned TRUE with acceptable input parameters"); + psVector *x = psVectorAlloc(2, PS_TYPE_F32); + bool errorFlag = false; + for (int i = 0 ; i < TEST_NUM_ROWS ; i++) { + for (int j = 0 ; j < TEST_NUM_COLS ; j++) { + x->data.F32[0] = (float) j; + x->data.F32[1] = (float) i; + psF32 modF = src->modelFlux->data.F32[i][j]; + psF32 imgF = src->pixels->data.F32[i][j]; + if (!TEST_FLOATS_EQUAL(modF, imgF)) { + diag("ERROR: src->pixels[%d][%d] is %.2f, should be %.2f", i, j, src->pixels->data.F32[i][j], modF); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmSourceOp() set the image pixels correctly (src->modelFlux cache image)"); + psFree(x); + psFree(src); + pmModelClassCleanup(); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmSourceCacheModel() tests + // call pmSourceCacheModel() with NULL pmSource input parameter + { + psMemId id = psMemGetId(); + bool rc = pmSourceCacheModel(NULL, 0); + ok(rc == false, "pmSourceCacheModel() returned FALSE with NULL pmSource input parameter"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmSourceCacheModel() tests + // bool pmSourceCacheModel (pmSource *source, psMaskType maskVal) { + // call pmSourceCacheModel() with acceptable parameters + { + psMemId id = psMemGetId(); + pmSource *src = pmSourceAlloc(); + src->pixels = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (int i = 0 ; i < TEST_NUM_ROWS ; i++) { + for (int j = 0 ; j < TEST_NUM_COLS ; j++) { + src->pixels->data.F32[i][j] = 0.0; + } + } + src->peak = pmPeakAlloc(TEST_NUM_COLS/2, TEST_NUM_ROWS/2, 5.0, PM_PEAK_LONE); + src->type = PM_SOURCE_TYPE_STAR; + src->modelPSF = pmModelAlloc(pmModelClassGetType("PS_MODEL_GAUSS")); + psF32 *PAR = src->modelPSF->params->data.F32; + PAR[PM_PAR_I0] = 1.0; + PAR[PM_PAR_XPOS] = 0.0; + PAR[PM_PAR_YPOS] = 0.0; + PAR[PM_PAR_XPOS] = (float) (TEST_NUM_COLS/2); + PAR[PM_PAR_YPOS] = (float) (TEST_NUM_ROWS/2); + PAR[PM_PAR_SXX] = 10.0; + PAR[PM_PAR_SYY] = 10.0; + + bool rc = pmSourceCacheModel(src, 0); + ok(rc == true, "pmSourceCacheModel() returned TRUE with acceptable input parameters"); + + psVector *x = psVectorAlloc(2, PS_TYPE_F32); + bool errorFlag = false; + for (int i = 0 ; i < TEST_NUM_ROWS ; i++) { + for (int j = 0 ; j < TEST_NUM_COLS ; j++) { + x->data.F32[0] = (float) j; + x->data.F32[1] = (float) i; + psF32 modF = src->modelPSF->modelFunc (NULL, src->modelPSF->params, x); + psF32 imgF = src->modelFlux->data.F32[i][j]; + if (!TEST_FLOATS_EQUAL(modF, imgF)) { + diag("ERROR: src->modelFlux[%d][%d] is %.2f, should be %.2f", i, j, src->modelFlux->data.F32[i][j], modF); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmSourceCacheModel() set the src->modelFlux correctly (PSF function)"); + psFree(x); + psFree(src); + pmModelClassCleanup(); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmSourceCachePSF() tests + // bool pmSourceCachePSF (pmSource *source, psMaskType maskVal) { + // call pmSourceCachePSF() with NULL pmSource input parameter + { + psMemId id = psMemGetId(); + bool rc = pmSourceCachePSF(NULL, 0); + ok(rc == false, "pmSourceCachePSF() returned FALSE with NULL pmSource input parameter"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // call pmSourceCachePSF() with acceptable parameters + { + psMemId id = psMemGetId(); + pmSource *src = pmSourceAlloc(); + src->pixels = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (int i = 0 ; i < TEST_NUM_ROWS ; i++) { + for (int j = 0 ; j < TEST_NUM_COLS ; j++) { + src->pixels->data.F32[i][j] = 0.0; + } + } + src->peak = pmPeakAlloc(TEST_NUM_COLS/2, TEST_NUM_ROWS/2, 5.0, PM_PEAK_LONE); + src->type = PM_SOURCE_TYPE_STAR; + src->modelPSF = pmModelAlloc(pmModelClassGetType("PS_MODEL_GAUSS")); + psF32 *PAR = src->modelPSF->params->data.F32; + PAR[PM_PAR_I0] = 1.0; + PAR[PM_PAR_XPOS] = 0.0; + PAR[PM_PAR_YPOS] = 0.0; + PAR[PM_PAR_XPOS] = (float) (TEST_NUM_COLS/2); + PAR[PM_PAR_YPOS] = (float) (TEST_NUM_ROWS/2); + PAR[PM_PAR_SXX] = 10.0; + PAR[PM_PAR_SYY] = 10.0; + + bool rc = pmSourceCachePSF(src, 0); + ok(rc == true, "pmSourceCachePSF() returned TRUE with acceptable input parameters"); + + psVector *x = psVectorAlloc(2, PS_TYPE_F32); + bool errorFlag = false; + for (int i = 0 ; i < TEST_NUM_ROWS ; i++) { + for (int j = 0 ; j < TEST_NUM_COLS ; j++) { + x->data.F32[0] = (float) j; + x->data.F32[1] = (float) i; + psF32 modF = src->modelPSF->modelFunc (NULL, src->modelPSF->params, x); + psF32 imgF = src->psfFlux->data.F32[i][j]; + if (!TEST_FLOATS_EQUAL(modF, imgF)) { + diag("ERROR: src->psfFlux[%d][%d] is %.2f, should be %.2f", i, j, src->psfFlux->data.F32[i][j], modF); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmSourceCachePSF() set the src->psfFlux correctly (PSF function)"); + psFree(x); + psFree(src); + pmModelClassCleanup(); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------- + // pmSourceSortBySN() tests + // int pmSourceSortBySN (const void **a, const void **b) + // Call pmSourceSortBySN() with acceptable input parameters. + // XXX: We don't test with NULL input parameters since this function has no PS_ASSERTS to protect + // against that. +/* XXXX: Compiler errors: fix this + { + psMemId id = psMemGetId(); + pmSource *src1 = pmSourceAlloc(); + src1->peak = pmPeakAlloc(3, 4, 2.0, PM_PEAK_LONE); + src1->peak->SN = 10.0; + pmSource *src2 = pmSourceAlloc(); + src2->peak = pmPeakAlloc(3, 4, 2.0, PM_PEAK_LONE); + src2->peak->SN = 20.0; + + int rc = pmSourceSortBySN((const void **) &src1, (const void **) &src2); + ok(rc == 1, "pmSourceSortBySN() returned correct result (source1 < source2) (%d)", rc); + rc = pmSourceSortBySN((const void **) &src2, (const void **) &src1); + ok(rc == -1, "pmSourceSortBySN() returned correct result (source2 < source1) (%d)", rc); + rc = pmSourceSortBySN((const void **) &src1, (const void **) &src1); + ok(rc == 0, "pmSourceSortBySN() returned correct result (source1 == source2) (%d)", rc); + + psFree(src1); + psFree(src2); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------- + // pmSourceSortByY() tests + // int pmSourceSortByY (const void **a, const void **b) + // Call pmSourceSortByY() with acceptable input parameters. + // XXX: We don't test with NULL input parameters since this function has no PS_ASSERTS to protect + // against that. + { + psMemId id = psMemGetId(); + pmSource *src1 = pmSourceAlloc(); + src1->peak = pmPeakAlloc(3, 4, 2.0, PM_PEAK_LONE); + src1->peak->y = 10.0; + pmSource *src2 = pmSourceAlloc(); + src2->peak = pmPeakAlloc(3, 4, 2.0, PM_PEAK_LONE); + src2->peak->y = 20.0; + + int rc = pmSourceSortByY((const void **) &src1, (const void **) &src2); + ok(rc == -1, "pmSourceSortByY() returned correct result (source1 < source2) (%d)", rc); + rc = pmSourceSortByY((const void **) &src2, (const void **) &src1); + ok(rc == 1, "pmSourceSortByY() returned correct result (source2 < source1) (%d)", rc); + rc = pmSourceSortByY((const void **) &src1, (const void **) &src1); + ok(rc == 0, "pmSourceSortByY() returned correct result (source1 == source2) (%d)", rc); + + psFree(src1); + psFree(src2); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +*/ + }