lsst::afw::fits::ImageWriteOptions Struct Reference

Options for writing an image to FITS. More...

#include <fits.h>

Public Member Functions
template<typename T>
	ImageWriteOptions (image::Image< T > const &image)
	Construct with default options for images.
template<typename T>
	ImageWriteOptions (image::Mask< T > const &mask)
	Construct with default options for masks.
	ImageWriteOptions (ImageCompressionOptions const &compression_=ImageCompressionOptions(ImageCompressionOptions::NONE), ImageScalingOptions const &scaling_=ImageScalingOptions())
	Construct with specific compression and scaling options.
	ImageWriteOptions (ImageScalingOptions const &scaling_)
	Construct with specific scaling options.
	ImageWriteOptions (daf::base::PropertySet const &config)
	Construct from a PropertySet.

Static Public Member Functions
static std::shared_ptr< daf::base::PropertySet >	validate (daf::base::PropertySet const &config)
	Validate a PropertySet.

Public Attributes
ImageCompressionOptions	compression
	Options controlling compression.
ImageScalingOptions	scaling
	Options controlling scaling.

Detailed Description

Options for writing an image to FITS.

An image being written to FITS may be scaled (quantised) and/or compressed. This struct is a container for options controlling each of those separately.

Definition at line 223 of file fits.h.

Constructor & Destructor Documentation

ImageWriteOptions() [1/5]

template<typename T>

lsst::afw::fits::ImageWriteOptions::ImageWriteOptions ( image::Image< T > const & image )

inlineexplicit

Construct with default options for images.

Definition at line 229 of file fits.h.

: compression(image) {}

ImageWriteOptions() [2/5]

template<typename T>

lsst::afw::fits::ImageWriteOptions::ImageWriteOptions ( image::Mask< T > const & mask )

inlineexplicit

Construct with default options for masks.

Definition at line 233 of file fits.h.

: compression(mask) {}

ImageWriteOptions() [3/5]

lsst::afw::fits::ImageWriteOptions::ImageWriteOptions ( ImageCompressionOptions const & compression_ = ImageCompressionOptions(ImageCompressionOptions::NONE), ImageScalingOptions const & scaling_ = ImageScalingOptions() )

inlineexplicit

Construct with specific compression and scaling options.

Definition at line 236 of file fits.h.

            : compression(compression_), scaling(scaling_) {}

ImageWriteOptions() [4/5]

lsst::afw::fits::ImageWriteOptions::ImageWriteOptions ( ImageScalingOptions const & scaling_ )

inlineexplicit

Construct with specific scaling options.

Definition at line 242 of file fits.h.

            : compression(ImageCompressionOptions::NONE), scaling(scaling_) {}

ImageWriteOptions() [5/5]

lsst::afw::fits::ImageWriteOptions::ImageWriteOptions

(

daf::base::PropertySet const &

config

)

Construct from a PropertySet.

The PropertySet should include the following elements:

• compression.scheme (string): compression algorithm to use
• compression.columns (int): number of columns per tile (0 = entire dimension)
• compression.rows (int): number of rows per tile (0 = 1 row; that's what cfitsio does)
• compression.quantizeLevel (float): cfitsio quantization level
• scaling.scheme (string): scaling algorithm to use
• scaling.bitpix (int): bits per pixel (0, 8,16,32,64,-32,-64)
• scaling.fuzz (bool): fuzz the values when quantising floating-point values?
• scaling.seed (long): seed for random number generator when fuzzing
• scaling.maskPlanes (list of string): mask planes to ignore when doing statistics
• scaling.quantizeLevel: divisor of the standard deviation for STDEV_* scaling
• scaling.quantizePad: number of stdev to allow on the low side (for STDEV_POSITIVE/NEGATIVE)
• scaling.bscale: manually specified BSCALE (for MANUAL scaling)
• scaling.bzero: manually specified BSCALE (for MANUAL scaling)

Use the 'validate' method to set default values for the above.

'scaling.maskPlanes' is the only entry that is allowed to be missing (because PropertySet can't represent an empty array); when it is missing, it is interpreted as an empty array.

Parameters

[in]

config

Configuration of image write options

Definition at line 1800 of file fits.cc.

        : compression(fits::compressionAlgorithmFromString(config.get<std::string>("compression.algorithm")),
                      std::vector<long>{config.getAsInt64("compression.columns"),
                                        config.getAsInt64("compression.rows")},
                      config.getAsDouble("compression.quantizeLevel")),
          scaling(fits::scalingAlgorithmFromString(config.get<std::string>("scaling.algorithm")),
                  config.getAsInt("scaling.bitpix"),
                  config.exists("scaling.maskPlanes") ? config.getArray<std::string>("scaling.maskPlanes")
                                                      : std::vector<std::string>{},
                  config.getAsInt("scaling.seed"), config.getAsDouble("scaling.quantizeLevel"),
                  config.getAsDouble("scaling.quantizePad"), config.get<bool>("scaling.fuzz"),
                  config.getAsDouble("scaling.bscale"), config.getAsDouble("scaling.bzero")) {}

Member Function Documentation

validate()

std::shared_ptr< daf::base::PropertySet > lsst::afw::fits::ImageWriteOptions::validate ( daf::base::PropertySet const & config )

static

Validate a PropertySet.

Returns a validated PropertySet with default values added, suitable for use with the constructor.

For details on what elements may be included in the input, see ImageWriteOptions::ImageWriteOptions(daf::base::PropertySet const&).

Parameters

[in]

config

Configuration of image write options

Returns

validated configuration

Exceptions

lsst::pex::exceptions::RuntimeError

if entry is not recognized.

Definition at line 1829 of file fits.cc.

                                                                                              {
    auto validated = std::make_shared<daf::base::PropertySet>();
 
    validateEntry(*validated, config, "compression.algorithm", std::string("NONE"));
    validateEntry(*validated, config, "compression.columns", 0);
    validateEntry(*validated, config, "compression.rows", 1);
    validateEntry(*validated, config, "compression.quantizeLevel", 0.0);
 
    validateEntry(*validated, config, "scaling.algorithm", std::string("NONE"));
    validateEntry(*validated, config, "scaling.bitpix", 0);
    validateEntry(*validated, config, "scaling.maskPlanes", std::vector<std::string>{"NO_DATA"});
    validateEntry(*validated, config, "scaling.seed", 1);
    validateEntry(*validated, config, "scaling.quantizeLevel", 5.0);
    validateEntry(*validated, config, "scaling.quantizePad", 10.0);
    validateEntry(*validated, config, "scaling.fuzz", true);
    validateEntry(*validated, config, "scaling.bscale", 1.0);
    validateEntry(*validated, config, "scaling.bzero", 0.0);
 
    // Check for additional entries that we don't support (e.g., from typos)
    for (auto const &name : config.names(false)) {
        if (!validated->exists(name)) {
            std::ostringstream os;
            os << "Invalid image write option: " << name;
            throw LSST_EXCEPT(pex::exceptions::RuntimeError, os.str());
        }
    }
 
    return validated;
}

Member Data Documentation

compression

ImageCompressionOptions lsst::afw::fits::ImageWriteOptions::compression

Options controlling compression.

Definition at line 224 of file fits.h.

scaling

ImageScalingOptions lsst::afw::fits::ImageWriteOptions::scaling

Options controlling scaling.

Definition at line 225 of file fits.h.

---

The documentation for this struct was generated from the following files:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.1.0/Linux/afw/g4595892280+fef73a337f/include/lsst/afw/fits.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.1.0/Linux/afw/g4595892280+fef73a337f/src/fits.cc