POO - GESTION DES COULEURS

<?php

/**
 * @filesource color.class.php
 * @desc Package de manipulation des couleurs
 *
 * @author M.Yvan.k <dighan@gmail.com>
 * @version 1.0.0
 * @date 14-11-2007
 * @package Graphics  
 * @subpackage Color
 */
 
 
/**
 * @name ColorException
 * @desc Classe de gestion des Exceptions
 *
 * @version 1.0.0
 * @date 14-11-2007
 */
class ColorException extends Exception {
  const UNKNOWN_CONSTRUCTOR = 'constructeur inconnu';
  const HEX_FORMAT = 'format hexadecimal invalide';
  const RED_RANGE = 'La composante rouge doit être comprise entre 0 et 255';
  const GREEN_RANGE = 'La composante verte doit être comprise entre 0 et 255';
  const BLUE_RANGE = 'La composante bleue doit être comprise entre 0 et 255';
   
  public function __construct($sMsg) {
    $sNewMsg = '<strong>Erreur : </strong>' . $sMsg;
    parent::__construct($sNewMsg);
 }
}

/**
 * @name ColorSpace
 * @desc Classe abstraite, introduite pour faciliter l'implémentation d'un nouvel espace chromatique
 *
 * @version 1.0.0
 * @date 14-11-2007
 */
abstract class ColorSpace {

 /**
  * @desc Masque de recuperation des bits de poids fort (Most Significant Bits)
  * @var integer MSB
  * @access public
  */
  const MSB = 0xf0;
  
 /**
  * @desc Masque de recuperation des bits de poids faible (Least Significant Bits)
  * @var integer LSB
  * @access public
  */
  const LSB = 0x0f;
  
 /**
  * @desc Couleur courante
  * @var array $_aColor
  * @access protected
  */
 protected $_aColor = array();
  
 /**
  * @desc Constructeur
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param array $aComponents Composantes chromatiques
  * @access public
  */  
  public function __construct(array $aComponents) {
    $this->_aColor = $aComponents;
  }
  
 /**
  * @desc Accesseur
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @return array
  * @access public
  */
  public function getColor() {
    return $this->_aColor;
  }
  
 /**
  * @desc Methode de comparaison de deux couleurs
  *
  * @version 1.0.0 
  * @date 14-11-2007
  * @param object $oColor Couleur a comparer
  * @return boolean TRUE en cas de succes, FALSE sinon
  * @access public
  */
  public function compare($oColor) {
    return ($this->_aColor === $oColor->getColor()) ? TRUE : FALSE;
  }
  
 /**
  * @desc Methode de conversion - Rgb => Hexa.
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param integer $iRed Composante rouge
  * @param integer $iGreen Composante verte
  * @param integer $iBlue Composante bleue
  * @param boolean $bToUpper TRUE pour un retour en majuscules, FALSE sinon
  * @return string Valeur convertie
  * @access public
  */
  public static function convertToHex($iRed, $iGreen, $iBlue, $bToUpper) {
    $sHexRefStr = '0123456789abcdef';
    $sHexCmp0 = $sHexRefStr[ ((int) $iRed & self::MSB) >> 4 ] . $sHexRefStr[ ((int) $iRed & self::LSB) ];
    $sHexCmp1 = $sHexRefStr[ ((int) $iGreen & self::MSB) >> 4 ] . $sHexRefStr[ ((int) $iGreen & self::LSB) ];
    $sHexCmp2 = $sHexRefStr[ ((int) $iBlue & self::MSB) >> 4 ] . $sHexRefStr[ ((int) $iBlue & self::LSB) ];
    $sRet = $sHexCmp0 . $sHexCmp1 . $sHexCmp2;
    return (!$bToUpper) ? $sRet : strtoupper($sRet);
  }
  
 /**
  * @desc Methode de verification - Format Hexa.
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param string $sHexStr Chaine a verifier
  * @return boolean TRUE en cas de succes, une Exception sinon
  * @exception ColorException Si la chaine ne respecte pas le format Hexa.
  * @access public
  */  
  public static function checkHexFormat($sHexStr) {
    $bRet = (preg_match('/^#[0-9a-f]{6}$/i', $sHexStr) == 1) ? TRUE : FALSE;
    if (!$bRet) throw new ColorException(ColorException::HEX_FORMAT);
    return $bRet;
  }
  
 /**
  * @desc Methode d'assombrissement
  */
  abstract public function darken($iCoeff);
  
 /**
  * @desc Methode d'eclaircissement
  */
  abstract public function brighten($iCoeff);
  
 /**
  * @desc Methode d'inversion
  */
  abstract public function reverse();
  
 /**
  * @desc Methode de melange
  */
  abstract public function mix($oColor);
}

/**
 * @name Rgb
 * @desc Classe representative de l'espace RGB
 *
 * @version 1.0.0
 * @date 14-11-2007
 */
class Rgb extends ColorSpace {
  
 /**
  * @desc Valeur max. dans l'espace RGB
  * @var integer MAX
  * @access public
  */  
  const MAX = 255;
  
 /**
  * @desc Valeur min. dans l'espace RGB
  * @var integer MIN
  * @access public
  */
  const MIN = 0;

 /**
  * @desc Constructeur
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param array $aComponents Composantes chromatiques
  * @exception ColorException Si les parametres ne sont pas reconnus
  * @access public
  */
  public function __construct(array $aComponents) {
    $iNumComponents = count($aComponents);
    if ($iNumComponents == 3 && Rgb::checkRgbFormat($aComponents[0], $aComponents[1], $aComponents[2]))
      parent::__construct($aComponents);
    else if ($aComponents[0][0] == '#' && ColorSpace::checkHexFormat($aComponents[0]))
      parent::__construct($this->convertToRgb($aComponents[0]));
    else
      throw new ColorException(ColorException::UNKNOWN_CONSTRUCTOR);
  }
  
 /**
  * @desc Methode d'eclaircissement
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param integer $iCoeff Coefficient d'eclaircissement comprit entre 0 et 255
  * @return array Un tableau du type ARRAY('0'=>R, '1'=>G, '2'=>B)
  * @access public
  */ 
  public function brighten($iCoeff) {
    $iRgbRed   = (($this->_aColor[0] + $iCoeff) > self::MAX) ? 255 : ($this->_aColor[0] + $iCoeff);
    $iRgbGreen = (($this->_aColor[1] + $iCoeff) > self::MAX) ? 255 : ($this->_aColor[1] + $iCoeff);
    $iRgbBlue  = (($this->_aColor[2] + $iCoeff) > self::MAX) ? 255 : ($this->_aColor[2] + $iCoeff);
    return array($iRgbRed, $iRgbGreen, $iRgbBlue);
  }

 /**
  * @desc Methode d'assombrissement
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param integer $iCoeff Coefficient d'assombrissement comprit entre 0 et 255
  * @return array Un tableau du type ARRAY('0'=>R, '1'=>G, '2'=>B)
  * @access public
  */
  public function darken($iCoeff) {
    $iRgbRed   = (($this->_aColor[0] - $iCoeff) < self::MIN) ? 0 : ($this->_aColor[0] - $iCoeff);
    $iRgbGreen = (($this->_aColor[1] - $iCoeff) < self::MIN) ? 0 : ($this->_aColor[1] - $iCoeff);
    $iRgbBlue  = (($this->_aColor[2] - $iCoeff) < self::MIN) ? 0 : ($this->_aColor[2] - $iCoeff);
    return array($iRgbRed, $iRgbGreen, $iRgbBlue);
  }

 /**
  * @desc Methode d'inversion
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @return array Un tableau du type ARRAY('0'=>R, '1'=>G, '2'=>B)
  * @access public
  */
  public function reverse() {
    $iRgbRed   = self::MAX - $this->_aColor[0];
    $iRgbGreen = self::MAX - $this->_aColor[1];
    $iRgbBlue  = self::MAX - $this->_aColor[2];
    return array($iRgbRed, $iRgbGreen, $iRgbBlue);
  }
  
 /**
  * @desc Methode de melange
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param object $oColor Couleur de melange
  * @return array Un tableau du type ARRAY('0'=>R, '1'=>G, '2'=>B)
  * @access public
  */  
  public function mix($oColor) {
    $aColor = $oColor->getColor();
    $iRgbRed   = ($this->_aColor[0] + $aColor[0]) / 2;
    $iRgbGreen = ($this->_aColor[1] + $aColor[1]) / 2;
    $iRgbBlue  = ($this->_aColor[2] + $aColor[2]) / 2;
    return array($iRgbRed, $iRgbGreen, $iRgbBlue);
  }
  
 /**
  * @desc Methode de conversion - Hexa. => Rgb
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param string $sHexStr Chaine Hexa. a convertir
  * @return array Un tableau du type ARRAY('0'=>R, '1'=>G, '2'=>B)
  * @access public
  */
  public static function convertToRgb($sHexStr) {
    return array(hexdec(substr($sHexStr, 1, 2)), hexdec(substr($sHexStr, 3, 2)), hexdec(substr($sHexStr, 5, 2))); 
  }
  
 /**
  * @desc Methode de verification - format Rgb
  *
  * @version 1.0.0
  * @date 05-02-2007
  * @param integer $iRed Composante rouge
  * @param integer $iGreen Composante verte
  * @param integer $iBlue Composante bleue
  * @return boolean TRUE en cas de succes, une Exception sinon
  * @exception ColorException Si les parametres ne respectent pas la plage de valeurs imposee dans l'espace RGB
  * @access public
  */
  public static function checkRgbFormat($iRed, $iGreen, $iBlue) {
    $bRet = FALSE;
    if ((int) $iRed >= self::MIN && (int) $iRed <= self::MAX)
      if ((int) $iGreen >= self::MIN && (int) $iGreen <= self::MAX)
        if ((int) $iBlue >= self::MIN && (int) $iBlue <= self::MAX) $bRet = TRUE;
        else throw new ColorException(ColorException::BLUE_RANGE);
      else throw new ColorException(ColorException::GREEN_RANGE);
    else throw new ColorException(ColorException::RED_RANGE);
    return $bRet;
  }
}

/**
 * @name Color
 * @desc Classe principale
 *
 * @version 1.0.0
 * @date 14-11-2007
 */
class Color {

 /**
  * @desc Couleurs principales
  * @var string
  * @access public
  */
  const BLACK = '#000000';
  const BLUE = '#0000ff';
  const CYAN = '#00ffff';
  const DARKEN_GRAY = '#a8a8a8';
  const GRAY = '#808080';
  const GREEN = '#00ff00';
  const LIGHT_GRAY = '#d0d0d0';
  const MAGENTA = '#ff00ff';
  const ORANGE = '#ffa400';
  const PINK = '#fa1493';
  const RED = '#ff0000';
  const WHITE = '#ffffff';
  const YELLOW = '#ffff00';

 /**
  * @desc Objet representatif de l'espace chromatique courant
  * @var object $_oColor
  * @access private
  */
  private $_oColor;
  
 /**
  * @desc Constructeur variable : 3 parametres (integer => Rgb) ou 1 parametre (string => Hexa.)
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param string Chaine Hexa.
  * @param integer Trois entiers => composantes R,G et B
  * @exception ColorException Si les parametres ne sont pas reconnus
  * @access public
  */  
  public function __construct() {
    $iNumArgs = func_num_args();
    if ($iNumArgs == 3 || $iNumArgs == 1) $this->_oColor = new Rgb(func_get_args());
    else throw new ColorException(ColorException::UNKNOWN_CONSTRUCTOR);
  }
  
 /**
  * @desc Méthode de conversion interne - Rgb => Hexa
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param boolean $bToUpper TRUE pour un retour en majuscules, FALSE sinon
  * @return string
  * @access public
  */
  public function getHexValue($bToUpper = FALSE) {
    $aColor = $this->_oColor->getColor();
    return Color::convertToHex($aColor[0], $aColor[1], $aColor[2], $bToUpper);
  }
  
 /**
  * @desc Methode de conversion interne - Hexa => Rgb
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param array $AsString TRUE pour un retour du type string, FALSE pour un type array
  * @return mixed
  * @access public
  */
  public function getRgbValue($AsString = FALSE) {
    $aColor = $this->_oColor->getColor();
    return (!$AsString) ? $aColor : $aColor[0] . ',' . $aColor[1] . ',' .$aColor[2];
  }
  
 /**
  * @desc Methode de recuperation du nom de la couleur courante
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @return mixed Le nom de la couleur en cas de succes, FALSE sinon
  * @access public
  */
  public function getName() {
    $mRet = FALSE;
    $oClass = new ReflectionClass('Color');
    $aColor = $this->_oColor->getColor();
    foreach ($oClass->getConstants() as $key => $val) {
      $aRgbVal = Color::convertToRgb($val);
      if ($aRgbVal === $aColor) {
        $mRet = (string) $key;
        break;
      }
    }
    return $mRet;
  }
  
 /**
  * @desc Methode d'eclaircissement
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param integer $iCoeff Coefficient d'eclaircissement comprit entre 0 et 255
  * @return object Un objet Color
  * @access public
  */
  public function brighten($iCoeff) {
    $aComponents = $this->_oColor->brighten($iCoeff);
    return new Color($aComponents[0], $aComponents[1], $aComponents[2]);
  }
  
 /**
  * @desc Methode d'assombrissement
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param integer $iCoeff Coefficient d'assombrissement comprit entre 0 et 255
  * @return object Un objet Color
  * @access public
  */
  public function darken($iCoeff) {
    $aComponents = $this->_oColor->darken($iCoeff);
    return new Color($aComponents[0], $aComponents[1], $aComponents[2]);
  }
  
 /**
  * @desc Methode d'inversion
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @return object Un objet Color
  * @access public
  */
  public function reverse() {
    $aComponents = $this->_oColor->reverse();
    return new Color($aComponents[0], $aComponents[1], $aComponents[2]);
  }
  
 /**
  * @desc Methode de melange
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param object $oColor Couleur de melange
  * @return object Un objet Color
  * @access public
  */ 
  public function mix(Color $oColor) {
    $aComponents = $this->_oColor->mix($oColor);
    return new Color($aComponents[0], $aComponents[1], $aComponents[2]);
  }
  
 /**
  * @desc Accesseur externe
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @return array Un tableau du type ARRAY('0'=>R, '1'=>G, '2'=>B)
  * @access public
  */ 
  public function getColor() {
    return $this->_oColor->getColor();
  }
  
 /**
  * @desc Methode de comparaison
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param object $oColor Couleur a comparer
  * @return boolean TRUE en cas de succes, FALSE sinon
  * @access public
  */
  public function compare(Color $oColor) {
    return $this->_oColor->compare($oColor);
  }
  
 /**
  *	@desc Methode de conversion - Rgb => Hexa
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param integer $iRed Composante rouge
  * @param integer $iGreen Composante verte
  * @param integer $iBlue Composante bleue
  * @param boolean $bToUpper TRUE pour un retour en majuscules, FALSE sinon
  * @return mixed Une chaine en cas de succes, FALSE sinon
  * @access public
  */
  public static function convertToHex($iRed, $iGreen, $iBlue, $bToUpper = FALSE) {
    $mRet = FALSE;
    if (Color::isRgbFormat($iRed, $iGreen, $iBlue)) $mRet = (string) ColorSpace::convertToHex($iRed, $iGreen, $iBlue, $bToUpper);
    return $mRet;
  }
  
 /**
  * @desc Methode de conversion - Hexa => Rgb
  *
  * @version 1.0.0
  * @date 14-11-2007
  * @param string $sHexStr Chaine Hexa.
  * @param boolean $AsString TRUE pour un retour du type string, FALSE pour un type array
  * @return mixed Un tableau ou une chaine en cas de succes, FALSE sinon
  * @access public
  */
  public static function convertToRgb($sHexStr, $AsString = FALSE) {
    $mRet = FALSE;
    if (Color::isHexFormat($sHexStr)) {
      $aRes = Rgb::convertToRgb($sHexStr);
      $mRet = (!$AsString) ? (array) $aRes : (string) $aRes[0] . ',' . $aRes[1] . ',' . $aRes[2];
    }
    return $mRet;
  }

 /**
  * @desc Methode de verification - Format Hexa.
  *
  * @version 1.0.0
  * @date 05-02-2007
  * @param string $sHexStr Chaine Hexa.
  * @return boolean TRUE en cas de succes, FALSE sinon
  * @access public
  */
  public static function isHexFormat($sHexStr) {
    $bRet = FALSE;
    try {
      ColorSpace::checkHexFormat($sHexStr);
      $bRet = TRUE;
    } catch (ColorException $e) {}
    return $bRet;
  }
  
 /**
  * @desc Methode de verification - Format Rgb
  *
  * @version 1.0.0
  * @date 05-02-2007
  * @param integer $iRed Composante rouge
  * @param integer $iGreen Composante verte
  * @param integer $iBlue Composante bleue
  * @return boolean TRUE en cas de succes, FALSE sinon
  * @access public
  */
  public static function isRgbFormat($iRed, $iGreen, $iBlue) {
    $bRet = FALSE;
    try {
      Rgb::checkRgbFormat($iRed, $iGreen, $iBlue);
      $bRet = TRUE;
    } catch (ColorException $e) {}
    return $bRet;
  }
  
}

# Exemple

try {

  # constructeurs possibles
  $oOrange = new Color(Color::ORANGE);
  $oGray = new Color(128, 128, 129);
  $oBlue = new Color('#0000ff');

  # affichage des conversions et du nom des couleurs courantes
  printf('Nom: %s - RGB: %s - Hexa: #%s <br />', $oOrange->getName(), $oOrange->getRgbValue(TRUE), $oOrange->getHexValue(TRUE));
  printf('Nom: %s - RGB: %s - Hexa: #%s <br />', $oGray->getName(), $oGray->getRgbValue(TRUE), $oGray->getHexValue());
  printf('Nom: %s - RGB: %s - Hexa: #%s <br />', $oBlue->getName(), $oBlue->getRgbValue(TRUE), $oBlue->getHexValue());
   
  # comparaison des couleurs (peu importe la valeur de depart)
  echo $oOrange->compare($oGray) ? 'EGAUX' : 'NE SONT PAS EGAUX' . '<br />';
  echo $oBlue->compare($oGray) ? 'EGAUX' : 'NE SONT PAS EGAUX' . '<br />';

} catch (ColorException $e) {
  echo $e->getMessage();
}

?>