# # XML_node.objet # # This object is an XML node representation # # /- name (string) # xml_node --- attributes (array) # \- children (array) or value (string) class xml_node { public $name; public $attributes = array(); public $children = array(); public $value = ""; public function xml_node($name,$attributes,$children=array(),$value="") { $this->name = $name; if (is_array($attributes)) { $this->attributes = $attributes; } $this->children = $children; $this->value = $value; } } # # xml_tree class # # This object parses an XML stream and offers a tree composed by xml_nodes # class xml_tree { private $xml_stream; public $current_node; protected $root_node; private $index; private $value; public function xml_tree() { $this->root_node = new xml_node("__ROOT_NODE",array()); $this->current_node = $this->root_node; } public function add_tree($xml_stream) { # Managing the parser $this->xml_stream = $xml_stream; $xml_parser = xml_parser_create(); xml_parser_set_option($xml_parser,XML_OPTION_CASE_FOLDING,0); xml_parser_set_option($xml_parser,XML_OPTION_SKIP_WHITE,1); if (!xml_parse_into_struct($xml_parser,$this->xml_stream,$this->value,$this->index)) { xml_parser_free($xml_parser); die("XML Parse error"); } xml_parser_free($xml_parser); # Now, $this->value and $this->index are informed, we can use the get_node methode. $tab_result = $this->get_node(0,count($this->value) - 1); $this->root_node->children[] = $tab_result[0]; $this->current_node = $this->root_node; } protected function get_node($index_start,$index_stop) { #echo "
\n"; #echo "GET-NODE($index_start,$index_stop)
\n"; # What we are going to return is an array of xml_nodes $return_tab = array(); # depth is only here to check if everything is all right $tab_node = $this->value[$index_start]; $depth = $tab_node["level"]-1; # Now we have to be sure we do not forget a single node for ($index = $index_start;$index <= $index_stop;$index++) { #echo "\$index = $index
"; # get the current node $tab_node = $this->value[$index]; # what type of node is it ? switch($tab_node["type"]) { case "complete" : # Depth integrity check if ($tab_node["level"] != $depth+1) { die("ERREUR # contrainte d'intégrité au noeud complet $index, niveau $depth + 1 au lieu de ".$tab_node["level"]); } #echo "Noeud complet trouvé position $index TAG ".$tab_node["tag"]."
\n"; # Easy one, no children to manage, only a value... $return_tab[] = new xml_node($tab_node["tag"],$tab_node["attributes"],"",$tab_node["value"]); break; case "open" : # Depth integrity check if ($tab_node["level"] != $depth +1 ) { die("ERREUR # contrainte d'intégrité au noeud ouvert $index, niveau $depth au lieu de ".$tab_node["level"]); } # Open tag, we re-use this methode to return its children # Where is the correspondong close tag ? $node_index = $this->index[$tab_node["tag"]]; $flipped_node_index = array_flip($node_index); #echo "This ".$tab_node["tag"]." is at coords ".$flipped_node_index[$index]."
"; $i=1; do { $next_index = $node_index[$flipped_node_index[$index] + $i++]; $next_tag=$this->value[$next_index]; } while ($next_tag["level"]!=$tab_node["level"]); #echo "Ouverture de noeud détectée pos $index TAG ".$tab_node["tag"]."
\n   Parcours jusqu au $next_index
\n"; # good, we can now instanciate our node $return_tab[] = new xml_node($tab_node["tag"],$tab_node["attributes"],$this->get_node($index+1,$next_index),""); # As we called the get_node methode, we are sure that nodes have been parsed to the corresponding close tag $index = $next_index; break; case "close" : # Depth integrity check if ($tab_node["level"] != $depth ){ die("ERREUR # contrainte d'intégrité au noeud fermé $index, niveau $depth au lieu de ".$tab_node["level"]); } #echo "Fermeture de noeud detectée pos $index TAG ".$tab_node["tag"]."

\n"; # This ugly thing is useless because reaching a close tag means that $index==$index_stop but who knows ? =) # it will be skipped soon $index = $index_stop; break; default: die("Erreur de type de TAG non déterminé :'".$tab_node["type"]."'"); } } # We are out ... returns the array with collected children... return ($return_tab); } # this function browse the xml tree and set the current node to the selected node public function give_node($path) { if ($path[0]=="/") { $current_node=$this->root_node; $path=substr($path,1); #echo "ABSOLUTE PATH GIVEN=$path
"; } else { $current_node = $this->current_node; } #echo "PATH GIVEN=$path
"; $tab_path = split("/",$path); foreach ($tab_path as $node_expr) { #echo "STUDYING EXPR='$node_expr'
"; $node = $current_node; $expr_tab = split("\?",$node_expr); $node_name = $expr_tab[0]; $attr_tab = 0; if (count($expr_tab)>1) { ##echo "TROUVE AU MOINS UNE CONDITION SUR LES ATTRIBUTS...
"; $attr_expr_tab=split(",",$expr_tab[1]); $attr_tab=array(); foreach($attr_expr_tab as $attr_expr) { $attr_split_expr=split("=",$attr_expr); $attr_tab[$attr_split_expr[0]]=$attr_split_expr[1]; } } $last=0; foreach ($node->children as $children) { #echo "COMPARING WITH '$children->name'
"; if ($children->name == $node_name) { ##echo "TROUVE NOEUD CORRESPONDANT $node_name
"; if (is_array($attr_tab)) { $node_attributes = $children->attributes; foreach ($attr_tab as $key=>$value) { if ($node_attributes[$key] == $value) { #echo "ATTRIBUTE & CHANGE CURRENT NODE TO ".$children->name."
"; $current_node = $children; $last = 1; } } } else { ##echo "CHILD=".$children->name."
"; #echo "CHANGE CURRENT NODE TO ".$children->name."
"; $current_node = $children; $last=1; } } if ($last) { break; } } if (!$last) { #echo "PATH ERROR $node_name
"; #die("MMmmmh It seems that this file is not a DIA XML format...sorry..."); return 0; } } return $current_node; } public function browse_tree($path) { $node = $this->give_node($path); if (is_object($node)) { $this->current_node = $node; return 1; } return 0; } # this method dumps an html representation of the xml tree public function xml_show($node = "",$level=0,$last=0) { if ($node=="") { $node=$this->root_node; } if (!is_object($node)) { die("ERROR : node is not an object"); } $line=""; for($i=1;$i<=$level;$i++) { if ((i==$level-1) and ($last)) { $line.="      "; } else { $line.="     |"; } if ($i==$level) { $line.="`-"; } } $line.=$node->name; #echo $line; $line.="".count($node->children).""; if (count($node->children)==1) { $line.=" (".$node->value.")
\n"; echo "$line"; } else { $line.="
\n"; echo "$line"; $i=1; foreach($node->children as $children) { if ($i==count($node->children)) { $this->xml_show($children,$level+1,1); } else { $this->xml_show($children,$level+1); } $i++; } } } #END_CLASS } Les indices de luminance - Artefact Photographie
 

Outils

Delicious Sauvegarder sur Delicious

Facebook Partager sur Facebook

Digg Envoyer sur Digg

Technorati Ajouter à Technorati

StumbleUpon Ajouter à StumbleUpon

Tutoriaux Vous êtes ici :   Accueil   >   Dossiers   >   Tutoriaux

Les indices de luminance

08/12/08 - 22:18 - ou IL, ou encore EV en anglais

Introduction


De la même manière que la température de couleur, sujet que j’ai abordé dans un précédent tutorial, le sujet des « IL » est la source de nombreuses interrogations.
Ne pouvant pas répondre de la façon aussi sérieuse que j’aurais voulu, je me suis penché sur la question, et je vous livre ici le résultat de mes recherches et de mes réflexions, largement alimentées par l’immense base de connaissance que constitue Internet. Vous l’aurez compris, je suis entièrement responsable de la moindre erreur ou inexactitude présente dans ce document.
Pour commencer doucement, sachez d’abord que le terme « IL » qui signifie Indice de Luminance (ou de Lumination) est strictement équivalent au terme anglophone « EV » qui signifie Exposure Value. A toute fin utile, je vous rappelle que la grandeur physique à laquelle est sensible votre capteur numérique ou votre pellicule est la luminance.


Quelques bases

 

Pour bien comprendre ce qu’est un IL, il faut d’abord savoir que les vitesses d’obturation d’un rideau et les ouvertures possibles d’un diaphragme sont « normalisées ». En effet, si l’on s’intéresse aux vitesses d’obturation, on remarque que l’on passe d’une vitesse entière à la suivante en divisant grosso modo par 2 la valeur de la première vitesse ; ainsi, nous obtenons la suite suivante, 1 seconde correspondant à la première vitesse : 1 s, 1/2 s, 1/4 s, 1/8 s, 1/15 s, 1/30 s, 1/60 s, 1/125 s, 1/250 s, etc...

La quantité de lumière qui arrive sur la pellicule de votre appareil est donc multipliée par 2 ou divisée par 2 à chaque « cran de vitesse ».
De même, si l’on s’intéresse aux ouvertures d’un diaphragme, on remarque (plus difficilement, je vous le concède) que l’on passe d’une ouverture entière à la suivante en multipliant par 2 soit 1.4, la valeur de la première ouverture ; ainsi, nous obtenons la suite suivante, 1 correspondant à la première valeur d’ouverture : 1, 1.4, 2, 2.8, 4, 5.6, 8, 11, 16, 22, 32, etc… Ainsi,

La quantité de lumière qui arrive sur la pellicule de votre appareil est donc multipliée par 2 ou divisée par 2 à chaque « cran d’ouverture ».
Je laisse volontairement tomber les vitesses et ouvertures intermédiaires qui compliquent inutilement la question de la signification des IL (sur la plupart des boîtiers et objectifs « actuels », le photographe a la possibilité de régler sa vitesse ou son ouverture en jouant sur des moitiés voire des tiers de valeur).

 

Constance de l'exposition

 

De ce fait, vous serez tous d’accord que l’exposition, c'est-à-dire la quantité de lumière reçue par la pellicule, est la même que l’on prenne une photo au 1/250 s avec une ouverture à 2.8 ou que l’on prenne une photo au 1/15 s avec une ouverture à 11… On multiplie par 16 la durée d’exposition mais, de l’autre côté, on divise par 16 la quantité de lumière qui passe par l’ouverture entre 2.8 et 11.
Attention, l’exposition est strictement identique mais la photo peut être et sera sûrement très différente : si vous photographiez une danseuse au 1/250 s, il y a de grande chance que celle-ci soit nette mais pas au 1/15 s… La profondeur de champ ne sera pas non plus la même entre une ouverture à 2.8 et une ouverture à 11.
La notion d’IL permet de traduire la constance de l’exposition en fonction du couple (vitesse, ouverture).
Le principe est de passer les vitesses et les ouvertures en échelle logarithmique (je reviendrai sur cette question plus loin pour les plus courageux)...
Pour faire simple, on associe la valeur 0 à l’ouverture 1, 1 à l’ouverture 1.4, 2 à l’ouverture 2, 3 à l’ouverture 2.8 et ainsi de suite...
On fait de même pour les vitesses : on associe la valeur 0 à la durée 1 s, 1 à la durée 1/2 s, 2 à la durée 1/4 s, 3 à la durée 1/8 s et ainsi de suite...


Une fois cette correspondance mathématique établie, l’indice de luminance est obtenu à partir de la formule simple suivante :

IL = TV + AV

en notant TV la vitesse d’obturation, AV la valeur de l’ouverture et IL désignant l’indice de luminance qui est donc simplement l’addition de la vitesse et de l’ouverture (une fois la correspondance décrite ci-dessus établie).

 

Le tableau suivant résume en quelques lignes et quelques colonnes mes propos précédents :

 

Tableau des IL

 

Pour reprendre mon exemple précédent, le couple (1/250 s, 2.8) pointe sur un IL=11 de même que le couple (1/15 s, 11).
Le tableau ci-dessus donne les indices de luminance pour une sensibilité de 100 ISO. Les valeurs sont bien entendues différentes si la sensibilité choisie est, par exemple, égale à 200 ISO, auquel cas, il faut ajouter 1 aux valeurs des IL (rajouter 2 si 400 ISO, etc…).

 

Remarques

 

On note que plus l’IL est petit, plus la quantité de lumière reçue est importante et inversement.
D’autre part, et notamment en photo de studio, quand on parle d'ouvrir le diaphragme d’un cran, ou d'ouvrir le diaphragme d’un IL, on dit strictement la même chose : puisque la vitesse d’obturation est fixe en studio, faire +1 ou – 1 IL impose de modifier son ouverture d’un cran en plus ou en moins.
Il est tout à fait possible de « rencontrer » des ILs négatifs… Si l’on donne la valeur 0 à la vitesse d’obturation 1 seconde, la valeur attribuée à un temps de pose de 2 secondes sera -1 ! Si vous faites une photo avec une vitesse de 2 secondes et une ouverture de 1, l’IL correspondant sera égal à -1.
Dernière remarque, on utilise également les indices de luminances pour spécifier les plages de détection d’un posemètre : tel modèle permet une mesure de -2 IL à 20 IL par exemple.
On l’utilise également pour préciser la plage d’exposition mesurable par un boîtier ou pour préciser l’étendue de détection de son autofocus :

Marque et Modèle Etendue de Détection AF
Canon EOS 20D / EOS 5D 0,5 IL - 18 IL
Canon EOS 300D / 350D 0,5 IL - 18 IL
Canon EOS 1Ds Mark II 0 IL - 18 IL
Nikon D70 / D70s / D50 -1 IL - 19 IL
Nikon D2H -1 IL - 19 IL
Olympus E-1 0 IL - 19 IL

La magie de l'échelle logarithmique !

 

Sans forcément rentrer trop dans le détail, une échelle logarithmique permet de représenter d’une manière particulière une donnée physique qui peut prendre des valeurs très différentes en ordre de grandeur (par exemple et pour rester dans l’optique, on représente souvent la sensibilité de l’oeil humain avec une échelle logarithmique car on arrive à voir, la nuit, avec très peu de lumière mais on peut également quasiment directement regarder le soleil en pleine journée et pourtant, la luminosité est très différente !).
Autre exemple d’échelle logarithmique : l’échelle de Richter qui caractérise la puissance d’un tremblement de terre.
Je vous détaille ci-après le calcul qui permet de passer des vitesses d’obturation aux indices de luminance mais je ne vous en voudrais nullement si vous laissez d’ores et déjà tomber !

 

Calculs des IL



J’espère que cette petite note vous aura appris quelque chose ou, tout du moins, vous aura permis de démystifier les ILS !

Rédigé par Frédéric Peche le 08/12/08 - 22:18

Ecrire un commentaire Voir les commentaires

1 commentaires

Identification

Publicité