readFromBufferHeader()

in src/engine/loaders/LoaderHdr.js [106:291]
138 lines of code
21 McCabe index (conditional complexity)

  readFromBufferHeader(volumeDst, arrBuf, callbackProgress, callbackComplete) {
    // check arguments
    console.assert(volumeDst != null, 'Null volume');
    console.assert(volumeDst instanceof Volume, 'Should be volume');
    console.assert(arrBuf != null, 'Null array');
    console.assert(arrBuf.constructor.name === 'ArrayBuffer', 'Should be ArrayBuf in arrBuf');

    const bufBytes = new Uint8Array(arrBuf);
    const bufLen = bufBytes.length;
    const HDR_HEADER_SIZE = 348;
    console.log(`Header buf size === ${bufLen}`);

    if (bufLen !== HDR_HEADER_SIZE) {
      if (callbackComplete) {
        callbackComplete(LoadResult.WRONG_HEADER_DATA_SIZE, null, 0, null);
      }
      return false;
    }

    const SIZE_DWORD = 4;
    const SIZE_SHORT = 2;
    const SIZE_BYTE = 1;

    let bufOff = 0;
    // read sizeof header
    const sizeofHdr = LoaderHdr.readIntFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_DWORD;
    if (sizeofHdr !== HDR_HEADER_SIZE) {
      console.log(`Hdr first int wrong: ${sizeofHdr}, but should be ${HDR_HEADER_SIZE}`);
      if (callbackComplete) {
        callbackComplete(LoadResult.BAD_HEADER, null, 0, null);
      }
      return false;
    }
    const ONE = 1;
    const TWO = 2;

    // read dataType char[10]
    const DATA_TYPE_LEN = 10;
    const strDataType = LoaderHdr.getStringAt(bufBytes, bufOff, DATA_TYPE_LEN);
    bufOff += DATA_TYPE_LEN;
    volumeDst.m_dataType = HDR_DT_NONE;
    if (strDataType === 'CHAR') {
      volumeDst.m_dataType = HDR_DT_UNSIGNED_CHAR;
      volumeDst.m_bytesPerVoxel = ONE;
    }
    if (strDataType === 'SHORT') {
      volumeDst.m_dataType = HDR_DT_SIGNED_SHORT;
      volumeDst.m_bytesPerVoxel = TWO;
    }
    if (volumeDst.m_dataType === HDR_DT_NONE) {
      console.log(`Hdr wrong data type. Should be CHAR or SHORT, but found: ${strDataType}`);
      if (callbackComplete) {
        callbackComplete(LoadResult.BAD_HEADER, null, 0, null);
      }
      return false;
    }
    console.log(`Hdr read data type = ${strDataType}`);

    // read dbName char[18]
    const DB_NAME_LEN = 18;
    bufOff += DB_NAME_LEN;

    // reads extents int
    const iExtents = LoaderHdr.readIntFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_DWORD;
    const MAGIC_EXTENTS = 16384;
    if (iExtents !== MAGIC_EXTENTS) {
      console.log(`Hdr wrong extents in header. Should be ${MAGIC_EXTENTS}, but found: ${iExtents}`);
      if (callbackComplete) {
        callbackComplete(LoadResult.BAD_HEADER, null, 0, null);
      }
      return false;
    }
    // read session error
    // const iSessionError = HdrVolume.readShortFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_SHORT;

    // read regular
    const iRegular = LoaderHdr.readByteFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_BYTE;

    const MAGIC_REGULAR = 114;
    if (iRegular !== MAGIC_REGULAR) {
      console.log(`Hdr wrong regular in header. Should be ${MAGIC_REGULAR}, but found: ${iRegular}`);
      if (callbackComplete) {
        callbackComplete(LoadResult.BAD_HEADER, null, 0, null);
      }
      return false;
    }

    // read hKeyUn
    // const hKeyUn = HdrVolume.readByteFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_BYTE;

    // read ushort dim[8]
    // const dim0 = HdrVolume.readShortFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_SHORT;
    const dim1 = LoaderHdr.readShortFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_SHORT;
    const dim2 = LoaderHdr.readShortFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_SHORT;
    const dim3 = LoaderHdr.readShortFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_SHORT;

    volumeDst.m_xDim = dim1;
    volumeDst.m_yDim = dim2;
    volumeDst.m_zDim = dim3;
    console.log(`HDR: volume dim = ${volumeDst.m_xDim} * ${volumeDst.m_yDim} * ${volumeDst.m_zDim} `);

    // read unused dim [4,5,6,7]
    const NUM_DIM_UNUSED = 4;
    bufOff += SIZE_SHORT * NUM_DIM_UNUSED;

    // read voxUnits
    const VOX_UNITS_SIZE = 4;
    bufOff += VOX_UNITS_SIZE;

    // read calUnits char[8]
    const CAL_UNITS_SIZE = 8;
    bufOff += CAL_UNITS_SIZE;

    // read unused
    // const unusedH = HdrVolume.readShortFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_SHORT;

    // read dataType
    const dataTypeH = LoaderHdr.readShortFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_SHORT;
    if (volumeDst.m_dataType === HDR_DT_UNSIGNED_CHAR) {
      if (dataTypeH !== HDR_DT_UNSIGNED_CHAR) {
        console.log('Wrong data tye for char typed header');
        return false;
      }
    }
    if (volumeDst.m_dataType === HDR_DT_SIGNED_SHORT) {
      if (dataTypeH !== HDR_DT_SIGNED_SHORT) {
        console.log('Wrong data tye for signed short typed header');
        return false;
      }
    }

    // read bitPix
    const BITS_IN_CHAR = 8;
    const BITS_IN_WORD = 16;

    const bitPixH = LoaderHdr.readShortFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_SHORT;
    if (volumeDst.m_dataType === HDR_DT_UNSIGNED_CHAR) {
      if (bitPixH !== BITS_IN_CHAR) {
        console.log('Wrong bits pix for char typed header');
        return false;
      }
    }
    if (volumeDst.m_dataType === HDR_DT_SIGNED_SHORT) {
      if (bitPixH !== BITS_IN_WORD) {
        console.log('Wrong bits pix for word typed header');
        return false;
      }
    }

    // read dimUn
    // const dimUn = HdrVolume.readShortFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_SHORT;

    // read pixDim : voxelDim
    // const pixDim0 = HdrVolume.readFloatFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_DWORD;
    const pixDim1 = LoaderHdr.readFloatFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_DWORD;
    const pixDim2 = LoaderHdr.readFloatFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_DWORD;
    const pixDim3 = LoaderHdr.readFloatFromBuffer(bufBytes, bufOff);
    bufOff += SIZE_DWORD;

    // read rest of pixDim
    const NUM_REST_PIX_DIM = 4;
    bufOff += SIZE_DWORD * NUM_REST_PIX_DIM;

    volumeDst.m_boxSize.x = volumeDst.m_xDim * pixDim1;
    volumeDst.m_boxSize.y = volumeDst.m_yDim * pixDim2;
    volumeDst.m_boxSize.z = volumeDst.m_zDim * pixDim3;
    console.log(`HDR: physic size = ${volumeDst.m_boxSize.x} * ${volumeDst.m_boxSize.y} * ${volumeDst.m_boxSize.z} `);

    return true;
  }