fly/terragear
1
0
Fork 0
Code Activity

[Genapts] Reduce technical debt.

Browse source
This commit is contained in:
Scott Giese 2019-01-29 14:02:18 -06:00
parent 279868b782
commit 911f7f9d27
11 changed files with 352 additions and 394 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
src/Airports/GenAirports850/helipad.hxx
View file

@ -56,18 +56,18 @@ public:
private: private:
struct TGRunway { struct TGRunway {
// data for helipad // data for helipad
char designator[16]; char designator[16];
double lat; double lat;
double lon; double lon;
double heading; double heading;
double length; double length;
double width; double width;
int surface; int surface;
int marking; int marking;
int shoulder; int shoulder;
double smoothness; double smoothness;
int edge_lights; int edge_lights;
}; };
TGRunway heli; TGRunway heli;

8
src/Airports/GenAirports850/linearfeature.cxx
View file

@ -370,10 +370,8 @@ int LinearFeature::Finish( bool closed, unsigned int idx )
double heading; double heading;
double dist; double dist;
double az2; double az2;
double last_end_v;
double width = 0; double width = 0;
std::string material; std::string material;
double cur_light_dist = 0.0f;
double light_delta = 0; double light_delta = 0;
bool markStarted; bool markStarted;
@ -386,7 +384,7 @@ int LinearFeature::Finish( bool closed, unsigned int idx )
for (unsigned int i=0; i<marks.size(); i++) for (unsigned int i=0; i<marks.size(); i++)
{ {
markStarted = false; markStarted = false;
last_end_v = 0.0f; double last_end_v = 0.0;
// which material for this mark? // which material for this mark?
switch( marks[i]->type ) switch( marks[i]->type )
@ -568,7 +566,7 @@ int LinearFeature::Finish( bool closed, unsigned int idx )
for (unsigned int i=0; i<lights.size(); i++) for (unsigned int i=0; i<lights.size(); i++)
{ {
markStarted = false; markStarted = false;
cur_light_dist = 0.0f; double cur_light_dist = 0.0;
int light_direction = lights[i]->LightDirection(); int light_direction = lights[i]->LightDirection();
bool alternate = false; bool alternate = false;
@ -637,7 +635,7 @@ int LinearFeature::Finish( bool closed, unsigned int idx )
while (cur_light_dist < dist) while (cur_light_dist < dist)
{ {
if (cur_light_dist == 0.0f) if (cur_light_dist == 0.0)
{ {
tmp = prev_outer; tmp = prev_outer;
} }

68
src/Airports/GenAirports850/main.cxx
View file

@ -41,8 +41,8 @@ static void usage( int argc, char **argv ) {
TG_LOG(SG_GENERAL, SG_ALERT, "Usage: " << argv[0] << "\n--input=<apt_file>" TG_LOG(SG_GENERAL, SG_ALERT, "Usage: " << argv[0] << "\n--input=<apt_file>"
<< "\n--work=<work_dir>\n[ --start-id=abcd ] [ --nudge=n ] " << "\n--work=<work_dir>\n[ --start-id=abcd ] [ --nudge=n ] "
<< "[--min-lon=<deg>] [--max-lon=<deg>] [--min-lat=<deg>] [--max-lat=<deg>] " << "[--min-lon=<deg>] [--max-lon=<deg>] [--min-lat=<deg>] [--max-lat=<deg>] "
<< "[ --airport=abcd ] [--max-slope=<decimal>] [--tile=<tile>] [--threads] [--threads=x]" << "[ --airport=abcd ] [--max-slope=<decimal>] [--threads] [--threads=x]"
<< "[--chunk=<chunk>] [--clear-dem-path] [--dem-path=<path>] [--verbose] [--help] [--log-level=bulk|info|debug|warn|alert]"); << "[--clear-dem-path] [--dem-path=<path>] [--verbose] [--help] [--log-level=bulk|info|debug|warn|alert]");
} }
@ -82,8 +82,6 @@ static void help( int argc, char **argv, const string_list& elev_src ) {
cout << "where once again abcd is a valid airport code. In this case, all airports in the file subsequent to the \n"; cout << "where once again abcd is a valid airport code. In this case, all airports in the file subsequent to the \n";
cout << "start-id are done. This is convenient when re-starting after a previous error. \n"; cout << "start-id are done. This is convenient when re-starting after a previous error. \n";
cout << "\nAn input area may be specified by lat and lon extent using min and max lat and lon. \n"; cout << "\nAn input area may be specified by lat and lon extent using min and max lat and lon. \n";
//cout << "Alternatively, you may specify a chunk (10 x 10 degrees) or tile (1 x 1 degree) using a string \n";
//cout << "such as eg. w080n40, e000s27. \n";
cout << "\nAn input file containing only a subset of the world's \n"; cout << "\nAn input file containing only a subset of the world's \n";
cout << "airports may of course be used.\n"; cout << "airports may of course be used.\n";
cout << "\n\n"; cout << "\n\n";
@ -92,7 +90,7 @@ static void help( int argc, char **argv, const string_list& elev_src ) {
cout << "The following subdirectories of the work-dir will be searched for elevation files:\n\n"; cout << "The following subdirectories of the work-dir will be searched for elevation files:\n\n";
string_list::const_iterator elev_src_it; string_list::const_iterator elev_src_it;
for (elev_src_it = elev_src.begin(); elev_src_it != elev_src.end(); elev_src_it++) { for (elev_src_it = elev_src.begin(); elev_src_it != elev_src.end(); ++elev_src_it) {
cout << *elev_src_it << "\n"; cout << *elev_src_it << "\n";
} }
cout << "\n"; cout << "\n";
@ -159,110 +157,96 @@ int main(int argc, char **argv)
for (arg_pos = 1; arg_pos < argc; arg_pos++) for (arg_pos = 1; arg_pos < argc; arg_pos++)
{ {
string arg = argv[arg_pos]; string arg = argv[arg_pos];
if ( arg.find("--log-level=") == 0 ) if (arg.compare(0, 12, "--log-level=") == 0)
{ {
setLoggingPriority(arg.substr(12)); setLoggingPriority(arg.substr(12));
} }
else if ( arg.find("--work=") == 0 ) else if (arg.compare(0, 7, "--work=") == 0)
{ {
work_dir = arg.substr(7); work_dir = arg.substr(7);
} }
else if ( arg.find("--input=") == 0 ) else if (arg.compare(0, 8, "--input=") == 0)
{ {
input_file = arg.substr(8); input_file = arg.substr(8);
} }
else if ( arg.find("--start-id=") == 0 ) else if (arg.compare(0, 11, "--start-id=") == 0)
{ {
start_id = arg.substr(11); start_id = arg.substr(11);
} }
else if ( arg.find("--nudge=") == 0 ) else if (arg.compare(0, 8, "--nudge=") == 0)
{ {
nudge = atoi( arg.substr(8).c_str() ); nudge = atoi( arg.substr(8).c_str() );
} }
else if ( arg.find("--snap=") == 0 ) else if (arg.compare(0, 7, "--snap=") == 0)
{ {
gSnap = atof( arg.substr(7).c_str() ); gSnap = atof( arg.substr(7).c_str() );
} }
else if ( arg.find("--min-lon=") == 0 ) else if (arg.compare(0, 10, "--min-lon=") == 0)
{ {
min.setLongitudeDeg(atof( arg.substr(10).c_str() )); min.setLongitudeDeg(atof( arg.substr(10).c_str() ));
} }
else if ( arg.find("--max-lon=") == 0 ) else if (arg.compare(0, 10, "--max-lon=") == 0)
{ {
max.setLongitudeDeg(atof( arg.substr(10).c_str() )); max.setLongitudeDeg(atof( arg.substr(10).c_str() ));
} }
else if ( arg.find("--min-lat=") == 0 ) else if (arg.compare(0, 10, "--min-lat=") == 0)
{ {
min.setLatitudeDeg(atof( arg.substr(10).c_str() )); min.setLatitudeDeg(atof( arg.substr(10).c_str() ));
} }
else if ( arg.find("--max-lat=") == 0 ) else if (arg.compare(0, 10, "--max-lat=") == 0)
{ {
max.setLatitudeDeg(atof( arg.substr(10).c_str() )); max.setLatitudeDeg(atof( arg.substr(10).c_str() ));
} }
#if 0 // relly? - do we need this? else if (arg.compare(0, 10, "--airport=") == 0)
else if ( arg.find("--chunk=") == 0 )
{
tg::Rectangle rectangle = tg::parseChunk(arg.substr(8).c_str(), 10.0);
min = rectangle.getMin();
max = rectangle.getMax();
}
else if ( arg.find("--tile=") == 0 )
{
tg::Rectangle rectangle = tg::parseTile(arg.substr(7).c_str());
min = rectangle.getMin();
max = rectangle.getMax();
}
#endif
else if ( arg.find("--airport=") == 0 )
{ {
airport_id = simgear::strutils::uppercase( arg.substr(10).c_str() ); airport_id = simgear::strutils::uppercase( arg.substr(10).c_str() );
} }
else if ( arg == "--clear-dem-path" ) else if (arg.compare(0, 16, "--clear-dem-path") == 0)
{ {
elev_src.clear(); elev_src.clear();
} }
else if ( arg.find("--dem-path=") == 0 ) else if (arg.compare(0, 11, "--dem-path=") == 0)
{ {
elev_src.push_back( arg.substr(11) ); elev_src.push_back( arg.substr(11) );
} }
else if ( (arg.find("--verbose") == 0) || (arg.find("-v") == 0) ) else if (arg.compare(0, 9, "--verbose") == 0 || arg.compare(0, 2, "-v") == 0)
{ {
sglog().setLogLevels( SG_GENERAL, SG_BULK ); sglog().setLogLevels( SG_GENERAL, SG_BULK );
} }
else if ( (arg.find("--max-slope=") == 0) ) else if (arg.compare(0, 12, "--max-slope=") == 0)
{ {
slope_max = atof( arg.substr(12).c_str() ); slope_max = atof( arg.substr(12).c_str() );
} }
else if ( (arg.find("--threads=") == 0) ) else if (arg.compare(0, 10, "--threads=") == 0)
{ {
num_threads = atoi( arg.substr(10).c_str() ); num_threads = atoi( arg.substr(10).c_str() );
} }
else if ( (arg.find("--threads") == 0) ) else if (arg.compare(0, 9, "--threads") == 0)
{ {
num_threads = boost::thread::hardware_concurrency(); num_threads = boost::thread::hardware_concurrency();
} }
else if (arg.find("--debug-dir=") == 0) else if (arg.compare(0, 12, "--debug-dir=") == 0)
{ {
debug_dir = arg.substr(12); debug_dir = arg.substr(12);
} }
else if (arg.find("--debug-runways=") == 0) else if (arg.compare(0, 16, "--debug-runways=") == 0)
{ {
debug_runway_defs.push_back( arg.substr(16) ); debug_runway_defs.push_back( arg.substr(16) );
} }
else if (arg.find("--debug-pavements=") == 0) else if (arg.compare(0, 18, "--debug-pavements=") == 0)
{ {
debug_pavement_defs.push_back( arg.substr(18) ); debug_pavement_defs.push_back( arg.substr(18) );
} }
else if (arg.find("--debug-taxiways=") == 0) else if (arg.compare(0, 17, "--debug-taxiways=") == 0)
{ {
TG_LOG(SG_GENERAL, SG_INFO, "add debug taxiway " << arg.substr(17) ); TG_LOG(SG_GENERAL, SG_INFO, "add debug taxiway " << arg.substr(17) );
debug_taxiway_defs.push_back( arg.substr(17) ); debug_taxiway_defs.push_back( arg.substr(17) );
} }
else if (arg.find("--debug-features=") == 0) else if (arg.compare(0, 17, "--debug-features=") == 0)
{ {
debug_feature_defs.push_back( arg.substr(17) ); debug_feature_defs.push_back( arg.substr(17) );
} }
else if ( (arg.find("--help") == 0) || (arg.find("-h") == 0) ) else if (arg.compare(0, 6, "--help") == 0 || arg.compare(0, 2, "-h") == 0)
{ {
help( argc, argv, elev_src ); help( argc, argv, elev_src );
exit(-1); exit(-1);

2
src/Airports/GenAirports850/output.cxx
View file

@ -101,7 +101,7 @@ void write_index_object_sign( const string &base, const SGBucket &b,
exit(-1); exit(-1);
} }
fprintf( fp, "OBJECT_SIGN %s %.6f %.6f %.1f %.2f %u\n", sign.c_str(), fprintf( fp, "OBJECT_SIGN %s %.6f %.6f %.1f %.2f %d\n", sign.c_str(),
p.getLongitudeDeg(), p.getLatitudeDeg(), p.getElevationM(), heading, size ); p.getLongitudeDeg(), p.getLatitudeDeg(), p.getElevationM(), heading, size );
fclose( fp ); fclose( fp );
} }

521
src/Airports/GenAirports850/parser.cxx
View file

@ -8,17 +8,15 @@
bool Parser::GetAirportDefinition( char* line, std::string& icao ) bool Parser::GetAirportDefinition( char* line, std::string& icao )
{ {
char* tok; bool match = false;
int code;
bool match = false;
// Get the number code // Get the number code
tok = strtok(line, " \t\r\n"); char* tok = strtok(line, " \t\r\n");
if (tok) if (tok)
{ {
line += strlen(tok)+1; line += strlen(tok)+1;
code = atoi(tok); int code = atoi(tok);
switch(code) switch(code)
{ {
@ -40,7 +38,7 @@ bool Parser::GetAirportDefinition( char* line, std::string& icao )
return match; return match;
} }
void Parser::set_debug( std::string path, std::vector<std::string> runway_defs, void Parser::set_debug( const std::string& path, std::vector<std::string> runway_defs,
std::vector<std::string> pavement_defs, std::vector<std::string> pavement_defs,
std::vector<std::string> taxiway_defs, std::vector<std::string> taxiway_defs,
std::vector<std::string> feature_defs ) std::vector<std::string> feature_defs )
@ -416,7 +414,7 @@ std::shared_ptr<ClosedPoly> Parser::ParsePavement( char* line )
char *d = nullptr; char *d = nullptr;
int numParams; int numParams;
numParams = sscanf(line, "%d %f %f %s", &st, &s, &th, desc); numParams = sscanf(line, "%d %f %f %255s", &st, &s, &th, desc);
if (numParams == 4) if (numParams == 4)
{ {
@ -440,7 +438,7 @@ std::shared_ptr<ClosedPoly> Parser::ParseBoundary( char* line )
char *d = nullptr; char *d = nullptr;
int numParams; int numParams;
numParams = sscanf(line, "%s", desc); numParams = sscanf(line, "%255s", desc);
if (numParams == 1) if (numParams == 1)
{ {
@ -485,164 +483,196 @@ int Parser::SetState( int state )
// TODO: This should be a loop here, and main should just pass the file name and airport code... // TODO: This should be a loop here, and main should just pass the file name and airport code...
int Parser::ParseLine(char* line) int Parser::ParseLine(char* line)
{ {
char* tok;
int code;
std::shared_ptr<BezNode> cur_node = nullptr; std::shared_ptr<BezNode> cur_node = nullptr;
if (*line != '#') if (*line == '#')
return cur_state;
// Get the number code
char* tok = strtok(line, " \t\r\n");
if (tok)
{ {
// Get the number code line += strlen(tok)+1;
tok = strtok(line, " \t\r\n"); int code = atoi(tok);
if (tok) switch(code)
{ {
line += strlen(tok)+1; case LAND_AIRPORT_CODE:
code = atoi(tok); case SEA_AIRPORT_CODE:
if (cur_state == STATE_NONE)
{
SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing land airport: " << line);
cur_airport = std::make_shared<Airport>( code, line );
}
else
{
SetState( STATE_DONE );
}
break;
case HELIPORT_CODE:
if (cur_state == STATE_NONE)
{
SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing heliport: " << line);
cur_airport = std::make_shared<Airport>( code, line );
}
else
{
SetState( STATE_DONE );
}
break;
switch(code) case LAND_RUNWAY_CODE:
{ SetState( STATE_PARSE_SIMPLE );
case LAND_AIRPORT_CODE: TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing runway: " << line);
case SEA_AIRPORT_CODE: cur_runway = std::make_shared<Runway>(line);
if (cur_state == STATE_NONE) if (cur_airport)
{ {
SetState( STATE_PARSE_SIMPLE ); cur_airport->AddRunway( cur_runway );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing land airport: " << line); }
cur_airport = std::make_shared<Airport>( code, line ); break;
}
else
{
SetState( STATE_DONE );
}
break;
case HELIPORT_CODE:
if (cur_state == STATE_NONE)
{
SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing heliport: " << line);
cur_airport = std::make_shared<Airport>( code, line );
}
else
{
SetState( STATE_DONE );
}
break;
case LAND_RUNWAY_CODE:
SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing runway: " << line);
cur_runway = std::make_shared<Runway>(line);
if (cur_airport)
{
cur_airport->AddRunway( cur_runway );
}
break;
case WATER_RUNWAY_CODE:
SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing water runway: " << line);
cur_waterrunway = std::make_shared<WaterRunway>(line);
if (cur_airport)
{
cur_airport->AddWaterRunway( cur_waterrunway );
}
break;
case HELIPAD_CODE:
SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing helipad: " << line);
cur_helipad = std::make_shared<Helipad>(line);
if (cur_airport)
{
cur_airport->AddHelipad( cur_helipad );
}
break;
case TAXIWAY_CODE:
SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing taxiway: " << line);
cur_taxiway = std::make_shared<Taxiway>(line);
if (cur_airport)
{
cur_airport->AddTaxiway( cur_taxiway );
}
break;
case PAVEMENT_CODE:
SetState( STATE_PARSE_PAVEMENT );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing pavement: " << line);
cur_pavement = ParsePavement( line );
break;
case LINEAR_FEATURE_CODE:
SetState( STATE_PARSE_FEATURE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Linear Feature: " << line);
cur_feat = ParseFeature( line );
break;
case BOUNDARY_CODE:
SetState( STATE_PARSE_BOUNDARY );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing Boundary: " << line);
cur_boundary = ParseBoundary( line );
break;
case NODE_CODE:
case BEZIER_NODE_CODE:
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing node: " << line);
cur_node = ParseNode( code, line, prev_node );
if ( prev_node && (cur_node != prev_node) )
{
// prev node is done - process it
if ( cur_state == STATE_PARSE_PAVEMENT )
{
cur_pavement->AddNode( prev_node );
}
else if ( cur_state == STATE_PARSE_FEATURE )
{
cur_feat->AddNode( prev_node );
}
else if ( cur_state == STATE_PARSE_BOUNDARY )
{
cur_boundary->AddNode( prev_node );
}
}
prev_node = cur_node; case WATER_RUNWAY_CODE:
break; SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing water runway: " << line);
case CLOSE_NODE_CODE: cur_waterrunway = std::make_shared<WaterRunway>(line);
case CLOSE_BEZIER_NODE_CODE: if (cur_airport)
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing close loop node: " << line); {
cur_node = ParseNode( code, line, prev_node ); cur_airport->AddWaterRunway( cur_waterrunway );
}
break;
case HELIPAD_CODE:
SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing helipad: " << line);
cur_helipad = std::make_shared<Helipad>(line);
if (cur_airport)
{
cur_airport->AddHelipad( cur_helipad );
}
break;
if ( cur_state == STATE_PARSE_PAVEMENT && prev_node ) case TAXIWAY_CODE:
SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing taxiway: " << line);
cur_taxiway = std::make_shared<Taxiway>(line);
if (cur_airport)
{
cur_airport->AddTaxiway( cur_taxiway );
}
break;
case PAVEMENT_CODE:
SetState( STATE_PARSE_PAVEMENT );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing pavement: " << line);
cur_pavement = ParsePavement( line );
break;
case LINEAR_FEATURE_CODE:
SetState( STATE_PARSE_FEATURE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Linear Feature: " << line);
cur_feat = ParseFeature( line );
break;
case BOUNDARY_CODE:
SetState( STATE_PARSE_BOUNDARY );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing Boundary: " << line);
cur_boundary = ParseBoundary( line );
break;
case NODE_CODE:
case BEZIER_NODE_CODE:
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing node: " << line);
cur_node = ParseNode( code, line, prev_node );
if ( prev_node && (cur_node != prev_node) )
{
// prev node is done - process it
if ( cur_state == STATE_PARSE_PAVEMENT )
{ {
if (cur_node != prev_node) cur_pavement->AddNode( prev_node );
{
cur_pavement->AddNode( prev_node );
cur_pavement->AddNode( cur_node );
}
else
{
cur_pavement->AddNode( cur_node );
}
cur_pavement->CloseCurContour();
}
else if ( cur_state == STATE_PARSE_BOUNDARY )
{
if (cur_node != prev_node)
{
cur_boundary->AddNode( prev_node );
cur_boundary->AddNode( cur_node );
}
else
{
cur_boundary->AddNode( cur_node );
}
cur_boundary->CloseCurContour();
} }
else if ( cur_state == STATE_PARSE_FEATURE ) else if ( cur_state == STATE_PARSE_FEATURE )
{ {
cur_feat->AddNode( prev_node );
}
else if ( cur_state == STATE_PARSE_BOUNDARY )
{
cur_boundary->AddNode( prev_node );
}
}
prev_node = cur_node;
break;
case CLOSE_NODE_CODE:
case CLOSE_BEZIER_NODE_CODE:
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing close loop node: " << line);
cur_node = ParseNode( code, line, prev_node );
if ( cur_state == STATE_PARSE_PAVEMENT && prev_node )
{
if (cur_node != prev_node)
{
cur_pavement->AddNode( prev_node );
cur_pavement->AddNode( cur_node );
}
else
{
cur_pavement->AddNode( cur_node );
}
cur_pavement->CloseCurContour();
}
else if ( cur_state == STATE_PARSE_BOUNDARY )
{
if (cur_node != prev_node)
{
cur_boundary->AddNode( prev_node );
cur_boundary->AddNode( cur_node );
}
else
{
cur_boundary->AddNode( cur_node );
}
cur_boundary->CloseCurContour();
}
else if ( cur_state == STATE_PARSE_FEATURE )
{
if (cur_node != prev_node)
{
cur_feat->AddNode( prev_node );
cur_feat->AddNode( cur_node );
}
else
{
cur_feat->AddNode( cur_node );
}
if (cur_airport)
{
cur_feat->Finish( true, cur_airport->NumFeatures() );
cur_airport->AddFeature( cur_feat );
}
cur_feat = nullptr;
SetState( STATE_PARSE_SIMPLE );
}
prev_node = nullptr;
cur_node = nullptr;
break;
case TERM_NODE_CODE:
case TERM_BEZIER_NODE_CODE:
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing termination node: " << line);
if ( cur_state == STATE_PARSE_FEATURE )
{
// we have some bad data - termination nodes right after the
// linear feature declaration - can't do anything with a
// single point - detect and delete.
if ( prev_node )
{
cur_node = ParseNode( code, line, prev_node );
if (cur_node != prev_node) if (cur_node != prev_node)
{ {
cur_feat->AddNode( prev_node ); cur_feat->AddNode( prev_node );
@ -654,121 +684,86 @@ int Parser::ParseLine(char* line)
} }
if (cur_airport) if (cur_airport)
{ {
cur_feat->Finish( true, cur_airport->NumFeatures() ); cur_feat->Finish( false, cur_airport->NumFeatures() );
cur_airport->AddFeature( cur_feat ); cur_airport->AddFeature( cur_feat );
} }
cur_feat = nullptr;
SetState( STATE_PARSE_SIMPLE );
} }
prev_node = nullptr; else
cur_node = nullptr;
break;
case TERM_NODE_CODE:
case TERM_BEZIER_NODE_CODE:
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing termination node: " << line);
if ( cur_state == STATE_PARSE_FEATURE )
{ {
// we have some bad data - termination nodes right after the TG_LOG(SG_GENERAL, SG_ALERT, "Parsing termination node with no previous nodes!!!" );
// linear feature declaration - can't do anything with a
// single point - detect and delete.
if ( prev_node )
{
cur_node = ParseNode( code, line, prev_node );
if (cur_node != prev_node)
{
cur_feat->AddNode( prev_node );
cur_feat->AddNode( cur_node );
}
else
{
cur_feat->AddNode( cur_node );
}
if (cur_airport)
{
cur_feat->Finish( false, cur_airport->NumFeatures() );
cur_airport->AddFeature( cur_feat );
}
}
else
{
TG_LOG(SG_GENERAL, SG_ALERT, "Parsing termination node with no previous nodes!!!" );
}
cur_feat = nullptr;
SetState( STATE_PARSE_SIMPLE );
} }
prev_node = nullptr;
cur_node = nullptr; cur_feat = nullptr;
break;
case AIRPORT_VIEWPOINT_CODE:
SetState( STATE_PARSE_SIMPLE ); SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing viewpoint: " << line); }
break; prev_node = nullptr;
case AIRPLANE_STARTUP_LOCATION_CODE: cur_node = nullptr;
SetState( STATE_PARSE_SIMPLE ); break;
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing airplane startup location: " << line);
break; case AIRPORT_VIEWPOINT_CODE:
case LIGHT_BEACON_CODE: SetState( STATE_PARSE_SIMPLE );
SetState( STATE_PARSE_SIMPLE ); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing viewpoint: " << line);
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing light beacon: " << line); break;
cur_beacon = std::make_shared<Beacon>(line); case AIRPLANE_STARTUP_LOCATION_CODE:
cur_airport->AddBeacon( cur_beacon ); SetState( STATE_PARSE_SIMPLE );
break; TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing airplane startup location: " << line);
case WINDSOCK_CODE: break;
SetState( STATE_PARSE_SIMPLE ); case LIGHT_BEACON_CODE:
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing windsock: " << line); SetState( STATE_PARSE_SIMPLE );
cur_windsock = std::make_shared<Windsock>(line); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing light beacon: " << line);
cur_airport->AddWindsock( cur_windsock ); cur_beacon = std::make_shared<Beacon>(line);
break; cur_airport->AddBeacon( cur_beacon );
case TAXIWAY_SIGN: break;
SetState( STATE_PARSE_SIMPLE ); case WINDSOCK_CODE:
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing taxiway sign: " << line); SetState( STATE_PARSE_SIMPLE );
cur_sign = std::make_shared<Sign>(line); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing windsock: " << line);
cur_airport->AddSign( cur_sign ); cur_windsock = std::make_shared<Windsock>(line);
break; cur_airport->AddWindsock( cur_windsock );
case LIGHTING_OBJECT: break;
SetState( STATE_PARSE_SIMPLE ); case TAXIWAY_SIGN:
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing lighting object: " << line); SetState( STATE_PARSE_SIMPLE );
cur_object = std::make_shared<LightingObj>(line); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing taxiway sign: " << line);
cur_airport->AddObj( cur_object ); cur_sign = std::make_shared<Sign>(line);
break; cur_airport->AddSign( cur_sign );
case COMM_FREQ1_CODE: break;
SetState( STATE_PARSE_SIMPLE ); case LIGHTING_OBJECT:
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 1: " << line); SetState( STATE_PARSE_SIMPLE );
break; TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing lighting object: " << line);
case COMM_FREQ2_CODE: cur_object = std::make_shared<LightingObj>(line);
SetState( STATE_PARSE_SIMPLE ); cur_airport->AddObj( cur_object );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 2: " << line); break;
break; case COMM_FREQ1_CODE:
case COMM_FREQ3_CODE: SetState( STATE_PARSE_SIMPLE );
SetState( STATE_PARSE_SIMPLE ); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 1: " << line);
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 3: " << line); break;
break; case COMM_FREQ2_CODE:
case COMM_FREQ4_CODE: SetState( STATE_PARSE_SIMPLE );
SetState( STATE_PARSE_SIMPLE ); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 2: " << line);
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 4: " << line); break;
break; case COMM_FREQ3_CODE:
case COMM_FREQ5_CODE: SetState( STATE_PARSE_SIMPLE );
SetState( STATE_PARSE_SIMPLE ); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 3: " << line);
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 5: " << line); break;
break; case COMM_FREQ4_CODE:
case COMM_FREQ6_CODE: SetState( STATE_PARSE_SIMPLE );
SetState( STATE_PARSE_SIMPLE ); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 4: " << line);
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 6: " << line); break;
break; case COMM_FREQ5_CODE:
case COMM_FREQ7_CODE: SetState( STATE_PARSE_SIMPLE );
SetState( STATE_PARSE_SIMPLE ); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 5: " << line);
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 7: " << line); break;
break; case COMM_FREQ6_CODE:
case END_OF_FILE : SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Reached end of file"); TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 6: " << line);
SetState( STATE_DONE ); break;
break; case COMM_FREQ7_CODE:
} SetState( STATE_PARSE_SIMPLE );
TG_LOG(SG_GENERAL, SG_DEBUG, "Parsing commfreq 7: " << line);
break;
case END_OF_FILE :
TG_LOG(SG_GENERAL, SG_DEBUG, "Reached end of file");
SetState( STATE_DONE );
break;
} }
} }

39
src/Airports/GenAirports850/parser.hxx
View file

@ -89,30 +89,29 @@
class Parser : public SGThread class Parser : public SGThread
{ {
public: public:
Parser(const std::string& datafile, const std::string& root, const string_list& elev_src ) Parser(const std::string& datafile, const std::string& root, const string_list& elev_src ) :
prev_node(nullptr),
filename(datafile),
elevation(elev_src),
work_dir(root),
cur_airport(nullptr),
cur_taxiway(nullptr),
cur_runway(nullptr),
cur_waterrunway(nullptr),
cur_helipad(nullptr),
cur_pavement(nullptr),
cur_boundary(nullptr),
cur_feat(nullptr),
cur_object(nullptr),
cur_windsock(nullptr),
cur_beacon(nullptr),
cur_sign(nullptr)
{ {
filename = datafile; cur_state = STATE_NONE;
work_dir = root;
elevation = elev_src;
cur_airport = nullptr;
cur_runway = nullptr;
cur_waterrunway = nullptr;
cur_helipad = nullptr;
cur_taxiway = nullptr;
cur_pavement = nullptr;
cur_boundary = nullptr;
cur_feat = nullptr;
cur_object = nullptr;
cur_windsock = nullptr;
cur_beacon = nullptr;
cur_sign = nullptr;
prev_node = nullptr;
cur_state = STATE_NONE;
} }
// Debug // Debug
void set_debug( std::string path, std::vector<std::string> runway_defs, void set_debug( const std::string& path, std::vector<std::string> runway_defs,
std::vector<std::string> pavement_defs, std::vector<std::string> pavement_defs,
std::vector<std::string> taxiway_defs, std::vector<std::string> taxiway_defs,
std::vector<std::string> feature_defs ); std::vector<std::string> feature_defs );

2
src/Airports/GenAirports850/runway.hxx
View file

@ -55,7 +55,7 @@ public:
private: private:
struct TGRunway { struct TGRunway {
// data for whole runway // data for whole runway
int surface; int surface;
int shoulder; int shoulder;
int centerline_lights; int centerline_lights;

13
src/Airports/GenAirports850/rwy_gen.cxx
View file

@ -832,19 +832,16 @@ void Runway::gen_rwy( tgpolygon_list& rwy_polys,
start1_pct = 0.0; start1_pct = 0.0;
end1_pct = 0.0; end1_pct = 0.0;
double part_len = 0.0;
int count=0;
if (rwy.overrun[rwhalf] > 0.0) { if (rwy.overrun[rwhalf] > 0.0) {
/* Generate approach end overrun */ /* Generate approach end overrun */
count = (int) (rwy.overrun[rwhalf] * 2.0/ rwy.width); int count = (int) (rwy.overrun[rwhalf] * 2.0/ rwy.width);
if(count < 1) { if (count < 1) {
count = 1; count = 1;
} }
part_len = rwy.overrun[rwhalf] / (double)count; double part_len = rwy.overrun[rwhalf] / (double)count;
for(int i=0; i<count; i++) { for (int i = 0; i < count; ++i) {
start1_pct=end1_pct; start1_pct = end1_pct;
end1_pct = start1_pct + ( part_len / length ); end1_pct = start1_pct + ( part_len / length );
if ( debug ) { section_name = shapefile_name + "stopway"; } if ( debug ) { section_name = shapefile_name + "stopway"; }
gen_runway_section( runway_half, gen_runway_section( runway_half,

6
src/Airports/GenAirports850/rwy_simple.cxx
View file

@ -22,6 +22,7 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
#include "runway.hxx" #include "runway.hxx"
#include "debug.hxx" #include "debug.hxx"
@ -37,9 +38,7 @@ void Runway::gen_simple_rwy( tgpolygon_list& rwy_polys,
std::string empty = ""; std::string empty = "";
for ( int rwhalf=0; rwhalf<2; ++rwhalf ) { for ( int rwhalf=0; rwhalf<2; ++rwhalf ) {
double length = rwy.length / 2.0; double length = rwy.length / 2.0;
double start_pct = 0.0;
double end_pct = 0.0; double end_pct = 0.0;
double heading = 0.0; double heading = 0.0;
@ -53,7 +52,6 @@ void Runway::gen_simple_rwy( tgpolygon_list& rwy_polys,
runway_half.AddNode( 0, runway.GetNode(5) ); runway_half.AddNode( 0, runway.GetNode(5) );
runway_half.AddNode( 0, runway.GetNode(2) ); runway_half.AddNode( 0, runway.GetNode(2) );
} }
else { else {
heading = rwy.heading; heading = rwy.heading;
@ -71,7 +69,7 @@ void Runway::gen_simple_rwy( tgpolygon_list& rwy_polys,
if ( rwy.threshold[rwhalf] > 0.0 ) { if ( rwy.threshold[rwhalf] > 0.0 ) {
TG_LOG( SG_GENERAL, SG_DEBUG, "Displaced threshold for RW side " << rwhalf << " is " << rwy.threshold[rwhalf] ); TG_LOG( SG_GENERAL, SG_DEBUG, "Displaced threshold for RW side " << rwhalf << " is " << rwy.threshold[rwhalf] );
start_pct = end_pct; double start_pct = end_pct;
end_pct = start_pct + ( rwy.threshold[rwhalf] / length ); end_pct = start_pct + ( rwy.threshold[rwhalf] / length );
Runway::gen_runway_section( runway_half, Runway::gen_runway_section( runway_half,
start_pct, end_pct, start_pct, end_pct,

53
src/Airports/GenAirports850/scheduler.cxx
View file

@ -49,7 +49,7 @@ std::ostream& operator<< (std::ostream &out, const AirportInfo &ai)
return out; // MSVC return out; // MSVC
} }
void Scheduler::set_debug( std::string path, std::vector<std::string> runway_defs, void Scheduler::set_debug( const std::string& path, std::vector<std::string> runway_defs,
std::vector<std::string> pavement_defs, std::vector<std::string> pavement_defs,
std::vector<std::string> taxiway_defs, std::vector<std::string> taxiway_defs,
std::vector<std::string> feature_defs ) std::vector<std::string> feature_defs )
@ -176,32 +176,31 @@ void Scheduler::set_debug( std::string path, std::vector<std::string> runway_def
} }
} }
bool Scheduler::IsAirportDefinition( char* line, std::string icao ) bool Scheduler::IsAirportDefinition( char* line, const std::string& icao )
{ {
char* tok; bool match = false;
int code;
bool match = false;
// Get the number code // Get the number code
tok = strtok(line, " \t\r\n"); char* tok = strtok(line, " \t\r\n");
if (tok) if (tok)
{ {
line += strlen(tok)+1; line += strlen(tok)+1;
code = atoi(tok); int code = atoi(tok);
switch(code) switch(code)
{ {
case LAND_AIRPORT_CODE: case LAND_AIRPORT_CODE:
case SEA_AIRPORT_CODE: case SEA_AIRPORT_CODE:
case HELIPORT_CODE: case HELIPORT_CODE:
{
Airport ap( code, line );
if ( ap.GetIcao() == icao )
{ {
match = true; Airport ap( code, line );
if ( ap.GetIcao() == icao )
{
match = true;
}
} }
}
break; break;
case LAND_RUNWAY_CODE: case LAND_RUNWAY_CODE:
@ -240,7 +239,6 @@ bool Scheduler::IsAirportDefinition( char* line, std::string icao )
void Scheduler::AddAirport( std::string icao ) void Scheduler::AddAirport( std::string icao )
{ {
char line[2048]; char line[2048];
long cur_pos;
bool found = false; bool found = false;
AirportInfo ai; AirportInfo ai;
@ -255,7 +253,7 @@ void Scheduler::AddAirport( std::string icao )
while ( !in.eof() && !found ) while ( !in.eof() && !found )
{ {
// remember the position of this line // remember the position of this line
cur_pos = in.tellg(); long cur_pos = in.tellg();
// get a line // get a line
in.getline(line, 2048); in.getline(line, 2048);
@ -273,7 +271,7 @@ void Scheduler::AddAirport( std::string icao )
} }
} }
long Scheduler::FindAirport( std::string icao ) long Scheduler::FindAirport( const std::string& icao )
{ {
char line[2048]; char line[2048];
long cur_pos = 0; long cur_pos = 0;
@ -321,11 +319,8 @@ void Scheduler::RetryAirport( AirportInfo* pai )
bool Scheduler::AddAirports( long start_pos, tgRectangle* boundingBox ) bool Scheduler::AddAirports( long start_pos, tgRectangle* boundingBox )
{ {
char line[2048]; char line[2048];
char* def;
long cur_pos;
long cur_apt_pos = 0; long cur_apt_pos = 0;
std::string cur_apt_name; std::string cur_apt_name;
char* tok;
int code; int code;
bool match; bool match;
bool done; bool done;
@ -351,14 +346,14 @@ bool Scheduler::AddAirports( long start_pos, tgRectangle* boundingBox )
while (!done) while (!done)
{ {
// remember the position of this line // remember the position of this line
cur_pos = in.tellg(); long cur_pos = in.tellg();
// get a line // get a line
in.getline(line, 2048); in.getline(line, 2048);
def = &line[0]; char* def = &line[0];
// Get the number code // Get the number code
tok = strtok(def, " \t\r\n"); char* tok = strtok(def, " \t\r\n");
if (tok) if (tok)
{ {
@ -471,12 +466,11 @@ bool Scheduler::AddAirports( long start_pos, tgRectangle* boundingBox )
} }
} }
Scheduler::Scheduler(std::string& datafile, const std::string& root, const string_list& elev_src) Scheduler::Scheduler(std::string& datafile, const std::string& root, const string_list& elev_src) :
filename(datafile),
elevation(elev_src),
work_dir(root)
{ {
filename = datafile;
work_dir = root;
elevation = elev_src;
std::ifstream in( filename.c_str() ); std::ifstream in( filename.c_str() );
if ( !in.is_open() ) if ( !in.is_open() )
{ {
@ -487,16 +481,9 @@ Scheduler::Scheduler(std::string& datafile, const std::string& root, const strin
void Scheduler::Schedule( int num_threads, std::string& summaryfile ) void Scheduler::Schedule( int num_threads, std::string& summaryfile )
{ {
// std::ofstream csvfile;
// open and truncate the summary file : monitor only appends
// csvfile.open( summaryfile.c_str(), std::ios_base::out | std::ios_base::trunc );
// csvfile.close();
std::vector<std::shared_ptr<Parser>> parsers; std::vector<std::shared_ptr<Parser>> parsers;
for (int i=0; i<num_threads; i++) { for (int i=0; i<num_threads; i++) {
auto parser = std::make_shared<Parser>( filename, work_dir, elevation ); auto parser = std::make_shared<Parser>( filename, work_dir, elevation );
// parser->set_debug();
parser->start(); parser->start();
parsers.push_back( parser ); parsers.push_back( parser );
} }

10
src/Airports/GenAirports850/scheduler.hxx
View file

@ -44,9 +44,9 @@ public:
{ {
} }
AirportInfo( std::string id, long p, double s ) AirportInfo( const std::string& id, long p, double s ) :
icao(id)
{ {
icao = id;
pos = p; pos = p;
snap = s; snap = s;
@ -99,7 +99,7 @@ class Scheduler
public: public:
Scheduler(std::string& datafile, const std::string& root, const string_list& elev_src); Scheduler(std::string& datafile, const std::string& root, const string_list& elev_src);
long FindAirport( std::string icao ); long FindAirport( const std::string& icao );
void AddAirport( std::string icao ); void AddAirport( std::string icao );
bool AddAirports( long start_pos, tgRectangle* boundingBox ); bool AddAirports( long start_pos, tgRectangle* boundingBox );
void RetryAirport( AirportInfo* pInfo ); void RetryAirport( AirportInfo* pInfo );
@ -107,13 +107,13 @@ public:
void Schedule( int num_threads, std::string& summaryfile ); void Schedule( int num_threads, std::string& summaryfile );
// Debug // Debug
void set_debug( std::string path, std::vector<std::string> runway_defs, void set_debug( const std::string& path, std::vector<std::string> runway_defs,
std::vector<std::string> pavement_defs, std::vector<std::string> pavement_defs,
std::vector<std::string> taxiway_defs, std::vector<std::string> taxiway_defs,
std::vector<std::string> feature_defs ); std::vector<std::string> feature_defs );
private: private:
bool IsAirportDefinition( char* line, std::string icao ); bool IsAirportDefinition( char* line, const std::string& icao );
std::string filename; std::string filename;
string_list elevation; string_list elevation;