C++ opencv2找错

opencv2找错  原来是参数位置没对齐。

#include "windows.h"
#include<iostream>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cuda_runtime.h>
#include <cuda.h>
#include <cuComplex.h>
#include <time.h>
#include<math.h>
#include <opencv2/opencv.hpp>

#include<fstream>
#ifdef __APPLE__
#include <OpenCL/opencl.h>
#else
#include <stdlib.h>
#include <CL/cl.h>
#endif
#include <clFFT.h>
using namespace std;
using namespace cv;

int main()
{
	Mat src1W = imread("none2.bmp", 0);
	if (src1W.empty())
	{
		cout << "读取图片错误，请确定目录下是否有imread函数指定图片存在~！\n" << endl;
		return -1;
	}
	imshow("无样品", src1W);

	//waitKey(0);
	Mat src3W = src1W(Rect(463, 169, 256, 256));
	src3W.convertTo(src3W, CV_64FC1);
	imshow("无样品1", src3W / 255);
	//waitKey(0);

	Mat src6;
	src6.convertTo(src6, CV_64FC1);
	cv::copyMakeBorder(src3W, src6, 0, 0, 0, 0, BORDER_CONSTANT, Scalar::all(0));
	imshow("ROItest1", src6 / 255);

	//waitKey(0);
	Mat src1D = imread("celiang2.bmp", 0);
	if (src1D.empty())
	{
		cout << "读取图片错误，请确定目录下是否有imread函数指定图片存在~！\n" << endl;
		return -1;
	}
	imshow("有样品", src1D);
	Mat src4W = src1D(Rect(463, 169, 256, 256));
	src4W.convertTo(src4W, CV_64FC1);
	imshow("有样品1", src4W / 255);

	Mat src6W;
	src6W.convertTo(src6W, CV_64FC1);
	cv::copyMakeBorder(src4W, src6W, 0, 0, 0, 0, BORDER_CONSTANT, Scalar::all(0));
	imshow("ROItest2", src6W / 255);
	Mat frame(src6.size(), CV_64FC1);
	int Width = frame.cols;
	int Height = frame.rows;
	Mat C1(frame.size(), CV_64FC2);
	Mat F(frame.size(), CV_64FC1);
	Mat F_re1(frame.size(), CV_64FC1);
	Mat dest(frame.size(), CV_64FC2);
	Mat B_im1(frame.size(), CV_64FC1, Scalar::all(0));
	Mat B_re1(frame.size(), CV_64FC1);
	Mat B_re2(frame.size(), CV_64FC1);
	Mat B_im2(frame.size(), CV_64FC1, Scalar::all(0));
	B_re1 = src6.clone();
	Mat value[2] = { B_re1,B_im1 };
	Mat B1;
	merge(value, 2, B1);
	B_re2 = src6W.clone();
	Mat value1[2] = { B_re2,B_im2 };
	Mat B2;
	merge(value1, 2, B2);
	cl_int err;
	cl_platform_id platform = 0;
	cl_device_id device = 0;
	cl_context_properties props[3] = { CL_CONTEXT_PLATFORM, 0, 0 };
	cl_context ctx = 0;
	cl_command_queue queue = 0;
	//cl_mem bufX;
	err = clGetPlatformIDs(1, &platform, NULL);
	err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL);
	props[1] = (cl_context_properties)platform;
	ctx = clCreateContext(props, 1, &device, NULL, NULL, &err);
	queue = clCreateCommandQueue(ctx, device, 0, &err);

	clfftSetupData fftSetup;
	err = clfftInitSetupData(&fftSetup);
	err = clfftSetup(&fftSetup);
	cl_mem B1_dev = NULL;  
	cl_mem A1_dev = NULL;
	B1_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	A1_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, B1_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), B1.data, 0, NULL, NULL);
	clfftPlanHandle planHandle;
	clfftDim dim = CLFFT_2D;
	size_t clLengths[2] = { (size_t)B1.cols,(size_t)B1.rows };
	err = clfftCreateDefaultPlan(&planHandle, ctx, dim, clLengths);
	err = clfftSetPlanPrecision(planHandle, CLFFT_DOUBLE);
	err = clfftSetLayout(planHandle, CLFFT_COMPLEX_INTERLEAVED, CLFFT_COMPLEX_INTERLEAVED);
	err = clfftSetResultLocation(planHandle, CLFFT_OUTOFPLACE);
	err = clfftBakePlan(planHandle, 1, &queue, NULL, NULL);
	err = clfftEnqueueTransform(planHandle, CLFFT_FORWARD, 1, &queue, 0, NULL, NULL, &B1_dev, &A1_dev, NULL);
	Mat result(frame.size(), CV_64FC2);
	clEnqueueReadBuffer(queue, A1_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), result.data, 0, NULL, NULL);
	cl_mem B2_dev = NULL;  
	cl_mem A2_dev = NULL;
	B2_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	A2_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, B2_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), B2.data, 0, NULL, NULL);
	double time1 = static_cast<double>(getTickCount());
	err = clfftEnqueueTransform(planHandle, CLFFT_FORWARD, 1, &queue, 0, NULL, NULL, &B2_dev, &A2_dev, NULL);
	time1 = ((double)getTickCount() - time1) * 1000 / getTickFrequency();
	cout << "此方法运行时间为：" << time1 << "ms" << endl;
	Mat result1(frame.size(), CV_64FC2);
	clEnqueueReadBuffer(queue, A2_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), result1.data, 0, NULL, NULL);
	
	std::ifstream kernelFile("sourse.cl", std::ios::in);
	std::ostringstream oss;
	oss << kernelFile.rdbuf();
	std::string srcStdStr = oss.str();
	const char* srcStr = srcStdStr.c_str();
	cl_program program = clCreateProgramWithSource(ctx, 1, (const char**)&srcStr, NULL, &err);
	err = clBuildProgram(program, 1, &device, NULL, NULL, NULL);
	cl_kernel kernel = clCreateKernel(program, "GPU_Zhengjiao", NULL);
	cl_mem des = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, src, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), result.data, 0, NULL, NULL);
	clSetKernelArg(kernel, 0, sizeof(cl_mem), &des);
	clSetKernelArg(kernel, 1, sizeof(cl_mem), &src);
	clSetKernelArg(kernel, 2, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel, 3, sizeof(int), (void*)&Width);
	size_t globalWorkSize[2] = { frame.rows, frame.cols };
	clEnqueueNDRangeKernel(queue, kernel, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat A11(frame.size(), CV_64FC2);
	err = clEnqueueReadBuffer(queue, des, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), A11.data, 0, NULL, NULL);

	cl_kernel kernel1 = clCreateKernel(program, "GPU_Zhengjiao", NULL);
	cl_mem des22 = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src22 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, src22, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), result1.data, 0, NULL, NULL);
	clSetKernelArg(kernel1, 0, sizeof(cl_mem), &des22);
	clSetKernelArg(kernel1, 1, sizeof(cl_mem), &src22);
	clSetKernelArg(kernel1, 2, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel1, 3, sizeof(int), (void*)&Width);
	clEnqueueNDRangeKernel(queue, kernel1, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat A22(frame.size(), CV_64FC2);
	err = clEnqueueReadBuffer(queue, des22, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), A22.data, 0, NULL, NULL);

	for (int i = 0; i < frame.rows; i++)
	{
		for (int j = 0; j < frame.cols; j++)
		{
			if ((i >= 97 && i < 160) && (j >= 147 && j < 190))
			{
				F_re1.at<double>(i, j) = 1;
			}
			else
			{
				F_re1.at<double>(i, j) = 0;
			}
		}
	}
	//F1圆形滤波器
	F = F_re1;
	imshow("矩形滤波器", F);
	
	err = clBuildProgram(program, 1, &device, NULL, NULL, NULL);
	cl_kernel kernel2 = clCreateKernel(program, "GPU_JvZhenDianCheng", NULL);
	cl_mem des_src = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src1 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src2 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	clEnqueueWriteBuffer(queue, src1, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), A11.data, 0, NULL, NULL);
	clEnqueueWriteBuffer(queue, src2, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), F.data, 0, NULL, NULL);
	clSetKernelArg(kernel2, 0, sizeof(cl_mem), &des_src);
	clSetKernelArg(kernel2, 1, sizeof(cl_mem), &src1);
	clSetKernelArg(kernel2, 2, sizeof(cl_mem), &src2);
	clSetKernelArg(kernel2, 3, sizeof(int), &frame.cols);
	clSetKernelArg(kernel2, 4, sizeof(int), &frame.rows);
	clEnqueueNDRangeKernel(queue, kernel2, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat SPA1(frame.size(), CV_64FC2);
	err = clEnqueueReadBuffer(queue, des_src, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), SPA1.data, 0, NULL, NULL);

	cl_kernel kernel3 = clCreateKernel(program, "GPU_JvZhenDianCheng", NULL);
	cl_mem des_src1 = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src15 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src25 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	clEnqueueWriteBuffer(queue, src15, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), A22.data, 0, NULL, NULL);
	clEnqueueWriteBuffer(queue, src25, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), F.data, 0, NULL, NULL);
	clSetKernelArg(kernel3, 0, sizeof(cl_mem), &des_src1);
	clSetKernelArg(kernel3, 1, sizeof(cl_mem), &src15);
	clSetKernelArg(kernel3, 2, sizeof(cl_mem), &src25);
	clSetKernelArg(kernel3, 3, sizeof(int), &frame.cols);
	clSetKernelArg(kernel3, 4, sizeof(int), &frame.rows);
	clEnqueueNDRangeKernel(queue, kernel3, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat SPB1(frame.size(), CV_64FC2);
	err = clEnqueueReadBuffer(queue, des_src1, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), SPB1.data, 0, NULL, NULL);

	cl_kernel kernel4 = clCreateKernel(program, "GPU_Zhengjiao", NULL);
	cl_mem dre = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src11 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, src11, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), SPA1.data, 0, NULL, NULL);
	clSetKernelArg(kernel4, 0, sizeof(cl_mem), &dre);
	clSetKernelArg(kernel4, 1, sizeof(cl_mem), &src11);
	clSetKernelArg(kernel4, 2, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel4, 3, sizeof(int), (void*)&Width);
	clEnqueueNDRangeKernel(queue, kernel4, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat A14(frame.size(), CV_64FC2);
	err = clEnqueueReadBuffer(queue, dre, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), A14.data, 0, NULL, NULL);

	cl_kernel kernel5 = clCreateKernel(program, "GPU_Zhengjiao", NULL);
	cl_mem dre33 = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src33 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, src33, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), SPB1.data, 0, NULL, NULL);
	clSetKernelArg(kernel5, 0, sizeof(cl_mem), &dre33);
	clSetKernelArg(kernel5, 1, sizeof(cl_mem), &src33);
	clSetKernelArg(kernel5, 2, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel5, 3, sizeof(int), (void*)&Width);
	clEnqueueNDRangeKernel(queue, kernel5, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat A44(frame.size(), CV_64FC2);
	err = clEnqueueReadBuffer(queue, dre33, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), A44.data, 0, NULL, NULL);

	cl_mem imageA1_dev = NULL;  
	cl_mem A11_dev = NULL;
	imageA1_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	A11_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, A11_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), A14.data, 0, NULL, NULL);
	err = clfftEnqueueTransform(planHandle, CLFFT_BACKWARD, 1, &queue, 0, NULL, NULL, &A11_dev, &imageA1_dev, NULL);
	Mat imageA1(frame.size(), CV_64FC2);
	clEnqueueReadBuffer(queue, imageA1_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), imageA1.data, 0, NULL, NULL);
	
	cl_mem imageB1_dev = NULL;  
	cl_mem A55_dev = NULL;
	imageB1_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	A55_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, A55_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), A44.data, 0, NULL, NULL);
	err = clfftEnqueueTransform(planHandle, CLFFT_BACKWARD, 1, &queue, 0, NULL, NULL, &A55_dev, &imageB1_dev, NULL);
	Mat imageB1(frame.size(), CV_64FC2);
	clEnqueueReadBuffer(queue, imageB1_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), imageB1.data, 0, NULL, NULL);
	err = clfftDestroyPlan(&planHandle);
	clfftTeardown();
	clReleaseMemObject(B1_dev);
	clReleaseMemObject(A1_dev);
	clReleaseMemObject(B2_dev);
	clReleaseMemObject(A2_dev);
	clReleaseMemObject(A11_dev);
	clReleaseMemObject(imageA1_dev);
	clReleaseMemObject(A55_dev);
	clReleaseMemObject(imageB1_dev);
	
	cl_kernel kernel6 = clCreateKernel(program, "GPU_DianChu", NULL);
	cl_mem des_src11 = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src16 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	cl_mem src26 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	clEnqueueWriteBuffer(queue, src16, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), imageB1.data, 0, NULL, NULL);
	clEnqueueWriteBuffer(queue, src26, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), imageA1.data, 0, NULL, NULL);
	clSetKernelArg(kernel6, 0, sizeof(cl_mem), &des_src11);
	clSetKernelArg(kernel6, 1, sizeof(cl_mem), &src16);
	clSetKernelArg(kernel6, 2, sizeof(cl_mem), &src26);
	clSetKernelArg(kernel6, 3, sizeof(int), &frame.cols);
	clSetKernelArg(kernel6, 4, sizeof(int), &frame.rows);
	clEnqueueNDRangeKernel(queue, kernel6, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat res1(frame.size(), CV_64FC2);
	err = clEnqueueReadBuffer(queue, des_src11, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), res1.data, 0, NULL, NULL);

	cl_kernel kernel7 = clCreateKernel(program, "GPU_atan", NULL);
	cl_mem res1_phase_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem src88 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(cl_double2), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, src88, CL_TRUE, 0, frame.rows * frame.cols * sizeof(cl_double2), res1.data, 0, NULL, NULL);
	clSetKernelArg(kernel7, 0, sizeof(cl_mem), &res1_phase_dev);
	clSetKernelArg(kernel7, 1, sizeof(cl_mem), &src88);
	clSetKernelArg(kernel7, 2, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel7, 3, sizeof(int), (void*)&Width);
	clEnqueueNDRangeKernel(queue, kernel7, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat phase(frame.size(), CV_64FC1);
	err = clEnqueueReadBuffer(queue, res1_phase_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), phase.data, 0, NULL, NULL);
	imshow("wrappedphase", phase);

	cl_kernel kernel8 = clCreateKernel(program, "dxanddy_OpenCL", NULL);
	cl_mem dstx_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem dsty_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem src_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, src_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), phase.data, 0, NULL, NULL);
	clSetKernelArg(kernel8, 0, sizeof(cl_mem), &dstx_dev);
	clSetKernelArg(kernel8, 1, sizeof(cl_mem), &dsty_dev);
	clSetKernelArg(kernel8, 2, sizeof(cl_mem), &src_dev);
	clSetKernelArg(kernel8, 3, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel8, 4, sizeof(int), (void*)&Width);
	clEnqueueNDRangeKernel(queue, kernel8, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat dstx(frame.size(), CV_64FC1);
	Mat dsty(frame.size(), CV_64FC1);
	err = clEnqueueReadBuffer(queue, dstx_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dstx.data, 0, NULL, NULL);
	err = clEnqueueReadBuffer(queue, dsty_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dsty.data, 0, NULL, NULL);

	cl_kernel kernel9 = clCreateKernel(program, "tmpsndderivative_OpenCL", NULL);
	cl_mem dstxx_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem dstyy_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem srcx_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem srcy_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, srcx_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dstx.data, 0, NULL, NULL);
	err = clEnqueueWriteBuffer(queue, srcy_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dsty.data, 0, NULL, NULL);
	clSetKernelArg(kernel9, 0, sizeof(cl_mem), &dstxx_dev);
	clSetKernelArg(kernel9, 1, sizeof(cl_mem), &dstyy_dev);
	clSetKernelArg(kernel9, 2, sizeof(cl_mem), &srcx_dev);
	clSetKernelArg(kernel9, 3, sizeof(cl_mem), &srcy_dev);
	clSetKernelArg(kernel9, 4, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel9, 5, sizeof(int), (void*)&Width);
	clEnqueueNDRangeKernel(queue, kernel9, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat dstxx(frame.size(), CV_64FC1);
	Mat dstyy(frame.size(), CV_64FC1);
	err = clEnqueueReadBuffer(queue, dstxx_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dstxx.data, 0, NULL, NULL);
	err = clEnqueueReadBuffer(queue, dstyy_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dstyy.data, 0, NULL, NULL);
	
	cl_kernel kernel10 = clCreateKernel(program, "gmpsndderivative_OpenCL", NULL);
	cl_mem dstxx4_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem dstyy4_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem srcxx_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem srcyy_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem dstp_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, dstxx4_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dstxx.data, 0, NULL, NULL);
	err = clEnqueueWriteBuffer(queue, dstyy4_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dstyy.data, 0, NULL, NULL);
	err = clEnqueueWriteBuffer(queue, srcxx_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dstx.data, 0, NULL, NULL);
	err = clEnqueueWriteBuffer(queue, srcyy_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dsty.data, 0, NULL, NULL);
	clSetKernelArg(kernel10, 0, sizeof(cl_mem), &dstxx4_dev);
	clSetKernelArg(kernel10, 1, sizeof(cl_mem), &dstyy4_dev);
	clSetKernelArg(kernel10, 0, sizeof(cl_mem), &srcxx_dev);
	clSetKernelArg(kernel10, 1, sizeof(cl_mem), &srcyy_dev);
	clSetKernelArg(kernel10, 2, sizeof(cl_mem), &dstp_dev);
	clSetKernelArg(kernel10, 3, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel10, 4, sizeof(int), (void*)&Width);
	clEnqueueNDRangeKernel(queue, kernel10, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat dst(frame.size(), CV_64FC1);
	err = clEnqueueReadBuffer(queue, dstp_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dst.data, 0, NULL, NULL);

	for (int i = 0; i < phase.rows; i++) {
		for (int j = 0; j < phase.cols; j++) {
			cout << "result(" << i << "," << j << "): " << dstyy.ptr<double>(i)[j] << endl;
		}
	}
	
	

	/*cl_kernel kernel11 = clCreateKernel(program, "GetAMAndAMT_OpenCL", NULL);
	cl_mem A_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem AT_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	clSetKernelArg(kernel11, 0, sizeof(cl_mem), &A_dev);
	clSetKernelArg(kernel11, 1, sizeof(cl_mem), &AT_dev);
	clSetKernelArg(kernel11, 2, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel11, 3, sizeof(int), (void*)&Width);
	clEnqueueNDRangeKernel(queue, kernel11, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat A(frame.size(), CV_64FC1);
	Mat AT(frame.size(), CV_64FC1);
	err = clEnqueueReadBuffer(queue, A_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), A.data, 0, NULL, NULL);
	err = clEnqueueReadBuffer(queue, AT_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), AT.data, 0, NULL, NULL);
	
	cl_kernel kernel12 = clCreateKernel(program, "LINETRANS_OpenCL", NULL);
	cl_mem dst44_dev = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem src55_dev = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	err = clEnqueueWriteBuffer(queue, src55_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), dstxx.data, 0, NULL, NULL);
	clSetKernelArg(kernel12, 0, sizeof(cl_mem), &dst44_dev);
	clSetKernelArg(kernel12, 1, sizeof(cl_mem), &src55_dev);
	clSetKernelArg(kernel12, 2, sizeof(int), (void*)&Height);
	clSetKernelArg(kernel12, 3, sizeof(int), (void*)&Width);
	clEnqueueNDRangeKernel(queue, kernel12, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat D(frame.size(), CV_64FC1);
	err = clEnqueueReadBuffer(queue, dst44_dev, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double),D.data, 0, NULL, NULL);*/



	/*cl_kernel kernel13 = clCreateKernel(program, "matrixMulOpenCL", NULL);
	cl_mem des_src18 = clCreateBuffer(ctx, CL_MEM_READ_WRITE, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem src17 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	cl_mem src27 = clCreateBuffer(ctx, CL_MEM_READ_ONLY, frame.rows * frame.cols * sizeof(double), NULL, NULL);
	clEnqueueWriteBuffer(queue, src17, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), A.data, 0, NULL, NULL);
	clEnqueueWriteBuffer(queue, src27, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), D.data, 0, NULL, NULL);
	clSetKernelArg(kernel13, 0, sizeof(cl_mem), &des_src18);
	clSetKernelArg(kernel13, 1, sizeof(cl_mem), &src17);
	clSetKernelArg(kernel13, 2, sizeof(cl_mem), &src27);
	clSetKernelArg(kernel13, 3, sizeof(int), &frame.cols);
	clSetKernelArg(kernel13, 4, sizeof(int), &frame.rows);
	clEnqueueNDRangeKernel(queue, kernel13, 2, NULL, globalWorkSize, NULL, 0, NULL, NULL);
	Mat res145(frame.size(), CV_64FC1);
	err = clEnqueueReadBuffer(queue, des_src18, CL_TRUE, 0, frame.rows * frame.cols * sizeof(double), res145.data, 0, NULL, NULL);*/
	

	
	/*for (int i = 0; i < A11.rows; i++) {
		for (int j = 0; j < A11.cols; j++) {
			cout << "result(" << i << "," << j << "): " << res1.ptr<cv::Vec2d>(i)[j][0] << " + " << res1.ptr<cv::Vec2d>(i)[j][1] << "i" << endl;
		}
	}*/
	/*ofstream Fs("D:\\test10.xls");
		if (!Fs.is_open())
		{
			cout << "error!" << endl;
			return 0;
		}

		int height = F.rows;
		int width =F.cols;
		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
			{
				Fs << AT.ptr<double>(i)[j] << '\t';
			}
			Fs << endl;
		}
		Fs.close();*/
	/*ofstream Fs("D:\\test9.xls");
	if (!Fs.is_open())
	{
		cout << "error!" << endl;
		return 0;
	}

	int height = result.rows;
	int width = result.cols;
	for (int i = 0; i < height; i++)
	{
		for (int j = 0; j < width; j++)
		{
			Fs << result.ptr<cv::Vec2d>(i)[j][0] << " + " << result.ptr<cv::Vec2d>(i)[j][1] << "i" << '\t';
		}
		Fs << endl;
	}
	Fs.close();*/
	waitKey(0);
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.kler.cn/a/273283.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Css提高——Css3的新增选择器

Css提高——Css3的新增选择器

目录 1、Css3新增选择器列举 2、属性选择器 2.1、语法 2.2、代码&#xff1a; 2.3、效果图 3、结构伪类选择器 3.1、语法 3.2、代码 3.3、效果图 3.4、nth&#xff1a;child&#xff08;n&#xff09;的用法拓展 nth-child&#xff08;n&#xff09;与nth-of-type&#x…
阅读更多...
mac npm install 很慢或报错

mac npm install 很慢或报错

npm ERR! code CERT_HAS_EXPIRED npm ERR! errno CERT_HAS_EXPIRED npm ERR! request to https://registry.npm.taobao.org/pnpm failed, reason: certificate has expired 1、取消ssl验证&#xff1a; npm config set strict-ssl false 修改后一般就可以了&#xff0c;…
阅读更多...
Nadaraya-Watson核回归

Nadaraya-Watson核回归

目录 基本原理 ​编辑 核函数的选择 带宽的选择 特点 应用 与注意力机制的关系 参考内容 在统计学中&#xff0c;核回归是一种估计随机变量的条件期望的非参数技术。目标是找到一对随机变量 X 和 Y 之间的非线性关系。 在任何非参数回归中&#xff0c;变量 Y 相对于变量…
阅读更多...
nvm安装和使用保姆级教程（详细）

nvm安装和使用保姆级教程（详细）

一、 nvm是什么 &#xff1a; nvm全英文也叫node.js version management&#xff0c;是一个nodejs的版本管理工具。nvm和npm都是node.js版本管理工具&#xff0c;为了解决node.js各种版本存在不兼容现象可以通过它可以安装和切换不同版本的node.js。 二、卸载之前安装的node: …
阅读更多...
微服务技术栈SpringCloud+RabbitMQ+Docker+Redis+搜索+分布式（五）：分布式搜索 ES-下

微服务技术栈SpringCloud+RabbitMQ+Docker+Redis+搜索+分布式（五）：分布式搜索 ES-下

文章目录 一、数据聚合1.1 聚合种类1.2 DSL实现聚合1.3 RestAPI实现聚合1.4 演示&#xff1a;多条件聚合 二、自动补全2.1 拼音分词器2.2 自定义分词器2.3 DSL自动补全查询2.5 实现酒店搜索框自动补全2.5.1 修改酒店索引库数据结构2.5.2 RestAPI实现自动补全查询2.5.3 实战 三、…
阅读更多...
Kafka：分布式消息队列

Kafka：分布式消息队列

1. 简介 介绍 Kafka 的概述、优势和劣势&#xff0c;以及应用场景。 2. 基本概念 2.1 架构 一个典型的 Kafka 体系架构包括若干 Producer、若干Broker、若干 Consumer&#xff0c;以及一个ZooKeeper集群。 ZooKeeper是Kafka用来负责集群元数据的管理、控制器的选举等操作的…
阅读更多...
【2023蓝桥杯】刷题笔记（C语言）

【2023蓝桥杯】刷题笔记（C语言）

1、字符串包含最多的字符及其个数 #include<stdio.h> int main() {int i;char arr[1000] { 0 };//定义字符串数组arr&#xff0c;初始化为0gets(arr);//从键盘输入字符串给arr// printf("%s\n",arr);//输出字符串数组// for(i0;i<5;i){// printf("%…
阅读更多...
关于 闰年 的小知识，为什么这样判断闰年

关于 闰年 的小知识，为什么这样判断闰年

闰年的规定&#xff1a; 知道了由来&#xff0c;我们就可以写程序来判断&#xff1a; #include <stdio.h> int main() {int year, leap;scanf("%d",&year);if((year%4 0 && year%100 ! 0) || year%400 0)leap 1;else leap 0;if(leap) printf(…
阅读更多...
centos破解root密码以及如何防止他人破解root密码

centos破解root密码以及如何防止他人破解root密码

目录 破解root密码 服务器重启 1.再重启页面上下选择第一个按e进入内核编辑模式 2.找到linux16开头的一行&#xff0c;光标移动到最后添加 init/bin/sh Ctrlx 保存 3.进入单用户模式 4.重新挂在根分区 5.关闭selinux 6.更新密码 passwd 7.在根分区下面创建一个隐藏文件…
阅读更多...
【设计模式】-工厂模式

【设计模式】-工厂模式

工厂模式是一种创建型设计模式&#xff0c;它提供了一种在不指定具体类的情况下创建对象的方法。工厂模式的核心思想是将对象的创建与使用分离&#xff0c;降低系统的耦合度&#xff0c;使系统更加灵活、可扩展。 工厂模式主要分为三种类型&#xff1a;简单工厂模式、工厂方法…
阅读更多...
CLIP解读

CLIP解读

1、引言 在计算机视觉领域&#xff0c;通常需要经过训练模型来实现对预定类别目标预测&#xff08;如分类、检测等任务&#xff09;&#xff0c;但是这种形式会限制模型的通用性。比如我们训练完了一个猫狗分类模型&#xff0c;如果现在希望识别一只老虎&#xff0c;那么原来训…
阅读更多...
Java基础-lambda表达式

Java基础-lambda表达式

lambda表达式 前言前置知识λ小故事函数式编程起源: λ演算法 概念Lambda && 匿名类无参类型的简写带参函数的简写 简写的依据自定义函数接口lambda && 匿名类JVM层面区别匿名内部类实现Lambda表达式实现推论,this引用的意义 lambda && 集合 前言 函数…
阅读更多...
C++_day6：继承、多态

C++_day6：继承、多态

1.封装一个动物的基类&#xff0c;类中有私有成员&#xff1a;姓名&#xff0c;颜色&#xff0c;指针成员年纪 再封装一个狗这样类&#xff0c;共有继承于动物类&#xff0c;自己拓展的私有成员有&#xff1a;指针成员&#xff1a;腿的个数&#xff08;整型 int count&#xf…
阅读更多...
arcgis 点连接到面（以地级市图层为例）

arcgis 点连接到面（以地级市图层为例）

地级市图层进行“点到面”的连接&#xff0c;并输出 在点击地级市图层&#xff0c;右击——连接和关联——连接 选择基于空间位置的另一图层数据&#xff0c;文件选择上面输出并添加的图层文件&#xff0c;进行“点到面”的连接&#xff0c;可依据新需求选择平均值&#xff0c…
阅读更多...
upload-labs-pass01

upload-labs-pass01

1.安装好环境进入关卡&#xff08;记得打开小皮&#xff09; 2.可以看到第一关是要求上传图片&#xff0c;但是同时限制了图片类型&#xff0c;那么如果我们将木马写入图片&#xff0c;但是类型又不在白名单&#xff0c;就要想办法绕过 3.可以看到这里的要求是有check&#xff…
阅读更多...
1.中医学习-总论

1.中医学习-总论

目录 1.为什么要学中医 2.什么是中医 介绍 中医例子1&#xff1a; 中医例子2: 中医最高境界“大道至简” 中医讲究的是本质 中医核心&#xff1a;阴阳、表里、寒热、虚实 ​编辑医不叩门 3.阴阳 1.一天中的阴阳 2.一年中的阴阳 3.阴阳之间的关系 4.阴阳四季的变化 …
阅读更多...
使用exe4j将java项目打包为exe文件（包含普通maven项目打jar包）

使用exe4j将java项目打包为exe文件（包含普通maven项目打jar包）

目录 背景实操普通maven项目打jar包手动构建修改pom文件 使用exe4j工具官网下载配置 注意事项&#xff08;锦囊&#xff09;jdk11没有jre文件夹生成独立的jre文件夹&#x1f302;经雨者&#xff0c;愿为人遮风挡雨&#xff08;jdk11直接生成的jre不行&#xff09;指定环境 过程…
阅读更多...
PostgreSQL中vacuum 物理文件truncate发生的条件

PostgreSQL中vacuum 物理文件truncate发生的条件

与我联系&#xff1a; 微信公众号&#xff1a;数据库杂记 个人微信: iiihero 我是iihero. 也可以叫我Sean. iiheroCSDN(https://blog.csdn.net/iihero) Sean墨天轮 (https://www.modb.pro/u/16258) 数据库领域的资深爱好者一枚。 水木早期数据库论坛发起人 db2smth就是俺&am…
阅读更多...
牛客题霸-SQL入门篇（刷题记录二）

牛客题霸-SQL入门篇（刷题记录二）

本文基于前段时间学习总结的 MySQL 相关的查询语法&#xff0c;在牛客网找了相应的 MySQL 题目进行练习&#xff0c;以便加强对于 MySQL 查询语法的理解和应用。 以下内容是牛客题霸-SQL入门篇剩余的第 21-39 道题目的 SQL 代码答案。 由于涉及到的数据库表较多&#xff0c;因…
阅读更多...
通过调整报文偏移解决CAN应用报文丢帧或周期过长问题

通过调整报文偏移解决CAN应用报文丢帧或周期过长问题

偏移原理 报文很多都是周期性发送的&#xff0c;但是如果每条报文都以一开始作为开始计时的时间点&#xff0c;也就是一开始就发送第一条报文&#xff0c;可能会导致CAN堵塞&#xff0c;导致丢帧或者某些报文某一时刻周期过长&#xff0c;就像下图这样&#xff0c;同一时刻CAN…
阅读更多...
最新文章

Copyright @ 2022~2023