0001: /*
0002: * This file is part of the GeOxygene project source files.
0003: *
0004: * GeOxygene aims at providing an open framework which implements OGC/ISO specifications for
0005: * the development and deployment of geographic (GIS) applications. It is a open source
0006: * contribution of the COGIT laboratory at the Institut Géographique National (the French
0007: * National Mapping Agency).
0008: *
0009: * See: http://oxygene-project.sourceforge.net
0010: *
0011: * Copyright (C) 2005 Institut Géographique National
0012: *
0013: * This library is free software; you can redistribute it and/or modify it under the terms
0014: * of the GNU Lesser General Public License as published by the Free Software Foundation;
0015: * either version 2.1 of the License, or any later version.
0016: *
0017: * This library is distributed in the hope that it will be useful, but WITHOUT ANY
0018: * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
0019: * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
0020: *
0021: * You should have received a copy of the GNU Lesser General Public License along with
0022: * this library (see file LICENSE if present); if not, write to the Free Software
0023: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0024: *
0025: */
0026:
0027: package fr.ign.cogit.geoxygene.contrib.appariement.reseaux;
0028:
0029: import java.sql.Time;
0030: import java.util.ArrayList;
0031: import java.util.Iterator;
0032: import java.util.List;
0033:
0034: import fr.ign.cogit.geoxygene.contrib.appariement.EnsembleDeLiens;
0035: import fr.ign.cogit.geoxygene.contrib.appariement.reseaux.topologie.ArcApp;
0036: import fr.ign.cogit.geoxygene.contrib.appariement.reseaux.topologie.GroupeApp;
0037: import fr.ign.cogit.geoxygene.contrib.appariement.reseaux.topologie.NoeudApp;
0038: import fr.ign.cogit.geoxygene.contrib.appariement.reseaux.topologie.ReseauApp;
0039: import fr.ign.cogit.geoxygene.contrib.cartetopo.CarteTopo;
0040: import fr.ign.cogit.geoxygene.contrib.cartetopo.Face;
0041: import fr.ign.cogit.geoxygene.contrib.cartetopo.Noeud;
0042: import fr.ign.cogit.geoxygene.contrib.geometrie.Distances;
0043: import fr.ign.cogit.geoxygene.contrib.geometrie.IndicesForme;
0044: import fr.ign.cogit.geoxygene.contrib.geometrie.Operateurs;
0045: import fr.ign.cogit.geoxygene.feature.FT_FeatureCollection;
0046: import fr.ign.cogit.geoxygene.feature.Population;
0047: import fr.ign.cogit.geoxygene.spatial.coordgeom.DirectPosition;
0048: import fr.ign.cogit.geoxygene.spatial.geomprim.GM_Point;
0049: import fr.ign.cogit.geoxygene.util.index.Tiling;
0050:
0051: /**
0052: * Cette classe supporte les methodes d'entrée pour executer l'appariement
0053: * de réseaux inspiré de la méthode de [Devogele 97].
0054: *
0055: * NB: Cette classe ne porte QUE les méthodes concernant l'appariement de cartes topo.
0056: * Pour un appariement complet de jeux géo (création carte topo, appariement, export),
0057: * voir la classe appariementIO.
0058: *
0059: * @author Mustiere / IGN Laboratoire COGIT
0060: * @version 1.0
0061: *
0062: */
0063:
0064: /////////////////////////////////////////////////////////////////////////////////////////////////
0065: //NOTE AUX CODEURS, dans le code parfois : reseau 1 = reseau ref, reseau 2 = reseau comp.
0066: /////////////////////////////////////////////////////////////////////////////////////////////////
0067: public abstract class Appariement {
0068:
0069: /** Appariement entre deux réseaux représentés par des carte topo.
0070: * Processus largement inspiré de celui défini dans la thèse de Thomas Devogèle (1997).
0071: *
0072: * Attention : les réseaux passés en entrée sont modifiés durant le traitement : des groupes y sont ajoutés.
0073: */
0074: public static EnsembleDeLiens appariementReseaux(ReseauApp reseau1,
0075: ReseauApp reseau2, ParametresApp param) {
0076: EnsembleDeLiens liensPreAppNN;
0077: EnsembleDeLiens liensPreAppAA;
0078: EnsembleDeLiens liensAppArcs;
0079: EnsembleDeLiens liensAppNoeuds;
0080: EnsembleDeLiens tousLiens;
0081:
0082: // Indexation spatiale si cela n'a pas déjà été fait :
0083: // dallage régulier avec en moyenne 20 objets par case
0084: if (!reseau1.getPopArcs().hasSpatialIndex()) {
0085: int nb = (int) Math.sqrt(reseau1.getPopArcs().size() / 20);
0086: if (nb == 0)
0087: nb = 1;
0088: reseau1.getPopArcs().initSpatialIndex(Tiling.class, true,
0089: nb);
0090: }
0091:
0092: if (!reseau2.getPopNoeuds().hasSpatialIndex()) {
0093: int nb = (int) Math
0094: .sqrt(reseau2.getPopNoeuds().size() / 20);
0095: if (nb == 0)
0096: nb = 1;
0097: reseau2.getPopNoeuds().initSpatialIndex(Tiling.class, true,
0098: nb);
0099: }
0100:
0101: ///////////// APPARIEMENT
0102: // Préappariement de noeuds à noeuds
0103: if (param.debugAffichageCommentaires > 1)
0104: System.out
0105: .println(" -- Pré-appariement des noeuds "
0106: + (new Time(System.currentTimeMillis()))
0107: .toString());
0108: liensPreAppNN = preAppariementNoeudNoeud(reseau1, reseau2,
0109: param);
0110:
0111: // Préappariement d'arcs à arcs
0112: if (liensPreAppNN.size() != 0) { // il est inutile de pre-appariéer les arcs si rien n'a été trouvé sur les noeuds
0113: // Preappariement des arcs entre eux (basé principalement sur Hausdorf)
0114: if (param.debugAffichageCommentaires > 1)
0115: System.out.println(" -- Pré-appariement des arcs "
0116: + (new Time(System.currentTimeMillis()))
0117: .toString());
0118: liensPreAppAA = preAppariementArcArc(reseau1, reseau2,
0119: param);
0120: } else {
0121: liensPreAppAA = new EnsembleDeLiens(LienReseaux.class);
0122: liensPreAppAA.setNom("Préappariement des arcs");
0123: }
0124:
0125: // Appariement de chaque noeud de la BDref (indépendamment les uns des autres)
0126: if (param.debugAffichageCommentaires > 1)
0127: System.out
0128: .println(" -- Appariement des noeuds "
0129: + (new Time(System.currentTimeMillis()))
0130: .toString());
0131: liensAppNoeuds = appariementNoeuds(reseau1, reseau2,
0132: liensPreAppNN, liensPreAppAA, param);
0133:
0134: nettoyageLiens(reseau1, reseau2, liensPreAppNN);
0135:
0136: if (param.varianteRedecoupageNoeudsNonApparies) {
0137: if (param.debugAffichageCommentaires > 1)
0138: System.out
0139: .println(" -- Projection plus forte pour les noeuds non appariés "
0140: + (new Time(System.currentTimeMillis()))
0141: .toString());
0142: decoupeNoeudsNonApparies(reseau1, reseau2, liensAppNoeuds,
0143: param);
0144: if (param.debugAffichageCommentaires > 1)
0145: System.out.println(" -- Nettoyage des liens "
0146: + (new Time(System.currentTimeMillis()))
0147: .toString());
0148: nettoyageLiens(reseau1, reseau2);
0149: liensPreAppNN.setElements(new ArrayList());
0150: liensPreAppAA.setElements(new ArrayList());
0151: liensAppNoeuds.setElements(new ArrayList());
0152: System.gc();
0153: // Préappariement de noeuds à noeuds
0154: if (param.debugAffichageCommentaires > 1)
0155: System.out.println(" -- Pré-appariement des noeuds "
0156: + (new Time(System.currentTimeMillis()))
0157: .toString());
0158: liensPreAppNN = preAppariementNoeudNoeud(reseau1, reseau2,
0159: param);
0160: if (param.debugAffichageCommentaires > 1)
0161: System.out
0162: .println(" Nb de liens de pre-appariement noeud-noeud = "
0163: + liensPreAppNN.size());
0164: // Preappariement des arcs entre eux (basé principalement sur Hausdroff)
0165: if (param.debugAffichageCommentaires > 1)
0166: System.out.println(" -- Pré-appariement des arcs "
0167: + (new Time(System.currentTimeMillis()))
0168: .toString());
0169: liensPreAppAA = preAppariementArcArc(reseau1, reseau2,
0170: param);
0171: // Appariement de chaque noeud de la BDref (indépendamment)
0172: if (param.debugAffichageCommentaires > 1)
0173: System.out.println(" -- Appariement des noeuds "
0174: + (new Time(System.currentTimeMillis()))
0175: .toString());
0176: liensAppNoeuds = appariementNoeuds(reseau1, reseau2,
0177: liensPreAppNN, liensPreAppAA, param);
0178: nettoyageLiens(reseau1, reseau2, liensPreAppNN);
0179: }
0180:
0181: // Appariement de chaque arc du reseau 1
0182: if (param.debugAffichageCommentaires > 1)
0183: System.out
0184: .println(" -- Appariement des arcs "
0185: + (new Time(System.currentTimeMillis()))
0186: .toString());
0187: liensAppArcs = appariementArcs(reseau1, reseau2, liensPreAppAA,
0188: liensAppNoeuds, param);
0189: if (param.debugAffichageCommentaires > 1)
0190: System.out.println("");
0191: tousLiens = EnsembleDeLiens.compile(liensAppNoeuds,
0192: liensAppArcs);
0193:
0194: if (param.varianteRedecoupageArcsNonApparies) {
0195: // NB: pas optimal du tout, on recalcule tout après avoir redécoupé.
0196: if (param.debugAffichageCommentaires > 1)
0197: System.out
0198: .println(" -- Redécoupage plus fort pour les arcs non appariés "
0199: + (new Time(System.currentTimeMillis()))
0200: .toString());
0201: decoupeNonApparies(reseau1, reseau2, tousLiens, param);
0202: nettoyageLiens(reseau1, reseau2);
0203: liensPreAppNN.setElements(new ArrayList());
0204: liensPreAppAA.setElements(new ArrayList());
0205: liensAppNoeuds.setElements(new ArrayList());
0206: // Préappariement de noeuds à noeuds
0207: if (param.debugAffichageCommentaires > 1)
0208: System.out.println(" -- Pré-appariement des noeuds "
0209: + (new Time(System.currentTimeMillis()))
0210: .toString());
0211: liensPreAppNN = preAppariementNoeudNoeud(reseau1, reseau2,
0212: param);
0213: // Preappariement des arcs entre eux (basé principalement sur Hausdroff)
0214: if (param.debugAffichageCommentaires > 1)
0215: System.out.println(" -- Pré-appariement des arcs "
0216: + (new Time(System.currentTimeMillis()))
0217: .toString());
0218: liensPreAppAA = preAppariementArcArc(reseau1, reseau2,
0219: param);
0220: // Appariement de chaque noeud de la BDref (indépendamment)
0221: if (param.debugAffichageCommentaires > 1)
0222: System.out.println(" -- Appariement des noeuds "
0223: + (new Time(System.currentTimeMillis()))
0224: .toString());
0225: liensAppNoeuds = appariementNoeuds(reseau1, reseau2,
0226: liensPreAppNN, liensPreAppAA, param);
0227: nettoyageLiens(reseau1, reseau2, liensPreAppNN);
0228: // Appariement de chaque arc de la BDref
0229: if (param.debugAffichageCommentaires > 1)
0230: System.out.println(" -- Appariement des arcs "
0231: + (new Time(System.currentTimeMillis()))
0232: .toString());
0233: liensAppArcs = appariementArcs(reseau1, reseau2,
0234: liensPreAppAA, liensAppNoeuds, param);
0235: tousLiens = EnsembleDeLiens.compile(liensAppNoeuds,
0236: liensAppArcs);
0237: }
0238:
0239: nettoyageLiens(reseau1, reseau2, liensPreAppAA);
0240:
0241: // Evaluation globale
0242: if (param.debugAffichageCommentaires > 1)
0243: System.out
0244: .println(" -- Controle global des appariements et bilan "
0245: + (new Time(System.currentTimeMillis()))
0246: .toString());
0247: controleGlobal(reseau1, reseau2, tousLiens, param);
0248:
0249: //return liens_AppArcs;
0250: return tousLiens;
0251: }
0252:
0253: /** Enlève tous les liens "liens" des cartes topo en entrée, et vide les liens "liens" */
0254: public static void nettoyageLiens(ReseauApp reseau1,
0255: ReseauApp reseau2, EnsembleDeLiens liens) {
0256: nettoyageLiens(reseau1, liens);
0257: nettoyageLiens(reseau2, liens);
0258: liens.setElements(new ArrayList());
0259: }
0260:
0261: /** Enlève tous les liens "liens" des cartes topo en entrée */
0262: private static void nettoyageLiens(ReseauApp res,
0263: EnsembleDeLiens liens) {
0264: Iterator it;
0265: it = res.getPopArcs().getElements().iterator();
0266: while (it.hasNext()) {
0267: ArcApp objet = (ArcApp) it.next();
0268: objet.getLiens().removeAll(liens.getElements());
0269: }
0270: it = res.getPopNoeuds().getElements().iterator();
0271: while (it.hasNext()) {
0272: NoeudApp objet = (NoeudApp) it.next();
0273: objet.getLiens().removeAll(liens.getElements());
0274: }
0275: it = res.getPopGroupes().getElements().iterator();
0276: while (it.hasNext()) {
0277: GroupeApp objet = (GroupeApp) it.next();
0278: objet.getLiens().removeAll(liens.getElements());
0279: }
0280: }
0281:
0282: /** Enlève tous les liens des cartes topo en entrée, et détruit les groupes */
0283: public static void nettoyageLiens(ReseauApp reseau1,
0284: ReseauApp reseau2) {
0285: nettoyageLiens(reseau1);
0286: nettoyageLiens(reseau2);
0287: }
0288:
0289: /** Enlève tous les liens de la carte topo en entrée, et détruit les groupes */
0290: public static void nettoyageLiens(ReseauApp res) {
0291: Iterator it;
0292: it = res.getPopArcs().getElements().iterator();
0293: while (it.hasNext()) {
0294: ArcApp objet = (ArcApp) it.next();
0295: objet.setLiens(new ArrayList());
0296: }
0297: it = res.getPopNoeuds().getElements().iterator();
0298: while (it.hasNext()) {
0299: NoeudApp objet = (NoeudApp) it.next();
0300: objet.setLiens(new ArrayList());
0301: }
0302: res.getPopGroupes().setElements(new ArrayList());
0303: }
0304:
0305: ///////////////////////////////////////////////////////////////////////////////////////////////////////
0306: ///////////////////////////////////////////////////////////////////////////////////////////////////////
0307: /** Préappariement entre noeuds uniquement sur un critère de distance euclidienne,
0308: * comme proposé dans [Devogèle 97].
0309: *
0310: * On crée des liens 1-n (n candidats noeuds de BDcomp pour chaque noeud de BDref).
0311: *
0312: * Comme suggéré dans [Devogèle 97], la taille de la recherche peut varier selon
0313: * le type du noeud de la BD de reférence (rond point, changement d'attribut...).
0314: * NB1: On préfère largement une taille de recherche sur-évaluée que sous-évaluée.
0315: * NB2: On ne traite pas les noeuds isolés.
0316: */
0317: public static EnsembleDeLiens preAppariementNoeudNoeud(
0318: CarteTopo reseau1, CarteTopo reseau2, ParametresApp param) {
0319: int nbCandidats = 0, nbRef = 0;
0320: NoeudApp noeudRef, noeudComp;
0321: List candidats;
0322: EnsembleDeLiens liens;
0323: Iterator itNoeuds, itCandidats;
0324: LienReseaux lien;
0325:
0326: liens = new EnsembleDeLiens(LienReseaux.class);
0327: liens.setNom("Préappariement des noeuds");
0328: itNoeuds = reseau1.getListeNoeuds().iterator();
0329: while (itNoeuds.hasNext()) {
0330: noeudRef = (NoeudApp) itNoeuds.next();
0331: // On ne tient pas compte des noeuds isolés
0332: if (noeudRef.getEntrants().size() == 0
0333: && noeudRef.getSortants().size() == 0)
0334: continue;
0335: nbRef++;
0336: // Détermination des noeuds comp dans le rayon de recherche
0337: candidats = reseau2.getPopNoeuds().select(
0338: noeudRef.getGeometrie(), noeudRef.getTaille())
0339: .getElements();
0340: if (candidats.size() != 0) {
0341: lien = (LienReseaux) liens.nouvelElement();
0342: lien.addNoeuds1(noeudRef);
0343: noeudRef.addLiens(lien);
0344: nbCandidats = nbCandidats + candidats.size();
0345: itCandidats = candidats.iterator();
0346: while (itCandidats.hasNext()) {
0347: noeudComp = (NoeudApp) itCandidats.next();
0348: lien.addNoeuds2(noeudComp);
0349: noeudComp.addLiens(lien);
0350: }
0351: }
0352: }
0353: if (param.debugAffichageCommentaires > 1)
0354: System.out.println(" Bilan : " + nbCandidats
0355: + " noeuds comp candidats pour " + nbRef
0356: + " noeuds ref à traiter");
0357: return liens;
0358: }
0359:
0360: ///////////////////////////////////////////////////////////////////////////////////////////////////////
0361: /** Préappariement entre arcs basé sur la "demi-distance de Hausdorff"
0362: * (on ne prend en compte que la composante de réseau 2 vers réseau 1).
0363: *
0364: * Pour chaque arc du reseau 2, on garde les arcs du reseau 1 qui sont à la fois
0365: * 1/ à moins distanceMax de l'arc comp
0366: * 2/ à moins de D + distanceMin de l'arc comp,
0367: * D étant la distance entre l'arc ref le plus proche de arc comp
0368: *
0369: * NB: ce pré-appariement est différent de ce qui est proposé dans [Devogèle 97],
0370: * pour minimiser la sensibilité aux seuils.
0371: *
0372: * On crée des liens 1-n: (1 arc de comp) - (n arcs de ref).
0373: * Un arc de ref peut être alors concerné par plusieurs liens différents.
0374: * Au total on a donc des relations n-m codées sous la forme de n relations 1-m
0375: */
0376: public static EnsembleDeLiens preAppariementArcArc(
0377: CarteTopo reseau1, CarteTopo reseau2, ParametresApp param) {
0378: int nbCandidats = 0;
0379: ArcApp arcComp, arcRef;
0380: List arcsProches, candidats, distances = new ArrayList();
0381: ;
0382: LienReseaux lien;
0383: EnsembleDeLiens liens;
0384: Iterator itArcs, itArcsProches, itCandidats;
0385: double dmin, dmax, d;
0386:
0387: liens = new EnsembleDeLiens(LienReseaux.class);
0388: liens.setNom("Préappariement des arcs");
0389: itArcs = reseau2.getListeArcs().iterator();
0390: while (itArcs.hasNext()) {
0391: arcComp = (ArcApp) itArcs.next();
0392: // On recherche les arcs dans l'entourage proche, grosso modo
0393: arcsProches = reseau1.getPopArcs().select(
0394: arcComp.getGeometrie(), param.distanceArcsMax)
0395: .getElements();
0396: if (arcsProches.size() == 0)
0397: continue;
0398: // On calcule leur distance à arccomp et on recherche le plus proche
0399: distances.clear();
0400: itArcsProches = arcsProches.iterator();
0401: arcRef = (ArcApp) itArcsProches.next();
0402: dmin = arcComp.premiereComposanteHausdorff(arcRef,
0403: param.distanceArcsMax);
0404: distances.add(new Double(dmin));
0405: while (itArcsProches.hasNext()) {
0406: arcRef = (ArcApp) itArcsProches.next();
0407: d = arcComp.premiereComposanteHausdorff(arcRef,
0408: param.distanceArcsMax);
0409: distances.add(new Double(d));
0410: if (d < dmin)
0411: dmin = d;
0412: }
0413: // On garde tous ceux assez proches
0414: dmax = Math.min(dmin + param.distanceArcsMin,
0415: param.distanceArcsMax);
0416: candidats = new ArrayList();
0417: for (int i = 0; i < arcsProches.size(); i++) {
0418: d = ((Double) distances.get(i)).doubleValue();
0419: if (d < dmax)
0420: candidats.add(arcsProches.get(i));
0421: }
0422:
0423: // Si pas de candidat pour l'arccomp, on s'arrête là
0424: if (candidats.size() == 0)
0425: continue;
0426: // Si il y a des candidats: on construit le lien de pré-appariement
0427: lien = (LienReseaux) liens.nouvelElement();
0428: arcComp.addLiens(lien);
0429: lien.addArcs2(arcComp);
0430: nbCandidats = nbCandidats + candidats.size();
0431: itCandidats = candidats.iterator();
0432: while (itCandidats.hasNext()) {
0433: arcRef = (ArcApp) itCandidats.next();
0434: lien.addArcs1(arcRef);
0435: arcRef.addLiens(lien);
0436: }
0437: }
0438: if (param.debugAffichageCommentaires > 1)
0439: System.out.println(" Bilan : " + nbCandidats
0440: + " arcs comp candidats pour "
0441: + reseau1.getListeArcs().size() + " arcs ref");
0442: return liens;
0443: }
0444:
0445: /** Appariement des Noeuds du reseau 1 avec les arcs et noeuds du reseau 1,
0446: * comme proposé dans [Devogèle 97] + modif au filtrage Seb
0447: * On crée les liens qui vont bien si le noeud est apparié.
0448: * Une évaluation de l'appariement est stockée sur les liens (note de 0, 0.5 ou 1)
0449: * Une explication plus détaillée du résultat est stockée sur les noeuds ref et comp.
0450: */
0451: public static EnsembleDeLiens appariementNoeuds(CarteTopo reseau1,
0452: CarteTopo reseau2, EnsembleDeLiens liensPreAppNN,
0453: EnsembleDeLiens liensPreAppAA, ParametresApp param) {
0454: int j, k, l;
0455: Population groupesComp = reseau2.getPopGroupes();
0456: List complets, complets2, incomplets, incomplets2, noeudsCompCandidats, noeudsIncomplets, groupesConnexes, entrants, liensDuNoeudRef;
0457: NoeudApp noeudRef, noeudComp, noeudDeb;
0458: GroupeApp groupeComp;
0459: int nbSansHomologue = 0, nbNonTraite = 0, nbPlusieursNoeudsComplets = 0, nbPlusieursGroupesComplets = 0, nbNoeudNoeud = 0, nbNoeudGroupe = 0, nbNoeudGroupeIncertain = 0, nbNoeudNoeudIncertain = 0;
0460: int correspondance;
0461: Iterator itNoeuds;
0462: LienReseaux lien;
0463: EnsembleDeLiens liens;
0464:
0465: liens = new EnsembleDeLiens(LienReseaux.class);
0466: liens.setNom("Appariement des noeuds");
0467: // On initialise le resultat à "non apparié" pour les noeuds comp
0468: itNoeuds = reseau2.getPopNoeuds().getElements().iterator();
0469: while (itNoeuds.hasNext()) {
0470: noeudComp = (NoeudApp) itNoeuds.next();
0471: noeudComp.setResultatAppariement("Non apparié");
0472: }
0473:
0474: // On traite chaque noeud ref, un par un
0475: itNoeuds = reseau1.getPopNoeuds().getElements().iterator();
0476: while (itNoeuds.hasNext()) {
0477: noeudRef = (NoeudApp) itNoeuds.next();
0478: noeudRef.setResultatAppariement("Bug: valeur non remplie"); // pour détecter les cas non traités
0479: // On ne traite pas les noeuds isolés
0480: if (noeudRef.arcs().size() == 0) {
0481: noeudRef
0482: .setResultatAppariement("Non traité : noeud isolé");
0483: nbNonTraite++;
0484: continue;
0485: }
0486:
0487: liensDuNoeudRef = new ArrayList(noeudRef
0488: .getLiens(liensPreAppNN.getElements()));
0489:
0490: //////////////////////////////////////////////////////////////////
0491: // Noeud ref qui n'a aucun noeud comp candidat dans le pré-appariement
0492: if (liensDuNoeudRef.size() == 0) {
0493: noeudRef
0494: .setResultatAppariement("Non apparié, aucun candidat");
0495: nbSansHomologue++;
0496: continue;
0497: }
0498:
0499: //////////////////////////////////////////////////////////////////
0500: // Noeud ref qui a un ou plusieurs candidats (réunis dans un seul lien par construction)
0501: //
0502: // On qualifie des noeuds comp candidats en comparant les entrants/sortants
0503: // Un noeud comp est dit, par rapport au noeud ref, :
0504: // - complet si on trouve une correspondance entre tous les incidents des noeuds ref et comp,
0505: // - incomplet si on trouve une correspondance entre certains incidents
0506: // - impossible si on ne trouve aucune correspondance
0507: noeudsCompCandidats = ((LienReseaux) liensDuNoeudRef.get(0))
0508: .getNoeuds2();
0509: complets = new ArrayList();
0510: incomplets = new ArrayList();
0511: Iterator itNoeudsComp = noeudsCompCandidats.iterator();
0512: while (itNoeudsComp.hasNext()) {
0513: noeudComp = (NoeudApp) itNoeudsComp.next();
0514: correspondance = noeudRef.correspCommunicants(
0515: noeudComp, liensPreAppAA);
0516: if (correspondance == 1)
0517: complets.add(noeudComp);
0518: if (correspondance == 0)
0519: incomplets.add(noeudComp);
0520: }
0521:
0522: ////////////////////////////////////////////////////////////////////
0523: // Cas d'un appariement simple : 1 noeud BDref correspond à un noeud BDComp
0524: // C'est un appariement que l'on juge sûr.
0525: if (complets.size() == 1) {
0526: noeudComp = (NoeudApp) complets.get(0);
0527: noeudRef
0528: .setResultatAppariement("Apparié avec un noeud");
0529: noeudComp
0530: .setResultatAppariement("Apparié avec un noeud");
0531: nbNoeudNoeud++;
0532: lien = (LienReseaux) liens.nouvelElement();
0533: lien.addNoeuds1(noeudRef);
0534: noeudRef.addLiens(lien);
0535: lien.addNoeuds2(noeudComp);
0536: noeudComp.addLiens(lien);
0537: lien.setEvaluation(1);
0538: continue;
0539: }
0540:
0541: /////////////////////////////////////////////////////////////////////////
0542: // Cas où plusieurs noeuds comp candidats sont complets.
0543: // Ce cas ne devrait en théorie pas arriver d'après Thomas,
0544: // mais si en pratique les seuils sont larges, c'est un cas courant
0545: //
0546: // Ajout Seb pour filtrer ce sur-appariement : on choisit le plus proche (devrait être affiné)
0547: if (complets.size() > 1) {
0548: filtrageNoeudsComplets(complets, noeudRef);
0549: if (complets.size() == 1) {
0550: noeudRef
0551: .setResultatAppariement("Incertitude : choix fait parmi plusieurs noeuds complets");
0552: nbPlusieursNoeudsComplets++;
0553: lien = (LienReseaux) liens.nouvelElement();
0554: lien.addNoeuds1(noeudRef);
0555: noeudRef.addLiens(lien);
0556: noeudComp = (NoeudApp) complets.get(0);
0557: noeudComp
0558: .setResultatAppariement("Incertitude : choisi parmi plusieurs noeuds complets");
0559: lien.addNoeuds2(noeudComp);
0560: noeudComp.addLiens(lien);
0561: lien.setEvaluation(0.5);
0562: continue;
0563: }
0564: // Si il reste plusieurs noeuds complets après le filtrage
0565: // NB : cas impossible dans l'état actuel du filtrage qui ne garde qu'un noeud complet
0566: noeudRef
0567: .setResultatAppariement("Incertitude : apparié avec plusieurs noeuds complets");
0568: nbPlusieursNoeudsComplets++;
0569: lien = (LienReseaux) liens.nouvelElement();
0570: lien.addNoeuds1(noeudRef);
0571: noeudRef.addLiens(lien);
0572: for (j = 0; j < complets.size(); j++) {
0573: noeudComp = (NoeudApp) complets.get(j);
0574: noeudComp
0575: .setResultatAppariement("Incertitude : plusieurs noeuds complets concurrents");
0576: lien.addNoeuds2(noeudComp);
0577: noeudComp.addLiens(lien);
0578: }
0579: lien.setEvaluation(0);
0580: continue;
0581: }
0582:
0583: ///////////////////////////////////////////////////////////////////////////
0584: // Cas où il n'y a pas de noeud comp complet, mais un seul incomplet
0585: // Appariement simple : 1 noeud ref correspond à un noeud comp,
0586: // mais c'est un appariement que l'on juge incertain
0587: if (incomplets.size() == 1) {
0588: noeudComp = (NoeudApp) incomplets.get(0);
0589: noeudRef
0590: .setResultatAppariement("Incertitude : apparié avec un noeud incomplet");
0591: noeudComp
0592: .setResultatAppariement("Incertitude : noeud incomplet");
0593: nbNoeudNoeudIncertain++;
0594: lien = (LienReseaux) liens.nouvelElement();
0595: lien.addNoeuds1(noeudRef);
0596: noeudRef.addLiens(lien);
0597: lien.addNoeuds2(noeudComp);
0598: noeudComp.addLiens(lien);
0599: lien.setEvaluation(0.5);
0600: continue;
0601: }
0602:
0603: //////////////////////////////////////////////////////////////////
0604: // Le noeud ref n'a que des noeuds comp candidats impossibles
0605: // i.e. ils n'ont aucun arc sortant apparié avec un des arcs sortant du noeudref
0606: if (incomplets.size() == 0) {
0607: noeudRef
0608: .setResultatAppariement("Non apparié, tous candidats impossibles");
0609: nbSansHomologue++;
0610: continue;
0611: }
0612:
0613: //////////////////////////////////////////////////////////////////
0614: // Si il y a plusieurs noeuds incomplets,
0615: // MAIS on autorise uniquement les appariement 1-1 et 1-0 aux noeuds
0616: // On choisit alors le noeud incomplet le plus proche
0617: if (param.varianteForceAppariementSimple) {
0618: noeudComp = noeudLePlusProche(incomplets, noeudRef);
0619: noeudRef
0620: .setResultatAppariement("Incertitude : apparié avec un noeud incomplet");
0621: noeudComp
0622: .setResultatAppariement("Incertitude : noeud incomplet");
0623: nbNoeudNoeudIncertain++;
0624: lien = (LienReseaux) liens.nouvelElement();
0625: lien.addNoeuds1(noeudRef);
0626: noeudRef.addLiens(lien);
0627: lien.addNoeuds2(noeudComp);
0628: noeudComp.addLiens(lien);
0629: lien.setEvaluation(0.5);
0630: continue;
0631: }
0632:
0633: /////////////////////////////////////////////////////////////////////////
0634: /////////////////////////////////////////////////////////////////////////
0635: /////////////////////////////////////////////////////////////////////////
0636: // DEBUT TRAITEMENT DES CARREFOURS COMPLEXES :
0637: // (quand un noeud ref correpsond à un ensemble de noeuds et arcs dans BDcomp)
0638: /////////////////////////////////////////////////////////////////////////
0639: /////////////////////////////////////////////////////////////////////////
0640: /////////////////////////////////////////////////////////////////////////
0641:
0642: // On crée un nouveau groupe contenant tous les noeuds incomplets ainsi que
0643: // tous les arcs ayant aux 2 extrémités un de ces noeuds
0644: groupeComp = (GroupeApp) groupesComp.nouvelElement();
0645: noeudsIncomplets = new ArrayList(incomplets); //ajout pour mieux gérer le cas des groupes impossibles
0646: for (j = 0; j < incomplets.size(); j++) {
0647: noeudComp = (NoeudApp) incomplets.get(j);
0648: groupeComp.addNoeud(noeudComp);
0649: //noeudcomp.addGroupe(groupecomp);
0650: entrants = noeudComp.getEntrants();
0651: for (k = 0; k < entrants.size(); k++) {
0652: noeudDeb = (NoeudApp) ((ArcApp) entrants.get(k))
0653: .getNoeudIni();
0654: for (l = 0; l < incomplets.size(); l++) {
0655: if (noeudDeb == incomplets.get(l)) {
0656: groupeComp.addArc((ArcApp) entrants.get(k));
0657: //((Arc_App)entrants.get(k)).addGroupe(groupecomp);
0658: break;
0659: }
0660: }
0661: }
0662: }
0663:
0664: ///////////////////////////////////////////////////////////////////////////////
0665: // decomposition du groupe créé en groupes connexes
0666: groupesConnexes = groupeComp.decomposeConnexes();
0667:
0668: ///////////////////////////////////////////////////////////////////////////////
0669: // Choix du groupe connexe à conserver :
0670: // Qualification des groupes candidats en comparant les entrants/sortants
0671: // Un groupe comp est dit, par rapport au noeud ref, :
0672: // - complet si on trouve une correspondance entre tous les incidents des noeuds ref et comp,
0673: // - incomplet si on trouve une correspondance entre certains incidents
0674: // - impossible si on ne trouve aucune correspondance
0675: // NB: methode strictement similaire à ce qui était réalisé sur les noeuds
0676: complets = new ArrayList();
0677: incomplets = new ArrayList();
0678:
0679: for (j = 0; j < groupesConnexes.size(); j++) {
0680: groupeComp = (GroupeApp) groupesConnexes.get(j);
0681: correspondance = noeudRef.correspCommunicants(
0682: groupeComp, liensPreAppAA);
0683: if (correspondance == 1)
0684: complets.add(groupeComp);
0685: if (correspondance == 0)
0686: incomplets.add(groupeComp);
0687: }
0688:
0689: ///////////////////////////////////////////////////////////////////////////////
0690: // On a trouvé un unique groupe complet
0691: // C'est un appariement que l'on juge sûr
0692: if (complets.size() == 1) {
0693: // vidage des groupes rejetés, pour faire propre
0694: for (j = 0; j < incomplets.size(); j++) {
0695: ((GroupeApp) incomplets.get(j)).vide();
0696: }
0697: groupeComp = (GroupeApp) complets.get(0);
0698: // filtrage du groupe connexe choisi
0699: groupeComp.filtrageGroupePendantAppariementDesNoeuds(
0700: noeudRef, liensPreAppAA);
0701: if (groupeComp.getListeNoeuds().size() == 0) {
0702: noeudRef
0703: .setResultatAppariement("Non apparié, unique groupe complet vidé au filtrage");
0704: nbSansHomologue = nbSansHomologue + 1;
0705: continue;
0706: }
0707: if ((groupeComp.getListeNoeuds().size() == 1)
0708: && (groupeComp.getListeArcs().size() == 0)) {
0709: noeudComp = (NoeudApp) groupeComp.getListeNoeuds()
0710: .get(0);
0711: noeudRef
0712: .setResultatAppariement("Apparié à un noeud");
0713: noeudComp
0714: .setResultatAppariement("Apparié à un noeud");
0715: groupeComp.vide();
0716: nbNoeudNoeud++;
0717: lien = new LienReseaux();
0718: liens.add(lien);
0719: lien.addNoeuds1(noeudRef);
0720: noeudRef.addLiens(lien);
0721: lien.addNoeuds2(noeudComp);
0722: noeudComp.addLiens(lien);
0723: lien.setEvaluation(0.5);
0724: continue;
0725: } else {
0726: noeudRef
0727: .setResultatAppariement("Apparié à un groupe");
0728: groupeComp
0729: .setResultatAppariement("Apparié à un noeud");
0730: nbNoeudGroupe++;
0731: for (j = 0; j < groupeComp.getListeArcs().size(); j++) {
0732: ((ArcApp) groupeComp.getListeArcs().get(j))
0733: .setResultatAppariement("Apparié à un noeud, dans un groupe");
0734: }
0735: for (j = 0; j < groupeComp.getListeNoeuds().size(); j++) {
0736: ((NoeudApp) groupeComp.getListeNoeuds().get(j))
0737: .setResultatAppariement("Apparié à un noeud, dans un groupe");
0738: }
0739: lien = new LienReseaux();
0740: liens.add(lien);
0741: lien.addNoeuds1(noeudRef);
0742: noeudRef.addLiens(lien);
0743: lien.addGroupes2(groupeComp);
0744: groupeComp.addLiens(lien);
0745: lien.setEvaluation(1);
0746: continue;
0747: }
0748: }
0749:
0750: ///////////////////////////////////////////////////////////////////////////////
0751: // plusieurs groupes sont bien appariés (complets) avec un noeud ref
0752: // On est sur qu'il y a sur-appariement (à raffiner dans le futur si possible)
0753: // Cas qui ne devrait pas arriver d'après Thomas (si les seuils sont bien choisis !)
0754: if (complets.size() > 1) {
0755: // vidage des groupes rejetés, pour faire propre
0756: for (j = 0; j < incomplets.size(); j++) {
0757: ((GroupeApp) incomplets.get(j)).vide();
0758: }
0759:
0760: complets2 = new ArrayList();
0761: for (j = 0; j < complets.size(); j++) {
0762: groupeComp = (GroupeApp) complets.get(j);
0763: groupeComp
0764: .filtrageGroupePendantAppariementDesNoeuds(
0765: noeudRef, liensPreAppAA);
0766: if (groupeComp.getListeNoeuds().size() != 0)
0767: complets2.add(groupeComp);
0768: }
0769: complets = new ArrayList(complets2);
0770:
0771: // aucun goupe complet restant après les filtrages
0772: if (complets.size() == 0) {
0773: noeudRef
0774: .setResultatAppariement("Non apparié, groupes complets vidés au filtrage");
0775: nbSansHomologue++;
0776: continue;
0777: }
0778:
0779: // un seul goupe complet restant après les filtrages
0780: if (complets.size() == 1) {
0781: lien = new LienReseaux();
0782: liens.add(lien);
0783: noeudRef
0784: .setResultatAppariement("Incertitude : apparié à un groupe complet, autres groupes complets vidés au filtrage");
0785: nbNoeudGroupeIncertain++;
0786: groupeComp = (GroupeApp) complets.get(0);
0787: groupeComp
0788: .setResultatAppariement("Incertitude : seul groupe complet, autres groupes complets vidés au filtrage");
0789: for (k = 0; k < groupeComp.getListeArcs().size(); k++) {
0790: ((ArcApp) groupeComp.getListeArcs().get(k))
0791: .setResultatAppariement("Incertitude : dans un seul groupe complet, autres groupes complets vidés au filtrage");
0792: }
0793: for (k = 0; k < groupeComp.getListeNoeuds().size(); k++) {
0794: ((NoeudApp) groupeComp.getListeNoeuds().get(k))
0795: .setResultatAppariement("Incertitude : dans un seul groupe complet, autres groupes complets vidés au filtrage");
0796: }
0797: lien.setEvaluation(0.5);
0798: lien.addGroupes2(groupeComp);
0799: groupeComp.addLiens(lien);
0800: lien.addNoeuds1(noeudRef);
0801: noeudRef.addLiens(lien);
0802: continue;
0803: }
0804:
0805: // plusieurs goupes complets restant après les filtrages
0806: lien = new LienReseaux();
0807: liens.add(lien);
0808: noeudRef
0809: .setResultatAppariement("Incertitude : apparié à plusieurs groupes complets");
0810: nbPlusieursGroupesComplets++;
0811: for (j = 0; j < complets.size(); j++) {
0812: groupeComp = (GroupeApp) complets.get(j);
0813: groupeComp
0814: .setResultatAppariement("Incertitude : un de plusieurs groupes complets concurrents");
0815: for (k = 0; k < groupeComp.getListeArcs().size(); k++) {
0816: ((ArcApp) groupeComp.getListeArcs().get(k))
0817: .setResultatAppariement("Incertitude : dans un de plusieurs groupes complets concurrents");
0818: }
0819: for (k = 0; k < groupeComp.getListeNoeuds().size(); k++) {
0820: ((NoeudApp) groupeComp.getListeNoeuds().get(k))
0821: .setResultatAppariement("Incertitude : dans un de plusieurs groupes complets concurrents");
0822: }
0823: lien.addGroupes2(groupeComp);
0824: groupeComp.addLiens(lien);
0825: }
0826: lien.setEvaluation(0);
0827: lien.addNoeuds1(noeudRef);
0828: noeudRef.addLiens(lien);
0829: continue;
0830: }
0831:
0832: ///////////////////////////////////////////////////////////////////////////////
0833: // On a trouvé un unique groupe incomplet
0834: // C'est un appariement que l'on accepte mais qu'on l'on juge incertain
0835: if (incomplets.size() == 1) {
0836: groupeComp = (GroupeApp) incomplets.get(0);
0837: groupeComp.filtrageGroupePendantAppariementDesNoeuds(
0838: noeudRef, liensPreAppAA);
0839: if (groupeComp.getListeNoeuds().size() == 0) {
0840: noeudRef
0841: .setResultatAppariement("Non apparié, seul goupe incomplet vidé au filtrage");
0842: nbSansHomologue++;
0843: continue;
0844: }
0845: if ((groupeComp.getListeNoeuds().size() == 1)
0846: && (groupeComp.getListeArcs().size() == 0)) {
0847: noeudComp = (NoeudApp) groupeComp.getListeNoeuds()
0848: .get(0);
0849: noeudRef
0850: .setResultatAppariement("Apparié à un noeud");
0851: noeudComp
0852: .setResultatAppariement("Apparié à un noeud");
0853: groupeComp.vide();
0854: nbNoeudNoeudIncertain++;
0855: lien = new LienReseaux();
0856: liens.add(lien);
0857: lien.addNoeuds1(noeudRef);
0858: noeudRef.addLiens(lien);
0859: lien.addNoeuds2(noeudComp);
0860: noeudComp.addLiens(lien);
0861: lien.setEvaluation(0.5);
0862: continue;
0863: } else {
0864: noeudRef
0865: .setResultatAppariement("Incertitude : apparié à un groupe incomplet");
0866: nbNoeudGroupeIncertain = nbNoeudGroupeIncertain + 1;
0867: groupeComp
0868: .setResultatAppariement("Incertitude : groupe incomplet");
0869: for (k = 0; k < groupeComp.getListeArcs().size(); k++) {
0870: ((ArcApp) groupeComp.getListeArcs().get(k))
0871: .setResultatAppariement("Incertitude : dans groupe incomplet");
0872: }
0873: for (k = 0; k < groupeComp.getListeNoeuds().size(); k++) {
0874: ((NoeudApp) groupeComp.getListeNoeuds().get(k))
0875: .setResultatAppariement("Incertitude : dans groupe incomplet");
0876: }
0877: //param.db.create(groupeComp);
0878: lien = new LienReseaux();
0879: liens.add(lien);
0880: lien.setEvaluation(0.5);
0881: lien.addNoeuds1(noeudRef);
0882: noeudRef.addLiens(lien);
0883: lien.addGroupes2(groupeComp);
0884: groupeComp.addLiens(lien);
0885: continue;
0886: }
0887: }
0888:
0889: ///////////////////////////////////////////////////////////////////////////////
0890: // On a trouvé plusieurs groupes incomplets
0891: // C'est un appariement que l'on accepte peut-être mais que l'on sait incohérent
0892: if (incomplets.size() > 1) {
0893: incomplets2 = new ArrayList();
0894: for (j = 0; j < incomplets.size(); j++) {
0895: groupeComp = (GroupeApp) incomplets.get(j);
0896: groupeComp
0897: .filtrageGroupePendantAppariementDesNoeuds(
0898: noeudRef, liensPreAppAA);
0899: if (groupeComp.getListeNoeuds().size() != 0)
0900: incomplets2.add(groupeComp);
0901: }
0902: incomplets = new ArrayList(incomplets2);
0903:
0904: // aucun goupe incomplet restant après le filtrage
0905: if (incomplets.size() == 0) {
0906: noeudRef
0907: .setResultatAppariement("Non apparié, groupes incomplets vidés au filtrage");
0908: nbSansHomologue = nbSansHomologue + 1;
0909: continue;
0910: }
0911:
0912: // un seul goupe incomplet restant après le filtrage
0913: if (incomplets.size() == 1) {
0914: lien = new LienReseaux();
0915: liens.add(lien);
0916: groupeComp = (GroupeApp) incomplets.get(0);
0917: groupeComp
0918: .setResultatAppariement("Incertitude : incomplet, autres groupes incomplets vidés au filtrage");
0919: for (k = 0; k < groupeComp.getListeArcs().size(); k++) {
0920: ((ArcApp) groupeComp.getListeArcs().get(k))
0921: .setResultatAppariement("Incertitude : dans groupe incomplet, autres groupes incomplets vidés au filtrage");
0922: }
0923: for (k = 0; k < groupeComp.getListeNoeuds().size(); k++) {
0924: ((NoeudApp) groupeComp.getListeNoeuds().get(k))
0925: .setResultatAppariement("Incertitude : dans groupe incomplet, autres groupes incomplets vidés au filtrage");
0926: }
0927: lien.addGroupes2(groupeComp);
0928: groupeComp.addLiens(lien);
0929: noeudRef
0930: .setResultatAppariement("Incertitude : apparié à groupe incomplet, autres groupes incomplets vidés au filtrage");
0931: nbNoeudGroupeIncertain++;
0932: lien.addNoeuds1(noeudRef);
0933: noeudRef.addLiens(lien);
0934: lien.setEvaluation(0.5);
0935: continue;
0936: }
0937:
0938: // plusieurs goupes incomplets restant après les filtrages
0939: lien = new LienReseaux();
0940: liens.add(lien);
0941: for (j = 0; j < incomplets.size(); j++) {
0942: groupeComp = (GroupeApp) incomplets.get(j);
0943: groupeComp
0944: .setResultatAppariement("Incertitude : parmi plusieurs groupes incomplets");
0945: for (k = 0; k < groupeComp.getListeArcs().size(); k++) {
0946: ((ArcApp) groupeComp.getListeArcs().get(k))
0947: .setResultatAppariement("Incertitude : dans un de plusieurs groupes incomplets");
0948: }
0949: for (k = 0; k < groupeComp.getListeNoeuds().size(); k++) {
0950: ((NoeudApp) groupeComp.getListeNoeuds().get(k))
0951: .setResultatAppariement("Incertitude : dans un de plusieurs groupes incomplets");
0952: }
0953: lien.addGroupes2(groupeComp);
0954: groupeComp.addLiens(lien);
0955: }
0956: noeudRef
0957: .setResultatAppariement("Incertitude : apparié à plusieurs groupes incomplets");
0958: nbPlusieursGroupesComplets++;
0959: lien.addNoeuds1(noeudRef);
0960: noeudRef.addLiens(lien);
0961: lien.setEvaluation(0);
0962: continue;
0963: }
0964:
0965: if (incomplets.size() == 0) { // ajout Seb 31/05/05
0966: noeudRef
0967: .setResultatAppariement("Incertitude : groupes candidats impossibles, choix fait parmis les noeuds incomplets");
0968: nbNoeudNoeudIncertain++;
0969: lien = new LienReseaux();
0970: liens.add(lien);
0971: lien.addNoeuds1(noeudRef);
0972: noeudRef.addLiens(lien);
0973: lien.setEvaluation(0.5);
0974: for (j = 0; j < noeudsIncomplets.size(); j++) {
0975: noeudComp = (NoeudApp) noeudsIncomplets.get(j);
0976: noeudComp
0977: .setResultatAppariement("Incertitude : groupes candidats impossibles, choix fait parmis les noeuds incomplets");
0978: lien.addNoeuds2(noeudComp);
0979: noeudComp.addLiens(lien);
0980: }
0981: continue;
0982: }
0983: }
0984:
0985: // pour le réseau routier uniquement: on traite le cas des rond-points
0986: // si un noeud est apparié avec une partie de rond point,
0987: // il devient apparié avec l'ensemble du rond point
0988: if (param.varianteChercheRondsPoints)
0989: rondsPoints(reseau1, reseau2, liens, liensPreAppAA, param);
0990:
0991: // Fin, affichage du bilan
0992: if (param.debugAffichageCommentaires > 1)
0993: System.out.println(" Bilan des noeuds:");
0994: if (param.debugAffichageCommentaires > 1)
0995: System.out.println(" Appariement jugés corrects : ");
0996: if (param.debugAffichageCommentaires > 1)
0997: System.out.println(" " + nbNoeudNoeud
0998: + " noeuds 1 appariés avec un seul noeud");
0999: if (param.debugAffichageCommentaires > 1)
1000: System.out.println(" " + nbNoeudGroupe
1001: + " noeuds 1 appariés avec un groupe");
1002: if (param.debugAffichageCommentaires > 1)
1003: System.out.println(" Appariement jugés incertains : ");
1004: if (param.debugAffichageCommentaires > 1)
1005: System.out.println(" " + nbNoeudNoeudIncertain
1006: + " noeuds 1 appariés avec un noeud incomplet");
1007: if (param.debugAffichageCommentaires > 1)
1008: System.out.println(" " + nbPlusieursNoeudsComplets
1009: + " noeuds 1 avec plusieurs noeuds complets");
1010: if (param.debugAffichageCommentaires > 1)
1011: System.out.println(" " + nbNoeudGroupeIncertain
1012: + " noeuds 1 appariés avec un groupe incomplet");
1013: if (param.debugAffichageCommentaires > 1)
1014: System.out.println(" Appariement jugés incohérents : ");
1015: if (param.debugAffichageCommentaires > 1)
1016: System.out
1017: .println(" "
1018: + nbSansHomologue
1019: + " noeuds 1 sans homolgues trouvés dans le préappariement");
1020: if (param.debugAffichageCommentaires > 1)
1021: System.out.println(" " + nbPlusieursGroupesComplets
1022: + " noeuds 1 avec plusieurs homologues groupes");
1023: if (param.debugAffichageCommentaires > 1)
1024: System.out.println(" Noeuds non traités : ");
1025: if (param.debugAffichageCommentaires > 1)
1026: System.out.println(" " + nbNonTraite
1027: + " noeuds 1 isolés");
1028: return liens;
1029: }
1030:
1031: // pour le réseau routier uniquement: on traite le cas des rond-points
1032: // si un noeud est apparié avec une partie de rond point,
1033: // il devient apparié avec l'ensemble du rond point
1034: private static void rondsPoints(CarteTopo reseau1,
1035: CarteTopo reseau2, EnsembleDeLiens liens_Noeuds,
1036: EnsembleDeLiens liensPreAppAA, ParametresApp param) {
1037: double compacite;
1038: Iterator itGroupesDuNoeud, itNoeudsDuRondPoint, itNoeudsDuRondPoint2, itArcsDuRondPoint, itLiensDuNoeudsDuRondPoint;
1039: List noeudsDuRondPoint, liensDuNoeudDuRondPoint;
1040: LienReseaux lien;
1041: NoeudApp noeud, noeud2, noeudRef;
1042: GroupeApp rondPoint;
1043: ArcApp arc2;
1044: Iterator itFaces = reseau2.getPopFaces().getElements()
1045: .iterator();
1046:
1047: while (itFaces.hasNext()) {
1048: Face face = (Face) itFaces.next();
1049: compacite = IndicesForme.indiceCompacite(face
1050: .getGeometrie());
1051: if (compacite < 0.95)
1052: continue;
1053: if (face.getGeometrie().area() > 8000)
1054: continue; //rond point de diametre>100m
1055: noeudsDuRondPoint = face.noeuds();
1056: itNoeudsDuRondPoint = noeudsDuRondPoint.iterator();
1057: while (itNoeudsDuRondPoint.hasNext()) {
1058: noeud = (NoeudApp) itNoeudsDuRondPoint.next();
1059: liensDuNoeudDuRondPoint = noeud.getLiens(liens_Noeuds
1060: .getElements());
1061: itLiensDuNoeudsDuRondPoint = liensDuNoeudDuRondPoint
1062: .iterator();
1063: // Pour un lien d'un noeud du rond point, 2 cas possibles:
1064: // 1/ avant ce lien ne pointait que vers ce noeud
1065: while (itLiensDuNoeudsDuRondPoint.hasNext()) {
1066: lien = (LienReseaux) itLiensDuNoeudsDuRondPoint
1067: .next();
1068: noeudRef = (NoeudApp) lien.getNoeuds1().get(0);
1069: if (lien.getNoeuds2().size() == 1) { // cas 1
1070: rondPoint = (GroupeApp) reseau2.getPopGroupes()
1071: .nouvelElement();
1072: rondPoint.addAllNoeuds(noeudsDuRondPoint);
1073: rondPoint.addAllArcs(face.arcs());
1074: lien.getNoeuds2().clear();
1075: noeud.getLiens().remove(lien);
1076: lien.addGroupes2(rondPoint);
1077: rondPoint.addLiens(lien);
1078: if (noeudRef.correspCommunicants(rondPoint,
1079: liensPreAppAA) == 1) {
1080: lien.setEvaluation(1);
1081: rondPoint
1082: .setResultatAppariement("Apparié à un noeud (rond-point)");
1083: for (int k = 0; k < rondPoint
1084: .getListeArcs().size(); k++) {
1085: ((ArcApp) rondPoint.getListeArcs().get(
1086: k))
1087: .setResultatAppariement("Apparié à un noeud, dans un rond-point");
1088: }
1089: for (int k = 0; k < rondPoint
1090: .getListeNoeuds().size(); k++) {
1091: ((NoeudApp) rondPoint.getListeNoeuds()
1092: .get(k))
1093: .setResultatAppariement("Apparié à un noeud, dans un rond-point");
1094: }
1095: } else {
1096: rondPoint
1097: .setResultatAppariement("Incertitude: Apparié à un noeud (rond-point incomplet)");
1098: for (int k = 0; k < rondPoint
1099: .getListeArcs().size(); k++) {
1100: ((ArcApp) rondPoint.getListeArcs().get(
1101: k))
1102: .setResultatAppariement("Incertitude: Apparié à un noeud, dans un rond-point incomplet");
1103: }
1104: for (int k = 0; k < rondPoint
1105: .getListeNoeuds().size(); k++) {
1106: ((NoeudApp) rondPoint.getListeNoeuds()
1107: .get(k))
1108: .setResultatAppariement("Incertitude: Apparié à un noeud, dans un rond-point incomplet");
1109: }
1110: }
1111: continue;
1112: }
1113: }
1114: // 2/ avant ce lien pointait vers une partie du rond point
1115: itGroupesDuNoeud = noeud.getListeGroupes().iterator();
1116: while (itGroupesDuNoeud.hasNext()) {
1117: GroupeApp groupe = (GroupeApp) itGroupesDuNoeud
1118: .next();
1119: List liens = groupe.getLiens(liens_Noeuds
1120: .getElements());
1121: if (liens.size() == 0)
1122: continue;
1123: if (groupe.getLiens().size() == 0)
1124: continue;
1125: if (liens_Noeuds.getElements().contains(
1126: groupe.getLiens().get(0))) {
1127: itNoeudsDuRondPoint2 = noeudsDuRondPoint
1128: .iterator();
1129: while (itNoeudsDuRondPoint2.hasNext()) {
1130: noeud2 = (NoeudApp) itNoeudsDuRondPoint2
1131: .next();
1132: if (!groupe.getListeNoeuds().contains(
1133: noeud2))
1134: groupe.addNoeud(noeud2);
1135: }
1136: itArcsDuRondPoint = face.arcs().iterator();
1137: while (itArcsDuRondPoint.hasNext()) {
1138: arc2 = (ArcApp) itArcsDuRondPoint.next();
1139: if (!groupe.getListeArcs().contains(arc2))
1140: groupe.addArc(arc2);
1141: }
1142: }
1143: lien = (LienReseaux) liens.get(0);
1144: noeudRef = (NoeudApp) lien.getNoeuds1().get(0);
1145: if (noeudRef.correspCommunicants(groupe,
1146: liensPreAppAA) == 1) {
1147: lien.setEvaluation(1);
1148: groupe
1149: .setResultatAppariement("Apparié à un noeud (rond-point)");
1150: for (int k = 0; k < groupe.getListeArcs()
1151: .size(); k++) {
1152: ((ArcApp) groupe.getListeArcs().get(k))
1153: .setResultatAppariement("Apparié à un noeud, dans un rond-point");
1154: }
1155: for (int k = 0; k < groupe.getListeNoeuds()
1156: .size(); k++) {
1157: ((NoeudApp) groupe.getListeNoeuds().get(k))
1158: .setResultatAppariement("Apparié à un noeud, dans un rond-point");
1159: }
1160: } else {
1161: groupe
1162: .setResultatAppariement("Incertitude: Apparié à un noeud (rond-point incomplet)");
1163: for (int k = 0; k < groupe.getListeArcs()
1164: .size(); k++) {
1165: ((ArcApp) groupe.getListeArcs().get(k))
1166: .setResultatAppariement("Incertitude: Apparié à un noeud, dans un rond-point incomplet");
1167: }
1168: for (int k = 0; k < groupe.getListeNoeuds()
1169: .size(); k++) {
1170: ((NoeudApp) groupe.getListeNoeuds().get(k))
1171: .setResultatAppariement("Incertitude: Apparié à un noeud, dans un rond-point incomplet");
1172: }
1173: }
1174:
1175: }
1176: }
1177: }
1178: }
1179:
1180: /** on ne garde que le noeud comp le plus proche */
1181: private static void filtrageNoeudsComplets(List complets,
1182: NoeudApp noeudRef) {
1183: int i;
1184: NoeudApp noeudComp, noeudPlusProche;
1185: double d, dmin;
1186:
1187: if (complets.size() <= 1)
1188: return;
1189: noeudPlusProche = (NoeudApp) complets.get(0);
1190: dmin = noeudPlusProche.distance(noeudRef);
1191: for (i = 1; i < complets.size(); i++) {
1192: noeudComp = (NoeudApp) complets.get(i);
1193: d = noeudComp.distance(noeudRef);
1194: if (d < dmin) {
1195: dmin = d;
1196: noeudPlusProche = noeudComp;
1197: }
1198: }
1199: complets.clear();
1200: complets.add(noeudPlusProche);
1201: }
1202:
1203: /** renvoie le noeud de 'noeuds' le plus proche de 'noeudRef' */
1204: private static NoeudApp noeudLePlusProche(List noeuds,
1205: NoeudApp noeudRef) {
1206: if (noeuds.size() < 1)
1207: return null;
1208: Iterator itNoeuds = noeuds.iterator();
1209: NoeudApp plusProche = (NoeudApp) itNoeuds.next();
1210: double dmin = plusProche.distance(noeudRef);
1211: while (itNoeuds.hasNext()) {
1212: NoeudApp noeud = (NoeudApp) itNoeuds.next();
1213: double d = noeud.distance(noeudRef);
1214: if (d < dmin) {
1215: dmin = d;
1216: plusProche = noeud;
1217: }
1218: }
1219: return plusProche;
1220: }
1221:
1222: /** Appariement des arcs, s'appuyant sur un appariement préalable des noeuds,
1223: * et sur un pré-appariement des arcs.
1224: * S'appuie essentiellement sur la notion de 'plus proche chemin d'un arc', défini
1225: * comme le chemin minimisant la surface entre le chemin et l'arc.
1226: */
1227: public static EnsembleDeLiens appariementArcs(CarteTopo reseau1,
1228: CarteTopo reseau2, EnsembleDeLiens liensPreAppAA,
1229: EnsembleDeLiens liensAppNoeuds, ParametresApp param) {
1230:
1231: GroupeApp tousCandidats, pccMin1, pccMin2;
1232: ArcApp arcRef, arcComp;
1233: NoeudApp noeudComp;
1234: List tousArcs = new ArrayList();
1235: List noeudsDebutIn, noeudsDebutOut, noeudsFinIn, noeudsFinOut;
1236: double longMaxRecherche;
1237: int nbSansHomologuePbNoeud = 0, nbSansHomologuePbPCC = 0, nbOkUneSerie = 0, nbOkPlusieursSeries = 0, nbDouteuxPbNoeud = 0, nbDouteuxPbSens = 0, nbTot;
1238: double longSansHomologuePbNoeud = 0, longSansHomologuePbPCC = 0, longOkUneSerie = 0, longOkPlusieursSeries = 0, longDouteuxPbNoeud = 0, longDouteuxPbSens = 0, longTot;
1239: LienReseaux lien;
1240: EnsembleDeLiens liensArcsArcs = new EnsembleDeLiens(
1241: LienReseaux.class);
1242: Iterator itArcs, itTousArcsComp;
1243:
1244: liensArcsArcs.setNom("Appariement des arcs");
1245:
1246: // on étudie tous les arc ref, un par un, indépendamment les uns des autres
1247: itArcs = reseau1.getPopArcs().getElements().iterator();
1248: while (itArcs.hasNext()) {
1249: arcRef = (ArcApp) itArcs.next();
1250: arcRef.setResultatAppariement("Bug: valeur non remplie"); // pour vérifier que tous les cas sont bien traités
1251:
1252: ///////// ETUDE DES EXTREMITES DE L'ARC /////////
1253:
1254: // Problème de topologie ?
1255: if ((arcRef.getNoeudIni() == null)
1256: || (arcRef.getNoeudFin() == null)) {
1257: // Cas 1 : l'arc n'a pas de noeud à une de ses extrêmités
1258: arcRef
1259: .setResultatAppariement("Non apparié, arc sans extrémité");
1260: nbSansHomologuePbNoeud++;
1261: longSansHomologuePbNoeud = longSansHomologuePbNoeud
1262: + arcRef.longueur();
1263: continue;
1264: }
1265:
1266: // On ne sait pas traiter les boucles (CODE A AFFINER POUR FAIRE CELA)
1267: if ((arcRef.getNoeudIni() == arcRef.getNoeudFin())) {
1268: arcRef
1269: .setResultatAppariement("Non apparié, on ne sait pas traiter les boucles");
1270: nbSansHomologuePbPCC++;
1271: longSansHomologuePbPCC = longSansHomologuePbPCC
1272: + arcRef.longueur();
1273: continue;
1274: }
1275:
1276: // Recherche des noeuds en correspondance avec les extrémités de l'arc,
1277: // que ce soit en entree ou en sortie pour l'arc (au sens de la circulation)
1278: List noeudsInOut = arcRef
1279: .noeudsEnCorrespondanceAuxExtremites(
1280: liensAppNoeuds, liensPreAppAA);
1281: noeudsDebutIn = (List) noeudsInOut.get(0);
1282: noeudsDebutOut = (List) noeudsInOut.get(1);
1283: noeudsFinIn = (List) noeudsInOut.get(2);
1284: noeudsFinOut = (List) noeudsInOut.get(3);
1285:
1286: if (((noeudsFinIn.size() == 0) && (noeudsFinOut.size() == 0))
1287: || ((noeudsDebutIn.size() == 0) && (noeudsDebutOut
1288: .size() == 0))) {
1289: // Cas 2 : un noeud extrémité n'est pas apparié
1290: arcRef
1291: .setResultatAppariement("Non apparié, noeud extrémité non apparié");
1292: nbSansHomologuePbNoeud++;
1293: longSansHomologuePbNoeud = longSansHomologuePbNoeud
1294: + arcRef.longueur();
1295: continue;
1296: }
1297:
1298: ///////// CALCUL DES PLUS COURTS CHEMINS /////////
1299:
1300: // creation d'un groupe "tousCandidats" avec tous les arcs candidats
1301: // issus du pré-appariement
1302: tousArcs = arcRef.arcsCompEnCorrespondance(liensPreAppAA);
1303: tousCandidats = (GroupeApp) reseau2.getPopGroupes()
1304: .nouvelElement();
1305: tousCandidats.setListeArcs(tousArcs);
1306: itTousArcsComp = tousArcs.iterator();
1307: while (itTousArcsComp.hasNext()) {
1308: arcComp = (ArcApp) itTousArcsComp.next();
1309: arcComp.addGroupe(tousCandidats);
1310: }
1311: tousCandidats.ajouteNoeuds();
1312: // Pour éviter les débordements, on ne cherche que les pcc pas trop grands
1313: //longMaxRecherche = arcRef.getGeometrie().length()*5*param.coefficentPoidsLongueurDistance;
1314: longMaxRecherche = arcRef.getGeometrie().length()
1315: * param.distanceArcsMax;
1316:
1317: //calcul du poids des arcs
1318: calculePoids(arcRef, tousCandidats, param);
1319:
1320: // Recherche du PCC dans un sens, et dans l'autre si l'arc est en double sens
1321: pccMin1 = tousCandidats.plusCourtChemin(noeudsDebutOut,
1322: noeudsFinIn, longMaxRecherche);
1323: pccMin2 = tousCandidats.plusCourtChemin(noeudsFinOut,
1324: noeudsDebutIn, longMaxRecherche);
1325: tousCandidats.videEtDetache();
1326:
1327: ///////// ANALYSE DES PLUS COURTS CHEMINS /////////
1328:
1329: // cas 3 : on n'a trouvé aucun plus court chemin, dans aucun sens
1330: if ((pccMin1 == null) && (pccMin2 == null)) {
1331: arcRef
1332: .setResultatAppariement("Non apparié, pas de plus court chemin");
1333: nbSansHomologuePbPCC++;
1334: longSansHomologuePbPCC = longSansHomologuePbPCC
1335: + arcRef.longueur();
1336: continue;
1337: }
1338:
1339: // cas 4 : on a trouvé un pcc dans un seul sens: celui direct
1340: if (pccMin1 == null) {
1341: lien = (LienReseaux) liensArcsArcs.nouvelElement();
1342: lien.addArcs1(arcRef);
1343: arcRef.addLiens(lien);
1344: if (pccMin2.getListeArcs().size() == 0) {
1345: // cas 4a : on a trouvé un pcc mais il est réduit à un point
1346: noeudComp = (NoeudApp) pccMin2.getListeNoeuds()
1347: .get(0);
1348: lien.addNoeuds2(noeudComp);
1349: lien.setEvaluation(0.5);
1350: noeudComp.addLiens(lien);
1351: arcRef
1352: .setResultatAppariement("Incertitude : Apparié à un noeud comp");
1353: noeudComp
1354: .setResultatAppariement("Incertitude : Apparié à un arc");
1355: pccMin2.videEtDetache();
1356: nbDouteuxPbNoeud++;
1357: longDouteuxPbNoeud = longDouteuxPbNoeud
1358: + arcRef.longueur();
1359: continue;
1360: }
1361: pccMin2.enleveExtremites();
1362: lien.addGroupes2(pccMin2);
1363: pccMin2.addLiens(lien);
1364: if (arcRef.getOrientation() == -1) {
1365: // cas 4b : on a trouvé un pcc dans un seul sens, et c'est normal
1366: lien.setEvaluation(1);
1367: arcRef
1368: .setResultatAppariement("Apparié à un arc ou une suite d'arcs");
1369: pccMin2
1370: .setResultatAppariementGlobal("Apparié à un arc ref");
1371: nbOkUneSerie++;
1372: longOkUneSerie = longOkUneSerie + arcRef.longueur();
1373: } else {
1374: // cas 4c : on a trouvé un pcc dans un seul sens, mais ce n'est pas normal
1375: lien.setEvaluation(0.5);
1376: arcRef
1377: .setResultatAppariement("Incertitude : Apparié que dans un sens");
1378: pccMin2
1379: .setResultatAppariementGlobal("Incertitude : Apparié que dans un sens");
1380: nbDouteuxPbSens++;
1381: longDouteuxPbSens = longDouteuxPbSens
1382: + arcRef.longueur();
1383: }
1384: continue;
1385: }
1386:
1387: // cas 4 : on a trouvé un pcc dans un seul sens: celui indirect
1388: if (pccMin2 == null) {
1389: lien = (LienReseaux) liensArcsArcs.nouvelElement();
1390: lien.addArcs1(arcRef);
1391: arcRef.addLiens(lien);
1392: if (pccMin1.getListeArcs().size() == 0) {
1393: // cas 4a : on a trouvé un pcc mais il est réduit à un point
1394: noeudComp = (NoeudApp) pccMin1.getListeNoeuds()
1395: .get(0);
1396: lien.addNoeuds2(noeudComp);
1397: lien.setEvaluation(0.5);
1398: noeudComp.addLiens(lien);
1399: arcRef
1400: .setResultatAppariement("Incertitude : Apparié à un noeud comp");
1401: noeudComp
1402: .setResultatAppariement("Incertitude : Apparié à un arc");
1403: pccMin1.videEtDetache();
1404: nbDouteuxPbNoeud++;
1405: longDouteuxPbNoeud = longDouteuxPbNoeud
1406: + arcRef.longueur();
1407: continue;
1408: }
1409: pccMin1.enleveExtremites();
1410: lien.addGroupes2(pccMin1);
1411: pccMin1.addLiens(lien);
1412: // pour noter le résultat sur les objets concernés
1413: if (arcRef.getOrientation() == 1) {
1414: // cas 4a : on a trouvé un pcc dans un seul sens, et c'est normal
1415: lien.setEvaluation(1);
1416: arcRef
1417: .setResultatAppariement("Apparié à un arc ou une suite d'arcs");
1418: pccMin1
1419: .setResultatAppariementGlobal("Apparié à un arc ref");
1420: nbOkUneSerie++;
1421: longOkUneSerie = longOkUneSerie + arcRef.longueur();
1422: } else {
1423: // cas 4b : on a trouvé un pcc dans un seul sens, mais ce n'est pas normal
1424: lien.setEvaluation(0.5);
1425: arcRef
1426: .setResultatAppariement("Incertitude : Apparié que dans un sens");
1427: pccMin1
1428: .setResultatAppariementGlobal("Incertitude : Apparié que dans un sens");
1429: nbDouteuxPbSens++;
1430: longDouteuxPbSens = longDouteuxPbSens
1431: + arcRef.longueur();
1432: }
1433: continue;
1434: }
1435:
1436: // cas 5 : on a trouvé un pcc dans les 2 sens, et c'est le même
1437: if (pccMin1.contientMemesArcs(pccMin2)) {
1438: pccMin2.videEtDetache();
1439: lien = (LienReseaux) liensArcsArcs.nouvelElement();
1440: lien.addArcs1(arcRef);
1441: arcRef.addLiens(lien);
1442: if (pccMin1.getListeArcs().size() == 0) {
1443: // cas 5a : on a trouvé un pcc mais il est réduit à un point
1444: noeudComp = (NoeudApp) pccMin1.getListeNoeuds()
1445: .get(0);
1446: lien.addNoeuds2(noeudComp);
1447: lien.setEvaluation(0.5);
1448: noeudComp.addLiens(lien);
1449: arcRef
1450: .setResultatAppariement("Incertitude : Apparié à un noeud comp");
1451: noeudComp
1452: .setResultatAppariement("Incertitude : Apparié à un arc");
1453: pccMin1.videEtDetache();
1454: nbDouteuxPbNoeud++;
1455: longDouteuxPbNoeud = longDouteuxPbNoeud
1456: + arcRef.longueur();
1457: continue;
1458: }
1459: pccMin1.enleveExtremites();
1460: // cas 5b : on a trouvé un pcc dans les 2 sens, non réduit à un point
1461: lien.addGroupes2(pccMin1);
1462: lien.setEvaluation(1);
1463: pccMin1.addLiens(lien);
1464: arcRef.setResultatAppariement("Apparié à un arc");
1465: pccMin1
1466: .setResultatAppariementGlobal("Apparié à un arc");
1467: nbOkUneSerie++;
1468: longOkUneSerie = longOkUneSerie + arcRef.longueur();
1469: continue;
1470: }
1471:
1472: // cas 6 : on a trouvé un pcc dans les 2 sens, mais ce n'est pas le même
1473: // cas d'arcs en parralèle
1474: lien = (LienReseaux) liensArcsArcs.nouvelElement();
1475: lien.addArcs1(arcRef);
1476: arcRef.addLiens(lien);
1477: if (pccMin1.getListeArcs().size() == 0) {
1478: // cas 6a : on a trouvé un pcc mais il est réduit à un point
1479: noeudComp = (NoeudApp) pccMin1.getListeNoeuds().get(0);
1480: lien.addNoeuds2(noeudComp);
1481: lien.setEvaluation(0.5);
1482: noeudComp.addLiens(lien);
1483: arcRef
1484: .setResultatAppariement("Incertitude : Apparié à un noeud comp");
1485: noeudComp
1486: .setResultatAppariement("Incertitude : Apparié à un arc");
1487: pccMin1.videEtDetache();
1488: } else {
1489: // cas 6b : on a trouvé un pcc non réduit à un point
1490: pccMin1.enleveExtremites();
1491: lien.setEvaluation(1);
1492: lien.addGroupes2(pccMin1);
1493: pccMin1.addLiens(lien);
1494: arcRef
1495: .setResultatAppariement("Apparié à plusieurs arcs en parallèle");
1496: pccMin1
1497: .setResultatAppariementGlobal("Apparié à un arc");
1498: }
1499: if (pccMin2.getListeArcs().size() == 0) {
1500: // cas 6a : on a trouvé un pcc mais il est réduit à un point
1501: noeudComp = (NoeudApp) pccMin2.getListeNoeuds().get(0);
1502: lien.addNoeuds2(noeudComp);
1503: lien.setEvaluation(0.5);
1504: noeudComp.addLiens(lien);
1505: arcRef
1506: .setResultatAppariement("Incertitude : Apparié à un noeud comp");
1507: noeudComp
1508: .setResultatAppariement("Incertitude : Apparié à un arc");
1509: pccMin2.videEtDetache();
1510: nbDouteuxPbNoeud++;
1511: longDouteuxPbNoeud = longDouteuxPbNoeud
1512: + arcRef.longueur();
1513: } else {
1514: // cas 6b : on a trouvé un pcc non réduit à un point
1515: pccMin2.enleveExtremites();
1516: lien.addGroupes2(pccMin2);
1517: pccMin2.addLiens(lien);
1518: arcRef
1519: .setResultatAppariement("Apparié à plusieurs arcs en parallèle");
1520: pccMin2
1521: .setResultatAppariementGlobal("Apparié à un arc");
1522: if (lien.getEvaluation() == 1) {
1523: nbOkPlusieursSeries++;
1524: longOkPlusieursSeries = longOkPlusieursSeries
1525: + arcRef.longueur();
1526: } else {
1527: nbDouteuxPbNoeud++;
1528: longDouteuxPbNoeud = longDouteuxPbNoeud
1529: + arcRef.longueur();
1530: }
1531: }
1532: }
1533:
1534: // Fin, affichage du bilan
1535: longTot = longSansHomologuePbNoeud + longSansHomologuePbPCC
1536: + longOkUneSerie + longOkPlusieursSeries
1537: + longDouteuxPbNoeud + longDouteuxPbSens;
1538: nbTot = reseau1.getPopArcs().getElements().size();
1539: if (param.debugAffichageCommentaires > 1)
1540: System.out.println(" Bilan des arcs:");
1541: if (param.debugAffichageCommentaires > 1)
1542: System.out.println(" (Longueur totale du réseau 1 : "
1543: + Math.round(longTot / 1000)
1544: + " km, si l'unité des données est le mètre)");
1545: if (param.debugAffichageCommentaires > 1)
1546: System.out.println(" Appariement jugés corrects : ");
1547: if (param.debugAffichageCommentaires > 1)
1548: System.out
1549: .println(" "
1550: + nbOkUneSerie
1551: + " arcs 1 appariés avec un ou plusieurs arc comp en série ("
1552: + nbOkUneSerie
1553: * 100
1554: / nbTot
1555: + "%nb, "
1556: + Math
1557: .round(longOkUneSerie * 100
1558: / longTot) + "%long)");
1559: if (param.debugAffichageCommentaires > 1)
1560: System.out
1561: .println(" "
1562: + nbOkPlusieursSeries
1563: + " arcs 1 appariés avec 2 ensembles de arc comp en parralèle ("
1564: + nbOkPlusieursSeries
1565: * 100
1566: / nbTot
1567: + "%nb, "
1568: + Math.round(longOkPlusieursSeries * 100
1569: / longTot) + "%long)");
1570: if (param.debugAffichageCommentaires > 1)
1571: System.out.println(" Appariement jugés incertains : ");
1572: if (param.debugAffichageCommentaires > 1)
1573: System.out.println(" " + nbDouteuxPbSens
1574: + " arcs 1 appariés dans un seul sens ("
1575: + nbDouteuxPbSens * 100 / nbTot + "%nb, "
1576: + Math.round(longDouteuxPbSens * 100 / longTot)
1577: + "%long)");
1578: if (param.debugAffichageCommentaires > 1)
1579: System.out.println(" " + nbDouteuxPbNoeud
1580: + " arcs 1 appariés avec un noeud ("
1581: + nbDouteuxPbNoeud * 100 / nbTot + "%nb, "
1582: + Math.round(longDouteuxPbNoeud * 100 / longTot)
1583: + "%long)");
1584: if (param.debugAffichageCommentaires > 1)
1585: System.out.println(" Arcs non appariés : ");
1586: if (param.debugAffichageCommentaires > 1)
1587: System.out
1588: .println(" "
1589: + nbSansHomologuePbNoeud
1590: + " arcs 1 sans homolgues (un des noeuds n'est pas apparié) ("
1591: + nbSansHomologuePbNoeud
1592: * 100
1593: / nbTot
1594: + "%nb, "
1595: + Math.round(longSansHomologuePbNoeud * 100
1596: / longTot) + "%long)");
1597: if (param.debugAffichageCommentaires > 1)
1598: System.out
1599: .println(" "
1600: + nbSansHomologuePbPCC
1601: + " arcs 1 sans homolgues (pas de plus court chemin trouvé) ("
1602: + nbSansHomologuePbPCC
1603: * 100
1604: / nbTot
1605: + "%nb, "
1606: + Math.round(longSansHomologuePbPCC * 100
1607: / longTot) + "%long)");
1608:
1609: return liensArcsArcs;
1610: }
1611:
1612: /** Affectation des poids au arcs pour le calcul de 'plus proche chemin' */
1613: private static void calculePoids(ArcApp arcRef,
1614: GroupeApp tousCandidats, ParametresApp param) {
1615: double poids;
1616: Iterator itCandidats = tousCandidats.getListeArcs().iterator();
1617: while (itCandidats.hasNext()) {
1618: ArcApp arcComp = (ArcApp) itCandidats.next();
1619: // poids = arcComp.longueur() + param.coefficentPoidsLongueurDistance*Operateurs.premiere_composante_hausdorff(arcComp.getGeometrie(),arcRef.getGeometrie()); ancienne version
1620: poids = Distances.ecartSurface(arcComp.getGeometrie(),
1621: arcRef.getGeometrie());
1622: arcComp.setPoids(poids);
1623: }
1624: }
1625:
1626: /** Controle de l'enemble des appariements (et non plus un à un) :
1627: * recherche des arcs ou noeuds du réseau 2 appariés avec plusieurs objets du réseau 1
1628: * */
1629: private static void controleGlobal(CarteTopo reseau1,
1630: CarteTopo reseau2, EnsembleDeLiens liens,
1631: ParametresApp param) {
1632: List liensObjet;
1633: Iterator itGroupes, itArcs, itNoeuds, itLiens;
1634: GroupeApp groupe;
1635: int nb, nbSansCorresp, nbDouteux, nbOK;
1636: double longTotal, longSansCorresp, longDouteux, longOK;
1637: ArcApp arcComp;
1638:
1639: ////////////////////////////////////////////////////////////
1640: //////////// Controle global des arcs comp //////////////
1641: // on recherche les arcs comp appariés avec plusieurs objets ref
1642: // pour les marquer comme douteux
1643:
1644: nbSansCorresp = 0;
1645: nbDouteux = 0;
1646: nbOK = 0;
1647: longSansCorresp = 0;
1648: longDouteux = 0;
1649: longOK = 0;
1650: itArcs = reseau2.getPopArcs().getElements().iterator();
1651: while (itArcs.hasNext()) {
1652: arcComp = (ArcApp) itArcs.next();
1653: // On récupère tous les liens concernés par l'arc
1654: liensObjet = new ArrayList();
1655: liensObjet.addAll(arcComp.getLiens(liens.getElements()));
1656: itGroupes = arcComp.getListeGroupes().iterator();
1657: while (itGroupes.hasNext()) {
1658: groupe = (GroupeApp) itGroupes.next();
1659: liensObjet.addAll(groupe.getLiens(liens.getElements()));
1660: }
1661: // cas où l'arc n'est concerné par aucun lien
1662: if (liensObjet.size() == 0) {
1663: arcComp.setResultatAppariement("Non apparié");
1664: nbSansCorresp++;
1665: longSansCorresp = longSansCorresp + arcComp.longueur();
1666: continue;
1667: }
1668: // cas où l'arc est concerné par un seul lien
1669: if (liensObjet.size() == 1) {
1670: if (((LienReseaux) liensObjet.get(0)).getEvaluation() == 1) {
1671: nbOK++;
1672: longOK = longOK + arcComp.longueur();
1673: } else {
1674: nbDouteux++;
1675: longDouteux = longDouteux + arcComp.longueur();
1676: }
1677: continue;
1678: }
1679: //cas où l'arc est concerné par plusieurs liens
1680: if (param.varianteFiltrageImpassesParasites) {
1681: // on regarde si l'arc est une petite impasse dans le réseau de comparaison apparié.
1682: // Si oui, on l'enlève des appariements, c'est sûrement un parasite;
1683: if (arcComp.longueur() < param.distanceNoeudsMax) { // est-il petit?
1684: // est-il une impasse au début?
1685: Noeud iniComp = arcComp.getNoeudIni();
1686: Iterator itArcsIncidents = iniComp.arcs()
1687: .iterator();
1688: boolean impasse = true;
1689: while (itArcsIncidents.hasNext()) {
1690: ArcApp arc = (ArcApp) itArcsIncidents.next();
1691: if (arc == arcComp)
1692: continue;
1693: if (arc.aUnCorrespondantGeneralise(liens)) {
1694: impasse = false;
1695: break;
1696: }
1697: }
1698: if (impasse) { //on nettoie
1699: arcComp
1700: .setResultatAppariement("Non apparié: impasse filtrée");
1701: itGroupes = arcComp.getListeGroupes()
1702: .iterator();
1703: while (itGroupes.hasNext()) {
1704: groupe = (GroupeApp) itGroupes.next();
1705: groupe.getListeArcs().remove(arcComp);
1706: groupe.getListeNoeuds().remove(
1707: arcComp.getNoeudIni());
1708: if (groupe.getListeArcs().size() == 0)
1709: liens.removeAll(groupe.getLiens(liens
1710: .getElements()));
1711: }
1712: arcComp.getListeGroupes().clear();
1713: continue;
1714: }
1715:
1716: // est-il une impasse à la fin?
1717: Noeud finComp = arcComp.getNoeudFin();
1718: itArcsIncidents = finComp.arcs().iterator();
1719: impasse = true;
1720: while (itArcsIncidents.hasNext()) {
1721: ArcApp arc = (ArcApp) itArcsIncidents.next();
1722: if (arc == arcComp)
1723: continue;
1724: if (arc.aUnCorrespondantGeneralise(liens)) {
1725: impasse = false;
1726: break;
1727: }
1728: }
1729: if (impasse) { //on nettoie
1730: arcComp
1731: .setResultatAppariement("Non apparié: impasse filtrée");
1732: itGroupes = arcComp.getListeGroupes()
1733: .iterator();
1734: while (itGroupes.hasNext()) {
1735: groupe = (GroupeApp) itGroupes.next();
1736: groupe.getListeArcs().remove(arcComp);
1737: groupe.getListeNoeuds().remove(
1738: arcComp.getNoeudFin());
1739: if (groupe.getListeArcs().size() == 0)
1740: liens.removeAll(groupe.getLiens(liens
1741: .getElements()));
1742: }
1743: arcComp.getListeGroupes().clear();
1744: continue;
1745: }
1746: }
1747: }
1748:
1749: // il faut le marquer comme incertain
1750: nbDouteux++;
1751: longDouteux = longDouteux + arcComp.longueur();
1752: itLiens = liensObjet.iterator();
1753: while (itLiens.hasNext()) {
1754: LienReseaux lien = (LienReseaux) itLiens.next();
1755: lien
1756: .affecteEvaluationAuxObjetsLies(0.5,
1757: "Incertitude: 1 arc comp lié à plusieurs objets ref différents");
1758: arcComp
1759: .setResultatAppariement("Incertitude: apparié à plusieurs objets de référence");
1760: }
1761: continue;
1762: }
1763:
1764: nb = nbDouteux + nbOK + nbSansCorresp;
1765: longTotal = longDouteux + longOK + longSansCorresp;
1766: if (param.debugAffichageCommentaires > 1)
1767: System.out.println(" Arcs du réseau 2 (" + nb + "):");
1768: if (param.debugAffichageCommentaires > 1)
1769: System.out.println(" arcs appariés et jugés OK : "
1770: + nbOK + " (" + (nbOK * 100 / nb) + "%, "
1771: + Math.round(longOK * 100 / longTotal) + "%long)");
1772: if (param.debugAffichageCommentaires > 1)
1773: System.out.println(" arcs appariés et jugés douteux : "
1774: + nbDouteux + " (" + (nbDouteux * 100 / nb) + "%, "
1775: + Math.round(longDouteux * 100 / longTotal)
1776: + "%long)");
1777: if (param.debugAffichageCommentaires > 1)
1778: System.out.println(" arcs non appariés : "
1779: + nbSansCorresp + " (" + (nbSansCorresp * 100 / nb)
1780: + "%, "
1781: + Math.round(longSansCorresp * 100 / longTotal)
1782: + "%long)");
1783:
1784: ////////////////////////////////////////////////////////////
1785: //////////// Controle global des noeuds comp //////////////
1786: // on recherche les noeuds comp appariés avec plusieurs objets ref
1787: // pour les marquer comme douteux
1788:
1789: nbSansCorresp = 0;
1790: nbDouteux = 0;
1791: nbOK = 0;
1792: itNoeuds = reseau2.getPopNoeuds().getElements().iterator();
1793: while (itNoeuds.hasNext()) {
1794: NoeudApp noeud = (NoeudApp) itNoeuds.next();
1795: //on récupère tous les liens concernés par le noeud
1796: liensObjet = new ArrayList();
1797: liensObjet.addAll(noeud.getLiens());
1798: itGroupes = noeud.getListeGroupes().iterator();
1799: while (itGroupes.hasNext()) {
1800: groupe = (GroupeApp) itGroupes.next();
1801: liensObjet.addAll(groupe.getLiens());
1802: }
1803: liensObjet.retainAll(liens.getElements());
1804:
1805: // cas où le noeud n'est concerné par aucun lien
1806: if (liensObjet.size() == 0) {
1807: noeud.setResultatAppariement("Non apparié");
1808: nbSansCorresp = nbSansCorresp + 1;
1809: continue;
1810: }
1811:
1812: // cas où le noeud est concerné par un seul lien
1813: if (liensObjet.size() == 1) {
1814: if (((LienReseaux) liensObjet.get(0)).getEvaluation() == 1)
1815: nbOK++;
1816: else
1817: nbDouteux++;
1818: continue;
1819: }
1820:
1821: //cas où le noeud est concerné par plusieurs liens
1822: // il faut le marquer comme incertain si il est concerné par au moins un un noeud ref
1823: // (et non par des arcRefs, car cela peut être normal dans le cas des doubles voies par exemple)
1824: itLiens = liensObjet.iterator();
1825: boolean OK = true;
1826: while (itLiens.hasNext()) {
1827: LienReseaux lien = (LienReseaux) itLiens.next();
1828: if (lien.getNoeuds1().size() != 0) {
1829: OK = false;
1830: break;
1831: }
1832: }
1833: if (OK)
1834: nbOK++;
1835: else {
1836: nbDouteux++;
1837: itLiens = liensObjet.iterator();
1838: while (itLiens.hasNext()) {
1839: LienReseaux lien = (LienReseaux) itLiens.next();
1840: lien
1841: .affecteEvaluationAuxObjetsLies(0.5,
1842: "Incertitude: 1 noeud comp lié à plusieurs objets ref différents");
1843: noeud
1844: .setResultatAppariement("Incertitude: apparié à plusieurs objets de référence");
1845: }
1846: }
1847: }
1848: nb = nbDouteux + nbOK + nbSansCorresp;
1849: if (param.debugAffichageCommentaires > 1)
1850: System.out.println(" Noeuds du réseau 2 (" + nb + "):");
1851: if (param.debugAffichageCommentaires > 1)
1852: System.out.println(" noeuds appariés et jugés OK : "
1853: + nbOK + " (" + (nbOK * 100 / nb) + "%)");
1854: if (param.debugAffichageCommentaires > 1)
1855: System.out
1856: .println(" noeuds appariés et jugés douteux : "
1857: + nbDouteux + " (" + (nbDouteux * 100 / nb)
1858: + "%)");
1859: if (param.debugAffichageCommentaires > 1)
1860: System.out.println(" noeuds non appariés : "
1861: + nbSansCorresp + " (" + (nbSansCorresp * 100 / nb)
1862: + "%)");
1863:
1864: ////////////////////////////////////////////////////////
1865: //////////// Controle global des arcs ref //////////////
1866: // On ne fait que compter pour évaluer le résultat
1867: nbSansCorresp = 0;
1868: nbDouteux = 0;
1869: nbOK = 0;
1870: longSansCorresp = 0;
1871: longDouteux = 0;
1872: longOK = 0;
1873:
1874: itArcs = reseau1.getPopArcs().getElements().iterator();
1875: while (itArcs.hasNext()) {
1876: ArcApp arc = (ArcApp) itArcs.next();
1877: if (arc.getResultatAppariement().startsWith("Non apparié")) {
1878: nbSansCorresp++;
1879: longSansCorresp = longSansCorresp + arc.longueur();
1880: continue;
1881: }
1882: if (arc.getResultatAppariement().startsWith("Incertitude")) {
1883: nbDouteux++;
1884: longDouteux = longDouteux + arc.longueur();
1885: continue;
1886: }
1887: if (arc.getResultatAppariement().startsWith("Apparié")) {
1888: nbOK++;
1889: longOK = longOK + arc.longueur();
1890: continue;
1891: }
1892: if (param.debugAffichageCommentaires > 1)
1893: System.out
1894: .println("Valeur imprévue de résultat d'arc : "
1895: + arc.getResultatAppariement());
1896: }
1897:
1898: nb = nbDouteux + nbOK + nbSansCorresp;
1899: longTotal = longDouteux + longOK + longSansCorresp;
1900: if (param.debugAffichageCommentaires > 1)
1901: System.out.println(" Arcs du réseau 1 (" + nb + "):");
1902: if (param.debugAffichageCommentaires > 1)
1903: System.out.println(" arcs appariés et jugés OK : "
1904: + nbOK + " (" + (nbOK * 100 / nb) + "%, "
1905: + Math.round(longOK * 100 / longTotal) + "%long)");
1906: if (param.debugAffichageCommentaires > 1)
1907: System.out.println(" arcs appariés et jugés douteux : "
1908: + nbDouteux + " (" + (nbDouteux * 100 / nb) + "%, "
1909: + Math.round(longDouteux * 100 / longTotal)
1910: + "%long)");
1911: if (param.debugAffichageCommentaires > 1)
1912: System.out.println(" arcs non appariés : "
1913: + nbSansCorresp + " (" + (nbSansCorresp * 100 / nb)
1914: + "%, "
1915: + Math.round(longSansCorresp * 100 / longTotal)
1916: + "%long)");
1917:
1918: /////////////////////////////////////////////
1919: //////////// cas des noeudss ref ////////////
1920: // On ne fait que compter pour évaluer le résultat
1921: nbSansCorresp = 0;
1922: nbDouteux = 0;
1923: nbOK = 0;
1924: itNoeuds = reseau1.getPopNoeuds().getElements().iterator();
1925: while (itNoeuds.hasNext()) {
1926: NoeudApp noeud = (NoeudApp) itNoeuds.next();
1927: if (noeud.getResultatAppariement()
1928: .startsWith("Non apparié")) {
1929: nbSansCorresp++;
1930: continue;
1931: }
1932: if (noeud.getResultatAppariement()
1933: .startsWith("Incertitude")) {
1934: nbDouteux++;
1935: continue;
1936: }
1937: if (noeud.getResultatAppariement().startsWith("Apparié")) {
1938: nbOK++;
1939: continue;
1940: }
1941: if (param.debugAffichageCommentaires > 1)
1942: System.out
1943: .println("Valeur imprévue de résultat de noeud : "
1944: + noeud.getResultatAppariement());
1945: }
1946: nb = nbDouteux + nbOK + nbSansCorresp;
1947: if (param.debugAffichageCommentaires > 1)
1948: System.out.println(" Noeuds du réseau 1 (" + nb + "):");
1949: if (param.debugAffichageCommentaires > 1)
1950: System.out.println(" noeuds appariés et jugés OK : "
1951: + nbOK + " (" + (nbOK * 100 / nb) + "%)");
1952: if (param.debugAffichageCommentaires > 1)
1953: System.out
1954: .println(" noeuds appariés et jugés douteux : "
1955: + nbDouteux + " (" + (nbDouteux * 100 / nb)
1956: + "%)");
1957: if (param.debugAffichageCommentaires > 1)
1958: System.out.println(" noeuds non appariés : "
1959: + nbSansCorresp + " (" + (nbSansCorresp * 100 / nb)
1960: + "%)");
1961: }
1962:
1963: /** Les noeuds de référence non appariés par les 'liens' sont projetés sur le réseau comp
1964: * de manière à introduire un noeud dans le reséau Comp aux endroits qui pourraient correspondre
1965: * à ces noeuds Ref non appariés.
1966: */
1967: public static void decoupeNoeudsNonApparies(ReseauApp ref,
1968: ReseauApp comp, EnsembleDeLiens liens, ParametresApp param) {
1969: List noeudsNonApparies = new ArrayList();
1970: Iterator itNoeuds = ref.getPopNoeuds().getElements().iterator();
1971: while (itNoeuds.hasNext()) {
1972: NoeudApp noeud = (NoeudApp) itNoeuds.next();
1973: if (noeud.getLiens(liens.getElements()).size() == 0)
1974: noeudsNonApparies.add(noeud.getGeometrie());
1975: }
1976: if (param.debugAffichageCommentaires > 1)
1977: System.out.println("Nb de noeuds non appariés : "
1978: + noeudsNonApparies.size());
1979: comp
1980: .projete(
1981: noeudsNonApparies,
1982: param.varianteRedecoupageNoeudsNonApparies_DistanceNoeudArc,
1983: param.varianteRedecoupageNoeudsNonApparies_DistanceProjectionNoeud);
1984: }
1985:
1986: /** Découpe les arcs de référence non appariés par les 'liens' de manière
1987: * à introduire un noeud dans le reséau Ref aux endroits où il s'éloigne du réseau Comp.
1988: *
1989: * Remarque: utilisé pour les GR par exemple pour traiter le cas des GR hors sentier.
1990: */
1991: public static void decoupeNonApparies(ReseauApp ref,
1992: ReseauApp comp, EnsembleDeLiens liens, ParametresApp param) {
1993:
1994: double distanceMaxNoeudArc = param.projeteNoeud2surReseau1_DistanceNoeudArc; //param.distanceArcsMax;
1995: double distanceMaxProjectionNoeud = param.projeteNoeud2surReseau1_DistanceProjectionNoeud;
1996: ArcApp arcComp, arcDecoupe;
1997: Iterator itArcsDecoupes, itArcsDecoupants;
1998: FT_FeatureCollection arcsCompProches;
1999: List pointsDeDecoupage;
2000: DirectPosition pt, ptDecoupage;
2001: int indiceDernierPtProche;
2002: int i;
2003: double longProche;
2004: boolean proche;
2005:
2006: itArcsDecoupes = ref.getPopArcs().getElements().iterator();
2007: pointsDeDecoupage = new ArrayList();
2008: while (itArcsDecoupes.hasNext()) {
2009: arcDecoupe = (ArcApp) itArcsDecoupes.next();
2010: if (arcDecoupe.getLiens(liens.getElements()).size() != 0)
2011: continue;
2012:
2013: arcsCompProches = comp.getPopArcs().select(
2014: arcDecoupe.getGeometrie(), distanceMaxNoeudArc);
2015: if (arcsCompProches.size() == 0)
2016: continue;
2017:
2018: itArcsDecoupants = arcsCompProches.getElements().iterator();
2019: while (itArcsDecoupants.hasNext()) {
2020: arcComp = (ArcApp) itArcsDecoupants.next();
2021:
2022: // recherche en partant du début
2023: indiceDernierPtProche = 0;
2024: longProche = 0;
2025: proche = false;
2026: for (i = 0; i < arcComp.getGeometrie()
2027: .getControlPoint().size(); i++) {
2028: pt = arcComp.getGeometrie().getControlPoint(i);
2029: if (Distances.distance(pt, arcDecoupe
2030: .getGeometrie()) < distanceMaxNoeudArc) {
2031: if (proche)
2032: longProche = longProche
2033: + Distances.distance(arcComp
2034: .getGeometrie()
2035: .getControlPoint(i),
2036: arcComp.getGeometrie()
2037: .getControlPoint(
2038: i - 1));
2039: indiceDernierPtProche = i;
2040: proche = true;
2041: } else {
2042: if (proche)
2043: break;
2044: }
2045: }
2046: if (indiceDernierPtProche != 0
2047: && indiceDernierPtProche != arcComp
2048: .getGeometrie().getControlPoint()
2049: .size() - 1
2050: && longProche > distanceMaxProjectionNoeud) {
2051: ptDecoupage = Operateurs.projection(arcComp
2052: .getGeometrie().getControlPoint(
2053: indiceDernierPtProche), arcDecoupe
2054: .getGeometrie());
2055: pointsDeDecoupage.add(new GM_Point(ptDecoupage));
2056: }
2057:
2058: // recherche en partant de la fin
2059: indiceDernierPtProche = arcComp.getCoord().size() - 1;
2060: longProche = 0;
2061: proche = false;
2062: for (i = arcComp.getGeometrie().getControlPoint()
2063: .size() - 1; i >= 0; i--) {
2064: pt = arcComp.getGeometrie().getControlPoint(i);
2065: if (Distances.distance(pt, arcDecoupe
2066: .getGeometrie()) < distanceMaxNoeudArc) {
2067: if (proche)
2068: longProche = longProche
2069: + Distances.distance(arcComp
2070: .getGeometrie()
2071: .getControlPoint(i),
2072: arcComp.getGeometrie()
2073: .getControlPoint(
2074: i + 1));
2075: indiceDernierPtProche = i;
2076: proche = true;
2077: } else {
2078: if (proche)
2079: break;
2080: }
2081: }
2082: if (indiceDernierPtProche != 0
2083: && indiceDernierPtProche != arcComp
2084: .getGeometrie().getControlPoint()
2085: .size() - 1
2086: && longProche > distanceMaxProjectionNoeud) {
2087: ptDecoupage = Operateurs.projection(arcComp
2088: .getGeometrie().getControlPoint(
2089: indiceDernierPtProche), arcDecoupe
2090: .getGeometrie());
2091: pointsDeDecoupage.add(new GM_Point(ptDecoupage));
2092: }
2093: }
2094: }
2095: ref.projete(pointsDeDecoupage, distanceMaxNoeudArc,
2096: distanceMaxNoeudArc);
2097: param.distanceNoeudsMax = 51;
2098: ref.instancieAttributsNuls(param);
2099: comp.projete(pointsDeDecoupage, distanceMaxNoeudArc,
2100: distanceMaxNoeudArc);
2101: }
2102: }
|