fork(36) download 
  1. #include <iostream>
  2. #include <cmath>
  3.  
  4. using namespace std;
  5.  
  6. struct CubicPoly
  7. {
  8. 	float c0, c1, c2, c3;
  9.  
  10. 	float eval(float t)
  11. 	{
  12. 		float t2 = t*t;
  13. 		float t3 = t2 * t;
  14. 		return c0 + c1*t + c2*t2 + c3*t3;
  15. 	}
  16. };
  17.  
  18. /*
  19.  * Compute coefficients for a cubic polynomial
  20.  *   p(s) = c0 + c1*s + c2*s^2 + c3*s^3
  21.  * such that
  22.  *   p(0) = x0, p(1) = x1
  23.  *  and
  24.  *   p'(0) = t0, p'(1) = t1.
  25.  */
  26. void InitCubicPoly(float x0, float x1, float t0, float t1, CubicPoly &p)
  27. {
  28.     p.c0 = x0;
  29.     p.c1 = t0;
  30.     p.c2 = -3*x0 + 3*x1 - 2*t0 - t1;
  31.     p.c3 = 2*x0 - 2*x1 + t0 + t1;
  32. }
  33.  
  34. // standard Catmull-Rom spline: interpolate between x1 and x2 with previous/following points x1/x4
  35. // (we don't need this here, but it's for illustration)
  36. void InitCatmullRom(float x0, float x1, float x2, float x3, CubicPoly &p)
  37. {
  38. 	// Catmull-Rom with tension 0.5
  39.     InitCubicPoly(x1, x2, 0.5f*(x2-x0), 0.5f*(x3-x1), p);
  40. }
  41.  
  42. // compute coefficients for a nonuniform Catmull-Rom spline
  43. void InitNonuniformCatmullRom(float x0, float x1, float x2, float x3, float dt0, float dt1, float dt2, CubicPoly &p)
  44. {
  45.     // compute tangents when parameterized in [t1,t2]
  46.     float t1 = (x1 - x0) / dt0 - (x2 - x0) / (dt0 + dt1) + (x2 - x1) / dt1;
  47.     float t2 = (x2 - x1) / dt1 - (x3 - x1) / (dt1 + dt2) + (x3 - x2) / dt2;
  48.  
  49.     // rescale tangents for parametrization in [0,1]
  50.     t1 *= dt1;
  51.     t2 *= dt1;
  52.  
  53.     InitCubicPoly(x1, x2, t1, t2, p);
  54. }
  55.  
  56. struct Vec2D
  57. {
  58. 	Vec2D(float _x, float _y) : x(_x), y(_y) {}
  59. 	float x, y;
  60. };
  61.  
  62. float VecDistSquared(const Vec2D& p, const Vec2D& q)
  63. {
  64. 	float dx = q.x - p.x;
  65. 	float dy = q.y - p.y;
  66. 	return dx*dx + dy*dy;
  67. }
  68.  
  69. void InitCentripetalCR(const Vec2D& p0, const Vec2D& p1, const Vec2D& p2, const Vec2D& p3,
  70. 	CubicPoly &px, CubicPoly &py)
  71. {
  72.     float dt0 = powf(VecDistSquared(p0, p1), 0.25f);
  73.     float dt1 = powf(VecDistSquared(p1, p2), 0.25f);
  74.     float dt2 = powf(VecDistSquared(p2, p3), 0.25f);
  75.  
  76. 	// safety check for repeated points
  77.     if (dt1 < 1e-4f)    dt1 = 1.0f;
  78.     if (dt0 < 1e-4f)    dt0 = dt1;
  79.     if (dt2 < 1e-4f)    dt2 = dt1;
  80.  
  81. 	InitNonuniformCatmullRom(p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2, px);
  82. 	InitNonuniformCatmullRom(p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2, py);
  83. }
  84.  
  85.  
  86. int main()
  87. {
  88. 	Vec2D p0(0,0), p1(1,1), p2(1.1,1), p3(2,0);
  89. 	CubicPoly px, py;
  90. 	InitCentripetalCR(p0, p1, p2, p3, px, py);
  91. 	for (int i = 0; i <= 10; ++i)
  92. 		cout << px.eval(0.1f*i) << " " << py.eval(0.1f*i) << endl;
  93. }
Success #stdin #stdout 0s 3296KB
comments (?)
stdin 
Standard input is empty
stdout 
1 1
1.01254 1.00505
1.02346 1.00902
1.03316 1.01189
1.04203 1.01365
1.05046 1.01428
1.05886 1.01377
1.06762 1.0121
1.07713 1.00926
1.08779 1.00523
1.1 1
https://ideone.com/NoEbVM
language:
C++ (gcc 8.3)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!