ModelBaseAnalysis.hpp

Go to the documentation of this file.

#ifndef MODEL_BASE_ANALYSIS_H
#define MODEL_BASE_ANALYSIS_H

#include <Eigen/Core>
#include <Eigen/Geometry>

#include "TerrainConfiguration.hpp" 
#include <iostream>
#include <vector>
#include <deque>
using namespace Eigen; 


namespace terrain_estimator
{

    class SVMTerrainClassification{
        public: 
            
            SVMTerrainClassification(std::vector<TerrainType> terrain_types, int min_number_of_votes); 
            
            void addSVMClassifier(SVMConfiguration svm_function);
            
            void addSVMClassifier(std::vector<SVMConfiguration> svm_functions){ this->svm_functions = svm_functions; }
            
            TerrainType getTerrainClassification(std::vector<double> histogram); 
        
            double getProbability(TerrainType type); 
            
        private: 
            
            void calculateSVMValue(); 
            
            int getIndexType(TerrainType type);
            
            std::vector < SVMConfiguration > svm_functions; 
            
            std::vector<TerrainType> terrain_types; 
            
            int min_number_of_votes;
            
            std::vector<double> probability; 
            
            double svm_value;
            
    }; 
    
    class HistogramTerrainClassification{
        public: 
            
            HistogramTerrainClassification(uint number_histograms);
            
            bool addHistogram(std::vector<double> histogram, std::vector<double> histogram_angular_velocity,  std::vector<double> histogram_linear_velocity );
            
            std::vector<double> getCombinedHistogram(); 
            
        
        private: 
            std::deque < std::vector<double> > histogram_list; 
            
            std::vector<double> combined_histogram; 
            
            uint number_histograms;
    }; 
    
    struct Step{
        std::vector<double> traction; 
        std::vector<double> angular_velocity; 
        std::vector<double> linear_velocity; 
        double max_traction; 
        double min_traction; 
        double min_angle; 
        double max_angle;           
        double id; 
        double last_encoder; 
    };
    
    class TractionForceGroupedIntoStep{
        
        public: 
            TractionForceGroupedIntoStep(double angle_between_legs);
            
            void addTraction(double traction, double encoder); 
            
            void addRobotVelocities(double angular_velocity, double linear_velocity); 
            
            double getCompletedStepId(); 
            
            Step getCompletedStep(); 
            
            double getMaximalTractionEitherStep(); 
            
             double getMinimalTractionEitherStep(); 
             
        private:
            
            Step completed_step; 
            
            Step current_step;
            
            bool isCurrentStepCompleted();
            
            double getStepId(double encoder); 
            
            void initCurrentStep(); 
            
            double getLegAngle( double encoder ); 
            
            double angle_between_legs;
            
    };
    
    class Histogram {
        public: 
            Histogram(int numb_bins, double min_value, double max_value); 
            
            void addValue( double value ); 
            
            void clearHistogram();
            
            std::vector<double> getHistogram(); 
            
            double getNumberPoints(){ return number_points; }
            
        private:
            
            double max_value; 
            
            double min_value; 
            
            int numb_bins; 
            
            std::vector<double> histogram;
            
            double number_points; 
            
            double bin_size; 
    }; 
    
    class SlipDetectionModelBased{
        public: 
            EIGEN_MAKE_ALIGNED_OPERATOR_NEW

            SlipDetectionModelBased(double axis_rotation, uint fl, uint fr, uint rl, uint rr); 
            
            ~SlipDetectionModelBased(); 
            
            bool slipDetection(Vector4d translation, double delta_heading_measured, double slip_threashold);
            
            double getWheelSlipSingleCase(); 
            
            bool hasWheelSingleSliped(int wheel); 
            
            bool hasWheelSliped(int wheel); 

            bool hasWheelConsecutivelySliped(int wheel); 
            
            void analyzeConsecutiveSlips();
            
            double delta_theta_model;
            
            double delta_theta_measured;
            
            Eigen::Vector4d total_slip;
            
            Vector4d slip_votes; 
            
            Vector4d consectuive_slip_votes; 
        private:
            bool hasSingleWheelSliped(); 
            
            Eigen::Vector4d slipValue(Vector4d translation, double right_translation, double left_translation);

            double axis_rotation;
            uint fl;
            uint fr;
            uint rl;
            uint rr; 
            

            
    }; 
    
    class LegWheelOdometry{
            
    public: 
            EIGEN_MAKE_ALIGNED_OPERATOR_NEW
            
            LegWheelOdometry(double angle_between_legs, double radius){this->angle_between_legs = angle_between_legs; this->radius = radius; } 
            

            void setInitialEncoder(Vector4d encoder){ this->init_encoder = encoder; }  
          
            Vector4d translationAxes(Vector4d encoder);
            
            double translationAxis(double encoder, double initial_encoder);

    private:
            double numberOfCycles(double encoder);
            
            double getLegPos(double external_encoder_value);
  
            Vector4d init_encoder; 
    
    private:    
            //Asguard Model Parameters 
            double angle_between_legs;
            double radius; 
            
    }; 
    


}

#endif