;
+ return ;
}
} // end class Volume
diff --git a/src/engine/VolumeSet.js b/src/engine/VolumeSet.js
index 30b0e1a2..e060f8f3 100644
--- a/src/engine/VolumeSet.js
+++ b/src/engine/VolumeSet.js
@@ -17,11 +17,6 @@ import React from 'react';
import Volume from './Volume';
-import LoaderKtx from './loaders/LoaderKtx';
-import LoaderNifti from './loaders/LoaderNifti';
-import LoaderDicom from './loaders/LoaderDicom';
-import LoaderHdr from './loaders/LoaderHdr';
-
// ********************************************************
// Const
// ********************************************************
@@ -32,11 +27,8 @@ import LoaderHdr from './loaders/LoaderHdr';
* See Volume class as an element of volume set
*/
class VolumeSet extends React.Component {
- /**
- * @param {object} props - props from up level object
- */
- constructor(props) {
- super(props);
+ constructor() {
+ super();
/** nuber of volumes in set */
this.m_numVolumes = 0;
/** volumes array. see more details in class Volume */
@@ -101,73 +93,7 @@ class VolumeSet extends React.Component {
// do nothing. But we need to implement render() to run Volume tests
render() {
- return
>
;
- }
-
- // ********************************************
- // Read metyhods. From Ktx, Dicom, ..
- // ********************************************
- /**
- * Read KTX from local file buffer
- *
- * @param {char array} arrBuf
- * @param {func} callbackProgress
- * @param {func} callbackComplete
- */
- readFromKtx(arrBuf, callbackProgress, callbackComplete) {
- console.assert(arrBuf != null);
- console.assert(arrBuf.constructor.name === 'ArrayBuffer', 'Should be ArrayBuf in arrBuf');
- const loader = new LoaderKtx();
- const vol = this.getVolume(0);
- const ret = loader.readFromBuffer(vol, arrBuf, callbackProgress, callbackComplete);
- return ret;
- }
-
- readFromKtxUrl(strUrl, callbackProgress, callbackComplete) {
- const loader = new LoaderKtx();
- const vol = this.getVolume(0);
- loader.readFromUrl(vol, strUrl, callbackProgress, callbackComplete);
- }
-
- readFromNiiUrl(strUrl, callbackProgress, callbackComplete) {
- const loader = new LoaderNifti();
- const vol = this.getVolume(0);
- const ret = loader.readFromUrl(vol, strUrl, callbackProgress, callbackComplete);
- return ret;
- }
-
- readFromDicomUrl(strUrl, callbackProgress, callbackComplete) {
- const NUM_FILES = 0; // will be filled later
- const loader = new LoaderDicom(NUM_FILES);
- const ret = loader.readFromUrl(this, strUrl, callbackProgress, callbackComplete);
- return ret;
- }
-
- readFromHdrUrl(strUrl, callbackProgress, callbackComplete) {
- const loader = new LoaderHdr();
- const ret = loader.readFromUrl(this, strUrl, callbackProgress, callbackComplete);
- return ret;
- }
-
- readFromNifti(arrBuf, callbackProgress, callbackComplete) {
- const loader = new LoaderNifti();
- const vol = this.getVolume(0);
- const ret = loader.readFromBuffer(vol, arrBuf, callbackProgress, callbackComplete);
- return ret;
- }
-
- readFromDicom(loader, arrBuf, callbackProgress, callbackComplete) {
- const indexFile = 0;
- const fileName = 'file???';
- const ratio = 0.0;
-
- const ret = loader.readFromBuffer(indexFile, fileName, ratio, arrBuf, callbackProgress, callbackComplete);
- return ret;
- }
-
- readSingleSliceFromDicom(loader, indexFile, fileName, ratioLoaded, arrBuf, callbackProgress, callbackComplete) {
- const ret = loader.readFromBuffer(indexFile, fileName, ratioLoaded, arrBuf, callbackProgress, callbackComplete);
- return ret;
+ return ;
}
} // end VolumeSet
diff --git a/src/engine/VolumeSet.test.js b/src/engine/VolumeSet.test.js
index 411847b6..21d866c1 100644
--- a/src/engine/VolumeSet.test.js
+++ b/src/engine/VolumeSet.test.js
@@ -9,219 +9,12 @@
import VolumeSet from './VolumeSet';
import Volume from './Volume';
-import { KtxHeader } from './loaders/LoaderKtx';
-import LoadResult from './LoadResult';
// ********************************************************
// Tests
// ********************************************************
describe('VolumeSetTests', () => {
- // special finction to creatre ktx in memory
- const _writeInt = (arrBuf, offs, valInt) => {
- let offsNew = offs;
- let val = valInt;
- for (let i = 0; i < 4; i++) {
- const bt = val & 0xff;
- val >>= 8;
- arrBuf[offsNew++] = bt;
- }
- return offsNew;
- };
-
- it('testWriteInt', () => {
- const SIZE_BUF = 4;
- const bufBytes = new Uint8Array(SIZE_BUF);
- const VAL_0 = 0x67;
- const VAL_1 = 0x58;
- const VAL_2 = 0x13;
- const VAL_3 = 0x2e;
-
- const SHIFT_8 = 8;
- const SHIFT_16 = 16;
- const SHIFT_24 = 24;
-
- const VAL_DWORD = VAL_0 | (VAL_1 << SHIFT_8) | (VAL_2 << SHIFT_16) | (VAL_3 << SHIFT_24);
- // console.log(`test. dword = ${VAL_DWORD.toString(16)}`);
- _writeInt(bufBytes, 0, VAL_DWORD);
- // console.log(`test. array0 = ${bufBytes[0].toString(16)}`);
- // console.log(`test. array1 = ${bufBytes[1].toString(16)}`);
- // console.log(`test. array2 = ${bufBytes[2].toString(16)}`);
- // console.log(`test. array3 = ${bufBytes[3].toString(16)}`);
- const isOk0 = bufBytes[0] === VAL_0;
- const isOk1 = bufBytes[1] === VAL_1;
- const isOk2 = bufBytes[2] === VAL_2;
- const isOk3 = bufBytes[3] === VAL_3;
- expect(isOk0).toBeTruthy();
- expect(isOk1).toBeTruthy();
- expect(isOk2).toBeTruthy();
- expect(isOk3).toBeTruthy();
- });
- it('testLoaderKtxBadHeader', () => {
- const MAX_SIZE_TEST = 64;
- const bufTest = new Uint8Array(MAX_SIZE_TEST);
- for (let i = 0; i < MAX_SIZE_TEST; i++) {
- bufTest[0] = 'a';
- }
- const callbackProgress = undefined;
- const callbackComplete = undefined;
- const volSet = new VolumeSet();
- volSet.addVolume(new Volume());
- const readOk = volSet.readFromKtx(bufTest, callbackProgress, callbackComplete);
- expect(readOk === true).toBeFalsy();
- });
- it('testLoaderKtxBadEndianness', () => {
- const MAX_SIZE_TEST = 512;
- const bufTest = new Uint8Array(MAX_SIZE_TEST);
- let i;
- let iDst = 0;
- // write header
- const arrayHeaderSign = [0xab, 0x4b, 0x54, 0x58, 0x20, 0x31, 0x31, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
- const lenHeaderSign = arrayHeaderSign.length;
-
- for (i = 0; i < lenHeaderSign; i++) {
- bufTest[iDst++] = arrayHeaderSign[i];
- }
- // write endianness
- iDst = _writeInt(bufTest, iDst, 5555);
-
- const callbackProgress = undefined;
- const callbackComplete = undefined;
- const volSet = new VolumeSet();
- volSet.addVolume(new Volume());
- const readOk = volSet.readFromKtx(bufTest, callbackProgress, callbackComplete);
- expect(readOk === true).toBeFalsy();
- });
- it('testLoaderKtxBadGlType', () => {
- const MAX_SIZE_TEST = 512;
- const bufTest = new Uint8Array(MAX_SIZE_TEST);
- let i;
- let iDst = 0;
- // write header
- const arrayHeaderSign = [0xab, 0x4b, 0x54, 0x58, 0x20, 0x31, 0x31, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
- const lenHeaderSign = arrayHeaderSign.length;
-
- for (i = 0; i < lenHeaderSign; i++) {
- bufTest[iDst++] = arrayHeaderSign[i];
- }
- // write endianness
- const ENDIANNESS_CONST = 0x04030201;
- iDst = _writeInt(bufTest, iDst, ENDIANNESS_CONST);
- const BAD = 44;
- // write type
- iDst = _writeInt(bufTest, iDst, BAD);
- // writ type size
- iDst = _writeInt(bufTest, iDst, BAD);
- // write gl format
- iDst = _writeInt(bufTest, iDst, BAD);
-
- const callbackProgress = undefined;
- const callbackComplete = undefined;
- const volSet = new VolumeSet();
- volSet.addVolume(new Volume());
- const readOk = volSet.readFromKtx(bufTest, callbackProgress, callbackComplete);
- expect(readOk === true).toBeFalsy();
- });
-
- it('testLoaderKtxBadDims', () => {
- const MAX_SIZE_TEST = 512;
- const bufTest = new Uint8Array(MAX_SIZE_TEST);
- let i;
- let iDst = 0;
- // write header
- const arrayHeaderSign = [0xab, 0x4b, 0x54, 0x58, 0x20, 0x31, 0x31, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
- const lenHeaderSign = arrayHeaderSign.length;
-
- for (i = 0; i < lenHeaderSign; i++) {
- bufTest[iDst++] = arrayHeaderSign[i];
- }
- // write endianness
- const ENDIANNESS_CONST = 0x04030201;
- iDst = _writeInt(bufTest, iDst, ENDIANNESS_CONST);
- // write gl type
- iDst = _writeInt(bufTest, iDst, KtxHeader.KTX_GL_RED);
- // write gl type size
- iDst = _writeInt(bufTest, iDst, 4);
- // write gl format
- iDst = _writeInt(bufTest, iDst, KtxHeader.KTX_GL_RED);
- // internal format
- iDst = _writeInt(bufTest, iDst, KtxHeader.KTX_GL_RED);
- // base int format
- iDst = _writeInt(bufTest, iDst, KtxHeader.KTX_GL_RED);
- const TOO_SMALL = 1;
- // write xDim, yDim, zDim
- iDst = _writeInt(bufTest, iDst, TOO_SMALL);
- iDst = _writeInt(bufTest, iDst, TOO_SMALL);
- iDst = _writeInt(bufTest, iDst, TOO_SMALL);
-
- const callbackProgress = undefined;
- const callbackComplete = undefined;
- const volSet = new VolumeSet();
- volSet.addVolume(new Volume());
- const readOk = volSet.readFromKtx(bufTest, callbackProgress, callbackComplete);
- // console.log(`Test. Vol dim = ${vol.m_xDim} * ${vol.m_yDim} * ${vol.m_zDim} `);
- expect(readOk === true).toBeFalsy();
- });
-
- it('testLoaderKtxGood888', () => {
- const MAX_SIZE_TEST = 512;
- const bufTest = new Uint8Array(MAX_SIZE_TEST);
- let i;
- let iDst = 0;
- // write header
- const arrayHeaderSign = [0xab, 0x4b, 0x54, 0x58, 0x20, 0x31, 0x31, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
- const lenHeaderSign = arrayHeaderSign.length;
-
- for (i = 0; i < lenHeaderSign; i++) {
- bufTest[iDst++] = arrayHeaderSign[i];
- }
- // write endianness
- const ENDIANNESS_CONST = 0x04030201;
- iDst = _writeInt(bufTest, iDst, ENDIANNESS_CONST);
- // write gl type
- iDst = _writeInt(bufTest, iDst, KtxHeader.KTX_GL_RED);
- // write gl type size
- iDst = _writeInt(bufTest, iDst, 4);
- // write gl format
- iDst = _writeInt(bufTest, iDst, KtxHeader.KTX_GL_RED);
- // internal format
- iDst = _writeInt(bufTest, iDst, KtxHeader.KTX_GL_RED);
- // base int format
- iDst = _writeInt(bufTest, iDst, KtxHeader.KTX_GL_RED);
- const SIDE = 8;
- // write xDim, yDim, zDim
- iDst = _writeInt(bufTest, iDst, SIDE);
- iDst = _writeInt(bufTest, iDst, SIDE);
- iDst = _writeInt(bufTest, iDst, SIDE);
-
- const ZERO = 0;
- // num arr elems
- iDst = _writeInt(bufTest, iDst, ZERO);
- // num faces
- iDst = _writeInt(bufTest, iDst, ZERO);
- // num mip maps
- iDst = _writeInt(bufTest, iDst, ZERO);
- // num bytes key value
- iDst = _writeInt(bufTest, iDst, ZERO);
-
- // data size
- const DTSIZE = SIDE * SIDE * SIDE;
- iDst = _writeInt(bufTest, iDst, DTSIZE);
-
- // write data
- for (i = 0; i < DTSIZE; i++) {
- bufTest[iDst++] = i & 0xff;
- }
-
- const callbackProgress = undefined;
- const callbackComplete = undefined;
- const volSet = new VolumeSet();
- volSet.addVolume(new Volume());
- const readOk = volSet.readFromKtx(bufTest, callbackProgress, callbackComplete);
- // console.log(`Test. Vol dim = ${vol.m_xDim} * ${vol.m_yDim} * ${vol.m_zDim} `);
- expect(readOk === LoadResult.SUCCESS).toBeTruthy();
- });
-
//
it('testCreateSingleVolume', () => {
const volumeSet = new VolumeSet();
diff --git a/src/engine/lib/MRIViewer.ts b/src/engine/lib/MRIViewer.ts
new file mode 100644
index 00000000..a24340d2
--- /dev/null
+++ b/src/engine/lib/MRIViewer.ts
@@ -0,0 +1,23 @@
+import { MRIReader, mriReader } from './core/readers';
+import { MRIEventsService } from './services';
+import mriEventsService from './services/EventsService';
+
+export class MRIViwer {
+ public mriReader: MRIReader;
+ public events: MRIEventsService;
+
+ constructor() {
+ this.events = mriEventsService;
+ this.mriReader = mriReader;
+ }
+
+ read(data: File[] | string): void {
+ this.mriReader.read(data);
+ }
+}
+
+// Create the singleton instance and freeze it
+const MriViwer = new MRIViwer();
+Object.freeze(MriViwer);
+
+export default MriViwer;
diff --git a/src/engine/lib/config/volume.config.ts b/src/engine/lib/config/volume.config.ts
new file mode 100644
index 00000000..01a40b41
--- /dev/null
+++ b/src/engine/lib/config/volume.config.ts
@@ -0,0 +1,3 @@
+export const volumeConfig: any = {
+ setTextureSize4X: true,
+};
diff --git a/src/engine/lib/core/loaders/MRIFileLoader.ts b/src/engine/lib/core/loaders/MRIFileLoader.ts
new file mode 100644
index 00000000..7738988e
--- /dev/null
+++ b/src/engine/lib/core/loaders/MRIFileLoader.ts
@@ -0,0 +1,194 @@
+import { MriEvents, MriExtensions } from '../../enums';
+import { MRIEventsService, MRIStoreService, mriEventsService, mriStoreService } from '../../services';
+import { getFileNameFromUrl, getFolderNameFromUrl } from '../../utils';
+
+/**
+ * Class responsible for loading MRI files from URLs.
+ * It handles different file types and tracks the loading progress.
+ */
+export class MRIFileLoader {
+ fileName = '';
+ filesLength = 0;
+ filesLoaded = 0;
+ filesProgressByLength = false;
+ store: MRIStoreService = mriStoreService;
+ events: MRIEventsService = mriEventsService;
+
+ constructor() {
+ this.load = this.load.bind(this);
+ this.callbackLoadProgress = this.callbackLoadProgress.bind(this);
+ }
+
+ /**
+ * Main load function responsible for loading a file from a given URL.
+ * @param {string} url - The URL of the file to load.
+ * @returns {Promise} A promise that resolves to an array of Files or rejects with an error.
+ */
+ async load(url: string): Promise {
+ this.filesLoaded = 0;
+ this.filesProgressByLength = false;
+ this.store.setLoadingProgress(0);
+ this.store.startLoadingSpinner('Loading File...');
+ const fileExtension = url.slice(url.lastIndexOf('.') + 1);
+
+ switch (fileExtension) {
+ case MriExtensions.KTX:
+ case MriExtensions.NII:
+ case MriExtensions.DCM:
+ case MriExtensions.ZIP:
+ return await this.fetchSingleFile(url);
+ case MriExtensions.TXT:
+ return await this.fetchTxtFile(url);
+ case MriExtensions.HDR:
+ return await this.fetchHdrFile(url);
+ default:
+ this.handleVolumeLoadFailed(`Unsupported file extension: ${fileExtension}`);
+ return [];
+ }
+ }
+
+ /**
+ * Fetches a single file from the given URL and tracks its progress.
+ * @param {string} url - The URL from which to fetch the file.
+ * @returns {Promise} A promise that resolves to an array containing the fetched file as a File object.
+ */
+ async fetchSingleFile(url: string): Promise {
+ const response = await this.fetchWithProgress(url, this.callbackLoadProgress);
+
+ if (!response.ok) {
+ this.handleVolumeLoadFailed(`Failed to fetch file from URL: ${url}`);
+ return [];
+ }
+
+ const blob = await response.blob();
+ const fileName = getFileNameFromUrl(url);
+ const file = new File([blob], fileName, {
+ type: blob.type,
+ });
+
+ return [file];
+ }
+
+ /**
+ * Fetches the content of a .txt file and splits it by newlines.
+ * @param {string} url - The URL of the .txt file.
+ * @returns {Promise} A promise that resolves to an array of strings from the .txt file.
+ */
+ async fetchTxtContent(url: string): Promise {
+ const response = await fetch(url);
+
+ if (!response.ok) {
+ this.handleVolumeLoadFailed(`Failed to fetch file list from URL: ${url}`);
+ return [];
+ }
+
+ const content = await response.text();
+ return content.split('\n').filter((line) => line.trim() !== '');
+ }
+
+ /**
+ * Fetches multiple files defined in a .txt file located at the given URL.
+ * @param {string} txtUrl - The URL of the .txt file containing the list of file URLs.
+ * @returns {Promise} A promise that resolves to an array of File objects.
+ */
+ async fetchTxtFile(txtUrl: string): Promise {
+ this.filesProgressByLength = true;
+ const base = txtUrl.substring(0, txtUrl.lastIndexOf('/') + 1);
+ const fileNames = await this.fetchTxtContent(txtUrl);
+ this.filesLength = fileNames.length;
+ const filePromises = fileNames.map((filename: string) => this.fetchSingleFile(base + filename));
+ const files = await Promise.all(filePromises);
+ return files.flat();
+ }
+
+ /**
+ * Fetches a set of related .hdr and .img files for MRI data.
+ * @param {string} url - The URL of the .hdr file.
+ * @returns {Promise} A promise that resolves to an array of File objects, or [] if failed.
+ */
+ async fetchHdrFile(url: string): Promise {
+ const folder = getFolderNameFromUrl(url);
+ const fileName = getFileNameFromUrl(url);
+ const regExp = /(\w+)_intn.(h|hdr)/;
+ const arrGrp = regExp.exec(fileName) || [];
+ const namePrefix = arrGrp[1];
+
+ if (arrGrp.length !== 3) {
+ this.handleVolumeLoadFailed(`LoaderHdr.readFromUrl: bad URL name = ${url}. Should be in template NNN_intn.h`);
+ return [];
+ }
+
+ const fileNameIntensityHeader = folder + '/' + namePrefix + '_intn.hdr';
+ const fileNameIntensityImage = folder + '/' + namePrefix + '_intn.img';
+ const fileNameMaskHeader = folder + '/' + namePrefix + '_mask.hdr';
+ const fileNameMaskImage = folder + '/' + namePrefix + '_mask.img';
+
+ const urls = [fileNameIntensityHeader, fileNameIntensityImage, fileNameMaskHeader, fileNameMaskImage];
+ this.filesProgressByLength = true;
+ this.filesLength = urls.length;
+
+ const filePromises = urls.map((url: string) => this.fetchSingleFile(url));
+
+ const files = await Promise.all(filePromises);
+
+ return files.flat();
+ }
+
+ /**
+ * Fetches a file with progress tracking via XMLHttpRequest.
+ * @param {string} url - The URL from which to fetch the file.
+ * @param {Function} onProgress - Callback function to report progress.
+ * @returns {Promise} A promise that resolves to the Response object of the request.
+ */
+ async fetchWithProgress(url: string, onProgress: Function): Promise {
+ return new Promise((resolve, reject) => {
+ const xhr = new XMLHttpRequest();
+
+ xhr.open('GET', url);
+
+ xhr.onprogress = (event) => {
+ if (event.lengthComputable && !this.filesProgressByLength) {
+ const percentComplete = event.loaded / event.total;
+ onProgress(percentComplete);
+ }
+ };
+
+ xhr.onload = () => {
+ if (this.filesProgressByLength) {
+ this.filesLoaded = this.filesLoaded + 1;
+ const percentComplete = this.filesLoaded / this.filesLength;
+ onProgress(percentComplete);
+ }
+
+ const blob = xhr.response;
+ resolve(new Response(blob));
+ };
+
+ xhr.onerror = () => {
+ this.handleVolumeLoadFailed(`Failed to fetch file from URL: ${url}`);
+ reject(new Error());
+ };
+
+ xhr.responseType = 'blob';
+ xhr.send();
+ });
+ }
+
+ /**
+ * Callback function to handle the progress of file loading.
+ * @param {number} progress - The progress of the loading, as a number between 0 and 1.
+ */
+ callbackLoadProgress(progress: number) {
+ const progressPercentage = Math.floor(progress * 100);
+ this.store.setLoadingProgress(progressPercentage);
+ }
+
+ /**
+ * Handles the event of a failed volume load operation.
+ * @param {string} error - The error message to be handled.
+ */
+ handleVolumeLoadFailed(error: string) {
+ this.events.emit(MriEvents.FILE_READ_ERROR, { error });
+ this.store.setVolumeLoadFailed(this.fileName, [error]);
+ }
+}
diff --git a/src/engine/lib/core/readers/MRIReader.ts b/src/engine/lib/core/readers/MRIReader.ts
new file mode 100644
index 00000000..f4e12778
--- /dev/null
+++ b/src/engine/lib/core/readers/MRIReader.ts
@@ -0,0 +1,25 @@
+import { isValidUrl } from '../../utils';
+import { MRIFileLoader } from '../loaders/MRIFileLoader';
+import { MRIFileReaderFactory } from './file-reader-factory/MRIReaderFactory';
+
+export class MRIReader {
+ fileLoader = new MRIFileLoader();
+ fileReader = new MRIFileReaderFactory();
+
+ async read(data: File[] | string): Promise {
+ if (data && data.length && data[0] instanceof File) {
+ this.fileReader.read(data as File[]);
+ } else if (isValidUrl(data as string)) {
+ const files: File[] = await this.fileLoader.load(data as string);
+ this.fileReader.read(files);
+ } else {
+ throw new Error('Invalid input. Expected a File or URL.');
+ }
+ }
+}
+
+// Create the singleton instance and freeze it
+const mriReader = new MRIReader();
+Object.freeze(mriReader);
+
+export default mriReader;
diff --git a/src/engine/lib/core/readers/abstract-file-reader/AbstractFileReader.ts b/src/engine/lib/core/readers/abstract-file-reader/AbstractFileReader.ts
new file mode 100644
index 00000000..bbeb9a6a
--- /dev/null
+++ b/src/engine/lib/core/readers/abstract-file-reader/AbstractFileReader.ts
@@ -0,0 +1,106 @@
+import LoadResult from '../../../../LoadResult';
+import VolumeSet from '../../../../VolumeSet';
+import LoaderDicom from '../../../../loaders/LoaderDicom';
+import LoaderHdr from '../../../../loaders/LoaderHdr';
+import MriViwer from '../../../MRIViewer';
+import { volumeConfig } from '../../../config/volume.config';
+import { MriEvents, MriExtensions } from '../../../enums';
+import {
+ MRIEventsService,
+ MRILocalStorageService,
+ MRIStoreService,
+ mriEventsService,
+ mriLocalStorageService,
+ mriStoreService,
+} from '../../../services';
+
+/**
+ * AbstractFileReader is an abstract class designed to be extended by specific file reader
+ * implementations for medical imaging data. It provides basic functionality for reading files,
+ * handling loading success or failure, and communicating with application services for state management
+ * and event handling.
+ *
+ * @abstract
+ */
+export abstract class AbstractFileReader {
+ // VolumeData
+ volumeSet = new VolumeSet();
+ volumeIndex: number = 0;
+ // FileData
+ fileName = '';
+ fileExtension: MriExtensions | '' = '';
+ // File Handlers
+ loader: LoaderDicom | LoaderHdr | undefined;
+ fileReader: FileReader = new FileReader();
+
+ // Services
+ store: MRIStoreService = mriStoreService;
+ events: MRIEventsService = mriEventsService;
+ localStorage: MRILocalStorageService = mriLocalStorageService;
+
+ constructor() {
+ this.callbackReadProgress = this.callbackReadProgress.bind(this);
+ this.callbackReadComplete = this.callbackReadComplete.bind(this);
+ }
+
+ /**
+ * Handles the successful loading of a volume. It updates the volume set, emits a success event,
+ * and updates the local storage with the recent file.
+ */
+ public handleVolumeLoadSuccess() {
+ const volume = this.volumeSet.getVolume(this.volumeIndex);
+
+ if (!volume.m_dataArray) return;
+
+ if (volumeConfig.setTextureSize4X) {
+ volume.makeDimensions4x();
+ }
+
+ this.callbackReadProgress(1);
+ MriViwer.events.emit(MriEvents.VOLUME_LOAD_SUCCESS);
+ this.store.setVolume(this.volumeSet, this.volumeIndex, this.fileName);
+
+ this.localStorage.saveRecentFiles(this.fileName);
+
+ if (this.store.getState().graphics2d) {
+ this.store.getState().graphics2d.forceUpdate();
+ }
+ }
+
+ /**
+ * Handles the failed read attempt of a volume by emitting an error event and updating the store with
+ * the failure information.
+ *
+ * @param {string} error - The error message describing the failure.
+ */
+ public handleVolumeReadFailed(error: string) {
+ this.events.emit(MriEvents.FILE_READ_ERROR, { error });
+ this.store.setVolumeLoadFailed(this.fileName, [error]);
+ }
+
+ /**
+ * A callback function that is called to update the read progress. It calculates the progress percentage
+ * and updates the store with the new progress value.
+ *
+ * @param {number} progress - The current progress value as a fraction from 0 to 1.
+ */
+ public callbackReadProgress(progress: number) {
+ const progressPercentage: number = Math.floor(progress * 100);
+ this.store.setLoadingProgress(progressPercentage);
+ }
+
+ /**
+ * A callback function that is called upon the completion of the read operation. It determines whether
+ * the read was successful and either triggers the load success handler or the read failed handler.
+ *
+ * @param {number} status - The status code indicating the result of the file read operation.
+ */
+ public callbackReadComplete(status: number) {
+ if (status === LoadResult.SUCCESS) {
+ this.handleVolumeLoadSuccess();
+ } else {
+ const error = LoadResult.getResultString(status);
+ this.handleVolumeReadFailed(error);
+ }
+ }
+}
diff --git a/src/engine/lib/core/readers/archive-reader/ArchiveReader.ts b/src/engine/lib/core/readers/archive-reader/ArchiveReader.ts
new file mode 100644
index 00000000..a15595b8
--- /dev/null
+++ b/src/engine/lib/core/readers/archive-reader/ArchiveReader.ts
@@ -0,0 +1,69 @@
+import JSZip from 'jszip';
+
+const IGNORED_FILE_PREFIXES = ['__MACOSX/', '._'];
+
+/**
+ * ArchiveReader is a utility class for reading and extracting files from ZIP archives.
+ * It uses the JSZip library to handle the zip file format. The class can filter out
+ * unnecessary files based on predefined rules, such as ignoring certain file prefixes.
+ */
+export class ArchiveReader {
+ /**
+ * Reads the provided ZIP file and returns a list of extracted files, omitting any
+ * files that meet the criteria to be ignored.
+ *
+ * @param {File} file - The ZIP file to be read.
+ * @returns {Promise} A promise that resolves to an array of File objects extracted from the ZIP archive,
+ * sorted by their last modified date.
+ */
+ async readZipFile(file: File): Promise {
+ const zip = new JSZip();
+ const unzippedFiles: File[] = [];
+
+ const arrayBuffer = await this.readFileAsArrayBuffer(file);
+
+ await zip.loadAsync(arrayBuffer);
+
+ for (const fileName in zip.files) {
+ if (this.shouldSkipFile(fileName)) {
+ continue;
+ }
+
+ const zipObject = zip.files[fileName];
+
+ if (!zipObject.dir) {
+ const blob = await zipObject.async('blob');
+ unzippedFiles.push(new File([blob], fileName, { type: blob.type }));
+ }
+ }
+
+ return unzippedFiles.sort((a, b) => a.lastModified - b.lastModified);
+ }
+
+ /**
+ * Checks whether a file from the ZIP archive should be ignored based on its file name.
+ * Files starting with certain prefixes (e.g., '__MACOSX/', '._') are ignored.
+ *
+ * @param {string} fileName - The name of the file to check.
+ * @returns {boolean} True if the file should be skipped; false otherwise.
+ */
+ private shouldSkipFile(fileName: string): boolean {
+ return IGNORED_FILE_PREFIXES.some((prefix) => fileName.startsWith(prefix));
+ }
+
+ /**
+ * Reads the content of the provided File object as an ArrayBuffer.
+ * This is a utility method used internally by the readZipFile method.
+ *
+ * @param {File} file - The file whose contents are to be read.
+ * @returns {Promise} A promise that resolves with the ArrayBuffer representation of the file's content.
+ */
+ readFileAsArrayBuffer(file: File): Promise {
+ return new Promise((resolve, reject) => {
+ const reader = new FileReader();
+ reader.onload = () => resolve(reader.result as ArrayBuffer);
+ reader.onerror = reject;
+ reader.readAsArrayBuffer(file);
+ });
+ }
+}
diff --git a/src/engine/lib/core/readers/file-reader-factory/MRIReaderFactory.ts b/src/engine/lib/core/readers/file-reader-factory/MRIReaderFactory.ts
new file mode 100644
index 00000000..07ff6381
--- /dev/null
+++ b/src/engine/lib/core/readers/file-reader-factory/MRIReaderFactory.ts
@@ -0,0 +1,51 @@
+import { MriEvents, MriExtensions } from '../../../enums';
+import { ArchiveReader } from '../archive-reader/ArchiveReader';
+import { MultiFileReader } from '../multi-file-reader/MultiFileReader';
+import { SingleFileReader } from '../single-file-reader/SingleFileReader';
+import { MRIStoreService, MRIEventsService, mriEventsService, mriStoreService } from '../../../services';
+
+/**
+ * Factory class for creating file readers based on the type and number of files provided.
+ * It handles the reading of single, multiple, and archived files by delegating to specific reader classes.
+ */
+export class MRIFileReaderFactory {
+ fileReader: SingleFileReader | MultiFileReader | ArchiveReader | undefined;
+ store: MRIStoreService = mriStoreService;
+ events: MRIEventsService = mriEventsService;
+
+ constructor() {
+ this.read = this.read.bind(this);
+ }
+
+ /**
+ * Reads the provided files and processes them according to their type and quantity.
+ * Emits an event in case of an error or delegates the file reading to the appropriate reader.
+ *
+ * @param {File[]} files - An array of files to be read.
+ * @returns {Promise} A promise that resolves when the file reading operation is complete.
+ */
+ async read(files: File[]): Promise {
+ if (!files || !files.length) {
+ return this.events.emit(MriEvents.FILE_READ_ERROR, { error: 'No files provided' });
+ }
+
+ this.store.startLoadingSpinner('Processing File...');
+
+ // Single ZIP file scenario
+ if (files.length === 1 && files[0].name.endsWith(MriExtensions.ZIP)) {
+ this.fileReader = new ArchiveReader();
+ const unzippedFiles = await this.fileReader.readZipFile(files[0]);
+ return this.read(unzippedFiles);
+ }
+
+ // Single non-ZIP file scenario
+ if (files.length === 1) {
+ this.fileReader = new SingleFileReader();
+ return this.fileReader.read(files[0]);
+ }
+
+ // Multiple files scenario
+ this.fileReader = new MultiFileReader();
+ (this.fileReader as MultiFileReader).read(files);
+ }
+}
diff --git a/src/engine/lib/core/readers/index.ts b/src/engine/lib/core/readers/index.ts
new file mode 100644
index 00000000..b9c37f2d
--- /dev/null
+++ b/src/engine/lib/core/readers/index.ts
@@ -0,0 +1,3 @@
+import mriReader, { MRIReader } from './MRIReader';
+
+export { mriReader, MRIReader };
diff --git a/src/engine/lib/core/readers/multi-file-reader/MultiFileReader.ts b/src/engine/lib/core/readers/multi-file-reader/MultiFileReader.ts
new file mode 100644
index 00000000..866e2838
--- /dev/null
+++ b/src/engine/lib/core/readers/multi-file-reader/MultiFileReader.ts
@@ -0,0 +1,178 @@
+import LoadResult from '../../../../LoadResult';
+import Volume from '../../../../Volume';
+import LoaderDcmDaikon from '../../../../loaders/LoaderDcmDaikon';
+import LoaderDicom from '../../../../loaders/LoaderDicom';
+import LoaderHdr from '../../../../loaders/LoaderHdr';
+import { MriExtensions } from '../../../enums';
+import { SingleFileReader } from '../single-file-reader/SingleFileReader';
+
+/**
+ * The `MultiFileReader` class extends `SingleFileReader` to handle reading and processing
+ * multiple files. It supports reading DICOM series and header-image pairs for volume rendering.
+ */
+export class MultiFileReader extends SingleFileReader {
+ files: Array = [];
+ fileIndex: number = 0;
+ filesLength: number = 0;
+
+ volumeRoi = new Volume();
+
+ constructor() {
+ super();
+
+ this.read = this.read.bind(this);
+ this.readMultipleHdr = this.readMultipleHdr.bind(this);
+ this.onFileContentReadMultipleDicom = this.onFileContentReadMultipleDicom.bind(this);
+ }
+
+ /**
+ * Reads multiple files and determines the processing method based on file extension.
+ * @param {File[]} files - An array of `File` objects to be read.
+ */
+ read(files: any): void {
+ this.files = this.getFilesOrderToRead(files);
+ this.filesLength = this.files.length;
+ this.setFileData(this.files[0]);
+ this.volumeSet.addVolume(new Volume());
+ this.readFile(0);
+
+ switch (this.fileExtension) {
+ case '':
+ case MriExtensions.DCM:
+ this.loader = new LoaderDicom(this.filesLength);
+ this.store.setDicomLoader(this.loader);
+ this.fileReader.onloadend = this.onFileContentReadMultipleDicom;
+ break;
+ case MriExtensions.HDR:
+ case MriExtensions.IMG:
+ this.loader = new LoaderHdr();
+ this.fileReader.onloadend = this.readMultipleHdr;
+ break;
+ default:
+ this.handleVolumeReadFailed(`Unsupported file extension: ${this.fileExtension}`);
+ break;
+ }
+ }
+
+ /**
+ * Orders files based on their last modified date and filters out files that don't match the primary file extension.
+ * @param {File[]} files - An array of `File` objects to be ordered.
+ * @returns {File[]} An ordered array of `File` objects.
+ */
+ getFilesOrderToRead(files: File[]): File[] {
+ const plainFiles: File[] = Array.from(files);
+ const fileExtension = this.getFileExtension(plainFiles[0]);
+
+ if (fileExtension === MriExtensions.HDR || fileExtension === MriExtensions.IMG) {
+ return plainFiles;
+ }
+
+ return plainFiles
+ .filter((file) => {
+ return this.getFileExtension(file) === fileExtension;
+ })
+ .sort((a, b) => a.lastModified - b.lastModified);
+ }
+
+ /**
+ * Reads a slice of a DICOM file using the Daikon loader.
+ * @param {string | ArrayBuffer | null} content - The content of the DICOM file.
+ * @returns {LoadResult} The result of the read operation.
+ */
+ readSliceDicomViaDaikon(content: string | ArrayBuffer | null) {
+ const loaderDaikon = new LoaderDcmDaikon();
+ return loaderDaikon.readSlice(this.loader, this.fileIndex, this.fileName, content);
+ }
+
+ /**
+ * Reads the file at the given index.
+ * @param {number} index - The index of the file to read.
+ */
+ readFile(index: number): void {
+ const file = this.files[index];
+ this.setFileData(file);
+ this.fileReader.readAsArrayBuffer(file);
+ this.callbackReadProgress(this.fileIndex / this.filesLength);
+ }
+
+ /**
+ * Handler for when content of a DICOM file is read.
+ */
+ onFileContentReadMultipleDicom(): void {
+ this.fileIndex++;
+
+ if (this.fileIndex === this.files.length) {
+ return this.callbackReadSingleDicomComplete(LoadResult.SUCCESS);
+ }
+ const readStatus = this.readSliceDicomViaDaikon(this.fileReader.result);
+
+ if (readStatus === LoadResult.SUCCESS && this.fileIndex < this.filesLength) {
+ this.readFile(this.fileIndex);
+ this.fileReader.onloadend = this.onFileContentReadMultipleDicom;
+ } else {
+ this.handleVolumeReadFailed(`Failed on parsing of this file: ${this.fileName}.${this.fileExtension}`);
+ }
+ }
+
+ /**
+ * Handler for reading multiple HDR (header) files.
+ */
+ readMultipleHdr() {
+ this.fileIndex++;
+
+ const VALID_NUM_FILES_2 = 2;
+ const VALID_NUM_FILES_4 = 4;
+
+ // Extract main part of the filename
+ const regExpFileName = /([\S]+)\.[\S]+/;
+ const fnameArr = regExpFileName.exec(this.fileName);
+ let detectedMask = false;
+ let detectedIntensity = false;
+
+ if (fnameArr && fnameArr.length === 2) {
+ const fname = fnameArr[1];
+ detectedMask = fname.endsWith('_mask');
+ detectedIntensity = fname.endsWith('_intn');
+ }
+
+ let volDst = this.volumeSet.getVolume(0);
+
+ if (this.fileIndex > VALID_NUM_FILES_2) {
+ volDst = this.volumeRoi;
+ }
+
+ if (detectedIntensity) {
+ volDst = this.volumeSet.getVolume(0);
+ }
+
+ if (detectedMask && this.filesLength !== VALID_NUM_FILES_4) {
+ volDst = this.volumeRoi;
+ }
+
+ const content = this.fileReader.result;
+
+ const readSuccess =
+ this.fileExtension === MriExtensions.HDR
+ ? (this.loader as LoaderHdr).readFromBufferHeader(volDst, content, this.callbackReadProgress, this.callbackReadComplete)
+ : (this.loader as LoaderHdr).readFromBufferImage(volDst, content, this.callbackReadProgress, this.callbackReadComplete);
+
+ volDst = this.volumeSet.getVolume(0);
+
+ if (readSuccess && this.fileIndex === this.filesLength) {
+ const loaderHdr = this.loader as LoaderHdr;
+ let ok = loaderHdr.createVolumeFromHeaderAndImage(volDst);
+
+ if (this.filesLength === VALID_NUM_FILES_4 && ok) {
+ ok = loaderHdr.createRoiVolumeFromHeaderAndImage(volDst, this.volumeRoi);
+ }
+
+ this.callbackReadProgress(1.0);
+ this.callbackReadComplete(ok ? LoadResult.SUCCESS : LoadResult.UNKNOWN);
+ }
+
+ if (this.fileIndex < this.filesLength) {
+ this.readFile(this.fileIndex);
+ this.fileReader.onloadend = this.readMultipleHdr;
+ }
+ }
+}
diff --git a/src/engine/lib/core/readers/single-file-reader/SingleFileReader.ts b/src/engine/lib/core/readers/single-file-reader/SingleFileReader.ts
new file mode 100644
index 00000000..fa3d8535
--- /dev/null
+++ b/src/engine/lib/core/readers/single-file-reader/SingleFileReader.ts
@@ -0,0 +1,167 @@
+import StoreActionType from '../../../../../store/ActionTypes';
+import LoadResult from '../../../../LoadResult';
+import Volume from '../../../../Volume';
+import LoaderDcmDaikon from '../../../../loaders/LoaderDcmDaikon';
+import LoaderDicom from '../../../../loaders/LoaderDicom';
+import LoaderKtx from '../../../../loaders/LoaderKtx';
+import LoaderNifti from '../../../../loaders/LoaderNifti';
+import { MriEvents, MriExtensions } from '../../../enums';
+import { AbstractFileReader } from '../abstract-file-reader/AbstractFileReader';
+
+/**
+ * The `SingleFileReader` class extends `AbstractFileReader` to handle the reading and processing
+ * of single files. It supports reading various medical imaging formats such as DICOM, KTX, and NIFTI.
+ */
+export class SingleFileReader extends AbstractFileReader {
+ constructor() {
+ super();
+ this.read = this.read.bind(this);
+ this.readSingleFile = this.readSingleFile.bind(this);
+ this.fileReadProgress = this.fileReadProgress.bind(this);
+ this.callbackReadSingleDicomComplete = this.callbackReadSingleDicomComplete.bind(this);
+ this.handleVolumeParametersSetSuccess = this.handleVolumeParametersSetSuccess.bind(this);
+
+ this.events.on(MriEvents.VOLUME_PARAMETERS_SET_SUCCESS, this.handleVolumeParametersSetSuccess);
+ }
+
+ /**
+ * Initiates reading of a single file.
+ * @param {File} file - The file to be read.
+ */
+ read(file: File): void {
+ this.setFileData(file);
+ this.fileReader.readAsArrayBuffer(file);
+ this.fileReader.onloadend = this.readSingleFile;
+ this.fileReader.addEventListener('progress', this.fileReadProgress);
+ }
+
+ /**
+ * Called when the FileReader has completed loading the file's data.
+ * Delegates to readFileData for processing the content.
+ */
+ readSingleFile() {
+ const data = this.fileReader.result as ArrayBuffer;
+ this.volumeSet.addVolume(new Volume());
+ this.readFileData(data);
+ }
+
+ /**
+ * Processes the read data based on the file extension.
+ * @param {ArrayBuffer} data - The data to be processed.
+ */
+ readFileData(data: ArrayBuffer) {
+ switch (this.fileExtension) {
+ case '':
+ case MriExtensions.DCM:
+ case MriExtensions.TXT:
+ this.readFromDicom(data);
+ break;
+ case MriExtensions.KTX:
+ this.readFromKtx(data);
+ break;
+ case MriExtensions.NII:
+ this.readFromNifti(data);
+ break;
+ default:
+ this.handleVolumeReadFailed(`Unsupported file extension: ${this.fileExtension}`);
+ break;
+ }
+ }
+
+ /**
+ * Reads and processes a KTX file's data.
+ * @param {ArrayBuffer} content - The file content.
+ * @returns {LoadResult} The result of the read operation.
+ */
+ readFromKtx(content: ArrayBuffer) {
+ const loader = new LoaderKtx();
+ const vol = this.volumeSet.getVolume(0);
+ const ret = loader.readFromBuffer(vol, content, this.callbackReadProgress, this.callbackReadComplete);
+ return ret;
+ }
+
+ /**
+ * Reads and processes a NIFTI file's data.
+ * @param {ArrayBuffer} content - The file content.
+ * @returns {LoadResult} The result of the read operation.
+ */
+ readFromNifti(content: ArrayBuffer) {
+ const loader = new LoaderNifti();
+ const vol = this.volumeSet.getVolume(0);
+ const ret = loader.readFromBuffer(vol, content, this.callbackReadProgress, this.callbackReadComplete);
+ return ret;
+ }
+
+ /**
+ * Reads and processes a DICOM file's data.
+ * @param {ArrayBuffer} content - The file content.
+ * @returns {LoadResult} The result of the read operation.
+ */
+ readFromDicom(content: ArrayBuffer) {
+ this.loader = new LoaderDicom(1);
+ const loaderDcm = new LoaderDcmDaikon();
+ const status = loaderDcm.readSingleSlice(this.store, this.loader, 0, this.fileName, content);
+ this.callbackReadSingleDicomComplete(status);
+ return status;
+ }
+
+ /**
+ * Sets metadata such as the file name and extension for the file being processed.
+ * @param {File} file - The file for which to set data.
+ */
+ setFileData(file: File): void {
+ this.fileName = file.name.toLowerCase();
+ this.fileExtension = this.getFileExtension(file);
+ }
+
+ /**
+ * Retrieves the extension of the given file.
+ * @param {File} file - The file from which to extract the extension.
+ * @returns {MriExtensions | ''} The file extension, or an empty string if no extension is found.
+ */
+ getFileExtension(file: File): MriExtensions | '' {
+ const parts = file.name.toLowerCase().split('.');
+
+ if (parts.length === 1) {
+ return '';
+ }
+
+ return (parts[parts.length - 1] as MriExtensions) || '';
+ }
+
+ /**
+ * Handles the progress event of the FileReader, updating the callback with the load progress.
+ * @param {Object} progressEvent - The progress event emitted by FileReader.
+ * @param {number} progressEvent.loaded - The number of bytes loaded.
+ * @param {number} progressEvent.total - The total number of bytes.
+ */
+ fileReadProgress({ loaded, total }: { loaded: number; total: number }) {
+ this.callbackReadProgress(loaded / total);
+ }
+
+ /**
+ * Callback invoked upon completion of reading a single DICOM file.
+ * @param {number} status - The status of the read operation.
+ */
+ callbackReadSingleDicomComplete(status: number) {
+ if (status !== LoadResult.SUCCESS) {
+ return this.callbackReadComplete(status);
+ }
+
+ this.callbackReadProgress(1);
+ this.store.setSingleDicom(this.volumeSet, this.volumeIndex, this.loader);
+ this.events.emit(MriEvents.FILE_READ_SUCCESS);
+ }
+
+ /**
+ * Handles the successful setting of volume parameters after reading the file.
+ */
+ handleVolumeParametersSetSuccess(): void {
+ this.handleVolumeLoadSuccess();
+
+ if (this.loader && this.loader instanceof LoaderDicom) {
+ const dicomSeries = this.loader.m_slicesVolume.getSeries();
+ this.store.dispatch({ type: StoreActionType.SET_DICOM_SERIES, dicomSeries });
+ }
+ }
+}
diff --git a/src/engine/lib/enums/events.enum.ts b/src/engine/lib/enums/events.enum.ts
new file mode 100644
index 00000000..18d5c4b4
--- /dev/null
+++ b/src/engine/lib/enums/events.enum.ts
@@ -0,0 +1,19 @@
+/* eslint-disable no-unused-vars */
+export enum MriEvents {
+ FILE_READ_SUCCESS = 'fileReadSuccess',
+ FILE_READ_ERROR = 'fileReadError',
+ FILE_SELECTED = 'fileSelectSucces',
+ VOLUME_PARAMETERS_SET_SUCCESS = 'VolumeParametersSetSuccess',
+ VOLUME_LOAD_SUCCESS = 'VolumeLoadSuccess',
+}
+
+export enum MriExtensions {
+ DCM = 'dcm',
+ KTX = 'ktx',
+ NII = 'nii',
+ HDR = 'hdr',
+ IMG = 'img',
+ TXT = 'txt',
+ ZIP = 'zip',
+}
+/* eslint-enable no-unused-vars */
diff --git a/src/engine/lib/enums/index.ts b/src/engine/lib/enums/index.ts
new file mode 100644
index 00000000..c556eeed
--- /dev/null
+++ b/src/engine/lib/enums/index.ts
@@ -0,0 +1 @@
+export * from './events.enum';
diff --git a/src/engine/lib/index.d.ts b/src/engine/lib/index.d.ts
new file mode 100644
index 00000000..e69de29b
diff --git a/src/engine/lib/interfaces/index.ts b/src/engine/lib/interfaces/index.ts
new file mode 100644
index 00000000..52b56386
--- /dev/null
+++ b/src/engine/lib/interfaces/index.ts
@@ -0,0 +1,3 @@
+export interface data {
+ data: any;
+}
diff --git a/src/engine/lib/services/ConfigService.ts b/src/engine/lib/services/ConfigService.ts
new file mode 100644
index 00000000..c1100e7a
--- /dev/null
+++ b/src/engine/lib/services/ConfigService.ts
@@ -0,0 +1,12 @@
+export class MRIConfigService {
+ get config(): any {
+ return {};
+ }
+}
+
+// Create the singleton instance and freeze it
+const mriEventsService = new MRIConfigService();
+Object.freeze(mriEventsService);
+
+// Export the MRIEventsService singleton instance
+export default mriEventsService;
diff --git a/src/engine/lib/services/EventsService.ts b/src/engine/lib/services/EventsService.ts
new file mode 100644
index 00000000..deab2824
--- /dev/null
+++ b/src/engine/lib/services/EventsService.ts
@@ -0,0 +1,28 @@
+export class MRIEventsService {
+ private events: { [key: string]: Function[] } = {};
+
+ on(eventName: string, fn: Function): Function {
+ if (!this.events[eventName]) {
+ this.events[eventName] = [];
+ }
+ this.events[eventName].push(fn);
+ return () => this.off(eventName, fn);
+ }
+
+ off(eventName: string, fn: Function): void {
+ if (!this.events[eventName]) return;
+ this.events[eventName] = this.events[eventName].filter((subscriber) => subscriber !== fn);
+ }
+
+ emit(eventName: string, data = {}): void {
+ if (!this.events[eventName]) return;
+ this.events[eventName].forEach((fn) => fn(data));
+ }
+}
+
+// Create the singleton instance and freeze it
+const mriEventsService = new MRIEventsService();
+Object.freeze(mriEventsService);
+
+// Export the MRIEventsService singleton instance
+export default mriEventsService;
diff --git a/src/engine/lib/services/LocalStorageService.ts b/src/engine/lib/services/LocalStorageService.ts
new file mode 100644
index 00000000..167521c5
--- /dev/null
+++ b/src/engine/lib/services/LocalStorageService.ts
@@ -0,0 +1,38 @@
+export class MRILocalStorageService {
+ RECENT_FILES_KEY: string = 'recentFiles';
+
+ constructor() {
+ this.saveRecentFiles = this.saveRecentFiles.bind(this);
+ }
+
+ get localStorage(): Storage {
+ if (!localStorage) {
+ throw new Error('Local Storage is not available');
+ }
+
+ return localStorage;
+ }
+
+ getData(key: string): string {
+ const stringData = this.localStorage.getItem(key);
+ return stringData ? JSON.parse(stringData) : '';
+ }
+
+ setData(key: string, data: any): void {
+ this.localStorage.setItem(key, JSON.stringify(data));
+ }
+
+ saveRecentFiles(fileName: string): void {
+ const recentFiles = this.getData(this.RECENT_FILES_KEY);
+ const limitedRecentFiles = recentFiles.slice(0, 2);
+ const data = [{ fileName, timestamp: Date.now() }, ...limitedRecentFiles];
+ this.setData(this.RECENT_FILES_KEY, data);
+ }
+}
+
+// Create the singleton instance and freeze it
+const mriLocalStorageService = new MRILocalStorageService();
+Object.freeze(mriLocalStorageService);
+
+// Export the FileLoader singleton instance
+export default mriLocalStorageService;
diff --git a/src/engine/lib/services/StoreService.ts b/src/engine/lib/services/StoreService.ts
new file mode 100644
index 00000000..e0b1a876
--- /dev/null
+++ b/src/engine/lib/services/StoreService.ts
@@ -0,0 +1,101 @@
+import { Store } from 'redux';
+import { store } from '../../../store';
+import StoreActionType from '../../../store/ActionTypes';
+import Modes3d from '../../../store/Modes3d';
+import ViewMode from '../../../store/ViewMode';
+import VolumeSet from '../../VolumeSet';
+import LoaderDicom from '../../loaders/LoaderDicom';
+import LoaderHdr from '../../loaders/LoaderHdr';
+
+export class MRIStoreService {
+ private store: Store;
+ public dispatch: Function;
+
+ constructor() {
+ this.store = store;
+ this.dispatch = store.dispatch;
+
+ this.getState = this.getState.bind(this);
+ this.setVolume = this.setVolume.bind(this);
+ this.dispatchActions = this.dispatchActions.bind(this);
+ this.setLoadingProgress = this.setLoadingProgress.bind(this);
+ }
+
+ public getState(): any {
+ return this.store.getState();
+ }
+
+ public dispatchActions(actions: any): void {
+ actions.forEach(this.dispatch);
+ }
+
+ public startLoadingSpinner(spinnerTitle: string): void {
+ this.setLoadingProgress(0);
+ this.dispatchActions([
+ { type: StoreActionType.SET_SPINNER, spinner: true },
+ { type: StoreActionType.SET_SPINNER_TITLE, spinnerTitle },
+ ]);
+ }
+
+ public setLoadingProgress(value: number): void {
+ this.dispatch({
+ type: StoreActionType.SET_SPINNER_PROGRESS,
+ spinnerProgress: value,
+ });
+ }
+
+ public setVolume(volumeSet: VolumeSet, volumeIndex: number, fileName: string): void {
+ const actions = [
+ { type: StoreActionType.SET_FILENAME, fileName },
+ { type: StoreActionType.SET_VOLUME_SET, volumeSet },
+ { type: StoreActionType.SET_VOLUME_INDEX, volumeIndex },
+ { type: StoreActionType.SET_MODE_3D, mode3d: Modes3d.RAYCAST },
+ { type: StoreActionType.SET_MODE_VIEW, viewMode: ViewMode.VIEW_2D },
+ { type: StoreActionType.SET_PROGRESS, progress: 0 },
+ { type: StoreActionType.SET_SPINNER, spinner: false },
+ { type: StoreActionType.SET_IS_LOADED, isLoaded: true },
+ { type: StoreActionType.SET_ERR_ARRAY, arrErrors: [] },
+ ];
+
+ this.dispatchActions(actions);
+ }
+
+ public setSingleDicom(volumeSet: VolumeSet, volumeIndex: number, loaderDicom: LoaderDicom | LoaderHdr | undefined): void {
+ const actions = [
+ { type: StoreActionType.SET_VOLUME_SET, volumeSet },
+ { type: StoreActionType.SET_LOADER_DICOM, loaderDicom },
+ { type: StoreActionType.SET_VOLUME_INDEX, volumeIndex },
+ { type: StoreActionType.SET_SPINNER, spinner: false },
+ ];
+
+ this.dispatchActions(actions);
+ }
+
+ public setDicomLoader(loaderDicom: LoaderDicom): void {
+ const actions = [
+ { type: StoreActionType.SET_LOADER_DICOM, loaderDicom },
+ { type: StoreActionType.SET_DICOM_INFO, dicomInfo: loaderDicom.m_dicomInfo },
+ ];
+
+ this.dispatchActions(actions);
+ }
+
+ public setVolumeLoadFailed(fileName: string, errors: string[]): void {
+ const actions = [
+ { type: StoreActionType.SET_ERR_ARRAY, errors },
+ { type: StoreActionType.SET_VOLUME_SET, volume: null },
+ { type: StoreActionType.SET_FILENAME, fileName: fileName },
+ { type: StoreActionType.SET_PROGRESS, progress: 0 },
+ { type: StoreActionType.SET_SPINNER, spinner: false },
+ { type: StoreActionType.SET_IS_LOADED, isLoaded: false },
+ ];
+
+ this.dispatchActions(actions);
+ }
+}
+
+// Create the singleton instance and freeze it
+const mriStoreService = new MRIStoreService();
+Object.freeze(mriStoreService);
+
+export default mriStoreService;
diff --git a/src/engine/lib/services/index.ts b/src/engine/lib/services/index.ts
new file mode 100644
index 00000000..d5a20c57
--- /dev/null
+++ b/src/engine/lib/services/index.ts
@@ -0,0 +1,5 @@
+import mriEventsService, { MRIEventsService } from './EventsService';
+import mriLocalStorageService, { MRILocalStorageService } from './LocalStorageService';
+import mriStoreService, { MRIStoreService } from './StoreService';
+
+export { mriEventsService, mriLocalStorageService, mriStoreService, MRIEventsService, MRILocalStorageService, MRIStoreService };
diff --git a/src/engine/lib/utils/index.ts b/src/engine/lib/utils/index.ts
new file mode 100644
index 00000000..944a376a
--- /dev/null
+++ b/src/engine/lib/utils/index.ts
@@ -0,0 +1 @@
+export * from './url';
diff --git a/src/engine/lib/utils/url.ts b/src/engine/lib/utils/url.ts
new file mode 100644
index 00000000..169b9a64
--- /dev/null
+++ b/src/engine/lib/utils/url.ts
@@ -0,0 +1,59 @@
+/**
+ * Checks if a given string is a valid URL with http or https protocol.
+ * @param {string} urlString - The string to be checked.
+ * @returns {boolean} True if the string is a valid URL, false otherwise.
+ */
+const isValidUrl = (urlString: string) => {
+ try {
+ const url = new URL(urlString);
+ return url.protocol === 'http:' || url.protocol === 'https:';
+ } catch (error) {
+ return false;
+ }
+};
+
+/**
+ * Extracts the file name from a URL.
+ * @param {string} url - The URL from which to extract the file name.
+ * @returns {string} The file name, or an empty string if the URL is invalid.
+ */
+const getFileNameFromUrl = (url: string) => {
+ const lastSlashIndex = Math.max(url.lastIndexOf('/'), url.lastIndexOf('\\'));
+ if (lastSlashIndex < 0) {
+ console.warn('getFileNameFromUrl: wrong URL!');
+ return '';
+ }
+ const strFileName = url.substring(lastSlashIndex + 1);
+ const MAX_LEN = 40;
+ return strFileName.length <= MAX_LEN ? strFileName : strFileName.substring(0, MAX_LEN);
+};
+
+/**
+ * Extracts the folder name from a URL.
+ * @param {string} url - The URL from which to extract the folder name.
+ * @returns {string} The folder name, or an empty string if the URL is invalid.
+ */
+const getFolderNameFromUrl = (url: string) => {
+ const lastSlashIndex = Math.max(url.lastIndexOf('/'), url.lastIndexOf('\\'));
+ if (lastSlashIndex < 0) {
+ console.warn('getFolderNameFromUrl: wrong URL!');
+ return '';
+ }
+ return url.substring(0, lastSlashIndex);
+};
+
+/**
+ * Extracts the extension from a URL.
+ * @param {string} url - The URL from which to extract the extension.
+ * @returns {string} The extracted extension.
+ */
+const getExtensionFromUrl = (url: string) => {
+ const lastDotIndex = url.lastIndexOf('.');
+ if (lastDotIndex < 0) {
+ console.warn('getExtensionFromUrl: No extension found in URL!');
+ return '';
+ }
+ return url.slice(lastDotIndex + 1);
+};
+
+export { isValidUrl, getFileNameFromUrl, getFolderNameFromUrl, getExtensionFromUrl };
diff --git a/src/engine/loaders/FileLoader.js b/src/engine/loaders/FileLoader.js
deleted file mode 100644
index bc3c62c6..00000000
--- a/src/engine/loaders/FileLoader.js
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright 2021 EPAM Systems, Inc. (https://www.epam.com/)
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Common binary file loader
- * @module src/demo/engine/loaders/FileLoader
- */
-
-// ******************************************************************
-// File loader
-// ******************************************************************
-
-/** Instance habdle for loader */
-let GInstanceFileLoader = null;
-
-/** Class FileLoader for load binary files */
-export default class FileLoader {
- /** Create empty loader
- * @param {string} strUrl - URL for loaded file
- */
- constructor(strUrl) {
- if (!GInstanceFileLoader) {
- GInstanceFileLoader = this;
- }
- /** @property {string} m_url - Urlf ror file being read */
- this.m_url = strUrl;
- /** @property {object} m_request - XMLHttpRequest object, used for acees to resource */
- this.m_request = null;
- this.readFile = this.readFile.bind(this);
- }
-
- /** Read file
- * @param {object} doneCallback - invoked callback
- */
- readFile(doneCallback, rejectCallback) {
- const METHOD = 'GET';
- this.m_request = new XMLHttpRequest();
- if (!this.m_request) {
- console.log('Cant create object request');
- }
- if ('withCredentials' in this.m_request) {
- // this.m_request.withCredentials = true;
- const NEED_ASYNC = true;
- this.m_request.open(METHOD, this.m_url, NEED_ASYNC);
- // } else if (typeof XDomainRequest !== 'undefined') {
- // console.log('HttpRequest: XDomainRequest will be used');
- // this.m_request = new XDomainRequest();
- // this.m_request.open(METHOD, this.m_url);
- } else {
- this.m_request = null;
- console.log('This browser cant support CORS requests');
- return;
- }
-
- this.m_request.responseType = 'arraybuffer'; // "blob"
- this.m_request.addEventListener(
- 'load',
- (event) => {
- const arrBuf = event.target.response;
- if (arrBuf === null) {
- console.log('Bad response type. Expect object type in response.');
- } else if (doneCallback) {
- // console.log(`FileFromServer response received. url = ${this.m_url}`);
-
- // check wrong buffer content
- const enc = new TextDecoder('utf-8');
- let sz = arrBuf.byteLength;
- if (sz > 4000) {
- sz = 4000;
- }
- const bufHead = arrBuf.slice(0, sz);
- const strBuf = enc.decode(bufHead);
- if (strBuf.substr(0, 9) === ' {
- // console.log(`Error event happend for XMLHttpRequest: loaded = ${event.loaded}, total = ${event.total}`);
- const errMsg = `Error accessing file ${this.m_url}`;
- rejectCallback(errMsg);
- },
- false
- );
-
- this.m_request.send();
- const RES_FAIL_404 = 404;
- if (this.m_request.status === RES_FAIL_404) {
- const errMsg = `Cant access url = ${this.m_url}`;
- rejectCallback(errMsg);
- }
- }
-} // end class FileLoader
diff --git a/src/engine/loaders/FileReader.js b/src/engine/loaders/FileReader.js
deleted file mode 100644
index 16b4728a..00000000
--- a/src/engine/loaders/FileReader.js
+++ /dev/null
@@ -1,904 +0,0 @@
-/*
- * Copyright 2022 EPAM Systems, Inc. (https://www.epam.com/)
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// import { gzip, ungzip } from 'node-gzip';
-// import UiModalDicomSeries from './UiModalDicomSeries';
-
-import React from 'react';
-import zlib from 'zlib';
-import createReadStream from 'filereader-stream';
-
-import StoreActionType from '../../store/ActionTypes';
-import ViewMode from '../../store/ViewMode';
-import Modes3d from '../../store/Modes3d';
-
-import Volume from '../Volume';
-import VolumeSet from '../VolumeSet';
-
-import LoaderHdr from './LoaderHdr';
-import FileTools from './FileTools';
-import LoadResult from '../LoadResult';
-import LoaderDicom from './LoaderDicom';
-import LoaderUrlDicom from './LoaderUrlDicom';
-import LoaderDcmDaikon from './LoaderDcmDaikon';
-import LoaderDcmUrlDaikon from './LoadDcmUrlDiakon';
-
-import config from '../../config/config';
-
-const NEED_TEXTURE_SIZE_4X = true;
-const READ_DICOM_VIA_DAIKON = true;
-
-class FileReader extends React.Component {
- constructor(props) {
- super(props);
- this.onButtonOpenLocalFileClick = this.onButtonOpenLocalFileClick.bind(this);
- this.handleFileSelected = this.handleFileSelected.bind(this);
- this.onFileContentReadSingleFile = this.onFileContentReadSingleFile.bind(this);
- this.onFileContentReadMultipleDicom = this.onFileContentReadMultipleDicom.bind(this);
- this.onFileContentReadMultipleHdr = this.onFileContentReadMultipleHdr.bind(this);
- this.setErrorString = this.setErrorString.bind(this);
- this.onModalUrlShow = this.onModalUrlShow.bind(this);
- this.onModalUrlHide = this.onModalUrlHide.bind(this);
- this.onClickLoadUrl = this.onClickLoadUrl.bind(this);
- this.callbackReadCompleteUrlKtxNii = this.callbackReadCompleteUrlKtxNii.bind(this);
- this.onModalDemoOpenShow = this.onModalDemoOpenShow.bind(this);
- this.onModalDemoOpenHide = this.onModalDemoOpenHide.bind(this);
- this.onDemoSelected = this.onDemoSelected.bind(this);
- this.onModalWindowCWHide = this.onModalWindowCWHide.bind(this);
- this.onModalGoogleShow = this.onModalGoogleShow.bind(this);
- this.onModalGoogleHide = this.onModalGoogleHide.bind(this);
- this.onGoogleSelected = this.onGoogleSelected.bind(this);
- this.onModalDicomSeriesHide = this.onModalDicomSeriesHide.bind(this);
- this.onDicomSerieSelected = this.onDicomSerieSelected.bind(this);
- this.callbackReadProgress = this.callbackReadProgress.bind(this);
- this.callbackReadComplete = this.callbackReadComplete.bind(this);
- this.callbackReadSingleDicomComplete = this.callbackReadSingleDicomComplete.bind(this);
- this.callbackReadMultipleComplete = this.callbackReadMultipleComplete.bind(this);
- this.callbackCompleteMultipleDicom = this.callbackCompleteMultipleDicom.bind(this);
-
- this.m_fileNameOnLoad = '';
- this.m_fileName = '';
- this.m_fileIndex = 0;
- this.m_fileReader = null;
- this.m_fileSelector = this.buildFileSelector();
- this.m_fileSize = null;
- this.state = {
- showModalUrl: false,
- showModalDemo: false,
- showModalGoogle: false,
- showModalWindowCW: false,
- onLoadCounter: 1,
- };
- this.m_volumeSet = null;
- this.m_volumeRoi = null;
- this.m_updateEnable = true;
- this.roiMode = false;
- }
-
- finalizeSuccessLoadedVolume(volSet, fileNameIn) {
- const store = this.props;
-
- console.assert(volSet instanceof VolumeSet, 'finalizeSuccessLoadedVolume: should be VolumeSet');
- console.assert(volSet.getNumVolumes() >= 1, 'finalizeSuccessLoadedVolume: should be more or 1 volume');
- const indexVol = 0;
-
- const vol = volSet.getVolume(indexVol);
- console.assert(vol !== null, 'finalizeSuccessLoadedVolume: should be non zero volume');
-
- if (vol.m_dataArray !== null) {
- console.log(`success loaded volume from ${fileNameIn}`);
-
- this.saveFileNameToLocalStorage(fileNameIn);
-
- if (NEED_TEXTURE_SIZE_4X) {
- vol.makeDimensions4x();
- }
- // invoke notification
-
- // send update (repaint) if was loaded prev model
- if (store.isLoaded) {
- store.dispatch({ type: StoreActionType.SET_IS_LOADED, isLoaded: false });
- }
-
- store.dispatch({ type: StoreActionType.SET_VOLUME_SET, volumeSet: volSet });
- store.dispatch({ type: StoreActionType.SET_VOLUME_INDEX, volumeIndex: 0 });
- store.dispatch({ type: StoreActionType.SET_IS_LOADED, isLoaded: true });
- store.dispatch({ type: StoreActionType.SET_FILENAME, fileName: fileNameIn });
- store.dispatch({ type: StoreActionType.SET_ERR_ARRAY, arrErrors: [] });
- store.dispatch({ type: StoreActionType.SET_MODE_VIEW, viewMode: ViewMode.VIEW_2D });
- store.dispatch({ type: StoreActionType.SET_MODE_3D, mode3d: Modes3d.RAYCAST });
- store.dispatch({ type: StoreActionType.SET_SPINNER, spinner: false });
- }
- }
-
- setErrorString(strErr) {
- const store = this.props;
- const arrErrors = [];
- arrErrors.push(strErr);
- store.dispatch({ type: StoreActionType.SET_IS_LOADED, isLoaded: false });
- store.dispatch({ type: StoreActionType.SET_ERR_ARRAY, arrErrors: arrErrors });
- store.dispatch({ type: StoreActionType.SET_VOLUME_SET, volume: null });
- }
-
- finalizeFailedLoadedVolume(volSet, fileNameIn, arrErrors) {
- console.assert(arrErrors !== undefined);
- // invoke notification
- const store = this.props;
- store.dispatch({ type: StoreActionType.SET_IS_LOADED, isLoaded: false });
- store.dispatch({ type: StoreActionType.SET_VOLUME_SET, volume: null });
- store.dispatch({ type: StoreActionType.SET_ERR_ARRAY, arrErrors: arrErrors });
- store.dispatch({ type: StoreActionType.SET_FILENAME, fileName: fileNameIn });
- store.dispatch({ type: StoreActionType.SET_PROGRESS, progress: 0 });
- }
-
- callbackReadProgress(ratio01) {
- // console.log(`callbackReadProgress = ${ratio01}`);
- const ratioPrc = Math.floor(ratio01 * 100);
- const store = this.props;
- console.log('ratioPrc ===================> ' + ratioPrc);
- console.log('ratio01 ===================> ' + ratio01);
- if (ratioPrc >= 99) {
- // console.log(`callbackReadProgress. hide on = ${ratio01}`);
- store.dispatch({
- type: StoreActionType.SET_PROGRESS,
- progress: 0,
- });
- } else {
- store.dispatch({
- type: StoreActionType.SET_PROGRESS,
- progress: ratioPrc,
- });
- }
- } // callback progress
-
- callbackReadComplete(errCode) {
- if (errCode === undefined) {
- console.log('callbackReadComplete. should be errCode');
- } else {
- if (errCode !== LoadResult.SUCCESS) {
- const strErr = LoadResult.getResultString(errCode);
- this.setErrorString(strErr);
- }
- }
- const store = this.props;
- store.dispatch({
- type: StoreActionType.SET_PROGRESS,
- progress: 0,
- });
- if (errCode === LoadResult.SUCCESS) {
- // console.log('callbackReadComplete finished OK');
- this.finalizeSuccessLoadedVolume(this.m_volumeSet, this.m_fileName);
- } else {
- console.log(`callbackReadComplete failed! reading ${this.m_fileName} file`);
- const arrErr = [];
- const strErr = LoadResult.getResultString(errCode);
- arrErr.push(strErr);
- this.finalizeFailedLoadedVolume(this.m_volumeSet, this.m_fileName, arrErr);
- }
- }
-
- callbackReadSingleDicomComplete(errCode) {
- if (errCode === LoadResult.SUCCESS) {
- const store = this.props;
- store.dispatch({ type: StoreActionType.SET_VOLUME_SET, volumeSet: this.m_volumeSet });
- store.dispatch({ type: StoreActionType.SET_VOLUME_INDEX, volumeIndex: 0 });
- // save dicom loader to store
- store.dispatch({ type: StoreActionType.SET_LOADER_DICOM, loaderDicom: this.m_loader });
-
- // show modal: select window center, width
- this.setState({ showModalWindowCW: true });
- return; // do nothing immediately after: wait for dialog
- }
- this.callbackReadComplete(errCode);
- }
-
- callbackReadMultipleComplete(errCode) {
- if (errCode !== LoadResult.SUCCESS) {
- const strErr = LoadResult.getResultString(errCode);
- this.setErrorString(strErr);
- }
- }
-
- onFileContentReadSingleFile() {
- let strContent = this.m_fileReader.result;
- this.onFileReadSingleBuffer(strContent);
- console.log(this.onFileReadSingleBuffer(strContent));
- }
-
- //
- // daikon read individual slice from file buffer (one from multiple files)
- // strContent is ArrayBuffer
- readSliceDicomViaDaikon(fileIndex, fileName, ratioLoad, strContent) {
- const loaderDaikon = new LoaderDcmDaikon();
- return loaderDaikon.readSlice(this.m_loader, fileIndex, fileName, strContent);
- } // end read single slice via daikon
-
- //
- // based on local file read
- // read from string content in this.m_fileReader.result
- //
- onFileReadSingleBuffer(strContent) {
- // daikon read
- // strContent is ArrayBuffer
- if ((this.m_fileName.endsWith('.dcm') || this.m_fileName.endsWith('.DCM')) && READ_DICOM_VIA_DAIKON) {
- const loaderDcm = new LoaderDcmDaikon();
- const store = this.props;
- const fileIndex = this.m_fileIndex;
- const fileName = this.m_fileName;
- this.m_loader = new LoaderDicom(1);
- const ret = loaderDcm.readSingleSlice(store, this.m_loader, fileIndex, fileName, strContent);
- this.callbackReadSingleDicomComplete(ret);
- return ret;
- }
-
- console.log('UiOpenMenu. onFileReadSingleBuffer ...');
- // console.log(`file content = ${strContent.substring(0, 64)}`);
- // console.log(`onFileContentRead. type = ${typeof strContent}`);
- this.m_volumeSet = new VolumeSet();
- // add empty [0]-th volume in set to read single file
- this.m_volumeSet.addVolume(new Volume());
- const callbackProgress = this.callbackReadProgress;
- const callbackComplete = this.callbackReadComplete;
- const callbackCompleteSingleDicom = this.callbackReadSingleDicomComplete;
-
- if (this.m_fileName.endsWith('.ktx') || this.m_fileName.endsWith('.KTX')) {
- // if read ktx
- // debugger;
- this.m_volumeSet.readFromKtx(strContent, callbackProgress, callbackComplete);
- } else if (this.m_fileName.endsWith('.nii') || this.m_fileName.endsWith('.NII')) {
- this.m_volumeSet.readFromNifti(strContent, callbackProgress, callbackComplete);
- } else if (this.m_fileName.endsWith('.dcm') || this.m_fileName.endsWith('.DCM')) {
- this.m_loader = new LoaderDicom();
- this.m_loader.m_zDim = 1;
- this.m_loader.m_numFiles = 1;
- this.m_volumeSet.readFromDicom(this.m_loader, strContent, callbackProgress, callbackCompleteSingleDicom);
- // save dicomInfo to store
- const dicomInfo = this.m_loader.m_dicomInfo;
- const sliceInfo = dicomInfo.m_sliceInfo[0];
- sliceInfo.m_fileName = this.m_fileName;
- sliceInfo.m_sliceName = 'Slice 0';
- const store = this.props;
- store.dispatch({ type: StoreActionType.SET_DICOM_INFO, dicomInfo: dicomInfo });
- } else if (this.m_fileName.endsWith('.hdr') || this.m_fileName.endsWith('.HDR')) {
- // readOk = vol.readFromHdrHeader(strContent, callbackProgress, callbackComplete);
- console.log(`cant read single hdr file: ${this.m_fileName}`);
- // readStatus = LoadResult.BAD_HEADER;
- } else if (this.m_fileName.endsWith('.img') || this.m_fileName.endsWith('.IMG')) {
- // readOk = vol.readFromHdrImage(strContent, callbackProgress, callbackComplete);
- console.log(`cant read single img file: ${this.m_fileName}`);
- // readStatus = LoadResult.BAD_HEADER;
- } else {
- console.log(`onFileContentReadSingleFile: unknown file type: ${this.m_fileName}`);
- }
- }
-
- //
- // read hdr/img. content is in this.m_fileReader.result
- //
- onFileContentReadMultipleHdr() {
- const VALID_NUM_FILES_2 = 2;
- const VALID_NUM_FILES_4 = 4;
- if (this.m_numFiles !== VALID_NUM_FILES_2 && this.m_numFiles !== VALID_NUM_FILES_4) {
- console.log(`onFileContentReadMultipleHdr: can read ${VALID_NUM_FILES_2} or ${VALID_NUM_FILES_4} files for multiple hdr loader`);
- return;
- }
-
- const isHdr = this.m_fileName.endsWith('hdr') || this.m_fileName.endsWith('HDR');
- console.log(`onFileContentReadMultipleHdr: read file ${this.m_fileName}. Ratio=${this.m_fileIndex} / ${this.m_numFiles}`);
- this.m_fileIndex++;
- const ratioLoad = this.m_fileIndex / this.m_numFiles;
- const strContent = this.m_fileReader.result;
- // const lenContent = strContent.length;
-
- if (this.m_fileIndex <= 1) {
- // add single volume to set
- if (this.m_volumeSet.getNumVolumes() === 0) {
- this.m_volumeSet.addVolume(new Volume());
- }
- this.callbackReadProgress(0.0);
- }
-
- if (this.m_numFiles === VALID_NUM_FILES_4 && this.m_volumeRoi === null) {
- this.m_volumeRoi = new Volume();
- }
-
- const callbackProgress = null;
- const callbackComplete = null;
-
- const regExpFileName = /([\S]+)\.[\S]+/;
- const fnameArr = regExpFileName.exec(this.m_fileName);
- const numFN = fnameArr.length;
- let detectedMask = false;
- let detectedIntensity = false;
- if (numFN === 2) {
- const fname = fnameArr[1];
- if (fname.endsWith('_mask')) {
- detectedMask = true;
- }
- if (fname.endsWith('_intn')) {
- detectedIntensity = true;
- }
- }
- let volDst = this.m_volumeSet.getVolume(0);
- if (this.m_fileIndex > VALID_NUM_FILES_2) {
- volDst = this.m_volumeRoi;
- }
- if (detectedIntensity) {
- volDst = this.m_volumeSet.getVolume(0);
- }
- if (detectedMask) {
- volDst = this.m_volumeRoi;
- this.roiMode = true;
- // console.log('mask vol by name');
- if (this.m_numFiles !== VALID_NUM_FILES_4) {
- console.log('You need to load 4 files, if one of them has _mask in name');
- return;
- }
- }
-
- // read header or image from src files
- let readOk;
- if (isHdr) {
- readOk = this.m_loader.readFromBufferHeader(volDst, strContent, callbackProgress, callbackComplete);
- } else {
- readOk = this.m_loader.readFromBufferImage(volDst, strContent, callbackProgress, callbackComplete);
- }
-
- // create final volume from readed data
- volDst = this.m_volumeSet.getVolume(0);
- if (readOk && this.m_fileIndex === this.m_numFiles) {
- let ok = false;
- if (this.m_numFiles === VALID_NUM_FILES_2) {
- ok = this.m_loader.createVolumeFromHeaderAndImage(volDst);
- } else if (this.m_numFiles === VALID_NUM_FILES_4) {
- // intensity data 16 -> 8 bpp
- ok = this.m_loader.createVolumeFromHeaderAndImage(volDst);
- if (ok) {
- // mix 8 bpp intensity and roi pixels
- ok = this.m_loader.createRoiVolumeFromHeaderAndImage(volDst, this.m_volumeRoi);
- }
- }
- this.callbackReadProgress(1.0);
- if (!ok) {
- this.callbackReadComplete(LoadResult.FAIL);
- } else {
- this.callbackReadComplete(LoadResult.SUCCESS);
- }
- }
-
- // read again new file
- if (this.m_fileIndex < this.m_numFiles) {
- this.callbackReadProgress(ratioLoad);
- this.m_fileReader.onloadend = this.onFileContentReadMultipleHdr;
- const file = this.m_files[this.m_fileIndex];
- this.m_fileName = file.name;
- this.m_fileReader.readAsArrayBuffer(file);
- }
- } // on multuple hdr
-
- // on complete read multuple dicom
- callbackCompleteMultipleDicom(errCode) {
- if (errCode !== LoadResult.SUCCESS) {
- const strErr = LoadResult.getResultString(errCode);
- this.setErrorString(strErr);
- }
- }
-
- //
- // read from string content in this.m_fileReader.result
- //
- onFileContentReadMultipleDicom() {
- // console.log('UiOpenMenu. onFileContentReadMultipleDicom ...');
- const strContent = this.m_fileReader.result;
- this.m_fileIndex++;
- const ratioLoad = this.m_fileIndex / this.m_numFiles;
- // console.log(`onFileContentReadMultipleDicom. r = ${ratioLoad}`);
- const callbackProgress = null;
- // const callbackComplete = this.callbackReadMultipleComplete;
-
- if (this.m_fileIndex <= 1) {
- // add new volume to volume set on the first slice
- const vol = new Volume();
- this.m_volumeSet.addVolume(vol);
- // init progress on the first file loading
- this.callbackReadProgress(0.0);
- }
-
- // FIX 05/06/2020: read multiple dicom callback complete
- // can be invoked with error code
- const callbackColmpleteVoid = this.callbackCompleteMultipleDicom;
-
- let readStatus;
-
- if (READ_DICOM_VIA_DAIKON) {
- readStatus = this.readSliceDicomViaDaikon(this.m_fileIndex - 1, this.m_fileName, ratioLoad, strContent);
- } else {
- readStatus = this.m_volumeSet.readSingleSliceFromDicom(
- this.m_loader,
- this.m_fileIndex - 1,
- this.m_fileName,
- ratioLoad,
- strContent,
- callbackProgress,
- callbackColmpleteVoid
- );
- }
-
- if (readStatus !== LoadResult.SUCCESS) {
- console.log('onFileContentReadMultipleDicom. Error read individual file');
- }
- if (readStatus === LoadResult.SUCCESS && this.m_fileIndex === this.m_numFiles) {
- // setup global vars
- const store = this.props;
- store.dispatch({ type: StoreActionType.SET_VOLUME_INDEX, volumeIndex: 0 });
- store.dispatch({ type: StoreActionType.SET_VOLUME_SET, volumeSet: this.m_volumeSet });
-
- // save dicom loader to store
- store.dispatch({ type: StoreActionType.SET_LOADER_DICOM, loaderDicom: this.m_loader });
- // stop show loading progress bar
- this.callbackReadProgress(1.0);
- this.callbackReadComplete(LoadResult.SUCCESS);
-
- // show modal: select window center, width
- this.setState({ showModalWindowCW: true });
- return; // do nothing immediately after: wait for dialog
- } // end if successfully read all files (multiple dicom read)
- // read again new file
- if (readStatus === LoadResult.SUCCESS) {
- if (this.m_fileIndex < this.m_numFiles) {
- // print console loading progress
- const NUM_PARTS_REPORT = 16;
- const STEP_PROGRESS = Math.floor(this.m_numFiles / NUM_PARTS_REPORT);
- if (this.m_fileIndex % STEP_PROGRESS === 0) {
- // console.log(`onFileContentReadMultipleDicom. Loading completed = ${ratioLoad}`);
- this.callbackReadProgress(ratioLoad);
- }
-
- this.m_fileReader.onloadend = this.onFileContentReadMultipleDicom;
- const file = this.m_files[this.m_fileIndex];
- this.m_fileName = file.name;
- this.m_fileReader.readAsArrayBuffer(file);
- } // if still need files
- } else {
- const arrErr = [];
- const strErr = this.props.arrErrors[0];
- arrErr.push(strErr);
- this.finalizeFailedLoadedVolume(this.m_volumeSet, this.m_fileName, arrErr);
- } // if result is not success
- }
-
- //
- // Perform open file after it selected in dialog
- handleFileSelected(evt) {
- const files = evt.target.files || evt.dataTransfer.files;
-
- if (!files) {
- return;
- }
-
- let numFiles = files.length;
- console.log(`UiOpenMenu. Trying to open ${numFiles} files`);
- if (numFiles <= 0) {
- return;
- }
- console.log(`UiOpenMenu. handleFileSelected. file[0] = ${files[0].name}`);
- // debugger;
- console.log('evt = ' + files);
- this.m_volumeSet = new VolumeSet();
- if (numFiles === 1) {
- const file = files[0];
- this.m_fileName = file.name;
- this.m_fileSize = file.size;
- console.log('this.m_fileSize ->>>>>>>>>>>>>> ' + this.m_fileSize);
- console.log('evt.loaded ->>>>>>>>>>>>>> ' + evt.loaded);
- console.log('evt.total ->>>>>>>>>>>>>> ' + evt.total);
-
- // read gzip
- if (this.m_fileName.endsWith('.gz')) {
- // here will be result raw buffer
- this.m_unzippedBuffer = null;
-
- // remove last 3 chars form file name string
- this.m_fileName = this.m_fileName.slice(0, -3);
-
- const store = this.props;
-
- const gunzip = zlib.createGunzip();
- createReadStream(file).pipe(gunzip);
- gunzip.on('data', (data) => {
- if (this.m_unzippedBuffer == null) {
- store.dispatch({ type: StoreActionType.SET_PROGRESS, progress: 0 });
- } else {
- const readSize = this.m_unzippedBuffer.length;
- const allSize = file.size;
- const KOEF_DEFLATE = 0.28;
- const ratio100 = Math.floor((readSize * 100.0 * KOEF_DEFLATE) / allSize);
- store.dispatch({ type: StoreActionType.SET_PROGRESS, progress: ratio100 });
- }
-
- // read the data chunk-by-chunk
- // data is Uint8Array
- const dataSize = data.length;
- if (this.m_unzippedBuffer == null) {
- // create buffer from first ungzipped data chunk
- this.m_unzippedBuffer = new Uint8Array(dataSize);
- this.m_unzippedBuffer.set(data, 0);
- } else {
- // append buffer from 2,3,... ungzipped data chunks
- const dataCollectedSize = this.m_unzippedBuffer.length;
- const arrNew = new Uint8Array(dataCollectedSize + dataSize);
- arrNew.set(this.m_unzippedBuffer, 0);
- arrNew.set(data, dataCollectedSize);
- this.m_unzippedBuffer = arrNew;
- }
- });
- gunzip.on('close', () => {
- console.log('gzip on close');
- });
-
- gunzip.on('end', () => {
- store.dispatch({ type: StoreActionType.SET_PROGRESS, progress: 0 });
- // now all chunks are read. Need to check raw ungzipped buffer
- const sizeBuffer = this.m_unzippedBuffer.length;
- if (sizeBuffer < 128) {
- console.log('Too small ungzipped data: ' + sizeBuffer.toString() + " bytes. can't read volume data");
- return;
- }
- // check correct nifti header after extract raw bytes from gzip
- const headTemplate = [0x00, 0x00, 0x01, 0x5c];
- let correctHead0 = true;
- for (let i = 0; i < 4; i++) {
- if (this.m_unzippedBuffer[i] !== headTemplate[i]) {
- correctHead0 = false;
- }
- }
- let correctHead1 = true;
- for (let i = 0; i < 4; i++) {
- if (this.m_unzippedBuffer[i] !== headTemplate[3 - i]) {
- correctHead1 = false;
- }
- }
- if (!correctHead0 && !correctHead1) {
- console.log('Wrong nifi header, cant read gzipped file');
- return;
- }
- console.log('ungzip done with ' + sizeBuffer.toString() + ' bytes. Correct nifti header detected');
- // process raw data buffer
- this.onFileReadSingleBuffer(this.m_unzippedBuffer);
- });
- return;
- } // if gzipped file
- this.m_fileReader = new window.FileReader();
-
- const progressHandler = ({ loaded, total }) => {
- this.callbackReadProgress(loaded / total);
- };
-
- console.log(this.m_fileReader);
-
- this.m_fileReader.addEventListener('progress', progressHandler);
- this.m_fileReader.onloadend = this.onFileContentReadSingleFile;
- this.m_fileReader.readAsArrayBuffer(file);
- } else {
- // not single file was open
- this.m_files = Array.from(files); // FileList -> Array
- this.m_fileIndex = 0;
- this.m_numFiles = numFiles;
- this.m_fileReader = new window.FileReader();
- // if multiple files, create Dicom loader
- this.m_loader = null;
- if (files[0].name.endsWith('.dcm')) {
- // remove non-dcm files
- let numFilesNew = 0;
- for (let i = numFiles - 1; i >= 0; i--) {
- if (this.m_files[i].name.endsWith('.dcm')) {
- numFilesNew++;
- } else {
- this.m_files.splice(i, 1);
- }
- }
- numFiles = numFilesNew;
- this.m_numFiles = numFilesNew;
-
- this.m_loader = new LoaderDicom(numFiles);
- const dicomInfo = this.m_loader.m_dicomInfo;
-
- // save dicomInfo to store
- const store = this.props;
- store.dispatch({ type: StoreActionType.SET_DICOM_INFO, dicomInfo: dicomInfo });
-
- // save dicom loader to store
- store.dispatch({ type: StoreActionType.SET_LOADER_DICOM, loaderDicom: this.m_loader });
-
- this.m_fileReader.onloadend = this.onFileContentReadMultipleDicom;
- } else if (files[0].name.endsWith('.hdr') || files[0].name.endsWith('.img')) {
- this.m_loader = new LoaderHdr(numFiles);
- this.m_fileReader.onloadend = this.onFileContentReadMultipleHdr;
- }
-
- //const vol = new Volume();
- //this.m_volume = vol;
- this.m_volumeRoi = null;
-
- const file = files[0];
- this.m_fileName = file.name;
- this.m_fileReader.readAsArrayBuffer(file);
- } // if event is not empty
- }
-
- buildFileSelector() {
- const fileSelector = document.createElement('input');
- fileSelector.setAttribute('type', 'file');
- fileSelector.setAttribute('hidden', 'true');
- fileSelector.setAttribute('accept', '.txt,.ktx,.dcm,.nii,.hdr,.h,.img,.gz');
- fileSelector.setAttribute('multiple', 'true');
- document.body.appendChild(fileSelector);
- fileSelector.onchange = this.handleFileSelected;
- return fileSelector;
- }
-
- onButtonOpenLocalFileClick(evt) {
- // console.log('onButtonLocalFile started');
- // debugger;
- evt.preventDefault();
- this.m_fileSelector.click();
- }
-
- //
- onModalUrlShow() {
- console.log(`onModalUrlShow`);
- this.setState({ showModalUrl: true });
- }
-
- onModalUrlHide() {
- console.log(`onModalUrlHide`);
- this.setState({ showModalUrl: false });
- }
-
- callbackReadCompleteUrlKtxNii(codeResult) {
- if (codeResult !== LoadResult.SUCCESS) {
- console.log(`onCompleteFromUrlKtx. Bad result: ${codeResult}`);
-
- const arrErrors = [];
- const strErr = LoadResult.getResultString(codeResult);
- arrErrors.push(strErr);
- this.finalizeFailedLoadedVolume(this.m_volumeSet, this.m_fileName, arrErrors);
- } else {
- this.finalizeSuccessLoadedVolume(this.m_volumeSet, this.m_fileName);
- this.callbackReadComplete(LoadResult.SUCCESS, null, 0, null);
- }
- }
-
- loadFromUrl(strUrl) {
- if (FileTools.isValidUrl(strUrl)) {
- this.m_url = strUrl;
-
- this.m_fileName = FileTools.getFileNameFromUrl(strUrl);
- this.m_volumeSet = new VolumeSet();
- this.m_volumeSet.addVolume(new Volume());
-
- if (strUrl.endsWith('.ktx')) {
- // debugger;
- const callbackProgress = this.callbackReadProgress;
- const callbackComplete = this.callbackReadCompleteUrlKtxNii;
- this.callbackReadProgress(0.0);
- // debugger;
- this.m_volumeSet.readFromKtxUrl(strUrl, callbackProgress, callbackComplete);
- // if KTX
- } else if (strUrl.endsWith('.nii')) {
- const callbackProgress = this.callbackReadProgress;
- const callbackComplete = this.callbackReadCompleteUrlKtxNii;
- this.callbackReadProgress(0.0);
- this.m_volumeSet.readFromNiiUrl(strUrl, callbackProgress, callbackComplete);
- // if NII (Nifti format)
- } else if (strUrl.endsWith('.dcm')) {
- if (READ_DICOM_VIA_DAIKON) {
- const loaderUrlDcm = new LoaderDcmUrlDaikon();
- return loaderUrlDcm.readFromUrl(this.m_volumeSet, strUrl, this.callbackReadCompleteUrlKtxNii, this.callbackReadProgress);
- }
-
- const callbackProgress = this.callbackReadProgress;
- const callbackComplete = this.callbackReadCompleteUrlKtxNii;
- this.callbackReadProgress(0.0);
- this.m_volumeSet.readFromDicomUrl(strUrl, callbackProgress, callbackComplete);
- // if Dicom
- } else if (strUrl.endsWith('.hdr')) {
- const callbackProgress = this.callbackReadProgress;
- const callbackComplete = this.callbackReadCompleteUrlKtxNii;
- this.callbackReadProgress(0.0);
- this.m_volumeSet.readFromHdrUrl(strUrl, callbackProgress, callbackComplete);
- // if Hdr
- } else {
- console.log(`UiOpenMenu. Unknown file type from URL = ${strUrl}`);
- }
- } else {
- const strErr = `UiOpenMenu. Bad URL = ${strUrl}`;
- console.log(strErr);
- this.setErrorString(strErr);
- }
- }
-
- onClickLoadUrl(strUrl) {
- this.setState({ showModalUrl: false });
- console.log(`onClickLoadUrl with strUrl = ${strUrl}`);
- this.loadFromUrl(strUrl);
- }
-
- //
- onModalDemoOpenShow() {
- this.setState({ showModalDemo: true });
- }
-
- onModalDemoOpenHide() {
- this.setState({ showModalDemo: false });
- }
-
- //
- arrNumToStr(arrNums) {
- const numLet = arrNums.length;
- let str = '';
- for (let i = 0; i < numLet; i++) {
- const n = arrNums[i];
- str = str.concat(String.fromCharCode(n));
- }
- return str;
- }
-
- onModalGoogleShow() {
- this.setState({ showModalGoogle: true });
- }
-
- onModalGoogleHide() {
- this.setState({ showModalGoogle: false });
- }
-
- onGoogleSelected(index) {
- // perform action on click i-th item in Google cloud menu . Or remove this menu completely
- console.log(`onGoogleSelected(${index}) ... `);
- }
-
- onDemoSelected(index) {
- const store = this.props;
- store.dispatch({
- type: StoreActionType.SET_PROGRESS,
- progress: 0,
- });
- store.dispatch({ type: StoreActionType.SET_SPINNER, spinner: true });
- const arr = config.demoUrls;
- if (arr.length >= 8) {
- const fileName = arr[index];
- console.log(`onDemoSelected: load file ${fileName}, config[ ${index} ]`);
- this.loadFromUrl(fileName);
- return;
- }
-
- const DEMO_URL = 'https://daentjnvnffrh.cloudfront.net/demo/';
-
- let fileName =
- DEMO_URL +
- [
- '01_lungs/20101108.ktx',
- '02_brain_set/brain256.ktx',
- '03_grandmother_gm3/gm3_512_512_165.nii',
- '04_woman_pelvis/file_list.txt',
- '05_lungs_00cba/file_list.txt',
- '06_ct_256/ct_256_256_256.ktx',
- '07_lungs_256/lungs_256_256_256.ktx',
- '08_brain_with_roi/set_intn.hdr',
- ][index] || console.log(`onDemoSelected. not implemented for index = ${index}`);
-
- if (fileName === '04_woman_pelvis/file_list.txt') {
- const numUrls = config.demoWomanPelvisUrls.length;
- if (numUrls > 0) {
- const strPrefix = config.demoWomanPelvisPrefix;
- // console.log(`config. prefix = ${strPrefix}`);
- const arrFileNames = [];
- for (let i = 0; i < numUrls; i++) {
- const strFn = config.demoWomanPelvisUrls[i];
- const url = `${strPrefix}${strFn}`;
- arrFileNames.push(url);
- }
- const store = this.props;
- const loader = new LoaderUrlDicom(store);
- const GOOGLE_HEADER = false;
- loader.loadFromUrlArray(arrFileNames, GOOGLE_HEADER);
- return;
- }
- }
- if (fileName === '05_lungs_00cba/file_list.txt') {
- const numUrls = config.demoLungsUrls.length;
- if (numUrls > 0) {
- const strPrefix = config.demoLungsPrefix;
- const arrFileNames = [];
- for (let i = 0; i < numUrls; i++) {
- const strFn = config.demoLungsUrls[i];
- const url = `${strPrefix}${strFn}`;
- arrFileNames.push(url);
- }
- const store = this.props;
- const loader = new LoaderUrlDicom(store);
- const GOOGLE_HEADER = false;
- loader.loadFromUrlArray(arrFileNames, GOOGLE_HEADER);
- return;
- }
- }
- if (fileName.length > 0) {
- console.log(`onDemoSelected. enc = ${fileName}`);
- this.loadFromUrl(fileName);
- }
- }
-
- //
- shouldComponentUpdate() {
- return true;
- }
-
- onModalDicomSeriesHide() {
- const arrEmpty = [];
- const store = this.props;
- store.dispatch({ type: StoreActionType.SET_DICOM_SERIES, dicomSeries: arrEmpty });
- }
-
- onDicomSerieSelected(indexSelected) {
- const store = this.props;
- const series = store.dicomSeries;
- const serieSelected = series[indexSelected];
- const hash = serieSelected.m_hash;
- this.m_loader.createVolumeFromSlices(this.m_volumeSet, indexSelected, hash);
- this.finalizeSuccessLoadedVolume(this.m_volumeSet, this.m_fileName);
- console.log(`onFileContentReadMultipleDicom read all ${this.m_numFiles} files`);
-
- // clear modal
- store.dispatch({ type: StoreActionType.SET_DICOM_SERIES, dicomSeries: [] });
- }
-
- //
- onModalWindowCWHide(needShow) {
- this.setState({ showModalWindowCW: false });
- if (needShow) {
- this.finalizeSuccessLoadedVolume(this.m_volumeSet, this.m_fileName);
- // setup dicom series (volumes info) for global store: select volume later
- const store = this.props;
- let series = null;
- if (this.m_loader !== undefined) {
- series = this.m_loader.m_slicesVolume.getSeries();
- store.dispatch({ type: StoreActionType.SET_DICOM_SERIES, dicomSeries: series });
- }
- // update graphics 2d window
- const gra = store.graphics2d;
- if (gra !== null) {
- gra.forceUpdate();
- }
- }
- }
-
- saveFileNameToLocalStorage(fileName) {
- const RECENT_FILES_KEY = 'recentFiles';
- const arrRecentFiles = JSON.parse(localStorage.getItem(RECENT_FILES_KEY)) || [];
-
- if (!arrRecentFiles.find((recentFile) => recentFile.fileName === fileName)) {
- // Set only unique file name
- const limitedRecentFiles = arrRecentFiles.slice(0, 2);
- localStorage.setItem(RECENT_FILES_KEY, JSON.stringify([{ fileName: fileName, timestamp: Date.now() }, ...limitedRecentFiles]));
- }
- }
-
- //
- // invoked after render
- //
- componentDidMount() {
- this.m_fileSelector = this.buildFileSelector();
- const fileNameOnLoad = this.m_fileNameOnLoad;
- // console.log(`UiOpenMenu. componentDidMount. fnonl = ${fileNameOnLoad}`);
- if (fileNameOnLoad.length > 0 && this.state.onLoadCounter > 0) {
- this.setState({ onLoadCounter: 0 });
- const TIMEOUT_MS = 50;
- // debugger;
- setTimeout(this.loadFromUrl(fileNameOnLoad), TIMEOUT_MS);
- }
- }
-}
-
-export default FileReader;
diff --git a/src/engine/loaders/FileTools.js b/src/engine/loaders/FileTools.js
deleted file mode 100644
index cfb34d2a..00000000
--- a/src/engine/loaders/FileTools.js
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2021 EPAM Systems, Inc. (https://www.epam.com/)
- * SPDX-License-Identifier: Apache-2.0
- */
-
-class FileTools {
- static isValidUrl(string) {
- let url;
-
- try {
- url = new URL(string);
- } catch (_) {
- return false;
- }
-
- return url.protocol === 'http:' || url.protocol === 'https:';
- }
-
- static getFileNameFromUrl(strUrl) {
- let idx = strUrl.lastIndexOf('/');
- if (idx < 0) {
- idx = strUrl.lastIndexOf('\\');
- }
- if (idx < 0) {
- console.log('getFileNameFromUrl: wrong URL!');
- return '';
- }
- let strFileName = strUrl.substring(idx + 1);
- const MAX_LEN = 40;
- strFileName = strFileName.length <= MAX_LEN ? strFileName : strFileName.substring(0, MAX_LEN);
- return strFileName;
- }
-
- static getFolderNameFromUrl(strUrl) {
- let idx = strUrl.lastIndexOf('/');
- if (idx < 0) {
- idx = strUrl.lastIndexOf('\\');
- }
- if (idx < 0) {
- console.log('getFolderNameFromUrl: wrong URL!');
- return '';
- }
- return strUrl.substring(0, idx);
- }
-}
-export default FileTools;
diff --git a/src/engine/loaders/LoadDcmUrlDiakon.js b/src/engine/loaders/LoadDcmUrlDiakon.js
deleted file mode 100644
index 78259f85..00000000
--- a/src/engine/loaders/LoadDcmUrlDiakon.js
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * Copyright 2021 EPAM Systems, Inc. (https://www.epam.com/)
- * SPDX-License-Identifier: Apache-2.0
- */
-
-//
-//
-//
-
-// **********************************************
-// Import
-// **********************************************
-
-import VolumeSet from '../VolumeSet';
-import LoadResult from '../LoadResult';
-import FileTools from './FileTools';
-import FileLoader from './FileLoader';
-import LoaderDcmDaikon from './LoaderDcmDaikon';
-import LoaderDicom from './LoaderDicom';
-// import DicomSlicesVolume from './dicomslicesvolume';
-
-// **********************************************
-// Const
-// **********************************************
-
-const DEBUG_PRINT_TAGS_INFO = false;
-
-// **********************************************
-// Class
-// **********************************************
-
-class LoaderDcmUrlDaikon {
- constructor() {
- this.m_loaderDaikon = new LoaderDcmDaikon();
- this.readReadyFileList = this.readReadyFileList.bind(this);
- }
-
- readFromUrl(volSet, strUrl, callbackComplete, callbackProgress) {
- // check arguments
- console.assert(volSet != null, 'Null volume');
- console.assert(volSet instanceof VolumeSet, 'Should be volume set');
- console.assert(strUrl != null, 'Null string url');
- console.assert(typeof strUrl === 'string', 'Should be string in url');
-
- if (!FileTools.isValidUrl(strUrl)) {
- console.log(`readFromUrl: not vaild URL = = ${strUrl} `);
- return false;
- }
- this.m_folder = FileTools.getFolderNameFromUrl(strUrl);
- const urlFileList = this.m_folder + '/file_list.txt';
- console.log(`readFromUrl: load file = ${urlFileList} `);
-
- callbackProgress(0.0);
-
- const fileLoader = new FileLoader(urlFileList);
- this.m_fileListCounter = 0;
- fileLoader.readFile(
- (arrBuf) => {
- this.m_fileListCounter += 1;
- if (this.m_fileListCounter === 1) {
- const okRead = this.readReadyFileList(volSet, arrBuf, callbackComplete, callbackProgress);
- return okRead;
- }
- return true;
- },
- (errMsg) => {
- console.log(`Error read file: ${errMsg}`);
- // callbackComplete(LoadResult.ERROR_CANT_OPEN_URL, null, 0, null);
- return false;
- }
- ); // get file from server
- return true;
- } // end read from url
-
- //
- readReadyFileList(volSet, arrBuf, callbackComplete, callbackProgress) {
- const uint8Arr = new Uint8Array(arrBuf);
- const strFileContent = String.fromCharCode.apply(null, uint8Arr);
-
- const LEN_LOG = 64;
- const strLog = strFileContent.substr(0, LEN_LOG);
- console.log(`Loaded file list. Started with: ${strLog} ...`);
-
- const arrFileNames = strFileContent.split('\n');
-
- let numFiles = arrFileNames.length;
- // check last empty elements
- const MIN_FILE_NAME_SIZE = 4;
- for (let i = numFiles - 1; i >= 0; i--) {
- if (arrFileNames[i].endsWith('\r')) {
- arrFileNames[i] = arrFileNames[i].substring(0, arrFileNames[i].length - 1);
- }
- if (arrFileNames[i].length < MIN_FILE_NAME_SIZE) {
- arrFileNames.pop();
- }
- }
- numFiles = arrFileNames.length;
- this.m_loaders = [];
- this.m_errors = [];
- // declare slices array
- for (let i = 0; i < numFiles; i++) {
- // this.m_slices[i] = null;
- this.m_errors[i] = -1;
- this.m_loaders[i] = null;
- }
-
- const zDim = numFiles;
- console.log(`Loaded file list. ${numFiles} files will be loaded. 1st file in list is = ${arrFileNames[0]}`);
- console.log(`Loaded file list. Last file in list is = ${arrFileNames[numFiles - 1]}`);
-
- this.m_loaderDaikon.m_loaderDicom = new LoaderDicom(numFiles);
-
- // physical dimension
- this.m_loaderDaikon.m_loaderDicom.m_pixelSpacing = {
- x: 0.0,
- y: 0.0,
- z: 0.0,
- };
- this.m_boxSize = {
- x: 1.0,
- y: 1.0,
- z: 1.0,
- };
- this.m_filesLoadedCounter = 0;
- this.m_numFailsLoad = 0;
- this.m_numLoadedFiles = numFiles;
-
- this.m_loaderDaikon.m_loaderDicom.m_imagePosMin = {
- // eslint-disable-next-line
- x: +1.0e12,
- // eslint-disable-next-line
- y: +1.0e12,
- // eslint-disable-next-line
- z: +1.0e12,
- };
- this.m_loaderDaikon.m_loaderDicom.m_imagePosMax = {
- // eslint-disable-next-line
- x: -1.0e12,
- // eslint-disable-next-line
- y: -1.0e12,
- // eslint-disable-next-line
- z: -1.0e12,
- };
-
- // eslint-disable-next-line
- this.m_loaderDaikon.m_sliceLocMin = +1.0e12;
- // eslint-disable-next-line
- this.m_loaderDaikon.m_sliceLocMax = -1.0e12;
-
- for (let i = 0; i < this.m_numLoadedFiles && this.m_numFailsLoad < 1; i++) {
- const urlFile = `${this.m_folder}/${arrFileNames[i]}`;
- // console.log(`trying read file ${urlFile} from web`);
-
- this.m_loaders[i] = new FileLoader(urlFile);
- const loader = this.m_loaders[i];
- loader.readFile((fileArrBu) => {
- const ratioLoaded = this.m_filesLoadedCounter / this.m_numLoadedFiles;
- const VAL_MASK = 7;
- if (callbackProgress !== undefined && (this.m_filesLoadedCounter & VAL_MASK) === 0) {
- //console.log(`LoadDcmUrlDaikon. Progress = ${ratioLoaded}`);
- callbackProgress(ratioLoaded);
- }
- //if ((callbackProgress !== undefined) &&
- // (this.m_filesLoadedCounter + 1 === this.m_numLoadedFiles)) {
- // callbackProgress(1.0);
- //}
- const ret = this.m_loaderDaikon.loadSingleSlice(i, urlFile, fileArrBu);
- if (ret !== LoadResult.SUCCESS) {
- return ret;
- }
- // console.log(`LoadDcmUrlDaikon. Loaded/All = ${this.m_filesLoadedCounter} / ${this.m_numLoadedFiles}`);
- this.m_filesLoadedCounter += 1;
- if (this.m_filesLoadedCounter === this.m_numLoadedFiles) {
- // Finalize physic dimension
- if (DEBUG_PRINT_TAGS_INFO) {
- console.log(`slice location (min, max) = ${this.m_sliceLocMin}, ${this.m_sliceLocMax}`);
- }
- const imagePosBox = {
- x: this.m_loaderDaikon.m_loaderDicom.m_imagePosMax.x - this.m_loaderDaikon.m_loaderDicom.m_imagePosMin.x,
- y: this.m_loaderDaikon.m_loaderDicom.y - this.m_loaderDaikon.m_loaderDicom.m_imagePosMin.y,
- z: this.m_loaderDaikon.m_loaderDicom.m_imagePosMax.z - this.m_loaderDaikon.m_loaderDicom.m_imagePosMin.z,
- };
- const TOO_MIN = 0.00001;
- let zBox;
- if (Math.abs(this.m_loaderDaikon.m_loaderDicom.m_pixelSpacing.z) > TOO_MIN) {
- zBox = this.m_loaderDaikon.m_loaderDicom.m_pixelSpacing.z * zDim;
- } else {
- zBox = imagePosBox.z;
- if (Math.abs(zBox) < TOO_MIN) {
- zBox = imagePosBox.x;
- if (Math.abs(zBox) < TOO_MIN) {
- zBox = imagePosBox.y;
- }
- }
- } // if pixel spacing 0
- if (zBox < TOO_MIN) {
- zBox = 1.0;
- }
- const xDim = this.m_loaderDaikon.m_loaderDicom.m_xDim;
- const yDim = this.m_loaderDaikon.m_loaderDicom.m_yDim;
-
- this.m_loaderDaikon.m_loaderDicom.m_pixelSpacing.z = zBox / zDim;
- this.m_boxSize.z = zDim * this.m_loaderDaikon.m_loaderDicom.m_pixelSpacing.z;
- this.m_boxSize.x = xDim * this.m_loaderDaikon.m_loaderDicom.m_pixelSpacing.x;
- this.m_boxSize.y = yDim * this.m_loaderDaikon.m_loaderDicom.m_pixelSpacing.y;
- console.log(`LoadDcmUrlDaikon. Volume local phys dim: ${this.m_boxSize.x} * ${this.m_boxSize.y} * ${this.m_boxSize.z}`);
-
- // TODO: add hash
- let series = this.m_loaderDaikon.m_loaderDicom.m_slicesVolume.getSeries();
- if (series.length === 0) {
- this.m_loaderDaikon.m_loaderDicom.m_slicesVolume.buildSeriesInfo();
- series = this.m_loaderDaikon.m_loaderDicom.m_slicesVolume.getSeries();
- }
- const indexSerie = 0;
- const hash = series[indexSerie].m_hash;
- const errStatus = this.m_loaderDaikon.m_loaderDicom.createVolumeFromSlices(volSet, indexSerie, hash);
- if (callbackProgress !== null) {
- callbackProgress(1.0);
- }
-
- if (callbackComplete !== null) {
- callbackComplete(errStatus);
- return true;
- }
- } // if last file
- }); // file buffer is ready to parse
- } // for i all files
-
- return LoadResult.SUCCESS;
- } // end readReadyFileList
-} // end class LoaderDcmUrlDaikon
-
-export default LoaderDcmUrlDaikon;
diff --git a/src/engine/loaders/LoadPromise.js b/src/engine/loaders/LoadPromise.js
deleted file mode 100644
index 0226bc01..00000000
--- a/src/engine/loaders/LoadPromise.js
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright 2021 EPAM Systems, Inc. (https://www.epam.com/)
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
-/**
-* File load from local disk or URL with promise to complete
-* @module demo/engine.loaders/loadpromise
-*/
-
-// ******************************************************************
-// class LoadFilePromise
-// ******************************************************************
-
-/** Class LoadFilePromise implements local and remote (via URL) file reading functionality via Promises */
-export default class LoadFilePromise {
- constructor() {
- this.m_file = null;
- this.m_reader = null;
- this.m_request = null;
- }
-
- /**
- * Read local file. If success, invoke resolve callback for created promise
- *
- * @param {object} file - file to read
- * @return {object} Promise, working after file will be read
- */
- readLocal(file) {
- return new Promise((resolve) => {
- this.m_file = file;
- this.m_reader = new FileReader();
- this.m_reader.addEventListener('load', (evt) => {
- const arrBuf = evt.target.result;
- if (resolve) {
- resolve(arrBuf);
- }
- });
- this.m_reader.readAsArrayBuffer(this.m_file);
- });
- }
-
- /**
- * Read remote file (via promise). If success, invoke resolve callback for created promise
- *
- * @param {string} url - file to read
- * @return {object} Promise, working after file will be read
- */
- readFromUrl(url) {
- return new Promise((resolve, reject) => {
- this.m_url = url;
- this.m_request = null;
- const METHOD = 'GET';
- this.m_request = new XMLHttpRequest();
- if ('withCredentials' in this.m_request) {
- // this.m_request.withCredentials = true;
- const NEED_ASYNC = true;
- this.m_request.open(METHOD, this.m_url, NEED_ASYNC);
- // } else if (typeof XDomainRequest !== 'undefined') {
- // console.log('HttpRequest: XDomainRequest will be used');
- // this.m_request = new XDomainRequest();
- // this.m_request.open(METHOD, this.m_url);
- } else {
- this.m_request = null;
- console.log('This browser cant support CORS requests');
- return;
- }
- this.m_request.responseType = 'arraybuffer'; // "blob"
- this.m_request.addEventListener(
- 'load',
- (event) => {
- const arrBuf = event.target.response;
- if (arrBuf === null) {
- console.log('Bad response type. Expect object type in response.');
- } else {
- resolve(arrBuf);
- }
- },
- false
- );
-
- this.m_request.addEventListener(
- 'error',
- (event) => {
- const strError = `Error event happend for XMLHttpRequest: loaded = ${event.loaded}, total = ${event.total}`;
- console.log(strError);
- reject(strError);
- },
- false
- );
- this.m_request.send();
- });
- }
-}
diff --git a/src/engine/loaders/LoaderDcmDaikon.js b/src/engine/loaders/LoaderDcmDaikon.js
index c9265217..172512d0 100644
--- a/src/engine/loaders/LoaderDcmDaikon.js
+++ b/src/engine/loaders/LoaderDcmDaikon.js
@@ -374,7 +374,7 @@ class LoaderDcmDaikon {
const tagSLT = image.tags[ind];
if (tagSLT !== undefined) {
let arrThick = tagSLT.value;
- if (arrThick.length === 1) {
+ if (arrThick && arrThick.length === 1) {
this.m_loaderDicom.m_pixelSpacing.z = parseFloat(arrThick[0]);
}
// console.log('val pad = ' + valPad);
diff --git a/src/engine/loaders/LoaderDicom.js b/src/engine/loaders/LoaderDicom.js
index e3ea110d..1cd66c1d 100644
--- a/src/engine/loaders/LoaderDicom.js
+++ b/src/engine/loaders/LoaderDicom.js
@@ -26,8 +26,6 @@ import DicomSlice from './dicomslice';
import DicomSlicesVolume from './dicomslicesvolume';
import DicomSliceInfo from './dicomsliceinfo';
import DicomTagInfo from './dicomtaginfo';
-import FileTools from './FileTools';
-import FileLoader from './FileLoader';
// import Volume from '../Volume';
import VolumeSet from '../VolumeSet';
@@ -38,7 +36,6 @@ import Volume from '../Volume';
// ********************************************************
const DEBUG_PRINT_TAGS_INFO = false;
-const DEBUG_PRINT_INDI_SLICE_INFO = false;
const NEED_SCAN_EMPTY_BORDER = false;
const NEED_APPLY_GAUSS_SMOOTHING = false;
@@ -235,8 +232,6 @@ class LoaderDicom {
this.m_sliceLocMin = +1.0e12;
// eslint-disable-next-line
this.m_sliceLocMax = -1.0e12;
-
- this.runLoader = this.runLoader.bind(this);
}
getBoxSize() {
return this.m_boxSize;
@@ -1865,238 +1860,6 @@ class LoaderDicom {
}
return LoadResult.SUCCESS;
} // end readFromBuffer
-
- readFromUrl(volSet, strUrl, callbackProgress, callbackComplete) {
- // check arguments
- console.assert(volSet != null, 'Null volume');
- console.assert(volSet instanceof VolumeSet, 'Should be volume set');
- console.assert(strUrl != null, 'Null string url');
-
- // console.log(`typeof(strUrl) - ${typeof(strUrl)}`);
- console.assert(typeof strUrl === 'string', 'Should be string in url');
-
- if (!FileTools.isValidUrl(strUrl)) {
- console.log(`readFromUrl: not vaild URL = = ${strUrl} `);
- return false;
- }
- this.m_folder = FileTools.getFolderNameFromUrl(strUrl);
- const urlFileList = this.m_folder + '/file_list.txt';
- console.log(`readFromUrl: load file = ${urlFileList} `);
-
- const fileLoader = new FileLoader(urlFileList);
- this.m_callbackComplete = callbackComplete;
- this.m_callbackProgress = callbackProgress;
- this.m_fileListCounter = 0;
- fileLoader.readFile(
- (arrBuf) => {
- this.m_fileListCounter += 1;
- if (this.m_fileListCounter === 1) {
- const okRead = this.readReadyFileList(volSet, arrBuf, callbackProgress, callbackComplete);
- return okRead;
- }
- return true;
- },
- (errMsg) => {
- console.log(`Error read file: ${errMsg}`);
- callbackComplete(LoadResult.ERROR_CANT_OPEN_URL, null, 0, null);
- return false;
- }
- ); // get file from server
- return true;
- }
- readReadyFileList(volSet, arrBuf, callbackProgress, callbackComplete) {
- // check arguments
- console.assert(volSet != null, 'Null volume');
- console.assert(volSet instanceof VolumeSet, 'Should be volume set');
- console.assert(arrBuf != null, 'Null array');
- console.assert(arrBuf.constructor.name === 'ArrayBuffer', 'Should be ArrayBuf in arrBuf');
-
- const uint8Arr = new Uint8Array(arrBuf);
- // const strFileContent = new TextDecoder('utf-8').decode(uint8Arr);
- const strFileContent = String.fromCharCode.apply(null, uint8Arr);
-
- const LEN_LOG = 64;
- const strLog = strFileContent.substr(0, LEN_LOG);
- console.log(`Loaded file list. Started with: ${strLog} ...`);
-
- const arrFileNames = strFileContent.split('\n');
-
- let numFiles = arrFileNames.length;
- // check last empty elements
- const MIN_FILE_NAME_SIZE = 4;
- for (let i = numFiles - 1; i >= 0; i--) {
- if (arrFileNames[i].endsWith('\r')) {
- arrFileNames[i] = arrFileNames[i].substring(0, arrFileNames[i].length - 1);
- }
- if (arrFileNames[i].length < MIN_FILE_NAME_SIZE) {
- arrFileNames.pop();
- }
- }
- numFiles = arrFileNames.length;
-
- this.m_zDim = numFiles;
- console.log(`Loaded file list. ${numFiles} files will be loaded. 1st file in list is = ${arrFileNames[0]}`);
- console.log(`Loaded file list. Last file in list is = ${arrFileNames[numFiles - 1]}`);
-
- // declare slices array
- for (let i = 0; i < numFiles; i++) {
- // this.m_slices[i] = null;
- this.m_errors[i] = -1;
- this.m_loaders[i] = null;
- }
-
- // physical dimension
- this.m_pixelSpacing = {
- x: 0.0,
- y: 0.0,
- z: 0.0,
- };
- this.m_filesLoadedCounter = 0;
- this.m_numFailsLoad = 0;
- this.m_numLoadedFiles = numFiles;
-
- this.m_imagePosMin = {
- // eslint-disable-next-line
- x: +1.0e12,
- // eslint-disable-next-line
- y: +1.0e12,
- // eslint-disable-next-line
- z: +1.0e12,
- };
- this.m_imagePosMax = {
- // eslint-disable-next-line
- x: -1.0e12,
- // eslint-disable-next-line
- y: -1.0e12,
- // eslint-disable-next-line
- z: -1.0e12,
- };
-
- // eslint-disable-next-line
- this.m_sliceLocMin = +1.0e12;
- // eslint-disable-next-line
- this.m_sliceLocMax = -1.0e12;
-
- for (let i = 0; i < this.m_numLoadedFiles && this.m_numFailsLoad < 1; i++) {
- const urlFile = `${this.m_folder}/${arrFileNames[i]}`;
- // console.log(`Loading (${i})-th url: ${urlFile}`);
- this.m_loaders[i] = new FileLoader(urlFile);
- const loader = this.m_loaders[i];
- const NOT_FROM_GOOGLE = false;
- // let volDst = volSet.getVolume(0);
- //if (volDst === null) {
- // volDst = new Volume();
- // volSet.addVolume(volDst);
- // }
- const okLoader = this.runLoader(volSet, arrFileNames[i], loader, i, callbackProgress, callbackComplete, NOT_FROM_GOOGLE);
- if (!okLoader) {
- return false;
- }
- } // for i all files-slices in folder
- return true;
- } // end readReadyFileList(arrBuf)
- /**
- * Run loader to read dicom file
- * @param {object} volSet - destination volum set
- * @param {string} fileName - File to read
- * @param {object} loader - loader object with file inside
- * @param {number} i - index of file in files array
- * @param {func} callbackProgress - callback for continiuos load reporting
- * @param {func} callbackComplete - callback after load finish
- * @param {bool} fromGoogle - true, if from google store
- *
- */
- runLoader(volSet, fileName, loader, i, callbackProgress, callbackComplete, fromGoogle) {
- this.m_fromGoogle = fromGoogle;
- // console.log(`Loading url: ${fileName}`);
- loader.readFile(
- (fileArrBu) => {
- const ratioLoaded = this.m_filesLoadedCounter / this.m_numLoadedFiles;
- const VAL_MASK = 7;
- if (callbackProgress !== undefined && (this.m_filesLoadedCounter & VAL_MASK) === 0) {
- callbackProgress(ratioLoaded);
- }
- if (callbackProgress !== undefined && this.m_filesLoadedCounter + 1 === this.m_numLoadedFiles) {
- callbackProgress(1.0);
- }
- this.m_newTagEvent.detail.fileName = fileName;
-
- let status;
- if (this.m_fromGoogle) {
- status = this.readFromGoogleBuffer(i, fileName, ratioLoaded, fileArrBu, callbackProgress, callbackComplete);
- } else {
- status = this.readFromBuffer(i, fileName, ratioLoaded, fileArrBu, callbackProgress, callbackComplete);
- }
-
- if (status !== LoadResult.SUCCESS && this.m_numFailsLoad === 0) {
- this.m_numFailsLoad += 1;
- if (callbackComplete !== null) {
- callbackComplete(status, null, 0, null, fileName);
- return false;
- }
- }
- // update total files counter
- this.m_filesLoadedCounter += 1;
- if (DEBUG_PRINT_INDI_SLICE_INFO) {
- console.log(`Loaded local indi slice: ${fileName}. Total loaded slices: ${this.m_filesLoadedCounter}`);
- }
- // console.log(`!!!!!!!!! m_filesLoadedCounter = ${this.m_filesLoadedCounter} / ${this.m_numLoadedFiles}`);
-
- if (this.m_filesLoadedCounter === this.m_numLoadedFiles) {
- // Finalize physic dimension
- if (DEBUG_PRINT_TAGS_INFO) {
- console.log(`slice location (min, max) = ${this.m_sliceLocMin}, ${this.m_sliceLocMax}`);
- }
- const imagePosBox = {
- x: this.m_imagePosMax.x - this.m_imagePosMin.x,
- y: this.m_imagePosMax.y - this.m_imagePosMin.y,
- z: this.m_imagePosMax.z - this.m_imagePosMin.z,
- };
- const TOO_MIN = 0.00001;
- let zBox;
- if (Math.abs(this.m_pixelSpacing.z) > TOO_MIN) {
- zBox = this.m_pixelSpacing.z * this.m_zDim;
- } else {
- zBox = imagePosBox.z;
- if (Math.abs(zBox) < TOO_MIN) {
- zBox = imagePosBox.x;
- if (Math.abs(zBox) < TOO_MIN) {
- zBox = imagePosBox.y;
- }
- }
- } // if pixel spacing 0
- if (zBox < TOO_MIN) {
- zBox = 1.0;
- }
-
- this.m_pixelSpacing.z = zBox / this.m_zDim;
- this.m_boxSize.z = this.m_zDim * this.m_pixelSpacing.z;
- this.m_boxSize.x = this.m_xDim * this.m_pixelSpacing.x;
- this.m_boxSize.y = this.m_yDim * this.m_pixelSpacing.y;
- console.log(`Volume local phys dim: ${this.m_boxSize.x} * ${this.m_boxSize.y} * ${this.m_boxSize.z}`);
- // TODO: add hash
- let series = this.m_slicesVolume.getSeries();
- if (series.length === 0) {
- this.m_slicesVolume.buildSeriesInfo();
- series = this.m_slicesVolume.getSeries();
- }
- const indexSerie = 0;
- const hash = series[indexSerie].m_hash;
- const errStatus = this.createVolumeFromSlices(volSet, indexSerie, hash);
- if (callbackComplete !== null) {
- callbackComplete(errStatus);
- return true;
- }
- } // if last file was loaded
- return true;
- },
- (errMsg) => {
- console.log(`Error read file: ${errMsg}`);
- return false;
- }
- ); // end of readfile
- return true;
- } // end runLoader
} // end class LoaderDicom
export default LoaderDicom;
diff --git a/src/engine/loaders/LoaderHdr.js b/src/engine/loaders/LoaderHdr.js
index 5afb751e..9bd99595 100644
--- a/src/engine/loaders/LoaderHdr.js
+++ b/src/engine/loaders/LoaderHdr.js
@@ -14,25 +14,12 @@
// ********************************************************
import LoadResult from '../LoadResult';
-import FileTools from './FileTools';
-import LoadFilePromise from './LoadPromise';
import Volume from '../Volume';
-import VolumeSet from '../VolumeSet';
-
-// ********************************************************
-// Const
-// ********************************************************
-
-// const NEED_EVEN_TEXTURE_SIZE = false;
const HDR_DT_NONE = 0;
const HDR_DT_UNSIGNED_CHAR = 2;
const HDR_DT_SIGNED_SHORT = 4;
-// ********************************************************
-// Class
-// ********************************************************
-
/**
* Class LoaderHdr some text later...
*/
@@ -126,7 +113,8 @@ class LoaderHdr {
const bufBytes = new Uint8Array(arrBuf);
const bufLen = bufBytes.length;
const HDR_HEADER_SIZE = 348;
- // console.log(`Header buf size === ${bufLen}`);
+ console.log(`Header buf size === ${bufLen}`);
+
if (bufLen !== HDR_HEADER_SIZE) {
if (callbackComplete) {
callbackComplete(LoadResult.WRONG_HEADER_DATA_SIZE, null, 0, null);
@@ -437,164 +425,7 @@ class LoaderHdr {
volDst.m_bytesPerVoxel = FOUR;
console.log('createRoiVolumeFromHeaderAndImage: success');
return true;
- } //
-
- /**
- * Read hdr (h + img) files from URL
- *
- * @param {object} volSet - volume set
- * @param {string} strUrl - url string
- * @param {func} callbackProgress - callback during read progress
- * @param {func} callbackComplete - callback after complete (good or bad)
- * @return true, if success
- */
- readFromUrl(volSet, strUrl, callbackProgress, callbackComplete) {
- console.log(`readFromUrl. going to read from ${strUrl} ...`);
-
- if (!FileTools.isValidUrl(strUrl)) {
- console.log(`readFromUrl: not vaild URL = = ${strUrl} `);
- return false;
- }
- this.m_folder = FileTools.getFolderNameFromUrl(strUrl);
- const fileName = FileTools.getFileNameFromUrl(strUrl);
- // console.log(`readFromUrl: folder = ${this.m_folder} filename = ${fileName}`);
-
- const regExp = /(\w+)_intn.(h|hdr)/;
- const arrGrp = regExp.exec(fileName);
- if (arrGrp.length !== 3) {
- console.log(`LoaderHdr.readFromUrl: bad URL name = ${strUrl}. Should be in template NNN_intn.h `);
- return false;
- }
- const namePrefix = arrGrp[1];
- //console.log(`readFromUrl: name prefix = ${namePrefix}, grpLen = ${arrGrp.length}`);
-
- const fileNameIntensityHeader = this.m_folder + '/' + namePrefix + '_intn.hdr';
- const fileNameIntensityImage = this.m_folder + '/' + namePrefix + '_intn.img';
- const fileNameMaskHeader = this.m_folder + '/' + namePrefix + '_mask.hdr';
- const fileNameMaskImage = this.m_folder + '/' + namePrefix + '_mask.img';
-
- const arrUrls = [];
- arrUrls.push(fileNameIntensityHeader);
- arrUrls.push(fileNameIntensityImage);
- arrUrls.push(fileNameMaskHeader);
- arrUrls.push(fileNameMaskImage);
- const ok = this.readFromUrls(arrUrls, volSet, callbackProgress, callbackComplete);
-
- return ok;
- } // end of readFromUrl
-
- /**
- *
- * @param {object} arrUrls - array of strings urls
- * @param {*} volSet - dest volume set
- * @param {*} callbackProgress - callback during read
- * @param {*} callbackComplete - callback after end fo read
- */
- readFromUrls(arrUrls, volSet, callbackProgress, callbackComplete) {
- // check arguments
- console.assert(volSet != null, 'Null volume set');
- console.assert(volSet instanceof VolumeSet, 'Should be volume set');
-
- const numUrls = arrUrls.length;
- const NUM_URLS_IN_SET = 2;
- const NUM_FILES_VOL_INT_ROI = 4;
- if (numUrls === NUM_URLS_IN_SET) {
- let urlHdr = arrUrls[0];
- let urlImg = arrUrls[1];
- const loaderHdr = new LoadFilePromise();
- const loaderImg = new LoadFilePromise();
- if (urlHdr.indexOf('.hdr') === -1) {
- const strCopy = urlHdr;
- urlHdr = urlImg;
- urlImg = strCopy;
- }
-
- // this.m_volIntensity = new HdrVolume(this.m_needScaleDownTexture);
-
- const volDst = volSet.getVolume(0);
- loaderHdr.readFromUrl(urlHdr).then(
- (arrBufHdr) => {
- this.readFromBufferHeader(volDst, arrBufHdr, callbackComplete, callbackProgress);
- console.log(`Load success HDR file: ${urlHdr}`);
- loaderImg.readFromUrl(urlImg).then((arrBufImg) => {
- this.readFromBufferImage(volDst, arrBufImg, callbackComplete, callbackProgress);
- console.log(`Load success IMG file: ${urlImg}`);
-
- // complete 2 images
- this.createVolumeFromHeaderAndImage(volDst);
-
- // invoke callback for good loading end
- callbackComplete(LoadResult.SUCCESS);
- });
- },
- (error) => {
- console.log('HDR File read error', error);
- callbackComplete(LoadResult.ERROR_CANT_OPEN_URL, null, 0, null);
- return false;
- }
- );
- } else if (numUrls === NUM_FILES_VOL_INT_ROI) {
- // read 4 files
- const urlHdrInt = arrUrls[0];
- const urlImgInt = arrUrls[1];
- const urlHdrRoi = arrUrls[2];
- const urlImgRoi = arrUrls[3];
-
- const loaderHdrInt = new LoadFilePromise();
- const loaderImgInt = new LoadFilePromise();
- const loaderHdrRoi = new LoadFilePromise();
- const loaderImgRoi = new LoadFilePromise();
-
- // this.m_volIntensity = new HdrVolume(this.m_needScaleDownTexture);
- // this.m_volRoi = new HdrVolume(this.m_needScaleDownTexture);
-
- const volRoi = new Volume();
- const volDst = volSet.getVolume(0);
-
- loaderHdrInt.readFromUrl(urlHdrInt).then(
- (arrBufHdr) => {
- // this.m_volIntensity.readBufferHead(arrBufHdr, callbackComplete, callbackProgress);
- // this.readBufferHead(arrBufHdr, callbackComplete, callbackProgress);
- this.readFromBufferHeader(volDst, arrBufHdr, callbackComplete, callbackProgress);
-
- console.log(`Load success HDR file: ${urlHdrInt}`);
- loaderImgInt.readFromUrl(urlImgInt).then((arrBufImg) => {
- // this.m_volIntensity.readBufferImg(arrBufImg, callbackComplete, callbackProgress);
- // this.readBufferImg(arrBufImg, callbackComplete, callbackProgress);
- this.readFromBufferImage(volDst, arrBufImg, callbackComplete, callbackProgress);
- console.log(`Load success IMG file: ${urlImgInt}`);
-
- loaderHdrRoi.readFromUrl(urlHdrRoi).then((arrBufferHdr) => {
- //this.m_volRoi.readBufferHead(arrBufferHdr, callbackComplete, callbackProgress);
- this.readFromBufferHeader(volRoi, arrBufferHdr, callbackComplete, callbackProgress);
-
- loaderImgRoi.readFromUrl(urlImgRoi).then((arrBufferImg) => {
- // this.m_volRoi.readBufferImg(arrBufferImg, callbackComplete, callbackProgress);
- this.readFromBufferImage(volRoi, arrBufferImg, callbackComplete, callbackProgress);
-
- // transform intensity data from 16 bpp -> 8 bpp
- this.createVolumeFromHeaderAndImage(volDst);
-
- // mix intensity + roi
- this.createRoiVolumeFromHeaderAndImage(volDst, volRoi);
-
- // invoke callback for good loading end
- callbackComplete(LoadResult.SUCCESS);
- }); // loaderImgRoi
- }); // loaderHdrRoi
- }); // loaderImgInt
- },
- (error) => {
- console.log('HDR File read error', error);
- return false;
- }
- ); // loaderHdrInt
- } else {
- console.log(`Error read hdr files. Should be ${NUM_URLS_IN_SET} files`);
- return false;
- } // if number of files equal to 2
- return true;
- } // end of readFromUrls
-} // end class LoaderHdr
+ }
+}
export default LoaderHdr;
diff --git a/src/engine/loaders/LoaderKtx.js b/src/engine/loaders/LoaderKtx.js
index a67bb7ca..4ecf3e82 100644
--- a/src/engine/loaders/LoaderKtx.js
+++ b/src/engine/loaders/LoaderKtx.js
@@ -14,7 +14,6 @@
// ********************************************************
import LoadResult from '../LoadResult';
-import FileLoader from './FileLoader';
// ********************************************************
// Const
@@ -341,28 +340,4 @@ export default class LoaderKtx {
}
return LoadResult.SUCCESS;
} // end readFromBuffer
-
- /**
- *
- * Read Ktx file from URL
- * @param {object} volDst volume to read
- * @param {string} strUrl from where
- * @param {Function} callbackProgress invoke during loading
- * @param {Function} callbackComplete invoke at the end with final success code
- */
- readFromUrl(volDst, strUrl, callbackProgress, callbackComplete) {
- console.log(`LoadedKtx. staring read ${strUrl}`);
- this.m_fileLoader = new FileLoader(strUrl);
- this.m_fileLoader.readFile(
- (arrBuf) => {
- this.readFromBuffer(volDst, arrBuf, callbackProgress, callbackComplete);
- return;
- },
- (errMsg) => {
- console.log(`LoaderKtx. Error read file: ${errMsg}`);
- callbackComplete(LoadResult.ERROR_CANT_OPEN_URL, null, 0, null);
- return;
- }
- );
- } // end of readFromUrl
} // end class
diff --git a/src/engine/loaders/LoaderNifti.js b/src/engine/loaders/LoaderNifti.js
index 11f5fb2e..61222af4 100644
--- a/src/engine/loaders/LoaderNifti.js
+++ b/src/engine/loaders/LoaderNifti.js
@@ -15,7 +15,6 @@
import LoadResult from '../LoadResult';
import HistogramUtils from '../../ui/Histogram/HistogramUtils';
-import FileLoader from './FileLoader';
// ********************************************************
// Const
@@ -660,30 +659,6 @@ class LoaderNifti {
return true;
} // end of readFromBuffer
-
- /**
- *
- * Read Nifti file from URL
- * @param {object} volDst volume to read
- * @param {string} strUrl from where
- * @param {Function} callbackProgress invoke during loading
- * @param {Function} callbackComplete invoke at the end with final success code
- */
- readFromUrl(volDst, strUrl, callbackProgress, callbackComplete) {
- console.log(`LoadedNifti. staring read ${strUrl}`);
- this.m_fileLoader = new FileLoader(strUrl);
- this.m_fileLoader.readFile(
- (arrBuf) => {
- const okRead = this.readFromBuffer(volDst, arrBuf, callbackProgress, callbackComplete);
- return okRead;
- },
- (errMsg) => {
- console.log(`LoadedNifti. Error read file: ${errMsg}`);
- callbackComplete(LoadResult.ERROR_CANT_OPEN_URL, null, 0, null);
- }
- );
- return true;
- } // end of readFromUrl
} // end class LoaderNifti
export default LoaderNifti;
diff --git a/src/engine/loaders/LoaderUrlDicom.js b/src/engine/loaders/LoaderUrlDicom.js
deleted file mode 100644
index ef9aa0eb..00000000
--- a/src/engine/loaders/LoaderUrlDicom.js
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright 2021 EPAM Systems, Inc. (https://www.epam.com/)
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import StoreActionType from '../../store/ActionTypes';
-import ViewMode from '../../store/ViewMode';
-import Modes3d from '../../store/Modes3d';
-
-const NEED_TEXTURE_SIZE_4X = true;
-
-class LoaderUrlDicom {
- constructor(store) {
- this.m_store = store;
- this.m_errors = [];
- this.m_loaders = [];
-
- this.callbackReadProgress = this.callbackReadProgress.bind(this);
- this.m_fileName = '???';
- }
-
- /**
- * Progress read callback
- *
- * @param ratio01
- */
- callbackReadProgress(ratio01) {
- const ratioPrc = Math.floor(ratio01);
- const store = this.m_store;
- if (ratioPrc >= 0.99) {
- // console.log(`callbackReadProgress. hide on = ${ratio01}`);
- store.dispatch({ type: StoreActionType.SET_PROGRESS, progress: 0 });
- } else {
- store.dispatch({ type: StoreActionType.SET_PROGRESS, progress: ratioPrc });
- }
- } // callback progress
-
- /**
- * On the end of success loading dicom folder
- *
- * @param {object} volume - destination volume
- * @param {string} fileNameIn - short file name for readed
- */
- finalizeSuccessLoadedVolume(volume, fileNameIn) {
- if (volume.m_dataArray !== null) {
- if (NEED_TEXTURE_SIZE_4X) {
- volume.makeDimensions4x();
- }
- // invoke notification
- const store = this.m_store;
- store.dispatch({ type: StoreActionType.SET_VOLUME_SET, volume });
- store.dispatch({ type: StoreActionType.SET_IS_LOADED, isLoaded: true });
- store.dispatch({ type: StoreActionType.SET_FILENAME, fileName: fileNameIn });
- store.dispatch({ type: StoreActionType.SET_ERR_ARRAY, arrErrors: [] });
- store.dispatch({ type: StoreActionType.SET_MODE_VIEW, viewMode: ViewMode.VIEW_2D });
- store.dispatch({ type: StoreActionType.SET_MODE_3D, mode3d: Modes3d.RAYCAST });
- }
- }
-} // end class LoaderUrlDicom
-
-export default LoaderUrlDicom;
diff --git a/src/index.js b/src/index.js
index 14389d05..82237b64 100644
--- a/src/index.js
+++ b/src/index.js
@@ -3,24 +3,17 @@
* SPDX-License-Identifier: Apache-2.0
*/
-import React from 'react';
+import 'regenerator-runtime/runtime';
import ReactDOM from 'react-dom';
-
import { Provider } from 'react-redux';
-
-import { createStore } from 'redux';
-
-import rootReducer from './store/Store';
-
import App from './App';
+import { store } from './store';
import './index.css';
import './nouislider-custom.css';
const rootElement = document.getElementById('root');
-const store = createStore(rootReducer);
-
ReactDOM.render(
diff --git a/src/react-app-env.d.ts b/src/react-app-env.d.ts
new file mode 100644
index 00000000..6431bc5f
--- /dev/null
+++ b/src/react-app-env.d.ts
@@ -0,0 +1 @@
+///
diff --git a/src/store/ActionTypes.js b/src/store/ActionTypes.js
index 6f61efa1..41b02599 100644
--- a/src/store/ActionTypes.js
+++ b/src/store/ActionTypes.js
@@ -46,5 +46,7 @@ const StoreActionType = {
SET_MODAL_ALERT: 34,
SET_SPINNER: 35,
SET_PROGRESS_INFO: 36,
+ SET_SPINNER_TITLE: 37,
+ SET_SPINNER_PROGRESS: 38,
};
export default StoreActionType;
diff --git a/src/store/Store.js b/src/store/Store.js
index 8f390ea3..040f051d 100644
--- a/src/store/Store.js
+++ b/src/store/Store.js
@@ -125,6 +125,10 @@ const medReducer = (state = initialState, action) => {
return Object.assign({}, state, { showModalAlert: action.showModalAlert });
case StoreActionType.SET_SPINNER:
return Object.assign({}, state, { spinner: action.spinner });
+ case StoreActionType.SET_SPINNER_TITLE:
+ return Object.assign({}, state, { spinnerTitle: action.spinnerTitle });
+ case StoreActionType.SET_SPINNER_PROGRESS:
+ return Object.assign({}, state, { spinnerProgress: action.spinnerProgress });
default:
return state;
}
diff --git a/src/store/index.js b/src/store/index.js
new file mode 100644
index 00000000..3f42cdc9
--- /dev/null
+++ b/src/store/index.js
@@ -0,0 +1,4 @@
+import { createStore } from 'redux';
+import rootReducer from './Store';
+
+export const store = createStore(rootReducer);
diff --git a/src/ui/Button/Button.module.css b/src/ui/Button/Button.module.css
index 910ddc33..1ff3473e 100644
--- a/src/ui/Button/Button.module.css
+++ b/src/ui/Button/Button.module.css
@@ -48,14 +48,11 @@ button:hover,
background-color: var(--red);
}
-
-
@media screen and (min-width: 768px) {
.reset {
display: flex;
justify-content: flex-end;
}
-
}
.reset {
display: inline-block;
@@ -66,8 +63,6 @@ button:hover,
padding: 0;
cursor: pointer;
transition: all 250ms ease-in-out, transform 150ms ease;
- -webkit-appearance: none;
- -moz-appearance: none;
}
.reset:focus {
@@ -108,7 +103,31 @@ button:hover,
}
.button:not(.reset) {
- display: block;
+ display: block;
+}
+.button:hover,
+.button:focus {
+ background-color: var(--light-orange);
+}
+
+.button.active {
+ color: var(--red);
+}
+
+.button.accent:hover,
+.button.accent:focus {
+ background-color: var(--red);
+ filter: brightness(85%);
+}
+
+.button.light.active {
+ color: var(--red);
+}
+
+.button.light:hover,
+.button.light:focus {
+ background-color: var(--light);
+ filter: brightness(80%);
}
@media screen and (min-width: 1024px) {
@@ -121,8 +140,6 @@ button:hover,
padding: 0;
cursor: pointer;
transition: all 250ms ease-in-out, transform 150ms ease;
- -webkit-appearance: none;
- -moz-appearance: none;
}
.reset:focus {
@@ -162,15 +179,6 @@ button:hover,
fill: var(--white);
}
- .button:hover,
- .button:focus {
- background-color: var(--light-orange);
- }
-
- .button.active {
- color: var(--red);
- }
-
.apply {
background-color: var(--red);
border-radius: 4px;
@@ -189,16 +197,6 @@ button:hover,
fill: var(--black);
}
- .button.light.active {
- color: var(--red);
- }
-
- .button.light:hover,
- .button.light:focus {
- background-color: var(--light);
- filter: brightness(80%);
- }
-
.button.accent {
color: var(--white);
background-color: var(--red);
@@ -208,13 +206,28 @@ button:hover,
fill: var(--white);
}
- .button.accent:hover,
- .button.accent:focus {
- background-color: var(--red);
- filter: brightness(85%);
- }
-
.button.accent.active svg {
fill: var(--black);
}
}
+
+.button_start_screen {
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ z-index: 10;
+ flex-basis: 33%;
+}
+
+.button_select_file {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+ z-index: 10;
+ width: 240px;
+ justify-content: center;
+}
+
+.button_select_file svg {
+ margin-right: 10px;
+}
diff --git a/src/ui/FileReaders/DragAndDrop.module.css b/src/ui/FileReaders/DragAndDrop.module.css
new file mode 100644
index 00000000..5c60c08d
--- /dev/null
+++ b/src/ui/FileReaders/DragAndDrop.module.css
@@ -0,0 +1,13 @@
+.dropzone {
+ position: absolute;
+ height: 100%;
+ width: 100%;
+ top: 0;
+ left: 0;
+ border-radius: 8px;
+}
+
+.dropzone_active {
+ border: 2px dashed var(--red);
+ z-index: 100;
+}
diff --git a/src/ui/FileReaders/DragAndDropComponent.jsx b/src/ui/FileReaders/DragAndDropComponent.jsx
new file mode 100644
index 00000000..32fed4e4
--- /dev/null
+++ b/src/ui/FileReaders/DragAndDropComponent.jsx
@@ -0,0 +1,40 @@
+import { useState } from 'react';
+import css from './DragAndDrop.module.css';
+import { SVG } from '../Button/SVG';
+import UiModalWindowCenterWidth from '../Modals/UiModalWinCW';
+import MriViwer from '../../engine/lib/MRIViewer';
+import { useOnEvent } from '../hooks/useOnEvent';
+import { MriEvents } from '../../engine/lib/enums';
+
+const IMG_DROPZONE_SIZE = 49;
+
+export const DragAndDropComponent = () => {
+ const [isActiveDnd, setIsActiveDnd] = useState(false);
+ const [showModalWindowCW, setShowModalWindowCW] = useState(false);
+
+ useOnEvent(MriEvents.FILE_READ_SUCCESS, () => {
+ setShowModalWindowCW(true);
+ });
+
+ const handleDrop = (e) => {
+ e.preventDefault();
+ setIsActiveDnd(false);
+
+ const files = e.dataTransfer.files;
+ MriViwer.read(files);
+ };
+
+ return (
+ <>
+
+