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(float) * <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 18444 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< 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(float) * <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 18565 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 18660 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 18756 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 18862 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< 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(float) * <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 18983 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 19078 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 19174 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 19280 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< 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(float) * <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 19401 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 19496 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 19592 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 19698 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 19819 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 19914 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 20010 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 20116 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 20237 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 20332 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 20428 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 20534 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 20655 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 20750 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 20846 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 20952 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 21073 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 21168 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 21264 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 21370 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 21491 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 21586 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 21682 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 21788 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 21909 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 22004 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 22100 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 22206 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 22327 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 22422 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 22518 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 22624 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 22745 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 22840 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 22936 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 23042 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 23163 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 23258 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 23354 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 23460 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 23581 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 23676 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 23772 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 23878 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 23999 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 24094 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 24190 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 24296 of file ros_opencl.cpp.
| std::vector< float > ros_opencl::ROS_OpenCL::process | ( | const std::vector< float > | 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(float) * <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 24417 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 24512 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 24608 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< float > * | 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(float) * <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 24714 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 24835 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 24930 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 25026 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 25132 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 25253 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 25348 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 25444 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 25550 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 25671 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 25766 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 25862 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 25968 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 26089 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 26184 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 26280 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 26386 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 26507 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 26602 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 26698 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 26804 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 26925 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 27020 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 27116 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 27222 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 27343 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 27438 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 27534 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 27640 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 27761 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 27856 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 27952 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 28058 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 28179 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 28274 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 28370 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 28476 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 28597 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 28692 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 28788 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 28894 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 29015 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 29110 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 29206 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 29312 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 29433 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 29528 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 29624 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 29730 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 29851 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 29946 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 30042 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 30148 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 30269 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 30364 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 30460 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 30566 of file ros_opencl.cpp.
| std::vector< double > ros_opencl::ROS_OpenCL::process | ( | const std::vector< double > | 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(double) * <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 30687 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 30782 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | 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(double) * <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 30878 of file ros_opencl.cpp.
| void ros_opencl::ROS_OpenCL::process | ( | std::vector< double > * | v, |
| std::vector< double > * | v2, | ||
| std::vector< float > * | v3, | ||
| const ROS_OpenCL_Params * | params = NULL |
||
| ) |
The function that initiates kernel processing.