sint32 treadn(int fd, uint8 *buf, uint32 nbytes, unsigned int timout)
{
uint32 nleft;
sint32 nread;
nleft = nbytes;
while (nleft > 0)
{
if ((nread = tread(fd, buf, nleft, timout)) < 0)
{
if (nleft == nbytes)
{
return(-1); /* error, return -1 */
}
else
{
break; /* error, return amount read so far */
}
}
else if (nread == 0)
{
break; /* EOF */
}
nleft -= nread;
buf += nread;
}
return (nbytes - nleft); /* return >= 0 */
}
rt_public char *app_tread(size_t *size)
/* Filled in with size of read string */
{
/* Read bytes from the "pipe" and put them into a new allocated buffer.
* Returns the address of that buffer or a null pointer in case of errors.
*/
return tread(app_sp, size);
}
// 经测试如果是[02 FF FE 91 0A 02 06 05 04 FF FD]，可以解析；
// 如果是[02 FF FF FE 91 0A 02 06 05 04 FF FD]，则不能解析。所以不能连续出现两个及以上的FF
// 从串口读数据
void BTM_Recv_BtmA(void)
{
uint32 i = 0;
sint32 num = 0; // recv data number
uint8 btmHead_1 = 0;
uint8 btmHead_2 = 0;
sint32 rst = 0;
int j;
// init req frame
BTM_ReqFrameInit();
// 从串口读取1字节数据
num = tread(btmAFd, &btmHead_1, 1, BTM_UART_RECV_TIMEOUT);
// DBG_INFO("[BTM] receive btmhead_1 = %02x\n", btmHead_1 );
// if btmhead_1 correct, then continue recv head_2
if ((num == 1) && (btmHead_1 == SINO_FRAME_HEAD_1))
{
num = tread(btmAFd, &btmHead_2, 1, BTM_UART_RECV_TIMEOUT);
// receive sino btm correct header
if ((num == 1) && (btmHead_2 == SINO_FRAME_HEAD_2))
{
for (i = 0; i < BTM_RECV_BUF_SIZE; i++)
{
tread(btmAFd, &btmARecvBuf[i], 1, BTM_UART_RECV_TIMEOUT);
// receive sino btm correct footer
if ((btmARecvBuf[i - 1] == SINO_FRAME_FOOT_1) && (btmARecvBuf[i] == SINO_FRAME_FOOT_2))
{
//DBG_INFO("[BTM] btm receive req frame footer\n");
// parse vobc req, i-2 means not include packet header
BTM_ParseSinoReqPacket_BtmA(btmARecvBuf, btmAReqframeBuf, (i - 2));
//DBG_INFO("[BTM] btm req frame buf size %d\n", rst);
// unpack vobc req frame
BTM_UnpackRecvPacket_BtmA();
break;
}
}
}
}
else
{
// if not receive req or timeout, then init req packet
BTM_ReqFrameInit();
}
}
task main()
{
while(true){
checkMode();
drive();
tread();
wheel();
}
}
BOOL CRarArchive::IsArchive()
//---------------------------
{
struct MarkHeader MarkHead;
int SFXLen,ArcType;
SFXLen=ArcType=SolidType=LockedType=0;
ArcFormat=0;
if (tread(MarkHead.Mark,SIZEOF_MARKHEAD)!=SIZEOF_MARKHEAD) return FALSE;
if (MarkHead.Mark[0]==0x52 && MarkHead.Mark[1]==0x45 &&
MarkHead.Mark[2]==0x7e && MarkHead.Mark[3]==0x5e)
{
ArcFormat=OLD;
tseek(0,SEEK_SET);
ReadHeader(MAIN_HEAD);
ArcType=(OldMhd.Flags & MHD_MULT_VOL) ? VOL : ARC;
} else
if (MarkHead.Mark[0]==0x52 && MarkHead.Mark[1]==0x61 &&
MarkHead.Mark[2]==0x72 && MarkHead.Mark[3]==0x21 &&
MarkHead.Mark[4]==0x1a && MarkHead.Mark[5]==0x07 &&
MarkHead.Mark[6]==0x00)
{
ArcFormat=NEW;
if (ReadHeader(MAIN_HEAD)!=SIZEOF_NEWMHD) return FALSE;
ArcType = (NewMhd.Flags & MHD_MULT_VOL) ? VOL : ARC;
}
if (ArcFormat==OLD)
{
MainHeadSize=SIZEOF_OLDMHD;
NewMhd.Flags=OldMhd.Flags & 0x3f;
NewMhd.HeadSize=OldMhd.HeadSize;
} else
{
MainHeadSize=SIZEOF_NEWMHD;
if ((UWORD)~HeaderCRC!=NewMhd.HeadCRC)
{
// Warning
return FALSE; //?
}
}
if (NewMhd.Flags & MHD_SOLID) SolidType=1;
if (NewMhd.Flags & MHD_LOCK) LockedType=1;
return (ArcType) ? TRUE : FALSE;
}
/*
* Read data from the printer, possibly increasing the buffer.
* Returns offset of end of data in buffer or -1 on failure.
*
* LOCKING: none.
*/
ssize_t readmore(int sockfd, char **bpp, int off, int *bszp)
{
ssize_t nr;
char *bp = *bpp;
int bsz = *bszp;
if (off >= bsz) {
bsz += IOBUFSZ;
if ((bp = realloc(*bpp, bsz)) == NULL)
log_sys("readmore: can't allocate bigger read buffer");
*bszp = bsz;
*bpp = bp;
}
if ((nr = tread(sockfd, &bp[off], bsz-off, 1)) < 0)
return(off+nr);
else
return(-1);
}
int readreq()
{
int r;
if (skipsp()) goto readend;
c = suck();
if (c == EOF) goto readend;
if (c == '\n') goto readend;
if (c == '.') {
while (1) {
c = suck();
if (c == EOF) break;
if (c == '\n') break;
}
goto readend;
}
r = c << 9;
c = suck();
if (c != EOF) {
if (c != '\n') {
r = r | c;
}
}
if (r==0157150) c = tread(ohead); /* oh */
if (r==0163160) { /* sp */
o_sp=nread();
writebreak();
}
if (r==0164141) do_ta(); /* ta */
if (r==0165154) o_ul=nread(); /* ul */
while (1) {
if (c == EOF) break;
if (c == '\n') break;
c= suck();
}
readend:
if (c != EOF)
return(1);
else
return(0);
}
static void
to_data_new(struct tor_conn *tc)
{
int from, to, amnt;
char *buf;
from = tc->from;
to = tc->to;
while (1) {
int ret;
cbuf_t cb;
if (!(buf = cbuf_alloc(BUFF_SZ, &cb))) BUG();
amnt = tread(cos_spd_id(), to, cb, BUFF_SZ-1);
if (0 == amnt) break;
else if (-EPIPE == amnt) {
goto close;
} else if (amnt < 0) {
printc("read from fd %d produced %d.\n", from, amnt);
BUG();
}
assert(amnt <= BUFF_SZ);
if (amnt != (ret = from_twrite(cos_spd_id(), from, cb, amnt))) {
printc("conn_mgr: write failed w/ %d of %d on fd %d\n",
ret, amnt, to);
goto close;
}
cbuf_free(buf);
}
done:
cbuf_free(buf);
return;
close:
mapping_remove(from, to, tc->feid, tc->teid);
from_trelease(cos_spd_id(), from);
trelease(cos_spd_id(), to);
assert(tc->feid && tc->teid);
evt_put(tc->feid);
evt_put(tc->teid);
goto done;
}
/*
* "Timed" read - timout specifies the number of seconds to wait
* per read call before giving up, but read exactly nbytes bytes.
* Returns number of bytes read or -1 on error.
*
* LOCKING: none.
*/
ssize_t
treadn(int fd, void *buf, size_t nbytes, unsigned int timout)
{
size_t nleft;
ssize_t nread;
nleft = nbytes;
while (nleft > 0) {
if ((nread = tread(fd, buf, nleft, timout)) < 0) {
if (nleft == nbytes)
return(-1); /* error, return -1 */
else
break; /* error, return amount read so far */
} else if (nread == 0) {
break; /* EOF */
}
nleft -= nread;
buf += nread;
}
return(nbytes - nleft); /* return >= 0 */
}
/*
* The TTY might be turning \n into \r. For now, just
* pretend it's working. The 8-bit test will fail with a
* good error message.
*/
static char*
rdln(Fd *fd)
{
int i=0;
static char buf[BUFSZ+1];
do{
if(tread(fd, &buf[i], 1) <= 0)
break;
if(buf[i] == '\r')
buf[i] = '\n';
if(buf[i++] == '\n')
break;
}while(i < BUFSZ);
if(i == 0)
return nil;
buf[i] = '\0';
return buf;
}
/*
* Read and parse the response from the printer. Return 1
* if the request was successful, and 0 otherwise.
*
* LOCKING: none.
*/
int
printer_status(int sfd, struct job *jp)
{
int i, success, code, len, found, bufsz, datsz;
int32_t jobid;
ssize_t nr;
char *bp, *cp, *statcode, *reason, *contentlen;
struct ipp_hdr *hp;
/*
* Read the HTTP header followed by the IPP response header.
* They can be returned in multiple read attempts. Use the
* Content-Length specifier to determine how much to read.
*/
success = 0;
bufsz = IOBUFSZ;
if ((bp = malloc(IOBUFSZ)) == NULL)
log_sys("printer_status: can't allocate read buffer");
while ((nr = tread(sfd, bp, bufsz, 5)) > 0) {
/*
* Find the status. Response starts with "HTTP/x.y"
* so we can skip the first 8 characters.
*/
cp = bp + 8;
datsz = nr;
while (isspace((int)*cp))
cp++;
statcode = cp;
while (isdigit((int)*cp))
cp++;
if (cp == statcode) { /* Bad format; log it and move on */
log_msg(bp);
} else {
*cp++ = '\0';
reason = cp;
while (*cp != '\r' && *cp != '\n')
cp++;
*cp = '\0';
code = atoi(statcode);
if (HTTP_INFO(code))
continue;
if (!HTTP_SUCCESS(code)) { /* probable error: log it */
bp[datsz] = '\0';
log_msg("error: %s", reason);
break;
}
/*
* HTTP request was okay, but still need to check
* IPP status. Search for the Content-Length.
*/
i = cp - bp;
for (;;) {
while (*cp != 'C' && *cp != 'c' && i < datsz) {
cp++;
i++;
}
if (i >= datsz) { /* get more header */
if ((nr = readmore(sfd, &bp, i, &bufsz)) < 0) {
goto out;
} else {
cp = &bp[i];
datsz += nr;
}
}
if (strncasecmp(cp, "Content-Length:", 15) == 0) {
cp += 15;
while (isspace((int)*cp))
cp++;
contentlen = cp;
while (isdigit((int)*cp))
cp++;
*cp++ = '\0';
i = cp - bp;
len = atoi(contentlen);
break;
} else {
cp++;
i++;
}
}
if (i >= datsz) { /* get more header */
if ((nr = readmore(sfd, &bp, i, &bufsz)) < 0) {
goto out;
} else {
cp = &bp[i];
datsz += nr;
}
}
found = 0;
while (!found) { /* look for end of HTTP header */
while (i < datsz - 2) {
if (*cp == '\n' && *(cp + 1) == '\r' &&
*(cp + 2) == '\n') {
found = 1;
cp += 3;
i += 3;
break;
}
cp++;
i++;
}
if (i >= datsz) { /* get more header */
if ((nr = readmore(sfd, &bp, i, &bufsz)) < 0) {
goto out;
} else {
cp = &bp[i];
datsz += nr;
}
}
}
if (datsz - i < len) { /* get more header */
if ((nr = readmore(sfd, &bp, i, &bufsz)) < 0) {
goto out;
} else {
cp = &bp[i];
datsz += nr;
}
}
hp = (struct ipp_hdr *)cp;
i = ntohs(hp->status);
jobid = ntohl(hp->request_id);
if (jobid != jp->jobid) {
/*
* Different jobs. Ignore it.
*/
log_msg("jobid %d status code %d", jobid, i);
break;
}
if (STATCLASS_OK(i))
success = 1;
break;
}
}
out:
free(bp);
if (nr < 0) {
log_msg("jobid %d: error reading printer response: %s",
jobid, strerror(errno));
}
return(success);
}
/*
* Accept a print job from a client.
*
* LOCKING: none.
*/
void *
client_thread(void *arg)
{
int n, fd, sockfd, nr, nw, first;
int32_t jobid;
pthread_t tid;
struct printreq req;
struct printresp res;
char name[FILENMSZ];
char buf[IOBUFSZ];
tid = pthread_self();
pthread_cleanup_push(client_cleanup, (void *)((long)tid));
sockfd = (long)arg;
add_worker(tid, sockfd);
/*
* Read the request header.
*/
if ((n = treadn(sockfd, &req, sizeof(struct printreq), 10)) !=
sizeof(struct printreq)) {
res.jobid = 0;
if (n < 0)
res.retcode = htonl(errno);
else
res.retcode = htonl(EIO);
strncpy(res.msg, strerror(res.retcode), MSGLEN_MAX);
writen(sockfd, &res, sizeof(struct printresp));
pthread_exit((void *)1);
}
req.size = ntohl(req.size);
req.flags = ntohl(req.flags);
/*
* Create the data file.
*/
jobid = get_newjobno();
sprintf(name, "%s/%s/%d", SPOOLDIR, DATADIR, jobid);
fd = creat(name, FILEPERM);
if (fd < 0) {
res.jobid = 0;
res.retcode = htonl(errno);
log_msg("client_thread: can't create %s: %s", name,
strerror(res.retcode));
strncpy(res.msg, strerror(res.retcode), MSGLEN_MAX);
writen(sockfd, &res, sizeof(struct printresp));
pthread_exit((void *)1);
}
/*
* Read the file and store it in the spool directory.
* Try to figure out if the file is a PostScript file
* or a plain text file.
*/
first = 1;
while ((nr = tread(sockfd, buf, IOBUFSZ, 20)) > 0) {
if (first) {
first = 0;
if (strncmp(buf, "%!PS", 4) != 0)
req.flags |= PR_TEXT;
}
nw = write(fd, buf, nr);
if (nw != nr) {
res.jobid = 0;
if (nw < 0)
res.retcode = htonl(errno);
else
res.retcode = htonl(EIO);
log_msg("client_thread: can't write %s: %s", name,
strerror(res.retcode));
close(fd);
strncpy(res.msg, strerror(res.retcode), MSGLEN_MAX);
writen(sockfd, &res, sizeof(struct printresp));
unlink(name);
pthread_exit((void *)1);
}
}
close(fd);
/*
* Create the control file. Then write the
* print request information to the control
* file.
*/
sprintf(name, "%s/%s/%d", SPOOLDIR, REQDIR, jobid);
fd = creat(name, FILEPERM);
if (fd < 0) {
res.jobid = 0;
res.retcode = htonl(errno);
log_msg("client_thread: can't create %s: %s", name,
strerror(res.retcode));
strncpy(res.msg, strerror(res.retcode), MSGLEN_MAX);
writen(sockfd, &res, sizeof(struct printresp));
sprintf(name, "%s/%s/%d", SPOOLDIR, DATADIR, jobid);
unlink(name);
pthread_exit((void *)1);
}
nw = write(fd, &req, sizeof(struct printreq));
if (nw != sizeof(struct printreq)) {
res.jobid = 0;
if (nw < 0)
res.retcode = htonl(errno);
else
res.retcode = htonl(EIO);
log_msg("client_thread: can't write %s: %s", name,
strerror(res.retcode));
close(fd);
strncpy(res.msg, strerror(res.retcode), MSGLEN_MAX);
writen(sockfd, &res, sizeof(struct printresp));
unlink(name);
sprintf(name, "%s/%s/%d", SPOOLDIR, DATADIR, jobid);
unlink(name);
pthread_exit((void *)1);
}
close(fd);
/*
* Send response to client.
*/
res.retcode = 0;
res.jobid = htonl(jobid);
sprintf(res.msg, "request ID %d", jobid);
writen(sockfd, &res, sizeof(struct printresp));
/*
* Notify the printer thread, clean up, and exit.
*/
log_msg("adding job %d to queue", jobid);
add_job(&req, jobid);
pthread_cleanup_pop(1);
return((void *)0);
}
static void
service(int cfd, int sfd, int dfd)
{
Fcall f;
int r;
Fid* fp;
fidpool = allocfidpool(nop);
for(;;){
fp = nil;
r = getfcall(cfd, &f);
if (r <= 0){
fprint(dfd, "trfs: getfcall %r\n");
break;
}
if(verbose)
fprint(dfd , "c→s %F\n", &f);
switch(f.type){
case Tclunk:
case Tremove:
// BUG in lib9p? removefid leaks fid.
// is that what it should do?
fp = lookupfid(fidpool, f.fid);
if (fp != nil){
removefid(fidpool, f.fid);
closefid(fp);
closefid(fp);
fp = nil;
}
break;
case Tcreate:
tcreate(&f);
// and also...
case Topen:
fp = allocfid(fidpool, f.fid);
fp->aux = 0;
break;
case Tread:
tread(&f);
break;
case Twalk:
twalk(&f);
break;
case Twstat:
twstat(&f);
break;
}
if(verbose && debug)
fprint(dfd , "c→s %F\n", &f);
if (putfcall(sfd, &f) < 0)
fprint(dfd , "can't putfcall: %r\n");
r = getfcall(sfd, &f);
if (r <= 0){
fprint(dfd, "trfs: 2nd getfcall %r\n");
break;
}
if (verbose)
fprint(dfd, "c←s %F\n", &f);
switch(f.type){
case Ropen:
case Rcreate:
fp->qid = f.qid;
break;
case Rread:
rread(&f);
break;
case Rstat:
rstat(&f);
break;
}
if(verbose && debug)
fprint(dfd , "c←s %F\n", &f);
if (putfcall(cfd, &f) < 0)
fprint(dfd , "can't 2n dputfcall: %r\n");
if (fp != nil)
closefid(fp);
}
}
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 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 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);
}
bool GlobalGrid::read( std::ifstream &ifs ){ // reads the grid
clear();
std::string T;
ifs >> T;
if ( !(T.compare( "num_dimensions:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 1" << endl; ifs.close(); clear(); return false; }
ifs >> num_dimensions;
ifs >> T; if ( !(T.compare( "num_outputs:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 2" << endl; ifs.close(); clear(); return false; }
ifs >> num_outputs;
ifs >> T; if ( !(T.compare( "alpha:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 3" << endl; ifs.close(); clear(); return false; }
tread( 1, &alpha, ifs );
ifs >> T; if ( !(T.compare( "beta:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 4" << endl; ifs.close(); clear(); return false; }
tread( 1, &beta, ifs );
ifs >> T; if ( !(T.compare( "ruleType:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 6" << endl; ifs.close(); clear(); return false; }
ifs >> T;
if ( T.compare("lagrange-chebyshev") == 0 ){ ruleType = rule_chebyshev; }else
if ( T.compare("lagrange-clenshaw-curtis") == 0 ){ ruleType = rule_clenshawcurtis; }else
if ( T.compare("lagrange-chebyshev-nested-twopoint") == 0 ){ ruleType = rule_chebyshevN2P; }else
if ( T.compare("lagrange-gauss-legendre") == 0 ){ ruleType = rule_gausslegendre; }else
if ( T.compare("lagrange-gauss-chebyshev1") == 0 ){ ruleType = rule_gausschebyshev1; }else
if ( T.compare("lagrange-gauss-chebyshev2") == 0 ){ ruleType = rule_gausschebyshev2; }else
if ( T.compare("lagrange-fejer2") == 0 ){ ruleType = rule_fejer2; }else
if ( T.compare("lagrange-gauss-gegenbauer") == 0 ){ ruleType = rule_gaussgegenbauer; }else
if ( T.compare("lagrange-gauss-jacobi") == 0 ){ ruleType = rule_gaussjacobi; }else
if ( T.compare("lagrange-gauss-laguerre") == 0 ){ ruleType = rule_gausslaguerre; }else
if ( T.compare("lagrange-gauss-hermite") == 0 ){ ruleType = rule_gausshermite; }else{
cerr << "ERROR: Wrong File Format! code GG 7" << endl; ifs.close(); clear(); return false;
}
ifs >> T; if ( !(T.compare( "Anisotropic:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 8" << endl; ifs.close(); clear(); return false; }
ifs >> T;
if ( T.compare("yes") == 0 ){
anisotropic = new int[num_dimensions+1];
tread( num_dimensions+1, anisotropic, ifs );
//tensorList = new IndexSet( num_dimensions, 0, num_outputs ); tensorList->read( ifs );
}
ifs >> T; if ( !(T.compare( "Tensors:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 9" << endl; ifs.close(); clear(); return false; }
ifs >> T;
if ( T.compare("yes") == 0 ){
tensorList = new IndexSet( num_dimensions, 0, num_outputs ); tensorList->read( ifs );
}
ifs >> T; if ( !(T.compare( "TensorWeights:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 10" << endl; ifs.close(); clear(); return false; }
ifs >> T;
if ( T.compare("yes") == 0 ){
tensor_weights = new int[tensorList->getNumIndexes()]; tread( tensorList->getNumIndexes(), tensor_weights, ifs );
}
ifs >> T; if ( !(T.compare( "Points:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 11" << endl; ifs.close(); clear(); return false; }
ifs >> T;
if ( T.compare("yes") == 0 ){
points = new IndexSet( num_dimensions, 0, num_outputs ); points->read( ifs );
}
ifs >> T; if ( !(T.compare( "NeededPoints:" ) == 0) ){ cerr << "ERROR: Wrong File Format! code GG 12" << endl; ifs.close(); clear(); return false; }
ifs >> T;
if ( T.compare( "yes" ) == 0 ){
needed_points = new IndexSet( num_dimensions, 0, num_outputs );
needed_points->read( ifs );
}else{
needed_points = 0;
}
makeOnedRule( computeMaxLevel() + 1 );
makeTensorsArray();
if ( num_outputs > 0 ){
for( int t=0; t<tensorList->getNumIndexes(); t++ ){
if ( tensor_weights[t] != 0 ){
tensorRules[t].referenceValues( points );
}
}
}
return true;
}
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);
}
}
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);
}
/*
* Assumes pipe is buffered at least 257 characters,
* so both sides can send and then receive.
*/
int
banner(Replica *r, char *name)
{
int i;
char c, *p;
char buf[257];
dbg(DbgRpc, "sending tracmd\n");
qlock(&r->rlock);
qlock(&r->wlock);
/* both sides send tracmd */
if(twrite(r->wfd, tracmd, sizeof tracmd-1) < 0
|| twflush(r->wfd) == -1){
werrstr("writing banner: %r");
err:
qunlock(&r->wlock);
qunlock(&r->rlock);
return -1;
}
dbg(DbgRpc, "waiting for tracmd\n");
while((p = rdln(r->rfd)) != nil){
if(strcmp(tracmd, p) == 0)
break;
if(name)
fprint(2, "%s# %s", name, p);
}
if(p == nil){
werrstr("did not receive initial banner");
goto err;
}
dbg(DbgRpc, "sending antissh\n");
/* both sides send \n~?\n~.\n */
if(twrite(r->wfd, antissh, sizeof antissh-1) < 0
|| twflush(r->wfd) == -1){
werrstr("writing antissh: %r");
goto err;
}
dbg(DbgRpc, "waiting for antissh\n");
if(readln(r->rfd, "\n")<0 || readln(r->rfd, "~?\n")<0 || readln(r->rfd, "~.\n") < 0){
werrstr("corrupt anti-ssh banner");
goto err;
}
dbg(DbgRpc, "sending byte map\n");
/* both sides send 0x00, 0x01, ..., 0xFF, 0x00 */
/* the second 0x00 gives us a way to notice 0xFF being dropped */
for(i=0; i<257; i++)
buf[i] = i;
if(twrite(r->wfd, buf, sizeof buf) < 0 || twflush(r->wfd) == -1){
werrstr("short channel test write: %r");
goto err;
}
dbg(DbgRpc, "receiving byte map\n");
/* could be more efficient but doesn't matter */
for(i=0; i < sizeof buf; i++){
if(tread(r->rfd, &c, 1) != 1){
werrstr("8-bit test: expected 0x%x, got eof", buf[i]);
goto err;
}
if(c != buf[i]){
werrstr("8-bit test: expected 0x%x, got 0x%x", buf[i], c);
goto err;
}
}
//fprint(2, "%s: pass\n", argv0);
qunlock(&r->wlock);
qunlock(&r->rlock);
return 0;
}
