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:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295: 296: 297: 298: 299: 300: 301: 302: 303: 304: 305: 306: 307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329: 330: 331: 332: 333: 334: 335: 336: 337: 338: 339: 340: 341: 342: 343: 344: 345: 346: 347: 348: 349: 350: 351: 352: 353: 354: 355: 356: 357: 358: 359: 360: 361: 362: 363: 364: 365: 366: 367: 368: 369: 370: 371: 372: 373: 374: 375: 376: 377: 378: 379: 380: 381: 382: 383: 384: 385: 386: 387: 388: 389: 390: 391: 392: 393: 394: 395: 396: 397: 398: 399: 400: 401: 402: 403: 404: 405: 406: 407: 408: 409: 410: 411: 412: 413: 414: 415: 416: 417: 418: 419: 420: 421: 422: 423: 424: 425: 426: 427: 428: 429: 430: 431: 432: 433: 434: 435: 436: 437: 438: 439: 440: 441: 442: 443: 444: 445: 446: 447: 448: 449: 450: 451: 452: 453: 454: 455: 456: 457: 458: 459: 460: 461: 462: 463: 464: 465: 466: 467: 468: 469: 470: 471: 472: 473: 474: 475: 476: 477: 478: 479: 480: 481: 482: 483: 484: 485: 486: 487: 488: 489: 490: 491: 492: 493: 494: 495: 496: 497: 498: 499: 500: 501: 502: 503: 504: 505: 506: 507: 508: 509: 510: 511: 512: 513: 514: 515: 516: 517: 518: 519: 520: 521: 522: 523: 524: 525: 526: 527: 528: 529: 530: 531: 532: 533: 534: 535: 536: 537: 538: 539: 540: 541: 542: 543: 544: 545: 546: 547: 548: 549: 550: 551: 552: 553: 554: 555: 556: 557: 558: 559: 560: 561: 562: 563: 564: 565: 566: 567: 568: 569: 570: 571: 572: 573: 574: 575: 576: 577: 578: 579: 580: 581: 582: 583: 584: 585: 586: 587: 588: 589: 590: 591: 592: 593: 594: 595: 596: 597: 598: 599: 600: 601: 602: 603: 604: 605: 606: 607: 608: 609: 610: 611: 612: 613: 614: 615: 616: 617: 618: 619: 620: 621: 622: 623: 624: 625: 626: 627: 628: 629: 630: 631: 632: 633: 634: 635: 636: 637: 638: 639: 640: 641: 642: 643: 644: 645: 646: 647: 648: 649: 650: 651: 652: 653: 654: 655: 656: 657: 658: 659: 660: 661: 662: 663: 

<?php

/**
 * Library for image handling using the Imagick library of functions
 *
 * Requires Imagick 3.0.0+ and ImageMagick 6.3.8+
 *
 * @package core
 * @subpackage graphic-handlers\lib-imagick
 */
// force UTF-8 Ø

define('IMAGICK_REQUIRED_VERSION', '3.0.0');
define('IMAGEMAGICK_REQUIRED_VERSION', '6.3.8');

$_imagick_version = phpversion('imagick');
$_imagick_version_pass = version_compare($_imagick_version, IMAGICK_REQUIRED_VERSION, '>=');

$_imagemagick_version = '';
$_imagemagick_version_pass = false;

$_zp_imagick_present = extension_loaded('imagick') && $_imagick_version_pass;

if ($_zp_imagick_present) {
    @$_imagemagick_version = Imagick::getVersion();
    preg_match('/\d+(\.\d+)*/', $_imagemagick_version['versionString'], $matches);

    $_imagemagick_version['versionNumber'] = $matches[0];
    $_imagemagick_version_pass = version_compare($_imagemagick_version['versionNumber'], IMAGEMAGICK_REQUIRED_VERSION, '>=');

    $_zp_imagick_present &= $_imagick_version_pass;
    unset($matches);
}

$_zp_graphics_optionhandlers += array('lib_Imagick_Options' => new lib_Imagick_Options());

/**
 * Option class for lib-Imagick
 */
class lib_Imagick_Options {

    public static $ignore_size = 0;

    function __construct() {
        setOptionDefault('magick_max_height', self::$ignore_size);
        setOptionDefault('magick_max_width', self::$ignore_size);

        if (!sanitize_numeric(getOption('magick_max_height'))) {
            setOption('magick_max_height', self::$ignore_size);
        }

        if (!sanitize_numeric(getOption('magick_max_width'))) {
            setOption('magick_max_width', self::$ignore_size);
        }
    }

    /**
     * Standard option interface
     *
     * @return array
     */
    function getOptionsSupported() {
        global $_zp_imagick_present, $_zp_graphics_optionhandlers;
        if ($disabled = $this->canLoadMsg()) {
            setOption('use_imagick', 0, true);
        }
        $imagickOptions = array(
                        gettext('Enable Imagick') => array(
                                        'key'            => 'use_imagick',
                                        'type'       => OPTION_TYPE_CHECKBOX,
                                        'order'      => 0,
                                        'disabled' => $disabled,
                                        'desc'       => ($disabled) ? '<p class="notebox">' . $disabled . '</p>' : gettext('Your PHP has support for Imagick. Check this option if you wish to use the Imagick graphics library.')
                        )
        );

        if (!$disabled) {
            $imagickOptions += array(
                            gettext('Max height')    => array(
                                            'key'        => 'magick_max_height',
                                            'type'   => OPTION_TYPE_TEXTBOX,
                                            'order'  => 1,
                                            'desc'   => sprintf(gettext('The maximum height used by the site for processed images. Set to %d for unconstrained. Default is <strong>%d</strong>'), self::$ignore_size, self::$ignore_size)
                            ),
                            gettext('Max width')     => array(
                                            'key'        => 'magick_max_width',
                                            'type'   => OPTION_TYPE_TEXTBOX,
                                            'order'  => 2,
                                            'desc'   => sprintf(gettext('The maximum width used by the site for processed images. Set to %d for unconstrained. Default is <strong>%d</strong>.'), self::$ignore_size, self::$ignore_size)
                            )
            );
        }

        return $imagickOptions;
    }

    function canLoadMsg() {
        global $_imagick_version_pass, $_imagemagick_version_pass;

        if (extension_loaded('imagick')) {
            if (!$_imagick_version_pass) {
                return sprintf(gettext('The <strong><em>Imagick</em></strong> library version must be <strong>%s</strong> or later.'), IMAGICK_REQUIRED_VERSION);
            }

            if (!$_imagemagick_version_pass) {
                return sprintf(gettext('The <strong><em>ImageMagick</em></strong> binary version must be <strong>%s</strong> or later.'), IMAGEMAGICK_REQUIRED_VERSION);
            }
        } else {
            return gettext('The <strong><em>Imagick</em></strong> extension is not available.');
        }

        return '';
    }

}

/**
 * Zenphoto image manipulation functions using the Imagick library
 */
if ($_zp_imagick_present && (getOption('use_imagick') || !extension_loaded('gd'))) {
    $_lib_Imagick_info = array();
    $_lib_Imagick_info['Library'] = 'Imagick';
    $_lib_Imagick_info['Library_desc'] = sprintf(gettext('PHP Imagick library <em>%s</em>') . '<br /><em>%s</em>', $_imagick_version, $_imagemagick_version['versionString']);

    $_imagick_format_whitelist = array(
            'BMP' => 'jpg',
            'BMP2' => 'jpg',
            'BMP3' => 'jpg',
            'GIF' => 'gif',
            'GIF87' => 'gif',
            'JPG' => 'jpg',
            'JPEG' => 'jpg',
            'PNG' => 'png',
            'PNG8' => 'png',
            'PNG24' => 'png',
            'PNG32' => 'png',
            'TIFF' => 'jpg',
            'TIFF64' => 'jpg',
            'WEBP' => 'webp'
    );

    $_imagick = new Imagick();
    $_imagick_formats = $_imagick->queryFormats();
    foreach ($_imagick_formats as $format) {
        if (array_key_exists($format, $_imagick_format_whitelist)) {
            $_lib_Imagick_info[$format] = $_imagick_format_whitelist[$format];
        }
    }
    unset($_imagick_format_whitelist);
    unset($_imagick_formats);
    unset($_imagick);
    unset($format);

    if (DEBUG_IMAGE) {
        debugLog('Loading ' . $_lib_Imagick_info['Library']);
    }

    /**
     * Takes an image filename and returns an Imagick image object
     *
     * @param string $imgfile the full path and filename of the image to load
     * @return Imagick
     */
    function zp_imageGet($imgfile) {
        global $_lib_Imagick_info;

        if (array_key_exists(strtoupper(getSuffix($imgfile)), $_lib_Imagick_info)) {
            $image = new Imagick();

            $maxHeight = getOption('magick_max_height');
            $maxWidth = getOption('magick_max_width');

            if ($maxHeight > lib_Imagick_Options::$ignore_size && $maxWidth > lib_Imagick_Options::$ignore_size) {
                $image->setOption('jpeg:size', $maxWidth . 'x' . $maxHeight);
            }

            $image->readImage(filesystemToInternal($imgfile));

            //Generic CMYK to RGB conversion
            if ($image->getImageColorspace() == Imagick::COLORSPACE_CMYK) {
                $image->transformimagecolorspace(Imagick::COLORSPACE_SRGB);
            }

            return $image;
        }

        return false;
    }

    /**
     * Outputs an image resource as a given type
     *
     * @param Imagick $im
     * @param string $type
     * @param string $filename
     * @param int $qual
     * @return bool
     */
    function zp_imageOutput($im, $type, $filename = NULL, $qual = 75) {
        $interlace = getOption('image_interlace');
        $qual = max(min($qual, 100), 0);

        $im->setImageFormat($type);

        switch ($type) {
            case 'gif':
                $im->setImageCompression(Imagick::COMPRESSION_LZW);
                $im->setImageCompressionQuality($qual);
                if ($interlace) {
                    $im->setInterlaceScheme(Imagick::INTERLACE_GIF);
                }
                break;
            case 'jpeg':
            case 'jpg':
                $im->setImageCompression(Imagick::COMPRESSION_JPEG);
                $im->setImageCompressionQuality($qual);
                if ($interlace) {
                    $im->setInterlaceScheme(Imagick::INTERLACE_JPEG);
                }
                break;
            case 'png':
            case 'webp': // apparently there are no interlace and compression constants for webp so we just use the png setting
                $im->setImageCompression(Imagick::COMPRESSION_ZIP);
                $im->setImageCompressionQuality($qual);
                if ($interlace) {
                    $im->setInterlaceScheme(Imagick::INTERLACE_PNG);
                }
                break;
        }

        $im->optimizeImageLayers();

        if ($filename == NULL) {
            header('Content-Type: image/' . $type);

            return print $im->getImagesBlob();
        }

        return $im->writeImages(filesystemToInternal($filename), true);
    }

    /**
     * Creates a true color image
     *
     * @param int $w the width of the image
     * @param int $h the height of the image
     * @param bool $truecolor True to create a true color image, false for usage with palette images like gifs
     * @return Imagick
     */
    function zp_createImage($w, $h, $truecolor = true) {
        $im = new Imagick();
        $im->newImage($w, $h, 'none');
        if($truecolor) {
            $im->setImageType(Imagick::IMGTYPE_TRUECOLORMATTE);
        } else {
            $imagetype = $im->getImageType();
            $im->setImageType($imagetype);
        }
        return $im;
    }

    /**
     * Fills an image area
     *
     * @param Imagick $image
     * @param int $x
     * @param int $y
     * @param color $color
     * @return bool
     */
    function zp_imageFill($image, $x, $y, $color) {
        $target = $image->getImagePixelColor($x, $y);

        return $image->floodFillPaintImage($color, 1, $target, $x, $y, false);
    }

    /**
     * Sets the transparency color
     *
     * @param Imagick $image
     * @param color $color
     * @return bool
     */
    function zp_imageColorTransparent($image, $color) {
        return $image->transparentPaintImage($color, 0.0, 1, false);
    }

    /**
     * Copies an image canvas
     *
     * @param Imagick $imgCanvas destination canvas
     * @param Imagick $img source canvas
     * @param int $dest_x destination x
     * @param int $dest_y destination y
     * @param int $src_x source x
     * @param int $src_y source y
     * @param int $w width
     * @param int $h height
     * @return bool
     */
    function zp_copyCanvas($imgCanvas, $img, $dest_x, $dest_y, $src_x, $src_y, $w, $h) {
        $img->cropImage($w, $h, $src_x, $src_y);
        $result = true;
        foreach ($imgCanvas as $frame) {
            $result &= $frame->compositeImage($img, Imagick::COMPOSITE_OVER, $dest_x, $dest_y);
        }
        return $result;
    }

    /**
     * Resamples an image to a new copy
     *
     * @param Imagick $dst_image
     * @param Imagick $src_image
     * @param int $dst_x
     * @param int $dst_y
     * @param int $src_x
     * @param int $src_y
     * @param int $dst_w
     * @param int $dst_h
     * @param int $src_w
     * @param int $src_h
     * @return bool
     */
    function zp_resampleImage($dst_image, $src_image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h) {
        foreach ($src_image->getImageProfiles() as $name => $profile) {
            $dst_image->profileImage($name, $profile);
        }
        $result = true;
        $src_image = $src_image->coalesceImages();
        foreach ($src_image as $frame) {
            $frame->cropImage($src_w, $src_h, $src_x, $src_y);
            $frame->setImagePage(0, 0, 0, 0);
            $frame->resizeImage($dst_w, $dst_h, Imagick::FILTER_LANCZOS, 1);

            $dst_image->setImageDelay($frame->getImageDelay());
            $result &= $dst_image->compositeImage($frame, Imagick::COMPOSITE_OVER, $dst_x, $dst_y);

            if ($dst_image->getNumberImages() < $src_image->getNumberImages()) {
                $result &= $dst_image->addImage(zp_createImage($dst_image->getImageWidth(), $dst_image->getImageHeight()));
            }
            if (!$result) {
                break;
            }
        }
        return $result;
    }

    /**
     * Sharpens an image using an Unsharp Mask filter.
     *
     * @param Imagick $img the image to sharpen
     * @param int $amount the strength of the sharpening effect
     * @param int $radius the pixel radius of the sharpening mask
     * @param int $threshold the color difference threshold required for sharpening
     * @return Imagick
     */
    function zp_imageUnsharpMask($img, $amount, $radius, $threshold) {
        $img->unsharpMaskImage($radius, 0.1, $amount, $threshold);

        return $img;
    }

    /**
     * Resize a file with transparency to given dimensions and still retain the alpha channel information
     *
     * @param Imagick $src
     * @param int $w
     * @param int $h
     * @return Imagick
     */
    function zp_imageResizeAlpha($src, $w, $h) {
        $src->scaleImage($w, $h);
        return $src;
    }
    
    /**
     * Uses zp_imageResizeAlpha() internally as Imagick does not make a difference
     * 
     * @param type $src
     * @param type $w
     * @param type $h
     * @return type
     */
    function zp_imageResizeTransparent($src, $w, $h) {
        return zp_imageResizeAlpha($src, $w, $h);
    }

    /**
     * Returns true if Imagick library is configured with image rotation support
     *
     * @return bool
     */
    function zp_imageCanRotate() {
        return true;
    }

    /**
     * Rotates an image resource according to its Orientation setting
     *
     * @param Imagick $im
     * @param int $rotate
     * @return Imagick
     */
    function zp_rotateImage($im, $rotate) {
        $im->rotateImage('none', 360 - $rotate);
        return $im;
    }

    /**
     * Returns the image height and width
     *
     * @param string $filename
     * @param array $imageinfo
     * @return array
     */
    function zp_imageDims($filename) {
        $imageinfo = NULL;
        $rslt = getimagesize($filename, $imageinfo);
        if (is_array($rslt)) {
            return array('width' => $rslt[0], 'height' => $rslt[1]);
        } else {
            return false;
        }
    }

    /**
     * Returns the IPTC data of an image
     *
     * @param string $filename
     * @return string
     */
    function zp_imageIPTC($filename) {
        $imageinfo = NULL;
        $rslt = getimagesize($filename, $imageinfo);
        if (is_array($rslt) && isset($imageinfo['APP13'])) {
            return $imageinfo['APP13'];
        } else {
            return false;
        }
    }

    /**
     * Returns the width of an image resource
     *
     * @param Imagick $im
     * @return int
     */
    function zp_imageWidth($im) {
        return $im->getImageWidth();
    }

    /**
     * Returns the height of an image resource
     *
     * @param Imagick $im
     * @return int
     */
    function zp_imageHeight($im) {
        return $im->getImageHeight();
    }

    /**
     * Does a copy merge of two image resources
     *
     * @param Imagick $dst_im
     * @param Imagick $src_im
     * @param int $dst_x
     * @param int $dst_y
     * @param int $src_x
     * @param int $src_y
     * @param int $src_w
     * @param int $src_h
     * @param int $pct
     * @return bool
     */
    function zp_imageMerge($dst_im, $src_im, $dst_x, $dst_y, $src_x, $src_y, $src_w, $src_h, $pct) {
        $src_im->cropImage($src_w, $src_h, $src_x, $src_y);
        $src_im->setImageOpacity($pct / 100);

        return $dst_im->compositeImage($src_im, Imagick::COMPOSITE_OVER, $dst_x, $dst_y);
    }

    /**
     * Creates a grayscale image
     *
     * @param Imagick $image The image to grayscale
     * @return Imagick
     */
    function zp_imageGray($image) {
        $image->setType(Imagick::IMGTYPE_GRAYSCALE);
        $image->setImageColorspace(Imagick::COLORSPACE_GRAY);
        $image->setImageProperty('exif:ColorSpace', Imagick::IMGTYPE_GRAYSCALE);

        return $image;
    }

    /**
     * Destroys an image resource
     *
     * @param Imagick $im
     * @return bool
     */
    function zp_imageKill($im) {
        return $im->destroy();
    }

    /**
     * Returns an RGB color identifier
     *
     * @param Imagick $image
     * @param int $red
     * @param int $green
     * @param int $blue
     * @return ImagickPixel
     */
    function zp_colorAllocate($image, $red, $green, $blue) {
        return new ImagickPixel("rgb($red, $green, $blue)");
    }

    /**
     * Renders a string into the image
     *
     * @param Imagick $image
     * @param ImagickDraw $font
     * @param int $x
     * @param int $y
     * @param string $string
     * @param ImagickPixel $color
     * @return bool
     */
    function zp_writeString($image, $font, $x, $y, $string, $color) {
        $font->setStrokeColor($color);

        return $image->annotateImage($font, $x, $y + $image->getImageHeight() / 2, 0, $string);
    }

    /**
     * Creates a rectangle
     *
     * @param Imagick $image
     * @param int $x1
     * @param int $y1
     * @param int $x2
     * @param int $y2
     * @param ImagickPixel $color
     * @return bool
     */
    function zp_drawRectangle($image, $x1, $y1, $x2, $y2, $color) {
        return $image->borderImage($color, 1, 1);
    }

    /**
     * Returns array of graphics library info
     *
     * @return array
     */
    function zp_graphicsLibInfo() {
        global $_lib_Imagick_info;

        return $_lib_Imagick_info;
    }

    /**
     * Returns a list of available fonts
     *
     * @return array
     */
    function zp_getFonts() {
        global $_imagick_fontlist;

        if (!is_array($_imagick_fontlist)) {
            @$_imagick_fontlist = Imagick::queryFonts();
            $_imagick_fontlist = array('system' => '') + array_combine($_imagick_fontlist, $_imagick_fontlist);

            $basefile = SERVERPATH . '/' . USER_PLUGIN_FOLDER . '/imagick_fonts/';

            if (is_dir($basefile)) {
                chdir($basefile);
                $filelist = safe_glob('*.ttf');

                foreach ($filelist as $file) {
                    $key = filesystemToInternal(str_replace('.ttf', '', $file));
                    $_imagick_fontlist[$key] = getcwd() . '/' . $file;
                }
            }

            chdir(dirname(__FILE__));
        }

        return $_imagick_fontlist;
    }

    /**
     * Loads a font and returns an object with the font loaded
     *
     * @param string $font
     * @return ImagickDraw
     */
    function zp_imageLoadFont($font = NULL, $size = 18) {
        $draw = new ImagickDraw();

        if (!empty($font)) {
            $draw->setFont($font);
        }

        $draw->setFontSize($size);

        return $draw;
    }

    /**
     * Returns the font width in pixels
     *
     * @param ImagickDraw $font
     * @return int
     */
    function zp_imageFontWidth($font) {
        $temp = new Imagick();
        $metrics = $temp->queryFontMetrics($font, "The quick brown fox jumps over the lazy dog");
        $temp->destroy();

        return $metrics['characterWidth'];
    }

    /**
     * Returns the font height in pixels
     *
     * @param ImagickDraw $font
     * @return int
     */
    function zp_imageFontHeight($font) {
        $temp = new Imagick();
        $metrics = $temp->queryFontMetrics($font, "The quick brown fox jumps over the lazy dog");
        $temp->destroy();

        return $metrics['characterHeight'];
    }

    /**
     * Creates an image from an image stream
     *
     * @param $string
     * @return Imagick
     */
    function zp_imageFromString($string) {
        $im = new Imagick();

        $maxHeight = getOption('magick_max_height');
        $maxWidth = getOption('magick_max_width');

        if ($maxHeight > lib_Imagick_Options::$ignore_size && $maxWidth > lib_Imagick_Options::$ignore_size) {
            $im->setOption('jpeg:size', $maxWidth . 'x' . $maxHeight);
        }

        $im->readImageBlob($string);

        return $im;
    }

}
?>