CrowfootMath.h

#pragma once
 
#include <Eigen/Dense>
#include <string>
 
#include <vector>
#ifdef FH_VISUALIZATION
#   pragma warning(push)
#   pragma warning(disable : 4251)
#   include <Ogre.h>
#   pragma warning(pop)
#   include "cable/subroutines/InternalCable.h"
#endif
 
// #define CROWFOOTMATH_DEBUG_RENDERING
 
class CrowfootMath
{
public:
   struct LineDef
   {
      Eigen::Vector3d fasteningPos;
      double          length;
   };
 
   struct VisualSpec
   {
      int         numFaces;
      int         numElements;
      double      drawDiameter;
      std::string materialName;
      VisualSpec()
      {
         numFaces     = 5;
         numElements  = 1;
         drawDiameter = 0.1;
         materialName = "Trawl/SteelWire";
      }
   };
 
   // CrowfootMath(double m_maxLineForce = 1.0e7);
 
   CrowfootMath(double maxLineForce = 1.0e7, const VisualSpec& visualSpec = VisualSpec());
 
   int AddLine(double length, const double* const fasteningpos);
 
   void Update(const double* const F, double* const posOut);
 
   void CalcIterativePos(const double* const F, double* const posOut, int maxNumIter = 500, double expectedLengthToGo = 3.0,
         double tolerance = 0.00001);
 
   void GetLineForce(double* F, int lineIndex);
 
   double GetLineTension(int lineIndex);
 
   void UpdateLineLength(double length, int lineIndex);
 
   void UpdateLineFasteningPos(const double* const fasteningpos, int lineIndex);
 
   int NumLines();
 
 
#ifdef FH_VISUALIZATION
   // Initial specification of the simObject geometry for rendering.
   virtual void RenderInit(Ogre::Root* const ogreRoot, Ogre::SceneManager* m_sceneMgr, std::string m_simObjectName);
 
   // Updating the simObject for rendering the next frame.
   virtual void RenderUpdate(std::vector<const double*>& aadPos, const double adPosCollectingPoint[3]);
#endif
 
protected:
   void CalcForOneLine(const Eigen::Vector3d& Force, const Eigen::Vector3d& ForceDir, double* const posOut);
 
   void CalcForTwoLines(const Eigen::Vector3d& Force, const Eigen::Vector3d& ForceDir, double* const posOut);
 
   void CalcForThreeLines(const Eigen::Vector3d&, const Eigen::Vector3d& ForceDir, double* const posOut);
 
   Eigen::Vector3d CalcPosForOneStretched(int index, const Eigen::Vector3d& ForceDir);
 
   Eigen::Vector3d CalcPosForTwoStretched(int index1, int index2, const Eigen::Vector3d& ForceDir);
 
   void CalcForOneActive(int index, const Eigen::Vector3d&, const Eigen::Vector3d& pos, double* const posOut);
 
   void CalcForTwoActive(int index1, int index2, const Eigen::Vector3d& Force, Eigen::Vector3d pos, double* const posOut);
 
   void SetPosition(double* const posOut, const Eigen::Vector3d& pos);
 
   bool EnsureLineIndexOk(int lineIndex);
 
   bool PointIsWithinLineReach(int index, const Eigen::Vector3d& connPos);
 
   std::vector<LineDef>         m_lines;
   std::vector<Eigen::Vector3d> m_lineForces;
   // Eigen::Vector3d                   m_lineTensions;
   double     m_maxLineForce;
   VisualSpec m_visualSpec;
 
   // DEBUGGING
#ifdef CROWFOOTMATH_DEBUG_RENDERING
   Eigen::Vector3f DEBUG_poss0;
   Eigen::Vector3f DEBUG_poss1;
   Eigen::Vector3f DEBUG_ForceDir;
#endif
 
#ifdef FH_VISUALIZATION
   std::vector<SCableRenderSpec*>   m_RenderSpecs;
   std::vector<Ogre::ManualObject*> m_RenderObjects;
   double                           m_drawDiam; 
   Ogre::SceneNode*                 m_lineSceneNode;
 
   // DEBUGGING
#   ifdef CROWFOOTMATH_DEBUG_RENDERING
   Ogre::Entity*    m_renderSphere[2];
   Ogre::SceneNode* m_renderNodeSphere[2];
   CDynamicLines*   m_lines;
   Ogre::SceneNode* m_debugLineSceneNode;
#   endif
#endif
};