Рисование круга, стиль OpenGL

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

Не делая ничего необычного, что-то вроде этого должно быть хорошим началом:

int intRad = (int)rad;
int intRadSqr = (int)(rad * rad);

for (int ix = 0; ix <= intRad; ++ix)
{
    for (int jx = 0; jx <= intRad; ++jx)
    {
        if (ix * ix + jx * jx <= radSqr)
        {
            matrix[6 - ix][6 - jx] = mode;
            matrix[6 - ix][6 + jx] = mode;
            matrix[6 + ix][6 - jx] = mode;
            matrix[6 + ix][6 + jx] = mode;
        }
    }
}

Это делает всю математику в целочисленном формате и использует симметрию круга.

Изменение вышеизложенного, основываясь на отзывах в комментариях:

int intRad = (int)rad;
int intRadSqr = (int)(rad * rad);

for (int ix = 0; ix <= intRad; ++ix)
{
    for (int jx = 0; ix * ix + jx * jx <= radSqr; ++jx)
    {
        matrix[6 - ix][6 - jx] = mode;
        matrix[6 - ix][6 + jx] = mode;
        matrix[6 + ix][6 - jx] = mode;
        matrix[6 + ix][6 + jx] = mode;
    }
}

Не стоит недооценивать стоимость даже базовой арифметики с использованием плавающей запятой на процессоре без FPU. Кажется маловероятным, что плавающая точка необходима, но детали ее использования скрыты в реализации matrix_to_polar().

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

Используя уравнение y = cy ± √ [rad ² - (x-cx) ² ], где cx, cy - центр (7, 7 в этом случае) и подходящая реализация целочисленного квадратного корня, круг может быть составлен таким образом:

void drawCircle( int rad, unsigned char mode )
{
    int r2 = rad * rad ;
    for( int x = 7 - rad; x <= 7 + rad; x++ )
    {
        int dx = x - 7 ;
        int dy = isqrt( r2 - dx * dx ) ;

        matrix[x][7 - dy] = mode ;
        matrix[x][7 + dy] = mode ;
    }
}

В моем тесте я использовал isqrt() ниже на основе кода здесь, но учитывая, что максимальный r ² необходим - 169 (13 ² вы могли бы реализовать 16 или даже 8-битную оптимизированную версию, если это необходимо.Если ваш процессор 32 бит, это, наверное, хорошо.

uint32_t isqrt(uint32_t n)
{
   uint32_t root = 0, bit, trial;
   bit = (n >= 0x10000) ? 1<<30 : 1<<14;
   do
   {
      trial = root+bit;
      if (n >= trial)
      {
         n -= trial;
         root = trial+bit;
      }
      root >>= 1;
      bit >>= 2;
   } while (bit);

   return root;
}

Все, что было сказано, на таком устройстве с низким разрешением, вы, вероятно, получите более качественные круги и более высокую производительность, вручную создавая таблицы поиска растровых изображений для каждого необходимого радиуса. Если память является проблемой, для одного круга требуется всего 7 байтов для описания квадранта 7 x 7, который вы можете отразить во всех трех квадрантах, или для большей производительности вы можете использовать 7 x 16 бит слов для описания полукруга (поскольку реверсивный порядок бит дороже реверсивного доступа к массиву - если вы не используете ARM Cortex-M с битовым диапазоном). Используя полукруглые образы, 13 кругов нуждались бы в 13 x 7 x 2 байтах (182 байта), квадранты выглядели бы 7 x 8 x 13 (91 байт) - вы можете обнаружить, что меньше байтов, что кодовое пространство для вычисления кругов.

Я бы согласился с ответом MooseBoy, если только он объяснил метод, который он предлагает лучше. Здесь мой подход к подходу таблицы поиска.

Решите его с помощью таблицы поиска

Дисплей 13x13 довольно мал, и если вам нужны только круги, которые полностью видны в пределах этого количества пикселей, вы будете обходиться с довольно маленькой таблицей. Даже если вам нужны большие круги, он должен быть лучше, чем любой алгоритмический способ, если вам нужно, чтобы он был быстрым (и у него есть ПЗУ для его сохранения).

Как это сделать

В основном вам нужно определить, как выглядит каждый возможный круг на дисплее 13x13. Недостаточно просто создавать моментальные снимки для дисплея 13x13, так как, скорее всего, вы хотели бы построить круги в произвольных положениях. Моя запись для записи таблицы будет выглядеть так:

struct circle_entry_s{
    unsigned int diameter;
    unsigned int offset;
};

Запись будет отображать заданный диаметр в пикселях в смещения в большой таблице байтов, содержащей форму кругов. Например, для диаметра 9 последовательность байтов будет выглядеть так:

0x1CU, 0x00U, /* 000111000 */
0x63U, 0x00U, /* 011000110 */
0x41U, 0x00U, /* 010000010 */
0x80U, 0x80U, /* 100000001 */
0x80U, 0x80U, /* 100000001 */
0x80U, 0x80U, /* 100000001 */
0x41U, 0x00U, /* 010000010 */
0x63U, 0x00U, /* 011000110 */
0x1CU, 0x00U, /* 000111000 */

Диаметр определяет, сколько байтов таблицы принадлежит кругу: одна строка пикселей генерируется из (diameter + 7) >> 3 байта, а количество строк соответствует диаметру. Коды вывода могут быть сделаны довольно быстро, в то время как таблица поиска достаточно компактна, чтобы получить даже больше, чем отображаемые в ней круги 13x13, если это необходимо.

Обратите внимание, что определение кругов таким образом для нечетного и четного диаметров может или не может понравиться вам при выводе по центру. Круги нечетного диаметра, по-видимому, будут иметь центр в "середине" пикселя, в то время как круги с четным диаметром будут иметь свой центр в "углу" пикселя.

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

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

Для медленного встроенного устройства, имеющего только элемент 13x13, вы должны просто составить справочную таблицу. Например:

struct ComputedCircle
{
    float rMax;
    char col[13][2];
};

Если процедура draw использует rMax для определения того, какой элемент LUT использовать. Например, если у вас есть 2 элемента с одним rMax = 1.4f, другое = 1.7f, то любой радиус между 1.4f и 1.7f будет использовать эту запись.

Элементы столбца будут указывать нулевой, один или два сегмента строки на строку, которые могут быть закодированы в нижнем и верхнем 4 битах каждого символа. -1 может использоваться как контрольное значение для ничего-на-этой-строке. Вам нужно, сколько записей в таблице поиска использовать, но с сеткой 13x13 вы должны иметь возможность кодировать все возможные исходы пикселей с более чем 100 записями и разумное приближение, используя только 10 или около того. Вы также можете обменивать сжатие на скорость рисования, например, помещая матрицу col [13] [2] в плоский список и кодируя количество строк.