241 lines
6.5 KiB
C++
241 lines
6.5 KiB
C++
// area.c -- routines to assist with inserting "areas" into FG terrain
|
|
//
|
|
// Written by Curtis Olson, started March 1998.
|
|
//
|
|
// Copyright (C) 1998 Curtis L. Olson - curt@me.umn.edu
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 2 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
//
|
|
// $Id$
|
|
// (Log is kept at end of this file)
|
|
//
|
|
|
|
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
|
|
#include <Include/fg_constants.h>
|
|
|
|
#include "area.hxx"
|
|
#include "point2d.hxx"
|
|
|
|
|
|
// calc new x, y for a rotation
|
|
double rot_x(double x, double y, double theta) {
|
|
return ( x * cos(theta) + y * sin(theta) );
|
|
}
|
|
|
|
|
|
// calc new x, y for a rotation
|
|
double rot_y(double x, double y, double theta) {
|
|
return ( -x * sin(theta) + y * cos(theta) );
|
|
}
|
|
|
|
|
|
// calc new lon/lat given starting lon/lat, and offset radial, and
|
|
// distance. NOTE: distance is specified in meters (and converted
|
|
// internally to radians)
|
|
point2d calc_lon_lat( point2d orig, point2d offset ) {
|
|
point2d result;
|
|
|
|
// printf("calc_lon_lat() offset.theta = %.2f offset.dist = %.2f\n",
|
|
// offset.theta, offset.dist);
|
|
|
|
offset.dist *= METER_TO_NM * NM_TO_RAD;
|
|
|
|
result.lat = asin( sin(orig.lat) * cos(offset.dist) +
|
|
cos(orig.lat) * sin(offset.dist) * cos(offset.theta) );
|
|
|
|
if ( cos(result.lat) < FG_EPSILON ) {
|
|
result.lon = orig.lon; // endpoint a pole
|
|
} else {
|
|
result.lon =
|
|
fmod(orig.lon - asin( sin(offset.theta) * sin(offset.dist) /
|
|
cos(result.lat) ) + FG_PI, FG_2PI) - FG_PI;
|
|
}
|
|
|
|
return(result);
|
|
}
|
|
|
|
|
|
list < point2d >
|
|
batch_cart_to_polar_2d( list < point2d > in_list)
|
|
{
|
|
list < point2d > out_list;
|
|
list < point2d > :: iterator current;
|
|
list < point2d > :: iterator last;
|
|
point2d p;
|
|
|
|
current = in_list.begin();
|
|
last = in_list.end();
|
|
for ( ; current != last ; ++current ) {
|
|
p = cart_to_polar_2d( *current );
|
|
out_list.push_back(p);
|
|
}
|
|
|
|
return out_list;
|
|
}
|
|
|
|
|
|
// given a set of 2d coordinates relative to a center point, and the
|
|
// lon, lat of that center point (specified in degrees), as well as a
|
|
// potential orientation angle, generate the corresponding lon and lat
|
|
// of the original 2d verticies.
|
|
list < point2d >
|
|
gen_area(point2d origin, double angle, list < point2d > cart_list)
|
|
{
|
|
list < point2d > rad_list;
|
|
list < point2d > result_list;
|
|
list < point2d > :: iterator current;
|
|
list < point2d > :: iterator last;
|
|
point2d origin_rad, p;
|
|
|
|
origin_rad.lon = origin.lon * DEG_TO_RAD;
|
|
origin_rad.lat = origin.lat * DEG_TO_RAD;
|
|
|
|
// convert to polar coordinates
|
|
rad_list = batch_cart_to_polar_2d(cart_list);
|
|
|
|
/*
|
|
// display points
|
|
printf("converted to polar\n");
|
|
current = rad_list.begin();
|
|
last = rad_list.end();
|
|
while ( current != last ) {
|
|
printf("(%.2f, %.2f)\n", current->theta, current->dist);
|
|
++current;
|
|
}
|
|
printf("\n");
|
|
*/
|
|
|
|
// rotate by specified angle
|
|
// printf("Rotating points by %.2f\n", angle);
|
|
current = rad_list.begin();
|
|
last = rad_list.end();
|
|
for ( ; current != last ; ++current ) {
|
|
current->theta -= angle;
|
|
while ( current->theta > FG_2PI ) {
|
|
current->theta -= FG_2PI;
|
|
// (*current).theta -= angle;
|
|
// while ( (*current).theta > FG_2PI ) {
|
|
// (*current).theta -= FG_2PI;
|
|
}
|
|
// printf("(%.2f, %.2f)\n", current->theta, current->dist);
|
|
}
|
|
// printf("\n");
|
|
|
|
// find actual lon,lat of coordinates
|
|
// printf("convert to lon, lat relative to %.2f %.2f\n",
|
|
// origin.lon, origin.lat);
|
|
current = rad_list.begin();
|
|
last = rad_list.end();
|
|
for ( ; current != last ; ++current ) {
|
|
p = calc_lon_lat(origin_rad, *current);
|
|
// convert from radians to degress
|
|
p.lon *= RAD_TO_DEG;
|
|
p.lat *= RAD_TO_DEG;
|
|
// printf("(%.8f, %.8f)\n", p.lon, p.lat);
|
|
result_list.push_back(p);
|
|
}
|
|
// printf("\n");
|
|
|
|
return result_list;
|
|
}
|
|
|
|
|
|
// generate an area for a runway
|
|
list < point2d >
|
|
gen_runway_area( double lon, double lat, double heading,
|
|
double length, double width)
|
|
{
|
|
list < point2d > result_list;
|
|
list < point2d > tmp_list;
|
|
list < point2d > :: iterator current;
|
|
list < point2d > :: iterator last;
|
|
|
|
point2d p;
|
|
point2d origin;
|
|
double l, w;
|
|
int i;
|
|
|
|
/*
|
|
printf("runway: lon = %.2f lat = %.2f hdg = %.2f len = %.2f width = %.2f\n",
|
|
lon, lat, heading, length, width);
|
|
*/
|
|
|
|
origin.lon = lon;
|
|
origin.lat = lat;
|
|
l = length / 2.0;
|
|
w = width / 2.0;
|
|
|
|
// generate untransformed runway area vertices
|
|
p.x = l; p.y = w; tmp_list.push_back(p);
|
|
p.x = l; p.y = -w; tmp_list.push_back(p);
|
|
p.x = -l; p.y = -w; tmp_list.push_back(p);
|
|
p.x = -l; p.y = w; tmp_list.push_back(p);
|
|
|
|
/*
|
|
// display points
|
|
printf("Untransformed, unrotated runway\n");
|
|
current = tmp_list.begin();
|
|
last = tmp_list.end();
|
|
while ( current != last ) {
|
|
printf("(%.2f, %.2f)\n", current->x, current->y);
|
|
++current;
|
|
}
|
|
printf("\n");
|
|
*/
|
|
|
|
// rotate, transform, and convert points to lon, lat in degrees
|
|
result_list = gen_area(origin, heading, tmp_list);
|
|
|
|
/*
|
|
// display points
|
|
printf("Results in radians.\n");
|
|
current = result_list.begin();
|
|
last = result_list.end();
|
|
while ( current != last ) {
|
|
printf("(%.8f, %.8f)\n", current->lon, current->lat);
|
|
++current;
|
|
}
|
|
printf("\n");
|
|
*/
|
|
|
|
return result_list;
|
|
}
|
|
|
|
|
|
// $Log$
|
|
// Revision 1.5 1998/10/20 15:49:54 curt
|
|
// tweak ...
|
|
//
|
|
// Revision 1.4 1998/09/09 20:59:53 curt
|
|
// Loop construct tweaks for STL usage.
|
|
// Output airport file to be used to generate airport scenery on the fly
|
|
// by the run time sim.
|
|
//
|
|
// Revision 1.3 1998/09/09 16:26:31 curt
|
|
// Continued progress in implementing the convex hull algorithm.
|
|
//
|
|
// Revision 1.2 1998/09/04 23:04:48 curt
|
|
// Beginning of convex hull genereration routine.
|
|
//
|
|
// Revision 1.1 1998/09/01 19:34:33 curt
|
|
// Initial revision.
|
|
//
|
|
// Revision 1.1 1998/07/20 12:54:05 curt
|
|
// Initial revision.
|
|
//
|
|
//
|