Половина моего эллипса нарисована не в том месте

Question

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

void cRenderClass::plotEllipse(int xCentre, int yCentre, int width, int height, float angle, float xScale, float yScale)
{
    if ((height == width) && (abs(xScale - yScale) < 0.005))
        plotCircle(xCentre, yCentre, width, xScale);

    std::vector<std::vector <float>> rotate;
    if (angle > 360.0f)
    {
        angle -= 180.0f;
    }
    rotate = maths.rotateMatrix(angle, 'z');

    //rotate[0][0] = cos(angle)
    //rotate[0][1] = sin(angle)

    float theta = atan2(-height*rotate[0][1], width*rotate[0][0]);
    if (angle > 90.0f && angle < 180.0f)
    {
        theta += PI;
    }

    //add scalation in at a later date

    float xShear = (width * (cos(theta) * rotate[0][0])) - (height * (sin(theta) * rotate[0][1]));
    float yShear = (width * (cos(theta) * rotate[0][1])) + (height * (sin(theta) * rotate[0][0]));
    float widthAxis = abs(sqrt(((rotate[0][0] * width) * (rotate[0][0] * width)) + ((rotate[0][1] * height) * (rotate[0][1] * height))));
    float heightAxis = (width * height) / widthAxis;

    int aSquared = widthAxis * widthAxis;
    int fourASquared = 4*aSquared;
    int bSquared = heightAxis * heightAxis;
    int fourBSquared = 4*bSquared;

    x0 = 0;
    y0 = heightAxis;
    int sigma = (bSquared * 2) + (aSquared * (1 - (2 * heightAxis)));

    while ((bSquared * x0) <= (aSquared * y0))
    {
        drawPixel(xCentre + x0, yCentre + ((floor((x0 * yShear) / xShear)) + y0));
        drawPixel(xCentre - x0, yCentre + ((floor((x0 * yShear) / xShear)) + y0));
        drawPixel(xCentre + x0, yCentre + ((floor((x0 * yShear) / xShear)) - y0));
        drawPixel(xCentre - x0, yCentre + ((floor((x0 * yShear) / xShear)) - y0));

        if (sigma >= 0)
        {
            sigma += (fourASquared * (1 - y0));
            y0--;
        }

        sigma += (bSquared * ((4 * x0) + 6));
        x0++;
    }

    x0 = widthAxis;
    y0 = 0;
    sigma = (aSquared * 2) + (bSquared * (1 - (2 * widthAxis)));

    while ((aSquared * y0) <= (bSquared * x0))
    {
        drawPixel(xCentre + x0, yCentre + ((floor((x0 * yShear) / xShear)) + y0));
        drawPixel(xCentre - x0, yCentre + ((floor((x0 * yShear) / xShear)) + y0));
        drawPixel(xCentre + x0, yCentre + ((floor((x0 * yShear) / xShear)) - y0));
        drawPixel(xCentre - x0, yCentre + ((floor((x0 * yShear) / xShear)) - y0));

        if (sigma >= 0)
        {
            sigma += (fourBSquared * (1 - x0));
            x0--;
        }

        sigma += (aSquared * (4 * y0) + 6);
        y0++;
    }

    //the above algorithm hasn't been quite completed
    //there are still a few things I want to enquire Andy about
    //before I move on

    //this other algorithm definitely works
    //however
    //it is computationally expensive
    //and the line drawing isn't as refined as the first one
    //only use this as a last resort

/*  std::vector<std::vector <float>> rotate;
    rotate = maths.rotateMatrix(angle, 'z');

    float s = rotate[0][1];
    float c = rotate[0][0];
    float ratio = (float)height / (float)width;
    float px, py, xNew, yNew;

    for (int theta = 0; theta <= 360; theta++)
    {
        px = (xCentre + (cos(maths.degToRad(theta)) * (width / 2))) - xCentre;
        py = (yCentre - (ratio * (sin(maths.degToRad(theta)) * (width / 2)))) -     yCentre;

        x0 = (px * c) - (py * s);
        y0 = (px * s) + (py * c);

        drawPixel(x0 + xCentre, y0 + yCentre);
    }*/
}

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

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

Кто-нибудь может помочь?