Image_Transform_Driver_GD1::rotate()

Complexity

Conditions	30
Paths	1728

Size

Total Lines	160
Code Lines	110

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function rotate($angle, $options = null)
    {
        if (null === $options) {

The condition null === $options is always true.

            $autoresize = true;
            $color_mask = [255, 255, 0];
        } else {
            extract($options);
        }

        while ($angle <= -45) {
            $angle += 360;
        }
        while ($angle > 270) {
            $angle -= 360;
        }

        $t = deg2rad($angle);

        if (!is_array($color_mask)) {

The condition is_array($color_mask) is always true.

            // Not already in numberical format, so we convert it.
            if ('#' == $color_mask[0]) {
                $color_mask = $this->colorhex2colorarray($color_mask);
            } else {
                require_once __DIR__ . '/Image/Transform/Driver/ColorsDefs.php';
                $color_mask = $colornames[$color_mask] ?? false;
            }
        }

        // Do not round it, too much lost of quality
        $cosT = cos($t);
        $sinT = sin($t);

        $img = &$this->imageHandle;

        $width  = $max_x = $this->img_x;
        $height = $max_y = $this->img_y;
        $min_y  = 0;
        $min_x  = 0;

        $x1 = round($max_x / 2, 0);
        $y1 = round($max_y / 2, 0);

        if ($autoresize) {

The condition $autoresize is always true.

            $t = abs($t);
            $a = round($angle, 0);

The assignment to $a is dead and can be removed.

            switch ((int)$angle) {
                case 0:
                    $width2  = $width;
                    $height2 = $height;
                    break;
                case 90:
                    $width2  = $height;
                    $height2 = $width;
                    break;
                case 180:
                    $width2  = $width;
                    $height2 = $height;
                    break;
                case 270:
                    $width2  = $height;
                    $height2 = $width;
                    break;
                default:
                    $width2  = (int)abs(sin($t) * $height + cos($t) * $width);
                    $height2 = (int)abs(cos($t) * $height + sin($t) * $width);
            }

            $width2  -= $width2 % 2;
            $height2 -= $height2 % 2;

            $d_width  = abs($width - $width2);
            $d_height = abs($height - $height2);
            $x_offset = $d_width / 2;
            $y_offset = $d_height / 2;
            $min_x2   = -abs($x_offset);
            $min_y2   = -abs($y_offset);
            $max_x2   = $width2;
            $max_y2   = $height2;
        }

        $img2 = @imagecreatetruecolor($width2, $height2);

        if (!is_resource($img2)) {
            return PEAR::raiseError('Cannot create buffer for the rotataion.', null, PEAR_ERROR_TRIGGER, E_USER_NOTICE);
        }

        $this->img_x = $width2;
        $this->img_y = $height2;

        imagepalettecopy($img2, $img);

        $mask = imagecolorresolve($img2, $color_mask[0], $color_mask[1], $color_mask[2]);

        // use simple lines copy for axes angles
        switch ((int)$angle) {
            case 0:
                imagefill($img2, 0, 0, $mask);
                for ($y = 0; $y < $max_y; $y++) {
                    for ($x = $min_x; $x < $max_x; $x++) {
                        $c = @imagecolorat($img, $x, $y);
                        imagesetpixel($img2, $x + $x_offset, $y + $y_offset, $c);

$x + $x_offset of type double is incompatible with the type integer expected by parameter $x of imagesetpixel().

$y + $y_offset of type double is incompatible with the type integer expected by parameter $y of imagesetpixel().

                    }
                }
                break;
            case 90:
                imagefill($img2, 0, 0, $mask);
                for ($x = $min_x; $x < $max_x; $x++) {
                    for ($y = $min_y; $y < $max_y; $y++) {
                        $c = imagecolorat($img, $x, $y);
                        imagesetpixel($img2, $max_y - $y - 1, $x, $c);
                    }
                }
                break;
            case 180:
                imagefill($img2, 0, 0, $mask);
                for ($y = 0; $y < $max_y; $y++) {
                    for ($x = $min_x; $x < $max_x; $x++) {
                        $c = @imagecolorat($img, $x, $y);
                        imagesetpixel($img2, $max_x2 - $x - 1, $max_y2 - $y - 1, $c);
                    }
                }
                break;
            case 270:
                imagefill($img2, 0, 0, $mask);
                for ($y = 0; $y < $max_y; $y++) {
                    for ($x = $max_x; $x >= $min_x; $x--) {
                        $c = @imagecolorat($img, $x, $y);
                        imagesetpixel($img2, $y, $max_x - $x - 1, $c);
                    }
                }
                break;
            // simple reverse rotation algo
            default:
                $i = 0;

The assignment to $i is dead and can be removed.

                for ($y = $min_y2; $y < $max_y2; $y++) {
                    // Algebra :)
                    $x2 = round((($min_x2 - $x1) * $cosT) + (($y - $y1) * $sinT + $x1), 0);
                    $y2 = round(($y - $y1) * $cosT - ($min_x2 - $x1) * $sinT + $y1, 0);

                    for ($x = $min_x2; $x < $max_x2; $x++) {
                        // Check if we are out of original bounces, if we are
                        // use the default color mask
                        if ($x2 >= 0 && $x2 < $max_x && $y2 >= 0 && $y2 < $max_y) {
                            $c = imagecolorat($img, $x2, $y2);

$y2 of type double is incompatible with the type integer expected by parameter $y of imagecolorat().

$x2 of type double is incompatible with the type integer expected by parameter $x of imagecolorat().

                        } else {
                            $c = $mask;
                        }
                        imagesetpixel($img2, $x + $x_offset, $y + $y_offset, $c);

                        // round verboten!
                        $x2 += $cosT;
                        $y2 -= $sinT;
                    }
                }
                break;
        }

        $this->imageHandle = $img2;

        return true;
    }