int main(int argc,char *argv[])
{
#define NOT_REPLACE -999999.0
struct imh imhin={""}, imhout={""};
struct icom icomin={0}, icomout={0};
char fnamin[BUFSIZ]="", fnamout[BUFSIZ]="";
char temp[BUFSIZ];
FILE *fp=NULL, *fp2=NULL;
float *dp, *dpout;
float *dpybin,*dpxbin;
int *ndp;
int ix,iy;
int pixignr=INT_MIN;
float rplc_ignor=NOT_REPLACE;
int maxadd=-1;
float bzero=0.,bscale=1.;
/* int pixoff; */
int u2off;
int iouty, ioutx, i, NBINX=1, NBINY=1, NBIN=1;
int ymin=0, ymax=INT_MAX;
int xmin=0, xmax=INT_MAX;
char dtype[80]="\0";
int fitsdtype;
float fitsmax;
char modename[20]="";
int pixoff;
int n0;
int nline=-1;
int xshift=0,yshift=0;
float vxref=FLT_MAX,vyref=FLT_MAX;
MOSMODE mosmode=NODIST_NOADD;
/*
int dist_clip=0,dist_flux=0,dist_peak=0,dist_add=0,
dist_med=0, nodist_noadd=0, const_add=0;
*/
int addorghead=0;
float vxoff,vyoff;
int nfrm;
float sigmaf=0.16,nsigma=3.0;
int meanmin=0,clipmin=3;
getargopt opts[30];
char *files[3]={NULL};
int n=0;
int helpflag;
/*
* ... Open Input
*/
files[0]=fnamin;
files[1]=fnamout;
setopts(&opts[n++],"-maxadd=", OPTTYP_INT , &maxadd,"(mos)max number of coadd");
setopts(&opts[n++],"-nline=", OPTTYP_INT , &nline,"(mos)y-width of buffering");
setopts(&opts[n++],"-nodist_noadd", OPTTYP_FLAG , &mosmode,"(mos)quick mode (default)",NODIST_NOADD);
setopts(&opts[n++],"-dist_add", OPTTYP_FLAG , &mosmode,"(mos)bilinear weighted mean",DIST_ADD);
setopts(&opts[n++],"-dist_med", OPTTYP_FLAG , &mosmode,"(mos)bilinear weighted median",DIST_MED);
setopts(&opts[n++],"-const_add", OPTTYP_FLAG , &mosmode,"(mos)mean of at least maxadd images or blank",CONST_ADD);
setopts(&opts[n++],"-dist_clip", OPTTYP_FLAG , &mosmode,"(mos)clip mean mode(tesing)",DIST_CLIP_ADD);
setopts(&opts[n++],"-dist_flux", OPTTYP_FLAG , &mosmode,"(mos)flux map mode(testing)",DIST_FLUX);
setopts(&opts[n++],"-dist_peak", OPTTYP_FLAG , &mosmode,"(mos)outlyer mode(testing)",DIST_PEAK);
setopts(&opts[n++],"-vxref=", OPTTYP_FLOAT , &vxref,"(mos) reference pixel x(default: not used (automatic))");
setopts(&opts[n++],"-vyref=", OPTTYP_FLOAT , &vyref,"(mos) reference pixel y(default: not used(automacic))");
setopts(&opts[n++],"-addorghead", OPTTYP_FLAG , &addorghead,"(mos) Add original header of reference (default:no)",1);
setopts(&opts[n++],"-sigmaf=", OPTTYP_FLOAT , &sigmaf,"(mos/clip)sigma estimate fraction (default:0.160)");
setopts(&opts[n++],"-nsigma=", OPTTYP_FLOAT , &nsigma,"(mos/clip)clipping sigma factor(default:3.0)");
setopts(&opts[n++],"-clipmin=", OPTTYP_INT , &clipmin,"(mos/clip)minimum # of images for clipping (default:3)");
setopts(&opts[n++],"-meanmin=", OPTTYP_INT , &meanmin,"(mos/clip)minimum # of images for taking clipped mean(default:not set)");
setopts(&opts[n++],"-ymin=", OPTTYP_INT , &ymin,"ymin (default:0)");
setopts(&opts[n++],"-ymax=", OPTTYP_INT , &ymax,"ymax (default:npy-1)");
setopts(&opts[n++],"-xmin=", OPTTYP_INT , &xmin,"xmin (default:0)");
setopts(&opts[n++],"-xmax=", OPTTYP_INT , &xmax,"xmax (default:npx-1");
setopts(&opts[n++],"-bin=", OPTTYP_INT , &NBIN,"binning size(default:1)");
setopts(&opts[n++],"-binx=", OPTTYP_INT , &NBINX,"binning size(default:1)");
setopts(&opts[n++],"-biny=", OPTTYP_INT , &NBINY,"binning size(default:1)");
setopts(&opts[n++],"-bzero=", OPTTYP_FLOAT , &bzero,
"bzero");
setopts(&opts[n++],"-bscale=", OPTTYP_FLOAT , &bscale,
"bscale");
setopts(&opts[n++],"-dtype=", OPTTYP_STRING , dtype,
"datatyp(FITSFLOAT,FITSSHORT...)");
setopts(&opts[n++],"-pixignr=", OPTTYP_FLOAT , &rplc_ignor,
"pixignr value");
setopts(&opts[n++],"-ignor=", OPTTYP_FLOAT , &rplc_ignor,
"pixignr value");
setopts(&opts[n++],"",0,NULL,NULL);
helpflag=parsearg(argc,argv,opts,files,NULL);
if(fnamout[0]=='\0')
{
fprintf(stderr,"Error: No input file specified!!\n");
helpflag=1;
}
if(helpflag==1)
{
print_help("Usage: imcio2 <options> [filein] [fileout]",
opts,
"");
exit(-1);
}
switch(mosmode)
{
case DIST_CLIP_ADD:
sprintf(modename,"dist_clip");
imc_mos_set_clip_param(nsigma,sigmaf,clipmin,meanmin);
break;
case CONST_ADD:
if (maxadd<=0) maxadd=1;
sprintf(modename,"const_add %d",maxadd);
break;
case DIST_FLUX:
sprintf(modename,"dist_flux");
break;
case DIST_PEAK:
sprintf(modename,"dist_peak");
break;
case DIST_ADD:
sprintf(modename,"dist_add");
break;
case DIST_MED:
sprintf(modename,"dist_med");
break;
case NODIST_NOADD:
sprintf(modename,"dist_noadd");
break;
default:
mosmode=NODIST_NOADD;
sprintf(modename,"nodist_noadd");
break;
}
imc_mos_set_default_add( mosmode );
if (maxadd>0)
{
imc_mos_set_default_maxadd( maxadd );
printf(" Max # of frames is %d\n", maxadd);
}
if(nline<0)
nline=200;
imc_mos_set_nline(nline);
imc_mos_set_nline_l(nline);
if( fnamin[0]=='\0' )
{
(void) printf("\n input IRAF/FITS/MOS file name = " );
(void) fgets( temp,BUFSIZ,stdin );
sscanf(temp,"%s",fnamin);
}
else
(void)printf("\n Input = %s\n",fnamin );
if( (fp = imropen ( fnamin, &imhin, &icomin )) == NULL )
{
exit(-1);
}
/* testing */
if (imhin.dtype==DTYPEMOS)
{
if (vxref!=FLT_MAX && vyref!=FLT_MAX)
{
printf("vxref:%f vyref:%f\n",vxref,vyref);
imc_mos_set_shift(&imhin, -vxref, -vyref);
}
}
u2off=imget_u2off( &imhin );
(void) printf("Offset = %d\n",u2off);
pixignr=imget_pixignr( &imhin );
(void) printf("Pixignr= %d\n",pixignr);
if(xmin<0) xshift=-xmin;
if(ymin<0) yshift=-ymin;
if( ymax == INT_MAX )
{
/* ymax is not given */
ymax = imhin.npy;
}
else
ymax++;
if( xmax == INT_MAX )
{
/* ymax is not given */
xmax = imhin.npx;
}
else
xmax++;
printf("Output Y range: %d to %d in original frame\n",ymin,(ymax-1));
printf("Output X range: %d to %d in original frame\n",xmin,(xmax-1));
if( ymin > (ymax-1) )
{
printf("Error: Ymin > Ymax\n");
imclose( fp,&imhin,&icomin );
exit(-1);
}
if( xmin > (xmax-1) )
{
printf("Error: Xmin > Xmax\n");
imclose( fp,&imhin,&icomin );
exit(-1);
}
/* 2003/12/23 */
/* check */
if (imhin.dtype==DTYPEMOS)
{
if (0!=imc_mos_check_fill_buffer(&imhin,xmin,xmax,
ymin,ymax,nline))
{
printf("Error: nline is not appropriate\n");
exit(-1);
}
}
/*
* ... Open output
*/
if(fnamout[0]=='\0' )
{
(void) printf(" output IRAF/FITS file name = " );
(void) fgets( temp,BUFSIZ,stdin );
sscanf(temp,"%s",fnamout);
}
else
(void)printf( " Output= %s\n\n", fnamout );
imh_inherit(&imhin,&icomin,&imhout,&icomout,fnamout);
if (NBIN!=1)
{
NBINX=NBIN;
NBINY=NBIN;
}
NBIN=NBINX*NBINY;
imhout.npx = (xmax - xmin)/ NBINX;
imhout.npy = (ymax - ymin)/ NBINY;
imhout.ndatx = imhout.npx;
imhout.ndaty = imhout.npy;
if (imhout.dtype==DTYPFITS)
{
if(dtype[0]!='\0')
{
if (strstr(dtype,"SHORT"))
{
fitsdtype=FITSSHORT;
fitsmax=(float)SHRT_MAX-1.; /* defined in <limits.h> */
}
else if (strstr(dtype,"INT"))
{
fitsdtype=FITSINT;
fitsmax=(float)INT_MAX-1.; /* defined in <limits.h> */
}
else if (strstr(dtype,"CHAR"))
{
fitsdtype=FITSCHAR;
fitsmax=(float)CHAR_MAX-1.; /* defined in <limits.h> */
}
else if (strstr(dtype,"FLOAT"))
{
fitsdtype=FITSFLOAT;
}
else
{
fitsdtype=FITSSHORT;
fitsmax=SHRT_MAX-2.; /* defined in <limits.h> */
}
}
else
{
(void)imc_fits_get_dtype( &imhout, &fitsdtype, NULL, NULL, NULL);
}
(void)imc_fits_set_dtype( &imhout, fitsdtype, bzero, bscale );
}
else
{
if (strstr(dtype,"I2"))
{
imhout.dtype=DTYPI2;
}
else if (strstr(dtype,"INT"))
{
imhout.dtype=DTYPINT;
}
else if (strstr(dtype,"I4"))
{
imhout.dtype=DTYPI4;
}
else if (strstr(dtype,"R4"))
{
imhout.dtype=DTYPR4;
}
else if (strstr(dtype,"R8"))
{
imhout.dtype=DTYPR8;
}
else
{
imhout.dtype=DTYPU2;
}
imset_u2off(&imhout,&icomout,u2off);
}
/* Make comments */
imaddhistf(&icomout,"made by imcio2 from %-48.48s",fnamin);
if(imhout.npx != imhin.npx || imhout.npy != imhin.npy || NBIN>1)
{
imaddhistf(&icomout,
" x[%d:%d] y[%d:%d] %dx%d bining",
xmin,xmax,ymin,ymax,NBINX,NBINY);
}
(void)imc_fits_get_dtype( &imhout, NULL, NULL, NULL, &pixoff);
if(rplc_ignor!=NOT_REPLACE)
{
imset_pixignr(&imhout, &icomout, (int)rplc_ignor);
}
else
{
imset_pixignr(&imhout, &icomout, (int)pixignr);
rplc_ignor=pixignr;
}
/* 2002/05/07 WCS change is added */
imc_shift_WCS(&icomout, (float)xmin, (float)ymin);
if (NBIN>1)
{
/*
imc_scale_WCS(&icomout, 1.0/((float)NBIN));
*/
imc_scale_WCS2(&icomout, 1.0/((float)NBINX),1.0/((float)NBINY));
}
/** 2004/03/03 *.mos */
if (imhin.dtype==DTYPEMOS)
{
imc_mos_get_params(&imhin,&vxoff,&vyoff,
NULL,NULL,NULL,NULL,
NULL,&nfrm,NULL);
imaddhistf(&icomout,"shift by %f %f from original mos",
vxoff,vyoff);
imaddhistf(&icomout,"%d frames are used, %s",
nfrm, modename);
if (addorghead==1)
imc_mos_merge_org_header(&icomout,&imhin);
}
if( (fp2 = imwopen( fnamout, &imhout, &icomout )) == NULL )
{
imclose( fp,&imhin,&icomin );
exit(-1);
}
/*
* ... Copy line to line
*/
dp=(float*)malloc(sizeof(float)*imhin.npx);
if(dp==NULL)
{
printf("Image too large. Cannot allocale memory for dp.\n");
imclose( fp,&imhin,&icomin );
imclose( fp2,&imhout,&icomout );
exit(-1);
}
/* Bin */
if( NBIN > 1 )
{
/* 1999/02/19 changed */
printf("\nBinning by %d x %d ...\n", NBINX, NBINY );
dpybin=(float*)malloc(sizeof(float)*imhin.npx);
dpxbin=(float*)malloc(sizeof(float)*imhout.npx);
ndp=(int*)malloc(sizeof(int)*imhin.npx);
if(dpybin==NULL||dpxbin==NULL||ndp==NULL)
{
printf("Image too large. Cannot allocale memory for ndp.\n");
imclose( fp,&imhin,&icomin );
imclose( fp2,&imhout,&icomout );
exit(-1);
}
for( iy=ymin, iouty=0; iouty<imhout.npy; iouty++ )
{
/* clear y buffer */
memset(ndp,0,imhin.npx*sizeof(int));
memset(dpybin,0,imhin.npx*sizeof(float));
/* bin in y */
for(i=0; i<NBINY && iy<ymax; i++ )
{
/* Read a line */
if(iy>=0)
{
(void) imrl_tor( &imhin, fp, dp, iy );
for( ix=xmin; ix<xmax; ix++)
{
if((ix>=0) && (dp[ix]!=(float)pixignr))
{
dpybin[ix+xshift] += dp[ix];
ndp[ix+xshift]++;
}
}
}
iy++;
}
/* clear x buffer */
memset(dpxbin,0,imhout.npx*sizeof(float));
/* bin in x */
for(ix=xmin, ioutx=0 ; ioutx<imhout.npx; ioutx++ )
{
n0=0;
for(i=0; i<NBINX && ix<xmax; i++)
{
dpxbin[ioutx] += dpybin[ix+xshift];
n0+=ndp[ix+xshift];
ix++;
}
/*
printf("%d %d %f %d\n",ioutx,iouty,dpxbin[ioutx],n0);
*/
if(n0!=0)
{
dpxbin[ioutx]/=(float)n0;
}
else
{
if(rplc_ignor != NOT_REPLACE)
dpxbin[ioutx]=rplc_ignor;
else
dpxbin[ioutx]=(float)pixignr;
}
}
/* output a line */
(void) imwl_rto( &imhout, fp2, dpxbin, iouty );
}
free(dpxbin);
free(dpybin);
free(ndp);
}
else
{
/* No binning */
dpout=(float*)malloc(sizeof(float)*imhout.npx);
if(dpout==NULL)
{
printf("Image too large. Cannot allocale memory for ndp.\n");
imclose( fp,&imhin,&icomin );
imclose( fp2,&imhout,&icomout );
exit(-1);
}
/* Sep 28 temp; -> Feb5 */
{
/**/
for( iy=ymin; iy<ymax; iy++ )
{
if(iy>=0 && iy<imhin.npy)
{
imrl_tor( &imhin, fp, dp, iy );
for( ix=xmin; ix<xmax; ix++ )
{
if(ix<0||ix>=imhin.npx|| dp[ix] == (float)pixignr)
dpout[ix-xmin]=rplc_ignor;
else
dpout[ix-xmin]=dp[ix];
/*
printf("%d %d\n",ix,ix-xmin);
*/
}
}
else
for( ix=xmin; ix<xmax; ix++ )
dpout[ix-xmin]=rplc_ignor;
(void) imwl_rto( &imhout, fp2, dpout, (iy-ymin));
}
}
free(dpout);
}
free(dp);
printf(" Image Size is %d x %d\n\n", imhout.npx, imhout.npy );
if (fp!=NULL) {imclose( fp,&imhin,&icomin );}
if (fp2!=NULL) {imclose( fp2,&imhout,&icomout );}
return 0;
}
int main(int argc,char *argv[])
{
struct imh imhin={""},imhout={""};
struct icom icomin={0},icomout={0};
char fnamin[100]="";
char fnamout[100]="";
char tmp[100]="";
FILE *fp,*fp2;
float dp[XMAX];
float data[OSMAX]; /* temporary */
int ix,iy;
int xmin=-1,xmax=-1,ymin=-1,ymax=-1;
int offst;
float bzero=0,bscale=1.0,bzero_new=FLT_MIN,bscale_new=FLT_MIN;
float blank_new=FLT_MIN;
float pixignr=INT_MIN;
int fitsdtype=-1;
int efpmin1,efprng1,efpmin2,efprng2;
int j=0;
char dtype[BUFSIZ]="";
int fit_param=-1;
float os[4096];
int notrim=0;
getargopt opts[20];
char *files[3]={NULL};
int n=0;
int helpflag;
files[0]=fnamin;
files[1]=fnamout;
setopts(&opts[n++],"-xmin=", OPTTYP_INT , &xmin,
"effective region (default:0)");
setopts(&opts[n++],"-xmax=", OPTTYP_INT , &xmax,
"effective region (default:npx-1)");
setopts(&opts[n++],"-ymin=", OPTTYP_INT , &ymin,
"effective region (default:0)");
setopts(&opts[n++],"-ymax=", OPTTYP_INT , &ymax,
"effective region (default:npy-1)");
setopts(&opts[n++],"-notrim", OPTTYP_FLAG , ¬rim,
"not trim off(default:trim)",1);
/* */
setopts(&opts[n++],"-bzero=", OPTTYP_FLOAT , &bzero_new,
"bzero");
setopts(&opts[n++],"-bscale=", OPTTYP_FLOAT , &bscale_new,
"bscale");
setopts(&opts[n++],"-dtype=", OPTTYP_STRING , dtype,
"datatyp(FITSFLOAT,FITSSHORT...)");
setopts(&opts[n++],"-pixignr=", OPTTYP_FLOAT , &blank_new,
"pixignr value");
/*
setopts(&opts[n++],"-fit", OPTTYP_FLAG , &fit_param,
"fitting (default:no)",1);
*/
setopts(&opts[n++],"",0,NULL,NULL);
helpflag=parsearg(argc,argv,opts,files,NULL);
if(fnamout[0]=='\0')
{
fprintf(stderr,"Error: No input file specified!!\n");
helpflag=1;
}
if(helpflag==1)
{
print_help("Usage: osmed4 <options> [filein] [fileout]",
opts,
"");
exit(-1);
}
/*
* ... Open Input
*/
(void)printf("\n Input = %s\n",fnamin );
if( (fp = imropen ( fnamin, &imhin, &icomin )) == NULL )
{
print_help("Usage: %s <options> [filein] [fileout]",
opts,
"");
exit(-1);
}
imget_fits_value(&icomin,"EFP-MIN1",tmp);
efpmin1=atoi(tmp);
imget_fits_value(&icomin,"EFP-MIN2",tmp);
efpmin2=atoi(tmp);
imget_fits_value(&icomin,"EFP-RNG1",tmp);
efprng1=atoi(tmp);
imget_fits_value(&icomin,"EFP-RNG2",tmp);
efprng2=atoi(tmp);
#if 0 /* included in imc_WCS 2002/05/07 */
/* 2000/09/26 */
imget_fits_value(&icomin,"CRPIX1",tmp);
crpix1=atof(tmp);
imget_fits_value(&icomin,"CRPIX2",tmp);
crpix2=atof(tmp);
#endif
if(xmin<0&&xmax<0&&ymin<0&&ymax<0)
{
xmin=efpmin1-1;
ymin=efpmin2-1;
xmax=xmin+efprng1-1;
ymax=ymin+efprng2-1;
}
/*
printf("xmin %d xmax %d ymin %d ymax %d\n",
xmin,xmax,ymin,ymax);
*/
if (xmin<0) xmin=0;
if (xmax>imhin.npx-1||xmax<xmin) xmax=imhin.npx-1;
if (ymin<0) ymin=0;
if (ymax>imhin.npy-1||ymax<ymin) ymax=imhin.npy-1;
printf("(%d,%d) - (%d,%d)\n",
xmin,ymin,xmax,ymax);
/* output */
imh_inherit(&imhin,&icomin,&imhout,&icomout,fnamout);
if(!notrim)
{
imhout.npx = (xmax - xmin + 1);
imhout.npy = (ymax - ymin + 1);
imhout.ndatx = imhout.npx;
imhout.ndaty = imhout.npy;
}
/* !! need 2000/07/02 or later version of IMC */
if(dtype[0]=='\0')
imc_fits_get_dtype( &imhout, &fitsdtype, &bzero, &bscale, &offst );
else
if ((fitsdtype=imc_fits_dtype_string(dtype))==-1)
{
printf("\nWarning: Unknown fits dtype %s. Inheriting original.\n",dtype);
imc_fits_get_dtype( &imhout, &fitsdtype, &bzero, &bscale, &offst );
}
if(bzero_new!=FLT_MIN)
{
bzero=bzero_new;
}
if(bscale_new!=FLT_MIN)
{
bscale=bscale_new;
}
(void)imc_fits_set_dtype( &imhout, fitsdtype, bzero, bscale );
if(blank_new!=FLT_MIN)
imset_pixignr(&imhout,&icomout,(int)blank_new);
else
{
pixignr=(float)imget_pixignr(&imhin);
imset_pixignr(&imhout,&icomout,(int)pixignr);
}
if (fit_param>0)
{
imaddhist(&icomout,"OSMED4: Overscan value is smoothed");
}
else
{
imaddhist(&icomout,"OSMED4: Overscan median is subtracted line by line.");
}
if (!notrim)
{
imaddhistf(&icomout,"OSMED4: And extracted [%d:%d,%d:%d] (0-origin)",
xmin,xmax,ymin,ymax);
}
(void)printf("\n Output = %s\n",fnamout );
/* 2000/09/26 EFP-MIN revise */
/* 2001/09/17 debug */
if(efpmin1-xmin<1)
{
efprng1-=(xmin+1-efpmin1);
efpmin1=xmin+1;
}
if(efpmin1-1+efprng1-1>=xmax)
{
efprng1=xmax-(efpmin1-1)+1;
}
if(efpmin2-ymin<1)
{
efprng2-=(ymin+1-efpmin2);
efpmin2=ymin+1;
}
if(efpmin2-2+efprng2-1>=ymax)
{
efprng2=ymax-(efpmin2-1)+1;
}
if(!notrim)
{
imupdate_fitsf(&icomout, "EFP-MIN1",IMC_FITS_INTFORM,
efpmin1-xmin,
"Start position of effective frame in axis-1");
imupdate_fitsf(&icomout, "EFP-MIN2",IMC_FITS_INTFORM,
efpmin2-ymin,
"Start position of effective frame in axis-2");
imupdate_fitsf(&icomout, "EFP-RNG1",IMC_FITS_INTFORM,
xmax-xmin+1,
"Range of effective frame in axis-1");
imupdate_fitsf(&icomout, "EFP-RNG2",IMC_FITS_INTFORM,
ymax-ymin+1,
"Range of effective frame in axis-2");
#if 0
/* 2000/09/26 CRPIX revise */
imupdate_fitsf(&icomout, "CRPIX1",
"%20.1f / %-47.47s",
crpix1-(float)xmin,
"Reference pixel coordinate system in axis1");
imupdate_fitsf(&icomout, "CRPIX2",
"%20.1f / %-47.47s",
crpix2-(float)ymin,
"Reference pixel coordinate system in axis2");
#else
imc_shift_WCS(&icomout,(float)xmin,(float)ymin);
#endif
}
for( iy=0; iy<imhin.npy; iy++ )
{
j=0;
(void) imrl_tor( &imhin, fp, dp, iy );
for( ix=0; ix<xmin; ix++ )
{
data[j++]=dp[ix];
}
for(ix=xmax+1;ix<imhin.npx;ix++)
{
data[j++]=dp[ix];
}
os[iy]=floatmedian(j,data);
}
/* fit, if needed, not implemented */
/**** OPEN output ****/
if( (fp2 = imwopen( fnamout, &imhout, &icomout )) == NULL )
{
(void) imclose(fp,&imhin,&icomin);
print_help("Usage: %s <options> [filein] [fileout]",
opts,
"");
exit(-1);
}
if (notrim)
{
xmin=0;
xmax=imhin.npx-1;
}
for( iy=0; iy<imhin.npy; iy++ )
{
j=0;
(void) imrl_tor( &imhin, fp, dp, iy );
for(ix=xmin;ix<=xmax;ix++)
dp[ix]-=os[iy];
(void) imwl_rto( &imhout, fp2, dp+xmin, iy);
}
(void) imclose(fp,&imhin,&icomin);
(void) imclose(fp2,&imhout,&icomout);
return 0;
}
int main(int argc,char **argv)
{
char fnamin[BUFSIZ]="";
char fnamout[BUFSIZ]="";
struct icom icomin={0};
struct imh imhin={""};
float fact,fsigm;
float gmax,gmean,gmin,gsd;
int npx,npy;
int nmesh_x,nmesh_y;
int meshsiz_x=0,meshsiz_y=0,meshsiz_xy=0;
int ncycle;
float pixignr;
float *g;
float *rmesh;
float *sgmesh;
float bscale=1.;
FILE *fpin;
float msky,msigm;
int dtypein;
int binflag;
/***** parse options ******/
getargopt opts[20];
char *files[3]={NULL};
int n=0;
files[0]=fnamin;
files[1]=fnamout;
n=0;
setopts(&opts[n++],"-mesh=", OPTTYP_INT , &meshsiz_xy,
"mesh size (default: image size)");
setopts(&opts[n++],"-meshx=", OPTTYP_INT , &meshsiz_x,
"mesh x-size (default: image size)");
setopts(&opts[n++],"-meshy=", OPTTYP_INT , &meshsiz_y,
"mesh y-size (default: image size)");
/* not impl. yet */
/*
setopts(&opts[n++],"-xmin=", OPTTYP_INT , &xmin,
"");
setopts(&opts[n++],"-xmax=", OPTTYP_INT , &xmax,
"");
setopts(&opts[n++],"-ymin=", OPTTYP_INT , &ymin,
"");
setopts(&opts[n++],"-ymax=", OPTTYP_INT , &ymax,
"");
*/
setopts(&opts[n++],"",0,NULL,NULL);
if(parsearg(argc,argv,opts,files,NULL)||fnamin[0]=='\0')
{
print_help("Usage: skydet [options] filein [fileout]",
opts,"");
exit(-1);
}
/********* main loop *************/
/*
*** DATA INPUT ***
*/
/**** read image ****/
if ((fpin= imropen(fnamin,&imhin,&icomin))==NULL)
{
fprintf(stderr,"File %s not found !!\n",fnamin);
exit(-1);
}
pixignr=imget_pixignr( &imhin );
if(imhin.dtype==DTYPFITS)
{
imc_fits_get_dtype( &imhin, &dtypein, NULL, &bscale, NULL );
if(dtypein==FITSFLOAT || bscale!=1.0)
binflag=0;
else
binflag=1;
}
else
{
if(imhin.dtype==DTYPR4 || imhin.dtype==DTYPR8)
binflag=0;
else
binflag=1;
}
npx=imhin.npx;
npy=imhin.npy;
if(meshsiz_xy!=0)
{
meshsiz_x=meshsiz_xy;
meshsiz_y=meshsiz_xy;
}
if(meshsiz_x<1) meshsiz_x=npx;
if(meshsiz_y<1) meshsiz_y=npy;
g=(float*)malloc(sizeof(float)*npx*npy);
if (g==NULL)
{
printf("Error cannot allocate image buffer");
exit(-1);
}
if(!imrall_tor(&imhin,fpin,g,npx*npy))
{
fprintf(stderr,"Error. cannot read data.\n");
exit(-1);
}
imclose(fpin,&imhin,&icomin);
/*
*** SATAISTICS
*/
fact=2.0;
ncycle=2;
statsk(g,npx,npy,fact,ncycle,&gmax,&gmin,&gmean,&gsd,pixignr);
printf("\n => GMAX GMIN GMEAN GSD= %f %f %f %f \n",gmax,gmin,gmean,gsd);
/*
*** SKY DETERMINATION AND SUBTRACTION ***
*/
nmesh_x=(int)(((float)npx*2.)/meshsiz_x)-1;
if(nmesh_x<1) nmesh_x=1;
nmesh_y=(int)(((float)npy*2.)/meshsiz_y)-1;
if(nmesh_y<1) nmesh_y=1;
rmesh=(float*)malloc(sizeof(float)*nmesh_x*nmesh_y);
sgmesh=(float*)malloc(sizeof(float)*nmesh_x*nmesh_y);
/* 97/09/12 Yagi */
fsigm=70.0; /* default */
skydet2b(g,npx,npy,rmesh,
nmesh_x,nmesh_y,
meshsiz_x,meshsiz_y,
gmean,gsd,fsigm,sgmesh,binflag,
pixignr);
if(nmesh_x*nmesh_y>2)
{
msigm=skysigmadet(sgmesh,nmesh_x,nmesh_y);
msky=medfilter_skysb(rmesh,nmesh_x,nmesh_y,1);
}
else if (nmesh_x*nmesh_y==2)
{
msky=0.5*(rmesh[0]+rmesh[1]);
msigm=0.5*(sgmesh[0]+sgmesh[1]);
}
else if(nmesh_x*nmesh_y==1)
{
msky=rmesh[0];
msigm=sgmesh[0];
}
else
{
msky=0;/* Error */
msigm=-1.0; /* Error */
}
printf("%g ",msky);
printf("%g\n",msigm);
if(fnamout[0]!='\0')
{
skypattern(g,npx,npy,rmesh,nmesh_x,nmesh_y,meshsiz_x,meshsiz_y);
makePostage(fnamout,g,npx,npy);
}
return 0;
}
/* --------------------------------------------------------------- */
FILE *imwopen_fits (
/* ---------------------------------------------------------------
*
* Description: <IM>age <W>rite <OPEN>
* ============
*
* imwopen_fits() writes the header portion of a fits
* file. It does not fill pixel data but returns a FILE
* pointer where the pixel data should start.
*
* Note:
* 0) The File name SHOULD BE xxx.fits
* 1) pix file is NOT closed by imwopen. Someone should close it.
* 2) FILE pointer IS MOVED to the start of pixel data by imwopen.
*
* Condition prior to call:
* ========================
*
* There are many paremeters in imh header to be filled.
* imwopen_fits() fills most of them for you. You have to
* fill the following parameters prior to call imwopen:
*
* imhp->dtype iraf data type
* imhp->npx x image size
* imhp->npy y image size
*
* If you like to add more comments, please do so using
* imaddcom.
*
* Arguments:
* ==========
*/
char *fnam, /* (in) file name WITH .fits */
struct imh *imhp, /* (in) ptr to imh header structure */
struct icom *comp) /* (in) ptr to comment struct */
/*
* Return value:
* =============
* File pointer address where pixel data starts.
* Will be NULL pointer if faile to open files.
*
* Caution:
* ========
* (1) imwopwn DOES OVERWRITE the existing files with the
* same name. Users should check the existing files
* if needed.
*
* ---------------------------------------------------------------
*/
{
char /**cp,*/ zero=' ';
char **fh;
char temp[NCHAFITS+1];
int i, nlin;
int dtype;
int odd, nzero;
int pixoff;
#ifdef HAVE_FSEEKO
off_t nblk;
off_t filloff;
off_t size;
off_t total_size;
#else
int nblk;
int filloff;
int size;
int total_size;
#endif
float bzero;
float bscale;
FILE *fp;
int mfitsh=MFITSH;
/* Yagi added */
/*
char key[10],val[80],com[80];
float fval;
int ival;
*/
/* 2003/11/04 */
imhp->buff=NULL;
fh=(char**)malloc(sizeof(char*)*mfitsh);
if(fh==NULL)
{
fprintf(stderr,"Cannot allocate memory for fh in imwopen_fits\n");
/* 2000/09/19 */
/* mfitsh should be set smaller and retry*/
/* but not implemented yet...*/
exit(-1);
}
for(i=0;i<mfitsh;i++)
{
fh[i]=(char*)malloc(sizeof(char)*(NCHAFITS+1));
if(fh[i]==NULL)
{
fprintf(stderr,"Cannot allocate memory for fh[%d] in imwopen_fits\n",i);
exit(-1);
}
/* fill space */
memset((&fh[i][0]),' ',(NCHAFITS+1));
}
/*
* ... check input paramters
*/
/* ... check FITS date type ... */
if( imhp->dtype != DTYPFITS ) {
(void) printf("Imwopen_fits: wrong imh.dtype\n");
return NULL;
}
#ifndef FORCEFITS
/* ... check file name ... */
if( strstr( fnam, FITSEXTEN ) == NULL ) {
(void) printf("Imwopen_fits: file name should be xx.fits\n");
return NULL;
}
#endif
/* ... check npx & npy ... */
if( imhp->npx < 0 || imhp->npy < 0 ) {
(void) printf("Imwopen_fits: npx or npy < 0\n");
return NULL;
}
if( imhp->npx == 0 && imhp->npy == 0 ) {
(void) printf("Imwopen_fits: npx = npy =0\n");
return NULL;
}
/* ... Check dtype ... */
(void)imc_fits_get_dtype(imhp,&dtype,&bzero,&bscale,&pixoff);
/* printf("debug: 2006-08-02 %f %f\n",bzero,bscale); */
if( dtype != FITSCHAR &&
dtype != FITSSHORT &&
dtype != FITSINT &&
dtype != FITSFLOAT ) {
(void) printf("Imwopen_fits: Unkown BITPIX %d\n",dtype);
(void) printf("Make sure to use pointer of imhd for imc_fits_set_dtype()\n");
return NULL;
}
/* ... Determine Naxis ... */
imhp->naxis = 0;
if( imhp->npx > 0 ) imhp->naxis++ ;
if( imhp->npy > 0 ) imhp->naxis++ ;
/*
* ... make FITS header
*/
nlin = 0;
(void)imc_fits_mklog (fh[nlin++],"SIMPLE",(int)1,"FITS STANDARD");
(void)imc_fits_mkint (fh[nlin++],"BITPIX",dtype,"FITS BITS/PIXEL");
(void)imc_fits_mkint (fh[nlin++],"NAXIS",(int)imhp->naxis,"NUMBER OF AXES");
(void)imc_fits_mkint (fh[nlin++],"NAXIS1",(int)imhp->npx,"NUMBER OF PIX IN 1ST AXIS");
(void)imc_fits_mkint (fh[nlin++],"NAXIS2",(int)imhp->npy,"NUMBER OF PIX IN 2ND AXIS");
/* 2006/08/02 */
/* here we should add EXTEND keyword */
(void)imc_fits_mklog (fh[nlin++],"EXTEND",(int)0,"FITS dataset may contain extensions");
/* write only NON-EXTEND FITS */
if(dtype!=FITSFLOAT || bscale!=1.0 || bzero!=0.0)
{
(void)imc_fits_mkfloat(fh[nlin++],"BSCALE",bscale,
"REAL = FILE*BSCALE + BZERO");
(void)imc_fits_mkfloat(fh[nlin++],"BZERO",bzero,
"REAL = FILE*BSCALE + BZERO");
}
/* 2002/07/31 */
/*
(void)imdecs( imhp->title, strg );
(void)imc_fits_mkstrg (fh[nlin++],"OBJECT",strg,"Name of object");
(void)imdecs( imhp->institute, strg );
(void)imc_fits_mkstrg (fh[nlin++],"ORIGIN",strg,"Origin");
*/
/* add iraf comments */
for(i=0; i<comp->ncom; i++) {
/* format check needed here (98/06/24)*/
/*
(void) imdecs( comp->com[i], strg);
(void) sprintf( fh[nlin++], "%-80.80s", strg);
*/
(void) sprintf( fh[nlin++], "%-80.80s", comp->com[i]);
}
/* ternimate line */
memset(temp,' ',NCHAFITS);
(void) sprintf( fh[nlin++], "END%77.77s", temp);
/*
* ... Open & write to file
*/
if( (fp=fopen(fnam,"w")) == NULL ) {
(void) printf("Imwopen_fits: can not open %s\n",fnam);
return NULL;
}
for( i=0; i<nlin; i++ )
{
if( fwrite(fh[i],(int)NCHAFITS,(size_t)1,fp) != 1 )
{
(void) printf("Imwopen_fits: error writing header\n");
return NULL;
}
}
/*
* ... Locate pixel data
*/
odd = (nlin * NCHAFITS) % NBYTEBLK;
nblk= (nlin * NCHAFITS) / NBYTEBLK;
if (odd == 0) pixoff = nblk * NBYTEBLK;
else pixoff = (nblk+1) * NBYTEBLK;
nzero= pixoff - nlin * NCHAFITS;
/*
fprintf(stderr,"%d %d %d\n",pixoff,nblk,nlin);
*/
/* write empty data to fill block */
for( i=0; i<nzero; i++ ) {
if( fwrite(&zero,(size_t)1,(size_t)1,fp) != 1 ) {
(void) printf("Imwopen_fits: error filling block\n");
return NULL;
}
}
/*
* ... Fill Dummy Pix Data
*/
/* pix data byte size */
#ifdef HAVE_FSEEKO
size = (off_t)(abs(dtype)/8) * (off_t)(imhp->npx) * (off_t)(imhp->npy);
odd = size % (off_t)NBYTEBLK;
nblk = size / (off_t)NBYTEBLK;
/* debug */
/*
printf("debug: sizeof(off_t)=%d\n",sizeof(off_t));
printf("debug: size=%f\n",(double)size);
printf("debug: odd=%f\n",(double)odd);
printf("debug: nblk=%f\n",(double)nblk);
*/
#else
size = abs(dtype)/8 * imhp->npx * imhp->npy;
odd = size % NBYTEBLK;
nblk = size / NBYTEBLK;
#endif
/* 2007/05/01 revised */
#ifdef HAVE_FSEEKO
total_size = (off_t)(nblk+1) * (off_t)NBYTEBLK;
#else
total_size = (nblk+1) * NBYTEBLK;
#endif
zero='\0';
if( odd != 0 )
{
#ifdef HAVE_FSEEKO
filloff = (off_t)pixoff + size;
if( fseeko(fp,filloff,SEEK_SET) != 0 )
#else
filloff = pixoff + size;
if( fseek(fp,filloff,SEEK_SET) != 0 )
#endif
{
(void) printf("Imwopen_fits: Error in fseek to dummy data\n");
return NULL;
}
/* wirte zeros */
nzero = total_size - size;
for( i=0; i<nzero; i++ ) {
if( fwrite(&zero,(int)1,(size_t)1,fp) != 1 ) {
(void) printf("Imwopen_fits: error filling dummy data\n");
return NULL;
}
}
} /* end if */
else
{
/* put last data */
#ifdef HAVE_FSEEKO
filloff = (off_t)pixoff+size-1;
if( fseeko(fp,filloff,SEEK_SET) != 0 )
#else
filloff = pixoff+size-1;
if( fseek(fp,filloff,SEEK_SET) != 0 )
#endif
{
(void) printf("Imwopen_fits: Error in fseek to dummy data\n");
return NULL;
}
if( fwrite(&zero,(int)1,(size_t)1,fp) != 1 ) {
(void) printf("Imwopen_fits: error filling dummy data\n");
return NULL;
}
}
/* relocate to first real data */
if( fseek(fp,pixoff,SEEK_SET) != 0 ) {
(void) printf("Imwopen_fits: Error in fseek to 1st data\n");
for(i=0;i<mfitsh;i++)
free(fh[i]);
free(fh);
return NULL;
}
/*
* ... Fill some parametes
*/
for(i=0;i<4;i++)
imhp->void_2[VID2SIZ-PXOFF-i]=fitsbuff_i1(&pixoff)[i];
/* free fh */
for(i=0;i<mfitsh;i++)
free(fh[i]);
free(fh);
return( fp );
}
/* ------------------------------------------------------------------------ */
int imc_fits_wl(
/* --------------------------------------------------------------------------
*
* Description: <IMC> <FITS> <W>rite <L>ine
* ============
* imc_fits_wl() writes real*4 data in a line to a pixel file.
* It can write the following data types:
*
* signed char ( integer*1 )
* signed short ( integer*2 )
* signed int ( integer*4 )
* float ( real*4 )
*
* When writing data to u2 or i4, the trancation is
* performed since C does not do this automatically:
*
* if( data > i4_max ) data = i4_max
* if( data < i4_min ) data = i4_min, or
*
* if( data > u2_max ) data = u2_max
* if( data < 0 ) data = 0
*
* These requires addtional CPU time.
*
* Arguments:
* ==========
*/
struct imh *imhp, /* (in) ptr to imh struct */
FILE *fp, /* (in) ptr to pixel file */
float *dp, /* (in) ptr to pixel data array */
int iy) /* (in) line # starting with 0 */
/*
* Note:
* =====
* imc_fits_wl() loads pixel data in an internal array
* whose size is 64K in u_short. The xdim should not exceed
* this size.
*
* Caution:
* ========
* imwl_fits_wl() writes data into a pixel file according to:
*
* imhp->npx, imhp->npy,
* imhp->ndatx, imhp->ndaty.
*
* Since the FITS header is already written when you call
* imwopen_fits(), no one can change or adjust ndatx or ndaty.
* Please be carfull not to change ndatx or ndaty after
* calling imwopen_fits().
*
* Revision history:
* =================
* Apr 25, 93: (Maki Sekiguchi) Original creation
*
* -----------------------------------------------------------------
*/
{
size_t size; /* data size (in byte) to read */
#ifdef HAVE_FSEEKO
off_t pntr_offset;
#else
int pntr_offset;
#endif
int pixignr;
int dtype;
int pixoff;
int ix;
int nbyte;
float *rp;
float bzero;
float bscale;
float bzero_up;
/*
* ... Check Input Parameters
*/
/* ... check FITS date type ... */
if( imhp->dtype != DTYPFITS ) {
(void) printf("Imc_fits_wl: wrong imh.dtype\n");
return( (int)0 );
}
if( imhp->npx == 0 ) {
(void) printf("Imc_fits_wl:npx =0\n");
return( (int)0 );
}
/* ... Check dtype ... */
(void)imc_fits_get_dtype(imhp,&dtype,&bzero,&bscale,&pixoff);
if( dtype != FITSCHAR &&
dtype != FITSSHORT &&
dtype != FITSINT &&
dtype != FITSFLOAT ) {
(void) printf("Imc_fits_wl: Unknown BITPIX %d",dtype);
return( (int)0 );
}
if( bscale == 0.0 ) {
(void) printf("Imc_fits_wl: Bscale=0\n");
return( (int)0 );
}
/*... check work area size */
nbyte= abs(dtype/8);
size = imhp->npx * nbyte;
bzero_up = bzero - 0.5;
/*
if( size > WRKSIZ ) {
(void) printf("Imc_fits_wl: Internal buffer too small\n");
return( (int)0 );
}
*/
imhp->buff=realloc(imhp->buff,size);
/*
* ... Locate pixel pntr
*/
/* offset is in byte */
#ifdef HAVE_FSEEKO
pntr_offset = (off_t)pixoff + (off_t)iy * (off_t)nbyte * (off_t)(imhp->npx);
if( fseeko(fp,pntr_offset,SEEK_SET) != 0 )
#else
pntr_offset = pixoff + iy * nbyte * imhp->npx;
if( fseek(fp,pntr_offset,SEEK_SET) != 0 )
#endif
{
(void) printf("Imc_fits_rl: Error in fseeking\n");
return( (int)0 );
}
/*
* ... Write Data Out
*/
pixignr=imget_pixignr(imhp);
switch ( dtype ) {
/* ============*/
case FITSCHAR:
/* ============*/
if( bscale == 1.0 ) {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
fitsbuff_i1(imhp->buff)[ix] = (char)floor( *rp-bzero_up );
}
else {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
fitsbuff_i1(imhp->buff)[ix] = (char)floor( (*rp-bzero)/bscale+0.5);
}
if( fwrite((imhp->buff),size,(size_t)1,fp) != 1 ) goto err;
break;
/* ============*/
case FITSSHORT:
/* ============*/
if( bscale == 1.0 ) {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
fitsbuff_i2(imhp->buff)[ix] = (short)floor( (*rp-bzero_up) );
}
else {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
fitsbuff_i2(imhp->buff)[ix] = (short)floor( (*rp-bzero)/bscale+0.5 );
}
if(BSWAP) (void)imc_fits_swap16((imhp->buff),(int)(size/SHORT_SIZE));
if( fwrite((imhp->buff),size,(size_t)1,fp) != 1 ) goto err;
break;
/* ============*/
case FITSINT:
/* ============*/
if( bscale == 1.0 ) {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
fitsbuff_i4(imhp->buff)[ix] = (int)floor(*rp-bzero_up);
}
else {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
fitsbuff_i4(imhp->buff)[ix] = (int)floor( (*rp-bzero)/bscale+0.5);
}
if(BSWAP) (void)imc_fits_swap32((imhp->buff),(int)(size/INT_SIZE));
if( fwrite((imhp->buff),size,(size_t)1,fp) != 1 ) goto err;
break;
/* ============*/
case FITSFLOAT:
/* ============*/
if( bscale == 1.0 ) {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
fitsbuff_r4(imhp->buff)[ix] = (float)(*rp - bzero);
}
else {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
{
fitsbuff_r4(imhp->buff)[ix] = (float) ((*rp - bzero) / bscale);
}
}
if(BSWAP)
(void)imc_fits_swap32((imhp->buff),(int)(size/FLOAT_SIZE));
if( fwrite((imhp->buff),size,(size_t)1,fp) != 1 ) goto err;
break;
/* ======*/
default:
/* ======*/
(void) printf("Imc_fits_wl: Unsupported data type = %d\n", dtype);
return 0;
/* break; */
} /* end switch */
return 1;
err:
(void) printf("Imc_fits_wl: Error writing pixel data\n");
return( (int)0 );
}
/* ------------------------------------------------------------------------ */
int imc_fits_rl(
/* --------------------------------------------------------------------------
*
* Description: <IMC> <FITS> <R>ead <L>ine
* ============
* imc_fits_rl reads line data from a FITS file into a given
* real*4 arrray. It can read the following data types:
*
* signed short ( integer*2 )
* signed int ( integer*4 )
* float ( real*4 )
*
* Arguments:
* ==========
*/
struct imh *imhp, /* (in) ptr to imh struct */
FILE *fp, /* (in) ptr to pixel file */
float *dp, /* (out) ptr to pixel array to be filled */
int iy) /* (in) Line # start with 0 */
/*
* Note:
* =====
* Some internal check is (like pix size consistence)
* eliminated for speed.
*
* Revision history:
* =================
*
* --------------------------------------------------------------------------
*/
{
size_t size;
int dtype;
int pixoff;
int nbyte;
int ix;
#ifdef HAVE_FSEEKO
off_t offset;
#else
int offset;
#endif
float *rp;
float bzero;
float bscale;
int pixignr;
/*
* ... Check Input Parameters
*/
/* ... check if this is a fits type ... */
if( imhp->dtype != DTYPFITS ) {
(void)printf("Imc_fits_rl: This is not FITS type\n");
return 0;
}
if( imhp->npx == 0 ) {
(void) printf("Imc_fits_rl: npx=0\n");
return 0;
}
(void)imc_fits_get_dtype( imhp, &dtype, &bzero, &bscale, &pixoff );
nbyte= abs(dtype/8);
size = imhp->npx * nbyte;
/*
if( size > WRKSIZ ) {
(void) printf("Imc_fits_rl: Internal buffer too small\n");
return 0;
}
*/
/* 2003/11/04 */
imhp->buff=realloc(imhp->buff,size);
/* ... Reposition file pointer ... */
/* offset is in byte */
#ifdef HAVE_FSEEKO
offset = (off_t)pixoff + (off_t)iy * (off_t)nbyte * (off_t)(imhp->ndatx);
if( fseeko(fp,offset,SEEK_SET) != 0 )
#else
offset = pixoff + iy * nbyte * imhp->ndatx;
if( fseek(fp,offset,SEEK_SET) != 0 )
#endif
{
(void) printf("Imc_fits_rl: Error in fseeking\n");
printf("pixoffset=%d offset=%ld\n",pixoff,(long)offset);
return 0;
}
/*
* ... Read Data In
*/
pixignr=imget_pixignr(imhp);
switch ( dtype ) {
/* ============ */
case FITSCHAR:
/* ============ */
if( fread((imhp->buff),size,(size_t)1,fp) != 1 ) goto err;
if( bscale == 1.0 ) {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
*rp = bzero + (float)fitsbuff_i1(imhp->buff)[ix];
}
else {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
*rp = bzero + bscale * (float)fitsbuff_i1(imhp->buff)[ix];
}
break;
/* ============ */
case FITSSHORT:
/* ============ */
if( fread((imhp->buff),size,(size_t)1,fp) != 1 ) goto err;
if(BSWAP) (void)imc_fits_swap16((imhp->buff),(int)(size/SHORT_SIZE));
if( bscale == 1.0 ) {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
*rp = bzero + (float)fitsbuff_i2(imhp->buff)[ix];
}
else {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
*rp = bzero + bscale * (float)fitsbuff_i2(imhp->buff)[ix];
}
break;
/* ============ */
case FITSINT:
/* ============ */
if( fread((imhp->buff),size,(size_t)1,fp) != 1 ) goto err;
if(BSWAP) (void)imc_fits_swap32((imhp->buff),(int)(size/INT_SIZE));
if( bscale == 1.0 ) {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
*rp = bzero + (float)fitsbuff_i4(imhp->buff)[ix];
}
else {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
*rp = bzero + bscale * (float)fitsbuff_i4(imhp->buff)[ix];
}
break;
/* ============ */
case FITSFLOAT:
/* ============ */
if( fread((imhp->buff),size,(size_t)1,fp) != 1 ) goto err;
if(BSWAP) (void)imc_fits_swap32((imhp->buff),(int)(size/FLOAT_SIZE));
if( bscale == 1.0 ) {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
*rp = bzero + (float)fitsbuff_r4(imhp->buff)[ix];
}
else {
for(ix=0,rp=dp;ix<imhp->npx;ix++,rp++)
*rp = bzero + bscale * (float)fitsbuff_r4(imhp->buff)[ix];
}
break;
/* ====== */
default:
/* ====== */
(void) printf("Imc_fits_rl: Unsupported data type = %d\n", dtype);
return 0;
/* break; */
} /* end switch */
return 1;
err:
(void) printf("Imc_fits_rl: Error reading pixel data\n");
return 0;
}
int main(int argc,char **argv)
{
float fact,fsigm;
float gmax,gmean,gmin,gsd;
int npx,npy,meshsiz_x,meshsiz_y;
int nmesh_x=0,nmesh_y=0,mesh=0;
int ncycle;
char fnamin[BUFSIZ]="";
char fnamout[BUFSIZ]="";
struct icom icomin={0},icomout={0},icomref={0};
struct imh imhin={""},imhout={""},imhref={""};
int i,j;
float *g,*g2;
float *rmesh;
float *sgmesh;
char fnamref[BUFSIZ]="";
char buffer[BUFSIZ];
char skymap[BUFSIZ]="";
float bzero=0.,bscale=1.;
float bzero_new=FLT_MIN,bscale_new=FLT_MIN;
int bzeroset=0;
int fitsdtype;
FILE *fpin,*fpout,*fpref;
FILE *fmap;
int mode;
char dtype[80]="";
float msky,msigm;
int dtypein;
int binflag;
float ignor=(float)INT_MIN;
float imax=(float)INT_MIN;
float imin=(float)INT_MAX;
int pixignr;
getargopt opts[20];
char *files[3]={NULL};
int n=0;
int helpflag;
/***************************************/
files[0]=fnamin;
files[1]=fnamout;
setopts(&opts[n++],"-mesh=", OPTTYP_INT , &mesh,
"mesh size (default:full image)");
setopts(&opts[n++],"-meshx=", OPTTYP_INT , &nmesh_x,
"mesh x-size (default:not used)");
setopts(&opts[n++],"-meshy=", OPTTYP_INT , &nmesh_y,
"mesh y-size (default:not used)");
setopts(&opts[n++],"-skyref=", OPTTYP_STRING , &fnamref,
"sky determination reference (default:use input image)");
setopts(&opts[n++],"-imax=", OPTTYP_FLOAT , &imax,
"flux upper limit to estimate sky(default:unlimited)");
setopts(&opts[n++],"-imin=", OPTTYP_FLOAT , &imin,
"flux lower limit to estimate sky(default:unlimited)");
/* */
setopts(&opts[n++],"-bzero=", OPTTYP_FLOAT , &bzero_new,
"bzero");
setopts(&opts[n++],"-bscale=", OPTTYP_FLOAT , &bscale_new,
"bscale");
setopts(&opts[n++],"-dtype=", OPTTYP_STRING , dtype,
"datatyp(FITSFLOAT,FITSSHORT...)");
setopts(&opts[n++],"-pixignr=", OPTTYP_FLOAT , &ignor,
"pixignr value");
/* To be implemented in next major version */
/*
setopts(&opts[n++],"-fit", OPTTYP_FLAG , &fit_param,
"fitting (default:no)",1);
*/
setopts(&opts[n++],"",0,NULL,NULL);
helpflag=parsearg(argc,argv,opts,files,NULL);
if(fnamout[0]=='\0')
{
fprintf(stderr,"Error: No input file specified!!\n");
helpflag=1;
}
if(helpflag==1)
{
print_help("Usage: skysb3b <options> [filein] [fileout]",
opts,
"");
exit(-1);
}
if(nmesh_x==0) nmesh_x=mesh;
if(nmesh_y==0) nmesh_y=mesh;
if(bzero_new!=FLT_MIN)
{
bzero=bzero_new;
bzeroset=1;
}
if(bscale_new!=FLT_MIN)
{
bscale=bscale_new;
bzeroset=1;
}
/*
printf("debug:nmesh_x=%d nmesh_y=%d\n",nmesh_x,nmesh_y);
*/
mode=1; /* default */
fsigm=70.0; /* default */
/*
*** DATA INPUT ***
*/
/**** read image ****/
fprintf(stderr,"%s\n",fnamin);
if ((fpin= imropen(fnamin,&imhin,&icomin))==NULL)
{
printf("File %s not found !!\n",fnamin);
exit(-1);
}
pixignr=(int)imget_pixignr( &imhin );
printf("pixignr_in=%f\n",(float)pixignr);
if(imhin.dtype==DTYPFITS)
{
imc_fits_get_dtype( &imhin, &dtypein, NULL, NULL, NULL);
if(dtypein==FITSFLOAT)
binflag=0;
else
binflag=1;
}
else
{
if(imhin.dtype==DTYPR4 || imhin.dtype==DTYPR8)
binflag=0;
else
binflag=1;
}
npx=imhin.npx;
npy=imhin.npy;
if(nmesh_x<1) nmesh_x=npx;
if(nmesh_y<1) nmesh_y=npy;
g=(float*)malloc(sizeof(float)*npx*npy);
g2=(float*)malloc(sizeof(float)*npx*npy);
if (g==NULL||g2==NULL) { printf("Error cannot allocate image buffer"); exit(-1);}
if(imrall_tor(&imhin,fpin,g2,npx*npy))
printf("npx, npy =%d %d \n",npx,npy);
else {
printf("Error. cannot read data.\n");
exit(-1);
}
/* 2002/05/21 */
if(fnamref[0]=='\0')
{
memcpy(g,g2,sizeof(float)*npx*npy);
}
else
{
if ((fpref=imropen(fnamref,&imhref,&icomref))==NULL)
{
printf("Reference File %s not found !!\n",fnamref);
exit(-1);
}
if (npx!=imhref.npx||npy!=imhref.npy)
{
printf("Error: Ref. size (%dx%d) differ from input (%dx%d)\n",
imhref.npx,imhref.npy,npx,npy);
exit(-1);
}
if(! imrall_tor(&imhref,fpref,g,npx*npy))
{
printf("Error: cannot read ref data.\n");
exit(-1);
}
imclose(fpref,&imhref,&icomref);
}
/* 2001/07/19 preformat (masking) */
if(imax>(float)INT_MIN||imin<(float)INT_MAX)
for(i=0;i<npx*npy;i++)
if(g[i]>imax||g[i]<imin) g[i]=pixignr;
/*
*** SATAISTICS
*/
printf("Calculating statistics \n");
/* TODO */
/* to be tunable ?*/
fact=2.0;
ncycle=2;
statsk(g,npx,npy,fact,ncycle,&gmax,&gmin,&gmean,&gsd,pixignr);
printf("\n");
printf(" => GMAX GMIN GMEAN GSD= %f %f %f %f \n",gmax,gmin,gmean,gsd);
/*
*** SKY DETERMINATION AND SUBTRACTION ***
*/
printf("Sky subtraction under way\n");
meshsiz_x=(int)((npx*2.)/nmesh_x)-1; /* meshsiz_x > 0 */
if(meshsiz_x<1) meshsiz_x=1;
meshsiz_y=(int)((npy*2.)/nmesh_y)-1; /* meshsiz_y > 0 */
if(meshsiz_y<1) meshsiz_y=1;
rmesh=(float*)malloc(sizeof(float)*meshsiz_x*meshsiz_y);
sgmesh=(float*)malloc(sizeof(float)*meshsiz_x*meshsiz_y);
/* 97/09/12 Yagi */
skydet2b(g,npx,npy,rmesh,meshsiz_x,meshsiz_y,
nmesh_x,nmesh_y,gmean,gsd,fsigm,sgmesh,binflag,pixignr);
if(meshsiz_x*meshsiz_y>2)
{
/* 3X3 median filter */
/*
msky=skysigmadet(rmesh,meshsiz_x,meshsiz_y);
*/
msky=medfilter_skysb
(rmesh,meshsiz_x,meshsiz_y,1);
msigm=skysigmadet(sgmesh,meshsiz_x,meshsiz_y);
}
else if (meshsiz_x*meshsiz_y==2)
{
msky=0.5*(rmesh[0]+rmesh[1]);
msigm=0.5*(sgmesh[0]+sgmesh[1]);
}
else if(meshsiz_x*meshsiz_y==1)
{
msky=rmesh[0];
msigm=sgmesh[0];
}
else
{
msky=0;/* Error */
msigm=-1.0; /* Error */
}
printf("SSB-EST %g\n",msky);
printf("SSGM-EST %g\n",msigm);
/* Write skymap to file*/
if(skymap[0]!='\0')
{
if(skymap[0]=='-')
{
fmap=stdout;
printf("mapfile:stdout\n");
fprintf(stderr,"mapfile:stdout\n");
}
else
{
printf("mapfile:%s\n",skymap);
fprintf(stderr,"mapfile:%s\n",skymap);
fmap=fopen(skymap,"a");
}
if(fmap==NULL)
{
printf("Cannot write to \"%s\" -- writeing to stdout.\n",skymap);
fprintf(stderr,
"Cannot write to \"%s\" -- writeing to stdout.\n",skymap);
fmap=stdout;
}
fprintf(fmap,"# %s\n",fnamin);
fprintf(fmap,"# %d %d # (mesh size)\n",nmesh_x,nmesh_y);
fprintf(fmap,"# %d %d # meshsiz_x meshsiz_y\n",meshsiz_x,meshsiz_y);
fprintf(fmap,"# %g %g # msky msigma\n",msky,msigm);
for(j=0;j<meshsiz_y;j++)
{
for(i=0;i<meshsiz_x;i++)
{
fprintf(fmap,"%d %d %6.2f\n",i,j,rmesh[i+meshsiz_x*j]);
}
}
if(fmap!=stdout) fclose(fmap);
}
/*
*** prepare for output ***
*/
/* Now sky subtract */
skysub(g2,npx,npy,rmesh,meshsiz_x,meshsiz_y,
nmesh_x,nmesh_y,mode,pixignr);
free(rmesh);
free(sgmesh);
statsk(g2,npx,npy,fact,ncycle,&gmax,&gmin,&gmean,&gsd,pixignr);
/***** set output format *******/
fprintf(stderr,"%s\n",fnamout);
imh_inherit(&imhin,&icomin,&imhout,&icomout,fnamout);
imclose(fpin,&imhin,&icomin);
if (imhout.dtype==DTYPFITS)
{
if(dtype[0]=='\0'||(fitsdtype=imc_fits_dtype_string(dtype))==-1)
(void)imc_fits_get_dtype( &imhout, &fitsdtype, NULL, NULL, NULL);
/* 2000/07/02 */
if(bzeroset!=1)
(void)imc_fits_get_dtype( &imhout, NULL, &bzero, &bscale, NULL);
/* re-set bzero & bscale */
if(imc_fits_set_dtype(&imhout,fitsdtype,bzero,bscale)==0)
{
printf("Error\nCannot set FITS %s\n",fnamout);
printf("Type %d BZERO %f BSCALE %f\n",fitsdtype,bzero,bscale);
exit(-1);
}
}
else
{
if (strstr(dtype,"I2"))
{
imhout.dtype=DTYPI2;
}
else if (strstr(dtype,"INT"))
{
imhout.dtype=DTYPINT;
}
else if (strstr(dtype,"I4"))
{
imhout.dtype=DTYPI4;
}
else if (strstr(dtype,"R4"))
{
imhout.dtype=DTYPR4;
}
else if (strstr(dtype,"R8"))
{
imhout.dtype=DTYPR8;
}
else
{
imhout.dtype=DTYPU2;
imset_u2off(&imhout,&icomout,500);
}
}
if(ignor!=(float)INT_MIN)
{
imset_pixignr(&imhout, &icomout, (int)ignor);
/* replace pixignr */
for(i=0;i<imhout.npx*imhout.npy;i++)
if(g2[i]==(float)pixignr) g2[i]=(float)ignor;
pixignr=ignor;
}
else
{
imset_pixignr(&imhout, &icomout, pixignr);
}
/**** output image ****/
imaddhistf(&icomout,
"Sky subtracted by skysb3b, mesh %3dx%3d sky%7.2f+%7.2f",
nmesh_x,nmesh_y,msky,msigm);
if (imget_fits_value(&icomout, "SSBMSH-I", buffer )==0)
{
imupdate_fitsf(&icomout, "SSBMSH-I", "%20d / %-46.46s",
nmesh_x , "SKY MESH X PIXEL" );
imupdate_fitsf(&icomout, "SSBMSH-J", "%20d / %-46.46s",
nmesh_y , "SKY MESH Y PIXEL" );
imupdate_fitsf(&icomout, "SSB-EST", "%20.4f / %-46.46s",
msky, "TYPICAL SKY ADC ESTIMATED" );
imupdate_fitsf(&icomout, "SSGM-EST", "%20.4f / %-46.46s",
msigm, "TYPICAL SKY SIGMA ADC ESTIMATED" );
}
if ((fpout= imwopen(fnamout,&imhout,&icomout))==NULL)
{
printf("Cannot open file %s !!\n",fnamout);
exit(-1);
}
imwall_rto( &imhout, fpout, g2 );
free(g);
imclose(fpout,&imhout,&icomout);
/*
printf("\n");
printf(" --- skysb3b PROGRAM ENDED ---\n");
*/
return 0;
}
int main(int argc,char *argv[])
{
struct imh imhin={""},imhout={""};
struct icom icomin={0},icomout={0};
char fnamin[100]="";
char fnamout[100]="";
char tmp[100]="";
FILE *fp,*fp2;
float *f,*g,*h;
int i;
int xmin=-1,xmax=-1,ymin=-1,ymax=-1;
int ymin2,ymax2;
int offst;
float bzero=0,bscale=1.0,bzero_new=FLT_MIN,bscale_new=FLT_MIN;
float blank_new=FLT_MIN;
float pixignr=INT_MIN;
int fitsdtype=-1;
int npx,npy,npx2,npy2,npxos,npyos,npxef[NREGION],npyef[NREGION];
int npxef0=0;
int xflip,yflip;
int region;
char regid[2],key[10],comment[80];
int efminx[NREGION],efmaxx[NREGION],efminy[NREGION],efmaxy[NREGION];
int osminx[NREGION],osmaxx[NREGION],osminy[NREGION],osmaxy[NREGION];
int j=0;
char dtype[BUFSIZ]="";
int notrim=0;
int no_y=0;
/* test */
int flag_norm=0;
float gain[NREGION]={0};
int fit_param=-1;
getargopt opts[20];
char *files[3]={NULL};
int nopt=0;
int helpflag;
files[0]=fnamin;
files[1]=fnamout;
/* only trim version is supported now */
setopts(&opts[nopt++],"-notrim", OPTTYP_FLAG , ¬rim,
"not trim off(default:trim)",1);
setopts(&opts[nopt++],"-no-y", OPTTYP_FLAG , &no_y,
"not subtract y-overscan(default:subtract)",1);
setopts(&opts[nopt++],"-bzero=", OPTTYP_FLOAT , &bzero_new,
"bzero");
setopts(&opts[nopt++],"-bscale=", OPTTYP_FLOAT , &bscale_new,
"bscale");
setopts(&opts[nopt++],"-dtype=", OPTTYP_STRING , dtype,
"datatyp(FITSFLOAT,FITSSHORT...)");
setopts(&opts[nopt++],"-pixignr=", OPTTYP_FLOAT , &blank_new,
"pixignr value");
setopts(&opts[nopt++],"",0,NULL,NULL);
helpflag=parsearg(argc,argv,opts,files,NULL);
if(fnamout[0]=='\0')
{
fprintf(stderr,"Error: No input file specified!!\n");
helpflag=1;
}
if(helpflag==1)
{
print_help("Usage: osmed4 <options> [filein] [fileout]",
opts,
"");
exit(-1);
}
/*
* ... Open Input
*/
(void)printf("\n Input = %s\n",fnamin );
if( (fp = imropen ( fnamin, &imhin, &icomin )) == NULL )
{
print_help("Usage: %s <options> [filein] [fileout]",
opts,
"");
exit(-1);
}
npx=imhin.npx;
npy=imhin.npy;
/* get information here */
npx2=0;
npy2=0;
npxos=0;
npyos=0;
imget_fits_value(&icomin,"S_XFLIP",tmp);
printf("debug: xflip [%s]\n",tmp);
if (tmp[0]=='T') xflip=1; else xflip=0;
imget_fits_value(&icomin,"S_YFLIP",tmp);
if (tmp[0]=='T') yflip=1; else yflip=0;
xmin=npx;
xmax=-1;
ymin=npy;
ymax=-1;
ymin2=npy;
ymax2=-1;
for(region=0;region<NREGION;region++)
{
if (xflip==0)
sprintf(regid,"%1d",region+1);
else
sprintf(regid,"%1d",NREGION-region);
sprintf(key,"S_EFMN%c1",regid[0]);
imget_fits_int_value(&icomin,key,&(efminx[region]));
sprintf(key,"S_EFMX%c1",regid[0]);
imget_fits_int_value(&icomin,key,&(efmaxx[region]));
sprintf(key,"S_EFMN%c2",regid[0]);
imget_fits_int_value(&icomin,key,&(efminy[region]));
sprintf(key,"S_EFMX%c2",regid[0]);
imget_fits_int_value(&icomin,key,&(efmaxy[region]));
efminx[region]--;
efmaxx[region]--;
efminy[region]--;
efmaxy[region]--;
printf("debug:EF: %d %d %d %d\n",
efminx[region],efmaxx[region],efminy[region],efmaxy[region]);
if(efmaxx[region]<efminx[region]) exit(-1);
if(efmaxy[region]<efminy[region]) exit(-1);
npxef[region]=efmaxx[region]-efminx[region]+1;
npyef[region]=efmaxy[region]-efminy[region]+1;
if(xmin>efminx[region]) xmin=efminx[region];
if(xmax<efmaxx[region]) xmax=efmaxx[region];
if(ymin>efminy[region]) ymin=efminy[region];
if(ymax<efmaxy[region]) ymax=efmaxy[region];
if(ymin2>efminy[region]) ymin2=efminy[region];
if(ymax2<efmaxy[region]) ymax2=efmaxy[region];
printf("debug: npx2=%d\n",npx2);
npx2+=npxef[region];
printf("debug: region %d: %d x %d \n",
region,npxef[region],npyef[region]);
sprintf(key,"S_OSMN%c1",regid[0]);
imget_fits_int_value(&icomin,key,&(osminx[region]));
sprintf(key,"S_OSMX%c1",regid[0]);
imget_fits_int_value(&icomin,key,&(osmaxx[region]));
sprintf(key,"S_OSMN%c2",regid[0]);
imget_fits_int_value(&icomin,key,&(osminy[region]));
sprintf(key,"S_OSMX%c2",regid[0]);
imget_fits_int_value(&icomin,key,&(osmaxy[region]));
osminx[region]--;
osmaxx[region]--;
osminy[region]--;
osmaxy[region]--;
printf("debug:OS: %d %d %d %d\n",
osminx[region],osmaxx[region],osminy[region],osmaxy[region]);
if(ymin2>osminy[region]) ymin2=osminy[region];
if(ymax2<osmaxy[region]) ymax2=osmaxy[region];
if (npxos<osmaxx[region]-osminx[region]+1)
npxos=osmaxx[region]-osminx[region]+1;
if (flag_norm==1)
{
sprintf(key,"S_GAIN%c",regid[0]);
imget_fits_float_value(&icomin,key,&(gain[region]));
}
if (npyos<osmaxy[region]-osminy[region]+1)
npyos=osmaxy[region]-osminy[region]+1;
}
npy2=ymax-ymin+1;
printf("debug: y %d-%d\n",ymin,ymax);
printf("debug: effective size: %dx%d\n",npx2,npy2);
/* output */
imh_inherit(&imhin,&icomin,&imhout,&icomout,fnamout);
if(!notrim)
{
imhout.npx = npx2;
imhout.npy = npy2;
imhout.ndatx = imhout.npx;
imhout.ndaty = imhout.npy;
}
else
{
imhout.npx = npx;
imhout.npy = npy;
imhout.ndatx = imhout.npx;
imhout.ndaty = imhout.npy;
}
if(dtype[0]=='\0')
{
imc_fits_get_dtype( &imhout, &fitsdtype, &bzero, &bscale, &offst );
/** force FLOAT **/
fitsdtype=FITSFLOAT;
}
else
if ((fitsdtype=imc_fits_dtype_string(dtype))==-1)
{
printf("\nWarning: Unknown fits dtype %s. Inheriting original.\n",dtype);
imc_fits_get_dtype( &imhout, &fitsdtype, &bzero, &bscale, &offst );
}
if(bzero_new!=FLT_MIN)
{
bzero=bzero_new;
}
else
bzero=0;
if(bscale_new!=FLT_MIN)
{
bscale=bscale_new;
}
else
bscale=1.0;
(void)imc_fits_set_dtype( &imhout, fitsdtype, bzero, bscale );
if(blank_new!=FLT_MIN)
imset_pixignr(&imhout,&icomout,(int)blank_new);
else
{
pixignr=(float)imget_pixignr(&imhin);
imset_pixignr(&imhout,&icomout,(int)pixignr);
}
if (fit_param>0)
{
imaddhist(&icomout,"OSMED5: Overscan value is smoothed");
}
else
{
imaddhist(&icomout,"OSMED5: X-Overscan median is subtracted line by line.");
if(no_y==0)
imaddhist(&icomout,"OSMED5: Y-Overscan median is subtracted row by row.");
}
if (!notrim)
{
imaddhistf(&icomout,"OSMED5: And trimmed");
}
(void)printf("\n Output = %s\n",fnamout );
if(!notrim)
{
imupdate_fitsf(&icomout, "EFP-MIN1",IMC_FITS_INTFORM,
1,
"Start position of effective frame in axis-1");
imupdate_fitsf(&icomout, "EFP-MIN2",IMC_FITS_INTFORM,
1,
"Start position of effective frame in axis-2");
imupdate_fitsf(&icomout, "EFP-RNG1",IMC_FITS_INTFORM,
npx2,
"Range of effective frame in axis-1");
imupdate_fitsf(&icomout, "EFP-RNG2",IMC_FITS_INTFORM,
npy2,
"Range of effective frame in axis-2");
imc_shift_WCS(&icomout,(float)xmin,(float)ymin);
/* 2008/08/28 header revision more */
/* tenuki kimeuchi */
/* ch1->ch4 ? ch4->ch1?? */
/* tenuki again */
npxef0=0;
for (i=0;i<NREGION;i++)
{
if (xflip==0)
j=i+1;
else
j=NREGION-i;
sprintf(key,"S_EFMN%d1",j);
sprintf(comment,"MIN pixel of x-effective range for ch%d",j);
imupdate_fitsf(&icomout,key,IMC_FITS_INTFORM,
npxef0+1,comment);
sprintf(key,"S_EFMX%d1",j);
sprintf(comment,"MAX pixel of x-effective range for ch%d",j);
imupdate_fitsf(&icomout,key,IMC_FITS_INTFORM,
npxef0+npxef[i],comment);
npxef0+=npxef[i];
sprintf(key,"S_EFMN%d2",j);
sprintf(comment,"MIN pixel of y-effective range for ch%d",j);
imupdate_fitsf(&icomout,key,IMC_FITS_INTFORM,
1,comment);
sprintf(key,"S_EFMX%d2",j);
sprintf(comment,"MAX pixel of y-effective range for ch%d",j);
imupdate_fitsf(&icomout,key,IMC_FITS_INTFORM,
npy2,comment);
}
}
f=(float*)malloc(npx*npy*sizeof(float));
imrall_tor(&imhin, fp, f, npx*npy );
imclose(fp,&imhin,&icomin);
g=(float*)calloc(npx*npy,sizeof(float));
/* overscan estimation and subtract */
for(region=0;region<NREGION;region++)
{
overscansub_x(npx,npy,f,g,
efminx[region],efmaxx[region],
osminx[region],osmaxx[region],
ymin2,ymax2);
if(no_y==0)
{
/* 2008/07/26 Overscan Y added*/
overscansub_y(npx,npy,g,f,
efminy[region],efmaxy[region],
osminy[region],osmaxy[region],
efminx[region],efmaxx[region]);
}
}
if(no_y!=0)
memcpy(f,g,npx*npy*sizeof(float));
if( (fp2 = imwopen( fnamout, &imhout, &icomout )) == NULL )
{
print_help("Usage: %s <options> [filein] [fileout]",
opts,
"");
exit(-1);
}
if(notrim)
{
imwall_rto( &imhout, fp2, h);
}
else
{
/* copy effective regions to g */
i=0;
for(region=0;region<NREGION;region++)
{
for(j=ymin;j<=ymax;j++)
{
memcpy(g+i+(j-ymin)*npx2,f+efminx[region]+j*npx,
(efmaxx[region]-efminx[region]+1)*sizeof(float));
}
i+=(efmaxx[region]-efminx[region]+1);
}
imwall_rto( &imhout, fp2, g);
}
(void) imclose(fp2,&imhout,&icomout);
return 0;
}
