Ma che dire quando il nostro sosia è un personaggio famoso?

Ecco una semplice applicazione online che controlla se assomigliamo a qualche celebrità!

Si tratta di Celebrity Collage, e previa registrazione gratuita permette di uppare una vostra foto in primo piano, ed in automatico riconoscerà la vostra faccia e la metterà in confronto con il database delle celebrità…

Il risultato sarà un percentuale approssimativa di somiglianza ad alcune delle celebrità più somiglianti a noi!

Assolutamente da provare direi!

La tragica scomparsa di Michael Jackson, ha incrementato le vendite di accessori creati per “ricordare” michael jackson (ricordare è tra virgolette perché ovviamente i commercianti speculano su questo aspetto purtroppo).

La notizia non è ancora ufficiale, ma una mezza conferma è stata data da un rappresentate della MJJ Productions.

Il lancio dovrebbe essere previsto per Natale…

Dimensione: 8,5 cm x 5,5 cm

Colori: Bianco e Turchese con Brush Splatter.

A distanza di tempo mi sono accorto di numerosi bug che corrompevano la corretta esecuzione dello script ( è stata la mia prima classe php )

Esattamente oggi, l’ho riscritta e testata modificando anche i comandi di esecuzione, in modo da facilitarne ancor di più l’esecuzione.

Requisiti:

• PHP 5
• Permessi in Scrittura sulla Cartella

Iniziamo scaricando il file sorgente della libreria:

class Uploader {

		private $ext_ok = array();
		private $ext_no = array();
		private $ctrl_ext = false;
		private $owrite = true;
		private $max_size = 0;
		private $path_file = '';
		private $campo = '';
		private $errore = '';

		public function Uploader($campo)
		{
			$this->campo = $campo;
		}

		public function getError()
		{
			return $this->errore;
		}

		public function set_opt($opzione, $valore)
		{
			if($opzione == 'controllo estensione')
			{
				$this->ctrl_ext = (bool)$valore;
			}
			elseif($opzione == 'estensioni consentite')
			{
				$this->ext_ok = explode(',', $valore);
			}
			elseif($opzione == 'estensioni non consentite')
			{
				$this->ext_no = explode(',', $valore);
			}
			elseif($opzione == 'massima dimensione')
			{
				$this->max_size = (int)$valore;
			}
			elseif($opzione == 'sovrascrittura')
			{
				$this->owrite = (bool)$valore;
			}
		}

		public function upload($destinazione)
		{
			$file = $_FILES[$this->campo]['name'];
			$size = $_FILES[$this->campo]['size'];
			$temp = $_FILES[$this->campo]['tmp_name'];

			if($this->max_size != 0 && ($size > $this->max_size))
			{
				$this->errore = ERR_TOO_BIG;
				return false;
			}
			else
			{
				$err = 0;

				if($this->ctrl_ext)
				{
						// non consentite
						if(count($this->ext_no) != 0)
						{
							foreach($this->ext_no as $no)
							{
								if(trim($no) == $this->getExt($file))
								{
									$err = 1;
								}
							}
						}

					if($err == 0)
					{
						$ctrl = 0;

						if(count($this->ext_ok) != 0)
						{
							foreach($this->ext_ok as $ok)
							{
								if(trim($ok) == $this->getExt($file))
								{
									$ctrl = 1;
								}
							}
						}
						else
						{
							$ctrl = 1;
						}

						if($ctrl == 0)
						{
							$err = 1;
						}
					}
				}

				if($err == 0)
				{
					if($this->owrite)
					{
						$this->path_file = $file;
					}
					else
					{
						if(file_exists($destinazione.$file))
						{
							$cas = md5(rand(0,9999999999));

							$nome = $this->dividi($file);

							$iniziali = substr($nome, 0, 3);

							$estensione = $this->getExt($file);

							$this->path_file = $iniziali.$cas.'.'.$estensione;
						}
						else
						{
							$this->path_file = $file;
						}
					}

					if(is_uploaded_file($temp))
					{
						if(move_uploaded_file($temp, $destinazione.$this->path_file))
						{
							return true;
						}
						else
						{
							$this->errore = ERR_UPLOAD;
							return false;
						}
					}
					else
					{
						$this->errore = ERR_UPLOAD;
						return false;
					}
				}
				else
				{
					$this->errore = ERR_WRONG_EXT;
					return false;
				}
			}
		}

		private function getExt($path)
		{
			$file_split = explode(".", $path);

			$estensione = array_pop($file_split);

			return $estensione;
		}

		private function dividi($nome)
		{
		   $file_split = explode(".", $nome);

			$estensione = array_pop($file_split);

			$len_ext = strlen($estensione);

			$nomef = substr($nome, 0, (strlen($nome) - ($len_ext + 1)));

			return $nomef;
		}

		public function getName()
		{
			return $this->path_file;
		}

	}

Ed ora veniamo all’utilizzo della classe stessa:

Definiamo il testo degli errori con la sintassi:

define(’ERR_TOO_BIG’, ‘Il File è troppo Grande!’);
define(’ERR_WRONG_EXT’, ‘Estensione non Consentita!’);
define(’ERR_UPLOAD’, ‘Errore nell\’Upload del File’);

Ora includiamo la libreria con:

include(”libs/upload.inc.php”);

Istanziamo la classe con la variabile $up passando come riferimento della funzione il nome del campo di tipo file che ha inviato il dato:

$up = new Uploader(’userfile’);

Ora veniamo alle opzioni, si usa la funzione set_opt(parametro, valore) come in questo esempio:

$up->set_opt(’controllo estensione’, true); // impone di controllare l’estensione, quindi richiede l’opzione delle estensioni non consentite OPPURE quella delle opzioni consentite.

$up->set_opt(’estensioni non consentite’, ‘txt, png’); // indica quali estesioni non sono consentite (separate con una virgola)

// $up->set_opt(’estensioni consentite’, ‘jpg, bmp’); // indica quali estesioni  sono consentite (separate con una virgola)

$up->set_opt(’sovrascrittura’, false); // indica che il file verrà rinominato invece di essere sovrascritto in caso esistesse gia

Dopo aver impostato lo script, lanciate il comando di upload e come parametro impostate il percorso dove andrà salvato il file:

if(!$up->upload(’files/’))
{
die($up->getError());
}

La funzione ritorna un risultato booleano con il quale potrete richiamare la funzione getError() in caso di errore nell’upload, oppure getName() che ritorna il nome del file uppato in caso di riuscita.

Qui in allegato tutti i file pronti da scaricare: Classe Upload

Ecco le regole per partecipare…

1. Potranno partecipare al contest tutti i blog che abbiano  a partire dalla data di creazione di questo post almeno 25 articoli, un mese di vita e che risultino essere indicizzati.
2. er partecipare dovrete scrivere un articolo in cui venga descritto il contest, le modalità di partecipazione ed i premi in palio.
3. Linkare Concorsomania e Zuzù Factory con i codici seguenti: CODICI
4. Infine dovrà essere presente un link alla pagina del contest. Fatto ciò , segnalate il link del vostro articolo nei commenti, indicando un numero da 1 a 90.

Potete verificare i numeri disponibili da qui: http://spreadsheets.google.com/pub?key=r2YekYFZagsaqH9PxzbvHQA

I premi:

1° Estratto : iPod Shuffle 4Gb con funzionalità VoiceOver. Il colore ed l’incisione saranno scelti dal vincitore.

2° Estratto : 2° T-shirts a scelta fra quelle presenti nello shop di Zuzù Factory

3° Estratto : 1° T-shirt   a scelta fra quelle presenti nello shop di Zuzù Factory

Mi raccomando, partecipate in tanti… in contest scade all’occupazione di tutti i numeri, e l’estrazione avverrà con i numeri del Lotto!

Ecco come ti scopro l’invisibile!

Ecco quello che dovete fare….

1. Effettuate l’accesso al vostro Account di MSN Messenger.

2. Selezionate il contatto da monitorare ed invitatelo a condividere una cartella con voi (Cartella Condivisa)

3. Se non ricevete nulla, il vostro amico non è online, Se invece è invisibile, ogni volta che entrerà in questo stato sarete avvisati dal messaggio di apertura della cartella condivisa…

Non ho ancora provato, ma se quando l’utente è connesso la cartella condivisa viene aperta indipendentemente dallo stato dell’utente, forse anche quando qualcuno ci ha bloccato possiamo vederlo con questo sistema… non ci resta che provare…

Se volete, commentate le vostre prove nei commenti…

Fonte | Tecnorati

Un’intera giornata a lavorare con le tonalità e saturazioni magari….

Oggi vi presento Color Picker, gia il nome dice tutto:

Color Picker è una penna dotata di uno scanner sulla punta in grado di individuare il colore RGB dell’oggetto semplicemente appoggiandola su di esso.

La penna è dotata di tre cartucce RGB, le quali miscelandosi, ricreeranno la tonalità esatta del colore scansionato.

Fonte | Tecnorati.it

Detto questo, torniamo sull’argomento Wordpress…

Ma come? E’ da poco uscita la 2.7.1 e già è prevista la 2.8 proprio in questo mese?

Ma sveliamo un pò cosa ci riserva questa nuova versione…

Alcune delle nuove caratteristiche:

• Migliorate le prestazioni del caricamento degli script.
• Installazione dei temi direttamente dal pannello d’amministrazione senza toccare l’ftp.
• Filtro contro gli XSS
• Nuove icone nel pannello di amministrazione
• Installazione plugin dal pannello di controllo.
• Performance migliorate
• Creazione Sitemap senza bisogno di plugin
• Possibilità di bloccare le richieste http in uscita.

E molte altre ancora che potete leggere direttamente sul sito: http://codex.wordpress.org/Version_2.8

Il Display è da 17″ on Full HD e risoluzione WUXGA, abbinato ad una scheda video GeForce GTX260M con 1GB di memoria GDDR3, 3 slot per la RAM espandibile fino a 12GB e 2 dischi fissi da 500GB l’uno.

In più troviamo il lettore Blu-Ray abbinato agli speaker Altec Lansing…

E’ ancora presto per parlare di prezzi e disponibilità, ma indipendentemente dal suo costo, sicuramente varrà fino all’ultimo centesimo!!!

Quante volte ci è capitato di dover effettuare una miniatura di un immagine via php, molte volte ci si dimentica le funzioni e i loro parametri, poi bisogna usare la funzione adatta al tipo di immagine da manipolare, ecc… ecc…

Oggi vi presento questa nuova classe php che ho nominato: Thumb And Crop ovvero rimpicciolisci e ritaglia.

Grazie a questa classe potremo:

- Ottenere le dimensioni di un immagine

- Ottenere le dimensioni di un immagine mantenendo le proporzioni

- Creare una miniatura di un immagine

- Ritagliare un pezzo di un immagine

- Combinare la funzione Crop alla Thumb per avere una foto ritagliata e rimpicciolita

- Manipolare un immagine Jpeg, Gif, Png, Bmp senza cambiare il codice in base al tipo di immagine.

Veniamo ora al codice della classe:

< ?php
	class ThumbAndCrop
	{

		private $handleimg;
		private $original = "";
		private $handlethumb;
		private $oldoriginal;

		/*
			Apre l'immagine da manipolare
		*/
		public function openImg($file)
		{
			$this->original = $file;

			if($this->extension($file) == 'jpg' || $this->extension($file) == 'jpeg')
			{
				$this->handleimg = imagecreatefromjpeg($file);
			}
			elseif($this->extension($file) == 'png')
			{
				$this->handleimg = imagecreatefrompng($file);
			}
			elseif($this->extension($file) == 'gif')
			{
				$this->handleimg = imagecreatefromgif($file);
			}
			elseif($this->extension($file) == 'bmp')
			{
				$this->handleimg = imagecreatefromwbmp($file);
			}
		}

		/*
			Ottiene la larghezza dell'immagine
		*/
		public function getWidth()
		{
			return imageSX($this->handleimg);
		}

		/*
			Ottiene la larghezza proporzionata all'immagine partendo da un'altezza
		*/
		public function getRightWidth($newheight)
		{
			$oldw = $this->getWidth();
			$oldh = $this->getHeight();

			$neww = ($oldw * $newheight) / $oldh;

			return $neww;
		}

		/*
			Ottiene l'altezza dell'immagine
		*/
		public function getHeight()
		{
			return imageSY($this->handleimg);
		}

		/*
			Ottiene l'altezza proporzionata all'immagine partendo da una larghezza
		*/
		public function getRightHeight($newwidth)
		{
			$oldw = $this->getWidth();
			$oldh = $this->getHeight();

			$newh = ($oldh * $newwidth) / $oldw;

			return $newh;
		}

		/*
			Crea una miniatura dell'immagine
		*/
		public function creaThumb($newWidth, $newHeight)
		{
			$oldw = $this->getWidth();
			$oldh = $this->getHeight();

			$this->handlethumb = imagecreatetruecolor($newWidth, $newHeight);

			return imagecopyresampled($this->handlethumb, $this->handleimg, 0, 0, 0, 0, $newWidth, $newHeight, $oldw, $oldh);
		}

		/*
			Ritaglia un pezzo dell'immagine
		*/
		public function cropThumb($width, $height, $x, $y)
		{
			$oldw = $this->getWidth();
			$oldh = $this->getHeight();

			$this->handlethumb = imagecreatetruecolor($width, $height);

			return imagecopy($this->handlethumb, $this->handleimg, 0, 0, $x, $y, $width, $height);
		}

		/*
			Salva su file la Thumbnail
		*/
		public function saveThumb($path, $qualityJpg = 100)
		{
			if($this->extension($this->original) == 'jpg' || $this->extension($this->original) == 'jpeg')
			{
				return imagejpeg($this->handlethumb, $path, $qualityJpg);
			}
			elseif($this->extension($this->original) == 'png')
			{
				return imagepng($this->handlethumb, $path);
			}
			elseif($this->extension($this->original) == 'gif')
			{
				return imagegif($this->handlethumb, $path);
			}
			elseif($this->extension($this->original) == 'bmp')
			{
				return imagewbmp($this->handlethumb, $path);
			}
		}

		/*
			Stampa a video la Thumbnail
		*/
		public function printThumb()
		{
			if($this->extension($this->original) == 'jpg' || $this->xtension($this->original) == 'jpeg')
			{
				header("Content-Type: image/jpeg");
				imagejpeg($this->handlethumb);
			}
			elseif($this->extension($this->original) == 'png')
			{
				header("Content-Type: image/png");
				imagepng($this->handlethumb);
			}
			elseif($this->extension($this->original) == 'gif')
			{
				header("Content-Type: image/gif");
				imagegif($this->handlethumb);
			}
			elseif($this->extension($this->original) == 'bmp')
			{
				header("Content-Type: image/bmp");
				imagewbmp($this->handlethumb);
			}
		}

		/*
			Distrugge le immagine per liberare le risorse
		*/
		public function closeImg()
		{
			imagedestroy($this->handleimg);
			imagedestroy($this->handlethumb);
		}

		/*
			Imposta la thumbnail come immagine sorgente,
			in questo modo potremo combinare la funzione crea con la funzione crop
		*/
		public function setThumbAsOriginal()
		{
			$this->oldoriginal = $this->handleimg;
			$this->handleimg = $this->handlethumb;
		}

		/*
			Resetta l'immagine originale
		*/
		public function resetOriginal()
		{
			$this->handleimg = $this->oldoriginal;
		}

		/*
			Estrae l'estensione da un file o un percorso
		*/
		private function extension($percorso)
		{
			if(eregi("[\|\\]", $percorso))
			{
				// da percorso
				$nome = $this->nomefile($percorso);

				$spezzo = explode(".", $nome);

				return strtolower(trim(array_pop($spezzo)));
			}
			else
			{
				//da file
				$spezzo = explode(".", $percorso);

				return strtolower(trim(array_pop($spezzo)));
			}
		}

		/*
			Estrae il nome del file da un percorso
		*/
		private function nomefile($path, $ext = true)
		{
			$diviso = spliti("[/|\\]", $path);

			if($ext)
			{
				return trim(array_pop($diviso));
			}
			else
			{
				$nome = explode(".", trim(array_pop($diviso)));

				array_pop($nome);

				return trim(implode(".", $nome));
			}
		}
	}
?>

Salviamo il file come thumbncrop.inc.php ed apriamo il file di esempio per provare la classe e scriviamo il seguente codice:

	// includo la classe
	require_once("libs/thumbncrop.inc.php");

	// valorizzo la variabile
	$tb = new ThumbAndCrop();

Come si può vedere abbiamo solamente incluso la classe, e valorizzato la variabile $tb.

Spiegazione delle funzioni:

In anzitutto la prima funzione da utilizzare obbligatoriamente è “openImg” passando come parametro il nome del file da aprire.

$tb->openImg(”ghi.jpg”);

Dopo-di-ché abbiamo le funzioni per ottenere le dimensioni dell’ immagine aperta:

$tb->getHeight();

$tb->getWidth();

Invece se dobbiamo ridimensionare l’immagine mantenendo le proporzioni basterà usare una di queste 2 funzioni, passando come parametro la larghezza/altezza di riferimento… esempio: dopo aver aperto l’immagine, se vogliamo ridimensionarla in larghezza a 100 pixels mantenendo l’altezza proporzionata, basterà usare la funzione “getRightHeight” passando come parametro, la larghezza indicativa ovvero 100.

$newHeight = $tb->getRightHeight(100);

$newWidth = $tb->getRightWidth(75);

Dopo aver calcolato le dimensioni passiamo ora a creare la miniatura con la funzione “creaThumb” e passando come parametro la larghezza e l’altezza da ottenere.

$tb->creaThumb(100, $newHeight);

Ora possiamo scegliere se printare a video l’immagine con la funzione “printThumb” (l’header verrà inviato in automatico non bisogna inserirlo a mano), oppure salvare l’immagine su disco con la funzione “saveThumb” passando come parametro il nome del file da creare, e nel caso sia un jpg anche la qualità dell’immagine finale (default: 100).

$tb->printThumb();

$tb->saveThumb(”cropthumb.jpg”);

Dopo-di-ché non ci resta che chiudere l’immagine aperta, per liberare le risorse con “closeImg”.

$tb->closeImg();

Oltre alla miniatura possiamo creare una piccola immagine contenente un ritaglio dell’immagine sorgente, basterà usare la funzione “cropThumb” prima di “closeImg”, infatti anche dopo aver usato l’immagine originale per creare una miniatura o ritagliare un pezzo dell’immagine, utilizzando di nuovo le funzioni senza chiudere l’immagine, potremo lavorare ancora sull’immagine originale…

Quindi potremo creare N miniature per volta usando semplicemente la funzione “creaThumb” e la stessa cosa vale anche per “cropThumb”.

La funzione “cropThumb” richiede 4 parametri, e sono larghezza finale, altezza finale, coordinata X dell’immagine originale dal quale iniziare a copiare l’immagine, coordinata Y dell’immagine originale dal quale iniziare a copiare l’immagine.

E se volessimo combinare le funzione rimpicciolisci e ritaglia? Ad esempio partendo da un’immagine 400×300, creare una miniatura 100×50 partendo a 20px dall’alto. Vediamo il codice in riferimento a quello precedentemente scritto:

	// creo la miniatura con le dimensioni da me volute
	$tb->creaThumb(100, $newHeight);

	// abilito il ThumbAndCrop
	$tb->setThumbAsOriginal();

	// taglio l'img a dimensione 100x50 artendo dalla thumb x:0, y:20
	$tb->cropThumb(100, 50, 0, 20);

Come possiamo vedere creiamo prima la miniatura da 400×300 (immagine originale) a 100×75 (miniatura proporzionata), dopo-di-ché usando la funzione “setThumbAsOriginal” setto la miniatura come immagine originale, quindi a partire da questo momento, ogni operazione fatta con le funzioni verrà effettuata sulla miniatura e non più sull’immagine originale! (per ripristinare l’immagine originale basterà utilizzare la funzione “resetOriginal”. Ed ora ritaglio un’immagine di 100×50 partendo dalle coordinate della miniature X:0 ed Y:20.

Spero che la classe vi possa essere utile, lasciate qualche commento se apprezzate!

Scarica i file di esempio: ThumbAndCrop