damageProbabilityResults.h

Go to the documentation of this file.

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

#if !defined(Q_MOC_RUN)
#include "simulationObjectEditorImpl/simulationObjectEditorImplDefines.h"
#include "simulationObjectEditorImpl/simulationModelSetLoader.h"
#include <vrfGuiCore/entityMapperKey.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrfobjparam/damageAdjudicationComponentDescriptor.h>
#endif

#include <QtWidgets/QDialog>

#include <set>

namespace makVrv
{
   class DtDe;
}

class QGridLayout;
class QHBoxLayout;
class QVBoxLayout;
class QScrollArea;
class QSlider;
class QCheckBox;
class QLabel;
class QPushButton;
class QToolButton;
class QListWidget;
class DtTargetingControlTable;
class DtPlotPicker;
class QwtPlot;
class QwtPlotCurve;
class QwtLegend;
class DtAmmunitionParamsEntry;
class DtComponentSystemDefinition;
class DtPowerRangeDeterminant;
class DtDamageProbabilityTable;
class DtFaceSelectionWidget;
class DtAngleOfIncidenceSelectionWidget;
class DtUiElementEvent;
class DtMunitionDetonationPowerEntry;
class DtRangeProbabilityTable;

class DT_DLL_simulationObjectEditorimpl DtDamageProbabilityResults : public QDialog
{
   Q_OBJECT

public:
   DtDamageProbabilityResults(makVrv::DtDe&, QWidget* p);

   virtual ~DtDamageProbabilityResults();

   virtual void setAttacker(const DtObjectType&);
   virtual void setDefender(const DtObjectType&);

protected:
   struct SimulationObject
   {
      QWidget* canvas;
      QVBoxLayout* layout;
      QHBoxLayout* buttonCenter;
      QToolButton* button;
      QHBoxLayout* labelLayout;
      QToolButton* editButton;
      QLabel* label;
      makVrf::DtEntityMapperKey key;
   };

   struct AmmunitionInformation
   {
      AmmunitionInformation() : controlTable(0), maximumRange(0.) {};
      AmmunitionInformation(const DtTargetingControlTable* c, double r) : controlTable(c), maximumRange(r) {};
      AmmunitionInformation(const AmmunitionInformation& orig) : controlTable(orig.controlTable), maximumRange(orig.maximumRange) {};

      const DtTargetingControlTable* controlTable;
      double maximumRange;
   };

   typedef std::map<const DtAmmunitionParamsEntry*, AmmunitionInformation> AmmunitionMap;

   virtual void slot_revertedMunitions(std::set<makVrf::DtEntityMapperKey>);
   virtual SimulationObject createSimulationObject(const DtString&);
   virtual double maximumRangeForMunition(const DtAmmunitionParamsEntry* ape) const;

   virtual void setIcon(const SimulationObject&);
   virtual void selectSimulationObject(SimulationObject&);
   virtual void slot_resetIcons();
   virtual void attack();
   virtual QWidget* showError(const QString&, const QString& toDo, int row, int col);
   virtual AmmunitionMap ammunitionThatCanTargetDefender(const DtSimulationModelSetLoader::TargetingControlAndRangeTables& targets) const;
   virtual double findMaximumRange(const AmmunitionMap&) const;
   virtual bool graphAttack(const AmmunitionMap&, const DtString& face, double angleOfIncidence);
   virtual void clearPlotLines();
   virtual QVector<QPointF> calculateIndirectFire(const DtMunitionDetonationPowerEntry*, const DtAmmunitionParamsEntry*,
      const DtRangeProbabilityTable* hitTable, const DtString&, const DtString&, double angleOfIncidence) const;
   virtual QVector<QPointF> calculateFromHitTable(const DtMunitionDetonationPowerEntry*, const DtAmmunitionParamsEntry*,
      const DtRangeProbabilityTable* hitTable, const DtString&, const DtString&, double angleOfIncidence) const;
   virtual QVector<QPointF> createPlotLine(const DtMunitionDetonationPowerEntry*, const DtAmmunitionParamsEntry*,
      const DtRangeProbabilityTable* hitTable, const DtString&, const DtString&, double angleOfIncidence) const;
   virtual bool isIndirectFire(const DtAmmunitionParamsEntry*) const;
   virtual bool getIndirectFireValues(const DtAmmunitionParamsEntry*, double& probableErrorInRange, double& probableErrorInDisplacement,
      double& minRange, double& maxRange) const;
   virtual double calculateIndirectDistanceFromTarget(double probableErrorInRange, double probableErrorInDisplacement) const;
   virtual double findMaximumRange(const DtAmmunitionParamsEntry* ammo) const;

   virtual double killPercentage(double range, const DtPowerRangeDeterminant*, const DtDamageProbabilityTable*,
      const DtString& type, const DtString& surface, double angleOfIncidence, double* retPower = 0, bool indirect = false) const;
   virtual const DtRangeProbabilityTable* hitTableForAmmunition(const DtAmmunitionParamsEntry*,
      const DtComponentSystemDefinition** definition = 0) const;
   virtual double hitPercentage(const DtRangeProbabilityTable* hitTable, double range) const;

   virtual double killPercentage(double range, const DtMunitionDetonationPowerEntry*, const DtAmmunitionParamsEntry*,
      const DtRangeProbabilityTable* hitTagble, const DtString& type, const DtString& surface, double angleOfIncidence,
      double* retPower = 0, DtString* retPowerType = 0, bool indirect = false) const;

   virtual double killPercentageModification(double range, double percent, const DtAmmunitionParamsEntry*,
      const DtRangeProbabilityTable*) const;

   virtual void setupForAnglesOfIncidence(const DtDamageProbabilityTable*, const DtString&, double angleOfIncidence);
   virtual void setupFacesWidget(const DtDamageProbabilityTable*);

   virtual void uiEvent(const DtUiElementEvent&);
   virtual void graphLineColorChanged(const QColor& oldColor, const QColor& newColor);

   virtual void clearDetailedData();
   virtual void addDetailedDataLabel(int col, const QString&);
   virtual bool getInformationForAmmuinitionAtRange(const DtAmmunitionParamsEntry*, double range, const DtRangeProbabilityTable*,
      const DtDamageProbabilityTable*&, double& hit, double& power, double& killPercent, DtString& powerType, bool& beyondMaxRange, double& maximumRange) const;
   virtual QWidget* setDetailedDataValue(int row, int col, const QString& value, bool isLink);

   virtual void replotAllCurves();

   virtual void slot_labelModified(const std::vector<DtObjectType>&);
   virtual void slot_objectTypeAboutToBeChanged(const DtObjectType& oldType, const DtObjectType& newType);
   virtual QLabel* addRowLabel(int row, const QString& ammoLabel);

   virtual QWidget* addRegenerateGraph(int row);
   virtual void clearRegenerateGraph(int row);
   virtual void regenerateGraphLine(int row);
   virtual QVector<QPointF> createPlotLine(const DtAmmunitionParamsEntry* entry, const DtString& surface, double angleOfIncidence,
      const DtDamageProbabilityTable** = 0);

   virtual QWidget* addAdditionalInformationText(int row, const QString& text);
   virtual QWidget* addAdditionalWarningText(int row, const QString& text);
   virtual QWidget* addAdditionalText(int row, const QString& text, const std::string& icon);
   virtual void clearAdditionalInformationText(int row);
   virtual void showAdditionalInformation(const QString&);
   virtual QString indirectFireText(const DtAmmunitionParamsEntry* entry, double power) const;
   virtual void processDataChangedEvent(const QString&);

   virtual QString damageTableCannotBeDamagedBy(const DtAmmunitionParamsEntry*) const;
   virtual QString damageTableCannotBeDamagedBy(const AmmunitionMap&) const;
   virtual QString weaponCannotDamage(const DtRwDamageByMunitionPowerMap*) const;

protected slots:
   virtual void selectAttacker();
   virtual void selectDefender();
   virtual void selectFace(const DtString&);
   virtual void legendClicked(const QVariant& itemInfo, int index);
   virtual void setupForAngleOfIncidence(double);
   virtual void showDetailedData(const QPointF&);
   virtual void selectAppropriateItem();
   virtual void editSimulationObject();
   virtual void onSwap();
   virtual void itemClicked();
   virtual void showCurveChanged();
   virtual void updateReverseButtonIcon();

public:
   QVBoxLayout* myMainLayout;
   QHBoxLayout* myGraphLayout;

   QHBoxLayout* myButtonsLayout;
   QVBoxLayout* myVsLayout;
   QToolButton* myReverseButton;
   QLabel* myVsLabel;

   SimulationObject myAttacker;
   SimulationObject myDefender;

   QToolButton* myAttackerButton;
   QToolButton* myDefenderButton;

   QPushButton* myCloseButton;

   QwtPlot* myGraph;
   QwtLegend* myLegend;
   DtPlotPicker* myPlotPicker;

   QVBoxLayout* mySelectionLayout;
   QLabel* myFaceLabel;
   DtFaceSelectionWidget* myFaces;

   DtAngleOfIncidenceSelectionWidget* myAngleOfIncidenceSelectionWidget;
   QLabel* myAngleOfIncidenceLabel;

   struct HitCurve
   {
      QwtPlotCurve* curve;
      QHBoxLayout* layout;
      QCheckBox* showCurve;
      QVector<QPointF> points;
      int row;
   };

   typedef std::map<const DtAmmunitionParamsEntry*, HitCurve> Curves;
   Curves myCurves;

   QLabel* myDetailedDataLabel;
   QGridLayout* myDetailedDataLayout;
   QHBoxLayout* myDataLayout;
   std::map<int, std::map<int, QWidget*> > myDetailedDataWidgets;
   std::vector<QLabel*> myDetailedDataLabels;
   QwtPlotCurve* mySelectionLine;

   QWidget* myDetailedDataWidget;

protected:
   makVrv::DtDe& myDe;
   makVrv::DtSignalConnectionManager myConnections;
   AmmunitionMap myAvailableAmmunition;
   DtRwDamageByMunitionPowerMap* myDamageTable;
   DtComponentSystemDefinition* myDamageSystem;
   makVrv::DtSignalConnectionManager myGraphLineColorConnections;
   DtSimulationModelSetLoader::TargetingControlAndRangeTables myTargetingControlAndRangeTables;
   double myLastRangeSelected;
   double myMaximumRange;
   int myIndirectFireRuns;

   struct IndirectFireResult
   {
      double averageRangeFromTarget;
      double averagePower;
      double averageKill;
      DtString powerType;
   };

   typedef std::map<const DtAmmunitionParamsEntry*, IndirectFireResult> IndirectFireResults;
   mutable IndirectFireResults myIndirectFireResults;
};

class DT_DLL_simulationObjectEditorimpl DtDamageProbabilityResultsCreator : public makVrv::DtVirtualBaseClass
{
public:
   DtDamageProbabilityResultsCreator(makVrv::DtDe&);

   virtual ~DtDamageProbabilityResultsCreator();

   static DtDamageProbabilityResultsCreator& instance(makVrv::DtDe&);

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

   virtual DtDamageProbabilityResults* create(QWidget* parent);

   virtual DtDamageProbabilityResults* globalInstance(QWidget* parent);

protected:
   makVrv::DtDe& myDe;
   DtDamageProbabilityResults* myGlobalInstance;
};