findSeedPointOnFirstSlice()

in src/engine/actvolume/lungsfill/seedPoints.js [151:256]
99 lines of code
28 McCabe index (conditional complexity)

  findSeedPointOnFirstSlice(vSeed) {
    const pixelsSrc = this.m_volTexSrc;
    const VAL_BLACK_BARRIER = 50;
    let holeFound = false;

    const NUM_7 = 7;
    const NUM_512 = 512;
    const sizeBlackAreaMin = Math.floor((this.m_xDim * NUM_7) / NUM_512);

    // for each point scan in 4 directions to find white barrier

    const MIN_RAT = 0.2;
    const MAX_RAT = 0.8;
    const yMin = Math.floor(this.m_yDim * MIN_RAT);
    const yMax = Math.floor(this.m_yDim * MAX_RAT);
    const xMin = Math.floor(this.m_xDim * MIN_RAT);
    const xMax = Math.floor(this.m_xDim * MAX_RAT);

    let cx, cy;
    const offZ = 2 * this.m_xDim * this.m_yDim;
    for (cy = yMin; cy < yMax && !holeFound; cy++) {
      const cyOff = cy * this.m_xDim;
      for (cx = xMin; cx < xMax && !holeFound; cx++) {
        const val = pixelsSrc[cx + cyOff + offZ];
        if (val >= VAL_BLACK_BARRIER) {
          continue;
        }
        // we have black current pixel
        let numWhiteBarriers = 0;

        let x, y, len;
        for (len = 0, y = cy - 1; y >= 0; y--, len++) {
          const off = cx + y * this.m_xDim + offZ;
          if (pixelsSrc[off] > VAL_BLACK_BARRIER) {
            if (len > sizeBlackAreaMin) {
              numWhiteBarriers++;
              break;
            }
          }
        } // for (y)
        for (len = 0, y = cy + 1; y < this.m_yDim; y++, len++) {
          const off = cx + y * this.m_xDim + offZ;
          if (pixelsSrc[off] > VAL_BLACK_BARRIER) {
            if (len > sizeBlackAreaMin) {
              numWhiteBarriers++;
            }
            break;
          }
        } // for (y)
        for (len = 0, x = cx - 1; x >= 0; x--, len++) {
          const off = x + cy * this.m_xDim + offZ;
          if (pixelsSrc[off] > VAL_BLACK_BARRIER) {
            if (len > sizeBlackAreaMin) {
              numWhiteBarriers++;
            }
            break;
          }
        } // for (x)
        for (len = 0, x = cx + 1; x < this.m_xDim; x++, len++) {
          const off = x + cy * this.m_xDim + offZ;
          if (pixelsSrc[off] > VAL_BLACK_BARRIER) {
            if (len > sizeBlackAreaMin) {
              numWhiteBarriers++;
            }
            break;
          }
        } // for (x)
        const MIN_BLACK_BARRIER = 17;
        const FOUR = 4;
        const TWO = 2;
        if (numWhiteBarriers === FOUR) {
          holeFound = true;
          vSeed.x = cx;
          vSeed.y = cy;
          let sum = 0;
          let minv = 255;
          let col = 0;
          for (let zz = 0; zz < TWO; zz++) {
            const zzOff = (zz + TWO) * this.m_xDim * this.m_yDim;
            for (let yy = -TWO; yy <= TWO; yy++) {
              const yyOff = (yy + cy) * this.m_xDim;
              for (let xx = -2; xx <= TWO; xx++) {
                let val = pixelsSrc[xx + cx + yyOff + zzOff];
                if (val < MIN_BLACK_BARRIER) {
                  sum = sum + val;
                  col++;
                  if (val < minv) {
                    minv = val;
                    vSeed.x = xx + cx;
                    vSeed.y = yy + cy;
                  }
                }
              } //for xx
            } //for yy
          } //for zz
          vSeed.z = Math.floor(sum / col);
          break;
        } // if 4 barriers
      } // for (cx)
    } // for (cy)
    if (!holeFound) {
      return 1;
    } else {
      return 0;
    }
  } //findSeedPointOnFirstSlice