biastrianglemesh.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/ThreeDOut.hh>
#ifdef BIAS_HAVE_OPENSCENEGRAPH
#include <GLviewer/ThreeDOutOpenSceneGraph.hh>
#endif
#include <Utils/TriangleMesh.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/Image/ImageConvert.hh>
#include <Filter/Rescale.hh>
#include <Base/Common/FileHandling.hh>
#include <Image/Camera.hh>
#include <Utils/Param.hh>

#include <sstream>
#include <iostream>

using namespace std;
using namespace BIAS;

#define TILE_WIDTH 129
#define TILE_HEIGHT 129


/**
    @file
    @ingroup g_tools
    @brief   generate triangle mesh from depth map, see biastrianglemesh.cpp
    @author  mfranke
*/

//////////////////////////// methods for triangle mesh computation ///////////////////////////////
//
// Level of detail downsamples the depth map and its projection, can be used
// with any meshing method
//
// Different meshing methods available through here
//
// tile mode -------on-------> mesh is created in single tiles by using naive
//      |                      pixelwise method
//      |
//      off
//      |
//      |
//
//   reduce!= 0 ------ yes ----> method for mesh reduction by % of the triangles
//     |
//     |
//     |
//     |
//    no
//     |
//     |
//     |
//
//     calling simplified mesh method
//     starting on a coarse pyramid level, triangles of the mesh are
//     refined using the finer levels if necessary
//
//
//////////////////////////////////////////////////////////////////////////////////////////

int main(int argc, char *argv[])
{
  Param params(true);

  /**** GENERAL PARAMS ****/
  int generalGroupID = params.GetFreeGroupID();

  bool* help = params.AddParamBool("help",
                                   "print out help",
                                   false, 'h',
                                   generalGroupID);

  params.SetGroupName(generalGroupID, "general");


  /**** INPUT PARAMS ****/
  int inputParamGroupID = params.GetFreeGroupID();

  string* inputDepthMap = params.AddParamString("DepthMap",
                                                "specify depth map",
                                                "",
                                                'D',
                                                inputParamGroupID);

  string* inputTexture = params.AddParamString("Texture",
                                               "specify texture, "
                                               "if not specified -> triangle mesh will be untextured",
                                               "",
                                               'T',
                                               inputParamGroupID);

  string* inputProjection = params.AddParamString("Projection",
                                                  "specify projection, "
                                                  "if not specified -> trying to parse meta data from (1.)texture or (2.)depth map",
                                                  "",
                                                  'P',
                                                  inputParamGroupID);


  params.SetGroupName(inputParamGroupID, "input parameters");

  /**** CONFIGURATION PARAMS ****/
  int configParamGroupID = params.GetFreeGroupID();

  double* inputReduce = params.AddParamDouble     ("Reduce",
        "reduce the triangles in the generated mesh to X percent of the original mesh ",
        0.0,
        0.0,
        99.9,
        'r',
        configParamGroupID);

  bool* TileMode = params.AddParamBool("TileMode",
                                       "set tile mode, "
                                       "default is: false",
                                       false, 't',
                                       configParamGroupID);

  double* MinCornerAngleDEG = params.AddParamDouble("MinCornerAngleDEG",
                                                    "discard triangles containing a smaller angle (in degree), "
                                                    "default is: 3.0",
                                                    3.0, 0.0, 180.0,
                                                    'a',
                                                    configParamGroupID);

  double* MaxAngleDEG =
    params.AddParamDouble("MaxAngleDEG",
                          "maximum angle between normal and viewray in degree, "
                          "0 means frontal view, default is: 91.0 (disabled)",
                          91.0, 0.0, 180.0,
                          'A',
                          configParamGroupID);

  double* LevelOfDetail = params.AddParamDouble("LevelOfDetail",
                                                "set level of detail, "
                                                "1: vertex for each pixel of full resolution, "
                                                "2: of half resolution",
                                                1.0, 0.0, 10.0,
                                                'l',
                                                configParamGroupID);


  params.SetGroupName(configParamGroupID, "configuration parameters");


  /**** OUTPUT PARAMS ****/
  int outputGroupID = params.GetFreeGroupID();

  string* Outfile = params.AddParamString("Outfile",
                                          "write results into this file",
                                          "DenseTriangleMesh.wrl",
                                          'o',
                                          outputGroupID);
#ifdef BIAS_HAVE_OPENSCENEGRAPH
  string* osgOutFile = params.AddParamString("ostOutFile", "write results in osg file", "DenseMesh.osg", 'O', outputGroupID);
#endif

  params.SetGroupName(outputGroupID, "output");

  /*** end params ***/

  int fup = params.ParseCommandLine(argc, argv);

  if(*help) {
    params.Usage();
    return 0;
  }


  if (fup < 3) {
    cout <<"==> Too few arguments."<<endl;
    params.Usage();
    exit(1);
  }

  Camera<unsigned char> texture;
  Camera<float> texFloat;
  if (string(*inputTexture) == "") {
    cout<<"no texture specified, drawing untextured triangle mesh!"<<endl;
  } else {
    if(ImageIO::Load(*inputTexture, texture)!=0) {
      if(ImageIO::Load(*inputTexture, texFloat)==0){
        float maxVal = texFloat.GetMaxPixelValue();
        if(maxVal <= 1.0){
          texFloat.ScaleShift(255, 0);
        }
        ImageConvert::ConvertST(texFloat, texture, ImageBase::ST_unsignedchar);
      } else {
        cout<<"texture could not be loaded!\n";
        return -1;
      }
      texture.ParseMetaData();
    }
  }

  Camera<float> depthMap;
  if(ImageIO::Load(*inputDepthMap, depthMap)!=0) {
    cout<<"depth map could not be loaded!\n";
    params.Usage();
    if (string(*inputDepthMap)==string("UNITSPHERE")) {
      depthMap.Init(texture.GetWidth(), texture.GetHeight(), 1);
      depthMap.FillImageWithConstValue(1.0f);
    }
    else return -1;
  }

  depthMap.ParseMetaData();

  Projection Ptmp, P, texP;
  int pLoad = -1;

  if (string(*inputProjection) == "") {
    cout<<"no projection specified, trying to parse from meta data..."<<endl;
  } else {
    pLoad = Ptmp.Load(*inputProjection);
  }
  // if no projection is specified, texture image and depth map meta data are searched...
  if (pLoad != 0) {
    if (texture.IsProjValid()) {
      Ptmp = texture.GetProj();
    } else if (depthMap.IsProjValid()) {
      Ptmp = depthMap.GetProj();
    } else {
      cout<<"Projection could not be loaded from file or meta data!\n";
      params.Usage();
      return -1;
    }
  }

  // create projections for depth map and texture according to image sizes
  int widthTex = texture.GetWidth();
  int heightTex = texture.GetHeight();
  int widthDepth = depthMap.GetWidth();
  int heightDepth = depthMap.GetHeight();
  unsigned int widthP, heightP;
  Ptmp.GetParameters()->GetImageSize(widthP, heightP);
  if(widthTex != (int)widthP || heightTex != (int)heightP){
    texP = Ptmp;
    texP.GetParameters()->Rescale((unsigned int)widthTex, (unsigned int)heightTex);

    // just for debugging
    unsigned int widthTmp, heightTmp;
    texP.GetParameters()->GetImageSize(widthTmp, heightTmp);
    cout << "rescaling texP tex size " << widthTex << " " << heightTex << " P size "
         << widthP << " " << heightP << " new P " << widthTmp << " " << heightTmp << endl;
    Ptmp.GetParameters()->GetImageSize(widthTmp, heightTmp);
    cout << "P size still the same? " << widthTmp << " " << heightTmp << endl;
    // end just for debugging
  } else {
    texP = Ptmp;
    unsigned int widthTmp, heightTmp;
    texP.GetParameters()->GetImageSize(widthTmp, heightTmp);
    cout << "keeping size of texP " << widthTmp << " " << heightTmp << endl;
  }

  if(widthDepth != (int)widthP || heightDepth != (int)heightP){
    P = Ptmp;

    P.GetParameters()->Rescale((unsigned int)widthDepth, (unsigned int)heightDepth);

    // just for debugging
    unsigned int widthTmp, heightTmp;
    P.GetParameters()->GetImageSize(widthTmp, heightTmp);
    cout << "rescaling depth P depth size " << widthDepth << " " << heightDepth << " P size "
         << widthP << " " << heightP << " new P " << widthTmp << " " << heightTmp << endl;
    // end just for debugging
  } else {
    P = Ptmp;
    unsigned int widthTmp, heightTmp;
    P.GetParameters()->GetImageSize(widthTmp, heightTmp);
    cout << "keeping size of depthP " << widthTmp << " " << heightTmp << endl;
  }

  cout<<"meshing..."<<flush<<endl;
  double minCornerAngle =  (*MinCornerAngleDEG)*M_PI/180.0;
  double maxViewingAngle = (*MaxAngleDEG)*M_PI/180.0;


  cout<<"minCornerAngle = "<<minCornerAngle<<endl;
  cout<<"maxViewingAngle = "<<maxViewingAngle<<endl;
  TriangleMesh mesh(minCornerAngle, maxViewingAngle);


  cout<<"Level of detail is "<< *LevelOfDetail<<endl;
  if (!(*LevelOfDetail == 1.0)) {
    //double maxlevel = log(double(depthMap.GetWidth()))/log(2.0)-6;
    //cout<<"maximum level is "<<maxlevel<<endl;

    for (double curLevel = 1.0;
         curLevel < *LevelOfDetail; curLevel += 1.0) {
      Gauss<float, float> DepthSmooth;
      DepthSmooth.SetSigma(sqrt(1.0*1.0 - 0.5*0.5));
      Image<float> copyOfDepth = depthMap;
      DepthSmooth.Filter7x7GreyIgnoreBelowThreshold(depthMap, copyOfDepth,
                                                    0.0f);
      depthMap.Release();
      depthMap.Init(copyOfDepth.GetWidth()/2, copyOfDepth.GetHeight()/2);
      for (unsigned int y=0; y<depthMap.GetHeight(); y++) {
        for (unsigned int x=0; x<depthMap.GetWidth(); x++) {
          depthMap.GetImageDataArray()[y][x] =
            copyOfDepth.GetImageDataArray()[2*y][2*x];
        }
      }

      P.GetParameters()->Rescale(depthMap.GetWidth(), depthMap.GetHeight());   
      ImageIO::Save("depth"+FileHandling::toString(curLevel), depthMap);
    }

  }

  string vrmlfilename = *Outfile;
  cout<<"vrml file name is now "<<vrmlfilename<<endl;
#ifdef BIAS_HAVE_OPENSCENEGRAPH  
  ThreeDOutOpenSceneGraph vrmlOut;
#else
  ThreeDOut vrmlOut;
#endif
  
  cout<<boolalpha;
  cout<<"Tile Mode is set to "<<*TileMode<<endl;

  if(*TileMode) {

    // tile here into small image blocks, allows for writing of huge files
    ofstream vrmlfile(vrmlfilename.c_str());
    vrmlOut.VRMLOutWriteHeader(vrmlfile);

    unsigned int width, height;
    P.GetParameters()->GetImageSize(width, height);
    unsigned int tileWidth, tileHeight;
    bool xFinished = false;
    bool yFinished = false;
    //  bool finished = false;
    unsigned int xStart, yStart;
    unsigned int tileNum = 0;
    yStart = 0;
    int numTiles = (height/(TILE_HEIGHT-1)+1)*(width/(TILE_WIDTH-1)+1);
    cout<<"Writing "<< numTiles
        <<" tiles: "<<flush;
    cout << "inputReduce " << *LevelOfDetail <<endl;
//    if(*LevelOfDetail != 1.0){
//      cout << "Rescaling texture to fit depth map - depth width " << depthMap.GetWidth() << " texture width " << texture.GetWidth() << endl;
//      cout << "downsampling by " << *inputReduce << endl;
//      Camera<unsigned char> tmp = texture;
//      Rescale<unsigned char, unsigned char> rescaler;
//      rescaler.Downsample(tmp,texture, *LevelOfDetail);
//    }
    while(!yFinished) {
      if(yStart+TILE_HEIGHT >= height) {
        yFinished = true;
        tileHeight = height-yStart;
      } else {
        tileHeight = TILE_HEIGHT;
      }

      cout<< double(tileNum)/double(numTiles)*100.0<<"% "<<flush;
      xFinished = false;
      xStart = 0;
      while(!xFinished) {
        stringstream ss;
        ss<<"mesh_from_"<<string(*inputDepthMap)<<"_t"<<tileNum;
        tileNum++;
        if(xStart+TILE_WIDTH >= width) {
          xFinished = true;
          tileWidth = width -xStart;
        }
        else
          tileWidth = TILE_WIDTH;
        
        int res = mesh.GenerateDenseMesh(depthMap, P, texture, texP,
                                         xStart, yStart, tileWidth, tileHeight);
        if(res==0) {
          vrmlOut.AddTriangleMesh(mesh, ss.str(),
                                  *inputTexture, false);
          vrmlOut.VRMLOutIndexedFaceSets(vrmlfile);
        //  vrmlOut.RemoveAiasvll();
        }
        xStart+=(tileWidth-1);
      }
      yStart+=(tileHeight-1);
    }
 
    cout<< "  finished."<<endl<<flush;

  } else {   // TileMode == false

    if(*inputReduce != 0.0){    // generate DenseMesh to reduce
      mesh.GenerateDenseMesh(depthMap,P,texture,texP,true,*inputReduce);
    }else{

      mesh.GenerateSimplifiedMesh(depthMap, P, texture, texP, 0, 0,
                                  depthMap.GetWidth(),
                                  depthMap.GetHeight(), 0.8, 0.5);
    }
    cout<<"finished\n"<<flush;


    string texturefilename = *Outfile;
    int dotIndex = texturefilename.find_last_of(".");
    texturefilename.replace(dotIndex+1, 3, "png");

    cout<<"Writing Texture to "<<texturefilename<<flush<<endl;
    vrmlOut.AddTriangleMesh(mesh, "mesh_from_"+string(*inputDepthMap),
                            texturefilename, true);
    cout<<"finished\n";

   
  }

  cout<<"Writing VRML to "<<vrmlfilename<<flush<<endl;
  vrmlOut.VRMLOut(vrmlfilename);
#ifdef BIAS_HAVE_OPENSCENEGRAPH   
  cout << "Writing osg file to " << *osgOutFile << endl;
  vrmlOut.OpenSceneGraphOut(*osgOutFile);
#endif
  
  cout<<"finished\n";
  
  return 0;
}