static makeTextureSizePowerOfTwoDown()

in src/engine/loaders/voltools.js [978:1109]
123 lines of code
35 McCabe index (conditional complexity)

  static makeTextureSizePowerOfTwoDown(pixelsSrc, xDimSrc, yDimSrc, zDimSrc, xDimDst, yDimDst) {
    const zDimDst = zDimSrc;
    if (xDimDst >= xDimSrc) {
      console.log(`Error: ${xDimDst} >= ${xDimSrc}`);
    }
    if (yDimDst >= yDimSrc) {
      console.log(`Error: ${yDimDst} >= ${yDimSrc}`);
    }
    const xScale = xDimSrc / xDimDst;
    const yScale = yDimSrc / yDimDst;
    const numPixelsSrc = xDimSrc * yDimSrc * zDimSrc;
    const numBytesPerPixel = Math.floor(pixelsSrc.length / numPixelsSrc);
    const FOUR = 4;
    if (numBytesPerPixel !== 1 && numBytesPerPixel !== FOUR) {
      console.log(`Error source volume bpp:  = ${xDimSrc} * ${yDimSrc} * ${zDimSrc}, bpp = ${numBytesPerPixel}`);
    }
    const numPixelsDst = xDimDst * yDimDst * zDimDst * numBytesPerPixel;
    const pixelsDst = new Uint8Array(numPixelsDst);
    let i;
    for (i = 0; i < numPixelsDst; i++) {
      pixelsDst[i] = 0;
    }
    let offDst = 0;
    if (numBytesPerPixel === 1) {
      for (let z = 0; z < zDimDst; z++) {
        const zOffSrc = z * xDimSrc * yDimSrc;
        for (let y = 0; y < yDimDst; y++) {
          const ySrcMin = Math.floor((y + 0) * yScale);
          const ySrcMax = Math.floor((y + 1) * yScale);

          for (let x = 0; x < xDimDst; x++) {
            const xSrcMin = Math.floor((x + 0) * xScale);
            const xSrcMax = Math.floor((x + 1) * xScale);

            let val = 0;
            let numPix = 0;
            for (let ySrc = ySrcMin; ySrc < ySrcMax; ySrc++) {
              for (let xSrc = xSrcMin; xSrc < xSrcMax; xSrc++) {
                const offSrc = zOffSrc + ySrc * xDimSrc + xSrc;
                val += pixelsSrc[offSrc];
                numPix++;
              } // for xSrc
            } // for ySrc
            val /= numPix;
            pixelsDst[offDst] = val;
            offDst++;
          } // for (x) source
        } // for (y) source
      } // for (z) source
    } else if (numBytesPerPixel === FOUR) {
      for (let z = 0; z < zDimDst; z++) {
        const zOffSrc = z * xDimSrc * yDimSrc;
        for (let y = 0; y < yDimDst; y++) {
          const ySrcMin = Math.floor((y + 0) * yScale);
          const ySrcMax = Math.floor((y + 1) * yScale);

          for (let x = 0; x < xDimDst; x++, offDst++) {
            const xSrcMin = Math.floor((x + 0) * xScale);
            const xSrcMax = Math.floor((x + 1) * xScale);

            let valA = 0;
            let valR = 0;
            let valG = 0;
            let valB = 0;
            let numPix = 0;

            for (let ySrc = ySrcMin; ySrc < ySrcMax; ySrc++) {
              for (let xSrc = xSrcMin; xSrc < xSrcMax; xSrc++) {
                let offSrc = (zOffSrc + ySrc * xDimSrc + xSrc) * FOUR;
                valB += pixelsSrc[offSrc];
                offSrc++;
                valG += pixelsSrc[offSrc];
                offSrc++;
                valR += pixelsSrc[offSrc];
                offSrc++;
                valA += pixelsSrc[offSrc];
                numPix++;
              } // for xSrc
            } // for ySrc
            valB /= numPix;
            valG /= numPix;
            valR /= numPix;
            valA /= numPix;
            pixelsDst[offDst] = valB;
            offDst++;
            pixelsDst[offDst] = valG;
            offDst++;
            pixelsDst[offDst] = valR;
            offDst++;
            pixelsDst[offDst] = valA;
            offDst++;
          } // for (x) source
        } // for (y) source
      } // for (z) source
    }
    return pixelsDst;

    /*
    let offDst = 0;
    for (let z = 0; z < zDimDst; z++) {
      const zSrcMin = (z + 0) * zScale;
      const zSrcMax = (z + 1) * zScale;
      for (let y = 0; y < yDimDst; y++) {
        const ySrcMin = (y + 0) * yScale;
        const ySrcMax = (y + 1) * yScale;
        for (let x = 0; x < xDimDst; x++) {
          const xSrcMin = (x + 0) * xScale;
          const xSrcMax = (x + 1) * xScale;

          // get ave value
          let valAve = 0;
          let numPixelsAve = 0;

          for (let zz = zSrcMin; zz < zSrcMax; zz++) {
            const zOff = zz * xDimSrc * yDimSrc;
            for (let yy = ySrcMin; yy < ySrcMax; yy++) {
              const yOff = yy * xDimSrc;
              for (let xx = xSrcMin; xx < xSrcMax; xx++) {
                const offSrc = xx + yOff + zOff;
                const val = pixelsSrc[offSrc];
                valAve += val;
                numPixelsAve++;
              }   // for (xx)
            }     // for (yy)
          }       // for (zz)
          valAve /= numPixelsAve;
          pixelsDst[offDst++] = Math.floor(valAve);
        } // for (x)
      } // for (y)
    } // for (z)
    */
  }