| Line | 
      Branch | 
      Exec | 
      Source | 
    
    
      | 1 | 
      
       | 
       | 
      // | 
    
    
      | 2 | 
      
       | 
       | 
      // Copyright (c) 2017 CNRS | 
    
    
      | 3 | 
      
       | 
       | 
      // | 
    
    
      | 4 | 
      
       | 
       | 
      // This file is part of tsid | 
    
    
      | 5 | 
      
       | 
       | 
      // tsid is free software: you can redistribute it | 
    
    
      | 6 | 
      
       | 
       | 
      // and/or modify it under the terms of the GNU Lesser General Public | 
    
    
      | 7 | 
      
       | 
       | 
      // License as published by the Free Software Foundation, either version | 
    
    
      | 8 | 
      
       | 
       | 
      // 3 of the License, or (at your option) any later version. | 
    
    
      | 9 | 
      
       | 
       | 
      // tsid is distributed in the hope that it will be | 
    
    
      | 10 | 
      
       | 
       | 
      // useful, but WITHOUT ANY WARRANTY; without even the implied warranty | 
    
    
      | 11 | 
      
       | 
       | 
      // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 
    
    
      | 12 | 
      
       | 
       | 
      // General Lesser Public License for more details. You should have | 
    
    
      | 13 | 
      
       | 
       | 
      // received a copy of the GNU Lesser General Public License along with | 
    
    
      | 14 | 
      
       | 
       | 
      // tsid If not, see | 
    
    
      | 15 | 
      
       | 
       | 
      // <http://www.gnu.org/licenses/>. | 
    
    
      | 16 | 
      
       | 
       | 
      // | 
    
    
      | 17 | 
      
       | 
       | 
       | 
    
    
      | 18 | 
      
       | 
       | 
      #ifndef __invdyn_task_actuation_bounds_hpp__ | 
    
    
      | 19 | 
      
       | 
       | 
      #define __invdyn_task_actuation_bounds_hpp__ | 
    
    
      | 20 | 
      
       | 
       | 
       | 
    
    
      | 21 | 
      
       | 
       | 
      #include <tsid/tasks/task-actuation.hpp> | 
    
    
      | 22 | 
      
       | 
       | 
      #include <tsid/trajectories/trajectory-base.hpp> | 
    
    
      | 23 | 
      
       | 
       | 
      #include <tsid/math/constraint-inequality.hpp> | 
    
    
      | 24 | 
      
       | 
       | 
       | 
    
    
      | 25 | 
      
       | 
       | 
      namespace tsid { | 
    
    
      | 26 | 
      
       | 
       | 
      namespace tasks { | 
    
    
      | 27 | 
      
       | 
       | 
       | 
    
    
      | 28 | 
      
       | 
       | 
      class TaskActuationBounds : public TaskActuation { | 
    
    
      | 29 | 
      
       | 
       | 
       public: | 
    
    
      | 30 | 
      
       | 
       | 
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW | 
    
    
      | 31 | 
      
       | 
       | 
       | 
    
    
      | 32 | 
      
       | 
       | 
        typedef math::Index Index; | 
    
    
      | 33 | 
      
       | 
       | 
        typedef trajectories::TrajectorySample TrajectorySample; | 
    
    
      | 34 | 
      
       | 
       | 
        typedef math::Vector Vector; | 
    
    
      | 35 | 
      
       | 
       | 
        typedef math::VectorXi VectorXi; | 
    
    
      | 36 | 
      
       | 
       | 
        typedef math::ConstraintInequality ConstraintInequality; | 
    
    
      | 37 | 
      
       | 
       | 
        typedef pinocchio::Data Data; | 
    
    
      | 38 | 
      
       | 
       | 
       | 
    
    
      | 39 | 
      
       | 
       | 
        TaskActuationBounds(const std::string& name, RobotWrapper& robot); | 
    
    
      | 40 | 
      
       | 
       | 
       | 
    
    
      | 41 | 
      
       | 
      ✗ | 
        virtual ~TaskActuationBounds() {} | 
    
    
      | 42 | 
      
       | 
       | 
       | 
    
    
      | 43 | 
      
       | 
       | 
        int dim() const; | 
    
    
      | 44 | 
      
       | 
       | 
       | 
    
    
      | 45 | 
      
       | 
       | 
        const ConstraintBase& compute(const double t, ConstRefVector q, | 
    
    
      | 46 | 
      
       | 
       | 
                                      ConstRefVector v, Data& data); | 
    
    
      | 47 | 
      
       | 
       | 
       | 
    
    
      | 48 | 
      
       | 
       | 
        const ConstraintBase& getConstraint() const; | 
    
    
      | 49 | 
      
       | 
       | 
       | 
    
    
      | 50 | 
      
       | 
       | 
        void setBounds(ConstRefVector lower, ConstRefVector upper); | 
    
    
      | 51 | 
      
       | 
       | 
        const Vector& getLowerBounds() const; | 
    
    
      | 52 | 
      
       | 
       | 
        const Vector& getUpperBounds() const; | 
    
    
      | 53 | 
      
       | 
       | 
       | 
    
    
      | 54 | 
      
       | 
       | 
        const Vector& mask() const; | 
    
    
      | 55 | 
      
       | 
       | 
        void mask(const Vector& mask); | 
    
    
      | 56 | 
      
       | 
       | 
       | 
    
    
      | 57 | 
      
       | 
       | 
       protected: | 
    
    
      | 58 | 
      
       | 
       | 
        Vector m_mask; | 
    
    
      | 59 | 
      
       | 
       | 
        VectorXi m_activeAxes; | 
    
    
      | 60 | 
      
       | 
       | 
        ConstraintInequality m_constraint; | 
    
    
      | 61 | 
      
       | 
       | 
      }; | 
    
    
      | 62 | 
      
       | 
       | 
       | 
    
    
      | 63 | 
      
       | 
       | 
      }  // namespace tasks | 
    
    
      | 64 | 
      
       | 
       | 
      }  // namespace tsid | 
    
    
      | 65 | 
      
       | 
       | 
       | 
    
    
      | 66 | 
      
       | 
       | 
      #endif  // ifndef __invdyn_task_actuation_bounds_hpp__ | 
    
    
      | 67 | 
      
       | 
       | 
       |