FMMdlFace.h

Go to the documentation of this file.

// Copyright (C) 2002-2015, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2015 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef __FMMDL_FACE_H__
#define __FMMDL_FACE_H__
 
#include "Modeler/FMMdlEntity.h"
#include "FMProfile3D.h"
 
namespace FacetModeler
{
 
const OdUInt32 VFF = FLAG(0);
const OdUInt32 OFF = FLAG(1);
const OdUInt32 SKIP_HATCH = FLAG(18);
 
struct Vertex2Surface;
class Surface;
 
class FMGEOMETRY_API Face : public Entity
{
    public:
        Face* next() const;
 
        Face* prev() const;
 
        const OdGePlane& plane() const;
 
        OdGeVector3d normal() const;
 
        bool isConvex() const;
 
        bool hasHoles() const;
 
        OdUInt32 loopCount() const;
 
        void setLoopCount( OdUInt32 n );
 
        OdUInt32 loopEdgeCount( OdUInt32 iLoopIndex = 0 ) const;
 
        Edge* edge( OdUInt32 nLoop = 0 ) const;
 
        Edge* addEdge( OdUInt32 nLoop, FacetModeler::Vertex* pVertex, bool bInverseOrder = false );
 
        OdUInt32 findLoop( const Edge* pEdge ) const;
 
        double area() const;
 
        void deletePlane() const;
 
        void clearVertexTags();
 
        void clearEdgeTags();
 
        void negate();
 
        void profile( Profile3D& rResult, const OdGePlane* pPlane = 0, bool bIncludeHoles = true) const;
 
        void profile( const OdGePlane& plane, Profile2D& result, bool bIncludeHoles = true, OdArray<const Edge*>* pSourceEdges = NULL ) const;
 
        void profileOuter( Profile3D& rResult, const OdGePlane* pPlane = 0 ) const;
 
        FaceOrientation orientation() const;
 
        void setOrientation( FaceOrientation eOrientation );
 
        bool intersectLine( const OdGeLinearEnt3d& gLine, OdGePoint3d* pptResult = 0, bool* pbCoplanar = 0 ) const;
 
        Surface* surface( ) const { return m_pSurface; }
 
        OdUInt32 color() const { return m_iColor; }
 
        void setColor ( OdUInt32 color ) { m_iColor = color; }
 
        void debugValidate( bool bValidateEdgePartners = false ) const;
 
        void nullLoopEdgesRefs();
 
        struct EdgeLoop
        {
          EdgeLoop()
          {
            m_pFace = 0;
            m_pFirstEdge = 0;
            m_pNextLoop = 0;
          }
          Face* m_pFace;
          Edge* m_pFirstEdge;
          EdgeLoop* m_pNextLoop;
 
          void zero()
          {
            m_pNextLoop = NULL;
            m_pFirstEdge = NULL;
            m_pFace = NULL;
          }
        };
 
        EdgeLoop* loop( OdUInt32 nLoop ) const;
 
        // all code below is secret and opened for testing purposes. DO NOT USE DIRECT ACCESS TO THESE VARIABLES!
    //protected:
 
        Face();
        ~Face();
 
    
 
        Face(const Face&);
        Face& operator=(const Face&);
 
    //private:
        Face* clone( Body& to ) const;
        void clear();
        void evaluatePlane() const;
 
        
 
        EdgeLoop* insertLoop( OdUInt32 nIndex, Edge* pFirstEdge = 0 );
 
        
 
        // Previous face.
        Face* m_pPrev;
 
        // Next face.
        Face* m_pNext;
 
        // First loop.
        EdgeLoop m_Loops;
 
        // Cached face plane.
        mutable OdGePlane* m_Plane;
 
        // Surface
        Surface* m_pSurface;
 
        // Color
        OdUInt32 m_iColor;
 
        friend class Body;
        friend class BodyInternalConsistencyRestorer;
        friend class BodyImpl;
        friend class Edge;
};
 
inline void Face::profileOuter( Profile3D& result, const OdGePlane* pPlane ) const {
  profile( result, pPlane, false );
}
 
#if 0
// debug finctions for memory leaks checking
class FaceTracker
{
  int m_id;
  std::map<Face*, int> m_faces;
 
public:
  FaceTracker()
  {
    m_id = 0;
  }
 
  ~FaceTracker();
 
  void FaceCreated(Face* pFace)
  {
    if(m_id == 5677163)
    {
      int breakHere = 0;
    }
    m_faces.insert(std::make_pair(pFace, m_id));
    m_id++;
  }
 
  void FaceDeleted(Face* pFace)
  {
    m_faces.erase(pFace);
  }
 
  void CheckFloatingEdges();
};
 
FaceTracker* GetFaceTracker();
#endif
 
}
 
#endif //__FMMDL_FACE_H__