//

// Created by Alan Freitas on 2020-07-04.

//

#include <algorithm>

#include <cmath>

#include <matplot/util/colors.h>

#include <vector>

namespace matplot {

std::string to_string(matplot::color c) {

switch (c) {

case color::blue:

return "blue";

case color::black:

return "black";

case color::red:

return "red";

case color::green:

return "green";

case color::yellow:

return "yellow";

case color::cyan:

return "cyan";

case color::magenta:

return "magenta";

case color::white:

return "white";

case color::none:

return "none";

}

}

matplot::color string_to_color(const std::string &s) {

if (s.size() == 1) {

return char_to_color(s[0]);

} else if (s == "blue") {

return color::blue;

} else if (s == "black") {

return color::black;

} else if (s == "red") {

return color::red;

} else if (s == "green") {

return color::green;

} else if (s == "yellow") {

return color::yellow;

} else if (s == "cyan") {

return color::cyan;

} else if (s == "magenta") {

return color::magenta;

} else if (s == "white") {

return color::white;

} else if (s == "none") {

return color::none;

} else {

return color::black;

}

}

matplot::color char_to_color(char c) {

switch (c) {

case 'b':

return color::blue;

case 'k':

return color::black;

case 'r':

return color::red;

case 'g':

return color::green;

case 'y':

return color::yellow;

case 'c':

return color::cyan;

case 'm':

return color::magenta;

case 'w':

return color::white;

case 'n':

return color::none;

default:

return color::black;

}

}

bool is_valid_color_char(char c) {

switch (c) {

case 'b':

case 'k':

case 'r':

case 'g':

case 'y':

case 'c':

case 'm':

case 'w':

case 'n':

return true;

default:

return false;

}

}

std::array<float, 4> to_array(matplot::color c) {

switch (c) {

case color::blue:

return {0, 0, 0, 1};

case color::black:

return {0, 0, 0, 0};

case color::red:

return {0, 1, 0, 0};

case color::green:

return {0, 0, 1, 0};

case color::yellow:

return {0, 1, 1, 0};

case color::cyan:

return {0, 0, 1, 1};

case color::magenta:

return {0, 1, 0, 1};

case color::white:

return {0, 1, 1, 1};

case color::none:

return {1, 0, 0, 0};

}

}

std::array<float, 4> to_array(const std::string &s) {

if (s.size() == 1) {

return to_array(char_to_color(s[0]));

} else if (s == "blue") {

return to_array(color::blue);

} else if (s == "black") {

return to_array(color::black);

} else if (s == "red") {

return to_array(color::red);

} else if (s == "green") {

return to_array(color::green);

} else if (s == "yellow") {

return to_array(color::yellow);

} else if (s == "cyan") {

return to_array(color::cyan);

} else if (s == "magenta") {

return to_array(color::magenta);

} else if (s == "white") {

return to_array(color::white);

} else if (s == "none") {

return to_array(color::none);

} else {

// look for a color in the string

size_t rgb_begin = 0;

bool string_might_have_color = false;

bool has_alpha = false;

if (s[0] == '0' && s[1] == 'x') {

string_might_have_color = true;

if (s.size() == 8) {

// e.g. "0x000000"

rgb_begin = 2;

has_alpha = false;

} else if (s.size() == 10) {

// e.g. "0x00000000"

rgb_begin = 2;

has_alpha = true;

}

} else if (s[0] == '#') {

string_might_have_color = true;

if (s.size() == 7) {

// e.g. "#000000"

rgb_begin = 1;

has_alpha = false;

} else if (s.size() == 9) {

// e.g. "#00000000"

rgb_begin = 1;

has_alpha = true;

}

} else if (s.size() == 6) {

string_might_have_color = true;

has_alpha = false;

rgb_begin = 0;

} else if (s.size() == 8) {

string_might_have_color = true;

has_alpha = false;

rgb_begin = 0;

}

if (string_might_have_color) {

constexpr char digits[] = "0123456789ABCDEF";

std::array<float, 4> result = {0, 0, 0, 0};

// check if all chars are valid

size_t alpha_extra = (has_alpha ? 2 : 0);

size_t color_substring_size = 6 + alpha_extra;

for (size_t i = rgb_begin; i < rgb_begin + color_substring_size;

++i) {

const bool is_valid_hex =

std::find(digits, digits + 16, toupper(s[i])) !=

digits + 16;

if (!is_valid_hex) {

return result;

}

}

// convert chars to float

uint8_t a = 0;

if (has_alpha) {

uint8_t a1 = std::find(digits, digits + 16,

toupper(s[rgb_begin + 0])) -

digits;

uint8_t a2 = std::find(digits, digits + 16,

toupper(s[rgb_begin + 1])) -

digits;

a = (a1 << 4u) | a2;

}

uint8_t r1 =

std::find(digits, digits + 16,

toupper(s[rgb_begin + 0 + alpha_extra])) -

digits;

uint8_t r2 =

std::find(digits, digits + 16,

toupper(s[rgb_begin + 1 + alpha_extra])) -

digits;

uint8_t r = (r1 << 4u) | r2;

uint8_t g1 =

std::find(digits, digits + 16,

toupper(s[rgb_begin + 2 + alpha_extra])) -

digits;

uint8_t g2 =

std::find(digits, digits + 16,

toupper(s[rgb_begin + 3 + alpha_extra])) -

digits;

uint8_t g = (g1 << 4u) | g2;

uint8_t b1 =

std::find(digits, digits + 16,

toupper(s[rgb_begin + 4 + alpha_extra])) -

digits;

uint8_t b2 =

std::find(digits, digits + 16,

toupper(s[rgb_begin + 5 + alpha_extra])) -

digits;

uint8_t b = (b1 << 4u) | b2;

result[0] = static_cast<float>(a) / 255;

result[1] = static_cast<float>(r) / 255;

result[2] = static_cast<float>(g) / 255;

result[3] = static_cast<float>(b) / 255;

return result;

}

}

return {0, 0, 0, 0};

}

std::string to_string(const std::array<float, 4> &c) {

// Alpha / Red / Green / Blue

if (c[0] == 0 && c[1] == 0 && c[2] == 0 && c[3] == 1) {

return "blue";

} else if (c[0] == 0 && c[1] == 0 && c[2] == 0 && c[3] == 0) {

return "black";

} else if (c[0] == 0 && c[1] == 1 && c[2] == 0 && c[3] == 0) {

return "red";

} else if (c[0] == 0 && c[1] == 0 && c[2] == 1 && c[3] == 0) {

return "green";

} else if (c[0] == 0 && c[1] == 1 && c[2] == 1 && c[3] == 0) {

return "yellow";

} else if (c[0] == 0 && c[1] == 0 && c[2] == 1 && c[3] == 1) {

return "cyan";

} else if (c[0] == 0 && c[1] == 1 && c[2] == 0 && c[3] == 1) {

return "magenta";

} else if (c[0] == 0 && c[1] == 1 && c[2] == 1 && c[3] == 1) {

return "white";

}

std::string str = "0x";

str.resize(10);

constexpr char digits[] = "0123456789ABCDEF";

auto a = uint8_t(c[0] * 255);

auto r = uint8_t(c[1] * 255);

auto g = uint8_t(c[2] * 255);

auto b = uint8_t(c[3] * 255);

uint8_t mask = 0b00001111;

str[2] = digits[a >> 4u];

str[3] = digits[a & mask];

str[4] = digits[r >> 4u];

str[5] = digits[r & mask];

str[6] = digits[g >> 4u];

str[7] = digits[g & mask];

str[8] = digits[b >> 4u];

str[9] = digits[b & mask];

return str;

}

std::string to_string(const std::array<float, 3> &c) {

return to_string({0., c[0], c[1], c[2]});

}

namespace palette {

std::vector<std::vector<double>> accent(size_t n) {

static std::vector<std::vector<double>> map = {

{0.498039, 0.788235, 0.498039},

{0.745098, 0.682353, 0.831373},

{0.992157, 0.752941, 0.52549},

{1, 1, 0.6},

{0.219608, 0.423529, 0.690196},

{0.941176, 0.00784314, 0.498039},

{0.74902, 0.356863, 0.0901961},

{0.4, 0.4, 0.4}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> blues(size_t n) {

static std::vector<std::vector<double>> map = {

{0.968627, 0.984314, 1},

{0.870588, 0.921569, 0.968627},

{0.776471, 0.858824, 0.937255},

{0.619608, 0.792157, 0.882353},

{0.419608, 0.682353, 0.839216},

{0.258824, 0.572549, 0.776471},

{0.129412, 0.443137, 0.709804},

{0.0313726, 0.270588, 0.580392}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> brbg(size_t n) {

static std::vector<std::vector<double>> map = {

{0.54902, 0.317647, 0.0392157}, {0.74902, 0.505882, 0.176471},

{0.87451, 0.760784, 0.490196}, {0.964706, 0.909804, 0.764706},

{0.780392, 0.917647, 0.898039}, {0.501961, 0.803922, 0.756863},

{0.207843, 0.592157, 0.560784}, {0.00392157, 0.4, 0.368627}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> bugn(size_t n) {

static std::vector<std::vector<double>> map = {

{0.968627, 0.988235, 0.992157}, {0.898039, 0.960784, 0.976471},

{0.8, 0.92549, 0.901961}, {0.6, 0.847059, 0.788235},

{0.4, 0.760784, 0.643137}, {0.254902, 0.682353, 0.462745},

{0.137255, 0.545098, 0.270588}, {0, 0.345098, 0.141176}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> bupu(size_t n) {

static std::vector<std::vector<double>> map = {

{0.968627, 0.988235, 0.992157},

{0.878431, 0.92549, 0.956863},

{0.74902, 0.827451, 0.901961},

{0.619608, 0.737255, 0.854902},

{0.54902, 0.588235, 0.776471},

{0.54902, 0.419608, 0.694118},

{0.533333, 0.254902, 0.615686},

{0.431373, 0.00392157, 0.419608}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> chromajs(size_t n) {

static std::vector<std::vector<double>> map = {

{1, 1, 0.878431},

{1, 0.87451, 0.721569},

{1, 0.737255, 0.580392},

{1, 0.592157, 0.466667},

{1, 0.411765, 0.384314},

{0.933333, 0.258824, 0.337255},

{0.823529, 0.121569, 0.278431},

{0.690196, 0.0235294, 0.172549},

{0.545098, 0, 0}};

if (n == 9) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> dark2(size_t n) {

static std::vector<std::vector<double>> map = {

{0.105882, 0.619608, 0.466667},

{0.85098, 0.372549, 0.00784314},

{0.458824, 0.439216, 0.701961},

{0.905882, 0.160784, 0.541176},

{0.4, 0.65098, 0.117647},

{0.901961, 0.670588, 0.00784314},

{0.65098, 0.462745, 0.113725},

{0.4, 0.4, 0.4}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> gnbu(size_t n) {

static std::vector<std::vector<double>> map = {

{0.968627, 0.988235, 0.941176},

{0.878431, 0.952941, 0.858824},

{0.8, 0.921569, 0.772549},

{0.658824, 0.866667, 0.709804},

{0.482353, 0.8, 0.768627},

{0.305882, 0.701961, 0.827451},

{0.168627, 0.54902, 0.745098},

{0.0313726, 0.345098, 0.619608}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> gnpu(size_t n) {

static std::vector<std::vector<double>> map = {

{0.223529, 0.388235, 0.32549}, {0.0509804, 0.694118, 0.294118},

{0.427451, 0.752941, 0.403922}, {0.670588, 0.839216, 0.607843},

{0.854902, 0.917647, 0.756863}, {0.87451, 0.8, 0.894118},

{0.780392, 0.698039, 0.839216}, {0.580392, 0.454902, 0.705882},

{0.458824, 0.25098, 0.596078}, {0.313726, 0.286275, 0.443137}};

if (n == 10) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> greens(size_t n) {

static std::vector<std::vector<double>> map = {

{0.968627, 0.988235, 0.960784}, {0.898039, 0.960784, 0.878431},

{0.780392, 0.913725, 0.752941}, {0.631373, 0.85098, 0.607843},

{0.454902, 0.768627, 0.462745}, {0.254902, 0.670588, 0.364706},

{0.137255, 0.545098, 0.270588}, {0, 0.352941, 0.196078}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> greys(size_t n) {

static std::vector<std::vector<double>> map = {

{1, 1, 1},

{0.941176, 0.941176, 0.941176},

{0.85098, 0.85098, 0.85098},

{0.741176, 0.741176, 0.741176},

{0.588235, 0.588235, 0.588235},

{0.45098, 0.45098, 0.45098},

{0.321569, 0.321569, 0.321569},

{0.145098, 0.145098, 0.145098}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> inferno(size_t n) {

static std::vector<std::vector<double>> map = {

{0.001462, 0.000466, 0.013866}, {0.002267, 0.00127, 0.01857},

{0.003299, 0.002249, 0.024239}, {0.004547, 0.003392, 0.030909},

{0.006006, 0.004692, 0.038558}, {0.007676, 0.006136, 0.046836},

{0.009561, 0.007713, 0.055143}, {0.011663, 0.009417, 0.06346},

{0.013995, 0.011225, 0.071862}, {0.016561, 0.013136, 0.080282},

{0.019373, 0.015133, 0.088767}, {0.022447, 0.017199, 0.097327},

{0.025793, 0.019331, 0.10593}, {0.029432, 0.021503, 0.114621},

{0.033385, 0.023702, 0.123397}, {0.037668, 0.025921, 0.132232},

{0.042253, 0.028139, 0.141141}, {0.046915, 0.030324, 0.150164},

{0.051644, 0.032474, 0.159254}, {0.056449, 0.034569, 0.168414},

{0.06134, 0.03659, 0.177642}, {0.066331, 0.038504, 0.186962},

{0.071429, 0.040294, 0.196354}, {0.076637, 0.041905, 0.205799},

{0.081962, 0.043328, 0.215289}, {0.087411, 0.044556, 0.224813},

{0.09299, 0.045583, 0.234358}, {0.098702, 0.046402, 0.243904},

{0.104551, 0.047008, 0.25343}, {0.110536, 0.047399, 0.262912},

{0.116656, 0.047574, 0.272321}, {0.122908, 0.047536, 0.281624},

{0.129285, 0.047293, 0.290788}, {0.135778, 0.046856, 0.299776},

{0.142378, 0.046242, 0.308553}, {0.149073, 0.045468, 0.317085},

{0.15585, 0.044559, 0.325338}, {0.162689, 0.043554, 0.333277},

{0.169575, 0.042489, 0.340874}, {0.176493, 0.041402, 0.348111},

{0.183429, 0.040329, 0.354971}, {0.190367, 0.039309, 0.361447},

{0.197297, 0.0384, 0.367535}, {0.204209, 0.037632, 0.373238},

{0.211095, 0.03703, 0.378563}, {0.217949, 0.036615, 0.383522},

{0.224763, 0.036405, 0.388129}, {0.231538, 0.036405, 0.3924},

{0.238273, 0.036621, 0.396353}, {0.244967, 0.037055, 0.400007},

{0.25162, 0.037705, 0.403378}, {0.258234, 0.038571, 0.406485},

{0.26481, 0.039647, 0.409345}, {0.271347, 0.040922, 0.411976},

{0.27785, 0.042353, 0.414392}, {0.284321, 0.043933, 0.416608},

{0.290763, 0.045644, 0.418637}, {0.297178, 0.04747, 0.420491},

{0.303568, 0.049396, 0.422182}, {0.309935, 0.051407, 0.423721},

{0.316282, 0.05349, 0.425116}, {0.32261, 0.055634, 0.426377},

{0.328921, 0.057827, 0.427511}, {0.335217, 0.06006, 0.428524},

{0.3415, 0.062325, 0.429425}, {0.347771, 0.064616, 0.430217},

{0.354032, 0.066925, 0.430906}, {0.360284, 0.069247, 0.431497},

{0.366529, 0.071579, 0.431994}, {0.372768, 0.073915, 0.4324},

{0.379001, 0.076253, 0.432719}, {0.385228, 0.078591, 0.432955},

{0.391453, 0.080927, 0.433109}, {0.397674, 0.083257, 0.433183},

{0.403894, 0.08558, 0.433179}, {0.410113, 0.087896, 0.433098},

{0.416331, 0.090203, 0.432943}, {0.422549, 0.092501, 0.432714},

{0.428768, 0.09479, 0.432412}, {0.434987, 0.097069, 0.432039},

{0.441207, 0.099338, 0.431594}, {0.447428, 0.101597, 0.43108},

{0.453651, 0.103848, 0.430498}, {0.459875, 0.106089, 0.429846},

{0.4661, 0.108322, 0.429125}, {0.472328, 0.110547, 0.428334},

{0.478558, 0.112764, 0.427475}, {0.484789, 0.114974, 0.426548},

{0.491022, 0.117179, 0.425552}, {0.497257, 0.119379, 0.424488},

{0.503493, 0.121575, 0.423356}, {0.50973, 0.123769, 0.422156},

{0.515967, 0.12596, 0.420887}, {0.522206, 0.12815, 0.419549},

{0.528444, 0.130341, 0.418142}, {0.534683, 0.132534, 0.416667},

{0.54092, 0.134729, 0.415123}, {0.547157, 0.136929, 0.413511},

{0.553392, 0.139134, 0.411829}, {0.559624, 0.141346, 0.410078},

{0.565854, 0.143567, 0.408258}, {0.572081, 0.145797, 0.406369},

{0.578304, 0.148039, 0.404411}, {0.584521, 0.150294, 0.402385},

{0.590734, 0.152563, 0.40029}, {0.59694, 0.154848, 0.398125},

{0.603139, 0.157151, 0.395891}, {0.60933, 0.159474, 0.393589},

{0.615513, 0.161817, 0.391219}, {0.621685, 0.164184, 0.388781},

{0.627847, 0.166575, 0.386276}, {0.633998, 0.168992, 0.383704},

{0.640135, 0.171438, 0.381065}, {0.64626, 0.173914, 0.378359},

{0.652369, 0.176421, 0.375586}, {0.658463, 0.178962, 0.372748},

{0.66454, 0.181539, 0.369846}, {0.670599, 0.184153, 0.366879},

{0.676638, 0.186807, 0.363849}, {0.682656, 0.189501, 0.360757},

{0.688653, 0.192239, 0.357603}, {0.694627, 0.195021, 0.354388},

{0.700576, 0.197851, 0.351113}, {0.7065, 0.200728, 0.347777},

{0.712396, 0.203656, 0.344383}, {0.718264, 0.206636, 0.340931},

{0.724103, 0.20967, 0.337424}, {0.729909, 0.212759, 0.333861},

{0.735683, 0.215906, 0.330245}, {0.741423, 0.219112, 0.326576},

{0.747127, 0.222378, 0.322856}, {0.752794, 0.225706, 0.319085},

{0.758422, 0.229097, 0.315266}, {0.76401, 0.232554, 0.311399},

{0.769556, 0.236077, 0.307485}, {0.775059, 0.239667, 0.303526},

{0.780517, 0.243327, 0.299523}, {0.785929, 0.247056, 0.295477},

{0.791293, 0.250856, 0.29139}, {0.796607, 0.254728, 0.287264},

{0.801871, 0.258674, 0.283099}, {0.807082, 0.262692, 0.278898},

{0.812239, 0.266786, 0.274661}, {0.817341, 0.270954, 0.27039},

{0.822386, 0.275197, 0.266085}, {0.827372, 0.279517, 0.26175},

{0.832299, 0.283913, 0.257383}, {0.837165, 0.288385, 0.252988},

{0.841969, 0.292933, 0.248564}, {0.846709, 0.297559, 0.244113},

{0.851384, 0.30226, 0.239636}, {0.855992, 0.307038, 0.235133},

{0.860533, 0.311892, 0.230606}, {0.865006, 0.316822, 0.226055},

{0.869409, 0.321827, 0.221482}, {0.873741, 0.326906, 0.216886},

{0.878001, 0.33206, 0.212268}, {0.882188, 0.337287, 0.207628},

{0.886302, 0.342586, 0.202968}, {0.890341, 0.347957, 0.198286},

{0.894305, 0.353399, 0.193584}, {0.898192, 0.358911, 0.18886},

{0.902003, 0.364492, 0.184116}, {0.905735, 0.37014, 0.17935},

{0.90939, 0.375856, 0.174563}, {0.912966, 0.381636, 0.169755},

{0.916462, 0.387481, 0.164924}, {0.919879, 0.393389, 0.16007},

{0.923215, 0.399359, 0.155193}, {0.92647, 0.405389, 0.150292},

{0.929644, 0.411479, 0.145367}, {0.932737, 0.417627, 0.140417},

{0.935747, 0.423831, 0.13544}, {0.938675, 0.430091, 0.130438},

{0.941521, 0.436405, 0.125409}, {0.944285, 0.442772, 0.120354},

{0.946965, 0.449191, 0.115272}, {0.949562, 0.45566, 0.110164},

{0.952075, 0.462178, 0.105031}, {0.954506, 0.468744, 0.099874},

{0.956852, 0.475356, 0.094695}, {0.959114, 0.482014, 0.089499},

{0.961293, 0.488716, 0.084289}, {0.963387, 0.495462, 0.079073},

{0.965397, 0.502249, 0.073859}, {0.967322, 0.509078, 0.068659},

{0.969163, 0.515946, 0.063488}, {0.970919, 0.522853, 0.058367},

{0.97259, 0.529798, 0.053324}, {0.974176, 0.53678, 0.048392},

{0.975677, 0.543798, 0.043618}, {0.977092, 0.55085, 0.03905},

{0.978422, 0.557937, 0.034931}, {0.979666, 0.565057, 0.031409},

{0.980824, 0.572209, 0.028508}, {0.981895, 0.579392, 0.02625},

{0.982881, 0.586606, 0.024661}, {0.983779, 0.593849, 0.02377},

{0.984591, 0.601122, 0.023606}, {0.985315, 0.608422, 0.024202},

{0.985952, 0.61575, 0.025592}, {0.986502, 0.623105, 0.027814},

{0.986964, 0.630485, 0.030908}, {0.987337, 0.63789, 0.034916},

{0.987622, 0.64532, 0.039886}, {0.987819, 0.652773, 0.045581},

{0.987926, 0.66025, 0.05175}, {0.987945, 0.667748, 0.058329},

{0.987874, 0.675267, 0.065257}, {0.987714, 0.682807, 0.072489},

{0.987464, 0.690366, 0.07999}, {0.987124, 0.697944, 0.087731},

{0.986694, 0.70554, 0.095694}, {0.986175, 0.713153, 0.103863},

{0.985566, 0.720782, 0.112229}, {0.984865, 0.728427, 0.120785},

{0.984075, 0.736087, 0.129527}, {0.983196, 0.743758, 0.138453},

{0.982228, 0.751442, 0.147565}, {0.981173, 0.759135, 0.156863},

{0.980032, 0.766837, 0.166353}, {0.978806, 0.774545, 0.176037},

{0.977497, 0.782258, 0.185923}, {0.976108, 0.789974, 0.196018},

{0.974638, 0.797692, 0.206332}, {0.973088, 0.805409, 0.216877},

{0.971468, 0.813122, 0.227658}, {0.969783, 0.820825, 0.238686},

{0.968041, 0.828515, 0.249972}, {0.966243, 0.836191, 0.261534},

{0.964394, 0.843848, 0.273391}, {0.962517, 0.851476, 0.285546},

{0.960626, 0.859069, 0.29801}, {0.95872, 0.866624, 0.31082},

{0.956834, 0.874129, 0.323974}, {0.954997, 0.881569, 0.337475},

{0.953215, 0.888942, 0.351369}, {0.951546, 0.896226, 0.365627},

{0.950018, 0.903409, 0.380271}, {0.948683, 0.910473, 0.395289},

{0.947594, 0.917399, 0.410665}, {0.946809, 0.924168, 0.426373},

{0.946392, 0.930761, 0.442367}, {0.946403, 0.937159, 0.458592},

{0.946903, 0.943348, 0.47497}, {0.947937, 0.949318, 0.491426},

{0.949545, 0.955063, 0.50786}, {0.95174, 0.960587, 0.524203},

{0.954529, 0.965896, 0.540361}, {0.957896, 0.971003, 0.556275},

{0.961812, 0.975924, 0.571925}, {0.966249, 0.980678, 0.587206},

{0.971162, 0.985282, 0.602154}, {0.976511, 0.989753, 0.61676},

{0.982257, 0.994109, 0.631017}, {0.988362, 0.998364, 0.644924}};

if (n == 256) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> jet(size_t n) {

static std::vector<std::vector<double>> map = {

{0, 0, 0.5625}, {0, 0, 0.625}, {0, 0, 0.6875},

{0, 0, 0.75}, {0, 0, 0.8125}, {0, 0, 0.875},

{0, 0, 0.9375}, {0, 0, 1}, {0, 0.0625, 1},

{0, 0.125, 1}, {0, 0.1875, 1}, {0, 0.25, 1},

{0, 0.3125, 1}, {0, 0.375, 1}, {0, 0.4375, 1},

{0, 0.5, 1}, {0, 0.5625, 1}, {0, 0.625, 1},

{0, 0.6875, 1}, {0, 0.75, 1}, {0, 0.8125, 1},

{0, 0.875, 1}, {0, 0.9375, 1}, {0, 1, 1},

{0.0625, 1, 0.9375}, {0.125, 1, 0.875}, {0.1875, 1, 0.8125},

{0.25, 1, 0.75}, {0.3125, 1, 0.6875}, {0.375, 1, 0.625},

{0.4375, 1, 0.5625}, {0.5, 1, 0.5}, {0.5625, 1, 0.4375},

{0.625, 1, 0.375}, {0.6875, 1, 0.3125}, {0.75, 1, 0.25},

{0.8125, 1, 0.1875}, {0.875, 1, 0.125}, {0.9375, 1, 0.0625},

{1, 1, 0}, {1, 0.9375, 0}, {1, 0.875, 0},

{1, 0.8125, 0}, {1, 0.75, 0}, {1, 0.6875, 0},

{1, 0.625, 0}, {1, 0.5625, 0}, {1, 0.5, 0},

{1, 0.4375, 0}, {1, 0.375, 0}, {1, 0.3125, 0},

{1, 0.25, 0}, {1, 0.1875, 0}, {1, 0.125, 0},

{1, 0.0625, 0}, {1, 0, 0}, {0.9375, 0, 0},

{0.875, 0, 0}, {0.8125, 0, 0}, {0.75, 0, 0},

{0.6875, 0, 0}, {0.625, 0, 0}, {0.5625, 0, 0},

{0.5, 0, 0}};

if (n == 64) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> magma(size_t n) {

static std::vector<std::vector<double>> map = {

{0.001462, 0.000466, 0.013866}, {0.002258, 0.001295, 0.018331},

{0.003279, 0.002305, 0.023708}, {0.004512, 0.00349, 0.029965},

{0.00595, 0.004843, 0.03713}, {0.007588, 0.006356, 0.044973},

{0.009426, 0.008022, 0.052844}, {0.011465, 0.009828, 0.06075},

{0.013708, 0.011771, 0.068667}, {0.016156, 0.01384, 0.076603},

{0.018815, 0.016026, 0.084584}, {0.021692, 0.01832, 0.09261},

{0.024792, 0.020715, 0.100676}, {0.028123, 0.023201, 0.108787},

{0.031696, 0.025765, 0.116965}, {0.03552, 0.028397, 0.125209},

{0.039608, 0.03109, 0.133515}, {0.04383, 0.03383, 0.141886},

{0.048062, 0.036607, 0.150327}, {0.05232, 0.039407, 0.158841},

{0.056615, 0.04216, 0.167446}, {0.060949, 0.044794, 0.176129},

{0.06533, 0.047318, 0.184892}, {0.069764, 0.049726, 0.193735},

{0.074257, 0.052017, 0.20266}, {0.078815, 0.054184, 0.211667},

{0.083446, 0.056225, 0.220755}, {0.088155, 0.058133, 0.229922},

{0.092949, 0.059904, 0.239164}, {0.097833, 0.061531, 0.248477},

{0.102815, 0.06301, 0.257854}, {0.107899, 0.064335, 0.267289},

{0.113094, 0.065492, 0.276784}, {0.118405, 0.066479, 0.286321},

{0.123833, 0.067295, 0.295879}, {0.12938, 0.067935, 0.305443},

{0.135053, 0.068391, 0.315}, {0.140858, 0.068654, 0.324538},

{0.146785, 0.068738, 0.334011}, {0.152839, 0.068637, 0.343404},

{0.159018, 0.068354, 0.352688}, {0.165308, 0.067911, 0.361816},

{0.171713, 0.067305, 0.370771}, {0.178212, 0.066576, 0.379497},

{0.184801, 0.065732, 0.387973}, {0.19146, 0.064818, 0.396152},

{0.198177, 0.063862, 0.404009}, {0.204935, 0.062907, 0.411514},

{0.211718, 0.061992, 0.418647}, {0.218512, 0.061158, 0.425392},

{0.225302, 0.060445, 0.431742}, {0.232077, 0.059889, 0.437695},

{0.238826, 0.059517, 0.443256}, {0.245543, 0.059352, 0.448436},

{0.25222, 0.059415, 0.453248}, {0.258857, 0.059706, 0.45771},

{0.265447, 0.060237, 0.46184}, {0.271994, 0.060994, 0.46566},

{0.278493, 0.061978, 0.46919}, {0.284951, 0.063168, 0.472451},

{0.291366, 0.064553, 0.475462}, {0.29774, 0.066117, 0.478243},

{0.304081, 0.067835, 0.480812}, {0.310382, 0.069702, 0.483186},

{0.316654, 0.07169, 0.48538}, {0.322899, 0.073782, 0.487408},

{0.329114, 0.075972, 0.489287}, {0.335308, 0.078236, 0.491024},

{0.341482, 0.080564, 0.492631}, {0.347636, 0.082946, 0.494121},

{0.353773, 0.085373, 0.495501}, {0.359898, 0.087831, 0.496778},

{0.366012, 0.090314, 0.49796}, {0.372116, 0.092816, 0.499053},

{0.378211, 0.095332, 0.500067}, {0.384299, 0.097855, 0.501002},

{0.390384, 0.100379, 0.501864}, {0.396467, 0.102902, 0.502658},

{0.402548, 0.10542, 0.503386}, {0.408629, 0.10793, 0.504052},

{0.414709, 0.110431, 0.504662}, {0.420791, 0.11292, 0.505215},

{0.426877, 0.115395, 0.505714}, {0.432967, 0.117855, 0.50616},

{0.439062, 0.120298, 0.506555}, {0.445163, 0.122724, 0.506901},

{0.451271, 0.125132, 0.507198}, {0.457386, 0.127522, 0.507448},

{0.463508, 0.129893, 0.507652}, {0.46964, 0.132245, 0.507809},

{0.47578, 0.134577, 0.507921}, {0.481929, 0.136891, 0.507989},

{0.488088, 0.139186, 0.508011}, {0.494258, 0.141462, 0.507988},

{0.500438, 0.143719, 0.50792}, {0.506629, 0.145958, 0.507806},

{0.512831, 0.148179, 0.507648}, {0.519045, 0.150383, 0.507443},

{0.52527, 0.152569, 0.507192}, {0.531507, 0.154739, 0.506895},

{0.537755, 0.156894, 0.506551}, {0.544015, 0.159033, 0.506159},

{0.550287, 0.161158, 0.505719}, {0.556571, 0.163269, 0.50523},

{0.562866, 0.165368, 0.504692}, {0.569172, 0.167454, 0.504105},

{0.57549, 0.16953, 0.503466}, {0.581819, 0.171596, 0.502777},

{0.588158, 0.173652, 0.502035}, {0.594508, 0.175701, 0.501241},

{0.600868, 0.177743, 0.500394}, {0.607238, 0.179779, 0.499492},

{0.613617, 0.181811, 0.498536}, {0.620005, 0.18384, 0.497524},

{0.626401, 0.185867, 0.496456}, {0.632805, 0.187893, 0.495332},

{0.639216, 0.189921, 0.49415}, {0.645633, 0.191952, 0.49291},

{0.652056, 0.193986, 0.491611}, {0.658483, 0.196027, 0.490253},

{0.664915, 0.198075, 0.488836}, {0.671349, 0.200133, 0.487358},

{0.677786, 0.202203, 0.485819}, {0.684224, 0.204286, 0.484219},

{0.690661, 0.206384, 0.482558}, {0.697098, 0.208501, 0.480835},

{0.703532, 0.210638, 0.479049}, {0.709962, 0.212797, 0.477201},

{0.716387, 0.214982, 0.47529}, {0.722805, 0.217194, 0.473316},

{0.729216, 0.219437, 0.471279}, {0.735616, 0.221713, 0.46918},

{0.742004, 0.224025, 0.467018}, {0.748378, 0.226377, 0.464794},

{0.754737, 0.228772, 0.462509}, {0.761077, 0.231214, 0.460162},

{0.767398, 0.233705, 0.457755}, {0.773695, 0.236249, 0.455289},

{0.779968, 0.238851, 0.452765}, {0.786212, 0.241514, 0.450184},

{0.792427, 0.244242, 0.447543}, {0.798608, 0.24704, 0.444848},

{0.804752, 0.249911, 0.442102}, {0.810855, 0.252861, 0.439305},

{0.816914, 0.255895, 0.436461}, {0.822926, 0.259016, 0.433573},

{0.828886, 0.262229, 0.430644}, {0.834791, 0.26554, 0.427671},

{0.840636, 0.268953, 0.424666}, {0.846416, 0.272473, 0.421631},

{0.852126, 0.276106, 0.418573}, {0.857763, 0.279857, 0.415496},

{0.86332, 0.283729, 0.412403}, {0.868793, 0.287728, 0.409303},

{0.874176, 0.291859, 0.406205}, {0.879464, 0.296125, 0.403118},

{0.884651, 0.30053, 0.400047}, {0.889731, 0.305079, 0.397002},

{0.8947, 0.309773, 0.393995}, {0.899552, 0.314616, 0.391037},

{0.904281, 0.31961, 0.388137}, {0.908884, 0.324755, 0.385308},

{0.913354, 0.330052, 0.382563}, {0.917689, 0.3355, 0.379915},

{0.921884, 0.341098, 0.377376}, {0.925937, 0.346844, 0.374959},

{0.929845, 0.352734, 0.372677}, {0.933606, 0.358764, 0.370541},

{0.937221, 0.364929, 0.368567}, {0.940687, 0.371224, 0.366762},

{0.944006, 0.377643, 0.365136}, {0.94718, 0.384178, 0.363701},

{0.95021, 0.39082, 0.362468}, {0.953099, 0.397563, 0.361438},

{0.955849, 0.4044, 0.360619}, {0.958464, 0.411324, 0.360014},

{0.960949, 0.418323, 0.35963}, {0.96331, 0.42539, 0.359469},

{0.965549, 0.432519, 0.359529}, {0.967671, 0.439703, 0.35981},

{0.96968, 0.446936, 0.360311}, {0.971582, 0.45421, 0.36103},

{0.973381, 0.46152, 0.361965}, {0.975082, 0.468861, 0.363111},

{0.97669, 0.476226, 0.364466}, {0.97821, 0.483612, 0.366025},

{0.979645, 0.491014, 0.367783}, {0.981, 0.498428, 0.369734},

{0.982279, 0.505851, 0.371874}, {0.983485, 0.51328, 0.374198},

{0.984622, 0.520713, 0.376698}, {0.985693, 0.528148, 0.379371},

{0.9867, 0.535582, 0.38221}, {0.987646, 0.543015, 0.38521},

{0.988533, 0.550446, 0.388365}, {0.989363, 0.557873, 0.391671},

{0.990138, 0.565296, 0.395122}, {0.990871, 0.572706, 0.398714},

{0.991558, 0.580107, 0.402441}, {0.992196, 0.587502, 0.406299},

{0.992785, 0.594891, 0.410283}, {0.993326, 0.602275, 0.41439},

{0.993834, 0.609644, 0.418613}, {0.994309, 0.616999, 0.42295},

{0.994738, 0.62435, 0.427397}, {0.995122, 0.631696, 0.431951},

{0.99548, 0.639027, 0.436607}, {0.99581, 0.646344, 0.441361},

{0.996096, 0.653659, 0.446213}, {0.996341, 0.660969, 0.45116},

{0.99658, 0.668256, 0.456192}, {0.996775, 0.675541, 0.461314},

{0.996925, 0.682828, 0.466526}, {0.997077, 0.690088, 0.471811},

{0.997186, 0.697349, 0.477182}, {0.997254, 0.704611, 0.482635},

{0.997325, 0.711848, 0.488154}, {0.997351, 0.719089, 0.493755},

{0.997351, 0.726324, 0.499428}, {0.997341, 0.733545, 0.505167},

{0.997285, 0.740772, 0.510983}, {0.997228, 0.747981, 0.516859},

{0.997138, 0.75519, 0.522806}, {0.997019, 0.762398, 0.528821},

{0.996898, 0.769591, 0.534892}, {0.996727, 0.776795, 0.541039},

{0.996571, 0.783977, 0.547233}, {0.996369, 0.791167, 0.553499},

{0.996162, 0.798348, 0.55982}, {0.995932, 0.805527, 0.566202},

{0.99568, 0.812706, 0.572645}, {0.995424, 0.819875, 0.57914},

{0.995131, 0.827052, 0.585701}, {0.994851, 0.834213, 0.592307},

{0.994524, 0.841387, 0.598983}, {0.994222, 0.84854, 0.605696},

{0.993866, 0.855711, 0.612482}, {0.993545, 0.862859, 0.619299},

{0.99317, 0.870024, 0.626189}, {0.992831, 0.877168, 0.633109},

{0.99244, 0.88433, 0.640099}, {0.992089, 0.89147, 0.647116},

{0.991688, 0.898627, 0.654202}, {0.991332, 0.905763, 0.661309},

{0.99093, 0.912915, 0.668481}, {0.99057, 0.920049, 0.675675},

{0.990175, 0.927196, 0.682926}, {0.989815, 0.934329, 0.690198},

{0.989434, 0.94147, 0.697519}, {0.989077, 0.948604, 0.704863},

{0.988717, 0.955742, 0.712242}, {0.988367, 0.962878, 0.719649},

{0.988033, 0.970012, 0.727077}, {0.987691, 0.977154, 0.734536},

{0.987387, 0.984288, 0.742002}, {0.987053, 0.991438, 0.749504}};

if (n == 256) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> oranges(size_t n) {

static std::vector<std::vector<double>> map = {

{1, 0.960784, 0.921569},

{0.996078, 0.901961, 0.807843},

{0.992157, 0.815686, 0.635294},

{0.992157, 0.682353, 0.419608},

{0.992157, 0.552941, 0.235294},

{0.945098, 0.411765, 0.0745098},

{0.85098, 0.282353, 0.00392157},

{0.54902, 0.176471, 0.0156863}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> orrd(size_t n) {

static std::vector<std::vector<double>> map = {

{1, 0.968627, 0.92549}, {0.996078, 0.909804, 0.784314},

{0.992157, 0.831373, 0.619608}, {0.992157, 0.733333, 0.517647},

{0.988235, 0.552941, 0.34902}, {0.937255, 0.396078, 0.282353},

{0.843137, 0.188235, 0.121569}, {0.6, 0, 0}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> paired(size_t n) {

static std::vector<std::vector<double>> map = {

{0.65098, 0.807843, 0.890196}, {0.121569, 0.470588, 0.705882},

{0.698039, 0.87451, 0.541176}, {0.2, 0.627451, 0.172549},

{0.984314, 0.603922, 0.6}, {0.890196, 0.101961, 0.109804},

{0.992157, 0.74902, 0.435294}, {1, 0.498039, 0}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> parula(size_t n) {

static std::vector<std::vector<double>> map = {

{0.2422, 0.1504, 0.6603},

{0.25039, 0.164995, 0.707614},

{0.257771, 0.181781, 0.751138},

{0.264729, 0.197757, 0.795214},

{0.270648, 0.214676, 0.836371},

{0.275114, 0.234238, 0.870986},

{0.2783, 0.255871, 0.899071},

{0.280333, 0.278233, 0.9221},

{0.281338, 0.300595, 0.941376},

{0.281014, 0.322757, 0.957886},

{0.279467, 0.344671, 0.971676},

{0.275971, 0.366681, 0.982905},

{0.269914, 0.3892, 0.9906},

{0.260243, 0.412329, 0.995157},

{0.244033, 0.435833, 0.998833},

{0.220643, 0.460257, 0.997286},

{0.196333, 0.484719, 0.989152},

{0.183405, 0.507371, 0.979795},

{0.178643, 0.528857, 0.968157},

{0.176438, 0.549905, 0.952019},

{0.168743, 0.570262, 0.935871},

{0.154, 0.5902, 0.9218},

{0.146029, 0.609119, 0.907857},

{0.138024, 0.627629, 0.89729},

{0.124814, 0.645929, 0.888343},

{0.111252, 0.6635, 0.876314},

{0.0952095, 0.679829, 0.859781},

{0.0688714, 0.694771, 0.839357},

{0.0296667, 0.708167, 0.816333},

{0.00357143, 0.720267, 0.7917},

{0.00665714, 0.731214, 0.766014},

{0.0433286, 0.741095, 0.73941},

{0.0963952, 0.75, 0.712038},

{0.140771, 0.7584, 0.684157},

{0.1717, 0.766962, 0.655443},

{0.193767, 0.775767, 0.6251},

{0.216086, 0.7843, 0.5923},

{0.246957, 0.791795, 0.556743},

{0.290614, 0.79729, 0.518829},

{0.340643, 0.8008, 0.478857},

{0.3909, 0.802871, 0.435448},

{0.445629, 0.802419, 0.390919},

{0.5044, 0.7993, 0.348},

{0.561562, 0.794233, 0.304481},

{0.617395, 0.787619, 0.261238},

{0.671986, 0.779271, 0.2227},

{0.7242, 0.769843, 0.191029},

{0.773833, 0.759805, 0.16461},

{0.820314, 0.749814, 0.153529},

{0.863433, 0.7406, 0.159633},

{0.903543, 0.733029, 0.177414},

{0.939257, 0.728786, 0.209957},

{0.972757, 0.729771, 0.239443},

{0.995648, 0.743371, 0.237148},

{0.996986, 0.765857, 0.219943},

{0.995205, 0.789252, 0.202762},

{0.9892, 0.813567, 0.188533},

{0.978629, 0.838629, 0.176557},

{0.967648, 0.8639, 0.16429},

{0.96101, 0.889019, 0.153676},

{0.959671, 0.913457, 0.142257},

{0.962795, 0.937338, 0.12651},

{0.969114, 0.960629, 0.106362},

{0.9769, 0.9839, 0.0805}};

if (n == 64) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> pastel1(size_t n) {

static std::vector<std::vector<double>> map = {

{0.984314, 0.705882, 0.682353}, {0.701961, 0.803922, 0.890196},

{0.8, 0.921569, 0.772549}, {0.870588, 0.796078, 0.894118},

{0.996078, 0.85098, 0.65098}, {1, 1, 0.8},

{0.898039, 0.847059, 0.741176}, {0.992157, 0.854902, 0.92549}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;

for (size_t i = 0; i < n; ++i) {

std::array<float, 4> ac =

colormap_interpolation(i, 0, n - 1, map);

std::vector<double> vc = {ac[1], ac[2], ac[3]};

result.emplace_back(vc);

}

return result;

}

std::vector<std::vector<double>> pastel2(size_t n) {

static std::vector<std::vector<double>> map = {

{0.701961, 0.886275, 0.803922}, {0.992157, 0.803922, 0.67451},

{0.803922, 0.709804, 0.909804}, {0.956863, 0.792157, 0.894118},

{0.839216, 0.960784, 0.788235}, {1, 0.94902, 0.682353},

{0.945098, 0.886275, 0.8}, {0.8, 0.8, 0.8}};

if (n == 8) {

return map;

}

std::vector<std::vector<double>> result;