serial::KmlGenerator Class Reference

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

#include "kml_generator.h"

Static Public Member Functions
static std::expected< void, std::string >	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 converts the stored platform coordinates to geodetic KML output using the user-specified KML/geospatial coordinate system in the XML file. This affects KML conversion only; the signal simulation uses the raw platform vectors directly. The KML/geospatial coordinate system 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 49 of file kml_generator.h.

Member Function Documentation

generateKml()

std::expected< void, std::string > 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

Success or an error message describing why generation failed.

Definition at line 28 of file kml_generator.cpp.

    {
        try
        {
            kml_generator_utils::KmlContext ctx;
            ctx.parameters = params::params;
 
            switch (ctx.parameters.coordinate_frame)
            {
            case params::CoordinateFrame::ENU:
                {
                    auto proj = std::make_shared<GeographicLib::LocalCartesian>(ctx.parameters.origin_latitude,
                                                                                ctx.parameters.origin_longitude,
                                                                                ctx.parameters.origin_altitude);
                    ctx.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 = ctx.parameters.utm_zone;
                    const bool northp = ctx.parameters.utm_north_hemisphere;
                    ctx.converter = [zone, northp](const math::Vec3& pos, double& lat, double& lon, double& alt)
                    {
                        double gamma = std::numeric_limits<double>::quiet_NaN();
                        double k = std::numeric_limits<double>::quiet_NaN();
                        GeographicLib::UTMUPS::Reverse(zone, northp, pos.x, pos.y, lat, lon, gamma, k);
                        alt = pos.z;
                    };
                    break;
                }
            case params::CoordinateFrame::ECEF:
                {
                    const auto& earth = GeographicLib::Geocentric::WGS84();
                    ctx.converter = [&earth](const math::Vec3& pos, double& lat, double& lon, double& alt)
                    { earth.Reverse(pos.x, pos.y, pos.z, lat, lon, alt); };
                    break;
                }
            }
 
            std::ofstream kml_file(outputKmlPath.c_str());
            if (!kml_file.is_open())
            {
                const std::string message = "Error opening output KML file " + outputKmlPath;
                LOG(logging::Level::ERROR, "{}", message);
                return std::unexpected(message);
            }
 
            kml_generator_utils::generateKmlToStream(kml_file, world, ctx);
            kml_file.close();
        }
        catch (const std::exception& e)
        {
            const std::string message = "Error generating KML file: " + std::string(e.what());
            LOG(logging::Level::ERROR, "{}", message);
            return std::unexpected(message);
        }
        catch (...)
        {
            const std::string message = "Unknown error occurred while generating KML file.";
            LOG(logging::Level::ERROR, "{}", message);
            return std::unexpected(message);
        }
        return {};
    }

References params::ECEF, params::ENU, logging::ERROR, serial::kml_generator_utils::generateKmlToStream(), LOG, max, params::params, params::UTM, 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