CarteTopo (GeOxygene 1.9-SNAPSHOT API)

Object
- DataSet
- - CarteTopo

All Implemented Interfaces:

IDataSet<SchemaConceptuelJeu>

Direct Known Subclasses:

AbstractTriangulation, ReseauApp
```
public class CarteTopo
extends DataSet
```
Classe racine de la carte topo. Une carte topo est une composition d'arcs, de noeuds, de faces et de groupes. Une carte topo est vue comme un DataSet particulier. Elle a éventuellement une topologie (SPAGHETTI, NETWORK ou MAP).
English: a topological map is an oriented graph, with arcs sorted around the nodes;

Author:

Sébastien Mustière, Olivier Bonin, Julien Perret

Field Summary

Fields
Modifier and Type	Field and Description
`protected EventListenerList`	`listenerList`
`protected static Logger`	`logger` Logger.
`static int`	`MAP` Network = topologie arc / noeuds / faces
`static int`	`NETWORK` Network = topologie arc / noeuds
`static int`	`SPAGHETTI` Spaghetti = pas de relation topologique entre arcs, noeuds et faces

Fields inherited from class DataSet
commentaire, composants, contraintes, date, db, extractions, id, modele, nom, ojbConcreteClass, persistant, populations, produit, schemaConceptuel, STATICID, typeBD, zone

Constructor Summary

Constructors
Constructor and Description
`CarteTopo()` Constructeur par défaut ; ATTENTION, constructeur à éviter car aucune population n'est créée: seule un objet carteTopo est créé.
`CarteTopo(String nomLogique)` Constructeur d'une carte topo non persistante.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addActionListener(ActionListener l)` Adds an `ActionListener` to the carteTopo.
`void`	`addArc(Arc arc)` Ajoute un arc à la population des arcs de la carte topo.
`void`	`addFace(Face face)` Ajoute une face à la population des faces de la carte topo.
`void`	`addGroupe(Groupe groupe)` Ajoute un groupe à la population des groupes de la carte topo.
`void`	`addMissingEdges(double threshold)` Add the missing edges from the graph.
`void`	`addNoeud(Noeud noeud)` Ajoute un noeud à la population des noeuds de la carte topo.
`void`	`ajouteArcsEtNoeudsAuxFaces(boolean filtrageNoeudsSimples)` Ajoute des arcs et des noeuds à la carteTopo this qui ne contient que des faces.
`void`	`cleanEdges(double tolerance)`
`static void`	`cleanLineString(ILineString line, double tolerance)`
`static List<Cycle>`	`construireGeometrieCycleExterieur(Arc arcInitial, boolean aGauche)` Construire la liste des géométries corrigées d'un cycle.
`CarteTopo`	`copie(String nomLogique)` Copie d'une carte topologique avec toutes les relations topologiques.
`void`	`creeNoeudsManquants(double tolerance)` Crée un nouveau noeud à l'extrémité de chaque arc si il n'y en a pas.
`void`	`creeTopologieArcsNoeuds(double tolerance)` Instancie la topologie de réseau d'une Carte Topo, en se basant sur la géométrie 2D des arcs et des noeuds.
`void`	`creeTopologieFaces()` Crée les faces à partir d'un graphe planaire et instancie la topologie face / arcs.
`void`	`decoupeArcs(double distance)` Découpe les arcs en utilisant les noeuds plus proches des arcs que la distance demandée.
`void`	`enleveArc(Arc arcAEnlever)`
`void`	`enleveArcs(Collection<Arc> arcsAEnlever)` enlève des arcs de la carteTopo, en enlevant aussi les relations topologiques les concernant (avec les faces et noeuds).
`void`	`enleveArcsBoucles()` Enlève les arcs qui forment une boucle, i.e. dont le noeud ini est égal au noeud fin.
`void`	`enleveFaces(Collection<Face> facesAEnlever)` Enlève des faces de la carteTopo, en enlevant aussi les relations topologiques les concernant (avec les arcs et par conséquent avec les noeuds).
`void`	`enleveNoeud(Noeud n)`
`void`	`enleveNoeuds(Collection<Noeud> noeudsAEnlever)` Enlève des noeuds de la carteTopo, en enlevant aussi les relations topologiques les concernant (avec les arcs et par conséquent avec les faces).
`void`	`filtreArcsDoublons()` Filtre les arcs en double (en double = même géométrie et même orientation).
`void`	`filtreArcsDoublons(double toleranceHaussdorf)` Filtre les arcs en double (en double = même géométrie et même orientation).
`void`	`filtreArcsNull(double tolerance)`
`void`	`filtreDoublons(double tolerance)` Filtrage des noeuds doublons (plusieurs noeuds localisés au même endroit).
`void`	`filtreNoeudsIsoles()` Filtrage des noeuds isolés (c'est-à-dire connectés à aucun arc).
`void`	`filtreNoeudsSimples()` Filtrage des noeuds "simples", c'est-à-dire avec seulement deux arcs incidents, si ils ont des orientations compatibles.
`void`	`filtreNoeudsSimples(boolean useWeight, IGeometry filteredArea)`
`void`	`filtreNoeudsSimples(boolean useWeight, IGeometry filteredArea, boolean checkEqualCorrespondants)`
`protected void`	`fireActionPerformed(ActionEvent event)` Notifies all listeners that have registered interest for notification on this event type.
`void`	`fusionNoeuds(double tolerance)` Fusionne en un seul noeud, tous les noeuds proches de moins de "tolerance" Les correspondants suivent, la topologie arcs/noeuds aussi.
`void`	`fusionNoeuds(IPopulation<? extends IFeature> popSurfaces)` Fusionne en un seul noeud, tous les noeuds contenu dans une même surface de la population de surfaces passée en paramètre.
`List<Arc>`	`getListeArcs()` Liste des arcs de la carte topo.
`List<Face>`	`getListeFaces()` Liste des faces de la carte topo.
`List<Groupe>`	`getListeGroupes()` Liste des groupes de la carte topo.
`List<Noeud>`	`getListeNoeuds()` Liste des noeuds de la carte topo.
`IPopulation<Arc>`	`getPopArcs()` Population des arcs de la carte topo.
`IPopulation<Face>`	`getPopFaces()` Population des faces de la carte topo.
`IPopulation<Groupe>`	`getPopGroupes()` Population des groupes de la carte topo.
`IPopulation<Noeud>`	`getPopNoeuds()` Population des noeuds de la carte topo.
`int`	`getType()`
`void`	`importAsNodes(Collection<? extends IFeature> listeFeatures)` Remplit 'this' avec des correspondants des éléments de 'listeFeature'.
`void`	`importAsNodes(IFeatureCollection<?> listeFeatures)` Remplit 'this' avec des correspondants des éléments de 'listeFeature'.
`void`	`importClasseGeo(IFeatureCollection<?> listeFeatures)` Remplit 'this' avec des correspondants des éléments de 'listeFeature'.
`void`	`importClasseGeo(IFeatureCollection<?> listeFeatures, boolean is2d)` Remplit 'this' avec des correspondants des éléments de 'listeFeature'.
`void`	`importClasseGeo(String nomClasseGeo)` Charge en mémoire les éléments de la classe 'nomClasseGeo' et remplit 'this' avec des correspondants de ces éléments.
`void`	`initialisePoids()` Initialise le poids de chaque arc comme étant égal à sa longueur; NB: utile uniquement aux plus courts chemins
`boolean`	`isBuildInfiniteFace()`
`void`	`marquerCycle(Cycle cycle, Face face)` Affecter la face passée en paramètre aux arcs du cycle
`void`	`marquerCycle(List<Arc> arcs, List<Boolean> orientations, boolean aGauche, Face face, List<Arc> arcsDejaTraitesAGauche, List<Arc> arcsDejaTraitesADroite)` Affecter la face passée en paramètre aux arcs parcourus
`void`	`nettoyer()` Nettoie les pointeurs de la carte topo pour assurer une bonne liberation de la memoire A utiliser lorsque'on souhaite effacer une carte topo.
`void`	`projete(CarteTopo ct, double distanceMaxNoeudArc, double distanceMaxProjectionNoeud, boolean impassesSeulement)` Découpe la carte topo this en fonction des noeuds d'une autre carte topo (ct).
`void`	`projete(List<IPoint> pts, double distanceMaxNoeudArc, double distanceMaxProjectionNoeud)` Découpe la carte topo this en fonction d'un ensemble de points (GM_Point).
`void`	`projeteTousLesPoints(CarteTopo ct, double distanceMaxNoeudArc, double distanceMaxProjectionNoeud)` Découpe la carte topo this en fonction de tous les points (noeuds et points intermediaires) d'une autre carte topo (ct).
`void`	`rendPlanaire(double tolerance)` Transforme la carte topo pour la rendre planaire : les arcs sont découpés à chaque intersection d'arcs, et un noeud est créé à chaque extrémité d'arc.
`void`	`setActionListeners(EventListenerList listenerList)` Sets the list of action listeners.
`void`	`setBuildInfiniteFace(boolean buildInfiniteFace)`
`void`	`setType(int i)`
`Groupe`	`shortestPath(IDirectPosition x1, IDirectPosition x2, Arc a1, Arc a2, double max)`
`Noeud`	`splitEdge(Arc a, IDirectPosition p)`
`void`	`splitEdgesWithPoints(double distance)` Découpe les arcs en utilisant les points plus proches des arcs que la distance demandée.
`void`	`videTopologieFace(Face face)` détruit les relations topologique d'une face avec tous ses arcs entourants

Methods inherited from class DataSet
addComposant, addExtraction, addPopulation, chargeElements, chargeElementsPartie, chargeElementsPartie, chargeExtractionThematiqueEtSpatiale, detruitJeu, emptyComposants, emptyPopulations, getAppartientA, getAppartientAID, getCommentaire, getComposant, getComposant, getComposants, getContraintes, getDate, getExtractions, getId, getInstance, getModele, getNom, getOjbConcreteClass, getPersistant, getPopulation, getPopulation, getPopulationByFeatureTypeName, getPopulations, getProduit, getSchemaConceptuel, getTypeBD, getZone, initPopulations, removeComposant, removePopulation, setAppartientA, setAppartientAID, setCommentaire, setComposants, setContraintes, setDate, setExtractions, setId, setModele, setNom, setOjbConcreteClass, setPersistant, setPopulations, setProduit, setSchemaConceptuel, setTypeBD, setZone, toString

Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - logger
```
protected static final Logger logger
```
    Logger.
  - listenerList
```
protected EventListenerList listenerList
```
  - SPAGHETTI
```
public static final int SPAGHETTI
```
    Spaghetti = pas de relation topologique entre arcs, noeuds et faces
    
    See Also:
    
    Constant Field Values
  - NETWORK
```
public static final int NETWORK
```
    Network = topologie arc / noeuds
    
    See Also:
    
    Constant Field Values
  - MAP
```
public static final int MAP
```
    Network = topologie arc / noeuds / faces
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - CarteTopo
```
public CarteTopo()
```
    Constructeur par défaut ; ATTENTION, constructeur à éviter car aucune population n'est créée: seule un objet carteTopo est créé. Ce constructeur sert aux constructeurs des sous-classe de la CarteTopo.
  - CarteTopo
```
public CarteTopo(String nomLogique)
```
    Constructeur d'une carte topo non persistante. Le nom logique peut être utilisé si la carte topo apparient à un DataSet, il peut être une chaîne vide sinon. Par ce constructeur, la carte topo contient des arcs/noeuds/faces/groupes des classes CarteTopo.Arc, CarteTopo.Noeud, CarteTopo.Face, CarteTopo.Groupe.
    
    Parameters:
    
    nomLogique - nom de la carte topo
- Method Detail
  - addActionListener
```
public void addActionListener(ActionListener l)
```
    Adds an ActionListener to the carteTopo.
    
    Parameters:
    
    l - the ActionListener to be added
  - setActionListeners
```
public void setActionListeners(EventListenerList listenerList)
```
    Sets the list of action listeners.
    
    Parameters:
    
    listenerList - list of action listeners
  - fireActionPerformed
```
protected void fireActionPerformed(ActionEvent event)
```
    Notifies all listeners that have registered interest for notification on this event type. The event instance is lazily created.
    
    See Also:
    
    EventListenerList
  - getPopArcs
```
public IPopulation<Arc> getPopArcs()
```
    Population des arcs de la carte topo.
  - getPopNoeuds
```
public IPopulation<Noeud> getPopNoeuds()
```
    Population des noeuds de la carte topo.
  - getPopFaces
```
public IPopulation<Face> getPopFaces()
```
    Population des faces de la carte topo.
  - getPopGroupes
```
public IPopulation<Groupe> getPopGroupes()
```
    Population des groupes de la carte topo.
  - getListeNoeuds
```
public List<Noeud> getListeNoeuds()
```
    Liste des noeuds de la carte topo. Surcharge de getPopNoeuds().getElements().
  - getListeArcs
```
public List<Arc> getListeArcs()
```
    Liste des arcs de la carte topo. Surcharge de getPopArcs().getElements().
  - getListeFaces
```
public List<Face> getListeFaces()
```
    Liste des faces de la carte topo. Surcharge de getPopFaces().getElements().
  - getListeGroupes
```
public List<Groupe> getListeGroupes()
```
    Liste des groupes de la carte topo. Surcharge de getPopGroupes().getElements().
  - addNoeud
```
public void addNoeud(Noeud noeud)
```
    Ajoute un noeud à la population des noeuds de la carte topo. Attention : même si la carte topo est persistante, le noeud n'est pas rendu persistant dans cette méthode
  - addArc
```
public void addArc(Arc arc)
```
    Ajoute un arc à la population des arcs de la carte topo. Attention : même si la carte topo est persistante, le noeud n'est pas rendu persistant dans cette méthode
  - addFace
```
public void addFace(Face face)
```
    Ajoute une face à la population des faces de la carte topo. Attention : même si la carte topo est persistante, le noeud n'est pas rendu persistant dans cette méthode
  - addGroupe
```
public void addGroupe(Groupe groupe)
```
    Ajoute un groupe à la population des groupes de la carte topo. Attention : même si la carte topo est persistante, le noeud n'est pas rendu persistant dans cette méthode
  - isBuildInfiniteFace
```
public boolean isBuildInfiniteFace()
```
  - setBuildInfiniteFace
```
public void setBuildInfiniteFace(boolean buildInfiniteFace)
```
  - getType
```
public int getType()
```
  - setType
```
public void setType(int i)
```
  - copie
```
public CarteTopo copie(String nomLogique)
```
    Copie d'une carte topologique avec toutes les relations topologiques. Les liens "correspondants" sont aussi dupliqués. ATTENTION: ne fonctionne bien que pour une carteTopo non spécialisée (i.e. avec carteTopo.Arc, carte.Noeud...). En effet, les objets copiés appartiendront au package cartetopo.
    
    Parameters:
    
    nomLogique - nom de la carte topo
    
    Returns:
    
    une copie d'une carte topologique avec toutes les relations topologiques.
  - enleveArcs
```
public void enleveArcs(Collection<Arc> arcsAEnlever)
```
    enlève des arcs de la carteTopo, en enlevant aussi les relations topologiques les concernant (avec les faces et noeuds).
    
    Parameters:
    
    arcsAEnlever - liste des arcs à enlever de la carte topo
  - enleveArc
```
public void enleveArc(Arc arcAEnlever)
```
  - enleveArcsBoucles
```
public void enleveArcsBoucles()
```
    Enlève les arcs qui forment une boucle, i.e. dont le noeud ini est égal au noeud fin.
  - enleveNoeuds
```
public void enleveNoeuds(Collection<Noeud> noeudsAEnlever)
```
    Enlève des noeuds de la carteTopo, en enlevant aussi les relations topologiques les concernant (avec les arcs et par conséquent avec les faces).
    
    Parameters:
    
    noeudsAEnlever - noeuds à enlever de la carte topo
  - enleveFaces
```
public void enleveFaces(Collection<Face> facesAEnlever)
```
    Enlève des faces de la carteTopo, en enlevant aussi les relations topologiques les concernant (avec les arcs et par conséquent avec les noeuds).
    
    Parameters:
    
    facesAEnlever - liste des face à enlever de la carte topo
  - creeTopologieArcsNoeuds
```
public void creeTopologieArcsNoeuds(double tolerance)
```
    Instancie la topologie de réseau d'une Carte Topo, en se basant sur la géométrie 2D des arcs et des noeuds. Autrement dit: crée les relation "noeud initial" et "noeud final" d'un arc.
    - ATTENTION: cette méthode ne rajoute pas de noeuds. Si un arc n'a pas de noeud localisé à son extrémité, il n'aura pas de noeud initial (ou final).
    - DE PLUS si plusieurs noeuds sont trop proches (cf. param tolérance), alors un des noeuds est choisi au hasard pour la relation arc/noeud, ce qui n'est pas correct.
    - IL EST DONC CONSEILLE DE FILTRER LES DOUBLONS AVANT SI NECESSAIRE.
    - NB: si cela n'avait pas été fait avant, la population des noeuds est indexée dans cette méthode (dallage, paramètre = 20).
    Parameters:
    
    tolerance - Le paramètre "tolerance" spécifie la distance maximale acceptée entre la position d'un noeud et la position d'une extrémité de ligne, pour considérer ce noeud comme extrémité (la tolérance peut être nulle).
  - creeNoeudsManquants
```
public void creeNoeudsManquants(double tolerance)
```
    Crée un nouveau noeud à l'extrémité de chaque arc si il n'y en a pas. Les noeuds existants sont tous conservés.
    - NB: la topologie arcs/noeuds est instanciée au passage.
    - NB: si cela n'avait pas été fait avant, la population des noeuds est indexée dans cette méthode.
    - Paramètres de l'index = le même que celui des arcs si il existe, sinon Dallage avec à peu près 50 noeuds par dalle.
    Parameters:
    
    tolerance - tolérance utilisée pour chercher des noeuds existants auxquels se raccrocher au lieu d'en créer de nouveaux.
  - filtreNoeudsIsoles
```
public void filtreNoeudsIsoles()
```
    Filtrage des noeuds isolés (c'est-à-dire connectés à aucun arc). Ceux-ci sont enlevés de la Carte Topo IMPORTANT : La topologie de réseau doit avoir été instanciée, sinon tous les noeuds sont enlevés.
  - filtreArcsNull
```
public void filtreArcsNull(double tolerance)
```
    Parameters:
    
    tolerance -
  - filtreDoublons
```
public void filtreDoublons(double tolerance)
```
    Filtrage des noeuds doublons (plusieurs noeuds localisés au même endroit).
    - NB: si cela n'avait pas été fait avant, la population des noeuds est indexée dans cette méthode (dallage, paramètre = 20).
    - Cette méthode gère les conséquences sur la topologie, si celle-ci a été instanciée auparavant.
    - Cette méthode gère aussi les conséquences sur les correspondants (un noeud gardé a pour correspondants tous les correspondants des doublons).
    Parameters:
    
    tolerance - Le paramètre tolérance spécifie la distance maximale pour considérer deux noeuds positionnés au même endroit.
  - filtreNoeudsSimples
```
public void filtreNoeudsSimples()
```
    Filtrage des noeuds "simples", c'est-à-dire avec seulement deux arcs incidents, si ils ont des orientations compatibles. Ces noeuds sont enlevés et un seul arc est créé à la place des deux arcs incidents.
    - Cette méthode gère les conséquences sur la topologie arcs/noeuds/faces.
    - Cette méthode gère aussi les conséquences sur les correspondants. (un nouvel arc a pour correspondants tous les correspondants des deux arcs incidents).
    - Cette méthode gère les conséquences sur l'orientation
    IMPORTANT: la topologie arcs/noeuds doit avoir été instanciée avant de lancer cette méthode
  - filtreNoeudsSimples
```
public void filtreNoeudsSimples(boolean useWeight,
                                IGeometry filteredArea)
```
  - filtreNoeudsSimples
```
public void filtreNoeudsSimples(boolean useWeight,
                                IGeometry filteredArea,
                                boolean checkEqualCorrespondants)
```
  - filtreArcsDoublons
```
public void filtreArcsDoublons()
```
    Filtre les arcs en double (en double = même géométrie et même orientation). On vérifie à la fois la géométrie et la topologie, i.e. la topologie arcs/noeuds doit être instanciée.
    Attention: les conséquences sur la topologie arcs/faces ne sont pas gérées.
    TODO s'il existe des arcs en plus de 2 exemplaires, ils ne sont pas enlevés je crois
  - filtreArcsDoublons
```
public void filtreArcsDoublons(double toleranceHaussdorf)
```
    Filtre les arcs en double (en double = même géométrie et même orientation). On vérifie à la fois la géométrie et la topologie, i.e. la topologie arcs/noeuds doit être instanciée.
    Attention: les conséquences sur la topologie arcs/faces ne sont pas gérées.
    TODO s'il existe des arcs en plus de 2 exemplaires, ils ne sont pas enlevés je crois
  - cleanEdges
```
public void cleanEdges(double tolerance)
```
  - cleanLineString
```
public static void cleanLineString(ILineString line,
                                   double tolerance)
```
  - rendPlanaire
```
public void rendPlanaire(double tolerance)
```
    Transforme la carte topo pour la rendre planaire : les arcs sont découpés à chaque intersection d'arcs, et un noeud est créé à chaque extrémité d'arc.
    - NB: la topologie arcs/noeuds de la carte en sortie est instanciée.
    - NB: les populations d'arcs et de noeuds sont indexées pendant la méthode, si cela n'avait pas déjà été fait avant. Les paramètres de ces index sont: 20x20 cases pour les noeuds, ~50 arcs par case pour les arcs. Si cela ne convient pas: instancier les topologies avant.
    - NB: les "correspondants" des arcs et noeuds suivent le découpage, de même que l'attribut orientation.
    - MAIS ATTENTION:
      
      - les liens vers des groupes ne suivent pas.
      - les attributs/liens particuliers (cas où les arcs proviennent d'une carteTopo spécialisée) ne suivent pas non plus
      - la topologie des faces est détruite aussi
    Parameters:
    
    tolerance - paramètre de tolérance sur la localisation des noeuds: deux extrémités d'arc à moins de cette distance sont considérées superposées (utilisé lors de la construction de la topologie arcs/noeuds). Ce paramètre peut être nul.
  - fusionNoeuds
```
public void fusionNoeuds(double tolerance)
```
    Fusionne en un seul noeud, tous les noeuds proches de moins de "tolerance" Les correspondants suivent, la topologie arcs/noeuds aussi. NB: les petits arcs qui n'ont plus de sens sont aussi éliminés. Plus précisément ce sont ceux qui partent et arrivent sur un même nouveau noeud créé, et restant à moins de "tolerance" de ce nouveau noeud Un index spatial (dallage) est créé si cela n'avait pas été fait avant, mais il est toujours conseillé de le faire en dehors de cette méthode, pour controler la taille du dallage.
    
    Parameters:
    
    tolerance - tolérance en dessous de laquelle les noeuds sont fusionés
  - fusionNoeuds
```
public void fusionNoeuds(IPopulation<? extends IFeature> popSurfaces)
```
    Fusionne en un seul noeud, tous les noeuds contenu dans une même surface de la population de surfaces passée en paramètre. Les correspondants suivent, la topologie arcs/noeuds aussi.
    NB: les petits arcs qui n'ont plus de sens sont aussi éliminés. Plus précisément ce sont ceux qui partent et arrivent sur un même nouveau noeud créé, et restant dans la surface de fusion. Un index spatial (dallage) est créé si cela n'avait pas été fait avant, mais il est toujours conseillé de le faire en dehors de cette méthode, pour controler la taille du dallage.
    
    Parameters:
    
    popSurfaces - population contenant les surface à fusionner en un seul noeud
  - projete
```
public void projete(CarteTopo ct,
                    double distanceMaxNoeudArc,
                    double distanceMaxProjectionNoeud,
                    boolean impassesSeulement)
```
    Découpe la carte topo this en fonction des noeuds d'une autre carte topo (ct).
    En détail: Pour chaque noeud N de la carte topo en entrée, on prend chaque arc de this qui en est proche (c'est-à-dire à moins de distanceMaxNoeudArc). Si aucune des extrémités de cet arc est à moins de distanceMaxProjectionNoeud du noeud N, alors on découpe l'arc en y projetant le noeud N.
    Si impassesSeulement = true: seules les noeuds N extrémités d'impasse peuvent être projetées La topologie arcs/noeuds, l'orientation et les correspondants suivent. Les arcs de this sont indexés au passage si cela n'avait pas été fait avant.
  - projeteTousLesPoints
```
public void projeteTousLesPoints(CarteTopo ct,
                                 double distanceMaxNoeudArc,
                                 double distanceMaxProjectionNoeud)
```
    Découpe la carte topo this en fonction de tous les points (noeuds et points intermediaires) d'une autre carte topo (ct).
    En détail: Pour chaque point P de la carte topo en entrée, on prend chaque arc de this qui en est proche (c'est-à-dire à moins de distanceMaxNoeudArc). Si aucune des extrémités de cet arc est à moins de distanceMaxProjectionNoeud du noeud P, alors on découpe l'arc en y projetant le noeud P. La topologie arcs/noeuds, l'orientation et les correspondants suivent. Les arcs de this sont indexés au passage si cela n'avait pas été fait avant.
  - projete
```
public void projete(List<IPoint> pts,
                    double distanceMaxNoeudArc,
                    double distanceMaxProjectionNoeud)
```
    Découpe la carte topo this en fonction d'un ensemble de points (GM_Point).
    En détail: Pour chaque point en entrée, on prend chaque arc de this qui en est proche (c'est-à-dire à moins de distanceMaxNoeudArc). Si aucune des extrémités de cet arc est à moins de distanceMaxProjectionNoeud du noeud N, alors on découpe l'arc en y projetant le noeud N.
    La topologie arcs/noeuds, l'orientation et les correspondants suivent.
  - creeTopologieFaces
```
public void creeTopologieFaces()
```
    Crée les faces à partir d'un graphe planaire et instancie la topologie face / arcs. Une face est délimitée par un cycle minimal du graphe.
    Le paramètre persistant spécifie si les faces créées, ainsi que la topologie, sont rendus persistants. Si oui, il faut appeler cette méthode dans une transaction ouverte.
    - NB1 : la topologie de réseau arcs/noeuds doit avoir été instanciée.
    - NB2 : une face "extérieure" est créée (sa géométrie entoure le "trou" de l'extérieur qu'est le réseau. Donc, dans le cas d'une topologie complete arcs/faces, tous les arcs ont une face gauche et une face à droite.
    - NB3 : ATTENTION : en cas d'un réseau non connexe, une face extérieure différente est crée pour chaque partie connexe !
    - NB4 : Les culs de sac ont la même face à gauche et à droite, et la face "longe le cul de sac";
    - NB5 : méthode en théorie conçue pour les graphes planaires uniquement (testée dans ce cadre uniquement). La méthode est en théorie valable pour les graphes non planaires, mais les faces créées seront étranges (on ne recrée pas les intersections manquantes, on les ignore). Si il existe des arcs sans noeud initial ou final (topologie de réseau pas complete), alors ces arcs n'ont ni face à gauche, ni face à droite
    Depuis la version 1.6 la géométrie des faces est corrigée et n'inclue donc plus un aller-retour sur les culs-de-sac. Les trous sont aussi ajoutés à la géométrie des faces.
  - construireGeometrieCycleExterieur
```
public static List<Cycle> construireGeometrieCycleExterieur(Arc arcInitial,
                                                            boolean aGauche)
```
    Construire la liste des géométries corrigées d'un cycle.
    
    Parameters:
    
    arcInitial - premier arc du cycle
    
    aGauche - vrai si ce cycle parcours son premier arc à gauche, faux sinon
    
    Returns:
    
    la liste des géométries corrigées du cycle
  - videTopologieFace
```
public void videTopologieFace(Face face)
```
    détruit les relations topologique d'une face avec tous ses arcs entourants
    
    Parameters:
    
    face - face dont la topologie doit être vidée
  - ajouteArcsEtNoeudsAuxFaces
```
public void ajouteArcsEtNoeudsAuxFaces(boolean filtrageNoeudsSimples)
```
    Ajoute des arcs et des noeuds à la carteTopo this qui ne contient que des faces. Ces arcs sont les arcs entourant les faces. Les relations topologiques arcs/noeuds/surfaces sont instanciées au passage. Les trous sont gérés. Les faces en entrée peuvent avoir une orientation quelconque (direct), cela est géré. Par contre, on ne s'appuie que sur les points intermédiaires existants dans les polygones des faces : les relations topologiques sont donc bien gérés uniquement si les polygones ont des géométrie "compatibles".
    
    Parameters:
    
    filtrageNoeudsSimples - Si ce paramètre est égal à false, alors on crée un arc et deux noeuds pour chaque segment reliant des points intermédiaires des surfaces. Si ce paramètre est égal à true, alors on fusionne les arcs et on ne retient que les noeuds qui ont 3 arcs incidents ou qui servent de point initial/final à une face.
  - addMissingEdges
```
public void addMissingEdges(double threshold)
```
    Add the missing edges from the graph.
  - initialisePoids
```
public void initialisePoids()
```
    Initialise le poids de chaque arc comme étant égal à sa longueur; NB: utile uniquement aux plus courts chemins
  - importClasseGeo
```
public void importClasseGeo(String nomClasseGeo)
```
    Charge en mémoire les éléments de la classe 'nomClasseGeo' et remplit 'this' avec des correspondants de ces éléments.
    
    Parameters:
    
    nomClasseGeo - nom de la classe des éléments à importer
  - importClasseGeo
```
public void importClasseGeo(IFeatureCollection<?> listeFeatures)
```
    Remplit 'this' avec des correspondants des éléments de 'listeFeature'.
    
    Parameters:
    
    listeFeatures - liste des éléments à importer
  - importClasseGeo
```
public void importClasseGeo(IFeatureCollection<?> listeFeatures,
                            boolean is2d)
```
    Remplit 'this' avec des correspondants des éléments de 'listeFeature'. Cette version de la méthode autorise la conversion des données en 2D.
    
    Parameters:
    
    listeFeatures - liste des éléments à importer
    
    is2d - si vrai, alors convertir les géométries en 2d
  - importAsNodes
```
public void importAsNodes(Collection<? extends IFeature> listeFeatures)
```
    Remplit 'this' avec des correspondants des éléments de 'listeFeature'. Seuls les points des éléments sont importés comme noeuds de la carte.
    
    Parameters:
    
    listeFeatures - liste des éléments à importer
  - importAsNodes
```
public void importAsNodes(IFeatureCollection<?> listeFeatures)
```
    Remplit 'this' avec des correspondants des éléments de 'listeFeature'. Seuls les points des éléments sont importés comme noeuds de la carte.
    
    Parameters:
    
    listeFeatures - liste des éléments à importer
  - marquerCycle
```
public void marquerCycle(Cycle cycle,
                         Face face)
```
    Affecter la face passée en paramètre aux arcs du cycle
    
    Parameters:
    
    cycle - cycle à parcourir afin d'affecter une face à ses arcs
    
    face - face à affecter aux arcs
  - marquerCycle
```
public void marquerCycle(List<Arc> arcs,
                         List<Boolean> orientations,
                         boolean aGauche,
                         Face face,
                         List<Arc> arcsDejaTraitesAGauche,
                         List<Arc> arcsDejaTraitesADroite)
```
    Affecter la face passée en paramètre aux arcs parcourus
    
    Parameters:
    
    arcs - arcs à parcourir
    
    orientations - orientations respectives des arcs
    
    aGauche - vrai si le premier arc est parcourus par la gauche, faux s'il est parcouru par la droite
    
    face - face à affecter aux arcs (du côté déterminé par l'orientation et la valeur de aGauche)
    
    arcsDejaTraitesAGauche - liste des arcs déjà traités à gauche à maintenir
    
    arcsDejaTraitesADroite - liste des arcs déjà traités à droite à maintenir
  - nettoyer
```
public void nettoyer()
```
    Nettoie les pointeurs de la carte topo pour assurer une bonne liberation de la memoire A utiliser lorsque'on souhaite effacer une carte topo.
  - enleveNoeud
```
public void enleveNoeud(Noeud n)
```
  - decoupeArcs
```
public void decoupeArcs(double distance)
```
    Découpe les arcs en utilisant les noeuds plus proches des arcs que la distance demandée.
    
    Parameters:
    
    distance - distance utilisée pour sélectionner les noeuds avec lesquels découpe
  - splitEdgesWithPoints
```
public void splitEdgesWithPoints(double distance)
```
    Découpe les arcs en utilisant les points plus proches des arcs que la distance demandée.
    
    Parameters:
    
    distance - distance utilisée pour sélectionner les points avec lesquels découpe
  - splitEdge
```
public Noeud splitEdge(Arc a,
                       IDirectPosition p)
```
  - shortestPath
```
public Groupe shortestPath(IDirectPosition x1,
                           IDirectPosition x2,
                           Arc a1,
                           Arc a2,
                           double max)
```

Class CarteTopo

Field Summary

Fields inherited from class DataSet

Constructor Summary

Method Summary

Methods inherited from class DataSet

Methods inherited from class Object

Field Detail

logger

listenerList

SPAGHETTI

NETWORK

MAP

Constructor Detail

CarteTopo

CarteTopo

Method Detail

addActionListener

setActionListeners

fireActionPerformed

getPopArcs

getPopNoeuds

getPopFaces

getPopGroupes

getListeNoeuds

getListeArcs

getListeFaces

getListeGroupes

addNoeud

addArc

addFace

addGroupe

isBuildInfiniteFace

setBuildInfiniteFace

getType

setType

copie

enleveArcs

enleveArc

enleveArcsBoucles

enleveNoeuds

enleveFaces

creeTopologieArcsNoeuds

creeNoeudsManquants

filtreNoeudsIsoles

filtreArcsNull

filtreDoublons

filtreNoeudsSimples

filtreNoeudsSimples

filtreNoeudsSimples

filtreArcsDoublons

filtreArcsDoublons

cleanEdges

cleanLineString

rendPlanaire

fusionNoeuds

fusionNoeuds

projete

projeteTousLesPoints

projete

creeTopologieFaces

construireGeometrieCycleExterieur

videTopologieFace

ajouteArcsEtNoeudsAuxFaces

addMissingEdges

initialisePoids

importClasseGeo

importClasseGeo

importClasseGeo

importAsNodes

importAsNodes

marquerCycle

marquerCycle

nettoyer

enleveNoeud

decoupeArcs

splitEdgesWithPoints

splitEdge

shortestPath