| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 5798 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< char > * | v2, | ||
| std::vector< float > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(char) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 5904 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< char > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(char) * <input v2 size> and typeof(double) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6025 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< char > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(char) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6120 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< char > * | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(char) * <input v2 size>. The size of the write only buffer is typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6216 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< char > * | v2, | ||
| std::vector< double > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(char) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6322 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< int > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(int) * <input v2 size> and typeof(char) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6443 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< int > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(int) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6538 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< int > * | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(int) * <input v2 size>. The size of the write only buffer is typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6634 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< int > * | v2, | ||
| std::vector< char > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(int) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6740 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< int > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(int) * <input v2 size> and typeof(int) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6861 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< int > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(int) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 6956 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< int > * | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(int) * <input v2 size>. The size of the write only buffer is typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7052 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< int > * | v2, | ||
| std::vector< int > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(int) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7158 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< int > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(int) * <input v2 size> and typeof(float) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7279 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< int > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(int) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7374 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< int > * | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(int) * <input v2 size>. The size of the write only buffer is typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7470 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< int > * | v2, | ||
| std::vector< float > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(int) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7576 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< int > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(int) * <input v2 size> and typeof(double) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7697 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< int > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(int) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7792 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< int > * | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(int) * <input v2 size>. The size of the write only buffer is typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7888 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< int > * | v2, | ||
| std::vector< double > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(int) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 7994 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< float > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(float) * <input v2 size> and typeof(char) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 8115 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< float > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(float) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 8210 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< float > * | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(float) * <input v2 size>. The size of the write only buffer is typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 8306 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< float > * | v2, | ||
| std::vector< char > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(float) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 8412 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< float > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(float) * <input v2 size> and typeof(int) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 8533 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< float > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(float) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 8628 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< float > * | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(float) * <input v2 size>. The size of the write only buffer is typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 8724 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< float > * | v2, | ||
| std::vector< int > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(float) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 8830 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< float > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(float) * <input v2 size> and typeof(float) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 8951 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< float > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(float) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9046 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< float > * | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(float) * <input v2 size>. The size of the write only buffer is typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9142 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< float > * | v2, | ||
| std::vector< float > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(float) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9248 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< float > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(float) * <input v2 size> and typeof(double) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9369 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< float > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(float) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9464 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< float > * | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(float) * <input v2 size>. The size of the write only buffer is typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9560 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< float > * | v2, | ||
| std::vector< double > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(float) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9666 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< double > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(double) * <input v2 size> and typeof(char) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9787 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< double > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(double) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9882 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< double > * | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(double) * <input v2 size>. The size of the write only buffer is typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 9978 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< double > * | v2, | ||
| std::vector< char > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(double) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 10084 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< double > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(double) * <input v2 size> and typeof(int) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 10205 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< double > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(double) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 10300 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< double > * | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(double) * <input v2 size>. The size of the write only buffer is typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 10396 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< double > * | v2, | ||
| std::vector< int > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(double) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 10502 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< double > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(double) * <input v2 size> and typeof(float) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 10623 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< double > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(double) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 10718 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< double > * | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(double) * <input v2 size>. The size of the write only buffer is typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 10814 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< double > * | v2, | ||
| std::vector< float > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(double) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 10920 of file ros_opencl.cpp.
| std::vector< char > ros_opencl::ROS_OpenCL::process | ( | const std::vector< char > | v, |
| const std::vector< double > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers are typeof(double) * <input v2 size> and typeof(double) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11041 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| const std::vector< double > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(char) * <input v size>. The size of the write only buffers is typeof(double) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11136 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< double > * | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size> and typeof(double) * <input v2 size>. The size of the write only buffer is typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11232 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< char > * | v, |
| std::vector< double > * | v2, | ||
| std::vector< double > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(char) * <input v size>, typeof(double) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11338 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< char > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(char) * <input v2 size> and typeof(char) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11459 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< char > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(char) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11554 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< char > * | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(char) * <input v2 size>. The size of the write only buffer is typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11650 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< char > * | v2, | ||
| std::vector< char > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(char) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11756 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< char > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(char) * <input v2 size> and typeof(int) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11877 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< char > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(char) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 11972 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< char > * | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(char) * <input v2 size>. The size of the write only buffer is typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 12068 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< char > * | v2, | ||
| std::vector< int > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(char) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 12174 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< char > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(char) * <input v2 size> and typeof(float) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 12295 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< char > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(char) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 12390 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< char > * | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(char) * <input v2 size>. The size of the write only buffer is typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 12486 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< char > * | v2, | ||
| std::vector< float > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(char) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 12592 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< char > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(char) * <input v2 size> and typeof(double) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 12713 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< char > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(char) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 12808 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< char > * | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(char) * <input v2 size>. The size of the write only buffer is typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 12904 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< char > * | v2, | ||
| std::vector< double > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(char) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13010 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< int > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(int) * <input v2 size> and typeof(char) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13131 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< int > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(int) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13226 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< int > * | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(int) * <input v2 size>. The size of the write only buffer is typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13322 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< int > * | v2, | ||
| std::vector< char > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(int) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13428 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< int > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(int) * <input v2 size> and typeof(int) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13549 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< int > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(int) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13644 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< int > * | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(int) * <input v2 size>. The size of the write only buffer is typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13740 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< int > * | v2, | ||
| std::vector< int > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(int) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13846 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< int > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(int) * <input v2 size> and typeof(float) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 13967 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< int > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(int) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14062 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< int > * | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(int) * <input v2 size>. The size of the write only buffer is typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14158 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< int > * | v2, | ||
| std::vector< float > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(int) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14264 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< int > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(int) * <input v2 size> and typeof(double) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14385 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< int > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(int) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14480 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< int > * | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(int) * <input v2 size>. The size of the write only buffer is typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14576 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< int > * | v2, | ||
| std::vector< double > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(int) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14682 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< float > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(float) * <input v2 size> and typeof(char) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14803 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< float > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(float) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14898 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< float > * | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(float) * <input v2 size>. The size of the write only buffer is typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 14994 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< float > * | v2, | ||
| std::vector< char > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(float) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 15100 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< float > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(float) * <input v2 size> and typeof(int) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 15221 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< float > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(float) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 15316 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< float > * | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(float) * <input v2 size>. The size of the write only buffer is typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 15412 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< float > * | v2, | ||
| std::vector< int > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(float) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 15518 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< float > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(float) * <input v2 size> and typeof(float) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 15639 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< float > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(float) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 15734 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< float > * | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(float) * <input v2 size>. The size of the write only buffer is typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 15830 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< float > * | v2, | ||
| std::vector< float > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(float) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 15936 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< float > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(float) * <input v2 size> and typeof(double) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16057 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< float > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(float) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16152 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< float > * | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(float) * <input v2 size>. The size of the write only buffer is typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16248 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< float > * | v2, | ||
| std::vector< double > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(float) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16354 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< double > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(double) * <input v2 size> and typeof(char) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16475 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< double > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(double) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16570 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< double > * | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(double) * <input v2 size>. The size of the write only buffer is typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16666 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< double > * | v2, | ||
| std::vector< char > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(double) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16772 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< double > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(double) * <input v2 size> and typeof(int) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16893 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< double > | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(double) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 16988 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< double > * | v2, | ||
| const std::vector< int > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(double) * <input v2 size>. The size of the write only buffer is typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 17084 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< double > * | v2, | ||
| std::vector< int > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(double) * <input v2 size> and typeof(int) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 17190 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< double > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(double) * <input v2 size> and typeof(float) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 17311 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< double > | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(double) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 17406 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< double > * | v2, | ||
| const std::vector< float > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(double) * <input v2 size>. The size of the write only buffer is typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 17502 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< double > * | v2, | ||
| std::vector< float > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(double) * <input v2 size> and typeof(float) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 17608 of file ros_opencl.cpp.
| std::vector< int > ros_opencl::ROS_OpenCL::process | ( | const std::vector< int > | v, |
| const std::vector< double > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers are typeof(double) * <input v2 size> and typeof(double) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 17729 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| const std::vector< double > | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(int) * <input v size>. The size of the write only buffers is typeof(double) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 17824 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< double > * | v2, | ||
| const std::vector< double > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size> and typeof(double) * <input v2 size>. The size of the write only buffer is typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 17920 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< int > * | v, |
| std::vector< double > * | v2, | ||
| std::vector< double > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first, second and third vector. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(int) * <input v size>, typeof(double) * <input v2 size> and typeof(double) * <input v3 size>. Changes made inside the kernel are overwritten on all three vectors.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 18026 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | v, |
| const std::vector< char > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(float) * <input v size>. The size of the write only buffers are typeof(char) * <input v2 size> and typeof(char) * <input v3 size>.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 18147 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | v, |
| const std::vector< char > | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first vector and a write only buffer for the second and third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffer is typeof(float) * <input v size>. The size of the write only buffers is typeof(char) * <input v2 size> and typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten only on v.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 18242 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | v, |
| std::vector< char > * | v2, | ||
| const std::vector< char > | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.
It uses a read/write buffer to send and receive data from the kernel for the first and second vector and a write only buffer for the third. The global work size used by default, matches the size of the first input vector. The size of the read/write buffers is typeof(float) * <input v size> and typeof(char) * <input v2 size>. The size of the write only buffer is typeof(char) * <input v3 size>. Changes made inside the kernel are overwritten on both v and v2 respectively.
| v | The input data. |
| v2 | Secondary input data. Could be a small set of complementary values, or a full-scale dataset to be compared with v. |
| v3 | Extra input data. Could be a small set of complementary values, or a full-scale dataset. |
| params | optional A ROS_OpenCL_Params object that includes the following params:
|
Definition at line 18338 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | v, |
| std::vector< char > * | v2, | ||
| std::vector< char > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.