DICOMLoader.cs

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.InteropServices;
using itk.simple;

public class DICOMLoader : MonoBehaviour {

    public static DICOMLoader instance { private set; get; }

    public DICOM2D currentDICOM { private set; get; }
    public DICOM3D currentDICOMVolume { private set; get; }
    public DICOMSeries currentDICOMSeries { private set; get; }

    public bool isBusy { private set; get; }

    private string directoryToLoad;

    private DICOMSeries seriesToLoad;
    private int sliceToLoad;

    private DICOM newlyLoadedDICOM;

    private string currentDirectory;

    public List<DICOMSeries> availableSeries { private set; get; }

    private bool newDirectoryParsed = false;
    private bool newDICOMLoaded = false;

    public DICOMLoader()
    {
        if (instance != null)
            throw( new System.Exception( "Error: Only one Instance of DICOMLoader may exist!" ) );

        availableSeries = new List<DICOMSeries>();

        instance = this;
        isBusy = false;
    }

    // ===============================================================
    // Directory parsing:

    public bool setDirectory( string path )
    {
        if (!isBusy) {

            // Lock:
            isBusy = true;

            directoryToLoad = path;
            ThreadUtil t = new ThreadUtil (parseDirectory, parseDirectoryCallback);
            t.Run ();

            // Let event system know what we're currently doing:
            PatientEventSystem.triggerEvent (PatientEventSystem.Event.LOADING_AddLoadingJob,
                "DICOM directory parsing");
            
            return true;
        } else {
            return false;
        }
    }

    public void parseDirectory(object sender, DoWorkEventArgs e)
    {
        // Parse the directory and return the seriesUIDs of all the DICOM series:
        try {
            availableSeries.Clear();

            Debug.Log("[DICOM] Searching directory: " + directoryToLoad ); 
            VectorString series = ImageSeriesReader.GetGDCMSeriesIDs (directoryToLoad);
            if (series.Count > 0) {

                foreach (string s in series) {
                    DICOMSeries info = new DICOMSeries ( directoryToLoad, s );
                    availableSeries.Add(info);
                }
            }

            // Debug log:
            string str = "[DICOM] Found " + series.Count + " series.";
            Debug.Log( str );

        } catch( System.Exception err ) {
            Debug.LogError( err.Message );
        }
    }

    public void parseDirectoryCallback(object sender, RunWorkerCompletedEventArgs e)
    {
        // Unlock:
        isBusy = false;
        newDirectoryParsed = true;
    }

    // ===============================================================
    // DICOM Loading:

    public bool startLoading (DICOMSeries toLoad, int slice = 0 )
    {
        if (!isBusy && toLoad != null) {

            // Lock:
            isBusy = true;

            seriesToLoad = toLoad;
            sliceToLoad = slice;
            ThreadUtil t = new ThreadUtil (load, loadCallback);
            t.Run ();

            // Let event system know what we're currently doing:
            PatientEventSystem.triggerEvent (PatientEventSystem.Event.LOADING_AddLoadingJob,
                "Loading DICOM series " + toLoad.seriesUID);

            if( slice >= 0 )
                PatientEventSystem.triggerEvent (PatientEventSystem.Event.DICOM_StartLoadingSlice);
            else
                PatientEventSystem.triggerEvent (PatientEventSystem.Event.DICOM_StartLoadingVolume);

            return true;
        } else {
            return false;
        }
    }
    public bool startLoadingSlice ( int index, int slice = 0 )
    {
        if (index >= 0 && index < availableSeries.Count) {
            return startLoading (availableSeries [index], slice);
        } else {
            return false;
        }
    }
    public bool startLoadingSlice ( string seriesUID, int slice = 0 )
    {
        foreach (DICOMSeries i in availableSeries) {
            if (i.seriesUID == seriesUID) {
                return startLoading (i, slice);
            }
        }
        return false;
    }

    public bool startLoadingVolume( DICOMSeries toLoad )
    {
        return startLoading (toLoad, -1);
    }

    public bool startLoadingVolume ( int index )
    {
        if (index >= 0 && index < availableSeries.Count) {
            return startLoading (availableSeries [index], -1);
        } else {
            return false;
        }
    }
    public bool startLoadingVolume ( string seriesUID )
    {
        foreach (DICOMSeries i in availableSeries) {
            if (i.seriesUID == seriesUID) {
                return startLoading (i, -1);
            }
        }
        return false;
    }



    public void load(object sender, DoWorkEventArgs e)
    {
        try {
            Debug.Log("[DICOM] Loading: " + seriesToLoad.seriesUID + " " + sliceToLoad );
            if( sliceToLoad >= 0 )
                newlyLoadedDICOM = new DICOM2D( seriesToLoad, sliceToLoad );
            else
                newlyLoadedDICOM = new DICOM3D( seriesToLoad );
            currentDICOMSeries = seriesToLoad;
        } catch( System.Exception err ) {
            Debug.LogError( "[DICOM] " + err.Message );
            newlyLoadedDICOM = null;
        }
    }
    public void loadCallback(object sender, RunWorkerCompletedEventArgs e)
    {
        // Unlock:
        isBusy = false;
        newDICOMLoaded = true;
        Debug.Log ("[DICOM] Loading done. " + currentDICOMSeries.seriesUID);
    }


    // ===============================================================
    // Update loop:
    public void Update()
    {
        if (newDirectoryParsed) {
            PatientEventSystem.triggerEvent(PatientEventSystem.Event.DICOM_NewList);
            newDirectoryParsed = false;

            // Let loading screen know what we're currently doing:
            PatientEventSystem.triggerEvent (PatientEventSystem.Event.LOADING_RemoveLoadingJob,
                "DICOM directory parsing");
        }
        if (newDICOMLoaded) {
            newDICOMLoaded = false;
            if (newlyLoadedDICOM != null) {
                if (newlyLoadedDICOM.dimensions == 2) {
                    currentDICOM = newlyLoadedDICOM as DICOM2D;
                    // Let Listeners know that we've loaded a new DICOM:
                    PatientEventSystem.triggerEvent (PatientEventSystem.Event.DICOM_NewLoadedSlice, currentDICOM);
                } else {
                    currentDICOMVolume = newlyLoadedDICOM as DICOM3D;
                    // Let Listeners know that we've loaded a new DICOM:
                    PatientEventSystem.triggerEvent (PatientEventSystem.Event.DICOM_NewLoadedVolume, currentDICOMVolume);
                }
            }
        }
    }

    public void unloadVolume()
    {
        PatientEventSystem.triggerEvent (PatientEventSystem.Event.DICOM_CloseVolume);
        currentDICOMVolume = null;
    }

}