Ego_Image.php

gehe zur Dokumentation dieser Datei

<?php
class Ego_Image_Exception extends Exception {
    const  INIT_FAILED = 1; 
}
 
class Ego_Image {
    const EXIF_ALL = 0;
    const EXIF_COPYRIGHT = 1;
 
    public $image = '';
 
    private $vector = false;
 
    private $icon = false;
 
    private $avif = false;
 
    private $imagick = null;
 
    public function __construct($file = '') {
        if ($file) {
            $this->load($file);
        }
    }
 
    public function __destruct() {
        $this->free();
    }
 
    public function load($file) {
        $this->free();
 
        // Vektorgrafik erkennen und nicht mit Imagick bearbeiten
        try {
            require_once 'base/Ego_MimeType.php';
            $mime = new Ego_MimeType();
            $mime_type = $mime->autoDetect($file);
 
            $this->vector = in_array($mime_type, array('image/svg', 'image/svg+xml', 'image/x-icon', 'image/vnd.microsoft.icon'));
            $this->icon = in_array($mime_type, array('image/x-icon', 'image/vnd.microsoft.icon'));
            $this->avif = $mime_type == 'image/avif';
 
            $this->imagick = $this->vector || $this->icon ? null : new Imagick($file);
 
            if (!$this->vector) {
                $this->image = $this->imagick->getImageFilename();
                $this->imagick->setImageOrientation(Imagick::ORIENTATION_TOPLEFT);
 
                // AVIF Features aktivieren
                if ($this->avif) {
                    $this->imagick->setImageFormat('avif');
                }
            } else {
                $this->image = $file;
            }
        } catch (Exception $e) {
            throw new Ego_Image_Exception($e->getMessage(), Ego_Image_Exception::INIT_FAILED);
        }
    }
 
    public function isVector() {
        return $this->vector;
    }
 
    public function save($file, $type = '', $quality = 100) {
        if ($this->vector) {
            return Ego_System::copy($this->image, $file);
        }
 
        if (in_array($type, ['jpg', 'jpeg', 'webp', 'avif'])) {
            $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()) {
        if ($this->vector) {
            return;
        }
 
        $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();
            }
        };
 
        $grayscale = function(Imagick &$image) {
            $image->setImageType(Imagick::IMGTYPE_GRAYSCALEMATTE);
        };
 
        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 grayscale() {
        $this->modify('grayscale');
    }
 
    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) {
        if ($this->vector) {
            return;
        }
 
        $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 = []) {
        if ($this->vector) {
            return null;
        }
 
        $type = $params['type'] ?? 'png';
 
        $this->imagick->setImageFormat($type);
        $this->imagick->scaleImage($width, $height ? $height : $width, true);
        $this->imagick->setImageAlphaChannel(Imagick::VIRTUALPIXELMETHOD_WHITE);
 
        Ego_System::mkdir($GLOBALS['egotec_conf']['bin_dir'] . 'tmp');
        $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 convert($format, $params = []) {
        if (!$this->vector) {
            $this->imagick->setImageFormat($format);
 
            if (!empty($params['output'])) {
                // Datei in übergebenen Pfad ablegen
                $file = $params['output'];
                if (!Ego_System::file_exists($file)) {
                    Ego_System::file_put_contents($file, '');
                }
            } else {
                // Datei in temporären Pfad ablegen
                Ego_System::mkdir($GLOBALS['egotec_conf']['bin_dir'] . 'tmp');
                $file = tempnam($GLOBALS['egotec_conf']['bin_dir'] . 'tmp', 'converted_' . $format);
            }
            if ($this->save($file, $format, $params['quality'] ?? $GLOBALS['egotec_conf']['image']['quality'] ?? 100)) {
                return $file;
            } elseif (empty($params['output'])) {
                @unlink($file);
            }
        }
        return null;
    }
 
    public function getDiffImage($file) {
        if ($this->vector) {
            return null;
        }
 
        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->vector ? 0 : $this->imagick->getImageWidth();
    }
 
    public function getImageHeight() {
        return $this->vector ? 0 : $this->imagick->getImageHeight();
    }
 
    public function getImageType() {
        if ($this->vector) {
            return 'svg';
        }
 
        $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';
                case 18:
                    return 'webp';
                case 19:
                    return 'avif';
            }
        }
        return '';
    }
 
    public function getMimeType() {
        return $this->vector ? 'image/svg+xml' : $this->imagick->getImageMimeType();
    }
 
    public function getExif(int $entry = self::EXIF_ALL) {
        if (
            !$this->vector
            && 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:
                    $copyrightKey = '';
 
                    foreach ($GLOBALS['site']->conf['exif']['import']['default'] as $field) {
                        if ($field['copyright']) {
                            $copyrightKey = $GLOBALS['site']->admin['exif_import']['exif_' . md5($field['title']) . '_keys'];
                            break;
                        }
                    }
 
                    if ($copyrightKey && $data[$copyrightKey]) {
                        $value = $data[$copyrightKey];
                    } else {
                        $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;
    }
 
    public function importExif(): array {
        if ($this->vector) {
            return [];
        }
 
        $imageData = [];
        $fields = array_merge((array) $GLOBALS['site']->conf['exif']['import']['default'], (array) $GLOBALS['site']->conf['exif']['import']['custom']);
 
        // EXIF-Daten auslesen
        $exifData = @exif_read_data($this->imagick->getImageFilename()) ?: [];
 
        // IPTC-Daten auslesen
        getimagesize($this->imagick->getImageFilename(), $info);
        $iptcData = @iptcparse($info ? (string) $info['APP13'] : '') ?: [];
 
        $getData = function($item) use ($exifData, $iptcData) {
            if ($item['copyright']) {
                return $this->getExif(self::EXIF_COPYRIGHT);
            }
 
            $keyString = $GLOBALS['site']->admin['exif_import']['exif_' . md5($item['title']) . '_keys'];
            $value = [];
 
            if ($keyString && ($keys = explode(',', $keyString))) {
                foreach ($keys as $key) {
                    $value = $exifData[$key] ?? $iptcData[$key] ?? [];
 
                    if ($value) {
                        break;
                    }
                }
            }
 
            return $value;
        };
 
        foreach ($fields as $field) {
            if ($GLOBALS['site']->admin['exif_import']['exif_' . md5($field['title']) . '_keys']) {
                $imageData[] = array_merge($field, ['value' => $getData($field)]);
            }
        }
 
        return $imageData;
    }
 
    public static function getDimensions($file) {
        $fallback = function() use ($file) {
            try {
                $image = new Ego_Image($file);
                return [$image->getImageWidth(), $image->getImageHeight()];
            } catch (Exception $e) {
                return [0, 0];
            }
        };
 
        try {
            $size = getimagesize($file);
            if (empty($size) || ($size[0] === 0 && $size[1] === 0)) {
                return $fallback();
            }
            return $size;
        } catch (Exception $e) {
            return $fallback();
        }
    }
}