WebSVN – eFlore/Projets.eflore-projets – Diff – /trunk/scripts/modules/osm/ParseurOsm.php

 <?php
 /**
+ * Exemple de lancement du script :
- * Exemple de lancement du script : /opt/lampp/bin/php cli.php parseur_osm -a compter -f "/home/jpm/Stockage/osm/languedoc-roussillon-communes.osm"
+ * /opt/lampp/bin/php cli.php osm/parseur_osm -a compter -f "/home/jpm/Stockage/osm/languedoc-roussillon-communes.osm"
  *
  */
 class ParseurOsm extends Script {
 	private $communes = array();
 	private $relations_communes = array();
 	private $relation_a_chemins = array();
 	private $chemin_a_noeuds = array();
 	private $noeuds = array();
 	private $pas = 10000;
 	private $pas_commune = 1000;
 	protected $parametres_autorises = array(
 		'-f' => array(true, null, 'Chemin du fichier osm à analyser'),
 		'-m' => array(false, 'auto', 'Mode «auto» ou «manuel». En manuel, les compteurs dans les boucles sont affichés.'));
 			default :
 				$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
+		}
+    }
     /**
 	 * Lit le fichier OSM et lance l'analyse des noeuds xml en fonction de leur type.
 	 */
 	private function lireFichierOsm() {
 		$lecteur = new XMLReader();
 		if ($lecteur->open($this->getParametre('f'))) {
 			$dom = new DomDocument();
 			while ($lecteur->read()) {
 				if ($lecteur->nodeType == XMLREADER::ELEMENT) {
 					if ($lecteur->localName == 'relation') {
 						$relation = $lecteur->expand();
 						$this->analyserRelation($relation);
 						if (count($this->relation_a_chemins) > $this->pas) {
 							$this->insererRelationAChemins();
+						}
 						if (count($this->relations_communes) > $this->pas_commune) {
 							$this->insererRelationsCommunes();
+						}
 					} else if ($lecteur->localName == 'way') {
 						$way = $lecteur->expand();
 						$this->analyserWay($way);
 						if (count($this->chemin_a_noeuds) > $this->pas) {
 							$this->insererCheminANoeuds();
+						}
 					} else if ($lecteur->localName == 'node') {
 		} else {
 			$e = "Impossible d'ouvrir le fichier osm : %s";
 			$this->traiterErreur($e, array($this->getParametre('f')));
+		}
+	}
 	/**
 	 * Récupère l'id commune, nom commune et le code INSEE et remplie la table `CommuneOSM`
 	 */
 	private function analyserRelation($relation) {
 		$relation_id = $this->proteger($relation->getAttribute('id'));
 		$chemins = $relation->getElementsByTagName('member');
 		foreach ($chemins as $chemin) {
 			if ($chemin->getAttribute('type') == 'way') { //écarter le noeud centrale
 				$chemin_id = $this->proteger($chemin->getAttribute('ref'));
 				$role = $this->proteger($chemin->getAttribute('role'));//role: null, inner, outer, exclave et enclave.
 				$this->relation_a_chemins[] = array($relation_id, $chemin_id, $role);
+			}
+		}
 		$commune_nom = null;
 		$commune_insee = null;
 		$tags = $relation->getElementsByTagName('tag');
 			$tag_cle = $tag->getAttribute('k');
 			$tag_val = $tag->getAttribute('v');
 			switch ($tag_cle) {
 				case 'name' :
 					$commune_nom = $this->proteger($tag_val);
 					break;
 				case 'ref:INSEE' :
 					$commune_insee = $this->proteger($tag_val);
 					break;
+			}
 			if (!is_null($commune_nom) && !is_null($commune_insee)) {
 						"Veuillez corriger la carte OSM.";
 					$this->traiterErreur($e, array($this->communes[$commune_insee], $commune_insee, $relation_id));
+				}
 				break;
+			}
 		}
+	}
 	/**
 	 * Récupère l'id_way et tous les id_node de chaque way et remplie la table `osm_chemin_a_noeuds`
 	 */
 	private function analyserWay($way) {
 		$chemin_id = $this->proteger($way->getAttribute('id'));
 		$ordre = 0;
 		$noeuds = $way->getElementsByTagName('nd');
 		$chemin_a_noeuds = array();
 			$noeud_id = $this->proteger($noeud->getAttribute('ref'));
 			$ordre++;
 	    	$this->chemin_a_noeuds[] = array($chemin_id, $noeud_id, $ordre);
+		}
+	}
 	/**
 	 * Fonction qui récupère tous les l'id_node et les valeurs(Lat/Lon) correspondantes et remplie la table `osm_noeuds`
 	 */
 	private function analyserNode($node) {
 		$noeud_id = $this->proteger($node->getAttribute('id'));
 		$lat = $this->proteger($node->getAttribute('lat'));
 		$lon = $this->proteger($node->getAttribute('lon'));
 		$this->noeuds[] = array($noeud_id, $lat, $lon);
+	}
 	private function insererRelationsCommunes() {
 		$requete =	'INSERT INTO osm_relations (id_relation, nom, code_insee) '.
 					'VALUES '.$this->creerValuesMultiple($this->relations_communes);
 		$this->inserer($requete);
 		$this->relations_communes = array();
+	}
 	private function insererRelationAChemins() {
 		$requete =	'INSERT INTO osm_relation_a_chemins (id_relation, id_chemin, role) '.
 					'VALUES '.$this->creerValuesMultiple($this->relation_a_chemins);
 		$this->inserer($requete);
 		$this->relation_a_chemins = array();
 	}
 	private function insererCheminANoeuds() {
 		$requete = 	'INSERT INTO osm_chemin_a_noeuds (id_chemin, id_noeud, ordre) '.
 					'VALUES '.$this->creerValuesMultiple($this->chemin_a_noeuds);
 		$this->inserer($requete);
 		$this->chemin_a_noeuds = array();
+	}
 	private function insererNoeuds() {
 		$requete = 'INSERT INTO osm_noeuds (id_noeud, lat, `long`) '.
 	    		   'VALUES '.$this->creerValuesMultiple($this->noeuds);
 		$this->inserer($requete);
 		$this->noeuds = array();
+	}
 	/**
 	 * Fonction qui rajoute l'ordre et le sens de chaque way d'une relation dans la table `osm_relation_a_chemins`
 	 * ALGO:
 	 * -On fait un select de toutes les ways d'une relation.
 	 * -On fait un count sur le tableau ways resutlant.
 	 * -On met l'ordre du premier Way à 0.
 	 * -On met : Actuelway = id_premier_way
 	 * -Select dans table nodes, les nodes du way actuel
 	 * -On prend le dernier noeud
 	 * -On met : ActuelNoeud = id_dernier_noeud
 	 * -Boucle for (i = 0; i < count(tabeau_way); i++) { sur le nombre de ways
 	 * 		-On sélectionne id_way suivant qui contient le dernier_noeud du précédent
 	 * 		(En écartant l'id_way déja existant )
 	 * 		-On recherche les noeuds du nouveau way
 	 * 		-On teste sur les extrémités du way précédent(dernier noeud) et suivant(premier noeud)
 	 * 		-si égalité: $nombrePolygone=1;
 	 * 			-sens:directe
 	 * 			-ordre++
 	 * 			-ActuelNoeud = id_dernier_noeud
 	 * 		sinon
 	 * 			-sens:indirecte
 	 * 	    	-ordre++
 	 * 			-ActuelNoeud = id_premier_noeud
 	 * }
 	 */
 			$ways = $this->bdd->recupererTous($requete);
           	$nombreWays = count($ways);
 			// premier élément du tableau
 	        $idPremierWay = $ways[0]['id_chemin'];
 			$wayActuel  = $idPremierWay;
 			$requete = 'UPDATE  osm_relation_a_chemins '.
 						'SET  ordre =  0,  sens =  "directe" '.
 						"WHERE  id_relation = $idRelation ".
 						"AND  id_chemin = $wayActuel ";
 			$this->inserer($requete);
 			// selection dernier noeud
 			$requete = 'SELECT id_noeud '.
 						'FROM osm_chemin_a_noeuds '.
 						"WHERE id_chemin = $wayActuel ORDER BY ordre";
 			$nodes = $this->bdd->recupererTous($requete);
 			$nombreNodes = count($nodes);
 			$dernierNoeud = $nodes[$nombreNodes - 1]['id_noeud'];
 			$noeudActuel = $dernierNoeud;
 			for ($ordre = 1; $ordre < $nombreWays; $ordre++) {
 				//selectionner le way qui possède le dernier noeud du précédent way et écarter l'actuel
 				$requete = 'SELECT WN.id_chemin '.
 							'FROM osm_relation_a_chemins AS RW LEFT JOIN osm_chemin_a_noeuds AS WN ON (RW.id_chemin = WN.id_chemin) '.
 							"WHERE WN.id_noeud = $noeudActuel ".
 							"AND WN.id_chemin != $wayActuel ".
 							"AND RW.id_relation = $idRelation ";
 				$ways = $this->bdd->recupererTous($requete);
 				if (isset($ways[0])) {
 					$wayActuel =  $ways[0]['id_chemin'];
 					$requete = 'SELECT id_noeud '.
 								'FROM osm_chemin_a_noeuds '.
 								"WHERE id_chemin = $wayActuel ORDER BY ordre ";
 					$nodes = $this->bdd->recupererTous($requete);
 					$nombreNodes = count($nodes);
 					if ( strcmp($nodes[0]['id_noeud'], $noeudActuel ) == 0 ) {
 						$requete = 'UPDATE osm_relation_a_chemins '.
 									"SET ordre = '$ordre', sens = 'directe' ".
 									"WHERE id_relation = $idRelation ".
 									"AND id_chemin = $wayActuel ";
 						$this->inserer($requete);
 						$noeudActuel = $nodes[$nombreNodes-1]['id_noeud'];
 					} else {
+			}
+        }
+	}
 	/**
 	 * Fonction qui parcourt tous les ways les noeuds de chaque relation en prenant en considération l'ordre et
 	 * le sens de chaque ways concaténés ensemble(séparés par des virgules). Update du champ polygone de chaque
 	 * relation dans la table  `osm_relations`
 	 */
 	private function remplirPolygone() {
 		$polygone = array();
 		$idNodes = array();
 		$String = '';
         $requete = 'SELECT id_relation, nom, code_insee FROM osm_relations ';
         $relations = $this->bdd->recupererTous($requete);
         foreach ($relations as $relation) {
         	$idCommune = $relation['id_relation'];
 			$nomCommune = $relation['nom'];
         	$INSEE = $relation['code_insee'];
     		$requete = 'SELECT id_chemin FROM osm_relation_a_chemins '.
         				"WHERE id_relation = $idCommune ".
         				'ORDER BY ordre';
 			$ways = $this->bdd->recupererTous($requete);
 		    foreach ($ways as $way) {
         		$idWay = $way['id_chemin'];
         		$requeteSensWay= "SELECT sens FROM osm_relation_a_chemins WHERE id_relation = $idCommune
         						 AND id_chemin = $idWay";
 				$sens = $this->bdd->recupererTous($requeteSensWay);
         		$requeteNodes = "SELECT id_noeud FROM osm_chemin_a_noeuds WHERE id_chemin= $idWay ORDER BY ordre ";
 				$nodes = $this->bdd->recupererTous($requeteNodes);
 				if($sens[0]['sens'] == "directe") {
 	        		foreach ($nodes as $node) {
 						$idNodes[] = $node['id_noeud'];
+        			}
        				$noeuds = implode(", ", $idNodes);
        				//requête IN qui gère l'ordre des noeuds de chaque way (CAS ASC)
 					$requeteLatitudeLongitude = 'SELECT NLL.id_noeud, NLL.lat, NLL.`long` '.
 												'FROM osm_chemin_a_noeuds WN, osm_noeuds NLL '.
 												"WHERE NLL.id_noeud IN ($noeuds) ".
 												'AND WN.id_noeud = NLL.id_noeud '.
 												"AND WN.id_chemin = $idWay ORDER BY WN.ordre ASC";
 					unset($noeuds);
 					unset($idNodes);
 					$LatLons = $this->bdd->recupererTous($requeteLatitudeLongitude);
 			        foreach ($LatLons as $LatLon) {
 		        			$Latitude = $LatLon['lat'];
 						    $Longitude = $LatLon['long'];
 						  	$String = "$Latitude $Longitude";
 							$polygone[] = $String;
+			       	}
 				} else {
 					foreach ($nodes as $node) {
 						$idNodes[] = $node['id_noeud'];
+        			}
         			$noeuds = implode(", ", $idNodes);
         			//requête IN qui gère l'ordre des noeuds de chaque way (CAS DESC)
         			$requeteLatitudeLongitude = 'SELECT NLL.id_noeud, NLL.lat, NLL.`long` '.
         									    'FROM osm_chemin_a_noeuds WN ,osm_noeuds NLL '.
         									    "WHERE NLL.id_noeud IN ($noeuds) ".
         									    'AND WN.id_noeud = NLL.id_noeud '.
         									    "AND WN.id_chemin = $idWay ORDER BY WN.ordre DESC";
 					unset($noeuds);
 					unset($idNodes);
 					$LatLons = $this->bdd->recupererTous($requeteLatitudeLongitude);
 					foreach ($LatLons as $LatLon) {
 		        		$Latitude = $LatLon['lat'];
 						$Longitude = $LatLon['long'];
 						$String = "$Latitude $Longitude";
 		        		$polygone[] = $String;
+				  	}
 				}
+            }
        			$this->etatPolygone($polygone, $idCommune, $nomCommune, $INSEE);
 	       		unset($separationVirgule);
 				unset($requeteNodes);
 				unset($String);
 				unset($polygone);
+		}
 	}
 	private function etatPolygone($polygone, $idCommune, $nomCommune, $INSEE) {
 			$separationVirgulePolygone = implode(', ', $polygone);
 			$nomCommuneProtege = $this->bdd->proteger($nomCommune);
 			$InseeProtege = $this->bdd->proteger($INSEE);
 			if ($polygone[0] == $polygone[count($polygone)-1]) { //test sur début et fin du polygone
 				//requête replace pour gérer la mise à jour à la suite
 				$requete = 'REPLACE INTO osm_communes (id_relation, nom, code_insee, polygon, note ) '.
 						   "VALUES ($idCommune, $nomCommuneProtege, $InseeProtege, ".
 						   "POLYFROMTEXT('MULTIPOLYGON ((($separationVirgulePolygone)))'),'Polygone complet');";
 			} else {
 				$requete = 'REPLACE INTO osm_communes (id_relation, nom, code_insee, polygon, note ) '.
 						   "VALUES ($idCommune, $nomCommuneProtege, $InseeProtege, ".
 						   "POLYFROMTEXT('MULTIPOLYGON ((($separationVirgulePolygone)))'),'Polygone incomplet');";
+			}
 			$this->inserer($requete);
        		$idRelation = $relation['id_relation'];
        		$requeteWays = "SELECT id_chemin FROM osm_relation_a_chemins WHERE id_relation= $idRelation";
 			$ways = $this->bdd->recupererTous($requeteWays);
 			foreach ($ways as $way) {
 				$idWay = $way['id_chemin'];
 				$this->	inserer('UPDATE osm_relation_a_chemins SET ordre = NULL '.
 								"WHERE id_relation = $idRelation AND id_chemin = $idWay ;");
+			}
+		}
 	}
 	/**
 	 * Fonction qui récupère les relations des polygones incomplets et appelle pour chaque relation la fonction
 	 * ordonnerPolygoneIncomplet($ordre,$tour,$idRelation,$nombrePolygone)
 	 */
        			$nombrePolygone = 1;
             	$idRelation = $relation['id_relation'];
             	$this->ordonnerPolygoneIncomplet($ordre,$tour,$idRelation,$nombrePolygone);
+            }
+	}
 	/**
 	 * Fonction récursive qui exécute la même tâche que la fonction ordonnerWays() pour chaque polygone d'un
 	 * multipolygone et remplie le champ NbPoly dans la table `osm_relation_a_chemins` qui correspond au nombre de polygone fermé
 	 * dans le multipolygone
 	 */
 	private function ordonnerPolygoneIncomplet($ordre, $tour, $idRelation, $nombrePolygone) {
 		$requeteWays = 'SELECT id_chemin FROM osm_relation_a_chemins '.
 						"WHERE id_relation = $idRelation AND ordre = 'NULL'";
 		$ways = $this->bdd->recupererTous($requeteWays);
 		$tempWays = $ways;
 		$nombreWays = count($ways);
    		// premier élément du tableau
         $idPremierWay = $ways[0]['id_chemin'];
 		$wayActuel = $idPremierWay;
 		$this->	inserer('UPDATE osm_relation_a_chemins '.
 						 "SET ordre = $ordre, sens = 'directe', nbre_poly = $nombrePolygone ".
 						 "WHERE id_relation = $idRelation ".
 						 "AND id_chemin = $wayActuel ;");
 		//selection dernier noeud
 		$requeteNodes = "SELECT id_noeud FROM osm_chemin_a_noeuds WHERE id_chemin = $wayActuel ORDER BY ordre;";
 		$nodes = $this->bdd->recupererTous($requeteNodes);
 		$nombreNodes = count($nodes);
 		$premierNoeud = $nodes[0]['id_noeud'];
 		$dernierNoeud = $nodes[$nombreNodes-1]['id_noeud'];
 		$noeudActuel = $dernierNoeud;
 		$tour++;
 		//Condition pour laquelle la boucle while continue à tourner; tant que le premier noeud du polygone n'est
 		//égale au dernier et tant qu'il reste des ways à gérer
 		while (($premierNoeud != $noeudActuel) && (($ordre % 1000) < count($tempWays))) {
 			//select le way qui possède le dernier noeud du précédent way et écarter l'actuel
 			$nombrePolygone;
 			$ordre++;
 			//select des ways qui n'ont pas été ordonnés: on obtient à chaque itération les ways qui restent à ordonner
 			$requeteWays = 'SELECT WN.id_chemin FROM (osm_chemin_a_noeuds WN, osm_relation_a_chemins RW) '.
 						   "WHERE WN.id_noeud = $noeudActuel AND WN.id_chemin != $wayActuel ".
 						   "AND RW.id_chemin = WN.id_chemin AND RW.id_relation = $idRelation ".
 						   "AND RW.ordre = 'NULL' ;";
 			$ways = $this->bdd->recupererTous($requeteWays);
 			if (isset($ways[0])) {
 				$wayActuel = $ways[0]['id_chemin'];
 				$requeteNodes = "SELECT id_noeud FROM osm_chemin_a_noeuds WHERE id_chemin = $wayActuel ORDER BY ordre;";
 				$nodes = $this->bdd->recupererTous($requeteNodes);
 				$nombreNodes = count($nodes);
 				if (strcmp($nodes[0]['id_noeud'], $noeudActuel ) == 0) {
 					$this->	inserer("UPDATE osm_relation_a_chemins SET ordre = '$ordre', sens = 'directe', ".
 									"nbre_poly = $nombrePolygone ".
 									"WHERE osm_relation_a_chemins.id_relation = $idRelation ".
 							        "AND osm_relation_a_chemins.id_chemin = $wayActuel");
 					$noeudActuel = $nodes[$nombreNodes-1]['id_noeud'];
 				} else {
 					$this->	inserer('UPDATE osm_relation_a_chemins '.
 									"SET ordre = '$ordre', sens = 'indirecte', ".
 									"nbre_poly = $nombrePolygone ".
 							        "WHERE id_relation = $idRelation ".
 						         	"AND id_chemin = $wayActuel");
 					$noeudActuel = $nodes[0]['id_noeud'];
+				}
+			}
 		}
 		$ordre = 1000 * $tour; //différencier chaque polygone: pour chaque polygone on a un multiple de mille
 		$requeteCount = "SELECT ordre FROM osm_relation_a_chemins WHERE id_relation = $idRelation AND ordre = 0";
 		$count = $this->bdd->recupererTous($requeteCount);
 		if ((count($count)) != 0) { // s'ils en restent des ways à gérer
 			$nombrePolygone++;
 			//appelle de la fonction récursive
 			$this->ordonnerPolygoneIncomplet($ordre, $tour, $idRelation, $nombrePolygone);
 		}
+	}
 	/**
 	 * Fonction qui récupère les relations des polygones incomplets et appelle pour chaque relation la fonction
 	 * remplirPolygoneIncomplet($idRelation);
 	 */
 	private function remplirCommunesPolygoneIncomplet() {
 		$nombrePolygone = 1;
 		$requeteRelations = "SELECT id_relation FROM osm_communes WHERE note LIKE 'Polygone incomplet'";
         	$relations = $this->bdd->recupererTous($requeteRelations);
             foreach ($relations as $relation) {
        			$idRelation = $relation['id_relation'];
 				$this->remplirPolygoneIncomplet($idRelation);//appel de la fonction avec comme paramètre ID-commune
+            }
+	}
 	/**
 	 * Fonction qui exécute la même tâche que la fonction remplirPolygone() pour chaque polygone d'un multipolygone
 	 * et renvoie un tableau MultiPolygone[] où chaque case contient un polygone fermé et appelle la fonction
 	 * etatMultiPolygone($multiPolygone, $idCommune) qui remplie le Multipolygone de la commune correspondante
 	 */
 	private function remplirPolygoneIncomplet($idCommune) {
 		$polygone = array();
 		$multiPolygone = array();//tableau multipolygone qui contient tous les polygones d'un multipolygone
 		$idNodes = array();
 		$roles = array();//tableau roles qui contient les roles des ways
 		$String = "";
 		//sélectionner le nombre de polygones qui existe dans un multipolygone
 		$requete = 'SELECT MAX(nbre_poly) AS nbre_poly '.
 					'FROM osm_relation_a_chemins '.
 					"WHERE id_relation = $idCommune";
         $nombrePolygone = $this->bdd->recupererTous($requete);
         $nbPoly = $nombrePolygone[0]['nbre_poly'];
 		for ($tour = 1; $tour <= $nbPoly; $tour++) {//boucle for qui parcourt chaque polygone du multipolygone
         	$requeteWays = 	'SELECT id_chemin FROM osm_relation_a_chemins '.
         					"WHERE id_relation = $idCommune ".
 							"AND nbre_poly = $tour ORDER BY ordre";
 		    $ways = $this->bdd->recupererTous($requeteWays);
 		    foreach ($ways as $way) {
         		$idWay = $way['id_chemin'];
    				$requeteSensWay = 'SELECT sens FROM osm_relation_a_chemins '.
    								  "WHERE id_relation = $idCommune ".
         						  "AND id_chemin = $idWay";//sélection de l'orientation du way
         		$sens= $this->bdd->recupererTous($requeteSensWay);
         		$requeteNodes = "SELECT id_noeud FROM osm_chemin_a_noeuds WHERE id_chemin= $idWay ORDER BY ordre";
 				$nodes = $this->bdd->recupererTous($requeteNodes);
         		if ($sens[0]['sens'] == "directe") {//test sur le sens des ways
 	        		foreach ($nodes as $node) {
 						$idNodes[] = $node['id_noeud'];
+        			}
        				$noeuds = implode(", ", $idNodes);
        				//requête IN qui gère l'ordre des noeuds de chaque way (CAS ASC)
 					$requeteLatitudeLongitude = 'SELECT NLL.id_noeud, NLL.lat, NLL.`long` '.
 												'FROM osm_chemin_a_noeuds WN, osm_noeuds NLL '.
 												"WHERE NLL.id_noeud IN ($noeuds) ".
 												'AND WN.id_noeud = NLL.id_noeud '.
 												"AND WN.id_chemin= $idWay ORDER BY WN.ordre ASC";
 					unset($noeuds);
 					unset($idNodes);
 					$LatLons = $this->bdd->recupererTous($requeteLatitudeLongitude);
 			        foreach ($LatLons as $LatLon) {
 	        			$Latitude = $LatLon['lat'];
 					    $Longitude = $LatLon['long'];
 					  	$String = "$Latitude $Longitude";
 						$polygone[] = $String;
+			  		}
 				} else {
 					foreach ($nodes as $node) {
 						$idNodes[] = $node['id_noeud'];
+        			}
         			$noeuds = implode(", ", $idNodes);
         			//requête IN qui gère l'ordre des noeuds de chaque way (CAS DESC)
         			$requeteLatitudeLongitude = 'SELECT NLL.id_noeud, NLL.lat, NLL.`long` '.
 												'FROM osm_chemin_a_noeuds WN, osm_noeuds NLL '.
 												"WHERE NLL.id_noeud IN ($noeuds) ".
 												'AND WN.id_noeud = NLL.id_noeud '.
 												"AND WN.id_chemin= $idWay ORDER BY WN.ordre DESC";
 					unset($noeuds);
 					unset($idNodes);
 					$LatLons = $this->bdd->recupererTous($requeteLatitudeLongitude);
 					foreach ($LatLons as $LatLon) {
 		        		$Latitude = $LatLon['lat'];
 						$Longitude = $LatLon['long'];
 						$String = "$Latitude $Longitude";
 		        		$polygone[] = $String;
+					}
+				}
 			}
 			$requeteRole = 'SELECT DISTINCT role '.
 						   'FROM  osm_relation_a_chemins '.
 						   "WHERE id_relation = $idCommune ".
 						   "AND nbre_poly = $tour ";
 			$role = $this->bdd->recupererTous($requeteRole);
 			$role = $role[0]['role'];
 			$separationVirgulePolygone = implode(", ", $polygone);
 	       	$multiPolygone[] = $separationVirgulePolygone;
 			unset($separationVirgulePolygone);
 			unset($polygone);
+		}
 			$this->etatMultiPolygone($multiPolygone, $roles, $idCommune, $nbPoly);//appel de la fonction de remplissage
+	}
 	/**
 	 * Remplie le champ polygone à partir du tableau MultiPolygone
 	 */
 	private function etatMultiPolygone($multiPolygone, $roles, $idCommune, $nbPoly) {
 		$note = $this->proteger('Polygone complet');
 		if ($nbPoly == 2 && ((in_array('inner', $roles)) || (in_array('enclave', $roles)))) {//cas Outer Inner à deux polygones
 			$multiPoly = implode('),(', $multiPolygone);
 			$requete = 'UPDATE osm_communes '.
 						"SET polygon = MPOLYFROMTEXT('MULTIPOLYGON((($multiPoly)))'), ".
 		           		"note = $note ".
 		           		"WHERE id_relation = $idCommune ";
 			$this->inserer($requete);
 		}
 		if ((in_array('inner', $roles)) || (in_array('enclave', $roles)) != 1) { //tous les autres cas
 			$multiPoly = implode(')),((', $multiPolygone);
 			$requete = 'UPDATE osm_communes '.
 						"SET polygon = MPOLYFROMTEXT('MULTIPOLYGON((($multiPoly)))'), ".
 	             		"note = $note ".
 	             		"WHERE id_relation = $idCommune ";
 			$this->inserer($requete);
+		}
 	}
 	/**
 	 * Renomme la note des polygones vides d'un polygone complet en polygone incomplet
 	 */
 	private function renommerEnPolygoneIncomplet() {
 		$requete = 'SELECT id_relation, ASTEXT(polygon) AS poly '.
 					'FROM osm_communes ';
 		$etatPolygones = $this->bdd->recupererTous($requete);
 		foreach ($etatPolygones as $etatPolygone ) {
 			if (isset($etatPolygone['poly']) == 0) {//test si le polygone est vide
 				$idCommune = $this->proteger($etatPolygone['id_relation']);
 				$note = $this->proteger('Polygone incomplet');
 				$requete = 'UPDATE osm_communes '.
 							"SET note = $note ".
 							"WHERE id_relation = $idCommune ";
 				$this->inserer($requete);
 			}
 		}
+	}
 			$requete = "SELECT ASTEXT(CENTROID(MPOLYFROMTEXT('$multipolygone'))) AS centre ";
 			$point = $this->bdd->recupererTous($requete);
         	$centre = $this->proteger($point[0]['centre']);
         	$idCom = $this->proteger($commune['id_relation']);
         	$requete = 'UPDATE osm_communes '.
         				"SET centre = POINTFROMTEXT($centre) ".
         				"WHERE id_relation = $idCom ";
         	$this->inserer($requete);
+		}
+	}
 	private function creerValuesMultiple($donnees) {
 		$values = array();
 		foreach ($donnees as $donnee) {
 			$values[] = implode(',', $donnee);
+		}
 		$values_chaine = '('.implode('),(', $values).')';
 		return $values_chaine;
+	}
 	private function inserer($requete) {
 		$this->bdd->requeter($requete);
+	}
 	private function proteger($chaine) {
 		return $this->bdd->proteger($chaine);
+	}
+}
 ?>

Subversion Repositories eFlore/Projets.eflore-projets

(root)/trunk/scripts/modules/osm/ParseurOsm.php – Rev 167 → 392