Image_Transform_Driver_GD::rotate()

Complexity

Conditions	32
Paths	2305

Size

Total Lines	164
Code Lines	115

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    public function rotate($angle, $options = null)
    {
        if (function_exists('imagerotate')) {
            $white             = imagecolorallocatealpha($this->imageHandle, 255, 255, 255, 127);

$this->imageHandle of type string is incompatible with the type GdImage|resource expected by parameter $image of imagecolorallocatealpha().

            $this->imageHandle = imagerotate($this->imageHandle, $angle, $white);

$this->imageHandle of type string is incompatible with the type GdImage|resource expected by parameter $image of imagerotate().

            return true;
        }

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

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

        $t = deg2rad($angle);

        if (!is_array($color_mask)) {
            if ('#' == $color[0]) {
                $this->colorhex2colorarray($color_mask);
            } else {
                include_once('Image/Transform/Driver/ColorDefs.php');
                $color = isset($colornames[$color_mask]) ? $colornames[$color_mask] : false;

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

            }
        }

        // 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) {
            $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 = @$this->newImgPreserveAlpha(imagecreateTrueColor($width2, $height2));

        if (!is_resource($img2)) {
            return false;/*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);

$img of type string is incompatible with the type GdImage|resource expected by parameter $source of imagepalettecopy().

        $mask = imagecolorallocatealpha($img2, $color_mask[0], $color_mask[1], $color_mask[2], 127);
        // 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);

$img of type string is incompatible with the type GdImage|resource expected by parameter $image of imagecolorat().

                        imagesetpixel($img2, $x + $x_offset, $y + $y_offset, $c);
                    }
                }
                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->old_image   = $this->imageHandle;
        $this->imageHandle = $img2;
        return true;
    }