static detectNonEmptyBox()

in src/engine/loaders/voltools.js [1121:1317]
172 lines of code
87 McCabe index (conditional complexity)

  static detectNonEmptyBox(pixelsSrc, xDim, yDim, zDim, boxMin, boxMax) {
    const MIN_VAL_BARRIER = 8;
    const TWICE = 2;
    const FOUR = 4;
    const xyDim = xDim * yDim;
    const xDimHalf = Math.floor(xDim / TWICE);
    const yDimHalf = Math.floor(yDim / TWICE);
    const zDimHalf = Math.floor(zDim / TWICE);
    let x, y, z;
    let isEmpty;

    let xBorderMin = 0;
    let yBorderMin = 0;
    let zBorderMin = 0;
    let xBorderMax = 0;
    let yBorderMax = 0;
    let zBorderMax = 0;

    const numBytesPerPixel = Math.floor(pixelsSrc.length / (xDim * yDim * zDim));
    if (numBytesPerPixel === 1) {
      isEmpty = true;
      for (x = 0; x < xDimHalf && isEmpty; x++) {
        // check is empty plane
        for (y = 0; y < yDim && isEmpty; y++) {
          for (z = 0; z < zDim && isEmpty; z++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      xBorderMin = x;

      isEmpty = true;
      for (x = xDim - 1; x > xDimHalf && isEmpty; x--) {
        // check is empty plane
        for (y = 0; y < yDim && isEmpty; y++) {
          for (z = 0; z < zDim && isEmpty; z++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      xBorderMax = x;

      isEmpty = true;
      for (y = 0; y < yDimHalf && isEmpty; y++) {
        // check is empty plane
        for (x = 0; x < xDim && isEmpty; x++) {
          for (z = 0; z < zDim && isEmpty; z++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      yBorderMin = y;

      isEmpty = true;
      for (y = yDim - 1; y > yDimHalf && isEmpty; y--) {
        // check is empty plane
        for (x = 0; x < xDim && isEmpty; x++) {
          for (z = 0; z < zDim && isEmpty; z++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      yBorderMax = y;

      isEmpty = true;
      for (z = 0; z < zDimHalf && isEmpty; z++) {
        // check is empty plane
        for (x = 0; x < xDim && isEmpty; x++) {
          for (y = 0; y < yDim && isEmpty; y++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      zBorderMin = z;

      isEmpty = true;
      for (z = zDim - 1; z > zDimHalf && isEmpty; z--) {
        // check is empty plane
        for (x = 0; x < xDim && isEmpty; x++) {
          for (y = 0; y < yDim && isEmpty; y++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      zBorderMax = z;
    } else if (numBytesPerPixel === FOUR) {
      // 4 bpp image scan
      const OFF_3 = 3;
      isEmpty = true;
      for (x = 0; x < xDimHalf && isEmpty; x++) {
        // check is empty plane
        for (y = 0; y < yDim && isEmpty; y++) {
          for (z = 0; z < zDim && isEmpty; z++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off * FOUR + OFF_3] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      xBorderMin = x;

      isEmpty = true;
      for (x = xDim - 1; x > xDimHalf && isEmpty; x--) {
        // check is empty plane
        for (y = 0; y < yDim && isEmpty; y++) {
          for (z = 0; z < zDim && isEmpty; z++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off * FOUR + OFF_3] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      xBorderMax = x;

      isEmpty = true;
      for (y = 0; y < yDimHalf && isEmpty; y++) {
        // check is empty plane
        for (x = 0; x < xDim && isEmpty; x++) {
          for (z = 0; z < zDim && isEmpty; z++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off * FOUR + OFF_3] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      yBorderMin = y;

      isEmpty = true;
      for (y = yDim - 1; y > yDimHalf && isEmpty; y--) {
        // check is empty plane
        for (x = 0; x < xDim && isEmpty; x++) {
          for (z = 0; z < zDim && isEmpty; z++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off * FOUR + OFF_3] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      yBorderMax = y;

      isEmpty = true;
      for (z = 0; z < zDimHalf && isEmpty; z++) {
        // check is empty plane
        for (x = 0; x < xDim && isEmpty; x++) {
          for (y = 0; y < yDim && isEmpty; y++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off * FOUR + OFF_3] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      zBorderMin = z;

      isEmpty = true;
      for (z = zDim - 1; z > zDimHalf && isEmpty; z--) {
        // check is empty plane
        for (x = 0; x < xDim && isEmpty; x++) {
          for (y = 0; y < yDim && isEmpty; y++) {
            const off = z * xyDim + y * xDim + x;
            if (pixelsSrc[off * FOUR + OFF_3] > MIN_VAL_BARRIER) {
              isEmpty = false;
            }
          } // for (z)
        } // for (y()
      } // for (x)
      zBorderMax = z;
    }
    boxMin.x = xBorderMin / xDim;
    boxMin.y = yBorderMin / yDim;
    boxMin.z = zBorderMin / zDim;
    boxMax.x = xBorderMax / xDim;
    boxMax.y = yBorderMax / yDim;
    boxMax.z = zBorderMax / zDim;
  }