LSSTApplications  19.0.0-16-gf391218+0d4bdb7e99,20.0.0-11-g973f35b+fc3da11c03,20.0.0-18-g2b8c1f54+f8fc1aa9fb,20.0.0-2-g103fe59+1a747c5cf5,20.0.0-2-g1367e85+b8fe48c8a0,20.0.0-2-g7f82c8f+cb8155b8e8,20.0.0-2-g8dde007+aaa4e16c0f,20.0.0-2-ga326454+cb8155b8e8,20.0.0-2-ga51b5d4+6432c6fd8d,20.0.0-2-gde069b7+44dbdb3492,20.0.0-2-gfc62afb+b8fe48c8a0,20.0.0-20-g54e6697de+ce03d725a7,20.0.0-22-g54e2caa+e2d4a7822a,20.0.0-25-g5eafb0f+f4a3e7a5aa,20.0.0-28-g73474ed+96410ea1f8,20.0.0-3-g5242d73+b8fe48c8a0,20.0.0-3-ga63a54e+af87b3138b,20.0.0-30-g597c966+cf8eea114e,20.0.0-4-g2909d54+37efb4748c,20.0.0-4-g35ce6d5+f4a3e7a5aa,20.0.0-4-g45278ab+d529cf1a41,20.0.0-4-g4bc9b9f+a7376eab67,20.0.0-4-g66bcc37+f4a3e7a5aa,20.0.0-4-ge17e5af+b8fe48c8a0,20.0.0-4-gecfae73+77584f1b13,20.0.0-4-gf910f65+37efb4748c,20.0.0-46-gd70f10e1+f17cbaf3d1,20.0.0-5-g8f08a60+4fac22bdb7,20.0.0-5-ga885a99+c1363b8d99,20.0.0-5-gc738bc1+47717dd73f,20.0.0-5-gfbfe500+d529cf1a41,20.0.0-6-gd222c45+88b21af515,20.0.0-6-gdef485e+46cd8289a4,20.0.0-7-gaa929c8+96410ea1f8,20.0.0-74-g0218c7a+939693069d,20.0.0-8-g5dd23de+1834535a4e,20.0.0-8-ge712728+fb4ad641b9,20.0.0-9-g5051ac2+d529cf1a41,w.2020.48-1-gdf601d2
LSSTDataManagementBasePackage
Namespaces | Classes | Functions | Variables
lsst::afw::fits Namespace Reference

Namespaces

 compression
 
 detail
 
 fitsContinued
 
 fitsLib
 
 pickleFits
 

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...
 

Functions

std::string makeErrorMessage (std::string const &fileName="", int status=0, std::string const &msg="")
 Return an error message reflecting FITS I/O errors. More...
 
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. More...
 
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. More...
 
template<typename T >
int getBitPix ()
 Return the cfitsio integer BITPIX code for the given data type. More...
 
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. More...
 
std::shared_ptr< daf::base::PropertyListcombineMetadata (std::shared_ptr< const daf::base::PropertyList > first, std::shared_ptr< const daf::base::PropertyList > second)
 Combine two sets of metadata in a FITS-appropriate fashion. More...
 
std::shared_ptr< daf::base::PropertyListreadMetadata (std::string const &fileName, int hdu=DEFAULT_HDU, bool strip=false)
 Read FITS header. More...
 
std::shared_ptr< daf::base::PropertyListreadMetadata (fits::MemFileManager &manager, int hdu=DEFAULT_HDU, bool strip=false)
 Read FITS header. More...
 
std::shared_ptr< daf::base::PropertyListreadMetadata (fits::Fits &fitsfile, bool strip=false)
 Read FITS header. More...
 
void setAllowImageCompression (bool allow)
 
bool getAllowImageCompression ()
 
ImageCompressionOptions::CompressionAlgorithm compressionAlgorithmFromString (std::string const &name)
 Interpret compression algorithm expressed in string. More...
 
std::string compressionAlgorithmToString (ImageCompressionOptions::CompressionAlgorithm algorithm)
 Provide string version of compression algorithm. More...
 
ImageCompressionOptions::CompressionAlgorithm compressionAlgorithmFromCfitsio (int cfitsio)
 Convert compression algorithm from cfitsio to ImageCompressionOptions::CompressionAlgorithm. More...
 
int compressionAlgorithmToCfitsio (ImageCompressionOptions::CompressionAlgorithm algorithm)
 Convert ImageCompressionOptions::CompressionAlgorithm to cfitsio. More...
 
ImageScalingOptions::ScalingAlgorithm scalingAlgorithmFromString (std::string const &name)
 Interpret scaling algorithm expressed in string. More...
 
std::string scalingAlgorithmToString (ImageScalingOptions::ScalingAlgorithm algorithm)
 Provide string version of compression algorithm. More...
 
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. More...
 

Function Documentation

◆ combineMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::fits::combineMetadata ( std::shared_ptr< const daf::base::PropertyList first,
std::shared_ptr< const daf::base::PropertyList 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 1628 of file fits.cc.

1630  {
1631  auto combined = std::make_shared<daf::base::PropertyList>();
1632  bool const asScalar = true;
1633  for (auto const &name : first->getOrderedNames()) {
1634  auto const iscv = isCommentIsValid(*first, name);
1635  if (iscv.isComment) {
1636  if (iscv.isValid) {
1637  combined->add<std::string>(name, first->getArray<std::string>(name));
1638  }
1639  } else {
1640  combined->copy(name, first, name, asScalar);
1641  }
1642  }
1643  for (auto const &name : second->getOrderedNames()) {
1644  auto const iscv = isCommentIsValid(*second, name);
1645  if (iscv.isComment) {
1646  if (iscv.isValid) {
1647  combined->add<std::string>(name, second->getArray<std::string>(name));
1648  }
1649  } else {
1650  // `copy` will replace an item, even if has a different type, so no need to call `remove`
1651  combined->copy(name, second, name, asScalar);
1652  }
1653  }
1654  return combined;
1655 }

◆ compressionAlgorithmFromCfitsio()

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

Convert compression algorithm from cfitsio to ImageCompressionOptions::CompressionAlgorithm.

Definition at line 50 of file fitsCompression.cc.

50  {
51  switch (cfitsio) {
52  case 0:
53  return ImageCompressionOptions::NONE;
54  case RICE_1:
55  return ImageCompressionOptions::RICE;
56  case GZIP_1:
57  return ImageCompressionOptions::GZIP;
58  case GZIP_2:
59  return ImageCompressionOptions::GZIP_SHUFFLE;
60  case PLIO_1:
61  return ImageCompressionOptions::PLIO;
62  case HCOMPRESS_1:
63  throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
64  "Unsupported compression algorithm: HCOMPRESS_1");
65  default:
67  os << "Unrecognized cfitsio compression: " << cfitsio;
68  throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, os.str());
69  }
70 }

◆ compressionAlgorithmFromString()

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

Interpret compression algorithm expressed in string.

Definition at line 20 of file fitsCompression.cc.

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

◆ compressionAlgorithmToCfitsio()

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

Convert ImageCompressionOptions::CompressionAlgorithm to cfitsio.

Definition at line 72 of file fitsCompression.cc.

72  {
73  switch (algorithm) {
74  case ImageCompressionOptions::NONE:
75  return 0;
76  case ImageCompressionOptions::GZIP:
77  return GZIP_1;
78  case ImageCompressionOptions::GZIP_SHUFFLE:
79  return GZIP_2;
80  case ImageCompressionOptions::RICE:
81  return RICE_1;
82  case ImageCompressionOptions::PLIO:
83  return PLIO_1;
84  default:
86  os << "Unrecognized compression algorithm: " << algorithm;
87  throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, os.str());
88  }
89 }

◆ compressionAlgorithmToString()

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

Provide string version of compression algorithm.

Definition at line 31 of file fitsCompression.cc.

31  {
32  switch (algorithm) {
33  case ImageCompressionOptions::NONE:
34  return "NONE";
35  case ImageCompressionOptions::GZIP:
36  return "GZIP";
37  case ImageCompressionOptions::GZIP_SHUFFLE:
38  return "GZIP_SHUFFLE";
39  case ImageCompressionOptions::RICE:
40  return "RICE";
41  case ImageCompressionOptions::PLIO:
42  return "PLIO";
43  default:
45  os << "Unrecognized compression algorithm: " << algorithm;
46  throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, os.str());
47  }
48 }

◆ getAllowImageCompression()

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

Definition at line 1548 of file fits.cc.

1548 { 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 490 of file fits.cc.

490  {
491  return FitsBitPix<T>::CONSTANT;
492 }

◆ 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 208 of file fits.h.

208  {
209  ndarray::Array<T const, N, N> contiguous = ndarray::dynamic_dimension_cast<N>(array);
210  if (contiguous.empty()) contiguous = ndarray::copy(array);
211  return contiguous;
212 }

◆ 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 }

◆ 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 426 of file fits.cc.

426  {
428  os << "cfitsio error";
429  if (fileName != "") {
430  os << " (" << fileName << ")";
431  }
432  if (status != 0) {
433  char fitsErrMsg[FLEN_ERRMSG];
434  fits_get_errstatus(status, fitsErrMsg);
435  os << ": " << fitsErrMsg << " (" << status << ")";
436  }
437  if (msg != "") {
438  os << " : " << msg;
439  }
440  os << "\ncfitsio error stack:\n";
441  char cfitsioMsg[FLEN_ERRMSG];
442  while (fits_read_errmsg(cfitsioMsg) != 0) {
443  os << " " << cfitsioMsg << "\n";
444  }
445  return os.str();
446 }

◆ 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 448 of file fits.cc.

448  {
449  std::string fileName = "";
450  fitsfile *fd = reinterpret_cast<fitsfile *>(fptr);
451  if (fd != 0 && fd->Fptr != 0 && fd->Fptr->filename != 0) {
452  fileName = fd->Fptr->filename;
453  }
454  return makeErrorMessage(fileName, status, msg);
455 }

◆ 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 457 of file fits.cc.

458  {
459  daf::base::PropertyList const *pl = dynamic_cast<daf::base::PropertyList const *>(&metadata);
460  std::vector<std::string> allParamNames;
461  if (pl) {
462  allParamNames = pl->getOrderedNames();
463  } else {
464  allParamNames = metadata.paramNames(false);
465  }
466  std::vector<std::string> desiredParamNames;
467  for (auto const &name : allParamNames) {
468  if (excludeNames.count(name) == 0) {
469  desiredParamNames.push_back(name);
470  }
471  }
472  return makeLimitedFitsHeaderImpl(desiredParamNames, metadata);
473 }

◆ readMetadata() [1/3]

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 1669 of file fits.cc.

1669  {
1670  auto metadata = std::make_shared<lsst::daf::base::PropertyList>();
1671  fitsfile.readMetadata(*metadata, strip);
1672  // if INHERIT=T, we want to also include header entries from the primary HDU
1673  int oldHdu = fitsfile.getHdu();
1674  if (oldHdu != 0 && metadata->exists("INHERIT")) {
1675  bool inherit = false;
1676  if (metadata->typeOf("INHERIT") == typeid(std::string)) {
1677  inherit = (metadata->get<std::string>("INHERIT") == "T");
1678  } else {
1679  inherit = metadata->get<bool>("INHERIT");
1680  }
1681  if (strip) metadata->remove("INHERIT");
1682  if (inherit) {
1683  HduMoveGuard guard(fitsfile, 0);
1684  // Combine the metadata from the primary HDU with the metadata from the specified HDU,
1685  // with non-comment values from the specified HDU superseding those in the primary HDU
1686  // and comments from the specified HDU appended to comments from the primary HDU
1687  auto primaryHduMetadata = std::make_shared<daf::base::PropertyList>();
1688  fitsfile.readMetadata(*primaryHduMetadata, strip);
1689  metadata = combineMetadata(primaryHduMetadata, metadata);
1690  } else {
1691  // Purge invalid values
1692  auto const emptyMetadata = std::make_shared<lsst::daf::base::PropertyList>();
1693  metadata = combineMetadata(metadata, emptyMetadata);
1694  }
1695  }
1696  return metadata;
1697 }

◆ readMetadata() [2/3]

std::shared_ptr< daf::base::PropertyList > 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 1663 of file fits.cc.

1663  {
1664  fits::Fits fp(manager, "r", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
1665  fp.setHdu(hdu);
1666  return readMetadata(fp, strip);
1667 }

◆ readMetadata() [3/3]

std::shared_ptr< daf::base::PropertyList > 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 1657 of file fits.cc.

1657  {
1658  fits::Fits fp(fileName, "r", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
1659  fp.setHdu(hdu);
1660  return readMetadata(fp, strip);
1661 }

◆ scalingAlgorithmFromString()

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

Interpret scaling algorithm expressed in string.

Definition at line 99 of file fitsCompression.cc.

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

◆ scalingAlgorithmToString()

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

Provide string version of compression algorithm.

Definition at line 109 of file fitsCompression.cc.

109  {
110  switch (algorithm) {
111  case ImageScalingOptions::NONE:
112  return "NONE";
113  case ImageScalingOptions::RANGE:
114  return "RANGE";
115  case ImageScalingOptions::STDEV_POSITIVE:
116  return "STDEV_POSITIVE";
117  case ImageScalingOptions::STDEV_NEGATIVE:
118  return "STDEV_NEGATIVE";
119  case ImageScalingOptions::STDEV_BOTH:
120  return "STDEV_BOTH";
121  case ImageScalingOptions::MANUAL:
122  return "MANUAL";
123  default:
125  os << "Unrecognized scaling algorithm: " << algorithm;
126  throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, os.str());
127  }
128 }

◆ setAllowImageCompression()

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

Definition at line 1546 of file fits.cc.

1546 { 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.

lsst::afw::fits::readMetadata
std::shared_ptr< daf::base::PropertyList > readMetadata(std::string const &fileName, int hdu=DEFAULT_HDU, bool strip=false)
Read FITS header.
Definition: fits.cc:1657
lsst::afw::fits::makeErrorMessage
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:426
std::string
STL class.
lsst::afw::table._match.second
second
Definition: _match.py:76
std::vector< std::string >
lsst::afw::fits::combineMetadata
std::shared_ptr< daf::base::PropertyList > combineMetadata(std::shared_ptr< const daf::base::PropertyList > first, std::shared_ptr< const daf::base::PropertyList > second)
Combine two sets of metadata in a FITS-appropriate fashion.
Definition: fits.cc:1628
lsst::afw::table._match.first
first
Definition: _match.py:74
strip
bool strip
Definition: fits.cc:911
lsst::afw::geom.transform.transformContinued.name
string name
Definition: transformContinued.py:32
std::vector::push_back
T push_back(T... args)
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
std::ostringstream
STL class.
os
std::ostream * os
Definition: Schema.cc:746
std::set::count
T count(T... args)
lsst::afw::fits::makeErrorMessage
std::string makeErrorMessage(void *fptr, int status, boost::format const &msg)
Definition: fits.h:79