fork download
copy 
  1. #include<opencv2/core/core.hpp>
  2. #include<opencv2/highgui/highgui.hpp>
  3. #include<iostream>
  4. #include <iostream>
  5. #include <fstream>
  6. #include <string>
  7. #include <vector>
  8. #include <cstdlib>
  9. #include <fstream>
  10. #include <windows.h>
  11. #include <stdlib.h>
  12. #include <stdio.h>
  13.  
  14. #ifdef __APPLE__
  15. #include <OpenCL/opencl.h>
  16. #else
  17. #include <CL/cl.h>
  18. #endif
  19. using namespace cv;
  20. using namespace std;
  21.  
  22.  
  23. cl_program load_program(cl_context context, const char* filename)
  24. {
  25. 	std::ifstream in(filename, std::ios_base::binary);
  26. 	if (!in.good()) {
  27. 		return 0;
  28. 	}
  29.  
  30. 	// get file length
  31. 	in.seekg(0, std::ios_base::end);
  32. 	size_t length = in.tellg();
  33. 	in.seekg(0, std::ios_base::beg);
  34.  
  35. 	// read program source
  36. 	std::vector<char> data(length + 1);
  37. 	in.read(&data[0], length);
  38. 	data[length] = 0;
  39.  
  40. 	// create and build program 
  41. 	const char* source = &data[0];
  42. 	cl_program program = clCreateProgramWithSource(context, 1, &source, 0, 0);
  43. 	if (program == 0) {
  44. 		return 0;
  45. 	}
  46.  
  47. 	if (clBuildProgram(program, 0, 0, 0, 0, 0) != CL_SUCCESS) {
  48. 		return 0;
  49. 	}
  50.  
  51. 	return program;
  52. }
  53.  
  54. /////
  55. cl_command_queue queue;
  56. cl_context context;
  57. cl_int err;
  58. cl_uint num;
  59. /////
  60. int detecDEVPLA(){
  61.  
  62. 	err = clGetPlatformIDs(0, 0, &num);
  63. 	if (err != CL_SUCCESS) {
  64. 		std::cerr << "Unable to get platforms\n";
  65. 		return 0;
  66. 	}
  67.  
  68. 	std::vector<cl_platform_id> platforms(num);
  69. 	err = clGetPlatformIDs(num, &platforms[0], &num);
  70. 	if (err != CL_SUCCESS) {
  71. 		std::cerr << "Unable to get platform ID\n";
  72. 		return 0;
  73. 	}
  74. 	cl_context_properties prop[] = { CL_CONTEXT_PLATFORM, reinterpret_cast<cl_context_properties>(platforms[0]), 0 };
  75. 	context = clCreateContextFromType(prop, CL_DEVICE_TYPE_DEFAULT, NULL, NULL, NULL);
  76. 	if (context == 0) {
  77. 		std::cerr << "Can't create OpenCL context\n";
  78. 		return 0;
  79. 	}
  80.  
  81.  
  82.  
  83. 	size_t cb;
  84. 	clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &cb);
  85. 	std::vector<cl_device_id> devices(cb / sizeof(cl_device_id));
  86. 	clGetContextInfo(context, CL_CONTEXT_DEVICES, cb, &devices[0], 0);
  87. 	clGetDeviceInfo(devices[0], CL_DEVICE_NAME, 0, NULL, &cb);
  88. 	std::string devname;
  89. 	devname.resize(cb);
  90. 	clGetDeviceInfo(devices[0], CL_DEVICE_NAME, cb, &devname[0], 0);
  91. 	std::cout << "Device: " << devname.c_str() << "\n";
  92.  
  93. 	queue = clCreateCommandQueue(context, devices[0], 0, 0);
  94. 	if (queue == 0) {
  95. 		std::cerr << "Can't create command queue\n";
  96. 		clReleaseContext(context);
  97. 		return 0;
  98. 	}
  99.  
  100. }
  101.  
  102. int main(int argc, char** argv){
  103. 	Mat image;
  104.  
  105.  
  106.  
  107. 	detecDEVPLA();		//detec device and platform
  108.  
  109.  
  110. 	char img_name[50]="";
  111.  
  112. 	strcpy(img_name,"8K.jpg");
  113. 	image = imread(img_name, CV_LOAD_IMAGE_COLOR);
  114. 	LARGE_INTEGER t1, t2, ts;
  115. 	QueryPerformanceFrequency(&ts);
  116. 	QueryPerformanceCounter(&t1);
  117.  
  118.  
  119.  
  120.  
  121. 	int DATA_SIZE = image.cols * image.rows*image.channels();
  122.  
  123.  
  124.  
  125. 	uchar *data;
  126. 	data = image.ptr<uchar>(0);
  127.  
  128.  
  129. 	cl_mem cl_data = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(cl_uchar) * DATA_SIZE, image.ptr(0), NULL);
  130. 	cl_mem cl_res = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(cl_uchar) * DATA_SIZE, NULL, NULL);
  131.  
  132.  
  133. 	if (cl_data == 0 || cl_res == 0) {
  134. 		std::cerr << "Can't create OpenCL buffer\n";
  135. 		clReleaseMemObject(cl_data);
  136. 		clReleaseMemObject(cl_res);
  137. 		clReleaseCommandQueue(queue);
  138. 		clReleaseContext(context);
  139. 		system("pause");
  140. 		return 0;
  141. 	}
  142.  
  143. 	cl_program program = load_program(context, "BGR2GRAY.cl");
  144.  
  145. 	if (program == 0) {
  146. 		std::cerr << "Can't load or build program\n";
  147. 		clReleaseMemObject(cl_data);
  148. 		clReleaseMemObject(cl_res);
  149. 		clReleaseCommandQueue(queue);
  150. 		clReleaseContext(context);
  151. 		system("pause");
  152. 		return 0;
  153. 	}
  154.  
  155. 	cl_kernel adder = clCreateKernel(program, "adder", 0);
  156. 	if (adder == 0) {
  157. 		std::cerr << "Can't load kernel\n";
  158. 		clReleaseProgram(program);
  159. 		clReleaseMemObject(cl_data);
  160. 		clReleaseMemObject(cl_res);
  161. 		clReleaseCommandQueue(queue);
  162. 		clReleaseContext(context);
  163. 		system("pause");
  164. 		return 0;
  165. 	}
  166.  
  167. 	clSetKernelArg(adder, 0, sizeof(cl_mem), &cl_data);
  168. 	clSetKernelArg(adder, 1, sizeof(cl_mem), &cl_res);
  169.  
  170. 	size_t work_item_size = DATA_SIZE / 3;
  171. 	err = clEnqueueNDRangeKernel(queue, adder, 1, 0, &work_item_size, 0, 0, 0, 0);
  172.  
  173.  
  174. 	Mat After_image = Mat::zeros(Size(image.cols, image.rows), CV_8UC3);
  175. 	uchar *GRAY;
  176. 	GRAY = After_image.ptr<uchar>(0);
  177.  
  178. 	if (err == CL_SUCCESS) {
  179. 		err = clEnqueueReadBuffer(queue, cl_res, CL_TRUE, 0, sizeof(uchar) * DATA_SIZE, After_image.ptr(0), 0, 0, 0);
  180. 	}
  181.  
  182. 	QueryPerformanceCounter(&t2);
  183. 	imshow("result", After_image);
  184. 	imwrite("GRAY_8K.jpg",After_image);
  185.  
  186. 	ofstream time_result;
  187. 	time_result.open("GPU_result_time.txt",ofstream::out|ofstream::app);
  188. 	time_result<<"GPU processing "<<img_name<<" time   :  "<<((t2.QuadPart - t1.QuadPart) / (double)(ts.QuadPart))<<" sec "<<endl;
  189. 	time_result.close();
  190.  
  191.  
  192. 	return 0;
  193. 	}
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
prog.cpp:1:32: fatal error: opencv2/core/core.hpp: No such file or directory
 #include<opencv2/core/core.hpp>
                                ^
compilation terminated.
stdout
copy 
Standard output is empty
https://ideone.com/hbnwdB
language:
C++14 (gcc 8.3)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!