Cppcheck report - [project name]: kooling/component/segmenter/v1.cpp

#include <kooling/component/segmenter/interface.h>
#include <kooling/datamodel/distance.h>
#include <kooling/datamodel/segment.h>
#include <kooling/datamodel/sensor.h>
#include <kooling/datamodel/speed.h>
#include <kooling/datamodel/timestamp.h>
#include <kooling/geo/algorithm.h>
#include <kooling/geo/constants.h>
#include <kooling/geo/coordinate.h>
#include <kooling/system/random.h>

#include <plog/Log.h>

#include <algorithm>
#include <limits>
#include <utility>

#include <boost/range/numeric.hpp>
#include <boost/range/adaptor/transformed.hpp>

namespace kooling::component::segmenter {

using coordinate_t        = kooling::geo::coordinate;
using distance_t          = kooling::datamodel::distance;
using duration_t          = kooling::datamodel::duration;
using fingerprint_t       = kooling::datamodel::fingerprint;
using motion_type_t       = kooling::datamodel::motion_type;
using sensor_data_t       = kooling::datamodel::sensor_data;
using sensor_data_point_t = kooling::datamodel::sensor_data_point;
using segment_t           = kooling::datamodel::segment;
using segments_t          = kooling::datamodel::segments;
using timestamp_t         = kooling::datamodel::timestamp;
using user_t              = kooling::datamodel::user;
using speed_t             = kooling::datamodel::speed;

struct validity
{
    validity(const json_t& config)
<--- Struct 'validity' has a constructor with 1 argument that is not explicit. [+]
Struct 'validity' has a constructor with 1 argument that is not explicit. Such, so called "Converting constructors", should in general be explicit for type safety reasons as that prevents unintended implicit conversions.
        : d_min_extent  { distance_t::from_m(config["min_extent_m"]) }
        , d_min_distance{ distance_t::from_km(config["min_distance_km"]) }
        , d_min_speed   { speed_t::from_kmh(config["min_speed_kmh"]) }
    {}

    bool check(const segment_t& segment) const
    {
        return (is_valid_distance(segment) || is_valid_speed(segment)) && is_valid_extent(segment);
    }

private:
    bool is_valid_distance(const segment_t& segment) const
    {
        return segment.integrated.distance >= d_min_distance;
    }

    bool is_valid_speed(const segment_t& segment) const
    {
        return segment.integrated.speed >= d_min_speed;
    }

    bool is_valid_extent(const segment_t& segment) const
    {
        using namespace boost::adaptors;
        const auto centroid{ kooling::geo::centroid(
            kooling::geo::make_bounding_box(
                segment.range | transformed([](const auto& dp) { return dp.coord; }))) };

        return std::any_of(
            segment.begin, segment.end,
            [&centroid, &min_extent=d_min_extent]
            (const sensor_data_point_t& dp)
            {
                return kooling::geo::distance(centroid, dp.coord) >= min_extent;
            });
    }

private:
    const distance_t d_min_extent;
    const distance_t d_min_distance;
    const speed_t    d_min_speed;
};

class v1 : public interface
{
    struct ctor_tag {};

public:
    explicit v1(ctor_tag, const json_t&);

    ~v1() override = default;

    static interface::pointer_type create(const json_t& config)
    {
        return std::make_unique<v1>(ctor_tag{}, config);
    }

    static std::string name()
    {
        return "v1";
    }

    void run(kooling::datamodel::user, kooling::datamodel::fingerprint, kooling::datamodel::sensor_data) override;

private:
    void cleanup(sensor_data_t&) const;
    std::pair<timestamp_t, segments_t> segment(const sensor_data_t&) const;<--- Shadowed declaration
    bool none_as_walk(const sensor_data_t&, std::size_t) const;
    bool is_fast_walk(const sensor_data_t&, std::size_t) const;
    bool is_cut(const sensor_data_t&, std::size_t, std::size_t) const;

private:
    const struct cleanup
    {
        explicit cleanup(const json_t& config)
            : min_jump_angle{ config["min_jump_angle_deg"] }
            , max_jump_gain{ config["max_jump_gain_ratio"] }
        {}

        const double min_jump_angle;
        const double max_jump_gain;
    } d_cleanup;

    const speed_t d_max_walk_speed;

    const struct cut
    {
        explicit cut(const json_t& config)
            : max_span{ duration_t::from_h(config["max_span_h"]) }
            , max_span_between{ duration_t::from_h(config["max_span_between_h"]) }
            , min_speed_between{ speed_t::from_kmh(config["min_speed_between_kmh"]) }
        {}

        const duration_t max_span;
        const duration_t max_span_between;
        const speed_t    min_speed_between;
    } d_cut;

    const struct walk_like
    {
        explicit walk_like(const json_t& config)
            : max_distance{ distance_t::from_m(config["max_distance_m"]) }
            , min_span{ duration_t::from_h(config["min_span_h"]) }
            , max_speed{ speed_t::from_kmh(config["max_speed_kmh"]) }
        {}

        const distance_t max_distance;
        const duration_t min_span;
        const speed_t    max_speed;

    } d_walk_like;

    const validity d_validity;
};

static bool registered{ factory().register_component<v1>() };

v1::v1(ctor_tag, const json_t& config)
    : d_cleanup  { config["cleanup"] }
    , d_max_walk_speed{ speed_t::from_kmh(config["max_walk_speed_kmh"]) }
    , d_cut      { config["cut"] }
    , d_walk_like{ config["walk_like"] }
    , d_validity { config["validity"] }
{
}

void v1::run(user_t user, fingerprint_t fingerprint, sensor_data_t sensor_data)
{
    const auto nof_dps{ sensor_data.size() };
    cleanup(sensor_data);
    auto [last_timestamp, segments]{ segment(sensor_data) };

    PLOG_DEBUG
        << "Created " << segments.size() << " segments "
           "out of " << nof_dps << " dps "
           "for user: '" << user.user_id << "', "
           "fingerprint: '" << fingerprint << "'";

    d_classifier->run(std::move(user), std::move(fingerprint), std::move(segments), std::move(last_timestamp));
}

bool v1::none_as_walk(const sensor_data_t& sensor_data, std::size_t idx) const
{
    using namespace kooling::datamodel::literals;
    using namespace std::chrono_literals;

    if (idx == 0)
    {
        return false;
    }

    const auto& fst{ sensor_data[idx - 1] };
    const auto& snd{ sensor_data[idx] };

    return
        is_none(fst.motion_type) && is_none(snd.motion_type) &&
        fst.speed < d_walk_like.max_speed && snd.speed < d_walk_like.max_speed &&
        kooling::geo::distance(fst.coord, snd.coord) < d_walk_like.max_distance &&
        snd.timestamp - fst.timestamp > d_walk_like.min_span;
}

bool v1::is_fast_walk(const sensor_data_t& sensor_data, std::size_t idx) const
{
    if (idx == 0)
    {
        return false;
    }

    const auto& fst{ sensor_data[idx - 1] };
    const auto& snd{ sensor_data[idx] };

    return
        is_walking(snd.motion_type) &&
        kooling::geo::distance(fst.coord, snd.coord) / (snd.timestamp - fst.timestamp) > d_max_walk_speed;
}

bool v1::is_cut(const sensor_data_t& sensor_data, std::size_t size, std::size_t idx) const
{
    if (idx == 0)
    {
        return false;
    }

    if (idx == size - 1)
    {
        const auto span{ timestamp_t::now() - sensor_data[idx].timestamp };
        if (span > d_cut.max_span)
        {
            return true;
        }
    }

    const auto& fst{ sensor_data[idx - 1] };
    const auto& snd{ sensor_data[idx] };
    const auto span{ snd.timestamp - fst.timestamp };
    if (span > d_cut.max_span)
    {
        return true;
    }

    const auto speed{ kooling::geo::distance(fst.coord, snd.coord) / span };
    return span > d_cut.max_span_between && speed < d_cut.min_speed_between;
}

void v1::cleanup(sensor_data_t& sensor_data) const
{
    if (sensor_data.size() < 3)
    {
        return;
    }

    size_t nof_duplicated{};
    size_t nof_extreme{};
    double max_gain{ std::numeric_limits<double>::min() };
    double min_angle{ std::numeric_limits<double>::max() };

    for (size_t i{ 1 }; i < sensor_data.size() - 1;)
    {
        const auto& prev{ sensor_data[i - 1] };
        const auto& curr{ sensor_data[i    ] };
        const auto& next{ sensor_data[i + 1] };

        if (prev.timestamp == curr.timestamp)
        {
            ++nof_duplicated;
            sensor_data.erase(std::next(sensor_data.begin(), i));
            continue;
        }

        const auto tot_distance{
            kooling::geo::distance(prev.coord, curr.coord) +
            kooling::geo::distance(curr.coord, next.coord) };
        const auto jump_distance{
            kooling::geo::distance(prev.coord, next.coord) };
        const auto jump_gain{ jump_distance.m() > 0.001 ? tot_distance.m() / jump_distance.m() : 1000 * d_cleanup.max_jump_gain };

        if (jump_gain > d_cleanup.max_jump_gain)
        {
            const auto angle_prev{ std::atan2(prev.coord.lat() - curr.coord.lat(), prev.coord.lon() - curr.coord.lon()) };
            const auto angle_next{ std::atan2(next.coord.lat() - curr.coord.lat(), next.coord.lon() - curr.coord.lon()) };
            const auto angle{ std::abs(angle_next - angle_prev) };
            const auto jump_angle{ kooling::geo::rad2deg(std::min(angle, kooling::geo::k_tau - angle)) };

            if (jump_angle < d_cleanup.min_jump_angle)
            {
                max_gain = std::max(max_gain, jump_gain);
                min_angle = std::min(min_angle, jump_angle);
                ++nof_extreme;

                sensor_data.erase(std::next(sensor_data.begin(), i));
                continue;
            }
        }

        ++i;
    }

    if (nof_duplicated != 0 || nof_extreme != 0)
    {
        PLOG_DEBUG
            << "Erased " << nof_duplicated << " DPs with duplicated timestamps "
            << "and " << nof_extreme << " DPs with extreme jump gain (max: "
            << max_gain << ") and/or angle (min: " << min_angle << ")";
    }
}

std::pair<timestamp_t, segments_t> v1::segment(const sensor_data_t& sensor_data) const
{
    const auto sensor_data_size{ sensor_data.size() };
    if (sensor_data_size < 3)
    {
        return {};
    }

    timestamp_t last_timestamp;
    segments_t segments;
    bool in_segment{ false };
    size_t first_candidate{ sensor_data_size };
    for (std::size_t idx{ 0 }; idx != sensor_data_size; ++idx)
    {
        const bool walk{ is_walking(sensor_data[idx].motion_type) };
        const bool fast_walk{ is_fast_walk(sensor_data, idx) };
        const bool cut{ is_cut(sensor_data, sensor_data_size, idx) };
        if (!in_segment)
        {
            if (fast_walk && idx > first_candidate)
            {
                in_segment = true;
            }
            else if (walk || none_as_walk(sensor_data, idx))
            {
                first_candidate = idx;
            }
            else if (cut)
            {
                first_candidate = idx;
                in_segment = true;
            }
            else if (idx == first_candidate + 2)
            {
                in_segment = true;
            }
        }
        else if (cut || (walk && !fast_walk))
        {
            auto begin { std::next(sensor_data.begin(), first_candidate) };
            auto end   { std::next(sensor_data.begin(), idx) };

            segment_t segment{ std::move(begin), std::move(end) };<--- Shadow variable<--- Calling std::move(begin)
            const auto valid{ d_validity.check(segment) };

            const auto motion{ is_walking(begin->motion_type) ? std::next(begin)->motion_type : begin->motion_type };<--- Access of moved variable 'begin'.

            PLOG_DEBUG
                << segment.id << ": "
                << (valid ? "Created " : "Skipped ")
                << segment.nof_dps
                << "-dp "
                << "'" << motion._to_string() << "'"
                << " segment: "
                << segment.begin->coord << " @ "
                << segment.begin->timestamp
                << " -> "
                << std::prev(segment.end)->coord << " @ "
                << std::prev(segment.end)->timestamp;

            if (valid)
            {
                segments.push_back(std::move(segment));
            }

            last_timestamp = std::prev(segment.end)->timestamp;

            // we want to consider this DP as the start of the next segment
            first_candidate = idx;
            in_segment = false;
        }
    }

    return { last_timestamp, segments };
}

} // namespace kooling::component::segmenter