finger.h

Go to the documentation of this file.

#ifndef finger_h___
#define finger_h___

#include "utilities.h" 
#include "target_object.h"
#include <iostream>
#include <string>

using std::string;

namespace ICR
{
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
struct InclusionRule
{
  double rule_parameter_; 
  RuleType rule_type_;
  bool filter_inside_points_;

  InclusionRule();
  InclusionRule(double rule_parameter_in, 
                RuleType rule_type_t_in = Sphere, 
                bool filter_in = false);

  friend std::ostream& operator<<(std::ostream &stream,InclusionRule const& inclusion_rule);
  bool inclusionTest(ContactPoint const* center_point, ContactPoint const* test_point)const;
};
//--------------------------------------------------------------
//--------------------------------------------------------------
struct Node
{
  ContactPoint* contact_point_;
  bool inside_patch_;

  Node();
  Node(ContactPoint* contact_point);
  friend std::ostream& operator<<(std::ostream &stream, Node const& node);
};
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
struct Patch
{
  IndexList patch_ids_;
  
  Patch();
  Patch(uint centerpoint_id);
  Patch(uint centerpoint_id, TargetObject const& obj, InclusionRule const& rule);
  friend std::ostream& operator<<(std::ostream &stream,Patch const& patch);
};
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
class FingerParameters
{
 private:

  string name_;
  double force_magnitude_;
  uint disc_;
  double mu_0_; 
  double mu_T_; 
  ContactType contact_type_; 
  ModelType model_type_; 
  InclusionRule inclusion_rule_; 

 public:
  FingerParameters();
  FingerParameters(FingerParameters const& src);
  FingerParameters(string name,
                   double force_magnitude_in,
                   uint disc_in,
                   double mu_0_in, 
                   double mu_T_in, 
                   ContactType contact_type_in, 
                   ModelType model_type_in, 
                   double radius_in);
  friend std::ostream& operator<<(std::ostream &stream,FingerParameters const& param);
  FingerParameters& operator=(FingerParameters const& src);
  ~FingerParameters();
  void setName(string &name_in) {name_ = name_in;}

  void setForce(double f_in) {assert(f_in > 0); force_magnitude_ = f_in;}
  void setFriction(double mu_in) {assert(mu_in > 0); mu_0_ = mu_in;}
  void setFrictionTorsional(double mu_in) {assert(mu_in > 0); mu_T_ = mu_in;}

  void setDiscretization(uint d_in) {assert(d_in > 0); disc_ = d_in;}

  void setFrictionlessContact(double force_magnitude);
  void setFrictionalContact(double force_magnitude,uint disc,double mu_0);
  void setSoftFingerContact(double force_magnitude,uint disc,double mu_0, double mu_T);
  void setContactType(ContactType contact_type);
  void setContactType(string &contact_type);
  void setContactModelType(ModelType model_type);
  void setContactModelType(string &model_type);
  void setInclusionRule(InclusionRule const& inclusion_rule);
  void setInclusionRuleType(RuleType rule_type);
  void setInclusionRuleType(string &rule_type);
  void setInclusionRuleParameter(double rule_parameter);
  void setInclusionRuleFilterPatch(bool filter_inside_points);

  double getForceMagnitude()const;
  string getName()const;
  uint getDisc()const;
  double getMu0()const;
  double getMuT()const;
  ContactType getContactType()const;
  ModelType getModelType()const;
  InclusionRule const* getInclusionRule()const;
  RuleType getInclusionRuleType()const;
  uint getInclusionRuleParameter()const;
  bool getInclusionRuleFilterPatch()const;

};


//---------------------------------------------------------------------
//---------------------------------------------------------------------
class Finger
{
 private:

  PointContactModel* c_model_;
  OWSPtr ows_;
  PatchListPtr patches_;
  uint centerpoint_id_;
  bool initialized_;
  string name_;

 public:

  Finger();
  Finger(FingerParameters const& param);
  Finger(Finger const& src);
  Finger& operator=(Finger const& src);
  friend std::ostream& operator<<(std::ostream& stream,Finger const& finger);
  ~Finger();
 
  void init(uint centerpoint_id, const PatchListPtr patches, const OWSPtr ows);
  void setCenterPointId(uint centerpoint_id);
  Patch const* getCenterPointPatch() const;
  Patch const* getPatch(uint id)const;
  const OWSPtr getOWS()const;
  const PatchListPtr getPatches()const;
  PointContactModel const* getContactModel()const; 
  PointContactModel* getContactModel(); 
  uint getCenterPointId()const;
  bool isInitialized()const;
  string getName()const;
  void setName(string const & name);

};
//---------------------------------------------------------------------
//---------------------------------------------------------------------
}//namespace ICR
#endif