serial::rotation_warning_utils Namespace Reference

Classes
struct	InferenceResult

Enumerations
enum class	ValueKind { Angle , Rate }
enum class	Confidence { None , Low , Medium , High }
enum class	WarningSensitivity { HighConfidence , MediumOrHigh , Aggressive }

Functions
InferenceResult	infer_unit_from_value (const RealType value, const ValueKind kind) noexcept
bool	should_warn (const Confidence confidence, const WarningSensitivity sensitivity) noexcept
void	clear_captured_warnings () noexcept
std::vector< std::string >	take_captured_warnings ()
void	maybe_warn_about_rotation_value (const RealType value, const params::RotationAngleUnit declared_unit, const ValueKind kind, const std::string_view source, const std::string_view owner, const std::string_view field)

Variables
constexpr WarningSensitivity	kWarningSensitivity = WarningSensitivity::MediumOrHigh

Enumeration Type Documentation

Confidence

enum class serial::rotation_warning_utils::Confidence

strong

Enumerator
None
Low
Medium
High

Definition at line 24 of file rotation_warning_utils.h.

    {
        None,
        Low,
        Medium,
        High
    };

ValueKind

enum class serial::rotation_warning_utils::ValueKind

strong

Enumerator
Angle
Rate

Definition at line 18 of file rotation_warning_utils.h.

    {
        Angle,
        Rate
    };

WarningSensitivity

enum class serial::rotation_warning_utils::WarningSensitivity

strong

Enumerator
HighConfidence
MediumOrHigh
Aggressive

Definition at line 32 of file rotation_warning_utils.h.

    {
        HighConfidence,
        MediumOrHigh,
        Aggressive
    };

Function Documentation

clear_captured_warnings()

void serial::rotation_warning_utils::clear_captured_warnings ( )

noexcept

Definition at line 260 of file rotation_warning_utils.cpp.

{ captured_warnings.clear(); }

Referenced by begin_warning_capture(), discard_warning_capture(), and fers_get_interpolated_rotation_path().

Here is the caller graph for this function:

infer_unit_from_value()

InferenceResult serial::rotation_warning_utils::infer_unit_from_value ( const RealType  value, const ValueKind  kind  )

noexcept

Definition at line 139 of file rotation_warning_utils.cpp.

    {
        const RealType abs_value = std::abs(value);
        const RealType pi = std::numbers::pi_v<RealType>;
        const RealType two_pi = 2.0 * pi;
 
        InferenceResult result;
        if (abs_value <= kEpsilon)
        {
            return result;
        }
 
        if (abs_value > 360.0)
        {
            result.degree_score += 8;
        }
        else if (abs_value > 180.0)
        {
            result.degree_score += 7;
        }
        else if (abs_value > two_pi)
        {
            result.degree_score += abs_value < 10.0 ? 3 : 6;
        }
        else if (abs_value > pi)
        {
            result.degree_score += 2;
        }
 
        const bool degree_famous = matches_common_angle(abs_value, common_degree_angles);
        const bool radian_famous = matches_common_angle(abs_value, common_radian_angles);
        if (degree_famous && !radian_famous)
        {
            result.degree_score += 3;
        }
        else if (radian_famous && !degree_famous)
        {
            result.radian_score += 3;
        }
 
        if (is_near_integer(abs_value))
        {
            const RealType rounded = std::round(abs_value);
            if ((std::fmod(rounded, 45.0) == 0.0) || (std::fmod(rounded, 30.0) == 0.0) ||
                (std::fmod(rounded, 15.0) == 0.0) || (std::fmod(rounded, 10.0) == 0.0) ||
                (std::fmod(rounded, 5.0) == 0.0))
            {
                result.degree_score += 2;
            }
            else
            {
                result.degree_score += 1;
            }
        }
        else if ((abs_value <= two_pi + 1.0) && !is_near_tenth(abs_value))
        {
            result.radian_score += 1;
        }
 
        if (matches_simple_pi_ratio(abs_value))
        {
            result.radian_score += 3;
        }
 
        if ((kind == ValueKind::Angle) && (abs_value <= two_pi + 0.5) &&
            (std::abs(result.degree_score - result.radian_score) <= 1))
        {
            const RealType degree_distance = best_clean_trig_distance(value * pi / 180.0);
            const RealType radian_distance = best_clean_trig_distance(value);
            if (degree_distance + 1e-4 < radian_distance)
            {
                ++result.degree_score;
            }
            else if (radian_distance + 1e-4 < degree_distance)
            {
                ++result.radian_score;
            }
        }
 
        if (result.degree_score == result.radian_score)
        {
            result.confidence = Confidence::None;
            return result;
        }
 
        result.inferred_unit = result.degree_score > result.radian_score ? params::RotationAngleUnit::Degrees
                                                                         : params::RotationAngleUnit::Radians;
        const int lead = std::abs(result.degree_score - result.radian_score);
        const int max_score = std::max(result.degree_score, result.radian_score);
 
        if ((lead >= 5) || ((max_score >= 7) && (lead >= 3)))
        {
            result.confidence = Confidence::High;
        }
        else if ((lead >= 3) || ((max_score >= 5) && (lead >= 2)))
        {
            result.confidence = Confidence::Medium;
        }
        else if ((lead >= 2) || (max_score >= 4))
        {
            result.confidence = Confidence::Low;
        }
 
        return result;
    }

References Angle, serial::rotation_warning_utils::InferenceResult::confidence, serial::rotation_warning_utils::InferenceResult::degree_score, params::Degrees, High, serial::rotation_warning_utils::InferenceResult::inferred_unit, Low, Medium, None, serial::rotation_warning_utils::InferenceResult::radian_score, and params::Radians.

Referenced by maybe_warn_about_rotation_value().

Here is the caller graph for this function:

maybe_warn_about_rotation_value()

void serial::rotation_warning_utils::maybe_warn_about_rotation_value	(	const RealType	value,
		const params::RotationAngleUnit	declared_unit,
		const ValueKind	kind,
		const std::string_view	source,
		const std::string_view	owner,
		const std::string_view	field
	)

Definition at line 269 of file rotation_warning_utils.cpp.

    {
        const InferenceResult inference = infer_unit_from_value(value, kind);
        if ((inference.inferred_unit == declared_unit) || !should_warn(inference.confidence, kWarningSensitivity))
        {
            return;
        }
 
        const std::string message =
            std::format("{} rotation {} '{}' looks like {} but '{}' was declared (confidence: {}, value: {}). "
                        "Change rotationangleunit or convert existing values.",
                        source, owner, field, unit_token(inference.inferred_unit), unit_token(declared_unit),
                        confidence_token(inference.confidence), value);
 
        if (std::ranges::find(captured_warnings, message) == captured_warnings.end())
        {
            captured_warnings.push_back(message);
        }
 
        LOG(logging::Level::WARNING, "{}", message);
    }

References serial::rotation_warning_utils::InferenceResult::confidence, infer_unit_from_value(), serial::rotation_warning_utils::InferenceResult::inferred_unit, kWarningSensitivity, LOG, should_warn(), and logging::WARNING.

Referenced by fers_get_interpolated_rotation_path(), serial::xml_parser_utils::parseFixedRotation(), serial::xml_parser_utils::parseRotationPath(), and serial::update_platform_paths_from_json().

Here is the call graph for this function:

Here is the caller graph for this function:

should_warn()

bool serial::rotation_warning_utils::should_warn ( const Confidence  confidence, const WarningSensitivity  sensitivity  )

noexcept

Definition at line 245 of file rotation_warning_utils.cpp.

    {
        switch (sensitivity)
        {
        case WarningSensitivity::HighConfidence:
            return confidence == Confidence::High;
        case WarningSensitivity::MediumOrHigh:
            return (confidence == Confidence::Medium) || (confidence == Confidence::High);
        case WarningSensitivity::Aggressive:
            return confidence != Confidence::None;
        default:
            return false;
        }
    }

References Aggressive, High, HighConfidence, Medium, MediumOrHigh, and None.

Referenced by maybe_warn_about_rotation_value().

Here is the caller graph for this function:

take_captured_warnings()

std::vector< std::string > serial::rotation_warning_utils::take_captured_warnings

(

)

Definition at line 262 of file rotation_warning_utils.cpp.

    {
        std::vector<std::string> warnings = std::move(captured_warnings);
        captured_warnings.clear();
        return warnings;
    }

Referenced by complete_warning_capture().

Here is the caller graph for this function:

Variable Documentation

kWarningSensitivity

constexpr WarningSensitivity serial::rotation_warning_utils::kWarningSensitivity = WarningSensitivity::MediumOrHigh

constexpr

Definition at line 47 of file rotation_warning_utils.h.

Referenced by maybe_warn_about_rotation_value().