TrawlReporter.h

#pragma once
 
#include "sfh/filters/FIR.h"
 
#include <fhsim/simobject/SimObject.h>
#include <marenv/marenv.h>
 
#ifdef FH_VISUALIZATION
#   include "trawl/subroutines/ValuesDisplayBase.h"
 
#   include <fhsim/visual/renderer/Hud.h>
#   include <memory>
#endif
 
#include <string>
#include <vector>
 
class TrawlReporter : public SimObject
{
public:
   static constexpr double kNewtonToTonneForce = 1.0 / (1000.0 * marenv::gravity);
 
   TrawlReporter(const std::string& simObjectName, ISimObjectCreator* const creator);
 
   void OdeFcn(const double T, const double* const X, double* const XDot) const override { }
   void AcceptedStep(const double T, const double* const X) override;
 
#ifdef FH_VISUALIZATION
   void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
   void RenderUpdate(const double T, const double* const X);
#endif
 
protected:
   std::vector<double> Measure(const double T, const double* const X) const;
 
   const double* Filtered(int offset) { return m_filter.GetValue() + offset; }
 
   const double* OutWarpTensions(const double T, const double* const X) { return Filtered(m_indWarpTensions); }
   const double* OutOuterDoorSpread(const double T, const double* const X) { return Filtered(m_indOuterDoorSpread); }
   const double* OutDoorSpreads(const double T, const double* const X) { return Filtered(m_indDoorSpreads); }
   const double* OutNetHeightsCenter(const double T, const double* const X) { return Filtered(m_indNetHeightsCenter); }
   const double* OutNetHeightsPWing(const double T, const double* const X) { return Filtered(m_indNetHeightsPWing); }
   const double* OutNetHeightsSWing(const double T, const double* const X) { return Filtered(m_indNetHeightsSWing); }
   const double* OutNetWidthTop(const double T, const double* const X) { return Filtered(m_indNetWidthTop); }
   const double* OutNetWidthBottom(const double T, const double* const X) { return Filtered(m_indNetWidthBottom); }
   const double* OutNetSeafloorPressure(const double T, const double* const X) { return Filtered(m_indNetSeafloorPressure); }
   const double* OutNetSeafloorFriction(const double T, const double* const X) { return Filtered(m_indNetSeafloorFriction); }
 
   int                       m_numNets;
   sfh::filters::FIR         m_filter;
   std::vector<ISignalPort*> m_inWarpForces;
   std::vector<ISignalPort*> m_inDoorPos;
   std::vector<ISignalPort*> m_inNetUpperPort;
   std::vector<ISignalPort*> m_inNetLowerPort;
   std::vector<ISignalPort*> m_inNetUpperStb;
   std::vector<ISignalPort*> m_inNetLowerStb;
   std::vector<ISignalPort*> m_inNetUpperCenter;
   std::vector<ISignalPort*> m_inNetLowerCenter;
   std::vector<ISignalPort*> m_inNetBottomContact;
 
   // Offsets into the values. The first seven groups are the HUD lines, in order.
   int m_indWarpTensions;
   int m_indOuterDoorSpread;
   int m_indDoorSpreads;
   int m_indNetHeightsCenter;
   int m_indNetWidthTop;
   int m_indNetSeafloorPressure;
   int m_indNetSeafloorFriction;
   int m_indNetHeightsPWing;
   int m_indNetHeightsSWing;
   int m_indNetWidthBottom;
   int m_numValues;
 
#ifdef FH_VISUALIZATION
   std::unique_ptr<ValuesDisplayBase> m_formatter;
   fhsim::HudCorner                   m_corner;
   std::vector<fhsim::HudLine>        m_hudLines; 
#endif
};