terrainProfileWidget.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#if !defined(Q_MOC_RUN)
#include <vrfGuiCommonQt/vrfGuiCommonQt.h>
#include <vrfGuiCore/guiSimObject.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvCore/DtUniqueID.h>

#include <vrvCore/DtDisplayUnitsSettingsManager.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <vrvUtil/DtUnitConverterCollection.h>
#endif

#include <vlpi/entityType.h>

#include <QtGui/QPixmap>
#include <QtWidgets/QWidget>

class QwtPlotPicker;
class QwtPlot;
class QVBoxLayout;
class QwtPlotCurve;
class DtReferenceEllipsoid;
class QLabel;
class QwtPlotMarker;
class QTime;
class QImage;
class DtSimMessage;
class QwtSymbol;

namespace makVrf
{
   class DtTerrainProfileDataProvider;
   class DtTerrainProfileSettingsRecord;
   class DtSymbolTracker;
   class DtTerrainProfileSymbol;

   class DT_DLL_VRFGUICOMMONQT DtTerrainProfileWidget : public QWidget
   {
      Q_OBJECT

   public:
      enum ReplotFlag
      {
         FullReplot = 0x00000001,
         ReplotPoints = 0x00000002,
         UpdateGraphOnly = 0x00000004
      };

      enum LineSampleStyle
      {
         DisplayAllSamplesStraight,
         DisplayAllSamplesFollowCurvature,
         DisplayVerticesOnly
      };

      DtTerrainProfileWidget(makVrv::DtDe& de, QWidget* parent = NULL, const Qt::WindowFlags& flags = 0);

      virtual ~DtTerrainProfileWidget() override;

      virtual void init();

      virtual void setDataProvider(DtTerrainProfileDataProvider*);

      virtual void replot();

      virtual void setSamplingRate(double);
      double samplingRate() const;

      virtual void setMaximumSamplingPoints(int);
      int maximumSamplingPoints() const;

      virtual void setUseBackendForProfile(bool);
      bool useBackendForProfile() const
      {
         return myUseBackendForProfile;
      }

      bool replotting() const
      {
         return myReplotting;
      }

      virtual void clearGraph();

      virtual bool backendCanBeUsedForProfileData() const;

      virtual bool allDataFromFrontEnd() const;

      virtual bool allDataFromBackEnd() const;

      virtual void labelDataForTerrainProfilePosition(const QPointF& pos, const DtVector& geoc, double distanceOnLine, double height, int soilType = 0);

      bool hasVertices() const
      {
         return (myVertices.size() != 0);
      }

      virtual void setReplotTime(int);
      int replotTime() const;

      virtual void setScaleFactor(double);
      double scaleFactor() const;

      virtual void suspend();

      virtual void resume();

      virtual bool isSuspended() const;

      virtual void setShowVertices(bool);
      bool showVertices() const;

      virtual void setShowVertexNumbers(bool);
      bool showVertexNumbers() const;

      virtual void setSuspendForMovement(bool);
      virtual bool suspendForMovement() const;

      virtual void setDistanceMoveTolerance(double);
      virtual double distanceMoveTolerance() const;

      virtual QString dataStatus() const;

      virtual void requestPlotPointsIfNeeded(bool force = false);

      virtual void setLineStyle(LineSampleStyle sampleDisplay, Qt::PenStyle style, unsigned size);

      virtual void setDisplayOnBehalfOf(const std::set<makVrv::DtUniqueID>&);
      const std::set<makVrv::DtUniqueID>& displayOnBehalfOf() const
      {
         return myDisplayOnBehalfOf;
      }

      boost::signals2::signal<void ()> signal_ready;

      boost::signals2::signal<void ()> signal_dataStatusChanged;

      boost::signals2::signal<void (int)> signal_replotted;

   protected:
      virtual void createProfileGraph();

      virtual void initConnections();

      virtual bool updateProfileData();

      virtual void slot_dataUpdated();

      virtual void slot_dataRemoved();

      virtual void calculateReplotRanges(std::vector<QPoint>&) const;

      virtual double calculateLineLength(const std::vector<DtVector>&) const;

      virtual double calculateSegment(const QPoint& segment, double lineLength);

      virtual double segmentLength(const QPoint&) const;
      virtual double segmentLength(int start, int end) const;
      
      virtual double terrainHeight(const DtVector&, int position = -1) const;

      virtual double lineHeight(int pos) const;

      virtual void setupLabels();

      virtual void slot_onUnitChanged(const makVrv::DtUnicode& category, const makVrv::DtUnicode& type, int to, int from);

      virtual double altitudeValueFor(double) const;
      virtual double distanceValueFor(double) const;

      virtual double altitudeFromDisplayValue(double) const;
      virtual double distanceFromDisplayValue(double) const;

      virtual void convertAltitudeAndDistance(int newAltitudeUnits, int newDistanceUnits, bool replot = true);

      virtual void convertAltitudeAndDistance(QVector<QPointF>&, int newAltitudeUnits, int newDistanceUnits) const;
      virtual void convertAltitudeAndDistance(QwtPlotMarker*, int newAltitudeUnits, int newDistanceUnits) const;

      virtual void deferredReplot(int flag = FullReplot);

      virtual QwtPlotMarker* addMarker(double x, double y);

      virtual void setupPointMarkerLabel();

      virtual void onTerrainProfileSettingsChanged(const DtTerrainProfileSettingsRecord&);

      virtual void createSymbolTracker();

      virtual void trackEntity(const DtVector& geocentricPosition, DtSimObjectReference);

      virtual void stopTrackingEntity(makVrv::DtElementID);

      virtual void clearTrackingSymbols(bool suspended = false);

      virtual QwtSymbol* symbolFor(DtSimObjectReference) const;

      virtual int linePositionFromLocation(const DtVector& geocentricLocation, QPointF& result, bool trackedItem = false) const;

      virtual int locationFromPlotPosition(const QPointF& result, DtVector& geocentricLocation) const;

      virtual int closestPoint(const DtVector& v, double& range, double& totalRange, bool trackedItem = false) const;

      virtual void timedReplot();
      virtual void replotIfTime();

      virtual void updateLineVertices(bool replot = true);

      virtual void resetAltitudeScale(bool replot = true);

      virtual double elevationAngle(const DtVector& geocentricFrom, const DtVector& geocentricTo) const;

      virtual void slot_defaultIconListChanged();

      virtual void slot_dataFrozenStateChanged(bool);
      
      virtual void processIntersectionResponse(DtSimMessage* msg);
      virtual void processPointMarkerResponse(DtSimMessage* msg);

      virtual void cancelTerrainInformationRequest();

      virtual void requestPointMarkerInformation(const DtVector&);

   protected slots:
      virtual void plotMouseReleased(const QPointF&);

   protected:
      makVrv::DtDe& myDe;
      DtTerrainProfileDataProvider* myDataProvider;
      makVrv::DtSignalConnectionManager myConnections;

      std::vector<DtVector>   myLinePoints;

      std::vector<DtVector>   myPlotPoints;

      double mySamplingRate;

      int myMaximumSamplingPoints;
      
      std::vector<int>  mySegmentPoints;

      QVector<QPointF>  myTerrainProfilePoints;

      std::vector<DtVector> myTerrainDatabasePoints;

      QVector<QPointF>  myTerrainLineSamplePoints;

      QVector<QPointF>  myTerrainLineDisplayPoints;

      DtReferenceEllipsoid* myReferenceForConversion;

      makVrv::DtDisplayUnitsConverter::DistanceUnits myAltitudeUnits;
      makVrv::DtDisplayUnitsConverter::DistanceUnits myDistanceUnits;

      DtVector myPointMarkerLocation;
      int myPointMarkerSoilType;
      double myPointMarkerDistanceAlongLine;
      double myPointMarkerCurrentHeight;
      QPointF myPointMarkerPosition;
      int myPointMarkerRequestId;

      bool myReady;

      DtSymbolTracker*  mySymbolTracker;
      QwtPlotMarker* myPointMarker;

      typedef std::map<makVrv::DtElementID, QwtPlotMarker*> TrackedEntities;
      TrackedEntities myTrackedEntities;

      QTime*         myReplotTimer;
      int            myReplotTime;

      double         myMinimumHeight;
      double         myMaximumHeight;

      double         myScaleFactor;
      double         myBuffer;

      bool           mySuspended;
      bool           myReplotting;
      bool           myShowVertices;
      bool           myShowVertexNumbers;
      QImage*        myVertexImage;
      std::vector<QwtPlotMarker*>   myVertices;
      bool           myFirstPlot;
      bool myResuming;

      typedef std::map<makVrv::DtUniqueID, DtVector> WaitingForPlot;
      WaitingForPlot myWaitingForPlot;
      bool mySuspendForMovement;
      double myDistanceMoveTolerance;
      int myReplotFlag;
      bool myTrackHistory;

      bool myUseBackendForProfile;

      makVrv::DtSignalConnectionManager myDataProviderConnections;

      int myTerrainInformationRequestId;
      std::map<int, DtVector> myReceivedTerrainProfileInformationFor;

      Qt::PenStyle myLinePenStyle;
      unsigned myLinePenSize;
      LineSampleStyle myLineSampleDisplay;

      std::set<makVrv::DtUniqueID> myDisplayOnBehalfOf;

   public:
      QwtPlot* myTerrainProfileGraph;
      QVBoxLayout* myMainLayout;
      QwtPlotCurve* myTerrainLine;
      QwtPlotCurve* myTerrainProfile;
      QwtPlotPicker* myPlotPicker;
      QLabel*        mySelectedPointLabel;
      QLabel*        mySelectedPoint;
      static QColor theTerrainProfileLineColor;
   };

   class DT_DLL_VRFGUICOMMONQT DtTerrainProfileWidgetCreator : public makVrv::DtVirtualBaseClass
   {
   public:
      DtTerrainProfileWidgetCreator(makVrv::DtDe&);
      virtual ~DtTerrainProfileWidgetCreator() override;

      static DtTerrainProfileWidgetCreator& instance(makVrv::DtDe&);
      static void registerInstance(makVrv::DtDe&, DtTerrainProfileWidgetCreator*);

      virtual DtTerrainProfileWidget* create(QWidget* parent);

   protected:
      makVrv::DtDe& myDe;
   };
}