Classes
class	Coord
	Represents a position in 3D space with an associated time. More...

class	Matrix3
	A class representing a 3x3 matrix. More...

class	Path
	Represents a path with coordinates and allows for various interpolation methods. More...

class	PathException
	Exception class for handling path-related errors. More...

class	RotationCoord
	Represents a rotation in terms of azimuth, elevation, and time. More...

class	RotationPath
	Manages rotational paths with different interpolation techniques. More...

class	SVec3
	A class representing a vector in spherical coordinates. More...

class	Vec3
	A class representing a vector in rectangular coordinates. More...

Functions
Coord	operator* (const Coord &a, const Coord &b) noexcept
	Multiplies two `Coord` objects' positions and copies the time.

Coord	operator+ (const Coord &a, const Coord &b) noexcept
	Adds two `Coord` objects' positions and copies the time.

Coord	operator- (const Coord &a, const Coord &b) noexcept
	Subtracts two `Coord` objects' positions and copies the time.

Coord	operator/ (const Coord &a, const Coord &b) noexcept
	Divides two `Coord` objects' positions and copies the time.

Coord	operator+ (const Coord &a, const RealType b) noexcept
	Adds a scalar to a `Coord`'s position while copying the time.

Coord	operator* (const Coord &a, const RealType b) noexcept
	Multiplies a `Coord`'s position by a scalar while copying the time.

Coord	operator/ (const RealType a, const Coord &b) noexcept
	Divides a scalar by a `Coord`'s position and copies the time.

Coord	operator/ (const Coord &b, const RealType a) noexcept
	Divides a `Coord`'s position by a scalar while copying the time.

RotationCoord	operator* (const RotationCoord &a, const RotationCoord &b) noexcept
	Multiplies two `RotationCoord` objects' components and copies the time.

RotationCoord	operator+ (const RotationCoord &a, const RotationCoord &b) noexcept
	Adds two `RotationCoord` objects' components and copies the time.

RotationCoord	operator- (const RotationCoord &a, const RotationCoord &b) noexcept
	Subtracts two `RotationCoord` objects' components and copies the time.

RotationCoord	operator/ (const RotationCoord &a, const RotationCoord &b) noexcept
	Divides two `RotationCoord` objects' components and copies the time.

RotationCoord	operator+ (const RotationCoord &a, const RealType b) noexcept
	Adds a scalar to a `RotationCoord`'s components while copying the time.

RotationCoord	operator* (const RotationCoord &a, const RealType b) noexcept
	Multiplies a `RotationCoord`'s components by a scalar while copying the time.

RotationCoord	operator/ (const RealType a, const RotationCoord &b) noexcept
	Divides a scalar by a `RotationCoord`'s components and copies the time.

RotationCoord	operator/ (const RotationCoord &b, const RealType a) noexcept
	Divides a `RotationCoord`'s components by a scalar while copying the time.

SVec3	operator+ (const SVec3 &a, const SVec3 &b) noexcept
	Adds two SVec3 vectors.

SVec3	operator- (const SVec3 &a, const SVec3 &b) noexcept
	Subtracts two SVec3 vectors.

RealType	dotProduct (const Vec3 &a, const Vec3 &b) noexcept
	Computes the dot product of two Vec3 vectors.

Vec3	operator* (const Vec3 &a, const Vec3 &b) noexcept
	Multiplies two Vec3 vectors component-wise.

Vec3	operator+ (const Vec3 &a, const Vec3 &b) noexcept
	Adds two Vec3 vectors component-wise.

Vec3	operator- (const Vec3 &a, const Vec3 &b) noexcept
	Subtracts two Vec3 vectors component-wise.

Vec3	operator/ (const Vec3 &a, const Vec3 &b)
	Divides two Vec3 vectors component-wise.

Vec3	operator* (const Vec3 &a, const RealType b) noexcept
	Multiplies a Vec3 vector by a scalar value.

Vec3	operator/ (const Vec3 &a, const RealType b) noexcept
	Divides a Vec3 vector by a scalar value.

Vec3	operator/ (const RealType a, const Vec3 &b) noexcept
	Divides a scalar value by a Vec3 vector.

void	to_json (nlohmann::json &j, const Vec3 &v)

void	from_json (const nlohmann::json &j, Vec3 &v)

void	to_json (nlohmann::json &j, const Coord &c)

void	from_json (const nlohmann::json &j, Coord &c)

void	to_json (nlohmann::json &j, const RotationCoord &rc)

void	from_json (const nlohmann::json &j, RotationCoord &rc)

	NLOHMANN_JSON_SERIALIZE_ENUM (Path::InterpType, {{Path::InterpType::INTERP_STATIC, "static"}, {Path::InterpType::INTERP_LINEAR, "linear"}, {Path::InterpType::INTERP_CUBIC, "cubic"}}) void to_json(nlohmann

void	from_json (const nlohmann::json &j, Path &p)

	NLOHMANN_JSON_SERIALIZE_ENUM (RotationPath::InterpType, {{RotationPath::InterpType::INTERP_STATIC, "static"}, {RotationPath::InterpType::INTERP_CONSTANT, "constant"}, {RotationPath::InterpType::INTERP_LINEAR, "linear"}, {RotationPath::InterpType::INTERP_CUBIC, "cubic"}}) void to_json(nlohmann

void	from_json (const nlohmann::json &j, RotationPath &p)

Function Documentation

◆ dotProduct()

RealType math::dotProduct	(	const Vec3 &	a,
		const Vec3 &	b
	)

noexcept

Computes the dot product of two Vec3 vectors.

Parameters

a	The first vector.
b	The second vector.

Returns: The dot product of the vectors.

Definition at line 207 of file geometry_ops.h.

207{ return a.x * b.x + a.y * b.y + a.z * b.z; }

math::Vec3::x

RealType x

The x component of the vector.

Definition geometry_ops.h:108

math::Vec3::z

RealType z

The z component of the vector.

Definition geometry_ops.h:110

math::Vec3::y

RealType y

The y component of the vector.

Definition geometry_ops.h:109

◆ from_json() [1/5]

void math::from_json	(	const nlohmann::json &	j,
		Coord &	c
	)

Definition at line 55 of file json_serializer.cpp.

    {
        j.at("time").get_to(c.t);
        j.at("x").get_to(c.pos.x);
        j.at("y").get_to(c.pos.y);
        j.at("altitude").get_to(c.pos.z);
    }

◆ from_json() [2/5]

void math::from_json	(	const nlohmann::json &	j,
		Path &	p
	)

Definition at line 97 of file json_serializer.cpp.

    {
        p.setInterp(j.at("interpolation").get<Path::InterpType>());
        for (const auto waypoints = j.at("positionwaypoints").get<std::vector<Coord>>(); const auto& wp : waypoints)
        {
            p.addCoord(wp);
        }
        p.finalize();
    }

References math::Path::addCoord(), math::Path::finalize(), and math::Path::setInterp().

Here is the call graph for this function:

◆ from_json() [3/5]

void math::from_json	(	const nlohmann::json &	j,
		RotationCoord &	rc
	)

Definition at line 74 of file json_serializer.cpp.

    {
        j.at("time").get_to(rc.t);
        const RealType az_deg = j.at("azimuth").get<RealType>();
        const RealType el_deg = j.at("elevation").get<RealType>();
 
        // Convert from compass degrees (from JSON/UI) back to the internal engine's
        // mathematical angle representation (radians, CCW from East). This keeps
        // all internal physics calculations consistent.
        rc.azimuth = (90.0 - az_deg) * (PI / 180.0);
        rc.elevation = el_deg * (PI / 180.0);
    }

References math::RotationCoord::azimuth, math::RotationCoord::elevation, PI, and math::RotationCoord::t.

◆ from_json() [4/5]

void math::from_json	(	const nlohmann::json &	j,
		RotationPath &	p
	)

Definition at line 140 of file json_serializer.cpp.

    {
        p.setInterp(j.at("interpolation").get<RotationPath::InterpType>());
        for (const auto waypoints = j.at("rotationwaypoints").get<std::vector<RotationCoord>>();
             const auto& wp : waypoints)
        {
            p.addCoord(wp);
        }
        p.finalize();
    }

References math::RotationPath::addCoord(), math::RotationPath::finalize(), and math::RotationPath::setInterp().

Here is the call graph for this function:

◆ from_json() [5/5]

void math::from_json	(	const nlohmann::json &	j,
		Vec3 &	v
	)

Definition at line 43 of file json_serializer.cpp.

    {
        j.at("x").get_to(v.x);
        j.at("y").get_to(v.y);
        j.at("z").get_to(v.z);
    }

References math::Vec3::x, math::Vec3::y, and math::Vec3::z.

◆ NLOHMANN_JSON_SERIALIZE_ENUM() [1/2]

math::NLOHMANN_JSON_SERIALIZE_ENUM	(	Path::InterpType	,
		{{Path::InterpType::INTERP_STATIC, "static"}, {Path::InterpType::INTERP_LINEAR, "linear"}, {Path::InterpType::INTERP_CUBIC, "cubic"}}
	)

Definition at line 87 of file json_serializer.cpp.

                                 {{Path::InterpType::INTERP_STATIC, "static"},
                                  {Path::InterpType::INTERP_LINEAR, "linear"},
                                  {Path::InterpType::INTERP_CUBIC, "cubic"}})
 
    void to_json(nlohmann::json& j, const Path& p)
    {
        j = {{"interpolation", p.getType()}, {"positionwaypoints", p.getCoords()}};
    }

References math::Path::INTERP_CUBIC, math::Path::INTERP_LINEAR, and math::Path::INTERP_STATIC.

◆ NLOHMANN_JSON_SERIALIZE_ENUM() [2/2]

math::NLOHMANN_JSON_SERIALIZE_ENUM	(	RotationPath::InterpType	,
		{{RotationPath::InterpType::INTERP_STATIC, "static"}, {RotationPath::InterpType::INTERP_CONSTANT, "constant"}, {RotationPath::InterpType::INTERP_LINEAR, "linear"}, {RotationPath::InterpType::INTERP_CUBIC, "cubic"}}
	)

Definition at line 107 of file json_serializer.cpp.

                                 {{RotationPath::InterpType::INTERP_STATIC, "static"},
                                  {RotationPath::InterpType::INTERP_CONSTANT,
                                   "constant"}, // Not used in xml_parser or UI yet, but for completeness
                                  {RotationPath::InterpType::INTERP_LINEAR, "linear"},
                                  {RotationPath::InterpType::INTERP_CUBIC, "cubic"}})
 
    void to_json(nlohmann::json& j, const RotationPath& p)
    {
        j["interpolation"] = p.getType();
        // This logic exists to map the two different rotation definitions from the
        // XML schema (<fixedrotation> and <rotationpath>) into a unified JSON
        // structure that the frontend can more easily handle.
        if (p.getType() == RotationPath::InterpType::INTERP_CONSTANT)
        {
            // A constant-rate rotation path corresponds to the <fixedrotation> XML element.
            // The start and rate values are converted to compass degrees per second.
            // No normalization is applied to preserve negative start angles.
            const RealType start_az_deg = 90.0 - p.getStart().azimuth * 180.0 / PI;
            const RealType start_el_deg = p.getStart().elevation * 180.0 / PI;
            const RealType rate_az_deg_s = -p.getRate().azimuth * 180.0 / PI; // Invert for CW rate
            const RealType rate_el_deg_s = p.getRate().elevation * 180.0 / PI;
            j["startazimuth"] = start_az_deg;
            j["startelevation"] = start_el_deg;
            j["azimuthrate"] = rate_az_deg_s;
            j["elevationrate"] = rate_el_deg_s;
        }
        else
        {
            j["rotationwaypoints"] = p.getCoords();
        }
    }

References math::RotationPath::INTERP_CONSTANT, math::RotationPath::INTERP_CUBIC, math::RotationPath::INTERP_LINEAR, and math::RotationPath::INTERP_STATIC.

◆ operator*() [1/6]

Coord math::operator*	(	const Coord &	a,
		const Coord &	b
	)

noexcept

Multiplies two Coord objects' positions and copies the time.

Definition at line 51 of file coord.h.

51{ return {a.pos * b.pos, a.t}; }

math::Coord::t

RealType t

Time.

Definition coord.h:26

math::Coord::pos

Vec3 pos

3D position

Definition coord.h:25

References math::Coord::pos.

◆ operator*() [2/6]

Coord math::operator*	(	const Coord &	a,
		const RealType	b
	)

noexcept

Multiplies a Coord's position by a scalar while copying the time.

Definition at line 61 of file coord.h.

61{ return {a.pos * b, a.t}; }

References math::Coord::pos.

◆ operator*() [3/6]

RotationCoord math::operator*	(	const RotationCoord &	a,
		const RealType	b
	)

noexcept

Multiplies a RotationCoord's components by a scalar while copying the time.

Definition at line 148 of file coord.h.

    {
        return {a.azimuth * b, a.elevation * b, a.t};
    }

References math::Coord::t.

◆ operator*() [4/6]

RotationCoord math::operator*	(	const RotationCoord &	a,
		const RotationCoord &	b
	)

noexcept

Multiplies two RotationCoord objects' components and copies the time.

Definition at line 118 of file coord.h.

    {
        return {a.azimuth * b.azimuth, a.elevation * b.elevation, a.t};
    }

References math::Coord::t.

◆ operator*() [5/6]

Vec3 math::operator*	(	const Vec3 &	a,
		const RealType	b
	)

noexcept

Multiplies a Vec3 vector by a scalar value.

Definition at line 229 of file geometry_ops.h.

229{ return {a.x * b, a.y * b, a.z * b}; }

◆ operator*() [6/6]

Vec3 math::operator*	(	const Vec3 &	a,
		const Vec3 &	b
	)

noexcept

Multiplies two Vec3 vectors component-wise.

Definition at line 217 of file geometry_ops.h.

217{ return {a.x * b.x, a.y * b.y, a.z * b.z}; }

◆ operator+() [1/6]

Coord math::operator+	(	const Coord &	a,
		const Coord &	b
	)

noexcept

Adds two Coord objects' positions and copies the time.

Definition at line 53 of file coord.h.

53{ return {a.pos + b.pos, a.t}; }

References math::Coord::pos.

◆ operator+() [2/6]

Coord math::operator+	(	const Coord &	a,
		const RealType	b
	)

noexcept

Adds a scalar to a Coord's position while copying the time.

Definition at line 59 of file coord.h.

59{ return {a.pos + b, a.t}; }

References math::Coord::pos.

◆ operator+() [3/6]

RotationCoord math::operator+	(	const RotationCoord &	a,
		const RealType	b
	)

noexcept

Adds a scalar to a RotationCoord's components while copying the time.

Definition at line 142 of file coord.h.

    {
        return {a.azimuth + b, a.elevation + b, a.t};
    }

References math::Coord::t.

◆ operator+() [4/6]

RotationCoord math::operator+	(	const RotationCoord &	a,
		const RotationCoord &	b
	)

noexcept

Adds two RotationCoord objects' components and copies the time.

Definition at line 124 of file coord.h.

    {
        return {a.azimuth + b.azimuth, a.elevation + b.elevation, a.t};
    }

References math::Coord::t.

◆ operator+() [5/6]

SVec3 math::operator+	(	const SVec3 &	a,
		const SVec3 &	b
	)

noexcept

Adds two SVec3 vectors.

Definition at line 91 of file geometry_ops.cpp.

    {
        RealType new_azimuth = fmod(a.azimuth + b.azimuth, 2 * PI);
        if (new_azimuth < 0)
        {
            new_azimuth += 2 * PI;
        }
        RealType new_elevation = fmod(a.elevation + b.elevation, PI);
        return {a.length + b.length, new_azimuth, new_elevation};
    }

References PI.

◆ operator+() [6/6]

Vec3 math::operator+	(	const Vec3 &	a,
		const Vec3 &	b
	)

noexcept

Adds two Vec3 vectors component-wise.

Definition at line 220 of file geometry_ops.h.

220{ return {a.x + b.x, a.y + b.y, a.z + b.z}; }

◆ operator-() [1/4]

Coord math::operator-	(	const Coord &	a,
		const Coord &	b
	)

noexcept

Subtracts two Coord objects' positions and copies the time.

Definition at line 55 of file coord.h.

55{ return {a.pos - b.pos, a.t}; }

References math::Coord::pos.

◆ operator-() [2/4]

RotationCoord math::operator-	(	const RotationCoord &	a,
		const RotationCoord &	b
	)

noexcept

Subtracts two RotationCoord objects' components and copies the time.

Definition at line 130 of file coord.h.

    {
        return {a.azimuth - b.azimuth, a.elevation - b.elevation, a.t};
    }

References math::Coord::t.

◆ operator-() [3/4]

SVec3 math::operator-	(	const SVec3 &	a,
		const SVec3 &	b
	)

noexcept

Subtracts two SVec3 vectors.

Definition at line 102 of file geometry_ops.cpp.

    {
        RealType new_azimuth = a.azimuth - b.azimuth;
 
        // Wrap the azimuth to the range [-PI, PI] to find the shortest angle
        // TODO: Has to be a better way to do this...
        while (new_azimuth <= -PI)
            new_azimuth += 2 * PI;
        while (new_azimuth > PI)
            new_azimuth -= 2 * PI;
 
        // Elevation difference is typically simpler and doesn't need wrapping
        // unless 180 degree elevation sweeps are expected.
        RealType new_elevation = fmod(a.elevation - b.elevation, PI);
        return {a.length - b.length, new_azimuth, new_elevation};
    }

References PI.

◆ operator-() [4/4]

Vec3 math::operator-	(	const Vec3 &	a,
		const Vec3 &	b
	)

noexcept

Subtracts two Vec3 vectors component-wise.

Definition at line 223 of file geometry_ops.h.

223{ return {a.x - b.x, a.y - b.y, a.z - b.z}; }

◆ operator/() [1/9]

Coord math::operator/	(	const Coord &	a,
		const Coord &	b
	)

noexcept

Divides two Coord objects' positions and copies the time.

Definition at line 57 of file coord.h.

57{ return {a.pos / b.pos, a.t}; }

References math::Coord::pos.

◆ operator/() [2/9]

Coord math::operator/	(	const Coord &	b,
		const RealType	a
	)

noexcept

Divides a Coord's position by a scalar while copying the time.

Definition at line 65 of file coord.h.

65{ return {b.pos / a, b.t}; }

References math::Coord::pos.

◆ operator/() [3/9]

Coord math::operator/	(	const RealType	a,
		const Coord &	b
	)

noexcept

Divides a scalar by a Coord's position and copies the time.

Definition at line 63 of file coord.h.

63{ return {a / b.pos, b.t}; }

References math::Coord::pos.

◆ operator/() [4/9]

RotationCoord math::operator/	(	const RealType	a,
		const RotationCoord &	b
	)

noexcept

Divides a scalar by a RotationCoord's components and copies the time.

Definition at line 154 of file coord.h.

    {
        return {a / b.azimuth, a / b.elevation, b.t};
    }

References math::Coord::t.

◆ operator/() [5/9]

Vec3 math::operator/	(	const RealType	a,
		const Vec3 &	b
	)

noexcept

Divides a scalar value by a Vec3 vector.

Definition at line 235 of file geometry_ops.h.

235{ return {a / b.x, a / b.y, a / b.z}; }

◆ operator/() [6/9]

RotationCoord math::operator/	(	const RotationCoord &	a,
		const RotationCoord &	b
	)

noexcept

Divides two RotationCoord objects' components and copies the time.

Definition at line 136 of file coord.h.

    {
        return {a.azimuth / b.azimuth, a.elevation / b.elevation, a.t};
    }

References math::Coord::t.

◆ operator/() [7/9]

RotationCoord math::operator/	(	const RotationCoord &	b,
		const RealType	a
	)

noexcept

Divides a RotationCoord's components by a scalar while copying the time.

Definition at line 160 of file coord.h.

    {
        return {b.azimuth / a, b.elevation / a, b.t};
    }

References math::Coord::t.

◆ operator/() [8/9]

Vec3 math::operator/	(	const Vec3 &	a,
		const RealType	b
	)

noexcept

Divides a Vec3 vector by a scalar value.

Definition at line 232 of file geometry_ops.h.

232{ return {a.x / b, a.y / b, a.z / b}; }

◆ operator/() [9/9]

Vec3 math::operator/	(	const Vec3 &	a,
		const Vec3 &	b
	)

Divides two Vec3 vectors component-wise.

Definition at line 226 of file geometry_ops.h.

226{ return {a.x / b.x, a.y / b.y, a.z / b.z}; }

References math::Vec3::x, math::Vec3::y, and math::Vec3::z.

◆ to_json() [1/3]

void math::to_json	(	nlohmann::json &	j,
		const Coord &	c
	)

Definition at line 50 of file json_serializer.cpp.

    {
        j = {{"time", c.t}, {"x", c.pos.x}, {"y", c.pos.y}, {"altitude", c.pos.z}};
    }

◆ to_json() [2/3]

void math::to_json	(	nlohmann::json &	j,
		const RotationCoord &	rc
	)

Definition at line 63 of file json_serializer.cpp.

    {
        // The internal engine uses mathematical angles (radians, CCW from East),
        // but the UI and XML format use compass degrees (CW from North).
        // We intentionally DO NOT normalize the output (no fmod) to preserve
        // negative angles or multi-turn rotations (winding) defined by the user.
        const RealType az_deg = 90.0 - rc.azimuth * 180.0 / PI;
        const RealType el_deg = rc.elevation * 180.0 / PI;
        j = {{"time", rc.t}, {"azimuth", az_deg}, {"elevation", el_deg}};
    }

References math::RotationCoord::azimuth, math::RotationCoord::elevation, PI, and math::RotationCoord::t.

◆ to_json() [3/3]

void math::to_json	(	nlohmann::json &	j,
		const Vec3 &	v
	)

Definition at line 41 of file json_serializer.cpp.

41{ j = {{"x", v.x}, {"y", v.y}, {"z", v.z}}; }

References math::Vec3::x, math::Vec3::y, and math::Vec3::z.

Classes

Functions

Function Documentation

◆ dotProduct()

◆ from_json() [1/5]

◆ from_json() [2/5]

◆ from_json() [3/5]

◆ from_json() [4/5]

◆ from_json() [5/5]

◆ NLOHMANN_JSON_SERIALIZE_ENUM() [1/2]

◆ NLOHMANN_JSON_SERIALIZE_ENUM() [2/2]

◆ operator*() [1/6]

◆ operator*() [2/6]

◆ operator*() [3/6]

◆ operator*() [4/6]

◆ operator*() [5/6]

◆ operator*() [6/6]

◆ operator+() [1/6]

◆ operator+() [2/6]

◆ operator+() [3/6]

◆ operator+() [4/6]

◆ operator+() [5/6]

◆ operator+() [6/6]

◆ operator-() [1/4]

◆ operator-() [2/4]

◆ operator-() [3/4]

◆ operator-() [4/4]

◆ operator/() [1/9]

◆ operator/() [2/9]

◆ operator/() [3/9]

◆ operator/() [4/9]

◆ operator/() [5/9]

◆ operator/() [6/9]

◆ operator/() [7/9]

◆ operator/() [8/9]

◆ operator/() [9/9]

◆ to_json() [1/3]

◆ to_json() [2/3]

◆ to_json() [3/3]