The algorithm is called "convex hull", IIRC.

That drawing seems so like an egg variation of perlin noise I've tweaked some time ago:  

GoToLoop:

Could you mind showing me the key part of the source code?
Thank you any way. Your advice is helpful.

Tom Tong

It's not my source code. Just a tweaked version I did.

The code below draws a closed Bezier spline through a set of points stored as PVector objects the array called path. Note that the points all have a z value of 0 and are in order arround the contour.

Depending on how your data is stored in the array then you will have to extract all the points for a given height (z value) then work out the order they are to be linked. A brute force approach would be to select a point at random, then find the point nearest to it (ignoring itself) then find the nearest point to that one (ignoring the two points already selected) and repeat for all points.

1. // Adapted from information found at
2. // http://scaledinnovation.com/analytics/splines/aboutSplines.html
3. PVector[] path;
4. // The arrays hold the control points calculated
5. PVector[] p1;
6. PVector[] p2;
7. 
   
8. void setup() {
9.   size(400, 400);
10.   ellipseMode(CENTER);
11.   noFill();
12.   // Calculate the contour
13.   getPath();
14.   getControlPoints();
15.   // Draw the contour
16.   drawContour();
17.   // Draw the countour points (red)
18.   drawContourPoints();
19.   // Draw the calculated control points (blue)
20.   //  drawControlPoints();
21. }
22. 
    
23. public void drawContourPoints() {
24.   noStroke();
25.   fill(255, 0, 0);
26.   for (int i = 0; i < path.length; i++)
27.     ellipse(path[i].x, path[i].y, 8, 8);
28. }
29. 
    
30. public void drawControlPoints() {
31.   noStroke();
32.   fill(0, 0, 255);
33.   for (int i = 0; i < path.length; i++) {
34.     ellipse(p1[i].x, p1[i].y, 8, 8);
35.     ellipse(p2[i].x, p2[i].y, 8, 8);
36.   }
37. }
38. 
    
39. public void drawContour() {
40.   PVector next, curr, cp1, cp2;
41.   strokeWeight(1.5);
42.   int n = path.length;
43.   int i1;
44.   for (int i = 0; i < n; i++) {
45.     i1 = (i + 1) % n;
46.     curr = path[i];
47.     cp1 = p2[i];
48.     cp2 = p1[i1];
49.     next = path[i1];
50.     bezier(curr.x, curr.y, cp1.x, cp1.y, cp2.x, cp2.y, next.x, next.y);
51.   }
52. }
53. 
    
54. public void getControlPoints() {
55.   int n = path.length;
56.   p1 = new PVector[path.length];
57.   p2 = new PVector[path.length];
58.   int leftIdx, rightIdx;
59.   PVector left, right, curr;
60.   float s = 0.65; // scale factor
61.   for (int i = 0; i < path.length; i++) {
62.     leftIdx = (i == 0) ? n-1 : i-1;
63.     rightIdx = (i == n - 1) ? 0 : i + 1;
64.     left = path[leftIdx];
65.     right = path[rightIdx];
66.     curr = path[i];
67.     float d01 = PVector.dist(left, curr);
68.     float d12 = PVector.dist(right, curr);
69.     float fa = s * d01 / (d01 + d12);
70.     float fb = s * d12 / (d01 + d12);
71.     p1[i] = new PVector(curr.x - fa * (right.x - left.x), curr.y - fb * (right.y - left.y));
72.     p2[i] = new PVector(curr.x + fb * (right.x - left.x), curr.y + fb * (right.y - left.y));
73.   }
74. }
75. 
    
76. public void getPath() {
77.   path = new PVector[] {
78.     new PVector(100, 100),
79.     new PVector(250, 100),
80.     new PVector(350, 200),
81.     new PVector(100, 250)
82.   };
83. }