GGEMSMHDImage.hh

Go to the documentation of this file.

#ifndef GUARD_GGEMS_IO_GGEMSMHDIMAGE_HH
#define GUARD_GGEMS_IO_GGEMSMHDIMAGE_HH
 
// ************************************************************************
// * This file is part of GGEMS.                                          *
// *                                                                      *
// * GGEMS is free software: you can redistribute it and/or modify        *
// * it under the terms of the GNU General Public License as published by *
// * the Free Software Foundation, either version 3 of the License, or    *
// * (at your option) any later version.                                  *
// *                                                                      *
// * GGEMS is distributed in the hope that it will be useful,             *
// * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
// * GNU General Public License for more details.                         *
// *                                                                      *
// * You should have received a copy of the GNU General Public License    *
// * along with GGEMS.  If not, see <https://www.gnu.org/licenses/>.      *
// *                                                                      *
// ************************************************************************
 
#ifdef _MSC_VER
#pragma warning(disable: 4251) // Deleting warning exporting STL members!!!
#endif
 
#include <fstream>
 
#include "GGEMS/global/GGEMSOpenCLManager.hh"
 
class GGEMS_EXPORT GGEMSMHDImage
{
  public:
    GGEMSMHDImage(void);
 
    ~GGEMSMHDImage(void);
 
  public:
    GGEMSMHDImage(GGEMSMHDImage const& mhd) = delete;
 
    GGEMSMHDImage& operator=(GGEMSMHDImage const& mhd) = delete;
 
    GGEMSMHDImage(GGEMSMHDImage const&& mhd) = delete;
 
    GGEMSMHDImage& operator=(GGEMSMHDImage const&& mhd) = delete;
 
    void SetOutputFileName(std::string const& basename);
 
    void Read(std::string const& image_mhd_header_filename, cl::Buffer* solid_data, GGsize const& thread_index);
 
    void Write(cl::Buffer* image, GGsize const& thread_index) const;
 
    template<typename T>
    void Write(T* image);
 
    void SetElementSizes(GGfloat3 const& element_sizes);
 
    void SetDimensions(GGsize3 const& dimensions);
 
    void SetDataType(std::string const& data_type);
 
    inline std::string GetDataMHDType(void) const {return mhd_data_type_;};
 
    inline std::string GetRawMDHfilename(void) const {return mhd_raw_file_;};
 
    inline std::string GetOutputDirectory(void) const {return output_dir_;};
 
  private:
    void CheckParameters(void) const;
 
    template <typename T>
    void WriteRaw(cl::Buffer* image, GGsize const& thread_index) const;
 
  private:
    std::string mhd_header_file_; 
    std::string mhd_raw_file_; 
    std::string output_dir_; 
    std::string mhd_data_type_; 
    GGfloat3 element_sizes_; 
    GGsize3 dimensions_; 
};
 
 
template <typename T>
void GGEMSMHDImage::Write(T* image)
{
  GGcout("GGEMSMHDImage", "Write", 1) << "Writing MHD Image " <<  mhd_header_file_ << "..." << GGendl;
 
  // Checking parameters before to write
  CheckParameters();
 
  // header data
  std::ofstream out_header_stream(mhd_header_file_, std::ios::out);
  out_header_stream << "ObjectType = Image" << std::endl;
  out_header_stream << "BinaryDataByteOrderMSB = False" << std::endl;
  out_header_stream << "NDims = 3" << std::endl;
  out_header_stream << "ElementSpacing = " << element_sizes_.x << " " << element_sizes_.y << " " << element_sizes_.z << std::endl;
  out_header_stream << "DimSize = " << dimensions_.x_ << " " << dimensions_.y_ << " " << dimensions_.z_ << std::endl;
  out_header_stream << "ElementType = " << mhd_data_type_ << std::endl;
  out_header_stream << "ElementDataFile = " << mhd_raw_file_ << std::endl;
  out_header_stream.close();
 
  // raw data
  std::ofstream out_raw_stream(output_dir_+mhd_raw_file_, std::ios::out | std::ios::binary);
 
  // Writing data on file
  out_raw_stream.write(reinterpret_cast<char*>(image), static_cast<std::streamsize>(dimensions_.x_ * dimensions_.y_* dimensions_.z_ * sizeof(T)));
 
  out_raw_stream.close();
}
 
 
template <typename T>
void GGEMSMHDImage::WriteRaw(cl::Buffer* image, GGsize const& thread_index) const
{
  // Get the OpenCL manager
  GGEMSOpenCLManager& opencl_manager = GGEMSOpenCLManager::GetInstance();
 
  // raw data
  std::ofstream out_raw_stream(output_dir_+mhd_raw_file_, std::ios::out | std::ios::binary);
 
  // Mapping data
  T* data_image_device = opencl_manager.GetDeviceBuffer<T>(image, dimensions_.x_ * dimensions_.y_ * dimensions_.z_ * sizeof(T), thread_index);
 
  // Writing data on file
  out_raw_stream.write(reinterpret_cast<char*>(data_image_device), static_cast<std::streamsize>(dimensions_.x_ * dimensions_.y_* dimensions_.z_ * sizeof(T)));
 
  // Release the pointers
  opencl_manager.ReleaseDeviceBuffer(image, data_image_device, thread_index);
  out_raw_stream.close();
}
 
#endif // End of GUARD_GGEMS_IO_GGEMSMHDIMAGE_HH