La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Utilisation des Graphes dans Morph-M

Présentations similaires


Présentation au sujet: "Utilisation des Graphes dans Morph-M"— Transcription de la présentation:

1 Utilisation des Graphes dans Morph-M
Jean Stawiaski Centre de Morphologie Mathématique 2 décembre 2008

2 Sommaire Introduction Morph-M (CommonGraph32) et (BoostGraph)
1) Passage Graphe-Image et Image-Graphe 1.1 Graphe d’une image 1.2 Graphe d’une partition Utilisation des Graphes (CommonGraph32) en Python 2.1 Fonctions de base 2.2 Exemples, opérations de base de morphologie mathématique Utilisation des Graphes en C++ 3.1 Création d’un graphe en C++ 3.2 Fonction de base 3.3 Algorithmes 3.4 Exemples Pour aller un peu plus loin Conclusion

3 Introduction : Vocabulaire
Un graphe G est une paire G = (V,E) où V est un ensemble finis appelé nœuds du graphe et E est une ensemble finis appelé les arêtes du graphe. i ei,j j Il est possible de différencier les arêtes ei,j et ej,i, on parle alors de graphes orientés. Il est possible d’associer à un graphe G, un ensemble de valeurs associés aux nœuds ou un ensemble associé aux arêtes. On parle de graphes aux nœuds valués ou bien de graphes aux arêtes valuées.

4 Introduction : BoostGraph
Les graphes de la librairie Boost, dénommés BoostGraph, est une structure générique pouvant représenté à peu près n’importe quel type de graphes. La structure BoostGraph représente des graphes orientés ou non, pouvant être valués aux nœuds et aux arrêtes. La valuation des arrêtes et des nœuds sont aussi représentés par des structures abstraites. BoostGraph Library met à disposition un grand nombre d’algorithmes (Dijkstra, Kruskal, Prim, Ford-Fulkerson, etc.)

5 Introduction : CommonGraph32
Les graphes sous Morph-M sont utilisés à travers la structure appelé CommonGraph32. La structure CommonGraph32 représente un graphe non-orienté, valué aux nœuds et aux arrêtes. La valuation des arrêtes et des nœuds sont des entiers codés sur 32 bits La structure CommonGraph32 est définie à partir de la librairie Boost. La structure CommonGraph32 est accessible en C++ et en Python. La structure CommonGraph32 est utilisée dans Morph-M pour représenter des images et des partitions.

6 1) Passage Graphe-Image et Image-Graphe

7 1) Passage Graphe-Image et Image-Graphe
1.1 Graphe d’une image Passage image graphe. Représentation d’une image par un graphe (nœuds = pixels, arrêtes = relations de voisinage). MorphoGraph.GetPixelGraph(im,nl,G) nl = CrossSE nl = SquareSE Passage graphe image. Projette les valeurs des nœuds sur les pixels de l’image. MorphoGraph.ProjectGraphOnPixel(G,imOut) Projection d’une image sur le graphe. Remplace la valeurs des nœuds du graphe par les valeurs des pixels. MorphoGraph.ProjectMarkersOnPixelGraph(ImIn, Gout)

8 1) Passage Graphe-Image et Image-Graphe
1.2 Graphe d’une partition Passage image graphe. Représentation d’une mosaïque par un graphe (nœuds = régions, arrêtes = relations de voisinage). G = Morphee.NeighborhoodGraphFromMosaic(imMosaic, nl) G = Morphee.NeighborhoodGraphFromMosaicWithPass(imMosaic, imGrad, nl) Passage graphe image. Projette les valeurs des nœuds sur les régions de la mosaïque. Morphee.ProjectGraphOnSegmentation(G, imMosaic,imOut) Projection d’une image sur le graphe. Remplace la valeurs des nœuds du graphe par les valeurs des régions. Morphee.ProjectMarkersOnGraph(Immarkers,imMosaic,Gout)

9 2) Utilisation des Graphes (CommonGraph32) en Python

10 2) Utilisation des (CommonGraph32) en Python
2.1 Fonctions de base La plupart des fonctions associées aux graphes sont accessibles à partir de Morph-M et d’un module spécifique Morpho-Graph : Morph-M contient les outils associés à la segmentation (hiérarchie, mst, graphes de régions, etc.), Morpho-Graph contient des fonctions de base de morphologie mathématique sur les graphes (Erosion, Dilatation, etc.) , ainsi que des fonctions de base pour graphes (labellisation, chemins les plus courts, coupe minimale, flots, etc.).

11 2) Utilisation des (CommonGraph32) en Python
2.1 Fonctions de base Création d’un graphe : G=morphee.CommonGraph32(numVertices) Les nœuds sont accéder par leurs descripteurs v, offset pour les graphes de pixels, labels de la régions -1 pour les graphes de régions) Récupérer le nombre de nœuds G.numVertices() Récupérer la valeur d’un nœud G.getVertexData(v) Imposer la valeur d’un nœud G.setVertexData(v,val) Obtenir les voisins d’un nœud G.getChildren(v1) Récupérer le nombre d’arrêtes G.numEdges() Récupérer la valeur d’une arrête G.getEdgeWeight(v1,v2) Imposer la valeur d’une arrête G.setEdgeWeight(v1,v2,val) Récupérer les arrêtes d’un graphe et leurs valeurs edgeList = G.getEdgesListAndWeights()

12 2) Utilisation des (CommonGraph32) en Python
2.2 Exemples for v1 in range( G.numVertices() ): G.setVertexData( v1, 0 ) edgeList = G.getEdgesListAndWeights() for v1,v2,w in edgeList: G.setEdgeWeight(v1,v2,0) for v1 in range( G.numVertices() ): for v2 in G.getChildren(v1): newVal = max (G.getVertexData(v2), newVal ) G2.setVertexData( v1, newVal )

13 2) Utilisation des (CommonGraph32) en Python
2.2 Exemples edgeList = G.getEdgesListAndWeights() for s,t,w in edgeList: newW = max ( G.getVertexData(s) , G.getVertexData(t) ) G.setEdgeWeight(s,t,newW) for v1 in range( G.numVertices() ): for v2 in G.getChildren(v1): newVal = max ( G.getEdgeWeight( v1, v2 ), newVal ) G.setVertexData( v1, newVal )

14 2) Utilisation des (CommonGraph32) en Python
2.2 Exemples : Opérations de base de morphologie mathématique ErosionNodesToEdges(graphIn,graphOut) DilationNodesToEdges(graphIn,graphOut) ErosionEdgesToNodes(graphIn,graphOut) DilationEdgesToNodes(graphIn,graphOut) ErosionNodesToNodes(graphIn,graphOut) DilationNodesToNodes(graphIn,graphOut) DilationEdgesToEdges(graphIn,graphOut) ErosionEdgesToEdges(graphIn,graphOut)

15 2) Utilisation des (CommonGraph32) en Python
2.2 Exemples def GetGraphFromFlatZones( im, nl ): imLab=morphee.getSameOf(im, morphee.dataCategory.dtScalar, morphee.scalarDataType.sdtUINT32) morphee.ImLabelFlatZones( im, nl, imLab ) G = morphee.NeighborhoodGraphFromMosaic_WithAverageAndDifference(imLab,im, nl ) return G,imLab def GetGraphFromWatershed( imIn, nl): imGrad = morphee.getSame( imIn ) morphee.ImMorphoGradient(imIn,nl,imGrad) imMinima32=morphee.getSameOf(imGrad, morphee.dataCategory.dtScalar, morphee.scalarDataType.sdtUINT32) morphee.ImMinima(imGrad,nl,imMinima32) imLabel32=morphee.getSame(imMinima32) morphee.ImLabel(imMinima32,nl,imLabel32) imWS32=morphee.getSame(imMinima32) morphee.ImBasinsConstrainedNoWSLine_v2(imGrad,imLabel32,nl,imWS32) G = morphee.NeighborhoodGraphFromMosaic_WithPass(imWS32,imGrad, nl ) return G, imWS32

16 2) Utilisation des (CommonGraph32) en Python
2.2 Exemples def GetGraphFromHierarchicalSegmentation( im, nl, numRegions, wsType): imGrad = morphee.getSame(im) morphee.ImMorphoGradient( im, nl, imGrad ) imMinima32=morphee.getSameOf(imGrad, morphee.dataCategory.dtScalar, morphee.scalarDataType.sdtUINT32) morphee.ImMinima(imGrad,nl,imMinima32) imLabel32=morphee.getSame(imMinima32) morphee.ImLabel(imMinima32,nl,imLabel32) imWS32=morphee.getSame(imMinima32) hierGraph=morphee.ImHierarchicalSegmentation32(imGrad,imLabel32,nl,wsType,imWS32) Forest=morphee.ImDisplayHierarchyLevel32(imWS32,hierGraph,numRegions,imOut32) return Forest, imOut32

17 3) Utilisation des Graphes en C++

18 3) Utilisation des Graphes en C++
3.1 Création d’un graphe en C++ avec Boost : Introduction Un graphe est représenté par une liste d’adjacence : Le type des entrées de la liste d’adjacence est spécifié par des paramètres de la classe graphe.

19 3) Utilisation des Graphes en C++
3.1 Création d’un graphe en C++ avec Boost VertexList et OutEdgeList défini le type d’objet utilisé pour décrire le graphe (std::list, set, vect). Ce choix a un impact sur la complexité des algorithmes. Les propriétés du graphe comme les couleurs, les distances, les poids des arrêtes, sont définis par l’utilisateur dans les propriétés VertexProperties, EdgeProperties, GraphProperties. Les propriétés du graphe sont définies en C++ par des std::maps.

20 3) Utilisation des Graphes en C++
3.1 Création d’un graphe en C++ avec Boost Exemple : Graphe non orienté, valué aux arrêtes, et valué aux nœuds par un double. typedef boost::adjacency_list < boost::vecS, boost::vecS, boost::undirectedS, boost::property < boost::vertex_distance_t, double >, boost::property < boost::edge_capacity_t, double > > Graph_d;

21 3) Utilisation des Graphes en C++
3.2 Fonction de base : Méthodes de CommonGraph32 et Boost graph_traits<adjacency_list>::vertex_descriptor graph_traits<adjacency_list>::edge_descriptor graph_traits<adjacency_list>::vertex_iterator boost::tie(v_iter, v_end)= boost::vertices(G) graph_traits<adjacency_list>::edge_iterator boost::tie(e_iter, e_end)=boost::edges(G) graph_traits<adjacency_list>::out_edge_iterator boost::tie(e_iter, e_end)=boost::out_edges(v,G) property_map<adjacency_list, PropertyTag>::type get(PropertyTag, adjacency_list& g)

22 3) Utilisation des Graphes en C++
3.2 Fonction de base : Méthodes de CommonGraph32 et Boost G.edgeFromVertices(v1,v2,&e) v1 = G.edgeSource(e) v2 = G.edgeTarget(e) ( e, in ) = boost::edge(v1,v2,g) boost::source(e,g) Boost::target(e,g) G.vertexData(v, &vdata) G.edgeWeight(e,&edgeweight) G.setVertexData(v,val) G.setEdgeWeight(e, val ) property_map<Graph, edge_capacity_t>::type weight = boost::get(edge_capacity, g); G.removeEdge(v1,v2) G.addEdge(v1,v2) G.addVertex() G.removeVertex(v1) boost::remove_edge( param , g) boost::add_edge(v1,v2,g) boost::add_vertex(g) boost::remove_vertex(v,g) g = G.getBoostGraph()

23 3) Utilisation des Graphes en C++
3.3 Exemples for ( boost::tie(ed_it, ed_end) = boost::edges(GIn.getBoostGraph()) ;ed_it != ed_end ; ++ed_it , ++edout) { GIn.edgeWeight(*ed_it,&tmp); if( tmp > seuil){ Gout.removeEdge( typename Graph::VertexDescriptor(GIn.edgeSource(*ed_it)), typename Graph::VertexDescriptor(GIn.edgeTarget(*ed_it)) ); } morphee::Morpho_Graph::ErosionEdgesToEdges(GIn, GEro); morphee::Morpho_Graph::DilationEdgesToEdges(GIn,GDil); for (boost::tie(ed_it, ed_end)=boost::edges(GIn.getBoostGraph()); ed_it != ed_end ; ++ed_it ) { GIn.edgeWeight(*ed_it,&tmp); GEro.edgeWeight(*edero_it,&tmp1); GDil.edgeWeight(*eddil_it,&tmp2); if(std::abs( (double) tmp - (double) tmp1) <= std::abs( (double) tmp2 - (double) tmp)) Gout.setEdgeWeight( *edout, tmp1 ); else Gout.setEdgeWeight( *edout, tmp2 ); }

24 3) Utilisation des Graphes en C++
3.4 Algorithmes (liste non exhaustive) Breadth First Search Depth First Search Uniform Cost Search Dijkstra's Shortest Paths Bellman-Ford Shortest Paths Johnson's All-Pairs Shortest Paths Kruskal's Minimum Spanning Tree Prim's Minimum Spanning Tree Edmund Karp Maximal flow Tarjan Push relabel max flow Kolmogorov max flow Edmund max cardinality matching Connected Components Strongly Connected Components Sequential Vertex Coloring

25 3) Utilisation des Graphes en C++
3.4 Algorithmes Composantes connexes std::vector<int> component(boost::num_vertices(GIn.getBoostGraph())); int num = connected_components(GIn.getBoostGraph(), &component[0]); for (boost::tie(u_iter, u_end)=boost::vertices(GIn.getBoostGraph()) ; u_iter != u_end; ++u_iter){ Gout.setVertexData(*u_iter,component[*u_iter]); } Arbre de recouvrement 1 std::vector< typename BoostGraph::EdgeDescriptor > v_spanning_tree; boost::kruskal_minimum_spanning_tree( (graphIn).getBoostGraph(), std::back_inserter(v_spanning_tree) ) ; Arbre de recouvrement 2 std::vector< typename BoostGraph::VertexDescriptor > p(boost::num_vertices((graphIn).getBoostGraph()); boost::prim_minimum_spanning_tree( (graphIn).getBoostGraph(), &p[0] ) ;

26 3) Utilisation des Graphes en C++
3.4 Algorithmes Chemins les plus courts boost::property_map< typename BoostGraph, boost::edge_capacity_t>::type weightmap = boost::get(boost::edge_capacity, g ); std::vector < typename BoostGraph::vertex_descriptor > p(boost::num_vertices(g)); boost::property_map < typename BoostGraph, boost::vertex_distance_t>::type distancemap = boost::get(boost::vertex_distance, g); boost::property_map< typename BoostGraph, boost::vertex_index_t>::type indexmap2 = boost::get(boost::vertex_index, g); dijkstra_shortest_paths(g, vRoot, &p[0], distancemap, weightmap, indexmap2, std::less<double>(), boost::closed_plus<double>(), (std::numeric_limits<double>::max)(), 0, boost::default_dijkstra_visitor()); L’Algorithme de Dijkstra permet de calculer les chemins les plus courts dans l’algèbre de chemins ( type distancemap, comparaison, combinaison, 0, infini)

27 3) Utilisation des Graphes en C++
3.4 Algorithmes Flot maximal et coupe minimale boost::property_map<Graph_d, boost::edge_capacity_t>::type capacity = boost::get(boost::edge_capacity, g); boost::property_map<Graph_d, boost::edge_reverse_t>::type rev = get(boost::edge_reverse, g); boost::property_map<Graph_d, boost::edge_residual_capacity_t>::type residual_capacity = get(boost::edge_residual_capacity, g); boost::property_map<Graph_d, boost::vertex_index_t>::type indexmap = boost::get(boost::vertex_index, g); std::vector<boost::default_color_type> color(boost::num_vertices(g)); flow = kolmogorov_max_flow(g, capacity, residual_capacity, rev, &color[0], indexmap, vSource, vSink); Les algorithmes de flots et coupes ne peuvent pas être directement utilisés sur des CommonGraph32….

28 4) Pour aller un peu plus loin…

29 4) Pour aller un peu plus loin…
1) Tirer Avantage de la généricité des algorithmes : Quelle est la différence entre : dijkstra_shortest_paths(g, vRoot, &p[0], distancemap, weightmap, indexmap2, std::less<double>(), boost::closed_plus<double>(), (std::numeric_limits<double>::max)(), 0, boost::default_dijkstra_visitor()); dijkstra_shortest_paths(g, vRoot, &p[0], distancemap, weightmap, indexmap2, std::less<double>(), std::max<double>(), (std::numeric_limits<double>::max)(), 0, boost::default_dijkstra_visitor()); Le seul algorithme de Dijstra permet de calculer les arbres de recouvrement min et max, les chemins les plus courts, les chemins les plus probables, etc.

30 4) Pour aller un peu plus loin…
2) Tirer Avantage de la généricité des structures : typedef std::vector<double> vdouble; typedef boost::adjacency_list < boost::vecS, boost::vecS, boost::undirectedS, boost::property < boost::vertex_distance_t, vdouble >, boost::property < boost::edge_capacity_t, vdouble > > Graph_v; Graph_v est un type de graphe dont les arrêtes sont valués par des vecteurs, et les nœuds valués par des vecteurs. De plus, la taille de ces vecteurs n’est pas défini, et peut donc être variable selon les arrêtes ou selon les nœuds. Graph_v peut être utilisé pour représenter des images multi-valués ou le nombre de canaux varient selon les pixels, ou les disimilarités entre pixels sont représentés par des vecteurs de taille variable.

31 4) Pour aller un peu plus loin…
2) Tirer Avantage de la généricité des structures : typedef std::vector<double> vdouble; typedef boost::adjacency_list < boost::vecS, boost::vecS, boost::undirectedS, boost::property < boost::vertex_distance_t, vdouble >, boost::property < boost::edge_capacity_t, vdouble > > Graph_v; dijkstra_shortest_paths(g, vRoot, &p[0], distancemap, weightmap, indexmap2, boost::detail::lexico_compare< vdouble > () , boost::detail::lexico_addition< vdouble > (), infinite, zero, boost::default_dijkstra_visitor()); Comparaison lexico de vecteurs Concaténation de vecteurs Transformée en distance lexicographique, la distance est donnée par un vecteur de taille variable (la valeur des arrêtes en ordre décroissant le long d’un chemin)

32 4) Pour aller un peu plus loin…
2) Tirer Avantage de la généricité des structures : Dijkstra a été utilisé pour : - distance classique - mst - distance multi-critères lexicographique - distance lexicographique sur image à niveaux de gris - mst sur image couleur (max de deux vecteurs ordonnés) - distance lexicographique sur image couleur - chemins les plus probables - etc.

33 Conclusion

34 Conclusion Le développement actuel du module graphe de Morph-M donne accès à une large gamme d’algorithmes utilisable en C++ et en Python. La librairie Boost évolué régulièrement, nous utilisons actuellement seulement une petite partie des algorithmes codés dans Boost\Graph. Le module Morpho-Graph est en cours de migration (développement de tests unitaires, etc.) La structure de graphe est actuellement la structure la plus générique utilisable pour le traitement d’images (graphes valués par des vecteurs, opérations de voisinage, algorithmes d’optimisation combinatoire, etc.) Développement actuel : Boite à outils pour les arbres (suite du module Morphee\Commontree) LPE stochastique Filtrage topologique des graphes Filtrage par critères Filtre Morphologique etc.

35 Merci pour votre attention
Questions ?


Télécharger ppt "Utilisation des Graphes dans Morph-M"

Présentations similaires


Annonces Google