Stojg\Crop\CropEntropy

Complexity

Total Complexity

22

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	6
Bugs	0	Features	2

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	getImage()	0	4	1
A	getRegion()	0	4	1
A	area()	0	5	1
A	compare()	0	11	3
A	getGrayScaleEntropy()	0	5	1
C	getMidPoint()	0	58	9
A	getEntropy()	0	12	2
A	getVerticalSlice()	0	5	1
A	getHorizontalSlice()	0	5	1

<?php

namespace Stojg\Crop;

use Imagick;
use ImagickPixel;
use InvalidArgumentException;

/**
 * Class CropEntropy
 *
 * This class will help on finding the most energetic part of an image.
 *
 * @package Stojg\Crop
 */
class CropEntropy
{
    /**
     * @var Imagick
     */
    protected $image = null;

    /**
     * CropEntropy constructor
     *
     * @param Imagick|null $image
     */
    public function __construct(Imagick $image = null)
    {
        if ($image !== null) {
            $this->image = $image;
        } else {
            $this->image = new Imagick();
        }
    }

    /**
     * @return Imagick
     */
    public function getImage()
    {
        return $this->image;
    }

    /**
     * @param int $width - The width of the region to be extracted
     * @param int $height - The height of the region to be extracted
     * @param int $x - X-coordinate of the top-left corner of the region to be extracted
     * @param int $y -Y-coordinate of the top-left corner of the region to be extracted
     * @return CropEntropy
     */
    public function getRegion($width, $height, $x, $y)
    {
        return new CropEntropy($this->image->getImageRegion($width, $height, $x, $y));
    }

    /**
     * Get the area in pixels for this image
     *
     * @return int
     */
    public function area()
    {
        $size = $this->image->getImageGeometry();
        return $size['height'] * $size['width'];
    }

    /**
     * @param CropEntropy $b
     * @return int
     */
    public function compare(CropEntropy $b)
    {
        $aValue = $this->getGrayScaleEntropy();
        $bValue = $b->getGrayScaleEntropy();

        if ($aValue == $bValue) {
            return 0;
        }

        return ($aValue < $bValue) ? -1 : 1;
    }

    /**
     * Calculate the entropy for this image.
     *
     * A higher value of entropy means more noise / liveliness / color / business
     *
     * @return float
     *
     * @see http://brainacle.com/calculating-image-entropy-with-python-how-and-why.html
     * @see http://www.mathworks.com/help/toolbox/images/ref/entropy.html
     */
    public function getGrayScaleEntropy()
    {
        $histogram = $this->image->getImageHistogram();
        return $this->getEntropy($histogram, $this->area());
    }

    /**
     *
     * @param string $axis - must be either 'x' or 'y'
     * @param int $sliceSize
     * @return int
     */
    public function getMidPoint($axis, $sliceSize = 20)
    {
        if (!in_array($axis, ['x', 'y'])) {
            throw new InvalidArgumentException('argument $axis must be either "x" or "y"');
        }

        $targetSize = $sliceSize;

        $clone = clone($this->image);
        $clone->modulateImage(100, 0, 100);
        $clone->setImageColorspace(Imagick::COLORSPACE_GRAY);
        $image = new CropEntropy($clone);

        $size = $clone->getImageGeometry();
        $min = 0;

        if ($axis === 'x') {
            $max = $size['width'];
        } else {
            $max = $size['height'];
        }

        $a = null;
        $b = null;

        // until we have a slice that would fit inside the target size
        do {
            // Make sure that we don't try to slice outside the image
            $sliceSize = min($max - $min - $targetSize, $sliceSize);

            if ($a === null) {
                if ($axis === 'x') {
                    $a = $image->getVerticalSlice($min - 1, $sliceSize);
                } else {
                    $a = $image->getHorizontalSlice($min - 1, $sliceSize);
                }
            }

            if ($b === null) {
                if ($axis === 'x') {
                    $b = $image->getVerticalSlice($max - $sliceSize - 1, $sliceSize);
                } else {
                    $b = $image->getHorizontalSlice($max - $sliceSize - 1, $sliceSize);
                }
            }

            // a has higher energy, so create a new b slice, i.e move b $sliceSize against a
            if ($a->compare($b) > 0) {
                $max -= $sliceSize;
                $b = null;
            } else {
                $min += $sliceSize;
                $a = null;
            }
        } while ($max - $min > $targetSize);

        return $min + ($sliceSize / 2);
    }

    /**
     *
     * @param  ImagickPixel[] $histogram
     * @param  int $area
     * @return float
     */
    protected function getEntropy($histogram, $area)
    {
        $value = 0.0;
        foreach ($histogram as $pixel) {
            // calculates the percentage of pixels having this color value
            $p = $pixel->getColorCount() / $area;
            // A common way of representing entropy in scalar
            $value += $p * log($p, 2);
        }
        // $value is always 0.0 or negative, so transform into positive scalar value
        return -$value;
    }

    public function getVerticalSlice($x, $sliceSize)
    {
        $size = $this->image->getImageGeometry();
        return $this->getRegion($sliceSize, $size['height'], $x, 0);
    }

    public function getHorizontalSlice($y, $sliceSize)
    {
        $size = $this->image->getImageGeometry();
        return $this->getRegion($size['width'], $sliceSize, 0, $y);
    }
}