C++ utilisation de furchterman directed force sur un graph

get retour de la propertyMap, no matching function for call to 'get'

Le problème exposé dans ce sujet a été résolu.

Salut,
je cherche a utiliser la fonction fruchterman_reingold_force_directed_layout de la BGL

Mais je suis un peu perdu, je ne sais pas quel version de la fonction utilisé (elle est surchargée) et je suis perdu avec ses paramètres.

Voila ce que j’ai fait:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
struct vertex_coo_t {
    //2 is because we are in 2D and point type 'cause fruchterman expect ::point_type in the property
    convex_topology<2>::point_type position;
    //correct topology ?
};
...
typedef adjacency_list<vecS ,vecS, undirectedS, vertex_coo_t> Graph;
...
Graph g;

add_edge(0, 1, g);
add_edge(0, 2, g);
add_edge(1, 3, g);
add_edge(2, 3, g);

auto propertyMap = get(vertex_coo_t, g); //no matching function
auto topo = square_topology<>(600.f);
fruchterman_reingold_force_directed_layout(g, propMap, topo);

Je n’arrive pas à utiliser get pour recevoir ma propertyMap et l’utiliser dans la fonction fruchterman.

Pourtant mon appel respecte la documentation (je crois):
property_map<adjacency_list, PropertyTag>::type get(PropertyTag, adjacency_list& g)

Returns the property map object for the vertex property specified by PropertyTag. The PropertyTag must match one of the properties specified in the graph’s VertexProperty template argument.

Mes questions sont :

  1. Ma structure vertex_coo_t est-elle correctement utilisé ?
  2. Pourquoi mon appel à get ne correspond à aucune surcharge ?
  3. Ma structure doit avoir une valeur de type point_type1 mais convex_topology<2> est correcte ou il faudrait utiliser qqch d’autre.
  4. La surcharge de fruchterman que j’utilise est correcte ou il en faut une autre pour atteindre mon but ?

Je veux avoir les positions de mes vertices aléatoires avant l’appel et positionés selon la force d’attraction/repulsion après l’appel à la fonction. Problème, le paramètre graph est constant et propertyMap n’est pas une référence et n’est donc pas modifié. de plus la fonction ne retourne rien, donc je ne sais pas ou trouver le résultat (les positions de mes vertices dirigé selon les forces : force-directed)

Merci d’avance pour toute aide ;-)

  1. The property map that stores the position of each vertex. It should typically be initialized with the vertices at random locations (use random_graph_layout). The type PositionMap must be a model of Lvalue Property Map such that the vertex descriptor type of Graph is convertible to its key type. Its value type must be Topology::point_type, representing the coordinates of the vertex. ↩

+0 -0

Bon je suis arrivé à l’utiliser, les exemples m’ont bien aider !

Pour les curieux : Merci à tous, je passe le sujet en résolut :-)

 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
//
struct PositionAndColor {
    rectangle_topology<>::point_type coo;
    sf::Color color = sf::Color::White; //drawing with SFML


};
typedef adjacency_list<vecS ,vecS, undirectedS , PositionAndColor > Graph;
typedef boost::rectangle_topology<> topology_type;
typedef topology_type::point_type point_type;


class progress_cooling : public linear_cooling<double>
{
    typedef linear_cooling<double> inherited;

public:
    explicit progress_cooling(std::size_t iterations) : inherited(iterations)
    {
        display.reset(new progress_display(iterations + 1, std::cerr)); //console display progressionBar (useless)
    }

    double operator()()
    {
        ++(*display);
        return inherited::operator()();
    }

private:
    shared_ptr<boost::progress_display> display;
};

void show_vertex_property(const Graph& g){
    int nbVertices = num_vertices(g);

    for (int i=0; i < nbVertices; i++)
        std::cout << i <<" :" <<g[i].coo[0] << '/' << g[i].coo[1] <<'\n' ;

}
void execute_fruchterman(const double w,const double h,Graph & g, const size_t iterations = 1000){
    minstd_rand gen;
    topology_type topo(gen, 0, 0, w, h);
    random_graph_layout(g, get(&PositionAndColor::coo, g), topo);
    fruchterman_reingold_force_directed_layout(g, get(&PositionAndColor::coo, g), topo, cooling(progress_cooling(iterations)));
}

int main(int argc, char* argv[])
{

    const double w = 800;
    const double h = 600;

    Graph g;
    for (size_t i =0; i< 10; ++i){
        add_edge(0,i,g);
    }

    execute_fruchterman(w, h, g);

        //SFML part

    return EXIT_SUCCESS;
}
+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte