FMMdlEdge.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_EDGE_H__
#define __FMMDL_EDGE_H__
 
#include "Modeler/FMMdlVertex.h"
#include "Modeler/FMMdlFace.h"
 
namespace FacetModeler
{
 
const OdUInt32 AEF = FLAG(0); // silhouette edge
const OdUInt32 VEF = FLAG(1); // invisible edge
 
class FMGEOMETRY_API Edge : public Entity
{
    public:
        Edge();
 
        Edge( FacetModeler::Vertex* pVertex,
            FacetModeler::Face* pFace, Edge* pPrevEdge, Edge* pPartner );
 
        FacetModeler::Face::EdgeLoop* loop() const;
 
        FacetModeler::Face* face() const;
 
        FacetModeler::Vertex* vertex() const;
 
        FacetModeler::Vertex* next_vertex() const;
 
        const OdGePoint3d& startPoint() const;
 
        const OdGePoint3d& endPoint() const;
 
        double length() const;
 
        OdGeVector3d vector() const;
 
        Edge* next() const;
 
        Edge* prev() const;
 
        Edge* pair() const;
 
        Edge* nextPartner() const;
 
        bool isPartner( const Edge* pEdge ) const;
 
        bool isManifold() const;
 
        double angleBetweenEdges() const;
 
        double angleBetweenFaces() const;
 
        OdGeVector3d normal() const;
 
        OdGeVector3d direction() const;
 
        OdGeVector3d calculateLoopNormal() const;
 
        void setNext( Edge* pNext );
 
        void setPrev( Edge* pPrev );
 
        void setPair( Edge* pPair );
 
        void setVertex( FacetModeler::Vertex* pVertex );
 
        void setFace( FacetModeler::Face* pFace );
 
        // Sets owner loop. Low level operation!
        void setLoop( FacetModeler::Face::EdgeLoop* pLoop );
 
        void addPartner( Edge* pPartner );
 
        void removePartner();
 
        void updatePartnerPairs();
 
        void debugValidate( bool bTestPartners = true ) const;
 
        void debugValidateLoop( bool bTestPartners = true ) const;
 
        void setColor(OdUInt32 iColor);
 
        OdUInt32 color() const;
 
        void zero();
 
        void setPartner(Edge* pPartner) { m_pNextPartner = pPartner; }
 
        ~Edge();
 
    private:
        static void addEdge( Face::EdgeLoop& loop, Edge* pEdge, bool bInverseOrder );
 
        Edge(const Edge&);
        Edge& operator=(const Edge&);
 
        // Owner face.
        Face* m_pFace;
 
        // Owner loop
        Face::EdgeLoop* m_pLoop;
 
        // Start vertex.
        Vertex* m_pVertex;
 
        // Previous edge.
        Edge* m_pPrevEdge;
 
        // Next edge.
        Edge* m_pNextEdge;
 
        // Overlapping edge from neighboring face.
        Edge* m_pPairEdge;
 
        // Next edge in a single-linked loop of overlapping edges.
        Edge* m_pNextPartner;
 
        // Edge color
        OdUInt32 m_iColor;
 
    friend class Body;
    friend class BodyImpl;
    friend class Face;
    friend class BodyInternalConsistencyRestorer;
};
 
 
// Inline alias method for the statement: this->next()->vertex();
inline Vertex* Edge::next_vertex() const {
  return next()->vertex();
}
 
inline Face::EdgeLoop* Edge::loop() const {
  return m_pLoop;
}
 
inline const OdGePoint3d& Edge::startPoint() const {
  return vertex()->point();
}
 
inline const OdGePoint3d& Edge::endPoint() const {
  return next_vertex()->point();
}
 
inline double Edge::length() const {
  return startPoint().distanceTo( endPoint() );
}
 
inline OdGeVector3d Edge::vector() const {
  return endPoint() - startPoint();
}
 
inline void Edge::setLoop( Face::EdgeLoop* pLoop ) {
  m_pLoop = pLoop;
}
 
 
#if 0
// debug finctions for memory leaks checking
class EdgeTracker
{
  int m_id;
  std::map<Edge*, int> m_edges;
 
public:
  EdgeTracker()
  {
    m_id = 0;
  }
 
  ~EdgeTracker();
 
 
  void EdgeCreated(Edge* pEdge);
 
  void EdgeDeleted(Edge* pEdge)
  {
    m_edges.erase(pEdge);
  }
 
  void GetEdges(std::map<Edge*, int>& edges)
  {
    edges = m_edges;
  }
};
 
EdgeTracker* GetEdgeTracker();
#endif
 
}
 
#endif //__FMMDL_EDGE_H__