/home/kitware/dashboards/avogadro/libavogadro/src/meshgenerator.h

/**********************************************************************
  MeshGenerator - Class to generate meshes from volumetric data

  Copyright (C) 2008-2009 by Marcus D. Hanwell

  This file is part of the Avogadro molecular editor project.
  For more information, see <http://avogadro.openmolecules.net/>

  Avogadro 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.

  Avogadro 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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
 **********************************************************************/

 #ifndef MESHGENERATOR_H
 #define MESHGENERATOR_H

#include <avogadro/global.h>

#include <Eigen/Core>

#include <QThread>

#include <vector>

 namespace Avogadro {

  class Cube;
  class Mesh;

  class A_EXPORT MeshGenerator : public QThread
  {
    Q_OBJECT
  public:
    explicit MeshGenerator(QObject *parent = 0);

    MeshGenerator(const Cube *cube, Mesh *mesh, float iso,
                  bool reverse = false, QObject *parent = 0);

    ~MeshGenerator();

    bool initialize(const Cube *cube, Mesh *mesh, float iso,
                    bool reverse = false);

    void run();

    const Cube * cube() const { return m_cube; }

    Mesh * mesh() const { return m_mesh; }

    void clear();

    int progressMinimum() {return m_progmin;};

    int progressMaximum() {return m_progmax;};

  signals:
    void progressValueChanged(int);

  protected:
    Eigen::Vector3f normal(const Eigen::Vector3f &pos);

    float offset(float val1, float val2);

    unsigned long duplicate(const Eigen::Vector3i &c,
                            const Eigen::Vector3f &pos);

    bool marchingCube(const Eigen::Vector3i &pos);

    float m_iso;           
    bool m_reverseWinding; 
    const Cube *m_cube;    
    Mesh *m_mesh;          
    float m_stepSize;      
    Eigen::Vector3f m_min; 
    Eigen::Vector3i m_dim; 
    std::vector<Eigen::Vector3f> m_vertices, m_normals;
    std::vector<unsigned int> m_indices;
    int m_progmin;
    int m_progmax;

    static const float a2fVertexOffset[8][3];
    static const int   a2iVertexOffset[8][3];
    static const int   a2iEdgeConnection[12][2];
    static const float a2fEdgeDirection[12][3];
    static const int   a2iTetrahedronEdgeConnection[6][2];
    static const int   a2iTetrahedronsInACube[6][4];
    static const long  aiTetrahedronEdgeFlags[16];
    static const int   a2iTetrahedronTriangles[16][7];
    static const long  aiCubeEdgeFlags[256];
    static const int   a2iTriangleConnectionTable[256][16];
  };

 } // End namespace Avogadro

 #endif