PMBezierCurve.h

//========================================================================================
// 
// $File$
// 
// Owner: jargast
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __PMBezierCurve__
#define __PMBezierCurve__

#include "PMPoint.h"

class IPMStream;
class PMRect;
class PMBezierCurve;
class PMMatrix;
class PMPathPoint;

typedef K2Vector<PMBezierCurve> PMBezierCurveList;


class PMBezierCurve
{
public: 
 typedef base_type data_type;
 PMBezierCurve();
 
 PMBezierCurve (const PMPoint& p0, const PMPoint& p1, const PMPoint& p2, const PMPoint& p3);
 
 PMBezierCurve (const PMPoint& p0p1, const PMPoint& p2p3);
 
 PMBezierCurve (const PMPoint& p);
 
 // Quick accesors
 const PMPoint& GetP0() const { return fP0; }
 const PMPoint& GetP1() const { return fP1; }
 const PMPoint& GetP2() const { return fP2; }
 const PMPoint& GetP3() const { return fP3; }
 
 const PMPoint& GetNthPoint (int32 n) const;
 
 // Quick ways to set the points. 
 void SetP0 (const PMPoint& p) { fP0 = p; }
 void SetP1 (const PMPoint& p) { fP1 = p; }
 void SetP2 (const PMPoint& p) { fP2 = p; }
 void SetP3 (const PMPoint& p) { fP3 = p; }
 
 // Use index
 void SetNthPoint (int32 n, const PMPoint& p);
 
 PMRect GetCtrlPtBounds() const;
 
 PMRect GetPathBounds() const;
 
 void TransformPoints (const PMMatrix& xForm);
 
 bool16 FindParameter (const PMPoint& p, const PMReal& hitzone, PMReal* retU) const;
 
 PMPoint Evaluate (const PMReal& u) const;
 
 PMPoint EvaluateSlope (const PMReal& u) const;
 
 void EvaluatePointAndSlope (const PMReal& u, PMPoint* outP, PMPoint* outSlope) const;
 
 int32 GetStepSize (const PMReal& flatness) const;
 
 void FlattenCurve (PMPoint* pts, int32 stepSize);
 
 int32 FindMinMax (PMReal* uResult) const;

 void SubDivide (const PMReal& u, PMBezierCurve* bezLeft, PMBezierCurve* bezRight) const;
 
 void SubSegment (const PMReal& begU, const PMReal& endU, PMBezierCurve* subSegment) const;
 
 void DivideIntoPathPoints
 (
 const PMReal u,
 PMPathPoint* ptBefore,
 PMPathPoint* ptAt,
 PMPathPoint* ptAfter
 );

 // persistance
 void ReadWrite (IPMStream* iPMStream);

 // Math Operators
 friend PMBezierCurve operator *(const PMReal& c, const PMBezierCurve& pt);
 friend PMBezierCurve operator /(const PMBezierCurve& numer, const PMReal& denom);

 // Assignment Operators
 void operator *=(const PMReal& a);
 void operator /=(const PMReal& a);
 PMBezierCurve& operator=(const PMBezierCurve& rhs);

 // Comparison Operators
 friend bool16 operator ==(const PMBezierCurve& a, const PMBezierCurve& b);
 friend bool16 operator !=(const PMBezierCurve& a, const PMBezierCurve& b);

 // Utility methods
 
 static void Reduce (PMPoint* P, const PMPoint& A, const PMPoint& B, const PMReal& u);

public:
 PMReal PrivateFindParameter 
 (
 const PMReal& startP, 
 const PMReal& endP, 
 const PMReal& coord, 
 bool16 isXCoord, 
 bool16* oneCrossing
 ) const ;

 PMReal FindParameterByAverage
 (
 PMReal t0,
 PMReal t1,
 const PMPoint& p
 ) const ;

 bool16 HitTest( const PMRect& r ) const ;

 int16 AdjustToPassThroughPoint( const PMPoint& p, const PMReal& t ) ;
 
 enum { 
 kBezierAdjustReflectedp1 = 1, 
 kBezierAdjustReflectedp2 = 2, 
 kBezierAdjustRotatedp1 = 4, 
 kBezierAdjustRotatedp2 = 8 
 } ;

 bool16 PreAdjustCurve(
 const PMReal& t, // input
 PMPoint& t0, PMPoint& t3, // output
 PMPoint& c, // output
 PMPoint& d, PMPoint& e ) const ; // output
 int16 DoAdjustCurve(
 const PMPoint& m,
 const PMReal& t,
 const PMPoint& t0, const PMPoint& t3,
 const PMPoint& c, const PMPoint& d, const PMPoint& e,
 bool16 parallel ) ;

protected:
 PMPoint fP0;
 PMPoint fP1;
 PMPoint fP2;
 PMPoint fP3;
};



#endif