BezierCurve.h

Go to the documentation of this file.

//==============================================================================================
//  FILENAME    :   BezierCurve.h
//  AUTHOR      :   Liang Liu
//  CREATION    :   2009-01-04
//  Copyright (C) MicroStrategy Incorporated 2009
//  All Rights Reserved
//==============================================================================================

#ifndef MsiChart_BezierCurve_h
#define MsiChart_BezierCurve_h

#include "Rect2D.h"
#include "Synch/Defines/SmartPtr.h"

struct _cairo;
typedef struct _cairo cairo_t;

namespace MsiChart
{
#ifdef _VE_CE
    class ChartContext;
#endif

    class BezierCurve
    {
    public:
        typedef MSynch::SmartPtr<BezierCurve> Ptr;      
        BezierCurve(const FPoint2D& irP0, float iP1, float iP2, const FPoint2D& irP3, 
            bool iIsVertical, bool iIsXAlwaysIndependent = false);  

        virtual void GetApproximatePolygon(Int32 iLineWidth, std::vector<Point2D>& orPolygon) const;

        void GetApproximatePolyline(std::vector<Point2D>& orPolyline) const;

        void Reverse();

#ifdef _VE_CE

        void MoveToStart(ChartContext* ipContext, bool iTuning = false) const;
        void CurveToEnd(ChartContext* ipContext, bool iTuning = false) const;
        void LineToStart(ChartContext* ipContext, bool iTuning = false) const;
#else

        void MoveToStart(CGPath* ipCGPath, bool iTuning = false) const;
        void CurveToEnd(CGPath* ipCGPath, bool iTuning = false) const;      
        void LineToStart(CGPath* ipCGPath, bool iTuning = false) const;
#endif

        FPoint2D GetStartPoint() const;

        FPoint2D GetEndPoint() const;

        double Evaluate(double iIndependentValue) const;
        double EvaluateDerivative(double iIndependentValue) const;

        double Evaluate2ndDerivative(double iIndependentValue) const;
        
        double Evaluate3rdDerivative() const;

        float GetStartIndependent() const;
        float GetEndIndependent() const;

        void GetMinMax(Int32& orMinY, Int32& orMaxY) const;

        float GetMinX() const;
        float GetMaxX() const;  

        BezierCurve::Ptr Clone() const;

        BezierCurve::Ptr CloneReverseShift(const Point2D& irOffset) const;

        bool IsVertical() const;
        
        bool IsBefore(const Point2D& irOffset, BezierCurve::Ptr iBezierCurvePtr) const;
        void SplitAtTangentPoints(const Point2D& irOffset, std::vector<BezierCurve::Ptr>& orSplitCurves);
        void SplitAtIntersections(BezierCurve::Ptr iBezierCurvePtr, std::vector<BezierCurve::Ptr>& orSplitCurves);

    protected:
        BezierCurve(const FPoint2D& irP0, const FPoint2D& irP1, const FPoint2D& irP2, const FPoint2D& irP3);    

        FPoint2D mP0;
        FPoint2D mP1;
        FPoint2D mP2;
        FPoint2D mP3;
    private:
        BezierCurve::Ptr hSplit(double iTao);           

        void hSolveQuadraticEquation(double iA, double iB, double iC, std::vector<double>& orPositiveRoots) const;
        
        void hSolveCubicEquation(double iA, double iB, double iC, double iD, std::vector<double>& orPositiveRoots) const;

        double hEvaluate(double iS) const;
        
        double hEvaluateDerivative(double iS) const;

        void hGetTangentPositions(double iSlope, std::vector<double>& orPositions) const;

        void hSplitAtPositions(std::vector<double>& iorPositions, std::vector<BezierCurve::Ptr>& orSplitCurves);

        void hGetIntersections(const BezierCurve* ipBezierCurve, std::vector<double>& orIntersections) const;

        BezierCurve::Ptr hGetSubCurve(float iValueX, bool iIsRightPart) const;      

        void hMakeXAscending();

        float hGetTaoFromX(float iValueX) const;

        void hMakeDeltaBezier(BezierCurve::Ptr iBezierCurvePtr);

        void hGetXRoots(std::vector<double>& orXRoots) const;
    
        bool hHasIntersection(const FPoint2D& irStart, const FPoint2D& irEnd) const;

        double hCubicRoot(double iValue) const; 
        
        bool hHaveSameY() const;

        bool mIsVertical;
    };  

    inline FPoint2D BezierCurve::GetStartPoint() const
    {       
        return mIsVertical ? mP0 : FPoint2D(mP0.y, mP0.x);
    }

    inline FPoint2D BezierCurve::GetEndPoint() const
    {
        return mIsVertical ? mP3 : FPoint2D(mP3.y, mP3.x);
    }

    inline bool BezierCurve::IsVertical() const
    {
        return mIsVertical;
    }
    
    inline float BezierCurve::GetMinX() const
    {
        return mP0.x < mP3.x ? mP0.x : mP3.x;
    }

    inline float BezierCurve::GetMaxX() const
    {
        return mP0.x < mP3.x ? mP3.x : mP0.x;
    }
    inline float BezierCurve::hGetTaoFromX(float iValueX) const
    {
        return (iValueX - mP0.x) / (mP3.x - mP0.x);
    }

    inline float BezierCurve::GetStartIndependent() const
    {
        return mP0.x;
    }
    
    inline float BezierCurve::GetEndIndependent() const
    {
        return mP3.x;
    }

    inline bool BezierCurve::hHaveSameY() const
    {
        return mP0.y == mP1.y &&  mP1.y == mP2.y && mP2.y == mP3.y;
    }
}

#endif