FMContour2D.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 __FMCONTOUR2D_H__
#define __FMCONTOUR2D_H__
 
#include "FMGeometry.h"
#include "FMContoursBase.h"
#include "FMSegment2D.h"
 
namespace FacetModeler
{
 
  class IContour2D;
  class IBulgeSeg2D;
  class Profile2D;
 
  class ODRX_ABSTRACT Contour2DTraversingReactor {
  public:
    virtual bool onLineSeg(int nSegment) = 0;
 
    virtual bool onArcSeg(int nSegment, DeviationParams** ppDev) = 0;
 
    virtual bool onArcStartPoint(int nSegment, const OdGePoint2d& pt, int nTotalPts) = 0;
 
    virtual bool onArcPoint(int nSegment, const OdGePoint2d& pt) = 0;
 
    virtual bool onArcEndPoint(int nSegment, const OdGePoint2d& pt) = 0;
 
    virtual bool onCoincidentSeg(int nSegment) = 0;
  };
 
  class FMGEOMETRY_API Contour2D
  {
  public:
    Contour2D();
 
    explicit Contour2D(ContourImplClass eImplClass);
 
    explicit Contour2D(const IBulgeSeg2D& rSrcSeg,
      ContourImplClass eImplClass = ecicSimple);
 
    Contour2D(const Contour2D& rSrcCont,
      ContourImplClass eImplClass = ecicSimple);
 
    explicit Contour2D(const IContour2D& rSrcCont,
      ContourImplClass eImplClass = ecicSimple);
 
    Contour2D(const OdGeExtents2d& ext);
 
    Contour2D& operator = (const Contour2D& rSrcCont);
 
    Contour2D& operator = (const IContour2D& rSrcCont);
 
    Contour2D& cloneFrom(const IContour2D& rSrcCont);
 
    Contour2D& reset(ContourImplClass eImplClass = ecicUnknown);
 
    ContourImplClass implClass() const;
 
    void swap(Contour2D& rAnother);
 
    bool isClosed() const;
 
    bool isEndsEqual(const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    void setClosed(bool bClosed = true);
 
    bool isEmpty() const;
 
    OdUInt32 numVerts() const;
 
    OdUInt32 numSegments() const;
 
    bool hasArcs() const;
 
    SegmentType segmentType(OdUInt32 iIndex) const;
 
    Result getSegmentAt(OdUInt32 iIndex,
      Segment2D& rSegment) const;
 
    Result getSegmentAt(OdUInt32 iIndex,
      OdGePoint2d& ptStart,
      OdGePoint2d& ptEnd,
      double& dBulge) const;
 
    Result getLineSegAt(OdUInt32 iIndex,
      OdGeLineSeg2d& geLine) const;
 
    Result getArcSegAt(OdUInt32 iIndex,
      OdGeCircArc2d& geArc) const;
 
    Result getPointAt(OdUInt32 iIndex,
      OdGePoint2d& ptPoint) const;
 
    Result getBulgeAt(OdUInt32 iIndex,
      double& dBulge) const;
 
    Result getVertexAt(OdUInt32 iIndex,
      OdGePoint2d* pPoint, double* pBulge = NULL,
      OdIntPtr* pMetadata = NULL, OdUInt32* puRawFlags = NULL) const;
 
    Result getInternalAngleAt(OdUInt32 iIndex, double & dAngle) const;
 
    Result setPointAt(OdUInt32 iIndex,
      const OdGePoint2d& ptPoint);
 
    Result setBulgeAt(OdUInt32 iIndex,
      double dBulge);
 
    Result setVertexAt(OdUInt32 iIndex,
      const OdGePoint2d& ptPoint, double dBulge);
 
    void reserveVertices(OdUInt32 iReservedSize);
 
    OdIntPtr metadataAt(OdUInt32 iIndex) const;
 
    Result setMetadataAt(OdUInt32 iIndex,
      OdIntPtr iNewData);
 
    Result setAllMetadata(OdIntPtr iNewData,
      OdIntPtr iBitsToModify = (OdIntPtr)-1);
 
    bool isHiddenAt(OdUInt32 iIndex) const;
 
    Result setHiddenAt(OdUInt32 iIndex,
      bool bHidden = true);
 
    FaceOrientation orientationAt(OdUInt32 iIndex) const;
 
    Result setOrientationAt(OdUInt32 iIndex,
      FaceOrientation eOrientation);
 
    bool threatAsSmoothCurveAt(OdUInt32 iIndex) const;
 
    void setThreatAsSmoothCurveAt(OdUInt32 iIndex, bool bSmooth);
 
    bool isExplodedArcAt(OdUInt32 iIndex) const;
 
    Result setExplodedArcAt(OdUInt32 iIndex,
      bool bExplodedArc = true);
 
    OdUInt32 rawFlagsAt(OdUInt32 iIndex) const;
 
    Result setRawFlagsAt(OdUInt32 iIndex, OdUInt32 iRawFlags);
 
    Result addVertexAt(OdUInt32 iIndex,
      const OdGePoint2d& ptStart, double dBulge = 0.0,
      OdIntPtr uMetadata = 0, OdUInt32 uRawFlags = 0);
 
    Result appendVertex(const OdGePoint2d& ptStart, double dBulge = 0.0,
      OdIntPtr uMetadata = 0, OdUInt32 uRawFlags = 0);
 
    Result appendVertex(const OdGePoint2d& ptStart,
      const OdGePoint2d& ptMid, OdIntPtr uMetadata = 0, OdUInt32 uRawFlags = 0);
 
    Result appendVertices(const OdGePoint2dArray & vecSource);
 
    Result appendVertices(OdUInt32 size, const OdGePoint2d* vecSource, const double* bulgeSource = NULL);
 
    Result appendSegment(const Segment2D& rSeg,
      bool bShiftToHit = false);
 
    Result appendContour(const Contour2D& rCont,
      bool bCloseGap = false, double dMaxGap = 1e99);
 
    Result removeVertexAt(OdUInt32 iIndex);
 
    Result getStartPoint(OdGePoint2d& ptPoint) const;
 
    Result getEndPoint(OdGePoint2d & ptPoint) const;
 
    Result getTangent(double dParam,
      OdGeVector2d& vTangent) const;
 
    Result getTangentAtDist(double dDist,
      OdGeVector2d& vTangent) const;
 
    Result getPoint(double dParam,
      OdGePoint2d& ptPoint) const;
 
    Result getPointAtDist(double dDist,
      OdGePoint2d& ptPoint) const;
 
    Result getDistAtParam(double dParam,
      double& dDist) const;
 
    Result getParamAtDist(double dDist,
      double& dParam) const;
 
    Result getNormalizedParam(double& dParam) const;
 
    Result getNormalizedDist(double& dDist) const;
 
    bool areEqualParams(double dParam1,
      double dParam2, double dParamTol = 1e-10) const;
 
    bool areEqualDists(double dDist1,
      double dDist2, double dTol = 1e-6/*FMGeGbl::gTol.equalPoint()*/) const;
 
    Result addExtents(OdGeExtents2d& extExtents) const;
 
    inline double startParam() const { return 0.0; };
 
    double endParam() const;
 
    // Returns true and a period value, if the contour is closed
    // Returns false otherwise
    //bool getPeriodParam( double & dPeriod ) const;
 
    double length() const;
 
    double area() const;
 
    double signedArea() const;
 
    bool isConvex() const;
 
    bool isCCW() const;
 
    void makeCCW(bool bCCW = true);
 
    bool isOn(const OdGePoint2d& ptTest, double* pParam = NULL,
      const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    double nearestParam(const OdGePoint2d& ptTest,
      OdGePoint2d* ptNearest = NULL) const;
 
    bool contains(const OdGePoint2d& ptPoint, bool* pOnBorder = NULL,
      const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    bool isSelfIntersecting(const OdGeTol& gTol = FMGeGbl::gTol, bool bExcludeTouch = false) const;
 
    bool isValidRegion(const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    bool isInsideContour(const Contour2D& c2dOuter,
      bool fAllowBordersTouch = false,
      const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    OdUInt32 intersect(const Segment2D& rSegB,
      std::vector< Intersection >& vecPoints,
      const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    OdUInt32 intersect(const Contour2D& rContB,
      std::vector< Intersection >& vecPoints,
      const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    OdUInt32 intersectLine(const OdGeLine2d& rLine,
      std::vector< Intersection >& vecPoints,
      const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    Result transformBy(const OdGeMatrix2d& mMatrix,
      const DeviationParams& devDeviation = FMGeGbl::gDefDev);
 
    void reverse();
 
    void deleteCoincident(const OdGeTol& gTol = FMGeGbl::gTol);
 
    void mergeSegments(int iMergeFlags = 0, const OdGeTol & gTol = FMGeGbl::gTol);
 
    Result explode(const DeviationParams& devDeviation = FMGeGbl::gDefDev, OdIntPtr uArcMetadata = 0);
 
    Result explodeTo(Contour2D& rDestCont,
      const DeviationParams& devDeviation = FMGeGbl::gDefDev, OdIntPtr uArcMetadata = 0) const;
 
    OdUInt32 createVertexAt(double dParam,
      const OdGeTol& gTol = FMGeGbl::gTol);
 
    OdUInt32 createVertexAtDist(double dDist,
      const OdGeTol & gTol = FMGeGbl::gTol);
 
    Result createVerticesAt(const std::vector<double> & vecParams,
      const OdGeTol& gTol = FMGeGbl::gTol);
 
    Result createVerticesAt(OdUInt32 size, const double* vecParams,
      const OdGeTol& gTol = FMGeGbl::gTol);
 
    Result getSubContour(double dStartParam, double dEndParam,
      Contour2D & rSubContour, const OdGeTol & gTol = FMGeGbl::gTol) const;
 
    Result getOffsetProfile(double dOffset, Profile2D& rResult,
      FilletType eFilletType = eftExtend,
      const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    Result getProfileByOffsets(const std::vector< double >& adOffset,
      Profile2D& rResult,
      const OdGeTol& gTol = FMGeGbl::gTol) const;
 
    bool traverse(Contour2DTraversingReactor& reactor) const;
 
    void getGeomExtens(OdGeExtents2d& extens);
 
    static Contour2D createCircle(const OdGePoint2d &center, double radius);
 
    static Contour2D createSquare(const OdGePoint2d &center, double side);
 
    FMGEOMETRY_API_STATIC static const Contour2D kNull;
 
    ~Contour2D();
 
  public:
    //DOM-IGNORE-BEGIN
    inline operator const IContour2D& () const { return *m_pImpl; }
 
    inline operator IContour2D& () { return *m_pImpl; }
 
    inline const IContour2D & impl() const { return *m_pImpl; }
 
    inline IContour2D & impl() { return *m_pImpl; }
    //DOM-IGNORE-END
  private:
    IContour2D* m_pImpl; // Pointer to the implementation object.
  };
 
};
 
#endif  //__FMCONTOUR2D_H__