Balise #EXIF : récupérer les informations stockées dans les images.

But

Avec le nouveau compilo, on peut créer des balises personnalisées. Sur la liste des utilisateurs, il y a eu une demande pour intégrer la lecture des metadata EXIF dans les fichiers jpg. Ces données permettent d’obtenir des informations sur le fichiers jpg (souvent annotée par les appareils photo digitaux) comme l’heure de prise de la photo, des commentaires, un copyright, etc...

Le code présenté ici doit être placé dans votre fichier mes_fonctions.php3.

php fournit une fonction pour accéder à ces données. On va commencer par coder deux petits wrappers pour l’utiliser simplement dans spip :

function verifier_JPG_TIFF($id_document) {
  	if ($id_document > 0) {
		$query = "SELECT id_type FROM spip_documents WHERE id_document = $id_document";
		$result = spip_query($query);
		if ($row = spip_fetch_array($result)) {
			$id_type = $row['id_type'];
		}
	}
	return (($id_type==1) || ($id_type==6));
}

function tag_exif($url_document,$section='',$tag='') {
  $to_ret = '';

  static $last_url;
  static $last_exif;

  if($last_url == $url_document) {
	$exif = $last_exif;
  } else {
	$exif = $last_exif =  @exif_read_data($url_document, 0, true);
	$last_url = $url_document;
  }

  if($exif) {
	if(($section != '') && ($tag != '')) {
	  $to_ret = $exif[$section][$tag];
	} else if($section) {
	  if($exif[$section]) {
		foreach ($exif[$section] as $name => $val) {
		  $to_ret .= "<B>$section.$name</B>: $val<br />\n";
		}
	  }
	} else {
	  foreach ($exif as $key => $section) {
		foreach ($section as $name => $val) {
		  $to_ret .= "<B>$key.$name</B>: $val<br />\n";
		}
	  }
	}
  }
  return $to_ret;
}

-  La première fonction teste si un fichier peut contenir des tags EXIF (à la base, si c’est un fichier jpg ou tiff)
-  La deuxième retourne un champ dans les metadata. On y accède en passant une section et un tag qui nous intéresse dans cette section. Si on ne donne pas de section et de tag, alors la fonction retourne une liste de tous les tags existant dans le fichier [1].

La balise

On va donc déclarer une nouvelle balise #EXIF qui retourne les metadata. Commençons par une version simple de cette balise :

function balise_EXIF($params) {

  $id_doc = champ_sql('id_document', $params);

  $params->code = "(verifier_JPG_TIFF($id_doc))?(tag_exif(generer_url_document($id_doc),'$section','$tag')):''";
  $params->type = 'php';  

  return $params;
}

Cette balise, en appelant tag_exif sans paramètres section et tag, va retourner une liste de tous les tags EXIF existants.

Avant tout, il nous faut récupérer le nom de fichier du document qui nous intéresse. Mais pour cela, on a besoin de l’ID du document. Le paramètre $param nous permet d’aller récupérer cette information. SPIP fournit une fonction pour simplifier la tâche : champ_sql retourne le code qui va nous donner la valeur d’id_document.

En fait, champ_sql est un raccourci pour index_pile :

index_pile retourne la position dans la pile du champ SQL $nom_champ en prenant la boucle la plus proche du sommet de pile (indique par $idb). Si on ne trouve rien, on considère que ça doit provenir du contexte (par l’URL ou l’include) qui a été recopié dans Pile[0] (un essai d’affinage a debouché sur un bug vicieux). Si ca référence un champ SQL, on le mémorise dans la structure $boucles afin de construire un requête SQL minimale (plutot qu’un brutal ’SELECT *’)

champ_sql va utiliser $param pour déduire « la boucle la plus proche », le 2^e paramètre spécifie que l’on veut récupérer le champ 'id_document'

Le code que l’on veut exécuter pour cette balise ne doit pas être exécuté maintenant, mais dans le cache. Il faut donc retourner une chaîne contenant le code que l’on veut exécuter : "(verifier_JPG_TIFF($id_doc))?(tag_exif(generer_url_document($id_doc))):''"

Il faut aussi specifier à spip qu’on retourne du code php à executer — contrairement à du code html brut — en mettant : $params->type = 'php';

Passer des paramètres

Bon, il est clair que cette balise n’est pas très intéressante. En général, on n’a pas besoin de toutes les informations, mais d’une seule à la fois. Au lieu de créer plein de balises pour chacun des champs EXIF — qui ne sont pas toujours fixes —, on va passer la section et le tag EXIF que l’on veut récupérer comme paramètres à la balise.

Depuis la version 1.8 [2], SPIP fournis une fonction simple pour récupérer des paramètres passés à une balise. Cette fonction est utilisée dans le code suivant, pour une méthode plus archaïque (à la #EXPOSER|on,off), inspirez vous du code des LOGO expliqué plus bas.

Nous allons utiliser la même méthode pour passer les deux paramètres à notre balise EXIF, on pourra alors faire : #EXIF{FILE,FileName} ou #EXIF{IFD0,DateTime} par exemple.

Voici le nouveau code :

function balise_EXIF($params) {

  list($section,$tag) = split(',',param_balise($params));

  $section = addslashes($section);
  $tag = addslashes($tag);
  
  $id_doc = champ_sql('id_document', $params);

  $params->code = "(verifier_JPG_TIFF($id_doc))?(tag_exif(generer_url_document($id_doc),'$section','$tag')):''";
  $params->type = 'php';
  
  return $params;
}

Il n’y pas beaucoup de différence dans le code retourné. Par contre, on va récupérer, si ils sont donnés, les paramètres $section et $tag pour les passer à tag_exif.

On parcourt la liste de filtres donnée dans params->fonctions pour trouver celui qui correspond aux paramètres. On enlève ensuite ce filtre de la liste et on extrait les paramètres du nom du filtre.

Une balise LOGO

Dans l’entête EXIF d’une image jpeg, il y a — souvent — une vignette de l’image contenue dans le fichier. Cette vignette est utilisée par les appareils photo pour rapidement afficher la photo sur son écran. Evidemment, cette vignette n’est pas de superbe qualité, mais c’est une bonne occasion de voir comment faire une balise LOGO. En plus, si on n’a ni GD, ni imagemagick sur son serveur, ça peut être utile :)

Commençons par deux petites fonctions :
-  generer_url_logo_EXIF cherche le logo exif — contenu dans le fichier nom_fichier.exif.jpg si celle-ci a déjà été extraire, sinon, il extrait la vignette pour la stocker dans un fichier sur le serveur. Dans les deux cas, il retourne le chemin vers ce fichier.
-  generer_html_logo_EXIF génére le code html du logo, avec un lien ou pas, et un alignement ou pas.

function generer_url_logo_EXIF($filename) {

  $thumbname = substr($filename,0,-4).".exif.jpg";

  if(file_exists($thumbname)) {
	return $thumbname;
  }

  $image = exif_thumbnail($filename);
  if ($image!==false) {
	$handle = fopen ($thumbname, 'a');
	fwrite($handle, $image);
	fclose($handle);
	return $thumbname;
  }
  
  return '';

}

function generer_html_logo_EXIF($url_doc,$code_lien='',$align='') {
   if(!$url_doc)
            return '';
  if($code_lien) {
	$code = "<a href=\"$code_lien\">";
  }

  $code .= "<IMG src=\"$url_doc\"".(($align)?"align=$align":'').">";
  if($code_lien) {
	$code .= "</a>";
  }

  return $code;
}

Regardons maintenant comment faire pour gérer un LOGO. Le plus gros problème est en fait la gestion des filtres spéciaux d’alignement etc...

Le principe est le même que pour le code précédent. On regarde la liste des fonctions pour voir ce qu’on y trouve. On peut soit y trouver une indication d’alignement, soit fichier (pour afficher l’url du fichier), soit un lien à mettre sur le logo.

La première partie du code étudie les filtres contenus dans le tableau $p->fonctions.
Ensuite, on regarde si on a besoin de générer du code pour le lien, c’est là qu’il y a un intérêt : on peut passer comme lien, une autre balise (par exemple : [(#LOGO_EXIF|#URL_DOCUMENT)]).

On appelle donc la fonction calculer_champ sur la potentielle balise, c’est la fonction de base qui calcule toutes les balises pour SPIP.

function balise_LOGO_EXIF($p) {

  // analyser les filtres
  $flag_fichier = false;
  $filtres = '';
  if (is_array($p->fonctions)) {
	foreach($p->fonctions as $nom) {
	  if (ereg('^(left|right|center|top|bottom)$', $nom))
		$align = $nom;
	  else if ($nom == 'lien') {
		$flag_lien_auto = true;
		$flag_stop = true;
	  }
	  else if ($nom == 'fichier') {
		$flag_fichier = true;
		$flag_stop = true;
	  }
	  // double || signifie "on passe aux filtres"
	  else if ($nom == '')
		$flag_stop = true;
	  else if (!$flag_stop) {
		$lien = $nom;
		$flag_stop = true;
	  }
	  // apres un URL ou || ou |fichier ce sont
	  // des filtres (sauf left...lien...fichier)
	  else
		$filtres[] = $nom;
	}
	// recuperer les autres filtres s'il y en a
	$p->fonctions = $filtres;
  }

  $id_doc = champ_sql('id_document', $p);
  $code_lien = '';

  $url_doc = "(verifier_JPG_TIFF($id_doc))?(generer_url_logo_EXIF(generer_url_document($id_doc))):''";

  //
	// Preparer le code du lien
	//
	// 1. filtre |lien
  if ($flag_lien_auto AND !$lien) {
	 $code_lien = "$url_doc";
  } else if ($lien) {
		// 2. lien indique en clair (avec des balises : imprimer#ID_ARTICLE.html)

		$code_lien = "'".texte_script(trim($lien))."'";
		while (ereg("^([^#]*)#([A-Za-z_]+)(.*)$", $code_lien, $match)) {
			$c = calculer_champ(array(), $match[2], $p->id_boucle, $p->boucles, $p->id_mere);
			$code_lien = str_replace('#'.$match[2], "'.".$c.".'", $code_lien);
		}
		// supprimer les '' disgracieux
		$code_lien = ereg_replace("^''\.|\.''$", "", $code_lien);
	}

  if($flag_fichier) {
	$p->code = "ereg_replace(\"^IMG/\",\"\",$url_doc)";
	$p->type = 'php';
	return $p;
  }

  if(!$code_lien)
	$code_lien = "''";

  
  if(!$align)
	$align = "''";

  $p->code = "generer_html_logo_EXIF($url_doc,$code_lien,$align)";
  $p->type = 'php';
  return $p;
}

Un filtre pour les dates

Les dates stockées dans les images sont sous un format différent de celui utilisé par SPIP, ainsi on ne peut pas directement utiliser les filtres fournis par SPIP.
Voici donc un filtre à appliquer avant les filtres de date SPIP pour que tout marche bien :

function date_EXIF2SPIP($date) {
  return preg_replace('/^([0-9]*):([0-9]*):([0-9]*) /','\1-\2-\3 ',$date);
}

Exemple d’utilisation

Voici une boucle qui affiche les documents d’un article en liste avec un certain nombre d’informations contenue dans les champs EXIF :

<B_jpg>
<ul>
<BOUCLE_jpg(DOCUMENTS) {id_article} {mode=document} {extension=jpg}>
<li>
#LOGO_DOCUMENT
<ul>
[<li>Model: (#EXIF{IFD0,Make})
[(#EXIF{IFD0,Model})]</li>]
[<li>Date: (#EXIF{EXIF,DateTimeOriginal}|date_EXIF2SPIP|sinon{#DATE}|affdate)
[(#EXIF{EXIF,DateTimeOriginal}|date_EXIF2SPIP|sinon{#DATE}|affdate{H\hm})]</li>]
[<li>Commentaire: (#EXIF{COMMENT,0}|sinon{#DESCRIPTIF})</li>]

[<li>ISO:(#EXIF{EXIF,ISOSpeedRatings})</li>]
[<li>Temps d'exposition: (#EXIF{EXIF,ExposureTime})</li>]
</ul>
</li>
</BOUCLE_jpg>
</ul>
</B_jpg>

Version de développement

Cette contrib est gérée sur spip-zone, on peut récupérer la dernière version de développement grâce à :

svn checkout svn://zone.spip.org/spip-zone/_contrib_/_balises_/exif/trunk/