PlottingInterface.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2020 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef IGNITION_GUI_PLOTTINGINTERFACE_HH_
#define IGNITION_GUI_PLOTTINGINTERFACE_HH_

#include <QObject>
#include <QString>
#include <QMap>
#include <QVariant>
#ifdef _MSC_VER
#pragma warning(push, 0)
#endif
#include <google/protobuf/message.h>
#include <google/protobuf/descriptor.h>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#include <map>
#include <set>
#include <string>
#include <memory>
#include <limits>

#include "ignition/gui/Export.hh"

namespace ignition
{
namespace gui
{
class PlotDataPrivate;

class IGNITION_GUI_VISIBLE PlotData
{
  public: PlotData();

  public: ~PlotData();

  public: void SetValue(const double _value);

  public: double Value() const;

  public: void SetTime(const double _time);

  public: double Time() const;

  public: void AddChart(int _chart);

  public: void RemoveChart(int _chart);

  public: int ChartCount() const;

  public: std::set<int> &Charts();

  private: std::unique_ptr<PlotDataPrivate> dataPtr;
};

class TopicPrivate;

class IGNITION_GUI_VISIBLE Topic : public QObject
{
  Q_OBJECT

  public: explicit Topic(const std::string &_name);

  public: ~Topic();

  public: std::string &Name() const;

  public: void Register(const std::string &_fieldPath, int _chart);

  public: void UnRegister(const std::string &_fieldPath, int _chart);

  public: int FieldCount() const;

  public: std::map<std::string, PlotData *> &Fields();

  public: void Callback(const google::protobuf::Message &_msg);

  public: bool HasHeader(const google::protobuf::Message &_msg,
                         double &_headerTime);

  public: void UpdateGui(const std::string &_field);

  signals: void plot(int _chart, QString _fieldID, double _x, double _y);

  public: void SetPlottingTimeRef(const std::shared_ptr<double> &_time);

  private: std::unique_ptr<TopicPrivate> dataPtr;
};

class TransportPrivate;

class IGNITION_GUI_VISIBLE Transport : public QObject
{
  Q_OBJECT

  public: Transport();

  public: ~Transport();

  public: void Unsubscribe(const std::string &_topic,
                           const std::string &_fieldPath,
                           int _chart);

  public: void Subscribe(const std::string &_topic,
                         const std::string &_fieldPath,
                         int _chart, const std::shared_ptr<double> &_time);

  public slots: void UnsubscribeOutdatedTopics();

  public: const std::map<std::string, Topic*> &Topics();

  public slots: void onPlot(int _chart, QString _fieldID, double _x, double _y);

  signals: void plot(int _chart, QString _fieldID, double _x, double _y);

  private: std::unique_ptr<TransportPrivate> dataPtr;
};

class PlottingIfacePrivate;

class IGNITION_GUI_VISIBLE PlottingInterface : public QObject
{
  Q_OBJECT

  public: explicit PlottingInterface();

  public: ~PlottingInterface();

  public slots: void subscribe(int _chart,
                               QString _fieldPath,
                               QString _topic);

  public slots: void unsubscribe(int _chart,
                                 QString _fieldPath,
                                 QString _topic);

  public: float Timeout() const;

  public slots: void onPlot(int _chart, QString _fieldID, double _x, double _y);

  signals: void plot(int _chart, QString _fieldID, double _x, double _y);

  public slots: void onComponentSubscribe(QString _entity,
                                          QString _typeId,
                                          QString _type,
                                          QString _attribute,
                                          int _chart);

  public slots: void onComponentUnSubscribe(QString _entity,
                                            QString _typeId,
                                            QString _attribute,
                                            int _chart);

  signals: void ComponentSubscribe(uint64_t _entity,
                                   uint64_t _typeId,
                                   const std::string &_type,
                                   const std::string &_attribute,
                                   int _chart);

  signals: void ComponentUnSubscribe(uint64_t _entity,
                                     uint64_t _typeId,
                                     const std::string &_attribute,
                                     int _chart);

  public slots: std::string FilePath(QString _path, std::string _name,
                                     std::string _extention);

  public slots: bool exportCSV(QString _path, int _chart,
                               QMap< QString, QVariant> _serieses);

  signals: std::string ComponentName(uint64_t _typeId);

  public: void InitTimer();

  public slots: void UpdateTime();

  private: std::unique_ptr<PlottingIfacePrivate> dataPtr;
};

}
}

#endif