hdicorePathArt.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_PATH_ART__
#define __HDI_CORE_PATH_ART__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include <vector>
 
#include "hdicoreArtboardPoint.h"
#include "hdicorePathStyle.h"
 
namespace hdi
{
    namespace core
    {
        class Angle;
        class Art;
        class Bezier;
        class HitData;
        class ArtboardSegPoint;
    
        class PathArt
        {
            public:
                typedef std::vector<ArtboardSegPoint> ArtboardSegPointVector;
                typedef std::vector< std::shared_ptr<HitData> > HitDataVector;
            
                static const int16_t maxSegments = 32000;
 
                enum WindingOrderType
                {
                    WindingUnknown      = 0,
                    Clockwise           = 1,    // determined by positive area
                    CounterClockwise    = 2     // determined by negative area
                };
 
                enum SegPointSelectionState
                {
                    SegPointNotSelected     = 0,
                    SegPointAnchorSelected  = 1 << 0,
                    SegPointInSelected      = 1 << 1,
                    SegPointOutSelected     = 1 << 2,
                    SegPointAllSelected     = (SegPointAnchorSelected | SegPointInSelected | SegPointOutSelected)
                };
 
                enum TrimDirectionType
                {
                    TrimGreaterDirectionOnly    = 1 << 0,
                    TrimLesserDirectionOnly     = 1 << 1,
                    TrimBothDirections          = (TrimGreaterDirectionOnly | TrimLesserDirectionOnly)
                };
                
                enum TrimError
                {
                    NoTrimError                         = 0,
                    HitDataArtMustMatchTrimPathArtError = 10,
                    TrimPathIsClosedError               = 20,
                    TrimPathNeedsAtLeast2PointsError    = 30,
                    InvalidSourcePathForTrimming        = 40
                };
                
                enum ExtendError
                {
                    NoExtendError                           = 0,
                    HitDataArtMustMatchExtendPathArtError   = 110,
                    NoExtendIntersectionsFoundError         = 120,
                    ExtendPathEndSegmentsOnlyError          = 130,
                    ExtendPathIsClosedError                 = 140,
                    ExtendPathNeedsAtLeast2PointsError      = 150,
                    InvalidSourcePathForExtending           = 160
                };
 
                ~PathArt();
                
                bool isGuide() const;
 
                bool closed() const;
 
                void setClosed(const bool closed_);
 
                PathStyle style() const;
 
                void setStyle(const PathStyle& style_);
 
                int16_t segCount() const;
 
                int16_t segPointCount() const;
 
                void setSegCount(const int16_t count_);
 
                void setSegPointCount(const int16_t count_);
 
                std::unique_ptr<hdi::core::Bezier> bezier(const int16_t segIndex_) const;
 
                ArtboardPoint midPoint() const;
 
                void endPoints(ArtboardPoint& start__, ArtboardPoint& end__) const;
 
                bool hasLength() const;
 
                double length() const;
 
                double sublength(const int16_t startSegPt_, const int16_t endSegPt_) const;
 
                double sublength(
                    const int16_t startSeg_,
                    const double startT_,
                    const int16_t endSeg_,
                    const double endT_
                ) const;
 
                double tAtLength(const int16_t segNum_, const double length_) const;
 
                double area() const;
                
                bool hasStraightSegs() const;
 
                bool isStraight() const;
 
                bool isRectangular() const;
 
                bool isCircular() const;
 
                bool isEllipse() const;
 
                ArtboardPoint centroid() const;
 
                bool angle(Angle& angle__) const;
 
                ArtboardSegPointVector segs(const int16_t segIndex_, const int16_t count_) const;
 
                ArtboardSegPointVector segPoints(const int16_t segPtIndex_, const int16_t count_) const;
 
                ArtboardSegPointVector phantomSeg() const;
 
                ArtboardSegPointVector phantomSegPoints() const;
 
                void setSegs(const int16_t segIndex_, const ArtboardSegPointVector& segPts_);
 
                void setSegPoints(const int16_t segPtIndex_, const ArtboardSegPointVector& segPts_);
                
                bool allSegPointsSelected() const;
 
                bool segSelected(const int16_t segIndex_) const;
 
                SegPointSelectionState segPointSelected(const int16_t segPtIndex_) const;
 
                bool setSegPointSelected(const int16_t segPtIndex_, const SegPointSelectionState selected_);
 
                void insertSegs(const int16_t segIndex_, const ArtboardSegPointVector& segPts_);
 
                void insertSegPoints(const int16_t segPtIndex_, const ArtboardSegPointVector& segPts_);
 
                void deleteSegs(const int16_t segIndex_, const int16_t count_);
 
                void deleteSegPoints(const int16_t segPtIndex_, const int16_t count_);
 
                void rotateSegPoints(const int16_t delta_);
 
                void reverseSegs();
 
                WindingOrderType windingOrder() const;
 
                void setWindingOrder(const WindingOrderType winding_);
                
                enum StrokeAlignment
                {
                    UnknownStrokeAlignment  = 0,
                    CenterStrokeAlignment   = 10,
                    InsideStrokeAlignment   = 20,
                    OutsideStrokeAlignment  = 30
                };
            
                void setStrokeAlignment(const StrokeAlignment align_);
 
                void insertSegPointAtT(const int16_t segIndex_, const double t_);
 
                int16_t segPointClosestToPoint(const ArtboardPoint& pt_) const;
 
                bool containsPoint(const ArtboardPoint& pt_) const;
 
                bool simplify(const double flatness_);
 
                HitDataVector getIntersections(const int16_t max_ = 0, const bool guides_ = false) const;
 
                HitDataVector getIntersections(
                    const Art& target_,
                    const int16_t max_ = 0,
                    const bool guides_ = false
                ) const;
 
                TrimError trim(
                    const HitData& center_,
                    const bool delete_,
                    const TrimDirectionType dir_,
                    const bool guides_,
                    Art& split__
                );
 
                ExtendError extend(const HitData& from_, const HitData& to_, const bool guides_);
 
 
            private:
                // Only Art can construct a new PathArt object
                friend class Art;
 
                void* __data;
                
                PathArt();
 
                PathArt(void* const art_);
            
                PathArt(const PathArt&);
            
                PathArt& operator=(const PathArt&);
        };
    }
}
 
hdi::core::PathArt::SegPointSelectionState operator|(
    const hdi::core::PathArt::SegPointSelectionState lhs_,
    const hdi::core::PathArt::SegPointSelectionState rhs_
);
 
hdi::core::PathArt::SegPointSelectionState& operator|=(
    hdi::core::PathArt::SegPointSelectionState& lhs__,
    const hdi::core::PathArt::SegPointSelectionState rhs_
);
 
hdi::core::PathArt::TrimDirectionType operator|(
    const hdi::core::PathArt::TrimDirectionType lhs_,
    const hdi::core::PathArt::TrimDirectionType rhs_
);
 
hdi::core::PathArt::TrimDirectionType& operator|=(
    hdi::core::PathArt::TrimDirectionType& lhs__,
    const hdi::core::PathArt::TrimDirectionType rhs_
);
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_PATH_ART__