fwDcmtkIO/include/fwDcmtkIO/SeriesDBReader.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2018.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#pragma once

#include "fwDcmtkIO/config.hpp"
#include "fwDcmtkIO/reader/IObjectReader.hpp"

#include <fwData/location/Folder.hpp>
#include <fwData/location/MultiFiles.hpp>

#include <fwDataIO/reader/GenericObjectReader.hpp>

#include <fwServices/IService.hpp>

#include <fwTools/ProgressAdviser.hpp>

namespace fwMedData
{
class SeriesDB;
class Patient;
class Study;
class Equipment;
class Series;
}

class DcmDataset;

namespace fwDcmtkIO
{

class FWDCMTKIO_CLASS_API SeriesDBReader : public ::fwDataIO::reader::GenericObjectReader< ::fwMedData::SeriesDB >,
                                           public ::fwData::location::enableFolder< ::fwDataIO::reader::IObjectReader >,
                                           public ::fwData::location::enableMultiFiles< ::fwDataIO::reader::
                                                                                        IObjectReader >,
                                           public ::fwTools::ProgressAdviser
{

public:

    fwCoreClassDefinitionsWithFactoryMacro(
        (SeriesDBReader)( ::fwDataIO::reader::GenericObjectReader< ::fwMedData::SeriesDB >),
        (()),
        ::fwDataIO::reader::factory::New< SeriesDBReader >
        );
    fwCoreAllowSharedFromThis();

    typedef std::map< std::string, SPTR(::fwMedData::Patient) > PatientMapType;
    typedef std::map< std::string, SPTR(::fwMedData::Study) > StudyMapType;
    typedef std::map< std::string, SPTR(::fwMedData::Equipment) > EquipmentMapType;
    typedef std::vector< SPTR(::fwMedData::DicomSeries) > DicomSeriesContainerType;
    typedef std::vector< std::string > FilenameContainerType;
    typedef std::vector< std::string > SupportedSOPClassContainerType;

    FWDCMTKIO_API SeriesDBReader(::fwDataIO::reader::IObjectReader::Key key);

    FWDCMTKIO_API ~SeriesDBReader();

    FWDCMTKIO_API void read() override;

    FWDCMTKIO_API void readFromDicomSeriesDB(CSPTR(::fwMedData::SeriesDB) dicomSeriesDB,
                                             ::fwServices::IService::sptr notifier = ::fwServices::IService::sptr());

    FWDCMTKIO_API void readDicomSeries();

    FWDCMTKIO_API bool isDicomDirAvailable();

    FWDCMTKIO_API DicomSeriesContainerType& getDicomSeries();

    const bool& getDicomdirActivated() const
    {
        return m_isDicomdirActivated;
    }

    void setDicomdirActivated(const bool& isDicomdirActivated)
    {
        m_isDicomdirActivated = isDicomdirActivated;
    }

    const std::string& getDicomFilterType() const
    {
        return m_dicomFilterType;
    }

    void setDicomFilterType(const std::string& dicomFilterType)
    {
        m_dicomFilterType = dicomFilterType;
    }

    const SupportedSOPClassContainerType& getSupportedSOPClassContainer() const
    {
        return m_supportedSOPClassContainer;
    }

    void setSupportedSOPClassContainer(const SupportedSOPClassContainerType& supportedSOPClassContainer)
    {
        m_supportedSOPClassContainer = supportedSOPClassContainer;
    }

private:

    FilenameContainerType getFilenames();

    void addSeries(const std::vector< std::string >& filenames);

    SPTR(::fwMedData::Patient) createPatient(DcmDataset* dataset);

    SPTR(::fwMedData::Study) createStudy(DcmDataset* dataset);

    SPTR(::fwMedData::Equipment) createEquipment(DcmDataset* dataset);

    void createSeries(DcmDataset* dataset, const std::string& filename);

    void convertDicomSeries(CSPTR(::fwMedData::DicomSeries) dicomSeries,
                            ::fwServices::IService::sptr notifier = ::fwServices::IService::sptr());

    PatientMapType m_patientMap;

    StudyMapType m_studyMap;

    EquipmentMapType m_equipmentMap;

    DicomSeriesContainerType m_dicomSeriesContainer;

    bool m_isDicomdirActivated;

    std::string m_dicomFilterType;

    SupportedSOPClassContainerType m_supportedSOPClassContainer;

};

} // namespace fwDcmtkIO