Цветовая палитра The Matrix Trilogy Film

Etsy больше не поддерживает старые версии вашего веб-браузера, чтобы обеспечить безопасность пользовательских данных. Пожалуйста, обновите до последней версии.

Воспользуйтесь всеми преимуществами нашего сайта, включив JavaScript.

Нажмите, чтобы увеличить

В наличии остался только 1 шт.

Цена:

от €13,81

Первоначальная цена:
от 16,24 €

(скидка 15%)

Загрузка

Доступен только 1

Включая НДС (где применимо), плюс стоимость доставки

2744 продажи

|

5 из 5 звезд

Размер

Выберите размер

A4 (210 мм x 297 мм) (13,81 евро)

A3 (297 мм x 420 мм) (17,40 евро)

Выберите размер

Возможна подарочная упаковка

Исследуйте другие похожие поисковые запросы

Внесен в список 27 ноября 2022 г.

136 избранных

Информация о продавце

Сообщить об этом элементе в Etsy

Выберите причину… С моим заказом возникла проблемаОн использует мою интеллектуальную собственность без разрешенияЯ не думаю, что это соответствует политике EtsyВыберите причину…

Первое, что вы должны сделать, это связаться с продавцом напрямую.

Если вы уже это сделали, ваш товар не прибыл или не соответствует описанию, вы можете сообщить об этом Etsy, открыв кейс.

Сообщить о проблеме с заказом

Мы очень серьезно относимся к вопросам интеллектуальной собственности, но многие из этих проблем могут быть решены непосредственно заинтересованными сторонами. Мы рекомендуем связаться с продавцом напрямую, чтобы уважительно поделиться своими проблемами.

Если вы хотите подать заявление о нарушении прав, вам необходимо выполнить процедуру, описанную в нашей Политике в отношении авторских прав и интеллектуальной собственности.

Посмотрите, как мы определяем ручную работу, винтаж и расходные материалы

Посмотреть список запрещенных предметов и материалов

Ознакомьтесь с нашей политикой в ​​отношении контента для взрослых

Товар на продажу…

не ручной работы

не винтаж (20+ лет)

не ремесленные принадлежности

запрещены или используют запрещенные материалы

неправильно помечен как содержимое для взрослых

Пожалуйста, выберите причину

Расскажите нам больше о том, как этот элемент нарушает наши правила. Расскажите нам больше о том, как этот элемент нарушает наши правила.

Опасности переноса палитры. Исследуйте глубины алгоритмического… | Автор Syafiq Kamarul Azman

Исследуйте глубины алгоритмического перекрашивания в Python

Фото Стива Джонсона на Unsplash

Несколько выходных назад я хотел освежить свои методы кластеризации. Я припоминаю — из курса обработки изображений в колледже — что вы можете уменьшить количество уникальных цветов в изображении до нескольких цветов, сохранив при этом важные. Это достигается путем кластеризации k-средних значений RGB пикселей изображения. Количество цветов, которые вы хотите получить в своей сокращенной палитре, равно значению k в кластеризации k-средних; другими словами, количество центров кластеров в пространстве RGB, в которых находится ваше изображение.

Это было особенно полезно в старые времена графики видеоигр, если изображение нужно было отобразить на устройстве с ограниченным объемом памяти. Уменьшая палитру, вы можете соответствовать ограниченной цветовой палитре PAL или SECAM и т. д., поскольку на всю цветовую палитру выделяется только 8 бит или 16 бит (в отличие от повсеместно распространенного сейчас 24-битного RGB). Сегодняшнее использование? Ну, если вы особенно ностальгируете по художественности низкобитовой графики или созданию чего-то для отображения на светодиодной матрице, это может быть вариантом использования.

Играясь, я невзначай подумал: а что, если мы перенесем уменьшенную палитру одного изображения в другое? Это, казалось бы, безобидный вопрос, который расширил мои знания о цветах и ​​наборе инструментов для параллельной обработки. В этой статье я собираюсь объяснить, как можно выполнить эту искусственную задачу передачи палитры и как ее продвинуть дальше. Приготовьтесь использовать инструменты из numpy , scikit-learn и dask . Найдите код в подготовленном блокноте Colab, содержащем все, что описано в этой статье.

Итак, давайте сначала разберемся с некоторыми определениями. Что я имею в виду под палитрой , так это набор значений пикселей RGB в изображении. Это число обычно исчисляется десятками тысяч для небольшого фотографического изображения. Сокращение палитры — это алгоритмический выбор подмножества исходной палитры изображения и сопоставление всех значений пикселей в исходной палитре с ближайшими значениями в уменьшенной палитре.

Код для этого относительно прост: запустите кластеризацию k-средних для всех пикселей изображения, и полученные центры кластеров станут вашей уменьшенной палитрой. Мы должны быть осторожны, так как центры кластеров не np.uint8 тип, а скорее np.float64 . Когда мы вызываем kmn.predict(src) , все выходные значения являются числами с плавающей запятой. Простое решение этой проблемы — просто округлить эти значения до ближайшего целого числа и привести их к типу np. uint8 перед их отображением. Вот как может выглядеть сокращенный класс палитры:

Определение класса довольно простое: оно содержит количество цветов в сокращенной палитре и экземпляр sklearn.clustering.KMeans . Во-первых, у нас есть функция предварительной обработки, которая гарантирует, что изображение сформировано (каламбур) для KMeans операций. Изменение формы преобразует трехмерную матрицу W × H × C в двумерную матрицу WH × C , где W — ширина изображения, H — ширина изображения. высота изображения и C — это три цветовых канала RGB. Затем функция KMeansReducedPalette.fit() работает как оболочка для функции KMeans.fit() , которая создает центры кластеров в пространстве RGB. Наконец, Функция recolor() преобразует исходную палитру изображения в уменьшенную палитру подобранного изображения. Давайте рассмотрим несколько примеров сокращения палитры:

Различные уровни уменьшения палитры цветка. Исходное фото Оли Гожи на Unsplash

Красиво, правда? Даже с уменьшенной палитрой в изображении все еще есть много очарования. Я бы сказал, что многое говорит о манерах фотографа. Один из способов визуализировать эти кластеры — просто нарисовать их график рассеивания. Наши данные здесь представляют собой уникальные значения RGB изображения в трех измерениях: одно измерение для каждого цветового канала. Это очень хорошо подходит для трехмерной точечной диаграммы:

Диаграмма рассеяния 1000 случайных цветов в цветке Гожи в пространстве RGB с 8 центроидами, отмеченными красным крестом

В 8 цветах есть относительно рыхлые кластеры, но сравнивая кластеры, окрашенные центроидом, по сравнению с исходными цветами, я думаю, что кластеры довольно хороши. Цвета не расходятся далеко, хотя есть светло-зеленые, которые отливают серовато-зелеными. С большим количеством точек кластеры будут более репрезентативными для основных цветов.

Теперь займемся второй задачей: переносом уменьшенной палитры одного изображения в другое. Оказывается, это относительно просто, нам не нужно никакого дополнительного программирования, кроме передачи целевого изображения в палитру recolor() функция. Рассмотрим некоторые переносы:

Перенос уменьшенной палитры цветка Гожи на другие изображения. Слева направо исходное изображение MIO ITO, Daniel Roe и Carles Rabada на Unsplash

. Здесь происходит следующее: расстояние каждого пикселя в новом изображении измеряется относительно уменьшенной палитры (т. е. центров кластеров). Затем значения RGB передаваемого пикселя меняются местами с ближайшим центром кластера в палитре. Вот почему в ситуациях, когда исходное изображение не имеет большого количества цветов или уменьшенная палитра слишком мала, мы получаем некоторые мультяшные эффекты на общем изображении. Это связано с тем, что цвета в передаваемом изображении не получают достаточно хорошего цвета для замены, а вместо этого выбирают ближайший центр кластера, несмотря на то, что он очень удален от значения передаваемого пикселя.

Давайте немного поэкспериментируем, прежде чем двигаться дальше. Мы сделали кластеризацию на основе всех пикселей изображения, но на самом деле не все пиксели уникальны. Скорее всего, вокруг определенной области изображения могут быть десятки или сотни одинаковых значений RGB пикселей (особенно для статического фона, неба и т.п.). Естественно, это сместит центры кластеров вокруг более обильных цветов изображения; это цвета, которые сразу появляются на исходном изображении, делая их визуально заметными. Ради забавы давайте поработаем и выполним кластеризацию только уникальных пикселей изображения (а не всех пикселей) и предоставим каждому из них равные возможности. Для этого мы создадим новый класс:

Новый класс наследует класс KMeansReducedPalette , что значительно упрощает дальнейшую работу: любые дополнительные функции, добавляемые в KMeansReducedPalette , будут включены в класс UniqueKMeansReducedPalette . Функция fit() переопределяется, чтобы подогнать палитру под набор уникальных пикселей изображения. Это не сильно увеличивает общий объем вычислений, поскольку кластеризация k-средних занимает O (nk) времени, что дороже, чем поиск уникальных пикселей, который занимает всего O (n) для изображения с n пикселями. Давайте сравним результаты:

Сравнение уменьшения палитры всего изображения и уменьшения палитры уникальных пикселей на разных изображениях

Издалека есть очень небольшие различия: кажется, что распределение цветов в уменьшенных палитрах примерно одинаковое, что можно отнести к начальные условия алгоритма кластеризации k-средних.

На мой взгляд, есть тонкая разница в качестве цветов. Кластеризация всего изображения привела к немного более насыщенной уменьшенной палитре по сравнению с кластеризацией уникальных пикселей, которая более приглушена. В верхнем ряду немного больше контраста по сравнению с нижними рядами. Я связываю это с результатом кластеризации в пространстве уникальных цветов: по сути, усреднение значений пикселей, окружающих локус, без взвешивания более распространенных цветов.

Мы могли бы приступить к численному анализу цветовых метрик, чтобы проверить это (что я и делал бесконечно), но это было бы слишком далеко от первоначальной цели этой статьи, состоящей в том, чтобы просто поэкспериментировать с передачей палитры, поэтому я оставлю это как упражнение для смелых среди вас. Вот некоторые ресурсы, которые я прочитал: цветовое зрение, расчет цветности.

Давайте еще раз посмотрим, к чему приводит кластеризация k-средних. После кластеризации нам предоставляется k центров кластеров, которые определяют метку других пикселей, окружающих его. Если точка находится ближе к одному центроиду по сравнению со всеми другими центроидами, точка группируется в этот центроид. По сути, это создает k разделов в пространстве данных; границы которого можно визуализировать с помощью диаграммы Вороного. На точечной диаграмме ранее мы частично видим границы разбиения в трехмерном пространстве. Поскольку построить трехмерную диаграмму Вороного сложно, давайте обратимся к PCA, уменьшим пространство до двухмерного и построим тесселяцию Вороного.

Мозаика Вороного из 8 кластеров RGB-пикселей цветка Гожи в 2D с помощью PCA-разложения

Из графика видно, что разделы представляют собой 2D-геометрические многоугольники. В исходном трехмерном пространстве эти разделы были бы трехмерными многогранниками. Кроме того, PCA «лжет» о некоторых точках, особенно на границах, поскольку точки были спроецированы в более низкое измерение (следовательно, теряется информация). Старайтесь не слишком внимательно изучать двумерную диаграмму Вороного .

Зная границы, мы можем случайным образом выбирать значения RGB внутри раздела в качестве перекрашивания нашего нового изображения, а не зависеть исключительно от значения RGB центроида. Это дает нам больше разнообразия для перекрашивания наших изображений. Поскольку у нас уже есть центроиды, мы можем начать с них и делать небольшие шаги, чтобы получить случайные значения RGB. Этот процесс называется случайное блуждание .

Вариант случайного блуждания 1: ходить везде

Давайте разберемся с одним из вариантов случайного блуждания, который заключается в перемещении на 1 единицу интенсивности в любом направлении RGB. Это случайное блуждание потенциально может исследовать все 16 777 216 цветов (если вы сделаете достаточно шагов). Давайте закодируем это:

Везде перекрашивание случайным блужданием, которое начинается с центроидов k-средних

Функция random_walk_recolor() принимает изображение и максимальное количество шагов, чтобы уйти от центра кластера. Во-первых, мы перекрашиваем пиксели, как мы это делали в функция recolor() , которая хранится в качестве начальных точек ( start ). Затем мы инициализируем массив различий ( diff ), который будет определять расстояние от начальных точек для каждого цветового канала.

Затем мы зацикливаемся до максимального количества шагов, которые мы хотим сделать, и случайным образом проходим 1 единицу в одном канале. Это хранится в walk : мы случайным образом индексируем идентификационную матрицу 3×3, используя np.eye() и np.random.randint() для каждого пикселя. Например, изображение с 9 пикселями:

 walk = [[ 0, 0, 1], 
 [ 0, 0, 1], 
 [ 1, 0, 0], 
 [ 0, 1, 0], 
 [ 0, 0, 1], 
 [ 0, 1, 0], 
 [ 1, 0, 0], 
 [ 1, 0, 0], 
 [ 1, 0, 0]] 

Затем нам нужно случайным образом выберите знак блуждания (в положительном или отрицательном направлении), используя np.random.choice() в наборе {-1, 1} , который затем преобразует массив блуждания в:

 walk = [[ 0, 0, 1], 
 [0, 0,-1], 
 [-1, 0, 0], 
 [0,-1, 0], 
 [0, 0, 1], 
 [0,-1, 0], 
 [ 1, 0, 0], 
 [-1, 0, 0], 
 [-1, 0, 0]] 

Наконец, мы добавляем обход в массив diff . Если мы повторим это достаточное количество раз, мы получим некоторое случайное распределение шагов от центров кластеров, самое большее максимальное количество шагов, которое мы желаем. Окончательное случайное блуждание diff может быть примерно таким для максимального размера шага 3:

 walk = [[ 0, 0, 1], 
 [0, 0,-2], 
 [-1, 1, 0], 
 [0,-1,-1], 
 [0, 0, 3], 
 [0,-1, 0], 
 [ 2, 0, 1], 
 [ 0, 0, 0], 
 [-1, -1, 1]] 

Из-за случайности случайного блуждания мы можем даже не отойти от центра скопления; однако это маловероятно для большого размера шага. Окончательное перекрашивание — это просто отправная точка перекрашивания методом k-средних плюс прогулка. Как выглядит перекрашивание разных значений шага с 32-цветной палитрой на другом передающем изображении? Для этого примера я перенесу палитру взморья Рабады на цветок Гожи.

Шумные случайные блуждания на разных максимальных дистанциях ходьбы

Что ж, похоже, что мы только что применили к нему немного шума, но сохраняем общий перенос. Шум становится довольно подавляющим на очень больших расстояниях. Но все же это круто.

Вариант случайного блуждания 2: блуждание по окрестностям

Первый вариант случайного блуждания не гарантирует посещение уникальных пикселей исходного изображения. На самом деле, он может даже выйти за границы раздела, о котором мы упоминали ранее. Что, если бы мы вместо этого хотели обойти только соседние пиксели к центру кластера? Кроме того, мы хотели бы остаться внутри раздела; мы же не хотим сейчас бродить не по тому району, не так ли?

Чтобы найти случайный пиксель, соседствующий с центроидом, нам нужно вычислить расстояние каждого пикселя в кластере до центроида и случайным образом выбрать ближайших соседей с некоторым максимальным шагом обхода. Одна оптимизация, которую мы можем сделать в этом конкретном сценарии, заключается в предварительном расчете этих расстояний, поскольку они никогда не изменятся после выполнения кластеризации.

Стратегия здесь состоит в том, чтобы выполнить все расчеты расстояния для всех пикселей в каждом кластере до ближайшего центра тяжести в течение fit() , отсортируйте пиксели по их расстоянию до центроида в порядке возрастания и сохраните их, чтобы их можно было использовать позже. Вот код для этого:

Это делает цикл по количеству кластеров в палитре и сохраняет расстояния для каждого пикселя до центра кластера. Во-первых, мы получаем все пиксели исходного изображения, которые находятся в текущем кластере ( пикселей_ci ), и вычисляем евклидово расстояние до центра кластера ( Distances_ci 9009).8). Затем мы используем np.argsort() , чтобы получить отсортированные индексы для расстояний, а затем используем его для индексации пикселей_ci . Теперь у нас осталась матрица пикселей в порядке возрастания расстояния вниз по строкам.

Чтобы выполнить случайное блуждание, мы просто выбираем случайное число до максимального значения индекса (случайное число представляет собой количество шагов). Нам также нужно убедиться, что индекс не превышает размер кластера. Вот код для перекрашивания этого случайного блуждания по окрестностям:

Код относительно прост: сначала мы перекрашиваем, как для другого случайного обхода, а затем перебираем каждый кластер и выбираем случайного ближайшего соседа. Мы использовали np.random.randint() для генерации случайных индексов для выбора ближайшего соседа. Поскольку случайная функция достигает максимума при max_steps , мы не будем исследовать дальше соседа, который оценивается ниже значения max_steps . Кроме того, установка максимального случайного числа на минимальное значение между n_neighbors и max_steps гарантируют, что вы находитесь в пределах окрестности. В результате получаются случайные блуждания, как показано ниже:

Шумные прогулки по окрестностям на разных максимальных расстояниях

Шум намного более тонкий и незаметный на меньших расстояниях. «Семантика» шума также более разумна: он не слишком далеко отклоняется от того, что должен представлять исходный пиксель. Это почти как если бы вы получили фотографию с зеркальной камеры с плохим сенсором или каким-то высоким значением ISO. Хороший!

Все техники, которые мы видели, уменьшают палитру перед переносом. Возможно, это гораздо проще сделать, так как нам нужно только сравнить n пикселей с k центрами кластеров. Что, если вместо этого мы захотим передать палитру всех уникальных пикселей? Что ж, если мы предположили, что у нас одинаковый размер палитры в исходном изображении и передающем изображении, нам нужно будет выполнить сравнение O ( n ²), чтобы найти ближайший пиксель передающего изображения и исходного изображения.

Это проблематично: наши рабочие изображения размером 320 на 480 пикселей имеют порядка 10⁵ уникальных пикселей. Попарное сравнение даст матрицу порядка (10⁵)² или 10¹⁰ во время вычисления. Ясно, что это не может поместиться в память, если у вас нет большого объема памяти (а у большинства обычных компьютеров ее нет). Мы могли бы использовать циклы, но циклы Python, как известно, медленны.

Идеальная золотая середина может быть достигнута, если мы развернем некоторую форму векторизованных вычислений (которая быстрее, чем циклы) вместе с фрагментацией массива. Разделение на фрагменты делит большое векторизованное вычисление на более мелкие управляемые вычисления и собирает части, чтобы сформировать окончательный выходной массив. Библиотека dask — это популярная реализация на Python, которая позволит нам это сделать, сохраняя при этом синтаксис numpy в коде. dask также обеспечивает распараллеливание, что означает, что мы можем потенциально перенести эти вычисления на разные машины или полностью использовать все ядра компьютера. Вот как выглядит код:

Весь класс переноса палитры имеет очень простой конструктор. Конструктору требуется значение размера фрагмента (по умолчанию 1024). Это компенсирует вычислительную память и распараллеливание на небольшом компьютере, но вы можете настроить большие значения, если у вас больше памяти. На этапе подбора просто сохраняются все уникальные пиксели изображения. Мы берем только уникальные пиксели исходного изображения, чтобы свести к минимуму вычисления, поскольку мы можем сопоставить все пиксели передаваемого изображения с подмножеством исходных пикселей. Это сопоставление будет создано, когда мы выполним перекрасить() .

Суть класса — функция recolor() . Сначала мы предварительно обрабатываем передаваемое изображение и собираем все уникальные пиксели. Затем мы создаем объект dask.array.core.Array для уникальных пикселей исходного изображения и передаваемого изображения. Передаваемое изображение преобразуется в трехмерный массив для векторизации расчета попарных разностей.

Вычислительная нагрузка

Давайте остановимся здесь и поймем вычислительную нагрузку, которую мы несем. dask имеет функцию визуализации памяти, выделенной для шага вычислений в среде ноутбука. Если разместить следующий код для исходного и передающего изображения:

В выходной ячейке блокнота отобразятся следующие изображения:

Dask визуализация вычислений попарной разности и выделение 77GB в процессе!

Понятно, что исходный и передающий даск массив уникальных пикселей занимают очень мало памяти. Однако в тот момент, когда мы выполняем попарную разность, нам нужно будет выделить 77,29ГБ памяти. В традиционной настройке NumPy это либо приведет к сбою, либо NumPy выдаст сообщение об ошибке, в котором говорится, что он не может выделить столько памяти. Это когда dask сияет своими возможностями фрагментации, позволяющими вычислять такие массивные массивы без фактического выделения всей этой памяти.

Разрешение нагрузки

В конечном счете, нам не нужны попарные расстояния, нам нужны только передающие пиксели, которые имеют наименьшее расстояние до исходных пикселей. Возвращаясь к коду, мы выполняем вычисление евклидова расстояния и сохраняем только индекс передающего пикселя, который имеет наименьшее расстояние до исходных пикселей, таким образом оставляя гораздо меньший выходной массив.

Чтобы запустить вычисление, мы должны вызвать idxs_da.compute() , и мы будем использовать встроенный ProgressBar() , который поставляется с dask для отображения хода вычисления. После того, как мы вычислили индексы, мы создаем сопоставление словаря из одного исходного пикселя RGB в ближайший передающий пиксел RGB. Словари Python используют хеширование, что означает, что поиск выполняется очень быстро (теоретически это занимает постоянное время). Наконец, чтобы передать пиксели, мы перебираем все пиксели в передаваемом изображении и используем сопоставление пикселей для замены значений пикселей RGB.

Давайте посмотрим некоторые переводы! На этот раз я буду использовать цветы Ито и перенесу палитру на остальные изображения.

Перенос всей палитры с одного изображения на три других

Прекрасные результаты. Перенесенные изображения имеют более естественную окраску, меньше блочности и очень похожи на оригиналы. Делая этот перенос, я не мог не заметить, что у цветка Гожи действительно могли быть более удачные переносы. В цветке Ито определенно есть розовые или красноватые оттенки, которые были бы лучше для передачи, но, возможно, они были слишком далеко. Чего я не осознавал, так это слабости нашего метода: евклидова расстояния.

Вот проблема: евклидово расстояние предполагает, что цвета равномерно распределены вокруг трехмерного куба 255 на 255 на 255. Расстояния между этими точками будут определять, насколько далеко цвета находятся друг от друга. Однако, перцептивно , мы по-разному воспринимаем расстояния. Вопрос «насколько далеко один красный оттенок от другого?» — это очень глубокий вопрос, но достаточно сказать, что евклидово расстояние не соответствует нашему дифференциальному восприятию.

Итак, я отправился рыскать в Интернете в поисках ответа на вопрос о мере расстояния, которую легко вычислить, но в какой-то степени она выполняет свою работу. На этом сайте подробно описан расчет с использованием пространства RGB для более «правильного» воспринимаемого цветового расстояния. Я оставлю дискуссию самому сайту, но в целом автор идет на компромисс между преобразованием в другое цветовое пространство (например, YUV или CIELAB) и учетом поправочных факторов, которые могут повлиять на измерение расстояния. Кроме того, он «более стабилен» с точки зрения значений расстояния, которые выдает алгоритм. Расчет расстояния следующий (адаптировано с сайта):

Уравнение цветового расстояния, адаптированное с этого сайта

В уравнении C — это вектор RGB пикселя, число в нижнем индексе указывает, на какой пиксель мы ссылаемся (сравнивая пиксель 1 и пиксель 2), а буква в нижнем индексе — это цветовой канал. пикселя. Расчет сначала делает среднее значение красных значений между двумя пикселями. Затем мы вычисляем разницу между каждым цветовым компонентом пикселей. Окончательное расстояние в основном представляет собой взвешенное евклидово расстояние, при этом веса определяются по-разному для каждого цветового компонента.

Мы можем адаптировать код с сайта, который использует некоторые приемы побитовых операций, в Python. Для справки, вот определение функции C++ с сайта:

Комментарии к вычислению

Чтобы ускорить вычисления, я не буду в конце вычислять квадратный корень, не нарушая вычисления расстояния. Это потому, что квадратный корень является монотонно возрастающей функцией для всех положительных чисел. Поскольку значения квадратного корня из ΔC всегда положительны, все, что нам нужно для сравнения, чтобы получить ближайший пиксель, — это член суммы в пределах квадратного корня. Кроме того, поскольку мы используем dask , нам также нужно будет закодировать векторизации. Обратите внимание, что мы приводим тип к типу np. long , поэтому мы можем иметь дело с квадратами ΔR , ΔG, и ΔB .

Я надеюсь, что код не требует пояснений, если вы можете сделать связи с кодом C++ выше и исходными уравнениями. Суть в том, что мы векторизовали вычисление разницы между каждым цветовым каналом, а также реализовали побитовые операции в соответствии с исходным кодом. Как выглядят выходы?

Передача всей палитры с использованием цветового расстояния

Это сработало для цветка Гожи, теперь передается более красноватый оттенок вместо мягкого коричнево-коричневого цвета, который давал евклидово расстояние. В остальном цвета побережья Рабады и гор Роу примерно одинаковы, есть очень тонких различий в цветовых тонах, но ничего не выделяется. Я оставлю вас с этим: наше визуальное восприятие цвета определенно отличается от структур данных, которые мы выбрали для их воплощения.

То есть это от меня на переносе палитры. Мне нравится делать такие забавные проекты на выходных, как эти, и тщательно их документировать.