Jetson Linux API Reference
39.2 Release
Types.h
Go to the documentation of this file.
1 /*
2  * SPDX-FileCopyrightText: Copyright (c) 2016-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
3  * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * * Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * * Neither the name of NVIDIA CORPORATION nor the names of its
14  * contributors may be used to endorse or promote products derived
15  * from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
25  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29 
37 #ifndef _ARGUS_TYPES_H
38 #define _ARGUS_TYPES_H
39 
40 #include <stdint.h>
41 #include <vector>
42 #include <string>
43 #include <assert.h>
44 
45 #include <EGL/egl.h>
46 #include <EGL/eglext.h>
47 
48 // Some versions of the Xlib.h header file define 'Status' to 'int'.
49 // This collides with the libargus 'Status' type.
50 // If 'Status' is defined then undefine it and use a typedef instead.
51 #ifdef Status
52 #undef Status
53 // typedef int Status;
54 #endif // Status
55 
56 namespace Argus
57 {
58 
59 /*
60  * Forward declaration of standard objects
61  */
62 class CameraDevice;
63 class CameraProvider;
64 class CaptureSession;
65 class CaptureMetadata;
66 class CaptureMetadataContainer;
67 class Event;
68 class EventQueue;
69 class InputStream;
70 class OutputStream;
71 class OutputStreamSettings;
72 class InputStreamSettings;
73 class Request;
74 class SensorMode;
75 
76 
77 /*
78  * Forward declaration of standard interfaces
79  */
80 class ICameraProperties;
81 class ICameraProvider;
82 class ICaptureSession;
83 class IAutoControlSettings;
84 class IRequest;
85 class IStream;
86 class IStreamSettings;
87 class IReprocessInfo;
88 
89 
93 const uint64_t TIMEOUT_INFINITE = 0xFFFFFFFFFFFFFFFF;
94 
98 enum Status
99 {
101  STATUS_OK = 0,
102 
104  STATUS_INVALID_PARAMS = 1,
105 
107  STATUS_INVALID_SETTINGS = 2,
108 
110  STATUS_UNAVAILABLE = 3,
111 
113  STATUS_OUT_OF_MEMORY = 4,
114 
116  STATUS_UNIMPLEMENTED = 5,
117 
119  STATUS_TIMEOUT = 6,
120 
122  STATUS_CANCELLED = 7,
123 
125  STATUS_DISCONNECTED = 8,
126 
128  STATUS_END_OF_STREAM = 9,
129 
130  // Number of elements in this enum.
131  STATUS_COUNT
132 };
133 
137 enum BayerChannel
138 {
139  BAYER_CHANNEL_R,
140  BAYER_CHANNEL_G_EVEN,
141  BAYER_CHANNEL_G_ODD,
142  BAYER_CHANNEL_B,
143 
144  BAYER_CHANNEL_COUNT
145 };
146 
150 enum Coordinate
151 {
152  COORDINATE_X,
153  COORDINATE_Y,
154  COORDINATE_Z,
155 
156  COORDINATE_2D_COUNT = 2,
157  COORDINATE_3D_COUNT = 3
158 };
159 
163 enum RGBChannel
164 {
165  RGB_CHANNEL_R,
166  RGB_CHANNEL_G,
167  RGB_CHANNEL_B,
168 
169  RGB_CHANNEL_COUNT
170 };
171 
175 DEFINE_NAMED_UUID_CLASS(AeAntibandingMode);
176 DEFINE_UUID(AeAntibandingMode, AE_ANTIBANDING_MODE_OFF, AD1E5560,9C16,11E8,B568,18,00,20,0C,9A,66);
177 DEFINE_UUID(AeAntibandingMode, AE_ANTIBANDING_MODE_AUTO, AD1E5561,9C16,11E8,B568,18,00,20,0C,9A,66);
178 DEFINE_UUID(AeAntibandingMode, AE_ANTIBANDING_MODE_50HZ, AD1E5562,9C16,11E8,B568,18,00,20,0C,9A,66);
179 DEFINE_UUID(AeAntibandingMode, AE_ANTIBANDING_MODE_60HZ, AD1E5563,9C16,11E8,B568,18,00,20,0C,9A,66);
180 
184 DEFINE_NAMED_UUID_CLASS(AeMode);
185 DEFINE_UUID(AeMode, AE_MODE_OFF, FCACB1E0,C6E5,11ED,A901,08,00,20,0C,9A,66);
186 DEFINE_UUID(AeMode, AE_MODE_ON, FCACB1E1,C6E5,11ED,A901,08,00,20,0C,9A,66);
187 
191 DEFINE_NAMED_UUID_CLASS(AeFlickerState);
192 DEFINE_UUID(AeFlickerState, AE_FLICKER_NONE, AD1E5564,9C16,11E8,B568,18,00,20,0C,9A,66);
193 DEFINE_UUID(AeFlickerState, AE_FLICKER_50HZ, AD1E5565,9C16,11E8,B568,18,00,20,0C,9A,66);
194 DEFINE_UUID(AeFlickerState, AE_FLICKER_60HZ, AD1E5566,9C16,11E8,B568,18,00,20,0C,9A,66);
195 
199 DEFINE_NAMED_UUID_CLASS(AeState);
200 DEFINE_UUID(AeState, AE_STATE_INACTIVE, D2EBEA50,9C16,11E8,B568,18,00,20,0C,9A,66);
201 DEFINE_UUID(AeState, AE_STATE_SEARCHING, D2EBEA51,9C16,11E8,B568,18,00,20,0C,9A,66);
202 DEFINE_UUID(AeState, AE_STATE_CONVERGED, D2EBEA52,9C16,11E8,B568,18,00,20,0C,9A,66);
203 DEFINE_UUID(AeState, AE_STATE_FLASH_REQUIRED, D2EBEA53,9C16,11E8,B568,18,00,20,0C,9A,66);
204 DEFINE_UUID(AeState, AE_STATE_TIMEOUT, D2EBEA54,9C16,11E8,B568,18,00,20,0C,9A,66);
205 
209 DEFINE_NAMED_UUID_CLASS(AwbMode);
210 DEFINE_UUID(AwbMode, AWB_MODE_OFF, FB3F365A,CC62,11E5,9956,62,56,62,87,07,61);
211 DEFINE_UUID(AwbMode, AWB_MODE_AUTO, FB3F365B,CC62,11E5,9956,62,56,62,87,07,61);
212 DEFINE_UUID(AwbMode, AWB_MODE_INCANDESCENT, FB3F365C,CC62,11E5,9956,62,56,62,87,07,61);
213 DEFINE_UUID(AwbMode, AWB_MODE_FLUORESCENT, FB3F365D,CC62,11E5,9956,62,56,62,87,07,61);
214 DEFINE_UUID(AwbMode, AWB_MODE_WARM_FLUORESCENT, FB3F365E,CC62,11E5,9956,62,56,62,87,07,61);
215 DEFINE_UUID(AwbMode, AWB_MODE_DAYLIGHT, FB3F365F,CC62,11E5,9956,62,56,62,87,07,61);
216 DEFINE_UUID(AwbMode, AWB_MODE_CLOUDY_DAYLIGHT, FB3F3660,CC62,11E5,9956,62,56,62,87,07,61);
217 DEFINE_UUID(AwbMode, AWB_MODE_TWILIGHT, FB3F3661,CC62,11E5,9956,62,56,62,87,07,61);
218 DEFINE_UUID(AwbMode, AWB_MODE_SHADE, FB3F3662,CC62,11E5,9956,62,56,62,87,07,61);
219 DEFINE_UUID(AwbMode, AWB_MODE_MANUAL, 20FB45DA,C49F,4293,AB02,13,3F,8C,CA,DD,69);
220 
224 DEFINE_NAMED_UUID_CLASS(AwbState);
225 DEFINE_UUID(AwbState, AWB_STATE_INACTIVE, E33CDB30,9C16,11E8,B568,18,00,20,0C,9A,66);
226 DEFINE_UUID(AwbState, AWB_STATE_SEARCHING, E33CDB31,9C16,11E8,B568,18,00,20,0C,9A,66);
227 DEFINE_UUID(AwbState, AWB_STATE_CONVERGED, E33CDB32,9C16,11E8,B568,18,00,20,0C,9A,66);
228 DEFINE_UUID(AwbState, AWB_STATE_LOCKED, E33CDB33,9C16,11E8,B568,18,00,20,0C,9A,66);
229 
233 DEFINE_NAMED_UUID_CLASS(AfMode);
234 DEFINE_UUID(AfMode, AF_MODE_OFF, FCACB1E3,C6E5,11ED,A901,08,00,20,0C,9A,66);
235 DEFINE_UUID(AfMode, AF_MODE_AUTO, FCACB1E4,C6E5,11ED,A901,08,00,20,0C,9A,66);
236 DEFINE_UUID(AfMode, AF_MODE_MANUAL, FCACB1E5,C6E5,11ED,A901,08,00,20,0C,9A,66);
237 
252 DEFINE_NAMED_UUID_CLASS(CaptureIntent);
253 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_MANUAL, FB3F3663,CC62,11E5,9956,62,56,62,87,07,61);
254 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_PREVIEW, FB3F3664,CC62,11E5,9956,62,56,62,87,07,61);
255 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_STILL_CAPTURE, FB3F3665,CC62,11E5,9956,62,56,62,87,07,61);
256 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_VIDEO_RECORD, FB3F3666,CC62,11E5,9956,62,56,62,87,07,61);
257 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_VIDEO_SNAPSHOT, FB3F3667,CC62,11E5,9956,62,56,62,87,07,61);
258 
262 DEFINE_NAMED_UUID_CLASS(DenoiseMode);
263 DEFINE_UUID(DenoiseMode, DENOISE_MODE_OFF, FB3F3668,CC62,11E5,9956,62,56,62,87,07,61);
264 DEFINE_UUID(DenoiseMode, DENOISE_MODE_FAST, FB3F3669,CC62,11E5,9956,62,56,62,87,07,61);
265 DEFINE_UUID(DenoiseMode, DENOISE_MODE_HIGH_QUALITY, FB3F366A,CC62,11E5,9956,62,56,62,87,07,61);
266 
270 DEFINE_NAMED_UUID_CLASS(EdgeEnhanceMode);
271 DEFINE_UUID(EdgeEnhanceMode, EDGE_ENHANCE_MODE_OFF, F7100B40,6A5F,11E6,BDF4,08,00,20,0C,9A,66);
272 DEFINE_UUID(EdgeEnhanceMode, EDGE_ENHANCE_MODE_FAST, F7100B41,6A5F,11E6,BDF4,08,00,20,0C,9A,66);
273 DEFINE_UUID(EdgeEnhanceMode, EDGE_ENHANCE_MODE_HIGH_QUALITY, F7100B42,6A5F,11E6,BDF4,08,00,20,0C,9A,66);
274 
278 DEFINE_NAMED_UUID_CLASS(ExtensionName);
279 
283 DEFINE_NAMED_UUID_CLASS(PixelFormat);
284 DEFINE_UUID(PixelFormat, PIXEL_FMT_UNKNOWN, 00000000,93d5,11e5,0000,1c,b7,2c,ef,d4,1e);
285 DEFINE_UUID(PixelFormat, PIXEL_FMT_Y8, 569be14a,93d5,11e5,91bc,1c,b7,2c,ef,d4,1e);
286 DEFINE_UUID(PixelFormat, PIXEL_FMT_Y16, 56ddb19c,93d5,11e5,8e2c,1c,b7,2c,ef,d4,1e);
287 DEFINE_UUID(PixelFormat, PIXEL_FMT_YCbCr_420_888, 570c10e6,93d5,11e5,8ff3,1c,b7,2c,ef,d4,1e);
288 DEFINE_UUID(PixelFormat, PIXEL_FMT_YCbCr_422_888, 573a7940,93d5,11e5,99c2,1c,b7,2c,ef,d4,1e);
289 DEFINE_UUID(PixelFormat, PIXEL_FMT_YCbCr_444_888, 576043dc,93d5,11e5,8983,1c,b7,2c,ef,d4,1e);
290 DEFINE_UUID(PixelFormat, PIXEL_FMT_JPEG_BLOB, 578b08c4,93d5,11e5,9686,1c,b7,2c,ef,d4,1e);
291 DEFINE_UUID(PixelFormat, PIXEL_FMT_RAW16, 57b484d8,93d5,11e5,aeb6,1c,b7,2c,ef,d4,1e);
292 DEFINE_UUID(PixelFormat, PIXEL_FMT_P016, 57b484d9,93d5,11e5,aeb6,1c,b7,2c,ef,d4,1e);
293 DEFINE_UUID(PixelFormat, PIXEL_FMT_LegacyRGBA, 091b5007,6784,4121,94c7,59,0d,29,03,36,72);
294 
299 DEFINE_NAMED_UUID_CLASS(SensorModeType);
300 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_UNSPECIFIED,64483463,4b91,11e6,bbbd,40,16,7e,ab,86,92);
301 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_DEPTH, 64483464,4b91,11e6,bbbd,40,16,7e,ab,86,92);
302 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_YUV, 6453e00c,4b91,11e6,871d,40,16,7e,ab,86,92);
303 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_RGB, 6463d4c6,4b91,11e6,88a3,40,16,7e,ab,86,92);
304 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_BAYER, 646f04ea,4b91,11e6,9c06,40,16,7e,ab,86,92);
305 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_BAYER_PWL, f6a08220,6a0f,11eb,8572,08,00,20,0c,9a,66);
306 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_BAYER_DOL, f6a08221,6a0f,11eb,8572,08,00,20,0c,9a,66);
307 
311 DEFINE_NAMED_UUID_CLASS(SensorPlacement);
312 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_REAR_OR_BOTTOM_OR_BOTTOM_LEFT, 01dba8b0,1946,11eb,8b6f,08,00,20,0c,9a,66);
313 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_FRONT_OR_TOP_OR_CENTER_LEFT, 01dba8b1,1946,11eb,8b6f,08,00,20,0c,9a,66);
314 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_CENTER_OR_CENTER_RIGHT, 01dba8b2,1946,11eb,8b6f,08,00,20,0c,9a,66);
315 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_TOP_LEFT, 01dba8b3,1946,11eb,8b6f,08,00,20,0c,9a,66);
316 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_BOTTOM_RIGHT, 01dba8b4,1946,11eb,8b6f,08,00,20,0c,9a,66);
317 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_TOP_RIGHT, 01dba8b5,1946,11eb,8b6f,08,00,20,0c,9a,66);
318 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_UNKNOWN, 01dba8b6,1946,11eb,8b6f,08,00,20,0c,9a,66);
319 
320 
324 DEFINE_NAMED_UUID_CLASS(BayerPhase);
325 DEFINE_UUID(BayerPhase, BAYER_PHASE_UNKNOWN, b9d43270,6a0e,12eb,8572,08,00,20,0c,9a,66);
326 DEFINE_UUID(BayerPhase, BAYER_PHASE_RGGB, b9d43271,6a0e,12eb,8572,08,00,20,0c,9a,66);
327 DEFINE_UUID(BayerPhase, BAYER_PHASE_BGGR, b9d43272,6a0e,12eb,8572,08,00,20,0c,9a,66);
328 DEFINE_UUID(BayerPhase, BAYER_PHASE_GRBG, b9d43273,6a0e,12eb,8572,08,00,20,0c,9a,66);
329 DEFINE_UUID(BayerPhase, BAYER_PHASE_GBRG, b9d43274,6a0e,12eb,8572,08,00,20,0c,9a,66);
330 
334 DEFINE_NAMED_UUID_CLASS(PixelFormatType);
335 DEFINE_UUID(PixelFormatType, PixelFormatType_None, b7d9b3a4,cdc6,4267,9969,57,a3,00,9a,41,32);
336 DEFINE_UUID(PixelFormatType, PixelFormatType_YuvOnly, 45bdf956,5624,4c2b,a196,fa,87,6d,a0,84,19);
337 DEFINE_UUID(PixelFormatType, PixelFormatType_RgbOnly, a5e5e1e9,56ac,4d14,8ce7,39,16,05,6c,86,4c);
338 DEFINE_UUID(PixelFormatType, PixelFormatType_Both, 7c0d1c33,bd27,4294,9dc6,04,1f,9f,9d,86,3c);
339 
343 DEFINE_NAMED_UUID_CLASS(CVOutput);
344 DEFINE_UUID(CVOutput, CVOutput_None, cf6353af,331f,4153,aaba,60,ef,87,36,04,03);
345 DEFINE_UUID(CVOutput, CVOutput_Linear, fa260819,baf4,4dea,9c15,eb,96,c0,95,0e,0e);
346 DEFINE_UUID(CVOutput, CVOutput_NonLinear, f19a1652,7e69,4efe,a6c9,72,05,ad,9d,95,fe);
347 
351 DEFINE_NAMED_UUID_CLASS(BufferLayout);
352 DEFINE_UUID(BufferLayout, BufferLayout_PitchLinear, 43685d2a,3c88,4a28,bb54,6e,1f,fb,99,9c,c9);
353 DEFINE_UUID(BufferLayout, BufferLayout_BlockLinear, 7083ba99,258a,4371,8950,50,ad,55,45,5d,76);
354 
358 class NonCopyable
359 {
360 protected:
361  NonCopyable() {}
362 
363 private:
364  NonCopyable(NonCopyable& other);
365  NonCopyable& operator=(NonCopyable& other);
366 };
367 
375 class Interface : NonCopyable
376 {
377 protected:
378  Interface() {}
379  ~Interface() {}
380 };
381 
385 class InterfaceID : public NamedUUID
386 {
387 public:
388  InterfaceID(uint32_t time_low_
389  , uint16_t time_mid_
390  , uint16_t time_hi_and_version_
391  , uint16_t clock_seq_
392  , uint8_t c0, uint8_t c1, uint8_t c2, uint8_t c3, uint8_t c4, uint8_t c5
393  , const char* name)
394  : NamedUUID(time_low_, time_mid_, time_hi_and_version_, clock_seq_,
395  c0, c1, c2, c3, c4, c5, name)
396  {}
397 
398  InterfaceID()
399  : NamedUUID(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "IID_UNSPECIFIED")
400  {}
401 };
402 
406 class InterfaceProvider : NonCopyable
407 {
408 public:
409 
415  virtual Interface* getInterface(const InterfaceID& interfaceId) = 0;
416 
417 protected:
418  ~InterfaceProvider() {}
419 };
420 
425 template <typename TheInterface>
426 inline TheInterface* interface_cast(InterfaceProvider* obj)
427 {
428  return static_cast<TheInterface*>(obj ? obj->getInterface(TheInterface::id()): 0);
429 }
430 
431 template <typename TheInterface>
432 inline TheInterface* interface_cast(const InterfaceProvider* obj)
433 {
434  return static_cast<TheInterface*>(
435  obj ? const_cast<const Interface*>(
436  const_cast<InterfaceProvider*>(obj)->getInterface(TheInterface::id())): 0);
437 }
438 
443 class Destructable
444 {
445 public:
446 
451  virtual void destroy() = 0;
452 
453 protected:
454  ~Destructable() {}
455 };
456 
461 template<typename T>
462 class rv : public T
463 {
464  rv();
465  ~rv();
466  rv(const rv&);
467  void operator=(const rv&);
468 };
469 
470 template<typename T>
471  rv<T>& move(T& self)
472 {
473  return *static_cast<rv<T>*>(&self);
474 }
481 template <typename T> struct remove_const;
482 template <typename T> struct remove_const<const T&>{ typedef T& type; };
483 template <typename T> struct remove_const<const T*>{ typedef T* type; };
484 template <typename T> struct remove_const<const T >{ typedef T type; };
485 template <typename T> struct remove_const { typedef T type; };
488 template <typename T>
489 class UniqueObj : NonCopyable
490 {
491 public:
492  explicit UniqueObj(T* obj=NULL): m_obj(obj) {}
493 
494  void reset(T* obj=NULL)
495  { if (m_obj && (m_obj != obj)) const_cast<typename remove_const<T*>::type>(m_obj)->destroy(); m_obj = obj; }
496  T* release()
497  { T* obj = m_obj; m_obj = NULL; return obj; }
498 
499  UniqueObj( rv<UniqueObj>& moved ): m_obj(moved.release()) {}
500  UniqueObj& operator=( rv<UniqueObj>& moved ){ reset( moved.release()); return *this; }
501 
502  ~UniqueObj() { reset(); }
503 
504  T& operator*() const { return *m_obj; }
505  T* get() const { return m_obj; }
506 
507  operator bool() const { return !!m_obj; }
508 
509  operator rv<UniqueObj>&() { return *static_cast< rv<UniqueObj>*>(this); }
510  operator const rv<UniqueObj>&() const { return *static_cast<const rv<UniqueObj>*>(this); }
511 
512 private:
513  T* m_obj;
514 
515  T* operator->() const; // Prevent calling destroy() directly.
516  // Note: For getInterface functionality use interface_cast.
517 };
518 
519 template <typename TheInterface, typename TObject>
520 inline TheInterface* interface_cast(const UniqueObj<TObject>& obj)
521 {
522  return interface_cast<TheInterface>( obj.get());
523 }
524 
528 template <unsigned int N, typename T>
529 class Tuple
530 {
531 public:
532  Tuple() {}
533 
535  Tuple(T init)
536  {
537  for (unsigned int i = 0; i < N; i++)
538  m_data[i] = init;
539  }
540 
542  bool operator==(const Tuple<N,T>& rhs) const
543  {
544  return !memcmp(m_data, rhs.m_data, sizeof(m_data));
545  }
546 
548  bool operator!=(const Tuple<N,T>& rhs) const
549  {
550  return !(*this == rhs);
551  }
552 
554  Tuple<N, T>& operator+=(const Tuple<N, T>& rhs)
555  {
556  for (unsigned int i = 0; i < N; i++)
557  m_data[i] += rhs.m_data[i];
558  return *this;
559  }
560 
562  Tuple<N, T>& operator-=(const Tuple<N, T>& rhs)
563  {
564  for (unsigned int i = 0; i < N; i++)
565  m_data[i] -= rhs.m_data[i];
566  return *this;
567  }
568 
570  Tuple<N, T>& operator*=(const T& rhs)
571  {
572  for (unsigned int i = 0; i < N; i++)
573  m_data[i] *= rhs;
574  return *this;
575  }
576 
578  Tuple<N, T>& operator/=(const T& rhs)
579  {
580  for (unsigned int i = 0; i < N; i++)
581  m_data[i] /= rhs;
582  return *this;
583  }
584 
586  const Tuple<N, T> operator+(const Tuple<N, T>& rhs) const
587  {
588  return Tuple<N, T>(*this) += rhs;
589  }
590 
592  const Tuple<N, T> operator-(const Tuple<N, T>& rhs) const
593  {
594  return Tuple<N, T>(*this) -= rhs;
595  }
596 
598  const Tuple<N, T> operator*(const T& rhs) const
599  {
600  return Tuple<N, T>(*this) *= rhs;
601  }
602 
604  const Tuple<N, T> operator/(const T& rhs) const
605  {
606  return Tuple<N, T>(*this) /= rhs;
607  }
608 
609  T& operator[](unsigned int i) { assert(i < N); return m_data[i]; }
610  const T& operator[](unsigned int i) const { assert(i < N); return m_data[i]; }
611 
613  static unsigned int tupleSize() { return N; }
614 
615 protected:
616  T m_data[N];
617 };
618 
624 template <typename T>
625 class BayerTuple : public Tuple<BAYER_CHANNEL_COUNT, T>
626 {
627 public:
628  BayerTuple() {}
629  BayerTuple(const Tuple<BAYER_CHANNEL_COUNT, T>& other) : Tuple<BAYER_CHANNEL_COUNT, T>(other) {}
630 
631  BayerTuple(T init)
632  {
633  r() = gEven() = gOdd() = b() = init;
634  }
635 
636  BayerTuple(T _r, T _gEven, T _gOdd, T _b)
637  {
638  r() = _r;
639  gEven() = _gEven;
640  gOdd() = _gOdd;
641  b() = _b;
642  }
643 
644  T& r() { return Tuple<BAYER_CHANNEL_COUNT, T>::m_data[BAYER_CHANNEL_R]; }
645  const T& r() const { return Tuple<BAYER_CHANNEL_COUNT, T>::m_data[BAYER_CHANNEL_R]; }
646  T& gEven() { return Tuple<BAYER_CHANNEL_COUNT, T>::m_data[BAYER_CHANNEL_G_EVEN]; }
647  const T& gEven() const { return Tuple<BAYER_CHANNEL_COUNT, T>::m_data[BAYER_CHANNEL_G_EVEN]; }
648  T& gOdd() { return Tuple<BAYER_CHANNEL_COUNT, T>::m_data[BAYER_CHANNEL_G_ODD]; }
649  const T& gOdd() const { return Tuple<BAYER_CHANNEL_COUNT, T>::m_data[BAYER_CHANNEL_G_ODD]; }
650  T& b() { return Tuple<BAYER_CHANNEL_COUNT, T>::m_data[BAYER_CHANNEL_B]; }
651  const T& b() const { return Tuple<BAYER_CHANNEL_COUNT, T>::m_data[BAYER_CHANNEL_B]; }
652 };
653 
659 template <typename T>
660 class RGBTuple : public Tuple<RGB_CHANNEL_COUNT, T>
661 {
662 public:
663  RGBTuple() {}
664  RGBTuple(const Tuple<RGB_CHANNEL_COUNT, T>& other) : Tuple<RGB_CHANNEL_COUNT, T>(other) {}
665 
666  RGBTuple(T init)
667  {
668  r() = g() = b() = init;
669  }
670 
671  RGBTuple(T _r, T _g, T _b)
672  {
673  r() = _r;
674  g() = _g;
675  b() = _b;
676  }
677 
678  T& r() { return Tuple<RGB_CHANNEL_COUNT, T>::m_data[RGB_CHANNEL_R]; }
679  const T& r() const { return Tuple<RGB_CHANNEL_COUNT, T>::m_data[RGB_CHANNEL_R]; }
680  T& g() { return Tuple<RGB_CHANNEL_COUNT, T>::m_data[RGB_CHANNEL_G]; }
681  const T& g() const { return Tuple<RGB_CHANNEL_COUNT, T>::m_data[RGB_CHANNEL_G]; }
682  T& b() { return Tuple<RGB_CHANNEL_COUNT, T>::m_data[RGB_CHANNEL_B]; }
683  const T& b() const { return Tuple<RGB_CHANNEL_COUNT, T>::m_data[RGB_CHANNEL_B]; }
684 };
685 
691 template <typename T>
692 class Point2D : public Tuple<COORDINATE_2D_COUNT, T>
693 {
694 public:
695  Point2D() {}
696  Point2D(const Tuple<COORDINATE_2D_COUNT, T>& other) : Tuple<COORDINATE_2D_COUNT, T>(other) {}
697 
698  Point2D(T init)
699  {
700  x() = y() = init;
701  }
702 
703  Point2D(T _x, T _y)
704  {
705  x() = _x;
706  y() = _y;
707  }
708 
709  T& x() { return Tuple<COORDINATE_2D_COUNT, T>::m_data[COORDINATE_X]; }
710  const T& x() const { return Tuple<COORDINATE_2D_COUNT, T>::m_data[COORDINATE_X]; }
711  T& y() { return Tuple<COORDINATE_2D_COUNT, T>::m_data[COORDINATE_Y]; }
712  const T& y() const { return Tuple<COORDINATE_2D_COUNT, T>::m_data[COORDINATE_Y]; }
713 };
714 
720 template <typename T>
721 class Point3D : public Tuple<COORDINATE_3D_COUNT, T>
722 {
723 public:
724  Point3D() {}
725  Point3D(const Tuple<COORDINATE_3D_COUNT, T>& other) : Tuple<COORDINATE_3D_COUNT, T>(other) {}
726 
727  Point3D(T init)
728  {
729  x() = y() = z() = init;
730  }
731 
732  Point3D(T _x, T _y, T _z)
733  {
734  x() = _x;
735  y() = _y;
736  z() = _z;
737  }
738 
739  T& x() { return Tuple<COORDINATE_3D_COUNT, T>::m_data[COORDINATE_X]; }
740  const T& x() const { return Tuple<COORDINATE_3D_COUNT, T>::m_data[COORDINATE_X]; }
741  T& y() { return Tuple<COORDINATE_3D_COUNT, T>::m_data[COORDINATE_Y]; }
742  const T& y() const { return Tuple<COORDINATE_3D_COUNT, T>::m_data[COORDINATE_Y]; }
743  T& z() { return Tuple<COORDINATE_3D_COUNT, T>::m_data[COORDINATE_Z]; }
744  const T& z() const { return Tuple<COORDINATE_3D_COUNT, T>::m_data[COORDINATE_Z]; }
745 };
746 
751 template <typename T>
752 class Size2D : public Tuple<2, T>
753 {
754 public:
755  Size2D() {}
756  Size2D(const Tuple<2, T>& other) : Tuple<2, T>(other) {}
757 
758  Size2D(T init)
759  {
760  width() = height() = init;
761  }
762 
763  Size2D(T _width, T _height)
764  {
765  width() = _width;
766  height() = _height;
767  }
768 
769  T& width() { return Tuple<2, T>::m_data[0]; }
770  const T& width() const { return Tuple<2, T>::m_data[0]; }
771  T& height() { return Tuple<2, T>::m_data[1]; }
772  const T& height() const { return Tuple<2, T>::m_data[1]; }
773 
775  T area() const { return width() * height(); }
776 };
777 
783 template <typename T>
784 class Rectangle : public Tuple<4, T>
785 {
786 public:
787  Rectangle() {}
788  Rectangle(const Tuple<4, T>& other) : Tuple<4, T>(other) {}
789 
790  Rectangle(T init)
791  {
792  left() = top() = right() = bottom() = init;
793  }
794 
795  Rectangle(T _left, T _top, T _right, T _bottom)
796  {
797  left() = _left;
798  top() = _top;
799  right() = _right;
800  bottom() = _bottom;
801  }
802 
803  T& left() { return Tuple<4, T>::m_data[0]; }
804  const T& left() const { return Tuple<4, T>::m_data[0]; }
805  T& top() { return Tuple<4, T>::m_data[1]; }
806  const T& top() const { return Tuple<4, T>::m_data[1]; }
807  T& right() { return Tuple<4, T>::m_data[2]; }
808  const T& right() const { return Tuple<4, T>::m_data[2]; }
809  T& bottom() { return Tuple<4, T>::m_data[3]; }
810  const T& bottom() const { return Tuple<4, T>::m_data[3]; }
811 
813  T width() const { return right() - left(); }
814 
816  T height() const { return bottom() - top(); }
817 
819  T area() const { return width() * height(); }
820 };
821 
826 template <typename T>
827 class Range : public Tuple<2, T>
828 {
829 public:
830  Range() {}
831  Range(const Tuple<2, T>& other) : Tuple<2, T>(other) {}
832 
833  Range(T init)
834  {
835  min() = max() = init;
836  }
837 
838  Range(T _min, T _max)
839  {
840  min() = _min;
841  max() = _max;
842  }
843 
844  T& min() { return Tuple<2, T>::m_data[0]; }
845  const T& min() const { return Tuple<2, T>::m_data[0]; }
846  T& max() { return Tuple<2, T>::m_data[1]; }
847  const T& max() const { return Tuple<2, T>::m_data[1]; }
848 
849  bool empty() const { return max() < min(); }
850 };
851 
856 class AcRegion : public Rectangle<uint32_t>
857 {
858 public:
859  AcRegion()
860  : Rectangle<uint32_t>(0, 0, 0, 0)
861  , m_weight(1.0f)
862  {}
863 
864  AcRegion(uint32_t _left, uint32_t _top, uint32_t _right, uint32_t _bottom, float _weight)
865  : Rectangle<uint32_t>(_left, _top, _right, _bottom)
866  , m_weight(_weight)
867  {}
868 
869  float& weight() { return m_weight; }
870  const float& weight() const { return m_weight; }
871 
872 protected:
873  float m_weight;
874 };
875 
883 template <typename T>
884 class Array2D
885 {
886 public:
887  // Iterator types.
888  typedef T* iterator;
889  typedef const T* const_iterator;
890 
892  Array2D() : m_size(0, 0) {}
893 
895  Array2D(const Size2D<uint32_t>& size) : m_size(size)
896  {
897  m_data.resize(size.width() * size.height());
898  }
899 
901  Array2D(const Size2D<uint32_t>& size, const T& value) : m_size(size)
902  {
903  m_data.resize(size.width() * size.height(), value);
904  }
905 
907  Array2D(const Array2D<T>& other)
908  {
909  m_data = other.m_data;
910  m_size = other.m_size;
911  }
912 
914  Array2D& operator= (const Array2D<T>& other)
915  {
916  m_data = other.m_data;
917  m_size = other.m_size;
918  return *this;
919  }
920 
922  bool operator== (const Array2D<T>& other) const
923  {
924  return (m_size == other.m_size && m_data == other.m_data);
925  }
926 
928  Size2D<uint32_t> size() const { return m_size; }
929 
932  bool resize(const Size2D<uint32_t>& size)
933  {
934  uint32_t s = size.width() * size.height();
935  m_data.resize(s);
936  if (m_data.size() != s)
937  return false;
938  m_size = size;
939  return true;
940  }
941 
943  inline const_iterator begin() const { return m_data.data(); }
944  inline const_iterator end() const { return m_data.data() + m_data.size(); }
945  inline iterator begin() { return m_data.data(); }
946  inline iterator end() { return m_data.data() + m_data.size(); }
947 
949  T& operator[](unsigned int i) { return m_data[checkIndex(i)]; }
950  const T& operator[](unsigned int i) const { return m_data[checkIndex(i)]; }
951 
953  inline const T& operator() (uint32_t i) const { return m_data[checkIndex(i)]; }
954  inline const T& operator() (uint32_t x, uint32_t y) const { return m_data[checkIndex(x, y)]; }
955  inline const T& operator() (const Point2D<uint32_t>& p) const
956  { return m_data[checkIndex(p.x(), p.y())]; }
957  inline T& operator() (uint32_t i) { return m_data[checkIndex(i)]; }
958  inline T& operator() (uint32_t x, uint32_t y) { return m_data[checkIndex(x, y)]; }
959  inline T& operator() (const Point2D<uint32_t>& p)
960  { return m_data[checkIndex(p.x(), p.y())]; }
961 
962  // Get pointers to data.
963  inline const T* data() const { return m_data.data(); }
964  inline T* data() { return m_data.data(); }
965 
966 private:
967  inline uint32_t checkIndex(uint32_t i) const
968  {
969  assert(i < m_data.size());
970  return i;
971  }
972 
973  inline uint32_t checkIndex(uint32_t x, uint32_t y) const
974  {
975  assert(x < m_size.width());
976  assert(y < m_size.height());
977  return x + (y * m_size.width());
978  }
979 
980  std::vector<T> m_data;
981  Size2D<uint32_t> m_size;
982 };
983 
984 typedef uint32_t AutoControlId;
985 
986 } // namespace Argus
987 
988 #endif // _ARGUS_TYPES_H
Argus::RGB_CHANNEL_COUNT
@ RGB_CHANNEL_COUNT
Definition: Types.h:169
Argus::Tuple::operator[]
T & operator[](unsigned int i)
Definition: Types.h:609
Argus::BayerTuple::gEven
T & gEven()
Definition: Types.h:646
Argus::Rectangle::Rectangle
Rectangle(T init)
Definition: Types.h:790
Argus::BAYER_CHANNEL_B
@ BAYER_CHANNEL_B
Definition: Types.h:142
Argus::RGBTuple::b
T & b()
Definition: Types.h:682
Argus::Range::empty
bool empty() const
Definition: Types.h:849
Argus::DEFINE_NAMED_UUID_CLASS
DEFINE_NAMED_UUID_CLASS(BufferType)
Argus::TIMEOUT_INFINITE
const uint64_t TIMEOUT_INFINITE
Constant used for infinite timeouts.
Definition: Types.h:93
Argus::interface_cast
TheInterface * interface_cast(InterfaceProvider *obj)
Interface-casting helper similar to dynamic_cast.
Definition: Types.h:426
Argus::RGB_CHANNEL_G
@ RGB_CHANNEL_G
Definition: Types.h:166
Argus::Coordinate
Coordinate
Coordinates used for 2D and 3D points.
Definition: Types.h:150
Argus::Array2D::operator[]
const T & operator[](unsigned int i) const
Definition: Types.h:950
Argus::NonCopyable::NonCopyable
NonCopyable()
Definition: Types.h:361
Argus::RGBTuple::g
const T & g() const
Definition: Types.h:681
Argus::Array2D
A template class to hold a 2-dimensional array of data.
Definition: Types.h:884
Argus::UniqueObj::operator=
UniqueObj & operator=(rv< UniqueObj > &moved)
Definition: Types.h:500
Argus::Point3D::Point3D
Point3D(T _x, T _y, T _z)
Definition: Types.h:732
Argus::Tuple::operator+=
Tuple< N, T > & operator+=(const Tuple< N, T > &rhs)
Adds every element of another tuple to the elements of this tuple.
Definition: Types.h:554
Argus::RGBTuple::RGBTuple
RGBTuple(T init)
Definition: Types.h:666
Argus::BayerTuple::BayerTuple
BayerTuple()
Definition: Types.h:628
Argus::Rectangle::height
T height() const
Returns the height of the rectangle.
Definition: Types.h:816
Argus::AutoControlId
uint32_t AutoControlId
Definition: Types.h:984
Argus::DEFINE_UUID
DEFINE_UUID(ExtensionName, EXT_BAYER_AVERAGE_MAP, 12c3de20, 64c5, 11e6, bdf4, 08, 00, 20, 0c, 9a, 66)
Argus::Range::max
const T & max() const
Definition: Types.h:847
Argus::COORDINATE_Y
@ COORDINATE_Y
Definition: Types.h:153
Argus::BayerTuple::b
const T & b() const
Definition: Types.h:651
Argus::AcRegion::weight
float & weight()
Definition: Types.h:869
Argus::UniqueObj::get
T * get() const
Definition: Types.h:505
Argus::Array2D::data
T * data()
Definition: Types.h:964
Argus::Rectangle::left
const T & left() const
Definition: Types.h:804
Argus::Point2D::y
T & y()
Definition: Types.h:711
Argus::Tuple::operator[]
const T & operator[](unsigned int i) const
Definition: Types.h:610
Argus::Destructable::~Destructable
~Destructable()
Definition: Types.h:454
Argus::Point3D::z
const T & z() const
Definition: Types.h:744
Argus::STATUS_CANCELLED
@ STATUS_CANCELLED
The capture was aborted.
Definition: Types.h:122
Argus::NamedUUID
A universally unique identifier with a name (used for debugging purposes).
Definition: UUID.h:73
Argus
Definition: BayerAverageMap.h:39
Argus::STATUS_OK
@ STATUS_OK
Function succeeded.
Definition: Types.h:101
Argus::Point2D::Point2D
Point2D(const Tuple< COORDINATE_2D_COUNT, T > &other)
Definition: Types.h:696
Argus::Tuple::operator-
const Tuple< N, T > operator-(const Tuple< N, T > &rhs) const
Returns the result of subtracting another tuple from this tuple.
Definition: Types.h:592
Argus::Tuple::operator!=
bool operator!=(const Tuple< N, T > &rhs) const
Returns true if there are any differences between the two tuples.
Definition: Types.h:548
Argus::STATUS_UNAVAILABLE
@ STATUS_UNAVAILABLE
The requested device is unavailable.
Definition: Types.h:110
Argus::STATUS_END_OF_STREAM
@ STATUS_END_OF_STREAM
End of stream, used by Stream objects.
Definition: Types.h:128
Argus::Point3D::x
const T & x() const
Definition: Types.h:740
Argus::Tuple::operator*=
Tuple< N, T > & operator*=(const T &rhs)
Multiplies every element in the tuple by a single value.
Definition: Types.h:570
Argus::Size2D
Size2D template class.
Definition: Types.h:752
Argus::BayerTuple::gOdd
T & gOdd()
Definition: Types.h:648
Argus::Tuple::operator-=
Tuple< N, T > & operator-=(const Tuple< N, T > &rhs)
Subtracts every element of another tuple from the elements of this tuple.
Definition: Types.h:562
Argus::Tuple::Tuple
Tuple(T init)
Initialize every element of the tuple to a single value.
Definition: Types.h:535
Argus::Tuple::operator*
const Tuple< N, T > operator*(const T &rhs) const
Returns the result of multiplying this tuple by a single value.
Definition: Types.h:598
Argus::Size2D::width
const T & width() const
Definition: Types.h:770
Argus::Tuple::tupleSize
static unsigned int tupleSize()
Returns the number of elements in the tuple.
Definition: Types.h:613
Argus::Range::Range
Range(const Tuple< 2, T > &other)
Definition: Types.h:831
Argus::RGB_CHANNEL_R
@ RGB_CHANNEL_R
Definition: Types.h:165
Argus::Range::Range
Range(T _min, T _max)
Definition: Types.h:838
Argus::Array2D::operator[]
T & operator[](unsigned int i)
Array indexing using [] operator.
Definition: Types.h:949
Argus::Interface
The top-level interface class.
Definition: Types.h:375
Argus::Point3D::Point3D
Point3D(const Tuple< COORDINATE_3D_COUNT, T > &other)
Definition: Types.h:725
Argus::Rectangle::bottom
const T & bottom() const
Definition: Types.h:810
Argus::Tuple::operator+
const Tuple< N, T > operator+(const Tuple< N, T > &rhs) const
Returns the result of adding another tuple to this tuple.
Definition: Types.h:586
Argus::STATUS_DISCONNECTED
@ STATUS_DISCONNECTED
The stream or other resource has been disconnected.
Definition: Types.h:125
Argus::AcRegion::AcRegion
AcRegion(uint32_t _left, uint32_t _top, uint32_t _right, uint32_t _bottom, float _weight)
Definition: Types.h:864
Argus::InterfaceProvider::getInterface
virtual Interface * getInterface(const InterfaceID &interfaceId)=0
Acquire the interface specified by interfaceId.
Argus::Interface::Interface
Interface()
Definition: Types.h:378
Argus::Range
Range template class.
Definition: Types.h:827
Argus::Rectangle::top
T & top()
Definition: Types.h:805
Argus::InterfaceID::InterfaceID
InterfaceID()
Definition: Types.h:398
Argus::Rectangle
Rectangle template class.
Definition: Types.h:784
Argus::Tuple::m_data
T m_data[N]
Definition: Types.h:616
Argus::Rectangle::right
T & right()
Definition: Types.h:807
Argus::Point3D
Point3D template class.
Definition: Types.h:721
Argus::BayerTuple::BayerTuple
BayerTuple(T _r, T _gEven, T _gOdd, T _b)
Definition: Types.h:636
Argus::Array2D::Array2D
Array2D(const Size2D< uint32_t > &size)
Constructor given initial array size.
Definition: Types.h:895
Argus::InterfaceID
A unique identifier for a libargus Interface.
Definition: Types.h:385
Argus::Tuple
Tuple template class.
Definition: Types.h:529
Argus::Tuple::operator/=
Tuple< N, T > & operator/=(const T &rhs)
Divides every element in the tuple by a single value.
Definition: Types.h:578
Argus::RGBTuple::b
const T & b() const
Definition: Types.h:683
Argus::Array2D::Array2D
Array2D()
Default Constructor.
Definition: Types.h:892
Argus::UniqueObj::UniqueObj
UniqueObj(rv< UniqueObj > &moved)
Definition: Types.h:499
Argus::Point2D::Point2D
Point2D(T init)
Definition: Types.h:698
Argus::Rectangle::width
T width() const
Returns the width of the rectangle.
Definition: Types.h:813
Argus::Array2D::begin
const_iterator begin() const
STL style iterators.
Definition: Types.h:943
Argus::STATUS_UNIMPLEMENTED
@ STATUS_UNIMPLEMENTED
This method has not been implemented.
Definition: Types.h:116
Argus::Point3D::y
T & y()
Definition: Types.h:741
Argus::BayerTuple::gEven
const T & gEven() const
Definition: Types.h:647
Argus::AcRegion::weight
const float & weight() const
Definition: Types.h:870
Argus::UniqueObj::UniqueObj
UniqueObj(T *obj=NULL)
Definition: Types.h:492
Argus::InterfaceProvider
The base interface for a class that provides libargus Interfaces.
Definition: Types.h:406
Argus::Rectangle::top
const T & top() const
Definition: Types.h:806
Argus::Rectangle::Rectangle
Rectangle()
Definition: Types.h:787
Argus::RGBTuple::r
const T & r() const
Definition: Types.h:679
Argus::COORDINATE_Z
@ COORDINATE_Z
Definition: Types.h:154
Argus::Array2D::end
iterator end()
Definition: Types.h:946
Argus::AcRegion
Defines an autocontrol region of interest (in pixel space).
Definition: Types.h:856
Argus::BAYER_CHANNEL_G_EVEN
@ BAYER_CHANNEL_G_EVEN
Definition: Types.h:140
Argus::Size2D::Size2D
Size2D()
Definition: Types.h:755
Argus::InterfaceProvider::~InterfaceProvider
~InterfaceProvider()
Definition: Types.h:418
Argus::AcRegion::m_weight
float m_weight
Definition: Types.h:873
Argus::Rectangle::bottom
T & bottom()
Definition: Types.h:809
Argus::UniqueObj::release
T * release()
Definition: Types.h:496
Argus::RGBTuple::g
T & g()
Definition: Types.h:680
Argus::Point3D::x
T & x()
Definition: Types.h:739
Argus::COORDINATE_3D_COUNT
@ COORDINATE_3D_COUNT
Definition: Types.h:157
Argus::Point2D::y
const T & y() const
Definition: Types.h:712
Argus::Rectangle::Rectangle
Rectangle(T _left, T _top, T _right, T _bottom)
Definition: Types.h:795
Argus::BayerTuple::BayerTuple
BayerTuple(T init)
Definition: Types.h:631
Argus::NonCopyable
Utility class for libargus interfaces.
Definition: Types.h:358
Argus::Array2D::size
Size2D< uint32_t > size() const
Returns the size (dimensions) of the array.
Definition: Types.h:928
Argus::BayerTuple
BayerTuple template class.
Definition: Types.h:625
Argus::Interface::~Interface
~Interface()
Definition: Types.h:379
Argus::Point2D::x
const T & x() const
Definition: Types.h:710
Argus::Destructable::destroy
virtual void destroy()=0
Destroy this object.
Argus::InterfaceID::InterfaceID
InterfaceID(uint32_t time_low_, uint16_t time_mid_, uint16_t time_hi_and_version_, uint16_t clock_seq_, uint8_t c0, uint8_t c1, uint8_t c2, uint8_t c3, uint8_t c4, uint8_t c5, const char *name)
Definition: Types.h:388
Argus::Tuple::Tuple
Tuple()
Definition: Types.h:532
Argus::AcRegion::AcRegion
AcRegion()
Definition: Types.h:859
Argus::RGBChannel
RGBChannel
Color channel constants for RGB data.
Definition: Types.h:163
Argus::Array2D::Array2D
Array2D(const Size2D< uint32_t > &size, const T &value)
Constructor given initial array size and initial fill value.
Definition: Types.h:901
Argus::STATUS_INVALID_PARAMS
@ STATUS_INVALID_PARAMS
The set of parameters passed was invalid.
Definition: Types.h:104
Argus::Range::min
T & min()
Definition: Types.h:844
Argus::Size2D::Size2D
Size2D(const Tuple< 2, T > &other)
Definition: Types.h:756
Argus::Size2D::area
T area() const
Returns the area of the size (width * height).
Definition: Types.h:775
Argus::Rectangle::Rectangle
Rectangle(const Tuple< 4, T > &other)
Definition: Types.h:788
Argus::BAYER_CHANNEL_COUNT
@ BAYER_CHANNEL_COUNT
Definition: Types.h:144
Argus::Array2D::operator==
bool operator==(const Array2D< T > &other) const
Equality operator.
Definition: Types.h:922
Argus::Rectangle::left
T & left()
Definition: Types.h:803
Argus::BayerTuple::gOdd
const T & gOdd() const
Definition: Types.h:649
Argus::STATUS_OUT_OF_MEMORY
@ STATUS_OUT_OF_MEMORY
An operation failed because of insufficient mavailable memory.
Definition: Types.h:113
Argus::BayerChannel
BayerChannel
Color channel constants for Bayer data.
Definition: Types.h:137
Argus::Array2D::resize
bool resize(const Size2D< uint32_t > &size)
Resize the array.
Definition: Types.h:932
Argus::BayerTuple::b
T & b()
Definition: Types.h:650
Argus::Tuple::operator/
const Tuple< N, T > operator/(const T &rhs) const
Returns the result of dividing this tuple by a single value.
Definition: Types.h:604
Argus::RGB_CHANNEL_B
@ RGB_CHANNEL_B
Definition: Types.h:167
Argus::Size2D::Size2D
Size2D(T init)
Definition: Types.h:758
Argus::Range::max
T & max()
Definition: Types.h:846
Argus::STATUS_COUNT
@ STATUS_COUNT
Definition: Types.h:131
Argus::Tuple::operator==
bool operator==(const Tuple< N, T > &rhs) const
Returns true when every element in the two tuples are identical.
Definition: Types.h:542
Argus::Array2D::operator()
const T & operator()(uint32_t i) const
Array indexing using () operator.
Definition: Types.h:953
Argus::Array2D::iterator
T * iterator
Definition: Types.h:888
Argus::STATUS_INVALID_SETTINGS
@ STATUS_INVALID_SETTINGS
The requested settings are invalid.
Definition: Types.h:107
Argus::RGBTuple::r
T & r()
Definition: Types.h:678
Argus::BayerTuple::BayerTuple
BayerTuple(const Tuple< BAYER_CHANNEL_COUNT, T > &other)
Definition: Types.h:629
Argus::Point3D::Point3D
Point3D()
Definition: Types.h:724
Argus::RGBTuple::RGBTuple
RGBTuple(T _r, T _g, T _b)
Definition: Types.h:671
Argus::Array2D::operator=
Array2D & operator=(const Array2D< T > &other)
Assignment operator.
Definition: Types.h:914
Argus::RGBTuple::RGBTuple
RGBTuple(const Tuple< RGB_CHANNEL_COUNT, T > &other)
Definition: Types.h:664
Argus::Array2D::end
const_iterator end() const
Definition: Types.h:944
Argus::Point2D::Point2D
Point2D()
Definition: Types.h:695
Argus::Point2D::x
T & x()
Definition: Types.h:709
Argus::Point2D
Point2D template class.
Definition: Types.h:692
Argus::Array2D::Array2D
Array2D(const Array2D< T > &other)
Copy constructor.
Definition: Types.h:907
Argus::RGBTuple
RGBTuple template class.
Definition: Types.h:660
Argus::RGBTuple::RGBTuple
RGBTuple()
Definition: Types.h:663
Argus::Array2D::const_iterator
const typedef T * const_iterator
Definition: Types.h:889
Argus::COORDINATE_X
@ COORDINATE_X
Definition: Types.h:152
Argus::Point3D::y
const T & y() const
Definition: Types.h:742
Argus::BAYER_CHANNEL_R
@ BAYER_CHANNEL_R
Definition: Types.h:139
Argus::COORDINATE_2D_COUNT
@ COORDINATE_2D_COUNT
Definition: Types.h:156
Argus::UniqueObj::operator*
T & operator*() const
Definition: Types.h:504
Argus::Destructable
A top level object class for libargus objects that are created and owned by the client.
Definition: Types.h:443
Argus::UniqueObj::reset
void reset(T *obj=NULL)
Definition: Types.h:494
Argus::Size2D::height
T & height()
Definition: Types.h:771
Argus::BayerTuple::r
const T & r() const
Definition: Types.h:645
Argus::BayerTuple::r
T & r()
Definition: Types.h:644
Argus::Size2D::height
const T & height() const
Definition: Types.h:772
Argus::Point3D::Point3D
Point3D(T init)
Definition: Types.h:727
Argus::Size2D::width
T & width()
Definition: Types.h:769
Argus::Status
Status
Status values returned by API function calls.
Definition: Types.h:98
Argus::Rectangle::area
T area() const
Returns the area of the rectangle (width * height).
Definition: Types.h:819
Argus::UniqueObj
Template helper emulating C++11 rvalue semantics.
Definition: Types.h:489
Argus::Range::min
const T & min() const
Definition: Types.h:845
Argus::Range::Range
Range(T init)
Definition: Types.h:833
Argus::Rectangle::right
const T & right() const
Definition: Types.h:808
Argus::Range::Range
Range()
Definition: Types.h:830
Argus::Array2D::begin
iterator begin()
Definition: Types.h:945
Argus::BAYER_CHANNEL_G_ODD
@ BAYER_CHANNEL_G_ODD
Definition: Types.h:141
Argus::UniqueObj::~UniqueObj
~UniqueObj()
Definition: Types.h:502
Argus::Point2D::Point2D
Point2D(T _x, T _y)
Definition: Types.h:703
Argus::Array2D::data
const T * data() const
Definition: Types.h:963
Argus::Size2D::Size2D
Size2D(T _width, T _height)
Definition: Types.h:763
Argus::Point3D::z
T & z()
Definition: Types.h:743
Argus::STATUS_TIMEOUT
@ STATUS_TIMEOUT
An operation timed out.
Definition: Types.h:119