LSST Applications  21.0.0-147-g0e635eb1+1acddb5be5,22.0.0+052faf71bd,22.0.0+1ea9a8b2b2,22.0.0+6312710a6c,22.0.0+729191ecac,22.0.0+7589c3a021,22.0.0+9f079a9461,22.0.1-1-g7d6de66+b8044ec9de,22.0.1-1-g87000a6+536b1ee016,22.0.1-1-g8e32f31+6312710a6c,22.0.1-10-gd060f87+016f7cdc03,22.0.1-12-g9c3108e+df145f6f68,22.0.1-16-g314fa6d+c825727ab8,22.0.1-19-g93a5c75+d23f2fb6d8,22.0.1-19-gb93eaa13+aab3ef7709,22.0.1-2-g8ef0a89+b8044ec9de,22.0.1-2-g92698f7+9f079a9461,22.0.1-2-ga9b0f51+052faf71bd,22.0.1-2-gac51dbf+052faf71bd,22.0.1-2-gb66926d+6312710a6c,22.0.1-2-gcb770ba+09e3807989,22.0.1-20-g32debb5+b8044ec9de,22.0.1-23-gc2439a9a+fb0756638e,22.0.1-3-g496fd5d+09117f784f,22.0.1-3-g59f966b+1e6ba2c031,22.0.1-3-g849a1b8+f8b568069f,22.0.1-3-gaaec9c0+c5c846a8b1,22.0.1-32-g5ddfab5d3+60ce4897b0,22.0.1-4-g037fbe1+64e601228d,22.0.1-4-g8623105+b8044ec9de,22.0.1-5-g096abc9+d18c45d440,22.0.1-5-g15c806e+57f5c03693,22.0.1-7-gba73697+57f5c03693,master-g6e05de7fdc+c1283a92b8,master-g72cdda8301+729191ecac,w.2021.39
LSST Data Management Base Package
Footprint.cc
Go to the documentation of this file.
1 
2 /*
3  * LSST Data Management System
4  * Copyright 2008-2016 AURA/LSST.
5  *
6  * This product includes software developed by the
7  * LSST Project (http://www.lsst.org/).
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the LSST License Statement and
20  * the GNU General Public License along with this program. If not,
21  * see <https://www.lsstcorp.org/LegalNotices/>.
22  */
23 
29 
30 namespace lsst {
31 namespace afw {
32 
33 template std::shared_ptr<detection::Footprint> table::io::PersistableFacade<
35 
36 namespace detection {
37 
39  : _spans(inputSpans), _peaks(PeakTable::makeMinimalSchema()), _region(region) {}
40 
42  lsst::geom::Box2I const& region)
43  : _spans(inputSpans), _peaks(peakSchema), _region(region) {}
44 
45 void Footprint::setSpans(std::shared_ptr<geom::SpanSet> otherSpanSet) { _spans = otherSpanSet; }
46 
47 std::shared_ptr<PeakRecord> Footprint::addPeak(float fx, float fy, float height) {
49  p->setIx(fx);
50  p->setIy(fy);
51  p->setFx(fx);
52  p->setFy(fy);
53  p->setPeakValue(height);
54  return p;
55 }
56 
58  auto validatedKey = key.isValid() ? key : PeakTable::getPeakValueKey();
59  getPeaks().sort([&validatedKey](detection::PeakRecord const& a, detection::PeakRecord const& b) {
60  return a.get(validatedKey) > b.get(validatedKey);
61  });
62 }
63 
64 void Footprint::shift(int dx, int dy) {
65  setSpans(getSpans()->shiftedBy(dx, dy));
66  for (auto& peak : getPeaks()) {
67  peak.setIx(peak.getIx() + dx);
68  peak.setIy(peak.getIy() + dy);
69  peak.setFx(peak.getFx() + dx);
70  peak.setFy(peak.getFy() + dy);
71  }
72 }
73 
75  setSpans(getSpans()->clippedTo(box));
77 }
78 
79 bool Footprint::contains(lsst::geom::Point2I const& pix) const { return getSpans()->contains(pix); }
80 
83  lsst::geom::Box2I const& region, bool doClip) const {
84  auto srcToTarget = geom::makeWcsPairTransform(*source, *target);
85  return transform(*srcToTarget, region, doClip);
86 }
87 
89  lsst::geom::Box2I const& region, bool doClip) const {
90  return transform(lsst::geom::AffineTransform(t), region, doClip);
91 }
92 
94  lsst::geom::Box2I const& region, bool doClip) const {
95  return transform(*geom::makeTransform(t), region, doClip);
96 }
97 
99  lsst::geom::Box2I const& region, bool doClip) const {
100  // Transfrom the SpanSet first
101  auto transformedSpan = getSpans()->transformedBy(t);
102  // Use this new SpanSet and the peakSchema to create a new Footprint
103  auto newFootprint = std::make_shared<Footprint>(transformedSpan, getPeaks().getSchema(), region);
104  // now populate the new Footprint with transformed Peaks
106  peakPosList.reserve(_peaks.size());
107  for (auto const& peak : getPeaks()) {
108  peakPosList.emplace_back(peak.getF());
109  }
110  auto newPeakPosList = t.applyForward(peakPosList);
111  auto newPeakPos = newPeakPosList.cbegin();
112  for (auto peak = getPeaks().cbegin(), endPeak = getPeaks().cend(); peak != endPeak;
113  ++peak, ++newPeakPos) {
114  newFootprint->addPeak(newPeakPos->getX(), newPeakPos->getY(), peak->getPeakValue());
115  }
116  if (doClip) {
117  newFootprint->clipTo(region);
118  }
119  return newFootprint;
120 }
121 
122 void Footprint::dilate(int r, geom::Stencil s) { setSpans(getSpans()->dilated(r, s)); }
123 
124 void Footprint::dilate(geom::SpanSet const& other) { setSpans(getSpans()->dilated(other)); }
125 
127  setSpans(getSpans()->eroded(r, s));
129 }
130 
131 void Footprint::erode(geom::SpanSet const& other) {
132  setSpans(getSpans()->eroded(other));
134 }
135 
137  for (auto iter = getPeaks().begin(); iter != getPeaks().end(); ++iter) {
138  if (!getSpans()->contains(lsst::geom::Point2I(iter->getIx(), iter->getIy()))) {
139  iter = getPeaks().erase(iter);
140  --iter;
141  }
142  }
143 }
144 
146  auto splitSpanSets = getSpans()->split();
148  footprintList.reserve(splitSpanSets.size());
149  for (auto& spanPtr : splitSpanSets) {
150  auto tmpFootprintPointer = std::make_shared<Footprint>(spanPtr, getPeaks().getSchema(), getRegion());
151  tmpFootprintPointer->_peaks = getPeaks();
152  // No need to remove any peaks, as there is only one Footprint, so it will
153  // simply be a copy of the original
154  if (splitSpanSets.size() > 1) {
155  tmpFootprintPointer->removeOrphanPeaks();
156  }
157  footprintList.push_back(std::move(tmpFootprintPointer));
158  }
159  return footprintList;
160 }
161 
162 bool Footprint::operator==(Footprint const& other) const {
163  /* If the peakCatalogs are not the same length the Footprints can't be equal */
164  if (getPeaks().size() != other.getPeaks().size()) {
165  return false;
166  }
167  /* Check that for every peak in the PeakCatalog there is a corresponding peak
168  * in the other, and if not return false
169  */
170  for (auto const& selfPeak : getPeaks()) {
171  bool match = false;
172  for (auto const& otherPeak : other.getPeaks()) {
173  if (selfPeak.getI() == otherPeak.getI() && selfPeak.getF() == otherPeak.getF() &&
174  selfPeak.getPeakValue() == otherPeak.getPeakValue()) {
175  match = true;
176  break;
177  }
178  }
179  if (!match) {
180  return false;
181  }
182  }
183  /* At this point the PeakCatalogs have evaluated true, compare the SpanSets
184  */
185  return *(getSpans()) == *(other.getSpans());
186 }
187 
188 namespace {
189 std::string getFootprintPersistenceName() { return "Footprint"; }
190 
191 class LegacyFootprintPersistenceHelper {
192 public:
193  table::Schema spanSchema;
194  table::Key<int> spanY;
195  table::Key<int> spanX0;
196  table::Key<int> spanX1;
197 
198  static LegacyFootprintPersistenceHelper const& get() {
199  static LegacyFootprintPersistenceHelper instance;
200  return instance;
201  }
202 
203  // No copying
204  LegacyFootprintPersistenceHelper(const LegacyFootprintPersistenceHelper&) = delete;
205  LegacyFootprintPersistenceHelper& operator=(const LegacyFootprintPersistenceHelper&) = delete;
206 
207  // No moving
208  LegacyFootprintPersistenceHelper(LegacyFootprintPersistenceHelper&&) = delete;
209  LegacyFootprintPersistenceHelper& operator=(LegacyFootprintPersistenceHelper&&) = delete;
210 
211 private:
212  LegacyFootprintPersistenceHelper()
213  : spanSchema(),
214  spanY(spanSchema.addField<int>("y", "The row of the span", "pixel")),
215  spanX0(spanSchema.addField<int>("x0", "First column of span (inclusive)", "pixel")),
216  spanX1(spanSchema.addField<int>("x1", "Second column of span (inclusive)", "pixel")) {}
217 };
218 
219 std::pair<afw::table::Schema&, table::Key<int>&> spanSetPersistenceHelper() {
220  static afw::table::Schema spanSetIdSchema;
221  static int initialize = true;
222  static table::Key<int> idKey;
223  if (initialize) {
224  idKey = spanSetIdSchema.addField<int>("id", "id of the SpanSet catalog");
225  initialize = false;
226  }
227  std::pair<afw::table::Schema&, table::Key<int>&> returnPair(spanSetIdSchema, idKey);
228  return returnPair;
229 }
230 } // end anonymous namespace
231 
233 public:
235  afw::table::io::InputArchive const& archive,
236  afw::table::io::CatalogVector const& catalogs) const override {
237  // Verify there are two catalogs
238  LSST_ARCHIVE_ASSERT(catalogs.size() == 2u);
239  std::shared_ptr<Footprint> loadedFootprint =
240  detection::Footprint::readSpanSet(catalogs.front(), archive);
241  // Now read in the PeakCatalog records
242  detection::Footprint::readPeaks(catalogs.back(), *loadedFootprint);
243  return loadedFootprint;
244  }
245 
246  explicit FootprintFactory(std::string const& name) : afw::table::io::PersistableFactory(name) {}
247 };
248 
249 namespace {
250 // Insert the factory into the registry (instantiating an instance is sufficient, because the
251 // the code that does the work is in the base class ctor)
252 FootprintFactory registration(getFootprintPersistenceName());
253 } // end anonymous namespace
254 
255 std::string Footprint::getPersistenceName() const { return getFootprintPersistenceName(); }
256 
258  // get the span schema and key
259  auto const keys = spanSetPersistenceHelper();
260  // create the output catalog
261  afw::table::BaseCatalog spanSetCat = handle.makeCatalog(keys.first);
262  // create a record that will hold the ID of the recursively saved SpanSet
263  auto record = spanSetCat.addNew();
264  record->set(keys.second, handle.put(getSpans()));
265  handle.saveCatalog(spanSetCat);
266  // save the peaks into a catalog
267  afw::table::BaseCatalog peakCat = handle.makeCatalog(getPeaks().getSchema());
268  peakCat.insert(peakCat.end(), getPeaks().begin(), getPeaks().end(), true);
269  handle.saveCatalog(peakCat);
270 }
271 
273  afw::table::io::InputArchive const& archive) {
274  int fieldCount = catalog.getSchema().getFieldCount();
275  LSST_ARCHIVE_ASSERT(fieldCount == 1 || fieldCount == 3);
276  std::shared_ptr<geom::SpanSet> loadedSpanSet;
277  if (fieldCount == 1) {
278  // This is a new style footprint with a SpanSet as a member, treat accordingly
279  auto const schemaAndKey = spanSetPersistenceHelper();
280  int persistedSpanSetId = catalog.front().get(schemaAndKey.second);
281  loadedSpanSet = std::dynamic_pointer_cast<geom::SpanSet>(archive.get(persistedSpanSetId));
282  } else {
283  // This block is for an old style footprint load.
284  auto const& keys = LegacyFootprintPersistenceHelper::get();
285  std::vector<geom::Span> tempVec;
286  tempVec.reserve(catalog.size());
287  for (auto const& val : catalog) {
288  tempVec.emplace_back(val.get(keys.spanY), val.get(keys.spanX0), val.get(keys.spanX1));
289  }
290  loadedSpanSet = std::make_shared<geom::SpanSet>(std::move(tempVec));
291  }
292  auto loadedFootprint = std::unique_ptr<Footprint>(new Footprint(loadedSpanSet));
293  return loadedFootprint;
294 }
295 
296 void Footprint::readPeaks(afw::table::BaseCatalog const& peakCat, Footprint& loadedFootprint) {
297  using namespace std::string_literals;
298  if (!peakCat.getSchema().contains(PeakTable::makeMinimalSchema())) {
299  // need to handle an older form of Peak persistence for backwards compatibility
301  mapper.addMinimalSchema(PeakTable::makeMinimalSchema());
302  afw::table::Key<float> oldX = peakCat.getSchema()["x"];
303  afw::table::Key<float> oldY = peakCat.getSchema()["y"];
304  afw::table::Key<float> oldPeakValue = peakCat.getSchema()["value"];
305  mapper.addMapping(oldX, "f.x"s);
306  mapper.addMapping(oldY, "f.y"s);
307  mapper.addMapping(oldPeakValue, "peakValue"s);
308  loadedFootprint.setPeakSchema(mapper.getOutputSchema());
309  auto peaks = loadedFootprint.getPeaks();
310  peaks.reserve(peakCat.size());
311  for (auto const& peak : peakCat) {
312  auto newPeak = peaks.addNew();
313  newPeak->assign(peak, mapper);
314  newPeak->setIx(static_cast<int>(newPeak->getFx()));
315  newPeak->setIy(static_cast<int>(newPeak->getFy()));
316  }
317  return;
318  }
319  loadedFootprint.setPeakSchema(peakCat.getSchema());
320  auto& peaks = loadedFootprint.getPeaks();
321  peaks.reserve(peakCat.size());
322  for (auto const& peak : peakCat) {
323  peaks.addNew()->assign(peak);
324  }
325 }
326 
327 std::shared_ptr<Footprint> mergeFootprints(Footprint const& footprint1, Footprint const& footprint2) {
328  // Bail out early if the schemas are not the same
329  if (footprint1.getPeaks().getSchema() != footprint2.getPeaks().getSchema()) {
331  "Cannot merge Footprints with different Schemas");
332  }
333 
334  // Merge the SpanSets
335  auto unionedSpanSet = footprint1.getSpans()->union_(*(footprint2.getSpans()));
336 
337  // Construct merged Footprint
338  auto mergedFootprint = std::make_shared<Footprint>(unionedSpanSet, footprint1.getPeaks().getSchema());
339  // Copy over the peaks from both footprints
340  mergedFootprint->setPeakCatalog(PeakCatalog(footprint1.getPeaks().getTable()));
341  PeakCatalog& peaks = mergedFootprint->getPeaks();
342  peaks.reserve(footprint1.getPeaks().size() + footprint2.getPeaks().size());
343  peaks.insert(peaks.end(), footprint1.getPeaks().begin(), footprint1.getPeaks().end(), true);
344  peaks.insert(peaks.end(), footprint2.getPeaks().begin(), footprint2.getPeaks().end(), true);
345 
346  // Sort the PeaksCatalog according to value
347  mergedFootprint->sortPeaks();
348 
349  return mergedFootprint;
350 }
351 
353  using PixelT = std::uint16_t;
354  lsst::geom::Box2I fpBBox = footprint.getBBox();
356  *idImage = 0;
357  int const height = fpBBox.getHeight();
358  lsst::geom::Extent2I shift(fpBBox.getMinX(), fpBBox.getMinY());
359  footprint.getSpans()->setImage(*idImage, static_cast<PixelT>(1), fpBBox, true);
360 
362  /*
363  * Our strategy is to find a row of pixels in the Footprint and interpret it as the first
364  * row of a rectangular set of pixels. We then extend this rectangle upwards as far as it
365  * will go, and define that as a BBox. We clear all those pixels, and repeat until there
366  * are none left. I.e. a Footprint will get cut up like this:
367  *
368  * .555...
369  * 22.3314
370  * 22.331.
371  * .000.1.
372  * (as shown in Footprint_1.py)
373  */
374 
375  int y0 = 0; // the first row with non-zero pixels in it
376  while (y0 < height) {
377  lsst::geom::Box2I bbox; // our next BBox
378  for (int y = y0; y < height; ++y) {
379  // Look for a set pixel in this row
380  image::Image<PixelT>::x_iterator begin = idImage->row_begin(y), end = idImage->row_end(y);
382 
383  if (first != end) { // A pixel is set in this row
385  int const x0 = first - begin;
386  int const x1 = last - begin;
387  int const x_size = 1 + x1 - x0;
388 
389  std::fill(first, last + 1, 0); // clear pixels; we don't want to see them again
390 
391  bbox.include(lsst::geom::Point2I(x0, y)); // the LLC
392  bbox.include(lsst::geom::Point2I(x1, y)); // the LRC; initial guess for URC
393 
394  // we found at least one pixel so extend the BBox upwards
395  for (++y; y < height; ++y) {
396  if (std::find(idImage->at(x0, y), idImage->at(x0, y) + x_size, 0) !=
397  idImage->at(x0, y) + x_size) {
398  break; // some pixels weren't set, so the BBox stops here, (actually in previous row)
399  }
400  std::fill(idImage->at(x0, y), idImage->at(x0, y) + x_size, 0);
401 
402  bbox.include(lsst::geom::Point2I(x1, y)); // the new URC
403  }
404 
405  bbox.shift(shift);
406  bboxes.push_back(bbox);
407  } else {
408  y0 = y + 1;
409  }
410  break;
411  }
412  }
413 
414  return bboxes;
415 }
416 
418  setPeakCatalog(PeakCatalog(peakSchema));
419 }
420 
421 void Footprint::setPeakCatalog(PeakCatalog const& otherPeaks) {
422  if (!getPeaks().empty()) {
423  throw LSST_EXCEPT(pex::exceptions::LogicError, "Cannot change the PeakCatalog unless it is empty");
424  }
425  // this syntax doesn't work in Python, which is why this method has to exist
426  getPeaks() = otherPeaks;
427 }
428 } // namespace detection
429 } // namespace afw
430 } // namespace lsst
table::Key< std::string > name
Definition: Amplifier.cc:116
AmpInfoBoxKey bbox
Definition: Amplifier.cc:117
Key< Flag > const & target
int end
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
table::Schema spanSchema
Definition: Footprint.cc:193
table::Key< int > spanX1
Definition: Footprint.cc:196
table::Key< int > spanY
Definition: Footprint.cc:194
table::Key< int > spanX0
Definition: Footprint.cc:195
SchemaMapper * mapper
Definition: SchemaMapper.cc:71
int y
Definition: SpanSet.cc:48
table::Key< int > b
table::Key< int > a
#define LSST_ARCHIVE_ASSERT(EXPR)
An assertion macro used to validate the structure of an InputArchive.
Definition: Persistable.h:48
T back(T... args)
std::shared_ptr< afw::table::io::Persistable > read(afw::table::io::InputArchive const &archive, afw::table::io::CatalogVector const &catalogs) const override
Construct a new object from the given InputArchive and vector of catalogs.
Definition: Footprint.cc:234
FootprintFactory(std::string const &name)
Definition: Footprint.cc:246
Class to describe the properties of a detected object from an image.
Definition: Footprint.h:63
Footprint()
Constructor of a empty Footprint object.
Definition: Footprint.h:96
lsst::geom::Box2I getRegion() const
Return the corners of the MaskedImage the footprints live in.
Definition: Footprint.h:213
std::shared_ptr< PeakRecord > addPeak(float fx, float fy, float value)
Convenience function to add a peak.
Definition: Footprint.cc:47
static std::unique_ptr< Footprint > readSpanSet(afw::table::BaseCatalog const &, afw::table::io::InputArchive const &)
Static method used to unpersist the SpanSet member of the Footprint class.
Definition: Footprint.cc:272
void write(OutputArchiveHandle &handle) const override
Write an instance of a Footprint to an output Archive.
Definition: Footprint.cc:257
std::shared_ptr< Footprint > transform(std::shared_ptr< geom::SkyWcs > source, std::shared_ptr< geom::SkyWcs > target, lsst::geom::Box2I const &region, bool doClip=true) const
Transform the footprint from one WCS to another.
Definition: Footprint.cc:81
bool contains(lsst::geom::Point2I const &pix) const
Tests if a pixel postion falls inside the Footprint.
Definition: Footprint.cc:79
std::vector< std::shared_ptr< Footprint > > split() const
Split a multi-component Footprint into a vector of contiguous Footprints.
Definition: Footprint.cc:145
std::shared_ptr< geom::SpanSet > getSpans() const
Return a shared pointer to the SpanSet.
Definition: Footprint.h:115
void dilate(int r, geom::Stencil s=geom::Stencil::CIRCLE)
Dilate the Footprint with a defined kernel.
Definition: Footprint.cc:122
lsst::geom::Box2I getBBox() const
Return the Footprint's bounding box.
Definition: Footprint.h:208
void sortPeaks(afw::table::Key< float > const &key=afw::table::Key< float >())
Sort Peaks from most positive value to most negative.
Definition: Footprint.cc:57
void removeOrphanPeaks()
Remove peaks from the PeakCatalog that fall outside the area of the Footprint.
Definition: Footprint.cc:136
void setPeakSchema(afw::table::Schema const &peakSchema)
Set the Schema used by the PeakCatalog (will throw if PeakCatalog is not empty).
Definition: Footprint.cc:417
PeakCatalog & getPeaks()
Return the Peaks contained in this Footprint.
Definition: Footprint.h:129
void setSpans(std::shared_ptr< geom::SpanSet > otherSpanSet)
Sets the shared pointer to the SpanSet in the Footprint.
Definition: Footprint.cc:45
std::string getPersistenceName() const override
Return the name correspoinging ot the persistence type.
Definition: Footprint.cc:255
void clipTo(lsst::geom::Box2I const &bbox)
Clip the Footprint such that all values lie inside the supplied Bounding Box.
Definition: Footprint.cc:74
void erode(int r, geom::Stencil s=geom::Stencil::CIRCLE)
Erode the Footprint with a defined kernel.
Definition: Footprint.cc:126
void shift(int dx, int dy)
Shift a Footprint by (dx, dy)
Definition: Footprint.cc:64
bool operator==(Footprint const &other) const
equality operator
Definition: Footprint.cc:162
static void readPeaks(afw::table::BaseCatalog const &, Footprint &)
Static method used to unpersist the PeakCatalog member of the Footprint class.
Definition: Footprint.cc:296
void setPeakCatalog(PeakCatalog const &otherPeaks)
Set the peakCatalog to a copy of the supplied catalog.
Definition: Footprint.cc:421
Record class that represents a peak in a Footprint.
Definition: Peak.h:42
Table class for Peaks in Footprints.
Definition: Peak.h:102
static afw::table::Schema makeMinimalSchema()
Return a minimal schema for Peak tables and records.
Definition: Peak.h:137
static afw::table::Key< float > getPeakValueKey()
Definition: Peak.h:169
typename _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:51
Field< T >::Value get(Key< T > const &key) const
Return the value of a field for the given key.
Definition: BaseRecord.h:151
std::shared_ptr< RecordT > addNew()
Create a new record, add it to the end of the catalog, and return a pointer to it.
Definition: Catalog.h:490
size_type size() const
Return the number of elements in the catalog.
Definition: Catalog.h:413
iterator begin()
Iterator access.
Definition: Catalog.h:401
iterator erase(iterator pos)
Erase the record pointed to by pos, and return an iterator the next record.
Definition: Catalog.h:565
void reserve(size_type n)
Increase the capacity of the catalog to the given size.
Definition: Catalog.h:433
reference front() const
Return the first record.
Definition: Catalog.h:458
void sort(Key< T > const &key)
Sort the catalog in-place by the field with the given key.
Definition: Catalog.h:756
std::shared_ptr< Table > getTable() const
Return the table associated with the catalog.
Definition: Catalog.h:115
void insert(iterator pos, InputIterator first, InputIterator last, bool deep=false)
Insert an iterator range into the table.
Definition: Catalog.h:518
Schema getSchema() const
Return the schema associated with the catalog's table.
Definition: Catalog.h:118
bool isValid() const noexcept
Return true if the key was initialized to valid offset.
Definition: Key.h:97
Defines the fields and offsets for a table.
Definition: Schema.h:51
std::size_t getFieldCount() const
The total number of fields.
Definition: Schema.h:152
int contains(Schema const &other, int flags=EQUAL_KEYS) const
Test whether the given schema is a subset of this.
Definition: Schema.cc:490
A mapping between the keys of two Schemas, used to copy data between them.
Definition: SchemaMapper.h:21
A vector of catalogs used by Persistable.
Definition: CatalogVector.h:29
A multi-catalog archive object used to load table::io::Persistable objects.
Definition: InputArchive.h:31
std::shared_ptr< Persistable > get(int id) const
Load the Persistable with the given ID and return it.
An object passed to Persistable::write to allow it to persist itself.
void saveCatalog(BaseCatalog const &catalog)
Save a catalog in the archive.
BaseCatalog makeCatalog(Schema const &schema)
Return a new, empty catalog with the given schema.
int put(Persistable const *obj, bool permissive=false)
Save an object to the archive and return a unique ID that can be used to retrieve it from an InputArc...
A base class for factory classes used to reconstruct objects from records.
Definition: Persistable.h:228
PersistableFactory(std::string const &name)
Constructor for the factory.
Definition: Persistable.cc:74
An affine coordinate transformation consisting of a linear transformation and an offset.
An integer coordinate rectangle.
Definition: Box.h:55
int getMinY() const noexcept
Definition: Box.h:158
int getHeight() const noexcept
Definition: Box.h:188
int getMinX() const noexcept
Definition: Box.h:157
A 2D linear coordinate transformation.
Reports invalid arguments.
Definition: Runtime.h:66
Reports errors in the logical structure of the program.
Definition: Runtime.h:46
T emplace_back(T... args)
T fill(T... args)
T find(T... args)
T front(T... args)
T move(T... args)
const char * source()
Source function that allows astChannel to source from a Stream.
Definition: Stream.h:224
afw::table::CatalogT< PeakRecord > PeakCatalog
Definition: Peak.h:244
std::vector< lsst::geom::Box2I > footprintToBBoxList(Footprint const &footprint)
Return a list of BBoxs, whose union contains exactly the pixels in the footprint, neither more nor le...
Definition: Footprint.cc:352
std::shared_ptr< Footprint > mergeFootprints(Footprint const &footprint1, Footprint const &footprint2)
Merges two Footprints – appends their peaks, and unions their spans, returning a new Footprint.
Definition: Footprint.cc:327
std::shared_ptr< TransformPoint2ToPoint2 > makeTransform(lsst::geom::AffineTransform const &affine)
Wrap an lsst::geom::AffineTransform as a Transform.
Stencil
An enumeration class which describes the shapes.
Definition: SpanSet.h:66
std::shared_ptr< TransformPoint2ToPoint2 > makeWcsPairTransform(SkyWcs const &src, SkyWcs const &dst)
A Transform obtained by putting two SkyWcs objects "back to back".
Definition: SkyWcs.cc:146
Transform< Point2Endpoint, Point2Endpoint > TransformPoint2ToPoint2
Definition: Transform.h:300
FilterProperty & operator=(FilterProperty const &)=default
lsst::afw::detection::Footprint Footprint
Definition: Source.h:57
A base class for image defects.
T push_back(T... args)
T reserve(T... args)
T size(T... args)
ImageT val
Definition: CR.cc:146