Рисование кривой Безье в растровом изображении С++

Question

Пишу небольшой конвертер изображений и необходимо из векторного(в данном случае svg) делать растровое.Дошел до реализации и застрял на кривых Безье.

Функции для обработки кривых:

void precompute_binomial_coefficients(std::vector<std::vector<double>>& binomial_coefficients, uint32_t n) 
{
    binomial_coefficients.resize(n + 1, std::vector<double>(n + 1, 0.0));
    for (uint32_t i = 0; i <= n; ++i) 
    {
        binomial_coefficients[i][0] = 1.0;
        for (uint32_t j = 1; j <= i; ++j) 
        {
            binomial_coefficients[i][j] = binomial_coefficients[i - 1][j - 1] + binomial_coefficients[i - 1][j];
        }
    }
}

double basis(const std::vector<std::vector<double>>& binomial_coefficients, uint32_t i, uint32_t n, double t) 
{
    if (i > n - 1)
    {
        throw std::out_of_range("Index i is out of range for binomial coefficients");
    }
    return binomial_coefficients[n - 1][i] * std::pow(t, i) * std::pow(1 - t, n - 1 - i);
}

std::pair<int, int> bezier(const std::vector<std::pair<int, int>>& control_points, const std::vector<std::vector<double>>& binomial_coefficients, double t) 
{
    uint32_t n = control_points.size();
    if (n == 0) 
    {
        throw std::invalid_argument("Control points vector is empty");
    }
    double x = 0.0;
    double y = 0.0;
    double temp;

    for (uint32_t i = 0; i < n; ++i) 
    {
        temp = basis(binomial_coefficients, i, n, t);
        x += control_points[i].first * temp;
        y += control_points[i].second * temp;
    }
    return std::make_pair(static_cast<int>(std::ceil(x)), static_cast<int>(std::ceil(y)));
}

void DrawBezierCurve(Image& image_, const std::vector<std::pair<int, int>>& control_points, const Color& color) 
{
    if (control_points.empty())
    {
        return;
    }

    uint32_t n = control_points.size();
    std::vector<std::vector<double>> binomial_coefficients;
    precompute_binomial_coefficients(binomial_coefficients, n - 1);

    double step = 0.01;

    for (double t = 0.0; t <= 1.0; t += step) 
    {
        std::pair<int, int> current_point = bezier(control_points, binomial_coefficients, t);
        if (current_point.first >= 0 && current_point.first < image_.GetWidth() && current_point.second >= 0 && current_point.second < image_.GetHeight()) 
        {
            image_.SetPixel(current_point.first, current_point.second, color);
        }
    }
}

Функция для рисования линии:

 void DrawLine(Image& image_, int x1_, int y1_, int x2_, int y2_, const Color& color_)
 {
     int dx = abs(x2_ - x1_);
     int dy = abs(y2_ - y1_);
     int sx = (x1_ < x2_) ? 1 : -1;
     int sy = (y1_ < y2_) ? 1 : -1;
     int err = dx - dy;

     while (true)
     {
         if (x1_ >= 0 && x1_ < image_.GetWidth() && y1_ >= 0 && y1_ < image_.GetHeight())
         {
             image_.SetPixel(x1_, y1_, color_);
         }

         if (x1_ == x2_ && y1_ == y2_)
         {
             break;
         }

         int e2 = 2 * err;

         if (e2 > -dy)
         {
             err -= dy;
             x1_ += sx;
         }

         if (e2 < dx)
         {
             err += dx;
             y1_ += sy;
         }
     }
 }

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

Answer 1

Если для кубической прямой получается 4 отрезка между контрольными точками, то каким-то образом использован полином первой степени, т.е. прямая.

Попробуйте жестко зашить в bezier() расчёт по формуле

 x(t) = CP[0].X*(1-t)^3+3*CP[1].X*t*(1-t)^2+3*CP[2].X*t^2*(1-t)+CP[3].X*t^3

Answer 2

@MBo Сделал в таком виде, явно указав формулу расчета для точек

struct Point
{
    float x = 0.0;
    float y = 0.0;
};

void DrawBezierQuadratic(Image& image, const std::vector<Point>& control_points, const Color& color)
{
    if (control_points.size() != 3)
    {
        return;
    }

    Point p1 = control_points[0];
    Point p2 = control_points[1];
    Point p3 = control_points[2];

    for (float t = 0; t <= 1; t += 0.01)
    {
        float x = (1 - t) * (1 - t) * p1.x + 2 * (1 - t) * t * p2.x + t * t * p3.x;
        float y = (1 - t) * (1 - t) * p1.y + 2 * (1 - t) * t * p2.y + t * t * p3.y;

        image.SetPixel(x, y, color);
    }
}

void DrawBezierCurve(Image& image, const std::vector<Point>& control_points, const Color& color)
{
    if (control_points.size() != 4)
    {
        return;
    }

    Point p1 = control_points[0];
    Point p2 = control_points[1];
    Point p3 = control_points[2];
    Point p4 = control_points[3];

    for (float t = 0; t <= 1; t += 0.01)
    {
        float x = (1 - t) * (1 - t) * (1 - t) * p1.x + 3 * (1 - t) * (1 - t) * t * p2.x + 3 * (1 - t) * t * t * p3.x + t * t * t * p4.x;
        float y = (1 - t) * (1 - t) * (1 - t) * p1.y + 3 * (1 - t) * (1 - t) * t * p2.y + 3 * (1 - t) * t * t * p3.y + t * t * t * p4.y;

        image.SetPixel(x, y, color);
    }
}

И немного изменил обработку

void XmlPathLoad(pugi::xml_node child_, Image& image_, const GSettings& settings_ = GSettings())
{
    std::string d_str = child_.attribute("d").as_string();

    std::string fill_str = "";
    Color stroke_color;
    Color fill_color;

    if (settings_.use_g_settings)
    {
        stroke_color = ParseColor(settings_.stroke.c_str());
        fill_color = ParseColor(settings_.fill.c_str());
    }
    else
    {
        std::string stroke_str = child_.attribute("stroke").as_string();
        fill_str = child_.attribute("fill").as_string();
        fill_color = ParseColor(fill_str);

        if (stroke_str.empty())
        {
            stroke_color = fill_color;
        }
        else
        {
            stroke_color = ParseColor(stroke_str);
        }
    }

    std::stringstream ss(d_str);
    std::string command;
    std::vector<Point> points;
    char current_command = '\0';
    float x = 0;
    float y = 0;

    while (ss >> command)
    {
        if (isalpha(command[0]))
        {
            current_command = command[0];
            continue;
        }

        std::stringstream command_ss(command);
        std::string x_str, y_str;

        if (current_command == 'M' || current_command == 'L')
        {
            std::getline(command_ss, x_str, ',');
            std::getline(command_ss, y_str, ',');
            x = std::stof(x_str);
            y = std::stof(y_str);
            points.push_back({ x, y });

            if (current_command == 'M')
            {
                current_command = 'L';
            }
        }
        else if (current_command == 'Z')
        {
            if (!points.empty())
            {
                DrawLine(image_, points.back().x, points.back().y, points.front().x, points.front().y, stroke_color);
            }
        }
        else if (current_command == 'Q')
        {
            if (points.empty())
            {
                continue;
            }

            std::vector<Point> control_points;
            for (int i = 0; i < 2; ++i)
            {
                std::getline(command_ss, x_str, ',');
                std::getline(command_ss, y_str, ',');
                float cx = std::stof(x_str);
                float cy = std::stof(y_str);
                control_points.push_back({ cx, cy });
            }
            DrawBezierQuadratic(image_, { points.back(), control_points[0], control_points[1] }, stroke_color);
            points.push_back(control_points[1]);
        }
        else if (current_command == 'C')
        {
            if (points.empty())
            {
                continue;
            }

            std::vector<Point> control_points;
            for (int i = 0; i < 3; ++i)
            {
                std::getline(command_ss, x_str, ',');
                std::getline(command_ss, y_str, ',');
                float cx = std::stof(x_str);
                float cy = std::stof(y_str);
                control_points.push_back({ cx, cy });
            }
            DrawBezierCurve(image_, { points.back(), control_points[0], control_points[1], control_points[2] }, stroke_color);
            points.push_back(control_points[2]);
        }
    }

    for (size_t i = 1; i < points.size(); ++i)
    {
        DrawLine(image_, points[i - 1].x, points[i - 1].y, points[i].x, points[i].y, stroke_color);
    }

    if (!fill_str.empty() && fill_str != "none"s)
    {
        std::vector<std::pair<int, int>> int_points;
        for (const auto& point : points)
        {
            int_points.push_back({ static_cast<int>(point.x), static_cast<int>(point.y) });
        }
        FillShape(image_, int_points, fill_color);
    }
}

Но результат остался тот же

БЛОГ НА HUSL

Рисование кривой Безье в растровом изображении С++

Ответы (2 шт):