/*
* get_slc_defaults
*
* Initialize the slc mapping table.
*/
void get_slc_defaults(void) {
int i;
init_termbuf();
for (i = 1; i <= NSLC; i++) {
slctab[i].defset.flag = spcset(i, &slctab[i].defset.val,
&slctab[i].sptr);
slctab[i].current.flag = SLC_NOSUPPORT;
slctab[i].current.val = 0;
}
}
int spcs2x(
struct spcprm *spc,
int nspec,
int sspec,
int sx,
const double spec[],
double x[],
int stat[])
{
static const char *function = "spcs2x";
int statP2X, status = 0, statS2P;
double beta, s;
register int ispec;
register int *statp;
register const double *specp;
register double *xp;
struct wcserr **err;
/* Initialize. */
if (spc == 0x0) return SPCERR_NULL_POINTER;
err = &(spc->err);
if (spc->flag == 0) {
if ((status = spcset(spc))) return status;
}
/* Apply the linear step of the algorithm chain to convert the S-type */
/* spectral variable to P-type intermediate spectral variable. */
if (spc->spxS2P) {
if ((statS2P = spc->spxS2P(spc->w[0], nspec, sspec, sx, spec, x, stat))) {
if (statS2P == SPXERR_BAD_INSPEC_COORD) {
status = SPCERR_BAD_SPEC;
} else if (statS2P == SPXERR_BAD_SPEC_PARAMS) {
return wcserr_set(WCSERR_SET(SPCERR_BAD_SPEC_PARAMS),
"Invalid spectral parameters: Frequency or wavelength is 0");
} else {
return wcserr_set(SPC_ERRMSG(spc_spxerr[statS2P]));
}
}
} else {
/* Just a copy. */
xp = x;
specp = spec;
statp = stat;
for (ispec = 0; ispec < nspec; ispec++, specp += sspec, xp += sx) {
*xp = *specp;
*(statp++) = 0;
}
}
/* Apply the non-linear step of the algorithm chain to convert P-type */
/* intermediate spectral variable to X-type spectral variable. */
if (spc->spxP2X) {
if ((statP2X = spc->spxP2X(spc->w[0], nspec, sx, sx, x, x, stat))) {
if (statP2X == SPCERR_BAD_SPEC) {
status = SPCERR_BAD_SPEC;
} else if (statP2X == SPXERR_BAD_SPEC_PARAMS) {
return wcserr_set(WCSERR_SET(SPCERR_BAD_SPEC_PARAMS),
"Invalid spectral parameters: Frequency or wavelength is 0");
} else {
return wcserr_set(SPC_ERRMSG(spc_spxerr[statP2X]));
}
}
}
if (spc->isGrism) {
/* Convert X-type spectral variable (wavelength) to grism parameter. */
xp = x;
statp = stat;
for (ispec = 0; ispec < nspec; ispec++, xp += sx, statp++) {
if (*statp) continue;
s = *xp/spc->w[5] - spc->w[4];
if (fabs(s) <= 1.0) {
beta = asind(s);
*xp = tand(beta - spc->w[3]);
} else {
*statp = 1;
}
}
}
/* Convert X-type spectral variable to intermediate world coordinate x. */
xp = x;
statp = stat;
for (ispec = 0; ispec < nspec; ispec++, xp += sx) {
if (*(statp++)) continue;
*xp -= spc->w[1];
*xp /= spc->w[2];
}
if (status) {
wcserr_set(SPC_ERRMSG(status));
}
return status;
}
int spcx2s(
struct spcprm *spc,
int nx,
int sx,
int sspec,
const double x[],
double spec[],
int stat[])
{
static const char *function = "spcx2s";
int statP2S, status = 0, statX2P;
double beta;
register int ix;
register int *statp;
register const double *xp;
register double *specp;
struct wcserr **err;
/* Initialize. */
if (spc == 0x0) return SPCERR_NULL_POINTER;
err = &(spc->err);
if (spc->flag == 0) {
if ((status = spcset(spc))) return status;
}
/* Convert intermediate world coordinate x to X. */
xp = x;
specp = spec;
statp = stat;
for (ix = 0; ix < nx; ix++, xp += sx, specp += sspec) {
*specp = spc->w[1] + (*xp)*spc->w[2];
*(statp++) = 0;
}
/* If X is the grism parameter then convert it to wavelength. */
if (spc->isGrism) {
specp = spec;
for (ix = 0; ix < nx; ix++, specp += sspec) {
beta = atand(*specp) + spc->w[3];
*specp = (sind(beta) + spc->w[4]) * spc->w[5];
}
}
/* Apply the non-linear step of the algorithm chain to convert the */
/* X-type spectral variable to P-type intermediate spectral variable. */
if (spc->spxX2P) {
if ((statX2P = spc->spxX2P(spc->w[0], nx, sspec, sspec, spec, spec,
stat))) {
if (statX2P == SPXERR_BAD_INSPEC_COORD) {
status = SPCERR_BAD_X;
} else if (statX2P == SPXERR_BAD_SPEC_PARAMS) {
return wcserr_set(WCSERR_SET(SPCERR_BAD_SPEC_PARAMS),
"Invalid spectral parameters: Frequency or wavelength is 0");
} else {
return wcserr_set(SPC_ERRMSG(spc_spxerr[statX2P]));
}
}
}
/* Apply the linear step of the algorithm chain to convert P-type */
/* intermediate spectral variable to the required S-type variable. */
if (spc->spxP2S) {
if ((statP2S = spc->spxP2S(spc->w[0], nx, sspec, sspec, spec, spec,
stat))) {
if (statP2S == SPXERR_BAD_INSPEC_COORD) {
status = SPCERR_BAD_X;
} else if (statP2S == SPXERR_BAD_SPEC_PARAMS) {
return wcserr_set(WCSERR_SET(SPCERR_BAD_SPEC_PARAMS),
"Invalid spectral parameters: Frequency or wavelength is 0");
} else {
return wcserr_set(SPC_ERRMSG(spc_spxerr[statP2S]));
}
}
}
if (status) {
wcserr_set(SPC_ERRMSG(status));
}
return status;
}
int spcs2x(
struct spcprm *spc,
int nspec,
int sspec,
int sx,
const double spec[],
double x[],
int stat[])
{
int statP2X, status = 0, statS2P;
double beta, s;
register int ispec;
register int *statp;
register const double *specp;
register double *xp;
/* Initialize. */
if (spc == 0) return 1;
if (spc->flag == 0) {
if (spcset(spc)) return 2;
}
/* Apply the linear step of the algorithm chain to convert the S-type */
/* spectral variable to P-type intermediate spectral variable. */
if (spc->spxS2P != 0) {
if (statS2P = spc->spxS2P(spc->w[0], nspec, sspec, sx, spec, x, stat)) {
if (statS2P == 4) {
status = 4;
} else {
return statS2P;
}
}
} else {
/* Just a copy. */
xp = x;
specp = spec;
statp = stat;
for (ispec = 0; ispec < nspec; ispec++, specp += sspec, xp += sx) {
*xp = *specp;
*(statp++) = 0;
}
}
/* Apply the non-linear step of the algorithm chain to convert P-type */
/* intermediate spectral variable to X-type spectral variable. */
if (spc->spxP2X != 0) {
if (statP2X = spc->spxP2X(spc->w[0], nspec, sx, sx, x, x, stat)) {
if (statP2X == 4) {
status = 4;
} else {
return statP2X;
}
}
}
if (spc->isGrism) {
/* Convert X-type spectral variable (wavelength) to grism parameter. */
xp = x;
statp = stat;
for (ispec = 0; ispec < nspec; ispec++, xp += sx, statp++) {
if (*statp) continue;
s = *xp/spc->w[5] - spc->w[4];
if (fabs(s) <= 1.0) {
beta = asind(s);
*xp = tand(beta - spc->w[3]);
} else {
*statp = 1;
}
}
}
/* Convert X-type spectral variable to intermediate world coordinate x. */
xp = x;
statp = stat;
for (ispec = 0; ispec < nspec; ispec++, xp += sx) {
if (*(statp++)) continue;
*xp -= spc->w[1];
*xp /= spc->w[2];
}
return status;
}
int spcx2s(
struct spcprm *spc,
int nx,
int sx,
int sspec,
const double x[],
double spec[],
int stat[])
{
int statP2S, status = 0, statX2P;
double beta;
register int ix;
register int *statp;
register const double *xp;
register double *specp;
/* Initialize. */
if (spc == 0) return 1;
if (spc->flag == 0) {
if (spcset(spc)) return 2;
}
/* Convert intermediate world coordinate x to X. */
xp = x;
specp = spec;
statp = stat;
for (ix = 0; ix < nx; ix++, xp += sx, specp += sspec) {
*specp = spc->w[1] + (*xp)*spc->w[2];
*(statp++) = 0;
}
/* If X is the grism parameter then convert it to wavelength. */
if (spc->isGrism) {
specp = spec;
for (ix = 0; ix < nx; ix++, specp += sspec) {
beta = atand(*specp) + spc->w[3];
*specp = (sind(beta) + spc->w[4]) * spc->w[5];
}
}
/* Apply the non-linear step of the algorithm chain to convert the */
/* X-type spectral variable to P-type intermediate spectral variable. */
if (spc->spxX2P != 0) {
if (statX2P = spc->spxX2P(spc->w[0], nx, sspec, sspec, spec, spec,
stat)) {
if (statX2P == 4) {
status = 3;
} else {
return statX2P;
}
}
}
/* Apply the linear step of the algorithm chain to convert P-type */
/* intermediate spectral variable to the required S-type variable. */
if (spc->spxP2S != 0) {
if (statP2S = spc->spxP2S(spc->w[0], nx, sspec, sspec, spec, spec,
stat)) {
if (statP2S == 4) {
status = 3;
} else {
return statP2S;
}
}
}
return status;
}
