Рисуем постепенно: Как нарисовать розу новичку

Мы можем определить наш внешний эллипс в виде структуры 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)
 

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

В качестве третьего шага мы создаем одноканальное изображение (оттенки серого или интенсивность), содержащее желаемый повернутый эллиптический градиент . Но, прежде всего, как мы можем даже математически определить повернутый эллипс с точки зрения декартовой 9 декартовой диаграммы нашего изображения?0030 (x, y) координат, используя наши (a, b) , theta (θ) и (h, k) параметры?

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

Назовем правую часть весом за неимением лучшего термина. Поскольку он очень хорошо масштабируется от центра к краям, мы можем использовать его для расчета желаемого градиента. Наша формула дает нам белый (1,0 в случае изображения с плавающей запятой) снаружи и черный (0,0) в центре. Нам нужно обратное, поэтому мы просто вычитаем вес из 1.0 и обрезаем результат до диапазона [0.0, 1.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, поэтому мы наверняка сможем добиться большего успеха, если воспользуемся его преимуществами. Это означает векторизацию всего, что мы можем.

Прежде всего, давайте заметим, что единственным входом, который меняется, являются координаты каждого заданного пикселя. Это означает, что для векторизации нашего алгоритма нам нужны в качестве входных данных два массива (того же размера, что и изображение), содержащие x и y координаты каждого пикселя. К счастью, Numpy предоставляет нам инструмент для создания таких массивов — numpy.mgrid . Мы можем написать

 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(строки))
 

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

ios — danielgindi/Диаграммы: как рисовать постепенно слева направо

(https://github.com/danielgindi/Charts/issues/5057)

Проблема в том, что я не могу нарисовать шаг входящих данных шаг за шагом. Я не могу найти такой флаг. Теперь записи идут постепенно — не все сразу. Но sdk сразу отображает их по всей ширине представления диаграммы, несмотря на их количество. Мне нужно, чтобы они рисовали точка за точкой слева направо и только после достижения правого края, чтобы начать масштабирование. Вроде есть такой флаг bool, но мне его не удалось настроить. Буду признателен за любую помощь. Под кодом.

 импорт UIKit
импортировать диаграммы
импортировать RxSwift
импорт RxCocoa
структура ChartViewModel {
    let blueValue: Driver
}
окончательный класс ChartView: UIView {
    частный ленивый var blueSet = makeEmptySet (цвет: . синий)
    частный ленивый var blueLineCharView = makeChartView()
    частная сумка для сдачи = DisposeBag()
    
    инициализация (модель: ChartViewModel) {
        super.init(кадр: .ноль)
        настраивать()
        установка ограничений ()
        привязать (модель)
    }
    
    требуется инициализация? (кодер: NSCoder) {
        fatalError("init(coder:) не реализован")
    }
    
    настройка частной функции () {
        фоновый цвет = .clear
        addSubview (блюлайнчарвиев)
    }
    
    частная функция setupConstraints() {
        blueLineCharView.make {
            $0.edges.equalToSuperview()
        }
    }
    
    приватная функция привязки (_ модель: ChartViewModel) {
        model.blueValue.drive(onNext: {значение [weak self] в
            охранять let self = self, let value = value else { return }
            self.blueSet.append(значение)
            self.blueLineCharView.data = LineChartData(dataSet: self.blueSet)
        })
        .disposed(по: сумка)
    }
    
    частная функция makeChartView() -> LineChartView {
        пусть chartView = LineChartView()
        chartView. backgroundColor = .clear
        chartView.leftAxis.enabled = ложь
        chartView.rightAxis.enabled = ложь
        chartView.xAxis.enabled = ложь
        chartView.isUserInteractionEnabled = ложь
        chartView.legend.enabled = ложь
        chartView.dragEnabled = ложь
        возврат диаграммы
    }
    
    частная функция makeEmptySet (цвет: UIColor) -> LineChartDataSet {
        пусть set = LineChartDataSet (записи: [])
        set.drawCirclesEnabled = ложь
        set.drawValuesEnabled = ложь
        set.mode = .cubicBezier
        set.lineWidth = 2
        set.setColor(цвет)
        set.drawVerticalHighlightIndicatorEnabled = ложь
        set.drawHorizontalHighlightIndicatorEnabled = ложь
        набор возврата
    }
}
 

• ios
• swift
• графики
• uikit

Зарегистрируйтесь или войдите в систему

Опубликовать как гость

Требуется, но не отображается

Опубликовать как гость

Требуется, но не отображается

Нажимая «Опубликовать свой ответ», вы соглашаетесь с нашими условиями обслуживания и подтверждаете, что прочитали и поняли нашу политику конфиденциальности и кодекс поведения.