Colors::hsl() - Code Metrics - bytic/utility - Measure and Improve Code Quality continuously with Scrutinizer

Colors::hsl() B
last analyzed 2021-06-22 13:07 UTC

↳ Parent: Colors

Complexity

Conditions	11
Paths	27

Size

Total Lines	39
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	23
CRAP Score	11.0619

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
eloc	24
c	1
b	0
f	1
dl	0
loc	39
ccs	23
cts	25
cp	0.92
rs	7.3166
cc	11
nc	27
nop	1
crap	11.0619

How to fix Complexity

<?php

namespace Nip\Utility;

/**
 * Class Colors
 * @package Nip\Utility
 */
class Colors
{
    /**
     * @return mixed
     */
    public static function colors()
    {
        static $colors = null;
        if ($colors === null) {
            $colors = require dirname(__DIR__) . DIRECTORY_SEPARATOR . 'data' . DIRECTORY_SEPARATOR . 'colors.php';
        }
        return $colors;
    }

    /**
     * @param $color
     * @return array
     */
    public static function rgb($color)
    {
        $red = substr($color, 1, 2);
        $green = substr($color, 3, 2);
        $blue = substr($color, 5, 2);

        $red = hexdec($red);
        $green = hexdec($green);
        $blue = hexdec($blue);

        return [$red, $green, $blue];
    }

    /**
     * @param string $color
     * @return array
     */
    public static function hsl($color)
    {
        list($red, $green, $blue) = static::rgb($color);

        $red /= 255;
        $green /= 255;
        $blue /= 255;

        $min = min([$red, min([$green, $blue])]);
        $max = max([$red, max([$green, $blue])]);

        $delta = $max - $min;
        $lightness = ($min + $max) / 2;

        $saturation = 0;
        if ($lightness > 0 && $lightness < 1) {
            $saturation = $delta / ($lightness < 0.5 ? (2 * $lightness) : 2 - (2 * $lightness));
        }

        $hue = 0;
        if ($delta > 0) {
            if ($max == $red && $max != $green) {
                $hue += ($green - $blue) / $delta;
            }
            if ($max == $green && $max != $blue) {
                $hue += (2 + ($blue - $red) / $delta);
            }
            if ($max == $blue && $max != $red) {
                $hue += (4 + ($red - $green) / $delta);
            }

            $hue /= 6;
        }

        $hue *= 255;
        $saturation *= 255;
        $lightness *= 255;

        return [floor($hue), floor($saturation), floor($lightness)];
    }


    /**
     * @param $color
     * @return array|bool
     */
    public static function name($color)
    {
        $color = strtoupper($color);

        if (strlen($color) < 3 || strlen($color) > 7) {
            return false;
        }

        if (strlen($color) % 3 == 0) {
            $color = '#' . $color;
        }

        if (strlen($color) == 4) {
            $color = '#' . $color[1] . $color[1] . $color[2] . $color[2] . $color[3] . $color[3];
        }

        list($red, $green, $blue) = static::rgb($color);
        list($h, $s, $l) = static::hsl($color);

        $ndf1 = 0;

        $ndf2 = 0;

        $ndf = 0;

        $cl = -1;
        $df = -1;

        $count = count(static::colors());
        $colors = static::colors();

        for ($index = 0; $index < $count; $index++) {
            if ($color == '#' . $colors[$index][0]) {
                return ['#' . $colors[$index][0], $colors[$index][1], true];
            }

            $ndf1 = pow($red - $colors[$index][2], 2) + pow(
                $green - $colors[$index][3],
                2
            ) + pow($blue - $colors[$index][4], 2);
            $ndf2 = abs(pow($h - $colors[$index][5], 2)) + pow(
                $s - $colors[$index][6],
                2
            ) + abs(pow($l - $colors[$index][7], 2));

            $ndf = $ndf1 + $ndf2 * 2;
            if ($df < 0 || $df > $ndf) {
                $df = $ndf;
                $cl = $index;
            }
        }

        return $cl < 0 ? false : ["#" . static::colors()[$cl][0], static::colors()[$cl][1], false];
    }


    /**
     * Uses luminosity to calculate the difference between the given colors.
     * The returned value should be bigger than 5 for best readability.
     *
     * @param string|array $color1
     * @param string|array $color2
     * @return double
     */
    public static function lumDiff($color1, $color2)
    {
        list($red1, $green1, $blue1) = is_array($color1) ? $color1 : static::rgb($color1);
        list($red2, $green2, $blue2) = is_array($color2) ? $color2 : static::rgb($color2);

        $lightness1 = 0.2126 * pow($red1 / 255, 2.2) +
            0.7152 * pow($green1 / 255, 2.2) +
            0.0722 * pow($blue1 / 255, 2.2);

        $lightness2 = 0.2126 * pow($red2 / 255, 2.2) +
            0.7152 * pow($green2 / 255, 2.2) +
            0.0722 * pow($blue2 / 255, 2.2);

        if ($lightness1 > $lightness2) {
            return ($lightness1 + 0.05) / ($lightness2 + 0.05);
        } else {
            return ($lightness2 + 0.05) / ($lightness1 + 0.05);
        }
    }
}


1		<?php
2
3		namespace Nip\Utility;
4
5		/**
6		* Class Colors
7		* @package Nip\Utility
8		*/
9		class Colors
10		{
11		/**
12		* @return mixed
13		*/
14	3	public static function colors()
15		{
16	3	static $colors = null;
17	3	if ($colors === null) {
18	1	$colors = require dirname(__DIR__) . DIRECTORY_SEPARATOR . 'data' . DIRECTORY_SEPARATOR . 'colors.php';
19		}
20	3	return $colors;
21		}
22
23		/**
24		* @param $color
25		* @return array
26		*/
27	4	public static function rgb($color)
28		{
29	4	$red = substr($color, 1, 2);
30	4	$green = substr($color, 3, 2);
31	4	$blue = substr($color, 5, 2);
32
33	4	$red = hexdec($red);
34	4	$green = hexdec($green);
35	4	$blue = hexdec($blue);
36
37	4	return [$red, $green, $blue];
38		}
39
40		/**
41		* @param string $color
42		* @return array
43		*/
44	2	public static function hsl($color)
45		{
46	2	list($red, $green, $blue) = static::rgb($color);
47
48	2	$red /= 255;
49	2	$green /= 255;
50	2	$blue /= 255;
51
52	2	$min = min([$red, min([$green, $blue])]);
53	2	$max = max([$red, max([$green, $blue])]);
54
55	2	$delta = $max - $min;
56	2	$lightness = ($min + $max) / 2;
57
58	2	$saturation = 0;
59	2	if ($lightness > 0 && $lightness < 1) {
60	1	$saturation = $delta / ($lightness < 0.5 ? (2 * $lightness) : 2 - (2 * $lightness));
61		}
62
63	2	$hue = 0;
64	2	if ($delta > 0) {
65	1	if ($max == $red && $max != $green) {
66		$hue += ($green - $blue) / $delta;
67		}
68	1	if ($max == $green && $max != $blue) {
69		$hue += (2 + ($blue - $red) / $delta);
70		}
71	1	if ($max == $blue && $max != $red) {
72	1	$hue += (4 + ($red - $green) / $delta);
73		}
74
75	1	$hue /= 6;
76		}
77
78	2	$hue *= 255;
79	2	$saturation *= 255;
80	2	$lightness *= 255;
81
82	2	return [floor($hue), floor($saturation), floor($lightness)];
83		}
84
85
86		/**
87		* @param $color
88		* @return array\|bool
89		*/
90	2	public static function name($color)
91		{
92	2	$color = strtoupper($color);
93
94	2	if (strlen($color) < 3 \|\| strlen($color) > 7) {
95		return false;
96		}
97
98	2	if (strlen($color) % 3 == 0) {
99	2	$color = '#' . $color;
100		}
101
102	2	if (strlen($color) == 4) {
103	2	$color = '#' . $color[1] . $color[1] . $color[2] . $color[2] . $color[3] . $color[3];
104		}
105
106	2	list($red, $green, $blue) = static::rgb($color);
107	2	list($h, $s, $l) = static::hsl($color);
108
109	2	$ndf1 = 0;
		0 ignored issues – show Unused Code introduced 2020-05-28 13:28 UTC by Report Bug Copy Issue Report The assignment to `$ndf1` is dead and can be removed. Loading history...
110	2	$ndf2 = 0;
		0 ignored issues – show Unused Code introduced 2020-05-28 13:28 UTC by Report Bug Copy Issue Report The assignment to `$ndf2` is dead and can be removed. Loading history...
111	2	$ndf = 0;
		0 ignored issues – show Unused Code introduced 2020-05-28 13:28 UTC by Report Bug Copy Issue Report The assignment to `$ndf` is dead and can be removed. Loading history...
112	2	$cl = -1;
113	2	$df = -1;
114
115	2	$count = count(static::colors());
116	2	$colors = static::colors();
117
118	2	for ($index = 0; $index < $count; $index++) {
119	2	if ($color == '#' . $colors[$index][0]) {
120	2	return ['#' . $colors[$index][0], $colors[$index][1], true];
121		}
122
123	2	$ndf1 = pow($red - $colors[$index][2], 2) + pow(
124	2	$green - $colors[$index][3],
125	2	2
126	2	) + pow($blue - $colors[$index][4], 2);
127	2	$ndf2 = abs(pow($h - $colors[$index][5], 2)) + pow(
128	2	$s - $colors[$index][6],
129	2	2
130	2	) + abs(pow($l - $colors[$index][7], 2));
131
132	2	$ndf = $ndf1 + $ndf2 * 2;
133	2	if ($df < 0 \|\| $df > $ndf) {
134	2	$df = $ndf;
135	2	$cl = $index;
136		}
137		}
138
139		return $cl < 0 ? false : ["#" . static::colors()[$cl][0], static::colors()[$cl][1], false];
140		}
141
142
143		/**
144		* Uses luminosity to calculate the difference between the given colors.
145		* The returned value should be bigger than 5 for best readability.
146		*
147		* @param string\|array $color1
148		* @param string\|array $color2
149		* @return double
150		*/
151		public static function lumDiff($color1, $color2)
152		{
153		list($red1, $green1, $blue1) = is_array($color1) ? $color1 : static::rgb($color1);
154		list($red2, $green2, $blue2) = is_array($color2) ? $color2 : static::rgb($color2);
155
156		$lightness1 = 0.2126 * pow($red1 / 255, 2.2) +
157		0.7152 * pow($green1 / 255, 2.2) +
158		0.0722 * pow($blue1 / 255, 2.2);
159
160		$lightness2 = 0.2126 * pow($red2 / 255, 2.2) +
161		0.7152 * pow($green2 / 255, 2.2) +
162		0.0722 * pow($blue2 / 255, 2.2);
163
164		if ($lightness1 > $lightness2) {
165		return ($lightness1 + 0.05) / ($lightness2 + 0.05);
166		} else {
167		return ($lightness2 + 0.05) / ($lightness1 + 0.05);
168		}
169		}
170		}
171

bytic / utility

Colors::hsl() B last analyzed 2021-06-22 13:07 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

Colors::hsl() B
last analyzed 2021-06-22 13:07 UTC