FGFS-4.1/simgear
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Collapse SGGeoCoord into SGTimeZone, and switch timezone search to cartesian math.

Browse Source
This commit is contained in:
James Turner
2010-07-29 10:12:00 +01:00
parent d23491646a
commit e99c3d4705
7 changed files with 79 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
projects/VC90/SimGear.vcproj
View File

@@ -883,14 +883,6 @@
<Filter <Filter
Name="Lib_sgtiming" Name="Lib_sgtiming"
> >
<File
RelativePath="..\..\simgear\timing\geocoord.cxx"
>
</File>
<File
RelativePath="..\..\simgear\timing\geocoord.h"
>
</File>
<File <File
RelativePath="..\..\simgear\timing\lowleveltime.cxx" RelativePath="..\..\simgear\timing\lowleveltime.cxx"
> >

2
simgear/timing/Makefile.am
View File

@@ -3,14 +3,12 @@ includedir = @includedir@/timing
lib_LIBRARIES = libsgtiming.a lib_LIBRARIES = libsgtiming.a
include_HEADERS = \ include_HEADERS = \
geocoord.h \
lowleveltime.h \ lowleveltime.h \
sg_time.hxx \ sg_time.hxx \
timestamp.hxx \ timestamp.hxx \
timezone.h timezone.h
libsgtiming_a_SOURCES = \ libsgtiming_a_SOURCES = \
geocoord.cxx \
lowleveltime.cxx \ lowleveltime.cxx \
sg_time.cxx \ sg_time.cxx \
timestamp.cxx \ timestamp.cxx \

69
simgear/timing/geocoord.cxx
View File

@@ -1,69 +0,0 @@
/* -*- Mode: C++ -*- *****************************************************
* geocoord.h
* Written by Durk Talsma. Started March 1998.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
**************************************************************************/
/*************************************************************************
*
* This file defines a small and simple class to store geocentric
* coordinates. Basically, class SGGeoCoord is intended as a base class for
* any kind of of object, that can be categorized according to its
* location on earth, be it navaids, or aircraft. This class for originally
* written for FlightGear, in order to store Timezone control points.
*
************************************************************************/
#ifdef HAVE_CONFIG_H
# include <simgear_config.h>
#endif
#include <simgear/math/SGMath.hxx>
#include "geocoord.h"
SGGeoCoord::SGGeoCoord(const SGGeoCoord& other)
{
lat = other.lat;
lon = other.lon;
}
SGGeoCoord* SGGeoCoordContainer::getNearest(const SGGeoCoord& ref) const
{
if (data.empty())
return 0;
float maxCosAng = -2;
SGVec3f refVec(ref.getX(), ref.getY(), ref.getZ());
SGGeoCoordVectorConstIterator i, nearest;
for (i = data.begin(); i != data.end(); ++i)
{
float cosAng = dot(refVec, SGVec3f((*i)->getX(), (*i)->getY(), (*i)->getZ()));
if (maxCosAng < cosAng)
{
maxCosAng = cosAng;
nearest = i;
}
}
return *nearest;
}
SGGeoCoordContainer::~SGGeoCoordContainer()
{
SGGeoCoordVectorIterator i = data.begin();
while (i != data.end())
delete *i++;
}

90
simgear/timing/geocoord.h
View File

@@ -1,90 +0,0 @@
/* -*- Mode: C++ -*- *****************************************************
* geocoord.h
* Written by Durk Talsma. Started July 1999.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
**************************************************************************/
/*************************************************************************
*
* This file defines a small and simple class to store geocentric
* coordinates. Basically, class GeoCoord is intended as a base class for
* any kind of of object, that can be categorized according to its
* location on earth, be it navaids, or aircraft. This class for originally
* written for FlightGear, in order to store Timezone control points.
*
************************************************************************/
#ifndef _GEOCOORD_H_
#define _GEOCOORD_H_
#include <simgear/compiler.h>
#include <math.h>
#include <vector>
#include <simgear/constants.h>
class SGGeoCoord
{
protected:
float lat;
float lon;
public:
SGGeoCoord() { lat = 0.0; lon = 0.0;};
SGGeoCoord(float la, float lo) { lat = la; lon = lo;};
SGGeoCoord(const SGGeoCoord& other);
virtual ~SGGeoCoord() {};
void set(float la, float lo) { lat = la; lon = lo; };
float getLat() const { return lat; };
float getLon() const { return lon; };
float getX() const { return cos(SGD_DEGREES_TO_RADIANS*lat) * cos(SGD_DEGREES_TO_RADIANS*lon); };
float getY() const { return cos(SGD_DEGREES_TO_RADIANS*lat) * sin(SGD_DEGREES_TO_RADIANS*lon); };
float getZ() const { return sin(SGD_DEGREES_TO_RADIANS*lat); };
virtual const char * getDescription() {return 0;};
};
typedef std::vector<SGGeoCoord*> SGGeoCoordVector;
typedef std::vector<SGGeoCoord*>::iterator SGGeoCoordVectorIterator;
typedef std::vector<SGGeoCoord*>::const_iterator SGGeoCoordVectorConstIterator;
/************************************************************************
* SGGeoCoordContainer is a simple container class, that stores objects
* derived from SGGeoCoord. Basically, it is a wrapper around an STL vector,
* with some added functionality
***********************************************************************/
class SGGeoCoordContainer
{
protected:
SGGeoCoordVector data;
public:
SGGeoCoordContainer() {};
virtual ~SGGeoCoordContainer();
const SGGeoCoordVector& getData() const { return data; };
SGGeoCoord* getNearest(const SGGeoCoord& ref) const;
};
#endif // _GEO_COORD_H_

10
simgear/timing/sg_time.cxx
View File

@@ -88,9 +88,8 @@ void SGTime::init( double lon_rad, double lat_rad,
SG_LOG( SG_EVENT, SG_INFO, "Reading timezone info from: " SG_LOG( SG_EVENT, SG_INFO, "Reading timezone info from: "
<< zone.str() ); << zone.str() );
tzContainer = new SGTimeZoneContainer( zone.c_str() ); tzContainer = new SGTimeZoneContainer( zone.c_str() );
SGGeod location(SGGeod::fromRad(lon_rad, lat_rad));
SGGeoCoord location( SGD_RADIANS_TO_DEGREES * lat_rad, SGD_RADIANS_TO_DEGREES * lon_rad ); SGTimeZone* nearestTz = tzContainer->getNearest(location);
SGGeoCoord* nearestTz = tzContainer->getNearest(location);
SGPath name( root ); SGPath name( root );
name.append( nearestTz->getDescription() ); name.append( nearestTz->getDescription() );
@@ -283,9 +282,8 @@ void SGTime::updateLocal( double lon_rad, double lat_rad, const string& root ) {
} }
time_t currGMT; time_t currGMT;
time_t aircraftLocalTime; time_t aircraftLocalTime;
SGGeoCoord location( SGD_RADIANS_TO_DEGREES * lat_rad, SGGeod location(SGGeod::fromRad(lon_rad, lat_rad));
SGD_RADIANS_TO_DEGREES * lon_rad ); SGTimeZone* nearestTz = tzContainer->getNearest(location);
SGGeoCoord* nearestTz = tzContainer->getNearest(location);
SGPath zone( root ); SGPath zone( root );
zone.append ( nearestTz->getDescription() ); zone.append ( nearestTz->getDescription() );
zonename = zone.str(); zonename = zone.str();

71
simgear/timing/timezone.cxx
View File

@@ -34,17 +34,18 @@
#include "timezone.h" #include "timezone.h"
SGTimeZone::SGTimeZone(float la, float lo, char* cc, char* desc) : SGTimeZone::SGTimeZone(const SGGeod& geod, char* cc, char* desc) :
SGGeoCoord(la, lo) centerpoint(SGVec3d::fromGeod(geod))
{ {
countryCode = cc; countryCode = cc;
descriptor = desc; descriptor = desc;
} }
/* Build a timezone object from a textline in zone.tab */ /* Build a timezone object from a textline in zone.tab */
SGTimeZone::SGTimeZone(const char *infoString) : SGTimeZone::SGTimeZone(const char *infoString)
SGGeoCoord()
{ {
double lat = 0.0, lon = 0.0;
int i = 0; int i = 0;
while (infoString[i] != '\t') while (infoString[i] != '\t')
i++; i++;
@@ -110,13 +111,14 @@ SGTimeZone::SGTimeZone(const char *infoString) :
strncpy(buffer, (&infoString[start]), size); strncpy(buffer, (&infoString[start]), size);
buffer[size] = 0; buffer[size] = 0;
descriptor = buffer; descriptor = buffer;
centerpoint = SGVec3d::fromGeod(SGGeod::fromDeg(lon, lat));
} }
/* the copy constructor */ /* the copy constructor */
SGTimeZone::SGTimeZone(const SGTimeZone& other) SGTimeZone::SGTimeZone(const SGTimeZone& other)
{ {
lat = other.getLat(); centerpoint = other.centerpoint;
lon = other.getLon();
countryCode = other.countryCode; countryCode = other.countryCode;
descriptor = other.descriptor; descriptor = other.descriptor;
} }
@@ -131,33 +133,56 @@ SGTimeZoneContainer::SGTimeZoneContainer(const char *filename)
if (!(infile)) { if (!(infile)) {
string e = "Unable to open time zone file '"; string e = "Unable to open time zone file '";
throw sg_exception(e + filename + '\''); throw sg_exception(e + filename + '\'');
}
} else { errno = 0;
errno = 0;
while (1) { while (1) {
fgets(buffer, 256, infile); fgets(buffer, 256, infile);
if (feof(infile)) { if (feof(infile)) {
break;
}
for (char *p = buffer; *p; p++) {
if (*p == '#') {
*p = 0;
break; break;
} }
for (char *p = buffer; *p; p++) {
if (*p == '#') {
*p = 0;
break;
}
}
if (buffer[0]) {
data.push_back(new SGTimeZone(buffer));
}
} }
if ( errno ) { if (buffer[0]) {
perror( "SGTimeZoneContainer()" ); zones.push_back(new SGTimeZone(buffer));
errno = 0;
} }
} }
if ( errno ) {
perror( "SGTimeZoneContainer()" );
errno = 0;
}
fclose(infile); fclose(infile);
} }
SGTimeZoneContainer::~SGTimeZoneContainer() SGTimeZoneContainer::~SGTimeZoneContainer()
{ {
TZVec::iterator it = zones.begin();
for (; it != zones.end(); ++it) {
delete *it;
}
} }
SGTimeZone* SGTimeZoneContainer::getNearest(const SGGeod& ref) const
{
SGVec3d refCart(SGVec3d::fromGeod(ref));
SGTimeZone* match = NULL;
double minDist2 = HUGE_VAL;
TZVec::const_iterator it = zones.begin();
for (; it != zones.end(); ++it) {
double d2 = distSqr((*it)->cartCenterpoint(), refCart);
if (d2 < minDist2) {
match = *it;
minDist2 = d2;
}
}
return match;
}

51
simgear/timing/timezone.h
View File

@@ -27,46 +27,38 @@
#ifndef _TIMEZONE_H_ #ifndef _TIMEZONE_H_
#define _TIMEZONE_H_ #define _TIMEZONE_H_
#include <stdio.h>
#include <string> #include <string>
#include <vector>
#include <simgear/timing/geocoord.h> #include <simgear/math/SGMath.hxx>
#include <simgear/math/SGGeod.hxx>
/** /**
* SGTimeZone is derived from geocoord, and stores the timezone centerpoint, * SGTimeZone stores the timezone centerpoint,
* as well as the countrycode and the timezone descriptor. The latter is * as well as the countrycode and the timezone descriptor. The latter is
* used in order to get the local time. * used in order to get the local time.
* *
*/ */
class SGTimeZone : public SGGeoCoord class SGTimeZone
{ {
private: private:
SGVec3d centerpoint; // centre of timezone, in cartesian coordinates
std::string countryCode; std::string countryCode;
std::string descriptor; std::string descriptor;
public: public:
/**
* Default constructor.
*/
SGTimeZone() : SGGeoCoord()
{
countryCode.erase();
descriptor.erase();
};
/** /**
* Build a timezone object with a specifed latitude, longitude, country * Build a timezone object with a specifed latitude, longitude, country
* code, and descriptor * code, and descriptor
* @param la latitude * @param pt centerpoint
* @param lo longitude
* @param cc country code * @param cc country code
* @param desc descriptor * @param desc descriptor
*/ */
SGTimeZone(float la, float lo, char* cc, char* desc); SGTimeZone(const SGGeod& pt, char* cc, char* desc);
/** /**
* Build a timezone object from a textline in zone.tab * Build a timezone object from a textline in zone.tab
@@ -80,28 +72,33 @@ public:
*/ */
SGTimeZone(const SGTimeZone &other); SGTimeZone(const SGTimeZone &other);
/**
* Virutal destructor
*/
virtual ~SGTimeZone() { };
/** /**
* Return the descriptor string * Return the descriptor string
* @return descriptor string (char array) * @return descriptor string (char array)
*/ */
virtual const char * getDescription() { return descriptor.c_str(); }; const char * getDescription() { return descriptor.c_str(); };
const SGVec3d& cartCenterpoint() const
{
return centerpoint;
}
}; };
/** /**
* SGTimeZoneContainer is derived from SGGeoCoordContainer, and has some * SGTimeZoneContainer
* added functionality.
*/ */
class SGTimeZoneContainer : public SGGeoCoordContainer class SGTimeZoneContainer
{ {
public: public:
SGTimeZoneContainer(const char *filename); SGTimeZoneContainer(const char *filename);
virtual ~SGTimeZoneContainer(); ~SGTimeZoneContainer();
SGTimeZone* getNearest(const SGGeod& ref) const;
private:
typedef std::vector<SGTimeZone*> TZVec;
TZVec zones;
}; };