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

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


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 *node = kdObj.GetItem();
        
        Intersectable::NewMail();

        // todo: traverse to leaves
        if (node->IsLeaf())
        {
                // eyport leaf pvs
                KdLeaf *leaf = dynamic_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 (!obj->Mailed())
                        {
                                ExportIntersectable(obj);
                                obj->Mail();                                    
                        }                               
                }
        }
}


bool Exporter::ExportBvHierarchy(const BvHierarchy &bvHierarchy, 
                                                                 const int maxPvs)
{
        vector<BvhLeaf *> leaves;
        bvHierarchy.CollectLeaves(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())
                        continue;

                SetWireframe();
                SetForcedMaterial(white);
                ExportBox(leaf->GetBoundingBox());
                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 (1) 
                {
                        SetFilled();
                        ExportGeometry(leaf->mObjects, true);
                }
        }

        return true;
}


void Exporter::ExportIntersectable(Intersectable *object)
{
        switch (object->Type()) 
        {
        case Intersectable::MESH_INSTANCE:
                ExportMeshInstance((MeshInstance *)object);
                break;
        case Intersectable::TRANSFORMED_MESH_INSTANCE:
                ExportTransformedMeshInstance(dynamic_cast<TransformedMeshInstance *>(object));
                break;
        case Intersectable::VIEW_CELL:
                ExportViewCell(dynamic_cast<ViewCell *>(object));
                break;
        case Intersectable::KD_INTERSECTABLE:
                ExportKdIntersectable(*(dynamic_cast<KdIntersectable *>(object)));
                break;
        case Intersectable::TRIANGLE_INTERSECTABLE:
                {
                        const Triangle3 triangle = dynamic_cast<TriangleIntersectable *>(object)->GetItem();

                        VertexContainer vertices;
                        vertices.push_back(triangle.mVertices[0]);
                        vertices.push_back(triangle.mVertices[1]);
                        vertices.push_back(triangle.mVertices[2]);

                        Polygon3 poly(vertices);
                        ExportPolygon(&poly);
                        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)
{
        ObjectContainer::const_iterator oit, oit_end = objects.end();

        if (!exportSingleMesh)
        {
                for (oit = objects.begin(); oit != oit_end; ++ oit)
                {
                        if (0) SetForcedMaterial(RandomMaterial());
                        ExportIntersectable(*oit);
                }

                return;
        }

        //-- all objects exported as one mesh
        //-- hack: currently works only for triangles
        PolygonContainer polys;

        for (oit = objects.begin(); oit != oit_end; ++ oit)
        {
                Intersectable *obj = *oit;
                switch (obj->Type())
                {
                case Intersectable::TRIANGLE_INTERSECTABLE:
                        {
                                TriangleIntersectable *ti = dynamic_cast<TriangleIntersectable *>(obj);
                                polys.push_back(new Polygon3(ti->GetItem()));
                break;
                        }
                default:
                        cout << "merging 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);
}



}