source: GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter/VisibilitySolutionConverter.cpp @ 3239

#include "VisibilitySolutionConverter.h"
#include "SimpleTri.h"
#include "SimpleVec.h"
#include "gzstream.h"
#include <iostream>
#include <queue>


using namespace std;

// MAGIC of all bin exports
#ifndef MAGIC 
#define MAGIC 0x827923
#endif

#define BVH_VERSION 2.1

#define TYPE_INTERIOR -2
#define TYPE_LEAF -3

//const int maxVertices = 20000000;



static string ReplaceSuffix(const string &str, 
                                                        const string &a, 
                                                        const string &b)
{
        string result = str;

        int pos = (int)str.rfind(a, (int)str.size() - 1);
        if (pos == str.size() - a.size()) 
        {
                result.replace(pos, a.size(), b);
        }

        return result;
}


static void LoadIndices(char *str, 
                                                const VertexArray &vertices, 
                                                const VertexArray &normals, 
                                                const vector<pair<float, float> > &texCoords,
                                                VertexArray &faceVertices,
                                                VertexArray &faceNormals,
                                                vector<TexCoord> &faceTexCoords
                                                )
{
        vector<string> triples;

        char *next_token;

        // extract the triples of the form v/t/n v/t/n ...
        char *pch = strtok_s(str + 1, " ", &next_token);

        while (pch)
        {
                string s(pch);
                //s += "\n",
                triples.push_back(s);
                
                pch = strtok_s(NULL, " ", &next_token);   
        }

        vector<int> indices;
        vector<int> nIndices;
        vector<int> tIndices;

        char seps[] = " /\t\n";

        for (size_t i = 0; i < triples.size(); ++ i)
        {
                static int dummy = 0;

                size_t found;
                found = triples[i].find_first_of(seps);
                size_t prevfound = 0;
                // vertex, normal, texture indices
                string str = triples[i].substr(prevfound, found);

                int index = (int)strtol(str.c_str(), NULL, 10) - 1;

                int tIndex = index;
                int nIndex = index;     
                
                prevfound = found;
                found = triples[i].find_first_of(seps, found + 1);  

                if (found != string::npos)
                {
                        str = triples[i].substr(prevfound, found);

                        int idx = (int)strtol(str.c_str(), NULL, 10) - 1;
                        if (idx > 0) tIndex = idx;
                }

                if ((found + 1) < triples[i].size())
                {
                        str = triples[i].substr(found + 1);

                        int idx = (int)strtol(str.c_str(), NULL, 10) - 1;
                        if (idx > 0) nIndex = idx;
                }

                // store indices
                if (index >= 0)
                {
                        indices.push_back(index);
                        nIndices.push_back(nIndex);
                        tIndices.push_back(tIndex);
                }

                // new triangle found
                if (indices.size() > 2)
                {
                        int idx1 = 0;
                        int idx2 = (int)indices.size() - 2;
                        int idx3 = (int)indices.size() - 1;

                        faceVertices.push_back(vertices[indices[idx1]]);
                        faceVertices.push_back(vertices[indices[idx2]]);
                        faceVertices.push_back(vertices[indices[idx3]]);


                        if (!normals.empty())
                        {
                                faceNormals.push_back(normals[nIndices[idx1]]);
                                faceNormals.push_back(normals[nIndices[idx2]]);
                                faceNormals.push_back(normals[nIndices[idx3]]);
                        }
                        else
                        {
                                // no face normals? => create normals
                                const SimpleTri tri(vertices[indices[idx1]],
                                                        vertices[indices[idx2]], 
                                                                        vertices[indices[idx3]]);

                                const SimpleVec n = tri.GetNormal();

                                faceNormals.push_back(n);
                                faceNormals.push_back(n);
                                faceNormals.push_back(n);
                        }

                        if (!texCoords.empty())
                        {
                                faceTexCoords.push_back(texCoords[tIndices[idx1]]);
                                faceTexCoords.push_back(texCoords[tIndices[idx2]]);
                                faceTexCoords.push_back(texCoords[tIndices[idx3]]);
                        }
                }
        }
}


VisibilitySolutionConverter::VisibilitySolutionConverter()
{}


VisibilitySolutionConverter::~VisibilitySolutionConverter()
{
        for (size_t i = 0; i < mGeometry.size(); ++ i)
        {
                delete [] mGeometry[i]->mVertices;
                delete [] mGeometry[i]->mNormals;
                delete [] mGeometry[i]->mTexCoords;

                delete mGeometry[i];
        }
        
        mGeometry.clear();
}


void VisibilitySolutionConverter::LoadShape(const VertexArray &vertices,
                                                                                        const VertexArray &normals,
                                                                                        const vector<TexCoord> &texCoords)
{
        int numElements = (int)vertices.size();
        Geometry *geom = new Geometry();

        // convert the triangles to geometry
        geom->mVertices = new SimpleVec[numElements];
        geom->mNormals = new SimpleVec[numElements];
        geom->mTexCoords = new TexCoord[numElements];

        geom->mVertexCount = numElements;
        geom->mTexcoordCount = (int)texCoords.size();

        //cout << "number of vertices=" << numElements << endl;

        for (int i = 0; i < numElements; ++ i)
        {
                // convert to our camera system: change y and z
                geom->mVertices[i].x =  vertices[i].x;
                geom->mVertices[i].y = -vertices[i].z;
                geom->mVertices[i].z =  vertices[i].y;
        
                geom->mNormals[i].x =  normals[i].x;
                geom->mNormals[i].y = -normals[i].z;
                geom->mNormals[i].z =  normals[i].y;

                if (i < geom->mTexcoordCount)
                {
                        geom->mTexCoords[i].first = texCoords[i].first;
                        geom->mTexCoords[i].second = texCoords[i].second;
                }
        }

        mGeometry.push_back(geom);
}


bool VisibilitySolutionConverter::Convert(const std::string &sceneInputFilename,
                                                                                  const std::string &sceneOutputFilename,
                                                                                  const std::string &bvhInputFilename,
                                                                                  const std::string &bvhOutputFilename)
{
        mNumShapes = 0;
        
        // delete previous geometry
        for (size_t i = 0; i < mGeometry.size(); ++ i)
        {
                delete [] mGeometry[i]->mVertices;
                delete [] mGeometry[i]->mNormals;
                delete [] mGeometry[i]->mTexCoords;

                delete mGeometry[i];
        }
        
        mGeometry.clear();

        if (!LoadSolution(bvhInputFilename))
        {
                cerr << "could not read solution file" << endl;
                return false;
        }

        if (!ReadScene(sceneInputFilename))
        {
                cerr << "could not read file" << endl;
                return false;
        }

        if (!WriteScene(sceneOutputFilename))
        {
                cerr << "could not write file" << endl;
                return false;
        }

        if (!WriteBvh(bvhOutputFilename))
        {
                cerr << "could not write bvh!" << endl;
                return false;
        }

        return true;
}


bool VisibilitySolutionConverter::ReadScene(const string &filename)
{
        VertexArray vertices;
        VertexArray normals;
        vector<TexCoord> texCoords;

        if (ReadSimpleObj(filename, vertices, normals, texCoords))
        //if (ReadObj(filename, vertices, normals, texCoords)) 
        {
                ConstructBvhObjects(vertices, normals, texCoords);
                return true;
        }

        return false;
}


bool VisibilitySolutionConverter::ReadObj(const string &filename,
                                                                                  VertexArray &vertices,
                                                                                  VertexArray &normals,
                                                                                  vector<TexCoord> &texcoords) 
{
        FILE *file;

        if ((file = fopen(filename.c_str(), "r")) == NULL) return false;
        
        VertexArray tempVertices; 
        VertexArray tempNormals;
        vector<TexCoord> tempTexcoords;

        vector<int> indices;

        int line = 0;
        const int len = 10000;
        char str[len];

        while (fgets(str, len, file) != NULL)
        {
                if (line % 500000 == 0)
                        cout << line << " " << str << endl;

                ++ line;

                switch (str[0])
                {
                case 'v': // vertex or normal
                        {
                                float x, y, z;

                                //if (tempVertices.size() >= maxVertices * 3) continue;

                                switch (str[1]) 
                                {
                                case 'n' :
                                        sscanf(str + 2, "%f %f %f", &x, &y, &z);
                                        tempNormals.push_back(SimpleVec(x, y, z));
                                        break;
                                case 't':
                                        sscanf(str + 2, "%f %f", &x, &y);
                                        tempTexcoords.push_back(pair<float, float>(x, y));
                                        break;
                                default:
                                        sscanf(str + 1, "%f %f %f", &x, &y, &z);
                                        //const float scale = 5e-3f;
                                        const float scale = 0.1f;
                                        tempVertices.push_back(SimpleVec(x * scale, y * scale, z * scale));
                                        //cout <<"v " << x << " " << y << " "<< z << " ";
                                }
                                break;
                        }
                case 'f': 
                        {
                                //////////
                                //-- indices in the current line

                                //if (tempVertices.size() >= maxVertices * 3) continue;
                                LoadIndices(str, 
                                                tempVertices, tempNormals, tempTexcoords, 
                                                vertices, normals, texcoords);

                                break;
                        }  
                        break;
                default:
                        // throw away line
                        break;
                }
        }

        fclose(file);

        return !vertices.empty();
}


bool VisibilitySolutionConverter::ReadSimpleObj(const string &filename,
                                                                                                VertexArray &vertices,
                                                                                                VertexArray &normals,
                                                                                                vector<TexCoord> &texcoords)
{
        const string binFilename = ReplaceSuffix(filename, ".obj", ".bn");

        if (!ReadBinObj(binFilename, vertices, 1))
        {
                cout << "binary dump " << binFilename << " not available, loading ascii obj" << endl;

                FILE *file;
                if ((file = fopen(filename.c_str(), "r")) == NULL) return false;

                int line = 0;
                const int len = 10000;
                char str[len];

                while (fgets(str, len, file) != NULL)
                {
                        if (line % 500000 == 0)
                                cout << line << " " << str << endl;

                        ++ line;

                        switch (str[0])
                        {
                        case 'v': // vertex or normal
                                {
                                        float x, y, z;

                                        sscanf(str + 1, "%f %f %f", &x, &y, &z);
                                        const float scale = 0.1f;
                                        vertices.push_back(SimpleVec(x * scale, y * scale, z * scale));
                                        break;
                                }
                        default:
                                // throw away line
                                break;
                        }
                }

                fclose(file);

                cout << "dumping " << vertices.size() << " to binary " << binFilename << endl;
                ExportBinObj(binFilename, vertices);
        }

        for (size_t i = 0; i < vertices.size(); i += 3)
        {
                // no face normals? => create normals
                const SimpleTri tri(vertices[i + 0],
                            vertices[i + 1], 
                                                        vertices[i + 2]);

                const SimpleVec n = tri.GetNormal();

                normals.push_back(n);
                normals.push_back(n);
                normals.push_back(n);
        }

        return !vertices.empty();
}



static inline float RandomColor(float x)
{
        return x + (1.0f - x) * (float)rand() / RAND_MAX; 
}


void VisibilitySolutionConverter::WriteGeometry(ogzstream &str, Geometry *geom)
{
        int vertexCount = geom->mVertexCount;
        str.write(reinterpret_cast<char *>(&vertexCount), sizeof(int));
  
        str.write(reinterpret_cast<char *>(geom->mVertices), sizeof(SimpleVec) * vertexCount);
        str.write(reinterpret_cast<char *>(geom->mNormals), sizeof(SimpleVec) * vertexCount);

        int texCoordCount = 0;//geom->mTexcoordCount;
        str.write(reinterpret_cast<char *>(&texCoordCount), sizeof(int));

        if (texCoordCount)
        {
                str.write(reinterpret_cast<char *>(geom->mTexCoords), sizeof(float) * texCoordCount * 2);
        }

        ///////
        //-- texture

        int texId = -1;
        str.write(reinterpret_cast<char *>(&texId), sizeof(int));

        bool alphaTestEnabled = false;
        bool cullFaceEnabled = true;

        str.write(reinterpret_cast<char *>(&alphaTestEnabled), sizeof(bool));
        str.write(reinterpret_cast<char *>(&cullFaceEnabled), sizeof(bool));

        // material
        bool hasMaterial = true;
        
        str.write(reinterpret_cast<char *>(&hasMaterial), sizeof(bool));
        
        if (hasMaterial)
        {
                SimpleVec ambient, diffuse, spec, emm;

                ambient.x = ambient.y = ambient.z = 0.2f;
                //diffuse.x = diffuse.y = diffuse.z = 1.0f;

                diffuse.x = RandomColor(0.5f); 
                diffuse.y = RandomColor(0.5f);
                diffuse.z = RandomColor(0.5f);

                spec.x    = spec.y    = spec.z    =  .0f;
                emm = spec;

                // only write rgb part of the material
                str.write(reinterpret_cast<char *>(&ambient), sizeof(SimpleVec));
                str.write(reinterpret_cast<char *>(&diffuse), sizeof(SimpleVec));
                str.write(reinterpret_cast<char *>(&spec), sizeof(SimpleVec));
                str.write(reinterpret_cast<char *>(&emm), sizeof(SimpleVec));
        }
}


bool VisibilitySolutionConverter::WriteScene(const string &filename)
{
        ogzstream ofile(filename.c_str());

        if (!ofile.is_open())
                return false;
        

        int textureCount = 0;
        ofile.write(reinterpret_cast<char *>(&textureCount), sizeof(int));


        ///////////
        //-- write shapes

        int numShapes = (int)mGeometry.size();
        ofile.write(reinterpret_cast<char *>(&numShapes), sizeof(int));

        vector<Geometry *>::const_iterator it, it_end = mGeometry.end();

        for (it = mGeometry.begin(); it != it_end; ++ it)
        {
                WriteGeometry(ofile, *it);
        }


        int entityCount = numShapes;
        ofile.write(reinterpret_cast<char *>(&entityCount), sizeof(int));


        //////////
        //-- write single scene entity for each shape

        // all shapes belong to this scene entity
        for (int i = 0; i < numShapes; ++ i)
        {
                // no transformation
                bool hasTrafo = false;
                ofile.write(reinterpret_cast<char *>(&hasTrafo), sizeof(bool));

                // a dummy lod
                int numLODs = 1;
                ofile.write(reinterpret_cast<char *>(&numLODs), sizeof(int));

                float dist = 0;
                ofile.write(reinterpret_cast<char *>(&dist), sizeof(float));

                int shapesPerEnt = 1;
                ofile.write(reinterpret_cast<char *>(&shapesPerEnt), sizeof(int));

                int shapeId = i;
                ofile.write(reinterpret_cast<char *>(&shapeId), sizeof(int));
        }

        return true;
}


void VisibilitySolutionConverter::ConstructBvhObjects(const VertexArray &vertices,
                                                                                                          const VertexArray &normals,
                                                                                                          const vector<TexCoord> &texCoords)
{
        VertexArray _vertices;
        VertexArray _normals;
        vector<TexCoord> _texCoords;

        for (size_t i = 0; i < mBvhNodes.size(); ++ i)
        {
                BvhNode *node = mBvhNodes[i];

                //for (size_t j = 0; j < node->mTriangleIds.size(); ++ j)
                for (int j = node->first; j <= node->last; ++ j)
                {
                        const int idx = 3 * mGlobalTriangleIds[j];

                        //if (idx >= maxVertices * 3) continue;

                        for (int k = 0; k < 3; ++ k)
                        {
                                _vertices.push_back(vertices[idx + k]);
                                _normals.push_back(normals[idx + k]);
                                //_texCoords.push_back(texCoords[idx + k]);
                        }
                }

                if (!_vertices.empty())
                {
                        ++ mNumShapes;
                        LoadShape(_vertices, _normals, _texCoords);
                }

                _vertices.clear();
                _normals.clear();
                _texCoords.clear();
        }
}


bool VisibilitySolutionConverter::ReadBvh(FILE *fr) 
{
        int buffer[6]; 
        fread(buffer, sizeof(int), 6, fr);

        if (buffer[0] != MAGIC) 
        {
                cerr << "Error: Wrong file type" << endl;
                return false;
        }

        if (buffer[1] != (int)(1000 * BVH_VERSION)) 
        {
                cerr << "Error: Wrong BVH version" << endl;
                return false;
        }

        // load triangle ids
        size_t numTriangles = buffer[2];

        for (size_t i = 0; i < numTriangles; ++i) 
        {
                int id;
                fread(&id, sizeof(int), 1, fr);
                mGlobalTriangleIds.push_back(id);
                //triangles[i] = scene->triangles[id];
        }

        //if (mRoot) delete mRoot;

        mNumNodes = 0; // this was set to 1 in constructor!

        mRoot = LoadNode(fr, 0);

        if (mNumNodes != buffer[5]) 
        {
                cerr << "Warning: Loaded " << mNumNodes <<
                            " bvh nodes instead of " << buffer[5] << endl;
        }

        fclose(fr);
        
        return true;
}


BvhNode *VisibilitySolutionConverter::LoadNode(FILE *fr, int depth)
{
        ++ mNumNodes;
        
        int buffer[4];
        fread(buffer, sizeof(int), 4, fr);

        if (buffer[2] != -1) 
        {
                BvhInterior *interior = new BvhInterior();
                
                interior->first = buffer[0];
                interior->last  = buffer[1];
                interior->axis  = buffer[2];
                interior->id    = buffer[3];
                interior->depth = depth;

                BvhNode *front, *back;

                front = LoadNode(fr, depth + 1);
                back  = LoadNode(fr, depth + 1);

                front->parent = interior;
                back->parent = interior;

                interior->front = front;
                interior->back = back;

                //interior->bmin = Minimize(front->bmin, back->bmin);
                //interior->bmax = Maximize(front->bmax, back->bmax);
        
                return (BvhNode *)interior;
        }
        else 
        {
                // leaf
                //Debug << "Info: Loading leaf (id: " << numberOfNodes << ", depth: " << depth << ")" << endl;
                BvhLeaf *leaf = new BvhLeaf();

                leaf->first = buffer[0];
                leaf->last  = buffer[1];
                leaf->axis  = buffer[2];
                leaf->id    = buffer[3];

                leaf->depth = depth;
                //UpdateLeafBox(leaf);

                mBvhNodes.push_back(leaf);
        
                return (BvhNode *)leaf;
        }
}


bool VisibilitySolutionConverter::ReadDummyTree(FILE *fr)
{
        int buffer[256]; 
        fread(buffer, sizeof(int), 3, fr);

        // read dummy bounding box
        float dummy[6];
        fread(dummy, sizeof(float) * 6, 1, fr);

        int stack = 1;

        // read dummy tree
        while (stack)
        {
                int axis;
                fread(&axis, sizeof(int), 1, fr);
                -- stack;

                if (axis != - 1) 
                {
                        float dummy;
                        fread(&dummy, sizeof(float), 1, fr);
                        
                        stack += 2;
                }
        }
  
        return true;
}



bool VisibilitySolutionConverter::LoadSolution(const string &filename)
{
        FILE *fr = fopen(filename.c_str(), "rb");

        cerr << "Info: Loading visibility solution from file '" + filename + "'" << endl;
  
        if (fr == NULL) 
        {
                cerr << "Error: Cannot open file for reading" << endl;
                return false;
        }

        float totalSamples, totalTime;

        fread(&totalSamples, sizeof(float), 1, fr);
        fread(&totalTime, sizeof(float), 1, fr);

        // just need to convert objects => read dummy visibility tree
        bool ok = ReadDummyTree(fr);

        // read bvh to optain objects (= the leaves of the bvh)
        if (ok) ok = ReadBvh(fr);

        fclose(fr);
        
        if (ok) 
                cout << "Info: visibility solution loaded" << endl;
        else
                cout << "Info: loading visibility solution failed" << endl;
  
        return true;
}


bool VisibilitySolutionConverter::ReadBinObj(const string &filename,
                                                                                         VertexArray &vertices,
                                                                                         float scale)
{
        igzstream inStream(filename.c_str());
        
        if (!inStream.is_open()) return false;

        cout << "binary obj dump available, loading " << filename.c_str() << endl;
        
        // read in triangle size
        int numTriangles;

        const int t = 500000;
        inStream.read(reinterpret_cast<char *>(&numTriangles), sizeof(int));
        vertices.reserve(numTriangles * 3);
        cout << "loading " << numTriangles * 3 << " vertices (" 
                 << numTriangles * 3 * sizeof(SimpleVec) /      (1024 * 1024) << " MB)" << endl;

        int i = 0;

        while (1)
        {
                SimpleVec v;
                
                inStream.read(reinterpret_cast<char *>(&v), sizeof(SimpleVec));

                // end of file reached
                if (inStream.eof())     break;
                
                //v *= scale;
                vertices.push_back(v);

                if (((i ++) % t) == 0)
                         cout << "\r" << i << "/" << numTriangles * 3 << "\r";
        }
        
        cout << "finished loading vertices" << endl;

        if (i != numTriangles * 3)
                cerr << "warning: " << numTriangles * 3 << " != " << i << endl;

        inStream.close();

        return true;
}


bool VisibilitySolutionConverter::ExportBinObj(const string &filename,
                                                                                           const VertexArray &vertices)
{       
        ogzstream ofile(filename.c_str());
        if (!ofile.is_open()) return false;

        int numTriangles = (int)vertices.size() / 3;

        ofile.write(reinterpret_cast<char *>(&numTriangles), sizeof(int));

        VertexArray::const_iterator it, it_end = vertices.end();

        for (it = vertices.begin(); it != it_end; ++ it)
        {
                SimpleVec v = *it;
                ofile.write(reinterpret_cast<char *>(&v), sizeof(SimpleVec));
        }

        cout << "exported " << numTriangles * 3 << " vertices" << endl;

        ofile.close();

        return true;
}


void VisibilitySolutionConverter::WriteNextNode(ogzstream &stream, 
                                                                                                BvhNode *node)
{
        int nodeType;

        if (!node->IsLeaf())
                nodeType = TYPE_LEAF;
        else 
                nodeType = TYPE_INTERIOR;
                
        cerr << "error: wrong node type: " << nodeType << endl;
                
        stream.write(reinterpret_cast<char *>(&nodeType), sizeof(int));

        SimpleVec bMin, bMax;

        stream.write(reinterpret_cast<char *>(&(node->first)), sizeof(int));
        stream.write(reinterpret_cast<char *>(&(node->last)), sizeof(int));

        stream.write(reinterpret_cast<char *>(&node->bmin), sizeof(SimpleVec));
        stream.write(reinterpret_cast<char *>(&node->bmax), sizeof(SimpleVec));
}


bool VisibilitySolutionConverter::WriteBvh(const string &filename)
{
        std::queue<BvhNode *> tQueue;
        ogzstream stream(filename.c_str());

        if (!stream.is_open()) return NULL;

        cout << "loading bvh" << endl;

        WriteNextNode(stream, mRoot);

        tQueue.push(mRoot);
        
        while (!tQueue.empty())
        {
                BvhNode *node = tQueue.front();
                tQueue.pop();

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

                        BvhNode *front = interior->front;
                        BvhNode *back = interior->back;

                        WriteNextNode(stream, front);
                        WriteNextNode(stream, back);

                        tQueue.push(front);                     
                        tQueue.push(back);
                }
        }

        return true;
}