I don't really understand your motivation, unless you save your curves to a SVG file.
I am not good enough at math to help you.
But obviously, if there are two different kinds of curves, that's because they are distinct, so in most cases, they probably don't fit exactly, unless perhaps you simulate a curve with lot of smaller curves of the other kind.

Yep, you've figured out my motivation :-)  I guess I could just break the curve down into a series of line-segments and export that to SVG instead, but where's the fun in that? ;-)

The curveVertex (Catmull-Rom) curves are particularly simple to use, and may have been put there for that reason rather than because they can't be expressed as beziers.  (However, I am almost certain that beziers couldn't be expressed as Catmull-Rom curves).

No, I'm not good enough at math to figure this one out either.  Thank you very much for your reply.

This sounded an interesting problem so I thought I would do some googling. I found this paper and on page 3 there looked a very interesting description converting Catermull-Rom curves to Bezier curves so I decided to have a go.

The result is shown in this picture. The green points and lines are the controls for the Catermull-Rom curve and the pink the Bezier curve. The dark line are both of the curves - a perfect alignment.



The sketch code is shown below. You will notice I have created 2 functions to calculate the Bezier points. The first one is a direct conversion of the formulae in the paper. The formulae showed the coefficients being raised to the power alpha. Reading the article suggested to me that alpha = 0.5 was best but it didin't give me a good fit. So I tried different values for alpha and the best was 0 (zero). Any number raised to the power 0 is 1 and this would simplify the calculation greatly. The result was the second fucntion  makeBezierZero.

Anyway here is my code HTH

1. PVector[] cm, bz;
2. 
   
3. void setup() {
4.   size(500, 500);
5.   cm = new PVector[4];
6.   cm[0] = new PVector(30, 300);
7.   cm[1] = new PVector(100, 110);
8.   cm[2] = new PVector(400, 240);
9.   cm[3] = new PVector(200, 280);
10. 
    
11.   bz = new PVector[4];
12.   bz[0] = new PVector(cm[1].x, cm[1].y);
13.   bz[1] = new PVector();
14.   bz[2] = new PVector();
15.   bz[3] = new PVector(cm[2].x, cm[2].y);
16. 
    
17.   // Now calculate the other 2 points
    
18.   makeBezierZero(cm, bz);
19. 
    
20.   background(240);
21.   // Draw Catmull-Rom curve
22.   noFill();
23.   stroke(0, 64, 0, 128);
24.   strokeWeight(1.8);
25.   beginShape();
26.   for (int i = 0; i < cm.length; i++)
27.     curveVertex(cm[i].x, cm[i].y);
28.   endShape();
29.   // Draw Catmull-Rom curve control points/lines
30.   strokeWeight(1);
31.   stroke(0, 128, 0, 64);
32.   fill(0, 128, 0, 64);
33.   for (int i = 0; i < cm.length; i++) {
34.     ellipse(cm[i].x, cm[i].y, 10, 10);
35.     if (i>0)
36.       line(cm[i-1].x, cm[i-1].y, cm[i].x, cm[i].y);
37.   }
38.  
    
39.   // Draw Bezier curve
40.   strokeWeight(1);
41.   strokeWeight(1.2);
42.   stroke(64, 0, 0, 128);
43.   noFill();
44.   bezier(bz[0].x, bz[0].y, bz[1].x, bz[1].y, bz[2].x, bz[2].y, bz[3].x, bz[3].y);
45.   // Draw Bezier curve control points/hull
46.   strokeWeight(1);
47.   stroke(128, 0, 0, 64);
48.   fill(128, 0, 0, 64);
49.   for (int i = 0; i < bz.length; i++) {
50.     ellipse(bz[i].x, bz[i].y, 10, 10);
51.     if (i>0)
52.       line(bz[i-1].x, bz[i-1].y, bz[i].x, bz[i].y);
53.   }
54. }
55. 
    
56. void makeBezier(PVector[] c, PVector[] b) {
57.   float alpha = 0.2; // Try different values zero was the best for me
    
58.   float d1 = PVector.dist(c[1], c[0]);
59.   float d2 = PVector.dist(c[2], c[1]);
60.   float d3 = PVector.dist(c[3], c[2]);
61. 
    
62.   float d1_a = pow(d1, alpha);
63.   float d2_a = pow(d2, alpha);
64.   float d3_a = pow(d3, alpha);
65. 
    
66.   float d1_2a = d1_a * d1_a;
67.   float d2_2a = d2_a * d2_a;
68.   float d3_2a = d3_a * d3_a;
69. 
    
70.   b[1].add(PVector.mult(c[2], d1_2a));
71.   b[1].sub(PVector.mult(c[0], d2_2a));
72.   b[1].add(PVector.mult(c[1], 2*d1_2a + 3*d1_a*d2_a + d2_2a));
73.   b[1].div(3*d1_a*(d1_a + d2_a));
74. 
    
75.   b[2].add(PVector.mult(c[1], d3_2a));
76.   b[2].sub(PVector.mult(c[3], d2_2a));
77.   b[2].add(PVector.mult(c[2], 2*d3_2a + 3*d3_a*d2_a + d2_2a));
78.   b[2].div(3*d3_a*(d3_a + d2_a));
79. }
80. 
    
81. void makeBezierZero(PVector[] c, PVector[] b) {
82.   b[1].add(c[2]);
83.   b[1].sub(c[0]);
84.   b[1].add(PVector.mult(c[1], 6));
85.   b[1].div(6);
86. 
    
87.   b[2].add(c[1]);
88.   b[2].sub(c[3]);
89.   b[2].add(PVector.mult(c[2], 6));
90.   b[2].div(6);
91. }

They're the two major classes of curves from two different fields - in animation, motion along a path (as well as frame tweening) uses Catmull-Rom curves, because they're relatively well behaved in terms of time spent on the curve: running through the curve based on its time parameter makes it run roughly equally fast along straight sections as it does along strongly curve sections. It's great for interpolating between points, but not so great for designing with curves, because you have to manipulate the on-curve points, rather than using off-curve controls.

Yes, that's really great!  Many thanks to both of you!

:-)

I thought you'd like to know I've got this exporting to SVG now - as the attached code shows (also it might be helpful to someone else trying to do the same thing).

Thanks again!

    Best wishes,

        Antony

1. //
2. // CurveToBezier - converts Processing's curve vertices (Catmull-Rom curves) into Beziers,
3. // so that they can be saved as SVG.  The class should be re-usable.  The rest is proof of concept.
4. //
5. // Click to add a vertex (you'll want to add at least four).
6. // Press s to save as SVG.
7. // Hold any other key to see the Catmull-Rom visualisation instead of the Bezier visualisation
8. // (they're almost identical).
9. //
10. // Thanks to quarks and therealpomax.
11. // http://forum.processing.org/topic/convert-between-curvevertex-and-beziervertex
12. //
13. // Requires the Geomerative library
14. // http://www.ricardmarxer.com/geomerative/
15. import geomerative.*;
16. 
    
17. Vector<PVector> points = new Vector<PVector>();
18. CurveToBezier c2b = new CurveToBezier();
19. 
    
20. void setup()
21. {
22.   size(900,600);
23.   RG.init(this);
24.   rectMode(CENTER);
25. }
26. void draw()
27. {
28.   background(128);
29.   if (keyPressed)
30.   {
31.     // Draw using Catmull-Rom
32.     noFill();
33.     stroke(0,0,255);
34.  
35.     beginShape();
36.     for (int n = 0; n < points.size(); ++n)
37.     {
38.       curveVertex(points.get(n).x, points.get(n).y);
39.     }
40.     endShape();
41.   }
42.   else
43.   {
44.     // Draw using the Beziers stored in our geomerative.RPath object
45.     noFill();
46.     stroke(0);
47.     c2b.path.draw();
48.   }
49. 
    
50.   // Draw vertices
51.   fill(255,0,0);
52.   noStroke();
53.   for (int n = 0; n < points.size(); ++n)
54.   {
55.     rect(points.get(n).x, points.get(n).y, 10, 10);
56.   }
57. }
58. void mousePressed()
59. {
60.   PVector pt = new PVector(mouseX, mouseY);
61.   points.add(pt);
62.  
63.   c2b.curveVertex(pt.x, pt.y); 
64. }
65. void keyPressed()
66. {
67.   if (key == 's') // Save
68.   {
69.     RStyle style = new RStyle();
70.     style.setFill(false);
71.     style.setStroke(color(0));
72. 
    
73.     RShape shape = new RShape(c2b.path);
74.     shape.setStyle(style);
75.     RG.saveShape("output.svg", shape);   
76.   }
77. }
78. //
79. // CurveToBezier
80. //
81. class CurveToBezier
82. {
83.   CurveToBezier()
84.   {
85.     ring[0] = new PVector();
86.     ring[1] = new PVector();
87.     ring[2] = new PVector();
88.     ring[3] = new PVector();
89.   }
90.  
91.   void curveVertex(float x, float y)
92.   {
93.     ring[count % 4].x = x;
94.     ring[count % 4].y = y;
95.     if (count >= 3)
96.     {
97.       makeBezierZero(ring[(count-3)%4], ring[(count-2)%4], ring[(count-1)%4], ring[count%4]);
98.     }
99.     else if (count == 1)
100.     {
101.       path = new RPath(x,y);
102.     }
103.     ++count;
104.   }
105.  
106.   private void makeBezierZero(PVector c0, PVector c1, PVector c2, PVector c3)
107.   {
108.     PVector b1 = new PVector(0,0);
109.     PVector b2 = new PVector(0,0);
110.    
111.     b1.add(c2);
112.     b1.sub(c0);
113.     b1.add(PVector.mult(c1, 6));
114.     b1.div(6);
115.  
116.     b2.add(c1);
117.     b2.sub(c3);
118.     b2.add(PVector.mult(c2, 6));
119.     b2.div(6);
120.    
121.     path.addBezierTo(b1.x, b1.y, b2.x, b2.y, c2.x, c2.y);
122.   }
123. 
     
124.   RPath path = new RPath();
125.   private PVector ring[] = new PVector[4];
126.   private int count = 0;
127. }