PolygonalMesh.h

Go to the documentation of this file.

#ifndef SimTK_SimTKCOMMON_POLYGONAL_MESH_H_
#define SimTK_SimTKCOMMON_POLYGONAL_MESH_H_
 
/* -------------------------------------------------------------------------- *
 *                       Simbody(tm): SimTKcommon                             *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2008-14 Stanford University and the Authors.        *
 * Authors: Peter Eastman                                                     *
 * Contributors: Michael Sherman, Ayman Habib                                 *
 *                                                                            *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may    *
 * not use this file except in compliance with the License. You may obtain a  *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */
 
#include "SimTKcommon/Simmatrix.h"
#include "SimTKcommon/internal/PrivateImplementation.h"
 
namespace SimTK {
 
class PolygonalMesh;
class PolygonalMeshImpl;
 
// We only want the template instantiation to occur once. This symbol is defined
// in the SimTKcommon compilation unit that defines the PolygonalMesh class but 
// should not be defined any other time.
#ifndef SimTK_SIMTKCOMMON_DEFINING_POLYGONALMESH
    extern template class PIMPLHandle<PolygonalMesh, PolygonalMeshImpl, true>;
#endif
 
class SimTK_SimTKCOMMON_EXPORT PolygonalMesh 
:   public PIMPLHandle<PolygonalMesh, PolygonalMeshImpl, true> {
public:
    PolygonalMesh() {}
 
    static PolygonalMesh createSphereMesh(Real  radius, 
                                          int   resolution = 1);
 
    static PolygonalMesh createBrickMesh(const Vec3& halfDims, 
                                         int resolution = 1);
 
    static PolygonalMesh createCylinderMesh(const UnitVec3& axis,
                                            Real            radius, 
                                            Real            halfLength, 
                                            int             resolution=1);
 
    void clear();
 
    int getNumFaces() const;
    int getNumVertices() const;
 
    bool hasNormals() const;
    bool hasNormalsAtVertices() const;
    bool hasNormalsAtFaces() const;
 
    bool hasTextureCoordinates() const;
    bool hasTextureCoordinatesAtFaces() const;
    bool hasTextureCoordinatesAtVertices() const;
 
    const Vec3& getVertexPosition(int vertex) const;
 
    const UnitVec3 getVertexNormal(int faceIndex, int vertexIndex) const;
 
    const UnitVec3& getVertexNormal(int vertex) const;
 
    const Vec2 getVertexTextureCoordinate(int faceIndex,
                                                         int vertexIndex) const;
 
    int getNumVerticesForFace(int face) const;
 
    int getFaceVertex(int face, int vertex) const;
 
    int addVertex(const Vec3& position);
 
    int addNormal(const UnitVec3& normal);
 
    int addTextureCoordinate(const Vec2& textureCoord);
 
    int addFace(const Array_<int>& vertices);
 
    int addFaceWithNormals(const Array_<int>& vertices,
                           const Array_<int>& normalIndices);
 
    void addFaceTextureCoordinates(const Array_<int>& textureIndices);
 
    PolygonalMesh& scaleMesh(Real scale);
 
    PolygonalMesh&  transformMesh(const Transform& X_AM);
 
    void loadFile(const String& pathname);
 
    void loadObjFile(const String& pathname);
 
    void loadObjFile(std::istream& file);
 
    void loadVtpFile(const String& pathname);
 
    void loadStlFile(const String& pathname);
 
   private:
    explicit PolygonalMesh(PolygonalMeshImpl* impl) : HandleBase(impl) {}
    void initializeHandleIfEmpty();
    void enforceMeshConsistency();
    
};
 
} // namespace SimTK
 
#endif // SimTK_SimTKCOMMON_POLYGONAL_MESH_H_