FMContour2D.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 __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();
 
        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 = 0, OdIntPtr* pMetadata = 0, OdUInt32* puRawFlags = 0 ) 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 appendSegment( const Segment2D& rSeg,
            bool bShiftToHit = false );
 
        Result appendContour( const Contour2D& rCont,
            bool bCloseGap = false, double dMaxGap = 1e99 );
 
        Result removeVertexAt( OdUInt32 iIndex );
 
        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;
 
        Result getStartPoint( OdGePoint2d& ptPoint ) const;
 
        Result getEndPoint( OdGePoint2d & ptPoint ) const;
 
        double length() 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 getParamAtPoint(const OdGePoint2d& ptPoint, double& dParam) const;
        //Result getDistAtPoint (const OdGePoint2d& ptPoint, double& dDist) 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;
 
        double area() const;
 
        double signedArea() const;
 
        bool isConvex() const;
 
        bool isCCW() const;
 
        void makeCCW( bool bCCW = true );
 
        bool isOn( const OdGePoint2d& ptTest, double* pParam = 0,
            const OdGeTol& gTol = FMGeGbl::gTol ) const;
 
        double nearestParam( const OdGePoint2d& ptTest,
            OdGePoint2d* ptNearest = 0 ) const;
 
        bool contains( const OdGePoint2d& ptPoint, bool* pOnBorder = 0,
            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 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);
 
    public:
        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; }
 
    private:
        IContour2D* m_pImpl;
 
    public:
        FMGEOMETRY_API_STATIC static const Contour2D kNull;
};
 
class FMGEOMETRY_API CachedContour2D : public Contour2D
{
    public:
        CachedContour2D( ) 
            : Contour2D( ecicCached )
        { }
    
        CachedContour2D( ContourImplClass eImplClass ) 
            : Contour2D( eImplClass )
        { }
        
        CachedContour2D( const IBulgeSeg2D& rSrcSeg, ContourImplClass eImplClass = ecicCached )
            : Contour2D( rSrcSeg, eImplClass )
        { }
    
        CachedContour2D( const Contour2D & rSrcCont, ContourImplClass eImplClass = ecicCached )
            : Contour2D( rSrcCont, eImplClass )
        { }
 
        inline CachedContour2D& operator = ( const Contour2D& rSrcCont )
        {
            Contour2D::operator=(rSrcCont);
            return *this;
        };
        
        inline CachedContour2D& cloneFrom( const Contour2D& rSrcCont ) 
        {
            Contour2D::cloneFrom(rSrcCont);
            return *this;
        };
        
        inline CachedContour2D& reset( ContourImplClass eImplClass = ecicUnknown )
        {
            Contour2D::reset(eImplClass);
            return *this;
        };
};
 
 
FMGEOMETRY_API void ExtendContourStart(Contour2D& rContour);
FMGEOMETRY_API void ExtendContourEnd(Contour2D& rContour);
 
FMGEOMETRY_API void ExtendContour(Contour2D& rContour);
 
FMGEOMETRY_API bool FindClosestIntToBaseStart(const Contour2D& cBase, const Contour2D& cCutter, Intersection& intClosest);
FMGEOMETRY_API bool FindClosestIntToBaseEnd(const Contour2D& cBase, const Contour2D& cCutter, Intersection& intClosest);
 
FMGEOMETRY_API Intersection FindIntClosestToPt(const OdGePoint2d& ptBase, const std::vector< Intersection >& vecPoints);
FMGEOMETRY_API bool IsIntersectionCloserToPt(const OdGePoint2d& ptBase, const Intersection& intCurrent, const Intersection& intToCheck);
 
}; // namespace AECContours
 
#endif  //__FMCONTOUR2D_H__