Merge pull request 'refactor/texte-verbessern' (#11) from refactor/texte-verbessern into master

Reviewed-on: #11

README.md

@@ -31,4 +31,8 @@ Die Werte werden als Hexadecimal Zahlen und in der Webschreibweise zur Verfügun
 
 Das Vorgehen der Umwandlung nimmt die Informationen von 
 [Wikipedia - Liste der Farbräume](https://de.wikipedia.org/wiki/Liste_der_Farbr%C3%A4ume)
-und [Die Chemie-Schule - HSV-Farbraum](https://www.chemie-schule.de/KnowHow/HSV-Farbraum) auf.
+und [Die Chemie-Schule - HSV-Farbraum](https://www.chemie-schule.de/KnowHow/HSV-Farbraum) auf.
+
+### Transformation natürlicher Modelle
+
+Die Klassen benötigen natürliche Modelle und geben auch nur solche raus.

composer.json

@@ -28,7 +28,7 @@
     "require-dev": {
         "codeception/codeception": "^4.1.18",
         "codeception/module-phpbrowser": "^1.0.0",
-        "codeception/module-asserts": "^1.0.0",
-        "phpstan/phpstan" : "^0.12.82"
+        "codeception/module-asserts": "^1.3.1",
+        "phpstan/phpstan" : "^1.4.7"
     }
 }

resources/uml/Klassen-Aufbau.puml

@@ -20,19 +20,38 @@ NaturallyColorModels.CyanMagentaYellowKey o-- ColorModels.CyanMagentaYellowKey
 NaturallyColorModels.HueSaturationValue o-- ColorModels.HueSaturationValue
 NaturallyColorModels.RedGreenBlue o-- ColorModels.RedGreenBlue
 
-
-namespace Transformer {
+namespace NaturallyTransformer {
     interface ColorModelTransformInterface {
-        + toRedGreenBlue(): RedGreenBlue;
-        + toCyanMagentaYellowKey(): CyanMagentaYellowKey;
-        + toHueSaturationValue(): HueSaturationValue;
+        + toRedGreenBlue(): NaturallyColorModels.RedGreenBlue
+        + toCyanMagentaYellowKey(): NaturallyColorModels.CyanMagentaYellowKey
+        + toHueSaturationValue(): NaturallyColorModels.HueSaturationValue
     }
     class CyanMagentaYellowKeyTransformer
     class HueSaturationValueTransformer
     class RedGreenBlueTransformer
-    ColorModelTransformInterface <|-- CyanMagentaYellowKeyTransformer
-    ColorModelTransformInterface <|-- HueSaturationValueTransformer
-    ColorModelTransformInterface <|-- RedGreenBlueTransformer
+
+    NaturallyTransformer.ColorModelTransformInterface o-- Transformer.ColorModelTransformInterface
+
+    NaturallyTransformer.ColorModelTransformInterface <|-- NaturallyTransformer.CyanMagentaYellowKeyTransformer
+    NaturallyTransformer.ColorModelTransformInterface <|-- NaturallyTransformer.HueSaturationValueTransformer
+    NaturallyTransformer.ColorModelTransformInterface <|-- NaturallyTransformer.RedGreenBlueTransformer
+    NaturallyTransformer.RedGreenBlueTransformer o-- NaturallyColorModels.RedGreenBlue
+    NaturallyTransformer.CyanMagentaYellowKeyTransformer o-- NaturallyColorModels.CyanMagentaYellowKey
+    NaturallyTransformer.HueSaturationValueTransformer o-- NaturallyColorModels.HueSaturationValue
+}
+
+namespace Transformer {
+    interface ColorModelTransformInterface {
+        + toRedGreenBlue(): ColorModels.RedGreenBlue
+        + toCyanMagentaYellowKey(): ColorModels.CyanMagentaYellowKey
+        + toHueSaturationValue(): ColorModels.HueSaturationValue
+    }
+    class CyanMagentaYellowKeyTransformer
+    class HueSaturationValueTransformer
+    class RedGreenBlueTransformer
+    Transformer.ColorModelTransformInterface <|-- Transformer.CyanMagentaYellowKeyTransformer
+    Transformer.ColorModelTransformInterface <|-- Transformer.HueSaturationValueTransformer
+    Transformer.ColorModelTransformInterface <|-- Transformer.RedGreenBlueTransformer
     namespace Utilities {
         abstract AbstractHueSaturationValueToUtility
         class CyanMagentaYellowKeyToHueSaturationValue

src/ColorModels/CyanMagentaYellowKey.php

@@ -9,11 +9,11 @@ namespace TorstenHettstedt\Colors\ColorModels;
  */
 class CyanMagentaYellowKey extends AbstractColorModel
 {
-    /** @var float : Definition des Cyan-Anteil */
+    /** @var float : Definition des Cyan-Anteils */
     protected float $cyan = 0.0;
-    /** @var float : Definition des Magenta-Anteil */
+    /** @var float : Definition des Magenta-Anteils */
     protected float $magenta = 0.0;
-    /** @var float : Definition des Gelbanteil */
+    /** @var float : Definition des Gelbanteiles */
     protected float $yellow = 0.0;
     /** @var float : Definition des Schwarzanteil */
     protected float $key = 0.0;

src/ColorModels/HueSaturationValue.php

@@ -9,7 +9,7 @@ namespace TorstenHettstedt\Colors\ColorModels;
  */
 class HueSaturationValue extends AbstractColorModel
 {
-    /** @var float : Definition des Farbton als Anteil eines Vollkreises '$Hue * π' */
+    /** @var float : Definition des Farbtones als Anteil eines Vollkreises '$Hue * π' */
     protected float $hue = 0.0;
     /** @var float : Definition der Sättigung der Farbe */
     protected float $saturation = 0.0;

src/ColorModels/RedGreenBlue.php

@@ -8,11 +8,11 @@ namespace TorstenHettstedt\Colors\ColorModels;
  */
 class RedGreenBlue extends AbstractColorModel
 {
-    /** @var float : Definition des Rotanteil */
+    /** @var float : Definition des Rot-Anteils */
     protected float $red = 1.0;
-    /** @var float : Definition des Grünanteil */
+    /** @var float : Definition des Grün-Anteils */
     protected float $green = 1.0;
-    /** @var float : Definition des Grünanteil */
+    /** @var float : Definition des Blau-Anteils */
     protected float $blue = 1.0;
 
     /**

src/NaturallyColorModels/CyanMagentaYellowKey.php

@@ -22,6 +22,14 @@ class CyanMagentaYellowKey
         $this->percentValuesHelper = new Helper\PercentValues();
     }
 
+    /**
+     * @return PureCyanMagentaYellowKey
+     */
+    public function getPureColor(): PureCyanMagentaYellowKey
+    {
+        return $this->pureColor;
+    }
+
     /**
      * @return int
      */

src/NaturallyColorModels/Helper/GradValues.php

@@ -10,7 +10,7 @@ class GradValues
 
     public function asGradValue(float $value): int
     {
-        return intval($value * 360);
+        return intval(round($value * 360, 0, PHP_ROUND_HALF_UP));
     }
 
     public function fromGradValue(int $value): float

src/NaturallyColorModels/Helper/PercentValues.php

@@ -10,7 +10,7 @@ class PercentValues
 
     public function asPercentValue(float $value): int
     {
-        return intval($value * 100);
+        return intval(round($value * 100, 0, PHP_ROUND_HALF_UP));
     }
 
     public function fromPercentValue(int $value): float

src/NaturallyColorModels/HueSaturationValue.php

@@ -25,6 +25,14 @@ class HueSaturationValue
         $this->gradValuesHelper = new Helper\GradValues();
     }
 
+    /**
+     * @return PureHueSaturationValue
+     */
+    public function getPureColor(): PureHueSaturationValue
+    {
+        return $this->pureColor;
+    }
+
     /**
      * @return int
      */

src/NaturallyColorModels/RedGreenBlue.php

@@ -21,6 +21,14 @@ class RedGreenBlue
         $this->hexadecimalValuesHelper = new Helper\HexadecimalValues();
     }
 
+    /**
+     * @return PureRedGreenBlue
+     */
+    public function getPureColor(): PureRedGreenBlue
+    {
+        return $this->pureColor;
+    }
+
     /**
      * @return int
      */
@@ -62,7 +70,7 @@ class RedGreenBlue
     /**
      * @return int
      */
-    public function getBlue(): int
+    #[Pure] public function getBlue(): int
     {
         return $this->hexadecimalValuesHelper->asHexadecimalValue($this->pureColor->getBlue());
     }
@@ -78,7 +86,7 @@ class RedGreenBlue
         return $this;
     }
 
-    public function asHtmlNotation(): string
+    #[Pure] public function asHtmlNotation(): string
     {
         return sprintf('#%X%X%X', $this->getRed(), $this->getGreen(), $this->getBlue());
     }

src/NaturallyTransformer/AbstractNaturallyTransformer.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace TorstenHettstedt\Colors\NaturallyTransformer;
+
+use TorstenHettstedt\Colors\NaturallyColorModels\CyanMagentaYellowKey;
+use TorstenHettstedt\Colors\NaturallyColorModels\Helper\GradValues;
+use TorstenHettstedt\Colors\NaturallyColorModels\Helper\HexadecimalValues;
+use TorstenHettstedt\Colors\NaturallyColorModels\Helper\PercentValues;
+use TorstenHettstedt\Colors\NaturallyColorModels\HueSaturationValue;
+use TorstenHettstedt\Colors\NaturallyColorModels\RedGreenBlue;
+use TorstenHettstedt\Colors\Transformer\ColorModelTransformInterface as PureTransformer;
+
+class AbstractNaturallyTransformer implements ColorModelTransformInterface
+{
+
+
+    protected PureTransformer $transformer;
+
+
+    public function toRedGreenBlue(): RedGreenBlue
+    {
+        $hex_helper = new HexadecimalValues();
+        $convert_color = $this->transformer->toRedGreenBlue();
+        $naturally_color = new RedGreenBlue();
+        $naturally_color->setRed($hex_helper->asHexadecimalValue($convert_color->getRed()));
+        $naturally_color->setGreen($hex_helper->asHexadecimalValue($convert_color->getGreen()));
+        $naturally_color->setBlue($hex_helper->asHexadecimalValue($convert_color->getBlue()));
+        return $naturally_color;
+    }
+
+    public function toCyanMagentaYellowKey(): CyanMagentaYellowKey
+    {
+        $percent_helper = new PercentValues();
+        $convert_color = $this->transformer->toCyanMagentaYellowKey();
+        $naturally_color = new CyanMagentaYellowKey();
+        $naturally_color->setCyan($percent_helper->asPercentValue($convert_color->getCyan()));
+        $naturally_color->setYellow($percent_helper->asPercentValue($convert_color->getYellow()));
+        $naturally_color->setMagenta($percent_helper->asPercentValue($convert_color->getMagenta()));
+        $naturally_color->setKey($percent_helper->asPercentValue($convert_color->getKey()));
+        return $naturally_color;
+    }
+
+    public function toHueSaturationValue(): HueSaturationValue
+    {
+        $percent_helper = new PercentValues();
+        $grad_helper = new GradValues();
+        $convert_color = $this->transformer->toHueSaturationValue();
+        $naturally_color = new HueSaturationValue();
+        $naturally_color->setHue($grad_helper->asGradValue($convert_color->getHue()));
+        $naturally_color->setSaturation($percent_helper->asPercentValue($convert_color->getSaturation()));
+        $naturally_color->setValue($percent_helper->asPercentValue($convert_color->getValue()));
+        return $naturally_color;
+    }
+}

src/NaturallyTransformer/ColorModelTransformInterface.php

@@ -0,0 +1,18 @@
+<?php
+
+
+namespace TorstenHettstedt\Colors\NaturallyTransformer;
+
+
+use TorstenHettstedt\Colors\NaturallyColorModels\CyanMagentaYellowKey;
+use TorstenHettstedt\Colors\NaturallyColorModels\HueSaturationValue;
+use TorstenHettstedt\Colors\NaturallyColorModels\RedGreenBlue;
+
+interface ColorModelTransformInterface
+{
+    public function toRedGreenBlue(): RedGreenBlue;
+
+    public function toCyanMagentaYellowKey(): CyanMagentaYellowKey;
+
+    public function toHueSaturationValue(): HueSaturationValue;
+}

src/NaturallyTransformer/CyanMagentaYellowKeyTransformer.php

@@ -0,0 +1,21 @@
+<?php
+
+
+namespace TorstenHettstedt\Colors\NaturallyTransformer;
+
+
+use JetBrains\PhpStorm\Pure;
+use TorstenHettstedt\Colors\NaturallyColorModels\CyanMagentaYellowKey;
+use TorstenHettstedt\Colors\Transformer\CyanMagentaYellowKeyTransformer as PureTransformer;
+
+class CyanMagentaYellowKeyTransformer extends AbstractNaturallyTransformer
+{
+
+    /**
+     * @param CyanMagentaYellowKey $color
+     */
+    #[Pure] public function __construct(CyanMagentaYellowKey $color)
+    {
+        $this->transformer = new PureTransformer($color->getPureColor());
+    }
+}

src/NaturallyTransformer/HueSaturationValueTransformer.php

@@ -0,0 +1,21 @@
+<?php
+
+
+namespace TorstenHettstedt\Colors\NaturallyTransformer;
+
+
+use JetBrains\PhpStorm\Pure;
+use TorstenHettstedt\Colors\NaturallyColorModels\HueSaturationValue;
+use TorstenHettstedt\Colors\Transformer\HueSaturationValueTransformer as PureTransformer;
+
+class HueSaturationValueTransformer extends AbstractNaturallyTransformer
+{
+
+    /**
+     * @param HueSaturationValue $color
+     */
+    #[Pure] public function __construct(HueSaturationValue $color)
+    {
+        $this->transformer = new PureTransformer($color->getPureColor());
+    }
+}

src/NaturallyTransformer/RedGreenBlueTransformer.php

@@ -0,0 +1,21 @@
+<?php
+
+
+namespace TorstenHettstedt\Colors\NaturallyTransformer;
+
+
+use JetBrains\PhpStorm\Pure;
+use TorstenHettstedt\Colors\NaturallyColorModels\RedGreenBlue;
+use TorstenHettstedt\Colors\Transformer\RedGreenBlueTransformer as PureTransformer;
+
+class RedGreenBlueTransformer extends AbstractNaturallyTransformer
+{
+
+    /**
+     * @param RedGreenBlue $color
+     */
+    #[Pure] public function __construct(RedGreenBlue $color)
+    {
+        $this->transformer = new PureTransformer($color->getPureColor());
+    }
+}

src/Transformer/Utilities/AbstractHueSaturationValueToUtility.php

@@ -8,11 +8,11 @@ use TorstenHettstedt\Colors\ColorModels\HueSaturationValue;
 
 abstract class AbstractHueSaturationValueToUtility
 {
-    /** @var int : Größe des Intervals in 1/100 Grad */
+    /** @var float : Größe des Intervals in 1/100 Grad */
     protected const INTERVAL = 60.0 * 100.0;
 
     // Daten für HSV
-    /** @var float : Definition des Farbton als Anteil eines Vollkreises '$Hue * π' */
+    /** @var float : Definition des Farbtones als Anteil eines Vollkreises '$Hue * π' */
     protected float $hue;
     /** @var float : Anteil am Vollkreis in 1/100 Grad  */
     protected float $hueAsPercentGrad;
@@ -49,7 +49,7 @@ abstract class AbstractHueSaturationValueToUtility
      *
      * @return float
      */
-    protected function calcColorValue($reciprocal = false): float
+    protected function calcColorValue(bool $reciprocal = false): float
     {
         // Rest-Anteil am Vollkreis des aktuellen Intervals als Wert '[0,1]'
         $remainder_grad = $this->hueAsPercentGrad % self::INTERVAL;

src/Transformer/Utilities/CyanMagentaYellowKeyToHueSaturationValue.php

@@ -15,11 +15,11 @@ class CyanMagentaYellowKeyToHueSaturationValue
     const PROPERTY_KEY = 'key';
 
     // Daten für CMYK
-    /** @var float : Definition des Cyan-Anteil */
+    /** @var float : Definition des Cyan-Anteils */
     protected float $cyan;
-    /** @var float : Definition des Magenta-Anteil */
+    /** @var float : Definition des Magenta-Anteils */
     protected float $magenta;
-    /** @var float : Definition des Gelbanteil */
+    /** @var float : Definition des Gelbanteils */
     protected float $yellow;
     /** @var float : Definition des Schwarzanteil */
     protected float $key;
@@ -30,7 +30,7 @@ class CyanMagentaYellowKeyToHueSaturationValue
     protected float $minCmyProperty;
 
     // Daten für HSV
-    /** @var float : Definition des Farbton als Anteil eines Vollkreises '$Hue * π' */
+    /** @var float : Definition des Farbtones als Anteil eines Vollkreises '$Hue * π' */
     protected float $hue = 0.0;
     /** @var float : Definition der Sättigung der Farbe */
     protected float $saturation = 0.0;
@@ -77,7 +77,7 @@ class CyanMagentaYellowKeyToHueSaturationValue
     protected function buildHueAmount(): float
     {
         // Wenn beide Werte gleich sind, ist die Endfarbe Grau.
-        // Damit wird auch in {@sse hueAmount()} eine Division durch Null verhindert.
+        // Damit wird auch in {@sse hueAmount()} eine Division durch '0' verhindert.
         if ($this->maxCmyProperty === $this->minCmyProperty) {
             return 0.0;
         }

src/Transformer/Utilities/HueSaturationValueToCyanMagentaYellowKey.php

@@ -9,11 +9,11 @@ use TorstenHettstedt\Colors\ColorModels\CyanMagentaYellowKey;
 class HueSaturationValueToCyanMagentaYellowKey extends AbstractHueSaturationValueToUtility
 {
     // Daten für CMYK
-    /** @var float : Definition des Cyan-Anteil */
+    /** @var float : Definition des Cyan-Anteils */
     protected float $cyan = 0.0;
-    /** @var float : Definition des Magenta-Anteil */
+    /** @var float : Definition des Magenta-Anteils */
     protected float $magenta = 0.0;
-    /** @var float : Definition des Gelbanteil */
+    /** @var float : Definition des Gelbanteils */
     protected float $yellow = 0.0;
     /** @var float : Definition des Schwarzanteil */
     protected float $key = 0.0;

src/Transformer/Utilities/HueSaturationValueToRedGreenBlue.php

@@ -9,11 +9,11 @@ use TorstenHettstedt\Colors\ColorModels\RedGreenBlue;
 class HueSaturationValueToRedGreenBlue extends AbstractHueSaturationValueToUtility
 {
     // Daten für RGB
-    /** @var float : Definition des Rotanteil */
+    /** @var float : Definition des Rotanteils */
     protected float $red = 1.0;
-    /** @var float : Definition des Grünanteil */
+    /** @var float : Definition des Grünanteils */
     protected float $green = 1.0;
-    /** @var float : Definition des Blauanteil */
+    /** @var float : Definition des Blauanteils */
     protected float $blue = 1.0;
 
     public function convert(): RedGreenBlue
@@ -37,7 +37,7 @@ class HueSaturationValueToRedGreenBlue extends AbstractHueSaturationValueToUtili
     {
         // ID des zu nutzenden Interval
         $interval_id = $this->hueAsPercentGrad / self::INTERVAL;
-        // Ist der Wert der entgegen gesetzten Farbe.
+        // der Wert der entgegen gesetzten Farbe
         $opposite_color_value = $this->value * ( 1 - $this->saturation);
 
         switch ((int)$interval_id) {

src/Transformer/Utilities/RedGreenBlueToHueSaturationValue.php

@@ -13,11 +13,11 @@ class RedGreenBlueToHueSaturationValue
     const PROPERTY_BLUE  = 'blue';
 
     // Daten für RGB
-    /** @var float : Definition des Rotanteil */
+    /** @var float : Definition des Rot-Anteils */
     protected float $red;
-    /** @var float : Definition des Grünanteil */
+    /** @var float : Definition des Grün-Anteils */
     protected float $green;
-    /** @var float : Definition des Blauanteil */
+    /** @var float : Definition des Blau-Anteils */
     protected float $blu;
 
     /** @var float : Der größte RGB-Farbwert */
@@ -26,7 +26,7 @@ class RedGreenBlueToHueSaturationValue
     protected float $minRgbProperty;
 
     // Daten für HSV
-    /** @var float : Definition des Farbton als Anteil eines Vollkreises '$Hue * π' */
+    /** @var float : Definition des Farbtones als Anteil eines Vollkreises '$Hue * π' */
     protected float $hue = 0.0;
     /** @var float : Definition der Sättigung der Farbe */
     protected float $saturation = 0.0;
@@ -75,7 +75,7 @@ class RedGreenBlueToHueSaturationValue
     protected function buildHueAmount(): float
     {
         // Wenn beide Werte gleich sind, ist die Endfarbe Grau.
-        // Damit wird auch in {@sse hueAmount()} eine Division durch Null verhindert.
+        // Damit wird auch in {@sse hueAmount()} eine Division durch '0' verhindert.
         if ($this->maxRgbProperty === $this->minRgbProperty) {
             return 0.0;
         }
@@ -114,7 +114,6 @@ class RedGreenBlueToHueSaturationValue
 
         switch ($property) {
             case self::PROPERTY_RED:
-                $amount = 0.0; // 0.0
                 $dividend = $this->green - $this->blu;
                 break;
             case self::PROPERTY_GREEN:

tests/_support/Helper/ValidColorValuesProvider.php

@@ -12,7 +12,7 @@ class ValidColorValuesProvider
     const HSV  = 'hsv';
 
     /**
-     * @var array<string, array<string, float>[]>
+     * @var array<string, array<array<string, float>>>
      */
     protected array $definitions = [
         'weiß'    => [
@@ -308,7 +308,7 @@ class ValidColorValuesProvider
     /**
      * @param array<string> $order
      *
-     * @return array<string, array<string, float>[]>
+     * @return array<string, array<array<string, float>>>
      */
     public function getValidColorValues(array $order): array
     {

tests/_support/Helper/ValidNaturallyColorValuesProvider.php

@@ -0,0 +1,128 @@
+<?php
+
+
+namespace TorstenHettstedt\Colors\Tests\Helper;
+
+
+class ValidNaturallyColorValuesProvider
+{
+
+    const CMYK = 'cmyk';
+    const RGB  = 'rgb';
+    const HSV  = 'hsv';
+
+    /**
+     * @var array<string, array<array<string, float>>>
+     */
+    protected array $definitions = [
+        'weiß'    => [
+            self::CMYK => [
+                'cyan'    => 0,
+                'magenta' => 0,
+                'yellow'  => 0,
+                'key'     => 0,
+            ],
+            self::RGB  => [
+                'red'   => 0xFF,
+                'green' => 0xFF,
+                'blue'  => 0xFF,
+            ],
+            self::HSV  => [
+                'hue'        =>   0,
+                'saturation' =>   0,
+                'value'      => 100,
+            ],
+        ],
+        'hellgrau' => [
+            self::CMYK => [
+                'cyan'    =>  0,
+                'magenta' =>  0,
+                'yellow'  =>  0,
+                'key'     => 67,
+            ],
+            self::RGB  => [
+                'red'   => 0x55,
+                'green' => 0x55,
+                'blue'  => 0x55,
+            ],
+            self::HSV  => [
+                'hue'        =>  0,
+                'saturation' =>  0,
+                'value'      => 33,
+            ],
+        ],
+        'dunkelgrau' => [
+            self::CMYK => [
+                'cyan'    =>  0,
+                'magenta' =>  0,
+                'yellow'  =>  0,
+                'key'     => 33,
+            ],
+            self::RGB  => [
+                'red'   => 0xAA,
+                'green' => 0xAA,
+                'blue'  => 0xAA,
+            ],
+            self::HSV  => [
+                'hue'        =>  0,
+                'saturation' =>  0,
+                'value'      => 67,
+            ],
+        ],
+        'schwarz' => [
+            self::CMYK => [
+                'cyan'    =>   0,
+                'magenta' =>   0,
+                'yellow'  =>   0,
+                'key'     => 100,
+            ],
+            self::RGB  => [
+                'red'   => 0,
+                'green' => 0,
+                'blue'  => 0,
+            ],
+            self::HSV  => [
+                'hue'        => 0,
+                'saturation' => 0,
+                'value'      => 0,
+            ],
+        ],
+        'aquamarin' => [
+            self::CMYK => [
+                'cyan'    => 50,
+                'magenta' =>  0,
+                'yellow'  => 17,
+                'key'     =>  0,
+            ],
+            self::RGB  => [
+                'red'   => 0x7F,
+                'green' => 0xFF,
+                'blue'  => 0xD4,
+            ],
+            self::HSV  => [
+                'hue'        => 160,
+                'saturation' =>  50,
+                'value'      => 100,
+            ],
+        ],
+    ];
+
+    /**
+     * @param string $pure_color
+     * @param string $test_color
+     *
+     * @return array<string, array<array<string, float>>>
+     */
+    public function getValidColorValues(string $pure_color, string $test_color): array
+    {
+        $values = [];
+        $pure_values = (new ValidColorValuesProvider())->getValidColorValues([$pure_color]);
+        foreach ($this->definitions as $color => $definition) {
+            $values[$color] = [
+                $pure_values[$color][0],
+                $definition[$test_color]
+            ];
+        }
+        return $values;
+    }
+}

tests/unit/NaturallyColorModels/CyanMagentaYellowKeyTest.php

@@ -125,4 +125,19 @@ class CyanMagentaYellowKeyTest extends AbstractColorModelUnit
         $this->expectException(InvalidArgumentException::class);
         $color->setKey($value);
     }
+
+    public function testGetPureColor(): void
+    {
+        $naturally_color = new CyanMagentaYellowKey();
+        $naturally_color
+            ->setCyan(12)
+            ->setMagenta(28)
+            ->setYellow(37)
+            ->setKey(56);
+        $pure_color = $naturally_color->getPureColor();
+        $this->assertEquals(0.12, $pure_color->getCyan());
+        $this->assertEquals(0.28, $pure_color->getMagenta());
+        $this->assertEquals(0.37, $pure_color->getYellow());
+        $this->assertEquals(0.56, $pure_color->getKey());
+    }
 }

tests/unit/NaturallyColorModels/HueSaturationValueTest.php

@@ -97,4 +97,17 @@ class HueSaturationValueTest extends AbstractColorModelUnit
         $this->expectException(InvalidArgumentException::class);
         $color->setValue($value);
     }
+
+    public function testGetPureColor(): void
+    {
+        $naturally_color = new HueSaturationValue();
+        $naturally_color
+            ->setHue(45)
+            ->setSaturation(28)
+            ->setValue(56);
+        $pure_color = $naturally_color->getPureColor();
+        $this->assertEquals(0.125, $pure_color->getHue());
+        $this->assertEquals(0.28, $pure_color->getSaturation());
+        $this->assertEquals(0.56, $pure_color->getValue());
+    }
 }

tests/unit/NaturallyColorModels/RedGreenBlueTest.php

@@ -106,4 +106,17 @@ class RedGreenBlueTest extends AbstractColorModelUnit
         $this->assertIsString($html);
         $this->assertEquals('#A1B2C3', $html);
     }
+
+    public function testGetPureColor(): void
+    {
+        $naturally_color = new RedGreenBlue();
+        $naturally_color
+            ->setRed(0x33)
+            ->setBlue(0x66)
+            ->setGreen(0x99);
+        $pure_color = $naturally_color->getPureColor();
+        $this->assertEquals(0.2, $pure_color->getRed());
+        $this->assertEquals(0.4, $pure_color->getBlue());
+        $this->assertEquals(0.6, $pure_color->getGreen());
+    }
 }

tests/unit/NaturallyTransformer/CyanMagentaYellowKeyTransformerTest.php

@@ -0,0 +1,121 @@
+<?php
+
+namespace TorstenHettstedt\Colors\Tests\Unit\NaturallyTransformer;
+
+use Codeception\Test\Unit;
+use Exception;
+use TorstenHettstedt\Colors\NaturallyColorModels\CyanMagentaYellowKey;
+use TorstenHettstedt\Colors\Tests\Helper\ValidNaturallyColorValuesProvider;
+use TorstenHettstedt\Colors\NaturallyTransformer\CyanMagentaYellowKeyTransformer;
+
+class CyanMagentaYellowKeyTransformerTest extends Unit
+{
+
+    protected CyanMagentaYellowKey $color;
+
+    /**
+     * @return array<string, array<array<string, float>>>
+     */
+    public function validRgbValuesProvider(): array
+    {
+        return (new ValidNaturallyColorValuesProvider())->getValidColorValues(
+            ValidNaturallyColorValuesProvider::CMYK,
+            ValidNaturallyColorValuesProvider::RGB
+        );
+    }
+
+    /**
+     * @return array<string, array<array<string, float>>>
+     */
+    public function validHsvValuesProvider(): array
+    {
+        return (new ValidNaturallyColorValuesProvider())->getValidColorValues(
+            ValidNaturallyColorValuesProvider::CMYK,
+            ValidNaturallyColorValuesProvider::HSV
+        );
+    }
+
+    /**
+     * @return array<string, array<array<string, float>>>
+     */
+    public function validCmykValuesProvider(): array
+    {
+        return (new ValidNaturallyColorValuesProvider())->getValidColorValues(
+            ValidNaturallyColorValuesProvider::CMYK,
+            ValidNaturallyColorValuesProvider::CMYK
+        );
+    }
+
+    /**
+     * @param array<string, float> $pure_color
+     * @param array<string, float> $rgb
+     *
+     * @dataProvider validRgbValuesProvider
+     *
+     * @throws Exception
+     */
+    public function testToRedGreenBlue(array $pure_color, array $rgb): void
+    {
+        $this->color = $this->make(CyanMagentaYellowKey::class, [
+            'getPureColor' => $this->make(\TorstenHettstedt\Colors\ColorModels\CyanMagentaYellowKey::class, $pure_color)
+        ]);
+
+        $transformer = new CyanMagentaYellowKeyTransformer($this->color);
+
+        $color = $transformer->toRedGreenBlue();
+
+        $this->assertEquals($rgb['red'], $color->getRed());
+        $this->assertEquals($rgb['green'], $color->getGreen());
+        $this->assertEquals($rgb['blue'], $color->getBlue());
+
+    }
+
+    /**
+     * @param array<string, float> $pure_color
+     * @param array<string, float> $cmyk
+     *
+     * @dataProvider validCmykValuesProvider
+     *
+     * @throws Exception
+     */
+    public function testToCyanMagentaYellowKey(array $pure_color, array $cmyk): void
+    {
+
+        $this->color = $this->make(CyanMagentaYellowKey::class, [
+            'getPureColor' => $this->make(\TorstenHettstedt\Colors\ColorModels\CyanMagentaYellowKey::class, $pure_color)
+        ]);
+
+        $transformer = new CyanMagentaYellowKeyTransformer($this->color);
+
+        $color = $transformer->toCyanMagentaYellowKey();
+
+        $this->assertEquals($cmyk['cyan'], $color->getCyan());
+        $this->assertEquals($cmyk['magenta'], $color->getMagenta());
+        $this->assertEquals($cmyk['yellow'], $color->getYellow());
+        $this->assertEquals($cmyk['key'], $color->getKey());
+    }
+
+    /**
+     * @param array<string, float> $pure_color
+     * @param array<string, float> $hsv
+     *
+     * @throws Exception
+     *
+     * @dataProvider validHsvValuesProvider
+     *
+     */
+    public function testToHueSaturationValue(array $pure_color, array $hsv): void
+    {
+        $this->color = $this->make(CyanMagentaYellowKey::class, [
+            'getPureColor' => $this->make(\TorstenHettstedt\Colors\ColorModels\CyanMagentaYellowKey::class, $pure_color)
+        ]);
+
+        $transformer = new CyanMagentaYellowKeyTransformer($this->color);
+
+        $color = $transformer->toHueSaturationValue();
+
+        $this->assertEquals($hsv['hue'], $color->getHue());
+        $this->assertEquals($hsv['saturation'], $color->getSaturation());
+        $this->assertEquals($hsv['value'], $color->getValue());
+    }
+}

tests/unit/NaturallyTransformer/HueSaturationValueTransformerTest.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace TorstenHettstedt\Colors\Tests\Unit\NaturallyTransformer;
+
+use Codeception\Test\Unit;
+use Exception;
+use TorstenHettstedt\Colors\NaturallyColorModels\HueSaturationValue;
+use TorstenHettstedt\Colors\Tests\Helper\ValidNaturallyColorValuesProvider;
+use TorstenHettstedt\Colors\NaturallyTransformer\HueSaturationValueTransformer;
+
+class HueSaturationValueTransformerTest extends Unit
+{
+
+    protected HueSaturationValue $color;
+
+    /**
+     * @return array<string, array<array<string, float>>>
+     */
+    public function validCmykValuesProvider(): array
+    {
+        return (new ValidNaturallyColorValuesProvider())->getValidColorValues(
+            ValidNaturallyColorValuesProvider::HSV,
+            ValidNaturallyColorValuesProvider::CMYK,
+        );
+    }
+
+    /**
+     * @return array<string, array<array<string, float>>>
+     */
+    public function validRgbValuesProvider(): array
+    {
+        return (new ValidNaturallyColorValuesProvider())->getValidColorValues(
+            ValidNaturallyColorValuesProvider::HSV,
+            ValidNaturallyColorValuesProvider::RGB,
+        );
+    }
+
+    /**
+     * @return array<string, array<array<string, float>>>
+     */
+    public function validHsvValuesProvider(): array
+    {
+        return (new ValidNaturallyColorValuesProvider())->getValidColorValues(
+            ValidNaturallyColorValuesProvider::HSV,
+            ValidNaturallyColorValuesProvider::HSV,
+        );
+    }
+
+    /**
+     * @param array<string, float> $pure_color
+     * @param array<string, float> $rgb
+     *
+     * @dataProvider validRgbValuesProvider
+     *
+     * @throws Exception
+     */
+    public function testToRedGreenBlue(array $pure_color, array $rgb): void
+    {
+        $this->color = $this->make(HueSaturationValue::class, [
+            'getPureColor' => $this->make(\TorstenHettstedt\Colors\ColorModels\HueSaturationValue::class, $pure_color)
+        ]);
+
+        $transformer = new HueSaturationValueTransformer($this->color);
+
+        $color = $transformer->toRedGreenBlue();
+
+        $this->assertEquals($rgb['red'], $color->getRed());
+        $this->assertEquals($rgb['green'], $color->getGreen());
+        $this->assertEquals($rgb['blue'], $color->getBlue());
+
+    }
+
+    /**
+     * @param array<string, float> $pure_color
+     * @param array<string, float> $cmyk
+     *
+     * @throws Exception
+     * @dataProvider validCmykValuesProvider
+     *
+     */
+    public function testToCyanMagentaYellowKey(array $pure_color, array $cmyk): void
+    {
+        $this->color = $this->make(HueSaturationValue::class, [
+            'getPureColor' => $this->make(\TorstenHettstedt\Colors\ColorModels\HueSaturationValue::class, $pure_color)
+        ]);
+
+        $transformer = new HueSaturationValueTransformer($this->color);
+
+        $color = $transformer->toCyanMagentaYellowKey();
+
+        $this->assertEquals($cmyk['cyan'], $color->getCyan());
+        $this->assertEquals($cmyk['magenta'], $color->getMagenta());
+        $this->assertEquals($cmyk['yellow'], $color->getYellow());
+        $this->assertEquals($cmyk['key'], $color->getKey());
+    }
+
+    /**
+     * @param array<string, float> $pure_color
+     * @param array<string, float> $hsv
+     *
+     * @throws Exception
+     * @dataProvider validHsvValuesProvider
+     */
+    public function testToHueSaturationValue(array $pure_color, array $hsv): void
+    {
+        $this->color = $this->make(HueSaturationValue::class, [
+            'getPureColor' => $this->make(\TorstenHettstedt\Colors\ColorModels\HueSaturationValue::class, $pure_color)
+        ]);
+
+        $transformer = new HueSaturationValueTransformer($this->color);
+
+        $color = $transformer->toHueSaturationValue();
+
+        $this->assertEquals($hsv['hue'], $color->getHue());
+        $this->assertEquals($hsv['saturation'], $color->getSaturation());
+        $this->assertEquals($hsv['value'], $color->getValue());
+    }
+}

tests/unit/NaturallyTransformer/RedGreenBlueTransformerTest.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace TorstenHettstedt\Colors\Tests\Unit\NaturallyTransformer;
+
+use Codeception\Test\Unit;
+use Exception;
+use TorstenHettstedt\Colors\NaturallyColorModels\RedGreenBlue;
+use TorstenHettstedt\Colors\Tests\Helper\ValidNaturallyColorValuesProvider;
+use TorstenHettstedt\Colors\NaturallyTransformer\RedGreenBlueTransformer;
+
+class RedGreenBlueTransformerTest extends Unit
+{
+
+    protected RedGreenBlue $color;
+
+    /**
+     * @return array<string, array<array<string, float>>>
+     */
+    public function validCmykValuesProvider(): array
+    {
+        return (new ValidNaturallyColorValuesProvider())->getValidColorValues(
+            ValidNaturallyColorValuesProvider::RGB,
+            ValidNaturallyColorValuesProvider::CMYK,
+        );
+    }
+
+    /**
+     * @return array<string, array<array<string, float>>>
+     */
+    public function validHsvValuesProvider(): array
+    {
+        return (new ValidNaturallyColorValuesProvider())->getValidColorValues(
+            ValidNaturallyColorValuesProvider::RGB,
+            ValidNaturallyColorValuesProvider::HSV,
+        );
+    }
+
+    /**
+     * @return array<string, array<array<string, float>>>
+     */
+    public function validRgbValuesProvider(): array
+    {
+        return (new ValidNaturallyColorValuesProvider())->getValidColorValues(
+            ValidNaturallyColorValuesProvider::RGB,
+            ValidNaturallyColorValuesProvider::RGB,
+        );
+    }
+
+    /**
+     * @param array<string, float> $pure_color
+     * @param array<string, float> $rgb
+     *
+     * @dataProvider validRgbValuesProvider
+     *
+     * @throws Exception
+     */
+    public function testToRedGreenBlue(array $pure_color, array $rgb): void
+    {
+        $this->color = $this->make(RedGreenBlue::class, [
+            'getPureColor' => $this->make(\TorstenHettstedt\Colors\ColorModels\RedGreenBlue::class, $pure_color)
+        ]);
+
+        $transformer = new RedGreenBlueTransformer($this->color);
+
+        $color = $transformer->toRedGreenBlue();
+
+        $this->assertEquals($rgb['red'], $color->getRed());
+        $this->assertEquals($rgb['green'], $color->getGreen());
+        $this->assertEquals($rgb['blue'], $color->getBlue());
+
+    }
+
+    /**
+     * @param array<string, float> $pure_color
+     * @param array<string, float> $cmyk
+     *
+     * @throws Exception
+     * @dataProvider validCmykValuesProvider
+     *
+     */
+    public function testToCyanMagentaYellowKey(array $pure_color, array $cmyk): void
+    {
+        $this->color = $this->make(RedGreenBlue::class, [
+            'getPureColor' => $this->make(\TorstenHettstedt\Colors\ColorModels\RedGreenBlue::class, $pure_color)
+        ]);
+
+        $transformer = new RedGreenBlueTransformer($this->color);
+
+        $color = $transformer->toCyanMagentaYellowKey();
+
+        $this->assertEquals($cmyk['cyan'], $color->getCyan());
+        $this->assertEquals($cmyk['magenta'], $color->getMagenta());
+        $this->assertEquals($cmyk['yellow'], $color->getYellow());
+        $this->assertEquals($cmyk['key'], $color->getKey());
+    }
+
+    /**
+     * @param array<string, float> $pure_color
+     * @param array<string, float> $hsv
+     *
+     * @throws Exception
+     * @dataProvider validHsvValuesProvider
+     */
+    public function testToHueSaturationValue(array $pure_color, array $hsv): void
+    {
+        $this->color = $this->make(RedGreenBlue::class, [
+            'getPureColor' => $this->make(\TorstenHettstedt\Colors\ColorModels\RedGreenBlue::class, $pure_color)
+        ]);
+
+        $transformer = new RedGreenBlueTransformer($this->color);
+
+        $color = $transformer->toHueSaturationValue();
+
+        $this->assertEquals($hsv['hue'], $color->getHue());
+        $this->assertEquals($hsv['saturation'], $color->getSaturation());
+        $this->assertEquals($hsv['value'], $color->getValue());
+    }
+}

tests/unit/Transformer/CyanMagentaYellowKeyTransformerTest.php

@@ -16,7 +16,7 @@ class CyanMagentaYellowKeyTransformerTest extends Unit
     protected CyanMagentaYellowKey $color;
 
     /**
-     * @return array<string, array<string, float>[]>
+     * @return array<string, array<array<string, float>>>
      */
     public function validRgbValuesProvider(): array
     {
@@ -27,7 +27,7 @@ class CyanMagentaYellowKeyTransformerTest extends Unit
     }
 
     /**
-     * @return array<string, array<string, float>[]>
+     * @return array<string, array<array<string, float>>>
      */
     public function validHsvValuesProvider(): array
     {

tests/unit/Transformer/HueSaturationValueTransformerTest.php

@@ -16,7 +16,7 @@ class HueSaturationValueTransformerTest extends Unit
     protected HueSaturationValue $color;
 
     /**
-     * @return array<string, array<string, float>[]>
+     * @return array<string, array<array<string, float>>>
      */
     public function validCmykValuesProvider(): array
     {
@@ -27,7 +27,7 @@ class HueSaturationValueTransformerTest extends Unit
     }
 
     /**
-     * @return array<string, array<string, float>[]>
+     * @return array<string, array<array<string, float>>>
      */
     public function validRgbValuesProvider(): array
     {

tests/unit/Transformer/RedGreenBlueTransformerTest.php

@@ -16,7 +16,7 @@ class RedGreenBlueTransformerTest extends Unit
     protected RedGreenBlue $color;
 
     /**
-     * @return array<string, array<string, float>[]>
+     * @return array<string, array<array<string, float>>>
      */
     public function validCmykValuesProvider(): array
     {
@@ -27,7 +27,7 @@ class RedGreenBlueTransformerTest extends Unit
     }
 
     /**
-     * @return array<string, array<string, float>[]>
+     * @return array<string, array<array<string, float>>>
      */
     public function validHsvValuesProvider(): array
     {