CVB++ 15.0
global.hpp
1#pragma once
2
3#include <array>
4#include <functional>
5#include <iterator>
6#include <list>
7#include <memory>
8#include <mutex>
9#include <vector>
10
11#include "namespace.hpp"
12
13#include "_cexports/c_core.h"
14#include "_cexports/c_driver.h"
15
16#ifdef _DEBUG
17# define CVB_FORCE_INLINE inline
18#else // _DEBUG
19# ifdef _MSC_VER
20
21# define CVB_FORCE_INLINE __forceinline
22
23# elif __GNUC__ && __cplusplus
24
25# define CVB_FORCE_INLINE inline __attribute__((always_inline))
26
27# else
28
29# endif
30#endif // _DEBUG
31
32
33
35
50namespace Cvb
51{
52
53CVB_BEGIN_INLINE_NS
54
55class IArray;
56class DataType;
57class DeviceFactory;
58class ImagePlane;
59class LinearAccessData;
60class Vpat;
61
62class Buffer;
65
66class BufferBase;
69
70class PFNCBuffer;
73
74class Plane;
77
78class PlaneEnumerator;
81
82class Image;
85
86class WrappedImage;
89
93
94class Device;
97
98class Composite;
101
102class HandleOnly;
105
109
113
117
118const double CVB_M_PI = 3.14159265358979323846;
119
121
122template<class T>
124
125template<class T>
127
130{
136 Undefined,
140 UInt,
144 Int,
148 Float,
153};
154
156enum class ColorModel
157{
161 RGBGuess = CExports::CM_Guess_RGB,
165 MonoGuess = CExports::CM_Guess_Mono,
169 Unknown = CExports::CM_Unknown,
173 Mono = CExports::CM_Mono,
174
175#ifdef RGB
176#undef RGB
177#endif
181 RGB = CExports::CM_RGB,
185 YUV = CExports::CM_YUV,
189 HSI = CExports::CM_HSI,
193 YCbCr = CExports::CM_YCbCr,
197 CieLUV = CExports::CM_LUV,
201 CieLab = CExports::CM_Lab,
205 HLS = CExports::CM_HLS,
209 YCC = CExports::CM_YCC,
213 HSV = CExports::CM_HSV,
217 CieXYZ = CExports::CM_XYZ
218};
219
221
232{
253};
254
257{
266};
267
270{
279
288};
289
291enum class SubPixelMode
292{
298 ParabolicFast = CExports::TSubPixelMode::SP_Parabolic_Fast,
299
303 ParabolicAccurate = CExports::TSubPixelMode::SP_Parabolic_Accurate,
304
308 Gaussian = CExports::TSubPixelMode::SP_Gauss
309};
310
312
316enum class Neighborhood
317{
321 Use3x3 = 1,
322
326 Use5x5 = 2,
327
331 Use7x7 = 3,
332
336 Use9x9 = 4
337};
338
341{
346
353};
354
356enum class RotationMap
357{
361 By90Degrees = CExports::VPATROT_90,
362
366 By180Degrees = CExports::VPATROT_180,
367
371 By270Degrees = CExports::VPATROT_270
372};
373
375enum class WaitStatus
376{
378 Ok = CExports::CVDWS_Ok,
380 Timeout = CExports::CVDWS_Timeout,
382 Abort = CExports::CVDWS_Canceled
383};
384
386
390enum class PlaneRole
391{
393 Undefined = CExports::CVCPR_Undefined,
394
396 PixMono = CExports::CVCPR_PixMono,
398 PixRGB_R = CExports::CVCPR_PixRGB_R,
400 PixRGB_G = CExports::CVCPR_PixRGB_G,
402 PixRGB_B = CExports::CVCPR_PixRGB_B,
404 PixYUV_Y = CExports::CVCPR_PixYUV_Y,
406 PixYUV_U = CExports::CVCPR_PixYUV_U,
408 PixYUV_V = CExports::CVCPR_PixYUV_V,
410 PixHSV_H = CExports::CVCPR_PixHSV_H,
411 // Saturation channel value.
412 PixHSV_S = CExports::CVCPR_PixHSV_S,
414 PixHSV_V = CExports::CVCPR_PixHSV_V,
416 PixLAB_L = CExports::CVCPR_PixLAB_L,
418 PixLAB_A = CExports::CVCPR_PixLAB_A,
420 PixLAB_B = CExports::CVCPR_PixLAB_B,
422 PixConfidence = CExports::CVCPR_PixConfidence,
424 PixRGB_RGB = CExports::CVCPR_PixRGB_RGB,
425
427 CoordCartesian_X = CExports::CVCPR_CoordCartesian_X,
429 CoordCartesian_Y = CExports::CVCPR_CoordCartesian_Y,
431 CoordCartesian_Z = CExports::CVCPR_CoordCartesian_Z,
433 CoordCartesian_W = CExports::CVCPR_CoordCartesian_W,
435 CoordPolar_Rho = CExports::CVCPR_CoordPolar_Rho,
437 CoordPolar_Phi = CExports::CVCPR_CoordPolar_Phi,
439 CoordCylindrical_Rho = CExports::CVCPR_CoordCylindrical_Rho,
441 CoordCylindrical_Phi = CExports::CVCPR_CoordCylindrical_Phi,
443 CoordCylindrical_Z = CExports::CVCPR_CoordCylindrical_Z,
445 CoordSpherical_Rho = CExports::CVCPR_CoordSpherical_Rho,
447 CoordSpherical_Phi = CExports::CVCPR_CoordSpherical_Phi,
449 CoordSpherical_Theta = CExports::CVCPR_CoordSpherical_Theta,
451 Normal_X = CExports::CVCPR_Normal_X,
453 Normal_Y = CExports::CVCPR_Normal_Y,
455 Normal_Z = CExports::CVCPR_Normal_Z,
457 PointPlanarity = CExports::CVCPR_Point_Planarity,
459 PointVariation = CExports::CVCPR_Point_Variation,
461 PointSphericity = CExports::CVCPR_Point_Sphericity,
463 PointLinearity = CExports::CVCPR_Point_Linearity,
465 PointCurvature = CExports::CVCPR_Point_Curvature,
466
468 Custom = CExports::CVCPR_Custom
469};
470
473{
475 Horizontal = CExports::PM_Horizontal,
477 Vertical = CExports::PM_Vertical
478};
479
482{
486 Connected,
488 Disconnected
489};
490
491enum class CompositePurpose
492{
493 Custom = -1,
494 Image = 0,
495 ImageList,
496 MultiAoi,
497 RangeMap,
498 PointCloud,
499 ImageCube
500};
501
504{
509};
510
511namespace Internal
512{
513
514template <class T> class AsyncRef
515{
516public:
517 AsyncRef() = default;
518
519 std::shared_ptr<T> AtomicGet(std::function<std::shared_ptr<T>()> create = nullptr)
520 {
521 std::unique_lock<std::mutex> guard(mutex_);
522 auto ref = weakRef_.lock();
523 if (!ref && create)
524 {
525 ref = create();
526 weakRef_ = ref;
527 }
528 return ref;
529 }
530
531 void Reset() noexcept { weakRef_.reset(); }
532
533private:
534 std::mutex mutex_;
535
536 std::weak_ptr<T> weakRef_;
537};
538
539class HandlerCarrier
540{
541public:
542 HandlerCarrier() noexcept = default;
543 HandlerCarrier(const HandlerCarrier& other) noexcept = default;
544 HandlerCarrier& operator=(const HandlerCarrier& other) noexcept = default;
545 HandlerCarrier(HandlerCarrier&& other) noexcept = default;
546 HandlerCarrier& operator=(HandlerCarrier&& other) noexcept = default;
547 virtual ~HandlerCarrier() = default;
548};
549
550typedef std::shared_ptr<HandlerCarrier> HandlerCarrierPtr;
551typedef std::weak_ptr<HandlerCarrier> HandlerCarrierWPtr;
552
553class CarrierContainer;
554
555}
556
558
566{
568 friend Internal::CarrierContainer;
570
571public:
573
576 EventCookie() noexcept = default;
577
579
582 explicit operator bool() const noexcept { return !handlerCarrier_.expired(); }
583
584private:
585 explicit EventCookie(const Internal::HandlerCarrierPtr &handlerCarrier) noexcept
586 : handlerCarrier_(handlerCarrier)
587 {
588 }
589
590 Internal::HandlerCarrierWPtr handlerCarrier_;
591};
592
593namespace Internal
594{
595
596typedef void(REL_CB)(void *handle);
597
598}
599
600template <class T, Internal::REL_CB CB> class SharedHandleGuard;
601
602template <class T, Internal::REL_CB CB = nullptr> class HandleGuard
603{
604
605public:
606 explicit HandleGuard(void *handle) noexcept : handle_(handle, CB)
607 {
608 static_assert(std::is_same<T, void>::value,
609 "CVB: HandleGuard need specialization, or type void with release callback!");
610 }
611
612 HandleGuard(void *handle, std::function<void(void *)> deleter) noexcept : handle_(handle, deleter) {}
613
614 void *Handle() const noexcept { return handle_.get(); }
615
616 void Reset(void *handle = nullptr) noexcept { handle_.reset(handle); }
617
618 void *Release() noexcept { return handle_.release(); }
619
620private:
621 std::unique_ptr<void, std::function<void(void *)>> handle_;
622
623 friend class SharedHandleGuard<T, CB>;
624};
625
626typedef HandleGuard<void, CVB_CALL_CAPI(ReleaseObjectVoid)> ReleaseObjectGuard;
627
628template <class T, Internal::REL_CB CB = nullptr> class SharedHandleGuard
629{
630public:
631 explicit SharedHandleGuard(HandleGuard<T, CB> &&uniqueGuard) : shandle_(std::move(uniqueGuard.handle_)) {}
632
633 SharedHandleGuard(const SharedHandleGuard& other) noexcept= default;
634 SharedHandleGuard &operator=(const SharedHandleGuard &) noexcept = default;
635 SharedHandleGuard(SharedHandleGuard&& other) noexcept = default;
636 SharedHandleGuard& operator=(SharedHandleGuard&& other) noexcept = default;
637 ~SharedHandleGuard() = default;
638
639 void *Handle() const noexcept { return shandle_.get(); }
640
641private:
642 std::shared_ptr<void> shandle_;
643};
644
645typedef SharedHandleGuard<void, CVB_CALL_CAPI(ReleaseObjectVoid)> SharedReleaseObjectGuard;
646
647// forward declaration needed for gcc
648namespace Utilities
649{
650
651namespace SystemInfo
652{
653void ThrowLastError();
654void ThrowLastError(int errorCode);
655
656}
657
658}
659
660namespace Internal
661{
662
663template <class T> class CbCarrier : public HandlerCarrier
664{
665
666public:
667 static std::shared_ptr<CbCarrier> Create(std::function<T> cb) { return std::make_shared<CbCarrier<T>>(cb); }
668
669 explicit CbCarrier(std::function<T> cb) noexcept : cb_(cb) {}
670
671 std::function<T> CB() const noexcept { return cb_; }
672
673private:
675};
676
677class CarrierContainer
678{
679public:
680 CarrierContainer() noexcept {}
681
682 CarrierContainer(const CarrierContainer& other) = delete;
683 CarrierContainer& operator=(const CarrierContainer& other) = delete;
684 CarrierContainer(CarrierContainer&& other) noexcept
685 {
686 try
687 {
688 carrierList_ = std::move(other.carrierList_);
689 }
690 catch (...)
691 {
692 // does not realy throw - catch required for static anlysis
693 }
694 }
695 CarrierContainer& operator=(CarrierContainer&& other) = delete;
696 ~CarrierContainer() = default;
697
698 EventCookie Register(const HandlerCarrierPtr &handlerBase)
699 {
700 std::unique_lock<std::mutex> guard(carrierListMutex_);
701 carrierList_.push_back(handlerBase);
702 return EventCookie{ handlerBase };
703 }
704
705 void Unregister(EventCookie eventCookie) noexcept
706 {
707
708 auto handlerBase = eventCookie.handlerCarrier_.lock();
709 if (!handlerBase)
710 return;
711
712 std::unique_lock<std::mutex> guard(carrierListMutex_);
713 carrierList_.remove(handlerBase);
714 }
715
716 template <class T, class... Args> void Call(Args &&... args) const
717 {
719 {
720 std::unique_lock<std::mutex> guard(carrierListMutex_);
721 carrierList.insert(carrierList.end(), carrierList_.begin(), carrierList_.end());
722 }
723 for (auto& carrier : carrierList)
724 {
725 auto holder = std::dynamic_pointer_cast<CbCarrier<T>>(carrier);
726 holder->CB()(std::forward<Args>(args)...);
727 }
728 }
729
730private:
731
732
733 mutable std::mutex carrierListMutex_;
734 std::list<HandlerCarrierPtr> carrierList_;
735};
736
737template <class OBJ, class RES, class... ARGS>
738inline std::unique_ptr<OBJ> DoCallObjectOut(std::function<RES(void *&handle)> call, ARGS &&... args)
739{
740 void *handle = nullptr;
741 auto code = CExports::MakeErrorCode(call(handle));
742 if (code < 0)
743 {
744 Utilities::SystemInfo::ThrowLastError(code);
745 }
746 return OBJ::FromHandle(HandleGuard<OBJ>(handle), std::forward<ARGS>(args)...);
747}
748
749template <class OBJ, class... ARGS>
750inline std::unique_ptr<OBJ> DoBoolCallObjectOut(std::function<CExports::cvbbool_t(void *&handle)> call, ARGS &&... args)
751{
752 return DoCallObjectOut<OBJ, CExports::cvbbool_t, ARGS...>(call, std::forward<ARGS>(args)...);
753}
754
755template <class OBJ, class... ARGS>
756inline std::unique_ptr<OBJ> DoResCallObjectOut(std::function<CExports::cvbres_t(void *&handle)> call, ARGS &&... args)
757{
758 return DoCallObjectOut<OBJ, CExports::cvbres_t, ARGS...>(call, std::forward<ARGS>(args)...);
759}
760
761template <class OBJ> inline std::unique_ptr<OBJ> DoHandleCallObjectOut(void *result)
762{
763 return DoCallObjectOut<OBJ, void *>([=](void *&handle) { return (handle = result); });
764}
765
766template <class OBJ, class RES, class... ARGS>
767inline std::shared_ptr<OBJ> DoCallShareOut(std::function<RES(void *&handle)> call, ARGS &&... args)
768{
769 void *handle = nullptr;
770 auto code = CExports::MakeErrorCode(call(handle));
771 if (code < 0)
772 {
773 Utilities::SystemInfo::ThrowLastError(code);
774 }
775 return OBJ::template FromHandle<OBJ>(typename OBJ::GuardType(handle), std::forward<ARGS>(args)...);
776}
777
778template <class OBJ, class... ARGS>
779inline std::shared_ptr<OBJ> DoBoolCallShareOut(std::function<CExports::cvbbool_t(void *&handle)> call, ARGS &&... args)
780{
781 return DoCallShareOut<OBJ, CExports::cvbbool_t, ARGS...>(call, std::forward<ARGS>(args)...);
782}
783
784template <class OBJ, class... ARGS>
785inline std::shared_ptr<OBJ> DoResCallShareOut(std::function<CExports::cvbres_t(void *&handle)> call, ARGS &&... args)
786{
787 return DoCallShareOut<OBJ, CExports::cvbres_t, ARGS...>(call, std::forward<ARGS>(args)...);
788}
789
790template <class T, class RES> inline T DoCallValueOut(std::function<RES(T &handle)> call)
791{
792 T value;
793 auto code = CExports::MakeErrorCode(call(value));
794 if (code < 0)
795 {
796 Utilities::SystemInfo::ThrowLastError(code);
797 }
798 return value;
799}
800
801template <class T> inline T DoBoolCallValueOut(std::function<CExports::cvbbool_t(T &handle)> call)
802{
803 return DoCallValueOut<T, CExports::cvbbool_t>(call);
804}
805
806template <class T> inline T DoResCallValueOut(std::function<CExports::cvbres_t(T &value)> call)
807{
808 return DoCallValueOut<T, CExports::cvbres_t>(call);
809}
810
811template <class RES> inline void DoCall(std::function<RES()> call)
812{
813 auto code = CExports::MakeErrorCode(call());
814 if (code < 0)
815 Utilities::SystemInfo::ThrowLastError(code);
816}
817
818inline void DoBoolCall(std::function<CExports::cvbbool_t()> call)
819{
820 DoCall<CExports::cvbbool_t>(call);
821}
822
823inline void DoResCall(std::function<CExports::cvbres_t()> call)
824{
825 DoCall<CExports::cvbres_t>(call);
826}
827
828class SmartBool final
829{
830public:
831 SmartBool() noexcept = default;
832 SmartBool(bool val) noexcept : cVal_(val ? 1 : 0) {} // NOLINT
833
834#if defined _WIN32
835 SmartBool(CExports::cvbbool_t val) noexcept : cVal_(val) {} // NOLINT
836#endif
837
838 operator bool() const noexcept { return ((cVal_) ? true : false); } // NOLINT
839
840 CExports::cvbbool_t *Ptr() noexcept { return &cVal_; }
841
842private:
843 CExports::cvbbool_t cVal_ = 0;
844};
845
846}
847
848template <class T>
849using IsNumeric =
854
855template <class T> using EnableIfNumeric = std::enable_if<IsNumeric<T>::value>;
856
857template <class T> using EnableIfArithmetic = std::enable_if<std::is_arithmetic<T>::value>;
858
859template <class T, class... ARGS> struct AllOfType;
860
861template <class T, class ARG> struct AllOfType<T, ARG>
862{
863 static constexpr bool Value =
866};
867
868template <class T, class ARG, class... ARGS> struct AllOfType<T, ARG, ARGS...>
869{
870 static constexpr bool Value =
873 AllOfType<T, ARGS...>::Value;
874};
875
876template <typename RET, typename TYPE, class RANGE>
877using TypedRange = std::enable_if<std::is_same<TYPE,
878 typename std::remove_const<typename std::remove_reference<decltype(
879 *std::begin(std::declval<RANGE &>()))>::type>::type>::value,
880 RET>;
881
882template <class RET, class TYPE, class... ARGS>
883using VarArgRange = typename std::enable_if<AllOfType<TYPE, ARGS...>::Value, RET>;
884
885template <class TYPE, class RANGE> class RangeAdapter
886{
887public:
888 /* The constructor only stores the reference and compile-time-checks the value type.
889 * All operations are performed only when needed. */
890 explicit RangeAdapter(const RANGE &range) : inputRef_(range)
891 {
892 static_assert(
895 TYPE>::value,
896 "Unexpected range value type");
897 }
898
899 /* Returns pointer to the range values in a contiguous memory block. */
900 TYPE *Data() const
901 {
902 return const_cast<TYPE *>(Data(inputRef_.get())); // NOLINT(cppcoreguidelines-pro-type-const-cast)
903 }
904
905 /* Returns size of the range. */
906 std::size_t Size() const { return std::distance(std::begin(inputRef_.get()), std::end(inputRef_.get())); }
907
908private:
909 /* Actual input-range dependent workers for the contiguous data query. */
910 template <size_t N> const TYPE *Data(const TYPE (&carray)[N]) const { return carray; } //NOLINT(cppcoreguidelines-avoid-c-arrays)
911
912 template <size_t N> const TYPE *Data(const std::array<TYPE, N> &stdarray) const { return stdarray.data(); }
913
914 const TYPE *Data(const std::vector<TYPE> &stdvec) const { return stdvec.data(); }
915
916 template <class LIST> const TYPE *Data(const LIST &list) const
917 {
918 if (convertedRange_.empty())
919 {
920 convertedRange_.assign(std::begin(list), std::end(list));
921 }
922 return convertedRange_.data();
923 }
924
925private:
927 mutable std::vector<TYPE> convertedRange_;
928};
929
930template <class TYPE, class RANGE>
931RangeAdapter<TYPE, RANGE> MakeRangeAdapter(const RANGE &range, std::size_t minSize = 1)
932{
933 RangeAdapter<TYPE, RANGE> rangeAdapter(range);
934 if (minSize != 0 && rangeAdapter.Size() < minSize)
935 throw std::runtime_error("insufficient number of input range values");
936 return rangeAdapter;
937}
938
939template <class...>
940struct DispatchableTypeList
941{
942};
943
944template <class DT, class... DTS>
945struct DispatchableTypeList<DT, DTS...>
946{
947 using DefaultType = DT;
948};
949
979template <class PLANE_T>
981
982CVB_END_INLINE_NS
983
984}
985
Base class of all buffers.
Definition: buffer_base.hpp:22
A token to enable cancellation on wait operations.
Definition: cancellation_token.hpp:20
Provides tokens and signals tokens cancellation.
Definition: cancellation_token_source.hpp:20
Point components of the point cloud.
Definition: components_pointers_3d.hpp:19
Component class is a container for CVB objects.
Definition: decl_composite.hpp:45
Point components of a dense point cloud.
Definition: dense_components_pointers_3d.hpp:15
Generic CVB physical device.
Definition: decl_device.hpp:39
HandleOnly class is as it says a handle only.
Definition: handle_only.hpp:21
The Common Vision Blox image.
Definition: decl_image.hpp:45
PFNC buffer class implementing a pfnc buffer.
Definition: pfnc_buffer.hpp:17
Mapped image of two merged source images.
Definition: panoramic_mapped_image.hpp:20
Helper class that takes care of pixel format conversion.
Definition: pixel_format_converter.hpp:25
Lazy enumeration of planes.
Definition: decl_plane_enumerator.hpp:28
Plane information container.
Definition: decl_plane.hpp:28
Point components of a sparse point cloud.
Definition: sparse_components_pointers_3d.hpp:14
A wrapped image wraps another pixel buffer without owning it.
Definition: decl_wrapped_image.hpp:30
T move(T... args)
@ Size
Area of the blob in pixels.
Root namespace for the Image Manager interface.
Definition: c_barcode.h:24
RotationMap
Amount of rotation to apply when mapping an image.
Definition: global.hpp:357
PanoramaDirection
Defines the direction of the panoramic image.
Definition: global.hpp:473
SubPixelMode
Method for determining sub pixel accuracy when working with the FindLocalMaxima functions.
Definition: global.hpp:292
ConversionMode
Mode used by conversion to dense point cloud.
Definition: global.hpp:504
MappingOption
Mapping options when creating a (potentially) mapped image.
Definition: global.hpp:341
WaitStatus
Status after waiting for an image to be returned.
Definition: global.hpp:376
@ Abort
The acquisition has been stopped asynchronously, there is no image buffer.
PixelDataType
Defines the numeric data type of one pixel.
Definition: global.hpp:130
ColorModel
Color model that this image is using.
Definition: global.hpp:157
CoordinateSystemType
Enumeration of the different available coordinate systems that an Area of interest may be defined in.
Definition: global.hpp:270
ConnectionState
Current connection state of the Device.
Definition: global.hpp:482
@ NotSupported
Connection state handling is not supported by the Device.
Neighborhood
Neighborhood to use in sub pixel calculation of local maxima.
Definition: global.hpp:317
DeviceUpdateMode
Defines how to treat the optional device image, when the device itself is updated.
Definition: global.hpp:232
PlaneNormalization
Plane handling for normalization.
Definition: global.hpp:257
PlaneRole
A plane role describes the components of the plane. They can coarsely be separated in two sets.
Definition: global.hpp:391
@ PixYUV_Y
Same as PixMono, but to distinguish YUV model.
@ PixLAB_A
Green-red chrominance channel.
@ PixRGB_R
Red channel value.
@ PointVariation
Variation of points in cloud.
@ CoordCartesian_W
Cartesian W axis component (homogeneous coordinates).
@ CoordCartesian_Y
Cartesian Y axis component.
@ PointPlanarity
Planarity of points in cloud.
@ CoordCartesian_X
Cartesian X axis component.
@ CoordPolar_Phi
Polar azimuth angle component.
@ PixConfidence
Confidence(probability density / percentage) or consistency(Boolean) value.
@ Normal_Z
Normal in Z.
@ PixLAB_B
Blue-yellow chrominance channel.
@ PointSphericity
Sphericity of points in cloud.
@ PointCurvature
Curvature of points in cloud.
@ PixRGB_B
Blue channel value.
@ CoordCylindrical_Phi
Cylindrical azimuth angle component.
@ CoordCylindrical_Rho
Cylindrical radius component.
@ Normal_X
Normal in X.
@ CoordCartesian_Z
Cartesian Z axis component.
@ CoordSpherical_Phi
Spherical azimuth angle component.
@ PointLinearity
Linearity of points in cloud.
@ PixRGB_RGB
Red-green-blue channel value.
@ PixYUV_V
Red chrominance channel.
@ CoordPolar_Rho
Polar radius component.
@ PixHSV_V
Value(luminance) channel value.
@ PixYUV_U
Blue chrominance channel.
@ Normal_Y
Normal in Y.
@ PixLAB_L
Lightness channel value.
@ CoordCylindrical_Z
Cylindrical Z axis component.
@ PixRGB_G
Green channel value.
@ PixHSV_H
Hue channel value.
@ CoordSpherical_Theta
Spherical inclination/polar angle component.
@ PixMono
Monochromatic, linear luminance value.
@ CoordSpherical_Rho
Spherical radius component.
T ref(T... args)
Definition: global.hpp:980