MRDicom.h

Go to the documentation of this file.

#pragma once
 
#include "MRVoxelsFwd.h"
#ifndef MRVOXELS_NO_DICOM
#include "MRVoxelsVolume.h"
 
#include "MRMesh/MRAffineXf.h"
#include "MRMesh/MRMatrix3.h"
#include "MRMesh/MRLoadedObjects.h"
 
#include <filesystem>
#include <optional>
 
namespace MR
{
 
namespace VoxelsLoad
{
 
 
enum class DicomStatusEnum : int
{
    Ok = 0,         // valid DICOM and we can open it
    Invalid,        // not a valid DICOM
    Unsupported,    // a valid DICOM, but we do not support it (e.g. some MediaStorages)
};
 
struct DicomStatus
{
    // implicit by design
    DicomStatus( DicomStatusEnum st, std::string_view rs = "" ):
        status( st ),
        reason( rs )
    {}
 
    explicit operator bool() const
    { return status == DicomStatusEnum::Ok; }
 
    bool operator==( DicomStatusEnum s ) const
    { return status == s; }
 
    DicomStatusEnum status = DicomStatusEnum::Invalid;
    std::string reason;     // if status is Unsupported, specify reason why
};
 
MRVOXELS_API DicomStatus isDicomFile( const std::filesystem::path& path, std::string* seriesUid = nullptr );
 
MRVOXELS_API bool isDicomFolder( const std::filesystem::path& dirPath );
 
MRVOXELS_API std::vector<std::filesystem::path> findDicomFoldersRecursively( const std::filesystem::path& path );
 
template <typename T>
struct DicomVolumeT
{
    T vol;
    std::string name;
    AffineXf3f xf;
};
 
MRVOXELS_API Expected<DicomVolume> loadDicomFile( const std::filesystem::path& file, const ProgressCallback& cb = {} );
 
MRVOXELS_API Expected<DicomVolumeAsVdb> loadDicomFileAsVdb( const std::filesystem::path& file, const ProgressCallback& cb = {} );
 
MRVOXELS_API Expected<DicomVolume> loadDicomFolder( const std::filesystem::path& path, unsigned maxNumThreads, const ProgressCallback& cb = {} );
 
MRVOXELS_API Expected<DicomVolumeAsVdb> loadDicomFolderAsVdb( const std::filesystem::path& path, unsigned maxNumThreads, const ProgressCallback& cb = {} );
 
MRVOXELS_API std::vector<Expected<DicomVolume>> loadDicomsFolder( const std::filesystem::path& path, unsigned maxNumThreads, const ProgressCallback& cb = {} );
 
MRVOXELS_API std::vector<Expected<DicomVolumeAsVdb>> loadDicomsFolderAsVdb( const std::filesystem::path& path, unsigned maxNumThreads, const ProgressCallback& cb = {} );
 
MRVOXELS_API std::vector<Expected<DicomVolumeAsVdb>> loadDicomsFolderTreeAsVdb( const std::filesystem::path& path,
                                                                     unsigned maxNumThreads = 4, const ProgressCallback& cb = {} );
 
MRVOXELS_API Expected<std::shared_ptr<ObjectVoxels>> createObjectVoxels( const DicomVolumeAsVdb & dcm, const ProgressCallback & cb = {} );
 
MRVOXELS_API Expected<LoadedObjects> makeObjectVoxelsFromDicomFolder( const std::filesystem::path& folder, const ProgressCallback& callback = {} );
 
} // namespace VoxelsLoad
 
namespace VoxelsSave
{
 
MRVOXELS_API Expected<void> toDicom( const VdbVolume& vdbVolume, const std::filesystem::path& path, ProgressCallback cb = {} );
template <typename T>
MRVOXELS_API Expected<void> toDicom( const VoxelsVolume<std::vector<T>>& volume, const std::filesystem::path& path, const std::optional<MinMaxf>& sourceScale = {}, const ProgressCallback& cb = {} );
 
extern template MRVOXELS_API Expected<void> toDicom( const VoxelsVolume<std::vector<std::uint16_t>>& volume, const std::filesystem::path& path, const std::optional<MinMaxf>& sourceScale, const ProgressCallback& cb );
 
} // namespace VoxelsSave
 
} // namespace MR
#endif