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 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); }
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; }
nemo_main() { int n = 0; setparams(); /* set globals */ instr = stropen (infile, "r"); plinit ("***", 0.0, 20.0, 0.0, 20.0); /* init yapp */ while (read_image(instr,&iptr)) { /* loop while more images found */ dprintf(1,"Time= %g MinMax= %g %g\n",Time(iptr),MapMin(iptr),MapMax(iptr)); nx=Nx(iptr); ny=Ny(iptr); nz=Nz(iptr); if (nz > 1) error("Cannot handle 3D images [%d,%d,%d]",nx,ny,nz); xmin=Xmin(iptr); ymin=Ymin(iptr); dx=Dx(iptr); dy=Dy(iptr); xsize = nx * dx; ysize = ny * dy; if (n>0) { sleep(1); plframe(); } plot_map(); /* plot the map */ n++; } plstop(); /* end of yapp */ strclose(instr); }
static void set_iarray(imageptr iptr) { int i; int nx, ny, nz; #ifdef USE_IARRAY nx = Nx(iptr); ny = Ny(iptr); nz = Nz(iptr); warning("USE_IARRAY (%d,%d,%d)",nx,ny,nz); IDx(iptr) = (int *) allocate( nx * sizeof(int)); IDy(iptr) = (int *) allocate( ny * sizeof(int)); IDz(iptr) = (int *) allocate( nz * sizeof(int)); if (idef == 1) { // CDEF for (i=0; i<nz; i++) IDz(iptr)[i] = i; for (i=0; i<ny; i++) IDy(iptr)[i] = nz*i; for (i=0; i<nx; i++) IDx(iptr)[i] = nz*ny*i; } else if (idef == 0) { // FORDEF for (i=0; i<nx; i++) IDx(iptr)[i] = i; for (i=0; i<ny; i++) IDy(iptr)[i] = nx*i; for (i=0; i<nz; i++) IDz(iptr)[i] = nx*ny*i; } else // ILLEGAL error("set_iarray: idef=%d\n",idef); #endif }
void nemo_main() { stream instr, outstr; int nx, ny, nz; /* size of scratch map */ int nx1,ny1,nz1; int nxaver, nyaver,nzaver; int i,j,k, i0,j0,k0, i1,j1,k1; imageptr iptr=NULL, iptr1=NULL; /* pointer to images */ real sum, tmp, zzz; bool Qreorder = FALSE; bool Qdummy, Qsample; string reorder; instr = stropen(getparam("in"), "r"); nxaver=getiparam("nxaver"); nyaver=getiparam("nyaver"); nzaver=getiparam("nzaver"); Qdummy = getbparam("dummy"); nx1 = nemoinpi(getparam("x"),ix,MAXDIM); ny1 = nemoinpi(getparam("y"),iy,MAXDIM); nz1 = nemoinpi(getparam("z"),iz,MAXDIM); if (nx1<0 || ny1<0 || nz1<0) error("Error parsing x,y,z="); Qsample = nx1>0 || ny1>0 || nz1>0; if (Qsample) warning("Sampling will be done"); read_image( instr, &iptr); nx = Nx(iptr); /* old cube size */ ny = Ny(iptr); nz = Nz(iptr); nx1 = ax_index("x",nx,nx1,ix); /* initialize new cube axes */ ny1 = ax_index("y",ny,ny1,iy); /* before any reordering */ nz1 = ax_index("z",nz,nz1,iz); Qreorder = hasvalue("reorder"); if (Qreorder) { reorder = getparam("reorder"); if (strlen(reorder) != 3) error("Reorder must have 3 letters"); } outstr = stropen(getparam("out"), "w"); if (nxaver>1 || nyaver>1 || nzaver>1) { /* averaging, but retaining size */ dprintf(0,"Averaging map %d * %d * %d pixels; mapsize %d * %d * %d\n", nxaver,nyaver,nzaver,nx,ny,nz); nx1 = nx/nxaver; if (nx % nxaver) warning("X binning not even"); ny1 = ny/nyaver; if (ny % nyaver) warning("Y binning not even"); nz1 = nz/nzaver; if (nz % nzaver) warning("X binning not even"); LOOP(k1,nz1) { k = k1*nzaver; LOOP(j1,ny1) { j = j1*nyaver; LOOP(i1,nx1) { i = i1*nxaver; sum = 0.0; LOOP(k0,nzaver) LOOP(j0,nyaver) LOOP(i0,nxaver) sum += CV(iptr, i+i0, j+j0, k+k0); sum /= (real) (nxaver*nyaver*nzaver); LOOP(k0,nzaver) LOOP(j0,nyaver) LOOP(i0,nxaver) CV(iptr, i+i0, j+j0, k+k0) = sum; }
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; }
local void read_data() { int i, k, ndata, n; real *data; stream instr; imageptr iptr=NULL; instr = stropen (input, "r"); read_image (instr,&iptr); strclose(instr); ndata = Nx(iptr) * Ny(iptr) * Nz(iptr); data = Frame(iptr); x = (real *) allocate(ndata*sizeof(real)); if (scale != 1.0) { for (i=0; i<ndata; i++) data[i] *= scale; } if (Qdual) { /* pass over the data, finding the mean */ dual_mean = 0.0; n = 0; for (i=0; i<ndata; i++) { if (Qblank && data[i]==blankval) continue; dual_mean += data[i]; n++; } dual_mean /= n; dprintf(0,"Dual pass mean : %g\n",dual_mean); } else dual_mean = 0.0; Nunder = Nover = Nblank = 0; for (i=0, k=0; i<ndata; i++) { if (Qblank && data[i]==blankval) { Nblank++; continue;} data[i] -= dual_mean; if (Qmin && data[i] < xrange[0]) { Nunder++; continue;} if (Qmax && data[i] > xrange[1]) { Nover++; continue;} /* should now copy data into new array for later work */ x[k++] = data[i]; } npt = k; dprintf(0,"Under/Over flow: %d %d\n",Nunder,Nover); dprintf(0,"Blanked: %d\n",Nblank); minmax(npt, x, &xmin, &xmax); if (!Qmin) xrange[0] = xmin; if (!Qmax) xrange[1] = xmax; /* allocate index arrray , and compute sorted index for median */ if (Qmedian) (mysort)(x,npt,sizeof(real),compar_real); free_image(iptr); }
inline void IsingLattice::initialize(){ // initialize the grid (all up) set_all(spin_up); m_total_magnetization = Nx() * Ny() * Nz(); // initial total magnetization = number of sites // As the energy of this initial configuration is the lowest possible for the system anyway, // it is conveniant to just set it to zero: m_total_energy = 0; }
int create_image_mask(imageptr iptr, image_maskptr *mptr) { int nx = Nx(iptr); int ny = Ny(iptr); int nz = Nz(iptr); size_t np = nx*ny*nz; *mptr = (image_maskptr ) allocate(sizeof(image_mask)); dprintf (DLEV,"create_image_mask:Allocated image_mask @ %d size=%d * %d * %d",*mptr,nx,ny,nz); if (*mptr == NULL) return 0; /* no memory available */ Frame(*mptr) = (bool *) allocate(np*sizeof(bool)); dprintf (DLEV,"Frame allocated @ %d ",Frame(*mptr)); if (Frame(*mptr)==NULL) { printf ("CREATE_IMAGE_MASK: Not enough memory to allocate image\n"); return 0; } Nx(*mptr) = nx; Ny(*mptr) = ny; Nz(*mptr) = nz; return 1; }
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; }
const arma::vec& CylindricalBirefringentMaterial::centerOfMass() { com.set_size(3); com.fill(0.0); double mass = 0.0; for ( unsigned int z=0;z<Nz();z++ ) for ( unsigned int y=0;y<Ny();y++ ) for ( unsigned int x=0;x<Nx();x++ ) { com(0) += x*get(x,y,z); com(1) += y*get(x,y,z); com(2) += z*get(x,y,z); mass += get(x,y,z); } com /= mass; return com; }
void report_minmax(string t) { real m_min, m_max, brightness, total; int i, ix, iy, iz, kounter, idir; char *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); } dprintf (0,"%s min and max in map are: %f %f\n",t,m_min,m_max); dprintf (0,"%s total values: %f\n",t,total); dprintf (0,"%s total surden: %f\n",t,total*Dx(iptr)*Dy(iptr)); }
/* * 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 */ }
const arma::mat& CylindricalBirefringentMaterial::inertiaTensor() { centerOfMass(); inertia.set_size(3,3); inertia.fill(0.0); for ( unsigned int z=0;z<Nz();z++ ) for ( unsigned int y=0;y<Ny();y++ ) for ( unsigned int x=0;x<Nx();x++ ) { double xcrd = static_cast<int>(x)-com(0); double ycrd = static_cast<int>(y)-com(1); double zcrd = static_cast<int>(z)-com(2); inertia(0,0) += (ycrd*ycrd + zcrd*zcrd)*get(x,y,z); inertia(0,1) -= xcrd*ycrd*get(x,y,z); inertia(0,2) -= xcrd*zcrd*get(x,y,z); inertia(1,1) += (xcrd*xcrd+zcrd*zcrd)*get(x,y,z); inertia(1,2) -= ycrd*zcrd*get(x,y,z); inertia(2,2) += (xcrd*xcrd+ycrd*ycrd)*get(x,y,z); } inertia(1,0) = inertia(0,1); inertia(2,1) = inertia(1,2); inertia(2,0) = inertia(0,2); return inertia; }
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); }
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)); }
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 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); }
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; }
void nemo_main() { stream instr, outstr; int nx, ny, nz; /* size of scratch map */ int ix, iy, flip; imageptr iptr=NULL; /* pointer to image */ real tmp, zzz; string flipmode; flipmode = getparam("flip"); if (streq(flipmode,"x")) flip = X; else if (streq(flipmode,"y")) flip = Y; else if (streq(flipmode,"xy")) flip = XY; else error("Illegal flip axis"); instr = stropen(getparam("in"), "r"); outstr = stropen(getparam("out"), "w"); read_image( instr, &iptr); nx = Nx(iptr); ny = Ny(iptr); nz = Nz(iptr); if(flip==X) { for (iy=0; iy<ny; iy++) { /* flip in x */ for (ix=0; ix<nx/2; ix++) { tmp = MapValue(iptr,ix,iy); zzz = MapValue(iptr,nx-ix-1,iy); dprintf(1,"%d %d: %f %f\n",ix,iy,tmp,zzz); MapValue(iptr,ix,iy) = MapValue(iptr,nx-ix-1,iy); MapValue(iptr,nx-ix-1,iy) = tmp; } } } else if (flip==Y) { for (iy=0; iy<ny; iy++) { /* flip in y */ for (ix=0; ix<nx/2; ix++) { tmp = MapValue(iptr,iy,ix); zzz = MapValue(iptr,iy,nx-ix-1); dprintf(1,"%d %d: %f %f\n",ix,iy,tmp,zzz); MapValue(iptr,iy,ix) = MapValue(iptr,iy,nx-ix-1); MapValue(iptr,iy,nx-ix-1) = tmp; } } } else if (flip==XY) { for (iy=0; iy<ny; iy++) { /* swap the x and y axes */ for (ix=iy+1; ix<nx; ix++) { tmp = MapValue(iptr,ix,iy); dprintf(1,"%d %d: %f \n",ix,iy,tmp); MapValue(iptr,ix,iy) = MapValue(iptr,iy,ix); MapValue(iptr,iy,ix) = tmp; } } SWAPR(Xmin(iptr), Ymin(iptr)); SWAPR(Dx(iptr), Dy(iptr)); SWAPS(Namex(iptr), Namey(iptr)); } write_image(outstr, 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 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); } } }
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); }
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); }
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 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); }