This file is indexed.

/usr/include/kdl/treeiksolver.hpp is in liborocos-kdl-dev 1.3.1+dfsg-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
/*
 * treeiksolver.hpp
 *
 *  Created on: Nov 28, 2008
 *      Author: rubensmits
 */

#ifndef TREEIKSOLVER_HPP_
#define TREEIKSOLVER_HPP_

#include "tree.hpp"
#include "jntarray.hpp"
#include "frames.hpp"
#include <map>

namespace KDL {

typedef std::map<std::string, Twist> Twists;
typedef std::map<std::string, Jacobian> Jacobians;
typedef std::map<std::string, Frame> Frames;

/**
 * \brief This <strong>abstract</strong> class encapsulates the inverse
 * position solver for a KDL::Chain.
 *
 * @ingroup KinematicFamily
 */
class TreeIkSolverPos {
public:
    /**
     * Calculate inverse position kinematics, from cartesian
     *coordinates to joint coordinates.
     *
     * @param q_init initial guess of the joint coordinates
     * @param p_in input cartesian coordinates
     * @param q_out output joint coordinates
     *
     * @return if < 0 something went wrong
	  *         otherwise (>=0) remaining (weighted) distance to target
     */
    virtual double CartToJnt(const JntArray& q_init, const Frames& p_in,JntArray& q_out)=0;
    
    virtual ~TreeIkSolverPos() {
    }
    ;
};

/**
 * \brief This <strong>abstract</strong> class encapsulates the inverse
 * velocity solver for a KDL::Tree.
 *
 * @ingroup KinematicFamily
 */
class TreeIkSolverVel {
public:
    /**
     * Calculate inverse velocity kinematics, from joint positions
     *and cartesian velocities to joint velocities.
     *
     * @param q_in input joint positions
     * @param v_in input cartesian velocity
     * @param qdot_out output joint velocities
     *
     * @return if < 0 something went wrong
	  *         distance to goal otherwise (weighted norm of v_in)
     */
    virtual double CartToJnt(const JntArray& q_in, const Twists& v_in, JntArray& qdot_out)=0;

    virtual ~TreeIkSolverVel() {
    }
    ;

};

}

#endif /* TREEIKSOLVER_HPP_ */