[PILLOLA] upload+resize+thumbnails

[mircov]

Io ho modificato la classe in questo modo

class Image
     {
        var $src_filename;
        var $src_witdh;
        var $src_height;
        var $src_type;
        var $src_attr;
        var $src_image; 

        function Image($filename)
                {
                   $this->src_filename = $filename;
                   $this->GetImageInfo();
                }

        function GetImageInfo()
                {
                   list($this->src_width,$this->src_height, $this->src_type, $this->src_attr) =  getimagesize($this->src_filename);
                }

        function CreateSourceImage()
                {
                   switch ($this->src_type)
                         {
                            case 1:
                            $this->src_image =imagecreatefromgif($this->src_filename);
                            break;

                            case 2:
                            $this->src_image =imagecreatefromjpeg($this->src_filename);
                            break;

                            case 3:
                            $this->src_image =imagecreatefrompng($this->src_filename);
                            break;

                            default: return false;
                         }
                   return true;
                }

        function GetHeight ($height , $width, $side)
                {
                   if ($height > $width)
                     {
                        $side = $side;
                     }
		           elseif ($height < $width)
		             {
			            $side = ($height*$side)/$width;
			         }
                }
		
		function SaveProportionateImage($filename, $quality, $height)
                {
                   $dest_height = $this->GetHeight($this->src_height , $this->src_width , $height);
                   
			$ratio = $this->src_height / $dest_height;
                   $dest_image = imagecreatetruecolor( $this->src_width / $ratio,$dest_height);

                   imagecopyresampled($dest_image, $this->src_image, 0, 0, 0, 0,$this->src_width / $ratio,$this->src_height / $ratio,$this->src_width,$this->src_height);
                   
                   imagejpeg($dest_image, $filename, $quality);

                   imagedestroy($dest_image);
                } 

        function Free()
                {
                   imagedestroy($this->src_image);
                }
     }

Ho preparato una pagina di test ma niente. La classe non funziona. L'errore sta nel modo in cui ho definito le variabili. Lo so perchè sia la classe che la funzione, prese singolarmente, funzionano. Il problema nasce nel momento in cui tento di implementare la funzione nella classe. Ho evidenziato in rosso la funzione in questione (quella da me creata) ed in arancione la funzione che crea l'immagine. Spero che qualcuno riesca a sistemare le variabili! Grazie mille!

[andrea.paiola]

1) Se non sbaglio mel tuo codice non hai preso in considerazione se l'immagine ha altezza e larghezza uguali !
2) La variabile $side da dove salta fuori? è uguale a $height no? perchè $heigth la passi due volte alla funzione? Sono un po' confuso...

[mircov]

Giusto! Me ne ero accorto ma mi ero ripromesso di correggere il codice una volta capito come dovevo utilizzare le variabili.
$side viene impostata nella funzione SaveProportionateImage($filename, $quality, $height) (sarebbe $height)
Ho tentato, infatti, di far richiamare la funzione GetHeight passando l'altezza impostata in SaveProportionateImage().
Poi fa i vari controlli e dovrebbe restituirmi l'altezza giusta.

Solo che io non so come si debbano richiamare le funzioni di una classe all'interno di altre funzioni della stessa classe e lo stesso vale per le variabili.

[andrea.paiola]

leggiti questo
Se crei una class pubblica la puoi riutilizzare quando e come ti pare...

[mircov]

E io che ci faccio con quel documento?
Non mi spiega niente che non sappia già o che mi serva!
Io non ho php 5!

[andrea.paiola]

[supersaibal]Originariamente inviato da mircov
E io che ci faccio con quel documento?
Non mi spiega niente che non sappia già o che mi serva!
Io non ho php 5! [/supersaibal]

OOPS ho toppato! Mi dispiace ma non conosco la programmazione ad oggetti con PHP != 5 ...

[mircov]

Si ma qua il problema non è nella classe!
Bisogna solo rendere la variabile $side usufruibile da SavePrportionateImage()!
Niente di più! Il resto credo vada bene!

E se invece di $side scrivessi $this->side = operazione da effettuare?

[andrea.paiola]

mmm... $this si riferisce all'oggetto...
Variabili globali e locali:
Le variabili globali sono le variabili definite all'esterno di funzioni, nello script principale e che possono essere utilizzate da tutto il programma PHP escluso all'interno di funzioni. Viceversa per variabili locali intendiamo solo quelle contenute all'interno di funzioni, che non potranno essere usate all'esterno delle stesse.

Detto questo se immaginiamo una situazione dove due variabili hanno lo stesso nome ma sono diverse fra loro ossia una locale e l'altra globale, possiamo stare tranquilli che l'una non influenzerà l'altra e viceversa.
Esempio:
$a = 5;
$c = abc();
function abc(){
$a = 10+3;
print $a."\n";
}
print $a;
Scriveremo:
13
5

Visto quello asserito in precedenza possiamo dire che in questo caso le due variabili sono distinte fra loro e con due valori ben diversi.




Global:
Si può verificare un'eccezione alla regola globale/locale se per qualsiasi motivo vogliamo usare direttamente una variabile globale all'interno di una funzione.
Il problema si risolve con il comando global. Per capire basta vedere l'esempio qua sotto.
Esempio:
$a = 5;
$c = abc();
function abc(){
global $a;
print $a."\n";
}
print $a;
Scriveremo:
5
5




Riferimento a variabili:
Come nel linguaggio C possiamo riferirci alle variabili. Il problema nasce nel momento in cui manipoliamo una variabile globale in una funzione e vogliamo che cambi valore anche esternamente.
Risolviamo il tutto richiamando la funzione non con il nome della variabile, ma con il suo riferimento al nome.

La sintassi prevede di dichiarare la variabile fra le proprietà della funzione con il simbolo & (e commerciale) che la precede.
esempio:
$a = 5;
print $a."
";
$c = abc($a);
function abc(&$a){
$a++;
print $a."
";
}
print $a."
";
Scriveremo:
5
6
6
Da adesso il valore della variabile globale resterà variato con il

[andrea.paiola]

Visibilita' delle variabili
Le variabili globali sono quelle definite all'esterno della funzione (nella parte principale dello script); viceversa, le variabili locali sono quelle definite all'interno della funzione.

Se una variabile e' definita nel corpo principale di uno script PHP (non all'interno di una funzione o di una classe), e' visibile globalmente.

L'unico modo per rendere le variabili di uno script disponibili per un altro script, e' di passarle con i cookies, con il metodo GET oppure con il metodo PUT.

Per accedere ad una variabile globale dall'interno di una funzione, occorre utilizzare la parola global.
Esempio:
<?// $numero e' una variabile globale nello script principale
$numero = 3;

function prova() {

global $numero; // Con l'istruzione global si rende visibile la variabile
// all'interno della funzione
echo $numero;
}
?>
L'array $GLOBALS (array associativo), e' un meccanismo alternativo per accedere alle variabili con visibilita' globale.
Esempio:

function test() {
echo $GLOBALS ["var1"];
echo'

';
echo $GLOBALS ["var2"];
}
$var1="prima variabile";
$var2='seconda variabile';
test();



Ogni funzione possiede una propria visibilita'. La variabile creata all'interno di una funzione ha una visibilita' locale, vale a dire che e' disponibile solamente all'interno della funzione.
Qualsiasi variazione ad una variabile interna ad una funzione, non modifica il valore di un'eventuale variabile globale con lo stesso nome.

[andrea.paiola]

In PHP, dove tra l'altro non ci sono dichiarazioni di variabili, le regole
di scoping (o visibilità delle variabili) sono leggermente diverse da
quelle del linguaggio C o del Pascal.
Lo scope (ambito di visibilità) di una variabile è il contesto in cui
questa è definita. Di default tutte le variabili in PHP hanno uno scope
singolo.
Una variabile usata al di fuori di una funzione ha scope globale e basta e
non è disponibile di default all'interno di una funzione definita
dall'utente, perchè lo scope globale non è ereditato implicitamente dalle
funzioni come in C. Questa è una misura di sicurezza per impedire che per
errore una funzione definita dall'utente cambi inavvertitamente il valore
di una variabile globale. Quindi quando usate una variabile all'interno di
una funzione viene ricercata per default solo nello scope locale della
funzione, mentre in C viene cercata prima nello scope locale e poi, se non
vi è trovata, viene implicitamente ricercata nello scope globale. Tutte le
variabili globali sono accessibili ad una funzione C se dichiarate o
definite prima della funzione, anche se la loro definizione o dichiarazione
è esterna alla funzione stessa.
$a = 1; /* global scope */
Function Test () {
echo $a; /* riferimento ad una variabile nello scope locale */
}
Test (); // non stampa niente, $a non è settata nello scope locale
Il programma precedente non stampa niente, perchè $a viene ricercata solo
nello scope locale, dove non è settata. In C invece una variabile globale
come $a, definita o dichiarata prima di una funzione, oppure dichiarata
all'interno di una funzione (come variabile extern) è automaticamente
disponibile alla funzione, a meno che non venga mascherata da una
definizione locale con lo stesso nome. I programmatori C sappiano che
devono utilizzare sempre l'equivalente di extern del C in PHP, che è il
costrutto global, all'interno delle funzioni per importare variabili dallo
scope globale in quello locale se intendono utilizzarle; poichè lo scope
globale non viene ereditato nello scope locale, global è sempre necessaria
per accedere a variabili globali nello scope locale.
$a = 1; /* global scope */
Function Test () {
global $a;
echo $a; /* riferimento ad una variabile nello scope globale */
}
Test (); // stampa 1
Nel caso dobbiate accedere a più variabili, basta specificarne la lista
separata da virgole nel costrutto global, anziché usare più costrutti
global:
global var1, var2, ..., varn;
Naturalmente purchè la variabile globale venga settata prima della chiamata
della funzione, la funzione non ha problemi a vederla:
Function Test () {
global $a;
echo $a; /* riferimento ad una variabile nello scope globale */
}
$a = 1; /* global scope */
Test (); // stampa 1
################################################## #####
Function Test () {
global $a;
echo $a; /* riferimento ad una variabile non settata nello scope globale */
}
Test (); // non stampa niente
$a = 1; /* global scope */
Un'alternativa all'utilizzo del costrutto global per accedere a variabili
globali da uno scope locale consiste nell'uso dell'array (associativo)
$GLOBALS. In pratica in uno scope locale PHP importa di default un array
associativo globale in cui memorizza tutti i riferimenti alle variabili
globali create dal programma; in effetti quando si importa una variabile
con:
global $var;
questo equivale a creare un riferimento ad un elemento omonimo dell'array
$GLOBALS:
$var =& $GLOBALS["var"];
Questo array contiene le coppie nome=>valore di tutte le variabili globali,
quindi l'esempio precedente si può riscrivere in questo modo:
$a = 1; /* global scope */
Function Test () {
echo $GLOBALS["a"]; /* riferimento ad una variabile nello scope globale */
}
Test (); // stampa 1
Le variabili con scope locale sono normalmente disallocate dall'interprete
quando l'interpretazione di una funzione finisce, allo scopo di
economizzare lo spazio di memoria, così ogni volta che viene chiamata una
funzione, una variabile locale presenta un valore non settato.
Poniamo il caso in cui si debba utilizzare una variabile solamente
all'interno di una funzione e si voglia che il suo valore venga conservato
tra una chiamata e l'altra della funzione, come nel caso banale di una
funzione che conta il numero di volte che è stata chiamata. Una possibile
soluzione è utilizzare allo scopo una variabile globale ed importarla nello
scope locale con global:
function counts_itself()
{
global $i;
return ++$i;
}
echo counts_itself(); // stampa 1
echo counts_itself(); // stampa 2
echo counts_itself(); // stampa 3
Questo metodo funziona, ma presenta l'inconveniente che la variabile,
avendo scope globale, può essere accidentalmente alterata da codice
presente in questo scope e persino da funzioni che per sbaglio la
importino. Il nome scelto per la variabile è così comune come valore indice
che quasi certamente la variabile è esposta a questo rischio.
La soluzione consiste nel conferirle scope locale, ma tempo di vita
(lifetime) globale tramite una dichiarazione static, che è del tutto
analoga a quella del C:
function counts_itself()
{
static $i=0;
return ++$i;
}
echo counts_itself(); // stampa 1
echo counts_itself(); // stampa 2
echo counts_itself(); // stampa 3
In PHP non è necessario inizializzare la variabile scrivendo =0 dopo static
$i, ma è comunque bene farlo per ragioni di chiarezza del codice. In questo
modo si può avere una variabile globale $i che non avrà niente a che fare
con la $i vista da counts_itself e nello stesso tempo far sì che
quest'ultima sia permanente per tutta la durata del programma.