TEST(RMDCuTests, deviceImageUploadDownloadFloat)
{
rmd::test::Dataset dataset;
if(!dataset.loadPathFromEnv())
{
FAIL() << "could not retrieve dataset path from the environment variable '"
<< rmd::test::Dataset::getDataPathEnvVar();
}
cv::Mat img;
if(!dataset.readImage(img, "scene_000.png"))
{
FAIL() << "could not could not load test image from dataset";
}
cv::Mat img_flt;
img.convertTo(img_flt, CV_32F, 1./255.);
const size_t w = img_flt.cols;
const size_t h = img_flt.rows;
// upload data to gpu memory
rmd::DeviceImage<float> in_img(w, h);
in_img.setDevData(reinterpret_cast<float*>(img_flt.data));
float * cu_img = new float[w*h];
in_img.getDevData(cu_img);
for(size_t y=0; y<h; ++y)
{
for(size_t x=0; x<w; ++x)
{
ASSERT_FLOAT_EQ(img_flt.at<float>(y, x), cu_img[y*w+x]);
}
}
delete cu_img;
}
TEST(RMDCuTests, deviceImageUploadDownloadFloat2)
{
rmd::test::Dataset dataset;
if(!dataset.loadPathFromEnv())
{
FAIL() << "could not retrieve dataset path from the environment variable '"
<< rmd::test::Dataset::getDataPathEnvVar();
}
cv::Mat img;
if(!dataset.readImage(img, "scene_000.png"))
{
FAIL() << "could not could not load test image from dataset";
}
cv::Mat img_flt;
img.convertTo(img_flt, CV_32F, 1./255.);
// Opencv gradient computation
cv::Mat ocv_grad_x, ocv_grad_y;
cv::Sobel(img_flt, ocv_grad_x, CV_32F, 1, 0, CV_SCHARR);
cv::Sobel(img_flt, ocv_grad_y, CV_32F, 0, 1, CV_SCHARR);
const size_t w = img_flt.cols;
const size_t h = img_flt.rows;
float2 * cu_grad = new float2[w*h];
for(size_t y=0; y<h; ++y)
{
for(size_t x=0; x<w; ++x)
{
cu_grad[y*w+x].x = ocv_grad_x.at<float>(y, x);
cu_grad[y*w+x].y = ocv_grad_y.at<float>(y, x);
}
}
// upload data to device memory
rmd::DeviceImage<float2> in_img(w, h);
in_img.setDevData(cu_grad);
// download data to host memory
memset(cu_grad, 0, sizeof(float2)*w*h);
in_img.getDevData(cu_grad);
for(size_t y=0; y<h; ++y)
{
for(size_t x=0; x<w; ++x)
{
ASSERT_FLOAT_EQ(ocv_grad_x.at<float>(y, x), cu_grad[y*w+x].x);
ASSERT_FLOAT_EQ(ocv_grad_y.at<float>(y, x), cu_grad[y*w+x].y);
}
}
delete cu_grad;
}
void imageCB(const sensor_msgs::Image::ConstPtr img) {
cv_bridge::CvImagePtr cv_ptr;
try {
cv_ptr = cv_bridge::toCvCopy(img);
} catch (cv_bridge::Exception& ex1) {
ROS_ERROR("cv_bridge exception: %s", ex1.what());
return;
}
// set the image region of interest
cv::Mat in_img1 = cv_ptr->image.clone();
cv::Rect roi(60,50,400,350);
cv::Mat in_img(in_img1, roi);
// do a circular hough transform
cv::Mat img1,gray;
in_img.copyTo(img1);
int thresh1 = 100;
cv::Canny(img1, gray, thresh1, thresh1*2, 3 );
// smooth it, otherwise a lot of false circles may be detected
cv::GaussianBlur( gray, gray, cv::Size(9, 9), 2, 2 );
cv::imshow( "blur", gray );
std::vector<cv::Vec3f> circles;
cv::HoughCircles(gray, circles, CV_HOUGH_GRADIENT,
2, gray.rows/3, 200, 100,50,150 );
for( size_t i = 0; i < circles.size(); i++ ) {
cv::Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
int radius = cvRound(circles[i][2]);
// draw the circle center
cv::circle( img1, center, 3, cv::Scalar(0,255,0), -1, 8, 0 );
// draw the circle outline
cv::circle( img1, center, radius, cv::Scalar(0,0,255), 7, 8, 0 );
}
cv::imshow( "circles", img1 );
cv::waitKey(10);
}
TEST(RMDCuTests, deviceImageSobelTexTest)
{
rmd::test::Dataset dataset;
if(!dataset.loadPathFromEnv())
{
FAIL() << "could not retrieve dataset path from the environment variable '"
<< rmd::test::Dataset::getDataPathEnvVar();
}
cv::Mat img;
if(!dataset.readImage(img, "scene_000.png"))
{
FAIL() << "could not could not load test image from dataset";
}
cv::Mat img_flt;
img.convertTo(img_flt, CV_32F, 1./255.);
// Compare results of the Scharr operator to compute image gradient
const size_t w = img_flt.cols;
const size_t h = img_flt.rows;
// Opencv gradient computation
cv::Mat ocv_grad_x(h, w, CV_32FC1);
cv::Mat ocv_grad_y(h, w, CV_32FC1);
double t = (double)cv::getTickCount();
cv::Sobel(img_flt, ocv_grad_x, CV_32F, 1, 0, CV_SCHARR);
cv::Sobel(img_flt, ocv_grad_y, CV_32F, 0, 1, CV_SCHARR);
t = ((double)cv::getTickCount() - t)/cv::getTickFrequency();
printf("Opencv execution time: %f seconds.\n", t);
// CUDA gradient computation
// upload data to device memory
rmd::DeviceImage<float> in_img(w, h);
in_img.setDevData(reinterpret_cast<float*>(img_flt.data));
// compute gradient on device
rmd::DeviceImage<float2> out_grad(w, h);
StopWatchInterface * timer = NULL;
sdkCreateTimer(&timer);
sdkResetTimer(&timer);
sdkStartTimer(&timer);
rmd::sobelTex(in_img, out_grad);
sdkStopTimer(&timer);
t = sdkGetAverageTimerValue(&timer) / 1000.0;
printf("CUDA execution time: %f seconds.\n", t);
// download result to host memory
float2 * cu_grad = new float2[w*h];
out_grad.getDevData(cu_grad);
for(size_t y=1; y<h-1; ++y)
{
for(size_t x=1; x<w-1; ++x)
{
ASSERT_NEAR(ocv_grad_x.at<float>(y, x), cu_grad[y*w+x].x, 0.00001f);
ASSERT_NEAR(ocv_grad_y.at<float>(y, x), cu_grad[y*w+x].y, 0.00001f);
}
}
delete cu_grad;
}
