IndexLineSetHandler.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 "IndexLineSetHandler.hh"
#include <fstream>
#include <bias_config.h>

using namespace BIAS;
using namespace std;

IndexLineSetHandler::IndexLineSetHandler()
{
  dNumberOfLinesInSet_ =0;
}

IndexLineSetHandler::~IndexLineSetHandler()
{
  dNumberOfLinesInSet_ =0; 
}


/**
  @returns vector of vector<BIAS::HomgPoint3D> with format:
       [0]---------[1]---- .....
        |           |
    startpos       .
    stoppos
  
  @param1 Filename of wrlFile with IndexLineSet
  @param2 here number of found lines is returned
  @author ischiller
  @date 03/06
*/
std::vector<std::vector<BIAS::HomgPoint3D> >
IndexLineSetHandler::Parse(std::string fileName, int &dNumberOfLines)
{
  char dummy[20];
  std::vector<double> point;
  std::vector<int>    linePos;
  std::string tmp;
  std::ifstream stream;
  stream.open(fileName.c_str(),ifstream::in);

  while(!stream.eof()){
    while(tmp != "point" && !stream.eof()){ 
      stream>>dummy; 
      tmp = dummy;
      if(tmp == "point" || tmp == "Point")
        {
          //get rid of the '['
          stream >> dummy;     
          break;
        }
    }

    int count = 0;
    // now parse points  
    while(tmp != "]" && !stream.eof() ) {
      point.clear();//release point vector
      for(int i=0;i<3;i++){
        stream>>dummy;
        tmp = dummy;
        if(tmp == "]" || (tmp.find(']',0) != string::npos))
          break;
        point.push_back(atof(dummy));
      }
      if(point.size() == 3){
#ifdef BIAS_DEBUG
        // cout<<"Point : "<<point[0]<<","<<point[1]<<","<<point[2]<<endl;
#endif
        count++;
        vDetectedPoints_.push_back(point);
      }
    }

    //look for the coordindex section
    while(tmp != "coordIndex" && !stream.eof()){ 
      stream>>dummy; 
      tmp = dummy;
      if(tmp == "coordIndex" || tmp == "coordIndex")
        {
          //get rid of the '['
          stream >> dummy;     
          break;
        }
    }
    //now parse section with connection assignments
    //read in "first index"
    stream>>dummy; 
    tmp = dummy; 
    while(tmp != "]" && !stream.eof() ){
      linePos.clear(); //clear it
      //recall last input (which is start)
      linePos.push_back(atoi(dummy)+vDetectedPoints_.size()-count); 
      stream>>dummy; //get next (stop)
      tmp = dummy; 
      if(tmp == "]"|| (tmp.find(']',0) != string::npos))
        break;            
      //if -1 at the end go two steps further, no connection at this position
      if(tmp == "-1" || tmp == "-1,"){ 
        linePos.clear(); 
        stream>>dummy;  
        tmp = dummy;
        if(tmp == "]"|| (tmp.find(']',0) != string::npos))
          break;   

        linePos.push_back(atoi(dummy)+vDetectedPoints_.size()-count); 
        stream>>dummy; 
        tmp = dummy;
        if(tmp == "]"|| (tmp.find(']',0) != string::npos))
          break;   
      }

      linePos.push_back(atoi(dummy)+vDetectedPoints_.size()-count);
   
      if(linePos.size() == 2){
#ifdef BIAS_DEBUG
        // cout<<"Intersection : "<<linePos[0]<<","<<linePos[1]<<endl;
#endif
        vConnectingLines_.push_back(linePos);
      }
    }
  
  }
  
  stream.close();

  //now build correct vector and deliver HomgPoint3D !! 
  BIAS::HomgPoint3D startPoint3D,stopPoint3D;
  std::vector<std::vector<BIAS::HomgPoint3D> > output;
  std::vector<BIAS::HomgPoint3D> line;

  for(unsigned int k=0; 
      k<vConnectingLines_.size() && k<vDetectedPoints_.size() ;
      k++) {  
    line.clear();

    for(int j=0;j<6;j++){
      if(j<3) { //starting point;
        startPoint3D[j] = vDetectedPoints_[vConnectingLines_[k][0]][j]; 

      }
      else{//stop point
        stopPoint3D[j-3] = vDetectedPoints_[vConnectingLines_[k][1]][j-3];

      }
    } 
    startPoint3D[3]=1;
    stopPoint3D[3]=1;
    
    //puhs the HomgPoints into vector line
    line.push_back(startPoint3D);
    line.push_back(stopPoint3D);
    //push line into gloab ouput
    output.push_back(line);

    dNumberOfLinesInSet_++;
#ifdef BIAS_DEBUG
    // cout<<"Line: ";
    // for(unsigned int h=0;h<2;h++) cout<<output[k][h]<<",";
    //  cout<<endl;
#endif
  }
  dNumberOfLines = dNumberOfLinesInSet_;
  return output;
}

int IndexLineSetHandler::
Write(std::string fileName, std::vector<std::vector<BIAS::HomgPoint3D> > fLines)
{
  //std::map<BIAS::HomgPoint3D, int> mapPoints;
  //std::map<const double*, int> mapPoints;
  int a = 0;
  int linesCount = fLines.size();

  std::vector<double > pointX, pointY, pointZ;
  pointX.clear();
  pointY.clear();
  pointZ.clear();

  std::ofstream stream;
  stream.open(fileName.c_str(),ofstream::out);

  //VRML HEADER
  stream << "#VRML V2.0 utf8" << endl;
  stream << "#Created by BIAS::IndexLineSetWriter amattal/ischiller"
         <<endl<<endl;

  //SHAPE DESCRIPTION
  stream << "Shape{ appearance Appearance { material Material {emissiveColor 1 1 1 }}" << endl;
  stream << "  geometry IndexedLineSet {" << endl;
  stream << "    coord Coordinate {" << endl;
  stream << "      point [" << endl;

  //Calculate points-array and their indexes

  //points - array of points with points[i] = a means that point a has index i
  //mapPoints - correspondences between point values and their indexes
  for (int i = 0; i < linesCount; i++)
    {
      if (FindPoint(fLines[i][0], pointX, pointY, pointZ, a) == -1)
        {
          //mapPoints.insert(make_pair(fLines[i][0], a));
          pointX.push_back(fLines[i][0][0]);
          pointY.push_back(fLines[i][0][1]);
          pointZ.push_back(fLines[i][0][2]);

          //VRML new point description
          stream << "      " 
                 << pointX[a] << " "
                 << pointY[a] << " "
                 << pointZ[a] << endl;
          
          a++;
        }
      
      if (FindPoint(fLines[i][1], pointX, pointY, pointZ, a) == -1)
        {
          //mapPoints.insert(make_pair(fLines[i][1], a));

          pointX.push_back(fLines[i][1][0]);
          pointY.push_back(fLines[i][1][1]);
          pointZ.push_back(fLines[i][1][2]);

          //VRML new point description
          stream << "      " 
                 << pointX[a] << " "
                 << pointY[a] << " "
                 << pointZ[a] << endl;

          a++;
        }
    }

  //VRML text
  stream << "      ]" << endl; 
  stream << "    }" << endl;  
  stream << "    coordIndex [" << endl; 

  //Fill the Edge-matrix for all the existing lines from our array
  int size = a;
  std::vector< std::vector< bool > > bEdges;

  bEdges.clear();
  //bEdges.reserve(size);
  for (int i = 0; i < size; i++)
    {
      std::vector< bool > just;
      just.clear();
      for (int j = 0; j < size; j++)
        {
          //bEdges[i].reserve(size);
          just.push_back(false);
        }
      bEdges.push_back(just);
    }

  //std::map<BIAS::HomgPoint3D, int>::iterator mapIteratorX;
  //std::map<BIAS::HomgPoint3D, int>::iterator mapIteratorY;
  for (int i = 0; i < linesCount; i++)
    {
      //mapIteratorX = mapPoints.find(fLines[i][0]);
      //mapIteratorY = mapPoints.find(fLines[i][1]);
      
      int indexX = FindPoint(fLines[i][0], pointX, pointY, pointZ, a);
      int indexY = FindPoint(fLines[i][1], pointX, pointY, pointZ, a);

      if((indexX != -1) &&
         (indexY != -1))
        {
          //int indexX = (*mapIteratorX).second;
          //int indexY = (*mapIteratorY).second;
          
          bEdges[indexX][indexY] = true;
          bEdges[indexY][indexX] = true;
        }
    }

  //calculate size of each column
  vector<int> sizeOfColumns;
  sizeOfColumns.reserve(size);

  for (int i = 0; i < size; i++)
    {
      sizeOfColumns[i] = 0;
      for (int j = 0; j < size; j++)
        {
          if(bEdges[i][j])
            {
              sizeOfColumns[i]++;
            }
        }
    }

  //And now fill the strings (and make them as long as possible)
  //with the lines-chains

  for (int i = 0; i < size; i++)
    {
      
      //calculate chains of lines and them to string tmp
      
      while(sizeOfColumns[i] != 0)
        {
          stream << "      " << i;
          
          int begin = 0;
          int end = i;
          while(end != -1)
            {
              begin = end;
              end = GetColumnElement(bEdges[begin], size);

              if(end != -1)
                {
                  //if the edge exists, delete it from matrix
                  bEdges[begin][end] = false;
                  bEdges[end][begin] = false;
                  
                  //correct the sizes of columns
                  if(end == begin){sizeOfColumns[end]--;}
                  else
                    {
                      sizeOfColumns[begin]--;
                      sizeOfColumns[end]--;
                    }

                  stream << " " << end;
                }
              else
                {
                  //if not, write ", -1" and get out to the next line-chain
                  stream << " " << end;
                  
                  //VRML write the line chain
                  stream << endl;
                }
            }
        }
    }

  //VRML endlines
  stream << "      ]" << endl; 
  stream << "    colorPerVertex FALSE" << endl;  
  stream << "  }" << endl; 
  stream << "}" << endl; 

  stream.close();
  int success = 0;
  
  //Block that writes the lines into stream

  return success;
}

//Check if the column is empty and if not, gives the first found element
//@param column - our column we're checking
//@param size - size of the column (so taht we don't have to calculate it each time

//@return -1 if empty, or, if column is not empty, number of the first element 
int IndexLineSetHandler::
GetColumnElement(std::vector< bool > column, int size)
{
  for (int i = 0; i < size; i++)
    {
      if (column[i])
        {
          return i;
        }
    }
  return -1;
} 

//says if current point is in our array
//if yes, give out an index
//if no, give out -1
int IndexLineSetHandler::
FindPoint(BIAS::HomgPoint3D point,
          std::vector<double > pX,
          std::vector<double > pY,
          std::vector<double > pZ, 
          int size)
{
  for (int i = 0; i < size; i++)
    {
      if ((pX[i] == point[0]) &&
          (pY[i] == point[1]) &&
          (pZ[i] == point[2]))
        {
          return i;
        }
    }
  return -1;
}