lsst.afw  21.0.0-42-gd49707f5a+db122c3704
MaskedImage.cc
Go to the documentation of this file.
1 // -*- lsst-c++ -*-
2 
3 /*
4  * LSST Data Management System
5  * Copyright 2008-2016 AURA/LSST.
6  *
7  * This product includes software developed by the
8  * LSST Project (http://www.lsst.org/).
9  *
10  * This program is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the LSST License Statement and
21  * the GNU General Public License along with this program. If not,
22  * see <http://www.lsstcorp.org/LegalNotices/>.
23  */
24 
25 /*
26  * Implementation for MaskedImage
27  */
28 #include <cstdint>
29 #include <typeinfo>
30 #include <sys/stat.h>
31 #pragma clang diagnostic push
32 #pragma clang diagnostic ignored "-Wunused-variable"
33 #pragma clang diagnostic pop
34 #include "boost/regex.hpp"
35 #include "boost/format.hpp"
36 #include "lsst/log/Log.h"
37 #include "lsst/pex/exceptions.h"
38 
40 #include "lsst/afw/fits.h"
42 
43 namespace lsst {
44 namespace afw {
45 namespace image {
46 
47 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
49  MaskPlaneDict const& planeDict)
50  : _image(new Image(width, height)),
51  _mask(new Mask(width, height, planeDict)),
52  _variance(new Variance(width, height)) {
53  *_image = 0;
54  *_mask = 0x0;
55  *_variance = 0;
56 }
57 
58 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
60  MaskPlaneDict const& planeDict)
61  : _image(new Image(dimensions)),
62  _mask(new Mask(dimensions, planeDict)),
63  _variance(new Variance(dimensions)) {
64  *_image = 0;
65  *_mask = 0x0;
66  *_variance = 0;
67 }
68 
69 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
71  MaskPlaneDict const& planeDict)
72  : _image(new Image(bbox)), _mask(new Mask(bbox, planeDict)), _variance(new Variance(bbox)) {
73  *_image = 0;
74  *_mask = 0x0;
75  *_variance = 0;
76 }
77 
78 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
80  std::string const& fileName, std::shared_ptr<daf::base::PropertySet> metadata,
81  lsst::geom::Box2I const& bbox, ImageOrigin origin, bool conformMasks, bool needAllHdus,
84  std::shared_ptr<daf::base::PropertySet> varianceMetadata, bool allowUnsafe)
85  : _image(), _mask(), _variance() {
86  MaskedImageFitsReader reader(fileName);
87  *this = reader.read<ImagePixelT, MaskPixelT, VariancePixelT>(bbox, origin, conformMasks, needAllHdus,
88  allowUnsafe);
89  if (metadata) {
90  metadata->combine(reader.readPrimaryMetadata());
91  }
92  if (imageMetadata) {
93  imageMetadata->combine(reader.readImageMetadata());
94  }
95  if (maskMetadata) {
96  maskMetadata->combine(reader.readMaskMetadata());
97  }
98  if (varianceMetadata) {
99  varianceMetadata->combine(reader.readVarianceMetadata());
100  }
101 }
102 
103 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
106  lsst::geom::Box2I const& bbox, ImageOrigin origin, bool conformMasks, bool needAllHdus,
109  std::shared_ptr<daf::base::PropertySet> varianceMetadata, bool allowUnsafe)
110  : _image(), _mask(), _variance() {
111  MaskedImageFitsReader reader(manager);
112  *this = reader.read<ImagePixelT, MaskPixelT, VariancePixelT>(bbox, origin, conformMasks, needAllHdus,
113  allowUnsafe);
114  if (metadata) {
115  metadata->combine(reader.readPrimaryMetadata());
116  }
117  if (imageMetadata) {
118  imageMetadata->combine(reader.readImageMetadata());
119  }
120  if (maskMetadata) {
121  maskMetadata->combine(reader.readMaskMetadata());
122  }
123  if (varianceMetadata) {
124  varianceMetadata->combine(reader.readVarianceMetadata());
125  }
126 }
127 
128 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
131  ImageOrigin origin, bool conformMasks, bool needAllHdus,
134  std::shared_ptr<daf::base::PropertySet> varianceMetadata, bool allowUnsafe)
135  : _image(), _mask(), _variance() {
136  MaskedImageFitsReader reader(&fitsFile);
137  *this = reader.read<ImagePixelT, MaskPixelT, VariancePixelT>(bbox, origin, conformMasks, needAllHdus,
138  allowUnsafe);
139  if (metadata) {
140  metadata->combine(reader.readPrimaryMetadata());
141  }
142  if (imageMetadata) {
143  imageMetadata->combine(reader.readImageMetadata());
144  }
145  if (maskMetadata) {
146  maskMetadata->combine(reader.readMaskMetadata());
147  }
148  if (varianceMetadata) {
149  varianceMetadata->combine(reader.readVarianceMetadata());
150  }
151 }
152 
153 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
156  : _image(image), _mask(mask), _variance(variance) {
157  conformSizes();
158 }
159 
160 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
162  : _image(rhs._image), _mask(rhs._mask), _variance(rhs._variance) {
163  if (deep) {
164  _image = std::shared_ptr<Image>(new Image(*rhs.getImage(), deep));
165  _mask = std::shared_ptr<Mask>(new Mask(*rhs.getMask(), deep));
166  _variance = std::shared_ptr<Variance>(new Variance(*rhs.getVariance(), deep));
167  }
168  conformSizes();
169 }
170 
171 // Delegate to copy-constructor for backwards compatibility
172 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
174  : MaskedImage(rhs, false) {}
175 
176 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
178  const lsst::geom::Box2I& bbox,
179  ImageOrigin const origin, bool deep
180 
181  )
182  : _image(new Image(*rhs.getImage(), bbox, origin, deep)),
183  _mask(rhs._mask ? new Mask(*rhs.getMask(), bbox, origin, deep) : static_cast<Mask*>(NULL)),
184  _variance(rhs._variance ? new Variance(*rhs.getVariance(), bbox, origin, deep)
185  : static_cast<Variance*>(NULL)) {
186  conformSizes();
187 }
188 
189 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
191 operator=(MaskedImage const& rhs) = default;
192 
193 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
195 operator=(MaskedImage&& rhs) = default;
196 
197 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
199  using std::swap; // See Meyers, Effective C++, Item 25
200 
201  _image.swap(rhs._image);
202  _mask.swap(rhs._mask);
203  _variance.swap(rhs._variance);
204 }
205 
206 // Operators
207 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
209 operator=(MaskedImage::Pixel const& rhs) {
210  *_image = rhs.image();
211  *_mask = rhs.mask();
212  *_variance = rhs.variance();
213 
214  return *this;
215 }
216 
217 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
220  *_image = rhs.image();
221  *_mask = rhs.mask();
222  *_variance = rhs.variance();
223 
224  return *this;
225 }
226 
227 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
229  lsst::geom::Box2I const& bbox,
230  ImageOrigin origin) {
231  _image->assign(*rhs.getImage(), bbox, origin);
232  _mask->assign(*rhs.getMask(), bbox, origin);
233  _variance->assign(*rhs.getVariance(), bbox, origin);
234 }
235 
236 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
238 operator+=(MaskedImage const& rhs) {
239  *_image += *rhs.getImage();
240  *_mask |= *rhs.getMask();
241  *_variance += *rhs.getVariance();
242  return *this;
243 }
244 
245 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
247  MaskedImage const& rhs) {
248  (*_image).scaledPlus(c, *rhs.getImage());
249  *_mask |= *rhs.getMask();
250  (*_variance).scaledPlus(c * c, *rhs.getVariance());
251 }
252 
253 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
255 operator+=(ImagePixelT const rhs) {
256  *_image += rhs;
257  return *this;
258 }
259 
260 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
262 operator-=(MaskedImage const& rhs) {
263  *_image -= *rhs.getImage();
264  *_mask |= *rhs.getMask();
265  *_variance += *rhs.getVariance();
266  return *this;
267 }
268 
269 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
271  MaskedImage const& rhs) {
272  (*_image).scaledMinus(c, *rhs.getImage());
273  *_mask |= *rhs.getMask();
274  (*_variance).scaledPlus(c * c, *rhs.getVariance());
275 }
276 
277 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
279 operator-=(ImagePixelT const rhs) {
280  *_image -= rhs;
281  return *this;
282 }
283 
284 namespace {
286 template <typename ImagePixelT, typename VariancePixelT>
287 struct productVariance {
288  double operator()(ImagePixelT lhs, ImagePixelT rhs, VariancePixelT varLhs, VariancePixelT varRhs) {
289  return lhs * lhs * varRhs + rhs * rhs * varLhs;
290  }
291 };
292 
295 template <typename ImagePixelT, typename VariancePixelT>
296 struct scaledProductVariance {
297  double _c;
298  scaledProductVariance(double const c) : _c(c) {}
299  double operator()(ImagePixelT lhs, ImagePixelT rhs, VariancePixelT varLhs, VariancePixelT varRhs) {
300  return _c * _c * (lhs * lhs * varRhs + rhs * rhs * varLhs);
301  }
302 };
303 } // namespace
304 
305 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
307 operator*=(MaskedImage const& rhs) {
308  // Must do variance before we modify the image values
309  if (_image->getDimensions() != rhs._image->getDimensions()) {
311  boost::str(boost::format("Images are of different size, %dx%d v %dx%d") %
312  _image->getWidth() % _image->getHeight() % rhs._image->getWidth() % rhs._image->getHeight()));
313  }
314  transform_pixels(_image->_getRawView(), // lhs
315  rhs._image->_getRawView(), // rhs,
316  _variance->_getRawView(), // Var(lhs),
317  rhs._variance->_getRawView(), // Var(rhs)
318  _variance->_getRawView(), // result
319  productVariance<ImagePixelT, VariancePixelT>());
320 
321  *_image *= *rhs.getImage();
322  *_mask |= *rhs.getMask();
323  return *this;
324 }
325 
326 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
328  MaskedImage const& rhs) {
329  // Must do variance before we modify the image values
330  if (_image->getDimensions() != rhs._image->getDimensions()) {
332  boost::str(boost::format("Images are of different size, %dx%d v %dx%d") %
333  _image->getWidth() % _image->getHeight() % rhs._image->getWidth() % rhs._image->getHeight()));
334  }
335  transform_pixels(_image->_getRawView(), // lhs
336  rhs._image->_getRawView(), // rhs,
337  _variance->_getRawView(), // Var(lhs),
338  rhs._variance->_getRawView(), // Var(rhs)
339  _variance->_getRawView(), // result
340  scaledProductVariance<ImagePixelT, VariancePixelT>(c));
341 
342  (*_image).scaledMultiplies(c, *rhs.getImage());
343  *_mask |= *rhs.getMask();
344 }
345 
346 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
348 operator*=(ImagePixelT const rhs) {
349  *_image *= rhs;
350  *_variance *= rhs * rhs;
351  return *this;
352 }
353 
354 namespace {
356 template <typename ImagePixelT, typename VariancePixelT>
357 struct quotientVariance {
358  double operator()(ImagePixelT lhs, ImagePixelT rhs, VariancePixelT varLhs, VariancePixelT varRhs) {
359  ImagePixelT const rhs2 = rhs * rhs;
360  return (lhs * lhs * varRhs + rhs2 * varLhs) / (rhs2 * rhs2);
361  }
362 };
365 template <typename ImagePixelT, typename VariancePixelT>
366 struct scaledQuotientVariance {
367  double _c;
368  scaledQuotientVariance(double c) : _c(c) {}
369  double operator()(ImagePixelT lhs, ImagePixelT rhs, VariancePixelT varLhs, VariancePixelT varRhs) {
370  ImagePixelT const rhs2 = rhs * rhs;
371  return (lhs * lhs * varRhs + rhs2 * varLhs) / (_c * _c * rhs2 * rhs2);
372  }
373 };
374 } // namespace
375 
376 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
378 operator/=(MaskedImage const& rhs) {
379  // Must do variance before we modify the image values
380  if (_image->getDimensions() != rhs._image->getDimensions()) {
382  boost::str(boost::format("Images are of different size, %dx%d v %dx%d") %
383  _image->getWidth() % _image->getHeight() % rhs._image->getWidth() % rhs._image->getHeight()));
384  }
385  transform_pixels(_image->_getRawView(), // lhs
386  rhs._image->_getRawView(), // rhs,
387  _variance->_getRawView(), // Var(lhs),
388  rhs._variance->_getRawView(), // Var(rhs)
389  _variance->_getRawView(), // result
390  quotientVariance<ImagePixelT, VariancePixelT>());
391 
392  *_image /= *rhs.getImage();
393  *_mask |= *rhs.getMask();
394  return *this;
395 }
396 
397 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
399  MaskedImage const& rhs) {
400  // Must do variance before we modify the image values
401  if (_image->getDimensions() != rhs._image->getDimensions()) {
403  str(boost::format("Images are of different size, %dx%d v %dx%d") %
404  _image->getWidth() % _image->getHeight() % rhs._image->getWidth() % rhs._image->getHeight()));
405  }
406  transform_pixels(_image->_getRawView(), // lhs
407  rhs._image->_getRawView(), // rhs,
408  _variance->_getRawView(), // Var(lhs),
409  rhs._variance->_getRawView(), // Var(rhs)
410  _variance->_getRawView(), // result
411  scaledQuotientVariance<ImagePixelT, VariancePixelT>(c));
412 
413  (*_image).scaledDivides(c, *rhs.getImage());
414  *_mask |= *rhs._mask;
415 }
416 
417 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
419 operator/=(ImagePixelT const rhs) {
420  *_image /= rhs;
421  *_variance /= rhs * rhs;
422  return *this;
423 }
424 
425 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
430  std::shared_ptr<daf::base::PropertySet const> varianceMetadata) const {
431  fits::Fits fitsfile(fileName, "w", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
432  writeFits(fitsfile, metadata, imageMetadata, maskMetadata, varianceMetadata);
433 }
434 
435 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
440  std::shared_ptr<daf::base::PropertySet const> varianceMetadata) const {
441  fits::Fits fitsfile(manager, "w", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
442  writeFits(fitsfile, metadata, imageMetadata, maskMetadata, varianceMetadata);
443 }
444 
445 namespace {
446 
447 void processPlaneMetadata(std::shared_ptr<daf::base::PropertySet const> metadata,
448  std::shared_ptr<daf::base::PropertySet>& hdr, char const* exttype) {
449  if (metadata) {
450  hdr = metadata->deepCopy();
451  } else {
452  hdr.reset(new daf::base::PropertyList());
453  }
454  hdr->set("INHERIT", true);
455  hdr->set("EXTTYPE", exttype);
456  hdr->set("EXTNAME", exttype);
457 }
458 
459 } // namespace
460 
461 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
466  std::shared_ptr<daf::base::PropertySet const> varianceMetadata) const {
467  writeFits(fitsfile, fits::ImageWriteOptions(*_image), fits::ImageWriteOptions(*_mask),
468  fits::ImageWriteOptions(*_variance), metadata, imageMetadata, maskMetadata, varianceMetadata);
469 }
470 
471 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
473  std::string const& fileName, fits::ImageWriteOptions const& imageOptions,
474  fits::ImageWriteOptions const& maskOptions, fits::ImageWriteOptions const& varianceOptions,
478  std::shared_ptr<daf::base::PropertySet const> varianceMetadata) const {
479  fits::Fits fitsfile(fileName, "w", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
480  writeFits(fitsfile, imageOptions, maskOptions, varianceOptions, metadata, imageMetadata, maskMetadata,
481  varianceMetadata);
482 }
483 
484 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
486  fits::MemFileManager& manager, fits::ImageWriteOptions const& imageOptions,
487  fits::ImageWriteOptions const& maskOptions, fits::ImageWriteOptions const& varianceOptions,
491  std::shared_ptr<daf::base::PropertySet const> varianceMetadata) const {
492  fits::Fits fitsfile(manager, "w", fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
493  writeFits(fitsfile, imageOptions, maskOptions, varianceOptions, metadata, imageMetadata, maskMetadata,
494  varianceMetadata);
495 }
496 
497 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
499  fits::Fits& fitsfile, fits::ImageWriteOptions const& imageOptions,
500  fits::ImageWriteOptions const& maskOptions, fits::ImageWriteOptions const& varianceOptions,
504  std::shared_ptr<daf::base::PropertySet const> varianceMetadata) const {
506  if (metadata) {
507  header = metadata->deepCopy();
508  } else {
509  header = std::make_shared<daf::base::PropertyList>();
510  }
511 
512  if (fitsfile.countHdus() != 0) {
514  "MaskedImage::writeFits can only write to an empty file");
515  }
516  if (fitsfile.getHdu() < 1) {
517  // Don't ever write images to primary; instead we make an empty primary.
518  fitsfile.createEmpty();
519  } else {
520  fitsfile.setHdu(0);
521  }
522  fitsfile.writeMetadata(*header);
523 
524  processPlaneMetadata(imageMetadata, header, "IMAGE");
525  _image->writeFits(fitsfile, imageOptions, header, _mask);
526 
527  processPlaneMetadata(maskMetadata, header, "MASK");
528  _mask->writeFits(fitsfile, maskOptions, header);
529 
530  processPlaneMetadata(varianceMetadata, header, "VARIANCE");
531  _variance->writeFits(fitsfile, varianceOptions, header, _mask);
532 }
533 
534 // private function conformSizes() ensures that the Mask and Variance have the same dimensions
535 // as Image. If Mask and/or Variance have non-zero dimensions that conflict with the size of Image,
536 // a lsst::pex::exceptions::LengthError is thrown.
537 
538 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
540  if (!_mask || _mask->getWidth() == 0 || _mask->getHeight() == 0) {
541  _mask = MaskPtr(new Mask(_image->getBBox()));
542  *_mask = 0;
543  } else {
544  if (_mask->getDimensions() != _image->getDimensions()) {
545  throw LSST_EXCEPT(
547  (boost::format("Dimension mismatch: Image %dx%d v. Mask %dx%d") % _image->getWidth() %
548  _image->getHeight() % _mask->getWidth() % _mask->getHeight())
549  .str());
550  }
551  }
552 
553  if (!_variance || _variance->getWidth() == 0 || _variance->getHeight() == 0) {
554  _variance = VariancePtr(new Variance(_image->getBBox()));
555  *_variance = 0;
556  } else {
557  if (_variance->getDimensions() != _image->getDimensions()) {
558  throw LSST_EXCEPT(
559  pex::exceptions::LengthError,
560  (boost::format("Dimension mismatch: Image %dx%d v. Variance %dx%d") % _image->getWidth() %
561  _image->getHeight() % _variance->getWidth() % _variance->getHeight())
562  .str());
563  }
564  }
565 }
566 
567 //
568 // Iterators and locators
569 //
570 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
573 #if 0 // this doesn't compile; why?
574  return iterator(_image->begin(), _mask->begin(), _variance->begin());
575 #else
576  typename Image::iterator imageBegin = _image->begin();
577  typename Mask::iterator maskBegin = _mask->begin();
578  typename Variance::iterator varianceBegin = _variance->begin();
579 
580  return iterator(imageBegin, maskBegin, varianceBegin);
581 #endif
582 }
583 
584 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
587  typename Image::iterator imageEnd = getImage()->end();
588  typename Mask::iterator maskEnd = getMask()->end();
589  typename Variance::iterator varianceEnd = getVariance()->end();
590 
591  return iterator(imageEnd, maskEnd, varianceEnd);
592 }
593 
594 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
597  typename Image::iterator imageEnd = getImage()->at(x, y);
598  typename Mask::iterator maskEnd = getMask()->at(x, y);
599  typename Variance::iterator varianceEnd = getVariance()->at(x, y);
600 
601  return iterator(imageEnd, maskEnd, varianceEnd);
602 }
603 
604 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
607  typename Image::reverse_iterator imageBegin = _image->rbegin();
608  typename Mask::reverse_iterator maskBegin = _mask->rbegin();
609  typename Variance::reverse_iterator varianceBegin = _variance->rbegin();
610 
611  return reverse_iterator(imageBegin, maskBegin, varianceBegin);
612 }
613 
614 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
617  typename Image::reverse_iterator imageEnd = getImage()->rend();
618  typename Mask::reverse_iterator maskEnd = getMask()->rend();
619  typename Variance::reverse_iterator varianceEnd = getVariance()->rend();
620 
621  return reverse_iterator(imageEnd, maskEnd, varianceEnd);
622 }
623 
624 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
627  typename Image::x_iterator imageBegin = _image->row_begin(y);
628  typename Mask::x_iterator maskBegin = _mask->row_begin(y);
629  typename Variance::x_iterator varianceBegin = _variance->row_begin(y);
630 
631  return x_iterator(imageBegin, maskBegin, varianceBegin);
632 }
633 
634 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
637  typename Image::x_iterator imageEnd = getImage()->row_end(y);
638  typename Mask::x_iterator maskEnd = getMask()->row_end(y);
639  typename Variance::x_iterator varianceEnd = getVariance()->row_end(y);
640 
641  return x_iterator(imageEnd, maskEnd, varianceEnd);
642 }
643 
644 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
647  typename Image::y_iterator imageBegin = _image->col_begin(x);
648  typename Mask::y_iterator maskBegin = _mask->col_begin(x);
649  typename Variance::y_iterator varianceBegin = _variance->col_begin(x);
650 
651  return y_iterator(imageBegin, maskBegin, varianceBegin);
652 }
653 
654 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
657  typename Image::y_iterator imageEnd = getImage()->col_end(x);
658  typename Mask::y_iterator maskEnd = getMask()->col_end(x);
659  typename Variance::y_iterator varianceEnd = getVariance()->col_end(x);
660 
661  return y_iterator(imageEnd, maskEnd, varianceEnd);
662 }
663 
664 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
667  typename Image::fast_iterator imageBegin = _image->begin(contiguous);
668  typename Mask::fast_iterator maskBegin = _mask->begin(contiguous);
669  typename Variance::fast_iterator varianceBegin = _variance->begin(contiguous);
670 
671  return fast_iterator(imageBegin, maskBegin, varianceBegin);
672 }
673 
674 template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
677  typename Image::fast_iterator imageEnd = getImage()->end(contiguous);
678  typename Mask::fast_iterator maskEnd = getMask()->end(contiguous);
679  typename Variance::fast_iterator varianceEnd = getVariance()->end(contiguous);
680 
681  return fast_iterator(imageEnd, maskEnd, varianceEnd);
682 }
683 
684 template <typename ImagePixelT1, typename ImagePixelT2>
687  return imagesOverlap(*image1.getImage(), *image2.getImage()) ||
688  imagesOverlap(*image1.getVariance(), *image2.getVariance()) ||
689  imagesOverlap(*image1.getMask(), *image2.getMask());
690 }
691 
692 //
693 // Explicit instantiations
694 //
695 #define INSTANTIATE2(ImagePixelT1, ImagePixelT2) \
696  template bool imagesOverlap<ImagePixelT1, ImagePixelT2>(MaskedImage<ImagePixelT1> const&, \
697  MaskedImage<ImagePixelT2> const&);
698 
699 template class MaskedImage<std::uint16_t>;
700 template class MaskedImage<int>;
701 template class MaskedImage<float>;
702 template class MaskedImage<double>;
704 
710 
712 INSTANTIATE2(int, int);
713 INSTANTIATE2(int, float);
714 INSTANTIATE2(int, double);
716 
718 INSTANTIATE2(float, int);
719 INSTANTIATE2(float, float);
720 INSTANTIATE2(float, double);
722 
724 INSTANTIATE2(double, int);
725 INSTANTIATE2(double, float);
726 INSTANTIATE2(double, double);
728 
734 
735 } // namespace image
736 } // namespace afw
737 } // namespace lsst
AmpInfoBoxKey bbox
Definition: Amplifier.cc:117
double x
#define LSST_EXCEPT(type,...)
afw::table::PointKey< int > dimensions
Definition: GaussianPsf.cc:49
afw::table::Key< afw::table::Array< MaskPixelT > > mask
afw::table::Key< afw::table::Array< VariancePixelT > > variance
double _c
Definition: MaskedImage.cc:297
#define INSTANTIATE2(ImagePixelT1, ImagePixelT2)
Definition: MaskedImage.cc:695
int y
Definition: SpanSet.cc:49
A simple struct that combines the two arguments that must be passed to most cfitsio routines and cont...
Definition: fits.h:297
void createEmpty()
Create an empty image HDU with NAXIS=0 at the end of the file.
Definition: fits.cc:1240
void setHdu(int hdu, bool relative=false)
Set the current HDU.
Definition: fits.cc:513
int countHdus()
Return the number of HDUs in the file.
Definition: fits.cc:534
int getHdu()
Return the current HDU (0-indexed; 0 is the Primary HDU).
Definition: fits.cc:507
void writeMetadata(daf::base::PropertySet const &metadata)
Read a FITS header into a PropertySet or PropertyList.
Definition: fits.cc:1095
Lifetime-management for memory that goes into FITS memory files.
Definition: fits.h:121
_view_t::reverse_iterator reverse_iterator
An STL compliant reverse iterator.
Definition: ImageBase.h:129
x_iterator fast_iterator
A fast STL compliant iterator for contiguous images N.b.
Definition: ImageBase.h:137
_view_t::iterator iterator
An STL compliant iterator.
Definition: ImageBase.h:125
_view_t::y_iterator y_iterator
An iterator for traversing the pixels in a column.
Definition: ImageBase.h:143
_view_t::x_iterator x_iterator
An iterator for traversing the pixels in a row.
Definition: ImageBase.h:133
A class to represent a 2-dimensional array of pixels.
Definition: Image.h:58
Represent a 2-dimensional array of bitmask pixels.
Definition: Mask.h:77
A FITS reader class for MaskedImages and their components.
std::shared_ptr< daf::base::PropertyList > readImageMetadata()
Read the FITS header of one of the HDUs.
std::shared_ptr< daf::base::PropertyList > readPrimaryMetadata()
Read the FITS header of one of the HDUs.
std::shared_ptr< daf::base::PropertyList > readMaskMetadata()
Read the FITS header of one of the HDUs.
std::shared_ptr< daf::base::PropertyList > readVarianceMetadata()
Read the FITS header of one of the HDUs.
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.
A class to manipulate images, masks, and variance as a single object.
Definition: MaskedImage.h:73
void scaledPlus(double const c, MaskedImage const &rhs)
Add a scaled MaskedImage c*rhs to a MaskedImage.
Definition: MaskedImage.cc:246
void writeFits(std::string const &fileName, std::shared_ptr< daf::base::PropertySet const > metadata=std::shared_ptr< daf::base::PropertySet const >(), std::shared_ptr< daf::base::PropertySet const > imageMetadata=std::shared_ptr< daf::base::PropertySet const >(), std::shared_ptr< daf::base::PropertySet const > maskMetadata=std::shared_ptr< daf::base::PropertySet const >(), std::shared_ptr< daf::base::PropertySet const > varianceMetadata=std::shared_ptr< daf::base::PropertySet const >()) const
Write a MaskedImage to a regular FITS file.
Definition: MaskedImage.cc:426
MaskedImage(unsigned int width, unsigned int height, MaskPlaneDict const &planeDict=MaskPlaneDict())
Construct from a supplied dimensions.
Definition: MaskedImage.cc:48
lsst::afw::image::Image< VariancePixelT > Variance
Definition: MaskedImage.h:84
void scaledDivides(double const c, MaskedImage const &rhs)
Definition: MaskedImage.cc:398
MaskedImageIterator< typename Image::reverse_iterator, typename Mask::reverse_iterator, typename Variance::reverse_iterator > reverse_iterator
Definition: MaskedImage.h:547
MaskedImageIterator< typename Image::y_iterator, typename Mask::y_iterator, typename Variance::y_iterator > y_iterator
An iterator to a column of a MaskedImage.
Definition: MaskedImage.h:568
iterator begin() const
Return an iterator to the start of the image.
Definition: MaskedImage.cc:572
reverse_iterator rbegin() const
Return a reverse_iterator to the start of the image.
Definition: MaskedImage.cc:606
y_iterator col_end(int x) const
Return an y_iterator to the end of the image.
Definition: MaskedImage.cc:656
void scaledMinus(double const c, MaskedImage const &rhs)
Subtract a scaled MaskedImage c*rhs from a MaskedImage.
Definition: MaskedImage.cc:270
lsst::afw::image::Image< ImagePixelT > Image
Definition: MaskedImage.h:85
MaskedImage & operator-=(ImagePixelT const rhs)
Subtract a scalar rhs from a MaskedImage.
Definition: MaskedImage.cc:279
x_iterator row_end(int y) const
Return an x_iterator to the end of the image.
Definition: MaskedImage.cc:636
void scaledMultiplies(double const c, MaskedImage const &rhs)
Definition: MaskedImage.cc:327
iterator end() const
Return an iterator to the end of the image.
Definition: MaskedImage.cc:586
void assign(MaskedImage const &rhs, lsst::geom::Box2I const &bbox=lsst::geom::Box2I(), ImageOrigin origin=PARENT)
Copy pixels from another masked image to a specified subregion of this masked image.
Definition: MaskedImage.cc:228
VariancePtr getVariance() const
Return a (shared_ptr to) the MaskedImage's variance.
Definition: MaskedImage.h:1079
MaskedImage & operator=(MaskedImage const &rhs)
Make the lhs use the rhs's pixels.
x_iterator row_begin(int y) const
Return an x_iterator to the start of the image.
Definition: MaskedImage.cc:626
void swap(MaskedImage &rhs)
Definition: MaskedImage.cc:198
y_iterator col_begin(int x) const
Return an y_iterator to the start of the image.
Definition: MaskedImage.cc:646
lsst::afw::image::Mask< MaskPixelT > Mask
Definition: MaskedImage.h:86
reverse_iterator rend() const
Return a reverse_iterator to the end of the image.
Definition: MaskedImage.cc:616
MaskedImageIterator< typename Image::iterator, typename Mask::iterator, typename Variance::iterator > iterator
Definition: MaskedImage.h:539
MaskedImage & operator+=(ImagePixelT const rhs)
Add a scalar rhs to a MaskedImage.
Definition: MaskedImage.cc:255
MaskedImage & operator*=(ImagePixelT const rhs)
Definition: MaskedImage.cc:348
iterator at(int const x, int const y) const
Return an iterator at the point (x, y)
Definition: MaskedImage.cc:596
MaskedImage & operator/=(ImagePixelT const rhs)
Definition: MaskedImage.cc:419
MaskPtr getMask() const
Return a (shared_ptr to) the MaskedImage's mask.
Definition: MaskedImage.h:1058
ImagePtr getImage() const
Return a (shared_ptr to) the MaskedImage's image.
Definition: MaskedImage.h:1046
MaskedImageIterator< typename Image::x_iterator, typename Mask::x_iterator, typename Variance::x_iterator > x_iterator
An iterator to a row of a MaskedImage.
Definition: MaskedImage.h:556
A pixel of a MaskedImage.
Definition: Pixel.h:148
MaskPixelT mask() const
Return the mask part of a Pixel.
Definition: Pixel.h:219
ImagePixelT image() const
Return the image part of a Pixel.
Definition: Pixel.h:217
VariancePixelT variance() const
Return the variance part of a Pixel.
Definition: Pixel.h:221
A single pixel of the same type as a MaskedImage.
Definition: Pixel.h:73
VariancePixelT variance() const
Definition: Pixel.h:96
MaskPixelT mask() const
Definition: Pixel.h:95
ImagePixelT image() const
Definition: Pixel.h:94
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.
bool imagesOverlap(ImageBase< T1 > const &image1, ImageBase< T2 > const &image2)
Return true if the pixels for two images or masks overlap in memory.
Definition: Image.cc:705
A base class for image defects.
T reset(T... args)
Options for writing an image to FITS.
Definition: fits.h:219
T swap(T... args)