Subversion Repositories eFlore/Applications.cel

Compare Revisions

No changes between revisions

Ignore whitespace Rev 2413 → Rev 2414

/trunk/scripts/modules/codeinseecommune/traitements_cel
File deleted
/trunk/scripts/modules/codeinseecommune/Codeinseecommune.php
File deleted
\ No newline at end of file
/trunk/scripts/modules/codeinseecommune/codeinseecommune.sh
File deleted
\ No newline at end of file
/trunk/scripts/modules/codeinseecommune/bibliotheque/Dao.php
File deleted
\ No newline at end of file
/trunk/scripts/modules/migrationmotscles/Migrationmotscles.php
File deleted
\ No newline at end of file
/trunk/scripts/modules/migrationmotscles/bibliotheque/Dao.php
File deleted
\ No newline at end of file
/trunk/scripts/modules/generationimages/Generationimages.php
File deleted
\ No newline at end of file
/trunk/scripts/modules/generationimages/ImageRecreation.php
File deleted
\ No newline at end of file
/trunk/scripts/modules/code_insee_commune/CodeInseeCommune.php
New file
0,0 → 1,191
<?php
// declare(encoding='UTF-8');
/**
* Traitement des codes INSEE de la base de données CEL
* Permet d'affecter des codes INSEE aux obs possédant des coordonnées mais pas de commune.
*
* Utilisation :
* - Pour ? : <code>/opt/lamp/bin/php cli.php code_insee_commune -a tout</code>
* - Pour ? : <code>/opt/lamp/bin/php cli.php code_insee_commune -a colonne</code>
* - Pour ? : <code>/opt/lamp/bin/php cli.php code_insee_commune -a sanscorrespondance</code>
* - Pour ? : <code>/opt/lamp/bin/php cli.php code_insee_commune -a calculer</code>
*
* @category CEL
* @package Scripts
* @subpackage Génération Images
* @author Mathias CHOUET <mathias@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Aurelien PERONNET <aurelien@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @copyright 1999-2014 Tela Botanica <accueil@tela-botanica.org>
*/
include_once dirname(__FILE__).'/bibliotheque/Dao.php';
 
class CodeInseeCommune extends Script {
 
protected $tableauTaxon;
protected $dao;
protected $observations;
 
protected $mode_verbeux = false;
 
// Paramêtres autorisées lors de l'appel au script en ligne de commande
protected $parametres_autorises = array(
'-n' => array(true, true, 'Nom du fichier ou du dossier à traiter'));
 
public function executer() {
 
$this->dao = new Dao();
// Récupération de paramétres
// Lancement de l'action demandée
$cmd = $this->getParametre('a');
$this->mode_verbeux = $this->getParametre('v');
 
switch ($cmd) {
case 'tout' :
// à effectuer manuellement au premier lancement du script
$this->creerColonne();
$this->calculerCodesInsee();
break;
case 'colonne' :
$this->creerColonne();
break;
case 'sanscorrespondance' :
// devrait être être l'option utilisée dans le cron quotidien (avec l'option -v 0)
$this->calculerCodesInseeSansCorrespondance();
break;
case 'calculer' :
$this->calculerCodesInsee();
break;
default :
$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
}
}
 
private function creerColonne() {
$this->dao->creerColonneCodeInseeCalcule();
}
 
private function calculerCodesInseeSansCorrespondance() {
$liste_coordonnees = $this->dao->rechercherCoordonneesSansCorrespondances();
$this->traiterCoordonnees($liste_coordonnees);
}
 
private function calculerCodesInsee() {
$liste_coordonnees = $this->dao->rechercherCoordonnees();
$this->traiterCoordonnees($liste_coordonnees);
}
 
private function traiterCoordonnees($liste_coordonnees) {
$debut = microtime(true);
$nb_coordonnees_modifiees = 0;
$nb_coordonnees_ignorees = 0;
$total = count($liste_coordonnees);
 
if ($this->mode_verbeux) {
echo "-------------------------------------------------------------------\n";
echo " Calcul des codes INSEE et modification (".count($liste_coordonnees)." coordonnées en tout) ... \n";
echo " Enrichissement des champs zone geo et ce_zone_geo vides ... \n";
echo "-------------------------------------------------------------------\n";
}
 
foreach ($liste_coordonnees as $coordonnees) {
$infos_coord = $this->obtenirInfosPourCoordonnees($coordonnees);
if ($infos_coord != null) {
$coordonnee_a_traiter = array(
'latitude' => $coordonnees['latitude'],
'longitude' => $coordonnees['longitude'],
'code_insee' => $infos_coord['code_insee'],
'nom' => $infos_coord['nom']
);
$this->modifierInformationsGeo($coordonnee_a_traiter);
$nb_coordonnees_modifiees++;
} else {
$nb_coordonnees_ignorees++;
}
if ($this->mode_verbeux) {
$this->afficherAvancement(' Coordonnées traitées ', $nb_coordonnees_modifiees);
}
}
 
$fin = microtime(true);
if ($this->mode_verbeux) {
echo "\n";
echo "-------------------------------------------------------------------\n";
echo " Fin de la mise à jour des codes INSEE calculés et de l'enrichissement, \n";
echo " ".($fin - $debut)." secondes écoulées \n";
echo " ".$nb_coordonnees_modifiees." code insee calculés et modifiés \n";
echo " ".$nb_coordonnees_ignorees." coordonnées ignorées \n";
echo "-------------------------------------------------------------------\n";
echo "\n";
}
}
 
private function obtenirInfosPourCoordonnees($coordonnees) {
$infos_coord = null;
if ($this->testerCoordonneesWgsFrance($coordonnees['latitude'], $coordonnees['longitude'])) {
$infos_coord = $this->chercherInfosCommune('osm', $coordonnees['latitude'], $coordonnees['longitude']);
if ($infos_coord == null) {
$infos_coord = $this->chercherInfosCommune('lion1906', $coordonnees['latitude'], $coordonnees['longitude']);
}
}
return $infos_coord;
}
 
private function modifierInformationsGeo($coordonnee_a_traiter) {
$this->modifierCodeInseeCalculePourCoordonnees($coordonnee_a_traiter);
$this->modifierCodeInseeEtZoneGeo($coordonnee_a_traiter);
}
 
private function modifierCodeInseeCalculePourCoordonnees($coordonnee_a_traiter) {
$this->dao->testerActiviteConnection();
$this->dao->ajouterCodeInseeCalcule($coordonnee_a_traiter['latitude'], $coordonnee_a_traiter['longitude'], $coordonnee_a_traiter['code_insee']);
}
 
private function modifierCodeInseeEtZoneGeo($coordonnee_a_traiter) {
$this->dao->testerActiviteConnection();
$this->dao->modifierCodeInseeEtZoneGeo($coordonnee_a_traiter);
}
 
private function chercherInfosCommune($projet, $latitude, $longitude) {
$url_service = "www.tela-botanica.org/service:eflore:0.1/{$projet}/nom-commune".
"?lat={$latitude}&lon={$longitude}";
 
$url_service = str_replace(',', '.', $url_service);
$ch = curl_init($url_service);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$reponse = curl_exec($ch);
 
$infos_coord = $this->traiterReponseServiceCommune($reponse);
curl_close($ch);
 
return $infos_coord;
}
 
private function traiterReponseServiceCommune($reponse) {
$retour = null;
$reponse = json_decode($reponse);
// cas du service lion 1906 qui peut renvoyer plusieurs communes (on prend la première)
if (is_array($reponse)) {
$reponse = $reponse[0];
}
if (isset($reponse->codeINSEE)) {
$retour = array('code_insee' => $reponse->codeINSEE,
'nom' => $reponse->nom);
}
return $retour;
}
 
private function testerCoordonneesWgsFrance($latitude, $longitude) {
$coord_france = false;
if ($latitude != '' && $longitude != '') {
if ($latitude < 51.071667 && $latitude > 41.316667) {
if ($longitude < 9.513333 && $longitude > -5.140278) {
$coord_france = true;
}
}
}
return $coord_france;
}
}
/trunk/scripts/modules/code_insee_commune/code_insee_commune.sh
New file
0,0 → 1,12
#!/bin/bash
#
# /etc/init.d/codeinseecommune : traitement du calcul des codes insee du cel
# Aurélien Peronnet [11 avril 2013]
#
while true
do
logger "Lancement script cel::codeinseecommune"
sudo -u telabotap /usr/local/bin/php-cli-52 -f /home/telabotap/www/eflore-test/cel/scripts/cli.php codeinseecommune -a sanscorrespondance -v 0
logger "Arret script cel::codeinseecommune"
sleep 86400
done
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
Added: svn:executable
+*
\ No newline at end of property
/trunk/scripts/modules/code_insee_commune/traitements_cel.sh
New file
0,0 → 1,41
#!/bin/sh
#/etc/rc.d/init.d/
#
# Aurélien PERONNET [17 avril 2013]
# Service de lancement des scripts de maintenance et modification du cel
#
case "$1" in
 
start)
 
echo "Demarrage de codeinseecommune :"
nohup /usr/local/sbin/codeinseecommune.sh 1>/dev/null 2>/dev/null &
 
;;
 
stop)
 
echo "Arret de codeinseecommune"
PID=`ps -eaf | grep codeinseecommune | grep -v grep | tr -s ' ' | cut -d' ' -f2 | head -n1`
kill -9 ${PID}
 
;;
 
status)
 
echo -n "Voici les PID du processus codeinseecommune :"
PID=`ps -eaf | grep codeinseecommune | grep -v grep | tr -s ' ' | cut -d' ' -f2 | head -n1`
echo ${PID}
 
;;
 
 
*)
 
echo "Usage: {start|stop|status}"
 
exit 1
 
;;
 
esac
/trunk/scripts/modules/code_insee_commune/bibliotheque/Dao.php
New file
0,0 → 1,69
<?php
class Dao extends Bdd {
private $temps_derniere_requete = 0;
public function rechercherCoordonnees() {
$requete = "SELECT longitude, latitude ".
"FROM cel_obs ".
"GROUP BY longitude , latitude ";
$resultat = $this->recupererTous($requete);
$this->reinitialiserTempsDerniereRequete();
return $resultat;
}
public function rechercherCoordonneesSansCorrespondances() {
$requete = 'SELECT longitude, latitude '.
'FROM cel_obs '.
"WHERE code_insee_calcule = '' ".
' AND DATE_ADD(date_modification, INTERVAL 25 HOUR) >= CURDATE() '.
'GROUP BY longitude , latitude ';
$resultat = $this->recupererTous($requete);
$this->reinitialiserTempsDerniereRequete();
return $resultat;
}
public function creerColonneCodeInseeCalcule() {
$create = 'ALTER TABLE cel_obs '.
'ADD code_insee_calcule VARCHAR(5) NOT NULL ';
$this->requeter($create);
$this->reinitialiserTempsDerniereRequete();
}
public function ajouterCodeInseeCalcule($latitude, $longitude, $code_insee) {
$insert = 'UPDATE cel_obs '.
"SET code_insee_calcule = ".$this->proteger($code_insee)." ".
"WHERE latitude = ".$this->proteger($latitude)." ".
" AND longitude = ".$this->proteger($longitude)." ";
$this->requeter($insert);
$this->reinitialiserTempsDerniereRequete();
}
public function modifierCodeInseeEtZoneGeo($coordonnees) {
$update = "UPDATE cel_obs ".
"SET ce_zone_geo = concat('INSEE-C:' , code_insee_calcule), ".
"zone_geo = ".$this->proteger($coordonnees['nom'])." ".
"WHERE ce_zone_geo = '' AND zone_geo = '' ".
" AND latitude = ".$this->proteger($coordonnees['latitude'])." ".
" AND longitude = ".$this->proteger($coordonnees['longitude'])." ";
$this->requeter($update);
$this->reinitialiserTempsDerniereRequete();
}
// Il peut se passer assez de temps sans qu'aucune requete ne soit effectuée
// (cas d'un grand nombre d'enregistrements à la suite pour lesquels on ne trouve
// aucun département). Pour éviter cela on teste régulièrement la connection
public function testerActiviteConnection() {
$temps_courant = microtime(true);
$temps_depuis_derniere_requete = $temps_courant - $this->temps_derniere_requete;
if($temps_depuis_derniere_requete >= 18) {
$this->ping();
$this->reinitialiserTempsDerniereRequete();
}
}
private function reinitialiserTempsDerniereRequete() {
$this->temps_derniere_requete = microtime(true);
}
}
?>
/trunk/scripts/modules/generation_images/GenerationImages.php
New file
0,0 → 1,75
<?php
// declare(encoding='UTF-8');
/**
* Génère des miniatures.
*
* Utilisation :
* - Pour ? : <code>/opt/lamp/bin/php cli.php generation_images -a genererMinaturesEnAttente</code>
* - Pour ? : <code>/opt/lamp/bin/php cli.php generation_images -a genererMinaturesEnAttente</code>
*
* @category CEL
* @package Scripts
* @subpackage Génération Images
* @author Mathias CHOUET <mathias@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Aurelien PERONNET <aurelien@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @copyright 1999-2014 Tela Botanica <accueil@tela-botanica.org>
*/
class GenerationImages extends Script {
 
protected $bdd;
protected $parametres_autorises = array(
'-id' => array(false, '1', 'Identifiants des images à traiter (séparés par des virgules')
);
 
public function __construct($script_nom, $parametres_cli) {
parent::__construct($script_nom, $parametres_cli);
$this->bdd = new Bdd();
}
 
public function executer() {
$cmd = $this->getParametre('a');
switch($cmd) {
case 'genererMinaturesEnAttente';
$this->genererMiniaturesEnAttente();
break;
case 'genererMinaturesPourId';
$this->genererMinaturesPourId();
break;
default :
$msg = "Erreur : la commande '$cmd' n'existe pas!\n";
throw new Exception($msg);
}
}
 
private function genererMinaturesPourId() {
$id = $this->getParametre('id');
$ids = explode(',',$id);
if ($id == null) {
echo "le paramètre id doit être un ensemble de nombres séparés par des virgules";
} else {
include_once dirname(__FILE__).'/bibliotheque/ImageRecreation.php';
$createur_images = new ImageRecreation();
foreach ($ids as $id_image) {
$createur_images->regenererMiniaturesPourId(array($id_image));
}
}
}
 
private function genererMiniaturesEnAttente() {
$req = "SELECT id_image FROM cel_images WHERE ".
"date_creation >= DATE_SUB(NOW(), INTERVAL 15 MINUTE)";
$images_attente = $this->bdd->recupererTous($req);
 
if (!empty($images_attente)) {
// iterer sur config pour formats
include_once dirname(__FILE__).'/bibliotheque/ImageRecreation.php';
$createur_images = new ImageRecreation();
foreach ($images_attente as $image) {
$createur_images->regenererMiniaturesPourId(array($image['id_image']));
}
}
}
}
/trunk/scripts/modules/generation_images/bibliotheque/ImageRecreation.php
New file
0,0 → 1,669
<?php
// declare(encoding='UTF-8');
/**
* Cette classe est un quasi copier-coller de la classe éponyme dans
* le dossier lib de jrest mais pas de mécanisme commun pour les classes
*
* @category CEL
* @package Scripts
* @subpackage Génération Images
* @author Mathias CHOUET <mathias@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Aurelien PERONNET <aurelien@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @copyright 1999-2014 Tela Botanica <accueil@tela-botanica.org>
*/
// TODO: utiliser la même classe pour jrest ainsi que les scripts => créer un projet cel-commun (même principe que del-commun)
Class ImageRecreation {
 
private $droits = 0755;
private $formats = array('CRX2S','CRXS','CXS','CS','CRS','XS','S','M','L','XL','X2L','X3L');
const MODE_GD = 'gd';
const MODE_IMAGEMAGICK = 'imagemagick';
private $mode;
 
private $verbose = true;
 
public function __construct() {
if (extension_loaded('imagick')) {
$this->mode = self::MODE_IMAGEMAGICK;
} else {
$this->mode = self::MODE_GD;
}
}
 
public function recreerMiniaturesRecursivement() {
$this->itererRecursivement(Config::get('dossierImages'));
}
 
public function regenererMiniaturesIntervalle($params) {
$id_debut = $params[0];
$id_fin = $params[1];
 
if (is_numeric($id_debut) && is_numeric($id_fin)) {
for ($i = $id_debut; $i <= $id_fin; $i++) {;
$tab_param = array($i);
$this->regenererMiniaturesPourId($tab_param);
}
}
}
 
public function regenererMiniaturesPourId($params) {
$id = $params[0];
 
if (!is_numeric($id)) {
return;
}
 
$dossier_fichier = $this->obtenirDossierPourFormat($id, 'O');
$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
 
$chemin_fichier = $dossier_fichier.'/'.$nom_fichier;
 
if (file_exists($chemin_fichier)) {
$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
// obtention d'un verrou sur le fichier original pour empecher d'autres scripts
// d'effectuer la création des miniatures
$fp = fopen($chemin_fichier, "r");
$verrou = flock($fp, LOCK_EX);
// creation de miniatures pour chacuns des formats définis
foreach ($this->formats as $format) {
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
};
$verrou = flock($fp, LOCK_UN);
fclose($fp);
}
}
 
public function itererRecursivement($dossier) {
// on ne parse que le dossier des images originales
$dossiers_a_exclure = $this->getFormats();
 
foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {
if ($fichier_ou_dossier->isDot()) {
continue;
}
 
if (in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {
continue;
}
 
if ($fichier_ou_dossier->isDir()) {
$this->itererRecursivement($fichier_ou_dossier->getPathname());
} else {
$nom_fichier = $fichier_ou_dossier->getFilename();
 
$infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());
$id = $this->convertirBaseNomFichierVersIdBdd($nom_fichier, $this->formats);
 
// creation de miniatures pour chacuns des formats définis
foreach ($this->formats as $format) {
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
}
}
}
}
 
public function creerOuRenvoyerImage($id, $format) {
$dossier = $this->obtenirDossierPourFormat($id, $format);
$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
$chemin_image = $dossier.'/'.$nom_fichier;
 
$image = false;
if(!file_exists($chemin_image)) {
$infos_image_originale = $this->obtenirImageEtInfosPourChemin($this->obtenirCheminImageOriginale($id));
if($infos_image_originale) {
$debut = microtime();
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
 
$image = file_get_contents($chemin_image);
}
} else {
$image = file_get_contents($chemin_image);
}
 
return $image;
}
 
public function creerMiniatureImageSelonFormat($infos_image_originale, $format = 'O') {
if ($format == 'O') {
// format original : rien à faire
$image_redimensionnee = $infos_image_originale['image'];
 
} else {
if ($this->estUnFormatRogne($format)) {
if ($this->mode == self::MODE_IMAGEMAGICK) {
// si l'on dispose de la librairie imageMagick
// on applique l'algorithme d'auto détection de sujets
// qui centre la miniature sur le sujet de l'image
$image_redimensionnee = $this->opticrop($infos_image_originale, $format);
} else {
// si l'on ne dispose que de gd
// la minature est une image redimensionnée rognée au centre
$image_redimensionnee = $this->creerMiniatureCarreeRognee($infos_image_originale, $format);
}
} else if ($this->estUnFormatCarre($format)) {
// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc
$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);
} else {
$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);
}
}
 
return $image_redimensionnee;
}
 
public function stockerFichierOriginal($fichier, $id) {
$chemin_fichier_origine = is_array($fichier) ? $fichier['tmp_name'] : $fichier;
 
$chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O');
$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
 
$chemin_fichier = $chemin_base_fichier.'/'.$nom_fichier;
 
$deplacement_fichier = $this->stockerImageExterne($chemin_fichier_origine, $chemin_fichier);
 
if ($deplacement_fichier) {
$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
 
if ($taux_compression < 100 && $this->mode == self::MODE_IMAGEMAGICK) {
$this->ecrireImageSurDisqueAvecMeta($chemin_fichier, $taux_compression);
}
 
return $infos_image_originale;
 
} else {
$erreur = 'ERROR : probleme durant le déplacement du fichier temporaire \n' ;
$this->logger('CEL_bugs',$erreur);
return false ;
}
}
 
public function stockerFichierEtCreerMiniatures($fichier, $id) {
 
$infos_image_originale_stockee = $this->stockerFichierOriginal($fichier, $id);
if($infos_image_originale_stockee) {
$formats = $this->getFormats();
 
// creation de miniatures pour chacuns des formats définis
foreach($formats as $format) {
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale_stockee, $format);
}
} else {
$erreur = 'ERROR : impossible d\'obtenir les informations sur l\'image originale \n' ;
$this->logger('CEL_bugs',$erreur);
return false ;
}
 
return true ;
}
 
public function creerEtStockerMiniatureFichierImageSelonFormat($id ,$infos_image_originale, $format = 'O') {
$image_redimensionnee = $this->creerMiniatureImageSelonFormat($infos_image_originale, $format);
 
$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
$this->ecrireImageSurDisque($image_redimensionnee, $id, $format, $taux_compression);
 
return true;
}
 
public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {
$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);
 
imagecopyresampled($image_redimensionnee,
$infos_image_originale['image'],
0, 0,
0, 0,
$largeur_redimension,
$hauteur_redimension,
$infos_image_originale['largeur'],
$infos_image_originale['hauteur']
);
 
return $image_redimensionnee;
}
 
public function creerMiniature($informations_images, $format) {
$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
 
$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);
 
return $image_redimensionnee;
}
 
public function creerMiniatureCarree($informations_image, $format) {
$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
$cote_carre = $taille_reference_pour_format['largeur'];
 
$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_image, $format);
$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_image, $taille_reference_pour_format['hauteur']);
 
if ($this->estPaysage($informations_image)) {
$debut_largeur_a_copier = 0 ;
$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;
} else {
$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;
$debut_hauteur_a_copier = 0 ;
}
 
$image_carre_blanc_cible = $this->renvoyerEtCreerImageCarreeBlancheSelonFormat($cote_carre);
 
imagecopy($image_carre_blanc_cible, $image_redimensionnee_avec_rapport,
$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,
$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']
);
 
return $image_carre_blanc_cible;
}
 
public function creerMiniatureCarreeRognee($informations_image, $format) {
$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
$cote_carre = $taille_reference_pour_format['largeur'];
$cote_carre_non_redimensionne = 0;
 
if ($this->estPaysage($informations_image)) {
$cote_carre_non_redimensionne = $informations_image['hauteur'];
$debut_largeur_a_copier = ($informations_image['hauteur'] - $cote_carre)/2 ;
$debut_hauteur_a_copier = 0;
 
if($debut_largeur_a_copier <= 0) {
$debut_largeur_a_copier = 0;
}
 
$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
} else {
$cote_carre_non_redimensionne = $informations_image['largeur'];
$debut_largeur_a_copier = 0 ;
$debut_hauteur_a_copier = ($informations_image['largeur'] - $cote_carre)/2;
 
if ($debut_hauteur_a_copier <= 0) {
$debut_hauteur_a_copier = 0;
}
 
$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
}
 
$image_carre_temporaire = imagecreatetruecolor($cote_carre_non_redimensionne, $cote_carre_non_redimensionne);
 
imagecopyresampled($image_carre_temporaire,
$informations_image['image'],
0, 0,
$debut_largeur_a_copier,
$debut_hauteur_a_copier,
$cote_carre_non_redimensionne,
$cote_carre_non_redimensionne,
$nb_pixels_largeur_a_copier,
$nb_pixels_hauteur_a_copier
);
 
$image_redimensionnee = imagecreatetruecolor($cote_carre, $cote_carre);
 
imagecopyresampled($image_redimensionnee,
$image_carre_temporaire,
0, 0,
0, 0,
$cote_carre,
$cote_carre,
$cote_carre_non_redimensionne,
$cote_carre_non_redimensionne
);
 
return $image_redimensionnee;
}
 
public function stockerImageExterne($chemin_fichier_temp, $chemin_destination) {
if (is_uploaded_file($chemin_fichier_temp)) {
$deplacement = move_uploaded_file($chemin_fichier_temp, $chemin_destination);
} else {
$deplacement = rename($chemin_fichier_temp, $chemin_destination);
}
 
return $deplacement;
}
 
public function creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format) {
$chemin_sur_serveur_final = $this->obtenirDossierPourFormat($id, $format);
 
if (!file_exists($chemin_sur_serveur_final)) {
umask(0);
if (!mkdir($chemin_sur_serveur_final, $this->droits, true)) {
$erreur = 'ERROR : probleme durant l\'écriture du dossier '.$format.' \n' ;
$this->logger('CEL_bugs', $erreur);
return false;
}
}
 
return $chemin_sur_serveur_final;
}
 
public function obtenirDossierPourFormat($id, $format) {
$chemin_base = Config::get('dossierImages');
 
$chemin_sur_serveur = $chemin_base;
 
$id = sprintf('%09s', $id);
$id = wordwrap($id, 3 , '_', true);
 
list($dossierNiveau1, $dossierNiveau2) = explode('_', $id);
 
$chemin_sur_serveur_final = $chemin_sur_serveur.'/'.$dossierNiveau1.'/'.$dossierNiveau2.'/'.$format;
 
return $chemin_sur_serveur_final;
}
 
public function obtenirCheminImageOriginale($id_image) {
$nom = $this->convertirIdBddVersNomFichier($id_image, 'O');
$dossier = $this->obtenirDossierPourFormat($id_image,'O');
 
return $dossier.'/'.$nom;
}
 
public function obtenirImageEtInfosPourId($id_image) {
$chemin_image_o = $this->obtenirCheminImageOriginale($id_image);
return $this->obtenirImageEtInfosPourChemin($chemin_image_o);
}
 
public function obtenirImageEtInfosPourChemin($chemin_fichier) {
$image_et_infos = false;
 
if (file_exists($chemin_fichier)) {
$image_et_infos = array();
list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);
$image_et_infos['poids_octets'] = filesize($chemin_fichier);
$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
$image_et_infos['chemin'] = $chemin_fichier;
}
 
return $image_et_infos;
}
 
public function obtenirDimensionsPourFormat($format) {
$dimensions = array('largeur' => 0, 'hauteur' => 0);
 
if (Config::get('format_'.$format) != null) {
list($dimensions['largeur'], $dimensions['hauteur']) = explode('_', Config::get('format_'.$format));
}
 
return $dimensions;
}
 
public function calculerTailleImage($informations_images, $taille_max) {
$HL_redimension = array();
 
if ($this->estPaysage($informations_images)) {
$rapport = $informations_images['hauteur']/$informations_images['largeur'] ;
$HL_redimension['largeur'] = round($taille_max) ;
$HL_redimension['hauteur'] = round($taille_max*$rapport) ;
} else {
$rapport = $informations_images['largeur']/$informations_images['hauteur'] ;
$HL_redimension['hauteur'] = round($taille_max) ;
$HL_redimension['largeur'] = round($taille_max*$rapport) ;
}
 
return $HL_redimension;
}
 
public function getFormats() {
return $this->formats;
}
 
public function estUnFormatCarre($format) {
return (strpos($format,'C') === 0);
}
 
public function estUnFormatRogne($format) {
return (strpos($format,'R') === 1);
}
 
public function estPaysage($informations_images) {
return $informations_images['largeur'] > $informations_images['hauteur'];
}
 
public function estPortait($informations_images) {
return $informations_images['largeur'] < $informations_images['hauteur'];
}
 
public function renvoyerTauxCompressionPourPoids($poids_octets) {
$poids_max_octets = Config::get('tailleMaxImages');
 
$ratio_compression = 100 ;
 
if ($poids_octets >= $poids_max_octets) {
$ratio_compression = 75 ;
}
 
return $ratio_compression;
}
 
public function convertirIdBddVersNomFichier($id, $format, $extension = 'jpg') {
// creation du format original
$id_avec_zeros = sprintf('%09s', $id) ;
$id_avec_zeros_underscores = wordwrap($id_avec_zeros, 3 , '_', true) ;
 
$nom_fichier = $id_avec_zeros_underscores.'_'.$format.'.'.$extension;
 
return $nom_fichier;
}
 
public function convertirBaseNomFichierVersIdBdd($nom_fichier, $formats) {
$nom_fichier_sans_extension = trim($nom_fichier, '.jpg');
 
foreach($formats as $format) {
$nom_fichier_sans_extension = trim($nom_fichier_sans_extension, '_'.$format);
}
 
$id_image = str_replace('_', '', $nom_fichier_sans_extension);
 
// suppression des 0 devant
$id_image += 0;
 
return $id_image;
}
 
public function ecrireImageSurDisque($image_binaire, $id, $format, $compression = 100) {
umask(0);
 
$chemin_sur_serveur_final = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format);
$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
 
if (file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
}
 
// attention, ceci ne preserve pas les metadonnées
imagejpeg($image_binaire, $chemin_sur_serveur_final.'/'.$nom_fichier, $compression);
chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);
}
 
public function ecrireImageSurDisqueAvecMeta($chemin_image_a_stocker, $compression = 100) {
$img = new Imagick($chemin_image_a_stocker);
 
// l'utilisation d'image magick préserve les métadonnées lors d'une recompression
$img->setformat("jpeg");
$img->setImageCompression(imagick::COMPRESSION_JPEG);
$img->setCompressionQuality($compression);
$img->writeImage($chemin_image_a_stocker);
$img->destroy();
 
chmod($chemin_image_a_stocker, $this->droits);
}
 
public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) {
$image_blanche = imagecreatetruecolor($cote, $cote);
$blanc = imagecolorallocate($image_blanche, 255, 255, 255);
imagefilledrectangle($image_blanche, 0, 0, $cote, $cote, $blanc);
 
return $image_blanche;
}
 
public function detruireImageEnMemoire($image) {
imagedestroy($image);
}
 
public function detruireImageSurDisque($id) {
$formats = $this->getFormats();
 
// on detruit aussi l'image originale
$formats[] = 'O';
 
$destruction_formats_fichier = false;
 
// destructions de chacuns des formats définis
foreach($formats as $format) {
 
$dossier_format = $this->obtenirDossierPourFormat($id, $format);
$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
 
if (file_exists($dossier_format.'/'.$nom_fichier)) {
$destruction_formats_fichier = unlink($dossier_format.'/'.$nom_fichier);
} else {
$destruction_formats_fichier = true;
}
}
 
return $destruction_formats_fichier;
}
 
/*
* edge-maximizing crop
* determines center-of-edginess, then tries different-sized crops around it.
* picks the crop with the highest normalized edginess.
* see documentation on how to tune the algorithm
*
* $informations_image - le tableau d'informations sur l'image tel que renvoyé par la fonction obtenirImageEtInfosPourChemin
* $format - le format (ex. : CS, XS, XL, CRS)
*/
public function opticrop($informations_image, $format) {
umask(0);
 
$nom_temp = md5(time());
$chemin_temp =
 
$out = Config::get('dossierImagesStockageTemp').'/'.$nom_temp;
 
$dimension_vignettes = $this->obtenirDimensionsPourFormat($format);
 
$largeur_vignette = $dimension_vignettes['largeur'];
$hauteur_vignette = $dimension_vignettes['hauteur'];
 
// source dimensions
$largeur_image_originale = $informations_image['largeur'];
$hauteur_image_originale = $informations_image['hauteur'];
 
$chemin_image = $informations_image['chemin'];
 
//if ($largeur_vignette > $largeur_image_originale || $hauteur_vignette > $hauteur_image_originale)
// die("Target dimensions must be smaller or equal to source dimensions.");
 
// parameters for the edge-maximizing crop algorithm
$r = 1; // radius of edge filter
$nk = 9; // scale count: number of crop sizes to try
$gamma = 0.2; // edge normalization parameter -- see documentation
$ar = $largeur_vignette/$hauteur_vignette; // target aspect ratio (AR)
$ar0 = $largeur_image_originale/$hauteur_image_originale; // original aspect ratio (AR)
 
$img = new Imagick($chemin_image);
$imgcp = clone $img;
 
// compute center of edginess
$img->edgeImage($r);
$img->modulateImage(100,0,100); // grayscale
$img->blackThresholdImage("#0f0f0f");
$img->writeImage($out);
// use gd for random pixel access
$im = ImageCreateFromJpeg($out);
$xcenter = 0;
$ycenter = 0;
$sum = 0;
$n = 100000;
for ($k=0; $k<$n; $k++) {
$i = mt_rand(0,$largeur_image_originale-1);
$j = mt_rand(0,$hauteur_image_originale-1);
$val = imagecolorat($im, $i, $j) & 0xFF;
$sum += $val;
$xcenter += ($i+1)*$val;
$ycenter += ($j+1)*$val;
}
$xcenter /= $sum;
$ycenter /= $sum;
 
// crop source img to target AR
if ($largeur_image_originale/$hauteur_image_originale > $ar) {
// source AR wider than target
// crop width to target AR
$wcrop0 = round($ar*$hauteur_image_originale);
$hcrop0 = $hauteur_image_originale;
} else {
// crop height to target AR
$wcrop0 = $largeur_image_originale;
$hcrop0 = round($largeur_image_originale/$ar);
}
 
// crop parameters for all scales and translations
$params = array();
 
// crop at different scales
$hgap = $hcrop0 - $hauteur_vignette;
$hinc = ($nk == 1) ? 0 : $hgap / ($nk - 1);
$wgap = $wcrop0 - $largeur_vignette;
$winc = ($nk == 1) ? 0 : $wgap / ($nk - 1);
 
// find window with highest normalized edginess
$n = 10000;
$maxbetanorm = 0;
$maxfile = '';
$maxparam = array('w'=>0, 'h'=>0, 'x'=>0, 'y'=>0);
 
for ($k = 0; $k < $nk; $k++) {
$hcrop = round($hcrop0 - $k*$hinc);
$wcrop = round($wcrop0 - $k*$winc);
$xcrop = $xcenter - $wcrop / 2;
$ycrop = $ycenter - $hcrop / 2;
//echo("crop: $wcrop, $hcrop, $xcrop, $ycrop");
 
if ($xcrop < 0) $xcrop = 0;
if ($xcrop+$wcrop > $largeur_image_originale) $xcrop = $largeur_image_originale-$wcrop;
if ($ycrop < 0) $ycrop = 0;
if ($ycrop+$hcrop > $hauteur_image_originale) $ycrop = $hauteur_image_originale-$hcrop;
 
$beta = 0;
for ($c=0; $c<$n; $c++) {
$i = mt_rand(0,$wcrop-1);
$j = mt_rand(0,$hcrop-1);
$beta += imagecolorat($im, $xcrop+$i, $ycrop+$j) & 0xFF;
}
$area = $wcrop * $hcrop;
$betanorm = $beta / ($n*pow($area, $gamma-1));
// echo("beta: $beta; betan: $betanorm");
// echo("image$k.jpg:<br/>\n<img src=\"$currfile\"/>");
// best image found, save it
 
if ($betanorm > $maxbetanorm) {
 
$maxbetanorm = $betanorm;
$maxparam['w'] = $wcrop;
$maxparam['h'] = $hcrop;
$maxparam['x'] = $xcrop;
$maxparam['y'] = $ycrop;
}
}
 
// return image
$imgcp->cropImage($maxparam['w'], $maxparam['h'], $maxparam['x'], $maxparam['y']);
$imgcp->scaleImage($largeur_vignette, $hauteur_vignette);
$imgcp->writeImage($out);
chmod($out, 0777);
$img->destroy();
$imgcp->destroy();
 
$image_sortie = ImageCreateFromJpeg($out);
unlink($out);
 
return $image_sortie;
}
}
/trunk/scripts/modules/migration_mots_cles/bibliotheque/Dao.php
New file
0,0 → 1,122
<?php
// declare(encoding='UTF-8');
/**
* Contient les requêtes effecturant la migration des mots-clés.
*
* @category CEL
* @package Scripts
* @subpackage Migration : Sauvages
* @author Mathias CHOUET <mathias@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Aurelien PERONNET <aurelien@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @copyright 1999-2014 Tela Botanica <accueil@tela-botanica.org>
*/
class Dao extends Bdd {
 
private $mode;
private $table_liaison;
private $table_mots_cles;
 
public function __construct($mode) {
parent::__construct();
$this->mode = $mode;
 
if ($mode == 'obs') {
$this->table_liaison = 'cel_mots_cles_obs_liaison';
$this->table_mots_cles = 'cel_arbre_mots_cles_obs';
} else {
$this->table_liaison = 'cel_mots_cles_images_liaison';
$this->table_mots_cles = 'cel_arbre_mots_cles_images';
}
}
 
public function viderTables() {
$requete = "TRUNCATE ".$this->table_mots_cles." ";
$vidage = $this->requeter($requete.' -- '.__FILE__.':'.__LINE__);
 
$requete = "TRUNCATE ".$this->table_liaison." ";
$vidage = $this->requeter($requete.' -- '.__FILE__.':'.__LINE__);
 
return $vidage;
}
 
public function obtenirMotsClesOriginaux() {
if($this->mode == 'obs') {
$requete = "SELECT id_mot_cle_obs as id_mot_cle, ce_mot_cle_obs_parent as parent, id_utilisateur, mot_cle ".
"FROM cel_mots_cles_obs WHERE niveau != 0 AND id_utilisateur != '' ORDER BY id_utilisateur, niveau";
} else {
$requete = "SELECT id_mot_cle_image as id_mot_cle, ce_mot_cle_image_parent as parent, id_utilisateur, mot_cle ".
"FROM cel_mots_cles_images WHERE niveau != 0 AND id_utilisateur != '' ORDER BY id_utilisateur, niveau";
}
 
$mots_cles = $this->recupererTous($requete);
return $mots_cles;
}
 
public function obtenirLiaisonsMotsClesOriginaux() {
if ($this->mode == 'obs') {
$requete = "SELECT comc.id_observation as id_element_lie, comc.id_mot_cle_obs as id_mot_cle, id_utilisateur as id_utilisateur ".
"FROM cel_obs_mots_cles comc ".
"INNER JOIN cel_obs o ON o.id_observation = comc.id_observation ";
} else {
$requete = "SELECT comc.id_image as id_element_lie, comc.id_mot_cle_image as id_mot_cle, o.ce_utilisateur as id_utilisateur ".
"FROM cel_images_mots_cles comc ".
"INNER JOIN cel_images o ON o.id_image = comc.id_image ";
}
$liaisons = $this->recupererTous($requete);
return $liaisons;
}
 
public function insererMotsCles($mots_cles) {
$requete = "INSERT INTO ".$this->table_mots_cles." (chemin, id_utilisateur, mot_cle) VALUES ";
 
foreach ($mots_cles as $mot_cle) {
$requete .= '('.
$this->proteger($mot_cle['chemin']).', '.
$this->proteger($mot_cle['id_utilisateur']).', '.
$this->proteger($mot_cle['mot_cle']).' '.
'), ';
}
 
$requete = rtrim($requete, ', ');
return $this->requeter($requete);
}
 
public function obtenirInfosNouveauxMotsCles() {
$requete = "SELECT id_mot_cle, id_utilisateur, chemin FROM ".$this->table_mots_cles;
return $this->recupererTous($requete);
}
 
public function insererLiaisonsMotsCles($mots_cles, $liaisons, $correspondances) {
$requete = "INSERT INTO ".$this->table_liaison." (id_element_lie, id_mot_cle) VALUES ";
$lier = false;
$mot_cles_inexistants = 0;
 
foreach ($liaisons as &$liaison_mot_cle) {
$cle = $liaison_mot_cle['id_mot_cle'].'-'.$liaison_mot_cle['id_utilisateur'];
if (isset($mots_cles[$cle])) {
$cle_id_mot_cle_migre = $mots_cles[$cle]['chemin'].'-'.$liaison_mot_cle['id_utilisateur'];
if(isset($correspondances[$cle_id_mot_cle_migre])) {
$id_mot_cle_migre = $correspondances[$cle_id_mot_cle_migre]['id_mot_cle'];
$requete .= "(".
$this->proteger($liaison_mot_cle['id_element_lie']).", ".
$this->proteger($id_mot_cle_migre)." ".
"), ";
$lier = true;
} else {
$mot_cles_inexistants++;
}
}
}
 
if ($lier) {
$requete = rtrim($requete, ', ');
$this->requeter($requete);
}
if ($mot_cles_inexistants != 0) {
echo $mot_cles_inexistants."\n";
}
}
}
/trunk/scripts/modules/migration_mots_cles/MigrationMotsCles.php
New file
0,0 → 1,174
<?php
// declare(encoding='UTF-8');
/**
* Traitement des mots clés cel pour les migrer vers des mots clés stockés avec path enumeration
*
* Utilisation :
* - migrer les mots-clés obs : <code>/opt/lamp/bin/php cli.php migration_mots_cles -a obs</code>
* - migrer les mots-clés images : <code>/opt/lamp/bin/php cli.php migration_mots_cles -a images</code>
*
* @category CEL
* @package Scripts
* @subpackage Migration : Mots-Clés
* @author Mathias CHOUET <mathias@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Aurelien PERONNET <aurelien@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @copyright 1999-2014 Tela Botanica <accueil@tela-botanica.org>
*/
include_once dirname(__FILE__).'/bibliotheque/Dao.php';
 
class MigrationMotsCles extends Script {
 
private $mode;
 
public function executer() {
$cmd = $this->getParametre('a');
$this->mode_verbeux = $this->getParametre('v');
 
switch($cmd) {
case 'obs':
$this->mode = $cmd;
$this->migrerMotsClesObservations();
break;
 
case 'images':
$this->mode = $cmd;
$this->migrerMotsClesImages();
break;
 
default:
echo 'Méthode inconnue, les méthodes possibles sont obs et images'."\n";
}
}
 
private function migrerMotsClesObservations() {
$this->dao = new Dao('obs');
$this->convertirNestedSetVersPathEnum();
}
 
private function migrerMotsClesImages() {
$this->dao = new Dao('images');
$this->convertirNestedSetVersPathEnum();
}
 
private function convertirNestedSetVersPathEnum() {
 
$debut = microtime();
 
$this->dao->viderTables();
 
$mots_cles_hierarchiques = $this->dao->obtenirMotsClesOriginaux($this->mode);
$mots_cles_hierarchiques = $this->formaterChemin($mots_cles_hierarchiques);
 
$liaisons = $this->dao->obtenirLiaisonsMotsClesOriginaux($this->mode);
 
if($this->mode_verbeux) {
echo "-------------------------------------------------------------------\n";
echo " Début de la migration des mots clés ".$this->mode." \n";
echo " ".count($mots_cles_hierarchiques)." mots clés et ".count($liaisons)." liaisons à migrer \n";
echo "-------------------------------------------------------------------\n";
}
 
$nb_mots_cles = 0;
$nb_liaisons = 0;
 
$mots_cles_slice = array_chunk($mots_cles_hierarchiques, 800, true);
echo " Insertion des mots clés par paquet de 800 \n";
foreach($mots_cles_slice as &$mots_cles_tranche) {
$this->dao->insererMotsCles($mots_cles_tranche);
$nb_mots_cles += 800;
if($this->mode_verbeux) {
$this->afficherAvancement(' mots clés insérés ', $nb_mots_cles);
}
}
echo "\n Insertion des mots clés ".$this->mode." terminée \n";
 
$infos_nouveaux_mots_cles = $this->dao->obtenirInfosNouveauxMotsCles();
$correspondances = $this->formaterCorrespondanceCheminId($infos_nouveaux_mots_cles);
 
$liaisons_slice = array_chunk($liaisons, 800, true);
echo " Insertion des mots liaisons par paquet de 800 \n";
foreach($liaisons_slice as &$liaison_tranche) {
$this->dao->insererLiaisonsMotsCles($mots_cles_hierarchiques, $liaison_tranche, $correspondances);
$nb_liaisons += 800;
if($this->mode_verbeux) {
$this->afficherAvancement(' liaisons insérées ', $nb_liaisons);
}
}
echo "\n Insertion des liaisons ".$this->mode." terminée \n";
 
$fin = microtime(true);
if($this->mode_verbeux) {
echo "\n";
echo "-------------------------------------------------------------------\n";
echo " Fin de la migration des mots clés ".$this->mode.", \n";
echo " ".($fin - $debut)." secondes écoulées \n";
echo " ".count($mots_cles_hierarchiques)." mots clés insérés \n";
echo " ".count($liaisons)." liaisons insérées \n";
echo "-------------------------------------------------------------------\n";
echo "\n";
}
}
 
private function formaterCorrespondanceCheminId($infos_nouveaux_mots_cles) {
$mots_cles_correspondances = array();
foreach($infos_nouveaux_mots_cles as &$mot) {
$cle = $mot['chemin'].'-'.$mot['id_utilisateur'];
$mots_cles_correspondances[$cle] = $mot;
}
return $mots_cles_correspondances;
}
 
private function formaterChemin($mots_cles) {
$mots_cles_hierarchiques = array();
$chemin_traites = array();
$pbs = array('doublons' => array(), 'vides' => array());
 
foreach($mots_cles as &$mot) {
 
if(trim($mot['mot_cle']) != "") {
$chemin = '/';
$cle_parent = $mot['parent'].'-'.$mot['id_utilisateur'];
if(isset($mots_cles_hierarchiques[$cle_parent])) {
$chemin = $mots_cles_hierarchiques[$cle_parent]['chemin'];
}
$chemin .= self::simplifier($mot['mot_cle']).'/';
$chemin = str_replace("//", "/", $chemin);
 
if(!isset($chemin_traites[self::harmoniserPourDoublon($chemin).'-'.$mot['id_utilisateur']])) {
$cle = $mot['id_mot_cle'].'-'.$mot['id_utilisateur'];
 
$mots_cles_hierarchiques[$cle] = array(
'id_utilisateur' => $mot['id_utilisateur'],
'chemin' => $chemin,
'mot_cle' => $mot['mot_cle']
);
$chemin_traites[self::harmoniserPourDoublon($chemin).'-'.$mot['id_utilisateur']] = 1;
} else {
$pbs['doublons'][self::harmoniserPourDoublon($chemin).'-'.$mot['id_utilisateur']] = $mot;
}
} else {
$pbs['vides'][] = $mot;
}
}
 
//echo '<pre>'.print_r($mots_cles_hierarchiques,true).'</pre>';exit;
return $mots_cles_hierarchiques;
}
 
static public function harmoniserPourDoublon($texte) {
$texte = htmlentities($texte, ENT_NOQUOTES, 'utf-8');
$texte = preg_replace('/&([A-za-z])(?:acute|cedil|circ|grave|orn|ring|slash|th|tilde|uml);/', '\1', $texte);
$texte = preg_replace('/&([A-za-z]{2})(?:lig);/', '\1', $texte); // pour les ligatures e.g. '&oelig;'
$texte = preg_replace('/&[^;]+;/', '', $texte); // supprime les autres caractères
 
return strtolower($texte);
}
 
static public function simplifier($text) {
// le slash est le seul caractère interdit dans les mots clés
return trim(str_replace(array('\\','/'), '', $text));
}
}