<?php 
 
/** Album photo php5
*** par thomas nares, tomasdev.fr
*** 
*** classe de creation et de gestion des apercus
*** version 0.1, 04/12/2008
*/
class ApercuModel {
    
    /* nom du fichier image */
    private $file = null;
 
    /* chemin d'acces à l'image */
    private $path = null;
    
    /* ressource image */
    private $image = null;
    
    /* format de l'image */
    private $format = null;
    
    /* tailles d'origine de l'image */
    private $xOrig = 0;
    private $yOrig = 0;
    
    /* tailles calculées par rapport au ratio de l'image d'origine */
    private $xNew = 0;
    private $yNew = 0;
    
    /* booleen indiquant si l'image est dans le cache de l'album photo, faux par defaut */
    private $cached = false;
    
    /* constantes entieres indiquants le type des images */
    const JPEG = 0;
    const PNG = 1;
    const GIF = 2;
    
    /* constantes entieres pour la qualité des images JPEG */
    const JPEG_QUALITY_HIGH = 100;
    const JPEG_QUALITY_MEDIUM = 75;
    const JPEG_QUALITY_LOW = 50;
    
    /* constantes entieres pour la qualité des images PNG */
    const PNG_QUALITY_HIGH = 0;
    const PNG_QUALITY_MEDIUM = 3;
    const PNG_QUALITY_LOW = 6;
    
    /** constructeur 
    * seul l'usage du constructeur est necessaire ici, il se charge d'afficher l'image et de la mettre en cache
    * @param $_file Fichier image
    * @param $_x longueur de l'aperçu
    * @param $_y largeur de l'aperçu
    */
    public function __construct($_path, $_size = 100){
        /* verification de l'existence de l'image */
        if (!file_exists(Config::url_images . $_path))
            throw new IOException("Image inlectable" );
        
        /* affectation aux champs de l'objet */
        $this->path = $_path;
        
        /* definir le nom de l'image */
        $this->getNSetFile();
        
        /* definir le type de l'image */
        $this->getNSetType();
        
        /* definir les dimensions de l'image */
        $this->getNSetDimensions();
    
        /* definir les nouvelles dimensions de l'image */
        $this->getNSetNewDimensions($_size);
        
        /* envoi du header */
        $this->envoiHeader();
        
        /* verification de l'existence de l'apercu */
        /* ou si l'apercu n'est pas depassé */
        if (!file_exists(Config::url_apercus . $_path) || filemtime(Config::url_apercus . $_path) < filemtime(Config::url_images . $_path)){
            /* on dessine l'apercu */
            $this->creerApercu($_size, $_size);
            /* on sauvegarde l'apercu */
            $this->sauvegarderApercu();
        }    
        /* l'apercu existe et n'est pas depassé, on le charge */
        else {
            /* booleen indiquant si l'image est dans le "cache" de l'album photo */
            $this->cached = true;
            /* on charge l'image */
            $this->chargerApercu();
        }
        
        /* on affiche l'aperçu */
        $this->afficherApercu();
    
        /* on libere les ressources */
        $this->__destruct();
    }
    
    /** destructeur privé
    * detruit la ressource image une fois affichée
    */
    private function __destruct(){
        /* si image est une ressource */
        if(is_resource($this->image)){
            /* detruire l'image et cacher l'erreur au cas ou */
            @ImageDestroy($this->image);
        }
    }
    
    /** methode privée de recuperation et d'affectation à l'objet du nom de l'image 
    * @return Nom du fichier
    */
    private function getNSetFile(){
        /* on explose $this->path sur '/' */
        $pieces = explode('/', $this->path);
    
        /* si la taille de $pieces est 1, alors on explose sur '\' */
        if (sizeof($pieces) == 1)
            $pieces = explode('\\', $this->path);
        
        /* on recupere la derniere case du tableau */
        $this->file = $pieces[sizeof($pieces) - 1];
        
        /* on retourne ce nom de fichier */
        return $this->file;
    }
    
    /** methode privée de creation de l'aperçu 
    * @param $_x longueur souhaitée 
    * @param $_y hauteur souhaitée
    */
    private function creerApercu($_x, $_y){
        /* image temporaire */
        $image = null;
        
        /* creation d'une image dans l'objet this */
        $this->image = imagecreatetruecolor($this->xNew, $this->yNew);
        
        /* switch sur le format pour appeler la bonne methode GD et creation de l'image */
        switch($this->format) {
            case self::GIF :
                /* format gif */
                $image = ImageCreateFromGif(Config::url_images . $this->path);
                break;
            case self::JPEG :
                /* format jpeg */
                $image = ImageCreateFromJpeg(Config::url_images . $this->path);
                break;
            case self::PNG:
                /* format png */
                $image = ImageCreateFromPng(Config::url_images . $this->path);
                break;
        }
        
        /* image du fond */
        $image_back = imagecreatetruecolor($_x, $_y);
    
        /* la remplir avec la couleur de fond (gris tres clair #EEEEEE;) */
        imagefilledrectangle($image_back, 0, 0, $_x, $_y, imagecolorallocate($image_back, 0xEE, 0xEE, 0xEE));
    
        /* redimensionnement de l'image et affectation dans l'objet */
        imagecopyresampled($this->image, $image, 0, 0, 0, 0, $this->xNew, $this->yNew, $this->xOrig, $this->yOrig);
        
        /* collage de l'image sur le fond */
        imagecopy($image_back, $this->image, ($_x - $this->xNew) / 2, ($_y - $this->yNew) / 2, 0, 0, $this->xNew, $this->yNew);
    
        /* reaffection dans l'objet */
        $this->image = $image_back;
    }
    
    /** methode privée de determination et d'affection du type de l'image
    * @return Type de l'image
    */
    private function getNSetType(){
        /* pour recuperer le format */
        /* si l'extension est gif ou GIF */
        if(stristr(strtolower(Config::url_images . $this->file),'.gif')) 
            $this->format = self::GIF;
        /* si l'extension est jpg ou JPG ou jpeg ou JPEG */
        elseif(stristr(strtolower(Config::url_images . $this->file),'.jpg') || stristr(strtolower(Config::url_images . $this->file),'.jpeg')) 
            $this->format = self::JPEG;
        /* si l'extension est png ou PNG */
        elseif(stristr(strtolower(Config::url_images . $this->file),'.png')) 
            $this->format = self::PNG;
        /* sinon on lance une IOException */
        else
            throw new IOException("Image inlectable, format inconnu" );
        
        /* retourne le format */
        return $this->format;
    }
    
    /** methode privée de determination et d'affection des dimensions originales
    * @return Tableau de dimensions
    */
    private function getNSetDimensions(){
        /* recuperation des dimensions de l'image */
        $sizes = getimagesize(Config::url_images . $this->path);
        
        /* affectation aux champs de l'objet */
        $this->xOrig = $sizes[0];
        $this->yOrig = $sizes[1];
        
        /* retourne les dimensions sous forme de tableau */
        return array($this->xOrig, $this->yOrig);
    }
    
    /** methode privée de determination et d'affection des nouvelles dimensions
    * algorithme de calcul du ratio expliqué plus bas
    * @return Tableau de dimensions
    */
    private function getNSetNewDimensions($_size){
        
        $this->xNew = $this->yNew = $_size;
        
        /* calcul des ratios */
        /* algo :
        *     si le ratio (L/l) de l'image initiale est superieur au ratio de l'apercu souhaité alors
        *        diviser la hauteur de l'apercu souhaité par le ratio de l'image initiale
        *     sinon
        *        multiplier la longueur de l'apercu souhaité par le ratio de l'image initiale
        */
        if ($this->xOrig / $this->yOrig > 1)
            $this->yNew /= $this->xOrig / $this->yOrig ;
        else
            $this->xNew *= $this->xOrig / $this->yOrig ;
        
        /* retourne les nouvelles dimensions sous forme de tableau */
        return array($this->xNew, $this->yNew);
    }
    
    /** methode privée d'envoi du header pour le navigateur
    */
    private function envoiHeader(){
        /* envoi du header */
        switch($this->format) {
            case self::GIF :
                /* header type GIF */
                header("Content-type: image/gif" );
                break;
            case self::JPEG :
                /* header type JPEG */
                header("Content-type: image/jpeg" );
                break;
            case self::PNG:
                /* header type PNG */
                header("Content-type: image/png" );
                break;
        }
    }
    
    /** methode privée de sauvegarde de l'aperçu dans le dossier aperçu
    */
    private function sauvegarderApercu(){
        /* on crée l'arborescence neccessaire pour accueillir l'apercu */
        $this->construireArborescence();
            
        /* sauvegarde de l'image */
        switch($this->format) {
            case self::GIF :
                /* image type GIF */
                imagegif($this->image, Config::url_apercus . $this->path);
                break;
            case self::JPEG :
                /* image type JPEG */
                imagejpeg($this->image, Config::url_apercus . $this->path, self::JPEG_QUALITY_MEDIUM);
                break;
            case self::PNG:
                /* image type PNG */
                imagepng($this->image, Config::url_apercus . $this->path, self::PNG_QUALITY_MEDIUM);
                break;
        }
    }
    
    /** methode privée qui creer l'arborescence necessaire pour enregistrer l'apercu
    */
    private function construireArborescence(){
        /* on explose $this->path sur '/' */
        $dossiers = explode('/', $this->path);
    
        /* si la taille de $pieces est 1, alors on explose sur '\' */
        if (sizeof($dossiers) == 1)
            $dossiers = explode('\\', $this->path);
        
        /* chaine des dossiers */
        $arbo = Config::url_apercus;
    
        /* si il y a des dossiers alors */
        /* pour chaque dossier */
        if (sizeof($dossiers) > 1) foreach($dossiers as $dossier){
            /* si le dossier actuel n'est pas le fichier lui meme */
            if ($dossier != $this->file){
                /* concatener l'arborescence avec un '/' et $dossier */
                $arbo .= $dossier . '/';
                /* on test si le dossier existe deja */
                if (!is_dir($arbo)){
                    /* on le crée si necessaire */
                    mkdir($arbo);
                }
            }
        }
    }
    
    /** methode privée d'affichage de l'image
    */
    private function afficherApercu(){
        /* envoi de l'image */
        switch($this->format) {
            case self::GIF :
                /* image type GIF */
                imagegif($this->image, null);
                break;
            case self::JPEG :
                /* image type JPEG */
                imagejpeg($this->image, null, self::JPEG_QUALITY_HIGH);
                break;
            case self::PNG :
                /* image type PNG */
                imagepng($this->image, null, self::PNG_QUALITY_MEDIUM);
                break;
        }
    }
    
    /** methode privée de chargement de l'aperçu dans l'objet
    */
    private function chargerApercu(){
        /* chargement de l'image */
        switch($this->format) {
            case self::GIF :
                /* image type GIF */
                $this->image = ImageCreateFromGif(Config::url_apercus . $this->path);
                break;
            case self::JPEG :
                /* image type JPEG */
                $this->image = ImageCreateFromJpeg(Config::url_apercus . $this->path);
                break;
            case self::PNG:
                /* image type PNG */
                $this->image = ImageCreateFromPng(Config::url_apercus . $this->path);
                break;
        }
    }
}
 
/** Album photo php5
*** par thomas nares, tomasdev.fr
*** 
*** classe de gestion des erreurs liées aux aperçus
*** version 0.1, 04/12/2008
*/
class IOException extends Exception {}
 
?>

<?php 
 
require_once(Config::incPath . 'ApercuModel.inc.php');
 
/** Album photo php5
*** par thomas nares, tomasdev.fr
*** 
*** classe d'affichage d'un apercu
*** version 0.1, 04/12/2008
*/
class ApercuView {
    
    /* adresse de l'image */
    private $path;
 
    /* nom de l'image */
    private $file;
    
    /** contructeur
    * @param $_path chemin d'acces à l'image
    */
    public function __construct($_path){
        /* verification de l'existence de l'image */
        if (!file_exists(Config::url_images . $_path))
            throw new IOException("Image inlectable" );
        
        /* pour verifier le format */
        /* si l'extension n'est pas gif ou GIF, jpg ou JPG, jpeg ou JPEG, png ou PNG on lance une IOException */
        if(!(stristr(strtolower($_path),'.gif') || 
            stristr(strtolower($_path),'.jpg') ||
            stristr(strtolower($_path),'.jpeg') ||
            stristr(strtolower($_path),'.png'))){
            throw new IOException("Image inlectable, format inconnu" );
        }
        
        /* affectation à l'objet */
        $this->path = $_path;
    
        /* affecter le nom de fichier */
        $this->getNSetFile();
        
        /* preparation d'une chaine pour le nom de l'image : */
        $name = $this->file;
        /* si la longueur de la chaine est superieure à 16 ... */
        if (strlen($name) > 16){
            /* ... on la coupe à 16, et on met '...' */
            $name = substr($name, 0, 15) . '...';
        }
    
        /* envoi du code */
        echo '    <div class="apercuView">
                    <a href="' . Config::url_ImageViewer . $_path . '">
                    <img src="' . Config::url_ApercuViewer . $_path . '" width="100" height="100">
                    </a>
                    <div class="apercuInfos">
                        <a href="' . Config::url_ImageViewer . $_path . '">' . $name . '</a>
                    </div>
                    <div class="apercuInfos">
                        ' . $this->getInfos(Config::url_images . $_path) . '
                    </div>
                </div>';
    }
    
    /** methode permettant d'obtenir les infos sur l'image
    * @return String avec les infos de l'image
    */
    private function getInfos(){
        /* recuperation des tailles */
        $sizes = getimagesize(Config::url_images . $this->path);
    
        /* recuperation du poids */
        $weight = round(filesize(Config::url_images . $this->path) / 1024);
    
        /* fabrication et retournement de la chaine */
        return "$sizes[0] x $sizes[1] px - $weight ko";
    }
 
    /** methode qui retourne le bbcode pour l'apercu
    */
    private function getBBCode(){
        return '[URL=' . Config::url_ImageViewer . $_path . '][IMG]' . Config::url_ApercuViewer . $_path . '[/IMG][/URL]';
    }
    
    /** methode privée de recuperation et d'affectation à l'objet du nom de l'image 
    * @return Nom du fichier
    */
    private function getNSetFile(){
        /* on explose $this->path sur '/' */
        $pieces = explode('/', $this->path);
    
        /* si la taille de $pieces est 1, alors on explose sur '\' */
        if (sizeof($pieces) == 1)
            $pieces = explode('\\', $this->path);
        
        /* on recupere la derniere case du tableau */
        $this->file = $pieces[sizeof($pieces) - 1];
        
        /* on retourne ce nom de fichier */
        return $this->file;
    }
    
}

<?php 
 
require_once(Config::incPath . 'ApercuView.inc.php');
 
/** Album photo php5
*** par thomas nares, tomasdev.fr
*** 
*** classe de creation et de gestion de l'album photo recursif
*** version 0.1, 04/12/2008
*/
class AlbumPhoto {
    
    /** constructeur, instancie un nouvel album photo */
    public function __construct($_clean){
        /* si $_clean vaut vrai */
        if ($_clean){
            /* on nettoie le repertoire des apercus */
            self::clean();
        }
        
        /* lance l'affichage recursif de l'album photo */
        self::affiche(Config::url_images, 1);
    }
    
    /** methode privée statique qui efface les apercus calculés 
    */
    private static function clean(){
        /* on lance le nettoyage de l'album */
        /* en supprimant le dossier des miniatures */
        exec("rm -r " . Config::albumPath . Config::url_apercus);
        
        /* et en recreant le dossier des apercus */
        exec("mkdir " . Config::albumPath . Config::url_apercus);
    }
 
    /** methode recursive statique d'afffichage des miniatures
    * du dossier $_path donné, au niveau de recursion donné $_level
    * @param $_path le dossier à afficher
    * @param $_level le niveau de recursion 
    */
    private static function affiche($_path, $_level){
        
        /* pour chaque fichier ayant comme extension jpg,JPG,jpeg,JPEG,gif,GIF,png ou PNG dans
        * $_path, on instancie un nouvel ApercuView, avec $file en enlevant le premier repertoire
        * qui correspond au repertoire des images */
        foreach (glob("$_path*.{jpg,JPG,jpeg,JPEG,gif,GIF,png,PNG}", GLOB_BRACE) as $file){
            new ApercuView(substr($file, strlen(Config::url_images)));
        }
        
        /* envoi au navigateur d'une div afin de rompre le float : left du css */
        echo '<div class="break"></div>';
    
        /* enfin, pour chaque dossier dans $_path,
        * on lance la recursion sur le dossier */
        foreach (glob("$_path*", GLOB_BRACE) as $file){
            if (is_dir($file)){
                /* Images de : $file */
                echo '<div class="lvl' . ($_level + 1) . '">Images de /' . substr($file, strrpos($file, "/" )+1) . '</div>';
                /* lancer la recursion */
                self::affiche($file . '/', $level +1);
            }
        }        
    }
}

<?php
            require_once("classes/Config.inc.php" );
            require_once(Config::incPath . 'AlbumPhoto.inc.php');
            $clean = false;
            if (isset($_GET['clean']) && $_GET['clean'] == 'true')
                $clean = true;
            new AlbumPhoto($clean);
        ?>

<?php
    /* require pour les classes */
    require_once("classes/Config.inc.php" );
    require_once(Config::incPath . "ApercuModel.inc.php" );
    
    if (isset($_GET['p'])){
        /* creation d'un objet apercu */
        new ApercuModel($_GET['p']);
    }        
?>

/* envoi du code */
echo '    <div class="apercuView">
                    <a href="' . Config::url_ImageViewer . $_path . '">
                    <img src="' . Config::url_ApercuViewer . $_path . '" width="100" height="100">
                    </a>
                    <div class="apercuInfos">
                        <a href="' . Config::url_ImageViewer . $_path . '">' . $name . '</a>
                    </div>
                    <div class="apercuInfos">
                        ' . $this->getInfos(Config::url_images . $_path) . '
                    </div>
                </div>';