DicomInstance.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 "fwGdcmIO/config.hpp"

#include <fwCore/macros.hpp>

#include <fwLog/Logger.hpp>

#include <gdcmMediaStorage.h>

#include <memory>

namespace fwMedData
{
class DicomSeries;
}

namespace fwMedData
{
class Series;
}

namespace fwGdcmIO
{
namespace container
{

class FWGDCMIO_CLASS_API DicomInstance
{
public:

    typedef  std::shared_ptr<DicomInstance> sptr;

    typedef std::vector< std::string > SOPInstanceUIDContainerType;

    FWGDCMIO_API DicomInstance();

    FWGDCMIO_API DicomInstance(const CSPTR(::fwMedData::Series)& series,
                               const SPTR(::fwLog::Logger)& logger = nullptr,
                               bool isMultiFiles                   = true);

    FWGDCMIO_API DicomInstance(const CSPTR(::fwMedData::DicomSeries)& dicomSeries,
                               const SPTR(::fwLog::Logger)& logger = nullptr);

    FWGDCMIO_API DicomInstance(const DicomInstance& dicomInstance);

    FWGDCMIO_API virtual ~DicomInstance();

    bool getIsMultiFiles() const
    {
        return m_isMultiFiles;
    }

    void setIsMultiFiles(bool isMultiFiles)
    {
        m_isMultiFiles = isMultiFiles;
    }

    const std::string& getSOPClassUID() const
    {
        return m_SOPClassUID;
    }

    void setSOPClassUID(const std::string& SOPClassUID)
    {
        m_SOPClassUID = SOPClassUID;
    }

    const std::string& getSeriesInstanceUID() const
    {
        return m_seriesInstanceUID;
    }

    void setSeriesInstanceUID(const std::string& seriesInstanceUID)
    {
        m_seriesInstanceUID = seriesInstanceUID;
    }

    const std::string& getStudyInstanceUID() const
    {
        return m_studyInstanceUID;
    }

    void setStudyInstanceUID(const std::string& studyInstanceUID)
    {
        m_studyInstanceUID = studyInstanceUID;
    }

    const std::string& getFrameOfReferenceUID() const
    {
        return m_frameOfReferenceUID;
    }

    void setFrameOfReferenceUID(const std::string& frameOfReferenceUID)
    {
        m_frameOfReferenceUID = frameOfReferenceUID;
    }

    const SOPInstanceUIDContainerType& getSOPInstanceUIDContainer() const
    {
        return m_SOPInstanceUIDContainer;
    }

    SOPInstanceUIDContainerType& getSOPInstanceUIDContainer()
    {
        return m_SOPInstanceUIDContainer;
    }

    void setSOPInstanceUIDContainer(const SOPInstanceUIDContainerType& SOPInstanceUIDContainer)
    {
        m_SOPInstanceUIDContainer = SOPInstanceUIDContainer;
    }

protected:
    void computeSOPClassUID(const CSPTR(::fwMedData::Series)& series);

    void generateSOPInstanceUIDs(const CSPTR(::fwMedData::Series)& series);

    void readUIDFromDicomSeries(const CSPTR(::fwMedData::DicomSeries)& dicomSeries);

private:

    bool m_isMultiFiles;

    std::string m_SOPClassUID;

    std::string m_studyInstanceUID;

    std::string m_seriesInstanceUID;

    std::string m_frameOfReferenceUID;

    SOPInstanceUIDContainerType m_SOPInstanceUIDContainer;

    SPTR(::fwLog::Logger) m_logger;
};

} //namespace container
} //namespace fwGdcmIO