serial::KmlGenerator Class Reference

Generates KML files from FERS simulation scenarios for geographical visualization. More...

#include "kml_generator.h"

Static Public Member Functions
static bool	generateKml (const core::World &world, const std::string &outputKmlPath)
	Generates a KML file from a pre-built simulation world.

Detailed Description

Generates KML files from FERS simulation scenarios for geographical visualization.

This class generates KML files for geographical visualization of FERS scenarios. It interprets the simulation coordinates based on the user-specified coordinate system in the XML file, which can be one of:

• ENU (East-North-Up): Default. Local Cartesian coordinates (x, y, z) are treated as meters in an ENU tangent plane centered at a geodetic <origin>.
• UTM (Universal Transverse Mercator): Coordinates (x, y, z) are treated as easting (m), northing (m), and altitude (m) within a specified UTM zone and hemisphere.
• ECEF (Earth-Centered, Earth-Fixed): Coordinates (x, y, z) are treated as geocentric X, Y, Z values in meters.

All input coordinates are converted to WGS84 geodetic coordinates (latitude, longitude, altitude) for the final KML output. The KML is written with <altitudeMode>absolute</altitudeMode>, where altitude is relative to Mean Sea Level (MSL).

Definition at line 46 of file kml_generator.h.

Member Function Documentation

generateKml()

bool serial::KmlGenerator::generateKml ( const core::World &  world, const std::string &  outputKmlPath  )

static

Generates a KML file from a pre-built simulation world.

Parameters

world	The simulation world containing all objects and paths.
outputKmlPath	The path for the output KML file.

Returns

True on success, false on failure.

Definition at line 654 of file kml_generator.cpp.

    {
        try
        {
            // Setup coordinate conversion based on global parameters
            ConverterFunc converter;
            double reference_latitude, reference_longitude, reference_altitude;
 
            switch (params::coordinateFrame())
            {
            case params::CoordinateFrame::ENU:
                {
                    reference_latitude = params::originLatitude();
                    reference_longitude = params::originLongitude();
                    reference_altitude = params::originAltitude();
                    auto proj = std::make_shared<GeographicLib::LocalCartesian>(reference_latitude, reference_longitude,
                                                                                reference_altitude);
                    converter = [proj](const math::Vec3& pos, double& lat, double& lon, double& alt)
                    { proj->Reverse(pos.x, pos.y, pos.z, lat, lon, alt); };
                    break;
                }
            case params::CoordinateFrame::UTM:
                {
                    const int zone = params::utmZone();
                    const bool northp = params::utmNorthHemisphere();
                    converter = [zone, northp](const math::Vec3& pos, double& lat, double& lon, double& alt)
                    {
                        double gamma, k;
                        GeographicLib::UTMUPS::Reverse(zone, northp, pos.x, pos.y, lat, lon, gamma, k);
                        alt = pos.z; // Altitude is given directly in the z-coordinate
                    };
                    break;
                }
            case params::CoordinateFrame::ECEF:
                {
                    const auto& earth = GeographicLib::Geocentric::WGS84();
                    converter = [&earth](const math::Vec3& pos, double& lat, double& lon, double& alt)
                    { earth.Reverse(pos.x, pos.y, pos.z, lat, lon, alt); };
                    break;
                }
            }
 
            map<const radar::Platform*, vector<const radar::Object*>> platform_to_objects;
            const auto group_objects = [&](const auto& objectCollection)
            {
                for (const auto& obj_ptr : objectCollection)
                {
                    platform_to_objects[obj_ptr->getPlatform()].push_back(obj_ptr.get());
                }
            };
 
            group_objects(world.getReceivers());
            group_objects(world.getTransmitters());
            group_objects(world.getTargets());
 
            if (params::coordinateFrame() != params::CoordinateFrame::ENU)
            {
                bool ref_set = false;
                for (const auto& platform : platform_to_objects | views::keys)
                {
                    if (!platform->getMotionPath()->getCoords().empty())
                    {
                        const math::Vec3& first_pos = platform->getMotionPath()->getCoords().front().pos;
                        converter(first_pos, reference_latitude, reference_longitude, reference_altitude);
                        ref_set = true;
                        break;
                    }
                }
                if (!ref_set) // Fallback if no platforms or no waypoints
                {
                    reference_latitude = params::originLatitude(); // UCT default
                    reference_longitude = params::originLongitude();
                    reference_altitude = params::originAltitude();
                }
            }
 
            std::ofstream kml_file(outputKmlPath.c_str());
            if (!kml_file.is_open())
            {
                LOG(logging::Level::ERROR, "Error opening output KML file {}", outputKmlPath);
                return false;
            }
 
            writeKmlHeaderAndStyles(kml_file);
 
            kml_file << "  <Folder>\n";
            kml_file << "    <name>Reference Coordinate</name>\n";
            kml_file << "    <description>Placemarks for various elements in the FERSXML file. All Placemarks are "
                        "situated relative to this reference point.</description>\n";
            kml_file << "    <LookAt>\n";
            kml_file << "      <longitude>" << reference_longitude << "</longitude>\n";
            kml_file << "      <latitude>" << reference_latitude << "</latitude>\n";
            kml_file << "      <altitude>" << reference_altitude << "</altitude>\n";
            kml_file << "      <heading>-148.41</heading><tilt>40.55</tilt><range>10000</range>\n";
            kml_file << "    </LookAt>\n";
 
            const std::string platform_indent = "    ";
            for (const auto& [platform, objects] : platform_to_objects)
            {
                processPlatform(platform, objects, kml_file, converter, reference_altitude, platform_indent);
            }
 
            kml_file << "  </Folder>\n";
            kml_file << "</Document>\n";
            kml_file << "</kml>\n";
            kml_file.close();
        }
        catch (const std::exception& e)
        {
            LOG(logging::Level::ERROR, "Error generating KML file: {}", e.what());
            return false;
        }
        catch (...)
        {
            LOG(logging::Level::ERROR, "Unknown error occurred while generating KML file.");
            return false;
        }
        return true;
    }

References params::coordinateFrame(), params::ECEF, params::ENU, logging::ERROR, math::Path::getCoords(), radar::Platform::getMotionPath(), core::World::getReceivers(), core::World::getTargets(), core::World::getTransmitters(), LOG, params::originAltitude(), params::originLatitude(), params::originLongitude(), params::UTM, params::utmNorthHemisphere(), params::utmZone(), math::Vec3::x, math::Vec3::y, and math::Vec3::z.

Referenced by fers_generate_kml().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• packages/libfers/src/serial/kml_generator.h
• packages/libfers/src/serial/kml_generator.cpp