SVOReader.ih

/**
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as
 *  published by the Free Software Foundation, either version 3 of the
 *  License, or  (at your option) any later version.
 *
 *  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 **/
 
#pragma once
 
/**
 * @file SVOReader.ih
 * @author Bastien Doignies (bastien.doignies@liris.cnrs.fr)
 * Laboratoire d'InfoRmatique en Image et Systèmes d'information - LIRIS (CNRS, UMR 5205), CNRS, France
 *
 * @date 2025/10/20
 *
 * This file is part of the DGtal library.
 */
 
#include <boost/iostreams/filtering_stream.hpp>
 
namespace DGtal 
{
  template<typename T> 
  inline static T getAs(const std::map<std::string, std::string>& fields, const std::string& key) 
  {
    T result;
 
    auto it = fields.find(key);
    if (it == fields.end()) 
    {
      trace.error() << "SVOReader: No such field \"" << key << "\"" << std::endl;
      throw IOException{};
    }
 
    if constexpr (std::is_same_v<T, std::string>) 
    {
      return it->second;
    }
    else
    {
      std::istringstream iss(it->second);
      iss >> result;
 
      if (iss.fail()) 
      {
        trace.error() << "SVOReader: Can't convert \"" << key << "\" to desired type." << std::endl; 
        throw IOException{};
      }
 
    }
    return result;
  }
 
  template <typename T>
  inline std::vector<T> getMultipleAs(const std::map<std::string, std::string>& fields, unsigned int count, const std::string& key) 
  {
    std::vector<T> result;
 
    auto it = fields.find(key);
    if (it == fields.end()) 
    {
      trace.error() << "SVOReader: No such field \"" << key << "\"" << std::endl;
      throw IOException{};
    }
 
    if constexpr (std::is_same_v<T, std::string>) 
    {
      return it->second;
    } 
    else
    {
      std::istringstream iss(it->second);
      for (unsigned int i = 0; i < count; ++i) 
      {
        T tmp; iss >> tmp;
        result.push_back(tmp);
      }
 
      if (!iss.fail() && !iss.eof()) 
      {
        trace.error() << "SVOReader: Can't convert \"" << key << "\" to desired type." << std::endl; 
        throw IOException{};
      }
    }
    return result;
  }
 
  template<typename Int, typename Stream>
  Int readBinInt(Stream& stream, unsigned int count) 
  {
    std::uint64_t value = 0;
    char byte;
    for (size_t i = 0; i < count; ++i) 
    {
      if (!stream.get(byte)) throw IOException{};
      value |= static_cast<std::uint64_t>(byte) << (8 * i);
    }
    boost::endian::little_to_native_inplace(value);
    return static_cast<Int>(value);
  }
 
  template <class Space>
  DigitalSetByOctree<Space> SVOReader<Space>::importSVO(const std::string& filename) 
  {
    std::ifstream file(filename.c_str(), std::ios::binary);
    if (!file) 
    {
      trace.warning() << "SVOReader: can't open file '" << filename << "'" << std::endl;
      throw IOException{};
    }
    
    std::string line;
    std::map<std::string, std::string> header;
    while (std::getline(file, line)) 
    {
      if (!line.empty() && line.back() == '.') break;
 
      auto split = line.find(":");
      if (split == std::string::npos) 
      {
        trace.warning() << "SVOReader: unrecognized line \"" << line << "\"" << std::endl;
        continue;
      }
 
      std::string key = line.substr(0, split);
      std::string val = line.substr(split + 1);
 
      // Trim value
      auto start = val.find_first_not_of(" \t\r\n");
      auto end = val.find_last_not_of(" \t\r\n");
      if (start == std::string::npos) 
      {
        trace.error() << "SVOReader: invalid value for line \"" << line << "\"" << std::endl;
        throw DGtal::IOException{};
      }
      
      header[key] = val.substr(start, end - start + 1);
    }
    
    const std::string format   = getAs<std::string>(header, "Format");
    // const std::int32_t version  = getAs<std::int32_t>(header, "Version");
    const std::int32_t compress = getAs<std::int32_t>(header, "Compression");
    const std::int32_t dim      = getAs<std::int32_t>(header, "Dim");
    const std::int32_t state    = getAs<std::int32_t>(header, "State");
    const std::uint64_t size   = getAs<std::uint64_t>(header, "Size");
    
    if (dim != Space::dimension) 
    {
      trace.error() << "SVOReader: Dimension mismatch, space is " << Space::dimension << "d and Octree is " << dim << "d" << std::endl;
      throw IOException{};
    }
    
    const auto lbdata = getMultipleAs<std::int64_t>(header, dim, "LowerBound");
    const auto ubdata = getMultipleAs<std::int64_t>(header, dim, "UpperBound");
    
    typename Space::Point lb, ub;
    for (unsigned int i = 0; i < dim; ++i) 
    {
      lb[i] = lbdata[i];
      ub[i] = ubdata[i];
    }
 
    Octree octree(typename Octree::Domain(lb, ub));
    octree.mySize = size;
    octree.myState = static_cast<typename Octree::State>(state);
    
    boost::iostreams::filtering_istream main;
    if (compress) main.push(boost::iostreams::zlib_decompressor());
    main.push(file);
 
    const int64_t sizesize = readBinInt<int64_t>(main, sizeof(int64_t));
    const int64_t cellsize = readBinInt<int64_t>(main, sizeof(int64_t));
 
    using CellI = typename Octree::CellIndex;
    using Size = typename Octree::Size;
 
    if (sizesize > sizeof(Size)) 
      trace.warning() << "SVOReader: integer size mismatch, this may cause unwanted truncation" << std::endl;
 
    if (cellsize > sizeof(CellI))
      trace.warning() << "SVOReader: integer size mismatch, this may cause unwanted truncation" << std::endl;
    
 
    octree.myNodes.resize(readBinInt<Size>(main, sizesize));
    for (size_t i = 0; i < octree.myNodes.size(); ++i) 
      octree.myNodes[i].resize(readBinInt<Size>(main, sizesize));
    
    try 
    {
      for (size_t i = 0; i < octree.myNodes.size(); ++i) 
        for (size_t j = 0; j < octree.myNodes[i].size(); ++j) 
          for (unsigned int k = 0; k < Octree::CELL_COUNT; ++k) 
            octree.myNodes[i][j].children[k] = readBinInt<CellI>(main, cellsize);
    } 
    catch(...) 
    {
      trace.error() << "SVOReader: Unexpected EOF while reading data." << std::endl;
      throw;
    }
 
    return octree;
  }
}