The Simple, Flexible, Octasphere

18 Dec 2019

When choosing from the Platonic solids, careful you must be. ~ Yoda

Two popular ways of tessellating spheres are the UV sphere (left) and icosphere (middle). The UV sphere is a parametric surface, typically generated with a double-nested loop over θ and φ. The icosphere is generated by starting with a regular icosahedron (the 20-sided Platonic solid) and applying multiple subdivisions. While icospheres are slightly more complex to create than UV spheres, they do not suffer from irregular faces.

Three spheres

In this post I’m championing the octasphere (right). This is subdivided from a mere 8-sided polyhedron, and is arguably less visually pleasing than the icosphere. However it’s easy to directly generate an octasphere to any level of detail parametrically, without actual subdivision. Moreover its 8-way symmetry is useful in a number of ways. For example, it can be generalized to include rounded cuboids like the ones below.

Three cuboids

Octaspheres can be parameterized with plain old lat-long mapping whereas icospheres force you to use an alternative texture mapping scheme. Note however that octaspheres suffer from undersampling near the poles when the geometric LOD is low. If this is a problem, you might want to consider using octahedral mapping instead of lat-long mapping.

Direct Tessellation

To make an octasphere, you can tessellate one-eighth of the shape (i.e. the mesh patch that arises from a single triangle in the octahedron), then make 7 copies at various rotations.

Single patch

To leverage parametric evaluation instead of subdivision, simply march along the sequence of geodesic lines that stretch between two patch boundaries. This is shown in blue in the above image.

The following Python snippet generates the vertices for a single patch.

        def tessellate_octasphere_patch(num_subdivisons):
            n = 2**num_subdivisions + 1
            num_verts = n * (n + 1) // 2
            verts = []
            for i in range(n):
                theta = pi * 0.5 * i / (n - 1)
                point_a = [0, sin(theta), cos(theta)]
                point_b = [cos(theta), sin(theta), 0]
                num_segments = n - 1 - i
                geodesic_verts = compute_geodesic(point_a, point_b, num_segments)
                verts = verts + geodesic_verts
            assert len(verts) == num_verts
            return verts

In the above snippet, compute_geodesic generates a sequence of surface points between point_a and point_b, inclusive. In general this is a hard problem but for spheres it’s easy:

        def compute_geodesic(point_a, point_b, num_segments):
            angle_between_endpoints = math.acos(, point_b))
            rotation_axis = np.cross(point_a, point_b)
            point_list = [point_a]
            if num_segments == 0:
                return point_list
            dtheta = angle_between_endpoints / num_segments
            for point_index in range(1, num_segments):
                theta = point_index * dtheta
                q = quaternion.create_from_axis_rotation(rotation_axis, theta)
                point_list.append(quaternion.apply_to_vector(q, point_a))
            return point_list

To finish making the actual sphere, make 7 copies of the patch at various orientations. Be sure to use rotation rather than mirroring, since the latter would cause inconsistent triangle winding.

Generalized Octaspheres

If you connect the 8 corner patches with degenerate triangles, you can translate them away from each other to create various useful shapes. Try playing with the sliders to see what I mean. To have an effect, the width / height / depth sliders must be more than twice the corner radius. If the canvas looks blank, try refreshing the page.

Source code for creating generalized octasphere meshes using direct parametric evaluation is available at the links below.