projectcleverweb\color\main

Complexity

Total Complexity

27

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

0%

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	__clone()	0	5	1
A	serialize()	0	3	1
A	unserialize()	0	5	1
A	set()	0	7	2
A	rgb()	0	3	1
A	hsl()	0	7	2
A	cmyk()	0	4	1
A	hex()	0	3	1
A	css()	0	3	1
A	alpha()	0	3	1
A	is_dark()	0	4	1
A	red()	0	3	1
A	green()	0	3	1
A	blue()	0	3	1
A	hue()	0	3	1
A	saturation()	0	3	1
A	light()	0	3	1
A	rgb_scheme()	0	6	1
A	hsl_scheme()	0	13	2
A	hex_scheme()	0	6	1
A	cmyk_scheme()	0	6	1
A	_convert_scheme()	0	7	2

<?php


namespace projectcleverweb\color;


class main implements \Serializable {
	
	public $color;
	public $hsl_result_accuracy = 0;
	
	public function __construct($color) {
		$this->set($color);
	}
	
	public function __clone() {
		$rgb = $this->color->rgb + ['a' => $this->color->alpha()];
		unset($this->color);
		$this->set($rgb, 'rgb');
	}
	
	public function serialize() :string {
		return $this->color->serialize();
	}
	
	public function unserialize($serialized) {
		$unserialized = (array) json_decode((string) $serialized);
		regulate::rgb_array($unserialized);
		$this->set($unserialized, 'rgb');
	}
	
	public function set($color, string $type = '') {
		if ($color instanceof color) {
			$this->color = $color;
		} else {
			$this->color = new color($color, $type);
		}
	}
	
	public function rgb() :array {
		return (array) $this->color->rgb + ['a' => $this->color->alpha()];
	}
	
	public function hsl() :array {
		$color = [];
		foreach((array) $this->color->hsl as $key => $value) {
			$color[$key] = round($value, abs($this->hsl_result_accuracy));
		}
		return $color + ['a' => $this->color->alpha()];
	}
	
	public function cmyk() :array {
		$rgb = $this->color->rgb;
		return generate::rgb_to_cmyk($rgb['r'], $rgb['g'], $rgb['b']) + ['a' => $this->color->alpha()];
	}
	
	public function hex() :string {
		return $this->color->hex;
	}
	
	public function css() :string {
		return css::best($this->color);
	}
	
	/**
	 * Get (and set) the alpha channel
	 * 
	 * @param  mixed $new_alpha If numeric, the alpha channel is set to this value
	 * @return float            The current alpha value
	 */
	public function alpha($new_alpha) {
		return $this->color->alpha($new_alpha);
	}
	
	public function is_dark(int $check_score = 128) :bool {
		$rgb = $this->color->rgb;
		return check::is_dark($rgb['r'], $rgb['g'], $rgb['b'], $check_score);
	}
	
	public function red(float $adjustment, bool $as_percentage = FALSE, bool $set_absolute = TRUE) {
		return modify::rgb($this->color, 'red', $adjustment, $as_percentage, $set_absolute);
	}
	
	public function green(float $adjustment, bool $as_percentage = FALSE, bool $set_absolute = TRUE) {
		return modify::rgb($this->color, 'green', $adjustment, $as_percentage, $set_absolute);
	}
	
	public function blue(float $adjustment, bool $as_percentage = FALSE, bool $set_absolute = TRUE) {
		return modify::rgb($this->color, 'blue', $adjustment, $as_percentage, $set_absolute);
	}
	
	public function hue(float $adjustment, bool $as_percentage = FALSE, bool $set_absolute = TRUE) {
		return modify::hsl($this->color, 'hue', $adjustment, $as_percentage, $set_absolute);
	}
	
	public function saturation(float $adjustment, bool $as_percentage = FALSE, bool $set_absolute = TRUE) {
		return modify::hsl($this->color, 'saturation', $adjustment, $as_percentage, $set_absolute);
	}
	
	public function light(float $adjustment, bool $as_percentage = FALSE, bool $set_absolute = TRUE) {
		return modify::hsl($this->color, 'light', $adjustment, $as_percentage, $set_absolute);
	}
	
	public function rgb_scheme(string $scheme_name = '') :array {
		return static::_convert_scheme(
			static::hsl_scheme($scheme_name),
			[new generate, 'hsl_to_rgb']
		);
	}
	
	public function hsl_scheme(string $scheme_name = '') :array {
		if (is_callable($callable = [new scheme, $scheme_name])) {
			$hsl = $this->color->hsl;
			return call_user_func($callable, $hsl['h'], $hsl['s'], $hsl['l']);
		}
		error::call(sprintf(
			'The $scheme_name "%s" is not a valid scheme name',
			$scheme_name,
			__CLASS__,
			__FUNCTION__
		));
		return [];
	}
	
	public function hex_scheme(string $scheme_name = '') :array {
		return static::_convert_scheme(
			static::rgb_scheme($scheme_name),
			[new generate, 'rgb_to_hex']
		);
	}
	
	public function cmyk_scheme(string $scheme_name = '') :array {
		return static::_convert_scheme(
			static::rgb_scheme($scheme_name),
			[new generate, 'rgb_to_cmyk']
		);
	}
	
	protected static function _convert_scheme(array $scheme, callable $callback) {
		$scheme = array_values($scheme);
		foreach ($scheme as &$color) {
			$color = call_user_func_array($callback, $color);
		}
		return $scheme;
	}
}