GGEMSVoxelizedSolid.hh

Go to the documentation of this file.

#ifndef GUARD_GGEMS_GEOMETRIES_GGEMSVOXELIZEDSOLID_HH
#define GUARD_GGEMS_GEOMETRIES_GGEMSVOXELIZEDSOLID_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/>.      *
// *                                                                      *
// ************************************************************************
 
#include "GGEMS/geometries/GGEMSVoxelizedSolidData.hh"
#include "GGEMS/geometries/GGEMSSolid.hh"
 
class GGEMS_EXPORT GGEMSVoxelizedSolid : public GGEMSSolid
{
  public:
    GGEMSVoxelizedSolid(std::string const& volume_header_filename, std::string const& range_filename, std::string const& data_reg_type = "");
 
    ~GGEMSVoxelizedSolid(void);
 
    GGEMSVoxelizedSolid(GGEMSVoxelizedSolid const& voxelized_solid) = delete;
 
    GGEMSVoxelizedSolid& operator=(GGEMSVoxelizedSolid const& voxelized_solid) = delete;
 
    GGEMSVoxelizedSolid(GGEMSVoxelizedSolid const&& voxelized_solid) = delete;
 
    GGEMSVoxelizedSolid& operator=(GGEMSVoxelizedSolid const&& voxelized_solid) = delete;
 
    void Initialize(GGEMSMaterials* materials) override;
 
    void EnableScatter(void) override {;};
 
    void PrintInfos(void) const override;
 
    void LoadVolumeImage(GGEMSMaterials* materials);
 
    void UpdateTransformationMatrix(GGsize const& thread_index) override;
 
    GGfloat3 GetVoxelSizes(GGsize const& thread_index) const;
 
    GGEMSOBB GetOBBGeometry(GGsize const& thread_index) const;
 
  private:
    template <typename T>
    void ConvertImageToLabel(std::string const& raw_data_filename, std::string const& range_data_filename, GGEMSMaterials* materials);
 
    void InitializeKernel(void) override;
 
  private:
    std::string volume_header_filename_; 
    std::string range_filename_; 
};
 
 
template <typename T>
void GGEMSVoxelizedSolid::ConvertImageToLabel(std::string const& raw_data_filename, std::string const& range_data_filename, GGEMSMaterials* materials)
{
  GGcout("GGEMSVoxelizedSolid", "ConvertImageToLabel", 3) << "Converting image material data to label data..." << GGendl;
 
  // Get the OpenCL manager
  GGEMSOpenCLManager& opencl_manager = GGEMSOpenCLManager::GetInstance();
 
  for (GGsize d = 0; d < number_activated_devices_; ++d) {
    // Get pointer on OpenCL device
    GGEMSVoxelizedSolidData* solid_data_device = opencl_manager.GetDeviceBuffer<GGEMSVoxelizedSolidData>(solid_data_[d], sizeof(GGEMSVoxelizedSolidData), d);
 
    // Get information about mhd file
    GGsize number_of_voxels = static_cast<GGsize>(solid_data_device->number_of_voxels_);
 
    // Release the pointer
    opencl_manager.ReleaseDeviceBuffer(solid_data_[d], solid_data_device, d);
 
    // Checking if file exists
    std::ifstream in_raw_stream(raw_data_filename, std::ios::in | std::ios::binary);
    GGEMSFileStream::CheckInputStream(in_raw_stream, raw_data_filename);
 
    // Reading data to a tmp buffer
    std::vector<T> tmp_raw_data;
    tmp_raw_data.resize(number_of_voxels);
    in_raw_stream.read(reinterpret_cast<char*>(&tmp_raw_data[0]), static_cast<std::streamsize>(number_of_voxels * sizeof(T)));
 
    // Closing file
    in_raw_stream.close();
 
    // Allocating memory on OpenCL device
    label_data_[d] = opencl_manager.Allocate(nullptr, number_of_voxels * sizeof(GGuchar), d, CL_MEM_READ_WRITE, "GGEMSVoxelizedSolid");
 
    // Get pointer on OpenCL device
    GGuchar* label_data_device = opencl_manager.GetDeviceBuffer<GGuchar>(label_data_[d], number_of_voxels * sizeof(GGuchar), d);
 
    // Set value to max of GGuchar
    std::fill(label_data_device, label_data_device + number_of_voxels, std::numeric_limits<GGuchar>::max());
 
    // Opening range data file
    std::ifstream in_range_stream(range_data_filename, std::ios::in);
    GGEMSFileStream::CheckInputStream(in_range_stream, range_data_filename);
 
    // Values in the range file
    GGfloat first_label_value = 0.0f;
    GGfloat last_label_value = 0.0f;
    GGuchar label_index = 0;
    std::string material_name("");
 
    // Reading range file
    std::string line("");
    while (std::getline(in_range_stream, line)) {
      // Check if blank line
      if (GGEMSTextReader::IsBlankLine(line)) continue;
 
      // Getting the value in string stream
      std::istringstream iss = GGEMSRangeReader::ReadRangeMaterial(line);
      iss >> first_label_value >> last_label_value >> material_name;
 
      // Adding the material only once
      if (d == 0) materials->AddMaterial(material_name);
 
      // Setting the label
      for (GGsize i = 0; i < number_of_voxels; ++i) {
        // Getting the value of phantom
        GGfloat value = static_cast<GGfloat>(tmp_raw_data[i]);
        if (((value == first_label_value) && (value == last_label_value)) || ((value >= first_label_value) && (value < last_label_value))) {
          label_data_device[i] = label_index;
        }
      }
 
      // Increment the label index
      ++label_index;
    }
 
    // Final loop checking if a value is still max of GGuchar
    bool all_converted = true;
    for (GGsize i = 0; i < number_of_voxels; ++i) {
      if (label_data_device[i] == std::numeric_limits<GGuchar>::max()) all_converted = false;
    }
 
    // Closing file
    in_range_stream.close();
    tmp_raw_data.clear();
 
    // Release the pointer
    opencl_manager.ReleaseDeviceBuffer(label_data_[d], label_data_device, d);
 
    // Checking if all voxels converted
    if (all_converted) {
      GGcout("GGEMSVoxelizedSolid", "ConvertImageToLabel", 2) << "All your voxels are converted to label..." << GGendl;
    }
    else {
      GGEMSMisc::ThrowException("GGEMSVoxelizedSolid", "ConvertImageToLabel", "Errors(s) in the range data file!!!");
    }
  }
}
 
#endif // End of GUARD_GGEMS_GEOMETRIES_GGEMSVOXELIZEDSOLID_HH