Issues in Gradient.php (master) - Issues in master - XoopsModules25x/xhelp - Measure and Improve Code Quality continuously with Scrutinizer

Issues (1844)

Security Analysis not enabled

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

Header Injection

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

vendor/amenadiel/jpgraph/src/plot/Gradient.php (5 issues)

Labels

Severity

Minor 5

<?php

/**
 * JPGraph v4.0.3
 */

namespace Amenadiel\JpGraph\Plot;

/*
 * File:        JPGRAPH_GRADIENT.PHP
 * // Description: Create a color gradient
 * // Created:     2003-02-01
 * // Ver:         $Id: jpgraph_gradient.php 1761 2009-08-01 08:31:28Z ljp $
 * //
 * // Copyright (c) Asial Corporation. All rights reserved.
 */
use Amenadiel\JpGraph\Util;

/**
 * @class Gradient
 * // Description: Handles gradient fills. This is to be
 * // considered a "friend" class of Class Image.
 */
class Gradient
{
    private $img;
    private $numcolors = 100;

    /**
     * CONSTRUCTOR.
     *
     * @param mixed $img
     */
    public function __construct(&$img)
    {
        $this->img = $img;
    }

    public function SetNumColors($aNum)
    {
        $this->numcolors = $aNum;
    }

    /**
     * PUBLIC METHODS.
     *
     * @param mixed $xl
     * @param mixed $yt
     * @param mixed $xr
     * @param mixed $yb
     * @param mixed $from_color
     * @param mixed $to_color
     * @param mixed $style
     */
    // Produce a gradient filled rectangle with a smooth transition between
    // two colors.
    // ($xl,$yt)  Top left corner
    // ($xr,$yb) Bottom right
    // $from_color Starting color in gradient
    // $to_color End color in the gradient
    // $style  Which way is the gradient oriented?
    public function FilledRectangle($xl, $yt, $xr, $yb, $from_color, $to_color, $style = 1)
    {
        $this->img->SetLineWeight(1);
        switch ($style) {
            case GRAD_VER:
                $steps = ceil(abs($xr - $xl) + 1);
                $delta = $xr >= $xl ? 1 : -1;
                $this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
                for ($i = 0, $x = $xl; $i < $steps; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yt, $x, $yb);
                    $x += $delta;
                }

                break;
            case GRAD_HOR:
                $steps = ceil(abs($yb - $yt) + 1);
                $delta = $yb >= $yt ? 1 : -1;
                $this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
                for ($i = 0, $y = $yt; $i < $steps; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($xl, $y, $xr, $y);
                    $y += $delta;
                }

                break;
            case GRAD_MIDHOR:
                $steps = ceil(abs($yb - $yt) / 2);
                $delta = $yb >= $yt ? 1 : -1;
                $this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
                for ($y = $yt, $i = 0; $i < $steps; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($xl, $y, $xr, $y);
                    $y += $delta;
                }
                --$i;
                if (abs($yb - $yt) % 2 == 1) {
                    --$steps;
                }
                for ($j = 0; $j < $steps; ++$j, --$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($xl, $y, $xr, $y);
                    $y += $delta;
                }
                $this->img->Line($xl, $y, $xr, $y);

                break;
            case GRAD_MIDVER:
                $steps = ceil(abs($xr - $xl) / 2);
                $delta = $xr >= $xl ? 1 : -1;
                $this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
                for ($x = $xl, $i = 0; $i < $steps; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }
                --$i;
                if (abs($xr - $xl) % 2 == 1) {
                    --$steps;
                }
                for ($j = 0; $j < $steps; ++$j, --$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }
                $this->img->Line($x, $yb, $x, $yt);

                break;
            case GRAD_WIDE_MIDVER:
                $diff      = ceil(abs($xr - $xl));
                $steps     = floor(abs($diff) / 3);
                $firststep = $diff - 2 * $steps;
                $delta     = $xr >= $xl ? 1 : -1;
                $this->GetColArray($from_color, $to_color, $firststep, $colors, $this->numcolors);
                for ($x = $xl, $i = 0; $i < $firststep; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }
                --$i;
                $this->img->current_color = $colors[$i];
                for ($j = 0; $j < $steps; ++$j) {
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }

                for ($j = 0; $j < $steps; ++$j, --$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }

                break;
            case GRAD_WIDE_MIDHOR:
                $diff      = ceil(abs($yb - $yt));
                $steps     = floor(abs($diff) / 3);
                $firststep = $diff - 2 * $steps;
                $delta     = $yb >= $yt ? 1 : -1;
                $this->GetColArray($from_color, $to_color, $firststep, $colors, $this->numcolors);
                for ($y = $yt, $i = 0; $i < $firststep; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($xl, $y, $xr, $y);
                    $y += $delta;
                }
                --$i;
                $this->img->current_color = $colors[$i];
                for ($j = 0; $j < $steps; ++$j) {
                    $this->img->Line($xl, $y, $xr, $y);
                    $y += $delta;
                }
                for ($j = 0; $j < $steps; ++$j, --$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($xl, $y, $xr, $y);
                    $y += $delta;
                }

                break;
            case GRAD_LEFT_REFLECTION:
                $steps1 = ceil(0.3 * abs($xr - $xl));
                $delta  = $xr >= $xl ? 1 : -1;

                $from_color  = $this->img->rgb->Color($from_color);
                $adj         = 1.4;
                $m           = ($adj - 1.0) * (255 - min(255, min($from_color[0], min($from_color[1], $from_color[2]))));
                $from_color2 = [min(255, $from_color[0] + $m),
                    min(255, $from_color[1] + $m), min(255, $from_color[2] + $m), ];

                $this->GetColArray($from_color2, $to_color, $steps1, $colors, $this->numcolors);
                $n = safe_count($colors);
                for ($x = $xl, $i = 0; $i < $steps1 && $i < $n; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }
                $steps2 = max(1, ceil(0.08 * abs($xr - $xl)));
                $this->img->SetColor($to_color);
                for ($j = 0; $j < $steps2; ++$j) {
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }
                $steps = abs($xr - $xl) - $steps1 - $steps2;
                $this->GetColArray($to_color, $from_color, $steps, $colors, $this->numcolors);
                $n = safe_count($colors);
                for ($i = 0; $i < $steps && $i < $n; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }

                break;
            case GRAD_RIGHT_REFLECTION:
                $steps1 = ceil(0.7 * abs($xr - $xl));
                $delta  = $xr >= $xl ? 1 : -1;

                $this->GetColArray($from_color, $to_color, $steps1, $colors, $this->numcolors);
                $n = safe_count($colors);
                for ($x = $xl, $i = 0; $i < $steps1 && $i < $n; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }
                $steps2 = max(1, ceil(0.08 * abs($xr - $xl)));
                $this->img->SetColor($to_color);
                for ($j = 0; $j < $steps2; ++$j) {
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }

                $from_color = $this->img->rgb->Color($from_color);
                $adj        = 1.4;
                $m          = ($adj - 1.0) * (255 - min(255, min($from_color[0], min($from_color[1], $from_color[2]))));
                $from_color = [min(255, $from_color[0] + $m),
                    min(255, $from_color[1] + $m), min(255, $from_color[2] + $m), ];

                $steps = abs($xr - $xl) - $steps1 - $steps2;
                $this->GetColArray($to_color, $from_color, $steps, $colors, $this->numcolors);
                $n = safe_count($colors);
                for ($i = 0; $i < $steps && $i < $n; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }

                break;
            case GRAD_CENTER:
                $steps = ceil(min(($yb - $yt) + 1, ($xr - $xl) + 1) / 2);
                $this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
                $dx = ($xr - $xl) / 2;
                $dy = ($yb - $yt) / 2;
                $x  = $xl;

                $y  = $yt;
                $x2 = $xr;
                $y2 = $yb;
                $n  = safe_count($colors);
                for ($x = $xl, $i = 0; $x < $xl + $dx && $y < $yt + $dy && $i < $n; ++$x, ++$y, --$x2, --$y2, ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Rectangle($x, $y, $x2, $y2);
                }
                $this->img->Line($x, $y, $x2, $y2);

                break;
            case GRAD_RAISED_PANEL:
                // right to left
                $steps1 = $xr - $xl;
                $delta  = $xr >= $xl ? 1 : -1;
                $this->GetColArray($to_color, $from_color, $steps1, $colors, $this->numcolors);
                $n = safe_count($colors);
                for ($x = $xl, $i = 0; $i < $steps1 && $i < $n; ++$i) {
                    $this->img->current_color = $colors[$i];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }

                // left to right
                $xr -= 3;
                $xl += 3;
                $yb -= 3;
                $yt += 3;
                $steps2 = $xr - $xl;
                $delta  = $xr >= $xl ? 1 : -1;
                for ($x = $xl, $j = $steps2; $j >= 0; --$j) {
                    $this->img->current_color = $colors[$j];
                    $this->img->Line($x, $yb, $x, $yt);
                    $x += $delta;
                }

                break;
            case GRAD_DIAGONAL:
                // use the longer dimension to determine the required number of steps.
                // first loop draws from one corner to the mid-diagonal and the second
                // loop draws from the mid-diagonal to the opposing corner.
                if ($xr - $xl > $yb - $yt) {
                    // width is greater than height -> use x-dimension for steps
                    $steps = $xr - $xl;
                    $delta = $xr >= $xl ? 1 : -1;
                    $this->GetColArray($from_color, $to_color, $steps * 2, $colors, $this->numcolors);
                    $n = safe_count($colors);

                    for ($x = $xl, $i = 0; $i < $steps && $i < $n; ++$i) {
                        $this->img->current_color = $colors[$i];
                        $y                        = $yt + ($i / $steps) * ($yb - $yt) * $delta;
                        $this->img->Line($x, $yt, $xl, $y);
                        $x += $delta;
                    }

                    for ($x = $xl, $i = 0; $i < $steps && $i < $n; ++$i) {
                        $this->img->current_color = $colors[$steps + $i];
                        $y                        = $yt + ($i / $steps) * ($yb - $yt) * $delta;
                        $this->img->Line($x, $yb, $xr, $y);
                        $x += $delta;
                    }
                } else {
                    // height is greater than width -> use y-dimension for steps
                    $steps = $yb - $yt;
                    $delta = $yb >= $yt ? 1 : -1;
                    $this->GetColArray($from_color, $to_color, $steps * 2, $colors, $this->numcolors);
                    $n = safe_count($colors);

                    for ($y = $yt, $i = 0; $i < $steps && $i < $n; ++$i) {
                        $this->img->current_color = $colors[$i];
                        $x                        = $xl + ($i / $steps) * ($xr - $xl) * $delta;
                        $this->img->Line($x, $yt, $xl, $y);
                        $y += $delta;
                    }

                    for ($y = $yt, $i = 0; $i < $steps && $i < $n; ++$i) {
                        $this->img->current_color = $colors[$steps + $i];
                        $x                        = $xl + ($i / $steps) * ($xr - $xl) * $delta;
                        $this->img->Line($x, $yb, $xr, $y);
                        $x += $delta;
                    }
                }

                break;
            default:
                Util\JpGraphError::RaiseL(7001, $style);
                //("Unknown gradient style (=$style).");
                break;
        }
    }

    // Fill a special case of a polygon with a flat bottom
    // with a gradient. Can be used for filled line plots.
    // Please note that this is NOT a generic gradient polygon fill
    // routine. It assumes that the bottom is flat (like a drawing
    // of a mountain)
    public function FilledFlatPolygon($pts, $from_color, $to_color)
    {
        if (safe_count($pts) == 0) {
            return;
        }

        $maxy = $pts[1];
        $miny = $pts[1];
        $n    = safe_count($pts);
        for ($i = 0, $idx = 0; $i < $n; $i += 2) {

            $x    = round($pts[$i]);

            $y    = round($pts[$i + 1]);
            $miny = min($miny, $y);
            $maxy = max($maxy, $y);
        }

        $colors = [];
        $this->GetColArray($from_color, $to_color, abs($maxy - $miny) + 1, $colors, $this->numcolors);
        for ($i = $miny, $idx = 0; $i <= $maxy; ++$i) {
            $colmap[$i] = $colors[$idx++];
        }

        $n   = safe_count($pts) / 2;
        $idx = 0;
        while ($idx < $n - 1) {
            $p1 = [round($pts[$idx * 2]), round($pts[$idx * 2 + 1])];
            $p2 = [round($pts[++$idx * 2]), round($pts[$idx * 2 + 1])];

            // Find the largest rectangle we can fill
            $y = max($p1[1], $p2[1]);
            for ($yy = $maxy; $yy > $y; --$yy) {
                $this->img->current_color = $colmap[$yy];

                $this->img->Line($p1[0], $yy, $p2[0] - 1, $yy);
            }

            if ($p1[1] == $p2[1]) {
                continue;
            }

            // Fill the rest using lines (slow...)
            $slope = ($p2[0] - $p1[0]) / ($p1[1] - $p2[1]);
            $x1    = $p1[0];
            $x2    = $p2[0] - 1;
            $start = $y;
            if ($p1[1] > $p2[1]) {
                while ($y >= $p2[1]) {
                    $x1                       = $slope * ($start - $y) + $p1[0];
                    $this->img->current_color = $colmap[$y];
                    $this->img->Line($x1, $y, $x2, $y);
                    --$y;
                }
            } else {
                while ($y >= $p1[1]) {
                    $x2                       = $p2[0] + $slope * ($start - $y);
                    $this->img->current_color = $colmap[$y];
                    $this->img->Line($x1, $y, $x2, $y);
                    --$y;
                }
            }
        }
    }

    /**
     * PRIVATE METHODS.
     *
     * @param mixed $from_color
     * @param mixed $to_color
     * @param mixed $arr_size
     * @param mixed $numcols
     * @param mixed $colors
     */
    // Add to the image color map the necessary colors to do the transition
    // between the two colors using $numcolors intermediate colors
    public function GetColArray($from_color, $to_color, $arr_size, &$colors, $numcols = 100)
    {
        if ($arr_size == 0) {
            return;
        }

        // If color is given as text get it's corresponding r,g,b values
        $from_color = $this->img->rgb->Color($from_color);
        $to_color   = $this->img->rgb->Color($to_color);

        $rdelta        = ($to_color[0] - $from_color[0]) / $numcols;
        $gdelta        = ($to_color[1] - $from_color[1]) / $numcols;
        $bdelta        = ($to_color[2] - $from_color[2]) / $numcols;
        $colorsperstep = $numcols / $arr_size;
        $prevcolnum    = -1;
        $from_alpha    = $from_color[3];
        $to_alpha      = $to_color[3];
        $adelta        = ($to_alpha - $from_alpha) / $numcols;

        for ($i = 0; $i < $arr_size; ++$i) {
            $colnum = floor($colorsperstep * $i);
            if ($colnum == $prevcolnum) {
                $colors[$i] = $colidx;

            } else {
                $r     = floor($from_color[0] + $colnum * $rdelta);
                $g     = floor($from_color[1] + $colnum * $gdelta);
                $b     = floor($from_color[2] + $colnum * $bdelta);
                $alpha = $from_alpha + $colnum * $adelta;

                $colidx     = $this->img->rgb->Allocate(sprintf('#%02x%02x%02x', $r, $g, $b), $alpha);
                $colors[$i] = $colidx;
            }
            $prevcolnum = $colnum;
        }
    }
} // @class


1			<?php
2
3			/**
4			* JPGraph v4.0.3
5			*/
6
7			namespace Amenadiel\JpGraph\Plot;
8
9			/*
10			* File: JPGRAPH_GRADIENT.PHP
11			* // Description: Create a color gradient
12			* // Created: 2003-02-01
13			* // Ver: $Id: jpgraph_gradient.php 1761 2009-08-01 08:31:28Z ljp $
14			* //
15			* // Copyright (c) Asial Corporation. All rights reserved.
16			*/
17			use Amenadiel\JpGraph\Util;
18
19			/**
20			* @class Gradient
21			* // Description: Handles gradient fills. This is to be
22			* // considered a "friend" class of Class Image.
23			*/
24			class Gradient
25			{
26			private $img;
27			private $numcolors = 100;
28
29			/**
30			* CONSTRUCTOR.
31			*
32			* @param mixed $img
33			*/
34			public function __construct(&$img)
35			{
36			$this->img = $img;
37			}
38
39			public function SetNumColors($aNum)
40			{
41			$this->numcolors = $aNum;
42			}
43
44			/**
45			* PUBLIC METHODS.
46			*
47			* @param mixed $xl
48			* @param mixed $yt
49			* @param mixed $xr
50			* @param mixed $yb
51			* @param mixed $from_color
52			* @param mixed $to_color
53			* @param mixed $style
54			*/
55			// Produce a gradient filled rectangle with a smooth transition between
56			// two colors.
57			// ($xl,$yt) Top left corner
58			// ($xr,$yb) Bottom right
59			// $from_color Starting color in gradient
60			// $to_color End color in the gradient
61			// $style Which way is the gradient oriented?
62			public function FilledRectangle($xl, $yt, $xr, $yb, $from_color, $to_color, $style = 1)
63			{
64			$this->img->SetLineWeight(1);
65			switch ($style) {
66			case GRAD_VER:
67			$steps = ceil(abs($xr - $xl) + 1);
68			$delta = $xr >= $xl ? 1 : -1;
69			$this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
70			for ($i = 0, $x = $xl; $i < $steps; ++$i) {
71			$this->img->current_color = $colors[$i];
72			$this->img->Line($x, $yt, $x, $yb);
73			$x += $delta;
74			}
75
76			break;
77			case GRAD_HOR:
78			$steps = ceil(abs($yb - $yt) + 1);
79			$delta = $yb >= $yt ? 1 : -1;
80			$this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
81			for ($i = 0, $y = $yt; $i < $steps; ++$i) {
82			$this->img->current_color = $colors[$i];
83			$this->img->Line($xl, $y, $xr, $y);
84			$y += $delta;
85			}
86
87			break;
88			case GRAD_MIDHOR:
89			$steps = ceil(abs($yb - $yt) / 2);
90			$delta = $yb >= $yt ? 1 : -1;
91			$this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
92			for ($y = $yt, $i = 0; $i < $steps; ++$i) {
93			$this->img->current_color = $colors[$i];
94			$this->img->Line($xl, $y, $xr, $y);
95			$y += $delta;
96			}
97			--$i;
98			if (abs($yb - $yt) % 2 == 1) {
99			--$steps;
100			}
101			for ($j = 0; $j < $steps; ++$j, --$i) {
102			$this->img->current_color = $colors[$i];
103			$this->img->Line($xl, $y, $xr, $y);
104			$y += $delta;
105			}
106			$this->img->Line($xl, $y, $xr, $y);
107
108			break;
109			case GRAD_MIDVER:
110			$steps = ceil(abs($xr - $xl) / 2);
111			$delta = $xr >= $xl ? 1 : -1;
112			$this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
113			for ($x = $xl, $i = 0; $i < $steps; ++$i) {
114			$this->img->current_color = $colors[$i];
115			$this->img->Line($x, $yb, $x, $yt);
116			$x += $delta;
117			}
118			--$i;
119			if (abs($xr - $xl) % 2 == 1) {
120			--$steps;
121			}
122			for ($j = 0; $j < $steps; ++$j, --$i) {
123			$this->img->current_color = $colors[$i];
124			$this->img->Line($x, $yb, $x, $yt);
125			$x += $delta;
126			}
127			$this->img->Line($x, $yb, $x, $yt);
128
129			break;
130			case GRAD_WIDE_MIDVER:
131			$diff = ceil(abs($xr - $xl));
132			$steps = floor(abs($diff) / 3);
133			$firststep = $diff - 2 * $steps;
134			$delta = $xr >= $xl ? 1 : -1;
135			$this->GetColArray($from_color, $to_color, $firststep, $colors, $this->numcolors);
136			for ($x = $xl, $i = 0; $i < $firststep; ++$i) {
137			$this->img->current_color = $colors[$i];
138			$this->img->Line($x, $yb, $x, $yt);
139			$x += $delta;
140			}
141			--$i;
142			$this->img->current_color = $colors[$i];
143			for ($j = 0; $j < $steps; ++$j) {
144			$this->img->Line($x, $yb, $x, $yt);
145			$x += $delta;
146			}
147
148			for ($j = 0; $j < $steps; ++$j, --$i) {
149			$this->img->current_color = $colors[$i];
150			$this->img->Line($x, $yb, $x, $yt);
151			$x += $delta;
152			}
153
154			break;
155			case GRAD_WIDE_MIDHOR:
156			$diff = ceil(abs($yb - $yt));
157			$steps = floor(abs($diff) / 3);
158			$firststep = $diff - 2 * $steps;
159			$delta = $yb >= $yt ? 1 : -1;
160			$this->GetColArray($from_color, $to_color, $firststep, $colors, $this->numcolors);
161			for ($y = $yt, $i = 0; $i < $firststep; ++$i) {
162			$this->img->current_color = $colors[$i];
163			$this->img->Line($xl, $y, $xr, $y);
164			$y += $delta;
165			}
166			--$i;
167			$this->img->current_color = $colors[$i];
168			for ($j = 0; $j < $steps; ++$j) {
169			$this->img->Line($xl, $y, $xr, $y);
170			$y += $delta;
171			}
172			for ($j = 0; $j < $steps; ++$j, --$i) {
173			$this->img->current_color = $colors[$i];
174			$this->img->Line($xl, $y, $xr, $y);
175			$y += $delta;
176			}
177
178			break;
179			case GRAD_LEFT_REFLECTION:
180			$steps1 = ceil(0.3 * abs($xr - $xl));
181			$delta = $xr >= $xl ? 1 : -1;
182
183			$from_color = $this->img->rgb->Color($from_color);
184			$adj = 1.4;
185			$m = ($adj - 1.0) * (255 - min(255, min($from_color[0], min($from_color[1], $from_color[2]))));
186			$from_color2 = [min(255, $from_color[0] + $m),
187			min(255, $from_color[1] + $m), min(255, $from_color[2] + $m), ];
188
189			$this->GetColArray($from_color2, $to_color, $steps1, $colors, $this->numcolors);
190			$n = safe_count($colors);
191			for ($x = $xl, $i = 0; $i < $steps1 && $i < $n; ++$i) {
192			$this->img->current_color = $colors[$i];
193			$this->img->Line($x, $yb, $x, $yt);
194			$x += $delta;
195			}
196			$steps2 = max(1, ceil(0.08 * abs($xr - $xl)));
197			$this->img->SetColor($to_color);
198			for ($j = 0; $j < $steps2; ++$j) {
199			$this->img->Line($x, $yb, $x, $yt);
200			$x += $delta;
201			}
202			$steps = abs($xr - $xl) - $steps1 - $steps2;
203			$this->GetColArray($to_color, $from_color, $steps, $colors, $this->numcolors);
204			$n = safe_count($colors);
205			for ($i = 0; $i < $steps && $i < $n; ++$i) {
206			$this->img->current_color = $colors[$i];
207			$this->img->Line($x, $yb, $x, $yt);
208			$x += $delta;
209			}
210
211			break;
212			case GRAD_RIGHT_REFLECTION:
213			$steps1 = ceil(0.7 * abs($xr - $xl));
214			$delta = $xr >= $xl ? 1 : -1;
215
216			$this->GetColArray($from_color, $to_color, $steps1, $colors, $this->numcolors);
217			$n = safe_count($colors);
218			for ($x = $xl, $i = 0; $i < $steps1 && $i < $n; ++$i) {
219			$this->img->current_color = $colors[$i];
220			$this->img->Line($x, $yb, $x, $yt);
221			$x += $delta;
222			}
223			$steps2 = max(1, ceil(0.08 * abs($xr - $xl)));
224			$this->img->SetColor($to_color);
225			for ($j = 0; $j < $steps2; ++$j) {
226			$this->img->Line($x, $yb, $x, $yt);
227			$x += $delta;
228			}
229
230			$from_color = $this->img->rgb->Color($from_color);
231			$adj = 1.4;
232			$m = ($adj - 1.0) * (255 - min(255, min($from_color[0], min($from_color[1], $from_color[2]))));
233			$from_color = [min(255, $from_color[0] + $m),
234			min(255, $from_color[1] + $m), min(255, $from_color[2] + $m), ];
235
236			$steps = abs($xr - $xl) - $steps1 - $steps2;
237			$this->GetColArray($to_color, $from_color, $steps, $colors, $this->numcolors);
238			$n = safe_count($colors);
239			for ($i = 0; $i < $steps && $i < $n; ++$i) {
240			$this->img->current_color = $colors[$i];
241			$this->img->Line($x, $yb, $x, $yt);
242			$x += $delta;
243			}
244
245			break;
246			case GRAD_CENTER:
247			$steps = ceil(min(($yb - $yt) + 1, ($xr - $xl) + 1) / 2);
248			$this->GetColArray($from_color, $to_color, $steps, $colors, $this->numcolors);
249			$dx = ($xr - $xl) / 2;
250			$dy = ($yb - $yt) / 2;
251			$x = $xl;
			0 ignored issues – show Unused Code introduced 2022-01-13 23:33 UTC by Report Bug Copy Issue Report Show Similar Issues like this The assignment to `$x` is dead and can be removed. Loading history...
252			$y = $yt;
253			$x2 = $xr;
254			$y2 = $yb;
255			$n = safe_count($colors);
256			for ($x = $xl, $i = 0; $x < $xl + $dx && $y < $yt + $dy && $i < $n; ++$x, ++$y, --$x2, --$y2, ++$i) {
257			$this->img->current_color = $colors[$i];
258			$this->img->Rectangle($x, $y, $x2, $y2);
259			}
260			$this->img->Line($x, $y, $x2, $y2);
261
262			break;
263			case GRAD_RAISED_PANEL:
264			// right to left
265			$steps1 = $xr - $xl;
266			$delta = $xr >= $xl ? 1 : -1;
267			$this->GetColArray($to_color, $from_color, $steps1, $colors, $this->numcolors);
268			$n = safe_count($colors);
269			for ($x = $xl, $i = 0; $i < $steps1 && $i < $n; ++$i) {
270			$this->img->current_color = $colors[$i];
271			$this->img->Line($x, $yb, $x, $yt);
272			$x += $delta;
273			}
274
275			// left to right
276			$xr -= 3;
277			$xl += 3;
278			$yb -= 3;
279			$yt += 3;
280			$steps2 = $xr - $xl;
281			$delta = $xr >= $xl ? 1 : -1;
282			for ($x = $xl, $j = $steps2; $j >= 0; --$j) {
283			$this->img->current_color = $colors[$j];
284			$this->img->Line($x, $yb, $x, $yt);
285			$x += $delta;
286			}
287
288			break;
289			case GRAD_DIAGONAL:
290			// use the longer dimension to determine the required number of steps.
291			// first loop draws from one corner to the mid-diagonal and the second
292			// loop draws from the mid-diagonal to the opposing corner.
293			if ($xr - $xl > $yb - $yt) {
294			// width is greater than height -> use x-dimension for steps
295			$steps = $xr - $xl;
296			$delta = $xr >= $xl ? 1 : -1;
297			$this->GetColArray($from_color, $to_color, $steps * 2, $colors, $this->numcolors);
298			$n = safe_count($colors);
299
300			for ($x = $xl, $i = 0; $i < $steps && $i < $n; ++$i) {
301			$this->img->current_color = $colors[$i];
302			$y = $yt + ($i / $steps) * ($yb - $yt) * $delta;
303			$this->img->Line($x, $yt, $xl, $y);
304			$x += $delta;
305			}
306
307			for ($x = $xl, $i = 0; $i < $steps && $i < $n; ++$i) {
308			$this->img->current_color = $colors[$steps + $i];
309			$y = $yt + ($i / $steps) * ($yb - $yt) * $delta;
310			$this->img->Line($x, $yb, $xr, $y);
311			$x += $delta;
312			}
313			} else {
314			// height is greater than width -> use y-dimension for steps
315			$steps = $yb - $yt;
316			$delta = $yb >= $yt ? 1 : -1;
317			$this->GetColArray($from_color, $to_color, $steps * 2, $colors, $this->numcolors);
318			$n = safe_count($colors);
319
320			for ($y = $yt, $i = 0; $i < $steps && $i < $n; ++$i) {
321			$this->img->current_color = $colors[$i];
322			$x = $xl + ($i / $steps) * ($xr - $xl) * $delta;
323			$this->img->Line($x, $yt, $xl, $y);
324			$y += $delta;
325			}
326
327			for ($y = $yt, $i = 0; $i < $steps && $i < $n; ++$i) {
328			$this->img->current_color = $colors[$steps + $i];
329			$x = $xl + ($i / $steps) * ($xr - $xl) * $delta;
330			$this->img->Line($x, $yb, $xr, $y);
331			$x += $delta;
332			}
333			}
334
335			break;
336			default:
337			Util\JpGraphError::RaiseL(7001, $style);
338			//("Unknown gradient style (=$style).");
339			break;
340			}
341			}
342
343			// Fill a special case of a polygon with a flat bottom
344			// with a gradient. Can be used for filled line plots.
345			// Please note that this is NOT a generic gradient polygon fill
346			// routine. It assumes that the bottom is flat (like a drawing
347			// of a mountain)
348			public function FilledFlatPolygon($pts, $from_color, $to_color)
349			{
350			if (safe_count($pts) == 0) {
351			return;
352			}
353
354			$maxy = $pts[1];
355			$miny = $pts[1];
356			$n = safe_count($pts);
357			for ($i = 0, $idx = 0; $i < $n; $i += 2) {
			0 ignored issues – show Unused Code introduced 2022-01-13 23:33 UTC by Report Bug Copy Issue Report Show Similar Issues like this The assignment to `$idx` is dead and can be removed. Loading history...
358			$x = round($pts[$i]);
			0 ignored issues – show Unused Code introduced 2022-01-13 23:33 UTC by Report Bug Copy Issue Report Show Similar Issues like this The assignment to `$x` is dead and can be removed. Loading history...
359			$y = round($pts[$i + 1]);
360			$miny = min($miny, $y);
361			$maxy = max($maxy, $y);
362			}
363
364			$colors = [];
365			$this->GetColArray($from_color, $to_color, abs($maxy - $miny) + 1, $colors, $this->numcolors);
366			for ($i = $miny, $idx = 0; $i <= $maxy; ++$i) {
367			$colmap[$i] = $colors[$idx++];
368			}
369
370			$n = safe_count($pts) / 2;
371			$idx = 0;
372			while ($idx < $n - 1) {
373			$p1 = [round($pts[$idx * 2]), round($pts[$idx * 2 + 1])];
374			$p2 = [round($pts[++$idx * 2]), round($pts[$idx * 2 + 1])];
375
376			// Find the largest rectangle we can fill
377			$y = max($p1[1], $p2[1]);
378			for ($yy = $maxy; $yy > $y; --$yy) {
379			$this->img->current_color = $colmap[$yy];
			0 ignored issues – show Comprehensibility Best Practice introduced 2022-01-13 23:33 UTC by Report Bug Copy Issue Report Show Similar Issues like this The variable `$colmap` does not seem to be defined for all execution paths leading up to this point. Loading history...
380			$this->img->Line($p1[0], $yy, $p2[0] - 1, $yy);
381			}
382
383			if ($p1[1] == $p2[1]) {
384			continue;
385			}
386
387			// Fill the rest using lines (slow...)
388			$slope = ($p2[0] - $p1[0]) / ($p1[1] - $p2[1]);
389			$x1 = $p1[0];
390			$x2 = $p2[0] - 1;
391			$start = $y;
392			if ($p1[1] > $p2[1]) {
393			while ($y >= $p2[1]) {
394			$x1 = $slope * ($start - $y) + $p1[0];
395			$this->img->current_color = $colmap[$y];
396			$this->img->Line($x1, $y, $x2, $y);
397			--$y;
398			}
399			} else {
400			while ($y >= $p1[1]) {
401			$x2 = $p2[0] + $slope * ($start - $y);
402			$this->img->current_color = $colmap[$y];
403			$this->img->Line($x1, $y, $x2, $y);
404			--$y;
405			}
406			}
407			}
408			}
409
410			/**
411			* PRIVATE METHODS.
412			*
413			* @param mixed $from_color
414			* @param mixed $to_color
415			* @param mixed $arr_size
416			* @param mixed $numcols
417			* @param mixed $colors
418			*/
419			// Add to the image color map the necessary colors to do the transition
420			// between the two colors using $numcolors intermediate colors
421			public function GetColArray($from_color, $to_color, $arr_size, &$colors, $numcols = 100)
422			{
423			if ($arr_size == 0) {
424			return;
425			}
426
427			// If color is given as text get it's corresponding r,g,b values
428			$from_color = $this->img->rgb->Color($from_color);
429			$to_color = $this->img->rgb->Color($to_color);
430
431			$rdelta = ($to_color[0] - $from_color[0]) / $numcols;
432			$gdelta = ($to_color[1] - $from_color[1]) / $numcols;
433			$bdelta = ($to_color[2] - $from_color[2]) / $numcols;
434			$colorsperstep = $numcols / $arr_size;
435			$prevcolnum = -1;
436			$from_alpha = $from_color[3];
437			$to_alpha = $to_color[3];
438			$adelta = ($to_alpha - $from_alpha) / $numcols;
439
440			for ($i = 0; $i < $arr_size; ++$i) {
441			$colnum = floor($colorsperstep * $i);
442			if ($colnum == $prevcolnum) {
443			$colors[$i] = $colidx;
			0 ignored issues – show Comprehensibility Best Practice introduced 2022-01-13 23:33 UTC by Report Bug Copy Issue Report Show Similar Issues like this The variable `$colidx` does not seem to be defined for all execution paths leading up to this point. Loading history...
444			} else {
445			$r = floor($from_color[0] + $colnum * $rdelta);
446			$g = floor($from_color[1] + $colnum * $gdelta);
447			$b = floor($from_color[2] + $colnum * $bdelta);
448			$alpha = $from_alpha + $colnum * $adelta;
449
450			$colidx = $this->img->rgb->Allocate(sprintf('#%02x%02x%02x', $r, $g, $b), $alpha);
451			$colors[$i] = $colidx;
452			}
453			$prevcolnum = $colnum;
454			}
455			}
456			} // @class
457

XoopsModules25x / xhelp

Issues (1844)

Security Analysis not enabled

vendor/amenadiel/jpgraph/src/plot/Gradient.php (5 issues)

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like