Newsgroup: it.comp.www.php
Titolo: KPA 2.0 - Album fotografico

Ho apportato alcuni miglioramenti al mio album fotografico in PHP.
Le più grosse novità sono:
- a ciascuna foto si può dare un commento e un voto;
- posso inserire filmati;
- lettura dei dati EXIF delle foto;
- visualizzazione del peso in Kb delle foto.
Se avete voglia dategli un'occhiata e testatelo un po'...
http://www.krakatoa.it/
Ciao!!
Luca

 ha scritto nel messaggio
news:RUL7b.62122$R32.1...@news2.tin.it...

Molto carino,
c'è anche la possibilità di fare upload delle immagini?
c'è una minima gestione dei permessi, chi può vedere e chi no e chi può
inserire e chi no?
Per caso lo integri in qualche CMS (postnuke, envolution etc...)? O rilasci
il codice open source?
Ciao
Frank

 Frank
Ciao
Luca
http://www.krakatoa.it/

un piccolo consiglio
io rifarei lo script che genera le anteprime
le immagini sono molto sgranate segno che usi le gd male
io ti consiglieri imagemagick(se sei sotto linux c'č sicuro)
ma di fatto devi creare i file delle anteprime sul server e non crearle
on-fly
system("/usr/local/bin/convert -geometry 160x120 file_immagine_grande
file_immagine_anteprima");
otterrai una ottima qualitą
ma puoi provare con questa classe
usa gd, ma con discreto risultato grafico
<?php
/* php image resizing class
About:
This is a php image resizing class. I wrote this class to make it easier to
properly resize images for my website. Before I wrote this class I manually
resized and compressed all images I put on my website. Right now I can make
php
do it and still maintain proper proportions etc.
Right now it only works with the Jpeg image format, but I might make it work
with
more formats soon (Jpeg is all I really need).
Required:
To make this image class work you will need the following software installed
- php, version 4.0.6 or later, with GD support
- GD version 2.0.1 or later, with Jpeg support
- and ofcourse a webserver
HowTo:
Using this image class is simple and straightforward, there are 3 steps
which
have to take place for the class to work:
-  Load a image with the loadImage($path) function
-  Resize the image using any of the resize*(*) functions
-  Save a image with the saveImage($path, $quality=75)
-  Clear the memory of the image by using clearImage()
I have included a small example at the bottem of this file
License:
Do whatever you want with it aslong as you leave this statement intact
and in the same file as the class definition.
Contact:
Got any questions, requests, changes or whatever, please contact me.
Greetings,
Timothy Kanters
< 
tph.k...@wanadoo.nl
 >
< 
http://www.TimothyKanters.com
 >
*/
class Image
{
    var $image = FALSE;
    function loadImage($path)
    /*
    This function loads the image you want to resize.
    The function will return TRUE on a succes and FALSE on failure
    */
    {
        if ( $this->image ) {
            imagedestroy($this->image);
        }
        if ( !($this->image = imageCreateFromJpeg($path)) ) {
            return FALSE;
        } else {
            return TRUE;
        }
    }
    function saveImage($path, $quality=75)
    /*
    Save the image, to either a new or an already existing file.
    The quality setting determines the quality of the image (0 to 100).
    The function will return TRUE on a succes and FALSE on failure
    */
    {
        if (!$this->image) {
            return FALSE;
        }
        $fp = fopen($path, "w");
        if (!$fp) {
            return FALSE;
        } else {
            fclose($fp);
            if (!imageJpeg($this->image, $path, $quality)) {
                return FALSE;
            } else {
                return TRUE;
            }
        }
    }
    function saveImagePNG($path)
    /*
    Save the image, to either a new or an already existing file.
    The quality setting determines the quality of the image (0 to 100).
    The function will return TRUE on a succes and FALSE on failure
    */
    {
        if (!$this->image) {
            return FALSE;
        }
        $fp = fopen($path, "w");
        if (!$fp) {
            return FALSE;
        } else {
            fclose($fp);
            if (!imagepng($this->image, str_replace(".jpg", "",
$path).".png")) {
                return FALSE;
            } else {
                return TRUE;
            }
        }
    }
    function clearImage()
    /*
    Clears the memory used for the image (if it is loaded)
    This function is required to ensure that there are no memory leaks!
    you have to run this function after your resizing is complete.
    The function always returns TRUE
    */
    {
        if ($this->image) {
            imagedestroy($this->image);
            $this->image = FALSE;
            return TRUE;
        } else {
            return TRUE;
        }
    }
    function getWidth()
    /*
    returns the width of the loaded image
    */
    {
        if (!$this->image) {
            return 0;
        }
        return imageSX($this->image);
    }
    function getHeight()
    /*
    returns the Height of the loaded image
    */
    {
        if (!$this->image) {
            return 0;
        }
        return imageSY($this->image);
    }
    function resizeW($newWidth)
    /*
    resizes an image accordingly to fit the newWidth and remain proportions
    */
    {
        if (!$this->image) {
            return FALSE;
        }
        $oldWidth = imageSX($this->image);
        $oldHeight = imageSY($this->image);
        $newHeight = ($oldHeight / ($oldWidth / $newWidth));
        $imageNew = ImageCreateTrueColor($newWidth, $newHeight);
        imageCopyResampled($imageNew, $this->image, 0, 0, 0, 0, $newWidth,
$newHeight, $oldWidth, $oldHeight);
        imageDestroy($this->image);
        $this->image = $imageNew;
        return TRUE;
    }
    function resizeH($newHeight)
    /*
    resizes an image accordingly to fit the newHeight and remain proportions
    */
    {
        if (!$this->image) {
            return FALSE;
        }
        $oldWidth = imageSX($this->image);
        $oldHeight = imageSY($this->image);
        $newWidth = ($oldWidth / ($oldHeight / $newHeight));
        $imageNew = ImageCreateTrueColor($newWidth, $newHeight);
        imageCopyResampled($imageNew, $this->image, 0, 0, 0, 0, $newWidth,
$newHeight, $oldWidth, $oldHeight);
        imageDestroy($this->image);
        $this->image = $imageNew;
        return TRUE;
    }
    function resizeWH_palette($maxWidth, $maxHeight, $stretch=FALSE)
    /*
    resizes an image accordingly to fit the maxWidth and maxHeight.
    By default it retains proportions. If however stretch is set to TRUE it
    will stretch the image to the maxWidth and maxHeight.
    */
    {
        if (!$this->image) {
            return FALSE;
        }
        $oldWidth = imageSX($this->image);
        $oldHeight = imageSY($this->image);
        $newWidth= $maxWidth;
        $newHeight= $maxHeight;
        if (!$stretch) {
            $ratio = $oldWidth / $oldHeight;
            if (($maxWidth  / $maxHeight) < $ratio) {
                $newHeight = ($oldHeight / ($oldWidth / $maxWidth));
            } else {
                $newWidth = ($oldWidth / ($oldHeight / $maxHeight));
            }
        }
        $imageNew = ImageCreateTrueColor($newWidth, $newHeight);
        imageCopyResampled($imageNew, $this->image, 0, 0, 0, 0, $newWidth,
$newHeight, $oldWidth, $oldHeight);
        imageDestroy($this->image);
        $this->image = $imageNew;
        return TRUE;
    }
function resizeWH($maxWidth, $maxHeight, $stretch=FALSE)
    /*
    resizes an image accordingly to fit the maxWidth and maxHeight.
    By default it retains proportions. If however stretch is set to TRUE it
    will stretch the image to the maxWidth and maxHeight.
    */
    {
        if (!$this->image) {
            return FALSE;
        }
        $oldWidth = imageSX($this->image);
        $oldHeight = imageSY($this->image);
        $newWidth= $maxWidth;
        $newHeight= $maxHeight;
        if (!$stretch) {
            $ratio = $oldWidth / $oldHeight;
            if (($maxWidth  / $maxHeight) < $ratio) {
                $newHeight = ($oldHeight / ($oldWidth / $maxWidth));
            } else {
                $newWidth = ($oldWidth / ($oldHeight / $maxHeight));
            }
        }
        $imageNew = ImageCreateTrueColor($newWidth, $newHeight);
        imageCopyResampled($imageNew, $this->image, 0, 0, 0, 0, $newWidth,
$newHeight, $oldWidth, $oldHeight);
        imageDestroy($this->image);
        $this->image = $imageNew;
        return TRUE;
    }
    function resizeCropped($width, $height)
    /*
    resizes an image to the width and height arguments.
    If needed parts of the image will be cropped to remain proportions
    ** note this is a function I quickly hacked in, I hope it works ok,
       but I haven't had a chance to properly test it, or to review the code
I wrote here yet
    */
    {
        if (!$this->image) {
            return FALSE;
        }
        $oldWidth = imageSX($this->image);
        $oldHeight = imageSY($this->image);
        $ratioW = $oldWidth / $width;
        $ratioH = $oldHeight / $height;
        if ($ratioH > $ratioW) {
            // some parts from the height will have to be cut off
            $newWidth = $oldWidth;
            $newHeight = $height * $ratioW;
            $srcX = 0;
            $srcY = +($oldHeight - $newHeight) / 2;
        } else {
            // some parts from the width will have to be cut off
            $newWidth = $width * $ratioH;
            $newHeight = $oldHeight;
            $srcX = +($oldWidth - $newWidth) / 2;
            $srcY = 0;
        }
        $imageNew = ImageCreateTrueColor($newWidth, $newHeight);
        imageCopyResized($imageNew, $this->image, 0, 0, $srcX, $srcY,
$oldWidth, $oldHeight, $oldWidth, $oldHeight);
        imageDestroy($this->image);
        $this->image = $imageNew;
        // Now we are actually going to resample the image to the correct
size
        $oldWidth = $newWidth;
        $oldHeight = $newHeight;
        $newWidth = $width;
        $newHeight = $height;
        $imageNew = ImageCreateTrueColor($newWidth, $newHeight);
        imageCopyResampled($imageNew, $this->image, 0, 0, 0, 0, $newWidth,
$newHeight, $oldWidth, $oldHeight);
        imageDestroy($this->image);
        $this->image = $imageNew;
        return TRUE;
    }
}
?>
ciao
Andrea

 le immagini sono molto sgranate segno che usi le gd male
Boh, a me non sembrano così male.
L'unica cosa che mi viene in mente è che ho usato la funzione
imagecopyresized piuttosto che la imagecopyresampled... ma questo l'ho fatto
apposta perché la prima è più veloce e appesantisce di meno il server.
E poi per l'output con imagejpeg ho lasciato una qualità piuttosto bassa....
In fondo sono solo thumbnails, mica devono essere a risoluzione
fotografica!!!
Questo ovviamente a mio parere... comunque grazie per il consiglio.
Luca
http://www.krakatoa.it/

 
http://www.krakatoa.it/
e poi se devo dirtela tutta anche l'uso dei frame lo sconsiglierei anche al
mio peggior nemico, sopratutto quando hai un linguaggio server(PHP) che ti
crea le pagine
sinceramente
tu hai chiesto consigli e io te li ho dati ^__^, e poi ti è andata bene che
ho fatto una visitina volante al tuo sito ^__^
ciao
Andrea

 Andrea
Ciao
Luca
http://www.krakatoa.it/

 non mi sembra roba da poco ^___^
Sicuramente hai ragione... e farò in modo di creare le thumb (con
imagecopyresampled) una sola volta e salvarle su disco per poi ripescarle
per gli accessi successivi...
Sarà che mi faccio troppi scrupoli di spreco di spazio!   :-D
Grazie di nuovo per i suggerimenti!
Ciao
Luca
http://www.krakatoa.it/

 Sarà che mi faccio troppi scrupoli di spreco di spazio!   :-D
Fatto... vedi se ti piacciono di più così... :-)
Ciao
Luca
http://www.krakatoa.it/


molto molto meglio ^_^
poi posso dirti che il layout è compatibile anche con i mozilla 
like(quindi netscape e i fratellini opensource di linux[da cui l'ho 
visitato] e altri so)
ciao
Andrea
ps. cavolo ne hai di foto ^_^, e giri parecchio ... beato te .. io sono 
sempre fossilizzato davanti ai miei computer

 sempre fossilizzato davanti ai miei computer
Macché... guarda che sono le foto di 4 (QUATTRO) anni!!!
Pure io sto sempre al PC o sui libri :-((
Ciao
Luca
http://www.krakatoa.it/