int
psf_open (const tchar *pathname, int mode)
{ int fd = -1 ;
switch (mode)
{ case SFM_READ :
fd = topen (pathname, O_RDONLY) ;
break ;
case SFM_WRITE :
fd = topen (pathname, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP) ;
break ;
case SFM_RDWR :
fd = topen (pathname, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP) ;
break ;
default :
/* psf_log_printf (psf, "ad open mode.\n") ; */
return -1 ;
} ;
if (fd < 0)
perror ("psf_open") ;
return fd ;
} /* psf_open */
static int
open_wim_file(const tchar *filename, struct filedes *fd_ret)
{
int raw_fd;
raw_fd = topen(filename, O_RDONLY | O_BINARY);
if (raw_fd < 0) {
ERROR_WITH_ERRNO("Can't open \"%"TS"\" read-only", filename);
return WIMLIB_ERR_OPEN;
}
filedes_init(fd_ret, raw_fd);
return 0;
}
static int
processStream(const XML_Char *filename, XML_Parser parser)
{
/* passing NULL for filename means read intput from stdin */
int fd = 0; /* 0 is the fileno for stdin */
if (filename != NULL) {
fd = topen(filename, O_BINARY|O_RDONLY);
if (fd < 0) {
tperror(filename);
return 0;
}
}
for (;;) {
int nread;
char *buf = (char *)XML_GetBuffer(parser, READ_SIZE);
if (!buf) {
if (filename != NULL)
close(fd);
ftprintf(stderr, T("%s: out of memory\n"),
filename != NULL ? filename : "xmlwf");
return 0;
}
nread = read(fd, buf, READ_SIZE);
if (nread < 0) {
tperror(filename != NULL ? filename : "STDIN");
if (filename != NULL)
close(fd);
return 0;
}
if (XML_ParseBuffer(parser, nread, nread == 0) == XML_STATUS_ERROR) {
reportError(parser, filename != NULL ? filename : "STDIN");
if (filename != NULL)
close(fd);
return 0;
}
if (nread == 0) {
if (filename != NULL)
close(fd);
break;;
}
}
return 1;
}
/* Library initialization function */
static void __attribute__((constructor)) interpose_init(void) {
/* XXX Note that this might be called twice in one program. Java
* seems to do this, for example.
*/
/* Open the trace file */
topen();
/* Get file descriptor limit and allocate descriptor table */
struct rlimit nofile_limit;
getrlimit(RLIMIT_NOFILE, &nofile_limit);
max_descriptors = nofile_limit.rlim_max;
descriptors = (Descriptor *)calloc(sizeof(Descriptor), max_descriptors);
if (descriptors == NULL) {
printerr("calloc: %s\n", strerror(errno));
}
debug("Max descriptors: %d", max_descriptors);
tprintf("start: %lf\n", get_time());
}
struct mFitExecReturn *mFitExec(char *tblfile, char *fitfile, char *diffdir, int levelOnly, int debugin)
{
int stat, ncols, count, failed;
int warning, missing;
int icntr1;
int icntr2;
int idiffname;
int cntr1;
int cntr2;
char diffname[MAXSTR];
double a;
double b;
double c;
double crpix1;
double crpix2;
int xmin;
int xmax;
int ymin;
int ymax;
double xcenter;
double ycenter;
double npixel;
double rms;
double boxx;
double boxy;
double boxwidth;
double boxheight;
double boxangle;
FILE *fout;
struct mFitExecReturn *returnStruct;
struct mFitplaneReturn *fitplane;
returnStruct = (struct mFitExecReturn *)malloc(sizeof(struct mFitExecReturn));
memset((void *)returnStruct, 0, sizeof(returnStruct));
returnStruct->status = 1;
/***************************************/
/* Process the command-line parameters */
/***************************************/
mFitExec_debug = debugin;
fout = fopen(fitfile, "w+");
if(fout == (FILE *)NULL)
{
strcpy(returnStruct->msg, "Can't open output file.");
return returnStruct;
}
/***************************************/
/* Open the difference list table file */
/***************************************/
ncols = topen(tblfile);
if(ncols <= 0)
{
sprintf(returnStruct->msg, "Invalid diffs metadata file: %s", tblfile);
fclose(fout);
return returnStruct;
}
icntr1 = tcol( "cntr1");
icntr2 = tcol( "cntr2");
idiffname = tcol( "diff");
if(icntr1 < 0
|| icntr2 < 0
|| idiffname < 0)
{
strcpy(returnStruct->msg, "Need columns: cntr1 cntr2 diff");
fclose(fout);
return returnStruct;
}
/***************************************/
/* Read the records and call mFitplane */
/***************************************/
count = 0;
failed = 0;
warning = 0;
missing = 0;
fprintf(fout, "|%9s|%9s|%16s|%16s|%16s|%14s|%14s|%10s|%10s|%10s|%10s|%13s|%13s|%13s|%16s|%16s|%16s|%16s|%16s|%16s|\n",
"plus", "minus", "a", "b", "c", "crpix1", "crpix2", "xmin", "xmax", "ymin", "ymax", "xcenter", "ycenter", "npixel", "rms", "boxx", "boxy", "boxwidth", "boxheight", "boxang");
fflush(fout);
while(1)
{
stat = tread();
if(stat < 0)
break;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
strcpy(diffname, montage_filePath(diffdir, tval(idiffname)));
if(montage_checkFile(diffname))
{
++count;
++missing;
continue;
}
fitplane = mFitplane(diffname, levelOnly, 0., 0);
if(mFitExec_debug)
{
printf("mFitplane(%s) -> [%s]\n", diffname, fitplane->msg);
fflush(stdout);
}
if(fitplane->status)
++failed;
else
{
a = fitplane->a;
b = fitplane->b;
c = fitplane->c;
crpix1 = fitplane->crpix1;
crpix2 = fitplane->crpix2;
xmin = fitplane->xmin;
xmax = fitplane->xmax;
ymin = fitplane->ymin;
ymax = fitplane->ymax;
xcenter = fitplane->xcenter;
ycenter = fitplane->ycenter;
npixel = fitplane->npixel;
rms = fitplane->rms;
boxx = fitplane->boxx;
boxy = fitplane->boxy;
boxwidth = fitplane->boxwidth;
boxheight = fitplane->boxheight;
boxangle = fitplane->boxang;
fprintf(fout, " %9d %9d %16.5e %16.5e %16.5e %14.2f %14.2f %10d %10d %10d %10d %13.2f %13.2f %13.0f %16.5e %16.1f %16.1f %16.1f %16.1f %16.1f \n",
cntr1, cntr2, a, b, c, crpix1, crpix2, xmin, xmax, ymin, ymax,
xcenter, ycenter, npixel, rms, boxx, boxy, boxwidth, boxheight, boxangle);
fflush(fout);
}
free(fitplane);
++count;
}
/* Finish up */
returnStruct->status = 0;
sprintf(returnStruct->msg, "count=%d, failed=%d, warning=%d, missing=%d",
count, failed, warning, missing);
sprintf(returnStruct->json, "{\"count\":%d, \"failed\":%d, \"warning\":%d, \"missing\":%d}",
count, failed, warning, missing);
returnStruct->count = count;
returnStruct->failed = failed;
returnStruct->warning = warning;
returnStruct->missing = missing;
return returnStruct;
}
int main(int argc, char **argv)
{
int i, j, l, m, c, count, ismag, ncol;
int dl, dm, width, haveFlux, isImg, csys;
int side, ibegin, iend, nstep, useCenter;
int racol, deccol, fluxcol;
int ra1col, dec1col;
int ra2col, dec2col;
int ra3col, dec3col;
int ra4col, dec4col;
long fpixel, nelements;
double rac, decc;
double ra[4], dec[4];
double x, y, z;
double x0, y0, z0;
double x1, y1, z1;
double oxpix, oypix, equinox;
int offscl;
double ilon;
double ilat;
double pixscale, len, sideLength, dtr;
double offset;
double xn, yn, zn;
double ran, decn;
double sina, cosa;
double sind, cosd;
double a11, a12, a13;
double a21, a22, a23;
double a31, a32, a33;
double x0p, y0p, z0p;
double x1p, y1p, z1p;
double lon0, lon1;
double xp, yp;
double lon;
double pixel_value;
double weights[5][5];
double weights3[5][5] = {{0.0, 0.0, 0.0, 0.0, 0.0},
{0.0, 0.1, 0.2, 0.1, 0.0},
{0.0, 0.2, 1.0, 0.2, 0.0},
{0.0, 0.1, 0.2, 0.1, 0.0},
{0.0, 0.0, 0.0, 0.0, 0.0}};
double weights5[5][5] = {{0.0, 0.1, 0.2, 0.1, 0.0},
{0.1, 0.3, 0.5, 0.3, 0.1},
{0.2, 0.5, 1.0, 0.5, 0.2},
{0.1, 0.3, 0.5, 0.3, 0.1},
{0.0, 0.1, 0.2, 0.1, 0.0}};
double **data;
int status = 0;
char input_file [MAXSTR];
char colname [MAXSTR];
char output_file [MAXSTR];
char template_file[MAXSTR];
int bitpix = DOUBLE_IMG;
long naxis = 2;
double sumweights;
double refmag;
dtr = atan(1.0)/45.;
/***************************************/
/* Process the command-line parameters */
/***************************************/
ismag = 0;
opterr = 0;
useCenter = 0;
strcpy(colname, "");
while ((c = getopt(argc, argv, "pm:d:w:c:")) != EOF)
{
switch (c)
{
case 'm':
ismag = 1;
refmag = atof(optarg);
break;
case 'd':
debug = debugCheck(optarg);
break;
case 'w':
width = atoi(optarg);
break;
case 'c':
strcpy(colname, optarg);
break;
case 'p':
useCenter = 1;
break;
default:
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-c column][-m refmag][-d level][-w size] in.tbl out.fits hdr.template\"]\n", argv[0]);
exit(1);
break;
}
}
if (argc - optind < 3)
{
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-c column][-m refmag][-d level][-w size] in.tbl out.fits hdr.template\"]\n", argv[0]);
exit(1);
}
strcpy(input_file, argv[optind]);
strcpy(output_file, argv[optind+1]);
strcpy(template_file, argv[optind+2]);
if(debug >= 1)
{
printf("input_file = [%s]\n", input_file);
printf("colname = [%s]\n", colname);
printf("output_file = [%s]\n", output_file);
printf("template_file = [%s]\n", template_file);
printf("width = %d\n", width);
printf("ismag = %d\n", ismag);
fflush(stdout);
}
/********************************************/
/* Set the weights for spreading the points */
/********************************************/
sumweights = 0.;
for(i=0; i<5; ++i)
{
for(j=0; j<5; ++j)
{
if(width == 3)
sumweights += weights3[i][j];
else if(width == 5)
sumweights += weights5[i][j];
}
}
for(i=0; i<5; ++i)
{
for(j=0; j<5; ++j)
{
if(width == 3)
weights[i][j] = weights3[i][j]/sumweights;
else if(width == 5)
weights[i][j] = weights5[i][j]/sumweights;
else
weights[i][j] = 0.;
}
}
if(width != 3 && width != 5)
weights[2][2] = 1.;
/************************************************/
/* Open the table file and find the data column */
/************************************************/
ncol = topen(input_file);
if(ncol <= 0)
{
printf("[struct stat=\"ERROR\", msg=\"Can't open input table %s\"]\n", input_file);
exit(0);
}
racol = tcol( "ra");
deccol = tcol("dec");
ra1col = tcol( "ra1");
dec1col = tcol("dec1");
ra2col = tcol( "ra2");
dec2col = tcol("dec2");
ra3col = tcol( "ra3");
dec3col = tcol("dec3");
ra4col = tcol( "ra4");
dec4col = tcol("dec4");
haveFlux = 1;
if(strlen(colname) == 0)
haveFlux = 0;
else
fluxcol = tcol(colname);
isImg = 1;
if(ra1col < 0 || dec1col < 0
|| ra2col < 0 || dec2col < 0
|| ra3col < 0 || dec3col < 0
|| ra4col < 0 || dec4col < 0)
isImg = 0;
if(useCenter)
isImg = 0;
if(!isImg)
{
if(racol < 0)
{
printf("[struct stat=\"ERROR\", msg=\"Can't find column 'ra'\"]\n");
exit(0);
}
if(deccol < 0)
{
printf("[struct stat=\"ERROR\", msg=\"Can't find column 'dec'\"]\n");
exit(0);
}
}
if(haveFlux && fluxcol < 0)
{
printf("[struct stat=\"ERROR\", msg=\"Can't find column '%s'\"]\n", colname);
exit(0);
}
/*************************************************/
/* Process the output header template to get the */
/* image size, coordinate system and projection */
/*************************************************/
readTemplate(template_file);
pixscale = fabs(output.wcs->xinc);
if(fabs(output.wcs->yinc) > pixscale)
pixscale = fabs(output.wcs->yinc);
csys = EQUJ;
if(strncmp(output.wcs->c1type, "RA", 2) == 0)
csys = EQUJ;
if(strncmp(output.wcs->c1type, "GLON", 4) == 0)
csys = GAL;
if(strncmp(output.wcs->c1type, "ELON", 4) == 0)
csys = ECLJ;
equinox = output.wcs->equinox;
if(debug >= 1)
{
printf("output.naxes[0] = %ld\n", output.naxes[0]);
printf("output.naxes[1] = %ld\n", output.naxes[1]);
printf("output.sys = %d\n", output.sys);
printf("output.epoch = %-g\n", output.epoch);
printf("output proj = %s\n", output.wcs->ptype);
printf("output crval[0] = %-g\n", output.wcs->crval[0]);
printf("output crval[1] = %-g\n", output.wcs->crval[1]);
printf("output crpix[0] = %-g\n", output.wcs->crpix[0]);
printf("output crpix[1] = %-g\n", output.wcs->crpix[1]);
printf("output cdelt[0] = %-g\n", output.wcs->cdelt[0]);
printf("output cdelt[1] = %-g\n", output.wcs->cdelt[1]);
fflush(stdout);
}
/***********************************************/
/* Allocate memory for the output image pixels */
/***********************************************/
data = (double **)malloc(output.naxes[1] * sizeof(double *));
data[0] = (double *)malloc(output.naxes[0] * output.naxes[1] * sizeof(double));
if(debug >= 1)
{
printf("%ld bytes allocated for image pixels\n",
output.naxes[0] * output.naxes[1] * sizeof(double));
fflush(stdout);
}
/**********************************************************/
/* Initialize pointers to the start of each row of pixels */
/**********************************************************/
for(i=1; i<output.naxes[1]; i++)
data[i] = data[i-1] + output.naxes[0];
if(debug >= 1)
{
printf("pixel line pointers populated\n");
fflush(stdout);
}
for (j=0; j<output.naxes[1]; ++j)
{
for (i=0; i<output.naxes[0]; ++i)
{
data[j][i] = 0.;
}
}
/************************/
/* Create the FITS file */
/************************/
remove(output_file);
if(fits_create_file(&output.fptr, output_file, &status))
printFitsError(status);
/*********************************************************/
/* Create the FITS image. All the required keywords are */
/* handled automatically. */
/*********************************************************/
if (fits_create_img(output.fptr, bitpix, naxis, output.naxes, &status))
printFitsError(status);
if(debug >= 1)
{
printf("FITS image created (not yet populated)\n");
fflush(stdout);
}
/*****************************/
/* Loop over the input files */
/*****************************/
time(&currtime);
start = currtime;
/*******************/
/* For each source */
/*******************/
count = 0;
while(tread() >= 0)
{
++count;
if(isImg)
{
if(debug && count/1000*1000 == count)
{
printf("%9d image outlines processed\n", count);
fflush(stdout);
}
ra [0] = atof(tval( ra1col));
dec[0] = atof(tval(dec1col));
ra [1] = atof(tval( ra2col));
dec[1] = atof(tval(dec2col));
ra [2] = atof(tval( ra3col));
dec[2] = atof(tval(dec3col));
ra [3] = atof(tval( ra4col));
dec[3] = atof(tval(dec4col));
for(side=0; side<4; ++side)
{
ibegin = side;
iend = (side+1)%4;
x0 = cos(ra[ibegin]*dtr) * cos(dec[ibegin]*dtr);
y0 = sin(ra[ibegin]*dtr) * cos(dec[ibegin]*dtr);
z0 = sin(dec[ibegin]*dtr);
x1 = cos(ra[iend]*dtr) * cos(dec[iend]*dtr);
y1 = sin(ra[iend]*dtr) * cos(dec[iend]*dtr);
z1 = sin(dec[iend]*dtr);
xn = y0*z1 - z0*y1;
yn = z0*x1 - x0*z1;
zn = x0*y1 - y0*x1;
len = sqrt(xn*xn + yn*yn + zn*zn);
xn = xn / len;
yn = yn / len;
zn = zn / len;
ran = atan2(yn, xn);
decn = asin(zn);
sina = sin(ran);
cosa = cos(ran);
sind = sin(decn);
cosd = cos(decn);
a11 = cosa*sind;
a12 = sina*sind;
a13 = -cosd;
a21 = -sina;
a22 = cosa;
a23 = 0.;
a31 = cosa*cosd;
a32 = sina*cosd;
a33 = sind;
x0p = a11*x0 + a12*y0 + a13*z0;
y0p = a21*x0 + a22*y0 + a23*z0;
z0p = a31*x0 + a32*y0 + a33*z0;
x1p = a11*x1 + a12*y1 + a13*z1;
y1p = a21*x1 + a22*y1 + a23*z1;
z1p = a31*x1 + a32*y1 + a33*z1;
lon0 = atan2(y0p, x0p);
lon1 = atan2(y1p, x1p);
if(fabs(lon1-lon0)/dtr > 180.)
{
if(lon0 < 0.) lon0 += 360.*dtr;
if(lon1 < 0.) lon1 += 360.*dtr;
}
sideLength = acos(x0*x1 + y0*y1 + z0*z1) / dtr;
offset = pixscale/2.*dtr;
if(lon0 > lon1)
offset = -offset;
nstep = (lon1 - lon0)/offset;
lon = lon0;
for(i=0; i<nstep; ++i)
{
lon += offset;
xp = cos(lon);
yp = sin(lon);
x = a11*xp + a21*yp;
y = a12*xp + a22*yp;
z = a13*xp + a23*yp;
rac = atan2(y,x)/dtr;
decc = asin(z)/dtr;
convertCoordinates (EQUJ, 2000., rac, decc,
csys, equinox, &ilon, &ilat, 0.);
offscl = 0;
wcs2pix(output.wcs, ilon, ilat, &oxpix, &oypix, &offscl);
fixxy(&oxpix, &oypix, &offscl);
if(haveFlux)
pixel_value = atof(tval(fluxcol));
else
pixel_value = 1;
l = (int)(oxpix + 0.5) - 1;
m = (int)(oypix + 0.5) - 1;
if(!offscl)
data[m][l] = pixel_value;
}
}
}
else
{
if(debug && count/1000*1000 == count)
{
printf("%9d sources processed\n", count);
fflush(stdout);
}
rac = atof(tval(racol));
decc = atof(tval(deccol));
convertCoordinates (EQUJ, 2000., rac, decc,
csys, equinox, &ilon, &ilat, 0.);
if(haveFlux)
pixel_value = atof(tval(fluxcol));
else
pixel_value = 1;
if(ismag)
pixel_value = pow(10., 0.4 * (refmag - pixel_value));
wcs2pix(output.wcs, ilon, ilat, &oxpix, &oypix, &offscl);
if(pixel_value < 1.e10)
{
if(debug >= 3)
{
printf(" value = %11.3e at coord = (%12.8f,%12.8f)", pixel_value, ilon, ilat);
if(offscl)
{
printf(" -> opix = (%7.1f,%7.1f) OFF SCALE\n",
oxpix, oypix);
fflush(stdout);
}
else
{
printf(" -> opix = (%7.1f,%7.1f)\n",
oxpix, oypix);
fflush(stdout);
}
}
else if(pixel_value > 1000000.)
{
printf(" value = %11.3e at coord = (%12.8f,%12.8f)", pixel_value, ilon, ilat);
if(offscl)
{
printf(" -> opix = (%7.1f,%7.1f) OFF SCALE\n",
oxpix, oypix);
fflush(stdout);
}
else
{
printf(" -> opix = (%7.1f,%7.1f)\n",
oxpix, oypix);
fflush(stdout);
}
}
if(!offscl)
{
l = (int)(oxpix + 0.5) - 1;
m = (int)(oypix + 0.5) - 1;
if(l < 0 || m < 0 || l >= output.naxes[0] || m >= output.naxes[1])
{
/*
printf("ERROR: l=%d, m=%d\n", l, m);
fflush(stdout);
*/
}
else
{
for(dl=-2; dl<=2; ++dl)
{
if(l+dl < 0 || l+dl>= output.naxes[0])
continue;
for(dm=-2; dm<=2; ++dm)
{
if(m+dm < 0 || m+dm>= output.naxes[1])
continue;
data[m+dm][l+dl] += weights[dm+2][dl+2] * pixel_value;
}
}
}
}
}
}
}
/************************/
/* Write the image data */
/************************/
fpixel = 1;
nelements = output.naxes[0] * output.naxes[1];
if (fits_write_img(output.fptr, TDOUBLE, fpixel, nelements, data[0], &status))
printFitsError(status);
if(debug >= 1)
{
printf("Data array written to FITS image\n");
fflush(stdout);
}
/*************************************/
/* Add keywords from a template file */
/*************************************/
if(fits_write_key_template(output.fptr, template_file, &status))
printFitsError(status);
if(debug >= 1)
{
printf("Template keywords written to FITS image\n");
fflush(stdout);
}
/***********************/
/* Close the FITS file */
/***********************/
if(fits_close_file(output.fptr, &status))
printFitsError(status);
if(debug >= 1)
{
printf("FITS image finalized\n");
fflush(stdout);
}
time(&currtime);
printf("[struct stat=\"OK\", time=%d]\n",
(int)(currtime - start));
fflush(stdout);
exit(0);
}
int
filemap(const tchar *name,
void (*processor)(const void *, size_t, const tchar *, void *arg),
void *arg)
{
size_t nbytes;
int fd;
_EXPAT_read_count_t n;
struct stat sb;
void *p;
fd = topen(name, O_RDONLY|O_BINARY);
if (fd < 0) {
tperror(name);
return 0;
}
if (fstat(fd, &sb) < 0) {
tperror(name);
close(fd);
return 0;
}
if (!S_ISREG(sb.st_mode)) {
ftprintf(stderr, T("%s: not a regular file\n"), name);
close(fd);
return 0;
}
if (sb.st_size > XML_MAX_CHUNK_LEN) {
close(fd);
return 2; /* Cannot be passed to XML_Parse in one go */
}
nbytes = sb.st_size;
/* malloc will return NULL with nbytes == 0, handle files with size 0 */
if (nbytes == 0) {
static const char c = '\0';
processor(&c, 0, name, arg);
close(fd);
return 1;
}
p = malloc(nbytes);
if (!p) {
ftprintf(stderr, T("%s: out of memory\n"), name);
close(fd);
return 0;
}
n = _EXPAT_read(fd, p, (_EXPAT_read_req_t)nbytes);
if (n < 0) {
tperror(name);
free(p);
close(fd);
return 0;
}
if (n != (_EXPAT_read_count_t)nbytes) {
ftprintf(stderr, T("%s: read unexpected number of bytes\n"), name);
free(p);
close(fd);
return 0;
}
processor(p, nbytes, name, arg);
free(p);
close(fd);
return 1;
}
int main(int argc,char** argv)
{
char pm, operation=-1, found=1, pw1[128], pw2[128], ae1[15], ae2[15];
u32 i;
PK0102 ce;
PK0304 le;
PK0506 ed;
for (pm=1; pm < argc; pm++)
{
char opt;
if (argv[pm][0] != '/') continue;
if (argv[pm][1] == '?') {
printf( "Encrypts or decrypts an archive following WinZip(R) 9 specifications.\n\n" \
"ZAES /D | /E:keysize [/2] archive.zip\n\n" \
" /D decrypts AES encrypted entries\n" \
" /E:keysize encrypts with 128, 192 or 256-bit keys (keysize 1, 2 or 3)\n" \
" /2 AE-2 format (sets CRC-32 to zero)\n");
return 1;
}
opt = toupper(argv[pm][1]);
if (opt== 'E') {
Mode = atol(&argv[pm][3]);
operation = 0;
filter = encrypt_authenticate;
if (Mode < 1 || Mode > 3)
Z_ERROR("Bad encryption mode specified!");
SaltSize = KS[Mode].Salt;
KeySize = KS[Mode].Key;
found++;
continue;
}
if (opt== 'D') {
operation = 1;
filter = authenticate_decrypt;
found++;
continue;
}
if (opt== '2') {
AE2 = 1;
found++;
printf("WARNING: according to AE-2 specifications, CRC-32 will be set to zero\n"\
"in encrypted entries. Reverting to original archive after decryption will\n"\
"be impossible with this utility!\n");
continue;
}
}
argv+=found;
argc-=found;
if (operation == -1) Z_ERROR("You must specify /E or /D switch!\nTry ZAES /?");
if (argc < 1) Z_ERROR("You must give a ZIP archive to process!");
register_prng(&sprng_desc);
register_cipher(&aes_desc);
register_hash(&sha1_desc);
//~ printf("DEBUG: sha1 id=%d, aes id=%d\n", find_hash("sha1"), find_cipher("aes"));
if ( (ZIN=fopen(argv[0],"rb")) == 0 || (ZIN2=fopen(argv[0],"rb")) == 0 )
Z_ERROR("Can't open input ZIP archive");
if ( (ZOUT=topen(ae1)) == 0 || (ZTMP=topen(ae2)) == 0)
Z_ERROR("Can't open temporary output files");
setvbuf(ZIN , 0, _IOFBF, BLOCK);
setvbuf(ZOUT, 0, _IOFBF, BLOCK);
/* assumiamo uno ZIP senza commento! */
fseek(ZIN2,-22,SEEK_END);
safeRead(&ed, ZIN2, sizeof(PK0506));
if (ed.Sig != 0x06054B50)
#ifdef HANDLE_COMMENT
{
fseek(ZIN2, -0xFFFF, SEEK_END);
fread(p, 1, 4, ZIN2);
#else
Z_ERROR("End directory marker not found!");
#endif
/* verifica un minimo di coerenza nella ENDDIR */
if (ed.Disk != 0)
Z_ERROR("Can't process a spanned archive");
while(1) {
printf("Enter password: "******"\rFor your safety, please use a password of 8 characters or more.\n");
continue;
}
if (operation) {
printf("\n");
break;
}
printf("\rVerify password: "******"Passwords don't match!\n");
continue;
}
printf("\n");
break;
}
#define PUTN(x) { fileCopy(stdout, ZIN, x.NameLen); fseek(ZIN, -x.NameLen, SEEK_CUR); }
fseek(ZIN2, ed.Offset, SEEK_SET);
for (i=0; i < ed.Total; i++)
{
safeRead(&ce, ZIN2, sizeof(PK0102));
if (ce.Sig != 0x02014B50)
Z_ERROR("Expected central directory marker not found");
/* Assume i dati corretti dalla LE */
fseek(ZIN, ce.Offset, SEEK_SET);
safeRead(&le, ZIN, sizeof(PK0304));
if (le.Sig != 0x04034B50)
Z_ERROR("Expected local entry marker not found");
if ( ((le.Flag & 1) && !operation) || /* doesn't encrypt already encrypted */
(!(le.Flag & 1) && operation) || /* doesn't decrypt already decrypted */
((le.Flag & 1) && operation && le.CompMethod != 99) || /* doesn't decrypt not AES encrypted */
!le.CompSize )
{
ce.Offset = ftell(ZOUT);
safeWrite(ZOUT, &le, sizeof(PK0304));
printf(" copying: "); PUTN(le);
fileCopy(ZOUT, ZIN, le.NameLen+le.ExtraLen+le.CompSize);
printf("\n");
safeWrite(ZTMP, &ce, sizeof(PK0102));
fileCopy(ZTMP, ZIN2, ce.NameLen+ce.ExtraLen);
continue;
}
if (!operation)
{
AE_EXTRA ae = {0x9901, 7, AE2+1, 0x4541, Mode, 0};
ae.CompMethod = ce.CompMethod;
ce.CompMethod = 99;
if (AE2) ce.Crc32 = 0;
ce.Flag |= 1;
ce.ExtraLen += 11;
ce.CompSize += SaltSize + 12; /* variable salt, fixed password check and hmac */
ce.Offset = ftell(ZOUT);
safeWrite(ZTMP, &ce, sizeof(PK0102));
fileCopy(ZTMP, ZIN2, ce.NameLen+ce.ExtraLen-11);
safeWrite(ZTMP, &ae, 11);
printf(" encrypting: "); PUTN(le);
Encrypt(&le, &ae, pw1);
printf("\n");
}
else
{
ce.Offset = ftell(ZOUT);
printf(" decrypting: "); PUTN(le);
Decrypt(&le, pw1); /* Decrypts contents */
printf("\n");
ce.CompMethod = le.CompMethod;
if (AE2) ce.Crc32 = 0;
ce.Flag ^= 1;
ce.ExtraLen -= 11;
ce.CompSize = le.CompSize;
safeWrite(ZTMP, &ce, sizeof(PK0102));
/* Copy the extra data (may be LE != CE) */
fileCopy(ZTMP, ZIN2, ce.NameLen);
for(ce.ExtraLen+=11; ce.ExtraLen;)
{
u16 u[2];
safeRead(u, ZIN2, 4);
ce.ExtraLen -= (4 + u[1]);
if (u[0] == 0x9901)
{
fseek(ZIN2, u[1], SEEK_CUR);
continue;
}
safeWrite(ZTMP, u, 4);
fileCopy(ZTMP, ZIN2, u[1]);
}
}
}
ed.Offset = ftell(ZOUT); /* new central directory start */
ed.Size = ftell(ZTMP); /* new central directory size */
fseek(ZTMP, 0, SEEK_SET);
fclose(ZIN);
fclose(ZIN2);
/* Copies central directory */
fileCopy(ZOUT, ZTMP, ed.Size);
safeWrite(ZOUT, &ed, sizeof(PK0506));
fclose(ZTMP);
fclose(ZOUT);
remove(ae2);
if (remove(argv[0]))
{
printf("Can't remove old archive; new one is in file '%s'\n", ae1);
} else
if (rename(ae1, argv[0]))
{
printf("Can't rename old archive; new one is in file '%s'\n", ae1);
}
memset(&BUF, 0, sizeof(BUF));
memset(&ctr, 0, sizeof(ctr));
memset(pw1, 0, 128);
memset(pw2, 0, 128);
return 0;
}
int main(int argc, char **argv)
{
int c;
char header[32768];
char temp [MAXSTR];
char fmt [MAXSTR];
char rfmt [MAXSTR];
char pfmt [MAXSTR];
char cfmt [MAXSTR];
char ofile [MAXSTR];
char scale [MAXSTR];
int i, j;
int namelen, nimages, ntotal, stat;
double xpos, ypos;
double lon, lat;
double oxpix, oypix;
int oxpixMin, oypixMin;
int oxpixMax, oypixMax;
int offscl, mode;
int ncols;
FILE *fraw;
FILE *fproj;
FILE *fcorr;
/***************************************/
/* Process the command-line parameters */
/***************************************/
debug = 0;
opterr = 0;
fstatus = stdout;
while ((c = getopt(argc, argv, "ds:")) != EOF)
{
switch (c)
{
case 'd':
debug = 1;
break;
case 's':
if((fstatus = fopen(optarg, "w+")) == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Cannot open status file: %s\"]\n",
optarg);
exit(1);
}
break;
default:
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d][-s statusfile] images.tbl hdr.template raw.tbl projected.tbl corrected.tbl\"]\n", argv[0]);
exit(1);
break;
}
}
if (argc - optind < 5)
{
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d][-s statusfile] images.tbl hdr.template raw.tbl projected.tbl corrected.tbl\"]\n", argv[0]);
exit(1);
}
strcpy(origimg_file, argv[optind]);
strcpy(template_file, argv[optind + 1]);
strcpy(rawimg_file, argv[optind + 2]);
strcpy(projimg_file, argv[optind + 3]);
strcpy(corrimg_file, argv[optind + 4]);
checkHdr(template_file, 1, 0);
if(debug)
{
printf("\norigimg_file = [%s]\n", origimg_file);
printf("template_file = [%s]\n\n", template_file);
printf("rawimg_file = [%s]\n", rawimg_file);
printf("projimg_file = [%s]\n", projimg_file);
printf("corrimg_file = [%s]\n", corrimg_file);
fflush(stdout);
}
/*************************************************/
/* Process the output header template to get the */
/* image size, coordinate system and projection */
/*************************************************/
readTemplate(template_file);
if(debug)
{
printf("\noutput.sys = %d\n", output.sys);
printf("output.epoch = %-g\n", output.epoch);
printf("output proj = %s\n", output.wcs->ptype);
fflush(stdout);
}
/*********************************************/
/* Open the image header metadata table file */
/*********************************************/
ncols = topen(origimg_file);
if(ncols <= 0)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid image metadata file: %s\"]\n",
origimg_file);
exit(1);
}
icntr = tcol("cntr");
ictype1 = tcol("ctype1");
ictype2 = tcol("ctype2");
iequinox = tcol("equinox");
inl = tcol("nl");
ins = tcol("ns");
icrval1 = tcol("crval1");
icrval2 = tcol("crval2");
icrpix1 = tcol("crpix1");
icrpix2 = tcol("crpix2");
icdelt1 = tcol("cdelt1");
icdelt2 = tcol("cdelt2");
icrota2 = tcol("crota2");
iepoch = tcol("epoch");
ifname = tcol("fname");
iscale = tcol("scale");
icd11 = tcol("cd1_1");
icd12 = tcol("cd1_2");
icd21 = tcol("cd2_1");
icd22 = tcol("cd2_2");
if(ins < 0)
ins = tcol("naxis1");
if(inl < 0)
inl = tcol("naxis2");
if(ifname < 0)
ifname = tcol("file");
if(icd11 >= 0 && icd12 >= 0 && icd21 >= 0 && icd12 >= 0)
mode = CD;
else if(icdelt1 >= 0 && icdelt2 >= 0 && icrota2 >= 0)
mode = CDELT;
else
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Not enough information to determine coverages (CDELTs or CD matrix)\"]\n");
exit(1);
}
if(icntr < 0
|| ictype1 < 0
|| ictype2 < 0
|| inl < 0
|| ins < 0
|| icrval1 < 0
|| icrval2 < 0
|| icrpix1 < 0
|| icrpix2 < 0
|| ifname < 0)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Need columns: cntr ctype1 ctype2 nl ns crval1 crval2 crpix1 crpix2 cdelt1 cdelt2 crota2 fname (equinox optional)\"]\n");
exit(1);
}
/******************************************************/
/* Scan the table to get the true 'file' column width */
/******************************************************/
namelen = 0;
while(1)
{
stat = tread();
if(stat < 0)
break;
strcpy(input.fname, fileName(tval(ifname)));
if(strlen(input.fname) > namelen)
namelen = strlen(input.fname);
}
tseek(0);
/*************************************/
/* Write headers to the output files */
/*************************************/
if((fraw = (FILE *)fopen(rawimg_file, "w+")) == (FILE *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid output metadata file: %s\"]\n",
rawimg_file);
exit(1);
}
fprintf(fraw, "\\datatype=fitshdr\n");
if(iscale >= 0)
{
sprintf(fmt, "|%%5s|%%8s|%%8s|%%6s|%%6s|%%10s|%%10s|%%10s|%%10s|%%11s|%%11s|%%8s|%%7s|%%10s|%%%ds|\n", namelen+2);
fprintf(fraw, fmt,
"cntr",
"ctype1",
"ctype2",
"naxis1",
"naxis2",
"crval1",
"crval2",
"crpix1",
"crpix2",
"cdelt1",
"cdelt2",
"crota2",
"equinox",
"scale",
"file");
fprintf(fraw, fmt,
"int",
"char",
"char",
"int",
"int",
"double",
"double",
"double",
"double",
"double",
"double",
"double",
"int",
"double",
"char");
}
else
{
sprintf(fmt, "|%%5s|%%8s|%%8s|%%6s|%%6s|%%10s|%%10s|%%10s|%%10s|%%11s|%%11s|%%8s|%%7s|%%%ds|\n", namelen+2);
fprintf(fraw, fmt,
"cntr",
"ctype1",
"ctype2",
"naxis1",
"naxis2",
"crval1",
"crval2",
"crpix1",
"crpix2",
"cdelt1",
"cdelt2",
"crota2",
"equinox",
"file");
fprintf(fraw, fmt,
"int",
"char",
"char",
"int",
"int",
"double",
"double",
"double",
"double",
"double",
"double",
"double",
"int",
"char");
}
if((fproj = (FILE *)fopen(projimg_file, "w+")) == (FILE *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid output metadata file: %s\"]\n",
projimg_file);
exit(1);
}
fprintf(fproj, "\\datatype=fitshdr\n");
sprintf(fmt, "|%%5s|%%8s|%%8s|%%6s|%%6s|%%10s|%%10s|%%10s|%%10s|%%11s|%%11s|%%8s|%%7s|%%%ds|\n", namelen+2);
fprintf(fproj, fmt,
"cntr",
"ctype1",
"ctype2",
"naxis1",
"naxis2",
"crval1",
"crval2",
"crpix1",
"crpix2",
"cdelt1",
"cdelt2",
"crota2",
"equinox",
"file");
fprintf(fproj, fmt,
"int",
"char",
"char",
"int",
"int",
"double",
"double",
"double",
"double",
"double",
"double",
"double",
"int",
"char");
if((fcorr = (FILE *)fopen(corrimg_file, "w+")) == (FILE *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid output metadata file: %s\"]\n",
corrimg_file);
exit(1);
}
fprintf(fcorr, "\\datatype=fitshdr\n");
fprintf(fcorr, fmt,
"cntr",
"ctype1",
"ctype2",
"naxis1",
"naxis2",
"crval1",
"crval2",
"crpix1",
"crpix2",
"cdelt1",
"cdelt2",
"crota2",
"equinox",
"file");
fprintf(fcorr, fmt,
"int",
"char",
"char",
"int",
"int",
"double",
"double",
"double",
"double",
"double",
"double",
"double",
"int",
"char");
/************************************************/
/* Read the metadata and process each image WCS */
/************************************************/
namelen = 0;
nimages = 0;
ntotal = 0;
if(iscale >= 0)
sprintf(rfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f %%10s %%%ds\n", namelen+2);
else
sprintf(rfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f %%%ds\n", namelen+2);
sprintf(pfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f p%%%ds\n", namelen+2);
sprintf(cfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f c%%%ds\n", namelen+2);
while(1)
{
stat = tread();
if(stat < 0)
break;
++ntotal;
strcpy(input.ctype1, tval(ictype1));
strcpy(input.ctype2, tval(ictype2));
input.cntr = atoi(tval(icntr));
input.naxis1 = atoi(tval(ins));
input.naxis2 = atoi(tval(inl));
input.crpix1 = atof(tval(icrpix1));
input.crpix2 = atof(tval(icrpix2));
input.crval1 = atof(tval(icrval1));
input.crval2 = atof(tval(icrval2));
if(mode == CDELT)
{
input.cdelt1 = atof(tval(icdelt1));
input.cdelt2 = atof(tval(icdelt2));
input.crota2 = atof(tval(icrota2));
}
else
{
input.cd11 = atof(tval(icd11));
input.cd12 = atof(tval(icd12));
input.cd21 = atof(tval(icd21));
input.cd22 = atof(tval(icd22));
}
input.epoch = 2000;
strcpy(header, "");
sprintf(temp, "SIMPLE = T" ); stradd(header, temp);
sprintf(temp, "BITPIX = -64" ); stradd(header, temp);
sprintf(temp, "NAXIS = 2" ); stradd(header, temp);
sprintf(temp, "NAXIS1 = %d", input.naxis1 ); stradd(header, temp);
sprintf(temp, "NAXIS2 = %d", input.naxis2 ); stradd(header, temp);
sprintf(temp, "CTYPE1 = '%s'", input.ctype1 ); stradd(header, temp);
sprintf(temp, "CTYPE2 = '%s'", input.ctype2 ); stradd(header, temp);
sprintf(temp, "CRVAL1 = %11.6f", input.crval1 ); stradd(header, temp);
sprintf(temp, "CRVAL2 = %11.6f", input.crval2 ); stradd(header, temp);
sprintf(temp, "CRPIX1 = %11.6f", input.crpix1 ); stradd(header, temp);
sprintf(temp, "CRPIX2 = %11.6f", input.crpix2 ); stradd(header, temp);
if(mode == CDELT)
{
sprintf(temp, "CDELT1 = %11.6f", input.cdelt1 ); stradd(header, temp);
sprintf(temp, "CDELT2 = %11.6f", input.cdelt2 ); stradd(header, temp);
sprintf(temp, "CROTA2 = %11.6f", input.crota2 ); stradd(header, temp);
}
else
{
sprintf(temp, "CD1_1 = %11.6f", input.cd11 ); stradd(header, temp);
sprintf(temp, "CD1_2 = %11.6f", input.cd12 ); stradd(header, temp);
sprintf(temp, "CD2_1 = %11.6f", input.cd21 ); stradd(header, temp);
sprintf(temp, "CD2_2 = %11.6f", input.cd22 ); stradd(header, temp);
}
sprintf(temp, "EQUINOX = %d", input.equinox); stradd(header, temp);
sprintf(temp, "END" ); stradd(header, temp);
if(iequinox >= 0)
input.equinox = atoi(tval(iequinox));
strcpy(input.fname, fileName(tval(ifname)));
if(iscale >= 0)
strcpy(scale, tval(iscale));
if(strlen(input.fname) > namelen)
namelen = strlen(input.fname);
if(debug)
{
printf("Image header to wcsinit():\n%s\n", header);
fflush(stdout);
}
input.wcs = wcsinit(header);
checkWCS(input.wcs, 0);
if(input.wcs == (struct WorldCoor *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Bad WCS for image %d\"]\n",
nimages);
exit(1);
}
/***************************************************/
/* Check the boundaries of the input image against */
/* the output region of interest */
/***************************************************/
oxpixMin = 100000000;
oxpixMax = -100000000;
oypixMin = 100000000;
oypixMax = -100000000;
/* Check input left and right */
for (j=0; j<input.naxis2+1; ++j)
{
pix2wcs(input.wcs, 0.5, j+0.5, &xpos, &ypos);
convertCoordinates(input.sys, input.epoch, xpos, ypos,
output.sys, output.epoch, &lon, &lat, 0.0);
wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(oxpix < oxpixMin) oxpixMin = oxpix;
if(oxpix > oxpixMax) oxpixMax = oxpix;
if(oypix < oypixMin) oypixMin = oypix;
if(oypix > oypixMax) oypixMax = oypix;
}
pix2wcs(input.wcs, input.naxis1+0.5, j+0.5, &xpos, &ypos);
convertCoordinates(input.sys, input.epoch, xpos, ypos,
output.sys, output.epoch, &lon, &lat, 0.0);
wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(oxpix < oxpixMin) oxpixMin = oxpix;
if(oxpix > oxpixMax) oxpixMax = oxpix;
if(oypix < oypixMin) oypixMin = oypix;
if(oypix > oypixMax) oypixMax = oypix;
}
}
/* Check input top and bottom */
for (i=0; i<input.naxis1+1; ++i)
{
pix2wcs(input.wcs, i+0.5, 0.5, &xpos, &ypos);
convertCoordinates(input.sys, input.epoch, xpos, ypos,
output.sys, output.epoch, &lon, &lat, 0.0);
wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(oxpix < oxpixMin) oxpixMin = oxpix;
if(oxpix > oxpixMax) oxpixMax = oxpix;
if(oypix < oypixMin) oypixMin = oypix;
if(oypix > oypixMax) oypixMax = oypix;
}
pix2wcs(input.wcs, i+0.5, input.naxis2+0.5, &xpos, &ypos);
convertCoordinates(input.sys, input.epoch, xpos, ypos,
output.sys, output.epoch, &lon, &lat, 0.0);
wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(oxpix < oxpixMin) oxpixMin = oxpix;
if(oxpix > oxpixMax) oxpixMax = oxpix;
if(oypix < oypixMin) oypixMin = oypix;
if(oypix > oypixMax) oypixMax = oypix;
}
}
/***************************************************/
/* Check the boundaries of the region of interest */
/* against the input image */
/***************************************************/
/* Check ouput left and right */
for (j=0; j<output.wcs->nypix+1; ++j)
{
pix2wcs(output.wcs, 0.5, j+0.5, &xpos, &ypos);
convertCoordinates(output.sys, output.epoch, xpos, ypos,
input.sys, input.epoch, &lon, &lat, 0.0);
wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(0.5 < oxpixMin) oxpixMin = 0.5;
if(0.5 > oxpixMax) oxpixMax = 0.5;
if(j+0.5 < oypixMin) oypixMin = j+0.5;
if(j+0.5 > oypixMax) oypixMax = j+0.5;
}
pix2wcs(output.wcs, output.wcs->nxpix+0.5, j+0.5, &xpos, &ypos);
convertCoordinates(output.sys, output.epoch, xpos, ypos,
input.sys, input.epoch, &lon, &lat, 0.0);
wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(output.wcs->nxpix+0.5 < oxpixMin) oxpixMin = output.wcs->nxpix+0.5;
if(output.wcs->nxpix+0.5 > oxpixMax) oxpixMax = output.wcs->nxpix+0.5;
if(j+0.5 < oypixMin) oypixMin = j+0.5;
if(j+0.5 > oypixMax) oypixMax = j+0.5;
}
}
/* Check input top and bottom */
for (i=0; i<output.wcs->nxpix+1; ++i)
{
pix2wcs(output.wcs, i+0.5, 0.5, &xpos, &ypos);
convertCoordinates(output.sys, output.epoch, xpos, ypos,
input.sys, input.epoch, &lon, &lat, 0.0);
wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(i+0.5 < oxpixMin) oxpixMin = i+0.5;
if(i+0.5 > oxpixMax) oxpixMax = i+0.5;
if(0.5 < oypixMin) oypixMin = 0.5 ;
if(0.5 > oypixMax) oypixMax = 0.5 ;
}
pix2wcs(output.wcs, i+0.5, output.wcs->nypix+0.5, &xpos, &ypos);
convertCoordinates(output.sys, output.epoch, xpos, ypos,
input.sys, input.epoch, &lon, &lat, 0.0);
wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(i+0.5 < oxpixMin) oxpixMin = i+0.5;
if(i+0.5 > oxpixMax) oxpixMax = i+0.5;
if(output.wcs->nypix+0.5 < oypixMin) oypixMin = output.wcs->nypix+0.5;
if(output.wcs->nypix+0.5 > oypixMax) oypixMax = output.wcs->nypix+0.5;
}
}
if(oxpixMax < oxpixMin) continue;
if(oypixMax < oypixMin) continue;
/* Remove any possible compression extension */
strcpy(ofile, input.fname);
if(strlen(ofile) > 3 && strcmp(ofile+strlen(ofile)-3, ".gz") == 0)
ofile[strlen(ofile)-3] = '\0';
else if(strlen(ofile) > 2 && strcmp(ofile+strlen(ofile)-2, ".Z") == 0)
ofile[strlen(ofile)-2] = '\0';
else if(strlen(ofile) > 2 && strcmp(ofile+strlen(ofile)-2, ".z") == 0)
ofile[strlen(ofile)-2] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".zip") == 0)
ofile[strlen(ofile)-4] = '\0';
else if(strlen(ofile) > 2 && strcmp(ofile+strlen(ofile)-2, "-z") == 0)
ofile[strlen(ofile)-2] = '\0';
else if(strlen(ofile) > 3 && strcmp(ofile+strlen(ofile)-3, "-gz") == 0)
ofile[strlen(ofile)-3] = '\0';
/* Make sure the extension is ".fits" */
if(strlen(ofile) > 5 && strcmp(ofile+strlen(ofile)-5, ".fits") == 0)
ofile[strlen(ofile)-5] = '\0';
else if(strlen(ofile) > 5 && strcmp(ofile+strlen(ofile)-5, ".FITS") == 0)
ofile[strlen(ofile)-5] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".fit") == 0)
ofile[strlen(ofile)-4] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".FIT") == 0)
ofile[strlen(ofile)-4] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".fts") == 0)
ofile[strlen(ofile)-4] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".FTS") == 0)
ofile[strlen(ofile)-4] = '\0';
strcat(ofile, ".fits");
if(iscale >= 0)
{
fprintf(fraw, rfmt,
nimages+1,
output.wcs->ctype[0],
output.wcs->ctype[1],
oxpixMax - oxpixMin + 1,
oypixMax - oypixMin + 1,
output.wcs->crval[0],
output.wcs->crval[1],
output.wcs->crpix[0] - oxpixMin,
output.wcs->crpix[1] - oypixMin,
output.wcs->cdelt[0],
output.wcs->cdelt[1],
output.wcs->rot,
output.epoch,
scale,
ofile);
}
else
{
fprintf(fraw, rfmt,
nimages+1,
output.wcs->ctype[0],
output.wcs->ctype[1],
oxpixMax - oxpixMin + 1,
oypixMax - oypixMin + 1,
output.wcs->crval[0],
output.wcs->crval[1],
output.wcs->crpix[0] - oxpixMin,
output.wcs->crpix[1] - oypixMin,
output.wcs->cdelt[0],
output.wcs->cdelt[1],
output.wcs->rot,
output.epoch,
ofile);
}
fprintf(fproj, pfmt,
nimages+1,
output.wcs->ctype[0],
output.wcs->ctype[1],
oxpixMax - oxpixMin + 1,
oypixMax - oypixMin + 1,
output.wcs->crval[0],
output.wcs->crval[1],
output.wcs->crpix[0] - oxpixMin,
output.wcs->crpix[1] - oypixMin,
output.wcs->cdelt[0],
output.wcs->cdelt[1],
output.wcs->rot,
output.epoch,
ofile);
fprintf(fcorr, cfmt,
nimages+1,
output.wcs->ctype[0],
output.wcs->ctype[1],
oxpixMax - oxpixMin + 1,
oypixMax - oypixMin + 1,
output.wcs->crval[0],
output.wcs->crval[1],
output.wcs->crpix[0] - oxpixMin,
output.wcs->crpix[1] - oypixMin,
output.wcs->cdelt[0],
output.wcs->cdelt[1],
output.wcs->rot,
output.epoch,
ofile);
++nimages;
}
fclose(fraw);
fclose(fproj);
fclose(fcorr);
fprintf(fstatus, "[struct stat=\"OK\", count=\"%d\", total=\"%d\"]\n",
nimages, ntotal);
fflush(stdout);
exit(0);
}
int main(int argc, char **argv)
{
int i, j, k, ncol, nimages;
int haveHdr, itmp, istat, mAddCntr;
int nparents, parent, parent_prev;
int naxis1s, naxis2s;
char line [MAXSTR];
char mproj [MAXSTR];
char survey [MAXSTR];
char band [MAXSTR];
char hdrFile [MAXSTR];
char mosaicCentLon [MAXSTR];
char mosaicCentLat [MAXSTR];
char mosaicWidth [MAXSTR];
char mosaicHeight [MAXSTR];
char mosaicCdelt [MAXSTR];
char workdir [MAXSTR];
char urlbase [MAXSTR];
char workurlbase [MAXSTR];
char timestr [MAXSTR];
char cmd [MAXSTR];
char status [MAXSTR];
char msg [MAXSTR];
char fname [MAXSTR];
char fitname [MAXSTR];
char plusname [MAXSTR];
char minusname [MAXSTR];
char jobid [MAXSTR];
char fileList [MAXSTR];
char parentList [MAXSTR];
char sortedParent [MAXSTR];
char *fileid;
char *parentid;
clock_t timeval;
double width;
double height;
double cdelt;
double crval1, crval2;
double crpix1, crpix2;
int ifname, iurl, icntr1, icntr2, iplusname, iminusname, iscale;
int cntr, cntr1, cntr2, id, level;
int shrinkFactor, shrinkFactorX, shrinkFactorY;
double x, y, z;
double xc, yc, zc;
double xpos, ypos, dtr;
double dist, maxRadius;
double lonc, latc;
FILE *fp;
FILE *fdag;
FILE *ffit;
FILE *fcache;
FILE *furl;
FILE *ffile;
FILE *fparent;
char dv_version [MAXSTR];
int maxtbl = 1000;
char key[MAXSTR];
char val[MAXSTR];
struct stat type;
HT_table_t *depends;
char *path = getenv("MONTAGE_HOME");
/* Various time value variables */
char buffer[256];
int yr, mo, day, hr, min, sec, pid;
time_t curtime;
struct tm *loctime;
char idstr[256];
dtr = atan(1.0)/45.;
strcpy(dv_version, "1.0");
HT_set_debug(0);
/* Generate a unique ID based on data/time/pid */
curtime = time (NULL);
loctime = localtime (&curtime);
strftime(buffer, 256, "%Y", loctime);
yr = atoi(buffer);
strftime(buffer, 256, "%m", loctime);
mo = atoi(buffer);
strftime(buffer, 256, "%d", loctime);
day = atoi(buffer);
strftime(buffer, 256, "%H", loctime);
hr = atoi(buffer);
strftime(buffer, 256, "%M", loctime);
min = atoi(buffer);
strftime(buffer, 256, "%S", loctime);
sec = atoi(buffer);
pid = (int)getpid();
sprintf(idstr, "%04d%02d%02d_%02d%02d%02d_%d",
yr, mo, day, hr, min, sec, pid);
/* Set up the dependency hash table */
depends = HT_create_table(maxtbl);
timeval = time(0);
strcpy(timestr, ctime((const time_t *)(&timeval)));
for(i=0; i<strlen(timestr); ++i)
if(timestr[i] == '\n')
timestr[i] = '\0';
if(debug)
{
fdebug = fopen("debug.txt", "w+");
if(fdebug == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening debug file\"]\n");
exit(0);
}
fprintf(fdebug, "DEBUGGING mDAG:\n\n");
fflush(fdebug);
if(debug > 1)
svc_debug(fdebug);
}
/* Get the location/size information */
haveHdr = 0;
if(argc < 11)
{
printf("[struct stat=\"ERROR\", msg=\"Usage: %s survey band centerlon centerlat width height cdelt workdir workurlbase urlbase | %s -h survey band hdrfile workdir workurlbase urlbase (object/location string must be a single argument)\"]\n", argv[0], argv[0]);
exit(0);
}
strcpy(survey, argv[1]);
strcpy(band, argv[2]);
strcpy(mosaicCentLon, argv[3]);
strcpy(mosaicCentLat, argv[4]);
strcpy(mosaicWidth, argv[5]);
strcpy(mosaicHeight, argv[6]);
strcpy(mosaicCdelt, argv[7]);
strcpy(workdir, argv[8]);
strcpy(workurlbase, argv[9]);
strcpy(urlbase, argv[10]);
crval1 = atof(mosaicCentLon);
crval2 = atof(mosaicCentLat);
width = fabs(atof(mosaicWidth));
height = fabs(atof(mosaicHeight));
cdelt = fabs(atof(mosaicCdelt));
naxis1 = (int)(width / cdelt) + 0.5;
naxis2 = (int)(height / cdelt) + 0.5;
crpix1 = (naxis1+1.)/2.;
crpix2 = (naxis2+1.)/2.;
istat = stat(workdir, &type);
if(istat < 0)
printError("work directory doesn't exist");
strcpy(mproj, "mProject");
/********************************************************/
/* we have the size/center, we need to build the header */
/********************************************************/
/*******************************/
/* Create header template file */
/*******************************/
sprintf(hdrFile, "%s/region.hdr", workdir);
fp = fopen(hdrFile, "w+");
if(fp == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening header template file\"]\n");
exit(0);
}
fprintf(fp, "SIMPLE = T\n" );
fprintf(fp, "BITPIX = -64\n" );
fprintf(fp, "NAXIS = 2\n" );
fprintf(fp, "NAXIS1 = %d\n", naxis1 );
fprintf(fp, "NAXIS2 = %d\n", naxis2 );
fprintf(fp, "CTYPE1 = '%s'\n", "GLON-CAR" );
fprintf(fp, "CTYPE2 = '%s'\n", "GLAT-CAR" );
fprintf(fp, "CRVAL1 = %11.6f\n", crval1 );
fprintf(fp, "CRVAL2 = %11.6f\n", crval2 );
fprintf(fp, "CRPIX1 = %11.6f\n", crpix1 );
fprintf(fp, "CRPIX2 = %11.6f\n", crpix2 );
fprintf(fp, "CDELT1 = %.9f\n", -cdelt );
fprintf(fp, "CDELT2 = %.9f\n", cdelt );
fprintf(fp, "CROTA2 = %11.6f\n", 0.0 );
fprintf(fp, "EQUINOX = %d\n", 2000 );
if(strcasecmp(survey, "2MASS") == 0)
{
if(strcasecmp(band, "J") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 20.9044);
else if(strcasecmp(band, "H") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 20.4871);
else if(strcasecmp(band, "K") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 19.9757);
}
fprintf(fp, "END\n" );
fclose(fp);
/***********************************/
/* Create big header template file */
/***********************************/
sprintf(hdrFile, "%s/big_region.hdr", workdir);
fp = fopen(hdrFile, "w+");
if(fp == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening big header template file\"]\n");
exit(0);
}
fprintf(fp, "SIMPLE = T\n" );
fprintf(fp, "BITPIX = -64\n" );
fprintf(fp, "NAXIS = 2\n" );
fprintf(fp, "NAXIS1 = %d\n", naxis1+3000 );
fprintf(fp, "NAXIS2 = %d\n", naxis2+3000 );
fprintf(fp, "CTYPE1 = '%s'\n", "GLON-CAR" );
fprintf(fp, "CTYPE2 = '%s'\n", "GLAT-CAR" );
fprintf(fp, "CRVAL1 = %11.6f\n", crval1 );
fprintf(fp, "CRVAL2 = %11.6f\n", crval2 );
fprintf(fp, "CRPIX1 = %11.6f\n", crpix1+1500 );
fprintf(fp, "CRPIX2 = %11.6f\n", crpix2+1500 );
fprintf(fp, "CDELT1 = %.9f\n", -cdelt );
fprintf(fp, "CDELT2 = %.9f\n", cdelt );
fprintf(fp, "CROTA2 = %11.6f\n", 0.0 );
fprintf(fp, "EQUINOX = %d\n", 2000 );
if(strcasecmp(survey, "2MASS") == 0)
{
if(strcasecmp(band, "J") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 20.9044);
else if(strcasecmp(band, "H") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 20.4871);
else if(strcasecmp(band, "K") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 19.9757);
}
fprintf(fp, "END\n" );
fclose(fp);
/************************************************/
/* Get list of raw input images for this region */
/************************************************/
/* this is how mExec is implemented */
double scaleWidth = width * 1.42;
double scaleHeight = height * 1.42;
if(path)
sprintf(cmd, "%s/bin/mArchiveList %s %s \"%s %s gal\" %.2f %.2f %s/images.tbl",
path, survey, band, mosaicCentLon, mosaicCentLat, scaleWidth,
scaleHeight, workdir);
else
sprintf(cmd, "mArchiveList %s %s \"%s %s gal\" %.2f %.2f %s/images.tbl",
survey, band, mosaicCentLon, mosaicCentLat, scaleWidth,
scaleHeight, workdir);
if(debug)
{
fprintf(fdebug, "[%s]\n", cmd);
fflush(fdebug);
}
svc_run(cmd);
strcpy( status, svc_value( "stat" ));
if (strcmp( status, "ERROR") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
if (strcmp(status, "ABORT") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
nimages = atof(svc_value("count"));
if (nimages == 0)
{
sprintf( msg, "%s has no data covering this area", survey);
printError(msg);
}
/*****************************************/
/* Get the image lists the DAG will need */
/*****************************************/
if(path)
sprintf(cmd, "%s/bin/mDAGTbls %s/images.tbl %s/big_region.hdr %s/rimages.tbl %s/pimages.tbl %s/cimages.tbl",
path, workdir, workdir, workdir, workdir, workdir);
else
sprintf(cmd, "mDAGTbls %s/images.tbl %s/big_region.hdr %s/rimages.tbl %s/pimages.tbl %s/cimages.tbl",
workdir, workdir, workdir, workdir, workdir);
if(debug)
{
fprintf(fdebug, "[%s]\n", cmd);
fflush(fdebug);
}
svc_run(cmd);
strcpy( status, svc_value( "stat" ));
if (strcmp( status, "ERROR") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
/******************************************/
/* Get the overlap list the DAG will need */
/******************************************/
if(path)
sprintf(cmd, "%s/bin/mOverlaps %s/rimages.tbl %s/diffs.tbl",
path, workdir, workdir);
else
sprintf(cmd, " mOverlaps %s/rimages.tbl %s/diffs.tbl",
workdir, workdir);
if(debug)
{
fprintf(fdebug, "[%s]\n", cmd);
fflush(fdebug);
}
svc_run(cmd);
strcpy( status, svc_value( "stat" ));
if (strcmp( status, "ERROR") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
/****************************************************/
/* Determine shrink factor for presentation image. */
/****************************************************/
shrinkFactorX = (int)(naxis1 / 1024. + 1.);
shrinkFactorY = (int)(naxis2 / 1024. + 1.);
shrinkFactor = shrinkFactorX;
if(shrinkFactor < shrinkFactorY)
shrinkFactor = shrinkFactorY;
if(debug)
{
fprintf(fdebug, "\n");
fprintf(fdebug, "shrinkFactorX = %d\n", shrinkFactorX);
fprintf(fdebug, "shrinkFactorY = %d\n", shrinkFactorY);
fprintf(fdebug, "shrinkFactor = %d\n", shrinkFactor);
fprintf(fdebug, "\n");
fflush(fdebug);
}
/***********************************************/
/* Now we can generate the DAG XML file itself */
/* First the XML header */
/***********************************************/
if(debug)
{
fprintf(fdebug, "Generating DAG file header ...\n");
fflush(fdebug);
}
sprintf(cmd, "%s/dag.xml", workdir);
fdag = fopen(cmd, "w+");
sprintf(cmd, "%s/cache.list", workdir);
fcache = fopen(cmd, "w+");
sprintf(cmd, "%s/url.list", workdir);
furl = fopen(cmd, "w+");
fprintf(fdag, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
fprintf(fdag, "<!-- Generated: %s -->\n", timestr);
fprintf(fdag, "<!-- Generated by: Montage DAG service -->\n\n");
fprintf(fdag, "<adag xmlns=\"http://pegasus.isi.edu/schema/DAX\"\n");
fprintf(fdag, " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n");
fprintf(fdag, " xsi:schemaLocation=\"http://pegasus.isi.edu/schema/DAX http://pegasus.isi.edu/schema/dax-2.1.xsd\"\n");
fprintf(fdag, " version=\"2.1\" count=\"1\" index=\"0\" name=\"montage\">\n\n");
fflush(fdag);
fprintf(fdag, " <!-- Survey: %-30s -->\n", survey);
fprintf(fdag, " <!-- Band: %-30s -->\n", band);
fprintf(fdag, " <!-- Center Longitude: %-30s -->\n", mosaicCentLon);
fprintf(fdag, " <!-- Center Latitude: %-30s -->\n", mosaicCentLat);
if(haveHdr)
fprintf(fdag, " <!-- (WCS is in input header file) -->\n");
else
{
fprintf(fdag, " <!-- Width: %-30s -->\n", mosaicWidth);
fprintf(fdag, " <!-- Height: %-30s -->\n", mosaicHeight);
}
fprintf(fdag, "\n\n");
fflush(fdag);
/******************************************/
/* compose the url lfn cache list */
/******************************************/
sprintf(cmd, "%s/images.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
iurl = tcol("URL");
if(ifname < 0)
printError("'Raw' image list does not have column 'file'");
if(iurl < 0)
printError("'Raw' image list does not have column 'url'");
while(1)
{
istat = tread();
if(istat < 0)
break;
fprintf(furl, "%s %s pool=\"ipac_cluster\"\n", tval(ifname), tval(iurl));
}
tclose();
fclose(furl);
/******************************************/
/* DAG: "filename" lines for input images */
/******************************************/
if(debug)
{
fprintf(fdebug, "Generating DAG file filename list ...\n");
fflush(fdebug);
}
fprintf(fdag, " <!-- Part 1: Files Used -->\n\n");
sprintf(cmd, "%s/rimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Raw' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
fprintf(fdag, " <filename file=\"%s\" link=\"input\"/>\n", tval(ifname));
}
fprintf(fdag, "\n");
fflush(fdag);
tclose();
/**********************************************/
/* DAG: "filename" lines for projected images */
/* including area files */
/**********************************************/
sprintf(cmd, "%s/pimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Projected' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n", tval(ifname));
strcpy(fname, tval(ifname));
fname[strlen(fname)-5] = '\0';
strcat(fname, "_area.fits");
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n", fname);
}
fprintf(fdag, "\n");
fflush(fdag);
tclose();
/***********************************************/
/* DAG: "filename" lines for difference images */
/* and fit output files (plus one more file */
/* with a list of these fits) */
/***********************************************/
sprintf(cmd, "%s/diffs.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("diff");
icntr1 = tcol("cntr1");
icntr2 = tcol("cntr2");
if(ifname < 0)
printError("'Diff' image list does not have column 'diff'");
sprintf(cmd, "%s/statfile.tbl", workdir);
ffit = fopen(cmd, "w+");
sprintf(fmt, "|%%7s|%%7s|%%22s|\n");
sprintf(dfmt, " %%7d %%7d %%22s \n");
fprintf(ffit, fmt, "cntr1", "cntr2", "stat");
fprintf(ffit, fmt, "int", "int", "char");
while(1)
{
istat = tread();
if(istat < 0)
break;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
fprintf(fdag, " <filename file=\"%s\" link=\"output\"/>\n", tval(ifname));
strcpy(fname, tval(ifname));
fname[strlen(fname)-5] = '\0';
sprintf(fitname, "fit%s.txt", fname+4);
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n\n", fitname);
fprintf(ffit, dfmt, cntr1, cntr2, fitname);
}
fflush(fdag);
tclose();
fclose(ffit);
fprintf(fdag, " <filename file=\"statfile_%s.tbl\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"fits.tbl\" link=\"inout\"/>\n");
fprintf(fdag, "\n");
fflush(fdag);
fprintf(fcache, "statfile_%s.tbl %s/%s/statfile.tbl pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
/***********************************************/
/* DAG: "filename" lines for corrections table */
/* and the corrected image files (including */
/* area files) */
/***********************************************/
fprintf(fdag, " <filename file=\"corrections.tbl\" link=\"inout\"/>\n");
fprintf(fdag, "\n");
fflush(fdag);
sprintf(cmd, "%s/cimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Corrected' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n", tval(ifname));
strcpy(fname, tval(ifname));
fname[strlen(fname)-5] = '\0';
strcat(fname, "_area.fits");
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n", fname);
}
fprintf(fdag, "\n");
fflush(fdag);
tclose();
/***********************************************/
/* DAG: "filename" lines for template files, */
/* subset image files, output files, and */
/* shrunken output files. */
/***********************************************/
fprintf(fdag, " <filename file=\"newcimages.tbl\" link=\"inout\"/>\n");
fprintf(fdag, "\n");
fflush(fdag);
fprintf(fdag, " <filename file=\"big_region_%s.hdr\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"region_%s.hdr\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"pimages_%s.tbl\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"cimages_%s.tbl\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"dag_%s.xml\" link=\"inout\"/>\n", idstr);
fprintf(fdag, " <filename file=\"images_%s.tbl\" link=\"inout\"/>\n", idstr);
fprintf(fdag, "\n");
fprintf(fdag, " <filename file=\"shrunken_%s.hdr\" link=\"inout\"/>\n", idstr);
fprintf(fdag, " <filename file=\"shrunken_%s.fits\" link=\"inout\"/>\n", idstr);
fprintf(fdag, " <filename file=\"shrunken_%s.jpg\" link=\"output\"/>\n", idstr);
fprintf(fdag, "\n\n");
fflush(fdag);
fprintf(fcache, "big_region_%s.hdr %s/%s/big_region.hdr pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fprintf(fcache, "region_%s.hdr %s/%s/region.hdr pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fprintf(fcache, "pimages_%s.tbl %s/%s/pimages.tbl pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fprintf(fcache, "cimages_%s.tbl %s/%s/cimages.tbl pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fflush(fcache);
/* to be saved in user's storage space */
fprintf(fcache, "dag_%s.xml %s/%s/dag.xml pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fprintf(fcache, "images_%s.tbl %s/%s/images.tbl pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
/**************************************************/
/* DAG: "job" lines for mProject/mProjectPP jobs. */
/**************************************************/
if(debug)
{
fprintf(fdebug, "Generating DAG file job list ...\n");
fflush(fdebug);
}
id = 0;
level = 9;
fprintf(fdag, " <!-- Part 2: Definition of Jobs -->\n\n");
cntr = 0;
sprintf(cmd, "%s/rimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
iscale = tcol("scale");
if(ifname < 0)
printError("'Raw' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
++id;
++cntr;
strcpy(fname, tval(ifname));
fname[strlen(fname) - 5] = '\0';
fprintf(fdag," <job id=\"ID%06d\" name=\"%s\" version=\"3.0\" level=\"%d\" dv-name=\"mProject%d\" dv-version=\"1.0\">\n", id, mproj, level, cntr);
if(iscale >= 0)
fprintf(fdag," <argument>\n -X\n -x %s\n <filename file=\"%s.fits\"/>\n <filename file=\"p%s.fits\"/>\n <filename file=\"big_region_%s.hdr\"/>\n </argument>\n\n", tval(iscale), fname, fname, idstr);
else
fprintf(fdag," <argument>\n -X\n <filename file=\"%s.fits\"/>\n <filename file=\"p%s.fits\"/>\n <filename file=\"big_region_%s.hdr\"/>\n </argument>\n\n", fname, fname, idstr);
fprintf(fdag," <uses file=\"%s.fits\" link=\"input\" transfer=\"true\"/>\n", fname);
sprintf(key, "ID%06d", id);
sprintf(val, "%s.fits", fname);
HT_add_entry(depends, key, val);
fprintf(fcache,"%s.fits %s/%s.fits pool=\"ipac_cluster\"\n",fname,urlbase,fname);
fprintf(fdag," <uses file=\"p%s.fits\" link=\"output\" register=\"false\" transfer=\"false\"/>\n", fname);
sprintf(key, "p%s.fits", fname);
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag," <uses file=\"p%s_area.fits\" link=\"output\" register=\"false\" transfer=\"false\"/>\n", fname);
fprintf(fdag," <uses file=\"big_region_%s.hdr\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "big_region.hdr");
HT_add_entry(depends, key, val);
fprintf(fdag," </job>\n\n\n");
}
tclose();
fflush(fcache);
fclose(fcache);
/***************************************/
/* DAG: "job" lines for mDiffFit jobs. */
/***************************************/
cntr = 0;
sprintf(cmd, "%s/diffs.tbl", workdir);
ncol = topen(cmd);
icntr1 = tcol("cntr1");
icntr2 = tcol("cntr2");
iplusname = tcol("plus");
iminusname = tcol("minus");
--level;
while(1)
{
istat = tread();
if(istat < 0)
break;
++id;
++cntr;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
strcpy(plusname, tval(iplusname));
strcpy(minusname, tval(iminusname));
plusname [strlen(plusname) - 5] = '\0';
minusname[strlen(minusname) - 5] = '\0';
fname[strlen(fname) - 5] = '\0';
fprintf(fdag, " <job id=\"ID%06d\" name=\"mDiffFit\" version=\"3.0\" level=\"%d\" dv-name=\"mDiffFit%d\" dv-version=\"1.0\">\n", id, level, cntr);
fprintf(fdag, " <argument>\n -s <filename file=\"fit.%06d.%06d.txt\"/>\n <filename file=\"p%s.fits\"/>\n <filename file=\"p%s.fits\"/>\n <filename file=\"diff.%06d.%06d.fits\"/>\n <filename file=\"big_region_%s.hdr\"/>\n </argument>\n\n",
cntr1, cntr2, plusname, minusname, cntr1, cntr2, idstr);
fprintf(fdag, " <uses file=\"mDiff\" link=\"input\" transfer=\"true\" type=\"executable\"/>\n");
fprintf(fdag, " <uses file=\"mFitplane\" link=\"input\" transfer=\"true\" type=\"executable\"/>\n");
fprintf(fdag, " <uses file=\"fit.%06d.%06d.txt\" link=\"output\" register=\"false\" transfer=\"false\"/>\n",
cntr1, cntr2);
sprintf(key, "fit.%06d.%06d.txt", cntr1, cntr2);
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"p%s.fits\" link=\"input\" transfer=\"true\"/>\n",
plusname);
sprintf(key, "ID%06d", id);
sprintf(val, "p%s.fits", plusname);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"p%s_area.fits\" link=\"input\" transfer=\"true\"/>\n",
plusname);
fprintf(fdag, " <uses file=\"p%s.fits\" link=\"input\" transfer=\"true\"/>\n",
minusname);
sprintf(key, "ID%06d", id);
sprintf(val, "p%s.fits", minusname);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"p%s_area.fits\" link=\"input\" transfer=\"true\"/>\n",
minusname);
fprintf(fdag, " <uses file=\"diff.%06d.%06d.fits\" link=\"output\" register=\"false\" transfer=\"false\" optional=\"true\"/>\n", cntr1, cntr2);
sprintf(key, "diff.%06d.%06d.fits", cntr1, cntr2);
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"big_region_%s.hdr\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "big_region.hdr");
HT_add_entry(depends, key, val);
fprintf(fdag, " </job>\n\n\n");
}
tclose();
/****************************************/
/* DAG: "job" line for mConcatFit jobs. */
/****************************************/
++id;
--level;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mConcatFit\" version=\"3.0\" level=\"%d\" dv-name=\"mConcatFit1\" dv-version=\"1.0\">\n", id, level);
fprintf(fdag, " <argument>\n <filename file=\"statfile_%s.tbl\"/>\n <filename file=\"fits.tbl\"/>\n .\n </argument>\n\n", idstr);
fprintf(fdag, " <uses file=\"statfile_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "statfile.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"fits.tbl\" link=\"output\" register=\"false\" transfer=\"false\"/>\n");
sprintf(key, "fits.tbl");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
sprintf(cmd, "%s/diffs.tbl", workdir);
ncol = topen(cmd);
icntr1 = tcol("cntr1");
icntr2 = tcol("cntr2");
while(1)
{
istat = tread();
if(istat < 0)
break;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
fprintf(fdag, " <uses file=\"fit.%06d.%06d.txt\" link=\"input\" transfer=\"true\"/>\n",
cntr1, cntr2);
sprintf(key, "ID%06d", id);
sprintf(val, "fit.%06d.%06d.txt", cntr1, cntr2);
HT_add_entry(depends, key, val);
}
tclose();
fprintf(fdag, " </job>\n\n\n");
/*************************************/
/* DAG: "job" line for mBgModel job. */
/*************************************/
++id;
--level;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mBgModel\" version=\"3.0\" level=\"%d\" dv-name=\"mBgModel1\" dv-version=\"1.0\">\n", id, level);
fprintf(fdag, " <argument>\n -l\n -i 100000\n <filename file=\"pimages_%s.tbl\"/>\n <filename file=\"fits.tbl\"/>\n <filename file=\"corrections.tbl\"/>\n </argument>\n\n", idstr);
fprintf(fdag, " <uses file=\"pimages_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "pimages.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"fits.tbl\" link=\"input\" transfer=\"true\"/>\n");
sprintf(key, "ID%06d", id);
sprintf(val, "fits.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"corrections.tbl\" link=\"output\" register=\"false\" transfer=\"false\"/>\n");
sprintf(key, "corrections.tbl");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " </job>\n\n\n");
/*****************************************/
/* DAG: "job" line for mBackground jobs. */
/*****************************************/
--level;
cntr = 0;
sprintf(cmd, "%s/rimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Raw' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
strcpy(fname, tval(ifname));
fname[strlen(fname) - 5] = '\0';
++id;
++cntr;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mBackground\" version=\"3.0\" level=\"%d\" dv-name=\"mBackground%d\" dv-version=\"1.0\">\n", id, level, cntr);
fprintf(fdag, " <argument>\n -t\n <filename file=\"p%s.fits\"/>\n <filename file=\"c%s.fits\"/>\n <filename file=\"pimages_%s.tbl\"/>\n <filename file=\"corrections.tbl\"/>\n </argument>\n\n",
fname, fname, idstr);
fprintf(fdag, " <uses file=\"p%s.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
sprintf(key, "ID%06d", id);
sprintf(val, "p%s.fits", fname);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"p%s_area.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
fprintf(fdag, " <uses file=\"pimages_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "pimages.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"corrections.tbl\" link=\"input\" transfer=\"true\"/>\n");
sprintf(key, "ID%06d", id);
sprintf(val, "corrections.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"c%s.fits\" link=\"output\" register=\"false\" transfer=\"false\"/>\n",
fname);
sprintf(key, "c%s.fits", fname);
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"c%s_area.fits\" link=\"output\" register=\"false\" transfer=\"false\"/>\n",
fname);
fprintf(fdag, " </job>\n\n\n");
}
fflush(fdag);
/**********************************************/
/* DAG: "job" lines for tile mImgtbl jobs. */
/* We have to regenerate the cimages table(s) */
/* because the pixel offsets and sizes need */
/* to be exactly right and the original is */
/* only an approximation. */
/**********************************************/
--level;
cntr = 0;
++id;
++cntr;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mImgtbl\" version=\"3.0\" level=\"%d\" dv-name=\"mImgtbl%d\" dv-version=\"1.0\">\n",
id, level, cntr);
fprintf(fdag, " <argument>\n .\n -t <filename file=\"cimages_%s.tbl\"/>\n <filename file=\"newcimages.tbl\"/>\n </argument>\n\n", idstr);
fprintf(fdag, " <uses file=\"cimages_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "cimages.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"newcimages.tbl\" link=\"output\" register=\"false\" transfer=\"false\"/>\n");
sprintf(key, "newcimages.tbl");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
sprintf(cmd, "%s/cimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Corrected' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
strcpy(fname, tval(ifname));
fname[strlen(fname) - 5] = '\0';
fprintf(fdag, " <uses file=\"%s.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
sprintf(key, "ID%06d", id);
sprintf(val, "%s.fits", fname);
HT_add_entry(depends, key, val);
}
tclose();
fprintf(fdag, " </job>\n\n\n");
fflush(fdag);
/*******************************************/
/* DAG: "job" lines for tile mAdd jobs. */
/*******************************************/
--level;
cntr = 0;
++id;
++cntr;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mAdd\" version=\"3.0\" level=\"%d\" dv-name=\"mAdd%d\" dv-version=\"1.0\">\n",
id, level, cntr);
fprintf(fdag, " <argument>\n -e\n <filename file=\"newcimages.tbl\"/>\n <filename file=\"region_%s.hdr\"/>\n <filename file=\"mosaic_%s.fits\"/>\n </argument>\n\n", idstr, idstr);
fprintf(fdag, " <uses file=\"newcimages.tbl\" link=\"input\" transfer=\"true\"/>\n");
sprintf(key, "ID%06d", id);
sprintf(val, "newcimages.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"region_%s.hdr\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "region.hdr");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"mosaic_%s.fits\" link=\"output\" register=\"true\" transfer=\"true\"/>\n", idstr);
sprintf(key, "mosaic.fits");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"mosaic_%s_area.fits\" link=\"output\" register=\"true\" transfer=\"true\"/>\n", idstr);
sprintf(cmd, "%s/cimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Corrected' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
strcpy(fname, tval(ifname));
fname[strlen(fname) - 5] = '\0';
fprintf(fdag, " <uses file=\"%s.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
fprintf(fdag, " <uses file=\"%s_area.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
sprintf(key, "ID%06d", id);
sprintf(val, "%s.fits", fname);
HT_add_entry(depends, key, val);
}
fprintf(fdag, " </job>\n\n\n");
fflush(fdag);
mAddCntr = cntr;
/*******************************************/
/* DAG: "job" lines for tile mShrink jobs. */
/*******************************************/
--level;
cntr = 0;
++id;
++cntr;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mShrink\" version=\"3.0\" level=\"%d\" dv-name=\"mShrink%d\" dv-version=\"1.0\">\n", id, level, cntr);
fprintf(fdag, " <argument>\n <filename file=\"mosaic_%s.fits\"/>\n <filename file=\"shrunken_%s.fits\"/>\n %d\n </argument>\n\n", idstr, idstr, shrinkFactor);
fprintf(fdag, " <uses file=\"mosaic_%s.fits\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "mosaic.fits");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"shrunken_%s.fits\" link=\"output\" register=\"true\" transfer=\"true\"/>\n", idstr);
sprintf(key, "shrunken.fits");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " </job>\n\n\n");
fflush(fdag);
/****************************/
/* DAG: Make the final JPEG */
/****************************/
++id;
--level;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mJPEG\" version=\"3.0\" level=\"%d\" dv-name=\"mJPEG1\" dv-version=\"1.0\">\n", id, level);
fprintf(fdag, " <argument>\n -ct 1\n -gray <filename file=\"shrunken_%s.fits\"/>\n min max gaussianlog\n -out <filename file=\"shrunken_%s.jpg\"/>\n </argument>\n\n", idstr, idstr);
fprintf(fdag, " <uses file=\"shrunken_%s.fits\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "shrunken.fits");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"shrunken_%s.jpg\" link=\"output\" register=\"true\" transfer=\"true\"/>\n", idstr);
sprintf(key, "shrunken.jpg");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"dag_%s.xml\" link=\"input\" transfer=\"true\"/>\n", idstr);
fprintf(fdag, " <uses file=\"dag_%s.xml\" link=\"output\" register=\"false\" transfer=\"true\"/>\n", idstr);
sprintf(key, "dag.xml");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"images_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
fprintf(fdag, " <uses file=\"images_%s.tbl\" link=\"output\" register=\"false\" transfer=\"true\"/>\n", idstr);
sprintf(key, "images.tbl");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " </job>\n\n\n\n");
fflush(fdag);
/*******************************************/
/* DAG: Flow control dependencies. */
/* First, mDiffs depend on mProjects */
/*******************************************/
if(debug)
{
fprintf(fdebug, "Generating DAG file parent/child info ...\n");
fflush(fdebug);
}
fprintf(fdag, " <!-- Part 3: Control-Flow Dependencies -->\n\n");
sprintf(fileList, "%s/files.lis", workdir);
sprintf(parentList, "%s/parents.lis", workdir);
sprintf(sortedParent, "%s/sortedParents.lis", workdir);
for(i=1; i<=id; ++i)
{
sprintf(jobid, "ID%06d", i);
fileid = HT_lookup_key(depends, jobid);
ffile = fopen(fileList, "w+");
if(ffile == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening working file list for write\"]\n");
exit(0);
}
while(fileid != (char *)NULL)
{
fprintf(ffile, "%s\n", fileid);
fflush(ffile);
fileid = HT_next_entry(depends);
}
fclose(ffile);
ffile = fopen(fileList, "r");
if(ffile == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening working file list for read\"]\n");
exit(0);
}
fparent = fopen(parentList, "w+");
if(fparent == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening parent list\"]\n");
exit(0);
}
nparents = 0;
fprintf(fparent, "| parent |\n");
while(1)
{
if(fgets(line, MAXSTR, ffile) == (char *)NULL)
break;
if(line[strlen(line)-1] == '\n')
line[strlen(line)-1] = '\0';
parentid = HT_lookup_key(depends, line);
while(parentid != (char *)NULL)
{
parent = atoi(parentid+2);
fprintf(fparent, " %12d\n", parent);
fflush(fparent);
++nparents;
parentid = HT_next_entry(depends);
}
}
fclose(ffile);
fclose(fparent);
unlink(fileList);
if(nparents > 0)
{
if(path)
sprintf(cmd, "%s/bin/mTblSort %s parent %s", path, parentList, sortedParent);
else
sprintf(cmd, "mTblSort %s parent %s", parentList, sortedParent);
svc_run(cmd);
strcpy( status, svc_value( "stat" ));
if (strcmp( status, "ERROR") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
unlink(parentList);
fparent = fopen(sortedParent, "r");
if(fparent == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening sorted parent list\"]\n");
exit(0);
}
fgets(line, MAXSTR, fparent);
fprintf(fdag, " <child ref=\"%s\">\n", jobid);
for(j=0; j<nparents; ++j)
{
if(fgets(line, MAXSTR, fparent) == (char *)NULL)
break;
parent_prev = parent;
parent = atoi(line);
if(j > 0 && parent == parent_prev)
continue;
fprintf(fdag, " <parent ref=\"ID%06d\"/>\n", parent);
}
fprintf(fdag, " </child>\n\n");
fflush(fdag);
fclose(fparent);
}
unlink(sortedParent);
}
fprintf(fdag, "</adag>\n");
fflush(fdag);
fclose(fdag);
if(debug)
{
fprintf(fdebug, "done.\n");
fflush(fdebug);
}
printf("[struct stat=\"OK\", id=\"%s\"]\n", idstr);
exit(0);
}
int
proc_rule(struct htx_data *phtx_info, struct ruleinfo *prule_info,
char *wbuf, char *rbuf, struct blk_num_typ *pblk_num)
{
int dlen, loop, rc;
char msg[220], path[100];
unsigned short seed[3];
rc = 0;
init_seed(seed); /* initialize seed for random number generator */
dlen = prule_info->num_blks * BLK_SIZE; /* initialize length of data */
/*-------------------------------*/
/* initialize the write buffer */
/*-------------------------------*/
if ( (prule_info->pattern_id[0] != '#') &&
(prule_info->pattern_id[0] != 0) ) {
path[0] ='\0';
if ( (int) htx_strlen((char *) htx_strcpy(path, getenv("HTXPATTERNS"))) == 0 )
htx_strcpy(path, "../pattern/"); /* default ONLY */
htx_strcat (path, prule_info->pattern_id);
rc = hxfpat(path, wbuf, dlen);
if ( rc == 1 ) {
sprintf(msg, "cannot open pattern file - %s\n", path);
hxfmsg(phtx_info, 0, SYSERR, msg);
return(1);
}
if ( rc == 2 ) {
sprintf(msg, "cannot read pattern file - %s\n", path);
hxfmsg(phtx_info, 0, SYSERR, msg);
return(1);
}
} else if ( prule_info->pattern_id[0] == '#' )
bldbuf((unsigned short*)wbuf, dlen, prule_info->pattern_id, pblk_num);
pblk_num->in_rule = 0; /* initialize block number within current rule */
rc = 0;
tape_error_code = 0;
for ( loop = 1; loop <= prule_info->num_oper; loop++ ) {
if ( strcmp(prule_info->oper, "R") == 0 ) {
rc = read_tape(phtx_info, prule_info, loop, pblk_num, rbuf);
} else if ( strcmp(prule_info->oper, "W") == 0 ) {
rc = write_tape(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "RC") == 0 ) {
rc = read_tape(phtx_info, prule_info, loop, pblk_num, rbuf);
if ( rc >= 0 )
rc = cmpbuf(phtx_info, prule_info, loop, pblk_num, wbuf, rbuf);
} else if ( strcmp(prule_info->oper, "RW") == 0 ) {
rc = rewind_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "WEOF") == 0 ) {
rc = weof_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "SF") == 0 ) {
rc = search_file(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "SR") == 0 ) {
rc = search_rec(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "D") == 0 ) {
rc = diag_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "E") == 0 ) {
rc = erase_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "S") == 0 ) {
rc = do_sleep(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "CO") == 0 ) {
rc = close_open(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "C") == 0 ) {
rc = tclose(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "O") == 0 ) {
rc = topen(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "WEOT") == 0 ) {
rc = write_eot(phtx_info, prule_info,loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "RCEOT") == 0 ) {
rc = read_eot(phtx_info, prule_info, loop,pblk_num, wbuf, rbuf);
} else if ( strcmp(prule_info->oper, "REOT") == 0 ) {
rc = read_teot(phtx_info, prule_info, loop, pblk_num, wbuf, rbuf);
} else if ( strcmp(prule_info->oper, "RS") == 0 ) {
rc = prt_req_sense(phtx_info, prule_info, loop, pblk_num);
}
#ifndef __HTX_LINUX__
else if ( strcmp(prule_info->oper, "ML") == 0 ) {
rc = medium_load(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "MUL") == 0 ) {
rc = medium_unload(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "RES") == 0 ) {
rc = read_status(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "IE") == 0 ) {
rc = init_element(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "RP") == 0 ) {
rc = read_posit(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "LB") == 0 ) {
rc = loc_block(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "ASF") == 0 ) {
rc = asearch_file(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "ASR") == 0 ) {
rc = asearch_rec(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "ADUL") == 0 ) {
rc = write_unload(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "TWIE") == 0 ) {
rc = twin_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "TWPE") == 0 ) {
rc = twps_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "TWRE") == 0 ) {
rc = twrd_stat(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "TWMM") == 0 ) {
rc = twmv_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "TWUL") == 0 ) {
rc = unload_write(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "WUL") == 0 ) {
rc = tape_unload(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "CDRE") == 0 ) {
rc = cdrd_stat(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "CDMM") == 0 ) {
rc = cdmv_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "HUNL") == 0 ) {
rc = himove(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "HINI") == 0 ) {
rc = hiinit(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "HREL") == 0 ) {
rc = hielem(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "HWUN") == 0 ) {
rc = hidal_unload(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "DBUG") == 0 ) {
rc = set_dbug(phtx_info, prule_info, pblk_num);
}
#endif
else if ( strcmp(prule_info->oper, "XCMD") == 0 ) {
rc = do_cmd(phtx_info, prule_info, pblk_num);
} else {
;
}
hxfupdate(UPDATE, phtx_info);
if ( phtx_info->run_type[0] == 'O' ) {
info_msg(phtx_info, prule_info, loop, pblk_num, msg);
hxfmsg(phtx_info, 0, INFO, msg);
}
if ( rc != 0 )
break;
}
return(rc);
}
int main(int argc, char **argv)
{
int ch, stat, ncols, count, failed, missing, warning;
int icntr1;
int icntr2;
int istatfile;
int cntr1;
int cntr2;
char statfile[MAXSTR];
char tblfile [MAXSTR];
char fitfile [MAXSTR];
char statdir [MAXSTR];
char line [MAXSTR];
char msg [MAXSTR];
char val [MAXSTR];
char status [32];
double a;
double b;
double c;
double crpix1;
double crpix2;
int xmin;
int xmax;
int ymin;
int ymax;
double xcenter;
double ycenter;
double npixel;
double rms;
double boxx;
double boxy;
double boxwidth;
double boxheight;
double boxangle;
FILE *fstat;
FILE *fout;
SVC *svc=NULL;
/***************************************/
/* Process the command-line parameters */
/***************************************/
debug = 0;
opterr = 0;
fstatus = stdout;
while ((ch = getopt(argc, argv, "ds:")) != EOF)
{
switch (ch)
{
case 'd':
debug = 1;
break;
case 's':
if((fstatus = fopen(optarg, "w+")) == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Cannot open status file: %s\"]\n",
optarg);
exit(1);
}
break;
default:
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d] [-s statusfile] statfiles.tbl fits.tbl statdir\"]\n", argv[0]);
exit(1);
break;
}
}
if (argc - optind < 3)
{
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d] [-s statusfile] statfiles.tbl fits.tbl statdir\"]\n", argv[0]);
exit(1);
}
strcpy(tblfile, argv[optind]);
strcpy(fitfile, argv[optind + 1]);
strcpy(statdir, argv[optind + 2]);
fout = fopen(fitfile, "w+");
if(fout == (FILE *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Can't open output file.\"]\n");
fflush(stdout);
exit(1);
}
/**************************************************/
/* Open the difference fit status file list table */
/**************************************************/
ncols = topen(tblfile);
if(ncols <= 0)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid statfiles metadata file: %s\"]\n",
tblfile);
exit(1);
}
icntr1 = tcol( "cntr1");
icntr2 = tcol( "cntr2");
istatfile = tcol( "stat");
if(icntr1 < 0
|| icntr2 < 0
|| istatfile < 0)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Need columns: cntr1 cntr2 plus minus diff\"]\n");
exit(1);
}
/***************************************/
/* Read the records and call mFitPlane */
/***************************************/
count = 0;
failed = 0;
missing = 0;
warning = 0;
fprintf(fout, "| plus|minus| a | b | c | crpix1 | crpix2 | xmin | xmax | ymin | ymax | xcenter | ycenter | npixel | rms | boxx | boxy | boxwidth | boxheight | boxang |\n");
fflush(fout);
while(1)
{
stat = tread();
if(stat < 0)
break;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
strcpy(statfile, statdir);
strcat(statfile, "/");
strcat(statfile, tval(istatfile));
if(checkFile(statfile))
{
++count;
++missing;
continue;
}
fstat = fopen(statfile, "r");
if(fstat == (FILE *)NULL)
{
++count;
++missing;
continue;
}
if(fgets(line, MAXSTR, fstat) == (char *)NULL)
{
++count;
++missing;
continue;
}
svc=svc_struct(line);
strcpy( status, svc_val(line, "stat", val));
if(strcmp( status, "ABORT") == 0)
{
strcpy( msg, svc_val(line, "msg", val ));
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"%s\"]\n", msg);
fflush(stdout);
exit(1);
}
++count;
if(strcmp( status, "ERROR") == 0)
++failed;
else if(strcmp( status, "WARNING") == 0)
++warning;
else
{
a = atof(svc_val(line, "a", val));
b = atof(svc_val(line, "b", val));
c = atof(svc_val(line, "c", val));
crpix1 = atof(svc_val(line, "crpix1", val));
crpix2 = atof(svc_val(line, "crpix2", val));
xmin = atoi(svc_val(line, "xmin", val));
xmax = atoi(svc_val(line, "xmax", val));
ymin = atoi(svc_val(line, "ymin", val));
ymax = atoi(svc_val(line, "ymax", val));
xcenter = atof(svc_val(line, "xcenter", val));
ycenter = atof(svc_val(line, "ycenter", val));
npixel = atof(svc_val(line, "npixel", val));
rms = atof(svc_val(line, "rms", val));
boxx = atof(svc_val(line, "boxx", val));
boxy = atof(svc_val(line, "boxy", val));
boxwidth = atof(svc_val(line, "boxwidth", val));
boxheight = atof(svc_val(line, "boxheight", val));
boxangle = atof(svc_val(line, "boxang", val));
fprintf(fout, " %5d %5d %12.5e %12.5e %12.5e %9.2f %9.2f %6d %6d %6d %6d %9.2f %9.2f %9.0f %12.5e %12.1f %12.1f %12.1f %12.1f %12.1f\n",
cntr1, cntr2, a, b, c, crpix1, crpix2, xmin, xmax, ymin, ymax,
xcenter, ycenter, npixel, rms, boxx, boxy, boxwidth, boxheight, boxangle);
fflush(fout);
}
svc_free(svc);
fclose(fstat);
}
fprintf(fstatus, "[struct stat=\"OK\", count=%d, failed=%d, missing=%d, warning=%d]\n", count, failed, missing, warning);
fflush(stdout);
exit(0);
}
int main(int argc, char **argv)
{
int debug, noAreas, i;
int tableDriven, haveStatus;
int icntr, ifname, cntr;
int ncols, index, istat;
int ia, ib, ic, id;
double A, B, C;
char input_file [MAXSTR];
char output_file[MAXSTR];
char tblfile [MAXSTR];
char corrfile [MAXSTR];
char file [MAXSTR];
char *end;
struct mBackgroundReturn *returnStruct;
FILE *montage_status;
/***************************************/
/* Process the command-line parameters */
/***************************************/
debug = 0;
tableDriven = 0;
noAreas = 0;
haveStatus = 0;
montage_status = stdout;
for(i=0; i<argc; ++i)
{
if(strcmp(argv[i], "-s") == 0)
{
haveStatus = 1;
if(i+1 >= argc)
{
printf("[struct stat=\"ERROR\", msg=\"No status file name given\"]\n");
exit(1);
}
if((montage_status = fopen(argv[i+1], "w+")) == (FILE *)NULL)
{
printf ("[struct stat=\"ERROR\", msg=\"Cannot open status file: %s\"]\n",
argv[i+1]);
exit(1);
}
++i;
}
else if(strcmp(argv[i], "-n") == 0)
noAreas = 1;
else if(strcmp(argv[i], "-t") == 0)
tableDriven = 1;
else if(strcmp(argv[i], "-d") == 0)
{
if(i+1 >= argc)
{
printf("[struct stat=\"ERROR\", msg=\"No debug level given\"]\n");
exit(1);
}
debug = strtol(argv[i+1], &end, 0);
if(end - argv[i+1] < strlen(argv[i+1]))
{
printf("[struct stat=\"ERROR\", msg=\"Debug level string is invalid: '%s'\"]\n", argv[i+1]);
exit(1);
}
if(debug < 0)
{
printf("[struct stat=\"ERROR\", msg=\"Debug level value cannot be negative\"]\n");
exit(1);
}
++i;
}
}
if(haveStatus)
{
argv += 2;
argc -= 2;;
}
if(debug)
{
argv += 2;
argc -= 2;;
}
if(noAreas)
{
++argv;
--argc;
}
if(tableDriven)
{
++argv;
--argc;
}
if (argc < 5)
{
printf ("[struct stat=\"ERROR\", msg=\"Usage: mBackground [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits A B C | mBackground [-t(able-mode)] [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits images.tbl corrfile.tbl\"]\n");
exit(1);
}
strcpy(input_file, argv[1]);
if(input_file[0] == '-')
{
printf ("[struct stat=\"ERROR\", msg=\"Invalid input file '%s'\"]\n", input_file);
exit(1);
}
strcpy(output_file, argv[2]);
if(output_file[0] == '-')
{
printf ("[struct stat=\"ERROR\", msg=\"Invalid output file '%s'\"]\n", output_file);
exit(1);
}
A = 0.;
B = 0.;
C = 0.;
if(!tableDriven)
{
if (argc != 6)
{
printf ("[struct stat=\"ERROR\", msg=\"Usage: mBackground [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits A B C | mBackground [-t](able-mode) [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits images.tbl corrfile.tbl\"]\n");
exit(1);
}
A = strtod(argv[3], &end);
if(end < argv[3] + strlen(argv[3]))
{
printf ("[struct stat=\"ERROR\", msg=\"A coefficient string is not a number\"]\n");
exit(1);
}
B = strtod(argv[4], &end);
if(end < argv[4] + strlen(argv[4]))
{
printf ("[struct stat=\"ERROR\", msg=\"B coefficient string is not a number\"]\n");
exit(1);
}
C = strtod(argv[5], &end);
if(end < argv[5] + strlen(argv[5]))
{
printf ("[struct stat=\"ERROR\", msg=\"C coefficient string is not a number\"]\n");
exit(1);
}
}
else
{
/* Look up the file cntr in the images.tbl file */
/* and then the correction coefficients in the */
/* corrections table generated by mBgModel */
if (argc != 5)
{
printf ("[struct stat=\"ERROR\", msg=\"Usage: mBackground [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits A B C | mBackground [-t](able-mode) [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits images.tbl corrfile.tbl\"]\n");
exit(1);
}
strcpy(tblfile, argv[3]);
strcpy(corrfile, argv[4]);
/* Open the image list table file */
ncols = topen(tblfile);
if(ncols <= 0)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"Invalid image metadata file: %s\"]\n",
tblfile);
exit(1);
}
icntr = tcol( "cntr");
ifname = tcol( "fname");
if(ifname < 0)
ifname = tcol( "file");
if(icntr < 0
|| ifname < 0)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"Image table needs columns cntr and fname\"]\n");
exit(1);
}
/* Read the records and find the cntr for our file name */
index = 0;
while(1)
{
istat = tread();
if(istat < 0)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"Hit end of image table without finding file name\"]\n");
exit(1);
}
cntr = atoi(tval(icntr));
strcpy(file, tval(ifname));
if(strcmp(file, input_file) == 0)
break;
}
tclose();
ncols = topen(corrfile);
icntr = tcol( "id");
ia = tcol( "a");
ib = tcol( "b");
ic = tcol( "c");
if(icntr < 0
|| ia < 0
|| ib < 0
|| ic < 0)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"Need columns: id,a,b,c in corrections file\"]\n");
exit(1);
}
/* Read the records and find the correction coefficients */
while(1)
{
istat = tread();
if(istat < 0)
{
A = 0.;
B = 0.;
C = 0.;
break;
}
id = atoi(tval(icntr));
if(id != cntr)
continue;
A = atof(tval(ia));
B = atof(tval(ib));
C = atof(tval(ic));
break;
}
tclose();
}
returnStruct = mBackground(input_file, output_file, A, B, C, noAreas, debug);
if(returnStruct->status == 1)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"%s\"]\n", returnStruct->msg);
exit(1);
}
else
{
fprintf(montage_status, "[struct stat=\"OK\", %s]\n", returnStruct->msg);
exit(0);
}
}
