void ChoppySimulate::updateOffsetField(float _deltaTime)
{
//计算偏移场
//#define __USE_FULL_WAVE_OFFSET__
for (int i = 0; i < WAVE_SIZE; ++i)
{
for (int j = 0; j < WAVE_SIZE; ++j)
{
if (_waveNum[i][j].z == 0.0f)
{
_deltaXField[i][j].real = 0.0f;
_deltaXField[i][j].imag = 0.0f;
_deltaYField[i][j].real = 0.0f;
_deltaYField[i][j].imag = 0.0f;
}
else
{
//一下可以选择的方式
const float klen = _waveNum[i][j].z;
const float xscale = -_waveNum[i][j].x / klen;
const float yscale = -_waveNum[i][j].y / klen;
#ifndef __USE_FULL_WAVE_OFFSET__
_deltaXField[i][j].real = 0.0f;
_deltaXField[i][j].imag = _choppyField[i][j].imag*xscale;
_deltaYField[i][j].real = 0.0f;
_deltaYField[i][j].imag = _choppyField[i][j].imag * yscale;
#endif
}
}
}
//#undef __USE_FULL_WAVE_OFFSET__
//逆快速傅里叶变换
if (!FFT2D(_deltaXField, WAVE_SIZE, WAVE_SIZE, -1))
{
printf("_deltaXField FFT2D error,please check\n");
assert(0);
}
if (!FFT2D(_deltaYField, WAVE_SIZE, WAVE_SIZE, -1))
{
printf("_deltaYField FFT2D error,please check.\n");
assert(0);
}
//对偏移场进行缩放
for (int i = 0; i < WAVE_SIZE; ++i)
{
for (int j = 0; j < WAVE_SIZE; ++j)
{
const float scaleXY = __LAMDA_SCALE * __neg2pow(i + j);
_deltaXField[i][j].real *= scaleXY;
_deltaXField[i][j].imag *= scaleXY;
_deltaYField[i][j].real *= scaleXY;
_deltaYField[i][j].imag *= scaleXY;
}
}
}
void Alaska::pre_choppy()
{
//this function sets up the DX DY choppiness
// it assumes that the current c values are in position
// before the c values have been FFT'd
double k[2],klen;
for (int i=0;i<NX;i++)
{
for (int j=0;j<NY;j++)
{
// k[0]=2.0*PI*((float)i-.5*NX)/MAX_WORLD_X;
// k[1]=2.0*PI*((float)j-.5*NY)/MAX_WORLD_Y;
k[0]=hold_horizontal[i][j][0];
k[1]=hold_horizontal[i][j][1];
klen=sqrt(k[0]*k[0]+k[1]*k[1]);
if (klen==0)
{
mDeltaX[i][j].real=0.0;
mDeltaX[i][j].imag=0.0;
mDeltaY[i][j].real=0.0;
mDeltaY[i][j].imag=0.0;
}
else
{
mDeltaX[i][j].real=0.0;
mDeltaX[i][j].imag=c[i][j].imag*(-k[0]/klen);
mDeltaY[i][j].real=0.0;
mDeltaY[i][j].imag=c[i][j].imag*(-k[1]/klen);
}
}
}
dir=-1;
if (FFT2D(mDeltaX, NX, NY, dir)==FALSE){printf("false on DXFFT!\n");}
dir=-1;
if (FFT2D(mDeltaY, NX, NY, dir)==FALSE){printf("false on DYFFT!\n");}
for (int i=0;i<NX;i++)
{
for (int j=0;j<NY;j++)
{
mDeltaX[i][j].real *= (double) neg1Pow(i+j)*lambda;
mDeltaX[i][j].imag *= (double) neg1Pow(i+j)*lambda;
mDeltaY[i][j].real *= (double) neg1Pow(i+j)*lambda;
mDeltaY[i][j].imag *= (double) neg1Pow(i+j)*lambda;
}
}
}
void binary_save_frame (BinaryData *binary, unsigned long int start_offset, unsigned long int cur_offset)
{
char bmp_filename[1024];
static unsigned int frame_id = 0;
sprintf (bmp_filename, "%s/%s/%d_%s_FFT_0x%lx-0x%lx.bmp",
binary->output_folder, binary->path, frame_id++, binary->name, start_offset, cur_offset);
// Convert frame to complex matrix and compute FFT
COMPLEX **c = frame_to_complex (binary->frame);
FFT2D (c, binary->frame->size, binary->frame->size, 1);
// Output to bmp
bmpfile_t *bmp = complex_to_bmp (c, binary->frame->size);
bmp_save (bmp, bmp_filename);
// Cleaning
bmp_destroy (bmp);
frame_reset (binary->frame);
}
void ChoppySimulate::updateHeightField(float _deltaTime)
{
const int halfWay = WAVE_SIZE/2 +1;
for (int i = 0; i < halfWay; ++i)
{
for (int j = 0; j < WAVE_SIZE; ++j)
{
const float wkt = sqrt(_waveNum[i][j].z *__GRAVITY_CONSTANT) * this->_deltaTime;
const float cosValue = cos(wkt);
const float sinValue = sin(wkt);
const int otherX = WAVE_SIZE - i - 1;
const int otherY = WAVE_SIZE - j - 1;
//计算真实的高度场
_choppyField[i][j].real =_heightField[i][j].real * cosValue - _heightField[i][j].imag*sinValue
+_heightField[otherX][otherY].real*cosValue +_heightField[otherX][otherY].imag *sinValue;
_choppyField[i][j].imag = _heightField[i][j].real *sinValue + _heightField[i][j].imag*cosValue
-_heightField[otherX][otherY].real*sinValue + _heightField[otherX][otherY].imag*cosValue;
//计算 X-Y对称的高度场
if (i < halfWay - 1)
{
_choppyField[otherX][otherY].real = _heightField[otherX][otherY].real * cosValue - _heightField[otherX][otherY].imag*sinValue
+ _heightField[i][j].real*cosValue + _heightField[i][j].imag *sinValue;
_choppyField[otherX][otherY].imag = _heightField[otherX][otherY].real *sinValue + _heightField[otherX][otherY].imag*cosValue
- _heightField[i][j].real*sinValue + _heightField[i][j].imag*cosValue;
}
}
}
this->updateOffsetField(_deltaTime);
if (! FFT2D(_choppyField,WAVE_SIZE,WAVE_SIZE,-1))
{
printf("_choppyField FFT2D failed,please check.\n");
assert(0);
}
//修正相关的值
for (int i = 0; i < WAVE_SIZE; ++i)
{
for (int j = 0; j < WAVE_SIZE; ++j)
{
_choppyField[i][j].real *= __neg2pow(i + j);
}
}
//生成法线
const float fixX=2.0f;
const float fixY = 2.0f;
for (int i = 0; i < WAVE_SIZE; ++i)
{
const int otherX = i < WAVE_SIZE - 1 ? i + 1 : 0;
for (int j = 0; j < WAVE_SIZE; ++j)
{
const int otherY = j < WAVE_SIZE - 1 ? j +1: 0;
//GLVector3 xVec = GLVector3(fixX + _deltaXField[otherX][j].imag - _deltaXField[i][j].imag,
// _deltaYField[otherX][j].imag - _deltaYField[i][j].imag,
// (_choppyField[otherX][j].imag - _choppyField[i][j].imag)*__HEIGHT_SCALE__
// );
//GLVector3 yVec = GLVector3(_deltaXField[i][otherY].imag - _deltaXField[i][j].imag,
// fixY + _deltaYField[i][otherY].imag - _deltaYField[i][j].imag,
// (_choppyField[i][otherY].imag - _choppyField[i][j].imag) * __HEIGHT_SCALE__
// );
//GLVector3 xVec = GLVector3(fixX, _deltaYField[i][otherY].imag - _deltaYField[i][j].imag, (_choppyField[otherX][j].real - _choppyField[i][j].real) *__HEIGHT_SCALE__);
//GLVector3 yVec = GLVector3(_deltaXField[otherX][j].imag - _deltaXField[i][j].imag, fixY, (_choppyField[i][otherY].real - _choppyField[i][j].real)*__HEIGHT_SCALE__);
GLVector3 xVec = GLVector3(fixX, 0.0f, (_choppyField[otherX][j].real - _choppyField[i][j].real) *__HEIGHT_SCALE__);
GLVector3 yVec = GLVector3(0.0f, fixY, (_choppyField[i][otherY].real - _choppyField[i][j].real)*__HEIGHT_SCALE__);
_choppyNormal[i][j] = xVec.cross(yVec);
}
}
}
int main(int argc, char **argv) {
int commandArgs = 1;
int i;
char x;
char performContrast = 0;
char fft_filename[FILENAME_LENGTH];
char cdf_filename[FILENAME_LENGTH];
char histo_filename[FILENAME_LENGTH];
float contrastLow = 0.0;
float contrastHigh = 0.0;
float highpasslevel;
float lowpasslevel;
float percentCorrupt;
float sigma;
float brightness;
float sat;
int m;
int replaceWithM;
int performHistogram = 0;
int performCDF = 0;
int performFFT = 0;
int performVectorMedianFilter = 0;
int performMedianFilter = 0;
int performMeanFilter = 0;
int performSpacialFilter = 0;
int performLevelSlicing = 0;
int performEqualize = 0;
int performColorScale = 0;
int performSpatialReduceWidth = 0;
int performSpatialReduceHeigth = 0;
int performHighpass = 0;
int performLowpass = 0;
int performComponentMedianFilter = 0;
int performVectorOrderStatistic = 0;
int performVectorSpacialOrderStatistic = 0;
int performVectorMedianOrderStatistic = 0;
int performMinkowskiAddition = 0;
int performMinkowskiSubtraction = 0;
int performMinkowskiOpening = 0;
int performMinkowskiClosing = 0;
int performEdgeDetectOne = 0;
int performEdgeDetectTwo = 0;
int performEdgeDetectThree = 0;
int performEdgeDetectFour = 0;
int performAddGaussianNoise = 0;
int performAddSaltPepperNoise = 0;
int performSetBrightness = 0;
int performSetSaturation = 0;
int performBrightFilter = 0;
int imageWriteNecessary = 0;
int maskwidth = 0;
int maskheight = 0;
int maskrepeat = 0;
FILE *in = stdin;
FILE *out = stdout;
struct portImage *pi;
if (argc < 3) {
printf("\n");
printf(" Usage: %s [inputFile] ([outputFile]) [option] ([option] ...)\n", argv[0]);
printf("\n");
printf(" InputFile: Either a filename or '-' for stdin.\n");
printf(" OutputFile: Either a filename or '-' for stdout. (Not needed if no output necessary.)\n");
printf("\n");
printf(" Options:\n");
printf(" -ghisto FILENAME Graph Histogram\n");
printf(" -gcdf FILENAME Graph Cumulative Distribution\n");
printf(" -gfft FILENAME Graph FFT plot\n");
printf(" -color n Reduce color scale to n\n");
printf(" -spatial WIDTH-HEIGHT Perform spacial reduction to Width and Height\n");
printf(" -level n Perform level slicing from graylevel n to graylevel n+10\n");
printf(" -con LOW-HIGH Scale image contrast from LOW graylevel percentage to HIGH graylevel percentage\n");
printf(" -equ Histogram Eqaulization\n");
printf(" -medianf n Simple Median Filter of window size n*n\n");
printf(" -meanf n Simple Mean Filter of window size n*n\n");
printf(" -cmf n Component Median Filter of window size n*n\n");
printf(" -vmf n Vector Median Filter of window n*n\n");
printf(" -sf Spacial Filter\n");
printf(" -vos n v Vector Order Stat of window size n*n and value v\n");
printf(" -vmos n m [01] Vector Median Order Stat of window size n*n, m threshold, and 0 or 1(True) replace with m\n");
printf(" -vsos n m [01] Vector Spacial Order Stat of window size n*n, m threshold, and 0 or 1(True) replace with m\n");
printf(" -brightf n Perform an Brightness filter using HSV colorspace on size n*n window.\n");
printf(" -bright %% Set brightness to %% percent\n");
printf(" -sat %% Set saturation to %% percent\n");
printf(" -hp %% Highpass filter of %% percent\n");
printf(" -lp %% Lowpass filter of %% percent\n");
printf(" -ma NxM R Perform Minkowski Addition using NxM mask, repeated R times.\n");
printf(" -ms NxM R Perform Minkowski Subtraction using NxM mask, repeated R times.\n");
printf(" -mo NxM R Perform Minkowski Opening using NxM mask, repeated R times.\n");
printf(" -mc NxM R Perform Minkowski Closing using NxM mask, repeated R times.\n");
printf(" -e1 Perform Edge Detection using X/(X – B)\n");
printf(" -e2 Perform Edge Detection using (X + B)/X\n");
printf(" -e3 Perform Edge Detection using [(X+B)/(X-B)]-B\n");
printf(" -e4 n Experimental Edge Detection on Color Images using n*n window.\n");
printf(" -noiseG p s Add Gaussian noise to p (0 to 1 floating) percent of image with s sigma noise.\n");
printf(" -noiseSP p Add Salt and Pepper noise to p (0 to 1 floating) percent of image.\n");
printf("\n");
return(1);
}
if (strcmp(argv[commandArgs], "-") != 0) {
in = fopen(argv[1],"r");
if (in == NULL) {
fprintf(stderr, "File '%s' failed to open for reading.\n", argv[1]);
exit(1);
}
}
commandArgs++;
if (strcmp(argv[commandArgs], "-") != 0 && argv[commandArgs][0] != '-') {
commandArgs++;
out = fopen(argv[2],"w");
if (out == NULL) {
fprintf(stderr, "File '%s' failed to open for writing.\n", argv[2]);
exit(1);
}
}
for (; commandArgs < argc; commandArgs++) {
if (strcmp(argv[commandArgs], "-color") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performColorScale);
}
if (strcmp(argv[commandArgs], "-spatial") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &performSpatialReduceWidth, &x, &performSpatialReduceHeigth);
}
if (strcmp(argv[commandArgs], "-level") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performLevelSlicing);
}
if (strcmp(argv[commandArgs], "-con") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%f%c%f", &contrastLow, &performContrast, &contrastHigh);
}
if (strcmp(argv[commandArgs], "-vos") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performVectorOrderStatistic);
commandArgs++;
sscanf(argv[commandArgs], "%d", &m);
}
if (strcmp(argv[commandArgs], "-vmf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performVectorMedianFilter);
}
if (strcmp(argv[commandArgs], "-sf") == 0) {
imageWriteNecessary = 1;
performSpacialFilter = 1;
}
if (strcmp(argv[commandArgs], "-vmos") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performVectorMedianOrderStatistic);
commandArgs++;
sscanf(argv[commandArgs], "%d", &m);
commandArgs++;
sscanf(argv[commandArgs], "%d", &replaceWithM);
}
if (strcmp(argv[commandArgs], "-vsos") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performVectorSpacialOrderStatistic);
commandArgs++;
sscanf(argv[commandArgs], "%d", &m);
commandArgs++;
sscanf(argv[commandArgs], "%d", &replaceWithM);
}
if (strcmp(argv[commandArgs], "-cmf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performComponentMedianFilter);
}
if (strcmp(argv[commandArgs], "-medianf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performMedianFilter);
}
if (strcmp(argv[commandArgs], "-meanf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performMeanFilter);
}
if (strcmp(argv[commandArgs], "-equ") == 0) {
imageWriteNecessary = 1;
performEqualize = 1;
}
if (strcmp(argv[commandArgs], "-hp") == 0) {
imageWriteNecessary = 1;
commandArgs++;
performHighpass = 1;
sscanf(argv[commandArgs], "%f", &highpasslevel);
}
if (strcmp(argv[commandArgs], "-lp") == 0) {
imageWriteNecessary = 1;
commandArgs++;
performLowpass = 1;
sscanf(argv[commandArgs], "%f", &lowpasslevel);
}
if (strcmp(argv[commandArgs], "-brightf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performBrightFilter);
}
if (strcmp(argv[commandArgs], "-bright") == 0) {
imageWriteNecessary = 1;
commandArgs++;
performSetBrightness = 1;
sscanf(argv[commandArgs], "%f", &brightness);
}
if (strcmp(argv[commandArgs], "-sat") == 0) {
imageWriteNecessary = 1;
commandArgs++;
performSetSaturation = 1;
sscanf(argv[commandArgs], "%f", &sat);
}
if (strcmp(argv[commandArgs], "-ghisto") == 0) {
commandArgs++;
performHistogram = 1;
strncpy(histo_filename, argv[commandArgs], FILENAME_LENGTH);
}
if (strcmp(argv[commandArgs], "-gcdf") == 0) {
commandArgs++;
performCDF = 1;
strncpy(cdf_filename, argv[commandArgs], FILENAME_LENGTH);
}
if (strcmp(argv[commandArgs], "-gfft") == 0) {
commandArgs++;
performFFT = 1;
strncpy(fft_filename, argv[commandArgs], FILENAME_LENGTH);
}
if (strcmp(argv[commandArgs], "-ma") == 0) {
imageWriteNecessary = 1;
performMinkowskiAddition = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &maskwidth, &x, &maskheight);
commandArgs++;
sscanf(argv[commandArgs], "%d", &maskrepeat);
}
if (strcmp(argv[commandArgs], "-ms") == 0) {
imageWriteNecessary = 1;
performMinkowskiSubtraction = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &maskwidth, &x, &maskheight);
commandArgs++;
sscanf(argv[commandArgs], "%d", &maskrepeat);
}
if (strcmp(argv[commandArgs], "-mo") == 0) {
imageWriteNecessary = 1;
performMinkowskiOpening = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &maskwidth, &x, &maskheight);
commandArgs++;
sscanf(argv[commandArgs], "%d", &maskrepeat);
}
if (strcmp(argv[commandArgs], "-mc") == 0) {
imageWriteNecessary = 1;
performMinkowskiClosing = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &maskwidth, &x, &maskheight);
commandArgs++;
sscanf(argv[commandArgs], "%d", &maskrepeat);
}
if (strcmp(argv[commandArgs], "-e1") == 0) {
imageWriteNecessary = 1;
performEdgeDetectOne = 1;
}
if (strcmp(argv[commandArgs], "-e2") == 0) {
imageWriteNecessary = 1;
performEdgeDetectTwo = 1;
}
if (strcmp(argv[commandArgs], "-e3") == 0) {
imageWriteNecessary = 1;
performEdgeDetectThree = 1;
}
if (strcmp(argv[commandArgs], "-e4") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performEdgeDetectFour);
}
if (strcmp(argv[commandArgs], "-noiseG") == 0) {
imageWriteNecessary = 1;
performAddGaussianNoise = 1;
commandArgs++;
sscanf(argv[commandArgs], "%f", &percentCorrupt);
commandArgs++;
sscanf(argv[commandArgs], "%f", &sigma);
}
if (strcmp(argv[commandArgs], "-noiseSP") == 0) {
imageWriteNecessary = 1;
performAddSaltPepperNoise = 1;
commandArgs++;
sscanf(argv[commandArgs], "%f", &percentCorrupt);
}
}
pi = readImage(in);
if (performHighpass || performLowpass || performFFT) {
FFT2D(pi);
if (performHighpass) highpass(pi, highpasslevel);
if (performLowpass) lowpass(pi, lowpasslevel);
if (performFFT) graph_fftlogplot(pi, fft_filename);
IFFT2D(pi);
}
if (performEdgeDetectOne || performEdgeDetectTwo || performEdgeDetectThree ||
performMinkowskiAddition || performMinkowskiSubtraction || performMinkowskiOpening || performMinkowskiClosing)
thresholdImage(pi);
if (performAddGaussianNoise) addGaussianNoise(pi, percentCorrupt, sigma);
if (performAddSaltPepperNoise) addSaltPepperNoise(pi, percentCorrupt);
if (performMedianFilter) simpleMedianFilter(pi, performMedianFilter);
if (performMeanFilter) simpleMeanFilter(pi, performMeanFilter);
if (performComponentMedianFilter) componentMedianFilter(pi, performComponentMedianFilter);
if (performVectorOrderStatistic) vectorOrderStatistic(pi, performVectorOrderStatistic, m);
if (performVectorSpacialOrderStatistic) vectorSpacialOrderStatistic(pi, performVectorSpacialOrderStatistic, m, replaceWithM);
if (performVectorMedianOrderStatistic) vectorMedianOrderStatistic(pi, performVectorMedianOrderStatistic, m, replaceWithM);
if (performVectorMedianFilter) vectorMedianFilter(pi, performVectorMedianFilter);
if (performSpacialFilter) spacialFilter(pi);
if (performBrightFilter) HSV_ValueFilter(pi, performBrightFilter);
if (performColorScale) scale_reduce(pi,performColorScale);
if (performSetBrightness) setBrightness(pi,brightness);
if (performSetSaturation) setSaturation(pi,sat);
if (performSpatialReduceWidth) spacial_reduce(pi,performSpatialReduceWidth, performSpatialReduceHeigth);
if (performContrast) contrast_stretching(pi, contrastLow, contrastHigh);
if (performLevelSlicing) level_slice(pi, performLevelSlicing);
if (performEqualize) equalize(pi);
if (performHistogram) graph_histogram(pi, histo_filename);
if (performCDF) graph_cdf(pi, cdf_filename);
if (performMinkowskiAddition)
for (i = 0; i < maskrepeat; i++)
minkowskiAddition(pi, maskwidth, maskheight);
if (performMinkowskiSubtraction)
for (i = 0; i < maskrepeat; i++)
minkowskiSubtraction(pi, maskwidth, maskheight);
if (performMinkowskiOpening)
for (i = 0; i < maskrepeat; i++)
minkowskiOpening(pi, maskwidth, maskheight);
if (performMinkowskiClosing)
for (i = 0; i < maskrepeat; i++)
minkowskiClosing(pi, maskwidth, maskheight);
if (performEdgeDetectOne) {
struct portImage *pc = copyImage(pi);
imageWriteNecessary = 1;
minkowskiSubtraction(pc, 3, 3);
minkowskiDivision(pi, pc);
freeImage(pc);
}
if (performEdgeDetectTwo) {
struct portImage *pc = copyImage(pi);
imageWriteNecessary = 1;
minkowskiAddition(pi, 3, 3);
minkowskiDivision(pi, pc);
freeImage(pc);
}
if (performEdgeDetectThree) {
struct portImage *pd = copyImage(pi);
maskrepeat = 3;
imageWriteNecessary = 1;
for (i = 0; i < maskrepeat; i++) {
minkowskiAddition(pi, 3, 3);
minkowskiSubtraction(pd, 3, 3);
}
minkowskiDivision(pi, pd);
minkowskiSubtraction(pi, 3, 3);
freeImage(pd);
}
if (imageWriteNecessary)
writeImage(pi, out);
freeImage(pi);
if (in != stdin) fclose(in);
if (out != stdout) fclose(out);
return 0;
} /* End Main */
int main(int argc,char **args)
{
PetscInt rank,size,npt;
PetscScalar dx,dy,cx,cy;
PetscErrorCode ierr;
Vec x,x0,tempvec, *vinda,*vindb,*vindc;
PetscInt i,j,k,n,n2,pmax,puse,Istart,Iend,localsize,niter;
PetscScalar **x0array, **aarray,**barray;
PetscInt *cacheInt;
PetscScalar *cacheScalar;
DA myDA;
PetscScalar *Mixnorm;
PetscInt iter,*iterind,*nind;
FILE *fidoutput, *fidtimelog;
char fname[50],ftimelog[50];
PetscViewer socketviewer;
PetscInt withMatlab, doFFT, doSmoothing;
PetscTruth Matlabflag, FFTflag, Smoothingflag;
PetscInt timelogcount;
MPI_Status status;
PetscLogDouble v1,v2,elapsed_time;
timelogcount = 0;
PetscInitialize(&argc,&args,(char *)0,help);
MPI_Comm_size(PETSC_COMM_WORLD,&size);
MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\nPETSC: Petsc Initializes successfully! \n");
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: comm_size is %d \n", size);
ierr = PetscOptionsGetInt(PETSC_NULL,"-withMatlab",&withMatlab,&Matlabflag);CHKERRQ(ierr);
if (Matlabflag == PETSC_FALSE){withMatlab = 0;}else{withMatlab = 1;}
ierr = PetscOptionsGetInt(PETSC_NULL,"-doFFT",&doFFT,&FFTflag);CHKERRQ(ierr);
if (FFTflag == PETSC_FALSE){doFFT = 0;}else{doFFT = 1;}
ierr = PetscOptionsGetInt(PETSC_NULL,"-doSmoothing",&doSmoothing,&Smoothingflag);CHKERRQ(ierr);
if (Smoothingflag == PETSC_FALSE){doSmoothing = 0;}else{doSmoothing = 1;}
if(withMatlab==1){
// Rank 0 connects to socket, use default socket
PetscViewerSocketOpen(PETSC_COMM_WORLD,0,PETSC_DEFAULT,&socketviewer);
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: socket opened! \n");CHKERRQ(ierr);
// Receive n from Matlab
IntReceive(socketviewer, &nind);
n = *nind;
// Receive iter from Matlab
IntReceive(socketviewer, &iterind);
iter = *iterind;
}else{
ierr = PetscOptionsGetInt(PETSC_NULL,"-ngrid",&n,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL,"-niter",&iter,PETSC_NULL);CHKERRQ(ierr);
}
/////////////////////////////////////////////////////////////////////////////////////
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: number of grid is %d \n", n);
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: number of iteration is %d \n", iter);
Mixnorm = malloc(iter*sizeof(PetscScalar));
dx = 1.0/n;
dy = 1.0/n;
n2 = (PetscInt)(n*0.5);
npt = 5;
pmax = 5e5;
puse = pmax;
PetscInt logmax = 1000;
PetscScalar Timelog[logmax];
PetscLogDouble t1,t2;
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: estimated buffer size (per processer) %f Mbytes \n", pmax*1.0/1e6*8*17 );
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: estimated variable size %f Mbytes\n", 1.0*n*n/1e6*8*1);
/////////////////////////////////////////////////////////////////////////////////////
// ierr = VecCreateMPI(PETSC_COMM_WORLD,PETSC_DECIDE ,n,&tempvec);CHKERRQ(ierr);
// ierr = VecGetOwnershipRange(tempvec,&Istart,&Iend);CHKERRQ(ierr);
// localsize = Iend-Istart;
// ierr = VecDestroy(tempvec);CHKERRQ(ierr);
/////////////////////////////////////////////////////////////////////////////////////
if(doSmoothing==1){
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n\n\n\n\nPETSC: Now Do DACreate2d \n\n\n\n" );
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n\n\n\n\nPETSC: %d %d %d\n\n\n\n",n2,n,size);
DACreate2d(MPI_COMM_WORLD,DA_XYPERIODIC,DA_STENCIL_BOX,n2,n,1,size,1,2,PETSC_NULL,PETSC_NULL,&myDA);
DACreateGlobalVector(myDA,&x0);
DAGetCorners(myDA,PETSC_NULL,&Istart,PETSC_NULL,PETSC_NULL,&localsize,PETSC_NULL);
Iend = Istart+localsize;
}else{
ierr = VecCreateMPI(PETSC_COMM_WORLD,PETSC_DECIDE ,n,&tempvec);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(tempvec,&Istart,&Iend);CHKERRQ(ierr);
localsize = Iend-Istart;
ierr = VecDestroy(tempvec);CHKERRQ(ierr);
VecCreateMPI(PETSC_COMM_WORLD,localsize*n2,PETSC_DETERMINE ,&x0);
}
//ierr = PetscPrintf(PETSC_COMM_WORLD,"\n\n\n\n\nPETSC: So far so good\n\n\n\n");
VecGetArray2d(x0,n2,localsize,0,0,&x0array);
// Create initial vector
for(j=0;j<localsize;j++){
for(i=0;i<n2;i++){
cx = (Istart+j+0.5)*dx;
x0array[i][j] = cos(2*M_PI*cx);
}
}
VecRestoreArray2d(x0,n2,localsize,0,0,&x0array);
ierr = VecDuplicate(x0,&x);CHKERRQ(ierr);
ierr = VecNorm(x0,NORM_2,Mixnorm); CHKERRQ(ierr);
PetscPrintf(PETSC_COMM_WORLD,"PETSC: initial norm= %f \n",*(Mixnorm+0)/n );
vinda = &x0;
vindb = &x;
sprintf(fname, "mixnorm_%d_%d",n,iter);
ierr =PetscPrintf(PETSC_COMM_WORLD,"\n iter norm time unit time\n");CHKERRQ(ierr);
ierr =PetscFOpen(PETSC_COMM_WORLD,fname,"w",&fidoutput);CHKERRQ(ierr);
///////////////////////////////////////////////////////////////////////////////////////////////////
// Memory allocation for the iteration scheme
// cacheInt = malloc(1*pmax*sizeof(PetscInt));
// cacheScalar = malloc(2*pmax*sizeof(PetscScalar));
cacheInt = malloc(2*pmax*sizeof(PetscInt));
cacheScalar = malloc(2*pmax*sizeof(PetscScalar));
///////////////////////////////////////////////////////////////////////////////////////////////////
// Iteration here!
for(niter=0;niter<iter;niter++){
ierr = PetscGetTime(&v1);CHKERRQ(ierr);
// BackwardAverage(vinda, vindb, cacheInt, cacheScalar, n, npt, pmax, Istart,Iend);
// BackwardAverageR(vinda, vindb, cacheInt, cacheScalar, n, npt, pmax, Istart,Iend);
BackwardAverageRL(vinda, vindb, cacheInt, cacheScalar, n, npt, pmax, Istart,Iend);
vindc = vindb;
vindb = vinda;
vinda = vindc;
// if(doSmoothing==1){Smoothing(vinda, vindb,n, myDA, Istart,Iend);}
ierr = PetscGetTime(&v2);CHKERRQ(ierr);
//vindc = vindb;
//vindb = vinda;
//vinda = vindc;
ierr = VecNorm(*vinda,NORM_2,Mixnorm+niter); CHKERRQ(ierr);
*(Mixnorm+niter) = *(Mixnorm+niter)/n;
elapsed_time = v2 - v1;
PetscPrintf(PETSC_COMM_WORLD," %d %f %f %f \n",niter,*(Mixnorm+niter),elapsed_time,elapsed_time/n/n*1e6 );
PetscFPrintf(PETSC_COMM_WORLD,fidoutput," %d %f %f %f\n"
,niter,*(Mixnorm+niter),elapsed_time,elapsed_time/n/n*1e6 );
}
////////////////////////////////////////////////////////////////////////////////////////////////////
//Change oremtation of vector
VecGetArray2d(*vinda,n2,localsize,0,0,&aarray);
VecGetArray2d(*vindb,localsize,n2,0,0,&barray);
for(j=0;j<localsize;j++){
for(i=0;i<n2;i++){
barray[j][i] = aarray[i][j];
}
}
VecRestoreArray2d(*vinda,n2,localsize,0,0,&aarray);
VecRestoreArray2d(*vindb,localsize,n2,0,0,&barray);
vindc = vindb;
vindb = vinda;
vinda = vindc;
////////////////////////////////////////////////////////////////////////////////////////////////////
// FFT part
if(doFFT==1){FFT2D(*vinda,*vindb, localsize, n, Istart,Iend, iter,doSmoothing);}
////////////////////////////////////////////////////////////////////////////////////////////////////
/*
if(rank==0){
sprintf(ftimelog, "timelog_%d_%d",n,iter);
fidtimelog = fopen(ftimelog,"w");
for(i=0;i<timelogcount;i++){ fprintf(fidtimelog,"%f ",Timelog[i]); }
fprintf(fidtimelog,"\n ");
for(j = 1;j<size;j++){
MPI_Recv(Timelog,timelogcount,MPI_DOUBLE,j,j,PETSC_COMM_WORLD,&status);
for(i=0;i<timelogcount;i++){ fprintf(fidtimelog,"%f ",Timelog[i]); }
fprintf(fidtimelog,"\n ");
}
fclose(fidtimelog);
}else{
MPI_Send(Timelog ,timelogcount,MPI_DOUBLE,0,rank,PETSC_COMM_WORLD);
}
PetscFClose(PETSC_COMM_WORLD,fidoutput);
*/
///////////////////////////////////////////////////////////////////////////
if(withMatlab==1){
VecView(*vinda,socketviewer);
PetscScalarView(iter,Mixnorm,socketviewer);
}
// free(x0array);
free(Mixnorm);
free(cacheInt);
free(cacheScalar);
ierr = VecDestroy(x0);CHKERRQ(ierr);
ierr = VecDestroy(x);CHKERRQ(ierr);
PetscPrintf(PETSC_COMM_WORLD,"Done!");
//////////////////////////////////////////////////////////////////////////////////////
ierr = PetscFinalize();CHKERRQ(ierr);
//************************************
// Method: FF2D
// FullName: CFFTMachine::FF2D
// Access: public
// Returns: CImgSource*
// Qualifier:
// Parameter: CImgSource * in_pSrcImg
//************************************
procStatus CFFTMachine::Run( CImgSource* in_pSrcImg, CImgFourierSource* out_pDesImg, FourierDirection eDirection )
{
procStatus eRetCode = eNormal;
ASSERT (out_pDesImg);
ASSERT (in_pSrcImg);
SourceType eType = in_pSrcImg->GetType();
if( eType < eSrcMonoBitmap)
{
AfxMessageBox(IMP_MSG_ADDSRC_INVALIDTYPE);
eRetCode = eInvalidOp;
}
if(eRetCode != eNormal) return eRetCode;
COMPLEX** ppSource = NULL;
Bitmap* pResBmp = NULL;
INT nWidth = 0;
INT nHeight = 0;
nWidth = in_pSrcImg->GetSourceRef()->GetWidth();
nHeight = in_pSrcImg->GetSourceRef()->GetHeight();
//Convert bitmap to complex in memory
ppSource = allocateComplexArray(nHeight, nWidth);
if(ppSource == NULL)
{
eRetCode = eMemAllocErr;
}
if (eRetCode == eNormal)eRetCode = getComplexImage(in_pSrcImg, ppSource);
//Run 2D Fourier transform
if(eRetCode == eNormal)
{
BOOL ffRetults = TRUE;
//run Fourier transform
eRetCode = FFT2D(ppSource, nWidth, nHeight, eDirection);
}
//Convert from complex to bitmap
if(eRetCode == eNormal)
{
#ifdef _DEBUG
// for (INT row=0; row<nHeight; row++)
// for(INT col=0; col<nWidth; col++)
// TRACE("\nrow:%d \tcol:%d real:%f imag:%f",row, col, ppSource[row][col].real, ppSource[row][col].imag);
#endif
pResBmp = getBitmapFromComplex(ppSource, nWidth, nHeight);
if(pResBmp == NULL)
{
eRetCode = eSystemErr;
}
}
//Create ImgSource object
if(eRetCode == eNormal)
{
out_pDesImg->SetType(eSrcFourierBitmap);
out_pDesImg->AttachSource(pResBmp);
out_pDesImg->SetName(in_pSrcImg->GetName() + IMP_SUF_FOURIER);
out_pDesImg->m_oFFresult.nWidth= nWidth;
out_pDesImg->m_oFFresult.nHeight = nHeight;
out_pDesImg->m_oFFresult.ppComplex= ppSource;
}
else
{
freeAllocateComplex(ppSource, nHeight, nWidth);
}
return eRetCode;
}
void Alaska::display(void)
{
//double kvector[2];
double klength,wkt;
//////////////////alernativ below///////////
int yHalf = NY/2 + 1;
for (int i = 0; i<yHalf; ++i)
{
//int yLine = i*NY;
// Mirror the y line index for calculation of -k
// The line below evalutes yLineMirr = y == 0 ? 0 : (mYSize-y)*mXSize;
// by wrapping the heightmap, since it is periodic.
//int yLineMirr = ((NY-i)% NY)*NY;
for (int j = 0; j<NX; ++j)
{
//kvector[0]=2.0*PI*((float)i-.5*NX)/NX;//I was using these
//kvector[1]=2.0*PI*((float)j-.5*NY)/NY;
// kvector[0]=2.0*PI*((float)i-.5*NX)/MAX_WORLD_X;//but I think I should use these
// kvector[1]=2.0*PI*((float)j-.5*NY)/MAX_WORLD_Y;
//kvector[0]=hold_horizontal[i][j][0];
//kvector[1]=hold_horizontal[i][j][1];
// klength=sqrt(kvector[0]*kvector[0]+kvector[1]*kvector[1]);
klength=hold_horizontal[i][j][2];
wkt = sqrt(klength * GRAV_CONSTANT) * dtime;
// yLineMirr+mXSize-x is the index of -k
//int kNegIndex = yLineMirr*NY + ((NY-j)% NY);
// This is h~(K, t) from the Tessendorf paper.
c[i][j].real= mH0[i][j].real*cos(wkt)
+ mH0[i][j].imag*sin(wkt)
+ mH0[NX - i-1][NY - j-1].real*cos(wkt)
- mH0[NX - i-1][NY -j-1].imag*sin(wkt);
c[i][j].imag= mH0[i][j].imag*cos(wkt)
+ mH0[i][j].real*sin(wkt)
-mH0[NX - i-1][NY - j-1].imag*cos(wkt)
- mH0[NX - i-1][NY -j-1].real*sin(wkt);
// Store it for later transformation
// h~(-K) = conj(h~(K))
if (i != yHalf-1)
{
c[NX - i-1][NY - j-1].imag= mH0[i][j].real*cos(wkt)
+ mH0[i][j].imag*sin(wkt)
+ mH0[NX - i-1][NY - j-1].real*cos(wkt)
- mH0[NX - i-1][NY -j-1].imag*sin(wkt);
c[NY - i-1][NY - j-1].real= mH0[i][j].imag*cos(wkt)
+ mH0[i][j].real*sin(wkt)
-mH0[NX - i-1][NY - j-1].imag*cos(wkt)
- mH0[NX - i-1][NY -j-1].real*sin(wkt);
}
}
}
//////////////////end alternative////////////
pre_choppy();
dir=-1;
FFT2D(c, NX, NY, dir);// do the inverse FFT to get the surface
///////////////negative power term creation
for (int i=0;i<NX;i++)
{
for (int j=0;j<NY;j++)
{
c[i][j].real *= float(neg1Pow(i+j));
// while we are looping, set up the final x,y values for display
displayXY[i][j][0]=((double)i/NX)*MAX_WORLD_X+mDeltaX[i][j].imag;
displayXY[i][j][1]=((double)j/NY)*MAX_WORLD_Y+mDeltaY[i][j].imag;
}
}
make_normals(c);
prep_loop(); //this loop loads the actual sea vertices
}
BOOL TransformImage(const CImage& original,CImage& transformed,CImage& originalProcessed,CImage& transformedProcessed)
{
COMPLEX_NUMBER** data = (COMPLEX_NUMBER**)malloc(sizeof(COMPLEX_NUMBER*)*original.GetHeight());
for(long y = 0; y < original.GetHeight(); ++y)
{
data[y] = (COMPLEX_NUMBER*)malloc(sizeof(COMPLEX_NUMBER)*original.GetWidth());
for(long x = 0; x < original.GetWidth(); ++x)
{
data[y][x].real = ((LONG)GetRValue(original.GetPixel(x,y)) + (LONG)GetGValue(original.GetPixel(x,y)) + (LONG)GetBValue(original.GetPixel(x,y))) / 3.0f;
data[y][x].imag = 0;
}
}
FFT2D(data,original.GetWidth(),original.GetHeight(),1);
if(!transformed.Create(original.GetWidth(),original.GetHeight(),24))
{
for(long y = 0; y < original.GetHeight(); ++y)
free(data[y]);
free(data);
return FALSE;
}
for(long y = 0; y < original.GetHeight(); ++y)
{
for(long x = 0; x < original.GetWidth(); ++x)
{
FLOAT power = sqrtf(data[y][x].real * data[y][x].real + data[y][x].imag * data[y][x].imag);
transformed.SetPixel(x < original.GetWidth()/2 ? original.GetWidth()/2 + x : x - original.GetWidth()/2,y < original.GetHeight()/2 ? original.GetHeight()/2 + y : y - original.GetHeight()/2,RGB(power*128,power*128,power*128));
}
}
///
AmplitudeBandpassFilter(data,original.GetWidth(),original.GetHeight(),0/128.0f,150/128.0f);
//FrequencyBandpassFilter(data,original.GetWidth(),original.GetHeight(),50,100);
///
if(!transformedProcessed.Create(original.GetWidth(),original.GetHeight(),24))
{
for(long y = 0; y < original.GetHeight(); ++y)
free(data[y]);
free(data);
return FALSE;
}
for(long y = 0; y < original.GetHeight(); ++y)
{
for(long x = 0; x < original.GetWidth(); ++x)
{
FLOAT power = sqrtf(data[y][x].real * data[y][x].real + data[y][x].imag * data[y][x].imag);
transformedProcessed.SetPixel(x < original.GetWidth()/2 ? original.GetWidth()/2 + x : x - original.GetWidth()/2,y < original.GetHeight()/2 ? original.GetHeight()/2 + y : y - original.GetHeight()/2,RGB(power*128,power*128,power*128));
}
}
FFT2D(data,original.GetWidth(),original.GetHeight(),-1);
if(!originalProcessed.Create(original.GetWidth(),original.GetHeight(),24))
{
for(long y = 0; y < original.GetHeight(); ++y)
free(data[y]);
free(data);
return FALSE;
}
for(long y = 0; y < original.GetHeight(); ++y)
{
for(long x = 0; x < original.GetWidth(); ++x)
{
FLOAT power = sqrt(data[y][x].real * data[y][x].real + data[y][x].imag * data[y][x].imag);
originalProcessed.SetPixel(x,y,RGB(power,power,power));
}
}
for(long y = 0; y < original.GetHeight(); ++y)
free(data[y]);
free(data);
return TRUE;
}
void initTextures()
{
glGenTextures(1, &texname);
glBindTexture(GL_TEXTURE_2D, texname);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
float *texels = malloc(WIDTH*HEIGHT*sizeof(float));
int u, v;
for(v=0; v<HEIGHT; v++) {
for(u=0; u<WIDTH; u++) {
texels[v*WIDTH+u] = (float)(random()%1931)/1931.f;
texels[v*WIDTH+u] = sin(3.14*(float)(u+0.5)/128.f*16.f)*0.5+0.5;
//texels[v*WIDTH+u] *= sin(3.14*(float)v/128.f*6.f+3.14)*0.5+0.5;
//texels[v*WIDTH+u] = 0;
}
}
for(v=50; v<78; v++)
for(u=50; u<78; u++) texels[v*WIDTH+u] = 1;
readEXRRED("/Users/jianzhang/Pictures/tomcat.exr", WIDTH, HEIGHT, texels);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE32F_ARB, WIDTH, HEIGHT, 0, GL_LUMINANCE, GL_FLOAT, texels);
float *dns = malloc(DNWIDTH*DNHEIGHT*sizeof(float));
for(v=0; v<DNHEIGHT; v++) {
for(u=0; u<DNWIDTH; u++) {
dns[v*DNWIDTH+u] = downsample(u, v, texels);
}
}
glGenTextures(1, &dnname);
glBindTexture(GL_TEXTURE_2D, dnname);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE32F_ARB, DNWIDTH, DNHEIGHT, 0, GL_LUMINANCE, GL_FLOAT, dns);
float *ups = malloc(WIDTH*HEIGHT*sizeof(float));
for(v=0; v<HEIGHT; v++) {
for(u=0; u<WIDTH; u++) {
ups[v*WIDTH+u] = upsample(u, v, dns);
}
}
glGenTextures(1, &upname);
glBindTexture(GL_TEXTURE_2D, upname);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE32F_ARB, WIDTH, HEIGHT, 0, GL_LUMINANCE, GL_FLOAT, ups);
float *fine = malloc(WIDTH*HEIGHT*sizeof(float));
float *tmp = malloc(WIDTH*HEIGHT*sizeof(float));
for(v=0; v<HEIGHT; v++) {
for(u=0; u<WIDTH; u++) {
fine[v*WIDTH+u] = texels[v*WIDTH+u] - ups[v*WIDTH+u];
tmp[v*WIDTH+u] = fine[v*WIDTH+u];
}
}
int offset = WIDTH/2 + 1;
for(v=0; v<HEIGHT; v++) {
for(u=0; u<WIDTH; u++) {
fine[v*WIDTH+u] +=tmp[Modi(v+offset, HEIGHT)*WIDTH+Modi(u+offset, WIDTH)];
fine[v*WIDTH+u] = 0.5 + fine[v*WIDTH+u]*0.5;
}
}
glGenTextures(1, &fnname);
glBindTexture(GL_TEXTURE_2D, fnname);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE32F_ARB, WIDTH, HEIGHT, 0, GL_LUMINANCE, GL_FLOAT, fine);
COMPLEX *comimg = malloc(WIDTH*HEIGHT*sizeof(COMPLEX));
for(v=0; v<HEIGHT; v++) {
for(u=0; u<WIDTH; u++) {
comimg[v*WIDTH+u].real = 0;
comimg[v*WIDTH+u].imag = texels[v*WIDTH+u];
}
}
FFT2D(comimg, WIDTH, HEIGHT, 1);
for(v=0; v<HEIGHT; v++) {
for(u=0; u<WIDTH; u++) {
fine[Modi(v+64,HEIGHT)*WIDTH+Modi(u+64,WIDTH)] = 64*sqrt(comimg[v*WIDTH+u].real*comimg[v*WIDTH+u].real + comimg[v*WIDTH+u].imag * comimg[v*WIDTH+u].imag);
}
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE32F_ARB, WIDTH, HEIGHT, 0, GL_LUMINANCE, GL_FLOAT, fine);
free(comimg);
free(ups);
free(texels);
free(dns);
free(fine);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texname);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, dnname);
glUseProgram(program);
glUniform1i(glGetUniformLocation(program, "WhiteNoise"), 0);
glBindTexture(GL_TEXTURE_2D, texname);
glGenTextures(1, &kerneltex);
glBindTexture(GL_TEXTURE_1D, kerneltex);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexImage1D(GL_TEXTURE_1D, 0, GL_LUMINANCE32F_ARB, 32, 0, GL_LUMINANCE, GL_FLOAT, aCoeffs);
//glEnable(GL_TEXTURE_1D);
//glActiveTexture(GL_TEXTURE1);
//glBindTexture(GL_TEXTURE_1D, kerneltex);
glUniform1i(glGetUniformLocation(program, "FilterKernel"), 1);
}
