gz/gui/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 GZ_GUI_PLOTTINGINTERFACE_HH_
#define GZ_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 "gz/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