Efekt starego zdjęcia w PHP

Patryk Kuźmicz 2 komentarze

Gdybyś kiedyś wpadł na szalony pomysł i chciał wykorzystać PHP do "obróbki" zdjęć, np. przerobić zdjęcie tak by wyglądało na starsze i zniszczone, możesz wykorzystać kilka funkcjonalności biblioteki GD, efekt raczej nie powali nikogo kto korzystał z aplikacji typu Hipstamatic czy Instagram na iPhone, ale niektóre kombinację moga wyjść naprawdę całkiem ciekawe.

Co będziemy robić?

  1. Załadujemy zdjęcie
  2. Przytniemy zdjęcie do kwadratu (650x650)
  3. Pozmieniamy trochę kolory, poprzez modyfikację palety RGB
  4. Nałożymy "warstwę" - inny plik graficzny
  5. Zapiszemy przerobione zdjęcie

Kodujemy

Dla ułatwienia napisałem prostą klasę, zawierająca metody:

  • load_image - ładowanie zdjęcia,
  • crop - przycięcie zdjęcie do stałego rozmiaru
  • colorize - zabawa z filtrami i paletą RGB
  • layer - nałożenie warstwy, czyli innego obrazu na nasz z przezroczystością
  • save_image - zapisanie zdjęcia na dysku

load_image()

Funkcja ładuje plik z określonej lokalizacji, sprawdza jakiego typu jest to plik (jpg, png, gif) i wywołuje odpowiednią funkcję imagecreatefrom*, oraz pobiera jego wysokość i szerokość, dzięki takiej budowie nasz skrypt będzie w stanie obsługiwać automatycznie różne pliki graficzne.

PHP
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public function load_image($path) {
 
    $this->image = getimagesize($path);
    $this->image_x = $this->image[0];
    $this->image_y = $this->image[1];
 
    if( $this->image_x <= 0 || $this->image_y <= 0 ) return false; $this->image['format'] = strtolower(preg_replace('/^.*?//', '', $this->image['mime']));
 
    switch( $this->image['format'] ) {
            case 'jpg':
            case 'jpeg':
                $this->image_data = imagecreatefromjpeg($path);
                break;
            case 'png':
                $this->image_data = imagecreatefrompng($path);
                break;
            case 'gif':
                $this->image_data = imagecreatefromgif($path);
                break;
            default:
                return false;
                break;
        }
}
 

crop()

Funkcja crop, przycina nasze zdjęcie do rozmiaru $thumb_size, w tym przypadku do wielkości naszych warstw czyli 650x650. Przycinanie polega na ścięciu boków tak by uzyskać proporcjonalną szerokość do wysokości lub odwrotnie w przypadku zdjęć portretowych. W rezultacie otrzymuje kwadrat.

PHP
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
public function crop($thumb_size = 650, $jpg_quality = 90) {
 
    if( $this->image_x > $this->image_y ) {
        $x_offset = ($this->image_x - $this->image_y) / 2;
        $y_offset = 0;
        $square_size = $this->image_x - ($x_offset * 2);
    } else {
        $x_offset = 0;
        $y_offset = ($this->image_y - $this->image_x) / 2;
        $square_size = $this->image_y - ($y_offset * 2);
    }
 
    $this->crop_image = imagecreatetruecolor($thumb_size, $thumb_size);
 
    if( imagecopyresampled( $this->crop_image, $this->image_data, 0, 0, $x_offset, $y_offset, $thumb_size, $thumb_size, $square_size, $square_size )) {
    } else {
        return false;
    }
}
 

colorize()

To właśnie metoda colorize odpowiada za modyfikację palety RGB, zmieniając parametry dla funkcji imagefilter możemy uzyskać różne efekty.

PHP
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
public function colorize($method = 1) {
    switch( $method ) {
        case '1':
            imagefilter($this->crop_image, IMG_FILTER_COLORIZE, 30, -40, 10);
            imagefilter($this->crop_image,IMG_FILTER_GAUSSIAN_BLUR);
            break;
        case '2':
            imagefilter($this->crop_image,IMG_FILTER_BRIGHTNESS,10);
            imagefilter($this->crop_image,IMG_FILTER_BRIGHTNESS,-20);
            imagefilter($this->crop_image,IMG_FILTER_COLORIZE,30,30,30);
            imagefilter($this->crop_image,IMG_FILTER_COLORIZE,70,0,10);
            imagefilter($this->crop_image,IMG_FILTER_COLORIZE,0,10,0);
            imagefilter($this->crop_image,IMG_FILTER_COLORIZE,0,0,15);
            imagefilter($this->crop_image,IMG_FILTER_CONTRAST,15);
            imagefilter($this->crop_image,IMG_FILTER_BRIGHTNESS,-20);
            break;
        case '3':
            imagefilter($this->crop_image,IMG_FILTER_BRIGHTNESS,20);
            imagefilter($this->crop_image,IMG_FILTER_COLORIZE, 30, -99, -35, 40);
            imagefilter($this->crop_image,IMG_FILTER_GAUSSIAN_BLUR);
            imagefilter($this->crop_image,IMG_FILTER_CONTRAST,10);
            break;
        case '4':
            imagefilter($this->crop_image,IMG_FILTER_BRIGHTNESS,40);
            imagefilter($this->crop_image,IMG_FILTER_BRIGHTNESS,-20);
            imagefilter($this->crop_image,IMG_FILTER_COLORIZE, 10, -39, -85, 50);
            imagefilter($this->crop_image,IMG_FILTER_CONTRAST,15);
            break;
        default:
            break;
    }
}
 

layer()

Metoda layer służy do nałożenia naszej warstwy na zdjęcie, jest to nic innego jak nałożenie jednego pliku na drugi ($mark) z zachowaniem głębi ($depth).

PHP
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
public function layer($mark = 1, $depth = 15) {
 
    switch($mark) {
        case 1:
            $watermark_file = "layers/layer_1.png";
            break;
        case 2:
            $watermark_file = "layers/layer_2.png";
            break;
        case 3:
            $watermark_file = "layers/layer_3.png";
            break;
        case 4:
            $watermark_file = "layers/layer_4.png";
            break;
        default:
            break;
    }
 
    $watermark = imagecreatefrompng($watermark_file);
 
    $watermark_width = 650;
    $watermark_height = 650;
 
    imagecopymerge($this->crop_image, $watermark, 0, 0, 0, 0, $watermark_width, $watermark_height, $depth);
    imagedestroy($watermark);
}
 

save_image()

Meotda save_image zapisuje plik jako JPG w lokalizacji $path.

PHP
0
1
2
3
4
5
 
public function save_image($path) {
    imagejpeg($this->crop_image, $path);
    imagedestroy($this->crop_image);
}
 

Warstwy

Przykładowe 4 warstwy użyte w przykładzie:

Jeśli ktoś będzie miał ochotę się pobawić trochę więcej, polecam używać ciemnych zdjęć z dużą ilością jasnych dodatków.

Zdjęcie

Będziemy bazować na zdjęciu przedstawiającym Pałac Branickich w Białymstoku ;-)

Przykładowe użycie

Modyfikując wywołanie colorize(), oraz layer() zmieniamy warstwę oraz filtry.

$imgobj->colorize(2);
$imgobj->layer(2,20);


$imgobj->colorize(3);
$imgobj->layer(3,40);


$imgobj->colorize(4);
$imgobj->layer(4,30);

Jeśli komuś może się coś przydać z tego, to całość - przykładowe zdjęcie, klasa, skrypt, warstwy są do pobrania stąd. ;-)