static intBool CheckRangeConstraint(
void *theEnv,
EXEC_STATUS,
int type,
void *vPtr,
CONSTRAINT_RECORD *constraints)
{
struct expr *minList, *maxList;
/*===================================*/
/* If the constraint record is NULL, */
/* there are no range restrictions. */
/*===================================*/
if (constraints == NULL) return(TRUE);
/*============================================*/
/* If the value being checked isn't a number, */
/* then the range restrictions don't apply. */
/*============================================*/
if ((type != INTEGER) && (type != FLOAT)) return(TRUE);
/*=====================================================*/
/* Check each of the range restrictions to see if the */
/* number falls within at least one of the allowed */
/* ranges. If it falls within one of the ranges, then */
/* return TRUE since the constraint is satisifed. */
/*=====================================================*/
minList = constraints->minValue;
maxList = constraints->maxValue;
while (minList != NULL)
{
if (CompareNumbers(theEnv,execStatus,type,vPtr,minList->type,minList->value) == LESS_THAN)
{
minList = minList->nextArg;
maxList = maxList->nextArg;
}
else if (CompareNumbers(theEnv,execStatus,type,vPtr,maxList->type,maxList->value) == GREATER_THAN)
{
minList = minList->nextArg;
maxList = maxList->nextArg;
}
else
{ return(TRUE); }
}
/*===========================================*/
/* Return FALSE since the number didn't fall */
/* within one of the allowed numeric ranges. */
/*===========================================*/
return(FALSE);
}
// smart name comparison (case insensitive); it treats all consecutive digits as a single character
// with value equal to the number
//
extern bool NameIsLess(const TCHAR* p, const TCHAR* q)
{
for ( ; *p && *q; ++p, ++q)
{
if (*p == *q)
continue;
unsigned int c1= _totlower(*p);
unsigned int c2= _totlower(*q);
if (c1 == c2)
continue;
if (c1 >= '0' && c1 <= '9' && c2 >= '0' && c2 <= '9')
{
int cmp= CompareNumbers(p, q);
if (cmp < 0)
return true;
else if (cmp > 0)
return false;
else
continue;
}
return c1 < c2;
}
if (*p == 0)
{
if (*q == 0)
return false;
else
return true;
}
else
{
if (*q == 0)
return false;
else
{ ASSERT(false); }
// return true;
}
ASSERT(false);
return false;
}
static intBool ParseRangeCardinalityAttribute(
void *theEnv,
char *readSource,
CONSTRAINT_RECORD *constraints,
CONSTRAINT_PARSE_RECORD *parsedConstraints,
char *constraintName,
int multipleValuesAllowed)
{
struct token inputToken;
int range;
char *tempPtr = NULL;
/*=================================*/
/* Determine if we're parsing the */
/* range or cardinality attribute. */
/*=================================*/
if (strcmp(constraintName,"range") == 0)
{
parsedConstraints->range = TRUE;
range = TRUE;
}
else
{
parsedConstraints->cardinality = TRUE;
range = FALSE;
}
/*===================================================================*/
/* The cardinality attribute can only be used with multifield slots. */
/*===================================================================*/
if ((range == FALSE) &&
(multipleValuesAllowed == FALSE))
{
PrintErrorID(theEnv,"CSTRNPSR",5,TRUE);
EnvPrintRouter(theEnv,WERROR,"The cardinality attribute ");
EnvPrintRouter(theEnv,WERROR,"can only be used with multifield slots.\n");
return(FALSE);
}
/*====================================================*/
/* The range attribute is not allowed with the */
/* allowed-values/numbers/integers/floats attributes. */
/*====================================================*/
if ((range == TRUE) &&
(parsedConstraints->allowedValues ||
parsedConstraints->allowedNumbers ||
parsedConstraints->allowedIntegers ||
parsedConstraints->allowedFloats))
{
if (parsedConstraints->allowedValues) tempPtr = "allowed-values";
else if (parsedConstraints->allowedIntegers) tempPtr = "allowed-integers";
else if (parsedConstraints->allowedFloats) tempPtr = "allowed-floats";
else if (parsedConstraints->allowedNumbers) tempPtr = "allowed-numbers";
NoConjunctiveUseError(theEnv,"range",tempPtr);
return(FALSE);
}
/*==========================*/
/* Parse the minimum value. */
/*==========================*/
SavePPBuffer(theEnv," ");
GetToken(theEnv,readSource,&inputToken);
if ((inputToken.type == INTEGER) || ((inputToken.type == FLOAT) && range))
{
if (range)
{
ReturnExpression(theEnv,constraints->minValue);
constraints->minValue = GenConstant(theEnv,inputToken.type,inputToken.value);
}
else
{
ReturnExpression(theEnv,constraints->minFields);
constraints->minFields = GenConstant(theEnv,inputToken.type,inputToken.value);
}
}
else if ((inputToken.type == SF_VARIABLE) && (strcmp(inputToken.printForm,"?VARIABLE") == 0))
{ /* Do nothing. */ }
else
{
char tempBuffer[120];
gensprintf(tempBuffer,"%s attribute",constraintName);
SyntaxErrorMessage(theEnv,tempBuffer);
return(FALSE);
}
/*==========================*/
/* Parse the maximum value. */
/*==========================*/
SavePPBuffer(theEnv," ");
GetToken(theEnv,readSource,&inputToken);
if ((inputToken.type == INTEGER) || ((inputToken.type == FLOAT) && range))
{
if (range)
{
ReturnExpression(theEnv,constraints->maxValue);
constraints->maxValue = GenConstant(theEnv,inputToken.type,inputToken.value);
}
else
{
ReturnExpression(theEnv,constraints->maxFields);
constraints->maxFields = GenConstant(theEnv,inputToken.type,inputToken.value);
}
}
else if ((inputToken.type == SF_VARIABLE) && (strcmp(inputToken.printForm,"?VARIABLE") == 0))
{ /* Do nothing. */ }
else
{
char tempBuffer[120];
gensprintf(tempBuffer,"%s attribute",constraintName);
SyntaxErrorMessage(theEnv,tempBuffer);
return(FALSE);
}
/*================================*/
/* Parse the closing parenthesis. */
/*================================*/
GetToken(theEnv,readSource,&inputToken);
if (inputToken.type != RPAREN)
{
SyntaxErrorMessage(theEnv,"range attribute");
return(FALSE);
}
/*====================================================*/
/* Minimum value must be less than the maximum value. */
/*====================================================*/
if (range)
{
if (CompareNumbers(theEnv,constraints->minValue->type,
constraints->minValue->value,
constraints->maxValue->type,
constraints->maxValue->value) == GREATER_THAN)
{
PrintErrorID(theEnv,"CSTRNPSR",2,TRUE);
EnvPrintRouter(theEnv,WERROR,"Minimum range value must be less than\n");
EnvPrintRouter(theEnv,WERROR,"or equal to the maximum range value\n");
return(FALSE);
}
}
else
{
if (CompareNumbers(theEnv,constraints->minFields->type,
constraints->minFields->value,
constraints->maxFields->type,
constraints->maxFields->value) == GREATER_THAN)
{
PrintErrorID(theEnv,"CSTRNPSR",2,TRUE);
EnvPrintRouter(theEnv,WERROR,"Minimum cardinality value must be less than\n");
EnvPrintRouter(theEnv,WERROR,"or equal to the maximum cardinality value\n");
return(FALSE);
}
}
/*====================================*/
/* Return TRUE to indicate that the */
/* attribute was successfully parsed. */
/*====================================*/
return(TRUE);
}
int main (int argc, char **argv) {
char *inlist; /* input file name */
char *outlist; /* output blev file name */
/*int switch_on = 0;*/ /* was any switch specified? */
int printtime = NO; /* print time after each step? */
int verbose = NO; /* print additional info? */
int quiet = NO; /* print additional info? */
int too_many = 0; /* too many command-line arguments? */
int i, j; /* loop indexes */
int k;
IRAFPointer i_imt, o_imt; /* imt list pointers */
char *input; /* name of input science file */
char *output; /* name of output file */
int n_in, n_out; /* number of files in each list */
int n;
/* Input and output suffixes. */
char isuffix[] = "_raw";
char osuffix[] = "_blv_tmp";
/* A structure to pass the calibration switches to ACSCCD */
CalSwitch ccd_sw;
/* reference file keywords and names */
RefFileInfo refnames;
void InitRefFile (RefFileInfo *);
void FreeRefFile (RefFileInfo *);
void initSwitch (CalSwitch *);
int ACSccd (char *, char *, CalSwitch *, RefFileInfo *, int, int);
int DefSwitch (char *);
int MkName (char *, char *, char *, char *, char *, int);
void WhichError (int);
int CompareNumbers (int, int, char *);
/* For image header access */
Hdr phdr;
int LoadHdr (char *, Hdr *);
int GetSwitch (Hdr *, char *, int *);
c_irafinit (argc, argv);
/* Allocate space for file names. */
inlist = calloc (ACS_LINE+1, sizeof (char));
outlist = calloc (ACS_LINE+1, sizeof (char));
input = calloc (ACS_LINE+1, sizeof (char));
output = calloc (ACS_LINE+1, sizeof (char));
if (inlist == NULL || outlist == NULL ||
input == NULL || output == NULL) {
printf ("Can't even begin; out of memory.\n");
exit (ERROR_RETURN);
}
inlist[0] = '\0';
outlist[0] = '\0';
input[0] = '\0';
output[0] = '\0';
/* Initialize the lists of reference file keywords and names. */
InitRefFile (&refnames);
/* Initial values. */
initSwitch (&ccd_sw);
for (i = 1; i < argc; i++) {
/**********
if (strcmp (argv[i], "-dqi") == 0) {
ccd_sw.dqicorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-atod") == 0) {
ccd_sw.atodcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-blev") == 0) {
ccd_sw.blevcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-bias") == 0) {
ccd_sw.biascorr = PERFORM;
switch_on = 1;
} else if (argv[i][0] == '-') {
**********/
if (argv[i][0] == '-') {
for (j = 1; argv[i][j] != '\0'; j++) {
if (argv[i][j] == 't') {
printtime = YES;
} else if (argv[i][j] == 'v') {
verbose = YES;
} else if (argv[i][j] == 'q') {
quiet = YES;
} else {
printf (MsgText, "Unrecognized option %s\n", argv[i]);
FreeNames (inlist, outlist, input, output);
exit (1);
}
}
} else if (inlist[0] == '\0') {
strcpy (inlist, argv[i]);
} else if (outlist[0] == '\0') {
strcpy (outlist, argv[i]);
} else {
too_many = 1;
}
}
if (inlist[0] == '\0' || too_many) {
printf ("syntax: acsccd [-t] [-v] [-q] input output\n");
/*
printf (" command-line switches:\n");
printf (" -dqi -atod -blev -bias\n");
*/
FreeNames (inlist, outlist, input, output);
exit (ERROR_RETURN);
}
/* Initialize the structure for managing trailer file comments */
InitTrlBuf ();
/* Copy command-line value for QUIET to structure */
SetTrlQuietMode(quiet);
/* Was no calibration switch specified on command line?
default values (mostly PERFORM) except ATODCORR
if (!switch_on) {*/
ccd_sw.dqicorr = DefSwitch ("dqicorr");
ccd_sw.atodcorr = DefSwitch ("atodcorr");
ccd_sw.blevcorr = DefSwitch ("blevcorr");
ccd_sw.biascorr = DefSwitch ("biascorr");
/*}*/
/* Expand the templates. */
i_imt = c_imtopen (inlist);
o_imt = c_imtopen (outlist);
n_in = c_imtlen (i_imt);
n_out = c_imtlen (o_imt);
/* The number of input and output files must be the same. */
if (CompareNumbers (n_in, n_out, "output"))
status = 1;
if (status) {
FreeNames (inlist, outlist, input, output);
CloseTrlBuf();
exit (ERROR_RETURN);
}
/* Loop over the list of input files. */
for (n = 0; n < n_in; n++) {
k = c_imtgetim (i_imt, input, ACS_LINE);
if (n_out > 0)
k = c_imtgetim (o_imt, output, ACS_LINE);
else
output[0] = '\0';
/* Open input image in order to read its primary header. */
if (LoadHdr (input, &phdr)) {
WhichError (status);
sprintf (MsgText, "Skipping %s", input);
trlmessage (MsgText);
continue;
}
/* Determine osuffix. */
strcpy(osuffix, "_blv_tmp");
if (MkName (input, isuffix, osuffix, "", output, ACS_LINE)) {
WhichError (status);
sprintf (MsgText, "Skipping %s", input);
trlmessage (MsgText);
continue;
}
/* Calibrate the current input file. */
if (ACSccd (input, output, &ccd_sw, &refnames, printtime, verbose)) {
sprintf (MsgText, "Error processing %s.", input);
trlerror (MsgText);
WhichError (status);
}
}
/* Close lists of file names, and free name buffers. */
c_imtclose (i_imt);
c_imtclose (o_imt);
CloseTrlBuf();
FreeRefFile (&refnames);
FreeNames (inlist, outlist, input, output);
if (status)
exit (ERROR_RETURN);
else
exit (0);
}
int main (int argc, char **argv) {
char *inlist; /* input file name */
char *outlist; /* output blev file name */
int switch_on = 0; /* was any switch specified? */
int printtime = NO; /* print time after each step? */
int verbose = NO; /* print additional info? */
int quiet = NO; /* print additional info? */
int too_many = 0; /* too many command-line arguments? */
int i, j; /* loop indexes */
IRAFPointer i_imt, o_imt; /* imt list pointers */
char *input; /* name of input science file */
char *output; /* name of output file */
int n_in, n_out; /* number of files in each list */
int n;
/* Input and output suffixes. */
char *isuffix[] = {"_raw", "_rac_tmp"};
char *osuffix[] = {"_blv_tmp", "_blc_tmp"};
int nsuffix = 2;
/* A structure to pass the calibration switches to WF3CCD */
CCD_Switch ccd_sw;
/* reference file keywords and names */
RefFileInfo refnames;
void InitRefFile (RefFileInfo *);
void FreeRefFile (RefFileInfo *);
void initCCDSwitches (CCD_Switch *);
int WF3ccd (char *, char *, CCD_Switch *, RefFileInfo *, int, int);
int DefSwitch (char *);
int MkName (char *, char *, char *, char *, char *, int);
void WhichError (int);
int CompareNumbers (int, int, char *);
/*===========================================================================*/
/* Initialize IRAF interface environment */
c_irafinit (argc, argv);
/* Post HSTIO error handler */
push_hstioerr (errchk);
/* Allocate space for file names. */
inlist = calloc (SZ_LINE+1, sizeof (char));
outlist = calloc (SZ_LINE+1, sizeof (char));
input = calloc (SZ_LINE+1, sizeof (char));
output = calloc (SZ_LINE+1, sizeof (char));
if (inlist == NULL || outlist == NULL ||
input == NULL || output == NULL) {
printf ("Can't even begin; out of memory.\n");
exit (ERROR_RETURN);
}
inlist[0] = '\0';
outlist[0] = '\0';
input[0] = '\0';
output[0] = '\0';
/* Initialize the lists of reference file keywords and names. */
InitRefFile (&refnames);
/* Initial values. */
initCCDSwitches (&ccd_sw);
/* Parse the command-line arguments */
for (i = 1; i < argc; i++) {
if (!(strcmp(argv[i],"--version"))) {
printf("%s\n",WF3_CAL_VER_NUM);
exit(0);
}
if (strcmp (argv[i], "-dqi") == 0) { /* turn on */
ccd_sw.dqicorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-atod") == 0) {
ccd_sw.atodcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-blev") == 0) {
ccd_sw.blevcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-bias") == 0) {
ccd_sw.biascorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-flash") == 0) {
ccd_sw.flashcorr = PERFORM;
switch_on = 1;
} else if (argv[i][0] == '-') {
for (j = 1; argv[i][j] != '\0'; j++) {
if (argv[i][j] == 't') {
printtime = YES;
} else if (argv[i][j] == 'v') {
verbose = YES;
} else if (argv[i][j] == 'q') {
quiet = YES;
} else if (argv[i][j] == 'r'){
printf ("Current version: %s\n", WF3_CAL_VER);
exit(0);
} else {
printf (MsgText, "Unrecognized option %s\n", argv[i]);
FreeNames (inlist, outlist, input, output);
exit (1);
}
}
} else if (inlist[0] == '\0') {
strcpy (inlist, argv[i]);
} else if (outlist[0] == '\0') {
strcpy (outlist, argv[i]);
} else {
too_many = 1;
}
}
if (inlist[0] == '\0' || too_many) {
printf ("syntax: wf3ccd [-t] [-v] [-q] [-r] input output\n");
printf (" command-line switches:\n");
printf (" -dqi -atod -blev -bias\n");
FreeNames (inlist, outlist, input, output);
exit (ERROR_RETURN);
}
/* Initialize the structure for managing trailer file comments */
InitTrlBuf ();
/* Copy command-line value for QUIET to structure */
SetTrlQuietMode(quiet);
/* Was no calibration switch specified on command line? */
if (!switch_on) { /* default values (mostly PERFORM) */
ccd_sw.dqicorr = DefSwitch ("dqicorr");
ccd_sw.atodcorr = DefSwitch ("atodcorr");
ccd_sw.blevcorr = DefSwitch ("blevcorr");
ccd_sw.biascorr = DefSwitch ("biascorr");
ccd_sw.flashcorr = DefSwitch ("flshcorr");
ccd_sw.fluxcorr = DefSwitch ("fluxcorr");
ccd_sw.pctecorr = DefSwitch ("pctecorr");
}
/* Expand the templates. */
i_imt = c_imtopen (inlist);
o_imt = c_imtopen (outlist);
n_in = c_imtlen (i_imt);
n_out = c_imtlen (o_imt);
/* The number of input and output files must be the same. */
if (CompareNumbers (n_in, n_out, "output"))
status = 1;
if (status) {
FreeNames (inlist, outlist, input, output);
CloseTrlBuf();
exit (ERROR_RETURN);
}
/* Loop over the list of input files. */
for (n = 0; n < n_in; n++) {
i = c_imtgetim (i_imt, input, SZ_LINE);
if (n_out > 0) {
i = c_imtgetim (o_imt, output, SZ_LINE);
} else {
output[0] = '\0';
}
if (MkOutName (input, isuffix, osuffix, nsuffix, output, SZ_LINE)) {
WhichError (status);
sprintf (MsgText, "Skipping %s", input);
trlmessage (MsgText);
continue;
}
/* Calibrate the current input file. */
if (WF3ccd (input, output, &ccd_sw, &refnames, printtime, verbose)){
sprintf (MsgText, "Error processing %s.", input);
trlerror (MsgText);
WhichError (status);
}
}
/* Close lists of file names, and free name buffers. */
c_imtclose (i_imt);
c_imtclose (o_imt);
CloseTrlBuf();
FreeRefFile (&refnames);
FreeNames (inlist, outlist, input, output);
if (status)
exit (ERROR_RETURN);
else
exit (0);
}
static void UnionRangeMinMaxValueWithList(
void *theEnv,
struct expr *addmin,
struct expr *addmax,
struct expr **theMinList,
struct expr **theMaxList)
{
struct expr *tmpmin, *tmpmax, *lastmin, *lastmax;
struct expr *themin, *themax, *nextmin, *nextmax;
int cmaxmin, cmaxmax, cminmin, cminmax;
/*=========================================================*/
/* If no values are on the lists, then use the new values. */
/*=========================================================*/
if (*theMinList == NULL)
{
*theMinList = GenConstant(theEnv,addmin->type,addmin->value);
*theMaxList = GenConstant(theEnv,addmax->type,addmax->value);
return;
}
lastmin = NULL;
lastmax = NULL;
tmpmin = (*theMinList);
tmpmax = (*theMaxList);
while (tmpmin != NULL)
{
cmaxmax = CompareNumbers(theEnv,addmax->type,addmax->value,
tmpmax->type,tmpmax->value);
cminmin = CompareNumbers(theEnv,addmin->type,addmin->value,
tmpmin->type,tmpmin->value);
cmaxmin = CompareNumbers(theEnv,addmax->type,addmax->value,
tmpmin->type,tmpmin->value);
cminmax = CompareNumbers(theEnv,addmin->type,addmin->value,
tmpmax->type,tmpmax->value);
/*=================================*/
/* Check to see if the range is */
/* contained within another range. */
/*=================================*/
if (((cmaxmax == LESS_THAN) || (cmaxmax == EQUAL)) &&
((cminmin == GREATER_THAN) || (cminmin == EQUAL)))
{ return; }
/*================================*/
/* Extend the greater than range. */
/*================================*/
if ((cmaxmax == GREATER_THAN) &&
((cminmax == LESS_THAN) || (cminmax == EQUAL)))
{
tmpmax->type = addmax->type;
tmpmax->value = addmax->value;
}
/*=============================*/
/* Extend the less than range. */
/*=============================*/
if ((cminmin == LESS_THAN) &&
((cmaxmin == GREATER_THAN) || (cmaxmin == EQUAL)))
{
tmpmin->type = addmin->type;
tmpmin->value = addmin->value;
}
/*====================*/
/* Handle insertions. */
/*====================*/
if (cmaxmin == LESS_THAN)
{
if (lastmax == NULL)
{
themin = GenConstant(theEnv,addmin->type,addmin->value);
themax = GenConstant(theEnv,addmax->type,addmax->value);
themin->nextArg = *theMinList;
themax->nextArg = *theMaxList;
*theMinList = themin;
*theMaxList = themax;
return;
}
if (CompareNumbers(theEnv,addmin->type,addmin->value,
lastmax->type,lastmax->value) == GREATER_THAN)
{
themin = GenConstant(theEnv,addmin->type,addmin->value);
themax = GenConstant(theEnv,addmax->type,addmax->value);
themin->nextArg = lastmin->nextArg;
themax->nextArg = lastmax->nextArg;
lastmin->nextArg = themin;
lastmax->nextArg = themax;
return;
}
}
/*==========================*/
/* Move on to the next one. */
/*==========================*/
tmpmin = tmpmin->nextArg;
tmpmax = tmpmax->nextArg;
}
/*===========================*/
/* Merge overlapping ranges. */
/*===========================*/
tmpmin = (*theMinList);
tmpmax = (*theMaxList);
while (tmpmin != NULL)
{
nextmin = tmpmin->nextArg;
nextmax = tmpmax->nextArg;
if (nextmin != NULL)
{
cmaxmin = CompareNumbers(theEnv,tmpmax->type,tmpmax->value,
nextmin->type,nextmin->value);
if ((cmaxmin == GREATER_THAN) || (cmaxmin == EQUAL))
{
tmpmax->type = nextmax->type;
tmpmax->value = nextmax->value;
tmpmax->nextArg = nextmax->nextArg;
tmpmin->nextArg = nextmin->nextArg;
rtn_struct(theEnv,expr,nextmin);
rtn_struct(theEnv,expr,nextmax);
}
else
{
tmpmin = tmpmin->nextArg;
tmpmax = tmpmax->nextArg;
}
}
else
{
tmpmin = nextmin;
tmpmax = nextmax;
}
}
}
static void IntersectNumericExpressions(
void *theEnv,
CONSTRAINT_RECORD *constraint1,
CONSTRAINT_RECORD *constraint2,
CONSTRAINT_RECORD *newConstraint,
int range)
{
struct expr *tmpmin1, *tmpmax1, *tmpmin2, *tmpmax2, *theMin, *theMax;
struct expr *theMinList, *theMaxList, *lastMin = NULL, *lastMax = NULL;
int cmaxmax, cminmin, cmaxmin, cminmax;
/*==========================================*/
/* Initialize the new range/min/max values */
/* for the intersection of the constraints. */
/*==========================================*/
theMinList = NULL;
theMaxList = NULL;
/*=================================*/
/* Determine the min/max values of */
/* the first constraint record. */
/*=================================*/
if (range)
{
tmpmin1 = constraint1->minValue;
tmpmax1 = constraint1->maxValue;
}
else
{
tmpmin1 = constraint1->minFields;
tmpmax1 = constraint1->maxFields;
}
/*===========================================*/
/* Loop through each of range/min/max values */
/* from the first constraint record. */
/*===========================================*/
for (;
tmpmin1 != NULL;
tmpmin1 = tmpmin1->nextArg, tmpmax1 = tmpmax1->nextArg)
{
/*============================================*/
/* Get the appropriate values from the second */
/* constraint record for comparison. */
/*============================================*/
if (range)
{
tmpmin2 = constraint2->minValue;
tmpmax2 = constraint2->maxValue;
}
else
{
tmpmin2 = constraint2->minFields;
tmpmax2 = constraint2->maxFields;
}
/*================================================*/
/* Loop through each of range/min/max values from */
/* the second constraint record comparing it to */
/* the values from the first constraint record. */
/*================================================*/
for (;
tmpmin2 != NULL;
tmpmin2 = tmpmin2->nextArg, tmpmax2 = tmpmax2->nextArg)
{
/*==============================================*/
/* Determine the relationship between the four */
/* combinations of min/max values (>, <, or =). */
/*==============================================*/
cmaxmax = CompareNumbers(theEnv,tmpmax1->type,tmpmax1->value,
tmpmax2->type,tmpmax2->value);
cminmin = CompareNumbers(theEnv,tmpmin1->type,tmpmin1->value,
tmpmin2->type,tmpmin2->value);
cmaxmin = CompareNumbers(theEnv,tmpmax1->type,tmpmax1->value,
tmpmin2->type,tmpmin2->value);
cminmax = CompareNumbers(theEnv,tmpmin1->type,tmpmin1->value,
tmpmax2->type,tmpmax2->value);
/*============================================*/
/* If the range/min/max values don't overlap, */
/* then proceed to the next pair of numbers */
/* to see if they overlap. */
/*============================================*/
if ((cmaxmin == LESS_THAN) || (cminmax == GREATER_THAN))
{ continue; }
/*=======================================*/
/* Compute the new minimum value for the */
/* intersected range/min/max values. */
/*=======================================*/
if (cminmin == GREATER_THAN)
{ theMin = GenConstant(theEnv,tmpmin1->type,tmpmin1->value); }
else
{ theMin = GenConstant(theEnv,tmpmin2->type,tmpmin2->value); }
/*=======================================*/
/* Compute the new maximum value for the */
/* intersected range/min/max values. */
/*=======================================*/
if (cmaxmax == LESS_THAN)
{ theMax = GenConstant(theEnv,tmpmax1->type,tmpmax1->value); }
else
{ theMax = GenConstant(theEnv,tmpmax2->type,tmpmax2->value); }
/*==================================*/
/* Add the new range/min/max values */
/* to the intersection list. */
/*==================================*/
if (lastMin == NULL)
{
theMinList = theMin;
theMaxList = theMax;
}
else
{
lastMin->nextArg = theMin;
lastMax->nextArg = theMax;
}
lastMin = theMin;
lastMax = theMax;
}
}
/*============================================================*/
/* If the intersection produced a pair of valid range/min/max */
/* values, then replace the previous values of the constraint */
/* record to the new intersected values. */
/*============================================================*/
if (theMinList != NULL)
{
if (range)
{
ReturnExpression(theEnv,newConstraint->minValue);
ReturnExpression(theEnv,newConstraint->maxValue);
newConstraint->minValue = theMinList;
newConstraint->maxValue = theMaxList;
}
else
{
ReturnExpression(theEnv,newConstraint->minFields);
ReturnExpression(theEnv,newConstraint->maxFields);
newConstraint->minFields = theMinList;
newConstraint->maxFields = theMaxList;
}
}
/*===============================================================*/
/* Otherwise, the intersection produced no valid range/min/max */
/* values. For the range attribute, this means that no numbers */
/* can satisfy the constraint. For the min/max fields attribute, */
/* it means that no value can satisfy the constraint. */
/*===============================================================*/
else
{
if (range)
{
if (newConstraint->anyAllowed) SetAnyAllowedFlags(newConstraint,FALSE);
newConstraint->integersAllowed = FALSE;
newConstraint->floatsAllowed = FALSE;
}
else
{
SetAnyAllowedFlags(newConstraint,TRUE);
newConstraint->singlefieldsAllowed = FALSE;
newConstraint->multifieldsAllowed = FALSE;
newConstraint->anyAllowed = FALSE;
}
}
}
int main (int argc, char **argv) {
int status; /* zero is OK */
char *inlist; /* list of input file names */
char *outlist; /* list of output file names */
int switch_on = 0; /* was any switch specified? */
int sgeocorr = OMIT; /* calibration switches */
int helcorr = OMIT;
int fluxcorr = OMIT;
int statcorr = OMIT;
int err_algorithm = WGT_VARIANCE;
int printtime = 0; /* print time after each step? */
int verbose = 0; /* print additional info? */
int center_target = 0; /* center target in output image? */
int too_many = 0; /* too many command-line arguments? */
int i, j; /* loop indexes */
double blazeshift = NO_VALUE;
IRAFPointer i_imt, o_imt; /* imt list pointers */
char *input; /* name of input science file */
char *output; /* optional name of output file */
int n_in, n_out; /* number of files in each list */
int n;
/* Input and output suffixes. */
char *isuffix[] =
{"_flt", "_crj", "_fwv", "_cwv", "_fwv_tmp", "_cwv_tmp"};
char *osuffix[] =
{"_x2d", "_sx2", "_w2d", "_w2d", "_w2d_tmp", "_w2d_tmp"};
int nsuffix = 6;
/* reference file keywords and names */
RefFileInfo refnames;
c_irafinit (argc, argv);
inlist = calloc (STIS_LINE+1, sizeof (char));
outlist = calloc (STIS_LINE+1, sizeof (char));
input = calloc (STIS_LINE+1, sizeof (char));
output = calloc (STIS_LINE+1, sizeof (char));
if (inlist == NULL || outlist == NULL ||
input == NULL || output == NULL) {
printf ("ERROR: Can't even begin: out of memory.\n");
exit (ERROR_RETURN);
}
/* Get command-line arguments. */
for (i = 1; i < argc; i++) {
if (strcmp (argv[i], "-x2d") == 0 ||
strcmp (argv[i], "-geo") == 0) {
switch_on = 1;
} else if (strcmp (argv[i], "-sgeo") == 0) { /* turn on */
sgeocorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-hel") == 0) {
helcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-flux") == 0) {
fluxcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-stat") == 0) {
statcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-wgt_err") == 0) {
err_algorithm = WGT_ERROR;
} else if (argv[i][0] == '-') {
if (strcmp (argv[i], "--version") == 0) {
PrVersion();
exit (0);
}
if (strcmp (argv[i], "-r") == 0) {
PrFullVersion();
exit (0);
}
for (j = 1; argv[i][j] != '\0'; j++) {
if (argv[i][j] == 't') {
printtime = 1;
} else if (argv[i][j] == 'v') {
verbose = 1;
} else if (argv[i][j] == 'c') {
center_target = 1; /* yes, center target */
} else if (argv[i][j] == 'b') {
blazeshift = (double) atof (argv[++i]);
if (i == argc-1)
break;
} else {
printf ("ERROR: Unrecognized option %s\n", argv[i]);
exit (1);
}
}
} else if (inlist[0] == '\0') {
strcpy (inlist, argv[i]);
} else if (outlist[0] == '\0') {
strcpy (outlist, argv[i]);
} else {
too_many = 1;
}
}
if (inlist[0] == '\0' || too_many) {
printf (
"syntax: cs7.e [-t] [-v] [-c] [-wgt_err] [-b blazeshift] input output\n");
printf (" command-line switches: -x2d -sgeo -hel -flux -stat\n");
FreeNames (inlist, outlist, input, output);
exit (ERROR_RETURN);
}
/* Was no calibration switch specified on command line? */
if (!switch_on) { /* default values (mostly PERFORM) */
sgeocorr = DefSwitch ("sgeocorr");
helcorr = DefSwitch ("helcorr");
fluxcorr = DefSwitch ("fluxcorr");
statcorr = DefSwitch ("statcorr");
}
/* Initialize the list of reference file keywords and names. */
InitRefFile (&refnames);
/* Expand the templates. */
i_imt = c_imtopen (inlist);
o_imt = c_imtopen (outlist);
n_in = c_imtlen (i_imt);
n_out = c_imtlen (o_imt);
/* The number of input and output files must be the same. */
if (CompareNumbers (n_in, n_out, "output")) {
FreeNames (inlist, outlist, input, output);
exit (ERROR_RETURN);
}
/* Loop over the list of input files. */
for (n = 0; n < n_in; n++) {
j = c_imtgetim (i_imt, input, STIS_LINE);
if (n_out > 0)
j = c_imtgetim (o_imt, output, STIS_LINE);
else
output[0] = '\0';
status = 0;
if ((status = MkOutName (input, isuffix, osuffix, nsuffix,
output, STIS_LINE))) {
WhichError (status);
printf ("Skipping %s\n", input);
continue;
}
/* Calibrate the current input file. */
if ((status = CalStis7 (input, output,
sgeocorr, helcorr, fluxcorr, statcorr,
&refnames, printtime, verbose, center_target,
blazeshift, err_algorithm))) {
printf ("Error processing %s.\n", input);
WhichError (status);
}
}
/* Close lists of file names, and free name buffers. */
c_imtclose (i_imt);
c_imtclose (o_imt);
FreeRefFile (&refnames);
FreeNames (inlist, outlist, input, output);
if (status)
exit (ERROR_RETURN);
else
exit (0);
}
int main (int argc, char **argv) {
int status; /* zero is OK */
char *inlist; /* list of input file names */
char *outlist; /* list of output file names */
char *blevlist; /* list of output blev file names */
int switch_on = 0; /* was any switch specified? */
int printtime = 0; /* print time after each step? */
int verbose = 0; /* print additional info? */
int too_many = 0; /* too many command-line arguments? */
int i, j; /* loop indexes */
int junk;
IRAFPointer i_imt, o_imt, b_imt; /* imt list pointers */
char *input; /* name of input science file */
char *output; /* optional name of output file */
char *outblev; /* optional file for blev values */
int n_in, n_out, n_blev; /* number of files in each list */
int n;
/* Input and output suffixes. */
char *isuffix[] = {"_raw", "_blv_tmp", "_crj_tmp", "_wav"};
char *osuffix[] = {"_flt", "_flt", "_crj", "_fwv"};
int nsuffix = 4;
/* A structure to pass the calibration switches to CalStis1 */
cs1_switch cs1_sw;
/* reference file keywords and names */
RefFileInfo refnames;
c_irafinit (argc, argv);
/* Allocate space for file names. */
inlist = calloc (1, sizeof (char)); /* allocated later */
outlist = calloc (1, sizeof (char));
blevlist = calloc (1, sizeof (char));
input = calloc (STIS_LINE+1, sizeof (char));
output = calloc (STIS_LINE+1, sizeof (char));
outblev = calloc (STIS_LINE+1, sizeof (char));
if (inlist == NULL || outlist == NULL || blevlist == NULL ||
input == NULL || output == NULL || outblev == NULL) {
printf ("ERROR: Can't even begin; out of memory.\n");
exit (ERROR_RETURN);
}
/* Initialize the lists of reference file keywords and names. */
InitRefFile (&refnames);
/* Initial values. */
cs1_sw.dqicorr = OMIT;
cs1_sw.atodcorr = OMIT;
cs1_sw.blevcorr = OMIT;
cs1_sw.doppcorr = OMIT;
cs1_sw.lorscorr = OMIT;
cs1_sw.glincorr = OMIT;
cs1_sw.lflgcorr = OMIT;
cs1_sw.biascorr = OMIT;
cs1_sw.darkcorr = OMIT;
cs1_sw.flatcorr = OMIT;
cs1_sw.shadcorr = OMIT;
cs1_sw.photcorr = OMIT;
cs1_sw.statcorr = OMIT;
strcpy (cs1_sw.darkscale_string, "");
for (i = 1; i < argc; i++) {
if (strcmp (argv[i], "--version") == 0) {
PrVersion();
exit (0);
}
if (strcmp (argv[i], "-r") == 0) {
PrFullVersion();
exit (0);
}
if (strcmp (argv[i], "-dqi") == 0) { /* turn on */
cs1_sw.dqicorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-atod") == 0) {
cs1_sw.atodcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-blev") == 0) {
cs1_sw.blevcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-dopp") == 0) {
cs1_sw.doppcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-lors") == 0) {
cs1_sw.lorscorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-glin") == 0) {
cs1_sw.glincorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-lflg") == 0) {
cs1_sw.lflgcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-bias") == 0) {
cs1_sw.biascorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-dark") == 0) {
cs1_sw.darkcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-flat") == 0) {
cs1_sw.flatcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-shad") == 0) {
cs1_sw.shadcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-phot") == 0) {
cs1_sw.photcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-stat") == 0) {
cs1_sw.statcorr = PERFORM;
switch_on = 1;
} else if (strcmp (argv[i], "-dscl") == 0) {
strcpy (cs1_sw.darkscale_string, argv[++i]);
switch_on = 1;
} else if (argv[i][0] == '-') {
for (j = 1; argv[i][j] != '\0'; j++) {
if (argv[i][j] == 't') {
printtime = 1;
} else if (argv[i][j] == 'v') {
verbose = 1;
} else {
printf ("ERROR: Unrecognized option %s\n", argv[i]);
exit (1);
}
}
} else if (inlist[0] == '\0') {
free (inlist);
if ((inlist = calloc (strlen(argv[i])+1, sizeof(char)))
== NULL) {
printf ("ERROR: Out of memory.\n");
exit (ERROR_RETURN);
}
strcpy (inlist, argv[i]);
} else if (outlist[0] == '\0') {
free (outlist);
if ((outlist = calloc (strlen(argv[i])+1, sizeof(char)))
== NULL) {
printf ("ERROR: Out of memory.\n");
exit (ERROR_RETURN);
}
strcpy (outlist, argv[i]);
} else if (blevlist[0] == '\0') {
free (blevlist);
if ((blevlist = calloc (strlen(argv[i])+1, sizeof(char)))
== NULL) {
printf ("ERROR: Out of memory.\n");
exit (ERROR_RETURN);
}
strcpy (blevlist, argv[i]);
} else {
too_many = 1;
}
}
if (inlist[0] == '\0' || too_many) {
printf ("syntax: cs1.e [-t] [-v] input output [outblev]\n");
printf (" command-line switches:\n");
printf (" -dqi -atod -blev\n");
printf (" -dopp -lors -glin -lflg\n");
printf (" -bias -dark -flat -shad -phot -stat\n");
FreeNames (inlist, outlist, blevlist, input, output, outblev);
exit (ERROR_RETURN);
}
/* Was no calibration switch specified on command line? */
if (!switch_on) { /* default values (mostly PERFORM) */
cs1_sw.dqicorr = DefSwitch ("dqicorr");
cs1_sw.atodcorr = DefSwitch ("atodcorr");
cs1_sw.blevcorr = DefSwitch ("blevcorr");
cs1_sw.doppcorr = DefSwitch ("doppcorr");
cs1_sw.lorscorr = DefSwitch ("lorscorr");
cs1_sw.glincorr = DefSwitch ("glincorr");
cs1_sw.lflgcorr = DefSwitch ("lflgcorr");
cs1_sw.biascorr = DefSwitch ("biascorr");
cs1_sw.darkcorr = DefSwitch ("darkcorr");
cs1_sw.flatcorr = DefSwitch ("flatcorr");
cs1_sw.shadcorr = DefSwitch ("shadcorr");
cs1_sw.photcorr = DefSwitch ("photcorr");
cs1_sw.statcorr = DefSwitch ("statcorr");
}
/* Expand the templates. */
i_imt = c_imtopen (inlist);
o_imt = c_imtopen (outlist);
b_imt = c_imtopen (blevlist);
n_in = c_imtlen (i_imt);
n_out = c_imtlen (o_imt);
n_blev = c_imtlen (b_imt);
/* The number of input and output files must be the same. */
status = 0;
if (CompareNumbers (n_in, n_out, "output"))
status = ERROR_RETURN;
if (CompareNumbers (n_in, n_blev, "outblev"))
status = ERROR_RETURN;
if (status) {
FreeNames (inlist, outlist, blevlist, input, output, outblev);
exit (ERROR_RETURN);
}
/* Loop over the list of input files. */
for (n = 0; n < n_in; n++) {
junk = c_imtgetim (i_imt, input, STIS_LINE);
if (n_out > 0)
junk = c_imtgetim (o_imt, output, STIS_LINE);
else
output[0] = '\0';
if (n_blev > 0)
junk = c_imtgetim (b_imt, outblev, STIS_LINE);
else
outblev[0] = '\0';
status = 0;
if ((status = MkOutName (input, isuffix, osuffix, nsuffix,
output, STIS_LINE))) {
WhichError (status);
printf ("Skipping %s\n", input);
continue;
}
/* Calibrate the current input file. */
if ((status = CalStis1 (input, output, outblev,
&cs1_sw, &refnames, printtime, verbose))) {
printf ("Error processing %s.\n", input);
WhichError (status);
}
}
/* Close lists of file names, and free name buffers. */
c_imtclose (i_imt);
c_imtclose (o_imt);
c_imtclose (b_imt);
FreeRefFile (&refnames);
FreeNames (inlist, outlist, blevlist, input, output, outblev);
if (status)
exit (ERROR_RETURN);
else
exit (0);
}
