IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Sep 4, 2008, 9:51:09 PM (18 years ago)
Author:
Paul Price
Message:

Adding capability for a mask to be provided when determining BSCALE,BZERO. This is required for the case when a large masked region of the image has been set to a constant (or close to a constant). If the mask is not provided in this case, then the standard deviation is under-estimated, leading to a choice of BSCALE,BZERO that adversely affects the dynamic range of the image. Added functions psFitsWriteImageWithMask, psFitsUpdateImageWithMask and psFitsInsertImageWithMask, and kept the APIs of psFitsWriteImage, psFitsUpdateImage and psFitsInsertImage so that this change shouldn't break anything.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/fits/psFitsImage.c

    r19270 r19383  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2008-08-29 01:01:39 $
     9 *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2008-09-05 07:51:09 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828#include "psLogMsg.h"
    2929#include "psTrace.h"
    30 #include "psVector.h"
    3130#include "psRandom.h"
     31#include "psImage.h"
    3232#include "psImageStructManip.h"
    3333
    … …  
    249249                                          psFitsFloat *floatType, // Type of custom floating-point
    250250                                          psFits *fits, // FITS file pointer
    251                                           const psImage *image, // Current type
     251                                          const psImage *image, // Image to convert
     252                                          const psImage *mask, // Mask image, or NULL
     253                                          psMaskType maskVal, // Value to mask
    252254                                          psRandom *rng, // Random number generator
    253255                                          bool newScaleZero // Determine a new BSCALE and BZERO?
    … …  
    285287        if (newScaleZero) {
    286288            // Choose an appropriate BSCALE and BZERO
    287             if (!psFitsScaleDetermine(bscale, bzero, blank, image, fits)) {
     289            if (!psFitsScaleDetermine(bscale, bzero, blank, image, mask, maskVal, fits)) {
    288290                // We can't have the write dying for this reason --- try to save it somehow!
    289291                psWarning("Unable to determine BSCALE and BZERO for image --- refusing to quantise.");
    … …  
    404406}
    405407
    406 psImage* psFitsReadImage(const psFits *fits, // the psFits object
     408psImage *psFitsReadImage(const psFits *fits, // the psFits object
    407409                         psRegion region, // the region in the FITS image to read
    408410                         int z          // the z-plane in the FITS image cube to read
    … …  
    445447}
    446448
    447 psImage* psFitsReadImageBuffer(psImage *outImage, // Output image buffer
     449psImage *psFitsReadImageBuffer(psImage *outImage, // Output image buffer
    448450                               const psFits *fits, // the psFits object
    449451                               psRegion region, // the region in the FITS image to read
    … …  
    497499}
    498500
    499 bool psFitsWriteImage(psFits* fits,
    500                       psMetadata* header,
    501                       const psImage* input,
    502                       int numZPlanes,
    503                       const char* extname)
     501bool psFitsWriteImage(psFits *fits, psMetadata *header, const psImage *input,
     502                      int numZPlanes, const char *extname)
     503{
     504    return psFitsWriteImageWithMask(fits, header, input, NULL, 0, numZPlanes, extname);
     505}
     506
     507bool psFitsWriteImageWithMask(psFits *fits, psMetadata *header, const psImage *input,
     508                              const psImage *mask, psMaskType maskVal, int numZPlanes,
     509                              const char *extname)
    504510{
    505511    PS_ASSERT_FITS_NON_NULL(fits, false);
    … …  
    509515
    510516    psFitsMoveLast(fits);
    511     return psFitsInsertImage(fits,header,input,numZPlanes,extname,true);
    512 }
    513 
    514 bool psFitsInsertImage(psFits* fits, psMetadata* header, const psImage* image, int numZPlanes,
    515                        const char* extname, bool after)
     517    return psFitsInsertImageWithMask(fits, header, input, mask, maskVal, numZPlanes, extname, true);
     518}
     519
     520bool psFitsInsertImage(psFits *fits, psMetadata *header, const psImage *image, int numZPlanes,
     521                       const char *extname, bool after)
     522{
     523    return psFitsInsertImageWithMask(fits, header, image, NULL, 0, numZPlanes, extname, after);
     524}
     525
     526bool psFitsInsertImageWithMask(psFits *fits, psMetadata *header, const psImage *image,
     527                               const psImage *mask, psMaskType maskVal, int numZPlanes,
     528                               const char *extname, bool after)
    516529{
    517530    PS_ASSERT_FITS_NON_NULL(fits, false);
    518531    PS_ASSERT_FITS_WRITABLE(fits, false);
    519532    PS_ASSERT_IMAGE_NON_NULL(image, false);
     533    if (mask) {
     534        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
     535        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, false);
     536    }
    520537
    521538    int numCols = image->numCols;       // Number of columns for image
    … …  
    529546    psFitsFloat floatType;              // Custom floating-point convention type
    530547    psImage *diskImage = imageToDiskRepresentation(&bscale, &bzero, &blank, &floatType, fits, image,
    531                                                    NULL, true); // Image to write out
     548                                                   mask, maskVal, NULL, true); // Image to write out
    532549    if (!diskImage) {
    533550        psError(PS_ERR_UNKNOWN, false, "Unable to convert image to desired disk format.");
    … …  
    557574    }
    558575    if (cfitsioBzero != 0.0) {
    559         // p_psFitsTypeToCfitsio and imageToDiskRepresentation must not clash!
    560         psAssert(bzero == 0.0 && bscale == 1.0, "impossible");
     576        psAssert(bzero == 0.0 && bscale == 1.0,
     577                 "p_psFitsTypeToCfitsio and imageToDiskRepresentation must not clash!");
    561578        bscale = 1.0;
    562579        bzero = cfitsioBzero;
    … …  
    564581
    565582    psFitsOptions *options = fits->options; // FITS I/O options
    566     psAssert(!useRequestedScale || !options || bitPix == options->bitpix || options->bitpix == 0, "impossible");
     583    psAssert(!useRequestedScale || !options || bitPix == options->bitpix || options->bitpix == 0,
     584             "Something's not consistent");
    567585
    568586    int naxis = 3;                      // Number of axes
    … …  
    630648        // own quantisation, the correct keyword is always "BLANK" instead of "ZBLANK".
    631649        fits_write_key_lng(fits->fd, "BLANK", blank, "Value for undefined pixels", &status);
     650        // But it seems that cfitsio uses ZBLANK
     651        fits_write_key_lng(fits->fd, "ZBLANK", blank, "Value for undefined pixels", &status);
    632652        fits_set_imgnull(fits->fd, blank, &status);
    633653        if (psFitsError(status, true, "Could not write BLANK header to file.")) {
    … …  
    681701}
    682702
    683 bool psFitsUpdateImage(psFits* fits, const psImage* input, int x0, int y0, int z)
     703bool psFitsUpdateImage(psFits *fits, const psImage *input, int x0, int y0, int z)
     704{
     705    return psFitsUpdateImageWithMask(fits, input, NULL, 0, x0, y0, z);
     706}
     707
     708bool psFitsUpdateImageWithMask(psFits *fits, const psImage *input, const psImage *mask, psMaskType maskVal,
     709                               int x0, int y0, int z)
    684710{
    685711    PS_ASSERT_FITS_NON_NULL(fits, false);
    686712    PS_ASSERT_FITS_WRITABLE(fits, false);
    687713    PS_ASSERT_IMAGE_NON_NULL(input, false);
     714    if (mask) {
     715        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
     716        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, input, false);
     717    }
    688718
    689719    int status = 0;
    … …  
    709739    psFitsFloat floatType;              // Custom floating-point convention type
    710740    psImage *diskImage = imageToDiskRepresentation(&bscale, &bzero, &blank, &floatType, fits, input,
    711                                                    NULL, false); // Image to write out
     741                                                   mask, maskVal, NULL, false); // Image to write out
    712742    if (!diskImage) {
    713743        psError(PS_ERR_UNKNOWN, false, "Unable to convert image to desired disk format.");
    … …  
    737767    }
    738768    if (cfitsioBzero != 0.0) {
    739         // p_psFitsTypeToCfitsio and imageToDiskRepresentation must not clash!
    740         psAssert(bzero == 0.0 && bscale == 1.0, "impossible");
     769        psAssert(bzero == 0.0 && bscale == 1.0,
     770                 "p_psFitsTypeToCfitsio and imageToDiskRepresentation must not clash!");
    741771        bscale = 1.0;
    742772        bzero = cfitsioBzero;
    743773    }
    744774    psFitsOptions *options = fits->options; // FITS I/O options
    745     psAssert(!useRequestedScale || !options || bitPix == options->bitpix || options->bitpix == 0, "impossible");
     775    psAssert(!useRequestedScale || !options || bitPix == options->bitpix || options->bitpix == 0,
     776             "Something's not consistent");
    746777
    747778    // Check to see if the HDU has the same datatype
Note: See TracChangeset for help on using the changeset viewer.