source: GTP/trunk/Lib/Vis/Preprocessing/src/Exporter.cpp @ 2599

#include "X3dExporter.h"
#include "VrmlExporter.h"
#include "OspTree.h"
#include "KdTree.h"
#include "IntersectableWrapper.h"
#include "BvHierarchy.h"
#include "Triangle3.h"
#include "Polygon3.h"
#include "TraversalTree.h"
#include "Material.h"


using namespace std;

namespace GtpVisibilityPreprocessor {

Exporter *
Exporter::GetExporter(const string filename)
{
  Exporter *exporter = NULL;

  if (strstr(filename.c_str(), ".x3d")) 
  {
          exporter = new X3dExporter(filename);
  } 
  else if (strstr(filename.c_str(), ".wrl"))
  {
          exporter = new VrmlExporter(filename);
  }
  else
  {
          cerr<<"Error: Currently unsuported export format, filename " << filename << endl;
  }

  return exporter;
}


bool Exporter::ExportOspTree(const OspTree &ospTree, 
                                                         const int maxPvs
                                                         )
{
        vector<KdLeaf *> leaves;
        ospTree.CollectLeaves(leaves);
        mUseForcedMaterial = true;

        vector<KdLeaf *>::const_iterator it, it_end = leaves.end();

        Material white; 
        white.mDiffuseColor.r = 1;
        white.mDiffuseColor.g = 1;
        white.mDiffuseColor.b = 1;
        
        for (it = leaves.begin(); it != it_end; ++ it)
        {
                KdLeaf *leaf = *it;

                SetWireframe();
                SetForcedMaterial(white);
                ExportBox(ospTree.GetBoundingBox(leaf));

                SetFilled();

                if (maxPvs) // color code pvs
                {
                        mForcedMaterial.mDiffuseColor.b = 1.0f;
                        const float importance = (float)leaf->mObjects.size() / (float)maxPvs;

                        mForcedMaterial.mDiffuseColor.r = importance;
                        mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
                }
                else
                {
                  SetForcedMaterial(RandomMaterial());
                }
                if (0) ExportGeometry(leaf->mObjects);  
        }

        return true;
}


void Exporter::ExportKdIntersectable(const KdIntersectable &kdObj)
{
        KdNode *root = kdObj.GetItem();
        Intersectable::NewMail();

        stack<KdNode *> tStack;

        tStack.push(root);

        while (!tStack.empty()) {
          KdNode *node = tStack.top();
          tStack.pop();
          // todo: traverse to leaves
          if (node->IsLeaf())
                {
                  // eyport leaf pvs
                  KdLeaf *leaf = static_cast<KdLeaf *>(node);
                  
                  ObjectContainer::const_iterator oit, oit_end = leaf->mObjects.end();
                  
                  for (oit = leaf->mObjects.begin(); oit != oit_end; ++ oit)
                        {       
                          Intersectable *obj = *oit;
                          
                          if (1 || !obj->Mailed())
                                {
                                  ExportIntersectable(obj);
                                  obj->Mail();                                  
                                }                       
                        }
                } else {
                  KdInterior *interior = (KdInterior *)node;
                  tStack.push(interior->mBack);
                  tStack.push(interior->mFront);
                  
                }
          
        }
}


bool Exporter::ExportBvHierarchy(const BvHierarchy &bvHierarchy, 
                                                                 const float maxPvs,
                                                                 AxisAlignedBox3 *box,
                                                                 const bool exportBoundingBoxes)
{
        vector<BvhLeaf *> leaves;
        bvHierarchy.CollectLeaves(bvHierarchy.GetRoot(), leaves);

        mUseForcedMaterial = true;
        vector<BvhLeaf *>::const_iterator it, it_end = leaves.end();

        Material white; 
        white.mDiffuseColor.r = 1;
        white.mDiffuseColor.g = 1;
        white.mDiffuseColor.b = 1;
        
        for (it = leaves.begin(); it != it_end; ++ it)
        {
                BvhLeaf *leaf = *it;

                if (leaf->mObjects.empty() || 
                        (box && !Overlap(*box, leaf->GetBoundingBox())))
                        continue;

                if (exportBoundingBoxes)
                {
                        SetWireframe();
                        SetForcedMaterial(white);
                        ExportBox(leaf->GetBoundingBox());
                }

        if (maxPvs > 0) // color code pvs
                {
                        mForcedMaterial.mDiffuseColor.b = 1.0f;
                        const float importance = (float)leaf->mRenderCost / (float)maxPvs;

                        mForcedMaterial.mDiffuseColor.r = importance;
                        mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
                }
                else
                {
                        SetForcedMaterial(RandomMaterial());
                }

                SetFilled();
                
                ExportGeometry(leaf->mObjects, true, box);
        }

        // reset to filled
        SetFilled();

        return true;
}


void Exporter::ExportIntersectable(Intersectable *object)
{
        switch (object->Type()) 
        {
        case Intersectable::MESH_INSTANCE:
                ExportMeshInstance((MeshInstance *)object);
                break;
        case Intersectable::TRANSFORMED_MESH_INSTANCE:
                ExportTransformedMeshInstance(static_cast<TransformedMeshInstance *>(object));
                break;
        case Intersectable::VIEW_CELL:
                ExportViewCell(static_cast<ViewCell *>(object));
                break;
        case Intersectable::KD_INTERSECTABLE:
                ExportKdIntersectable(*(static_cast<KdIntersectable *>(object)));
                break;
        case Intersectable::TRIANGLE_INTERSECTABLE:
                {
                        // if (mClampToBox && !Overlap(mBoundingBox, object->GetBox()))  return;
                        const Triangle3 triangle = static_cast<TriangleIntersectable *>(object)->GetItem();

            Polygon3 poly(triangle);
                        ExportPolygon(&poly);
                        break;
                }
        case Intersectable::BVH_INTERSECTABLE:
                {
                        BvhNode *node = static_cast<BvhNode *>(object);
                        
                        if (node->IsLeaf())
                        {
                                ExportGeometry(static_cast<BvhLeaf *>(node)->mObjects, true);
                        }

                        break;
                }
        default:
                cerr << "Sorry the export for object type " << Intersectable::GetTypeName(object) << " is not available yet" << endl;
                break;
        }
}


void Exporter::ExportMeshInstance(MeshInstance *object)
{
        // $$JB$$
        // in the future check whether the mesh was not already exported
        // and use a reference to the that mesh instead
        ExportMesh(object->GetMesh());
}


void Exporter::ExportTransformedMeshInstance(TransformedMeshInstance *mi)
{
        Mesh mesh(*mi->GetMesh());

        Matrix4x4 m;
        mi->GetWorldTransform(m);
        mesh.ApplyTransformation(m);

        ExportMesh(&mesh);
}


void Exporter::ExportViewCells(const ViewCellContainer &viewCells)
{
        ViewCellContainer::const_iterator it, it_end = viewCells.end();

        for (it = viewCells.begin(); it != it_end; ++ it)
        {
                ExportViewCell(*it);
        }
}


void Exporter::ExportGeometry(const ObjectContainer &objects, 
                                                          const bool exportSingleMesh,
                                                          AxisAlignedBox3 *bbox)
{
        ObjectContainer::const_iterator oit, oit_end = objects.end();

        if (!exportSingleMesh)
        {
                for (oit = objects.begin(); oit != oit_end; ++ oit)
                {
                        if (!bbox || Overlap(*bbox, (*oit)->GetBox()))
                        {
                                if (0) SetForcedMaterial(RandomMaterial());
                                ExportIntersectable(*oit);
                        }
                }
                return;
        }
        
        ///////////////////////
        //-- all objects exported as one mesh
        //-- warning: currently works only for triangles

        PolygonContainer polys;

        for (oit = objects.begin(); oit != oit_end; ++ oit)
        {
                Intersectable *obj = *oit;

                if (bbox && !Overlap(*bbox, obj->GetBox()))
                {
                        continue;
                }
                switch (obj->Type())
                {
                case Intersectable::TRIANGLE_INTERSECTABLE:
                        {
                                TriangleIntersectable *ti = static_cast<TriangleIntersectable *>(obj);
                                polys.push_back(new Polygon3(ti->GetItem()));
                break;
                        }
                case Intersectable::MESH_INSTANCE:
                        {
                                MeshInstance *mi = static_cast<MeshInstance *>(obj);
                                ExportMesh(mi->GetMesh());
                                break;
                        }
                default:
                        cout << "merge of object type " << obj->Type() << " not implemented yet" << endl;
                        break;
                }
        }

        Mesh dummyMesh;
        PolygonContainer::const_iterator pit, pit_end = polys.end();

        for (pit = polys.begin(); pit != pit_end; ++ pit)
        {
                Polygon3 *poly = (*pit);
                IncludePolyInMesh(*poly, dummyMesh);
        }
        
        ExportMesh(&dummyMesh);
        CLEAR_CONTAINER(polys);
}


bool Exporter::ExportTraversalTree(const TraversalTree &tree, 
                                                                          const bool exportGeometry)
{
        stack<TraversalNode *> tStack;

        tStack.push(tree.GetRoot());

        Mesh *mesh = new Mesh;

        SetWireframe();

        while (!tStack.empty()) 
        {
                TraversalNode *node = tStack.top();
                tStack.pop();
                const AxisAlignedBox3 box = tree.GetBox(node);

                // add 6 vertices of the box
                const int index = (int)mesh->mVertices.size();

                SetForcedMaterial(RandomMaterial());

                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()) 
                {
                        TraversalInterior *interior = static_cast<TraversalInterior *>(node);

                        tStack.push(interior->mFront);
                        tStack.push(interior->mBack);
                }
                else if (exportGeometry)
                {
                        SetFilled();
                        SetForcedMaterial(RandomMaterial());

                        ExportViewCells(static_cast<TraversalLeaf *>(node)->mViewCells);        
                        SetWireframe();
                }
        }

        ExportMesh(mesh);
        delete mesh;

        return true;
}


}