Libargus API
Libargus Camera API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
Types.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016-2022, NVIDIA CORPORATION. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * * Redistributions of source code must retain the above copyright
8  * notice, this list of conditions and the following disclaimer.
9  * * Redistributions in binary form must reproduce the above copyright
10  * notice, this list of conditions and the following disclaimer in the
11  * documentation and/or other materials provided with the distribution.
12  * * Neither the name of NVIDIA CORPORATION nor the names of its
13  * contributors may be used to endorse or promote products derived
14  * from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 /**
30  * @file
31  * <b>Libargus API: Types API</b>
32  *
33  * @b Description: Defines the basic types that are used by the API.
34  */
35 
36 #ifndef _ARGUS_TYPES_H
37 #define _ARGUS_TYPES_H
38 
39 #include <stdint.h>
40 #include <vector>
41 #include <string>
42 #include <assert.h>
43 
44 #include <EGL/egl.h>
45 #include <EGL/eglext.h>
46 
47 // Some versions of the Xlib.h header file define 'Status' to 'int'.
48 // This collides with the libargus 'Status' type.
49 // If 'Status' is defined then undefine it and use a typedef instead.
50 #ifdef Status
51 #undef Status
52 typedef int Status;
53 #endif // Status
54 
55 namespace Argus
56 {
57 
58 /*
59  * Forward declaration of standard objects
60  */
61 class CameraDevice;
62 class CameraProvider;
63 class CaptureSession;
64 class CaptureMetadata;
65 class CaptureMetadataContainer;
66 class Event;
67 class EventQueue;
68 class InputStream;
69 class OutputStream;
70 class OutputStreamSettings;
71 class Request;
72 class SensorMode;
73 
74 /*
75  * Forward declaration of standard interfaces
76  */
77 class ICameraProperties;
78 class ICameraProvider;
79 class ICaptureSession;
80 class IAutoControlSettings;
81 class IRequest;
82 class IStream;
83 class IStreamSettings;
84 
85 /**
86  * Constant used for infinite timeouts.
87  */
88 const uint64_t TIMEOUT_INFINITE = 0xFFFFFFFFFFFFFFFF;
89 
90 /**
91  * Status values returned by API function calls.
92  */
93 enum Status
94 {
95  /// Function succeeded.
96  STATUS_OK = 0,
97 
98  /// The set of parameters passed was invalid.
100 
101  /// The requested settings are invalid.
103 
104  /// The requested device is unavailable.
106 
107  /// An operation failed because of insufficient mavailable memory.
109 
110  /// This method has not been implemented.
112 
113  /// An operation timed out.
115 
116  /// The capture was aborted. @see ICaptureSession::cancelRequests()
118 
119  /// The stream or other resource has been disconnected.
121 
122  /// End of stream, used by Stream objects.
124 
125  // Number of elements in this enum.
127 };
128 
129 /**
130  * Color channel constants for Bayer data.
131  */
133 {
138 
140 };
141 
142 /**
143  * Coordinates used for 2D and 3D points.
144  */
146 {
150 
153 };
154 
155 /**
156  * Color channel constants for RGB data.
157  */
159 {
163 
165 };
166 
167 /**
168  * Auto Exposure Anti-Banding Modes.
169  */
170 DEFINE_NAMED_UUID_CLASS(AeAntibandingMode);
171 DEFINE_UUID(AeAntibandingMode, AE_ANTIBANDING_MODE_OFF, AD1E5560,9C16,11E8,B568,18,00,20,0C,9A,66);
172 DEFINE_UUID(AeAntibandingMode, AE_ANTIBANDING_MODE_AUTO, AD1E5561,9C16,11E8,B568,18,00,20,0C,9A,66);
173 DEFINE_UUID(AeAntibandingMode, AE_ANTIBANDING_MODE_50HZ, AD1E5562,9C16,11E8,B568,18,00,20,0C,9A,66);
174 DEFINE_UUID(AeAntibandingMode, AE_ANTIBANDING_MODE_60HZ, AD1E5563,9C16,11E8,B568,18,00,20,0C,9A,66);
175 
176 /**
177  * Auto Exposure Flicker States.
178  */
179 DEFINE_NAMED_UUID_CLASS(AeFlickerState);
180 DEFINE_UUID(AeFlickerState, AE_FLICKER_NONE, AD1E5564,9C16,11E8,B568,18,00,20,0C,9A,66);
181 DEFINE_UUID(AeFlickerState, AE_FLICKER_50HZ, AD1E5565,9C16,11E8,B568,18,00,20,0C,9A,66);
182 DEFINE_UUID(AeFlickerState, AE_FLICKER_60HZ, AD1E5566,9C16,11E8,B568,18,00,20,0C,9A,66);
183 
184 /**
185  * Auto Exposure States.
186  */
187 DEFINE_NAMED_UUID_CLASS(AeState);
188 DEFINE_UUID(AeState, AE_STATE_INACTIVE, D2EBEA50,9C16,11E8,B568,18,00,20,0C,9A,66);
189 DEFINE_UUID(AeState, AE_STATE_SEARCHING, D2EBEA51,9C16,11E8,B568,18,00,20,0C,9A,66);
190 DEFINE_UUID(AeState, AE_STATE_CONVERGED, D2EBEA52,9C16,11E8,B568,18,00,20,0C,9A,66);
191 DEFINE_UUID(AeState, AE_STATE_FLASH_REQUIRED, D2EBEA53,9C16,11E8,B568,18,00,20,0C,9A,66);
192 DEFINE_UUID(AeState, AE_STATE_TIMEOUT, D2EBEA54,9C16,11E8,B568,18,00,20,0C,9A,66);
193 
194 /**
195  * Auto White Balance (AWB) Modes.
196  */
197 DEFINE_NAMED_UUID_CLASS(AwbMode);
198 DEFINE_UUID(AwbMode, AWB_MODE_OFF, FB3F365A,CC62,11E5,9956,62,56,62,87,07,61);
199 DEFINE_UUID(AwbMode, AWB_MODE_AUTO, FB3F365B,CC62,11E5,9956,62,56,62,87,07,61);
200 DEFINE_UUID(AwbMode, AWB_MODE_INCANDESCENT, FB3F365C,CC62,11E5,9956,62,56,62,87,07,61);
201 DEFINE_UUID(AwbMode, AWB_MODE_FLUORESCENT, FB3F365D,CC62,11E5,9956,62,56,62,87,07,61);
202 DEFINE_UUID(AwbMode, AWB_MODE_WARM_FLUORESCENT, FB3F365E,CC62,11E5,9956,62,56,62,87,07,61);
203 DEFINE_UUID(AwbMode, AWB_MODE_DAYLIGHT, FB3F365F,CC62,11E5,9956,62,56,62,87,07,61);
204 DEFINE_UUID(AwbMode, AWB_MODE_CLOUDY_DAYLIGHT, FB3F3660,CC62,11E5,9956,62,56,62,87,07,61);
205 DEFINE_UUID(AwbMode, AWB_MODE_TWILIGHT, FB3F3661,CC62,11E5,9956,62,56,62,87,07,61);
206 DEFINE_UUID(AwbMode, AWB_MODE_SHADE, FB3F3662,CC62,11E5,9956,62,56,62,87,07,61);
207 DEFINE_UUID(AwbMode, AWB_MODE_MANUAL, 20FB45DA,C49F,4293,AB02,13,3F,8C,CA,DD,69);
208 
209 /**
210  * Auto White-Balance States.
211  */
212 DEFINE_NAMED_UUID_CLASS(AwbState);
213 DEFINE_UUID(AwbState, AWB_STATE_INACTIVE, E33CDB30,9C16,11E8,B568,18,00,20,0C,9A,66);
214 DEFINE_UUID(AwbState, AWB_STATE_SEARCHING, E33CDB31,9C16,11E8,B568,18,00,20,0C,9A,66);
215 DEFINE_UUID(AwbState, AWB_STATE_CONVERGED, E33CDB32,9C16,11E8,B568,18,00,20,0C,9A,66);
216 DEFINE_UUID(AwbState, AWB_STATE_LOCKED, E33CDB33,9C16,11E8,B568,18,00,20,0C,9A,66);
217 
218 /**
219  * A CaptureIntent may be provided during capture request creation to initialize the new
220  * Request with default settings that are appropriate for captures of the given intent.
221  * More details regarding each intent are as follows:
222  * MANUAL intent disables auto white balance and auto-focus.
223  * PREVIEW intent disables noise reduction related post-processing in order to
224  * reduce latency and resource usage.
225  * STILL_CAPTURE intent enables Noise Reduction related post-processing in order
226  * to optimize still image quality.
227  * VIDEO_RECORD intent enables motion sensors related post-processing to optimize
228  * the video quality.
229  * Apart from above processing blocks each intent also helps in optimizing the
230  * processing resource usage appropriate for that intent.
231  */
232 DEFINE_NAMED_UUID_CLASS(CaptureIntent);
233 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_MANUAL, FB3F3663,CC62,11E5,9956,62,56,62,87,07,61);
234 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_PREVIEW, FB3F3664,CC62,11E5,9956,62,56,62,87,07,61);
235 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_STILL_CAPTURE, FB3F3665,CC62,11E5,9956,62,56,62,87,07,61);
236 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_VIDEO_RECORD, FB3F3666,CC62,11E5,9956,62,56,62,87,07,61);
237 DEFINE_UUID(CaptureIntent, CAPTURE_INTENT_VIDEO_SNAPSHOT, FB3F3667,CC62,11E5,9956,62,56,62,87,07,61);
238 
239 /**
240  * Denoise (noise reduction) Modes.
241  */
242 DEFINE_NAMED_UUID_CLASS(DenoiseMode);
243 DEFINE_UUID(DenoiseMode, DENOISE_MODE_OFF, FB3F3668,CC62,11E5,9956,62,56,62,87,07,61);
244 DEFINE_UUID(DenoiseMode, DENOISE_MODE_FAST, FB3F3669,CC62,11E5,9956,62,56,62,87,07,61);
245 DEFINE_UUID(DenoiseMode, DENOISE_MODE_HIGH_QUALITY, FB3F366A,CC62,11E5,9956,62,56,62,87,07,61);
246 
247 /**
248  * Edge Enhance Modes.
249  */
250 DEFINE_NAMED_UUID_CLASS(EdgeEnhanceMode);
251 DEFINE_UUID(EdgeEnhanceMode, EDGE_ENHANCE_MODE_OFF, F7100B40,6A5F,11E6,BDF4,08,00,20,0C,9A,66);
252 DEFINE_UUID(EdgeEnhanceMode, EDGE_ENHANCE_MODE_FAST, F7100B41,6A5F,11E6,BDF4,08,00,20,0C,9A,66);
253 DEFINE_UUID(EdgeEnhanceMode, EDGE_ENHANCE_MODE_HIGH_QUALITY, F7100B42,6A5F,11E6,BDF4,08,00,20,0C,9A,66);
254 
255 /**
256  * Extension Names. Note that ExtensionName UUIDs are defined by their respective extension headers.
257  */
258 DEFINE_NAMED_UUID_CLASS(ExtensionName);
259 
260 /**
261  * Pixel formats.
262  */
263 DEFINE_NAMED_UUID_CLASS(PixelFormat);
264 DEFINE_UUID(PixelFormat, PIXEL_FMT_UNKNOWN, 00000000,93d5,11e5,0000,1c,b7,2c,ef,d4,1e);
265 DEFINE_UUID(PixelFormat, PIXEL_FMT_Y8, 569be14a,93d5,11e5,91bc,1c,b7,2c,ef,d4,1e);
266 DEFINE_UUID(PixelFormat, PIXEL_FMT_Y16, 56ddb19c,93d5,11e5,8e2c,1c,b7,2c,ef,d4,1e);
267 DEFINE_UUID(PixelFormat, PIXEL_FMT_YCbCr_420_888, 570c10e6,93d5,11e5,8ff3,1c,b7,2c,ef,d4,1e);
268 DEFINE_UUID(PixelFormat, PIXEL_FMT_YCbCr_422_888, 573a7940,93d5,11e5,99c2,1c,b7,2c,ef,d4,1e);
269 DEFINE_UUID(PixelFormat, PIXEL_FMT_YCbCr_444_888, 576043dc,93d5,11e5,8983,1c,b7,2c,ef,d4,1e);
270 DEFINE_UUID(PixelFormat, PIXEL_FMT_JPEG_BLOB, 578b08c4,93d5,11e5,9686,1c,b7,2c,ef,d4,1e);
271 DEFINE_UUID(PixelFormat, PIXEL_FMT_RAW16, 57b484d8,93d5,11e5,aeb6,1c,b7,2c,ef,d4,1e);
272 DEFINE_UUID(PixelFormat, PIXEL_FMT_P016, 57b484d9,93d5,11e5,aeb6,1c,b7,2c,ef,d4,1e);
273 DEFINE_UUID(PixelFormat, PIXEL_FMT_LegacyRGBA, 091b5007,6784,4121,94c7,59,0d,29,03,36,72);
274 
275 /**
276  * The SensorModeType of a sensor defines the type of image data that is output by the
277  * imaging sensor before any sort of image processing (ie. pre-ISP format).
278  */
279 DEFINE_NAMED_UUID_CLASS(SensorModeType);
280 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_DEPTH, 64483464,4b91,11e6,bbbd,40,16,7e,ab,86,92);
281 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_YUV, 6453e00c,4b91,11e6,871d,40,16,7e,ab,86,92);
282 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_RGB, 6463d4c6,4b91,11e6,88a3,40,16,7e,ab,86,92);
283 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_BAYER, 646f04ea,4b91,11e6,9c06,40,16,7e,ab,86,92);
284 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_BAYER_PWL, f6a08220,6a0f,11eb,8572,08,00,20,0c,9a,66);
285 DEFINE_UUID(SensorModeType, SENSOR_MODE_TYPE_BAYER_DOL, f6a08221,6a0f,11eb,8572,08,00,20,0c,9a,66);
286 
287 /**
288  * SensorPlacement defines the placement of the sensor on the module
289  */
290 DEFINE_NAMED_UUID_CLASS(SensorPlacement);
291 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_REAR_OR_BOTTOM_OR_BOTTOM_LEFT, 01dba8b0,1946,11eb,8b6f,08,00,20,0c,9a,66);
292 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_FRONT_OR_TOP_OR_CENTER_LEFT, 01dba8b1,1946,11eb,8b6f,08,00,20,0c,9a,66);
293 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_CENTER_OR_CENTER_RIGHT, 01dba8b2,1946,11eb,8b6f,08,00,20,0c,9a,66);
294 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_TOP_LEFT, 01dba8b3,1946,11eb,8b6f,08,00,20,0c,9a,66);
295 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_BOTTOM_RIGHT, 01dba8b4,1946,11eb,8b6f,08,00,20,0c,9a,66);
296 DEFINE_UUID(SensorPlacement, SENSOR_PLACEMENT_TOP_RIGHT, 01dba8b5,1946,11eb,8b6f,08,00,20,0c,9a,66);
297 
298 
299 /**
300  * Bayer Phases
301  */
302 DEFINE_NAMED_UUID_CLASS(BayerPhase);
303 DEFINE_UUID(BayerPhase, BAYER_PHASE_UNKNOWN, b9d43270,6a0e,12eb,8572,08,00,20,0c,9a,66);
304 DEFINE_UUID(BayerPhase, BAYER_PHASE_RGGB, b9d43271,6a0e,12eb,8572,08,00,20,0c,9a,66);
305 DEFINE_UUID(BayerPhase, BAYER_PHASE_BGGR, b9d43272,6a0e,12eb,8572,08,00,20,0c,9a,66);
306 DEFINE_UUID(BayerPhase, BAYER_PHASE_GRBG, b9d43273,6a0e,12eb,8572,08,00,20,0c,9a,66);
307 DEFINE_UUID(BayerPhase, BAYER_PHASE_GBRG, b9d43274,6a0e,12eb,8572,08,00,20,0c,9a,66);
308 
309 /**
310  * PixelFormatType
311  */
312 DEFINE_NAMED_UUID_CLASS(PixelFormatType);
313 DEFINE_UUID(PixelFormatType, PixelFormatType_None, b7d9b3a4,cdc6,4267,9969,57,a3,00,9a,41,32);
314 DEFINE_UUID(PixelFormatType, PixelFormatType_YuvOnly, 45bdf956,5624,4c2b,a196,fa,87,6d,a0,84,19);
315 DEFINE_UUID(PixelFormatType, PixelFormatType_RgbOnly, a5e5e1e9,56ac,4d14,8ce7,39,16,05,6c,86,4c);
316 DEFINE_UUID(PixelFormatType, PixelFormatType_Both, 7c0d1c33,bd27,4294,9dc6,04,1f,9f,9d,86,3c);
317 
318 /**
319  * CVOutput
320  */
321 DEFINE_NAMED_UUID_CLASS(CVOutput);
322 DEFINE_UUID(CVOutput, CVOutput_None, cf6353af,331f,4153,aaba,60,ef,87,36,04,03);
323 DEFINE_UUID(CVOutput, CVOutput_Linear, fa260819,baf4,4dea,9c15,eb,96,c0,95,0e,0e);
324 DEFINE_UUID(CVOutput, CVOutput_NonLinear, f19a1652,7e69,4efe,a6c9,72,05,ad,9d,95,fe);
325 
326 /**
327  * Utility class for libargus interfaces.
328  */
330 {
331 protected:
333 
334 private:
335  NonCopyable(NonCopyable& other);
337 };
338 
339 /**
340  * The top-level interface class.
341  *
342  * By convention, every Interface subclass exposes a public static method called @c id(),
343  * which returns the unique InterfaceID for that interface.
344  * This is required for the @c interface_cast<> template to work with that interface.
345  */
347 {
348 protected:
351 };
352 
353 /**
354  * A unique identifier for a libargus Interface.
355  */
356 class InterfaceID : public NamedUUID
357 {
358 public:
359  InterfaceID(uint32_t time_low_
360  , uint16_t time_mid_
361  , uint16_t time_hi_and_version_
362  , uint16_t clock_seq_
363  , uint8_t c0, uint8_t c1, uint8_t c2, uint8_t c3, uint8_t c4, uint8_t c5
364  , const char* name)
365  : NamedUUID(time_low_, time_mid_, time_hi_and_version_, clock_seq_,
366  c0, c1, c2, c3, c4, c5, name)
367  {}
368 
370  : NamedUUID(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "IID_UNSPECIFIED")
371  {}
372 };
373 
374 /**
375  * The base interface for a class that provides libargus Interfaces.
376  */
378 {
379 public:
380 
381  /**
382  * Acquire the interface specified by @c interfaceId.
383  * @returns An instance of the requested interface,
384  * or NULL if that interface is not available.
385  */
386  virtual Interface* getInterface(const InterfaceID& interfaceId) = 0;
387 
388 protected:
390 };
391 
392 /**
393  * Interface-casting helper similar to dynamic_cast.
394  */
395 
396 template <typename TheInterface>
397 inline TheInterface* interface_cast(InterfaceProvider* obj)
398 {
399  return static_cast<TheInterface*>(obj ? obj->getInterface(TheInterface::id()): 0);
400 }
401 
402 template <typename TheInterface>
403 inline TheInterface* interface_cast(const InterfaceProvider* obj)
404 {
405  return static_cast<TheInterface*>(
406  obj ? const_cast<const Interface*>(
407  const_cast<InterfaceProvider*>(obj)->getInterface(TheInterface::id())): 0);
408 }
409 
410 /**
411  * A top level object class for libargus objects that are created and owned by
412  * the client. All Destructable objects created by the client must be explicitly destroyed.
413  */
415 {
416 public:
417 
418  /**
419  * Destroy this object.
420  * After making this call, the client cannot make any more calls on this object.
421  */
422  virtual void destroy() = 0;
423 
424 protected:
426 };
427 
428 /**
429  * Template helper emulating C++11 rvalue semantics.
430  * @cond
431  */
432 template<typename T>
433 class rv : public T
434 {
435  rv();
436  ~rv();
437  rv(const rv&);
438  void operator=(const rv&);
439 };
440 
441 template<typename T>
442  rv<T>& move(T& self)
443 {
444  return *static_cast<rv<T>*>(&self);
445 }
446 /** @endcond */
447 
448 /**
449  * Movable smart pointer mimicking std::unique_ptr.
450  * @cond
451  */
452 template <typename T> struct remove_const;
453 template <typename T> struct remove_const<const T&>{ typedef T& type; };
454 template <typename T> struct remove_const<const T*>{ typedef T* type; };
455 template <typename T> struct remove_const<const T >{ typedef T type; };
456 template <typename T> struct remove_const { typedef T type; };
457 /** @endcond */
458 
459 template <typename T>
461 {
462 public:
463  explicit UniqueObj(T* obj=NULL): m_obj(obj) {}
464 
465  void reset(T* obj=NULL)
466  { if (m_obj && (m_obj != obj)) const_cast<typename remove_const<T*>::type>(m_obj)->destroy(); m_obj = obj; }
467  T* release()
468  { T* obj = m_obj; m_obj = NULL; return obj; }
469 
470  UniqueObj( rv<UniqueObj>& moved ): m_obj(moved.release()) {}
471  UniqueObj& operator=( rv<UniqueObj>& moved ){ reset( moved.release()); return *this; }
472 
473  ~UniqueObj() { reset(); }
474 
475  T& operator*() const { return *m_obj; }
476  T* get() const { return m_obj; }
477 
478  operator bool() const { return !!m_obj; }
479 
480  operator rv<UniqueObj>&() { return *static_cast< rv<UniqueObj>*>(this); }
481  operator const rv<UniqueObj>&() const { return *static_cast<const rv<UniqueObj>*>(this); }
482 
483 private:
484  T* m_obj;
485 
486  T* operator->() const; // Prevent calling destroy() directly.
487  // Note: For getInterface functionality use interface_cast.
488 };
489 
490 template <typename TheInterface, typename TObject>
491 inline TheInterface* interface_cast(const UniqueObj<TObject>& obj)
492 {
493  return interface_cast<TheInterface>( obj.get());
494 }
495 
496 /**
497  * Tuple template class. This provides a finite ordered list of N elements having type T.
498  */
499 template <unsigned int N, typename T>
500 class Tuple
501 {
502 public:
503  Tuple() {}
504 
505  /// Initialize every element of the tuple to a single value.
506  Tuple(T init)
507  {
508  for (unsigned int i = 0; i < N; i++)
509  m_data[i] = init;
510  }
511 
512  /// Returns true when every element in the two tuples are identical.
513  bool operator==(const Tuple<N,T>& rhs) const
514  {
515  return !memcmp(m_data, rhs.m_data, sizeof(m_data));
516  }
517 
518  /// Returns true if there are any differences between the two tuples.
519  bool operator!=(const Tuple<N,T>& rhs) const
520  {
521  return !(*this == rhs);
522  }
523 
524  /// Adds every element of another tuple to the elements of this tuple.
526  {
527  for (unsigned int i = 0; i < N; i++)
528  m_data[i] += rhs.m_data[i];
529  return *this;
530  }
531 
532  /// Subtracts every element of another tuple from the elements of this tuple.
534  {
535  for (unsigned int i = 0; i < N; i++)
536  m_data[i] -= rhs.m_data[i];
537  return *this;
538  }
539 
540  /// Multiplies every element in the tuple by a single value.
541  Tuple<N, T>& operator*=(const T& rhs)
542  {
543  for (unsigned int i = 0; i < N; i++)
544  m_data[i] *= rhs;
545  return *this;
546  }
547 
548  /// Divides every element in the tuple by a single value.
549  Tuple<N, T>& operator/=(const T& rhs)
550  {
551  for (unsigned int i = 0; i < N; i++)
552  m_data[i] /= rhs;
553  return *this;
554  }
555 
556  /// Returns the result of adding another tuple to this tuple.
557  const Tuple<N, T> operator+(const Tuple<N, T>& rhs) const
558  {
559  return Tuple<N, T>(*this) += rhs;
560  }
561 
562  /// Returns the result of subtracting another tuple from this tuple.
563  const Tuple<N, T> operator-(const Tuple<N, T>& rhs) const
564  {
565  return Tuple<N, T>(*this) -= rhs;
566  }
567 
568  /// Returns the result of multiplying this tuple by a single value.
569  const Tuple<N, T> operator*(const T& rhs) const
570  {
571  return Tuple<N, T>(*this) *= rhs;
572  }
573 
574  /// Returns the result of dividing this tuple by a single value.
575  const Tuple<N, T> operator/(const T& rhs) const
576  {
577  return Tuple<N, T>(*this) /= rhs;
578  }
579 
580  T& operator[](unsigned int i) { assert(i < N); return m_data[i]; }
581  const T& operator[](unsigned int i) const { assert(i < N); return m_data[i]; }
582 
583  /// Returns the number of elements in the tuple.
584  static unsigned int tupleSize() { return N; }
585 
586 protected:
587  T m_data[N];
588 };
589 
590 /**
591  * BayerTuple template class. This is a Tuple specialization containing 4 elements corresponding
592  * to the Bayer color channels: R, G_EVEN, G_ODD, and B. Values can be accessed using the named
593  * methods or subscript indexing using the Argus::BayerChannel enum.
594  */
595 template <typename T>
596 class BayerTuple : public Tuple<BAYER_CHANNEL_COUNT, T>
597 {
598 public:
601 
602  BayerTuple(T init)
603  {
604  r() = gEven() = gOdd() = b() = init;
605  }
606 
607  BayerTuple(T _r, T _gEven, T _gOdd, T _b)
608  {
609  r() = _r;
610  gEven() = _gEven;
611  gOdd() = _gOdd;
612  b() = _b;
613  }
614 
623 };
624 
625 /**
626  * RGBTuple template class. This is a Tuple specialization containing 3 elements corresponding
627  * to the RGB color channels: R, G, and B. Values can be accessed using the named methods or
628  * subscript indexing using the Argus::RGBChannel enum.
629  */
630 template <typename T>
631 class RGBTuple : public Tuple<RGB_CHANNEL_COUNT, T>
632 {
633 public:
634  RGBTuple() {}
636 
637  RGBTuple(T init)
638  {
639  r() = g() = b() = init;
640  }
641 
642  RGBTuple(T _r, T _g, T _b)
643  {
644  r() = _r;
645  g() = _g;
646  b() = _b;
647  }
648 
655 };
656 
657 /**
658  * Point2D template class. This is a Tuple specialization containing 2 elements corresponding
659  * to the x and y coordinates a 2D point. Values can be accessed using the named methods or
660  * subscript indexing using the Argus::Coordinate enum.
661  */
662 template <typename T>
663 class Point2D : public Tuple<COORDINATE_2D_COUNT, T>
664 {
665 public:
666  Point2D() {}
668 
669  Point2D(T init)
670  {
671  x() = y() = init;
672  }
673 
674  Point2D(T _x, T _y)
675  {
676  x() = _x;
677  y() = _y;
678  }
679 
684 };
685 
686 /**
687  * Point3D template class. This is a Tuple specialization containing 3 elements corresponding
688  * to the x, y and z coordinates of a 3D point. Values can be accessed using the named methods or
689  * subscript indexing using the Argus::Coordinate enum.
690  */
691 template <typename T>
692 class Point3D : public Tuple<COORDINATE_3D_COUNT, T>
693 {
694 public:
695  Point3D() {}
697 
698  Point3D(T init)
699  {
700  x() = y() = z() = init;
701  }
702 
703  Point3D(T _x, T _y, T _z)
704  {
705  x() = _x;
706  y() = _y;
707  z() = _z;
708  }
709 
716 };
717 
718 /**
719  * Size2D template class. This is a Tuple specialization containing 2 elements corresponding to the
720  * width and height of a 2D size, in that order. Values can be accessed using the named methods.
721  */
722 template <typename T>
723 class Size2D : public Tuple<2, T>
724 {
725 public:
726  Size2D() {}
727  Size2D(const Tuple<2, T>& other) : Tuple<2, T>(other) {}
728 
729  Size2D(T init)
730  {
731  width() = height() = init;
732  }
733 
734  Size2D(T _width, T _height)
735  {
736  width() = _width;
737  height() = _height;
738  }
739 
740  T& width() { return Tuple<2, T>::m_data[0]; }
741  const T& width() const { return Tuple<2, T>::m_data[0]; }
742  T& height() { return Tuple<2, T>::m_data[1]; }
743  const T& height() const { return Tuple<2, T>::m_data[1]; }
744 
745  /// Returns the area of the size (width * height).
746  T area() const { return width() * height(); }
747 };
748 
749 /**
750  * Rectangle template class. This is a Tuple specialization containing 4 elements corresponding
751  * to the positions of the left, top, right, and bottom edges of a rectangle, in that order.
752  * Values can be accessed using the named methods.
753  */
754 template <typename T>
755 class Rectangle : public Tuple<4, T>
756 {
757 public:
759  Rectangle(const Tuple<4, T>& other) : Tuple<4, T>(other) {}
760 
761  Rectangle(T init)
762  {
763  left() = top() = right() = bottom() = init;
764  }
765 
766  Rectangle(T _left, T _top, T _right, T _bottom)
767  {
768  left() = _left;
769  top() = _top;
770  right() = _right;
771  bottom() = _bottom;
772  }
773 
774  T& left() { return Tuple<4, T>::m_data[0]; }
775  const T& left() const { return Tuple<4, T>::m_data[0]; }
776  T& top() { return Tuple<4, T>::m_data[1]; }
777  const T& top() const { return Tuple<4, T>::m_data[1]; }
778  T& right() { return Tuple<4, T>::m_data[2]; }
779  const T& right() const { return Tuple<4, T>::m_data[2]; }
780  T& bottom() { return Tuple<4, T>::m_data[3]; }
781  const T& bottom() const { return Tuple<4, T>::m_data[3]; }
782 
783  /// Returns the width of the rectangle.
784  T width() const { return right() - left(); }
785 
786  /// Returns the height of the rectangle.
787  T height() const { return bottom() - top(); }
788 
789  /// Returns the area of the rectangle (width * height).
790  T area() const { return width() * height(); }
791 };
792 
793 /**
794  * Range template class. This is a Tuple specialization containing 2 elements corresponding to the
795  * min and max values of the range, in that order. Values can be accessed using the named methods.
796  */
797 template <typename T>
798 class Range : public Tuple<2, T>
799 {
800 public:
801  Range() {}
802  Range(const Tuple<2, T>& other) : Tuple<2, T>(other) {}
803 
804  Range(T init)
805  {
806  min() = max() = init;
807  }
808 
809  Range(T _min, T _max)
810  {
811  min() = _min;
812  max() = _max;
813  }
814 
815  T& min() { return Tuple<2, T>::m_data[0]; }
816  const T& min() const { return Tuple<2, T>::m_data[0]; }
817  T& max() { return Tuple<2, T>::m_data[1]; }
818  const T& max() const { return Tuple<2, T>::m_data[1]; }
819 
820  bool empty() const { return max() < min(); }
821 };
822 
823 /**
824  * Defines an autocontrol region of interest (in pixel space). This region consists of a rectangle
825  * (inherited from the Rectangle<uint32_t> Tuple) and a floating point weight value.
826  */
827 class AcRegion : public Rectangle<uint32_t>
828 {
829 public:
831  : Rectangle<uint32_t>(0, 0, 0, 0)
832  , m_weight(1.0f)
833  {}
834 
835  AcRegion(uint32_t _left, uint32_t _top, uint32_t _right, uint32_t _bottom, float _weight)
836  : Rectangle<uint32_t>(_left, _top, _right, _bottom)
837  , m_weight(_weight)
838  {}
839 
840  float& weight() { return m_weight; }
841  const float& weight() const { return m_weight; }
842 
843 protected:
844  float m_weight;
845 };
846 
847 /**
848  * A template class to hold a 2-dimensional array of data.
849  * Data in this array is tightly packed in a 1-dimensional vector in row-major order;
850  * that is, the vector index for any value given its 2-dimensional location (Point2D) is
851  * index = location.x() + (location.y() * size.x());
852  * Indexing operators using iterators, 1-dimensional, or 2-dimensional coordinates are provided.
853  */
854 template <typename T>
855 class Array2D
856 {
857 public:
858  // Iterator types.
859  typedef T* iterator;
860  typedef const T* const_iterator;
861 
862  /// Default Constructor.
863  Array2D() : m_size(0, 0) {}
864 
865  /// Constructor given initial array size.
867  {
868  m_data.resize(size.width() * size.height());
869  }
870 
871  /// Constructor given initial array size and initial fill value.
872  Array2D(const Size2D<uint32_t>& size, const T& value) : m_size(size)
873  {
874  m_data.resize(size.width() * size.height(), value);
875  }
876 
877  /// Copy constructor.
878  Array2D(const Array2D<T>& other)
879  {
880  m_data = other.m_data;
881  m_size = other.m_size;
882  }
883 
884  /// Assignment operator.
886  {
887  m_data = other.m_data;
888  m_size = other.m_size;
889  return *this;
890  }
891 
892  /// Equality operator.
893  bool operator== (const Array2D<T>& other) const
894  {
895  return (m_size == other.m_size && m_data == other.m_data);
896  }
897 
898  /// Returns the size (dimensions) of the array.
899  Size2D<uint32_t> size() const { return m_size; }
900 
901  /// Resize the array. Array contents after resize are undefined.
902  /// Boolean return value enables error checking when exceptions are not available.
904  {
905  uint32_t s = size.width() * size.height();
906  m_data.resize(s);
907  if (m_data.size() != s)
908  return false;
909  m_size = size;
910  return true;
911  }
912 
913  /// STL style iterators.
914  inline const_iterator begin() const { return m_data.data(); }
915  inline const_iterator end() const { return m_data.data() + m_data.size(); }
916  inline iterator begin() { return m_data.data(); }
917  inline iterator end() { return m_data.data() + m_data.size(); }
918 
919  /// Array indexing using [] operator.
920  T& operator[](unsigned int i) { return m_data[checkIndex(i)]; }
921  const T& operator[](unsigned int i) const { return m_data[checkIndex(i)]; }
922 
923  /// Array indexing using () operator.
924  inline const T& operator() (uint32_t i) const { return m_data[checkIndex(i)]; }
925  inline const T& operator() (uint32_t x, uint32_t y) const { return m_data[checkIndex(x, y)]; }
926  inline const T& operator() (const Point2D<uint32_t>& p) const
927  { return m_data[checkIndex(p.x(), p.y())]; }
928  inline T& operator() (uint32_t i) { return m_data[checkIndex(i)]; }
929  inline T& operator() (uint32_t x, uint32_t y) { return m_data[checkIndex(x, y)]; }
930  inline T& operator() (const Point2D<uint32_t>& p)
931  { return m_data[checkIndex(p.x(), p.y())]; }
932 
933  // Get pointers to data.
934  inline const T* data() const { return m_data.data(); }
935  inline T* data() { return m_data.data(); }
936 
937 private:
938  inline uint32_t checkIndex(uint32_t i) const
939  {
940  assert(i < m_data.size());
941  return i;
942  }
943 
944  inline uint32_t checkIndex(uint32_t x, uint32_t y) const
945  {
946  assert(x < m_size.width());
947  assert(y < m_size.height());
948  return x + (y * m_size.width());
949  }
950 
951  std::vector<T> m_data;
953 };
954 
955 typedef uint32_t AutoControlId;
956 
957 } // namespace Argus
958 
959 #endif // _ARGUS_TYPES_H