source: GTP/trunk/Lib/Vis/Preprocessing/src/X3dExporter.cpp @ 2601

#include <stack>
#include "common.h"
#include "SceneGraph.h"
#include "X3dExporter.h"
#include "Mesh.h"
#include "KdTree.h"
#include "ViewCellBsp.h"
#include "ViewCell.h"
#include "Polygon3.h"
#include "VssRay.h"
#include "HierarchyManager.h"
#include "VssTree.h"
#include "VspBspTree.h"
#include "RssTree.h"
#include "Beam.h"


using namespace std;

namespace GtpVisibilityPreprocessor {


X3dExporter::X3dExporter(const string filename):Exporter(filename)
{
  stream.open(mFilename.c_str());
  stream<<"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"<<endl;
  stream<<"<X3D>"<<endl;
  stream<<"<Scene>"<<endl;
  
}


X3dExporter::~X3dExporter()
{
  stream<<"</Scene>"<<endl;
  stream<<"</X3D>"<<endl;
  stream.close();
}



bool
X3dExporter::ExportRays(const RayContainer &rays,
                                                const float length,
                                                const RgbColor &color)
{
  RayContainer::const_iterator ri = rays.begin();

  stream<<"<Shape>"<<endl;
  stream<<"<Appearance>"<<endl;
  stream<<"<Material diffuseColor=\""<<color.r<<" "<<color.g<<" "<<color.b<<
    "\" />"<<endl;
  stream<<"</Appearance>"<<endl;
  
  stream<<"<IndexedLineSet coordIndex=\""<<endl;

  int index = 0;
  for (; ri != rays.end(); ri++) {
    stream<<index<<" "<<index+1<<" -1\n";
    index+=2;
  }
  
  stream<<"\" >"<<endl;
  
  stream<<"<Coordinate  point=\""<<endl;
  
  ri = rays.begin();
  for (; ri != rays.end(); ri++) {
    Vector3 a = (*ri)->GetLoc();
    
    Vector3 b;
    if (length < 0)
      b = (*ri)->GetLoc() - length*(*ri)->GetDir();
    else
      if ((*ri)->intersections.size()==0)
                b = (*ri)->GetLoc() + length*(*ri)->GetDir();
      else
                b = (*ri)->Extrap((*ri)->intersections[0].mT);
    
    stream<<a.x<<" "<<a.y<<" "<<a.z<<" ,";
    stream<<b.x<<" "<<b.y<<" "<<b.z<<" ,\n";
  }
  
  stream<<"\" >"<<endl;
  stream<<"</Coordinate>"<<endl;
  stream<<"</IndexedLineSet>"<<endl;
  stream<<"</Shape>"<<endl;

  return true;
}


bool
X3dExporter::ExportRaySets(const vector<VssRayContainer> &rays,
                                                   const RgbColor &color)
{
  vector<VssRayContainer>::const_iterator ri = rays.begin();
  
  stream<<"<Switch DEF=\"RAYS\" whichChoice=\"0\" >"<<endl;

  bool result = false;

  for (; ri != rays.end(); ri++) {
        result = ExportRays(*ri, color);
        if (!result) {
          std::cerr<<"Error while exporting rays!\n";
          break;
        }
  }
  
  stream<<"</Switch>"<<endl;

  stream<<"<TimeSensor DEF='TIMER' loop='true' startTime='0' stopTime='0' cycleInterval='5'>"
                <<endl;
  stream<<"</TimeSensor>"<<endl;
  
  stream<<"<IntegerSequencer DEF='SEQ'"<<endl;
  stream<<"key='0.0 ";
  int i;
  int size = (int)rays.size() + 2;
  for (i=1; i < size; i++) {
        stream<<i/(float)(size-1)<<" ";
  }
  stream<<"'\n";

  stream<<"keyValue='";
  for (i=0; i < size; i++) {
        stream<<i<<" ";
  }
  stream<<"'>\n";
  
  stream<<"</IntegerSequencer>"<<endl;

  stream<<
        "<ROUTE fromNode='TIMER' fromField='fraction_changed' toNode='SEQ' toField='set_fraction'>";
  stream<<"</ROUTE>"<<endl;
  
  stream<<"<ROUTE fromNode='SEQ' fromField='value_changed' toNode='RAYS' toField='set_whichChoice'>";
  
  stream<<"</ROUTE>"<<endl;
  
  return result;
}

bool
X3dExporter::ExportRays(const VssRayContainer &rays,
                                                const RgbColor &color)
{
  VssRayContainer::const_iterator ri = rays.begin();

  stream<<"<Shape>"<<endl;
  stream<<"<Appearance>"<<endl;
  stream<<"<Material diffuseColor=\""<<color.r<<" "<<color.g<<" "<<color.b<<
    "\" />"<<endl;
  stream<<"</Appearance>"<<endl;
  
  stream<<"<IndexedLineSet coordIndex=\""<<endl;

  int index = 0;
  for (; ri != rays.end(); ri++) {
    stream<<index<<" "<<index+1<<" -1\n";
    index+=2;
  }
  
  stream<<"\" >"<<endl;
  
  stream<<"<Coordinate  point=\""<<endl;
  
  ri = rays.begin();
  for (; ri != rays.end(); ri++) {
    const Vector3 a = (*ri)->GetOrigin();
        //const Vector3 b = (*ri)->mTerminationObject ? (*ri)->GetTermination() : a + 1000 * Normalize((*ri)->GetDir());
        const Vector3 b = (*ri)->GetTermination(); // matt: change again!!

    stream<<a.x<<" "<<a.y<<" "<<a.z<<" ,";
        stream<<b.x<<" "<<b.y<<" "<<b.z<<" ,\n";
  }
  
  stream<<"\" >"<<endl;
  stream<<"</Coordinate>"<<endl;
  stream<<"</IndexedLineSet>"<<endl;
  stream<<"</Shape>"<<endl;
        
  return true;
}

void
X3dExporter::ExportSceneNode(SceneGraphNode *node)
{
  stream<<"<Group>"<<endl;

  if (!node->IsLeaf())
  {
          SceneGraphInterior *interior = static_cast<SceneGraphInterior *>(node);

          SceneGraphNodeContainer::iterator ni = interior->mChildren.begin();
          for (; ni != interior->mChildren.end(); ++ ni)
                  ExportSceneNode(*ni);
  }
  else
  {
          SceneGraphLeaf *leaf = static_cast<SceneGraphLeaf *>(node);

          ObjectContainer::const_iterator mi = leaf->mGeometry.begin();
          for (; mi != leaf->mGeometry.end(); ++ mi) 
          {
                  // export the transform...
                  ExportIntersectable(*mi);
          }
  }

  stream<<"</Group>"<<endl;

}


void 
X3dExporter::ExportBspLeaves(const BspTree &tree, const int maxPvs)
{
        stack<pair<BspNode *, BspNodeGeometry *> > tStack;
        ViewCell::NewMail();

        BspNodeGeometry *geom = new BspNodeGeometry();
        tree.ConstructGeometry(tree.GetRoot(), *geom);

        tStack.push(pair<BspNode *, BspNodeGeometry *>(tree.GetRoot(), geom));

        if (maxPvs)
                mUseForcedMaterial = true;

        while (!tStack.empty()) 
        {
                BspNode *node = tStack.top().first;
                BspNodeGeometry *cell = tStack.top().second;
                tStack.pop();

                if (!node->IsLeaf()) 
                {
                        BspInterior *interior = static_cast<BspInterior *>(node);
                                                                
                        BspNodeGeometry *front = new BspNodeGeometry();
                        BspNodeGeometry *back = new BspNodeGeometry();

                        cell->SplitGeometry(*front, 
                                                                *back, 
                                                                interior->GetPlane(), 
                                                                tree.GetBoundingBox(), 
                                                                tree.GetEpsilon());

                        tStack.push(pair<BspNode *, BspNodeGeometry *>(interior->GetFront(), front));
                        tStack.push(pair<BspNode *, BspNodeGeometry *>(interior->GetBack(), back));
                }
                else
                {
                        if (maxPvs)
                        {
                                BspLeaf *leaf = static_cast<BspLeaf *>(node);

                                mForcedMaterial.mDiffuseColor.b = 1.0f;
                                const float importance = 
                                        (float)leaf->GetViewCell()->GetPvs().EvalPvsCost() / (float)maxPvs;

                                mForcedMaterial.mDiffuseColor.r = importance;
                                mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
                        }
                        ExportPolygons(cell->GetPolys());
                }               
                DEL_PTR(cell);
        }
}

void
X3dExporter::ExportViewCell(ViewCell *viewCell)
{
        if (viewCell->GetMesh())
        {
                ExportMesh(viewCell->GetMesh());
        }
}

void
X3dExporter::ExportMesh(Mesh *mesh)
{

  stream<<"<Shape>"<<endl;
  stream<<"<Appearance>"<<endl;
  
  // $$ tmp -> random material
  
  float r, g, b;

  if (mUseForcedMaterial) {
    r = mForcedMaterial.mDiffuseColor.r;
    g = mForcedMaterial.mDiffuseColor.g;
    b = mForcedMaterial.mDiffuseColor.b;
    
  } else
    if (mesh->mMaterial) {
      r = mesh->mMaterial->mDiffuseColor.r;
      g = mesh->mMaterial->mDiffuseColor.g;
      b = mesh->mMaterial->mDiffuseColor.b;
    } else {
      r = RandomValue(0.5, 1.0);
      g = RandomValue(0.5, 1.0);
      b = RandomValue(0.5, 1.0);
    }
    
  stream<<"<Material diffuseColor=\""<<r<<" "<<g<<" "<<b<<
    "\" specularColor=\"0.0 0.0 0.0\"/>"<<endl;
  stream<<"</Appearance>"<<endl;


  if (mWireframe)
    stream<<"<IndexedLineSet coordIndex=\""<<endl;
  else
    //stream<<"<IndexedFaceSet ccw=\"TRUE\" coordIndex=\""<<endl;
        stream << "<IndexedFaceSet coordIndex=\"" << endl;

  FaceContainer::const_iterator fi = mesh->mFaces.begin();

  int index = 0;
  
  for (; fi != mesh->mFaces.end(); fi++) {
    Face *face = *fi;
    VertexIndexContainer::const_iterator vi = face->mVertexIndices.begin();
    for (; vi != face->mVertexIndices.end(); vi++)
      stream<<*vi<<" ";
        if (mWireframe) // final line to finish polygon
                stream << (*face->mVertexIndices.begin()) << " ";

    stream<<"-1"<<endl;
  }
  stream<<"\" >"<<endl;

  stream<<"<Coordinate  point=\""<<endl;
  
  VertexContainer::const_iterator vi = mesh->mVertices.begin();
  for (; vi != mesh->mVertices.end(); vi++) {
    stream<<(*vi).x<<" "<<(*vi).y<<" "<<(*vi).z;
    stream<<","<<endl;
  }
  
  stream<<"\" >"<<endl;
  stream<<"</Coordinate>"<<endl;

  if (mWireframe)
    stream<<"</IndexedLineSet>"<<endl;
  else
    stream<<"</IndexedFaceSet>"<<endl;
  
  stream<<"</Shape>"<<endl;

}


void X3dExporter::ExportPolygon(Polygon3 *poly)
{
        stream << "<Shape>" << endl;
        stream << "<Appearance>" << endl;
  
        // $$ tmp -> random material
  
        float r, g, b;

        if (mUseForcedMaterial) 
        {
                r = mForcedMaterial.mDiffuseColor.r;
                g = mForcedMaterial.mDiffuseColor.g;
                b = mForcedMaterial.mDiffuseColor.b;
        } 
        else if (poly->mMaterial) 
        {
                r = poly->mMaterial->mDiffuseColor.r;
                g = poly->mMaterial->mDiffuseColor.g;
                b = poly->mMaterial->mDiffuseColor.b;
        } else 
        {
                r = RandomValue(0.5, 1.0);
                g = RandomValue(0.5, 1.0);
                b = RandomValue(0.5, 1.0);
        }

        stream << "<Material diffuseColor=\"" << r << " " << g << " " << b 
                   << "\" specularColor=\"0.0 0.0 0.0\"/>" << endl;

    stream << "</Appearance>" << endl;


        //-- create and write indices
        if (mWireframe)
                stream<<"<IndexedLineSet coordIndex=\""<<endl;
        else
                //stream << "<IndexedFaceSet ccw=\"TRUE\" coordIndex=\"" << endl;
                stream << "<IndexedFaceSet coordIndex=\"" << endl;
        int index = 0;
        
        VertexContainer::const_iterator vi;  
        
        for (index = 0; index < (int)poly->mVertices.size(); ++ index) 
                stream << index << " ";
        
        if (mWireframe) // final line to finish polygon
                stream << "0 ";

        stream << "-1" << endl;
        stream << "\" >" << endl;
        
        stream << "<Coordinate  point=\"" << endl;
  
        for (vi = poly->mVertices.begin(); vi != poly->mVertices.end(); ++vi) 
        {
                stream << (*vi).x << " " << (*vi).y << " " << (*vi).z;
                stream << "," << endl;
        }
  
        stream << "\" >" << endl;
        stream << "</Coordinate>" << endl;

        if (mWireframe)
                stream << "</IndexedLineSet>" << endl;
        else
                stream << "</IndexedFaceSet>" << endl;
  
        stream << "</Shape>" << endl;
}



void X3dExporter::ExportPolygons(const PolygonContainer &polys)
{
        stream << "<Shape>" << endl;
        stream << "<Appearance>" << endl;
  
        // $$ tmp -> random material
  
        float r, g, b;

        if (mUseForcedMaterial) 
        {
                r = mForcedMaterial.mDiffuseColor.r;
                g = mForcedMaterial.mDiffuseColor.g;
                b = mForcedMaterial.mDiffuseColor.b;
        } 
        else 
        {
                r = RandomValue(0.5, 1.0);
                g = RandomValue(0.5, 1.0);
                b = RandomValue(0.5, 1.0);
        }

        stream << "<Material diffuseColor=\"" << r << " " << g << " " << b 
                   << "\" specularColor=\"0.0 0.0 0.0\"/>" << endl;

    stream << "</Appearance>" << endl;


        //-- create and write indices
        if (mWireframe)
                stream<<"<IndexedLineSet coordIndex=\""<<endl;
        else
                //stream << "<IndexedFaceSet ccw=\"TRUE\" coordIndex=\"" << endl;
                stream << "<IndexedFaceSet coordIndex=\"" << endl;

        int index = 0;
        
        PolygonContainer::const_iterator pit;

    VertexContainer::const_iterator vi;  
        
        for (pit = polys.begin(); pit != polys.end(); ++pit)
        {
                Polygon3 *poly = *pit;
                int startIdx = index;
                for (vi = poly->mVertices.begin(); vi != poly->mVertices.end(); ++vi) 
                {
                        stream << index ++ << " ";
                }

                stream << startIdx << " ";// finish line
                stream << "-1" << endl;
        }

        stream << "\" >" << endl;
        
        stream << "<Coordinate  point=\"" << endl;
        for (pit = polys.begin(); pit != polys.end(); ++ pit)
        {
                Polygon3 *poly = *pit;
        for (vi = poly->mVertices.begin(); vi != poly->mVertices.end(); ++vi) 
                {
                        stream << (*vi).x << " " << (*vi).y << " " << (*vi).z;
                        stream << "," << endl;
                }
        }
        stream << "\" >" << endl;
        stream << "</Coordinate>" << endl;

        if (mWireframe)
                stream << "</IndexedLineSet>" << endl;
        else
                stream << "</IndexedFaceSet>" << endl;
  
        stream << "</Shape>" << endl;
}


bool
X3dExporter::ExportBox(const AxisAlignedBox3 &box)
{
  Mesh *mesh = new Mesh;
  // add 8 vertices of the box
  int index = (int)mesh->mVertices.size();
  for (int i=0; i < 8; i++) {
    Vector3 v;
    box.GetVertex(i, v);
    mesh->mVertices.push_back(v);
  }
  
  mesh->AddFace(new Face(index + 0, index + 1, index + 3, index + 2) );
  mesh->AddFace(new Face(index + 0, index + 2, index + 6, index + 4) );
  mesh->AddFace(new Face(index + 4, index + 6, index + 7, index + 5) );
  
  mesh->AddFace(new Face(index + 3, index + 1, index + 5, index + 7) );
  mesh->AddFace(new Face(index + 0, index + 4, index + 5, index + 1) );
  mesh->AddFace(new Face(index + 2, index + 3, index + 7, index + 6) );
  
  ExportMesh(mesh);
  delete mesh;
  return true;
}


bool
X3dExporter::ExportBspTree(const BspTree &tree)
{
        if (mExportRayDensity) 
        {
                return ExportBspTreeRayDensity(tree);
        }
  
        bool savedWireframe = mWireframe;

        SetWireframe();
        
        ExportBox(tree.GetBoundingBox());
        
        if (!savedWireframe)
                SetFilled();

        // export view cells
        ExportBspLeaves(tree);  

        return true;
}


bool X3dExporter::ExportKdTree(const KdTree &tree, 
                                                           const bool exportGeometry)
{
         if (mExportRayDensity) {
    return ExportKdTreeRayDensity(tree);
  }
  
  stack<KdNode *> tStack;

  tStack.push(tree.GetRoot());

  Mesh *mesh = new Mesh;
  
  while (!tStack.empty()) {
    KdNode *node = tStack.top();
    tStack.pop();
    AxisAlignedBox3 box = tree.GetBox(node);
    // add 6 vertices of the box
    int index = (int)mesh->mVertices.size();
    for (int i=0; i < 8; i++) {
      Vector3 v;
      box.GetVertex(i, v);
      mesh->mVertices.push_back(v);
    }
    mesh->AddFace(new Face(index + 0, index + 1, index + 3, index + 2) );
    mesh->AddFace(new Face(index + 0, index + 2, index + 6, index + 4) );
    mesh->AddFace(new Face(index + 4, index + 6, index + 7, index + 5) );

    mesh->AddFace(new Face(index + 3, index + 1, index + 5, index + 7) );
    mesh->AddFace(new Face(index + 0, index + 4, index + 5, index + 1) );
    mesh->AddFace(new Face(index + 2, index + 3, index + 7, index + 6) );

    if (!node->IsLeaf()) {
      KdInterior *interior = (KdInterior *)node;
      tStack.push(interior->mFront);
      tStack.push(interior->mBack);
    }
        else if (exportGeometry)
        {
                SetFilled();
                SetForcedMaterial(RandomMaterial());
                ExportGeometry(static_cast<KdLeaf *>(node)->mObjects);  
                SetWireframe();
        }
  }
  
  ExportMesh(mesh);
  delete mesh;

  return true;
}


bool
X3dExporter::ExportVssTree(const VssTree &tree
                                                   )
{
  stack<VssTreeNode *> tStack;
        
  tStack.push(tree.GetRoot());
        
  Mesh *mesh = new Mesh;
  VssRayContainer rays;
        
  while (!tStack.empty()) {

                VssTreeNode *node = tStack.top();
    tStack.pop();

                        
    if (!node->IsLeaf()) {
      VssTreeInterior *interior = (VssTreeInterior *)node;
      tStack.push(interior->front);
      tStack.push(interior->back);
    } else {
                        VssTreeLeaf *leaf = (VssTreeLeaf *)node;
                        AxisAlignedBox3 box;
                        box = tree.GetBBox(leaf);
                        IncludeBoxInMesh(box, *mesh);

                        if (tree.ValidLeaf(leaf)) {
                                
                                Vector3 origin = box.Center();
                                box = tree.GetDirBBox(leaf);
                                VssRay *ray;
                                
                                const int indices[][2] = {{0,0}, {0,1}, {1,1}, {1,0}}; 
                                MeshInstance dummy(mesh);
                                for (int i=0; i < 4; i++) {
                                        //                              Vector3 v = box.GetVertex(indices[i][0], indices[i][1], 0);
                                        Vector3 v = box.Center();
                                        
                                        Vector3 direction = VssRay::GetDirection(v.x, v.y);
                                        if (Magnitude(direction) > Limits::Small)
                                          direction.Normalize();
                                        else
                                          direction = Vector3(0, 1, 0);
                                        float k = 100.0f*leaf->GetImportance();
                                        // get 4 corners of the ray directions
                                        
                                        ray = new VssRay(origin, origin + (direction*k), NULL, &dummy);
                                        rays.push_back(ray);
                                }
                        }
                }
  }

  ExportMesh(mesh);
  ExportRays(rays);
  CLEAR_CONTAINER(rays);
  delete mesh;
  return true;
}

bool
X3dExporter::ExportVssTree2(const VssTree &tree,
                                                        const Vector3 direction
                                                        )
{
  stack<VssTreeNode *> tStack;
        

  mUseForcedMaterial = true;

  Vector3 dirParam;

  dirParam.x = VssRay::GetDirParam(0, Normalize(direction));
  dirParam.y = VssRay::GetDirParam(1, Normalize(direction));

  float maxImportance = 0.0f;
  tStack.push(tree.GetRoot());
  while (!tStack.empty()) {
        
        VssTreeNode *node = tStack.top();
    tStack.pop();
        
    if (!node->IsLeaf()) {
      VssTreeInterior *interior = (VssTreeInterior *)node;
          if (interior->axis < 3) {
                tStack.push(interior->front);
                tStack.push(interior->back);
          } else {
                if (dirParam[interior->axis-3] < interior->position)
                  tStack.push(interior->back);
                else
                  tStack.push(interior->front);
          }
    } else {
          VssTreeLeaf *leaf = (VssTreeLeaf *)node;
          if (tree.ValidLeaf(leaf)) {
                float i = leaf->GetImportance();
                if (i > maxImportance)
                  maxImportance = i;
          }
        }
  }

  tStack.push(tree.GetRoot());
  while (!tStack.empty()) {

        VssTreeNode *node = tStack.top();
    tStack.pop();
        
                        
    if (!node->IsLeaf()) {
      VssTreeInterior *interior = (VssTreeInterior *)node;
          if (interior->axis < 3) {
                tStack.push(interior->front);
                tStack.push(interior->back);
          } else {
                if (dirParam[interior->axis-3] < interior->position)
                  tStack.push(interior->back);
                else
                  tStack.push(interior->front);
          }
    } else {
          VssTreeLeaf *leaf = (VssTreeLeaf *)node;
          if (tree.ValidLeaf(leaf)) {
                AxisAlignedBox3 box;
                box = tree.GetBBox(leaf);
                Mesh *mesh = new Mesh;
                IncludeBoxInMesh(box, *mesh);
                
                // get 4 corners of the ray directions
                
                mForcedMaterial.mDiffuseColor.b = 1.0f;
                mForcedMaterial.mDiffuseColor.r = leaf->GetImportance()/maxImportance;
                mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
                
                ExportMesh(mesh);
                delete mesh;
          }
        }
  }

  mUseForcedMaterial = false;

  return true;
}

bool
X3dExporter::ExportBspTreeRayDensity(const BspTree &tree)
{
        stack<BspNode *> tStack;

        tStack.push(tree.GetRoot());

        bool fm = mUseForcedMaterial;
        
        mUseForcedMaterial = true;
        
        mForcedMaterial.mDiffuseColor.g = 1.0f;
        mForcedMaterial.mDiffuseColor.b = 1.0f;
  
        while (!tStack.empty()) 
        {
                BspNode *node = tStack.top();
                tStack.pop();

                if (node->IsLeaf()) 
                {
                        ViewCell *vc = static_cast<BspLeaf *>(node)->GetViewCell();
#if 0     
                        // set the mesh material according to the ray density
                        if (vc->mPassingRays.mRays) 
                        {
                                float importance = 
                                  vc->mPassingRays.mContributions / (float)vc->mPassingRays.mRays;
                                
                                mForcedMaterial.mDiffuseColor.r = importance;
                                mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
                                ExportViewCell(vc);

                        }
#endif
                } 
                else 
                {
                        BspInterior *interior = (BspInterior *)node;
                        tStack.push(interior->GetFront());
                        tStack.push(interior->GetBack());
                }
        }
  
        // restore the state of forced material
        mUseForcedMaterial = fm;

        return true;
}

bool
X3dExporter::ExportKdTreeRayDensity(const KdTree &tree)
{
  stack<KdNode *> tStack;

  tStack.push(tree.GetRoot());

  bool fm = mUseForcedMaterial;
  mUseForcedMaterial = true;
  mForcedMaterial.mDiffuseColor.g = 1.0f;
  mForcedMaterial.mDiffuseColor.b = 1.0f;
  while (!tStack.empty()) {
    KdNode *node = tStack.top();
    tStack.pop();
    if (node->IsLeaf()) {
      AxisAlignedBox3 box = tree.GetBox(node);
      Mesh *mesh = new Mesh;
      
      // add 6 vertices of the box
      int index = (int)mesh->mVertices.size();
      for (int i=0; i < 8; i++) {
        Vector3 v;
        box.GetVertex(i, v);
        mesh->mVertices.push_back(v);
      }
      mesh->AddFace(new Face(index + 0, index + 1, index + 3, index + 2) );
      mesh->AddFace(new Face(index + 0, index + 2, index + 6, index + 4) );
      mesh->AddFace(new Face(index + 4, index + 6, index + 7, index + 5) );
      
      mesh->AddFace(new Face(index + 3, index + 1, index + 5, index + 7) );
      mesh->AddFace(new Face(index + 0, index + 4, index + 5, index + 1) );
      mesh->AddFace(new Face(index + 2, index + 3, index + 7, index + 6) );


      // set the mesh material according to the ray density
      KdLeaf *leaf = (KdLeaf *) node;
      if (leaf->mPassingRays.mRays) {
        float importance = leaf->mPassingRays.mContributions/(float)leaf->mPassingRays.mRays;
        //      float importance = leaf->mPassingRays.mContributions/1000.0f;
        //      float importance = leaf->mPassingRays.mRays/1000.0f;
        ///(float)leaf->mPassingRays.mRays;
        // mForcedMaterial.mDiffuseColor.r = log10(leaf->mPassingRays.mRays)/3.0f;
        mForcedMaterial.mDiffuseColor.r = importance;
        mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
        ExportMesh(mesh);
      }
      delete mesh;
    } else {
      KdInterior *interior = (KdInterior *)node;
      tStack.push(interior->mFront);
      tStack.push(interior->mBack);
    }
  }
  // restore the state of forced material
  mUseForcedMaterial = fm;
  return true;
}


struct BspSplitData
{
        /// the current node
        BspNode *mNode;

        vector<Plane3> mPlanes;
        vector<bool> mSides;
        bool mIsFront;
        int mDepth;

        BspSplitData(BspNode *node): 
        mNode(node), mIsFront(false), mDepth(0)
        {};     

        BspSplitData(BspNode *node, 
                                vector<Plane3> planes, 
                                vector<bool> sides, 
                                const bool isFront,
                                const int depth): 
        mNode(node), mPlanes(planes), mSides(sides), 
        mIsFront(isFront), mDepth(depth)
        {};
};

void X3dExporter::ExportLeavesGeometry(const BspTree &tree, 
                                                                           const vector<BspLeaf *> &leaves)
{
        vector<BspLeaf *>::const_iterator it, it_end = leaves.end();

        for (it = leaves.begin(); it != it_end; ++ it)
        {
                BspNodeGeometry geom;
                tree.ConstructGeometry(*it, geom);
                
                ExportPolygons(geom.GetPolys());
        }
}

void X3dExporter::ExportBspNodeSplits(BspNode *root,
                                                                          const AxisAlignedBox3 &box, 
                                                                          const bool exportDepth,
                                                                          const bool epsilon)
{
        std::stack<BspSplitData> tStack;

        BspSplitData tData(root);
        tStack.push(tData);
  
        PolygonContainer polys;
        vector <int> depths;

        int maxDepth = 0;

        while (!tStack.empty())
        {
                // filter polygons donw the tree
                BspSplitData tData = tStack.top();
            tStack.pop();       
                
                if (tData.mNode->IsLeaf())
                {
                        if (tData.mDepth > maxDepth)
                                maxDepth = tData.mDepth;
                }
                else
                {
                        BspInterior *interior = static_cast<BspInterior *>(tData.mNode);

                        // add current side of split plane
                        if (tData.mNode != root)
                                tData.mSides.push_back(tData.mIsFront);

                        // bounded plane is added to the polygons
                        Polygon3 *planePoly = 
                                box.CrossSection(interior->GetPlane());
                
                        // do all the splits with the previous planes
                        for (int i = 0; i < (int)tData.mPlanes.size(); ++ i)
                        {                               
                                if (planePoly->ClassifyPlane(tData.mPlanes[i], epsilon) 
                                        == Polygon3::SPLIT)
                                {
                                        Polygon3 *frontPoly = new Polygon3();
                                        Polygon3 *backPoly = new Polygon3();

                                        planePoly->Split(tData.mPlanes[i], 
                                                                         *frontPoly, 
                                                                         *backPoly,
                                                                         epsilon);

                                        DEL_PTR(planePoly);

                                        if(tData.mSides[i] == true)
                                        {
                                                planePoly = frontPoly;
                                                DEL_PTR(backPoly);
                                        }
                                        else
                                        {
                                                planePoly = backPoly;
                                                DEL_PTR(frontPoly);
                                        }
                                }
                        }

                        tData.mPlanes.push_back(interior->GetPlane()); // add plane to split planes

                        if (planePoly->Valid(epsilon))
                        {
                                polys.push_back(planePoly);
                                depths.push_back(tData.mDepth);
                        }
                        else
                                DEL_PTR(planePoly);
                        
                        // push the children on the stack
                        tStack.push(BspSplitData(interior->GetFront(), tData.mPlanes, 
                                                     tData.mSides, true, tData.mDepth + 1));
                        tStack.push(BspSplitData(interior->GetBack(), tData.mPlanes, 
                                                     tData.mSides, false, tData.mDepth + 1));
                }
        }

        if (maxDepth > 0)
        {       
                mUseForcedMaterial = true;
                        
                for (int i = 0; i < (int)polys.size(); ++ i)
                {
                        mForcedMaterial.mDiffuseColor.b = 1.0f;
                        float importance =  (float)depths[i]/ (float)maxDepth;
            
                        mForcedMaterial.mDiffuseColor.r = importance;
                        mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;

                        ExportPolygon(polys[i]);
                }
        }
        else
        {
                ExportPolygons(polys);
        }

        CLEAR_CONTAINER(polys);
}


void X3dExporter::ExportBspSplits(const BspTree &tree,
                                                                  const bool exportDepth)
{
        ExportBspNodeSplits(tree.GetRoot(), 
                                                tree.GetBoundingBox(), 
                                                exportDepth, 
                                                tree.GetEpsilon());
}


void X3dExporter::ExportBspSplits(const VspBspTree &tree,
                                                                  const bool exportDepth)
{
        ExportBspNodeSplits(tree.GetRoot(), 
                                                tree.GetBoundingBox(), 
                                                exportDepth, 
                                                tree.GetEpsilon());
}


void X3dExporter::ExportBspSplitPlanes(const BspTree &tree)
{
        std::stack<BspNode *> tStack;

        tStack.push(tree.GetRoot());
  
        PolygonContainer polys;

        while (!tStack.empty())
        {
                // filter polygons donw the tree
                BspNode *node = tStack.top();
            tStack.pop();       
                
                if (!node->IsLeaf())
                {
                        BspInterior *interior = static_cast<BspInterior *>(node);

                        // bounded plane is added to the polygons
                        polys.push_back(tree.GetBoundingBox().CrossSection(interior->GetPlane()));
                
                        // push the children on the stack
                        tStack.push(interior->GetBack());
                        tStack.push(interior->GetFront());
                }
        }

        ExportPolygons(polys);
        CLEAR_CONTAINER(polys);
}


bool
X3dExporter::ExportRssTree2(const RssTree &tree,
                                                        const Vector3 direction
                                                        )
{
  stack<RssTreeNode *> tStack;
  
  
  mUseForcedMaterial = true;

  Vector3 dirParam;

  dirParam.x = VssRay::GetDirParam(0, Normalize(direction));
  dirParam.y = VssRay::GetDirParam(1, Normalize(direction));

  float maxImportance = 0.0f;
  tStack.push(tree.GetRoot());
  while (!tStack.empty()) {
        
        RssTreeNode *node = tStack.top();
    tStack.pop();
        
    if (!node->IsLeaf()) {
      RssTreeInterior *interior = (RssTreeInterior *)node;
          if (interior->axis < 3) {
                tStack.push(interior->front);
                tStack.push(interior->back);
          } else {
                if (dirParam[interior->axis-3] < interior->position)
                  tStack.push(interior->back);
                else
                  tStack.push(interior->front);
          }
    } else {
          RssTreeLeaf *leaf = (RssTreeLeaf *)node;
          if (tree.ValidLeaf(leaf)) {
                float i = leaf->GetImportance();
                if (i > maxImportance)
                  maxImportance = i;
          }
        }
  }

  tStack.push(tree.GetRoot());
  while (!tStack.empty()) {

        RssTreeNode *node = tStack.top();
    tStack.pop();
        
                        
    if (!node->IsLeaf()) {
      RssTreeInterior *interior = (RssTreeInterior *)node;
          if (interior->axis < 3) {
                tStack.push(interior->front);
                tStack.push(interior->back);
          } else {
                if (dirParam[interior->axis-3] < interior->position)
                  tStack.push(interior->back);
                else
                  tStack.push(interior->front);
          }
    } else {
          RssTreeLeaf *leaf = (RssTreeLeaf *)node;
          if (tree.ValidLeaf(leaf)) {
                AxisAlignedBox3 box;
                box = tree.GetShrankedBBox(leaf);
                Mesh *mesh = new Mesh;
                IncludeBoxInMesh(box, *mesh);
                
                // get 4 corners of the ray directions
                
                mForcedMaterial.mDiffuseColor.b = 1.0f;
                mForcedMaterial.mDiffuseColor.r = leaf->GetImportance()/maxImportance;
                mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
                
                ExportMesh(mesh);
                delete mesh;
          }
        }
  }

  mUseForcedMaterial = false;

  return true;
}


void
X3dExporter::ExportViewpoint(const Vector3 &point,
                                                         const Vector3 &direction)
{
  stream<<"<Viewpoint "<<endl;
  
  stream<<"position=\""<<point.x<<" "<<point.y<<" "<<point.z<<"\""<<endl;
  //  stream<<"orientation "<<direction.x<<direction.y<<direction.z<<endl;
  
  stream<<">"<<endl;
  stream<<"</Viewpoint>"<<endl;

}



void X3dExporter::ExportBeam(const Beam &beam, const AxisAlignedBox3 &box)
{
        if (beam.mMesh)
        {
                ExportMesh(beam.mMesh);
                return;
        }

        PolygonContainer polys;
        //ExportBox(beam.mBox);

        const float zfar = 2.0f * Magnitude(box.Diagonal());

        // box should not never remove part of beam polygons
        Vector3 bmin = beam.mBox.Min() - Vector3(zfar * 2.0f);
        Vector3 bmax = beam.mBox.Max() + Vector3(zfar * 2.0f);

        AxisAlignedBox3 bbox(bmin, bmax);
        Plane3 fplane;
        fplane.mNormal = -beam.mPlanes[0].mNormal;

        fplane.mD = beam.mPlanes[0].mD - zfar - 1.0f; 
        
        vector<Plane3> planes = beam.mPlanes;
        planes.push_back(fplane);

        for (int i = 0; i < planes.size(); ++ i)
        {
                Polygon3 *poly = bbox.CrossSection(planes[i]);
                if (!poly->Valid(Limits::Small))
                        DEL_PTR(poly);
                
                for (int j = 0; (j < planes.size()) && poly; ++ j)
                {
                        if (j != i)
                        {
                                Polygon3 *front = new Polygon3();
                                Polygon3 *back = new Polygon3();
                                
                                poly->Split(planes[j], *front, *back, Limits::Small);
                                DEL_PTR(poly);
                                DEL_PTR(front);

                                if (!back->Valid(Limits::Small))
                                        DEL_PTR(back);
                                poly = back;
                        }
                }
                if (poly)
                        polys.push_back(poly);
        }

        ExportPolygons(polys);
        CLEAR_CONTAINER(polys);
}





}