It would be interesting to have a sample of the kind of points you need to join. Should the curves pass exactly by the points or just near them? How to determine the orders of points? Can be trivial if relatively linear, less trivial if they are all over the plane.
In short, we need more info.

Is this sort of what you're looking for?

Code:

// spline curve between random vertices
int nodeCount = 60;
float nodeSize = 6.0;
float padding = 50.0;
Vertex3D[] v = new Vertex3D[nodeCount];
 
void setup(){
  size(500, 500, P3D);
  background(255);
  lights();
  
  // argument changes spline interpolation
  curveTightness(0);
 
  // calc random vertices
  for (int i=0; i<v.length; i++){
    v[i] = new Vertex3D(random(padding, width-padding), random(padding, height-padding), random(-padding, padding));
  }
 
  // draw spline curve
  noFill();
  stroke(0);
  beginShape();
  curve(v[0].x, v[0].y, v[0].z, v[0].x, v[0].y, v[0].z, v[1].x, v[1].y, v[1].z, v[2].x, v[2].y, v[2].z);
  for (int i=0; i<v.length-3; i++){
    curve(v[i].x, v[i].y, v[i].z, v[i+1].x, v[i+1].y, v[i+1].z, v[i+2].x, v[i+2].y, v[i+2].z, v[i+3].x, v[i+3].y, v[i+3].z);
  }
  curve(v[v.length-3].x, v[v.length-3].y, v[v.length-3].z, v[v.length-2].x, v[v.length-2].y, v[v.length-2].z, v[v.length-1].x, v[v.length-1].y, v[v.length-1].z, v[v.length-1].x, v[v.length-1].y, v[v.length-1].z);
 
  // draw nodes
  noStroke();
  for (int i=0; i<v.length; i++){
    pushMatrix();
    translate(v[i].x, v[i].y, v[i].z);
    fill(100);
    if (i==0 || i == v.length-1){
	fill(255, 75, 0);
    }
    box(nodeSize, nodeSize, nodeSize);
    popMatrix();
  }
}
 
class Vertex3D{
  float x, y, z;
 
  Vertex3D(){
  }
 
  Vertex3D(float x, float y, float z){
    this.x = x;
    this.y = y;
    this.z = z;
  }
} 

if you want to get into the math, it's possible to convert catmull-rom curves to beziers. a curve is constructed using a "basis matrix", a 4x4 matrix of numbers that are multiplied out to create the exact curve coordinates. catmull-rom and bezier curves each have their own basis matrix, so you can do:

catmull-rom point * inverse of catmull-rom basis matrix * bezier basis matrix = bezier curve point

and catmull-rom curves (as implemented in p5) have the curveTightness() function that allows you to tweak how closely the points connect (this relates to a multiplier used in the matrix itself).

it's a little mind-bending, but fun when you get it to work :)

or barring all that, there's code around (i think graphics gems had some) that'll try to fit bezier curves to a set of points.

I think the easiest solution( conceptually and in code) to this is using quadratic beziers. The algorithm, as given in Keith Peter's 'Foundation Actionscript 3.0 Animation' and elsewhere ( and not too hard to come up by oneself if you think about it) is to use the given points you want to join as control points ( except the first and last point) of piecewise quadratic beziers anchored between the average of successive pairs of points.
Since Processing does not have quadratic beziers one will have to use its cubic beziers converted to quadratic beziers as given in my post 'quadratic bezier from cubic bezier' in this forum.

Here is some code to smoothly join a set of points captured in a mousedrag( i am capturing only every 5th point to make it more rounded):
Quote: