double UpdateAzim(struct control *pcontrol, sort *NN, data *Point, data **P)
/* function calculating the predicted f^ (azimuth) for a given location stored
in Point.
Function returns the azimuth between -pi/2 and pi/2, returns -pi if error
occured and pi if no azimuth could be calculated (for example if no neighbours
were found */
{
int NoNeighbour, i, use=TRUE, numnn;
double azim, sumweights, sumquality;
double Azimuth(double f1, double f2);
int FindNNP(struct control *pcontrol, sort *NN, data *Point, data **P);
int CalcWeightsP(struct control *pcontrol, data *Point);
int CalcPredictor(struct control *pcontrol, data *Point);
if ( (NoNeighbour = FindNNP(pcontrol, NN, Point, P)) < 0 ) {
fprintf(stderr, "ERROR: occured in function FindNNP \n");
return (-1) * pi;
} else if (NoNeighbour == TRUE) {
if (debug)
fprintf(stdout, " INFO: no neighbour for smoothing ... \n");
return pi;
}
if (CalcWeightsP(pcontrol, Point) != 0 ) {
fprintf(stderr, "ERROR: occured in function CalcWeightsP \n");
return (-1)*pi;
}
if (CalcPredictor(pcontrol, Point) != 0 ) {
fprintf(stderr, "ERROR: occured in function CalcPredictorP \n");
return (-1)*pi;
}
// number of neighbours for this location, define abreviation
numnn = Point->numnn;
// calculate the values needed to check if this point should be ignored
// due to a -I option
use = TRUE;
if (pcontrol->ConstNNRadius) {
for (i=1, sumweights=0.0, sumquality=0.0; i<numnn; i++) {
sumweights += Point->wnn[i];
sumquality += Point->nn[i]->quality;
}
if (pcontrol->IgnorePoint == ignore_n && numnn < pcontrol->IgnoreNum) {
use = FALSE;
} else if (pcontrol->IgnorePoint == ignore_w && sumweights < pcontrol->IgnoreNum) {
use = FALSE;
} else if (pcontrol->IgnorePoint == ignore_q && sumquality < pcontrol->IgnoreNum) {
use = FALSE;
}
}
if (use) {
azim = Azimuth(Point->f1,Point->f2);
return azim;
} else {
return pi;
}
}
void animateCamera() {
pScene sc;
pCamera c;
double dazim,delev,azim,elev;
float cfelev,cfazim;
if ( !animate || !ctracking ) return;
sc = cv.scene[currentScene()];
c = sc->camera;
azim = Azimuth(c);
elev = Elevation(c);
switch (cbutton) {
case GLUT_LEFT_BUTTON:
cfelev = 3.0;
cfazim = 3.0;
delev = 2.0*(cury-starty)/(float)sc->par.ys;
dazim = 2.0*(curx-startx)/(float)sc->par.xs;
if ( delev >= 0.0 ) delev *= delev;
else delev = -delev*delev;
if ( dazim >= 0.0 ) dazim *= dazim;
else dazim = -dazim*dazim;
elev += cfelev * delev;
azim -= cfazim * dazim;
break;
case GLUT_MIDDLE_BUTTON:
break;
case GLUT_BUTTON_3:
puts("button3");
break;
case GLUT_BUTTON_4:
puts("button4");
break;
}
updateCamera(sc,c,azim,elev);
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
}
void motionCamera(int x,int y) {
pScene sc;
pCamera c;
double dazim,delev,azim,elev;
float cfelev,cfazim;
/* keep current pos */
curx = x;
cury = y;
if ( animate ) return;
sc = cv.scene[currentScene()];
c = sc->camera;
azim = Azimuth(c);
elev = Elevation(c);
switch (cbutton) {
case GLUT_LEFT_BUTTON:
cfelev = 50.0;
cfazim = 50.0;
delev = cfelev * (y-starty)/(float)sc->par.ys;
dazim = cfazim * (x-startx)/(float)sc->par.xs;
startx = x;
starty = y;
elev += delev;
azim -= dazim;
break;
case GLUT_MIDDLE_BUTTON:
break;
case GLUT_BUTTON_3:
puts("button3");
break;
case GLUT_BUTTON_4:
puts("button4");
break;
}
updateCamera(sc,c,azim,elev);
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
}
/* draw HUD system for flight */
void drawHUD(pScene sc) {
pCamera c;
pMesh mesh;
GLfloat xm,ym,x,y,dx,dy,alt;
double azim,elev;
int i,j;
if ( ddebug ) fprintf(stdout,"drawHUD\n");
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(-0.5,639.5,-0.5,479.5);
c = sc->camera;
mesh = cv.mesh[sc->idmesh];
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glColor3f(0.0,0.5,0.0);
glLineWidth(1.0f);
xm = sc->par.xs / 2.0f;
ym = sc->par.ys / 2.0f;
glRecti(200,160,440,320);
/* altitude */
glColor3f(1.0,0.5,0.0);
output2(230,330,"speed: %6.1f",1000.0f*c->spmod/sc->dmax);
switch(c->vecup) {
case X_AXIS: alt = (c->eye[1]+mesh->xtra)/(mesh->xmax-mesh->xmin); break;
case Y_AXIS: alt = (c->eye[1]+mesh->ytra)/(mesh->ymax-mesh->ymin); break;
case Z_AXIS: alt = (c->eye[1]+mesh->ztra)/(mesh->zmax-mesh->zmin); break;
default: alt = 0.0; break;
}
glColor3f(1.0,0.5,0.0);
output2(350,330,"alt: %9.1f",1000.0f*alt);
/* horiz rulers */
output2(310,139.0f,"azim");
glColor3f(0.0,1.0,0.0);
output2(197,150,"-180");
output2(257,150," -90");
output2(317,150,"0");
output2(377,150," 90");
output2(437,150,"180");
x = 200.0f;
glBegin(GL_LINES);
for (i=1; i<8; i++) {
x += 240.0 / 8.0;
glVertex2f(x,158.0);
glVertex2f(x,162.0);
}
glEnd();
/* vert rulers */
glColor3f(0.0,1.0,0.0);
output2(185,160,"-90");
output2(185,200,"-45");
output2(185,240,"0");
output2(185,280,"45");
output2(185,320,"90");
y = 160.0f;
glBegin(GL_LINES);
for (i=1; i<8; i++) {
y += 160.0 / 8.0;
glVertex2f(198,y);
glVertex2f(202,y);
}
glEnd();
/* azimuth */
azim = Azimuth(c);
if ( azim > 0.0f ) azim = 180.0f - azim;
else if ( azim < 0.0f ) azim = -180.0f - azim;
x = 2.0/3.0*azim + 320.0f;
glColor3f(1.0,0.0,0.0);
glLineWidth(1.0);
output2(x,143.0,"%d",azim>0 ? (int)(azim+0.5) : (int)(azim-0.5));
glBegin(GL_LINES);
glVertex2f(x,166.0);
glVertex2f(x,318.0);
glEnd();
y = 160.0f;
dy = 160.0 / 8.0;
glBegin(GL_LINES);
for (i=0; i<8; i++) {
glVertex2f(x-4,y);
glVertex2f(x+4,y);
for (j=0; j<5; j++) {
glVertex2f(x-2,y+j*dy/5.0);
glVertex2f(x+2,y+j*dy/5.0);
}
y += dy;
}
glEnd();
/* elevation */
elev = Elevation(c);
if ( elev > 90.0f ) y = 320.0f;
else if ( elev < -90.0f ) y = 160.0f;
else y = 8.0/9.0 * elev + 240.0;
glColor3f(1.0,0.0,0.0);
output2(175.0,y,"%5.1f",elev);
glBegin(GL_LINES);
glVertex2f(206.0,y);
glVertex2f(438.0,y);
glEnd();
x = 200.0f;
dx = 240.0f / 8.0f;
glBegin(GL_LINES);
for (i=1; i<=8; i++) {
glVertex2f(x,y-4);
glVertex2f(x,y+4);
for (j=0; j<5; j++) {
glVertex2f(x+j*dx/5.0,y-2);
glVertex2f(x+j*dx/5.0,y+2);
}
x += dx;
}
glEnd();
/* horizon */
glLineWidth(2.0f);
glColor3f(0.0,0.0,1.0);
glBegin(GL_LINES);
glVertex2f(200.0,240.0);
glVertex2f(440.0,240.0);
glEnd();
glLineWidth(1.0f);
/* HUD */
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(310,230);
glVertex2f(330,230);
glVertex2f(310,250);
glVertex2f(330,250);
glVertex2f(310,230);
glVertex2f(310,234);
glVertex2f(330,230);
glVertex2f(330,234);
glVertex2f(310,246);
glVertex2f(310,250);
glVertex2f(330,246);
glVertex2f(330,250);
glEnd();
/*glRecti(318,238,322,242);*/
glColor3f(0.0,1.0,0.0);
glLineWidth(3.0f);
glBegin(GL_LINES);
glVertex2f(320.,235.);
glVertex2f(320.,245.);
glVertex2f(315.,240.);
glVertex2f(325.,240.);
glEnd();
glLineWidth(1.0f);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
}
int main(int argc, char *argv[])
{
int x, y;
unsigned char sitenum, metric, error;
double distance, azimuth;
struct site point[2];
if (argc==1)
{
fprintf(stdout,"\nProvides distance and azimuth bearing between two site locations.\n");
fprintf(stdout,"\nUsage: bearing site1(.qth) site2(.qth)");
fprintf(stdout,"\n bearing site1(.qth) site2(.qth) -metric\n\n");
fflush(stdout);
return 1;
}
metric=0;
error=0;
y=argc-1;
sitenum=0;
point[0].lat=91.0;
point[0].lon=361.0;
point[1].lat=91.0;
point[1].lon=361.0;
/* Scan for command line arguments */
for (x=1; x<=y; x++)
{
if (strcmp(argv[x],"-metric")==0)
{
metric=1;
x++;
}
/* Read Receiver Location */
if (x<=y && argv[x][0] && argv[x][0]!='-' && sitenum<2)
{
point[sitenum]=LoadQTH(argv[x]);
if (point[sitenum].lat>90.0 || point[sitenum].lon>360.0)
fprintf(stderr,"\n%c*** \"%s\" is not a valid .qth file!",7,argv[x]);
else
sitenum++;
}
}
if (sitenum<2)
{
fprintf(stderr,"\n%c*** ERROR: Not enough valid sites specified!\n\n",7);
exit (-1);
}
for (x=0; x<sitenum; x++)
{
if (point[x].lat>90.0 && point[x].lon>360.0)
{
fprintf(stderr,"\n*** ERROR: site #%d not found!",x+1);
error=1;
}
}
if (error)
return -1;
else
{
/* Perform the calculations and display the results */
distance=Distance(point[0],point[1]);
azimuth=Azimuth(point[0],point[1]);
printf("\nThe distance between %s and %s is\n",point[0].name, point[1].name);
if (metric)
printf("%.2f kilometers",distance*KM_PER_MILE);
else
printf("%.2f miles",distance);
printf(" at a bearing of %.2f%c azimuth.\n\n",azimuth, 176);
}
return 0;
}
/* special keys CAMERA mode */
void specCamera(pScene sc,int key) {
pCamera c;
double dd,azim,elev;
GLfloat axe[3];
int keyact;
c = sc->camera;
keyact = glutGetModifiers();
axe[0] = c->speed[2];
axe[1] = 0.0;
axe[2] = -c->speed[0];
dd = sqrt(axe[0]*axe[0] + axe[2]*axe[2]);
if ( dd != 0.0f ) {
axe[0] /= dd;
axe[2] /= dd;
}
switch (key) {
case GLUT_KEY_LEFT:
if ( keyact & GLUT_ACTIVE_SHIFT ) {
c->eye[0] += axe[0]*c->altinc;
c->eye[2] += axe[2]*c->altinc;
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
return;
}
else {
azim = Azimuth(c);
elev = Elevation(c);
azim += dazim;
}
break;
case GLUT_KEY_RIGHT:
if ( keyact & GLUT_ACTIVE_SHIFT ) {
c->eye[0] -= axe[0]*c->altinc;
c->eye[2] -= axe[2]*c->altinc;
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
return;
}
else {
azim = Azimuth(c);
elev = Elevation(c);
azim -= dazim;
}
break;
case GLUT_KEY_UP:
if ( keyact & GLUT_ACTIVE_SHIFT ) {
c->eye[1] += c->altinc;
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
return;
}
else {
azim = Azimuth(c);
elev = Elevation(c);
elev -= delev;
}
break;
case GLUT_KEY_DOWN:
if ( keyact & GLUT_ACTIVE_SHIFT ) {
c->eye[1] -= c->altinc;
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
return;
}
else {
azim = Azimuth(c);
elev = Elevation(c);
elev += delev;
}
break;
default:
return;
}
updateCamera(sc,c,azim,elev);
/* refresh scene */
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
}
