MultiResSparseGridTopology.h

Go to the documentation of this file.

/******************************************************************************
*       SOFA, Simulation Open-Framework Architecture, version 1.0 beta 3      *
*                (c) 2006-2008 MGH, INRIA, USTL, UJF, CNRS                    *
*                                                                             *
* This library 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.                                             *
*                                                                             *
* This library 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 this library; if not, write to the Free Software Foundation,     *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.          *
*******************************************************************************
*                               SOFA :: Modules                               *
*                                                                             *
* Authors: The SOFA Team and external contributors (see Authors.txt)          *
*                                                                             *
* Contact information: contact@sofa-framework.org                             *
******************************************************************************/
#ifndef SOFA_COMPONENT_TOPOLOGY_MULTIRESSPARSEGRIDTOPOLOGY_H
#define SOFA_COMPONENT_TOPOLOGY_MULTIRESSPARSEGRIDTOPOLOGY_H

#include <sofa/component/topology/GridTopology.h>
#include <sofa/defaulttype/Vec.h>
#include <sofa/helper/vector.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <fstream>
#include <iostream>
#include <map>
using std::cout;
using std::cerr;
using std::endl;
namespace sofa
{

namespace component
{

namespace topology
{

using namespace sofa::defaulttype;
using helper::vector;

class MultiResSparseGridTopology : public core::componentmodel::topology::Topology
{
        int nbPoints;
public:


        class SparseGrid
        {
        public :
                struct Vertex
                {
                        //Vector3 vertexPosition;
                        int index;
                        /*            Vertex(float x=0, float y=0, float z=0)
                                    {
                                        //position = new float(3);
                                        vertexPosition[0]=x;
                                        vertexPosition[1]=y;
                                        vertexPosition[2]=z;
                                    };*/
                };

                struct Index3D
                {
                        int i,j,k;
                        Index3D(int a=0,int b=0,int c=0):i(a),j(b),k(c)
                        {}

                        bool operator < (const Index3D& ind ) const
                        {
                                return ( i<ind.i || i==ind.i && j<ind.j || i==ind.i && j==ind.j && k<ind.k );
                        }
                };
                struct Voxel
                {
                        int vertices[8];
                        float density;
                        Voxel(int v1=0,int v2=0,int v3=0,int v4=0,int v5=0,int v6=0,int v7=0,int v8=0,float d=0.0)
                        {
                                vertices[0]=v1;
                                vertices[1]=v2;
                                vertices[2]=v3;
                                vertices[3]=v4;
                                vertices[4]=v5;
                                vertices[5]=v6;
                                vertices[6]=v7;
                                vertices[7]=v8;
                                density = d;
                        }
                };

        protected :
                int FIN_DE_LISTE;
                float scale;
                vector<Vector3> vertices;
                vector<Index3D> surfaceSparseGrid;
                int numIndices;
                vector<int> indices;
                int numSurfaceIndices;
                vector<int> surfaceIndices;
                float* voxelsDensity;
                float dimVoxX, dimVoxY, dimVoxZ;
                int dimX,dimY,dimZ;

                typedef std::map<Index3D, Vertex> VertexMap;
                typedef std::map<Index3D, Voxel> VoxelMap;
                VertexMap vertexMap;
                VoxelMap voxelsMap;

        public:

                SparseGrid(void);//sans rien
                SparseGrid(int);// avec un indice de fin de liste
                SparseGrid(float); // avec uune echelle
                ~SparseGrid(void);
                void initFromPNG( char* fileName,int color,int filesNo );
                void initFromVOX( char* fileName,int color);
                unsigned getNumSparseGrid() const
                {
                        return voxelsMap.size();
                }
                unsigned getNumVertices() const
                {
                        return vertexMap.size();
                }
                unsigned getNumFaceIndices() const
                {
                        return numIndices;
                }
                unsigned getNumSurfaceIndices() const
                {
                        return numSurfaceIndices;
                }
                vector< Vector3>& getVertices()
                {
                        return vertices;
                }
                const vector<Vector3>& getVertices() const
                {
                        return vertices;
                }
                vector<int>& getFaceIndices()
                {
                        return indices;
                }
                std::map<Index3D,Voxel>& getSparseGridMap()
                {
                        return voxelsMap;
                }
                const std::map<Index3D,Voxel>& getSparseGridMap() const
                {
                        return voxelsMap;
                }
                std::map<Index3D,Voxel>::iterator getVoxelsMapBegin()
                {
                        return voxelsMap.begin();
                }
                std::map<Index3D,Voxel>::iterator getVoxelsMapEnd()
                {
                        return voxelsMap.end();
                }
                std::map<Index3D,Vertex>& getVertexMap()
                {
                        return vertexMap;
                }
                const std::map<Index3D,Vertex>& getVertexMap() const
                {
                        return vertexMap;
                }
                std::map<Index3D,Vertex>::iterator getVertexMapBegin()
                {
                        return vertexMap.begin();
                }
                std::map<Index3D,Vertex>::iterator  const getVertexMapEnd()
                {
                        return vertexMap.end();
                }

                float* getSparseGridDensity()
                {
                        return voxelsDensity;
                }
                vector<int>& getSurfaceIndices()
                {
                        return surfaceIndices;
                }
                int pasResolution(SparseGrid vg);
                float getDimVoxX()
                {
                        return dimVoxX;
                }
                float getDimVoxY()
                {
                        return dimVoxY;
                }
                float getDimVoxZ()
                {
                        return dimVoxZ;
                }
                int getDimX() const
                {
                        return dimX;
                }
                int getDimY() const
                {
                        return dimY;
                }
                int getDimZ() const
                {
                        return dimZ;
                }
                float getDensity(int i,int j,int k);
                void afficherVertices();
                void afficherSparseGridMap();
                void afficherVertexMap();
                void afficherIndices();


        protected:
                int readFilePNG( char* fileName,int color,int filesNo );
                int readFileVOX( char* fileName,int color);
                int setPixels( const char *FileName, int color,float plane);
                void setVertexMap();
                void setIndicesMap();
                void setSurfaceSparseGrid();
                void insertVoxel(int i,int j,int k,float d);
                void buildFromSparseGridMap(int allPixels);
                void setDensity();
                void setDimX(int x)
                {
                        dimX = x;
                }
                void setDimY(int y)
                {
                        dimY = y;
                }
                void setDimZ(int z)
                {
                        dimZ = z;
                }
                void setDimVoxX(float x)
                {
                        dimVoxX = x;
                }
                void setDimVoxY(float y)
                {
                        dimVoxY = y;
                }
                void setDimVoxZ(float z)
                {
                        dimVoxZ = z;
                }
        };


        typedef GridTopology::Cube Cube;
        MultiResSparseGridTopology();
        MultiResSparseGridTopology(const char* filevoxel, int resol,float scale);

        vector <SparseGrid> vectorSparseGrid;

        int resolution;

        int dimx,dimy,dimz,px,py,pz;

        SReal getPX(int i) const ;
        SReal getPY(int i) const ;
        SReal getPZ(int i) const ;

        Vector3 getPoint(int i) const ;
        //Vector3 getPoint(int ,int ,int );

        bool hasPos() const;
        int getNbVoxels() const;
        int getNbPoints() const;
        int point(int x, int y, int z);
        GridTopology::Cube getCube (int i);
        int findCube(const Vector3& pos, SReal& fx, SReal &fy, SReal &fz) const;
        int findNearestCube(const Vector3& pos, SReal& fx, SReal &fy, SReal &fz) const;
        void setP0(const Vector3& val)
        {
                p0 = val;
        }
        void setDx(const Vector3& val)
        {
                dx = val;
                inv_dx2 = 1/(dx*dx);
        }
        void setDy(const Vector3& val)
        {
                dy = val;
                inv_dy2 = 1/(dy*dy);
        }
        void setDz(const Vector3& val)
        {
                dz = val;
                inv_dz2 = 1/(dz*dz);
        }
        const Vector3& getP0() const
        {
                return p0;
        }
        const Vector3& getDx() const
        {
                return dx;
        }
        const Vector3& getDy() const
        {
                return dy;
        }
        const Vector3& getDz() const
        {
                return dz;
        }

protected:
        Vector3 p0;
        Vector3 dx,dy,dz;
        SReal inv_dx2, inv_dy2, inv_dz2;

};

} // namespace topology

} // namespace component

} // namespace sofa

#endif