void *performXCorr(){
int d;
if(fillingB1){
d = xcorr(ch1b0, ch0b0, SMPSZ);
}else{
d = xcorr(ch1b1, ch0b1, SMPSZ);
}
printf("%d\n", d);
return 0;
}
void cFilterSpatial<T>::filterSpatial(cData3<T>& data, eXCorrRes shape)
{
const std::string funcName("void cFilterSpatial<T>::filterSpatial("
"cData3<T>& data, eXCorrRes shape)");
data.requireNonEmpty(funcName);
_kernel.requireNonEmpty(funcName);
require(data.getDimension() == _kernel.getDimension(),
funcName + ": data and _kernel have different dimensions");
cData3<T> other(data.getSize() + _kernel.getSize() - 1);
switch (data.getDimension()) {
case 1:
xcorr(_kernel.getAddrData(), _kernel.getNrow(),
data.getAddrData(), data.getNrow(),
other.getAddrData(),
XCORR_RES_FULL);
break;
case 2:
xcorr(_kernel.getAddrData(), _kernel.getNrow(), _kernel.getNcol(),
data.getAddrData(), data.getNrow(), data.getNcol(),
other.getAddrData(),
XCORR_RES_FULL);
break;
case 3:
xcorr(_kernel.getAddrData(), _kernel.getNrow(), _kernel.getNcol(), _kernel.getNsec(),
data.getAddrData(), data.getNrow(), data.getNcol(), data.getNsec(),
other.getAddrData(),
XCORR_RES_FULL);
break;
default:
ERROR(funcName, "unsupported dimension");
}
// cropping
switch (shape) {
case XCORR_RES_FULL:
data = other;
break;
case XCORR_RES_SAME:
array_crop(other.getAddrData(), other.getNrow(), other.getNcol(), other.getNsec(),
data.getAddrData(), data.getNrow(), data.getNcol(), data.getNsec(),
(_kernel.getNrow()-1)/2,
(_kernel.getNcol()-1)/2,
(_kernel.getNsec()-1)/2);
break;
case XCORR_RES_VALID:
ERROR(funcName, "unsupported xcorr mode");
break;
default:
ERROR(funcName, "unsupported xcorr mode");
}
}
int main(int argc, char** argv) {
std::cout.precision(10);
options opt(argc, argv, 14);
if (!opt.valid) std::abort();
boost::timer tm;
double t1 = tm.elapsed();
// lattice structure
int n = opt.N;
int ibond = n;
std::vector<int> ipair;
for (int i = 0; i < ibond; ++i) {
ipair.push_back(i);
ipair.push_back((i + 1) % n);
}
// Hamiltonian parameters
std::vector<double> bondwt(ibond, -1);
std::vector<double> zrtio(ibond, 1);
// table of configurations and Hamiltonian operator
subspace ss(n, 0);
hamiltonian hop(ss, ipair, bondwt, zrtio);
// Hamiltonian matrix
matrix_type elemnt;
elm3(hop, elemnt);
double t2 = tm.elapsed();
std::vector<double> E;
matrix_type v;
int nvec = 1;
diag(elemnt, E, v, nvec);
double t3 = tm.elapsed();
int ne = 4;
std::cout << "[Eigenvalues]\n";
for (int i = 0; i < ne; ++i) std::cout << '\t' << E[i];
std::cout << std::endl;
// // Do not forget to call elm3 again before calling check3
elm3(hop, elemnt);
check3(elemnt, v, 0);
double t4 = tm.elapsed();
std::vector<int> npair;
npair.push_back(1);
npair.push_back(2);
std::vector<double> sxx(1);
xcorr(ss, npair, v, 0, sxx);
std::cout << "sxx: " << sxx[0] << std::endl;
std::vector<double> szz(1);
zcorr(ss, npair, v, 0, szz);
std::cout << "szz: " << szz[0] << std::endl;
double t5 = tm.elapsed();
std::cerr << "initialize " << (t2-t1) << " sec\n"
<< "diagonalization " << (t3-t2) << " sec\n"
<< "check " << (t4-t3) << " sec\n"
<< "correlation " << (t5-t4) << " sec\n";
}
cvec xcorr(const cvec &x, const cvec &y, const int max_lag, const std::string scaleopt)
{
cvec out(2*x.length() - 1); //Initial size does ont matter, it will get adjusted
xcorr(x, y, out, max_lag, scaleopt, false);
return out;
}
vec xcorr(const vec &x, const vec &y, const int max_lag, const std::string scaleopt)
{
cvec out(2*x.length() - 1); //Initial size does ont matter, it will get adjusted
xcorr(to_cvec(x), to_cvec(y), out, max_lag, scaleopt, false);
return real(out);
}
std::pair<float, float> delay(const std::vector<int16_t>& buffer,
unsigned int ch1, unsigned int ch2,
int range){
std::vector<std::pair<float, float> > corrs
= xcorr(buffer, ch1, ch2, range+2); //TODO: Should this +2 be gone now?
float ac1 = dotWithOffset(buffer, ch1, ch1, 0);
float ac2 = dotWithOffset(buffer, ch2, ch2, 0);
int maxOffset = 0;
std::pair<float, float> maxVal = corrs[0];
for(int i=1; i<corrs.size(); i++){
if(corrs[i].second > maxVal.second){
maxVal = corrs[i];
maxOffset = i;
} else if(corrs[i].second == maxVal.second &&
std::abs(corrs[i].first) < std::abs(maxVal.first)){
maxVal = corrs[i];
maxOffset = i;
}
}
return std::make_pair(maxVal.first, maxVal.second/std::sqrt(ac1*ac2));
}
void corr()
{
int i; int tmp; int tmp_nfft = nfft/2;
Complex *rm = (Complex *)malloc( nfft * sizeof( Complex ));
for(i = 0; i < nfft; i++) {
tmp = pri.n - i -1;
tmp = (tmp>0) ? tmp : (-tmp);
*(rm+i) = xcorr(pri.dt, pri.n, tmp);
}
Complex *nf = fft(rm, nfft, nfft);
free(rm);
if( ret.x ) free(ret.x); if( ret.y ) free( ret.y );
ret.x = (double *)malloc( (tmp_nfft) *sizeof(double));
ret.y = (double *)malloc( (tmp_nfft) *sizeof(double));
for(i = 0; i < tmp_nfft; i++) {
double l = abs( *(nf+i) );
*(ret.y+i) = 10*log10(l);
*(ret.x+i) = i*fs/nfft;
}
free(nf);
ret.xlabel = "(Hz)";
ret.ylabel = "(db)";
ret.n = tmp_nfft;
}
/**
* Process input data stream
*/
void DoubleClickFilter::process()
{
// Store latest input (shift the buffer
for( int k=0; k<mInputStream.rows; k++ ) {
mInputStream.at< float >(k, 0) = mInputStream.at< float >(k+1, 0);
}
mInputStream.at< float >( mInputStream.rows-1, 0) = Input;
// Find maximum cross correlation with a pattern
double max = 0.0;
for( int i=0; i<mPatterns.size(); i++ )
{
double x = xcorr( mPatterns.at(i), mInputStream );
max = qMax( max, x );
}
XCorr = max;
// If the pattern matches the input stream the xcorr is > Threshold,
// in this case trigger the detected() signal.
if( max >= Threshold )
{
emit detected();
Detected = true;
}
else
{
Detected = false;
}
}
void xcorr(const vec &x, const vec &y, vec &out, const int max_lag, const std::string scaleopt)
{
cvec xx = to_cvec(x);
cvec yy = to_cvec(y);
cvec oo = to_cvec(out);
xcorr(xx, yy, oo, max_lag, scaleopt, false);
out = real(oo);
}
}END_TEST
START_TEST(test_correct_code_xcorr)
{
si32 * result;
si8 input1[10] = { 0, 1, 0, 1, 1, 1, 0, 0, 0, 0 };
si32 input1Size = 10;
si8 input2[5] = { 0, 1, 1, 1, 0 };
si32 input2Size = 5;
si32 trueVal[10] = { 1, -1, 5, 1, -1, -3, -2, -1, 0, 1 };
si32 inda = 0;
result = xcorr(input1, input1Size, input2, input2Size);
ck_assert(result != NULL);
for (inda = 0; inda < 10; inda++) {
ck_assert_int_eq(trueVal[inda], result[inda]);
}
free(result);
}END_TEST
void normxcorrmw(T *tplData, size_t tplNrow, size_t tplNcol, size_t tplNsec, T *tplWght,
T *refData, size_t refNrow, size_t refNcol, size_t refNsec, T *refWght,
T *resData,
T *mskData,
eXCorrRes shape)
{
assert(tplData != NULL && refData != NULL && resData != NULL);
assert(tplWght != NULL && refWght != NULL && mskData != NULL);
assert(tplNrow > 0 && tplNcol > 0 && tplNsec > 0);
assert(refNrow > 0 && refNcol > 0 && refNsec > 0);
T *tplDataTmp = NULL,
*refDataTmp = NULL,
*tplWghtTmp = NULL,
*refWghtTmp = NULL,
*fftTmp1 = NULL,
*fftTmp2 = NULL;
size_t resNrow = 0, resNcol = 0, resNsec = 0, tplSize, refSize, resSize;
if (shape != XCORR_RES_FULL && shape != XCORR_RES_VALID) {
shape = XCORR_RES_FULL;
}
switch (shape) {
case XCORR_RES_FULL:
resNrow = refNrow + tplNrow - 1;
resNcol = refNcol + tplNcol - 1;
resNsec = refNsec + tplNsec - 1;
break;
case XCORR_RES_VALID:
resNrow = refNrow - tplNrow + 1;
resNcol = refNcol - tplNcol + 1;
resNsec = refNsec - tplNsec + 1;
break;
default:
ERROR("normxcorrmw", "unsupported xcorr mode");
}
tplSize = tplNrow * tplNcol * tplNsec;
refSize = refNrow * refNcol * refNsec;
resSize = resNrow * resNcol * resNsec;
// allocate arrays as copies of input arrays
array_new(tplDataTmp, tplSize);
array_new(refDataTmp, refSize);
memcpy(tplDataTmp, tplData, tplSize*sizeof(T));
memcpy(refDataTmp, refData, refSize*sizeof(T));
array_new(tplWghtTmp, tplSize);
array_new(refWghtTmp, tplSize);
memcpy(tplWghtTmp, tplWght, tplSize*sizeof(T));
memcpy(refWghtTmp, refWght, tplSize*sizeof(T));
// weight and template normalization
xcorrNormTemplateWCC2(tplDataTmp, tplSize,
mskData,
tplWghtTmp,
refWghtTmp);
// allocate temporary arrays
array_new(fftTmp1, resSize);
array_new(fftTmp2, resSize);
// numerator
xcorr(tplDataTmp, tplNrow, tplNcol, tplNsec,
refDataTmp, refNrow, refNcol, refNsec,
resData,
shape);
// denominator
xcorr(refWghtTmp, tplNrow, tplNcol, tplNsec,
refDataTmp, refNrow, refNcol, refNsec,
fftTmp1,
shape);
array_math_sqr(refDataTmp, refSize);
xcorr(refWghtTmp, tplNrow, tplNcol, tplNsec,
refDataTmp, refNrow, refNcol, refNsec,
fftTmp2,
shape);
// NCC
xcorrCombineResultWCC(resData,
fftTmp1,
fftTmp2,
array_reduce_sum(tplDataTmp, tplSize),
resSize);
// deallocate
array_delete(tplDataTmp);
array_delete(refDataTmp);
array_delete(tplWghtTmp);
array_delete(refWghtTmp);
array_delete(fftTmp1);
array_delete(fftTmp2);
}
void ecorr(T *tplData, size_t tplNrow,
T *refData, size_t refNrow,
T *resData,
eXCorrRes shape)
{
assert(tplData != NULL && refData != NULL && resData != NULL);
assert(tplNrow > 0);
assert(refNrow > 0);
T *tplDataTmp = NULL,
*refDataTmp = NULL,
*fftTmp1 = NULL,
*mskData = NULL;
size_t resNrow = 0, tplSize, refSize, resSize;
if (shape != XCORR_RES_FULL && shape != XCORR_RES_VALID) {
shape = XCORR_RES_FULL;
}
switch (shape) {
case XCORR_RES_FULL:
resNrow = refNrow + tplNrow - 1;
break;
case XCORR_RES_VALID:
resNrow = refNrow - tplNrow + 1;
break;
default:
ERROR("ecorr", "unsupported xcorr mode");
}
tplSize = tplNrow;
refSize = refNrow;
resSize = resNrow;
// allocate arrays as copies of input arrays
array_new(tplDataTmp, tplSize);
array_new(refDataTmp, refSize);
memcpy(tplDataTmp, tplData, tplSize*sizeof(T));
memcpy(refDataTmp, refData, refSize*sizeof(T));
// template normalization
array_new(mskData, tplSize);
array_setval(mskData, (T) 1, tplSize);
xcorrNormTemplateECC(tplDataTmp, tplSize);
// allocate temporary arrays
array_new(fftTmp1, resSize);
// numerator
xcorr(tplDataTmp, tplNrow,
refDataTmp, refNrow,
resData,
shape);
// denominator
array_math_sqr(refDataTmp, refSize);
xcorr(mskData, tplNrow,
refDataTmp, refNrow,
fftTmp1,
shape);
// ECC
xcorrCombineResultECC(resData, fftTmp1, resSize);
// deallocate
array_delete(tplDataTmp);
array_delete(refDataTmp);
array_delete(mskData);
array_delete(fftTmp1);
}
int
main(int argc, char *argv[])
{
FILE *fd1;
FILE *fd2;
wave_t *wave1;
wave_t *wave2;
buffer_t *buffer1;
buffer_t *buffer2;
int bytesread;
int length = 512;
if (argc < 2) {
fprintf(stderr, "Usage: %s <file>\n", argv[0]);
exit(EXIT_FAILURE);
}
// LOAD wave to compare with Square1.wav
if (!(fd1 = fopen(argv[1], "rb"))) {
fprintf(stderr, "Couldn't open \"%s\".\n", argv[1]);
exit(EXIT_FAILURE);
}
if (!(wave2 = waveopen(fd1))) {
fprintf(stderr, "Couldn't open \"%s\" as a .wav file.\n", argv[1]);
exit(EXIT_FAILURE);
}
// LOAD Pulse1.wav
if (!(fd2 = fopen("./wavs/Pulse1.wav", "rb"))) {
fprintf(stderr, "Couldn't open \"%s\".\n", "Square1.wav");
exit(EXIT_FAILURE);
}
if (!(wave1 = waveopen(fd2))) {
fprintf(stderr, "Couldn't open \"%s\" as a .wav file.\n", argv[1]);
exit(EXIT_FAILURE);
}
wavegetprop(wave1, WAVE_LENGTH, &length);
//length = 16;
buffer1 = mkbuffer(wave1, length);
buffer2 = mkbuffer(wave2, length);
if (!(bytesread = getpcm(wave1, buffer1))) {
fprintf(stderr, "Couldn't stream pcm data!\n");
exit(EXIT_FAILURE);
}
if (!(bytesread = getpcm(wave2, buffer2))) {
fprintf(stderr, "Couldn't stream pcm data!\n");
exit(EXIT_FAILURE);
}
char2double(wave1, buffer1);
char2double(wave2, buffer2);
/*int16_t **sample;
sample = (int16_t **)buffer->pcm;
for(int i = 0; i < buffer->length; i++){
printf("sample %d = %i \n", i, sample[0][i]);
}*/
print_waveinfo(wave1);
/* Test signal processing routines
--------------------------------------------------------------*/
printf("\nSIGNAL PROCESSING RESULTS:\n");
double **R = xcorr(0, buffer1, buffer2);
qsort(R[1], 2*length - 1, sizeof(double), doublecmp);
printf("max xcorr o/p = %f \n", R[1][2*length-2]);
/* for(int i = 1024 - 300; i < 1024 + 300; i++)
printf("index %d R=%f @ lag = %f \n", i, R[1][i],R[0][i]);
look at the output and lag 100 should have R ~= 1;*/
/* clean up mem allocs */
free(R[0]);
free(R[1]);
free(R);
rmbuffer(wave1, buffer1);
rmbuffer(wave2, buffer2);
waveclose(wave1);
waveclose(wave2);
fclose(fd1);
fclose(fd2);
return 0;
}
int main (int argc, const char * argv[])
{
// choose which zero of autocorrelation should be set as delay parameter
int delay_choice =2;
int embed_dimension =3;
int num_neighbours = 15;
long num_of_points_retained=500;
int percentile =70;
long output_len=2*(((float)percentile)/100)*num_of_points_retained;
printf("%ld output_len =",output_len);
float *output = malloc(output_len* sizeof(float));
printf("Density based subsampling running \n");
if (argc != 2) {
fprintf(stderr, "Expecting wav file as argument\n");
return 1;
}
// Open sound file that comes in as a command line argument
SF_INFO sndInfo;
SNDFILE *sndFile = sf_open(argv[1], SFM_READ, &sndInfo);
if (sndFile == NULL) {
fprintf(stderr, "Error reading source file '%s': %s\n", argv[1], sf_strerror(sndFile));
return 1;
}
// Check format - 16bit PCM
if (sndInfo.format != (SF_FORMAT_WAV | SF_FORMAT_PCM_16)) {
fprintf(stderr, "Input should be 16bit Wav\n");
sf_close(sndFile);
return 1;
}
// Now we know the length of the wav file, we can create a buffer for it, in this case, we are creating a double array.
// Allocate memory
float *buffer = malloc(sndInfo.frames * sizeof(float)* sndInfo.channels);
if (buffer == NULL)
{
fprintf(stderr, "Could not allocate memory for data\n");
sf_close(sndFile);
return 1;
}
// This next step, actually reads in the wav file data. This function automatically converts the whichever format the audio file data is in to doubles. The library can convert to a number of different formats.
// Load data
long numFrames = sf_readf_float(sndFile, buffer, sndInfo.frames);
// Check correct number of samples loaded
if (numFrames != sndInfo.frames) {
fprintf(stderr, "Did not read enough samples for source\n");
sf_close(sndFile);
free(buffer);
return 1;
}
// Now just output some info about the wav file
printf("Read %ld samples from %s, Sample rate: %d, Length: %fs\n",
numFrames, argv[1], sndInfo.samplerate, (float)numFrames/sndInfo.samplerate);
// extract a single channel out
float *buffer_singlechannel = malloc(sndInfo.frames * sizeof(float));
long i=0;
for (long f=0 ; f<numFrames ; f++) {
buffer_singlechannel[f]= buffer[i]; // Channel 1
i+=sndInfo.channels;
}
// free the buffer with multiple channel input
free(buffer);
// array to store the autocorrelation function
double *buffer_autocorrelation = malloc((2*sndInfo.frames +1)* sizeof(double));
// calculate autocorrelation
xcorr( buffer_singlechannel, buffer_singlechannel, buffer_autocorrelation, sndInfo.frames, 0,sndInfo.frames, 1, 1, sndInfo.frames,sndInfo.frames, sndInfo.frames, sndInfo.frames);
// choose delay to be second zero of auto correlation
long long delay = zeroCrossing(buffer_autocorrelation, 2*sndInfo.frames +1, delay_choice);
printf("Delay chosen = %lld\n",delay);
long long delay_embd_length= (sndInfo.frames -(delay*embed_dimension)+2)* embed_dimension;
//create delay embedding and store in a linear array in row major form
float *buffer_delayembedding =malloc(delay_embd_length*sizeof(float));
long long k1=0;
for (long long l=(delay*embed_dimension)-2; l<sndInfo.frames; l=l+1) {
buffer_delayembedding[k1]=buffer_singlechannel[l];
buffer_delayembedding[k1+1]=buffer_singlechannel[l-delay];
buffer_delayembedding[k1+2]=buffer_singlechannel[l-2*delay];
// printf("%f %f %f\n", buffer_delayembedding[k1],buffer_delayembedding[k1+1],buffer_delayembedding[k1+2]);
k1=k1+embed_dimension;
}
int *array =malloc(num_of_points_retained *sizeof(int));
random_selector( delay_embd_length/ embed_dimension ,num_of_points_retained , array);
for (int i=0; i<num_of_points_retained; i++) {
// printf("%d\n",array[i]);
}
float *buffer_delayembedding_selec =malloc(num_of_points_retained*embed_dimension*sizeof(float));
float * density_vals =malloc(num_of_points_retained* sizeof(float));
printf("total len = %lld\n ", delay_embd_length/3 );
printf("buffer len = %ld\n", num_of_points_retained*embed_dimension);
printf("num_of_points_retained = %ld\n", num_of_points_retained);
for (int i=0; i<num_of_points_retained; i=i+1)
{
int loc=(array[i]-1)*embed_dimension;
// printf("i :%d loc=%d array[i]: %d \n",i, loc, array[i]);
buffer_delayembedding_selec[3*i]=buffer_delayembedding[loc];
buffer_delayembedding_selec[3*i+1]=buffer_delayembedding[loc+1];
buffer_delayembedding_selec[3*i+2]=buffer_delayembedding[loc+2];
// printf("buffer selec [%d] = %f ", 3*i, buffer_delayembedding_selec[3*i]);
// printf("[%d] = %f ", 3*i+1, buffer_delayembedding_selec[3*i+1]);
// printf("[%d] = %f \n", 3*i+2, buffer_delayembedding_selec[3*i+2]);
}
// for (int i=0; i<delay_embd_length/ embed_dimension ; i++)
// {
// printf("% d th original :%f %f %f\n",i, buffer_delayembedding [3*i],buffer_delayembedding [3*i+1],buffer_delayembedding [3*i+2]);
// }
knn (buffer_delayembedding_selec, density_vals , (num_of_points_retained), num_neighbours);
// free all arrays used till now except the single channel wave file and close the sndFile object
sf_close(sndFile);
//desnity based subsampling
float * density_vals_temp =malloc(num_of_points_retained* sizeof(float));
memcpy(density_vals_temp,density_vals,num_of_points_retained* sizeof(float));
qsort(density_vals_temp, num_of_points_retained, sizeof(float), cmpfunc);
float key=findNumber(100-percentile,density_vals_temp,500);
// Function call and the print statement
// printf(" \n %d percentile: %.4lf \n", percentile, key);
printf(" \n the linear array output contains the subsampled point cloud \n");
//for (int kk=0; kk<num_of_points_retained; kk++) {
// printf("%d index %f \n", kk,density_vals_temp[kk]);
//}
free(density_vals_temp);
int counter2=0;
for( int counter = 0 ; counter < num_of_points_retained; counter++)
{
if (density_vals[counter]>=key && counter2<output_len/2)
{
output[2*counter2]=buffer_delayembedding_selec[3*counter];
output[2*counter2+1]=buffer_delayembedding_selec[3*counter+1];
//printf("%d output %.4lf , %.4lf\n", counter2,output[2*counter2],output[2*counter2+1]);
//printf("%d output %.4lf , %.4lf\n", counter,buffer_delayembedding_selec[3*counter],buffer_delayembedding_selec[3*counter+1]);
counter2++;
}
}
free(buffer_singlechannel);
free(buffer_autocorrelation);
free(buffer_delayembedding);
free(array);
free(buffer_delayembedding_selec);
free(density_vals);
printf("Density based subsampling End\n");
free(output);
return 0;
}
int main(int argc, char* argv[])
{
int n, nw, w, iw, i0=0, maxshift, i, i2, n2, nc;
float dt,h, eps, lam;
bool verb, taper;
float **dat, **dat2, **win, **win2, *coord, *shift, *warp, *xc;
map2 str;
sf_file in, out, other, xcr;
sf_init(argc,argv);
in = sf_input("in");
other = sf_input("other");
out = sf_output("out");
xcr = sf_output("xcorr");
if (!sf_histint(in,"n1",&n)) sf_error("No n1= in input");
if (!sf_histfloat(in,"d1",&dt)) sf_error("No d1= in input");
n2 = sf_leftsize(in,1);
if (!sf_getint("nw",&nw)) sf_error ("Need nw=");
/* number of windows */
if (!sf_getint("w",&w)) sf_error ("Need w=");
/* window size */
if (!sf_getfloat("h",&h)) h=0.5*(w-1);
/* window overlap */
if (!sf_getint("maxshift",&maxshift)) maxshift=w/2; nc=2*maxshift-1;
/* maximum correlation lag */
if (!sf_getfloat("eps",&eps)) eps=0.01;
/* vertical smoothness (for picking) */
if (!sf_getfloat("lam",&lam)) lam=0.5;
/* horizontal smoothness (for picking) */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
if (!sf_getbool("taper",&taper)) taper=true;
/* window tapering */
dat = sf_floatalloc2(n,n2);
dat2 = sf_floatalloc2(n,n2);
win = sf_floatalloc2(w,n2);
win2 = sf_floatalloc2(w,n2);
coord = sf_floatalloc(nw);
shift = sf_floatalloc(nw);
warp = sf_floatalloc(n);
xc = sf_floatalloc(nc);
window1_init (w,nw,n,h,w-h);
str = stretch2_init (n,1.,1.,nw,eps,lam);
sf_floatread (dat[0],n*n2,in);
sf_floatread (dat2[0],n*n2,other);
sf_putint(xcr,"n1",nc);
sf_putint(xcr,"n2",nw);
sf_putfloat(xcr,"o2",(0.5*w+1.)*dt);
sf_putfloat(xcr,"d2",(n-w)*dt/(nw-1.));
sf_putfloat(xcr,"o1",-maxshift*dt);
for (iw=0; iw < nw; iw++) {
for (i2=0; i2 < n2; i2++) {
i0 = window1_apply(iw,dat[i2] ,taper,taper,win[i2] );
i0 = window1_apply(iw,dat2[i2],taper,taper,win2[i2]);
}
coord[iw] = i0 + 0.5*(w+1.);
shift[iw] = xcorr (w,n2,win[0], win2[0],nc,xc);
sf_floatwrite(xc,nc,xcr);
if (verb) sf_warning("shift[%d]=%g",iw,shift[iw]);
}
stretch2_define (str, coord, false);
stretch2_apply (str, shift, warp);
for (i=0; i < n; i++) {
warp[i] *= dt;
}
for (i2=0; i2 < n2; i2++) {
sf_floatwrite (warp,n,out);
}
exit(0);
}
void xcorr(subspace const& ss, std::vector<int> const& npair, std::vector<double> const& x,
std::vector<double>& sxx) {
xcorr(ss, npair, &x[0], sxx);
}
