├── .gitignore
├── examples
    ├── font
    │   └── font.ttf
    ├── line.php
    ├── badInput.php
    ├── largeKeys.php
    ├── html.php
    ├── stretched.php
    ├── sinus.php
    ├── floats.php
    ├── realData.php
    ├── image.php
    ├── randomValues.php
    └── example.php
├── phpstan.neon
├── src
    ├── Colorizers
    │   ├── ColorException.php
    │   ├── ColorizerInterface.php
    │   ├── ImageColorizer.php
    │   ├── HTMLColorizer.php
    │   └── AsciiColorizer.php
    ├── Settings.php
    ├── Chart.php
    └── Linechart.php
├── LICENCE.md
├── ecs.yml
├── composer.json
├── README.md
└── log
    └── phpstan.html


/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor/
2 | /.idea/
3 | 


--------------------------------------------------------------------------------
/examples/font/font.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noximo/PHP-colored-ascii-linechart/HEAD/examples/font/font.ttf


--------------------------------------------------------------------------------
/phpstan.neon:
--------------------------------------------------------------------------------
1 | parameters:
2 |     autoload_files:
3 |         - vendor/autoload.php
4 |     excludes_analyse:
5 |         - %rootDir%/vendor
6 |     ignoreErrors:
7 |     checkMissingIterableValueType: false
8 | 


--------------------------------------------------------------------------------
/src/Colorizers/ColorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace noximo\PHPColoredAsciiLinechart\Colorizers;
 6 | 
 7 | use Exception;
 8 | 
 9 | /**
10 |  * Class ColorException
11 |  * @package noximo\PHPColoredConsoleLinegraph
12 |  */
13 | final class ColorException extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Colorizers/ColorizerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace noximo\PHPColoredAsciiLinechart\Colorizers;
 6 | 
 7 | interface ColorizerInterface
 8 | {
 9 |     /**
10 |      * @param array|null $colors
11 |      */
12 |     public function colorize(string $text, ?array $colors = null): string;
13 | 
14 |     public function getEOL(): string;
15 | 
16 |     public function processFinalText(string $text): string;
17 | }
18 | 


--------------------------------------------------------------------------------
/examples/line.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Settings;
 6 | use noximo\PHPColoredAsciiLinechart\Linechart;
 7 | 
 8 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
 9 | $settings = new Settings();
10 | $settings->setFPS(40);
11 | 
12 | $lineGraph = new Linechart();
13 | $lineGraph->setSettings($settings);
14 | 
15 | try {
16 |     $linechart = new Linechart();
17 |     $linechart->addMarkers([1, 1, 1, 1, 1, 1])->chart()->print();
18 | } catch (\Throwable $e) {
19 |     echo $e->getMessage();
20 | }
21 | 


--------------------------------------------------------------------------------
/examples/badInput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Linechart;
 6 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
 7 | 
 8 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
 9 | $lineGraph = new Linechart();
10 | 
11 | $lineA = [
12 |     1 => 2,
13 |     9 => 2,
14 |     'a' => 12,
15 |     2 => 8,
16 |     15 => 4,
17 |     14 => 8,
18 |     8 => 2,
19 |     3 => 2,
20 |     4 => 2,
21 | ];
22 | $lineGraph->addMarkers($lineA, [AsciiColorizer::GREEN, AsciiColorizer::BOLD], [AsciiColorizer::RED]);
23 | 
24 | $lineGraph->chart()->print();
25 | 


--------------------------------------------------------------------------------
/src/Colorizers/ImageColorizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace noximo\PHPColoredAsciiLinechart\Colorizers;
 6 | 
 7 | /**
 8 |  * Class HTMLColorizer
 9 |  * @package noximo\PHPColoredAsciiLinechart\Colorizers
10 |  */
11 | final class ImageColorizer implements ColorizerInterface
12 | {
13 |     /**
14 |      * @param array|null $styles
15 |      */
16 |     public function colorize(string $text, ?array $styles = null): string
17 |     {
18 |         return $text;
19 |     }
20 | 
21 |     public function getEOL(): string
22 |     {
23 |         return PHP_EOL;
24 |     }
25 | 
26 |     public function processFinalText(string $text): string
27 |     {
28 |         return $text;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/examples/largeKeys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Linechart;
 6 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
 7 | 
 8 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
 9 | $lineGraph = new Linechart();
10 | 
11 | $lineA = [
12 |     14536 => 2,
13 |     14537 => 2,
14 |     14538 => 8,
15 |     14539 => 8,
16 |     14540 => 4,
17 |     14541 => 4,
18 |     14542 => 8,
19 |     14543 => 8,
20 |     14544 => 8,
21 |     14545 => 8,
22 |     14546 => 2,
23 |     14547 => 2,
24 |     14548 => 2,
25 |     14549 => 2,
26 | ];
27 | $lineGraph->addMarkers($lineA, [AsciiColorizer::GREEN, AsciiColorizer::BOLD]);
28 | 
29 | $lineGraph->chart()->print();
30 | 


--------------------------------------------------------------------------------
/examples/html.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Settings;
 6 | use noximo\PHPColoredAsciiLinechart\Linechart;
 7 | use noximo\PHPColoredAsciiLinechart\Colorizers\HTMLColorizer;
 8 | 
 9 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
10 | $lineGraph = new Linechart();
11 | $settings = new Settings();
12 | $settings->setColorizer(new HTMLColorizer());
13 | $lineA = [];
14 | 
15 | for ($i = 0; $i < +120; $i++) {
16 |     $lineA[] = 10 * sin($i * ((M_PI * 4) / 120));
17 | }
18 | 
19 | $lineGraph->addLine(0, ['color:black'], Linechart::FULL_LINE);
20 | $lineGraph->addMarkers($lineA, ['color: green'], ['color: red']);
21 | $lineGraph->setSettings($settings);
22 | 
23 | $lineGraph->chart()->print();
24 | 


--------------------------------------------------------------------------------
/examples/stretched.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Settings;
 6 | use noximo\PHPColoredAsciiLinechart\Linechart;
 7 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
 8 | 
 9 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
10 | $settings = new Settings();
11 | $settings->setFPS(40);
12 | 
13 | $lineGraph = new Linechart();
14 | $lineGraph->setSettings($settings);
15 | 
16 | try {
17 |     $line = [];
18 |     for ($i = 0; $i < 50; $i++) {
19 |         $line[$i] = $i;
20 |     }
21 | 
22 |     $lineGraph->addMarkers($line, [AsciiColorizer::GREEN], [AsciiColorizer::RED]);
23 | 
24 |     $lineGraph->chart()->clearScreen()->print()->wait();
25 |     $lineGraph->clearAllMarkers();
26 | } catch (\Throwable $e) {
27 |     echo $e->getMessage();
28 | }
29 | 


--------------------------------------------------------------------------------
/examples/sinus.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Settings;
 6 | use noximo\PHPColoredAsciiLinechart\Linechart;
 7 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
 8 | 
 9 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
10 | $lineGraph = new Linechart();
11 | $settings = new Settings();
12 | $settings->setFPS(120);
13 | 
14 | for ($y = 0; $y < 1; $y++) {
15 |     $lineA = [];
16 |     for ($i = $y; $i < $y + 120; $i++) {
17 |         $lineA[] = 1 * sin($i * ((M_PI * 4) / 120));
18 |     }
19 | 
20 |     $lineGraph->addMarkers($lineA, [AsciiColorizer::GREEN, AsciiColorizer::BOLD], [AsciiColorizer::RED]);
21 | 
22 |     $lineGraph->setSettings($settings);
23 |     $lineGraph->chart()->clearScreen()->print()->wait();
24 |     $lineGraph->clearAllMarkers();
25 | }
26 | 


--------------------------------------------------------------------------------
/LICENCE.md:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Tomas Pospisil
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/src/Colorizers/HTMLColorizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace noximo\PHPColoredAsciiLinechart\Colorizers;
 6 | 
 7 | /**
 8 |  * Class HTMLColorizer
 9 |  * @package noximo\PHPColoredAsciiLinechart\Colorizers
10 |  */
11 | final class HTMLColorizer implements ColorizerInterface
12 | {
13 |     /**
14 |      * @param array|null $styles
15 |      */
16 |     public function colorize(string $text, ?array $styles = null): string
17 |     {
18 |         if ($styles === null) {
19 |             return $text;
20 |         }
21 | 
22 |         $cssStyles = implode(';', str_replace(' ', '', $styles));
23 | 
24 |         return sprintf("<span style='%s'>%s</span>", $cssStyles, $text);
25 |     }
26 | 
27 |     public function getEOL(): string
28 |     {
29 |         return '<br>';
30 |     }
31 | 
32 |     public function processFinalText(string $text): string
33 |     {
34 |         $div = "<div style='font-family:monospace,monospace; font-size:1em;'>";
35 |         $text = str_replace([' ', 'span&nbsp;'], ['&nbsp;', 'span '], $text);
36 |         $endDiv = '</div>';
37 | 
38 |         return $div . $text . $endDiv;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/examples/floats.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Settings;
 6 | use noximo\PHPColoredAsciiLinechart\Linechart;
 7 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
 8 | 
 9 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
10 | $settings = new Settings();
11 | $settings->setFPS(40);
12 | $settings->setHeight(30);
13 | $lineGraph = new Linechart();
14 | $lineGraph->setSettings($settings);
15 | 
16 | try {
17 |     $line = [];
18 |     for ($i = 0; $i < 120; $i++) {
19 |         $line[$i] = $lineA[$i - 1] ?? 1 + (lcg_value() * random_int(-1, 1));
20 |     }
21 |     for ($y = 0; $y < 1500; $y++) {
22 |         array_shift($line);
23 |         $line[] = end($line) + (lcg_value() * random_int(-1, 1));
24 |         $lineGraph->addMarkers($line, [AsciiColorizer::GREEN], [AsciiColorizer::RED]);
25 | 
26 |         //$lineGraph->addLine($line[0] * 1.1, [AsciiColorizer::CYAN], Linechart::FULL_LINE);
27 | 
28 |         $lineGraph->chart()->clearScreen()->print()->wait();
29 |         $lineGraph->clearAllMarkers();
30 |     }
31 | } catch (\Throwable $e) {
32 |     echo $e->getMessage();
33 | }
34 | 


--------------------------------------------------------------------------------
/examples/realData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Settings;
 6 | use noximo\PHPColoredAsciiLinechart\Linechart;
 7 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
 8 | 
 9 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
10 | $settings = new Settings();
11 | $settings->setFPS(40);
12 | $lineGraph = new Linechart();
13 | $lineGraph->setSettings($settings);
14 | 
15 | try {
16 |     $line = [0.0208, 0.020858, 0.021, 0.021, 0.0211, 0.0211, 0.0211, 0.0211, 0.0211, 0.021056, 0.0211, 0.0211, 0.0211, 0.0211, 0.0211, 0.0211, 0.0211, 0.0211, 0.021124, 0.0214, 0.0215, 0.021436, 0.02149, 0.021488, 0.02149, 0.02145, 0.02145, 0.021406, 0.02145, 0.02145, 0.02145, 0.0214, 0.02145, 0.021487, 0.02149, 0.021482, 0.02148, 0.02148, 0.0215, 0.0215, 0.0215, 0.0215, 0.021499, 0.021473, 0.021454, 0.021497, 0.021489, 0.021454, 0.021705, 0.02151, 0.021513];
17 | 
18 |     $lineGraph->addMarkers($line, [AsciiColorizer::GREEN], [AsciiColorizer::RED]);
19 | 
20 |     $lineGraph->chart()->clearScreen()->print()->wait();
21 |     $lineGraph->clearAllMarkers();
22 | } catch (\Throwable $e) {
23 |     echo $e->getMessage();
24 | }
25 | 


--------------------------------------------------------------------------------
/ecs.yml:
--------------------------------------------------------------------------------
 1 | imports:
 2 |   - { resource: '%vendor_dir%/symplify/easy-coding-standard/config/set/psr2.yaml' }
 3 |   - { resource: '%vendor_dir%/symplify/easy-coding-standard/config/set/psr12.yaml' }
 4 |   - { resource: '%vendor_dir%/symplify/easy-coding-standard/config/set/common.yaml' }
 5 |   - { resource: '%vendor_dir%/symplify/easy-coding-standard/config/set/clean-code.yaml' }
 6 |   - { resource: '%vendor_dir%/symplify/easy-coding-standard/config/set/php70.yaml' }
 7 |   - { resource: '%vendor_dir%/symplify/easy-coding-standard/config/set/php71.yaml' }
 8 |   - { resource: '%vendor_dir%/symplify/easy-coding-standard/config/set/symplify.yaml' }
 9 | services:
10 | 
11 | parameters:
12 |   skip:
13 |     PhpCsFixer\Fixer\Operator\NotOperatorWithSuccessorSpaceFixer: ~
14 |     Symplify\CodingStandard\Fixer\LineLength\LineLengthFixer: ~
15 |     Symplify\CodingStandard\Fixer\Naming\PropertyNameMatchingTypeFixer: ~
16 |     SlevomatCodingStandard\Sniffs\Namespaces\ReferenceUsedNamesOnlySniff: ~
17 |     Symplify\CodingStandard\Sniffs\DependencyInjection\NoClassInstantiationSniff: ~
18 |     Symplify\CodingStandard\Sniffs\CleanCode\ForbiddenStaticFunctionSniff: ~
19 |     PhpCsFixer\Fixer\Import\OrderedImportsFixer: ~
20 |     Symplify\CodingStandard\Fixer\Commenting\BlockPropertyCommentFixer: ~
21 |     Symplify\CodingStandard\Sniffs\ControlStructure\SprintfOverContactSniff: ~
22 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "noximo/php-colored-ascii-linechart",
 3 |   "description": "Pretty line graphs in your console, html or images",
 4 |   "keywords": [
 5 |     "chart",
 6 |     "graph",
 7 |     "linechart",
 8 |     "linegraph",
 9 |     "ascii",
10 |     "marker",
11 |     "stock"
12 |   ],
13 |   "type": "library",
14 |   "authors": [
15 |     {
16 |       "name": "Tomas Pospisil",
17 |       "email": "pospisilt@gmail.com"
18 |     }
19 |   ],
20 |   "autoload": {
21 |     "psr-4": {
22 |       "noximo\\PHPColoredAsciiLinechart\\": "src/"
23 |     }
24 |   },
25 |   "require": {
26 |     "php": ">= 7.1",
27 |     "ext-json": ">=1.3.7"
28 |   },
29 |   "license": "MIT",
30 |   "require-dev": {
31 |     "php-parallel-lint/php-parallel-lint": "^v1.0.0",
32 |     "phpstan/phpstan": "^0.12",
33 |     "phpstan/phpstan-deprecation-rules": "^0.12",
34 |     "phpstan/phpstan-strict-rules": "^0.12",
35 |     "roave/security-advisories": "dev-master",
36 |     "symplify/easy-coding-standard": "^6.0"
37 |   },
38 |   "scripts": {
39 |     "check-cs": "ecs check src examples",
40 |     "fix-cs": "ecs check src examples --fix",
41 |     "lint": "parallel-lint --colors --exclude vendor .",
42 |     "phpstan": "phpstan analyze src examples --level max -c phpstan.neon",
43 |     "test": [
44 |       "@lint",
45 |       "@check-cs",
46 |       "@phpstan"
47 |     ]
48 |   }
49 | }
50 | 


--------------------------------------------------------------------------------
/examples/image.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Settings;
 6 | use noximo\PHPColoredAsciiLinechart\Linechart;
 7 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
 8 | use noximo\PHPColoredAsciiLinechart\Colorizers\ImageColorizer;
 9 | 
10 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
11 | $lineGraph = new Linechart();
12 | $settings = new Settings();
13 | $settings->setColorizer(new ImageColorizer());
14 | $lineA = [];
15 | 
16 | for ($i = 0; $i < +120; $i++) {
17 |     $lineA[] = 10 * sin($i * ((M_PI * 4) / 120));
18 | }
19 | 
20 | $lineGraph->addMarkers($lineA, [AsciiColorizer::WHITE]);
21 | 
22 | $lineGraph->setSettings($settings);
23 | $graph = $lineGraph->chart();
24 | // Set http headers
25 | header('Content-Type: image/png');
26 | 
27 | $font = __DIR__ . '/font/font.ttf';
28 | $fontSize = 40;
29 | 
30 | $text = (string) $graph;
31 | 
32 | // Calculate the required width to hold this text
33 | $enclosingBox = imagettfbbox($fontSize, 0, $font, $text);
34 | $width = $enclosingBox[2] - $enclosingBox[0] - 10;
35 | 
36 | $height = $fontSize * $graph->getSettings()->getHeight() * 2;
37 | 
38 | // Create the image and define colours
39 | $im = imagecreatetruecolor($width + $fontSize, $height + $fontSize);
40 | $white = imagecolorallocate($im, 255, 255, 255);
41 | $grey = imagecolorallocate($im, 0, 0, 0);
42 | 
43 | imagefilledrectangle($im, 0, 0, $width - 1, $height - 1, $grey);
44 | 
45 | imagettftext($im, $fontSize, 0, $fontSize, $fontSize, $white, $font, $text);
46 | 
47 | // Output and cleanup
48 | imagepng($im);
49 | imagedestroy($im);
50 | 


--------------------------------------------------------------------------------
/examples/randomValues.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Settings;
 6 | use noximo\PHPColoredAsciiLinechart\Linechart;
 7 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
 8 | 
 9 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
10 | $settings = new Settings();
11 | $settings->setHeight(30);
12 | $settings->setFPS(120);
13 | $lineGraph = new Linechart();
14 | $lineGraph->setSettings($settings);
15 | 
16 | try {
17 |     $lineA = [];
18 |     $lineB = [];
19 |     $lineC = [];
20 |     $lineD = [];
21 |     for ($i = 0; $i < 120; $i++) {
22 |         $lineA[$i] = $lineA[$i - 1] ?? 1 + random_int(-2, 2);
23 |         $lineB[$i] = $lineB[$i - 1] ?? 1 + random_int(-2, 2);
24 |         $lineC[$i] = $lineC[$i - 1] ?? 1 + random_int(-2, 2);
25 |         $lineD[$i] = $lineD[$i - 1] ?? 1 + random_int(-2, 2);
26 |     }
27 |     for ($y = 0; $y < 1500; $y++) {
28 |         array_shift($lineA);
29 |         $lineA[] = end($lineA) + random_int(-2, 2);
30 |         array_shift($lineB);
31 |         $lineB[] = end($lineB) + random_int(-2, 2);
32 |         array_shift($lineC);
33 |         $lineC[] = end($lineC) + random_int(-2, 2);
34 |         array_shift($lineD);
35 |         $lineD[] = end($lineD) + random_int(-2, 2);
36 | 
37 |         $lineGraph->addMarkers($lineA, [AsciiColorizer::GREEN, AsciiColorizer::BOLD]);
38 |         $lineGraph->addMarkers($lineB, [AsciiColorizer::GREEN], [AsciiColorizer::RED]);
39 |         $lineGraph->addMarkers($lineC, [AsciiColorizer::CYAN, AsciiColorizer::BOLD]);
40 |         $lineGraph->addMarkers($lineD, [AsciiColorizer::WHITE, AsciiColorizer::BOLD]);
41 | 
42 |         $lineGraph->addLine(0, [AsciiColorizer::CYAN], Linechart::FULL_LINE);
43 | 
44 |         $lineGraph->chart()->clearScreen()->print()->wait();
45 |         $lineGraph->clearAllMarkers();
46 |     }
47 | } catch (Throwable $throwable) {
48 |     echo $throwable->getMessage();
49 | }
50 | 


--------------------------------------------------------------------------------
/examples/example.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use noximo\PHPColoredAsciiLinechart\Settings;
 6 | use noximo\PHPColoredAsciiLinechart\Linechart;
 7 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
 8 | 
 9 | require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
10 | 
11 | $settings = new Settings();
12 | //Note that any setting can be ommited.
13 | $settings
14 |     ->setColorizer(new AsciiColorizer())//Colorizer, choose between Ascii, HTML and image colorizers
15 |     ->setFPS(24)//control speed of Graph::wait method
16 |     ->setHeight(30)//Set fixed height of graph. Graph will scale accordingly
17 |     ->setPadding(5, ' ')//Set lenght of a padding and character used
18 |     ->setOffset(10)//Offset left border
19 |     ->setFormat( //control how y axis labels will be printed out
20 |         function ($x, Settings $settings) {
21 |             $padding = $settings->getPadding();
22 |             $paddingLength = strlen($padding);
23 | 
24 |             return substr($padding . round($x, 2), -$paddingLength);
25 |         }
26 |     );
27 | 
28 | $lineGraph = new Linechart();
29 | $lineGraph->setSettings($settings);
30 | 
31 | for ($y = 0; $y < 40000; $y++) { //Move sinusoid
32 |     $lineA = [];
33 |     $lineB = [];
34 |     for ($i = $y; $i < $y + 120; $i++) {
35 |         $lineA[] = 10 * sin($i * ((M_PI * 4) / 120)); //Draw sinusoid
36 |         $lineB[] = 20 * sin($i * ((M_PI * 4) / 120)); //Draw sinusoid
37 |     }
38 | 
39 |     $lineGraph->addMarkers(
40 |         $lineA, //graph data - note that any elements with non-integer keys will be discarded
41 |         [AsciiColorizer::GREEN, AsciiColorizer::BOLD], // Default color of line. Can be ommited. You can combine mutliple color codes together. If you set up HTML colorizer, you can enter css styles instead of codes. See below
42 |         [AsciiColorizer::RED, AsciiColorizer::BOLD] // Color of downtrend. Can be ommited, then default color will be used instead.
43 |     );
44 |     //Pro-tip - combine color with bold style - it will pop-out nicely
45 | 
46 |     $lineGraph->addMarkers($lineB, [AsciiColorizer::CYAN]); //Add as many datasets as you want
47 | 
48 |     $lineGraph->addLine( //Add a guiding line - a zero line for example
49 |         0, //Alias y coordinate
50 |         [AsciiColorizer::CYAN], //You can set color the same way as with series
51 |         Linechart::FULL_LINE //Choose between full line and
52 |     );
53 | 
54 |     $lineGraph->addPoint(
55 |         10,
56 |         15,
57 |         [AsciiColorizer::LIGHT_BLUE],
58 |         Linechart::CROSS //Point can be made more visible with crosslines. Default is Linegraph::POINT
59 |     );
60 | 
61 |     $graph = $lineGraph->chart(); //Graph is an object with all data drawn. It can be simply echoed or we can leverage its methods for output control
62 | 
63 |     $graph->clearScreen(); //clears already outputed graphs
64 |     $graph->print(); //Alias of echo $graph with fluent method call
65 |     $graph->wait(); //Naive implementation of animation. It simply sleeps for n microseconds (defined by setFPS earlier). It does not take into account time spent on graph generation or on retrieving data
66 |     $lineGraph->clearAllMarkers(); //Get rid of already processed graph data so they won't get printed again.
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Settings.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace noximo\PHPColoredAsciiLinechart;
  6 | 
  7 | use noximo\PHPColoredAsciiLinechart\Colorizers\AsciiColorizer;
  8 | use noximo\PHPColoredAsciiLinechart\Colorizers\ColorizerInterface;
  9 | 
 10 | /**
 11 |  * Class Config
 12 |  * @package noximo\PHPColoredConsoleLinegraph
 13 |  */
 14 | final class Settings
 15 | {
 16 |     /**
 17 |      * @var callable
 18 |      */
 19 |     private $format;
 20 | 
 21 |     /**
 22 |      * @var int
 23 |      */
 24 |     private $offset = 2;
 25 |     
 26 |     /**
 27 |      * @var int
 28 |      */
 29 |     private $decimals = 2;
 30 | 
 31 |     /**
 32 |      * @var string
 33 |      */
 34 |     private $padding = '      ';
 35 | 
 36 |     /**
 37 |      * @var int
 38 |      */
 39 |     private $height;
 40 | 
 41 |     /**
 42 |      * @var int
 43 |      */
 44 |     private $fps = 12;
 45 | 
 46 |     /**
 47 |      * @var ColorizerInterface
 48 |      */
 49 |     private $colorizer;
 50 | 
 51 |     /**
 52 |      * Settings constructor.
 53 |      */
 54 |     public function __construct()
 55 |     {
 56 |         $this->format = function ($x, self $settings) {
 57 |             $padding = $settings->getPadding();
 58 |             $decimals = $settings->getDecimals();
 59 |             $paddingLength = \strlen($padding);
 60 | 
 61 |             return substr($padding . round($x, $decimals), -$paddingLength);
 62 |         };
 63 |     }
 64 | 
 65 |     public function getPadding(): string
 66 |     {
 67 |         return $this->padding;
 68 |     }
 69 | 
 70 |     public function setPadding(int $length, ?string $char = null): self
 71 |     {
 72 |         if ($char === null || $char === '') {
 73 |             $padding = ' ';
 74 |         } else {
 75 |             $padding = $char;
 76 |         }
 77 |         $this->padding = str_pad('', $length, $padding);
 78 | 
 79 |         return $this;
 80 |     }
 81 | 
 82 |     public function getDecimals(): int
 83 |     {
 84 |         return $this->decimals;
 85 |     }
 86 |     
 87 |     public function setDecimals(int $decimals): self
 88 |     {
 89 |         $this->decimals = $decimals;
 90 | 
 91 |         return $this;
 92 |     }
 93 |     
 94 |     public function getHeight(): ?int
 95 |     {
 96 |         return $this->height;
 97 |     }
 98 | 
 99 |     public function setHeight(int $height): self
100 |     {
101 |         $this->height = $height;
102 | 
103 |         return $this;
104 |     }
105 | 
106 |     public function getOffset(): int
107 |     {
108 |         return $this->offset;
109 |     }
110 | 
111 |     public function setOffset(int $offset): self
112 |     {
113 |         $this->offset = $offset;
114 | 
115 |         return $this;
116 |     }
117 | 
118 |     public function getFormat(): callable
119 |     {
120 |         return $this->format;
121 |     }
122 | 
123 |     /**
124 |      * @param callable $format =function ($x, Settings $config) {
125 |      * $padding = $config->getPadding();
126 |      * $paddingLength = strlen($padding);
127 |      * return substr($padding . round($x, 2), -$paddingLength);
128 |      * }
129 |      * @return Settings
130 |      */
131 |     public function setFormat(callable $format): self
132 |     {
133 |         $this->format = $format;
134 | 
135 |         return $this;
136 |     }
137 | 
138 |     public function getFps(): int
139 |     {
140 |         return $this->fps;
141 |     }
142 | 
143 |     public function setFPS(int $fps): self
144 |     {
145 |         $this->fps = $fps;
146 | 
147 |         return $this;
148 |     }
149 | 
150 |     public function getColorizer(): ColorizerInterface
151 |     {
152 |         return $this->colorizer ?? new AsciiColorizer();
153 |     }
154 | 
155 |     public function setColorizer(ColorizerInterface $colorizer): self
156 |     {
157 |         $this->colorizer = $colorizer;
158 | 
159 |         return $this;
160 |     }
161 | }
162 | 


--------------------------------------------------------------------------------
/src/Colorizers/AsciiColorizer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace noximo\PHPColoredAsciiLinechart\Colorizers;
  6 | 
  7 | use ReflectionClass;
  8 | use ReflectionException;
  9 | use function chr;
 10 | use function in_array;
 11 | 
 12 | /**
 13 |  * Class Colorize
 14 |  * @package noximo\PHPColoredConsoleLinegraph
 15 |  */
 16 | final class AsciiColorizer implements ColorizerInterface
 17 | {
 18 |     /** @var int */
 19 |     public const BOLD = 1;
 20 | 
 21 |     /** @var int */
 22 |     public const DARK = 2;
 23 | 
 24 |     /** @var int */
 25 |     public const ITALIC = 3;
 26 | 
 27 |     /** @var int */
 28 |     public const UNDERLINE = 4;
 29 | 
 30 |     /** @var int */
 31 |     public const BLINK = 5;
 32 | 
 33 |     /** @var int */
 34 |     public const REVERSE = 7;
 35 | 
 36 |     /** @var int */
 37 |     public const CONCEALED = 8;
 38 | 
 39 |     /** @var int */
 40 |     public const BLACK = 30;
 41 | 
 42 |     /** @var int */
 43 |     public const RED = 31;
 44 | 
 45 |     /** @var int */
 46 |     public const GREEN = 32;
 47 | 
 48 |     /** @var int */
 49 |     public const YELLOW = 33;
 50 | 
 51 |     /** @var int */
 52 |     public const BLUE = 34;
 53 | 
 54 |     /** @var int */
 55 |     public const MAGENTA = 35;
 56 | 
 57 |     /** @var int */
 58 |     public const CYAN = 36;
 59 | 
 60 |     /** @var int */
 61 |     public const LIGHT_GRAY = 37;
 62 | 
 63 |     /** @var int */
 64 |     public const DARK_GRAY = 90;
 65 | 
 66 |     /** @var int */
 67 |     public const LIGHT_RED = 91;
 68 | 
 69 |     /** @var int */
 70 |     public const LIGHT_GREEN = 92;
 71 | 
 72 |     /** @var int */
 73 |     public const LIGHT_YELLOW = 93;
 74 | 
 75 |     /** @var int */
 76 |     public const LIGHT_BLUE = 94;
 77 | 
 78 |     /** @var int */
 79 |     public const LIGHT_MAGENTA = 95;
 80 | 
 81 |     /** @var int */
 82 |     public const LIGHT_CYAN = 96;
 83 | 
 84 |     /** @var int */
 85 |     public const WHITE = 97;
 86 | 
 87 |     /** @var int */
 88 |     public const BACKGROUND_DEFAULT = 49;
 89 | 
 90 |     /** @var int */
 91 |     public const BACKGROUND_BLACK = 40;
 92 | 
 93 |     /** @var int */
 94 |     public const BACKGROUND_RED = 41;
 95 | 
 96 |     /** @var int */
 97 |     public const BACKGROUND_GREEN = 42;
 98 | 
 99 |     /** @var int */
100 |     public const BACKGROUND_YELLOW = 43;
101 | 
102 |     /** @var int */
103 |     public const BACKGROUND_BLUE = 44;
104 | 
105 |     /** @var int */
106 |     public const BACKGROUND_MAGENTA = 45;
107 | 
108 |     /** @var int */
109 |     public const BACKGROUND_CYAN = 46;
110 | 
111 |     /** @var int */
112 |     public const BACKGROUND_LIGHT_GRAY = 47;
113 | 
114 |     /** @var int */
115 |     public const BACKGROUND_DARK_GRAY = 100;
116 | 
117 |     /** @var int */
118 |     public const BACKGROUND_LIGHT_RED = 101;
119 | 
120 |     /** @var int */
121 |     public const BACKGROUND_LIGHT_GREEN = 102;
122 | 
123 |     /** @var int */
124 |     public const BACKGROUND_LIGHT_YELLOW = 103;
125 | 
126 |     /** @var int */
127 |     public const BACKGROUND_LIGHT_BLUE = 104;
128 | 
129 |     /** @var int */
130 |     public const BACKGROUND_LIGHT_MAGENTA = 105;
131 | 
132 |     /** @var int */
133 |     public const BACKGROUND_LIGHT_CYAN = 106;
134 | 
135 |     /** @var int */
136 |     public const BACKGROUND_WHITE = 107;
137 | 
138 |     /** @var array */
139 |     private static $constants = [];
140 | 
141 |     /**
142 |      * @param array|null $colors
143 |      *
144 |      * @return string
145 |      * @throws ColorException
146 |      * @throws ReflectionException
147 |      */
148 |     public function colorize(string $text, ?array $colors = null): string
149 |     {
150 |         if ($colors === null) {
151 |             return $text;
152 |         }
153 | 
154 |         foreach ($colors as $color) {
155 |             if (!$this->colorExists((int) $color)) {
156 |                 throw new ColorException('Unknown color ' . $color . ', use constans of class Color');
157 |             }
158 |         }
159 | 
160 |         $chr27 = chr(27);
161 | 
162 |         return sprintf('%s[0m%s[%sm%s%s[0m', $chr27, $chr27, implode(';', $colors), $text, $chr27);
163 |     }
164 | 
165 |     /**
166 |      * @throws ReflectionException
167 |      */
168 |     public function colorExists(int $color): bool
169 |     {
170 |         if (count(self::$constants) === 0) {
171 |             $oClass = new ReflectionClass(self::class);
172 |             self::$constants = $oClass->getConstants();
173 |         }
174 | 
175 |         return in_array($color, self::$constants, true);
176 |     }
177 | 
178 |     public function getEOL(): string
179 |     {
180 |         return PHP_EOL;
181 |     }
182 | 
183 |     public function processFinalText(string $text): string
184 |     {
185 |         return $text;
186 |     }
187 | }
188 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # PHP-colored-ascii-linechart
  2 | 
  3 | [![Sinus output](https://i.imgur.com/Wc7OjvO.gif)](https://i.imgur.com/Wc7OjvO.gif)
  4 | 
  5 | Create beautiful, versatile ASCII line-charts within Terminal, written in `PHP`.
  6 | 
  7 | - Create multiple lines in a single chart, each with its own color,
  8 | - Use points in your chart ,
  9 | - Scale the chart to a desired height or let it grow and shrink freely,
 10 | - Have multi-colored lines based on uptrends and downtrends,
 11 | - Print charts as ASCII colored text, a HTML snippet or png image,
 12 | - Use simple API that helps with animating sequence of charts.
 13 | 
 14 | _Built upon [kroitor/asciichart](https://github.com/kroitor/asciichart)_
 15 | 
 16 | ## Installation
 17 | ```
 18 | $ composer require noximo/php-colored-ascii-linechart
 19 | ```
 20 | 
 21 | ## Usage
 22 | 
 23 | ### Simple Output:
 24 | 
 25 | ```php
 26 | $linechart = new Linechart();
 27 | echo $linechart->addMarkers([1,2,3,4,5,6])->addPoint(4, 2)->chart();
 28 | ```
 29 | This will print a simple chart with a single point in default colors.
 30 | 
 31 | ### Advanced Output:
 32 | 
 33 | ```php
 34 | $settings = new Settings();
 35 | // Note that any setting can be ommited.
 36 | $settings
 37 |     ->setColorizer(new AsciiColorizer())  // Colorizer, choose between Ascii, HTML and image colorizers
 38 |     ->setFPS(24)  // Control speed of chart::wait method
 39 |     ->setHeight(30)  // Set fixed height of chart. chart will scale accordingly. If not set, height will be calculated based on highest and lowest numbers across all sets of markers.
 40 |     ->setPadding(5, ' ')  // Set lenght of a padding and character used
 41 |     ->setOffset(10)  // Offset left border
 42 |     ->setFormat(  // Control how y axis labels will be printed out
 43 |         function ($x, Settings $settings) {
 44 |             $padding = $settings->getPadding();
 45 |             $paddingLength = \strlen($padding);
 46 | 
 47 |             return substr($padding . round($x, 2), -$paddingLength);
 48 |         }
 49 |     );
 50 | 
 51 | $linechart = new Linechart();
 52 | $linechart->setSettings($settings);
 53 | 
 54 | for ($y = 0; $y < 1200; $y++) { // Move sinusoid
 55 |     $lineA = [];
 56 |     $lineB = [];
 57 |     for ($i = $y; $i < $y + 120; $i++) {
 58 |         $lineA[] = 10 * sin($i * ((M_PI * 4) / 120));  // Draw sinusoid
 59 |         $lineB[] = 20 * sin($i * ((M_PI * 4) / 120));  // Draw sinusoid
 60 |     }
 61 |     
 62 |     $linechart->addMarkers(    
 63 |         $lineA,  // Chart data - note that any elements with non-integer keys will be discarded
 64 |         [AsciiColorizer::GREEN, AsciiColorizer::BOLD],  // Default color of line. Can be ommited. You can combine mutliple color codes together. If you set up HTML colorizer, you can enter css styles instead of codes. See below
 65 |         [AsciiColorizer::RED, AsciiColorizer::BOLD]  // Color of downtrend. Can be ommited, then default color will be used instead.
 66 |     );  // Pro-tip - combine color with bold style - it will pop-out nicely
 67 | 
 68 |     $linechart->addMarkers($lineB, [AsciiColorizer::CYAN]);  // Add as many datasets as you want
 69 | 
 70 |     $linechart->addLine(  // Add a guiding line - a zero line for example
 71 |         0,  // Alias y coordinate
 72 |         [AsciiColorizer::CYAN],  // You can set color the same way as with markers
 73 |         Linechart::FULL_LINE  // Choose between full line and dashed line
 74 |     );
 75 | 
 76 |     $linechart->addPoint(
 77 |         10,
 78 |         15,
 79 |         [AsciiColorizer::LIGHT_BLUE],
 80 |         Linechart::CROSS  // Point can be made more visible with crosslines. Default is Linechart::POINT
 81 |     );
 82 | 
 83 | 
 84 |     $chart = $linechart->chart();  // Chart is an object with all data drawn. It can be simply echoed or we can leverage its methods for output control
 85 | 
 86 |     $chart->clearScreen();  // Clears already outputed charts
 87 |     $chart->print();  // Alias of echo $chart with fluent method call
 88 |     $chart->wait();  // Naive implementation of animation. It simply sleeps for n microseconds (defined by setFPS earlier). It does not take into account time spent on chart generation or on retrieving data
 89 |     $linechart->clearAllMarkers();  // Get rid of already processed chart data so they won't get printed again.
 90 | }
 91 | ```
 92 | 
 93 | This will print out the [chart](https://i.imgur.com/Wc7OjvO.gif) shown in the [heading](https://github.com/noximo/PHP-colored-ascii-linechart#php-colored-ascii-linechart).
 94 | 
 95 | ### HTML Output
 96 | 
 97 | ```php
 98 | $linechart = new Linechart();
 99 | $settings = new Settings();  // Settings are needed in this case
100 | $settings->setColorizer(new HTMLColorizer());  // Here you need to set up HTMLColorizer
101 | 
102 | $lineA = [];
103 | for ($i = 0; $i < +120; $i++) {
104 |     $lineA[] = 10 * sin($i * ((M_PI * 4) / 120));
105 | }
106 | 
107 | $linechart->addLine(0, ['color:white'], Linechart::FULL_LINE);  // Use css styles instead of ascii color codes
108 | $linechart->addMarkers($lineA, ['color: green'], ['color: red']);
109 | $linechart->setSettings($settings);
110 | 
111 | echo $linechart->chart();
112 | ``` 
113 | 
114 | [![Sinus output](https://i.imgur.com/Qw78k9k.png)](https://i.imgur.com/Qw78k9k.png)
115 | 
116 | ### Image Output
117 | Images are a work in progress. You can look in `/examples` folder for a *beta* implementation.
118 | 
119 | ## Development Pathway / To-Do
120 | 
121 | - Refactoring of colorizers and printers:
122 |   - single colorizer regardles of output type, 
123 |   - chart class rewrite so $chart->toHtml(), $chart->toPng(), $chart->toAscii() etc. exists,
124 | - Proper image support. Animated images through gifs,
125 | - Better customization (backgrounds, borders),
126 | - X axis with labels.
127 | 


--------------------------------------------------------------------------------
/src/Chart.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace noximo\PHPColoredAsciiLinechart;
  6 | 
  7 | use function chr;
  8 | use function strlen;
  9 | use function is_resource;
 10 | 
 11 | /**
 12 |  * Class Graph
 13 |  * @package noximo\PHPColoredConsoleLinegraph
 14 |  */
 15 | final class Chart
 16 | {
 17 |     /**
 18 |      * @var array
 19 |      */
 20 |     private $results = [];
 21 | 
 22 |     /**
 23 |      * @var float
 24 |      */
 25 |     private $min;
 26 | 
 27 |     /**
 28 |      * @var float
 29 |      */
 30 |     private $max;
 31 | 
 32 |     /**
 33 |      * @var int
 34 |      */
 35 |     private $width;
 36 | 
 37 |     /**
 38 |      * @var int
 39 |      */
 40 |     private $allTimeMaxHeight = 0;
 41 | 
 42 |     /**
 43 |      * @var int
 44 |      */
 45 |     private $longestText = 0;
 46 | 
 47 |     /**
 48 |      * @var Settings
 49 |      */
 50 |     private $settings;
 51 | 
 52 |     /**
 53 |      * @var Linechart
 54 |      */
 55 |     private $chart;
 56 | 
 57 |     public function __construct(Linechart $chart)
 58 |     {
 59 |         $this->chart = $chart;
 60 |     }
 61 | 
 62 |     public function __toString()
 63 |     {
 64 |         return $this->prepareChart() . $this->prepareText();
 65 |     }
 66 | 
 67 |     public function getSettings(): Settings
 68 |     {
 69 |         return $this->settings;
 70 |     }
 71 | 
 72 |     public function setSettings(Settings $settings): self
 73 |     {
 74 |         $this->settings = $settings;
 75 | 
 76 |         return $this;
 77 |     }
 78 | 
 79 |     public function getResults(): array
 80 |     {
 81 |         return $this->results;
 82 |     }
 83 | 
 84 |     public function getMin(): float
 85 |     {
 86 |         return $this->min;
 87 |     }
 88 | 
 89 |     public function setMin(float $min): self
 90 |     {
 91 |         $this->min = $min;
 92 | 
 93 |         return $this;
 94 |     }
 95 | 
 96 |     public function getMax(): float
 97 |     {
 98 |         return $this->max;
 99 |     }
100 | 
101 |     public function setMax(float $max): self
102 |     {
103 |         $this->max = $max;
104 | 
105 |         return $this;
106 |     }
107 | 
108 |     public function setWidth(int $width): self
109 |     {
110 |         $this->width = $width;
111 | 
112 |         return $this;
113 |     }
114 | 
115 |     public function addResult(array $result): void
116 |     {
117 |         $this->results[] = $result;
118 |     }
119 | 
120 |     public function printAndwait(): self
121 |     {
122 |         $this->print()->wait();
123 | 
124 |         return $this;
125 |     }
126 | 
127 |     public function wait(): self
128 |     {
129 |         usleep((int) round(1000000 / $this->settings->getFps()));
130 | 
131 |         return $this;
132 |     }
133 | 
134 |     public function print(): self
135 |     {
136 |         $this->output($this->prepareChart());
137 |         $this->output($this->prepareText());
138 | 
139 |         return $this;
140 |     }
141 | 
142 |     public function toArray(): array
143 |     {
144 |         $return = [];
145 |         foreach ($this->merge() as $row) {
146 |             foreach ($row as $cell) {
147 |                 $return[] = $cell;
148 |             }
149 |         }
150 | 
151 |         return $return;
152 |     }
153 | 
154 |     public function clearScreen(bool $useAlternativeMethod = false): self
155 |     {
156 |         if ($useAlternativeMethod) {
157 |             $chr27 = chr(27);
158 |             $chr91 = chr(91);
159 |             $output = sprintf('%s%sH%s%sJ', $chr27, $chr91, $chr27, $chr91);
160 |         } else {
161 |             $output = "\033[0;0f";
162 |         }
163 | 
164 |         $this->output($output);
165 | 
166 |         return $this;
167 |     }
168 | 
169 |     public function setAlltimeMaxHeight(int $allTimeMaxHeight): self
170 |     {
171 |         $this->allTimeMaxHeight = $allTimeMaxHeight;
172 | 
173 |         return $this;
174 |     }
175 | 
176 |     public function printText(): self
177 |     {
178 |         $text = $this->prepareText();
179 | 
180 |         $this->output($text);
181 | 
182 |         return $this;
183 |     }
184 | 
185 |     private function prepareChart(): string
186 |     {
187 |         $return = '';
188 |         foreach ($this->merge() as $row) {
189 |             foreach ($row as $cell) {
190 |                 $return .= $cell;
191 |             }
192 |             $return .= $this->settings->getColorizer()->getEOL();
193 |         }
194 | 
195 |         return $this->settings->getColorizer()->processFinalText($return);
196 |     }
197 | 
198 |     private function prepareText(): string
199 |     {
200 |         $return = '';
201 |         foreach ($this->chart->getText() as $row) {
202 |             $line = $this->settings->getColorizer()->colorize($row[Linechart::VALUE], $row[Linechart::COLORS]);
203 |             $lineLength = strlen($line);
204 |             $this->longestText = $lineLength > $this->longestText ? $lineLength : $this->longestText;
205 |             $line = str_pad($line, $this->longestText, ' ');
206 |             $return .= $line . $this->settings->getColorizer()->getEOL();
207 |         }
208 | 
209 |         $return = $this->settings->getColorizer()->processFinalText($return);
210 | 
211 |         $this->chart->clearText();
212 | 
213 |         return $return;
214 |     }
215 | 
216 |     private function output(string $output): void
217 |     {
218 |         $fopen = fopen('php://stdout', 'wb');
219 |         if (is_resource($fopen)) {
220 |             fwrite($fopen, $output);
221 |         }
222 |     }
223 | 
224 |     private function merge(): array
225 |     {
226 |         $merged = [];
227 |         foreach ($this->results as $result) {
228 |             foreach ($result as $x => $row) {
229 |                 $merged = $this->mergeRow($merged, $row, $x);
230 |             }
231 |         }
232 | 
233 |         return $this->adjustAllTimeMaxHeight($merged, $x ?? 0);
234 |     }
235 | 
236 |     private function mergeRow(array $merged, array $row, int $x): array
237 |     {
238 |         foreach ($row as $y => $cell) {
239 |             $cell = (string) $cell;
240 |             if ($this->shouldBeMerged($merged, $x, $y, $cell)) {
241 |                 $merged[$x][$y] = $cell;
242 |             }
243 |         }
244 | 
245 |         return $merged;
246 |     }
247 | 
248 |     private function adjustAllTimeMaxHeight(array $merged, int $x): array
249 |     {
250 |         if ($x < $this->allTimeMaxHeight) {
251 |             $width = $this->width + strlen($this->settings->getPadding());
252 |             $filledArray = array_fill(0, $width, ' ');
253 |             for ($i = 0, $iMax = $this->allTimeMaxHeight - $x; $i < $iMax; $i++) {
254 |                 $merged[] = $filledArray;
255 |             }
256 |         }
257 | 
258 |         return $merged;
259 |     }
260 | 
261 |     private function shouldBeMerged(array $merged, int $x, int $y, string $cell): bool
262 |     {
263 |         return !isset($merged[$x][$y]) || ($cell !== ' ');
264 |     }
265 | }
266 | 


--------------------------------------------------------------------------------
/log/phpstan.html:
--------------------------------------------------------------------------------
  1 | <html lang="">
  2 | <head>
  3 |     <style>
  4 |         body {
  5 |             background-color: #34495e;
  6 |             color: white;
  7 |             font-family: monospace;
  8 |             font-size: 16px;
  9 |         }
 10 | 
 11 |         b {
 12 |             color: lightskyblue;
 13 |         }
 14 | 
 15 |         h1 {
 16 |             color: white;
 17 |             text-align: center;
 18 |             margin: 5px;
 19 |         }
 20 | 
 21 |         .time {
 22 |             font-style: italic;
 23 |             color: white;
 24 |             text-align: center;
 25 |             margin-bottom: 15px;
 26 |         }
 27 | 
 28 |         a {
 29 |             color: yellow;
 30 |         }
 31 | 
 32 |         table {
 33 |             width: 100%;
 34 |             font-size: 12px;
 35 |         }
 36 | 
 37 |         th {
 38 |             text-align: left;
 39 |             padding: 25px 0 10px 0;
 40 |         }
 41 | 
 42 |         td {
 43 |             padding: 5px;
 44 |         }
 45 | 
 46 |         .section {
 47 |             font-size: 1.4em;
 48 |         }
 49 | 
 50 |         .line {
 51 |             text-align: right;
 52 |             vertical-align: middle;
 53 |         }
 54 | 
 55 |         .error:nth-child(odd) {
 56 |             background: #374d63
 57 |         }
 58 | 
 59 |         .regex {
 60 |             color: #00000085;
 61 |         }
 62 | 
 63 |         #thanks {
 64 |             margin-top: 50px;
 65 |             font-size: 0.65em;
 66 |             text-align: center;
 67 |         }
 68 |     </style>
 69 |     <title>PHPStan analysis result</title>
 70 | </head>
 71 | <h1>PHPStan analysis result</h1>
 72 | <div class="time">2019-08-20 22:11:06</div>
 73 | 
 74 | 
 75 | <div>
 76 |     <table>
 77 |                             <thead>
 78 |             <tr>
 79 |                 <th colspan="2" class="section">Files with errors: 2</th>
 80 |             </tr>
 81 |             </thead>
 82 |                             <thead>
 83 |                 <tr>
 84 |                     <th colspan="2">C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php (9×)</th>
 85 |                 </tr>
 86 |                 </thead>
 87 |                                     <tr class="error">
 88 |                         <td class="line">
 89 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php&line=49'>49</a>
 90 |                         </td>
 91 |                         <td>
 92 |                             Parameter <b>#1</b> <b>$im</b> of function imagedestroy expects resource, <b>resource|false</b> given.                            <br>
 93 |                             <small class="regex">- '#Parameter \#1 \$im of function imagedestroy expects resource, resource\|false given#'</small>
 94 |                         </td>
 95 |                     </tr>
 96 |                                     <tr class="error">
 97 |                         <td class="line">
 98 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php&line=48'>48</a>
 99 |                         </td>
100 |                         <td>
101 |                             Parameter <b>#1</b> <b>$im</b> of function imagepng expects resource, <b>resource|false</b> given.                            <br>
102 |                             <small class="regex">- '#Parameter \#1 \$im of function imagepng expects resource, resource\|false given#'</small>
103 |                         </td>
104 |                     </tr>
105 |                                     <tr class="error">
106 |                         <td class="line">
107 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php&line=45'>45</a>
108 |                         </td>
109 |                         <td>
110 |                             Parameter <b>#1</b> <b>$im</b> of function imagettftext expects resource, <b>resource|false</b> given.                            <br>
111 |                             <small class="regex">- '#Parameter \#1 \$im of function imagettftext expects resource, resource\|false given#'</small>
112 |                         </td>
113 |                     </tr>
114 |                                     <tr class="error">
115 |                         <td class="line">
116 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php&line=43'>43</a>
117 |                         </td>
118 |                         <td>
119 |                             Parameter <b>#1</b> <b>$im</b> of function imagefilledrectangle expects resource, <b>resource|false</b> given.                            <br>
120 |                             <small class="regex">- '#Parameter \#1 \$im of function imagefilledrectangle expects resource, resource\|false given#'</small>
121 |                         </td>
122 |                     </tr>
123 |                                     <tr class="error">
124 |                         <td class="line">
125 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php&line=43'>43</a>
126 |                         </td>
127 |                         <td>
128 |                             Parameter <b>#4</b> <b>$x2</b> of function imagefilledrectangle expects <b>int,</b> <b>float|int</b> given.                            <br>
129 |                             <small class="regex">- '#Parameter \#4 \$x2 of function imagefilledrectangle expects int, float\|int given#'</small>
130 |                         </td>
131 |                     </tr>
132 |                                     <tr class="error">
133 |                         <td class="line">
134 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php&line=41'>41</a>
135 |                         </td>
136 |                         <td>
137 |                             Parameter <b>#1</b> <b>$im</b> of function imagecolorallocate expects resource, <b>resource|false</b> given.                            <br>
138 |                             <small class="regex">- '#Parameter \#1 \$im of function imagecolorallocate expects resource, resource\|false given#'</small>
139 |                         </td>
140 |                     </tr>
141 |                                     <tr class="error">
142 |                         <td class="line">
143 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php&line=40'>40</a>
144 |                         </td>
145 |                         <td>
146 |                             Parameter <b>#1</b> <b>$im</b> of function imagecolorallocate expects resource, <b>resource|false</b> given.                            <br>
147 |                             <small class="regex">- '#Parameter \#1 \$im of function imagecolorallocate expects resource, resource\|false given#'</small>
148 |                         </td>
149 |                     </tr>
150 |                                     <tr class="error">
151 |                         <td class="line">
152 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php&line=39'>39</a>
153 |                         </td>
154 |                         <td>
155 |                             Parameter <b>#1</b> <b>$x_size</b> of function imagecreatetruecolor expects <b>int,</b> <b>float|int</b> given.                            <br>
156 |                             <small class="regex">- '#Parameter \#1 \$x_size of function imagecreatetruecolor expects int, float\|int given#'</small>
157 |                         </td>
158 |                     </tr>
159 |                                     <tr class="error">
160 |                         <td class="line">
161 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\image.php&line=36'>36</a>
162 |                         </td>
163 |                         <td>
164 |                             Only numeric types are allowed in <b>*,</b> <b>int|null</b> given on the right side.                            <br>
165 |                             <small class="regex">- '#Only numeric types are allowed in \*, int\|null given on the right side#'</small>
166 |                         </td>
167 |                     </tr>
168 |                                             <thead>
169 |                 <tr>
170 |                     <th colspan="2">C:\wamp64\www\PHPColoredAsciiLinechart\examples\randomValues.php (4×)</th>
171 |                 </tr>
172 |                 </thead>
173 |                                     <tr class="error">
174 |                         <td class="line">
175 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\randomValues.php&line=35'>35</a>
176 |                         </td>
177 |                         <td>
178 |                             Only numeric types are allowed in <b>+,</b> <b>int|false</b> given on the left side.                            <br>
179 |                             <small class="regex">- '#Only numeric types are allowed in \+, int\|false given on the left side#'</small>
180 |                         </td>
181 |                     </tr>
182 |                                     <tr class="error">
183 |                         <td class="line">
184 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\randomValues.php&line=33'>33</a>
185 |                         </td>
186 |                         <td>
187 |                             Only numeric types are allowed in <b>+,</b> <b>int|false</b> given on the left side.                            <br>
188 |                             <small class="regex">- '#Only numeric types are allowed in \+, int\|false given on the left side#'</small>
189 |                         </td>
190 |                     </tr>
191 |                                     <tr class="error">
192 |                         <td class="line">
193 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\randomValues.php&line=31'>31</a>
194 |                         </td>
195 |                         <td>
196 |                             Only numeric types are allowed in <b>+,</b> <b>int|false</b> given on the left side.                            <br>
197 |                             <small class="regex">- '#Only numeric types are allowed in \+, int\|false given on the left side#'</small>
198 |                         </td>
199 |                     </tr>
200 |                                     <tr class="error">
201 |                         <td class="line">
202 |                             <a href='editor://open/?file=C:\wamp64\www\PHPColoredAsciiLinechart\examples\randomValues.php&line=29'>29</a>
203 |                         </td>
204 |                         <td>
205 |                             Only numeric types are allowed in <b>+,</b> <b>int|false</b> given on the left side.                            <br>
206 |                             <small class="regex">- '#Only numeric types are allowed in \+, int\|false given on the left side#'</small>
207 |                         </td>
208 |                     </tr>
209 |                                     
210 |     </table>
211 |     <div id="thanks">
212 |         This file was made thanks to
213 |         <a href="https://github.com/phpstan/phpstan">PHPStan</a> and was outputted by
214 |         <a href="https://github.com/noximo/PHPStan-FileOutput">PHPStan FileOutput</a>
215 |     </div>
216 | </div>
217 | </html>
218 | 


--------------------------------------------------------------------------------
/src/Linechart.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace noximo\PHPColoredAsciiLinechart;
  6 | 
  7 | use noximo\PHPColoredAsciiLinechart\Colorizers\ColorizerInterface;
  8 | use function strlen;
  9 | use function in_array;
 10 | 
 11 | /**
 12 |  * Class LineGraph
 13 |  * @package noximo\PHPColoredConsoleLinegraph
 14 |  */
 15 | final class Linechart
 16 | {
 17 |     /** @var string */
 18 |     public const CROSS = 'cross';
 19 | 
 20 |     /** @var string */
 21 |     public const POINT = 'point';
 22 | 
 23 |     /** @var string */
 24 |     public const DASHED_LINE = 'dashedLine';
 25 | 
 26 |     /** @var string */
 27 |     public const POINT_X = 'x';
 28 | 
 29 |     /** @var string */
 30 |     public const POINT_Y = 'y';
 31 | 
 32 |     /** @var string */
 33 |     public const VALUE = 'value';
 34 | 
 35 |     /** @var string */
 36 |     public const COLORS = 'colors';
 37 | 
 38 |     /** @var string */
 39 |     public const FULL_LINE = 'fullLIne';
 40 | 
 41 |     /** @var string */
 42 |     public const MARKERS = 'markers';
 43 | 
 44 |     /** @var string */
 45 |     public const COLORS_DOWN = 'colorsDown';
 46 | 
 47 |     /** @var string */
 48 |     public const SPREADS = 'spreads';
 49 | 
 50 |     /**
 51 |      * @var array = [
 52 |      * [['markers' => [1,2,3.45], SELF::COLORS => [1,2,3]]];
 53 |      * ]
 54 |      */
 55 |     private $allmarkers = [];
 56 | 
 57 |     /** @var int */
 58 |     private $width;
 59 | 
 60 |     /**
 61 |      * @var array|null
 62 |      */
 63 |     private $currentColors;
 64 | 
 65 |     /**
 66 |      * @var float
 67 |      */
 68 |     private $range = 0.0;
 69 | 
 70 |     /**
 71 |      * @var float
 72 |      */
 73 |     private $ratio = 0.0;
 74 | 
 75 |     /**
 76 |      * @var float
 77 |      */
 78 |     private $min2 = 0.0;
 79 | 
 80 |     /**
 81 |      * @var float
 82 |      */
 83 |     private $max2 = 0.0;
 84 | 
 85 |     /**
 86 |      * @var int
 87 |      */
 88 |     private $rows = 1;
 89 | 
 90 |     /**
 91 |      * @var int
 92 |      */
 93 |     private $offset = 0;
 94 | 
 95 |     /**
 96 |      * @var float|null
 97 |      */
 98 |     private $adjuster;
 99 | 
100 |     /**
101 |      * @var array
102 |      */
103 |     private $text = [];
104 | 
105 |     /**
106 |      * @var Settings|null
107 |      */
108 |     private $settings;
109 | 
110 |     /**
111 |      * @var ColorizerInterface
112 |      */
113 |     private $colorizer;
114 | 
115 |     /**
116 |      * @param int $x alias x coordinate
117 |      * @param float $y alias y coordinate
118 |      * @param array|null $colors
119 |      * @param string|null $appearance
120 |      * @return Linechart
121 |      */
122 |     public function addPoint(int $x, float $y, ?array $colors = null, ?string $appearance = null): self
123 |     {
124 |         $markers = [];
125 |         $markers[0] = $y;
126 |         $markers[$x] = $y;
127 |         if (!in_array($appearance, [self::CROSS, self::POINT], true)) {
128 |             $appearance = self::POINT;
129 |         }
130 |         $this->addMarkerData($markers, $colors, null, $appearance);
131 | 
132 |         return $this;
133 |     }
134 | 
135 |     /**
136 |      * @param array $markers
137 |      * @param array|null $colors
138 |      * @param array|null $colorsDown
139 |      * @return Linechart
140 |      */
141 |     public function addMarkers(array $markers, ?array $colors = null, ?array $colorsDown = null): self
142 |     {
143 |         $this->addMarkerData($markers, $colors, $colorsDown);
144 | 
145 |         return $this;
146 |     }
147 | 
148 |     public function chart(): Chart
149 |     {
150 |         $graph = new Chart($this);
151 |         $graph->setSettings($this->getSettings());
152 |         $this->prepareData();
153 | 
154 |         foreach ($this->allmarkers as $markersData) {
155 |             $result = $this->getResultFromMarkersData($markersData);
156 | 
157 |             $this->currentColors = null;
158 |             $graph->addResult($result);
159 |         }
160 | 
161 |         $graph->setWidth($this->width);
162 | 
163 |         return $graph;
164 |     }
165 | 
166 |     public function getSettings(): Settings
167 |     {
168 |         if ($this->settings === null) {
169 |             $this->settings = new Settings();
170 |         }
171 | 
172 |         return $this->settings;
173 |     }
174 | 
175 |     public function setSettings(Settings $settings): self
176 |     {
177 |         $this->settings = $settings;
178 | 
179 |         return $this;
180 |     }
181 | 
182 |     public function clearAllMarkers(): self
183 |     {
184 |         $this->allmarkers = [];
185 | 
186 |         return $this;
187 |     }
188 | 
189 |     /**
190 |      * @param string $value
191 |      * @param string[] $color
192 |      */
193 |     public function addText(string $value, array $color): void
194 |     {
195 |         $this->text[] = [
196 |             self::VALUE => $value,
197 |             self::COLORS => $color,
198 |         ];
199 |     }
200 | 
201 |     /**
202 |      * @param array $values
203 |      * @param float $mainValue
204 |      * @param array $colors
205 |      */
206 |     public function addSpread(array $values, float $mainValue, array $colors): void
207 |     {
208 |         foreach ($values as $value) {
209 |             $colors = $colors ?? [];
210 |             $appearance = $value === 1 ? self::FULL_LINE : self::DASHED_LINE;
211 |             $this->addLine($value * $mainValue, $colors ?? [], $appearance);
212 |         }
213 |     }
214 | 
215 |     /**
216 |      * @param float $value alias y coordinate
217 |      * @param array|null $colors
218 |      * @param string|null $appearance
219 |      * @return Linechart
220 |      */
221 |     public function addLine(float $value, ?array $colors = null, ?string $appearance = null): self
222 |     {
223 |         $markers = [];
224 |         $markers[0] = $value;
225 |         if (!in_array($appearance, [self::DASHED_LINE, self::FULL_LINE], true)) {
226 |             $appearance = self::DASHED_LINE;
227 |         }
228 |         $this->addMarkerData($markers, $colors, null, $appearance);
229 | 
230 |         return $this;
231 |     }
232 | 
233 |     public function getText(): array
234 |     {
235 |         return $this->text;
236 |     }
237 | 
238 |     public function clearText(): void
239 |     {
240 |         $this->text = [];
241 |     }
242 | 
243 |     /**
244 |      * @param array $markers
245 |      * @param array|null $colors
246 |      * @param array|null $colorsDown
247 |      * @param string|null $point
248 |      * @return Linechart
249 |      */
250 |     private function addMarkerData(array $markers, ?array $colors = null, ?array $colorsDown = null, ?string $point = null): self
251 |     {
252 |         $markersData = [
253 |             self::MARKERS => $this->normalizeData($markers),
254 |             self::COLORS => $colors ?? [],
255 |             self::COLORS_DOWN => $colorsDown ?? $colors ?? [],
256 |             self::POINT => $point,
257 |         ];
258 | 
259 |         $this->allmarkers[] = $markersData;
260 | 
261 |         return $this;
262 |     }
263 | 
264 |     private function prepareData(): void
265 |     {
266 |         [$min, $max, $width] = $this->findMinMax($this->allmarkers);
267 | 
268 |         $this->adjuster = $this->findAdjuster($min, $max);
269 |         $max = $this->adjust($max);
270 |         $min = $this->adjust($min);
271 | 
272 |         $this->range = max(1, abs($max - $min));
273 | 
274 |         $height = max(1, (int) ($this->getSettings()->getHeight() ?? $this->range));
275 |         $this->ratio = $height / $this->range;
276 | 
277 |         $this->min2 = $min * $this->ratio;
278 |         $this->max2 = $max * $this->ratio;
279 | 
280 |         $this->rows = (int) max(0, abs(round($this->max2 - $this->min2)));
281 | 
282 |         $this->offset = $this->getSettings()->getOffset();
283 | 
284 |         $this->width = $width + $this->offset;
285 |     }
286 | 
287 |     private function getResultFromMarkersData(array $markersData): array
288 |     {
289 |         $markersData[self::MARKERS] = $this->adjustMarkerValues($markersData[self::MARKERS]);
290 |         $this->currentColors = $this->currentColors ?? $markersData[self::COLORS];
291 | 
292 |         $result = $this->processBorder($this->prepareResult(), $markersData);
293 | 
294 |         $isPoint = in_array($markersData[self::POINT], [self::CROSS, self::POINT], true);
295 |         $isLine = in_array($markersData[self::POINT], [self::DASHED_LINE, self::FULL_LINE], true);
296 | 
297 |         foreach ($markersData[self::MARKERS] as $x => $value) {
298 |             $y0 = (int) (round($value * $this->ratio) - $this->min2);
299 | 
300 |             if ($this->isPresent($markersData[self::MARKERS], $x + 1)) {
301 |                 $result = $this->processLinearGraph($result, $markersData, $x, $y0);
302 |             } elseif ($x !== 0 && $isPoint) {
303 |                 $result = $this->processPoint($result, $markersData, $y0, $x);
304 |             } elseif ($x === 0 && $isLine) {
305 |                 $result = $this->processLine($result, $y0, $markersData[self::POINT]);
306 |             }
307 |         }
308 | 
309 |         return $result;
310 |     }
311 | 
312 |     private function normalizeData(array $markers): array
313 |     {
314 |         $markers = array_filter($markers, '\is_int', ARRAY_FILTER_USE_KEY);
315 |         ksort($markers);
316 | 
317 |         reset($markers);
318 |         $firstKey = key($markers);
319 | 
320 |         $keys = [];
321 |         foreach (array_keys($markers) as $key) {
322 |             $keys[] = $key - $firstKey;
323 |         }
324 | 
325 |         $combined = array_combine($keys, $markers);
326 | 
327 |         if ($combined === false) {
328 |             return [];
329 |         }
330 | 
331 |         return $combined;
332 |     }
333 | 
334 |     private function findMinMax(array $allmarkers): array
335 |     {
336 |         $width = 0;
337 |         $min = PHP_INT_MAX;
338 |         $max = -PHP_INT_MAX;
339 |         foreach ($allmarkers as $markers) {
340 |             end($markers[self::MARKERS]);
341 |             $width = (int) max($width, key($markers[self::MARKERS]));
342 | 
343 |             /** @var int[][] $markers */
344 |             foreach ($markers[self::MARKERS] as $value) {
345 |                 if ($value !== null && $value !== false) {
346 |                     $min = min($min, $value);
347 |                     $max = max($max, $value);
348 |                 }
349 |             }
350 |         }
351 | 
352 |         return [$min, $max, $width];
353 |     }
354 | 
355 |     private function findAdjuster(float $min, float $max): ?float
356 |     {
357 |         $adjuster = null;
358 |         $realMin = $max - $min;
359 | 
360 |         if ($realMin < 1 && $realMin > 0) {
361 |             $adjuster = 1 / $realMin;
362 |         }
363 | 
364 |         return $adjuster;
365 |     }
366 | 
367 |     private function adjust(float $number): float
368 |     {
369 |         if ($this->adjuster !== null) {
370 |             $number *= $this->adjuster;
371 |         }
372 | 
373 |         return $number;
374 |     }
375 | 
376 |     private function adjustMarkerValues(array $markers): array
377 |     {
378 |         if ($this->adjuster === null) {
379 |             return $markers;
380 |         }
381 | 
382 |         return array_map(function ($value) {
383 |             return $this->adjuster !== null ? $value * $this->adjuster : $value;
384 |         }, $markers);
385 |     }
386 | 
387 |     private function processBorder(array $result, array $markersData): array
388 |     {
389 |         $format = $this->getSettings()->getFormat();
390 |         $y0 = (int) (round($markersData[self::MARKERS][0] * $this->ratio) - $this->min2);
391 |         $y = (int) floor($this->min2);
392 |         $yMax = (int) ceil($this->max2);
393 | 
394 |         for (; $y <= $yMax; ++$y) {
395 |             $rows = $this->rows === 0 ? 1 : $this->rows;
396 |             $rawLabel = $this->max2 / $this->ratio - ($y - $this->min2) * $this->range / $rows;
397 |             $rawLabel = $this->deadjust($rawLabel);
398 |             $label = $format($rawLabel, $this->getSettings());
399 | 
400 |             $border = '┤';
401 |             if ($y - $this->min2 === (float) ($rows - $y0)) {
402 |                 $label = $this->colorize($label, $this->currentColors);
403 |                 $border = $this->colorize('┼', $this->currentColors);
404 |             }
405 | 
406 |             $result[$y - $this->min2][max($this->offset - strlen($label), 0)] = $label;
407 |             $result[$y - $this->min2][$this->offset - 1] = $border;
408 |         }
409 | 
410 |         return $result;
411 |     }
412 | 
413 |     private function prepareResult(): array
414 |     {
415 |         $result = [];
416 | 
417 |         /** @noinspection ForeachInvariantsInspection */
418 |         for ($i = 0; $i <= $this->rows; $i++) {
419 |             $result[$i] = array_fill(0, $this->width, ' ');
420 |         }
421 | 
422 |         return $result;
423 |     }
424 | 
425 |     private function isPresent(array $markers, int $x): bool
426 |     {
427 |         return isset($markers[$x]) && ($markers[$x] !== null && $markers[$x] !== false);
428 |     }
429 | 
430 |     private function processLinearGraph(array $result, array $markersData, int $x, int $y): array
431 |     {
432 |         $y1 = (int) (round($markersData[self::MARKERS][$x + 1] * $this->ratio) - $this->min2);
433 |         if ($y === $y1) {
434 |             $result[$this->rows - $y][$x + $this->offset] = $this->colorize('─', $this->currentColors);
435 |         } else {
436 |             if ($y > $y1) {
437 |                 $connectA = '╰';
438 |                 $connectB = '╮';
439 | 
440 |                 $this->currentColors = $markersData[self::COLORS_DOWN];
441 |             } else {
442 |                 $connectA = '╭';
443 |                 $connectB = '╯';
444 | 
445 |                 $this->currentColors = $markersData[self::COLORS];
446 |             }
447 |             $result[$this->rows - $y1][$x + $this->offset] = $this->colorize($connectA, $this->currentColors);
448 |             $result[$this->rows - $y][$x + $this->offset] = $this->colorize($connectB, $this->currentColors);
449 | 
450 |             $from = min($y, $y1);
451 |             $to = max($y, $y1);
452 |             for ($i = $from + 1; $i < $to; $i++) {
453 |                 $result[$this->rows - $i][$x + $this->offset] = $this->colorize('│', $this->currentColors);
454 |             }
455 |         }
456 | 
457 |         return $result;
458 |     }
459 | 
460 |     private function processPoint(array $result, array $markersData, int $y, int $x): array
461 |     {
462 |         if ($markersData[self::POINT] === self::CROSS) {
463 |             for ($i = 0; $i <= $this->width - $this->offset - 2; $i++) {
464 |                 $result[$this->rows - $y][$i + $this->offset] = $this->colorize('╌', $this->currentColors);
465 |             }
466 |             for ($i = 0; $i <= $this->rows; $i++) {
467 |                 $result[$this->rows - $i][$x + $this->offset] = $this->colorize('╎', $this->currentColors);
468 |             }
469 |         }
470 | 
471 |         $result[$this->rows - $y][$x + $this->offset] = $this->colorize('o', $this->currentColors);
472 | 
473 |         return $result;
474 |     }
475 | 
476 |     private function processLine(array $result, int $y, string $lineStyle): array
477 |     {
478 |         $line = '╌';
479 |         if ($lineStyle === self::FULL_LINE) {
480 |             $line = '─';
481 |         }
482 | 
483 |         for ($i = 0; $i <= $this->width - $this->offset - 2; $i++) {
484 |             $result[$this->rows - $y][$i + $this->offset] = $this->colorize($line, $this->currentColors);
485 |         }
486 | 
487 |         return $result;
488 |     }
489 | 
490 |     private function deadjust(float $number): float
491 |     {
492 |         if ($this->adjuster !== null) {
493 |             $number /= $this->adjuster;
494 |         }
495 | 
496 |         return $number;
497 |     }
498 | 
499 |     private function colorize(string $label, ?array $currentColors = null): string
500 |     {
501 |         if ($this->colorizer === null) {
502 |             $this->colorizer = $this->getSettings()->getColorizer();
503 |         }
504 | 
505 |         return $this->colorizer->colorize($label, $currentColors);
506 |     }
507 | }
508 | 


--------------------------------------------------------------------------------