IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 27365


Ignore:
Timestamp:
Mar 19, 2010, 5:09:20 PM (16 years ago)
Author:
Paul Price
Message:

Adding program ppSubConvolve to convolve an image by the (previously calculated) convolution kernel. Made a small change to the API for initialising PSF-matching (pmSubtraction) threads. pmSubtractionMatchPrecalc now does a quick and dirty background subtraction, just like pmSubtractionMatch does. Changed a few functions to allow one of the input readouts to be NULL.

Location:
trunk
Files:
1 added
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippconfig/recipes/filerules-mef.mdc

    r26902 r27365  
    111111PPSUB.REF.VARIANCE      INPUT    @FILES        FPA        VARIANCE
    112112PPSUB.REF.SOURCES       INPUT    @FILES        FPA        CMF
     113PPSUB.INPUT.KERNEL      INPUT    @FILES        FPA        SUBKERNEL
    113114
    114115## files used by ppstack

  • trunk/ippconfig/recipes/filerules-simple.mdc

    r26902 r27365  
    7474PPSUB.REF.VARIANCE      INPUT    @FILES        FPA        VARIANCE
    7575PPSUB.REF.SOURCES       INPUT    @FILES        FPA        CMF
     76PPSUB.INPUT.KERNEL      INPUT    @FILES        FPA        SUBKERNEL
    7677
    7778## files used by ppstack

  • trunk/ippconfig/recipes/filerules-split.mdc

    r27232 r27365  
    8484PPSUB.REF.VARIANCE      INPUT    @FILES        FPA        VARIANCE
    8585PPSUB.REF.SOURCES       INPUT    @FILES        FPA        CMF
     86PPSUB.INPUT.KERNEL      INPUT    @FILES        FPA        SUBKERNEL
    8687
    8788## files used by ppstack

  • trunk/ppStack/src/ppStackMatch.c

    r27332 r27365  
    407407
    408408            if (threads > 0) {
    409                 pmSubtractionThreadsInit(readout, fake);
     409                pmSubtractionThreadsInit();
    410410            }
    411411
    … …  
    423423                    psFree(conv);
    424424                    if (threads > 0) {
    425                         pmSubtractionThreadsFinalize(readout, fake);
     425                        pmSubtractionThreadsFinalize();
    426426                    }
    427427                    return false;
    … …  
    440440                    psFree(widthsCopy);
    441441                    if (threads > 0) {
    442                         pmSubtractionThreadsFinalize(readout, fake);
     442                        pmSubtractionThreadsFinalize();
    443443                    }
    444444                    return false;
    … …  
    458458                    psFree(widthsCopy);
    459459                    if (threads > 0) {
    460                         pmSubtractionThreadsFinalize(readout, fake);
     460                        pmSubtractionThreadsFinalize();
    461461                    }
    462462                    return false;
    … …  
    495495
    496496            if (threads > 0) {
    497                 pmSubtractionThreadsFinalize(readout, fake);
     497                pmSubtractionThreadsFinalize();
    498498            }
    499499

  • trunk/ppSub/src

    • Property svn:ignore

      •  

        old new  
        1313ppSubErrorCodes.c
        1414ppSubVersionDefinitions.h
         15ppSubConvolve

  • trunk/ppSub/src/Makefile.am

    r27109 r27365  
    1 bin_PROGRAMS = ppSub ppSubKernel
     1bin_PROGRAMS = ppSub ppSubKernel ppSubConvolve
    22
    33if HAVE_SVNVERSION
    … …  
    5555        ppSubKernel.c
    5656
     57ppSubConvolve_CPPFLAGS = $(PSLIB_CFLAGS) $(PSMODULE_CFLAGS) $(PPSTATS_CFLAGS) $(PSPHOT_CFLAGS) $(PPSUB_CFLAGS)
     58ppSubConvolve_LDFLAGS  = $(PSLIB_LIBS)   $(PSMODULE_LIBS)   $(PPSTATS_LIBS)   $(PSPHOT_LIBS)   $(PPSUB_LIBS)
     59
     60ppSubConvolve_SOURCES =         \
     61        ppSubConvolve.c         \
     62        ppSubExit.c             \
     63        ppSubVersion.c
     64
    5765noinst_HEADERS = \
    5866        ppSub.h

  • trunk/ppSub/src/ppSubMatchPSFs.c

    r27316 r27365  
    331331    int threads = psMetadataLookupS32(NULL, config->arguments, "-threads"); // Number of threads
    332332    if (threads > 0) {
    333         pmSubtractionThreadsInit(inRO, refRO);
     333        pmSubtractionThreadsInit();
    334334    }
    335335
    … …  
    380380
    381381    psFree(optWidths);
    382     pmSubtractionThreadsFinalize(inRO, refRO);
     382    pmSubtractionThreadsFinalize();
    383383
    384384    if (!success) {

  • trunk/psModules/src/imcombine/pmStackReject.c

    r27322 r27365  
    103103
    104104    if (!pmSubtractionThreaded()) {
    105         pmSubtractionThreadsInit(NULL, NULL);
     105        pmSubtractionThreadsInit();
    106106    }
    107107

  • trunk/psModules/src/imcombine/pmSubtractionMask.c

    r27086 r27365  
    4242                           pmSubtractionMode mode)
    4343{
    44     PM_ASSERT_READOUT_NON_NULL(ro1, NULL);
    45     PM_ASSERT_READOUT_IMAGE(ro1, NULL);
    46     PM_ASSERT_READOUT_MASK(ro1, NULL);
    47     PM_ASSERT_READOUT_NON_NULL(ro2, NULL);
    48     PM_ASSERT_READOUT_IMAGE(ro2, NULL);
    49     PM_ASSERT_READOUT_MASK(ro2, NULL);
    50     PS_ASSERT_IMAGES_SIZE_EQUAL(ro1->image, ro2->image, NULL);
     44    int numCols = 0, numRows = 0;       // Size of the images
     45    if (ro1) {
     46        PM_ASSERT_READOUT_NON_NULL(ro1, NULL);
     47        PM_ASSERT_READOUT_IMAGE(ro1, NULL);
     48        PM_ASSERT_READOUT_MASK(ro1, NULL);
     49        numCols = ro1->image->numCols;
     50        numRows = ro1->image->numRows;
     51            }
     52    if (ro2) {
     53        PM_ASSERT_READOUT_NON_NULL(ro2, NULL);
     54        PM_ASSERT_READOUT_IMAGE(ro2, NULL);
     55        PM_ASSERT_READOUT_MASK(ro2, NULL);
     56        numCols = ro2->image->numCols;
     57        numRows = ro2->image->numRows;
     58    }
     59    if (ro1 && ro2) {
     60        PS_ASSERT_IMAGES_SIZE_EQUAL(ro1->image, ro2->image, NULL);
     61    }
     62    if (!ro1 && !ro2) {
     63        psError(PS_ERR_UNEXPECTED_NULL, true, "No image provided.");
     64        return false;
     65    }
     66    psAssert(numCols > 0 && numRows > 0, "There should be an image provided");
    5167    PS_ASSERT_INT_NONNEGATIVE(size, NULL);
    5268    PS_ASSERT_INT_NONNEGATIVE(footprint, NULL);
    … …  
    5672    }
    5773
    58     int numCols = ro1->image->numCols, numRows = ro1->image->numRows; // Size of the images
    59 
    6074    // Dereference inputs for convenience
    61     psF32 **imageData1 = ro1->image->data.F32, **imageData2 = ro2->image->data.F32;
    62     psImageMaskType **maskData1 = ro1->mask->data.PS_TYPE_IMAGE_MASK_DATA,
    63         **maskData2 = ro2->mask->data.PS_TYPE_IMAGE_MASK_DATA;
     75    psF32 **imageData1 = ro1 ? ro1->image->data.F32 : NULL;
     76    psF32 **imageData2 = ro2 ? ro2->image->data.F32 : NULL;
     77    psImageMaskType **maskData1 = ro1 ? ro1->mask->data.PS_TYPE_IMAGE_MASK_DATA : NULL;
     78    psImageMaskType **maskData2 = ro2 ? ro2->mask->data.PS_TYPE_IMAGE_MASK_DATA : NULL;
    6479
    6580    // First, a pass through to determine the fraction of bad pixels
    … …  
    6984        for (int y = 0; y < numRows; y++) {
    7085            for (int x = 0; x < numCols; x++) {
    71                 if ((maskData1[y][x] & maskVal) || !isfinite(imageData1[y][x])) {
     86                if (ro1 && ((maskData1[y][x] & maskVal) || !isfinite(imageData1[y][x]))) {
    7287                    numBad++;
    7388                    continue;
    7489                }
    75                 if ((maskData2[y][x] & maskVal) || !isfinite(imageData2[y][x])) {
     90                if (ro2 && ((maskData2[y][x] & maskVal) || !isfinite(imageData2[y][x]))) {
    7691                    numBad++;
    7792                    continue;
    … …  
    128143    for (int y = 0; y < numRows; y++) {
    129144        for (int x = 0; x < numCols; x++) {
    130             if (maskData1[y][x] & maskVal) {
     145            if (ro1 && maskData1[y][x] & maskVal) {
    131146                maskData[y][x] |= PM_SUBTRACTION_MASK_BAD_1;
    132147            }
    133             if (maskData2[y][x] & maskVal) {
     148            if (ro2 && maskData2[y][x] & maskVal) {
    134149                maskData[y][x] |= PM_SUBTRACTION_MASK_BAD_2;
    135150            }
    … …  
    144159
    145160    // Pixels that will be bad (or poor) if we convolve with a bad reference pixel
    146     if (!psImageConvolveMask(mask, mask, PM_SUBTRACTION_MASK_BAD_1, PM_SUBTRACTION_MASK_CONVOLVE_1,
    147                              -size, size, -size, size)) {
     161    if (ro1 && !psImageConvolveMask(mask, mask, PM_SUBTRACTION_MASK_BAD_1, PM_SUBTRACTION_MASK_CONVOLVE_1,
     162                                    -size, size, -size, size)) {
    148163        psError(psErrorCodeLast(), false, "Unable to convolve bad pixels from mask 1.");
    149164        psFree(mask);
    150165        return NULL;
    151166    }
    152     if (!psImageConvolveMask(mask, mask, PM_SUBTRACTION_MASK_BAD_2, PM_SUBTRACTION_MASK_CONVOLVE_2,
    153                              -size, size, -size, size)) {
     167    if (ro2 && !psImageConvolveMask(mask, mask, PM_SUBTRACTION_MASK_BAD_2, PM_SUBTRACTION_MASK_CONVOLVE_2,
     168                                    -size, size, -size, size)) {
    154169        psError(psErrorCodeLast(), false, "Unable to convolve bad pixels from mask 2.");
    155170        psFree(mask);
    … …  
    174189        psAbort("Unsupported subtraction mode: %x", mode);
    175190    }
    176     if (!psImageConvolveMask(mask, mask, maskRej, PM_SUBTRACTION_MASK_REJ,
    177                              -footprint, footprint, -footprint, footprint)) {
     191    if (ro1 && ro2 && !psImageConvolveMask(mask, mask, maskRej, PM_SUBTRACTION_MASK_REJ,
     192                                           -footprint, footprint, -footprint, footprint)) {
    178193        psError(psErrorCodeLast(), false, "Unable to convolve bad pixels.");
    179194        psFree(mask);

  • trunk/psModules/src/imcombine/pmSubtractionMatch.c

    r27086 r27365  
    132132    if (subMode != PM_SUBTRACTION_MODE_2) {
    133133        PM_ASSERT_READOUT_NON_NULL(conv1, false);
     134        PM_ASSERT_READOUT_NON_NULL(ro1, false);
     135        PM_ASSERT_READOUT_IMAGE(ro1, false);
    134136        if (conv1->image) {
    135137            psFree(conv1->image);
    … …  
    147149    if (subMode != PM_SUBTRACTION_MODE_1) {
    148150        PM_ASSERT_READOUT_NON_NULL(conv2, false);
     151        PM_ASSERT_READOUT_NON_NULL(ro2, false);
     152        PM_ASSERT_READOUT_IMAGE(ro2, false);
    149153        if (conv2->image) {
    150154            psFree(conv2->image);
    … …  
    161165    }
    162166
    163     PM_ASSERT_READOUT_NON_NULL(ro1, false);
    164     PM_ASSERT_READOUT_NON_NULL(ro2, false);
    165     PM_ASSERT_READOUT_IMAGE(ro1, false);
    166     PM_ASSERT_READOUT_IMAGE(ro2, false);
    167     PS_ASSERT_IMAGES_SIZE_EQUAL(ro1->image, ro2->image, false);
     167    if (ro1 && ro2) {
     168        PS_ASSERT_IMAGES_SIZE_EQUAL(ro1->image, ro2->image, false);
     169    }
    168170    PS_ASSERT_INT_NONNEGATIVE(stride, false);
    169171    if (isfinite(normFrac)) {
    … …  
    379381    }
    380382
     383    int numCols, numRows;       // Size of image
     384    if (ro1) {
     385        numCols = ro1->image->numCols;
     386        numRows = ro1->image->numRows;
     387    } else if (ro2) {
     388        numCols = ro2->image->numCols;
     389        numRows = ro2->image->numRows;
     390    } else {
     391        psAbort("No input image provided.");
     392    }
     393
    381394    pmSubtractionMaskInvalid(ro1, maskVal);
    382395    pmSubtractionMaskInvalid(ro2, maskVal);
     396
     397    // General background subtraction, since this is done in pmSubtractionMatch
     398    {
     399        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
     400        psStats *bg = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); // Statistics for background
     401        if (ro1) {
     402            psStatsInit(bg);
     403            if (!psImageBackground(bg, NULL, ro1->image, ro1->mask, maskVal, rng)) {
     404                psError(PM_ERR_DATA, false, "Unable to measure background statistics.");
     405                psFree(bg);
     406                psFree(rng);
     407                return false;
     408            }
     409            psBinaryOp(ro1->image, ro1->image, "-", psScalarAlloc((float)bg->robustMedian, PS_TYPE_F32));
     410        }
     411        if (ro2) {
     412            psStatsInit(bg);
     413            if (!psImageBackground(bg, NULL, ro2->image, ro2->mask, maskVal, rng)) {
     414                psError(PM_ERR_DATA, false, "Unable to measure background statistics.");
     415                psFree(bg);
     416                psFree(rng);
     417                return false;
     418            }
     419            psBinaryOp(ro2->image, ro2->image, "-", psScalarAlloc((float)bg->robustMedian, PS_TYPE_F32));
     420        }
     421        psFree(bg);
     422        psFree(rng);
     423    }
    383424
    384425    psRegion bounds = psRegionSet(NAN, NAN, NAN, NAN); // Bounds of valid pixels
    … …  
    396437    psMetadata *outHeader = psMetadataAlloc(); // Output header values
    397438
    398     int numCols = ro1->image->numCols, numRows = ro1->image->numRows; // Size of image
    399439    subtractionMatchAlloc(conv1, conv2, ro1, ro2, subMask, maskBad, mode, numCols, numRows);
    400440
    … …  
    404444        psRegion *region = regions->data[i]; // Region of interest
    405445
    406         if (!pmSubtractionAnalysis(outAnalysis, outHeader, kernel, region,
    407                                    ro1->image->numCols, ro1->image->numRows)) {
     446        if (!pmSubtractionAnalysis(outAnalysis, outHeader, kernel, region, numCols, numRows)) {
    408447            psError(psErrorCodeLast(), false, "Unable to generate QA data");
    409448            psFree(outAnalysis);
    … …  
    454493        return false;
    455494    }
     495
     496    // We need both inputs
     497    PM_ASSERT_READOUT_NON_NULL(ro1, false);
     498    PM_ASSERT_READOUT_NON_NULL(ro2, false);
    456499
    457500    PS_ASSERT_INT_NONNEGATIVE(footprint, false);

  • trunk/psModules/src/imcombine/pmSubtractionThreads.c

    r26893 r27365  
    1717}
    1818
    19 // Initialise a mutex in each of the input
    20 static void subtractionMutexInit(pmReadout *ro)
    21 {
    22     if (!ro) {
    23         return;
    24     }
    25 
    26     // XXX if (ro->image) {
    27     // XXX     psMutexInit(ro->image);
    28     // XXX }
    29     // XXX if (ro->variance) {
    30     // XXX     psMutexInit(ro->variance);
    31     // XXX }
    32 
    33     return;
    34 }
    35 
    36 static void subtractionMutexDestroy(pmReadout *ro)
    37 {
    38     if (!ro) {
    39         return;
    40     }
    41 
    42     // XXX if (ro->image) {
    43     // XXX     psMutexDestroy(ro->image);
    44     // XXX }
    45     // XXX if (ro->variance) {
    46     // XXX     psMutexDestroy(ro->variance);
    47     // XXX }
    48 
    49     return;
    50 }
    51 
    52 void pmSubtractionThreadsInit(pmReadout *in1, pmReadout *in2)
     19void pmSubtractionThreadsInit(void)
    5320{
    5421    if (threaded) {
    … …  
    5724
    5825    threaded = true;
    59 
    60     subtractionMutexInit(in1);
    61     subtractionMutexInit(in2);
    6226
    6327    {
    … …  
    8650
    8751
    88 void pmSubtractionThreadsFinalize(pmReadout *in1, pmReadout *in2)
     52void pmSubtractionThreadsFinalize(void)
    8953{
    9054    if (!threaded) {
    … …  
    9761    psThreadTaskRemove("PSMODULES_SUBTRACTION_CONVOLVE");
    9862
    99     subtractionMutexDestroy(in1);
    100     subtractionMutexDestroy(in1);
    10163    return;
    10264}

  • trunk/psModules/src/imcombine/pmSubtractionThreads.h

    r19340 r27365  
    77/// Set up threading for image matching
    88///
    9 /// Sets up thread tasks, and initialises mutexes in readouts
    10 void pmSubtractionThreadsInit(pmReadout *in1, pmReadout *in2 // Input readouts
    11     );
     9/// Sets up thread tasks
     10void pmSubtractionThreadsInit(void);
    1211
    1312
    1413/// Take down threading for image matching
    1514///
    16 /// Destroys thread tasks, and initialises mutexes in readouts
    17 void pmSubtractionThreadsFinalize(pmReadout *in1, pmReadout *in2);
     15/// Destroys thread tasks
     16void pmSubtractionThreadsFinalize(void);
    1817
    1918#endif
Note: See TracChangeset for help on using the changeset viewer.