mesh.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2018  D Haley
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program 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, see <http://www.gnu.org/licenses/>.
 */
#ifndef ATOMPROBE_MESH_H
#define ATOMPROBE_MESH_H

#include "atomprobe/primitives/point3D.h"
#include "atomprobe/primitives/boundcube.h"
#include "atomprobe/helper/maths/quat.h"

#include <vector>
#include <fstream>
#include <list>

namespace AtomProbe
{
//GMSH load constants
//-----------
//Constants are defined in the GMSH documentation
//under section MSH-ASCII-file-format
//http://geuz.org/gmsh/doc/texinfo/gmsh.html#MSH-ASCII-file-format
const unsigned int ELEM_SINGLE_NODE_POINT=15;
const unsigned int ELEM_TWO_NODE_LINE=1;
const unsigned int ELEM_THREE_NODE_TRIANGLE=2;
const unsigned int ELEM_FOUR_NODE_TETRAHEDRON=4;
//-----------


extern const char *MESH_LOAD_ERRS[];

enum
{
    ELEMENT_TRIANGLE=1,
    ELEMENT_TETRAHEDRON=2,
    ELEMENT_LINE=4,
};

class TETRAHEDRON{ 
    public:
    unsigned int p[4];
    unsigned int physGroup;
};

class TRIANGLE{ 
    public:
    unsigned int p[3];
    unsigned int physGroup;

        //These functions exist due to swig+python
        // if there is another way to do this without access functions
        // then should use that
        inline unsigned int getP(unsigned int offset) { return p[offset];};
        inline void setP(unsigned int offset, unsigned int v) { p[offset]=v;};
    bool isSane(size_t pLimit=(size_t)-1) const;
    bool edgesMismatch(const TRIANGLE &tOther) const;
};

class LINE{
    public:
    unsigned int p[2];
    unsigned int physGroup;
};

class Mesh
{
    private:

        bool sameTriangle(unsigned int ui, unsigned int uj) const;

        static bool sameTriangle(const TRIANGLE &t1, const TRIANGLE &t2);

        bool trianglesCoincident(unsigned int ui, const std::vector<size_t> &v) const;

        //using vertex sharing rules
        //i.e. this will retrieve all vector of all triangles who share edge incidence 
        // for a specified vertex, eg: <|>  vertex only 
        //incident triangles eg : |>*<| , will be excluded.
        //The returned map can be used to perform triangle -> surrounding triangle lookups for shared edge
        // incidence
        void getTriEdgeAdjacencyMap(std::vector<std::list<size_t> > &map) const;

        float normalAngle(size_t triOne,size_t triTwo,bool flip=false ) const;

        void flipTriNormalCoherently(size_t triOne, size_t triTwo); 

        void killOrphanNodes(const std::vector<size_t> &orphans) ;
    public:
        std::vector<Point3D> nodes;

        std::vector<std::string> physGroupNames;
        
        
        //==== Element Storage ====
        std::vector<TETRAHEDRON> tetrahedra;
        //triangles.size() %3 should always == 0.
        std::vector<TRIANGLE> triangles;
        std::vector<LINE> lines;
        std::vector<unsigned long long> points;
        
                //Python helper functions
                // not recommended for C++ use, due to speed
                //----
                void setNode(unsigned int index, Point3D node);
                void resizeNodes(unsigned int newSize);
                Point3D getNodes(unsigned int index);
                //----
                            


        //Returns 0 on OK, nonzero on error.
        unsigned int loadGmshMesh(const char *meshfile, unsigned int &curLine, bool allowBadMeshes=true);
        unsigned int saveGmshMesh(const char *meshfile) const;

        //Return sum of all element sizes (total lines, points, triangles, tetrahedras, etc)
        size_t elementCount() const;

        //Set the triangle mesh from the following pt triplet, each vector being the same size.
        // Function will clear any existing data
        void setTriangleMesh(const std::vector<float> &ptsA, 
                const std::vector<float> &ptsB, const std::vector<float> &ptsC);

        void reassignGroups(unsigned int i);

        void removeDuplicateTris();

        //Merge vertices that lie  within tolerance distance of one another into a single vertex.
        // note that this can produced degenerate objects in the mesh, if tolerance is large compared to the smallest element in the mesh
        void mergeDuplicateVertices(float tolerance);

        //Returning true is not a guarantee of anything however.
        bool isSane(bool output=false,std::ostream &outStream=std::cerr) const;

        void getBounds(BoundCube &b) const;

        unsigned int countTriNodes() const;

        void translate();
        void translate(const Point3D &origin);
        
        void scale(const Point3D &origin,float scaleFactor);

        void scale(float scaleFactor);

        void rotate(const Point3D &axis, const Point3D &origin, float angle);

        // triangles must be correctly oriented, and closed
        float getVolume() const;

        void clear();
        
        void getContainedNodes(const BoundCube &b,
                    std::vector<size_t> &nodes) const;

        void getIntersectingPrimitives( std::vector<size_t> &searchNodes,
                    std::vector<size_t> &lines,
                    std::vector<size_t> &triangles,
                    std::vector<size_t> &tetrahedra ) const;

        unsigned int divideMeshSurface(float divisionAngle, unsigned int newPhysGroupStart,
            const std::vector<size_t> &physGroupsToSplit) ;

        void getCurPhysGroups(std::vector<std::pair<unsigned int,size_t> > &curPhys) const;

        void erasePhysGroup(unsigned int group, unsigned int typeMask);

    
        unsigned int numDupVertices(float tolerance) const;

    
        unsigned int numDupTris() const;

        void print(std::ostream &o) const;

        bool isOrientedCoherently()  const;

        void killOrphanNodes();

        void pointsInside(const std::vector<Point3D> &p,
            std::vector<bool> &meshResults, unsigned int &prog) const ;
                void pointsInside(const std::vector<Point3D> &p,
                               std::vector<bool> &meshResults) const;


        size_t getNearestTri(const Point3D &p,float &distance)  const;

        void getTriNormal(size_t tri, Point3D &normal) const;
};

#ifdef DEBUG
//Run unit tests for mesh
bool meshTests();
#endif
}

#endif