Subversion Repositories web.active

<?php namespace ProcessWire;

/**
 * ImageSizer Engine Module (Abstract)
 * 
 * Copyright (C) 2016-2019 by Horst Nogajski and Ryan Cramer
 * This file licensed under Mozilla Public License v2.0 http://mozilla.org/MPL/2.0/
 *
 * @property bool $autoRotation
 * @property bool $upscaling
 * @property bool $interlace
 * @property array|string|bool $cropping
 * @property int $quality
 * @property string $sharpening
 * @property float $defaultGamma
 * @property float $scale
 * @property int $rotate
 * @property string $flip
 * @property bool $useUSM
 * @property int $enginePriority Priority for use among other ImageSizerEngine modules (0=disabled, 1=first, 2=second, 3=and so on)
 * @property bool $webpAdd
 * @property int $webpQuality
 * @property bool|null $webpResult
 * @property bool|null $webpOnly
 * 
 */
abstract class ImageSizerEngine extends WireData implements Module, ConfigurableModule {

    /**
     * Filename to be resized
     *
     * @var string
     *
     */
    protected $filename;

    /**
     * Temporary filename as used by the resize() method
     * 
     * @var string
     * 
     */
    protected $tmpFile;

    /**
     * Extension of filename
     *
     * @var string
     *
     */
    protected $extension;

    /**
     * Type of image
     *
     */
    protected $imageType = null;

    /**
     * Image quality setting, 1..100
     *
     * @var int
     *
     */
    protected $quality = 90;

    /**
     * WebP Image quality setting, 1..100
     *
     * @var int
     *
     */
    protected $webpQuality = 90;

    /**
     * Also create a WebP Image with this variation?
     *
     * @var bool
     *
     */
    protected $webpAdd = false;

    /**
     * Only create the webp file?
     * 
     * @var bool
     * 
     */
    protected $webpOnly = false;

    /**
     * webp result (null=not known or not applicable)
     * 
     * @var bool|null
     * 
     */
    protected $webpResult = null;

    /**
     * Image interlace setting, false or true
     *
     * @var bool
     *
     */
    protected $interlace = false;

    /**
     * Information about the image (width/height)
     *
     * @var array
     *
     */
    protected $image = array(
        'width' => 0,
        'height' => 0
    );

    /**
     * Allow images to be upscaled / enlarged?
     *
     * @var bool
     *
     */
    protected $upscaling = true;

    /**
     * Directions that cropping may gravitate towards
     *
     * Beyond those included below, TRUE represents center and FALSE represents no cropping.
     *
     */
    static protected $croppingValues = array(
        'nw' => 'northwest',
        'n' => 'north',
        'ne' => 'northeast',
        'w' => 'west',
        'e' => 'east',
        'sw' => 'southwest',
        's' => 'south',
        'se' => 'southeast',
    );

    /**
     * Allow images to be cropped to achieve necessary dimension? If so, what direction?
     *
     * Possible values: northwest, north, northeast, west, center, east, southwest, south, southeast
     *    or TRUE to crop to center, or FALSE to disable cropping.
     * Or array where index 0 is % or px from left, and index 1 is % or px from top. Percent is assumed if
     *    values are number strings that end with %. Pixels are assumed of values are just integers. 
     * Default is: TRUE
     *
     * @var bool|array
     *
     */
    protected $cropping = true;

    /**
     * This can be populated on a per image basis. It provides cropping first and then resizing, the opposite of the
     * default behavior
     *
     * It needs an array with 4 params: x y w h for the cropping rectangle
     *
     * Default is: null
     *
     * @var null|array
     *
     */
    protected $cropExtra = null;

    /**
     * Was the given image modified?
     *
     * @var bool
     *
     */
    protected $modified = false;

    /**
     * enable auto_rotation according to EXIF-Orientation-Flag
     *
     * @var bool
     *
     */
    protected $autoRotation = true;

    /**
     * default sharpening mode: [ none | soft | medium | strong ]
     *
     * @var string
     *
     */
    protected $sharpening = 'soft';

    /**
     * Degrees to rotate: -270, -180, -90, 90, 180, 270
     *
     * @var int
     *
     */
    protected $rotate = 0;

    /**
     * Flip image: Specify 'v' for vertical or 'h' for horizontal
     *
     * @var string
     *
     */
    protected $flip = '';

    /**
     * default gamma correction: 0.5 - 4.0 | -1 to disable gammacorrection, default = 2.0
     *
     * can be overridden by setting it to $config->imageSizerOptions['defaultGamma']
     * or passing it along with image options array
     *
     */
    protected $defaultGamma = 2.2;

    /**
     * @var bool
     * 
     */
    protected $useUSM = false;

    /**
     * Other options for 3rd party use
     *
     * @var array
     *
     */
    protected $options = array();

    /**
     * Options allowed for sharpening
     *
     * @var array
     *
     */
    static protected $sharpeningValues = array(
        0 => 'none', // none
        1 => 'soft',
        2 => 'medium',
        3 => 'strong'
    );

    /**
     * List of valid option Names from config.php (@horst)
     *
     * @var array
     *
     */
    protected $optionNames = array(
        'autoRotation',
        'upscaling',
        'cropping',
        'interlace', 
        'quality',
        'webpQuality',
        'webpAdd',
        'sharpening',
        'defaultGamma',
        'scale',
        'rotate',
        'flip',
        'useUSM',
    );

    /**
     * Supported image types (@teppo)
     *
     * @var array
     *
     */
    protected $supportedImageTypes = array(
        'gif' => IMAGETYPE_GIF,
        'jpg' => IMAGETYPE_JPEG,
        'jpeg' => IMAGETYPE_JPEG,
        'png' => IMAGETYPE_PNG,
    );

    /**
     * Indicates how much an image should be sharpened
     *
     * @var int
     *
     */
    protected $usmValue = 100;

    /**
     * Result of iptcparse(), if available
     *
     * @var mixed
     *
     */
    protected $iptcRaw = null;

    /**
     * List of valid IPTC tags (@horst)
     *
     * @var array
     *
     */
    protected $validIptcTags = array(
        '005', '007', '010', '012', '015', '020', '022', '025', '030', '035', '037', '038', '040', '045', '047', '050', '055', '060',
        '062', '063', '065', '070', '075', '080', '085', '090', '092', '095', '100', '101', '103', '105', '110', '115', '116', '118',
        '120', '121', '122', '130', '131', '135', '150', '199', '209', '210', '211', '212', '213', '214', '215', '216', '217');

    /**
     * Information about the image from getimagesize (width, height, imagetype, channels, etc.)
     *
     * @var array|null
     *
     */
    protected $info = null;

    /**
     * HiDPI scale value (2.0 = hidpi, 1.0 = normal)
     *
     * @var float
     *
     */
    protected $scale = 1.0;

    /**
     * the resize wrapper method sets this to the width of the given source image
     *
     * @var integer
     *
     */
    protected $fullWidth;

    /**
     * the resize wrapper method sets this to the height of the given source image
     *
     * @var integer
     *
     */
    protected $fullHeight;

    /**
     * the resize wrapper method sets this to the width of the target image
     * therefore it also may calculate it in regard of hiDpi
     *
     * @var integer
     *
     */
    protected $finalWidth;

    /**
     * the resize wrapper method sets this to the height of the target image
     * therefor it also may calculate it in regard of hiDpi
     *
     * @var integer
     *
     */
    protected $finalHeight;

    /**
     * Data received from the setConfigData() method
     * 
     * @var array
     * 
     */
    protected $moduleConfigData = array();

    /**
     * Collection of Imagefile and -format Informations from ImageInspector
     * 
     * @var null|array
     *
     */
    protected $inspectionResult = null;

    /******************************************************************************************************/
    
    public function __construct() {
        $this->set('enginePriority', 1);
        parent::__construct();
    }

    /**
     * Prepare the ImageSizer (this should be the first method you call)
     * 
     * This is used as a replacement for __construct() since modules can't have required arguments
     * to their constructor. 
     *
     * @param string $filename
     * @param array $options
     * @param null|array $inspectionResult
     *
     */
    public function prepare($filename, $options = array(), $inspectionResult = null) {

        // ensures the resize doesn't timeout the request (with at least 30 seconds)
        $this->setTimeLimit();

        // when invoked from Pageimage, $inspectionResult holds the InfoCollection from ImageInspector, otherwise NULL
        // if it is invoked manually and its value is NULL, the method loadImageInfo() will fetch the infos
        $this->inspectionResult = $inspectionResult;

        // filling all options with global custom values from config.php
        $options = array_merge($this->wire('config')->imageSizerOptions, $options);
        $this->setOptions($options);
        $this->loadImageInfo($filename, false);
    }
    
    /*************************************************************************************************
     * ABSTRACT AND TEMPLATE METHODS
     *
     */

    /**
     * Is this ImageSizer class ready only means: does the server / system provide all Requirements!
     *
     * @param string $action Optional type of action supported.
     * @return bool
     *
     */
    abstract public function supported($action = 'imageformat');

    /**
     * Process the image resize
     *
     * Processing is as follows:
     *    1. first do a check if the given image(type) can be processed, if not do an early return false
     *    2. than (try) to process all required steps, if one failes, return false
     *    3. if all is successful, finally return true
     *
     * @param string $srcFilename Source file
     * @param string $dstFilename Destination file
     * @param int $fullWidth Current width
     * @param int $fullHeight Current height
     * @param int $finalWidth Requested final width
     * @param int $finalHeight Requested final height
     * @return bool True if successful, false if not
     * @throws WireException
     *
     */
    abstract protected function processResize($srcFilename, $dstFilename, $fullWidth, $fullHeight, $finalWidth, $finalHeight);

    /**
     * Process rotate of an image
     * 
     * @param string $srcFilename
     * @param string $dstFilename
     * @param int $degrees Clockwise degrees, i.e. 90, 180, 270, -90, -180, -270
     * @return bool
     * 
     */
    protected function processRotate($srcFilename, $dstFilename, $degrees) { 
        if($srcFilename && $dstFilename && $degrees) {}
        $this->error('rotate not implemented for ' . $this->className());
        return false;
    }

    /**
     * Process vertical or horizontal flip of an image
     * 
     * @param string $srcFilename
     * @param string $dstFilename
     * @param bool $flipVertical True if flip is vertical, false if flip is horizontal
     * @return bool
     * 
     */
    protected function processFlip($srcFilename, $dstFilename, $flipVertical) {
        if($srcFilename && $dstFilename && $flipVertical) {}
        $this->error('flip not implemented for ' . $this->className());
        return false;
    }

    /**
     * Get array of image file extensions this ImageSizerModule can process
     *
     * @return array of uppercase file extensions, i.e. ['PNG', 'JPG']
     *
     */
    abstract protected function validSourceImageFormats();

    /**
     * Get an array of image file extensions this ImageSizerModule can create
     *
     * @return array of uppercase file extensions, i.e. ['PNG', 'JPG']
     *
     */
    protected function validTargetImageFormats() {
        return $this->validSourceImageFormats();
    }

    /**
     * Get an array of image file formats this ImageSizerModule can use as source or target
     * 
     * Unless using the $type argument, returned array contains 'source' and 'target' indexes, 
     * each an array of image file types/extensions in uppercase. 
     * 
     * @param string $type Specify 'source' or 'target' to get just those formats, or omit to get all.
     * @return array 
     * @since 3.0.138
     * 
     */
    public function getSupportedFormats($type = '') {
        $a = array(
            'source' => $this->validSourceImageFormats(),
            'target' => $this->validTargetImageFormats()
        );
        return $type && isset($a[$type]) ? $a[$type] : $a;
    }

    /**
     * Get array of information about this engine
     * 
     * @return array
     * @since 3.0.138
     * 
     */
    public function getEngineInfo() {
        
        $formats = $this->getSupportedFormats();
        $moduleName = $this->className();
        $className = $this->className(true);

        if(is_callable("$className::getModuleInfo")) {
            $moduleInfo = $className::getModuleInfo();
        } else {
            $moduleInfo = $this->wire('modules')->getModuleInfoVerbose($className);
        }

        if(!is_array($moduleInfo)) $moduleInfo = array();

        $info = array(
            'name' => str_replace('ImageSizerEngine', '', $moduleName),
            'title' => isset($moduleInfo['title']) ? $moduleInfo['title'] : '',
            'class' => $moduleName,
            'summary' => isset($moduleInfo['summary']) ? $moduleInfo['summary'] : '',
            'author' => isset($moduleInfo['author']) ? $moduleInfo['author'] : '',
            'moduleVersion' => isset($moduleInfo['version']) ? $moduleInfo['version'] : '',
            'libraryVersion' => $this->getLibraryVersion(),
            'priority' => $this->enginePriority,
            'sources' => $formats['source'],
            'targets' => $formats['target'],
            'quality' => $this->quality,
            'sharpening' => $this->sharpening,
        );

        return $info;
    }

    /*************************************************************************************************
     * COMMON IMPLEMENTATION METHODS
     *
     */

    /**
     * Load all image information from ImageInspector (Module)
     *
     * @param string $filename
     * @param bool $reloadAll
     * @throws WireException
     *
     */
    protected function loadImageInfo($filename, $reloadAll = false) {
        // if the engine is invoked manually, we need to inspect the image first
        if(empty($this->inspectionResult) || $reloadAll) {
            $imageInspector = new ImageInspector($filename);
            $this->inspectionResult = $imageInspector->inspect($filename, true);
        }
        if(null === $this->inspectionResult) throw new WireException("no valid filename passed to image inspector");
        if(false === $this->inspectionResult) throw new WireException(basename($filename) . " - not a recognized image");

        $this->filename = $this->inspectionResult['filename'];
        $this->extension = $this->inspectionResult['extension'];
        $this->imageType = $this->inspectionResult['imageType'];

        if(!in_array($this->imageType, $this->supportedImageTypes)) {
            throw new WireException(basename($filename) . " - not a supported image type");
        }

        $this->info = $this->inspectionResult['info'];
        $this->iptcRaw = $this->inspectionResult['iptcRaw'];
        // set width & height
        $this->setImageInfo($this->info['width'], $this->info['height']);
    }

    /**
     * ImageInformation from Image Inspector
     * in short form or full RawInfoData
     *
     * @param bool $rawData
     * @return string|array
     * @todo this appears to be a duplicate of what's in ImageSizer class?
     *
     */
    protected function getImageInfo($rawData = false) {
        if($rawData) return $this->inspectionResult;
        $imageType = $this->inspectionResult['info']['imageType'];
        
        $type = '';
        $indexed = '';
        $trans = '';
        $animated = '';
        
        switch($imageType) {
            case \IMAGETYPE_JPEG:
                $type = 'jpg';
                $indexed = '';
                $trans = '';
                $animated = '';
                break;
            case \IMAGETYPE_GIF:
                $type = 'gif';
                $indexed = '';
                $trans = $this->inspectionResult['info']['trans'] ? '-trans' : '';
                $animated = $this->inspectionResult['info']['animated'] ? '-anim' : '';
                break;
            case \IMAGETYPE_PNG:
                $type = 'png';
                $indexed = 'Indexed' == $this->inspectionResult['info']['colspace'] ? '8' : '24';
                $trans = is_array($this->inspectionResult['info']['trans']) ? '-trans' : '';
                $trans = $this->inspectionResult['info']['alpha'] ? '-alpha' : $trans;
                $animated = '';
                break;
        }
        
        return $type . $indexed . $trans . $animated;
    }
    
    /**
     * Default IPTC Handling
     *
     * If we've retrieved IPTC-Metadata from sourcefile, we write it into the variation here but we omit
     * custom tags for internal use (@horst)
     *
     * @param string $filename the file we want write the IPTC data to
     * @param bool $includeCustomTags default is FALSE
     * @return bool|null
     *
     */
    public function writeBackIPTC($filename, $includeCustomTags = false) {
        if($this->wire('config')->debug) {
            // add a timestamp and the name of the image sizer engine to the IPTC tag number 217
            $entry = $this->className() . '-' . date('Ymd:His');
            if(!$this->iptcRaw) $this->iptcRaw = array();
            $this->iptcRaw['2#217'] = array(0 => $entry);
        }
        if(!$this->iptcRaw) return null; // the sourceimage doesn't contain IPTC infos
        $content = iptcembed($this->iptcPrepareData($includeCustomTags), $filename);
        if(false === $content) return null;
        $extension = pathinfo($filename, \PATHINFO_EXTENSION);
        $dest = preg_replace('/\.' . $extension . '$/', '_tmp.' . $extension, $filename);
        if(strlen($content) == @file_put_contents($dest, $content, \LOCK_EX)) {
            // on success we replace the file
            $this->wire('files')->unlink($filename);
            $this->wire('files')->rename($dest, $filename);
            $this->wire('files')->chmod($filename);
            return true;
        } else {
            // it was created a temp diskfile but not with all data in it
            if(file_exists($dest)) @unlink($dest);
            return false;
        }
    }

    /**
     * Save the width and height of the image
     *
     * @param int $width
     * @param int $height
     *
     */
    protected function setImageInfo($width, $height) {
        $this->image['width'] = $width;
        $this->image['height'] = $height;
    }

    /**
     * Return the image width
     *
     * @return int
     *
     */
    public function getWidth() {
        return $this->image['width'];
    }

    /**
     * Return the image height
     *
     * @return int
     *
     */
    public function getHeight() {
        return $this->image['height'];
    }

    /**
     * Given a target height, return the proportional width for this image
     *
     * @param int $targetHeight
     *
     * @return int
     *
     */
    protected function getProportionalWidth($targetHeight) {
        $img =& $this->image;
        return ceil(($targetHeight / $img['height']) * $img['width']); // @horst
    }

    /**
     * Given a target width, return the proportional height for this image
     *
     * @param int $targetWidth
     *
     * @return int
     *
     */
    protected function getProportionalHeight($targetWidth) {
        $img =& $this->image;
        return ceil(($targetWidth / $img['width']) * $img['height']); // @horst
    }

    /**
     * Get an array of the 4 dimensions necessary to perform the resize
     *
     * Note: Some code used in this method is adapted from code found in comments at php.net for the GD functions
     *
     * Intended for use by the resize() method
     *
     * @param int $targetWidth
     * @param int $targetHeight
     *
     * @return array
     *
     */
    protected function getResizeDimensions($targetWidth, $targetHeight) {

        $pWidth = $targetWidth;
        $pHeight = $targetHeight;

        $img =& $this->image;

        if(!$targetHeight) $targetHeight = round(($targetWidth / $img['width']) * $img['height']);
        if(!$targetWidth) $targetWidth = round(($targetHeight / $img['height']) * $img['width']);

        $originalTargetWidth = $targetWidth;
        $originalTargetHeight = $targetHeight;

        if($img['width'] < $img['height']) {
            $pHeight = $this->getProportionalHeight($targetWidth);
        } else {
            $pWidth = $this->getProportionalWidth($targetHeight);
        }

        if($pWidth < $targetWidth) {
            // if the proportional width is smaller than specified target width
            $pWidth = $targetWidth;
            $pHeight = $this->getProportionalHeight($targetWidth);
        }

        if($pHeight < $targetHeight) {
            // if the proportional height is smaller than specified target height
            $pHeight = $targetHeight;
            $pWidth = $this->getProportionalWidth($targetHeight);
        }

        // rounding issue fix via @horst-n for #191 
        if($targetWidth == $originalTargetWidth && 1 + $targetWidth == $pWidth) $pWidth = $pWidth - 1;
        if($targetHeight == $originalTargetHeight && 1 + $targetHeight == $pHeight) $pHeight = $pHeight - 1;

        if(!$this->upscaling && ($img['width'] < $targetWidth || $img['height'] < $targetHeight)) {
            // via @horst-n PR #118: 
            // upscaling is not allowed and we have one or both dimensions to small,
            // we scale down the target dimensions to fit within the image dimensions, 
            // with respect to the target dimensions ratio
            $ratioSource = $img['height'] / $img['width'];
            $ratioTarget = !$this->cropping ? $ratioSource : $targetHeight / $targetWidth;
            if($ratioSource >= $ratioTarget) {
                // ratio is equal or target fits into source
                $pWidth = $targetWidth = $img['width'];
                $pHeight = $img['height'];
                $targetHeight = ceil($pWidth * $ratioTarget);
            } else {
                // target doesn't fit into source
                $pHeight = $targetHeight = $img['height'];
                $pWidth = $img['width'];
                $targetWidth = ceil($pHeight / $ratioTarget);
            }
            if($this->cropping) {
                // we have to disable any sharpening method here, 
                // as the source will not be resized, only cropped
                $this->sharpening = 'none';
            }
        }

        if(!$this->cropping) {
            // we will make the image smaller so that none of it gets cropped
            // this means we'll be adjusting either the targetWidth or targetHeight
            // till we have a suitable dimension

            if($pHeight > $originalTargetHeight) {
                $pHeight = $originalTargetHeight;
                $pWidth = $this->getProportionalWidth($pHeight);
                $targetWidth = $pWidth;
                $targetHeight = $pHeight;
            }
            if($pWidth > $originalTargetWidth) {
                $pWidth = $originalTargetWidth;
                $pHeight = $this->getProportionalHeight($pWidth);
                $targetWidth = $pWidth;
                $targetHeight = $pHeight;
            }
        }

        return array(
            0 => (int) $pWidth,
            1 => (int) $pHeight,
            2 => (int) $targetWidth,
            3 => (int) $targetHeight
        );
    }

    /**
     * Was the image modified?
     *
     * @return bool
     *
     */
    public function isModified() {
        return $this->modified;
    }

    /**
     * Given an unknown cropping value, return the validated internal representation of it
     *
     * @param string|bool|array $cropping
     *
     * @return string|bool|array
     *
     */
    static public function croppingValue($cropping) {

        if(is_string($cropping)) {
            $cropping = strtolower($cropping);
            if(strpos($cropping, ',')) {
                $cropping = explode(',', $cropping);
            } else if(strpos($cropping, 'x') && preg_match('/^([pd])(\d+)x(\d+)(z\d+)?/', $cropping, $matches)) {
                $cropping = array(
                    0 => (int) $matches[2], // x 
                    1 => (int) $matches[3] // y
                );
                if(isset($matches[4])) {
                    $cropping[2] = (int) ltrim($matches[4], 'z'); // zoom
                }
                if($matches[1] == 'p') { // percent
                    $cropping[0] .= '%';
                    $cropping[1] .= '%';
                }
            }
        }
        if(is_array($cropping)) {
            if(strpos($cropping[0], '%') !== false) {
                $v = trim($cropping[0], '%');
                if(ctype_digit(trim($v, '-'))) $v = (int) $v;
                $cropping[0] = round(min(100, max(0, $v))) . '%';
            } else {
                $cropping[0] = (int) $cropping[0];
            }
            if(strpos($cropping[1], '%') !== false) {
                $v = trim($cropping[1], '%');
                if(ctype_digit(trim($v, '-'))) $v = (int) $v;
                $cropping[1] = round(min(100, max(0, $v))) . '%';
            } else {
                $cropping[1] = (int) $cropping[1];
            }
            if(isset($cropping[2])) { // zoom
                $cropping[2] = (int) $cropping[2]; 
                if($cropping[2] < 2 || $cropping[2] > 99) unset($cropping[2]);
            }
        }

        if($cropping === true) {
            $cropping = true; // default, crop to center
        } else if(!$cropping) {
            $cropping = false;
        } else if(is_array($cropping)) {
            // already took care of it above
        } else if(in_array($cropping, self::$croppingValues)) {
            $cropping = array_search($cropping, self::$croppingValues);
        } else if(array_key_exists($cropping, self::$croppingValues)) {
            // okay
        } else {
            $cropping = true; // unknown value or 'center', default to TRUE/center
        }

        return $cropping;
    }

    /**
     * Given an unknown cropping value, return the string representation of it
     *
     * Okay for use in filenames
     *
     * @param string|bool|array $cropping
     *
     * @return string
     *
     */
    static public function croppingValueStr($cropping) {

        $cropping = self::croppingValue($cropping);

        // crop name if custom center point is specified
        if(is_array($cropping)) {
            // p = percent, d = pixel dimension, z = zoom
            $zoom = isset($cropping[2]) ? (int) $cropping[2] : 0;
            $cropping = 
                (strpos($cropping[0], '%') !== false ? 'p' : 'd') . 
                ((int) rtrim($cropping[0], '%')) . 'x' . ((int) rtrim($cropping[1], '%'));
            if($zoom > 1 && $zoom < 100) $cropping .= "z$zoom";
        }

        // if crop is TRUE or FALSE, we don't reflect that in the filename, so make it blank
        if(is_bool($cropping)) $cropping = '';

        return $cropping;
    }

    /**
     * Turn on/off cropping and/or set cropping direction
     *
     * @param bool|string|array $cropping Specify one of: northwest, north, northeast, west, center, east, southwest,
     *     south, southeast. Or a string of: 50%,50% (x and y percentages to crop from) Or an array('50%', '50%') Or to
     *     disable cropping, specify boolean false. To enable cropping with default (center), you may also specify
     *     boolean true.
     *
     * @return self
     *
     */
    public function setCropping($cropping = true) {
        $this->cropping = self::croppingValue($cropping);
        return $this;
    }

    /**
     * Set values for cropExtra rectangle, which enables cropping before resizing
     *
     * Added by @horst
     *
     * @param array $value containing 4 params (x y w h) indexed or associative
     *
     * @return self
     * @throws WireException when given invalid value
     *
     */
    public function setCropExtra($value) {

        $this->cropExtra = null;
        $x = null;
        $y = null;
        $w = null;
        $h = null;

        if(!is_array($value) || 4 != count($value)) {
            throw new WireException('Missing or wrong param Array for ImageSizer-cropExtra!');
        }

        if(array_keys($value) === range(0, count($value) - 1)) {
            // we have a zerobased sequential array, we assume this order: x y w h
            list($x, $y, $w, $h) = $value;
        } else {
            // check for associative array
            foreach(array('x', 'y', 'w', 'h') as $v) {
                if(isset($value[$v])) $$v = $value[$v];
            }
        }
        
        foreach(array('x', 'y', 'w', 'h') as $k) {
            $v = (int) (isset($$k) ? $$k : -1);
            if(!$v && $k == 'w' && $h > 0) $v = $this->getProportionalWidth((int) $h); 
            if(!$v && $k == 'h' && $w > 0) $v = $this->getProportionalHeight((int) $w); 
            if($v < 0) throw new WireException("Missing or wrong param $k=$v for ImageSizer-cropExtra! " . print_r($value, true));
            if(('w' == $k || 'h' == $k) && 0 == $v) throw new WireException("Wrong param $k=$v for ImageSizer-cropExtra! " . print_r($value, true));
        }

        $this->cropExtra = array($x, $y, $w, $h);

        return $this;
    }

    /**
     * Set the image quality 1-100, where 100 is highest quality
     *
     * @param int $n
     *
     * @return self
     *
     */
    public function setQuality($n) {
        $this->quality = $this->getIntegerValue($n, 1, 100);
        return $this;
    }

    /**
     * Set the image quality 1-100 for WebP output, where 100 is highest quality
     *
     * @param int $n
     *
     * @return self
     *
     */
    public function setWebpQuality($n) {
        $this->webpQuality = $this->getIntegerValue($n, 1, 100);
        return $this;
    }

    /**
     * Set flag to also create a webp file or not
     *
     * @param bool $webpAdd
     * @param bool|null $webpOnly
     * @return self
     *
     */
    public function setWebpAdd($webpAdd, $webpOnly = null) {
        $this->webpAdd = (bool) $webpAdd;
        if(is_bool($webpOnly)) $this->webpOnly = $webpOnly;
        return $this;
    }

    /**
     * Set flag to only create a webp file
     *
     * @param bool value$
     * @return self
     *
     */
    public function setWebpOnly($value) {
        $this->webpOnly = (bool) $value;
        if($this->webpOnly) $this->webpAdd = true; // webpAdd required for webpOnly
        return $this;
    }

    /**
     * Given an unknown sharpening value, return the string representation of it
     *
     * Okay for use in filenames. Method added by @horst
     *
     * @param string|bool $value
     * @param bool $short
     *
     * @return string
     *
     */
    static public function sharpeningValueStr($value, $short = false) {

        $sharpeningValues = self::$sharpeningValues;

        if(is_string($value) && in_array(strtolower($value), $sharpeningValues)) {
            $ret = strtolower($value);

        } else if(is_int($value) && isset($sharpeningValues[$value])) {
            $ret = $sharpeningValues[$value];

        } else if(is_bool($value)) {
            $ret = $value ? "soft" : "none";

        } else {
            // sharpening is unknown, return empty string
            return '';
        }

        if(!$short) return $ret;    // return name
        $flip = array_flip($sharpeningValues);
        return 's' . $flip[$ret];   // return char s appended with the numbered index
    }

    /**
     * Set sharpening value: blank (for none), soft, medium, or strong
     *
     * @param mixed $value
     *
     * @return self
     * @throws WireException
     *
     */
    public function setSharpening($value) {

        if(is_string($value) && in_array(strtolower($value), self::$sharpeningValues)) {
            $ret = strtolower($value);

        } else if(is_int($value) && isset(self::$sharpeningValues[$value])) {
            $ret = self::$sharpeningValues[$value];

        } else if(is_bool($value)) {
            $ret = $value ? "soft" : "none";

        } else {
            throw new WireException("Unknown value for sharpening");
        }

        $this->sharpening = $ret;

        return $this;
    }

    /**
     * Turn on/off auto rotation
     *
     * @param bool $value Whether to auto-rotate or not (default = true)
     *
     * @return self
     *
     */
    public function setAutoRotation($value = true) {
        $this->autoRotation = $this->getBooleanValue($value);
        return $this;
    }

    /**
     * Turn on/off upscaling
     *
     * @param bool $value Whether to upscale or not (default = true)
     *
     * @return self
     *
     */
    public function setUpscaling($value = true) {
        $this->upscaling = $this->getBooleanValue($value);
        return $this;
    }
    
    /**
     * Turn on/off interlace 
     *
     * @param bool $value Whether to upscale or not (default = true)
     *
     * @return self
     *
     */
    public function setInterlace($value = true) {
        $this->interlace = $this->getBooleanValue($value);
        return $this;
    }

    /**
     * Set default gamma value: 0.5 - 4.0 | -1
     *
     * @param float|int $value 0.5 to 4.0 or -1 to disable
     *
     * @return self
     * @throws WireException when given invalid value
     *
     */
    public function setDefaultGamma($value = 2.2) {
        if($value === -1 || ($value >= 0.5 && $value <= 4.0)) {
            $this->defaultGamma = $value;
        } else {
            throw new WireException('Invalid defaultGamma value - must be 0.5 - 4.0 or -1 to disable gammacorrection');
        }
        return $this;
    }

    /**
     * Set a time limit for manipulating one image (default is 30)
     *
     * If specified time limit is less than PHP's max_execution_time, then PHP's setting will be used instead.
     *
     * @param int $value 10 to 60 recommended, default is 30
     *
     * @return self
     *
     */
    public function setTimeLimit($value = 30) {
        // imagesizer can get invoked from different locations, including those that are inside of loops
        // like the wire/modules/Inputfield/InputfieldFile/InputfieldFile.module :: ___renderList() method

        $prevLimit = ini_get('max_execution_time');

        // if unlimited execution time, no need to introduce one
        if(!$prevLimit) return $this;

        // don't override a previously set high time limit, just start over with it
        $timeLimit = (int) ($prevLimit > $value ? $prevLimit : $value);

        // restart time limit
        set_time_limit($timeLimit);

        return $this;
    }

    /**
     * Set scale for hidpi (2.0=hidpi, 1.0=normal, or other value if preferred)
     *
     * @param float $scale
     *
     * @return self
     *
     */
    public function setScale($scale) {
        $this->scale = (float) $scale;
        return $this;
    }

    /**
     * Enable hidpi mode?
     *
     * Just a shortcut for calling $this->scale()
     *
     * @param bool $hidpi True or false (default=true)
     *
     * @return self
     *
     */
    public function setHidpi($hidpi = true) {
        return $this->setScale($hidpi ? 2.0 : 1.0);
    }

    /**
     * Set rotation degrees
     *
     * Specify one of: -270, -180, -90, 90, 180, 270
     *
     * @param $degrees
     *
     * @return self
     *
     */
    public function setRotate($degrees) {
        $valid = array(-270, -180, -90, 90, 180, 270);
        $degrees = (int) $degrees;
        if(in_array($degrees, $valid)) $this->rotate = $degrees;
        return $this;
    }

    /**
     * Set flip
     *
     * Specify one of: 'vertical' or 'horizontal', also accepts
     * shorter versions like, 'vert', 'horiz', 'v', 'h', etc.
     *
     * @param $flip
     *
     * @return self
     *
     */
    public function setFlip($flip) {
        $flip = strtolower(substr($flip, 0, 1));
        if($flip == 'v' || $flip == 'h') $this->flip = $flip;
        return $this;
    }

    /**
     * Toggle on/off the usage of USM algorithm for sharpening
     *
     * @param bool $value Whether to USM is used or not (default = true)
     *
     * @return self
     *
     */
    public function setUseUSM($value = true) {
        $this->useUSM = true === $this->getBooleanValue($value) ? true : false;
        return $this;
    }

    /**
     * Alternative to the above set* functions where you specify all in an array
     *
     * @param array $options May contain the following (show with default values):
     *    'quality' => 90,
     *    'webpQuality' => 90,
     *    'cropping' => true,
     *    'upscaling' => true,
     *    'autoRotation' => true,
     *    'sharpening' => 'soft' (none|soft|medium|string)
     *    'scale' => 1.0 (use 2.0 for hidpi or 1.0 for normal-default)
     *    'hidpi' => false, (alternative to scale, specify true to enable hidpi)
     *    'rotate' => 0 (90, 180, 270 or negative versions of those)
     *    'flip' => '', (vertical|horizontal)
     *
     * @return self
     *
     */
    public function setOptions(array $options) {

        foreach($options as $key => $value) {
            switch($key) {

                case 'autoRotation':
                    $this->setAutoRotation($value);
                    break;
                case 'upscaling':
                    $this->setUpscaling($value);
                    break;
                case 'interlace':
                    $this->setInterlace($value);
                    break;
                case 'sharpening':
                    $this->setSharpening($value);
                    break;
                case 'quality':
                    $this->setQuality($value);
                    break;
                case 'webpQuality':
                    $this->setWebpQuality($value);
                    break;
                case 'webpAdd':
                    $this->setWebpAdd($value);
                    break;
                case 'webpOnly':
                    $this->setWebpOnly($value);
                    break;
                case 'cropping':
                    $this->setCropping($value);
                    break;
                case 'defaultGamma':
                    $this->setDefaultGamma($value);
                    break;
                case 'cropExtra':
                    $this->setCropExtra($value);
                    break;
                case 'scale':
                    $this->setScale($value);
                    break;
                case 'hidpi':
                    $this->setHidpi($value);
                    break;
                case 'rotate':
                    $this->setRotate($value);
                    break;
                case 'flip':
                    $this->setFlip($value);
                    break;
                case 'useUSM':
                    $this->setUseUSM($value);
                    break;

                default:
                    // unknown or 3rd party option
                    $this->options[$key] = $value;
            }
        }

        return $this;
    }

    /**
     * Given a value, convert it to a boolean.
     *
     * Value can be string representations like: 0, 1 off, on, yes, no, y, n, false, true.
     *
     * @param bool|int|string $value
     *
     * @return bool
     *
     */
    protected function getBooleanValue($value) {
        if(in_array(strtolower($value), array('0', 'off', 'false', 'no', 'n', 'none'))) return false;
        return ((int) $value) > 0;
    }
    
    /**
     * Get integer value within given range
     *
     * @param int $n Number to require in given range
     * @param int $min Minimum allowed number
     * @param int $max Maximum allowed number
     * @return int
     *
     */
    protected function getIntegerValue($n, $min, $max) {
        $n = (int) $n;
        if($n < $min) {
            $n = $min;
        } else if($n > $max) {
            $n = $max;
        }
        return $n;
    }

    /**
     * Return an array of the current options
     *
     * @return array
     *
     */
    public function getOptions() {

        $options = array(
            'quality' => $this->quality,
            'webpQuality' => $this->webpQuality,
            'webpAdd' => $this->webpAdd,
            'webpOnly' => $this->webpOnly,
            'cropping' => $this->cropping,
            'upscaling' => $this->upscaling,
            'interlace' => $this->interlace, 
            'autoRotation' => $this->autoRotation,
            'sharpening' => $this->sharpening,
            'defaultGamma' => $this->defaultGamma,
            'cropExtra' => $this->cropExtra,
            'scale' => $this->scale,
            'useUSM' => $this->useUSM,
        );

        $options = array_merge($this->options, $options);

        return $options;
    }

    /**
     * Get a property
     *
     * @param string $key
     *
     * @return mixed|null
     *
     */
    public function get($key) {

        $keys = array(
            'filename',
            'extension',
            'imageType',
            'image',
            'modified',
            'supportedImageTypes',
            'info',
            'iptcRaw',
            'validIptcTags',
            'cropExtra',
            'options'
        );

        if($key === 'webpResult') return $this->webpResult;
        if($key === 'webpOnly') return $this->webpOnly;
        if(in_array($key, $keys)) return $this->$key;
        if(in_array($key, $this->optionNames)) return $this->$key;
        if(isset($this->options[$key])) return $this->options[$key];
        
        return parent::get($key);
    }

    /**
     * Return the filename
     *
     * @return string
     *
     */
    public function getFilename() {
        return $this->filename;
    }

    /**
     * Return the file extension
     *
     * @return string
     *
     */
    public function getExtension() {
        return $this->extension;
    }

    /**
     * Return the image type constant
     *
     * @return string
     *
     */
    public function getImageType() {
        return $this->imageType;
    }

    /**
     * Prepare IPTC data (@horst)
     *
     * @param bool $includeCustomTags (default=false)
     *
     * @return string $iptcNew
     *
     */
    protected function iptcPrepareData($includeCustomTags = false) {
        $customTags = array('213', '214', '215', '216', '217');
        $iptcNew = '';
        foreach(array_keys($this->iptcRaw) as $s) {
            $tag = substr($s, 2);
            if(!$includeCustomTags && in_array($tag, $customTags)) continue;
            if(substr($s, 0, 1) == '2' && in_array($tag, $this->validIptcTags) && is_array($this->iptcRaw[$s])) {
                foreach($this->iptcRaw[$s] as $row) {
                    $iptcNew .= $this->iptcMakeTag(2, $tag, $row);
                }
            }
        }
        return $iptcNew;
    }

    /**
     * Make IPTC tag (@horst)
     *
     * @param string $rec
     * @param string $dat
     * @param string $val
     *
     * @return string
     *
     */
    protected function iptcMakeTag($rec, $dat, $val) {
        $len = strlen($val);
        if($len < 0x8000) {
            return @chr(0x1c) . @chr($rec) . @chr($dat) .
            chr($len >> 8) .
            chr($len & 0xff) .
            $val;
        } else {
            return chr(0x1c) . chr($rec) . chr($dat) .
            chr(0x80) . chr(0x04) .
            chr(($len >> 24) & 0xff) .
            chr(($len >> 16) & 0xff) .
            chr(($len >> 8) & 0xff) .
            chr(($len) & 0xff) .
            $val;
        }
    }

    /**
     * Check orientation (@horst)
     *
     * @param array
     *
     * @return bool
     *
     */
    protected function checkOrientation(&$correctionArray) {
        // first value is rotation-degree and second value is flip-mode: 0=NONE | 1=HORIZONTAL | 2=VERTICAL
        $corrections = array(
            '1' => array(0, 0),
            '2' => array(0, 1),
            '3' => array(180, 0),
            '4' => array(0, 2),
            '5' => array(90, 1),    // OLD: 270
            '6' => array(90, 0),    // OLD: 270
            '7' => array(270, 1),   // OLD: 90
            '8' => array(270, 0)    // OLD: 90
        );
        
        if(!isset($this->info['orientation']) || !isset($corrections[strval($this->info['orientation'])])) {
            return false;
        }
        
        $correctionArray = $corrections[strval($this->info['orientation'])];
        
        return true;
    }


    /**
     * Check for alphachannel in PNGs
     *
     * @return bool
     *
     */
    protected function hasAlphaChannel() {
        if(!isset($this->info['alpha']) && !isset($this->info['trans'])) return false;
        if(isset($this->info['alpha']) && $this->info['alpha']) return true;
        if(isset($this->info['trans']) && $this->info['trans']) return true;
        return false;
    }

    /**
     * Set whether the image was modified
     *
     * Public so that other modules/hooks can adjust this property if needed.
     * Not for general API use
     *
     * @param bool $modified
     *
     * @return self
     *
     */
    public function setModified($modified) {
        $this->modified = $modified ? true : false;
        return $this;
    }

    /**
     * Get whether the image was modified
     * 
     * @return bool
     * 
     */
    public function getModified() {
        return $this->modified;
    }

    /**
     * Check if cropping is needed, if yes, populate x- and y-position to params $w1 and $h1
     *
     * Intended for use by the resize() method
     *
     * @param int $w1 - byReference
     * @param int $h1 - byReference
     * @param int $gdWidth
     * @param int $targetWidth
     * @param int $gdHeight
     * @param int $targetHeight
     *
     */
    protected function getCropDimensions(&$w1, &$h1, $gdWidth, $targetWidth, $gdHeight, $targetHeight) {

        if(is_string($this->cropping)) {
            // calculate from 8 named cropping points 
            switch($this->cropping) {
                case 'nw':
                    $w1 = 0;
                    $h1 = 0;
                    break;
                case 'n':
                    $h1 = 0;
                    break;
                case 'ne':
                    $w1 = $gdWidth - $targetWidth;
                    $h1 = 0;
                    break;
                case 'w':
                    $w1 = 0;
                    break;
                case 'e':
                    $w1 = $gdWidth - $targetWidth;
                    break;
                case 'sw':
                    $w1 = 0;
                    $h1 = $gdHeight - $targetHeight;
                    break;
                case 's':
                    $h1 = $gdHeight - $targetHeight;
                    break;
                case 'se':
                    $w1 = $gdWidth - $targetWidth;
                    $h1 = $gdHeight - $targetHeight;
                    break;
                default: // center or false, we do nothing
            }

        } else if(is_array($this->cropping)) {
            // calculate from specific percent or pixels from left and top
            // $this->cropping is an array with the following:
            // index 0 represents % or pixels from left
            // index 1 represents % or pixels from top
            // @interrobang + @u-nikos
            if(strpos($this->cropping[0], '%') === false) {
                $pointX = (int) $this->cropping[0];
            } else {
                $pointX = $gdWidth * ((int) $this->cropping[0] / 100);
            }

            if(strpos($this->cropping[1], '%') === false) {
                $pointY = (int) $this->cropping[1];
            } else {
                $pointY = $gdHeight * ((int) $this->cropping[1] / 100);
            }
        
            /*
            if(isset($this->cropping[2]) && $this->cropping[2] > 1) {
                // zoom percent (2-100)
                $zoom = (int) $this->cropping[2];
            }
            */

            if($pointX < $targetWidth / 2) {
                $w1 = 0;
            } else if($pointX > ($gdWidth - $targetWidth / 2)) {
                $w1 = $gdWidth - $targetWidth;
            } else {
                $w1 = $pointX - $targetWidth / 2;
            }

            if($pointY < $targetHeight / 2) {
                $h1 = 0;
            } else if($pointY > ($gdHeight - $targetHeight / 2)) {
                $h1 = $gdHeight - $targetHeight;
            } else {
                $h1 = $pointY - $targetHeight / 2;
            }
        }

    }

    /*************************************************************************************************/

    /**
     * Resize the image
     * 
     * The resize method does all pre and post-processing for the engines + calls the engine's 
     * processResize() method.
     *
     * Pre-processing is: 
     *   Calculate and set dimensions, create a tempfile.
     *
     * Post-processing is: 
     *   Copy back and delete tempfile, write IPTC if necessary, reload imageinfo, set the modified flag.
     *
     * @param int $finalWidth
     * @param int $finalHeight
     * @return bool
     *
     */
    public function resize($finalWidth, $finalHeight) {

        // @todo is this call necessary, since ImageSizer.php would have already checked this?
        if(!$this->supported()) return false;

        // first prepare dimension settings for the engine(s)
        $this->finalWidth = $finalWidth;
        $this->finalHeight = $finalHeight;
        $this->fullWidth = $this->image['width'];
        $this->fullHeight = $this->image['height'];

        if(0 == $this->finalWidth && 0 == $this->finalHeight) return false;

        if($this->scale !== 1.0) { // adjust for hidpi
            if($this->finalWidth) $this->finalWidth = ceil($this->finalWidth * $this->scale);
            if($this->finalHeight) $this->finalHeight = ceil($this->finalHeight * $this->scale);
        }

        // create another temp copy so that we have the source unaltered if an engine fails
        // and we need to start another one
        $this->tmpFile = $this->filename . '-tmp.' . $this->extension;
        if(!@copy($this->filename, $this->tmpFile)) return false; // fallback or failed

        // lets the engine do the resize work
        if(!$this->processResize(
            $this->filename, $this->tmpFile, 
            $this->fullWidth, $this->fullHeight, 
            $this->finalWidth, $this->finalHeight)) {
            return false; // fallback or failed
        }

        if($this->webpOnly) {
            $this->wire('files')->unlink($this->tmpFile);
        } else {
            // all went well, copy back the temp file,
            if(!@copy($this->tmpFile, $this->filename)) return false; // fallback or failed 
            $this->wire('files')->chmod($this->filename);
            // remove the temp file
            $this->wire('files')->unlink($this->tmpFile);
            // post processing: IPTC, setModified and reload ImageInfo
            $this->writeBackIPTC($this->filename, false);
        }
        $this->setModified($this->modified);
        $this->loadImageInfo($this->filename, true);

        return true;
    }

    /**
     * Just rotate image by number of degrees
     * 
     * @param int $degrees
     * @param string $dstFilename Optional destination filename. If not present, source will be overwritten. 
     * @return bool True on success, false on fail
     * 
     */
    public function rotate($degrees, $dstFilename = '') {

        $degrees = (int) $degrees;
        $srcFilename = $this->filename;
        
        if(empty($dstFilename)) $dstFilename = $srcFilename;
        
        if($degrees > 360) $degrees = 360 - $degrees;
        if($degrees < -360) $degrees = $degrees - 360;

        if($degrees == 0 || $degrees == 360 || $degrees == -360) {
            if($dstFilename != $this->filename) wireCopy($this->filename, $dstFilename);
            return true;
        }

        if($srcFilename == $dstFilename) {
            // src and dest are the same, so use a temporary file 
            $n = 1;
            do {
                $tmpFilename = dirname($dstFilename) . "/.ise$n-" . basename($dstFilename);
            } while(file_exists($tmpFilename) && $n++); 
        } else {
            // src and dest are different files
            $tmpFilename = $dstFilename;
        }
        
        $result = $this->processRotate($srcFilename, $tmpFilename, $degrees);
        
        if($result) {
            // success
            if($tmpFilename != $dstFilename) {
                if(is_file($dstFilename)) $this->wire('files')->unlink($dstFilename);
                $this->wire('files')->rename($tmpFilename, $dstFilename);
            }
            $this->wire('files')->chmod($dstFilename);
        } else {
            // fail
            if(is_file($tmpFilename)) $this->wire('files')->unlink($tmpFilename);   
        }
        
        return $result;
    }

    /**
     * Flip vertically 
     * 
     * @param string $dstFilename
     * @return bool
     * 
     */
    public function flipVertical($dstFilename = '') {
        if(empty($dstFilename)) $dstFilename = $this->filename;
        return $this->processFlip($this->filename, $dstFilename, 'vertical'); 
    }

    /**
     * Flip horizontally 
     * 
     * @param string $dstFilename
     * @return bool
     * 
     */ 
    public function flipHorizontal($dstFilename = '') {
        if(empty($dstFilename)) $dstFilename = $this->filename;
        return $this->processFlip($this->filename, $dstFilename, 'horizontal'); 
    }

    /**
     * Flip both vertically and horizontally
     * 
     * @param string $dstFilename
     * @return bool
     * 
     */
    public function flipBoth($dstFilename = '') {
        if(empty($dstFilename)) $dstFilename = $this->filename;
        return $this->processFlip($this->filename, $dstFilename, 'both');
    }
    
    /**
     * Convert image to greyscale
     *
     * @param string $dstFilename If different from source file
     * @return bool
     *
     */
    public function convertToGreyscale($dstFilename = '') {
        if($dstFilename) {}
        return false;
    }

    /**
     * Convert image to sepia
     *
     * @param string $dstFilename If different from source file
     * @param float|int $sepia Sepia value
     * @return bool
     *
     */
    public function convertToSepia($dstFilename = '', $sepia = 55) {
        if($dstFilename && $sepia) {}
        return false;
    }

    /**
     * Get an integer representing the resize method to use
     *
     * This method calculates all dimensions at first. It is called before any of the main image operations,
     * but after rotation and crop_before_resize. As result it returns an integer [0|2|4] that indicates which
     * steps should be processed:
     *
     * 0 = this is the case if the original size is requested or a greater size but upscaling is set to false
     * 2 = only resize with aspect ratio
     * 4 = resize and crop with aspect ratio
     *
     * @param mixed $gdWidth
     * @param mixed $gdHeight
     * @param mixed $targetWidth
     * @param mixed $targetHeight
     * @param mixed $x1
     * @param mixed $y1
     *
     * @return int 0|2|4
     *
     */
    protected function getResizeMethod(&$gdWidth, &$gdHeight, &$targetWidth, &$targetHeight, &$x1, &$y1) {
        list($gdWidth, $gdHeight, $targetWidth, $targetHeight) = $this->getResizeDimensions($targetWidth, $targetHeight);
        $x1 = ($gdWidth / 2) - ($targetWidth / 2);
        $y1 = ($gdHeight / 2) - ($targetHeight / 2);
        $this->getCropDimensions($x1, $y1, $gdWidth, $targetWidth, $gdHeight, $targetHeight);
        $x1 = intval($x1);
        $y1 = intval($y1);
        if($gdWidth == $targetWidth && $gdWidth == $this->image['width'] && $gdHeight == $this->image['height'] && $gdHeight == $targetHeight) return 0;
        if($gdWidth == $targetWidth && $gdHeight == $targetHeight) return 2;
        return 4;
    }

    /**
     * Helper function to perform a cropExtra / cropBefore cropping
     *
     * Intended for use by the getFocusZoomCropDimensions() method
     *
     * @param string $focus (focus point in percent, like: 54.7%)
     * @param int $sourceDimension (source image width or height)
     * @param int $cropDimension (target crop-image width or height)
     * @param int $zoom
     *
     * @return int $position (crop position x or y in pixel)
     *
     */
    protected function getFocusZoomPosition($focus, $sourceDimension, $cropDimension, $zoom) {
        $focus = intval($focus); // string with float value and percent char, (needs to be converted to integer)
        $scale = 1 + (($zoom / 100) * 2);
        $focusPX = ($sourceDimension / 100 * $focus);
        $posMinPX = $cropDimension / 2 / $scale;
        $posMaxPX = $sourceDimension - ($cropDimension / 2);

        // calculate the position in pixel !
        if($focusPX >= $posMaxPX) {
            $posPX = $sourceDimension - $cropDimension;
        } else if($focusPX <= $posMinPX) {
            $posPX = 0;
        } else {
            $posPX = $focusPX - ($cropDimension / 2);
            if(0 > $posPX) $posPX = 0;
        }

        return $posPX;
    }

    /**
     * Get an array of the 4 dimensions necessary to perform a cropExtra / cropBefore cropping
     *
     * Intended for use by the resize() method
     *
     * @param int $zoom
     * @param int $fullWidth
     * @param int $fullHeight
     * @param int $finalWidth
     * @param int $finalHeight
     * @return array
     *
     */
    protected function getFocusZoomCropDimensions($zoom, $fullWidth, $fullHeight, $finalWidth, $finalHeight) {
        // validate & calculate / prepare params
        $zoom = $zoom <= 70 ? $zoom : 70; // validate / correct the zoom value, it needs to be between 2 and 70
        $zoom = $zoom >= 2 ? $zoom : 2;

        // calculate the max crop dimensions
        $ratioFinal = $finalWidth / $finalHeight; // get the ratio of the requested crop
        $percentW = $finalWidth / $fullWidth * 100; // calculate percentage of the crop width in regard of the original width
        $percentH = $finalHeight / $fullHeight * 100; // calculate percentage of the crop height in regard of the original height
        if($percentW >= $percentH) { // check wich one is greater
            $maxW = $fullWidth; // if percentW is greater, maxW becomes the original Width
            $maxH = $fullWidth / $ratioFinal; // ... and maxH gets calculated via the ratio
        } else {
            $maxH = $fullHeight; // if percentH is greater, maxH becomes the original Height
            $maxW = $fullHeight * $ratioFinal; // ... and maxW gets calculated via the ratio
        }

        // calculate the zoomed dimensions
        $cropW = $maxW - ($maxW * $zoom / 100); // to get the final crop Width and Height, the amount for zoom-in
        $cropH = $maxH - ($maxH * $zoom / 100); // needs to get stripped out

        // validate against the minimal dimensions
        if(!$this->upscaling) { // if upscaling isn't allowed, we decrease the zoom, so that we get a crop with the min-Dimensions
            if($cropW < $finalWidth) {
                $cropW = $finalWidth;
                $cropH = $finalWidth / $ratioFinal;
            }
            if($cropH < $finalHeight) {
                $cropH = $finalHeight;
                $cropW = $finalHeight * $ratioFinal;
            }
        }

        // calculate the crop positions
        $posX = $this->getFocusZoomPosition($this->cropping[0], $fullWidth, $cropW, $zoom); // calculate the x-position
        $posY = $this->getFocusZoomPosition($this->cropping[1], $fullHeight, $cropH, $zoom); // calculate the y-position

        return array(
            0 => (int) $posX,
            1 => (int) $posY,
            2 => (int) $cropW,
            3 => (int) $cropH
        );
    }

    /**
     * Get current zoom percentage setting or 0 if not set
     * 
     * Value is determined from the $this->cropping array index 2 and is used only if index 0 and
     * index 1 are percentages (and indicated as such with a percent sign). 
     * 
     * @return int
     * 
     */
    protected function getFocusZoomPercent() {
        // check if we have to proceed a zoomed focal point cropping,
        // therefore we need index 0 and 1 to be strings with '%' sign included
        // and index 2 to be an integer between 2 and 70
        $a = $this->cropping;
        if(is_array($a) && isset($a[2]) && strpos($a[0], '%') !== false && strpos($a[1], '%') !== false) {
            $zoom = (int) $a[2];
            if($zoom < 2) $zoom = 0;
            if($zoom > 70) $zoom = 70;
        } else {
            $zoom = 0;
        }
        return $zoom;
    }

    /**
     * Module info: not-autoload
     * 
     * @return bool
     * 
     */
    public function isAutoload() {
        return false;
    }

    /**
     * Module info: not singular
     * 
     * @return bool
     * 
     */
    public function isSingular() {
        return false;
    }

    /**
     * Set module config data for ConfigurableModule interface
     * 
     * @param array $data
     * 
     */
    public function setConfigData(array $data) {
        if(count($data)) $this->moduleConfigData = $data;
        foreach($data as $key => $value) {
            if($key == 'sharpening') {
                $this->setSharpening($value);
            } else if($key == 'quality') {
                $this->setQuality($value);
            } else {
                $this->set($key, $value);
            }
        }
    }

    /**
     * Get module config data
     * 
     * @return array
     * 
     */
    public function getConfigData() {
        return $this->moduleConfigData;
    }

    /**
     * Get library version string
     * 
     * @return string Returns version string or blank string if not applicable/available
     * @since 3.0.138
     * 
     */
    public function getLibraryVersion() {
        return '';
    }

    /**
     * Module configuration
     * 
     * @param InputfieldWrapper $inputfields
     * 
     */
    public function getModuleConfigInputfields(InputfieldWrapper $inputfields) {
        
        $f = $this->wire('modules')->get('InputfieldInteger');
        $f->attr('name', 'enginePriority');
        $f->label = $this->_('Engine priority');
        $f->description = $this->_('This determines what order this engine is tried in relation to other ImageSizerEngine modules.');
        $f->description .= ' ' . $this->_('The lower the number, the more preference you give it.');
        $f->description .= ' ' . $this->_('If you have other ImageSizerEngine modules installed, make sure no two have the same priority.');
        $f->attr('value', $this->enginePriority);
        $f->icon = 'sort-numeric-asc';
        $inputfields->add($f);
        
        $f = $this->wire('modules')->get('InputfieldRadios');
        $f->attr('name', 'sharpening'); 
        $f->label = $this->_('Sharpening');
        $f->addOption('none', $this->_('None'));
        $f->addOption('soft', $this->_('Soft'));
        $f->addOption('medium', $this->_('Medium'));
        $f->addOption('strong', $this->_('Strong'));
        $f->optionColumns = 1;
        $f->attr('value', $this->sharpening);
        $f->icon = 'image';
        $inputfields->add($f);

        $f = $this->wire('modules')->get('InputfieldInteger');
        $f->attr('name', 'quality');
        $f->label = $this->_('Quality');
        $f->description = $this->_('Default quality setting from 1 to 100 where 1 is lowest quality, and 100 is highest.');
        $f->attr('value', $this->quality);
        $f->min = 0;
        $f->max = 100;
        $f->icon = 'dashboard';
        $inputfields->add($f);
    }

}