fly/flightgear
1
0
Fork 0
Code Activity

Initial revision.

Browse source
This commit is contained in:
curt 1999-08-10 03:40:34 +00:00
parent 21f888a43f
commit b645c8cf7e
31 changed files with 3901 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
src/WeatherCM/FGAirPressureItem.cpp Normal file
View file

@ -0,0 +1,45 @@
/*****************************************************************************
Module: FGAirPressureItem.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: FGMicroWeather
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Operator< definition for the item
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGAirPressureItem.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/

119
src/WeatherCM/FGAirPressureItem.h Normal file
View file

@ -0,0 +1,119 @@
/*****************************************************************************
Header: FGAirPressureItem.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Air pressure item that is stored in the micro weather class
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
08.06.1999 Christian Mayer Added international air preasure formula
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGAirPressureItem_H
#define FGAirPressureItem_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGWeatherDefs.h"
#include <math.h>
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
class FGAirPressureItem;
FGAirPressureItem operator-(const FGAirPressureItem& arg);
/****************************************************************************/
/* CLASS DECLARATION */
/* NOTE: The value stored in 'value' is the air preasure that we'd have at */
/* an altitude of 0.0 The correct airpreasure at the stored altitude */
/* gets calulated when getValue() is called. */
/****************************************************************************/
class FGAirPressureItem
{
private:
WeatherPrecition value;
protected:
public:
FGAirPressureItem(const WeatherPrecition& v) {value = v;}
FGAirPressureItem() {value = FG_WEATHER_DEFAULT_AIRPRESSURE;}
//WeatherPrecition getValue(WeatherPrecition alt) { return value * pow(1.0 - 0.0065*alt/288.0, 5.255); };
WeatherPrecition getValue(const WeatherPrecition& alt) const
{
return (WeatherPrecition)((value / 101325.0) *
(
1.01325e5 + alt * (-1.19459535223623e1 + alt * (5.50461110007561e-4 + alt * (-1.13574703113648e-8 + alt * 8.61601726143988e-14)))
));
};
FGAirPressureItem& operator*=(const WeatherPrecition& arg);
FGAirPressureItem& operator+=(const FGAirPressureItem& arg);
FGAirPressureItem& operator-=(const FGAirPressureItem& arg);
friend FGAirPressureItem operator-(const FGAirPressureItem& arg);
};
inline FGAirPressureItem& FGAirPressureItem::operator*= (const WeatherPrecition& arg)
{
value *= arg;
return *this;
}
inline FGAirPressureItem& FGAirPressureItem::operator+= (const FGAirPressureItem& arg)
{
value += arg.value;
return *this;
}
inline FGAirPressureItem& FGAirPressureItem::operator-= (const FGAirPressureItem& arg)
{
value -= arg.value;
return *this;
}
inline FGAirPressureItem operator-(const FGAirPressureItem& arg)
{
return FGAirPressureItem(-arg.value);
}
/****************************************************************************/
#endif /*FGAirPressureItem_H*/

63
src/WeatherCM/FGCloud.h Normal file
View file

@ -0,0 +1,63 @@
/*****************************************************************************
Header: FGCloud.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Header for the cloud class
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGCloud_H
#define FGCloud_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGWeatherFeature.h"
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGCloud:FGWeatherFeature
{
private:
protected:
public:
};
/****************************************************************************/
#endif /*FGCloud_H*/

50
src/WeatherCM/FGCloudItem.cpp Normal file
View file

@ -0,0 +1,50 @@
/*****************************************************************************
Module: FGCloudItem.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: FGMicroWeather
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Operator< definition for the item
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGCloudItem.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
bool operator<(const FGCloudItem& arg1, const FGCloudItem& arg2)
{
return arg1.alt < arg2.alt;
}

71
src/WeatherCM/FGCloudItem.h Normal file
View file

@ -0,0 +1,71 @@
/*****************************************************************************
Header: FGCloudItem.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Air pressure item that is stored in the micro weather class
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGCloudItem_H
#define FGCloudItem_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGWeatherDefs.h"
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGCloudItem
{
private:
protected:
public:
WeatherPrecition value;
WeatherPrecition alt;
FGCloudItem(const WeatherPrecition& a, const WeatherPrecition& v) {alt = a; value = v;}
FGCloudItem(const WeatherPrecition& v) {alt = 0.0; value = v;}
FGCloudItem() {alt = 0.0; value = FG_WEATHER_DEFAULT_AIRPRESSURE;}
friend bool operator<(const FGCloudItem& arg1, const FGCloudItem& arg2);
};
/****************************************************************************/
#endif /*FGCloudItem_H*/

245
src/WeatherCM/FGGlobalWeatherDatabase.cpp Normal file
View file

@ -0,0 +1,245 @@
/*****************************************************************************
Module: FGGlobalWeatherDatabase.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: main program
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Database for the global weather
This database is only called by the local database and by the weather
simulator driving this database
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGGlobalWeatherDatabase.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
/****************************************************************************/
/* Interpolate p which lies inside the triangle x1, x2, x3 */
/* */
/* x3\ Do this by calulating q and linear interpolate its */
/* |\ \ value as it's laying between x1 and x2. */
/* | \ \ Then interpolate p as it lays between p and x3 */
/* | \ \ */
/* | p \ Advantages: p has exactly the value of a corner */
/* | \ \ when it's laying on it. */
/* | \ \ If p isn't in the triangle the algoritm */
/* x1------q------x2 extrapolates it's value */
/****************************************************************************/
template<class P, class V>
V triangle_interpolate(const P& x1, const V& v1, const P& x2, const V& v2, const P& x3, const V& v3, const P& p)
{
P q;
V q_value;
q = x1 + (x2 - x1)*( ((x3-x1).x()*(x1-x2).y() - (x1-x2).x()*(x3-x1).y())/((p-x3).x()*(x2-x1).y() - (x2-x1).x()*(p-x3).y()) );
q_value = v1 + (v2 - v1) * (x1.distance3D(q) / x1.distance3D(x2));
return q_value + (v3 - q_value) * (q.distance3D(p) / q.distance3D(x3));
}
/****************************************************************************/
/* Constructor and Destructor */
/****************************************************************************/
FGGlobalWeatherDatabase::FGGlobalWeatherDatabase(const FGGlobalWeatherDatabaseStatus& s)
{
DatabaseStatus = s;
}
FGGlobalWeatherDatabase::~FGGlobalWeatherDatabase()
{
}
/****************************************************************************/
/* Get the physical properties on the specified point p */
/* do this by interpolating between the 3 closest points */
/****************************************************************************/
FGPhysicalProperties FGGlobalWeatherDatabase::get(const Point2D& p) const
{
WeatherPrecition distance[3]; //store the 3 closest distances
FGPhysicalProperties2DVectorConstIt iterator[3]; //and the coresponding iterators
WeatherPrecition d;
distance[0] = 9.46e15; //init with a distance that every calculated
distance[1] = 9.46e15; //distance is guranteed to be shorter as
distance[2] = 9.46e15; //9.46e15 metres are 1 light year...
for (FGPhysicalProperties2DVectorConstIt it=database.begin(); it!=database.end(); it++)
{ //go through the whole database
d = it->p.distance2Dsquared(p);
if (d<distance[0])
{
distance[2] = distance[1]; distance[1] = distance[0]; distance[0] = d;
iterator[2] = iterator[1]; iterator[1] = iterator[0]; iterator[0] = it;
//NOTE: The last line causes a warning that an unitialiced variable
//is used. You can ignore this warning here.
}
else if (d<distance[1])
{
distance[2] = distance[1]; distance[1] = d;
iterator[2] = iterator[1]; iterator[1] = it;
}
else if (d<distance[2])
{
distance[2] = d;
iterator[2] = it;
}
}
//now I've got the closest entry in xx[0], the 2nd closest in xx[1] and the
//3rd in xx[2];
//interpolate now:
return triangle_interpolate(
iterator[0]->p, (FGPhysicalProperties)*iterator[0],
iterator[1]->p, (FGPhysicalProperties)*iterator[1],
iterator[2]->p, (FGPhysicalProperties)*iterator[2], p);
}
/****************************************************************************/
/* update the database. Since the last call we had dt seconds */
/****************************************************************************/
void FGGlobalWeatherDatabase::update(const WeatherPrecition& dt)
{
// I've got nothing to update here (yet...)
}
/****************************************************************************/
/* Add a physical property on the specified point p */
/****************************************************************************/
void FGGlobalWeatherDatabase::add(const Point2D& p, const FGPhysicalProperties& x)
{
FGPhysicalProperties2D e;
e.p = p;
e.Wind = x.Wind;
e.Turbulence = x.Turbulence;
e.Temperature = x.Temperature;
e.AirPressure = x.AirPressure;
e.VaporPressure = x.VaporPressure;
e.Clouds = x.Clouds;
e.SnowRainIntensity = x.SnowRainIntensity;
e.snowRainType = x.snowRainType;
e.LightningProbability = x.LightningProbability;
database.push_back(e);
}
/****************************************************************************/
/* Change the closest physical property to p. If p is further away than */
/* tolerance I'm returning false otherwise true */
/****************************************************************************/
bool FGGlobalWeatherDatabase::change(const FGPhysicalProperties2D& p, const WeatherPrecition& tolerance)
{
for (FGPhysicalProperties2DVectorIt it = database.begin(); it != database.end(); it++)
{
if (it->p.distance3Dsquared(p.p) < (tolerance*tolerance))
{ //assume that's my point
(*it) = p;
return true;
}
}
return false;
}
/****************************************************************************/
/* Get all, but at least min, stored point in the circle around p with the */
/* radius r */
/****************************************************************************/
FGPhysicalProperties2DVector FGGlobalWeatherDatabase::getAll(const Point2D& p, const WeatherPrecition& r, const unsigned int& min)
{
FGPhysicalProperties2DVector ret_list;
if ((DatabaseStatus == FGGlobalWeatherDatabase_only_static)
||(DatabaseStatus == FGGlobalWeatherDatabase_working) )
{ //doest it make sense?
FGPhysicalProperties2DVectorIt *it; //store the closest entries
WeatherPrecition *d;
unsigned int act_it = 0;
int i;
it = new FGPhysicalProperties2DVectorIt[min+1];
d = new WeatherPrecition[min+1];
for (it[0]=database.begin(); it[act_it]!=database.end(); it[act_it]++)
{ //go through the whole database
d[act_it] = it[act_it]->p.distance2Dsquared(p);
if (r >= d[act_it])
{ //add it
ret_list.push_back(*it[act_it]);
}
else
{
if (act_it>0)
{ //figure out if this distance belongs to the closest ones
WeatherPrecition dummy;
FGPhysicalProperties2DVectorIt dummyIt;
for (i = act_it++; i >= 0;)
{
if (d[i] >= d[--i])
{
act_it--;
break; //nope => stop
}
//swap both
dummy =d[i]; d[i] = d[i+1]; d[i+1] = dummy;
dummyIt = it[i]; it[i] = it[i+1]; it[i+1] = dummyIt;
}
}
}
}
if (ret_list.size()<min)
{
for(i = 0; (i < (min - ret_list.size())) && (ret_list.size() < database.size()); i++)
ret_list.push_back(*it[i]);
}
delete d;
delete it;
}
return ret_list;
}

144
src/WeatherCM/FGGlobalWeatherDatabase.h Normal file
View file

@ -0,0 +1,144 @@
/*****************************************************************************
Header: FGGlobalWeatherDatabase.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Database for the global weather
This database is only called by the local database and by the weather
simulator driving this database
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
30.06.1999 Christian Mayer STL portability
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGGlobalWeatherDatabase_H
#define FGGlobalWeatherDatabase_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGPhysicalProperties.h"
#include "FGPhysicalProperty.h"
#include <Include/compiler.h>
#include <vector>
#include STL_IOSTREAM
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
FG_USING_STD(vector);
FG_USING_STD(iostream);
FG_USING_NAMESPACE(std);
enum FGGlobalWeatherDatabaseStatus {
FGGlobalWeatherDatabase_not_used,
FGGlobalWeatherDatabase_switched_off,
FGGlobalWeatherDatabase_only_static,
FGGlobalWeatherDatabase_working
};
class FGGlobalWeatherDatabase;
ostream& operator<< ( ostream& out, const FGGlobalWeatherDatabase& p );
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGGlobalWeatherDatabase
{
private:
protected:
FGGlobalWeatherDatabaseStatus DatabaseStatus;
FGPhysicalProperties2DVector database;
public:
/************************************************************************/
/* Constructor and Destructor */
/************************************************************************/
FGGlobalWeatherDatabase(const FGGlobalWeatherDatabaseStatus& s = FGGlobalWeatherDatabase_not_used);
~FGGlobalWeatherDatabase();
/************************************************************************/
/* Get the physical properties on the specified point p */
/************************************************************************/
FGPhysicalProperties get(const Point2D& p) const;
inline FGPhysicalProperty get(const Point3D& p) const {return FGPhysicalProperty(get(Point2D(p)), p.elev());}
/************************************************************************/
/* update the database. Since the last call we had dt seconds */
/************************************************************************/
void update(const WeatherPrecition& dt);
/************************************************************************/
/* Add a physical property on the specified point p */
/************************************************************************/
void add(const Point2D& p, const FGPhysicalProperties& x);
inline void add(const FGPhysicalProperties2D& x) {database.push_back(x);}
/************************************************************************/
/* Change the closest physical property to p. If p is further away than */
/* tolerance I'm returning false otherwise true */
/************************************************************************/
bool change(const FGPhysicalProperties2D& p, const WeatherPrecition& tolerance = 0.0000001);
/************************************************************************/
/* Get all stored points in the circle around p with the radius r, but */
/* at least min points. */
/************************************************************************/
FGPhysicalProperties2DVector getAll(const Point2D& p, const WeatherPrecition& r, const unsigned int& min = 0);
/************************************************************************/
/* get/set the operating status of the database */
/************************************************************************/
FGGlobalWeatherDatabaseStatus getDatabaseStatus(void) const { return DatabaseStatus; }
void setDatabaseStatus(const FGGlobalWeatherDatabaseStatus& s) { DatabaseStatus = s; }
/************************************************************************/
/* Dump the whole database */
/************************************************************************/
//friend istream& operator>> ( istream&, Point3D& );
friend ostream& operator<< ( ostream& out, const FGGlobalWeatherDatabase& p );
};
inline ostream& operator<< ( ostream& out, const FGGlobalWeatherDatabase& p )
{
//out << "Database status: " << DatabaseStatus << "\n";
out << "Database number of entries: " << p.database.size() << "\n";
for (FGPhysicalProperties2DVector::const_iterator it = p.database.begin(); it != p.database.end(); it++)
out << "Next entry: " << *it;
return out;
}
/****************************************************************************/
#endif /*FGGlobalWeatherDatabase_H*/

339
src/WeatherCM/FGLocalWeatherDatabase.cpp Normal file
View file

@ -0,0 +1,339 @@
/*****************************************************************************
Module: FGLocalWeatherDatabase.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: main program
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Database for the local weather
This database is the only one that gets called from FG
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGLocalWeatherDatabase.h"
#include "FGVoronoi.h"
#include "fg_constants.h"
#include <Aircraft/aircraft.hxx>
#include <Include/fg_constants.h>
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
/****************************************************************************/
/* return the index (better: ID) of the area with point p */
/****************************************************************************/
unsigned int FGLocalWeatherDatabase::AreaWith(const Point2D& p) const
{
for (FGMicroWeatherList::size_type i = 0; i != WeatherAreas.size(); i++)
{
if (WeatherAreas[i].hasPoint(p) == true)
return i+1;
}
return 0; //nothing found
}
/****************************************************************************/
/* make tiles out of points on a 2D plane */
/****************************************************************************/
void FGLocalWeatherDatabase::tileLocalWeather(const FGPhysicalProperties2DVector& EntryList)
{
FGVoronoiInputList input;
for (FGPhysicalProperties2DVector::const_iterator it1 = EntryList.begin(); it1 != EntryList.end(); it1++)
input.push_back(FGVoronoiInput(it1->p, *it1));
FGVoronoiOutputList output = Voronoiate(input);
for (FGVoronoiOutputList::iterator it2 = output.begin(); it2 != output.end(); it2++)
WeatherAreas.push_back(FGMicroWeather(it2->value, it2->boundary));
}
/****************************************************************************/
/* Constructor and Destructor */
/****************************************************************************/
FGLocalWeatherDatabase* FGLocalWeatherDatabase::theFGLocalWeatherDatabase = 0;
FGLocalWeatherDatabase *WeatherDatabase;
FGLocalWeatherDatabase::FGLocalWeatherDatabase(const Point3D& posititon, const WeatherPrecition& visibility, const DatabaseWorkingType& type)
{
cerr << "Initializing FGLocalWeatherDatabase\n";
cerr << "-----------------------------------\n";
if (theFGLocalWeatherDatabase)
{
//FG_LOG( FG_GENERAL, FG_ALERT, "Error: only one local weather allowed" );
cerr << "Error: only one local weather allowed";
exit(-1);
}
setWeatherVisibility(visibility);
//WeatherVisibility = visibility;
DatabaseStatus = type;
global = 0; //just get sure...
last_known_position = posititon;
theFGLocalWeatherDatabase = this;
switch(DatabaseStatus)
{
case use_global:
{
global = new FGGlobalWeatherDatabase; //initialize GlobalDatabase
global->setDatabaseStatus(FGGlobalWeatherDatabase_working);
tileLocalWeather(global->getAll(posititon, WeatherVisibility, 3));
}
break;
case distant:
cerr << "FGLocalWeatherDatabase error: Distant database isn't implemented yet!\n";
cerr << " using random mode instead!\n";
case random:
case manual:
case default_mode:
{
vector<Point2D> emptyList;
WeatherAreas.push_back(FGMicroWeather(FGPhysicalProperties2D(), emptyList)); //in these cases I've only got one tile
}
break;
default:
cerr << "FGLocalWeatherDatabase error: Unknown database type specified!\n";
};
}
FGLocalWeatherDatabase::~FGLocalWeatherDatabase()
{
//Tidying up:
//delete every stored area
WeatherAreas.erase(WeatherAreas.begin(), WeatherAreas.end());
//delete global database if necessary
if (DatabaseStatus == use_global)
delete global;
}
/****************************************************************************/
/* reset the whole database */
/****************************************************************************/
void FGLocalWeatherDatabase::reset(const DatabaseWorkingType& type)
{
//delete global database if necessary
if ((DatabaseStatus == use_global) && (type != use_global))
delete global;
DatabaseStatus = type;
if (DatabaseStatus == use_global)
tileLocalWeather(global->getAll(last_known_position, WeatherVisibility, 3));
//delete every stored area
WeatherAreas.erase(WeatherAreas.begin(), WeatherAreas.end());
}
/****************************************************************************/
/* update the database. Since the last call we had dt seconds */
/****************************************************************************/
void FGLocalWeatherDatabase::update(const WeatherPrecition& dt)
{
if (DatabaseStatus==use_global)
global->update(dt);
}
void FGLocalWeatherDatabase::update(const Point3D& p) //position has changed
{
last_known_position = p;
//cerr << "****\nupdate inside\n";
//cerr << "Parameter: " << p << "\n";
//cerr << "****\n";
}
void FGLocalWeatherDatabase::update(const Point3D& p, const WeatherPrecition& dt) //time and/or position has changed
{
last_known_position = p;
if (DatabaseStatus==use_global)
global->update(dt);
}
/****************************************************************************/
/* Get the physical properties on the specified point p out of the database */
/****************************************************************************/
FGPhysicalProperty FGLocalWeatherDatabase::get(const Point3D& p) const
{
unsigned int a = AreaWith(p);
if (a != 0)
return WeatherAreas[a-1].get(p.elev());
else //point is outside => ask GlobalWeatherDatabase
return global->get(p);
}
WeatherPrecition FGLocalWeatherDatabase::getAirDensity(const Point3D& p) const
{
FGPhysicalProperty dummy;
unsigned int a = AreaWith(p);
if (a != 0)
dummy = WeatherAreas[a-1].get(p.elev());
else //point is outside => ask GlobalWeatherDatabase
dummy = global->get(p);
return
(dummy.AirPressure*FG_WEATHER_DEFAULT_AIRDENSITY*FG_WEATHER_DEFAULT_TEMPERATURE) /
(dummy.Temperature*FG_WEATHER_DEFAULT_AIRPRESSURE);
}
/****************************************************************************/
/* Add a weather feature at the point p and surrounding area */
/****************************************************************************/
void FGLocalWeatherDatabase::addWind(const FGWindItem& x, const Point2D& p)
{
unsigned int a = AreaWith(p);
if (a != 0)
WeatherAreas[a-1].addWind(x);
}
void FGLocalWeatherDatabase::addTurbulence(const FGTurbulenceItem& x, const Point2D& p)
{
unsigned int a = AreaWith(p);
if (a != 0)
WeatherAreas[a-1].addTurbulence(x);
}
void FGLocalWeatherDatabase::addTemperature(const FGTemperatureItem& x, const Point2D& p)
{
unsigned int a = AreaWith(p);
if (a != 0)
WeatherAreas[a-1].addTemperature(x);
}
void FGLocalWeatherDatabase::addAirPressure(const FGAirPressureItem& x, const Point2D& p)
{
unsigned int a = AreaWith(p);
if (a != 0)
WeatherAreas[a-1].addAirPressure(x);
}
void FGLocalWeatherDatabase::addVaporPressure(const FGVaporPressureItem& x, const Point2D& p)
{
unsigned int a = AreaWith(p);
if (a != 0)
WeatherAreas[a-1].addVaporPressure(x);
}
void FGLocalWeatherDatabase::addCloud(const FGCloudItem& x, const Point2D& p)
{
unsigned int a = AreaWith(p);
if (a != 0)
WeatherAreas[a-1].addCloud(x);
}
void FGLocalWeatherDatabase::setSnowRainIntensity(const WeatherPrecition& x, const Point2D& p)
{
unsigned int a = AreaWith(p);
if (a != 0)
WeatherAreas[a-1].setSnowRainIntensity(x);
}
void FGLocalWeatherDatabase::setSnowRainType(const SnowRainType& x, const Point2D& p)
{
unsigned int a = AreaWith(p);
if (a != 0)
WeatherAreas[a-1].setSnowRainType(x);
}
void FGLocalWeatherDatabase::setLightningProbability(const WeatherPrecition& x, const Point2D& p)
{
unsigned int a = AreaWith(p);
if (a != 0)
WeatherAreas[a-1].setLightningProbability(x);
}
void FGLocalWeatherDatabase::addProperties(const FGPhysicalProperties2D& x)
{
if (DatabaseStatus==use_global)
{
global->add(x);
//BAD, BAD, BAD thing I'm doing here: I'm adding to the global database a point that
//changes my voronoi diagram but I don't update it! instead I'm changing one local value
//that could be anywhere!!
//This only *might* work when the plane moves so far so fast that the diagram gets new
//calculated soon...
unsigned int a = AreaWith(x.p);
if (a != 0)
WeatherAreas[a-1].setStoredWeather(x);
}
else
{
unsigned int a = AreaWith(x.p);
if (a != 0)
WeatherAreas[a-1].setStoredWeather(x);
}
}
void FGLocalWeatherDatabase::setProperties(const FGPhysicalProperties2D& x)
{
if (DatabaseStatus==use_global)
{
global->change(x);
//BAD, BAD, BAD thing I'm doing here: I'm adding to the global database a point that
//changes my voronoi diagram but I don't update it! Instead I'm changing one local value
//that could be anywhere!!
//This only *might* work when the plane moves so far so fast that the diagram gets newly
//calculated soon...
unsigned int a = AreaWith(x.p);
if (a != 0)
WeatherAreas[a-1].setStoredWeather(x);
}
else
{
unsigned int a = AreaWith(x.p);
if (a != 0)
WeatherAreas[a-1].setStoredWeather(x);
}
}
void fgUpdateWeatherDatabase(void)
{
//cerr << "FGLocalWeatherDatabase::update()\n";
WeatherDatabase->update( Point3D(
current_aircraft.fdm_state->get_Latitude(),
current_aircraft.fdm_state->get_Longitude(),
current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER) );
}

213
src/WeatherCM/FGLocalWeatherDatabase.h Normal file
View file

@ -0,0 +1,213 @@
/*****************************************************************************
Header: FGLocalWeatherDatabase.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Database for the local weather
This database is the only one that gets called from FG
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
30.06.1999 Christian Mayer STL portability
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGLocalWeatherDatabase_H
#define FGLocalWeatherDatabase_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
//This is only here for smoother code change. In the end the WD should be clean
//of *any* OpenGL:
#ifdef HAVE_WINDOWS_H
# include <windows.h>
#endif
#include <GL/glut.h>
#include <XGL/xgl.h>
#include "FGPhysicalProperties.h"
#include "FGGlobalWeatherDatabase.h"
#include "FGMicroWeather.h"
#include "FGWeatherFeature.h"
#include "FGWeatherDefs.h"
#include <vector>
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
FG_USING_STD(vector);
FG_USING_NAMESPACE(std);
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGLocalWeatherDatabase
{
private:
protected:
FGGlobalWeatherDatabase *global; //point to the global database
typedef vector<FGMicroWeather> FGMicroWeatherList;
typedef FGMicroWeatherList::iterator FGMicroWeatherListIt;
typedef vector<Point2D> pointVector;
typedef vector<pointVector> tileVector;
/************************************************************************/
/* make tiles out of points on a 2D plane */
/************************************************************************/
void tileLocalWeather(const FGPhysicalProperties2DVector& EntryList);
FGMicroWeatherList WeatherAreas;
WeatherPrecition WeatherVisibility; //how far do I need to simulate the
//local weather? Unit: metres
Point3D last_known_position;
public:
static FGLocalWeatherDatabase *theFGLocalWeatherDatabase;
enum DatabaseWorkingType {
use_global, //use global database for data
manual, //use only user inputs
distant, //use distant information, e.g. like LAN when used in
//a multiplayer environment
random, //generate weather randomly
default_mode //use only default values
};
protected:
DatabaseWorkingType DatabaseStatus;
/************************************************************************/
/* return the index of the area with point p */
/************************************************************************/
unsigned int AreaWith(const Point2D& p) const;
public:
/************************************************************************/
/* Constructor and Destructor */
/************************************************************************/
FGLocalWeatherDatabase(
const Point3D& posititon,
const WeatherPrecition& visibility = DEFAULT_WEATHER_VISIBILIY,
const DatabaseWorkingType& type = PREFERED_WORKING_TYPE);
~FGLocalWeatherDatabase();
/************************************************************************/
/* reset the whole database */
/************************************************************************/
void reset(const DatabaseWorkingType& type = PREFERED_WORKING_TYPE);
/************************************************************************/
/* update the database. Since the last call we had dt seconds */
/************************************************************************/
void update(const WeatherPrecition& dt); //time has changed
void update(const Point3D& p); //position has changed
void update(const Point3D& p, const WeatherPrecition& dt); //time and/or position has changed
/************************************************************************/
/* Get the physical properties on the specified point p */
/************************************************************************/
FGPhysicalProperty get(const Point3D& p) const;
WeatherPrecition getAirDensity(const Point3D& p) const;
/************************************************************************/
/* Add a weather feature at the point p and surrounding area */
/************************************************************************/
void addWind(const FGWindItem& x, const Point2D& p);
void addTurbulence(const FGTurbulenceItem& x, const Point2D& p);
void addTemperature(const FGTemperatureItem& x, const Point2D& p);
void addAirPressure(const FGAirPressureItem& x, const Point2D& p);
void addVaporPressure(const FGVaporPressureItem& x, const Point2D& p);
void addCloud(const FGCloudItem& x, const Point2D& p);
void setSnowRainIntensity(const WeatherPrecition& x, const Point2D& p);
void setSnowRainType(const SnowRainType& x, const Point2D& p);
void setLightningProbability(const WeatherPrecition& x, const Point2D& p);
void addProperties(const FGPhysicalProperties2D& x); //add a property
void setProperties(const FGPhysicalProperties2D& x); //change a property
/************************************************************************/
/* get/set weather visibility */
/************************************************************************/
void setWeatherVisibility(const WeatherPrecition& visibility);
WeatherPrecition getWeatherVisibility(void) const;
};
extern FGLocalWeatherDatabase *WeatherDatabase;
void fgUpdateWeatherDatabase(void);
/****************************************************************************/
/* get/set weather visibility */
/****************************************************************************/
void inline FGLocalWeatherDatabase::setWeatherVisibility(const WeatherPrecition& visibility)
{
if (visibility >= MINIMUM_WEATHER_VISIBILIY)
WeatherVisibility = visibility;
else
WeatherVisibility = MINIMUM_WEATHER_VISIBILIY;
//This code doesn't belong here as this is the optical visibility and not
//the visibility of the weather database (that should be bigger...). The
//optical visibility should be calculated from the vapor pressure e.g.
//But for the sake of a smoother change from the old way to the new one...
GLfloat fog_exp_density;
GLfloat fog_exp2_density;
// for GL_FOG_EXP
fog_exp_density = -log(0.01 / WeatherVisibility);
// for GL_FOG_EXP2
fog_exp2_density = sqrt( -log(0.01) ) / WeatherVisibility;
// Set correct opengl fog density
xglFogf (GL_FOG_DENSITY, fog_exp2_density);
// FG_LOG( FG_INPUT, FG_DEBUG, "Fog density = " << w->fog_density );
//cerr << "FGLocalWeatherDatabase::setWeatherVisibility(" << visibility << "):\n";
//cerr << "Fog density = " << fog_exp_density << "\n";
}
WeatherPrecition inline FGLocalWeatherDatabase::getWeatherVisibility(void) const
{
//cerr << "FGLocalWeatherDatabase::getWeatherVisibility() = " << WeatherVisibility << "\n";
return WeatherVisibility;
}
/****************************************************************************/
#endif /*FGLocalWeatherDatabase_H*/

165
src/WeatherCM/FGMicroWeather.cpp Normal file
View file

@ -0,0 +1,165 @@
/*****************************************************************************
Module: FGMicroWeather.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: FGLocalWeatherDatabase
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Handle the weather areas
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGMicroWeather.h"
#include "fg_constants.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
FGMicroWeather::FGMicroWeather(const FGPhysicalProperties2D& p, const positionList& points)
{
StoredWeather = p;
position = points;
}
FGMicroWeather::~FGMicroWeather()
{
}
/****************************************************************************/
/* Add the features to the micro weather */
/* return succss */
/****************************************************************************/
void FGMicroWeather::addWind(const FGWindItem& x)
{
StoredWeather.Wind.insert(x);
}
void FGMicroWeather::addTurbulence(const FGTurbulenceItem& x)
{
StoredWeather.Turbulence.insert(x);
}
void FGMicroWeather::addTemperature(const FGTemperatureItem& x)
{
StoredWeather.Temperature.insert(x);
}
void FGMicroWeather::addAirPressure(const FGAirPressureItem& x)
{
cerr << "Error: caught attempt to add AirPressure which is logical wrong\n";
//StoredWeather.AirPressure.insert(x);
}
void FGMicroWeather::addVaporPressure(const FGVaporPressureItem& x)
{
StoredWeather.VaporPressure.insert(x);
}
void FGMicroWeather::addCloud(const FGCloudItem& x)
{
StoredWeather.Clouds.insert(x);
}
void FGMicroWeather::setSnowRainIntensity(const WeatherPrecition& x)
{
StoredWeather.SnowRainIntensity = x;
}
void FGMicroWeather::setSnowRainType(const SnowRainType& x)
{
StoredWeather.snowRainType = x;
}
void FGMicroWeather::setLightningProbability(const WeatherPrecition& x)
{
StoredWeather.LightningProbability = x;
}
void FGMicroWeather::setStoredWeather(const FGPhysicalProperties2D& x)
{
StoredWeather = x;
}
/****************************************************************************/
/* return true if p is inside this micro weather */
/* code stolen from $FG_ROOT/Simulator/Objects/fragment.cxx, which was */
/* written by Curtis L. Olson - curt@me.umn.edu */
/****************************************************************************/
template <class T> //template to help with the calulation
inline const int FG_SIGN(const T& x) {
return x < T(0) ? -1 : 1;
}
bool FGMicroWeather::hasPoint(const Point2D& p) const
{
if (position.size()==0)
return true; //no border => this tile is infinite
if (position.size()==1)
return false; //a border on 1 point?!?
//when I'm here I've got at least 2 points
WeatherPrecition t;
signed char side1, side2;
const_positionListIt it = position.begin();
const_positionListIt it2 = it; it2++;
for (;;)
{
if (it2 == position.end())
break;
if (fabs(it->x() - it2->x()) >= FG_EPSILON)
{
t = (it->y() - it2->y()) / (it->x() - it2->x());
side1 = FG_SIGN (t * (StoredWeather.p.x() - it2->x()) + it2->y() - StoredWeather.p.y());
side2 = FG_SIGN (t * ( p.x() - it2->x()) + it2->y() - p.y());
if ( side1 != side2 )
return false; //cout << "failed side check\n";
}
else
{
t = (it->x() - it2->x()) / (it->y() - it2->y());
side1 = FG_SIGN (t * (StoredWeather.p.y() - it2->y()) + it2->x() - StoredWeather.p.x());
side2 = FG_SIGN (t * ( p.y() - it2->y()) + it2->x() - p.x());
if ( side1 != side2 )
return false; //cout << "failed side check\n";
}
it++; it2++;
}
return true;
}

127
src/WeatherCM/FGMicroWeather.h Normal file
View file

@ -0,0 +1,127 @@
/*****************************************************************************
Header: FGMicroWeather.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Store the single weather areas
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
30.06.1999 Christian Mayer STL portability
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGMicroWeather_H
#define FGMicroWeather_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
//Include all the simulated weather features
#include "FGCloud.h"
#include "FGSnowRain.h"
#include "FGAirPressureItem.h"
#include "FGTemperatureItem.h"
#include "FGWindItem.h"
#include "FGTurbulenceItem.h"
#include "FGVaporPressureItem.h"
#include "FGWeatherDefs.h"
#include "FGPhysicalProperties.h"
#include "FGPhysicalProperty.h"
#include <Voronoi/point2d.h>
#include <set>
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
FG_USING_STD(set);
FG_USING_NAMESPACE(std);
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGMicroWeather
{
private:
protected:
typedef vector<Point2D> positionList;
typedef positionList::iterator positionListIt;
typedef positionList::const_iterator const_positionListIt;
positionList position; //the points that specify the outline of the
//micro weather (lat/lon)
FGPhysicalProperties2D StoredWeather; //property if nothing is specified
public:
/************************************************************************/
/* Constructor and Destructor */
/************************************************************************/
FGMicroWeather(const FGPhysicalProperties2D& p, const positionList& points);
~FGMicroWeather();
/************************************************************************/
/* Add a feature to the micro weather */
/************************************************************************/
void addWind(const FGWindItem& x);
void addTurbulence(const FGTurbulenceItem& x);
void addTemperature(const FGTemperatureItem& x);
void addAirPressure(const FGAirPressureItem& x);
void addVaporPressure(const FGVaporPressureItem& x);
void addCloud(const FGCloudItem& x);
void setSnowRainIntensity(const WeatherPrecition& x);
void setSnowRainType(const SnowRainType& x);
void setLightningProbability(const WeatherPrecition& x);
void setStoredWeather(const FGPhysicalProperties2D& x);
/************************************************************************/
/* get physical properties in the micro weather */
/* NOTE: I don't neet to speify a positon as the properties don't */
/* change in a micro weather */
/************************************************************************/
inline FGPhysicalProperty get(const WeatherPrecition& altitude) const
{
return FGPhysicalProperty(StoredWeather, altitude);
}
/************************************************************************/
/* return true if p is inside this micro weather */
/************************************************************************/
inline bool hasPoint(const Point3D& p) const { return hasPoint((Point2D) p); }
bool hasPoint(const Point2D& p) const;
};
/****************************************************************************/
#endif /*FGMicroWeather_H*/

77
src/WeatherCM/FGPhysicalProperties.cpp Normal file
View file

@ -0,0 +1,77 @@
/*****************************************************************************
Module: FGPhysicalProperties.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: main program
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Initialice the FGPhysicalProperties struct to something sensible(?)
HISTORY
------------------------------------------------------------------------------
29.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGPhysicalProperties.h"
#include "FGWeatherDefs.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
FGPhysicalProperties::FGPhysicalProperties()
{
/************************************************************************/
/* This standart constructor fills the class with a standard weather */
/************************************************************************/
Wind.insert(FGWindItem(-1000.0, Point3D(0.0))); //no Wind by default
Wind.insert(FGWindItem(10000.0, Point3D(0.0))); //no Wind by default
Turbulence.insert(FGTurbulenceItem(-1000.0, Point3D(0.0))); //no Turbulence by default
Turbulence.insert(FGTurbulenceItem(10000.0, Point3D(0.0))); //no Turbulence by default
//Initialice with the CINA atmosphere
Temperature.insert(FGTemperatureItem( 0.0, (+15.0+273.16)));
Temperature.insert(FGTemperatureItem(11000.0, (-56.5+273.16)));
Temperature.insert(FGTemperatureItem(20000.0, (-56.5+273.16)));
AirPressure = FGAirPressureItem(101325.0);
VaporPressure.insert(FGVaporPressureItem( 0.0, FG_WEATHER_DEFAULT_VAPORPRESSURE)); //in Pa (I *only* accept SI!)
VaporPressure.insert(FGVaporPressureItem(10000.0, FG_WEATHER_DEFAULT_VAPORPRESSURE)); //in Pa (I *only* accept SI!)
//Clouds.insert(FGCloudItem()) => none
SnowRainIntensity = 0.0;
snowRainType = Rain;
LightningProbability = 0.0;
}

346
src/WeatherCM/FGPhysicalProperties.h Normal file
View file

@ -0,0 +1,346 @@
/*******-*- Mode: C++ -*-************************************************************
Header: FGPhysicalProperties.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Define the simulated physical properties of the weather
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer Changed struct to class
20.06.1999 Christian Mayer added lots of consts
30.06.1999 Christian Mayer STL portability
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGPhysicalProperties_H
#define FGPhysicalProperties_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include <Include/compiler.h>
#include <vector>
#include <set>
FG_USING_STD(vector);
FG_USING_STD(set);
FG_USING_NAMESPACE(std);
#include <Math/point3d.hxx>
#include <Voronoi/point2d.h>
#include "FGWeatherDefs.h"
#include "FGWindItem.h"
#include "FGTurbulenceItem.h"
#include "FGTemperatureItem.h"
#include "FGAirPressureItem.h"
#include "FGVaporPressureItem.h"
#include "FGCloudItem.h"
#include "FGSnowRain.h"
class FGPhysicalProperties
{
public:
set<FGWindItem> Wind; //all Wind vectors
set<FGTurbulenceItem> Turbulence; //all Turbulence vectors
set<FGTemperatureItem> Temperature; //in deg. Kelvin (I *only* accept SI!)
FGAirPressureItem AirPressure; //in Pascal (I *only* accept SI!)
set<FGVaporPressureItem> VaporPressure; //in Pascal (I *only* accept SI!)
set<FGCloudItem> Clouds; //amount of covering and type
WeatherPrecition SnowRainIntensity; //this also stands for hail, snow,...
SnowRainType snowRainType;
WeatherPrecition LightningProbability;
FGPhysicalProperties(); //consructor to fill it with FG standart weather
//return values at specified altitudes
Point3D WindAt(const WeatherPrecition& a) const;
Point3D TurbulenceAt(const WeatherPrecition& a) const;
WeatherPrecition TemperatureAt(const WeatherPrecition& a) const;
WeatherPrecition AirPressureAt(const WeatherPrecition& a) const;
WeatherPrecition VaporPressureAt(const WeatherPrecition& a) const;
FGPhysicalProperties& operator = ( const FGPhysicalProperties& p );
FGPhysicalProperties& operator *= ( const WeatherPrecition& d );
FGPhysicalProperties& operator += ( const FGPhysicalProperties& p);
FGPhysicalProperties& operator -= ( const FGPhysicalProperties& p);
};
typedef vector<FGPhysicalProperties> FGPhysicalPropertiesVector;
typedef FGPhysicalPropertiesVector::iterator FGPhysicalPropertiesVectorIt;
typedef FGPhysicalPropertiesVector::const_iterator FGPhysicalPropertiesVectorConstIt;
class FGPhysicalProperties2D;
ostream& operator<< ( ostream& out, const FGPhysicalProperties2D& p );
class FGPhysicalProperties2D : public FGPhysicalProperties
{
public:
Point2D p; //position of the property (lat/lon)
friend ostream& operator<< ( ostream& out, const FGPhysicalProperties2D& p );
FGPhysicalProperties2D() {}
FGPhysicalProperties2D(const FGPhysicalProperties& prop, const Point2D& pos)
{
Wind = prop.Wind; Turbulence = prop.Turbulence; Temperature = prop.Temperature;
AirPressure = prop.AirPressure; VaporPressure = prop.VaporPressure; p = pos;
}
};
typedef vector<FGPhysicalProperties2D> FGPhysicalProperties2DVector;
typedef FGPhysicalProperties2DVector::iterator FGPhysicalProperties2DVectorIt;
typedef FGPhysicalProperties2DVector::const_iterator FGPhysicalProperties2DVectorConstIt;
inline ostream& operator<< ( ostream& out, const FGPhysicalProperties2D& p )
{
out << "Position: " << p.p << "\nStored Wind: ";
for (set<FGWindItem>::const_iterator WindIt = p.Wind.begin(); WindIt != p.Wind.end(); WindIt++)
out << "(" << WindIt->getValue() << ") at " << WindIt->getAlt() << "m; ";
out << "\nStored Turbulence: ";
for (set<FGTurbulenceItem>::const_iterator TurbulenceIt = p.Turbulence.begin();
TurbulenceIt != p.Turbulence.end();
TurbulenceIt++)
out << "(" << TurbulenceIt->getValue() << ") at " << TurbulenceIt->getAlt() << "m; ";
out << "\nStored Temperature: ";
for (set<FGTemperatureItem>::const_iterator TemperatureIt = p.Temperature.begin();
TemperatureIt != p.Temperature.end();
TemperatureIt++)
out << TemperatureIt->getValue() << " at " << TemperatureIt->getAlt() << "m; ";
out << "\nStored AirPressure: ";
out << p.AirPressure.getValue(0) << " at " << 0 << "m; ";
out << "\nStored VaporPressure: ";
for (set<FGVaporPressureItem>::const_iterator VaporPressureIt = p.VaporPressure.begin();
VaporPressureIt != p.VaporPressure.end();
VaporPressureIt++)
out << VaporPressureIt->getValue() << " at " << VaporPressureIt->getAlt() << "m; ";
return out << "\n";
}
inline FGPhysicalProperties& FGPhysicalProperties::operator = ( const FGPhysicalProperties& p )
{
Wind = p.Wind;
Turbulence = p.Turbulence;
Temperature = p.Temperature;
AirPressure = p.AirPressure;
VaporPressure = p.VaporPressure;
return *this;
}
inline FGPhysicalProperties& FGPhysicalProperties::operator *= ( const WeatherPrecition& d )
{
for (set<FGWindItem>::iterator WindIt = Wind.begin();
WindIt != Wind.end();
WindIt++)
*WindIt *= d;
for (set<FGTurbulenceItem>::iterator TurbulenceIt = Turbulence.begin();
TurbulenceIt != Turbulence.end();
TurbulenceIt++)
*TurbulenceIt *= d;
for (set<FGTemperatureItem>::iterator TemperatureIt = Temperature.begin();
TemperatureIt != Temperature.end();
TemperatureIt++)
*TemperatureIt *= d;
AirPressure *= d;
for (set<FGVaporPressureItem>::iterator VaporPressureIt = VaporPressure.begin();
VaporPressureIt != VaporPressure.end();
VaporPressureIt++)
*VaporPressureIt *= d;
return *this;
}
inline FGPhysicalProperties& FGPhysicalProperties::operator += (const FGPhysicalProperties& p)
{
for (set<FGWindItem>::const_iterator WindIt = p.Wind.begin();
WindIt != p.Wind.end();
WindIt++ )
if (WindIt != Wind.upper_bound( FGWindItem(WindIt->getAlt(), Point3D(0)) ))
Wind.insert(*WindIt);
else
*(Wind.upper_bound( FGWindItem(WindIt->getAlt(), Point3D(0))) ) += WindIt->getValue();
for (set<FGTurbulenceItem>::const_iterator TurbulenceIt = p.Turbulence.begin();
TurbulenceIt != p.Turbulence.end();
TurbulenceIt++)
if (TurbulenceIt != Turbulence.upper_bound( FGTurbulenceItem(TurbulenceIt->getAlt(), Point3D(0)) ))
Turbulence.insert(*TurbulenceIt);
else
*(Turbulence.upper_bound( FGTurbulenceItem(TurbulenceIt->getAlt(), Point3D(0)) )) += TurbulenceIt->getValue();
for (set<FGTemperatureItem>::const_iterator TemperatureIt = p.Temperature.begin();
TemperatureIt != p.Temperature.end();
TemperatureIt++)
if (TemperatureIt != Temperature.upper_bound( FGTemperatureItem(TemperatureIt->getAlt(), 0.0) ))
Temperature.insert(*TemperatureIt);
else
*(Temperature.upper_bound( FGTemperatureItem(TemperatureIt->getAlt(), 0.0) )) += TemperatureIt->getValue();
AirPressure += p.AirPressure.getValue(0.0);
for (set<FGVaporPressureItem>::const_iterator VaporPressureIt = p.VaporPressure.begin();
VaporPressureIt != p.VaporPressure.end();
VaporPressureIt++)
if (VaporPressureIt != VaporPressure.upper_bound( FGVaporPressureItem(VaporPressureIt->getAlt(), 0.0) ))
VaporPressure.insert(*VaporPressureIt);
else
*(VaporPressure.upper_bound( FGVaporPressureItem(VaporPressureIt->getAlt(), 0.0) )) += VaporPressureIt->getValue();
return *this;
}
inline FGPhysicalProperties& FGPhysicalProperties::operator -= (const FGPhysicalProperties& p)
{
for (set<FGWindItem>::const_iterator WindIt = p.Wind.begin();
WindIt != p.Wind.end();
WindIt++)
if (WindIt != Wind.upper_bound( FGWindItem(WindIt->getAlt(), Point3D(0)) ))
Wind.insert(-(*WindIt));
else
*(Wind.upper_bound( FGWindItem(WindIt->getAlt(), Point3D(0)) )) -= WindIt->getValue();
for (set<FGTurbulenceItem>::const_iterator TurbulenceIt = p.Turbulence.begin();
TurbulenceIt != p.Turbulence.end();
TurbulenceIt++)
if (TurbulenceIt != Turbulence.upper_bound( FGTurbulenceItem(TurbulenceIt->getAlt(), Point3D(0)) ))
Turbulence.insert(-(*TurbulenceIt));
else
*(Turbulence.upper_bound( FGTurbulenceItem(TurbulenceIt->getAlt(), Point3D(0)) )) -= TurbulenceIt->getValue();
for (set<FGTemperatureItem>::const_iterator TemperatureIt = p.Temperature.begin();
TemperatureIt != p.Temperature.end();
TemperatureIt++)
if (TemperatureIt != Temperature.upper_bound( FGTemperatureItem(TemperatureIt->getAlt(), 0.0) ))
Temperature.insert(-(*TemperatureIt));
else
*(Temperature.upper_bound( FGTemperatureItem(TemperatureIt->getAlt(), 0.0) )) -= TemperatureIt->getValue();
AirPressure -= p.AirPressure.getValue(0.0);
for (set<FGVaporPressureItem>::const_iterator VaporPressureIt = p.VaporPressure.begin();
VaporPressureIt != p.VaporPressure.end();
VaporPressureIt++)
if (VaporPressureIt != VaporPressure.upper_bound( FGVaporPressureItem(VaporPressureIt->getAlt(), 0.0) ))
VaporPressure.insert(-(*VaporPressureIt));
else
*(VaporPressure.upper_bound( FGVaporPressureItem(VaporPressureIt->getAlt(), 0.0) )) -= VaporPressureIt->getValue();
return *this;
}
inline Point3D FGPhysicalProperties::WindAt(const WeatherPrecition& a) const
{
set<FGWindItem>::const_iterator it = Wind.lower_bound(FGWindItem(a, Point3D(0)));
set<FGWindItem>::const_iterator it2 = it;
it--;
//now I've got it->alt < a < it2->alt so I can interpolate
return ( (it2->getValue() - it->getValue())/(it2->getAlt() - it->getAlt()) )*
(a - it2->getAlt()) +
it2->getValue();
}
inline Point3D FGPhysicalProperties::TurbulenceAt(const WeatherPrecition& a) const
{
set<FGTurbulenceItem>::const_iterator it = Turbulence.lower_bound(FGTurbulenceItem(a, Point3D(0)));
set<FGTurbulenceItem>::const_iterator it2 = it;
it--;
//now I've got it->alt < a < it2->alt so I can interpolate
return ( (it2->getValue() - it->getValue() )/(it2->getAlt() - it->getAlt()) )*
(a - it2->getAlt())+ it2->getValue();
}
inline WeatherPrecition FGPhysicalProperties::TemperatureAt(const WeatherPrecition& a) const
{
set<FGTemperatureItem>::const_iterator it = Temperature.lower_bound(FGTemperatureItem(a, 0));
set<FGTemperatureItem>::const_iterator it2 = it;
it--;
//now I've got it->alt < a < it2->alt so I can interpolate
return ( (it2->getValue() - it->getValue()) / (it2->getAlt() - it->getAlt()) )*
(a - it2->getAlt() )+ it2->getValue();
}
inline WeatherPrecition FGPhysicalProperties::AirPressureAt(const WeatherPrecition& a) const
{
return AirPressure.getValue(a);
}
inline WeatherPrecition FGPhysicalProperties::VaporPressureAt(const WeatherPrecition& a) const
{
set<FGVaporPressureItem>::const_iterator it = VaporPressure.lower_bound(FGVaporPressureItem(a, 0));
set<FGVaporPressureItem>::const_iterator it2 = it;
it--;
//now I've got it->alt < a < it2->alt so I can interpolate
return ( (it2->getValue() - it->getValue() ) / (it2->getAlt() - it->getAlt() ) ) *
(a - it2->getAlt() )+ it2->getValue();
}
inline FGPhysicalProperties operator * (const FGPhysicalProperties& a, const WeatherPrecition& b)
{
return FGPhysicalProperties(a) *= b;
}
inline FGPhysicalProperties operator * (const WeatherPrecition& b, const FGPhysicalProperties& a)
{
return FGPhysicalProperties(a) *= b;
}
inline FGPhysicalProperties operator + (const FGPhysicalProperties& a, const FGPhysicalProperties& b)
{
return FGPhysicalProperties(a) += (FGPhysicalProperties)b;
}
inline FGPhysicalProperties operator - (const FGPhysicalProperties& a, const FGPhysicalProperties& b)
{
return FGPhysicalProperties(a) -= (FGPhysicalProperties)b;
}
/****************************************************************************/
#endif /*FGPhysicalProperties_H*/

71
src/WeatherCM/FGPhysicalProperty.cpp Normal file
View file

@ -0,0 +1,71 @@
/*****************************************************************************
Module: FGPhysicalProperty.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: main program
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Initialice the FGPhysicalProperty struct to something sensible(?)
HISTORY
------------------------------------------------------------------------------
29.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGPhysicalProperty.h"
#include "FGWeatherDefs.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
FGPhysicalProperty::FGPhysicalProperty()
{
Wind.setx(0.0); //Wind vector
Wind.sety(0.0); //Wind vector
Wind.setz(0.0); //Wind vector
Turbulence.setx(0.0); //Turbulence vector
Turbulence.sety(0.0); //Turbulence vector
Turbulence.setz(0.0); //Turbulence vector
Temperature = FG_WEATHER_DEFAULT_TEMPERATURE; //a nice warm day
AirPressure = FG_WEATHER_DEFAULT_AIRPRESSURE; //mbar, that's ground level
VaporPressure = FG_WEATHER_DEFAULT_VAPORPRESSURE; //that gives about 50% relatvie humidity
}
FGPhysicalProperty::FGPhysicalProperty(const FGPhysicalProperties& p, const WeatherPrecition& altitude)
{
Wind = p.WindAt(altitude);
Turbulence = p.TurbulenceAt(altitude);
Temperature = p.TemperatureAt(altitude);
AirPressure = p.AirPressureAt(altitude);
VaporPressure = p.VaporPressureAt(altitude);
}

205
src/WeatherCM/FGPhysicalProperty.h Normal file
View file

@ -0,0 +1,205 @@
/*****************************************************************************
Header: FGPhysicalProperty.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Define the simulated physical property of the weather in one point
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer Changed struct to class
20.06.1999 Christian Mayer added lots of consts
30.06.1999 Christian Mayer STL portability
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGPhysicalProperty_H
#define FGPhysicalProperty_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include <Include/compiler.h>
#include <vector>
FG_USING_STD(vector);
FG_USING_NAMESPACE(std);
#include <Math/point3d.hxx>
#include <Voronoi/point2d.h>
#include "FGWeatherDefs.h"
#include "FGPhysicalProperties.h"
/****************************************************************************/
/* used for output: */
/****************************************************************************/
class FGPhysicalProperty
{
private:
protected:
public:
Point3D Wind; //Wind vector
Point3D Turbulence; //Turbulence vector
WeatherPrecition Temperature; //in deg. Kelvin (I *only* accept SI!)
WeatherPrecition AirPressure; //in Pascal (I *only* accept SI!)
WeatherPrecition VaporPressure; //in Pascal (I *only* accept SI!)
FGPhysicalProperty(); //consructor to fill it with FG standart weather
FGPhysicalProperty(const FGPhysicalProperties& p, const WeatherPrecition& altitude);
//allow calculations for easier handling such as interpolating
FGPhysicalProperty& operator = ( const FGPhysicalProperty& p ); // assignment of a Point3D
FGPhysicalProperty& operator += ( const FGPhysicalProperty& p ); // incrementation by a Point3D
FGPhysicalProperty& operator -= ( const FGPhysicalProperty& p ); // decrementation by a Point3D
FGPhysicalProperty& operator *= ( const double& d ); // multiplication by a constant
FGPhysicalProperty& operator /= ( const double& d ); // division by a constant
friend FGPhysicalProperty operator - (const FGPhysicalProperty& p); // -p1
friend bool operator == (const FGPhysicalProperty& a, const FGPhysicalProperty& b); // p1 == p2?
};
typedef vector<FGPhysicalProperty> FGPhysicalPropertyVector;
typedef FGPhysicalPropertyVector::iterator FGPhysicalPropertyVectorIt;
typedef FGPhysicalPropertyVector::const_iterator FGPhysicalPropertyVectorConstIt;
class FGPhysicalProperty3D : public FGPhysicalProperty
{
private:
protected:
public:
Point3D p; //position of the property (lat/lon/alt)
};
typedef vector<FGPhysicalProperty3D> FGPhysicalProperty3DVector;
typedef FGPhysicalProperty3DVector::iterator FGPhysicalProperty3DVectorIt;
typedef FGPhysicalProperty3DVector::const_iterator FGPhysicalProperty3DVectorConstIt;
inline FGPhysicalProperty& FGPhysicalProperty::operator = ( const FGPhysicalProperty& p )
{
Wind = p.Wind;
Turbulence = p.Turbulence;
Temperature = p.Temperature;
AirPressure = p.AirPressure;
VaporPressure = p.VaporPressure;
return *this;
}
inline FGPhysicalProperty& FGPhysicalProperty::operator += ( const FGPhysicalProperty& p )
{
Wind += p.Wind;
Turbulence += p.Turbulence;
Temperature += p.Temperature;
AirPressure += p.AirPressure;
VaporPressure += p.VaporPressure;
return *this;
}
inline FGPhysicalProperty& FGPhysicalProperty::operator -= ( const FGPhysicalProperty& p )
{
Wind -= p.Wind;
Turbulence -= p.Turbulence;
Temperature -= p.Temperature;
AirPressure -= p.AirPressure;
VaporPressure -= p.VaporPressure;
return *this;
}
inline FGPhysicalProperty& FGPhysicalProperty::operator *= ( const double& d )
{
Wind *= d;
Turbulence *= d;
Temperature *= d;
AirPressure *= d;
VaporPressure *= d;
return *this;
}
inline FGPhysicalProperty& FGPhysicalProperty::operator /= ( const double& d )
{
Wind /= d;
Turbulence /= d;
Temperature /= d;
AirPressure /= d;
VaporPressure /= d;
return *this;
}
inline FGPhysicalProperty operator - (const FGPhysicalProperty& p)
{
FGPhysicalProperty x;
x.Wind = -p.Wind;
x.Turbulence = -p.Turbulence;
x.Temperature = -p.Temperature;
x.AirPressure = -p.AirPressure;
x.VaporPressure = -p.VaporPressure;
return x;
}
inline bool operator == (const FGPhysicalProperty& a, const FGPhysicalProperty& b)
{
return (
(a.Wind == b.Wind) &&
(a.Turbulence == b.Turbulence) &&
(a.Temperature == b.Temperature) &&
(a.AirPressure == b.AirPressure) &&
(a.VaporPressure == b.VaporPressure));
}
inline bool operator != (const FGPhysicalProperty& a, const FGPhysicalProperty& b)
{
return !(a == b);
}
inline FGPhysicalProperty operator + (const FGPhysicalProperty& a, const FGPhysicalProperty& b)
{
return FGPhysicalProperty(a) += b;
}
inline FGPhysicalProperty operator - (const FGPhysicalProperty& a, const FGPhysicalProperty& b)
{
return FGPhysicalProperty(a) -= b;
}
inline FGPhysicalProperty operator * (const FGPhysicalProperty& a, const WeatherPrecition& b)
{
return FGPhysicalProperty(a) *= b;
}
inline FGPhysicalProperty operator * (const WeatherPrecition& b, const FGPhysicalProperty& a)
{
return FGPhysicalProperty(a) *= b;
}
inline FGPhysicalProperty operator / (const FGPhysicalProperty& a, const WeatherPrecition& b)
{
return FGPhysicalProperty(a) *= (1.0/b);
}
/****************************************************************************/
#endif /*FGPhysicalProperty_H*/

71
src/WeatherCM/FGSnowRain.h Normal file
View file

@ -0,0 +1,71 @@
/*****************************************************************************
Header: FGSnowRain.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Header for the rain/snow/hail/... class
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGSnowRain_H
#define FGSnowRain_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGWeatherFeature.h"
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
typedef enum SnowRainType
{
Rain,
Snow,
Hail,
usedRainSnowTypes
};
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGSnowRain:FGWeatherFeature
{
private:
protected:
public:
};
/****************************************************************************/
#endif /*FGSnowRain_H*/

50
src/WeatherCM/FGTemperatureItem.cpp Normal file
View file

@ -0,0 +1,50 @@
/*****************************************************************************
Module: FGTemperatureItem.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: FGMicroWeather
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Operator< definition for the item
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGTemperatureItem.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
bool operator<(const FGTemperatureItem& arg1, const FGTemperatureItem& arg2 )
{
return arg1.alt < arg2.alt;
}

109
src/WeatherCM/FGTemperatureItem.h Normal file
View file

@ -0,0 +1,109 @@
/*****************************************************************************
Header: FGTemperatureItem.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Temperature item that is stored in the micro weather class
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGTemperatureItem_H
#define FGTemperatureItem_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGWeatherDefs.h"
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
class FGTemperatureItem;
FGTemperatureItem operator-(const FGTemperatureItem& arg);
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGTemperatureItem
{
private:
WeatherPrecition value;
WeatherPrecition alt;
protected:
public:
FGTemperatureItem(const WeatherPrecition& a, const WeatherPrecition& v) {alt = a; value = v;}
FGTemperatureItem(const WeatherPrecition& v) {alt = 0.0; value = v;}
FGTemperatureItem() {alt = 0.0; value = (WeatherPrecition)FG_WEATHER_DEFAULT_TEMPERATURE;}
WeatherPrecition getValue() const { return value; };
WeatherPrecition getAlt() const { return alt; };
FGTemperatureItem& operator*= (const WeatherPrecition& arg);
FGTemperatureItem& operator+= (const FGTemperatureItem& arg);
FGTemperatureItem& operator-= (const FGTemperatureItem& arg);
friend bool operator<(const FGTemperatureItem& arg1, const FGTemperatureItem& arg2 );
friend FGTemperatureItem operator-(const FGTemperatureItem& arg);
};
inline FGTemperatureItem& FGTemperatureItem::operator*= (const WeatherPrecition& arg)
{
value *= arg;
return *this;
}
inline FGTemperatureItem& FGTemperatureItem::operator+= (const FGTemperatureItem& arg)
{
value += arg.value;
return *this;
}
inline FGTemperatureItem& FGTemperatureItem::operator-= (const FGTemperatureItem& arg)
{
value -= arg.value;
return *this;
}
inline FGTemperatureItem operator-(const FGTemperatureItem& arg)
{
return FGTemperatureItem(arg.alt, -arg.value);
}
/****************************************************************************/
#endif /*FGTemperatureItem_H*/

50
src/WeatherCM/FGTurbulenceItem.cpp Normal file
View file

@ -0,0 +1,50 @@
/*****************************************************************************
Module: FGTurbulenceItem.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: FGMicroWeather
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Operator< definition for the item
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGTurbulenceItem.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
bool operator<(const FGTurbulenceItem& arg1, const FGTurbulenceItem& arg2)
{
return arg1.alt < arg2.alt;
}

110
src/WeatherCM/FGTurbulenceItem.h Normal file
View file

@ -0,0 +1,110 @@
/*****************************************************************************
Header: FGTurbulenceItem.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
turbulence item that gets stored in the micro weather class
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGTurbulenceItem_H
#define FGTurbulenceItem_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include <Math/point3d.hxx>
#include "FGWeatherDefs.h"
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
class FGTurbulenceItem;
FGTurbulenceItem operator-(const FGTurbulenceItem& arg);
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGTurbulenceItem
{
private:
Point3D value;
WeatherPrecition alt;
protected:
public:
FGTurbulenceItem(const WeatherPrecition& a, const Point3D& v) {alt = a; value = v;}
FGTurbulenceItem(const Point3D& v) {alt = 0.0; value = v;}
FGTurbulenceItem() {alt = 0.0; value = Point3D(0.0);}
Point3D getValue() const { return value; };
WeatherPrecition getAlt() const { return alt; };
FGTurbulenceItem& operator*= (const WeatherPrecition& arg);
FGTurbulenceItem& operator+= (const FGTurbulenceItem& arg);
FGTurbulenceItem& operator-= (const FGTurbulenceItem& arg);
friend bool operator<(const FGTurbulenceItem& arg1, const FGTurbulenceItem& arg2 );
friend FGTurbulenceItem operator-(const FGTurbulenceItem& arg);
};
inline FGTurbulenceItem& FGTurbulenceItem::operator*= (const WeatherPrecition& arg)
{
value *= arg;
return *this;
}
inline FGTurbulenceItem& FGTurbulenceItem::operator+= (const FGTurbulenceItem& arg)
{
value += arg.value;
return *this;
}
inline FGTurbulenceItem& FGTurbulenceItem::operator-= (const FGTurbulenceItem& arg)
{
value -= arg.value;
return *this;
}
inline FGTurbulenceItem operator-(const FGTurbulenceItem& arg)
{
return FGTurbulenceItem(arg.alt, -arg.value);
}
/****************************************************************************/
#endif /*FGTurbulenceItem_H*/

49
src/WeatherCM/FGVaporPressureItem.cpp Normal file
View file

@ -0,0 +1,49 @@
/*****************************************************************************
Module: FGVaporPressureItem.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: FGMicroWeather
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Operator< definition for the item
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGVaporPressureItem.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
bool operator<(const FGVaporPressureItem& arg1, const FGVaporPressureItem& arg2 )
{
return arg1.alt < arg2.alt;
}

105
src/WeatherCM/FGVaporPressureItem.h Normal file
View file

@ -0,0 +1,105 @@
/*****************************************************************************
Header: FGVaporPressureItem.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Vapor pressure item that is stored in the micro weather class
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGVaporPressureItem_H
#define FGVaporPressureItem_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGWeatherDefs.h"
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
class FGVaporPressureItem;
FGVaporPressureItem operator-(const FGVaporPressureItem& arg);
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGVaporPressureItem
{
private:
WeatherPrecition value;
WeatherPrecition alt;
protected:
public:
FGVaporPressureItem(const WeatherPrecition& a, const WeatherPrecition& v) {alt = a; value = v;}
FGVaporPressureItem(const WeatherPrecition& v) {alt = 0.0; value = v;}
FGVaporPressureItem() {alt = 0.0; value = FG_WEATHER_DEFAULT_VAPORPRESSURE;}
WeatherPrecition getValue() const { return value; };
WeatherPrecition getAlt() const { return alt; };
FGVaporPressureItem& operator*= (const WeatherPrecition& arg);
FGVaporPressureItem& operator+= (const FGVaporPressureItem& arg);
FGVaporPressureItem& operator-= (const FGVaporPressureItem& arg);
friend bool operator<(const FGVaporPressureItem& arg1, const FGVaporPressureItem& arg2 );
friend FGVaporPressureItem operator-(const FGVaporPressureItem& arg);
};
inline FGVaporPressureItem& FGVaporPressureItem::operator*= (const WeatherPrecition& arg)
{
value *= arg;
return *this;
}
inline FGVaporPressureItem& FGVaporPressureItem::operator+= (const FGVaporPressureItem& arg)
{
value += arg.value;
return *this;
}
inline FGVaporPressureItem& FGVaporPressureItem::operator-= (const FGVaporPressureItem& arg)
{
value -= arg.value;
return *this;
}
inline FGVaporPressureItem operator-(const FGVaporPressureItem& arg)
{
return FGVaporPressureItem(arg.alt, -arg.value);
}
/****************************************************************************/
#endif /*FGVaporPressureItem_H*/

216
src/WeatherCM/FGVoronoi.cpp Normal file
View file

@ -0,0 +1,216 @@
/*****************************************************************************
Module: FGVoronoi.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: main program
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
library for Voronoi Diagram calculation based on Steven Fortune 'Sweep2'
FGVoronoi is the wraper to feed the voronoi calulation with a vetor of points
and any class you want, as it uses templates
NOTE: Sweep2 didn't free *any* memory. So I'm doing what I can, but that's not
good enough...
HISTORY
------------------------------------------------------------------------------
30.05.99 Christian Mayer Created
16.06.99 Durk Talsma Portability for Linux
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGVoronoi.h"
#include <Voronoi/voronoi.h>
#include <Voronoi/my_memory.h>
extern "C" {
#include <Voronoi/defs.h>
//forward definitions
void voronoi(int triangulate, struct Site *(*nextsite)());
void geominit(void);
void freeinit(struct Freelist *fl, int size);
struct Site *nextone(void);
bool readsites(PointList input);
};
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
FGVoronoiOutputList Voronoiate(const FGVoronoiInputList& input)
{
FGVoronoiOutputList ret_list;
PointList p2ds;
FGVoronoiInputList::iterator it1;
//get the points
for (it1 = (FGVoronoiInputList::iterator)input.begin(); it1 != input.end(); it1++)
{
p2ds.push_back(VoronoiPoint(it1->position.x(), it1->position.y()));
}
cl.clear(); //make sure that it's empty
if (readsites(p2ds) == false)
return ret_list;
freeinit(&sfl, sizeof *sites);
siteidx = 0;
geominit();
voronoi(triangulate, nextone);
_my_free();
/*free(sites); //to prevent a *big* memory leak...
free(ELhash); //Sweep2 didn't free *any* memory...
free(PQhash);*/
for (cellList::iterator it2 = cl.begin(); it2 != cl.end(); it2++)
{
it2->sort();
it2->strip();
//uncomment for debugging
//cout << *it2;
Point2DList boundary;
//copy points
PointList::iterator it3 = it2->boundary.begin();
if (it3->infinity == false)
boundary.push_back( *it3 );
else
{
Point2D direction_vector = *it3;
it3++;
boundary.push_back( (*it3) + direction_vector);
}
for (; it3 != it2->boundary.end(); it3++)
{
boundary.push_back( *it3 );
}
it3--;
if (it3->infinity == true)
{
Point2D direction_vector = *it3;
it3--;
Point2D value = *it3;
boundary.pop_back();
boundary.push_back(value + direction_vector);
}
ret_list.push_back(FGVoronoiOutput(boundary, input[it2->ID].value));
}
return ret_list;
}
extern "C"
{
/* return a single in-storage site */
struct Site *nextone(void)
{
struct Site *s;
if(siteidx < nsites)
{
s = &sites[siteidx];
siteidx ++;
return(s);
}
else
return( (struct Site *)NULL);
}
/* sort sites on y, then x, coord */
//int scomp(const struct Point *s1, const struct Point *s2)
int scomp(const void *s1, const void *s2)
{
if(((Point*)s1) -> y < ((Point*)s2) -> y) return(-1);
if(((Point*)s1) -> y > ((Point*)s2) -> y) return(1);
if(((Point*)s1) -> x < ((Point*)s2) -> x) return(-1);
if(((Point*)s1) -> x > ((Point*)s2) -> x) return(1);
return(0);
}
/* read all sites, sort, and compute xmin, xmax, ymin, ymax */
bool readsites(PointList input)
{
int i;
if (input.size() == 0)
return false; //empty array
PointList::iterator It = input.begin();
nsites=0;
sites = (struct Site *) myalloc(4000*sizeof(*sites));
while(It != input.end())
{
sites[nsites].coord.x = It->x();
sites[nsites].coord.y = It->y();
sites[nsites].sitenbr = nsites;
sites[nsites].refcnt = 0;
nsites ++;
It++;
if (nsites % 4000 == 0)
sites = (struct Site *) my_realloc(sites,(nsites+4000)*sizeof(*sites));
};
qsort(sites, nsites, sizeof (*sites), scomp);
xmin=sites[0].coord.x;
xmax=sites[0].coord.x;
for(i=1; i<nsites; i+=1)
{
if(sites[i].coord.x < xmin)
xmin = sites[i].coord.x;
if(sites[i].coord.x > xmax)
xmax = sites[i].coord.x;
};
ymin = sites[0].coord.y;
ymax = sites[nsites-1].coord.y;
return true;
}
}

98
src/WeatherCM/FGVoronoi.h Normal file
View file

@ -0,0 +1,98 @@
/*****************************************************************************
Header: FGVoronoi.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
library for Voronoi Diagram calculation based on Steven Fortune 'Sweep2'
FGVoronoi is the wraper to feed the voronoi calulation with a vetor of points
and any class you want, as it uses templates
NOTE: Sweep2 didn't free *any* memory. So I'm doing what I can, but that's not
good enough...
HISTORY
------------------------------------------------------------------------------
30.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
30.06.1999 Christian Mayer STL portability
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGVoronoi_H
#define FGVoronoi_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "compiler.h"
#include <vector>
#include <set>
#include <Voronoi/point2d.h>
#include "FGPhysicalProperties.h"
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
FG_USING_STD(vector);
FG_USING_STD(set);
FG_USING_NAMESPACE(std);
typedef vector<Point2D> Point2DList;
struct FGVoronoiInput
{
Point2D position;
FGPhysicalProperties2D value;
FGVoronoiInput(const Point2D& p, const FGPhysicalProperties2D& v) { position = p; value = v; }
};
struct FGVoronoiOutput
{
Point2DList boundary;
FGPhysicalProperties2D value;
FGVoronoiOutput(const Point2DList& b, const FGPhysicalProperties2D& v) {boundary = b; value = v;};
};
typedef vector<FGVoronoiInput> FGVoronoiInputList;
typedef vector<FGVoronoiOutput> FGVoronoiOutputList;
/****************************************************************************/
/* FUNCTION DECLARATION */
/****************************************************************************/
FGVoronoiOutputList Voronoiate(const FGVoronoiInputList& input);
#endif /*FGVoronoi_H*/

67
src/WeatherCM/FGWeatherDefs.h Normal file
View file

@ -0,0 +1,67 @@
/*****************************************************************************
Header: FGWeatherDefs.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
definitions uses in most weather classes
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGWeatherDefs_H
#define FGWeatherDefs_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
typedef float WeatherPrecition;
//set the minimum visibility to get a at least half way realistic weather
#define MINIMUM_WEATHER_VISIBILIY 10.0 /* metres */
#define DEFAULT_WEATHER_VISIBILIY 32000.0 /* metres */
//prefered way the database is working
#define PREFERED_WORKING_TYPE default_mode
#define FG_WEATHER_DEFAULT_TEMPERATURE (15.0+273.16) /*15°C or 288.16°K*/
#define FG_WEATHER_DEFAULT_VAPORPRESSURE (0.0) /*in Pascal 1 Pa = N/m^2*/
#define FG_WEATHER_DEFAULT_AIRPRESSURE (1013.25*100.0) /*in Pascal 1 Pa = N/m^2*/
#define FG_WEATHER_DEFAULT_AIRDENSITY (1.22501) /*in kg/m^3*/
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
/****************************************************************************/
#endif /*FGWeatherDefs_H*/

87
src/WeatherCM/FGWeatherFeature.h Normal file
View file

@ -0,0 +1,87 @@
/*****************************************************************************
Header: FGWeatherFeature.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Abstract class that every weather feature, such as wind layers, are derivated
from
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
30.06.1999 Christian Mayer STL portability
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGWeatherFeature_H
#define FGWeatherFeature_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include <Include/compiler.h>
#include <vector>
FG_USING_STD(vector);
FG_USING_NAMESPACE(std);
#include <Math/point3d.hxx>
#include "FGWeatherDefs.h"
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
enum LayerType {
fgWind,
fgTurbulence,
fgTemperature,
fgAirDensity,
fgCloud,
fgRain
};
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGWeatherFeature
{
private:
protected:
Point3D position; //middle of the feature in lat/lon/alt
WeatherPrecition minSize; //smalest size of the feature
//=> a disk is specifies
LayerType FeatureType;
public:
LayerType getFeature(void) const { return FeatureType; }
bool isFeature(const LayerType& f) const {return (f == FeatureType);}
};
/****************************************************************************/
#endif /*FGWeatherFeature_H*/

178
src/WeatherCM/FGWeatherUtils.h Normal file
View file

@ -0,0 +1,178 @@
/*****************************************************************************
Header: FGWeatherUtils.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Utilities for the weather calculation like converting formulas
HISTORY
------------------------------------------------------------------------------
02.06.1999 Christian Mayer Created
08.06.1999 Christian Mayer Changed sat_vp
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGWeatherUtils_H
#define FGWeatherUtils_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include <math.h>
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
/****************************************************************************/
/*assuming as given: */
/* */
/* t: temperature in °C */
/* p: preasure in mbar */
/* //abs_hum: absoloute humidity in g/m^3, */
/* act_vp: actual vapor pressure pascal */
/* */
/* Calculated vaues: */
/* //max_hum: maximum of humidity in g/m^3, */
/* sat_vp: saturated vapor pressure in pascal */
/* rel_hum: relative humidity in % */
/* dp: dew point in °C */
/* wb: approximate wetbulp in °C */
/* */
/* NOTE: Pascal is the SI unit for preasure and is defined as Pa = N/m^2 */
/* 1 mbar = 1 hPa = 100 Pa */
/* NOTE: °C isn't a SI unit, so I should use °K instead. But as all */
/* formulas are given in °C and the weather database only uses */
/* 'normal' temperatures, I've kept it in °C */
/****************************************************************************/
#define SAT_VP_CONST1 610.483125
#define SAT_VP_CONST2 7.444072452
#define SAT_VP_CONST3 235.3120919
inline WeatherPrecition sat_vp(const WeatherPrecition& temp)
{
//old:
//return 6.112 * pow( 10, (7.5*dp)/(237.7+dp) ); //in mbar
//new:
//advantages: return the result as SI unit pascal and the constants
//are choosen that the correct results are returned for 0°C, 20°C and
//100°C. By 100°C I'm now returning a preasure of 1013.25 hPa
return SAT_VP_CONST1 * pow( 10, (SAT_VP_CONST2*temp)/(SAT_VP_CONST3+temp) ); //in pascal
}
inline WeatherPrecition rel_hum(const WeatherPrecition& act_vp, const WeatherPrecition& sat_vp)
{
return (act_vp / sat_vp) * 100; //in %
}
inline WeatherPrecition dp(const WeatherPrecition& sat_vp)
{
return (SAT_VP_CONST3*log10(sat_vp/SAT_VP_CONST1))/(SAT_VP_CONST2-log10(sat_vp/SAT_VP_CONST1)); //in °C
}
inline WeatherPrecition wb(const WeatherPrecition& t, const WeatherPrecition& p, const WeatherPrecition& dp)
{
WeatherPrecition e = sat_vp(dp);
WeatherPrecition tcur, tcvp, peq, diff;
WeatherPrecition tmin, tmax;
if (t > dp)
{
tmax = t;
tmin = dp;
}
else
{
tmax = dp;
tmin = t;
}
while (true)
{
tcur=(tmax+tmin)/2;
tcvp=sat_vp(tcur);
peq = 0.000660*(1+0.00155*tcur)*p*(t-tcur);
diff = peq-tcvp+e;
if (fabs(diff) < 0.01)
return tcur; //in °C
if (diff < 0)
tmax=tcur;
else
tmin=tcur;
};
}
inline WeatherPrecition Celsius(const WeatherPrecition& celsius)
{
return celsius + 273.16; //Kelvin
}
inline WeatherPrecition Fahrenheit(const WeatherPrecition& fahrenheit)
{
return (fahrenheit * 9.0 / 5.0) + 32.0 + 273.16; //Kelvin
}
inline WeatherPrecition Kelvin2Celsius(const WeatherPrecition& kelvin)
{
return kelvin - 273.16; //Celsius
}
inline WeatherPrecition Kelvin2Fahrenheit(const WeatherPrecition& kelvin)
{
return ((kelvin - 273.16) * 9.0 / 5.0) + 32.0; //Fahrenheit
}
inline WeatherPrecition Celsius2Fahrenheit(const WeatherPrecition& celsius)
{
return (celsius * 9.0 / 5.0) + 32.0; //Fahrenheit
}
inline WeatherPrecition Fahrenheit2Celsius(const WeatherPrecition& fahrenheit)
{
return (fahrenheit - 32.0) * 5.0 / 9.0; //Celsius
}
inline WeatherPrecition Torr2Pascal(const WeatherPrecition& torr)
{
return (101325.0/760.0)*torr;
}
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
/****************************************************************************/
#endif /*FGWeatherUtils_H*/

50
src/WeatherCM/FGWindItem.cpp Normal file
View file

@ -0,0 +1,50 @@
/*****************************************************************************
Module: FGWindItem.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: FGMicroWeather
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Operator< definition for the item
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGWindItem.h"
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
bool operator<(const FGWindItem& arg1, const FGWindItem& arg2)
{
return arg1.alt < arg2.alt;
}

107
src/WeatherCM/FGWindItem.h Normal file
View file

@ -0,0 +1,107 @@
/*****************************************************************************
Header: FGWindItem.h
Author: Christian Mayer
Date started: 28.05.99
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
wind item that gets stored in the micro weather class
HISTORY
------------------------------------------------------------------------------
28.05.1999 Christian Mayer Created
16.06.1999 Durk Talsma Portability for Linux
20.06.1999 Christian Mayer added lots of consts
*****************************************************************************/
/****************************************************************************/
/* SENTRY */
/****************************************************************************/
#ifndef FGWindItem_H
#define FGWindItem_H
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include <Math/point3d.hxx>
#include "FGWeatherDefs.h"
/****************************************************************************/
/* DEFINES */
/****************************************************************************/
class FGWindItem;
FGWindItem operator-(const FGWindItem& arg);
/****************************************************************************/
/* CLASS DECLARATION */
/****************************************************************************/
class FGWindItem
{
private:
Point3D value;
WeatherPrecition alt;
protected:
public:
FGWindItem(const WeatherPrecition& a, const Point3D& v) {alt = a; value = v;}
FGWindItem(const Point3D& v) {alt = 0.0; value = v;}
FGWindItem() {alt = 0.0; value = Point3D(0.0);}
Point3D getValue() const { return value; };
WeatherPrecition getAlt() const { return alt; };
FGWindItem& operator*= (const WeatherPrecition& arg);
FGWindItem& operator+= (const FGWindItem& arg);
FGWindItem& operator-= (const FGWindItem& arg);
friend bool operator<(const FGWindItem& arg1, const FGWindItem& arg2);
friend FGWindItem operator-(const FGWindItem& arg);
};
inline FGWindItem& FGWindItem::operator*= (const WeatherPrecition& arg)
{
value *= arg;
return *this;
}
inline FGWindItem& FGWindItem::operator+= (const FGWindItem& arg)
{
value += arg.value;
return *this;
}
inline FGWindItem& FGWindItem::operator-= (const FGWindItem& arg)
{
value -= arg.value;
return *this;
}
inline FGWindItem operator-(const FGWindItem& arg)
{
return FGWindItem(arg.alt, -arg.value);
}
/****************************************************************************/
#endif /*FGWindItem_H*/

19
src/WeatherCM/Makefile.am Normal file
View file

@ -0,0 +1,19 @@
noinst_LIBRARIES = libWeatherCM.a
libWeatherCM_a_SOURCES = \
FGAirPressureItem.cpp FGAirPressureItem.h \
FGCloud.h FGCloudItem.cpp FGCloudItem.h \
FGGlobalWeatherDatabase.cpp FGGlobalWeatherDatabase.h \
FGLocalWeatherDatabase.cpp FGLocalWeatherDatabase.h \
FGMicroWeather.cpp FGMicroWeather.h \
FGPhysicalProperties.cpp FGPhysicalProperties.h \
FGPhysicalProperty.cpp FGPhysicalProperty.h \
FGSnowRain.h \
FGTemperatureItem.cpp FGTemperatureItem.h \
FGTurbulenceItem.cpp FGTurbulenceItem.h \
FGVaporPressureItem.cpp FGVaporPressureItem.h \
FGVoronoi.cpp FGVoronoi.h \
FGWeatherDefs.h FGWeatherFeature.h FGWeatherUtils.h \
FGWindItem.cpp FGWindItem.h
INCLUDES += -I$(top_builddir) -I$(top_builddir)/Lib -I$(top_builddir)/Simulator

255
src/WeatherCM/test.cpp Normal file
View file

@ -0,0 +1,255 @@
/*****************************************************************************
Module: test.cpp
Author: Christian Mayer
Date started: 28.05.99
Called by: command line
---------- Copyright (C) 1999 Christian Mayer (vader@t-online.de) ----------
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., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
Further information about the GNU General Public License can also be found on
the world wide web at http://www.gnu.org.
FUNCTIONAL DESCRIPTION
------------------------------------------------------------------------------
Test program for the weather database
HISTORY
------------------------------------------------------------------------------
28.05.99 CM Created
*****************************************************************************/
/****************************************************************************/
/* INCLUDES */
/****************************************************************************/
#include "FGLocalWeatherDatabase.h"
#include "FGGlobalWeatherDatabase.h"
#include "LibVoronoi/FGVoronoi.h"
#include "FGWeatherUtils.h"
#include <time.h>
#include STL_IOSTREAM
#include <vector>
/****************************************************************************/
/********************************** CODE ************************************/
/****************************************************************************/
int main(void)
{
//init local database:
FGLocalWeatherDatabase local(Point3D(0,0,0), 10000, FGLocalWeatherDatabase::use_global);
FGGlobalWeatherDatabase global(FGGlobalWeatherDatabase_working);
Point3D p(0);
Point2D p2d(0);
FGPhysicalProperties x;
FGPhysicalProperties2D x2d;
FGPhysicalProperties2DVector getAllvect;
cout << "\n**************** FGGlobalWeatherDatabase Test ****************\n";
x.Temperature.insert(FGTemperatureItem(100, Celsius(10)));
global.add(Point2D(5,5), x);
x.Temperature.insert(FGTemperatureItem(110, Celsius(-10)));
global.add(Point3D(10,10,10), x);
x2d.Temperature.insert(FGTemperatureItem(90, Celsius(-20)));
x2d.p = Point2D(10,5);
global.add(x2d);
getAllvect = global.getAll(p2d, 10000);
cout << "Returned size: " << getAllvect.size() << "\n";
getAllvect = global.getAll(p2d, 10000, 30);
cout << "Returned size: " << getAllvect.size() << "\n";
getAllvect = global.getAll(p, 10000);
cout << "Returned size: " << getAllvect.size() << "\n";
getAllvect = global.getAll(p, 10000, 3);
cout << "Returned size: " << getAllvect.size() << "\n";
cout << "Temperature: " << global.get(Point3D(5, 5, 100)).Temperature << "°C\n";
cout << "AirPressure at 0m: " << global.get(Point3D(5, 5, 0)).AirPressure << "\n";
cout << "AirPressure at 1000m: " << global.get(Point3D(5, 5, 1000)).AirPressure << "\n";
cout << global;
cout << "\n**************** FGMicroWeather Test ****************\n";
vector<Point2D> points;
points.push_back(Point2D(0.1, 0.1));
points.push_back(Point2D(0.9, 0.1));
points.push_back(Point2D(0.9, 0.9));
points.push_back(Point2D(0.1, 0.9));
points.push_back(Point2D(0.1, 0.1));
x2d.p = Point2D(0.4, 0.4);
FGMicroWeather micro(x2d, points);
cout << "hasPoint 0.5, 0.5: ";
if (micro.hasPoint(Point2D(0.5, 0.5)) == true)
cout << "true";
else
cout << "false";
cout << "\nhasPoint 0.9, 0.5: ";
if (micro.hasPoint(Point2D(0.9, 0.5)) == true)
cout << "true";
else
cout << "false";
cout << "\nhasPoint 1.5, 0.5: ";
if (micro.hasPoint(Point2D(1.5, 0.5)) == true)
cout << "true";
else
cout << "false";
cout << "\n";
cout << "\n**************** Voronoi Diagram Test ****************\n";
FGVoronoiInputList input;
FGVoronoiOutputList output;
FGVoronoiInput test(Point2D(0.0), FGPhysicalProperties2D());
test.position = Point2D(0.1,0.2);
input.push_back(test);
test.position = Point2D(0.8,0.9);
input.push_back(test);
test.position = Point2D(0.9,0.1);
input.push_back(test);
test.position = Point2D(0.6,0.4);
input.push_back(test);
test.position = Point2D(1.1,1.2);
input.push_back(test);
test.position = Point2D(1.8,1.9);
input.push_back(test);
test.position = Point2D(1.9,1.1);
input.push_back(test);
test.position = Point2D(1.6,1.4);
input.push_back(test);
test.position = Point2D(2.9,2.1);
input.push_back(test);
test.position = Point2D(2.6,2.4);
input.push_back(test);
output = Voronoiate(input);
cout << "\n";
for (FGVoronoiOutputList::iterator it=output.begin(); it!=output.end(); it++)
{
cout << "Cell start: ";
for (Point2DList::iterator it2= it->boundary.begin();it2!= it->boundary.end();it2++)
{
if (it2==it->boundary.begin())
cout << "(";
else
cout << "-(";
cout << *it2 << ")";
}
cout << "\n";
}
cout << "\n**************** Database Stress Test ****************\n";
time_t starttime, currenttime;
unsigned long count = 0;
unsigned long count2 = 0;
float xxx, yyy;
cout << "Filling Database... ";
time( &starttime );
for (count = 0; count < 5000; count++)
{
xxx = (rand()%36000)/100.0;
yyy = (rand()%18000)/100.0;
local.addProperties(FGPhysicalProperties2D(FGPhysicalProperties(), Point2D(xxx, yyy)));
}
local.addProperties(FGPhysicalProperties2D(FGPhysicalProperties(), Point3D(-10.0)));
local.addProperties(FGPhysicalProperties2D(FGPhysicalProperties(), Point3D(+10.0)));
local.addProperties(FGPhysicalProperties2D(FGPhysicalProperties(), Point3D(-100.0)));
local.addProperties(FGPhysicalProperties2D(FGPhysicalProperties(), Point3D(+100.0)));
time( &currenttime );
cout << float(count)/float(currenttime - starttime) << "/s filling rate; ";
time( &starttime );
for (count = 0; count < 5; count++)
{
local.reset(FGLocalWeatherDatabase::use_global); //make sure I've got a current voronoi
}
time( &currenttime );
cout << float(currenttime - starttime)/float(count) << "s resetting time; Done\n";
count = 0;
//for (;count<200;)
cout << "local.get() test: 10 seconds\n";
time( &starttime );
time( &currenttime );
for (;currenttime<(starttime+10);)
{
time( &currenttime );
count++;
local.get(Point3D(0.0));
}
cout << "Result: " << float(count) / float(currenttime-starttime) << "/s\n";
count = 0;
cout << "output = Voronoiate(input) test: 10 seconds\n";
time( &starttime );
time( &currenttime );
for (;currenttime<(starttime+10);)
{
time( &currenttime );
count++;
output = Voronoiate(input);
}
cout << "Result: " << float(count) / float(currenttime-starttime) << "/s\n";
cout << "Reference: 176800/s\n";
cout << "\n**************** Database Stress Test end ****************\n";
return 0;
}