IOUtils.hh

/*
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
*/

#ifndef _IO_UTILS__HH_
#define _IO_UTILS__HH_

#include <bias_config.h>
#include <Utils/Param.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/Image/MetaData.hh>
#include <Image/Camera.hh>
#include <Geometry/Projection.hh>
#include <iostream>
#include <sstream>

namespace BIAS{
  /**
   * \class IOUtils
   * \brief Class grouping together some IO code often used in (small) application,
   * like loading images, parsing their meta data etc.
   * \ingroup g_utils
   * \author bartczak 01/2008
   */
  class BIASUtils_EXPORT IOUtils {
  public:

    /** Takes in the name of a text file, that contains an image file-name per line, tries to load these 
     * images into the vector.
     * \returns false if not usccesfull in loading any image.
     **/
    template<class type>
      static bool LoadImageList(const std::string& listFileName,
                                std::vector<Image<type> >& imgs,
                                const bool verbose = false)  {
      std::vector<std::string> imageNameList;
      if(Param::ParseListFile(listFileName, imageNameList)!=0) {
        BIASERR("could not read list file");
        return false;
      }
      imgs.clear();
      unsigned int num = imageNameList.size();
      imgs.resize(num);
      for(unsigned int i=0; i<num; i++) {
        if(verbose) std::cout<<"loading "<<imageNameList[i]<<"... "<<std::flush;
        if(ImageIO::Load(imageNameList[i], imgs[i])!=0){
          if(verbose) std::cout<<"failed!\n";
          imgs.clear();
          return false;
        }
        if(verbose) std::cout<<"ok\n";
      }
      return true;
    }

#ifdef BIAS_HAVE_XML2
    template<class type>
      static bool LoadImageList(const std::string& listFileName,
                                std::vector<Image<type> >& imgs,
                                std::vector<ProjectionParametersPerspective*>& ppp,
                                const bool verbose = false)  {
      std::vector<std::string> imageNameList;
      if(Param::ParseListFile(listFileName, imageNameList)!=0) {
        BIASERR("could not read list file");
        return false;
      }
      imgs.clear();
      unsigned int num = imageNameList.size();
      imgs.resize(num);
      ppp.resize(num, NULL);
      for(unsigned int i=0; i<num; i++) {
        if(verbose) std::cout<<"loading "<<imageNameList[i]<<"... "<<std::flush;
        if(!IOUtils::LoadCamera(&(imageNameList[i]), imgs[i], ppp[i])){
          if(verbose) std::cout<<"failed!\n";
          imgs.clear();
          for(unsigned int j=0; j<i; j++) {
            delete ppp[j];
          }
          ppp.clear();
          return false;
        }
        if(verbose) std::cout<<"ok\n";
      }
      return true;
    }


    static bool LoadImageList(const std::string& listFileName,
                                std::vector<ImageBase>& imgs,
                                std::vector<ProjectionParametersPerspective*>& ppp,
                                const bool verbose = false)  {
      std::vector<std::string> imageNameList;
      if(Param::ParseListFile(listFileName, imageNameList)!=0) {
        BIASERR("could not read list file");
        return false;
      }
      imgs.clear();
      unsigned int num = (unsigned int)imageNameList.size();
      imgs.resize(num);
      ppp.resize(num, NULL);
      for(unsigned int i=0; i<num; i++) {
        if(verbose) std::cout<<"loading "<<imageNameList[i]<<"... "<<std::flush;
        if(!IOUtils::LoadCamera(&(imageNameList[i]), imgs[i], ppp[i])){
          if(verbose) std::cout<<"failed!\n";
          imgs.clear();
          for(unsigned int j=0; j<i; j++) {
            delete ppp[j];
          }
          ppp.clear();
          return false;
        }
        if(verbose) std::cout<<"ok\n";
      }
      return true;
    }

    static bool LoadImageList(const std::string& listFileName,
                                std::vector<ImageBase>& imgs,
                                std::vector<ProjectionParametersPerspective>& ppp,
                                const bool verbose = false)  {
      std::vector<ProjectionParametersPerspective*> pppPntr;
      if(!LoadImageList(listFileName, imgs, pppPntr, verbose)) return false;
      
      ppp.clear();
      ppp.reserve(pppPntr.size());
      for(unsigned int i=0; i<pppPntr.size(); i++)
        ppp.push_back(*(pppPntr[i]));
      
      return true;
    }

#endif

    /** Appends 2D points read in from file to vector.
     **/
    static bool ReadIn2DPointList(const std::string& fileName,
                                  std::vector<BIAS::Vector2<int> >& pointLst);

    static bool ReadIn2DPointList(const std::string& fileName,
                                  std::vector<unsigned int>& xPos,
                                  std::vector<unsigned int>& yPos);
    
    template<class T>
      static bool Write2DPointWithDatumList(const std::string& fileName,
                                            std::vector<unsigned int>& xPos,
                                            std::vector<unsigned int>& yPos,
                                            std::vector<T>& datum) {
      
      BIASASSERT(xPos.size() == yPos.size());
      BIASASSERT(xPos.size() == datum.size());
      
      std::ofstream ofs(fileName.c_str());
      if (!ofs) {
        ofs.close();
        return false; // error, could not open file.
      }
      else {
        for(unsigned int i=0; i<xPos.size(); i++) {

          if(!ofs) {
            ofs.close(); 
            return false; 
          }
          ofs << xPos[i] <<"\t";
          ofs << yPos[i]<<"\t";
          ofs << datum[i]<<"\n";

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


    /**
     * @brief Reads a list of 2D points from a text file and appends them to the
     *        given vector.
     *
     * @param fileName
     *        the name of the file to read from
     * @param pointList
     *        the list to add the points, note that it is not cleared so the 
     *        points are appended
     *
     * @return true on success or false if the file was not found
     */
    template<class T>
    static bool ReadIn2DPointList(const std::string &fileName,
                                  std::vector<BIAS::Vector2<T> > &pointList) {
      std::ifstream ifs(fileName.c_str());
      
      if (!ifs) { // could not open file
        ifs.close();
        return false;
      }
      
      Vector2<T> pt;
      
      while (ifs) {
        ifs >> pt[0];
        ifs >> pt[1];
        
        pointList.push_back(pt);
      }
      
      ifs.close();
      return true;
    }


    /**
     * @brief Reads a list of 3D points from a text file and appends them to the
     *        given vector.
     *
     * @param fileName
     *        the name of the file to read from
     * @param pointList
     *        the list to add the points, note that it is not cleared so the 
     *        points are appended
     *
     * @return true on success or false if the file was not found
     */
    template<class T>
    static bool ReadIn3DPointList(const std::string &fileName,
                                  std::vector<BIAS::Vector3<T> > &pointList) {
      std::ifstream ifs(fileName.c_str());
      
      if (!ifs) { // could not open file
        ifs.close();
        return false;
      }
      
      Vector3<T> pt;
      
      while (ifs) {
        ifs >> pt[0];
        ifs >> pt[1];
        ifs >> pt[2];
        
        pointList.push_back(pt);
      }
      
      ifs.close();
      return true;
    }


      /** Will take outname which is assumed to be of path/base.ext structure and will 
          build path/base_extension.suffix from it.
      **/
      static std::string ExtendOutName(const std::string& outname, const std::string& suffix,
                                       const std::string& extension);

      /** Will take outname which is assumed to be of path/base.ext structure and will 
          build path/base_extension.ext from it.
      **/
      static std::string ExtendOutName(const std::string& outname, const std::string& extension);


      /** Seperates out the paths that are contained in a list of
        * directories that are stored in an environment variable
       **/
      static bool ExtractSubPaths(const std::string& environmentVariable,
                                  std::vector<std::string>& subPaths);

      /** Searches for the file specified by baseFileName in the
       * specified searchPaths.
       * \param searchPaths is a string like returned by getenv, i.e. a path list seperated by a colon
       * for Linux or a path list seperated by a semicolon for windows
       * \param returns true if file was found;
       **/
      static bool FindFile(const std::string& searchPaths,
                           const std::string& baseFileName,
                           std::string& fullFileName);

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

      /** Convenience wrapper to using SHADERSRC environment variable
       */
      static bool FindShaderFile(const std::string& shaderFileName, std::string& res);

      static bool LoadImage(
                            const std::string& fileName, 
                            ImageBase& img, 
                            unsigned int& width,
                            unsigned int& height,
                            unsigned int& channels);

      template<class dataType>
        static bool LoadCamera(std::string* fileName,
                               BIAS::Camera<dataType>& cam)
      {
        if(ImageIO::Load(*fileName, cam)!=0) {
          BIASERR("could not load camera: "<<*fileName);
          return false;
        }
        return true;
      }

      template<class dataType>
        static bool LoadCamera(const std::string& fileName,
                               BIAS::Camera<dataType>& cam)
      {
        if(ImageIO::Load(fileName, cam)!=0) {
          BIASERR("could not load camera: "<<fileName);
          return false;
        }
        return true;
      }


      template<class dataType>
        static bool LoadCamera(std::string* fileName,
                               BIAS::Camera<dataType>& cam,
                               BIAS::Projection& proj)
      {
        if(!LoadCamera<dataType>(fileName, cam))
          return false;

        if(cam.ParseMetaData()<0) {
          BIASERR("could not parse metadata from file: "<<*fileName);
          return false;
        }
        proj = cam.GetProj();
        return true;
      }

      template<class dataType>
        static bool LoadCamera(const std::string& fileName,
                               BIAS::Camera<dataType>& cam,
                               BIAS::Projection& proj)
      {
        if(!LoadCamera<dataType>(fileName, cam))
          return false;

        if(cam.ParseMetaData()<0) {
          BIASERR("could not parse metadata from file: "<<fileName);
          return false;
        }
        proj = cam.GetProj();
        return true;
      }

      template<class dataType>
        static bool LoadCamera(const std::string& fileName,
                               BIAS::Camera<dataType>& cam,
                               BIAS::Projection& proj,
                               unsigned int& width,
                               unsigned int& height,
                               unsigned int& channels)
      {
        std::string fileNameBak = fileName;
        if(!LoadCamera<dataType>(&fileNameBak, cam, proj))
          return false;

        width = cam.GetWidth();
        height = cam.GetHeight();
        channels = cam.GetChannelCount();
      
        return true;
      }

      template<class dataType>
        static bool SaveCamera(const std::string& fileName,
                               const BIAS::Camera<dataType>& cam)
      {        
        if(ImageIO::Save(fileName, cam)!=0) {
          BIASERR("could not save camera: "<<fileName);
          return false;
        }
        return true;
      }

      template<class dataType>
        static bool SaveCamera(const std::string& fileName,
                               BIAS::Camera<dataType>& cam,
                               const BIAS::Projection& proj)
      {
        cam.SetProj(proj);
        cam.UpdateMetaData();
        if(!SaveCamera<dataType>(fileName, cam))
          return false;

        return true;
      }

      /** \brief parses the command line, adds parameter "help" */
      static bool ParseCommandLineEvalHelp(Param& params,
                                             int argc, char* argv[]);
      /** \brief parses the command line, adds parameter "help"
       *  and return first unknown parameter in fup */
      static bool ParseCommandLineEvalHelp(Param& params,
                                           int argc, char* argv[],
                                           int& fup);


      template<class ptType, class inPtType>
        static bool CheckType(inPtType* checked, ptType*& result) {
        result = dynamic_cast<ptType*>(checked);
        if(result == NULL) {
          return false;
        }
        return true;
      }

      template<class ptType, class inPtType>
        static bool CheckTypeDelete(inPtType* checked, ptType*& result) {
        result = dynamic_cast<ptType*>(checked);
        if(result == NULL) {
          delete [] checked;
          return false;
        }
        return true;
      }

      static bool LoadParameters(const std::string* fileName,
                                 BIAS::ProjectionParametersPerspective*& ppp) {
        Projection tempProj;
        if(tempProj.Load(*fileName)!=0) {
          BIASERR("could not load projection from "<<fileName);
          return false;
        }
        if(!CheckTypeDelete(tempProj.GetParameters()->Clone(),ppp)) {
          BIASERR("projection file is not of type projection parameters perspective!");
          return false;
        }
        return true;
      }

      static void PrintWithLineNumbers(const std::string& text, std::ostream& out = std::cout);

      static int GetApplicationMemory() {
#ifndef WIN32
        long int totalmemory = 0;
        std::ifstream memfile("/proc/self/statm");
        memfile >> totalmemory;      
        return totalmemory;
#else
        return 0;
#endif
      }

#ifdef BIAS_HAVE_XML2
      /** This is the implementation found in Camera::ParseMetaData() !
       * It allows to extract the Projection from ImageBase without the unconvenient
       * type determination.
       * \returns true if a valid pose was found.
       **/
      static bool GetProjection(ImageBase& imgBase, Projection& projOut);
      static bool GetProjectionParametersPerspective(ImageBase& imgBase,
                                                     BIAS::ProjectionParametersPerspective*& ppp);
      static bool LoadCamera(const std::string* fileName,
                             BIAS::ImageBase& cam,
                             BIAS::Projection& proj)
      {
        if(ImageIO::Load(*fileName, cam)!=0) {
          BIASERR("could not load the image file! : "<<*fileName);
          return false;
        }

        if(!GetProjection(cam, proj)) {
          BIASERR("could not retrive projection.");
          return false;
        }

        return true;
      }

      static bool LoadCamera(const std::string* fileName,
                             BIAS::ImageBase& cam,
                             BIAS::ProjectionParametersPerspective*& ppp)
      {
        Projection tempProj;
        if(!LoadCamera(fileName, cam, tempProj)) return false;
        if(!CheckTypeDelete(tempProj.GetParameters()->Clone(),ppp)) {
          BIASERR("meta data do not contain projection parameters perspective!");
          return false;
        }
        return true;
      }

      template<class dataType>
        static bool LoadCamera(const std::string& fileName,
                               BIAS::Camera<dataType>& cam,
                               BIAS::ProjectionParametersPerspective*& proj,
                               unsigned int& width,
                               unsigned int& height,
                               unsigned int& channels)
      {
        std::string fileNameBak = fileName;
        if(!LoadCamera(&fileNameBak, cam, proj))
          return false;
        
        width = cam.GetWidth();
        height = cam.GetHeight();
        channels = cam.GetChannelCount();
      
        return true;
      }

      static bool LoadCamera(const std::string* fileName,
                             BIAS::ImageBase& cam,
                             BIAS::ProjectionParametersPerspectiveDepth*& ppp)
      {
        Projection tempProj;
        if(!LoadCamera(fileName, cam, tempProj)) return false;
        if(!CheckTypeDelete(tempProj.GetParameters()->Clone(),ppp)) {
          BIASERR("meta data do not contain projection parameters perspective depth!");
          return false;
        }
        return true;
      }

      template<class dataType>
        static bool LoadCamera(const std::string& fileName,
                               BIAS::Camera<dataType>& cam,
                               BIAS::ProjectionParametersPerspectiveDepth*& proj,
                               unsigned int& width,
                               unsigned int& height,
                               unsigned int& channels)
      {
        std::string fileNameBak = fileName;
        if(!LoadCamera(&fileNameBak, cam, proj))
          return false;
        
        width = cam.GetWidth();
        height = cam.GetHeight();
        channels = cam.GetChannelCount();
      
        return true;
      }




#endif //BIAS_HAVE_XML2

      struct BIASUtils_EXPORT ProgressIndicator {

        ProgressIndicator() : indicatorState(0) {};
        void Reset();
        void operator++(int);
        unsigned int indicatorState;
      };

      class BIASUtils_EXPORT ProgressBar {
      public:
        ProgressBar(bool cl=false) :
          clear_(cl), incrementThreshold_(1), incrementPos_(0)  {};
        void Init(const int steps);
        /** From **/
        void Init(const int steps, const int maxLength);
        void operator++(int);

      private:
        bool clear_;
        unsigned int incrementThreshold_;
        unsigned int incrementPos_;

      };

      static bool LoadFloat(const std::string& filename, BIAS::Image<float>& outcome);

      static bool SaveForPlot(const std::string& filename, const std::vector<double>& x_vector, const std::vector<double>& y_vector);

    };

  } //end of namespace

#endif