Рисуем постепенно: Рисуем героев Dota 2 поэтапно 10+ уроков

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

Я не знаю о существующей функции OpenCV для эффективного выполнения этого, но StackOverflow спасает положение — уже есть связанный вопрос с ответом, связанным со ссылкой на полезную статью, в которой обсуждается проблема. Мы можем использовать эти ресурсы для следующей реализации Python:

 def ellipse_bbox(h, k, a, b, theta):
    ux = a * math.cos(тета)
    uy = a * math.sin(тета)
    vx = b * math.cos (тета + math.pi / 2)
    vy = b * math.sin (тета + math.pi / 2)
    box_halfwidth = np.ceil (math.sqrt (ux ** 2 + vx ** 2))
    box_halfheight = np.  ceil (math.sqrt (uy ** 2 + vy ** 2))
    return ((int(h - box_halfwidth), int(k - box_halfheight))
        , (int(h + box_halfwidth), int(k + box_halfheight)))
 

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

Затем мы можем использовать функцию следующим образом:

 # Вычислить размер изображения, необходимый для рисования этого и центрирования эллипса
_, (h, k) = ellipse_bbox(0, 0, a, b, theta) # Центр эллипса
h += 2 # Добавляем небольшое поле
k += 2 # Добавляем небольшое поле
ширина, высота = (h*2+1, k*2+1) # Размер холста
 

Второй шаг — создание слоя прозрачности. Это одноканальное 8-битное изображение, где черный цвет (0) представляет собой полностью прозрачное изображение, а белый (255) — полностью непрозрачные пиксели. Эта задача довольно проста, так как мы можем использовать

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

• кортеж, представляющий центр повернутого прямоугольника (координаты x и y)
• кортеж, представляющий размер повернутого прямоугольника (его ширину и высоту)
• угол поворота в градусах

Вот код:

 ellipse_outer = ((h,k), (a*2, b*2), math.степени(тета))
прозрачность = np.zeros((высота, ширина), np.uint8)
cv2.ellipse(прозрачность, ellipse_outer, 255, -1, cv2.LINE_AA)
 

… и получаемое изображение:

В качестве третьего шага мы создаем одноканальное изображение (оттенки серого или интенсивность), содержащее желаемый

На этот раз Mathematics StackExchange спасает положение: есть вопрос, точно соответствующий нашей проблеме, и ответ, содержащий это полезное уравнение: сторона стороны оценивается как 1 по периметру эллипса. Это 0 в центре и линейно увеличивается к 1 по периметру, а затем дальше от него.

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

Давайте начнем с простой реализации только для Python (например, при ручном переборе отдельных элементов numpy.array , представляющий наше изображение) для расчета весов. Однако, поскольку мы ленивые программисты, мы будем использовать Numpy для преобразования рассчитанного веса в изображение градации, используя векторизованное вычитание вместе с numpy.clip .

Вот код:

 def make_gradient_v1(width, height, h, k, a, b, theta):
    # Предварительный расчет констант
    ст, кт = math. sin(тета), math.cos(тета)
    аа, бб = а**2, б**2
    веса = np.zeros ((высота, ширина), np.float64)
    для y в диапазоне (высоте):
        для x в диапазоне (ширине):
            веса[y,x] = ((((x-h) * ct + (y-k) * st) ** 2) / aa
                +(((х-з)*ст-(у-к)*ст)**2)/бб)
            
    вернуть np.clip (1.0 - веса, 0, 1)
 

… и изображение, которое он создает:

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

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

 y,x = np.mgrid[:height,:width]
 

для генерации необходимых нам входных массивов. Однако давайте заметим, что мы никогда не используем x и y напрямую — мы всегда компенсируем их константой. Давайте избежим этой операции смещения, создав x-h и y-k …

 y,x = np.mgrid[-k:height-k,-h:width-h]
 

Мы снова можем предварительно вычислить 4 константы, а кроме того, остальное — просто векторизованное сложение, вычитание, умножение, деление и степени, которые предоставляются Numpy как векторизованные операции (т.е. намного быстрее).

 def make_gradient_v2 (ширина, высота, h, k, a, b, тета):
    # Предварительный расчет констант
    ст, кт = math.sin(тета), math.cos(тета)
    аа, бб = а**2, б**2
        
    # Генерация (x,y) массивов координат
    y,x = np.mgrid[-k:высота-k,-h:ширина-h]
    # Рассчитываем вес каждого пикселя
    веса = (((x * ct + y * st) ** 2) / aa) + (((x * st - y * ct) ** 2) / bb)
    вернуть np. clip (1.0 - веса, 0, 1)
 

Сценарий, использующий эту версию, занимает около 30% времени по сравнению со сценарием, использующим только Python. Ничего ошеломляющего, но результат тот же, и эта задача кажется чем-то, что вам не нужно делать часто, так что мне этого достаточно.

Если вы [читатель] знаете более быстрый способ, опубликуйте его как ответ.

Теперь у нас есть изображение с плавающей запятой, интенсивность которого находится в диапазоне от 0,0 до 1,0. Чтобы сгенерировать наш результат, мы хотим иметь 8-битное изображение со значениями от 0 до 255.

 интенсивность = np.uint8 (make_gradient_v2 (ширина, высота, h, k, a, b, тета) * 255)
 

Четвертый шаг — нарисуйте внутренний эллипс . Это просто, мы делали это раньше. Нам просто нужно масштабировать оси соответствующим образом.

 ellipse_inner = ((h,k), (a*2*inner_scale, b*2*inner_scale), math.степени(тета))
cv2.ellipse(интенсивность, ellipse_inner, 255, -1, cv2. LINE_AA)
 

Это дает нам следующее изображение интенсивности:

Пятый шаг — мы почти закончили. Все, что нам нужно сделать, это объединить слои интенсивности и прозрачности в изображение BGRA, а затем сохранить его в формате PNG.

 результат = cv2.merge([интенсивность, интенсивность, интенсивность, прозрачность])
 

NB: Использование одинаковой интенсивности для красного, зеленого и синего дает нам только оттенки серого.

Когда мы сохраняем результат, мы получаем следующее изображение:

Учитывая, что я предположил параметры, которые вы использовали для создания образца изображения, я бы сказал, что результат моего скрипта чертовски близок. Он также работает достаточно быстро — если вы хотите чего-то лучшего, вы, вероятно, не сможете избежать приближения к «голому железу» (C, C++ и т. д.). Более разумный подход или, возможно, графический процессор могли бы работать еще лучше. Стоит поэкспериментировать с. ..

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

И полный сценарий, который я использовал для написания этого:

 import cv2
импортировать numpy как np
импортировать математику
# ================================================ ============================
def ellipse_bbox (ч, к, а, б, тета):
    ux = a * math.cos(тета)
    uy = a * math.sin(тета)
    vx = b * math.cos (тета + math.pi / 2)
    vy = b * math.sin (тета + math.pi / 2)
    box_halfwidth = np.ceil (math.sqrt (ux ** 2 + vx ** 2))
    box_halfheight = np.ceil (math.sqrt (uy ** 2 + vy ** 2))
    return ((int(h - box_halfwidth), int(k - box_halfheight))
        , (int(h + box_halfwidth), int(k + box_halfheight)))
# -------------------------------------------------- ---------------------------
        
# Повернутый эллиптический градиент - медленный подход только для Python
def make_gradient_v1 (ширина, высота, h, k, a, b, тета):
    # Предварительный расчет констант
    ст, кт = math. sin(тета), math.cos(тета)
    аа, бб = а**2, б**2
    веса = np.zeros ((высота, ширина), np.float64)
    для y в диапазоне (высоте):
        для x в диапазоне (ширине):
            веса[y,x] = ((((x-h) * ct + (y-k) * st) ** 2) / aa
                +(((х-з)*ст-(у-к)*ст)**2)/бб)
            
    вернуть np.clip (1.0 - веса, 0, 1)
# -------------------------------------------------- ---------------------------
    
# Повернутый эллиптический градиент - более быстрый, векторизованный подход numpy
def make_gradient_v2 (ширина, высота, h, k, a, b, тета):
    # Предварительный расчет констант
    ст, кт = math.sin(тета), math.cos(тета)
    аа, бб = а**2, б**2
        
    # Генерация (x,y) массивов координат
    y,x = np.mgrid[-k:высота-k,-h:ширина-h]
    # Рассчитываем вес каждого пикселя
    веса = (((x * ct + y * st) ** 2) / aa) + (((x * st - y * ct) ** 2) / bb)
    вернуть np.clip (1.0 - веса, 0, 1)
# ================================================ ============================
def draw_image(a, b, theta, inner_scale, save_intermediate=False):
    # Рассчитать размер изображения, необходимый для рисования этого и центрирования эллипса
    _, (h, k) = ellipse_bbox(0,0,a,b,theta) # Центр эллипса
    h += 2 # Добавляем небольшое поле
    k += 2 # Добавляем небольшое поле
    ширина, высота = (h*2+1, k*2+1) # Размер холста
    # Параметры, определяющие два эллипса для OpenCV (структура RotatedRect)
    ellipse_outer = ((h,k), (a*2, b*2), math. степени(тета))
    ellipse_inner = ((h,k), (a*2*inner_scale, b*2*inner_scale), math.степени(тета))
    # Создаем слой прозрачности -- внешний эллипс заполнен и сглажен.
    прозрачность = np.zeros((высота, ширина), np.uint8)
    cv2.ellipse(прозрачность, ellipse_outer, 255, -1, cv2.LINE_AA)
    если save_intermediate:
        cv2.imwrite("eligrad-t.png", прозрачность) # Сохранить промежуточный файл для демонстрации
    # Генерируем градиент и масштабируем его до 8-битного диапазона оттенков серого
    интенсивность = np.uint8 (make_gradient_v1 (ширина, высота, h, k, a, b, тета) * 255)
    если save_intermediate:
        cv2.imwrite("eligrad-i1.png", Intensity) # Сохранить промежуточный файл для демонстрации
    
    # Нарисуйте промежуточный эллипс, заполненный и сглаженный
    cv2.ellipse(интенсивность, ellipse_inner, 255, -1, cv2.LINE_AA)
    если save_intermediate:
        cv2.imwrite("eligrad-i2.png", Intensity) # Сохранить промежуточный файл для демонстрации
    # Превратить его в образ BGRA
    результат = cv2. merge([интенсивность, интенсивность, интенсивность, прозрачность])
    вернуть результат
# ================================================ ============================
a, b = (360.0, 200.0) # Большая и малая полуоси
theta = math.radians(40.0) # Вращение эллипса (радианы)
inner_scale = 0.6 # Масштаб внутреннего полностью белого эллипса
    
cv2.imwrite("eligrad.png", draw_image(a, b, theta, inner_scale, True))
# ================================================ ============================
строки = []
для j в диапазоне (0, 4, 1):
    столбцы = []
    для я в диапазоне (0, 90, 10):
        плитка = np.zeros ((170, 170, 4), np.uint8)
        image = draw_image(80.0, 50.0, math.radians(i + j * 90), 0.6)
        плитка[:image.shape[0],:image.shape[1]] = изображение
        cols.append(плитка)
    rows.append (np.hstack (столбцы))
cv2.imwrite("eligrad-m.png", np.vstack(строки))
 

Примечание. Если вы обнаружите какие-либо глупые ошибки, непонятную терминологию или любые другие проблемы с этим постом, не стесняйтесь оставлять конструктивный комментарий или просто отредактируйте ответ, чтобы сделать его лучше. Я знаю, что есть способы дальнейшей оптимизации этого — пусть читатель сделает это упражнение (и, возможно, даст дополнительный ответ).

Стать художником можно постепенно и внезапно.

Я официально начал свою карьеру Fine Artist почти 10 лет назад. Потребовалось много внешней проверки и блужданий, чтобы полностью подготовить меня к прыжку. Когда я оглядываюсь назад, мне кажется, что все годы, предшествовавшие «Прыжку», были подготовкой, которая привела меня к тому короткому моменту времени, когда мой самый тихий голос объявил: « Я хочу стать художником ». Я готов .». И как только я услышал этот тихий шепот, этот звон моей собственной правды, моя жизнь изменилась. Я изменил.

В детстве я был творческим человеком, и моей первой работой был модный иллюстратор. Это превратилось в модный и текстильный дизайн и, в конечном итоге, в фэшн-фотографию. Я всегда чувствовал, что блефую в мире моды, потому что я не особенно стильный, но мне это нравилось, потому что люди веселые, и я думаю, что я двигался вперед за счет страсти других людей! Пока мне приходилось время от времени рисовать, раскрашивать и фотографировать, я был очень счастлив!

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

Моя рабочая неделя проходила в человеческом мире, и я проводил время с моими «жучками». Я держал свою растущую библиотеку личных работ очень близко, только несколько лучших друзей были посвящены в мою секретную сессию ошибок . А потом я сделал странную вещь… Я записал свою работу в несколько наград и подал заявку на стипендию. Я выиграл их всех. Я учился на семинарах Sante Fe Workshops и прилетел туда после того, как получил награду «Гуру» на PhotoShop World в Лос-Анджелесе. Это было захватывающее время!

На моем курсе была женщина, назвавшая себя «Фотохудожник». В то время я почти не встречал никого, кто называл бы себя Художником, не говоря уже о чем-то столь конкретном. Я считал ее волшебным существом… редким и неземным… и мои глаза открылись, чтобы увидеть, что существует целый мир Фотохудожников. Санте-Фе — город в Нью-Мексико, полный художественных галерей. Каждый день я заканчивал занятия и мчался в город, чтобы протиснуться в двери любой галереи, готовившейся к закрытию. И мое сердце расцвело. Я чувствую, как мой мозг просыпается, садится и замечает.

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

И когда я вышел из самолета, я объявил себе, что теперь я «Художник». Я молча принял это слово.