3D Printed Ping-Pong Ball

The purpose of this instructable is to model a ping-pong ball that can be easily
3d printed while keeping a low weight for playability. I got the inspiration for
this project from the deceptor concept from finnish designer janne kyttanen
(read about it here : 3d printed ping pong table + paddles ).

One drawback of current 3d printing techniques is that they typically don't allow
a wall thickness under 0.8mm, which would result in a heavy and thus not
practical ball (standard 40mm balls weigh 2.7 grams).
To mitigate that issue, i chose to use a geodome-like structure, which has a high
strength to weight ratio.

We will walk through the steps required to model such a ball in the following
sections. The only tool we'll be using for this purpose is OpenJSCAD,
a powerful online script-based 3d modeler. You need to be familiar with
javascript syntax to make the most of this tutorial.

Let's get started!

First start OpenJSCAD by clicking on the following link : OpenJSCAD

The code editor on the right should display the following code :

function main() {
return union( 	difference(cube({size: 3, center: true}),
				   sphere({r:2, center: true})),
		intersection(sphere({r: 1.3, center: true}),
			     cube({size: 2.1, center: true}))
		).translate([0,0,1.5]).scale(10);
}

This script here generates the model shown in the 3d view. Notice that what gets
displayed is what you return from the main function. You can play with that code
if you wish, for example by modifying the sphere radius or cube size. For a
detailed description of the all available geometric primitives and transformations,
refer to the OpenJSCAD User Guide.

To see the result, regenerate the model by pressing Shift + Enter.

Next we'll start modelling our ping-pong ball.

We start with the external envellope of the ball, which is a sphere with a 40mm diameter.

function main(){
    var ballDiameter = 40;
    var sphereRes = 50;
    
    var outerSphere = CSG.sphere({
      center: [0, 0, 0],
      radius: ballDiameter/2.,    // must be scalar
      resolution: sphereRes        // optional
    });
    
    return outerSphere;
}

You can find more info on generating spheres with OpenJSCAD in the user guide here.

After generating the model (Shift + Enter), you should see a sphere like in the picture above.

But wait, what we have here is a solid sphere, which would result in a pretty
heavy ball! To model an actual ping pong ball, we need to hollow out the
inside of our sphere.
To do that, we will use a boolean operation called a Difference, which is done
in OpenJSCAD by calling the difference function with two 3d objects as parameters.

Basic ping-pong ball script

function main(){
    var ballDiameter = 40;
    var wallThickness = 1.0;
    var sphereRes = 50;
    
    var outerSphere = CSG.sphere({
      center: [0, 0, 0],
      radius: ballDiameter/2.,    // must be scalar
      resolution: sphereRes        // optional
    });
    
    var innerSphere = CSG.sphere({
      center: [0, 0, 0],
      radius: ballDiameter/2. - wallThickness ,    // must be scalar
      resolution: sphereRes        // optional
    });
    
    var cuttingCube = CSG.cube({
        center: [0, -ballDiameter/2., 0],
        radius: [ballDiameter/2, ballDiameter/2, ballDiameter/2]
    });
    
    var ball = difference(outerSphere, innerSphere);
    return difference(ball, cuttingCube);
}

I used a cube to cut the sphere in half so you can better see that the ball is
indeed hollow. A wall thickness of 1mm ensures printability as well as solidity,
especially as we'll later add holes all over the surface of the ball.

Now we'll look into how to subdivide a sphere into a determined number of
triangles of approximately similar shape. The method described here is
often used to build polygonal approximations of spheres, such as detailed
in this OpenGL tutorial : http://www.opengl.org.ru/docs/pg/0208.html.
In our case, this will be the building step to generate the holes that will
transfrom our regular ball into a geodeome-like one.

First we start with a regular isocahedron , which has twenty triangular faces, and
the interesting property that each of its vertices lie on a sphere.
Then for every triangle, we split each of the three edges at the middle, which
gives us three additional vertices which we use to subdivide said triangle
into four smaller triangles. The three vertices are then translated outwards
so they lie on the sphere's surface.

Isocahedron OpenJSCAD script

function main(){
    var X = 0.525731112119133606;
    var Z = 0.850650808352039932;
    var radius = 20;
    var vdata = [
        [-X, 0.0, Z], [ X, 0.0, Z ], [ -X, 0.0, -Z ], [ X, 0.0, -Z ],
        [ 0.0, Z, X ], [ 0.0, Z, -X ], [ 0.0, -Z, X ], [ 0.0, -Z, -X ],
        [ Z, X, 0.0 ], [ -Z, X, 0.0 ], [ Z, -X, 0.0 ], [ -Z, -X, 0.0 ]
    ]; // isocahedron vertex coordinates
    var tindices = [
        [0, 4, 1], [ 0, 9, 4 ], [ 9, 5, 4 ], [ 4, 5, 8 ], [ 4, 8, 1 ],
        [ 8, 10, 1 ], [ 8, 3, 10 ], [ 5, 3, 8 ], [ 5, 2, 3 ], [ 2, 7, 3 ],
        [ 7, 10, 3 ], [ 7, 6, 10 ], [ 7, 11, 6 ], [ 11, 0, 6 ], [ 0, 1, 6 ],
        [ 6, 1, 10 ], [ 9, 0, 11 ], [ 9, 11, 2 ], [ 9, 2, 5 ], [ 7, 2, 11 ]
    ]; // isocahedron triangles
    
    return polyhedron({      
      points: vdata,
      triangles: tindices
    }).scale([radius, radius, radius]);
}

Next we write the subdivision fonction for a unit sphere approximation :

The subdvide function

/* fn 	subdivide(v1, v2, v3, addPolyCb, depth)
* brief subdivides a triangle into 4 smaller ones
* params 	v1, v2, v3 : triangle vertices
*		addPolyCb : callback for add polygon notification
*		depth : number of remaining subdivision iterations
*/
function subdivide(v1, v2, v3, addPolyCb, depth)
{
    if(depth == 0) {
        addPolyCb(v1, v2, v3);
       return;
    }
    
    var v12 = v1.plus(v2).unit(); // middle of v1v2 edge projected on the unit sphere
    var v23 = v2.plus(v3).unit();
    var v31 = v3.plus(v1).unit();
    var newDepth = depth - 1;
    subdivide(v1, v12, v31, addPolyCb, newDepth);
    subdivide(v2, v23, v12, addPolyCb, newDepth);    
    subdivide(v3, v31, v23, addPolyCb, newDepth);
    subdivide(v12, v23, v31, addPolyCb, newDepth);
}

The subdivision process works recursively; starting from the 20 isocahedron
faces, each step of the subdivision multiplies the total number of faces by 4.
Consequently, a depth of 1 generates an 80 faces polyhedron.

We can now generate a sphere approximation by calling the subdivide function
iteratively over the isocahedron faces as follows :

80 faces geodesic sphere script

function main()
{
    var ballDiameter = 40;
    var ballRadius = ballDiameter/2.;
    var polygons = []; // list of polygons
    addPolyCb = function(v1, v2, v3) 
    { 
        polygons.push(new CSG.Polygon([
              new CSG.Vertex(new CSG.Vector3D(v3.x,v3.y,v3.z)),
              new CSG.Vertex(new CSG.Vector3D(v2.x,v2.y,v2.z)),
              new CSG.Vertex(new CSG.Vector3D(v1.x,v1.y,v1.z))
        ]));
    }
    
    createGeodesicSphere(addPolyCb, 1);
    var unitSphereApprox = CSG.fromPolygons(polygons);
    
    return unitSphereApprox.scale([ballRadius, ballRadius, ballRadius]);
}

// subdivides a unit isocahedron n=depth times and calls a callback for each created face
function createGeodesicSphere(addPolyCb, depth) 
{
    var X = 0.525731112119133606;
    var Z = 0.850650808352039932;
    var vdata = [
        [-X, 0.0, Z], [ X, 0.0, Z ], [ -X, 0.0, -Z ], [ X, 0.0, -Z ],
        [ 0.0, Z, X ], [ 0.0, Z, -X ], [ 0.0, -Z, X ], [ 0.0, -Z, -X ],
        [ Z, X, 0.0 ], [ -Z, X, 0.0 ], [ Z, -X, 0.0 ], [ -Z, -X, 0.0 ]
    ];
    var tindices = [
        [0, 4, 1], [ 0, 9, 4 ], [ 9, 5, 4 ], [ 4, 5, 8 ], [ 4, 8, 1 ],
        [ 8, 10, 1 ], [ 8, 3, 10 ], [ 5, 3, 8 ], [ 5, 2, 3 ], [ 2, 7, 3 ],
        [ 7, 10, 3 ], [ 7, 6, 10 ], [ 7, 11, 6 ], [ 11, 0, 6 ], [ 0, 1, 6 ],
        [ 6, 1, 10 ], [ 9, 0, 11 ], [ 9, 11, 2 ], [ 9, 2, 5 ], [ 7, 2, 11 ]
    ];

    // iterate over isocahedron triangles
    for(var i = 0; i < 20; i++)
        subdivide(  new CSG.Vector3D(vdata[tindices[i][0]]), 
                    new CSG.Vector3D(vdata[tindices[i][1]]), 
                    new CSG.Vector3D(vdata[tindices[i][2]]), 
                    addPolyCb, depth);
} 

To run this script, copy and paste the code in your favorite code editor, and save
the file with the .jscad extension. Then just drag & drop the file in the recangular
area at the bottom left corner of your OpenJSCAD browser window.

In this section we'll look into how to generate a pattern of prisms from the geodesic sphere faces, that we'll then substract from our ball from Step 2 to generate the actual holes.

First we need to create prisms from the geodesic sphere triangles.
To do so, we first create a smaller triangle within each triangle of the geodesic
sphere by offsetting its edges inward by a fixed distance and computing
the intersection points of the translated edges which make up the vertices
of the new triangle (see picture above).

To generate the prism, I used the solidFromSlices method to extrude the current triangle (i1 i2 i3) orthogonally to its surface.

The createPrism function

// generates a prism from a unit sphere triangle, a radius, and an offset
function createPrism(sphereTri, radius, offset)
{// compute the coordinates of the vertices of the input triangle
    var v1 = new CSG.Vector3D(scalar_mul(sphereTri[0], radius));
    var v2 = new CSG.Vector3D(scalar_mul(sphereTri[1], radius));
    var v3 = new CSG.Vector3D(scalar_mul(sphereTri[2], radius));
    
    // make plane base (v1, x, y)
    var xAxis = v2.minus(v1).unit();
    var v13 = v3.minus(v1);
    var yAxis = v13.minus(xAxis.times(v13.dot(xAxis))).unit();

    // retrieve 2d coordinates of the triangle vertices in that base
    var v1_2d = new CSG.Vector2D(0, 0);
    var v2_2d = new CSG.Vector2D(v2.minus(v1).dot(xAxis), 0);
    var v3_2d = new CSG.Vector2D(v3.minus(v1).dot(xAxis), v3.minus(v1).dot(yAxis));

    // get the middle of each segment in the plane
    var v12_2d = v2_2d.minus(v1_2d);
    var v23_2d = v3_2d.minus(v2_2d);
    var v31_2d = v1_2d.minus(v3_2d);

    // get unit vector perpendicular to i1i2 segment in the plane
    var ortho12 = new CSG.Vector2D(-v12_2d.y, v12_2d.x).unit();
    if(v3_2d.minus(v1_2d).dot(ortho12) <0)
        ortho12 = ortho12.times(-1);
        
    var ortho23 = new CSG.Vector2D(-v23_2d.y, v23_2d.x).unit();
    if(v1_2d.minus(v2_2d).dot(ortho23) <0)
        ortho23 = ortho23.times(-1);
        
    var ortho31 = new CSG.Vector2D(-v31_2d.y, v31_2d.x).unit();
    if(v2_2d.minus(v1_2d).dot(ortho31) <0)
        ortho31 = ortho31.times(-1);
        
    // translate all tri segments inward by the same offset
    var s12b = translate_segment([v1_2d, v2_2d], ortho12.times(offset));
    var s23b = translate_segment([v2_2d, v3_2d], ortho23.times(offset));
    var s31b = translate_segment([v3_2d, v1_2d], ortho31.times(offset));
    
    // compute intersection points of translated segments in the plane
    var i1 = intersect(s12b, s23b);
    var i2 = intersect(s23b, s31b);
    var i3 = intersect(s31b, s12b);

    var i1_3d = v1.plus(xAxis.times(i1.x)).plus(yAxis.times(i1.y));
    var i2_3d = v1.plus(xAxis.times(i2.x)).plus(yAxis.times(i2.y));
    var i3_3d = v1.plus(xAxis.times(i3.x)).plus(yAxis.times(i3.y));
    
    // create a polygon from the intersection points
    var tri =  new CSG.Polygon([
                new CSG.Vertex(i1_3d),
                new CSG.Vertex(i2_3d),
                new CSG.Vertex(i3_3d)
               ]);
               
    var zAxis = tri.plane.normal;
    return tri.solidFromSlices({
      numslices: 2,              // amount of slices
      loop: false,            // final CSG is closed by looping (start = end) like a torus
      callback: function(t,slice) {
          // echo("t:" + t)
         return this.translate( scalar_mul([zAxis.x, zAxis.y, zAxis.z], 4*t) );
      }
   }).translate(scalar_mul([zAxis.x, zAxis.y, zAxis.z], -2));
}

// multiplies a 3d vector by a scalar
function scalar_mul(v, c)
{
    return [c*v[0], c*v[1], c*v[2]];
}

// translates a 2d segment by a 2d vector
function translate_segment(seg, vec)
{
    s0b = seg[0].plus(vec);
    s1b = seg[1].plus(vec);
    
    return [s0b, s1b];
}

// computes the intersection of 2 2d segments
function intersect(s1, s2)
{
    var p = s1[0];
    var q = s2[0];
    var r = s1[1].minus(p);
    var s = s2[1].minus(q);
    
    var u = q.minus(p).cross(r)/r.cross(s);
    var t = q.minus(p).cross(s)/r.cross(s);
    
    if(r.cross(s) != 0 && u >= 0 && u<= 1 && t >= 0 && t<= 1)
        return p.plus(r.times(t));
   return null;
}

Making use of the createPrism function above, whe can now generate the full
hole pattern by iterating over the geodesic sphere triangles :

Hole pattern script

function main(){
    var ballDiameter = 40; // mm
    var segmentWidth = 2; // mm

    var sphereTris = []; // holds list of geodesic sphere triangles
    addPolyCb = function(v1, v2, v3) 
    { 
        sphereTris.push([
                            [v1.x, v1.y, v1.z],
                            [v2.x, v2.y, v2.z],
                            [v3.x, v3.y, v3.z]
        ]); 
    }
    
    createGeodesicSphere(addPolyCb, 1);
    
    var holePattern;
    for(j=0; j!=sphereTris.length; ++j)
    {
        var prism =  createPrism(sphereTris[j], ballDiameter/2., segmentWidth/2.);
        if(j==0)
        {
            holePattern = prism;
        }
        else
            holePattern = holePattern.union(prism);
    }
    
    return holePattern;
}

function subdivide(v1, v2, v3, addPolyCb, depth) 
{
    if(depth == 0) {
        addPolyCb(v1, v2, v3);
       return;
    }
    
    var v12 = v1.plus(v2).unit();
    var v23 = v2.plus(v3).unit();
    var v31 = v3.plus(v1).unit();
    var newDepth = depth - 1;
    subdivide(v1, v12, v31, addPolyCb, newDepth);
    subdivide(v2, v23, v12, addPolyCb, newDepth);    
    subdivide(v3, v31, v23, addPolyCb, newDepth);
    subdivide(v12, v23, v31, addPolyCb, newDepth);
}

function createGeodesicSphere(addPolyCb, depth) {
    var X = 0.525731112119133606;
    var Z = 0.850650808352039932;
    var vdata = [
        [-X, 0.0, Z], [ X, 0.0, Z ], [ -X, 0.0, -Z ], [ X, 0.0, -Z ],
        [ 0.0, Z, X ], [ 0.0, Z, -X ], [ 0.0, -Z, X ], [ 0.0, -Z, -X ],
        [ Z, X, 0.0 ], [ -Z, X, 0.0 ], [ Z, -X, 0.0 ], [ -Z, -X, 0.0 ]
    ];
    var tindices = [
        [0, 4, 1], [ 0, 9, 4 ], [ 9, 5, 4 ], [ 4, 5, 8 ], [ 4, 8, 1 ],
        [ 8, 10, 1 ], [ 8, 3, 10 ], [ 5, 3, 8 ], [ 5, 2, 3 ], [ 2, 7, 3 ],
        [ 7, 10, 3 ], [ 7, 6, 10 ], [ 7, 11, 6 ], [ 11, 0, 6 ], [ 0, 1, 6 ],
        [ 6, 1, 10 ], [ 9, 0, 11 ], [ 9, 11, 2 ], [ 9, 2, 5 ], [ 7, 2, 11 ]
    ];
    
    for(var i = 0; i < 20; i++)
        subdivide(    new CSG.Vector3D(vdata[tindices[i][0]]), 
                    new CSG.Vector3D(vdata[tindices[i][1]]), 
                    new CSG.Vector3D(vdata[tindices[i][2]]), 
                    addPolyCb, depth);
}

This is where we combine the results of steps 2 and 4 to achieve the desired
outcome. Using the functions createGeodesicSphere and createPrism
encoutered in the previous steps, the end result is obtained by first substracting
each prism from the ball, and then hollowing out the ball as seen in Step 2.
I chose a subdivision depth of 2, which means our ball has 320 holes, which
is the best fit for a 3d print of that size.

Final script

function main(){
    // definitions
    var ballDiameter = 40;
    var ballRadius = ballDiameter/2.;
    var wallThickness = 1.0;
    var segmentWidth = 1.1; // width of an individual link of the structure
    var sphereRes = 33;
    var subdivisionDepth = 2;
    
    var outerSphere = CSG.sphere({
      center: [0, 0, 0],
      radius: ballRadius,    // must be scalar
      resolution: sphereRes        // optional
    });
   
    var innerSphere = CSG.sphere({
      center: [0, 0, 0],
      radius: ballRadius - wallThickness ,    // must be scalar
      resolution: sphereRes        // optional
    });
    
    var ball = outerSphere;
    var geoSphereTris = []; // list of geosphere triangles
    addPolyCb = function(v1, v2, v3) 
    { 
        geoSphereTris.push([
                            [v1.x, v1.y, v1.z],
                            [v2.x, v2.y, v2.z],
                            [v3.x, v3.y, v3.z]
        ]); 
    }
    
    createGeodesicSphere(addPolyCb, subdivisionDepth);

    // successively substract each prism from the ball
    for(j=0; j!=geoSphereTris.length; ++j)
    {
        var prism =  createPrism(geoSphereTris[j], ballRadius, segmentWidth/2.);
        ball = difference(ball, prism);
    }
    
    ball = difference(ball, innerSphere); // hollow out the inside
    
    return ball;
}

Once the model is generated, you can export it directly in STL format using the
'Generate STL' button under the 3d view. You can now get the model printed
through your favorite 3d printing service or local store.

Warning : this model cannot be printed as-is on FDM printers, it would need an additional removable support structure, which is beyond the scope of this tutorial. However, it can be printed on SLS or SLA printers effortlessly.

Thank you for reading this instructable, I hope you gained something valuable from it.

You can find the resulting STL files here :

http://www.thingiverse.com/thing:859499

http://www.thingiverse.com/thing:859513 ( w/ support structure for FDM printers )


Best wishes,

Vincent