vpIoTools.cpp

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2023 by Inria. All rights reserved.
 *
 * This software 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 2 of the License, or
 * (at your option) any later version.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See https://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Directory management.
 */
 
// At this point, to make scandir() working as expected on armv7 virtualized on a x86-64bit architecture
// (see github/workflow/other-arch-isolated.yml) we need to define _FILE_OFFSET_BITS=64. Otherwise
// testVideo.cpp will fail.
// Since adding here something like:
//   #include <visp3/core/vpConfig.h>
//   #ifdef VISP_DEFINE_FILE_OFFSET_BITS
//   # define _FILE_OFFSET_BITS 64
//   #endif
// where VISP_DEFINE_FILE_OFFSET_BITS is defined in vpConfig.h doesn't work (my explanation is that the define
// should be done before any other includes; in vpConfig.h there is cstdlib that is included), the other way
// that was retained is to add to vpIoTools.cpp COMPILE_DEFINTIONS _FILE_OFFSET_BITS=64 (see CMakeLists.txt)
 
#include <algorithm>
#include <cctype>
#include <cmath>
#include <errno.h>
#include <fcntl.h>
#include <fstream>
#include <functional>
#include <limits>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <visp3/core/vpDebug.h>
#include <visp3/core/vpEndian.h>
#include <visp3/core/vpIoException.h>
#include <visp3/core/vpIoTools.h>
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
#include <dirent.h>
#include <unistd.h>
#elif defined(_WIN32)
#include <direct.h>
#include <windows.h>
#endif
#if !defined(_WIN32)
#ifdef __ANDROID__
// Like IOS, wordexp.cpp is not defined for Android
#else
#include <wordexp.h>
#endif
#endif
 
#if defined(__APPLE__) && defined(__MACH__) // Apple OSX and iOS (Darwin)
#include <TargetConditionals.h>             // To detect OSX or IOS using TARGET_OS_IOS macro
#endif
 
#ifndef PATH_MAX
#ifdef _MAX_PATH
#define PATH_MAX _MAX_PATH
#else
#define PATH_MAX 1024
#endif
#endif
 
 
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
#define VP_STAT stat
#elif defined(_WIN32) && defined(__MINGW32__)
#define VP_STAT stat
#elif defined(_WIN32)
#define VP_STAT _stat
#else
#define VP_STAT stat
#endif
 
#if VISP_CXX_STANDARD > VISP_CXX_STANDARD_98
#define USE_ZLIB_API 0
 
#if !USE_ZLIB_API
// See: https://github.com/BinomialLLC/basis_universal/blob/master/encoder/basisu_miniz.h
// Apache License, Version 2.0
#include "basisu_miniz.h"
 
using namespace buminiz;
#else
#include <zlib.h>
#endif
 
// To avoid warnings such as: warning: unused variable ‘littleEndian’ [-Wunused-variable]
#define UNUSED(x) ((void)(x)) // see: https://stackoverflow.com/a/777359
 
// Copyright (C) 2011  Carl Rogers
// Released under MIT License
// license available in LICENSE file, or at http://www.opensource.org/licenses/mit-license.php
 
#include <regex>
 
char visp::cnpy::BigEndianTest()
{
  int x = 1;
  return (((reinterpret_cast<char *>(&x))[0]) ? '<' : '>');
}
 
char visp::cnpy::map_type(const std::type_info &t)
{
  if (t == typeid(float)) { return 'f'; }
  if (t == typeid(double)) { return 'f'; }
  if (t == typeid(long double)) { return 'f'; }
 
  if (t == typeid(int)) { return 'i'; }
  if (t == typeid(char)) { return 'i'; }
  if (t == typeid(short)) { return 'i'; }
  if (t == typeid(long)) { return 'i'; }
  if (t == typeid(long long)) { return 'i'; }
 
  if (t == typeid(unsigned char)) { return 'u'; }
  if (t == typeid(unsigned short)) { return 'u'; }
  if (t == typeid(unsigned long)) { return 'u'; }
  if (t == typeid(unsigned long long)) { return 'u'; }
  if (t == typeid(unsigned int)) { return 'u'; }
 
  if (t == typeid(bool)) { return 'b'; }
 
  if (t == typeid(std::complex<float>)) { return 'c'; }
  if (t == typeid(std::complex<double>)) { return 'c'; }
  if (t == typeid(std::complex<long double>)) { return 'c'; }
 
  else { return '?'; }
}
 
void visp::cnpy::parse_npy_header(unsigned char *buffer, size_t &word_size, std::vector<size_t> &shape, bool &fortran_order)
{
  uint16_t header_len = *reinterpret_cast<uint16_t *>(buffer+8);
  std::string header(reinterpret_cast<char *>(buffer+9), header_len);
 
  //fortran order
  size_t loc1 = header.find("fortran_order")+16;
  fortran_order = (header.substr(loc1, 4) == "True" ? true : false);
 
  //shape
  loc1 = header.find("(");
  size_t loc2 = header.find(")");
 
  std::regex num_regex("[0-9][0-9]*");
  std::smatch sm;
  shape.clear();
 
  std::string str_shape = header.substr(loc1+1, loc2-loc1-1);
  while (std::regex_search(str_shape, sm, num_regex)) {
    shape.push_back(std::stoi(sm[0].str()));
    str_shape = sm.suffix().str();
  }
 
  //endian, word size, data type
  //byte order code | stands for not applicable.
  //not sure when this applies except for byte array
  loc1 = header.find("descr")+9;
  bool littleEndian = (((header[loc1] == '<') || (header[loc1] == '|')) ? true : false);
  UNUSED(littleEndian); assert(littleEndian);
 
  std::string str_ws = header.substr(loc1+2);
  loc2 = str_ws.find("'");
  word_size = atoi(str_ws.substr(0, loc2).c_str());
}
 
void visp::cnpy::parse_npy_header(FILE *fp, size_t &word_size, std::vector<size_t> &shape, bool &fortran_order)
{
  char buffer[256];
  size_t res = fread(buffer, sizeof(char), 11, fp);
  if (res != 11) {
    throw std::runtime_error("parse_npy_header: failed fread");
  }
  std::string header = fgets(buffer, 256, fp);
  assert(header[header.size()-1] == '\n');
 
  size_t loc1, loc2;
 
  //fortran order
  loc1 = header.find("fortran_order");
  if (loc1 == std::string::npos) {
    throw std::runtime_error("parse_npy_header: failed to find header keyword: 'fortran_order'");
  }
  loc1 += 16;
  fortran_order = (header.substr(loc1, 4) == "True" ? true : false);
 
  //shape
  loc1 = header.find("(");
  loc2 = header.find(")");
  if ((loc1 == std::string::npos) || (loc2 == std::string::npos)) {
    throw std::runtime_error("parse_npy_header: failed to find header keyword: '(' or ')'");
  }
 
  std::regex num_regex("[0-9][0-9]*");
  std::smatch sm;
  shape.clear();
 
  std::string str_shape = header.substr(loc1+1, loc2-loc1-1);
  while (std::regex_search(str_shape, sm, num_regex)) {
    shape.push_back(std::stoi(sm[0].str()));
    str_shape = sm.suffix().str();
  }
 
  //endian, word size, data type
  //byte order code | stands for not applicable.
  //not sure when this applies except for byte array
  loc1 = header.find("descr");
  if (loc1 == std::string::npos) {
    throw std::runtime_error("parse_npy_header: failed to find header keyword: 'descr'");
  }
  loc1 += 9;
  bool littleEndian = ((header[loc1] == '<') || (header[loc1] == '|') ? true : false);
  UNUSED(littleEndian); assert(littleEndian);
 
  // --comment: char type equals header[loc1+1];
  // --comment: assert type equals map_type(T);
 
  std::string str_ws = header.substr(loc1+2);
  loc2 = str_ws.find("'");
  word_size = atoi(str_ws.substr(0, loc2).c_str());
}
 
void visp::cnpy::parse_zip_footer(FILE *fp, uint16_t &nrecs, size_t &global_header_size, size_t &global_header_offset)
{
  std::vector<char> footer(22);
  fseek(fp, -22, SEEK_END);
  size_t res = fread(&footer[0], sizeof(char), 22, fp);
  if (res != 22) {
    throw std::runtime_error("parse_zip_footer: failed fread");
  }
 
  uint16_t disk_no, disk_start, nrecs_on_disk, comment_len;
  disk_no = *(uint16_t *)&footer[4];
  disk_start = *(uint16_t *)&footer[6];
  nrecs_on_disk = *(uint16_t *)&footer[8];
  nrecs = *(uint16_t *)&footer[10];
  global_header_size = *(uint32_t *)&footer[12];
  global_header_offset = *(uint32_t *)&footer[16];
  comment_len = *(uint16_t *)&footer[20];
 
  UNUSED(disk_no); assert(disk_no == 0);
  UNUSED(disk_start); assert(disk_start == 0);
  UNUSED(nrecs_on_disk); assert(nrecs_on_disk == nrecs);
  UNUSED(comment_len); assert(comment_len == 0);
}
 
visp::cnpy::NpyArray load_the_npy_file(FILE *fp)
{
  std::vector<size_t> shape;
  size_t word_size;
  bool fortran_order;
  visp::cnpy::parse_npy_header(fp, word_size, shape, fortran_order);
 
  visp::cnpy::NpyArray arr(shape, word_size, fortran_order);
  size_t nread = fread(arr.data<char>(), 1, arr.num_bytes(), fp);
  if (nread != arr.num_bytes()) {
    throw std::runtime_error("load_the_npy_file: failed fread");
  }
  return arr;
}
 
visp::cnpy::NpyArray load_the_npz_array(FILE *fp, uint32_t compr_bytes, uint32_t uncompr_bytes)
{
  std::vector<unsigned char> buffer_compr(compr_bytes);
  std::vector<unsigned char> buffer_uncompr(uncompr_bytes);
  size_t nread = fread(&buffer_compr[0], 1, compr_bytes, fp);
  if (nread != compr_bytes) {
    throw std::runtime_error("load_the_npy_file: failed fread");
  }
 
  z_stream d_stream;
 
  d_stream.zalloc = Z_NULL;
  d_stream.zfree = Z_NULL;
  d_stream.opaque = Z_NULL;
  d_stream.avail_in = 0;
  d_stream.next_in = Z_NULL;
  int err = inflateInit2(&d_stream, -MAX_WBITS);
  UNUSED(err); assert(err == 0);
 
  d_stream.avail_in = compr_bytes;
  d_stream.next_in = &buffer_compr[0];
  d_stream.avail_out = uncompr_bytes;
  d_stream.next_out = &buffer_uncompr[0];
 
  err = inflate(&d_stream, Z_FINISH);
  UNUSED(err); assert(err == 0);
  err = inflateEnd(&d_stream);
  UNUSED(err); assert(err == 0);
 
  std::vector<size_t> shape;
  size_t word_size;
  bool fortran_order;
  visp::cnpy::parse_npy_header(&buffer_uncompr[0], word_size, shape, fortran_order);
 
  visp::cnpy::NpyArray array(shape, word_size, fortran_order);
 
  size_t offset = uncompr_bytes - array.num_bytes();
  memcpy(array.data<unsigned char>(), &buffer_uncompr[0]+offset, array.num_bytes());
 
  return array;
}
 
visp::cnpy::npz_t visp::cnpy::npz_load(std::string fname)
{
  FILE *fp = fopen(fname.c_str(), "rb");
 
  if (!fp) {
    throw std::runtime_error("npz_load: Error! Unable to open file "+fname+"!");
  }
 
  visp::cnpy::npz_t arrays;
  bool quit = false;
  while (!quit) {
    std::vector<char> local_header(30);
    size_t headerres = fread(&local_header[0], sizeof(char), 30, fp);
    if (headerres != 30) {
      throw std::runtime_error("npz_load: failed fread");
    }
 
    //if we've reached the global header, stop reading
    if ((local_header[2] != 0x03) || (local_header[3] != 0x04)) {
      quit = true;
    }
 
    //read in the variable name
    uint16_t name_len = *(uint16_t *)&local_header[26];
    std::string varname(name_len, ' ');
    size_t vname_res = fread(&varname[0], sizeof(char), name_len, fp);
    if (vname_res != name_len) {
      throw std::runtime_error("npz_load: failed fread");
    }
 
    //erase the lagging .npy
    varname.erase(varname.end()-4, varname.end());
 
    //read in the extra field
    uint16_t extra_field_len = *(uint16_t *)&local_header[28];
    if (extra_field_len > 0) {
      std::vector<char> buff(extra_field_len);
      size_t efield_res = fread(&buff[0], sizeof(char), extra_field_len, fp);
      if (efield_res != extra_field_len) {
        throw std::runtime_error("npz_load: failed fread");
      }
    }
 
    uint16_t compr_method = *reinterpret_cast<uint16_t *>(&local_header[0]+8);
    uint32_t compr_bytes = *reinterpret_cast<uint32_t *>(&local_header[0]+18);
    uint32_t uncompr_bytes = *reinterpret_cast<uint32_t *>(&local_header[0]+22);
 
    if (compr_method == 0) { arrays[varname] = load_the_npy_file(fp); }
    else { arrays[varname] = load_the_npz_array(fp, compr_bytes, uncompr_bytes); }
  }
 
  fclose(fp);
  return arrays;
}
 
visp::cnpy::NpyArray visp::cnpy::npz_load(std::string fname, std::string varname)
{
  FILE *fp = fopen(fname.c_str(), "rb");
 
  if (!fp) {
    throw std::runtime_error("npz_load: Unable to open file "+fname);
  }
 
  bool quit = false;
  while (!quit) {
    std::vector<char> local_header(30);
    size_t header_res = fread(&local_header[0], sizeof(char), 30, fp);
    if (header_res != 30) {
      throw std::runtime_error("npz_load: failed fread");
    }
 
    //if we've reached the global header, stop reading
    if ((local_header[2] != 0x03) || (local_header[3] != 0x04)) {
      quit = true;
    }
 
    //read in the variable name
    uint16_t name_len = *(uint16_t *)&local_header[26];
    std::string vname(name_len, ' ');
    size_t vname_res = fread(&vname[0], sizeof(char), name_len, fp);
    if (vname_res != name_len) {
      throw std::runtime_error("npz_load: failed fread");
    }
    vname.erase(vname.end()-4, vname.end()); //erase the lagging .npy
 
    //read in the extra field
    uint16_t extra_field_len = *(uint16_t *)&local_header[28];
    fseek(fp, extra_field_len, SEEK_CUR); //skip past the extra field
 
    uint16_t compr_method = *reinterpret_cast<uint16_t *>(&local_header[0]+8);
    uint32_t compr_bytes = *reinterpret_cast<uint32_t *>(&local_header[0]+18);
    uint32_t uncompr_bytes = *reinterpret_cast<uint32_t *>(&local_header[0]+22);
 
    if (vname == varname) {
      NpyArray array = (compr_method == 0) ? load_the_npy_file(fp) : load_the_npz_array(fp, compr_bytes, uncompr_bytes);
      fclose(fp);
      return array;
    }
    else {
        //skip past the data
      uint32_t size = *(uint32_t *)&local_header[22];
      fseek(fp, size, SEEK_CUR);
    }
  }
 
  fclose(fp);
 
  //if we get here, we haven't found the variable in the file
  throw std::runtime_error("npz_load: Variable name "+varname+" not found in "+fname);
}
 
visp::cnpy::NpyArray visp::cnpy::npy_load(std::string fname)
{
 
  FILE *fp = fopen(fname.c_str(), "rb");
 
  if (!fp) {
    throw std::runtime_error("npy_load: Unable to open file "+fname);
  }
 
  NpyArray arr = load_the_npy_file(fp);
 
  fclose(fp);
  return arr;
}
 
#endif
 
std::string vpIoTools::baseName = "";
std::string vpIoTools::baseDir = "";
std::string vpIoTools::configFile = "";
std::vector<std::string> vpIoTools::configVars = std::vector<std::string>();
std::vector<std::string> vpIoTools::configValues = std::vector<std::string>();
 
const char vpIoTools::separator =
#if defined(_WIN32)
'\\';
#else
'/';
#endif
 
namespace
{
// The following code is not working on iOS since wordexp() is not available
// The function is not used on Android
#if defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
#if (TARGET_OS_IOS == 0) && !defined(__ANDROID__)
void replaceAll(std::string &str, const std::string &search, const std::string &replace)
{
  size_t start_pos = 0;
  while ((start_pos = str.find(search, start_pos)) != std::string::npos) {
    str.replace(start_pos, search.length(), replace);
    start_pos += replace.length(); // Handles case where 'replace' is a
    // substring of 'search'
  }
}
#endif
#endif
 
std::string &ltrim(std::string &s)
{
#if VISP_CXX_STANDARD > VISP_CXX_STANDARD_98
  s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int c) { return !std::isspace(c); }));
#else
  s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
#endif
  return s;
}
 
std::string &rtrim(std::string &s)
{
#if VISP_CXX_STANDARD > VISP_CXX_STANDARD_98
  s.erase(std::find_if(s.rbegin(), s.rend(), [](int c) { return !std::isspace(c); }).base(), s.end());
#else
  s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
#endif
  return s;
}
} // namespace
 
const std::string &vpIoTools::getBuildInformation()
{
  static std::string build_info =
#include "version_string.inc"
    ;
  return build_info;
}
 
std::string vpIoTools::getTempPath()
{
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  std::string username;
  vpIoTools::getUserName(username);
  return "/tmp/" + username;
#elif defined(_WIN32) && !defined(WINRT)
  // https://docs.microsoft.com/en-us/windows/win32/fileio/creating-and-using-a-temporary-file
  //  Gets the temp path env string (no guarantee it's a valid path).
  TCHAR lpTempPathBuffer[MAX_PATH];
  DWORD dwRetVal = GetTempPath(MAX_PATH /* length of the buffer */, lpTempPathBuffer /* buffer for path */);
  if (dwRetVal > MAX_PATH || (dwRetVal == 0)) {
    throw vpIoException(vpIoException::cantGetenv, "Error with GetTempPath() call!");
  }
  std::string temp_path(lpTempPathBuffer);
  if (!temp_path.empty()) {
    if (temp_path.back() == '\\') {
      temp_path.resize(temp_path.size() - 1);
    }
  }
  else {
    temp_path = "C:\temp";
    try {
      vpIoTools::makeDirectory(temp_path);
    }
    catch (...) {
      throw(vpException(vpException::fatalError, "Cannot set temp path to %s", temp_path.c_str()));
    }
  }
  return temp_path;
#else
  throw vpIoException(vpException::fatalError, "Not implemented on this platform!");
#endif
}
 
void vpIoTools::setBaseName(const std::string &s) { baseName = s; }
 
void vpIoTools::setBaseDir(const std::string &dir) { baseDir = dir + "/"; }
 
std::string vpIoTools::getBaseName() { return baseName; }
 
std::string vpIoTools::getFullName() { return baseDir + baseName; }
 
void vpIoTools::getUserName(std::string &username)
{
  // With MinGW, UNIX and _WIN32 are defined
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  // Get the user name.
  char *logname = ::getenv("LOGNAME");
  if (!logname) {
    username = "unknown";
  }
  else {
    username = logname;
  }
#elif defined(_WIN32)
#if (!defined(WINRT))
  unsigned int info_buffer_size = 1024;
  TCHAR *infoBuf = new TCHAR[info_buffer_size];
  DWORD bufCharCount = (DWORD)info_buffer_size;
  // Get the user name.
  if (!GetUserName(infoBuf, &bufCharCount)) {
    username = "unknown";
  }
  else {
    username = infoBuf;
  }
  delete[] infoBuf;
#else
  // Universal platform
  username = "unknown";
#endif
#else
  username = "unknown";
#endif
}
 
std::string vpIoTools::getUserName()
{
  std::string username;
  getUserName(username);
  return username;
}
 
std::string vpIoTools::getenv(const std::string &env)
{
#if defined(_WIN32) && defined(WINRT)
  throw(vpIoException(vpIoException::cantGetenv, "Cannot get the environment variable value: not "
                      "implemented on Universal Windows Platform"));
#else
  std::string value;
  // Get the environment variable value.
  char *v_value = ::getenv(env.c_str());
  if (!v_value) {
    throw(vpIoException(vpIoException::cantGetenv, "Cannot get the environment variable value"));
  }
  value = v_value;
 
  return value;
#endif
}
 
void vpIoTools::getVersion(const std::string &version, unsigned int &major, unsigned int &minor, unsigned int &patch)
{
  if (version.size() == 0) {
    major = 0;
    minor = 0;
    patch = 0;
  }
  else {
    size_t major_pos = version.find('.');
    std::string major_str = version.substr(0, major_pos);
    major = static_cast<unsigned>(atoi(major_str.c_str()));
 
    if (major_pos != std::string::npos) {
      size_t minor_pos = version.find('.', major_pos + 1);
      std::string minor_str = version.substr(major_pos + 1, (minor_pos - (major_pos + 1)));
      minor = static_cast<unsigned>(atoi(minor_str.c_str()));
 
      if (minor_pos != std::string::npos) {
        std::string patch_str = version.substr(minor_pos + 1);
        patch = static_cast<unsigned>(atoi(patch_str.c_str()));
      }
      else {
        patch = 0;
      }
    }
    else {
      minor = 0;
      patch = 0;
    }
  }
}
 
bool vpIoTools::checkDirectory(const std::string &dirname)
{
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  struct stat stbuf;
#elif defined(_WIN32) && defined(__MINGW32__)
  struct stat stbuf;
#elif defined(_WIN32)
  struct _stat stbuf;
#endif
 
  if (dirname.empty()) {
    return false;
  }
 
  std::string path_dirname = path(dirname);
 
  if (VP_STAT(path_dirname.c_str(), &stbuf) != 0) {
    // Test adding the separator if not already present
    if (path_dirname.at(path_dirname.size() - 1) != separator) {
      if (VP_STAT((path_dirname + separator).c_str(), &stbuf) != 0) {
        return false;
      }
    }
    // Test removing the separator if already present
    if (path_dirname.at(path_dirname.size() - 1) == separator) {
      if (VP_STAT((path_dirname.substr(0, path_dirname.size() - 1)).c_str(), &stbuf) != 0) {
        return false;
      }
    }
  }
 
#if defined(_WIN32) || (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__)))
  if ((stbuf.st_mode & S_IFDIR) == 0)
#endif
  {
    return false;
  }
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  if ((stbuf.st_mode & S_IWUSR) == 0)
#elif defined(_WIN32)
  if ((stbuf.st_mode & S_IWRITE) == 0)
#endif
  {
    return false;
  }
  return true;
}
 
bool vpIoTools::checkFifo(const std::string &fifofilename)
{
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  struct stat stbuf;
 
  std::string v_filename = path(fifofilename);
  if (stat(v_filename.c_str(), &stbuf) != 0) {
    return false;
  }
  if ((stbuf.st_mode & S_IFIFO) == 0) {
    return false;
  }
  if ((stbuf.st_mode & S_IRUSR) == 0)
 
  {
    return false;
  }
  return true;
#elif defined(_WIN32)
  (void)fifofilename;
  throw(vpIoException(vpIoException::notImplementedError, "Fifo files are not supported on Windows platforms."));
#endif
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
int vpIoTools::mkdir_p(const std::string &path, int mode)
{
  errno = 0;
  if (path.size() > PATH_MAX) {
    errno = ENAMETOOLONG;
    return -1;
  }
 
  // Iterate over the string
  std::string cpy_path = path;
  std::string sub_path;
  for (size_t pos = 0; (pos = cpy_path.find(vpIoTools::separator)) != std::string::npos;) {
    sub_path += cpy_path.substr(0, pos + 1);
    // Continue if sub_path = separator
    if (pos == 0) {
      cpy_path.erase(0, pos + 1);
      continue;
    }
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__)))
    if (mkdir(sub_path.c_str(), static_cast<mode_t>(mode)) != 0)
#elif defined(_WIN32)
    (void)mode; // var not used
    if (!checkDirectory(sub_path) && _mkdir(sub_path.c_str()) != 0)
#endif
    {
      if (errno != EEXIST) {
        return -1;
      }
    }
    cpy_path.erase(0, pos + 1);
  }
 
  if (!cpy_path.empty()) {
    sub_path += cpy_path;
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__)))
    if (mkdir(sub_path.c_str(), static_cast<mode_t>(mode)) != 0)
#elif defined(_WIN32)
 
    if (_mkdir(sub_path.c_str()) != 0)
#endif
    {
      if (errno != EEXIST) {
        return -1;
      }
    }
  }
 
  return 0;
}
 
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
void vpIoTools::makeDirectory(const std::string &dirname)
{
#if ((!defined(__unix__) && !defined(__unix) && (!defined(__APPLE__) || !defined(__MACH__)))) && !defined(_WIN32)
  std::cerr << "Unsupported platform for vpIoTools::makeDirectory()!" << std::endl;
  return;
#endif
 
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  struct stat stbuf;
#elif defined(_WIN32) && defined(__MINGW32__)
  struct stat stbuf;
#elif defined(_WIN32)
  struct _stat stbuf;
#endif
 
  if (dirname.empty()) {
    throw(vpIoException(vpIoException::invalidDirectoryName, "invalid directory name"));
  }
 
  std::string v_dirname = path(dirname);
 
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  if (stat(v_dirname.c_str(), &stbuf) != 0)
#elif defined(_WIN32) && defined(__MINGW32__)
  if (stat(v_dirname.c_str(), &stbuf) != 0)
#elif defined(_WIN32)
  if (_stat(v_dirname.c_str(), &stbuf) != 0)
#endif
  {
    if (vpIoTools::mkdir_p(v_dirname, 0755) != 0) {
      throw(vpIoException(vpIoException::cantCreateDirectory, "Unable to create directory '%s'", dirname.c_str()));
    }
  }
 
  if (checkDirectory(dirname) == false) {
    throw(vpIoException(vpIoException::cantCreateDirectory, "Unable to create directory '%s'", dirname.c_str()));
  }
}
 
void vpIoTools::makeFifo(const std::string &fifoname)
{
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
 
  // If dirname is a directory, we throw an error
  if (vpIoTools::checkDirectory(fifoname)) {
    throw(vpIoException(vpIoException::invalidDirectoryName,
                        "Unable to create fifo file. '%s' is an existing directory.", fifoname.c_str()));
  }
 
  // If dirname refers to an already existing file, we throw an error
  else if (vpIoTools::checkFilename(fifoname)) {
    throw(vpIoException(vpIoException::invalidDirectoryName, "Unable to create fifo file '%s'. File already exists.",
                        fifoname.c_str()));
    // If dirname refers to an already existing fifo, we throw an error
  }
  else if (vpIoTools::checkFifo(fifoname)) {
    throw(vpIoException(vpIoException::invalidDirectoryName, "Unable to create fifo file '%s'. Fifo already exists.",
                        fifoname.c_str()));
  }
 
  else if (mkfifo(fifoname.c_str(), 0666) < 0) {
    throw(vpIoException(vpIoException::cantCreateDirectory, "Unable to create fifo file '%s'.", fifoname.c_str()));
  }
#elif defined(_WIN32)
  (void)fifoname;
  throw(vpIoException(vpIoException::cantCreateDirectory, "Unable to create fifo on Windows platforms."));
#endif
}
 
#if defined(_WIN32) && !defined(WINRT)
std::string getUuid()
{
  UUID uuid;
  if (UuidCreate(&uuid) != RPC_S_OK) {
    throw(vpIoException(vpIoException::fatalError, "UuidCreate() failed!"));
  }
 
  RPC_CSTR stringUuid;
  if (UuidToString(&uuid, &stringUuid) != RPC_S_OK) {
    throw(vpIoException(vpIoException::fatalError, "UuidToString() failed!"));
  }
 
  return reinterpret_cast<char *>(stringUuid);
}
#endif
 
std::string vpIoTools::makeTempDirectory(const std::string &dirname)
{
#if defined(WINRT) || !defined(_WIN32) && !(defined(__unix__) || defined(__unix) ||                                    \
                                            (defined(__APPLE__) && defined(__MACH__))) // not UNIX and not Windows
  throw(vpIoException(vpIoException::cantCreateDirectory, "makeTempDirectory() is not supported on this platform!"));
#endif
 
  std::string dirname_cpy = std::string(dirname);
  std::string correctEnding = "XXXXXX";
 
  // If dirname is an unexisting directory, it should end with XXXXXX in order to create a temp directory
  if (!vpIoTools::checkDirectory(dirname_cpy)) {
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
    // Check if dirname ends with XXXXXX
    if (dirname_cpy.rfind(correctEnding) == std::string::npos) {
      if (dirname_cpy.at(dirname_cpy.length() - 1) != '/') {
        dirname_cpy = dirname_cpy + "/";
      }
      try {
        vpIoTools::makeDirectory(dirname_cpy);
      }
      catch (...) {
        throw(vpException(vpException::fatalError, "Cannot create temp directory %s", dirname_cpy.c_str()));
      }
 
      dirname_cpy = dirname_cpy + "XXXXXX";
    }
 
#elif defined(_WIN32) && !defined(WINRT)
    // Remove XXXXXX
    dirname_cpy = dirname_cpy.substr(0, dirname_cpy.rfind(correctEnding));
    // Append UUID
    dirname_cpy = dirname_cpy + getUuid();
#endif
 
  }
  else {
    // If dirname is an existing directory, we create a temp directory inside
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
    if (dirname_cpy.at(dirname_cpy.length() - 1) != '/') {
      dirname_cpy = dirname_cpy + "/";
    }
    dirname_cpy = dirname_cpy + "XXXXXX";
#elif defined(_WIN32) && !defined(WINRT)
    dirname_cpy = createFilePath(dirname_cpy, getUuid());
#endif
  }
 
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  char *dirname_char = new char[dirname_cpy.length() + 1];
  strcpy(dirname_char, dirname_cpy.c_str());
 
  char *computedDirname = mkdtemp(dirname_char);
 
  if (!computedDirname) {
    delete[] dirname_char;
    throw(vpIoException(vpIoException::cantCreateDirectory, "Unable to create directory '%s'.", dirname_cpy.c_str()));
  }
 
  std::string res(computedDirname);
  delete[] dirname_char;
  return res;
#elif defined(_WIN32) && !defined(WINRT)
  makeDirectory(dirname_cpy);
  return dirname_cpy;
#endif
}
 
bool vpIoTools::checkFilename(const std::string &filename)
{
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  struct stat stbuf;
#elif defined(_WIN32)
  struct _stat stbuf;
#endif
 
  if (filename.empty()) {
    return false;
  }
 
  std::string v_filename = path(filename);
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  if (stat(v_filename.c_str(), &stbuf) != 0)
#elif defined(_WIN32)
  if (_stat(v_filename.c_str(), &stbuf) != 0)
#endif
  {
    return false;
  }
  if ((stbuf.st_mode & S_IFREG) == 0) {
    return false;
  }
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  if ((stbuf.st_mode & S_IRUSR) == 0)
#elif defined(_WIN32)
  if ((stbuf.st_mode & S_IREAD) == 0)
#endif
  {
    return false;
  }
  return true;
}
 
bool vpIoTools::copy(const std::string &src, const std::string &dst)
{
  // Check if we have to consider a file or a directory
  if (vpIoTools::checkFilename(src)) {
    // --comment: std::cout "copy file: " src " in " dst std::endl;
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
#if TARGET_OS_IOS == 0 // The following code is not working on iOS since
                       // wordexp() is not available
    std::stringstream cmd;
    cmd << "cp -p ";
    cmd << src;
    cmd << " ";
    cmd << dst;
    int ret = system(cmd.str().c_str());
    if (ret) {
    } // to avoid a warning
    // std::cout << cmd << " return value: " << ret << std::endl;
    return true;
#else
    throw(vpIoException(vpException::fatalError, "Cannot copy %s in %s: not implemented on iOS Platform", src.c_str(),
                        dst.c_str()));
#endif
#elif defined(_WIN32)
#if (!defined(WINRT))
    std::stringstream cmd;
    cmd << "copy ";
    cmd << vpIoTools::path(src);
    cmd << " ";
    cmd << vpIoTools::path(dst);
    int ret = system(cmd.str().c_str());
    if (ret) {
    }; // to avoid a warning
    // std::cout << cmd << " return value: " << ret << std::endl;
    return true;
#else
    throw(vpIoException(vpException::fatalError, "Cannot copy %s in %s: not implemented on Universal Windows Platform",
                        src.c_str(), dst.c_str()));
#endif
#endif
  }
  else if (vpIoTools::checkDirectory(src)) {
    // --comment: std::cout  "copy directory: "  src  " in "  dst
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
#if TARGET_OS_IOS == 0 // The following code is not working on iOS since
                       // wordexp() is not available
    std::stringstream cmd;
    cmd << "cp -p ";
    cmd << src;
    cmd << " ";
    cmd << dst;
    int ret = system(cmd.str().c_str());
    if (ret) {
    } // to avoid a warning
    // std::cout << cmd << " return value: " << ret << std::endl;
    return true;
#else
    throw(vpIoException(vpException::fatalError, "Cannot copy %s in %s: not implemented on iOS Platform", src.c_str(),
                        dst.c_str()));
#endif
#elif defined(_WIN32)
#if (!defined(WINRT))
    std::stringstream cmd;
    cmd << "copy ";
    cmd << vpIoTools::path(src);
    cmd << " ";
    cmd << vpIoTools::path(dst);
    int ret = system(cmd.str().c_str());
    if (ret) {
    }; // to avoid a warning
    // std::cout << cmd << " return value: " << ret << std::endl;
    return true;
#else
    throw(vpIoException(vpException::fatalError, "Cannot copy %s in %s: not implemented on Universal Windows Platform",
                        src.c_str(), dst.c_str()));
#endif
#endif
  }
  else {
    std::cout << "Cannot copy: " << src << " in " << dst << std::endl;
    return false;
  }
}
 
bool vpIoTools::remove(const std::string &file_or_dir)
{
  // Check if we have to consider a file or a directory
  if (vpIoTools::checkFilename(file_or_dir)
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
    || vpIoTools::checkFifo(std::string(file_or_dir))
#endif
    ) {
    if (::remove(file_or_dir.c_str()) != 0) {
      return false;
    }
    else {
      return true;
    }
  }
  else if (vpIoTools::checkDirectory(file_or_dir)) {
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
#if TARGET_OS_IOS == 0 // The following code is not working on iOS since
                       // wordexp() is not available
    std::stringstream cmd;
    cmd << "rm -rf \"";
    cmd << file_or_dir;
    cmd << "\"";
    int ret = system(cmd.str().c_str());
    if (ret) {
    } // to avoid a warning
    // std::cout << cmd << " return value: " << ret << std::endl;
    return true;
#else
    throw(vpIoException(vpException::fatalError, "Cannot remove %s: not implemented on iOS Platform",
                        file_or_dir.c_str()));
#endif
#elif defined(_WIN32)
#if (!defined(WINRT))
    std::stringstream cmd;
    cmd << "rmdir /S /Q ";
    cmd << vpIoTools::path(file_or_dir);
    cmd << "\"";
    int ret = system(cmd.str().c_str());
    if (ret) {
    }; // to avoid a warning
    // std::cout << cmd << " return value: " << ret << std::endl;
    return true;
#else
    throw(vpIoException(vpException::fatalError, "Cannot remove %s: not implemented on Universal Windows Platform",
                        file_or_dir.c_str()));
#endif
#endif
  }
  else {
    std::cout << "Cannot remove: " << file_or_dir << std::endl;
    return false;
  }
}
 
bool vpIoTools::rename(const std::string &oldfilename, const std::string &newfilename)
{
  if (::rename(oldfilename.c_str(), newfilename.c_str()) != 0) {
    return false;
  }
  else {
    return true;
  }
}
 
std::string vpIoTools::path(const std::string &pathname)
{
  std::string path(pathname);
 
#if defined(_WIN32)
  for (unsigned int i = 0; i < path.length(); ++i)
    if (path[i] == '/')
      path[i] = '\\';
#elif defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
  unsigned int path_length = path.length();
  for (unsigned int i = 0; i < path_length; ++i) {
    if (path[i] == '\\') {
      path[i] = '/';
    }
  }
#if TARGET_OS_IOS == 0 // The following code is not working on iOS and android since
  // wordexp() is not available
#ifdef __ANDROID__
// Do nothing
#else
  wordexp_t exp_result;
 
  // escape quote character
  replaceAll(path, "'", "'\\''");
  // add quotes to handle special characters like parentheses and spaces
  wordexp(std::string("'" + path + "'").c_str(), &exp_result, 0);
  path = exp_result.we_wordc == 1 ? exp_result.we_wordv[0] : "";
  wordfree(&exp_result);
#endif
#endif
#endif
 
  return path;
}
 
bool vpIoTools::loadConfigFile(const std::string &confFile)
{
  configFile = path(confFile);
  configVars.clear();
  configValues.clear();
  std::ifstream confContent(configFile.c_str(), std::ios::in);
 
  if (confContent.is_open()) {
    std::string line, var, val;
    unsigned long int k;
    int c;
    std::string stop[3] = { " ", "\t", "#" };
    while (std::getline(confContent, line)) {
      if ((line.compare(0, 1, "#") != 0) && (line.size() > 2)) {
        // name of the variable
        k = static_cast<unsigned long>(line.find(" "));
        var = line.substr(0, k);
        // look for the end of the actual value
        c = 200;
        for (unsigned i = 0; i < 3; ++i) {
          c = vpMath::minimum(c,
            static_cast<int>(line.find(stop[i], static_cast<size_t>(k) + static_cast<size_t>(1))));
        }
        if (c == -1) {
          c = static_cast<int>(line.size());
        }
        unsigned long int c_ = static_cast<unsigned long int>(c);
        val = line.substr(static_cast<size_t>(k) + static_cast<size_t>(1),
          static_cast<size_t>(c_) - static_cast<size_t>(k) - static_cast<size_t>(1));
        configVars.push_back(var);
        configValues.push_back(val);
      }
    }
    confContent.close();
  }
  else {
    return false;
  }
  return true;
}
 
bool vpIoTools::readConfigVar(const std::string &var, float &value)
{
  bool found = false;
  unsigned int configvars_size = configVars.size();
  for (unsigned int k = 0; (k < configvars_size) && (found == false); ++k) {
    if (configVars[k] == var) {
      if (configValues[k].compare("PI") == 0) {
        value = static_cast<float>(M_PI);
      }
      else if (configValues[k].compare("PI/2") == 0) {
        value = static_cast<float>(M_PI / 2.0);
      }
      else if (configValues[k].compare("-PI/2") == 0) {
        value = static_cast<float>(-M_PI / 2.0);
      }
      else {
        value = static_cast<float>(atof(configValues[k].c_str()));
      }
      found = true;
    }
  }
  if (found == false) {
    std::cout << var << " not found in config file" << std::endl;
  }
  return found;
}
bool vpIoTools::readConfigVar(const std::string &var, double &value)
{
  bool found = false;
  unsigned int configvars_size = configVars.size();
  for (unsigned int k = 0; (k < configvars_size) && (found == false); ++k) {
    if (configVars[k] == var) {
      if (configValues[k].compare("PI") == 0) {
        value = M_PI;
      }
      else if (configValues[k].compare("PI/2") == 0) {
        value = M_PI / 2;
      }
      else if (configValues[k].compare("-PI/2") == 0) {
        value = -M_PI / 2;
      }
      else {
        value = atof(configValues[k].c_str());
      }
      found = true;
    }
  }
  if (found == false) {
    std::cout << var << " not found in config file" << std::endl;
  }
  return found;
}
 
bool vpIoTools::readConfigVar(const std::string &var, int &value)
{
  bool found = false;
  unsigned int configvars_size = configVars.size();
  for (unsigned int k = 0; (k < configvars_size) && (found == false); ++k) {
    if (configVars[k] == var) {
      value = atoi(configValues[k].c_str());
      found = true;
    }
  }
  if (found == false) {
    std::cout << var << " not found in config file" << std::endl;
  }
  return found;
}
 
bool vpIoTools::readConfigVar(const std::string &var, unsigned int &value)
{
  int v = 0;
  bool found = readConfigVar(var, v);
  value = static_cast<unsigned int>(v);
  return found;
}
 
bool vpIoTools::readConfigVar(const std::string &var, bool &value)
{
  int v = 0;
  bool found = readConfigVar(var, v);
  value = (v != 0);
  return found;
}
 
bool vpIoTools::readConfigVar(const std::string &var, vpColor &value)
{
  unsigned int v = 0;
  bool found = readConfigVar(var, v);
  value = vpColor::getColor(v);
  return found;
}
 
bool vpIoTools::readConfigVar(const std::string &var, std::string &value)
{
  bool found = false;
  unsigned int configvars_size = configVars.size();
  for (unsigned int k = 0; (k < configvars_size) && (found == false); ++k) {
    if (configVars[k] == var) {
      value = configValues[k];
      found = true;
    }
  }
  if (found == false) {
    std::cout << var << " not found in config file" << std::endl;
  }
  return found;
}
 
bool vpIoTools::readConfigVar(const std::string &var, vpArray2D<double> &value, const unsigned int &nCols,
  const unsigned int &nRows)
{
  bool found = false;
  std::string nb;
  unsigned int configvars_size = configVars.size();
  for (unsigned int k = 0; (k < configvars_size) && (found == false); ++k) {
    if (configVars[k] == var) {
      found = true;
      // resize or not
      if ((nCols != 0) && (nRows != 0)) {
        value.resize(nRows, nCols);
      }
      size_t ind = 0, ind2;
      unsigned int value_rows = value.getRows();
      unsigned int value_cols = value.getCols();
      for (unsigned int i = 0; i < value_rows; ++i) {
        for (unsigned int j = 0; j < value_cols; ++j) {
          ind2 = configValues[k].find(",", ind);
          nb = configValues[k].substr(ind, ind2 - ind);
          if (nb.compare("PI") == 0) {
            value[i][j] = M_PI;
          }
          else if (nb.compare("PI/2") == 0) {
            value[i][j] = M_PI / 2;
          }
          else if (nb.compare("-PI/2") == 0) {
            value[i][j] = -M_PI / 2;
          }
          else {
            value[i][j] = atof(nb.c_str());
          }
          ind = ind2 + 1;
        }
      }
    }
  }
  if (found == false) {
    std::cout << var << " not found in config file" << std::endl;
  }
  return found;
}
 
// construct experiment filename & path
 
void vpIoTools::addNameElement(const std::string &strTrue, const bool &cond, const std::string &strFalse)
{
  if (cond) {
    baseName += "_" + strTrue;
  }
  else if (strFalse != "") {
    baseName += "_" + strFalse;
  }
}
 
void vpIoTools::addNameElement(const std::string &strTrue, const double &val)
{
  // if(val != 0.)
  if (std::fabs(val) < std::numeric_limits<double>::epsilon()) {
    std::stringstream valS;
    valS.precision(4);
    valS << val;
    baseName += "_" + strTrue + valS.str();
  }
}
 
void vpIoTools::createBaseNamePath(const bool &empty)
{
  std::string path = baseDir + baseName;
  if (vpIoTools::checkDirectory(path) == false) {
    try {
      vpIoTools::makeDirectory(path);
      std::cout << "Creating directory " << path << std::endl;
    }
    catch (...) {
      throw(vpException(vpException::fatalError, "Cannot create base name directory %s", path.c_str()));
    }
  }
  else {
    if (empty) {
      std::cout << "Emptying directory " << path << std::endl;
      vpIoTools::remove(path + "/*");
    }
  }
}
 
void vpIoTools::saveConfigFile(const bool &actuallySave)
{
  if (actuallySave) {
    std::string dest = baseDir + "/" + baseName + "_config.txt";
    // file copy
    vpIoTools::copy(configFile, dest);
  }
}
 
std::string vpIoTools::getViSPImagesDataPath()
{
  std::string data_path;
  std::string file_to_test("mbt/cube.cao");
  std::string filename;
  // Test if VISP_INPUT_IMAGE_PATH env var is set
  data_path = vpIoTools::getenv("VISP_INPUT_IMAGE_PATH");
  filename = data_path + "/" + file_to_test;
  if (vpIoTools::checkFilename(filename)) {
    return data_path;
  }
  data_path = vpIoTools::getenv("VISP_INPUT_IMAGE_PATH") + "/ViSP-images";
  filename = data_path + "/" + file_to_test;
  if (vpIoTools::checkFilename(filename)) {
    return data_path;
  }
  data_path = vpIoTools::getenv("VISP_INPUT_IMAGE_PATH") + "/visp-images";
  filename = data_path + "/" + file_to_test;
  if (vpIoTools::checkFilename(filename)) {
    return data_path;
  }
 
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  // Test if visp-images-data package is installed (Ubuntu and Debian)
  data_path = "/usr/share/visp-images-data/ViSP-images";
  filename = data_path + "/" + file_to_test;
  if (vpIoTools::checkFilename(filename)) {
    return data_path;
  }
  data_path = "/usr/share/visp-images-data/visp-images";
  filename = data_path + "/" + file_to_test;
  if (vpIoTools::checkFilename(filename)) {
    return data_path;
  }
#endif
  data_path = "";
  return data_path;
}
 
std::string vpIoTools::getFileExtension(const std::string &pathname, bool checkFile)
{
  if (checkFile && (vpIoTools::checkDirectory(pathname) || (!vpIoTools::checkFilename(pathname)))) {
    return "";
  }
 
#if defined(_WIN32)
  std::string sep = "\\";
  std::string altsep = "/";
  std::string extsep = ".";
#else
  // On Unix, or on the Mac
  std::string sep = "/";
  std::string altsep = "";
  std::string extsep = ".";
#endif
 
  // Python 2.7.8 module.
  // # Split a path in root and extension.
  // # The extension is everything starting at the last dot in the last
  // # pathname component; the root is everything before that.
  // # It is always true that root + ext == p.
  //
  // # Generic implementation of splitext, to be parametrized with
  // # the separators
  // def _splitext(p, sep, altsep, extsep):
  //    """Split the extension from a pathname.
  //
  //    Extension is everything from the last dot to the end, ignoring
  //    leading dots.  Returns "(root, ext)"; ext may be empty."""
  //
  //    sepIndex = p.rfind(sep)
  //    if altsep:
  //        altsepIndex = p.rfind(altsep)
  //        sepIndex = max(sepIndex, altsepIndex)
  //
  //    dotIndex = p.rfind(extsep)
  //    if dotIndex > sepIndex:
  //        # skip all leading dots
  //        filenameIndex = sepIndex + 1
  //        while filenameIndex < dotIndex:
  //            if p[filenameIndex] != extsep:
  //                return p[:dotIndex], p[dotIndex:]
  //            filenameIndex += 1
  //
  //    return p, ''
 
  int sepIndex = static_cast<int>(pathname.rfind(sep));
  if (!altsep.empty()) {
    int altsepIndex = static_cast<int>(pathname.rfind(altsep));
    sepIndex = std::max<int>(sepIndex, altsepIndex);
  }
 
  size_t dotIndex = pathname.rfind(extsep);
  if (dotIndex != std::string::npos) {
    // The extsep character exists
    size_t npos = std::string::npos;
    if (((sepIndex != static_cast<int>(npos)) && (static_cast<int>(dotIndex) > sepIndex)) ||
      (sepIndex == static_cast<int>(npos))) {
      if (sepIndex == static_cast<int>(npos)) {
        sepIndex = 0;
      }
      size_t filenameIndex = static_cast<size_t>(sepIndex) + static_cast<size_t>(1);
 
      while (filenameIndex < dotIndex) {
        if (pathname.compare(filenameIndex, 1, extsep) != 0) {
          return pathname.substr(dotIndex);
        }
        filenameIndex++;
      }
    }
  }
 
  return "";
}
 
std::string vpIoTools::getName(const std::string &pathname)
{
  if (pathname.size() > 0) {
    std::string convertedPathname = vpIoTools::path(pathname);
 
    size_t index = convertedPathname.find_last_of(vpIoTools::separator);
    if (index != std::string::npos) {
      return convertedPathname.substr(index + 1);
    }
 
    return convertedPathname;
  }
 
  return "";
}
 
std::string vpIoTools::getNameWE(const std::string &pathname)
{
  std::string name = vpIoTools::getName(pathname);
  size_t found = name.find_last_of(".");
  std::string name_we = name.substr(0, found);
  return name_we;
}
 
long vpIoTools::getIndex(const std::string &filename, const std::string &format)
{
  size_t indexBegin = format.find_last_of('%');
  size_t indexEnd = format.find_first_of('d', indexBegin);
  size_t suffixLength = format.length() - indexEnd - 1;
  // Extracting index
  if (filename.length() <= (suffixLength + indexBegin)) {
    return -1;
  }
  size_t indexLength = filename.length() - suffixLength - indexBegin;
  std::string indexSubstr = filename.substr(indexBegin, indexLength);
  std::istringstream ss(indexSubstr);
  long index = 0;
  ss >> index;
  if (ss.fail() || (index < 0) || (!ss.eof())) {
    return -1;
  }
 
  // Checking that format with inserted index equals filename
  char nameByFormat[FILENAME_MAX];
  snprintf(nameByFormat, FILENAME_MAX, format.c_str(), index);
  if (std::string(nameByFormat) != filename) {
    return -1;
  }
  return index;
}
 
std::string vpIoTools::getParent(const std::string &pathname)
{
  if (pathname.size() > 0) {
    std::string convertedPathname = vpIoTools::path(pathname);
 
    size_t index = convertedPathname.find_last_of(vpIoTools::separator);
    if (index != std::string::npos) {
      return convertedPathname.substr(0, index);
    }
 
    return ".";
  }
  else {
    return "";
  }
}
 
std::string vpIoTools::toLowerCase(const std::string &input)
{
  std::string out;
#if VISP_CXX_STANDARD > VISP_CXX_STANDARD_98
  for (std::string::const_iterator it = input.cbegin(); it != input.cend(); ++it) {
#else
  for (std::string::const_iterator it = input.begin(); it != input.end(); ++it) {
#endif
    out += std::tolower(*it);
  }
  return out;
  }
 
std::string vpIoTools::toUpperCase(const std::string &input)
{
  std::string out;
#if VISP_CXX_STANDARD > VISP_CXX_STANDARD_98
  for (std::string::const_iterator it = input.cbegin(); it != input.cend(); ++it) {
#else
  for (std::string::const_iterator it = input.begin(); it != input.end(); ++it) {
#endif
    out += std::toupper(*it);
  }
  return out;
  }
 
std::string vpIoTools::getAbsolutePathname(const std::string &pathname)
{
 
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  std::string real_path_str = pathname;
  char *real_path = realpath(pathname.c_str(), nullptr);
 
  if (real_path) {
    real_path_str = real_path;
    free(real_path);
  }
  return real_path_str;
#elif defined(_WIN32)
#if (!defined(WINRT))
  std::string real_path_str = pathname;
  DWORD retval = 0;
  TCHAR buffer[4096] = TEXT("");
 
  retval = GetFullPathName(pathname.c_str(), 4096, buffer, 0);
  if (retval != 0) {
    real_path_str = buffer;
  }
  return real_path_str;
#else
  throw(vpIoException(vpException::fatalError,
                      "Cannot get absolute path of %s: not implemented on "
                      "Universal Windows Platform",
                      pathname.c_str()));
#endif
#endif
}
 
std::string vpIoTools::createFilePath(const std::string &parent, const std::string &child)
{
  if ((child.size() == 0) && (parent.size() == 0)) {
    return "";
  }
 
  if (child.size() == 0) {
    return vpIoTools::path(parent);
  }
 
  if (parent.size() == 0) {
    return vpIoTools::path(child);
  }
 
  std::string convertedParent = vpIoTools::path(parent);
  std::string convertedChild = vpIoTools::path(child);
 
  std::stringstream ss;
  ss << vpIoTools::separator;
  std::string stringSeparator;
  ss >> stringSeparator;
 
  std::string lastConvertedParentChar = convertedParent.substr(convertedParent.size() - 1);
  std::string firstConvertedChildChar = convertedChild.substr(0, 1);
 
  if (lastConvertedParentChar == stringSeparator) {
    convertedParent = convertedParent.substr(0, convertedParent.size() - 1);
  }
 
  if (firstConvertedChildChar == stringSeparator) {
    convertedChild = convertedChild.substr(1);
  }
 
  return std::string(convertedParent + vpIoTools::separator + convertedChild);
}
 
bool vpIoTools::isAbsolutePathname(const std::string &pathname)
{
  // # Inspired by the Python 2.7.8 module.
  // # Return whether a path is absolute.
  // # Trivial in Posix, harder on the Mac or MS-DOS.
  // # For DOS it is absolute if it starts with a slash or backslash (current
  // # volume), or if a pathname after the volume letter and colon / UNC
  //  resource # starts with a slash or backslash.
  //
  //  def isabs(s):
  //     """Test whether a path is absolute"""
  //     s = splitdrive(s)[1]
  //     return s != '' and s[:1] in '/\\'
  std::string path = splitDrive(pathname).second;
  return (path.size() > 0) && ((path.substr(0, 1) == "/") || (path.substr(0, 1) == "\\"));
}
 
bool vpIoTools::isSamePathname(const std::string &pathname1, const std::string &pathname2)
{
  // Normalize path
  std::string path1_normalize = vpIoTools::path(pathname1);
  std::string path2_normalize = vpIoTools::path(pathname2);
 
  // Get absolute path
  path1_normalize = vpIoTools::getAbsolutePathname(path1_normalize);
  path2_normalize = vpIoTools::getAbsolutePathname(path2_normalize);
 
  return (path1_normalize == path2_normalize);
}
 
std::pair<std::string, std::string> vpIoTools::splitDrive(const std::string &pathname)
{
  // # Split a path in a drive specification (a drive letter followed by a
  // # colon) and the path specification.
  // # It is always true that drivespec + pathspec == p
  //  def splitdrive(p):
  //     """Split a pathname into drive/UNC sharepoint and relative path
  //     specifiers. Returns a 2-tuple (drive_or_unc, path); either part may be
  //     empty.
  //
  //     If you assign
  //         result = splitdrive(p)
  //     It is always true that:
  //         result[0] + result[1] == p
  //
  //     If the path contained a drive letter, drive_or_unc will contain
  //     everything up to and including the colon.  e.g. splitdrive("c:/dir")
  //     returns ("c:", "/dir")
  //
  //     If the path contained a UNC path, the drive_or_unc will contain the host
  //     name and share up to but not including the fourth directory separator
  //     character. e.g. splitdrive("//host/computer/dir") returns
  //     ("//host/computer", "/dir")
  //
  //     Paths cannot contain both a drive letter and a UNC path.
  //
  //     """
  //     if len(p) > 1:
  //         normp = p.replace(altsep, sep)
  //         if (normp[0:2] == sep*2) and (normp[2] != sep):
  //             # is a UNC path:
  //             # vvvvvvvvvvvvvvvvvvvv drive letter or UNC path
  //             # \\machine\mountpoint\directory\etc\...
  //             #           directory ^^^^^^^^^^^^^^^
  //             index = normp.find(sep, 2)
  //             if index == -1:
  //                 return '', p
  //             index2 = normp.find(sep, index + 1)
  //             # a UNC path can't have two slashes in a row
  //             # (after the initial two)
  //             if index2 == index + 1:
  //                 return '', p
  //             if index2 == -1:
  //                 index2 = len(p)
  //             return p[:index2], p[index2:]
  //         if normp[1] == ':':
  //             return p[:2], p[2:]
  //     return '', p
 
  // On Unix, the drive is always empty.
  // On the Mac, the drive is always empty (don't use the volume name -- it
  // doesn't have the same  syntactic and semantic oddities as DOS drive
  // letters, such as there being a separate current directory per drive).
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__)))
  return std::pair<std::string, std::string>("", pathname);
#else
  const std::string sep = "\\";
  const std::string sepsep = "\\\\";
  const std::string altsep = "/";
 
  if (pathname.size() > 1) {
    std::string normPathname = pathname;
    std::replace(normPathname.begin(), normPathname.end(), *altsep.c_str(), *sep.c_str());
 
    if (normPathname.substr(0, 2) == sepsep && normPathname.substr(2, 1) != sep) {
      // is a UNC path:
      // vvvvvvvvvvvvvvvvvvvv drive letter or UNC path
      // \\machine\mountpoint\directory\etc\...
      //           directory ^^^^^^^^^^^^^^^
      size_t index = normPathname.find(sep, 2);
      if (index == std::string::npos) {
        return std::pair<std::string, std::string>("", pathname);
      }
 
      size_t index2 = normPathname.find(sep, index + 1);
      // # a UNC path can't have two slashes in a row
      // # (after the initial two)
      if (index2 == index + 1) {
        return std::pair<std::string, std::string>("", pathname);
      }
 
      if (index2 == std::string::npos) {
        index2 = pathname.size();
      }
 
      return std::pair<std::string, std::string>(pathname.substr(0, index2), pathname.substr(index2));
    }
 
    if (normPathname[1] == ':') {
      return std::pair<std::string, std::string>(pathname.substr(0, 2), pathname.substr(2));
    }
  }
 
  return std::pair<std::string, std::string>("", pathname);
#endif
}
 
std::vector<std::string> vpIoTools::splitChain(const std::string &chain, const std::string &sep)
{
  size_t startIndex = 0;
 
  std::string chainToSplit = chain;
  std::vector<std::string> subChain;
  size_t sepIndex = chainToSplit.find(sep);
 
  while (sepIndex != std::string::npos) {
    std::string sub = chainToSplit.substr(startIndex, sepIndex);
    if (!sub.empty()) {
      subChain.push_back(sub);
    }
    chainToSplit = chainToSplit.substr(sepIndex + 1, chain.size() - 1);
 
    sepIndex = chainToSplit.find(sep);
  }
  if (!chainToSplit.empty()) {
    subChain.push_back(chainToSplit);
  }
 
  return subChain;
}
 
std::vector<std::string> vpIoTools::getDirFiles(const std::string &pathname)
{
 
  if (!checkDirectory(pathname)) {
    throw(vpIoException(vpException::fatalError, "Directory %s doesn't exist'", pathname.c_str()));
  }
  std::string dirName = path(pathname);
 
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
 
  std::vector<std::string> files;
  struct dirent **list = nullptr;
  int filesCount = scandir(dirName.c_str(), &list, nullptr, nullptr);
  if (filesCount == -1) {
    throw(vpIoException(vpException::fatalError, "Cannot read files of directory %s", dirName.c_str()));
  }
  for (int i = 0; i < filesCount; ++i) {
    std::string fileName = list[i]->d_name;
    if ((fileName != ".") && (fileName != "..")) {
      files.push_back(fileName);
    }
    free(list[i]);
  }
  free(list);
  std::sort(files.begin(), files.end());
  return files;
 
#elif defined(_WIN32)
#if (!defined(WINRT))
 
  std::vector<std::string> files;
  std::string fileMask = dirName;
  fileMask.append("\\*");
  WIN32_FIND_DATA FindFileData;
  HANDLE hFind = FindFirstFile(fileMask.c_str(), &FindFileData);
  // Directory is empty
  if (HandleToLong(&hFind) == ERROR_FILE_NOT_FOUND) {
    return files;
  }
  if (hFind == INVALID_HANDLE_VALUE) {
    throw(vpIoException(vpException::fatalError, "Cannot read files of directory %s", dirName.c_str()));
  }
  do {
    std::string fileName = FindFileData.cFileName;
    if (fileName != "." && fileName != "..") {
      files.push_back(fileName);
    }
  } while (FindNextFile(hFind, &FindFileData));
  FindClose(hFind);
  std::sort(files.begin(), files.end());
  return files;
 
#else
  throw(vpIoException(vpException::fatalError,
                      "Cannot read files of directory %s: not implemented on "
                      "Universal Windows Platform",
                      dirName.c_str()));
#endif
#endif
}
 
void vpIoTools::readBinaryValueLE(std::ifstream &file, int16_t &short_value)
{
  file.read((char *)(&short_value), sizeof(short_value));
 
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order from little endian to big endian
  short_value = vpEndian::swap16bits((uint16_t)short_value);
#endif
}
 
void vpIoTools::readBinaryValueLE(std::ifstream &file, uint16_t &ushort_value)
{
  file.read((char *)(&ushort_value), sizeof(ushort_value));
 
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order from little endian to big endian
  ushort_value = vpEndian::swap16bits(ushort_value);
#endif
}
 
void vpIoTools::readBinaryValueLE(std::ifstream &file, int32_t &int_value)
{
  file.read((char *)(&int_value), sizeof(int_value));
 
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order from little endian to big endian
  int_value = vpEndian::swap32bits((uint32_t)int_value);
#endif
}
 
void vpIoTools::readBinaryValueLE(std::ifstream &file, uint32_t &uint_value)
{
  file.read((char *)(&uint_value), sizeof(uint_value));
 
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order from little endian to big endian
  uint_value = vpEndian::swap32bits(uint_value);
#endif
}
 
void vpIoTools::readBinaryValueLE(std::ifstream &file, float &float_value)
{
  file.read((char *)(&float_value), sizeof(float_value));
 
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order from little endian to big endian
  float_value = vpEndian::swapFloat(float_value);
#endif
}
 
void vpIoTools::readBinaryValueLE(std::ifstream &file, double &double_value)
{
  file.read((char *)(&double_value), sizeof(double_value));
 
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order from little endian to big endian
  double_value = vpEndian::swapDouble(double_value);
#endif
}
 
void vpIoTools::writeBinaryValueLE(std::ofstream &file, const int16_t short_value)
{
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order to little endian
  uint16_t swap_short = vpEndian::swap16bits((uint16_t)short_value);
  file.write((char *)(&swap_short), sizeof(swap_short));
#else
  file.write((char *)(&short_value), sizeof(short_value));
#endif
}
 
void vpIoTools::writeBinaryValueLE(std::ofstream &file, const uint16_t ushort_value)
{
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order to little endian
  uint16_t swap_ushort = vpEndian::swap16bits(ushort_value);
  file.write((char *)(&swap_ushort), sizeof(swap_ushort));
#else
  file.write((char *)(&ushort_value), sizeof(ushort_value));
#endif
}
 
void vpIoTools::writeBinaryValueLE(std::ofstream &file, const int32_t int_value)
{
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order to little endian
  uint32_t swap_int = vpEndian::swap32bits((uint32_t)int_value);
  file.write((char *)(&swap_int), sizeof(swap_int));
#else
  file.write((char *)(&int_value), sizeof(int_value));
#endif
}
 
void vpIoTools::writeBinaryValueLE(std::ofstream &file, const uint32_t uint_value)
{
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order to little endian
  uint32_t swap_int = vpEndian::swap32bits(uint_value);
  file.write((char *)(&swap_int), sizeof(swap_int));
#else
  file.write((char *)(&uint_value), sizeof(uint_value));
#endif
}
 
void vpIoTools::writeBinaryValueLE(std::ofstream &file, float float_value)
{
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order to little endian
  float swap_float = vpEndian::swapFloat(float_value);
  file.write((char *)(&swap_float), sizeof(swap_float));
#else
  file.write((char *)(&float_value), sizeof(float_value));
#endif
}
 
void vpIoTools::writeBinaryValueLE(std::ofstream &file, double double_value)
{
#ifdef VISP_BIG_ENDIAN
  // Swap bytes order to little endian
  double swap_double = vpEndian::swapDouble(double_value);
  file.write((char *)(&swap_double), sizeof(swap_double));
#else
  file.write((char *)(&double_value), sizeof(double_value));
#endif
}
 
bool vpIoTools::parseBoolean(std::string input)
{
  std::transform(input.begin(), input.end(), input.begin(), ::tolower);
  std::istringstream is(input);
  bool b;
  // Parse string to boolean either in the textual representation
  // (True/False)  or in numeric representation (1/0)
  is >> (input.size() > 1 ? std::boolalpha : std::noboolalpha) >> b;
  return b;
}
 
std::string vpIoTools::trim(std::string s) { return ltrim(rtrim(s)); }