001: /*
002: * This file is part of the GeOxygene project source files.
003: *
004: * GeOxygene aims at providing an open framework which implements OGC/ISO specifications for
005: * the development and deployment of geographic (GIS) applications. It is a open source
006: * contribution of the COGIT laboratory at the Institut Géographique National (the French
007: * National Mapping Agency).
008: *
009: * See: http://oxygene-project.sourceforge.net
010: *
011: * Copyright (C) 2005 Institut Géographique National
012: *
013: * This library is free software; you can redistribute it and/or modify it under the terms
014: * of the GNU Lesser General Public License as published by the Free Software Foundation;
015: * either version 2.1 of the License, or any later version.
016: *
017: * This library is distributed in the hope that it will be useful, but WITHOUT ANY
018: * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
019: * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
020: *
021: * You should have received a copy of the GNU Lesser General Public License along with
022: * this library (see file LICENSE if present); if not, write to the Free Software
023: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
024: *
025: */
026:
027: package fr.ign.cogit.geoxygene.contrib.appariement.reseaux;
028:
029: import java.util.ArrayList;
030: import java.util.HashSet;
031: import java.util.Iterator;
032: import java.util.List;
033: import java.util.Set;
034:
035: import fr.ign.cogit.geoxygene.contrib.appariement.EnsembleDeLiens;
036: import fr.ign.cogit.geoxygene.contrib.appariement.Lien;
037: import fr.ign.cogit.geoxygene.contrib.appariement.reseaux.topologie.ArcApp;
038: import fr.ign.cogit.geoxygene.contrib.appariement.reseaux.topologie.GroupeApp;
039: import fr.ign.cogit.geoxygene.contrib.appariement.reseaux.topologie.NoeudApp;
040: import fr.ign.cogit.geoxygene.contrib.appariement.reseaux.topologie.ReseauApp;
041: import fr.ign.cogit.geoxygene.contrib.cartetopo.Arc;
042: import fr.ign.cogit.geoxygene.contrib.cartetopo.Groupe;
043: import fr.ign.cogit.geoxygene.contrib.cartetopo.Noeud;
044: import fr.ign.cogit.geoxygene.contrib.geometrie.Operateurs;
045: import fr.ign.cogit.geoxygene.feature.FT_Feature;
046: import fr.ign.cogit.geoxygene.feature.FT_FeatureCollection;
047: import fr.ign.cogit.geoxygene.spatial.coordgeom.DirectPosition;
048: import fr.ign.cogit.geoxygene.spatial.coordgeom.GM_LineString;
049: import fr.ign.cogit.geoxygene.spatial.geomaggr.GM_Aggregate;
050: import fr.ign.cogit.geoxygene.spatial.geomprim.GM_Point;
051: import fr.ign.cogit.geoxygene.spatial.geomroot.GM_Object;
052:
053: /**
054: * Resultats de l'appariement, qui sont des liens entre objets de BDref et objets de BDcomp.
055: * Un lien a aussi une géométrie qui est sa représentation graphique.
056: *
057: * @author Mustiere - IGN / Laboratoire COGIT
058: * @version 1.0
059: *
060: */
061:
062: public class LienReseaux extends Lien {
063:
064: /** Nom de l'appariement qui a créé le lien */
065: private String nom;
066:
067: public String getNom() {
068: return nom;
069: }
070:
071: public void setNom(String nom) {
072: this .nom = nom;
073: }
074:
075: /** Les Arc1 pointés par le lien */
076: private List arcs1 = new ArrayList();
077:
078: public List getArcs1() {
079: return arcs1;
080: }
081:
082: public void setArcs1(List arcs) {
083: arcs1 = arcs;
084: }
085:
086: public void addArcs1(Arc arc) {
087: arcs1.add(arc);
088: }
089:
090: /** Les Noeud1 pointés par le lien */
091: private List noeuds1 = new ArrayList();
092:
093: public List getNoeuds1() {
094: return noeuds1;
095: }
096:
097: public void setNoeuds1(List noeuds) {
098: noeuds1 = noeuds;
099: }
100:
101: public void addNoeuds1(Noeud noeud) {
102: noeuds1.add(noeud);
103: }
104:
105: /** Les Groupe1 pointés par le lien */
106: private List groupes1 = new ArrayList();
107:
108: public List getGroupes1() {
109: return groupes1;
110: }
111:
112: public void setGroupes1(List groupes) {
113: groupes1 = groupes;
114: }
115:
116: public void addGroupes1(Groupe groupe) {
117: groupes1.add(groupe);
118: }
119:
120: /** Les Arc2 pointés par le lien */
121: private List arcs2 = new ArrayList();
122:
123: public List getArcs2() {
124: return arcs2;
125: }
126:
127: public void setArcs2(List arcs) {
128: arcs2 = arcs;
129: }
130:
131: public void addArcs2(Arc arc) {
132: arcs2.add(arc);
133: }
134:
135: /** Les Noeud2 pointés par le lien */
136: private List noeuds2 = new ArrayList();
137:
138: public List getNoeuds2() {
139: return noeuds2;
140: }
141:
142: public void setNoeuds2(List noeuds) {
143: noeuds2 = noeuds;
144: }
145:
146: public void addNoeuds2(Noeud noeud) {
147: noeuds2.add(noeud);
148: }
149:
150: /** Les Groupe2 pointés par le lien */
151: private List groupes2 = new ArrayList();
152:
153: public List getGroupes2() {
154: return groupes2;
155: }
156:
157: public void setGroupes2(List groupes) {
158: groupes2 = groupes;
159: }
160:
161: public void addGroupes2(Groupe groupe) {
162: groupes2.add(groupe);
163: }
164:
165: /** Methode qui affecte la valeur 'eval' comme évaluation du lien et
166: * le commentaire 'commentaire' à tous les objets liés par ce lien.
167: */
168: public void affecteEvaluationAuxObjetsLies(double eval,
169: String commentaire) {
170: this .setEvaluation(eval);
171: Iterator itObj;
172:
173: itObj = this .getArcs2().iterator();
174: while (itObj.hasNext()) {
175: ArcApp arc = (ArcApp) itObj.next();
176: arc.setResultatAppariement(commentaire);
177: }
178: itObj = this .getArcs1().iterator();
179: while (itObj.hasNext()) {
180: ArcApp arc = (ArcApp) itObj.next();
181: arc.setResultatAppariement(commentaire);
182: }
183: itObj = this .getNoeuds2().iterator();
184: while (itObj.hasNext()) {
185: NoeudApp noeud = (NoeudApp) itObj.next();
186: noeud.setResultatAppariement(commentaire);
187: }
188: itObj = this .getNoeuds1().iterator();
189: while (itObj.hasNext()) {
190: NoeudApp noeud = (NoeudApp) itObj.next();
191: noeud.setResultatAppariement(commentaire);
192: }
193: itObj = this .getGroupes2().iterator();
194: while (itObj.hasNext()) {
195: GroupeApp groupe = (GroupeApp) itObj.next();
196: groupe.setResultatAppariement(commentaire);
197: }
198: itObj = this .getGroupes1().iterator();
199: while (itObj.hasNext()) {
200: GroupeApp groupe = (GroupeApp) itObj.next();
201: groupe.setResultatAppariement(commentaire);
202: }
203: }
204:
205: /** Méthode qui renvoie en sortie des liens génériques (appariement.Lien, liens 1-1 uniquement)
206: * correspondant aux lienReseaux en entrée.
207: * Cette méthode crée une géoémtrie aux liens au passage
208: */
209: public static EnsembleDeLiens exportLiensAppariement(
210: EnsembleDeLiens liensReseaux, ReseauApp ctRef,
211: ParametresApp param) {
212: Lien lienG;
213: Iterator itObjets2, itObjets1;
214: EnsembleDeLiens liensGeneriques;
215:
216: liensGeneriques = new EnsembleDeLiens();
217: liensGeneriques.setNom(liensReseaux.getNom());
218:
219: // On compile toutes les populations du reseau 1 [resp. 2] dans une liste
220: List pops1 = new ArrayList(param.populationsArcs1);
221: pops1.addAll(param.populationsNoeuds1);
222: List pops2 = new ArrayList(param.populationsArcs2);
223: pops2.addAll(param.populationsNoeuds2);
224:
225: //boucle sur les liens entre cartes topo
226: Iterator itLiensReseaux = liensReseaux.iterator();
227: while (itLiensReseaux.hasNext()) {
228: LienReseaux lienReseau = (LienReseaux) itLiensReseaux
229: .next();
230: // on récupère tous les objets des carte topo concernés
231: Set objetsCT1PourUnLien = new HashSet(lienReseau.getArcs1());
232: objetsCT1PourUnLien.addAll(lienReseau.getNoeuds1());
233: Iterator itGroupes1 = lienReseau.getGroupes1().iterator();
234: while (itGroupes1.hasNext()) {
235: GroupeApp groupe1 = (GroupeApp) itGroupes1.next();
236: objetsCT1PourUnLien.addAll(groupe1.getListeArcs());
237: objetsCT1PourUnLien.addAll(groupe1.getListeNoeuds());
238: }
239: Set objetsCT2PourUnLien = new HashSet(lienReseau.getArcs2());
240: objetsCT2PourUnLien.addAll(lienReseau.getNoeuds2());
241: Iterator itGroupes2 = lienReseau.getGroupes2().iterator();
242: while (itGroupes2.hasNext()) {
243: GroupeApp groupe2 = (GroupeApp) itGroupes2.next();
244: objetsCT2PourUnLien.addAll(groupe2.getListeArcs());
245: objetsCT2PourUnLien.addAll(groupe2.getListeNoeuds());
246: }
247:
248: // On parcours chaque couple d'objets de cartes topos appariés
249: Iterator itObjetsCT1PourUnLien = objetsCT1PourUnLien
250: .iterator();
251: while (itObjetsCT1PourUnLien.hasNext()) {
252: FT_Feature objetCT1 = (FT_Feature) itObjetsCT1PourUnLien
253: .next();
254: Iterator itObjetsCT2PourUnLien = objetsCT2PourUnLien
255: .iterator();
256: List objets1 = getCorrespondants(objetCT1, pops1);
257: while (itObjetsCT2PourUnLien.hasNext()) {
258: FT_Feature objetCT2 = (FT_Feature) itObjetsCT2PourUnLien
259: .next();
260: List objets2 = getCorrespondants(objetCT2, pops2);
261: if (objets1.size() == 0 && objets2.size() == 0) {
262: //cas où il n'y a pas de correspondant dans les données de départ des 2 cotés
263: lienG = (Lien) liensGeneriques.nouvelElement();
264: lienG.setEvaluation(lienReseau.getEvaluation());
265: lienG
266: .setCommentaire("Pas de correspondant géo dans les deux BDs");
267: if (param.exportGeometrieLiens2vers1)
268: lienG.setGeom(creeGeometrieLienSimple(
269: objetCT1, objetCT2));
270: else
271: lienG.setGeom(creeGeometrieLienSimple(
272: objetCT2, objetCT1));
273: continue;
274: }
275: if (objets1.size() == 0) {
276: //cas où il n'y a pas de correspondant dans les données de BD1
277: itObjets2 = objets2.iterator();
278: while (itObjets2.hasNext()) {
279: FT_Feature objet2 = (FT_Feature) itObjets2
280: .next();
281: lienG = (Lien) liensGeneriques
282: .nouvelElement();
283: lienG.setEvaluation(lienReseau
284: .getEvaluation());
285: lienG
286: .setCommentaire("Pas de correspondant géo dans BD1");
287: if (param.exportGeometrieLiens2vers1)
288: lienG.setGeom(creeGeometrieLienSimple(
289: objetCT1, objet2));
290: else
291: lienG.setGeom(creeGeometrieLienSimple(
292: objet2, objetCT1));
293: lienG.addObjetComp(objet2);
294: }
295: continue;
296: }
297: if (objets2.size() == 0) {
298: //cas où il n'y a pas de correspondant dans les données de BD2
299: itObjets1 = objets1.iterator();
300: while (itObjets1.hasNext()) {
301: FT_Feature objet1 = (FT_Feature) itObjets1
302: .next();
303: lienG = (Lien) liensGeneriques
304: .nouvelElement();
305: lienG.setEvaluation(lienReseau
306: .getEvaluation());
307: lienG
308: .setCommentaire("Pas de correspondant géo dans BD1");
309: if (param.exportGeometrieLiens2vers1)
310: lienG.setGeom(creeGeometrieLienSimple(
311: objet1, objetCT2));
312: else
313: lienG.setGeom(creeGeometrieLienSimple(
314: objetCT2, objet1));
315: lienG.addObjetRef(objet1);
316: }
317: continue;
318: }
319: //cas où il y a des correspondants dans les deux BD
320: itObjets1 = objets1.iterator();
321: while (itObjets1.hasNext()) {
322: FT_Feature objet1 = (FT_Feature) itObjets1
323: .next();
324: itObjets2 = objets2.iterator();
325: while (itObjets2.hasNext()) {
326: FT_Feature objet2 = (FT_Feature) itObjets2
327: .next();
328: lienG = (Lien) liensGeneriques
329: .nouvelElement();
330: lienG.setEvaluation(lienReseau
331: .getEvaluation());
332: lienG.setCommentaire("");
333: if (param.exportGeometrieLiens2vers1)
334: lienG.setGeom(creeGeometrieLienSimple(
335: objet1, objet2));
336: else
337: lienG.setGeom(creeGeometrieLienSimple(
338: objet2, objet1));
339: lienG.addObjetRef(objet1);
340: lienG.addObjetComp(objet2);
341: }
342: }
343: }
344: }
345: }
346: if (param.debugAffichageCommentaires > 1)
347: System.out.println(" " + liensGeneriques.size()
348: + " liens 1-1 ont été exportés");
349: System.out.println("liens réseaux" + liensReseaux.size());
350:
351: return liensGeneriques;
352: }
353:
354: /** Renvoie les correspondants appartenant à une des FT_FeatureCollection de la liste passée en parametre. */
355: private static List getCorrespondants(FT_Feature ft,
356: List populations) {
357: List resultats = new ArrayList();
358: Iterator itPop = populations.iterator();
359: while (itPop.hasNext()) {
360: FT_FeatureCollection pop = (FT_FeatureCollection) itPop
361: .next();
362: resultats.addAll(ft.getCorrespondants(pop));
363: }
364: return resultats;
365: }
366:
367: /** Methode créant une géométrie au lien 1-1 en reliant les
368: * deux objets concerné par un simple trait
369: */
370: private static GM_Object creeGeometrieLienSimple(FT_Feature obj1,
371: FT_Feature obj2) {
372: GM_LineString ligne = new GM_LineString();
373: DirectPosition DP2 = null;
374: if (obj2.getGeom() instanceof GM_Point) {
375: GM_Point point2 = (GM_Point) obj2.getGeom();
376: DP2 = point2.getPosition();
377: ligne.addControlPoint(DP2);
378: }
379: if (obj2.getGeom() instanceof GM_LineString) {
380: GM_LineString ligne2 = (GM_LineString) obj2.getGeom();
381: DP2 = Operateurs.milieu(ligne2);
382: ligne.addControlPoint(DP2);
383: }
384:
385: if (obj1.getGeom() instanceof GM_Point) {
386: GM_Point point1 = (GM_Point) obj1.getGeom();
387: ligne.addControlPoint(point1.getPosition());
388: }
389: if (obj1.getGeom() instanceof GM_LineString) {
390: GM_LineString ligne1 = (GM_LineString) obj1.getGeom();
391: ligne.addControlPoint(Operateurs.projection(DP2, ligne1));
392: }
393: return ligne;
394: }
395:
396: //////////////////////////////////////////////////////////////
397: //////////////////////////////////////////////////////////////
398: // ATTENTION
399: //
400: // LES CODES CI-DESSOUS PERMETTENT DE CREER DES GEOMETRIES
401: // COMPLEXES QUI...
402: // 1/ SONT UTILES POUR AVOIR UNE REPRESENTATION FINE
403: // 2/ MAIS NE SONT PAS TRES BLINDEES (code en cours d'affinage)
404: //
405: // A UTILSER AVEC PRECAUTION DONC
406: //////////////////////////////////////////////////////////////
407: //////////////////////////////////////////////////////////////
408:
409: /** Méthode qui affecte une geometrie aux liens de réseau et remplit les commentaires des liens.
410: * UTILE POUR CODE / DEBUG UNIQUEMENT
411: */
412: public static EnsembleDeLiens exportAppCarteTopo(
413: EnsembleDeLiens liensReseaux, ParametresApp param) {
414: EnsembleDeLiens liensGeneriques;
415: LienReseaux lienR;
416: Lien lienG;
417: List tousobjetsRef, tousobjetsComp;
418: Iterator itGroupe;
419: Groupe groupe;
420: Iterator itLiens;
421:
422: if (param.debugAffichageCommentaires > 1)
423: System.out
424: .println("BILAN de l'appariement sur le réseau 1");
425: if (param.debugAffichageCommentaires > 1)
426: System.out
427: .println("NB : bilan sur les objets des réseaux créés, et non sur les objets initiaux, il peut y avoir quelques nuances");
428:
429: liensGeneriques = new EnsembleDeLiens();
430: liensGeneriques.setNom(liensReseaux.getNom());
431:
432: itLiens = liensReseaux.getElements().iterator();
433: while (itLiens.hasNext()) {
434: lienR = (LienReseaux) itLiens.next();
435: lienG = (Lien) liensGeneriques.nouvelElement();
436: lienG.setEvaluation(lienR.getEvaluation());
437:
438: /////////////////////////////////////////
439: // Récupération des objets pointés par le lien
440:
441: // Liens vers les objets de référence
442: tousobjetsRef = new ArrayList();
443: tousobjetsRef.addAll(lienR.getArcs1());
444: tousobjetsRef.addAll(lienR.getNoeuds1());
445: itGroupe = lienR.getGroupes1().iterator();
446: while (itGroupe.hasNext()) {
447: groupe = (Groupe) itGroupe.next();
448: tousobjetsRef.addAll(groupe.getListeArcs());
449: tousobjetsRef.addAll(groupe.getListeNoeuds());
450: }
451: lienG.setObjetsRef(tousobjetsRef);
452:
453: // Liens vers les objets de comparaison
454: tousobjetsComp = new ArrayList();
455: tousobjetsComp.addAll(lienR.getArcs2());
456: tousobjetsComp.addAll(lienR.getNoeuds2());
457: itGroupe = lienR.getGroupes2().iterator();
458: while (itGroupe.hasNext()) {
459: groupe = (Groupe) itGroupe.next();
460: tousobjetsComp.addAll(groupe.getListeArcs());
461: tousobjetsComp.addAll(groupe.getListeNoeuds());
462: }
463: lienG.setObjetsComp(tousobjetsComp);
464:
465: /////////////////////////////////////////
466: // Détermination du type du lien
467: if (lienR.getNoeuds1().size() != 0) {
468: lienG.setType("Lien de noeud ref");
469: liensGeneriques.enleveElement(lienG);
470: continue;
471: } else if (lienR.getArcs1().size() != 0)
472: lienG.setType("Lien d'arc ref");
473:
474: /////////////////////////////////////////
475: // Remplissage des chaines de caractères pour l'export
476: Iterator itRef = lienG.getObjetsRef().iterator();
477: String txt = new String("COGITID:");
478: while (itRef.hasNext()) {
479: FT_Feature objet = (FT_Feature) itRef.next();
480: Iterator itObjGeo = objet.getCorrespondants()
481: .iterator();
482: while (itObjGeo.hasNext()) {
483: FT_Feature objetGeo = (FT_Feature) itObjGeo.next();
484: txt = txt.concat(objetGeo.getId() + " ");
485: }
486: }
487: lienG.setReference(txt);
488:
489: txt = new String("COGITID:");
490: Iterator itComp = lienG.getObjetsComp().iterator();
491: while (itComp.hasNext()) {
492: FT_Feature objet = (FT_Feature) itComp.next();
493: Iterator itObjGeo = objet.getCorrespondants()
494: .iterator();
495: while (itObjGeo.hasNext()) {
496: FT_Feature objetGeo = (FT_Feature) itObjGeo.next();
497: txt = txt.concat(objetGeo.getId() + " ");
498: }
499: }
500: lienG.setComparaison(txt);
501:
502: /////////////////////////////////////////
503: // Création de la géométrie des liens
504: lienG.setGeom(lienR.creeGeometrieLien(param.debugTirets,
505: param.debugPasTirets, param.debugBuffer,
506: param.debugTailleBuffer));
507: }
508: return liensGeneriques;
509: }
510:
511: /** Methode créant une géométrie pour les liens de réseau.
512: *
513: * 1/ Pour chaque noeud du réseau 1 apparié, cette géoémtrie est constituée...
514: * - d'un buffer entourant les objets homolgues dans le réseau ,
515: * - d'un trait reliant le noeud à ce buffer.
516: *
517: * 2/ Pour chaque arc du réseau 1 apparié, cette géoémtrie est constituée...
518: * - d'un ensemble de tirets reliant les arcs homologues de manière régulière
519: * (intervalle entre les tirets en paramètre),
520: * - ou alors d'un ensemble de traits reliant le milieu des arcs appariés.
521: *
522: * @param tirets
523: * Spécifie si on veut une géométrie faite de tirets (true),
524: * ou plutôt d'un unique trait pour chaque couple d'arcs (false)
525: *
526: * @param pasTirets
527: * Si on veut des tirets réguliers, distance entre ces tirets.
528: *
529: * @param tailleBuffer
530: * Taille du buffer autour des objets appariés à un noeud.
531: *
532: */
533: private GM_Object creeGeometrieLien(boolean tirets,
534: double pasTirets, boolean buffer, double tailleBuffer) {
535:
536: Iterator itGroupes, itNoeudsComp, itArcsComp;
537: NoeudApp noeudComp, noeudRef;
538: ArcApp arcComp, arcRef;
539: GroupeApp groupeComp;
540: GM_LineString ligne, chemin;
541: GM_Aggregate geomLien;
542:
543: // LIEN D'UN NOEUD REF VERS DES NOEUDS COMP ET/OU DES GROUPES COMP
544: if (this .getNoeuds1().size() == 1) {
545: noeudRef = (NoeudApp) this .getNoeuds1().get(0);
546: geomLien = new GM_Aggregate();
547:
548: // 1 noeud ref - n noeuds comp isolés --> 1 aggrégat de traits et de surfaces
549: itNoeudsComp = this .getNoeuds2().iterator();
550: while (itNoeudsComp.hasNext()) {
551: noeudComp = (NoeudApp) itNoeudsComp.next();
552: ligne = new GM_LineString();
553: ligne.addControlPoint(noeudRef.getCoord());
554: ligne.addControlPoint(noeudComp.getCoord());
555: geomLien.add(ligne);
556: if (buffer)
557: geomLien.add(noeudComp.getGeometrie().buffer(
558: tailleBuffer));
559: }
560:
561: // 1 noeud ref - n groupes --> aggrégat de traits et de surface autour du groupe
562: itGroupes = this .getGroupes2().iterator();
563: while (itGroupes.hasNext()) {
564: groupeComp = (GroupeApp) itGroupes.next();
565: itArcsComp = groupeComp.getListeArcs().iterator();
566: while (itArcsComp.hasNext()) {
567: arcComp = (ArcApp) itArcsComp.next();
568: geomLien.add(arcComp.getGeometrie().buffer(
569: tailleBuffer));
570: }
571: itNoeudsComp = groupeComp.getListeNoeuds().iterator();
572: while (itNoeudsComp.hasNext()) {
573: noeudComp = (NoeudApp) itNoeudsComp.next();
574: geomLien.add(noeudComp.getGeometrie().buffer(
575: tailleBuffer));
576: }
577:
578: // on fait le trait entre le noeud ref et le groupe comp
579: ligne = new GM_LineString();
580: ligne.addControlPoint(noeudRef.getCoord());
581: ligne.addControlPoint(noeudRef.noeudLePlusProche(
582: groupeComp).getCoord());
583: geomLien.add(ligne);
584: }
585:
586: if (geomLien.coord().size() > 1)
587: return geomLien;
588: System.out
589: .println("Lien pour un noeud non créé : pas assez de coordonnées");
590: return null;
591: }
592:
593: // LIEN D'ARCS REF VERS DES ARCS OU DES GROUPES COMP
594: Iterator itArcsRef = this .getArcs1().iterator();
595: geomLien = new GM_Aggregate();
596: while (itArcsRef.hasNext()) {
597: arcRef = (ArcApp) itArcsRef.next();
598:
599: // 1 arc ref directement vers des noeuds
600: itNoeudsComp = this .getNoeuds2().iterator();
601: while (itNoeudsComp.hasNext()) {
602: noeudComp = (NoeudApp) itNoeudsComp.next();
603: if (tirets)
604: geomLien.add(Lien.tirets(arcRef.getGeometrie(),
605: noeudComp.getGeometrie(), pasTirets));
606: else
607: geomLien.add(Lien.tiret(arcRef.getGeometrie(),
608: noeudComp.getGeometrie()));
609: }
610:
611: // 1 arc ref vers des groupes comp (groupes en parrallèle) --> plusieurs séries de tirets
612: itGroupes = this .getGroupes2().iterator();
613: while (itGroupes.hasNext()) {
614: // 1 arc ref vers un groupe comp (des arcs en série) --> des tirets
615: groupeComp = (GroupeApp) itGroupes.next();
616: chemin = groupeComp.compileArcs(arcRef);
617: if (chemin != null) {
618: if (tirets)
619: geomLien.add(Lien.tirets(arcRef.getGeometrie(),
620: chemin, pasTirets));
621: else
622: geomLien.add(Lien.tiret(arcRef.getGeometrie(),
623: chemin));
624: }
625: }
626:
627: // 1 arc ref vers des arcs comp en série --> des tirets (utile pour le pre-appariement uniquement)
628: itArcsComp = this .getArcs2().iterator();
629: while (itArcsComp.hasNext()) {
630: arcComp = (ArcApp) itArcsComp.next();
631: if (tirets)
632: geomLien.add(Lien.tirets(arcRef.getGeometrie(),
633: arcComp.getGeometrie(), 25));
634: else
635: geomLien.add(Lien.tiret(arcRef.getGeometrie(),
636: arcComp.getGeometrie()));
637: }
638:
639: }
640: if (geomLien.coord().size() > 1)
641: return geomLien;
642: System.out
643: .println("Lien pour un arc non créé : pas assez de coordonnées");
644: return null;
645: }
646:
647: }
|