Merge branch 'develop'

* develop:
  feat(ColorSpace): differnet color types

.clang-format

+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveMacros: None
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: Right
+AlignOperands:   Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: true
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     120
+CommentPragmas:  '^ IWYU pragma:'
+QualifierAlignment: Leave
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+PackConstructorInitializers: BinPack
+BasedOnStyle:    ''
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+AllowAllConstructorInitializersOnNextLine: true
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseLabels: false
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequires:  false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+LambdaBodyIndentation: Signature
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Right
+PPIndentWidth:   -1
+ReferenceAlignment: Pointer
+ReflowComments:  true
+RemoveBracesLLVM: false
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SortIncludes:    CaseSensitive
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterOverloadedOperator: false
+  BeforeNonEmptyParentheses: false
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  Never
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard:        Latest
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        8
+UseCRLF:         false
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...
+

.envrc

+
+export ENVNAME=CPP
+
+
+run() {
+    xmake
+    echo ""
+    xmake run resume /doc/work/WUR/data/APPLEMATURITY/transfer_1868746_files_e2d8fb8c/test_masks/test_masks/1662032319_640766208-snap__1_cam0_color_apple10.png /tmp/one.jpg 3
+}
+
+export_function run
+export_alias lcu "ls -la"

.gitignore

@@ -7,3 +7,5 @@ build/
 .DS_Store
 
 
+.cache
+.direnv

.vscode/c_cpp_properties.json

@@ -6,11 +6,12 @@
                 "${workspaceFolder}/**"
             ],
             "defines": [],
-            "compilerPath": "/usr/bin/clang-10",
+            "compilerPath": "/usr/bin/clang",
             "cStandard": "c17",
             "cppStandard": "c++14",
             "intelliSenseMode": "linux-clang-x64",
-            "compileCommands": "${workspaceFolder}/compile_commands.json"
+            "compileCommands": "${workspaceFolder}/compile_commands.json",
+            "configurationProvider": "ms-vscode.cmake-tools"
         }
     ],
     "version": 4

.vscode/compile_commands.json

-[
-{
-  "directory": "/doc/work/WUR/data/APPLEMATURITY/maturity",
-  "arguments": ["/usr/bin/gcc", "-c", "-m64", "-fvisibility=hidden", "-fvisibility-inlines-hidden", "-O3", "-std=c++2a", "-I/usr/include", "-I/usr/local/include", "-I", "/usr/include/opencv4", "-DNDEBUG", "-o", "build/.objs/resume/linux/x86_64/release/src/resume.cpp.o", "src/resume.cpp"],
-  "file": "src/resume.cpp"
-},
-{
-  "directory": "/doc/work/WUR/data/APPLEMATURITY/maturity",
-  "arguments": ["/usr/bin/gcc", "-c", "-m64", "-fvisibility=hidden", "-fvisibility-inlines-hidden", "-O3", "-std=c++2a", "-I/usr/include", "-I/usr/local/include", "-DNDEBUG", "-o", "build/.objs/dipper/linux/x86_64/release/src/dipper.cpp.o", "src/dipper.cpp"],
-  "file": "src/dipper.cpp"
-}]

.vscode/launch.json

 {
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
         {
-            "configuration": {
-                "type": "object",
-                "title": "XMake configuration",
-                "properties": {
-                    "xmake.executable": {
-                        "type": "string",
-                        "default": "xmake",
-                        "description": "The xmake executable name / path"
-                    },
-                    "xmake.logLevel": {
-                        "type": "string",
-                        "default": "normal",
-                        "description": "The Log Level: normal/verbose/minimal",
-                        "enum": [
-                            "verbose",
-                            "normal",
-                            "minimal"
-                        ]
-                    },
-                    "xmake.buildLevel": {
-                        "type": "string",
-                        "default": "normal",
-                        "description": "The Build Output Level: normal/verbose/warning/debug",
-                        "enum": [
-                            "verbose",
-                            "normal",
-                            "warning",
-                            "debug"
-                        ]
-                    },
-                    "xmake.buildDirectory": {
-                        "type": "string",
-                        "default": "${workspaceRoot}/build",
-                        "description": "The Build Output Directory"
-                    },
-                    "xmake.installDirectory": {
-                        "type": "string",
-                        "default": "",
-                        "description": "The Install Output Directory"
-                    },
-                    "xmake.packageDirectory": {
-                        "type": "string",
-                        "default": "",
-                        "description": "The Package Output Directory"
-                    },
-                    "xmake.workingDirectory": {
-                        "type": "string",
-                        "default": "${workspaceRoot}",
-                        "description": "The Project Working Directory with the root xmake.lua"
-                    },
-                    "xmake.androidNDKDirectory": {
-                        "type": "string",
-                        "default": "",
-                        "description": "The Android NDK Directory"
-                    }
-                }
-            }
-        }
+            "type": "lldb",
+            "request": "launch",
+            "name": "codelldb",
+            "program": "${workspaceFolder}/build/linux/x86_64/debug/${fileBasenameNoExtension}",
+            "args": [
+                "/home/bresilla/sync/Test54_Image_07.jpg", 
+                "/home/bresilla/down/one.jpg", 
+                "3"
+            ],
+            "cwd": "${workspaceFolder}",
+            // "preLaunchTask": "XMAKE"
+        },
     ]
 }
\ No newline at end of file

.vscode/settings.json

+{
+    "C_Cpp.errorSquiggles": "disabled"
+}
\ No newline at end of file

.vscode/tasks.json

+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "type": "shell",
+            "label": "XMAKE",
+            "command": "xmake -w && xmake project -k compile_commands",
+            "group": "build",
+            "presentation": {
+                "reveal": "silent",
+                "close": true
+            }
+        }
+    ]
+}

CMakeLists.txt

+# this is the build file for project 
+# it is autogenerated by the xmake build system.
+# do not edit by hand.
+
+# project
+cmake_minimum_required(VERSION 3.15.0)
+cmake_policy(SET CMP0091 NEW)
+project(dipper LANGUAGES CXX C)
+
+# target
+add_executable(dipper "")
+set_target_properties(dipper PROPERTIES OUTPUT_NAME "dipper")
+set_target_properties(dipper PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/build/linux/x86_64/release")
+target_include_directories(dipper PRIVATE
+    /usr/include
+    /usr/local/include
+)
+target_compile_options(dipper PRIVATE
+    $<$<COMPILE_LANGUAGE:C>:-m64>
+    $<$<COMPILE_LANGUAGE:CXX>:-m64>
+    $<$<COMPILE_LANGUAGE:C>:-DNDEBUG>
+    $<$<COMPILE_LANGUAGE:CXX>:-DNDEBUG>
+)
+set_target_properties(dipper PROPERTIES CXX_EXTENSIONS OFF)
+target_compile_features(dipper PRIVATE cxx_std_20)
+if(MSVC)
+    target_compile_options(dipper PRIVATE $<$<CONFIG:Release>:-Ox -fp:fast>)
+else()
+    target_compile_options(dipper PRIVATE -O3)
+endif()
+if(MSVC)
+else()
+    target_compile_options(dipper PRIVATE -fvisibility=hidden)
+endif()
+if(MSVC)
+    set_property(TARGET dipper PROPERTY
+        MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+endif()
+target_link_libraries(dipper PRIVATE
+    fmt
+    DIP
+)
+target_link_directories(dipper PRIVATE
+    /usr/local/lib
+    /usr/lib
+)
+target_link_options(dipper PRIVATE
+    -m64
+)
+target_sources(dipper PRIVATE
+    src/dipper.cpp
+)
+
+# target
+add_executable(resume "")
+set_target_properties(resume PROPERTIES OUTPUT_NAME "resume")
+set_target_properties(resume PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/build/linux/x86_64/release")
+target_include_directories(resume PRIVATE
+    /usr/include
+    /usr/local/include
+)
+target_include_directories(resume PRIVATE
+    /usr/include/opencv4
+)
+target_compile_options(resume PRIVATE
+    $<$<COMPILE_LANGUAGE:C>:-m64>
+    $<$<COMPILE_LANGUAGE:CXX>:-m64>
+    $<$<COMPILE_LANGUAGE:C>:-DNDEBUG>
+    $<$<COMPILE_LANGUAGE:CXX>:-DNDEBUG>
+)
+set_target_properties(resume PROPERTIES CXX_EXTENSIONS OFF)
+target_compile_features(resume PRIVATE cxx_std_20)
+if(MSVC)
+    target_compile_options(resume PRIVATE $<$<CONFIG:Release>:-Ox -fp:fast>)
+else()
+    target_compile_options(resume PRIVATE -O3)
+endif()
+if(MSVC)
+else()
+    target_compile_options(resume PRIVATE -fvisibility=hidden)
+endif()
+if(MSVC)
+    set_property(TARGET resume PROPERTY
+        MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+endif()
+target_link_libraries(resume PRIVATE
+    opencv_stitching
+    opencv_aruco
+    opencv_bgsegm
+    opencv_bioinspired
+    opencv_ccalib
+    opencv_dnn_objdetect
+    opencv_dnn_superres
+    opencv_dpm
+    opencv_highgui
+    opencv_face
+    opencv_freetype
+    opencv_fuzzy
+    opencv_hdf
+    opencv_hfs
+    opencv_img_hash
+    opencv_line_descriptor
+    opencv_quality
+    opencv_reg
+    opencv_rgbd
+    opencv_saliency
+    opencv_shape
+    opencv_stereo
+    opencv_structured_light
+    opencv_phase_unwrapping
+    opencv_superres
+    opencv_optflow
+    opencv_surface_matching
+    opencv_tracking
+    opencv_datasets
+    opencv_text
+    opencv_dnn
+    opencv_plot
+    opencv_ml
+    opencv_videostab
+    opencv_videoio
+    opencv_viz
+    opencv_ximgproc
+    opencv_video
+    opencv_xobjdetect
+    opencv_objdetect
+    opencv_calib3d
+    opencv_imgcodecs
+    opencv_features2d
+    opencv_flann
+    opencv_xphoto
+    opencv_photo
+    opencv_imgproc
+    opencv_core
+    fmt
+)
+target_link_directories(resume PRIVATE
+    /usr/local/lib
+    /usr/lib
+)
+target_link_options(resume PRIVATE
+    -m64
+)
+target_sources(resume PRIVATE
+    src/resume.cpp
+)
+

compile_commands.json

 [
 {
   "directory": "/doc/work/WUR/data/APPLEMATURITY/maturity",
-  "arguments": ["/usr/bin/gcc", "-c", "-m64", "-fvisibility=hidden", "-fvisibility-inlines-hidden", "-O3", "-std=c++2a", "-I/usr/include", "-I/usr/local/include", "-I", "/usr/include/opencv4", "-DNDEBUG", "-o", "build/.objs/resume/linux/x86_64/release/src/resume.cpp.o", "src/resume.cpp"],
-  "file": "src/resume.cpp"
+  "arguments": ["/usr/bin/gcc", "-c", "-m64", "-g", "-O3", "-std=c++20", "-I", "/usr/include/opencv4", "-fno-strict-aliasing", "-DDEBUG", "-o", "build/.objs/classy/linux/x86_64/debug/src/ColorSpace.cpp.o", "src/ColorSpace.cpp"],
+  "file": "src/ColorSpace.cpp"
 },
 {
   "directory": "/doc/work/WUR/data/APPLEMATURITY/maturity",
-  "arguments": ["/usr/bin/gcc", "-c", "-m64", "-fvisibility=hidden", "-fvisibility-inlines-hidden", "-O3", "-std=c++2a", "-I/usr/include", "-I/usr/local/include", "-DNDEBUG", "-o", "build/.objs/dipper/linux/x86_64/release/src/dipper.cpp.o", "src/dipper.cpp"],
-  "file": "src/dipper.cpp"
+  "arguments": ["/usr/bin/gcc", "-c", "-m64", "-g", "-O3", "-std=c++20", "-I", "/usr/include/opencv4", "-fno-strict-aliasing", "-DDEBUG", "-o", "build/.objs/classy/linux/x86_64/debug/src/Comparison.cpp.o", "src/Comparison.cpp"],
+  "file": "src/Comparison.cpp"
+},
+{
+  "directory": "/doc/work/WUR/data/APPLEMATURITY/maturity",
+  "arguments": ["/usr/bin/gcc", "-c", "-m64", "-g", "-O3", "-std=c++20", "-I", "/usr/include/opencv4", "-fno-strict-aliasing", "-DDEBUG", "-o", "build/.objs/classy/linux/x86_64/debug/src/Conversion.cpp.o", "src/Conversion.cpp"],
+  "file": "src/Conversion.cpp"
+},
+{
+  "directory": "/doc/work/WUR/data/APPLEMATURITY/maturity",
+  "arguments": ["/usr/bin/gcc", "-c", "-m64", "-g", "-O3", "-std=c++20", "-I", "/usr/include/opencv4", "-fno-strict-aliasing", "-DDEBUG", "-o", "build/.objs/classy/linux/x86_64/debug/src/classy.cpp.o", "src/classy.cpp"],
+  "file": "src/classy.cpp"
 }]

src/ColorSpace.cpp

+#include "ColorSpace.h"
+#include "Conversion.h"
+
+namespace ColorSpace {
+    Rgb::Rgb() {}
+    Rgb::Rgb(double r, double g, double b) : r(r), g(g), b(b) {}
+    void Rgb::Initialize(Rgb *color) { RgbConverter::ToColorSpace(color, this); }
+    void Rgb::ToRgb(Rgb *color) { RgbConverter::ToColor(color, this); }
+    void Rgb::Copy(IColorSpace *color) {
+        Rgb *rgb = static_cast<Rgb *>(color);
+        rgb->r = r;
+        rgb->g = g;
+        rgb->b = b;
+    }
+
+    Xyz::Xyz() {}
+    Xyz::Xyz(double x, double y, double z) : x(x), y(y), z(z) {}
+    void Xyz::Initialize(Rgb *color) { XyzConverter::ToColorSpace(color, this); }
+    void Xyz::ToRgb(Rgb *color) { XyzConverter::ToColor(color, this); }
+    void Xyz::Copy(IColorSpace *color) {
+        Xyz *xyz = static_cast<Xyz *>(color);
+        xyz->x = x;
+        xyz->y = y;
+        xyz->z = z;
+    }
+
+    Hsl::Hsl() {}
+    Hsl::Hsl(double h, double s, double l) : h(h), s(s), l(l) {}
+    void Hsl::Initialize(Rgb *color) { HslConverter::ToColorSpace(color, this); }
+    void Hsl::ToRgb(Rgb *color) { HslConverter::ToColor(color, this); }
+    void Hsl::Copy(IColorSpace *color) {
+        Hsl *hsl = static_cast<Hsl *>(color);
+        hsl->h = h;
+        hsl->s = s;
+        hsl->l = l;
+    }
+
+    Lab::Lab() {}
+    Lab::Lab(double l, double a, double b) : l(l), a(a), b(b) {}
+    void Lab::Initialize(Rgb *color) { LabConverter::ToColorSpace(color, this); }
+    void Lab::ToRgb(Rgb *color) { LabConverter::ToColor(color, this); }
+    void Lab::Copy(IColorSpace *color) {
+        Lab *lab = static_cast<Lab *>(color);
+        lab->l = l;
+        lab->a = a;
+        lab->b = b;
+    }
+
+    Lch::Lch() {}
+    Lch::Lch(double l, double c, double h) : l(l), c(c), h(h) {}
+    void Lch::Initialize(Rgb *color) { LchConverter::ToColorSpace(color, this); }
+    void Lch::ToRgb(Rgb *color) { LchConverter::ToColor(color, this); }
+    void Lch::Copy(IColorSpace *color) {
+        Lch *lch = static_cast<Lch *>(color);
+        lch->l = l;
+        lch->c = c;
+        lch->h = h;
+    }
+
+    Luv::Luv() {}
+    Luv::Luv(double l, double u, double v) : l(l), u(u), v(v) {}
+    void Luv::Initialize(Rgb *color) { LuvConverter::ToColorSpace(color, this); }
+    void Luv::ToRgb(Rgb *color) { LuvConverter::ToColor(color, this); }
+    void Luv::Copy(IColorSpace *color) {
+        Luv *luv = static_cast<Luv *>(color);
+        luv->l = l;
+        luv->u = u;
+        luv->v = v;
+    }
+
+    Yxy::Yxy() {}
+    Yxy::Yxy(double y1, double x, double y2) : y1(y1), x(x), y2(y2) {}
+    void Yxy::Initialize(Rgb *color) { YxyConverter::ToColorSpace(color, this); }
+    void Yxy::ToRgb(Rgb *color) { YxyConverter::ToColor(color, this); }
+    void Yxy::Copy(IColorSpace *color) {
+        Yxy *yxy = static_cast<Yxy *>(color);
+        yxy->y1 = y1;
+        yxy->x = x;
+        yxy->y2 = y2;
+    }
+
+    Cmy::Cmy() {}
+    Cmy::Cmy(double c, double m, double y) : c(c), m(m), y(y) {}
+    void Cmy::Initialize(Rgb *color) { CmyConverter::ToColorSpace(color, this); }
+    void Cmy::ToRgb(Rgb *color) { CmyConverter::ToColor(color, this); }
+    void Cmy::Copy(IColorSpace *color) {
+        Cmy *cmy = static_cast<Cmy *>(color);
+        cmy->c = c;
+        cmy->m = m;
+        cmy->y = y;
+    }
+
+    Cmyk::Cmyk() {}
+    Cmyk::Cmyk(double c, double m, double y, double k) : c(c), m(m), y(y), k(k) {}
+    void Cmyk::Initialize(Rgb *color) { CmykConverter::ToColorSpace(color, this); }
+    void Cmyk::ToRgb(Rgb *color) { CmykConverter::ToColor(color, this); }
+    void Cmyk::Copy(IColorSpace *color) {
+        Cmyk *cmyk = static_cast<Cmyk *>(color);
+        cmyk->c = c;
+        cmyk->m = m;
+        cmyk->y = y;
+        cmyk->k = k;
+    }
+
+    Hsv::Hsv() {}
+    Hsv::Hsv(double h, double s, double v) : h(h), s(s), v(v) {}
+    void Hsv::Initialize(Rgb *color) { HsvConverter::ToColorSpace(color, this); }
+    void Hsv::ToRgb(Rgb *color) { HsvConverter::ToColor(color, this); }
+    void Hsv::Copy(IColorSpace *color) {
+        Hsv *hsv = static_cast<Hsv *>(color);
+        hsv->h = h;
+        hsv->s = s;
+        hsv->v = v;
+    }
+
+    Hsb::Hsb() {}
+    Hsb::Hsb(double h, double s, double b) : h(h), s(s), b(b) {}
+    void Hsb::Initialize(Rgb *color) { HsbConverter::ToColorSpace(color, this); }
+    void Hsb::ToRgb(Rgb *color) { HsbConverter::ToColor(color, this); }
+    void Hsb::Copy(IColorSpace *color) {
+        Hsb *hsb = static_cast<Hsb *>(color);
+        hsb->h = h;
+        hsb->s = s;
+        hsb->b = b;
+    }
+
+    HunterLab::HunterLab() {}
+    HunterLab::HunterLab(double l, double a, double b) : l(l), a(a), b(b) {}
+    void HunterLab::Initialize(Rgb *color) { HunterLabConverter::ToColorSpace(color, this); }
+    void HunterLab::ToRgb(Rgb *color) { HunterLabConverter::ToColor(color, this); }
+    void HunterLab::Copy(IColorSpace *color) {
+        HunterLab *lab = static_cast<HunterLab *>(color);
+        lab->l = l;
+        lab->a = a;
+        lab->b = b;
+    }
+} // namespace ColorSpace

src/ColorSpace.h

+#ifndef COLOR_SPACE_H
+#define COLOR_SPACE_H
+
+#include "Conversion.h"
+#include <typeinfo>
+
+namespace ColorSpace {
+    struct IColorSpace {
+        IColorSpace() {}
+        virtual ~IColorSpace() {}
+
+        virtual void Initialize(Rgb *color) = 0;
+        virtual void ToRgb(Rgb *color) = 0;
+        virtual void Copy(IColorSpace *color) = 0;
+
+        template <typename TColorSpace> void To(TColorSpace *color);
+    };
+
+    struct Rgb : public IColorSpace {
+        double r, g, b;
+
+        Rgb();
+        Rgb(double r, double g, double b);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Xyz : public IColorSpace {
+        double x, y, z;
+
+        Xyz();
+        Xyz(double x, double y, double z);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Hsl : public IColorSpace {
+        double h, s, l;
+
+        Hsl();
+        Hsl(double h, double s, double l);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Lab : public IColorSpace {
+        double l, a, b;
+
+        Lab();
+        Lab(double l, double a, double b);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Lch : public IColorSpace {
+        double l, c, h;
+
+        Lch();
+        Lch(double l, double c, double h);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Luv : public IColorSpace {
+        double l, u, v;
+
+        Luv();
+        Luv(double l, double u, double v);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Yxy : public IColorSpace {
+        double y1, x, y2;
+
+        Yxy();
+        Yxy(double y1, double x, double y2);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Cmy : public IColorSpace {
+        double c, m, y;
+
+        Cmy();
+        Cmy(double c, double m, double y);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Cmyk : public IColorSpace {
+        double c, m, y, k;
+
+        Cmyk();
+        Cmyk(double c, double m, double y, double k);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Hsv : public IColorSpace {
+        double h, s, v;
+
+        Hsv();
+        Hsv(double h, double s, double v);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct Hsb : public IColorSpace {
+        double h, s, b;
+
+        Hsb();
+        Hsb(double h, double s, double b);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    struct HunterLab : public IColorSpace {
+        double l, a, b;
+
+        HunterLab();
+        HunterLab(double l, double a, double b);
+
+        virtual void Initialize(Rgb *color);
+        virtual void ToRgb(Rgb *color);
+        virtual void Copy(IColorSpace *color);
+    };
+
+    template <typename TColorSpace> void IColorSpace::To(TColorSpace *color) {
+        Rgb rgb;
+
+        if (typeid(*this) == typeid(*color)) {
+            this->Copy(color);
+        } else {
+            this->ToRgb(&rgb);
+            IConverter<TColorSpace>::ToColorSpace(&rgb, color);
+        }
+    }
+
+} // namespace ColorSpace
+
+#endif // COLOR_SPACE_H

src/Comparison.cpp

+#include "Comparison.h"
+#include <cmath>
+
+#define M_PI 3.141592653589793238462643383279502884L
+#define SQR(x) ((x) * (x))
+#define POW2(x) SQR(x)
+#define POW3(x) ((x) * (x) * (x))
+#define POW4(x) (POW2(x) * POW2(x))
+#define POW7(x) (POW3(x) * POW3(x) * (x))
+#define DegToRad(x) ((x)*M_PI / 180)
+#define RadToDeg(x) ((x) / M_PI * 180)
+
+namespace ColorSpace {
+    double EuclideanComparison::Compare(IColorSpace *a, IColorSpace *b) {
+        Rgb rgb_a;
+        Rgb rgb_b;
+
+        a->ToRgb(&rgb_a);
+        b->ToRgb(&rgb_b);
+
+        return sqrt(SQR(rgb_a.r - rgb_b.r) + SQR(rgb_a.g - rgb_b.g) + SQR(rgb_a.b - rgb_b.b));
+    }
+
+    double Cie1976Comparison::Compare(IColorSpace *a, IColorSpace *b) {
+        Lab lab_a;
+        Lab lab_b;
+
+        a->To<Lab>(&lab_a);
+        b->To<Lab>(&lab_b);
+
+        return sqrt(SQR(lab_a.l - lab_b.l) + SQR(lab_a.a - lab_b.a) + SQR(lab_a.b - lab_b.b));
+    }
+
+    Cie94Comparison::Application::Application(Cie94Comparison::APPLICATION appType) {
+        switch (appType) {
+        case GRAPHIC_ARTS:
+            kl = 1.0;
+            k1 = 0.045;
+            k2 = 0.015;
+            break;
+        case TEXTILES:
+            kl = 2.0;
+            k1 = 0.048;
+            k2 = 0.014;
+            break;
+        }
+    }
+
+    double Cie94Comparison::Compare(IColorSpace *a, IColorSpace *b, APPLICATION appType) {
+        Application app(appType);
+        Lab lab_a;
+        Lab lab_b;
+
+        a->To<Lab>(&lab_a);
+        b->To<Lab>(&lab_b);
+
+        double deltaL = lab_a.l - lab_b.l;
+        double deltaA = lab_a.a - lab_b.a;
+        double deltaB = lab_a.b - lab_b.b;
+
+        double c1 = sqrt(SQR(lab_a.a) + SQR(lab_a.b));
+        double c2 = sqrt(SQR(lab_b.a) + SQR(lab_b.b));
+        double deltaC = c1 - c2;
+
+        double deltaH = SQR(deltaA) + SQR(deltaB) - SQR(deltaC);
+
+        double sl = 1.0;
+        double sc = 1.0 + app.k1 * c1;
+        double sh = 1.0 + app.k2 * c1;
+
+        deltaL /= app.kl * sl;
+        deltaC /= sc;
+
+        return sqrt(SQR(deltaL) + SQR(deltaC) + deltaH / SQR(sh));
+    }
+
+    double Cie2000Comparison::Compare(IColorSpace *a, IColorSpace *b) {
+        const double eps = 1e-5;
+        Lab lab_a;
+        Lab lab_b;
+
+        a->To<Lab>(&lab_a);
+        b->To<Lab>(&lab_b);
+
+        // calculate ci, hi, i=1,2
+        double c1 = sqrt(SQR(lab_a.a) + SQR(lab_a.b));
+        double c2 = sqrt(SQR(lab_b.a) + SQR(lab_b.b));
+        double meanC = (c1 + c2) / 2.0;
+        double meanC7 = POW7(meanC);
+
+        double g = 0.5 * (1 - sqrt(meanC7 / (meanC7 + 6103515625.))); // 0.5*(1-sqrt(meanC^7/(meanC^7+25^7)))
+        double a1p = lab_a.a * (1 + g);
+        double a2p = lab_b.a * (1 + g);
+
+        c1 = sqrt(SQR(a1p) + SQR(lab_a.b));
+        c2 = sqrt(SQR(a2p) + SQR(lab_b.b));
+        double h1 = fmod(atan2(lab_a.b, a1p) + 2 * M_PI, 2 * M_PI);
+        double h2 = fmod(atan2(lab_b.b, a2p) + 2 * M_PI, 2 * M_PI);
+
+        // compute deltaL, deltaC, deltaH
+        double deltaL = lab_b.l - lab_a.l;
+        double deltaC = c2 - c1;
+        double deltah;
+
+        if (c1 * c2 < eps) {
+            deltah = 0;
+        }
+        if (std::abs(h2 - h1) <= M_PI) {
+            deltah = h2 - h1;
+        } else if (h2 > h1) {
+            deltah = h2 - h1 - 2 * M_PI;
+        } else {
+            deltah = h2 - h1 + 2 * M_PI;
+        }
+
+        double deltaH = 2 * sqrt(c1 * c2) * sin(deltah / 2);
+
+        // calculate CIEDE2000
+        double meanL = (lab_a.l + lab_b.l) / 2;
+        meanC = (c1 + c2) / 2.0;
+        meanC7 = POW7(meanC);
+        double meanH;
+
+        if (c1 * c2 < eps) {
+            meanH = h1 + h2;
+        }
+        if (std::abs(h1 - h2) <= M_PI + eps) {
+            meanH = (h1 + h2) / 2;
+        } else if (h1 + h2 < 2 * M_PI) {
+            meanH = (h1 + h2 + 2 * M_PI) / 2;
+        } else {
+            meanH = (h1 + h2 - 2 * M_PI) / 2;
+        }
+
+        double T = 1 - 0.17 * cos(meanH - DegToRad(30)) + 0.24 * cos(2 * meanH) + 0.32 * cos(3 * meanH + DegToRad(6)) -
+                   0.2 * cos(4 * meanH - DegToRad(63));
+        double sl = 1 + (0.015 * SQR(meanL - 50)) / sqrt(20 + SQR(meanL - 50));
+        double sc = 1 + 0.045 * meanC;
+        double sh = 1 + 0.015 * meanC * T;
+        double rc = 2 * sqrt(meanC7 / (meanC7 + 6103515625.));
+        double rt = -sin(DegToRad(60 * exp(-SQR((RadToDeg(meanH) - 275) / 25)))) * rc;
+
+        return sqrt(SQR(deltaL / sl) + SQR(deltaC / sc) + SQR(deltaH / sh) + rt * deltaC / sc * deltaH / sh);
+    }
+
+    const double CmcComparison::defaultLightness = 2.;
+    const double CmcComparison::defaultChroma = 1.;
+    double CmcComparison::Compare(IColorSpace *a, IColorSpace *b) {
+        Lch lch_a;
+        Lch lch_b;
+
+        a->To<Lch>(&lch_a);
+        b->To<Lch>(&lch_b);
+
+        double deltaL = lch_a.l - lch_b.l;
+        double deltaC = lch_a.c - lch_b.c;
+        double deltaH = 0;
+
+        double f = sqrt(POW4(lch_a.c) / (POW4(lch_a.c) + 1900));
+        double t = (164 <= lch_a.h && lch_a.h <= 345) ? (0.56 + std::abs(0.2 * cos(lch_a.h + 168)))
+                                                      : (0.36 + std::abs(0.4 * cos(lch_a.h + 35)));
+
+        double sl = (lch_a.l < 16) ? 0.511 : (0.040975 * lch_a.l / (1 + 0.01765 * lch_a.l));
+        double sc = 0.0638 * lch_a.c / (1 + 0.0131 * lch_a.c) + 0.638;
+        double sh = sc * (f * t + 1 - f);
+
+        return sqrt(SQR(deltaL / (defaultLightness * sl)) + SQR(deltaC / (defaultChroma * sc)) + SQR(deltaH / sh));
+    }
+} // namespace ColorSpace

src/Comparison.h

+#ifndef COMPARISON_H
+#define COMPARISON_H
+
+#include "ColorSpace.h"
+
+namespace ColorSpace {
+    struct EuclideanComparison {
+        static double Compare(IColorSpace *a, IColorSpace *b);
+    };
+
+    struct Cie1976Comparison {
+        static double Compare(IColorSpace *a, IColorSpace *b);
+    };
+
+    struct Cie94Comparison {
+        enum APPLICATION { GRAPHIC_ARTS = 0, TEXTILES };
+
+        struct Application {
+            double kl, k1, k2;
+            Application(APPLICATION appType);
+        };
+
+        static double Compare(IColorSpace *a, IColorSpace *b, APPLICATION appType = GRAPHIC_ARTS);
+    };
+
+    struct Cie2000Comparison {
+        static double Compare(IColorSpace *a, IColorSpace *b);
+    };
+
+    struct CmcComparison {
+        static const double defaultLightness;
+        static const double defaultChroma;
+        static double Compare(IColorSpace *a, IColorSpace *b);
+    };
+} // namespace ColorSpace
+
+#endif // COMPARISON_H

src/Conversion.cpp

+#include "Conversion.h"
+#include "ColorSpace.h"
+#define _USE_MATH_DEFINES
+#include <algorithm>
+#include <cmath>
+
+#define M_PI 3.141592653589793238462643383279502884L
+#define SQR(x) ((x) * (x))
+#define POW2(x) SQR(x)
+#define POW3(x) ((x) * (x) * (x))
+#define POW4(x) (POW2(x) * POW2(x))
+#define POW7(x) (POW3(x) * POW3(x) * (x))
+#define DegToRad(x) ((x)*M_PI / 180)
+#define RadToDeg(x) ((x) / M_PI * 180)
+
+namespace ColorSpace {
+    double Hue_2_RGB(double v1, double v2, double vh) {
+        if (vh < 0)
+            vh += 1;
+        if (vh > 1)
+            vh -= 1;
+        if (6 * vh < 1)
+            return v1 + (v2 - v1) * 6 * vh;
+        if (2 * vh < 1)
+            return v2;
+        if (3 * vh < 2)
+            return v1 + (v2 - v1) * (2.0 / 3.0 - vh) * 6;
+        return v1;
+    }
+
+    void RgbConverter::ToColorSpace(Rgb *color, Rgb *item) {
+        item->r = color->r;
+        item->g = color->g;
+        item->b = color->b;
+    }
+    void RgbConverter::ToColor(Rgb *color, Rgb *item) {
+        color->r = item->r;
+        color->g = item->g;
+        color->b = item->b;
+    }
+
+    void XyzConverter::ToColorSpace(Rgb *color, Xyz *item) {
+        double r = color->r / 255.0;
+        double g = color->g / 255.0;
+        double b = color->b / 255.0;
+
+        r = ((r > 0.04045) ? pow((r + 0.055) / 1.055, 2.4) : (r / 12.92)) * 100.0;
+        g = ((g > 0.04045) ? pow((g + 0.055) / 1.055, 2.4) : (g / 12.92)) * 100.0;
+        b = ((b > 0.04045) ? pow((b + 0.055) / 1.055, 2.4) : (b / 12.92)) * 100.0;
+
+        item->x = r * 0.4124564 + g * 0.3575761 + b * 0.1804375;
+        item->y = r * 0.2126729 + g * 0.7151522 + b * 0.0721750;
+        item->z = r * 0.0193339 + g * 0.1191920 + b * 0.9503041;
+    }
+    void XyzConverter::ToColor(Rgb *color, Xyz *item) {
+        double x = item->x / 100.0;
+        double y = item->y / 100.0;
+        double z = item->z / 100.0;
+
+        double r = x * 3.2404542 + y * -1.5371385 + z * -0.4985314;
+        double g = x * -0.9692660 + y * 1.8760108 + z * 0.0415560;
+        double b = x * 0.0556434 + y * -0.2040259 + z * 1.0572252;
+
+        r = ((r > 0.0031308) ? (1.055 * pow(r, 1 / 2.4) - 0.055) : (12.92 * r)) * 255.0;
+        g = ((g > 0.0031308) ? (1.055 * pow(g, 1 / 2.4) - 0.055) : (12.92 * g)) * 255.0;
+        b = ((b > 0.0031308) ? (1.055 * pow(b, 1 / 2.4) - 0.055) : (12.92 * b)) * 255.0;
+
+        color->r = r;
+        color->g = g;
+        color->b = b;
+    }
+    const double XyzConverter::eps = 216.0 / 24389.0;
+    const double XyzConverter::kappa = 24389.0 / 27.0;
+    const Xyz XyzConverter::whiteReference(95.047, 100.000, 108.883);
+
+    void HslConverter::ToColorSpace(Rgb *color, Hsl *item) {
+        double r = color->r / 255.0;
+        double g = color->g / 255.0;
+        double b = color->b / 255.0;
+
+        double min = std::min(r, std::min(g, b));
+        double max = std::max(r, std::max(g, b));
+        double delta = max - min;
+
+        item->l = (max + min) / 2;
+        if (delta == 0) {
+            item->h = item->s = 0;
+        } else {
+            if (item->l < 0.5) {
+                item->s = delta / (max + min) * 100;
+            } else {
+                item->s = delta / (1 - std::abs(2 * item->l - 1)) * 100;
+            }
+
+            if (r == max) {
+                item->h = (g - b) / delta;
+            } else if (g == max) {
+                item->h = (b - r) / delta + 2;
+            } else if (b == max) {
+                item->h = (r - g) / delta + 4;
+            }
+            item->h = fmod(60 * item->h + 360, 360);
+        }
+        item->l *= 100;
+    }
+    void HslConverter::ToColor(Rgb *color, Hsl *item) {
+        double h = item->h / 360;
+        double s = item->s / 100;
+        double l = item->l / 100;
+
+        if (item->s == 0) {
+            color->r = color->g = color->b = item->l * 255;
+        } else {
+            double temp1, temp2;
+
+            temp2 = (l < 0.5) ? (l * (1 + s)) : (l + s - (s * l));
+            temp1 = 2 * l - temp2;
+
+            color->r = 255 * Hue_2_RGB(temp1, temp2, h + 1.0 / 3.0);
+            color->g = 255 * Hue_2_RGB(temp1, temp2, h);
+            color->b = 255 * Hue_2_RGB(temp1, temp2, h - 1.0 / 3.0);
+        }
+    }
+
+    void LabConverter::ToColorSpace(Rgb *color, Lab *item) {
+        Xyz xyz;
+
+        XyzConverter::ToColorSpace(color, &xyz);
+
+        double x = xyz.x / 95.047;
+        double y = xyz.y / 100.00;
+        double z = xyz.z / 108.883;
+
+        x = (x > 0.008856) ? cbrt(x) : (7.787 * x + 16.0 / 116.0);
+        y = (y > 0.008856) ? cbrt(y) : (7.787 * y + 16.0 / 116.0);
+        z = (z > 0.008856) ? cbrt(z) : (7.787 * z + 16.0 / 116.0);
+
+        item->l = (116.0 * y) - 16;
+        item->a = 500 * (x - y);
+        item->b = 200 * (y - z);
+    }
+    void LabConverter::ToColor(Rgb *color, Lab *item) {
+        double y = (item->l + 16.0) / 116.0;
+        double x = item->a / 500.0 + y;
+        double z = y - item->b / 200.0;
+
+        double x3 = POW3(x);
+        double y3 = POW3(y);
+        double z3 = POW3(z);
+
+        x = ((x3 > 0.008856) ? x3 : ((x - 16.0 / 116.0) / 7.787)) * 95.047;
+        y = ((y3 > 0.008856) ? y3 : ((y - 16.0 / 116.0) / 7.787)) * 100.0;
+        z = ((z3 > 0.008856) ? z3 : ((z - 16.0 / 116.0) / 7.787)) * 108.883;
+
+        Xyz xyz(x, y, z);
+        XyzConverter::ToColor(color, &xyz);
+    }
+
+    void LchConverter::ToColorSpace(Rgb *color, Lch *item) {
+        Lab lab;
+
+        LabConverter::ToColorSpace(color, &lab);
+        double l = lab.l;
+        double c = sqrt(lab.a * lab.a + lab.b * lab.b);
+        double h = atan2(lab.b, lab.a);
+
+        h = h / M_PI * 180;
+        if (h < 0) {
+            h += 360;
+        } else if (h >= 360) {
+            h -= 360;
+        }
+
+        item->l = l;
+        item->c = c;
+        item->h = h;
+    }
+    void LchConverter::ToColor(Rgb *color, Lch *item) {
+        Lab lab;
+
+        item->h = item->h * M_PI / 180;
+
+        lab.l = item->l;
+        lab.a = cos(item->h) * item->c;
+        lab.b = sin(item->h) * item->c;
+
+        LabConverter::ToColor(color, &lab);
+    }
+
+    void LuvConverter::ToColorSpace(Rgb *color, Luv *item) {
+        const Xyz &white = XyzConverter::whiteReference;
+        Xyz xyz;
+
+        XyzConverter::ToColorSpace(color, &xyz);
+        double y = xyz.y / white.y;
+        double temp = (xyz.x + 15 * xyz.y + 3 * xyz.z);
+        double tempr = (white.x + 15 * white.y + 3 * white.z);
+
+        item->l = (y > XyzConverter::eps) ? (116 * cbrt(y) - 16) : (XyzConverter::kappa * y);
+        item->u = 52 * item->l * (((temp > 1e-3) ? (xyz.x / temp) : 0) - white.x / tempr);
+        item->v = 117 * item->l * (((temp > 1e-3) ? (xyz.y / temp) : 0) - white.y / tempr);
+    }
+    void LuvConverter::ToColor(Rgb *color, Luv *item) {
+        const Xyz &white = XyzConverter::whiteReference;
+        Xyz xyz;
+
+        double y = (item->l > XyzConverter::eps * XyzConverter::kappa) ? POW3((item->l + 16) / 116)
+                                                                       : (item->l / XyzConverter::kappa);
+        double tempr = white.x + 15 * white.y + 3 * white.z;
+        double up = 4 * white.x / tempr;
+        double vp = 9 * white.y / tempr;
+
+        double a = 1. / 3. * (52 * item->l / (item->u + 13 * item->l * up) - 1);
+        double b = -5 * y;
+        double x = (y * (39 * item->l / (item->v + 13 * item->l * vp) - 5) - b) / (a + 1. / 3.);
+        double z = x * a + b;
+
+        xyz.x = x * 100;
+        xyz.y = y * 100;
+        xyz.z = z * 100;
+
+        XyzConverter::ToColor(color, &xyz);
+    }
+
+    void YxyConverter::ToColorSpace(Rgb *color, Yxy *item) {
+        Xyz xyz;
+
+        XyzConverter::ToColorSpace(color, &xyz);
+        double temp = xyz.x + xyz.y + xyz.z;
+        item->y1 = xyz.y;
+        item->x = (temp == 0) ? 0 : (xyz.x / temp);
+        item->y2 = (temp == 0) ? 0 : (xyz.y / temp);
+    }
+    void YxyConverter::ToColor(Rgb *color, Yxy *item) {
+        Xyz xyz;
+
+        xyz.x = item->x * (item->y1 / item->y2);
+        xyz.y = item->y1;
+        xyz.z = (1 - item->x - item->y2) * (item->y1 / item->y2);
+        XyzConverter::ToColor(color, &xyz);
+    }
+
+    void CmyConverter::ToColorSpace(Rgb *color, Cmy *item) {
+        item->c = 1 - color->r / 255;
+        item->m = 1 - color->g / 255;
+        item->y = 1 - color->b / 255;
+    }
+    void CmyConverter::ToColor(Rgb *color, Cmy *item) {
+        color->r = (1 - item->c) * 255;
+        color->g = (1 - item->m) * 255;
+        color->b = (1 - item->y) * 255;
+    }
+
+    void CmykConverter::ToColorSpace(Rgb *color, Cmyk *item) {
+        Cmy cmy;
+
+        CmyConverter::ToColorSpace(color, &cmy);
+        double k = 1.0;
+        k = std::min(k, cmy.c);
+        k = std::min(k, cmy.m);
+        k = std::min(k, cmy.y);
+
+        item->k = k;
+        if (std::abs(item->k - 1) < 1e-3) {
+            item->c = 0;
+            item->m = 0;
+            item->y = 0;
+        } else {
+            item->c = (cmy.c - k) / (1 - k);
+            item->m = (cmy.m - k) / (1 - k);
+            item->y = (cmy.y - k) / (1 - k);
+        }
+    }
+    void CmykConverter::ToColor(Rgb *color, Cmyk *item) {
+        Cmy cmy;
+
+        cmy.c = item->c * (1 - item->k) + item->k;
+        cmy.m = item->m * (1 - item->k) + item->k;
+        cmy.y = item->y * (1 - item->k) + item->k;
+        CmyConverter::ToColor(color, &cmy);
+    }
+
+    void HsvConverter::ToColorSpace(Rgb *color, Hsv *item) {
+        double r = color->r / 255.0;
+        double g = color->g / 255.0;
+        double b = color->b / 255.0;
+
+        double min = std::min(r, std::min(g, b));
+        double max = std::max(r, std::max(g, b));
+        double delta = max - min;
+
+        item->v = max;
+        item->s = (max > 1e-3) ? (delta / max) : 0;
+
+        if (delta == 0) {
+            item->h = 0;
+        } else {
+            if (r == max) {
+                item->h = (g - b) / delta;
+            } else if (g == max) {
+                item->h = 2 + (b - r) / delta;
+            } else if (b == max) {
+                item->h = 4 + (r - g) / delta;
+            }
+
+            item->h *= 60;
+            item->h = fmod(item->h + 360, 360);
+        }
+    }
+    void HsvConverter::ToColor(Rgb *color, Hsv *item) {
+        int range = (int)floor(item->h / 60);
+        double c = item->v * item->s;
+        double x = c * (1 - std::abs(fmod(item->h / 60, 2) - 1));
+        double m = item->v - c;
+
+        switch (range) {
+        case 0:
+            color->r = (c + m) * 255;
+            color->g = (x + m) * 255;
+            color->b = m * 255;
+            break;
+        case 1:
+            color->r = (x + m) * 255;
+            color->g = (c + m) * 255;
+            color->b = m * 255;
+            break;
+        case 2:
+            color->r = m * 255;
+            color->g = (c + m) * 255;
+            color->b = (x + m) * 255;
+            break;
+        case 3:
+            color->r = m * 255;
+            color->g = (x + m) * 255;
+            color->b = (c + m) * 255;
+            break;
+        case 4:
+            color->r = (x + m) * 255;
+            color->g = m * 255;
+            color->b = (c + m) * 255;
+            break;
+        default: // case 5:
+            color->r = (c + m) * 255;
+            color->g = m * 255;
+            color->b = (x + m) * 255;
+            break;
+        }
+    }
+
+    void HsbConverter::ToColorSpace(Rgb *color, Hsb *item) {
+        Hsv hsv;
+
+        HsvConverter::ToColorSpace(color, &hsv);
+        item->h = hsv.h;
+        item->s = hsv.s;
+        item->b = hsv.v;
+    }
+    void HsbConverter::ToColor(Rgb *color, Hsb *item) {
+        Hsv hsv;
+
+        hsv.h = item->h;
+        hsv.s = item->s;
+        hsv.v = item->b;
+        HsvConverter::ToColor(color, &hsv);
+    }
+
+    void HunterLabConverter::ToColorSpace(Rgb *color, HunterLab *item) {
+        Xyz xyz;
+
+        XyzConverter::ToColorSpace(color, &xyz);
+        item->l = 10.0 * sqrt(xyz.y);
+        item->a = (xyz.y != 0) ? (17.5 * (1.02 * xyz.x - xyz.y) / sqrt(xyz.y)) : 0;
+        item->b = (xyz.y != 0) ? (7.0 * (xyz.y - 0.847 * xyz.z) / sqrt(xyz.y)) : 0;
+    }
+    void HunterLabConverter::ToColor(Rgb *color, HunterLab *item) {
+        double x = (item->a / 17.5) * (item->l / 10.0);
+        double y = item->l * item->l / 100;
+        double z = item->b / 7.0 * item->l / 10.0;
+
+        Xyz xyz((x + y) / 1.02, y, -(z - y) / 0.847);
+        XyzConverter::ToColor(color, &xyz);
+    }
+} // namespace ColorSpace

src/Conversion.h

+#ifndef RGB_CONVERTER_H
+#define RGB_CONVERTER_H
+
+namespace ColorSpace {
+    struct Rgb;
+    struct Xyz;
+    struct Hsl;
+    struct Lab;
+    struct Lch;
+    struct Luv;
+    struct Yxy;
+    struct Cmy;
+    struct Cmyk;
+    struct Hsv;
+    struct Hsb;
+    struct HunterLab;
+
+    template <typename TColorSpace> struct IConverter {
+        static void ToColorSpace(Rgb *color, TColorSpace *item);
+        static void ToColor(Rgb *color, TColorSpace *item);
+    };
+
+    template <> struct IConverter<Rgb> {
+        static void ToColorSpace(Rgb *color, Rgb *item);
+        static void ToColor(Rgb *color, Rgb *item);
+    };
+    typedef IConverter<Rgb> RgbConverter;
+
+    template <> struct IConverter<Xyz> {
+        static void ToColorSpace(Rgb *color, Xyz *item);
+        static void ToColor(Rgb *color, Xyz *item);
+        static const double eps;
+        static const double kappa;
+        static const Xyz whiteReference;
+    };
+    typedef IConverter<Xyz> XyzConverter;
+
+    template <> struct IConverter<Hsl> {
+        static void ToColorSpace(Rgb *color, Hsl *item);
+        static void ToColor(Rgb *color, Hsl *item);
+    };
+    typedef IConverter<Hsl> HslConverter;
+
+    template <> struct IConverter<Lab> {
+        static void ToColorSpace(Rgb *color, Lab *item);
+        static void ToColor(Rgb *color, Lab *item);
+    };
+    typedef IConverter<Lab> LabConverter;
+
+    template <> struct IConverter<Lch> {
+        static void ToColorSpace(Rgb *color, Lch *item);
+        static void ToColor(Rgb *color, Lch *item);
+    };
+    typedef IConverter<Lch> LchConverter;
+
+    template <> struct IConverter<Luv> {
+        static void ToColorSpace(Rgb *color, Luv *item);
+        static void ToColor(Rgb *color, Luv *item);
+    };
+    typedef IConverter<Luv> LuvConverter;
+
+    template <> struct IConverter<Yxy> {
+        static void ToColorSpace(Rgb *color, Yxy *item);
+        static void ToColor(Rgb *color, Yxy *item);
+    };
+    typedef IConverter<Yxy> YxyConverter;
+
+    template <> struct IConverter<Cmy> {
+        static void ToColorSpace(Rgb *color, Cmy *item);
+        static void ToColor(Rgb *color, Cmy *item);
+    };
+    typedef IConverter<Cmy> CmyConverter;
+
+    template <> struct IConverter<Cmyk> {
+        static void ToColorSpace(Rgb *color, Cmyk *item);
+        static void ToColor(Rgb *color, Cmyk *item);
+    };
+    typedef IConverter<Cmyk> CmykConverter;
+
+    template <> struct IConverter<Hsv> {
+        static void ToColorSpace(Rgb *color, Hsv *item);
+        static void ToColor(Rgb *color, Hsv *item);
+    };
+    typedef IConverter<Hsv> HsvConverter;
+
+    template <> struct IConverter<Hsb> {
+        static void ToColorSpace(Rgb *color, Hsb *item);
+        static void ToColor(Rgb *color, Hsb *item);
+    };
+    typedef IConverter<Hsb> HsbConverter;
+
+    template <> struct IConverter<HunterLab> {
+        static void ToColorSpace(Rgb *color, HunterLab *item);
+        static void ToColor(Rgb *color, HunterLab *item);
+    };
+    typedef IConverter<HunterLab> HunterLabConverter;
+} // namespace ColorSpace
+
+#endif // RGB_CONVERTER_H