FMMdlEdge.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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-2024 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;
    friend class CFxFacetModelerHelper; //FELIX_CHANGE
    //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__