/* -------------------------------------------------------------------------- */
void set_proj()
{
double psx;
double cell;
double cell2;
double r;
double phictr;
dddd = cntrj0 * pj.cds;
sign = (pj.cenlat >= 0.0) ? 1.0 : -1.0;
xn = 0.0;
psi1 = 0.0;
pole = sign*90.0;
psi0 = (pole - pj.cenlat) * DEG_TO_RAD;
if (pj.code == LAMBERT)
{
xn = log10(cosd(pj.stdlat1)) - log10(cosd(pj.stdlat2));
xn = xn/(log10(tand(45.0-sign*pj.stdlat1*0.50)) -
log10(tand(45.0-sign*pj.stdlat2*0.50)));
psi1 = (90.0-sign*pj.stdlat1) * DEG_TO_RAD;
psi1 = sign*psi1;
}
else if (pj.code == POLAR)
{
xn = 1.0;
psi1 = (90.0-sign*pj.stdlat1) * DEG_TO_RAD;
psi1 = sign*psi1;
}
if (pj.code != MERCATOR)
{
psx = (pole-pj.cenlat) * DEG_TO_RAD;
if (pj.code == LAMBERT)
{
cell = RADIUS_EARTH*sin(psi1)/xn;
cell2 = tan(psx*0.50) / tan(psi1*0.50);
}
else
{
cell = RADIUS_EARTH*sin(psx)/xn;
cell2 = (1.0 + cos(psi1))/(1.0 + cos(psx));
}
r = cell*pow(cell2,xn);
xcntr = 0.0;
ycntr = -r;
xc = 0.0;
yc = -RADIUS_EARTH/xn*sin(psi1)*pow(tan(psi0*0.5)/tan(psi1*0.5),xn);
}
else {
c2 = RADIUS_EARTH*cos(psi1);
xcntr = 0.0;
phictr = pj.cenlat * DEG_TO_RAD;
cell = cos(phictr)/(1.0+sin(phictr));
ycntr = -c2*log(cell);
xc = xcntr;
yc = ycntr;
}
return;
}
/* FUNCTION: GLCreatePerspectiveMatrix
ARGUMENTS: m destination matrix
fov field of view
aspect aspect ratio
znear near plane
zfar far plane
RETURN: n/a
DESCRIPTION: Same as gluPerspective
*/
void GLCreatePerspectiveMatrix(float *m, float fov, float aspect, float znear, float zfar)
{
const float h = 1.0f/tand(fov/2.0f);
float neg_depth = znear-zfar;
m[0] = h / aspect;
m[1] = 0;
m[2] = 0;
m[3] = 0;
m[4] = 0;
m[5] = h;
m[6] = 0;
m[7] = 0;
m[8] = 0;
m[9] = 0;
m[10] = (zfar + znear)/neg_depth;
m[11] = -1;
m[12] = 0;
m[13] = 0;
m[14] = 2.0f*(znear*zfar)/neg_depth;
m[15] = 0;
}
/*
** The HAE to HEEQ transformation is given by the matrix
**
** S2 = <theta0,Z>*<i,X>*<Omega,Z>
**
** where the rotation angle theta0 is the the longitude of the Sun's
** central meridian, i is the the inclination of the Sun's equator and
** Omega is the the ecliptic longitude of the ascending node of the Sun's
** equator. This transformation comprises a rotation in the plane of the
** ecliptic from the First Point of Aries to the ascending node of the
** solar equator, then a rotation from the plane of the ecliptic to the
** plane of the equator and finally a rotation in the plane of the solar
** equator from the ascending node to the central meridian.
**
** Implemented by Kristi Keller on 2/2/2004
*/
void
mat_S2(const double et, Mat mat)
{
Mat mat_tmp;
double Omega = 73.6667+0.013958*(MJD(et)+3242)/365.25;
double theta0 = atand(cosd(7.25) * tand(lambda0(et)-Omega));
double angle_1 = lambda0(et)-Omega;
angle_1=fmod(angle_1,360.0);
if (angle_1 < 0.0) angle_1+=360.0;
theta0=fmod(theta0,360.0);
if (theta0 < 0.0) theta0+=360.0;
if (angle_1 < 180.0) {
if (theta0 < 180.0) theta0+=180.0;
}
if (angle_1 > 180.0) {
if (theta0 > 180.0) theta0-=180.0;
}
hapgood_matrix(theta0, Z, mat);
hapgood_matrix(7.25, X, mat_tmp);
mat_times_mat(mat, mat_tmp, mat);
hapgood_matrix(Omega, Z, mat_tmp);
mat_times_mat(mat, mat_tmp, mat);
}
/* p. 185, 28.3 */
double EquationOfTime( double centuryTime)
{
double epsilon = ObliquityCorrection( centuryTime);
double y = tand(epsilon/2.0);
y *=y;
double l0 = GeometricMeanLongitudeSun( centuryTime);
double e = EccentricityEarth( centuryTime);
double m = GeometricMeanAnomalySun( centuryTime);
l0 = DEG2RAD(l0);
double l0x2 = l0 + l0;
double l0x4 = l0x2 + l0x2;
m = DEG2RAD(m);
double sinm = sin(m);
double mx2 = m + m;
double ex2 = e + e;
double eRad = y * sin(l0x2) - ex2 * sinm + 2 * ex2 * y * sinm * cos(l0x2) -
0.5 * y * y * sin(l0x4) - 1.25 * e * e * sin(mx2);
/* convert radians to degrees to minutes of time */
return DEG2MIN(RAD2DEG(eRad));
}
void geodtgc(int iopt,double *gdlat,double *gdlon,
double *grho,double *glat,
double *glon,double *del) {
double a=6378.16;
double f=1.0/298.25;
double b,e2;
b=a*(1.0-f);
e2=(a*a)/(b*b)-1;
if (iopt>0) {
*glat=atand( (b*b)/(a*a)*tand(*gdlat));
*glon=*gdlon;
if (*glon > 180) *glon=*glon-360;
} else {
*gdlat=atand( (a*a)/(b*b)*tand(*glat));
*gdlon=*glon;
}
*grho=a/sqrt(1.0+e2*sind(*glat)*sind(*glat));
*del=*gdlat-*glat;
}
static double* setMatPerspective(double *mat, double fov) {
// http://stackoverflow.com/questions/6060169/is-this-a-correct-perspective-fov-matrix
double ys = 1. / tand(fov/2.);
double xs = ys*aspect;
set16(mat,
xs,0,0,0,
0,ys,0,0,
0,0,(far+near)/(near-far),2*far*near/(near-far),
0,0,-1,0);
return mat;
}
void scan_to_latlon(meta_parameters *meta,
double x, double y, double z,
double *lat_d, double *lon, double *height)
{
double qlat, qlon;
double lat,radius;
vector pos;
meta_projection *proj = meta->projection;
if (z != 0.0) {
// height correction applies directly to y (range direction)
double line, samp;
line = (y-proj->startY)/proj->perY - meta->general->start_line;
samp = (x-proj->startX)/proj->perX - meta->general->start_sample;
double sr = meta_get_slant(meta,line,samp);
double er = proj->param.atct.rlocal;
double ht = meta_get_sat_height(meta,line,samp);
double cos_ang = (sr*sr + er*er - ht*ht)/(2.0*sr*er);
if (cos_ang > 1) cos_ang = 1;
if (cos_ang < -1) cos_ang = -1;
double incid = PI-acos(cos_ang);
x += z*tan(PI/2-incid);
}
if (meta->sar->look_direction=='R')
qlat = -x/proj->param.atct.rlocal; /* Right looking sar */
else
qlat = x/proj->param.atct.rlocal; /* Left looking sar */
qlon = y/(proj->param.atct.rlocal*cos(qlat));
sph2cart(proj->param.atct.rlocal, qlat, qlon, &pos);
rotate_z(&pos,-proj->param.atct.alpha3);
rotate_y(&pos,-proj->param.atct.alpha2);
rotate_z(&pos,-proj->param.atct.alpha1);
cart2sph(pos,&radius,&lat,lon);
*lon *= R2D;
lat *= R2D;
*lat_d = atand(tand(lat) / (1-ecc2(proj->re_minor,proj->re_major)));
*height = z; // FIXME: Do we need to correct the height at all?
}
int main (int argc, char *argv[]){
if (argc != 2){
printf("Give a parameter file.\n");
exit(1);
}
int SpaceGrp;
double LatC[6], wl, Lsd, MaxRingRad;
char *ParamFN;
FILE *fileParam;
ParamFN = argv[1];
char aline[1000];
fileParam = fopen(ParamFN,"r");
char *str, dummy[1000];
int LowNr;
while (fgets(aline,1000,fileParam)!=NULL){
str = "SpaceGroup ";
LowNr = strncmp(aline,str,strlen(str));
if (LowNr==0){
sscanf(aline,"%s %d", dummy, &SpaceGrp);
continue;
}
str = "LatticeConstant ";
LowNr = strncmp(aline,str,strlen(str));
if (LowNr==0){
sscanf(aline,"%s %lf %lf %lf %lf %lf %lf", dummy, &LatC[0],
&LatC[1], &LatC[2], &LatC[3], &LatC[4], &LatC[5]);
continue;
}
str = "LatticeParameter ";
LowNr = strncmp(aline,str,strlen(str));
if (LowNr==0){
sscanf(aline,"%s %lf %lf %lf %lf %lf %lf", dummy, &LatC[0],
&LatC[1], &LatC[2], &LatC[3], &LatC[4], &LatC[5]);
continue;
}
str = "Wavelength ";
LowNr = strncmp(aline,str,strlen(str));
if (LowNr==0){
sscanf(aline,"%s %lf", dummy, &wl);
continue;
}
str = "Lsd ";
LowNr = strncmp(aline,str,strlen(str));
if (LowNr==0){
sscanf(aline,"%s %lf", dummy, &Lsd);
continue;
}
str = "MaxRingRad ";
LowNr = strncmp(aline,str,strlen(str));
if (LowNr==0){
sscanf(aline,"%s %lf", dummy, &MaxRingRad);
continue;
}
}
printf("%f %f %f %d %f %f %f %f %f %f\n",wl,Lsd,MaxRingRad,SpaceGrp,LatC[0],LatC[1],LatC[2],LatC[3],LatC[4],LatC[5]);
int h, k, l, iList, restriction, M, i, j;
int Minh, Mink, Minl;
int CCMx_PL[9], deterCCMx_LP = 0;
double Epsilon = 0.0001;
int Families[50000][3];
T_SgInfo *SgInfo;
char SgName[200];
int F_Convention='A';
const T_TabSgName *tsgn;
printf("Generating hkl's\n");
if((SgInfo = (T_SgInfo *)malloc(sizeof(T_SgInfo)))==NULL){
printf("Unable to allocate SgInfo\n");
printf("Aborting\n");
exit(1);
}
SgInfo->GenOption = 0;
SgInfo->MaxList = 192;
if((SgInfo->ListSeitzMx = (T_RTMx*)malloc(SgInfo->MaxList * sizeof(T_RTMx)))==NULL){
printf("Unable to allocate (SgInfo.ListSeitzMx\n");
printf("Aborting\n");
exit(1);
}
SgInfo->ListRotMxInfo = NULL;
InitSgInfo(SgInfo);
sprintf(SgName,"%d",SpaceGrp);
tsgn = FindTabSgNameEntry(SgName, F_Convention);
if (tsgn == NULL){
printf("Error: Unknown Space Group Symbol\n");
printf("Aborting\n");
exit(1);
}
sprintf(SgName,"%s",tsgn->HallSymbol);
SgInfo->TabSgName = tsgn;
if (tsgn) SgInfo->GenOption = 1;
{
int pos_hsym;
pos_hsym = ParseHallSymbol(SgName, SgInfo);
if (SgError != NULL) {
printf("Error: Unknown Space Group Symbol\n");
printf("Aborting\n");
exit(1);
}
}
if(CompleteSgInfo(SgInfo)!=0) {
printf("Error in Complete\n");
printf("Aborting\n");
exit(1);
}
if (SgInfo->LatticeInfo->Code != 'P')
{
deterCCMx_LP = deterRotMx(SgInfo->CCMx_LP);
InverseRotMx(SgInfo->CCMx_LP, CCMx_PL);
if (deterCCMx_LP < 1) {
printf("deterCMM failed.\n");
return 0;
}
}
int Maxh, Maxk, Maxl;
int nrFilled=0;
Maxh = 10;
Maxk = 10;
Maxl = 10;
SetListMin_hkl(SgInfo, Maxk, Maxl, &Minh, &Mink, &Minl);
printf("Will go from %d to %d in h; %d to %d in k; %d to %d in l.\n",Minh, Maxh, Mink, Maxk, Minl, Maxl);
for (h = Minh; h <= Maxh; h++){
for (k = Mink; k <= Maxk; k++){
for (l = Minl; l <= Maxl; l++){
if (h==0 && k==0 && l==0){
continue;
}
iList = IsSysAbsent_hkl(SgInfo, h, k, l, &restriction);
if (SgError != NULL) {
printf("IsSysAbsent_hkl failed.\n");
return 0;
}
if (iList == 0){
if ((iList = IsSuppressed_hkl(SgInfo, Minh, Mink, Minl,
Maxk, Maxl, h, k, l)) != 0) {/* Suppressed reflections */
} else {
//printf("New plane.\n");
T_Eq_hkl Eq_hkl;
M = BuildEq_hkl(SgInfo, &Eq_hkl, h, k, l);
if (SgError != NULL){
return 0;
}
for (i=0;i<Eq_hkl.N;i++){
for (j=-1;j<=1;j+=2){
//printf("%d %d %d\n",Eq_hkl.h[i]*j,Eq_hkl.k[i]*j,Eq_hkl.l[i]*j);
Families[nrFilled][0] = Eq_hkl.h[i]*j;
Families[nrFilled][1] = Eq_hkl.k[i]*j;
Families[nrFilled][2] = Eq_hkl.l[i]*j;
nrFilled++;
}
}
}
}
}
}
}
int AreDuplicates[50000];
double **UniquePlanes;
UniquePlanes = allocMatrix(50000,3);
for (i=0;i<50000;i++) AreDuplicates[i] = 0;
int nrPlanes=0;
for (i=0;i<nrFilled-1;i++){
if (AreDuplicates[i] == 1){
continue;
}
for (j=i+1;j<nrFilled;j++){
if (Families[i][0] == Families[j][0] &&
Families[i][1] == Families[j][1] &&
Families[i][2] == Families[j][2] &&
AreDuplicates[j] == 0){
AreDuplicates[j] = 1;
}
}
UniquePlanes[nrPlanes][0] = (double)Families[i][0];
UniquePlanes[nrPlanes][1] = (double)Families[i][1];
UniquePlanes[nrPlanes][2] = (double)Families[i][2];
nrPlanes++;
}
double **hkls;
hkls = allocMatrix(nrPlanes,12);
CorrectHKLsLatC(LatC,UniquePlanes,nrPlanes,hkls);
SortFunc(nrPlanes,11,hkls,3,-1);
double DsMin = wl/(2*sind((atand(MaxRingRad/Lsd))/2));
for (i=0;i<nrPlanes;i++){
if (hkls[i][3] < DsMin){
nrPlanes = i;
break;
}
}
int RingNr = 1;
double DsTemp = hkls[0][3];
hkls[0][4] = 1;
hkls[0][8] = asind(wl/(2*(hkls[0][3])));
hkls[0][9] = hkls[0][8]*2;
hkls[0][10] = Lsd*tand(hkls[0][9]);
for (i=1;i<nrPlanes;i++){
if (fabs(hkls[i][3] - DsTemp) < Epsilon){
hkls[i][4] = RingNr;
}else{
DsTemp = hkls[i][3];
RingNr++;
hkls[i][4] = RingNr;
}
hkls[i][8] = asind(wl/(2*(hkls[i][3])));
hkls[i][9] = hkls[i][8]*2;
hkls[i][10] = Lsd*tand(hkls[i][9]);
}
char *fn = "hkls.csv";
FILE *fp;
fp = fopen(fn,"w");
fprintf(fp,"h k l D-spacing RingNr\n");
for (i=0;i<nrPlanes;i++){
fprintf(fp,"%.0f %.0f %.0f %f %.0f %f %f %f %f %f %f\n",hkls[i][0],
hkls[i][1],hkls[i][2],hkls[i][3],hkls[i][4],
hkls[i][5],hkls[i][6],hkls[i][7],hkls[i][8],
hkls[i][9],hkls[i][10]);
}
}
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 spcset(struct spcprm *spc)
{
static const char *function = "spcset";
char ctype[9], ptype, xtype;
int restreq, status;
double alpha, beta_r, crvalX, dn_r, dXdS, epsilon, G, m, lambda_r, n_r,
t, restfrq, restwav, theta;
struct wcserr **err;
if (spc == 0x0) return SPCERR_NULL_POINTER;
err = &(spc->err);
if (undefined(spc->crval)) {
return wcserr_set(WCSERR_SET(SPCERR_BAD_SPEC_PARAMS),
"Spectral crval is undefined");
}
memset((spc->type)+4, 0, 4);
spc->code[3] = '\0';
wcsutil_blank_fill(4, spc->type);
wcsutil_blank_fill(3, spc->code);
spc->w[0] = 0.0;
/* Analyse the spectral axis type. */
memset(ctype, 0, 9);
strncpy(ctype, spc->type, 4);
if (*(spc->code) != ' ') {
sprintf(ctype+4, "-%s", spc->code);
}
restfrq = spc->restfrq;
restwav = spc->restwav;
if ((status = spcspxe(ctype, spc->crval, restfrq, restwav, &ptype, &xtype,
&restreq, &crvalX, &dXdS, &(spc->err)))) {
return status;
}
/* Satisfy rest frequency/wavelength requirements. */
if (restreq) {
if (restreq == 3 && restfrq == 0.0 && restwav == 0.0) {
/* VRAD-V2F, VOPT-V2W, and ZOPT-V2W require the rest frequency or */
/* wavelength for the S-P and P-X transformations but not for S-X */
/* so supply a phoney value. */
restwav = 1.0;
}
if (restfrq == 0.0) {
restfrq = C/restwav;
} else {
restwav = C/restfrq;
}
if (ptype == 'F') {
spc->w[0] = restfrq;
} else if (ptype != 'V') {
spc->w[0] = restwav;
} else {
if (xtype == 'F') {
spc->w[0] = restfrq;
} else {
spc->w[0] = restwav;
}
}
}
spc->w[1] = crvalX;
spc->w[2] = dXdS;
/* Set pointers-to-functions for the linear part of the transformation. */
if (ptype == 'F') {
if (strcmp(spc->type, "FREQ") == 0) {
/* Frequency. */
spc->flag = FREQ;
spc->spxP2S = 0x0;
spc->spxS2P = 0x0;
} else if (strcmp(spc->type, "AFRQ") == 0) {
/* Angular frequency. */
spc->flag = AFRQ;
spc->spxP2S = freqafrq;
spc->spxS2P = afrqfreq;
} else if (strcmp(spc->type, "ENER") == 0) {
/* Photon energy. */
spc->flag = ENER;
spc->spxP2S = freqener;
spc->spxS2P = enerfreq;
} else if (strcmp(spc->type, "WAVN") == 0) {
/* Wave number. */
spc->flag = WAVN;
spc->spxP2S = freqwavn;
spc->spxS2P = wavnfreq;
} else if (strcmp(spc->type, "VRAD") == 0) {
/* Radio velocity. */
spc->flag = VRAD;
spc->spxP2S = freqvrad;
spc->spxS2P = vradfreq;
}
} else if (ptype == 'W') {
if (strcmp(spc->type, "WAVE") == 0) {
/* Vacuum wavelengths. */
spc->flag = WAVE;
spc->spxP2S = 0x0;
spc->spxS2P = 0x0;
} else if (strcmp(spc->type, "VOPT") == 0) {
/* Optical velocity. */
spc->flag = VOPT;
spc->spxP2S = wavevopt;
spc->spxS2P = voptwave;
} else if (strcmp(spc->type, "ZOPT") == 0) {
/* Redshift. */
spc->flag = ZOPT;
spc->spxP2S = wavezopt;
spc->spxS2P = zoptwave;
}
} else if (ptype == 'A') {
if (strcmp(spc->type, "AWAV") == 0) {
/* Air wavelengths. */
spc->flag = AWAV;
spc->spxP2S = 0x0;
spc->spxS2P = 0x0;
}
} else if (ptype == 'V') {
if (strcmp(spc->type, "VELO") == 0) {
/* Relativistic velocity. */
spc->flag = VELO;
spc->spxP2S = 0x0;
spc->spxS2P = 0x0;
} else if (strcmp(spc->type, "BETA") == 0) {
/* Velocity ratio (v/c). */
spc->flag = BETA;
spc->spxP2S = velobeta;
spc->spxS2P = betavelo;
}
}
/* Set pointers-to-functions for the non-linear part of the spectral */
/* transformation. */
spc->isGrism = 0;
if (xtype == 'F') {
/* Axis is linear in frequency. */
if (ptype == 'F') {
spc->spxX2P = 0x0;
spc->spxP2X = 0x0;
} else if (ptype == 'W') {
spc->spxX2P = freqwave;
spc->spxP2X = wavefreq;
} else if (ptype == 'A') {
spc->spxX2P = freqawav;
spc->spxP2X = awavfreq;
} else if (ptype == 'V') {
spc->spxX2P = freqvelo;
spc->spxP2X = velofreq;
}
spc->flag += F2S;
} else if (xtype == 'W' || xtype == 'w') {
/* Axis is linear in vacuum wavelengths. */
if (ptype == 'F') {
spc->spxX2P = wavefreq;
spc->spxP2X = freqwave;
} else if (ptype == 'W') {
spc->spxX2P = 0x0;
spc->spxP2X = 0x0;
} else if (ptype == 'A') {
spc->spxX2P = waveawav;
spc->spxP2X = awavwave;
} else if (ptype == 'V') {
spc->spxX2P = wavevelo;
spc->spxP2X = velowave;
}
if (xtype == 'W') {
spc->flag += W2S;
} else {
/* Grism in vacuum. */
spc->isGrism = 1;
spc->flag += GRI;
}
} else if (xtype == 'A' || xtype == 'a') {
/* Axis is linear in air wavelengths. */
if (ptype == 'F') {
spc->spxX2P = awavfreq;
spc->spxP2X = freqawav;
} else if (ptype == 'W') {
spc->spxX2P = awavwave;
spc->spxP2X = waveawav;
} else if (ptype == 'A') {
spc->spxX2P = 0x0;
spc->spxP2X = 0x0;
} else if (ptype == 'V') {
spc->spxX2P = awavvelo;
spc->spxP2X = veloawav;
}
if (xtype == 'A') {
spc->flag += A2S;
} else {
/* Grism in air. */
spc->isGrism = 2;
spc->flag += GRA;
}
} else if (xtype == 'V') {
/* Axis is linear in relativistic velocity. */
if (ptype == 'F') {
spc->spxX2P = velofreq;
spc->spxP2X = freqvelo;
} else if (ptype == 'W') {
spc->spxX2P = velowave;
spc->spxP2X = wavevelo;
} else if (ptype == 'A') {
spc->spxX2P = veloawav;
spc->spxP2X = awavvelo;
} else if (ptype == 'V') {
spc->spxX2P = 0x0;
spc->spxP2X = 0x0;
}
spc->flag += V2S;
}
/* Check for grism axes. */
if (spc->isGrism) {
/* Axis is linear in "grism parameter"; work in wavelength. */
lambda_r = crvalX;
/* Set defaults. */
if (undefined(spc->pv[0])) spc->pv[0] = 0.0;
if (undefined(spc->pv[1])) spc->pv[1] = 0.0;
if (undefined(spc->pv[2])) spc->pv[2] = 0.0;
if (undefined(spc->pv[3])) spc->pv[3] = 1.0;
if (undefined(spc->pv[4])) spc->pv[4] = 0.0;
if (undefined(spc->pv[5])) spc->pv[5] = 0.0;
if (undefined(spc->pv[6])) spc->pv[6] = 0.0;
/* Compute intermediaries. */
G = spc->pv[0];
m = spc->pv[1];
alpha = spc->pv[2];
n_r = spc->pv[3];
dn_r = spc->pv[4];
epsilon = spc->pv[5];
theta = spc->pv[6];
t = G*m/cosd(epsilon);
beta_r = asind(t*lambda_r - n_r*sind(alpha));
t -= dn_r*sind(alpha);
spc->w[1] = -tand(theta);
spc->w[2] *= t / (cosd(beta_r)*cosd(theta)*cosd(theta));
spc->w[3] = beta_r + theta;
spc->w[4] = (n_r - dn_r*lambda_r)*sind(alpha);
spc->w[5] = 1.0 / t;
}
return 0;
}
void GWcsMER::prj_s2x(int nphi, int ntheta, int spt, int sxy,
const double* phi, const double* theta,
double* x, double* y, int* stat) const
{
// Initialize projection if required
if (!m_prjset) {
prj_set();
}
// Set value replication length mphi,mtheta
int mphi;
int mtheta;
if (ntheta > 0) {
mphi = nphi;
mtheta = ntheta;
}
else {
mphi = 1;
mtheta = 1;
ntheta = nphi;
}
// Initialise status code and statistics
int status = 0;
int n_invalid = 0;
// Do phi dependence
const double* phip = phi;
int rowoff = 0;
int rowlen = nphi * sxy;
for (int iphi = 0; iphi < nphi; ++iphi, rowoff += sxy, phip += spt) {
double xi = m_w[0] * (*phip) - m_x0;
double* xp = x + rowoff;
for (int itheta = 0; itheta < mtheta; ++itheta, xp += rowlen) {
*xp = xi;
}
}
// Do theta dependence
const double* thetap = theta;
double* yp = y;
int* statp = stat;
for (int itheta = 0; itheta < ntheta; ++itheta, thetap += spt) {
double eta;
int istat = 0;
if (*thetap <= -90.0 || *thetap >= 90.0) {
eta = 0.0;
istat = 1;
status = 3;
n_invalid++;
} else {
eta = m_r0 * std::log(tand((*thetap+90.0)/2.0)) - m_y0;
}
for (int iphi = 0; iphi < mphi; ++iphi, yp += sxy) {
*yp = eta;
*(statp++) = istat;
}
}
// Return
return;
}
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;
}
void fps_camera::rotatePitch (float direction)
{
pitch += 3*direction*rotateSpeed;
ref.y = tand (pitch);
}
