OpenCV 4.5.3(日本語機械翻訳)
dnn.inl.hpp
1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
21 //
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
25 //
26 // * The name of the copyright holders may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //M*/
41
42 #ifndef OPENCV_DNN_DNN_INL_HPP
43 #define OPENCV_DNN_DNN_INL_HPP
44
45 #include <opencv2/dnn.hpp>
46
47 namespace cv {
48 namespace dnn {
49CV__DNN_INLINE_NS_BEGIN
50
51 template<typename TypeIter>
52DictValue DictValue::arrayInt(TypeIter begin, int size)
53{
54 DictValue res(Param::INT, new AutoBuffer<int64, 1>(size));
55 for (int j = 0; j < size; begin++, j++)
56 (*res.pi)[j] = *begin;
57 return res;
58}
59
60 template<typename TypeIter>
61 DictValue DictValue::arrayReal(TypeIter begin, int size)
62{
63 DictValue res(Param::REAL, new AutoBuffer<double, 1>(size));
64 for (int j = 0; j < size; begin++, j++)
65 (*res.pd)[j] = *begin;
66 return res;
67}
68
69 template<typename TypeIter>
70 DictValue DictValue::arrayString(TypeIter begin, int size)
71{
72 DictValue res(Param::STRING, new AutoBuffer<String, 1>(size));
73 for (int j = 0; j < size; begin++, j++)
74 (*res.ps)[j] = *begin;
75 return res;
76}
77
78 template<>
79 inline DictValue DictValue::get<DictValue>(int idx) const
80 {
81 CV_Assert(idx == -1);
82 return *this;
83}
84
85 template<>
86 inline int64 DictValue::get<int64>(int idx) const
87 {
88 CV_Assert((idx == -1 && size() == 1) || (idx >= 0 && idx < size()));
89 idx = (idx == -1) ? 0 : idx;
90
91 if (type == Param::INT)
92 {
93 return (*pi)[idx];
94 }
95 else if (type == Param::REAL)
96 {
97 double doubleValue = (*pd)[idx];
98
99 double fracpart, intpart;
100 fracpart = std::modf(doubleValue, &intpart);
101 CV_Assert(fracpart == 0.0);
102
103 return (int64)doubleValue;
104 }
105 else if (type == Param::STRING)
106 {
107 return std::atoi((*ps)[idx].c_str());
108 }
109 else
110 {
111 CV_Assert(isInt() || isReal() || isString());
112 return 0;
113 }
114}
115
116 template<>
117 inline int DictValue::get<int>(int idx) const
118 {
119 return (int)get<int64>(idx);
120}
121
122 inline int DictValue::getIntValue(int idx) const
123 {
124 return (int)get<int64>(idx);
125}
126
127 template<>
128 inline unsigned DictValue::get<unsigned>(int idx) const
129 {
130 return (unsigned)get<int64>(idx);
131}
132
133 template<>
134 inline bool DictValue::get<bool>(int idx) const
135 {
136 return (get<int64>(idx) != 0);
137}
138
139 template<>
140 inline double DictValue::get<double>(int idx) const
141 {
142 CV_Assert((idx == -1 && size() == 1) || (idx >= 0 && idx < size()));
143 idx = (idx == -1) ? 0 : idx;
144
145 if (type == Param::REAL)
146 {
147 return (*pd)[idx];
148 }
149 else if (type == Param::INT)
150 {
151 return (double)(*pi)[idx];
152 }
153 else if (type == Param::STRING)
154 {
155 return std::atof((*ps)[idx].c_str());
156 }
157 else
158 {
159 CV_Assert(isReal() || isInt() || isString());
160 return 0;
161 }
162}
163
164 inline double DictValue::getRealValue(int idx) const
165 {
166 return get<double>(idx);
167}
168
169 template<>
170 inline float DictValue::get<float>(int idx) const
171 {
172 return (float)get<double>(idx);
173}
174
175 template<>
176 inline String DictValue::get<String>(int idx) const
177 {
178 CV_Assert(isString());
179 CV_Assert((idx == -1 && ps->size() == 1) || (idx >= 0 && idx < (int)ps->size()));
180 return (*ps)[(idx == -1) ? 0 : idx];
181}
182
183
184 inline String DictValue::getStringValue(int idx) const
185 {
186 return get<String>(idx);
187}
188
189 inline void DictValue::release()
190{
191 switch (type)
192 {
193 case Param::INT:
194 delete pi;
195 break;
196 case Param::STRING:
197 delete ps;
198 break;
199 case Param::REAL:
200 delete pd;
201 break;
202 case Param::BOOLEAN:
203 case Param::MAT:
204 case Param::MAT_VECTOR:
205 case Param::ALGORITHM:
206 case Param::FLOAT:
207 case Param::UNSIGNED_INT:
208 case Param::UINT64:
209 case Param::UCHAR:
210 case Param::SCALAR:
211 break; // unhandled
212 }
213}
214
215 inline DictValue::~DictValue()
216{
217 release();
218}
219
220 inline DictValue & DictValue::operator=(const DictValue &r)
221{
222 if (&r == this)
223 return *this;
224
225 if (r.type == Param::INT)
226 {
227 AutoBuffer<int64, 1> *tmp = new AutoBuffer<int64, 1>(*r.pi);
228 release();
229 pi = tmp;
230 }
231 else if (r.type == Param::STRING)
232 {
233 AutoBuffer<String, 1> *tmp = new AutoBuffer<String, 1>(*r.ps);
234 release();
235 ps = tmp;
236 }
237 else if (r.type == Param::REAL)
238 {
239 AutoBuffer<double, 1> *tmp = new AutoBuffer<double, 1>(*r.pd);
240 release();
241 pd = tmp;
242 }
243
244 type = r.type;
245
246 return *this;
247}
248
249 inline DictValue::DictValue(const DictValue &r)
250 : pv(NULL)
251{
252 type = r.type;
253
254 if (r.type == Param::INT)
255 pi = new AutoBuffer<int64, 1>(*r.pi);
256 else if (r.type == Param::STRING)
257 ps = new AutoBuffer<String, 1>(*r.ps);
258 else if (r.type == Param::REAL)
259 pd = new AutoBuffer<double, 1>(*r.pd);
260}
261
262 inline bool DictValue::isString() const
263 {
264 return (type == Param::STRING);
265}
266
267 inline bool DictValue::isInt() const
268 {
269 return (type == Param::INT);
270}
271
272 inline bool DictValue::isReal() const
273 {
274 return (type == Param::REAL || type == Param::INT);
275}
276
277 inline int DictValue::size() const
278 {
279 switch (type)
280 {
281 case Param::INT:
282 return (int)pi->size();
283 case Param::STRING:
284 return (int)ps->size();
285 case Param::REAL:
286 return (int)pd->size();
287 case Param::BOOLEAN:
288 case Param::MAT:
289 case Param::MAT_VECTOR:
290 case Param::ALGORITHM:
291 case Param::FLOAT:
292 case Param::UNSIGNED_INT:
293 case Param::UINT64:
294 case Param::UCHAR:
295 case Param::SCALAR:
296 break; // unhandled
297 }
298 CV_Error_(Error::StsInternal, ("Unhandled type (%d)", static_cast< int >(type)));
299}
300
301 inline std::ostream &operator<<(std::ostream &stream, const DictValue &dictv)
302{
303 int i;
304
305 if (dictv.isInt())
306 {
307 for (i = 0; i < dictv.size() - 1; i++)
308 stream << dictv.get<int64>(i) << ", ";
309 stream << dictv.get<int64>(i);
310 }
311 else if (dictv.isReal())
312 {
313 for (i = 0; i < dictv.size() - 1; i++)
314 stream << dictv.get<double>(i) << ", ";
315 stream << dictv.get<double>(i);
316 }
317 else if (dictv.isString())
318 {
319 for (i = 0; i < dictv.size() - 1; i++)
320 stream << "\"" << dictv.get<String>(i) << "\", ";
321 stream << dictv.get<String>(i);
322 }
323
324 return stream;
325}
326
328
329 inline bool Dict::has(const String &key) const
330 {
331 return dict.count(key) != 0;
332}
333
334 inline DictValue *Dict::ptr(const String &key)
335{
336 _Dict::iterator i = dict.find(key);
337 return (i == dict.end()) ? NULL : &i->second;
338}
339
340 inline const DictValue *Dict::ptr(const String &key) const
341 {
342 _Dict::const_iterator i = dict.find(key);
343 return (i == dict.end()) ? NULL : &i->second;
344}
345
346 inline const DictValue &Dict::get(const String &key) const
347 {
348 _Dict::const_iterator i = dict.find(key);
349 if (i == dict.end())
350 CV_Error(Error::StsObjectNotFound, "Required argument \"" + key + "\" not found into dictionary");
351 return i->second;
352}
353
354 template <typename T>
355 inline T Dict::get(const String &key) const
356 {
357 return this->get(key).get<T>();
358}
359
360 template <typename T>
361 inline T Dict::get(const String &key, const T &defaultValue) const
362 {
363 _Dict::const_iterator i = dict.find(key);
364
365 if (i != dict.end())
366 return i->second.get<T>();
367 else
368 return defaultValue;
369}
370
371 template<typename T>
372 inline const T &Dict::set(const String &key, const T &value)
373{
374 _Dict::iterator i = dict.find(key);
375
376 if (i != dict.end())
377 i->second = DictValue(value);
378 else
379 dict.insert(std::make_pair(key, DictValue(value)));
380
381 return value;
382}
383
384 inline void Dict::erase(const String &key)
385{
386 dict.erase(key);
387}
388
389 inline std::ostream &operator<<(std::ostream &stream, const Dict &dict)
390{
391 Dict::_Dict::const_iterator it;
392 for (it = dict.dict.begin(); it != dict.dict.end(); it++)
393 stream << it->first << " : " << it->second << "\n";
394
395 return stream;
396}
397
398 inline std::map<String, DictValue>::const_iterator Dict::begin() const
399 {
400 return dict.begin();
401}
402
403 inline std::map<String, DictValue>::const_iterator Dict::end() const
404 {
405 return dict.end();
406}
407
408CV__DNN_INLINE_NS_END
409}
410}
411
412 #endif
cv::AutoBuffer
Automatically Allocated Buffer Class
Definition: utility.hpp:102
cv::dnn::Dict
This class implements name-value dictionary, values are instances of DictValue.
Definition: dict.hpp:115
cv::dnn::Dict::ptr
DictValue * ptr(const String &key)
If the key in the dictionary then returns pointer to its value, else returns NULL.
Definition: dnn.inl.hpp:334
cv::dnn::Dict::set
const T & set(const String &key, const T &value)
Sets new value for the key, or adds new key-value pair into the dictionary.
Definition: dnn.inl.hpp:372
cv::dnn::Dict::erase
void erase(const String &key)
Erase key from the dictionary.
Definition: dnn.inl.hpp:384
cv::dnn::Dict::get
const DictValue & get(const String &key) const
If the key in the dictionary then returns its value, else an error will be generated.
Definition: dnn.inl.hpp:346
cv::dnn::Dict::has
bool has(const String &key) const
Checks a presence of the key in the dictionary.
Definition: dnn.inl.hpp:329
CV_Error_
#define CV_Error_(code, args)
Call the error handler.
Definition: base.hpp:334
CV_Error
#define CV_Error(code, msg)
Call the error handler.
Definition: base.hpp:320
CV_Assert
#define CV_Assert(expr)
Checks a condition at runtime and throws exception if it fails
Definition: base.hpp:342
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::dnn::DictValue
This struct stores the scalar value (or array) of one of the following type: double,...
Definition: dict.hpp:61
cv::dnn::DictValue::arrayInt
static DictValue arrayInt(TypeIter begin, int size)
Constructs integer array
cv::dnn::DictValue::arrayString
static DictValue arrayString(TypeIter begin, int size)
Constructs array of strings
Definition: dnn.inl.hpp:70
cv::dnn::DictValue::arrayReal
static DictValue arrayReal(TypeIter begin, int size)
Constructs floating point array
Definition: dnn.inl.hpp:61
cv::dnn::DictValue::get
T get(int idx=-1) const
Tries to convert array element with specified index to requested type and returns its.
構築: doxygen 1.9.2