LSST Applications g0265f82a02+093ff98f47,g02d81e74bb+10352d6f39,g1f3e9fa97e+40b0fc677d,g2079a07aa2+14824f138e,g2bbee38e9b+093ff98f47,g337abbeb29+093ff98f47,g3ddfee87b4+064c02c7ee,g487adcacf7+7e842ebf4b,g50ff169b8f+5929b3527e,g52b1c1532d+a6fc98d2e7,g568d43a26c+1d7ac31cb0,g591dd9f2cf+fb1f69e2ea,g858d7b2824+10352d6f39,g8a8a8dda67+a6fc98d2e7,g8cdfe0ae6a+66d966b544,g99cad8db69+7ce8a7c20a,g9ddcbc5298+d4bad12328,ga1e77700b3+246acaaf9c,ga2e4dd1c03+064c02c7ee,ga8c6da7877+04f6ba86dc,gae46bcf261+093ff98f47,gb0e22166c9+3863383f4c,gba4ed39666+9664299f35,gbb8dafda3b+db40f59a7d,gbeb006f7da+e6a448e96d,gbf5cecdb8a+10352d6f39,gc0f3af6251+10a3fd39cd,gc120e1dc64+5839e50a77,gc28159a63d+093ff98f47,gcf0d15dbbd+064c02c7ee,gd2a12a3803+0c2c227a2b,gdaeeff99f8+a38ce5ea23,ge79ae78c31+093ff98f47,gee10cc3b42+a6fc98d2e7,gf1cff7945b+10352d6f39,w.2024.15
LSST Data Management Base Package
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
lsst::afw::fits Namespace Reference

Namespaces

namespace  _compression
 
namespace  _fitsContinued
 
namespace  _pickleFits
 
namespace  detail
 

Classes

struct  Bzero
 Scaling zero-point, set according to pixel type. More...
 
struct  Bzero< std::uint64_t >
 
struct  Bzero< T, typename std::enable_if< std::numeric_limits< T >::is_integer &&!std::numeric_limits< T >::is_signed >::type >
 
class  Fits
 A simple struct that combines the two arguments that must be passed to most cfitsio routines and contains thin and/or templated wrappers around common cfitsio routines. More...
 
class  FitsError
 An exception thrown when problems are found when reading or writing FITS files. More...
 
class  FitsTypeError
 An exception thrown when a FITS file has the wrong type. More...
 
class  HduMoveGuard
 RAII scoped guard for moving the HDU in a Fits object. More...
 
class  HeaderIterationFunctor
 Base class for polymorphic functors used to iterator over FITS key headers. More...
 
struct  ImageCompressionOptions
 Options for tile compression of image pixels. More...
 
struct  ImageScale
 Scale to apply to image. More...
 
class  ImageScalingOptions
 Options for scaling image pixels. More...
 
struct  ImageWriteOptions
 Options for writing an image to FITS. More...
 
class  MemFileManager
 Lifetime-management for memory that goes into FITS memory files. More...
 

Typedefs

using dafPlistPtr = std::shared_ptr<daf::base::PropertyList>
 

Enumerations

enum class  HduType : int { IMAGE = 0 , ASCII_TABLE = 1 , BIN_TABLE = 2 , ANY = -1 }
 an enum representing the various types of FITS HDU that are available in cfitsio library More...
 

Functions

std::string makeErrorMessage (std::string const &fileName="", int status=0, std::string const &msg="")
 Return an error message reflecting FITS I/O errors.
 
std::string makeErrorMessage (std::string const &fileName, int status, boost::format const &msg)
 
std::string makeErrorMessage (void *fptr, int status=0, std::string const &msg="")
 Return an error message reflecting FITS I/O errors.
 
std::string makeErrorMessage (void *fptr, int status, boost::format const &msg)
 
std::string makeLimitedFitsHeader (lsst::daf::base::PropertySet const &metadata, std::set< std::string > const &excludeNames={})
 Format a PropertySet into an FITS header string in a simplistic fashion.
 
template<typename T >
int getBitPix ()
 Return the cfitsio integer BITPIX code for the given data type.
 
template<typename T , int N, int C>
ndarray::Array< T const, N, N > const makeContiguousArray (ndarray::Array< T, N, C > const &array)
 Construct a contiguous ndarray.
 
std::shared_ptr< daf::base::PropertyListcombineMetadata (daf::base::PropertyList const &first, daf::base::PropertyList const &second)
 Combine two sets of metadata in a FITS-appropriate fashion.
 
std::shared_ptr< daf::base::PropertyListreadMetadata (std::string const &fileName, int hdu=DEFAULT_HDU, bool strip=false)
 Read FITS header.
 
std::shared_ptr< daf::base::PropertyListreadMetadata (std::string const &fileName, std::string const &hduname, HduType type=HduType::ANY, int hduver=0, bool strip=false)
 Read FITS header.
 
std::shared_ptr< daf::base::PropertyListreadMetadata (fits::MemFileManager &manager, int hdu=DEFAULT_HDU, bool strip=false)
 Read FITS header.
 
std::shared_ptr< daf::base::PropertyListreadMetadata (fits::MemFileManager &manager, std::string const &hduname, HduType type=HduType::ANY, int hduver=0, bool strip=false)
 Read FITS header.
 
std::shared_ptr< daf::base::PropertyListreadMetadata (fits::Fits &fitsfile, bool strip=false)
 Read FITS header.
 
void setAllowImageCompression (bool allow)
 
bool getAllowImageCompression ()
 
ImageCompressionOptions::CompressionAlgorithm compressionAlgorithmFromString (std::string const &name)
 Interpret compression algorithm expressed in string.
 
std::string compressionAlgorithmToString (ImageCompressionOptions::CompressionAlgorithm algorithm)
 Provide string version of compression algorithm.
 
ImageCompressionOptions::CompressionAlgorithm compressionAlgorithmFromCfitsio (int cfitsio)
 Convert compression algorithm from cfitsio to ImageCompressionOptions::CompressionAlgorithm.
 
int compressionAlgorithmToCfitsio (ImageCompressionOptions::CompressionAlgorithm algorithm)
 Convert ImageCompressionOptions::CompressionAlgorithm to cfitsio.
 
ImageScalingOptions::ScalingAlgorithm scalingAlgorithmFromString (std::string const &name)
 Interpret scaling algorithm expressed in string.
 
std::string scalingAlgorithmToString (ImageScalingOptions::ScalingAlgorithm algorithm)
 Provide string version of compression algorithm.
 
 PYBIND11_MODULE (_fits, mod)
 
template ImageScale ImageScalingOptions::determine< std::uint8_t, 2 > (ndarray::Array< std::uint8_t const, 2, 2 > const &image, ndarray::Array< bool, 2, 2 > const &mask) const
 
template std::shared_ptr< detail::PixelArrayBaseImageScale::toFits< std::uint8_t > (ndarray::Array< std::uint8_t const, 2, 2 > const &, bool, bool, ndarray::Array< long, 1 > const &, int) const
 
template ndarray::Array< std::uint8_t, 2, 2 > ImageScale::fromFits< std::uint8_t > (ndarray::Array< std::uint8_t, 2, 2 > const &) const
 
template ImageScale ImageScalingOptions::determine< std::uint16_t, 2 > (ndarray::Array< std::uint16_t const, 2, 2 > const &image, ndarray::Array< bool, 2, 2 > const &mask) const
 
template std::shared_ptr< detail::PixelArrayBaseImageScale::toFits< std::uint16_t > (ndarray::Array< std::uint16_t const, 2, 2 > const &, bool, bool, ndarray::Array< long, 1 > const &, int) const
 
template ndarray::Array< std::uint16_t, 2, 2 > ImageScale::fromFits< std::uint16_t > (ndarray::Array< std::uint16_t, 2, 2 > const &) const
 
template ImageScale ImageScalingOptions::determine< std::int16_t, 2 > (ndarray::Array< std::int16_t const, 2, 2 > const &image, ndarray::Array< bool, 2, 2 > const &mask) const
 
template std::shared_ptr< detail::PixelArrayBaseImageScale::toFits< std::int16_t > (ndarray::Array< std::int16_t const, 2, 2 > const &, bool, bool, ndarray::Array< long, 1 > const &, int) const
 
template ndarray::Array< std::int16_t, 2, 2 > ImageScale::fromFits< std::int16_t > (ndarray::Array< std::int16_t, 2, 2 > const &) const
 
template ImageScale ImageScalingOptions::determine< std::uint32_t, 2 > (ndarray::Array< std::uint32_t const, 2, 2 > const &image, ndarray::Array< bool, 2, 2 > const &mask) const
 
template std::shared_ptr< detail::PixelArrayBaseImageScale::toFits< std::uint32_t > (ndarray::Array< std::uint32_t const, 2, 2 > const &, bool, bool, ndarray::Array< long, 1 > const &, int) const
 
template ndarray::Array< std::uint32_t, 2, 2 > ImageScale::fromFits< std::uint32_t > (ndarray::Array< std::uint32_t, 2, 2 > const &) const
 
template ImageScale ImageScalingOptions::determine< std::int32_t, 2 > (ndarray::Array< std::int32_t const, 2, 2 > const &image, ndarray::Array< bool, 2, 2 > const &mask) const
 
template std::shared_ptr< detail::PixelArrayBaseImageScale::toFits< std::int32_t > (ndarray::Array< std::int32_t const, 2, 2 > const &, bool, bool, ndarray::Array< long, 1 > const &, int) const
 
template ndarray::Array< std::int32_t, 2, 2 > ImageScale::fromFits< std::int32_t > (ndarray::Array< std::int32_t, 2, 2 > const &) const
 
template ImageScale ImageScalingOptions::determine< std::uint64_t, 2 > (ndarray::Array< std::uint64_t const, 2, 2 > const &image, ndarray::Array< bool, 2, 2 > const &mask) const
 
template std::shared_ptr< detail::PixelArrayBaseImageScale::toFits< std::uint64_t > (ndarray::Array< std::uint64_t const, 2, 2 > const &, bool, bool, ndarray::Array< long, 1 > const &, int) const
 
template ndarray::Array< std::uint64_t, 2, 2 > ImageScale::fromFits< std::uint64_t > (ndarray::Array< std::uint64_t, 2, 2 > const &) const
 
template ImageScale ImageScalingOptions::determine< std::int64_t, 2 > (ndarray::Array< std::int64_t const, 2, 2 > const &image, ndarray::Array< bool, 2, 2 > const &mask) const
 
template std::shared_ptr< detail::PixelArrayBaseImageScale::toFits< std::int64_t > (ndarray::Array< std::int64_t const, 2, 2 > const &, bool, bool, ndarray::Array< long, 1 > const &, int) const
 
template ndarray::Array< std::int64_t, 2, 2 > ImageScale::fromFits< std::int64_t > (ndarray::Array< std::int64_t, 2, 2 > const &) const
 
template ImageScale ImageScalingOptions::determine< boost::float32_t, 2 > (ndarray::Array< boost::float32_t const, 2, 2 > const &image, ndarray::Array< bool, 2, 2 > const &mask) const
 
template std::shared_ptr< detail::PixelArrayBaseImageScale::toFits< boost::float32_t > (ndarray::Array< boost::float32_t const, 2, 2 > const &, bool, bool, ndarray::Array< long, 1 > const &, int) const
 
template ndarray::Array< boost::float32_t, 2, 2 > ImageScale::fromFits< boost::float32_t > (ndarray::Array< boost::float32_t, 2, 2 > const &) const
 
template ImageScale ImageScalingOptions::determine< boost::float64_t, 2 > (ndarray::Array< boost::float64_t const, 2, 2 > const &image, ndarray::Array< bool, 2, 2 > const &mask) const
 
template std::shared_ptr< detail::PixelArrayBaseImageScale::toFits< boost::float64_t > (ndarray::Array< boost::float64_t const, 2, 2 > const &, bool, bool, ndarray::Array< long, 1 > const &, int) const
 
template ndarray::Array< boost::float64_t, 2, 2 > ImageScale::fromFits< boost::float64_t > (ndarray::Array< boost::float64_t, 2, 2 > const &) const
 

Variables

const int DEFAULT_HDU = INT_MIN
 Specify that the default HDU should be read.
 

Typedef Documentation

◆ dafPlistPtr

Definition at line 1677 of file fits.cc.

Enumeration Type Documentation

◆ HduType

enum class lsst::afw::fits::HduType : int
strong

an enum representing the various types of FITS HDU that are available in cfitsio library

This is an int because the value it maps to in cfitsio is also an int.

Enumerator
IMAGE 
ASCII_TABLE 
BIN_TABLE 
ANY 

Definition at line 290 of file fits.h.

Function Documentation

◆ combineMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::fits::combineMetadata ( daf::base::PropertyList const & first,
daf::base::PropertyList const & second )

Combine two sets of metadata in a FITS-appropriate fashion.

"COMMENT" and "HISTORY" entries:

  • If of type std::string then the values in second are appended to values in first
  • If not of type std::string then they are silently ignored

All other entries:

  • Values in second override values in first (regardless of type)
  • Only scalars are copied; if a vector is found, only the last value is copied
Parameters
[in]firstThe first set of metadata to combine
[in]secondThe second set of metadata to combine
Returns
The combined metadata. Item names have the following order:
  • names in first, omitting all names except "COMMENT" and "HISTORY" that appear in second
  • names in second, omitting "COMMENT" and "HISTORY" if valid versions appear in first

Definition at line 1648 of file fits.cc.

1650 {
1651 auto combined = std::make_shared<daf::base::PropertyList>();
1652 bool const asScalar = true;
1653 for (auto const &name : first.getOrderedNames()) {
1654 auto const iscv = isCommentIsValid(first, name);
1655 if (iscv.isComment) {
1656 if (iscv.isValid) {
1657 combined->add<std::string>(name, first.getArray<std::string>(name));
1658 }
1659 } else {
1660 combined->copy(name, first, name, asScalar);
1661 }
1662 }
1663 for (auto const &name : second.getOrderedNames()) {
1664 auto const iscv = isCommentIsValid(second, name);
1665 if (iscv.isComment) {
1666 if (iscv.isValid) {
1667 combined->add<std::string>(name, second.getArray<std::string>(name));
1668 }
1669 } else {
1670 // `copy` will replace an item, even if has a different type, so no need to call `remove`
1671 combined->copy(name, second, name, asScalar);
1672 }
1673 }
1674 return combined;
1675}
table::Key< std::string > name
Definition Amplifier.cc:116

◆ compressionAlgorithmFromCfitsio()

ImageCompressionOptions::CompressionAlgorithm lsst::afw::fits::compressionAlgorithmFromCfitsio ( int cfitsio)

Convert compression algorithm from cfitsio to ImageCompressionOptions::CompressionAlgorithm.

Definition at line 49 of file fitsCompression.cc.

49 {
50 switch (cfitsio) {
51 case 0:
52 return ImageCompressionOptions::NONE;
53 case RICE_1:
54 return ImageCompressionOptions::RICE;
55 case GZIP_1:
56 return ImageCompressionOptions::GZIP;
57 case GZIP_2:
58 return ImageCompressionOptions::GZIP_SHUFFLE;
59 case PLIO_1:
60 return ImageCompressionOptions::PLIO;
61 case HCOMPRESS_1:
63 "Unsupported compression algorithm: HCOMPRESS_1");
64 default:
66 os << "Unrecognized cfitsio compression: " << cfitsio;
68 }
69}
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition Exception.h:48
std::ostream * os
Definition Schema.cc:557
Reports invalid arguments.
Definition Runtime.h:66

◆ compressionAlgorithmFromString()

ImageCompressionOptions::CompressionAlgorithm lsst::afw::fits::compressionAlgorithmFromString ( std::string const & name)

Interpret compression algorithm expressed in string.

Definition at line 19 of file fitsCompression.cc.

19 {
20 if (name == "NONE") return ImageCompressionOptions::NONE;
21 if (name == "GZIP") return ImageCompressionOptions::GZIP;
22 if (name == "GZIP_SHUFFLE") return ImageCompressionOptions::GZIP_SHUFFLE;
23 if (name == "RICE") return ImageCompressionOptions::RICE;
24 if (name == "HCOMPRESS")
25 throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "HCOMPRESS is unsupported");
26 if (name == "PLIO") return ImageCompressionOptions::PLIO;
27 throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Unrecognised compression algorithm: " + name);
28}

◆ compressionAlgorithmToCfitsio()

int lsst::afw::fits::compressionAlgorithmToCfitsio ( ImageCompressionOptions::CompressionAlgorithm algorithm)

Convert ImageCompressionOptions::CompressionAlgorithm to cfitsio.

Definition at line 71 of file fitsCompression.cc.

71 {
72 switch (algorithm) {
73 case ImageCompressionOptions::NONE:
74 return 0;
75 case ImageCompressionOptions::GZIP:
76 return GZIP_1;
77 case ImageCompressionOptions::GZIP_SHUFFLE:
78 return GZIP_2;
79 case ImageCompressionOptions::RICE:
80 return RICE_1;
81 case ImageCompressionOptions::PLIO:
82 return PLIO_1;
83 default:
85 os << "Unrecognized compression algorithm: " << algorithm;
87 }
88}

◆ compressionAlgorithmToString()

std::string lsst::afw::fits::compressionAlgorithmToString ( ImageCompressionOptions::CompressionAlgorithm algorithm)

Provide string version of compression algorithm.

Definition at line 30 of file fitsCompression.cc.

30 {
31 switch (algorithm) {
32 case ImageCompressionOptions::NONE:
33 return "NONE";
34 case ImageCompressionOptions::GZIP:
35 return "GZIP";
36 case ImageCompressionOptions::GZIP_SHUFFLE:
37 return "GZIP_SHUFFLE";
38 case ImageCompressionOptions::RICE:
39 return "RICE";
40 case ImageCompressionOptions::PLIO:
41 return "PLIO";
42 default:
44 os << "Unrecognized compression algorithm: " << algorithm;
46 }
47}

◆ getAllowImageCompression()

bool lsst::afw::fits::getAllowImageCompression ( )

Definition at line 1568 of file fits.cc.

1568{ return allowImageCompression; }

◆ getBitPix()

template<typename T >
int lsst::afw::fits::getBitPix ( )

Return the cfitsio integer BITPIX code for the given data type.

Definition at line 501 of file fits.cc.

501 {
502 return FitsBitPix<T>::CONSTANT;
503}

◆ ImageScale::fromFits< boost::float32_t >()

template ndarray::Array< boost::float32_t, 2, 2 > lsst::afw::fits::ImageScale::fromFits< boost::float32_t > ( ndarray::Array< boost::float32_t, 2, 2 > const & ) const

◆ ImageScale::fromFits< boost::float64_t >()

template ndarray::Array< boost::float64_t, 2, 2 > lsst::afw::fits::ImageScale::fromFits< boost::float64_t > ( ndarray::Array< boost::float64_t, 2, 2 > const & ) const

◆ ImageScale::fromFits< std::int16_t >()

template ndarray::Array< std::int16_t, 2, 2 > lsst::afw::fits::ImageScale::fromFits< std::int16_t > ( ndarray::Array< std::int16_t, 2, 2 > const & ) const

◆ ImageScale::fromFits< std::int32_t >()

template ndarray::Array< std::int32_t, 2, 2 > lsst::afw::fits::ImageScale::fromFits< std::int32_t > ( ndarray::Array< std::int32_t, 2, 2 > const & ) const

◆ ImageScale::fromFits< std::int64_t >()

template ndarray::Array< std::int64_t, 2, 2 > lsst::afw::fits::ImageScale::fromFits< std::int64_t > ( ndarray::Array< std::int64_t, 2, 2 > const & ) const

◆ ImageScale::fromFits< std::uint16_t >()

template ndarray::Array< std::uint16_t, 2, 2 > lsst::afw::fits::ImageScale::fromFits< std::uint16_t > ( ndarray::Array< std::uint16_t, 2, 2 > const & ) const

◆ ImageScale::fromFits< std::uint32_t >()

template ndarray::Array< std::uint32_t, 2, 2 > lsst::afw::fits::ImageScale::fromFits< std::uint32_t > ( ndarray::Array< std::uint32_t, 2, 2 > const & ) const

◆ ImageScale::fromFits< std::uint64_t >()

template ndarray::Array< std::uint64_t, 2, 2 > lsst::afw::fits::ImageScale::fromFits< std::uint64_t > ( ndarray::Array< std::uint64_t, 2, 2 > const & ) const

◆ ImageScale::fromFits< std::uint8_t >()

template ndarray::Array< std::uint8_t, 2, 2 > lsst::afw::fits::ImageScale::fromFits< std::uint8_t > ( ndarray::Array< std::uint8_t, 2, 2 > const & ) const

◆ ImageScale::toFits< boost::float32_t >()

template std::shared_ptr< detail::PixelArrayBase > lsst::afw::fits::ImageScale::toFits< boost::float32_t > ( ndarray::Array< boost::float32_t const, 2, 2 > const & ,
bool ,
bool ,
ndarray::Array< long, 1 > const & ,
int  ) const

◆ ImageScale::toFits< boost::float64_t >()

template std::shared_ptr< detail::PixelArrayBase > lsst::afw::fits::ImageScale::toFits< boost::float64_t > ( ndarray::Array< boost::float64_t const, 2, 2 > const & ,
bool ,
bool ,
ndarray::Array< long, 1 > const & ,
int  ) const

◆ ImageScale::toFits< std::int16_t >()

template std::shared_ptr< detail::PixelArrayBase > lsst::afw::fits::ImageScale::toFits< std::int16_t > ( ndarray::Array< std::int16_t const, 2, 2 > const & ,
bool ,
bool ,
ndarray::Array< long, 1 > const & ,
int  ) const

◆ ImageScale::toFits< std::int32_t >()

template std::shared_ptr< detail::PixelArrayBase > lsst::afw::fits::ImageScale::toFits< std::int32_t > ( ndarray::Array< std::int32_t const, 2, 2 > const & ,
bool ,
bool ,
ndarray::Array< long, 1 > const & ,
int  ) const

◆ ImageScale::toFits< std::int64_t >()

template std::shared_ptr< detail::PixelArrayBase > lsst::afw::fits::ImageScale::toFits< std::int64_t > ( ndarray::Array< std::int64_t const, 2, 2 > const & ,
bool ,
bool ,
ndarray::Array< long, 1 > const & ,
int  ) const

◆ ImageScale::toFits< std::uint16_t >()

template std::shared_ptr< detail::PixelArrayBase > lsst::afw::fits::ImageScale::toFits< std::uint16_t > ( ndarray::Array< std::uint16_t const, 2, 2 > const & ,
bool ,
bool ,
ndarray::Array< long, 1 > const & ,
int  ) const

◆ ImageScale::toFits< std::uint32_t >()

template std::shared_ptr< detail::PixelArrayBase > lsst::afw::fits::ImageScale::toFits< std::uint32_t > ( ndarray::Array< std::uint32_t const, 2, 2 > const & ,
bool ,
bool ,
ndarray::Array< long, 1 > const & ,
int  ) const

◆ ImageScale::toFits< std::uint64_t >()

template std::shared_ptr< detail::PixelArrayBase > lsst::afw::fits::ImageScale::toFits< std::uint64_t > ( ndarray::Array< std::uint64_t const, 2, 2 > const & ,
bool ,
bool ,
ndarray::Array< long, 1 > const & ,
int  ) const

◆ ImageScale::toFits< std::uint8_t >()

template std::shared_ptr< detail::PixelArrayBase > lsst::afw::fits::ImageScale::toFits< std::uint8_t > ( ndarray::Array< std::uint8_t const, 2, 2 > const & ,
bool ,
bool ,
ndarray::Array< long, 1 > const & ,
int  ) const

◆ ImageScalingOptions::determine< boost::float32_t, 2 >()

template ImageScale lsst::afw::fits::ImageScalingOptions::determine< boost::float32_t, 2 > ( ndarray::Array< boost::float32_t const, 2, 2 > const & image,
ndarray::Array< bool, 2, 2 > const & mask ) const

◆ ImageScalingOptions::determine< boost::float64_t, 2 >()

template ImageScale lsst::afw::fits::ImageScalingOptions::determine< boost::float64_t, 2 > ( ndarray::Array< boost::float64_t const, 2, 2 > const & image,
ndarray::Array< bool, 2, 2 > const & mask ) const

◆ ImageScalingOptions::determine< std::int16_t, 2 >()

template ImageScale lsst::afw::fits::ImageScalingOptions::determine< std::int16_t, 2 > ( ndarray::Array< std::int16_t const, 2, 2 > const & image,
ndarray::Array< bool, 2, 2 > const & mask ) const

◆ ImageScalingOptions::determine< std::int32_t, 2 >()

template ImageScale lsst::afw::fits::ImageScalingOptions::determine< std::int32_t, 2 > ( ndarray::Array< std::int32_t const, 2, 2 > const & image,
ndarray::Array< bool, 2, 2 > const & mask ) const

◆ ImageScalingOptions::determine< std::int64_t, 2 >()

template ImageScale lsst::afw::fits::ImageScalingOptions::determine< std::int64_t, 2 > ( ndarray::Array< std::int64_t const, 2, 2 > const & image,
ndarray::Array< bool, 2, 2 > const & mask ) const

◆ ImageScalingOptions::determine< std::uint16_t, 2 >()

template ImageScale lsst::afw::fits::ImageScalingOptions::determine< std::uint16_t, 2 > ( ndarray::Array< std::uint16_t const, 2, 2 > const & image,
ndarray::Array< bool, 2, 2 > const & mask ) const

◆ ImageScalingOptions::determine< std::uint32_t, 2 >()

template ImageScale lsst::afw::fits::ImageScalingOptions::determine< std::uint32_t, 2 > ( ndarray::Array< std::uint32_t const, 2, 2 > const & image,
ndarray::Array< bool, 2, 2 > const & mask ) const

◆ ImageScalingOptions::determine< std::uint64_t, 2 >()

template ImageScale lsst::afw::fits::ImageScalingOptions::determine< std::uint64_t, 2 > ( ndarray::Array< std::uint64_t const, 2, 2 > const & image,
ndarray::Array< bool, 2, 2 > const & mask ) const

◆ ImageScalingOptions::determine< std::uint8_t, 2 >()

template ImageScale lsst::afw::fits::ImageScalingOptions::determine< std::uint8_t, 2 > ( ndarray::Array< std::uint8_t const, 2, 2 > const & image,
ndarray::Array< bool, 2, 2 > const & mask ) const

◆ makeContiguousArray()

template<typename T , int N, int C>
ndarray::Array< T const, N, N > const lsst::afw::fits::makeContiguousArray ( ndarray::Array< T, N, C > const & array)

Construct a contiguous ndarray.

A deep copy is only performed if the array is not already contiguous.

Definition at line 212 of file fits.h.

212 {
213 ndarray::Array<T const, N, N> contiguous = ndarray::dynamic_dimension_cast<N>(array);
214 if (contiguous.empty()) contiguous = ndarray::copy(array);
215 return contiguous;
216}

◆ makeErrorMessage() [1/4]

std::string lsst::afw::fits::makeErrorMessage ( std::string const & fileName,
int status,
boost::format const & msg )
inline

Definition at line 65 of file fits.h.

65 {
66 return makeErrorMessage(fileName, status, msg.str());
67}
std::string makeErrorMessage(std::string const &fileName="", int status=0, std::string const &msg="")
Return an error message reflecting FITS I/O errors.
Definition fits.cc:431

◆ makeErrorMessage() [2/4]

std::string lsst::afw::fits::makeErrorMessage ( std::string const & fileName = "",
int status = 0,
std::string const & msg = "" )

Return an error message reflecting FITS I/O errors.

Parameters
[in]fileNameFITS filename to be included in the error message.
[in]statusThe last status value returned by the cfitsio library; if nonzero, the error message will include a description from cfitsio.
[in]msgAn additional custom message to include.

Definition at line 431 of file fits.cc.

431 {
433 os << "cfitsio error";
434 if (fileName != "") {
435 os << " (" << fileName << ")";
436 }
437 if (status != 0) {
438 char fitsErrMsg[FLEN_ERRMSG];
439 fits_get_errstatus(status, fitsErrMsg);
440 os << ": " << fitsErrMsg << " (" << status << ")";
441 }
442 if (msg != "") {
443 os << " : " << msg;
444 }
445 os << "\ncfitsio error stack:\n";
446 char cfitsioMsg[FLEN_ERRMSG];
447 // fits_read_errmsg can return a junk string with non printable characters
448 // creating problem with python exception bindings
449 while (fits_read_errmsg(cfitsioMsg) != 0) {
450 cfitsioMsg[FLEN_ERRMSG-1] = char(0); // ensure termination
451 std::size_t len=strlen(cfitsioMsg);
452 for(std::size_t i = 0; i < len; i++)
453 if( !isprint(cfitsioMsg[i]) ) cfitsioMsg[i] = '.';
454 os << " " << cfitsioMsg << "\n";
455 }
456 return os.str();
457}

◆ makeErrorMessage() [3/4]

std::string lsst::afw::fits::makeErrorMessage ( void * fptr,
int status,
boost::format const & msg )
inline

Definition at line 79 of file fits.h.

79 {
80 return makeErrorMessage(fptr, status, msg.str());
81}

◆ makeErrorMessage() [4/4]

std::string lsst::afw::fits::makeErrorMessage ( void * fptr,
int status = 0,
std::string const & msg = "" )

Return an error message reflecting FITS I/O errors.

Parameters
[in]fptrA cfitsio fitsfile pointer to be inspected for a filename. Passed as void* to avoid including fitsio.h in the header file.
[in]statusThe last status value returned by the cfitsio library; if nonzero, the error message will include a description from cfitsio.
[in]msgAn additional custom message to include.

Definition at line 459 of file fits.cc.

459 {
460 std::string fileName = "";
461 fitsfile *fd = reinterpret_cast<fitsfile *>(fptr);
462 if (fd != nullptr && fd->Fptr != nullptr && fd->Fptr->filename != nullptr) {
463 fileName = fd->Fptr->filename;
464 }
465 return makeErrorMessage(fileName, status, msg);
466}

◆ makeLimitedFitsHeader()

std::string lsst::afw::fits::makeLimitedFitsHeader ( lsst::daf::base::PropertySet const & metadata,
std::set< std::string > const & excludeNames = {} )

Format a PropertySet into an FITS header string in a simplistic fashion.

This function is designed to format data for creating a WCS. As such, it is quite limited:

  • It skips entries whose name is longer than 8 characters, since none are used for FITS-WCS
  • It skips string entries if the fully formatted string is longer than 80 characters
  • It skips entries with types it cannot handle (e.g. long, long long)
  • For entries that have array data, it only writes the final value, since that is the value that should be used by code that reads FITS headers.
  • It makes no attempt to insure that required entries, such as SIMPLE, are present.
Parameters
[in]metadataMetadata to format; if this is a PropertyList then the order of items is preserved
[in]excludeNamesNames of entries to exclude from the returned header string
Returns
a FITS header string (exactly 80 characters per entry, no line terminators)

Definition at line 468 of file fits.cc.

469 {
470 daf::base::PropertyList const *pl = dynamic_cast<daf::base::PropertyList const *>(&metadata);
471 std::vector<std::string> allParamNames;
472 if (pl) {
473 allParamNames = pl->getOrderedNames();
474 } else {
475 allParamNames = metadata.paramNames(false);
476 }
477 std::vector<std::string> desiredParamNames;
478 for (auto const &name : allParamNames) {
479 if (excludeNames.count(name) == 0) {
480 desiredParamNames.push_back(name);
481 }
482 }
483 return makeLimitedFitsHeaderImpl(desiredParamNames, metadata);
484}
Class for storing ordered metadata with comments.
std::vector< std::string > getOrderedNames() const
Get the list of property names, in the order they were added.
T count(T... args)
T push_back(T... args)

◆ PYBIND11_MODULE()

lsst::afw::fits::PYBIND11_MODULE ( _fits ,
mod  )

Definition at line 284 of file _fits.cc.

284 {
285 lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.fits");
286 wrappers.addInheritanceDependency("lsst.pex.exceptions");
287 wrappers.addSignatureDependency("lsst.daf.base");
288 // FIXME: after afw.image pybind wrappers are converted
289 //wrappers.addSignatureDependency("lsst.afw.image");
290 auto cls = wrappers.wrapException<FitsError, lsst::pex::exceptions::IoError>("FitsError", "IoError");
291 cls.def(py::init<std::string const &>());
292 declareImageCompression(wrappers);
293 declareImageScalingOptions(wrappers);
294 declareImageScale(wrappers);
295 declareImageWriteOptions(wrappers);
296 declareFits(wrappers);
297 declareFitsModule(wrappers);
298 wrappers.finish();
299}
An exception thrown when problems are found when reading or writing FITS files.
Definition fits.h:36
Reports errors in external input/output operations.
Definition Runtime.h:160

◆ readMetadata() [1/5]

std::shared_ptr< daf::base::PropertyList > lsst::afw::fits::readMetadata ( fits::Fits & fitsfile,
bool strip = false )

Read FITS header.

Includes support for the INHERIT convention: if 'INHERIT = T' is in the header, the PHU will be read as well, and nominated HDU will override any duplicated values.

Parameters
fitsfilethe file and HDU to be read
stripif true, common FITS keys that usually have non-metadata intepretations (e.g. NAXIS, BITPIX) will be ignored.

Definition at line 1707 of file fits.cc.

1707 {
1708 auto metadata = std::make_shared<lsst::daf::base::PropertyList>();
1709 fitsfile.readMetadata(*metadata, strip);
1710 // if INHERIT=T, we want to also include header entries from the primary HDU
1711 int oldHdu = fitsfile.getHdu();
1712 if (oldHdu != 0 && metadata->exists("INHERIT")) {
1713 bool inherit = false;
1714 if (metadata->typeOf("INHERIT") == typeid(std::nullptr_t)) {
1715 // Assume false if INHERIT exists but is undefined.
1716 inherit = false;
1717 } else if (metadata->typeOf("INHERIT") == typeid(std::string)) {
1718 inherit = (metadata->get<std::string>("INHERIT") == "T");
1719 } else {
1720 inherit = metadata->get<bool>("INHERIT");
1721 }
1722 if (strip) metadata->remove("INHERIT");
1723 if (inherit) {
1724 HduMoveGuard guard(fitsfile, 0);
1725 // Combine the metadata from the primary HDU with the metadata from the specified HDU,
1726 // with non-comment values from the specified HDU superseding those in the primary HDU
1727 // and comments from the specified HDU appended to comments from the primary HDU
1728 auto primaryHduMetadata = std::make_shared<daf::base::PropertyList>();
1729 fitsfile.readMetadata(*primaryHduMetadata, strip);
1730 metadata = combineMetadata(*primaryHduMetadata, *metadata);
1731 } else {
1732 // Purge invalid values
1733 auto const emptyMetadata = std::make_shared<lsst::daf::base::PropertyList>();
1734 metadata = combineMetadata(*metadata, *emptyMetadata);
1735 }
1736 }
1737 return metadata;
1738}
void readMetadata(daf::base::PropertySet &metadata, bool strip=false)
Read a FITS header into a PropertySet or PropertyList.
Definition fits.cc:1106
int getHdu()
Return the current HDU (0-indexed; 0 is the Primary HDU).
Definition fits.cc:518
bool strip
Definition fits.cc:930
std::shared_ptr< daf::base::PropertyList > combineMetadata(daf::base::PropertyList const &first, daf::base::PropertyList const &second)
Combine two sets of metadata in a FITS-appropriate fashion.
Definition fits.cc:1648

◆ readMetadata() [2/5]

dafPlistPtr lsst::afw::fits::readMetadata ( fits::MemFileManager & manager,
int hdu = DEFAULT_HDU,
bool strip = false )

Read FITS header.

Includes support for the INHERIT convention: if 'INHERIT = T' is in the header, the PHU will be read as well, and nominated HDU will override any duplicated values.

Parameters
managerthe in-memory file whose header will be read
hduthe HDU to read (0-indexed; 0 is the Primary HDU).
stripif true, common FITS keys that usually have non-metadata intepretations (e.g. NAXIS, BITPIX) will be ignored.

Definition at line 1698 of file fits.cc.

1698 {
1699 return detail::_readMetadata(manager, strip, hdu);
1700}

◆ readMetadata() [3/5]

dafPlistPtr lsst::afw::fits::readMetadata ( fits::MemFileManager & manager,
std::string const & hduname,
HduType type = HduType::ANY,
int hduver = 0,
bool strip = false )

Read FITS header.

Includes support for the INHERIT convention: if 'INHERIT = T' is in the header, the PHU will be read as well, and nominated HDU will override any duplicated values.

Parameters
managerthe in-memory file whose header will be read
hdunamethe name of the HDU to read
typetype of FITS header to match. Defaults to ANY_HDU
hduverversion of HDU header to match, defaults to 0 (version ignored)
stripif true, common FITS keys that usually have non-metadata intepretations (e.g. NAXIS, BITPIX) will be ignored.

Definition at line 1702 of file fits.cc.

1703 {
1704 return detail::_readMetadata(manager, strip, hduname, type, hduver);
1705}

◆ readMetadata() [4/5]

dafPlistPtr lsst::afw::fits::readMetadata ( std::string const & fileName,
int hdu = DEFAULT_HDU,
bool strip = false )

Read FITS header.

Includes support for the INHERIT convention: if 'INHERIT = T' is in the header, the PHU will be read as well, and nominated HDU will override any duplicated values.

Parameters
fileNamethe file whose header will be read
hduthe HDU to read (0-indexed; 0 is the Primary HDU).
stripif true, common FITS keys that usually have non-metadata intepretations (e.g. NAXIS, BITPIX) will be ignored.

Definition at line 1689 of file fits.cc.

1689 {
1690 return detail::_readMetadata(fileName, strip, hdu);
1691}

◆ readMetadata() [5/5]

dafPlistPtr lsst::afw::fits::readMetadata ( std::string const & fileName,
std::string const & hduname,
HduType type = HduType::ANY,
int hduver = 0,
bool strip = false )

Read FITS header.

Includes support for the INHERIT convention: if 'INHERIT = T' is in the header, the PHU will be read as well, and nominated HDU will override any duplicated values.

Parameters
fileNamethe file whose header will be read
hdunamethe name of the HDU to read
typetype of FITS header to match. Defaults to ANY_HDU
hduverversion of HDU header to match, defaults to 0 (version ignored)
stripif true, common FITS keys that usually have non-metadata intepretations (e.g. NAXIS, BITPIX) will be ignored.

Definition at line 1693 of file fits.cc.

1694 {
1695 return detail::_readMetadata(fileName, strip, hduname, type, hduver);
1696}

◆ scalingAlgorithmFromString()

ImageScalingOptions::ScalingAlgorithm lsst::afw::fits::scalingAlgorithmFromString ( std::string const & name)

Interpret scaling algorithm expressed in string.

Definition at line 98 of file fitsCompression.cc.

98 {
99 if (name == "NONE") return ImageScalingOptions::NONE;
100 if (name == "RANGE") return ImageScalingOptions::RANGE;
101 if (name == "STDEV_POSITIVE") return ImageScalingOptions::STDEV_POSITIVE;
102 if (name == "STDEV_NEGATIVE") return ImageScalingOptions::STDEV_NEGATIVE;
103 if (name == "STDEV_BOTH") return ImageScalingOptions::STDEV_BOTH;
104 if (name == "MANUAL") return ImageScalingOptions::MANUAL;
105 throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Unrecognized scaling algorithm: " + name);
106}

◆ scalingAlgorithmToString()

std::string lsst::afw::fits::scalingAlgorithmToString ( ImageScalingOptions::ScalingAlgorithm algorithm)

Provide string version of compression algorithm.

Definition at line 108 of file fitsCompression.cc.

108 {
109 switch (algorithm) {
110 case ImageScalingOptions::NONE:
111 return "NONE";
112 case ImageScalingOptions::RANGE:
113 return "RANGE";
114 case ImageScalingOptions::STDEV_POSITIVE:
115 return "STDEV_POSITIVE";
116 case ImageScalingOptions::STDEV_NEGATIVE:
117 return "STDEV_NEGATIVE";
118 case ImageScalingOptions::STDEV_BOTH:
119 return "STDEV_BOTH";
120 case ImageScalingOptions::MANUAL:
121 return "MANUAL";
122 default:
124 os << "Unrecognized scaling algorithm: " << algorithm;
126 }
127}

◆ setAllowImageCompression()

void lsst::afw::fits::setAllowImageCompression ( bool allow)

Definition at line 1566 of file fits.cc.

1566{ allowImageCompression = allow; }

Variable Documentation

◆ DEFAULT_HDU

const int lsst::afw::fits::DEFAULT_HDU = INT_MIN

Specify that the default HDU should be read.

This special HDU number indicates that the first extension should be used if the primary HDU is empty (i.e., has NAXIS=0) and the Primary HDU is the current.

Definition at line 18 of file fitsDefaults.h.