code: private float[] restoreNormals(int[] intNormals, float[] vertices, int[] indices, float normalPrecision) {
  
          // Calculate smooth normals (nominal normals)
          float[] smoothNormals = calcSmoothNormals(vertices, indices);
          float[] normals = new float[vertices.length];
  
          int vc = vertices.length / CTM_POSITION_ELEMENT_COUNT;
          int ne = CTM_NORMAL_ELEMENT_COUNT;
  
          for (int i = 0; i < vc; ++i) {
              // Get the normal magnitude from the first of the three normal elements
              float magn = intNormals[i * ne] * normalPrecision;
  
              // Get phi and theta (spherical coordinates, relative to the smooth normal).
              double thetaScale, theta;
              int intPhi = intNormals[i * ne + 1];
              double phi = intPhi * (0.5 * PI) * normalPrecision;
              if (intPhi == 0) {
                  thetaScale = 0.0f;
              } else if (intPhi <= 4) {
                  thetaScale = PI / 2.0f;
              } else {
                  thetaScale = (2.0f * PI) / intPhi;
              }
              theta = intNormals[i * ne + 2] * thetaScale - PI;
  
              // Convert the normal from the angular representation (phi, theta) back to
              // cartesian coordinates
              double[] n2 = new double[3];
              n2[0] = sin(phi) * cos(theta);
              n2[1] = sin(phi) * sin(theta);
              n2[2] = cos(phi);
              float[] basisAxes = makeNormalCoordSys(smoothNormals, i * ne);
              double[] n = new double[3];
              for (int j = 0; j < 3; ++j) {
                  n[j] = basisAxes[j] * n2[0]
                         + basisAxes[3 + j] * n2[1]
                         + basisAxes[6 + j] * n2[2];
              }
  
              // Apply normal magnitude, and output to the normals array
              for (int j = 0; j < 3; ++j) {
                  normals[i * ne + j] = (float) (n[j] * magn);
              }
          }
  
          return normals;
      }
docs: Convert the normals back to cartesian coordinates.