cross-correlation

According to this link and this one , it is said that opencv is much faster than matlab. First link is written in March 2012, second one is a bit later than that. In the first link, it says, "Programs written in OpenCV run much faster than similar programs written in Matlab." and rates Matlab: 2/10 and OpenCV: 9/10 Consider, I have two float Matrix whose size are 1024*1024 ( mat1 and mat2 ). I want to correlate this matrices. In matlab, corr2(mat1,mat2); //70-75 ms In opencv, c++ Mat result(1,1,CV_32F); matchTemplate(mat1,mat2,result, CV_TM_CCOEFF_NORMED); // 145-150 ms As far as I know, c and

I can't find a reason why calculating the correlation between two series A and B using numpy.correlate gives me different results than the ones I obtain using statsmodels.tsa.stattools.ccf Here's an example of this difference I mention: import numpy as np from matplotlib import pyplot as plt from statsmodels.tsa.stattools import ccf #Calculate correlation using numpy.correlate def corr(x,y): result = numpy.correlate(x, y, mode='full') return result[result.size/2:] #This are the data series I want to analyze A = np.array([np.absolute(x) for x in np.arange(-1,1.1,0.1)]) B = np.array([x for x in

I am trying to implement a 2d phase correlation algorithm in R using a recipe from Wikipedia ( http://en.wikipedia.org/wiki/Phase_correlation ) in order to track the movement between 2 images. These images (frames) were captured with a camera shaking in the wind and the ultimate goal is to remove the shake in these and subsequent frames. The two example images and the R code are below: ## we will need the tiff library library(tiff) ## read in the tiff files f1=as.matrix(readTIFF('f1.tiff',native=TRUE)) f2=as.matrix(readTIFF('f2.tiff',native=TRUE)) ## take the fft of the first frame F1 <- fft

Unlike the standard (and more challenging) de-blurring and super resolution scenarios, I have access to both the original (sharp) image G and it's blurred version B . I'm simply looking for the blur kernel h . So because B is taken using a real camera the relation is: B=G*h+N (where * denotes convolution and N is some additive noise) Naturally, this is an over-constrained problem since h is small in size compared to G and B and so every few pixels in the pair of images generate an equation on the entries of h . But what would be the simplest way to actually implement this? My thoughts so far:

I got two images showing exaktly the same content: 2D-gaussian-shaped spots. I call these two 16-bit png-files "left.png" and "right.png". But as they are obtained thru an slightly different optical setup, the corresponding spots (physically the same) appear at slightly different positions. Meaning the right is slightly stretched, distorted, or so, in a non-linear way. Therefore I would like to get the transformation from left to right. So for every pixel on the left side with its x- and y-coordinate I want a function giving me the components of the displacement-vector that points to the