| ▼Nvisioncpp | VisionCpp namespace |
| ►Ninternal | Internal implementations |
| ►Ntools | Internal tools scope |
| ►Ntuple | Contains standard layout tuple implementation |
| CEnableIf | The EnableIf struct is used to statically define type based on the condition |
| CEnableIf< true, T > | Specialisation of the EnableIf when the condition is matched |
| CTuple | The tuple is a fixed-size collection of heterogeneous values |
| CTuple< T, Ts... > | Specialisation of the Tuple class when it has at least one element |
| CElemTypeHolder | ElemTypeHolder class is used to specify the types of the elements inside the tuple |
| CElemTypeHolder< 0, Tuple< T, Ts... > > | Specialisation of the ElemTypeHolder class when the number of the elements inside the tuple is 1 |
| CElemTypeHolder< k, Tuple< T, Ts... > > | Specialisation of the ElemTypeHolder class when the number of the elements inside the tuple is bigger than 1 |
| CIndex_list | Creates a list of indices created for the elements in the tuple |
| CRangeBuilder | Specialisation of the RangeBuilder class when N!=MIN |
| CRangeBuilder< MIN, MIN, Is... > | Specialisation of the RangeBuilder when the MIN==MAX |
| CConvertor | This struct is used to convert the provide struct to flot4, uint4, int4 memory |
| CConvertor< cl::sycl::float4 > | Specialisation of Convertor when the output is float4 |
| CConvertor< cl::sycl::int4 > | Specialisation of Convertor when the output is int4 |
| CConvertor< cl::sycl::uint4 > | Specialisation of the Convertor when the output is uint4 |
| CConvertor< visioncpp::pixel::F32C3 > | Specialisation of the Convertor when the output is F32C3 |
| CConvertor< visioncpp::pixel::F32C4 > | Specialisation of the Convertor when the output is F32C4 |
| CConvertor< visioncpp::pixel::U8C3 > | Specialisation of the Convertor when the output is U8C3 |
| CConvertor< visioncpp::pixel::U8C4 > | Specialisation of the Convertor when the output is U8C4 |
| CConvertor< unsigned char > | Specialisation of the Convertor when the output is unsigned char |
| CConvertor< char > | Specialisation of the Convertor when the output is char |
| CConvertor< unsigned short > | Specialisation of the Convertor when the output is unsigned short |
| CConvertor< short > | Specialisation of the Convertor when the output is short |
| CConvertor< unsigned int > | Specialisation of the Convertor when the output is unsigned int |
| CConvertor< int > | Specialisation of the Convertor when the output is int |
| CConvertor< float > | Specialisation of the Convertor when the output is float |
| CIfNode | This struct is used to determine whether or not an expression node is a leafNode template parameters |
| CIfNode< LeafNode< Nested, LVL > > | Specialisation of the IfNode when the node is leafNode |
| CStaticIf | It is used to select either of the input type based the Conds template parameters |
| CStaticIf< false, T1, T2 > | Specialisation of the StaticIf when the condition is false |
| CIfConst | |
| CIfConst< false, X, Y > | Specialisation of the IfConst when the condition is false |
| CRemoveAll | These methods are used to remove all the & const and * from a type |
| CRemoveAll< T & > | Specialisation of RemoveAll when the type contains & |
| CRemoveAll< T * > | Specialisation of RemoveAll when the type contains * |
| CRemoveAll< const T > | Specialisation of RemoveAll when the type contains const |
| CRemoveAll< const T & > | Specialisation of RemoveAll when the type contains const and & |
| CRemoveAll< T volatile > | Specialisation of RemoveAll when the type contains volatile |
| CRemoveAll< T const volatile > | Specialisation of RemoveAll when the type contains const volatile |
| CRemoveAll< const T * > | Specialisation of RemoveAll when the type contains const and * |
| CDeviceSelector | This class is used to define different types of device for sycl |
| CDeviceSelector< device::cpu > | Specialisation of the device_selector for sycl when the device type is cpu |
| CDeviceSelector< device::gpu > | Specialisation of the device_selector for sycl when the device type is gpu |
| CDeviceSelector< device::host > | Specialisation of the device_selector for sycl when the device type is host |
| CExtractAccessor | The extract accessor struct is used to extract the accessor from the leafnodes and pack them in a tuple by using the in-order traverse algorithm on the expression tree |
| CExtractAccessor< expr_category::Unary, LeafNode< RHS, LVL > > | Specialisation of ExtractAccessor class where the expression node is LeafNode |
| CExtractAccessor< expr_category::Unary, Expr > | Specialisation of ExtractAccessor class where the expression node has one child |
| CExtractAccessor< expr_category::Binary, Expr > | Specialisation of ExtractAccessor class where the expression node has two children |
| CExtractAccessor< expr_category::Binary, Assign< LHSExpr, RHSExpr, Cols, Rows, LeafType, LVL > > | Specialisation of ExtractAccessor class where the expression node is Assign |
| CExtractAccessor< expr_category::Binary, ParallelCopy< LHSExpr, RHSExpr, Cols, Rows, OffsetColIn, OffsetRowIn, OffsetColOut, OffsetRowOut, LeafType, LVL > > | Specialisation of ExtractAccessor class where the expression node is is a ParallelCopy (partial assign) |
| CDevice_< backend::sycl, dv > | Specialisation Device_ for sycl |
| CEvaluator< internal::ops_category::GlobalNeighbourOP, OutputIndex, Offset, LC, LR, internal::Assign< LHS, RHS, Cols, Rows, LfType, LVL >, Loc, Params... > | Partial specialisation of the Evaluator when the expression is an internal::Assign expression and the internal::ops_category is GlobalNeighbourOP |
| CEvaluator< internal::ops_category::NeighbourOP, OutputIndex, Offset, LC, LR, internal::Assign< LHS, RHS, Cols, Rows, LfType, LVL >, Loc, Params... > | Partial specialisation of the Evaluator when the expression is an internal::Assign expression and the internal::ops_category is NeighbourOP |
| CEvaluator< internal::ops_category::PointOP, Output_Index, Offset, LC, LR, internal::Assign< LHS, RHS, Cols, Rows, LfType, LVL >, Loc, Params... > | Partial specialisation of the Evaluator when the expression is an internal::Assign expression and the internal::ops_category is PointOP |
| CEvaluator< ops_category::PointOP, OutputIndex, Offset, LC, LR, ParallelCopy< LHS, RHS, Cols, Rows, OffsetColIn, OffsetRowIn, OffsetColOut, OffsetRowOut, LfType, LVL >, Loc, Params... > | Partial specialisation of the Evaluator when the expression is an ParallelCopy expression and the ops_category is PointOP |
| CEvaluator< ops_category::NeighbourOP, OutputIndex, Offset, LC, LR, ParallelCopy< LHS, RHS, Cols, Rows, OffsetColIn, OffsetRowIn, OffsetColOut, OffsetRowOut, LfType, LVL >, Loc, Params... > | Partial specialisation of the Evaluator when the expression is an ParallelCopy expression and the ops_category is NeighbourOP |
| CEvaluator< ops_category::GlobalNeighbourOP, OutputIndex, Offset, LC, LR, ParallelCopy< LHS, RHS, Cols, Rows, OffsetColIn, OffsetRowIn, OffsetColOut, OffsetRowOut, LfType, LVL >, Loc, Params... > | Partial specialisation of the Evaluator when the expression is an ParallelCopy expression and the ops_category is GlobalNeighbourOP |
| CEvalExpr< Assign< LHS, RHS, Cols, Rows, LfType, LVL >, Loc, Params... > | Partial specialisation of the EvalExpr when the expression is an Assign expression |
| CEvalExpr< LeafNode< PlaceHolder< Memory_Type, N, Cols, Rows, Sc >, LVL >, Loc, Params... > | Partial specialisation of the EvalExpr when the expression is an LeafNode expression and the internal::ops_category is NeighbourOP |
| CEvalExpr< RBiOP< BI_OP, LHS, RHS, Cols, Rows, LfType, LVL >, Loc, Params... > | Partial specialisation of the EvalExpr when the expression is an RBiOP(binary operation) expression |
| CEvalExpr< RUnOP< UN_OP, Nested, Cols, Rows, LfType, LVL >, Loc, Params... > | Partial specialisation of the EvalExpr when the expression is an RUnOP(unary operation) expression |
| CEvalExpr< RDCN< C_OP, RHS, Cols, Rows, LfType, LVL >, Loc, Params... > | Partial specialisation of the EvalExpr when the expression is an RDCN(reduction operation) expression |
| CEvalExpr< StnFilt< C_OP, Halo_T, Halo_L, Halo_B, Halo_R, LHS, RHS, Cols, Rows, LfType, LVL >, Loc, Params... > | Partial specialisation of the EvalExpr when the expression is an StnFilt(stencil with filter operation) expression |
| CEvalExpr< StnNoFilt< C_OP, Halo_T, Halo_L, Halo_B, Halo_R, RHS, Cols, Rows, LfType, LVL >, Loc, Params... > | Partial specialisation of the EvalExpr when the expression is an StnNoFilt(stencil without filter operation) expression |
| CGetGlobalRange | GetGlobalRange is used to check the range when the halo is applied template parameters |
| CGetGlobalRange< 0, DimSize > | Specialisation of GetGlobalRange when the Halo is 0 |
| CFill | The Fill is used to load a rectangle neighbour area from global memory to local memory |
| CTrait | This struct is used to trait the value type inside the accessor |
| CTrait< cl::sycl::accessor< elementType, dimensions, accessMode, accessTarget > > | Specialisation of the Trait class when the accessor is sycl accessor |
| CTrait< visioncpp::internal::ConstMemory< T > > | Specialisation of the Trait class when the accessor is on ConstMemory |
| CIndex_Finder | Used to find the index required to access the accessor inside the buffer |
| CIndex_Finder< N, Indx, memory_type::Const, Sc > | Specialisation of the Index_Finder when the memory_type is a constant variable |
| CIndex_Finder< N, Indx, LeafType, scope::Constant > | Specialisation of the Index_Finder when the memory located on device constant memory |
| CEvaluator | Root of the expression tree |
| CEvalExpr | Eval_global_neighbour function: |
| COutputLocation | This is used to find whether a node should use a global memory output or a local memory output is created for that node |
| COutputLocation< true, OutOffset > | Specialisation of the OutputLocation when the node is the immediate child of the root node |
| CFill< LeafNode< PlaceHolder< memory_type::Const, N, Cols, Rows, Sc >, LVL >, Loc, Params... > | Partial specialisation of the Fill when the LeafNode contains the const variable |
| CFill< LeafNode< PlaceHolder< Memory_Type, N, Cols, Rows, scope::Constant >, LVL >, Loc, Params... > | Partial specialisation of the Fill when the LeafNode contains a sycl buffer created on constant memory |
| CFill< LeafNode< PlaceHolder< Memory_Type, N, Cols, Rows, Sc >, LVL >, Loc, Params... > | Partial specialisation of the Fill when the LeafNode contains the sycl buffer on the global memory |
| CFuseExpr | FuseExpr when the expression type is not a terminal node (leafNode) |
| CNoFuseExpr | The NoFuseExpr struct is used to generate one device kernel per each non-terminal node in the expression |
| CIfExprExecNeeded | IfExprExecNeeded is used to decide: 1) the expression should force its children to launch a separate kernel and execute the code 2) the expression should create a new subexpression tree with the result of its children execution; execute the new sub expression and return the LeafNode as a result |
| CExecutor | The Executor struct is used to specialise the execute function for different avaiable policies at compile time |
| CExecutor< policy::Fuse, LC, LR, LCT, LRT, Expr, DeviceT > | Specialisaton of Execute function when the policy is fuse |
| CExecutor< policy::NoFuse, LC, LR, LCT, LRT, Expr, DeviceT > | |
| CSubExprExecute | It is used to statically determine whether or not a subexpression execution is needed |
| CSubExprExecute< false, ExecPolicy, LC, LR, LCT, LRT, Expr, DeviceT > | Specialisation of the status of when there is no need for subexpression execution |
| CSubExprRes | The definition is in SubExprRes file |
| CSubExprRes< LC, LR, LCT, LRT, LVL1, internal::LeafNode< RHS, LVL2 >, DeviceT > | Specialisation of the SubExprRes when it is a LeafNode |
| CParentForcedExecute | To check whether or not the parent of the Expr requires that the expr to be executed and the LeafNode as a result to be returned |
| CParentForcedExecute< true, Expr, DeviceT > | Specialisation of ParentForcedExecute when the condition is true |
| CParentForcedExecute< false, Expr, DeviceT > | Specialisation of ParentForcedExecute when the condition is false |
| CIfExprExecNeeded< false, ParentConds, internal::expr_category::Unary, Expr, DeviceT > | Specialisation of the IfExprExecNeeded when the decision for executing the children of the expression is false and the expression category is unary |
| CIfExprExecNeeded< true, ParentConds, internal::expr_category::Unary, Expr, DeviceT > | Specialisation of the IfExprExecNeeded when the decision for executing the children of the expression is true and the expression category is unary |
| CIfExprExecNeeded< false, ParentConds, internal::expr_category::Binary, Expr, DeviceT > | Specialisation of the IfExprExecNeeded when the decision for executing the children of the expression is false and the expression category is binary |
| CIfExprExecNeeded< true, ParentConds, internal::expr_category::Binary, Expr, DeviceT > | Specialisation of the IfExprExecNeeded when the decision for executing the children of the expression is true and the expression category is binary |
| CFuseExpr< LC, LR, LCT, LRT, LeafNode< RHS, LVL >, DeviceT > | Specialisation of Fuse struct when the Expr is a terminal node (leafNode) |
| CNoFuseExpr< LC, LR, LCT, LRT, internal::expr_category::Unary, LeafNode< RHS, LVL >, DeviceT > | The specialisation of the NoFuseExpr for LeafNode |
| CNoFuseExpr< LC, LR, LCT, LRT, internal::expr_category::Unary, Expr, DeviceT > | The specialisation of the NoFuseExpr for Expression node with one operand |
| CNoFuseExpr< LC, LR, LCT, LRT, internal::expr_category::Binary, Expr, DeviceT > | The specialisation of the NoFuseExpr for Expression node with two operands |
| CNoFuseExpr< LC, LR, LCT, LRT, internal::expr_category::Binary, Assign< LHS, RHS, Cols, Rows, LeafType, LVL >, DeviceT > | The specialisation of the NoFuseExpr for Assign where it is a root node and has its own lhs leaf node |
| CPlaceHolder | PlaceHolder is used to replace the Vision Memory in the LeafNode containing sycl buffer |
| CLocalOutput | LocalOutput:Local output is used for neighbour operation in order to create a local memory for the output of non-terminal nodes in the expression tree when the NeighbourOP is used |
| CLeafCount | Used to count the total number of leafNode in the expression tree |
| CLocalMemCount | Used to count the total number of local memory for the subxpression |
| CMakePlaceHolderExprHelper | It is used to create the PlaceHolder expression |
| CLeafCount< expr_category::Unary, LeafNode< RHS, LVL > > | Specialisation of LeafCount when the node is a LeafNode template parameters: |
| CLeafCount< expr_category::Unary, Expr > | Specialisation of LeafCount when the node has one child template parameters: |
| CLeafCount< expr_category::Binary, Expr > | Specialisation of LeafCount when the node has two children template parameters: |
| CLocalMemCount< expr_category::Unary, LeafNode< PlaceHolder< memory_type::Const, N, Cols, Rows, scope::Global >, LVL > > | Partial specialisation of the LocalmemCount when the LeafNode contains the const variable |
| CLocalMemCount< expr_category::Unary, LeafNode< PlaceHolder< MemoryType, N, Cols, Rows, scope::Constant >, LVL > > | Partial specialisation of the LocalmemCount when the LeafNode contains a sycl buffer created on constant memory |
| CLocalMemCount< expr_category::Unary, LeafNode< RHSExpr, LVL > > | Specialisation of LocalmemCount when the node is a LeafNode template parameters: |
| CLocalMemCount< expr_category::Unary, Expr > | Template parameters: |
| CLocalMemCount< expr_category::Binary, Expr > | Specialisation of LocalmemCount when the node has two children template parameters: |
| CLocalMemCount< expr_category::Binary, Assign< LHSExpr, RHSExpr, Cols, Rows, LeafType, LVL > > | Specialisation of ExtractAccessor class where the expression node is Assign |
| CLocalMemCount< expr_category::Binary, ParallelCopy< LHSExpr, RHSExpr, Cols, Rows, OffsetColIn, OffsetRowIn, OffsetColOut, OffsetRowOut, LeafType, LVL > > | Specialisation of ExtractAccessor class where the expression node is is ParallelCopy (partial assign) |
| COutputAccessor | OutputAccessor struct is used to generate an accessor when the node is not root |
| COutputAccessor< false, LeafType, LC, LR, OutType > | Specialisation of OutputAccessor when a node is not a root node |
| CLocalOutput< false, IsRoot, LC, LR, LeafNode< VisionMemory< in, element_category, memory_type::Const, Sclr, Width, Height, Sclr, 1, scope::Global, LVL >, LVL > > | Specialisation of the LocalOutput for leaf node when the vision memory is a const variable |
| CLocalOutput< false, IsRoot, LC, LR, LeafNode< VisionMemory< in, element_category, Memory_Type, Scalar, Width, Height, ElementTp, Elements, scope::Constant, LVL >, LVL > > | Specialisation of the LocalOutput for leaf node when the vision memory is a constant buffer |
| CLocalOutput< false, IsRoot, LC, LR, LeafNode< RHS, LVL > > | LocalOutput specialisation for leaf node it creates the local accessor that contains the data of the leaf node from global memory |
| CLocalOutput< false, IsRoot, LC, LR, RUnOP< OP, RHSExpr, Cols, Rows, LeafType, LVL > > | LocalOutput specialisation for unary operation(RUnOP) it creates the local accessor to store the output of unary operation which is going to be used as an output for its parent |
| CLocalOutput< false, IsRoot, LC, LR, RBiOP< OP, LHSExpr, RHSExpr, Cols, Rows, LeafType, LVL > > | LocalOutput specialisation for binary operation(RBiOP) it creates the local accessor to store the output of binary operation which is going to be used as an output for its parent |
| CLocalOutput< false, IsRoot, LC, LR, StnFilt< OP, Halo_T, Halo_L, Halo_B, Halo_R, LHSExpr, RHSExpr, Cols, Rows, LeafType, LVL > > | LocalOutput specialisation for binary neighbour operation(StnFilt) |
| CLocalOutput< false, IsRoot, LC, LR, StnNoFilt< OP, Halo_T, Halo_L, Halo_B, Halo_R, RHSExpr, Cols, Rows, LeafType, LVL > > | LocalOutput specialisation for unary neighbour operation(StnNoFilt) |
| CLocalOutput< false, IsRoot, LC, LR, RDCN< OP, RHSExpr, Cols, Rows, LeafType, LVL > > | LocalOutput specialisation for reduction neighbour operation(RDCN) |
| CLocalOutput< false, IsRoot, LC, LR, ParallelCopy< LHSExpr, RHSExpr, Cols, Rows, OffsetColIn, OffsetRowIn, OffsetColOut, OffsetRowOut, LeafType, LVL > > | LocalOutput specialisation for point operation(ParallelCopy) |
| CLocalOutput< false, IsRoot, LC, LR, Assign< LHSExpr, RHSExpr, Cols, Rows, LeafType, LVL > > | LocalOutput specialisation for point operation(Assign) |
| CMakePlaceHolderExprHelper< internal::expr_category::Unary, LeafNode< RHS, LVL >, N > | Specialisation of MakePlaceHolderExprHelper where the node is leaf node |
| CMakePlaceHolderExprHelper< internal::expr_category::Unary, Expr, N > | Specialisation of MakePlaceHolderExprHelper where the operation of the node is unary (the node has one child) |
| CMakePlaceHolderExprHelper< internal::expr_category::Binary, Expr, N > | Specialisation of MakePlaceHolderExprHelper where the operation of the node is binary (the node has two children) |
| CLeafNode< PlaceHolder< Memory_Type, N, C, R, Sc >, LVL > | The specialisation of LeafNode for the PlaceHolder |
| CCreatePyramidTupleType | CreatePyramidTupleType: This file is used to create each output element type for each downsampling output of the pyramid memory |
| CCreatePyramidTuple | CreatePyramidTuple |
| CPyramidLeafNode | |
| CCreatePyramidTupleType< true, Cols, Rows, LeafType, Depth, CurrentDepth, LHS, ChildType... > | Specialisation of the CreatePyramidTupleType when the SatisfyingConds is true |
| CCreatePyramidTuple< true, Cols, Rows, LeafType, Depth, CurrentDepth, LHS > | Specialisation of the CreatePyramidTuple when the SatisfyingConds is true |
| CPyramidExecuteAutoMemGen | Here we execute the pyramid; automatically construct the output tuple based on the depth of the pyramid; and construct the kernels |
| CPyramidExecuteAutoMemGen< true, Fltr2DOP, DownSmplOP, Cols, Rows, LeafType, OffsetCol, OffsetRow, LVL, LC, LR, LCT, LRT, Depth, CurrentDepth, LHS, RHS, Fltr2D, PyramidMem, DeviceT > | Specialisation of the PyramidExecuteAutoMemGen when the SatisfyingConds is true |
| CPyramidAutomemGen | PyramidDownGen is used to construct a pyramid node in the expression tree with general Filter2D and general DownSmplOP functors |
| CPyramidExecuteAutoMemSep | Here we execute the pyramid; automatically construct the output tuple based on the depth of the pyramid; and construct the kernels |
| CPyramidExecuteAutoMemSep< true, SepFltrColOP, SepFltrRowOP, DownSmplOP, Cols, Rows, LeafType, OffsetCol, OffsetRow, LVL, LC, LR, LCT, LRT, Depth, CurrentDepth, LHS, RHS, SepFilterCol, SepFilterRow, PyramidMem, DeviceT > | Specialisation of the PyramidExecuteAutoMemSep when the SatisfyingConds is true |
| CPyramidAutomemSep | PyramidAutomemSep is used to construct a pyramid node in the expression tree with two separable Filter for row and column and general DownSmplOP functors |
| CGlobalUnaryOp | This class is used to encapsulate the global unary functor and the types of each operand in this functor |
| CLocalUnaryOp | This class is used to encapsulate the local unary functor and the types of each operand in this functor |
| CLocalBinaryOp | This class is used to encapsulate the local binary functor and the types of each operand in this functor |
| CPixelUnaryOp | This class is used to encapsulate the unary point operation functor and the types of each operand in this functor |
| CPixelBinaryOp | This class is used to encapsulate the binary point operation functor and the types of each operand in this functor |
| CRDCN | The definition is in RDCN file |
| CStnNoFilt | The definition is in StnNoFilt file |
| CStnFilt | The definition is in StnFilt file |
| CAssign | The definition is in Assign file |
| CLeafNode | Definition is in LeafNode |
| CParallelCopy | The definition is in ParallelCopy file |
| CInheritTypeBinary | This struct is used to extract the output type of the binary operation from both input |
| COpTP | This struct is used to determine the operation type for binary operation based on the operation type of its children |
| COpTP< false, internal::ops_category::PointOP, RhsOP > | Specialisation of the PointOP category where the two operation types are not equal and the lhs operation type is PointOp |
| COpTP< false, LhsOP, internal::ops_category::PointOP > | Specialisation of the PointOP category where the two operation types are not equal and the rhs operation type is PointOp |
| COpTP< true, OPType, OPType > | Specialisation of the PointOP category where the two operation types are equal |
| CRBiOP | The definition is in RBiOP file |
| CRUnOP | The definition is in RUnOP file |
| CDevice_ | Class used to implement the execution of the expression tree |
| CVirtualMemory | Definition is in VirtualMemory |
| CConstMemory | The definition can be found in ConstMemory |
| CMemoryProperties | This file is used to detect the ChannelType ElementCategory {basic or struct}, and the channel size of a row input data |
| CMemoryProperties< unsigned char > | Specialisation of the MemoryProperties when the output is unsigned char |
| CMemoryProperties< char > | Specialisation of the MemoryProperties when the output is char |
| CMemoryProperties< unsigned short > | Specialisation of the MemoryProperties when the output is unsigned short |
| CMemoryProperties< short > | Specialisation of the MemoryProperties when the output is short |
| CMemoryProperties< unsigned int > | Specialisation of the MemoryProperties when the output is unsigned int |
| CMemoryProperties< int > | Specialisation of the MemoryProperties when the output is int |
| CMemoryProperties< float > | Specialisation of the MemoryProperties when the output is float |
| CVisionMemory | Definition of VisionMemory |
| COutputMemory | OutputMemory is used to deduce the output type of each node in the expression tree by using certain parameters from its child(ren) |
| CImageProperties | This file is used to create the image properties required to create opencl image for different types of pixel |
| CSyclRange | This is used to determine the range for creating a syclbuffer based on the memory dimension template parameters: |
| CSyclRange< 2 > | Specialisation of the SyclRange when the dimension is 2 |
| CSyclRange< 1 > | Specialisation of the SyclRange when the dimension is 1 |
| CSyclScope | Determines the memory target on the device based on the memory type and suggested target |
| CSyclScope< LeafType, scope::Global > | |
| CSyclScope< LeafType, scope::Host_Buffer > | |
| CSyclScope< LeafType, scope::Local > | |
| CSyclScope< LeafType, scope::Constant > | |
| CSyclScope< memory_type::Image, scope::Global > | Specialisation of the SyclScope when the memory type is Image |
| CConvertToVisionScope | This struct is used to convert the sycl target to visioncpp target |
| CConvertToVisionScope< cl::sycl::access::target::global_buffer > | Specialisation of ConvertToVisionScope where the target is global_buffer |
| CConvertToVisionScope< cl::sycl::access::target::host_buffer > | Specialisation of ConvertToVisionScope where the target is host_buffer |
| CConvertToVisionScope< cl::sycl::access::target::local > | Specialisation of ConvertToVisionScope where the target is local |
| CConvertToVisionScope< cl::sycl::access::target::constant_buffer > | Specialisation of ConvertToVisionScope where the target is constant_buffer |
| CConvertToVisionScope< cl::sycl::access::target::image > | Specialisation of ConvertToVisionScope where the target is image |
| CSyclAccessor | This struct is used to create a sycl accessor type based on access mode; dimension and memory type |
| CSyclAccessor< memory_type::Image, Dim, AccMd, ElementType, Scalar, scope > | Specialisation of the SyclAccessor when the memory_type is Image |
| CSyclAccessor< memory_type::Const, Dim, AccMd, ElementType, Scalar, scope > | Specialisation of the SyclAccessor when the memory_type is constant variable |
| CSyclMem | SyclMem is used to create VisionMemory data storage |
| CSyclMem< true, LeafType, Dim, ElementType > | Specialisation of SyclMem when there is host memory allocated |
| CSyclMem< false, LeafType, Dim, ElementType > | Specialisation of SyclMem when there is no host memory allocated |
| CSyclMem< true, memory_type::Image, Dim, ElementType > | Specialisation of SyclMem when the memory_type is Image |
| CSyclMem< true, memory_type::Const, Dim, ElementType > | Specialisation of SyclMem when the memory_type is Constant variable |
| CSyclMem< false, memory_type::Image, Dim, ElementType > | Specialisation of the SyclMem when the memory_type is Image and no device pointer is allocated to the memory |
| CMemDimension | This is used to determine the dimension of the memory based on the memory type template parameters: |
| CMemDimension< memory_type::Buffer1D > | Specialisation of the MemDimension when the memory type is Buffer1D |
| CMemDimension< memory_type::Host > | Specialisation of the MemDimension when the memory type is Host |
| CMemDimension< memory_type::Const > | Specialisation of the MemDimension when the memory type is constant variable |
| CCreateSyclBuffer | This class is used to instantiate the sycl memory based on the memory types |
| CCreateSyclBuffer< memory_type::Image, ElemType, Scalar, VisionMem, RNG > | Specialisation of create CreateSyclBuffer when the memory type is image |
| CCreateSyclBuffer< memory_type::Const, ElemType, Scalar, VisionMem, RNG > | Specialisation of create CreateSyclBuffer when the memory type is constant variable |
| CBufferUpdate | This is used to update the Vision Memory with new value update sycl buffer at the moment we use ptr.reset() because it was faster than getting the host pointer and updating it in the host side |
| CBufferUpdate< memory_type::Image, Rows, Cols, ElemType, Scalar, VisionMem > | Specialisation of the BufferUpdate when the memory_type is Image |
| CBufferUpdate< memory_type::Const, Rows, Cols, ElemType, Scalar, VisionMem > | Specialisation of the BufferUpdate when the memory_type is Constant variable |
| CCoordinate | Coordinate is used to specify local/global offset for local/global access to the local/global memory for each thread on the device |
| CLocalNeighbour | LocalNeighbour is used to provide local access for each element of the local memory based on the Coordinate passed by eval expression |
| CGlobalNeighbour | GlobalNeighbour is used to provide local access for each element of the global memory based on the Coordinate passed by eval expression |
| CConstNeighbour | ConstNeighbour is used to provide global access to the constant memory |
| CCompareIdBasedScope | This is used for range check to make sure the index is within the range |
| CCompareIdBasedScope< false, LDSize, GDSize, T > | Specialisation of the CompareIdBasedScope when the Conds is false in this case the range check is with the global size template parameters: |
| CGetIdBasedScope | Brief This is used to get the correct Id based on the condition |
| CGetIdBasedScope< false, T > | Specialisation of the GetIdBasedScope when the condition is false |
| CMemoryTrait | This class is used to determine the ElementType of accessor template parameters |
| CMemoryTrait< memory_type::Host, T > | Specialisation of MemoryTrait when the LeafType is Host |
| CAssignValueToArray | |
| CAssignValueToArray< false, K, PixelType, Params... > | |
| ►Npixel | Contains VisionCpp pixel type definitions |
| CStorage | |
| COP_BGRToRGB | This functor reorders channels BGR to RGB |
| COP_F32C3ToU8C3 | This functor performs conversion from [0.0f, 1.0f] to [0, 255] |
| COP_HSVToRGB | Functor converts HSV(H:[0.0f, 360.f], S:[0.0f, 1.0f] V: [0.0f, 1.0f]) to color RGB(R:[0.0f, 1.0f], G:[0.0f, 1.0f], B:[0.0f, 1.0f]) |
| COP_HSVToU8C3 | This functor allows displaying HSV |
| COP_RGBToBGR | This functor reorders channels BGR to RGB |
| COP_RGBToGREY | This functor performs RGB to GREY convertion following rule: GREY <- 0.299f * R + 0,587f * G + 0.114 * B |
| COP_RGBToHSV | Functor converts RGB ( R: 0.0f..1.0f, G: 0.0f..1.0f, B: 0.0f..1.0f) to HSV ( H: 0.0f..360.f, S: 0.0f..1.0f V: 0.0f..1.0f ) color space |
| COP_U8C3ToF32C3 | This functor performs conversion from [0, 255] to [0.0f, 1.0f] |
| COP_Filter2D | Applying the general convolution for 3 channel Image |
| COP_Filter2D_One | Applying the general convolution for 1 channel Image |
| COP_GaussianBlur3x3 | Applying the Gaussian blur 3x3 |
| COP_SepFilterRow | Separable filter for rows |
| COP_SepFilterCol | Separable filter for cols |
| COP_SepGaussRow3 | Separable filter for rows |
| COP_SepGaussCol3 | Separable filter for cols |
| COP_DownsampleAverage | Downsampling filter using average technique Other filters could be added for different numbers of channels |
| COP_DownsampleClosest | Downsampling filter using closest technique |
| COP_AbsSub | This functor uses the sycl::fabs to return the difference |
| COP_Add | This functor adds two pixels |
| COP_AniDiff_Grey | This functor applies anisotropic diffusion for one channel |
| COP_AniDiff | This functor applies anisotropic diffusion for 3 channels |
| COP_Div | This functor divides two matrices element-wise |
| COP_FloatToF32C3 | It replicates one channel to 3 channels |
| COP_FloatToU8C1 | It converts float to uchar converting [0.0f, 1.0f] to [0, 255] |
| COP_U8C1ToFloat | It converts uchar to float converting range [0, 255] to [0.0f, 1.0f] |
| COP_FloatToUChar | It converts float to uchar |
| COP_Median | This functor implements a median filter |
| COP_Merge2Chns | This functor merges 2 matrices into one matrix of 2 channels |
| COP_Mul | This functor implements an element-wise matrix multiplication |
| COP_PowerOf2 | This functor implements the power of 2 of one matrix |
| COP_Scale | Scales the pixel value of an image by a factor |
| COP_Sub | This functor subtracts 2 images |
| COP_Thresh | Implements a binary threshold |
| COP_Broadcast | This functor sets the pixel to the value passed in |
| COP_ScaleChannelZero | This custom functor changes 0 channel by factor passed via float f |
| COP_ScaleChannelOne | This custom functor changes 1 channel by factor passed via float f |
| COP_ScaleChannelTwo | This custom functor changes 2 channel by factor passed via float f |
| COP_CVBGRToRGB | This node is a utility node that does a conversion from cv::Mat ( unsigned char storage; channel order BGR ) to float with order of RGB normalise from opencv format to VisionCpp internal format [0, 255] to [0.0f, 1.0f] |
| COP_RGBToCVBGR | This node is a utility node that does a conversion from float with order of RGB to cv::Mat ( unsigned char storage; channel order BGR ) denormalise from VisionCpp base format ( F32C3 ) to opencv 8UC3 (three channel unsigned char) |
| COP_GREYToCVBGR | Float between [0.0f, 1.0f] to [0, 255] One channel GREY ( float ) is going to be converted to one channel cv::Mat |
| Cbackend | Enum class that defines supported backends |
| Cdevice | Enum class that defines supported devices types |
| CF32C1 | This struct is generalisation for three channels float that is perfect for storing pixels of R |
| CF32C2 | This struct is generalisation for three channels float that is perfect for storing pixels of RG and permutations |
| CF32C3 | This struct is generalisation for three channels float that is perfect for storing pixels of RGB and permutations |
| CF32C4 | This struct is generalisation for three channels float that is perfect for storing pixels of RGBA and permutations |
| CU8C1 | This struct is generalisation for three channels float that is perfect for storing pixels of R |
| CU8C2 | This struct is generalisation for three channels unsigned char that is perfect for storing pixels of RG and permutations |
| CU8C3 | This struct is generalisation for three channels unsigned char that is perfect for storing pixels of RGB and permutations |
| CU8C4 | This struct is generalisation for three channels unsigned char that is perfect for storing pixels of RGBA and permutations |
