[OPENCV GPU] How can I convert GpuMat and Vector<Point2f> using HostMem? [closed]

edit

I am also using the streams to make it asynchronous. But not using the stream.waitForCompletion();. What is it for?

Can I treat the HostMem h_dst as the vector<Point2f> vec? Because d_mat is the output from cuda::createGoodFeaturesToTrackDetector(CV_8UC1,maxCorners, qualityLevel, minDistance, blockSize) and I need to access the points to calculate the centre of all of them, that's why I want to put all the points into vec.

When you use streams control returns immediately to the host. Therefore you need a way to know when the work has completed e.g. d_vec.download(h_dst,stream); (MemCpy (DToH)). One way is to query with stream.queryIfComplete() another is to force the host to wait until the device work has completed with stream.waitForCompletion();.

Put another way if you call d_vec.download(h_dst,stream); you cannot be sure that the copy from d_vec to h_dest has completed until stream.queryIfComplete() returns true. Alternatively you can call stream.waitForCompletion(); which guarantees that the host will wait until stream.queryIfComplete() would return true. The downside is that you have just lost the advantage of using an async pipeline.

1. Then, why using streams if we need to make sure that they are done and then we lose the advantage of using an asynchronous pipeline? Is there a way that you don't lose the advantages of streams?

2. How do you access the data of a HostMem variable to treat it as a vector<Point2f>?

Mainly streams allow you to overlap host and device computation. You need to sync before examining the result on the host. That said you get a choice when to sync, ideally this would be performed when you know all the work has finished on the device.

In your case if you are trying to examine the result immediately after downloading this defeats the objective of using streams. Ideally you would call download, then proceed with some more work on the host before synchronizing.

All that said I don't know what you are doing because you haven't shared you code yet?

I wouldn't worry about converting HostMem to vector<Point2f> at the moment as you may not even benefit from streams.

Okay. I will need to find a way to be able to use asynchronous calls.

I am preparing the code to share it with you.

OK have you checked out Accelerating OpenCV with CUDA streams in Python for an overview of stream usage.

Is a 25% reduction in execution time enough for your application?

Yes. I've been following this post to optimize my code. I will need to have a look on how I can make my code follow the second statement of the Summary in the post.

Please, find in this link the code I use: Link to code

I have had a very quick look and I may be wrong but it because the result of your CPU tracking determines the ROI which you use for the next detection of key points you will always need two sync points. If it was possible to perform the same tracking without using the CPU this would remove this requirement and allow you to run asynchronously with respect the host.

That said I think there are a few places where you can overlap host/device computation. For example you should be able to overlap the frame decoding by placing it in between the call to download the opt flow points and the call to detect the next key points. frame_grey is not used immediately so you may be able to move cuda::cvtColor(frame_rgb, frame_gray, COLOR_RGB2GRAY, 0, stream); a later point etc.

So you recommend me to write all the code that is now running on CPU on CUDA so it can go asynchronously with respect to the host? Do you have any link where I can get started fast with CUDA? Thank you very much for all your time and help.