Ego_Image.php

gehe zur Dokumentation dieser Datei

<?php
class Ego_Image {
    const EXIF_ALL = 0;
    const EXIF_COPYRIGHT = 1;

    public $image = '';

    private $imagick = null;

    public function __construct($file = '') {
        if ($file) {
            $this->load($file);
        }
    }

    public function __destruct() {
        $this->free();
    }

    public function load($file) {
        $this->free();
        $this->imagick = new Imagick($file);
        $this->image = $this->imagick->getImageFilename();

        $this->imagick->setImageOrientation(Imagick::ORIENTATION_TOPLEFT);
    }

    public function save($file, $type = '', $quality = 100) {
        if ($type == 'jpg' || $type == 'jpeg') {
            $this->imagick->setImageCompressionQuality($quality);
        }
        return $this->imagick->writeImages($file, true);
    }

    public function free() {
        if ($this->imagick) {
            $this->imagick->clear();
        }
    }

    private function modify($action, $params = array()) {
        $resize = function(Imagick &$image) use ($params) {
            $image->scaleImage($params['width'], $params['height'], $params['width'] && $params['height']);
        };

        $crop = function(Imagick &$image) use ($params) {
            $image->cropImage($params['width'], $params['height'], $params['x'], $params['y']);
            $image->setImagePage($params['width'], $params['height'], 0, 0);
        };

        $rotate = function(Imagick &$image) use ($params) {
            $image->rotateImage(new ImagickPixel('#00000000'), $params['deg']);
        };

        $mirror = function(Imagick &$image) use ($params) {
            if ($params['horizontal']) {
                $image->flopImage();
            }
            if ($params['vertical']) {
                $image->flipImage();
            }
        };

        if (isset($$action)) {
            if ($this->imagick->getNumberImages() > 1) {
                // Bei einer Animation muss die Aktion für jedes Frame ausgeführt werden
                $image = $this->imagick->coalesceImages();
                foreach ($image as $frame) {
                    $$action($frame);
                }
                $this->imagick = $image->optimizeImageLayers();
            } else {
                $$action($this->imagick);
            }
        } else {
            throw new Exception('Invalid modify action.');
        }
    }

    public function crop($x1, $y1, $x2, $y2) {
        $this->modify('crop', array(
            'width' => $x2 - $x1,
            'height' => $y2 - $y1,
            'x' => $x1,
            'y' => $y1
        ));
    }

    public function rotate($deg) {
        $this->modify('rotate', array(
            'deg' => $deg
        ));
    }

    public function mirror($vertical, $horizontal) {
        $this->modify('mirror', array(
            'vertical' => $vertical,
            'horizontal' => $horizontal
        ));
    }

    public function resize($width, $height) {
        $this->modify('resize', array(
            'width' => $width,
            'height' => $height
        ));
    }

    public function scaleByX($width) {
        $this->resize($width, 0);
    }

    public function scaleByY($height) {
        $this->resize(0, $height);
    }

    public function watermark($file) {
        $watermark = new Imagick($file);

        // Bei Bedarf das Wasserzeichen skalieren
        $image_w = $this->imagick->getImageWidth();
        $image_h = $this->imagick->getImageHeight();
        $watermark_w = $watermark->getImageWidth();
        $watermark_h = $watermark->getImageHeight();

        if ($image_w < $watermark_w || $image_h < $watermark_h) {
            $watermark->scaleImage($image_w, 0);
            $watermark_w = $watermark->getImageWidth();
            $watermark_h = $watermark->getImageHeight();
            if ($image_h < $watermark_h) {
                $watermark->scaleImage(0, $image_h);
                $watermark_w = $watermark->getImageWidth();
                $watermark_h = $watermark->getImageHeight();
            }
        }

        $x = floor(($image_w - $watermark_w) / 2);
        $y = floor(($image_h - $watermark_h) / 2);

        $this->imagick->compositeImage($watermark, Imagick::COMPOSITE_OVER, $x, $y);
    }

    public function thumbnail($width, $height, $params = []) {
        $type = $params['type'] ?? 'png';

        $this->imagick->setImageFormat($type);
        $this->imagick->scaleImage($width, $height ? $height : $width, true);
        $this->imagick->setImageAlphaChannel(Imagick::VIRTUALPIXELMETHOD_WHITE);

        $file = tempnam($GLOBALS['egotec_conf']['bin_dir'] . 'tmp', 'thumbnail');
        if ($this->save($file, $type, $params['quality'] ?? $GLOBALS['egotec_conf']['image']['quality'] ?? 100)) {
            return $file;
        }
        return null;
    }

    public function getDiffImage($file) {
        try {
            $result = $this->imagick->compareImages(new Imagick($file), Imagick::METRIC_MEANSQUAREERROR);
            return 'data:' . $result[0]->getImageMimeType() . ';base64,' . base64_encode($result[0]->getImageBlob());
        } catch (Exception $e) {
            return null;
        }
    }

    public function getImageWidth() {
        return $this->imagick->getImageWidth();
    }

    public function getImageHeight() {
        return $this->imagick->getImageHeight();
    }

    public function getImageType() {
        $data = @getimagesize($this->image);
        if (is_array($data)){
            switch($data[2]) {
                case 1:
                    return 'gif';
                case 2:
                    return 'jpeg';
                case 3:
                    return 'png';
                case 4:
                    return 'swf';
                case 5:
                    return 'psd';
                case 6:
                    return 'bmp';
                case 7:
                case 8:
                    return 'tiff';
            }
        }
        return '';
    }

    public function getMimeType() {
        return $this->imagick->getImageMimeType();
    }

    public function getExif($entry = self::EXIF_ALL) {
        if (
            function_exists('exif_read_data')
            && ($data = @exif_read_data($this->imagick->getImageFilename())) !== false
        ) {
            switch ($entry) {
                case self::EXIF_ALL:
                    return $data;
                case self::EXIF_COPYRIGHT:
                    $value = trim($data['Copyright'] ?? $data['COMPUTED']['Copyright'] ?? $data['Artist']);
                    if (empty($value) && isset($data['COMMENT'])) {
                        if (is_array($data['COMMENT'])) {
                            $value = implode($data['COMMENT'], ', ');
                        } else {
                            $value = $data['COMMENT'];
                        }
                    }
                    return trim(str_replace('©', '', $value));
            }
        }
        return null;
    }
}
?>