#include "fgmetar.hxx"
#include "environment.hxx"
#include "atmosphere.hxx"
+#include "metarairportfilter.hxx"
#include <simgear/scene/sky/cloud.hxx>
#include <simgear/structure/exception.hxx>
+#include <simgear/misc/strutils.hxx>
+#include <simgear/magvar/magvar.hxx>
+#include <simgear/timing/sg_time.hxx>
#include <Main/fg_props.hxx>
using std::string;
static vector<string> coverage_string;
+/**
+ * @brief Helper class to wrap SGMagVar functionality and cache the variation and dip for
+ * a certain position.
+ */
+class MagneticVariation : public SGMagVar {
+public:
+ /**
+ * Constructor
+ */
+ MagneticVariation() : _lat(1), _lon(1), _alt(1) {
+ recalc( 0.0, 0.0, 0.0 );
+ }
+
+ /**
+ * @brief get the magnetic variation for a specific position at the current time
+ * @param lon the positions longitude in degrees
+ * @param lat the positions latitude in degrees
+ * @param alt the positions height above MSL (aka altitude) in feet
+ * @return the magnetic variation in degrees
+ */
+ double get_variation_deg( double lon, double lat, double alt );
+
+ /**
+ * @brief get the magnetic dip for a specific position at the current time
+ * @param lon the positions longitude in degrees
+ * @param lat the positions latitude in degrees
+ * @param alt the positions height above MSL (aka altitude) in feet
+ * @return the magnetic dip in degrees
+ */
+ double get_dip_deg( double lon, double lat, double alt );
+private:
+ void recalc( double lon, double lat, double alt );
+ SGTime _time;
+ double _lat, _lon, _alt;
+};
+
+inline void MagneticVariation::recalc( double lon, double lat, double alt )
+{
+ // calculation of magnetic variation is expensive. Cache the position
+ // and perform this calculation only if it has changed
+ if( _lon != lon || _lat != lat || _alt != alt ) {
+ SG_LOG(SG_ALL, SG_DEBUG, "Recalculating magvar for lon=" << lon << ", lat=" << lat << ", alt=" << alt );
+ _lon = lon;
+ _lat = lat;
+ _alt = alt;
+
+ lon *= SGD_DEGREES_TO_RADIANS;
+ lat *= SGD_DEGREES_TO_RADIANS;
+ alt *= SG_FEET_TO_METER;
+ _time.update( lon, lat, 0, 0 );
+ update( lon, lat, alt, _time.getJD() );
+ }
+}
+
+inline double MagneticVariation::get_variation_deg( double lon, double lat, double alt )
+{
+ recalc( lon, lat, alt );
+ return get_magvar() * SGD_RADIANS_TO_DEGREES;
+}
+
+inline double MagneticVariation::get_dip_deg( double lon, double lat, double alt )
+{
+ recalc( lon, lat, alt );
+ return get_magdip() * SGD_RADIANS_TO_DEGREES;
+}
+
MetarProperties::MetarProperties( SGPropertyNode_ptr rootNode ) :
_rootNode(rootNode),
_metarValidNode( rootNode->getNode( "valid", true ) ),
_rain(0.0),
_hail(0.0),
_snow(0.0),
- _snow_cover(false)
+ _snow_cover(false),
+ _magneticVariation(new MagneticVariation())
{
// Hack to avoid static initialization order problems on OSX
if( coverage_string.size() == 0 ) {
_metarValidNode->setBoolValue( false );
_tiedProperties.setRoot( _rootNode );
_tiedProperties.Tie("data", this, &MetarProperties::get_metar, &MetarProperties::set_metar );
- _tiedProperties.Tie("station-id", this, &MetarProperties::get_station_id );
+ _tiedProperties.Tie("station-id", this, &MetarProperties::get_station_id, &MetarProperties::set_station_id );
_tiedProperties.Tie("station-elevation-ft", &_station_elevation );
_tiedProperties.Tie("station-latitude-deg", &_station_latitude );
_tiedProperties.Tie("station-longitude-deg", &_station_longitude );
+ _tiedProperties.Tie("station-magnetic-variation-deg", this, &MetarProperties::get_magnetic_variation_deg );
+ _tiedProperties.Tie("station-magnetic-dip-deg", this, &MetarProperties::get_magnetic_dip_deg );
_tiedProperties.Tie("min-visibility-m", &_min_visibility );
_tiedProperties.Tie("max-visibility-m", &_max_visibility );
_tiedProperties.Tie("base-wind-range-from", &_base_wind_range_from );
MetarProperties::~MetarProperties()
{
+ delete _magneticVariation;
}
{
// 1. check the id given in the metar
FGAirport* a = FGAirport::findByIdent(m->getId());
-/*
+
// 2. if unknown, find closest airport with metar to current position
if( a == NULL ) {
- SGGeod pos = SGGeod::fromDeg(_longitude_n->getDoubleValue(), _latitude_n->getDoubleValue());
- a = FGAirport::findClosest(pos, 10000.0, &_airportWithMetarFilter);
+ SGGeod pos = SGGeod::fromDeg(
+ fgGetDouble( "/position/longitude-deg", 0.0 ),
+ fgGetDouble( "/position/latitude-deg", 0.0 ) );
+ a = FGAirport::findClosest(pos, 10000.0, MetarAirportFilter::instance() );
}
-*/
+
// 3. otherwise use ground elevation
if( a != NULL ) {
_station_elevation = a->getElevation();
_station_longitude = towerPosition.getLongitudeDeg();
_station_id = a->ident();
} else {
- _station_elevation = 0.0;
- _station_latitude = 0.0;
- _station_longitude = 0.0;
+ _station_elevation = fgGetDouble("/position/ground-elev-m", 0.0 ) * SG_METER_TO_FEET;
+ _station_latitude = fgGetDouble( "/position/latitude-deg", 0.0 );
+ _station_longitude = fgGetDouble( "/position/longitude-deg", 0.0 );
_station_id = "XXXX";
-// station_elevation_ft = _ground_elevation_n->getDoubleValue() * SG_METER_TO_FEET;
-// _station_id = m->getId();
}
}
SGPropertyNode_ptr cloudsNode = _rootNode->getNode("clouds", true );
const vector<SGMetarCloud> & metarClouds = m->getClouds();
unsigned layerOffset = 0; // Oh, this is ugly!
- bool setGroundCloudLayer = _rootNode->getBoolValue("set-ground-cloud-layer", false );
+
+ // fog/mist/haze cloud layer does not work with 3d clouds yet :-(
+ bool setGroundCloudLayer = _rootNode->getBoolValue("set-ground-cloud-layer", false ) &&
+ false == (fgGetBool("/sim/rendering/shader-effects", false ) &&
+ fgGetBool("/sim/rendering/clouds3d-enable", false ) );
+
if( setGroundCloudLayer ) {
// create a cloud layer #0 starting at the ground if its fog, mist or haze
// make sure layer actually starts at ground and set it's bottom at a constant
// value below the station's elevation
- const double LAYER_BOTTOM_BELOW_STATION_ELEVATION =
- fgGetDouble( "/environment/config/offset-from-station-elevation-ft", 200 );
+ const double LAYER_BOTTOM_STATION_OFFSET =
+ fgGetDouble( "/environment/params/fog-mist-haze-layer/offset-from-station-elevation-ft", -200 );
SGMetarCloud::Coverage coverage = SGMetarCloud::COVERAGE_NIL;
double thickness = 0;
if( isFG ) { // fog
coverage = SGMetarCloud::getCoverage( isBC ?
- fgGetString( "/environment/config/fog-bc-2dlayer-coverage", SGMetarCloud::COVERAGE_SCATTERED_STRING ) :
- fgGetString( "/environment/config/fog-2dlayer-coverage", SGMetarCloud::COVERAGE_BROKEN_STRING )
+ fgGetString( "/environment/params/fog-mist-haze-layer/fog-bc-2dlayer-coverage", SGMetarCloud::COVERAGE_SCATTERED_STRING ) :
+ fgGetString( "/environment/params/fog-mist-haze-layer/fog-2dlayer-coverage", SGMetarCloud::COVERAGE_BROKEN_STRING )
);
thickness = isMI ?
- fgGetDouble("/environment/config/fog-shallow-thickness-ft",30) + LAYER_BOTTOM_BELOW_STATION_ELEVATION : // shallow fog, 10m/30ft
- fgGetDouble("/environment/config/fog-thickness-ft",500) + LAYER_BOTTOM_BELOW_STATION_ELEVATION; // fog, 150m/500ft
- alpha = fgGetDouble("/environment/config/fog-alpha",0.0);
+ fgGetDouble("/environment/params/fog-mist-haze-layer/fog-shallow-thickness-ft",30) - LAYER_BOTTOM_STATION_OFFSET : // shallow fog, 10m/30ft
+ fgGetDouble("/environment/params/fog-mist-haze-layer/fog-thickness-ft",500) - LAYER_BOTTOM_STATION_OFFSET; // fog, 150m/500ft
+ alpha = fgGetDouble("/environment/params/fog-mist-haze-layer/fog-2dlayer-alpha", 1.0);
} else if( isBR ) { // mist
- coverage = SGMetarCloud::getCoverage(fgGetString("/environment/config/mist-2dlayer-coverage", SGMetarCloud::COVERAGE_OVERCAST_STRING));
- thickness = fgGetDouble("/environment/config/mist-thickness-ft",2000) + LAYER_BOTTOM_BELOW_STATION_ELEVATION;
- alpha = fgGetDouble("/environment/config/mist-alpha",0.8);
- } else if( isHZ ) { // hase
- coverage = SGMetarCloud::getCoverage(fgGetString("/environment/config/mist-2dlayer-coverage", SGMetarCloud::COVERAGE_OVERCAST_STRING));
- thickness = fgGetDouble("/environment/config/haze-thickness-ft",2000) + LAYER_BOTTOM_BELOW_STATION_ELEVATION;
- alpha = fgGetDouble("/environment/config/haze-alpha",0.6);
+ coverage = SGMetarCloud::getCoverage(fgGetString("/environment/params/fog-mist-haze-layer/mist-2dlayer-coverage", SGMetarCloud::COVERAGE_OVERCAST_STRING));
+ thickness = fgGetDouble("/environment/params/fog-mist-haze-layer/mist-thickness-ft",2000) - LAYER_BOTTOM_STATION_OFFSET;
+ alpha = fgGetDouble("/environment/params/fog-mist-haze-layer/mist-2dlayer-alpha",0.8);
+ } else if( isHZ ) { // haze
+ coverage = SGMetarCloud::getCoverage(fgGetString("/environment/params/fog-mist-haze-layer/mist-2dlayer-coverage", SGMetarCloud::COVERAGE_OVERCAST_STRING));
+ thickness = fgGetDouble("/environment/params/fog-mist-haze-layer/haze-thickness-ft",2000) - LAYER_BOTTOM_STATION_OFFSET;
+ alpha = fgGetDouble("/environment/params/fog-mist-haze-layer/haze-2dlayer-alpha",0.6);
}
if( coverage != SGMetarCloud::COVERAGE_NIL ) {
+
+ // if there is a layer above the fog, limit the top to one foot below that layer's bottom
+ if( metarClouds.size() > 0 && metarClouds[0].getCoverage() != SGMetarCloud::COVERAGE_CLEAR )
+ thickness = metarClouds[0].getAltitude_ft() - LAYER_BOTTOM_STATION_OFFSET - 1;
+
SGPropertyNode_ptr layerNode = cloudsNode->getChild(LAYER, 0, true );
layerNode->setDoubleValue( "coverage-type", SGCloudLayer::getCoverageType(coverage_string[coverage]) );
layerNode->setStringValue( "coverage", coverage_string[coverage] );
- layerNode->setDoubleValue( "elevation-ft", _station_elevation - LAYER_BOTTOM_BELOW_STATION_ELEVATION );
+ layerNode->setDoubleValue( "elevation-ft", _station_elevation + LAYER_BOTTOM_STATION_OFFSET );
layerNode->setDoubleValue( "thickness-ft", thickness );
layerNode->setDoubleValue( "visibility-m", _min_visibility );
layerNode->setDoubleValue( "alpha", alpha );
_min_visibility = _max_visibility =
- fgGetDouble("/environment/config/visibility-above-layer-m",20000.0); // assume good visibility above the fog
+ fgGetDouble("/environment/params/fog-mist-haze-layer/visibility-above-layer-m",20000.0); // assume good visibility above the fog
layerOffset = 1; // shudder
}
}
_metarValidNode->setBoolValue(true);
}
+void MetarProperties::setStationId( const std::string & value )
+{
+ set_station_id(simgear::strutils::strip(value).c_str());
+}
+
+double MetarProperties::get_magnetic_variation_deg() const
+{
+ return _magneticVariation->get_variation_deg( _station_longitude, _station_latitude, _station_elevation );
+}
+
+double MetarProperties::get_magnetic_dip_deg() const
+{
+ return _magneticVariation->get_dip_deg( _station_longitude, _station_latitude, _station_elevation );
+}
+
} // namespace Environment
projects / flightgear.git / blobdiff