IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 28796


Ignore:
Timestamp:
Jul 30, 2010, 9:38:40 AM (16 years ago)
Author:
eugene
Message:

updates from trunk

Location:
branches/eam_branches/ipp-20100621/psModules
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20100621/psModules

  • branches/eam_branches/ipp-20100621/psModules/src/concepts/pmConcepts.c

    r26971 r28796  
    350350        conceptRegisterS32("CHIP.YSIZE", "Size of chip (pixels)", NULL, NULL, NULL, true, PM_FPA_LEVEL_CHIP);
    351351        conceptRegisterF32("CHIP.TEMP", "Temperature of chip", NULL, NULL, NULL, false, PM_FPA_LEVEL_CHIP);
     352        conceptRegisterF32("CHIP.TEMPERATURE", "Temperature of chip", NULL, NULL, NULL, false, PM_FPA_LEVEL_CHIP);
    352353        conceptRegisterStr("CHIP.ID", "Chip identifier", NULL, NULL, NULL, false, PM_FPA_LEVEL_CHIP);
    353354        conceptRegisterF32("CHIP.SEEING", "Seeing FWHM (pixels)", NULL, NULL, NULL, false, PM_FPA_LEVEL_CHIP);

  • branches/eam_branches/ipp-20100621/psModules/src/concepts/pmConceptsStandard.c

    r25930 r28796  
    449449            int big, medium;
    450450            float small;
     451            bool negative =  *((char *)concept->data.V) == '-'; // check for sign explicitly since -0 is not less than 0
     452
    451453            // XXX: Upgrade path is to allow dd:mm.mmm
    452454            if (sscanf(concept->data.V, "%d:%d:%f", &big, &medium, &small) != 3 &&
    … …  
    457459            }
    458460            coords = abs(big) + (float)medium/60.0 + small/3600.0;
    459             if (big < 0)
     461            if (negative)
    460462            {
    461463                coords *= -1.0;

  • branches/eam_branches/ipp-20100621/psModules/src/extras/ippStages.c

    r24881 r28796  
    1515    } else if (!strcmp(stageString, "chip")) {
    1616        return IPP_STAGE_CHIP;
     17    } else if (!strcmp(stageString, "chip_bg")) {
     18        return IPP_STAGE_CHIP_BG;
    1719    } else if (!strcmp(stageString, "camera")) {
    1820        return IPP_STAGE_CAMERA;
    1921    } else if (!strcmp(stageString, "warp")) {
    2022        return IPP_STAGE_WARP;
     23    } else if (!strcmp(stageString, "warp_bg")) {
     24        return IPP_STAGE_WARP_BG;
    2125    } else if (!strcmp(stageString, "fake")) {
    2226        return IPP_STAGE_FAKE;

  • branches/eam_branches/ipp-20100621/psModules/src/extras/ippStages.h

    r27750 r28796  
    1313    IPP_STAGE_RAW = 0,
    1414    IPP_STAGE_CHIP,
     15    IPP_STAGE_CHIP_BG,
    1516    IPP_STAGE_CAMERA,
    1617    IPP_STAGE_FAKE,
    1718    IPP_STAGE_WARP,
     19    IPP_STAGE_WARP_BG,
    1820    IPP_STAGE_DIFF,
    1921    IPP_STAGE_STACK,

  • branches/eam_branches/ipp-20100621/psModules/src/imcombine/pmSubtraction.c

    r28405 r28796  
    5252
    5353    // Take the square of the normal kernel
    54     double sumVariance = 0.0; // Sum of the variance kernels
    5554    for (int v = yMin; v <= yMax; v++) {
    5655        for (int u = xMin; u <= xMax; u++) {
    57             sumVariance += out->kernel[v][u] = PS_SQR(normalKernel->kernel[v][u]);
    58         }
    59     }
    60 
    61     // Normalise so that the sum of the variance kernel is the square of the sum of the normal kernel
    62     // This is required to keep the relative scaling between the image and the variance map
    63     psBinaryOp(out->image, out->image, "*", psScalarAlloc(1.0 / sumVariance, PS_TYPE_F32));
    64 
     56            out->kernel[v][u] = PS_SQR(normalKernel->kernel[v][u]);
     57        }
     58    }
    6559    return out;
    6660}
    … …  
    271265// Convolve an image using FFT
    272266static void convolveVarianceFFT(psImage *target,// Place the result in here
    273                               psImage *variance, // Variance map to convolve
    274                               psImage *kernelErr, // Kernel error image
    275                               psImage *mask, // Mask image
    276                               psImageMaskType maskVal, // Value to mask
    277                               const psKernel *kernel, // Kernel by which to convolve
    278                               psRegion region,// Region of interest
    279                               int size        // Size of (square) kernel
    280                               )
     267                                psImage *variance, // Variance map to convolve
     268                                psImage *kernelErr, // Kernel error image
     269                                psImage *mask, // Mask image
     270                                psImageMaskType maskVal, // Value to mask
     271                                const psKernel *kernel, // Kernel by which to convolve
     272                                psRegion region,// Region of interest
     273                                int size        // Size of (square) kernel
     274                                )
    281275{
    282276    psRegion border = psRegionSet(region.x0 - size, region.x1 + size,
    … …  
    348342                                  psImage *image, // Image to convolve
    349343                                  psImage *variance, // Variance map to convolve, or NULL
     344                                  const psKernel *covar,               // Covariance, or NULL
    350345                                  psImage *kernelErr, // Kernel error image, or NULL
    351346                                  psImage *subMask, // Subtraction mask
    … …  
    393388        if (variance) {
    394389            convolveDirect(convVariance, variance, *kernelVariance, region, 0.0, kernels->size);
     390        }
     391    }
     392
     393    if (variance && covar) {
     394        // Apply covariance factor to variance map, to allow for spatial variation
     395        float factor = psImageCovarianceCalculateFactor(*kernelImage, covar); // Factor to apply
     396        for (int y = region.y0; y < region.y1; y++) {
     397            for (int x = region.x0; x < region.x1; x++) {
     398                convVariance->data.F32[y][x] *= factor;
     399            }
    395400        }
    396401    }
    … …  
    10851090    if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    10861091        convolveRegion(out1->image, out1->variance, out1->mask, &kernelImage, &kernelVariance,
    1087                        ro1->image, ro1->variance, kernelErr1, subMask, kernels, polyValues, background,
    1088                        *region, maskBad, maskPoor, poorFrac, useFFT, false);
     1092                       ro1->image, ro1->variance, ro1->covariance, kernelErr1, subMask, kernels,
     1093                       polyValues, background, *region, maskBad, maskPoor, poorFrac, useFFT, false);
    10891094    }
    10901095    if (kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    10911096        convolveRegion(out2->image, out2->variance, out2->mask, &kernelImage, &kernelVariance,
    1092                        ro2->image, ro2->variance, kernelErr2, subMask, kernels, polyValues, background,
    1093                        *region, maskBad, maskPoor, poorFrac, useFFT,
     1097                       ro2->image, ro2->variance, ro2->covariance, kernelErr2, subMask, kernels,
     1098                       polyValues, background, *region, maskBad, maskPoor, poorFrac, useFFT,
    10941099                       kernels->mode == PM_SUBTRACTION_MODE_DUAL);
    10951100    }
    … …  
    13251330
    13261331    // Calculate covariances
    1327     // This can be fairly involved, so we only do it for a single instance
    1328     // Enable threads for covariance calculation, since we're not threading on top of it.
     1332    // This can be fairly involved, so we only do it for a small number of instances
    13291333    float position[NUM_COVAR_POS] = { -1.0, -0.5, 0.0, +0.5, +1.0 }; // Positions for covariance calculations
     1334    // Enable threads for covariance calculation, since we're not threading on top of it
    13301335    oldThreads = psImageCovarianceSetThreads(true);
    13311336    if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    … …  
    13421347        out1->covariance = psImageCovarianceAverage(covars);
    13431348        psFree(covars);
     1349        // Remove covariance factor from covariance, since we've put it in the variance map already
     1350        float factor = psImageCovarianceFactor(out1->covariance);
     1351        psBinaryOp(out1->covariance->image, out1->covariance->image, "/", psScalarAlloc(factor, PS_TYPE_F32));
    13441352    }
    13451353    if (kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    … …  
    13561364        out2->covariance = psImageCovarianceAverage(covars);
    13571365        psFree(covars);
     1366        // Remove covariance factor from covariance, since we've put it in the variance map already
     1367        float factor = psImageCovarianceFactor(out2->covariance);
     1368        psBinaryOp(out2->covariance->image, out2->covariance->image, "/", psScalarAlloc(factor, PS_TYPE_F32));
    13581369    }
    13591370    psImageCovarianceSetThreads(oldThreads);

  • branches/eam_branches/ipp-20100621/psModules/src/objects/pmPSF_IO.c

    r28643 r28796  
    191191    pmReadout *ro = pmFPAviewThisReadout(roView, chip->parent); // Readout with analysis data
    192192    psFree(roView);
    193     PM_ASSERT_READOUT_NON_NULL(ro, false);
    194 
    195     if (!pmPSFmodelWrite(chip->analysis, ro->analysis, view, file, config)) {
     193
     194    if (!pmPSFmodelWrite(chip->analysis, ro ? ro->analysis : NULL, view, file, config)) {
    196195        psError(psErrorCodeLast(), false, "Failed to write PSF for chip");
    197196        return false;
    … …  
    222221    }
    223222    if (!roAnalysis) {
    224         psError(PM_ERR_PROG, true, "No analysis metadata for readout.");
    225         return false;
     223        psWarning("No analysis metadata for PSF, clump parameters cannot be saved.");
    226224    }
    227225
    … …  
    369367
    370368        // we now save clump parameters for each region : need to save all of those
    371         int nRegions = psMetadataLookupS32 (&status, roAnalysis, "PSF.CLUMP.NREGIONS");
    372         psMetadataAddS32 (header, PS_LIST_TAIL, "PSF_CLN", PS_META_REPLACE, "number of psf clump regions", nRegions);
    373         for (int i = 0; i < nRegions; i++) {
    374             char regionName[64];
    375             snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", i);
    376             psMetadata *regionMD = psMetadataLookupPtr (&status, roAnalysis, regionName);
    377 
    378             psfClump.X  = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X");   assert (status);
    379             psfClump.Y  = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y");   assert (status);
    380             psfClump.dX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX");  assert (status);
    381             psfClump.dY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY");  assert (status);
    382 
    383             char key[16];
    384             snprintf (key, 9, "CLX_%03d", i);
    385             psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump center", psfClump.X);
    386             snprintf (key, 9, "CLY_%03d", i);
    387             psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump center", psfClump.Y);
    388             snprintf (key, 9, "CLDX_%03d", i);
    389             psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump size", psfClump.dX);
    390             snprintf (key, 9, "CLDY_%03d", i);
    391             psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump size", psfClump.dY);
     369        if (roAnalysis) {
     370            int nRegions = psMetadataLookupS32 (&status, roAnalysis, "PSF.CLUMP.NREGIONS");
     371            psMetadataAddS32 (header, PS_LIST_TAIL, "PSF_CLN", PS_META_REPLACE, "number of psf clump regions", nRegions);
     372            for (int i = 0; i < nRegions; i++) {
     373                char regionName[64];
     374                snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", i);
     375                psMetadata *regionMD = psMetadataLookupPtr (&status, roAnalysis, regionName);
     376
     377                psfClump.X  = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X");   assert (status);
     378                psfClump.Y  = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y");   assert (status);
     379                psfClump.dX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX");  assert (status);
     380                psfClump.dY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY");  assert (status);
     381
     382                char key[16];
     383                snprintf (key, 9, "CLX_%03d", i);
     384                psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump center", psfClump.X);
     385                snprintf (key, 9, "CLY_%03d", i);
     386                psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump center", psfClump.Y);
     387                snprintf (key, 9, "CLDX_%03d", i);
     388                psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump size", psfClump.dX);
     389                snprintf (key, 9, "CLDY_%03d", i);
     390                psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump size", psfClump.dY);
     391            }
    392392        }
    393393
    … …  
    787787{
    788788    PS_ASSERT_METADATA_NON_NULL(chipAnalysis, false);
    789     PS_ASSERT_METADATA_NON_NULL(roAnalysis, false);
    790789    PS_ASSERT_PTR_NON_NULL(view, false);
    791790    PS_ASSERT_PTR_NON_NULL(file, false);
    … …  
    852851
    853852    // read the psf clump data for each region
    854     int nRegions = psMetadataLookupS32 (&status, header, "PSF_CLN");
    855     if (!status) {
    856         // read old-style psf clump data
    857 
    858         char regionName[64];
    859         snprintf (regionName, 64, "PSF.CLUMP.REGION.000");
    860         psMetadataAddS32 (roAnalysis, PS_LIST_TAIL, "PSF.CLUMP.NREGIONS",  PS_META_REPLACE, "psf clump regions", 1);
    861 
    862         psMetadata *regionMD = psMetadataLookupPtr (&status, roAnalysis, regionName);
    863         if (!regionMD) {
    864             regionMD = psMetadataAlloc();
    865             psMetadataAddMetadata (roAnalysis, PS_LIST_TAIL, regionName, PS_META_REPLACE, "psf clump region", regionMD);
    866             psFree (regionMD);
    867         }
    868 
    869         // psf clump data
    870         pmPSFClump psfClump;
    871 
    872         psfClump.X  = psMetadataLookupF32 (&status, header, "PSF_CLX" );  assert(status);
    873         psfClump.Y  = psMetadataLookupF32 (&status, header, "PSF_CLY" );  assert(status);
    874         psfClump.dX = psMetadataLookupF32 (&status, header, "PSF_CLDX");  assert(status);
    875         psfClump.dY = psMetadataLookupF32 (&status, header, "PSF_CLDY");  assert(status);
    876 
    877         psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.X",  PS_META_REPLACE, "psf clump center", psfClump.X);
    878         psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.Y",  PS_META_REPLACE, "psf clump center", psfClump.Y);
    879         psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DX", PS_META_REPLACE, "psf clump center", psfClump.dX);
    880         psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DY", PS_META_REPLACE, "psf clump center", psfClump.dY);
    881     } else {
    882         psMetadataAddS32 (roAnalysis, PS_LIST_TAIL, "PSF.CLUMP.NREGIONS",  PS_META_REPLACE, "psf clump regions", nRegions);
    883 
    884         for (int i = 0; i < nRegions; i++) {
    885             char key[10];
     853    if (roAnalysis) {
     854        int nRegions = psMetadataLookupS32 (&status, header, "PSF_CLN");
     855        if (!status) {
     856            // read old-style psf clump data
     857
    886858            char regionName[64];
    887             snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", i);
     859            snprintf (regionName, 64, "PSF.CLUMP.REGION.000");
     860            psMetadataAddS32 (roAnalysis, PS_LIST_TAIL, "PSF.CLUMP.NREGIONS",  PS_META_REPLACE, "psf clump regions", 1);
    888861
    889862            psMetadata *regionMD = psMetadataLookupPtr (&status, roAnalysis, regionName);
    … …  
    897870            pmPSFClump psfClump;
    898871
    899             snprintf (key, 9, "CLX_%03d", i);
    900             psfClump.X  = psMetadataLookupF32 (&status, header, key);  assert(status);
    901             snprintf (key, 9, "CLY_%03d", i);
    902             psfClump.Y  = psMetadataLookupF32 (&status, header, key);  assert(status);
    903             snprintf (key, 9, "CLDX_%03d", i);
    904             psfClump.dX = psMetadataLookupF32 (&status, header, key);  assert(status);
    905             snprintf (key, 9, "CLDY_%03d", i);
    906             psfClump.dY = psMetadataLookupF32 (&status, header, key);  assert(status);
     872            psfClump.X  = psMetadataLookupF32 (&status, header, "PSF_CLX" );  assert(status);
     873            psfClump.Y  = psMetadataLookupF32 (&status, header, "PSF_CLY" );  assert(status);
     874            psfClump.dX = psMetadataLookupF32 (&status, header, "PSF_CLDX");  assert(status);
     875            psfClump.dY = psMetadataLookupF32 (&status, header, "PSF_CLDY");  assert(status);
    907876
    908877            psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.X",  PS_META_REPLACE, "psf clump center", psfClump.X);
    … …  
    910879            psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DX", PS_META_REPLACE, "psf clump center", psfClump.dX);
    911880            psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DY", PS_META_REPLACE, "psf clump center", psfClump.dY);
     881        } else {
     882            psMetadataAddS32 (roAnalysis, PS_LIST_TAIL, "PSF.CLUMP.NREGIONS",  PS_META_REPLACE, "psf clump regions", nRegions);
     883
     884            for (int i = 0; i < nRegions; i++) {
     885                char key[10];
     886                char regionName[64];
     887                snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", i);
     888
     889                psMetadata *regionMD = psMetadataLookupPtr (&status, roAnalysis, regionName);
     890                if (!regionMD) {
     891                    regionMD = psMetadataAlloc();
     892                    psMetadataAddMetadata (roAnalysis, PS_LIST_TAIL, regionName, PS_META_REPLACE, "psf clump region", regionMD);
     893                    psFree (regionMD);
     894                }
     895
     896                // psf clump data
     897                pmPSFClump psfClump;
     898
     899                snprintf (key, 9, "CLX_%03d", i);
     900                psfClump.X  = psMetadataLookupF32 (&status, header, key);  assert(status);
     901                snprintf (key, 9, "CLY_%03d", i);
     902                psfClump.Y  = psMetadataLookupF32 (&status, header, key);  assert(status);
     903                snprintf (key, 9, "CLDX_%03d", i);
     904                psfClump.dX = psMetadataLookupF32 (&status, header, key);  assert(status);
     905                snprintf (key, 9, "CLDY_%03d", i);
     906                psfClump.dY = psMetadataLookupF32 (&status, header, key);  assert(status);
     907
     908                psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.X",  PS_META_REPLACE, "psf clump center", psfClump.X);
     909                psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.Y",  PS_META_REPLACE, "psf clump center", psfClump.Y);
     910                psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DX", PS_META_REPLACE, "psf clump center", psfClump.dX);
     911                psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DY", PS_META_REPLACE, "psf clump center", psfClump.dY);
     912            }
    912913        }
    913914    }

  • branches/eam_branches/ipp-20100621/psModules/src/objects/pmSourceMatch.c

    r28643 r28796  
    249249            }
    250250
     251            numMaster = size;
    251252            xMaster->n = size;
    252253            yMaster->n = size;

  • branches/eam_branches/ipp-20100621/psModules/src/objects/pmSourcePhotometry.c

    r28692 r28796  
    409409    psImage *mask     = source->maskObj;
    410410
     411    if (!flux || !variance || !mask) {
     412        return false;
     413    }
     414
    411415    for (int iy = 0; iy < flux->numRows; iy++) {
    412416        for (int ix = 0; ix < flux->numCols; ix++) {
Note: See TracChangeset for help on using the changeset viewer.