void checkOpenCL() { DevicesInfo devices; getOpenCLDevices(devices); for (size_t i = 0; i < devices.size(); i++) { const DeviceInfo *info = devices[i]; printf("%s : %s\nMax Compute unit:%d\n%s\n%s", info->deviceName.c_str(), info->deviceVersion.c_str(), info->maxComputeUnits, info->compilationExtraOptions.c_str(), info->deviceExtensions.c_str()); } }
void checkOpenCL() { PlatformsInfo platforms; getOpenCLPlatforms(platforms); for (size_t p = 0; p < platforms.size(); p++) { DevicesInfo devices; getOpenCLDevices(devices, CVCL_DEVICE_TYPE_GPU, platforms[p]); for (size_t i = 0; i < devices.size(); i++) { const DeviceInfo *info = devices[i]; printf("%s : %s\n", info->deviceName.c_str(), info->deviceVersion.c_str()); } } }
matches im_utility::diff(const std::string &im_file1, const std::string &im_file2, const parameters ¶ms, key_points *im1_kps, key_points *im2_kps) { using namespace cv; matches mt; std::vector<KeyPoint> im1_key_points, im2_key_points; std::vector<DMatch> matches; std::vector<DMatch> good_matches; double min_hessian = 400.0; if (params.find(key_hessian_threshold) != params.end()) min_hessian = params.at(key_hessian_threshold); double sigma = 2.0; if (params.find(key_match_threshold) != params.end()) sigma = params.at(key_match_threshold); int speedup = speedup_default; if (params.find(key_speedup) != params.end()) speedup = params.at(key_speedup); //auto info = getBuildInformation(); if (speedup == speedup_use_cuda) { using namespace gpu; DeviceInfo dev; auto name = dev.name(); GpuMat img1, img2; // upload data img1.upload(imread(im_file1, CV_LOAD_IMAGE_GRAYSCALE)); img2.upload(imread(im_file2, CV_LOAD_IMAGE_GRAYSCALE)); // detect keypoints & computing descriptors SURF_GPU surf; GpuMat kps_gpu1, kps_gpu2; GpuMat desc_gpu1, desc_gpu2; surf(img1, GpuMat(), kps_gpu1, desc_gpu1); surf(img2, GpuMat(), kps_gpu2, desc_gpu2); // matching descriptors BFMatcher_GPU matcher_gpu(NORM_L2); GpuMat trainIdx, distance; matcher_gpu.matchSingle(desc_gpu1, desc_gpu2, trainIdx, distance); // download results std::vector<float> desc1, desc2; surf.downloadKeypoints(kps_gpu1, im1_key_points); surf.downloadKeypoints(kps_gpu2, im2_key_points); surf.downloadDescriptors(desc_gpu1, desc1); surf.downloadDescriptors(desc_gpu2, desc2); BFMatcher_GPU::matchDownload(trainIdx, distance, matches); good_matches = matches; } else if (speedup == speedup_use_ocl) { using namespace ocl; DevicesInfo devs; getOpenCLDevices(devs, CVCL_DEVICE_TYPE_GPU); int dev = 0; if (params.find(key_ocl_dev) != params.end()) dev = params.at(key_ocl_dev); if (dev < 0 || dev >= devs.size()) dev = 0; setDevice(devs[dev]); SURF_OCL surf(800.0); BFMatcher_OCL matcher(NORM_L2); oclMat desc1, desc2; oclMat im1, im2; im1 = imread(im_file1, CV_LOAD_IMAGE_GRAYSCALE); im2 = imread(im_file2, CV_LOAD_IMAGE_GRAYSCALE); surf(im1, oclMat(), im1_key_points, desc1); surf(im2, oclMat(), im2_key_points, desc2); matcher.match(desc1, desc2, matches); double max_dist = 0; double min_dist = 100; for (int i = 0; i < desc1.rows; i++) { double dist = matches[i].distance; if (dist < min_dist) min_dist = dist; if (dist > max_dist) max_dist = dist; } for (int i = 0; i < desc1.rows; i++) { if (matches[i].distance <= max(sigma * min_dist, 0.02)) { good_matches.push_back(matches[i]); } } } else { auto get_file_desc = [](const std::string &filename, double min_hessian, std::vector<cv::KeyPoint> *out_key_points) { using namespace cv; Mat desc; Mat img = imread(filename, CV_LOAD_IMAGE_GRAYSCALE); if (!img.data) return desc; SurfFeatureDetector detecter(min_hessian); std::vector<KeyPoint> key_points; detecter.detect(img, key_points); if (out_key_points) *out_key_points = key_points; if (key_points.empty()) { std::cout << "no feature detected: " << filename << std::endl; return desc; } SurfDescriptorExtractor extractor; extractor.compute(img, key_points, desc); return desc; }; auto im1_desc = get_file_desc(im_file1, min_hessian, &im1_key_points); auto im2_desc = get_file_desc(im_file2, min_hessian, &im2_key_points); FlannBasedMatcher matcher; matcher.match(im1_desc, im2_desc, matches); double max_dist = 0; double min_dist = 100; for (int i = 0; i < im1_desc.rows; i++) { double dist = matches[i].distance; if (dist < min_dist) min_dist = dist; if (dist > max_dist) max_dist = dist; } for (int i = 0; i < im1_desc.rows; i++) { if (matches[i].distance <= max(sigma * min_dist, 0.02)) { good_matches.push_back(matches[i]); } } } auto conv_keypoint = [](const std::vector<KeyPoint> &kps) { key_points out; std::transform(kps.begin(), kps.end(), std::back_inserter(out), [](const KeyPoint &kp){ //return key_point{ kp.pt.x, kp.pt.y, kp.size, kp.angle }; key_point p; p.x = kp.pt.x; p.y = kp.pt.y; p.size = kp.size; p.angle = kp.angle; return p; }); return out; }; auto kps1 = conv_keypoint(im1_key_points); auto kps2 = conv_keypoint(im2_key_points); if (im1_kps) *im1_kps = kps1; if (im2_kps) *im2_kps = kps2; std::transform(good_matches.begin(), good_matches.end(), std::back_inserter(mt), [&](const DMatch &m) { //return match{ kps1[m.queryIdx] , kps2[m.trainIdx] , m.distance }; match ma; ma.pt1 = kps1[m.queryIdx]; ma.pt2 = kps2[m.trainIdx]; ma.distance = m.distance; return ma; }); return mt; }
static bool selectOpenCLDevice() { std::string platform; std::vector<std::string> deviceTypes; std::string deviceName; const char* configuration = getenv("OPENCV_OPENCL_DEVICE"); if (configuration) { if (!parseOpenCLDeviceConfiguration(std::string(configuration), platform, deviceTypes, deviceName)) return false; } bool isID = false; int deviceID = -1; if (deviceName.length() == 1) // We limit ID range to 0..9, because we want to write: // - '2500' to mean i5-2500 // - '8350' to mean AMD FX-8350 // - '650' to mean GeForce 650 // To extend ID range change condition to '> 0' { isID = true; for (size_t i = 0; i < deviceName.length(); i++) { if (!isdigit(deviceName[i])) { isID = false; break; } } if (isID) { deviceID = atoi(deviceName.c_str()); CV_Assert(deviceID >= 0); } } const PlatformInfo* platformInfo = NULL; if (platform.length() > 0) { PlatformsInfo platforms; getOpenCLPlatforms(platforms); for (size_t i = 0; i < platforms.size(); i++) { if (platforms[i]->platformName.find(platform) != std::string::npos) { platformInfo = platforms[i]; break; } } if (platformInfo == NULL) { std::cerr << "ERROR: Can't find OpenCL platform by name: " << platform << std::endl; goto not_found; } } if (deviceTypes.size() == 0) { if (!isID) { deviceTypes.push_back("GPU"); deviceTypes.push_back("CPU"); } else { deviceTypes.push_back("ALL"); } } for (size_t t = 0; t < deviceTypes.size(); t++) { int deviceType = 0; if (deviceTypes[t] == "GPU") { deviceType = CVCL_DEVICE_TYPE_GPU; } else if (deviceTypes[t] == "CPU") { deviceType = CVCL_DEVICE_TYPE_CPU; } else if (deviceTypes[t] == "ACCELERATOR") { deviceType = CVCL_DEVICE_TYPE_ACCELERATOR; } else if (deviceTypes[t] == "ALL") { deviceType = CVCL_DEVICE_TYPE_ALL; } else { std::cerr << "ERROR: Unsupported device type for OpenCL device (GPU, CPU, ACCELERATOR): " << deviceTypes[t] << std::endl; goto not_found; } DevicesInfo devices; getOpenCLDevices(devices, deviceType, platformInfo); for (size_t i = (isID ? deviceID : 0); (isID ? (i == (size_t)deviceID) : true) && (i < devices.size()); i++) { if (isID || devices[i]->deviceName.find(deviceName) != std::string::npos) { // check for OpenCL 1.1 if (devices[i]->deviceVersionMajor < 1 || (devices[i]->deviceVersionMajor == 1 && devices[i]->deviceVersionMinor < 1)) { std::cerr << "Skip unsupported version of OpenCL device: " << devices[i]->deviceName << "(" << devices[i]->platform->platformName << ")" << std::endl; continue; // unsupported version of device, skip it } try { setDevice(devices[i]); } catch (...) { std::cerr << "ERROR: Can't select OpenCL device: " << devices[i]->deviceName << "(" << devices[i]->platform->platformName << ")" << std::endl; goto not_found; } return true; } } } not_found: std::cerr << "ERROR: Required OpenCL device not found, check configuration: " << (configuration == NULL ? "" : configuration) << std::endl << " Platform: " << (platform.length() == 0 ? "any" : platform) << std::endl << " Device types: "; for (size_t t = 0; t < deviceTypes.size(); t++) { std::cerr << deviceTypes[t] << " "; } std::cerr << std::endl << " Device name: " << (deviceName.length() == 0 ? "any" : deviceName) << std::endl; return false; }