Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 1070 → Rev 1071

/branches/v1.5-cisaille/jrest/lib/ImageRecreation.php
1,28 → 1,28
<?php
Class ImageRecreation {
 
private $droits = 0705;
private $formats = array('CRX2S','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($config) {
$this->config = $config;
$this->mode = self::MODE_GD;
 
if (extension_loaded('imagick')) {
putenv('MAGICK_TEMPORARY_PATH='.$this->config['cel_db']['chemin_stockage_temp']);
$this->mode = self::MODE_IMAGEMAGICK;
}
}
 
public function recreerMiniaturesRecursivement() {
$this->itererRecursivement($this->config['cel_db']['chemin_images']);
}
 
public function regenererMiniaturesIntervalle($params) {
$id_debut = $params[0];
$id_fin = $params[1];
34,7 → 34,7
}
}
}
 
public function regenererMiniaturesPourId($params) {
$id = $params[0];
 
44,41 → 44,41
 
$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);
 
// creation de miniatures pour chacuns des formats définis
foreach($this->formats as $format) {
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
};
 
}
}
 
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 {
} 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);
86,12 → 86,12
}
}
}
 
public function creerMiniatureImageSelonFormat($infos_image_originale, $format = 'O') {
if ($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) {
102,70 → 102,70
} 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);
}
$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);
$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);
} else {
$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);
$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);
}
}
 
return $image_redimensionnee;
}
 
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'],
 
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)) {
 
if ($this->estPaysage($informations_image)) {
$debut_largeur_a_copier = 0 ;
$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;
$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 ;
$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']
173,21 → 173,21
 
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'];
 
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 {
194,71 → 194,73
$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,
 
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,
$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,
 
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 stockerFichierEtCreerMiniatures($fichier, $id) {
$chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O');
$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($fichier['tmp_name'], $chemin_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);
}
 
$infos_image_originale_stockee = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
 
$formats = $this->getFormats();
 
// creation de miniatures pour chacuns des formats définis
foreach($formats as $format) {
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale_stockee, $format);
}
 
return true ;
 
} else {
$erreur = 'ERROR : probleme durant le déplacement du fichier temporaire \n' ;
$this->logger('CEL_bugs',$erreur);
265,7 → 267,7
return false ;
}
}
 
public function stockerImageExterne($chemin_fichier_temp, $chemin_destination) {
if(is_uploaded_file($chemin_fichier_temp)) {
$deplacement = move_uploaded_file($chemin_fichier_temp, $chemin_destination);
272,13 → 274,13
} 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)) {
287,189 → 289,189
return false;
}
}
 
return $chemin_sur_serveur_final;
}
 
public function obtenirDossierPourFormat($id, $format) {
$chemin_base = $this->config['cel_db']['chemin_images'];
 
$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)) {
 
if (file_exists($chemin_fichier)) {
$image_et_infos = array();
list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);
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 (isset($this->config['cel_db']['format_'.$format])) {
list($dimensions['largeur'], $dimensions['hauteur']) = explode('_', $this->config['cel_db']['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);
return (strpos($format,'C') === 0);
}
 
public function estUnFormatRogne($format) {
return (strpos($format,'R') === 1);
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 = $this->config['cel_db']['taille_max'];
 
$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($image_a_stocker, $compression = 100) {
$image_a_stocker = new Imagick($image_a_stocker);
 
// l'utilisation d'image magick préserve les métadonnées lors d'une recompression
$image_a_stocker->setformat("jpeg");
$image_a_stocker->setImageCompression(imagick::COMPRESSION_JPEG);
$image_a_stocker->setImageCompression(imagick::COMPRESSION_JPEG);
$image_a_stocker->setCompressionQuality($compression);
$image_a_stocker->writeImage($image_a_stocker);
$image_a_stocker->destroy();
$image_a_stocker->destroy();
 
chmod($image_a_stocker,$this->droits);
}
 
public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) {
$image_blanche = imagecreatetruecolor($cote, $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) {
 
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 {
476,13 → 478,13
$destruction_formats_fichier = true;
}
}
 
return $destruction_formats_fichier;
}
/*
 
/*
* edge-maximizing crop
* determines center-of-edginess, then tries different-sized crops around it.
* 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
*
491,26 → 493,26
*/
public function opticrop($informations_image, $format) {
umask(0);
 
$nom_temp = md5(time());
$chemin_temp =
$chemin_temp =
 
$out = $this->config['cel_db']['chemin_stockage_temp'].'/'.$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
517,11 → 519,11
$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)
 
//echo("$chemin_image: $largeur_image_originale x $hauteur_image_originale => $largeur_vignette x $hauteur_vignette");
$img = new Imagick($chemin_image);
$imgcp = clone $img;
 
// compute center of edginess
$img->edgeImage($r);
$img->modulateImage(100,0,100); // grayscale
543,7 → 545,7
}
$xcenter /= $sum;
$ycenter /= $sum;
 
// crop source img to target AR
if ($largeur_image_originale/$hauteur_image_originale > $ar) {
// source AR wider than target
555,22 → 557,22
$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);
577,26 → 579,26
$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;
 
/*if (self::MODE_DEBUG) {
// debug
$currfile = '/home/aurelien/web/file_tmp/'."image$k.jpg";
 
$currimg = clone $img;
$c= new ImagickDraw();
$c->setFillColor("red");
$c->circle($xcenter, $ycenter, $xcenter, $ycenter+4);
$currimg->drawImage($c);
$c= new ImagickDraw();
$c->setFillColor("red");
$c->circle($xcenter, $ycenter, $xcenter, $ycenter+4);
$currimg->drawImage($c);
$currimg->cropImage($wcrop, $hcrop, $xcrop, $ycrop);
$currimg->writeImage($currfile);
$currimg->destroy();
}*/
 
$beta = 0;
for ($c=0; $c<$n; $c++) {
$i = mt_rand(0,$wcrop-1);
608,9 → 610,9
// 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;
619,7 → 621,7
// $maxfile = $currfile;
}
}
 
// return image
$imgcp->cropImage($maxparam['w'], $maxparam['h'], $maxparam['x'], $maxparam['y']);
$imgcp->scaleImage($largeur_vignette, $hauteur_vignette);
627,10 → 629,10
chmod($out, 0777);
$img->destroy();
$imgcp->destroy();
 
$image_sortie = ImageCreateFromJpeg($out);
unlink($out);
 
return $image_sortie;
}
}
/branches/v1.5-cisaille/jrest/lib/ExtracteurMetadonnees.php
1,6 → 1,6
<?php
/**
* Classe d'extraction de metadonnées afin de les mettre dans
* Classe d'extraction de metadonnées afin de les mettre dans
* un tableau au format du cel
* Encodage en entrée : utf8
* Encodage en sortie : utf8
14,244 → 14,231
 
public function extraireMetadonnees($chemin_fichier)
{
 
$iptc = $this->extraireIptc($chemin_fichier) ;
$exif = $this->extraireExif($chemin_fichier) ;
 
$meta = array_merge($exif,$iptc);
$this->initialiserSectionsSupplementaires(&$meta) ;
 
$this->initialiserSectionsSupplementaires($meta) ;
 
return $meta ;
}
 
/**
* Extraction des metadonnées exif
* Extraction des metadonnées exif
**/
public function extraireExif($chemin_fichier)
{
public function extraireExif($chemin_fichier) {
$exif_tab = $this->initialiserTableauExif () ;
$exif = @exif_read_data($chemin_fichier,"EXIF,COMPUTED,IFD0,FILE,COMMENT",true,false);
$exif = @exif_read_data($chemin_fichier,"EXIF,COMPUTED,IFD0,FILE,COMMENT", true, false);
 
if ($exif) {
foreach ($exif as $key => $section)
{
foreach ($section as $name => $val)
{
if ($name != "MakerNote")
{
$this->decoderValeurExif ($name, $val ,&$exif_tab) ;
foreach ($exif as $key => $section) {
foreach ($section as $name => $val) {
if ($name != "MakerNote") {
$this->decoderValeurExif($name, $val , $exif_tab);
}
}
}
}
return $exif_tab ;
return $exif_tab;
}
 
/**
* Extraction des metadonnées iptc
* Extraction des metadonnées iptc
**/
public function extraireIptc($chemin_fichier)
{
public function extraireIptc($chemin_fichier) {
$iptc_tab = $this->initialiserTableauIptc() ;
 
// geimagesize renvoie le infos iptc dans le tableau info
$size = getimagesize($chemin_fichier, $info);
// s'il existe
if (isset($info["APP13"]))
{
if (isset($info["APP13"])) {
// on parse les donnees
$iptc = iptcparse($info["APP13"]);
if ($iptc) {
// et on les analyse
foreach ($iptc as $marker => $section)
{
foreach ($section as $nom => $val)
{
foreach ($iptc as $marker => $section) {
foreach ($section as $nom => $val) {
// pour remplir le tableau de donnees
$this->decoderValeurIptc($marker, $val ,&$iptc_tab) ;
$this->decoderValeurIptc($marker, $val, $iptc_tab);
}
}
}
}
return $iptc_tab ;
 
return $iptc_tab;
}
 
/**
* Stocke une valeur de metadonnées exif dans le champ du tableau correspondant
* @param String $nom nom de la valeur
* @param String $val valeur
* @param String $data référence vers le tableau où la donnée sera stockée
* @param String $data référence vers le tableau où la donnée sera stockée
**/
private function decoderValeurExif($nom, $val ,$data_tab)
{
switch ($nom)
{
private function decoderValeurExif($nom, $val, &$data_tab) {
switch ($nom) {
case "Height" :
$data_tab['ci_meta_height'] = $val ;
break ;
 
case "Width" :
$data_tab['ci_meta_width'] = $val ;
break ;
 
case "Make" :
$data_tab['ci_meta_make'] = $val ;
break ;
 
case "Model" :
$data_tab['ci_meta_model'] = $val ;
break ;
 
case "XResolution" :
$data_tab['ci_meta_x_resolution'] = $val ;
break ;
 
case "YResolution" :
$data_tab['ci_meta_y_resolution'] = $val ;
break ;
break ;
 
case "DateTimeOriginal" :
$data_tab['ci_meta_date_time'] = $val ;
break ;
 
case "GPS" :
$data_tab['ci_meta_gps'] = $val ;
break ;
 
case "UserComment" :
$data_tab['ci_meta_user_comment'] = '"'.$val.'"' ;
break ;
 
case "ExposureTime" :
$data_tab['ci_meta_exif_exposure_time'] = $val ;
break ;
 
case "FNumber" :
$data_tab['ci_meta_exif_f_number'] = $val ;
break ;
 
case "ExifVersion" :
$data_tab['ci_meta_exif_exif_version'] = $val ;
break ;
 
case "CompressedBitsPerPixel" :
$data_tab['ci_meta_exif_compressed_bits_per_pixel'] = $val ;
break ;
 
case "ShutterSpeedValue" :
$data_tab['ci_meta_exif_shutter_speed_value'] = $val ;
break ;
 
case "ApertureValue" :
$data_tab['ci_meta_exif_aperture_value'] = $val ;
break ;
 
case "ExposureBiasValue" :
$data_tab['ci_meta_exif_exposure_bias_value'] = $val ;
break ;
 
case "MaxApertureValue" :
$data_tab['ci_meta_exif_max_aperture_value'] = $val ;
break ;
 
case "MeteringMode" :
$data_tab['ci_meta_exif_metering_mode'] = $val ;
break ;
 
case "LightSource" :
$data_tab['ci_meta_exif_light_source'] = $val ;
break ;
 
case "Flash" :
$data_tab['ci_meta_exif_flash'] = $val ;
break ;
 
case "FocalLength" :
$data_tab['ci_meta_exif_focal_length'] = $val ;
break ;
 
case "FlashpixVersion" :
$data_tab['ci_meta_exif_flash_pix_version'] = $val ;
break ;
 
case "ColorSpace" :
$data_tab['ci_meta_exif_color_space'] = $val ;
break ;
 
case "InteroperabilityOffset" :
$data_tab['ci_meta_exif_interoperability_offset'] = $val ;
break ;
 
case "FocalPlaneXResolution" :
$data_tab['ci_meta_exif_focal_plane_x_resolution'] = $val ;
break ;
 
case "FocalPlaneYResolution" :
$data_tab['ci_meta_exif_focal_plane_y_resolution'] = $val ;
break ;
 
case "FocalPlaneResolutionUnit" :
$data_tab['ci_meta_exif_focal_plane_resolution_unit'] = $val ;
break ;
 
case "SensingMethod" :
$data_tab['ci_meta_exif_sensing_method'] = $val ;
break ;
 
case "FileSource" :
$data_tab['ci_meta_exif_file_source'] = $val ;
break ;
 
case "CustomRendered" :
$data_tab['ci_meta_exif_custom_rendered'] = $val ;
break ;
 
case "ExposureMode" :
$data_tab['ci_meta_exif_exposure_mode'] = $val ;
break ;
 
case "WhiteBalance" :
$data_tab['ci_meta_exif_white_balance'] = $val ;
break ;
 
case "DigitalZoomRatio" :
$data_tab['ci_meta_exif_digital_zoom_ratio'] = $val ;
break ;
 
case "SceneCaptureType" :
$data_tab['ci_meta_exif_scene_capture_type'] = $val ;
break ;
 
case "GainControl" :
$data_tab['ci_meta_exif_gain_control'] = $val ;
break ;
 
case "Contrast" :
$data_tab['ci_meta_exif_contrast'] = $val ;
break ;
 
case "Saturation" :
$data_tab['ci_meta_exif_saturation'] = $val ;
break ;
 
case "Sharpness" :
$data_tab['ci_meta_exif_sharpness'] = $val ;
break ;
 
case "SubjectDistanceRange" :
$data_tab['ci_meta_exif_subject_distance_range'] = $val ;
break ;
 
default :
$data_tab['ci_meta_exif_autres'] .= $nom.":".$val.";" ;
}
}
}
 
/**
* Stocke une valeur de metadonnées iptc dans le champ du tableau correspondant
* @param String $nom nom de la valeur
258,222 → 245,217
* @param String $val valeur
* @param String $data référence vers le tableau où la donnée sera stockée
**/
private function decoderValeurIptc($nom, $val ,$data_tab)
{
switch($nom)
{
private function decoderValeurIptc($nom, $val, &$data_tab) {
switch($nom) {
// mots cles iptc
case "2#005" :
$data_tab['ci_meta_iptc_category'] = $val ;
break;
 
case "2#025" :
$data_tab['ci_meta_iptc_mots_cles'] = $val ;
break;
 
// champ by line
case "2#080" :
$data_tab['ci_meta_iptc_by_line'] = $val ;
break ;
 
// champ by line titre
case "2#085" :
$data_tab['ci_meta_iptc_by_line_title'] = $val ;
break ;
 
// ville
case "2#090" :
$data_tab['ci_meta_iptc_city'] = $val ;
break ;
 
// sous location
case "2#092" :
$data_tab['ci_meta_iptc_sub_location'] = $val ;
break ;
 
// etat (pour les us)
case "2#095" :
$data_tab['ci_meta_iptc_province_state'] = $val ;
break ;
 
// code pays
case "2#100" :
$data_tab['ci_meta_iptc_country_primary_location_code'] = $val ;
break ;
 
// code pays
case "2#101" :
$data_tab['ci_meta_iptc_country_name'] = $val ;
break ;
 
// titre principal
case "2#105" :
$data_tab['ci_meta_iptc_headline'] = $val ;
break ;
 
// credit
case "2#110" :
$data_tab['ci_meta_iptc_credit'] = $val ;
break ;
 
// copyright
case "2#116" :
$data_tab['ci_meta_iptc_copyright_notice'] = $val ;
break ;
 
// contact
case "2#118" :
$data_tab['ci_meta_iptc_contact'] = $val ;
break ;
 
// autres (pour les champs qu'on ne prend pas en compte)
default :
$data_tab['ci_meta_iptc_autres'] .= $nom.":".$val.";" ;
}
}
 
/**
* Crée le tableau vide pour stocker les iptc pour le ce
*
*
* @return array $data_tab référence vers le tableau où la donnée sera stockée
*
*
**/
private function initialiserTableauIptc()
{
private function initialiserTableauIptc() {
$data_tab = array() ;
 
$data_tab['ci_meta_iptc_category'] = NULL ;
 
$data_tab['ci_meta_iptc_mots_cles'] = NULL ;
 
$data_tab['ci_meta_iptc_by_line'] = NULL ;
 
$data_tab['ci_meta_iptc_by_line_title'] = NULL ;
 
$data_tab['ci_meta_iptc_city'] = NULL ;
 
$data_tab['ci_meta_iptc_sub_location'] = NULL ;
 
$data_tab['ci_meta_iptc_province_state'] = NULL ;
 
$data_tab['ci_meta_iptc_country_primary_location_code'] = NULL ;
 
$data_tab['ci_meta_iptc_country_name'] = NULL ;
 
$data_tab['ci_meta_iptc_headline'] = NULL ;
 
$data_tab['ci_meta_iptc_credit'] = NULL ;
 
$data_tab['ci_meta_iptc_copyright_notice'] = NULL ;
 
$data_tab['ci_meta_iptc_contact'] = NULL ;
$data_tab['ci_meta_iptc_autres'] .= " " ;
return $data_tab ;
 
$data_tab['ci_meta_iptc_autres'] = " ";
 
return $data_tab ;
}
 
/**
* Crée le tableau vide pour stocker les exifs pour le cel
*
*
* @return array $data_tab référence vers le tableau où la donnée sera stockée
*
*
**/
private function initialiserTableauExif()
{
private function initialiserTableauExif() {
$data_tab = array() ;
 
$data_tab['ci_meta_height'] = 0 ;
 
$data_tab['ci_meta_width'] = 0 ;
 
$data_tab['ci_meta_make'] = NULL ;
 
$data_tab['ci_meta_model'] = NULL ;
 
$data_tab['ci_meta_x_resolution'] = NULL ;
 
$data_tab['ci_meta_y_resolution'] = NULL ;
 
$data_tab['ci_meta_date_time'] = NULL ;
 
$data_tab['ci_meta_gps'] = NULL ;
 
$data_tab['ci_meta_user_comment'] = NULL ;
 
$data_tab['ci_meta_exif_exposure_time'] = NULL ;
 
$data_tab['ci_meta_exif_f_number'] = NULL ;
 
$data_tab['ci_meta_exif_exif_version'] = NULL ;
 
$data_tab['ci_meta_exif_compressed_bits_per_pixel'] = NULL ;
 
$data_tab['ci_meta_exif_shutter_speed_value'] = NULL ;
 
$data_tab['ci_meta_exif_aperture_value'] = NULL ;
 
$data_tab['ci_meta_exif_exposure_bias_value'] = NULL ;
 
$data_tab['ci_meta_exif_max_aperture_value'] = NULL ;
 
$data_tab['ci_meta_exif_metering_mode'] = NULL ;
 
$data_tab['ci_meta_exif_flash'] = NULL ;
 
$data_tab['ci_meta_exif_light_source'] = NULL ;
 
$data_tab['ci_meta_exif_focal_length'] = NULL ;
 
$data_tab['ci_meta_exif_flash_pix_version'] = NULL ;
 
$data_tab['ci_meta_exif_color_space'] = NULL ;
 
$data_tab['ci_meta_exif_interoperability_offset'] = NULL ;
 
$data_tab['ci_meta_exif_focal_plane_x_resolution'] = NULL ;
 
$data_tab['ci_meta_exif_focal_plane_y_resolution'] = NULL ;
 
$data_tab['ci_meta_exif_focal_plane_resolution_unit'] = NULL ;
 
$data_tab['ci_meta_exif_sensing_method'] = NULL ;
 
$data_tab['ci_meta_exif_file_source'] = NULL ;
 
$data_tab['ci_meta_exif_custom_rendered'] = NULL ;
 
$data_tab['ci_meta_exif_exposure_mode'] = NULL ;
$data_tab['ci_meta_exif_white_balance'] = NULL ;
 
$data_tab['ci_meta_exif_white_balance'] = NULL ;
 
$data_tab['ci_meta_exif_digital_zoom_ratio'] = NULL ;
 
$data_tab['ci_meta_exif_scene_capture_type'] = NULL ;
 
$data_tab['ci_meta_exif_gain_control'] = NULL ;
 
$data_tab['ci_meta_exif_contrast'] = NULL ;
 
$data_tab['ci_meta_exif_saturation'] = NULL ;
 
$data_tab['ci_meta_exif_sharpness'] = NULL ;
 
$data_tab['ci_meta_exif_subject_distance_range'] = NULL ;
$data_tab['ci_meta_exif_autres'] .= " " ;
return $data_tab ;
 
$data_tab['ci_meta_exif_autres'] = " ";
 
return $data_tab ;
}
 
/**
* Crée le tableau vide pour stocker les section supplémentaires pour le cel
*
*
* @return array $tab référence vers le tableau de metadonnées
*
*
**/
private function InitialiserSectionsSupplementaires($tab)
{
private function InitialiserSectionsSupplementaires(&$tab) {
$tab['ci_meta_exif_autres'] .= " " ;
$tab['ci_meta_iptc_autres'] .= " " ;
$tab['ci_nom_original'] = NULL ;