image\components\Kohana\Image::resize()

Complexity

Conditions	30
Paths	4730

Size

Total Lines	118
Code Lines	69

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    public function resize($width = null, $height = null, $master = null)
    {
        if ($master === null) {
            // Choose the master dimension automatically
            $master = Image::AUTO;
        } elseif ($master === Image::CROP) {
            if (empty($width) || empty($height)) {
                return $this->resize($width, $height, Image::AUTO);
            }

            $master = $this->width / $this->height > $width / $height ? Image::HEIGHT : Image::WIDTH;
            $this->resize($width, $height, $master);

            if ($this->width !== $width || $this->height !== $height) {
                $offset_x = round(($this->width - $width) / 2);
                $offset_y = round(($this->height - $height) / 2);
                $this->crop($width, $height, $offset_x, $offset_y);
            }

            return $this;
        }
        // Image::WIDTH and Image::HEIGHT deprecated. You can use it in old projects,
        // but in new you must pass empty value for non-master dimension
        elseif ($master == Image::WIDTH && !empty($width)) {
            $master = Image::AUTO;

            // Set empty height for backward compatibility
            $height = null;
        } elseif ($master == Image::HEIGHT && !empty($height)) {
            $master = Image::AUTO;

            // Set empty width for backward compatibility
            $width = null;
        } elseif ($master === Image::ADAPT) {
            if (empty($width)) {
                $width = $this->width * $height / $this->height;
            } elseif (empty($height)) {
                $height = $this->height * $width / $this->width;
            }
        }

        if (empty($width)) {
            if ($master === Image::NONE) {
                // Use the current width
                $width = $this->width;
            } else {
                // If width not set, master will be height
                $master = Image::HEIGHT;
            }
        }

        if (empty($height)) {
            if ($master === Image::NONE) {
                // Use the current height
                $height = $this->height;
            } else {
                // If height not set, master will be width
                $master = Image::WIDTH;
            }
        }

        switch ($master) {
            case Image::AUTO:
                // Choose direction with the greatest reduction ratio
                $master = ($this->width / $width) > ($this->height / $height) ? Image::WIDTH : Image::HEIGHT;
                break;
            case Image::INVERSE:
                // Choose direction with the minimum reduction ratio
                $master = ($this->width / $width) > ($this->height / $height) ? Image::HEIGHT : Image::WIDTH;
                break;
        }

        switch ($master) {
            case Image::WIDTH:
                // Recalculate the height based on the width proportions
                $height = $this->height * $width / $this->width;
                break;
            case Image::HEIGHT:
                // Recalculate the width based on the height proportions
                $width = $this->width * $height / $this->height;
                break;
            case Image::PRECISE:
                // Resize to precise size
                $ratio = $this->width / $this->height;

                if ($width / $height > $ratio) {
                    $height = $this->height * $width / $this->width;
                } else {
                    $width = $this->width * $height / $this->height;
                }
                break;
        }

        // Convert the width and height to integers, minimum value is 1px
        $width = max(round($width), 1);
        $height = max(round($height), 1);

        // Adapt the image if the ratios are not equivalent
        if ($master === Image::ADAPT && $width / $height !== $this->width / $this->height) {
            $image_width = $bg_width = $this->width;
            $image_height = $bg_height = $this->height;

            $offset_x = $offset_y = 0;

            if ($width / $height > $image_width / $image_height) {
                $bg_width = floor($image_height * $width / $height);
                $offset_x = abs(floor(($bg_width - $image_width) / 2));
            } else {
                $bg_height = floor($image_width * $height / $width);
                $offset_y = abs(floor(($bg_height - $image_height) / 2));
            }

            $this->_do_adapt($image_width, $image_height, $bg_width, $bg_height, $offset_x, $offset_y);

It seems like $bg_height can also be of type double; however, parameter $bg_height of image\components\drivers\Driver::_do_adapt() does only seem to accept integer, maybe add an additional type check?

It seems like $offset_x can also be of type double; however, parameter $offset_x of image\components\drivers\Driver::_do_adapt() does only seem to accept integer, maybe add an additional type check?

It seems like $bg_width can also be of type double; however, parameter $bg_width of image\components\drivers\Driver::_do_adapt() does only seem to accept integer, maybe add an additional type check?

It seems like $offset_y can also be of type double; however, parameter $offset_y of image\components\drivers\Driver::_do_adapt() does only seem to accept integer, maybe add an additional type check?

        }

        $this->_do_resize($width, $height);

        return $this;
    }