ParametricNet.h

#pragma once
#include <vector>
#include <eigen_matrix_defs.h>
#include <memory>
#include <CEnvironment.h>
 
#ifdef FH_VISUALIZATION
#include "Ogre.h"
#include <sfh/ogre/C3DLine.h>
#endif
 
typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> MatriX;
 
class ParametricNet {
public:
    void Init(double diameter, int num_circumference, double height);
    void InitStates(CoRiBoDynamics::Vector& PA, CoRiBoDynamics::Vector& PB);
    void SetEnvironment(CEnvironment* environment);
    CoRiBoDynamics::Vector Points(CoRiBoDynamics::Vector& PA, CoRiBoDynamics::Vector& PB, double T, const double * X);
 
    int cols() { return m_nc; }
    int rows() { return m_nr; }
 
#ifdef FH_VISUALIZATION
    void    RenderInit(Ogre::Root* const ogreRoot);
    void    RenderUpdate(const double T, const double* const X);
    std::unique_ptr<C3DLine> m_h_line; // horizontal lines
    std::unique_ptr<C3DLine> m_v_line; // vertical lines
    double max_tension;
#endif
 
private:
    bool m_first_time;
 
    CEnvironment* m_environment;
    double m_node_weight;
    double m_node_drag;
 
    double m_EA;
    double m_Lx; // horizontal element length
    double m_Ly; // vertical element length
 
    int m_nc; // number of point columns
    int m_nr; // number of point rows
    int m_nP; // number of points total
    int m_nT;
 
    int ixP (int r, int c) { return 3*(r + c*m_nr); }                           // point index
    int ixTL(int r, int c) { return 3*m_nP + r + c*m_nr; }                      // tension left index
    int ixTR(int r, int c) { return 3*m_nP + r + ((c + m_nc-1)%m_nc)*m_nr; }    // tension right index
    int ixTU(int r, int c) { return 4*m_nP + r + c*(m_nr+1); }                  // tension up index
    int ixTD(int r, int c) { return 4*m_nP + (r+1)%(m_nr+1) + c*(m_nr+1); }     // tension down index
 
    int ixNL(int r, int c) { return 3*(r + c*m_nr); }                                   // normal left index
    int ixNR(int r, int c) { return 3*(r + ((c + m_nc - 1) % m_nc)*m_nr); }             // normal right index
    int ixNU(int r, int c) { return 3*(m_nP + r + c*(m_nr + 1)); }                      // normal up index
    int ixND(int r, int c) { return 3*(m_nP + (r + 1) % (m_nr + 1) + c*(m_nr + 1)); }   // normal down index
 
    CoRiBoDynamics::Vector m_X; // state vector. contains node positions and tensions
    CoRiBoDynamics::Vector m_PA; // position of upper points
    CoRiBoDynamics::Vector m_PB; // position of lower points
    CoRiBoDynamics::Vector m_U; // edge unit vectors
    CoRiBoDynamics::Vector m_F; // vertex forces
 
    CoRiBoDynamics::Vector Constraint(const CoRiBoDynamics::Vector& X);
 
    MatriX Jacobian(const CoRiBoDynamics::Vector& X);
 
    CoRiBoDynamics::Vector DeltaX(const CoRiBoDynamics::Vector& X);
 
    void NewtonRhapson(CoRiBoDynamics::Vector& X);
 
};