lsst.afw 22.0.1-48-g5c39d4753+955d02b84f
Utils.cc
Go to the documentation of this file.
1// -*- lsst-c++ -*-
2
3/*
4 * LSST Data Management System
5 * Copyright 2008, 2009, 2010 LSST Corporation.
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//##====---------------- ----------------====##/
27//
28// Support for formatters
29//
30//##====---------------- ----------------====##/
31
32#include <cstdint>
33#include <iostream>
34
35#include "boost/format.hpp"
36#include "lsst/pex/exceptions.h"
40
41using std::int64_t;
42namespace ex = lsst::pex::exceptions;
45
46namespace lsst {
47namespace afw {
48namespace formatters {
49
51 if (properties->isArray("sliceId")) {
52 throw LSST_EXCEPT(ex::RuntimeError, "\"sliceId\" property has multiple values");
53 }
54 int sliceId = properties->getAsInt("sliceId");
55 if (sliceId < 0) {
56 throw LSST_EXCEPT(ex::RangeError, "negative \"sliceId\"");
57 }
58 if (properties->exists("universeSize") && !properties->isArray("universeSize")) {
59 int universeSize = properties->getAsInt("universeSize");
60 if (sliceId >= universeSize) {
61 throw LSST_EXCEPT(ex::RangeError, "\"sliceId\" must be less than \"universeSize \"");
62 }
63 }
64 return sliceId;
65}
66
68 if (properties->isArray("visitId")) {
69 throw LSST_EXCEPT(ex::RuntimeError, "\"visitId\" property has multiple values");
70 }
71 int visitId = properties->getAsInt("visitId");
72 if (visitId < 0) {
73 throw LSST_EXCEPT(ex::RangeError, "negative \"visitId\"");
74 }
75 return visitId;
76}
77
79 if (properties->isArray("fpaExposureId")) {
80 throw LSST_EXCEPT(ex::RuntimeError, "\"fpaExposureId\" property has multiple values");
81 }
82 int64_t fpaExposureId = properties->getAsInt64("fpaExposureId");
83 if (fpaExposureId < 0) {
84 throw LSST_EXCEPT(ex::RangeError, "negative \"fpaExposureId\"");
85 }
86 if ((fpaExposureId & 0xfffffffe00000000LL) != 0LL) {
87 throw LSST_EXCEPT(ex::RangeError, "\"fpaExposureId\" is too large");
88 }
89 return fpaExposureId;
90}
91
93 if (properties->isArray("ccdId")) {
94 throw LSST_EXCEPT(ex::RuntimeError, "\"ccdId\" property has multiple values");
95 }
96 int ccdId = properties->getAsInt("ccdId");
97 if (ccdId < 0) {
98 throw LSST_EXCEPT(ex::RangeError, "negative \"ccdId\"");
99 }
100 if (ccdId > 255) {
101 throw LSST_EXCEPT(ex::RangeError, "\"ccdId\" is too large");
102 }
103 return static_cast<int>(ccdId);
104}
105
107 if (properties->isArray("ampId")) {
108 throw LSST_EXCEPT(ex::RuntimeError, "\"ampId\" property has multiple values");
109 }
110 int ampId = properties->getAsInt("ampId");
111 if (ampId < 0) {
112 throw LSST_EXCEPT(ex::RangeError, "negative \"ampId\"");
113 }
114 if (ampId > 63) {
115 throw LSST_EXCEPT(ex::RangeError, "\"ampId\" is too large");
116 }
117 return (extractCcdId(properties) << 6) + ampId;
118}
119
121 if (properties->isArray("ccdExposureId")) {
122 throw LSST_EXCEPT(ex::RuntimeError, "\"ccdExposureId\" property has multiple values");
123 }
124 int64_t ccdExposureId = properties->getAsInt64("ccdExposureId");
125 if (ccdExposureId < 0) {
126 throw LSST_EXCEPT(ex::RangeError, "negative \"ccdExposureId\"");
127 }
128 return ccdExposureId;
129}
130
132 if (properties->isArray("ampExposureId")) {
133 throw LSST_EXCEPT(ex::RuntimeError, "\"ampExposureId\" property has multiple values");
134 }
135 int64_t ampExposureId = properties->getAsInt64("ampExposureId");
136 if (ampExposureId < 0) {
137 throw LSST_EXCEPT(ex::RangeError, "negative \"ampExposureId\"");
138 }
139 return ampExposureId;
140}
141
143 if (!properties) {
144 throw LSST_EXCEPT(ex::InvalidParameterError, "Null std::shared_ptr<PropertySet>");
145 }
146 if (properties->isArray("itemName")) {
147 throw LSST_EXCEPT(ex::InvalidParameterError, "\"itemName\" property has multiple values");
148 }
149 return properties->getAsString("itemName");
150}
151
153 if (properties && properties->exists(name)) {
154 return properties->getAsBool(name);
155 }
156 return false;
157}
158
159int countFitsHeaderCards(lsst::daf::base::PropertySet const& prop) { return prop.paramNames(false).size(); }
160
161ndarray::Array<std::uint8_t, 1, 1> stringToBytes(std::string const& str) {
162 auto nbytes = str.size() * sizeof(char) / sizeof(std::uint8_t);
163 std::uint8_t const* byteCArr = reinterpret_cast<std::uint8_t const*>(str.data());
164 auto shape = ndarray::makeVector(nbytes);
165 auto strides = ndarray::makeVector(1);
166 // Make an Array that shares memory with `str` (and does not free that memory when destroyed),
167 // then return a copy; this is simpler than manually copying the data into a newly allocated array
168 ndarray::Array<std::uint8_t const, 1, 1> localArray = ndarray::external(byteCArr, shape, strides);
169 return ndarray::copy(localArray);
170}
171
172std::string bytesToString(ndarray::Array<std::uint8_t const, 1, 1> const& bytes) {
173 auto nchars = bytes.size() * sizeof(std::uint8_t) / sizeof(char);
174 char const* charCArr = reinterpret_cast<char const*>(bytes.getData());
175 return std::string(charCArr, nchars);
176}
177
178} // namespace formatters
179} // namespace afw
180} // namespace lsst
table::Key< std::string > name
Definition: Amplifier.cc:116
#define LSST_EXCEPT(type,...)
std::vector< std::string > paramNames(bool topLevelOnly=true) const
T data(T... args)
ndarray::Array< std::uint8_t, 1, 1 > stringToBytes(std::string const &str)
Encode a std::string as a vector of uint8.
Definition: Utils.cc:161
int extractSliceId(std::shared_ptr< lsst::daf::base::PropertySet const > const &properties)
Definition: Utils.cc:50
bool extractOptionalFlag(std::shared_ptr< lsst::daf::base::PropertySet const > const &properties, std::string const &name)
Returns true if and only if properties is non-null and contains a unique property with the given name...
Definition: Utils.cc:152
int64_t extractAmpExposureId(std::shared_ptr< lsst::daf::base::PropertySet const > const &properties)
Definition: Utils.cc:131
int extractCcdId(std::shared_ptr< lsst::daf::base::PropertySet const > const &properties)
Definition: Utils.cc:92
int extractAmpId(std::shared_ptr< lsst::daf::base::PropertySet const > const &properties)
Definition: Utils.cc:106
std::string bytesToString(ndarray::Array< std::uint8_t const, 1, 1 > const &bytes)
Decode a std::string from a vector of uint8 returned by stringToBytes.
Definition: Utils.cc:172
int64_t extractCcdExposureId(std::shared_ptr< lsst::daf::base::PropertySet const > const &properties)
Definition: Utils.cc:120
int extractVisitId(std::shared_ptr< lsst::daf::base::PropertySet const > const &properties)
Definition: Utils.cc:67
std::string const getItemName(std::shared_ptr< lsst::daf::base::PropertySet const > const &properties)
Extracts and returns the string-valued "itemName" property from the given data property object.
Definition: Utils.cc:142
int64_t extractFpaExposureId(std::shared_ptr< lsst::daf::base::PropertySet const > const &properties)
Definition: Utils.cc:78
int countFitsHeaderCards(lsst::daf::base::PropertySet const &prop)
Definition: Utils.cc:159
A base class for image defects.
T size(T... args)
table::Key< table::Array< std::uint8_t > > bytes
Definition: python.h:135