int sub_image (imageptr iptr, regionptr rptr, imageptr *optr)
{
int nx,ny,nz, nx1,ny1,nz1, ix,iy,iz, ix0,iy0,iz0;
size_t np, np1;
nx = Nx(iptr);
ny = Ny(iptr);
nz = Nz(iptr);
np = nx*ny*nz;
/* grab the bounding box */
ix0 = BLC(rptr)[0];
iy0 = BLC(rptr)[1];
iz0 = BLC(rptr)[2];
nx1 = TRC(rptr)[0] - ix0;
ny1 = TRC(rptr)[1] - iy0;
nz1 = TRC(rptr)[2] - iz0;
np1 = nx1*ny1*nz1;
*optr = (imageptr ) allocate(sizeof(image));
dprintf (DLEV,"copy_image:Allocated image @ %d size=%d * %d * %d",*optr,nx1,ny1,nz1);
Frame(*optr) = (real *) allocate(np1*sizeof(real));
dprintf (DLEV,"Frame allocated @ %d ",Frame(*optr));
Nx(*optr) = nx1;
Ny(*optr) = ny1;
Nz(*optr) = nz1;
Xmin(*optr) = Xmin(iptr) + ix0*Dx(iptr);
Ymin(*optr) = Ymin(iptr) + iy0*Dy(iptr);
Zmin(*optr) = Zmin(iptr) + iz0*Dz(iptr);
Dx(*optr) = Dx(iptr);
Dy(*optr) = Dy(iptr);
Dz(*optr) = Dz(iptr);
Namex(*optr) = mystrcpy(Namex(iptr));
Namey(*optr) = mystrcpy(Namey(iptr));
Namez(*optr) = mystrcpy(Namez(iptr));
Xref(*optr) = Xref(iptr) + ix0;
Yref(*optr) = Yref(iptr) + iy0;
Zref(*optr) = Zref(iptr) + iz0;
for (iz=0; iz<nz1; iz++)
for (iy=0; iy<ny1; iy++)
for (ix=0; ix<nx1; ix++)
CubeValue(*optr,ix,iy,iz) = CubeValue(iptr,ix-ix0,iy-iy0,iz-iy0);
Storage(*optr) = matdef[idef];
Axis(*optr) = Axis(iptr);
set_iarray(*optr);
return 1; /* succes return code */
}
void ini_matrix(imageptr *iptr, int nx, int ny)
{
int ix,iy;
printf ("iptr @ %d (sizeof = %d)\n",*iptr,sizeof(image));
if (*iptr==0) {
*iptr = (imageptr ) allocate((sizeof(image)));
printf ("allocated image 'iptr' @ %d\n",*iptr);
Frame(*iptr) = (real *) allocate (nx*ny*sizeof(real));
printf ("Allocated frame @ %d\n",Frame(*iptr));
} else {
printf ("Image already allocated @ %d\n",*iptr);
printf ("with Frame @ %d\n",Frame(*iptr));
}
Nx(*iptr) = nx;
Ny(*iptr) = ny;
Nz(*iptr) = 1;
Xmin(*iptr) = 1.0;
Ymin(*iptr) = 2.0;
Zmin(*iptr) = 3.0;
Dx(*iptr) = 0.1;
Dy(*iptr) = 0.1;
Dz(*iptr) = 0.1;
Namex(*iptr) = NULL; /* no axis names */
Namey(*iptr) = NULL;
Namez(*iptr) = NULL;
Unit(*iptr) = NULL; /* no units */
Mask(*iptr) = NULL;
set_iarray(*iptr);
for (ix=0; ix<nx; ix++)
for (iy=0; iy<ny; iy++)
MapValue(*iptr,ix,iy) = (ix*ny+iy)*0.1;
}
void nemo_main ()
{
setparams(); /* set par's in globals */
instr = stropen (infile, "r");
read_image (instr,&iptr);
/* set some global paramters */
nx = Nx(iptr);
ny = Ny(iptr);
nz = Nz(iptr);
xmin = Xmin(iptr);
ymin = Ymin(iptr);
zmin = Zmin(iptr);
dx = Dx(iptr);
dy = Dy(iptr);
dz = Dz(iptr);
if(hasvalue("gauss"))
make_gauss_beam(getparam("dir"));
outstr = stropen (outfile,"w");
if (hasvalue("wiener"))
wiener();
else
smooth_it();
write_image (outstr,iptr);
strclose(instr);
strclose(outstr);
}
int copy_image (imageptr iptr, imageptr *optr)
{
int nx,ny,nz;
size_t np;
nx = Nx(iptr);
ny = Ny(iptr);
nz = Nz(iptr);
np = nx*ny*nz;
*optr = (imageptr ) allocate(sizeof(image));
dprintf (DLEV,"copy_image:Allocated image @ %d size=%d * %d * %d",*optr,nx,ny,nz);
Frame(*optr) = (real *) allocate(np*sizeof(real));
dprintf (DLEV,"Frame allocated @ %d ",Frame(*optr));
Nx(*optr) = nx;
Ny(*optr) = ny;
Nz(*optr) = nz;
Xmin(*optr) = Xmin(iptr);
Ymin(*optr) = Ymin(iptr);
Zmin(*optr) = Zmin(iptr);
Dx(*optr) = Dx(iptr);
Dy(*optr) = Dy(iptr);
Dz(*optr) = Dz(iptr);
Namex(*optr) = mystrcpy(Namex(iptr));
Namey(*optr) = mystrcpy(Namey(iptr));
Namez(*optr) = mystrcpy(Namez(iptr));
Xref(*optr) = Xref(iptr);
Yref(*optr) = Yref(iptr);
Zref(*optr) = Zref(iptr);
Storage(*optr) = matdef[idef];
Axis(*optr) = Axis(iptr);
set_iarray(*optr);
return 1; /* succes return code */
}
void make_rawheader(FITS *fitsfile, imageptr iptr, bool Qrel)
{
int ndim, n;
double tmpr[3];
ndim = (Nz(iptr) > 1) ? 3 : 2;
n = nemoinpd(getparam("cdelt"),tmpr,3);
if (n == 0) {
Dx(iptr) = 2.0/Nx(iptr);
Dy(iptr) = 2.0/Ny(iptr);
Dz(iptr) = 2.0/Nz(iptr);
} else if (n == 3) {
Dx(iptr) = tmpr[0];
Dy(iptr) = tmpr[1];
Dz(iptr) = tmpr[2];
} else
error("cdelt= needs either 3 or 0 entries");
Xmin(iptr) = 0.0;
Ymin(iptr) = 0.0;
Zmin(iptr) = 0.0;
}
int write_image (stream outstr, imageptr iptr)
{
put_history(outstr);
put_set (outstr,ImageTag);
put_set (outstr,ParametersTag);
put_data (outstr,NxTag, IntType, &(Nx(iptr)), 0);
put_data (outstr,NyTag, IntType, &(Ny(iptr)), 0);
put_data (outstr,NzTag, IntType, &(Nz(iptr)), 0);
put_data (outstr,XminTag,RealType, &(Xmin(iptr)), 0);
put_data (outstr,YminTag,RealType, &(Ymin(iptr)), 0);
put_data (outstr,ZminTag,RealType, &(Zmin(iptr)), 0);
put_data (outstr,DxTag, RealType, &(Dx(iptr)), 0);
put_data (outstr,DyTag, RealType, &(Dy(iptr)), 0);
put_data (outstr,DzTag, RealType, &(Dz(iptr)), 0);
put_data (outstr,XrefTag,RealType, &(Xref(iptr)), 0);
put_data (outstr,YrefTag,RealType, &(Yref(iptr)), 0);
put_data (outstr,ZrefTag,RealType, &(Zref(iptr)), 0);
put_data (outstr,MapMinTag, RealType, &(MapMin(iptr)), 0);
put_data (outstr,MapMaxTag, RealType, &(MapMax(iptr)), 0);
put_data (outstr,BeamTypeTag, IntType, &(BeamType(iptr)), 0);
put_data (outstr,BeamxTag, RealType, &(Beamx(iptr)), 0);
put_data (outstr,BeamyTag, RealType, &(Beamy(iptr)), 0);
put_data (outstr,BeamzTag, RealType, &(Beamz(iptr)), 0);
if (Namex(iptr))
put_string (outstr,NamexTag,Namex(iptr));
if (Namey(iptr))
put_string (outstr,NameyTag,Namey(iptr));
if (Namez(iptr))
put_string (outstr,NamezTag,Namez(iptr));
if (Unit(iptr))
put_string (outstr,UnitTag,Unit(iptr));
put_data (outstr,TimeTag, RealType, &(Time(iptr)), 0);
put_string(outstr,StorageTag,matdef[idef]);
put_data (outstr,AxisTag, IntType, &(Axis(iptr)), 0);
put_tes (outstr, ParametersTag);
put_set (outstr,MapTag);
if (Nz(iptr)==1)
put_data (outstr,MapValuesTag,RealType,
Frame(iptr),Nx(iptr),Ny(iptr),0);
else
put_data (outstr,MapValuesTag,RealType,
Frame(iptr),Nx(iptr),Ny(iptr),Nz(iptr),0);
put_tes (outstr, MapTag);
put_tes (outstr, ImageTag);
return 1;
}
void fixheader(imageptr iptr, string options, real t0, real dt)
{
char *ap = allocate(sizeof(options) + sizeof("Attribute") + 10);
sprintf(ap,"Attribute: %s",options);
Namex(iptr) = strdup("Particle");
Xmin(iptr) = 0.0;
Dx(iptr) = 1.0;
Namey(iptr) = strdup(ap);
Ymin(iptr) = 0.0;
Dy(iptr) = 1.0;
Namez(iptr) = strdup("Time");
Zmin(iptr) = t0;
Dz(iptr) = dt;
free(ap);
}
/*
* CREATE_CUBE: create a blank cube Nx by Ny by Nz in size
*/
int create_cube (imageptr *iptr, int nx, int ny, int nz)
{
*iptr = (imageptr ) allocate(sizeof(image));
dprintf (DLEV,"CREATE_CUBE: Allocated image @ cube %d size=%d * %d * %d",
*iptr,nx,ny,nz);
if (*iptr == NULL)
return 0; /* no memory available */
Frame(*iptr) = (real *) allocate(nx*ny*nz*sizeof(real));
dprintf (DLEV,"Frame allocated @ %d ",Frame(*iptr));
Nx(*iptr) = nx; /* cube dimension */
Ny(*iptr) = ny;
Nz(*iptr) = nz;
Xmin(*iptr) = 0.0; /* start lower left corner at 0.0 */
Ymin(*iptr) = 0.0;
Zmin(*iptr) = 0.0;
Xref(*iptr) = 0.0;
Yref(*iptr) = 0.0;
Zref(*iptr) = 0.0;
Dx(*iptr) = 1.0; /* unity pixels */
Dy(*iptr) = 1.0;
Dz(*iptr) = 1.0;
MapMin(*iptr) = 0.0;
MapMax(*iptr) = 0.0;
BeamType(*iptr) = 0;
Beamx(*iptr) = 0.0; /* name beams */
Beamy(*iptr) = 0.0;
Beamz(*iptr) = 0.0;
Namex(*iptr) = NULL; /* no axis names yet */
Namey(*iptr) = NULL;
Namez(*iptr) = NULL;
Unit(*iptr) = NULL; /* no units */
Time(*iptr) = 0.0;
Storage(*iptr) = matdef[idef];
Axis(*iptr) = 0;
Mask(*iptr) = NULL;
set_iarray(*iptr);
return 1; /* succes return code */
}
int create_image (imageptr *iptr, int nx, int ny)
{
*iptr = (imageptr ) allocate(sizeof(image));
dprintf (DLEV,"create_image:Allocated image @ %d size=%d * %d",*iptr,nx,ny);
Frame(*iptr) = (real *) allocate(nx*ny*sizeof(real));
dprintf (DLEV,"Frame allocated @ %d ",Frame(*iptr));
Axis(*iptr) = 0; /* old style axis with no reference pixel */
Nx(*iptr) = nx; /* old style ONE map, no cube */
Ny(*iptr) = ny;
Nz(*iptr) = 1;
Xmin(*iptr) = 0.0; /* start lower left corner at 0.0 */
Ymin(*iptr) = 0.0;
Zmin(*iptr) = 0.0;
Dx(*iptr) = 1.0; /* unity pixels */
Dy(*iptr) = 1.0;
Dz(*iptr) = 1.0;
Xref(*iptr) = 0.0;
Yref(*iptr) = 0.0;
Zref(*iptr) = 0.0;
MapMin(*iptr) = 0.0;
MapMax(*iptr) = 0.0;
BeamType(*iptr) = 0;
Beamx(*iptr) = 0.0; /* name beams */
Beamy(*iptr) = 0.0;
Beamz(*iptr) = 0.0;
Namex(*iptr) = NULL; /* no axis names */
Namey(*iptr) = NULL;
Namez(*iptr) = NULL;
Unit(*iptr) = NULL; /* no units */
Time(*iptr) = 0.0;
Storage(*iptr) = matdef[idef];
Axis(*iptr) = 0;
Mask(*iptr) = NULL;
set_iarray((*iptr));
return 1; /* succes return code */
}
void make_fitheader(FITS *fitsfile, imageptr iptr, bool Qrel, bool Qout, int axistype,
FLOAT *data_min, FLOAT *data_max)
{
int nz, tmpi, i, j;
real crpix1, crpix2, crpix3;
FLOAT tmpr, cd[3][3];
char cdname[10], ctype[32];
nz = Nz(iptr);
fitrdhdr(fitsfile,"CRVAL1",&tmpr,0.0); Xmin(iptr) = tmpr;
fitrdhdr(fitsfile,"CRVAL2",&tmpr,0.0); Ymin(iptr) = tmpr;
fitrdhdr(fitsfile,"CRVAL3",&tmpr,0.0); Zmin(iptr) = tmpr;
if (Qrel) {
Xmin(iptr) = Ymin(iptr) = Zmin(iptr) = 0.0;
}
fitrdhdr(fitsfile,"CDELT1",&tmpr,1.0); Dx(iptr)=tmpr;
fitrdhdr(fitsfile,"CDELT2",&tmpr,1.0); Dy(iptr)=tmpr;
fitrdhdr(fitsfile,"CDELT3",&tmpr,1.0); Dz(iptr)=tmpr;
for (i=1; i<=3; i++)
for (j=1; j<=3; j++) {
sprintf(cdname,"CD%d_%d",i,j);
fitrdhdr(fitsfile,cdname,&tmpr, (i==j ? 1.0 : 0.0));
dprintf(1,"%s: %g\n",cdname,tmpr);
cd[i-1][j-1] = tmpr;
}
if (fitexhd(fitsfile,"CD1_1")) {
if (fitexhd(fitsfile,"CDELT1"))
warning("CDELT1 as well as CD_1_1 have been specified - using CD");
Dx(iptr) = cd[0][0];
Dy(iptr) = cd[1][1];
Dz(iptr) = cd[2][2];
}
fitrdhdr(fitsfile,"CRPIX1",&tmpr,1.0); crpix1 = tmpr;
fitrdhdr(fitsfile,"CRPIX2",&tmpr,1.0); crpix2 = tmpr;
if (nz>1) {
fitrdhdr(fitsfile,"CRPIX3",&tmpr,1.0); crpix3 = tmpr;
} else
crpix3 = 0.0;
if (!Qout) {
print_axis(1, Nx(iptr), crpix1, Xmin(iptr), Dx(iptr));
print_axis(2, Ny(iptr), crpix2, Ymin(iptr), Dy(iptr));
print_axis(3, Nz(iptr), crpix3, Zmin(iptr), Dz(iptr));
return;
}
if (axistype==0) {
Axis(iptr) = 0;
if (crpix1 != 1.0)
Xmin(iptr) -= (crpix1-1.0)*Dx(iptr);
if (crpix2 != 1.0)
Ymin(iptr) -= (crpix2-1.0)*Dy(iptr);
if (nz>1 && crpix3 != 1.0)
Zmin(iptr) -= (crpix3-1.0)*Dz(iptr);
} else if (axistype==1) {
Axis(iptr) = 1;
Xref(iptr) = crpix1-1;
Yref(iptr) = crpix2-1;
Zref(iptr) = crpix3-1;
} else
error("Illegal axistype=%d",axistype);
fitrdhda(fitsfile,"CTYPE1",ctype,"");
Namex(iptr) = scopy(ctype);
fitrdhda(fitsfile,"CTYPE2",ctype,"");
Namey(iptr) = scopy(ctype);
if (nz>1) {
fitrdhda(fitsfile,"CTYPE3",ctype,"");
Namez(iptr) = scopy(ctype);
}
fitrdhdr(fitsfile,"DATAMIN",&tmpr,0.0);
MapMin(iptr) = *data_min = tmpr;
dprintf(1,"DATAMIN: %g %g\n",*data_min,MapMin(iptr));
fitrdhdr(fitsfile,"DATAMAX",&tmpr,0.0);
MapMax(iptr) = *data_max = tmpr;
dprintf(1,"DATAMAX: %g %g\n",*data_max,MapMax(iptr));
if (fitexhd(fitsfile,"BLANK")) {
dprintf(1,"BLANK keyword exists\n");
fitrdhdi(fitsfile,"BITPIX",&tmpi,-1);
if (tmpi<0) {
warning("FITS keyword BLANK not interpreted - BITPIX<0");
} else {
fitrdhdi(fitsfile,"BLANK",&tmpi,0);
dprintf(1,"BLANK = %d\n",tmpi);
}
}
}
/*
* create a velocity field (GIPSY method)
* 0..nx-1 and 0..ny-1
* start from pixel, work back to gal plane and interpolate
* (a.k.a. retracing method)
*
*/
local void cube_create(stream outstr)
{
int i, j, k, n, nx, ny;
real m_min, m_max, sum;
real den, vel, sig, velk, x;
imageptr vptr;
real f = 4.0;
m_min = HUGE; m_max = -HUGE;
nx = Nx(velptr);
ny = Ny(velptr);
if (!create_cube(&vptr, nx, ny, nz)) /* output data cube */
error("Could not create cube from scratch");
for (j=0; j<ny; j++) /* Loop over all pixels */
for (i=0; i<nx; i++) {
for (k=0; k<nz; k++)
CubeValue(vptr,i,j,k) = undef; /* first set all to 'undefined' */
sum = 0.0;
vel = MapValue(velptr,i,j);
if (denptr) {
den = MapValue(denptr,i,j);
if (den <= 0.0) continue;
} else
den = 1.0;
if (sigptr) {
sig = MapValue(sigptr,i,j);
if (sig < 0.0) continue;
} else
sig = sigdef;
if (sig == 0.0) { /* special case, only populate 1 cell */
k = (int) floor( (vel-zrange[0])/zrange[2] );
if (k<0 || k>nz-1) continue;
CubeValue(vptr,i,j,k) = den;
sum = den;
} else { /* else use a gaussian profile */
for (k=0, velk=zrange[0]+0.5*zrange[2]; k<nz; k++, velk += zrange[2]) {
x = (velk-vel)/sig;
x = ABS(x);
if (x > f) continue;
CubeValue(vptr,i,j,k) = den * exp(-0.5*x*x);
sum += CubeValue(vptr,i,j,k);
}
}
sum = den/sum; /* now normalize the spectrum so the sum is 'den' */
for (k=0; k<nz; k++) {
if (CubeValue(vptr,i,j,k) != undef)
CubeValue(vptr,i,j,k) *= sum;
}
}
n=0;
for (k=0; k<nz; k++) /* get min and max in map */
for (j=0; j<ny; j++)
for (i=0; i<nx; i++)
if (CubeValue(vptr,i,j,k) != undef) {
m_min = MIN(CubeValue(vptr,i,j,k),m_min);
m_max = MAX(CubeValue(vptr,i,j,k),m_max);
} else
n++;
MapMin(vptr) = m_min;
MapMax(vptr) = m_max;
Dx(vptr) = Dx(velptr);
Dy(vptr) = Dy(velptr);
Dz(vptr) = zrange[2];
Xmin(vptr) = Xmin(velptr);
Ymin(vptr) = Ymin(velptr);
Zmin(vptr) = zrange[0];
if (n>0) warning("%d/%d cells with no signal",n,nx*ny*nz);
printf("Min and max in map: %g %g\n",m_min,m_max);
write_image (outstr,vptr);
}
void nemo_main()
{
stream instr, outstr;
int nx, ny, nz, nx1, ny1, nz1;
int axis, mom;
int i,j,k, apeak, cnt;
imageptr iptr=NULL, iptr1=NULL, iptr2=NULL; /* pointer to images */
real tmp0, tmp1, tmp2, tmp00, newvalue, peakvalue, scale, offset;
bool Qpeak;
instr = stropen(getparam("in"), "r");
mom = 0;
axis = 3;
Qpeak = getbparam("peak");
read_image( instr, &iptr);
nx1 = nx = Nx(iptr);
ny1 = ny = Ny(iptr);
nz1 = 1;
nz = Nz(iptr);
outstr = stropen(getparam("out"), "w");
create_cube(&iptr1,nx1,ny1,nz1);
create_cube(&iptr2,nx1,ny1,nz1);
scale = Dz(iptr);
offset = Zmin(iptr);
for(j=0; j<ny; j++)
for(i=0; i<nx; i++) {
tmp0 = tmp00 = tmp1 = tmp2 = 0.0;
cnt = 0;
peakvalue = CubeValue(iptr,i,j,0);
for(k=0; k<nz; k++) {
if (out_of_range(CubeValue(iptr,i,j,k))) continue;
cnt++;
tmp0 += CubeValue(iptr,i,j,k);
tmp00 += sqr(CubeValue(iptr,i,j,k));
if (CubeValue(iptr,i,j,k) > peakvalue) {
apeak = k;
peakvalue = CubeValue(iptr,i,j,k);
}
}
if (cnt==0 || tmp0==0.0) {
newvalue = 0.0;
} else {
if (Qpeak)
newvalue = peakvalue;
else
newvalue = tmp0;
}
CubeValue(iptr1,i,j,1) = newvalue;
}
Xmin(iptr1) = Xmin(iptr);
Ymin(iptr1) = Ymin(iptr);
Zmin(iptr1) = Zmin(iptr) + 0.5*(nz-1)*Dz(iptr);
Dx(iptr1) = Dx(iptr);
Dy(iptr1) = Dy(iptr);
Dz(iptr1) = nz * Dz(iptr);
Namex(iptr1) = Namex(iptr); /* care: we're passing a pointer */
Namey(iptr1) = Namey(iptr);
Namez(iptr1) = Namez(iptr);
write_image(outstr, iptr1);
}
void nemo_main()
{
stream instr, outstr;
int nx, ny, nz; /* size of scratch map */
int nx1, ny1, nz1, nz2;
int ni, i, ix, iy, iz, iz1;
real dmin, dmax;
imageptr iptr[MAXIM], optr; /* pointer to image */
string flipmode;
instr = stropen(getparam("in"), "r");
outstr = stropen(getparam("out"), "w");
for (i=0; i<MAXIM; i++) { /* loop over all to gather data */
iptr[i] = 0;
if (read_image( instr, &iptr[i]) == 0) break;
nx1 = Nx(iptr[i]);
ny1 = Ny(iptr[i]);
nz1 = Nz(iptr[i]);
dprintf(1,"Image %d: %d x %d x %d\n",i,nx1,ny1,nz1);
if (i==0) {
nx = nx1;
ny = ny1;
nz = nz1;
dmin = MapMin(iptr[i]);
dmax = MapMax(iptr[i]);
} else {
if (nx != nx1) error("size nx: %d != %d",nx,nx1);
if (ny != ny1) error("size ny: %d != %d",ny,ny1);
nz += nz1;
dmin = MIN(dmin,MapMin(iptr[i]));
dmax = MAX(dmax,MapMax(iptr[i]));
}
}
ni = i;
dprintf(0,"Final cube: %d x %d x %d\n",nx,ny,nz);
dprintf(0,"Data min/max: %g %g\n",dmin,dmax);
create_cube(&optr,nx,ny,nz);
MapMin(optr) = dmin;
MapMax(optr) = dmax;
Xmin(optr) = Xmin(iptr[0]);
Ymin(optr) = Ymin(iptr[0]);
Zmin(optr) = Zmin(iptr[0]);
Xref(optr) = Xref(iptr[0]);
Yref(optr) = Yref(iptr[0]);
Zref(optr) = Zref(iptr[0]);
Dx(optr) = Dx(iptr[0]);
Dy(optr) = Dy(iptr[0]);
Dz(optr) = Dz(iptr[0]);
for (i=0, iz=0; i<ni; i++) { /* grab all data in output cube */
nz1 = Nz(iptr[i]);
for (iz1=0; iz1< nz1; iz1++, iz++) {
for (iy=0; iy<ny; iy++) {
for (ix=0; ix<nx; ix++) {
CubeValue(optr,ix,iy,iz) = CubeValue(iptr[i],ix,iy,iz1);
}
}
}
}
write_image(outstr, optr);
}
int main(int argc, char* argv[])
{
bool verb,fsrf,snap,ssou,dabc,opot;
int jsnap,ntsnap,jdata;
/* I/O files */
sf_file Fwav=NULL; /* wavelet */
sf_file Fsou=NULL; /* sources */
sf_file Frec=NULL; /* receivers */
sf_file Fccc=NULL; /* velocity */
sf_file Fden=NULL; /* density */
sf_file Fdat=NULL; /* data */
sf_file Fwfl=NULL; /* wavefield */
/* cube axes */
sf_axis at,ax,ay,az;
sf_axis as,ar,ac;
int nt,nz,nx,ny,ns,nr,nc,nb;
int it,iz,ix,iy;
float dt,dz,dx,dy,idz,idx,idy;
/* FDM structure */
fdm3d fdm=NULL;
abcone3d /* abcp=NULL, */ abcs=NULL;
sponge spo=NULL;
/* I/O arrays */
float***ww=NULL; /* wavelet */
pt3d *ss=NULL; /* sources */
pt3d *rr=NULL; /* receivers */
float **dd=NULL; /* data */
/*------------------------------------------------------------*/
float ***tt=NULL;
float ***ro=NULL; /* density */
/* orthorombic footprint - 9 coefficients */
/* c11 c12 c13
. c22 c23
. . c33
c44
c55
c66 */
float ***c11=NULL;
float ***c22=NULL;
float ***c33=NULL;
float ***c44=NULL;
float ***c55=NULL;
float ***c66=NULL;
float ***c12=NULL;
float ***c13=NULL;
float ***c23=NULL;
float ***vp,***vs;
float ***qp=NULL,***qsx=NULL,***qsy=NULL,***qsz=NULL;
/*------------------------------------------------------------*/
/* displacement: um = U @ t-1; uo = U @ t; up = U @ t+1 */
float ***umz,***uoz,***upz,***uaz,***utz;
float ***umx,***uox,***upx,***uax,***utx;
float ***umy,***uoy,***upy,***uay,***uty;
/* stress/strain tensor */
float ***tzz,***txx,***tyy,***txy,***tyz,***tzx;
float szz, sxx, syy, sxy, syz, szx;
/*------------------------------------------------------------*/
/* linear interpolation weights/indices */
lint3d cs,cr;
/* Gaussian bell */
int nbell;
/* wavefield cut params */
sf_axis acz=NULL,acx=NULL,acy=NULL;
int nqz,nqx,nqy;
float oqz,oqx,oqy;
float dqz,dqx,dqy;
float ***uc=NULL;
/*------------------------------------------------------------*/
/* init RSF */
sf_init(argc,argv);
/*------------------------------------------------------------*/
/* OMP parameters */
#ifdef _OPENMP
omp_init();
#endif
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* execution flags */
if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */
if(! sf_getbool("snap",&snap)) snap=false; /* wavefield snapshots flag */
if(! sf_getbool("free",&fsrf)) fsrf=false; /* free surface flag */
if(! sf_getbool("ssou",&ssou)) ssou=false; /* stress source */
if(! sf_getbool("dabc",&dabc)) dabc=false; /* absorbing BC */
if(! sf_getbool("opot",&opot)) opot=false; /* output potentials */
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* I/O files */
Fwav = sf_input ("in" ); /* wavelet */
Fccc = sf_input ("ccc"); /* stiffness */
Fden = sf_input ("den"); /* density */
Fsou = sf_input ("sou"); /* sources */
Frec = sf_input ("rec"); /* receivers */
Fwfl = sf_output("wfl"); /* wavefield */
Fdat = sf_output("out"); /* data */
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* axes */
at = sf_iaxa(Fwav,3); sf_setlabel(at,"t"); if(verb) sf_raxa(at); /* time */
az = sf_iaxa(Fccc,1); sf_setlabel(az,"z"); if(verb) sf_raxa(az); /* depth */
ax = sf_iaxa(Fccc,2); sf_setlabel(ax,"x"); if(verb) sf_raxa(ax); /* space x */
ay = sf_iaxa(Fccc,3); sf_setlabel(ay,"y"); if(verb) sf_raxa(ay); /* space y */
as = sf_iaxa(Fsou,2); sf_setlabel(as,"s"); if(verb) sf_raxa(as); /* sources */
ar = sf_iaxa(Frec,2); sf_setlabel(ar,"r"); if(verb) sf_raxa(ar); /* receivers */
nt = sf_n(at); dt = sf_d(at);
nz = sf_n(az); dz = sf_d(az);
nx = sf_n(ax); dx = sf_d(ax);
ny = sf_n(ay); dy = sf_d(ay);
ns = sf_n(as);
nr = sf_n(ar);
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* other execution parameters */
if(! sf_getint("nbell",&nbell)) nbell=5; /* bell size */
if(verb) sf_warning("nbell=%d",nbell);
if(! sf_getint("jdata",&jdata)) jdata=1;
if(snap) { /* save wavefield every *jsnap* time steps */
if(! sf_getint("jsnap",&jsnap)) jsnap=nt;
}
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* expand domain for FD operators and ABC */
if( !sf_getint("nb",&nb) || nb<NOP) nb=NOP;
fdm=fdutil3d_init(verb,fsrf,az,ax,ay,nb,1);
fdbell3d_init(nbell);
sf_setn(az,fdm->nzpad); sf_seto(az,fdm->ozpad); if(verb) sf_raxa(az);
sf_setn(ax,fdm->nxpad); sf_seto(ax,fdm->oxpad); if(verb) sf_raxa(ax);
sf_setn(ay,fdm->nypad); sf_seto(ay,fdm->oypad); if(verb) sf_raxa(ay);
/*------------------------------------------------------------*/
/* 3D vector components */
nc=3;
if(opot) {
ac=sf_maxa(nc+1,0,1);
} else {
ac=sf_maxa(nc ,0,1);
}
/*------------------------------------------------------------*/
/* setup output data header */
sf_oaxa(Fdat,ar,1);
sf_oaxa(Fdat,ac,2);
sf_setn(at,nt/jdata);
sf_setd(at,dt*jdata);
sf_oaxa(Fdat,at,3);
/* setup output wavefield header */
if(snap) {
if(!sf_getint ("nqz",&nqz)) nqz=sf_n(az);
if(!sf_getint ("nqx",&nqx)) nqx=sf_n(ax);
if(!sf_getint ("nqy",&nqy)) nqy=sf_n(ay);
if(!sf_getfloat("oqz",&oqz)) oqz=sf_o(az);
if(!sf_getfloat("oqx",&oqx)) oqx=sf_o(ax);
if(!sf_getfloat("oqy",&oqy)) oqy=sf_o(ay);
dqz=sf_d(az);
dqx=sf_d(ax);
dqy=sf_d(ay);
acz = sf_maxa(nqz,oqz,dqz); sf_raxa(acz);
acx = sf_maxa(nqx,oqx,dqx); sf_raxa(acx);
acy = sf_maxa(nqy,oqy,dqy); sf_raxa(acy);
/* TODO: check if the imaging window fits in the wavefield domain */
uc=sf_floatalloc3(sf_n(acz),sf_n(acx),sf_n(acy));
ntsnap=0;
for(it=0; it<nt; it++) {
if(it%jsnap==0) ntsnap++;
}
sf_setn(at, ntsnap);
sf_setd(at,dt*jsnap);
if(verb) sf_raxa(at);
sf_oaxa(Fwfl,acz,1);
sf_oaxa(Fwfl,acx,2);
sf_oaxa(Fwfl,acy,3);
sf_oaxa(Fwfl,ac, 4);
sf_oaxa(Fwfl,at, 5);
}
/*------------------------------------------------------------*/
/* source array */
ww=sf_floatalloc3(ns,nc,nt);
sf_floatread(ww[0][0],nt*nc*ns,Fwav);
/* data array */
if(opot) {
dd=sf_floatalloc2(nr,nc+1);
} else {
dd=sf_floatalloc2(nr,nc );
}
/*------------------------------------------------------------*/
/* setup source/receiver coordinates */
ss = (pt3d*) sf_alloc(ns,sizeof(*ss));
rr = (pt3d*) sf_alloc(nr,sizeof(*rr));
pt3dread1(Fsou,ss,ns,3); /* read (x,y,z) coordinates */
pt3dread1(Frec,rr,nr,3); /* read (x,y,z) coordinates */
cs = lint3d_make(ns,ss,fdm);
cr = lint3d_make(nr,rr,fdm);
/*------------------------------------------------------------*/
/* setup FD coefficients */
/* idz = 2/dz;*/
/* idx = 2/dx;*/
/* idy = 2/dy;*/
idz = 1/dz;
idx = 1/dx;
idy = 1/dy;
/*------------------------------------------------------------*/
tt = sf_floatalloc3(nz,nx,ny);
ro =sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c11=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c22=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c33=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c44=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c55=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c66=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c12=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c13=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c23=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
/* input density */
sf_floatread(tt[0][0],nz*nx*ny,Fden); expand3d(tt,ro ,fdm);
/* input stiffness */
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c11,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c22,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c33,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c44,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c55,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c66,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c12,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c13,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c23,fdm);
free(**tt); free(*tt); free(tt);
/*------------------------------------------------------------*/
if(dabc) {
/* one-way abc setup */
vp = sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
vs = sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
vp[iy][ix][iz] = sqrt( c11[iy][ix][iz]/ro[iy][ix][iz] );
vs[iy][ix][iz] = sqrt( c55[iy][ix][iz]/ro[iy][ix][iz] );
}
}
}
/* abcp = abcone3d_make(NOP,dt,vp,fsrf,fdm); */
abcs = abcone3d_make(NOP,dt,vs,fsrf,fdm);
free(**vp); free(*vp); free(vp);
free(**vs); free(*vs); free(vs);
/* sponge abc setup */
spo = sponge_make(fdm->nb);
}
/*------------------------------------------------------------*/
/* precompute 1/ro * dt^2 */
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
ro[iy][ix][iz] = dt*dt/ro[iy][ix][iz];
}
}
}
/*------------------------------------------------------------*/
/* allocate wavefield arrays */
umz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uoz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
upz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uaz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
umx=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uox=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
upx=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uax=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
umy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uoy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
upy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uay=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
tzz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
tyy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
txx=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
txy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
tyz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
tzx=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
umz[iy][ix][iz]=0; umx[iy][ix][iz]=0; umy[iy][ix][iz]=0;
uoz[iy][ix][iz]=0; uox[iy][ix][iz]=0; uoy[iy][ix][iz]=0;
upz[iy][ix][iz]=0; upx[iy][ix][iz]=0; upy[iy][ix][iz]=0;
uaz[iy][ix][iz]=0; uax[iy][ix][iz]=0; uay[iy][ix][iz]=0;
}
}
}
if(opot) {
qp =sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
qsx=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
qsy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
qsz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
}
/*------------------------------------------------------------*/
/*
* MAIN LOOP
*/
/*------------------------------------------------------------*/
if(verb) fprintf(stderr,"\n");
for (it=0; it<nt; it++) {
if(verb) fprintf(stderr,"\b\b\b\b\b%d",it);
/*------------------------------------------------------------*/
/* from displacement to strain */
/*------------------------------------------------------------*/
/*
* exx = Fx(ux)
* eyy = Fy(uy)
* ezz = Fz(uz)
* exy = By(ux) + Bx(uy)
* eyz = Bz(uy) + By(uz)
* ezx = Bx(uz) + Bz(ux)
*/
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz) \
shared(fdm,txx,tyy,tzz,txy,tyz,tzx,uox,uoy,uoz,idx,idy,idz)
#endif
for (iy=NOP; iy<fdm->nypad-NOP; iy++) {
for (ix=NOP; ix<fdm->nxpad-NOP; ix++) {
for(iz=NOP; iz<fdm->nzpad-NOP; iz++) {
txx[iy][ix][iz] = Dx(uox,ix,iy,iz,idx);
tyy[iy][ix][iz] = Dy(uoy,ix,iy,iz,idy);
tzz[iy][ix][iz] = Dz(uoz,ix,iy,iz,idz);
txy[iy][ix][iz] = Dy(uox,ix,iy,iz,idy) + Dx(uoy,ix,iy,iz,idx);
tyz[iy][ix][iz] = Dz(uoy,ix,iy,iz,idz) + Dy(uoz,ix,iy,iz,idy);
tzx[iy][ix][iz] = Dx(uoz,ix,iy,iz,idx) + Dz(uox,ix,iy,iz,idz);
}
}
}
/*------------------------------------------------------------*/
/* from strain to stress */
/*------------------------------------------------------------*/
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz,sxx,syy,szz,sxy,syz,szx) \
shared(fdm,txx,tyy,tzz,txy,tyz,tzx,c11,c22,c33,c44,c55,c66,c12,c13,c23)
#endif
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
sxx = c11[iy][ix][iz] * txx[iy][ix][iz]
+ c12[iy][ix][iz] * tyy[iy][ix][iz]
+ c13[iy][ix][iz] * tzz[iy][ix][iz];
syy = c12[iy][ix][iz] * txx[iy][ix][iz]
+ c22[iy][ix][iz] * tyy[iy][ix][iz]
+ c23[iy][ix][iz] * tzz[iy][ix][iz];
szz = c13[iy][ix][iz] * txx[iy][ix][iz]
+ c23[iy][ix][iz] * tyy[iy][ix][iz]
+ c33[iy][ix][iz] * tzz[iy][ix][iz];
sxy = c66[iy][ix][iz] * txy[iy][ix][iz];
syz = c44[iy][ix][iz] * tyz[iy][ix][iz];
szx = c55[iy][ix][iz] * tzx[iy][ix][iz];
txx[iy][ix][iz] = sxx;
tyy[iy][ix][iz] = syy;
tzz[iy][ix][iz] = szz;
txy[iy][ix][iz] = sxy;
tyz[iy][ix][iz] = syz;
tzx[iy][ix][iz] = szx;
}
}
}
/*------------------------------------------------------------*/
/* free surface */
/*------------------------------------------------------------*/
if(fsrf) {
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz) \
shared(fdm,txx,tyy,tzz,txy,tyz,tzx)
#endif
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nb; iz++) {
txx[iy][ix][iz]=0;
tyy[iy][ix][iz]=0;
tzz[iy][ix][iz]=0;
txy[iy][ix][iz]=0;
tyz[iy][ix][iz]=0;
tzx[iy][ix][iz]=0;
}
}
}
}
/*------------------------------------------------------------*/
/* inject stress source */
/*------------------------------------------------------------*/
if(ssou) {
lint3d_bell(tzz,ww[it][0],cs);
lint3d_bell(txx,ww[it][1],cs);
lint3d_bell(tyy,ww[it][2],cs);
}
/*------------------------------------------------------------*/
/* from stress to acceleration */
/*------------------------------------------------------------*/
/*
* ax = Bx(txx) + Fy(txy) + Fz(txz)
* ay = Fx(txy) + By(tyy) + Fz(tyz)
* az = Fx(txz) + Fy(tyz) + Bz(tzz)
*/
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz) \
shared(fdm,txx,tyy,tzz,txy,tyz,tzx,uax,uay,uaz,idx,idy,idz)
#endif
for (iy=NOP; iy<fdm->nypad-NOP; iy++) {
for (ix=NOP; ix<fdm->nxpad-NOP; ix++) {
for(iz=NOP; iz<fdm->nzpad-NOP; iz++) {
uax[iy][ix][iz] = Dx( txx,ix,iy,iz,idx ) + Dy( txy,ix,iy,iz,idy ) + Dz( tzx,ix,iy,iz,idz ) ;
uay[iy][ix][iz] = Dx( txy,ix,iy,iz,idx ) + Dy( tyy,ix,iy,iz,idy ) + Dz( tyz,ix,iy,iz,idz ) ;
uaz[iy][ix][iz] = Dx( tzx,ix,iy,iz,idx ) + Dy( tyz,ix,iy,iz,idy ) + Dz( tzz,ix,iy,iz,idz ) ;
}
}
}
/*------------------------------------------------------------*/
/* inject acceleration source */
/*------------------------------------------------------------*/
if(!ssou) {
lint3d_bell(uaz,ww[it][0],cs);
lint3d_bell(uax,ww[it][1],cs);
lint3d_bell(uay,ww[it][2],cs);
}
/*------------------------------------------------------------*/
/* step forward in time */
/*------------------------------------------------------------*/
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz) \
shared(fdm,uox,uoy,uoz,umx,umy,umz,upx,upy,upz,uax,uay,uaz,ro)
#endif
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
upx[iy][ix][iz] = 2*uox[iy][ix][iz]
- umx[iy][ix][iz]
+ uax[iy][ix][iz] * ro[iy][ix][iz];
upy[iy][ix][iz] = 2*uoy[iy][ix][iz]
- umy[iy][ix][iz]
+ uay[iy][ix][iz] * ro[iy][ix][iz];
upz[iy][ix][iz] = 2*uoz[iy][ix][iz]
- umz[iy][ix][iz]
+ uaz[iy][ix][iz] * ro[iy][ix][iz];
}
}
}
/* circulate wavefield arrays */
utz=umz; uty=umy; utx=umx;
umz=uoz; umy=uoy; umx=uox;
uoz=upz; uoy=upy; uox=upx;
upz=utz; upy=uty; upx=utx;
if(dabc) {
/* one-way ABC */
/* abcone3d_apply(uoz,umz,NOP,abcp,fdm); */
/* abcone3d_apply(uox,umx,NOP,abcp,fdm); */
/* abcone3d_apply(uoy,umy,NOP,abcp,fdm); */
abcone3d_apply(uoz,umz,NOP,abcs,fdm);
abcone3d_apply(uox,umx,NOP,abcs,fdm);
abcone3d_apply(uoy,umy,NOP,abcs,fdm);
/* sponge ABC */
sponge3d_apply(umz,spo,fdm);
sponge3d_apply(uoz,spo,fdm);
sponge3d_apply(umx,spo,fdm);
sponge3d_apply(uox,spo,fdm);
sponge3d_apply(umy,spo,fdm);
sponge3d_apply(uoy,spo,fdm);
}
/*------------------------------------------------------------*/
/* cut wavefield and save */
/*------------------------------------------------------------*/
if(opot) {
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz) \
shared(fdm,uox,uoy,uoz,idx,idy,idz)
#endif
for (iy=NOP; iy<fdm->nypad-NOP; iy++) {
for (ix=NOP; ix<fdm->nxpad-NOP; ix++) {
for(iz=NOP; iz<fdm->nzpad-NOP; iz++) {
qp [iy][ix][iz] = Dx( uox,ix,iy,iz,idx )
+ Dy( uoy,ix,iy,iz,idy )
+ Dz( uoz,ix,iy,iz,idz );
qsx[iy][ix][iz] = Dy( uoz,ix,iy,iz,idy ) - Dz( uoy,ix,iy,iz,idz );
qsy[iy][ix][iz] = Dz( uox,ix,iy,iz,idz ) - Dx( uoz,ix,iy,iz,idx );
qsz[iy][ix][iz] = Dx( uoy,ix,iy,iz,idx ) - Dy( uox,ix,iy,iz,idy );
}
}
}
if(snap && it%jsnap==0) {
cut3d(qp ,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
cut3d(qsz,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
cut3d(qsx,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
cut3d(qsy,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
}
lint3d_extract(qp , dd[0],cr);
lint3d_extract(qsx, dd[1],cr);
lint3d_extract(qsy, dd[2],cr);
lint3d_extract(qsz, dd[3],cr);
if(it%jdata==0) sf_floatwrite(dd[0],nr*(nc+1),Fdat);
} else {
if(snap && it%jsnap==0) {
cut3d(uoz,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
cut3d(uox,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
cut3d(uoy,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
}
lint3d_extract(uoz,dd[0],cr);
lint3d_extract(uox,dd[1],cr);
lint3d_extract(uoy,dd[2],cr);
if(it%jdata==0) sf_floatwrite(dd[0],nr*nc,Fdat);
}
}
if(verb) fprintf(stderr,"\n");
/*------------------------------------------------------------*/
/* deallocate arrays */
free(**ww); free(*ww); free(ww);
free(ss);
free(rr);
free(*dd); free(dd);
free(**ro); free(*ro); free(ro);
free(**c11); free(*c11); free(c11);
free(**c22); free(*c22); free(c22);
free(**c33); free(*c33); free(c33);
free(**c44); free(*c44); free(c44);
free(**c55); free(*c55); free(c55);
free(**c66); free(*c66); free(c66);
free(**c12); free(*c12); free(c12);
free(**c13); free(*c13); free(c13);
free(**c23); free(*c23); free(c23);
free(**umz); free(*umz); free(umz);
free(**uoz); free(*uoz); free(uoz);
free(**upz); free(*upz); free(upz);
free(**uaz); free(*uaz); free(uaz);
free(**umx); free(*umx); free(umx);
free(**uox); free(*uox); free(uox);
free(**upx); free(*upx); free(upx);
free(**uax); free(*uax); free(uax);
free(**umy); free(*umy); free(umy);
free(**uoy); free(*uoy); free(uoy);
free(**upy); free(*upy); free(upy);
free(**uay); free(*uay); free(uay);
free(**tzz); free(*tzz); free(tzz);
free(**txx); free(*txx); free(txx);
free(**tyy); free(*tyy); free(tyy);
free(**txy); free(*txy); free(txy);
free(**tyz); free(*tyz); free(tyz);
free(**tzx); free(*tzx); free(tzx);
if (snap) {
free(**uc); free(*uc); free(uc);
}
if(opot) {
free(**qp); free(*qp); free(qp);
free(**qsx); free(*qsx); free(qsx);
free(**qsy); free(*qsy); free(qsy);
free(**qsz); free(*qsz); free(qsz);
}
/*------------------------------------------------------------*/
exit (0);
}
void smooth_it()
{
real m_min, m_max, brightness, total;
int i, ix, iy, iz, kounter, idir;
char *cp;
m_min = HUGE;
m_max = -HUGE;
total = 0.0;
kounter = nsmooth;
while (kounter-- > 0) {
dprintf (1,"Convolving %s with %d-length beam: ",dir,lsmooth);
for (i=0; i<lsmooth; i++)
dprintf (1," %f ",smooth[i]);
cp = dir; /* point to direction again */
while (*cp) {
if (*cp=='x')
idir=1;
else if (*cp=='y')
idir=2;
else if (*cp=='z')
idir=3;
else
error("Wrong direction %c for beamsmoothing\n",*cp);
convolve_cube (Frame(iptr),nx,ny,nz,smooth,lsmooth,idir);
cp++;
}
}
m_max = -HUGE; /* determine new min/max */
m_min = HUGE;
for (ix=0; ix<Nx(iptr); ix++)
for (iy=0; iy<Ny(iptr); iy++)
for (iz=0; iz<Nz(iptr); iz++) {
brightness = CubeValue(iptr,ix,iy,iz);
total += brightness;
m_max = MAX(m_max, brightness);
m_min = MIN(m_min, brightness);
}
MapMin(iptr) = m_min; /* update map headers */
MapMax(iptr) = m_max;
if (hasvalue("gauss")) {
BeamType(iptr)=GAUSS;
if (strchr(getparam("dir"),'x'))
Beamx(iptr)=gauss_fwhm;
if (strchr(getparam("dir"),'y'))
Beamy(iptr)=gauss_fwhm;
if (strchr(getparam("dir"),'z'))
Beamz(iptr)=gauss_fwhm;
} else {
BeamType(iptr)=ANYBEAM;
/* factor (3+nsmooth)/2 is very roughly ok for nsmooth=1,2,3,4 */
Beamx(iptr) = (1.5+0.5*nsmooth) * ABS(Dx(iptr));
Beamy(iptr) = (1.5+0.5*nsmooth) * ABS(Dy(iptr));
Beamz(iptr) = (1.5+0.5*nsmooth) * ABS(Dz(iptr));
}
dprintf (1,"New min and max in map are: %f %f\n",m_min,m_max);
dprintf (1,"New total brightness/mass is %f\n",total*Dx(iptr)*Dy(iptr));
}
int read_image (stream instr, imageptr *iptr)
{
string read_matdef;
int nx=0, ny=0, nz=0;
size_t nxyz;
get_history(instr); /* accumulate history */
if (!get_tag_ok (instr,ImageTag))
return 0; /* not an image available */
if (*iptr==NULL) { /* allocate image if neccessary */
*iptr = (imageptr ) allocate(sizeof(image));
dprintf (DLEV,"Allocated image @ %d ",*iptr);
} else {
nx = Nx(*iptr);
ny = Ny(*iptr);
nz = Nz(*iptr);
dprintf (DLEV,"Image %dx%dx%d already allocated @ %d\n",
nx,ny,nz,*iptr);
}
get_set (instr,ImageTag);
get_set (instr,ParametersTag);
get_data (instr,NxTag,IntType, &(Nx(*iptr)), 0);
get_data (instr,NyTag,IntType, &(Ny(*iptr)), 0);
get_data (instr,NzTag,IntType, &(Nz(*iptr)), 0);
if ((nx>0 || ny>0 || nz>0) &&
(nx != Nx(*iptr) || ny != Ny(*iptr) || nz != Nz(*iptr)))
error("Cannot read different sized images in old pointer yet");
if (get_tag_ok(instr,AxisTag))
get_data (instr,AxisTag,IntType, &(Axis(*iptr)), 0);
else
Axis(*iptr) = 0;
if (Axis(*iptr) == 1) {
get_data_coerced (instr,XrefTag,RealType, &(Xref(*iptr)), 0);
get_data_coerced (instr,YrefTag,RealType, &(Yref(*iptr)), 0);
get_data_coerced (instr,ZrefTag,RealType, &(Zref(*iptr)), 0);
} else {
Xref(*iptr) = 0.0;
Yref(*iptr) = 0.0;
Zref(*iptr) = 0.0;
}
get_data_coerced (instr,XminTag,RealType, &(Xmin(*iptr)), 0);
get_data_coerced (instr,YminTag,RealType, &(Ymin(*iptr)), 0);
get_data_coerced (instr,ZminTag,RealType, &(Zmin(*iptr)), 0);
get_data_coerced (instr,DxTag,RealType, &(Dx(*iptr)), 0);
get_data_coerced (instr,DyTag,RealType, &(Dy(*iptr)), 0);
get_data_coerced (instr,DzTag,RealType, &(Dz(*iptr)), 0);
get_data_coerced (instr,MapMinTag, RealType, &(MapMin(*iptr)), 0);
get_data_coerced (instr,MapMaxTag, RealType, &(MapMax(*iptr)), 0);
get_data (instr,BeamTypeTag, IntType, &(BeamType(*iptr)), 0);
get_data_coerced (instr,BeamxTag, RealType, &(Beamx(*iptr)), 0);
get_data_coerced (instr,BeamyTag, RealType, &(Beamy(*iptr)), 0);
get_data_coerced (instr,BeamzTag, RealType, &(Beamz(*iptr)), 0);
if (get_tag_ok(instr,NamexTag)) /* X-axis name */
Namex(*iptr) = get_string(instr,NamexTag);
else
Namex(*iptr) = NULL;
if (get_tag_ok(instr,NameyTag)) /* Y-axis name */
Namey(*iptr) = get_string(instr,NameyTag);
else
Namey(*iptr) = NULL;
if (get_tag_ok(instr,NamezTag)) /* Z-axis name */
Namez(*iptr) = get_string(instr,NamezTag);
else
Namez(*iptr) = NULL;
if (get_tag_ok(instr,UnitTag)) /* units */
Unit(*iptr) = get_string(instr,UnitTag);
else
Unit(*iptr) = NULL;
if (get_tag_ok(instr,TimeTag)) /* time */
get_data_coerced (instr,TimeTag, RealType, &(Time(*iptr)), 0);
else
Time(*iptr) = 0.0;
read_matdef = get_string(instr,StorageTag);
if (!streq(read_matdef,matdef[idef]))
dprintf(0,"read_image: StorageTag = %s, compiled with %s\n",
read_matdef, matdef[idef]);
get_tes (instr,ParametersTag);
get_set (instr,MapTag);
if (Frame(*iptr)==NULL) { /* check if allocated */
nxyz = Nx(*iptr)*Ny(*iptr)*Nz(*iptr);
Frame(*iptr) = (real *) allocate(nxyz * sizeof(real));
dprintf (DLEV,"Frame allocated @ %d ",Frame(*iptr));
} else
dprintf (DLEV,"Frame already allocated @ %d\n",Frame(*iptr));
if (Nz(*iptr)==1)
get_data_coerced (instr,MapValuesTag,RealType, Frame(*iptr),
Nx(*iptr), Ny(*iptr), 0);
else
get_data_coerced (instr,MapValuesTag,RealType, Frame(*iptr),
Nx(*iptr), Ny(*iptr), Nz(*iptr), 0);
get_tes (instr,MapTag);
get_tes (instr,ImageTag);
set_iarray(*iptr);
dprintf (DLEV,"Frame size %d * %d \n",Nx(*iptr), Ny(*iptr));
return 1; /* succes return code */
}
//---------------------------------------------------------
void NDG3D::PoissonIPDG3D(CSd& spOP, CSd& spMM)
//---------------------------------------------------------
{
// function [OP,MM] = PoissonIPDG3D()
//
// Purpose: Set up the discrete Poisson matrix directly
// using LDG. The operator is set up in the weak form
DVec faceR("faceR"), faceS("faceS"), faceT("faceT");
DMat V2D; IVec Fm("Fm"); IVec i1_Nfp = Range(1,Nfp);
double opti1=0.0, opti2=0.0; int i=0;
umLOG(1, "\n ==> {OP,MM} assembly: ");
opti1 = timer.read(); // time assembly
// build local face matrices
DMat massEdge[5]; // = zeros(Np,Np,Nfaces);
for (i=1; i<=Nfaces; ++i) {
massEdge[i].resize(Np,Np);
}
// face mass matrix 1
Fm = Fmask(All,1); faceR=r(Fm); faceS=s(Fm);
V2D = Vandermonde2D(N, faceR, faceS);
massEdge[1](Fm,Fm) = inv(V2D*trans(V2D));
// face mass matrix 2
Fm = Fmask(All,2); faceR = r(Fm); faceT = t(Fm);
V2D = Vandermonde2D(N, faceR, faceT);
massEdge[2](Fm,Fm) = inv(V2D*trans(V2D));
// face mass matrix 3
Fm = Fmask(All,3); faceS = s(Fm); faceT = t(Fm);
V2D = Vandermonde2D(N, faceS, faceT);
massEdge[3](Fm,Fm) = inv(V2D*trans(V2D));
// face mass matrix 4
Fm = Fmask(All,4); faceS = s(Fm); faceT = t(Fm);
V2D = Vandermonde2D(N, faceS, faceT);
massEdge[4](Fm,Fm) = inv(V2D*trans(V2D));
// build local volume mass matrix
MassMatrix = trans(invV)*invV;
DMat Dx("Dx"),Dy("Dy"),Dz("Dz"), Dx2("Dx2"),Dy2("Dy2"),Dz2("Dz2");
DMat Dn1("Dn1"),Dn2("Dn2"), mmE("mmE"), OP11("OP11"), OP12("OP12");
DMat mmE_All_Fm1, mmE_Fm1_Fm1, Dn2_Fm2_All;
IMat rows1,cols1,rows2,cols2; int k1=0,f1=0,k2=0,f2=0,id=0;
Index1D entries, entriesMM, idsM; IVec fidM,vidM,Fm1,vidP,Fm2;
double lnx=0.0,lny=0.0,lnz=0.0,lsJ=0.0,hinv=0.0,gtau=0.0;
double N1N1 = double((N+1)*(N+1)); int NpNp = Np*Np;
// build DG derivative matrices
int max_OP = (K*Np*Np*(1+Nfaces));
int max_MM = (K*Np*Np);
// "OP" triplets (i,j,x), extracted to {Ai,Aj,Ax}
IVec OPi(max_OP), OPj(max_OP), Ai,Aj; DVec OPx(max_OP), Ax;
// "MM" triplets (i,j,x)
IVec MMi(max_MM), MMj(max_MM); DVec MMx(max_MM);
IVec OnesNp = Ones(Np);
// global node numbering
entries.reset(1,NpNp); entriesMM.reset(1,NpNp);
OP12.resize(Np,Np);
for (k1=1; k1<=K; ++k1)
{
if (! (k1%250)) { umLOG(1, "%d, ",k1); }
rows1 = outer( Range((k1-1)*Np+1,k1*Np), OnesNp );
cols1 = trans(rows1);
// Build local operators
Dx = rx(1,k1)*Dr + sx(1,k1)*Ds + tx(1,k1)*Dt;
Dy = ry(1,k1)*Dr + sy(1,k1)*Ds + ty(1,k1)*Dt;
Dz = rz(1,k1)*Dr + sz(1,k1)*Ds + tz(1,k1)*Dt;
OP11 = J(1,k1)*(trans(Dx)*MassMatrix*Dx +
trans(Dy)*MassMatrix*Dy +
trans(Dz)*MassMatrix*Dz);
// Build element-to-element parts of operator
for (f1=1; f1<=Nfaces; ++f1) {
k2 = EToE(k1,f1); f2 = EToF(k1,f1);
rows2 = outer( Range((k2-1)*Np+1, k2*Np), OnesNp );
cols2 = trans(rows2);
fidM = (k1-1)*Nfp*Nfaces + (f1-1)*Nfp + i1_Nfp;
vidM = vmapM(fidM); Fm1 = mod(vidM-1,Np)+1;
vidP = vmapP(fidM); Fm2 = mod(vidP-1,Np)+1;
id = 1+(f1-1)*Nfp + (k1-1)*Nfp*Nfaces;
lnx = nx(id); lny = ny(id); lnz = nz(id); lsJ = sJ(id);
hinv = std::max(Fscale(id), Fscale(1+(f2-1)*Nfp, k2));
Dx2 = rx(1,k2)*Dr + sx(1,k2)*Ds + tx(1,k2)*Dt;
Dy2 = ry(1,k2)*Dr + sy(1,k2)*Ds + ty(1,k2)*Dt;
Dz2 = rz(1,k2)*Dr + sz(1,k2)*Ds + tz(1,k2)*Dt;
Dn1 = lnx*Dx + lny*Dy + lnz*Dz;
Dn2 = lnx*Dx2 + lny*Dy2 + lnz*Dz2;
mmE = lsJ*massEdge[f1];
gtau = 2.0 * N1N1 * hinv; // set penalty scaling
if (EToE(k1,f1)==k1) {
OP11 += ( gtau*mmE - mmE*Dn1 - trans(Dn1)*mmE ); // ok
}
else
{
// interior face variational terms
OP11 += 0.5*( gtau*mmE - mmE*Dn1 - trans(Dn1)*mmE );
// extract mapped regions:
mmE_All_Fm1 = mmE(All,Fm1);
mmE_Fm1_Fm1 = mmE(Fm1,Fm1);
Dn2_Fm2_All = Dn2(Fm2,All);
OP12 = 0.0; // reset to zero
OP12(All,Fm2) = -0.5*( gtau*mmE_All_Fm1 );
OP12(Fm1,All) -= 0.5*( mmE_Fm1_Fm1*Dn2_Fm2_All );
//OP12(All,Fm2) -= 0.5*(-trans(Dn1)*mmE_All_Fm1 );
OP12(All,Fm2) += 0.5*( trans(Dn1)*mmE_All_Fm1 );
// load this set of triplets
#if (1)
OPi(entries)=rows1; OPj(entries)=cols2, OPx(entries)=OP12;
entries += (NpNp);
#else
//###########################################################
// load only the lower triangle (after droptol test?)
sk=0; start=entries(1);
for (int i=1; i<=NpNp; ++i) {
eid = start+i;
id=entries(eid); rid=rows1(i); cid=cols2(i);
if (rows1(rid) >= cid) { // take lower triangle
if ( fabs(OP12(id)) > 1e-15) { // drop small entries
++sk; OPi(id)=rid; OPj(id)=cid, OPx(id)=OP12(id);
}
}
}
entries += sk;
//###########################################################
#endif
}
}
OPi(entries )=rows1; OPj(entries )=cols1, OPx(entries )=OP11;
MMi(entriesMM)=rows1; MMj(entriesMM)=cols1; MMx(entriesMM)=J(1,k1)*MassMatrix;
entries += (NpNp); entriesMM += (NpNp);
}
umLOG(1, "\n ==> {OP,MM} to sparse\n");
entries.reset(1, entries.hi()-Np*Np);
// Extract triplets from the large buffers. Note: this
// requires copying each array, and since these arrays
// can be HUGE(!), we force immediate deallocation:
Ai=OPi(entries); OPi.Free();
Aj=OPj(entries); OPj.Free();
Ax=OPx(entries); OPx.Free();
umLOG(1, " ==> triplets ready (OP) nnz = %10d\n", entries.hi());
// adjust triplet indices for 0-based sparse operators
Ai -= 1; Aj -= 1; MMi -= 1; MMj -= 1; int npk=Np*K;
#if defined(NDG_USE_CHOLMOD) || defined(NDG_New_CHOLINC)
// load only the lower triangle tril(OP) free args?
spOP.load(npk,npk, Ai,Aj,Ax, sp_LT, false,1e-15, true); // {LT, false} -> TriL
#else
// select {upper,lower,both} triangles
//spOP.load(npk,npk, Ai,Aj,Ax, sp_LT, true,1e-15,true); // LT -> enforce symmetry
//spOP.load(npk,npk, Ai,Aj,Ax, sp_All,true,1e-15,true); // All-> includes "noise"
//spOP.load(npk,npk, Ai,Aj,Ax, sp_UT, false,1e-15,true); // UT -> triu(OP) only
#endif
Ai.Free(); Aj.Free(); Ax.Free();
umLOG(1, " ==> triplets ready (MM) nnz = %10d\n", entriesMM.hi());
//-------------------------------------------------------
// The mass matrix operator will NOT be factorised,
// Load ALL elements (both upper and lower triangles):
//-------------------------------------------------------
spMM.load(npk,npk, MMi,MMj,MMx, sp_All,false,1.00e-15,true);
MMi.Free(); MMj.Free(); MMx.Free();
opti2 = timer.read(); // time assembly
umLOG(1, " ==> {OP,MM} converted to csc. (%g secs)\n", opti2-opti1);
}
void nemo_main()
{
stream instr, outstr;
int nx, ny, nz, mode;
int i,j,k;
imageptr iptr1=NULL, iptr2=NULL, optr; /* pointer to images */
real d1, d2, d3, d4, d5, d6, dx, dy, dz;
bool Qsym = TRUE; /* symmetric derivates w.r.t. pixel point */
match(getparam("mode"),valid_modes,&mode);
if (mode==0) error("Not a valid mode; valid:%s",valid_modes);
dprintf(0,"Image sharpening method #%d\n",mode);
instr = stropen(getparam("in"), "r");
read_image( instr, &iptr1);
nx = Nx(iptr1);
ny = Ny(iptr1);
nz = Nz(iptr1);
dx = Dx(iptr1);
dy = Dy(iptr1);
dz = Dz(iptr1);
if (mode & MODE_DIV || mode & MODE_VORT) {
if (read_image(instr,&iptr2) == 0)
error("No second image found in %s\n",getparam("in"));
if (nx != Nx(iptr2))
error("Second image doesn't match in NX: %d <> %d\n",Nx(iptr2),nx);
if (ny != Ny(iptr2))
error("Second image doesn't match in NY: %d <> %d\n",Ny(iptr2),ny);
if (nz != Nz(iptr2))
error("Second image doesn't match in NZ: %d <> %d\n",Nz(iptr2),nz);
}
outstr = stropen(getparam("out"), "w");
create_cube(&optr,nx,ny,nz);
Dx(optr) = Dx(iptr1);
Dy(optr) = Dy(iptr1);
Dz(optr) = Dz(iptr1);
Xmin(optr) = Xmin(iptr1);
Ymin(optr) = Ymin(iptr1);
Zmin(optr) = Zmin(iptr1);
if (mode & MODE_LAPLACE) {
for (k=1; k<nz-1; k++) {
for (j=1; j<ny-1; j++) {
for (i=1; i<nx-1; i++) {
d1 = CV1(i,j,k) - CV1(i-1,j,k);
d2 = CV1(i,j,k) - CV1(i+1,j,k);
d3 = CV1(i,j,k) - CV1(i,j-1,k);
d4 = CV1(i,j,k) - CV1(i,j+1,k);
d5 = CV1(i,j,k) - CV1(i,j,k-1);
d6 = CV1(i,j,k) - CV1(i,j,k+1);
CVO(i,j,k) = sqrt(d1*d1+d2*d2+d3*d3+d4*d4+d5*d5+d6*d6);
}
CVO(0,j,k) = 0.0;
CVO(nx-1,j,k) = 0.0;
}
for (i=0; i<nx; i++)
CVO(i,0,k) = CVO(i,ny-1,k) = 0.0;
}
for(j=0; j<ny; j++)
for(i=0; i<nx; i++)
CVO(i,j,0) = CVO(i,j,nz-1) = 0.0;
} else if (mode & MODE_DIV || mode & MODE_VORT) {
warning("only 2D implemented");
for (k=0; k<nz; k++) {
for (j=0; j<ny-1; j++) {
for (i=0; i<nx-1; i++) {
if (Qsym) {
if (i>0 && j>0) {
d1 = 0.5*(CV1(i+1,j,k) - CV1(i-1,j,k)); /* dv_x/dx */
d2 = 0.5*(CV1(i,j+1,k) - CV1(i,j-1,k)); /* dv_x/dy */
d3 = 0.5*(CV2(i+1,j,k) - CV2(i-1,j,k)); /* dv_y/dx */
d4 = 0.5*(CV2(i,j+1,k) - CV2(i,j-1,k)); /* dv_y/dy */
} else
d1 = d2 = d3 = d4 = 0.0;
} else {
d1 = CV1(i+1,j,k) - CV1(i,j,k); /* dv_x/dx */
d2 = CV1(i,j+1,k) - CV1(i,j,k); /* dv_x/dy */
d3 = CV2(i+1,j,k) - CV2(i,j,k); /* dv_y/dx */
d4 = CV2(i,j+1,k) - CV2(i,j,k); /* dv_y/dy */
}
if (mode&MODE_DIV)
CVO(i,j,k) = d1/dx + d4/dy;
else if (mode&MODE_VORT)
CVO(i,j,k) = d3/dx - d2/dy;
}
CVO(nx-1,j,k) = 0.0;
}
for (i=0; i<nx; i++) {
CVO(i,ny-1,k) = 0.0;
}
}
} else if (mode & MODE_AREGAN || mode & MODE_PREGAN) {
warning("only 2D implemented");
for (k=0; k<nz; k++) {
for (j=0; j<ny-1; j++) {
for (i=0; i<nx-1; i++) {
d1 = CV1(i,j,k) - CV1(i+1,j,k);
d2 = CV1(i,j+1,k) - CV1(i+1,j+1,k);
d3 = CV1(i,j,k) - CV1(i,j+1,k);
d4 = CV1(i+1,j,k) - CV1(i+1,j+1,k);
if (mode&MODE_AREGAN)
CVO(i,j,k) = sqrt(sqr(d1+d2)+sqr(d3+d4))/2;
else {
if (d3+d4==0.0 && d1+d2==0.0)
CVO(i,j,k) = 0.0;
else
CVO(i,j,k) = atan2(d3+d4,d1+d2) * 180 / PI;
}
}
CVO(nx-1,j,k) = 0.0;
}
for (i=0; i<nx; i++) {
CVO(i,ny-1,k) = 0.0;
}
}
}
write_image(outstr, optr);
}
image *xyopen(int *handle, string name, string status, int naxis, int *axes)
{
int i, access;
string read_matdef;
image *iptr;
stream str;
if(naxis>MAXNAXIS)
error("naxis=%d not supported: MAXNAXIS=%d",naxis, MAXNAXIS);
if (first) xy_init();
str = stropen(name,status); /* open file */
switch (*status) {
case 'r': /* "r", "old" */
case 'o':
access = GET;
break;
case 'w': /* "w", "new" */
case 'n':
access = PUT;
break;
default:
error("xyopen: Unsupported mode %s",status);
}
iptr = (imageptr )allocate(sizeof(image)); /* new image */
if(access == GET){
get_history(str);
get_set (str,ImageTag);
get_set (str,ParametersTag);
get_data (str,NxTag,IntType, &(Nx(iptr)), 0);
get_data (str,NyTag,IntType, &(Ny(iptr)), 0);
get_data (str,NzTag,IntType, &(Nz(iptr)), 0);
get_data_coerced (str,XminTag,RealType, &(Xmin(iptr)), 0);
get_data_coerced (str,YminTag,RealType, &(Ymin(iptr)), 0);
get_data_coerced (str,ZminTag,RealType, &(Zmin(iptr)), 0);
get_data_coerced (str,DxTag,RealType, &(Dx(iptr)), 0);
get_data_coerced (str,DyTag,RealType, &(Dy(iptr)), 0);
get_data_coerced (str,DzTag,RealType, &(Dz(iptr)), 0);
get_data_coerced (str,MapMinTag, RealType, &(MapMin(iptr)), 0);
get_data_coerced (str,MapMaxTag, RealType, &(MapMax(iptr)), 0);
get_data (str,BeamTypeTag, IntType, &(BeamType(iptr)), 0);
get_data_coerced (str,BeamxTag, RealType, &(Beamx(iptr)), 0);
get_data_coerced (str,BeamyTag, RealType, &(Beamy(iptr)), 0);
get_data_coerced (str,BeamzTag, RealType, &(Beamz(iptr)), 0);
if (get_tag_ok(str,NamexTag)) /* X-axis name */
Namex(iptr) = get_string(str,NamexTag);
else
Namex(iptr) = NULL;
if (get_tag_ok(str,NameyTag)) /* Y-axis name */
Namey(iptr) = get_string(str,NameyTag);
else
Namey(iptr) = NULL;
if (get_tag_ok(str,NamezTag)) /* Z-axis name */
Namez(iptr) = get_string(str,NamezTag);
else
Namez(iptr) = NULL;
if (get_tag_ok(str,UnitTag)) /* units */
Unit(iptr) = get_string(str,UnitTag);
else
Unit(iptr) = NULL;
read_matdef = get_string(str,StorageTag);
if (!streq(read_matdef,matdef[idef]))
dprintf(0,"read_image: StorageTag = %s, compiled with %s\n",
read_matdef, matdef[idef]);
get_tes(str,ParametersTag);
get_set(str,MapTag);
if(Nz(iptr)<=1)
get_data_set(str,MapValuesTag,RealType,Nx(iptr),Ny(iptr),0);
else
get_data_set(str,MapValuesTag,RealType,Nx(iptr),Ny(iptr),Nz(iptr),0);
for (i=0; i<naxis; i++) axes[i] = 1;
axes[0] = Nx(iptr); axes[1] = Ny(iptr); axes[2] = Nz(iptr);
} else { /* PUT */
Nx(iptr) = Ny(iptr) = Nz(iptr) = 1;
if (naxis>0) Nx(iptr) = axes[0];
if (naxis>1) Ny(iptr) = axes[1];
if (naxis>2) Nz(iptr) = axes[2];
put_history(str);
put_set (str,ImageTag);
put_set (str,ParametersTag);
put_data (str,NxTag, IntType, &(Nx(iptr)), 0);
put_data (str,NyTag, IntType, &(Ny(iptr)), 0);
put_data (str,NzTag, IntType, &(Nz(iptr)), 0);
put_data (str,XminTag,RealType, &(Xmin(iptr)), 0);
put_data (str,YminTag,RealType, &(Ymin(iptr)), 0);
put_data (str,ZminTag,RealType, &(Zmin(iptr)), 0);
put_data (str,DxTag, RealType, &(Dx(iptr)), 0);
put_data (str,DyTag, RealType, &(Dy(iptr)), 0);
put_data (str,DzTag, RealType, &(Dz(iptr)), 0);
put_data (str,MapMinTag, RealType, &(MapMin(iptr)), 0);
put_data (str,MapMaxTag, RealType, &(MapMax(iptr)), 0);
put_data (str,BeamTypeTag, IntType, &(BeamType(iptr)), 0);
put_data (str,BeamxTag, RealType, &(Beamx(iptr)), 0);
put_data (str,BeamyTag, RealType, &(Beamy(iptr)), 0);
put_data (str,BeamzTag, RealType, &(Beamz(iptr)), 0);
if (Namex(iptr))
put_string (str,NamexTag,Namex(iptr));
if (Namey(iptr))
put_string (str,NameyTag,Namey(iptr));
if (Namez(iptr))
put_string (str,NamezTag,Namez(iptr));
if (Unit(iptr))
put_string (str,UnitTag,Unit(iptr));
put_string(str,StorageTag,matdef[idef]);
put_tes(str, ParametersTag);
put_set(str, MapTag);
if(Nz(iptr)<=1)
put_data_set(str,MapValuesTag,RealType,Nx(iptr),Ny(iptr),0);
else
put_data_set(str,MapValuesTag,RealType,Nx(iptr),Ny(iptr),Nz(iptr),0);
}
*handle = -1;
for(i=0; i<MAXOPEN; i++) { /* look for a new table entry */
if(images[i].str == NULL) *handle = i;
}
if(*handle < 0)
error("xyopen: No more free slots; too many open images");
for (i=0; i<MAXNAXIS; i++)
images[*handle].axes[i] = 1;
images[*handle].str = str;
images[*handle].iptr = iptr;
images[*handle].offset = 0;
images[*handle].access = access;
images[*handle].naxis = (Nz(iptr)<=1 ? 2 : 3);
images[*handle].axes[0] = Nx(iptr);
images[*handle].axes[1] = Ny(iptr);
images[*handle].axes[2] = Nz(iptr);
return iptr;
}
nemo_main()
{
int i, j, k;
real x, xmin, xmax, mean, sigma, skew, kurt, median, bad, w, *data;
real sum, sov;
Moment m;
bool Qmin, Qmax, Qbad, Qw, Qmedian, Qmmcount = getbparam("mmcount");
real nu, nppb = getdparam("nppb");
int npar = getiparam("npar");
int ngood = 0;
int min_count, max_count;
instr = stropen (getparam("in"), "r");
read_image (instr,&iptr);
strclose(instr);
if (hasvalue("win")) {
instr = stropen (getparam("win"), "r");
read_image (instr,&wptr);
strclose(instr);
if (Nx(iptr) != Nx(wptr)) error("X sizes of in/win don't match");
if (Ny(iptr) != Ny(wptr)) error("X sizes of in/win don't match");
if (Nz(iptr) != Nz(wptr)) error("X sizes of in/win don't match");
Qw = TRUE;
} else
Qw = FALSE;
nx = Nx(iptr);
ny = Ny(iptr);
nz = Nz(iptr);
Qmin = hasvalue("min");
if (Qmin) xmin = getdparam("min");
Qmax = hasvalue("max");
if (Qmax) xmax = getdparam("max");
Qbad = hasvalue("bad");
if (Qbad) bad = getdparam("bad");
Qmedian = getbparam("median");
if (Qmedian)
data = (real *) allocate(nx*ny*nz*sizeof(real));
sov = Dx(iptr)*Dy(iptr)*Dz(iptr); /* voxel volume; TODO: should we do 2D vs. 3D ? */
ini_moment(&m,4,0);
for (i=0; i<nx; i++) {
for (j=0; j<ny; j++) {
for (k=0; k<nz; k++) {
x = CubeValue(iptr,i,j,k);
if (Qmin && x<xmin) continue;
if (Qmax && x>xmax) continue;
if (Qbad && x==bad) continue;
w = Qw ? CubeValue(wptr,i,j,k) : 1.0;
accum_moment(&m,x,w);
if (Qmedian) data[ngood++] = x;
}
}
}
if (npar > 0) {
nu = n_moment(&m)/nppb - npar;
if (nu < 1) error("%g: No degrees of freedom",nu);
printf("chi2= %g\n", show_moment(&m,2)/nu/nppb);
printf("df= %g\n", nu);
} else {
nsize = nx * ny * nz;
mean = mean_moment(&m);
sigma = sigma_moment(&m);
skew = skewness_moment(&m);
kurt = kurtosis_moment(&m);
sum = show_moment(&m,1);
printf ("Min=%f Max=%f\n",min_moment(&m), max_moment(&m));
printf ("Number of points : %d\n",n_moment(&m));
printf ("Mean and dispersion : %f %f\n",mean,sigma);
printf ("Skewness and kurtosis : %f %f\n",skew,kurt);
printf ("Sum and Sum*Dx*Dy*Dz : %f %f\n",sum, sum*sov);
if (Qmedian)
printf ("Median : %f\n",get_median(ngood,data));
if (Qmmcount) {
min_count = max_count = 0;
xmin = min_moment(&m);
xmax = max_moment(&m);
for (i=0; i<nx; i++) {
for (j=0; j<ny; j++) {
for (k=0; k<nz; k++) {
x = CubeValue(iptr,i,j,k);
if (x==xmin) min_count++;
if (x==xmax) max_count++;
}
}
} /* i */
printf("Min_Max_count : %d %d\n",min_count,max_count);
}
printf ("%d/%d out-of-range points discarded\n",nsize-n_moment(&m), nsize);
}
}
void write_fits(string name,imageptr iptr)
{
FLOAT tmpr,xmin[3],xref[3],dx[3],mapmin,mapmax; /* fitsio FLOAT !!! */
FITS *fitsfile;
char *cp, origin[80];
string *hitem, axname[3];
float *buffer, *bp;
int i, j, k, axistype, bitpix, keepaxis[3], nx[3], p[3], nx_out[3], ndim=3;
double bscale, bzero;
if (hasvalue("ndim")) ndim = getiparam("ndim");
nx[0] = Nx(iptr);
nx[1] = Ny(iptr);
nx[2] = Nz(iptr); if (nx[2] <= 0) nx[2] = 1;
xmin[0] = Xmin(iptr)*scale[0];
xmin[1] = Ymin(iptr)*scale[1];
xmin[2] = Zmin(iptr)*scale[2];
dx[0] = Dx(iptr)*scale[0];
dx[1] = Dy(iptr)*scale[1];
dx[2] = Dz(iptr)*scale[2];
xref[0] = Xref(iptr)+1.0;
xref[1] = Yref(iptr)+1.0;
xref[2] = Zref(iptr)+1.0;
axistype = Axis(iptr);
axname[0] = (Namex(iptr) ? Namex(iptr) : xyz[0]);
axname[1] = (Namey(iptr) ? Namey(iptr) : xyz[1]);
axname[2] = (Namez(iptr) ? Namez(iptr) : xyz[2]);
mapmin = MapMin(iptr);
mapmax = MapMax(iptr);
if (Qdummy)
for (i=0; i<3; i++) p[i] = i;
else {
if (Qrefmap) warning("dummy=f and usage of refmap will result in bad headers");
permute(nx,p,3);
dprintf(0,"Reordering axes: %d %d %d\n",p[0],p[1],p[2]);
}
#if 1
for (i=0; i<3; i++) nx_out[i] = nx[p[i]];
/* fix this so CubeValue works */
Nx(iptr) = nx_out[0];
Ny(iptr) = nx_out[1];
Nz(iptr) = nx_out[2];
#else
for (i=0; i<3; i++) nx_out[i] = nx[i];
#endif
sprintf(origin,"NEMO ccdfits %s",getparam("VERSION"));
dprintf(1,"NEMO Image file written to FITS disk file\n");
dprintf(1,"%d %d %d %f %f %f %f %f %f %f %f %f %f %f \n",
nx[0],nx[1],nx[2],xmin[0],xmin[1],xmin[2],dx[0],dx[1],dx[2],xref[0],xref[1],xref[2],
mapmin,mapmax);
dprintf(1,"keepaxis(%d,%d,%d)\n",keepaxis[0],keepaxis[1],keepaxis[2]);
fit_setblocksize(2880*getiparam("blocking"));
bitpix = getiparam("bitpix");
fit_setbitpix(bitpix);
if (bitpix == 16) { /* scale from -2^(bitpix-1) .. 2^(bitpix-1)-1 */
bscale = (mapmax - mapmin) / (2.0*32768.0 - 1.0);
bzero = mapmax - bscale*32767.0;
fit_setscale(bscale,bzero);
} else if (bitpix == 32) {
bscale = (mapmax - mapmin) / (2.0*2147483648.0 - 1.0);
bzero = mapmax - bscale*2147483647.0;
fit_setscale(bscale,bzero);
} else if (bitpix == 8) {
bscale = (mapmax - mapmin) / (2.0*128.0 - 1.0);
bzero = mapmin;
fit_setscale(bscale,bzero);
}
dprintf(1,"bscale,bzero=%g %g\n",bscale,bzero);
fitsfile = fitopen(name,"new",ndim,nx_out);
if (fitsfile==NULL) error("Could not open fitsfile %s for writing\n",name);
if (Qrefmap || Qcrpix) {
fitwrhdr(fitsfile,"CRPIX1",ref_crpix[0]);
fitwrhdr(fitsfile,"CRPIX2",ref_crpix[1]);
if (ndim>2) fitwrhdr(fitsfile,"CRPIX3",ref_crpix[2]);
} else {
if (axistype==1) {
fitwrhdr(fitsfile,"CRPIX1",xref[0]);
fitwrhdr(fitsfile,"CRPIX2",xref[1]);
if (ndim>2) fitwrhdr(fitsfile,"CRPIX3",xref[2]);
} else {
fitwrhdr(fitsfile,"CRPIX1",1.0); /* CRPIX = 1 by Nemo definition */
fitwrhdr(fitsfile,"CRPIX2",1.0);
if (ndim>2) fitwrhdr(fitsfile,"CRPIX3",1.0);
}
}
if (Qrefmap || Qcrval) {
fitwrhdr(fitsfile,"CRVAL1",ref_crval[0]);
fitwrhdr(fitsfile,"CRVAL2",ref_crval[1]);
if (ndim>2) fitwrhdr(fitsfile,"CRVAL3",ref_crval[2]);
} else {
fitwrhdr(fitsfile,"CRVAL1",xmin[p[0]]);
fitwrhdr(fitsfile,"CRVAL2",xmin[p[1]]);
if (ndim>2) fitwrhdr(fitsfile,"CRVAL3",xmin[p[2]]);
}
if (Qcdmatrix) {
fitwrhdr(fitsfile,"CD1_1",dx[p[0]]);
fitwrhdr(fitsfile,"CD2_2",dx[p[1]]);
if (ndim>2) fitwrhdr(fitsfile,"CD3_3",dx[p[2]]);
} else {
if (Qrefmap || Qcdelt) {
fitwrhdr(fitsfile,"CDELT1",ref_cdelt[0]*scale[0]);
fitwrhdr(fitsfile,"CDELT2",ref_cdelt[1]*scale[1]);
if (ndim>2) fitwrhdr(fitsfile,"CDELT3",ref_cdelt[2]*scale[2]);
} else {
fitwrhdr(fitsfile,"CDELT1",dx[p[0]]);
fitwrhdr(fitsfile,"CDELT2",dx[p[1]]);
if (ndim>2) fitwrhdr(fitsfile,"CDELT3",dx[p[2]]);
}
}
if (Qradecvel) {
dprintf(0,"[Axes names written as %s, %s, %s\n",
radeve[p[0]],radeve[p[1]],radeve[p[2]]);
fitwrhda(fitsfile,"CTYPE1",radeve[p[0]]);
fitwrhda(fitsfile,"CTYPE2",radeve[p[1]]);
if (ndim>2) fitwrhda(fitsfile,"CTYPE3",radeve[p[2]]);
} else {
if (Qrefmap) {
fitwrhda(fitsfile,"CTYPE1",ref_ctype[0]);
fitwrhda(fitsfile,"CTYPE2",ref_ctype[1]);
if (ndim>2) fitwrhda(fitsfile,"CTYPE3",ref_ctype[2]);
} else {
fitwrhda(fitsfile,"CTYPE1",axname[p[0]]);
fitwrhda(fitsfile,"CTYPE2",axname[p[1]]);
if (ndim>2) fitwrhda(fitsfile,"CTYPE3",axname[p[2]]);
}
}
fitwrhdr(fitsfile,"DATAMIN",mapmin);
fitwrhdr(fitsfile,"DATAMAX",mapmax);
fitwrhda(fitsfile,"ORIGIN",origin);
cp = getenv("USER"); /* AUTHOR */
if (cp)
fitwrhda(fitsfile,"AUTHOR",cp);
else
fitwrhda(fitsfile,"AUTHOR","NEMO");
if (object) /* OBJECT */
fitwrhda(fitsfile,"OBJECT",object);
if (comment) /* COMMENT */
stuffit(fitsfile,"COMMENT",comment);
if (headline)
stuffit(fitsfile,"COMMENT",headline);
hitem = ask_history(); /* HISTORY */
fitwra(fitsfile,"HISTORY","NEMO: History in reversed order");
for (i=0, cp=hitem[0]; cp != NULL; i++) {
stuffit(fitsfile,"HISTORY",cp);
cp = hitem[i+1];
}
for(i=0; i<nfill; i++) /* debugging header I/O */
fitwra(fitsfile,"COMMENT","Dummy filler space");
buffer = (float *) allocate(nx[p[0]]*sizeof(float));
for (k=0; k<nx_out[2]; k++) { /* loop over all planes */
fitsetpl(fitsfile,1,&k);
for (j=0; j<nx_out[1]; j++) { /* loop over all rows */
for (i=0, bp=buffer; i<nx_out[0]; i++, bp++)
*bp = iscale[0] * CubeValue(iptr,i,j,k) + iscale[1];
fitwrite(fitsfile,j,buffer);
}
}
free(buffer);
fitclose(fitsfile);
}
nemo_main()
{
int i, j, k, ki;
real x, y, z, xmin, xmax, mean, sigma, skew, kurt, bad, w, *data;
real dmin, dmax;
real sum, sov, q1, q2, q3;
Moment m;
bool Qmin, Qmax, Qbad, Qw, Qmedian, Qrobust, Qtorben, Qmmcount = getbparam("mmcount");
bool Qx, Qy, Qz, Qone, Qall, Qign = getbparam("ignore");
bool Qhalf = getbparam("half");
bool Qmaxpos = getbparam("maxpos");
real nu, nppb = getdparam("nppb");
int npar = getiparam("npar");
int ngood;
int ndat = 0;
int nplanes;
int min_count, max_count;
int maxmom = getiparam("maxmom");
int maxpos[2];
char slabel[32];
instr = stropen (getparam("in"), "r");
read_image (instr,&iptr);
strclose(instr);
nx = Nx(iptr);
ny = Ny(iptr);
nz = Nz(iptr);
dprintf(1,"# data order debug: %f %f\n",Frame(iptr)[0], Frame(iptr)[1]);
if (hasvalue("tab")) tabstr = stropen(getparam("tab"),"w");
planes = (int *) allocate((nz+1)*sizeof(int));
nplanes = nemoinpi(getparam("planes"),planes,nz+1);
Qall = (planes[0]==-1);
if (planes[0]==0) {
Qone = FALSE;
nplanes = nz;
for (k=0; k<nz; k++)
planes[k] = k;
} else if (!Qall) {
Qone = (!Qall && nplanes==1);
for (k=0; k<nplanes; k++) {
if (planes[k]<1 || planes[k]>nz) error("%d is an illegal plane [1..%d]",planes[k],nz);
planes[k]--;
}
}
if (hasvalue("win")) {
instr = stropen (getparam("win"), "r");
read_image (instr,&wptr);
strclose(instr);
if (Nx(iptr) != Nx(wptr)) error("X sizes of in=/win= don't match");
if (Ny(iptr) != Ny(wptr)) error("Y sizes of in=/win= don't match");
if (Nz(iptr) != Nz(wptr)) error("Z sizes of in=/win= don't match");
Qw = TRUE;
} else
Qw = FALSE;
Qmin = hasvalue("min");
if (Qmin) xmin = getdparam("min");
Qmax = hasvalue("max");
if (Qmax) xmax = getdparam("max");
Qbad = hasvalue("bad");
if (Qbad) bad = getdparam("bad");
Qmedian = getbparam("median");
Qrobust = getbparam("robust");
Qtorben = getbparam("torben");
if (Qtorben) Qmedian = TRUE;
if (Qmedian || Qrobust || Qtorben) {
ndat = nx*ny*nz;
data = (real *) allocate(ndat*sizeof(real));
}
sov = 1.0; /* volume of a pixel/voxel */
Qx = Qign && Nx(iptr)==1;
Qy = Qign && Ny(iptr)==1;
Qz = Qign && Nz(iptr)==1;
sov *= Qx ? 1.0 : Dx(iptr);
sov *= Qy ? 1.0 : Dy(iptr);
sov *= Qz ? 1.0 : Dz(iptr);
strcpy(slabel,"*");
if (!Qx) strcat(slabel,"Dx*");
if (!Qy) strcat(slabel,"Dy*");
if (!Qz) strcat(slabel,"Dz*");
if (maxmom < 0) {
warning("No work done, maxmom<0");
stop(0);
}
if (Qall) { /* treat cube as one data block */
ini_moment(&m,maxmom,ndat);
ngood = 0;
for (k=0; k<nz; k++) {
for (j=0; j<ny; j++) {
for (i=0; i<nx; i++) {
x = CubeValue(iptr,i,j,k);
if (Qhalf && x>=0.0) continue;
if (Qmin && x<xmin) continue;
if (Qmax && x>xmax) continue;
if (Qbad && x==bad) continue;
w = Qw ? CubeValue(wptr,i,j,k) : 1.0;
accum_moment(&m,x,w);
if (Qhalf && x<0) accum_moment(&m,-x,w);
if (Qmedian) data[ngood++] = x;
if (tabstr) fprintf(tabstr,"%g\n",x);
}
}
}
if (npar > 0) {
nu = n_moment(&m)/nppb - npar;
if (nu < 1) error("%g: No degrees of freedom",nu);
printf("chi2= %g\n", show_moment(&m,2)/nu/nppb);
printf("df= %g\n", nu);
} else {
nsize = nx * ny * nz;
sum = mean = sigma = skew = kurt = 0;
if (maxmom > 0) {
mean = mean_moment(&m);
sum = show_moment(&m,1);
}
if (maxmom > 1)
sigma = sigma_moment(&m);
if (maxmom > 2)
skew = skewness_moment(&m);
if (maxmom > 3)
kurt = kurtosis_moment(&m);
printf ("Number of points : %d\n",n_moment(&m));
printf ("Min and Max : %f %f\n",min_moment(&m), max_moment(&m));
printf ("Mean and dispersion : %f %f\n",mean,sigma);
printf ("Skewness and kurtosis : %f %f\n",skew,kurt);
printf ("Sum and Sum*%s : %f %f\n",slabel, sum, sum*sov);
if (Qmedian) {
if (Qtorben) {
printf ("Median Torben : %f (%d)\n",median_torben(ngood,data,min_moment(&m),max_moment(&m)),ngood);
} else {
printf ("Median : %f\n",get_median(ngood,data));
q2 = median(ngood,data);
q1 = median_q1(ngood,data);
q3 = median_q3(ngood,data);
printf ("Q1,Q2,Q3 : %f %f %f\n",q1,q2,q3);
}
#if 1
if (ndat>0)
printf ("MedianL : %f\n",median_moment(&m));
#endif
}
if (Qrobust) {
compute_robust_moment(&m);
printf ("Mean Robust : %f\n",mean_robust_moment(&m));
printf ("Sigma Robust : %f\n",sigma_robust_moment(&m));
printf ("Median Robust : %f\n",median_robust_moment(&m));
}
if (Qmmcount) {
min_count = max_count = 0;
xmin = min_moment(&m);
xmax = max_moment(&m);
for (i=0; i<nx; i++) {
for (j=0; j<ny; j++) {
for (k=0; k<nz; k++) {
x = CubeValue(iptr,i,j,k);
if (x==xmin) min_count++;
if (x==xmax) max_count++;
}
}
} /* i */
printf("Min_Max_count : %d %d\n",min_count,max_count);
}
printf ("%d/%d out-of-range points discarded\n",nsize-n_moment(&m), nsize);
}
} else { /* treat each plane seperately */
/* tabular output, one line per (selected) plane */
printf("# iz z min max N mean sigma skew kurt sum sumsov ");
if (Qmedian) printf(" [med med]");
if (Qrobust) printf(" robust[N mean sig med]");
if (Qmaxpos) printf(" maxposx maxposy");
printf("\n");
ini_moment(&m,maxmom,ndat);
for (ki=0; ki<nplanes; ki++) {
reset_moment(&m);
k = planes[ki];
z = Zmin(iptr) + k*Dz(iptr);
ngood = 0;
for (j=0; j<ny; j++) {
for (i=0; i<nx; i++) {
x = CubeValue(iptr,i,j,k);
if (Qmin && x<xmin) continue;
if (Qmax && x>xmax) continue;
if (Qbad && x==bad) continue;
if (Qmaxpos) {
if (i==0 && j==0) { dmax = x; maxpos[0] = 0; maxpos[1] = 0;}
else if (x>dmax) { dmax = x; maxpos[0] = i; maxpos[1] = j;}
}
w = Qw ? CubeValue(wptr,i,j,k) : 1.0;
accum_moment(&m,x,w);
if (Qmedian) data[ngood++] = x;
}
}
nsize = nx * ny * nz;
sum = mean = sigma = skew = kurt = 0;
if (maxmom > 0) {
mean = mean_moment(&m);
sum = show_moment(&m,1);
}
if (maxmom > 1)
sigma = sigma_moment(&m);
if (maxmom > 2)
skew = skewness_moment(&m);
if (maxmom > 3)
kurt = kurtosis_moment(&m);
if (n_moment(&m) == 0) {
printf("# %d no data\n",k+1);
continue;
}
printf("%d %f %f %f %d %f %f %f %f %f %f",
k+1, z, min_moment(&m), max_moment(&m), n_moment(&m),
mean,sigma,skew,kurt,sum,sum*sov);
if (Qmedian) {
printf (" %f",get_median(ngood,data));
if (ndat>0) printf (" %f",median_moment(&m));
}
if (Qrobust) {
compute_robust_moment(&m);
printf (" %d %f %f %f",n_robust_moment(&m), mean_robust_moment(&m),
sigma_robust_moment(&m), median_robust_moment(&m));
}
if (Qmaxpos) {
printf(" %d %d",maxpos[0],maxpos[1]);
}
#if 0
if (Qmmcount) {
min_count = max_count = 0;
xmin = min_moment(&m);
xmax = max_moment(&m);
for (i=0; i<nx; i++) {
for (j=0; j<ny; j++) {
x = CubeValue(iptr,i,j,k);
if (x==xmin) min_count++;
if (x==xmax) max_count++;
}
} /* i,j */
printf(" %d %d",min_count,max_count);
}
printf ("%d/%d out-of-range points discarded\n",nsize-n_moment(&m), nsize);
#endif
printf("\n");
} /* ki */
}
}
void nemo_main()
{
stream instr, outstr;
int nx, ny, nz;
int nstep,nstep1;
int i,j,k, n, n1, i1, j1, m;
int ix[2], iy[2];
imageptr iptr=NULL, optr; /* pointer to images */
real *vals, fraction;
string mode = getparam("mode");
bool Qmedian = (*mode == 'm');
bool Qmean = (*mode == 'a');
nstep = getiparam("nstep");
if (nstep%2 != 1) error("step size %d needs to be odd",nstep);
nstep1 = (nstep-1)/2;
n = getiparam("n");
if (Qmedian)
dprintf(1,"Median filter size %d\n",n);
else if (Qmean)
dprintf(1,"Mean filter size %d\n",n);
else
dprintf(1,"Subtraction filter size %d\n",n);
if (n%2 != 1) error("filter size %d needs to be odd",n);
n1 = (n-1)/2;
vals = (real *) allocate (sizeof(real) * (n*n + 1));
instr = stropen(getparam("in"), "r");
read_image( instr, &iptr);
nx = Nx(iptr);
ny = Ny(iptr);
nz = Nz(iptr);
if (nz > 1) error("Cannot do 3D cubes properly; use 2D");
if (hasvalue("x") && hasvalue("y")) {
get_range("x",ix);
get_range("y",iy);
} else {
ix[0] = 0;
ix[1] = nx-1;
iy[0] = 0;
iy[1] = ny-1;
}
dprintf(1,"Xrange: %d - %d Yrange: %d - %d\n",ix[0],ix[1],iy[0],iy[1]);
outstr = stropen(getparam("out"), "w");
create_cube(&optr,nx,ny,nz);
Dx(optr) = Dx(iptr);
Dy(optr) = Dy(iptr);
Dz(optr) = Dz(iptr);
Xmin(optr) = Xmin(iptr);
Ymin(optr) = Ymin(iptr);
Zmin(optr) = Zmin(iptr);
if (nstep > 1) {
warning("Cheat mode nstep=%d",nstep);
for (j=nstep1; j<ny-nstep1; j+=nstep) {
for (i=nstep1; i<nx-nstep1; i+=nstep) {
if (j<n1 || j >= ny-n1 || j < iy[0] || j > iy[1]) {
CVO(i,j) = CVI(i,j);
continue;
}
if (i<n1 || i >= nx-n1 || i < ix[0] || i > ix[1]) {
CVO(i,j) = CVI(i,j);
continue;
}
m = 0;
for (j1=j-n1; j1<=j+n1; j1++)
for (i1=i-n1; i1<=i+n1; i1++)
vals[m++] = CVI(i1,j1);
CVO(i,j) = median(m,vals,fraction);
for (j1=j-nstep1; j1<=j+nstep1; j1++)
for (i1=i-nstep1; i1<=i+nstep1; i1++)
CVO(i1,j1) = CVO(i,j);
}
}
} else {
for (j=0; j<ny; j++) {
for (i=0; i<nx; i++) {
if (j<n1 || j >= ny-n1 || j < iy[0] || j > iy[1]) {
CVO(i,j) = CVI(i,j);
continue;
}
if (i<n1 || i >= nx-n1 || i < ix[0] || i > ix[1]) {
CVO(i,j) = CVI(i,j);
continue;
}
m = 0;
for (j1=j-n1; j1<=j+n1; j1++)
for (i1=i-n1; i1<=i+n1; i1++)
vals[m++] = CVI(i1,j1);
if (Qmedian)
CVO(i,j) = median(m,vals,fraction);
else if (Qmean)
CVO(i,j) = mean(m,vals,fraction);
else
CVO(i,j) = subtract(m,vals,fraction);
}
}
}
write_image(outstr, optr);
}
double Niu2(double z) /*niu' * deltaM */
{
double deltac=1.69;
return (sqrt(0.707) * deltac / (Dz(z) ));
}
