VRS - The Virtual Rendering System

version 3.3

polygonsettool.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2003 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * 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 FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: polygonsettool.h 6506 2008-09-30 13:40:36Z Tassilo_Glander $
// $Date: 2008-09-30 15:40:36 +0200 (Tue, 30 Sep 2008) $
// $Revision: 6506 $
// $State$
// $Author: Tassilo_Glander $
//

#ifndef VRS_POLYGONSETTOOL_H
#define VRS_POLYGONSETTOOL_H

#include <vrs/matrix.h>
#include <vrs/vector.h>

namespace VRS {

class PolygonSet;
class Transform;
template<typename T> class Iterator;
class Bounds;
class Facet;
class Color;

class VRS_CORE_API PolygonSetTool {
public:

        static SO<Facet> removeRedundantVertices(SO<Facet> soFacet, double toleranceDegrees = 0.0);
                
        static SO<PolygonSet> tesselateFacet(SO<Facet> facet, const Vector& forceNormal = Vector::origin);
                
    static void copy(const PolygonSet* source, PolygonSet* dest, bool deepCopy = true);
        
    static PolygonSet* copy(const PolygonSet* poly, bool deepCopy = true);
        

        static PolygonSet* mergePolygonSets(Iterator<SO<PolygonSet> >* polys);
        

    static SO<Iterator<SO<PolygonSet> > > forceMerge(SO<Iterator<SO<PolygonSet> > > meshes, bool indexed, int maxVertices = 65535);

    static SO<PolygonSet> forceTriangleMerge(SO<Iterator<SO<PolygonSet> > > polys, bool indexed);

    static bool canBeMerged(PolygonSet* poly1, PolygonSet* poly2, bool considerEfficiency = true);        
   
    static SO<PolygonSet> convertToIndexedForm(SO<PolygonSet> poly, bool packData = false);
    
    static SO<PolygonSet> convertToTrivialIndexedForm(SO<PolygonSet> poly);

        static SO<PolygonSet> convertToNonIndexedForm(SO<PolygonSet> poly, bool packData = false);
                
    static PolygonSet* invertOrientation(const PolygonSet* poly); 
        
        
    static PolygonSet* extractTriangleMesh(const PolygonSet* mesh, bool removeUnusedVertices = false);
        

        // same length as the vertex iterator. 
    static bool isValid(const PolygonSet* poly);

    static void ValidatePolygonSet(SO<PolygonSet> poly);

    static bool isSimpleTriangleMesh(const PolygonSet* mesh);

    static void computeFaceNormals(PolygonSet* mesh);
        
        static void invertNormals(PolygonSet* mesh);
        

    static void computeVertexNormals(PolygonSet* mesh);
    

        static void computeSmoothingNormals(PolygonSet* mesh,double maxAngle=30.0);     

    static void computeSphericalTexCoords(PolygonSet* mesh, const Vector& center);


    static void computeTangents(PolygonSet* mesh);

    static Vector getTriangleNormal(const Vector& a, const Vector& b, const Vector& c);
        


        
    static void transformPolygonSet(PolygonSet* mesh, const Matrix& matrix);

    static void compress(SO<PolygonSet> poly);

    enum ClipMethod { KEEP_INTERSECTING_TRIANGLES, REMOVE_INTERSECTING_TRIANGLES, 
        CLIP_INTERSECTING_TRIANGLES };
    VRS_SERIALIZABLE_CLASS_ENUM(ClipMethod);
    static SO<PolygonSet> clipMesh(SO<PolygonSet> mesh, Bounds clipBounds, 
        ClipMethod method = PolygonSetTool::CLIP_INTERSECTING_TRIANGLES);

    static SO<PolygonSet> clipMesh(
        SO<PolygonSet> poly, 
        const Vector& onPlane, 
        const Vector& planeNormal,
        PolygonSetTool::ClipMethod method = PolygonSetTool::CLIP_INTERSECTING_TRIANGLES
    );

    static PolygonSet* createSphere(Vector midpoint, double radius, UINT subdivisions = 4);
        

    static PolygonSet* extrudeEdges(const Facet* polygon, double height, bool stripes = false, Vector direction = Vector(0.0, 0.0, 0.0));

    static PolygonSet* splitTriangles(const PolygonSet* poly, double maxEdgeLength); 
        
    static SO<PolygonSet> filterTriangles(
        SO<PolygonSet> poly,
        const Vector& normal,
        double maxAngle,
        bool complement = false
    );
       

    enum EdgeGroup {
        SoftEdge =        1<<0, // edge with 2 adjacent faces forming an angle smaller than a specified threshold
        HardEdge =        1<<1, // edge with 2 adjacent faces that is no hard edge
        BoundaryEdge =    1<<2, // edge with 1 adjacent face
        NonManifoldEdge = 1<<3  // edge with more than 2 adjacent faces        
    };

    static SO<PolygonSet> extractEdges(const PolygonSet* poly, double angle, EdgeGroup group = PolygonSetTool::HardEdge);
        
        static PolygonSet* computeNormals(const PolygonSet* poly, double length, Color color);

    static void unifySimilarVertices(SO<PolygonSet> poly, double minDistance);
  
    static VRS::SO<VRS::Iterator<VRS::Vector> > unifySimilarVertices(
        VRS::Iterator<VRS::Vector> *vertices,
        double minDistance);

    
    static VRS::SO<VRS::Iterator<VRS::SO<VRS::Iterator<VRS::Vector> > > > unifySimilarVerticesInMultipleItems(
        VRS::SO<VRS::Iterator<VRS::SO<VRS::Iterator<VRS::Vector> > > > items,
        double minDistance);


    static SO<PolygonSet> extrudeSurface(
        SO<PolygonSet> surface, 
        const Vector& shift, 
        bool createTopSurface = true,
        bool createBottomSurface = true
    );

    static SO<Iterator<SO<PolygonSet> > > splitPolygonSet(
        SO<PolygonSet> poly,
        unsigned int maxElements = 10000,
        bool allowSplitX = true,
        bool allowSplitY = true,
        bool allowSplitZ = true
    );
};

inline Vector PolygonSetTool::getTriangleNormal(const Vector& a, const Vector& b, const Vector& c) {
        return ((c-a) * (b-a)).normalized();
}

} // namespace VRS

#endif // VRS_POLYGONSETTOOL_H

---

Generated on Wed May 23 06:00:13 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact