Sonar.hpp

Go to the documentation of this file.

#ifndef __BASE_SAMPLES_SONAR_HPP__
#define __BASE_SAMPLES_SONAR_HPP__

#include <vector>
#include <base/Float.hpp>
#include <base/Time.hpp>
#include <base/Angle.hpp>
#include <base/Deprecated.hpp>
BASE_TYPES_DEPRECATED_SUPPRESS_START
#include <base/samples/SonarBeam.hpp>
#include <base/samples/SonarScan.hpp>
BASE_TYPES_DEPRECATED_SUPPRESS_STOP

namespace base { namespace samples {

struct Sonar
{
public:
    base::Time time;

    std::vector<base::Time> timestamps;
    
    base::Time bin_duration;
    
    base::Angle beam_width;
    
    base::Angle beam_height;

    std::vector<base::Angle> bearings;

    float speed_of_sound;
    
    uint32_t bin_count;
    
    uint32_t beam_count;

    std::vector<float> bins;

    static float getSpeedOfSoundInWater() { return 1497.0; }

    Sonar()
        : speed_of_sound(getSpeedOfSoundInWater())
        , bin_count(0)
        , beam_count(0) {}

    Sonar(base::Time time, base::Time bin_duration, int bin_count, base::Angle beam_width, base::Angle beam_height)
        : time(time)
        , bin_duration(bin_duration)
        , beam_width(beam_width)
        , beam_height(beam_height)
        , speed_of_sound(getSpeedOfSoundInWater())
        , bin_count(bin_count)
        , beam_count(0)
    {
    }

    Sonar(base::Time time, base::Time bin_duration, int bin_count, base::Angle beam_width, base::Angle beam_height,
            int beam_count, bool per_beam_timestamps)
        : time(time)
        , bin_duration(bin_duration)
        , beam_width(beam_width)
        , beam_height(beam_height)
        , speed_of_sound(getSpeedOfSoundInWater())
        , bin_count(bin_count)
        , beam_count(beam_count)
    {
        resize(bin_count, beam_count, per_beam_timestamps);
    }

    void resize(int bin_count, int beam_count, bool per_beam_timestamps);

    static Sonar fromSingleBeam(base::Time time, base::Time bin_duration, base::Angle beam_width, base::Angle beam_height,
            std::vector<float> const& bins, base::Angle bearing = base::Angle(),
            float speed_of_sound = getSpeedOfSoundInWater());

    base::Time getBinRelativeStartTime(unsigned int bin_idx) const;

    base::Time getBeamAcquisitionStartTime(unsigned int beam) const;

    base::Time getBinTime(unsigned int bin, unsigned int beam) const;

    float getBinStartDistance(unsigned int bin) const;

    void setRegularBeamBearings(base::Angle start, base::Angle interval);

    void pushBeam(std::vector<float> const& bins);

    void pushBeam(std::vector<float> const& bins, base::Angle bearing);

    void pushBeam(base::Time const& beam_time, std::vector<float> const& beam_bins);


    void pushBeam(base::Time const& beam_time, std::vector<float> const& beam_bins, base::Angle bearing);

    void pushBeamBins(std::vector<float> const& beam_bins);

    void setBeam(unsigned int beam, std::vector<float> const& bins);

    void setBeam(unsigned int beam, std::vector<float> const& bins, base::Angle bearing);

    void setBeam(unsigned int beam, base::Time const& beam_time, std::vector<float> const& beam_bins);

    void setBeam(unsigned int beam, base::Time const& beam_time, std::vector<float> const& beam_bins, base::Angle bearing);

    void setBeamBins(int beam, std::vector<float> const& beam_bins);

    base::Angle getBeamBearing(unsigned int beam) const;

    std::vector<float> getBeamBins(unsigned int beam) const;

    void getBeamBins(unsigned int beam, std::vector<float>& beam_bins) const;

    Sonar getBeam(unsigned int beam) const;

    void validate();

BASE_TYPES_DEPRECATED_SUPPRESS_START
    explicit Sonar(SonarScan const& old, float gain = 1);

    explicit Sonar(SonarBeam const& old, float gain = 1);

    base::samples::SonarBeam toSonarBeam(float gain = 1);

    base::samples::SonarScan toSonarScan(float gain = 1);
BASE_TYPES_DEPRECATED_SUPPRESS_STOP
};

}} // namespaces

#endif