Перевести код из C++ в чистый Си - C (СИ)

Узнай цену своей работы

Формулировка задачи:

Из-за наличия специфики плюсов (векторы, классы, operator) вообще не удаётся интерпретировать логику, заложенную в код. Помогите, пожалуйста, разобраться и получить хотя бы шаблонный вариант на Си, который я смогу дописать до рабочего. Приведённая программа позволяет интерполировать графики кривыми Безье. В отличие от других сотен вариаций на данную тему не даёт ложных экстремумов. Вот статья на хабре с подробным описанием и примерами. Код программы на гитхабе.
Листинг программы 
  1. // TBezierInterpolation.cpp
  2. #include <vector>
  3. #include <iostream>
  4. #include <cmath>
  5.  
  6. using namespace std;
  7.  
  8. #define EPSILON 1.0e-5
  9. #define RESOLUTION 32
  10.  
  11. class Point2D
  12. {
  13. public:
  14.     double x, y;
  15.     
  16.     Point2D() { x = y = 0.0; };
  17.     Point2D(double _x, double _y) { x = _x; y = _y; };
  18.     
  19.     Point2D operator +(const Point2D &point) const { return Point2D(x + point.x, y + point.y); };
  20.     Point2D operator -(const Point2D &point) const { return Point2D(x - point.x, y - point.y); };
  21.     Point2D operator *(double v) const { return Point2D(x * v, y * v); };
  22.     void operator +=(const Point2D &point) { x += point.x; y += point.y; };
  23.     void operator -=(const Point2D &point) { x -= point.x; y -= point.y; };
  24.     
  25.     void normalize()
  26.     {
  27.         double l = sqrt(x * x + y * y);
  28.         x /= l;
  29.         y /= l;
  30.     }
  31. };
  32.  
  33. class Segment
  34. {
  35. public:
  36.     Point2D points[4];
  37.     
  38.     void calc(double t, Point2D &p)
  39.     {
  40.         double t2 = t * t;
  41.         double t3 = t2 * t;
  42.         double nt = 1.0 - t;
  43.         double nt2 = nt * nt;
  44.         double nt3 = nt2 * nt;
  45.         p.x = nt3 * points[0].x + 3.0 * t * nt2 * points[1].x + 3.0 * t2 * nt * points[2].x + t3 * points[3].x;
  46.         p.y = nt3 * points[0].y + 3.0 * t * nt2 * points[1].y + 3.0 * t2 * nt * points[2].y + t3 * points[3].y;
  47.     };
  48. };
  49.  
  50. bool calculateSpline(const vector<Point2D> &values, vector<Segment> &bezier)
  51. {
  52.     int n = values.size() - 1;
  53.     
  54.     if (n < 2)
  55.         return false;
  56.     
  57.     bezier.resize(n);
  58.     
  59.     Point2D tgL;
  60.     Point2D tgR;
  61.     Point2D cur;
  62.     Point2D next = values[1] - values[0];
  63.     next.normalize();
  64.     
  65.     double l1, l2, tmp, x;
  66.     
  67.     --n;
  68.     
  69.     for (int i = 0; i < n; ++i)
  70.     {
  71.         bezier[i].points[0] = bezier[i].points[1] = values[i];
  72.         bezier[i].points[2] = bezier[i].points[3] = values[i + 1];
  73.         
  74.         cur = next;
  75.         next = values[i + 2] - values[i + 1];
  76.         next.normalize();
  77.         
  78.         tgL = tgR;
  79.         
  80.         tgR = cur + next;
  81.         tgR.normalize();
  82.         
  83.         if (abs(values[i + 1].y - values[i].y) < EPSILON)
  84.         {
  85.             l1 = l2 = 0.0;
  86.         }
  87.         else
  88.         {
  89.             tmp = values[i + 1].x - values[i].x;
  90.             l1 = abs(tgL.x) > EPSILON ? tmp / (2.0 * tgL.x) : 1.0;
  91.             l2 = abs(tgR.x) > EPSILON ? tmp / (2.0 * tgR.x) : 1.0;
  92.         }
  93.         
  94.         if (abs(tgL.x) > EPSILON && abs(tgR.x) > EPSILON)
  95.         {
  96.             tmp = tgL.y / tgL.x - tgR.y / tgR.x;
  97.             if (abs(tmp) > EPSILON)
  98.             {
  99.                 x = (values[i + 1].y - tgR.y / tgR.x * values[i + 1].x - values[i].y + tgL.y / tgL.x * values[i].x) / tmp;
  100.                 if (x > values[i].x && x < values[i + 1].x)
  101.                 {
  102.                     if (tgL.y > 0.0)
  103.                     {
  104.                         if (l1 > l2)
  105.                             l1 = 0.0;
  106.                         else
  107.                             l2 = 0.0;
  108.                     }
  109.                     else
  110.                     {
  111.                         if (l1 < l2)
  112.                             l1 = 0.0;
  113.                         else
  114.                             l2 = 0.0;
  115.                     }
  116.                 }
  117.             }
  118.         }
  119.         
  120.         bezier[i].points[1] += tgL * l1;
  121.         bezier[i].points[2] -= tgR * l2;
  122.     }
  123.     
  124.     l1 = abs(tgL.x) > EPSILON ? (values[n + 1].x - values[n].x) / (2.0 * tgL.x) : 1.0;
  125.     
  126.     bezier[n].points[0] = bezier[n].points[1] = values[n];
  127.     bezier[n].points[2] = bezier[n].points[3] = values[n + 1];
  128.     bezier[n].points[1] += tgR * l1;
  129.     
  130.     return true;
  131. }
  132.  
  133. int main()
  134. {
  135.     vector<Point2D> testValues;
  136.     vector<Segment> spline;
  137.     Point2D p;
  138.  
  139.     testValues.push_back(Point2D(0, 0));
  140.     testValues.push_back(Point2D(20, 0));
  141.     testValues.push_back(Point2D(45, -47));
  142.     testValues.push_back(Point2D(53, 335));
  143.     testValues.push_back(Point2D(57, 26));
  144.     testValues.push_back(Point2D(62, 387));
  145.     testValues.push_back(Point2D(74, 104));
  146.     testValues.push_back(Point2D(89, 0));
  147.     testValues.push_back(Point2D(95, 100));
  148.     testValues.push_back(Point2D(100, 0));
  149.  
  150.     calculateSpline(testValues, spline);
  151.  
  152.     for (auto s : spline)
  153.     {
  154.         for (int i = 0; i < RESOLUTION; ++i)
  155.         {
  156.             s.calc((double)i / (double)RESOLUTION, p);
  157.             cout << p.x << " " << p.y << endl;
  158.         }
  159.     }
  160.  
  161.     cout << testValues.back().x << " " << testValues.back().y << endl;
  162.  
  163.     return 0;
  164. }
Листинг программы 
  1. g++ -std=c++11 TBezierInterpolation.cpp

Решение задачи: «Перевести код из C++ в чистый Си»

textual
Листинг программы 
  1. // TBezierInterpolation.c
  2. #include <stdio.h>
  3. #include <math.h>
  4. #include <stdlib.h>
  5. #include <stdbool.h>
  6. #include <float.h>
  7.  
  8. #define RESOLUTION 32
  9. #define  POINTS_LEN 10
  10.  
  11. typedef struct
  12. {
  13.     double x, y;
  14. }Point2D;
  15.  
  16.  
  17. Point2D Point2DAdd( Point2D *left,  Point2D *right)
  18. {
  19.     Point2D newPoint = {left->x + right->x, left->y + right->y};
  20.     return newPoint;
  21. }
  22. Point2D Point2DSubtract( Point2D *left,  Point2D *right)
  23. {
  24.     Point2D newPoint = {left->x - right->x, left->y - right->y};
  25.     return newPoint;
  26. }
  27. Point2D Point2DMultiply( Point2D *left, double v)
  28. {
  29.     Point2D newPoint = {left->x * v, left->y * v};
  30.     return newPoint;
  31. }
  32.  
  33.  
  34. void Point2DNormalize(Point2D *point)
  35. {
  36.     double l = sqrt(point->x * point->x + point->y * point->y);
  37.     point->x /= l;
  38.     point->y /= l;
  39. }
  40.  
  41.  
  42. typedef struct
  43. {
  44.     Point2D points[4];
  45. }Segment;
  46.  
  47. void SegmentCalc(Segment *seg,double t, Point2D *p)
  48. {
  49.     double t2 = t * t;
  50.     double t3 = t2 * t;
  51.     double nt = 1.0 - t;
  52.     double nt2 = nt * nt;
  53.     double nt3 = nt2 * nt;
  54.     p->x = nt3 * seg->points[0].x + 3.0 * t * nt2 * seg->points[1].x + 3.0 * t2 * nt * seg->points[2].x + t3 * seg->points[3].x;
  55.     p->y = nt3 * seg->points[0].y + 3.0 * t * nt2 * seg->points[1].y + 3.0 * t2 * nt * seg->points[2].y + t3 * seg->points[3].y;
  56. }
  57.  
  58.  
  59. bool CalculateSpline( Point2D values[], int valuesSize, Segment bezier[])
  60. {
  61.     int n = valuesSize - 1;
  62.  
  63.     if (valuesSize < 2)
  64.         return false;
  65.  
  66.     Point2D tgL= {0.0,0.0};
  67.     Point2D tgR= {0.0,0.0};
  68.     Point2D cur= {0.0,0.0};
  69.     Point2D next = Point2DSubtract(&values[1] ,&values[0]);
  70.     Point2D tmpPoint= {0.0,0.0};
  71.     Point2DNormalize(&next);
  72.  
  73.     double l1 = 0.0, l2= 0.0, tmp= 0.0, x= 0.0;
  74.  
  75.     --n;
  76.  
  77.     for (int i = 0; i < n; ++i)
  78.     {
  79.         bezier[i].points[0] = bezier[i].points[1] = values[i];
  80.         bezier[i].points[2] = bezier[i].points[3] = values[i + 1];
  81.  
  82.         cur = next;
  83.         next = Point2DSubtract(&values[i + 2],&values[i + 1]);
  84.         Point2DNormalize(&next);
  85.  
  86.         tgL = tgR;
  87.  
  88.         tgR = Point2DAdd(&cur,&next);
  89.         Point2DNormalize(&tgR);
  90.  
  91.         if (abs(values[i + 1].y - values[i].y) < DBL_EPSILON)
  92.         {
  93.             l1 = l2 = 0.0;
  94.         }
  95.         else
  96.         {
  97.             tmp = values[i + 1].x - values[i].x;
  98.             l1 = abs(tgL.x) > DBL_EPSILON ? tmp / (2.0 * tgL.x) : 1.0;
  99.             l2 = abs(tgR.x) > DBL_EPSILON ? tmp / (2.0 * tgR.x) : 1.0;
  100.         }
  101.  
  102.         if (abs(tgL.x) > DBL_EPSILON && abs(tgR.x) > DBL_EPSILON)
  103.         {
  104.             tmp = tgL.y / tgL.x - tgR.y / tgR.x;
  105.             if (abs(tmp) > DBL_EPSILON)
  106.             {
  107.                 x = (values[i + 1].y - tgR.y / tgR.x * values[i + 1].x - values[i].y + tgL.y / tgL.x * values[i].x) / tmp;
  108.                 if (x > values[i].x && x < values[i + 1].x)
  109.                 {
  110.                     if (tgL.y > 0.0)
  111.                     {
  112.                         if (l1 > l2)
  113.                             l1 = 0.0;
  114.                         else
  115.                             l2 = 0.0;
  116.                     }
  117.                     else
  118.                     {
  119.                         if (l1 < l2)
  120.                             l1 = 0.0;
  121.                         else
  122.                             l2 = 0.0;
  123.                     }
  124.                 }
  125.             }
  126.         }
  127.         tmpPoint = Point2DMultiply(&tgL , l1);
  128.         bezier[i].points[1] = Point2DAdd(& bezier[i].points[1],&tmpPoint);
  129.         tmpPoint = Point2DMultiply(&tgR , l2);
  130.         bezier[i].points[2] = Point2DSubtract(& bezier[i].points[2],&tmpPoint);
  131.     }
  132.  
  133.     l1 = abs(tgL.x) > DBL_EPSILON ? (values[n + 1].x - values[n].x) / (2.0 * tgL.x) : 1.0;
  134.  
  135.     bezier[n].points[0] = bezier[n].points[1] = values[n];
  136.     bezier[n].points[2] = bezier[n].points[3] = values[n + 1];
  137.     tmpPoint = Point2DMultiply(&tgR , l1);
  138.     bezier[n].points[1] = Point2DAdd(& bezier[n].points[1],&tmpPoint);
  139.  
  140.     return true;
  141. }
  142.  
  143. int main()
  144. {
  145.  
  146.     Point2D testValues[POINTS_LEN] = {{0.0, 0.0},
  147.                                {20.0, 0.0},
  148.                                {45.0, -47.0},
  149.                                {53.0, 335.0},
  150.                                {57.0, 26.0},
  151.                                {62.0, 387.0},
  152.                                { 74.0, 104.0},
  153.                               { 89.0, 0.0},
  154.                              {95.0, 100.0},
  155.                              { 100.0, 0.0} };
  156.     Segment spline[100];
  157.  
  158.     Point2D p = {0.0,0.0};
  159.  
  160.  
  161.     CalculateSpline(testValues,POINTS_LEN, spline);
  162.  
  163.     for(int i = 0; i < POINTS_LEN - 1;i++)
  164.     {
  165.         for (int j = 0; j < RESOLUTION; j++)
  166.         {
  167.             SegmentCalc(&spline[i],(double)j / (double)RESOLUTION, &p);
  168.             printf("%lf %lf\n", p.x, p.y);
  169.         }
  170.     }
  171.  
  172.     printf("%lf %lf\n", testValues[POINTS_LEN - 1].x,testValues[POINTS_LEN - 1].y);
  173.  
  174.     return 0;
  175. }

Объяснение кода листинга программы

Код выполняет вычисление сплайсинга для набора точек в двумерном пространстве. Список действий:

  1. Включаются необходимые заголовочные файлы:
    • stdio.h для работы с стандартным вводом/выводом
    • math.h для работы с математическими функциями
    • stdlib.h для работы с функциями стандартной библиотеки C
    • stdbool.h для работы с булевыми значениями
    • float.h для работы с плавающей точкой
  2. Определяются константы:
    • RESOLUTION - количество точек на интервале между двумя соседними точками
    • POINTS_LEN - общее количество точек
  3. Создается структура Point2D, представляющая точку в двумерном пространстве
  4. Реализуются функции для работы с точками:
    • Point2DAdd - добавляет две точки и возвращает их сумму
    • Point2DSubtract - вычитает две точки и возвращает разность
    • Point2DMultiply - умножает точку на число и возвращает результат
    • Point2DNormalize - нормализует точку (делает ее длину равной 1)
  5. Создается структура Segment, представляющая сегмент кривой
  6. Реализуется функция SegmentCalc, которая вычисляет значения точки на сегменте кривой для заданного параметра
  7. Реализуется функция CalculateSpline, которая вычисляет сплайсинг для набора точек
  8. В функции main создается набор точек testValues, инициализируются начальные значения для сегментов кривой
  9. Вызывается функция CalculateSpline для вычисления сплайсинга
  10. Для каждого сегмента кривой вычисляются значения точек на интервале от 0 до 1 с шагом RESOLUTION и выводятся на экран
  11. Выводятся координаты последней точки testValues[POINTS_LEN - 1]
  12. Функция main возвращает 0, что означает успешное выполнение программы

ИИ поможет Вам:

  • решить любую задачу по программированию
  • объяснить код
  • расставить комментарии в коде
  • и т.д
Попробуйте бесплатно

Оцени полезность:

8   голосов , оценка 3.75 из 5

Нужна аналогичная работа?

Оформи быстрый заказ и узнай стоимость

Бесплатно
Оформите заказ и авторы начнут откликаться уже через 10 минут