you had already a line defining the node to connect to

So I just added one line (in function render()) to use this entry (it's called conn)

1. import peasy.*;
2. import toxi.geom.Vec3D;
3. int NUM_PARTICLES = 5000;
4. PeasyCam cam;
5. Node nodes[] = new Node[NUM_PARTICLES];
6. float radius = 150;
7. void setup() {
8.   size(800, 600, P3D);
9.   background(255); 
10.   cam = new PeasyCam(this, width);
11.   for (int i=0; i<NUM_PARTICLES; i++) {
12.     Node n = new Node(random(0, TWO_PI), random(-1, 1));
13.     nodes[i] = n;
14.   }
15.   for (int j=0; j<NUM_PARTICLES; j++) {
16.     nodes[j].connect(nodes[(int)random(0, nodes.length-1)]);  // was there already
17.   }
18. }
19. void draw() {
20.   background(255);
21.   for (int i=0; i<nodes.length; i++) {
22.     Node n = nodes[i];
23.     n.render();
24.   }
25. }
26. // =====================================================================
27. class Node extends Vec3D {
28.   float theta, u;
29.   Node conn;    // that's it
30.   Node(float Theta, float U) {
31.     theta = Theta;
32.     u = U;
33.     x = radius*cos(theta)*sqrt(1-(u*u));
34.     y = radius*sin(theta)*sqrt(1-(u*u));
35.     z = u*radius;
36.   }
37.   void connect(Node cn) {
38.     conn = cn;
39.   }
40.   void render() {
41.     pushMatrix();
42.     translate(x, y, z);
43.     point(0, 0, 0);
44.     stroke(0, 0, 0, 20);
45.     popMatrix();
46.     line (x, y, z, conn.x, conn.y, conn.z );   // from me
47.   }
48. }

from the above sketch I don't understand why it draws a hollow sphere

Theta comes randomly 0 to 2PI - that I understand, normal circle.
U comes in -1 to 1 -- that I understand: Since it is mulitplied by radius you get all values between -radius and +radius.

what I don't get is *sqrt(1-(u*u)); -- it looks like derived from Mister Pythagoras a^2 + b^2 = c^2
u^2 + u^2 = c^2
c = ???

and how do play x,y,z together now?

  // constructor
  Node(float Theta, float U) {
    theta = Theta;
    u = U;
    x = radius*cos(theta)*sqrt(1-(u*u));
    y = radius*sin(theta)*sqrt(1-(u*u));
    z = u*radius;
  }  // constructor

Hi Chrisir!

The equation helps to distribute the points more evenly around the sphere... I picked it up from here:  http://blog.arsthanea.com/2009/01/05/black-hole/

@Ale: Thank you very much!




@pootley
look at
https://forum.processing.org/topic/need-help-with-geos-on-a-flat-3d-map
or
https://forum.processing.org/topic/3d-arc-ribbon
maybe ask them

Hello,

I did it.

I skip nodes that are not very close.

I think you need to identify neighbours to connect (not randomly).

Greetings, Chrisir 

1. import peasy.*;
2. import toxi.geom.Vec3D;
3. //
4. // that limits what arcs are drawn (only close together ones)
5. final int distLimit = 40;
6. //
7. int NUM_PARTICLES = 5000;
8. PeasyCam cam;
9. Node nodes[] = new Node[NUM_PARTICLES];
10. //
11. float radius = 150;  // for sphere
12. // for arc: curve:
13. float radiusForControlPoint = -500;  //  0.00000001;  // try 10000 / -600
14. //
15. // --------------------------------------------------------
16. //
17. void setup() {
18.   size(800, 600, P3D);
19.   background(255);
20.   cam = new PeasyCam(this, width);
21.   for (int i=0; i<NUM_PARTICLES; i++) {
22.     //Node n = new Node(random(0, TWO_PI), random(-1, -.71));  // hat
23.     //Node n = new Node(random(0, TWO_PI), random(-.41, .11));  // belt 
24.     // Node n = new Node(random(0, TWO_PI), .3 );  // small ring
25.     // Node n = new Node( PI , .3 );  // one point
26.     Node n = new Node(random(0, TWO_PI), random(-1, 1));   // full sphere
27.     nodes[i] = n;
28.     // Testing
29.     if (i<100) {
30.       //println(n.x+", "+n.y+", "+n.z);
31.     }
32.   }
33.   for (int j=0; j<NUM_PARTICLES; j++) {
34.     nodes[j].connect(nodes[(int)random(0, nodes.length-1)]);
35.   }
36. } // func
37. //
38. // -----------------------------------------------------------
39. //
40. void draw() {
41.   background(255);
42.   pushMatrix();
43.   translate(0, 0, 0);
44.   fill(0, 244, 0);
45.   box(10, 10, 10);
46.   stroke(0, 0, 0, 20);
47.   popMatrix();
48.   for (int i=0; i<nodes.length; i++) {
49.     Node n = nodes[i];
50.     n.render();
51.   }
52. }
53. //
54. // -----------------------------------------------------------
55. //
56. PVector getVector (float x, float y, float z) {
57.   // note: that func is outside the class
58.   PVector Buffer = new PVector (x, y, z);
59.   return Buffer;
60. }
61. // =====================================================================
62. class Node extends Vec3D {
63.   float theta, u;
64.   PVector controlPointForCurve = new PVector();
65.   color colorStroke;
66.   color colorFill;
67.   boolean bFillIt = false;
68.   Node conn;    // that's it
69.   //
70.   // constructor
71.   Node(float Theta, float U) {
72.     theta = Theta;
73.     u = U;
74.     x = radius*cos(theta)*sqrt(1-(u*u));
75.     y = radius*sin(theta)*sqrt(1-(u*u));
76.     z = u*radius;
77.     colorStroke = color(random(255), random(255), random(255));
78.     colorFill= colorStroke;
79.     bFillIt = false;
80.     if (random (100)>94) {
81.       bFillIt = true;
82.     }
83.     // get controlPointForCurve (similar to above)
84.     controlPointForCurve.x = radiusForControlPoint*cos(theta)*sqrt(1-(u*u));
85.     controlPointForCurve.y = radiusForControlPoint*sin(theta)*sqrt(1-(u*u));
86.     controlPointForCurve.z = u*radiusForControlPoint;
87.   }  // constructor
88.   //
89.   void connect(Node cn) {
90.     conn = cn;
91.   } // func
92.   //
93.   void render() {
94.     pushMatrix();
95.     translate(x, y, z);
96.     //if (z>99) {
97.     point(0, 0, 0);
98.     stroke(0, 0, 0, 20);
99.     //}
100.     popMatrix();
101.     if (getVector(x, y, z).dist(getVector(conn.x, conn.y, conn.z )) < distLimit ) {
102.       // line (for testing)
103.       stroke(255, 2, 2);
104.       stroke(colorStroke);
105.       line (x, y, z, conn.x, conn.y, conn.z );   // red
106.       // now the arc
107.       // can have same color or green
108.       // stroke(2, 255, 2);
109.       // can be filled or not
110.       if (!bFillIt) {
111.         noFill();
112.       }
113.       else {
114.         fill (colorFill);
115.       } // else
116.       // please note two different controlPointForCurve: one from the actual node, one
117.       // from node "conn"
118.       curve (
119.       controlPointForCurve.x, controlPointForCurve.y, controlPointForCurve.z,
120.       x, y, z,
121.       conn.x, conn.y, conn.z,
122.       conn.controlPointForCurve.x, conn.controlPointForCurve.y, conn.controlPointForCurve.z
123.         );   // same color or green
124.     } // if
125.   } // func
126. } // class
127. // ++++++++++++++++++++++++++++++++++++++++++++++++++++