//

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

//

#include <algorithm>

#include <cmath>

#include <cstdint>

#include <matplot/util/colors.h>

#include <vector>

#include <stdexcept>

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";

}

throw std::logic_error("colors::to_string: could not find a string for color");

}

matplot::color string_to_color(std::string_view 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};

}

throw std::logic_error("colors::to_array: could not find an array for color");

}

std::array<float, 4> to_array(std::string_view 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 = static_cast<uint8_t>(

std::find(digits, digits + 16,

static_cast<uint8_t>(toupper(

static_cast<int>(s[rgb_begin + 0])))) -

digits);

uint8_t a2 = static_cast<uint8_t>(

std::find(digits, digits + 16,

toupper(s[rgb_begin + 1])) -

digits);

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

}

uint8_t r1 = static_cast<uint8_t>(

std::find(digits, digits + 16,

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

digits);

uint8_t r2 = static_cast<uint8_t>(

std::find(digits, digits + 16,

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

digits);

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

uint8_t g1 = static_cast<uint8_t>(

std::find(digits, digits + 16,

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

digits);

uint8_t g2 = static_cast<uint8_t>(

std::find(digits, digits + 16,

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

digits);

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

uint8_t b1 = static_cast<uint8_t>(

std::find(digits, digits + 16,

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

digits);

uint8_t b2 = static_cast<uint8_t>(

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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(n - 1), map);

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

result.emplace_back(vc);

}

return result;

}

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

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

{0.189950, 0.071760, 0.232170}, {0.194830, 0.083390, 0.261490},

{0.199560, 0.094980, 0.290240}, {0.204150, 0.106520, 0.318440},

{0.208600, 0.118020, 0.346070}, {0.212910, 0.129470, 0.373140},

{0.217080, 0.140870, 0.399640}, {0.221110, 0.152230, 0.425580},

{0.225000, 0.163540, 0.450960}, {0.228750, 0.174810, 0.475780},

{0.232360, 0.186030, 0.500040}, {0.235820, 0.197200, 0.523730},

{0.239150, 0.208330, 0.546860}, {0.242340, 0.219410, 0.569420},

{0.245390, 0.230440, 0.591420}, {0.248300, 0.241430, 0.612860},

{0.251070, 0.252370, 0.633740}, {0.253690, 0.263270, 0.654060},

{0.256180, 0.274120, 0.673810}, {0.258530, 0.284920, 0.693000},

{0.260740, 0.295680, 0.711620}, {0.262800, 0.306390, 0.729680},

{0.264730, 0.317060, 0.747180}, {0.266520, 0.327680, 0.764120},

{0.268160, 0.338250, 0.780500}, {0.269670, 0.348780, 0.796310},

{0.271030, 0.359260, 0.811560}, {0.272260, 0.369700, 0.826240},

{0.273340, 0.380080, 0.840370}, {0.274290, 0.390430, 0.853930},

{0.275090, 0.400720, 0.866920}, {0.275760, 0.410970, 0.879360},

{0.276280, 0.421180, 0.891230}, {0.276670, 0.431340, 0.902540},

{0.276910, 0.441450, 0.913280}, {0.277010, 0.451520, 0.923470},

{0.276980, 0.461530, 0.933090}, {0.276800, 0.471510, 0.942140},

{0.276480, 0.481440, 0.950640}, {0.276030, 0.491320, 0.958570},

{0.275430, 0.501150, 0.965940}, {0.274690, 0.510940, 0.972750},

{0.273810, 0.520690, 0.978990}, {0.272730, 0.530400, 0.984610},

{0.271060, 0.540150, 0.989300}, {0.268780, 0.549950, 0.993030},

{0.265920, 0.559790, 0.995830}, {0.262520, 0.569670, 0.997730},

{0.258620, 0.579580, 0.998760}, {0.254250, 0.589500, 0.998960},

{0.249460, 0.599430, 0.998350}, {0.244270, 0.609370, 0.996970},

{0.238740, 0.619310, 0.994850}, {0.232880, 0.629230, 0.992020},

{0.226760, 0.639130, 0.988510}, {0.220390, 0.649010, 0.984360},

{0.213820, 0.658860, 0.979590}, {0.207080, 0.668660, 0.974230},

{0.200210, 0.678420, 0.968330}, {0.193260, 0.688120, 0.961900},

{0.186250, 0.697750, 0.954980}, {0.179230, 0.707320, 0.947610},

{0.172230, 0.716800, 0.939810}, {0.165290, 0.726200, 0.931610},

{0.158440, 0.735510, 0.923050}, {0.151730, 0.744720, 0.914160},

{0.145190, 0.753810, 0.904960}, {0.138860, 0.762790, 0.895500},

{0.132780, 0.771650, 0.885800}, {0.126980, 0.780370, 0.875900},

{0.121510, 0.788960, 0.865810}, {0.116390, 0.797400, 0.855590},

{0.111670, 0.805690, 0.845250}, {0.107380, 0.813810, 0.834840},

{0.103570, 0.821770, 0.824370}, {0.100260, 0.829550, 0.813890},

{0.097500, 0.837140, 0.803420}, {0.095320, 0.844550, 0.792990},

{0.093770, 0.851750, 0.782640}, {0.092870, 0.858750, 0.772400},

{0.092670, 0.865540, 0.762300}, {0.093200, 0.872110, 0.752370},

{0.094510, 0.878440, 0.742650}, {0.096620, 0.884540, 0.733160},

{0.099580, 0.890400, 0.723930}, {0.103420, 0.896000, 0.715000},

{0.108150, 0.901420, 0.705990}, {0.113740, 0.906730, 0.696510},

{0.120140, 0.911930, 0.686600}, {0.127330, 0.917010, 0.676270},

{0.135260, 0.921970, 0.665560}, {0.143910, 0.926800, 0.654480},

{0.153230, 0.931510, 0.643080}, {0.163190, 0.936090, 0.631370},

{0.173770, 0.940530, 0.619380}, {0.184910, 0.944840, 0.607130},

{0.196590, 0.949010, 0.594660}, {0.208770, 0.953040, 0.581990},

{0.221420, 0.956920, 0.569140}, {0.234490, 0.960650, 0.556140},

{0.247970, 0.964230, 0.543030}, {0.261800, 0.967650, 0.529810},

{0.275970, 0.970920, 0.516530}, {0.290420, 0.974030, 0.503210},

{0.305130, 0.976970, 0.489870}, {0.320060, 0.979740, 0.476540},

{0.335170, 0.982340, 0.463250}, {0.350430, 0.984770, 0.450020},

{0.365810, 0.987020, 0.436880}, {0.381270, 0.989090, 0.423860},

{0.396780, 0.990980, 0.410980}, {0.412290, 0.992680, 0.398260},

{0.427780, 0.994190, 0.385750}, {0.443210, 0.995510, 0.373450},

{0.458540, 0.996630, 0.361400}, {0.473750, 0.997550, 0.349630},

{0.488790, 0.998280, 0.338160}, {0.503620, 0.998790, 0.327010},

{0.518220, 0.999100, 0.316220}, {0.532550, 0.999190, 0.305810},

{0.546580, 0.999070, 0.295810}, {0.560260, 0.998730, 0.286230},

{0.573570, 0.998170, 0.277120}, {0.586460, 0.997390, 0.268490},

{0.598910, 0.996380, 0.260380}, {0.610880, 0.995140, 0.252800},

{0.622330, 0.993660, 0.245790}, {0.633230, 0.991950, 0.239370},

{0.643620, 0.989990, 0.233560}, {0.653940, 0.987750, 0.228350},

{0.664280, 0.985240, 0.223700}, {0.674620, 0.982460, 0.219600},

{0.684940, 0.979410, 0.216020}, {0.695250, 0.976100, 0.212940},

{0.705530, 0.972550, 0.210320}, {0.715770, 0.968750, 0.208150},

{0.725960, 0.964700, 0.206400}, {0.736100, 0.960430, 0.205040},

{0.746170, 0.955930, 0.204060}, {0.756170, 0.951210, 0.203430},

{0.766080, 0.946270, 0.203110}, {0.775910, 0.941130, 0.203100},

{0.785630, 0.935790, 0.203360}, {0.795240, 0.930250, 0.203860},

{0.804730, 0.924520, 0.204590}, {0.814100, 0.918610, 0.205520},

{0.823330, 0.912530, 0.206630}, {0.832410, 0.906270, 0.207880},

{0.841330, 0.899860, 0.209260}, {0.850100, 0.893280, 0.210740},

{0.858680, 0.886550, 0.212300}, {0.867090, 0.879680, 0.213910},

{0.875300, 0.872670, 0.215550}, {0.883310, 0.865530, 0.217190},

{0.891120, 0.858260, 0.218800}, {0.898700, 0.850870, 0.220380},

{0.906050, 0.843370, 0.221880}, {0.913170, 0.835760, 0.223280},

{0.920040, 0.828060, 0.224560}, {0.926660, 0.820250, 0.225700},

{0.933010, 0.812360, 0.226670}, {0.939090, 0.804390, 0.227440},

{0.944890, 0.796340, 0.228000}, {0.950390, 0.788230, 0.228310},

{0.955600, 0.780050, 0.228360}, {0.960490, 0.771810, 0.228110},

{0.965070, 0.763520, 0.227540}, {0.969310, 0.755190, 0.226630},

{0.973230, 0.746820, 0.225360}, {0.976790, 0.738420, 0.223690},

{0.980000, 0.730000, 0.221610}, {0.982890, 0.721400, 0.219180},

{0.985490, 0.712500, 0.216500}, {0.987810, 0.703300, 0.213580},

{0.989860, 0.693820, 0.210430}, {0.991630, 0.684080, 0.207060},

{0.993140, 0.674080, 0.203480}, {0.994380, 0.663860, 0.199710},

{0.995350, 0.653410, 0.195770}, {0.996070, 0.642770, 0.191650},

{0.996540, 0.631930, 0.187380}, {0.996750, 0.620930, 0.182970},

{0.996720, 0.609770, 0.178420}, {0.996440, 0.598460, 0.173760},

{0.995930, 0.587030, 0.168990}, {0.995170, 0.575490, 0.164120},

{0.994190, 0.563860, 0.159180}, {0.992970, 0.552140, 0.154170},

{0.991530, 0.540360, 0.149100}, {0.989870, 0.528540, 0.143980},

{0.987990, 0.516670, 0.138830}, {0.985900, 0.504790, 0.133670},

{0.983600, 0.492910, 0.128490}, {0.981080, 0.481040, 0.123320},

{0.978370, 0.469200, 0.118170}, {0.975450, 0.457400, 0.113050},

{0.972340, 0.445650, 0.107970}, {0.969040, 0.433990, 0.102940},

{0.965550, 0.422410, 0.097980}, {0.961870, 0.410930, 0.093100},

{0.958010, 0.399580, 0.088310}, {0.953980, 0.388360, 0.083620},

{0.949770, 0.377290, 0.079050}, {0.945380, 0.366380, 0.074610},

{0.940840, 0.355660, 0.070310}, {0.936120, 0.345130, 0.066160},

{0.931250, 0.334820, 0.062180}, {0.926230, 0.324730, 0.058370},

{0.921050, 0.314890, 0.054750}, {0.915720, 0.305300, 0.051340},

{0.910240, 0.295990, 0.048140}, {0.904630, 0.286960, 0.045160},

{0.898880, 0.278240, 0.042430}, {0.892980, 0.269810, 0.039930},

{0.886910, 0.261520, 0.037530}, {0.880660, 0.253340, 0.035210},

{0.874220, 0.245260, 0.032970}, {0.867600, 0.237300, 0.030820},

{0.860790, 0.229450, 0.028750}, {0.853800, 0.221700, 0.026770},

{0.846620, 0.214070, 0.024870}, {0.839260, 0.206540, 0.023050},

{0.831720, 0.199120, 0.021310}, {0.823990, 0.191820, 0.019660},

{0.816080, 0.184620, 0.018090}, {0.807990, 0.177530, 0.016600},

{0.799710, 0.170550, 0.015200}, {0.791250, 0.163680, 0.013870},

{0.782600, 0.156930, 0.012640}, {0.773770, 0.150280, 0.011480},

{0.764760, 0.143740, 0.010410}, {0.755560, 0.137310, 0.009420},

{0.746170, 0.130980, 0.008510}, {0.736610, 0.124770, 0.007690},

{0.726860, 0.118670, 0.006950}, {0.716920, 0.112680, 0.006290},

{0.706800, 0.106800, 0.005710}, {0.696500, 0.101020, 0.005220},

{0.686020, 0.095360, 0.004810}, {0.675350, 0.089800, 0.004490},

{0.664490, 0.084360, 0.004240}, {0.653450, 0.079020, 0.004080},

{0.642230, 0.073800, 0.004010}, {0.630820, 0.068680, 0.004010},

{0.619230, 0.063670, 0.004100}, {0.607460, 0.058780, 0.004270},

{0.595500, 0.053990, 0.004530}, {0.583360, 0.049310, 0.004860},

{0.571030, 0.044740, 0.005290}, {0.558520, 0.040280, 0.005790},

{0.545830, 0.035930, 0.006380}, {0.532950, 0.031690, 0.007050},

{0.519890, 0.027560, 0.007800}, {0.506640, 0.023540, 0.008630},

{0.493210, 0.019630, 0.009550}, {0.479600, 0.015830, 0.010550}};

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(static_cast<double>(i), 0.,

static_cast<double>(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(static_cast<double>(i), 0.,

static_cast<double>(n - 1), map);

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

result.emplace_back(vc);

}

return result;

}