Subversion Repositories eFlore/Projets.eflore-projets

<?php

/**

 * Réparation des polygones incomplets :

 *

 * Exemple de lancement du script :

 * /opt/lampp/bin/php -d memory_limit=8000M cli.php osm -a ordonnerPolygoneInc -m manuel -v 3

 *

 * /opt/lampp/bin/php -d memory_limit=8000M cli.php osm -a remplirPolygoneInc -m manuel -v 3

 *

 * /opt/lampp/bin/php -d memory_limit=8000M cli.php osm -a renommer -m manuel -v 3

 *

 */

class PolygoneReparateur {

	private $conteneur;

	private $bdd;

	private $messages;

	private $mode;

	public function __construct($conteneur) {

		$this->conteneur = $conteneur;

		$this->bdd = $this->conteneur->getBdd();

		$this->messages = $this->conteneur->getMessages();

		$this->mode = $this->conteneur->getParametre('m');

	}

	/**

	 * 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`

	 */

	public function executer() {

		// Lancement de l'action demandée

		$cmd = $this->conteneur->getParametre('a');

		switch ($cmd) {

			case 'ordonnerPolygoneInc' :

				$this->ordonnerRelationsAuPolygoneIncomplet();

				break;

			case 'remplirPolygoneInc' :

				$this->remplirRelationsAuPolygoneIncomplet();

				break;

			case 'renommer' :

				$this->renommerEnPolygoneIncomplet();

				break;

			default :

				$msgTpl = "Erreur : la commande '%s' n'est pas prise en compte par la classe %s !";

				$msg = sprintf($msgTpl, $cmd, get_class($this));

				throw new Exception($msg);

		}

		print "\n";// Pour ramener à la ligne en fin de script

	}

	/**

	 * Fonction qui récupère les relations des polygones incomplets et appelle pour chaque relation la fonction

	 * ordonnerPolygoneIncomplet($ordre,$tour,$idRelation,$nombrePolygone)

	 */

	private function ordonnerRelationsAuPolygoneIncomplet() {

		$relations = $this->getRelationsAuPolygoneIncomplet();

		foreach ($relations as $relation) {

			$idRelation = $relation['id_relation'];

			$this->ordonnerCheminsMultiPolygone($idRelation);

			if ($this->mode == 'manuel') {

				$this->messages->afficherAvancement("Réparation du polygone incomplet : ", 1);

			}

		}

	}

	/**

	 * 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 ordonnerCheminsMultiPolygone($idRelation, $numPolygone = 1, $ordre = 1, $tour = 1) {

		$chemins = $this->getChemins($idRelation);

		$nbreCheminsTotal = count($chemins);

		// premier élément du tableau

		$idPremierChemin = $chemins[0]['id_chemin'];

		$idChemin = $idPremierChemin;

		$this->mettreAJourChemin($idRelation, $idPremierChemin, $ordre, 'directe', $numPolygone);

		//selection dernier noeud

		$nodes = $this->getNoeuds($idPremierChemin);

		$nombreNodes = count($nodes);

		$premierNoeud = $nodes[0]['id_noeud'];

		$dernierNoeud = $nodes[$nombreNodes - 1]['id_noeud'];

		$noeudActuel = $dernierNoeud;

		//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) < $nbreCheminsTotal)) {

			//select le way qui possède le dernier noeud du précédent way et écarter l'actuel

			$ordre++;

			$chemins = $this->getCheminsAOrdonner($idRelation, $idChemin, $noeudActuel);

			if (isset($chemins[0])) {

				$idChemin = $chemins[0]['id_chemin'];

				$nodes = $this->getNoeuds($idChemin);

				$nombreNodes = count($nodes);

				if (strcmp($nodes[0]['id_noeud'], $noeudActuel ) == 0) {

					$sens = 'directe';

					$noeudActuel = $nodes[$nombreNodes-1]['id_noeud'];

				} else {

					$sens = 'indirecte';

					$noeudActuel = $nodes[0]['id_noeud'];

				}

				$this->mettreAJourChemin($idRelation, $idChemin, $ordre, $sens, $numPolygone);

			}

		}

		$ordre = 1000 * $tour; //différencier chaque polygone: pour chaque polygone on a un multiple de mille

		if ($this->getNombreChemins($idRelation) != 0) {

			//appelle de la méthode récursivement

			$this->ordonnerCheminsMultiPolygone($idRelation, ++$numPolygone, $ordre, ++$tour);

		}

	}

	private function getRelationsAuPolygoneIncomplet() {

		$requete = 'SELECT id_relation '.

			'FROM osm_communes '.

			"WHERE notes = 'Polygone incomplet' ".

			' -- '.__FILE__.' : '.__LINE__;

		$relations = $this->bdd->recupererTous($requete);

		return $relations;

	}

	private function getChemins($idRelation) {

		$requete = 'SELECT id_chemin '.

			'FROM osm_relation_a_chemins '.

			"WHERE id_relation = $idRelation ".

			"AND ordre IS NULL ".

			' -- '.__FILE__.' : '.__LINE__;

		$chemins = $this->bdd->recupererTous($requete);

		return $chemins;

	}

	/**

	 * Select des ways qui n'ont pas été ordonnés: on obtient à chaque itération les ways qui restent à ordonner

	 */

	private function getCheminsAOrdonner($idRelation, $idChemin, $idNoeud) {

		$requete = 'SELECT cn.id_chemin '.

			'FROM osm_relation_a_chemins AS rc '.

			'	INNER JOIN osm_chemin_a_noeuds AS cn ON (rc.id_chemin = cn.id_chemin) '.

			"WHERE cn.id_noeud = $idNoeud ".

			"AND cn.id_chemin != $idChemin ".

			"AND rc.id_relation = $idRelation ".

			"AND rc.ordre IS NULL ".

			' -- '.__FILE__.' : '.__LINE__;

		$chemins = $this->bdd->recupererTous($requete);

		return $chemins;

	}

	private function getNoeuds($idChemin) {

		$requete = 'SELECT id_noeud '.

			'FROM osm_chemin_a_noeuds '.

			"WHERE id_chemin = $idChemin ".

			'ORDER BY ordre '.

			' -- '.__FILE__.' : '.__LINE__;

		$noeuds = $this->bdd->recupererTous($requete);

		return $noeuds;

	}

	private function getNombreChemins($idRelation) {

		$requete = 'SELECT COUNT(id_chemin) AS nbre '.

			'FROM osm_relation_a_chemins '.

			"WHERE id_relation = $idRelation ".

			'AND ordre = 0 '.

			' -- '.__FILE__.' : '.__LINE__;

		$infos = $this->bdd->recuperer($requete);

		return $infos['nbre'];

	}

	private function mettreAJourChemin($idRelation, $idChemin, $ordre, $sens, $nbrePoly) {

		$requete = 'UPDATE osm_relation_a_chemins '.

			"SET ordre = '$ordre', sens = '$sens', num_poly = $nbrePoly ".

			"WHERE id_relation = $idRelation ".

			"AND id_chemin = $idChemin ".

			' -- '.__FILE__.' : '.__LINE__;

		$this->bdd->requeter($requete);

	}

	/**

	 * Fonction qui récupère les relations des polygones incomplets et appelle pour chaque relation la fonction

	 * remplirPolygoneIncomplet($idRelation);

	 */

	private function remplirRelationsAuPolygoneIncomplet() {

		$relations = $this->getRelationsAuPolygoneIncomplet();

		foreach ($relations as $relation) {

			$this->remplirPolygoneIncomplet($relation['id_relation']);

			if ($this->mode == 'manuel') {

				$this->messages->afficherAvancement("Création du polygone incomplet : ", 1);

			}

		}

	}

	/**

	 * 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é. Puis met à jour le polygone

	 * de la commune.

	 */

	private function remplirPolygoneIncomplet($idRelation) {

		// Tableau multipolygone qui contient tous les polygones d'un multipolygone

		$multiPolygone = array();

		// Tableau roles qui contient les différents roles des chemins de la relation

		$roles = array();

		// Sélectionner le nombre de polygones qui existe dans un multipolygone

		$nbPoly = $this->getNombrePoly($idRelation);

		//boucle for qui parcourt chaque polygone du multipolygone

		for ($numPoly = 1; $numPoly <= $nbPoly; $numPoly++) {

			$polygone = array();

			$chemins = $this->getCheminsParPolygone($idRelation, $numPoly);

			foreach ($chemins as $chemin) {

				$role = $chemin['role'];

				$roles[$role] = (isset($roles[$role])) ? $roles[$role]++ : 1;

				$noeuds = $this->getNoeudsPourCheminEtSens($chemin['id_chemin'], $chemin['sens']);

				$polygone = array_merge($polygone, $noeuds);

			}

			$multiPolygone[] = implode(', ', $polygone);

		}

		$this->mettreAJourMultiPolygone($multiPolygone, $roles, $idRelation, $nbPoly);

	}

	private function getNombrePoly($idRelation) {

		$requete = 'SELECT MAX(num_poly) AS num_poly '.

			'FROM osm_relation_a_chemins '.

			"WHERE id_relation = $idRelation ".

			' -- '.__FILE__.' : '.__LINE__;

		$resultat = $this->bdd->recuperer($requete);

		return $resultat['num_poly'];

	}

	private function getCheminsParPolygone($idRelation, $numPoly) {

		$requete = 'SELECT id_chemin, sens, role '.

			'FROM osm_relation_a_chemins '.

			"WHERE id_relation = $idRelation ".

			"AND num_poly = $numPoly ".

			'ORDER BY ordre '.

			' -- '.__FILE__.' : '.__LINE__;

		$chemins = $this->bdd->recupererTous($requete);

		return $chemins;

	}

	private function getNoeudsPourCheminEtSens($idChemin, $sens) {

		$tri = ($sens == 'directe') ? 'ASC' : 'DESC';

		$requete = 'SELECT NLL.id_noeud, NLL.lat, NLL.`long` '.

			'FROM osm_chemin_a_noeuds AS WN '.

			'	INNER JOIN osm_noeuds AS NLL ON (WN.id_noeud = NLL.id_noeud) '.

			"WHERE WN.id_chemin = $idChemin ".

			"ORDER BY WN.ordre $tri ".

			' -- '.__FILE__.' : '.__LINE__;

		$noeuds = $this->bdd->recupererTous($requete);

		$latLng = array();

		foreach ($noeuds as $noeud) {

			$latLng[] = $noeud['lat'].' '.$noeud['long'];

		}

		return $latLng;

	}

	/**

	 * Remplie le champ polygone à partir du tableau MultiPolygone

	 */

	private function mettreAJourMultiPolygone($multiPolygone, $roles, $idRelation, $nbPoly) {

		// Présence d'une enclave contenue dans cette entité administrative mais qui appartient à une autre entité administrative

		if ((isset($roles['inner']) || isset($roles['enclave']))) {

			if ($nbPoly == 2) {

				$multiPoly = implode('),(', $multiPolygone);

			} else {

				$multiPoly = null;

				$msgTpl = "La relation '%s' possède plus de 2 polygones de type enclaves.";

				$this->messages->traiterErreur($msgTpl, array($idRelation));

			}

		} else {

			// Tous les autres cas

			$multiPoly = implode(')),((', $multiPolygone);

		}

		if (isset($multiPoly)) {

			$this->mettreAJourCommune($idRelation, $multiPoly);

		}

	}

	private function mettreAJourCommune($idRelation, $multiPoly) {

		$requete = 'UPDATE osm_communes '.

			"SET polygone = MPOLYFROMTEXT('MULTIPOLYGON((($multiPoly)))'), ".

			"notes = 'Polygone complet' ".

			"WHERE id_relation = $idRelation ".

			' -- '.__FILE__.' : '.__LINE__;

		$this->bdd->requeter($requete);

	}

	/**

	 * Renomme la note des polygones vides d'un polygone complet en polygone incomplet

	 */

	private function renommerEnPolygoneIncomplet() {

		$requete = 'UPDATE osm_communes '.

			"SET notes = 'Polygone incomplet' ".

			"WHERE ASTEXT(polygone) IS NULL ".

			' -- '.__FILE__.' : '.__LINE__;

		$retour = $this->bdd->requeter($requete);

		$this->messages->traiterInfo("Nombre de polygones définis à incomplet : ".$retour->rowCount());

	}

}