calibrator.h

Go to the documentation of this file.

#pragma once

#include <GRT/GRT.h>
#include <set>
#include <string>

class CalibrateResult {
  public:
    enum Result {
        SUCCESS,
        WARNING,
        FAILURE,
    };

    CalibrateResult(Result result);
    CalibrateResult(Result result, string message);

    Result getResult() const { return result_; }
    string getResultString() const { return result_strings_[result_]; }
    string getMessage() const { return result_message_; }

  private:
    static const char *result_strings_[3];

    Result result_;
    string result_message_;

    static const string kDefaultSuccessMessage;
    static const string kDefaultWarningMessage;
    static const string kDefaultFailureMessage;
};

class CalibrateProcess {
  public:
    typedef CalibrateResult (*CalibratorCallback)(const GRT::MatrixDouble&);

    CalibrateProcess(std::string name, std::string description,
                     CalibratorCallback cb)
            : name_(name), description_(description), cb_(cb),
            is_calibrated_(false) {}

    CalibrateResult calibrate(GRT::MatrixDouble data) {
        CalibrateResult result = cb_(data);
        if (result.getResult() != CalibrateResult::FAILURE) {
            // Only failure is considered as not calibrated.
            is_calibrated_ = true;
            setData(data);
        }
        return result;
    }
    void clear() { data_.clear(); is_calibrated_ = false; }
    bool isCalibrated() const { return is_calibrated_; }

    std::string getName() const { return name_; }
    std::string getDescription() const { return description_; }

    void setData(GRT::MatrixDouble data) { data_ = data; }
    GRT::MatrixDouble getData() { return data_; }
  private:
    std::string name_;
    std::string description_;
    CalibratorCallback cb_;
    bool is_calibrated_;
    GRT::MatrixDouble data_;
};

class Calibrator {
  public:
    using SimpleCalibrateFunc = std::function<double(double)>;

    using CalibrateFunc = std::function<vector<double>(vector<double>)>;

    Calibrator() : simple_calibrate_func_(nullptr), calibrate_func_(nullptr) {}

    Calibrator(SimpleCalibrateFunc f)
            : simple_calibrate_func_(f), calibrate_func_(nullptr) {}
    Calibrator(CalibrateFunc f)
            : simple_calibrate_func_(nullptr), calibrate_func_(f) {}

    Calibrator& setCalibrateFunction(CalibrateFunc f);

    Calibrator& setCalibrateFunction(SimpleCalibrateFunc f);
    Calibrator& addCalibrateProcess(CalibrateProcess cp);

    Calibrator& addCalibrateProcess(const string& name,
                                    const string& description,
                                    const CalibrateProcess::CalibratorCallback cb);
    vector<CalibrateProcess>& getCalibrateProcesses() {
        return calibrate_processes_;
    }

    vector<double> calibrate(vector<double> input);


    bool isCalibrated();

  private:
    void registerCalibrateProcess(const CalibrateProcess& cp);

    bool isCalibrateProcessRegistered(const CalibrateProcess& cp);

    SimpleCalibrateFunc simple_calibrate_func_;
    CalibrateFunc calibrate_func_;
    vector<CalibrateProcess> calibrate_processes_;
    std::set<std::string> registered_;
};