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;
028:
029: import java.util.ArrayList;
030: import java.util.Collections;
031: import java.util.Iterator;
032: import java.util.List;
033: import java.util.SortedSet;
034: import java.util.TreeSet;
035:
036: import fr.ign.cogit.geoxygene.contrib.cartetopo.Arc;
037: import fr.ign.cogit.geoxygene.contrib.cartetopo.CarteTopo;
038: import fr.ign.cogit.geoxygene.contrib.cartetopo.Groupe;
039: import fr.ign.cogit.geoxygene.contrib.cartetopo.Noeud;
040: import fr.ign.cogit.geoxygene.contrib.geometrie.Operateurs;
041: import fr.ign.cogit.geoxygene.feature.FT_Feature;
042: import fr.ign.cogit.geoxygene.feature.FT_FeatureCollection;
043: import fr.ign.cogit.geoxygene.feature.Population;
044: import fr.ign.cogit.geoxygene.spatial.coordgeom.DirectPosition;
045: import fr.ign.cogit.geoxygene.spatial.coordgeom.GM_LineString;
046: import fr.ign.cogit.geoxygene.spatial.geomaggr.GM_Aggregate;
047: import fr.ign.cogit.geoxygene.spatial.geomprim.GM_Point;
048:
049: /**
050: * Resultats de la réalisation d'un appariement : un ensemble de liens.
051: *
052: * @author Mustiere / IGN Laboratoire COGIT
053: * @version 1.0
054: */
055:
056: public class EnsembleDeLiens extends Population {
057:
058: public EnsembleDeLiens() {
059: super (false, "Ensemble de liens", Lien.class, true);
060: }
061:
062: public EnsembleDeLiens(boolean persistant) {
063: super (persistant, "Ensemble de liens", Lien.class, true);
064: }
065:
066: public EnsembleDeLiens(Class classeDesLiens) {
067: super (false, "Ensemble de liens", classeDesLiens, true);
068: }
069:
070: /** Nom du l'ensemble des liens d'appariement (ex: "Appariement des routes par la méthode XX")*/
071: private String nom;
072:
073: public String getNom() {
074: return nom;
075: }
076:
077: public void setNom(String nom) {
078: this .nom = nom;
079: }
080:
081: /** Description textuelle des paramètres utilisés pour l'appariement */
082: private String parametrage;
083:
084: public String getParametrage() {
085: return parametrage;
086: }
087:
088: public void setParametrage(String parametrage) {
089: this .parametrage = parametrage;
090: }
091:
092: /** Description textuelle du résultat de l'auto-évaluation des liens */
093: private String evaluationInterne;
094:
095: public String getEvaluationInterne() {
096: return evaluationInterne;
097: }
098:
099: public void setEvaluationInterne(String evaluation) {
100: evaluationInterne = evaluation;
101: }
102:
103: /** Description textuelle du résultat de l'évaluation globale des liens */
104: private String evaluationGlobale;
105:
106: public String getEvaluationGlobale() {
107: return evaluationGlobale;
108: }
109:
110: public void setEvaluationGlobale(String evaluation) {
111: evaluationGlobale = evaluation;
112: }
113:
114: //////////////////////////////////////////////////////////////
115: // METHODES UTILES A LA MANIPULATION DES ENSEMBLES DE LIENS
116: //////////////////////////////////////////////////////////////
117:
118: //////////////////////////////////////////////////////////////
119: // MANIPULATION DE BASE DES LISTES D'ELEMENTS
120: //////////////////////////////////////////////////////////////
121: /** Copie d'un ensemble de liens */
122: public EnsembleDeLiens copie() {
123: EnsembleDeLiens copie = new EnsembleDeLiens();
124: copie.setElements(this .getElements());
125: copie.setNom(this .getNom());
126: copie.setEvaluationGlobale(this .getEvaluationGlobale());
127: copie.setEvaluationInterne(this .getEvaluationInterne());
128: return copie;
129: }
130:
131: /** Compilation de deux listes de liens */
132: public static EnsembleDeLiens compile(EnsembleDeLiens liens1,
133: EnsembleDeLiens liens2) {
134: EnsembleDeLiens total = liens1.copie();
135: total.compile(liens2);
136: return total;
137: }
138:
139: /** Ajout des liens à this. NB: modifie this. */
140: public void compile(EnsembleDeLiens liensAAjouter) {
141: this .getElements().addAll(liensAAjouter.getElements());
142: }
143:
144: /** Regroupement de liens pointant vers les mêmes objets.
145: * Autrement dit : les liens en entrée forment un graphe entre les objets;
146: * la méthode crée un seul lien pour toute partie connexe du graphe.
147: * exemple : Ref = (A,B,C), Comp = (X,Y,Z)
148: * en entrée (this) on a 4 liens 1-1 (A-X) (B-X) (B-Y) (C-Z)
149: * en sortie on a un lien n-m (A,B)-(X-Y) et 1 lien 1-1 (C-Z)
150: *
151: */
152: public EnsembleDeLiens regroupeLiens(Population popRef,
153: Population popComp) {
154: EnsembleDeLiens liensGroupes;
155: Lien lienGroupe;
156: CarteTopo grapheDesLiens;
157: Groupe groupeTotal, groupeConnexe;
158: Iterator itGroupes, itNoeuds;
159: Noeud noeud;
160: FT_Feature feat;
161: grapheDesLiens = this .transformeEnCarteTopo(popRef, popComp);
162: groupeTotal = (Groupe) grapheDesLiens.getPopGroupes()
163: .nouvelElement();
164: groupeTotal.setListeArcs(grapheDesLiens.getListeArcs());
165: groupeTotal.setListeNoeuds(grapheDesLiens.getListeNoeuds());
166: groupeTotal.decomposeConnexes();
167:
168: liensGroupes = new EnsembleDeLiens();
169: liensGroupes.setNom("TMP : liens issus d'un regroupement");
170: // on parcours tous les groupes connexes créés
171: itGroupes = grapheDesLiens.getListeArcs().iterator();
172: while (itGroupes.hasNext()) {
173: groupeConnexe = (Groupe) itGroupes.next();
174: if (groupeConnexe.getListeArcs().size() == 0)
175: continue; // cas des noeuds isolés
176: lienGroupe = (Lien) liensGroupes.nouvelElement();
177: itNoeuds = groupeConnexe.getListeNoeuds().iterator();
178: while (itNoeuds.hasNext()) {
179: noeud = (Noeud) itNoeuds.next();
180: feat = noeud.getCorrespondant(0);
181: if (popRef.getElements().contains(feat))
182: lienGroupe.addObjetRef(feat);
183: if (popComp.getElements().contains(feat))
184: lienGroupe.addObjetComp(feat);
185: // nettoyage de la carteTopo créée
186: noeud.setCorrespondants(new ArrayList());
187: }
188: }
189: return liensGroupes;
190: }
191:
192: /** Regroupement de liens pointant vers les mêmes objets.
193: * Autrement dit : les liens en entrée forment un graphe entre les objets;
194: * la méthode crée un seul lien pour toute partie connexe du graphe.
195: * exemple : Ref = (A,B,C), Comp = (X,Y,Z)
196: * en entrée (this) on a 4 liens 1-1 (A-X) (B-X) (B-Y) (C-Z)
197: * en sortie on a un lien n-m (A,B)-(X-Y) et 1 lien 1-1 (C-Z)
198: */
199: public EnsembleDeLiens regroupeLiens(FT_FeatureCollection popRef,
200: FT_FeatureCollection popComp) {
201: EnsembleDeLiens liensGroupes;
202: Lien lienGroupe;
203: CarteTopo grapheDesLiens;
204: Groupe groupeTotal, groupeConnexe;
205: Iterator itGroupes, itNoeuds;
206: Noeud noeud;
207: FT_Feature feat;
208: grapheDesLiens = this .transformeEnCarteTopo(popRef, popComp);
209: groupeTotal = (Groupe) grapheDesLiens.getPopGroupes()
210: .nouvelElement();
211: groupeTotal.setListeArcs(grapheDesLiens.getListeArcs());
212: groupeTotal.setListeNoeuds(grapheDesLiens.getListeNoeuds());
213: groupeTotal.decomposeConnexes();
214:
215: liensGroupes = new EnsembleDeLiens();
216: liensGroupes.setNom("TMP : liens issus d'un regroupement");
217: // on parcours tous les groupes connexes créés
218: itGroupes = grapheDesLiens.getListeArcs().iterator();
219: while (itGroupes.hasNext()) {
220: groupeConnexe = (Groupe) itGroupes.next();
221: if (groupeConnexe.getListeArcs().size() == 0)
222: continue; // cas des noeuds isolés
223: lienGroupe = (Lien) liensGroupes.nouvelElement();
224: itNoeuds = groupeConnexe.getListeNoeuds().iterator();
225: while (itNoeuds.hasNext()) {
226: noeud = (Noeud) itNoeuds.next();
227: feat = noeud.getCorrespondant(0);
228: if (popRef.getElements().contains(feat))
229: lienGroupe.addObjetRef(feat);
230: if (popComp.getElements().contains(feat))
231: lienGroupe.addObjetComp(feat);
232: // nettoyage de la carteTopo créée
233: noeud.setCorrespondants(new ArrayList());
234: }
235: }
236: return liensGroupes;
237: }
238:
239: /** Transforme les liens, qui relient des objets de popRef et popComp,
240: * en une carte topo (graphe sans géométrie) où :
241: * - les objets de popRef et popComp sont des noeuds (sans géométrie)
242: * - les liens sont des arcs entre ces noeuds (sans géométrie)
243: */
244: public CarteTopo transformeEnCarteTopo(FT_FeatureCollection popRef,
245: FT_FeatureCollection popComp) {
246: Iterator itObjetsRef, itObjetsComp, itNoeudsRef, itNoeudsComp;
247: List noeudsRef = new ArrayList(), noeudsComp = new ArrayList(); // listes de Noeud
248:
249: Lien lien;
250: CarteTopo grapheDesLiens = new CarteTopo("Carte de liens");
251: FT_Feature objetRef, objetComp;
252: Noeud noeudRef, noeudComp;
253: Arc arc;
254:
255: // création de noeuds du graphe = les objets ref et comp
256: itObjetsRef = popRef.getElements().iterator();
257: while (itObjetsRef.hasNext()) {
258: objetRef = (FT_Feature) itObjetsRef.next();
259: noeudRef = (Noeud) grapheDesLiens.getPopNoeuds()
260: .nouvelElement();
261: noeudRef.addCorrespondant(objetRef);
262: }
263: itObjetsComp = popComp.getElements().iterator();
264: while (itObjetsComp.hasNext()) {
265: objetComp = (FT_Feature) itObjetsComp.next();
266: noeudComp = (Noeud) grapheDesLiens.getPopNoeuds()
267: .nouvelElement();
268: noeudComp.addCorrespondant(objetComp);
269: }
270:
271: // création des arcs du graphe = les liens d'appariement
272: Iterator itLiens = this .getElements().iterator();
273: while (itLiens.hasNext()) {
274: lien = (Lien) itLiens.next();
275: itObjetsRef = lien.getObjetsRef().iterator();
276: // création des listes de noeuds concernés par le lien
277: noeudsRef.clear();
278: while (itObjetsRef.hasNext()) {
279: objetRef = (FT_Feature) itObjetsRef.next();
280: noeudsRef.add(objetRef.getCorrespondants(
281: grapheDesLiens.getPopNoeuds()).get(0));
282: }
283: itObjetsComp = lien.getObjetsComp().iterator();
284: noeudsComp.clear();
285: while (itObjetsComp.hasNext()) {
286: objetComp = (FT_Feature) itObjetsComp.next();
287: noeudsComp.add(objetComp.getCorrespondants(
288: grapheDesLiens.getPopNoeuds()).get(0));
289: }
290:
291: // instanciation des arcs
292: itNoeudsRef = noeudsRef.iterator();
293: while (itNoeudsRef.hasNext()) {
294: noeudRef = (Noeud) itNoeudsRef.next();
295: itNoeudsComp = noeudsComp.iterator();
296: while (itNoeudsComp.hasNext()) {
297: noeudComp = (Noeud) itNoeudsComp.next();
298: arc = (Arc) grapheDesLiens.getPopArcs()
299: .nouvelElement();
300: arc.addCorrespondant(lien);
301: arc.setNoeudIni(noeudRef);
302: arc.setNoeudFin(noeudComp);
303: }
304: }
305: }
306: return grapheDesLiens;
307: }
308:
309: /** Methode de regroupement des liens 1-1 carto qui pointent sur le meme
310: * objet topo; non optimisee du tout!!!
311: * @return
312: */
313: public EnsembleDeLiens regroupeLiensCartoQuiPointentSurMemeTopo() {
314: List liens = this .getElements();
315: List remove = new ArrayList(), objetsRef = new ArrayList(), objetsComp = new ArrayList();
316: Object objetTest;
317: int i, j, k;
318:
319: for (i = 0; i < liens.size(); i++) {
320: objetsComp
321: .add(((Lien) liens.get(i)).getObjetsComp().get(0));
322: objetsRef.add(((Lien) liens.get(i)).getObjetsRef().get(0));
323: }
324:
325: //regroupement des liens
326: for (j = 0; j < liens.size(); j++) {
327: objetTest = objetsComp.get(j);
328: for (k = j; k < liens.size(); k++) {
329: if (objetTest.equals(objetsComp.get(k)) && j != k) {
330: ((Lien) liens.get(j))
331: .addObjetRef((FT_Feature) objetsRef.get(k));
332: if (!remove.contains(new Integer(k))) {
333: remove.add(new Integer(k));
334: }
335: }
336: }
337: }
338:
339: //destruction des liens superflus
340: SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
341: s.addAll(remove);
342: remove = new ArrayList(s);
343: for (i = s.size() - 1; i >= 0; i--) {
344: liens.remove(((Integer) remove.get(i)).intValue());
345: }
346: return this ;
347: }
348:
349: //////////////////////////////////////////////////////////////
350: // AUTOUR DE L'EVALUATION
351: //////////////////////////////////////////////////////////////
352:
353: /** Filtrage des liens, on ne retient que ceux dont l'évaluation
354: * est supérieure ou égale au seuil passé en paramètre.
355: */
356: public void filtreLiens(float seuilEvaluation) {
357: Lien lien;
358: Iterator itLiens = this .getElements().iterator();
359: while (itLiens.hasNext()) {
360: lien = (Lien) itLiens.next();
361: if (lien.getEvaluation() < seuilEvaluation)
362: this .enleveElement(lien);
363: }
364: }
365:
366: /** Change l'évaluation d'un lien si celui-ci a un nombre d'objets associés
367: * à la base de comparaison (flag=true) ou à la base de référence (flag=false)
368: * supérieur au seuilCardinalite, en lui donnant la valeur nulle.
369: * Si le seuil n'est pas dépassé, l'évaluation du lien reste ce qu'elle est.
370: * @param flag : true si l'on s'intéresse aux objets de la base de comparaison des liens,
371: * false s'il s'agit de la base de référence
372: * @param seuilCardinalite : seuil au dessus duquel la méthode affecte une évaluation nulle
373: * au lien
374: */
375: public void evaluationLiensParCardinalite(boolean flag,
376: double seuilCardinalite) {
377: Lien lien;
378: Iterator itLiens = this .getElements().iterator();
379: if (flag) {
380: while (itLiens.hasNext()) {
381: lien = (Lien) itLiens.next();
382: if (lien.getObjetsComp().size() > seuilCardinalite)
383: lien.setEvaluation(0);
384: }
385: } else {
386: while (itLiens.hasNext()) {
387: lien = (Lien) itLiens.next();
388: if (lien.getObjetsRef().size() > seuilCardinalite)
389: lien.setEvaluation(0);
390: }
391: }
392: }
393:
394: /** Crée une liste de population en fonction des seuils sur l'evaluation
395: * passés en paramètre.
396: * Exemple: si la liste en entree contient 2 "Double" (0.5, 1),
397: * alors renvoie 3 populations avec les liens ayant respectivement leur évaluation...
398: * 0: inférieur à 0.5 (strictement)
399: * 1: entre 0.5 et 1 (strictement sur 1)
400: * 2: supérieur ou égal à 1
401: */
402: public List classeSelonSeuilEvaluation(List valeursClassement) {
403: List liensClasses = new ArrayList();
404: Iterator itLiens = this .getElements().iterator();
405: Lien lien, lienClasse;
406: double seuil;
407: int i;
408: boolean trouve;
409:
410: for (i = 0; i <= valeursClassement.size(); i++) {
411: liensClasses.add(new EnsembleDeLiens());
412: }
413: while (itLiens.hasNext()) {
414: lien = (Lien) itLiens.next();
415: trouve = false;
416: for (i = 0; i < valeursClassement.size(); i++) {
417: seuil = ((Double) valeursClassement.get(i))
418: .doubleValue();
419: if (lien.getEvaluation() < seuil) {
420: lienClasse = (Lien) ((EnsembleDeLiens) liensClasses
421: .get(i)).nouvelElement();
422: lienClasse.setEvaluation(lien.getEvaluation());
423: lienClasse.setGeom(lien.getGeom());
424: lienClasse.setCommentaire(lien.getCommentaire());
425: lienClasse.setCorrespondants(lien
426: .getCorrespondants());
427: lienClasse.setObjetsComp(lien.getObjetsComp());
428: lienClasse.setObjetsRef(lien.getObjetsRef());
429: lienClasse.setIndicateurs(lien.getIndicateurs());
430: trouve = true;
431: break;
432: }
433: }
434: if (trouve)
435: continue;
436: lienClasse = (Lien) ((EnsembleDeLiens) liensClasses
437: .get(valeursClassement.size())).nouvelElement();
438: lienClasse.setEvaluation(lien.getEvaluation());
439: lienClasse.setGeom(lien.getGeom());
440: lienClasse.setCommentaire(lien.getCommentaire());
441: lienClasse.setCorrespondants(lien.getCorrespondants());
442: lienClasse.setObjetsComp(lien.getObjetsComp());
443: lienClasse.setObjetsRef(lien.getObjetsRef());
444: lienClasse.setIndicateurs(lien.getIndicateurs());
445: }
446: return liensClasses;
447: }
448:
449: //////////////////////////////////////////////////////////////
450: // AUTOUR DE LA GEOMETRIE ET DE LA VISUALISATION
451: //////////////////////////////////////////////////////////////
452:
453: /** Affecte une géométrie à l'ensemble des liens, cette géométrie
454: * relie les centroïdes des objets concernés entre eux */
455: public void creeGeometrieDesLiens() {
456: Iterator itLiens = this .getElements().iterator();
457: Iterator itRef, itComp;
458: Lien lien;
459: FT_Feature ref, comp;
460:
461: while (itLiens.hasNext()) {
462: lien = (Lien) itLiens.next();
463: itRef = lien.getObjetsRef().iterator();
464: GM_Aggregate geom = new GM_Aggregate();
465: while (itRef.hasNext()) {
466: ref = (FT_Feature) itRef.next();
467: itComp = lien.getObjetsComp().iterator();
468: while (itComp.hasNext()) {
469: comp = (FT_Feature) itComp.next();
470: GM_LineString ligne = new GM_LineString();
471: ligne.addControlPoint(((GM_Point) ref.getGeom()
472: .centroid()).getPosition());
473: ligne.addControlPoint(((GM_Point) comp.getGeom()
474: .centroid()).getPosition());
475: geom.add(ligne);
476: }
477: }
478: lien.setGeom(geom);
479: }
480: }
481:
482: /** Affecte une géométrie à l'ensemble des liens, cette géométrie
483: * relie le milieu d'une ligne au milieu d'une ligne correspondant
484: * des objets
485: */
486: public void creeGeometrieDesLiensEntreLignesEtLignes() {
487: Iterator itLiens = this .getElements().iterator();
488: Iterator itRef, itComp;
489: Lien lien;
490: FT_Feature ref, comp;
491: GM_LineString lineStringLien;
492: GM_Aggregate geom;
493: DirectPosition dpRef;
494:
495: while (itLiens.hasNext()) {
496: lien = (Lien) itLiens.next();
497: geom = new GM_Aggregate();
498: itRef = lien.getObjetsRef().iterator();
499: while (itRef.hasNext()) {
500: ref = (FT_Feature) itRef.next();
501: dpRef = Operateurs
502: .milieu((GM_LineString) ref.getGeom());
503: itComp = lien.getObjetsComp().iterator();
504: while (itComp.hasNext()) {
505: comp = (FT_Feature) itComp.next();
506: lineStringLien = new GM_LineString();
507: lineStringLien.addControlPoint(dpRef);
508: lineStringLien.addControlPoint(Operateurs
509: .milieu((GM_LineString) comp.getGeom()));
510: geom.add(lineStringLien);
511: }
512: }
513: lien.setGeom(geom);
514: }
515: }
516:
517: /** Affecte une géométrie à l'ensemble des liens, cette géométrie
518: * relie le centroide d'une surface au milieu du segment correspondant
519: * des objets
520: * @param comparaison : true si les objets de la BD de comparaison sont
521: * des lignes; false s'il s'agit des objets de la BD de référence
522: */
523: public void creeGeometrieDesLiensEntreSurfacesEtLignes(
524: boolean comparaison) {
525: Iterator itLiens = this .getElements().iterator();
526: Iterator itRef, itComp;
527: Lien lien;
528: FT_Feature ref, comp;
529:
530: while (itLiens.hasNext()) {
531: lien = (Lien) itLiens.next();
532: itRef = lien.getObjetsRef().iterator();
533: GM_Aggregate geom = new GM_Aggregate();
534: while (itRef.hasNext()) {
535: ref = (FT_Feature) itRef.next();
536: itComp = lien.getObjetsComp().iterator();
537: while (itComp.hasNext()) {
538: comp = (FT_Feature) itComp.next();
539: GM_LineString ligne = new GM_LineString();
540: if (comparaison) {
541: GM_Point centroideSurface = (GM_Point) ref
542: .getGeom().centroid();
543: double pointCentral = Math
544: .floor(((GM_LineString) comp.getGeom())
545: .numPoints() / 2) - 1;
546: GM_Point pointMilieu = new GM_Point(
547: ((GM_LineString) comp.getGeom())
548: .getControlPoint((int) pointCentral));
549: ligne.addControlPoint(centroideSurface
550: .getPosition());
551: ligne
552: .addControlPoint(pointMilieu
553: .getPosition());
554: geom.add(ligne);
555: } else {
556: GM_Point centroideSurface = (GM_Point) comp
557: .getGeom().centroid();
558: double pointCentral = Math
559: .floor(((GM_LineString) ref.getGeom())
560: .numPoints() / 2) - 1;
561: GM_Point pointMilieu = new GM_Point(
562: ((GM_LineString) ref.getGeom())
563: .getControlPoint((int) pointCentral));
564: ligne.addControlPoint(centroideSurface
565: .getPosition());
566: ligne
567: .addControlPoint(pointMilieu
568: .getPosition());
569: geom.add(ligne);
570: }
571:
572: }
573: }
574: lien.setGeom(geom);
575: }
576: }
577:
578: /** Affecte une géométrie à l'ensemble des liens, cette géométrie
579: * relie le centroïde d'une surface à un point
580: * @param comparaison : true si les objets de la BD de comparaison sont
581: * des points; false s'il s'agit des objets de la BD de référence
582: */
583: public void creeGeometrieDesLiensEntreSurfacesEtPoints(
584: boolean comparaison) {
585: Iterator itLiens = this .getElements().iterator();
586: Iterator itRef, itComp;
587: Lien lien;
588: FT_Feature ref, comp;
589:
590: while (itLiens.hasNext()) {
591: lien = (Lien) itLiens.next();
592: itRef = lien.getObjetsRef().iterator();
593: GM_Aggregate geom = new GM_Aggregate();
594: while (itRef.hasNext()) {
595: ref = (FT_Feature) itRef.next();
596: itComp = lien.getObjetsComp().iterator();
597: while (itComp.hasNext()) {
598: comp = (FT_Feature) itComp.next();
599: GM_LineString ligne = new GM_LineString();
600: if (comparaison) {
601: GM_Point centroideSurface = (GM_Point) ref
602: .getGeom().centroid();
603: ligne.addControlPoint(centroideSurface
604: .getPosition());
605: ligne.addControlPoint(((GM_Point) comp
606: .getGeom()).getPosition());
607: geom.add(ligne);
608: } else {
609: GM_Point centroideSurface = (GM_Point) comp
610: .getGeom().centroid();
611: ligne.addControlPoint(centroideSurface
612: .getPosition());
613: ligne
614: .addControlPoint(((GM_Point) ref
615: .getGeom()).getPosition());
616: geom.add(ligne);
617: }
618:
619: }
620: }
621: lien.setGeom(geom);
622: }
623: }
624:
625: /** Détruit la géométrie des liens
626: */
627: public void detruitGeometrieDesLiens() {
628: Iterator itLiens = this .getElements().iterator();
629: Lien lien;
630:
631: while (itLiens.hasNext()) {
632: lien = (Lien) itLiens.next();
633: GM_Aggregate geom = new GM_Aggregate();
634: lien.setGeom(geom);
635: }
636: }
637:
638: //////////////////////////////////////////////////////////////
639: // AUTOUR DE LA VISUALISATION OBJETS APPARIES / NON APPARIES
640: //////////////////////////////////////////////////////////////
641:
642: /** Méthode qui renvoie à partir d'un ensemble de liens une liste de dimension 4,
643: * avec
644: * en 1. la population issue de la population de référence qui a été appariée,
645: * en 2. la population issue de la population de comparaison qui a été appariée,
646: * en 3. la population issue de la population de référence qui n'a pas été appariée,
647: * en 4. la population issue de la population de comparaison qui n'a pas été appariée.
648: * @param ensemble: ensemble de liens issu d'un appariement
649: * @param popRef
650: * @param popComp
651: * @return liste des populations appariées et non appariées
652: */
653: public static List<Population> objetsApparies(
654: EnsembleDeLiens ensemble, FT_FeatureCollection popRef,
655: FT_FeatureCollection popComp) {
656: List<Population> listPopulation = new ArrayList<Population>();
657: Population popCompAppariee = new Population(), popCompNonAppariee = new Population(), popRefAppariee = new Population(), popRefNonAppariee = new Population();
658:
659: Lien lien;
660: FT_Feature elementPopComp, elementPopRef;
661:
662: List liens = ensemble.getElements();
663: Iterator itLiens = liens.iterator();
664: //ajout des éléments appariés dans les populations concernées
665: while (itLiens.hasNext()) {
666: lien = (Lien) itLiens.next();
667: List elementsComp = lien.getObjetsComp();
668: List elementsRef = lien.getObjetsRef();
669:
670: Iterator itComp = elementsComp.iterator();
671: Iterator itRef = elementsRef.iterator();
672:
673: while (itComp.hasNext()) {
674: elementPopComp = (FT_Feature) itComp.next();
675: popCompAppariee.add(elementPopComp);
676: }
677:
678: while (itRef.hasNext()) {
679: elementPopRef = (FT_Feature) itRef.next();
680: popRefAppariee.add(elementPopRef);
681: }
682: }
683:
684: //copie des populations comp et ref dans les populations non appariées
685: //popCompNonAppariee.copiePopulation(popComp);
686: //popRefNonAppariee.copiePopulation(popRef);
687: popCompNonAppariee.setElements(popComp.getElements());
688: popRefNonAppariee.setElements(popRef.getElements());
689:
690: Iterator itPopCompApp = popCompAppariee.getElements()
691: .iterator();
692: Iterator itPopRefApp = popRefAppariee.getElements().iterator();
693:
694: //élimination dans les populations non appariées des éléments appariés contenus
695: //dans les populations appariés afin d'obtenir les complémentaires
696: while (itPopCompApp.hasNext()) {
697: FT_Feature elementAOter = (FT_Feature) itPopCompApp.next();
698: popCompNonAppariee.remove(elementAOter);
699: }
700:
701: while (itPopRefApp.hasNext()) {
702: FT_Feature elementAOter = (FT_Feature) itPopRefApp.next();
703: popRefNonAppariee.remove(elementAOter);
704: }
705:
706: listPopulation.add(popRefAppariee);
707: listPopulation.add(popCompAppariee);
708: listPopulation.add(popRefNonAppariee);
709: listPopulation.add(popCompNonAppariee);
710:
711: return listPopulation;
712: }
713:
714: /** Methode utile principalement pour analyser les résultats d'un appariement,
715: * qui découpe un réseau en plusieurs réseaux selon les valeurs de l'attribut
716: * "resultatAppariement" des arcs et noeuds du réseau apparié.
717: */
718: public List scindeSelonValeursCommentaires(List valeursClassement) {
719: List liensClasses = new ArrayList();
720: int i;
721:
722: for (i = 0; i < valeursClassement.size(); i++) {
723: liensClasses.add(new EnsembleDeLiens());
724: }
725: Iterator itLiens = this .getElements().iterator();
726: while (itLiens.hasNext()) {
727: Lien lien = (Lien) itLiens.next();
728: for (i = 0; i < valeursClassement.size(); i++) {
729: if (lien.getCommentaire() == null) {
730: continue;
731: }
732: if (lien.getCommentaire().startsWith(
733: (String) valeursClassement.get(i))) {
734: ((EnsembleDeLiens) liensClasses.get(i)).add(lien);
735: }
736: }
737: }
738: return liensClasses;
739: }
740:
741: }
|