FMMdlEdge.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, 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 Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 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);
  const OdUInt32 VEF = FLAG(1);
 
  class FMGEOMETRY_API Edge : public Entity
  {
  public:
    Edge();
 
    Edge(Vertex* pVertex, Face* pFace, Edge* pPrevEdge, Edge* pPartner);
 
    Face::EdgeLoop* loop() const;
 
    Face* face() const;
 
    Vertex* vertex() const;
 
    Vertex* endVertex() 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 addNext(Edge* pNext);
 
    void set(Edge* pPrev, Edge* pNext);
 
    void setNext(Edge* pNext);
 
    void setPrev(Edge* pPrev);
 
 
    void setPair(Edge* pPair);
 
    void setVertex(Vertex* pVertex);
 
    void setFace(Face* pFace);
 
    void setLoop(Face::EdgeLoop* pLoop);
 
    void setPartner(Edge* pPartner) { m_pNextPartner = pPartner; }
 
    void addPartner(Edge* pPartner);
 
    void removePartner();
 
    OdUInt32 color() const;
 
    void setColor(OdUInt32 iColor);
 
    void zero();
 
    ~Edge();
 
    const OdGePoint2d& mappingCoord(bool& isInitialized) const;
 
    void setMappingCoord(const OdGePoint2d& coord);
 
  private:
 
    void updatePartnerPairs();
 
    void validate(bool bTestPartners = true) const;
 
    void validateLoop(bool bTestPartners = true) const;
 
    static void addEdge(Face::EdgeLoop& loop, Edge* pEdge, bool bInverseOrder);
 
    Edge(const Edge&);
 
 
    Edge& operator=(const Edge& edge);
 
    Vertex* m_pVertex;    // Start vertex.
    Edge* m_pPrevEdge;    // Previous edge.
    Edge* m_pNextEdge;    // Next edge.
    Edge* m_pPairEdge;    // Overlapping edge from neighboring face.
    Edge* m_pNextPartner; // Next edge in a single-linked loop of overlapping edges.
    Face* m_pFace;        // Owner face.
    Face::EdgeLoop* m_pLoop; // Owner loop.
    OdUInt32 m_iColor;    // Edge color.
    OdGePoint2d m_mappingCoord; // Start vertex mapping coordinate.
 
    //DOM-IGNORE-BEGIN
    friend class Face;
    friend class Body;
    friend class BodyImpl;
    //DOM-IGNORE-END
  };
 
  // Inline alias method for the statement: this->next()->vertex();
  inline Vertex* Edge::endVertex() 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 endVertex()->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;
  }
}
 
#endif //__FMMDL_EDGE_H__