subDivideMesh()

in src/engine/actvolume/tetra.js [262:356]
80 lines of code
11 McCabe index (conditional complexity)

  subDivideMesh(numSubdividesOfOrigTetra) {
    if (numSubdividesOfOrigTetra === 0) {
      return 1;
    }
    const triStackSrc = new TriangleStack();
    triStackSrc.create(numSubdividesOfOrigTetra);
    const triStackDst = new TriangleStack();
    triStackDst.create(numSubdividesOfOrigTetra);

    const numTriangles = this.m_triangleSet.getNumTriangles();
    for (let t = 0; t < numTriangles; t++) {
      const triIndices = this.m_triangleSet.m_triangles[t].m_indices;
      const ia = triIndices[0];
      const ib = triIndices[1];
      const ic = triIndices[2];
      const va = this.m_pointSet.m_points[ia].m_point;
      const vb = this.m_pointSet.m_points[ib].m_point;
      const vc = this.m_pointSet.m_points[ic].m_point;
      const okPush = triStackSrc.push(va, vb, vc);
      if (okPush < 1) {
        return okPush;
      }
    } // for (t) all triangles, push em all
    let stackSrc = triStackSrc;
    let stackDst = triStackDst;
    for (let iter = 0; iter < numSubdividesOfOrigTetra; iter++) {
      const numStacked = stackSrc.getStackDepth();
      for (let s = 0; s < numStacked; s++) {
        // pop tri from stack
        const triSingle = stackSrc.pop();
        if (triSingle === null) {
          return -1;
        }
        const v1 = triSingle.va;
        const v2 = triSingle.vb;
        const v3 = triSingle.vc;

        // create additional vertices
        const v12 = new THREE.Vector3();
        const v23 = new THREE.Vector3();
        const v31 = new THREE.Vector3();
        v12.addVectors(v1, v2);
        v12.normalize();
        v23.addVectors(v2, v3);
        v23.normalize();
        v31.addVectors(v3, v1);
        v31.normalize();

        stackDst.push(v1, v12, v31);
        stackDst.push(v2, v23, v12);
        stackDst.push(v3, v31, v23);
        stackDst.push(v12, v23, v31);
      } // for (s) stacked triangles
      // exchange stack
      const stackTmp = stackSrc;
      stackSrc = stackDst;
      stackDst = stackTmp;
    } // for (iter) all stack depth, subdivide iterations
    // now we have stack src
    const numTrisInStack = stackSrc.getStackDepth();
    // vertices should not be more than 12/20 == 0.6
    const estimateNumVertices = Math.floor(numTrisInStack * 3 * 0.6);
    this.m_triangleSet.create(numTrisInStack);
    this.m_pointSet.create(estimateNumVertices);
    // let numTrisFromStack = 0;
    while (!stackSrc.isEmpty()) {
      // V3f va, vb, vc;
      // stackSrc->pop(va, vb, vc);
      const triSingle = stackSrc.pop();
      const va = triSingle.va;
      const vb = triSingle.vb;
      const vc = triSingle.vc;
      const indA = this.m_pointSet.addPoint(va.x, va.y, va.z);
      const indB = this.m_pointSet.addPoint(vb.x, vb.y, vb.z);
      const indC = this.m_pointSet.addPoint(vc.x, vc.y, vc.z);

      const okAddTri = this.m_triangleSet.addTriangle(indA, indB, indC);
      if (okAddTri !== 1) {
        return okAddTri;
      }
      // numTrisFromStack++;
    } // while
    // assert(m_pointsSet.getNumPoints() <= estimateNumVertices);
    // assert(m_triangleSet.getNumTriangles() <= numTrisInStack);
    const numPts = this.m_pointSet.getNumPoints();
    const numTris = this.m_triangleSet.getNumTriangles();
    const ERR_ESTIMATE = -10;
    if (numPts > estimateNumVertices) {
      return ERR_ESTIMATE;
    }
    if (numTris > numTrisInStack) {
      return ERR_ESTIMATE;
    }
    return 1;
  }