lsst.afw  21.0.0-11-ga6ea59e8e+47cba9fc36
ExposureFitsReader.cc
Go to the documentation of this file.
1 /*
2  * Developed for the LSST Data Management System.
3  * This product includes software developed by the LSST Project
4  * (https://www.lsst.org).
5  * See the COPYRIGHT file at the top-level directory of this distribution
6  * for details of code ownership.
7  *
8  * This program is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program. If not, see <https://www.gnu.org/licenses/>.
20  */
21 
22 #include <map>
23 #include <regex>
24 #include <set>
25 
26 #include "lsst/log/Log.h"
27 
30 #include "lsst/afw/geom/SkyWcs.h"
33 #include "lsst/afw/detection/Psf.h"
36 
37 namespace lsst {
38 namespace afw {
39 namespace image {
40 
41 namespace {
42 
43 LOG_LOGGER _log = LOG_GET("afw.image.fits.ExposureFitsReader");
44 
45 template <typename T, std::size_t N>
46 bool _contains(std::array<T, N> const& array, T const& value) {
47  for (T const& element : array) {
48  if (element == value) {
49  return true;
50  }
51  }
52  return false;
53 }
54 
55 // Map from compatibility "afw name" to correct filter label
56 std::map<std::string, FilterLabel> const _AFW_NAMES = {
57  std::make_pair("r2", FilterLabel::fromBandPhysical("r", "HSC-R2")),
58  std::make_pair("i2", FilterLabel::fromBandPhysical("i", "HSC-I2")),
59  std::make_pair("SOLID", FilterLabel::fromPhysical("solid plate 0.0 0.0")),
60 };
61 
67 bool _isBand(std::string const& name) {
68  static std::set<std::string> const BANDS = {"u", "g", "r", "i", "z", "y", "SH", "PH", "VR", "white"};
69  // Standard band
70  if (BANDS.count(name) > 0) {
71  return true;
72  }
73  // Looks like a narrow-band band
74  if (std::regex_match(name, std::regex("N\\d+"))) {
75  return true;
76  }
77  // Looks like an intermediate-band band; exclude "I2"
78  if (std::regex_match(name, std::regex("I\\d{2,}"))) {
79  return true;
80  }
81  return false;
82 }
83 
84 } // namespace
85 
95  static Filter const DEFAULT;
96  // Avoid turning dummy filters into real FilterLabels.
97  if (name == DEFAULT.getName()) {
98  return nullptr;
99  }
100 
101  // FilterLabel::from* returns a statically allocated object, so only way
102  // to get it into shared_ptr is to copy it.
103  if (_isBand(name)) {
104  return std::make_shared<FilterLabel>(FilterLabel::fromBand(name));
105  } else {
106  return std::make_shared<FilterLabel>(FilterLabel::fromPhysical(name));
107  }
108 }
109 
120 // TODO: compatibility code to be removed in DM-27177
122  static Filter const DEFAULT;
123  // Avoid turning dummy filters into real FilterLabels.
124  // Default filter has id=UNKNOWN, but others do too.
125  if (filter.getId() == DEFAULT.getId() && filter.getName() == DEFAULT.getName()) {
126  return nullptr;
127  }
128 
129  // Filter has no self-consistency guarantees whatsoever, and most methods
130  // are unsafe. Program extremely defensively.
131  if (filter.getId() == Filter::UNKNOWN) {
132  // Not a registered filter; guarantees on canonical name do not apply
133  return makeFilterLabelDirect(filter.getName());
134  }
135 
136  // obs.base.FilterDefinition ensures the canonical name is the first defined
137  // of afwname, band name, physical filter name.
138  std::string canonical;
139  try {
140  canonical = filter.getCanonicalName();
141  } catch (pex::exceptions::NotFoundError const&) {
142  // Not a registered filter; guarantees on canonical name do not apply
143  return makeFilterLabelDirect(filter.getName());
144  }
145 
146  if (_AFW_NAMES.count(canonical) > 0) {
147  return std::make_shared<FilterLabel>(_AFW_NAMES.at(canonical));
148  } else if (_isBand(canonical)) {
149  // physical filter is one of the aliases, but can't tell which one
150  // (FilterDefinition helpfully sorts them). Safer to leave it blank.
151  std::vector<std::string> aliases;
152  try {
153  aliases = filter.getAliases();
154  } catch (pex::exceptions::NotFoundError const&) {
155  // No aliases; leave the vector empty
156  }
157  if (aliases.size() == 1) {
158  return std::make_shared<FilterLabel>(FilterLabel::fromBandPhysical(canonical, aliases.front()));
159  } else {
160  return std::make_shared<FilterLabel>(FilterLabel::fromBand(canonical));
161  }
162  } else {
163  return std::make_shared<FilterLabel>(FilterLabel::fromPhysical(canonical));
164  }
165 }
166 
178  if (_AFW_NAMES.count(name) > 0) {
179  return std::make_shared<FilterLabel>(_AFW_NAMES.at(name));
180  }
181  // else name is either a band, a physical filter, or a deprecated alias
182 
183  try {
184  // To ease the transition to FilterLabel, use Filter to get all the names
185  // TODO: after DM-27177, leave only the catch block
186  Filter filter(name, false);
187  std::shared_ptr<FilterLabel> converted = makeFilterLabel(filter);
188  // Make use of the extra information that `name` is a preferred name
189  // If name is not a band, it is likely the physical filter
190  if (converted && !converted->hasPhysicalLabel() && converted->hasBandLabel() &&
191  name != converted->getBandLabel()) {
192  return std::make_shared<FilterLabel>(
194  } else {
195  return converted;
196  }
197  } catch (pex::exceptions::NotFoundError const&) {
198  // Unknown filter, no extra info to be gained
199  return makeFilterLabelDirect(name);
200  }
201 }
202 
211  // Filters still have standard aliases, so can use almost any name to define them.
212  // Prefer afw_name or band because that's what most code assumes is Filter.getName().
213  for (auto const& keyValue : _AFW_NAMES) {
214  std::string const& afwName = keyValue.first;
215  FilterLabel const& afwFilter = keyValue.second;
216  if (label == afwFilter) {
217  return Filter(afwName);
218  }
219  }
220 
221  if (label.hasBandLabel()) {
222  return Filter(label.getBandLabel(), true);
223  } else {
224  // FilterLabel guarantees at least one of band or physical is defined.
225  return Filter(label.getPhysicalLabel(), true);
226  }
227 }
228 
230 public:
234  if (primaryMetadata->exists(versionName)) {
235  version = primaryMetadata->getAsInt(versionName);
236  primaryMetadata->remove(versionName);
237  } else {
238  version = 0; // unversioned files are implicitly version 0
239  }
242  str(boost::format("Cannot read Exposure FITS version >= %i") %
244  }
245 
246  // Try to read WCS from image metadata, and if found, strip the keywords used
247  try {
248  wcs = afw::geom::makeSkyWcs(*imageMetadata, true);
249  } catch (lsst::pex::exceptions::TypeError const&) {
250  LOGLS_DEBUG(_log, "No WCS found in FITS metadata");
251  }
252  if (wcs && any(xy0.ne(lsst::geom::Point2I(0, 0)))) {
253  wcs = wcs->copyAtShiftedPixelOrigin(lsst::geom::Extent2D(xy0));
254  }
255 
256  // Strip LTV1, LTV2 from imageMetadata, because we don't use it internally
257  imageMetadata->remove("LTV1");
258  imageMetadata->remove("LTV2");
259 
260  if (!imageMetadata->exists("INHERIT")) {
261  // New-style exposures put everything but the Wcs in the primary HDU, use
262  // INHERIT keyword in the others. For backwards compatibility, if we don't
263  // find the INHERIT keyword, we ignore the primary HDU metadata and expect
264  // everything to be in the image HDU metadata. Note that we can't merge them,
265  // because they're probably duplicates.
266  metadata = imageMetadata;
267  } else {
268  metadata = primaryMetadata;
269  }
270 
271  // Earlier versions persisted Filter as header keyword, version 2 persists FilterLabel as a Storable
272  if (version < 2) {
273  std::string key = "FILTER";
274  if (metadata->exists(key)) {
275  // Original Filter code depended on Boost for string trimming.
276  // DIY to avoid making this module depend on Boost.
277  std::string name = metadata->getAsString(key);
278  size_t end = name.find_last_not_of(' ');
279  filterLabel = makeFilterLabel(name.substr(0, end + 1));
280  }
281  }
282 
283  visitInfo = std::make_shared<VisitInfo>(*metadata);
285 
286  // Version 0 persisted Calib FLUXMAG0 in the metadata, >=1 persisted PhotoCalib as a binary table.
287  if (version == 0) {
289  }
290 
291  // Strip MJD-OBS and DATE-OBS from metadata; those may be read by
292  // either SkyWcs or VisitInfo or both, so neither can strip them.
293  metadata->remove("MJD-OBS");
294  metadata->remove("DATE-OBS");
295 
296  // Strip DETSER, DETNAME; these are added when writing an Exposure
297  // with a Detector
298  metadata->remove("DETNAME");
299  metadata->remove("DETSER");
300  }
301 
302  int version;
308 };
309 
311 public:
312  enum Component {
313  PSF = 0,
322  };
323 
325  auto popInt = [&metadata](std::string const& name) {
326  // The default of zero will cause archive.get to return a
327  // null/empty pointer, just as if a null/empty pointer was
328  // originally written to the archive.
329  int r = 0;
330  if (metadata.exists(name)) {
331  r = metadata.get<int>(name);
332  // We remove metadata entries to maintaing our practice
333  // of stripped metadata entries that have been used to
334  // construct more structured components.
335  metadata.remove(name);
336  }
337  return r;
338  };
339  _hdu = popInt("AR_HDU");
340  if (_hdu == 0) {
341  _state = ArchiveState::MISSING;
342  } else {
343  --_hdu; // Switch from FITS 1-indexed convention to LSST 0-indexed convention.
344  _state = ArchiveState::PRESENT;
345  }
346  // Read in traditional components using old-style IDs, for backwards compatibility
347  _ids[PSF] = popInt("PSF_ID");
348  _ids[WCS] = popInt("SKYWCS_ID");
349  _ids[COADD_INPUTS] = popInt("COADD_INPUTS_ID");
350  _ids[AP_CORR_MAP] = popInt("AP_CORR_MAP_ID");
351  _ids[VALID_POLYGON] = popInt("VALID_POLYGON_ID");
352  _ids[TRANSMISSION_CURVE] = popInt("TRANSMISSION_CURVE_ID");
353  _ids[DETECTOR] = popInt("DETECTOR_ID");
354  _ids[PHOTOCALIB] = popInt("PHOTOCALIB_ID");
355 
356  // "Extra" components use a different keyword convention to avoid collisions with non-persistence IDs
357  std::vector<std::string> toStrip;
358  for (std::string const& headerKey : metadata) {
359  static std::string const PREFIX = "ARCHIVE_ID_";
360  if (headerKey.substr(0, PREFIX.size()) == PREFIX) {
361  std::string componentName = headerKey.substr(PREFIX.size());
362  int archiveId = metadata.get<int>(headerKey);
363  _genericIds.emplace(componentName, archiveId);
364  if (!_contains(_ids, archiveId)) {
365  _extraIds.emplace(componentName);
366  }
367  toStrip.push_back(headerKey);
368  toStrip.push_back(componentName + "_ID"); // strip corresponding old-style ID, if it exists
369  }
370  }
371  for (std::string const& key : toStrip) {
372  metadata.remove(key);
373  }
374  }
375 
385  template <typename T>
387  if (!_ensureLoaded(fitsFile)) {
388  return nullptr;
389  }
390  return _archive.get<T>(_ids[c]);
391  }
392 
409  // This method takes a string instead of a strongly typed Key because
410  // readExtraComponents() gets its keys from the FITS metadata.
411  // Using a Key would make the calling code more complicated.
412  template <typename T>
414  if (!_ensureLoaded(fitsFile)) {
415  return nullptr;
416  }
417 
418  if (_genericIds.count(c) > 0) {
419  int archiveId = _genericIds.at(c);
420  return _archive.get<T>(archiveId);
421  } else {
422  return nullptr;
423  }
424  }
425 
436  afw::fits::Fits* fitsFile) {
438 
439  if (!_ensureLoaded(fitsFile)) {
440  return result;
441  }
442 
443  // Not safe to call getAll if a component cannot be unpersisted
444  // Instead, look for the archives registered in the metadata
445  for (std::string const& componentName : _extraIds) {
446  try {
447  result.emplace(componentName, readComponent<table::io::Persistable>(fitsFile, componentName));
448  } catch (pex::exceptions::NotFoundError const& err) {
449  LOGLS_WARN(_log,
450  "Could not read component " << componentName << "; skipping: " << err.what());
451  }
452  }
453  return result;
454  }
455 
456 private:
457  bool _ensureLoaded(afw::fits::Fits* fitsFile) {
458  if (_state == ArchiveState::MISSING) {
459  return false;
460  }
461  if (_state == ArchiveState::PRESENT) {
462  afw::fits::HduMoveGuard guard(*fitsFile, _hdu);
463  _archive = table::io::InputArchive::readFits(*fitsFile);
464  _state = ArchiveState::LOADED;
465  }
466  assert(_state == ArchiveState::LOADED); // constructor body should guarantee it's not UNKNOWN
467  return true;
468  }
469 
470  enum class ArchiveState { UNKNOWN, MISSING, PRESENT, LOADED };
471 
472  int _hdu = 0;
473  ArchiveState _state = ArchiveState::UNKNOWN;
474  table::io::InputArchive _archive;
476  std::map<std::string, int> _genericIds;
477  std::set<std::string> _extraIds; // _genericIds not included in _ids
478 };
479 
480 ExposureFitsReader::ExposureFitsReader(std::string const& fileName) : _maskedImageReader(fileName) {}
481 
482 ExposureFitsReader::ExposureFitsReader(fits::MemFileManager& manager) : _maskedImageReader(manager) {}
483 
484 ExposureFitsReader::ExposureFitsReader(fits::Fits* fitsFile) : _maskedImageReader(fitsFile) {}
485 
486 ExposureFitsReader::~ExposureFitsReader() noexcept = default;
487 
488 lsst::geom::Box2I ExposureFitsReader::readBBox(ImageOrigin origin) {
489  return _maskedImageReader.readBBox(origin);
490 }
491 
493  return _maskedImageReader.readXY0(bbox, origin);
494 }
495 
496 std::string ExposureFitsReader::readImageDType() const { return _maskedImageReader.readImageDType(); }
497 
498 std::string ExposureFitsReader::readMaskDType() const { return _maskedImageReader.readMaskDType(); }
499 
501 
503  _ensureReaders();
504  return _metadataReader->metadata;
505 }
506 
508  _ensureReaders();
509  auto r = _archiveReader->readComponent<afw::geom::SkyWcs>(_getFitsFile(), ArchiveReader::WCS);
510  if (!r) {
511  r = _metadataReader->wcs;
512  }
513  return r;
514 }
515 
518  if (label) {
519  return makeFilter(*label);
520  } else {
521  // Old exposures always had a Filter, even if only the default
522  return Filter();
523  }
524 }
525 
527  _ensureReaders();
528  if (_metadataReader->version < 2) {
529  return _metadataReader->filterLabel;
530  } else {
531  return _archiveReader->readComponent<FilterLabel>(_getFitsFile(), ExposureInfo::KEY_FILTER.getId());
532  }
533 }
534 
536  _ensureReaders();
537  if (_metadataReader->version == 0) {
538  return _metadataReader->photoCalib;
539  } else {
540  return _archiveReader->readComponent<image::PhotoCalib>(_getFitsFile(), ArchiveReader::PHOTOCALIB);
541  }
542 }
543 
545  _ensureReaders();
546  return _archiveReader->readComponent<detection::Psf>(_getFitsFile(), ArchiveReader::PSF);
547 }
548 
550  _ensureReaders();
551  return _archiveReader->readComponent<afw::geom::polygon::Polygon>(_getFitsFile(),
553 }
554 
556  _ensureReaders();
557  return _archiveReader->readComponent<ApCorrMap>(_getFitsFile(), ArchiveReader::AP_CORR_MAP);
558 }
559 
561  _ensureReaders();
562  return _archiveReader->readComponent<CoaddInputs>(_getFitsFile(), ArchiveReader::COADD_INPUTS);
563 }
564 
566  _ensureReaders();
567  return _metadataReader->visitInfo;
568 }
569 
571  _ensureReaders();
572  return _archiveReader->readComponent<TransmissionCurve>(_getFitsFile(),
574 }
575 
577  _ensureReaders();
578  return _archiveReader->readComponent<cameraGeom::Detector>(_getFitsFile(), ArchiveReader::DETECTOR);
579 }
580 
582  _ensureReaders();
583  return _archiveReader->readComponent<typehandling::Storable>(_getFitsFile(), componentName);
584 }
585 
587  _ensureReaders();
588  return _archiveReader->readExtraComponents(_getFitsFile());
589 }
590 
592  auto result = std::make_shared<ExposureInfo>();
593  result->setMetadata(readMetadata());
594  result->setPhotoCalib(readPhotoCalib());
595  result->setVisitInfo(readVisitInfo());
596  // When reading an ExposureInfo (as opposed to reading individual
597  // components), we warn and try to proceed when a component is present
598  // but can't be read due its serialization factory not being set up
599  // (that's what throws the NotFoundErrors caught below).
600  try {
601  result->setPsf(readPsf());
602  } catch (pex::exceptions::NotFoundError& err) {
603  LOGLS_WARN(_log, "Could not read PSF; setting to null: " << err.what());
604  }
605  try {
606  result->setCoaddInputs(readCoaddInputs());
607  } catch (pex::exceptions::NotFoundError& err) {
608  LOGLS_WARN(_log, "Could not read CoaddInputs; setting to null: " << err.what());
609  }
610  try {
611  result->setApCorrMap(readApCorrMap());
612  } catch (pex::exceptions::NotFoundError& err) {
613  LOGLS_WARN(_log, "Could not read ApCorrMap; setting to null: " << err.what());
614  }
615  try {
616  result->setValidPolygon(readValidPolygon());
617  } catch (pex::exceptions::NotFoundError& err) {
618  LOGLS_WARN(_log, "Could not read ValidPolygon; setting to null: " << err.what());
619  }
620  try {
621  result->setTransmissionCurve(readTransmissionCurve());
622  } catch (pex::exceptions::NotFoundError& err) {
623  LOGLS_WARN(_log, "Could not read TransmissionCurve; setting to null: " << err.what());
624  }
625  try {
626  result->setDetector(readDetector());
627  } catch (pex::exceptions::NotFoundError& err) {
628  LOGLS_WARN(_log, "Could not read Detector; setting to null: " << err.what());
629  }
630  // In the case of WCS, we fall back to the metadata WCS if the one from
631  // the archive can't be read.
632  _ensureReaders();
633  result->setWcs(_metadataReader->wcs);
634  try {
635  auto wcs = _archiveReader->readComponent<afw::geom::SkyWcs>(_getFitsFile(), ArchiveReader::WCS);
636  if (!wcs) {
637  LOGLS_DEBUG(_log, "No WCS found in binary table");
638  } else {
639  result->setWcs(wcs);
640  }
641  } catch (pex::exceptions::NotFoundError& err) {
642  auto msg = str(boost::format("Could not read WCS extension; setting to null: %s") % err.what());
643  if (result->hasWcs()) {
644  msg += " ; using WCS from FITS header";
645  }
646  LOGLS_WARN(_log, msg);
647  }
648  for (auto keyValue : readExtraComponents()) {
650  std::string key = keyValue.first;
651  StorablePtr object = std::dynamic_pointer_cast<StorablePtr::element_type>(keyValue.second);
652 
653  if (object.use_count() > 0) { // Failed cast guarantees empty pointer, but not a null one
654  result->setComponent(typehandling::makeKey<StorablePtr>(key), object);
655  } else {
656  LOGLS_WARN(_log, "Data corruption: generic component " << key << " is not a Storable; skipping.");
657  }
658  }
659  // Convert old-style Filter to new-style FilterLabel
660  // In newer versions this is handled by readExtraComponents()
661  if (_metadataReader->version < 2 && !result->hasFilterLabel()) {
662  result->setFilterLabel(readFilterLabel());
663  }
664  return result;
665 } // namespace image
666 
667 template <typename ImagePixelT>
669  bool allowUnsafe) {
670  return _maskedImageReader.readImage<ImagePixelT>(bbox, origin, allowUnsafe);
671 }
672 
673 template <typename ImagePixelT>
674 ndarray::Array<ImagePixelT, 2, 2> ExposureFitsReader::readImageArray(lsst::geom::Box2I const& bbox,
675  ImageOrigin origin, bool allowUnsafe) {
676  return _maskedImageReader.readImageArray<ImagePixelT>(bbox, origin, allowUnsafe);
677 }
678 
679 template <typename MaskPixelT>
681  bool conformMasks, bool allowUnsafe) {
682  return _maskedImageReader.readMask<MaskPixelT>(bbox, origin, conformMasks, allowUnsafe);
683 }
684 
685 template <typename MaskPixelT>
686 ndarray::Array<MaskPixelT, 2, 2> ExposureFitsReader::readMaskArray(lsst::geom::Box2I const& bbox,
687  ImageOrigin origin, bool allowUnsafe) {
688  return _maskedImageReader.readMaskArray<MaskPixelT>(bbox, origin, allowUnsafe);
689 }
690 
691 template <typename VariancePixelT>
693  bool allowUnsafe) {
694  return _maskedImageReader.readVariance<VariancePixelT>(bbox, origin, allowUnsafe);
695 }
696 
697 template <typename VariancePixelT>
698 ndarray::Array<VariancePixelT, 2, 2> ExposureFitsReader::readVarianceArray(lsst::geom::Box2I const& bbox,
699  ImageOrigin origin,
700  bool allowUnsafe) {
701  return _maskedImageReader.readVarianceArray<VariancePixelT>(bbox, origin, allowUnsafe);
702 }
703 
704 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
706  lsst::geom::Box2I const& bbox, ImageOrigin origin, bool conformMasks, bool allowUnsafe) {
707  return _maskedImageReader.read<ImagePixelT, MaskPixelT, VariancePixelT>(bbox, origin, conformMasks,
708  /* needAllHdus= */ false,
709  allowUnsafe);
710 }
711 
712 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
714  ImageOrigin origin,
715  bool conformMasks,
716  bool allowUnsafe) {
717  auto mi =
718  readMaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>(bbox, origin, conformMasks, allowUnsafe);
720 }
721 
722 void ExposureFitsReader::_ensureReaders() {
723  if (!_metadataReader) {
724  auto metadataReader = std::make_unique<MetadataReader>(_maskedImageReader.readPrimaryMetadata(),
725  _maskedImageReader.readImageMetadata(),
726  _maskedImageReader.readXY0());
727  _archiveReader = std::make_unique<ArchiveReader>(*metadataReader->metadata);
728  _metadataReader = std::move(metadataReader); // deferred for exception safety
729  }
730  assert(_archiveReader); // should always be initialized with _metadataReader.
731 }
732 
733 #define INSTANTIATE(ImagePixelT) \
734  template Exposure<ImagePixelT, MaskPixel, VariancePixel> ExposureFitsReader::read( \
735  lsst::geom::Box2I const&, ImageOrigin, bool, bool); \
736  template Image<ImagePixelT> ExposureFitsReader::readImage(lsst::geom::Box2I const&, ImageOrigin, bool); \
737  template ndarray::Array<ImagePixelT, 2, 2> ExposureFitsReader::readImageArray(lsst::geom::Box2I const&, \
738  ImageOrigin, bool); \
739  template MaskedImage<ImagePixelT, MaskPixel, VariancePixel> ExposureFitsReader::readMaskedImage( \
740  lsst::geom::Box2I const&, ImageOrigin, bool, bool)
741 
743 INSTANTIATE(int);
744 INSTANTIATE(float);
745 INSTANTIATE(double);
747 
748 template Mask<MaskPixel> ExposureFitsReader::readMask(lsst::geom::Box2I const&, ImageOrigin, bool, bool);
749 template ndarray::Array<MaskPixel, 2, 2> ExposureFitsReader::readMaskArray(lsst::geom::Box2I const&,
750  ImageOrigin, bool);
751 
752 template Image<VariancePixel> ExposureFitsReader::readVariance(lsst::geom::Box2I const&, ImageOrigin, bool);
753 template ndarray::Array<VariancePixel, 2, 2> ExposureFitsReader::readVarianceArray(lsst::geom::Box2I const&,
754  ImageOrigin, bool);
755 
756 } // namespace image
757 } // namespace afw
758 } // namespace lsst
lsst::afw::image::MaskedImageFitsReader::readImage
Image< ImagePixelT > readImage(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the image plane.
Definition: MaskedImageFitsReader.cc:131
lsst::afw::image::FilterLabel::hasPhysicalLabel
bool hasPhysicalLabel() const noexcept
Return whether the filter label names a physical filter.
Definition: FilterLabel.cc:96
lsst::afw::image
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.
Definition: imageAlgorithm.dox:1
lsst::afw::image::ExposureFitsReader::readMaskedImage
MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > readMaskedImage(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool allowUnsafe=false)
Read the MaskedImage.
Definition: ExposureFitsReader.cc:705
lsst::afw::image::Filter::getId
int getId() const noexcept
Return a Filter's integral id.
Definition: Filter.h:185
lsst::afw::image::FilterLabel::fromPhysical
static FilterLabel fromPhysical(std::string const &physical)
Construct a FilterLabel from specific inputs.
Definition: FilterLabel.cc:74
lsst::afw::image::ExposureFitsReader::ArchiveReader::readComponent
std::shared_ptr< T > readComponent(afw::fits::Fits *fitsFile, std::string c)
Read an arbitrary component, if available.
Definition: ExposureFitsReader.cc:413
lsst::afw::image::MaskedImageFitsReader::readPrimaryMetadata
std::shared_ptr< daf::base::PropertyList > readPrimaryMetadata()
Read the FITS header of one of the HDUs.
Definition: MaskedImageFitsReader.cc:100
std::string
STL class.
std::shared_ptr
STL class.
lsst::afw::image::MaskedImageFitsReader::readVarianceArray
ndarray::Array< VariancePixelT, 2, 2 > readVarianceArray(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the variance plane.
Definition: MaskedImageFitsReader.cc:163
lsst::afw::image::ExposureFitsReader::ExposureFitsReader
ExposureFitsReader(std::string const &fileName)
Construct a FITS reader object.
Definition: ExposureFitsReader.cc:480
lsst::afw::image::Mask
Represent a 2-dimensional array of bitmask pixels.
Definition: Mask.h:77
Psf.h
lsst::afw::image::makePhotoCalibFromMetadata
std::shared_ptr< PhotoCalib > makePhotoCalibFromMetadata(daf::base::PropertySet &metadata, bool strip=false)
Construct a PhotoCalib from FITS FLUXMAG0/FLUXMAG0ERR keywords.
Definition: PhotoCalib.cc:596
std::move
T move(T... args)
lsst::afw::image::MaskedImageFitsReader::readMaskArray
ndarray::Array< MaskPixelT, 2, 2 > readMaskArray(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the mask plane.
Definition: MaskedImageFitsReader.cc:150
TransmissionCurve.h
lsst::afw::image::Exposure
A class to contain the data, WCS, and other information needed to describe an image of the sky.
Definition: Exposure.h:72
lsst::afw::image::ExposureFitsReader::readFilter
Filter readFilter()
Read the Exposure's filter.
Definition: ExposureFitsReader.cc:516
lsst::afw::image::ExposureFitsReader::readVariance
Image< VariancePixelT > readVariance(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the variance plane.
Definition: ExposureFitsReader.cc:692
wcs
table::Key< table::Array< std::uint8_t > > wcs
Definition: SkyWcs.cc:71
lsst::afw::image::ExposureFitsReader::ArchiveReader::PHOTOCALIB
@ PHOTOCALIB
Definition: ExposureFitsReader.cc:320
Log.h
lsst::afw::fits::Fits
A simple struct that combines the two arguments that must be passed to most cfitsio routines and cont...
Definition: fits.h:297
std::vector< std::string >
std::vector::size
T size(T... args)
lsst::pex::exceptions::NotFoundError
lsst::afw::image::Filter
Holds an integer identifier for an LSST filter.
Definition: Filter.h:141
lsst::afw::image::ExposureFitsReader::MetadataReader::wcs
std::shared_ptr< afw::geom::SkyWcs > wcs
Definition: ExposureFitsReader.cc:305
lsst::afw::image::ExposureFitsReader::readMaskArray
ndarray::Array< MaskPixelT, 2, 2 > readMaskArray(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the mask plane.
Definition: ExposureFitsReader.cc:686
lsst::afw::fits::HduMoveGuard
RAII scoped guard for moving the HDU in a Fits object.
Definition: fits.h:724
lsst::afw::image::ExposureFitsReader::readBBox
lsst::geom::Box2I readBBox(ImageOrigin origin=PARENT)
Read the bounding box of the on-disk image.
Definition: ExposureFitsReader.cc:488
lsst::afw::image::ExposureFitsReader::ArchiveReader::ArchiveReader
ArchiveReader(daf::base::PropertyList &metadata)
Definition: ExposureFitsReader.cc:324
std::map::emplace
T emplace(T... args)
lsst::afw::image::ExposureFitsReader::ArchiveReader::readExtraComponents
std::map< std::string, std::shared_ptr< table::io::Persistable > > readExtraComponents(afw::fits::Fits *fitsFile)
Read the components that are stored using arbitrary-component support.
Definition: ExposureFitsReader.cc:435
LOG_GET
#define LOG_GET(logger)
version
lsst::daf::base::PropertyList
lsst::daf::base::PropertyList::exists
bool exists(std::string const &name) const
std::regex_match
T regex_match(T... args)
SkyWcs.h
lsst::afw::image::makeFilterLabel
std::shared_ptr< FilterLabel > makeFilterLabel(Filter const &filter)
Convert an old-style Filter to a FilterLabel.
Definition: ExposureFitsReader.cc:121
lsst::afw::image::FilterLabel::getPhysicalLabel
std::string getPhysicalLabel() const
Return the physical filter label.
Definition: FilterLabel.cc:98
lsst::afw::image::ExposureFitsReader::readExtraComponents
std::map< std::string, std::shared_ptr< table::io::Persistable > > readExtraComponents()
Read the Exposure's non-standard components.
Definition: ExposureFitsReader.cc:586
lsst::afw::geom::SkyWcs
A 2-dimensional celestial WCS that transform pixels to ICRS RA/Dec, using the LSST standard for pixel...
Definition: SkyWcs.h:117
lsst::afw::typehandling::Storable
Interface supporting iteration over heterogenous containers.
Definition: Storable.h:58
lsst::afw::image::MaskedImageFitsReader::readImageDType
std::string readImageDType() const
Read a string describing the pixel type of the on-disk image plane.
Definition: MaskedImageFitsReader.cc:66
lsst::afw::fits::MemFileManager
Lifetime-management for memory that goes into FITS memory files.
Definition: fits.h:121
lsst::afw::geom.transform.transformContinued.name
string name
Definition: transformContinued.py:32
lsst::afw::image::ExposureFitsReader::readDetector
std::shared_ptr< cameraGeom::Detector > readDetector()
Read the Exposure's detector.
Definition: ExposureFitsReader.cc:576
lsst::afw::image::MaskedImageFitsReader::readVarianceDType
std::string readVarianceDType() const
Read a string describing the pixel type of the on-disk image plane.
Definition: MaskedImageFitsReader.cc:70
lsst::afw::image::ExposureInfo::getFitsSerializationVersion
static int getFitsSerializationVersion()
Get the version of FITS serialization that this ExposureInfo understands.
Definition: ExposureInfo.cc:155
std::vector::front
T front(T... args)
lsst::daf::base::PropertyList::get
T get(std::string const &name) const
end
int end
Definition: BoundedField.cc:105
lsst::afw::image::ExposureFitsReader::readVarianceDType
std::string readVarianceDType() const
Read a string describing the pixel type of the on-disk image plane.
Definition: ExposureFitsReader.cc:500
std::vector::push_back
T push_back(T... args)
lsst::afw::image::ExposureFitsReader::readExposureInfo
std::shared_ptr< ExposureInfo > readExposureInfo()
Read the ExposureInfo containing all non-image components.
Definition: ExposureFitsReader.cc:591
LOGLS_WARN
#define LOGLS_WARN(logger, message)
result
std::unique_ptr< SchemaItem< U > > result
Definition: Schema.cc:195
lsst::afw::image::ExposureFitsReader::MetadataReader::version
int version
Definition: ExposureFitsReader.cc:302
lsst::afw::image::MaskedImageFitsReader::readVariance
Image< VariancePixelT > readVariance(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the variance plane.
Definition: MaskedImageFitsReader.cc:157
lsst::afw::image::MaskedImage
A class to manipulate images, masks, and variance as a single object.
Definition: MaskedImage.h:73
lsst::afw::image::ExposureFitsReader::readMetadata
std::shared_ptr< daf::base::PropertyList > readMetadata()
Read the flexible metadata associated with the Exposure.
Definition: ExposureFitsReader.cc:502
lsst::afw::geom::polygon::Polygon
Cartesian polygons.
Definition: Polygon.h:59
std::map::at
T at(T... args)
lsst::afw::image::ExposureFitsReader::readWcs
std::shared_ptr< afw::geom::SkyWcs > readWcs()
Read the Exposure's world coordinate system.
Definition: ExposureFitsReader.cc:507
lsst::afw::image::ExposureFitsReader::readFilterLabel
std::shared_ptr< FilterLabel > readFilterLabel()
Read the Exposure's filter information.
Definition: ExposureFitsReader.cc:526
lsst::afw::image::ExposureFitsReader::readCoaddInputs
std::shared_ptr< CoaddInputs > readCoaddInputs()
Read the Exposure's coadd input catalogs.
Definition: ExposureFitsReader.cc:560
lsst::afw::image::ExposureFitsReader::readImage
Image< ImagePixelT > readImage(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the image plane.
Definition: ExposureFitsReader.cc:668
lsst::afw::image::ExposureFitsReader::readMaskDType
std::string readMaskDType() const
Read a string describing the pixel type of the on-disk image plane.
Definition: ExposureFitsReader.cc:498
lsst::afw::image::ExposureFitsReader::MetadataReader::photoCalib
std::shared_ptr< PhotoCalib > photoCalib
Definition: ExposureFitsReader.cc:306
std::array
STL class.
any
bool any(CoordinateExpr< N > const &expr) noexcept
lsst::afw::image::ExposureInfo::getFitsSerializationVersionName
static std::string const & getFitsSerializationVersionName()
Get the version of FITS serialization version info name.
Definition: ExposureInfo.cc:164
lsst::afw::image::ExposureFitsReader::MetadataReader::filterLabel
std::shared_ptr< FilterLabel > filterLabel
Definition: ExposureFitsReader.cc:304
lsst::afw::image::ExposureFitsReader::MetadataReader::visitInfo
std::shared_ptr< VisitInfo > visitInfo
Definition: ExposureFitsReader.cc:307
lsst::afw::image::ExposureFitsReader::readMask
Mask< MaskPixelT > readMask(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool allowUnsafe=false)
Read the mask plane.
Definition: ExposureFitsReader.cc:680
lsst::afw::image::PhotoCalib
The photometric calibration of an exposure.
Definition: PhotoCalib.h:114
std::uint16_t
lsst::afw::image::FilterLabel::hasBandLabel
bool hasBandLabel() const noexcept
Return whether the filter label names a band.
Definition: FilterLabel.cc:85
lsst::afw::image::MaskedImageFitsReader::readXY0
lsst::geom::Point2I readXY0(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT)
Read the image origin from the on-disk image or a subimage thereof.
Definition: MaskedImageFitsReader.cc:76
lsst::afw::image::FilterLabel
A group of labels for a filter in an exposure or coadd.
Definition: FilterLabel.h:58
std::map
STL class.
std::regex
lsst::afw::image::ExposureFitsReader::ArchiveReader::readComponent
std::shared_ptr< T > readComponent(afw::fits::Fits *fitsFile, Component c)
Read a known component, if available.
Definition: ExposureFitsReader.cc:386
lsst::afw::image::MaskedImageFitsReader::read
MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > read(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool needAllHdus=false, bool allowUnsafe=false)
Read the full MaskedImage.
Definition: MaskedImageFitsReader.cc:170
lsst::afw::image::ExposureFitsReader::readXY0
lsst::geom::Point2I readXY0(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT)
Read the image origin from the on-disk image or a subimage thereof.
Definition: ExposureFitsReader.cc:492
ExposureFitsReader.h
lsst::afw::image::ExposureFitsReader::ArchiveReader::WCS
@ WCS
Definition: ExposureFitsReader.cc:314
lsst
A base class for image defects.
lsst::afw::image::ExposureFitsReader::ArchiveReader
Definition: ExposureFitsReader.cc:310
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
lsst::afw::image::ExposureFitsReader::ArchiveReader::N_ARCHIVE_COMPONENTS
@ N_ARCHIVE_COMPONENTS
Definition: ExposureFitsReader.cc:321
lsst::pex::exceptions::NotFoundError::what
virtual char const * what(void) const noexcept
LOGLS_DEBUG
#define LOGLS_DEBUG(logger, message)
Polygon.h
std::string::substr
T substr(T... args)
lsst::afw::image::ExposureFitsReader::readApCorrMap
std::shared_ptr< ApCorrMap > readApCorrMap()
Read the Exposure's aperture correction map.
Definition: ExposureFitsReader.cc:555
lsst::afw::image::TransmissionCurve
A spatially-varying transmission curve as a function of wavelength.
Definition: TransmissionCurve.h:67
lsst::afw::image::FilterLabel::fromBandPhysical
static FilterLabel fromBandPhysical(std::string const &band, std::string const &physical)
Construct a FilterLabel from specific inputs.
Definition: FilterLabel.cc:68
lsst::afw::image::FilterLabel::getBandLabel
std::string getBandLabel() const
Return the band label.
Definition: FilterLabel.cc:87
lsst::afw::image::ExposureFitsReader
A FITS reader class for Exposures and their components.
Definition: ExposureFitsReader.h:42
lsst::afw::image::ExposureFitsReader::readTransmissionCurve
std::shared_ptr< TransmissionCurve > readTransmissionCurve()
Read the Exposure's transmission curve.
Definition: ExposureFitsReader.cc:570
lsst::afw::image::MaskedImageFitsReader::readImageArray
ndarray::Array< ImagePixelT, 2, 2 > readImageArray(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the image plane.
Definition: MaskedImageFitsReader.cc:137
lsst::afw::image::makeFilter
Filter makeFilter(FilterLabel const &label)
Convert a FilterLabel back to an old-style Filter.
Definition: ExposureFitsReader.cc:210
lsst::afw::image::ExposureInfo::KEY_FILTER
static typehandling::Key< std::string, std::shared_ptr< FilterLabel const > > const KEY_FILTER
Standard key for looking up filter information.
Definition: ExposureInfo.h:107
lsst::afw::image::MaskedImageFitsReader::readImageMetadata
std::shared_ptr< daf::base::PropertyList > readImageMetadata()
Read the FITS header of one of the HDUs.
Definition: MaskedImageFitsReader.cc:106
lsst::afw::image::MaskedImageFitsReader::readMaskDType
std::string readMaskDType() const
Read a string describing the pixel type of the on-disk image plane.
Definition: MaskedImageFitsReader.cc:68
PhotoCalib.h
Implementation of the Photometric Calibration class.
lsst::afw::image::Filter::UNKNOWN
static int const UNKNOWN
Definition: Filter.h:144
key
Key< U > key
Definition: Schema.cc:281
lsst::afw::table::io::InputArchive::readFits
static InputArchive readFits(fits::Fits &fitsfile)
Read an object from an already open FITS object.
Definition: InputArchive.cc:186
Point< int, 2 >
lsst::afw::image::ExposureFitsReader::readComponent
std::shared_ptr< typehandling::Storable > readComponent(std::string const &componentName)
Read an arbitrary non-standard component by name.
Definition: ExposureFitsReader.cc:581
lsst::afw::image::CoaddInputs
A simple Persistable struct containing ExposureCatalogs that record the inputs to a coadd.
Definition: CoaddInputs.h:49
lsst::afw::image::ExposureFitsReader::readImageDType
std::string readImageDType() const
Read a string describing the pixel type of the on-disk image plane.
Definition: ExposureFitsReader.cc:496
lsst::afw::image::ExposureFitsReader::readVisitInfo
std::shared_ptr< VisitInfo > readVisitInfo()
Read the Exposure's visit metadata.
Definition: ExposureFitsReader.cc:565
lsst::afw::image::ExposureFitsReader::ArchiveReader::COADD_INPUTS
@ COADD_INPUTS
Definition: ExposureFitsReader.cc:315
lsst::afw::image::ExposureFitsReader::ArchiveReader::PSF
@ PSF
Definition: ExposureFitsReader.cc:313
std::set::count
T count(T... args)
lsst::afw::image::Filter::getCanonicalName
std::string const & getCanonicalName() const
Return a filter's canonical name.
Definition: Filter.h:195
lsst::geom::Box2I
lsst::afw::image::ExposureFitsReader::MetadataReader::metadata
std::shared_ptr< daf::base::PropertyList > metadata
Definition: ExposureFitsReader.cc:303
lsst::afw::geom::makeSkyWcs
std::shared_ptr< SkyWcs > makeSkyWcs(daf::base::PropertySet &metadata, bool strip=false)
Construct a SkyWcs from FITS keywords.
Definition: SkyWcs.cc:526
lsst::afw::image::ExposureFitsReader::readValidPolygon
std::shared_ptr< afw::geom::polygon::Polygon > readValidPolygon()
Read the polygon describing the region of validity for the Exposure.
Definition: ExposureFitsReader.cc:549
ApCorrMap.h
lsst::afw::image::MaskedImageFitsReader::readMask
Mask< MaskPixelT > readMask(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool allowUnsafe=false)
Read the mask plane.
Definition: MaskedImageFitsReader.cc:144
lsst::afw::image::FilterLabel::fromBand
static FilterLabel fromBand(std::string const &band)
Construct a FilterLabel from specific inputs.
Definition: FilterLabel.cc:72
lsst::daf::base::PropertyList::remove
virtual void remove(std::string const &name)
std::make_pair
T make_pair(T... args)
lsst::afw::image::ExposureFitsReader::MetadataReader
Definition: ExposureFitsReader.cc:229
lsst::afw::image::ImageOrigin
ImageOrigin
Definition: ImageBase.h:94
lsst::afw::detection::Psf
A polymorphic base class for representing an image's Point Spread Function.
Definition: Psf.h:76
element
double element[2]
Definition: BaseTable.cc:91
lsst::pex::exceptions::TypeError
lsst::afw::image::ExposureFitsReader::MetadataReader::MetadataReader
MetadataReader(std::shared_ptr< daf::base::PropertyList > primaryMetadata, std::shared_ptr< daf::base::PropertyList > imageMetadata, lsst::geom::Point2I const &xy0)
Definition: ExposureFitsReader.cc:231
lsst::afw::image::Filter::getName
std::string const & getName() const noexcept
Return a Filter's name.
Definition: Filter.h:189
lsst::afw::image::Filter::getAliases
std::vector< std::string > getAliases() const
Return all aliases by which this filter is known.
Definition: Filter.cc:146
lsst::afw::image::ExposureFitsReader::ArchiveReader::AP_CORR_MAP
@ AP_CORR_MAP
Definition: ExposureFitsReader.cc:316
lsst::afw::image::ExposureFitsReader::readPsf
std::shared_ptr< detection::Psf > readPsf()
Read the Exposure's point-spread function.
Definition: ExposureFitsReader.cc:544
lsst::afw::image::ExposureFitsReader::readPhotoCalib
std::shared_ptr< PhotoCalib > readPhotoCalib()
Read the Exposure's photometric calibration.
Definition: ExposureFitsReader.cc:535
lsst::afw::image::ExposureFitsReader::read
Exposure< ImagePixelT, MaskPixelT, VariancePixelT > read(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool conformMasks=false, bool allowUnsafe=false)
Read the full Exposure.
Definition: ExposureFitsReader.cc:713
lsst::afw::image::ApCorrMap
A thin wrapper around std::map to allow aperture corrections to be attached to Exposures.
Definition: ApCorrMap.h:45
lsst::afw::image::Image< ImagePixelT >
lsst::afw::image::ExposureFitsReader::ArchiveReader::Component
Component
Definition: ExposureFitsReader.cc:312
INSTANTIATE
#define INSTANTIATE(ImagePixelT)
Definition: ExposureFitsReader.cc:733
lsst::afw::image::ExposureFitsReader::readVarianceArray
ndarray::Array< VariancePixelT, 2, 2 > readVarianceArray(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the variance plane.
Definition: ExposureFitsReader.cc:698
lsst::afw::image::detail::stripVisitInfoKeywords
int stripVisitInfoKeywords(daf::base::PropertySet &metadata)
Remove VisitInfo-related keywords from the metadata.
Definition: VisitInfo.cc:301
lsst::afw::image::makeFilterLabelDirect
std::shared_ptr< FilterLabel > makeFilterLabelDirect(std::string const &name)
Convert an old-style filter name to a FilterLabel without external information.
Definition: ExposureFitsReader.cc:94
Extent< double, 2 >
lsst::afw::image::ExposureFitsReader::readImageArray
ndarray::Array< ImagePixelT, 2, 2 > readImageArray(lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT, bool allowUnsafe=false)
Read the image plane.
Definition: ExposureFitsReader.cc:674
std::set< std::string >
Detector.h
lsst::afw::image::ExposureFitsReader::~ExposureFitsReader
~ExposureFitsReader() noexcept
lsst::afw::cameraGeom::Detector
A representation of a detector in a mosaic camera.
Definition: Detector.h:185
lsst::afw::image::ExposureFitsReader::ArchiveReader::DETECTOR
@ DETECTOR
Definition: ExposureFitsReader.cc:319
bbox
AmpInfoBoxKey bbox
Definition: Amplifier.cc:117
lsst::afw::image::ExposureFitsReader::ArchiveReader::VALID_POLYGON
@ VALID_POLYGON
Definition: ExposureFitsReader.cc:317
FitsKeyState::ABSENT
@ ABSENT
lsst::afw::table::io::InputArchive::get
std::shared_ptr< Persistable > get(int id) const
Load the Persistable with the given ID and return it.
Definition: InputArchive.cc:182
lsst::afw::image::ExposureFitsReader::ArchiveReader::TRANSMISSION_CURVE
@ TRANSMISSION_CURVE
Definition: ExposureFitsReader.cc:318