LSST Applications g063fba187b+fee0456c91,g0f08755f38+ea96e5a5a3,g1653933729+a8ce1bb630,g168dd56ebc+a8ce1bb630,g1a2382251a+90257ff92a,g20f6ffc8e0+ea96e5a5a3,g217e2c1bcf+937a289c59,g28da252d5a+daa7da44eb,g2bbee38e9b+253935c60e,g2bc492864f+253935c60e,g3156d2b45e+6e55a43351,g32e5bea42b+31359a2a7a,g347aa1857d+253935c60e,g35bb328faa+a8ce1bb630,g3a166c0a6a+253935c60e,g3b1af351f3+a8ce1bb630,g3e281a1b8c+c5dd892a6c,g414038480c+416496e02f,g41af890bb2+afe91b1188,g599934f4f4+0db33f7991,g7af13505b9+e36de7bce6,g80478fca09+da231ba887,g82479be7b0+a4516e59e3,g858d7b2824+ea96e5a5a3,g89c8672015+f4add4ffd5,g9125e01d80+a8ce1bb630,ga5288a1d22+bc6ab8dfbd,gb58c049af0+d64f4d3760,gc28159a63d+253935c60e,gcab2d0539d+3f2b72788c,gcf0d15dbbd+4ea9c45075,gda6a2b7d83+4ea9c45075,gdaeeff99f8+1711a396fd,ge79ae78c31+253935c60e,gef2f8181fd+3031e3cf99,gf0baf85859+c1f95f4921,gfa517265be+ea96e5a5a3,gfa999e8aa5+17cd334064,w.2024.50
LSST Data Management Base Package
Loading...
Searching...
No Matches
CoaddBoundedField.cc
Go to the documentation of this file.
1// -*- LSST-C++ -*-
2/*
3 * LSST Data Management System
4 * Copyright 2008-2014, 2010 LSST Corporation.
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 <http://www.lsstcorp.org/LegalNotices/>.
22 */
23
25#include "lsst/geom/Box.h"
32
33namespace lsst {
34namespace afw {
35namespace table {
36namespace io {
37
40
41} // namespace io
42} // namespace table
43} // namespace afw
44namespace meas {
45namespace algorithms {
46namespace {
47
48/*
49 * Compare two pointers of the same type
50 *
51 * If both pointers are set then return *a == *b
52 * else return a == b
53 */
54template <typename T>
55bool ptrEquals(T a, T b) {
56 if (a == b) {
57 // test this first for efficiency
58 return true;
59 } else if (a && b) {
60 // both pointers are set, so it is safe to check value equality
61 return *a == *b;
62 }
63 return false;
64}
65
66} // namespace
67
68bool CoaddBoundedFieldElement::operator==(CoaddBoundedFieldElement const& rhs) const {
69 return ptrEquals(field, rhs.field) && ptrEquals(wcs, rhs.wcs) &&
70 ptrEquals(validPolygon, rhs.validPolygon) && (weight == rhs.weight);
71}
72
73CoaddBoundedField::CoaddBoundedField(geom::Box2I const& bbox, std::shared_ptr<afw::geom::SkyWcs const> coaddWcs,
74 ElementVector const& elements)
75 : afw::math::BoundedField(bbox),
76 _throwOnMissing(true),
77 _default(0.0), // unused
78 _coaddWcs(coaddWcs),
79 _elements(elements) {}
80
82 ElementVector const& elements, double default_)
83 : afw::math::BoundedField(bbox),
84 _throwOnMissing(false),
85 _default(default_),
86 _coaddWcs(coaddWcs),
87 _elements(elements) {}
88
89double CoaddBoundedField::evaluate(geom::Point2D const& position) const {
90 auto coord = _coaddWcs->pixelToSky(position);
91 double sum = 0.0;
92 double wSum = 0.0;
93 for (ElementVector::const_iterator i = _elements.begin(); i != _elements.end(); ++i) {
94 geom::Point2D transformedPosition = i->wcs->skyToPixel(coord);
95 bool inValidArea = i->validPolygon ? i->validPolygon->contains(transformedPosition) : true;
96 if (geom::Box2D(i->field->getBBox()).contains(transformedPosition) && inValidArea) {
97 sum += i->weight * i->field->evaluate(transformedPosition);
98 wSum += i->weight;
99 }
100 }
101 if (wSum == 0.0) {
102 if (_throwOnMissing) {
104 (boost::format("No constituent fields to evaluate at point %f, %f") %
105 position.getX() % position.getY())
106 .str());
107 } else {
108 return _default;
109 }
110 }
111 return sum / wSum;
112}
113
114// ---------- Persistence -----------------------------------------------------------------------------------
115
116// For persistence of CoaddBoundedField, we have two catalogs: the first has just one record, and contains
117// the archive ID of the coadd WCS and the parameters that control missing data. The other catalog
118// has one record for each element, with fields corresponding to the data members of the Element struct.
119
120namespace {
121
122// Singleton class that manages the first persistence catalog's schema and keys
123class CoaddBoundedFieldPersistenceKeys1 {
124public:
125 afw::table::Schema schema;
126 afw::table::PointKey<int> bboxMin;
127 afw::table::PointKey<int> bboxMax;
128 afw::table::Key<int> coaddWcs;
129 afw::table::Key<afw::table::Flag> throwOnMissing;
130 afw::table::Key<double> default_;
131
132 static CoaddBoundedFieldPersistenceKeys1 const& get() {
133 static CoaddBoundedFieldPersistenceKeys1 const instance;
134 return instance;
135 }
136
137 // No copying
138 CoaddBoundedFieldPersistenceKeys1(const CoaddBoundedFieldPersistenceKeys1&) = delete;
139 CoaddBoundedFieldPersistenceKeys1& operator=(const CoaddBoundedFieldPersistenceKeys1&) = delete;
140
141 // No moving
142 CoaddBoundedFieldPersistenceKeys1(CoaddBoundedFieldPersistenceKeys1&&) = delete;
143 CoaddBoundedFieldPersistenceKeys1& operator=(CoaddBoundedFieldPersistenceKeys1&&) = delete;
144
145private:
146 CoaddBoundedFieldPersistenceKeys1()
147 : schema(),
148 bboxMin(afw::table::PointKey<int>::addFields(schema, "bbox_min",
149 "lower-left corner of bounding box", "pixel")),
150 bboxMax(afw::table::PointKey<int>::addFields(schema, "bbox_max",
151 "upper-right corner of bounding box", "pixel")),
152 coaddWcs(schema.addField<int>("coaddWcs", "archive ID of the coadd's WCS")),
153 throwOnMissing(schema.addField<afw::table::Flag>(
154 "throwOnMissing", "whether to throw an exception on missing data")),
155 default_(schema.addField<double>("default",
156 "default value to use when throwOnMissing is False")) {}
157};
158
159// Singleton class that manages the second persistence catalog's schema and keys
160class CoaddBoundedFieldPersistenceKeys2 {
161public:
162 afw::table::Schema schema;
163 afw::table::Key<int> field;
164 afw::table::Key<int> wcs;
165 afw::table::Key<int> validPolygon;
166 afw::table::Key<double> weight;
167
168 static CoaddBoundedFieldPersistenceKeys2 const& get() {
169 static CoaddBoundedFieldPersistenceKeys2 const instance;
170 return instance;
171 }
172
173 // No copying
174 CoaddBoundedFieldPersistenceKeys2(const CoaddBoundedFieldPersistenceKeys2&) = delete;
175 CoaddBoundedFieldPersistenceKeys2& operator=(const CoaddBoundedFieldPersistenceKeys2&) = delete;
176
177 // No moving
178 CoaddBoundedFieldPersistenceKeys2(CoaddBoundedFieldPersistenceKeys2&&) = delete;
179 CoaddBoundedFieldPersistenceKeys2& operator=(CoaddBoundedFieldPersistenceKeys2&&) = delete;
180
181private:
182 CoaddBoundedFieldPersistenceKeys2()
183 : schema(),
184 field(schema.addField<int>("field", "archive ID of the BoundedField to be coadded")),
185 wcs(schema.addField<int>("wcs", "archive ID of the Wcs associated with this element")),
186 validPolygon(schema.addField<int>("validPolygon",
187 "archive ID of the Polygon associated with this element")),
188 weight(schema.addField<double>("weight", "weight value for this element")) {}
189};
190
191} // namespace
192
194public:
196 read(InputArchive const& archive, CatalogVector const& catalogs) const {
197 CoaddBoundedFieldPersistenceKeys1 const& keys1 = CoaddBoundedFieldPersistenceKeys1::get();
198 CoaddBoundedFieldPersistenceKeys2 const& keys2 = CoaddBoundedFieldPersistenceKeys2::get();
199 LSST_ARCHIVE_ASSERT(catalogs.size() == 2u);
200 LSST_ARCHIVE_ASSERT(catalogs.front().getSchema() == keys1.schema);
201 LSST_ARCHIVE_ASSERT(catalogs.back().getSchema() == keys2.schema);
202 afw::table::BaseRecord const& record1 = catalogs.front().front();
203 ElementVector elements;
204 elements.reserve(catalogs.back().size());
205 for (afw::table::BaseCatalog::const_iterator i = catalogs.back().begin(); i != catalogs.back().end();
206 ++i) {
207 elements.push_back(Element(archive.get<afw::math::BoundedField>(i->get(keys2.field)),
208 archive.get<afw::geom::SkyWcs>(i->get(keys2.wcs)),
209 archive.get<afw::geom::polygon::Polygon>(i->get(keys2.validPolygon)),
210 i->get(keys2.weight)));
211 }
212 return std::make_shared<CoaddBoundedField>(
213 geom::Box2I(record1.get(keys1.bboxMin), record1.get(keys1.bboxMax)),
214 archive.get<afw::geom::SkyWcs>(record1.get(keys1.coaddWcs)), elements,
215 record1.get(keys1.default_));
216 }
217
218 Factory(std::string const& name) : afw::table::io::PersistableFactory(name) {}
219};
220
221namespace {
222
223std::string getCoaddBoundedFieldPersistenceName() { return "CoaddBoundedField"; }
224
225CoaddBoundedField::Factory registration(getCoaddBoundedFieldPersistenceName());
226
227} // namespace
228
229std::string CoaddBoundedField::getPersistenceName() const { return getCoaddBoundedFieldPersistenceName(); }
230
231std::string CoaddBoundedField::getPythonModule() const { return "lsst.meas.algorithms"; }
232
234 CoaddBoundedFieldPersistenceKeys1 const& keys1 = CoaddBoundedFieldPersistenceKeys1::get();
235 CoaddBoundedFieldPersistenceKeys2 const& keys2 = CoaddBoundedFieldPersistenceKeys2::get();
236 afw::table::BaseCatalog cat1 = handle.makeCatalog(keys1.schema);
238 record1->set(keys1.bboxMin, getBBox().getMin());
239 record1->set(keys1.bboxMax, getBBox().getMax());
240 record1->set(keys1.coaddWcs, handle.put(_coaddWcs));
241 record1->set(keys1.default_, _default);
242 handle.saveCatalog(cat1);
243 afw::table::BaseCatalog cat2 = handle.makeCatalog(keys2.schema);
244 for (ElementVector::const_iterator i = _elements.begin(); i != _elements.end(); ++i) {
246 record2->set(keys2.field, handle.put(i->field));
247 record2->set(keys2.wcs, handle.put(i->wcs));
248 record2->set(keys2.validPolygon, handle.put(i->validPolygon));
249 record2->set(keys2.weight, i->weight);
250 }
251 handle.saveCatalog(cat2);
252}
253
255 throw LSST_EXCEPT(pex::exceptions::NotFoundError, "Scaling of CoaddBoundedField is not implemented");
256}
257
258bool CoaddBoundedField::operator==(BoundedField const& rhs) const {
259 auto rhsCasted = dynamic_cast<CoaddBoundedField const*>(&rhs);
260 if (!rhsCasted) return false;
261
262 return (getBBox() == rhsCasted->getBBox()) && (_default == rhsCasted->_default) &&
263 ptrEquals(_coaddWcs, rhsCasted->_coaddWcs) && (_elements == rhsCasted->_elements);
264}
265
266} // namespace algorithms
267} // namespace meas
268} // namespace lsst
AmpInfoBoxKey bbox
Definition Amplifier.cc:117
table::Key< int > field
Definition ApCorrMap.cc:77
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition Exception.h:48
table::Key< table::Array< std::uint8_t > > wcs
Definition SkyWcs.cc:66
table::Key< int > b
#define LSST_ARCHIVE_ASSERT(EXPR)
An assertion macro used to validate the structure of an InputArchive.
Definition Persistable.h:48
table::Schema schema
Definition python.h:134
T begin(T... args)
A 2-dimensional celestial WCS that transform pixels to ICRS RA/Dec, using the LSST standard for pixel...
Definition SkyWcs.h:117
Cartesian polygons.
Definition Polygon.h:59
An abstract base class for 2-d functions defined on an integer bounding boxes.
lsst::geom::Box2I getBBox() const
Return the bounding box that defines the region where the field is valid.
Tag types used to declare specialized field types.
Definition misc.h:31
Base class for all records.
Definition BaseRecord.h:31
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:489
A vector of catalogs used by Persistable.
A multi-catalog archive object used to load table::io::Persistable objects.
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...
static std::shared_ptr< T > dynamicCast(std::shared_ptr< Persistable > const &ptr)
Dynamically cast a shared_ptr.
A base class for factory classes used to reconstruct objects from records.
A floating-point coordinate rectangle geometry.
Definition Box.h:413
bool contains(Point2D const &point) const noexcept
Return true if the box contains the point.
Definition Box.cc:322
An integer coordinate rectangle.
Definition Box.h:55
virtual std::shared_ptr< afw::table::io::Persistable > read(InputArchive const &archive, CatalogVector const &catalogs) const
Construct a new object from the given InputArchive and vector of catalogs.
CoaddBoundedField(geom::Box2I const &bbox, std::shared_ptr< afw::geom::SkyWcs const > coaddWcs, ElementVector const &elements)
void write(OutputArchiveHandle &handle) const override
Write the object to one or more catalogs.
std::shared_ptr< afw::math::BoundedField > operator*(double const scale) const override
Return a scaled BoundedField.
std::string getPythonModule() const override
Return the fully-qualified Python module that should be imported to guarantee that its factory is reg...
double evaluate(geom::Point2D const &position) const override
Evaluate the field at the given point.
bool operator==(BoundedField const &rhs) const override
BoundedFields (of the same sublcass) are equal if their bounding boxes and parameters are equal.
std::string getPersistenceName() const override
Return the unique name used to persist this object and look up its factory.
Reports arguments outside the domain of an operation.
Definition Runtime.h:57
Reports attempts to access elements using an invalid key.
Definition Runtime.h:151
T end(T... args)
T push_back(T... args)
T reserve(T... args)
afw::table::Key< double > weight
afw::table::PointKey< int > bboxMax
afw::table::Key< afw::table::Flag > throwOnMissing
afw::table::Key< int > coaddWcs
afw::table::Key< double > default_
afw::table::PointKey< int > bboxMin
Struct used to hold one Exposure's data in a CoaddBoundedField.
std::shared_ptr< afw::geom::SkyWcs const > wcs
std::shared_ptr< afw::math::BoundedField > field
std::shared_ptr< afw::geom::polygon::Polygon const > validPolygon
Key< int > validPolygon
Definition Exposure.cc:69