libcnoid-dev 1.1.0+dfsg-6.1+b4 / usr / include / choreonoid-1.1 / cnoid / src / Collision / CollisionPairInserter.h

This file is indexed.

/usr/include/choreonoid-1.1/cnoid/src/Collision/CollisionPairInserter.h is in libcnoid-dev 1.1.0+dfsg-6.1+b4.

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
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#ifndef CNOID_COLLISION_COLLISION_PAIR_INSERTER_H_INCLUDED
#define CNOID_COLLISION_COLLISION_PAIR_INSERTER_H_INCLUDED

#include "CollisionData.h"
#include <vector>

namespace Opcode {

    class AABBCollisionNode;
    class MeshInterface;
}
    
namespace cnoid {

    class CollisionPairInserter
    {
      public:
        CollisionPairInserter();
        ~CollisionPairInserter();

        void clear(){
            cdContact.clear();
        }

        int detectTriTriOverlap(
            const Vector3& P1,
            const Vector3& P2,
            const Vector3& P3,
            const Vector3& Q1,
            const Vector3& Q2,
            const Vector3& Q3,
            collision_data* col_p);

        int apply(const Opcode::AABBCollisionNode* b1,
                  const Opcode::AABBCollisionNode* b2,
                  int id1, int id2,
                  int num_of_i_points,
                  Vector3 i_points[4],
                  Vector3& n_vector,
                  double depth,
                  Vector3& n1,
                  Vector3& m1,
                  int ctype,
                  Opcode::MeshInterface* mesh1,
                  Opcode::MeshInterface* mesh2);

        inline std::vector<collision_data>& collisions() {
            return cdContact;
        }

        Matrix3 CD_Rot1;
        Vector3 CD_Trans1;
        double CD_s1;

        Matrix3 CD_Rot2;
        Vector3 CD_Trans2;
        double CD_s2;

        std::vector<collision_data> cdContact;

      private:

        class tri
        {
          public:
            int id;
            Vector3 p1, p2, p3;
        };
        
        class col_tri
        {
          public:
            int status; // 0: unvisited, 1: visited, 2: included in the convex neighbor 
            Vector3 p1, p2, p3;
            Vector3 n;
        };

        static void copy_tri(col_tri* t1, tri* t2);
        
        static void copy_tri(col_tri* t1, col_tri* t2);
        
        static void calc_normal_vector(col_tri* t);
        
        static int is_convex_neighbor(col_tri* t1, col_tri* t2);
        
        static int identical_ver(const Vector3& v1, const Vector3& v2);
        
        static int is_neighboring_triangle(col_tri* t1, col_tri* t2);
        
        static void get_neighboring_triangles(
            col_tri* tri_convex_neighbor, col_tri* tri_neighbor,
            int* start_tri, int* end_tri, int num_tri);
        
        static int get_triangles_in_convex_neighbor(
            tri* root, col_tri* tri_convex_neighbor, col_tri* tri_neighbor,
            int num_tri, int max_num);
        
        static int get_triangles_in_convex_neighbor(
            tri* root, col_tri* tri_convex_neighbor, col_tri* tri_neighbor, int num_tri);
        
        static void get_triangles_in_neighbor(
            col_tri* neighbor_tris,
            int* n,
            const Opcode::AABBCollisionNode* root,
            Opcode::MeshInterface* mesh);

        static int count_num_of_triangles(const Opcode::AABBCollisionNode* root);

        void examine_normal_vector(
            const Opcode::AABBCollisionNode* b1,
            const Opcode::AABBCollisionNode* b2,
            int ctype,
            Opcode::MeshInterface* mesh1,
            Opcode::MeshInterface* mesh2);

        void check_separability(
            const Opcode::AABBCollisionNode* b1,
            const Opcode::AABBCollisionNode* root1, int num_tri1,
            const Opcode::AABBCollisionNode* b2,
            const Opcode::AABBCollisionNode* root2, int num_tri2,
            int ctype,
            Opcode::MeshInterface* mesh1, Opcode::MeshInterface* mesh2);

        void find_signed_distance(
            Vector3 &signed_distance, col_tri *trp, int nth, int ctype, int obj);

        void find_signed_distance(
            Vector3& signed_distance, const Vector3& vert, int nth, int ctype, int obj);

        void find_signed_distance(
            Vector3& signed_distance,
            const Opcode::AABBCollisionNode* b1,
            const Opcode::AABBCollisionNode* root,
            int num_tri,
            int contactIndex,
            int ctype,
            int obj,
            Opcode::MeshInterface* mesh);

        int new_point_test(int k);
    };
}

#endif

APT Browse - Built by Thomas Orozco.