GGEMSVolumeCreatorManager.hh

Go to the documentation of this file.

#ifndef GUARD_GGEMS_GEOMETRIES_GGEMSVOLUMECREATORMANAGER_HH
#define GUARD_GGEMS_GEOMETRIES_GGEMSVOLUMECREATORMANAGER_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 <map>
 
#include "GGEMS/global/GGEMSOpenCLManager.hh"
 
typedef std::map<GGfloat, std::string> LabelToMaterialMap; 
class GGEMS_EXPORT GGEMSVolumeCreatorManager
{
  private:
    GGEMSVolumeCreatorManager(void);
 
    ~GGEMSVolumeCreatorManager(void);
 
  public:
    static GGEMSVolumeCreatorManager& GetInstance(void)
    {
      static GGEMSVolumeCreatorManager instance;
      return instance;
    }
 
    GGEMSVolumeCreatorManager(GGEMSVolumeCreatorManager const& volume_creator_manager) = delete;
 
    GGEMSVolumeCreatorManager& operator=(GGEMSVolumeCreatorManager const& volume_creator_manager) = delete;
 
    GGEMSVolumeCreatorManager(GGEMSVolumeCreatorManager const&& volume_creator_manager) = delete;
 
    GGEMSVolumeCreatorManager& operator=(GGEMSVolumeCreatorManager const&& volume_creator_manager) = delete;
 
    void SetElementSizes(GGfloat const& voxel_width, GGfloat const& voxel_height, GGfloat const& voxel_depth, std::string const& unit = "mm");
 
    inline GGfloat3 GetElementsSizes() const {return element_sizes_;}
 
    void SetVolumeDimensions(GGsize const& volume_width, GGsize const& volume_height, GGsize const& volume_depth);
 
    inline GGsize3 GetVolumeDimensions() const {return volume_dimensions_;};
 
    void SetMaterial(std::string const& material = "Air");
 
    inline GGsize GetNumberElements(void) const {return number_elements_;}
 
    inline std::string GetDataType(void) const {return data_type_;};
 
    inline cl::Buffer* GetVoxelizedVolume(void) const {return voxelized_volume_;}
 
    void SetOutputImageFilename(std::string const& output_image_filename);
 
    void SetRangeToMaterialDataFilename(std::string const& output_range_to_material_filename);
 
    void AddLabelAndMaterial(GGfloat const& label, std::string const& material);
 
    void SetDataType(std::string const& data_type = "MET_FLOAT");
 
    void Initialize(void);
 
    void Write(void);
 
    void Clean(void);
 
  private:
    void CheckParameters(void) const;
 
    void WriteMHDImage(void) const;
 
    void WriteRangeToMaterialFile(void);
 
    template <typename T>
    void AllocateImage(void);
 
  private:
    GGfloat3 element_sizes_; 
    GGsize3 volume_dimensions_; 
    GGsize number_elements_; 
    std::string data_type_; 
    std::string output_image_filename_; 
    std::string output_range_to_material_filename_; 
    cl::Buffer* voxelized_volume_; 
    LabelToMaterialMap label_to_material_; 
};
 
 
template <typename T>
void GGEMSVolumeCreatorManager::AllocateImage(void)
{
  // Get the OpenCL manager
  GGEMSOpenCLManager& opencl_manager = GGEMSOpenCLManager::GetInstance();
 
  // Allocation of memory on OpenCL device depending of type
  voxelized_volume_ = opencl_manager.Allocate(nullptr, number_elements_ * sizeof(T), 0, CL_MEM_READ_WRITE, "GGEMSVolumeCreatorManager");
 
  // Initialize the buffer to zero
  opencl_manager.CleanBuffer(voxelized_volume_, number_elements_ * sizeof(T), 0);
}
 
extern "C" GGEMS_EXPORT GGEMSVolumeCreatorManager* get_instance_volume_creator_manager(void);
 
extern "C" GGEMS_EXPORT void set_volume_dimension_volume_creator_manager(GGEMSVolumeCreatorManager* volume_creator_manager, GGsize const volume_width, GGsize const volume_height, GGsize const volume_depth);
 
extern "C" GGEMS_EXPORT void set_element_sizes_volume_creator_manager(GGEMSVolumeCreatorManager* volume_creator_manager, GGfloat const voxel_width, GGfloat const voxel_height, GGfloat const voxel_depth, char const* unit);
 
extern "C" GGEMS_EXPORT void set_output_image_filename_volume_creator_manager(GGEMSVolumeCreatorManager* volume_creator_manager,char const* output_image_filename);
 
extern "C" GGEMS_EXPORT void set_output_range_to_material_filename_volume_creator_manager(GGEMSVolumeCreatorManager* volume_creator_manager,char const* output_range_to_material_filename);
 
extern "C" GGEMS_EXPORT void initialize_volume_creator_manager(GGEMSVolumeCreatorManager* volume_creator_manager);
 
extern "C" GGEMS_EXPORT void write_volume_creator_manager(GGEMSVolumeCreatorManager* volume_creator_manager);
 
extern "C" GGEMS_EXPORT void set_material_volume_creator_manager(GGEMSVolumeCreatorManager* volume_creator_manager, char const* material);
 
extern "C" GGEMS_EXPORT void set_data_type_volume_creator_manager(GGEMSVolumeCreatorManager* volume_creator_manager, char const* data_type);
 
#endif // GUARD_GGEMS_GEOMETRIES_GGEMSVOLUMECREATORMANAGER_HH