1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277 |
- // This file is part of OpenCV project.
- // It is subject to the license terms in the LICENSE file found in the top-level directory
- // of this distribution and at http://opencv.org/license.html.
- // Copyright (C) 2016, Intel Corporation, all rights reserved.
- // Third party copyrights are property of their respective owners.
- /*
- C++ wrappers over OpenVX 1.x C API
- Details: TBD
- */
- #pragma once
- #ifndef IVX_HPP
- #define IVX_HPP
- #ifndef __cplusplus
- #error This file has to be compiled with C++ compiler
- #endif
- #include <VX/vx.h>
- #include <VX/vxu.h>
- #ifndef VX_VERSION_1_1
- // 1.1 to 1.0 backward compatibility defines
- static const vx_enum VX_INTERPOLATION_BILINEAR = VX_INTERPOLATION_TYPE_BILINEAR;
- static const vx_enum VX_INTERPOLATION_AREA = VX_INTERPOLATION_TYPE_AREA;
- static const vx_enum VX_INTERPOLATION_NEAREST_NEIGHBOR = VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR;
- static const vx_enum VX_BORDER_CONSTANT = VX_BORDER_MODE_CONSTANT;
- static const vx_enum VX_BORDER_REPLICATE = VX_BORDER_MODE_REPLICATE;
- #else
- #ifdef IVX_RENAMED_REFS
- static const vx_enum VX_REF_ATTRIBUTE_TYPE = VX_REFERENCE_TYPE;
- #endif
- #endif
- #ifndef IVX_USE_CXX98
- // checking compiler
- #if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_VER < 1800)
- #define IVX_USE_CXX98
- #endif
- #endif // IVX_USE_CXX98
- #if defined(IVX_USE_CXX98) && !defined(IVX_HIDE_INFO_WARNINGS)
- #ifdef _MSC_VER
- #pragma message ("ivx.hpp: The ISO C++ 2011 standard is not enabled, switching to C++98 fallback implementation.")
- #else
- #warning The ISO C++ 2011 standard is not enabled, switching to C++98 fallback implementation.
- #endif
- #endif // IVX_USE_CXX98
- #ifndef IVX_USE_EXTERNAL_REFCOUNT
- // checking OpenVX version
- #ifndef VX_VERSION_1_1
- #define IVX_USE_EXTERNAL_REFCOUNT
- #endif
- #endif // IVX_USE_CXX98
- #if defined(IVX_USE_EXTERNAL_REFCOUNT) && !defined(IVX_HIDE_INFO_WARNINGS)
- #ifdef _MSC_VER
- #pragma message ("ivx.hpp: OpenVX version < 1.1, switching to external refcounter implementation.")
- #else
- #warning OpenVX version < 1.1, switching to external refcounter implementation.
- #endif
- #endif // IVX_USE_EXTERNAL_REFCOUNT
- #include <stdexcept>
- #include <utility>
- #include <string>
- #include <vector>
- #include <cstdlib>
- #ifndef IVX_USE_CXX98
- #include <type_traits>
- namespace ivx
- {
- using std::is_same;
- using std::is_pointer;
- }
- #else
- namespace ivx
- {
- // helpers for compile-time type checking
- template<typename, typename> struct is_same { static const bool value = false; };
- template<typename T> struct is_same<T, T> { static const bool value = true; };
- template<typename T> struct is_pointer { static const bool value = false; };
- template<typename T> struct is_pointer<T*> { static const bool value = true; };
- template<typename T> struct is_pointer<const T*> { static const bool value = true; };
- }
- #endif
- #ifdef IVX_USE_OPENCV
- #include "opencv2/core.hpp"
- #endif
- // disabling false alarm warnings
- #if defined(_MSC_VER)
- #pragma warning(push)
- //#pragma warning( disable : 4??? )
- #elif defined(__clang__)
- #pragma clang diagnostic push
- #pragma clang diagnostic ignored "-Wunused-local-typedef"
- #pragma clang diagnostic ignored "-Wmissing-prototypes"
- #elif defined(__GNUC__)
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
- #pragma GCC diagnostic ignored "-Wunused-value"
- #pragma GCC diagnostic ignored "-Wmissing-declarations"
- #endif // compiler macro
- namespace ivx
- {
- inline vx_uint16 compiledWithVersion()
- { return VX_VERSION; }
- /// Exception class for OpenVX runtime errors
- class RuntimeError : public std::runtime_error
- {
- public:
- /// Constructor
- explicit RuntimeError(vx_status st, const std::string& msg = "")
- : runtime_error(msg), _status(st)
- {}
- /// OpenVX error code
- vx_status status() const
- { return _status; }
- private:
- vx_status _status;
- };
- /// Exception class for wrappers logic errors
- class WrapperError : public std::logic_error
- {
- public:
- /// Constructor
- explicit WrapperError(const std::string& msg) : logic_error(msg)
- {}
- };
- inline void checkVxStatus(vx_status status, const std::string& func, const std::string& msg)
- {
- if(status != VX_SUCCESS) throw RuntimeError( status, func + "() : " + msg );
- }
- /// Helper macro for turning a runtime error in the provided code into a \RuntimeError
- #define IVX_CHECK_STATUS(code) checkVxStatus(code, __func__, #code)
- /// OpenVX enum to type compile-time converter (TODO: add more types)
- template<vx_enum E> struct EnumToType {};
- template<> struct EnumToType<VX_TYPE_CHAR> { typedef vx_char type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_INT8> { typedef vx_int8 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_UINT8> { typedef vx_uint8 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_INT16> { typedef vx_int16 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_UINT16> { typedef vx_uint16 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_INT32> { typedef vx_int32 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_UINT32> { typedef vx_uint32 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_INT64> { typedef vx_int64 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_UINT64> { typedef vx_uint64 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_FLOAT32> { typedef vx_float32 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_FLOAT64> { typedef vx_float64 type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_ENUM> { typedef vx_enum type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_SIZE> { typedef vx_size type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_DF_IMAGE> { typedef vx_df_image type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_BOOL> { typedef vx_bool type; static const vx_size bytes = sizeof(type); };
- template<> struct EnumToType<VX_TYPE_KEYPOINT> { typedef vx_keypoint_t type;static const vx_size bytes = sizeof(type); };
- #ifndef IVX_USE_CXX98
- template <vx_enum E> using EnumToType_t = typename EnumToType<E>::type;
- #endif
- /// Gets size in bytes for the provided OpenVX type enum
- inline vx_size enumToTypeSize(vx_enum type)
- {
- switch (type)
- {
- case VX_TYPE_CHAR: return EnumToType<VX_TYPE_CHAR>::bytes;
- case VX_TYPE_INT8: return EnumToType<VX_TYPE_INT8>::bytes;
- case VX_TYPE_UINT8: return EnumToType<VX_TYPE_UINT8>::bytes;
- case VX_TYPE_INT16: return EnumToType<VX_TYPE_INT16>::bytes;
- case VX_TYPE_UINT16: return EnumToType<VX_TYPE_UINT16>::bytes;
- case VX_TYPE_INT32: return EnumToType<VX_TYPE_INT32>::bytes;
- case VX_TYPE_UINT32: return EnumToType<VX_TYPE_UINT32>::bytes;
- case VX_TYPE_INT64: return EnumToType<VX_TYPE_INT64>::bytes;
- case VX_TYPE_UINT64: return EnumToType<VX_TYPE_UINT64>::bytes;
- case VX_TYPE_FLOAT32: return EnumToType<VX_TYPE_FLOAT32>::bytes;
- case VX_TYPE_FLOAT64: return EnumToType<VX_TYPE_FLOAT64>::bytes;
- case VX_TYPE_ENUM: return EnumToType<VX_TYPE_ENUM>::bytes;
- case VX_TYPE_SIZE: return EnumToType<VX_TYPE_SIZE>::bytes;
- case VX_TYPE_DF_IMAGE: return EnumToType<VX_TYPE_DF_IMAGE>::bytes;
- case VX_TYPE_BOOL: return EnumToType<VX_TYPE_BOOL>::bytes;
- case VX_TYPE_KEYPOINT: return EnumToType<VX_TYPE_KEYPOINT>::bytes;
- default: throw WrapperError(std::string(__func__) + ": unsupported type enum");
- }
- }
- /// type to enum compile-time converter (TODO: add more types)
- template<typename T> struct TypeToEnum {};
- template<> struct TypeToEnum<vx_char> { static const vx_enum value = VX_TYPE_CHAR; };
- template<> struct TypeToEnum<vx_int8> { static const vx_enum value = VX_TYPE_INT8; };
- template<> struct TypeToEnum<vx_uint8> { static const vx_enum value = VX_TYPE_UINT8, imgType = VX_DF_IMAGE_U8; };
- template<> struct TypeToEnum<vx_int16> { static const vx_enum value = VX_TYPE_INT16, imgType = VX_DF_IMAGE_S16; };
- template<> struct TypeToEnum<vx_uint16> { static const vx_enum value = VX_TYPE_UINT16, imgType = VX_DF_IMAGE_U16; };
- template<> struct TypeToEnum<vx_int32> { static const vx_enum value = VX_TYPE_INT32, imgType = VX_DF_IMAGE_S32; };
- template<> struct TypeToEnum<vx_uint32> { static const vx_enum value = VX_TYPE_UINT32, imgType = VX_DF_IMAGE_U32; };
- template<> struct TypeToEnum<vx_int64> { static const vx_enum value = VX_TYPE_INT64; };
- template<> struct TypeToEnum<vx_uint64> { static const vx_enum value = VX_TYPE_UINT64; };
- template<> struct TypeToEnum<vx_float32> { static const vx_enum value = VX_TYPE_FLOAT32, imgType = VX_DF_IMAGE('F', '0', '3', '2'); };
- template<> struct TypeToEnum<vx_float64> { static const vx_enum value = VX_TYPE_FLOAT64; };
- template<> struct TypeToEnum<vx_bool> { static const vx_enum value = VX_TYPE_BOOL; };
- template<> struct TypeToEnum<vx_keypoint_t> {static const vx_enum value = VX_TYPE_KEYPOINT; };
- // the commented types are aliases (of integral tyes) and have conflicts with the types above
- //template<> struct TypeToEnum<vx_enum> { static const vx_enum val = VX_TYPE_ENUM; };
- //template<> struct TypeToEnum<vx_size> { static const vx_enum val = VX_TYPE_SIZE; };
- //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
- inline bool areTypesCompatible(const vx_enum a, const vx_enum b)
- {
- return enumToTypeSize(a) == enumToTypeSize(b);
- }
- #ifdef IVX_USE_OPENCV
- inline int enumToCVType(vx_enum type)
- {
- switch (type)
- {
- case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
- case VX_TYPE_INT8: return CV_8SC1;
- case VX_TYPE_UINT8: return CV_8UC1;
- case VX_TYPE_INT16: return CV_16SC1;
- case VX_TYPE_UINT16: return CV_16UC1;
- case VX_TYPE_INT32: return CV_32SC1;
- case VX_TYPE_UINT32: return CV_32SC1;//That's not the best option but there is CV_32S type only
- case VX_TYPE_FLOAT32: return CV_32FC1;
- case VX_TYPE_FLOAT64: return CV_64FC1;
- case VX_TYPE_ENUM: return CV_32SC1;
- case VX_TYPE_BOOL: return CV_32SC1;
- default: throw WrapperError(std::string(__func__) + ": unsupported type enum");
- }
- }
- #endif
- /// Helper type, provides info for OpenVX 'objects' (vx_reference extending) types
- template <typename T> struct RefTypeTraits {};
- class Context;
- template <> struct RefTypeTraits <vx_context>
- {
- typedef vx_context vxType;
- typedef Context wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_CONTEXT;
- static vx_status release(vxType& ref) { return vxReleaseContext(&ref); }
- };
- class Graph;
- template <> struct RefTypeTraits <vx_graph>
- {
- typedef vx_graph vxType;
- typedef Graph wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_GRAPH;
- static vx_status release(vxType& ref) { return vxReleaseGraph(&ref); }
- };
- class Node;
- template <> struct RefTypeTraits <vx_node>
- {
- typedef vx_node vxType;
- typedef Node wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_NODE;
- static vx_status release(vxType& ref) { return vxReleaseNode(&ref); }
- };
- class Kernel;
- template <> struct RefTypeTraits <vx_kernel>
- {
- typedef vx_kernel vxType;
- typedef Kernel wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_KERNEL;
- static vx_status release(vxType& ref) { return vxReleaseKernel(&ref); }
- };
- class Param;
- template <> struct RefTypeTraits <vx_parameter>
- {
- typedef vx_parameter vxType;
- typedef Param wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_PARAMETER;
- static vx_status release(vxType& ref) { return vxReleaseParameter(&ref); }
- };
- class Image;
- template <> struct RefTypeTraits <vx_image>
- {
- typedef vx_image vxType;
- typedef Image wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_IMAGE;
- static vx_status release(vxType& ref) { return vxReleaseImage(&ref); }
- };
- class Scalar;
- template <> struct RefTypeTraits <vx_scalar>
- {
- typedef vx_scalar vxType;
- typedef Scalar wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_SCALAR;
- static vx_status release(vxType& ref) { return vxReleaseScalar(&ref); }
- };
- class Array;
- template <> struct RefTypeTraits <vx_array>
- {
- typedef vx_array vxType;
- typedef Array wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_ARRAY;
- static vx_status release(vxType& ref) { return vxReleaseArray(&ref); }
- };
- class Threshold;
- template <> struct RefTypeTraits <vx_threshold>
- {
- typedef vx_threshold vxType;
- typedef Threshold wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_THRESHOLD;
- static vx_status release(vxType& ref) { return vxReleaseThreshold(&ref); }
- };
- class Convolution;
- template <> struct RefTypeTraits <vx_convolution>
- {
- typedef vx_convolution vxType;
- typedef Convolution wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_CONVOLUTION;
- static vx_status release(vxType& ref) { return vxReleaseConvolution(&ref); }
- };
- class Matrix;
- template <> struct RefTypeTraits <vx_matrix>
- {
- typedef vx_matrix vxType;
- typedef Matrix wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_MATRIX;
- static vx_status release(vxType& ref) { return vxReleaseMatrix(&ref); }
- };
- class LUT;
- template <> struct RefTypeTraits <vx_lut>
- {
- typedef vx_lut vxType;
- typedef LUT wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_LUT;
- static vx_status release(vxType& ref) { return vxReleaseLUT(&ref); }
- };
- class Pyramid;
- template <> struct RefTypeTraits <vx_pyramid>
- {
- typedef vx_pyramid vxType;
- typedef Pyramid wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_PYRAMID;
- static vx_status release(vxType& ref) { return vxReleasePyramid(&ref); }
- };
- class Distribution;
- template <> struct RefTypeTraits <vx_distribution>
- {
- typedef vx_distribution vxType;
- typedef Distribution wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_DISTRIBUTION;
- static vx_status release(vxType& ref) { return vxReleaseDistribution(&ref); }
- };
- class Remap;
- template <> struct RefTypeTraits <vx_remap>
- {
- typedef vx_remap vxType;
- typedef Remap wrapperType;
- static const vx_enum vxTypeEnum = VX_TYPE_REMAP;
- static vx_status release(vxType& ref) { return vxReleaseRemap(&ref); }
- };
- #ifdef IVX_USE_CXX98
- /// Casting to vx_reference with compile-time check
- // takes 'vx_reference' itself and RefWrapper<T> via 'operator vx_reference()'
- inline vx_reference castToReference(vx_reference ref)
- { return ref; }
- // takes vx_reference extensions that have RefTypeTraits<T> specializations
- template<typename T>
- inline vx_reference castToReference(const T& ref, typename RefTypeTraits<T>::vxType dummy = 0)
- { (void)dummy; return (vx_reference)ref; }
- #else
- template<typename T, typename = void>
- struct is_ref : std::is_same<T, vx_reference>{}; // allow vx_reference
- // allow RefWrapper<> types
- template<typename T>
- #ifndef _MSC_VER
- struct is_ref<T, decltype(T().operator vx_reference(), void())> : std::true_type {};
- #else
- // workarounding VC14 compiler crash
- struct is_ref<T, decltype(T::vxType(), void())> : std::true_type {};
- #endif
- // allow vx_reference extensions
- template<typename T>
- struct is_ref<T, decltype(RefTypeTraits<T>::vxTypeEnum, void())> : std::true_type {};
- /// Casting to vx_reference with compile-time check
- template<typename T>
- inline vx_reference castToReference(const T& obj)
- {
- static_assert(is_ref<T>::value, "unsupported conversion");
- return (vx_reference) obj;
- }
- #endif // IVX_USE_CXX98
- inline void checkVxRef(vx_reference ref, const std::string& func, const std::string& msg)
- {
- vx_status status = vxGetStatus(ref);
- if(status != VX_SUCCESS) throw RuntimeError( status, func + "() : " + msg );
- }
- /// Helper macro for checking the provided OpenVX 'object' and throwing a \RuntimeError in case of error
- #define IVX_CHECK_REF(code) checkVxRef(castToReference(code), __func__, #code)
- #ifdef IVX_USE_EXTERNAL_REFCOUNT
- /// Base class for OpenVX 'objects' wrappers
- template <typename T> class RefWrapper
- {
- public:
- typedef T vxType;
- static const vx_enum vxTypeEnum = RefTypeTraits <T>::vxTypeEnum;
- /// Default constructor
- RefWrapper() : ref(0), refcount(0)
- {}
- /// Constructor
- /// \param r OpenVX 'object' (e.g. vx_image)
- /// \param retainRef flag indicating whether to increase ref counter in constructor (false by default)
- explicit RefWrapper(T r, bool retainRef = false) : ref(0), refcount(0)
- { reset(r, retainRef); }
- /// Copy constructor
- RefWrapper(const RefWrapper& r) : ref(r.ref), refcount(r.refcount)
- { addRef(); }
- #ifndef IVX_USE_CXX98
- /// Move constructor
- RefWrapper(RefWrapper&& rw) noexcept : RefWrapper()
- {
- using std::swap;
- swap(ref, rw.ref);
- swap(refcount, rw.refcount);
- }
- #endif
- /// Casting to the wrapped OpenVX 'object'
- operator T() const
- { return ref; }
- /// Casting to vx_reference since every OpenVX 'object' extends it
- operator vx_reference() const
- { return castToReference(ref); }
- /// Assigning a new value (decreasing ref counter for the old one)
- /// \param r OpenVX 'object' (e.g. vx_image)
- /// \param retainRef flag indicating whether to increase ref counter in constructor (false by default)
- void reset(T r, bool retainRef = false)
- {
- release();
- ref = r;
- #ifdef VX_VERSION_1_1
- if(retainRef) addRef();
- #else
- // if 'retainRef' -just don't use ref-counting for v 1.0
- if(!retainRef) refcount = new int(1);
- #endif
- checkRef();
- }
- /// Assigning an empty value (decreasing ref counter for the old one)
- void reset()
- { release(); }
- /// Dropping kept value without releas decreasing ref counter
- /// \return the value being dropped
- T detach()
- {
- T tmp = ref;
- ref = 0;
- release();
- return tmp;
- }
- /// Unified assignment operator (covers both copy and move cases)
- RefWrapper& operator=(RefWrapper r)
- {
- using std::swap;
- swap(ref, r.ref);
- swap(refcount, r.refcount);
- return *this;
- }
- /// Checking for non-empty
- bool operator !() const
- { return ref == 0; }
- #ifndef IVX_USE_CXX98
- /// Explicit boolean evaluation (called automatically inside conditional operators only)
- explicit operator bool() const
- { return ref != 0; }
- #endif
- /// Getting a context that is kept in each OpenVX 'object' (call get<Context>())
- template<typename C>
- C get() const
- {
- typedef int static_assert_context[is_same<C, Context>::value ? 1 : -1];
- vx_context c = vxGetContext(castToReference(ref));
- // vxGetContext doesn't increment ref count, let do it in wrapper c-tor
- return C(c, true);
- }
- #ifndef IVX_USE_CXX98
- /// Getting a context that is kept in each OpenVX 'object'
- template<typename C = Context, typename = typename std::enable_if<std::is_same<C, Context>::value>::type>
- C getContext() const
- {
- vx_context c = vxGetContext(castToReference(ref));
- // vxGetContext doesn't increment ref count, let do it in wrapper c-tor
- return C(c, true);
- }
- #endif // IVX_USE_CXX98
- protected:
- T ref;
- int* refcount;
- void addRef()
- {
- #ifdef VX_VERSION_1_1
- if(ref) IVX_CHECK_STATUS(vxRetainReference(castToReference(ref)));
- #else //TODO: make thread-safe
- if(refcount) ++(*refcount);
- #endif
- }
- void release()
- {
- #ifdef VX_VERSION_1_1
- if(ref) RefTypeTraits<T>::release(ref);
- #else //TODO: make thread-safe
- if(refcount && --(*refcount) == 0)
- {
- if(ref) RefTypeTraits<T>::release(ref);
- ref = 0;
- delete refcount;
- refcount = 0;
- }
- #endif
- }
- void checkRef() const
- {
- IVX_CHECK_REF(ref);
- vx_enum type;
- IVX_CHECK_STATUS(vxQueryReference((vx_reference)ref, VX_REF_ATTRIBUTE_TYPE, &type, sizeof(type)));
- if (type != vxTypeEnum) throw WrapperError("incompatible reference type");
- }
- ~RefWrapper()
- { release(); }
- };
- #ifdef IVX_USE_CXX98
- #define IVX_REF_STD_CTORS_AND_ASSIGNMENT(Class) \
- Class() : RefWrapper() {} \
- explicit Class(Class::vxType _ref, bool retainRef = false) : RefWrapper(_ref, retainRef) {} \
- Class(const Class& _obj) : RefWrapper(_obj) {} \
- \
- Class& operator=(Class _obj) { using std::swap; swap(ref, _obj.ref); swap(refcount, _obj.refcount); return *this; }
- #else
- #define IVX_REF_STD_CTORS_AND_ASSIGNMENT(Class) \
- Class() : RefWrapper() {} \
- explicit Class(Class::vxType _ref, bool retainRef = false) : RefWrapper(_ref, retainRef) {} \
- Class(const Class& _obj) : RefWrapper(_obj) {} \
- Class(Class&& _obj) : RefWrapper(std::move(_obj)) {} \
- \
- Class& operator=(Class _obj) { using std::swap; swap(ref, _obj.ref); swap(refcount, _obj.refcount); return *this; }
- #endif // IVX_USE_CXX98
- #else // not IVX_USE_EXTERNAL_REFCOUNT
- /// Base class for OpenVX 'objects' wrappers
- template <typename T> class RefWrapper
- {
- public:
- typedef T vxType;
- static const vx_enum vxTypeEnum = RefTypeTraits <T>::vxTypeEnum;
- /// Default constructor
- RefWrapper() : ref(0)
- {}
- /// Constructor
- /// \param r OpenVX 'object' (e.g. vx_image)
- /// \param retainRef flag indicating whether to increase ref counter in constructor (false by default)
- explicit RefWrapper(T r, bool retainRef = false) : ref(0)
- { reset(r, retainRef); }
- /// Copy constructor
- RefWrapper(const RefWrapper& r) : ref(r.ref)
- { addRef(); }
- #ifndef IVX_USE_CXX98
- /// Move constructor
- RefWrapper(RefWrapper&& rw) noexcept : RefWrapper()
- {
- using std::swap;
- swap(ref, rw.ref);
- }
- #endif
- /// Casting to the wrapped OpenVX 'object'
- operator T() const
- { return ref; }
- /// Casting to vx_reference since every OpenVX 'object' extends it
- operator vx_reference() const
- { return castToReference(ref); }
- /// Getting a context that is kept in each OpenVX 'object' (call get<Context>())
- template<typename C>
- C get() const
- {
- typedef int static_assert_context[is_same<C, Context>::value ? 1 : -1];
- vx_context c = vxGetContext(castToReference(ref));
- // vxGetContext doesn't increment ref count, let do it in wrapper c-tor
- return C(c, true);
- }
- #ifndef IVX_USE_CXX98
- /// Getting a context that is kept in each OpenVX 'object'
- template<typename C = Context, typename = typename std::enable_if<std::is_same<C, Context>::value>::type>
- C getContext() const
- {
- vx_context c = vxGetContext(castToReference(ref));
- // vxGetContext doesn't increment ref count, let do it in wrapper c-tor
- return C(c, true);
- }
- #endif // IVX_USE_CXX98
- /// Assigning a new value (decreasing ref counter for the old one)
- /// \param r OpenVX 'object' (e.g. vx_image)
- /// \param retainRef flag indicating whether to increase ref counter in constructor (false by default)
- void reset(T r, bool retainRef = false)
- {
- release();
- ref = r;
- if (retainRef) addRef();
- checkRef();
- }
- /// Assigning an empty value (decreasing ref counter for the old one)
- void reset()
- { release(); }
- /// Dropping kept value without releas decreasing ref counter
- /// \return the value being dropped
- T detach()
- {
- T tmp = ref;
- ref = 0;
- return tmp;
- }
- /// Unified assignment operator (covers both copy and move cases)
- RefWrapper& operator=(RefWrapper r)
- {
- using std::swap;
- swap(ref, r.ref);
- return *this;
- }
- /// Checking for non-empty
- bool operator !() const
- { return ref == 0; }
- #ifndef IVX_USE_CXX98
- /// Explicit boolean evaluation (called automatically inside conditional operators only)
- explicit operator bool() const
- { return ref != 0; }
- #endif
- protected:
- T ref;
- void addRef()
- { if (ref) IVX_CHECK_STATUS(vxRetainReference((vx_reference)ref)); }
- void release()
- {
- if (ref) RefTypeTraits<T>::release(ref);
- ref = 0;
- }
- void checkRef() const
- {
- IVX_CHECK_REF(ref);
- vx_enum type;
- IVX_CHECK_STATUS(vxQueryReference((vx_reference)ref, VX_REF_ATTRIBUTE_TYPE, &type, sizeof(type)));
- if (type != vxTypeEnum) throw WrapperError("incompatible reference type");
- }
- ~RefWrapper()
- { release(); }
- };
- #ifdef IVX_USE_CXX98
- #define IVX_REF_STD_CTORS_AND_ASSIGNMENT(Class) \
- Class() : RefWrapper() {} \
- explicit Class(Class::vxType _ref, bool retainRef = false) : RefWrapper(_ref, retainRef) {} \
- Class(const Class& _obj) : RefWrapper(_obj) {} \
- \
- Class& operator=(Class _obj) { using std::swap; swap(ref, _obj.ref); return *this; }
- #else
- #define IVX_REF_STD_CTORS_AND_ASSIGNMENT(Class) \
- Class() : RefWrapper() {} \
- explicit Class(Class::vxType _ref, bool retainRef = false) : RefWrapper(_ref, retainRef) {} \
- Class(const Class& _obj) : RefWrapper(_obj) {} \
- Class(Class&& _obj) : RefWrapper(std::move(_obj)) {} \
- \
- Class& operator=(Class _obj) { using std::swap; swap(ref, _obj.ref); return *this; }
- #endif // IVX_USE_CXX98
- #endif // IVX_USE_EXTERNAL_REFCOUNT
- #ifndef VX_VERSION_1_1
- typedef vx_border_mode_t border_t;
- #else
- typedef vx_border_t border_t;
- #endif
- /// vx_context wrapper
- class Context : public RefWrapper<vx_context>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Context)
- /// vxCreateContext() wrapper
- static Context create()
- { return Context(vxCreateContext()); }
- /// vxGetContext() wrapper
- template <typename T>
- static Context getFrom(const T& ref)
- {
- vx_context c = vxGetContext(castToReference(ref));
- // vxGetContext doesn't increment ref count, let do it in wrapper c-tor
- return Context(c, true);
- }
- /// vxLoadKernels() wrapper
- void loadKernels(const std::string& module)
- { IVX_CHECK_STATUS( vxLoadKernels(ref, module.c_str()) ); }
- /// vxQueryContext() wrapper
- template<typename T>
- void query(vx_enum att, T& value) const
- { IVX_CHECK_STATUS(vxQueryContext(ref, att, &value, sizeof(value))); }
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_CONTEXT_VENDOR_ID = VX_CONTEXT_ATTRIBUTE_VENDOR_ID,
- VX_CONTEXT_VERSION = VX_CONTEXT_ATTRIBUTE_VERSION,
- VX_CONTEXT_UNIQUE_KERNELS = VX_CONTEXT_ATTRIBUTE_UNIQUE_KERNELS,
- VX_CONTEXT_MODULES = VX_CONTEXT_ATTRIBUTE_MODULES,
- VX_CONTEXT_REFERENCES = VX_CONTEXT_ATTRIBUTE_REFERENCES,
- VX_CONTEXT_IMPLEMENTATION = VX_CONTEXT_ATTRIBUTE_IMPLEMENTATION,
- VX_CONTEXT_EXTENSIONS_SIZE = VX_CONTEXT_ATTRIBUTE_EXTENSIONS_SIZE,
- VX_CONTEXT_EXTENSIONS = VX_CONTEXT_ATTRIBUTE_EXTENSIONS,
- VX_CONTEXT_CONVOLUTION_MAX_DIMENSION = VX_CONTEXT_ATTRIBUTE_CONVOLUTION_MAXIMUM_DIMENSION,
- VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION = VX_CONTEXT_ATTRIBUTE_OPTICAL_FLOW_WINDOW_MAXIMUM_DIMENSION,
- VX_CONTEXT_IMMEDIATE_BORDER = VX_CONTEXT_ATTRIBUTE_IMMEDIATE_BORDER_MODE,
- VX_CONTEXT_UNIQUE_KERNEL_TABLE = VX_CONTEXT_ATTRIBUTE_UNIQUE_KERNEL_TABLE;
- #endif
- /// vxQueryContext(VX_CONTEXT_VENDOR_ID) wrapper
- vx_uint16 vendorID() const
- {
- vx_uint16 v;
- query(VX_CONTEXT_VENDOR_ID, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_VERSION) wrapper
- vx_uint16 version() const
- {
- vx_uint16 v;
- query(VX_CONTEXT_VERSION, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_UNIQUE_KERNELS) wrapper
- vx_uint32 uniqueKernelsNum() const
- {
- vx_uint32 v;
- query(VX_CONTEXT_UNIQUE_KERNELS, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_MODULES) wrapper
- vx_uint32 modulesNum() const
- {
- vx_uint32 v;
- query(VX_CONTEXT_MODULES, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_REFERENCES) wrapper
- vx_uint32 refsNum() const
- {
- vx_uint32 v;
- query(VX_CONTEXT_REFERENCES, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_EXTENSIONS_SIZE) wrapper
- vx_size extensionsSize() const
- {
- vx_size v;
- query(VX_CONTEXT_EXTENSIONS_SIZE, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_CONVOLUTION_MAX_DIMENSION) wrapper
- vx_size convolutionMaxDimension() const
- {
- vx_size v;
- query(VX_CONTEXT_CONVOLUTION_MAX_DIMENSION, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION) wrapper
- vx_size opticalFlowMaxWindowSize() const
- {
- vx_size v;
- query(VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_IMMEDIATE_BORDER) wrapper
- border_t immediateBorder() const
- {
- border_t v;
- query(VX_CONTEXT_IMMEDIATE_BORDER, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_IMPLEMENTATION) wrapper
- std::string implName() const
- {
- std::vector<vx_char> v(VX_MAX_IMPLEMENTATION_NAME);
- IVX_CHECK_STATUS(vxQueryContext(ref, VX_CONTEXT_IMPLEMENTATION, &v[0], v.size() * sizeof(vx_char)));
- return std::string(v.data());
- }
- /// vxQueryContext(VX_CONTEXT_EXTENSIONS) wrapper
- std::string extensionsStr() const
- {
- std::vector<vx_char> v(extensionsSize());
- IVX_CHECK_STATUS(vxQueryContext(ref, VX_CONTEXT_EXTENSIONS, &v[0], v.size() * sizeof(vx_char)));
- return std::string(v.data());
- }
- /// vxQueryContext(VX_CONTEXT_UNIQUE_KERNEL_TABLE) wrapper
- std::vector<vx_kernel_info_t> kernelTable() const
- {
- std::vector<vx_kernel_info_t> v(uniqueKernelsNum());
- IVX_CHECK_STATUS(vxQueryContext(ref, VX_CONTEXT_UNIQUE_KERNEL_TABLE, &v[0], v.size() * sizeof(vx_kernel_info_t)));
- return v;
- }
- #ifdef VX_VERSION_1_1
- /// vxQueryContext(VX_CONTEXT_IMMEDIATE_BORDER_POLICY) wrapper
- vx_enum immediateBorderPolicy() const
- {
- vx_enum v;
- query(VX_CONTEXT_IMMEDIATE_BORDER_POLICY, v);
- return v;
- }
- /// vxQueryContext(VX_CONTEXT_NONLINEAR_MAX_DIMENSION) wrapper
- vx_size nonlinearMaxDimension() const
- {
- vx_size v;
- query(VX_CONTEXT_NONLINEAR_MAX_DIMENSION, v);
- return v;
- }
- #endif
- /// vxSetContextAttribute() wrapper
- template<typename T>
- void setAttribute(vx_enum att, const T& value)
- { IVX_CHECK_STATUS( vxSetContextAttribute(ref, att, &value, sizeof(value)) ); }
- /// vxSetContextAttribute(BORDER) wrapper
- void setImmediateBorder(const border_t& bm)
- { setAttribute(VX_CONTEXT_IMMEDIATE_BORDER, bm); }
- #ifndef VX_VERSION_1_1
- /// vxSetContextAttribute(BORDER) wrapper
- void setImmediateBorder(vx_enum mode, vx_uint32 val = 0)
- { border_t bm = {mode, val}; setImmediateBorder(bm); }
- #else
- /// vxSetContextAttribute(BORDER) wrapper
- void setImmediateBorder(vx_enum mode, const vx_pixel_value_t& val)
- { border_t bm = {mode, val}; setImmediateBorder(bm); }
- /// vxSetContextAttribute(BORDER) wrapper
- template <typename T>
- void setImmediateBorder(vx_enum mode, const T& _val)
- {
- vx_pixel_value_t val;
- switch (TypeToEnum<T>::value)
- {
- case VX_TYPE_UINT8:
- val.U8 = _val;
- break;
- case VX_TYPE_INT16:
- val.S16 = _val;
- break;
- case VX_TYPE_UINT16:
- val.U16 = _val;
- break;
- case VX_TYPE_INT32:
- val.S32 = _val;
- break;
- case VX_TYPE_UINT32:
- val.U32 = _val;
- break;
- default:
- throw WrapperError("Unsupported constant border value type");
- }
- setImmediateBorder(mode, val);
- }
- /// vxSetContextAttribute(BORDER) wrapper
- void setImmediateBorder(vx_enum mode)
- { vx_pixel_value_t val = {}; setImmediateBorder(mode, val); }
- #endif
- };
- /// vx_graph wrapper
- class Graph : public RefWrapper<vx_graph>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Graph);
- /// vxCreateGraph() wrapper
- static Graph create(vx_context c)
- { return Graph(vxCreateGraph(c)); }
- /// vxVerifyGraph() wrapper
- void verify()
- { IVX_CHECK_STATUS( vxVerifyGraph(ref) ); }
- /// vxProcessGraph() wrapper
- void process()
- { IVX_CHECK_STATUS( vxProcessGraph(ref) ); }
- /// vxScheduleGraph() wrapper
- void schedule()
- { IVX_CHECK_STATUS(vxScheduleGraph(ref) ); }
- /// vxWaitGraph() wrapper
- void wait()
- { IVX_CHECK_STATUS(vxWaitGraph(ref)); }
- };
- /// vx_kernel wrapper
- class Kernel : public RefWrapper<vx_kernel>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Kernel);
- /// vxGetKernelByEnum() wrapper
- static Kernel getByEnum(vx_context c, vx_enum kernelID)
- { return Kernel(vxGetKernelByEnum(c, kernelID)); }
- /// vxGetKernelByName() wrapper
- static Kernel getByName(vx_context c, const std::string& name)
- { return Kernel(vxGetKernelByName(c, name.c_str())); }
- };
- /// vx_node wrapper
- class Node : public RefWrapper<vx_node>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Node);
- /// vxCreateGenericNode() wrapper
- static Node create(vx_graph g, vx_kernel k)
- { return Node(vxCreateGenericNode(g, k)); }
- /// Create node for the kernel and set the parameters
- static Node create(vx_graph graph, vx_kernel kernel, const std::vector<vx_reference>& params)
- {
- Node node = Node::create(graph, kernel);
- vx_uint32 i = 0;
- for (std::vector<vx_reference>::const_iterator p = params.begin(); p != params.end(); ++p)
- node.setParameterByIndex(i++, *p);
- return node;
- }
- /// Create node for the kernel ID and set the parameters
- static Node create(vx_graph graph, vx_enum kernelID, const std::vector<vx_reference>& params)
- { return Node::create(graph, Kernel::getByEnum(Context::getFrom(graph), kernelID), params); }
- #ifdef IVX_USE_CXX98
- /// Create node for the kernel ID and set one parameter
- template<typename T0>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- /// Create node for the kernel ID and set two parameters
- template<typename T0, typename T1>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0, const T1& arg1)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- params.push_back(castToReference(arg1));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- /// Create node for the kernel ID and set three parameters
- template<typename T0, typename T1, typename T2>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0, const T1& arg1, const T2& arg2)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- params.push_back(castToReference(arg1));
- params.push_back(castToReference(arg2));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- /// Create node for the kernel ID and set four parameters
- template<typename T0, typename T1, typename T2, typename T3>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0, const T1& arg1, const T2& arg2,
- const T3& arg3)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- params.push_back(castToReference(arg1));
- params.push_back(castToReference(arg2));
- params.push_back(castToReference(arg3));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- /// Create node for the kernel ID and set five parameters
- template<typename T0, typename T1, typename T2, typename T3, typename T4>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0, const T1& arg1, const T2& arg2,
- const T3& arg3, const T4& arg4)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- params.push_back(castToReference(arg1));
- params.push_back(castToReference(arg2));
- params.push_back(castToReference(arg3));
- params.push_back(castToReference(arg4));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- /// Create node for the kernel ID and set six parameters
- template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0, const T1& arg1, const T2& arg2,
- const T3& arg3, const T4& arg4, const T5& arg5)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- params.push_back(castToReference(arg1));
- params.push_back(castToReference(arg2));
- params.push_back(castToReference(arg3));
- params.push_back(castToReference(arg4));
- params.push_back(castToReference(arg5));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- /// Create node for the kernel ID and set seven parameters
- template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
- typename T6>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0, const T1& arg1, const T2& arg2,
- const T3& arg3, const T4& arg4, const T5& arg5,
- const T6& arg6)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- params.push_back(castToReference(arg1));
- params.push_back(castToReference(arg2));
- params.push_back(castToReference(arg3));
- params.push_back(castToReference(arg4));
- params.push_back(castToReference(arg5));
- params.push_back(castToReference(arg6));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- /// Create node for the kernel ID and set eight parameters
- template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
- typename T6, typename T7>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0, const T1& arg1, const T2& arg2,
- const T3& arg3, const T4& arg4, const T5& arg5,
- const T6& arg6, const T7& arg7)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- params.push_back(castToReference(arg1));
- params.push_back(castToReference(arg2));
- params.push_back(castToReference(arg3));
- params.push_back(castToReference(arg4));
- params.push_back(castToReference(arg5));
- params.push_back(castToReference(arg6));
- params.push_back(castToReference(arg7));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- /// Create node for the kernel ID and set nine parameters
- template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
- typename T6, typename T7, typename T8>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0, const T1& arg1, const T2& arg2,
- const T3& arg3, const T4& arg4, const T5& arg5,
- const T6& arg6, const T7& arg7, const T8& arg8)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- params.push_back(castToReference(arg1));
- params.push_back(castToReference(arg2));
- params.push_back(castToReference(arg3));
- params.push_back(castToReference(arg4));
- params.push_back(castToReference(arg5));
- params.push_back(castToReference(arg6));
- params.push_back(castToReference(arg7));
- params.push_back(castToReference(arg8));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- /// Create node for the kernel ID and set ten parameters
- template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
- typename T6, typename T7, typename T8, typename T9>
- static Node create(vx_graph g, vx_enum kernelID,
- const T0& arg0, const T1& arg1, const T2& arg2,
- const T3& arg3, const T4& arg4, const T5& arg5,
- const T6& arg6, const T7& arg7, const T8& arg8,
- const T9& arg9)
- {
- std::vector<vx_reference> params;
- params.push_back(castToReference(arg0));
- params.push_back(castToReference(arg1));
- params.push_back(castToReference(arg2));
- params.push_back(castToReference(arg3));
- params.push_back(castToReference(arg4));
- params.push_back(castToReference(arg5));
- params.push_back(castToReference(arg6));
- params.push_back(castToReference(arg7));
- params.push_back(castToReference(arg8));
- params.push_back(castToReference(arg9));
- return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params);
- }
- #else // not IVX_USE_CXX98
- /// Create node for the kernel ID and set the specified parameters
- template<typename...Ts>
- static Node create(vx_graph g, vx_enum kernelID, const Ts&...args)
- { return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), { castToReference(args)... }); }
- #endif // IVX_USE_CXX98
- /// vxSetParameterByIndex() wrapper
- void setParameterByIndex(vx_uint32 index, vx_reference value)
- { IVX_CHECK_STATUS(vxSetParameterByIndex(ref, index, value)); }
- /// vxQueryNode() wrapper
- template<typename T>
- void query(vx_enum att, T& value) const
- { IVX_CHECK_STATUS( vxQueryNode(ref, att, &value, sizeof(value)) ); }
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_NODE_STATUS = VX_NODE_ATTRIBUTE_STATUS,
- VX_NODE_PERFORMANCE = VX_NODE_ATTRIBUTE_PERFORMANCE,
- VX_NODE_BORDER = VX_NODE_ATTRIBUTE_BORDER_MODE,
- VX_NODE_LOCAL_DATA_SIZE = VX_NODE_ATTRIBUTE_LOCAL_DATA_SIZE,
- VX_NODE_LOCAL_DATA_PTR = VX_NODE_ATTRIBUTE_LOCAL_DATA_PTR,
- VX_BORDER_UNDEFINED = VX_BORDER_MODE_UNDEFINED;
- #endif
- /// vxQueryNode(STATUS) wrapper
- vx_status status() const
- {
- vx_status v;
- query(VX_NODE_STATUS, v);
- return v;
- }
- /// vxQueryNode(PERFORMANCE) wrapper
- vx_perf_t performance() const
- {
- vx_perf_t v;
- query(VX_NODE_PERFORMANCE, v);
- return v;
- }
- /// vxQueryNode(BORDER) wrapper
- border_t border() const
- {
- border_t v;
- v.mode = VX_BORDER_UNDEFINED;
- query(VX_NODE_BORDER, v);
- return v;
- }
- /// vxQueryNode(LOCAL_DATA_SIZE) wrapper
- vx_size dataSize() const
- {
- vx_size v;
- query(VX_NODE_LOCAL_DATA_SIZE, v);
- return v;
- }
- /// vxQueryNode(LOCAL_DATA_PTR) wrapper
- void* dataPtr() const
- {
- void* v;
- query(VX_NODE_LOCAL_DATA_PTR, v);
- return v;
- }
- #ifdef VX_VERSION_1_1
- /// vxQueryNode(PARAMETERS) wrapper
- vx_uint32 paramsNum() const
- {
- vx_uint32 v;
- query(VX_NODE_PARAMETERS, v);
- return v;
- }
- /// vxQueryNode(REPLICATED) wrapper
- vx_bool isReplicated() const
- {
- vx_bool v;
- query(VX_NODE_IS_REPLICATED, v);
- return v;
- }
- /// vxQueryNode(REPLICATE_FLAGS) wrapper
- void replicateFlags(std::vector<vx_bool>& flags) const
- {
- if(flags.empty()) flags.resize(paramsNum(), vx_false_e);
- IVX_CHECK_STATUS( vxQueryNode(ref, VX_NODE_REPLICATE_FLAGS, &flags[0], flags.size()*sizeof(flags[0])) );
- }
- /// vxQueryNode(VX_NODE_VALID_RECT_RESET) wrapper
- vx_bool resetValidRect() const
- {
- vx_bool v;
- query(VX_NODE_VALID_RECT_RESET, v);
- return v;
- }
- #endif // VX_VERSION_1_1
- /// vxSetNodeAttribute() wrapper
- template<typename T>
- void setAttribute(vx_enum att, const T& value)
- { IVX_CHECK_STATUS( vxSetNodeAttribute(ref, att, &value, sizeof(value)) ); }
- /// vxSetNodeAttribute(BORDER) wrapper
- void setBorder(const border_t& bm)
- { setAttribute(VX_NODE_BORDER, bm); }
- #ifndef VX_VERSION_1_1
- /// vxSetNodeAttribute(BORDER) wrapper
- void setBorder(vx_enum mode, vx_uint32 val = 0)
- { vx_border_mode_t bm = {mode, val}; setBorder(bm); }
- #else
- /// vxSetNodeAttribute(BORDER) wrapper
- void setBorder(vx_enum mode, const vx_pixel_value_t& val)
- { vx_border_t bm = {mode, val}; setBorder(bm); }
- /// vxSetNodeAttribute(BORDER) wrapper
- template <typename T>
- void setBorder(vx_enum mode, const T& _val)
- {
- vx_pixel_value_t val;
- switch (TypeToEnum<T>::value)
- {
- case VX_TYPE_UINT8:
- val.U8 = _val;
- break;
- case VX_TYPE_INT16:
- val.S16 = _val;
- break;
- case VX_TYPE_UINT16:
- val.U16 = _val;
- break;
- case VX_TYPE_INT32:
- val.S32 = _val;
- break;
- case VX_TYPE_UINT32:
- val.U32 = _val;
- break;
- default:
- throw WrapperError("Unsupported constant border value type");
- }
- setBorder(mode, val);
- }
- /// vxSetNodeAttribute(BORDER) wrapper
- void setBorder(vx_enum mode)
- { vx_pixel_value_t val = {}; setBorder(mode, val); }
- #endif
- /// vxSetNodeAttribute(LOCAL_DATA_SIZE) wrapper
- void setDataSize(vx_size size)
- { setAttribute(VX_NODE_LOCAL_DATA_SIZE, size); }
- /// vxSetNodeAttribute(LOCAL_DATA_PTR) wrapper
- void setDataPtr(void* ptr)
- { setAttribute(VX_NODE_LOCAL_DATA_PTR, ptr); }
- };
- /// vx_image wrapper
- class Image : public RefWrapper<vx_image>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Image);
- /// vxCreateImage() wrapper
- static Image create(vx_context context, vx_uint32 width, vx_uint32 height, vx_df_image format)
- { return Image(vxCreateImage(context, width, height, format)); }
- /// vxCreateVirtualImage() wrapper
- static Image createVirtual(vx_graph graph, vx_uint32 width = 0, vx_uint32 height = 0, vx_df_image format = VX_DF_IMAGE_VIRT)
- { return Image(vxCreateVirtualImage(graph, width, height, format)); }
- #ifdef VX_VERSION_1_1
- /// vxCreateUniformImage() wrapper
- static Image createUniform(vx_context context, vx_uint32 width, vx_uint32 height, vx_df_image format, const vx_pixel_value_t& value)
- { return Image(vxCreateUniformImage(context, width, height, format, &value)); }
- #else
- /// vxCreateUniformImage() wrapper
- static Image createUniform(vx_context context, vx_uint32 width, vx_uint32 height, vx_df_image format, const void* value)
- { return Image(vxCreateUniformImage(context, width, height, format, value)); }
- #endif
- template <typename T>
- static Image createUniform(vx_context context, vx_uint32 width, vx_uint32 height, vx_df_image format, const T value)
- {
- #if VX_VERSION > VX_VERSION_1_0
- vx_pixel_value_t pixel;
- switch (format)
- {
- case VX_DF_IMAGE_U8:pixel.U8 = (vx_uint8)value; break;
- case VX_DF_IMAGE_S16:pixel.S16 = (vx_int16)value; break;
- case VX_DF_IMAGE_U16:pixel.U16 = (vx_uint16)value; break;
- case VX_DF_IMAGE_S32:pixel.S32 = (vx_int32)value; break;
- case VX_DF_IMAGE_U32:pixel.U32 = (vx_uint32)value; break;
- default:throw ivx::WrapperError("uniform image type unsupported by this call");
- }
- return Image(vxCreateUniformImage(context, width, height, format, &pixel));
- #else
- return Image(vxCreateUniformImage(context, width, height, format, &value));
- #endif
- }
- /// Planes number for the specified image format (fourcc)
- /// \return 0 for unknown formats
- static vx_size planes(vx_df_image format)
- {
- switch (format)
- {
- case VX_DF_IMAGE_IYUV:
- case VX_DF_IMAGE_YUV4: return 3;
- case VX_DF_IMAGE_NV12:
- case VX_DF_IMAGE_NV21: return 2;
- case VX_DF_IMAGE_RGB:
- case VX_DF_IMAGE_RGBX:
- case VX_DF_IMAGE_UYVY:
- case VX_DF_IMAGE_YUYV:
- case VX_DF_IMAGE_U8:
- case VX_DF_IMAGE_U16:
- case VX_DF_IMAGE_S16:
- case VX_DF_IMAGE_U32:
- case VX_DF_IMAGE_S32:
- case /*VX_DF_IMAGE_F32*/VX_DF_IMAGE('F', '0', '3', '2'):
- return 1;
- default: return 0;
- }
- }
- /// Create vx_imagepatch_addressing_t structure with default values
- static vx_imagepatch_addressing_t createAddressing()
- { vx_imagepatch_addressing_t ipa = VX_IMAGEPATCH_ADDR_INIT; return ipa; }
- /// Create vx_imagepatch_addressing_t structure with the provided values
- static vx_imagepatch_addressing_t createAddressing(
- vx_uint32 dimX, vx_uint32 dimY,
- vx_int32 strideX, vx_int32 strideY,
- vx_uint32 scaleX = VX_SCALE_UNITY, vx_uint32 scaleY = VX_SCALE_UNITY )
- {
- if (std::abs(strideY) < std::abs(strideX*(vx_int32)dimX))
- throw WrapperError(std::string(__func__)+"(): invalid arguments");
- vx_imagepatch_addressing_t ipa = VX_IMAGEPATCH_ADDR_INIT;
- ipa.dim_x = dimX;
- ipa.dim_y = dimY;
- ipa.stride_x = strideX;
- ipa.stride_y = strideY;
- ipa.scale_x = scaleX;
- ipa.scale_y = scaleY;
- return ipa;
- }
- /// Create vx_imagepatch_addressing_t structure for the specified image plane and its valid region
- vx_imagepatch_addressing_t createAddressing(vx_uint32 planeIdx)
- { return createAddressing(planeIdx, getValidRegion()); }
- /// Create vx_imagepatch_addressing_t structure for the specified image plane and the provided region
- vx_imagepatch_addressing_t createAddressing(vx_uint32 planeIdx, const vx_rectangle_t& rect)
- {
- vx_uint32 w = rect.end_x-rect.start_x, h = rect.end_y-rect.start_y;
- vx_size patchBytes = computePatchSize(planeIdx, rect);
- vx_imagepatch_addressing_t ipa = createAddressing(w, h, (vx_int32)(patchBytes/w/h), (vx_int32)(patchBytes/h));
- return ipa;
- }
- #ifndef VX_VERSION_1_1
- static const vx_enum VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST;
- #endif
- /// vxCreateImageFromHandle() wrapper
- static Image createFromHandle(
- vx_context context, vx_df_image format,
- const std::vector<vx_imagepatch_addressing_t>& addrs,
- const std::vector<void*>& ptrs, vx_enum memType = VX_MEMORY_TYPE_HOST )
- {
- vx_size num = planes(format);
- if(num == 0)
- throw WrapperError(std::string(__func__)+"(): unknown/unexpected planes number for the requested format");
- if (addrs.size() != num || ptrs.size() != num)
- throw WrapperError(std::string(__func__)+"(): incomplete input");
- #ifdef VX_VERSION_1_1
- return Image(vxCreateImageFromHandle(context, format, &addrs[0], &ptrs[0], memType));
- #else
- return Image( vxCreateImageFromHandle(context, format,
- const_cast<vx_imagepatch_addressing_t*>(&addrs[0]),
- const_cast<void**>(&ptrs[0]), memType) );
- #endif
- }
- /// vxCreateImageFromHandle() wrapper for a single plane image
- static Image createFromHandle(vx_context context, vx_df_image format,const vx_imagepatch_addressing_t& addr, void* ptr)
- {
- if(planes(format) != 1) throw WrapperError(std::string(__func__)+"(): not a single plane format");
- return Image(vxCreateImageFromHandle(context, format, const_cast<vx_imagepatch_addressing_t*> (&addr), &ptr, VX_MEMORY_TYPE_HOST));
- }
- #ifdef VX_VERSION_1_1
- /// vxSwapImageHandle() wrapper
- /// \param newPtrs keeps addresses of new image planes data, can be of image planes size or empty when new pointers are not provided
- /// \param prevPtrs storage for the previous addresses of image planes data, can be of image planes size or empty when previous pointers are not needed
- void swapHandle(const std::vector<void*>& newPtrs, std::vector<void*>& prevPtrs)
- {
- vx_size num = planes();
- if(num == 0)
- throw WrapperError(std::string(__func__)+"(): unexpected planes number");
- if (!newPtrs.empty() && newPtrs.size() != num)
- throw WrapperError(std::string(__func__)+"(): unexpected number of input pointers");
- if (!prevPtrs.empty() && prevPtrs.size() != num)
- throw WrapperError(std::string(__func__)+"(): unexpected number of output pointers");
- IVX_CHECK_STATUS( vxSwapImageHandle( ref,
- newPtrs.empty() ? 0 : &newPtrs[0],
- prevPtrs.empty() ? 0 : &prevPtrs[0],
- num ) );
- }
- /// vxSwapImageHandle() wrapper for a single plane image
- /// \param newPtr an address of new image data, can be zero when new pointer is not provided
- /// \return the previuos address of image data
- void* swapHandle(void* newPtr)
- {
- if(planes() != 1) throw WrapperError(std::string(__func__)+"(): not a single plane image");
- void* prevPtr = 0;
- IVX_CHECK_STATUS( vxSwapImageHandle(ref, &newPtr, &prevPtr, 1) );
- return prevPtr;
- }
- /// vxSwapImageHandle() wrapper for the case when no new pointers provided and previous ones are not needed (retrive memory back)
- void swapHandle()
- { IVX_CHECK_STATUS( vxSwapImageHandle(ref, 0, 0, 0) ); }
- /// vxCreateImageFromChannel() wrapper
- Image createFromChannel(vx_enum channel)
- { return Image(vxCreateImageFromChannel(ref, channel)); }
- #endif // VX_VERSION_1_1
- /// vxQueryImage() wrapper
- template<typename T>
- void query(vx_enum att, T& value) const
- { IVX_CHECK_STATUS( vxQueryImage(ref, att, &value, sizeof(value)) ); }
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_IMAGE_WIDTH = VX_IMAGE_ATTRIBUTE_WIDTH,
- VX_IMAGE_HEIGHT = VX_IMAGE_ATTRIBUTE_HEIGHT,
- VX_IMAGE_FORMAT = VX_IMAGE_ATTRIBUTE_FORMAT,
- VX_IMAGE_PLANES = VX_IMAGE_ATTRIBUTE_PLANES,
- VX_IMAGE_SPACE = VX_IMAGE_ATTRIBUTE_SPACE,
- VX_IMAGE_RANGE = VX_IMAGE_ATTRIBUTE_RANGE,
- VX_IMAGE_SIZE = VX_IMAGE_ATTRIBUTE_SIZE;
- #endif
- /// vxQueryImage(VX_IMAGE_WIDTH) wrapper
- vx_uint32 width() const
- {
- vx_uint32 v;
- query(VX_IMAGE_WIDTH, v);
- return v;
- }
- /// vxQueryImage(VX_IMAGE_HEIGHT) wrapper
- vx_uint32 height() const
- {
- vx_uint32 v;
- query(VX_IMAGE_HEIGHT, v);
- return v;
- }
- /// vxQueryImage(VX_IMAGE_FORMAT) wrapper
- vx_df_image format() const
- {
- vx_df_image v;
- query(VX_IMAGE_FORMAT, v);
- return v;
- }
- /// vxQueryImage(VX_IMAGE_PLANES) wrapper
- vx_size planes() const
- {
- vx_size v;
- query(VX_IMAGE_PLANES, v);
- return v;
- }
- /// vxQueryImage(VX_IMAGE_SPACE) wrapper
- vx_enum space() const
- {
- vx_enum v;
- query(VX_IMAGE_SPACE, v);
- return v;
- }
- /// vxQueryImage(VX_IMAGE_RANGE) wrapper
- vx_enum range() const
- {
- vx_enum v;
- query(VX_IMAGE_RANGE, v);
- return v;
- }
- /// vxQueryImage(VX_IMAGE_SIZE) wrapper
- vx_size size() const
- {
- vx_size v;
- query(VX_IMAGE_SIZE, v);
- return v;
- }
- #ifdef VX_VERSION_1_1
- /// vxQueryImage(VX_IMAGE_MEMORY_TYPE) wrapper
- vx_memory_type_e memType() const
- {
- vx_memory_type_e v;
- query(VX_IMAGE_MEMORY_TYPE, v);
- return v;
- }
- #endif // VX_VERSION_1_1
- /// vxSetImageAttribute() wrapper
- template<typename T>
- void setAttribute(vx_enum att, T& value) const
- { IVX_CHECK_STATUS(vxSetImageAttribute(ref, att, &value, sizeof(value))); }
- /// vxSetImageAttribute(SPACE) wrapper
- void setColorSpace(const vx_enum& sp)
- { setAttribute(VX_IMAGE_SPACE, sp); }
- /// vxGetValidRegionImage() wrapper
- vx_rectangle_t getValidRegion() const
- {
- vx_rectangle_t rect;
- IVX_CHECK_STATUS( vxGetValidRegionImage(ref, &rect) );
- return rect;
- }
- /// vxComputeImagePatchSize(valid region) wrapper
- vx_size computePatchSize(vx_uint32 planeIdx)
- { return computePatchSize(planeIdx, getValidRegion()); }
- /// vxComputeImagePatchSize() wrapper
- vx_size computePatchSize(vx_uint32 planeIdx, const vx_rectangle_t& rect)
- {
- vx_size bytes = vxComputeImagePatchSize(ref, &rect, planeIdx);
- if (bytes == 0) throw WrapperError(std::string(__func__)+"(): vxComputeImagePatchSize returned 0");
- return bytes;
- }
- #ifdef VX_VERSION_1_1
- /// vxSetImageValidRectangle() wrapper
- void setValidRectangle(const vx_rectangle_t& rect)
- { IVX_CHECK_STATUS( vxSetImageValidRectangle(ref, &rect) ); }
- #endif // VX_VERSION_1_1
- /// Copy image plane content to the provided memory
- void copyTo(vx_uint32 planeIdx, const vx_imagepatch_addressing_t& addr, void* data)
- {
- if(!data) throw WrapperError(std::string(__func__)+"(): output pointer is 0");
- vx_rectangle_t r = getValidRegion();
- // TODO: add sizes consistency checks
- /*
- vx_uint32 w = r.end_x - r.start_x, h = r.end_y - r.start_y;
- if (w != addr.dim_x) throw WrapperError("Image::copyTo(): inconsistent dimension X");
- if (h != addr.dim_y) throw WrapperError("Image::copyTo(): inconsistent dimension Y");
- */
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyImagePatch(ref, &r, planeIdx, &addr, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- vx_imagepatch_addressing_t* a = const_cast<vx_imagepatch_addressing_t*>(&addr);
- IVX_CHECK_STATUS(vxAccessImagePatch(ref, &r, planeIdx, a, &data, VX_READ_ONLY));
- IVX_CHECK_STATUS(vxCommitImagePatch(ref, 0, planeIdx, a, data));
- #endif
- }
- /// Copy the provided memory data to the specified image plane
- void copyFrom(vx_uint32 planeIdx, const vx_imagepatch_addressing_t& addr, const void* data)
- {
- if (!data) throw WrapperError(std::string(__func__)+"(): input pointer is 0");
- vx_rectangle_t r = getValidRegion();
- // TODO: add sizes consistency checks
- /*
- vx_uint32 w = r.end_x - r.start_x, h = r.end_y - r.start_y;
- //vx_size patchBytes = vxComputeImagePatchSize(ref, &r, planeIdx);
- if (w != addr.dim_x) throw WrapperError("Image::copyFrom(): inconsistent dimension X");
- if (h != addr.dim_y) throw WrapperError("Image::copyFrom(): inconsistent dimension Y");
- */
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyImagePatch(ref, &r, planeIdx, &addr, (void*)data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- vx_imagepatch_addressing_t* a = const_cast<vx_imagepatch_addressing_t*>(&addr);
- IVX_CHECK_STATUS(vxAccessImagePatch(ref, &r, planeIdx, a, const_cast<void**>(&data), VX_WRITE_ONLY));
- IVX_CHECK_STATUS(vxCommitImagePatch(ref, &r, planeIdx, a, data));
- #endif
- }
- /// vxCopyImagePatch() wrapper (or vxAccessImagePatch() + vxCommitImagePatch() for OpenVX 1.0)
- void copy( vx_uint32 planeIdx, vx_rectangle_t rect,
- const vx_imagepatch_addressing_t& addr, void* data,
- vx_enum usage, vx_enum memoryType = VX_MEMORY_TYPE_HOST )
- {
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyImagePatch(ref, &rect, planeIdx, &addr, (void*)data, usage, memoryType));
- #else
- (void)memoryType;
- vx_imagepatch_addressing_t* a = const_cast<vx_imagepatch_addressing_t*>(&addr);
- IVX_CHECK_STATUS(vxAccessImagePatch(ref, &rect, planeIdx, a, &data, usage));
- IVX_CHECK_STATUS(vxCommitImagePatch(ref, &rect, planeIdx, a, data));
- #endif
- }
- #ifdef IVX_USE_OPENCV
- /// Convert image format (fourcc) to cv::Mat type, throws WrapperError if not possible
- static int formatToMatType(vx_df_image format, vx_uint32 planeIdx = 0)
- {
- switch (format)
- {
- case VX_DF_IMAGE_RGB: return CV_8UC3;
- case VX_DF_IMAGE_RGBX: return CV_8UC4;
- case VX_DF_IMAGE_U8: return CV_8UC1;
- case VX_DF_IMAGE_U16: return CV_16UC1;
- case VX_DF_IMAGE_S16: return CV_16SC1;
- case VX_DF_IMAGE_U32:
- case VX_DF_IMAGE_S32: return CV_32SC1;
- case VX_DF_IMAGE('F', '0', '3', '2'):
- return CV_32FC1;
- case VX_DF_IMAGE_YUV4:
- case VX_DF_IMAGE_IYUV: return CV_8UC1;
- case VX_DF_IMAGE_UYVY:
- case VX_DF_IMAGE_YUYV: return CV_8UC2;
- case VX_DF_IMAGE_NV12:
- case VX_DF_IMAGE_NV21: return planeIdx == 0 ? CV_8UC1 : CV_8UC2;
- default: throw WrapperError(std::string(__func__)+"(): unsupported image format");
- }
- }
- /// Convert cv::Mat type to standard image format (fourcc), throws WrapperError if not possible
- static vx_df_image matTypeToFormat(int matType)
- {
- switch (matType)
- {
- case CV_8UC4: return VX_DF_IMAGE_RGBX;
- case CV_8UC3: return VX_DF_IMAGE_RGB;
- case CV_8UC1: return VX_DF_IMAGE_U8;
- case CV_16UC1: return VX_DF_IMAGE_U16;
- case CV_16SC1: return VX_DF_IMAGE_S16;
- case CV_32SC1: return VX_DF_IMAGE_S32;
- case CV_32FC1: return VX_DF_IMAGE('F', '0', '3', '2');
- default: throw WrapperError(std::string(__func__)+"(): unsupported cv::Mat type");
- }
- }
- /// Initialize cv::Mat shape to fit the specified image plane data
- void createMatForPlane(cv::Mat& m, vx_uint32 planeIdx)
- {
- vx_df_image f = format();
- //vx_uint32 w = width(), h = height();
- vx_rectangle_t r = getValidRegion();
- vx_int32 w = vx_int32(r.end_x - r.start_x), h = vx_int32(r.end_y - r.start_y);
- switch (f)
- {
- case VX_DF_IMAGE_IYUV:
- if (planeIdx == 0u) m.create(h, w, formatToMatType(f));
- else if (planeIdx == 1u || planeIdx == 2u) m.create(h/2, w/2, formatToMatType(f));
- else throw WrapperError(std::string(__func__)+"(): wrong plane index");
- break;
- case VX_DF_IMAGE_YUV4:
- if (planeIdx == 0u || planeIdx == 1u || planeIdx == 2u) m.create(h, w, formatToMatType(f));
- else throw WrapperError(std::string(__func__)+"(): wrong plane index");
- break;
- case VX_DF_IMAGE_NV12:
- case VX_DF_IMAGE_NV21:
- if (planeIdx == 0u) m.create(h, w, formatToMatType(f, 0));
- else if (planeIdx == 1u) m.create(h/2, w/2, formatToMatType(f, 1));
- else throw WrapperError(std::string(__func__)+"(): wrong plane index");
- break;
- case VX_DF_IMAGE_RGB:
- case VX_DF_IMAGE_RGBX:
- case VX_DF_IMAGE_UYVY:
- case VX_DF_IMAGE_YUYV:
- case VX_DF_IMAGE_U8:
- case VX_DF_IMAGE_U16:
- case VX_DF_IMAGE_S16:
- case VX_DF_IMAGE_U32:
- case VX_DF_IMAGE_S32:
- case /*VX_DF_IMAGE_F32*/VX_DF_IMAGE('F', '0', '3', '2'):
- if(planeIdx == 0u) m.create(h, w, formatToMatType(f));
- else throw WrapperError(std::string(__func__)+"(): wrong plane index");
- break;
- default: throw WrapperError(std::string(__func__)+"(): unsupported color format");
- }
- }
- /// Create vx_imagepatch_addressing_t corresponding to the provided cv::Mat
- static vx_imagepatch_addressing_t createAddressing(const cv::Mat& m)
- {
- if(m.empty()) throw WrapperError(std::string(__func__)+"(): empty input Mat");
- return createAddressing((vx_uint32)m.cols, (vx_uint32)m.rows, (vx_int32)m.elemSize(), (vx_int32)m.step);
- }
- /// Copy image plane content to the provided cv::Mat (reallocate if needed)
- void copyTo(vx_uint32 planeIdx, cv::Mat& m)
- {
- createMatForPlane(m, planeIdx);
- copyTo(planeIdx, createAddressing((vx_uint32)m.cols, (vx_uint32)m.rows, (vx_int32)m.elemSize(), (vx_int32)m.step), m.ptr());
- }
- /// Copy the provided cv::Mat data to the specified image plane
- void copyFrom(vx_uint32 planeIdx, const cv::Mat& m)
- {
- if(m.empty()) throw WrapperError(std::string(__func__)+"(): empty input Mat");
- // TODO: add sizes consistency checks
- //vx_rectangle_t r = getValidRegion();
- copyFrom(planeIdx, createAddressing((vx_uint32)m.cols, (vx_uint32)m.rows, (vx_int32)m.elemSize(), (vx_int32)m.step), m.ptr());
- }
- /*
- private:
- cv::Mat _mat; // TODO: update copy/move-c-tors, operator=() and swapHandles()
- public:
- static Image createFromHandle(vx_context context, const cv::Mat& mat)
- {
- if(mat.empty()) throw WrapperError(std::string(__func__)+"(): empty cv::Mat");
- Image res = createFromHandle(context, matTypeToFormat(mat.type()), createAddressing(mat), mat.data );
- res._mat = mat;
- return res;
- }
- */
- #endif //IVX_USE_OPENCV
- struct Patch;
- };
- /// Helper class for a mapping vx_image patch
- struct Image::Patch
- {
- public:
- /// reference to the current vx_imagepatch_addressing_t
- const vx_imagepatch_addressing_t& addr() const
- { return _addr;}
- /// current pixels data pointer
- void* data() const
- { return _data; }
- #ifdef VX_VERSION_1_1
- /// vx_memory_type_e for the current data pointer
- vx_memory_type_e memType() const
- { return _memType; }
- /// vx_map_id for the current mapping
- vx_map_id mapId() const
- { return _mapId; }
- #else
- /// reference to vx_rectangle_t for the current mapping
- const vx_rectangle_t& rectangle() const
- { return _rect; }
- /// Image plane index for the current mapping
- vx_uint32 planeIndex() const
- { return _planeIdx; }
- #endif // VX_VERSION_1_1
- /// vx_image for the current mapping
- vx_image image() const
- { return _img; }
- /// where this patch is mapped
- bool isMapped() const
- { return _img != 0; }
- #ifdef IVX_USE_OPENCV
- /// Reference to cv::Mat instance wrapping the mapped image data, becomes invalid after unmap()
- cv::Mat& getMat()
- { return _m; }
- #endif //IVX_USE_OPENCV
- protected:
- vx_imagepatch_addressing_t _addr;
- void* _data;
- vx_image _img;
- #ifdef VX_VERSION_1_1
- vx_memory_type_e _memType;
- vx_map_id _mapId;
- #else
- vx_rectangle_t _rect;
- vx_uint32 _planeIdx;
- #endif
- #ifdef IVX_USE_OPENCV
- cv::Mat _m;
- #endif
- public:
- /// Default constructor
- Patch() : _addr(createAddressing()), _data(0), _img(0)
- #ifdef VX_VERSION_1_1
- , _memType(VX_MEMORY_TYPE_HOST), _mapId(0)
- {}
- #else
- , _planeIdx(-1)
- { _rect.start_x = _rect.end_x = _rect.start_y = _rect.end_y = 0u; }
- #endif
- #ifndef IVX_USE_CXX98
- /// Move constructor
- Patch(Patch&& p) : Patch()
- {
- using std::swap;
- swap(_addr, p._addr);
- swap(_data, p._data);
- #ifdef VX_VERSION_1_1
- swap(_memType, p._memType);
- swap(_mapId, p._mapId);
- #else
- swap(_rect, p._rect);
- swap(_planeIdx, p._planeIdx);
- #endif
- swap(_img, p._img);
- #ifdef IVX_USE_OPENCV
- swap(_m, p._m);
- #endif
- }
- #endif
- /// vxMapImagePatch(VX_READ_ONLY, planeIdx valid region)
- void map(vx_image img, vx_uint32 planeIdx)
- { map(img, planeIdx, Image(img, true).getValidRegion()); }
- /// vxMapImagePatch() wrapper (or vxAccessImagePatch() for 1.0)
- void map(vx_image img, vx_uint32 planeIdx, const vx_rectangle_t& rect, vx_enum usage = VX_READ_ONLY, vx_uint32 flags = 0)
- {
- if (isMapped()) throw WrapperError(std::string(__func__)+"(): already mapped");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxMapImagePatch(img, &rect, planeIdx, &_mapId, &_addr, &_data, usage, _memType, flags) );
- #else
- IVX_CHECK_STATUS(vxAccessImagePatch(img, &rect, planeIdx, &_addr, &_data, usage));
- (void)flags;
- _rect = rect;
- _planeIdx = planeIdx;
- #endif
- if (_data == 0) throw WrapperError(std::string(__func__)+"(): mapped address is null");
- _img = img;
- #ifdef IVX_USE_OPENCV
- vx_df_image format;
- IVX_CHECK_STATUS( vxQueryImage(_img, VX_IMAGE_FORMAT, &format, sizeof(format)) );
- int matType = formatToMatType(format);
- _m = cv::Mat( vx_int32((vx_int64)_addr.dim_y * VX_SCALE_UNITY / _addr.scale_y),
- vx_int32((vx_int64)_addr.dim_x * VX_SCALE_UNITY / _addr.scale_x),
- matType, _data, std::size_t(_addr.stride_y) );
- #endif
- }
- /// vxUnmapImagePatch() wrapper (or vxCommitImagePatch() for 1.0)
- void unmap()
- {
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxUnmapImagePatch(_img, _mapId));
- _mapId = 0;
- #else
- IVX_CHECK_STATUS(vxCommitImagePatch(_img, &_rect, _planeIdx, &_addr, _data));
- _rect.start_x = _rect.end_x = _rect.start_y = _rect.end_y = 0u;
- _planeIdx = -1;
- #endif
- _img = 0;
- _data = 0;
- _addr = createAddressing();
- #ifdef IVX_USE_OPENCV
- _m.release();
- #endif
- }
- /// Destructor
- ~Patch()
- { try { if (_img) unmap(); } catch(...) {; /*ignore*/} }
- /// Pointer to the specified pixel data (vxFormatImagePatchAddress2d)
- void* pixelPtr(vx_uint32 x, vx_uint32 y)
- {
- if (!_data) throw WrapperError(std::string(__func__)+"(): base pointer is NULL");
- if (x >= _addr.dim_x) throw WrapperError(std::string(__func__)+"(): X out of range");
- if (y >= _addr.dim_y) throw WrapperError(std::string(__func__)+"(): Y out of range");
- return vxFormatImagePatchAddress2d(_data, x, y, &_addr);
- }
- private:
- Patch(const Patch& p); // = delete
- Patch& operator=(const Patch&); // = delete
- #ifndef IVX_USE_CXX98
- Patch& operator=(Patch&&); // = delete
- #endif
- };
- /// vx_parameter wrapper
- class Param : public RefWrapper<vx_parameter>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Param);
- // NYI
- };
- /// vx_scalar wrapper
- class Scalar : public RefWrapper<vx_scalar>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Scalar);
- /// vxCreateScalar() wrapper
- static Scalar create(vx_context c, vx_enum dataType, const void *ptr)
- { return Scalar( vxCreateScalar(c, dataType, ptr) ); }
- /// vxCreateScalar() wrapper, value is passed as a value not as a pointer
- template<typename T> static Scalar create(vx_context c, vx_enum dataType, T value)
- {
- typedef int static_assert_not_pointer[is_pointer<T>::value ? -1 : 1];
- return Scalar( vxCreateScalar(c, dataType, &value) );
- }
- /// vxCreateScalar() wrapper, data type is guessed based on the passed value
- template<vx_enum E> static Scalar create(vx_context c, typename EnumToType<E>::type value)
- { return Scalar( vxCreateScalar(c, E, &value) ); }
- #ifndef VX_VERSION_1_1
- static const vx_enum VX_SCALAR_TYPE = VX_SCALAR_ATTRIBUTE_TYPE;
- #endif
- /// Get scalar data type
- vx_enum type()
- {
- vx_enum val;
- IVX_CHECK_STATUS( vxQueryScalar(ref, VX_SCALAR_TYPE, &val, sizeof(val)) );
- return val;
- }
- /// Get scalar value
- template<typename T>
- void getValue(T& val)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, type()))
- throw WrapperError(std::string(__func__)+"(): incompatible types");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS( vxCopyScalar(ref, &val, VX_READ_ONLY, VX_MEMORY_TYPE_HOST) );
- #else
- IVX_CHECK_STATUS( vxReadScalarValue(ref, &val) );
- #endif
- }
- /// Get scalar value
- template<typename T>
- T getValue()
- {
- T val;
- getValue(val);
- return val;
- }
- /// Set scalar value
- template<typename T>
- void setValue(T val)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, type()))
- throw WrapperError(std::string(__func__)+"(): incompatible types");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyScalar(ref, &val, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- IVX_CHECK_STATUS( vxWriteScalarValue(ref, &val) );
- #endif
- }
- };
- /// vx_threshold wrapper
- class Threshold : public RefWrapper<vx_threshold>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Threshold);
- /// vxCreateThreshold() wrapper
- static Threshold create(vx_context c, vx_enum threshType, vx_enum dataType)
- { return Threshold(vxCreateThreshold(c, threshType, dataType)); }
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_THRESHOLD_TYPE = VX_THRESHOLD_ATTRIBUTE_TYPE,
- VX_THRESHOLD_THRESHOLD_VALUE = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_VALUE,
- VX_THRESHOLD_THRESHOLD_LOWER = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_LOWER,
- VX_THRESHOLD_THRESHOLD_UPPER = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_UPPER,
- VX_THRESHOLD_TRUE_VALUE = VX_THRESHOLD_ATTRIBUTE_TRUE_VALUE,
- VX_THRESHOLD_FALSE_VALUE = VX_THRESHOLD_ATTRIBUTE_FALSE_VALUE,
- VX_THRESHOLD_DATA_TYPE = VX_THRESHOLD_ATTRIBUTE_DATA_TYPE;
- #endif
- /// Create binary threshold with the provided value
- static Threshold createBinary(vx_context c, vx_enum dataType, vx_int32 val)
- {
- Threshold thr = create(c, VX_THRESHOLD_TYPE_BINARY, dataType);
- IVX_CHECK_STATUS( vxSetThresholdAttribute(thr.ref, VX_THRESHOLD_THRESHOLD_VALUE, &val, sizeof(val)) );
- return thr;
- }
- /// Create range threshold with the provided low and high values
- static Threshold createRange(vx_context c, vx_enum dataType, vx_int32 valLower, vx_int32 valUpper)
- {
- Threshold thr = create(c, VX_THRESHOLD_TYPE_RANGE, dataType);
- IVX_CHECK_STATUS( vxSetThresholdAttribute(thr.ref, VX_THRESHOLD_THRESHOLD_LOWER, &valLower, sizeof(valLower)) );
- IVX_CHECK_STATUS( vxSetThresholdAttribute(thr.ref, VX_THRESHOLD_THRESHOLD_UPPER, &valUpper, sizeof(valUpper)) );
- return thr;
- }
- /// vxQueryThreshold() wrapper
- template<typename T>
- void query(vx_enum att, T& val) const
- { IVX_CHECK_STATUS( vxQueryThreshold(ref, att, &val, sizeof(val)) ); }
- /// vxQueryThreshold(VX_THRESHOLD_TYPE) wrapper
- vx_enum type() const
- {
- vx_enum v;
- query(VX_THRESHOLD_TYPE, v);
- return v;
- }
- /// vxQueryThreshold(DATA_TYPE) wrapper
- vx_enum dataType() const
- {
- vx_enum v;
- query(VX_THRESHOLD_DATA_TYPE, v);
- return v;
- }
- /// vxQueryThreshold(THRESHOLD_VALUE) wrapper
- vx_int32 value() const
- {
- vx_int32 v;
- query(VX_THRESHOLD_THRESHOLD_VALUE, v);
- return v;
- }
- /// vxQueryThreshold(THRESHOLD_LOWER) wrapper
- vx_int32 valueLower() const
- {
- vx_int32 v;
- query(VX_THRESHOLD_THRESHOLD_LOWER, v);
- return v;
- }
- /// vxQueryThreshold(THRESHOLD_UPPER) wrapper
- vx_int32 valueUpper() const
- {
- vx_int32 v;
- query(VX_THRESHOLD_THRESHOLD_UPPER, v);
- return v;
- }
- /// vxQueryThreshold(TRUE_VALUE) wrapper
- vx_int32 valueTrue() const
- {
- vx_int32 v;
- query(VX_THRESHOLD_TRUE_VALUE, v);
- return v;
- }
- /// vxQueryThreshold(FALSE_VALUE) wrapper
- vx_int32 valueFalse() const
- {
- vx_int32 v;
- query(VX_THRESHOLD_FALSE_VALUE, v);
- return v;
- }
- /// vxSetThresholdAttribute(THRESHOLD_VALUE) wrapper
- void setValue(vx_int32 &val)
- { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_THRESHOLD_VALUE, &val, sizeof(val))); }
- /// vxSetThresholdAttribute(THRESHOLD_LOWER) wrapper
- void setValueLower(vx_int32 &val)
- { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_THRESHOLD_LOWER, &val, sizeof(val))); }
- /// vxSetThresholdAttribute(THRESHOLD_UPPER) wrapper
- void setValueUpper(vx_int32 &val)
- { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_THRESHOLD_UPPER, &val, sizeof(val))); }
- /// vxSetThresholdAttribute(TRUE_VALUE) wrapper
- void setValueTrue(vx_int32 &val)
- { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_TRUE_VALUE, &val, sizeof(val))); }
- /// vxSetThresholdAttribute(FALSE_VALUE) wrapper
- void setValueFalse(vx_int32 &val)
- { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_FALSE_VALUE, &val, sizeof(val))); }
- };
- /// vx_array wrapper
- class Array : public RefWrapper<vx_array>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Array);
- /// vxCreateArray() wrapper
- static Array create(vx_context c, vx_enum type, vx_size capacity)
- { return Array(vxCreateArray(c, type, capacity)); }
- /// vxCreateVirtualArray() wrapper
- static Array createVirtual(vx_graph g, vx_enum type, vx_size capacity)
- { return Array(vxCreateVirtualArray(g, type, capacity)); }
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST,
- VX_ARRAY_ITEMTYPE = VX_ARRAY_ATTRIBUTE_ITEMTYPE,
- VX_ARRAY_NUMITEMS = VX_ARRAY_ATTRIBUTE_NUMITEMS,
- VX_ARRAY_CAPACITY = VX_ARRAY_ATTRIBUTE_CAPACITY,
- VX_ARRAY_ITEMSIZE = VX_ARRAY_ATTRIBUTE_ITEMSIZE;
- #endif
- template<typename T>
- void query(vx_enum att, T& value) const
- { IVX_CHECK_STATUS( vxQueryArray(ref, att, &value, sizeof(value)) ); }
- vx_enum itemType() const
- {
- vx_enum v;
- query(VX_ARRAY_ITEMTYPE, v);
- return v;
- }
- vx_size itemSize() const
- {
- vx_size v;
- query(VX_ARRAY_ITEMSIZE, v);
- return v;
- }
- vx_size capacity() const
- {
- vx_size v;
- query(VX_ARRAY_CAPACITY, v);
- return v;
- }
- vx_size itemCount() const
- {
- vx_size v;
- query(VX_ARRAY_NUMITEMS, v);
- return v;
- }
- void addItems(vx_size count, const void* ptr, vx_size stride)
- {
- IVX_CHECK_STATUS(vxAddArrayItems(ref, count, ptr, stride));
- }
- void truncateArray(vx_size new_count)
- {
- if(new_count <= itemCount())
- IVX_CHECK_STATUS(vxTruncateArray(ref, new_count));
- else
- throw WrapperError(std::string(__func__) + "(): array is too small");
- }
- void copyRangeTo(size_t start, size_t end, void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): output pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyArrayRange(ref, start, end, itemSize(), data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- vx_size stride = itemSize();
- IVX_CHECK_STATUS(vxAccessArrayRange(ref, start, end, &stride, &data, VX_READ_ONLY));
- IVX_CHECK_STATUS(vxCommitArrayRange(ref, start, end, data));
- #endif
- }
- void copyTo(void* data)
- { copyRangeTo(0, itemCount(), data); }
- void copyRangeFrom(size_t start, size_t end, const void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): input pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyArrayRange(ref, start, end, itemSize(), const_cast<void*>(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- vx_size stride = itemSize();
- IVX_CHECK_STATUS(vxAccessArrayRange(ref, start, end, &stride, const_cast<void**>(&data), VX_WRITE_ONLY));
- IVX_CHECK_STATUS(vxCommitArrayRange(ref, start, end, data));
- #endif
- }
- void copyFrom(const void* data)
- { copyRangeFrom(0, itemCount(), data); }
- void copyRange(size_t start, size_t end, void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): data pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyArrayRange(ref, start, end, itemSize(), data, usage, memType));
- #else
- vx_size stride = itemSize();
- IVX_CHECK_STATUS(vxAccessArrayRange(ref, start, end, &stride, &data, usage));
- IVX_CHECK_STATUS(vxCommitArrayRange(ref, start, end, data));
- (void)memType;
- #endif
- }
- void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST)
- { copyRange(0, itemCount(), data, usage, memType); }
- template<typename T> void addItem(const T& item)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, itemType()))
- throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- addItems(1, &item, sizeof(T));
- }
- template<typename T> void addItems(const std::vector<T>& data)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, itemType()))
- throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- addItems(data.size(), &data[0], itemSize());
- }
- template<typename T> void copyRangeTo(size_t start, size_t end, std::vector<T>& data)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, itemType()))
- throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (data.empty())
- data.resize((end - start));
- else if (data.size() != (end - start))
- {
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- }
- copyRangeTo(start, end, &data[0]);
- }
- template<typename T> void copyTo(std::vector<T>& data)
- { copyRangeTo(0, itemCount(), data); }
- template<typename T> void copyRangeFrom(size_t start, size_t end, const std::vector<T>& data)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, itemType()))
- throw WrapperError(std::string(__func__) + "(): source type is wrong");
- if (data.size() != (end - start)) throw WrapperError(std::string(__func__) + "(): source size is wrong");
- copyRangeFrom(start, end, &data[0]);
- }
- template<typename T> void copyFrom(std::vector<T>& data)
- { copyRangeFrom(0, itemCount(), data); }
- #ifdef IVX_USE_OPENCV
- void addItems(cv::InputArray ia)
- {
- cv::Mat m = ia.getMat();
- if (m.type() != enumToCVType(itemType()))
- throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- addItems(m.total(), m.isContinuous() ? m.ptr() : m.clone().ptr(),
- (vx_size)(m.elemSize()));
- }
- void copyRangeTo(size_t start, size_t end, cv::Mat& m)
- {
- if (m.type() != enumToCVType(itemType()))
- throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (!(
- ((vx_size)(m.rows) == (end - start) && m.cols == 1) ||
- ((vx_size)(m.cols) == (end - start) && m.rows == 1)
- ) && !m.empty())
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- if (m.isContinuous() && (vx_size)(m.total()) == (end - start))
- {
- copyRangeTo(start, end, m.ptr());
- }
- else
- {
- cv::Mat tmp(1, (int)(end - start), enumToCVType(itemType()));
- copyRangeTo(start, end, tmp.ptr());
- if (m.empty())
- m = tmp;
- else
- tmp.copyTo(m);
- }
- }
- void copyTo(cv::Mat& m)
- { copyRangeTo(0, itemCount(), m); }
- void copyRangeFrom(size_t start, size_t end, const cv::Mat& m)
- {
- if (!(
- ((vx_size)(m.rows) == (end - start) && m.cols == 1) ||
- ((vx_size)(m.cols) == (end - start) && m.rows == 1)
- ))
- throw WrapperError(std::string(__func__) + "(): source size is wrong");
- if (m.type() != enumToCVType(itemType()))
- throw WrapperError(std::string(__func__) + "(): source type is wrong");
- copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr());
- }
- void copyFrom(const cv::Mat& m)
- { copyRangeFrom(0, itemCount(), m); }
- #endif //IVX_USE_OPENCV
- };
- /*
- * Convolution
- */
- class Convolution : public RefWrapper<vx_convolution>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Convolution);
- static Convolution create(vx_context context, vx_size columns, vx_size rows)
- { return Convolution(vxCreateConvolution(context, columns, rows)); }
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST,
- VX_CONVOLUTION_ROWS = VX_CONVOLUTION_ATTRIBUTE_ROWS,
- VX_CONVOLUTION_COLUMNS = VX_CONVOLUTION_ATTRIBUTE_COLUMNS,
- VX_CONVOLUTION_SCALE = VX_CONVOLUTION_ATTRIBUTE_SCALE,
- VX_CONVOLUTION_SIZE = VX_CONVOLUTION_ATTRIBUTE_SIZE;
- #endif
- template<typename T>
- void query(vx_enum att, T& value) const
- { IVX_CHECK_STATUS( vxQueryConvolution(ref, att, &value, sizeof(value)) ); }
- vx_size columns() const
- {
- vx_size v;
- query(VX_CONVOLUTION_COLUMNS, v);
- return v;
- }
- vx_size rows() const
- {
- vx_size v;
- query(VX_CONVOLUTION_ROWS, v);
- return v;
- }
- vx_uint32 scale() const
- {
- vx_uint32 v;
- query(VX_CONVOLUTION_SCALE, v);
- return v;
- }
- vx_size size() const
- {
- vx_size v;
- query(VX_CONVOLUTION_SIZE, v);
- return v;
- }
- vx_enum dataType()
- {
- return VX_TYPE_INT16;
- }
- void setScale(vx_uint32 newScale)
- { IVX_CHECK_STATUS( vxSetConvolutionAttribute(ref, VX_CONVOLUTION_SCALE, &newScale, sizeof(newScale)) ); }
- void copyTo(void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): output pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyConvolutionCoefficients(ref, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- IVX_CHECK_STATUS(vxReadConvolutionCoefficients(ref, (vx_int16 *)data));
- #endif
- }
- void copyFrom(const void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): input pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyConvolutionCoefficients(ref, const_cast<void*>(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- IVX_CHECK_STATUS(vxWriteConvolutionCoefficients(ref, (const vx_int16 *)data));
- #endif
- }
- void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): data pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyConvolutionCoefficients(ref, data, usage, memType));
- #else
- if (usage == VX_READ_ONLY)
- IVX_CHECK_STATUS(vxReadConvolutionCoefficients(ref, (vx_int16 *)data));
- else if (usage == VX_WRITE_ONLY)
- IVX_CHECK_STATUS(vxWriteConvolutionCoefficients(ref, (const vx_int16 *)data));
- else
- throw WrapperError(std::string(__func__) + "(): unknown copy direction");
- (void)memType;
- #endif
- }
- template<typename T> void copyTo(std::vector<T>& data)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, dataType()))
- throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (data.size()*sizeof(T) != size())
- {
- if (data.size() == 0)
- data.resize(size()/sizeof(T));
- else
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- }
- copyTo(&data[0]);
- }
- template<typename T> void copyFrom(const std::vector<T>& data)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, dataType()))
- throw WrapperError(std::string(__func__) + "(): source type is wrong");
- if (data.size()*sizeof(T) != size()) throw WrapperError(std::string(__func__) + "(): source size is wrong");
- copyFrom(&data[0]);
- }
- #ifdef IVX_USE_OPENCV
- void copyTo(cv::Mat& m)
- {
- if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (((vx_size)(m.rows) != rows() || (vx_size)(m.cols) != columns()) && !m.empty())
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- if (m.isContinuous() && (vx_size)(m.rows) == rows() && (vx_size)(m.cols) == columns())
- {
- copyTo(m.ptr());
- }
- else
- {
- cv::Mat tmp((int)rows(), (int)columns(), enumToCVType(dataType()));
- copyTo(tmp.ptr());
- if (m.empty())
- m = tmp;
- else
- tmp.copyTo(m);
- }
- }
- void copyFrom(const cv::Mat& m)
- {
- if ((vx_size)(m.rows) != rows() || (vx_size)(m.cols) != columns()) throw WrapperError(std::string(__func__) + "(): source size is wrong");
- if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): source type is wrong");
- copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr());
- }
- #endif //IVX_USE_OPENCV
- };
- /*
- * Matrix
- */
- class Matrix : public RefWrapper<vx_matrix>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Matrix);
- static Matrix create(vx_context context, vx_enum dataType, vx_size columns, vx_size rows)
- { return Matrix(vxCreateMatrix(context, dataType, columns, rows)); }
- #ifdef VX_VERSION_1_1
- static Matrix createFromPattern(vx_context context, vx_enum pattern, vx_size columns, vx_size rows)
- { return Matrix(vxCreateMatrixFromPattern(context, pattern, columns, rows)); }
- #endif
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST,
- VX_MATRIX_TYPE = VX_MATRIX_ATTRIBUTE_TYPE,
- VX_MATRIX_ROWS = VX_MATRIX_ATTRIBUTE_ROWS,
- VX_MATRIX_COLUMNS = VX_MATRIX_ATTRIBUTE_COLUMNS,
- VX_MATRIX_SIZE = VX_MATRIX_ATTRIBUTE_SIZE;
- #endif
- template<typename T>
- void query(vx_enum att, T& value) const
- { IVX_CHECK_STATUS( vxQueryMatrix(ref, att, &value, sizeof(value)) ); }
- vx_enum dataType() const
- {
- vx_enum v;
- query(VX_MATRIX_TYPE, v);
- return v;
- }
- vx_size columns() const
- {
- vx_size v;
- query(VX_MATRIX_COLUMNS, v);
- return v;
- }
- vx_size rows() const
- {
- vx_size v;
- query(VX_MATRIX_ROWS, v);
- return v;
- }
- vx_size size() const
- {
- vx_size v;
- query(VX_MATRIX_SIZE, v);
- return v;
- }
- #ifdef VX_VERSION_1_1
- vx_coordinates2d_t origin() const
- {
- vx_coordinates2d_t v;
- query(VX_MATRIX_ORIGIN, v);
- return v;
- }
- vx_enum pattern() const
- {
- vx_enum v;
- query(VX_MATRIX_PATTERN, v);
- return v;
- }
- #endif // VX_VERSION_1_1
- void copyTo(void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): output pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyMatrix(ref, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- IVX_CHECK_STATUS(vxReadMatrix(ref, data));
- #endif
- }
- void copyFrom(const void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): input pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyMatrix(ref, const_cast<void*>(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- IVX_CHECK_STATUS(vxWriteMatrix(ref, data));
- #endif
- }
- void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): data pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyMatrix(ref, data, usage, memType));
- #else
- if (usage == VX_READ_ONLY)
- IVX_CHECK_STATUS(vxReadMatrix(ref, data));
- else if (usage == VX_WRITE_ONLY)
- IVX_CHECK_STATUS(vxWriteMatrix(ref, data));
- else
- throw WrapperError(std::string(__func__) + "(): unknown copy direction");
- (void)memType;
- #endif
- }
- template<typename T> void copyTo(std::vector<T>& data)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, dataType()))
- throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (data.size()*sizeof(T) != size())
- {
- if (data.size() == 0)
- data.resize(size()/sizeof(T));
- else
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- }
- copyTo(&data[0]);
- }
- template<typename T> void copyFrom(const std::vector<T>& data)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, dataType()))
- throw WrapperError(std::string(__func__) + "(): source type is wrong");
- if (data.size()*sizeof(T) != size()) throw WrapperError(std::string(__func__) + "(): source size is wrong");
- copyFrom(&data[0]);
- }
- #ifdef IVX_USE_OPENCV
- void copyTo(cv::Mat& m)
- {
- if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (((vx_size)(m.rows) != rows() || (vx_size)(m.cols) != columns()) && !m.empty())
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- if (m.isContinuous() && (vx_size)(m.rows) == rows() && (vx_size)(m.cols) == columns())
- {
- copyTo(m.ptr());
- }
- else
- {
- cv::Mat tmp((int)rows(), (int)columns(), enumToCVType(dataType()));
- copyTo(tmp.ptr());
- if (m.empty())
- m = tmp;
- else
- tmp.copyTo(m);
- }
- }
- void copyFrom(const cv::Mat& m)
- {
- if ((vx_size)(m.rows) != rows() || (vx_size)(m.cols) != columns()) throw WrapperError(std::string(__func__) + "(): source size is wrong");
- if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): source type is wrong");
- copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr());
- }
- #endif //IVX_USE_OPENCV
- };
- /*
- * LUT
- */
- class LUT : public RefWrapper<vx_lut>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(LUT);
- #ifdef VX_VERSION_1_1
- static LUT create(vx_context context, vx_enum dataType = VX_TYPE_UINT8, vx_size count = 256)
- {
- #else
- static LUT create(vx_context context)
- {
- vx_enum dataType = VX_TYPE_UINT8;
- vx_size count = 256;
- #endif
- return LUT(vxCreateLUT(context, dataType, count));
- }
- #ifndef VX_VERSION_1_1
- static const vx_enum VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST;
- #endif
- template<typename T>
- void query(vx_enum att, T& value) const
- {
- IVX_CHECK_STATUS(vxQueryLUT(ref, att, &value, sizeof(value)));
- }
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_LUT_TYPE = VX_LUT_ATTRIBUTE_TYPE,
- VX_LUT_COUNT = VX_LUT_ATTRIBUTE_COUNT,
- VX_LUT_SIZE = VX_LUT_ATTRIBUTE_SIZE;
- #endif
- vx_enum dataType() const
- {
- vx_enum v;
- query(VX_LUT_TYPE, v);
- return v;
- }
- vx_size count() const
- {
- vx_size v;
- query(VX_LUT_COUNT, v);
- return v;
- }
- vx_size size() const
- {
- vx_size v;
- query(VX_LUT_SIZE, v);
- return v;
- }
- #ifdef VX_VERSION_1_1
- vx_uint32 offset() const
- {
- vx_enum v;
- query(VX_LUT_OFFSET, v);
- return v;
- }
- #endif // VX_VERSION_1_1
- void copyTo(void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): output pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyLUT(ref, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- IVX_CHECK_STATUS(vxAccessLUT(ref, &data, VX_READ_ONLY));
- IVX_CHECK_STATUS(vxCommitLUT(ref, data));
- #endif
- }
- void copyFrom(const void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): input pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyLUT(ref, const_cast<void*>(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- IVX_CHECK_STATUS(vxAccessLUT(ref, const_cast<void**>(&data), VX_WRITE_ONLY));
- IVX_CHECK_STATUS(vxCommitLUT(ref, data));
- #endif
- }
- void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST)
- {
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyLUT(ref, data, usage, memType));
- #else
- IVX_CHECK_STATUS(vxAccessLUT(ref, const_cast<void**>(&data), usage));
- IVX_CHECK_STATUS(vxCommitLUT(ref, data));
- (void)memType;
- #endif
- }
- template<typename T> void copyTo(std::vector<T>& data)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, dataType()))
- throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (data.size() != count())
- {
- if (data.size() == 0)
- data.resize(count());
- else
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- }
- copyTo(&data[0]);
- }
- template<typename T> void copyFrom(const std::vector<T>& data)
- {
- if (!areTypesCompatible(TypeToEnum<T>::value, dataType()))
- throw WrapperError(std::string(__func__) + "(): source type is wrong");
- if (data.size() != count()) throw WrapperError(std::string(__func__) + "(): source size is wrong");
- copyFrom(&data[0]);
- }
- #ifdef IVX_USE_OPENCV
- void copyTo(cv::Mat& m)
- {
- if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (!(
- ((vx_size)(m.rows) == count() && m.cols == 1) ||
- ((vx_size)(m.cols) == count() && m.rows == 1)
- ) && !m.empty())
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- if (m.isContinuous() && (vx_size)(m.total()) == count())
- {
- copyTo(m.ptr());
- }
- else
- {
- cv::Mat tmp(1, (int)count(), enumToCVType(dataType()));
- copyTo(tmp.ptr());
- if (m.empty())
- m = tmp;
- else
- tmp.copyTo(m);
- }
- }
- void copyFrom(const cv::Mat& m)
- {
- if (!(
- ((vx_size)(m.rows) == count() && m.cols == 1) ||
- ((vx_size)(m.cols) == count() && m.rows == 1)
- )) throw WrapperError(std::string(__func__) + "(): source size is wrong");
- if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): source type is wrong");
- copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr());
- }
- #endif //IVX_USE_OPENCV
- };
- /*
- * Pyramid
- */
- class Pyramid : public RefWrapper<vx_pyramid>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Pyramid)
- static Pyramid create(vx_context context, vx_size levels, vx_float32 scale,
- vx_uint32 width, vx_uint32 height, vx_df_image format)
- {return Pyramid(vxCreatePyramid(context, levels, scale, width, height, format));}
- static Pyramid createVirtual(vx_graph graph, vx_size levels, vx_float32 scale,
- vx_uint32 width, vx_uint32 height, vx_df_image format)
- {return Pyramid(vxCreateVirtualPyramid(graph, levels, scale, width, height, format));}
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_PYRAMID_LEVELS = VX_PYRAMID_ATTRIBUTE_LEVELS,
- VX_PYRAMID_SCALE = VX_PYRAMID_ATTRIBUTE_SCALE,
- VX_PYRAMID_WIDTH = VX_PYRAMID_ATTRIBUTE_WIDTH,
- VX_PYRAMID_HEIGHT = VX_PYRAMID_ATTRIBUTE_HEIGHT,
- VX_PYRAMID_FORMAT = VX_PYRAMID_ATTRIBUTE_FORMAT;
- #endif
- template<typename T>
- void query(vx_enum att, T& value) const
- { IVX_CHECK_STATUS( vxQueryPyramid(ref, att, &value, sizeof(value)) ); }
- vx_size levels() const
- {
- vx_size l;
- query(VX_PYRAMID_LEVELS, l);
- return l;
- }
- vx_float32 scale() const
- {
- vx_float32 s;
- query(VX_PYRAMID_SCALE, s);
- return s;
- }
- vx_uint32 width() const
- {
- vx_uint32 v;
- query(VX_PYRAMID_WIDTH, v);
- return v;
- }
- vx_uint32 height() const
- {
- vx_uint32 v;
- query(VX_PYRAMID_HEIGHT, v);
- return v;
- }
- vx_df_image format() const
- {
- vx_df_image f;
- query(VX_PYRAMID_FORMAT, f);
- return f;
- }
- Image getLevel(vx_uint32 index)
- { return Image(vxGetPyramidLevel(ref, index)); }
- };
- /*
- * Distribution
- */
- class Distribution : public RefWrapper<vx_distribution>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Distribution);
- static Distribution create(vx_context context, vx_size numBins, vx_int32 offset, vx_uint32 range)
- {
- return Distribution(vxCreateDistribution(context, numBins, offset, range));
- }
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST,
- VX_DISTRIBUTION_DIMENSIONS = VX_DISTRIBUTION_ATTRIBUTE_DIMENSIONS,
- VX_DISTRIBUTION_OFFSET = VX_DISTRIBUTION_ATTRIBUTE_OFFSET,
- VX_DISTRIBUTION_RANGE = VX_DISTRIBUTION_ATTRIBUTE_RANGE,
- VX_DISTRIBUTION_BINS = VX_DISTRIBUTION_ATTRIBUTE_BINS,
- VX_DISTRIBUTION_WINDOW = VX_DISTRIBUTION_ATTRIBUTE_WINDOW,
- VX_DISTRIBUTION_SIZE = VX_DISTRIBUTION_ATTRIBUTE_SIZE;
- #endif
- template<typename T>
- void query(vx_enum att, T& value) const
- {
- IVX_CHECK_STATUS(vxQueryDistribution(ref, att, &value, sizeof(value)));
- }
- vx_size dimensions() const
- {
- vx_size v;
- query(VX_DISTRIBUTION_DIMENSIONS, v);
- return v;
- }
- vx_int32 offset() const
- {
- vx_int32 v;
- query(VX_DISTRIBUTION_OFFSET, v);
- return v;
- }
- vx_uint32 range() const
- {
- vx_uint32 v;
- query(VX_DISTRIBUTION_RANGE, v);
- return v;
- }
- vx_size bins() const
- {
- vx_size v;
- query(VX_DISTRIBUTION_BINS, v);
- return v;
- }
- vx_uint32 window() const
- {
- vx_uint32 v;
- query(VX_DISTRIBUTION_WINDOW, v);
- return v;
- }
- vx_size size() const
- {
- vx_size v;
- query(VX_DISTRIBUTION_SIZE, v);
- return v;
- }
- vx_size dataType() const
- {
- return VX_TYPE_UINT32;
- }
- void copyTo(void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): output pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyDistribution(ref, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- IVX_CHECK_STATUS(vxAccessDistribution(ref, &data, VX_READ_ONLY));
- IVX_CHECK_STATUS(vxCommitDistribution(ref, data));
- #endif
- }
- void copyFrom(const void* data)
- {
- if (!data) throw WrapperError(std::string(__func__) + "(): input pointer is 0");
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyDistribution(ref, const_cast<void*>(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
- #else
- IVX_CHECK_STATUS(vxAccessDistribution(ref, const_cast<void**>(&data), VX_WRITE_ONLY));
- IVX_CHECK_STATUS(vxCommitDistribution(ref, data));
- #endif
- }
- void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST)
- {
- #ifdef VX_VERSION_1_1
- IVX_CHECK_STATUS(vxCopyDistribution(ref, data, usage, memType));
- #else
- IVX_CHECK_STATUS(vxAccessDistribution(ref, const_cast<void**>(&data), usage));
- IVX_CHECK_STATUS(vxCommitDistribution(ref, data));
- (void)memType;
- #endif
- }
- template<typename T> void copyTo(std::vector<T>& data)
- {
- if (TypeToEnum<T>::value != dataType()) throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (data.size() != bins())
- {
- if (data.size() == 0)
- data.resize(bins());
- else
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- }
- copyTo(&data[0]);
- }
- template<typename T> void copyFrom(const std::vector<T>& data)
- {
- if (TypeToEnum<T>::value != dataType()) throw WrapperError(std::string(__func__) + "(): source type is wrong");
- if (data.size() != bins()) throw WrapperError(std::string(__func__) + "(): source size is wrong");
- copyFrom(&data[0]);
- }
- #ifdef IVX_USE_OPENCV
- void copyTo(cv::Mat& m)
- {
- if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): destination type is wrong");
- if (!(
- ((vx_size)(m.rows) == bins() && m.cols == 1) ||
- ((vx_size)(m.cols) == bins() && m.rows == 1)
- ) && !m.empty())
- throw WrapperError(std::string(__func__) + "(): destination size is wrong");
- if (m.isContinuous() && (vx_size)(m.total()) == bins())
- {
- copyTo(m.ptr());
- }
- else
- {
- cv::Mat tmp(1, (int)bins(), enumToCVType(dataType()));
- copyTo(tmp.ptr());
- if (m.empty())
- m = tmp;
- else
- tmp.copyTo(m);
- }
- }
- void copyFrom(const cv::Mat& m)
- {
- if (!(
- ((vx_size)(m.rows) == bins() && m.cols == 1) ||
- ((vx_size)(m.cols) == bins() && m.rows == 1)
- )) throw WrapperError(std::string(__func__) + "(): source size is wrong");
- if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): source type is wrong");
- copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr());
- }
- #endif //IVX_USE_OPENCV
- };
- /*
- * Remap
- */
- class Remap : public RefWrapper<vx_remap>
- {
- public:
- IVX_REF_STD_CTORS_AND_ASSIGNMENT(Remap);
- static Remap create(vx_context context, vx_uint32 src_width, vx_uint32 src_height, vx_uint32 dst_width, vx_uint32 dst_height)
- {
- return Remap(vxCreateRemap(context, src_width, src_height, dst_width, dst_height));
- }
- #ifndef VX_VERSION_1_1
- static const vx_enum
- VX_REMAP_SOURCE_WIDTH = VX_REMAP_ATTRIBUTE_SOURCE_WIDTH,
- VX_REMAP_SOURCE_HEIGHT = VX_REMAP_ATTRIBUTE_SOURCE_HEIGHT,
- VX_REMAP_DESTINATION_WIDTH = VX_REMAP_ATTRIBUTE_DESTINATION_WIDTH,
- VX_REMAP_DESTINATION_HEIGHT = VX_REMAP_ATTRIBUTE_DESTINATION_HEIGHT;
- #endif
- template<typename T>
- void query(vx_enum att, T& value) const
- { IVX_CHECK_STATUS(vxQueryRemap(ref, att, &value, sizeof(value))); }
- vx_uint32 srcWidth() const
- {
- vx_uint32 v;
- query(VX_REMAP_SOURCE_WIDTH, v);
- return v;
- }
- vx_uint32 srcHeight() const
- {
- vx_uint32 v;
- query(VX_REMAP_SOURCE_HEIGHT, v);
- return v;
- }
- vx_uint32 dstWidth() const
- {
- vx_uint32 v;
- query(VX_REMAP_DESTINATION_WIDTH, v);
- return v;
- }
- vx_uint32 dstHeight() const
- {
- vx_uint32 v;
- query(VX_REMAP_DESTINATION_HEIGHT, v);
- return v;
- }
- vx_uint32 srcCoordType() const
- { return VX_TYPE_FLOAT32; }
- vx_uint32 dstCoordType() const
- { return VX_TYPE_UINT32; }
- void setMapping(vx_uint32 dst_x, vx_uint32 dst_y, vx_float32 src_x, vx_float32 src_y)
- { IVX_CHECK_STATUS(vxSetRemapPoint(ref, dst_x, dst_y, src_x, src_y)); }
- void getMapping(vx_uint32 dst_x, vx_uint32 dst_y, vx_float32 &src_x, vx_float32 &src_y) const
- { IVX_CHECK_STATUS(vxGetRemapPoint(ref, dst_x, dst_y, &src_x, &src_y)); }
- #ifdef IVX_USE_OPENCV
- void setMappings(const cv::Mat& map_x, const cv::Mat& map_y)
- {
- if (map_x.type() != enumToCVType(srcCoordType()) || map_y.type() != enumToCVType(srcCoordType()))
- throw WrapperError(std::string(__func__) + "(): mapping type is wrong");
- if ((vx_uint32)(map_x.rows) != dstHeight() || (vx_uint32)(map_x.cols) != dstWidth())
- throw WrapperError(std::string(__func__) + "(): x mapping size is wrong");
- if ((vx_uint32)(map_y.rows) != dstHeight() || (vx_uint32)(map_y.cols) != dstWidth())
- throw WrapperError(std::string(__func__) + "(): y mapping size is wrong");
- for (vx_uint32 y = 0; y < dstHeight(); y++)
- {
- const vx_float32* map_x_line = map_x.ptr<vx_float32>(y);
- const vx_float32* map_y_line = map_y.ptr<vx_float32>(y);
- for (vx_uint32 x = 0; x < dstWidth(); x++)
- setMapping(x, y, map_x_line[x], map_y_line[x]);
- }
- }
- void setMappings(const cv::Mat& map)
- {
- if (map.depth() != CV_MAT_DEPTH(enumToCVType(srcCoordType())) || map.channels() != 2)
- throw WrapperError(std::string(__func__) + "(): mapping type is wrong");
- if ((vx_uint32)(map.rows) != dstHeight() || (vx_uint32)(map.cols) != dstWidth())
- throw WrapperError(std::string(__func__) + "(): x mapping size is wrong");
- for (vx_uint32 y = 0; y < dstHeight(); y++)
- {
- const vx_float32* map_line = map.ptr<vx_float32>(y);
- for (vx_uint32 x = 0; x < 2*dstWidth(); x+=2)
- setMapping(x, y, map_line[x], map_line[x+1]);
- }
- }
- void getMappings(cv::Mat& map_x, cv::Mat& map_y) const
- {
- if (map_x.type() != enumToCVType(srcCoordType()) || map_y.type() != enumToCVType(srcCoordType()))
- throw WrapperError(std::string(__func__) + "(): mapping type is wrong");
- if (((vx_uint32)(map_x.rows) != dstHeight() || (vx_uint32)(map_x.cols) != dstWidth()) && !map_x.empty())
- throw WrapperError(std::string(__func__) + "(): x mapping size is wrong");
- if (((vx_uint32)(map_y.rows) != dstHeight() || (vx_uint32)(map_y.cols) != dstWidth()) && !map_y.empty())
- throw WrapperError(std::string(__func__) + "(): y mapping size is wrong");
- if (map_x.empty())
- map_x = cv::Mat((int)dstHeight(), (int)dstWidth(), enumToCVType(srcCoordType()));
- if (map_y.empty())
- map_y = cv::Mat((int)dstHeight(), (int)dstWidth(), enumToCVType(srcCoordType()));
- for (vx_uint32 y = 0; y < dstHeight(); y++)
- {
- vx_float32* map_x_line = map_x.ptr<vx_float32>(y);
- vx_float32* map_y_line = map_y.ptr<vx_float32>(y);
- for (vx_uint32 x = 0; x < dstWidth(); x++)
- getMapping(x, y, map_x_line[x], map_y_line[x]);
- }
- }
- void getMappings(cv::Mat& map) const
- {
- if (map.depth() != CV_MAT_DEPTH(enumToCVType(srcCoordType())) || map.channels() != 2)
- throw WrapperError(std::string(__func__) + "(): mapping type is wrong");
- if (((vx_uint32)(map.rows) != dstHeight() || (vx_uint32)(map.cols) != dstWidth()) && !map.empty())
- throw WrapperError(std::string(__func__) + "(): x mapping size is wrong");
- if (map.empty())
- map = cv::Mat((int)dstHeight(), (int)dstWidth(), CV_MAKETYPE(CV_MAT_DEPTH(enumToCVType(srcCoordType())),2));
- for (vx_uint32 y = 0; y < dstHeight(); y++)
- {
- vx_float32* map_line = map.ptr<vx_float32>(y);
- for (vx_uint32 x = 0; x < 2*dstWidth(); x+=2)
- getMapping(x, y, map_line[x], map_line[x+1]);
- }
- }
- #endif //IVX_USE_OPENCV
- };
- /// Standard nodes
- namespace nodes {
- /// Creates a Gaussian Filter 3x3 Node (vxGaussian3x3Node)
- inline Node gaussian3x3(vx_graph graph, vx_image inImg, vx_image outImg)
- { return Node(vxGaussian3x3Node(graph, inImg, outImg)); }
- } // namespace nodes
- } // namespace ivx
- // restore warnings
- #if defined(_MSC_VER)
- #pragma warning(pop)
- #elif defined(__clang__)
- #pragma clang diagnostic pop
- #elif defined(__GNUC__)
- #pragma GCC diagnostic pop
- #endif // compiler macro
- #endif //IVX_HPP
|