anatrong0's profile - activity

6.64 ms if I use codes inside int main and not sepparate function

tried linear case, with single Stream but that is roughly same speed as w/o

with stream: 7.4745 ms w/o: 7.57892 ms

(averaged over 1000 readouts)

for (int i=0; i<1000;i++){
g_disk.upload(readDisk(fs,tmp0, disk),myStream);
cudaDFT2D(g_disk, G_disk, G_gauss_dx, G_gauss_dy, g_disk_dx, g_disk_dy, G_magnitude, myStream);  
g_disk_dx.download(disk,myStream);}

compared with functions without myStream. I also made sepparate function so need to check whether this dos not influence speed

I will try. My analysis has 5x dft + 2x mulSpectrum + 1x magnitude per each image 512x512 (zero padded due to the features close to image border) and these are done without CPU code in-line, therefore I thought if CUDA may be better here. It may be faster on CPU but not so parallel (at least I think)

to cross-correlate same size images:

//FORWARD TRANSFORMS
cv::cuda::dft(image1, G_image1, Size(SIZE,SIZE), DFT_SCALE);        
cv::cuda::dft(image2, G_image2, Size(SIZE,SIZE), DFT_SCALE);        

//MULTIPLY CONJUGATE
cv::cuda::mulSpectrums(G_image1,G_image2,G_image1,true);    

//BACKWARD TRANSFORM
cv::cuda::dft(G_image1,RESULT,Size(SIZE,SIZE),DFT_REAL_OUTPUT | DFT_SCALE);

• result in unscaled cross-correlation
• to scale between (-1,1): normalize source images to have mean(src's) = 0, StdDev(src's) = 1 before computation

Hi, I am analysing set of images for subpixel image shifts. I have code which essantially loops through:

loop(){

• read binary image, send it to GpuMat/cuda

//next 2 points are based on dft, mulSpectrums, magnitude (all cuda "Streamable")

• convolve with smoothing/gradient kernels (cuda)
• cross-correlate (phase-correlate) with base image (cuda)

// next are locating maximum of correlation pattern with subpixel precision

• find maxLoc (cuda, but value sent to Point.x/Point.y on CPU)
• copy maxLoc 3x3 neighbours into Mat (CPU)
• subpixel registration by quadratic fit of 3x3 maxima neighbours (CPU)
• resulting (x,y) pixel shifts are placed in shift maps (CPU) }

All this is computed ~65000 times, it takes about 8 minutes to compute (256x256 base 16 bit B&W images). Cuda card is not even heating up (nvidia-smi shows 6% GPU-Util).

Any suggestions on how to parallelize (the faster the better) this?

(also thanks to L.Berger who got me this far)

cuda::createLinearFilter() is the way to go

yes,

Ptr<cuda::convolution> conv = cuda::createConvolution(); conv->convolve(zero_padded_source1, source2 ,result, true);

But filter 2D will do all this better I guess

just zero pad one of the images to (double -1) size of the other and do

convolve(zero_padded_source1, source2 ,result, true);

Thanks, other software I used did not say how is the cross-correlation produced. I realised you just need to zero pad one of the images and use openCV convolution(ccor=true)

Is there a way to compute full cross-correlation (or phase correlation) for two images of same size?

-resulting image should be same size as 2 source images. Convolution will only give me one pixel image the way it is implemented.

Or do I have to compute it by dft and therefore code it manually? Essentially I am looking for subpixel template matching (for 2 same sized images where an object within shifts)

cool, I am not sure how much is this applicable but will give it a try. Images here are from Scanning TEM detector so it might be a little bit different

thanks for help, camera itself has 12bit counter and this is saved as 16bit raw file. It depends on our experiment how much of this space is filled. Counts are <20 in my example file (waste of space), but we do not have direct access to drivers or FPGA card which saves datasets. I'm doing analysis of data in proprietary software but I want to try something different.

ok, I am not programmer as is clear I think :) is your suggestion faster?

for anyone doing simmilar, to display normalised first image from 16bit 256x256 raw binary file with 256 bytes header, there is also endian conversion (many thanks to L.Berger)

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
#include <fstream>          

using namespace cv;
using namespace std;

int main( int argc, char** argv )
{
        //file read
        ifstream fs;
        fs.open(argv[1], ios::in | ios::binary);
        unsigned short *tmp = new unsigned short [256*256];
        fs.seekg(256);
        fs.read((char*)tmp, 256*256*2 );
        fs.close();

    //endian conversion
    unsigned char*c = (unsigned char*)tmp;
    for (int i = 0; i < 65536*2; i += 2)
    swap(c[i], c[i + 1]);
    Mat imAcq = Mat(256, 256, CV_16UC1,tmp);// , tmp, 256 * 256 * sizeof(unsigned short));

    normalize(imAcq, imAcq, 0, 65536, NORM_MINMAX, -1, Mat() );

    //convert to 8bit for imshow
    Mat img8bit;
    imAcq.convertTo(img8bit,CV_8UC1,1/256.0);
    namedWindow( "8bit normalised", WINDOW_AUTOSIZE );
    imshow( "8bit normalised", img8bit );                   // Show image

    waitKey(0);                                          // Wait for a keystroke in the window
    return 0;
}

this seems to work:

Mat imAcq=Mat(256,256,CV_16UC1,tmp);
Mat mat1;
mat1 = imAcq/256;
imAcq = (imAcq - (256*mat1))*256+mat1;

Can you please comment on this, I have same trouble.

OK thanks, that one works fine now. Other problem is now endians. Value 1 is given as 256 in my Mat. Is there any simple workaround? (if I multiply whole array by 256 in imageJ it gives me 1 for same pixel)

Hi, I got back to this and I am stuck bit further.. this code:

    int main( int argc, char** argv )
{
        ifstream fs;
        fs.open(argv[1], ios::in | ios::binary);
        unsigned short *tmp = new unsigned short[256*256];
        fs.seekg(256);
        fs.read(reinterpret_cast<char*>(tmp), 256*256*sizeof(unsigned short) );
        fs.close();

    Mat imAcq=Mat(256,256,CV_16UC1,&tmp,256*256*sizeof(unsigned short));
    for (long i=0; i<30000; i++)
    {
    cout << " "  << tmp[i]/256;
    }

creates tmp array with everything 256 x bigger, then if it is read in Mat imAcq=Mat(... it gets to segmentation fault. I am pretty sure my file is 16bit (unsigned short) and if I display values of tmp as in example it gets it right, any suggestions for quick, non all array fix?