IOUtils.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003-2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS 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 2.1 of the License, or
 (at your option) any later version.

 BIAS 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 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <Utils/IOUtils.hh>

#include <Base/Image/ImageConvert.hh>
#include <Base/Common/FileHandling.hh>
#include <string>

using namespace std;
using namespace BIAS;

#ifdef WIN32
#define SEPERATOR ";"
#define SUBDIRSEP "\\"
#else
#define SEPERATOR ":"
#define SUBDIRSEP "/"
#endif

bool IOUtils::
    ExtractSubPaths(const std::string& environmentVariable,
                   std::vector<std::string>& subPaths)
{

  if (getenv(environmentVariable.c_str()) == NULL)
  {
    BIASWARN("environment variable "<<environmentVariable<<" not found");
    return false;
  }

  string concatenatedPaths(getenv(environmentVariable.c_str()));

  //vector<string> subPaths;
  vector<unsigned int> seperators;//positions of seperators
  string::size_type index = concatenatedPaths.find(SEPERATOR, 0);
  while (index != string::npos)
    {
      seperators.push_back(index);
      index++;
      index = concatenatedPaths.find(SEPERATOR, index);
    }
  seperators.push_back(concatenatedPaths.size());

  subPaths.push_back(concatenatedPaths.substr(0, seperators[0]));
  for (unsigned int i = 0; i < seperators.size() - 1; i++)
    {
      subPaths.push_back(concatenatedPaths.substr(seperators[i] + 1,
          seperators[i + 1] - seperators[i] - 1));
    }
  return true;
}


bool
IOUtils::FindFile(const std::string& searchPaths,
    const std::string& baseFileName, std::string& fullFileName)
{
  bool found = false;
  //  string sp = searchPaths;
  vector<string> subPaths;
  vector<unsigned int> seperators;
  string::size_type index = searchPaths.find(SEPERATOR, 0);
  while (index != string::npos)
    {
      seperators.push_back(index);
      index++;
      index = searchPaths.find(SEPERATOR, index);
    }
  seperators.push_back(searchPaths.size());

  subPaths.push_back(searchPaths.substr(0, seperators[0]));
  for (unsigned int i = 0; i < seperators.size() - 1; i++)
    {
      subPaths.push_back(searchPaths.substr(seperators[i] + 1,
          seperators[i + 1] - seperators[i] - 1));
    }

  for (unsigned int i = 0; i < subPaths.size() && !found; i++)
    {
      fullFileName = subPaths[i];
      fullFileName += SUBDIRSEP;
      fullFileName += baseFileName;
      found = FileHandling::FileExists(fullFileName);
    }
  return found;
}

/** Like FindFile but reads out the searchPath from the specified environmentVariable.
 **/
bool
IOUtils::FindFileEnv(const std::string& environmentVariable,
    const std::string& baseFileName, std::string& fullFileName)
{

  if (getenv(environmentVariable.c_str()) == NULL)
    {
        BIASWARN("environment variable "<<environmentVariable<<" not found");
      return false;
    }
  return FindFile(getenv(environmentVariable.c_str()), baseFileName,
      fullFileName);
}

bool
IOUtils::FindShaderFile(const string& shaderFileName, string& res)
{
  if (!IOUtils::FindFileEnv("SHADERSRC", shaderFileName, res))
    {
      cout << "failed loading shader " << shaderFileName << endl;
      return false;
    }
  return true;
}

string
IOUtils::ExtendOutName(const std::string& outname, const std::string& suffix,
    const std::string& extension)
{
  string path, base, ext;
  FileHandling::SplitName(outname, path, base, ext);
  path = FileHandling::StripTerminatingSlash(path);
  if (path.size() == 0)
    path = ".";
  string pathbase;
#ifdef WIN32
  pathbase = path + "\\"+ base;
#else
  pathbase = path + "/" + base;
#endif

  return (pathbase + "_" + extension + "." + suffix);
}

string
IOUtils::ExtendOutName(const std::string& outname, const std::string& extension)
{
  string path, base, ext;
  FileHandling::SplitName(outname, path, base, ext);
  path = FileHandling::StripTerminatingSlash(path);
  if (path.size() == 0)
    path = ".";
  string pathbase;
#ifdef WIN32
  pathbase = path + "\\"+ base;
#else
  pathbase = path + "/" + base;
#endif

  return (pathbase + "_" + extension + ext);
}


bool
IOUtils::ParseCommandLineEvalHelp(Param& params, int argc, char* argv[])
{
  int miscGrpID = params.GetFreeGroupID();
  bool* help = params.AddParamBool("help", "Display help message", false, 'h', miscGrpID);
  params.SetGroupName(miscGrpID, "Misc");

  params.ParseCommandLine(argc, argv);
  if (*help)
    {
      params.Usage();
      return false;
    }
  return true;
}

bool
IOUtils::ParseCommandLineEvalHelp(Param& params, int argc, char* argv[],
    int& fup)
{
  int miscGrpID = params.GetFreeGroupID();
  bool* help = params.AddParamBool("help", "Display help message", false, 'h', miscGrpID);
  params.SetGroupName(miscGrpID, "Misc");

  fup = params.ParseCommandLine(argc, argv);
  if (*help)
    {
      params.Usage();
      return false;
    }
  return true;
}

void
IOUtils::PrintWithLineNumbers(const std::string& text, std::ostream& out)
{
  std::istringstream in(text);
  int lineNumber = 1;
  std::string line;
  while (std::getline(in, line))
    {
      out.width(3);
      out << lineNumber << " | " << line << std::endl;
      lineNumber++;
    }
}

#ifdef BIAS_HAVE_XML2
bool
IOUtils::GetProjectionParametersPerspective(ImageBase& imgBase,
    BIAS::ProjectionParametersPerspective*& ppp)
{
  Projection tempProj;
  if (!GetProjection(imgBase, tempProj))
    {
      return false;
    }
  else
    {
      if (!CheckTypeDelete(tempProj.GetParameters()->Clone(), ppp))
        {
            BIASERR("contained projection is not of type projection parameters perspective!");
          return false;
        }
      return true;
    }
}

bool
IOUtils::GetProjection(ImageBase& imgBase, Projection& projOut)
{
  AppData ad;
  MetaData* MD = imgBase.GetMetaData();
  if (MD->Find(AppData::MD_Projection, "#[Projection]", ad) >= 0)
    {
      // BIASDOUT(D_CAMERAMD, "found Projection");
      std::string flatproj;
      if (ad.tag == AppData::MD_USE_ASCII)
        flatproj = ad.sdata;

      else
        {
          char *tmp = new char[ad.length + 1];
          memcpy(tmp, ad.data, ad.length);
          tmp[ad.length] = 0;
          flatproj = tmp;
          //flatproj = flatproj.substr(0,ad.length);
          delete[] tmp;
          //cout << flatproj;
        }

      int res = projOut.XMLReadFromString(flatproj);
      if (res < 0)
        {
            BIASERR("Failed to parse string with length: "<<ad.length<<" string: "
                <<flatproj);
          return false;
        }
      //Proj_.GetParameters()->ValidatePose();
      if (!projOut.GetParameters()->PoseValid())
        {
            BIASERR("returning invalid pose!");
          return false;
        }

      return true;

    }
  return false;
}

#endif //BIAS_HAVE_XML2
void
IOUtils::ProgressIndicator::operator++(int)
{
  switch (indicatorState)
    {
  case 0:
    std::cerr << "|";
    break;
  case 1:
    std::cerr << "/";
    break;
  case 2:
    std::cerr << "-";
    break;
  case 3:
    std::cerr << "\\";
    break;
    }
  std::cerr << "\b";
  std::cerr << std::flush;
  indicatorState++;
  if (indicatorState > 3)
    indicatorState = 0;
}

void
IOUtils::ProgressIndicator::Reset()
{
  indicatorState = 0;
}

void
IOUtils::ProgressBar::Init(const int steps)
{
  incrementThreshold_ = 1;
  incrementPos_ = 0;
  std::cerr << "[" << std::flush;
  for (int i = 0; i < steps; i++)
    {
      std::cerr << "-";
    }
  std::cerr << "]\r[" << std::flush;
}

void
IOUtils::ProgressBar::Init(const int steps, const int maxLength)
{
  if (steps <= maxLength)
    {
      Init(steps);
    }
  else
    {
      float n = static_cast<float> (steps) / static_cast<float> (maxLength);
      Init(maxLength);
      incrementThreshold_ = static_cast<int> (ceil(n));
    }

}

void
IOUtils::ProgressBar::operator++(int)
{
  if (++incrementPos_ == incrementThreshold_)
    {
      if (clear_)
        std::cerr << "\b";
      std::cerr << "|" << std::flush;
      incrementPos_ = 0;
    }
}

bool
IOUtils::LoadFloat(const std::string& filename, BIAS::Image<float>& outcome)
{
  ImageBase img;
  if (ImageIO::Load(filename, img) != 0)
    {
        BIASERR("could not load specified image named: "<<filename);
      return false;
    }
  switch (img.GetStorageType())
    {
  case ImageBase::ST_float:
    outcome = img;
    outcome.SetMetaData(*img.GetMetaData());
    break;
  default:
    outcome.Init(img.GetWidth(), img.GetHeight(), img.GetChannelCount());
    if (ImageConvert::ConvertST(img, outcome, ImageBase::ST_float) != 0)
      {
          BIASERR("could not convert storage type!");
        return false;
      }
    break;

    }

  return true;
}

bool
IOUtils::SaveForPlot(const std::string& filename,
    const std::vector<double>& x_vector, const std::vector<double>& y_vector)
{
  BIASASSERT(x_vector.size() == y_vector.size());
  std::ofstream fs(filename.c_str());
  if (!fs)
    {
      return false; // error, could not open file.
    }
  else
    {
      // write out to disk
      for (unsigned int row = 0; row < x_vector.size(); row++)
        {
          fs << x_vector[row] << "\t" << y_vector[row] << "\n";
        }
      fs.close();
    };
  return true;
}


bool
IOUtils::LoadImage(
      const std::string& fileName,
      ImageBase& img,
      unsigned int& width,
      unsigned int& height,
      unsigned int& channels)
{
  if(ImageIO::Load(fileName, img)!=0) {
    BIASERR("could not load image named "<<fileName);
    return false;
  }
  width = img.GetWidth();
  height = img.GetHeight();
  channels = img.GetChannelCount();

  return true;
}

bool 
IOUtils::ReadIn2DPointList(const std::string& fileName,
                           std::vector<BIAS::Vector2<int> >& pointLst)
{
  std::ifstream ifs(fileName.c_str());
  if (!ifs) {
      ifs.close();
      return false; // error, could not open file.
    }
  else {
    Vector2<int> pt;
    while(ifs) {
      
      ifs >> pt[0] ;
      ifs >> pt[1] ;
      
      pointLst.push_back(pt);

    }
  };
  ifs.close();
  return true;
  
}


bool 
IOUtils::ReadIn2DPointList(const std::string& fileName,
                           std::vector<unsigned int>& xPos,
                           std::vector<unsigned int>& yPos)
{
  std::ifstream ifs(fileName.c_str());
  if (!ifs) {
      ifs.close();
      return false; // error, could not open file.
    }
  else {
    unsigned int x, y;
    while(ifs) {
      
      ifs >> x ;
      ifs >> y ;
      
      xPos.push_back(x);
      yPos.push_back(y);

    }
  };
  ifs.close();
  return true;
  
}